Print this page
de-linting of .s files
first


  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 
  27 /*
  28  * Copyright 2019 Joyent, Inc.
  29  */
  30 
  31 #if defined(lint) || defined(__lint)
  32 #include <sys/types.h>
  33 #include <sys/sunddi.h>
  34 #else
  35 #include <sys/asm_linkage.h>
  36 #include <sys/asm_misc.h>
  37 #include "assym.h"
  38 #endif
  39 
  40 #if defined(lint) || defined(__lint)
  41 
  42 /*ARGSUSED*/
  43 uint8_t
  44 ddi_get8(ddi_acc_handle_t handle, uint8_t *addr)
  45 {
  46         return (0);
  47 }
  48 
  49 /*ARGSUSED*/
  50 uint8_t
  51 ddi_mem_get8(ddi_acc_handle_t handle, uint8_t *addr)
  52 {
  53         return (0);
  54 }
  55 
  56 /*ARGSUSED*/
  57 uint8_t
  58 ddi_io_get8(ddi_acc_handle_t handle, uint8_t *dev_addr)
  59 {
  60         return (0);
  61 }
  62 
  63 /*ARGSUSED*/
  64 uint16_t
  65 ddi_get16(ddi_acc_handle_t handle, uint16_t *addr)
  66 {
  67         return (0);
  68 }
  69 
  70 /*ARGSUSED*/
  71 uint16_t
  72 ddi_mem_get16(ddi_acc_handle_t handle, uint16_t *addr)
  73 {
  74         return (0);
  75 }
  76 
  77 /*ARGSUSED*/
  78 uint16_t
  79 ddi_io_get16(ddi_acc_handle_t handle, uint16_t *dev_addr)
  80 {
  81         return (0);
  82 }
  83 
  84 /*ARGSUSED*/
  85 uint32_t
  86 ddi_get32(ddi_acc_handle_t handle, uint32_t *addr)
  87 {
  88         return (0);
  89 }
  90 
  91 /*ARGSUSED*/
  92 uint32_t
  93 ddi_mem_get32(ddi_acc_handle_t handle, uint32_t *addr)
  94 {
  95         return (0);
  96 }
  97 
  98 /*ARGSUSED*/
  99 uint32_t
 100 ddi_io_get32(ddi_acc_handle_t handle, uint32_t *dev_addr)
 101 {
 102         return (0);
 103 }
 104 
 105 /*ARGSUSED*/
 106 uint64_t
 107 ddi_get64(ddi_acc_handle_t handle, uint64_t *addr)
 108 {
 109         return (0);
 110 }
 111 
 112 /*ARGSUSED*/
 113 uint64_t
 114 ddi_mem_get64(ddi_acc_handle_t handle, uint64_t *addr)
 115 {
 116         return (0);
 117 }
 118 
 119 /*ARGSUSED*/
 120 void
 121 ddi_put8(ddi_acc_handle_t handle, uint8_t *addr, uint8_t value)
 122 {}
 123 
 124 /*ARGSUSED*/
 125 void
 126 ddi_mem_put8(ddi_acc_handle_t handle, uint8_t *dev_addr, uint8_t value)
 127 {}
 128 
 129 /*ARGSUSED*/
 130 void
 131 ddi_io_put8(ddi_acc_handle_t handle, uint8_t *dev_addr, uint8_t value)
 132 {}
 133 
 134 /*ARGSUSED*/
 135 void
 136 ddi_put16(ddi_acc_handle_t handle, uint16_t *addr, uint16_t value)
 137 {}
 138 
 139 /*ARGSUSED*/
 140 void
 141 ddi_mem_put16(ddi_acc_handle_t handle, uint16_t *dev_addr, uint16_t value)
 142 {}
 143 
 144 /*ARGSUSED*/
 145 void
 146 ddi_io_put16(ddi_acc_handle_t handle, uint16_t *dev_addr, uint16_t value)
 147 {}
 148 
 149 /*ARGSUSED*/
 150 void
 151 ddi_put32(ddi_acc_handle_t handle, uint32_t *addr, uint32_t value)
 152 {}
 153 
 154 /*ARGSUSED*/
 155 void
 156 ddi_mem_put32(ddi_acc_handle_t handle, uint32_t *dev_addr, uint32_t value)
 157 {}
 158 
 159 /*ARGSUSED*/
 160 void
 161 ddi_io_put32(ddi_acc_handle_t handle, uint32_t *dev_addr, uint32_t value)
 162 {}
 163 
 164 /*ARGSUSED*/
 165 void
 166 ddi_put64(ddi_acc_handle_t handle, uint64_t *addr, uint64_t value)
 167 {}
 168 
 169 /*ARGSUSED*/
 170 void
 171 ddi_mem_put64(ddi_acc_handle_t handle, uint64_t *dev_addr, uint64_t value)
 172 {}
 173 
 174 /*ARGSUSED*/
 175 void
 176 ddi_rep_get8(ddi_acc_handle_t handle, uint8_t *host_addr, uint8_t *dev_addr,
 177     size_t repcount, uint_t flags)
 178 {}
 179 
 180 /*ARGSUSED*/
 181 void
 182 ddi_rep_get16(ddi_acc_handle_t handle, uint16_t *host_addr, uint16_t *dev_addr,
 183     size_t repcount, uint_t flags)
 184 {}
 185 
 186 /*ARGSUSED*/
 187 void
 188 ddi_rep_get32(ddi_acc_handle_t handle, uint32_t *host_addr, uint32_t *dev_addr,
 189     size_t repcount, uint_t flags)
 190 {}
 191 
 192 /*ARGSUSED*/
 193 void
 194 ddi_rep_get64(ddi_acc_handle_t handle, uint64_t *host_addr, uint64_t *dev_addr,
 195     size_t repcount, uint_t flags)
 196 {}
 197 
 198 /*ARGSUSED*/
 199 void
 200 ddi_rep_put8(ddi_acc_handle_t handle, uint8_t *host_addr, uint8_t *dev_addr,
 201     size_t repcount, uint_t flags)
 202 {}
 203 
 204 /*ARGSUSED*/
 205 void
 206 ddi_rep_put16(ddi_acc_handle_t handle, uint16_t *host_addr, uint16_t *dev_addr,
 207     size_t repcount, uint_t flags)
 208 {}
 209 
 210 /*ARGSUSED*/
 211 void
 212 ddi_rep_put32(ddi_acc_handle_t handle, uint32_t *host_addr, uint32_t *dev_addr,
 213     size_t repcount, uint_t flags)
 214 {}
 215 
 216 /*ARGSUSED*/
 217 void
 218 ddi_rep_put64(ddi_acc_handle_t handle, uint64_t *host_addr, uint64_t *dev_addr,
 219     size_t repcount, uint_t flags)
 220 {}
 221 
 222 /*ARGSUSED*/
 223 void
 224 ddi_mem_rep_get8(ddi_acc_handle_t handle, uint8_t *host_addr,
 225     uint8_t *dev_addr, size_t repcount, uint_t flags)
 226 {}
 227 
 228 /*ARGSUSED*/
 229 void
 230 ddi_mem_rep_get16(ddi_acc_handle_t handle, uint16_t *host_addr,
 231     uint16_t *dev_addr, size_t repcount, uint_t flags)
 232 {}
 233 
 234 /*ARGSUSED*/
 235 void
 236 ddi_mem_rep_get32(ddi_acc_handle_t handle, uint32_t *host_addr,
 237     uint32_t *dev_addr, size_t repcount, uint_t flags)
 238 {}
 239 
 240 /*ARGSUSED*/
 241 void
 242 ddi_mem_rep_get64(ddi_acc_handle_t handle, uint64_t *host_addr,
 243     uint64_t *dev_addr, size_t repcount, uint_t flags)
 244 {}
 245 
 246 /*ARGSUSED*/
 247 void
 248 ddi_mem_rep_put8(ddi_acc_handle_t handle, uint8_t *host_addr,
 249     uint8_t *dev_addr, size_t repcount, uint_t flags)
 250 {}
 251 
 252 /*ARGSUSED*/
 253 void
 254 ddi_mem_rep_put16(ddi_acc_handle_t handle, uint16_t *host_addr,
 255     uint16_t *dev_addr, size_t repcount, uint_t flags)
 256 {}
 257 
 258 /*ARGSUSED*/
 259 void
 260 ddi_mem_rep_put32(ddi_acc_handle_t handle, uint32_t *host_addr,
 261     uint32_t *dev_addr, size_t repcount, uint_t flags)
 262 {}
 263 
 264 /*ARGSUSED*/
 265 void
 266 ddi_mem_rep_put64(ddi_acc_handle_t handle, uint64_t *host_addr,
 267     uint64_t *dev_addr, size_t repcount, uint_t flags)
 268 {}
 269 
 270 #else   /* lint */
 271 
 272 
 273 #if defined(__amd64)
 274 
 275         ENTRY(ddi_get8)
 276         ALTENTRY(ddi_getb)
 277         ALTENTRY(ddi_mem_getb)
 278         ALTENTRY(ddi_mem_get8)
 279         ALTENTRY(ddi_io_getb)
 280         ALTENTRY(ddi_io_get8)
 281         movl    ACC_ATTR(%rdi), %edx
 282         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %edx
 283         jne     1f
 284         movq    %rsi, %rdx
 285         xorq    %rax, %rax
 286         inb     (%dx)
 287         ret
 288 1:
 289         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %edx
 290         jne     2f
 291         movzbq  (%rsi), %rax
 292         ret
 293 2:
 294         movq    ACC_GETB(%rdi), %rax
 295         INDIRECT_JMP_REG(rax)
 296         SET_SIZE(ddi_get8)
 297         SET_SIZE(ddi_getb)
 298         SET_SIZE(ddi_mem_getb)
 299         SET_SIZE(ddi_mem_get8)
 300         SET_SIZE(ddi_io_getb)
 301         SET_SIZE(ddi_io_get8)
 302 
 303 #elif defined(__i386)
 304 
 305         ENTRY(ddi_get8)
 306         ALTENTRY(ddi_getb)
 307         ALTENTRY(ddi_mem_getb)
 308         ALTENTRY(ddi_mem_get8)
 309         ALTENTRY(ddi_io_getb)
 310         ALTENTRY(ddi_io_get8)
 311         movl    4(%esp), %eax
 312         movl    ACC_ATTR(%eax), %ecx
 313         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 314         jne     1f
 315         movl    8(%esp), %edx
 316         xorl    %eax, %eax
 317         inb     (%dx)
 318         ret
 319 1:
 320         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 321         jne     2f
 322         movl    8(%esp), %eax
 323         movzbl  (%eax), %eax
 324         ret
 325 2:
 326         jmp     *ACC_GETB(%eax)
 327         SET_SIZE(ddi_get8)
 328         SET_SIZE(ddi_getb)
 329         SET_SIZE(ddi_mem_getb)
 330         SET_SIZE(ddi_mem_get8)
 331         SET_SIZE(ddi_io_getb)
 332         SET_SIZE(ddi_io_get8)
 333 
 334 #endif  /* __i386 */
 335 
 336 #if defined(__amd64)
 337 
 338         ENTRY(ddi_get16)
 339         ALTENTRY(ddi_getw)
 340         ALTENTRY(ddi_mem_getw)
 341         ALTENTRY(ddi_mem_get16)
 342         ALTENTRY(ddi_io_getw)
 343         ALTENTRY(ddi_io_get16)
 344         movl    ACC_ATTR(%rdi), %edx
 345         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %edx
 346         jne     3f
 347         movq    %rsi, %rdx
 348         xorq    %rax, %rax
 349         inw     (%dx)
 350         ret
 351 3:
 352         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %edx
 353         jne     4f
 354         movzwq  (%rsi), %rax
 355         ret
 356 4:
 357         movq    ACC_GETW(%rdi), %rax
 358         INDIRECT_JMP_REG(rax)
 359         SET_SIZE(ddi_get16)
 360         SET_SIZE(ddi_getw)
 361         SET_SIZE(ddi_mem_getw)
 362         SET_SIZE(ddi_mem_get16)
 363         SET_SIZE(ddi_io_getw)
 364         SET_SIZE(ddi_io_get16)
 365 
 366 #elif defined(__i386)
 367 
 368         ENTRY(ddi_get16)
 369         ALTENTRY(ddi_getw)
 370         ALTENTRY(ddi_mem_getw)
 371         ALTENTRY(ddi_mem_get16)
 372         ALTENTRY(ddi_io_getw)
 373         ALTENTRY(ddi_io_get16)
 374         movl    4(%esp), %eax
 375         movl    ACC_ATTR(%eax), %ecx
 376         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 377         jne     3f
 378         movl    8(%esp), %edx
 379         xorl    %eax, %eax
 380         inw     (%dx)
 381         ret
 382 3:
 383         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 384         jne     4f
 385         movl    8(%esp), %eax
 386         movzwl  (%eax), %eax
 387         ret
 388 4:
 389         jmp     *ACC_GETW(%eax)
 390         SET_SIZE(ddi_get16)
 391         SET_SIZE(ddi_getw)
 392         SET_SIZE(ddi_mem_getw)
 393         SET_SIZE(ddi_mem_get16)
 394         SET_SIZE(ddi_io_getw)
 395         SET_SIZE(ddi_io_get16)
 396 
 397 #endif  /* __i386 */
 398 
 399 #if defined(__amd64)
 400 
 401         ENTRY(ddi_get32)
 402         ALTENTRY(ddi_getl)
 403         ALTENTRY(ddi_mem_getl)
 404         ALTENTRY(ddi_mem_get32)
 405         ALTENTRY(ddi_io_getl)
 406         ALTENTRY(ddi_io_get32)
 407         movl    ACC_ATTR(%rdi), %edx
 408         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %edx
 409         jne     5f
 410         movq    %rsi, %rdx
 411         inl     (%dx)
 412         ret
 413 5:
 414         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %edx
 415         jne     6f
 416         movl    (%rsi), %eax
 417         ret
 418 6:
 419         movq    ACC_GETL(%rdi), %rax
 420         INDIRECT_JMP_REG(rax)
 421         SET_SIZE(ddi_get32)
 422         SET_SIZE(ddi_getl)
 423         SET_SIZE(ddi_mem_getl)
 424         SET_SIZE(ddi_mem_get32)
 425         SET_SIZE(ddi_io_getl)
 426         SET_SIZE(ddi_io_get32)
 427 
 428 #elif defined(__i386)
 429 
 430         ENTRY(ddi_get32)
 431         ALTENTRY(ddi_getl)
 432         ALTENTRY(ddi_mem_getl)
 433         ALTENTRY(ddi_mem_get32)
 434         ALTENTRY(ddi_io_getl)
 435         ALTENTRY(ddi_io_get32)
 436         movl    4(%esp), %eax
 437         movl    ACC_ATTR(%eax), %ecx
 438         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 439         jne     5f
 440         movl    8(%esp), %edx
 441         inl     (%dx)
 442         ret
 443 5:
 444         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 445         jne     6f
 446         movl    8(%esp), %eax
 447         movl    (%eax), %eax
 448         ret
 449 6:
 450         jmp     *ACC_GETL(%eax)
 451         SET_SIZE(ddi_get32)
 452         SET_SIZE(ddi_getl)
 453         SET_SIZE(ddi_mem_getl)
 454         SET_SIZE(ddi_mem_get32)
 455         SET_SIZE(ddi_io_getl)
 456         SET_SIZE(ddi_io_get32)
 457 
 458 #endif  /* __i386 */
 459 
 460 #if defined(__amd64)
 461 
 462         ENTRY(ddi_get64)
 463         ALTENTRY(ddi_getll)
 464         ALTENTRY(ddi_mem_getll)
 465         ALTENTRY(ddi_mem_get64)
 466         movq    ACC_GETLL(%rdi), %rax
 467         INDIRECT_JMP_REG(rax)
 468         SET_SIZE(ddi_get64)
 469         SET_SIZE(ddi_getll)
 470         SET_SIZE(ddi_mem_getll)
 471         SET_SIZE(ddi_mem_get64)
 472 
 473 #elif defined(__i386)
 474 
 475         ENTRY(ddi_get64)
 476         ALTENTRY(ddi_getll)
 477         ALTENTRY(ddi_mem_getll)
 478         ALTENTRY(ddi_mem_get64)
 479         movl    4(%esp), %eax
 480         jmp     *ACC_GETLL(%eax)
 481         SET_SIZE(ddi_get64)
 482         SET_SIZE(ddi_getll)
 483         SET_SIZE(ddi_mem_getll)
 484         SET_SIZE(ddi_mem_get64)
 485 
 486 #endif  /* __i386 */
 487 
 488 #if defined(__amd64)
 489 
 490         ENTRY(ddi_put8)
 491         ALTENTRY(ddi_putb)
 492         ALTENTRY(ddi_mem_putb)
 493         ALTENTRY(ddi_mem_put8)
 494         ALTENTRY(ddi_io_putb)
 495         ALTENTRY(ddi_io_put8)
 496         movl    ACC_ATTR(%rdi), %ecx
 497         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 498         jne     7f
 499         movq    %rdx, %rax
 500         movq    %rsi, %rdx
 501         outb    (%dx)
 502         ret
 503 7:
 504         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 505         jne     8f
 506         movb    %dl, (%rsi)
 507         ret
 508 8:
 509         movq    ACC_PUTB(%rdi), %rax
 510         INDIRECT_JMP_REG(rax)
 511         SET_SIZE(ddi_put8)
 512         SET_SIZE(ddi_putb)
 513         SET_SIZE(ddi_mem_putb)
 514         SET_SIZE(ddi_mem_put8)
 515         SET_SIZE(ddi_io_putb)
 516         SET_SIZE(ddi_io_put8)
 517 
 518 #elif defined(__i386)
 519 
 520         ENTRY(ddi_put8)
 521         ALTENTRY(ddi_putb)
 522         ALTENTRY(ddi_mem_putb)
 523         ALTENTRY(ddi_mem_put8)
 524         ALTENTRY(ddi_io_putb)
 525         ALTENTRY(ddi_io_put8)
 526         movl    4(%esp), %eax
 527         movl    ACC_ATTR(%eax), %ecx
 528         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 529         jne     7f
 530         movl    12(%esp), %eax
 531         movl    8(%esp), %edx
 532         outb    (%dx)
 533         ret
 534 7:
 535         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 536         jne     8f
 537         movl    8(%esp), %eax
 538         movl    12(%esp), %ecx
 539         movb    %cl, (%eax)
 540         ret
 541 8:
 542         jmp     *ACC_PUTB(%eax)
 543         SET_SIZE(ddi_put8)
 544         SET_SIZE(ddi_putb)
 545         SET_SIZE(ddi_mem_putb)
 546         SET_SIZE(ddi_mem_put8)
 547         SET_SIZE(ddi_io_putb)
 548         SET_SIZE(ddi_io_put8)
 549 
 550 #endif  /* __i386 */
 551 
 552 #if defined(__amd64)
 553 
 554         ENTRY(ddi_put16)
 555         ALTENTRY(ddi_putw)
 556         ALTENTRY(ddi_mem_putw)
 557         ALTENTRY(ddi_mem_put16)
 558         ALTENTRY(ddi_io_putw)
 559         ALTENTRY(ddi_io_put16)
 560         movl    ACC_ATTR(%rdi), %ecx
 561         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 562         jne     8f
 563         movq    %rdx, %rax
 564         movq    %rsi, %rdx
 565         outw    (%dx)
 566         ret
 567 8:
 568         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 569         jne     9f
 570         movw    %dx, (%rsi)
 571         ret
 572 9:
 573         movq    ACC_PUTW(%rdi), %rax
 574         INDIRECT_JMP_REG(rax)
 575         SET_SIZE(ddi_put16)
 576         SET_SIZE(ddi_putw)
 577         SET_SIZE(ddi_mem_putw)
 578         SET_SIZE(ddi_mem_put16)
 579         SET_SIZE(ddi_io_putw)
 580         SET_SIZE(ddi_io_put16)
 581 
 582 #elif defined(__i386)
 583 
 584         ENTRY(ddi_put16)
 585         ALTENTRY(ddi_putw)
 586         ALTENTRY(ddi_mem_putw)
 587         ALTENTRY(ddi_mem_put16)
 588         ALTENTRY(ddi_io_putw)
 589         ALTENTRY(ddi_io_put16)
 590         movl    4(%esp), %eax
 591         movl    ACC_ATTR(%eax), %ecx
 592         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 593         jne     8f
 594         movl    12(%esp), %eax
 595         movl    8(%esp), %edx
 596         outw    (%dx)
 597         ret
 598 8:
 599         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 600         jne     9f
 601         movl    8(%esp), %eax
 602         movl    12(%esp), %ecx
 603         movw    %cx, (%eax)
 604         ret
 605 9:
 606         jmp     *ACC_PUTW(%eax)
 607         SET_SIZE(ddi_put16)
 608         SET_SIZE(ddi_putw)
 609         SET_SIZE(ddi_mem_putw)
 610         SET_SIZE(ddi_mem_put16)
 611         SET_SIZE(ddi_io_putw)
 612         SET_SIZE(ddi_io_put16)
 613 
 614 #endif  /* __i386 */
 615 
 616 #if defined(__amd64)
 617 
 618         ENTRY(ddi_put32)
 619         ALTENTRY(ddi_putl)
 620         ALTENTRY(ddi_mem_putl)
 621         ALTENTRY(ddi_mem_put32)
 622         ALTENTRY(ddi_io_putl)
 623         ALTENTRY(ddi_io_put32)
 624         movl    ACC_ATTR(%rdi), %ecx
 625         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 626         jne     8f
 627         movq    %rdx, %rax
 628         movq    %rsi, %rdx
 629         outl    (%dx)
 630         ret
 631 8:
 632         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 633         jne     9f
 634         movl    %edx, (%rsi)
 635         ret
 636 9:
 637         movq    ACC_PUTL(%rdi), %rax
 638         INDIRECT_JMP_REG(rax)
 639         SET_SIZE(ddi_put32)
 640         SET_SIZE(ddi_putl)
 641         SET_SIZE(ddi_mem_putl)
 642         SET_SIZE(ddi_mem_put32)
 643         SET_SIZE(ddi_io_putl)
 644         SET_SIZE(ddi_io_put32)
 645 
 646 #elif defined(__i386)
 647 
 648         ENTRY(ddi_put32)
 649         ALTENTRY(ddi_putl)
 650         ALTENTRY(ddi_mem_putl)
 651         ALTENTRY(ddi_mem_put32)
 652         ALTENTRY(ddi_io_putl)
 653         ALTENTRY(ddi_io_put32)
 654         movl    4(%esp), %eax
 655         movl    ACC_ATTR(%eax), %ecx
 656         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 657         jne     8f
 658         movl    12(%esp), %eax
 659         movl    8(%esp), %edx
 660         outl    (%dx)
 661         ret
 662 8:
 663         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 664         jne     9f
 665         movl    8(%esp), %eax
 666         movl    12(%esp), %ecx
 667         movl    %ecx, (%eax)
 668         ret
 669 9:
 670         jmp     *ACC_PUTL(%eax)
 671         SET_SIZE(ddi_put32)
 672         SET_SIZE(ddi_putl)
 673         SET_SIZE(ddi_mem_putl)
 674         SET_SIZE(ddi_mem_put32)
 675         SET_SIZE(ddi_io_putl)
 676         SET_SIZE(ddi_io_put32)
 677 
 678 #endif  /* __i386 */
 679 
 680 #if defined(__amd64)
 681 
 682         ENTRY(ddi_put64)
 683         ALTENTRY(ddi_putll)
 684         ALTENTRY(ddi_mem_putll)
 685         ALTENTRY(ddi_mem_put64)
 686         movq    ACC_PUTLL(%rdi), %rax
 687         INDIRECT_JMP_REG(rax)
 688         SET_SIZE(ddi_put64)
 689         SET_SIZE(ddi_putll)
 690         SET_SIZE(ddi_mem_putll)
 691         SET_SIZE(ddi_mem_put64)
 692 
 693 #elif defined(__i386)
 694 
 695         ENTRY(ddi_put64)
 696         ALTENTRY(ddi_putll)
 697         ALTENTRY(ddi_mem_putll)
 698         ALTENTRY(ddi_mem_put64)
 699         movl    4(%esp), %eax
 700         jmp     *ACC_PUTLL(%eax)
 701         SET_SIZE(ddi_put64)
 702         SET_SIZE(ddi_putll)
 703         SET_SIZE(ddi_mem_putll)
 704         SET_SIZE(ddi_mem_put64)
 705 
 706 #endif  /* __i386 */
 707 
 708 #if defined(__amd64)
 709 
 710         ENTRY(ddi_rep_get8)
 711         ALTENTRY(ddi_rep_getb)
 712         ALTENTRY(ddi_mem_rep_getb)
 713         ALTENTRY(ddi_mem_rep_get8)
 714         movq    ACC_REP_GETB(%rdi), %rax
 715         INDIRECT_JMP_REG(rax)
 716         SET_SIZE(ddi_rep_get8)
 717         SET_SIZE(ddi_rep_getb)
 718         SET_SIZE(ddi_mem_rep_getb)
 719         SET_SIZE(ddi_mem_rep_get8)
 720 
 721 #elif defined(__i386)
 722 
 723         ENTRY(ddi_rep_get8)
 724         ALTENTRY(ddi_rep_getb)
 725         ALTENTRY(ddi_mem_rep_getb)
 726         ALTENTRY(ddi_mem_rep_get8)
 727         movl    4(%esp), %eax
 728         jmp     *ACC_REP_GETB(%eax)
 729         SET_SIZE(ddi_rep_get8)
 730         SET_SIZE(ddi_rep_getb)
 731         SET_SIZE(ddi_mem_rep_getb)
 732         SET_SIZE(ddi_mem_rep_get8)
 733 
 734 #endif  /* __i386 */
 735 
 736 #if defined(__amd64)
 737 
 738         ENTRY(ddi_rep_get16)
 739         ALTENTRY(ddi_rep_getw)
 740         ALTENTRY(ddi_mem_rep_getw)
 741         ALTENTRY(ddi_mem_rep_get16)
 742         movq    ACC_REP_GETW(%rdi), %rax
 743         INDIRECT_JMP_REG(rax)
 744         SET_SIZE(ddi_rep_get16)
 745         SET_SIZE(ddi_rep_getw)
 746         SET_SIZE(ddi_mem_rep_getw)
 747         SET_SIZE(ddi_mem_rep_get16)
 748 
 749 #elif defined(__i386)
 750 
 751         ENTRY(ddi_rep_get16)
 752         ALTENTRY(ddi_rep_getw)
 753         ALTENTRY(ddi_mem_rep_getw)
 754         ALTENTRY(ddi_mem_rep_get16)
 755         movl    4(%esp), %eax
 756         jmp     *ACC_REP_GETW(%eax)
 757         SET_SIZE(ddi_rep_get16)
 758         SET_SIZE(ddi_rep_getw)
 759         SET_SIZE(ddi_mem_rep_getw)
 760         SET_SIZE(ddi_mem_rep_get16)
 761 
 762 #endif  /* __i386 */
 763 
 764 #if defined(__amd64)
 765 
 766         ENTRY(ddi_rep_get32)
 767         ALTENTRY(ddi_rep_getl)
 768         ALTENTRY(ddi_mem_rep_getl)
 769         ALTENTRY(ddi_mem_rep_get32)
 770         movq    ACC_REP_GETL(%rdi), %rax
 771         INDIRECT_JMP_REG(rax)
 772         SET_SIZE(ddi_rep_get32)
 773         SET_SIZE(ddi_rep_getl)
 774         SET_SIZE(ddi_mem_rep_getl)
 775         SET_SIZE(ddi_mem_rep_get32)
 776 
 777 #elif defined(__i386)
 778 
 779         ENTRY(ddi_rep_get32)
 780         ALTENTRY(ddi_rep_getl)
 781         ALTENTRY(ddi_mem_rep_getl)
 782         ALTENTRY(ddi_mem_rep_get32)
 783         movl    4(%esp), %eax
 784         jmp     *ACC_REP_GETL(%eax)
 785         SET_SIZE(ddi_rep_get32)
 786         SET_SIZE(ddi_rep_getl)
 787         SET_SIZE(ddi_mem_rep_getl)
 788         SET_SIZE(ddi_mem_rep_get32)
 789 
 790 #endif  /* __i386 */
 791 
 792 #if defined(__amd64)
 793 
 794         ENTRY(ddi_rep_get64)
 795         ALTENTRY(ddi_rep_getll)
 796         ALTENTRY(ddi_mem_rep_getll)
 797         ALTENTRY(ddi_mem_rep_get64)
 798         movq    ACC_REP_GETLL(%rdi), %rax
 799         INDIRECT_JMP_REG(rax)
 800         SET_SIZE(ddi_rep_get64)
 801         SET_SIZE(ddi_rep_getll)
 802         SET_SIZE(ddi_mem_rep_getll)
 803         SET_SIZE(ddi_mem_rep_get64)
 804 
 805 #elif defined(__i386)
 806 
 807         ENTRY(ddi_rep_get64)
 808         ALTENTRY(ddi_rep_getll)
 809         ALTENTRY(ddi_mem_rep_getll)
 810         ALTENTRY(ddi_mem_rep_get64)
 811         movl    4(%esp), %eax
 812         jmp     *ACC_REP_GETLL(%eax)
 813         SET_SIZE(ddi_rep_get64)
 814         SET_SIZE(ddi_rep_getll)
 815         SET_SIZE(ddi_mem_rep_getll)
 816         SET_SIZE(ddi_mem_rep_get64)
 817 
 818 #endif  /* __i386 */
 819 
 820 #if defined(__amd64)
 821 
 822         ENTRY(ddi_rep_put8)
 823         ALTENTRY(ddi_rep_putb)
 824         ALTENTRY(ddi_mem_rep_putb)
 825         ALTENTRY(ddi_mem_rep_put8)
 826         movq    ACC_REP_PUTB(%rdi), %rax
 827         INDIRECT_JMP_REG(rax)
 828         SET_SIZE(ddi_rep_put8)
 829         SET_SIZE(ddi_rep_putb)
 830         SET_SIZE(ddi_mem_rep_putb)
 831         SET_SIZE(ddi_mem_rep_put8)
 832 
 833 #elif defined(__i386)
 834 
 835         ENTRY(ddi_rep_put8)
 836         ALTENTRY(ddi_rep_putb)
 837         ALTENTRY(ddi_mem_rep_putb)
 838         ALTENTRY(ddi_mem_rep_put8)
 839         movl    4(%esp), %eax
 840         jmp     *ACC_REP_PUTB(%eax)
 841         SET_SIZE(ddi_rep_put8)
 842         SET_SIZE(ddi_rep_putb)
 843         SET_SIZE(ddi_mem_rep_putb)
 844         SET_SIZE(ddi_mem_rep_put8)
 845 
 846 #endif  /* __i386 */
 847 
 848 #if defined(__amd64)
 849 
 850         ENTRY(ddi_rep_put16)
 851         ALTENTRY(ddi_rep_putw)
 852         ALTENTRY(ddi_mem_rep_putw)
 853         ALTENTRY(ddi_mem_rep_put16)
 854         movq    ACC_REP_PUTW(%rdi), %rax
 855         INDIRECT_JMP_REG(rax)
 856         SET_SIZE(ddi_rep_put16)
 857         SET_SIZE(ddi_rep_putw)
 858         SET_SIZE(ddi_mem_rep_putw)
 859         SET_SIZE(ddi_mem_rep_put16)
 860 
 861 #elif defined(__i386)
 862 
 863         ENTRY(ddi_rep_put16)
 864         ALTENTRY(ddi_rep_putw)
 865         ALTENTRY(ddi_mem_rep_putw)
 866         ALTENTRY(ddi_mem_rep_put16)
 867         movl    4(%esp), %eax
 868         jmp     *ACC_REP_PUTW(%eax)
 869         SET_SIZE(ddi_rep_put16)
 870         SET_SIZE(ddi_rep_putw)
 871         SET_SIZE(ddi_mem_rep_putw)
 872         SET_SIZE(ddi_mem_rep_put16)
 873 
 874 #endif  /* __i386 */
 875 
 876 #if defined(__amd64)
 877 
 878         ENTRY(ddi_rep_put32)
 879         ALTENTRY(ddi_rep_putl)
 880         ALTENTRY(ddi_mem_rep_putl)
 881         ALTENTRY(ddi_mem_rep_put32)
 882         movq    ACC_REP_PUTL(%rdi), %rax
 883         INDIRECT_JMP_REG(rax)
 884         SET_SIZE(ddi_rep_put32)
 885         SET_SIZE(ddi_rep_putl)
 886         SET_SIZE(ddi_mem_rep_putl)
 887         SET_SIZE(ddi_mem_rep_put32)
 888 
 889 #elif defined(__i386)
 890 
 891         ENTRY(ddi_rep_put32)
 892         ALTENTRY(ddi_rep_putl)
 893         ALTENTRY(ddi_mem_rep_putl)
 894         ALTENTRY(ddi_mem_rep_put32)
 895         movl    4(%esp), %eax
 896         jmp     *ACC_REP_PUTL(%eax)
 897         SET_SIZE(ddi_rep_put32)
 898         SET_SIZE(ddi_rep_putl)
 899         SET_SIZE(ddi_mem_rep_putl)
 900         SET_SIZE(ddi_mem_rep_put32)
 901 
 902 #endif  /* __i386 */
 903 
 904 #if defined(__amd64)
 905 
 906         ENTRY(ddi_rep_put64)
 907         ALTENTRY(ddi_rep_putll)
 908         ALTENTRY(ddi_mem_rep_putll)
 909         ALTENTRY(ddi_mem_rep_put64)
 910         movq    ACC_REP_PUTLL(%rdi), %rax
 911         INDIRECT_JMP_REG(rax)
 912         SET_SIZE(ddi_rep_put64)
 913         SET_SIZE(ddi_rep_putll)
 914         SET_SIZE(ddi_mem_rep_putll)
 915         SET_SIZE(ddi_mem_rep_put64)
 916 
 917 #elif defined(__i386)
 918 
 919         ENTRY(ddi_rep_put64)
 920         ALTENTRY(ddi_rep_putll)
 921         ALTENTRY(ddi_mem_rep_putll)
 922         ALTENTRY(ddi_mem_rep_put64)
 923         movl    4(%esp), %eax
 924         jmp     *ACC_REP_PUTLL(%eax)
 925         SET_SIZE(ddi_rep_put64)
 926         SET_SIZE(ddi_rep_putll)
 927         SET_SIZE(ddi_mem_rep_putll)
 928         SET_SIZE(ddi_mem_rep_put64)
 929 
 930 #endif  /* __i386 */
 931 
 932 #endif /* lint */
 933 
 934 #if defined(lint) || defined(__lint)
 935 
 936 /*ARGSUSED*/
 937 uint8_t
 938 i_ddi_vaddr_get8(ddi_acc_impl_t *hdlp, uint8_t *addr)
 939 {
 940         return (*addr);
 941 }
 942 
 943 /*ARGSUSED*/
 944 uint16_t
 945 i_ddi_vaddr_get16(ddi_acc_impl_t *hdlp, uint16_t *addr)
 946 {
 947         return (*addr);
 948 }
 949 
 950 /*ARGSUSED*/
 951 uint32_t
 952 i_ddi_vaddr_get32(ddi_acc_impl_t *hdlp, uint32_t *addr)
 953 {
 954         return (*addr);
 955 }
 956 
 957 /*ARGSUSED*/
 958 uint64_t
 959 i_ddi_vaddr_get64(ddi_acc_impl_t *hdlp, uint64_t *addr)
 960 {
 961         return (*addr);
 962 }
 963 
 964 #else   /* lint */
 965 
 966 #if defined(__amd64)
 967 
 968         ENTRY(i_ddi_vaddr_get8)
 969         movzbq  (%rsi), %rax
 970         ret
 971         SET_SIZE(i_ddi_vaddr_get8)
 972 
 973 #elif defined(__i386)
 974 
 975         ENTRY(i_ddi_vaddr_get8)
 976         movl    8(%esp), %eax
 977         movzbl  (%eax), %eax
 978         ret
 979         SET_SIZE(i_ddi_vaddr_get8)
 980 
 981 #endif  /* __i386 */
 982 
 983 #if defined(__amd64)
 984 
 985         ENTRY(i_ddi_vaddr_get16)
 986         movzwq  (%rsi), %rax
 987         ret
 988         SET_SIZE(i_ddi_vaddr_get16)
 989 
 990 #elif defined(__i386)
 991 
 992         ENTRY(i_ddi_vaddr_get16)
 993         movl    8(%esp), %eax
 994         movzwl  (%eax), %eax
 995         ret
 996         SET_SIZE(i_ddi_vaddr_get16)
 997 
 998 #endif  /* __i386 */
 999 
