cpufunc.h

Go to the documentation of this file.

/*-
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Charles M. Hannum.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *        This product includes software developed by the NetBSD
 *        Foundation, Inc. and its contributors.
 * 4. Neither the name of The NetBSD Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef __PROGRAM_CPROTO__

#ifndef _I386_CPUFUNC_H_
#define _I386_CPUFUNC_H_
#include <sysinterf/types.h>
#include <machdep/psl.h>

/*
 * Some of these functions were borrowed from NetBSD
 */

static __inline void 
invlpg(u_int addr)
{ 
  __asm __volatile ("invlpg (%0)" : : "r" (addr) : "memory");
}  

static __inline void    
lidt(void * base, unsigned int limit)
{
  unsigned int  i[2];
        
  i[0] = limit<<16;
  i[1] = (unsigned int) base;

  /* lidt takes a memory location which has bits 0..15 as the limit
   * and 16..47 as the base of the IDT */
  __asm __volatile ("lidt (%0)": :"r" (((char *)i) + 2));
}

static __inline void
lgdt(void * base, unsigned int limit)
{
  unsigned int  i[2];
        
  i[0] = limit<<16;
  i[1] = (unsigned int) base;

  __asm __volatile ("lgdt (%0)": :"r" (((char *) i) + 2));
}

static __inline void
lcall(u_int selector)
{
  u_int sel[2];

  sel[0] = 0;
  sel[1] = selector;

  __asm __volatile ("lcall *%0": :"m" (*sel)); 
}

static __inline void
lldt(u_short sel)
{
  __asm __volatile ("lldt %0" : : "r" (sel));
}

static __inline void
lcr0(u_int val)
{
  __asm __volatile ("movl %0,%%cr0" : : "r" (val));
}

static __inline u_int
rcr0(void)
{
  u_int val;
  __asm __volatile ("movl %%cr0,%0" : "=r" (val));
  return val;
}

static __inline u_int
rcr2(void)
{
  u_int val;
  __asm __volatile ("movl %%cr2,%0" : "=r" (val));
  return val;
}

static __inline void
lcr2(u_int val)
{
  __asm __volatile ("movl %0,%%cr2" : : "r" (val));
}


static __inline void
lcr3(u_int val)
{
  __asm __volatile ("movl %0,%%cr3" : : "r" (val));
}

static __inline u_int
rcr3(void)
{
  u_int val;
  __asm __volatile ("movl %%cr3,%0" : "=r" (val));
  return val;
}

static __inline void
lcr4(u_int val)
{
  __asm __volatile ("movl %0,%%cr4" : : "r" (val));
}

static __inline u_int
rcr4(void)
{
  u_int val;
  __asm __volatile ("movl %%cr4,%0" : "=r" (val));
  return val;
}

static __inline void
tlbflush(void)
{
  u_int val;
  __asm __volatile ("movl %%cr3,%0" : "=r" (val));
  __asm __volatile ("movl %0,%%cr3" : : "r" (val));
}

static __inline void
leax(u_int val)
{
  __asm __volatile ("movl %0,%%eax" : : "r" (val));
}

static __inline void
lebx(u_int val)
{
  __asm __volatile ("movl %0,%%ebx" : : "r" (val));
}

static __inline void
lecx(u_int val)
{
  __asm __volatile ("movl %0,%%ecx" : : "r" (val));
}

static __inline u_int
rebx(void)
{
  u_int val;
  __asm __volatile ("movl %%ebx,%0" : "=r" (val));
  return val;
}

static __inline u_int
recx(void)
{
  u_int val;
  __asm __volatile ("movl %%ecx,%0" : "=r" (val));
  return val;
}

static __inline void
ledx(u_int val)
{
  __asm __volatile ("movl %0,%%edx" : : "r" (val));
}

static __inline void
cpu_hang()
{
  __asm __volatile ("cli;hlt");
}

static __inline void
cpu_halt()
{
  __asm __volatile ("hlt");
}

static __inline void
yield()
{
  __asm __volatile ("iret");
}

static __inline void
disable_intr(void)
{
  __asm __volatile ("cli");
}

