sys/i386/include/cpufunc.h

   1 /*-
   2  * Copyright (c) 1993 The Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * $FreeBSD: src/sys/i386/include/cpufunc.h,v 1.96.2.3 2002/04/28 22:50:54 dwmalone Exp $
  34  * $DragonFly: src/sys/i386/include/Attic/cpufunc.h,v 1.2 2003/06/17 04:28:35 dillon Exp $
  35  */
  36
  37 /*
  38  * Functions to provide access to special i386 instructions.
  39  */
  40
  41 #ifndef _MACHINE_CPUFUNC_H_
  42 #define _MACHINE_CPUFUNC_H_
  43
  44 #include <sys/cdefs.h>
  45
  46 __BEGIN_DECLS
  47 #define readb(va)       (*(volatile u_int8_t *) (va))
  48 #define readw(va)       (*(volatile u_int16_t *) (va))
  49 #define readl(va)       (*(volatile u_int32_t *) (va))
  50
  51 #define writeb(va, d)   (*(volatile u_int8_t *) (va) = (d))
  52 #define writew(va, d)   (*(volatile u_int16_t *) (va) = (d))
  53 #define writel(va, d)   (*(volatile u_int32_t *) (va) = (d))
  54
  55 #ifdef  __GNUC__
  56
  57 #ifdef SMP
  58 #include <machine/lock.h>               /* XXX */
  59 #endif
  60
  61 #ifdef SWTCH_OPTIM_STATS
  62 extern  int     tlb_flush_count;        /* XXX */
  63 #endif
  64
  65 static __inline void
  66 breakpoint(void)
  67 {
  68         __asm __volatile("int $3");
  69 }
  70
  71 static __inline u_int
  72 bsfl(u_int mask)
  73 {
  74         u_int   result;
  75
  76         __asm __volatile("bsfl %0,%0" : "=r" (result) : "0" (mask));
  77         return (result);
  78 }
  79
  80 static __inline u_int
  81 bsrl(u_int mask)
  82 {
  83         u_int   result;
  84
  85         __asm __volatile("bsrl %0,%0" : "=r" (result) : "0" (mask));
  86         return (result);
  87 }
  88
  89 static __inline void
  90 disable_intr(void)
  91 {
  92         __asm __volatile("cli" : : : "memory");
  93 #ifdef SMP
  94         MPINTR_LOCK();
  95 #endif
  96 }
  97
  98 static __inline void
  99 do_cpuid(u_int ax, u_int *p)
 100 {
 101         __asm __volatile("cpuid"
 102                          : "=a" (p[0]), "=b" (p[1]), "=c" (p[2]), "=d" (p[3])
 103                          :  "0" (ax));
 104 }
 105
 106 static __inline void
 107 enable_intr(void)
 108 {
 109 #ifdef SMP
 110         MPINTR_UNLOCK();
 111 #endif
 112         __asm __volatile("sti");
 113 }
 114
 115 #define HAVE_INLINE_FFS
 116
 117 static __inline int
 118 ffs(int mask)
 119 {
 120         /*
 121          * Note that gcc-2's builtin ffs would be used if we didn't declare
 122          * this inline or turn off the builtin.  The builtin is faster but
 123          * broken in gcc-2.4.5 and slower but working in gcc-2.5 and later
 124          * versions.
 125          */
 126          return (mask == 0 ? mask : bsfl((u_int)mask) + 1);
 127 }
 128
 129 #define HAVE_INLINE_FLS
 130
 131 static __inline int
 132 fls(int mask)
 133 {
 134         return (mask == 0 ? mask : bsrl((u_int)mask) + 1);
 135 }
 136
 137 #if __GNUC__ < 2
 138
 139 #define inb(port)               inbv(port)
 140 #define outb(port, data)        outbv(port, data)
 141
 142 #else /* __GNUC >= 2 */
 143
 144 /*
 145  * The following complications are to get around gcc not having a
 146  * constraint letter for the range 0..255.  We still put "d" in the
 147  * constraint because "i" isn't a valid constraint when the port
 148  * isn't constant.  This only matters for -O0 because otherwise
 149  * the non-working version gets optimized away.
 150  *
 151  * Use an expression-statement instead of a conditional expression
 152  * because gcc-2.6.0 would promote the operands of the conditional
 153  * and produce poor code for "if ((inb(var) & const1) == const2)".
 154  *
 155  * The unnecessary test `(port) < 0x10000' is to generate a warning if
 156  * the `port' has type u_short or smaller.  Such types are pessimal.
 157  * This actually only works for signed types.  The range check is
 158  * careful to avoid generating warnings.
 159  */
 160 #define inb(port) __extension__ ({                                      \
 161         u_char  _data;                                                  \
 162         if (__builtin_constant_p(port) && ((port) & 0xffff) < 0x100     \
 163             && (port) < 0x10000)                                        \
 164                 _data = inbc(port);                                     \
 165         else                                                            \
 166                 _data = inbv(port);                                     \
 167         _data; })
 168
 169 #define outb(port, data) (                                              \
 170         __builtin_constant_p(port) && ((port) & 0xffff) < 0x100         \
 171         && (port) < 0x10000                                             \
 172         ? outbc(port, data) : outbv(port, data))
 173
 174 static __inline u_char
 175 inbc(u_int port)
 176 {
 177         u_char  data;
 178
 179         __asm __volatile("inb %1,%0" : "=a" (data) : "id" ((u_short)(port)));
 180         return (data);
 181 }
 182
 183 static __inline void
 184 outbc(u_int port, u_char data)
 185 {
 186         __asm __volatile("outb %0,%1" : : "a" (data), "id" ((u_short)(port)));
 187 }
 188
 189 #endif /* __GNUC <= 2 */
 190
 191 static __inline u_char
 192 inbv(u_int port)
 193 {
 194         u_char  data;
 195         /*
 196          * We use %%dx and not %1 here because i/o is done at %dx and not at
 197          * %edx, while gcc generates inferior code (movw instead of movl)
 198          * if we tell it to load (u_short) port.
 199          */
 200         __asm __volatile("inb %%dx,%0" : "=a" (data) : "d" (port));
 201         return (data);
 202 }
 203
 204 static __inline u_int
 205 inl(u_int port)
 206 {
 207         u_int   data;
 208
 209         __asm __volatile("inl %%dx,%0" : "=a" (data) : "d" (port));
 210         return (data);
 211 }
 212
 213 static __inline void
 214 insb(u_int port, void *addr, size_t cnt)
 215 {
 216         __asm __volatile("cld; rep; insb"
 217                          : "=D" (addr), "=c" (cnt)
 218                          :  "0" (addr),  "1" (cnt), "d" (port)
 219                          : "memory");
 220 }
 221
 222 static __inline void
 223 insw(u_int port, void *addr, size_t cnt)
 224 {
 225         __asm __volatile("cld; rep; insw"
 226                          : "=D" (addr), "=c" (cnt)
 227                          :  "0" (addr),  "1" (cnt), "d" (port)
 228                          : "memory");
 229 }
 230
 231 static __inline void
 232 insl(u_int port, void *addr, size_t cnt)
 233 {
 234         __asm __volatile("cld; rep; insl"
 235                          : "=D" (addr), "=c" (cnt)
 236                          :  "0" (addr),  "1" (cnt), "d" (port)
 237                          : "memory");
 238 }
 239
 240 static __inline void
 241 invd(void)
 242 {
 243         __asm __volatile("invd");
 244 }
 245
 246 #if defined(SMP) && defined(_KERNEL)
 247
 248 /*
 249  * When using APIC IPI's, invlpg() is not simply the invlpg instruction
 250  * (this is a bug) and the inlining cost is prohibitive since the call
 251  * executes into the IPI transmission system.
 252  */
 253 void    invlpg          __P((u_int addr));
 254 void    invltlb         __P((void));
 255
 256 static __inline void
 257 cpu_invlpg(void *addr)
 258 {
 259         __asm __volatile("invlpg %0" : : "m" (*(char *)addr) : "memory");
 260 }
 261
 262 static __inline void
 263 cpu_invltlb(void)
 264 {
 265         u_int   temp;
 266         /*
 267          * This should be implemented as load_cr3(rcr3()) when load_cr3()
 268          * is inlined.
 269          */
 270         __asm __volatile("movl %%cr3, %0; movl %0, %%cr3" : "=r" (temp)
 271                          : : "memory");
 272 #if defined(SWTCH_OPTIM_STATS)
 273         ++tlb_flush_count;
 274 #endif
 275 }
 276
 277 #else /* !(SMP && _KERNEL) */
 278
 279 static __inline void
 280 invlpg(u_int addr)
 281 {
 282         __asm __volatile("invlpg %0" : : "m" (*(char *)addr) : "memory");
 283 }
 284
 285 static __inline void
 286 invltlb(void)
 287 {
 288         u_int   temp;
 289         /*
 290          * This should be implemented as load_cr3(rcr3()) when load_cr3()
 291          * is inlined.
 292          */
 293         __asm __volatile("movl %%cr3, %0; movl %0, %%cr3" : "=r" (temp)
 294                          : : "memory");
 295 #ifdef SWTCH_OPTIM_STATS
 296         ++tlb_flush_count;
 297 #endif
 298 }
 299
 300 #endif /* SMP && _KERNEL */
 301
 302 static __inline u_short
 303 inw(u_int port)
 304 {
 305         u_short data;
 306
 307         __asm __volatile("inw %%dx,%0" : "=a" (data) : "d" (port));
 308         return (data);
 309 }
 310
 311 static __inline u_int
 312 loadandclear(volatile u_int *addr)
 313 {
 314         u_int   result;
 315
 316         __asm __volatile("xorl %0,%0; xchgl %1,%0"
 317                          : "=&r" (result) : "m" (*addr));
 318         return (result);
 319 }
 320
 321 static __inline void
 322 outbv(u_int port, u_char data)
 323 {
 324         u_char  al;
 325         /*
 326          * Use an unnecessary assignment to help gcc's register allocator.
 327          * This make a large difference for gcc-1.40 and a tiny difference
 328          * for gcc-2.6.0.  For gcc-1.40, al had to be ``asm("ax")'' for
 329          * best results.  gcc-2.6.0 can't handle this.
 330          */
 331         al = data;
 332         __asm __volatile("outb %0,%%dx" : : "a" (al), "d" (port));
 333 }
 334
 335 static __inline void
 336 outl(u_int port, u_int data)
 337 {
 338         /*
 339          * outl() and outw() aren't used much so we haven't looked at
 340          * possible micro-optimizations such as the unnecessary
 341          * assignment for them.
 342          */
 343         __asm __volatile("outl %0,%%dx" : : "a" (data), "d" (port));
 344 }
 345
 346 static __inline void
 347 outsb(u_int port, const void *addr, size_t cnt)
 348 {
 349         __asm __volatile("cld; rep; outsb"
 350                          : "=S" (addr), "=c" (cnt)
 351                          :  "0" (addr),  "1" (cnt), "d" (port));
 352 }
 353
 354 static __inline void
 355 outsw(u_int port, const void *addr, size_t cnt)
 356 {
 357         __asm __volatile("cld; rep; outsw"
 358                          : "=S" (addr), "=c" (cnt)
 359                          :  "0" (addr),  "1" (cnt), "d" (port));
 360 }
 361
 362 static __inline void
 363 outsl(u_int port, const void *addr, size_t cnt)
 364 {
 365         __asm __volatile("cld; rep; outsl"
 366                          : "=S" (addr), "=c" (cnt)
 367                          :  "0" (addr),  "1" (cnt), "d" (port));
 368 }
 369
 370 static __inline void
 371 outw(u_int port, u_short data)
 372 {
 373         __asm __volatile("outw %0,%%dx" : : "a" (data), "d" (port));
 374 }
 375
 376 static __inline u_int
 377 rcr2(void)
 378 {
 379         u_int   data;
 380
 381         __asm __volatile("movl %%cr2,%0" : "=r" (data));
 382         return (data);
 383 }
 384
 385 static __inline u_int
 386 read_eflags(void)
 387 {
 388         u_int   ef;
 389
 390         __asm __volatile("pushfl; popl %0" : "=r" (ef));
 391         return (ef);
 392 }
 393
 394 static __inline u_int64_t
 395 rdmsr(u_int msr)
 396 {
 397         u_int64_t rv;
 398
 399         __asm __volatile(".byte 0x0f, 0x32" : "=A" (rv) : "c" (msr));
 400         return (rv);
 401 }
 402
 403 static __inline u_int64_t
 404 rdpmc(u_int pmc)
 405 {
 406         u_int64_t rv;
 407
 408         __asm __volatile(".byte 0x0f, 0x33" : "=A" (rv) : "c" (pmc));
 409         return (rv);
 410 }
 411
 412 static __inline u_int64_t
 413 rdtsc(void)
 414 {
 415         u_int64_t rv;
 416
 417         __asm __volatile(".byte 0x0f, 0x31" : "=A" (rv));
 418         return (rv);
 419 }
 420
 421 static __inline void
 422 wbinvd(void)
 423 {
 424         __asm __volatile("wbinvd");
 425 }
 426
 427 static __inline void
 428 write_eflags(u_int ef)
 429 {
 430         __asm __volatile("pushl %0; popfl" : : "r" (ef));
 431 }
 432
 433 static __inline void
 434 wrmsr(u_int msr, u_int64_t newval)
 435 {
 436         __asm __volatile(".byte 0x0f, 0x30" : : "A" (newval), "c" (msr));
 437 }
 438
 439 static __inline u_int
 440 rfs(void)
 441 {
 442         u_int sel;
 443         __asm __volatile("movl %%fs,%0" : "=rm" (sel));
 444         return (sel);
 445 }
 446
 447 static __inline u_int
 448 rgs(void)
 449 {
 450         u_int sel;
 451         __asm __volatile("movl %%gs,%0" : "=rm" (sel));
 452         return (sel);
 453 }
 454
 455 static __inline void
 456 load_fs(u_int sel)
 457 {
 458         __asm __volatile("movl %0,%%fs" : : "rm" (sel));
 459 }
 460
 461 static __inline void
 462 load_gs(u_int sel)
 463 {
 464         __asm __volatile("movl %0,%%gs" : : "rm" (sel));
 465 }
 466
 467 static __inline u_int
 468 rdr0(void)
 469 {
 470         u_int   data;
 471         __asm __volatile("movl %%dr0,%0" : "=r" (data));
 472         return (data);
 473 }
 474
 475 static __inline void
 476 load_dr0(u_int sel)
 477 {
 478         __asm __volatile("movl %0,%%dr0" : : "r" (sel));
 479 }
 480
 481 static __inline u_int
 482 rdr1(void)
 483 {
 484         u_int   data;
 485         __asm __volatile("movl %%dr1,%0" : "=r" (data));
 486         return (data);
 487 }
 488
 489 static __inline void
 490 load_dr1(u_int sel)
 491 {
 492         __asm __volatile("movl %0,%%dr1" : : "r" (sel));
 493 }
 494
 495 static __inline u_int
 496 rdr2(void)
 497 {
 498         u_int   data;
 499         __asm __volatile("movl %%dr2,%0" : "=r" (data));
 500         return (data);
 501 }
 502
 503 static __inline void
 504 load_dr2(u_int sel)
 505 {
 506         __asm __volatile("movl %0,%%dr2" : : "r" (sel));
 507 }
 508
 509 static __inline u_int
 510 rdr3(void)
 511 {
 512         u_int   data;
 513         __asm __volatile("movl %%dr3,%0" : "=r" (data));
 514         return (data);
 515 }
 516
 517 static __inline void
 518 load_dr3(u_int sel)
 519 {
 520         __asm __volatile("movl %0,%%dr3" : : "r" (sel));
 521 }
 522
 523 static __inline u_int
 524 rdr4(void)
 525 {
 526         u_int   data;
 527         __asm __volatile("movl %%dr4,%0" : "=r" (data));
 528         return (data);
 529 }
 530
 531 static __inline void
 532 load_dr4(u_int sel)
 533 {
 534         __asm __volatile("movl %0,%%dr4" : : "r" (sel));
 535 }
 536
 537 static __inline u_int
 538 rdr5(void)
 539 {
 540         u_int   data;
 541         __asm __volatile("movl %%dr5,%0" : "=r" (data));
 542         return (data);
 543 }
 544
 545 static __inline void
 546 load_dr5(u_int sel)
 547 {
 548         __asm __volatile("movl %0,%%dr5" : : "r" (sel));
 549 }
 550
 551 static __inline u_int
 552 rdr6(void)
 553 {
 554         u_int   data;
 555         __asm __volatile("movl %%dr6,%0" : "=r" (data));
 556         return (data);
 557 }
 558
 559 static __inline void
 560 load_dr6(u_int sel)
 561 {
 562         __asm __volatile("movl %0,%%dr6" : : "r" (sel));
 563 }
 564
 565 static __inline u_int
 566 rdr7(void)
 567 {
 568         u_int   data;
 569         __asm __volatile("movl %%dr7,%0" : "=r" (data));
 570         return (data);
 571 }
 572
 573 static __inline void
 574 load_dr7(u_int sel)
 575 {
 576         __asm __volatile("movl %0,%%dr7" : : "r" (sel));
 577 }
 578
 579 #else /* !__GNUC__ */
 580
 581 int     breakpoint      __P((void));
 582 u_int   bsfl            __P((u_int mask));
 583 u_int   bsrl            __P((u_int mask));
 584 void    disable_intr    __P((void));
 585 void    do_cpuid        __P((u_int ax, u_int *p));
 586 void    enable_intr     __P((void));
 587 u_char  inb             __P((u_int port));
 588 u_int   inl             __P((u_int port));
 589 void    insb            __P((u_int port, void *addr, size_t cnt));
 590 void    insl            __P((u_int port, void *addr, size_t cnt));
 591 void    insw            __P((u_int port, void *addr, size_t cnt));
 592 void    invd            __P((void));
 593 void    invlpg          __P((u_int addr));
 594 void    invltlb         __P((void));
 595 u_short inw             __P((u_int port));
 596 u_int   loadandclear    __P((u_int *addr));
 597 void    outb            __P((u_int port, u_char data));
 598 void    outl            __P((u_int port, u_int data));
 599 void    outsb           __P((u_int port, void *addr, size_t cnt));
 600 void    outsl           __P((u_int port, void *addr, size_t cnt));
 601 void    outsw           __P((u_int port, void *addr, size_t cnt));
 602 void    outw            __P((u_int port, u_short data));
 603 u_int   rcr2            __P((void));
 604 u_int64_t rdmsr         __P((u_int msr));
 605 u_int64_t rdpmc         __P((u_int pmc));
 606 u_int64_t rdtsc         __P((void));
 607 u_int   read_eflags     __P((void));
 608 void    wbinvd          __P((void));
 609 void    write_eflags    __P((u_int ef));
 610 void    wrmsr           __P((u_int msr, u_int64_t newval));
 611 u_int   rfs             __P((void));
 612 u_int   rgs             __P((void));
 613 void    load_fs         __P((u_int sel));
 614 void    load_gs         __P((u_int sel));
 615
 616 #endif  /* __GNUC__ */
 617
 618 void    load_cr0        __P((u_int cr0));
 619 void    load_cr3        __P((u_int cr3));
 620 void    load_cr4        __P((u_int cr4));
 621 void    ltr             __P((u_short sel));
 622 u_int   rcr0            __P((void));
 623 u_int   rcr3            __P((void));
 624 u_int   rcr4            __P((void));
 625 void    reset_dbregs    __P((void));
 626 __END_DECLS
 627
 628 #endif /* !_MACHINE_CPUFUNC_H_ */