2 * Copyright (c) 1993 The Regents of the University of California.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * Functions to provide access to special i386 instructions.
34 * This in included in sys/systm.h, and that file should be
35 * used in preference to this.
38 #ifndef _MACHINE_CPUFUNC_H_
39 #define _MACHINE_CPUFUNC_H_
42 #error this file needs sys/cdefs.h as a prerequisite
45 struct region_descriptor;
47 #define readb(va) (*(volatile uint8_t *) (va))
48 #define readw(va) (*(volatile uint16_t *) (va))
49 #define readl(va) (*(volatile uint32_t *) (va))
51 #define writeb(va, d) (*(volatile uint8_t *) (va) = (d))
52 #define writew(va, d) (*(volatile uint16_t *) (va) = (d))
53 #define writel(va, d) (*(volatile uint32_t *) (va) = (d))
55 #if defined(__GNUCLIKE_ASM) && defined(__CC_SUPPORTS___INLINE)
60 __asm __volatile("int $3");
68 __asm("bsfl %1,%0" : "=r" (result) : "rm" (mask) : "cc");
77 __asm("bsrl %1,%0" : "=r" (result) : "rm" (mask) : "cc");
85 __asm __volatile("clflush %0" : : "m" (*(char *)addr));
92 __asm __volatile("clts");
99 __asm __volatile("cli" : : : "memory");
103 do_cpuid(u_int ax, u_int *p)
105 __asm __volatile("cpuid"
106 : "=a" (p[0]), "=b" (p[1]), "=c" (p[2]), "=d" (p[3])
111 cpuid_count(u_int ax, u_int cx, u_int *p)
113 __asm __volatile("cpuid"
114 : "=a" (p[0]), "=b" (p[1]), "=c" (p[2]), "=d" (p[3])
115 : "0" (ax), "c" (cx));
122 __asm __volatile("sti");
126 cpu_monitor(const void *addr, u_long extensions, u_int hints)
129 __asm __volatile("monitor"
130 : : "a" (addr), "c" (extensions), "d" (hints));
134 cpu_mwait(u_long extensions, u_int hints)
137 __asm __volatile("mwait" : : "a" (hints), "c" (extensions));
144 __asm __volatile("lfence" : : : "memory");
151 __asm __volatile("mfence" : : : "memory");
156 #define HAVE_INLINE_FFS
162 * Note that gcc-2's builtin ffs would be used if we didn't declare
163 * this inline or turn off the builtin. The builtin is faster but
164 * broken in gcc-2.4.5 and slower but working in gcc-2.5 and later
167 return (mask == 0 ? mask : (int)bsfl((u_int)mask) + 1);
170 #define HAVE_INLINE_FFSL
175 return (ffs((int)mask));
178 #define HAVE_INLINE_FLS
183 return (mask == 0 ? mask : (int)bsrl((u_int)mask) + 1);
186 #define HAVE_INLINE_FLSL
191 return (fls((int)mask));
199 __asm __volatile("hlt");
202 static __inline u_char
207 __asm __volatile("inb %w1, %0" : "=a" (data) : "Nd" (port));
211 static __inline u_int
216 __asm __volatile("inl %w1, %0" : "=a" (data) : "Nd" (port));
221 insb(u_int port, void *addr, size_t count)
223 __asm __volatile("cld; rep; insb"
224 : "+D" (addr), "+c" (count)
230 insw(u_int port, void *addr, size_t count)
232 __asm __volatile("cld; rep; insw"
233 : "+D" (addr), "+c" (count)
239 insl(u_int port, void *addr, size_t count)
241 __asm __volatile("cld; rep; insl"
242 : "+D" (addr), "+c" (count)
250 __asm __volatile("invd");
253 static __inline u_short
258 __asm __volatile("inw %w1, %0" : "=a" (data) : "Nd" (port));
263 outb(u_int port, u_char data)
265 __asm __volatile("outb %0, %w1" : : "a" (data), "Nd" (port));
269 outl(u_int port, u_int data)
271 __asm __volatile("outl %0, %w1" : : "a" (data), "Nd" (port));
275 outsb(u_int port, const void *addr, size_t count)
277 __asm __volatile("cld; rep; outsb"
278 : "+S" (addr), "+c" (count)
283 outsw(u_int port, const void *addr, size_t count)
285 __asm __volatile("cld; rep; outsw"
286 : "+S" (addr), "+c" (count)
291 outsl(u_int port, const void *addr, size_t count)
293 __asm __volatile("cld; rep; outsl"
294 : "+S" (addr), "+c" (count)
299 outw(u_int port, u_short data)
301 __asm __volatile("outw %0, %w1" : : "a" (data), "Nd" (port));
307 __asm __volatile("pause");
310 static __inline u_int
315 __asm __volatile("pushfl; popl %0" : "=r" (ef));
319 static __inline uint64_t
324 __asm __volatile("rdmsr" : "=A" (rv) : "c" (msr));
328 static __inline uint32_t
333 __asm __volatile("rdmsr" : "=a" (low) : "c" (msr) : "edx");
337 static __inline uint64_t
342 __asm __volatile("rdpmc" : "=A" (rv) : "c" (pmc));
346 static __inline uint64_t
351 __asm __volatile("rdtsc" : "=A" (rv));
355 static __inline uint32_t
360 __asm __volatile("rdtsc" : "=a" (rv) : : "edx");
367 __asm __volatile("wbinvd");
371 write_eflags(u_int ef)
373 __asm __volatile("pushl %0; popfl" : : "r" (ef));
377 wrmsr(u_int msr, uint64_t newval)
379 __asm __volatile("wrmsr" : : "A" (newval), "c" (msr));
386 __asm __volatile("movl %0,%%cr0" : : "r" (data));
389 static __inline u_int
394 __asm __volatile("movl %%cr0,%0" : "=r" (data));
398 static __inline u_int
403 __asm __volatile("movl %%cr2,%0" : "=r" (data));
411 __asm __volatile("movl %0,%%cr3" : : "r" (data) : "memory");
414 static __inline u_int
419 __asm __volatile("movl %%cr3,%0" : "=r" (data));
426 __asm __volatile("movl %0,%%cr4" : : "r" (data));
429 static __inline u_int
434 __asm __volatile("movl %%cr4,%0" : "=r" (data));
438 static __inline uint64_t
443 __asm __volatile("xgetbv" : "=a" (low), "=d" (high) : "c" (reg));
444 return (low | ((uint64_t)high << 32));
448 load_xcr(u_int reg, uint64_t val)
454 __asm __volatile("xsetbv" : : "c" (reg), "a" (low), "d" (high));
458 * Global TLB flush (except for thise for pages marked PG_G)
468 * TLB flush for an individual page (even if it has PG_G).
469 * Only works on 486+ CPUs (i386 does not have PG_G).
475 __asm __volatile("invlpg %0" : : "m" (*(char *)addr) : "memory");
478 static __inline u_short
482 __asm __volatile("movw %%fs,%0" : "=rm" (sel));
486 static __inline uint64_t
490 __asm __volatile("sgdt %0" : "=m" (gdtr));
494 static __inline u_short
498 __asm __volatile("movw %%gs,%0" : "=rm" (sel));
502 static __inline uint64_t
506 __asm __volatile("sidt %0" : "=m" (idtr));
510 static __inline u_short
514 __asm __volatile("sldt %0" : "=g" (ldtr));
518 static __inline u_short
522 __asm __volatile("movw %%ss,%0" : "=rm" (sel));
526 static __inline u_short
530 __asm __volatile("str %0" : "=g" (tr));
537 __asm __volatile("movw %0,%%fs" : : "rm" (sel));
543 __asm __volatile("movw %0,%%gs" : : "rm" (sel));
547 lidt(struct region_descriptor *addr)
549 __asm __volatile("lidt (%0)" : : "r" (addr));
555 __asm __volatile("lldt %0" : : "r" (sel));
561 __asm __volatile("ltr %0" : : "r" (sel));
564 static __inline u_int
568 __asm __volatile("movl %%dr0,%0" : "=r" (data));
575 __asm __volatile("movl %0,%%dr0" : : "r" (dr0));
578 static __inline u_int
582 __asm __volatile("movl %%dr1,%0" : "=r" (data));
589 __asm __volatile("movl %0,%%dr1" : : "r" (dr1));
592 static __inline u_int
596 __asm __volatile("movl %%dr2,%0" : "=r" (data));
603 __asm __volatile("movl %0,%%dr2" : : "r" (dr2));
606 static __inline u_int
610 __asm __volatile("movl %%dr3,%0" : "=r" (data));
617 __asm __volatile("movl %0,%%dr3" : : "r" (dr3));
620 static __inline u_int
624 __asm __volatile("movl %%dr4,%0" : "=r" (data));
631 __asm __volatile("movl %0,%%dr4" : : "r" (dr4));
634 static __inline u_int
638 __asm __volatile("movl %%dr5,%0" : "=r" (data));
645 __asm __volatile("movl %0,%%dr5" : : "r" (dr5));
648 static __inline u_int
652 __asm __volatile("movl %%dr6,%0" : "=r" (data));
659 __asm __volatile("movl %0,%%dr6" : : "r" (dr6));
662 static __inline u_int
666 __asm __volatile("movl %%dr7,%0" : "=r" (data));
673 __asm __volatile("movl %0,%%dr7" : : "r" (dr7));
676 static __inline u_char
677 read_cyrix_reg(u_char reg)
684 write_cyrix_reg(u_char reg, u_char data)
690 static __inline register_t
695 eflags = read_eflags();
701 intr_restore(register_t eflags)
703 write_eflags(eflags);
706 #else /* !(__GNUCLIKE_ASM && __CC_SUPPORTS___INLINE) */
708 int breakpoint(void);
709 u_int bsfl(u_int mask);
710 u_int bsrl(u_int mask);
711 void clflush(u_long addr);
713 void cpuid_count(u_int ax, u_int cx, u_int *p);
714 void disable_intr(void);
715 void do_cpuid(u_int ax, u_int *p);
716 void enable_intr(void);
718 void ia32_pause(void);
719 u_char inb(u_int port);
720 u_int inl(u_int port);
721 void insb(u_int port, void *addr, size_t count);
722 void insl(u_int port, void *addr, size_t count);
723 void insw(u_int port, void *addr, size_t count);
724 register_t intr_disable(void);
725 void intr_restore(register_t ef);
727 void invlpg(u_int addr);
729 u_short inw(u_int port);
730 void lidt(struct region_descriptor *addr);
731 void lldt(u_short sel);
732 void load_cr0(u_int cr0);
733 void load_cr3(u_int cr3);
734 void load_cr4(u_int cr4);
735 void load_dr0(u_int dr0);
736 void load_dr1(u_int dr1);
737 void load_dr2(u_int dr2);
738 void load_dr3(u_int dr3);
739 void load_dr4(u_int dr4);
740 void load_dr5(u_int dr5);
741 void load_dr6(u_int dr6);
742 void load_dr7(u_int dr7);
743 void load_fs(u_short sel);
744 void load_gs(u_short sel);
745 void ltr(u_short sel);
746 void outb(u_int port, u_char data);
747 void outl(u_int port, u_int data);
748 void outsb(u_int port, const void *addr, size_t count);
749 void outsl(u_int port, const void *addr, size_t count);
750 void outsw(u_int port, const void *addr, size_t count);
751 void outw(u_int port, u_short data);
756 uint64_t rdmsr(u_int msr);
757 uint64_t rdpmc(u_int pmc);
766 uint64_t rdtsc(void);
767 u_char read_cyrix_reg(u_char reg);
768 u_int read_eflags(void);
776 void write_cyrix_reg(u_char reg, u_char data);
777 void write_eflags(u_int ef);
778 void wrmsr(u_int msr, uint64_t newval);
780 #endif /* __GNUCLIKE_ASM && __CC_SUPPORTS___INLINE */
782 void reset_dbregs(void);
785 int rdmsr_safe(u_int msr, uint64_t *val);
786 int wrmsr_safe(u_int msr, uint64_t newval);
789 #endif /* !_MACHINE_CPUFUNC_H_ */