Subversion Repositories Kolibri OS

#include 

#include 

#include "pci.h"

#include "syscall.h"

static Bool FindPciDevice();

int __stdcall srv_usb(ioctl_t *io);

Bool init_hc(hc_t *hc);

static slab_t   qh_slab;

static link_t  hc_list;

static link_t  rq_list;

u32_t __stdcall drvEntry(int action)

    u32_t   retval;

    hc_t   *hc;

    udev_t *dev;

    int     i;

    if(action != 1)

    if(!dbg_open("/rd/1/drivers/usb.log"))

        printf("Can't open /rd/1/drivers/usb.log\nExit\n");

        return 0;

    }

    list_initialize(&hc_list);

    list_initialize(&rq_list);

    if( !FindPciDevice() ) {

        return 0;

    };

     qh_slab.available = 256;

     qh_slab.nextavail = (addr_t)qh_slab.start;

     qh_slab.dma       = GetPgAddr(qh_slab.start);

     qh_t    *p;

     for (i = 0, p = (qh_t*)qh_slab.start, dma = qh_slab.dma;

     {

        p->qlink  = (addr_t)(p+1);

        p->qelem  = 1;

        p->dma    = dma;

        p->r1     = 0;

     };

     td_slab.available = 128;

     td_slab.nextavail = (addr_t)td_slab.start;

     td_slab.dma       = GetPgAddr(td_slab.start);

     td_t *td;

          i < 128; i++, td++, dma+= sizeof(td_t))

     {

        td->link   = (addr_t)(td+1);

        td->status = 0;

        td->token  = 0;

        td->buffer = 0;

        td->dma    = dma;

     };

    while( &hc->link != &hc_list)

        init_hc(hc);

        hc = (hc_t*)hc->link.next;

    }

    dbgprintf("\n");

    dev = (udev_t*)newdev_list.next;

    {

        udev_t *tmp = dev;

        dev = (udev_t*)dev->link.next;

        if(tmp->id != 0)

    }

    while(1)

        udev_t    *dev;

        request_t *rq;

        rq = (request_t*)rq_list.next;

        {

            qh_t      *qh;

            td_t      *td;

            td  = rq->td_head;

            qh  = dev->host->qh1;

            qh->qelem = td->dma;

            __asm__ __volatile__ ("":::"memory");

        };

        delay(10/10);

        rq = (request_t*)rq_list.next;

        {

            request_t *tmp;

            td_t      *td;

            tmp = rq;

            td  = tmp->td_head;

            if( td->status & TD_CTRL_ACTIVE)

            tmp->handler(tmp->dev, tmp);

    };

    retval = RegService("USB", srv_usb);

    return retval;

#define SRV_GETVERSION  0

  u32_t *inp;

  u32_t *outp;

  inp = io->input;

  switch(io->io_code)

    case SRV_GETVERSION:

      if(io->out_size==4)

      {

        *outp = API_VERSION;

        return 0;

      }

      break;

  };

  return ERR_PARAM;

}

    if( qh_slab.available )

    {

        qh_t *qh;

        qh_slab.available--;

        qh_slab.nextavail = qh->qlink;

        return qh;

     }

     return NULL;

};

static void  free_qh(qh_t *qh)

     qh->qlink = qh_slab.nextavail;

     qh_slab.nextavail = (addr_t)qh;

     qh_slab.available++;

};

static td_t* alloc_td()

    if( td_slab.available )

    {

        td_t *td;

        td_slab.available--;

        td_slab.nextavail = td->link;

        return td;

     }

     return NULL;

};

static void  free_td(td_t *td)

     td->link = td_slab.nextavail;

     td_slab.nextavail = (addr_t)td;

     td_slab.available++;

};

#include "pci.inc"

#include "hcd.inc"

#include "hid.inc"