Subversion Repositories Kolibri OS

#include 

//#include 

//#include 

bool init_hc(hc_t *hc);

static slab_t   qh_slab;

LIST_HEAD( hc_list );

LIST_HEAD( rq_list );

u32_t drvEntry(int action, char *cmdline)

    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;

    }

    if( !FindUSBControllers() ) {

        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->list != &hc_list)

        init_hc(hc);

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

    }

    dbgprintf("\n");

    dev = (udev_t*)newdev_list.next;

    {

        udev_t *tmp = dev;

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

        if(tmp->id != 0)

    }

    while(1)

        udev_t    *dev;

        request_t *rq;

        kevent_t    event;

        u32_t       handle;

        event.code    = 0;

        handle = GetEvent(&event);

//        dbgprintf("event handle 0x%0x code 0x%0x\n",

        if(event.code != 0xFF000001)

        rq = (request_t*)event.data[0];

//        dbgprintf("rq = 0x%0x\n", rq);

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

    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"