Subversion Repositories shark

/* Project:     OSLib

 * Description: The OS Construction Kit

 * Date:                1.6.2000

 * Idea by:             Luca Abeni & Gerardo Lamastra

 *

 * OSLib is an SO project aimed at developing a common, easy-to-use

 * low-level infrastructure for developing OS kernels and Embedded

 * Applications; it partially derives from the HARTIK project but it

 * currently is independently developed.

 *

 * OSLib is distributed under GPL License, and some of its code has

 * been derived from the Linux kernel source; also some important

 * ideas come from studying the DJGPP go32 extender.

 *

 * We acknowledge the Linux Community, Free Software Foundation,

 * D.J. Delorie and all the other developers who believe in the

 * freedom of software and ideas.

 *

 * For legalese, check out the included GPL license.

 */

/*      As the name says... All the hardware-dependent instructions

        there is a 1->1 corrispondence with ASM instructions    */

#ifndef __LL_I386_HW_INSTR_H__

#define __LL_I386_HW_INSTR_H__

#include <ll/i386/defs.h>

#define INLINE_OP __inline__ static

#include <ll/i386/hw-data.h>

/* Low Level I/O funcs are in a separate file (by Luca) */

#include <ll/i386/hw-io.h>

BEGIN_DEF

INLINE_OP WORD get_CS(void)

{WORD r; __asm__ __volatile__ ("movw %%cs,%0" : "=q" (r)); return(r);}

INLINE_OP WORD get_DS(void)

{WORD r; __asm__ __volatile__ ("movw %%ds,%0" : "=q" (r)); return(r);}

INLINE_OP WORD get_FS(void)

{WORD r; __asm__ __volatile__ ("movw %%fs,%0" : "=q" (r)); return(r);}

/*INLINE_OP DWORD get_SP(void)

{DWORD r; __asm__ __volatile__ ("movw %%esp,%0" : "=q" (r)); return(r);}*/

INLINE_OP DWORD get_SP(void)

{

    DWORD rv;

    __asm__ __volatile__ ("movl %%esp, %0"

          : "=a" (rv));

    return(rv);

}

INLINE_OP DWORD get_BP(void)

{

    DWORD rv;

    __asm__ __volatile__ ("movl %%ebp, %0"

          : "=a" (rv));

    return(rv);

}

INLINE_OP WORD get_TR(void)

{WORD r; __asm__ __volatile__ ("strw %0" : "=q" (r)); return(r); }

INLINE_OP void set_TR(WORD n)

{__asm__ __volatile__("ltr %%ax": /* no output */ :"a" (n)); }

INLINE_OP void set_LDTR(WORD addr)

{ __asm__ __volatile__("lldt %%ax": /* no output */ :"a" (addr)); }

/* Clear Task Switched Flag! Used for FPU preemtion */

INLINE_OP void clts(void)

{__asm__ __volatile__ ("clts"); }

/* Halt the processor! */

INLINE_OP void hlt(void)

{__asm__ __volatile__ ("hlt"); }

/* These functions are used to mask/unmask interrupts           */

INLINE_OP void sti(void) {__asm__ __volatile__ ("sti"); }

INLINE_OP void cli(void) {__asm__ __volatile__ ("cli"); }

INLINE_OP SYS_FLAGS ll_fsave(void)

{

    SYS_FLAGS result;

    __asm__ __volatile__ ("pushfl");

    __asm__ __volatile__ ("cli");

    __asm__ __volatile__ ("popl %eax");

    __asm__ __volatile__ ("movl %%eax,%0"

        : "=r" (result)

        :

        : "eax" );

    return(result);

}

INLINE_OP void ll_frestore(SYS_FLAGS f)

{

    __asm__ __volatile__ ("mov %0,%%eax"

        :

        : "r" (f)

        : "eax");

    __asm__ __volatile__ ("pushl %eax");

    __asm__ __volatile__ ("popfl");

}

/*

    FPU context switch management functions!

    FPU management exported at kernel layer to allow the use

    of floating point in kernel primitives; this turns to be

    useful for bandwidth reservation or guarantee!

*/

/* FPU lazy state save handling.. */

INLINE_OP void save_fpu(TSS *t)

{

    __asm__ __volatile__("fnsave %0\n\tfwait":"=m" (t->ctx_FPU));

}

INLINE_OP void restore_fpu(TSS *t)

{

#if 1

    __asm__ __volatile__("frstor %0": :"p" (t->ctx_FPU));

#else

    __asm__ __volatile__("frstor %0\n\tfwait": :"p" (t->ctx_FPU));

#endif

/*    __asm__ __volatile__("frstor _LL_FPU_savearea"); */

}

INLINE_OP void smartsave_fpu(TSS *t)

{

    if (t->control & FPU_USED) save_fpu(t);

}

INLINE_OP void reset_fpu(void) { __asm__ __volatile__ ("fninit"); }

#if 0

/* OK, now everything is clear... We test the NE bit to see if the

 * CPU is using the internal mechanism for reporting FPU errors or not...

 */

INLINE_OP int check_fpu(void)

{

    int result;

    __asm__ __volatile__ ("movl %cr0,%eax");

    __asm__ __volatile__ ("movl %eax,%edi");

    __asm__ __volatile__ ("andl $0x0FFFFFFEF,%eax");

    __asm__ __volatile__ ("movl %eax,%cr0");

    __asm__ __volatile__ ("movl %cr0,%eax");

    __asm__ __volatile__ ("xchgl %edi,%eax");

    __asm__ __volatile__ ("movl %eax,%cr0");

#if 0

    __asm__ __volatile__ ("xorl %eax,%eax");

    __asm__ __volatile__ ("movb %bl,%al");

#else

    __asm__ __volatile__ ("movl %edi,%eax");

    __asm__ __volatile__ ("andl $0x10,%eax");

#endif

    __asm__ __volatile__ ("shrb $4,%al");

    __asm__ __volatile__ ("movl %%eax,%0"

        : "=r" (result)

        :

        : "eax" );

    return(result);

}

#endif

INLINE_OP void init_fpu(void)

{

    __asm__ __volatile__ ("movl %cr0,%eax");

    __asm__ __volatile__ ("orl  $34,%eax");

    __asm__ __volatile__ ("movl %eax,%cr0");

    __asm__ __volatile__ ("fninit");

}

extern BYTE LL_FPU_savearea[];

extern __inline__ void LL_FPU_save(void)

{

    #ifdef __LINUX__

        __asm__ __volatile__ ("fsave LL_FPU_savearea");

    #else

        __asm__ __volatile__ ("fsave _LL_FPU_savearea");

    #endif

}

extern __inline__ void LL_FPU_restore(void)

{

    #ifdef __LINUX__

        __asm__ __volatile__ ("frstor LL_FPU_savearea");

    #else

        __asm__ __volatile__ ("frstor _LL_FPU_savearea");

    #endif

}

INLINE_OP void lmempokeb(LIN_ADDR a, BYTE v)

{

        *((BYTE *)a) = v;

}

INLINE_OP void lmempokew(LIN_ADDR a, WORD v)

{

        *((WORD *)a) = v;

}

INLINE_OP void lmempoked(LIN_ADDR a, DWORD v)

{

        *((DWORD *)a) = v;

}

INLINE_OP BYTE lmempeekb(LIN_ADDR a)

{

        return *((BYTE *)a);

}

INLINE_OP WORD lmempeekw(LIN_ADDR a)

{

        return *((WORD *)a);

}

INLINE_OP DWORD lmempeekd(LIN_ADDR a)

{

        return *((DWORD *)a);

}

END_DEF

#endif