-/*\r
- * linux-wrapper.h\r
- *\r
- * Hard coded Linux kernel replacements for x86\r
- *\r
- * (c) 2003 Georg Acher (georg@acher.org)\r
- *\r
- * Emulation of:\r
- * typedefs\r
- * structs\r
- * macros\r
- *\r
- * All structs and prototypes are based on kernel source 2.5.72\r
- *\r
- * Modified by Aleksey Bragin (aleksey@reactos.com) for ReactOS needs\r
- *\r
- *\r
- * #include <standard-GPL-header.h>\r
- */\r
-\r
-/*------------------------------------------------------------------------*/\r
-/* Typedefs */\r
-/*------------------------------------------------------------------------*/ \r
-#include "cromwell_types.h"\r
-\r
-typedef unsigned int __u32;\r
-//typedef __u32 u32;\r
-typedef unsigned short __u16;\r
-//typedef __u16 u16;\r
-typedef unsigned char __u8;\r
-//typedef __u8 u8;\r
-\r
-typedef short s16;\r
-\r
-typedef u32 dma_addr_t;\r
-\r
-typedef int spinlock_t;\r
-typedef int atomic_t;\r
-#ifndef STANDALONE\r
-typedef int mode_t;\r
-typedef int pid_t;\r
-typedef int ssize_t;\r
-\r
-#endif\r
-typedef int irqreturn_t;\r
-typedef unsigned long kernel_ulong_t;\r
-\r
-typedef int wait_queue_head_t;\r
-/*------------------------------------------------------------------------*/ \r
-/* Stuff from xbox/linux environment */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-#include "list.h"\r
-\r
-#ifndef STANDALONE\r
-#ifdef MODULE\r
-typedef int size_t;\r
-#define NULL ((void*)0)\r
-extern void * memset(void *,int,unsigned int);\r
-extern void * memcpy(void *,const void *,unsigned int);\r
-#if 0\r
-extern char * strcpy(char *,const char *);\r
-#else\r
-static inline char * strcpy(char * dest,const char *src)\r
-{\r
-int d0, d1, d2;\r
-__asm__ __volatile__(\r
- "1:\tlodsb\n\t"\r
- "stosb\n\t"\r
- "testb %%al,%%al\n\t"\r
- "jne 1b"\r
- : "=&S" (d0), "=&D" (d1), "=&a" (d2)\r
- :"0" (src),"1" (dest) : "memory");\r
-return dest;\r
-}\r
-#endif\r
-extern size_t strlen(const char *);\r
-\r
-extern int memcmp(const void *,const void *,unsigned int);\r
-\r
-#else\r
-#include "boot.h"\r
-#include "config.h"\r
-#endif\r
-#else\r
-#include <stdarg.h>\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
-#include "consts.h"\r
-#include <string.h>\r
-#endif\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* General structs */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-struct timer_list { \r
- void (*function)(unsigned long);\r
- unsigned long data;\r
- int expires;\r
- struct list_head timer_list;\r
-};\r
-\r
-struct work_struct {\r
- void (*func)(void *);\r
-};\r
-struct device {\r
- char name[128];\r
- struct bus_type *bus;\r
- int dma_mask;\r
- char bus_id[16];\r
- struct device_driver* driver;\r
- void *driver_data;\r
- struct device *parent;\r
- struct list_head driver_list;\r
- void (*release)(struct device * dev);\r
-};\r
-struct class_device{int a;};\r
-struct semaphore{int a;};\r
-\r
-struct device_driver{\r
- char *name;\r
- struct bus_type *bus;\r
- int (*probe) (struct device * dev);\r
- int (*remove) (struct device * dev);\r
- struct list_head devices;\r
-};\r
-\r
-struct bus_type {\r
- char * name; \r
- int (*match)(struct device * dev, struct device_driver * drv);\r
- struct device * (*add) (struct device * parent, char * bus_id);\r
- int (*hotplug) (struct device *dev, char **envp, \r
- int num_envp, char *buffer, int buffer_size);\r
-};\r
-\r
-struct dummy_process\r
-{\r
- int flags;\r
-};\r
-\r
-struct pt_regs\r
-{\r
- int a;\r
-};\r
-struct completion {\r
- unsigned int done;\r
- wait_queue_head_t wait;\r
-};\r
-\r
-// windows lookaside list head\r
-typedef void* kmem_cache_t;\r
-\r
-struct dma_pool\r
-{\r
- int dummy;\r
-};\r
-\r
-/* from mod_devicetable.h */\r
-\r
-struct usb_device_id {\r
- /* which fields to match against? */\r
- __u16 match_flags;\r
-\r
- /* Used for product specific matches; range is inclusive */\r
- __u16 idVendor;\r
- __u16 idProduct;\r
- __u16 bcdDevice_lo;\r
- __u16 bcdDevice_hi;\r
-\r
- /* Used for device class matches */\r
- __u8 bDeviceClass;\r
- __u8 bDeviceSubClass;\r
- __u8 bDeviceProtocol;\r
-\r
- /* Used for interface class matches */\r
- __u8 bInterfaceClass;\r
- __u8 bInterfaceSubClass;\r
- __u8 bInterfaceProtocol;\r
-\r
- /* not matched against */\r
- kernel_ulong_t driver_info;\r
-};\r
-\r
-/* Some useful macros to use to create struct usb_device_id */\r
-#define USB_DEVICE_ID_MATCH_VENDOR 0x0001\r
-#define USB_DEVICE_ID_MATCH_PRODUCT 0x0002\r
-#define USB_DEVICE_ID_MATCH_DEV_LO 0x0004\r
-#define USB_DEVICE_ID_MATCH_DEV_HI 0x0008\r
-#define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010\r
-#define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020\r
-#define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040\r
-#define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080\r
-#define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100\r
-#define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* imported functions from top-level */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-//void zxprintf(char* fmt, ...);\r
-//void zxsprintf(char *buffer, char* fmt, ...);\r
-//int zxsnprintf(char *buffer, size_t s, char* fmt, ...);\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* PCI structs (taken from linux/pci.h et al., but slightly modified) */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-struct pci_dev {\r
- int vendor;\r
- int device;\r
- struct pci_bus *bus;\r
- int irq;\r
- char *slot_name;\r
- struct device dev;\r
- int base[4];\r
- int flags[4];\r
- void * data;\r
- void * dev_ext; // link to Windows DeviceExtension\r
-};\r
-\r
-struct pci_bus {\r
- unsigned char number;\r
-};\r
-\r
-struct pci_device_id {\r
- __u32 vendor, device; /* Vendor and device ID or PCI_ANY_ID*/\r
- __u32 subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */\r
- __u32 class, class_mask; /* (class,subclass,prog-if) triplet */\r
- kernel_ulong_t driver_data; /* Data private to the driver */\r
-};\r
-\r
-struct pci_driver {\r
- struct list_head node;\r
- char *name;\r
- const struct pci_device_id *id_table; /* must be non-NULL for probe to be called */\r
- int (*probe) (struct pci_dev *dev, const struct pci_device_id *id); /* New device inserted */\r
- void (*remove) (struct pci_dev *dev); /* Device removed (NULL if not a hot-plug capable driver) */\r
- int (*save_state) (struct pci_dev *dev, u32 state); /* Save Device Context */\r
- int (*suspend) (struct pci_dev *dev, u32 state); /* Device suspended */\r
- int (*resume) (struct pci_dev *dev); /* Device woken up */\r
- int (*enable_wake) (struct pci_dev *dev, u32 state, int enable); /* Enable wake event */\r
-};\r
-\r
-struct scatterlist\r
-{\r
- int page;\r
- int offset;\r
- int length;\r
-};\r
-\r
-struct usbdevfs_hub_portinfo\r
-{\r
- int nports;\r
- int port[8];\r
-};\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* constant defines */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-#define TASK_UNINTERRUPTIBLE 0\r
-#define HZ 100 /* Don't rely on that... */\r
-#define KERN_DEBUG "DBG: "\r
-#define KERN_ERR "ERR: "\r
-#define KERN_WARNING "WRN: "\r
-#define KERN_INFO "INF: "\r
-#define GFP_KERNEL 0\r
-#define GFP_ATOMIC 0\r
-#define GFP_NOIO 0\r
-#define SLAB_ATOMIC 0\r
-#define PCI_ANY_ID (~0)\r
-#define SIGKILL 9\r
-#define THIS_MODULE 0\r
-//#define PAGE_SIZE 4096\r
-\r
-\r
-#define CLONE_FS 0\r
-#define CLONE_FILES 0\r
-#define CLONE_SIGHAND 0\r
-#define PF_FREEZE 0\r
-#define PF_IOTHREAD 0\r
-\r
-\r
-#define USBDEVFS_HUB_PORTINFO 1234\r
-#define SA_SHIRQ 0\r
-\r
-#undef PCI_COMMAND\r
-#define PCI_COMMAND 0\r
-#undef PCI_COMMAND_MASTER\r
-#define PCI_COMMAND_MASTER 0\r
-/*------------------------------------------------------------------------*/ \r
-/* Module/export macros */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-#define MODULE_AUTHOR(a)\r
-#define MODULE_DESCRIPTION(a)\r
-#define MODULE_LICENSE(a)\r
-#define MODULE_DEVICE_TABLE(type,name) void* module_table_##name=&name\r
-#define MODULE_PARM(a,b)\r
-#define MODULE_PARM_DESC(a,b)\r
-\r
-#define __devinit\r
-#define __exit\r
-#define __init\r
-#define __devinitdata\r
-#define module_init(x) static void module_init_##x(void){ x();}\r
-#define module_exit(x) void module_exit_##x(void){ x();}\r
-#define EXPORT_SYMBOL_GPL(x)\r
-#define EXPORT_SYMBOL(x)\r
-\r
-#define __setup(x,y) int setup_##y=(int)y\r
-#define subsys_initcall(x) void subsys_##x(void){x();}\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* Access macros */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-#define dev_get_drvdata(a) (a)->driver_data\r
-#define dev_set_drvdata(a,b) (a)->driver_data=(b)\r
-\r
-#define __io_virt(x) ((void *)(x))\r
-#define readl(addr) (*(volatile unsigned int *) __io_virt(addr))\r
-#define writel(b,addr) (*(volatile unsigned int *) __io_virt(addr) = (b))\r
-#define likely(x) (x)\r
-#define unlikely(x) (x)\r
-#define prefetch(x) 1\r
-\r
-#define inw(x) READ_PORT_USHORT((PUSHORT)(x))\r
-#define outw(x,p) WRITE_PORT_USHORT((PUSHORT)(p),(x))\r
-#define outl(x,p) WRITE_PORT_ULONG((PUSHORT)(p),(x))\r
-\r
-/* The kernel macro for list_for_each_entry makes nonsense (have no clue\r
- * why, this is just the same definition...) */\r
-\r
-#undef list_for_each_entry\r
-#define list_for_each_entry(pos, head, member) \\r
- for (pos = list_entry((head)->next, typeof(*pos), member), \\r
- prefetch(pos->member.next); \\r
- &pos->member != (head); \\r
- pos = list_entry(pos->member.next, typeof(*pos), member), \\r
- prefetch(pos->member.next))\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* function wrapper macros */\r
-/*------------------------------------------------------------------------*/ \r
-#define kmalloc(x,y) ExAllocatePool(PagedPool,x)\r
-#define kfree(x) ExFreePool(x)\r
-\r
-//#define sprintf(a,b,format, arg...) zxsprintf((a),(b),format, ## arg)\r
-//#define snprintf(a,b,format, arg...) zxsnprintf((a),(b),format, ##arg)\r
-//#define printk(format, arg...) zxprintf(format, ## arg)\r
-#define snprintf(a,b,format, arg...) _snprintf((a),(b),format, ##arg)\r
-#define printk(format, arg...) DPRINT1(format, ## arg)\r
-#define BUG(...) do {} while(0)\r
-\r
-/* Locks & friends */\r
-\r
-#define DECLARE_MUTEX(x) struct semaphore x\r
-#define init_MUTEX(x)\r
-\r
-#define SPIN_LOCK_UNLOCKED 0\r
-#define spin_lock_init(a) do {} while(0)\r
-#define spin_lock(a) *(int*)a=1\r
-#define spin_unlock(a) do {} while(0)\r
-\r
-#define spin_lock_irqsave(a,b) b=0\r
-#define spin_unlock_irqrestore(a,b)\r
-\r
-#if 0\r
-#define local_irq_save(x) __asm__ __volatile__("pushfl ; popl %0 ; cli":"=g" (x): /* no input */ :"memory")\r
-#define local_irq_restore(x) __asm__ __volatile__("pushl %0 ; popfl": /* no output */ :"g" (x):"memory", "cc")\r
-#else\r
-#define local_irq_save(x) do {} while(0) \r
-#define local_irq_restore(x) do {} while(0) \r
-#endif\r
-\r
-#define atomic_inc(x) *(x)+=1\r
-#define atomic_dec(x) *(x)-=1\r
-#define atomic_dec_and_test(x) (*(x)-=1,(*(x))==0)\r
-#define atomic_set(x,a) *(x)=a\r
-#define atomic_read(x) *(x)\r
-#define ATOMIC_INIT(x) (x)\r
-\r
-#define down(x) do {} while(0) \r
-#define up(x) do {} while(0)\r
-#define down_trylock(a) 0\r
-\r
-#define down_read(a) do {} while(0)\r
-#define up_read(a) do {} while(0)\r
-\r
-#define DECLARE_WAIT_QUEUE_HEAD(x) KEVENT x\r
-\r
-#define DECLARE_COMPLETION(x) struct completion x\r
-\r
-/* driver */\r
-\r
-#define driver_unregister(a) do {} while(0)\r
-#define put_device(a) do {} while(0)\r
-\r
-\r
-/* PCI */\r
-#define to_pci_dev(n) container_of(n, struct pci_dev, dev)\r
-\r
-#define pci_pool_create(a,b,c,d,e) (void*)1\r
-\r
-#define pci_pool_alloc(a,b,c) my_pci_pool_alloc(a,b,c) \r
-\r
-static void __inline__ *my_pci_pool_alloc(void* pool, size_t size,\r
- dma_addr_t *dma_handle)\r
-{\r
- void* a;\r
- a=kmalloc(size,0); //FIXME\r
-#ifdef MODULE\r
- *dma_handle=((u32)a)&0xfffffff;\r
-#else\r
- *dma_handle=(u32)a;\r
-#endif\r
- return a;\r
-}\r
-\r
-\r
-#define pci_pool_free(a,b,c) kfree(b)\r
-#define pci_alloc_consistent(a,b,c) my_pci_alloc_consistent(a,b,c)\r
-\r
-static void __inline__ *my_pci_alloc_consistent(struct pci_dev *hwdev, size_t size,\r
- dma_addr_t *dma_handle)\r
-{\r
- void* a;\r
-\r
- a=kmalloc(size+256,0); //FIXME\r
- a=(void*)(((int)a+255)&~255); // 256 alignment\r
- *dma_handle=((u32)a)&0xfffffff;\r
-\r
- return a;\r
-}\r
-\r
-#define pci_free_consistent(a,b,c,d) kfree(c)\r
-#define pci_pool_destroy(a) do {} while(0)\r
-\r
-#define pci_module_init(x) my_pci_module_init(x)\r
-int my_pci_module_init(struct pci_driver *x);\r
-\r
-#define pci_unregister_driver(a) do {} while(0) \r
-\r
-#define pci_write_config_word(a,b,c) my_pci_write_config_word(a,b,c)\r
-\r
-#define bus_register(a) do {} while(0)\r
-#define bus_unregister(a) do {} while(0)\r
-\r
-/* DMA */\r
-//#define dma_pool_alloc(a,b,c) my_dma_pool_alloc((a),(b),(c))\r
-#define dma_pool_alloc(a,b,c) pci_pool_alloc(a,b,c)\r
-#define dma_pool_create(a,b,c,d,e) pci_pool_create(a,b,c,d,e)\r
-#define dma_pool_free(a,b,c) pci_pool_free(a,b,c)\r
-#define dma_pool_destroy(a) pci_pool_destroy(a)\r
-\r
-#define dma_alloc_coherent(a,b,c,d) NULL\r
-#define dma_free_coherent(a,b,c,d) do {} while(0)\r
-\r
-#define dma_map_single(a,b,c,d) ((u32)(b)&0xfffffff)\r
-#define dma_unmap_single(a,b,c,d) do {} while(0)\r
-#define pci_unmap_single(a,b,c,d) do {} while(0)\r
-#define dma_sync_single(a,b,c,d) do {} while(0)\r
-#define dma_sync_sg(a,b,c,d) do {} while(0)\r
-#define dma_map_sg(a,b,c,d) 0\r
-#define dma_unmap_sg(a,b,c,d) do {} while(0)\r
-\r
-#define usb_create_driverfs_dev_files(a) do {} while(0)\r
-#define usb_create_driverfs_intf_files(a) do {} while(0)\r
-#define sg_dma_address(x) ((u32)((x)->page*4096 + (x)->offset))\r
-#define sg_dma_len(x) ((x)->length) \r
-\r
-#define page_address(x) ((void*)(x/4096))\r
-\r
-#define DMA_TO_DEVICE 0\r
-#define DMA_FROM_DEVICE 0\r
-#define PCI_DMA_TODEVICE\r
-#define PCI_DMA_FROMDEVICE\r
-#define PCI_DMA_TODEVICE\r
-\r
-#define PCI_ROM_RESOURCE 0\r
-#define IORESOURCE_IO 1\r
-\r
-#define DECLARE_WAITQUEUE(a,b) KEVENT a=0\r
-#define init_waitqueue_head(a) my_init_waitqueue_head(a)\r
-#define add_wait_queue(a,b) do {} while(0)\r
-#define remove_wait_queue(a,b) do {} while(0)\r
-void my_init_waitqueue_head(PKEVENT a);\r
-\r
-VOID KeMemoryBarrier(VOID);\r
-\r
-#define mb() KeMemoryBarrier()\r
-#define wmb() __asm__ __volatile__ ("": : :"memory")\r
-#define rmb() __asm__ __volatile__ ("lock; addl $0,0(%%esp)": : :"memory")\r
-\r
-#define in_interrupt() 0\r
-\r
-#define init_completion(x) (x)->done=0\r
-#define wait_for_completion(x) my_wait_for_completion(x)\r
-void my_wait_for_completion(struct completion*);\r
-\r
-#define IRQ_NONE 0\r
-#define IRQ_HANDLED 1\r
-\r
-#define INIT_WORK(a,b,c) (a)->func=b\r
-\r
-#define set_current_state(a) do {} while(0)\r
-\r
-#define might_sleep() do {} while(0)\r
-#define daemonize(a) do {} while(0)\r
-#define allow_signal(a) do {} while(0)\r
-#define wait_event_interruptible(x,y) do {} while(0)\r
-\r
-#define interruptible_sleep_on(a) my_interruptible_sleep_on(a)\r
-void my_interruptible_sleep_on(PKEVENT evnt);\r
-\r
-#define flush_scheduled_work() do {} while(0)\r
-#define refrigerator(x) do {} while(0)\r
-#define signal_pending(x) 1 // fall through threads\r
-#define complete_and_exit(a,b) return 0\r
-\r
-//#define kill_proc(a,b,c) 0\r
-#define kill_proc(a,b,c) my_kill_proc(a, b, c);\r
-int my_kill_proc(int pid, int signal, int unk);\r
-\r
-#define yield() do {} while(0)\r
-#define cpu_relax() do {} while(0)\r
-\r
-#define WARN_ON(a) do {} while(0)\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* Lookaside lists funcs */\r
-/*------------------------------------------------------------------------*/ \r
-#define kmem_cache_create(a,b,c,d,e,f) my_kmem_cache_create((a),(b),(c),(d),(e),(f))\r
-#define kmem_cache_destroy(a) my_kmem_cache_destroy((a))\r
-#define kmem_cache_alloc(co, flags) my_kmem_cache_alloc((co), (flags))\r
-#define kmem_cache_free(co, ptr) my_kmem_cache_free((co), (ptr))\r
-\r
-kmem_cache_t *my_kmem_cache_create(const char *tag, size_t alloc_size,\r
- size_t offset, unsigned long flags,\r
- void *ctor,\r
- void *dtor);\r
-\r
-BOOLEAN my_kmem_cache_destroy(kmem_cache_t *co);\r
-void *my_kmem_cache_alloc(kmem_cache_t *co, int flags);\r
-void my_kmem_cache_free(kmem_cache_t *co, void *ptr);\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* Kernel macros */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-#define LINUX_VERSION_CODE 0x020572\r
-#define UTS_SYSNAME "XBOX"\r
-#define UTS_RELEASE "----"\r
-\r
-/* from linux/kernel.h */\r
-#define max_t(type,x,y) \\r
- ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })\r
-\r
-#define min_t(type,x,y) \\r
- ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })\r
-\r
-#define container_of(ptr, type, member) ({ \\r
- const typeof( ((type *)0)->member ) *__mptr = (ptr); \\r
- (type *)( (char *)__mptr - offsetof(type,member) );})\r
-\r
-/* from linux/stddef.h */\r
-\r
-#undef offsetof\r
-#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* Conversion macros */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-#define __constant_cpu_to_le32(x) (x)\r
-#define cpu_to_le16(x) (x)\r
-#define le16_to_cpu(x) (x)\r
-#define cpu_to_le32(x) (x)\r
-#define cpu_to_le32p(x) (*(__u32*)(x))\r
-#define le32_to_cpup(x) (*(__u32*)(x))\r
-#define le32_to_cpu(x) ((u32)x)\r
-#define le16_to_cpus(x) do {} while (0)\r
-#define le16_to_cpup(x) (*(__u16*)(x))\r
-#define cpu_to_le16p(x) (*(__u16*)(x))\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* Debug output */\r
-/*------------------------------------------------------------------------*/ \r
-#ifdef DEBUG_MODE\r
-#define dev_printk(lvl,x,f,arg...) printk(f, ## arg)\r
-#define dev_dbg(x,f,arg...) printk(f, ## arg)\r
-#define dev_info(x,f,arg...) printk(f,## arg)\r
-#define dev_warn(x,f,arg...) printk(f,## arg)\r
-#define dev_err(x,f,arg...) printk(f,## arg)\r
-#define pr_debug(x,f,arg...) printk(f,## arg)\r
-#define usbprintk printk\r
-#endif\r
-\r
-#ifndef DEBUG_MODE\r
-#define dev_printk(lvl,x,f,arg...) do {} while (0)\r
-#define dev_dbg(x,f,arg...) do {} while (0) //printk(f, ## arg)\r
-#define dev_info(x,f,arg...) do {} while (0)\r
-#define dev_warn(x,f,arg...) do {} while (0)\r
-#define dev_err(x,f,arg...) do {} while (0)\r
-#define pr_debug(x,f,arg...) do {} while (0)\r
-#define usbprintk\r
-#endif\r
-\r
-\r
-\r
-#define PCI_DEVFN(a,b) 0\r
-#define PCI_SLOT(a) 0\r
-\r
-/**\r
- * PCI_DEVICE_CLASS - macro used to describe a specific pci device class\r
- * @dev_class: the class, subclass, prog-if triple for this device\r
- * @dev_class_mask: the class mask for this device\r
- *\r
- * This macro is used to create a struct pci_device_id that matches a\r
- * specific PCI class. The vendor, device, subvendor, and subdevice \r
- * fields will be set to PCI_ANY_ID.\r
- */\r
-#define PCI_DEVICE_CLASS(dev_class,dev_class_mask) \\r
- .class = (dev_class), .class_mask = (dev_class_mask), \\r
- .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \\r
- .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID\r
-\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* Stuff from kernel */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-#include "errno.h"\r
-#include "bitops.h"\r
-//#include "linux/pci_ids.h"\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* global variables */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-#define jiffies my_jiffies\r
-extern int my_jiffies;\r
-#define current my_current\r
-extern struct dummy_process *my_current;\r
-\r
-extern struct list_head interrupt_list;\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* Function prototypes */\r
-/*------------------------------------------------------------------------*/ \r
-void STDCALL usb_hcd_pci_remove (struct pci_dev *dev);\r
-\r
-#define my_wait_ms(x) wait_ms(x)\r
-\r
-#define my_udelay(x) wait_ms(x)\r
-#define udelay(x) my_udelay(x)\r
-\r
-#define my_mdelay(x) wait_ms(1+x/1000);\r
-#define mdelay(x) my_mdelay(x);\r
-\r
-#define pci_find_slot(a,b) my_pci_find_slot(a,b)\r
-struct pci_dev *my_pci_find_slot(int a,int b);\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* Timer management */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-#define MAX_TIMERS 20\r
-extern struct timer_list *main_timer_list[MAX_TIMERS];\r
-\r
-static void __inline__ init_timer(struct timer_list* t)\r
-{\r
- INIT_LIST_HEAD(&t->timer_list);\r
- t->function=NULL;\r
- t->expires=0;\r
-}\r
-\r
-static void __inline__ add_timer(struct timer_list* t)\r
-{\r
- int n;\r
- for(n=0;n<MAX_TIMERS;n++)\r
- if (main_timer_list[n]==0)\r
- {\r
- main_timer_list[n]=t;\r
- break;\r
- }\r
-}\r
-\r
-static void __inline__ del_timer(struct timer_list* t)\r
-{\r
- int n;\r
- for(n=0;n<MAX_TIMERS;n++)\r
- if (main_timer_list[n]==t)\r
- {\r
- main_timer_list[n]=0;\r
- break;\r
- }\r
-}\r
-static void __inline__ del_timer_sync(struct timer_list* t)\r
-{\r
- int n;\r
- for(n=0;n<MAX_TIMERS;n++)\r
- if (main_timer_list[n]==t)\r
- {\r
- main_timer_list[n]=0;\r
- break;\r
- }\r
-\r
-}\r
-static void __inline__ mod_timer(struct timer_list* t, int ex)\r
-{\r
- del_timer(t);\r
- t->expires=ex;\r
- add_timer(t);\r
-}\r
-\r
-#define time_after_eq(a,b) \\r
- (((long)(a) - (long)(b) >= 0))\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* Device driver and process related stuff */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-static int __inline__ usb_major_init(void){return 0;}\r
-static void __inline__ usb_major_cleanup(void){}\r
-static void __inline__ schedule_work(void* p){}\r
-\r
-#define device_initialize(x) my_device_initialize(x)\r
-void my_device_initialize(struct device *dev);\r
-\r
-#define get_device(x) my_get_device(x)\r
-struct device *my_get_device(struct device *dev);\r
-\r
-#define device_add(x) my_device_add(x)\r
-int my_device_add(struct device *dev);\r
-\r
-#define driver_register(x) my_driver_register(x)\r
-int my_driver_register(struct device_driver *driver);\r
-\r
-#define device_unregister(a) my_device_unregister(a)\r
-int my_device_unregister(struct device *dev);\r
-\r
-#define DEVICE_ATTR(a,b,c,d) int xxx_##a\r
-#define device_create_file(a,b) do {} while(0)\r
-#define device_remove_file(a,b) do {} while(0)\r
-\r
-#define schedule_timeout(x) my_schedule_timeout(x)\r
-int my_schedule_timeout(int x);\r
-\r
-#define wake_up(x) my_wake_up(x)\r
-void my_wake_up(PKEVENT);\r
-\r
-// cannot be mapped via macro due to collision with urb->complete\r
-static void __inline__ complete(struct completion *p)\r
-{\r
- /* Wake up x->wait */\r
- p->done++;\r
- wake_up(&p->wait);\r
-}\r
-\r
-#define kernel_thread(a,b,c) my_kernel_thread(a,b,c)\r
-int my_kernel_thread(int STDCALL (*handler)(void*), void* parm, int flags);\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* PCI, simple and inlined... */\r
-/*------------------------------------------------------------------------*/ \r
-#include "pci_hal.c"\r
-\r
-/*------------------------------------------------------------------------*/ \r
-/* IRQ handling */\r
-/*------------------------------------------------------------------------*/ \r
-\r
-#define request_irq(a,b,c,d,e) my_request_irq(a,b,c,d,e)\r
-int my_request_irq(unsigned int irq,\r
- int (*handler)(int, void *, struct pt_regs *),\r
- unsigned long mode, const char *desc, void *data);\r
-\r
-#define free_irq(a,b) my_free_irq(a,b)\r
-int free_irq(int irq, void* p);\r
-\r
-\r
-\r
-struct my_irqs {\r
- int (*handler)(int, void *, struct pt_regs *);\r
- int irq;\r
- void* data;\r
-};\r
-\r
-#define MAX_IRQS 8\r
-\r
-// Exported to top level\r
-\r
-void handle_irqs(int irq);\r
-void inc_jiffies(int);\r
-void init_wrapper(struct pci_dev *pci_dev);\r
-void do_all_timers(void);\r
-\r
-#define __KERNEL_DS 0x18\r
-\r
-\r
+/*
+ * linux-wrapper.h
+ *
+ * Hard coded Linux kernel replacements for x86
+ *
+ * (c) 2003 Georg Acher (georg@acher.org)
+ *
+ * Emulation of:
+ * typedefs
+ * structs
+ * macros
+ *
+ * All structs and prototypes are based on kernel source 2.5.72
+ *
+ * Modified by Aleksey Bragin (aleksey@reactos.com) for ReactOS needs
+ *
+ *
+ * #include <standard-GPL-header.h>
+ */
+
+/*------------------------------------------------------------------------*/
+/* Typedefs */
+/*------------------------------------------------------------------------*/
+#include "cromwell_types.h"
+
+typedef unsigned int __u32;
+//typedef __u32 u32;
+typedef unsigned short __u16;
+//typedef __u16 u16;
+typedef unsigned char __u8;
+//typedef __u8 u8;
+
+typedef short s16;
+
+typedef u32 dma_addr_t;
+
+typedef int spinlock_t;
+typedef int atomic_t;
+#ifndef STANDALONE
+typedef int mode_t;
+typedef int pid_t;
+typedef int ssize_t;
+
+#endif
+typedef int irqreturn_t;
+typedef unsigned long kernel_ulong_t;
+
+typedef int wait_queue_head_t;
+/*------------------------------------------------------------------------*/
+/* Stuff from xbox/linux environment */
+/*------------------------------------------------------------------------*/
+
+#include "list.h"
+
+#ifndef STANDALONE
+#ifdef MODULE
+typedef int size_t;
+#define NULL ((void*)0)
+extern void * memset(void *,int,unsigned int);
+extern void * memcpy(void *,const void *,unsigned int);
+#if 0
+extern char * strcpy(char *,const char *);
+#else
+static inline char * strcpy(char * dest,const char *src)
+{
+int d0, d1, d2;
+__asm__ __volatile__(
+ "1:\tlodsb\n\t"
+ "stosb\n\t"
+ "testb %%al,%%al\n\t"
+ "jne 1b"
+ : "=&S" (d0), "=&D" (d1), "=&a" (d2)
+ :"0" (src),"1" (dest) : "memory");
+return dest;
+}
+#endif
+extern size_t strlen(const char *);
+
+extern int memcmp(const void *,const void *,unsigned int);
+
+#else
+#include "boot.h"
+#include "config.h"
+#endif
+#else
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "consts.h"
+#include <string.h>
+#endif
+
+/*------------------------------------------------------------------------*/
+/* General structs */
+/*------------------------------------------------------------------------*/
+
+struct timer_list {
+ void (*function)(unsigned long);
+ unsigned long data;
+ int expires;
+ struct list_head timer_list;
+};
+
+struct work_struct {
+ void (*func)(void *);
+};
+struct device {
+ char name[128];
+ struct bus_type *bus;
+ int dma_mask;
+ char bus_id[16];
+ struct device_driver* driver;
+ void *driver_data;
+ struct device *parent;
+ struct list_head driver_list;
+ void (*release)(struct device * dev);
+};
+struct class_device{int a;};
+struct semaphore{int a;};
+
+struct device_driver{
+ char *name;
+ struct bus_type *bus;
+ int (*probe) (struct device * dev);
+ int (*remove) (struct device * dev);
+ struct list_head devices;
+};
+
+struct bus_type {
+ char * name;
+ int (*match)(struct device * dev, struct device_driver * drv);
+ struct device * (*add) (struct device * parent, char * bus_id);
+ int (*hotplug) (struct device *dev, char **envp,
+ int num_envp, char *buffer, int buffer_size);
+};
+
+struct dummy_process
+{
+ int flags;
+};
+
+struct pt_regs
+{
+ int a;
+};
+struct completion {
+ unsigned int done;
+ wait_queue_head_t wait;
+};
+
+// windows lookaside list head
+typedef void* kmem_cache_t;
+
+struct dma_pool
+{
+ int dummy;
+};
+
+/* from mod_devicetable.h */
+
+struct usb_device_id {
+ /* which fields to match against? */
+ __u16 match_flags;
+
+ /* Used for product specific matches; range is inclusive */
+ __u16 idVendor;
+ __u16 idProduct;
+ __u16 bcdDevice_lo;
+ __u16 bcdDevice_hi;
+
+ /* Used for device class matches */
+ __u8 bDeviceClass;
+ __u8 bDeviceSubClass;
+ __u8 bDeviceProtocol;
+
+ /* Used for interface class matches */
+ __u8 bInterfaceClass;
+ __u8 bInterfaceSubClass;
+ __u8 bInterfaceProtocol;
+
+ /* not matched against */
+ kernel_ulong_t driver_info;
+};
+
+/* Some useful macros to use to create struct usb_device_id */
+#define USB_DEVICE_ID_MATCH_VENDOR 0x0001
+#define USB_DEVICE_ID_MATCH_PRODUCT 0x0002
+#define USB_DEVICE_ID_MATCH_DEV_LO 0x0004
+#define USB_DEVICE_ID_MATCH_DEV_HI 0x0008
+#define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010
+#define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020
+#define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040
+#define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080
+#define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100
+#define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200
+
+/*------------------------------------------------------------------------*/
+/* imported functions from top-level */
+/*------------------------------------------------------------------------*/
+
+//void zxprintf(char* fmt, ...);
+//void zxsprintf(char *buffer, char* fmt, ...);
+//int zxsnprintf(char *buffer, size_t s, char* fmt, ...);
+
+/*------------------------------------------------------------------------*/
+/* PCI structs (taken from linux/pci.h et al., but slightly modified) */
+/*------------------------------------------------------------------------*/
+
+struct pci_dev {
+ int vendor;
+ int device;
+ struct pci_bus *bus;
+ int irq;
+ char *slot_name;
+ struct device dev;
+ int base[4];
+ int flags[4];
+ void * data;
+ void * dev_ext; // link to Windows DeviceExtension
+};
+
+struct pci_bus {
+ unsigned char number;
+};
+
+struct pci_device_id {
+ __u32 vendor, device; /* Vendor and device ID or PCI_ANY_ID*/
+ __u32 subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
+ __u32 class, class_mask; /* (class,subclass,prog-if) triplet */
+ kernel_ulong_t driver_data; /* Data private to the driver */
+};
+
+struct pci_driver {
+ struct list_head node;
+ char *name;
+ const struct pci_device_id *id_table; /* must be non-NULL for probe to be called */
+ int (*probe) (struct pci_dev *dev, const struct pci_device_id *id); /* New device inserted */
+ void (*remove) (struct pci_dev *dev); /* Device removed (NULL if not a hot-plug capable driver) */
+ int (*save_state) (struct pci_dev *dev, u32 state); /* Save Device Context */
+ int (*suspend) (struct pci_dev *dev, u32 state); /* Device suspended */
+ int (*resume) (struct pci_dev *dev); /* Device woken up */
+ int (*enable_wake) (struct pci_dev *dev, u32 state, int enable); /* Enable wake event */
+};
+
+struct scatterlist
+{
+ int page;
+ int offset;
+ int length;
+};
+
+struct usbdevfs_hub_portinfo
+{
+ int nports;
+ int port[8];
+};
+
+/*------------------------------------------------------------------------*/
+/* constant defines */
+/*------------------------------------------------------------------------*/
+
+#define TASK_UNINTERRUPTIBLE 0
+#define HZ 100 /* Don't rely on that... */
+#define KERN_DEBUG "DBG: "
+#define KERN_ERR "ERR: "
+#define KERN_WARNING "WRN: "
+#define KERN_INFO "INF: "
+#define GFP_KERNEL 0
+#define GFP_ATOMIC 0x20
+#define GFP_NOIO 0
+#define SLAB_ATOMIC 0
+#define PCI_ANY_ID (~0)
+#define SIGKILL 9
+#define THIS_MODULE 0
+//#define PAGE_SIZE 4096
+
+
+#define CLONE_FS 0
+#define CLONE_FILES 0
+#define CLONE_SIGHAND 0
+#define PF_FREEZE 0
+#define PF_IOTHREAD 0
+
+
+#define USBDEVFS_HUB_PORTINFO 1234
+#define SA_SHIRQ 0
+
+#undef PCI_COMMAND
+#define PCI_COMMAND 0
+#undef PCI_COMMAND_MASTER
+#define PCI_COMMAND_MASTER 0
+/*------------------------------------------------------------------------*/
+/* Module/export macros */
+/*------------------------------------------------------------------------*/
+
+#define MODULE_AUTHOR(a)
+#define MODULE_DESCRIPTION(a)
+#define MODULE_LICENSE(a)
+#define MODULE_DEVICE_TABLE(type,name) void* module_table_##name=&name
+#define MODULE_PARM(a,b)
+#define MODULE_PARM_DESC(a,b)
+
+#define __devinit
+#define __exit
+#define __init
+#define __devinitdata
+#define module_init(x) static void module_init_##x(void){ x();}
+#define module_exit(x) void module_exit_##x(void){ x();}
+#define EXPORT_SYMBOL_GPL(x)
+#define EXPORT_SYMBOL(x)
+
+#define __setup(x,y) int setup_##y=(int)y
+#define subsys_initcall(x) void subsys_##x(void){x();}
+
+/*------------------------------------------------------------------------*/
+/* Access macros */
+/*------------------------------------------------------------------------*/
+
+#define dev_get_drvdata(a) (a)->driver_data
+#define dev_set_drvdata(a,b) (a)->driver_data=(b)
+
+#define __io_virt(x) ((void *)(x))
+#define readl(addr) (*(volatile unsigned int *) __io_virt(addr))
+#define writel(b,addr) (*(volatile unsigned int *) __io_virt(addr) = (b))
+#define likely(x) (x)
+#define unlikely(x) (x)
+#define prefetch(x) 1
+
+#define inw(x) READ_PORT_USHORT((PUSHORT)(x))
+#define outw(x,p) WRITE_PORT_USHORT((PUSHORT)(p),(x))
+#define outl(x,p) WRITE_PORT_ULONG((PUSHORT)(p),(x))
+
+/* The kernel macro for list_for_each_entry makes nonsense (have no clue
+ * why, this is just the same definition...) */
+
+#undef list_for_each_entry
+#define list_for_each_entry(pos, head, member) \
+ for (pos = list_entry((head)->next, typeof(*pos), member), \
+ prefetch(pos->member.next); \
+ &pos->member != (head); \
+ pos = list_entry(pos->member.next, typeof(*pos), member), \
+ prefetch(pos->member.next))
+
+/*------------------------------------------------------------------------*/
+/* function wrapper macros */
+/*------------------------------------------------------------------------*/
+#define kmalloc(x,y) ExAllocatePool(PagedPool,x)
+#define kfree(x) ExFreePool(x)
+
+//#define sprintf(a,b,format, arg...) zxsprintf((a),(b),format, ## arg)
+//#define snprintf(a,b,format, arg...) zxsnprintf((a),(b),format, ##arg)
+//#define printk(format, arg...) zxprintf(format, ## arg)
+#define snprintf(a,b,format, arg...) _snprintf((a),(b),format, ##arg)
+#define printk(format, arg...) DPRINT1(format, ## arg)
+#define BUG(...) do {} while(0)
+
+/* Locks & friends */
+
+#define DECLARE_MUTEX(x) struct semaphore x
+#define init_MUTEX(x)
+
+#define SPIN_LOCK_UNLOCKED 0
+#define spin_lock_init(a) do {} while(0)
+#define spin_lock(a) *(int*)a=1
+#define spin_unlock(a) do {} while(0)
+
+#define spin_lock_irqsave(a,b) b=0
+#define spin_unlock_irqrestore(a,b)
+
+#if 0
+#define local_irq_save(x) __asm__ __volatile__("pushfl ; popl %0 ; cli":"=g" (x): /* no input */ :"memory")
+#define local_irq_restore(x) __asm__ __volatile__("pushl %0 ; popfl": /* no output */ :"g" (x):"memory", "cc")
+#else
+#define local_irq_save(x) do {} while(0)
+#define local_irq_restore(x) do {} while(0)
+#endif
+
+#define atomic_inc(x) *(x)+=1
+#define atomic_dec(x) *(x)-=1
+#define atomic_dec_and_test(x) (*(x)-=1,(*(x))==0)
+#define atomic_set(x,a) *(x)=a
+#define atomic_read(x) *(x)
+#define ATOMIC_INIT(x) (x)
+
+#define down(x) do {} while(0)
+#define up(x) do {} while(0)
+#define down_trylock(a) 0
+
+#define down_read(a) do {} while(0)
+#define up_read(a) do {} while(0)
+
+#define DECLARE_WAIT_QUEUE_HEAD(x) KEVENT x
+
+#define DECLARE_COMPLETION(x) struct completion x
+
+/* driver */
+
+#define driver_unregister(a) do {} while(0)
+#define put_device(a) do {} while(0)
+
+
+/* PCI */
+#define to_pci_dev(n) container_of(n, struct pci_dev, dev)
+
+#define pci_pool_create(a,b,c,d,e) (void*)1
+
+#define pci_pool_alloc(a,b,c) my_pci_pool_alloc(a,b,c)
+
+static void __inline__ *my_pci_pool_alloc(void* pool, size_t size,
+ dma_addr_t *dma_handle)
+{
+ void* a;
+ a=kmalloc(size,0); //FIXME
+#ifdef MODULE
+ *dma_handle=((u32)a)&0xfffffff;
+#else
+ *dma_handle=(u32)a;
+#endif
+ return a;
+}
+
+
+#define pci_pool_free(a,b,c) kfree(b)
+#define pci_alloc_consistent(a,b,c) my_pci_alloc_consistent(a,b,c)
+
+static void __inline__ *my_pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
+ dma_addr_t *dma_handle)
+{
+ void* a;
+
+ a=kmalloc(size+256,0); //FIXME
+ a=(void*)(((int)a+255)&~255); // 256 alignment
+ *dma_handle=((u32)a)&0xfffffff;
+
+ return a;
+}
+
+#define pci_free_consistent(a,b,c,d) kfree(c)
+#define pci_pool_destroy(a) do {} while(0)
+
+#define pci_module_init(x) my_pci_module_init(x)
+int my_pci_module_init(struct pci_driver *x);
+
+#define pci_unregister_driver(a) do {} while(0)
+
+#define pci_write_config_word(a,b,c) my_pci_write_config_word(a,b,c)
+
+#define bus_register(a) do {} while(0)
+#define bus_unregister(a) do {} while(0)
+
+/* DMA */
+//#define dma_pool_alloc(a,b,c) my_dma_pool_alloc((a),(b),(c))
+#define dma_pool_alloc(a,b,c) pci_pool_alloc(a,b,c)
+#define dma_pool_create(a,b,c,d,e) pci_pool_create(a,b,c,d,e)
+#define dma_pool_free(a,b,c) pci_pool_free(a,b,c)
+#define dma_pool_destroy(a) pci_pool_destroy(a)
+
+#define dma_alloc_coherent(a,b,c,d) NULL
+#define dma_free_coherent(a,b,c,d) do {} while(0)
+
+#define dma_map_single(a,b,c,d) ((u32)(b)&0xfffffff)
+#define dma_unmap_single(a,b,c,d) do {} while(0)
+#define pci_unmap_single(a,b,c,d) do {} while(0)
+#define dma_sync_single(a,b,c,d) do {} while(0)
+#define dma_sync_sg(a,b,c,d) do {} while(0)
+#define dma_map_sg(a,b,c,d) 0
+#define dma_unmap_sg(a,b,c,d) do {} while(0)
+
+#define usb_create_driverfs_dev_files(a) do {} while(0)
+#define usb_create_driverfs_intf_files(a) do {} while(0)
+#define sg_dma_address(x) ((u32)((x)->page*4096 + (x)->offset))
+#define sg_dma_len(x) ((x)->length)
+
+#define page_address(x) ((void*)(x/4096))
+
+#define DMA_TO_DEVICE 0
+#define DMA_FROM_DEVICE 0
+#define PCI_DMA_TODEVICE
+#define PCI_DMA_FROMDEVICE
+#define PCI_DMA_TODEVICE
+
+#define PCI_ROM_RESOURCE 1
+#define IORESOURCE_IO CM_RESOURCE_PORT_IO
+
+#define DECLARE_WAITQUEUE(a,b) KEVENT a=0
+#define init_waitqueue_head(a) my_init_waitqueue_head(a)
+#define add_wait_queue(a,b) do {} while(0)
+#define remove_wait_queue(a,b) do {} while(0)
+void my_init_waitqueue_head(PKEVENT a);
+
+VOID KeMemoryBarrier(VOID);
+
+#define mb() KeMemoryBarrier()
+#define wmb() __asm__ __volatile__ ("": : :"memory")
+#define rmb() __asm__ __volatile__ ("lock; addl $0,0(%%esp)": : :"memory")
+
+#define in_interrupt() 0
+
+#define init_completion(x) (x)->done=0
+#define wait_for_completion(x) my_wait_for_completion(x)
+void my_wait_for_completion(struct completion*);
+
+#define IRQ_NONE 0
+#define IRQ_HANDLED 1
+
+#define INIT_WORK(a,b,c) (a)->func=b
+
+#define set_current_state(a) do {} while(0)
+
+#define might_sleep() do {} while(0)
+#define daemonize(a) do {} while(0)
+#define allow_signal(a) do {} while(0)
+#define wait_event_interruptible(x,y) do {} while(0)
+
+#define interruptible_sleep_on(a) my_interruptible_sleep_on(a)
+void my_interruptible_sleep_on(PKEVENT evnt);
+
+#define flush_scheduled_work() do {} while(0)
+#define refrigerator(x) do {} while(0)
+#define signal_pending(x) 1 // fall through threads
+#define complete_and_exit(a,b) return 0
+
+//#define kill_proc(a,b,c) 0
+#define kill_proc(a,b,c) my_kill_proc(a, b, c);
+int my_kill_proc(int pid, int signal, int unk);
+
+#define yield() do {} while(0)
+#define cpu_relax() do {} while(0)
+
+#define WARN_ON(a) do {} while(0)
+
+/*------------------------------------------------------------------------*/
+/* Lookaside lists funcs */
+/*------------------------------------------------------------------------*/
+#define kmem_cache_create(a,b,c,d,e,f) my_kmem_cache_create((a),(b),(c),(d),(e),(f))
+#define kmem_cache_destroy(a) my_kmem_cache_destroy((a))
+#define kmem_cache_alloc(co, flags) my_kmem_cache_alloc((co), (flags))
+#define kmem_cache_free(co, ptr) my_kmem_cache_free((co), (ptr))
+
+kmem_cache_t *my_kmem_cache_create(const char *tag, size_t alloc_size,
+ size_t offset, unsigned long flags,
+ void *ctor,
+ void *dtor);
+
+BOOLEAN my_kmem_cache_destroy(kmem_cache_t *co);
+void *my_kmem_cache_alloc(kmem_cache_t *co, int flags);
+void my_kmem_cache_free(kmem_cache_t *co, void *ptr);
+
+/*------------------------------------------------------------------------*/
+/* Kernel macros */
+/*------------------------------------------------------------------------*/
+
+#define LINUX_VERSION_CODE 0x020572
+#define UTS_SYSNAME "XBOX"
+#define UTS_RELEASE "----"
+
+/* from linux/kernel.h */
+#define max_t(type,x,y) \
+ ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
+
+#define min_t(type,x,y) \
+ ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
+
+#define container_of(ptr, type, member) ({ \
+ const typeof( ((type *)0)->member ) *__mptr = (ptr); \
+ (type *)( (char *)__mptr - offsetof(type,member) );})
+
+/* from linux/stddef.h */
+
+#undef offsetof
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+
+/*------------------------------------------------------------------------*/
+/* Conversion macros */
+/*------------------------------------------------------------------------*/
+
+#define __constant_cpu_to_le32(x) (x)
+#define cpu_to_le16(x) (x)
+#define le16_to_cpu(x) (x)
+#define cpu_to_le32(x) (x)
+#define cpu_to_le32p(x) (*(__u32*)(x))
+#define le32_to_cpup(x) (*(__u32*)(x))
+#define le32_to_cpu(x) ((u32)x)
+#define le16_to_cpus(x) do {} while (0)
+#define le16_to_cpup(x) (*(__u16*)(x))
+#define cpu_to_le16p(x) (*(__u16*)(x))
+
+/*------------------------------------------------------------------------*/
+/* Debug output */
+/*------------------------------------------------------------------------*/
+#ifdef DEBUG_MODE
+#define dev_printk(lvl,x,f,arg...) printk(f, ## arg)
+#define dev_dbg(x,f,arg...) printk(f, ## arg)
+#define dev_info(x,f,arg...) printk(f,## arg)
+#define dev_warn(x,f,arg...) printk(f,## arg)
+#define dev_err(x,f,arg...) printk(f,## arg)
+#define pr_debug(x,f,arg...) printk(f,## arg)
+#define usbprintk printk
+#endif
+
+#ifndef DEBUG_MODE
+#define dev_printk(lvl,x,f,arg...) do {} while (0)
+#define dev_dbg(x,f,arg...) do {} while (0) //printk(f, ## arg)
+#define dev_info(x,f,arg...) do {} while (0)
+#define dev_warn(x,f,arg...) do {} while (0)
+#define dev_err(x,f,arg...) do {} while (0)
+#define pr_debug(x,f,arg...) do {} while (0)
+#define usbprintk
+#endif
+
+
+
+#define PCI_DEVFN(a,b) 0
+#define PCI_SLOT(a) 0
+
+/**
+ * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
+ * @dev_class: the class, subclass, prog-if triple for this device
+ * @dev_class_mask: the class mask for this device
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI class. The vendor, device, subvendor, and subdevice
+ * fields will be set to PCI_ANY_ID.
+ */
+#define PCI_DEVICE_CLASS(dev_class,dev_class_mask) \
+ .class = (dev_class), .class_mask = (dev_class_mask), \
+ .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
+ .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+
+/*------------------------------------------------------------------------*/
+/* Stuff from kernel */
+/*------------------------------------------------------------------------*/
+
+#include "errno.h"
+#include "bitops.h"
+//#include "linux/pci_ids.h"
+
+/*------------------------------------------------------------------------*/
+/* global variables */
+/*------------------------------------------------------------------------*/
+
+#define jiffies my_jiffies
+extern int my_jiffies;
+#define current my_current
+extern struct dummy_process *my_current;
+
+extern struct list_head interrupt_list;
+
+/*------------------------------------------------------------------------*/
+/* Function prototypes */
+/*------------------------------------------------------------------------*/
+void STDCALL usb_hcd_pci_remove (struct pci_dev *dev);
+
+#define my_wait_ms(x) wait_ms(x)
+
+#define my_udelay(x) wait_ms(x)
+#define udelay(x) my_udelay(x)
+
+#define my_mdelay(x) wait_ms(1+x/1000);
+#define mdelay(x) my_mdelay(x);
+
+#define pci_find_slot(a,b) my_pci_find_slot(a,b)
+struct pci_dev *my_pci_find_slot(int a,int b);
+
+/*------------------------------------------------------------------------*/
+/* Timer management */
+/*------------------------------------------------------------------------*/
+
+#define MAX_TIMERS 20
+extern struct timer_list *main_timer_list[MAX_TIMERS];
+
+static void __inline__ init_timer(struct timer_list* t)
+{
+ INIT_LIST_HEAD(&t->timer_list);
+ t->function=NULL;
+ t->expires=0;
+}
+
+static void __inline__ add_timer(struct timer_list* t)
+{
+ int n;
+ for(n=0;n<MAX_TIMERS;n++)
+ if (main_timer_list[n]==0)
+ {
+ main_timer_list[n]=t;
+ break;
+ }
+}
+
+static void __inline__ del_timer(struct timer_list* t)
+{
+ int n;
+ for(n=0;n<MAX_TIMERS;n++)
+ if (main_timer_list[n]==t)
+ {
+ main_timer_list[n]=0;
+ break;
+ }
+}
+static void __inline__ del_timer_sync(struct timer_list* t)
+{
+ int n;
+ for(n=0;n<MAX_TIMERS;n++)
+ if (main_timer_list[n]==t)
+ {
+ main_timer_list[n]=0;
+ break;
+ }
+
+}
+static void __inline__ mod_timer(struct timer_list* t, int ex)
+{
+ del_timer(t);
+ t->expires=ex;
+ add_timer(t);
+}
+
+#define time_after_eq(a,b) \
+ (((long)(a) - (long)(b) >= 0))
+
+/*------------------------------------------------------------------------*/
+/* Device driver and process related stuff */
+/*------------------------------------------------------------------------*/
+
+static int __inline__ usb_major_init(void){return 0;}
+static void __inline__ usb_major_cleanup(void){}
+static void __inline__ schedule_work(void* p){}
+
+#define device_initialize(x) my_device_initialize(x)
+void my_device_initialize(struct device *dev);
+
+#define get_device(x) my_get_device(x)
+struct device *my_get_device(struct device *dev);
+
+#define device_add(x) my_device_add(x)
+int my_device_add(struct device *dev);
+
+#define driver_register(x) my_driver_register(x)
+int my_driver_register(struct device_driver *driver);
+
+#define device_unregister(a) my_device_unregister(a)
+int my_device_unregister(struct device *dev);
+
+#define DEVICE_ATTR(a,b,c,d) int xxx_##a
+#define device_create_file(a,b) do {} while(0)
+#define device_remove_file(a,b) do {} while(0)
+
+#define schedule_timeout(x) my_schedule_timeout(x)
+int my_schedule_timeout(int x);
+
+#define wake_up(x) my_wake_up(x)
+void my_wake_up(PKEVENT);
+
+// cannot be mapped via macro due to collision with urb->complete
+static void __inline__ complete(struct completion *p)
+{
+ /* Wake up x->wait */
+ p->done++;
+ wake_up((PKEVENT)&p->wait);
+}
+
+#define kernel_thread(a,b,c) my_kernel_thread(a,b,c)
+int my_kernel_thread(int STDCALL (*handler)(void*), void* parm, int flags);
+
+/*------------------------------------------------------------------------*/
+/* PCI, simple and inlined... */
+/*------------------------------------------------------------------------*/
+#include "pci_hal.c"
+
+/*------------------------------------------------------------------------*/
+/* IRQ handling */
+/*------------------------------------------------------------------------*/
+
+#define request_irq(a,b,c,d,e) my_request_irq(a,b,c,d,e)
+int my_request_irq(unsigned int irq,
+ int (*handler)(int, void *, struct pt_regs *),
+ unsigned long mode, const char *desc, void *data);
+
+#define free_irq(a,b) my_free_irq(a,b)
+int free_irq(int irq, void* p);
+
+
+
+struct my_irqs {
+ int (*handler)(int, void *, struct pt_regs *);
+ int irq;
+ void* data;
+};
+
+#define MAX_IRQS 8
+
+// Exported to top level
+
+void handle_irqs(int irq);
+void inc_jiffies(int);
+void init_wrapper(struct pci_dev *pci_dev);
+void do_all_timers(void);
+
+#define __KERNEL_DS 0x18
+
+
projects / reactos.git / blobdiff