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.3 2003/06/28 02:09:49 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(_KERNEL)
 247
 248 /*
 249  * If we are not a true-SMP box then smp_invltlb() is a NOP.  Note that this
 250  * will cause the invl*() functions to be equivalent to the cpu_invl*()
 251  * functions.
 252  */
 253 #ifndef SMP
 254 #define smp_invltlb()
 255 #endif
 256
 257 /*
 258  * Invalidate a patricular VA on this cpu only
 259  */
 260 static __inline void
 261 cpu_invlpg(void *addr)
 262 {
 263         __asm __volatile("invlpg %0" : : "m" (*(char *)addr) : "memory");
 264 }
 265
 266 /*
 267  * Invalidate the TLB on this cpu only
 268  */
 269 static __inline void
 270 cpu_invltlb(void)
 271 {
 272         u_int   temp;
 273         /*
 274          * This should be implemented as load_cr3(rcr3()) when load_cr3()
 275          * is inlined.
 276          */
 277         __asm __volatile("movl %%cr3, %0; movl %0, %%cr3" : "=r" (temp)
 278                          : : "memory");
 279 #if defined(SWTCH_OPTIM_STATS)
 280         ++tlb_flush_count;
 281 #endif
 282 }
 283
 284 /*
 285  * Invalidate a patricular VA on all cpus
 286  */
 287 static __inline void
 288 invlpg(u_int addr)
 289 {
 290         __asm __volatile("invlpg %0" : : "m" (*(char *)addr) : "memory");
 291         smp_invltlb();
 292 }
 293
 294 /*
 295  * Invalidate the TLB on all cpus
 296  */
 297 static __inline void
 298 invltlb(void)
 299 {
 300         u_int   temp;
 301         /*
 302          * This should be implemented as load_cr3(rcr3()) when load_cr3()
 303          * is inlined.
 304          */
 305         __asm __volatile("movl %%cr3, %0; movl %0, %%cr3" : "=r" (temp)
 306                          : : "memory");
 307         smp_invltlb();
 308 #ifdef SWTCH_OPTIM_STATS
 309         ++tlb_flush_count;
 310 #endif
 311 }
 312
 313 #endif  /* _KERNEL */
 314
 315 static __inline u_short
 316 inw(u_int port)
 317 {
 318         u_short data;
 319
 320         __asm __volatile("inw %%dx,%0" : "=a" (data) : "d" (port));
 321         return (data);
 322 }
 323
 324 static __inline u_int
 325 loadandclear(volatile u_int *addr)
 326 {
 327         u_int   result;
 328
 329         __asm __volatile("xorl %0,%0; xchgl %1,%0"
 330                          : "=&r" (result) : "m" (*addr));
 331         return (result);
 332 }
 333
 334 static __inline void
 335 outbv(u_int port, u_char data)
 336 {
 337         u_char  al;
 338         /*
 339          * Use an unnecessary assignment to help gcc's register allocator.
 340          * This make a large difference for gcc-1.40 and a tiny difference
 341          * for gcc-2.6.0.  For gcc-1.40, al had to be ``asm("ax")'' for
 342          * best results.  gcc-2.6.0 can't handle this.
 343          */
 344         al = data;
 345         __asm __volatile("outb %0,%%dx" : : "a" (al), "d" (port));
 346 }
 347
 348 static __inline void
 349 outl(u_int port, u_int data)
 350 {
 351         /*
 352          * outl() and outw() aren't used much so we haven't looked at
 353          * possible micro-optimizations such as the unnecessary
 354          * assignment for them.
 355          */
 356         __asm __volatile("outl %0,%%dx" : : "a" (data), "d" (port));
 357 }
 358
 359 static __inline void
 360 outsb(u_int port, const void *addr, size_t cnt)
 361 {
 362         __asm __volatile("cld; rep; outsb"
 363                          : "=S" (addr), "=c" (cnt)
 364                          :  "0" (addr),  "1" (cnt), "d" (port));
 365 }
 366
 367 static __inline void
 368 outsw(u_int port, const void *addr, size_t cnt)
 369 {
 370         __asm __volatile("cld; rep; outsw"
 371                          : "=S" (addr), "=c" (cnt)
 372                          :  "0" (addr),  "1" (cnt), "d" (port));
 373 }
 374
 375 static __inline void
 376 outsl(u_int port, const void *addr, size_t cnt)
 377 {
 378         __asm __volatile("cld; rep; outsl"
 379                          : "=S" (addr), "=c" (cnt)
 380                          :  "0" (addr),  "1" (cnt), "d" (port));
 381 }
 382
 383 static __inline void
 384 outw(u_int port, u_short data)
 385 {
 386         __asm __volatile("outw %0,%%dx" : : "a" (data), "d" (port));
 387 }
 388
 389 static __inline u_int
 390 rcr2(void)
 391 {
 392         u_int   data;
 393
 394         __asm __volatile("movl %%cr2,%0" : "=r" (data));
 395         return (data);
 396 }
 397
 398 static __inline u_int
 399 read_eflags(void)
 400 {
 401         u_int   ef;
 402
 403         __asm __volatile("pushfl; popl %0" : "=r" (ef));
 404         return (ef);
 405 }
 406
 407 static __inline u_int64_t
 408 rdmsr(u_int msr)
 409 {
 410         u_int64_t rv;
 411
 412         __asm __volatile(".byte 0x0f, 0x32" : "=A" (rv) : "c" (msr));
 413         return (rv);
 414 }
 415
 416 static __inline u_int64_t
 417 rdpmc(u_int pmc)
 418 {
 419         u_int64_t rv;
 420
 421         __asm __volatile(".byte 0x0f, 0x33" : "=A" (rv) : "c" (pmc));
 422         return (rv);
 423 }
 424
 425 static __inline u_int64_t
 426 rdtsc(void)
 427 {
 428         u_int64_t rv;
 429
 430         __asm __volatile(".byte 0x0f, 0x31" : "=A" (rv));
 431         return (rv);
 432 }
 433
 434 static __inline void
 435 wbinvd(void)
 436 {
 437         __asm __volatile("wbinvd");
 438 }
 439
 440 static __inline void
 441 write_eflags(u_int ef)
 442 {
 443         __asm __volatile("pushl %0; popfl" : : "r" (ef));
 444 }
 445
 446 static __inline void
 447 wrmsr(u_int msr, u_int64_t newval)
 448 {
 449         __asm __volatile(".byte 0x0f, 0x30" : : "A" (newval), "c" (msr));
 450 }
 451
 452 static __inline u_int
 453 rfs(void)
 454 {
 455         u_int sel;
 456         __asm __volatile("movl %%fs,%0" : "=rm" (sel));
 457         return (sel);
 458 }
 459
 460 static __inline u_int
 461 rgs(void)
 462 {
 463         u_int sel;
 464         __asm __volatile("movl %%gs,%0" : "=rm" (sel));
 465         return (sel);
 466 }
 467
 468 static __inline void
 469 load_fs(u_int sel)
 470 {
 471         __asm __volatile("movl %0,%%fs" : : "rm" (sel));
 472 }
 473
 474 static __inline void
 475 load_gs(u_int sel)
 476 {
 477         __asm __volatile("movl %0,%%gs" : : "rm" (sel));
 478 }
 479
 480 static __inline u_int
 481 rdr0(void)
 482 {
 483         u_int   data;
 484         __asm __volatile("movl %%dr0,%0" : "=r" (data));
 485         return (data);
 486 }
 487
 488 static __inline void
 489 load_dr0(u_int sel)
 490 {
 491         __asm __volatile("movl %0,%%dr0" : : "r" (sel));
 492 }
 493
 494 static __inline u_int
 495 rdr1(void)
 496 {
 497         u_int   data;
 498         __asm __volatile("movl %%dr1,%0" : "=r" (data));
 499         return (data);
 500 }
 501
 502 static __inline void
 503 load_dr1(u_int sel)
 504 {
 505         __asm __volatile("movl %0,%%dr1" : : "r" (sel));
 506 }
 507
 508 static __inline u_int
 509 rdr2(void)
 510 {
 511         u_int   data;
 512         __asm __volatile("movl %%dr2,%0" : "=r" (data));
 513         return (data);
 514 }
 515
 516 static __inline void
 517 load_dr2(u_int sel)
 518 {
 519         __asm __volatile("movl %0,%%dr2" : : "r" (sel));
 520 }
 521
 522 static __inline u_int
 523 rdr3(void)
 524 {
 525         u_int   data;
 526         __asm __volatile("movl %%dr3,%0" : "=r" (data));
 527         return (data);
 528 }
 529
 530 static __inline void
 531 load_dr3(u_int sel)
 532 {
 533         __asm __volatile("movl %0,%%dr3" : : "r" (sel));
 534 }
 535
 536 static __inline u_int
 537 rdr4(void)
 538 {
 539         u_int   data;
 540         __asm __volatile("movl %%dr4,%0" : "=r" (data));
 541         return (data);
 542 }
 543
 544 static __inline void
 545 load_dr4(u_int sel)
 546 {
 547         __asm __volatile("movl %0,%%dr4" : : "r" (sel));
 548 }
 549
 550 static __inline u_int
 551 rdr5(void)
 552 {
 553         u_int   data;
 554         __asm __volatile("movl %%dr5,%0" : "=r" (data));
 555         return (data);
 556 }
 557
 558 static __inline void
 559 load_dr5(u_int sel)
 560 {
 561         __asm __volatile("movl %0,%%dr5" : : "r" (sel));
 562 }
 563
 564 static __inline u_int
 565 rdr6(void)
 566 {
 567         u_int   data;
 568         __asm __volatile("movl %%dr6,%0" : "=r" (data));
 569         return (data);
 570 }
 571
 572 static __inline void
 573 load_dr6(u_int sel)
 574 {
 575         __asm __volatile("movl %0,%%dr6" : : "r" (sel));
 576 }
 577
 578 static __inline u_int
 579 rdr7(void)
 580 {
 581         u_int   data;
 582         __asm __volatile("movl %%dr7,%0" : "=r" (data));
 583         return (data);
 584 }
 585
 586 static __inline void
 587 load_dr7(u_int sel)
 588 {
 589         __asm __volatile("movl %0,%%dr7" : : "r" (sel));
 590 }
 591
 592 #else /* !__GNUC__ */
 593
 594 int     breakpoint      __P((void));
 595 u_int   bsfl            __P((u_int mask));
 596 u_int   bsrl            __P((u_int mask));
 597 void    disable_intr    __P((void));
 598 void    do_cpuid        __P((u_int ax, u_int *p));
 599 void    enable_intr     __P((void));
 600 u_char  inb             __P((u_int port));
 601 u_int   inl             __P((u_int port));
 602 void    insb            __P((u_int port, void *addr, size_t cnt));
 603 void    insl            __P((u_int port, void *addr, size_t cnt));
 604 void    insw            __P((u_int port, void *addr, size_t cnt));
 605 void    invd            __P((void));
 606 void    invlpg          __P((u_int addr));
 607 void    invltlb         __P((void));
 608 u_short inw             __P((u_int port));
 609 u_int   loadandclear    __P((u_int *addr));
 610 void    outb            __P((u_int port, u_char data));
 611 void    outl            __P((u_int port, u_int data));
 612 void    outsb           __P((u_int port, void *addr, size_t cnt));
 613 void    outsl           __P((u_int port, void *addr, size_t cnt));
 614 void    outsw           __P((u_int port, void *addr, size_t cnt));
 615 void    outw            __P((u_int port, u_short data));
 616 u_int   rcr2            __P((void));
 617 u_int64_t rdmsr         __P((u_int msr));
 618 u_int64_t rdpmc         __P((u_int pmc));
 619 u_int64_t rdtsc         __P((void));
 620 u_int   read_eflags     __P((void));
 621 void    wbinvd          __P((void));
 622 void    write_eflags    __P((u_int ef));
 623 void    wrmsr           __P((u_int msr, u_int64_t newval));
 624 u_int   rfs             __P((void));
 625 u_int   rgs             __P((void));
 626 void    load_fs         __P((u_int sel));
 627 void    load_gs         __P((u_int sel));
 628
 629 #endif  /* __GNUC__ */
 630
 631 void    load_cr0        __P((u_int cr0));
 632 void    load_cr3        __P((u_int cr3));
 633 void    load_cr4        __P((u_int cr4));
 634 void    ltr             __P((u_short sel));
 635 u_int   rcr0            __P((void));
 636 u_int   rcr3            __P((void));
 637 u_int   rcr4            __P((void));
 638 void    reset_dbregs    __P((void));
 639 __END_DECLS
 640
 641 #endif /* !_MACHINE_CPUFUNC_H_ */