Subversion Repositories Kolibri OS

Rev

Rev 1029 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1.  
  2.  
  3. #include "types.h"
  4. #include "link.h"
  5.  
  6. #include <stdio.h>
  7. #include <malloc.h>
  8. #include <memory.h>
  9.  
  10. #include "pci.h"
  11.  
  12. #include "syscall.h"
  13. #include "usb.h"
  14.  
  15.  
  16. int __stdcall srv_usb(ioctl_t *io);
  17.  
  18. Bool init_hc(hc_t *hc);
  19.  
  20. static slab_t   qh_slab;
  21. static slab_t   td_slab;
  22.  
  23. static link_t  hc_list;
  24. static link_t  newdev_list;
  25. static link_t  rq_list;
  26.  
  27. u32_t __stdcall drvEntry(int action)
  28. {
  29.     u32_t   retval;
  30.     hc_t   *hc;
  31.     udev_t *dev;
  32.  
  33.     int     i;
  34.  
  35.     if(action != 1)
  36.         return 0;
  37.  
  38.     if(!dbg_open("/rd/1/drivers/usb.log"))
  39.     {
  40.         printf("Can't open /rd/1/drivers/usb.log\nExit\n");
  41.         return 0;
  42.     }
  43.  
  44.     list_initialize(&hc_list);
  45.     list_initialize(&newdev_list);
  46.     list_initialize(&rq_list);
  47.  
  48.     if( !FindPciDevice() ) {
  49.         dbgprintf("no uhci devices found\n");
  50.         return 0;
  51.     };
  52.  
  53.      qh_slab.available = 256;
  54.      qh_slab.start     = KernelAlloc(4096);
  55.      qh_slab.nextavail = (addr_t)qh_slab.start;
  56.      qh_slab.dma       = GetPgAddr(qh_slab.start);
  57.  
  58.      qh_t    *p;
  59.      addr_t  dma;
  60.  
  61.      for (i = 0, p = (qh_t*)qh_slab.start, dma = qh_slab.dma;
  62.           i < 256; i++, p++, dma+= sizeof(qh_t))
  63.      {
  64.         p->qlink  = (addr_t)(p+1);
  65.         p->qelem  = 1;
  66.         p->dma    = dma;
  67.         p->r1     = 0;
  68.      };
  69.  
  70.      td_slab.available = 128;
  71.      td_slab.start     = KernelAlloc(4096);
  72.      td_slab.nextavail = (addr_t)td_slab.start;
  73.      td_slab.dma       = GetPgAddr(td_slab.start);
  74.  
  75.      td_t *td;
  76.      for (i = 0, td = (td_t*)td_slab.start, dma = td_slab.dma;
  77.           i < 128; i++, td++, dma+= sizeof(td_t))
  78.      {
  79.         td->link   = (addr_t)(td+1);
  80.         td->status = 0;
  81.         td->token  = 0;
  82.         td->buffer = 0;
  83.         td->dma    = dma;
  84.      };
  85.  
  86.  
  87.     hc = (hc_t*)hc_list.next;
  88.  
  89.     while( &hc->link != &hc_list)
  90.     {
  91.         init_hc(hc);
  92.         hc = (hc_t*)hc->link.next;
  93.     }
  94.  
  95.     dbgprintf("\n");
  96.  
  97.     dev = (udev_t*)newdev_list.next;
  98.     while( &dev->link != &newdev_list)
  99.     {
  100.         udev_t *tmp = dev;
  101.         dev = (udev_t*)dev->link.next;
  102.  
  103.         if(tmp->id != 0)
  104.             init_device(tmp);
  105.     }
  106.  
  107.     while(1)
  108.     {
  109.         udev_t    *dev;
  110.         request_t *rq;
  111.  
  112.         rq = (request_t*)rq_list.next;
  113.         while( &rq->link != &rq_list)
  114.         {
  115.             qh_t      *qh;
  116.             td_t      *td;
  117.  
  118.             td  = rq->td_head;
  119.             dev = rq->dev;
  120.             qh  = dev->host->qh1;
  121.  
  122.             qh->qelem = td->dma;
  123.  
  124.             __asm__ __volatile__ ("":::"memory");
  125.             rq = (request_t*)rq->link.next;
  126.         };
  127.  
  128.         delay(10/10);
  129.  
  130.         rq = (request_t*)rq_list.next;
  131.         while( &rq->link != &rq_list)
  132.         {
  133.             request_t *tmp;
  134.             td_t      *td;
  135.  
  136.             tmp = rq;
  137.             rq = (request_t*)rq->link.next;
  138.  
  139.             td  = tmp->td_head;
  140.  
  141.             if( td->status & TD_CTRL_ACTIVE)
  142.                 continue;
  143.  
  144.             tmp->handler(tmp->dev, tmp);
  145.         };
  146.     };
  147.  
  148.     retval = RegService("USB", srv_usb);
  149.     dbgprintf("reg service USB as: %x\n", retval);
  150.  
  151.     return retval;
  152. };
  153.  
  154.  
  155. #define API_VERSION     0x01000100
  156.  
  157. #define SRV_GETVERSION  0
  158.  
  159.  
  160. int __stdcall srv_usb(ioctl_t *io)
  161. {
  162.   u32_t *inp;
  163.   u32_t *outp;
  164.  
  165.   inp = io->input;
  166.   outp = io->output;
  167.  
  168.   switch(io->io_code)
  169.   {
  170.     case SRV_GETVERSION:
  171.       if(io->out_size==4)
  172.       {
  173.         *outp = API_VERSION;
  174.         return 0;
  175.       }
  176.       break;
  177.  
  178.  
  179.     default:
  180.       return ERR_PARAM;
  181.   };
  182.   return ERR_PARAM;
  183. }
  184.  
  185.  
  186. static qh_t* alloc_qh()
  187. {
  188.     if( qh_slab.available )
  189.     {
  190.         qh_t *qh;
  191.  
  192.         qh_slab.available--;
  193.         qh = (qh_t*)qh_slab.nextavail;
  194.         qh_slab.nextavail = qh->qlink;
  195.         return qh;
  196.      }
  197.      return NULL;
  198. };
  199.  
  200. static void  free_qh(qh_t *qh)
  201. {
  202.      qh->qlink = qh_slab.nextavail;
  203.      qh_slab.nextavail = (addr_t)qh;
  204.      qh_slab.available++;
  205. };
  206.  
  207. static td_t* alloc_td()
  208. {
  209.     if( td_slab.available )
  210.     {
  211.         td_t *td;
  212.  
  213.         td_slab.available--;
  214.         td = (td_t*)td_slab.nextavail;
  215.         td_slab.nextavail = td->link;
  216.         return td;
  217.      }
  218.      return NULL;
  219. };
  220.  
  221. static void  free_td(td_t *td)
  222. {
  223.      td->link = td_slab.nextavail;
  224.      td_slab.nextavail = (addr_t)td;
  225.      td_slab.available++;
  226. };
  227.  
  228. #include "pci.inc"
  229. #include "detect.inc"
  230. #include "hcd.inc"
  231. #include "hid.inc"
  232.