[fireball] 16642: Implemented needed DMA functions (pool alloc/free, create/destroy, map/unmap single), manipulations with timers (schedule_timeout, schedule_wait).

Implemented needed DMA functions (pool alloc/free, create/destroy,
map/unmap single), manipulations with timers (schedule_timeout,
schedule_wait).
Modified: trunk/reactos/drivers/usb/cromwell/host/ohci_main.h
Modified: trunk/reactos/drivers/usb/cromwell/linux/linux_wrapper.h
Modified: trunk/reactos/drivers/usb/cromwell/linux/usb.h
Modified: trunk/reactos/drivers/usb/cromwell/sys/linuxwrapper.c
  _____
Modified: trunk/reactos/drivers/usb/cromwell/host/ohci_main.h
--- trunk/reactos/drivers/usb/cromwell/host/ohci_main.h 2005-07-19
11:18:40 UTC (rev 16641)
+++ trunk/reactos/drivers/usb/cromwell/host/ohci_main.h 2005-07-19
13:19:04 UTC (rev 16642)
@@ -38,6 +38,20 @@
    ULONG SystemIoBusNumber;
    ULONG SystemIoSlotNumber;
    LIST_ENTRY AddressMappingListHead;
+
+   // DMA stuff, and buffers
+   PDMA_ADAPTER pDmaAdapter;
+   PVOID MapRegisterBase;
+   ULONG mapRegisterCount;
+#ifdef USB_DMA_SINGLE_SUPPORT
+   PHYSICAL_ADDRESS Buffer;
+   PVOID VirtualBuffer;
+   ULONG BufferSize;
+
+   // Mdl used for single DMA transfers
+   PMDL Mdl;
+#endif
+
    //KDPC DpcObject;
    OHCI_DRIVER_EXTENSION *DriverExtension;
    ULONG DeviceOpened;
  _____
Modified: trunk/reactos/drivers/usb/cromwell/linux/linux_wrapper.h
--- trunk/reactos/drivers/usb/cromwell/linux/linux_wrapper.h
2005-07-19 11:18:40 UTC (rev 16641)
+++ trunk/reactos/drivers/usb/cromwell/linux/linux_wrapper.h
2005-07-19 13:19:04 UTC (rev 16642)
@@ -34,7 +34,7 @@
 typedef u32 dma_addr_t;
-typedef  int spinlock_t;
+typedef int spinlock_t;
 typedef int atomic_t;
 #ifndef STANDALONE
 #ifndef _MODE_T_
@@ -123,6 +123,8 @@
        struct device *parent;
        struct list_head driver_list;
        void    (*release)(struct device * dev);
+
+       void *dev_ext; // ReactOS-specific: pointer to windows device
extension
 };
 struct class_device{int a;};
 struct semaphore{int a;};
@@ -165,8 +167,20 @@
        int dummy;
 };
+/* These definitions mirror those in pci.h, so they can be used
+ * interchangeably with their PCI_ counterparts */
+enum dma_data_direction {
+       DMA_BIDIRECTIONAL = 0,
+       DMA_TO_DEVICE = 1,
+       DMA_FROM_DEVICE = 2,
+       DMA_NONE = 3,
+};
+
+/* compatibility */
+#define PCI_DMA_TODEVICE DMA_TO_DEVICE
+#define PCI_DMA_FROMDEVICE DMA_FROM_DEVICE
+
 /* from mod_devicetable.h */
