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


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

Subversion Repositories Kolibri OS

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