Subversion Repositories Kolibri OS

Rev

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

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