WebSVN – Kolibri OS – Diff – /drivers/usb/uhci/hcd.inc

 	return 1;
+}
-Bool init_hc(hc_t *hc)
+bool init_hc(hc_t *hc)
+{
-	int port;
+    int    port;
-    u32_t ifl;
+    u32_t  ifl;
-    u16_t dev_status;
+    u16_t  dev_status;
             delay(10/10);
             status = in16(hc->iobase + USBPORTSC1 + (port * 2));
             if(status & 1)
+            {
-                udev_t *dev = malloc(sizeof(udev_t));
+                udev_t *dev = kmalloc(sizeof(udev_t),0);
                 out16(hc->iobase + USBPORTSC1 + (port * 2), 0x0E);
                 delay(20/10);
                 dbgprintf("enable port\n");
                 status = in16(hc->iobase + USBPORTSC1 + (port * 2));
-                dbgprintf("port%d status %x\n", port, status);
+                dbgprintf("port%d status %x\n", port, status);
-                link_initialize(&dev->link);
-                dev->id       = 0;
+                INIT_LIST_HEAD(&dev->list);
                 dev->host     = hc;
-                dev->addr     = 0;
+                dev->host     = hc;
                 dev->port     = port;
                     dbgprintf(" full speed\n");
                 };
                 if(set_address(dev)) {
-                    list_prepend(&dev->link, &newdev_list);
+                    list_add_tail(&dev->list, &newdev_list);
                     hc->port_map |= 1<
+                }
                 else {
                     free(dev);
                     out16(hc->iobase + USBPORTSC1 + (port * 2), 0);
+                }
                 break;
             };
         };
     };
-    return TRUE;
+    return true;
 };
 u16_t __attribute__((aligned(16)))
 SETUP(0) IN(1) IN(0) IN(1)...OUT(0)
 */
-Bool set_address(udev_t *dev)
+bool set_address(udev_t *dev)
+{
     static  udev_id   = 0;
     static  udev_addr = 0;
     static  u16_t __attribute__((aligned(16)))
     req_addr[1] = address;
     if( !ctrl_request(dev, &req_addr, DOUT, NULL, 0))
-        return FALSE;
+        return false;
     dev->addr = address;
     dev->id   = (++udev_id << 8) | address;
     dbgprintf("set address %d\n", address);
     data[0] = 0;
     data[1] = 0;
     if( !ctrl_request(dev, &req_descr, DIN, data, 8))
-        return FALSE;
+        return false;
     dev_descr_t *descr = (dev_descr_t*)&data;
     dev->ep0_size = descr->bMaxPacketSize0;
-    return TRUE;
+    return true;
+}
-}
 request_t *create_request(udev_t *dev, endp_t *enp, u32_t dir,
                           void *data, size_t req_size)
+{
     td_t  *td, *td_prev;
     addr_t data_dma;
-    request_t *rq = (request_t*)malloc(sizeof(request_t));
+    size_t  packet_size = enp->size;
+    size_t  size = req_size;
+    request_t *rq = (request_t*)kmalloc(sizeof(request_t),0);
     link_initialize(&rq->link);
+    INIT_LIST_HEAD(&rq->list);
+    rq->data = (addr_t)data;
     rq->size = req_size;
-    rq->td_head = 0;
+    rq->dev  = dev;
     rq->td_tail = 0;
     if(data)
-    rq->data = (addr_t)data;
+        data_dma = DMA(data);
     rq->size = req_size;
-    rq->dev = dev;
+    td_prev = NULL;
-    if(data)
+    while(size > 0)
         data_dma = DMA(data);
         if ( size < packet_size)
     td_prev = NULL;
+            packet_size = size;
-    while(req_size >= enp->size)
+        };
-    {
-        td = alloc_td();
-        td->link   = 1;
-        if(rq->td_head == NULL)
-            rq->td_head = td;
-        if( td_prev )
-            td_prev->link   = td->dma | 4;
-        td->status = 0x00800000 | dev->speed;
-        td->token  = TOKEN(enp->size,enp->toggle,enp->address,
-                           dev->addr,dir);
-        td->buffer = data_dma;
-        td->bk     = td_prev;
-        td_prev = td;
-        data_dma+= enp->size;
-        req_size-= enp->size;
         enp->toggle ^= DATA1;
         td = alloc_td();
-    if(req_size)
+        td->link = 1;
-        td = alloc_td();
+        if(rq->td_head == NULL)
 */
     return rq;
+}
-Bool ctrl_request(udev_t *dev, void *req, u32_t pid,
+bool ctrl_request(udev_t *dev, void *req, u32_t pid,
                   void *data, size_t req_size)
+{
     size_t  packet_size = dev->ep0_size;
     size_t  size = req_size;
     u32_t   toggle = DATA1;
     td_t   *td0, *td, *td_prev;
     qh_t   *qh;
     addr_t  data_dma = 0;
-    Bool    retval;
+    bool    retval;
     td0 = alloc_td();
         data_dma = DMA(data);
     td_prev = td0;
-    while(size >= packet_size)
+    while(size > 0)
-    {
-        td = alloc_td();
-        td_prev->link   = td->dma | 4;
-        td->status = 0x00800000 | dev->speed;
-        td->token  = TOKEN(packet_size, toggle, 0,dev->addr, pid);
-        td->buffer = data_dma;
-        td->bk     = td_prev;
-        td_prev = td;
-        data_dma+= packet_size;
+    {
-        size-= packet_size;
-        toggle ^= DATA1;
-    }
-    if(size)
+        if ( size < packet_size)
+        {
+            packet_size = size;
+        };
         td = alloc_td();
         td_prev->link   = td->dma | 4;
         td->status = 0x00800000 | dev->speed;
-        td->token  = ((size-1)<<21)|toggle|(dev->addr<<8)|pid;
+        td->token  = TOKEN(packet_size, toggle, 0,dev->addr, pid);
         td->buffer = data_dma;
         td->bk     = td_prev;
         dbgprintf("td_prev status %x\n",td_prev->status);
         dbgprintf("td status %x\n",td->status);
         dbgprintf("qh %x \n", qh->qelem);
-        retval = FALSE;
+        retval = false;
-    } else retval = TRUE;
+    } else retval = true;
     do
+    {
         td_prev = td->bk;
     return retval;
 };
-Bool init_device(udev_t *dev)
+bool init_device(udev_t *dev)
+{
     static  u16_t __attribute__((aligned(16)))
                 dbgprintf( "audio device\n");
                 break;
             case USB_CLASS_HID:
                 dev->conf = conf;
-                list_remove(&dev->link);
+                list_del(&dev->list);
                 return init_hid(dev);
             case USB_CLASS_PRINTER:
                 dbgprintf("printer\n");
                 break;

Subversion Repositories Kolibri OS

(root)/drivers/usb/uhci/hcd.inc – Rev 1029 → 1600