Subversion Repositories Kolibri OS

Rev

Rev 1605 | 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.         kevent_t    event;
  108.         u32_t       handle;
  109.  
  110.         event.code    = 0;
  111.         event.data[0] = 0;
  112.  
  113.         handle = GetEvent(&event);
  114.  
  115. //        dbgprintf("event handle 0x%0x code 0x%0x\n",
  116. //                   handle, event.code);
  117.  
  118.         if(event.code != 0xFF000001)
  119.             continue;
  120.  
  121.         rq = (request_t*)event.data[0];
  122.  
  123. //        dbgprintf("rq = 0x%0x\n", rq);
  124.  
  125.         rq->handler(rq->dev, rq);
  126.     };
  127.  
  128.     retval = RegService("USB", srv_usb);
  129.     dbgprintf("reg service USB as: %x\n", retval);
  130.  
  131.     return retval;
  132. };
  133.  
  134.  
  135. #define API_VERSION     0x01000100
  136.  
  137. #define SRV_GETVERSION  0
  138.  
  139.  
  140. int __stdcall srv_usb(ioctl_t *io)
  141. {
  142.   u32_t *inp;
  143.   u32_t *outp;
  144.  
  145.   inp = io->input;
  146.   outp = io->output;
  147.  
  148.   switch(io->io_code)
  149.   {
  150.     case SRV_GETVERSION:
  151.       if(io->out_size==4)
  152.       {
  153.         *outp = API_VERSION;
  154.         return 0;
  155.       }
  156.       break;
  157.  
  158.  
  159.     default:
  160.       return ERR_PARAM;
  161.   };
  162.   return ERR_PARAM;
  163. }
  164.  
  165.  
  166. static qh_t* alloc_qh()
  167. {
  168.     if( qh_slab.available )
  169.     {
  170.         qh_t *qh;
  171.  
  172.         qh_slab.available--;
  173.         qh = (qh_t*)qh_slab.nextavail;
  174.         qh_slab.nextavail = qh->qlink;
  175.         return qh;
  176.      }
  177.      return NULL;
  178. };
  179.  
  180. static void  free_qh(qh_t *qh)
  181. {
  182.      qh->qlink = qh_slab.nextavail;
  183.      qh_slab.nextavail = (addr_t)qh;
  184.      qh_slab.available++;
  185. };
  186.  
  187. static td_t* alloc_td()
  188. {
  189.     if( td_slab.available )
  190.     {
  191.         td_t *td;
  192.  
  193.         td_slab.available--;
  194.         td = (td_t*)td_slab.nextavail;
  195.         td_slab.nextavail = td->link;
  196.         return td;
  197.      }
  198.      return NULL;
  199. };
  200.  
  201. static void  free_td(td_t *td)
  202. {
  203.      td->link = td_slab.nextavail;
  204.      td_slab.nextavail = (addr_t)td;
  205.      td_slab.available++;
  206. };
  207.  
  208. #include "pci.inc"
  209. #include "detect.inc"
  210. #include "hcd.inc"
  211. #include "hid.inc"
  212.