1000 #if defined(__amd64)
1001 
1002         ENTRY(i_ddi_vaddr_get32)
1003         movl    (%rsi), %eax
1004         ret
1005         SET_SIZE(i_ddi_vaddr_get32)
1006 
1007 #elif defined(__i386)
1008 
1009         ENTRY(i_ddi_vaddr_get32)
1010         movl    8(%esp), %eax
1011         movl    (%eax), %eax
1012         ret
1013         SET_SIZE(i_ddi_vaddr_get32)
1014 
1015 #endif  /* __i386 */
1016 
1017 #if defined(__amd64)
1018 
1019         ENTRY(i_ddi_vaddr_get64)
1020         movq    (%rsi), %rax
1021         ret
1022         SET_SIZE(i_ddi_vaddr_get64)
1023 
1024 #elif defined(__i386)
1025 
1026         ENTRY(i_ddi_vaddr_get64)
1027         movl    8(%esp), %ecx
1028         movl    (%ecx), %eax
1029         movl    4(%ecx), %edx
1030         ret
1031         SET_SIZE(i_ddi_vaddr_get64)
1032 
1033 #endif  /* __i386 */
1034 
1035 #endif /* lint */
1036 
1037 
1038 #if defined(lint) || defined(__lint)
1039 
1040 /*ARGSUSED*/
1041 uint8_t
1042 i_ddi_io_get8(ddi_acc_impl_t *hdlp, uint8_t *addr)
1043 {
1044         return (0);
1045 }
1046 
1047 /*ARGSUSED*/
1048 uint16_t
1049 i_ddi_io_get16(ddi_acc_impl_t *hdlp, uint16_t *addr)
1050 {
1051         return (0);
1052 }
1053 
1054 /*ARGSUSED*/
1055 uint32_t
1056 i_ddi_io_get32(ddi_acc_impl_t *hdlp, uint32_t *addr)
1057 {
1058         return (0);
1059 }
1060 
1061 #else   /* lint */
1062 
1063 #if defined(__amd64)
1064 
1065         ENTRY(i_ddi_io_get8)
1066         movq    %rsi, %rdx
1067         inb     (%dx)
1068         movzbq  %al, %rax
1069         ret
1070         SET_SIZE(i_ddi_io_get8)
1071 
1072 #elif defined(__i386)
1073 
1074         ENTRY(i_ddi_io_get8)
1075         movl    8(%esp), %edx
1076         inb     (%dx)
1077         movzbl  %al, %eax
1078         ret
1079         SET_SIZE(i_ddi_io_get8)
1080 
1081 #endif  /* __i386 */
1082 
1083 #if defined(__amd64)
1084 
1085         ENTRY(i_ddi_io_get16)
1086         movq    %rsi, %rdx
1087         inw     (%dx)
1088         movzwq  %ax, %rax
1089         ret
1090         SET_SIZE(i_ddi_io_get16)
1091 
1092 #elif defined(__i386)
1093 
1094         ENTRY(i_ddi_io_get16)
1095         movl    8(%esp), %edx
1096         inw     (%dx)
1097         movzwl  %ax, %eax
1098         ret
1099         SET_SIZE(i_ddi_io_get16)
1100 
1101 #endif  /* __i386 */
1102 
1103 #if defined(__amd64)
1104 
1105         ENTRY(i_ddi_io_get32)
1106         movq    %rsi, %rdx
1107         inl     (%dx)
1108         ret
1109         SET_SIZE(i_ddi_io_get32)
1110 
1111 #elif defined(__i386)
1112 
1113         ENTRY(i_ddi_io_get32)
1114         movl    8(%esp), %edx
1115         inl     (%dx)
1116         ret
1117         SET_SIZE(i_ddi_io_get32)
1118 
1119 #endif  /* __i386 */
1120 
1121 #endif /* lint */
1122 
1123 #if defined(lint) || defined(__lint)
1124 
1125 /*ARGSUSED*/
1126 void
1127 i_ddi_vaddr_put8(ddi_acc_impl_t *hdlp, uint8_t *addr, uint8_t value)
1128 {
1129         *addr = value;
1130 }
1131 
1132 /*ARGSUSED*/
1133 void
1134 i_ddi_vaddr_put16(ddi_acc_impl_t *hdlp, uint16_t *addr, uint16_t value)
1135 {
1136         *addr = value;
1137 }
1138 
1139 /*ARGSUSED*/
1140 void
1141 i_ddi_vaddr_put32(ddi_acc_impl_t *hdlp, uint32_t *addr, uint32_t value)
1142 {
1143         *(uint32_t *)addr = value;
1144 }
1145 
1146 /*ARGSUSED*/
1147 void
1148 i_ddi_vaddr_put64(ddi_acc_impl_t *hdlp, uint64_t *addr, uint64_t value)
1149 {
1150         *addr = value;
1151 }
1152 
1153 #else   /* lint */
1154 
1155 #if defined(__amd64)
1156 
1157         ENTRY(i_ddi_vaddr_put8)
1158         movb    %dl, (%rsi)
1159         ret
1160         SET_SIZE(i_ddi_vaddr_put8)
1161 
1162 #elif defined(__i386)
1163 
1164         ENTRY(i_ddi_vaddr_put8)
1165         movl    8(%esp), %eax
1166         movb    12(%esp), %cl
1167         movb    %cl, (%eax)
1168         ret
1169         SET_SIZE(i_ddi_vaddr_put8)
1170 
1171 #endif  /* __i386 */
1172 
1173 #if defined(__amd64)
1174 
1175         ENTRY(i_ddi_vaddr_put16)
1176         movw    %dx, (%rsi)
1177         ret
1178         SET_SIZE(i_ddi_vaddr_put16)
1179 
1180 #elif defined(__i386)
1181 
1182         ENTRY(i_ddi_vaddr_put16)
1183         movl    8(%esp), %eax
1184         movl    12(%esp), %ecx
1185         movw    %cx, (%eax)
1186         ret
1187         SET_SIZE(i_ddi_vaddr_put16)
1188 
1189 #endif  /* __i386 */
1190 
1191 #if defined(__amd64)
1192 
1193         ENTRY(i_ddi_vaddr_put32)
1194         movl    %edx, (%rsi)
1195         ret
1196         SET_SIZE(i_ddi_vaddr_put32)
1197 
1198 #elif defined(__i386)
1199 
1200         ENTRY(i_ddi_vaddr_put32)
1201         movl    8(%esp), %eax
1202         movl    12(%esp), %ecx
1203         movl    %ecx, (%eax)
1204         ret
1205         SET_SIZE(i_ddi_vaddr_put32)
1206 
1207 #endif  /* __i386 */
1208 
1209 #if defined(__amd64)
1210 
1211         ENTRY(i_ddi_vaddr_put64)
1212         movq    %rdx, (%rsi)
1213         ret
1214         SET_SIZE(i_ddi_vaddr_put64)
1215 
1216 #elif defined(__i386)
1217 
1218         ENTRY(i_ddi_vaddr_put64)
1219         movl    8(%esp), %ecx
1220         movl    12(%esp), %edx
1221         movl    16(%esp), %eax
1222         movl    %edx, (%ecx)
1223         movl    %eax, 4(%ecx)
1224         ret
1225         SET_SIZE(i_ddi_vaddr_put64)
1226 
1227 #endif  /* __i386 */
1228 
1229 #endif /* lint */
1230 
1231 #if defined(lint) || defined(__lint)
1232 
1233 /*ARGSUSED*/
1234 void
1235 i_ddi_io_put8(ddi_acc_impl_t *hdlp, uint8_t *addr, uint8_t value)
1236 {}
1237 
1238 /*ARGSUSED*/
1239 void
1240 i_ddi_io_put16(ddi_acc_impl_t *hdlp, uint16_t *addr, uint16_t value)
1241 {}
1242 
1243 /*ARGSUSED*/
1244 void
1245 i_ddi_io_put32(ddi_acc_impl_t *hdlp, uint32_t *addr, uint32_t value)
1246 {}
1247 
1248 #else   /* lint */
1249 
1250 #if defined(__amd64)
1251 
1252         ENTRY(i_ddi_io_put8)
1253         movq    %rdx, %rax
1254         movq    %rsi, %rdx
1255         outb    (%dx)
1256         ret
1257         SET_SIZE(i_ddi_io_put8)
1258 
1259 #elif defined(__i386)
1260 
1261         ENTRY(i_ddi_io_put8)
1262         movl    12(%esp), %eax
1263         movl    8(%esp), %edx
1264         outb    (%dx)
1265         ret
1266         SET_SIZE(i_ddi_io_put8)
1267 
1268 #endif  /* __i386 */
1269 
1270 #if defined(__amd64)
1271 
1272         ENTRY(i_ddi_io_put16)
1273         movq    %rdx, %rax
1274         movq    %rsi, %rdx
1275         outw    (%dx)
1276         ret
1277         SET_SIZE(i_ddi_io_put16)
1278 
1279 #elif defined(__i386)
1280 
1281         ENTRY(i_ddi_io_put16)
1282         movl    12(%esp), %eax
1283         movl    8(%esp), %edx
1284         outw    (%dx)
1285         ret
1286         SET_SIZE(i_ddi_io_put16)
1287 
1288 #endif  /* __i386 */
1289 
1290 #if defined(__amd64)
1291 
1292         ENTRY(i_ddi_io_put32)
1293         movq    %rdx, %rax
1294         movq    %rsi, %rdx
1295         outl    (%dx)
1296         ret
1297         SET_SIZE(i_ddi_io_put32)
1298 
1299 #elif defined(__i386)
1300 
1301         ENTRY(i_ddi_io_put32)
1302         movl    12(%esp), %eax
1303         movl    8(%esp), %edx
1304         outl    (%dx)
1305         ret
1306         SET_SIZE(i_ddi_io_put32)
1307 
1308 #endif  /* __i386 */
1309 
1310 #endif /* lint */
1311 
1312 #if defined(lint) || defined(__lint)
1313 
1314 /*ARGSUSED*/
1315 void
1316 i_ddi_io_rep_get8(ddi_acc_impl_t *hdlp, uint8_t *host_addr,
1317         uint8_t *dev_addr, size_t repcount, uint_t flags)
1318 {}
1319 
1320 /*ARGSUSED*/
1321 void
1322 i_ddi_io_rep_get16(ddi_acc_impl_t *hdlp, uint16_t *host_addr,
1323         uint16_t *dev_addr, size_t repcount, uint_t flags)
1324 {}
1325 
1326 /*ARGSUSED*/
1327 void
1328 i_ddi_io_rep_get32(ddi_acc_impl_t *hdlp, uint32_t *host_addr,
1329         uint32_t *dev_addr, size_t repcount, uint_t flags)
1330 {}
1331 
1332 #else   /* lint */
1333 
1334 #if defined(__amd64)
1335 
1336         /*
1337          * Incoming arguments
1338          *
1339          * %rdi : hdlp
1340          * %rsi : host_addr
1341          * %rdx : dev_addr
1342          * %rcx : repcount
1343          * %r8  : flags
1344          *
1345          * This routine will destroy values in %rdx, %rsi, %rcx.
1346          */
1347         ENTRY(i_ddi_io_rep_get8)
1348 
1349         cmpq    $DDI_DEV_AUTOINCR, %r8
1350         je      gb_ioadv
1351         movq    %rsi, %rdi
1352         rep
1353         insb
1354         ret
1355 
1356 gb_ioadv:
1357         andq    %rcx, %rcx
1358         jz      gb_ioadv_done
1359 gb_ioadv2:
1360         inb     (%dx)
1361         movb    %al, (%rsi)
1362         incq    %rdx
1363         incq    %rsi
1364         decq    %rcx
1365         jg      gb_ioadv2
1366 
1367 gb_ioadv_done:
1368         rep;    ret     /* use 2 byte return instruction when branch target */
1369                         /* AMD Software Optimization Guide - Section 6.2 */
1370 
1371         SET_SIZE(i_ddi_io_rep_get8)
1372 
1373 #elif defined(__i386)
1374 
1375         ENTRY(i_ddi_io_rep_get8)
1376         pushl   %edi
1377 
1378         movl    12(%esp),%edi                   / get host_addr
1379         movl    16(%esp),%edx                   / get port
1380         movl    20(%esp),%ecx                   / get repcount
1381         cmpl    $DDI_DEV_AUTOINCR, 24(%esp)
1382         je      gb_ioadv
1383 
1384         rep
1385         insb
1386         popl    %edi
1387         ret
1388 
1389 gb_ioadv:
1390         andl    %ecx, %ecx
1391         jz      gb_ioadv_done
1392 gb_ioadv2:
1393         inb     (%dx)
1394         movb    %al,(%edi)
1395         incl    %edi
1396         incl    %edx
1397         decl    %ecx
1398         jg      gb_ioadv2
1399 
1400 gb_ioadv_done:
1401         popl    %edi
1402         ret
1403 
1404         SET_SIZE(i_ddi_io_rep_get8)
1405 
1406 #endif  /* __i386 */
1407 
1408 #if defined(__amd64)
1409 
1410         ENTRY(i_ddi_io_rep_get16)
1411 
1412         cmpq    $DDI_DEV_AUTOINCR, %r8
1413         je      gw_ioadv
1414 
1415         movq    %rsi, %rdi
1416         rep
1417         insw
1418         ret
1419 
1420 gw_ioadv:
1421         andq    %rcx, %rcx
1422         jz      gw_ioadv_done
1423 gw_ioadv2:
1424         inw     (%dx)
1425         movw    %ax,(%rsi)
1426         addq    $2, %rsi
1427         addq    $2, %rdx
1428         decq    %rcx
1429         jg      gw_ioadv2
1430 
1431 gw_ioadv_done:
1432         rep;    ret     /* use 2 byte return instruction when branch target */
1433                         /* AMD Software Optimization Guide - Section 6.2 */
1434         SET_SIZE(i_ddi_io_rep_get16)
1435 
1436 #elif defined(__i386)
1437 
1438         ENTRY(i_ddi_io_rep_get16)
1439         pushl   %edi
1440 
1441         movl    12(%esp),%edi                   / get host_addr
1442         movl    16(%esp),%edx                   / get port
1443         movl    20(%esp),%ecx                   / get repcount
1444         cmpl    $DDI_DEV_AUTOINCR, 24(%esp)
1445         je      gw_ioadv
1446 
1447         rep
1448         insw
1449         popl    %edi
1450         ret
1451 
1452 gw_ioadv:
1453         andl    %ecx, %ecx
1454         jz      gw_ioadv_done
1455 gw_ioadv2:
1456         inw     (%dx)
1457         movw    %ax,(%edi)
1458         addl    $2, %edi
1459         addl    $2, %edx
1460         decl    %ecx
1461         jg      gw_ioadv2
1462 
1463 gw_ioadv_done:
1464         popl    %edi
1465         ret
1466         SET_SIZE(i_ddi_io_rep_get16)
1467 
1468 #endif  /* __i386 */
1469 
1470 #if defined(__amd64)
1471 
1472         ENTRY(i_ddi_io_rep_get32)
1473 
1474         cmpq    $DDI_DEV_AUTOINCR, %r8
1475         je      gl_ioadv
1476 
1477         movq    %rsi, %rdi
1478         rep
1479         insl
1480         ret
1481 
1482 gl_ioadv:
1483         andq    %rcx, %rcx
1484         jz      gl_ioadv_done
1485 gl_ioadv2:
1486         inl     (%dx)
1487         movl    %eax,(%rsi)
1488         addq    $4, %rsi
1489         addq    $4, %rdx
1490         decq    %rcx
1491         jg      gl_ioadv2
1492 
1493 gl_ioadv_done:
1494         rep;    ret     /* use 2 byte return instruction when branch target */
1495                         /* AMD Software Optimization Guide - Section 6.2 */
1496 
1497         SET_SIZE(i_ddi_io_rep_get32)
1498 
1499 
1500 #elif defined(__i386)
1501 
1502         ENTRY(i_ddi_io_rep_get32)
1503         pushl   %edi
1504 
1505         movl    12(%esp),%edi                   / get host_addr
1506         movl    16(%esp),%edx                   / get port
1507         movl    20(%esp),%ecx                   / get repcount
1508         cmpl    $DDI_DEV_AUTOINCR, 24(%esp)
1509         je      gl_ioadv
1510 
1511         rep
1512         insl
1513         popl    %edi
1514         ret
1515 
1516 gl_ioadv:
1517         andl    %ecx, %ecx
1518         jz      gl_ioadv_done
1519 gl_ioadv2:
1520         inl     (%dx)
1521         movl    %eax,(%edi)
1522         addl    $4, %edi
1523         addl    $4, %edx
1524         decl    %ecx
1525         jg      gl_ioadv2
1526 
1527 gl_ioadv_done:
1528         popl    %edi
1529         ret
1530 
1531         SET_SIZE(i_ddi_io_rep_get32)
1532 
1533 #endif  /* __i386 */
1534 
1535 #endif /* lint */
1536 
1537 #if defined(lint) || defined(__lint)
1538 
1539 /*ARGSUSED*/
1540 void
1541 i_ddi_io_rep_put8(ddi_acc_impl_t *hdlp, uint8_t *host_addr,
1542         uint8_t *dev_addr, size_t repcount, uint_t flags)
1543 {}
1544 
1545 /*ARGSUSED*/
1546 void
1547 i_ddi_io_rep_put16(ddi_acc_impl_t *hdlp, uint16_t *host_addr,
1548         uint16_t *dev_addr, size_t repcount, uint_t flags)
1549 {}
1550 
1551 /*ARGSUSED*/
1552 void
1553 i_ddi_io_rep_put32(ddi_acc_impl_t *hdlp, uint32_t *host_addr,
1554         uint32_t *dev_addr, size_t repcount, uint_t flags)
1555 {}
1556 
1557 #else   /* lint */
1558 
1559 #if defined(__amd64)
1560 
1561         /*
1562          * Incoming arguments
1563          *
1564          * %rdi : hdlp
1565          * %rsi : host_addr
1566          * %rdx : dev_addr
1567          * %rcx : repcount
1568          * %r8  : flags
1569          *
1570          * This routine will destroy values in %rdx, %rsi, %rcx.
1571          */
1572         ENTRY(i_ddi_io_rep_put8)
1573 
1574         cmpq    $DDI_DEV_AUTOINCR, %r8
1575         je      pb_ioadv
1576 
1577         movq    %rsi, %rdi
1578         rep
1579         outsb
1580         ret
1581 
1582 pb_ioadv:
1583         andq    %rcx, %rcx
1584         jz      pb_ioadv_done
1585 pb_ioadv2:
1586         movb    (%rsi), %al
1587         outb    (%dx)
1588         incq    %rsi
1589         incq    %rdx
1590         decq    %rcx
1591         jg      pb_ioadv2
1592 
1593 pb_ioadv_done:
1594         rep;    ret     /* use 2 byte return instruction when branch target */
1595                         /* AMD Software Optimization Guide - Section 6.2 */
1596         SET_SIZE(i_ddi_io_rep_put8)
1597 
1598 #elif defined(__i386)
1599 
1600         ENTRY(i_ddi_io_rep_put8)
1601         pushl   %esi
1602 
1603         movl    12(%esp),%esi                   / get host_addr
1604         movl    16(%esp),%edx                   / get port
1605         movl    20(%esp),%ecx                   / get repcount
1606         cmpl    $DDI_DEV_AUTOINCR, 24(%esp)
1607         je      pb_ioadv
1608 
1609         rep
1610         outsb
1611         popl    %esi
1612         ret
1613 
1614 pb_ioadv:
1615         andl    %ecx, %ecx
1616         jz      pb_ioadv_done
1617 pb_ioadv2:
1618         movb    (%esi), %al
1619         outb    (%dx)
1620         incl    %esi
1621         incl    %edx
1622         decl    %ecx
1623         jg      pb_ioadv2
1624 
1625 pb_ioadv_done:
1626         popl    %esi
1627         ret
1628         SET_SIZE(i_ddi_io_rep_put8)
1629 
1630 #endif  /* __i386 */
1631 
1632 #if defined(__amd64)
1633 
1634         ENTRY(i_ddi_io_rep_put16)
1635 
1636         cmpq    $DDI_DEV_AUTOINCR, %r8
1637         je      pw_ioadv
1638 
1639         movq    %rsi, %rdi
1640         rep
1641         outsw
1642         ret
1643 
1644 pw_ioadv:
1645         andq    %rcx, %rcx
1646         jz      pw_ioadv_done
1647 pw_ioadv2:
1648         movw    (%rsi), %ax
1649         outw    (%dx)
1650         addq    $2, %rsi
1651         addq    $2, %rdx
1652         decq    %rcx
1653         jg      pw_ioadv2
1654 
1655 pw_ioadv_done:
1656         rep;    ret     /* use 2 byte return instruction when branch target */
1657                         /* AMD Software Optimization Guide - Section 6.2 */
1658         SET_SIZE(i_ddi_io_rep_put16)
1659 
1660 #elif defined(__i386)
1661 
1662         ENTRY(i_ddi_io_rep_put16)
1663         pushl   %esi
1664 
1665         movl    12(%esp),%esi                   / get host_addr
1666         movl    16(%esp),%edx                   / get port
1667         movl    20(%esp),%ecx                   / get repcount
1668         cmpl    $DDI_DEV_AUTOINCR, 24(%esp)
1669         je      pw_ioadv
1670 
1671         rep
1672         outsw
1673         popl    %esi
1674         ret
1675 
1676 pw_ioadv:
1677         andl    %ecx, %ecx
1678         jz      pw_ioadv_done
1679 pw_ioadv2:
1680         movw    (%esi), %ax
1681         outw    (%dx)
1682         addl    $2, %esi
1683         addl    $2, %edx
1684         decl    %ecx
1685         jg      pw_ioadv2
1686 
1687 pw_ioadv_done:
1688         popl    %esi
1689         ret
1690         SET_SIZE(i_ddi_io_rep_put16)
1691 
1692 #endif  /* __i386 */
1693 
1694 #if defined(__amd64)
1695 
1696         ENTRY(i_ddi_io_rep_put32)
1697 
1698         cmpq    $DDI_DEV_AUTOINCR, %r8
1699         je      pl_ioadv
1700 
1701         movq    %rsi, %rdi
1702         rep
1703         outsl
1704         ret
1705 
1706 pl_ioadv:
1707         andq    %rcx, %rcx
1708         jz      pl_ioadv_done
1709 pl_ioadv2:
1710         movl    (%rsi), %eax
1711         outl    (%dx)
1712         addq    $4, %rsi
1713         addq    $4, %rdx
1714         decq    %rcx
1715         jg      pl_ioadv2
1716 
1717 pl_ioadv_done:
1718         rep;    ret     /* use 2 byte return instruction when branch target */
1719                         /* AMD Software Optimization Guide - Section 6.2 */
1720         SET_SIZE(i_ddi_io_rep_put32)
1721 
1722 #elif defined(__i386)
1723 
1724         ENTRY(i_ddi_io_rep_put32)
1725         pushl   %esi
1726 
1727         movl    12(%esp),%esi                   / get host_addr
1728         movl    16(%esp),%edx                   / get port
1729         movl    20(%esp),%ecx                   / get repcount
1730         cmpl    $DDI_DEV_AUTOINCR, 24(%esp)
1731         je      pl_ioadv
1732 
1733         rep
1734         outsl
1735         popl    %esi
1736         ret
1737 
1738 pl_ioadv:
1739         andl    %ecx, %ecx
1740         jz      pl_ioadv_done
1741 pl_ioadv2:
1742         movl    (%esi), %eax
1743         outl    (%dx)
1744         addl    $4, %esi
1745         addl    $4, %edx
1746         decl    %ecx
1747         jg      pl_ioadv2
1748 
1749 pl_ioadv_done:
1750         popl    %esi
1751         ret
1752         SET_SIZE(i_ddi_io_rep_put32)
1753 
1754 #endif  /* __i386 */
1755 
1756 #endif /* lint */


  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 
  27 /*
  28  * Copyright 2019 Joyent, Inc.
  29  */
  30 




  31 #include <sys/asm_linkage.h>
  32 #include <sys/asm_misc.h>
  33 #include "assym.h"

  34 











































































































































































































































  35         ENTRY(ddi_get8)
  36         ALTENTRY(ddi_getb)
  37         ALTENTRY(ddi_mem_getb)
  38         ALTENTRY(ddi_mem_get8)
  39         ALTENTRY(ddi_io_getb)
  40         ALTENTRY(ddi_io_get8)
  41         movl    ACC_ATTR(%rdi), %edx
  42         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %edx
  43         jne     1f
  44         movq    %rsi, %rdx
  45         xorq    %rax, %rax
  46         inb     (%dx)
  47         ret
  48 1:
  49         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %edx
  50         jne     2f
  51         movzbq  (%rsi), %rax
  52         ret
  53 2:
  54         movq    ACC_GETB(%rdi), %rax
  55         INDIRECT_JMP_REG(rax)
  56         SET_SIZE(ddi_get8)
  57         SET_SIZE(ddi_getb)
  58         SET_SIZE(ddi_mem_getb)
  59         SET_SIZE(ddi_mem_get8)
  60         SET_SIZE(ddi_io_getb)
  61         SET_SIZE(ddi_io_get8)
  62 

  63 

































  64         ENTRY(ddi_get16)
  65         ALTENTRY(ddi_getw)
  66         ALTENTRY(ddi_mem_getw)
  67         ALTENTRY(ddi_mem_get16)
  68         ALTENTRY(ddi_io_getw)
  69         ALTENTRY(ddi_io_get16)
  70         movl    ACC_ATTR(%rdi), %edx
  71         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %edx
  72         jne     3f
  73         movq    %rsi, %rdx
  74         xorq    %rax, %rax
  75         inw     (%dx)
  76         ret
  77 3:
  78         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %edx
  79         jne     4f
  80         movzwq  (%rsi), %rax
  81         ret
  82 4:
  83         movq    ACC_GETW(%rdi), %rax
  84         INDIRECT_JMP_REG(rax)
  85         SET_SIZE(ddi_get16)
  86         SET_SIZE(ddi_getw)
  87         SET_SIZE(ddi_mem_getw)
  88         SET_SIZE(ddi_mem_get16)
  89         SET_SIZE(ddi_io_getw)
  90         SET_SIZE(ddi_io_get16)
  91 

  92 

































  93         ENTRY(ddi_get32)
  94         ALTENTRY(ddi_getl)
  95         ALTENTRY(ddi_mem_getl)
  96         ALTENTRY(ddi_mem_get32)
  97         ALTENTRY(ddi_io_getl)
  98         ALTENTRY(ddi_io_get32)
  99         movl    ACC_ATTR(%rdi), %edx
 100         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %edx
 101         jne     5f
 102         movq    %rsi, %rdx
 103         inl     (%dx)
 104         ret
 105 5:
 106         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %edx
 107         jne     6f
 108         movl    (%rsi), %eax
 109         ret
 110 6:
 111         movq    ACC_GETL(%rdi), %rax
 112         INDIRECT_JMP_REG(rax)
 113         SET_SIZE(ddi_get32)
 114         SET_SIZE(ddi_getl)
 115         SET_SIZE(ddi_mem_getl)
 116         SET_SIZE(ddi_mem_get32)
 117         SET_SIZE(ddi_io_getl)
 118         SET_SIZE(ddi_io_get32)
 119 

 120 
































 121         ENTRY(ddi_get64)
 122         ALTENTRY(ddi_getll)
 123         ALTENTRY(ddi_mem_getll)
 124         ALTENTRY(ddi_mem_get64)
 125         movq    ACC_GETLL(%rdi), %rax
 126         INDIRECT_JMP_REG(rax)
 127         SET_SIZE(ddi_get64)
 128         SET_SIZE(ddi_getll)
 129         SET_SIZE(ddi_mem_getll)
 130         SET_SIZE(ddi_mem_get64)
 131 

 132 















 133         ENTRY(ddi_put8)
 134         ALTENTRY(ddi_putb)
 135         ALTENTRY(ddi_mem_putb)
 136         ALTENTRY(ddi_mem_put8)
 137         ALTENTRY(ddi_io_putb)
 138         ALTENTRY(ddi_io_put8)
 139         movl    ACC_ATTR(%rdi), %ecx
 140         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 141         jne     7f
 142         movq    %rdx, %rax
 143         movq    %rsi, %rdx
 144         outb    (%dx)
 145         ret
 146 7:
 147         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 148         jne     8f
 149         movb    %dl, (%rsi)
 150         ret
 151 8:
 152         movq    ACC_PUTB(%rdi), %rax
 153         INDIRECT_JMP_REG(rax)
 154         SET_SIZE(ddi_put8)
 155         SET_SIZE(ddi_putb)
 156         SET_SIZE(ddi_mem_putb)
 157         SET_SIZE(ddi_mem_put8)
 158         SET_SIZE(ddi_io_putb)
 159         SET_SIZE(ddi_io_put8)
 160 

 161 


































 162         ENTRY(ddi_put16)
 163         ALTENTRY(ddi_putw)
 164         ALTENTRY(ddi_mem_putw)
 165         ALTENTRY(ddi_mem_put16)
 166         ALTENTRY(ddi_io_putw)
 167         ALTENTRY(ddi_io_put16)
 168         movl    ACC_ATTR(%rdi), %ecx
 169         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 170         jne     8f
 171         movq    %rdx, %rax
 172         movq    %rsi, %rdx
 173         outw    (%dx)
 174         ret
 175 8:
 176         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 177         jne     9f
 178         movw    %dx, (%rsi)
 179         ret
 180 9:
 181         movq    ACC_PUTW(%rdi), %rax
 182         INDIRECT_JMP_REG(rax)
 183         SET_SIZE(ddi_put16)
 184         SET_SIZE(ddi_putw)
 185         SET_SIZE(ddi_mem_putw)
 186         SET_SIZE(ddi_mem_put16)
 187         SET_SIZE(ddi_io_putw)
 188         SET_SIZE(ddi_io_put16)
 189 

 190 


































 191         ENTRY(ddi_put32)
 192         ALTENTRY(ddi_putl)
 193         ALTENTRY(ddi_mem_putl)
 194         ALTENTRY(ddi_mem_put32)
 195         ALTENTRY(ddi_io_putl)
 196         ALTENTRY(ddi_io_put32)
 197         movl    ACC_ATTR(%rdi), %ecx
 198         cmpl    $_CONST(DDI_ACCATTR_IO_SPACE|DDI_ACCATTR_DIRECT), %ecx
 199         jne     8f
 200         movq    %rdx, %rax
 201         movq    %rsi, %rdx
 202         outl    (%dx)
 203         ret
 204 8:
 205         cmpl    $_CONST(DDI_ACCATTR_CPU_VADDR|DDI_ACCATTR_DIRECT), %ecx
 206         jne     9f
 207         movl    %edx, (%rsi)
 208         ret
 209 9:
 210         movq    ACC_PUTL(%rdi), %rax
 211         INDIRECT_JMP_REG(rax)
 212         SET_SIZE(ddi_put32)
 213         SET_SIZE(ddi_putl)
 214         SET_SIZE(ddi_mem_putl)
 215         SET_SIZE(ddi_mem_put32)
 216         SET_SIZE(ddi_io_putl)
 217         SET_SIZE(ddi_io_put32)
 218 

 219 


































 220         ENTRY(ddi_put64)
 221         ALTENTRY(ddi_putll)
 222         ALTENTRY(ddi_mem_putll)
 223         ALTENTRY(ddi_mem_put64)
 224         movq    ACC_PUTLL(%rdi), %rax
 225         INDIRECT_JMP_REG(rax)
 226         SET_SIZE(ddi_put64)
 227         SET_SIZE(ddi_putll)
 228         SET_SIZE(ddi_mem_putll)
 229         SET_SIZE(ddi_mem_put64)
 230 

 231 















 232         ENTRY(ddi_rep_get8)
 233         ALTENTRY(ddi_rep_getb)
 234         ALTENTRY(ddi_mem_rep_getb)
 235         ALTENTRY(ddi_mem_rep_get8)
 236         movq    ACC_REP_GETB(%rdi), %rax
 237         INDIRECT_JMP_REG(rax)
 238         SET_SIZE(ddi_rep_get8)
 239         SET_SIZE(ddi_rep_getb)
 240         SET_SIZE(ddi_mem_rep_getb)
 241         SET_SIZE(ddi_mem_rep_get8)
 242 

 243 















 244         ENTRY(ddi_rep_get16)
 245         ALTENTRY(ddi_rep_getw)
 246         ALTENTRY(ddi_mem_rep_getw)
 247         ALTENTRY(ddi_mem_rep_get16)
 248         movq    ACC_REP_GETW(%rdi), %rax
 249         INDIRECT_JMP_REG(rax)
 250         SET_SIZE(ddi_rep_get16)
 251         SET_SIZE(ddi_rep_getw)
 252         SET_SIZE(ddi_mem_rep_getw)
 253         SET_SIZE(ddi_mem_rep_get16)
 254 

 255 















 256         ENTRY(ddi_rep_get32)
 257         ALTENTRY(ddi_rep_getl)
 258         ALTENTRY(ddi_mem_rep_getl)
 259         ALTENTRY(ddi_mem_rep_get32)
 260         movq    ACC_REP_GETL(%rdi), %rax
 261         INDIRECT_JMP_REG(rax)
 262         SET_SIZE(ddi_rep_get32)
 263         SET_SIZE(ddi_rep_getl)
 264         SET_SIZE(ddi_mem_rep_getl)
 265         SET_SIZE(ddi_mem_rep_get32)
 266 

 267 















 268         ENTRY(ddi_rep_get64)
 269         ALTENTRY(ddi_rep_getll)
 270         ALTENTRY(ddi_mem_rep_getll)
 271         ALTENTRY(ddi_mem_rep_get64)
 272         movq    ACC_REP_GETLL(%rdi), %rax
 273         INDIRECT_JMP_REG(rax)
 274         SET_SIZE(ddi_rep_get64)
 275         SET_SIZE(ddi_rep_getll)
 276         SET_SIZE(ddi_mem_rep_getll)
 277         SET_SIZE(ddi_mem_rep_get64)
 278 

 279 















 280         ENTRY(ddi_rep_put8)
 281         ALTENTRY(ddi_rep_putb)
 282         ALTENTRY(ddi_mem_rep_putb)
 283         ALTENTRY(ddi_mem_rep_put8)
 284         movq    ACC_REP_PUTB(%rdi), %rax
 285         INDIRECT_JMP_REG(rax)
 286         SET_SIZE(ddi_rep_put8)
 287         SET_SIZE(ddi_rep_putb)
 288         SET_SIZE(ddi_mem_rep_putb)
 289         SET_SIZE(ddi_mem_rep_put8)
 290 

 291 















 292         ENTRY(ddi_rep_put16)
 293         ALTENTRY(ddi_rep_putw)
 294         ALTENTRY(ddi_mem_rep_putw)
 295         ALTENTRY(ddi_mem_rep_put16)
 296         movq    ACC_REP_PUTW(%rdi), %rax
 297         INDIRECT_JMP_REG(rax)
 298         SET_SIZE(ddi_rep_put16)
 299         SET_SIZE(ddi_rep_putw)
 300         SET_SIZE(ddi_mem_rep_putw)
 301         SET_SIZE(ddi_mem_rep_put16)
 302 

 303 















 304         ENTRY(ddi_rep_put32)
 305         ALTENTRY(ddi_rep_putl)
 306         ALTENTRY(ddi_mem_rep_putl)
 307         ALTENTRY(ddi_mem_rep_put32)
 308         movq    ACC_REP_PUTL(%rdi), %rax
 309         INDIRECT_JMP_REG(rax)
 310         SET_SIZE(ddi_rep_put32)
 311         SET_SIZE(ddi_rep_putl)
 312         SET_SIZE(ddi_mem_rep_putl)
 313         SET_SIZE(ddi_mem_rep_put32)
 314 

 315 















 316         ENTRY(ddi_rep_put64)
 317         ALTENTRY(ddi_rep_putll)
 318         ALTENTRY(ddi_mem_rep_putll)
 319         ALTENTRY(ddi_mem_rep_put64)
 320         movq    ACC_REP_PUTLL(%rdi), %rax
 321         INDIRECT_JMP_REG(rax)
 322         SET_SIZE(ddi_rep_put64)
 323         SET_SIZE(ddi_rep_putll)
 324         SET_SIZE(ddi_mem_rep_putll)
 325         SET_SIZE(ddi_mem_rep_put64)
 326 



















































 327         ENTRY(i_ddi_vaddr_get8)
 328         movzbq  (%rsi), %rax
 329         ret
 330         SET_SIZE(i_ddi_vaddr_get8)
 331 












 332         ENTRY(i_ddi_vaddr_get16)
 333         movzwq  (%rsi), %rax
 334         ret
 335         SET_SIZE(i_ddi_vaddr_get16)
 336 

 337 










 338         ENTRY(i_ddi_vaddr_get32)
 339         movl    (%rsi), %eax
 340         ret
 341         SET_SIZE(i_ddi_vaddr_get32)
 342 

 343 










 344         ENTRY(i_ddi_vaddr_get64)
 345         movq    (%rsi), %rax
 346         ret
 347         SET_SIZE(i_ddi_vaddr_get64)
 348 

 349 







































 350         ENTRY(i_ddi_io_get8)
 351         movq    %rsi, %rdx
 352         inb     (%dx)
 353         movzbq  %al, %rax
 354         ret
 355         SET_SIZE(i_ddi_io_get8)
 356 

 357 











 358         ENTRY(i_ddi_io_get16)
 359         movq    %rsi, %rdx
 360         inw     (%dx)
 361         movzwq  %ax, %rax
 362         ret
 363         SET_SIZE(i_ddi_io_get16)
 364 

 365 











 366         ENTRY(i_ddi_io_get32)
 367         movq    %rsi, %rdx
 368         inl     (%dx)
 369         ret
 370         SET_SIZE(i_ddi_io_get32)
 371 














































 372         ENTRY(i_ddi_vaddr_put8)
 373         movb    %dl, (%rsi)
 374         ret
 375         SET_SIZE(i_ddi_vaddr_put8)
 376 

 377 











 378         ENTRY(i_ddi_vaddr_put16)
 379         movw    %dx, (%rsi)
 380         ret
 381         SET_SIZE(i_ddi_vaddr_put16)
 382 

 383 











 384         ENTRY(i_ddi_vaddr_put32)
 385         movl    %edx, (%rsi)
 386         ret
 387         SET_SIZE(i_ddi_vaddr_put32)
 388 

 389 











 390         ENTRY(i_ddi_vaddr_put64)
 391         movq    %rdx, (%rsi)
 392         ret
 393         SET_SIZE(i_ddi_vaddr_put64)
 394 




































 395         ENTRY(i_ddi_io_put8)
 396         movq    %rdx, %rax
 397         movq    %rsi, %rdx
 398         outb    (%dx)
 399         ret
 400         SET_SIZE(i_ddi_io_put8)
 401 

 402 











 403         ENTRY(i_ddi_io_put16)
 404         movq    %rdx, %rax
 405         movq    %rsi, %rdx
 406         outw    (%dx)
 407         ret
 408         SET_SIZE(i_ddi_io_put16)
 409 

 410 











 411         ENTRY(i_ddi_io_put32)
 412         movq    %rdx, %rax
 413         movq    %rsi, %rdx
 414         outl    (%dx)
 415         ret
 416         SET_SIZE(i_ddi_io_put32)
 417 





































 418         /*
 419          * Incoming arguments
 420          *
 421          * %rdi : hdlp
 422          * %rsi : host_addr
 423          * %rdx : dev_addr
 424          * %rcx : repcount
 425          * %r8  : flags
 426          *
 427          * This routine will destroy values in %rdx, %rsi, %rcx.
 428          */
 429         ENTRY(i_ddi_io_rep_get8)
 430 
 431         cmpq    $DDI_DEV_AUTOINCR, %r8
 432         je      gb_ioadv
 433         movq    %rsi, %rdi
 434         rep
 435         insb
 436         ret
 437 
 438 gb_ioadv:
 439         andq    %rcx, %rcx
 440         jz      gb_ioadv_done
 441 gb_ioadv2:
 442         inb     (%dx)
 443         movb    %al, (%rsi)
 444         incq    %rdx
 445         incq    %rsi
 446         decq    %rcx
 447         jg      gb_ioadv2
 448 
 449 gb_ioadv_done:
 450         rep;    ret     /* use 2 byte return instruction when branch target */
 451                         /* AMD Software Optimization Guide - Section 6.2 */
 452 
 453         SET_SIZE(i_ddi_io_rep_get8)
 454 

 455 



































 456         ENTRY(i_ddi_io_rep_get16)
 457 
 458         cmpq    $DDI_DEV_AUTOINCR, %r8
 459         je      gw_ioadv
 460 
 461         movq    %rsi, %rdi
 462         rep
 463         insw
 464         ret
 465 
 466 gw_ioadv:
 467         andq    %rcx, %rcx
 468         jz      gw_ioadv_done
 469 gw_ioadv2:
 470         inw     (%dx)
 471         movw    %ax,(%rsi)
 472         addq    $2, %rsi
 473         addq    $2, %rdx
 474         decq    %rcx
 475         jg      gw_ioadv2
 476 
 477 gw_ioadv_done:
 478         rep;    ret     /* use 2 byte return instruction when branch target */
 479                         /* AMD Software Optimization Guide - Section 6.2 */
 480         SET_SIZE(i_ddi_io_rep_get16)
 481 

 482 


































 483         ENTRY(i_ddi_io_rep_get32)
 484 
 485         cmpq    $DDI_DEV_AUTOINCR, %r8
 486         je      gl_ioadv
 487 
 488         movq    %rsi, %rdi
 489         rep
 490         insl
 491         ret
 492 
 493 gl_ioadv:
 494         andq    %rcx, %rcx
 495         jz      gl_ioadv_done
 496 gl_ioadv2:
 497         inl     (%dx)
 498         movl    %eax,(%rsi)
 499         addq    $4, %rsi
 500         addq    $4, %rdx
 501         decq    %rcx
 502         jg      gl_ioadv2
 503 
 504 gl_ioadv_done:
 505         rep;    ret     /* use 2 byte return instruction when branch target */
 506                         /* AMD Software Optimization Guide - Section 6.2 */
 507 
 508         SET_SIZE(i_ddi_io_rep_get32)
 509 






























































 510         /*
 511          * Incoming arguments
 512          *
 513          * %rdi : hdlp
 514          * %rsi : host_addr
 515          * %rdx : dev_addr
 516          * %rcx : repcount
 517          * %r8  : flags
 518          *
 519          * This routine will destroy values in %rdx, %rsi, %rcx.
 520          */
 521         ENTRY(i_ddi_io_rep_put8)
 522 
 523         cmpq    $DDI_DEV_AUTOINCR, %r8
 524         je      pb_ioadv
 525 
 526         movq    %rsi, %rdi
 527         rep
 528         outsb
 529         ret
 530 
 531 pb_ioadv:
 532         andq    %rcx, %rcx
 533         jz      pb_ioadv_done
 534 pb_ioadv2:
 535         movb    (%rsi), %al
 536         outb    (%dx)
 537         incq    %rsi
 538         incq    %rdx
 539         decq    %rcx
 540         jg      pb_ioadv2
 541 
 542 pb_ioadv_done:
 543         rep;    ret     /* use 2 byte return instruction when branch target */
 544                         /* AMD Software Optimization Guide - Section 6.2 */
 545         SET_SIZE(i_ddi_io_rep_put8)
 546 




































 547         ENTRY(i_ddi_io_rep_put16)
 548 
 549         cmpq    $DDI_DEV_AUTOINCR, %r8
 550         je      pw_ioadv
 551 
 552         movq    %rsi, %rdi
 553         rep
 554         outsw
 555         ret
 556 
 557 pw_ioadv:
 558         andq    %rcx, %rcx
 559         jz      pw_ioadv_done
 560 pw_ioadv2:
 561         movw    (%rsi), %ax
 562         outw    (%dx)
 563         addq    $2, %rsi
 564         addq    $2, %rdx
 565         decq    %rcx
 566         jg      pw_ioadv2
 567 
 568 pw_ioadv_done:
 569         rep;    ret     /* use 2 byte return instruction when branch target */
 570                         /* AMD Software Optimization Guide - Section 6.2 */
 571         SET_SIZE(i_ddi_io_rep_put16)
 572 

 573 


































 574         ENTRY(i_ddi_io_rep_put32)
 575 
 576         cmpq    $DDI_DEV_AUTOINCR, %r8
 577         je      pl_ioadv
 578 
 579         movq    %rsi, %rdi
 580         rep
 581         outsl
 582         ret
 583 
 584 pl_ioadv:
 585         andq    %rcx, %rcx
 586         jz      pl_ioadv_done
 587 pl_ioadv2:
 588         movl    (%rsi), %eax
 589         outl    (%dx)
 590         addq    $4, %rsi
 591         addq    $4, %rdx
 592         decq    %rcx
 593         jg      pl_ioadv2
 594 
 595 pl_ioadv_done:
 596         rep;    ret     /* use 2 byte return instruction when branch target */
 597                         /* AMD Software Optimization Guide - Section 6.2 */
 598         SET_SIZE(i_ddi_io_rep_put32)
 599