WebSVN – Kolibri OS – Diff – /drivers/usb/uhci/usb.c


#include 
#include 
#include 
#include 
#include 
#include 
#include "usb.h"
 
int __stdcall srv_usb(ioctl_t *io);
 
bool init_hc(hc_t *hc);
 
static slab_t   qh_slab;
 
LIST_HEAD( hc_list );
LIST_HEAD( newdev_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)
        return 0;
 
    if(!dbg_open("/rd/1/drivers/usb.log"))
    {
        printf("Can't open /rd/1/drivers/usb.log\nExit\n");
        return 0;
    }
 
    if( !FindUSBControllers() ) {
        dbgprintf("no uhci devices found\n");
        return 0;
    };
 
    hcd_buffer_create();
 
    qh_slab.available = 256;
    qh_slab.start     = KernelAlloc(4096);
    qh_slab.nextavail = (addr_t)qh_slab.start;
    qh_slab.dma       = GetPgAddr(qh_slab.start);
 
    qh_t    *p;
    addr_t  dma;
 
    for (i = 0, p = (qh_t*)qh_slab.start, dma = qh_slab.dma;
         i < 256; i++, p++, dma+= sizeof(qh_t))
    {
       p->qlink  = (addr_t)(p+1);
       p->qelem  = 1;
       p->dma    = dma;
       p->r1     = 0;
    };
 
    hc = (hc_t*)hc_list.next;
 
    while( &hc->list != &hc_list)
    {
        hc_t *tmp = hc;
        hc = (hc_t*)hc->list.next;
 
        if( !init_hc(tmp))
            list_del(&tmp->list);
    };
 
    dbgprintf("\n");
 
    dev = (udev_t*)newdev_list.next;
    while( &dev->list != &newdev_list)
    {
        udev_t *tmp = dev;
        dev = (udev_t*)dev->list.next;
 
        if(tmp->id != 0)
            init_device(tmp);
    }
 
    while(1)
    {
        udev_t    *dev;
        request_t *rq;
        kevent_t    event;
        u32_t       handle;
 
        event.code    = 0;
        event.data[0] = 0;
 
        handle = GetEvent(&event);
 
//        dbgprintf("event handle 0x%0x code 0x%0x\n",
//                   handle, event.code);
 
        if(event.code != 0xFF000001)
            continue;
 
        rq = (request_t*)event.data[0];
 
//        dbgprintf("rq = 0x%0x\n", rq);
 
        rq->handler(rq->dev, rq);
    };
 
    retval = RegService("USB", srv_usb);
    dbgprintf("reg service USB as: %x\n", retval);
 
    return retval;
};
 
 
#define API_VERSION     0x01000100
 
