Subversion Repositories Kolibri OS

#define __SYSCALL_H__

#define FASTCALL __attribute__ ((fastcall)) __attribute__ ((dllimport))

#define PciApi          __PciApi

#define CreateObject    __CreateObject

#define DestroyObject   __DestroyObject

void   STDCALL FreeKernelSpace(void *mem)__asm__("FreeKernelSpace");

addr_t STDCALL MapIoMem(addr_t base, size_t size, u32_t flags)__asm__("MapIoMem");

void*  STDCALL KernelAlloc(size_t size)__asm__("KernelAlloc");

void*  STDCALL KernelFree(void *mem)__asm__("KernelFree");

void*  STDCALL UserAlloc(size_t size)__asm__("UserAlloc");

int    STDCALL UserFree(void *mem)__asm__("UserFree");

addr_t STDCALL AllocPages(count_t count)__asm__("AllocPages");

void   IMPORT  __attribute__((regparm(1)))

               FreePage(addr_t page)__asm__("FreePage");

void   STDCALL MapPage(void *vaddr, addr_t paddr, u32_t flags)__asm__("MapPage");

void  FASTCALL MutexLock(struct mutex*)__asm__("MutexLock");

void  FASTCALL MutexUnlock(struct mutex*)__asm__("MutexUnlock");

u32_t  IMPORT  GetPid(void)__asm__("GetPid");

                    void *fn, void *data)asm("TimerHS");

                            int z, int h)__asm__("SetMouseData");

u16_t STDCALL PciRead16(u32_t bus, u32_t devfn, u32_t reg)__asm__("PciRead16");

u32_t STDCALL PciRead32(u32_t bus, u32_t devfn, u32_t reg)__asm__("PciRead32");

u32_t STDCALL PciWrite16(u32_t bus, u32_t devfn, u32_t reg,u16_t val)__asm__("PciWrite16");

u32_t STDCALL PciWrite32(u32_t bus, u32_t devfn, u32_t reg,u32_t val)__asm__("PciWrite32");

        PciRead8(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg))

        PciRead16(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg))

        PciRead32(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg))

        PciWrite8(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val))

        PciWrite16(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val))

        PciWrite32(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val))

                    u8 *val)

{

    *val = PciRead8(dev->busnr, dev->devfn, where);

    return 1;

}

                    u16 *val)

{

    *val = PciRead16(dev->busnr, dev->devfn, where);

    return 1;

}

                    u32 *val)

{

    *val = PciRead32(dev->busnr, dev->devfn, where);

    return 1;

}

                    u8 val)

{

    PciWrite8(dev->busnr, dev->devfn, where, val);

    return 1;

}

                    u16 val)

{

    PciWrite16(dev->busnr, dev->devfn, where, val);

    return 1;

}

                    u32 val)

{

    PciWrite32(dev->busnr, dev->devfn, where, val);

    return 1;

}

int dbgprintf(const char* format, ...);

{

    int pid;

     __asm__ __volatile__ (

     "call *__imp__CreateThread"

     :"=a"(pid)

     :"b"(1),"c"(entry),"d"(0)

     :"memory");

     __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");

     return pid;

};

{

     evhandle_t evh;

     "call *__imp__CreateEvent"

     :"=A"(evh.raw)

     :"S" (ev), "c"(flags)

     :"memory");

     __asm__ __volatile__ ("":::"ebx","ecx","edx","esi", "edi");

};

{

     __asm__ __volatile__ (

     "call *__imp__RaiseEvent"

     ::"a"(evh.handle),"b"(evh.euid),"d"(flags),"S" (ev)

     :"memory");

     __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");

{

     __asm__ __volatile__ (

     "call *__imp__WaitEvent"

     ::"a"(evh.handle),"b"(evh.euid));

     __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");

};

{

    int retval;

    __asm__ __volatile__ (

    "call *__imp__WaitEventTimeout"

    :"=a"(retval)

    :"a"(evh.handle),"b"(evh.euid), "c"(timeout));

    __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");

    return retval;

};

{

     __asm__ __volatile__ (

     "call *__imp__DestroyEvent"

     ::"a"(evh.handle),"b"(evh.euid));

     __asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi");

};

{

    u32_t  handle;

    "call *__imp__GetEvent"

    :"=a"(handle)

    :"D"(ev)

    :"memory");

    __asm__ __volatile__ ("":::"ebx","ecx","edx", "esi","edi");

     return handle;

};

{

  int retval;

      :"=a"(retval)

      :"a"(61), "b"(1));

  return retval;

}

{

  int retval;

      :"=a"(retval)

      :"a"(61), "b"(2));

  return retval;

}

{

  int retval;

      :"=a"(retval)

      :"a"(61), "b"(3));

  return retval;

}

{

     u32_t retval;

     "call *__imp__GetPgAddr \n\t"

     :"=a" (retval)

     :"a" (mem) );

     return retval;

};

{

     size = (size+4095) & ~4095;

     __asm__ __volatile__ (

     "call *__imp__CommitPages"

     ::"a" (page), "b"(mem),"c"(size>>12)

     :"edx" );

     __asm__ __volatile__ ("":::"eax","ebx","ecx");

};

