Updated linux wrapper to contain more funcs (to allow UHCI in the future), also wait...
authorAleksey Bragin <aleksey@reactos.org>
Fri, 25 Feb 2005 15:05:51 +0000 (15:05 +0000)
committerAleksey Bragin <aleksey@reactos.org>
Fri, 25 Feb 2005 15:05:51 +0000 (15:05 +0000)
svn path=/trunk/; revision=13741

reactos/drivers/usb/cromwell/core/hcd.h
reactos/drivers/usb/cromwell/core/hub.c
reactos/drivers/usb/cromwell/core/makefile
reactos/drivers/usb/cromwell/core/message.c
reactos/drivers/usb/cromwell/host/makefile
reactos/drivers/usb/cromwell/linux/linux_wrapper.h
reactos/drivers/usb/cromwell/linux/pci_ids.h
reactos/drivers/usb/cromwell/sys/linuxwrapper.c
reactos/drivers/usb/cromwell/usb_wrapper.h

index 15eae1d..266324d 100644 (file)
@@ -161,6 +161,56 @@ struct usb_operations {
 \r
 struct pt_regs;\r
 \r
+// new struct from 2.6\r
+struct hc_driver {\r
+       const char      *description;   /* "ehci-hcd" etc */\r
+\r
+       /* irq handler */\r
+       irqreturn_t     (*irq) (struct usb_hcd *hcd, struct pt_regs *regs);\r
+\r
+       int     flags;\r
+#define        HCD_MEMORY      0x0001          /* HC regs use memory (else I/O) */\r
+#define        HCD_USB11       0x0010          /* USB 1.1 */\r
+#define        HCD_USB2        0x0020          /* USB 2.0 */\r
+\r
+       /* called to init HCD and root hub */\r
+       int     (*reset) (struct usb_hcd *hcd);\r
+       int     (*start) (struct usb_hcd *hcd);\r
+\r
+       /* called after all devices were suspended */\r
+       int     (*suspend) (struct usb_hcd *hcd, u32 state);\r
+\r
+       /* called before any devices get resumed */\r
+       int     (*resume) (struct usb_hcd *hcd);\r
+\r
+       /* cleanly make HCD stop writing memory and doing I/O */\r
+       void    (*stop) (struct usb_hcd *hcd);\r
+\r
+       /* return current frame number */\r
+       int     (*get_frame_number) (struct usb_hcd *hcd);\r
+\r
+       /* memory lifecycle */\r
+       struct usb_hcd  *(*hcd_alloc) (void);\r
+       void            (*hcd_free) (struct usb_hcd *hcd);\r
+\r
+       /* manage i/o requests, device state */\r
+       int     (*urb_enqueue) (struct usb_hcd *hcd, struct urb *urb,\r
+                                       int mem_flags);\r
+       int     (*urb_dequeue) (struct usb_hcd *hcd, struct urb *urb);\r
+\r
+       /* hw synch, freeing endpoint resources that urb_dequeue can't */\r
+       void    (*endpoint_disable)(struct usb_hcd *hcd,\r
+                       struct hcd_dev *dev, int bEndpointAddress);\r
+\r
+       /* root hub support */\r
+       int             (*hub_status_data) (struct usb_hcd *hcd, char *buf);\r
+       int             (*hub_control) (struct usb_hcd *hcd,\r
+                               u16 typeReq, u16 wValue, u16 wIndex,\r
+                               char *buf, u16 wLength);\r
+};\r
+\r
+// old version, "just in case"\r
+#if 0\r
 struct hc_driver {\r
        const char      *description;   /* "ehci-hcd" etc */\r
 \r
@@ -206,6 +256,7 @@ struct hc_driver {
                                u16 typeReq, u16 wValue, u16 wIndex,\r
                                char *buf, u16 wLength);\r
 };\r
+#endif\r
 \r
 extern void STDCALL usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb, struct pt_regs *regs);\r
 extern void STDCALL usb_bus_init (struct usb_bus *bus);\r
index b60aa8d..1b7e820 100644 (file)
@@ -1151,9 +1151,9 @@ static int hub_thread(void *__hub)
 \r
                //FIXME: Correct this\r
                //wait_event_interruptible(khubd_wait, !list_empty(&hub_event_list)); // interruptable_sleep_on analog - below\r
-               /*while (!list_empty(&hub_event_list)) {\r
+               while (!list_empty(&hub_event_list)) {\r
                        interruptible_sleep_on(&khubd_wait);\r
-               }*/\r
+               }\r
 \r
                if (current->flags & PF_FREEZE)\r
                        refrigerator(PF_IOTHREAD);\r
