Subversion Repositories Kolibri OS

Rev

Rev 1430 | 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.             qh  = dev->host->qh1;
  117.  
  118.             qh->qelem = td->dma;
  119.  
  120.             __asm__ __volatile__ ("":::"memory");
  121.             rq = (request_t*)rq->list.next;
  122.         };
  123.  
  124.         delay(10/10);
  125.  
  126.         rq = (request_t*)rq_list.next;
  127.         while( &rq->list != &rq_list)
  128.         {
  129.             request_t *tmp;
  130.             td_t      *td;
  131.  
  132.             tmp = rq;
  133.             rq = (request_t*)rq->list.next;
  134.  
  135.             td  = tmp->td_head;
  136.  
  137.             if( td->status & TD_CTRL_ACTIVE)
  138.                 continue;
  139.  
  140.             tmp->handler(tmp->dev, tmp);
  141.         };
  142.     };
  143.  
  144.     retval = RegService("USB", srv_usb);
  145.     dbgprintf("reg service USB as: %x\n", retval);
  146.  
  147.     return retval;
  148. };
  149.  
  150.  
  151. #define API_VERSION     0x01000100
  152.  
  153. #define SRV_GETVERSION  0
  154.  
  155.  
  156. int __stdcall srv_usb(ioctl_t *io)
  157. {
  158.   u32_t *inp;
  159.   u32_t *outp;
  160.  
  161.   inp = io->input;
  162.   outp = io->output;
  163.  
  164.   switch(io->io_code)
  165.   {
  166.     case SRV_GETVERSION:
  167.       if(io->out_size==4)
  168.       {
  169.         *outp = API_VERSION;
  170.         return 0;
  171.       }
  172.       break;
  173.  
  174.  
  175.     default:
  176.       return ERR_PARAM;
  177.   };
  178.   return ERR_PARAM;
  179. }
  180.  
  181.  
  182. static qh_t* alloc_qh()
  183. {
  184.     if( qh_slab.available )
  185.     {
  186.         qh_t *qh;
  187.  
  188.         qh_slab.available--;
  189.         qh = (qh_t*)qh_slab.nextavail;
  190.         qh_slab.nextavail = qh->qlink;
  191.         return qh;
  192.      }
  193.      return NULL;
  194. };
  195.  
  196. static void  free_qh(qh_t *qh)
  197. {
  198.      qh->qlink = qh_slab.nextavail;
  199.      qh_slab.nextavail = (addr_t)qh;
  200.      qh_slab.available++;
  201. };
  202.  
  203. static td_t* alloc_td()
  204. {
  205.     if( td_slab.available )
  206.     {
  207.         td_t *td;
  208.  
  209.         td_slab.available--;
  210.         td = (td_t*)td_slab.nextavail;
  211.         td_slab.nextavail = td->link;
  212.         return td;
  213.      }
  214.      return NULL;
  215. };
  216.  
  217. static void  free_td(td_t *td)
  218. {
  219.      td->link = td_slab.nextavail;
  220.      td_slab.nextavail = (addr_t)td;
  221.      td_slab.available++;
  222. };
  223.  
  224. #include "pci.inc"
  225. #include "detect.inc"
  226. #include "hcd.inc"
  227. #include "hid.inc"
  228.