{

     size = (size+4095) & ~4095;

     __asm__ __volatile__ (

     "call *__imp__UnmapPages"

     ::"a" (mem), "c"(size>>12)

     :"edx");

     __asm__ __volatile__ ("":::"eax","ecx");

};

{

     if( !delay )

        delay++;

     delay*= 500;

        __asm__ __volatile__(

        "xorl %%eax, %%eax \n\t"

        "cpuid \n\t"

        :::"eax","ebx","ecx","edx");

     };

{

    if(!delay) delay++;

    delay*= 100;

    {

        __asm__ __volatile__(

        "xorl %%eax, %%eax \n\t"

        "cpuid"

        :::"eax","ebx","ecx","edx" );

    }

}

{

    msecs /= 10;

    if(!msecs) msecs = 1;

     "call *__imp__Delay"

     ::"b" (msecs));

     __asm__ __volatile__ (

     "":::"ebx");

{

    time /= 10;

    if(!time) time = 1;

     "call *__imp__Delay"

     ::"b" (time));

     __asm__ __volatile__ (

     "":::"ebx");

{

     u32_t retval;

     "call *__imp__PciApi \n\t"

     "movzxb %%al, %%eax"

     :"=a" (retval)

     :"a" (cmd)

     :"cc");

};

{

     void *retval;

     "call *__imp__CreateObject \n\t"

     :"=a" (retval)

     :"a" (size),"b"(pid)

     :"esi","edi", "memory");

     return retval;

}

{

     __asm__ __volatile__ (

     "call *__imp__DestroyObject \n\t"

     :

     :"a" (obj));

     __asm__ __volatile__ (

     ""

     :::"eax","ebx","ecx","edx","esi","edi","cc","memory");

}

{

    u32_t handle;

    (

     "pushl %%eax \n\t"

     "call *__imp__GetService"

     :"=a" (handle)

     :"a" (name)

     :"ebx","ecx","edx","esi", "edi"

  );

  return handle;

};

{

     u32_t ifl;

     __asm__ __volatile__ (

     "pushf\n\t"

     "popl %0\n\t"

     "cli\n"

     : "=r" (ifl));

    return ifl;

}

{

     if (efl & (1<<9))

        __asm__ __volatile__ ("sti");

}

{

    u32_t val;

    asm volatile (

    "pushfl\n\t"

    "popl %0\n"

    : "=r" (val));

    return val;

}

{

     u32_t tmp;

     __asm__ __volatile__ (

     "cld \n\t"

     "rep stosb \n"

     :"=c"(tmp),"=D"(tmp)

     :"a"(0),"c"(len),"D"(dst));

     __asm__ __volatile__ ("":::"ecx","edi");

};

{

    __asm__ __volatile__

    ("outb  %1, %0\n" : : "dN"(port), "a"(val));

}

{

    __asm__ __volatile__

    ("outw  %1, %0\n" : : "dN"(port), "a"(val));

}

{

    __asm__ __volatile__

    ("outl  %1, %0\n" : : "dN"(port), "a"(val));

}

{

    u8_t tmp;

    __asm__ __volatile__

    ("inb %1, %0\n" : "=a"(tmp) : "dN"(port));

    return tmp;

};

{

    u16_t tmp;

    __asm__ __volatile__

    ("inw %1, %0\n" : "=a"(tmp) : "dN"(port));

    return tmp;

};

{

    u32_t tmp;

    __asm__ __volatile__

    ("inl %1, %0\n" : "=a"(tmp) : "dN"(port));

    return tmp;

};

{

     __asm__ __volatile__ (

     "call *__imp__Delay"

     ::"b" (time));

     __asm__ __volatile__ (

     "":::"ebx");

{

     __asm__ __volatile__ (

     "call *__imp__ChangeTask");

}

{

    __asm__ __volatile__

    (

        "call *__imp__SetScreen"

        :

        :"a" (width-1),"d"(height-1), "c"(pitch)

    );

    __asm__ __volatile__

    ("" :::"eax","ecx","edx");

}

{

    return (void __iomem*) MapIoMem(offset, size, PG_SW|PG_NOCACHE|0x100);

}

{

    return (void __iomem*) MapIoMem(offset, size, PG_SW|0x100);

}

{

    FreeKernelSpace(addr);

}

{

    __asm__ __volatile__(

    "call *__imp__SysMsgBoardStr"

    ::"S" (text));

};

{

    void *mem;

    if(mem)

        memset(mem, 0, size);

};

{

    KernelFree(addr);

}

#define RWSEM_ACTIVE_BIAS               0x00000001

#define RWSEM_ACTIVE_MASK               0x0000ffff

#define RWSEM_WAITING_BIAS              (-0x00010000)

#define RWSEM_ACTIVE_READ_BIAS          RWSEM_ACTIVE_BIAS

#define RWSEM_ACTIVE_WRITE_BIAS         (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)

//{

//    sem->count = RWSEM_UNLOCKED_VALUE;

//    spin_lock_init(&sem->wait_lock);

//    INIT_LIST_HEAD(&sem->wait_list);

//}

>