-
 struct usb_device_id {
         /* which fields to match against? */
         __u16           match_flags;
@@ -409,43 +423,49 @@
 /* PCI */
-#define        to_pci_dev(n) container_of(n, struct pci_dev, dev)
+#define MAX_POOL_PAGES 2
+#define BITS_PER_LONG 32
-#define pci_pool_create(a,b,c,d,e) (void*)1
+struct pci_page
+{
+       PHYSICAL_ADDRESS dmaAddress;
+       PVOID   virtualAddress;
-#define pci_pool_alloc(a,b,c)  my_pci_pool_alloc(a,b,c)
+       unsigned long bitmap[128]; // 128 == 32bits*4096 blocks
+};
-static void __inline__ *my_pci_pool_alloc(void* pool, size_t size,
-                                               dma_addr_t *dma_handle)
+struct pci_pool
 {
-       void* a;
-       a=kmalloc(size,0); //FIXME
-#ifdef MODULE
-       *dma_handle=((u32)a)&0xfffffff;
-#else
-       *dma_handle=(u32)a;
-#endif
-       return a;
-}
+       char name[32];
+       size_t size;
+       size_t allocation;
+       size_t blocks_per_page;
+       struct pci_dev *pdev;
+       // internal stuff
+       int pages_allocated;
+       int blocks_allocated;
-#define pci_pool_free(a,b,c)    kfree(b)
-#define pci_alloc_consistent(a,b,c) my_pci_alloc_consistent(a,b,c)
+       struct pci_page pages[MAX_POOL_PAGES];
+};
-static void  __inline__ *my_pci_alloc_consistent(struct pci_dev *hwdev,
size_t size,
-                                               dma_addr_t *dma_handle)
-{
-       void* a;
+#define        to_pci_dev(n) container_of(n, struct pci_dev, dev)
-       a=kmalloc(size+256,0); //FIXME
-       a=(void*)(((int)a+255)&~255); // 256 alignment
-       *dma_handle=((u32)a)&0xfffffff;
+#define pci_pool_create(a,b,c,d,e) my_pci_pool_create(a,b,c,d,e)
+struct pci_pool *my_pci_pool_create(const char * name, struct pci_dev *
pdev, size_t size, size_t align, size_t allocation);
-       return a;
-}
+#define pci_pool_alloc(a,b,c)  my_pci_pool_alloc(a,b,c)
+void *my_pci_pool_alloc(struct pci_pool * pool, int mem_flags,
dma_addr_t *dma_handle);
+#define pci_pool_free(a,b,c)    my_pci_pool_free(a,b,c)
+void my_pci_pool_free(struct pci_pool * pool, void * vaddr, dma_addr_t
dma);
+
+#define pci_alloc_consistent(a,b,c) my_pci_alloc_consistent(a,b,c)
+void  *my_pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
dma_addr_t *dma_handle);
+
 #define pci_free_consistent(a,b,c,d)  kfree(c)
-#define pci_pool_destroy(a)           do {} while(0)
+#define pci_pool_destroy(a)           my_pci_pool_destroy(a)
+void my_pci_pool_destroy (struct pci_pool * pool);
 #define pci_module_init(x) my_pci_module_init(x)
 int my_pci_module_init(struct pci_driver *x);
@@ -464,17 +484,29 @@
 #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_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)
my_dma_map_single(a,b,c,d)
+dma_addr_t my_dma_map_single(struct device *hwdev, void *ptr, size_t
size, enum dma_data_direction direction);
-#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 dma_unmap_single(a,b,c,d)      my_dma_unmap_single(a,b,c,d)
+void my_dma_unmap_single(struct device *dev, dma_addr_t dma_addr,
size_t size, enum dma_data_direction direction);
+#define pci_unmap_single(a,b,c,d)      my_pci_unmap_single(a,b,c,d)
+void my_pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr,
size_t size, int direction);
+
+#define dma_sync_single(a,b,c,d)       my_dma_sync_single(a,b,c,d)
+void my_dma_sync_single(struct device *hwdev, dma_addr_t dma_handle,
size_t size, int direction);
+
+#define dma_sync_sg(a,b,c,d)           my_dma_sync_sg(a,b,c,d)
+void my_dma_sync_sg(struct device *hwdev,  struct scatterlist *sg, int
nelems, int direction);
+
+#define dma_map_sg(a,b,c,d)                    my_dma_map_sg(a,b,c,d)
+int my_dma_map_sg(struct device *hwdev, struct scatterlist *sg, int
nents, enum dma_data_direction direction);
+
+#define dma_unmap_sg(a,b,c,d)          my_dma_unmap_sg(a,b,c,d)
+void my_dma_unmap_sg(struct device *hwdev, struct scatterlist *sg, int
nents, enum dma_data_direction direction);
+
 #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))
@@ -482,12 +514,6 @@
 #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
  _____
Modified: trunk/reactos/drivers/usb/cromwell/linux/usb.h
--- trunk/reactos/drivers/usb/cromwell/linux/usb.h      2005-07-19
11:18:40 UTC (rev 16641)
+++ trunk/reactos/drivers/usb/cromwell/linux/usb.h      2005-07-19
13:19:04 UTC (rev 16642)
@@ -327,7 +327,7 @@
 {
        int actual;
        actual = snprintf (buf, size, "usb-%s-%s", dev->bus->bus_name,
dev->devpath);
-       return (actual >= (int)size) ? -1 : actual;
+       return (actual >= size) ? -1 : actual;
 }
