dd79888d8e1e2fdd59551e386aa0b6f99df606fe
[reactos.git] / reactos / drivers / usb / cromwell / linux / linux_wrapper.h
1 /*
2 * linux-wrapper.h
3 *
4 * Hard coded Linux kernel replacements for x86
5 *
6 * (c) 2003 Georg Acher (georg@acher.org)
7 *
8 * Emulation of:
9 * typedefs
10 * structs
11 * macros
12 *
13 * All structs and prototypes are based on kernel source 2.5.72
14 *
15 * Modified by Aleksey Bragin (aleksey@reactos.com) for ReactOS needs
16 *
17 *
18 * #include <standard-GPL-header.h>
19 */
20
21 /*------------------------------------------------------------------------*/
22 /* Typedefs */
23 /*------------------------------------------------------------------------*/
24 #include "cromwell_types.h"
25
26 typedef unsigned int __u32;
27 //typedef __u32 u32;
28 typedef unsigned short __u16;
29 //typedef __u16 u16;
30 typedef unsigned char __u8;
31 //typedef __u8 u8;
32
33 typedef short s16;
34
35 typedef u32 dma_addr_t;
36
37 typedef int spinlock_t;
38 typedef int atomic_t;
39 #ifndef STANDALONE
40 typedef int mode_t;
41 typedef int pid_t;
42 typedef int ssize_t;
43
44 #endif
45 typedef int irqreturn_t;
46 typedef unsigned long kernel_ulong_t;
47
48 typedef int wait_queue_head_t;
49 /*------------------------------------------------------------------------*/
50 /* Stuff from xbox/linux environment */
51 /*------------------------------------------------------------------------*/
52
53 #include "list.h"
54
55 #ifndef STANDALONE
56 #ifdef MODULE
57 typedef int size_t;
58 #define NULL ((void*)0)
59 extern void * memset(void *,int,unsigned int);
60 extern void * memcpy(void *,const void *,unsigned int);
61 #if 0
62 extern char * strcpy(char *,const char *);
63 #else
64 static inline char * strcpy(char * dest,const char *src)
65 {
66 int d0, d1, d2;
67 __asm__ __volatile__(
68 "1:\tlodsb\n\t"
69 "stosb\n\t"
70 "testb %%al,%%al\n\t"
71 "jne 1b"
72 : "=&S" (d0), "=&D" (d1), "=&a" (d2)
73 :"0" (src),"1" (dest) : "memory");
74 return dest;
75 }
76 #endif
77 extern size_t strlen(const char *);
78
79 extern int memcmp(const void *,const void *,unsigned int);
80
81 #else
82 #include "boot.h"
83 #include "config.h"
84 #endif
85 #else
86 #include <stdarg.h>
87 #include <stdio.h>
88 #include <stdlib.h>
89 #include "consts.h"
90 #include <string.h>
91 #endif
92
93 /*------------------------------------------------------------------------*/
94 /* General structs */
95 /*------------------------------------------------------------------------*/
96
97 struct timer_list {
98 void (*function)(unsigned long);
99 unsigned long data;
100 int expires;
101 struct list_head timer_list;
102 };
103
104 struct work_struct {
105 void (*func)(void *);
106 };
107 struct device {
108 char name[128];
109 struct bus_type *bus;
110 int dma_mask;
111 char bus_id[16];
112 struct device_driver* driver;
113 void *driver_data;
114 struct device *parent;
115 struct list_head driver_list;
116 void (*release)(struct device * dev);
117 };
118 struct class_device{int a;};
119 struct semaphore{int a;};
120
121 struct device_driver{
122 char *name;
123 struct bus_type *bus;
124 int (*probe) (struct device * dev);
125 int (*remove) (struct device * dev);
126 struct list_head devices;
127 };
128
129 struct bus_type {
130 char * name;
131 int (*match)(struct device * dev, struct device_driver * drv);
132 struct device * (*add) (struct device * parent, char * bus_id);
133 int (*hotplug) (struct device *dev, char **envp,
134 int num_envp, char *buffer, int buffer_size);
135 };
136
137 struct dummy_process
138 {
139 int flags;
140 };
141
142 struct pt_regs
143 {
144 int a;
145 };
146 struct completion {
147 unsigned int done;
148 wait_queue_head_t wait;
149 };
150
151 // windows lookaside list head
152 typedef void* kmem_cache_t;
153
154 struct dma_pool
155 {
156 int dummy;
157 };
158
159 /* from mod_devicetable.h */
160
161 struct usb_device_id {
162 /* which fields to match against? */
163 __u16 match_flags;
164
165 /* Used for product specific matches; range is inclusive */
166 __u16 idVendor;
167 __u16 idProduct;
168 __u16 bcdDevice_lo;
169 __u16 bcdDevice_hi;
170
171 /* Used for device class matches */
172 __u8 bDeviceClass;
173 __u8 bDeviceSubClass;
174 __u8 bDeviceProtocol;
175
176 /* Used for interface class matches */
177 __u8 bInterfaceClass;
178 __u8 bInterfaceSubClass;
179 __u8 bInterfaceProtocol;
180
181 /* not matched against */
182 kernel_ulong_t driver_info;
183 };
184
185 /* Some useful macros to use to create struct usb_device_id */
186 #define USB_DEVICE_ID_MATCH_VENDOR 0x0001
187 #define USB_DEVICE_ID_MATCH_PRODUCT 0x0002
188 #define USB_DEVICE_ID_MATCH_DEV_LO 0x0004
189 #define USB_DEVICE_ID_MATCH_DEV_HI 0x0008
190 #define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010
191 #define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020
192 #define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040
193 #define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080
194 #define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100
195 #define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200
196
197 /*------------------------------------------------------------------------*/
198 /* imported functions from top-level */
199 /*------------------------------------------------------------------------*/
200
201 //void zxprintf(char* fmt, ...);
202 //void zxsprintf(char *buffer, char* fmt, ...);
203 //int zxsnprintf(char *buffer, size_t s, char* fmt, ...);
204
205 /*------------------------------------------------------------------------*/
206 /* PCI structs (taken from linux/pci.h et al., but slightly modified) */
207 /*------------------------------------------------------------------------*/
208
209 struct pci_dev {
210 int vendor;
211 int device;
212 struct pci_bus *bus;
213 int irq;
214 char *slot_name;
215 struct device dev;
216 int base[4];
217 int flags[4];
218 void * data;
219 void * dev_ext; // link to Windows DeviceExtension
220 };
221
222 struct pci_bus {
223 unsigned char number;
224 };
225
226 struct pci_device_id {
227 __u32 vendor, device; /* Vendor and device ID or PCI_ANY_ID*/
228 __u32 subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
229 __u32 class, class_mask; /* (class,subclass,prog-if) triplet */
230 kernel_ulong_t driver_data; /* Data private to the driver */
231 };
232
233 struct pci_driver {
234 struct list_head node;
235 char *name;
236 const struct pci_device_id *id_table; /* must be non-NULL for probe to be called */
237 int (*probe) (struct pci_dev *dev, const struct pci_device_id *id); /* New device inserted */
238 void (*remove) (struct pci_dev *dev); /* Device removed (NULL if not a hot-plug capable driver) */
239 int (*save_state) (struct pci_dev *dev, u32 state); /* Save Device Context */
240 int (*suspend) (struct pci_dev *dev, u32 state); /* Device suspended */
241 int (*resume) (struct pci_dev *dev); /* Device woken up */
242 int (*enable_wake) (struct pci_dev *dev, u32 state, int enable); /* Enable wake event */
243 };
244
245 struct scatterlist
246 {
247 int page;
248 int offset;
249 int length;
250 };
251
252 struct usbdevfs_hub_portinfo
253 {
254 int nports;
255 int port[8];
256 };
257
258 /*------------------------------------------------------------------------*/
259 /* constant defines */
260 /*------------------------------------------------------------------------*/
261
262 #define TASK_UNINTERRUPTIBLE 0
263 #define HZ 100 /* Don't rely on that... */
264 #define KERN_DEBUG "DBG: "
265 #define KERN_ERR "ERR: "
266 #define KERN_WARNING "WRN: "
267 #define KERN_INFO "INF: "
268 #define GFP_KERNEL 0
269 #define GFP_ATOMIC 0x20
270 #define GFP_NOIO 0
271 #define SLAB_ATOMIC 0
272 #define PCI_ANY_ID (~0)
273 #define SIGKILL 9
274 #define THIS_MODULE 0
275 //#define PAGE_SIZE 4096
276
277
278 #define CLONE_FS 0
279 #define CLONE_FILES 0
280 #define CLONE_SIGHAND 0
281 #define PF_FREEZE 0
282 #define PF_IOTHREAD 0
283
284
285 #define USBDEVFS_HUB_PORTINFO 1234
286 #define SA_SHIRQ 0
287
288 #undef PCI_COMMAND
289 #define PCI_COMMAND 0
290 #undef PCI_COMMAND_MASTER
291 #define PCI_COMMAND_MASTER 0
292 /*------------------------------------------------------------------------*/
293 /* Module/export macros */
294 /*------------------------------------------------------------------------*/
295
296 #define MODULE_AUTHOR(a)
297 #define MODULE_DESCRIPTION(a)
298 #define MODULE_LICENSE(a)
299 #define MODULE_DEVICE_TABLE(type,name) void* module_table_##name=&name
300 #define MODULE_PARM(a,b)
301 #define MODULE_PARM_DESC(a,b)
302
303 #define __devinit
304 #define __exit
305 #define __init
306 #define __devinitdata
307 #define module_init(x) static void module_init_##x(void){ x();}
308 #define module_exit(x) void module_exit_##x(void){ x();}
309 #define EXPORT_SYMBOL_GPL(x)
310 #define EXPORT_SYMBOL(x)
311
312 #define __setup(x,y) int setup_##y=(int)y
313 #define subsys_initcall(x) void subsys_##x(void){x();}
314
315 /*------------------------------------------------------------------------*/
316 /* Access macros */
317 /*------------------------------------------------------------------------*/
318
319 #define dev_get_drvdata(a) (a)->driver_data
320 #define dev_set_drvdata(a,b) (a)->driver_data=(b)
321
322 #define __io_virt(x) ((void *)(x))
323 #define readl(addr) (*(volatile unsigned int *) __io_virt(addr))
324 #define writel(b,addr) (*(volatile unsigned int *) __io_virt(addr) = (b))
325 #define likely(x) (x)
326 #define unlikely(x) (x)
327 #define prefetch(x) 1
328
329 #define inw(x) READ_PORT_USHORT((PUSHORT)(x))
330 #define outw(x,p) WRITE_PORT_USHORT((PUSHORT)(p),(x))
331 #define outl(x,p) WRITE_PORT_ULONG((PUSHORT)(p),(x))
332
333 /* The kernel macro for list_for_each_entry makes nonsense (have no clue
334 * why, this is just the same definition...) */
335
336 #undef list_for_each_entry
337 #define list_for_each_entry(pos, head, member) \
338 for (pos = list_entry((head)->next, typeof(*pos), member), \
339 prefetch(pos->member.next); \
340 &pos->member != (head); \
341 pos = list_entry(pos->member.next, typeof(*pos), member), \
342 prefetch(pos->member.next))
343
344 /*------------------------------------------------------------------------*/
345 /* function wrapper macros */
346 /*------------------------------------------------------------------------*/
347 #define kmalloc(x,y) ExAllocatePool(PagedPool,x)
348 #define kfree(x) ExFreePool(x)
349
350 //#define sprintf(a,b,format, arg...) zxsprintf((a),(b),format, ## arg)
351 //#define snprintf(a,b,format, arg...) zxsnprintf((a),(b),format, ##arg)
352 //#define printk(format, arg...) zxprintf(format, ## arg)
353 #define snprintf(a,b,format, arg...) _snprintf((a),(b),format, ##arg)
354 #define printk(format, arg...) DPRINT1(format, ## arg)
355 #define BUG(...) do {} while(0)
356
357 /* Locks & friends */
358
359 #define DECLARE_MUTEX(x) struct semaphore x
360 #define init_MUTEX(x)
361
362 #define SPIN_LOCK_UNLOCKED 0
363 #define spin_lock_init(a) do {} while(0)
364 #define spin_lock(a) *(int*)a=1
365 #define spin_unlock(a) do {} while(0)
366
367 #define spin_lock_irqsave(a,b) b=0
368 #define spin_unlock_irqrestore(a,b)
369
370 #if 0
371 #define local_irq_save(x) __asm__ __volatile__("pushfl ; popl %0 ; cli":"=g" (x): /* no input */ :"memory")
372 #define local_irq_restore(x) __asm__ __volatile__("pushl %0 ; popfl": /* no output */ :"g" (x):"memory", "cc")
373 #else
374 #define local_irq_save(x) do {} while(0)
375 #define local_irq_restore(x) do {} while(0)
376 #endif
377
378 #define atomic_inc(x) *(x)+=1
379 #define atomic_dec(x) *(x)-=1
380 #define atomic_dec_and_test(x) (*(x)-=1,(*(x))==0)
381 #define atomic_set(x,a) *(x)=a
382 #define atomic_read(x) *(x)
383 #define ATOMIC_INIT(x) (x)
384
385 #define down(x) do {} while(0)
386 #define up(x) do {} while(0)
387 #define down_trylock(a) 0
388
389 #define down_read(a) do {} while(0)
390 #define up_read(a) do {} while(0)
391
392 #define DECLARE_WAIT_QUEUE_HEAD(x) KEVENT x
393
394 #define DECLARE_COMPLETION(x) struct completion x
395
396 /* driver */
397
398 #define driver_unregister(a) do {} while(0)
399 #define put_device(a) do {} while(0)
400
401
402 /* PCI */
403 #define to_pci_dev(n) container_of(n, struct pci_dev, dev)
404
405 #define pci_pool_create(a,b,c,d,e) (void*)1
406
407 #define pci_pool_alloc(a,b,c) my_pci_pool_alloc(a,b,c)
408
409 static void __inline__ *my_pci_pool_alloc(void* pool, size_t size,
410 dma_addr_t *dma_handle)
411 {
412 void* a;
413 a=kmalloc(size,0); //FIXME
414 #ifdef MODULE
415 *dma_handle=((u32)a)&0xfffffff;
416 #else
417 *dma_handle=(u32)a;
418 #endif
419 return a;
420 }
421
422
423 #define pci_pool_free(a,b,c) kfree(b)
424 #define pci_alloc_consistent(a,b,c) my_pci_alloc_consistent(a,b,c)
425
426 static void __inline__ *my_pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
427 dma_addr_t *dma_handle)
428 {
429 void* a;
430
431 a=kmalloc(size+256,0); //FIXME
432 a=(void*)(((int)a+255)&~255); // 256 alignment
433 *dma_handle=((u32)a)&0xfffffff;
434
435 return a;
436 }
437
438 #define pci_free_consistent(a,b,c,d) kfree(c)
439 #define pci_pool_destroy(a) do {} while(0)
440
441 #define pci_module_init(x) my_pci_module_init(x)
442 int my_pci_module_init(struct pci_driver *x);
443
444 #define pci_unregister_driver(a) do {} while(0)
445
446 #define pci_write_config_word(a,b,c) my_pci_write_config_word(a,b,c)
447
448 #define bus_register(a) do {} while(0)
449 #define bus_unregister(a) do {} while(0)
450
451 /* DMA */
452 //#define dma_pool_alloc(a,b,c) my_dma_pool_alloc((a),(b),(c))
453 #define dma_pool_alloc(a,b,c) pci_pool_alloc(a,b,c)
454 #define dma_pool_create(a,b,c,d,e) pci_pool_create(a,b,c,d,e)
455 #define dma_pool_free(a,b,c) pci_pool_free(a,b,c)
456 #define dma_pool_destroy(a) pci_pool_destroy(a)
457
458 #define dma_alloc_coherent(a,b,c,d) NULL
459 #define dma_free_coherent(a,b,c,d) do {} while(0)
460
461 #define dma_map_single(a,b,c,d) ((u32)(b)&0xfffffff)
462 #define dma_unmap_single(a,b,c,d) do {} while(0)
463 #define pci_unmap_single(a,b,c,d) do {} while(0)
464 #define dma_sync_single(a,b,c,d) do {} while(0)
465 #define dma_sync_sg(a,b,c,d) do {} while(0)
466 #define dma_map_sg(a,b,c,d) 0
467 #define dma_unmap_sg(a,b,c,d) do {} while(0)
468
469 #define usb_create_driverfs_dev_files(a) do {} while(0)
470 #define usb_create_driverfs_intf_files(a) do {} while(0)
471 #define sg_dma_address(x) ((u32)((x)->page*4096 + (x)->offset))
472 #define sg_dma_len(x) ((x)->length)
473
474 #define page_address(x) ((void*)(x/4096))
475
476 #define DMA_TO_DEVICE 0
477 #define DMA_FROM_DEVICE 0
478 #define PCI_DMA_TODEVICE
479 #define PCI_DMA_FROMDEVICE
480 #define PCI_DMA_TODEVICE
481
482 #define PCI_ROM_RESOURCE 1
483 #define IORESOURCE_IO CM_RESOURCE_PORT_IO
484
485 #define DECLARE_WAITQUEUE(a,b) KEVENT a=0
486 #define init_waitqueue_head(a) my_init_waitqueue_head(a)
487 #define add_wait_queue(a,b) do {} while(0)
488 #define remove_wait_queue(a,b) do {} while(0)
489 void my_init_waitqueue_head(PKEVENT a);
490
491 VOID KeMemoryBarrier(VOID);
492
493 #define mb() KeMemoryBarrier()
494 #define wmb() __asm__ __volatile__ ("": : :"memory")
495 #define rmb() __asm__ __volatile__ ("lock; addl $0,0(%%esp)": : :"memory")
496
497 #define in_interrupt() 0
498
499 #define init_completion(x) (x)->done=0
500 #define wait_for_completion(x) my_wait_for_completion(x)
501 void my_wait_for_completion(struct completion*);
502
503 #define IRQ_NONE 0
504 #define IRQ_HANDLED 1
505
506 #define INIT_WORK(a,b,c) (a)->func=b
507
508 #define set_current_state(a) do {} while(0)
509
510 #define might_sleep() do {} while(0)
511 #define daemonize(a) do {} while(0)
512 #define allow_signal(a) do {} while(0)
513 #define wait_event_interruptible(x,y) do {} while(0)
514
515 #define interruptible_sleep_on(a) my_interruptible_sleep_on(a)
516 void my_interruptible_sleep_on(PKEVENT evnt);
517
518 #define flush_scheduled_work() do {} while(0)
519 #define refrigerator(x) do {} while(0)
520 #define signal_pending(x) 1 // fall through threads
521 #define complete_and_exit(a,b) return 0
522
523 //#define kill_proc(a,b,c) 0
524 #define kill_proc(a,b,c) my_kill_proc(a, b, c);
525 int my_kill_proc(int pid, int signal, int unk);
526
527 #define yield() do {} while(0)
528 #define cpu_relax() do {} while(0)
529
530 #define WARN_ON(a) do {} while(0)
531
532 /*------------------------------------------------------------------------*/
533 /* Lookaside lists funcs */
534 /*------------------------------------------------------------------------*/
535 #define kmem_cache_create(a,b,c,d,e,f) my_kmem_cache_create((a),(b),(c),(d),(e),(f))
536 #define kmem_cache_destroy(a) my_kmem_cache_destroy((a))
537 #define kmem_cache_alloc(co, flags) my_kmem_cache_alloc((co), (flags))
538 #define kmem_cache_free(co, ptr) my_kmem_cache_free((co), (ptr))
539
540 kmem_cache_t *my_kmem_cache_create(const char *tag, size_t alloc_size,
541 size_t offset, unsigned long flags,
542 void *ctor,
543 void *dtor);
544
545 BOOLEAN my_kmem_cache_destroy(kmem_cache_t *co);
546 void *my_kmem_cache_alloc(kmem_cache_t *co, int flags);
547 void my_kmem_cache_free(kmem_cache_t *co, void *ptr);
548
549 /*------------------------------------------------------------------------*/
550 /* Kernel macros */
551 /*------------------------------------------------------------------------*/
552
553 #define LINUX_VERSION_CODE 0x020572
554 #define UTS_SYSNAME "XBOX"
555 #define UTS_RELEASE "----"
556
557 /* from linux/kernel.h */
558 #define max_t(type,x,y) \
559 ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
560
561 #define min_t(type,x,y) \
562 ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
563
564 #define container_of(ptr, type, member) ({ \
565 const typeof( ((type *)0)->member ) *__mptr = (ptr); \
566 (type *)( (char *)__mptr - offsetof(type,member) );})
567
568 /* from linux/stddef.h */
569
570 #undef offsetof
571 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
572
573 /*------------------------------------------------------------------------*/
574 /* Conversion macros */
575 /*------------------------------------------------------------------------*/
576
577 #define __constant_cpu_to_le32(x) (x)
578 #define cpu_to_le16(x) (x)
579 #define le16_to_cpu(x) (x)
580 #define cpu_to_le32(x) (x)
581 #define cpu_to_le32p(x) (*(__u32*)(x))
582 #define le32_to_cpup(x) (*(__u32*)(x))
583 #define le32_to_cpu(x) ((u32)x)
584 #define le16_to_cpus(x) do {} while (0)
585 #define le16_to_cpup(x) (*(__u16*)(x))
586 #define cpu_to_le16p(x) (*(__u16*)(x))
587
588 /*------------------------------------------------------------------------*/
589 /* Debug output */
590 /*------------------------------------------------------------------------*/
591 #ifdef DEBUG_MODE
592 #define dev_printk(lvl,x,f,arg...) printk(f, ## arg)
593 #define dev_dbg(x,f,arg...) printk(f, ## arg)
594 #define dev_info(x,f,arg...) printk(f,## arg)
595 #define dev_warn(x,f,arg...) printk(f,## arg)
596 #define dev_err(x,f,arg...) printk(f,## arg)
597 #define pr_debug(x,f,arg...) printk(f,## arg)
598 #define usbprintk printk
599 #endif
600
601 #ifndef DEBUG_MODE
602 #define dev_printk(lvl,x,f,arg...) do {} while (0)
603 #define dev_dbg(x,f,arg...) do {} while (0) //printk(f, ## arg)
604 #define dev_info(x,f,arg...) do {} while (0)
605 #define dev_warn(x,f,arg...) do {} while (0)
606 #define dev_err(x,f,arg...) do {} while (0)
607 #define pr_debug(x,f,arg...) do {} while (0)
608 #define usbprintk
609 #endif
610
611
612
613 #define PCI_DEVFN(a,b) 0
614 #define PCI_SLOT(a) 0
615
616 /**
617 * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
618 * @dev_class: the class, subclass, prog-if triple for this device
619 * @dev_class_mask: the class mask for this device
620 *
621 * This macro is used to create a struct pci_device_id that matches a
622 * specific PCI class. The vendor, device, subvendor, and subdevice
623 * fields will be set to PCI_ANY_ID.
624 */
625 #define PCI_DEVICE_CLASS(dev_class,dev_class_mask) \
626 .class = (dev_class), .class_mask = (dev_class_mask), \
627 .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
628 .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
629
630
631 /*------------------------------------------------------------------------*/
632 /* Stuff from kernel */
633 /*------------------------------------------------------------------------*/
634
635 #include "errno.h"
636 #include "bitops.h"
637 //#include "linux/pci_ids.h"
638
639 /*------------------------------------------------------------------------*/
640 /* global variables */
641 /*------------------------------------------------------------------------*/
642
643 #define jiffies my_jiffies
644 extern int my_jiffies;
645 #define current my_current
646 extern struct dummy_process *my_current;
647
648 extern struct list_head interrupt_list;
649
650 /*------------------------------------------------------------------------*/
651 /* Function prototypes */
652 /*------------------------------------------------------------------------*/
653 void STDCALL usb_hcd_pci_remove (struct pci_dev *dev);
654
655 #define my_wait_ms(x) wait_ms(x)
656
657 #define my_udelay(x) wait_ms(x)
658 #define udelay(x) my_udelay(x)
659
660 #define my_mdelay(x) wait_ms(1+x/1000);
661 #define mdelay(x) my_mdelay(x);
662
663 #define pci_find_slot(a,b) my_pci_find_slot(a,b)
664 struct pci_dev *my_pci_find_slot(int a,int b);
665
666 /*------------------------------------------------------------------------*/
667 /* Timer management */
668 /*------------------------------------------------------------------------*/
669
670 #define MAX_TIMERS 20
671 extern struct timer_list *main_timer_list[MAX_TIMERS];
672
673 static void __inline__ init_timer(struct timer_list* t)
674 {
675 INIT_LIST_HEAD(&t->timer_list);
676 t->function=NULL;
677 t->expires=0;
678 }
679
680 static void __inline__ add_timer(struct timer_list* t)
681 {
682 int n;
683 for(n=0;n<MAX_TIMERS;n++)
684 if (main_timer_list[n]==0)
685 {
686 main_timer_list[n]=t;
687 break;
688 }
689 }
690
691 static void __inline__ del_timer(struct timer_list* t)
692 {
693 int n;
694 for(n=0;n<MAX_TIMERS;n++)
695 if (main_timer_list[n]==t)
696 {
697 main_timer_list[n]=0;
698 break;
699 }
700 }
701 static void __inline__ del_timer_sync(struct timer_list* t)
702 {
703 int n;
704 for(n=0;n<MAX_TIMERS;n++)
705 if (main_timer_list[n]==t)
706 {
707 main_timer_list[n]=0;
708 break;
709 }
710
711 }
712 static void __inline__ mod_timer(struct timer_list* t, int ex)
713 {
714 del_timer(t);
715 t->expires=ex;
716 add_timer(t);
717 }
718
719 #define time_after_eq(a,b) \
720 (((long)(a) - (long)(b) >= 0))
721
722 /*------------------------------------------------------------------------*/
723 /* Device driver and process related stuff */
724 /*------------------------------------------------------------------------*/
725
726 static int __inline__ usb_major_init(void){return 0;}
727 static void __inline__ usb_major_cleanup(void){}
728 static void __inline__ schedule_work(void* p){}
729
730 #define device_initialize(x) my_device_initialize(x)
731 void my_device_initialize(struct device *dev);
732
733 #define get_device(x) my_get_device(x)
734 struct device *my_get_device(struct device *dev);
735
736 #define device_add(x) my_device_add(x)
737 int my_device_add(struct device *dev);
738
739 #define driver_register(x) my_driver_register(x)
740 int my_driver_register(struct device_driver *driver);
741
742 #define device_unregister(a) my_device_unregister(a)
743 int my_device_unregister(struct device *dev);
744
745 #define DEVICE_ATTR(a,b,c,d) int xxx_##a
746 #define device_create_file(a,b) do {} while(0)
747 #define device_remove_file(a,b) do {} while(0)
748
749 #define schedule_timeout(x) my_schedule_timeout(x)
750 int my_schedule_timeout(int x);
751
752 #define wake_up(x) my_wake_up(x)
753 void my_wake_up(PKEVENT);
754
755 // cannot be mapped via macro due to collision with urb->complete
756 static void __inline__ complete(struct completion *p)
757 {
758 /* Wake up x->wait */
759 p->done++;
760 wake_up(&p->wait);
761 }
762
763 #define kernel_thread(a,b,c) my_kernel_thread(a,b,c)
764 int my_kernel_thread(int STDCALL (*handler)(void*), void* parm, int flags);
765
766 /*------------------------------------------------------------------------*/
767 /* PCI, simple and inlined... */
768 /*------------------------------------------------------------------------*/
769 #include "pci_hal.c"
770
771 /*------------------------------------------------------------------------*/
772 /* IRQ handling */
773 /*------------------------------------------------------------------------*/
774
775 #define request_irq(a,b,c,d,e) my_request_irq(a,b,c,d,e)
776 int my_request_irq(unsigned int irq,
777 int (*handler)(int, void *, struct pt_regs *),
778 unsigned long mode, const char *desc, void *data);
779
780 #define free_irq(a,b) my_free_irq(a,b)
781 int free_irq(int irq, void* p);
782
783
784
785 struct my_irqs {
786 int (*handler)(int, void *, struct pt_regs *);
787 int irq;
788 void* data;
789 };
790
791 #define MAX_IRQS 8
792
793 // Exported to top level
794
795 void handle_irqs(int irq);
796 void inc_jiffies(int);
797 void init_wrapper(struct pci_dev *pci_dev);
798 void do_all_timers(void);
799
800 #define __KERNEL_DS 0x18
801
802