The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/x86/include/bus.h

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) KATO Takenori, 1999.
    3  *
    4  * All rights reserved.  Unpublished rights reserved under the copyright
    5  * laws of Japan.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer as
   13  *    the first lines of this file unmodified.
   14  * 2. Redistributions in binary form must reproduce the above copyright
   15  *    notice, this list of conditions and the following disclaimer in the
   16  *    documentation and/or other materials provided with the distribution.
   17  * 3. The name of the author may not be used to endorse or promote products
   18  *    derived from this software without specific prior written permission.
   19  * 
   20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   30  *
   31  * $FreeBSD: releng/10.0/sys/x86/include/bus.h 244193 2012-12-13 21:40:11Z jimharris $
   32  */
   33 
   34 /*      $NetBSD: bus.h,v 1.12 1997/10/01 08:25:15 fvdl Exp $    */
   35 
   36 /*-
   37  * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc.
   38  * All rights reserved.
   39  *
   40  * This code is derived from software contributed to The NetBSD Foundation
   41  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
   42  * NASA Ames Research Center.
   43  *
   44  * Redistribution and use in source and binary forms, with or without
   45  * modification, are permitted provided that the following conditions
   46  * are met:
   47  * 1. Redistributions of source code must retain the above copyright
   48  *    notice, this list of conditions and the following disclaimer.
   49  * 2. Redistributions in binary form must reproduce the above copyright
   50  *    notice, this list of conditions and the following disclaimer in the
   51  *    documentation and/or other materials provided with the distribution.
   52  * 3. All advertising materials mentioning features or use of this software
   53  *    must display the following acknowledgement:
   54  *      This product includes software developed by the NetBSD
   55  *      Foundation, Inc. and its contributors.
   56  * 4. Neither the name of The NetBSD Foundation nor the names of its
   57  *    contributors may be used to endorse or promote products derived
   58  *    from this software without specific prior written permission.
   59  *
   60  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   61  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   62  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   63  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   64  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   65  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   66  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   67  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   68  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   69  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   70  * POSSIBILITY OF SUCH DAMAGE.
   71  */
   72 
   73 /*-
   74  * Copyright (c) 1996 Charles M. Hannum.  All rights reserved.
   75  * Copyright (c) 1996 Christopher G. Demetriou.  All rights reserved.
   76  *
   77  * Redistribution and use in source and binary forms, with or without
   78  * modification, are permitted provided that the following conditions
   79  * are met:
   80  * 1. Redistributions of source code must retain the above copyright
   81  *    notice, this list of conditions and the following disclaimer.
   82  * 2. Redistributions in binary form must reproduce the above copyright
   83  *    notice, this list of conditions and the following disclaimer in the
   84  *    documentation and/or other materials provided with the distribution.
   85  * 3. All advertising materials mentioning features or use of this software
   86  *    must display the following acknowledgement:
   87  *      This product includes software developed by Christopher G. Demetriou
   88  *      for the NetBSD Project.
   89  * 4. The name of the author may not be used to endorse or promote products
   90  *    derived from this software without specific prior written permission
   91  *
   92  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   93  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   94  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   95  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   96  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   97  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   98  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   99  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  100  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  101  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  102  */
  103 
  104 #ifndef _X86_BUS_H_
  105 #define _X86_BUS_H_
  106 
  107 #include <machine/_bus.h>
  108 #include <machine/cpufunc.h>
  109 
  110 #ifndef __GNUCLIKE_ASM
  111 # ifndef lint
  112 #  error "no assembler code for your compiler"
  113 # endif
  114 #endif
  115 
  116 /*
  117  * Values for the x86 bus space tag, not to be used directly by MI code.
  118  */
  119 #define X86_BUS_SPACE_IO        0       /* space is i/o space */
  120 #define X86_BUS_SPACE_MEM       1       /* space is mem space */
  121 
  122 #define BUS_SPACE_MAXSIZE_24BIT 0xFFFFFF
  123 #define BUS_SPACE_MAXSIZE_32BIT 0xFFFFFFFF
  124 #define BUS_SPACE_MAXSIZE       0xFFFFFFFF
  125 #define BUS_SPACE_MAXADDR_24BIT 0xFFFFFF
  126 #define BUS_SPACE_MAXADDR_32BIT 0xFFFFFFFF
  127 #if defined(__amd64__) || defined(PAE)
  128 #define BUS_SPACE_MAXADDR       0xFFFFFFFFFFFFFFFFULL
  129 #else
  130 #define BUS_SPACE_MAXADDR       0xFFFFFFFF
  131 #endif
  132 
  133 #define BUS_SPACE_INVALID_DATA  (~0)
  134 #define BUS_SPACE_UNRESTRICTED  (~0)
  135 
  136 /*
  137  * Map a region of device bus space into CPU virtual address space.
  138  */
  139 
  140 static __inline int bus_space_map(bus_space_tag_t t, bus_addr_t addr,
  141                                   bus_size_t size, int flags,
  142                                   bus_space_handle_t *bshp);
  143 
  144 static __inline int
  145 bus_space_map(bus_space_tag_t t __unused, bus_addr_t addr,
  146               bus_size_t size __unused, int flags __unused,
  147               bus_space_handle_t *bshp)
  148 {
  149 
  150         *bshp = addr;
  151         return (0);
  152 }
  153 
  154 /*
  155  * Unmap a region of device bus space.
  156  */
  157 
  158 static __inline void bus_space_unmap(bus_space_tag_t t, bus_space_handle_t bsh,
  159                                      bus_size_t size);
  160 
  161 static __inline void
  162 bus_space_unmap(bus_space_tag_t t __unused, bus_space_handle_t bsh __unused,
  163                 bus_size_t size __unused)
  164 {
  165 }
  166 
  167 /*
  168  * Get a new handle for a subregion of an already-mapped area of bus space.
  169  */
  170 
  171 static __inline int bus_space_subregion(bus_space_tag_t t,
  172                                         bus_space_handle_t bsh,
  173                                         bus_size_t offset, bus_size_t size,
  174                                         bus_space_handle_t *nbshp);
  175 
  176 static __inline int
  177 bus_space_subregion(bus_space_tag_t t __unused, bus_space_handle_t bsh,
  178                     bus_size_t offset, bus_size_t size __unused,
  179                     bus_space_handle_t *nbshp)
  180 {
  181 
  182         *nbshp = bsh + offset;
  183         return (0);
  184 }
  185 
  186 /*
  187  * Allocate a region of memory that is accessible to devices in bus space.
  188  */
  189 
  190 int     bus_space_alloc(bus_space_tag_t t, bus_addr_t rstart,
  191                         bus_addr_t rend, bus_size_t size, bus_size_t align,
  192                         bus_size_t boundary, int flags, bus_addr_t *addrp,
  193                         bus_space_handle_t *bshp);
  194 
  195 /*
  196  * Free a region of bus space accessible memory.
  197  */
  198 
  199 static __inline void bus_space_free(bus_space_tag_t t, bus_space_handle_t bsh,
  200                                     bus_size_t size);
  201 
  202 static __inline void
  203 bus_space_free(bus_space_tag_t t __unused, bus_space_handle_t bsh __unused,
  204                bus_size_t size __unused)
  205 {
  206 }
  207 
  208 
  209 /*
  210  * Read a 1, 2, 4, or 8 byte quantity from bus space
  211  * described by tag/handle/offset.
  212  */
  213 static __inline u_int8_t bus_space_read_1(bus_space_tag_t tag,
  214                                           bus_space_handle_t handle,
  215                                           bus_size_t offset);
  216 
  217 static __inline u_int16_t bus_space_read_2(bus_space_tag_t tag,
  218                                            bus_space_handle_t handle,
  219                                            bus_size_t offset);
  220 
  221 static __inline u_int32_t bus_space_read_4(bus_space_tag_t tag,
  222                                            bus_space_handle_t handle,
  223                                            bus_size_t offset);
  224 
  225 #ifdef __amd64__
  226 static __inline uint64_t bus_space_read_8(bus_space_tag_t tag,
  227                                           bus_space_handle_t handle,
  228                                           bus_size_t offset);
  229 #endif
  230 
  231 static __inline u_int8_t
  232 bus_space_read_1(bus_space_tag_t tag, bus_space_handle_t handle,
  233                  bus_size_t offset)
  234 {
  235 
  236         if (tag == X86_BUS_SPACE_IO)
  237                 return (inb(handle + offset));
  238         return (*(volatile u_int8_t *)(handle + offset));
  239 }
  240 
  241 static __inline u_int16_t
  242 bus_space_read_2(bus_space_tag_t tag, bus_space_handle_t handle,
  243                  bus_size_t offset)
  244 {
  245 
  246         if (tag == X86_BUS_SPACE_IO)
  247                 return (inw(handle + offset));
  248         return (*(volatile u_int16_t *)(handle + offset));
  249 }
  250 
  251 static __inline u_int32_t
  252 bus_space_read_4(bus_space_tag_t tag, bus_space_handle_t handle,
  253                  bus_size_t offset)
  254 {
  255 
  256         if (tag == X86_BUS_SPACE_IO)
  257                 return (inl(handle + offset));
  258         return (*(volatile u_int32_t *)(handle + offset));
  259 }
  260 
  261 #ifdef __amd64__
  262 static __inline uint64_t
  263 bus_space_read_8(bus_space_tag_t tag, bus_space_handle_t handle,
  264                  bus_size_t offset)
  265 {
  266 
  267         if (tag == X86_BUS_SPACE_IO) /* No 8 byte IO space access on x86 */
  268                 return (BUS_SPACE_INVALID_DATA);
  269         return (*(volatile uint64_t *)(handle + offset));
  270 }
  271 #endif
  272 
  273 /*
  274  * Read `count' 1, 2, 4, or 8 byte quantities from bus space
  275  * described by tag/handle/offset and copy into buffer provided.
  276  */
  277 static __inline void bus_space_read_multi_1(bus_space_tag_t tag,
  278                                             bus_space_handle_t bsh,
  279                                             bus_size_t offset, u_int8_t *addr,
  280                                             size_t count);
  281 
  282 static __inline void bus_space_read_multi_2(bus_space_tag_t tag,
  283                                             bus_space_handle_t bsh,
  284                                             bus_size_t offset, u_int16_t *addr,
  285                                             size_t count);
  286 
  287 static __inline void bus_space_read_multi_4(bus_space_tag_t tag,
  288                                             bus_space_handle_t bsh,
  289                                             bus_size_t offset, u_int32_t *addr,
  290                                             size_t count);
  291 
  292 static __inline void
  293 bus_space_read_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh,
  294                        bus_size_t offset, u_int8_t *addr, size_t count)
  295 {
  296 
  297         if (tag == X86_BUS_SPACE_IO)
  298                 insb(bsh + offset, addr, count);
  299         else {
  300 #ifdef __GNUCLIKE_ASM
  301                 __asm __volatile("                              \n\
  302                         cld                                     \n\
  303                 1:      movb (%2),%%al                          \n\
  304                         stosb                                   \n\
  305                         loop 1b"                                :
  306                     "=D" (addr), "=c" (count)                   :
  307                     "r" (bsh + offset), "" (addr), "1" (count) :
  308                     "%eax", "memory");
  309 #endif
  310         }
  311 }
  312 
  313 static __inline void
  314 bus_space_read_multi_2(bus_space_tag_t tag, bus_space_handle_t bsh,
  315                        bus_size_t offset, u_int16_t *addr, size_t count)
  316 {
  317 
  318         if (tag == X86_BUS_SPACE_IO)
  319                 insw(bsh + offset, addr, count);
  320         else {
  321 #ifdef __GNUCLIKE_ASM
  322                 __asm __volatile("                              \n\
  323                         cld                                     \n\
  324                 1:      movw (%2),%%ax                          \n\
  325                         stosw                                   \n\
  326                         loop 1b"                                :
  327                     "=D" (addr), "=c" (count)                   :
  328                     "r" (bsh + offset), "" (addr), "1" (count) :
  329                     "%eax", "memory");
  330 #endif
  331         }
  332 }
  333 
  334 static __inline void
  335 bus_space_read_multi_4(bus_space_tag_t tag, bus_space_handle_t bsh,
  336                        bus_size_t offset, u_int32_t *addr, size_t count)
  337 {
  338 
  339         if (tag == X86_BUS_SPACE_IO)
  340                 insl(bsh + offset, addr, count);
  341         else {
  342 #ifdef __GNUCLIKE_ASM
  343                 __asm __volatile("                              \n\
  344                         cld                                     \n\
  345                 1:      movl (%2),%%eax                         \n\
  346                         stosl                                   \n\
  347                         loop 1b"                                :
  348                     "=D" (addr), "=c" (count)                   :
  349                     "r" (bsh + offset), "" (addr), "1" (count) :
  350                     "%eax", "memory");
  351 #endif
  352         }
  353 }
  354 
  355 #if 0   /* Cause a link error for bus_space_read_multi_8 */
  356 #define bus_space_read_multi_8  !!! bus_space_read_multi_8 unimplemented !!!
  357 #endif
  358 
  359 /*
  360  * Read `count' 1, 2, 4, or 8 byte quantities from bus space
  361  * described by tag/handle and starting at `offset' and copy into
  362  * buffer provided.
  363  */
  364 static __inline void bus_space_read_region_1(bus_space_tag_t tag,
  365                                              bus_space_handle_t bsh,
  366                                              bus_size_t offset, u_int8_t *addr,
  367                                              size_t count);
  368 
  369 static __inline void bus_space_read_region_2(bus_space_tag_t tag,
  370                                              bus_space_handle_t bsh,
  371                                              bus_size_t offset, u_int16_t *addr,
  372                                              size_t count);
  373 
  374 static __inline void bus_space_read_region_4(bus_space_tag_t tag,
  375                                              bus_space_handle_t bsh,
  376                                              bus_size_t offset, u_int32_t *addr,
  377                                              size_t count);
  378 
  379 
  380 static __inline void
  381 bus_space_read_region_1(bus_space_tag_t tag, bus_space_handle_t bsh,
  382                         bus_size_t offset, u_int8_t *addr, size_t count)
  383 {
  384 
  385         if (tag == X86_BUS_SPACE_IO) {
  386                 int _port_ = bsh + offset;
  387 #ifdef __GNUCLIKE_ASM
  388                 __asm __volatile("                              \n\
  389                         cld                                     \n\
  390                 1:      inb %w2,%%al                            \n\
  391                         stosb                                   \n\
  392                         incl %2                                 \n\
  393                         loop 1b"                                :
  394                     "=D" (addr), "=c" (count), "=d" (_port_)    :
  395                     "" (addr), "1" (count), "2" (_port_)       :
  396                     "%eax", "memory", "cc");
  397 #endif
  398         } else {
  399                 bus_space_handle_t _port_ = bsh + offset;
  400 #ifdef __GNUCLIKE_ASM
  401                 __asm __volatile("                              \n\
  402                         cld                                     \n\
  403                         repne                                   \n\
  404                         movsb"                                  :
  405                     "=D" (addr), "=c" (count), "=S" (_port_)    :
  406                     "" (addr), "1" (count), "2" (_port_)       :
  407                     "memory", "cc");
  408 #endif
  409         }
  410 }
  411 
  412 static __inline void
  413 bus_space_read_region_2(bus_space_tag_t tag, bus_space_handle_t bsh,
  414                         bus_size_t offset, u_int16_t *addr, size_t count)
  415 {
  416 
  417         if (tag == X86_BUS_SPACE_IO) {
  418                 int _port_ = bsh + offset;
  419 #ifdef __GNUCLIKE_ASM
  420                 __asm __volatile("                              \n\
  421                         cld                                     \n\
  422                 1:      inw %w2,%%ax                            \n\
  423                         stosw                                   \n\
  424                         addl $2,%2                              \n\
  425                         loop 1b"                                :
  426                     "=D" (addr), "=c" (count), "=d" (_port_)    :
  427                     "" (addr), "1" (count), "2" (_port_)       :
  428                     "%eax", "memory", "cc");
  429 #endif
  430         } else {
  431                 bus_space_handle_t _port_ = bsh + offset;
  432 #ifdef __GNUCLIKE_ASM
  433                 __asm __volatile("                              \n\
  434                         cld                                     \n\
  435                         repne                                   \n\
  436                         movsw"                                  :
  437                     "=D" (addr), "=c" (count), "=S" (_port_)    :
  438                     "" (addr), "1" (count), "2" (_port_)       :
  439                     "memory", "cc");
  440 #endif
  441         }
  442 }
  443 
  444 static __inline void
  445 bus_space_read_region_4(bus_space_tag_t tag, bus_space_handle_t bsh,
  446                         bus_size_t offset, u_int32_t *addr, size_t count)
  447 {
  448 
  449         if (tag == X86_BUS_SPACE_IO) {
  450                 int _port_ = bsh + offset;
  451 #ifdef __GNUCLIKE_ASM
  452                 __asm __volatile("                              \n\
  453                         cld                                     \n\
  454                 1:      inl %w2,%%eax                           \n\
  455                         stosl                                   \n\
  456                         addl $4,%2                              \n\
  457                         loop 1b"                                :
  458                     "=D" (addr), "=c" (count), "=d" (_port_)    :
  459                     "" (addr), "1" (count), "2" (_port_)       :
  460                     "%eax", "memory", "cc");
  461 #endif
  462         } else {
  463                 bus_space_handle_t _port_ = bsh + offset;
  464 #ifdef __GNUCLIKE_ASM
  465                 __asm __volatile("                              \n\
  466                         cld                                     \n\
  467                         repne                                   \n\
  468                         movsl"                                  :
  469                     "=D" (addr), "=c" (count), "=S" (_port_)    :
  470                     "" (addr), "1" (count), "2" (_port_)       :
  471                     "memory", "cc");
  472 #endif
  473         }
  474 }
  475 
  476 #if 0   /* Cause a link error for bus_space_read_region_8 */
  477 #define bus_space_read_region_8 !!! bus_space_read_region_8 unimplemented !!!
  478 #endif
  479 
  480 /*
  481  * Write the 1, 2, 4, or 8 byte value `value' to bus space
  482  * described by tag/handle/offset.
  483  */
  484 
  485 static __inline void bus_space_write_1(bus_space_tag_t tag,
  486                                        bus_space_handle_t bsh,
  487                                        bus_size_t offset, u_int8_t value);
  488 
  489 static __inline void bus_space_write_2(bus_space_tag_t tag,
  490                                        bus_space_handle_t bsh,
  491                                        bus_size_t offset, u_int16_t value);
  492 
  493 static __inline void bus_space_write_4(bus_space_tag_t tag,
  494                                        bus_space_handle_t bsh,
  495                                        bus_size_t offset, u_int32_t value);
  496 
  497 #ifdef __amd64__
  498 static __inline void bus_space_write_8(bus_space_tag_t tag,
  499                                        bus_space_handle_t bsh,
  500                                        bus_size_t offset, uint64_t value);
  501 #endif
  502 
  503 static __inline void
  504 bus_space_write_1(bus_space_tag_t tag, bus_space_handle_t bsh,
  505                        bus_size_t offset, u_int8_t value)
  506 {
  507 
  508         if (tag == X86_BUS_SPACE_IO)
  509                 outb(bsh + offset, value);
  510         else
  511                 *(volatile u_int8_t *)(bsh + offset) = value;
  512 }
  513 
  514 static __inline void
  515 bus_space_write_2(bus_space_tag_t tag, bus_space_handle_t bsh,
  516                        bus_size_t offset, u_int16_t value)
  517 {
  518 
  519         if (tag == X86_BUS_SPACE_IO)
  520                 outw(bsh + offset, value);
  521         else
  522                 *(volatile u_int16_t *)(bsh + offset) = value;
  523 }
  524 
  525 static __inline void
  526 bus_space_write_4(bus_space_tag_t tag, bus_space_handle_t bsh,
  527                        bus_size_t offset, u_int32_t value)
  528 {
  529 
  530         if (tag == X86_BUS_SPACE_IO)
  531                 outl(bsh + offset, value);
  532         else
  533                 *(volatile u_int32_t *)(bsh + offset) = value;
  534 }
  535 
  536 #ifdef __amd64__
  537 static __inline void
  538 bus_space_write_8(bus_space_tag_t tag, bus_space_handle_t bsh,
  539                   bus_size_t offset, uint64_t value)
  540 {
  541 
  542         if (tag == X86_BUS_SPACE_IO) /* No 8 byte IO space access on x86 */
  543                 return;
  544         else
  545                 *(volatile uint64_t *)(bsh + offset) = value;
  546 }
  547 #endif
  548 
  549 /*
  550  * Write `count' 1, 2, 4, or 8 byte quantities from the buffer
  551  * provided to bus space described by tag/handle/offset.
  552  */
  553 
  554 static __inline void bus_space_write_multi_1(bus_space_tag_t tag,
  555                                              bus_space_handle_t bsh,
  556                                              bus_size_t offset,
  557                                              const u_int8_t *addr,
  558                                              size_t count);
  559 static __inline void bus_space_write_multi_2(bus_space_tag_t tag,
  560                                              bus_space_handle_t bsh,
  561                                              bus_size_t offset,
  562                                              const u_int16_t *addr,
  563                                              size_t count);
  564 
  565 static __inline void bus_space_write_multi_4(bus_space_tag_t tag,
  566                                              bus_space_handle_t bsh,
  567                                              bus_size_t offset,
  568                                              const u_int32_t *addr,
  569                                              size_t count);
  570 
  571 static __inline void
  572 bus_space_write_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh,
  573                         bus_size_t offset, const u_int8_t *addr, size_t count)
  574 {
  575 
  576         if (tag == X86_BUS_SPACE_IO)
  577                 outsb(bsh + offset, addr, count);
  578         else {
  579 #ifdef __GNUCLIKE_ASM
  580                 __asm __volatile("                              \n\
  581                         cld                                     \n\
  582                 1:      lodsb                                   \n\
  583                         movb %%al,(%2)                          \n\
  584                         loop 1b"                                :
  585                     "=S" (addr), "=c" (count)                   :
  586                     "r" (bsh + offset), "" (addr), "1" (count) :
  587                     "%eax", "memory", "cc");
  588 #endif
  589         }
  590 }
  591 
  592 static __inline void
  593 bus_space_write_multi_2(bus_space_tag_t tag, bus_space_handle_t bsh,
  594                         bus_size_t offset, const u_int16_t *addr, size_t count)
  595 {
  596 
  597         if (tag == X86_BUS_SPACE_IO)
  598                 outsw(bsh + offset, addr, count);
  599         else {
  600 #ifdef __GNUCLIKE_ASM
  601                 __asm __volatile("                              \n\
  602                         cld                                     \n\
  603                 1:      lodsw                                   \n\
  604                         movw %%ax,(%2)                          \n\
  605                         loop 1b"                                :
  606                     "=S" (addr), "=c" (count)                   :
  607                     "r" (bsh + offset), "" (addr), "1" (count) :
  608                     "%eax", "memory", "cc");
  609 #endif
  610         }
  611 }
  612 
  613 static __inline void
  614 bus_space_write_multi_4(bus_space_tag_t tag, bus_space_handle_t bsh,
  615                         bus_size_t offset, const u_int32_t *addr, size_t count)
  616 {
  617 
  618         if (tag == X86_BUS_SPACE_IO)
  619                 outsl(bsh + offset, addr, count);
  620         else {
  621 #ifdef __GNUCLIKE_ASM
  622                 __asm __volatile("                              \n\
  623                         cld                                     \n\
  624                 1:      lodsl                                   \n\
  625                         movl %%eax,(%2)                         \n\
  626                         loop 1b"                                :
  627                     "=S" (addr), "=c" (count)                   :
  628                     "r" (bsh + offset), "" (addr), "1" (count) :
  629                     "%eax", "memory", "cc");
  630 #endif
  631         }
  632 }
  633 
  634 #if 0   /* Cause a link error for bus_space_write_multi_8 */
  635 #define bus_space_write_multi_8(t, h, o, a, c)                          \
  636                         !!! bus_space_write_multi_8 unimplemented !!!
  637 #endif
  638 
  639 /*
  640  * Write `count' 1, 2, 4, or 8 byte quantities from the buffer provided
  641  * to bus space described by tag/handle starting at `offset'.
  642  */
  643 
  644 static __inline void bus_space_write_region_1(bus_space_tag_t tag,
  645                                               bus_space_handle_t bsh,
  646                                               bus_size_t offset,
  647                                               const u_int8_t *addr,
  648                                               size_t count);
  649 static __inline void bus_space_write_region_2(bus_space_tag_t tag,
  650                                               bus_space_handle_t bsh,
  651                                               bus_size_t offset,
  652                                               const u_int16_t *addr,
  653                                               size_t count);
  654 static __inline void bus_space_write_region_4(bus_space_tag_t tag,
  655                                               bus_space_handle_t bsh,
  656                                               bus_size_t offset,
  657                                               const u_int32_t *addr,
  658                                               size_t count);
  659 
  660 static __inline void
  661 bus_space_write_region_1(bus_space_tag_t tag, bus_space_handle_t bsh,
  662                          bus_size_t offset, const u_int8_t *addr, size_t count)
  663 {
  664 
  665         if (tag == X86_BUS_SPACE_IO) {
  666                 int _port_ = bsh + offset;
  667 #ifdef __GNUCLIKE_ASM
  668                 __asm __volatile("                              \n\
  669                         cld                                     \n\
  670                 1:      lodsb                                   \n\
  671                         outb %%al,%w0                           \n\
  672                         incl %0                                 \n\
  673                         loop 1b"                                :
  674                     "=d" (_port_), "=S" (addr), "=c" (count)    :
  675                     "" (_port_), "1" (addr), "2" (count)       :
  676                     "%eax", "memory", "cc");
  677 #endif
  678         } else {
  679                 bus_space_handle_t _port_ = bsh + offset;
  680 #ifdef __GNUCLIKE_ASM
  681                 __asm __volatile("                              \n\
  682                         cld                                     \n\
  683                         repne                                   \n\
  684                         movsb"                                  :
  685                     "=D" (_port_), "=S" (addr), "=c" (count)    :
  686                     "" (_port_), "1" (addr), "2" (count)       :
  687                     "memory", "cc");
  688 #endif
  689         }
  690 }
  691 
  692 static __inline void
  693 bus_space_write_region_2(bus_space_tag_t tag, bus_space_handle_t bsh,
  694                          bus_size_t offset, const u_int16_t *addr, size_t count)
  695 {
  696 
  697         if (tag == X86_BUS_SPACE_IO) {
  698                 int _port_ = bsh + offset;
  699 #ifdef __GNUCLIKE_ASM
  700                 __asm __volatile("                              \n\
  701                         cld                                     \n\
  702                 1:      lodsw                                   \n\
  703                         outw %%ax,%w0                           \n\
  704                         addl $2,%0                              \n\
  705                         loop 1b"                                :
  706                     "=d" (_port_), "=S" (addr), "=c" (count)    :
  707                     "" (_port_), "1" (addr), "2" (count)       :
  708                     "%eax", "memory", "cc");
  709 #endif
  710         } else {
  711                 bus_space_handle_t _port_ = bsh + offset;
  712 #ifdef __GNUCLIKE_ASM
  713                 __asm __volatile("                              \n\
  714                         cld                                     \n\
  715                         repne                                   \n\
  716                         movsw"                                  :
  717                     "=D" (_port_), "=S" (addr), "=c" (count)    :
  718                     "" (_port_), "1" (addr), "2" (count)       :
  719                     "memory", "cc");
  720 #endif
  721         }
  722 }
  723 
  724 static __inline void
  725 bus_space_write_region_4(bus_space_tag_t tag, bus_space_handle_t bsh,
  726                          bus_size_t offset, const u_int32_t *addr, size_t count)
  727 {
  728 
  729         if (tag == X86_BUS_SPACE_IO) {
  730                 int _port_ = bsh + offset;
  731 #ifdef __GNUCLIKE_ASM
  732                 __asm __volatile("                              \n\
  733                         cld                                     \n\
  734                 1:      lodsl                                   \n\
  735                         outl %%eax,%w0                          \n\
  736                         addl $4,%0                              \n\
  737                         loop 1b"                                :
  738                     "=d" (_port_), "=S" (addr), "=c" (count)    :
  739                     "" (_port_), "1" (addr), "2" (count)       :
  740                     "%eax", "memory", "cc");
  741 #endif
  742         } else {
  743                 bus_space_handle_t _port_ = bsh + offset;
  744 #ifdef __GNUCLIKE_ASM
  745                 __asm __volatile("                              \n\
  746                         cld                                     \n\
  747                         repne                                   \n\
  748                         movsl"                                  :
  749                     "=D" (_port_), "=S" (addr), "=c" (count)    :
  750                     "" (_port_), "1" (addr), "2" (count)       :
  751                     "memory", "cc");
  752 #endif
  753         }
  754 }
  755 
  756 #if 0   /* Cause a link error for bus_space_write_region_8 */
  757 #define bus_space_write_region_8                                        \
  758                         !!! bus_space_write_region_8 unimplemented !!!
  759 #endif
  760 
  761 /*
  762  * Write the 1, 2, 4, or 8 byte value `val' to bus space described
  763  * by tag/handle/offset `count' times.
  764  */
  765 
  766 static __inline void bus_space_set_multi_1(bus_space_tag_t tag,
  767                                            bus_space_handle_t bsh,
  768                                            bus_size_t offset,
  769                                            u_int8_t value, size_t count);
  770 static __inline void bus_space_set_multi_2(bus_space_tag_t tag,
  771                                            bus_space_handle_t bsh,
  772                                            bus_size_t offset,
  773                                            u_int16_t value, size_t count);
  774 static __inline void bus_space_set_multi_4(bus_space_tag_t tag,
  775                                            bus_space_handle_t bsh,
  776                                            bus_size_t offset,
  777                                            u_int32_t value, size_t count);
  778 
  779 static __inline void
  780 bus_space_set_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh,
  781                       bus_size_t offset, u_int8_t value, size_t count)
  782 {
  783         bus_space_handle_t addr = bsh + offset;
  784 
  785         if (tag == X86_BUS_SPACE_IO)
  786                 while (count--)
  787                         outb(addr, value);
  788         else
  789                 while (count--)
  790                         *(volatile u_int8_t *)(addr) = value;
  791 }
  792 
  793 static __inline void
  794 bus_space_set_multi_2(bus_space_tag_t tag, bus_space_handle_t bsh,
  795                      bus_size_t offset, u_int16_t value, size_t count)
  796 {
  797         bus_space_handle_t addr = bsh + offset;
  798 
  799         if (tag == X86_BUS_SPACE_IO)
  800                 while (count--)
  801                         outw(addr, value);
  802         else
  803                 while (count--)
  804                         *(volatile u_int16_t *)(addr) = value;
  805 }
  806 
  807 static __inline void
  808 bus_space_set_multi_4(bus_space_tag_t tag, bus_space_handle_t bsh,
  809                       bus_size_t offset, u_int32_t value, size_t count)
  810 {
  811         bus_space_handle_t addr = bsh + offset;
  812 
  813         if (tag == X86_BUS_SPACE_IO)
  814                 while (count--)
  815                         outl(addr, value);
  816         else
  817                 while (count--)
  818                         *(volatile u_int32_t *)(addr) = value;
  819 }
  820 
  821 #if 0   /* Cause a link error for bus_space_set_multi_8 */
  822 #define bus_space_set_multi_8 !!! bus_space_set_multi_8 unimplemented !!!
  823 #endif
  824 
  825 /*
  826  * Write `count' 1, 2, 4, or 8 byte value `val' to bus space described
  827  * by tag/handle starting at `offset'.
  828  */
  829 
  830 static __inline void bus_space_set_region_1(bus_space_tag_t tag,
  831                                             bus_space_handle_t bsh,
  832                                             bus_size_t offset, u_int8_t value,
  833                                             size_t count);
  834 static __inline void bus_space_set_region_2(bus_space_tag_t tag,
  835                                             bus_space_handle_t bsh,
  836                                             bus_size_t offset, u_int16_t value,
  837                                             size_t count);
  838 static __inline void bus_space_set_region_4(bus_space_tag_t tag,
  839                                             bus_space_handle_t bsh,
  840                                             bus_size_t offset, u_int32_t value,
  841                                             size_t count);
  842 
  843 static __inline void
  844 bus_space_set_region_1(bus_space_tag_t tag, bus_space_handle_t bsh,
  845                        bus_size_t offset, u_int8_t value, size_t count)
  846 {
  847         bus_space_handle_t addr = bsh + offset;
  848 
  849         if (tag == X86_BUS_SPACE_IO)
  850                 for (; count != 0; count--, addr++)
  851                         outb(addr, value);
  852         else
  853                 for (; count != 0; count--, addr++)
  854                         *(volatile u_int8_t *)(addr) = value;
  855 }
  856 
  857 static __inline void
  858 bus_space_set_region_2(bus_space_tag_t tag, bus_space_handle_t bsh,
  859                        bus_size_t offset, u_int16_t value, size_t count)
  860 {
  861         bus_space_handle_t addr = bsh + offset;
  862 
  863         if (tag == X86_BUS_SPACE_IO)
  864                 for (; count != 0; count--, addr += 2)
  865                         outw(addr, value);
  866         else
  867                 for (; count != 0; count--, addr += 2)
  868                         *(volatile u_int16_t *)(addr) = value;
  869 }
  870 
  871 static __inline void
  872 bus_space_set_region_4(bus_space_tag_t tag, bus_space_handle_t bsh,
  873                        bus_size_t offset, u_int32_t value, size_t count)
  874 {
  875         bus_space_handle_t addr = bsh + offset;
  876 
  877         if (tag == X86_BUS_SPACE_IO)
  878                 for (; count != 0; count--, addr += 4)
  879                         outl(addr, value);
  880         else
  881                 for (; count != 0; count--, addr += 4)
  882                         *(volatile u_int32_t *)(addr) = value;
  883 }
  884 
  885 #if 0   /* Cause a link error for bus_space_set_region_8 */
  886 #define bus_space_set_region_8  !!! bus_space_set_region_8 unimplemented !!!
  887 #endif
  888 
  889 /*
  890  * Copy `count' 1, 2, 4, or 8 byte values from bus space starting
  891  * at tag/bsh1/off1 to bus space starting at tag/bsh2/off2.
  892  */
  893 
  894 static __inline void bus_space_copy_region_1(bus_space_tag_t tag,
  895                                              bus_space_handle_t bsh1,
  896                                              bus_size_t off1,
  897                                              bus_space_handle_t bsh2,
  898                                              bus_size_t off2, size_t count);
  899 
  900 static __inline void bus_space_copy_region_2(bus_space_tag_t tag,
  901                                              bus_space_handle_t bsh1,
  902                                              bus_size_t off1,
  903                                              bus_space_handle_t bsh2,
  904                                              bus_size_t off2, size_t count);
  905 
  906 static __inline void bus_space_copy_region_4(bus_space_tag_t tag,
  907                                              bus_space_handle_t bsh1,
  908                                              bus_size_t off1,
  909                                              bus_space_handle_t bsh2,
  910                                              bus_size_t off2, size_t count);
  911 
  912 static __inline void
  913 bus_space_copy_region_1(bus_space_tag_t tag, bus_space_handle_t bsh1,
  914                         bus_size_t off1, bus_space_handle_t bsh2,
  915                         bus_size_t off2, size_t count)
  916 {
  917         bus_space_handle_t addr1 = bsh1 + off1;
  918         bus_space_handle_t addr2 = bsh2 + off2;
  919 
  920         if (tag == X86_BUS_SPACE_IO) {
  921                 if (addr1 >= addr2) {
  922                         /* src after dest: copy forward */
  923                         for (; count != 0; count--, addr1++, addr2++)
  924                                 outb(addr2, inb(addr1));
  925                 } else {
  926                         /* dest after src: copy backwards */
  927                         for (addr1 += (count - 1), addr2 += (count - 1);
  928                             count != 0; count--, addr1--, addr2--)
  929                                 outb(addr2, inb(addr1));
  930                 }
  931         } else {
  932                 if (addr1 >= addr2) {
  933                         /* src after dest: copy forward */
  934                         for (; count != 0; count--, addr1++, addr2++)
  935                                 *(volatile u_int8_t *)(addr2) =
  936                                     *(volatile u_int8_t *)(addr1);
  937                 } else {
  938                         /* dest after src: copy backwards */
  939                         for (addr1 += (count - 1), addr2 += (count - 1);
  940                             count != 0; count--, addr1--, addr2--)
  941                                 *(volatile u_int8_t *)(addr2) =
  942                                     *(volatile u_int8_t *)(addr1);
  943                 }
  944         }
  945 }
  946 
  947 static __inline void
  948 bus_space_copy_region_2(bus_space_tag_t tag, bus_space_handle_t bsh1,
  949                         bus_size_t off1, bus_space_handle_t bsh2,
  950                         bus_size_t off2, size_t count)
  951 {
  952         bus_space_handle_t addr1 = bsh1 + off1;
  953         bus_space_handle_t addr2 = bsh2 + off2;
  954 
  955         if (tag == X86_BUS_SPACE_IO) {
  956                 if (addr1 >= addr2) {
  957                         /* src after dest: copy forward */
  958                         for (; count != 0; count--, addr1 += 2, addr2 += 2)
  959                                 outw(addr2, inw(addr1));
  960                 } else {
  961                         /* dest after src: copy backwards */
  962                         for (addr1 += 2 * (count - 1), addr2 += 2 * (count - 1);
  963                             count != 0; count--, addr1 -= 2, addr2 -= 2)
  964                                 outw(addr2, inw(addr1));
  965                 }
  966         } else {
  967                 if (addr1 >= addr2) {
  968                         /* src after dest: copy forward */
  969                         for (; count != 0; count--, addr1 += 2, addr2 += 2)
  970                                 *(volatile u_int16_t *)(addr2) =
  971                                     *(volatile u_int16_t *)(addr1);
  972                 } else {
  973                         /* dest after src: copy backwards */
  974                         for (addr1 += 2 * (count - 1), addr2 += 2 * (count - 1);
  975                             count != 0; count--, addr1 -= 2, addr2 -= 2)
  976                                 *(volatile u_int16_t *)(addr2) =
  977                                     *(volatile u_int16_t *)(addr1);
  978                 }
  979         }
  980 }
  981 
  982 static __inline void
  983 bus_space_copy_region_4(bus_space_tag_t tag, bus_space_handle_t bsh1,
  984                         bus_size_t off1, bus_space_handle_t bsh2,
  985                         bus_size_t off2, size_t count)
  986 {
  987         bus_space_handle_t addr1 = bsh1 + off1;
  988         bus_space_handle_t addr2 = bsh2 + off2;
  989 
  990         if (tag == X86_BUS_SPACE_IO) {
  991                 if (addr1 >= addr2) {
  992                         /* src after dest: copy forward */
  993                         for (; count != 0; count--, addr1 += 4, addr2 += 4)
  994                                 outl(addr2, inl(addr1));
  995                 } else {
  996                         /* dest after src: copy backwards */
  997                         for (addr1 += 4 * (count - 1), addr2 += 4 * (count - 1);
  998                             count != 0; count--, addr1 -= 4, addr2 -= 4)
  999                                 outl(addr2, inl(addr1));
 1000                 }
 1001         } else {
 1002                 if (addr1 >= addr2) {
 1003                         /* src after dest: copy forward */
 1004                         for (; count != 0; count--, addr1 += 4, addr2 += 4)
 1005                                 *(volatile u_int32_t *)(addr2) =
 1006                                     *(volatile u_int32_t *)(addr1);
 1007                 } else {
 1008                         /* dest after src: copy backwards */
 1009                         for (addr1 += 4 * (count - 1), addr2 += 4 * (count - 1);
 1010                             count != 0; count--, addr1 -= 4, addr2 -= 4)
 1011                                 *(volatile u_int32_t *)(addr2) =
 1012                                     *(volatile u_int32_t *)(addr1);
 1013                 }
 1014         }
 1015 }
 1016 
 1017 #if 0   /* Cause a link error for bus_space_copy_8 */
 1018 #define bus_space_copy_region_8 !!! bus_space_copy_region_8 unimplemented !!!
 1019 #endif
 1020 
 1021 /*
 1022  * Bus read/write barrier methods.
 1023  *
 1024  *      void bus_space_barrier(bus_space_tag_t tag, bus_space_handle_t bsh,
 1025  *                             bus_size_t offset, bus_size_t len, int flags);
 1026  *
 1027  *
 1028  * Note that BUS_SPACE_BARRIER_WRITE doesn't do anything other than
 1029  * prevent reordering by the compiler; all Intel x86 processors currently
 1030  * retire operations outside the CPU in program order.
 1031  */
 1032 #define BUS_SPACE_BARRIER_READ  0x01            /* force read barrier */
 1033 #define BUS_SPACE_BARRIER_WRITE 0x02            /* force write barrier */
 1034 
 1035 static __inline void
 1036 bus_space_barrier(bus_space_tag_t tag __unused, bus_space_handle_t bsh __unused,
 1037                   bus_size_t offset __unused, bus_size_t len __unused, int flags)
 1038 {
 1039 #ifdef __GNUCLIKE_ASM
 1040         if (flags & BUS_SPACE_BARRIER_READ)
 1041 #ifdef __amd64__
 1042                 __asm __volatile("lock; addl $0,0(%%rsp)" : : : "memory");
 1043 #else
 1044                 __asm __volatile("lock; addl $0,0(%%esp)" : : : "memory");
 1045 #endif
 1046         else
 1047                 __compiler_membar();
 1048 #endif
 1049 }
 1050 
 1051 #ifdef BUS_SPACE_NO_LEGACY
 1052 #undef inb
 1053 #undef outb
 1054 #define inb(a) compiler_error
 1055 #define inw(a) compiler_error
 1056 #define inl(a) compiler_error
 1057 #define outb(a, b) compiler_error
 1058 #define outw(a, b) compiler_error
 1059 #define outl(a, b) compiler_error
 1060 #endif
 1061 
 1062 #include <machine/bus_dma.h>
 1063 
 1064 /*
 1065  * Stream accesses are the same as normal accesses on x86; there are no
 1066  * supported bus systems with an endianess different from the host one.
 1067  */
 1068 #define bus_space_read_stream_1(t, h, o)        bus_space_read_1((t), (h), (o))
 1069 #define bus_space_read_stream_2(t, h, o)        bus_space_read_2((t), (h), (o))
 1070 #define bus_space_read_stream_4(t, h, o)        bus_space_read_4((t), (h), (o))
 1071 
 1072 #define bus_space_read_multi_stream_1(t, h, o, a, c) \
 1073         bus_space_read_multi_1((t), (h), (o), (a), (c))
 1074 #define bus_space_read_multi_stream_2(t, h, o, a, c) \
 1075         bus_space_read_multi_2((t), (h), (o), (a), (c))
 1076 #define bus_space_read_multi_stream_4(t, h, o, a, c) \
 1077         bus_space_read_multi_4((t), (h), (o), (a), (c))
 1078 
 1079 #define bus_space_write_stream_1(t, h, o, v) \
 1080         bus_space_write_1((t), (h), (o), (v))
 1081 #define bus_space_write_stream_2(t, h, o, v) \
 1082         bus_space_write_2((t), (h), (o), (v))
 1083 #define bus_space_write_stream_4(t, h, o, v) \
 1084         bus_space_write_4((t), (h), (o), (v))
 1085 
 1086 #define bus_space_write_multi_stream_1(t, h, o, a, c) \
 1087         bus_space_write_multi_1((t), (h), (o), (a), (c))
 1088 #define bus_space_write_multi_stream_2(t, h, o, a, c) \
 1089         bus_space_write_multi_2((t), (h), (o), (a), (c))
 1090 #define bus_space_write_multi_stream_4(t, h, o, a, c) \
 1091         bus_space_write_multi_4((t), (h), (o), (a), (c))
 1092 
 1093 #define bus_space_set_multi_stream_1(t, h, o, v, c) \
 1094         bus_space_set_multi_1((t), (h), (o), (v), (c))
 1095 #define bus_space_set_multi_stream_2(t, h, o, v, c) \
 1096         bus_space_set_multi_2((t), (h), (o), (v), (c))
 1097 #define bus_space_set_multi_stream_4(t, h, o, v, c) \
 1098         bus_space_set_multi_4((t), (h), (o), (v), (c))
 1099 
 1100 #define bus_space_read_region_stream_1(t, h, o, a, c) \
 1101         bus_space_read_region_1((t), (h), (o), (a), (c))
 1102 #define bus_space_read_region_stream_2(t, h, o, a, c) \
 1103         bus_space_read_region_2((t), (h), (o), (a), (c))
 1104 #define bus_space_read_region_stream_4(t, h, o, a, c) \
 1105         bus_space_read_region_4((t), (h), (o), (a), (c))
 1106 
 1107 #define bus_space_write_region_stream_1(t, h, o, a, c) \
 1108         bus_space_write_region_1((t), (h), (o), (a), (c))
 1109 #define bus_space_write_region_stream_2(t, h, o, a, c) \
 1110         bus_space_write_region_2((t), (h), (o), (a), (c))
 1111 #define bus_space_write_region_stream_4(t, h, o, a, c) \
 1112         bus_space_write_region_4((t), (h), (o), (a), (c))
 1113 
 1114 #define bus_space_set_region_stream_1(t, h, o, v, c) \
 1115         bus_space_set_region_1((t), (h), (o), (v), (c))
 1116 #define bus_space_set_region_stream_2(t, h, o, v, c) \
 1117         bus_space_set_region_2((t), (h), (o), (v), (c))
 1118 #define bus_space_set_region_stream_4(t, h, o, v, c) \
 1119         bus_space_set_region_4((t), (h), (o), (v), (c))
 1120 
 1121 #define bus_space_copy_region_stream_1(t, h1, o1, h2, o2, c) \
 1122         bus_space_copy_region_1((t), (h1), (o1), (h2), (o2), (c))
 1123 #define bus_space_copy_region_stream_2(t, h1, o1, h2, o2, c) \
 1124         bus_space_copy_region_2((t), (h1), (o1), (h2), (o2), (c))
 1125 #define bus_space_copy_region_stream_4(t, h1, o1, h2, o2, c) \
 1126         bus_space_copy_region_4((t), (h1), (o1), (h2), (o2), (c))
 1127 
 1128 #endif /* _X86_BUS_H_ */

Cache object: 3fcd37db00ca0c4995915f640620a93c


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.