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.14 2005/08/28 15:27:05 hsu 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 "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 /*
  72  * Find the first 1 in mask, starting with bit 0 and return the
  73  * bit number.  If mask is 0 the result is undefined.
  74  */
  75 static __inline u_int
  76 bsfl(u_int mask)
  77 {
  78         u_int   result;
  79
  80         __asm __volatile("bsfl %0,%0" : "=r" (result) : "0" (mask));
  81         return (result);
  82 }
  83
  84 /*
  85  * Find the last 1 in mask, starting with bit 31 and return the
  86  * bit number.  If mask is 0 the result is undefined.
  87  */
  88 static __inline u_int
  89 bsrl(u_int mask)
  90 {
  91         u_int   result;
  92
  93         __asm __volatile("bsrl %0,%0" : "=r" (result) : "0" (mask));
  94         return (result);
  95 }
  96
  97 /*
  98  * Test and set the specified bit (1 << bit) in the integer.  The
  99  * previous value of the bit is returned (0 or 1).
 100  */
 101 static __inline int
 102 btsl(u_int *mask, int bit)
 103 {
 104         int result;
 105
 106         __asm __volatile("btsl %2,%1; movl $0,%0; adcl $0,%0" :
 107                     "=r"(result), "=m"(*mask) : "r" (bit));
 108         return(result);
 109 }
 110
 111 /*
 112  * Test and clear the specified bit (1 << bit) in the integer.  The
 113  * previous value of the bit is returned (0 or 1).
 114  */
 115 static __inline int
 116 btrl(u_int *mask, int bit)
 117 {
 118         int result;
 119
 120         __asm __volatile("btrl %2,%1; movl $0,%0; adcl $0,%0" :
 121                     "=r"(result), "=m"(*mask) : "r" (bit));
 122         return(result);
 123 }
 124
 125 static __inline void
 126 do_cpuid(u_int ax, u_int *p)
 127 {
 128         __asm __volatile("cpuid"
 129                          : "=a" (p[0]), "=b" (p[1]), "=c" (p[2]), "=d" (p[3])
 130                          :  "0" (ax));
 131 }
 132
 133 static __inline void
 134 cpu_disable_intr(void)
 135 {
 136         __asm __volatile("cli" : : : "memory");
 137 }
 138
 139 static __inline void
 140 cpu_enable_intr(void)
 141 {
 142         __asm __volatile("sti");
 143 }
 144
 145 /*
 146  * Cpu and compiler memory ordering fence.  mfence ensures strong read and
 147  * write ordering.
 148  *
 149  * A serializing or fence instruction is required here.  A locked bus
 150  * cycle on data for which we already own cache mastership is the most
 151  * portable.
 152  */
 153 static __inline void
 154 cpu_mfence(void)
 155 {
 156 #ifdef SMP
 157         __asm __volatile("lock; addl $0,(%%esp)" : : : "memory");
 158 #else
 159         __asm __volatile("" : : : "memory");
 160 #endif
 161 }
 162
 163 /*
 164  * cpu_lfence() ensures strong read ordering for reads issued prior
 165  * to the instruction verses reads issued afterwords.
 166  *
 167  * A serializing or fence instruction is required here.  A locked bus
 168  * cycle on data for which we already own cache mastership is the most
 169  * portable.
 170  */
 171 static __inline void
 172 cpu_lfence(void)
 173 {
 174 #ifdef SMP
 175         __asm __volatile("lock; addl $0,(%%esp)" : : : "memory");
 176 #else
 177         __asm __volatile("" : : : "memory");
 178 #endif
 179 }
 180
 181 /*
 182  * cpu_sfence() ensures strong write ordering for writes issued prior
 183  * to the instruction verses writes issued afterwords.  Writes are
 184  * ordered on intel cpus so we do not actually have to do anything.
 185  */
 186 static __inline void
 187 cpu_sfence(void)
 188 {
 189         __asm __volatile("" : : : "memory");
 190 }
 191
 192 /*
 193  * cpu_ccfence() prevents the compiler from reordering instructions, in
 194  * particular stores, relative to the current cpu.  Use cpu_sfence() if
 195  * you need to guarentee ordering by both the compiler and by the cpu.
 196  *
 197  * This also prevents the compiler from caching memory loads into local
 198  * variables across the routine.
 199  */
 200 static __inline void
 201 cpu_ccfence(void)
 202 {
 203         __asm __volatile("" : : : "memory");
 204 }
 205
 206 #ifdef _KERNEL
 207
 208 #define HAVE_INLINE_FFS
 209
 210 static __inline int
 211 ffs(int mask)
 212 {
 213         /*
 214          * Note that gcc-2's builtin ffs would be used if we didn't declare
 215          * this inline or turn off the builtin.  The builtin is faster but
 216          * broken in gcc-2.4.5 and slower but working in gcc-2.5 and later
 217          * versions.
 218          */
 219          return (mask == 0 ? mask : (int)bsfl((u_int)mask) + 1);
 220 }
 221
 222 #define HAVE_INLINE_FLS
 223
 224 static __inline int
 225 fls(int mask)
 226 {
 227         return (mask == 0 ? mask : (int) bsrl((u_int)mask) + 1);
 228 }
 229
 230 #endif /* _KERNEL */
 231
 232 /*
 233  * The following complications are to get around gcc not having a
 234  * constraint letter for the range 0..255.  We still put "d" in the
 235  * constraint because "i" isn't a valid constraint when the port
 236  * isn't constant.  This only matters for -O0 because otherwise
 237  * the non-working version gets optimized away.
 238  *
 239  * Use an expression-statement instead of a conditional expression
 240  * because gcc-2.6.0 would promote the operands of the conditional
 241  * and produce poor code for "if ((inb(var) & const1) == const2)".
 242  *
 243  * The unnecessary test `(port) < 0x10000' is to generate a warning if
 244  * the `port' has type u_short or smaller.  Such types are pessimal.
 245  * This actually only works for signed types.  The range check is
 246  * careful to avoid generating warnings.
 247  */
 248 #define inb(port) __extension__ ({                                      \
 249         u_char  _data;                                                  \
 250         if (__builtin_constant_p(port) && ((port) & 0xffff) < 0x100     \
 251             && (port) < 0x10000)                                        \
 252                 _data = inbc(port);                                     \
 253         else                                                            \
 254                 _data = inbv(port);                                     \
 255         _data; })
 256
 257 #define outb(port, data) (                                              \
 258         __builtin_constant_p(port) && ((port) & 0xffff) < 0x100         \
 259         && (port) < 0x10000                                             \
 260         ? outbc(port, data) : outbv(port, data))
 261
 262 static __inline u_char
 263 inbc(u_int port)
 264 {
 265         u_char  data;
 266
 267         __asm __volatile("inb %1,%0" : "=a" (data) : "id" ((u_short)(port)));
 268         return (data);
 269 }
 270
 271 static __inline void
 272 outbc(u_int port, u_char data)
 273 {
 274         __asm __volatile("outb %0,%1" : : "a" (data), "id" ((u_short)(port)));
 275 }
 276
 277 static __inline u_char
 278 inbv(u_int port)
 279 {
 280         u_char  data;
 281         /*
 282          * We use %%dx and not %1 here because i/o is done at %dx and not at
 283          * %edx, while gcc generates inferior code (movw instead of movl)
 284          * if we tell it to load (u_short) port.
 285          */
 286         __asm __volatile("inb %%dx,%0" : "=a" (data) : "d" (port));
 287         return (data);
 288 }
 289
 290 static __inline u_int
 291 inl(u_int port)
 292 {
 293         u_int   data;
 294
 295         __asm __volatile("inl %%dx,%0" : "=a" (data) : "d" (port));
 296         return (data);
 297 }
 298
 299 static __inline void
 300 insb(u_int port, void *addr, size_t cnt)
 301 {
 302         __asm __volatile("cld; rep; insb"
 303                          : "=D" (addr), "=c" (cnt)
 304                          :  "0" (addr),  "1" (cnt), "d" (port)
 305                          : "memory");
 306 }
 307
 308 static __inline void
 309 insw(u_int port, void *addr, size_t cnt)
 310 {
 311         __asm __volatile("cld; rep; insw"
 312                          : "=D" (addr), "=c" (cnt)
 313                          :  "0" (addr),  "1" (cnt), "d" (port)
 314                          : "memory");
 315 }
 316
 317 static __inline void
 318 insl(u_int port, void *addr, size_t cnt)
 319 {
 320         __asm __volatile("cld; rep; insl"
 321                          : "=D" (addr), "=c" (cnt)
 322                          :  "0" (addr),  "1" (cnt), "d" (port)
 323                          : "memory");
 324 }
 325
 326 static __inline void
 327 invd(void)
 328 {
 329         __asm __volatile("invd");
 330 }
 331
 332 #if defined(_KERNEL)
 333
 334 /*
 335  * If we are not a true-SMP box then smp_invltlb() is a NOP.  Note that this
 336  * will cause the invl*() functions to be equivalent to the cpu_invl*()
 337  * functions.
 338  */
 339 #ifdef SMP
 340 void smp_invltlb(void);
 341 #else
 342 #define smp_invltlb()
 343 #endif
 344
 345 /*
 346  * Invalidate a patricular VA on this cpu only
 347  */
 348 static __inline void
 349 cpu_invlpg(void *addr)
 350 {
 351         __asm __volatile("invlpg %0" : : "m" (*(char *)addr) : "memory");
 352 }
 353
 354 /*
 355  * Invalidate the TLB on this cpu only
 356  */
 357 static __inline void
 358 cpu_invltlb(void)
 359 {
 360         u_int   temp;
 361         /*
 362          * This should be implemented as load_cr3(rcr3()) when load_cr3()
 363          * is inlined.
 364          */
 365         __asm __volatile("movl %%cr3, %0; movl %0, %%cr3" : "=r" (temp)
 366                          : : "memory");
 367 #if defined(SWTCH_OPTIM_STATS)
 368         ++tlb_flush_count;
 369 #endif
 370 }
 371
 372 static __inline void
 373 cpu_nop(void)
 374 {
 375         __asm __volatile("rep; nop");
 376 }
 377
 378 #endif  /* _KERNEL */
 379
 380 static __inline u_short
 381 inw(u_int port)
 382 {
 383         u_short data;
 384
 385         __asm __volatile("inw %%dx,%0" : "=a" (data) : "d" (port));
 386         return (data);
 387 }
 388
 389 static __inline u_int
 390 loadandclear(volatile u_int *addr)
 391 {
 392         u_int   result;
 393
 394         __asm __volatile("xorl %0,%0; xchgl %1,%0"
 395                          : "=&r" (result) : "m" (*addr));
 396         return (result);
 397 }
 398
 399 static __inline void
 400 outbv(u_int port, u_char data)
 401 {
 402         u_char  al;
 403         /*
 404          * Use an unnecessary assignment to help gcc's register allocator.
 405          * This make a large difference for gcc-1.40 and a tiny difference
 406          * for gcc-2.6.0.  For gcc-1.40, al had to be ``asm("ax")'' for
 407          * best results.  gcc-2.6.0 can't handle this.
 408          */
 409         al = data;
 410         __asm __volatile("outb %0,%%dx" : : "a" (al), "d" (port));
 411 }
 412
 413 static __inline void
 414 outl(u_int port, u_int data)
 415 {
 416         /*
 417          * outl() and outw() aren't used much so we haven't looked at
 418          * possible micro-optimizations such as the unnecessary
 419          * assignment for them.
 420          */
 421         __asm __volatile("outl %0,%%dx" : : "a" (data), "d" (port));
 422 }
 423
 424 static __inline void
 425 outsb(u_int port, const void *addr, size_t cnt)
 426 {
 427         __asm __volatile("cld; rep; outsb"
 428                          : "=S" (addr), "=c" (cnt)
 429                          :  "0" (addr),  "1" (cnt), "d" (port));
 430 }
 431
 432 static __inline void
 433 outsw(u_int port, const void *addr, size_t cnt)
 434 {
 435         __asm __volatile("cld; rep; outsw"
 436                          : "=S" (addr), "=c" (cnt)
 437                          :  "0" (addr),  "1" (cnt), "d" (port));
 438 }
 439
 440 static __inline void
 441 outsl(u_int port, const void *addr, size_t cnt)
 442 {
 443         __asm __volatile("cld; rep; outsl"
 444                          : "=S" (addr), "=c" (cnt)
 445                          :  "0" (addr),  "1" (cnt), "d" (port));
 446 }
 447
 448 static __inline void
 449 outw(u_int port, u_short data)
 450 {
 451         __asm __volatile("outw %0,%%dx" : : "a" (data), "d" (port));
 452 }
 453
 454 static __inline u_int
 455 rcr2(void)
 456 {
 457         u_int   data;
 458
 459         __asm __volatile("movl %%cr2,%0" : "=r" (data));
 460         return (data);
 461 }
 462
 463 static __inline u_int
 464 read_eflags(void)
 465 {
 466         u_int   ef;
 467
 468         __asm __volatile("pushfl; popl %0" : "=r" (ef));
 469         return (ef);
 470 }
 471
 472 static __inline u_int64_t
 473 rdmsr(u_int msr)
 474 {
 475         u_int64_t rv;
 476
 477         __asm __volatile(".byte 0x0f, 0x32" : "=A" (rv) : "c" (msr));
 478         return (rv);
 479 }
 480
 481 static __inline u_int64_t
 482 rdpmc(u_int pmc)
 483 {
 484         u_int64_t rv;
 485
 486         __asm __volatile(".byte 0x0f, 0x33" : "=A" (rv) : "c" (pmc));
 487         return (rv);
 488 }
 489
 490 static __inline u_int64_t
 491 rdtsc(void)
 492 {
 493         u_int64_t rv;
 494
 495         __asm __volatile(".byte 0x0f, 0x31" : "=A" (rv));
 496         return (rv);
 497 }
 498
 499 static __inline void
 500 wbinvd(void)
 501 {
 502         __asm __volatile("wbinvd");
 503 }
 504
 505 static __inline void
 506 write_eflags(u_int ef)
 507 {
 508         __asm __volatile("pushl %0; popfl" : : "r" (ef));
 509 }
 510
 511 static __inline void
 512 wrmsr(u_int msr, u_int64_t newval)
 513 {
 514         __asm __volatile(".byte 0x0f, 0x30" : : "A" (newval), "c" (msr));
 515 }
 516
 517 static __inline u_int
 518 rfs(void)
 519 {
 520         u_int sel;
 521         __asm __volatile("movl %%fs,%0" : "=rm" (sel));
 522         return (sel);
 523 }
 524
 525 static __inline u_int
 526 rgs(void)
 527 {
 528         u_int sel;
 529         __asm __volatile("movl %%gs,%0" : "=rm" (sel));
 530         return (sel);
 531 }
 532
 533 static __inline void
 534 load_fs(u_int sel)
 535 {
 536         __asm __volatile("movl %0,%%fs" : : "rm" (sel));
 537 }
 538
 539 static __inline void
 540 load_gs(u_int sel)
 541 {
 542         __asm __volatile("movl %0,%%gs" : : "rm" (sel));
 543 }
 544
 545 static __inline u_int
 546 rdr0(void)
 547 {
 548         u_int   data;
 549         __asm __volatile("movl %%dr0,%0" : "=r" (data));
 550         return (data);
 551 }
 552
 553 static __inline void
 554 load_dr0(u_int sel)
 555 {
 556         __asm __volatile("movl %0,%%dr0" : : "r" (sel));
 557 }
 558
 559 static __inline u_int
 560 rdr1(void)
 561 {
 562         u_int   data;
 563         __asm __volatile("movl %%dr1,%0" : "=r" (data));
 564         return (data);
 565 }
 566
 567 static __inline void
 568 load_dr1(u_int sel)
 569 {
 570         __asm __volatile("movl %0,%%dr1" : : "r" (sel));
 571 }
 572
 573 static __inline u_int
 574 rdr2(void)
 575 {
 576         u_int   data;
 577         __asm __volatile("movl %%dr2,%0" : "=r" (data));
 578         return (data);
 579 }
 580
 581 static __inline void
 582 load_dr2(u_int sel)
 583 {
 584         __asm __volatile("movl %0,%%dr2" : : "r" (sel));
 585 }
 586
 587 static __inline u_int
 588 rdr3(void)
 589 {
 590         u_int   data;
 591         __asm __volatile("movl %%dr3,%0" : "=r" (data));
 592         return (data);
 593 }
 594
 595 static __inline void
 596 load_dr3(u_int sel)
 597 {
 598         __asm __volatile("movl %0,%%dr3" : : "r" (sel));
 599 }
 600
 601 static __inline u_int
 602 rdr4(void)
 603 {
 604         u_int   data;
 605         __asm __volatile("movl %%dr4,%0" : "=r" (data));
 606         return (data);
 607 }
 608
 609 static __inline void
 610 load_dr4(u_int sel)
 611 {
 612         __asm __volatile("movl %0,%%dr4" : : "r" (sel));
 613 }
 614
 615 static __inline u_int
 616 rdr5(void)
 617 {
 618         u_int   data;
 619         __asm __volatile("movl %%dr5,%0" : "=r" (data));
 620         return (data);
 621 }
 622
 623 static __inline void
 624 load_dr5(u_int sel)
 625 {
 626         __asm __volatile("movl %0,%%dr5" : : "r" (sel));
 627 }
 628
 629 static __inline u_int
 630 rdr6(void)
 631 {
 632         u_int   data;
 633         __asm __volatile("movl %%dr6,%0" : "=r" (data));
 634         return (data);
 635 }
 636
 637 static __inline void
 638 load_dr6(u_int sel)
 639 {
 640         __asm __volatile("movl %0,%%dr6" : : "r" (sel));
 641 }
 642
 643 static __inline u_int
 644 rdr7(void)
 645 {
 646         u_int   data;
 647         __asm __volatile("movl %%dr7,%0" : "=r" (data));
 648         return (data);
 649 }
 650
 651 static __inline void
 652 load_dr7(u_int sel)
 653 {
 654         __asm __volatile("movl %0,%%dr7" : : "r" (sel));
 655 }
 656
 657 #else /* !__GNUC__ */
 658
 659 int     breakpoint      (void);
 660 u_int   bsfl            (u_int mask);
 661 u_int   bsrl            (u_int mask);
 662 void    cpu_disable_intr (void);
 663 void    do_cpuid        (u_int ax, u_int *p);
 664 void    cpu_enable_intr (void);
 665 u_char  inb             (u_int port);
 666 u_int   inl             (u_int port);
 667 void    insb            (u_int port, void *addr, size_t cnt);
 668 void    insl            (u_int port, void *addr, size_t cnt);
 669 void    insw            (u_int port, void *addr, size_t cnt);
 670 void    invd            (void);
 671 u_short inw             (u_int port);
 672 u_int   loadandclear    (u_int *addr);
 673 void    outb            (u_int port, u_char data);
 674 void    outl            (u_int port, u_int data);
 675 void    outsb           (u_int port, void *addr, size_t cnt);
 676 void    outsl           (u_int port, void *addr, size_t cnt);
 677 void    outsw           (u_int port, void *addr, size_t cnt);
 678 void    outw            (u_int port, u_short data);
 679 u_int   rcr2            (void);
 680 u_int64_t rdmsr         (u_int msr);
 681 u_int64_t rdpmc         (u_int pmc);
 682 u_int64_t rdtsc         (void);
 683 u_int   read_eflags     (void);
 684 void    wbinvd          (void);
 685 void    write_eflags    (u_int ef);
 686 void    wrmsr           (u_int msr, u_int64_t newval);
 687 u_int   rfs             (void);
 688 u_int   rgs             (void);
 689 void    load_fs         (u_int sel);
 690 void    load_gs         (u_int sel);
 691
 692 #endif  /* __GNUC__ */
 693
 694 void    load_cr0        (u_int cr0);
 695 void    load_cr3        (u_int cr3);
 696 void    load_cr4        (u_int cr4);
 697 void    ltr             (u_short sel);
 698 u_int   rcr0            (void);
 699 u_int   rcr3            (void);
 700 u_int   rcr4            (void);
 701 void    reset_dbregs    (void);
 702 __END_DECLS
 703
 704 #endif /* !_MACHINE_CPUFUNC_H_ */