1 /* $NetBSD: bus.h,v 1.12 1997/10/01 08:25:15 fvdl Exp $ */ 2 3 /*- 4 * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * Copyright (c) 1996 Charles M. Hannum. All rights reserved. 42 * Copyright (c) 1996 Christopher G. Demetriou. All rights reserved. 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 Christopher G. Demetriou 55 * for the NetBSD Project. 56 * 4. The name of the author may not be used to endorse or promote products 57 * derived from this software without specific prior written permission 58 * 59 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 60 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 61 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 62 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 63 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 64 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 65 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 66 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 67 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 68 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 69 */ 70 /* $Id: bus.h,v 1.4 1998/09/29 09:06:00 bde Exp $ */ 71 72 #ifndef _I386_BUS_H_ 73 #define _I386_BUS_H_ 74 75 #include <machine/cpufunc.h> 76 77 /* 78 * To remain compatible with NetBSD's interface, default to both memio and 79 * pio when neither of them is defined. 80 */ 81 #if !defined(_I386_BUS_PIO_H_) && !defined(_I386_BUS_MEMIO_H_) 82 #define _I386_BUS_PIO_H_ 83 #define _I386_BUS_MEMIO_H_ 84 #endif 85 86 /* 87 * Values for the i386 bus space tag, not to be used directly by MI code. 88 */ 89 #define I386_BUS_SPACE_IO 0 /* space is i/o space */ 90 #define I386_BUS_SPACE_MEM 1 /* space is mem space */ 91 92 /* 93 * Bus address and size types 94 */ 95 typedef u_int bus_addr_t; 96 typedef u_int bus_size_t; 97 98 #define BUS_SPACE_MAXSIZE_24BIT 0xFFFFFF 99 #define BUS_SPACE_MAXSIZE_32BIT 0xFFFFFFFF 100 #define BUS_SPACE_MAXSIZE (64 * 1024) /* Maximum supported size */ 101 #define BUS_SPACE_MAXADDR_24BIT 0xFFFFFF 102 #define BUS_SPACE_MAXADDR_32BIT 0xFFFFFFFF 103 #define BUS_SPACE_MAXADDR 0xFFFFFFFF 104 105 #define BUS_SPACE_UNRESTRICTED (~0) 106 107 /* 108 * Access methods for bus resources and address space. 109 */ 110 typedef int bus_space_tag_t; 111 typedef u_int bus_space_handle_t; 112 113 /* 114 * Map a region of device bus space into CPU virtual address space. 115 */ 116 117 #define BUS_SPACE_MAP_CACHEABLE 0x01 118 #define BUS_SPACE_MAP_LINEAR 0x02 119 120 int bus_space_map(bus_space_tag_t t, bus_addr_t addr, bus_size_t size, 121 int flags, bus_space_handle_t *bshp); 122 123 /* 124 * Unmap a region of device bus space. 125 */ 126 127 void bus_space_unmap(bus_space_tag_t t, bus_space_handle_t bsh, 128 bus_size_t size); 129 130 /* 131 * Get a new handle for a subregion of an already-mapped area of bus space. 132 */ 133 134 int bus_space_subregion(bus_space_tag_t t, bus_space_handle_t bsh, 135 bus_size_t offset, bus_size_t size, 136 bus_space_handle_t *nbshp); 137 138 /* 139 * Allocate a region of memory that is accessible to devices in bus space. 140 */ 141 142 int bus_space_alloc(bus_space_tag_t t, bus_addr_t rstart, 143 bus_addr_t rend, bus_size_t size, bus_size_t align, 144 bus_size_t boundary, int flags, bus_addr_t *addrp, 145 bus_space_handle_t *bshp); 146 147 /* 148 * Free a region of bus space accessible memory. 149 */ 150 151 void bus_space_free(bus_space_tag_t t, bus_space_handle_t bsh, 152 bus_size_t size); 153 154 #if defined(_I386_BUS_PIO_H_) || defined(_I386_BUS_MEMIO_H_) 155 156 /* 157 * Read a 1, 2, 4, or 8 byte quantity from bus space 158 * described by tag/handle/offset. 159 */ 160 static __inline u_int8_t bus_space_read_1(bus_space_tag_t tag, 161 bus_space_handle_t handle, 162 bus_size_t offset); 163 164 static __inline u_int16_t bus_space_read_2(bus_space_tag_t tag, 165 bus_space_handle_t handle, 166 bus_size_t offset); 167 168 static __inline u_int32_t bus_space_read_4(bus_space_tag_t tag, 169 bus_space_handle_t handle, 170 bus_size_t offset); 171 172 static __inline u_int8_t 173 bus_space_read_1(bus_space_tag_t tag, bus_space_handle_t handle, 174 bus_size_t offset) 175 { 176 #if defined (_I386_BUS_PIO_H_) 177 #if defined (_I386_BUS_MEMIO_H_) 178 if (tag == I386_BUS_SPACE_IO) 179 #endif 180 return (inb(handle + offset)); 181 #endif 182 #if defined (_I386_BUS_MEMIO_H_) 183 return (*(volatile u_int8_t *)(handle + offset)); 184 #endif 185 } 186 187 static __inline u_int16_t 188 bus_space_read_2(bus_space_tag_t tag, bus_space_handle_t handle, 189 bus_size_t offset) 190 { 191 #if defined(_I386_BUS_PIO_H_) 192 #if defined(_I386_BUS_MEMIO_H_) 193 if (tag == I386_BUS_SPACE_IO) 194 #endif 195 return (inw(handle + offset)); 196 #endif 197 #if defined(_I386_BUS_MEMIO_H_) 198 return (*(volatile u_int16_t *)(handle + offset)); 199 #endif 200 } 201 202 static __inline u_int32_t 203 bus_space_read_4(bus_space_tag_t tag, bus_space_handle_t handle, 204 bus_size_t offset) 205 { 206 #if defined(_I386_BUS_PIO_H_) 207 #if defined(_I386_BUS_MEMIO_H_) 208 if (tag == I386_BUS_SPACE_IO) 209 #endif 210 return (inl(handle + offset)); 211 #endif 212 #if defined(_I386_BUS_MEMIO_H_) 213 return (*(volatile u_int32_t *)(handle + offset)); 214 #endif 215 } 216 217 #if 0 /* Cause a link error for bus_space_read_8 */ 218 #define bus_space_read_8(t, h, o) !!! bus_space_read_8 unimplemented !!! 219 #endif 220 221 /* 222 * Read `count' 1, 2, 4, or 8 byte quantities from bus space 223 * described by tag/handle/offset and copy into buffer provided. 224 */ 225 static __inline void bus_space_read_multi_1(bus_space_tag_t tag, 226 bus_space_handle_t bsh, 227 bus_size_t offset, u_int8_t *addr, 228 size_t count); 229 230 static __inline void bus_space_read_multi_2(bus_space_tag_t tag, 231 bus_space_handle_t bsh, 232 bus_size_t offset, u_int16_t *addr, 233 size_t count); 234 235 static __inline void bus_space_read_multi_4(bus_space_tag_t tag, 236 bus_space_handle_t bsh, 237 bus_size_t offset, u_int32_t *addr, 238 size_t count); 239 240 static __inline void 241 bus_space_read_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh, 242 bus_size_t offset, u_int8_t *addr, size_t count) 243 { 244 #if defined(_I386_BUS_PIO_H_) 245 #if defined(_I386_BUS_MEMIO_H_) 246 if (tag == I386_BUS_SPACE_IO) 247 #endif 248 insb(bsh + offset, addr, count); 249 #endif 250 #if defined(_I386_BUS_MEMIO_H_) 251 #if defined(_I386_BUS_PIO_H_) 252 else 253 #endif 254 { 255 int __x __asm__("%eax"); 256 __asm __volatile(" \n\ 257 cld \n\ 258 1: movb (%1),%%al \n\ 259 stosb \n\ 260 loop 1b" : 261 "=&a" (__x) : 262 "r" (bsh + offset), "D" (addr), "c" (count) : 263 "%edi", "%ecx", "memory"); 264 } 265 #endif 266 } 267 268 static __inline void 269 bus_space_read_multi_2(bus_space_tag_t tag, bus_space_handle_t bsh, 270 bus_size_t offset, u_int16_t *addr, size_t count) 271 { 272 #if defined(_I386_BUS_PIO_H_) 273 #if defined(_I386_BUS_MEMIO_H_) 274 if (tag == I386_BUS_SPACE_IO) 275 #endif 276 insw(bsh + offset, addr, count); 277 #endif 278 #if defined(_I386_BUS_MEMIO_H_) 279 #if defined(_I386_BUS_PIO_H_) 280 else 281 #endif 282 { 283 int __x __asm__("%eax"); 284 __asm __volatile(" \n\ 285 cld \n\ 286 1: movw (%1),%%ax \n\ 287 stosw \n\ 288 loop 1b" : 289 "=&a" (__x) : 290 "r" (bsh + offset), "D" (addr), "c" (count) : 291 "%edi", "%ecx", "memory"); 292 } 293 #endif 294 } 295 296 static __inline void 297 bus_space_read_multi_4(bus_space_tag_t tag, bus_space_handle_t bsh, 298 bus_size_t offset, u_int32_t *addr, size_t count) 299 { 300 #if defined(_I386_BUS_PIO_H_) 301 #if defined(_I386_BUS_MEMIO_H_) 302 if (tag == I386_BUS_SPACE_IO) 303 #endif 304 insl(bsh + offset, addr, count); 305 #endif 306 #if defined(_I386_BUS_MEMIO_H_) 307 #if defined(_I386_BUS_PIO_H_) 308 else 309 #endif 310 { 311 int __x __asm__("%eax"); 312 __asm __volatile(" \n\ 313 cld \n\ 314 1: movl (%1),%%eax \n\ 315 stosl \n\ 316 loop 1b" : 317 "=&a" (__x) : 318 "r" (bsh + offset), "D" (addr), "c" (count) : 319 "%edi", "%ecx", "memory"); 320 } 321 #endif 322 } 323 324 #if 0 /* Cause a link error for bus_space_read_multi_8 */ 325 #define bus_space_read_multi_8 !!! bus_space_read_multi_8 unimplemented !!! 326 #endif 327 328 /* 329 * Read `count' 1, 2, 4, or 8 byte quantities from bus space 330 * described by tag/handle and starting at `offset' and copy into 331 * buffer provided. 332 */ 333 static __inline void bus_space_read_region_1(bus_space_tag_t tag, 334 bus_space_handle_t bsh, 335 bus_size_t offset, u_int8_t *addr, 336 size_t count); 337 338 static __inline void bus_space_read_region_2(bus_space_tag_t tag, 339 bus_space_handle_t bsh, 340 bus_size_t offset, u_int16_t *addr, 341 size_t count); 342 343 static __inline void bus_space_read_region_4(bus_space_tag_t tag, 344 bus_space_handle_t bsh, 345 bus_size_t offset, u_int32_t *addr, 346 size_t count); 347 348 349 static __inline void 350 bus_space_read_region_1(bus_space_tag_t tag, bus_space_handle_t bsh, 351 bus_size_t offset, u_int8_t *addr, size_t count) 352 { 353 #if defined(_I386_BUS_PIO_H_) 354 #if defined(_I386_BUS_MEMIO_H_) 355 if (tag == I386_BUS_SPACE_IO) 356 #endif 357 { 358 int __x __asm__("%eax"); 359 __asm __volatile(" \n\ 360 cld \n\ 361 1: inb %w1,%%al \n\ 362 stosb \n\ 363 incl %1 \n\ 364 loop 1b" : 365 "=&a" (__x) : 366 "d" (bsh + offset), "D" (addr), "c" (count) : 367 "%edx", "%edi", "%ecx", "memory"); 368 } 369 #endif 370 #if defined(_I386_BUS_MEMIO_H_) 371 #if defined(_I386_BUS_PIO_H_) 372 else 373 #endif 374 { 375 __asm __volatile(" \n\ 376 cld \n\ 377 repne \n\ 378 movsb" : 379 : 380 "S" (bsh + offset), "D" (addr), "c" (count) : 381 "%esi", "%edi", "%ecx", "memory"); 382 } 383 #endif 384 } 385 386 static __inline void 387 bus_space_read_region_2(bus_space_tag_t tag, bus_space_handle_t bsh, 388 bus_size_t offset, u_int16_t *addr, size_t count) 389 { 390 #if defined(_I386_BUS_PIO_H_) 391 #if defined(_I386_BUS_MEMIO_H_) 392 if (tag == I386_BUS_SPACE_IO) 393 #endif 394 { 395 int __x __asm__("%eax"); 396 __asm __volatile(" \n\ 397 cld \n\ 398 1: inw %w1,%%ax \n\ 399 stosw \n\ 400 addl $2,%1 \n\ 401 loop 1b" : 402 "=&a" (__x) : 403 "d" (bsh + offset), "D" (addr), "c" (count) : 404 "%edx", "%edi", "%ecx", "memory"); 405 } 406 #endif 407 #if defined(_I386_BUS_MEMIO_H_) 408 #if defined(_I386_BUS_PIO_H_) 409 else 410 #endif 411 { 412 __asm __volatile(" \n\ 413 cld \n\ 414 repne \n\ 415 movsw" : 416 : 417 "S" (bsh + offset), "D" (addr), "c" (count) : 418 "%esi", "%edi", "%ecx", "memory"); 419 } 420 #endif 421 } 422 423 static __inline void 424 bus_space_read_region_4(bus_space_tag_t tag, bus_space_handle_t bsh, 425 bus_size_t offset, u_int32_t *addr, size_t count) 426 { 427 #if defined(_I386_BUS_PIO_H_) 428 #if defined(_I386_BUS_MEMIO_H_) 429 if (tag == I386_BUS_SPACE_IO) 430 #endif 431 { 432 int __x __asm__("%eax"); 433 __asm __volatile(" \n\ 434 cld \n\ 435 1: inl %w1,%%eax \n\ 436 stosl \n\ 437 addl $4,%1 \n\ 438 loop 1b" : 439 "=&a" (__x) : 440 "d" (bsh + offset), "D" (addr), "c" (count) : 441 "%edx", "%edi", "%ecx", "memory"); 442 } 443 #endif 444 #if defined(_I386_BUS_MEMIO_H_) 445 #if defined(_I386_BUS_PIO_H_) 446 else 447 #endif 448 { 449 __asm __volatile(" \n\ 450 cld \n\ 451 repne \n\ 452 movsl" : 453 : 454 "S" (bsh + offset), "D" (addr), "c" (count) : 455 "%esi", "%edi", "%ecx", "memory"); 456 } 457 #endif 458 } 459 460 #if 0 /* Cause a link error for bus_space_read_region_8 */ 461 #define bus_space_read_region_8 !!! bus_space_read_region_8 unimplemented !!! 462 #endif 463 464 /* 465 * Write the 1, 2, 4, or 8 byte value `value' to bus space 466 * described by tag/handle/offset. 467 */ 468 469 static __inline void bus_space_write_1(bus_space_tag_t tag, 470 bus_space_handle_t bsh, 471 bus_size_t offset, u_int8_t value); 472 473 static __inline void bus_space_write_2(bus_space_tag_t tag, 474 bus_space_handle_t bsh, 475 bus_size_t offset, u_int16_t value); 476 477 static __inline void bus_space_write_4(bus_space_tag_t tag, 478 bus_space_handle_t bsh, 479 bus_size_t offset, u_int32_t value); 480 481 static __inline void 482 bus_space_write_1(bus_space_tag_t tag, bus_space_handle_t bsh, 483 bus_size_t offset, u_int8_t value) 484 { 485 #if defined(_I386_BUS_PIO_H_) 486 #if defined(_I386_BUS_MEMIO_H_) 487 if (tag == I386_BUS_SPACE_IO) 488 #endif 489 outb(bsh + offset, value); 490 #endif 491 #if defined(_I386_BUS_MEMIO_H_) 492 #if defined(_I386_BUS_PIO_H_) 493 else 494 #endif 495 *(volatile u_int8_t *)(bsh + offset) = value; 496 #endif 497 } 498 499 static __inline void 500 bus_space_write_2(bus_space_tag_t tag, bus_space_handle_t bsh, 501 bus_size_t offset, u_int16_t value) 502 { 503 #if defined(_I386_BUS_PIO_H_) 504 #if defined(_I386_BUS_MEMIO_H_) 505 if (tag == I386_BUS_SPACE_IO) 506 #endif 507 outw(bsh + offset, value); 508 #endif 509 #if defined(_I386_BUS_MEMIO_H_) 510 #if defined(_I386_BUS_PIO_H_) 511 else 512 #endif 513 *(volatile u_int16_t *)(bsh + offset) = value; 514 #endif 515 } 516 517 static __inline void 518 bus_space_write_4(bus_space_tag_t tag, bus_space_handle_t bsh, 519 bus_size_t offset, u_int32_t value) 520 { 521 #if defined(_I386_BUS_PIO_H_) 522 #if defined(_I386_BUS_MEMIO_H_) 523 if (tag == I386_BUS_SPACE_IO) 524 #endif 525 outl(bsh + offset, value); 526 #endif 527 #if defined(_I386_BUS_MEMIO_H_) 528 #if defined(_I386_BUS_PIO_H_) 529 else 530 #endif 531 *(volatile u_int32_t *)(bsh + offset) = value; 532 #endif 533 } 534 535 #if 0 /* Cause a link error for bus_space_write_8 */ 536 #define bus_space_write_8 !!! bus_space_write_8 not implemented !!! 537 #endif 538 539 /* 540 * Write `count' 1, 2, 4, or 8 byte quantities from the buffer 541 * provided to bus space described by tag/handle/offset. 542 */ 543 544 static __inline void bus_space_write_multi_1(bus_space_tag_t tag, 545 bus_space_handle_t bsh, 546 bus_size_t offset, 547 const u_int8_t *addr, 548 size_t count); 549 static __inline void bus_space_write_multi_2(bus_space_tag_t tag, 550 bus_space_handle_t bsh, 551 bus_size_t offset, 552 const u_int16_t *addr, 553 size_t count); 554 555 static __inline void bus_space_write_multi_4(bus_space_tag_t tag, 556 bus_space_handle_t bsh, 557 bus_size_t offset, 558 const u_int32_t *addr, 559 size_t count); 560 561 static __inline void 562 bus_space_write_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh, 563 bus_size_t offset, const u_int8_t *addr, size_t count) 564 { 565 #if defined(_I386_BUS_PIO_H_) 566 #if defined(_I386_BUS_MEMIO_H_) 567 if (tag == I386_BUS_SPACE_IO) 568 #endif 569 outsb(bsh + offset, addr, count); 570 #endif 571 #if defined(_I386_BUS_MEMIO_H_) 572 #if defined(_I386_BUS_PIO_H_) 573 else 574 #endif 575 { 576 int __x __asm__("%eax"); 577 __asm __volatile(" \n\ 578 cld \n\ 579 1: lodsb \n\ 580 movb %%al,(%1) \n\ 581 loop 1b" : 582 "=&a" (__x) : 583 "r" (bsh + offset), "S" (addr), "c" (count) : 584 "%esi", "%ecx"); 585 } 586 #endif 587 } 588 589 static __inline void 590 bus_space_write_multi_2(bus_space_tag_t tag, bus_space_handle_t bsh, 591 bus_size_t offset, const u_int16_t *addr, size_t count) 592 { 593 #if defined(_I386_BUS_PIO_H_) 594 #if defined(_I386_BUS_MEMIO_H_) 595 if (tag == I386_BUS_SPACE_IO) 596 #endif 597 outsw(bsh + offset, addr, count); 598 #endif 599 #if defined(_I386_BUS_MEMIO_H_) 600 #if defined(_I386_BUS_PIO_H_) 601 else 602 #endif 603 { 604 int __x __asm__("%eax"); 605 __asm __volatile(" \n\ 606 cld \n\ 607 1: lodsw \n\ 608 movw %%ax,(%1) \n\ 609 loop 1b" : 610 "=&a" (__x) : 611 "r" (bsh + offset), "S" (addr), "c" (count) : 612 "%esi", "%ecx"); 613 } 614 #endif 615 } 616 617 static __inline void 618 bus_space_write_multi_4(bus_space_tag_t tag, bus_space_handle_t bsh, 619 bus_size_t offset, const u_int32_t *addr, size_t count) 620 { 621 #if defined(_I386_BUS_PIO_H_) 622 #if defined(_I386_BUS_MEMIO_H_) 623 if (tag == I386_BUS_SPACE_IO) 624 #endif 625 outsl(bsh + offset, addr, count); 626 #endif 627 #if defined(_I386_BUS_MEMIO_H_) 628 #if defined(_I386_BUS_PIO_H_) 629 else 630 #endif 631 { 632 int __x __asm__("%eax"); 633 __asm __volatile(" \n\ 634 cld \n\ 635 1: lodsl \n\ 636 movl %%eax,(%1) \n\ 637 loop 1b" : 638 "=&a" (__x) : 639 "r" (bsh + offset), "S" (addr), "c" (count) : 640 "%esi", "%ecx"); 641 } 642 #endif 643 } 644 645 #if 0 /* Cause a link error for bus_space_write_multi_8 */ 646 #define bus_space_write_multi_8(t, h, o, a, c) \ 647 !!! bus_space_write_multi_8 unimplemented !!! 648 #endif 649 650 /* 651 * Write `count' 1, 2, 4, or 8 byte quantities from the buffer provided 652 * to bus space described by tag/handle starting at `offset'. 653 */ 654 655 static __inline void bus_space_write_region_1(bus_space_tag_t tag, 656 bus_space_handle_t bsh, 657 bus_size_t offset, 658 const u_int8_t *addr, 659 size_t count); 660 static __inline void bus_space_write_region_2(bus_space_tag_t tag, 661 bus_space_handle_t bsh, 662 bus_size_t offset, 663 const u_int16_t *addr, 664 size_t count); 665 static __inline void bus_space_write_region_4(bus_space_tag_t tag, 666 bus_space_handle_t bsh, 667 bus_size_t offset, 668 const u_int32_t *addr, 669 size_t count); 670 671 static __inline void 672 bus_space_write_region_1(bus_space_tag_t tag, bus_space_handle_t bsh, 673 bus_size_t offset, const u_int8_t *addr, size_t count) 674 { 675 #if defined(_I386_BUS_PIO_H_) 676 #if defined(_I386_BUS_MEMIO_H_) 677 if (tag == I386_BUS_SPACE_IO) 678 #endif 679 { 680 int __x __asm__("%eax"); 681 __asm __volatile(" \n\ 682 cld \n\ 683 1: lodsb \n\ 684 outb %%al,%w1 \n\ 685 incl %1 \n\ 686 loop 1b" : 687 "=&a" (__x) : 688 "d" (bsh + offset), "S" (addr), "c" (count) : 689 "%edx", "%esi", "%ecx", "memory"); 690 } 691 #endif 692 #if defined(_I386_BUS_MEMIO_H_) 693 #if defined(_I386_BUS_PIO_H_) 694 else 695 #endif 696 { 697 __asm __volatile(" \n\ 698 cld \n\ 699 repne \n\ 700 movsb" : 701 : 702 "D" (bsh + offset), "S" (addr), "c" (count) : 703 "%edi", "%esi", "%ecx", "memory"); 704 } 705 #endif 706 } 707 708 static __inline void 709 bus_space_write_region_2(bus_space_tag_t tag, bus_space_handle_t bsh, 710 bus_size_t offset, const u_int16_t *addr, size_t count) 711 { 712 #if defined(_I386_BUS_PIO_H_) 713 #if defined(_I386_BUS_MEMIO_H_) 714 if (tag == I386_BUS_SPACE_IO) 715 #endif 716 { 717 int __x __asm__("%eax"); 718 __asm __volatile(" \n\ 719 cld \n\ 720 1: lodsw \n\ 721 outw %%ax,%w1 \n\ 722 addl $2,%1 \n\ 723 loop 1b" : 724 "=&a" (__x) : 725 "d" (bsh + offset), "S" (addr), "c" (count) : 726 "%edx", "%esi", "%ecx", "memory"); 727 } 728 #endif 729 #if defined(_I386_BUS_MEMIO_H_) 730 #if defined(_I386_BUS_PIO_H_) 731 else 732 #endif 733 { 734 __asm __volatile(" \n\ 735 cld \n\ 736 repne \n\ 737 movsw" : 738 : 739 "D" (bsh + offset), "S" (addr), "c" (count) : 740 "%edi", "%esi", "%ecx", "memory"); 741 } 742 #endif 743 } 744 745 static __inline void 746 bus_space_write_region_4(bus_space_tag_t tag, bus_space_handle_t bsh, 747 bus_size_t offset, const u_int32_t *addr, size_t count) 748 { 749 #if defined(_I386_BUS_PIO_H_) 750 #if defined(_I386_BUS_MEMIO_H_) 751 if (tag == I386_BUS_SPACE_IO) 752 #endif 753 { 754 int __x __asm__("%eax"); 755 __asm __volatile(" \n\ 756 cld \n\ 757 1: lodsl \n\ 758 outl %%eax,%w1 \n\ 759 addl $4,%1 \n\ 760 loop 1b" : 761 "=&a" (__x) : 762 "d" (bsh + offset), "S" (addr), "c" (count) : 763 "%edx", "%esi", "%ecx", "memory"); 764 } 765 #endif 766 #if defined(_I386_BUS_MEMIO_H_) 767 #if defined(_I386_BUS_PIO_H_) 768 else 769 #endif 770 { 771 __asm __volatile(" \n\ 772 cld \n\ 773 repne \n\ 774 movsl" : 775 : 776 "D" (bsh + offset), "S" (addr), "c" (count) : 777 "%edi", "%esi", "%ecx", "memory"); 778 } 779 #endif 780 } 781 782 #if 0 /* Cause a link error for bus_space_write_region_8 */ 783 #define bus_space_write_region_8 \ 784 !!! bus_space_write_region_8 unimplemented !!! 785 #endif 786 787 /* 788 * Write the 1, 2, 4, or 8 byte value `val' to bus space described 789 * by tag/handle/offset `count' times. 790 */ 791 792 static __inline void bus_space_set_multi_1(bus_space_tag_t tag, 793 bus_space_handle_t bsh, 794 bus_size_t offset, 795 u_int8_t value, size_t count); 796 static __inline void bus_space_set_multi_2(bus_space_tag_t tag, 797 bus_space_handle_t bsh, 798 bus_size_t offset, 799 u_int16_t value, size_t count); 800 static __inline void bus_space_set_multi_4(bus_space_tag_t tag, 801 bus_space_handle_t bsh, 802 bus_size_t offset, 803 u_int32_t value, size_t count); 804 805 static __inline void 806 bus_space_set_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh, 807 bus_size_t offset, u_int8_t value, size_t count) 808 { 809 bus_addr_t addr = bsh + offset; 810 811 #if defined(_I386_BUS_PIO_H_) 812 #if defined(_I386_BUS_MEMIO_H_) 813 if (tag == I386_BUS_SPACE_IO) 814 #endif 815 while (count--) 816 outb(addr, value); 817 #endif 818 #if defined(_I386_BUS_MEMIO_H_) 819 #if defined(_I386_BUS_PIO_H_) 820 else 821 #endif 822 while (count--) 823 *(volatile u_int8_t *)(addr) = value; 824 #endif 825 } 826 827 static __inline void 828 bus_space_set_multi_2(bus_space_tag_t tag, bus_space_handle_t bsh, 829 bus_size_t offset, u_int16_t value, size_t count) 830 { 831 bus_addr_t addr = bsh + offset; 832 833 #if defined(_I386_BUS_PIO_H_) 834 #if defined(_I386_BUS_MEMIO_H_) 835 if (tag == I386_BUS_SPACE_IO) 836 #endif 837 while (count--) 838 outw(addr, value); 839 #endif 840 #if defined(_I386_BUS_MEMIO_H_) 841 #if defined(_I386_BUS_PIO_H_) 842 else 843 #endif 844 while (count--) 845 *(volatile u_int16_t *)(addr) = value; 846 #endif 847 } 848 849 static __inline void 850 bus_space_set_multi_4(bus_space_tag_t tag, bus_space_handle_t bsh, 851 bus_size_t offset, u_int32_t value, size_t count) 852 { 853 bus_addr_t addr = bsh + offset; 854 855 #if defined(_I386_BUS_PIO_H_) 856 #if defined(_I386_BUS_MEMIO_H_) 857 if (tag == I386_BUS_SPACE_IO) 858 #endif 859 while (count--) 860 outl(addr, value); 861 #endif 862 #if defined(_I386_BUS_MEMIO_H_) 863 #if defined(_I386_BUS_PIO_H_) 864 else 865 #endif 866 while (count--) 867 *(volatile u_int32_t *)(addr) = value; 868 #endif 869 } 870 871 #if 0 /* Cause a link error for bus_space_set_multi_8 */ 872 #define bus_space_set_multi_8 !!! bus_space_set_multi_8 unimplemented !!! 873 #endif 874 875 /* 876 * Write `count' 1, 2, 4, or 8 byte value `val' to bus space described 877 * by tag/handle starting at `offset'. 878 */ 879 880 static __inline void bus_space_set_region_1(bus_space_tag_t tag, 881 bus_space_handle_t bsh, 882 bus_size_t offset, u_int8_t value, 883 size_t count); 884 static __inline void bus_space_set_region_2(bus_space_tag_t tag, 885 bus_space_handle_t bsh, 886 bus_size_t offset, u_int16_t value, 887 size_t count); 888 static __inline void bus_space_set_region_4(bus_space_tag_t tag, 889 bus_space_handle_t bsh, 890 bus_size_t offset, u_int32_t value, 891 size_t count); 892 893 static __inline void 894 bus_space_set_region_1(bus_space_tag_t tag, bus_space_handle_t bsh, 895 bus_size_t offset, u_int8_t value, size_t count) 896 { 897 bus_addr_t addr = bsh + offset; 898 899 #if defined(_I386_BUS_PIO_H_) 900 #if defined(_I386_BUS_MEMIO_H_) 901 if (tag == I386_BUS_SPACE_IO) 902 #endif 903 for (; count != 0; count--, addr++) 904 outb(addr, value); 905 #endif 906 #if defined(_I386_BUS_MEMIO_H_) 907 #if defined(_I386_BUS_PIO_H_) 908 else 909 #endif 910 for (; count != 0; count--, addr++) 911 *(volatile u_int8_t *)(addr) = value; 912 #endif 913 } 914 915 static __inline void 916 bus_space_set_region_2(bus_space_tag_t tag, bus_space_handle_t bsh, 917 bus_size_t offset, u_int16_t value, size_t count) 918 { 919 bus_addr_t addr = bsh + offset; 920 921 #if defined(_I386_BUS_PIO_H_) 922 #if defined(_I386_BUS_MEMIO_H_) 923 if (tag == I386_BUS_SPACE_IO) 924 #endif 925 for (; count != 0; count--, addr += 2) 926 outw(addr, value); 927 #endif 928 #if defined(_I386_BUS_MEMIO_H_) 929 #if defined(_I386_BUS_PIO_H_) 930 else 931 #endif 932 for (; count != 0; count--, addr += 2) 933 *(volatile u_int16_t *)(addr) = value; 934 #endif 935 } 936 937 static __inline void 938 bus_space_set_region_4(bus_space_tag_t tag, bus_space_handle_t bsh, 939 bus_size_t offset, u_int32_t value, size_t count) 940 { 941 bus_addr_t addr = bsh + offset; 942 943 #if defined(_I386_BUS_PIO_H_) 944 #if defined(_I386_BUS_MEMIO_H_) 945 if (tag == I386_BUS_SPACE_IO) 946 #endif 947 for (; count != 0; count--, addr += 4) 948 outl(addr, value); 949 #endif 950 #if defined(_I386_BUS_MEMIO_H_) 951 #if defined(_I386_BUS_PIO_H_) 952 else 953 #endif 954 for (; count != 0; count--, addr += 4) 955 *(volatile u_int32_t *)(addr) = value; 956 #endif 957 } 958 959 #if 0 /* Cause a link error for bus_space_set_region_8 */ 960 #define bus_space_set_region_8 !!! bus_space_set_region_8 unimplemented !!! 961 #endif 962 963 /* 964 * Copy `count' 1, 2, 4, or 8 byte values from bus space starting 965 * at tag/bsh1/off1 to bus space starting at tag/bsh2/off2. 966 */ 967 968 static __inline void bus_space_copy_region_1(bus_space_tag_t tag, 969 bus_space_handle_t bsh1, 970 bus_size_t off1, 971 bus_space_handle_t bsh2, 972 bus_size_t off2, size_t count); 973 974 static __inline void bus_space_copy_region_2(bus_space_tag_t tag, 975 bus_space_handle_t bsh1, 976 bus_size_t off1, 977 bus_space_handle_t bsh2, 978 bus_size_t off2, size_t count); 979 980 static __inline void bus_space_copy_region_4(bus_space_tag_t tag, 981 bus_space_handle_t bsh1, 982 bus_size_t off1, 983 bus_space_handle_t bsh2, 984 bus_size_t off2, size_t count); 985 986 static __inline void 987 bus_space_copy_region_1(bus_space_tag_t tag, bus_space_handle_t bsh1, 988 bus_size_t off1, bus_space_handle_t bsh2, 989 bus_size_t off2, size_t count) 990 { 991 bus_addr_t addr1 = bsh1 + off1; 992 bus_addr_t addr2 = bsh2 + off2; 993 994 #if defined(_I386_BUS_PIO_H_) 995 #if defined(_I386_BUS_MEMIO_H_) 996 if (tag == I386_BUS_SPACE_IO) 997 #endif 998 { 999 if (addr1 >= addr2) { 1000 /* src after dest: copy forward */ 1001 for (; count != 0; count--, addr1++, addr2++) 1002 outb(addr2, inb(addr1)); 1003 } else { 1004 /* dest after src: copy backwards */ 1005 for (addr1 += (count - 1), addr2 += (count - 1); 1006 count != 0; count--, addr1--, addr2--) 1007 outb(addr2, inb(addr1)); 1008 } 1009 } 1010 #endif 1011 #if defined(_I386_BUS_MEMIO_H_) 1012 #if defined(_I386_BUS_PIO_H_) 1013 else 1014 #endif 1015 { 1016 if (addr1 >= addr2) { 1017 /* src after dest: copy forward */ 1018 for (; count != 0; count--, addr1++, addr2++) 1019 *(volatile u_int8_t *)(addr2) = 1020 *(volatile u_int8_t *)(addr1); 1021 } else { 1022 /* dest after src: copy backwards */ 1023 for (addr1 += (count - 1), addr2 += (count - 1); 1024 count != 0; count--, addr1--, addr2--) 1025 *(volatile u_int8_t *)(addr2) = 1026 *(volatile u_int8_t *)(addr1); 1027 } 1028 } 1029 #endif 1030 } 1031 1032 static __inline void 1033 bus_space_copy_region_2(bus_space_tag_t tag, bus_space_handle_t bsh1, 1034 bus_size_t off1, bus_space_handle_t bsh2, 1035 bus_size_t off2, size_t count) 1036 { 1037 bus_addr_t addr1 = bsh1 + off1; 1038 bus_addr_t addr2 = bsh2 + off2; 1039 1040 #if defined(_I386_BUS_PIO_H_) 1041 #if defined(_I386_BUS_MEMIO_H_) 1042 if (tag == I386_BUS_SPACE_IO) 1043 #endif 1044 { 1045 if (addr1 >= addr2) { 1046 /* src after dest: copy forward */ 1047 for (; count != 0; count--, addr1 += 2, addr2 += 2) 1048 outw(addr2, inw(addr1)); 1049 } else { 1050 /* dest after src: copy backwards */ 1051 for (addr1 += 2 * (count - 1), addr2 += 2 * (count - 1); 1052 count != 0; count--, addr1 -= 2, addr2 -= 2) 1053 outw(addr2, inw(addr1)); 1054 } 1055 } 1056 #endif 1057 #if defined(_I386_BUS_MEMIO_H_) 1058 #if defined(_I386_BUS_PIO_H_) 1059 else 1060 #endif 1061 { 1062 if (addr1 >= addr2) { 1063 /* src after dest: copy forward */ 1064 for (; count != 0; count--, addr1 += 2, addr2 += 2) 1065 *(volatile u_int16_t *)(addr2) = 1066 *(volatile u_int16_t *)(addr1); 1067 } else { 1068 /* dest after src: copy backwards */ 1069 for (addr1 += 2 * (count - 1), addr2 += 2 * (count - 1); 1070 count != 0; count--, addr1 -= 2, addr2 -= 2) 1071 *(volatile u_int16_t *)(addr2) = 1072 *(volatile u_int16_t *)(addr1); 1073 } 1074 } 1075 #endif 1076 } 1077 1078 static __inline void 1079 bus_space_copy_region_4(bus_space_tag_t tag, bus_space_handle_t bsh1, 1080 bus_size_t off1, bus_space_handle_t bsh2, 1081 bus_size_t off2, size_t count) 1082 { 1083 bus_addr_t addr1 = bsh1 + off1; 1084 bus_addr_t addr2 = bsh2 + off2; 1085 1086 #if defined(_I386_BUS_PIO_H_) 1087 #if defined(_I386_BUS_MEMIO_H_) 1088 if (tag == I386_BUS_SPACE_IO) 1089 #endif 1090 { 1091 if (addr1 >= addr2) { 1092 /* src after dest: copy forward */ 1093 for (; count != 0; count--, addr1 += 4, addr2 += 4) 1094 outl(addr2, inl(addr1)); 1095 } else { 1096 /* dest after src: copy backwards */ 1097 for (addr1 += 4 * (count - 1), addr2 += 4 * (count - 1); 1098 count != 0; count--, addr1 -= 4, addr2 -= 4) 1099 outl(addr2, inl(addr1)); 1100 } 1101 } 1102 #endif 1103 #if defined(_I386_BUS_MEMIO_H_) 1104 #if defined(_I386_BUS_PIO_H_) 1105 else 1106 #endif 1107 { 1108 if (addr1 >= addr2) { 1109 /* src after dest: copy forward */ 1110 for (; count != 0; count--, addr1 += 4, addr2 += 4) 1111 *(volatile u_int32_t *)(addr2) = 1112 *(volatile u_int32_t *)(addr1); 1113 } else { 1114 /* dest after src: copy backwards */ 1115 for (addr1 += 4 * (count - 1), addr2 += 4 * (count - 1); 1116 count != 0; count--, addr1 -= 4, addr2 -= 4) 1117 *(volatile u_int32_t *)(addr2) = 1118 *(volatile u_int32_t *)(addr1); 1119 } 1120 } 1121 #endif 1122 } 1123 1124 #endif /* defined(_I386_BUS_PIO_H_) || defined(_I386_MEM_IO_H_) */ 1125 1126 #if 0 /* Cause a link error for bus_space_copy_8 */ 1127 #define bus_space_copy_region_8 !!! bus_space_copy_region_8 unimplemented !!! 1128 #endif 1129 1130 /* 1131 * Bus read/write barrier methods. 1132 * 1133 * void bus_space_barrier(bus_space_tag_t tag, bus_space_handle_t bsh, 1134 * bus_size_t offset, bus_size_t len, int flags); 1135 * 1136 * Note: the i386 does not currently require barriers, but we must 1137 * provide the flags to MI code. 1138 */ 1139 #define bus_space_barrier(t, h, o, l, f) \ 1140 ((void)((void)(t), (void)(h), (void)(o), (void)(l), (void)(f))) 1141 #define BUS_SPACE_BARRIER_READ 0x01 /* force read barrier */ 1142 #define BUS_SPACE_BARRIER_WRITE 0x02 /* force write barrier */ 1143 1144 /* 1145 * Flags used in various bus DMA methods. 1146 */ 1147 #define BUS_DMA_WAITOK 0x00 /* safe to sleep (pseudo-flag) */ 1148 #define BUS_DMA_NOWAIT 0x01 /* not safe to sleep */ 1149 #define BUS_DMA_ALLOCNOW 0x02 /* perform resource allocation now */ 1150 #define BUS_DMAMEM_NOSYNC 0x04 /* map memory to not require sync */ 1151 #define BUS_DMA_BUS1 0x10 /* placeholders for bus functions... */ 1152 #define BUS_DMA_BUS2 0x20 1153 #define BUS_DMA_BUS3 0x40 1154 #define BUS_DMA_BUS4 0x80 1155 1156 /* Forwards needed by prototypes below. */ 1157 struct mbuf; 1158 struct uio; 1159 1160 /* 1161 * bus_dmasync_op_t 1162 * 1163 * Operations performed by bus_dmamap_sync(). 1164 */ 1165 typedef enum { 1166 BUS_DMASYNC_PREREAD, 1167 BUS_DMASYNC_POSTREAD, 1168 BUS_DMASYNC_PREWRITE, 1169 BUS_DMASYNC_POSTWRITE 1170 } bus_dmasync_op_t; 1171 1172 /* 1173 * bus_dma_tag_t 1174 * 1175 * A machine-dependent opaque type describing the characteristics 1176 * of how to perform DMA mappings. This structure encapsultes 1177 * information concerning address and alignment restrictions, number 1178 * of S/G segments, amount of data per S/G segment, etc. 1179 */ 1180 typedef struct bus_dma_tag *bus_dma_tag_t; 1181 1182 /* 1183 * bus_dmamap_t 1184 * 1185 * DMA mapping instance information. 1186 */ 1187 typedef struct bus_dmamap *bus_dmamap_t; 1188 1189 /* 1190 * bus_dma_segment_t 1191 * 1192 * Describes a single contiguous DMA transaction. Values 1193 * are suitable for programming into DMA registers. 1194 */ 1195 typedef struct bus_dma_segment { 1196 bus_addr_t ds_addr; /* DMA address */ 1197 bus_size_t ds_len; /* length of transfer */ 1198 } bus_dma_segment_t; 1199 1200 /* 1201 * A function that returns 1 if the address cannot be accessed by 1202 * a device and 0 if it can be. 1203 */ 1204 typedef int bus_dma_filter_t(void *, bus_addr_t); 1205 1206 /* 1207 * Allocate a device specific dma_tag encapsulating the constraints of 1208 * the parent tag in addition to other restrictions specified: 1209 * 1210 * alignment: alignment for segments. 1211 * boundary: Boundary that segments cannot cross. 1212 * lowaddr: Low restricted address that cannot appear in a mapping. 1213 * highaddr: High restricted address that cannot appear in a mapping. 1214 * filtfunc: An optional function to further test if an address 1215 * within the range of lowaddr and highaddr cannot appear 1216 * in a mapping. 1217 * filtfuncarg: An argument that will be passed to filtfunc in addition 1218 * to the address to test. 1219 * maxsize: Maximum mapping size supported by this tag. 1220 * nsegments: Number of discontinuities allowed in maps. 1221 * maxsegsz: Maximum size of a segment in the map. 1222 * flags: Bus DMA flags. 1223 * dmat: A pointer to set to a valid dma tag should the return 1224 * value of this function indicate success. 1225 */ 1226 /* XXX Should probably allow specification of alignment */ 1227 int bus_dma_tag_create(bus_dma_tag_t parent, bus_size_t alignemnt, 1228 bus_size_t boundary, bus_addr_t lowaddr, 1229 bus_addr_t highaddr, bus_dma_filter_t *filtfunc, 1230 void *filtfuncarg, bus_size_t maxsize, int nsegments, 1231 bus_size_t maxsegsz, int flags, bus_dma_tag_t *dmat); 1232 1233 int bus_dma_tag_destroy(bus_dma_tag_t dmat); 1234 1235 /* 1236 * Allocate a handle for mapping from kva/uva/physical 1237 * address space into bus device space. 1238 */ 1239 int bus_dmamap_create(bus_dma_tag_t dmat, int flags, bus_dmamap_t *mapp); 1240 1241 /* 1242 * Destroy a handle for mapping from kva/uva/physical 1243 * address space into bus device space. 1244 */ 1245 int bus_dmamap_destroy(bus_dma_tag_t dmat, bus_dmamap_t map); 1246 1247 /* 1248 * Allocate a piece of memory that can be efficiently mapped into 1249 * bus device space based on the constraints lited in the dma tag. 1250 * A dmamap to for use with dmamap_load is also allocated. 1251 */ 1252 int bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr, int flags, 1253 bus_dmamap_t *mapp); 1254 1255 /* 1256 * Free a piece of memory and it's allociated dmamap, that was allocated 1257 * via bus_dmamem_alloc. 1258 */ 1259 void bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, bus_dmamap_t map); 1260 1261 /* 1262 * A function that processes a successfully loaded dma map or an error 1263 * from a delayed load map. 1264 */ 1265 typedef void bus_dmamap_callback_t(void *, bus_dma_segment_t *, int, int); 1266 1267 /* 1268 * Map the buffer buf into bus space using the dmamap map. 1269 */ 1270 int bus_dmamap_load(bus_dma_tag_t dmat, bus_dmamap_t map, void *buf, 1271 bus_size_t buflen, bus_dmamap_callback_t *callback, 1272 void *callback_arg, int flags); 1273 1274 /* 1275 * Perform a syncronization operation on the given map. 1276 */ 1277 void _bus_dmamap_sync(bus_dma_tag_t, bus_dmamap_t, bus_dmasync_op_t); 1278 #define bus_dmamap_sync(dmat, dmamap, op) \ 1279 if ((dmamap) != NULL) \ 1280 _bus_dmamap_sync(dmat, dmamap, op) 1281 1282 /* 1283 * Release the mapping held by map. 1284 */ 1285 void _bus_dmamap_unload(bus_dma_tag_t dmat, bus_dmamap_t map); 1286 #define bus_dmamap_unload(dmat, dmamap) \ 1287 if ((dmamap) != NULL) \ 1288 _bus_dmamap_unload(dmat, dmamap) 1289 1290 #endif /* _I386_BUS_H_ */ 1291