/*----------------------------------------------------------------------
---*/
  _____
Modified: trunk/reactos/drivers/usb/cromwell/sys/linuxwrapper.c
--- trunk/reactos/drivers/usb/cromwell/sys/linuxwrapper.c
2005-07-19 11:18:40 UTC (rev 16641)
+++ trunk/reactos/drivers/usb/cromwell/sys/linuxwrapper.c
2005-07-19 13:19:04 UTC (rev 16642)
@@ -40,8 +40,11 @@
 #define MAX_DRVS 8
 static struct device_driver *m_drivers[MAX_DRVS];
-static int drvs_num;
+static int drvs_num=0;
+unsigned int LAST_USB_EVENT_TICK;
+NTSTATUS init_dma(POHCI_DEVICE_EXTENSION pDevExt);
+
/*----------------------------------------------------------------------
--*/
 /*
  * Helper functions for top-level system
@@ -69,6 +72,8 @@
        need_wakeup=0;
        for(n=0;n<MAX_DRVS;n++)
                m_drivers[n]=NULL;
+
+       init_dma(probe_dev->dev_ext);
 }
/*----------------------------------------------------------------------
--*/
 void handle_irqs(int irq)
@@ -92,17 +97,20 @@
        int n;
        for(n=0;n<MAX_TIMERS;n++)
        {
-               if (main_timer_list[n] &&
-                   main_timer_list[n]->function &&
main_timer_list[n]->expires)
+               if (main_timer_list[n] && main_timer_list[n]->function)
                {
                        void (*function)(unsigned
long)=main_timer_list[n]->function;
                        unsigned long data=main_timer_list[n]->data;
-                       main_timer_list[n]->expires=0;
-
-                       main_timer_list[n]=NULL; // remove timer
-                       //printk("do timer %i fn %p\n",n,function);
-
-                       function(data);
+
+                       if (main_timer_list[n]->expires>1) {
+                               main_timer_list[n]->expires--;
+                       } else {
+
+                               main_timer_list[n]->expires=0;
+                               main_timer_list[n]=0; // remove timer
+                               // Call Timer Function Data
+                               function(data);
+                       }
                }
        }
 }
@@ -118,13 +126,13 @@
        ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
-       /*PsCreateSystemThread(&hThread,
+       PsCreateSystemThread(&hThread,
                             THREAD_ALL_ACCESS,
                             NULL,
                             NULL,
                             NULL,
                             (PKSTART_ROUTINE)handler,
-                                parm);*/
+                                parm);
        DPRINT1("usbcore: Created system thread %d\n", (int)hThread);
@@ -229,24 +237,42 @@
 }
/*----------------------------------------------------------------------
--*/
 /* wait until woken up (only one wait allowed!) */