static __inline void
enable_intr(void)
{
  __asm __volatile ("sti");
}

static __inline u_long
read_eflags(void)
{
  u_long        ef;

  __asm __volatile ("pushfl; popl %0" : "=r" (ef));
  return (ef);
}

static __inline int
interruptible()
{
  return (read_eflags() & PSL_I);
}

static __inline void
write_eflags(u_long ef)
{
  __asm __volatile ("pushl %0; popfl" : : "r" (ef));
}

static __inline u_int64_t
rdmsr(u_int msr)
{
  u_int64_t rv;

  __asm __volatile ("rdmsr" : "=A" (rv) : "c" (msr));
  return (rv);
}

static __inline void
wrmsr(u_int msr, u_int64_t newval)
{
  __asm __volatile ("wrmsr" : : "A" (newval), "c" (msr));
}

static __inline void
wbinvd(void)
{
  __asm __volatile ("wbinvd");
}

static __inline u_int64_t
rdtsc(void)
{
  u_int64_t rv;

  __asm __volatile ("rdtsc" : "=A" (rv));
  return (rv);
}

static __inline u_int64_t
rdpmc(u_int pmc)
{
  u_int64_t rv;

  __asm __volatile ("rdpmc" : "=A" (rv) : "c" (pmc));
  return (rv);
}

/*
 * xchg borrowed from linux 
 */
#define xchg(ptr,v) ((__typeof__(*(ptr)))__xchg((unsigned long)(v),(ptr),sizeof(*(ptr))))

struct __xchg_dummy { unsigned long a[100]; };
#define __xg(x) ((struct __xchg_dummy *)(x))

/*
 * Note: no "lock" prefix even on SMP: xchg always implies lock anyway
 * Note 2: xchg has side effect, so that attribute volatile is necessary,
 * but generally the primitive is invalid, *ptr is output argument. --ANK
 */
static __inline unsigned long 
__xchg(unsigned long x, volatile void * ptr, int size)
{
  switch (size) {
  case 1:
    __asm __volatile ("xchgb %b0,%1"
                      :"=q" (x)
                      :"m" (*__xg(ptr)), "0" (x)
                      :"memory");
    break;
  case 2:
    __asm __volatile ("xchgw %w0,%1"
                      :"=r" (x)
                      :"m" (*__xg(ptr)), "0" (x)
                      :"memory");
    break;
  case 4:
    __asm __volatile ("xchgl %0,%1"
                      :"=r" (x)
                      :"m" (*__xg(ptr)), "0" (x)
                      :"memory");
    break;
  }
  return x;
}

/* I/O functions borrowed from NetBSD */

/*
 * Functions to provide access to i386 programmed I/O instructions.
 *
 * The in[bwl]() and out[bwl]() functions are split into two varieties: one to
 * use a small, constant, 8-bit port number, and another to use a large or
 * variable port number.  The former can be compiled as a smaller instruction.
 */
#ifdef __OPTIMIZE__

#define __use_immediate_port(port) \
        (__builtin_constant_p((port)) && (port) < 0x100)

#else

#define __use_immediate_port(port)      0

#endif


#define inb(port) \
        (__use_immediate_port(port) ? __inbc(port) : __inb(port))

static __inline u_int8_t
__inbc(int port)
{
        u_int8_t data;
        __asm __volatile("inb %1,%0" : "=a" (data) : "id" (port));
        return data;
}

static __inline u_int8_t
__inb(int port)
{
        u_int8_t data;
        __asm __volatile("inb %w1,%0" : "=a" (data) : "d" (port));
        return data;
}

static __inline void
insb(int port, void *addr, int cnt)
{
        void *dummy1;
        int dummy2;
        __asm __volatile("cld\n\trepne\n\tinsb"                 :
                         "=D" (dummy1), "=c" (dummy2)           :
                         "d" (port), "0" (addr), "1" (cnt)      :
                         "memory");
}

#define inw(port) \
        (__use_immediate_port(port) ? __inwc(port) : __inw(port))