@@ -1190,6 +1190,10 @@ int usb_hub_init(void)
 {\r
        pid_t pid;\r
 \r
+       // ReactOS-specific\r
+       // Create Event object, initialize other sync events\r
+       KeInitializeEvent(&khubd_wait, NotificationEvent, TRUE); // signalled state\r
+\r
        if (usb_register(&hub_driver) < 0) {\r
                err("Unable to register USB hub driver");\r
                return -1;\r
index 27d2ff9..5301aa3 100644 (file)
@@ -16,3 +16,7 @@ TARGET_OBJECTS = \
 include $(PATH_TO_TOP)/rules.mak\r
 \r
 include $(TOOLS_PATH)/helper.mk\r
+\r
+# Automatic dependency tracking\r
+DEP_OBJECTS := $(TARGET_OBJECTS)\r
+include $(PATH_TO_TOP)/tools/depend.mk\r
index b43a52d..749c76b 100644 (file)
@@ -15,6 +15,9 @@
 \r
 #include "hcd.h"       /* for usbcore internals */\r
 \r
+// ReactOS specific: No WAITQUEUEs here\r
+#define wake_up(a) do {} while(0)\r
+\r
 struct usb_api_data {\r
        wait_queue_head_t wqh;\r
        int done;\r
index fa4c7e6..e2e02ed 100644 (file)
@@ -14,3 +14,7 @@ TARGET_OBJECTS = \
 include $(PATH_TO_TOP)/rules.mak\r
 \r
 include $(TOOLS_PATH)/helper.mk\r
+\r
+# Automatic dependency tracking\r
+DEP_OBJECTS := $(TARGET_OBJECTS)\r
+include $(PATH_TO_TOP)/tools/depend.mk\r
index 89308c7..3de8596 100644 (file)
@@ -12,6 +12,9 @@
  *\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
@@ -145,6 +148,14 @@ struct completion {
         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
@@ -286,6 +297,8 @@ struct usbdevfs_hub_portinfo
 #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
@@ -313,6 +326,10 @@ struct usbdevfs_hub_portinfo
 #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
@@ -372,7 +389,7 @@ struct usbdevfs_hub_portinfo
 #define down_read(a) do {} while(0)\r
 #define up_read(a) do {} while(0)\r
 \r
-#define DECLARE_WAIT_QUEUE_HEAD(x) int x\r
+#define DECLARE_WAIT_QUEUE_HEAD(x) KEVENT x\r
 \r
 #define DECLARE_COMPLETION(x) struct completion x\r
 \r
@@ -383,6 +400,8 @@ struct usbdevfs_hub_portinfo
 \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
@@ -427,6 +446,16 @@ int my_pci_module_init(struct pci_driver *x);
 #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
@@ -451,11 +480,15 @@ int my_pci_module_init(struct pci_driver *x);
 #define PCI_ROM_RESOURCE 0\r
 #define IORESOURCE_IO 1\r
 \r
-#define DECLARE_WAITQUEUE(a,b) wait_queue_head_t a=0\r
-#define init_waitqueue_head(a) do {} while(0)\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
@@ -478,7 +511,7 @@ void my_wait_for_completion(struct completion*);
 #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(int 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
@@ -492,6 +525,25 @@ int my_kill_proc(int pid, int signal, int unk);
 #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
+void 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
@@ -559,6 +611,21 @@ int my_kill_proc(int pid, int signal, int unk);
 #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
@@ -647,6 +714,9 @@ static void __inline__ mod_timer(struct timer_list* t, int ex)
        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
@@ -678,7 +748,7 @@ int my_device_unregister(struct device *dev);
 int my_schedule_timeout(int x);\r
 \r
 #define wake_up(x) my_wake_up(x)\r
-void my_wake_up(void*);\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
index 5384136..77a1569 100644 (file)
@@ -5,7 +5,10 @@
 #define PCI_DEVICE_ID_NS_87560_LIO     0x000e\r
 #define        PCI_VENDOR_ID_AMD               0x1022\r
 #define PCI_VENDOR_ID_OPTI             0x1045\r
+#define PCI_VENDOR_ID_VIA              0x1106\r
+#define PCI_VENDOR_ID_INTEL            0x8086\r
 \r
 #define PCI_CLASS_SERIAL_USB (PCI_CLASS_SERIAL_BUS_CTLR << 8 + PCI_SUBCLASS_SB_USB)\r
 \r
 #endif\r
+\r
index e1170e9..39791ea 100644 (file)
@@ -134,6 +134,8 @@ int my_kill_proc(int pid, int signal, int unk)
 {\r
        HANDLE hThread;\r
 \r
+       // TODO: Implement actual process killing\r
+\r
        hThread = (HANDLE)pid;\r
        ZwClose(hThread);\r
 \r
@@ -208,9 +210,17 @@ void my_device_initialize(struct device *dev)
 {\r
 }\r
 /*------------------------------------------------------------------------*/ \r
-void my_wake_up(void* p)\r
+void my_wake_up(PKEVENT evnt)\r
 {\r
        need_wakeup=1;\r
+\r
+       KeSetEvent(evnt, 0, FALSE); // Signal event\r
+}\r
+/*------------------------------------------------------------------------*/ \r
+void my_init_waitqueue_head(PKEVENT evnt)\r
+{\r
+       // this is used only in core/message.c, and it isn't needed there\r
+       //KeInitializeEvent(evnt, NotificationEvent, TRUE); // signalled state\r
 }\r
 /*------------------------------------------------------------------------*/ \r
 /* wait until woken up (only one wait allowed!) */\r
@@ -254,6 +264,12 @@ void my_wait_for_completion(struct completion *x)
 //     printk("wait for completion done %i\n",x->done);\r
 }\r
 /*------------------------------------------------------------------------*/ \r
+void my_interruptible_sleep_on(PKEVENT evnt)\r
+{\r
+       KeWaitForSingleObject(evnt, Executive, KernelMode, FALSE, NULL);\r
+       KeClearEvent(evnt); // reset to not-signalled\r
+}\r
+/*------------------------------------------------------------------------*/ \r
 // Helper for pci_module_init\r
 /*------------------------------------------------------------------------*/ \r
 int my_pci_module_init(struct pci_driver *x)\r
@@ -294,4 +310,55 @@ int my_free_irq(int irq, void* p)
        /* No free... */\r
        return 0;\r
 }\r
-/*------------------------------------------------------------------------*/ 
\ No newline at end of file
+/*------------------------------------------------------------------------*/ \r
+// Lookaside funcs\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
+       //TODO: Take in account ctor and dtor - callbacks for alloc/free, flags and offset\r
+       //FIXME: We assume this cache is always NPaged\r
+       PNPAGED_LOOKASIDE_LIST Lookaside;\r
+       ULONG Tag=0x11223344; //FIXME: Make this from tag\r
+\r
+       Lookaside = ExAllocatePool(NonPagedPool, sizeof(NPAGED_LOOKASIDE_LIST));\r
+       \r
+       ExInitializeNPagedLookasideList(\r
+               Lookaside,\r
+               NULL,\r
+               NULL,\r
+               0,\r
+               alloc_size,\r
+               Tag,\r
+               0);\r
+\r
+       return (kmem_cache_t *)Lookaside;\r
+}\r
+/*------------------------------------------------------------------------*/ \r
+void my_kmem_cache_destroy(kmem_cache_t *co)\r
+{\r
+       ExDeleteNPagedLookasideList((PNPAGED_LOOKASIDE_LIST)co);\r
+\r
+    ExFreePool(co);\r
+}\r
+/*------------------------------------------------------------------------*/ \r
+void *my_kmem_cache_alloc(kmem_cache_t *co, int flags)\r
+{\r
+       return ExAllocateFromNPagedLookasideList((PNPAGED_LOOKASIDE_LIST)co);\r
+}\r
+/*------------------------------------------------------------------------*/ \r
+void my_kmem_cache_free(kmem_cache_t *co, void *ptr)\r
+{\r
+       ExFreeToNPagedLookasideList((PNPAGED_LOOKASIDE_LIST)co, ptr);\r
+}\r
+/*------------------------------------------------------------------------*/ \r
+// DMA, not used now\r
+/*------------------------------------------------------------------------*/ \r
+void *my_dma_pool_alloc(struct dma_pool *pool, int gfp_flags, dma_addr_t *dma_handle)\r
+{\r
+       // HalAllocCommonBuffer\r
+       // But ideally IoGetDmaAdapter\r
+       return NULL;\r
+}\r
index 47e0d9b..4b810ca 100644 (file)
@@ -12,3 +12,4 @@ void wait_ms(int mils);
 #define CONFIG_PCI\r
 \r
 #include "linux/usb.h"\r
+#include "linux/pci_ids.h"
\ No newline at end of file