#define SRV_GETVERSION  0
 
 
int __stdcall srv_usb(ioctl_t *io)
{
  u32_t *inp;
  u32_t *outp;
 
  inp = io->input;
  outp = io->output;
 
  switch(io->io_code)
  {
    case SRV_GETVERSION:
      if(io->out_size==4)
      {
        *outp = API_VERSION;
        return 0;
      }
      break;
 
 
    default:
      return ERR_PARAM;
  };
  return ERR_PARAM;
}
 
 
static qh_t* alloc_qh()
{
    if( qh_slab.available )
    {
        qh_t *qh;
 
        qh_slab.available--;
        qh = (qh_t*)qh_slab.nextavail;
        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++;
};
 
 
#include "pci.inc"
#include "detect.inc"
#include "hcd.inc"
#include "hid.inc"

Rev 1616	Rev 1875
1	#include	1	#include
2	#include	2	#include
3	#include	3	#include
4	#include	4	#include
5	#include	5	#include
6	#include "usb.h"	6	#include
-		7	#include "usb.h"
7		8
8	int __stdcall srv_usb(ioctl_t *io);	9	int __stdcall srv_usb(ioctl_t *io);
9		10
10	bool init_hc(hc_t *hc);	11	bool init_hc(hc_t *hc);
11		12
12	static slab_t qh_slab;	13	static slab_t qh_slab;
13		14
14	LIST_HEAD( hc_list );	15	LIST_HEAD( hc_list );
15	LIST_HEAD( newdev_list );	16	LIST_HEAD( newdev_list );
16	LIST_HEAD( rq_list );	17	LIST_HEAD( rq_list );
17		18
18	u32_t drvEntry(int action, char *cmdline)	19	u32_t drvEntry(int action, char *cmdline)
19	{	20	{
20	u32_t retval;	21	u32_t retval;
21	hc_t *hc;	22	hc_t *hc;
22	udev_t *dev;	23	udev_t *dev;
23		24
24	int i;	25	int i;
25		26
26	if(action != 1)	27	if(action != 1)
27	return 0;	28	return 0;
28		29
29	if(!dbg_open("/rd/1/drivers/usb.log"))	30	if(!dbg_open("/rd/1/drivers/usb.log"))
30	{	31	{
31	printf("Can't open /rd/1/drivers/usb.log\nExit\n");	32	printf("Can't open /rd/1/drivers/usb.log\nExit\n");
32	return 0;	33	return 0;
33	}	34	}
34		35
35	if( !FindUSBControllers() ) {	36	if( !FindUSBControllers() ) {
36	dbgprintf("no uhci devices found\n");	37	dbgprintf("no uhci devices found\n");
37	return 0;	38	return 0;
38	};	39	};
39		40
40	qh_slab.available = 256;	41	hcd_buffer_create();
-		42
-		43	qh_slab.available = 256;
41	qh_slab.start = KernelAlloc(4096);	44	qh_slab.start = KernelAlloc(4096);
42	qh_slab.nextavail = (addr_t)qh_slab.start;	45	qh_slab.nextavail = (addr_t)qh_slab.start;
43	qh_slab.dma = GetPgAddr(qh_slab.start);	46	qh_slab.dma = GetPgAddr(qh_slab.start);
44		47
45	qh_t *p;	48	qh_t *p;
46	addr_t dma;	49	addr_t dma;
47		50
48	for (i = 0, p = (qh_t*)qh_slab.start, dma = qh_slab.dma;	51	for (i = 0, p = (qh_t*)qh_slab.start, dma = qh_slab.dma;
49	i < 256; i++, p++, dma+= sizeof(qh_t))	52	i < 256; i++, p++, dma+= sizeof(qh_t))
50	{	53	{
51	p->qlink = (addr_t)(p+1);	54	p->qlink = (addr_t)(p+1);
52	p->qelem = 1;	55	p->qelem = 1;
53	p->dma = dma;	56	p->dma = dma;
54	p->r1 = 0;	57	p->r1 = 0;
55	};	58	};
56		59
57	hc = (hc_t*)hc_list.next;	60	hc = (hc_t*)hc_list.next;
58		61
59	while( &hc->list != &hc_list)	62	while( &hc->list != &hc_list)
60	{	63	{
61	hc_t *tmp = hc;	64	hc_t *tmp = hc;
62	hc = (hc_t*)hc->list.next;	65	hc = (hc_t*)hc->list.next;
63		66
64	if( !init_hc(tmp))	67	if( !init_hc(tmp))
65	list_del(&tmp->list);	68	list_del(&tmp->list);
66	};	69	};
67		70
68	dbgprintf("\n");	71	dbgprintf("\n");
69		72
70	dev = (udev_t*)newdev_list.next;	73	dev = (udev_t*)newdev_list.next;
71	while( &dev->list != &newdev_list)	74	while( &dev->list != &newdev_list)
72	{	75	{
73	udev_t *tmp = dev;	76	udev_t *tmp = dev;
74	dev = (udev_t*)dev->list.next;	77	dev = (udev_t*)dev->list.next;
75		78
76	if(tmp->id != 0)	79	if(tmp->id != 0)
77	init_device(tmp);	80	init_device(tmp);
78	}	81	}
79		82
80	while(1)	83	while(1)
81	{	84	{
82	udev_t *dev;	85	udev_t *dev;
83	request_t *rq;	86	request_t *rq;
84	kevent_t event;	87	kevent_t event;
85	u32_t handle;	88	u32_t handle;
86		89
87	event.code = 0;	90	event.code = 0;
88	event.data[0] = 0;	91	event.data[0] = 0;
89		92
90	handle = GetEvent(&event);	93	handle = GetEvent(&event);
91		94
92	// dbgprintf("event handle 0x%0x code 0x%0x\n",	95	// dbgprintf("event handle 0x%0x code 0x%0x\n",
93	// handle, event.code);	96	// handle, event.code);
94		97
95	if(event.code != 0xFF000001)	98	if(event.code != 0xFF000001)
96	continue;	99	continue;
97		100
98	rq = (request_t*)event.data[0];	101	rq = (request_t*)event.data[0];
99		102
100	// dbgprintf("rq = 0x%0x\n", rq);	103	// dbgprintf("rq = 0x%0x\n", rq);
101		104
102	rq->handler(rq->dev, rq);	105	rq->handler(rq->dev, rq);
103	};	106	};
104		107
105	retval = RegService("USB", srv_usb);	108	retval = RegService("USB", srv_usb);
106	dbgprintf("reg service USB as: %x\n", retval);	109	dbgprintf("reg service USB as: %x\n", retval);
107		110
108	return retval;	111	return retval;
109	};	112	};
110		113
111		114
112	#define API_VERSION 0x01000100	115	#define API_VERSION 0x01000100
113		116
114	#define SRV_GETVERSION 0	117	#define SRV_GETVERSION 0
115		118
116		119
117	int __stdcall srv_usb(ioctl_t *io)	120	int __stdcall srv_usb(ioctl_t *io)
118	{	121	{
119	u32_t *inp;	122	u32_t *inp;
120	u32_t *outp;	123	u32_t *outp;
121		124
122	inp = io->input;	125	inp = io->input;
123	outp = io->output;	126	outp = io->output;
124		127
125	switch(io->io_code)	128	switch(io->io_code)
126	{	129	{
127	case SRV_GETVERSION:	130	case SRV_GETVERSION:
128	if(io->out_size==4)	131	if(io->out_size==4)
129	{	132	{
130	*outp = API_VERSION;	133	*outp = API_VERSION;
131	return 0;	134	return 0;
132	}	135	}
133	break;	136	break;
134		137
135		138
136	default:	139	default:
137	return ERR_PARAM;	140	return ERR_PARAM;
138	};	141	};
139	return ERR_PARAM;	142	return ERR_PARAM;
140	}	143	}
141		144
142		145
143	static qh_t* alloc_qh()	146	static qh_t* alloc_qh()
144	{	147	{
145	if( qh_slab.available )	148	if( qh_slab.available )
146	{	149	{
147	qh_t *qh;	150	qh_t *qh;
148		151
149	qh_slab.available--;	152	qh_slab.available--;
150	qh = (qh_t*)qh_slab.nextavail;	153	qh = (qh_t*)qh_slab.nextavail;
151	qh_slab.nextavail = qh->qlink;	154	qh_slab.nextavail = qh->qlink;
152	return qh;	155	return qh;
153	}	156	}
154	return NULL;	157	return NULL;
155	};	158	};
156		159
157	static void free_qh(qh_t *qh)	160	static void free_qh(qh_t *qh)
158	{	161	{
159	qh->qlink = qh_slab.nextavail;	162	qh->qlink = qh_slab.nextavail;
160	qh_slab.nextavail = (addr_t)qh;	163	qh_slab.nextavail = (addr_t)qh;
161	qh_slab.available++;	164	qh_slab.available++;
162	};	165	};
163		166
164		167
165	#include "pci.inc"	168	#include "pci.inc"
166	#include "detect.inc"	169	#include "detect.inc"
167	#include "hcd.inc"	170	#include "hcd.inc"
168	#include "hid.inc"	171	#include "hid.inc"

Subversion Repositories Kolibri OS

(root)/drivers/usb/uhci/usb.c – Rev 1616 → 1875