static __inline u_int16_t
__inwc(int port)
{
        u_int16_t data;
        __asm __volatile("inw %1,%0" : "=a" (data) : "id" (port));
        return data;
}

static __inline u_int16_t
__inw(int port)
{
        u_int16_t data;
        __asm __volatile("inw %w1,%0" : "=a" (data) : "d" (port));
        return data;
}

static __inline void
insw(int port, void *addr, int cnt)
{
        void *dummy1;
        int dummy2;
        __asm __volatile("cld\n\trepne\n\tinsw"                 :
                         "=D" (dummy1), "=c" (dummy2)           :
                         "d" (port), "0" (addr), "1" (cnt)      :
                         "memory");
}

#define inl(port) \
        (__use_immediate_port(port) ? __inlc(port) : __inl(port))

static __inline u_int32_t
__inlc(int port)
{
        u_int32_t data;
        __asm __volatile("inl %1,%0" : "=a" (data) : "id" (port));
        return data;
}

static __inline u_int32_t
__inl(int port)
{
        u_int32_t data;
        __asm __volatile("inl %w1,%0" : "=a" (data) : "d" (port));
        return data;
}

static __inline void
insl(int port, void *addr, int cnt)
{
        void *dummy1;
        int dummy2;
        __asm __volatile("cld\n\trepne\n\tinsl"                 :
                         "=D" (dummy1), "=c" (dummy2)           :
                         "d" (port), "0" (addr), "1" (cnt)      :
                         "memory");
}

#define outb(port, data) \
        (__use_immediate_port(port) ? __outbc(port, data) : __outb(port, data))

static __inline void
__outbc(int port, u_int8_t data)
{
        __asm __volatile("outb %0,%1" : : "a" (data), "id" (port));
}

static __inline void
__outb(int port, u_int8_t data)
{
        __asm __volatile("outb %0,%w1" : : "a" (data), "d" (port));
}

static __inline void
outsb(int port, void *addr, int cnt)
{
        void *dummy1;
        int dummy2;
        __asm __volatile("cld\n\trepne\n\toutsb"                :
                         "=S" (dummy1), "=c" (dummy2)           :
                         "d" (port), "0" (addr), "1" (cnt));
}

#define outw(port, data) \
        (__use_immediate_port(port) ? __outwc(port, data) : __outw(port, data))

static __inline void
__outwc(int port, u_int16_t data)
{
        __asm __volatile("outw %0,%1" : : "a" (data), "id" (port));
}

static __inline void
__outw(int port, u_int16_t data)
{
        __asm __volatile("outw %0,%w1" : : "a" (data), "d" (port));
}

static __inline void
outsw(int port, void *addr, int cnt)
{
        void *dummy1;
        int dummy2;
        __asm __volatile("cld\n\trepne\n\toutsw"                :
                         "=S" (dummy1), "=c" (dummy2)           :
                         "d" (port), "0" (addr), "1" (cnt));
}

#define outl(port, data) \
        (__use_immediate_port(port) ? __outlc(port, data) : __outl(port, data))

static __inline void
__outlc(int port, u_int32_t data)
{
        __asm __volatile("outl %0,%1" : : "a" (data), "id" (port));
}

static __inline void
__outl(int port, u_int32_t data)
{
        __asm __volatile("outl %0,%w1" : : "a" (data), "d" (port));
}

static __inline void
outsl(int port, void *addr, int cnt)
{
        void *dummy1;
        int dummy2;
        __asm __volatile("cld\n\trepne\n\toutsl"                :
                         "=S" (dummy1), "=c" (dummy2)           :
                         "d" (port), "0" (addr), "1" (cnt));
}

/*
 * debug function: in a non-ring0 program, should ioacquire(0x60)
 * before using it
 */
static __inline void
waitch(u_int8_t waited)
{
  static u_int8_t       prev_code = 0xff;
  u_int8_t              code;

  while (1)
    {
      code = inb(0x60);
      if (code == waited && prev_code != waited)
        {
          prev_code = code;
          return ;
        }
      prev_code = code;
    }
}

#endif
#endif /* PROGRAM_CPROTO */

---