+extern unsigned int LAST_USB_IRQ;
+
 int my_schedule_timeout(int x)
 {
-       int wait=1;
-       x+=10; // safety
-       printk("schedule_timeout %i\n",x);
+       LONGLONG HH;
+       LONGLONG temp;
+       LONGLONG delay;
+       extern unsigned int LAST_USB_EVENT_TICK;
+       printk("schedule_timeout: %d ms\n", x);
+
+       x+=5; // safety
+       x = x*1000;     // to us format
+
        while(x>0)
        {
-               do_all_timers();
-#ifndef HAVE_IRQS
-               handle_irqs(-1);
+               KeQueryTickCount((LARGE_INTEGER
*)&HH);//IoInputDword(0x8008);
+       temp = HH - LAST_USB_EVENT_TICK;
+
+               //if (temp>(3579)) { //3579 = 1ms!
+               if (temp>1000) {
+                       do_all_timers();
+                       LAST_USB_EVENT_TICK = HH;
+               }
-#endif
+                       //if (LAST_USB_IRQ != OHCI_1_INTERRUPT ) {
+               //              LAST_USB_IRQ = OHCI_1_INTERRUPT;
+                       handle_irqs(-1);
+               //}
+
                if (need_wakeup)
                        break;
-               wait_ms(wait);
-               inc_jiffies(wait);
-               x-=wait;
+
+               delay = 10;
+               KeDelayExecutionThread(KernelMode, FALSE, (LARGE_INTEGER
*)&delay); //wait_us(1);
+               x-=1;
        }
        need_wakeup=0;
        printk("schedule DONE!!!!!!\n");
@@ -256,17 +282,34 @@
/*----------------------------------------------------------------------
--*/
 void my_wait_for_completion(struct completion *x)
 {
-       int n=100;
+       LONGLONG HH;
+       LONGLONG temp;
+       LONGLONG delay;
+       extern unsigned int LAST_USB_EVENT_TICK;
+
        printk("wait for completion\n");
+       int n=10;
+       n = n*1000;     // to us format
+
        while(!x->done && (n>0))
        {
-               do_all_timers();
-#ifndef HAVE_IRQS
-               handle_irqs(-1);
+               KeQueryTickCount((LARGE_INTEGER
*)&HH);//IoInputDword(0x8008);
+               temp = HH - LAST_USB_EVENT_TICK;
-#endif
-               wait_ms(10);
+               //if (temp>(3579)) {
+               if (temp>(1000)) {
+                       do_all_timers();
+                       LAST_USB_EVENT_TICK = HH;
+               }
+
+               //if (LAST_USB_IRQ != OHCI_1_INTERRUPT ) {
+               //      LAST_USB_IRQ = OHCI_1_INTERRUPT;
+                       handle_irqs(-1);
+               //}
+
+               delay = 10;
+               KeDelayExecutionThread(KernelMode, FALSE, (LARGE_INTEGER
*)&delay); //wait_us(1);
                n--;
        }
        printk("wait for completion done %i\n",x->done);
@@ -374,11 +417,468 @@
        ExFreeToNPagedLookasideList((PNPAGED_LOOKASIDE_LIST)co, ptr);
 }
/*----------------------------------------------------------------------
--*/
-// DMA, not used now
+// DMA support routines
/*----------------------------------------------------------------------
--*/
+#ifdef USB_DMA_SINGLE_SUPPORT
+static IO_ALLOCATION_ACTION NTAPI MapRegisterCallback(PDEVICE_OBJECT
DeviceObject,
+                                                      PIRP Irp,
+                                                      PVOID
MapRegisterBase,
+                                                      PVOID Context);
+#endif
+
+NTSTATUS
+init_dma(POHCI_DEVICE_EXTENSION pDevExt)
+{
+       // Prepare device descriptor structure
+       DEVICE_DESCRIPTION dd;
+#ifdef USB_DMA_SINGLE_SUPPORT
+       KEVENT DMAEvent;
+       KIRQL OldIrql;
+       NTSTATUS Status;
+#endif
+
+       RtlZeroMemory( &dd, sizeof(dd) );
+       dd.Version = DEVICE_DESCRIPTION_VERSION;
+       dd.Master = TRUE;
+       dd.ScatterGather = TRUE;
+       dd.DemandMode = FALSE;
+       dd.AutoInitialize = FALSE;
+       dd.Dma32BitAddresses = TRUE;
+       dd.InterfaceType = PCIBus;
+       dd.DmaChannel = 0;//pDevExt->dmaChannel;
+       dd.MaximumLength = 128;//MAX_DMA_LENGTH;
+       dd.DmaWidth = Width32Bits;
+       dd.DmaSpeed = MaximumDmaSpeed;
+
+       // The following taken from Win2k DDB:
+       // "Compute the maximum number of mapping regs
+       // this device could possibly need. Since the
+       // transfer may not be paged aligned, add one
+       // to allow the max xfer size to span a page."
+       //pDevExt->mapRegisterCount = (MAX_DMA_LENGTH / PAGE_SIZE) + 1;
+
+    // TODO: Free it somewhere (PutDmaAdapter)
+       pDevExt->pDmaAdapter =
+               IoGetDmaAdapter( pDevExt->PhysicalDeviceObject,
+               &dd,
+               &pDevExt->mapRegisterCount);
+
+       DPRINT1("IoGetDmaAdapter done 0x%X, mapRegisterCount=%d\n",
pDevExt->pDmaAdapter, pDevExt->mapRegisterCount);
+
+       // Fail if failed
+       if (pDevExt->pDmaAdapter == NULL)
+               return STATUS_INSUFFICIENT_RESOURCES;
+
+#ifdef USB_DMA_SINGLE_SUPPORT
+       /* Allocate buffer now */
+    pDevExt->BufferSize = pDevExt->mapRegisterCount * PAGE_SIZE;
+    DPRINT1("Bufsize = %u\n", pDevExt->BufferSize);
+    pDevExt->VirtualBuffer =
pDevExt->pDmaAdapter->DmaOperations->AllocateCommonBuffer(
+
pDevExt->pDmaAdapter, pDevExt->BufferSize, &pDevExt->Buffer, FALSE);
+    DPRINT1("Bufsize = %u, Buffer = 0x%x", pDevExt->BufferSize,
pDevExt->Buffer.LowPart);
+
+       if (!pDevExt->VirtualBuffer)
+    {
+        DPRINT1("Could not allocate buffer\n");
+        // should try again with smaller buffer...
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
+
+    DPRINT1("Calling IoAllocateMdl()\n");
+    pDevExt->Mdl = IoAllocateMdl(pDevExt->VirtualBuffer,
pDevExt->BufferSize, FALSE, FALSE, NULL);
+    DPRINT1("Bufsize == %u\n", pDevExt->BufferSize);
+
+    if (!pDevExt->Mdl)
+    {
+        DPRINT1("IoAllocateMdl() FAILED\n");
+        //TODO: Free the HAL buffer
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
+
+    DPRINT1("VBuffer == 0x%x Mdl == %u Bufsize == %u\n",
pDevExt->VirtualBuffer, pDevExt->Mdl, pDevExt->BufferSize);
+
+    DPRINT1("Calling MmBuildMdlForNonPagedPool\n");
+    MmBuildMdlForNonPagedPool(pDevExt->Mdl);
+
+
+       /* Get map registers for DMA */
+       KeInitializeEvent(&DMAEvent, SynchronizationEvent, FALSE);
+
+       KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+       // TODO: Free adapter channel somewhere
+       Status =
pDevExt->pDmaAdapter->DmaOperations->AllocateAdapterChannel(pDevExt->pDm
aAdapter,
+                               pDevExt->PhysicalDeviceObject,
pDevExt->mapRegisterCount, MapRegisterCallback, &DMAEvent);
+       KeLowerIrql(OldIrql);
+
+    DPRINT1("VBuffer == 0x%x Bufsize == %u\n", pDevExt->VirtualBuffer,
pDevExt->BufferSize);
+    KeWaitForSingleObject(&DMAEvent, Executive, KernelMode, FALSE,
NULL);
+
+       if(Status != STATUS_SUCCESS)
+       {
+               DPRINT("init_dma(): unable to allocate adapter
channels\n");
+               return STATUS_INSUFFICIENT_RESOURCES;
+       }
+#endif
+       return STATUS_SUCCESS;
+}
+
+/*
+ * FUNCTION: Acquire map registers in prep for DMA
+ * ARGUMENTS:
+ *     DeviceObject: unused
+ *     Irp: unused
+ *     MapRegisterBase: returned to blocked thread via a member var
+ *     Context: contains a pointer to the right ControllerInfo
+ *     struct
+ * RETURNS:
+ *     KeepObject, because that's what the DDK says to do
+ */
+#ifdef USB_DMA_SINGLE_SUPPORT
+static IO_ALLOCATION_ACTION NTAPI MapRegisterCallback(PDEVICE_OBJECT
DeviceObject,
+                                                      PIRP Irp,
+                                                      PVOID
MapRegisterBase,
+                                                      PVOID Context)
+{
+       POHCI_DEVICE_EXTENSION pDevExt =
(POHCI_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+       UNREFERENCED_PARAMETER(Irp);
+
+       DPRINT("usb_linuxwrapper: MapRegisterCallback Called,
base=0x%08x\n", MapRegisterBase);
+
+       pDevExt->MapRegisterBase = MapRegisterBase;
+
+       // signal that we are finished
+    KeSetEvent(Context, 0, FALSE);
+
+       return KeepObject;//DeallocateObjectKeepRegisters;
+}
+#endif
+
 void *my_dma_pool_alloc(struct dma_pool *pool, int gfp_flags,
dma_addr_t *dma_handle)
 {
        // HalAllocCommonBuffer
        // But ideally IoGetDmaAdapter
+
+       DPRINT1("dma_pool_alloc() called\n");
        return NULL;
 }
+
+/*
+pci_pool_create --  Creates a pool of pci consistent memory blocks, for
dma.
+
+struct pci_pool * pci_pool_create (const char * name, struct pci_dev *
pdev, size_t size, size_t align, size_t allocation, int flags);
+
+Arguments:
+name - name of pool, for diagnostics
+pdev - pci device that will be doing the DMA
+size - size of the blocks in this pool.
+align - alignment requirement for blocks; must be a power of two
+allocation - returned blocks won't cross this boundary (or zero)
+flags - SLAB_* flags (not all are supported).
+
+Description:
+Returns a pci allocation pool with the requested characteristics, or
null if one can't be created.
+Given one of these pools, pci_pool_alloc may be used to allocate
memory. Such memory will all have
+"consistent" DMA mappings, accessible by the device and its driver
without using cache flushing
+primitives. The actual size of blocks allocated may be larger than
requested because of alignment.
+If allocation is nonzero, objects returned from pci_pool_alloc won't
cross that size boundary.
+This is useful for devices which have addressing restrictions on
individual DMA transfers, such
+as not crossing boundaries of 4KBytes.
+*/
+struct pci_pool *my_pci_pool_create(const char * name, struct pci_dev *
pdev, size_t size, size_t align, size_t allocation)
+{
+       struct pci_pool         *retval;
+
+       if (align == 0)
+               align = 1;
+       if (size == 0)
+               return 0;
+       else if (size < align)
+               size = align;
+       else if ((size % align) != 0) {
+               size += align + 1;
+               size &= ~(align - 1);
+       }
+
+       if (allocation == 0) {
+               if (PAGE_SIZE < size)
+                       allocation = size;
+               else
+                       allocation = PAGE_SIZE;
+               // FIXME: round up for less fragmentation
+       } else if (allocation < size)
+               return 0;
+
+       retval = ExAllocatePool(NonPagedPool, sizeof(retval)); //FIXME:
Should it be non-paged?
+
// pci_pool is rather big struct
+
+       // fill retval structure
+       strncpy (retval->name, name, sizeof retval->name);
+       retval->name[sizeof retval->name - 1] = 0;
+
+       retval->allocation = allocation;
+       retval->size = size;
+       retval->blocks_per_page = allocation / size;
+       retval->pdev = pdev;
+
+       retval->pages_allocated = 0;
+       retval->blocks_allocated = 0;
+
+       DPRINT1("pci_pool_create(): %s/%s size %d, %d/page (%d
alloc)\n",
+               pdev ? pdev->slot_name : NULL, retval->name, size,
+               retval->blocks_per_page, allocation);
+
+       return retval;
+}
+
+/*
+Name:
+pci_pool_alloc --  get a block of consistent memory
+
+Synopsis:
+void * pci_pool_alloc (struct pci_pool * pool, int mem_flags,
dma_addr_t * handle);
+
+Arguments:
+pool - pci pool that will produce the block
+
+mem_flags - SLAB_KERNEL or SLAB_ATOMIC
+
+handle - pointer to dma address of block
+
+Description:
+This returns the kernel virtual address of a currently unused block,
and reports its dma
+address through the handle. If such a memory block can't be allocated,
null is returned.
+*/
+void * my_pci_pool_alloc(struct pci_pool * pool, int mem_flags,
dma_addr_t *dma_handle)
+{
+       PVOID result;
+       POHCI_DEVICE_EXTENSION devExt =
(POHCI_DEVICE_EXTENSION)pool->pdev->dev_ext;
+       //PHYSICAL_ADDRESS logicalAddr;
+       DPRINT1("pci_pool_alloc() called, blocks already
allocated=%d\n", pool->blocks_allocated);
+       //size_t current_block_in_page;
+       int page,map,i,block,offset;
+
+       if (pool->pages_allocated == 0)
+       {
+               // we need to allocate at least one page
+               pool->pages[pool->pages_allocated].virtualAddress =
+
devExt->pDmaAdapter->DmaOperations->AllocateCommonBuffer(devExt->pDmaAda
pter,
+                               PAGE_SIZE,
&pool->pages[pool->pages_allocated].dmaAddress, FALSE); //FIXME:
Cache-enabled?
+
+               // mark all blocks as free (bit=set)
+               memset(pool->pages[pool->pages_allocated].bitmap, 0xFF,
128*sizeof(long));
+
+               /* FIXME: the next line replaces physical address by
virtual address:
+               * this change is needed to boot VMWare, but I'm really
not sure this
+               * change is correct!
+               */
+               //pool->pages[pool->pages_allocated].dmaAddress.QuadPart
= (ULONG_PTR)pool->pages[pool->pages_allocated].virtualAddress;
+               pool->pages_allocated++;
+       }
+
+       // search for a free block in all pages
+       for (page=0; page<pool->pages_allocated; page++)
+       {
+               for (map=0,i=0; i < pool->blocks_per_page; i+=
BITS_PER_LONG, map++)
+               {
+                       if (pool->pages[page].bitmap[map] == 0)
+                               continue;
+
+                       block = ffz(~ pool->pages[page].bitmap[map]);
+
+                       if ((i + block) < pool->blocks_per_page)
+                       {
+                               clear_bit(block,
&pool->pages[page].bitmap[map]);
+                               offset = (BITS_PER_LONG * map) + block;
+                               offset *= pool->size;
+                               goto ready;
+                       }
+               }
+       }
+
+       //TODO: alloc page here then
+       DPRINT1("Panic!! We need one more page to be allocated, and
Fireball doesn't want to alloc it!\n");
+       offset = 0;
+       return 0;
+
+ready:
+       *dma_handle = pool->pages[page].dmaAddress.QuadPart + offset;
+       result = (char *)pool->pages[page].virtualAddress + offset;
+       pool->blocks_allocated++;
+
+#if 0
+       // check do we have enough free blocks on the current page
+       if (pool->pages_allocated*pool->blocks_per_page <
pool->blocks_allocated+1)
+       {
+               DPRINT1("Panic!! We need one more page to be allocated,
and Fireball doesn't want to alloc it!\n");
+               *dma_handle = 0;
+               return NULL;
+       }
+
+       // Alloc one block now
+       pool->blocks_allocated++;
+       current_block_in_page = pool->blocks_allocated -
(pool->blocks_allocated / pool->blocks_per_page) *
pool->blocks_per_page;
+       *dma_handle =
pool->pages[pool->pages_allocated-1].dmaAddress.QuadPart +
pool->size*(current_block_in_page - 1);
+       result = pool->pages[pool->pages_allocated-1].virtualAddress +
pool->size*(current_block_in_page - 1);
+#endif
+
+       return result;
+}
+
+/*
+Name
+pci_pool_free --  put block back into pci pool
+Synopsis
+
+void pci_pool_free (struct pci_pool * pool, void * vaddr, dma_addr_t
dma);
+
+Arguments
+
+pool - the pci pool holding the block
+
+vaddr - virtual address of block
+
+dma - dma address of block
+
+Description:
+Caller promises neither device nor driver will again touch this block
unless it is first re-allocated.
+*/
+void my_pci_pool_free (struct pci_pool * pool, void * vaddr, dma_addr_t
dma)
+{
+       int page, block, map;
+
+       // Find page
+       for (page=0; page<pool->pages_allocated; page++)
+       {
+               if (dma < pool->pages[page].dmaAddress.QuadPart)
+                       continue;
+               if (dma < (pool->pages[page].dmaAddress.QuadPart +
pool->allocation))
+                       break;
+       }
+
+       block = dma - pool->pages[page].dmaAddress.QuadPart;
+       block /= pool->size;
+       map = block / BITS_PER_LONG;
+       block %= BITS_PER_LONG;
+
+       // mark as free
+       set_bit (block, &pool->pages[page].bitmap[map]);
+
+       pool->blocks_allocated--;
+
+       DPRINT1("pci_pool_free(): alloc'd: %d\n",
pool->blocks_allocated);
+}
+
+/*
+pci_pool_destroy --  destroys a pool of pci memory blocks.
+Synopsis
+
+void pci_pool_destroy (struct pci_pool * pool);
+
+
+Arguments:
+pool - pci pool that will be destroyed
+
+Description
+Caller guarantees that no more memory from the pool is in use, and that
nothing will try to
+use the pool after this call.
+*/
+void __inline__ my_pci_pool_destroy (struct pci_pool * pool)
+{
+       DPRINT1("pci_pool_destroy(): alloc'd: %d, UNIMPLEMENTED\n",
pool->blocks_allocated);
+
+       ExFreePool(pool);
+}
+
+void  *my_pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
dma_addr_t *dma_handle)
+{
+    POHCI_DEVICE_EXTENSION devExt =
(POHCI_DEVICE_EXTENSION)hwdev->dev_ext;
+       DPRINT1("pci_alloc_consistent() size=%d\n", size);
+
+    return
devExt->pDmaAdapter->DmaOperations->AllocateCommonBuffer(devExt->pDmaAda
pter, size, (PPHYSICAL_ADDRESS)dma_handle, FALSE); //FIXME:
Cache-enabled?
+}
+
+dma_addr_t my_dma_map_single(struct device *hwdev, void *ptr, size_t
size, enum dma_data_direction direction)
+{
+    //PHYSICAL_ADDRESS BaseAddress;
+    //POHCI_DEVICE_EXTENSION pDevExt =
(POHCI_DEVICE_EXTENSION)hwdev->dev_ext;
+    //PUCHAR VirtualAddress = (PUCHAR)
MmGetMdlVirtualAddress(pDevExt->Mdl);
+       //ULONG transferSize = size;
+       //BOOLEAN WriteToDevice;
+
+       //DPRINT1("dma_map_single() ptr=0x%lx, size=0x%x, dir=%d\n",
ptr, size, direction);
+       /*ASSERT(pDevExt->BufferSize > size);
+
+       // FIXME: It must be an error if DMA_BIDIRECTIONAL trasnfer
happens, since MSDN says
+       //        the buffer is locked
+       if (direction == DMA_BIDIRECTIONAL || direction ==
DMA_TO_DEVICE)
+        WriteToDevice = TRUE;
+       else
+               WriteToDevice = FALSE;
+
+    DPRINT1("IoMapTransfer\n");
+    BaseAddress =
pDevExt->pDmaAdapter->DmaOperations->MapTransfer(pDevExt->pDmaAdapter,
+                    pDevExt->Mdl,
+                    pDevExt->MapRegisterBase,
+                    (PUCHAR) MmGetMdlVirtualAddress(pDevExt->Mdl),
+                    &transferSize,
+                    WriteToDevice);
+
+       if (WriteToDevice)
+       {
+               DPRINT1("Writing to the device...\n");
+               memcpy(VirtualAddress, ptr, size);
+       }
+       else
+       {
+               DPRINT1("Reading from the device...\n");
+               memcpy(ptr, VirtualAddress, size);
+       }*/
+
+       //DPRINT1("VBuffer == 0x%x (really 0x%x?) transf_size == %u\n",
pDevExt->VirtualBuffer,
MmGetPhysicalAddress(pDevExt->VirtualBuffer).LowPart, transferSize);
+       //DPRINT1("VBuffer == 0x%x (really 0x%x?) transf_size == %u\n",
ptr, MmGetPhysicalAddress(ptr).LowPart, transferSize);
+
+       return
MmGetPhysicalAddress(ptr).QuadPart;//BaseAddress.QuadPart; /* BIG HACK
*/
+}
+
+// 2.6 version of pci_unmap_single
+//void my_dma_unmap_single(struct device *dev, dma_addr_t dma_addr,
size_t size, enum dma_data_direction direction)
+void my_dma_unmap_single(struct device *dev, dma_addr_t dma_addr,
size_t size, enum dma_data_direction direction)
+{
+       //DPRINT1("dma_unmap_single() called, nothing to do\n");
+       /* nothing yet */
+}
+
+void my_dma_sync_single(struct device *hwdev,
+                                      dma_addr_t dma_handle,
+                                      size_t size, int direction)
+{
+       DPRINT1("dma_sync_single() called, UNIMPLEMENTED\n");
+       /* nothing yet */
+}
+
+void my_dma_sync_sg(struct device *hwdev,
+                                  struct scatterlist *sg,
+                                  int nelems, int direction)
+{
+       DPRINT1("dma_sync_sg() called, UNIMPLEMENTED\n");
+       /* nothing yet */
+}
+
+
+int my_dma_map_sg(struct device *hwdev, struct scatterlist *sg, int
nents, enum dma_data_direction direction)
+{
+       DPRINT1("dma_map_sg() called, UNIMPLEMENTED\n");
+       return 0;
+}
+
+void my_dma_unmap_sg(struct device *hwdev, struct scatterlist *sg, int
nents, enum dma_data_direction direction)
+{
+       DPRINT1("dma_unmap_sg() called, UNIMPLEMENTED\n");
+       /* nothing yet */
+}
+
+/* forwarder ro dma_ equivalent */
+void my_pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr,
size_t size, int direction)
+{
+       my_dma_unmap_single(&hwdev->dev, dma_addr, size, direction);
+}