projects / openwrt / staging / wigyori.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
enable start-stop-daemon by default, i want to use this to clean up a few init script...
[openwrt/staging/wigyori.git] / target / linux / adm5120-2.6 / files / drivers / usb / host / adm5120-hcd.c
1 /*
2 * HCD driver for ADM5120 SoC
3 *
4 * Copyright (C) 2005 Jeroen Vreeken (pe1rxq@amsat.org)
5 *
6 * Based on the ADMtek 2.4 driver
7 * (C) Copyright 2003 Junius Chen <juniusc@admtek.com.tw>
8 * Which again was based on the ohci and uhci drivers.
9 */
10
11 #include <linux/module.h>
12 #include <linux/delay.h>
13 #include <linux/debugfs.h>
14 #include <linux/seq_file.h>
15 #include <linux/errno.h>
16 #include <linux/init.h>
17 #include <linux/list.h>
18 #include <linux/usb.h>
19 #include <linux/platform_device.h>
20
21 #include <asm/bootinfo.h>
22 #include <asm/io.h>
23 #include <asm/irq.h>
24 #include <asm/system.h>
25 #include <asm/byteorder.h>
26 #include <asm/mach-adm5120/adm5120_info.h>
27
28 #include "../core/hcd.h"
29
30 MODULE_DESCRIPTION("ADM5120 USB Host Controller Driver");
31 MODULE_LICENSE("GPL");
32 MODULE_AUTHOR("Jeroen Vreeken (pe1rxq@amsat.org)");
33
34 #define PFX "adm5120-hcd: "
35
36 #define ADMHCD_REG_CONTROL 0x00
37 #define ADMHCD_SW_RESET 0x00000008 /* Reset */
38 #define ADMHCD_DMAA 0x00000004 /* DMA arbitration control */
39 #define ADMHCD_SW_INTREQ 0x00000002 /* request software int */
40 #define ADMHCD_HOST_EN 0x00000001 /* Host enable */
41 #define ADMHCD_REG_INTSTATUS 0x04
42 #define ADMHCD_INT_ACT 0x80000000 /* Interrupt active */
43 #define ADMHCD_INT_FATAL 0x40000000 /* Fatal interrupt */
44 #define ADMHCD_INT_SW 0x20000000 /* software interrupt */
45 #define ADMHCD_INT_TD 0x00100000 /* TD completed */
46 #define ADMHCD_FNO 0x00000800 /* Frame number overaflow */
47 #define ADMHCD_SO 0x00000400 /* Scheduling overrun */
48 #define ADMHCD_INSMI 0x00000200 /* Root hub status change */
49 #define ADMHCD_BABI 0x00000100 /* Babble detected, host mode */
50 #define ADMHCD_RESI 0x00000020 /* Resume detected */
51 #define ADMHCD_SOFI 0x00000010 /* SOF transmitted/received, host mode */
52 #define ADMHCD_REG_INTENABLE 0x08
53 #define ADMHCD_INT_EN 0x80000000 /* Interrupt enable */
54 #define ADMHCD_INTMASK 0x00000001 /* Interrupt mask */
55 #define ADMHCD_REG_HOSTCONTROL 0x10
56 #define ADMHCD_DMA_EN 0x00000004 /* USB host DMA enable */
57 #define ADMHCD_STATE_MASK 0x00000003
58 #define ADMHCD_STATE_RST 0x00000000 /* bus state reset */
59 #define ADMHCD_STATE_RES 0x00000001 /* bus state resume */
60 #define ADMHCD_STATE_OP 0x00000002 /* bus state operational */
61 #define ADMHCD_STATE_SUS 0x00000003 /* bus state suspended */
62 #define ADMHCD_REG_FMINTERVAL 0x18
63 #define ADMHCD_REG_FMNUMBER 0x1c
64 #define ADMHCD_REG_LSTHRESH 0x70
65 #define ADMHCD_REG_RHDESCR 0x74
66 #define ADMHCD_CRWE 0x20000000 /* Clear wakeup enable */
67 #define ADMHCD_DRWE 0x10000000 /* Device remote wakeup enable */
68 #define ADMHCD_HW_OCIC 0x08000000 /* Over current indication change */
69 #define ADMHCD_LPSC 0x04000000 /* Local power switch change */
70 #define ADMHCD_OCI 0x02000000 /* Over current indication */
71 #define ADMHCD_LPS 0x01000000 /* Local power switch/global power switch */
72 #define ADMHCD_NOCP 0x00000800 /* No over current protect mode */
73 #define ADMHCD_OPCM 0x00000400 /* Over current protect mode */
74 #define ADMHCD_NPS 0x00000200 /* No Power Switch */
75 #define ADMHCD_PSM 0x00000100 /* Power switch mode */
76 #define ADMHCD_REG_PORTSTATUS0 0x78
77 #define ADMHCD_CCS 0x00000001 /* current connect status */
78 #define ADMHCD_PES 0x00000002 /* port enable status */
79 #define ADMHCD_PSS 0x00000004 /* port suspend status */
80 #define ADMHCD_POCI 0x00000008 /* port overcurrent indicator */
81 #define ADMHCD_PRS 0x00000010 /* port reset status */
82 #define ADMHCD_PPS 0x00000100 /* port power status */
83 #define ADMHCD_LSDA 0x00000200 /* low speed device attached */
84 #define ADMHCD_CSC 0x00010000 /* connect status change */
85 #define ADMHCD_PESC 0x00020000 /* enable status change */
86 #define ADMHCD_PSSC 0x00040000 /* suspend status change */
87 #define ADMHCD_OCIC 0x00080000 /* overcurrent change*/
88 #define ADMHCD_PRSC 0x00100000 /* reset status change */
89 #define ADMHCD_REG_PORTSTATUS1 0x7c
90 #define ADMHCD_REG_HOSTHEAD 0x80
91
92 #define ADMHCD_NUMPORTS 1
93 #define ADMHCD_DESC_ALIGN 16
94
95 struct admhcd_ed {
96 /* Don't change first four, they used for DMA */
97 u32 control;
98 struct admhcd_td *tail;
99 struct admhcd_td *head;
100 struct admhcd_ed *next;
101 /* the rest is for the driver only: */
102 struct admhcd_td *cur;
103 struct usb_host_endpoint *ep;
104 struct urb *urb;
105 struct admhcd_ed *real;
106 } __attribute__ ((packed));
107
108 #define ADMHCD_ED_EPSHIFT 7 /* Shift for endpoint number */
109 #define ADMHCD_ED_INT 0x00000800 /* Is this an int endpoint */
110 #define ADMHCD_ED_SPEED 0x00002000 /* Is it a high speed dev? */
111 #define ADMHCD_ED_SKIP 0x00004000 /* Skip this ED */
112 #define ADMHCD_ED_FORMAT 0x00008000 /* Is this an isoc endpoint */
113 #define ADMHCD_ED_MAXSHIFT 16 /* Shift for max packet size */
114
115 struct admhcd_td {
116 /* Don't change first four, they are used for DMA */
117 u32 control;
118 u32 buffer;
119 u32 buflen;
120 struct admhcd_td *next;
121 /* the rest is for the driver only: */
122 struct urb *urb;
123 struct admhcd_td *real;
124 } __attribute__ ((packed));
125
126 #define ADMHCD_TD_OWN 0x80000000
127 #define ADMHCD_TD_TOGGLE 0x00000000
128 #define ADMHCD_TD_DATA0 0x01000000
129 #define ADMHCD_TD_DATA1 0x01800000
130 #define ADMHCD_TD_OUT 0x00200000
131 #define ADMHCD_TD_IN 0x00400000
132 #define ADMHCD_TD_SETUP 0x00000000
133 #define ADMHCD_TD_ISO 0x00010000
134 #define ADMHCD_TD_R 0x00040000
135 #define ADMHCD_TD_INTEN 0x00010000
136
137 static int admhcd_td_err[16] = {
138 0, /* No */
139 -EREMOTEIO, /* CRC */
140 -EREMOTEIO, /* bit stuff */
141 -EREMOTEIO, /* data toggle */
142 -EPIPE, /* stall */
143 -ETIMEDOUT, /* timeout */
144 -EPROTO, /* pid err */
145 -EPROTO, /* unexpected pid */
146 -EREMOTEIO, /* data overrun */
147 -EREMOTEIO, /* data underrun */
148 -ETIMEDOUT, /* 1010 */
149 -ETIMEDOUT, /* 1011 */
150 -EREMOTEIO, /* buffer overrun */
151 -EREMOTEIO, /* buffer underrun */
152 -ETIMEDOUT, /* 1110 */
153 -ETIMEDOUT, /* 1111 */
154 };
155
156 #define ADMHCD_TD_ERRMASK 0x38000000
157 #define ADMHCD_TD_ERRSHIFT 27
158
159 #define TD(td) ((struct admhcd_td *)(((u32)(td)) & ~(ADMHCD_DESC_ALIGN-1)))
160 #define ED(ed) ((struct admhcd_ed *)(((u32)(ed)) & ~(ADMHCD_DESC_ALIGN-1)))
161
162 struct admhcd {
163 spinlock_t lock;
164
165 /* Root hub registers */
166 u32 rhdesca;
167 u32 rhdescb;
168 u32 rhstatus;
169 u32 rhport[2];
170
171 /* async schedule: control, bulk */
172 struct list_head async;
173 u32 base;
174 u32 dma_en;
175 unsigned long flags;
176 };
177
178 static inline struct admhcd *hcd_to_admhcd(struct usb_hcd *hcd)
179 {
180 return (struct admhcd *)(hcd->hcd_priv);
181 }
182
183 static inline struct usb_hcd *admhcd_to_hcd(struct admhcd *admhcd)
184 {
185 return container_of((void *)admhcd, struct usb_hcd, hcd_priv);
186 }
187
188 static char hcd_name[] = "adm5120-hcd";
189
190 static u32 admhcd_reg_get(struct admhcd *ahcd, int reg)
191 {
192 return *(volatile u32 *)KSEG1ADDR(ahcd->base+reg);
193 }
194
195 static void admhcd_reg_set(struct admhcd *ahcd, int reg, u32 val)
196 {
197 *(volatile u32 *)KSEG1ADDR(ahcd->base+reg) = val;
198 }
199
200 static void admhcd_lock(struct admhcd *ahcd)
201 {
202 spin_lock_irqsave(&ahcd->lock, ahcd->flags);
203 ahcd->dma_en = admhcd_reg_get(ahcd, ADMHCD_REG_HOSTCONTROL) &
204 ADMHCD_DMA_EN;
205 admhcd_reg_set(ahcd, ADMHCD_REG_HOSTCONTROL, ADMHCD_STATE_OP);
206 }
207
208 static void admhcd_unlock(struct admhcd *ahcd)
209 {
210 admhcd_reg_set(ahcd, ADMHCD_REG_HOSTCONTROL,
211 ADMHCD_STATE_OP | ahcd->dma_en);
212 spin_unlock_irqrestore(&ahcd->lock, ahcd->flags);
213 }
214
215 static struct admhcd_td *admhcd_td_alloc(struct admhcd_ed *ed, struct urb *urb)
216 {
217 struct admhcd_td *tdn, *td;
218
219 tdn = kzalloc(sizeof(*tdn)+ADMHCD_DESC_ALIGN, GFP_ATOMIC);
220 if (!tdn)
221 return NULL;
222
223 tdn->real = tdn;
224 tdn = TD(KSEG1ADDR(tdn));
225 if (ed->cur == NULL) {
226 ed->cur = tdn;
227 ed->head = tdn;
228 ed->tail = tdn;
229 td = tdn;
230 } else {
231 /* Supply back the old tail and link in new td as tail */
232 td = TD(ed->tail);
233 TD(ed->tail)->next = tdn;
234 ed->tail = tdn;
235 }
236 td->urb = urb;
237
238 return td;
239 }
240
241 static void admhcd_td_free(struct admhcd_ed *ed, struct urb *urb)
242 {
243 struct admhcd_td *td, **tdp;
244
245 if (urb == NULL)
246 ed->control |= ADMHCD_ED_SKIP;
247 tdp = &ed->cur;
248 td = ed->cur;
249 do {
250 if (td->urb == urb)
251 break;
252 tdp = &td->next;
253 td = TD(td->next);
254 } while (td);
255 while (td && td->urb == urb) {
256 *tdp = TD(td->next);
257 kfree(td->real);
258 td = *tdp;
259 }
260 }
261
262 /* Find an endpoint's descriptor, if needed allocate a new one and link it
263 in the DMA chain
264 */
265 static struct admhcd_ed *admhcd_get_ed(struct admhcd *ahcd,
266 struct usb_host_endpoint *ep, struct urb *urb)
267 {
268 struct admhcd_ed *hosthead;
269 struct admhcd_ed *found = NULL, *ed = NULL;
270 unsigned int pipe = urb->pipe;
271
272 admhcd_lock(ahcd);
273 hosthead = (struct admhcd_ed *)admhcd_reg_get(ahcd, ADMHCD_REG_HOSTHEAD);
274 if (hosthead) {
275 for (ed = hosthead;; ed = ED(ed->next)) {
276 if (ed->ep == ep) {
277 found = ed;
278 break;
279 }
280 if (ED(ed->next) == hosthead)
281 break;
282 }
283 }
284 if (!found) {
285 found = kzalloc(sizeof(*found)+ADMHCD_DESC_ALIGN, GFP_ATOMIC);
286 if (!found)
287 goto out;
288 found->real = found;
289 found->ep = ep;
290 found = ED(KSEG1ADDR(found));
291 found->control = usb_pipedevice(pipe) |
292 (usb_pipeendpoint(pipe) << ADMHCD_ED_EPSHIFT) |
293 (usb_pipeint(pipe) ? ADMHCD_ED_INT : 0) |
294 (urb->dev->speed == USB_SPEED_FULL ? ADMHCD_ED_SPEED : 0) |
295 (usb_pipeisoc(pipe) ? ADMHCD_ED_FORMAT : 0) |
296 (usb_maxpacket(urb->dev, pipe, usb_pipeout(pipe)) << ADMHCD_ED_MAXSHIFT);
297 /* Alloc first dummy td */
298 admhcd_td_alloc(found, NULL);
299 if (hosthead) {
300 found->next = hosthead;
301 ed->next = found;
302 } else {
303 found->next = found;
304 admhcd_reg_set(ahcd, ADMHCD_REG_HOSTHEAD, (u32)found);
305 }
306 }
307 out:
308 admhcd_unlock(ahcd);
309 return found;
310 }
311
312 static struct admhcd_td *admhcd_td_fill(u32 control, struct admhcd_td *td,
313 dma_addr_t data, int len)
314 {
315 td->buffer = data;
316 td->buflen = len;
317 td->control = control;
318 return TD(td->next);
319 }
320
321 static void admhcd_ed_start(struct admhcd *ahcd, struct admhcd_ed *ed)
322 {
323 struct admhcd_td *td = ed->cur;
324
325 if (ed->urb)
326 return;
327 if (td->urb) {
328 ed->urb = td->urb;
329 while (1) {
330 td->control |= ADMHCD_TD_OWN;
331 if (TD(td->next)->urb != td->urb) {
332 td->buflen |= ADMHCD_TD_INTEN;
333 break;
334 }
335 td = TD(td->next);
336 }
337 }
338 ed->head = TD(ed->head);
339 ahcd->dma_en |= ADMHCD_DMA_EN;
340 }
341
342 static irqreturn_t admhcd_irq(struct usb_hcd *hcd)
343 {
344 struct admhcd *ahcd = hcd_to_admhcd(hcd);
345 u32 intstatus;
346
347 intstatus = admhcd_reg_get(ahcd, ADMHCD_REG_INTSTATUS);
348 if (intstatus & ADMHCD_INT_FATAL) {
349 admhcd_reg_set(ahcd, ADMHCD_REG_INTSTATUS, ADMHCD_INT_FATAL);
350 /* FIXME: handle fatal interrupts */
351 }
352
353 if (intstatus & ADMHCD_INT_SW) {
354 admhcd_reg_set(ahcd, ADMHCD_REG_INTSTATUS, ADMHCD_INT_SW);
355 /* FIXME: handle software interrupts */
356 }
357
358 if (intstatus & ADMHCD_INT_TD) {
359 struct admhcd_ed *ed, *head;
360
361 admhcd_reg_set(ahcd, ADMHCD_REG_INTSTATUS, ADMHCD_INT_TD);
362
363 head = (struct admhcd_ed *)admhcd_reg_get(ahcd, ADMHCD_REG_HOSTHEAD);
364 ed = head;
365 if (ed) do {
366 /* Is it a finished TD? */
367 if (ed->urb && !(ed->cur->control & ADMHCD_TD_OWN)) {
368 struct admhcd_td *td;
369 int error;
370
371 td = ed->cur;
372 error = (td->control & ADMHCD_TD_ERRMASK) >>
373 ADMHCD_TD_ERRSHIFT;
374 ed->urb->status = admhcd_td_err[error];
375 admhcd_td_free(ed, ed->urb);
376 // Calculate real length!!!
377 ed->urb->actual_length = ed->urb->transfer_buffer_length;
378 ed->urb->hcpriv = NULL;
379 usb_hcd_giveback_urb(hcd, ed->urb);
380 ed->urb = NULL;
381 }
382 admhcd_ed_start(ahcd, ed);
383 ed = ED(ed->next);
384 } while (ed != head);
385 }
386
387 return IRQ_HANDLED;
388 }
389
390 static int admhcd_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *ep,
391 struct urb *urb, gfp_t mem_flags)
392 {
393 struct admhcd *ahcd = hcd_to_admhcd(hcd);
394 struct admhcd_ed *ed;
395 struct admhcd_td *td;
396 int size = 0, i, zero = 0, ret = 0;
397 unsigned int pipe = urb->pipe, toggle = 0;
398 dma_addr_t data = (dma_addr_t)urb->transfer_buffer;
399 int data_len = urb->transfer_buffer_length;
400
401 ed = admhcd_get_ed(ahcd, ep, urb);
402 if (!ed)
403 return -ENOMEM;
404
405 switch(usb_pipetype(pipe)) {
406 case PIPE_CONTROL:
407 size = 2;
408 case PIPE_INTERRUPT:
409 case PIPE_BULK:
410 default:
411 size += urb->transfer_buffer_length / 4096;
412 if (urb->transfer_buffer_length % 4096)
413 size++;
414 if (size == 0)
415 size++;
416 else if (urb->transfer_flags & URB_ZERO_PACKET &&
417 !(urb->transfer_buffer_length %
418 usb_maxpacket(urb->dev, pipe, usb_pipeout(pipe)))) {
419 size++;
420 zero = 1;
421 }
422 break;
423 case PIPE_ISOCHRONOUS:
424 size = urb->number_of_packets;
425 break;
426 }
427
428 admhcd_lock(ahcd);
429 /* Remember the first td */
430 td = admhcd_td_alloc(ed, urb);
431 if (!td) {
432 ret = -ENOMEM;
433 goto out;
434 }
435 /* Allocate additionall tds first */
436 for (i = 1; i < size; i++) {
437 if (admhcd_td_alloc(ed, urb) == NULL) {
438 admhcd_td_free(ed, urb);
439 ret = -ENOMEM;
440 goto out;
441 }
442 }
443
444 if (usb_gettoggle(urb->dev, usb_pipeendpoint(pipe), usb_pipeout(pipe)))
445 toggle = ADMHCD_TD_TOGGLE;
446 else {
447 toggle = ADMHCD_TD_DATA0;
448 usb_settoggle(urb->dev, usb_pipeendpoint(pipe),
449 usb_pipeout(pipe), 1);
450 }
451
452 switch(usb_pipetype(pipe)) {
453 case PIPE_CONTROL:
454 td = admhcd_td_fill(ADMHCD_TD_SETUP | ADMHCD_TD_DATA0,
455 td, (dma_addr_t)urb->setup_packet, 8);
456 while (data_len > 0) {
457 td = admhcd_td_fill(ADMHCD_TD_DATA1
458 | ADMHCD_TD_R |
459 (usb_pipeout(pipe) ?
460 ADMHCD_TD_OUT : ADMHCD_TD_IN), td,
461 data, data_len % 4097);
462 data_len -= 4096;
463 }
464 admhcd_td_fill(ADMHCD_TD_DATA1 | (usb_pipeout(pipe) ?
465 ADMHCD_TD_IN : ADMHCD_TD_OUT), td,
466 data, 0);
467 break;
468 case PIPE_INTERRUPT:
469 case PIPE_BULK:
470 //info ok for interrupt?
471 i = 0;
472 while(data_len > 4096) {
473 td = admhcd_td_fill((usb_pipeout(pipe) ?
474 ADMHCD_TD_OUT :
475 ADMHCD_TD_IN | ADMHCD_TD_R) |
476 (i ? ADMHCD_TD_TOGGLE : toggle), td,
477 data, 4096);
478 data += 4096;
479 data_len -= 4096;
480 i++;
481 }
482 td = admhcd_td_fill((usb_pipeout(pipe) ?
483 ADMHCD_TD_OUT : ADMHCD_TD_IN) |
484 (i ? ADMHCD_TD_TOGGLE : toggle), td, data, data_len);
485 i++;
486 if (zero)
487 admhcd_td_fill((usb_pipeout(pipe) ?
488 ADMHCD_TD_OUT : ADMHCD_TD_IN) |
489 (i ? ADMHCD_TD_TOGGLE : toggle), td, 0, 0);
490 break;
491 case PIPE_ISOCHRONOUS:
492 for (i = 0; i < urb->number_of_packets; i++) {
493 td = admhcd_td_fill(ADMHCD_TD_ISO |
494 ((urb->start_frame + i) & 0xffff), td,
495 data + urb->iso_frame_desc[i].offset,
496 urb->iso_frame_desc[i].length);
497 }
498 break;
499 }
500 urb->hcpriv = ed;
501 admhcd_ed_start(ahcd, ed);
502 out:
503 admhcd_unlock(ahcd);
504 return ret;
505 }
506
507 static int admhcd_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
508 {
509 struct admhcd *ahcd = hcd_to_admhcd(hcd);
510 struct admhcd_ed *ed;
511
512 admhcd_lock(ahcd);
513
514 ed = urb->hcpriv;
515 if (ed && ed->urb != urb)
516 admhcd_td_free(ed, urb);
517
518 admhcd_unlock(ahcd);
519 return 0;
520 }
521
522 static void admhcd_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
523 {
524 struct admhcd *ahcd = hcd_to_admhcd(hcd);
525 struct admhcd_ed *ed, *edt, *head;
526
527 admhcd_lock(ahcd);
528
529 head = (struct admhcd_ed *)admhcd_reg_get(ahcd, ADMHCD_REG_HOSTHEAD);
530 if (!head)
531 goto out;
532 for (ed = head; ED(ed->next) != head; ed = ED(ed->next))
533 if (ed->ep == ep)
534 break;
535 if (ed->ep != ep)
536 goto out;
537 while (ed->cur)
538 admhcd_td_free(ed, ed->cur->urb);
539 if (head == ed) {
540 if (ED(ed->next) == ed) {
541 admhcd_reg_set(ahcd, ADMHCD_REG_HOSTHEAD, 0);
542 ahcd->dma_en = 0;
543 goto out_free;
544 }
545 head = ED(ed->next);
546 for (edt = head; ED(edt->next) != head; edt = ED(edt->next));
547 edt->next = ED(ed->next);
548 admhcd_reg_set(ahcd, ADMHCD_REG_HOSTHEAD, (u32)ed->next);
549 goto out_free;
550 }
551 for (edt = head; edt->next != ed; edt = edt->next);
552 edt->next = ed->next;
553
554 out_free:
555 kfree(ed->real);
556 out:
557 admhcd_unlock(ahcd);
558 }
559
560 static int admhcd_get_frame_number(struct usb_hcd *hcd)
561 {
562 struct admhcd *ahcd = hcd_to_admhcd(hcd);
563
564 return admhcd_reg_get(ahcd, ADMHCD_REG_FMNUMBER) & 0x0000ffff;
565 }
566
567 static int admhcd_hub_status_data(struct usb_hcd *hcd, char *buf)
568 {
569 struct admhcd *ahcd = hcd_to_admhcd(hcd);
570 int port;
571
572 *buf = 0;
573 for (port = 0; port < ADMHCD_NUMPORTS; port++) {
574 if (admhcd_reg_get(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4) &
575 (ADMHCD_CSC | ADMHCD_PESC | ADMHCD_PSSC | ADMHCD_OCIC |
576 ADMHCD_PRSC))
577 *buf |= (1 << (port + 1));
578 }
579 return !!*buf;
580 }
581
582 static __u8 root_hub_hub_des[] = {
583 0x09, /* __u8 bLength; */
584 0x29, /* __u8 bDescriptorType; Hub-descriptor */
585 0x02, /* __u8 bNbrPorts; */
586 0x0a, 0x00, /* __u16 wHubCharacteristics; */
587 0x01, /* __u8 bPwrOn2pwrGood; 2ms */
588 0x00, /* __u8 bHubContrCurrent; 0mA */
589 0x00, /* __u8 DeviceRemovable; */
590 0xff, /* __u8 PortPwrCtrlMask; */
591 };
592
593 static int admhcd_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
594 u16 wIndex, char *buf, u16 wLength)
595 {
596 struct admhcd *ahcd = hcd_to_admhcd(hcd);
597 int retval = 0, len;
598 unsigned int port = wIndex -1;
599
600 switch (typeReq) {
601
602 case GetHubStatus:
603 *(__le32 *)buf = cpu_to_le32(0);
604 break;
605 case GetPortStatus:
606 if (port >= ADMHCD_NUMPORTS)
607 goto err;
608 *(__le32 *)buf = cpu_to_le32(
609 admhcd_reg_get(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4));
610 break;
611 case SetHubFeature: /* We don't implement these */
612 case ClearHubFeature:
613 switch (wValue) {
614 case C_HUB_OVER_CURRENT:
615 case C_HUB_LOCAL_POWER:
616 break;
617 default:
618 goto err;
619 }
620 case SetPortFeature:
621 if (port >= ADMHCD_NUMPORTS)
622 goto err;
623
624 switch (wValue) {
625 case USB_PORT_FEAT_SUSPEND:
626 admhcd_reg_set(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4,
627 ADMHCD_PSS);
628 break;
629 case USB_PORT_FEAT_RESET:
630 if (admhcd_reg_get(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4)
631 & ADMHCD_CCS) {
632 admhcd_reg_set(ahcd,
633 ADMHCD_REG_PORTSTATUS0 + port*4,
634 ADMHCD_PRS | ADMHCD_CSC);
635 mdelay(50);
636 admhcd_reg_set(ahcd,
637 ADMHCD_REG_PORTSTATUS0 + port*4,
638 ADMHCD_PES | ADMHCD_CSC);
639 }
640 break;
641 case USB_PORT_FEAT_POWER:
642 admhcd_reg_set(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4,
643 ADMHCD_PPS);
644 break;
645 default:
646 goto err;
647 }
648 break;
649 case ClearPortFeature:
650 if (port >= ADMHCD_NUMPORTS)
651 goto err;
652
653 switch (wValue) {
654 case USB_PORT_FEAT_ENABLE:
655 admhcd_reg_set(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4,
656 ADMHCD_CCS);
657 break;
658 case USB_PORT_FEAT_C_ENABLE:
659 admhcd_reg_set(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4,
660 ADMHCD_PESC);
661 break;
662 case USB_PORT_FEAT_SUSPEND:
663 admhcd_reg_set(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4,
664 ADMHCD_POCI);
665 break;
666 case USB_PORT_FEAT_C_SUSPEND:
667 admhcd_reg_set(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4,
668 ADMHCD_PSSC);
669 case USB_PORT_FEAT_POWER:
670 admhcd_reg_set(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4,
671 ADMHCD_LSDA);
672 break;
673 case USB_PORT_FEAT_C_CONNECTION:
674 admhcd_reg_set(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4,
675 ADMHCD_CSC);
676 break;
677 case USB_PORT_FEAT_C_OVER_CURRENT:
678 admhcd_reg_set(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4,
679 ADMHCD_OCIC);
680 break;
681 case USB_PORT_FEAT_C_RESET:
682 admhcd_reg_set(ahcd, ADMHCD_REG_PORTSTATUS0 + port*4,
683 ADMHCD_PRSC);
684 break;
685 default:
686 goto err;
687 }
688 break;
689 case GetHubDescriptor:
690 len = min_t(unsigned int, sizeof(root_hub_hub_des), wLength);
691 memcpy(buf, root_hub_hub_des, len);
692 break;
693 default:
694 err:
695 retval = -EPIPE;
696 }
697
698 return retval;
699 }
700
701 static int admhcd_start(struct usb_hcd *hcd)
702 {
703 struct admhcd *ahcd = hcd_to_admhcd(hcd);
704 unsigned long flags;
705
706 spin_lock_irqsave(&ahcd->lock, flags);
707
708 /* Initialise the HCD registers */
709 admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE, 0);
710 mdelay(10);
711
712 admhcd_reg_set(ahcd, ADMHCD_REG_CONTROL, ADMHCD_SW_RESET);
713
714 while (admhcd_reg_get(ahcd, ADMHCD_REG_CONTROL) & ADMHCD_SW_RESET) {
715 printk(KERN_WARNING PFX "waiting for reset to complete\n");
716 mdelay(1);
717 }
718
719 //hcd->uses_new_polling = 1;
720
721 /* Enable USB host mode */
722 admhcd_reg_set(ahcd, ADMHCD_REG_CONTROL, ADMHCD_HOST_EN);
723
724 /* Set host specific settings */
725 admhcd_reg_set(ahcd, ADMHCD_REG_HOSTHEAD, 0x00000000);
726 admhcd_reg_set(ahcd, ADMHCD_REG_FMINTERVAL, 0x20002edf);
727 admhcd_reg_set(ahcd, ADMHCD_REG_LSTHRESH, 0x628);
728
729 /* Set interrupts */
730 admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE, ADMHCD_INT_ACT |
731 ADMHCD_INT_FATAL | ADMHCD_INT_SW | ADMHCD_INT_TD);
732 admhcd_reg_set(ahcd, ADMHCD_REG_INTSTATUS, ADMHCD_INT_ACT |
733 ADMHCD_INT_FATAL | ADMHCD_INT_SW | ADMHCD_INT_TD);
734
735 /* Power on all ports */
736 admhcd_reg_set(ahcd, ADMHCD_REG_RHDESCR, ADMHCD_NPS | ADMHCD_LPSC);
737
738 /* HCD is now operationnal */
739 admhcd_reg_set(ahcd, ADMHCD_REG_HOSTCONTROL, ADMHCD_STATE_OP);
740
741 hcd->state = HC_STATE_RUNNING;
742
743 spin_unlock_irqrestore(&ahcd->lock, flags);
744
745 return 0;
746 }
747
748 static int admhcd_sw_reset(struct admhcd *ahcd)
749 {
750 int retries = 15;
751 unsigned long flags;
752 int ret = 0;
753
754 spin_lock_irqsave(&ahcd->lock, flags);
755
756 admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE, 0);
757 mdelay(10);
758
759 admhcd_reg_set(ahcd, ADMHCD_REG_CONTROL, ADMHCD_SW_RESET);
760
761 while (--retries) {
762 mdelay(1);
763 if (!(admhcd_reg_get(ahcd, ADMHCD_REG_CONTROL) & ADMHCD_SW_RESET))
764 break;
765 }
766 if (!retries) {
767 printk(KERN_WARNING "%s: software reset timeout\n", hcd_name);
768 ret = -ETIME;
769 }
770 spin_unlock_irqrestore(&ahcd->lock, flags);
771 return ret;
772 }
773
774 static int admhcd_reset(struct usb_hcd *hcd)
775 {
776 struct admhcd *ahcd = hcd_to_admhcd(hcd);
777 u32 state = 0;
778 int ret, timeout = 15; /* ms */
779 unsigned long t;
780
781 ret = admhcd_sw_reset(ahcd);
782 if (ret)
783 return ret;
784
785 t = jiffies + msecs_to_jiffies(timeout);
786 do {
787 spin_lock_irq(&ahcd->lock);
788 state = admhcd_reg_get(ahcd, ADMHCD_REG_HOSTCONTROL);
789 spin_unlock_irq(&ahcd->lock);
790 state &= ADMHCD_STATE_MASK;
791 if (state == ADMHCD_STATE_RST)
792 break;
793 msleep(4);
794 } while (time_before_eq(jiffies, t));
795
796 if (state != ADMHCD_STATE_RST) {
797 printk(KERN_WARNING "%s: device not ready after %dms\n",
798 hcd_name, timeout);
799 ret = -ENODEV;
800 }
801
802 return ret;
803 }
804
805 static void admhcd_stop(struct usb_hcd *hcd)
806 {
807 struct admhcd *ahcd = hcd_to_admhcd(hcd);
808 unsigned long flags;
809 u32 val;
810
811 spin_lock_irqsave(&ahcd->lock, flags);
812 admhcd_reg_set(ahcd, ADMHCD_REG_INTENABLE, 0);
813
814 /* Set global control of power for ports */
815 val = admhcd_reg_get(ahcd, ADMHCD_REG_RHDESCR);
816 val &= (~ADMHCD_PSM | ADMHCD_LPS);
817 admhcd_reg_set(ahcd, ADMHCD_REG_RHDESCR, val);
818
819 spin_unlock_irqrestore(&ahcd->lock, flags);
820
821 /* Ask for software reset */
822 admhcd_sw_reset(ahcd);
823 }
824
825
826 static struct hc_driver adm5120_hc_driver = {
827 .description = hcd_name,
828 .product_desc = "ADM5120 HCD",
829 .hcd_priv_size = sizeof(struct admhcd),
830 .irq = admhcd_irq,
831 .flags = HCD_USB11,
832 .urb_enqueue = admhcd_urb_enqueue,
833 .urb_dequeue = admhcd_urb_dequeue,
834 .endpoint_disable = admhcd_endpoint_disable,
835 .get_frame_number = admhcd_get_frame_number,
836 .hub_status_data = admhcd_hub_status_data,
837 .hub_control = admhcd_hub_control,
838 .start = admhcd_start,
839 .stop = admhcd_stop,
840 .reset = admhcd_reset,
841 };
842
843 #define resource_len(r) (((r)->end - (r)->start) + 1)
844
845 static int __init adm5120hcd_probe(struct platform_device *pdev)
846 {
847 struct usb_hcd *hcd;
848 struct admhcd *ahcd;
849 struct resource *data;
850 void __iomem *data_reg;
851
852 int err = 0, irq;
853
854 if (pdev->num_resources < 2) {
855 printk(KERN_WARNING PFX "not enough resources\n");
856 err = -ENODEV;
857 goto out;
858 }
859
860 irq = platform_get_irq(pdev, 0);
861 data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
862
863 if (pdev->dev.dma_mask) {
864 printk(KERN_DEBUG PFX "no we won't dma\n");
865 return -EINVAL;
866 }
867
868 if (!data || irq < 0) {
869 printk(KERN_DEBUG PFX "either IRQ or data resource is invalid\n");
870 err = -ENODEV;
871 goto out;
872 }
873
874 if (!request_mem_region(data->start, resource_len(data), hcd_name)) {
875 printk(KERN_DEBUG PFX "cannot request memory regions for the data resource\n");
876 err = -EBUSY;
877 goto out;
878 }
879
880 data_reg = ioremap(data->start, resource_len(data));
881 if (data_reg == NULL) {
882 printk(KERN_DEBUG PFX "unable to ioremap\n");
883 err = -ENOMEM;
884 goto out_mem;
885 }
886
887 hcd = usb_create_hcd(&adm5120_hc_driver, &pdev->dev, pdev->dev.bus_id);
888 if (!hcd) {
889 printk(KERN_DEBUG PFX "unable to create the hcd\n");
890 err = -ENOMEM;
891 goto out_unmap;
892 }
893
894 hcd->rsrc_start = data->start;
895 hcd->rsrc_len = resource_len(data);
896 hcd->regs = data_reg;
897
898 ahcd = hcd_to_admhcd(hcd);
899 ahcd->base = (u32)data_reg;
900
901 spin_lock_init(&ahcd->lock);
902 INIT_LIST_HEAD(&ahcd->async);
903
904 hcd->product_desc = "ADM5120 HCD";
905
906 err = usb_add_hcd(hcd, irq, IRQF_DISABLED);
907 if (err) {
908 printk(KERN_DEBUG PFX "unable to add hcd\n");
909 goto out_dev;
910 }
911
912 return 0;
913
914 out_dev:
915 usb_put_hcd(hcd);
916 out_unmap:
917 iounmap(data_reg);
918 out_mem:
919 release_mem_region(data->start, resource_len(data));
920 out:
921 return err;
922 }
923
924 #ifdef CONFIG_PM
925 static int adm5120hcd_suspend(struct platform_device *pdev, pm_message_t state)
926 {
927 pdev->dev.power.power_state = state;
928 mdelay(1);
929 return 0;
930 }
931
932 static int adm5120hcd_resume(struct platform_device *pdev, pm_message_t state)
933 {
934 pdev->dev.power.power_state = PMSG_ON;
935 mdelay(1);
936 return 0;
937 }
938 #else
939 #define adm5120hcd_suspend NULL
940 #define adm5120hcd_resume NULL
941 #endif
942
943 static int __init_or_module adm5120hcd_remove(struct platform_device *pdev)
944 {
945 struct usb_hcd *hcd = platform_get_drvdata(pdev);
946 struct admhcd *ahcd;
947
948 if (!hcd)
949 return 0;
950 ahcd = hcd_to_admhcd(hcd);
951 usb_remove_hcd(hcd);
952
953 usb_put_hcd(hcd);
954 return 0;
955 }
956
957 static struct platform_driver adm5120hcd_driver = {
958 .probe = adm5120hcd_probe,
959 .remove = adm5120hcd_remove,
960 .suspend = adm5120hcd_suspend,
961 .remove = adm5120hcd_resume,
962 .driver = {
963 .name = (char *)hcd_name,
964 .owner = THIS_MODULE,
965 },
966 };
967
968 static int __init adm5120hcd_init(void)
969 {
970 int ret;
971
972 if (usb_disabled()) {
973 printk(KERN_DEBUG PFX "USB support is disabled\n");
974 return -ENODEV;
975 }
976
977 if (mips_machgroup != MACH_GROUP_ADM5120) {
978 printk(KERN_DEBUG PFX "unsupported machine group\n");
979 return -ENODEV;
980 }
981
982 ret = platform_driver_register(&adm5120hcd_driver);
983 if (ret == 0)
984 printk(KERN_INFO PFX "registered\n");
985
986 return ret;
987 }
988
989 static void __exit adm5120hcd_exit(void)
990 {
991 platform_driver_unregister(&adm5120hcd_driver);
992 printk(KERN_INFO PFX "driver unregistered\n");
993 }
994
995 module_init(adm5120hcd_init);
996 module_exit(adm5120hcd_exit);
Staging tree of Zoltan Herpai