projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
omap24xx: Update 3.1 config
[openwrt.git] / target / linux / etrax / files / drivers / usb / host / hc-crisv10.c
1 /*
2 *
3 * ETRAX 100LX USB Host Controller Driver
4 *
5 * Copyright (C) 2005 - 2008 Axis Communications AB
6 *
7 * Author: Konrad Eriksson <konrad.eriksson@axis.se>
8 *
9 */
10
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/init.h>
14 #include <linux/moduleparam.h>
15 #include <linux/spinlock.h>
16 #include <linux/usb.h>
17 #include <linux/platform_device.h>
18
19 #include <asm/io.h>
20 #include <asm/irq.h>
21 #include <asm/arch/dma.h>
22 #include <asm/arch/io_interface_mux.h>
23
24 #include "../core/hcd.h"
25 #include "../core/hub.h"
26 #include "hc-crisv10.h"
27 #include "hc-cris-dbg.h"
28
29
30 /***************************************************************************/
31 /***************************************************************************/
32 /* Host Controller settings */
33 /***************************************************************************/
34 /***************************************************************************/
35
36 #define VERSION "1.00-openwrt_diff-v1"
37 #define COPYRIGHT "(c) 2005, 2006 Axis Communications AB"
38 #define DESCRIPTION "ETRAX 100LX USB Host Controller"
39
40 #define ETRAX_USB_HC_IRQ USB_HC_IRQ_NBR
41 #define ETRAX_USB_RX_IRQ USB_DMA_RX_IRQ_NBR
42 #define ETRAX_USB_TX_IRQ USB_DMA_TX_IRQ_NBR
43
44 /* Number of physical ports in Etrax 100LX */
45 #define USB_ROOT_HUB_PORTS 2
46
47 const char hc_name[] = "hc-crisv10";
48 const char product_desc[] = DESCRIPTION;
49
50 /* The number of epids is, among other things, used for pre-allocating
51 ctrl, bulk and isoc EP descriptors (one for each epid).
52 Assumed to be > 1 when initiating the DMA lists. */
53 #define NBR_OF_EPIDS 32
54
55 /* Support interrupt traffic intervals up to 128 ms. */
56 #define MAX_INTR_INTERVAL 128
57
58 /* If periodic traffic (intr or isoc) is to be used, then one entry in the EP
59 table must be "invalid". By this we mean that we shouldn't care about epid
60 attentions for this epid, or at least handle them differently from epid
61 attentions for "valid" epids. This define determines which one to use
62 (don't change it). */
63 #define INVALID_EPID 31
64 /* A special epid for the bulk dummys. */
65 #define DUMMY_EPID 30
66
67 /* Module settings */
68
69 MODULE_DESCRIPTION(DESCRIPTION);
70 MODULE_LICENSE("GPL");
71 MODULE_AUTHOR("Konrad Eriksson <konrad.eriksson@axis.se>");
72
73
74 /* Module parameters */
75
76 /* 0 = No ports enabled
77 1 = Only port 1 enabled (on board ethernet on devboard)
78 2 = Only port 2 enabled (external connector on devboard)
79 3 = Both ports enabled
80 */
81 static unsigned int ports = 3;
82 module_param(ports, uint, S_IRUGO);
83 MODULE_PARM_DESC(ports, "Bitmask indicating USB ports to use");
84
85
86 /***************************************************************************/
87 /***************************************************************************/
88 /* Shared global variables for this module */
89 /***************************************************************************/
90 /***************************************************************************/
91
92 /* EP descriptor lists for non period transfers. Must be 32-bit aligned. */
93 static volatile struct USB_EP_Desc TxBulkEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
94
95 static volatile struct USB_EP_Desc TxCtrlEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
96
97 /* EP descriptor lists for period transfers. Must be 32-bit aligned. */
98 static volatile struct USB_EP_Desc TxIntrEPList[MAX_INTR_INTERVAL] __attribute__ ((aligned (4)));
99 static volatile struct USB_SB_Desc TxIntrSB_zout __attribute__ ((aligned (4)));
100
101 static volatile struct USB_EP_Desc TxIsocEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
102 static volatile struct USB_SB_Desc TxIsocSB_zout __attribute__ ((aligned (4)));
103
104 static volatile struct USB_SB_Desc TxIsocSBList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
105
106 /* After each enabled bulk EP IN we put two disabled EP descriptors with the eol flag set,
107 causing the DMA to stop the DMA channel. The first of these two has the intr flag set, which
108 gives us a dma8_sub0_descr interrupt. When we receive this, we advance the DMA one step in the
109 EP list and then restart the bulk channel, thus forcing a switch between bulk EP descriptors
110 in each frame. */
111 static volatile struct USB_EP_Desc TxBulkDummyEPList[NBR_OF_EPIDS][2] __attribute__ ((aligned (4)));
112
113 /* List of URB pointers, where each points to the active URB for a epid.
114 For Bulk, Ctrl and Intr this means which URB that currently is added to
115 DMA lists (Isoc URBs are all directly added to DMA lists). As soon as
116 URB has completed is the queue examined and the first URB in queue is
117 removed and moved to the activeUrbList while its state change to STARTED and
118 its transfer(s) gets added to DMA list (exception Isoc where URBs enter
119 state STARTED directly and added transfers added to DMA lists). */
120 static struct urb *activeUrbList[NBR_OF_EPIDS];
121
122 /* Additional software state info for each epid */
123 static struct etrax_epid epid_state[NBR_OF_EPIDS];
124
125 /* Timer handles for bulk traffic timer used to avoid DMA bug where DMA stops
126 even if there is new data waiting to be processed */
127 static struct timer_list bulk_start_timer = TIMER_INITIALIZER(NULL, 0, 0);
128 static struct timer_list bulk_eot_timer = TIMER_INITIALIZER(NULL, 0, 0);
129
130 /* We want the start timer to expire before the eot timer, because the former
131 might start traffic, thus making it unnecessary for the latter to time
132 out. */
133 #define BULK_START_TIMER_INTERVAL (HZ/50) /* 20 ms */
134 #define BULK_EOT_TIMER_INTERVAL (HZ/16) /* 60 ms */
135
136 /* Delay before a URB completion happen when it's scheduled to be delayed */
137 #define LATER_TIMER_DELAY (HZ/50) /* 20 ms */
138
139 /* Simplifying macros for checking software state info of a epid */
140 /* ----------------------------------------------------------------------- */
141 #define epid_inuse(epid) epid_state[epid].inuse
142 #define epid_out_traffic(epid) epid_state[epid].out_traffic
143 #define epid_isoc(epid) (epid_state[epid].type == PIPE_ISOCHRONOUS ? 1 : 0)
144 #define epid_intr(epid) (epid_state[epid].type == PIPE_INTERRUPT ? 1 : 0)
145
146
147 /***************************************************************************/
148 /***************************************************************************/
149 /* DEBUG FUNCTIONS */
150 /***************************************************************************/
151 /***************************************************************************/
152 /* Note that these functions are always available in their "__" variants,
153 for use in error situations. The "__" missing variants are controlled by
154 the USB_DEBUG_DESC/USB_DEBUG_URB macros. */
155 static void __dump_urb(struct urb* purb)
156 {
157 struct crisv10_urb_priv *urb_priv = purb->hcpriv;
158 int urb_num = -1;
159 if(urb_priv) {
160 urb_num = urb_priv->urb_num;
161 }
162 printk("\nURB:0x%x[%d]\n", (unsigned int)purb, urb_num);
163 printk("dev :0x%08lx\n", (unsigned long)purb->dev);
164 printk("pipe :0x%08x\n", purb->pipe);
165 printk("status :%d\n", purb->status);
166 printk("transfer_flags :0x%08x\n", purb->transfer_flags);
167 printk("transfer_buffer :0x%08lx\n", (unsigned long)purb->transfer_buffer);
168 printk("transfer_buffer_length:%d\n", purb->transfer_buffer_length);
169 printk("actual_length :%d\n", purb->actual_length);
170 printk("setup_packet :0x%08lx\n", (unsigned long)purb->setup_packet);
171 printk("start_frame :%d\n", purb->start_frame);
172 printk("number_of_packets :%d\n", purb->number_of_packets);
173 printk("interval :%d\n", purb->interval);
174 printk("error_count :%d\n", purb->error_count);
175 printk("context :0x%08lx\n", (unsigned long)purb->context);
176 printk("complete :0x%08lx\n\n", (unsigned long)purb->complete);
177 }
178
179 static void __dump_in_desc(volatile struct USB_IN_Desc *in)
180 {
181 printk("\nUSB_IN_Desc at 0x%08lx\n", (unsigned long)in);
182 printk(" sw_len : 0x%04x (%d)\n", in->sw_len, in->sw_len);
183 printk(" command : 0x%04x\n", in->command);
184 printk(" next : 0x%08lx\n", in->next);
185 printk(" buf : 0x%08lx\n", in->buf);
186 printk(" hw_len : 0x%04x (%d)\n", in->hw_len, in->hw_len);
187 printk(" status : 0x%04x\n\n", in->status);
188 }
189
190 static void __dump_sb_desc(volatile struct USB_SB_Desc *sb)
191 {
192 char tt = (sb->command & 0x30) >> 4;
193 char *tt_string;
194
195 switch (tt) {
196 case 0:
197 tt_string = "zout";
198 break;
199 case 1:
200 tt_string = "in";
201 break;
202 case 2:
203 tt_string = "out";
204 break;
205 case 3:
206 tt_string = "setup";
207 break;
208 default:
209 tt_string = "unknown (weird)";
210 }
211
212 printk(" USB_SB_Desc at 0x%08lx ", (unsigned long)sb);
213 printk(" command:0x%04x (", sb->command);
214 printk("rem:%d ", (sb->command & 0x3f00) >> 8);
215 printk("full:%d ", (sb->command & 0x40) >> 6);
216 printk("tt:%d(%s) ", tt, tt_string);
217 printk("intr:%d ", (sb->command & 0x8) >> 3);
218 printk("eot:%d ", (sb->command & 0x2) >> 1);
219 printk("eol:%d)", sb->command & 0x1);
220 printk(" sw_len:0x%04x(%d)", sb->sw_len, sb->sw_len);
221 printk(" next:0x%08lx", sb->next);
222 printk(" buf:0x%08lx\n", sb->buf);
223 }
224
225
226 static void __dump_ep_desc(volatile struct USB_EP_Desc *ep)
227 {
228 printk("USB_EP_Desc at 0x%08lx ", (unsigned long)ep);
229 printk(" command:0x%04x (", ep->command);
230 printk("ep_id:%d ", (ep->command & 0x1f00) >> 8);
231 printk("enable:%d ", (ep->command & 0x10) >> 4);
232 printk("intr:%d ", (ep->command & 0x8) >> 3);
233 printk("eof:%d ", (ep->command & 0x2) >> 1);
234 printk("eol:%d)", ep->command & 0x1);
235 printk(" hw_len:0x%04x(%d)", ep->hw_len, ep->hw_len);
236 printk(" next:0x%08lx", ep->next);
237 printk(" sub:0x%08lx\n", ep->sub);
238 }
239
240 static inline void __dump_ep_list(int pipe_type)
241 {
242 volatile struct USB_EP_Desc *ep;
243 volatile struct USB_EP_Desc *first_ep;
244 volatile struct USB_SB_Desc *sb;
245
246 switch (pipe_type)
247 {
248 case PIPE_BULK:
249 first_ep = &TxBulkEPList[0];
250 break;
251 case PIPE_CONTROL:
252 first_ep = &TxCtrlEPList[0];
253 break;
254 case PIPE_INTERRUPT:
255 first_ep = &TxIntrEPList[0];
256 break;
257 case PIPE_ISOCHRONOUS:
258 first_ep = &TxIsocEPList[0];
259 break;
260 default:
261 return;
262 }
263 ep = first_ep;
264
265 printk("\n\nDumping EP list...\n\n");
266
267 do {
268 __dump_ep_desc(ep);
269 /* Cannot phys_to_virt on 0 as it turns into 80000000, which is != 0. */
270 sb = ep->sub ? phys_to_virt(ep->sub) : 0;
271 while (sb) {
272 __dump_sb_desc(sb);
273 sb = sb->next ? phys_to_virt(sb->next) : 0;
274 }
275 ep = (volatile struct USB_EP_Desc *)(phys_to_virt(ep->next));
276
277 } while (ep != first_ep);
278 }
279
280 static inline void __dump_ept_data(int epid)
281 {
282 unsigned long flags;
283 __u32 r_usb_ept_data;
284
285 if (epid < 0 || epid > 31) {
286 printk("Cannot dump ept data for invalid epid %d\n", epid);
287 return;
288 }
289
290 local_irq_save(flags);
291 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
292 nop();
293 r_usb_ept_data = *R_USB_EPT_DATA;
294 local_irq_restore(flags);
295
296 printk(" R_USB_EPT_DATA = 0x%x for epid %d :\n", r_usb_ept_data, epid);
297 if (r_usb_ept_data == 0) {
298 /* No need for more detailed printing. */
299 return;
300 }
301 printk(" valid : %d\n", (r_usb_ept_data & 0x80000000) >> 31);
302 printk(" hold : %d\n", (r_usb_ept_data & 0x40000000) >> 30);
303 printk(" error_count_in : %d\n", (r_usb_ept_data & 0x30000000) >> 28);
304 printk(" t_in : %d\n", (r_usb_ept_data & 0x08000000) >> 27);
305 printk(" low_speed : %d\n", (r_usb_ept_data & 0x04000000) >> 26);
306 printk(" port : %d\n", (r_usb_ept_data & 0x03000000) >> 24);
307 printk(" error_code : %d\n", (r_usb_ept_data & 0x00c00000) >> 22);
308 printk(" t_out : %d\n", (r_usb_ept_data & 0x00200000) >> 21);
309 printk(" error_count_out : %d\n", (r_usb_ept_data & 0x00180000) >> 19);
310 printk(" max_len : %d\n", (r_usb_ept_data & 0x0003f800) >> 11);
311 printk(" ep : %d\n", (r_usb_ept_data & 0x00000780) >> 7);
312 printk(" dev : %d\n", (r_usb_ept_data & 0x0000003f));
313 }
314
315 static inline void __dump_ept_data_iso(int epid)
316 {
317 unsigned long flags;
318 __u32 ept_data;
319
320 if (epid < 0 || epid > 31) {
321 printk("Cannot dump ept data for invalid epid %d\n", epid);
322 return;
323 }
324
325 local_irq_save(flags);
326 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
327 nop();
328 ept_data = *R_USB_EPT_DATA_ISO;
329 local_irq_restore(flags);
330
331 printk(" R_USB_EPT_DATA = 0x%x for epid %d :\n", ept_data, epid);
332 if (ept_data == 0) {
333 /* No need for more detailed printing. */
334 return;
335 }
336 printk(" valid : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, valid,
337 ept_data));
338 printk(" port : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, port,
339 ept_data));
340 printk(" error_code : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code,
341 ept_data));
342 printk(" max_len : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, max_len,
343 ept_data));
344 printk(" ep : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, ep,
345 ept_data));
346 printk(" dev : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, dev,
347 ept_data));
348 }
349
350 static inline void __dump_ept_data_list(void)
351 {
352 int i;
353
354 printk("Dumping the whole R_USB_EPT_DATA list\n");
355
356 for (i = 0; i < 32; i++) {
357 __dump_ept_data(i);
358 }
359 }
360
361 static void debug_epid(int epid) {
362 int i;
363
364 if(epid_isoc(epid)) {
365 __dump_ept_data_iso(epid);
366 } else {
367 __dump_ept_data(epid);
368 }
369
370 printk("Bulk:\n");
371 for(i = 0; i < 32; i++) {
372 if(IO_EXTRACT(USB_EP_command, epid, TxBulkEPList[i].command) ==
373 epid) {
374 printk("%d: ", i); __dump_ep_desc(&(TxBulkEPList[i]));
375 }
376 }
377
378 printk("Ctrl:\n");
379 for(i = 0; i < 32; i++) {
380 if(IO_EXTRACT(USB_EP_command, epid, TxCtrlEPList[i].command) ==
381 epid) {
382 printk("%d: ", i); __dump_ep_desc(&(TxCtrlEPList[i]));
383 }
384 }
385
386 printk("Intr:\n");
387 for(i = 0; i < MAX_INTR_INTERVAL; i++) {
388 if(IO_EXTRACT(USB_EP_command, epid, TxIntrEPList[i].command) ==
389 epid) {
390 printk("%d: ", i); __dump_ep_desc(&(TxIntrEPList[i]));
391 }
392 }
393
394 printk("Isoc:\n");
395 for(i = 0; i < 32; i++) {
396 if(IO_EXTRACT(USB_EP_command, epid, TxIsocEPList[i].command) ==
397 epid) {
398 printk("%d: ", i); __dump_ep_desc(&(TxIsocEPList[i]));
399 }
400 }
401
402 __dump_ept_data_list();
403 __dump_ep_list(PIPE_INTERRUPT);
404 printk("\n\n");
405 }
406
407
408
409 char* hcd_status_to_str(__u8 bUsbStatus) {
410 static char hcd_status_str[128];
411 hcd_status_str[0] = '\0';
412 if(bUsbStatus & IO_STATE(R_USB_STATUS, ourun, yes)) {
413 strcat(hcd_status_str, "ourun ");
414 }
415 if(bUsbStatus & IO_STATE(R_USB_STATUS, perror, yes)) {
416 strcat(hcd_status_str, "perror ");
417 }
418 if(bUsbStatus & IO_STATE(R_USB_STATUS, device_mode, yes)) {
419 strcat(hcd_status_str, "device_mode ");
420 }
421 if(bUsbStatus & IO_STATE(R_USB_STATUS, host_mode, yes)) {
422 strcat(hcd_status_str, "host_mode ");
423 }
424 if(bUsbStatus & IO_STATE(R_USB_STATUS, started, yes)) {
425 strcat(hcd_status_str, "started ");
426 }
427 if(bUsbStatus & IO_STATE(R_USB_STATUS, running, yes)) {
428 strcat(hcd_status_str, "running ");
429 }
430 return hcd_status_str;
431 }
432
433
434 char* sblist_to_str(struct USB_SB_Desc* sb_desc) {
435 static char sblist_to_str_buff[128];
436 char tmp[32], tmp2[32];
437 sblist_to_str_buff[0] = '\0';
438 while(sb_desc != NULL) {
439 switch(IO_EXTRACT(USB_SB_command, tt, sb_desc->command)) {
440 case 0: sprintf(tmp, "zout"); break;
441 case 1: sprintf(tmp, "in"); break;
442 case 2: sprintf(tmp, "out"); break;
443 case 3: sprintf(tmp, "setup"); break;
444 }
445 sprintf(tmp2, "(%s %d)", tmp, sb_desc->sw_len);
446 strcat(sblist_to_str_buff, tmp2);
447 if(sb_desc->next != 0) {
448 sb_desc = phys_to_virt(sb_desc->next);
449 } else {
450 sb_desc = NULL;
451 }
452 }
453 return sblist_to_str_buff;
454 }
455
456 char* port_status_to_str(__u16 wPortStatus) {
457 static char port_status_str[128];
458 port_status_str[0] = '\0';
459 if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, connected, yes)) {
460 strcat(port_status_str, "connected ");
461 }
462 if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)) {
463 strcat(port_status_str, "enabled ");
464 }
465 if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, suspended, yes)) {
466 strcat(port_status_str, "suspended ");
467 }
468 if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, reset, yes)) {
469 strcat(port_status_str, "reset ");
470 }
471 if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, speed, full)) {
472 strcat(port_status_str, "full-speed ");
473 } else {
474 strcat(port_status_str, "low-speed ");
475 }
476 return port_status_str;
477 }
478
479
480 char* endpoint_to_str(struct usb_endpoint_descriptor *ed) {
481 static char endpoint_to_str_buff[128];
482 char tmp[32];
483 int epnum = ed->bEndpointAddress & 0x0F;
484 int dir = ed->bEndpointAddress & 0x80;
485 int type = ed->bmAttributes & 0x03;
486 endpoint_to_str_buff[0] = '\0';
487 sprintf(endpoint_to_str_buff, "ep:%d ", epnum);
488 switch(type) {
489 case 0:
490 sprintf(tmp, " ctrl");
491 break;
492 case 1:
493 sprintf(tmp, " isoc");
494 break;
495 case 2:
496 sprintf(tmp, " bulk");
497 break;
498 case 3:
499 sprintf(tmp, " intr");
500 break;
501 }
502 strcat(endpoint_to_str_buff, tmp);
503 if(dir) {
504 sprintf(tmp, " in");
505 } else {
506 sprintf(tmp, " out");
507 }
508 strcat(endpoint_to_str_buff, tmp);
509
510 return endpoint_to_str_buff;
511 }
512
513 /* Debug helper functions for Transfer Controller */
514 char* pipe_to_str(unsigned int pipe) {
515 static char pipe_to_str_buff[128];
516 char tmp[64];
517 sprintf(pipe_to_str_buff, "dir:%s", str_dir(pipe));
518 sprintf(tmp, " type:%s", str_type(pipe));
519 strcat(pipe_to_str_buff, tmp);
520
521 sprintf(tmp, " dev:%d", usb_pipedevice(pipe));
522 strcat(pipe_to_str_buff, tmp);
523 sprintf(tmp, " ep:%d", usb_pipeendpoint(pipe));
524 strcat(pipe_to_str_buff, tmp);
525 return pipe_to_str_buff;
526 }
527
528
529 #define USB_DEBUG_DESC 1
530
531 #ifdef USB_DEBUG_DESC
532 #define dump_in_desc(x) __dump_in_desc(x)
533 #define dump_sb_desc(...) __dump_sb_desc(...)
534 #define dump_ep_desc(x) __dump_ep_desc(x)
535 #define dump_ept_data(x) __dump_ept_data(x)
536 #else
537 #define dump_in_desc(...) do {} while (0)
538 #define dump_sb_desc(...) do {} while (0)
539 #define dump_ep_desc(...) do {} while (0)
540 #endif
541
542
543 /* Uncomment this to enable massive function call trace
544 #define USB_DEBUG_TRACE */
545
546 #ifdef USB_DEBUG_TRACE
547 #define DBFENTER (printk(": Entering: %s\n", __FUNCTION__))
548 #define DBFEXIT (printk(": Exiting: %s\n", __FUNCTION__))
549 #else
550 #define DBFENTER do {} while (0)
551 #define DBFEXIT do {} while (0)
552 #endif
553
554 #define CHECK_ALIGN(x) if (((__u32)(x)) & 0x00000003) \
555 {panic("Alignment check (DWORD) failed at %s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);}
556
557 /* Most helpful debugging aid */
558 #define ASSERT(expr) ((void) ((expr) ? 0 : (err("assert failed at: %s %d",__FUNCTION__, __LINE__))))
559
560
561 /***************************************************************************/
562 /***************************************************************************/
563 /* Forward declarations */
564 /***************************************************************************/
565 /***************************************************************************/
566 void crisv10_hcd_epid_attn_irq(struct crisv10_irq_reg *reg);
567 void crisv10_hcd_port_status_irq(struct crisv10_irq_reg *reg);
568 void crisv10_hcd_ctl_status_irq(struct crisv10_irq_reg *reg);
569 void crisv10_hcd_isoc_eof_irq(struct crisv10_irq_reg *reg);
570
571 void rh_port_status_change(__u16[]);
572 int rh_clear_port_feature(__u8, __u16);
573 int rh_set_port_feature(__u8, __u16);
574 static void rh_disable_port(unsigned int port);
575
576 static void check_finished_bulk_tx_epids(struct usb_hcd *hcd,
577 int timer);
578
579 static int tc_setup_epid(struct usb_host_endpoint *ep, struct urb *urb,
580 int mem_flags);
581 static void tc_free_epid(struct usb_host_endpoint *ep);
582 static int tc_allocate_epid(void);
583 static void tc_finish_urb(struct usb_hcd *hcd, struct urb *urb, int status);
584 static void tc_finish_urb_later(struct usb_hcd *hcd, struct urb *urb,
585 int status);
586
587 static int urb_priv_create(struct usb_hcd *hcd, struct urb *urb, int epid,
588 int mem_flags);
589 static void urb_priv_free(struct usb_hcd *hcd, struct urb *urb);
590
591 static int crisv10_usb_check_bandwidth(struct usb_device *dev,struct urb *urb);
592 static void crisv10_usb_claim_bandwidth(
593 struct usb_device *dev, struct urb *urb, int bustime, int isoc);
594 static void crisv10_usb_release_bandwidth(
595 struct usb_hcd *hcd, int isoc, int bandwidth);
596
597 static inline struct urb *urb_list_first(int epid);
598 static inline void urb_list_add(struct urb *urb, int epid,
599 int mem_flags);
600 static inline urb_entry_t *urb_list_entry(struct urb *urb, int epid);
601 static inline void urb_list_del(struct urb *urb, int epid);
602 static inline void urb_list_move_last(struct urb *urb, int epid);
603 static inline struct urb *urb_list_next(struct urb *urb, int epid);
604
605 int create_sb_for_urb(struct urb *urb, int mem_flags);
606 int init_intr_urb(struct urb *urb, int mem_flags);
607
608 static inline void etrax_epid_set(__u8 index, __u32 data);
609 static inline void etrax_epid_clear_error(__u8 index);
610 static inline void etrax_epid_set_toggle(__u8 index, __u8 dirout,
611 __u8 toggle);
612 static inline __u8 etrax_epid_get_toggle(__u8 index, __u8 dirout);
613 static inline __u32 etrax_epid_get(__u8 index);
614
615 /* We're accessing the same register position in Etrax so
616 when we do full access the internal difference doesn't matter */
617 #define etrax_epid_iso_set(index, data) etrax_epid_set(index, data)
618 #define etrax_epid_iso_get(index) etrax_epid_get(index)
619
620
621 static void tc_dma_process_isoc_urb(struct urb *urb);
622 static void tc_dma_process_queue(int epid);
623 static void tc_dma_unlink_intr_urb(struct urb *urb);
624 static irqreturn_t tc_dma_tx_interrupt(int irq, void *vhc);
625 static irqreturn_t tc_dma_rx_interrupt(int irq, void *vhc);
626
627 static void tc_bulk_start_timer_func(unsigned long dummy);
628 static void tc_bulk_eot_timer_func(unsigned long dummy);
629
630
631 /*************************************************************/
632 /*************************************************************/
633 /* Host Controler Driver block */
634 /*************************************************************/
635 /*************************************************************/
636
637 /* HCD operations */
638 static irqreturn_t crisv10_hcd_top_irq(int irq, void*);
639 static int crisv10_hcd_reset(struct usb_hcd *);
640 static int crisv10_hcd_start(struct usb_hcd *);
641 static void crisv10_hcd_stop(struct usb_hcd *);
642 #ifdef CONFIG_PM
643 static int crisv10_hcd_suspend(struct device *, u32, u32);
644 static int crisv10_hcd_resume(struct device *, u32);
645 #endif /* CONFIG_PM */
646 static int crisv10_hcd_get_frame(struct usb_hcd *);
647
648 static int tc_urb_enqueue(struct usb_hcd *, struct urb *, gfp_t mem_flags);
649 static int tc_urb_dequeue(struct usb_hcd *, struct urb *, int);
650 static void tc_endpoint_disable(struct usb_hcd *, struct usb_host_endpoint *ep);
651
652 static int rh_status_data_request(struct usb_hcd *, char *);
653 static int rh_control_request(struct usb_hcd *, u16, u16, u16, char*, u16);
654
655 #ifdef CONFIG_PM
656 static int crisv10_hcd_hub_suspend(struct usb_hcd *);
657 static int crisv10_hcd_hub_resume(struct usb_hcd *);
658 #endif /* CONFIG_PM */
659 #ifdef CONFIG_USB_OTG
660 static int crisv10_hcd_start_port_reset(struct usb_hcd *, unsigned);
661 #endif /* CONFIG_USB_OTG */
662
663 /* host controller driver interface */
664 static const struct hc_driver crisv10_hc_driver =
665 {
666 .description = hc_name,
667 .product_desc = product_desc,
668 .hcd_priv_size = sizeof(struct crisv10_hcd),
669
670 /* Attaching IRQ handler manualy in probe() */
671 /* .irq = crisv10_hcd_irq, */
672
673 .flags = HCD_USB11,
674
675 /* called to init HCD and root hub */
676 .reset = crisv10_hcd_reset,
677 .start = crisv10_hcd_start,
678
679 /* cleanly make HCD stop writing memory and doing I/O */
680 .stop = crisv10_hcd_stop,
681
682 /* return current frame number */
683 .get_frame_number = crisv10_hcd_get_frame,
684
685
686 /* Manage i/o requests via the Transfer Controller */
687 .urb_enqueue = tc_urb_enqueue,
688 .urb_dequeue = tc_urb_dequeue,
689
690 /* hw synch, freeing endpoint resources that urb_dequeue can't */
691 .endpoint_disable = tc_endpoint_disable,
692
693
694 /* Root Hub support */
695 .hub_status_data = rh_status_data_request,
696 .hub_control = rh_control_request,
697 #ifdef CONFIG_PM
698 .hub_suspend = rh_suspend_request,
699 .hub_resume = rh_resume_request,
700 #endif /* CONFIG_PM */
701 #ifdef CONFIG_USB_OTG
702 .start_port_reset = crisv10_hcd_start_port_reset,
703 #endif /* CONFIG_USB_OTG */
704 };
705
706
707 /*
708 * conversion between pointers to a hcd and the corresponding
709 * crisv10_hcd
710 */
711
712 static inline struct crisv10_hcd *hcd_to_crisv10_hcd(struct usb_hcd *hcd)
713 {
714 return (struct crisv10_hcd *) hcd->hcd_priv;
715 }
716
717 static inline struct usb_hcd *crisv10_hcd_to_hcd(struct crisv10_hcd *hcd)
718 {
719 return container_of((void *) hcd, struct usb_hcd, hcd_priv);
720 }
721
722 /* check if specified port is in use */
723 static inline int port_in_use(unsigned int port)
724 {
725 return ports & (1 << port);
726 }
727
728 /* number of ports in use */
729 static inline unsigned int num_ports(void)
730 {
731 unsigned int i, num = 0;
732 for (i = 0; i < USB_ROOT_HUB_PORTS; i++)
733 if (port_in_use(i))
734 num++;
735 return num;
736 }
737
738 /* map hub port number to the port number used internally by the HC */
739 static inline unsigned int map_port(unsigned int port)
740 {
741 unsigned int i, num = 0;
742 for (i = 0; i < USB_ROOT_HUB_PORTS; i++)
743 if (port_in_use(i))
744 if (++num == port)
745 return i;
746 return -1;
747 }
748
749 /* size of descriptors in slab cache */
750 #ifndef MAX
751 #define MAX(x, y) ((x) > (y) ? (x) : (y))
752 #endif
753
754
755 /******************************************************************/
756 /* Hardware Interrupt functions */
757 /******************************************************************/
758
759 /* Fast interrupt handler for HC */
760 static irqreturn_t crisv10_hcd_top_irq(int irq, void *vcd)
761 {
762 struct usb_hcd *hcd = vcd;
763 struct crisv10_irq_reg reg;
764 __u32 irq_mask;
765 unsigned long flags;
766
767 DBFENTER;
768
769 ASSERT(hcd != NULL);
770 reg.hcd = hcd;
771
772 /* Turn of other interrupts while handling these sensitive cases */
773 local_irq_save(flags);
774
775 /* Read out which interrupts that are flaged */
776 irq_mask = *R_USB_IRQ_MASK_READ;
777 reg.r_usb_irq_mask_read = irq_mask;
778
779 /* Reading R_USB_STATUS clears the ctl_status interrupt. Note that
780 R_USB_STATUS must be read before R_USB_EPID_ATTN since reading the latter
781 clears the ourun and perror fields of R_USB_STATUS. */
782 reg.r_usb_status = *R_USB_STATUS;
783
784 /* Reading R_USB_EPID_ATTN clears the iso_eof, bulk_eot and epid_attn
785 interrupts. */
786 reg.r_usb_epid_attn = *R_USB_EPID_ATTN;
787
788 /* Reading R_USB_RH_PORT_STATUS_1 and R_USB_RH_PORT_STATUS_2 clears the
789 port_status interrupt. */
790 reg.r_usb_rh_port_status_1 = *R_USB_RH_PORT_STATUS_1;
791 reg.r_usb_rh_port_status_2 = *R_USB_RH_PORT_STATUS_2;
792
793 /* Reading R_USB_FM_NUMBER clears the sof interrupt. */
794 /* Note: the lower 11 bits contain the actual frame number, sent with each
795 sof. */
796 reg.r_usb_fm_number = *R_USB_FM_NUMBER;
797
798 /* Interrupts are handled in order of priority. */
799 if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, port_status)) {
800 crisv10_hcd_port_status_irq(&reg);
801 }
802 if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, epid_attn)) {
803 crisv10_hcd_epid_attn_irq(&reg);
804 }
805 if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, ctl_status)) {
806 crisv10_hcd_ctl_status_irq(&reg);
807 }
808 if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, iso_eof)) {
809 crisv10_hcd_isoc_eof_irq(&reg);
810 }
811 if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, bulk_eot)) {
812 /* Update/restart the bulk start timer since obviously the channel is
813 running. */
814 mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
815 /* Update/restart the bulk eot timer since we just received an bulk eot
816 interrupt. */
817 mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
818
819 /* Check for finished bulk transfers on epids */
820 check_finished_bulk_tx_epids(hcd, 0);
821 }
822 local_irq_restore(flags);
823
824 DBFEXIT;
825 return IRQ_HANDLED;
826 }
827
828
829 void crisv10_hcd_epid_attn_irq(struct crisv10_irq_reg *reg) {
830 struct usb_hcd *hcd = reg->hcd;
831 struct crisv10_urb_priv *urb_priv;
832 int epid;
833 DBFENTER;
834
835 for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
836 if (test_bit(epid, (void *)&reg->r_usb_epid_attn)) {
837 struct urb *urb;
838 __u32 ept_data;
839 int error_code;
840
841 if (epid == DUMMY_EPID || epid == INVALID_EPID) {
842 /* We definitely don't care about these ones. Besides, they are
843 always disabled, so any possible disabling caused by the
844 epid attention interrupt is irrelevant. */
845 continue;
846 }
847
848 if(!epid_inuse(epid)) {
849 irq_err("Epid attention on epid:%d that isn't in use\n", epid);
850 printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
851 debug_epid(epid);
852 continue;
853 }
854
855 /* Note that although there are separate R_USB_EPT_DATA and
856 R_USB_EPT_DATA_ISO registers, they are located at the same address and
857 are of the same size. In other words, this read should be ok for isoc
858 also. */
859 ept_data = etrax_epid_get(epid);
860 error_code = IO_EXTRACT(R_USB_EPT_DATA, error_code, ept_data);
861
862 /* Get the active URB for this epid. We blatantly assume
863 that only this URB could have caused the epid attention. */
864 urb = activeUrbList[epid];
865 if (urb == NULL) {
866 irq_err("Attention on epid:%d error:%d with no active URB.\n",
867 epid, error_code);
868 printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
869 debug_epid(epid);
870 continue;
871 }
872
873 urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
874 ASSERT(urb_priv);
875
876 /* Using IO_STATE_VALUE on R_USB_EPT_DATA should be ok for isoc also. */
877 if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
878
879 /* Isoc traffic doesn't have error_count_in/error_count_out. */
880 if ((usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS) &&
881 (IO_EXTRACT(R_USB_EPT_DATA, error_count_in, ept_data) == 3 ||
882 IO_EXTRACT(R_USB_EPT_DATA, error_count_out, ept_data) == 3)) {
883 /* Check if URB allready is marked for late-finish, we can get
884 several 3rd error for Intr traffic when a device is unplugged */
885 if(urb_priv->later_data == NULL) {
886 /* 3rd error. */
887 irq_warn("3rd error for epid:%d (%s %s) URB:0x%x[%d]\n", epid,
888 str_dir(urb->pipe), str_type(urb->pipe),
889 (unsigned int)urb, urb_priv->urb_num);
890
891 tc_finish_urb_later(hcd, urb, -EPROTO);
892 }
893
894 } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
895 irq_warn("Perror for epid:%d\n", epid);
896 printk("FM_NUMBER: %d\n", reg->r_usb_fm_number & 0x7ff);
897 printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
898 __dump_urb(urb);
899 debug_epid(epid);
900
901 if (!(ept_data & IO_MASK(R_USB_EPT_DATA, valid))) {
902 /* invalid ep_id */
903 panic("Perror because of invalid epid."
904 " Deconfigured too early?");
905 } else {
906 /* past eof1, near eof, zout transfer, setup transfer */
907 /* Dump the urb and the relevant EP descriptor. */
908 panic("Something wrong with DMA descriptor contents."
909 " Too much traffic inserted?");
910 }
911 } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
912 /* buffer ourun */
913 printk("FM_NUMBER: %d\n", reg->r_usb_fm_number & 0x7ff);
914 printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
915 __dump_urb(urb);
916 debug_epid(epid);
917
918 panic("Buffer overrun/underrun for epid:%d. DMA too busy?", epid);
919 } else {
920 irq_warn("Attention on epid:%d (%s %s) with no error code\n", epid,
921 str_dir(urb->pipe), str_type(urb->pipe));
922 printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
923 __dump_urb(urb);
924 debug_epid(epid);
925 }
926
927 } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
928 stall)) {
929 /* Not really a protocol error, just says that the endpoint gave
930 a stall response. Note that error_code cannot be stall for isoc. */
931 if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
932 panic("Isoc traffic cannot stall");
933 }
934
935 tc_dbg("Stall for epid:%d (%s %s) URB:0x%x\n", epid,
936 str_dir(urb->pipe), str_type(urb->pipe), (unsigned int)urb);
937 tc_finish_urb(hcd, urb, -EPIPE);
938
939 } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
940 bus_error)) {
941 /* Two devices responded to a transaction request. Must be resolved
942 by software. FIXME: Reset ports? */
943 panic("Bus error for epid %d."
944 " Two devices responded to transaction request\n",
945 epid);
946
947 } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
948 buffer_error)) {
949 /* DMA overrun or underrun. */
950 irq_warn("Buffer overrun/underrun for epid:%d (%s %s)\n", epid,
951 str_dir(urb->pipe), str_type(urb->pipe));
952
953 /* It seems that error_code = buffer_error in
954 R_USB_EPT_DATA/R_USB_EPT_DATA_ISO and ourun = yes in R_USB_STATUS
955 are the same error. */
956 tc_finish_urb(hcd, urb, -EPROTO);
957 } else {
958 irq_warn("Unknown attention on epid:%d (%s %s)\n", epid,
959 str_dir(urb->pipe), str_type(urb->pipe));
960 dump_ept_data(epid);
961 }
962 }
963 }
964 DBFEXIT;
965 }
966
967 void crisv10_hcd_port_status_irq(struct crisv10_irq_reg *reg)
968 {
969 __u16 port_reg[USB_ROOT_HUB_PORTS];
970 DBFENTER;
971 port_reg[0] = reg->r_usb_rh_port_status_1;
972 port_reg[1] = reg->r_usb_rh_port_status_2;
973 rh_port_status_change(port_reg);
974 DBFEXIT;
975 }
976
977 void crisv10_hcd_isoc_eof_irq(struct crisv10_irq_reg *reg)
978 {
979 int epid;
980 struct urb *urb;
981 struct crisv10_urb_priv *urb_priv;
982
983 DBFENTER;
984
985 for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
986
987 /* Only check epids that are in use, is valid and has SB list */
988 if (!epid_inuse(epid) || epid == INVALID_EPID ||
989 TxIsocEPList[epid].sub == 0 || epid == DUMMY_EPID) {
990 /* Nothing here to see. */
991 continue;
992 }
993 ASSERT(epid_isoc(epid));
994
995 /* Get the active URB for this epid (if any). */
996 urb = activeUrbList[epid];
997 if (urb == 0) {
998 isoc_warn("Ignoring NULL urb for epid:%d\n", epid);
999 continue;
1000 }
1001 if(!epid_out_traffic(epid)) {
1002 /* Sanity check. */
1003 ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
1004
1005 urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
1006 ASSERT(urb_priv);
1007
1008 if (urb_priv->urb_state == NOT_STARTED) {
1009 /* If ASAP is not set and urb->start_frame is the current frame,
1010 start the transfer. */
1011 if (!(urb->transfer_flags & URB_ISO_ASAP) &&
1012 (urb->start_frame == (*R_USB_FM_NUMBER & 0x7ff))) {
1013 /* EP should not be enabled if we're waiting for start_frame */
1014 ASSERT((TxIsocEPList[epid].command &
1015 IO_STATE(USB_EP_command, enable, yes)) == 0);
1016
1017 isoc_warn("Enabling isoc IN EP descr for epid %d\n", epid);
1018 TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
1019
1020 /* This urb is now active. */
1021 urb_priv->urb_state = STARTED;
1022 continue;
1023 }
1024 }
1025 }
1026 }
1027
1028 DBFEXIT;
1029 }
1030
1031 void crisv10_hcd_ctl_status_irq(struct crisv10_irq_reg *reg)
1032 {
1033 struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(reg->hcd);
1034
1035 DBFENTER;
1036 ASSERT(crisv10_hcd);
1037
1038 /* irq_dbg("ctr_status_irq, controller status: %s\n",
1039 hcd_status_to_str(reg->r_usb_status));*/
1040
1041 /* FIXME: What should we do if we get ourun or perror? Dump the EP and SB
1042 list for the corresponding epid? */
1043 if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
1044 panic("USB controller got ourun.");
1045 }
1046 if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
1047
1048 /* Before, etrax_usb_do_intr_recover was called on this epid if it was
1049 an interrupt pipe. I don't see how re-enabling all EP descriptors
1050 will help if there was a programming error. */
1051 panic("USB controller got perror.");
1052 }
1053
1054 /* Keep track of USB Controller, if it's running or not */
1055 if(reg->r_usb_status & IO_STATE(R_USB_STATUS, running, yes)) {
1056 crisv10_hcd->running = 1;
1057 } else {
1058 crisv10_hcd->running = 0;
1059 }
1060
1061 if (reg->r_usb_status & IO_MASK(R_USB_STATUS, device_mode)) {
1062 /* We should never operate in device mode. */
1063 panic("USB controller in device mode.");
1064 }
1065
1066 /* Set the flag to avoid getting "Unlink after no-IRQ? Controller is probably
1067 using the wrong IRQ" from hcd_unlink_urb() in drivers/usb/core/hcd.c */
1068 set_bit(HCD_FLAG_SAW_IRQ, &reg->hcd->flags);
1069
1070 DBFEXIT;
1071 }
1072
1073
1074 /******************************************************************/
1075 /* Host Controller interface functions */
1076 /******************************************************************/
1077
1078 static inline void crisv10_ready_wait(void) {
1079 volatile int timeout = 10000;
1080 /* Check the busy bit of USB controller in Etrax */
1081 while((*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy)) &&
1082 (timeout-- > 0));
1083 }
1084
1085 /* reset host controller */
1086 static int crisv10_hcd_reset(struct usb_hcd *hcd)
1087 {
1088 DBFENTER;
1089 hcd_dbg(hcd, "reset\n");
1090
1091
1092 /* Reset the USB interface. */
1093 /*
1094 *R_USB_COMMAND =
1095 IO_STATE(R_USB_COMMAND, port_sel, nop) |
1096 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
1097 IO_STATE(R_USB_COMMAND, ctrl_cmd, reset);
1098 nop();
1099 */
1100 DBFEXIT;
1101 return 0;
1102 }
1103
1104 /* start host controller */
1105 static int crisv10_hcd_start(struct usb_hcd *hcd)
1106 {
1107 DBFENTER;
1108 hcd_dbg(hcd, "start\n");
1109
1110 crisv10_ready_wait();
1111
1112 /* Start processing of USB traffic. */
1113 *R_USB_COMMAND =
1114 IO_STATE(R_USB_COMMAND, port_sel, nop) |
1115 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
1116 IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
1117
1118 nop();
1119
1120 hcd->state = HC_STATE_RUNNING;
1121
1122 DBFEXIT;
1123 return 0;
1124 }
1125
1126 /* stop host controller */
1127 static void crisv10_hcd_stop(struct usb_hcd *hcd)
1128 {
1129 DBFENTER;
1130 hcd_dbg(hcd, "stop\n");
1131 crisv10_hcd_reset(hcd);
1132 DBFEXIT;
1133 }
1134
1135 /* return the current frame number */
1136 static int crisv10_hcd_get_frame(struct usb_hcd *hcd)
1137 {
1138 DBFENTER;
1139 DBFEXIT;
1140 return (*R_USB_FM_NUMBER & 0x7ff);
1141 }
1142
1143 #ifdef CONFIG_USB_OTG
1144
1145 static int crisv10_hcd_start_port_reset(struct usb_hcd *hcd, unsigned port)
1146 {
1147 return 0; /* no-op for now */
1148 }
1149
1150 #endif /* CONFIG_USB_OTG */
1151
1152
1153 /******************************************************************/
1154 /* Root Hub functions */
1155 /******************************************************************/
1156
1157 /* root hub status */
1158 static const struct usb_hub_status rh_hub_status =
1159 {
1160 .wHubStatus = 0,
1161 .wHubChange = 0,
1162 };
1163
1164 /* root hub descriptor */
1165 static const u8 rh_hub_descr[] =
1166 {
1167 0x09, /* bDescLength */
1168 0x29, /* bDescriptorType */
1169 USB_ROOT_HUB_PORTS, /* bNbrPorts */
1170 0x00, /* wHubCharacteristics */
1171 0x00,
1172 0x01, /* bPwrOn2pwrGood */
1173 0x00, /* bHubContrCurrent */
1174 0x00, /* DeviceRemovable */
1175 0xff /* PortPwrCtrlMask */
1176 };
1177
1178 /* Actual holder of root hub status*/
1179 struct crisv10_rh rh;
1180
1181 /* Initialize root hub data structures (called from dvdrv_hcd_probe()) */
1182 int rh_init(void) {
1183 int i;
1184 /* Reset port status flags */
1185 for (i = 0; i < USB_ROOT_HUB_PORTS; i++) {
1186 rh.wPortChange[i] = 0;
1187 rh.wPortStatusPrev[i] = 0;
1188 }
1189 return 0;
1190 }
1191
1192 #define RH_FEAT_MASK ((1<<USB_PORT_FEAT_CONNECTION)|\
1193 (1<<USB_PORT_FEAT_ENABLE)|\
1194 (1<<USB_PORT_FEAT_SUSPEND)|\
1195 (1<<USB_PORT_FEAT_RESET))
1196
1197 /* Handle port status change interrupt (called from bottom part interrupt) */
1198 void rh_port_status_change(__u16 port_reg[]) {
1199 int i;
1200 __u16 wChange;
1201
1202 for(i = 0; i < USB_ROOT_HUB_PORTS; i++) {
1203 /* Xor out changes since last read, masked for important flags */
1204 wChange = (port_reg[i] & RH_FEAT_MASK) ^ rh.wPortStatusPrev[i];
1205 /* Or changes together with (if any) saved changes */
1206 rh.wPortChange[i] |= wChange;
1207 /* Save new status */
1208 rh.wPortStatusPrev[i] = port_reg[i];
1209
1210 if(wChange) {
1211 rh_dbg("Interrupt port_status change port%d: %s Current-status:%s\n", i+1,
1212 port_status_to_str(wChange),
1213 port_status_to_str(port_reg[i]));
1214 }
1215 }
1216 }
1217
1218 /* Construct port status change bitmap for the root hub */
1219 static int rh_status_data_request(struct usb_hcd *hcd, char *buf)
1220 {
1221 struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
1222 unsigned int i;
1223
1224 DBFENTER;
1225 /*
1226 * corresponds to hub status change EP (USB 2.0 spec section 11.13.4)
1227 * return bitmap indicating ports with status change
1228 */
1229 *buf = 0;
1230 spin_lock(&crisv10_hcd->lock);
1231 for (i = 1; i <= crisv10_hcd->num_ports; i++) {
1232 if (rh.wPortChange[map_port(i)]) {
1233 *buf |= (1 << i);
1234 rh_dbg("rh_status_data_request, change on port %d: %s Current Status: %s\n", i,
1235 port_status_to_str(rh.wPortChange[map_port(i)]),
1236 port_status_to_str(rh.wPortStatusPrev[map_port(i)]));
1237 }
1238 }
1239 spin_unlock(&crisv10_hcd->lock);
1240 DBFEXIT;
1241 return *buf == 0 ? 0 : 1;
1242 }
1243
1244 /* Handle a control request for the root hub (called from hcd_driver) */
1245 static int rh_control_request(struct usb_hcd *hcd,
1246 u16 typeReq,
1247 u16 wValue,
1248 u16 wIndex,
1249 char *buf,
1250 u16 wLength) {
1251
1252 struct crisv10_hcd *crisv10_hcd = hcd_to_crisv10_hcd(hcd);
1253 int retval = 0;
1254 int len;
1255 DBFENTER;
1256
1257 switch (typeReq) {
1258 case GetHubDescriptor:
1259 rh_dbg("GetHubDescriptor\n");
1260 len = min_t(unsigned int, sizeof rh_hub_descr, wLength);
1261 memcpy(buf, rh_hub_descr, len);
1262 buf[2] = crisv10_hcd->num_ports;
1263 break;
1264 case GetHubStatus:
1265 rh_dbg("GetHubStatus\n");
1266 len = min_t(unsigned int, sizeof rh_hub_status, wLength);
1267 memcpy(buf, &rh_hub_status, len);
1268 break;
1269 case GetPortStatus:
1270 if (!wIndex || wIndex > crisv10_hcd->num_ports)
1271 goto error;
1272 rh_dbg("GetportStatus, port:%d change:%s status:%s\n", wIndex,
1273 port_status_to_str(rh.wPortChange[map_port(wIndex)]),
1274 port_status_to_str(rh.wPortStatusPrev[map_port(wIndex)]));
1275 *(u16 *) buf = cpu_to_le16(rh.wPortStatusPrev[map_port(wIndex)]);
1276 *(u16 *) (buf + 2) = cpu_to_le16(rh.wPortChange[map_port(wIndex)]);
1277 break;
1278 case SetHubFeature:
1279 rh_dbg("SetHubFeature\n");
1280 case ClearHubFeature:
1281 rh_dbg("ClearHubFeature\n");
1282 switch (wValue) {
1283 case C_HUB_OVER_CURRENT:
1284 case C_HUB_LOCAL_POWER:
1285 rh_warn("Not implemented hub request:%d \n", typeReq);
1286 /* not implemented */
1287 break;
1288 default:
1289 goto error;
1290 }
1291 break;
1292 case SetPortFeature:
1293 if (!wIndex || wIndex > crisv10_hcd->num_ports)
1294 goto error;
1295 if(rh_set_port_feature(map_port(wIndex), wValue))
1296 goto error;
1297 break;
1298 case ClearPortFeature:
1299 if (!wIndex || wIndex > crisv10_hcd->num_ports)
1300 goto error;
1301 if(rh_clear_port_feature(map_port(wIndex), wValue))
1302 goto error;
1303 break;
1304 default:
1305 rh_warn("Unknown hub request: %d\n", typeReq);
1306 error:
1307 retval = -EPIPE;
1308 }
1309 DBFEXIT;
1310 return retval;
1311 }
1312
1313 int rh_set_port_feature(__u8 bPort, __u16 wFeature) {
1314 __u8 bUsbCommand = 0;
1315 __u8 reset_cnt;
1316 switch(wFeature) {
1317 case USB_PORT_FEAT_RESET:
1318 rh_dbg("SetPortFeature: reset\n");
1319
1320 if (rh.wPortStatusPrev[bPort] &
1321 IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes))
1322 {
1323 __u8 restart_controller = 0;
1324
1325 if ( (rh.wPortStatusPrev[0] &
1326 IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)) &&
1327 (rh.wPortStatusPrev[1] &
1328 IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, yes)) )
1329 {
1330 /* Both ports is enabled. The USB controller will not change state. */
1331 restart_controller = 0;
1332 }
1333 else
1334 {
1335 /* Only ports is enabled. The USB controller will change state and
1336 must be restarted. */
1337 restart_controller = 1;
1338 }
1339 /*
1340 In ETRAX 100LX it's not possible to reset an enabled root hub port.
1341 The workaround is to disable and enable the port before resetting it.
1342 Disabling the port can, if both ports are disabled at once, cause the
1343 USB controller to change state to HOST_MODE state.
1344 The USB controller state transition causes a lot of unwanted
1345 interrupts that must be avoided.
1346 Disabling the USB controller status and port status interrupts before
1347 disabling/resetting the port stops these interrupts.
1348
1349 These actions are performed:
1350 1. Disable USB controller status and port status interrupts.
1351 2. Disable the port
1352 3. Wait for the port to be disabled.
1353 4. Enable the port.
1354 5. Wait for the port to be enabled.
1355 6. Reset the port.
1356 7. Wait for for the reset to end.
1357 8. Wait for the USB controller entering started state.
1358 9. Order the USB controller to running state.
1359 10. Wait for the USB controller reaching running state.
1360 11. Clear all interrupts generated during the disable/enable/reset
1361 procedure.
1362 12. Enable the USB controller status and port status interrupts.
1363 */
1364
1365 /* 1. Disable USB controller status and USB port status interrupts. */
1366 *R_USB_IRQ_MASK_CLR = IO_STATE(R_USB_IRQ_MASK_CLR, ctl_status, clr);
1367 __asm__ __volatile__ (" nop");
1368 *R_USB_IRQ_MASK_CLR = IO_STATE(R_USB_IRQ_MASK_CLR, port_status, clr);
1369 __asm__ __volatile__ (" nop");
1370
1371 {
1372
1373 /* Since an root hub port reset shall be 50 ms and the ETRAX 100LX
1374 root hub port reset is 10 ms we must perform 5 port resets to
1375 achieve a proper root hub port reset. */
1376 for (reset_cnt = 0; reset_cnt < 5; reset_cnt ++)
1377 {
1378 rh_dbg("Disable Port %d\n", bPort + 1);
1379
1380 /* 2. Disable the port*/
1381 if (bPort == 0)
1382 {
1383 *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
1384 }
1385 else
1386 {
1387 *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, yes);
1388 }
1389
1390 /* 3. Wait for the port to be disabled. */
1391 while ( (bPort == 0) ?
1392 *R_USB_RH_PORT_STATUS_1 &
1393 IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes) :
1394 *R_USB_RH_PORT_STATUS_2 &
1395 IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, yes) ) {}
1396
1397 rh_dbg("Port %d is disabled. Enable it!\n", bPort + 1);
1398
1399 /* 4. Enable the port. */
1400 if (bPort == 0)
1401 {
1402 *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
1403 }
1404 else
1405 {
1406 *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no);
1407 }
1408
1409 /* 5. Wait for the port to be enabled again. */
1410 while (!( (bPort == 0) ?
1411 *R_USB_RH_PORT_STATUS_1 &
1412 IO_STATE(R_USB_RH_PORT_STATUS_1, connected, yes) :
1413 *R_USB_RH_PORT_STATUS_2 &
1414 IO_STATE(R_USB_RH_PORT_STATUS_2, connected, yes) ) ) {}
1415
1416 rh_dbg("Port %d is enabled.\n", bPort + 1);
1417
1418 /* 6. Reset the port */
1419 crisv10_ready_wait();
1420 *R_USB_COMMAND =
1421 ( (bPort == 0) ?
1422 IO_STATE(R_USB_COMMAND, port_sel, port1):
1423 IO_STATE(R_USB_COMMAND, port_sel, port2) ) |
1424 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
1425 IO_STATE(R_USB_COMMAND, busy, no) |
1426 IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
1427 rh_dbg("Port %d is resetting.\n", bPort + 1);
1428
1429 /* 7. The USB specification says that we should wait for at least
1430 10ms for device recover */
1431 udelay(10500); /* 10,5ms blocking wait */
1432
1433 crisv10_ready_wait();
1434 }
1435 }
1436
1437
1438 /* Check if the USB controller needs to be restarted. */
1439 if (restart_controller)
1440 {
1441 /* 8. Wait for the USB controller entering started state. */
1442 while (!(*R_USB_STATUS & IO_STATE(R_USB_STATUS, started, yes))) {}
1443
1444 /* 9. Order the USB controller to running state. */
1445 crisv10_ready_wait();
1446 *R_USB_COMMAND =
1447 IO_STATE(R_USB_COMMAND, port_sel, nop) |
1448 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
1449 IO_STATE(R_USB_COMMAND, busy, no) |
1450 IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
1451
1452 /* 10. Wait for the USB controller reaching running state. */
1453 while (!(*R_USB_STATUS & IO_STATE(R_USB_STATUS, running, yes))) {}
1454 }
1455
1456 /* 11. Clear any controller or port satus interrupts before enabling
1457 the interrupts. */
1458 {
1459 u16 dummy;
1460
1461 /* Clear the port status interrupt of the reset port. */
1462 if (bPort == 0)
1463 {
1464 rh_dbg("Clearing port 1 interrupts\n");
1465 dummy = *R_USB_RH_PORT_STATUS_1;
1466 }
1467 else
1468 {
1469 rh_dbg("Clearing port 2 interrupts\n");
1470 dummy = *R_USB_RH_PORT_STATUS_2;
1471 }
1472
1473 if (restart_controller)
1474 {
1475 /* The USB controller is restarted. Clear all interupts. */
1476 rh_dbg("Clearing all interrupts\n");
1477 dummy = *R_USB_STATUS;
1478 dummy = *R_USB_RH_PORT_STATUS_1;
1479 dummy = *R_USB_RH_PORT_STATUS_2;
1480 }
1481 }
1482
1483 /* 12. Enable USB controller status and USB port status interrupts. */
1484 *R_USB_IRQ_MASK_SET = IO_STATE(R_USB_IRQ_MASK_SET, ctl_status, set);
1485 __asm__ __volatile__ (" nop");
1486 *R_USB_IRQ_MASK_SET = IO_STATE(R_USB_IRQ_MASK_SET, port_status, set);
1487 __asm__ __volatile__ (" nop");
1488
1489 }
1490 else
1491 {
1492
1493 bUsbCommand |= IO_STATE(R_USB_COMMAND, port_cmd, reset);
1494 /* Select which port via the port_sel field */
1495 bUsbCommand |= IO_FIELD(R_USB_COMMAND, port_sel, bPort+1);
1496
1497 /* Make sure the controller isn't busy. */
1498 crisv10_ready_wait();
1499 /* Send out the actual command to the USB controller */
1500 *R_USB_COMMAND = bUsbCommand;
1501
1502 /* Wait a while for controller to first become started after port reset */
1503 udelay(12000); /* 12ms blocking wait */
1504
1505 /* Make sure the controller isn't busy. */
1506 crisv10_ready_wait();
1507
1508 /* If all enabled ports were disabled the host controller goes down into
1509 started mode, so we need to bring it back into the running state.
1510 (This is safe even if it's already in the running state.) */
1511 *R_USB_COMMAND =
1512 IO_STATE(R_USB_COMMAND, port_sel, nop) |
1513 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
1514 IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
1515 }
1516
1517 break;
1518 case USB_PORT_FEAT_SUSPEND:
1519 rh_dbg("SetPortFeature: suspend\n");
1520 bUsbCommand |= IO_STATE(R_USB_COMMAND, port_cmd, suspend);
1521 goto set;
1522 break;
1523 case USB_PORT_FEAT_POWER:
1524 rh_dbg("SetPortFeature: power\n");
1525 break;
1526 case USB_PORT_FEAT_C_CONNECTION:
1527 rh_dbg("SetPortFeature: c_connection\n");
1528 break;
1529 case USB_PORT_FEAT_C_RESET:
1530 rh_dbg("SetPortFeature: c_reset\n");
1531 break;
1532 case USB_PORT_FEAT_C_OVER_CURRENT:
1533 rh_dbg("SetPortFeature: c_over_current\n");
1534 break;
1535
1536 set:
1537 /* Select which port via the port_sel field */
1538 bUsbCommand |= IO_FIELD(R_USB_COMMAND, port_sel, bPort+1);
1539
1540 /* Make sure the controller isn't busy. */
1541 crisv10_ready_wait();
1542 /* Send out the actual command to the USB controller */
1543 *R_USB_COMMAND = bUsbCommand;
1544 break;
1545 default:
1546 rh_dbg("SetPortFeature: unknown feature\n");
1547 return -1;
1548 }
1549 return 0;
1550 }
1551
1552 int rh_clear_port_feature(__u8 bPort, __u16 wFeature) {
1553 switch(wFeature) {
1554 case USB_PORT_FEAT_ENABLE:
1555 rh_dbg("ClearPortFeature: enable\n");
1556 rh_disable_port(bPort);
1557 break;
1558 case USB_PORT_FEAT_SUSPEND:
1559 rh_dbg("ClearPortFeature: suspend\n");
1560 break;
1561 case USB_PORT_FEAT_POWER:
1562 rh_dbg("ClearPortFeature: power\n");
1563 break;
1564
1565 case USB_PORT_FEAT_C_ENABLE:
1566 rh_dbg("ClearPortFeature: c_enable\n");
1567 goto clear;
1568 case USB_PORT_FEAT_C_SUSPEND:
1569 rh_dbg("ClearPortFeature: c_suspend\n");
1570 goto clear;
1571 case USB_PORT_FEAT_C_CONNECTION:
1572 rh_dbg("ClearPortFeature: c_connection\n");
1573 goto clear;
1574 case USB_PORT_FEAT_C_OVER_CURRENT:
1575 rh_dbg("ClearPortFeature: c_over_current\n");
1576 goto clear;
1577 case USB_PORT_FEAT_C_RESET:
1578 rh_dbg("ClearPortFeature: c_reset\n");
1579 goto clear;
1580 clear:
1581 rh.wPortChange[bPort] &= ~(1 << (wFeature - 16));
1582 break;
1583 default:
1584 rh_dbg("ClearPortFeature: unknown feature\n");
1585 return -1;
1586 }
1587 return 0;
1588 }
1589
1590
1591 #ifdef CONFIG_PM
1592 /* Handle a suspend request for the root hub (called from hcd_driver) */
1593 static int rh_suspend_request(struct usb_hcd *hcd)
1594 {
1595 return 0; /* no-op for now */
1596 }
1597
1598 /* Handle a resume request for the root hub (called from hcd_driver) */
1599 static int rh_resume_request(struct usb_hcd *hcd)
1600 {
1601 return 0; /* no-op for now */
1602 }
1603 #endif /* CONFIG_PM */
1604
1605
1606
1607 /* Wrapper function for workaround port disable registers in USB controller */
1608 static void rh_disable_port(unsigned int port) {
1609 volatile int timeout = 10000;
1610 volatile char* usb_portx_disable;
1611 switch(port) {
1612 case 0:
1613 usb_portx_disable = R_USB_PORT1_DISABLE;
1614 break;
1615 case 1:
1616 usb_portx_disable = R_USB_PORT2_DISABLE;
1617 break;
1618 default:
1619 /* Invalid port index */
1620 return;
1621 }
1622 /* Set disable flag in special register */
1623 *usb_portx_disable = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
1624 /* Wait until not enabled anymore */
1625 while((rh.wPortStatusPrev[port] &
1626 IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)) &&
1627 (timeout-- > 0));
1628
1629 /* clear disable flag in special register */
1630 *usb_portx_disable = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
1631 rh_info("Physical port %d disabled\n", port+1);
1632 }
1633
1634
1635 /******************************************************************/
1636 /* Transfer Controller (TC) functions */
1637 /******************************************************************/
1638
1639 /* FIXME: Should RX_BUF_SIZE be a config option, or maybe we should adjust it
1640 dynamically?
1641 To adjust it dynamically we would have to get an interrupt when we reach
1642 the end of the rx descriptor list, or when we get close to the end, and
1643 then allocate more descriptors. */
1644 #define NBR_OF_RX_DESC 512
1645 #define RX_DESC_BUF_SIZE 1024
1646 #define RX_BUF_SIZE (NBR_OF_RX_DESC * RX_DESC_BUF_SIZE)
1647
1648
1649 /* Local variables for Transfer Controller */
1650 /* --------------------------------------- */
1651
1652 /* This is a circular (double-linked) list of the active urbs for each epid.
1653 The head is never removed, and new urbs are linked onto the list as
1654 urb_entry_t elements. Don't reference urb_list directly; use the wrapper
1655 functions instead (which includes spin_locks) */
1656 static struct list_head urb_list[NBR_OF_EPIDS];
1657
1658 /* Read about the need and usage of this lock in submit_ctrl_urb. */
1659 /* Lock for URB lists for each EPID */
1660 static spinlock_t urb_list_lock;
1661
1662 /* Lock for EPID array register (R_USB_EPT_x) in Etrax */
1663 static spinlock_t etrax_epid_lock;
1664
1665 /* Lock for dma8 sub0 handling */
1666 static spinlock_t etrax_dma8_sub0_lock;
1667
1668 /* DMA IN cache bug. Align the DMA IN buffers to 32 bytes, i.e. a cache line.
1669 Since RX_DESC_BUF_SIZE is 1024 is a multiple of 32, all rx buffers will be
1670 cache aligned. */
1671 static volatile unsigned char RxBuf[RX_BUF_SIZE] __attribute__ ((aligned (32)));
1672 static volatile struct USB_IN_Desc RxDescList[NBR_OF_RX_DESC] __attribute__ ((aligned (4)));
1673
1674 /* Pointers into RxDescList. */
1675 static volatile struct USB_IN_Desc *myNextRxDesc;
1676 static volatile struct USB_IN_Desc *myLastRxDesc;
1677
1678 /* A zout transfer makes a memory access at the address of its buf pointer,
1679 which means that setting this buf pointer to 0 will cause an access to the
1680 flash. In addition to this, setting sw_len to 0 results in a 16/32 bytes
1681 (depending on DMA burst size) transfer.
1682 Instead, we set it to 1, and point it to this buffer. */
1683 static int zout_buffer[4] __attribute__ ((aligned (4)));
1684
1685 /* Cache for allocating new EP and SB descriptors. */
1686 static struct kmem_cache *usb_desc_cache;
1687
1688 /* Cache for the data allocated in the isoc descr top half. */
1689 static struct kmem_cache *isoc_compl_cache;
1690
1691 /* Cache for the data allocated when delayed finishing of URBs */
1692 static struct kmem_cache *later_data_cache;
1693
1694
1695 /* Counter to keep track of how many Isoc EP we have sat up. Used to enable
1696 and disable iso_eof interrupt. We only need these interrupts when we have
1697 Isoc data endpoints (consumes CPU cycles).
1698 FIXME: This could be more fine granular, so this interrupt is only enabled
1699 when we have a In Isoc URB not URB_ISO_ASAP flaged queued. */
1700 static int isoc_epid_counter;
1701
1702 /* Protecting wrapper functions for R_USB_EPT_x */
1703 /* -------------------------------------------- */
1704 static inline void etrax_epid_set(__u8 index, __u32 data) {
1705 unsigned long flags;
1706 spin_lock_irqsave(&etrax_epid_lock, flags);
1707 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
1708 nop();
1709 *R_USB_EPT_DATA = data;
1710 spin_unlock_irqrestore(&etrax_epid_lock, flags);
1711 }
1712
1713 static inline void etrax_epid_clear_error(__u8 index) {
1714 unsigned long flags;
1715 spin_lock_irqsave(&etrax_epid_lock, flags);
1716 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
1717 nop();
1718 *R_USB_EPT_DATA &=
1719 ~(IO_MASK(R_USB_EPT_DATA, error_count_in) |
1720 IO_MASK(R_USB_EPT_DATA, error_count_out) |
1721 IO_MASK(R_USB_EPT_DATA, error_code));
1722 spin_unlock_irqrestore(&etrax_epid_lock, flags);
1723 }
1724
1725 static inline void etrax_epid_set_toggle(__u8 index, __u8 dirout,
1726 __u8 toggle) {
1727 unsigned long flags;
1728 spin_lock_irqsave(&etrax_epid_lock, flags);
1729 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
1730 nop();
1731 if(dirout) {
1732 *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_out);
1733 *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_out, toggle);
1734 } else {
1735 *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_in);
1736 *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_in, toggle);
1737 }
1738 spin_unlock_irqrestore(&etrax_epid_lock, flags);
1739 }
1740
1741 static inline __u8 etrax_epid_get_toggle(__u8 index, __u8 dirout) {
1742 unsigned long flags;
1743 __u8 toggle;
1744 spin_lock_irqsave(&etrax_epid_lock, flags);
1745 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
1746 nop();
1747 if (dirout) {
1748 toggle = IO_EXTRACT(R_USB_EPT_DATA, t_out, *R_USB_EPT_DATA);
1749 } else {
1750 toggle = IO_EXTRACT(R_USB_EPT_DATA, t_in, *R_USB_EPT_DATA);
1751 }
1752 spin_unlock_irqrestore(&etrax_epid_lock, flags);
1753 return toggle;
1754 }
1755
1756
1757 static inline __u32 etrax_epid_get(__u8 index) {
1758 unsigned long flags;
1759 __u32 data;
1760 spin_lock_irqsave(&etrax_epid_lock, flags);
1761 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
1762 nop();
1763 data = *R_USB_EPT_DATA;
1764 spin_unlock_irqrestore(&etrax_epid_lock, flags);
1765 return data;
1766 }
1767
1768
1769
1770
1771 /* Main functions for Transfer Controller */
1772 /* -------------------------------------- */
1773
1774 /* Init structs, memories and lists used by Transfer Controller */
1775 int tc_init(struct usb_hcd *hcd) {
1776 int i;
1777 /* Clear software state info for all epids */
1778 memset(epid_state, 0, sizeof(struct etrax_epid) * NBR_OF_EPIDS);
1779
1780 /* Set Invalid and Dummy as being in use and disabled */
1781 epid_state[INVALID_EPID].inuse = 1;
1782 epid_state[DUMMY_EPID].inuse = 1;
1783 epid_state[INVALID_EPID].disabled = 1;
1784 epid_state[DUMMY_EPID].disabled = 1;
1785
1786 /* Clear counter for how many Isoc epids we have sat up */
1787 isoc_epid_counter = 0;
1788
1789 /* Initialize the urb list by initiating a head for each list.
1790 Also reset list hodling active URB for each epid */
1791 for (i = 0; i < NBR_OF_EPIDS; i++) {
1792 INIT_LIST_HEAD(&urb_list[i]);
1793 activeUrbList[i] = NULL;
1794 }
1795
1796 /* Init lock for URB lists */
1797 spin_lock_init(&urb_list_lock);
1798 /* Init lock for Etrax R_USB_EPT register */
1799 spin_lock_init(&etrax_epid_lock);
1800 /* Init lock for Etrax dma8 sub0 handling */
1801 spin_lock_init(&etrax_dma8_sub0_lock);
1802
1803 /* We use kmem_cache_* to make sure that all DMA desc. are dword aligned */
1804
1805 /* Note that we specify sizeof(struct USB_EP_Desc) as the size, but also
1806 allocate SB descriptors from this cache. This is ok since
1807 sizeof(struct USB_EP_Desc) == sizeof(struct USB_SB_Desc). */
1808 usb_desc_cache = kmem_cache_create("usb_desc_cache",
1809 sizeof(struct USB_EP_Desc), 0,
1810 SLAB_HWCACHE_ALIGN, 0);
1811 if(usb_desc_cache == NULL) {
1812 return -ENOMEM;
1813 }
1814
1815 /* Create slab cache for speedy allocation of memory for isoc bottom-half
1816 interrupt handling */
1817 isoc_compl_cache =
1818 kmem_cache_create("isoc_compl_cache",
1819 sizeof(struct crisv10_isoc_complete_data),
1820 0, SLAB_HWCACHE_ALIGN, 0);
1821 if(isoc_compl_cache == NULL) {
1822 return -ENOMEM;
1823 }
1824
1825 /* Create slab cache for speedy allocation of memory for later URB finish
1826 struct */
1827 later_data_cache =
1828 kmem_cache_create("later_data_cache",
1829 sizeof(struct urb_later_data),
1830 0, SLAB_HWCACHE_ALIGN, 0);
1831 if(later_data_cache == NULL) {
1832 return -ENOMEM;
1833 }
1834
1835
1836 /* Initiate the bulk start timer. */
1837 init_timer(&bulk_start_timer);
1838 bulk_start_timer.expires = jiffies + BULK_START_TIMER_INTERVAL;
1839 bulk_start_timer.function = tc_bulk_start_timer_func;
1840 add_timer(&bulk_start_timer);
1841
1842
1843 /* Initiate the bulk eot timer. */
1844 init_timer(&bulk_eot_timer);
1845 bulk_eot_timer.expires = jiffies + BULK_EOT_TIMER_INTERVAL;
1846 bulk_eot_timer.function = tc_bulk_eot_timer_func;
1847 bulk_eot_timer.data = (unsigned long)hcd;
1848 add_timer(&bulk_eot_timer);
1849
1850 return 0;
1851 }
1852
1853 /* Uninitialize all resources used by Transfer Controller */
1854 void tc_destroy(void) {
1855
1856 /* Destroy all slab cache */
1857 kmem_cache_destroy(usb_desc_cache);
1858 kmem_cache_destroy(isoc_compl_cache);
1859 kmem_cache_destroy(later_data_cache);
1860
1861 /* Remove timers */
1862 del_timer(&bulk_start_timer);
1863 del_timer(&bulk_eot_timer);
1864 }
1865
1866 static void restart_dma8_sub0(void) {
1867 unsigned long flags;
1868 spin_lock_irqsave(&etrax_dma8_sub0_lock, flags);
1869 /* Verify that the dma is not running */
1870 if ((*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd)) == 0) {
1871 struct USB_EP_Desc *ep = (struct USB_EP_Desc *)phys_to_virt(*R_DMA_CH8_SUB0_EP);
1872 while (DUMMY_EPID == IO_EXTRACT(USB_EP_command, epid, ep->command)) {
1873 ep = (struct USB_EP_Desc *)phys_to_virt(ep->next);
1874 }
1875 /* Advance the DMA to the next EP descriptor that is not a DUMMY_EPID. */
1876 *R_DMA_CH8_SUB0_EP = virt_to_phys(ep);
1877 /* Restart the DMA */
1878 *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start);
1879 }
1880 spin_unlock_irqrestore(&etrax_dma8_sub0_lock, flags);
1881 }
1882
1883 /* queue an URB with the transfer controller (called from hcd_driver) */
1884 static int tc_urb_enqueue(struct usb_hcd *hcd,
1885 struct urb *urb,
1886 gfp_t mem_flags) {
1887 int epid;
1888 int retval;
1889 int bustime = 0;
1890 int maxpacket;
1891 unsigned long flags;
1892 struct crisv10_urb_priv *urb_priv;
1893 struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
1894 DBFENTER;
1895
1896 if(!(crisv10_hcd->running)) {
1897 /* The USB Controller is not running, probably because no device is
1898 attached. No idea to enqueue URBs then */
1899 tc_warn("Rejected enqueueing of URB:0x%x because no dev attached\n",
1900 (unsigned int)urb);
1901 return -ENOENT;
1902 }
1903
1904 maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
1905 /* Special case check for In Isoc transfers. Specification states that each
1906 In Isoc transfer consists of one packet and therefore it should fit into
1907 the transfer-buffer of an URB.
1908 We do the check here to be sure (an invalid scenario can be produced with
1909 parameters to the usbtest suite) */
1910 if(usb_pipeisoc(urb->pipe) && usb_pipein(urb->pipe) &&
1911 (urb->transfer_buffer_length < maxpacket)) {
1912 tc_err("Submit In Isoc URB with buffer length:%d to pipe with maxpacketlen: %d\n", urb->transfer_buffer_length, maxpacket);
1913 return -EMSGSIZE;
1914 }
1915
1916 /* Check if there is a epid for URBs destination, if not this function
1917 set up one. */
1918 epid = tc_setup_epid(urb->ep, urb, mem_flags);
1919 if (epid < 0) {
1920 tc_err("Failed setup epid:%d for URB:0x%x\n", epid, (unsigned int)urb);
1921 DBFEXIT;
1922 return -ENOMEM;
1923 }
1924
1925 if(urb == activeUrbList[epid]) {
1926 tc_err("Resubmition of allready active URB:0x%x\n", (unsigned int)urb);
1927 return -ENXIO;
1928 }
1929
1930 if(urb_list_entry(urb, epid)) {
1931 tc_err("Resubmition of allready queued URB:0x%x\n", (unsigned int)urb);
1932 return -ENXIO;
1933 }
1934
1935 /* If we actively have flaged endpoint as disabled then refuse submition */
1936 if(epid_state[epid].disabled) {
1937 return -ENOENT;
1938 }
1939
1940 /* Allocate and init HC-private data for URB */
1941 if(urb_priv_create(hcd, urb, epid, mem_flags) != 0) {
1942 DBFEXIT;
1943 return -ENOMEM;
1944 }
1945 urb_priv = urb->hcpriv;
1946
1947 /* Check if there is enough bandwidth for periodic transfer */
1948 if(usb_pipeint(urb->pipe) || usb_pipeisoc(urb->pipe)) {
1949 /* only check (and later claim) if not already claimed */
1950 if (urb_priv->bandwidth == 0) {
1951 bustime = crisv10_usb_check_bandwidth(urb->dev, urb);
1952 if (bustime < 0) {
1953 tc_err("Not enough periodic bandwidth\n");
1954 urb_priv_free(hcd, urb);
1955 DBFEXIT;
1956 return -ENOSPC;
1957 }
1958 }
1959 }
1960
1961 tc_dbg("Enqueue URB:0x%x[%d] epid:%d (%s) bufflen:%d\n",
1962 (unsigned int)urb, urb_priv->urb_num, epid,
1963 pipe_to_str(urb->pipe), urb->transfer_buffer_length);
1964
1965 /* Create and link SBs required for this URB */
1966 retval = create_sb_for_urb(urb, mem_flags);
1967 if(retval != 0) {
1968 tc_err("Failed to create SBs for URB:0x%x[%d]\n", (unsigned int)urb,
1969 urb_priv->urb_num);
1970 urb_priv_free(hcd, urb);
1971 DBFEXIT;
1972 return retval;
1973 }
1974
1975 /* Init intr EP pool if this URB is a INTR transfer. This pool is later
1976 used when inserting EPs in the TxIntrEPList. We do the alloc here
1977 so we can't run out of memory later */
1978 if(usb_pipeint(urb->pipe)) {
1979 retval = init_intr_urb(urb, mem_flags);
1980 if(retval != 0) {
1981 tc_warn("Failed to init Intr URB\n");
1982 urb_priv_free(hcd, urb);
1983 DBFEXIT;
1984 return retval;
1985 }
1986 }
1987
1988 /* Disable other access when inserting USB */
1989 local_irq_save(flags);
1990
1991 /* Claim bandwidth, if needed */
1992 if(bustime) {
1993 crisv10_usb_claim_bandwidth(urb->dev,
1994 urb,
1995 bustime,
1996 (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS));
1997 }
1998
1999 /* Add URB to EP queue */
2000 urb_list_add(urb, epid, mem_flags);
2001
2002 if(usb_pipeisoc(urb->pipe)) {
2003 /* Special processing of Isoc URBs. */
2004 tc_dma_process_isoc_urb(urb);
2005 } else {
2006 /* Process EP queue for rest of the URB types (Bulk, Ctrl, Intr) */
2007 tc_dma_process_queue(epid);
2008 }
2009
2010 local_irq_restore(flags);
2011
2012 DBFEXIT;
2013 return 0;
2014 }
2015
2016 /* remove an URB from the transfer controller queues (called from hcd_driver)*/
2017 static int tc_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) {
2018 struct crisv10_urb_priv *urb_priv;
2019 unsigned long flags;
2020 int epid;
2021
2022 DBFENTER;
2023 /* Disable interrupts here since a descriptor interrupt for the isoc epid
2024 will modify the sb list. This could possibly be done more granular, but
2025 urb_dequeue should not be used frequently anyway.
2026 */
2027 local_irq_save(flags);
2028
2029 urb->status = status;
2030 urb_priv = urb->hcpriv;
2031
2032 if (!urb_priv) {
2033 /* This happens if a device driver calls unlink on an urb that
2034 was never submitted (lazy driver) or if the urb was completed
2035 while dequeue was being called. */
2036 tc_warn("Dequeing of not enqueued URB:0x%x\n", (unsigned int)urb);
2037 local_irq_restore(flags);
2038 return 0;
2039 }
2040 epid = urb_priv->epid;
2041
2042 tc_warn("Dequeing %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
2043 (urb == activeUrbList[epid]) ? "active" : "queued",
2044 (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
2045 str_type(urb->pipe), epid, urb->status,
2046 (urb_priv->later_data) ? "later-sched" : "");
2047
2048 /* For Bulk, Ctrl and Intr are only one URB active at a time. So any URB
2049 that isn't active can be dequeued by just removing it from the queue */
2050 if(usb_pipebulk(urb->pipe) || usb_pipecontrol(urb->pipe) ||
2051 usb_pipeint(urb->pipe)) {
2052
2053 /* Check if URB haven't gone further than the queue */
2054 if(urb != activeUrbList[epid]) {
2055 ASSERT(urb_priv->later_data == NULL);
2056 tc_warn("Dequeing URB:0x%x[%d] (%s %s epid:%d) from queue"
2057 " (not active)\n", (unsigned int)urb, urb_priv->urb_num,
2058 str_dir(urb->pipe), str_type(urb->pipe), epid);
2059
2060 /* Finish the URB with error status from USB core */
2061 tc_finish_urb(hcd, urb, urb->status);
2062 local_irq_restore(flags);
2063 return 0;
2064 }
2065 }
2066
2067 /* Set URB status to Unlink for handling when interrupt comes. */
2068 urb_priv->urb_state = UNLINK;
2069
2070 /* Differentiate dequeing of Bulk and Ctrl from Isoc and Intr */
2071 switch(usb_pipetype(urb->pipe)) {
2072 case PIPE_BULK:
2073 /* Check if EP still is enabled */
2074 if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2075 /* The EP was enabled, disable it. */
2076 TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2077 }
2078 /* Kicking dummy list out of the party. */
2079 TxBulkEPList[epid].next = virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
2080 break;
2081 case PIPE_CONTROL:
2082 /* Check if EP still is enabled */
2083 if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2084 /* The EP was enabled, disable it. */
2085 TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2086 }
2087 break;
2088 case PIPE_ISOCHRONOUS:
2089 /* Disabling, busy-wait and unlinking of Isoc SBs will be done in
2090 finish_isoc_urb(). Because there might the case when URB is dequeued
2091 but there are other valid URBs waiting */
2092
2093 /* Check if In Isoc EP still is enabled */
2094 if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2095 /* The EP was enabled, disable it. */
2096 TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2097 }
2098 break;
2099 case PIPE_INTERRUPT:
2100 /* Special care is taken for interrupt URBs. EPs are unlinked in
2101 tc_finish_urb */
2102 break;
2103 default:
2104 break;
2105 }
2106
2107 /* Asynchronous unlink, finish the URB later from scheduled or other
2108 event (data finished, error) */
2109 tc_finish_urb_later(hcd, urb, urb->status);
2110
2111 local_irq_restore(flags);
2112 DBFEXIT;
2113 return 0;
2114 }
2115
2116
2117 static void tc_sync_finish_epid(struct usb_hcd *hcd, int epid) {
2118 volatile int timeout = 10000;
2119 struct urb* urb;
2120 struct crisv10_urb_priv* urb_priv;
2121 unsigned long flags;
2122
2123 volatile struct USB_EP_Desc *first_ep; /* First EP in the list. */
2124 volatile struct USB_EP_Desc *curr_ep; /* Current EP, the iterator. */
2125 volatile struct USB_EP_Desc *next_ep; /* The EP after current. */
2126
2127 int type = epid_state[epid].type;
2128
2129 /* Setting this flag will cause enqueue() to return -ENOENT for new
2130 submitions on this endpoint and finish_urb() wont process queue further */
2131 epid_state[epid].disabled = 1;
2132
2133 switch(type) {
2134 case PIPE_BULK:
2135 /* Check if EP still is enabled */
2136 if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2137 /* The EP was enabled, disable it. */
2138 TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2139 tc_warn("sync_finish: Disabling EP for epid:%d\n", epid);
2140
2141 /* Do busy-wait until DMA not using this EP descriptor anymore */
2142 while((*R_DMA_CH8_SUB0_EP ==
2143 virt_to_phys(&TxBulkEPList[epid])) &&
2144 (timeout-- > 0));
2145
2146 }
2147 break;
2148
2149 case PIPE_CONTROL:
2150 /* Check if EP still is enabled */
2151 if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2152 /* The EP was enabled, disable it. */
2153 TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2154 tc_warn("sync_finish: Disabling EP for epid:%d\n", epid);
2155
2156 /* Do busy-wait until DMA not using this EP descriptor anymore */
2157 while((*R_DMA_CH8_SUB1_EP ==
2158 virt_to_phys(&TxCtrlEPList[epid])) &&
2159 (timeout-- > 0));
2160 }
2161 break;
2162
2163 case PIPE_INTERRUPT:
2164 local_irq_save(flags);
2165 /* Disable all Intr EPs belonging to epid */
2166 first_ep = &TxIntrEPList[0];
2167 curr_ep = first_ep;
2168 do {
2169 next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
2170 if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
2171 /* Disable EP */
2172 next_ep->command &= ~IO_MASK(USB_EP_command, enable);
2173 }
2174 curr_ep = phys_to_virt(curr_ep->next);
2175 } while (curr_ep != first_ep);
2176
2177 local_irq_restore(flags);
2178 break;
2179
2180 case PIPE_ISOCHRONOUS:
2181 /* Check if EP still is enabled */
2182 if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2183 tc_warn("sync_finish: Disabling Isoc EP for epid:%d\n", epid);
2184 /* The EP was enabled, disable it. */
2185 TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2186
2187 while((*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid])) &&
2188 (timeout-- > 0));
2189 }
2190 break;
2191 }
2192
2193 local_irq_save(flags);
2194
2195 /* Finish if there is active URB for this endpoint */
2196 if(activeUrbList[epid] != NULL) {
2197 urb = activeUrbList[epid];
2198 urb_priv = urb->hcpriv;
2199 ASSERT(urb_priv);
2200 tc_warn("Sync finish %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
2201 (urb == activeUrbList[epid]) ? "active" : "queued",
2202 (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
2203 str_type(urb->pipe), epid, urb->status,
2204 (urb_priv->later_data) ? "later-sched" : "");
2205
2206 tc_finish_urb(hcd, activeUrbList[epid], -ENOENT);
2207 ASSERT(activeUrbList[epid] == NULL);
2208 }
2209
2210 /* Finish any queued URBs for this endpoint. There won't be any resubmitions
2211 because epid_disabled causes enqueue() to fail for this endpoint */
2212 while((urb = urb_list_first(epid)) != NULL) {
2213 urb_priv = urb->hcpriv;
2214 ASSERT(urb_priv);
2215
2216 tc_warn("Sync finish %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
2217 (urb == activeUrbList[epid]) ? "active" : "queued",
2218 (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
2219 str_type(urb->pipe), epid, urb->status,
2220 (urb_priv->later_data) ? "later-sched" : "");
2221
2222 tc_finish_urb(hcd, urb, -ENOENT);
2223 }
2224 epid_state[epid].disabled = 0;
2225 local_irq_restore(flags);
2226 }
2227
2228 /* free resources associated with an endpoint (called from hcd_driver) */
2229 static void tc_endpoint_disable(struct usb_hcd *hcd,
2230 struct usb_host_endpoint *ep) {
2231 DBFENTER;
2232 /* Only free epid if it has been allocated. We get two endpoint_disable
2233 requests for ctrl endpoints so ignore the second one */
2234 if(ep->hcpriv != NULL) {
2235 struct crisv10_ep_priv *ep_priv = ep->hcpriv;
2236 int epid = ep_priv->epid;
2237 tc_warn("endpoint_disable ep:0x%x ep-priv:0x%x (%s) (epid:%d freed)\n",
2238 (unsigned int)ep, (unsigned int)ep->hcpriv,
2239 endpoint_to_str(&(ep->desc)), epid);
2240
2241 tc_sync_finish_epid(hcd, epid);
2242
2243 ASSERT(activeUrbList[epid] == NULL);
2244 ASSERT(list_empty(&urb_list[epid]));
2245
2246 tc_free_epid(ep);
2247 } else {
2248 tc_dbg("endpoint_disable ep:0x%x ep-priv:0x%x (%s)\n", (unsigned int)ep,
2249 (unsigned int)ep->hcpriv, endpoint_to_str(&(ep->desc)));
2250 }
2251 DBFEXIT;
2252 }
2253
2254 static void tc_finish_urb_later_proc(struct work_struct* work) {
2255 unsigned long flags;
2256 struct urb_later_data* uld;
2257
2258 local_irq_save(flags);
2259 uld = container_of(work, struct urb_later_data, dws.work);
2260 if(uld->urb == NULL) {
2261 late_dbg("Later finish of URB = NULL (allready finished)\n");
2262 } else {
2263 struct crisv10_urb_priv* urb_priv = uld->urb->hcpriv;
2264 ASSERT(urb_priv);
2265 if(urb_priv->urb_num == uld->urb_num) {
2266 late_dbg("Later finish of URB:0x%x[%d]\n", (unsigned int)(uld->urb),
2267 urb_priv->urb_num);
2268 if(uld->status != uld->urb->status) {
2269 errno_dbg("Later-finish URB with status:%d, later-status:%d\n",
2270 uld->urb->status, uld->status);
2271 }
2272 if(uld != urb_priv->later_data) {
2273 panic("Scheduled uld not same as URBs uld\n");
2274 }
2275 tc_finish_urb(uld->hcd, uld->urb, uld->status);
2276 } else {
2277 late_warn("Ignoring later finish of URB:0x%x[%d]"
2278 ", urb_num doesn't match current URB:0x%x[%d]",
2279 (unsigned int)(uld->urb), uld->urb_num,
2280 (unsigned int)(uld->urb), urb_priv->urb_num);
2281 }
2282 }
2283 local_irq_restore(flags);
2284 kmem_cache_free(later_data_cache, uld);
2285 }
2286
2287 static void tc_finish_urb_later(struct usb_hcd *hcd, struct urb *urb,
2288 int status) {
2289 struct crisv10_urb_priv *urb_priv = urb->hcpriv;
2290 struct urb_later_data* uld;
2291
2292 ASSERT(urb_priv);
2293
2294 if(urb_priv->later_data != NULL) {
2295 /* Later-finish allready scheduled for this URB, just update status to
2296 return when finishing later */
2297 errno_dbg("Later-finish schedule change URB status:%d with new"
2298 " status:%d\n", urb_priv->later_data->status, status);
2299
2300 urb_priv->later_data->status = status;
2301 return;
2302 }
2303
2304 uld = kmem_cache_alloc(later_data_cache, GFP_ATOMIC);
2305 ASSERT(uld);
2306
2307 uld->hcd = hcd;
2308 uld->urb = urb;
2309 uld->urb_num = urb_priv->urb_num;
2310 uld->status = status;
2311
2312 INIT_DELAYED_WORK(&uld->dws, tc_finish_urb_later_proc);
2313 urb_priv->later_data = uld;
2314
2315 /* Schedule the finishing of the URB to happen later */
2316 schedule_delayed_work(&uld->dws, LATER_TIMER_DELAY);
2317 }
2318
2319 static void tc_finish_isoc_urb(struct usb_hcd *hcd, struct urb *urb,
2320 int status);
2321
2322 static void tc_finish_urb(struct usb_hcd *hcd, struct urb *urb, int status) {
2323 struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
2324 struct crisv10_urb_priv *urb_priv = urb->hcpriv;
2325 int epid;
2326 char toggle;
2327 int urb_num;
2328
2329 DBFENTER;
2330 ASSERT(urb_priv != NULL);
2331 epid = urb_priv->epid;
2332 urb_num = urb_priv->urb_num;
2333
2334 if(urb != activeUrbList[epid]) {
2335 if(urb_list_entry(urb, epid)) {
2336 /* Remove this URB from the list. Only happens when URB are finished
2337 before having been processed (dequeing) */
2338 urb_list_del(urb, epid);
2339 } else {
2340 tc_warn("Finishing of URB:0x%x[%d] neither active or in queue for"
2341 " epid:%d\n", (unsigned int)urb, urb_num, epid);
2342 }
2343 }
2344
2345 /* Cancel any pending later-finish of this URB */
2346 if(urb_priv->later_data) {
2347 urb_priv->later_data->urb = NULL;
2348 }
2349
2350 /* For an IN pipe, we always set the actual length, regardless of whether
2351 there was an error or not (which means the device driver can use the data
2352 if it wants to). */
2353 if(usb_pipein(urb->pipe)) {
2354 urb->actual_length = urb_priv->rx_offset;
2355 } else {
2356 /* Set actual_length for OUT urbs also; the USB mass storage driver seems
2357 to want that. */
2358 if (status == 0 && urb->status == -EINPROGRESS) {
2359 urb->actual_length = urb->transfer_buffer_length;
2360 } else {
2361 /* We wouldn't know of any partial writes if there was an error. */
2362 urb->actual_length = 0;
2363 }
2364 }
2365
2366
2367 /* URB status mangling */
2368 if(urb->status == -EINPROGRESS) {
2369 /* The USB core hasn't changed the status, let's set our finish status */
2370 urb->status = status;
2371
2372 if ((status == 0) && (urb->transfer_flags & URB_SHORT_NOT_OK) &&
2373 usb_pipein(urb->pipe) &&
2374 (urb->actual_length != urb->transfer_buffer_length)) {
2375 /* URB_SHORT_NOT_OK means that short reads (shorter than the endpoint's
2376 max length) is to be treated as an error. */
2377 errno_dbg("Finishing URB:0x%x[%d] with SHORT_NOT_OK flag and short"
2378 " data:%d\n", (unsigned int)urb, urb_num,
2379 urb->actual_length);
2380 urb->status = -EREMOTEIO;
2381 }
2382
2383 if(urb_priv->urb_state == UNLINK) {
2384 /* URB has been requested to be unlinked asynchronously */
2385 urb->status = -ECONNRESET;
2386 errno_dbg("Fixing unlink status of URB:0x%x[%d] to:%d\n",
2387 (unsigned int)urb, urb_num, urb->status);
2388 }
2389 } else {
2390 /* The USB Core wants to signal some error via the URB, pass it through */
2391 }
2392
2393 /* use completely different finish function for Isoc URBs */
2394 if(usb_pipeisoc(urb->pipe)) {
2395 tc_finish_isoc_urb(hcd, urb, status);
2396 return;
2397 }
2398
2399 /* Do special unlinking of EPs for Intr traffic */
2400 if(usb_pipeint(urb->pipe)) {
2401 tc_dma_unlink_intr_urb(urb);
2402 }
2403
2404 /* Release allocated bandwidth for periodic transfers */
2405 if(usb_pipeint(urb->pipe) || usb_pipeisoc(urb->pipe))
2406 crisv10_usb_release_bandwidth(hcd,
2407 usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS,
2408 urb_priv->bandwidth);
2409
2410 /* This URB is active on EP */
2411 if(urb == activeUrbList[epid]) {
2412 /* We need to fiddle with the toggle bits because the hardware doesn't do
2413 it for us. */
2414 toggle = etrax_epid_get_toggle(epid, usb_pipeout(urb->pipe));
2415 usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
2416 usb_pipeout(urb->pipe), toggle);
2417
2418 /* Checks for Ctrl and Bulk EPs */
2419 switch(usb_pipetype(urb->pipe)) {
2420 case PIPE_BULK:
2421 /* Check so Bulk EP realy is disabled before finishing active URB */
2422 ASSERT((TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) ==
2423 IO_STATE(USB_EP_command, enable, no));
2424 /* Disable sub-pointer for EP to avoid next tx_interrupt() to
2425 process Bulk EP. */
2426 TxBulkEPList[epid].sub = 0;
2427 /* No need to wait for the DMA before changing the next pointer.
2428 The modulo NBR_OF_EPIDS isn't actually necessary, since we will never use
2429 the last one (INVALID_EPID) for actual traffic. */
2430 TxBulkEPList[epid].next =
2431 virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
2432 break;
2433 case PIPE_CONTROL:
2434 /* Check so Ctrl EP realy is disabled before finishing active URB */
2435 ASSERT((TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) ==
2436 IO_STATE(USB_EP_command, enable, no));
2437 /* Disable sub-pointer for EP to avoid next tx_interrupt() to
2438 process Ctrl EP. */
2439 TxCtrlEPList[epid].sub = 0;
2440 break;
2441 }
2442 }
2443
2444 /* Free HC-private URB data*/
2445 urb_priv_free(hcd, urb);
2446
2447 if(urb->status) {
2448 errno_dbg("finish_urb (URB:0x%x[%d] %s %s) (data:%d) status:%d\n",
2449 (unsigned int)urb, urb_num, str_dir(urb->pipe),
2450 str_type(urb->pipe), urb->actual_length, urb->status);
2451 } else {
2452 tc_dbg("finish_urb (URB:0x%x[%d] %s %s) (data:%d) status:%d\n",
2453 (unsigned int)urb, urb_num, str_dir(urb->pipe),
2454 str_type(urb->pipe), urb->actual_length, urb->status);
2455 }
2456
2457 /* If we just finished an active URB, clear active pointer. */
2458 if (urb == activeUrbList[epid]) {
2459 /* Make URB not active on EP anymore */
2460 activeUrbList[epid] = NULL;
2461
2462 if(urb->status == 0) {
2463 /* URB finished sucessfully, process queue to see if there are any more
2464 URBs waiting before we call completion function.*/
2465 if(crisv10_hcd->running) {
2466 /* Only process queue if USB controller is running */
2467 tc_dma_process_queue(epid);
2468 } else {
2469 tc_warn("No processing of queue for epid:%d, USB Controller not"
2470 " running\n", epid);
2471 }
2472 }
2473 }
2474
2475 /* Hand the URB from HCD to its USB device driver, using its completion
2476 functions */
2477 usb_hcd_giveback_urb (hcd, urb, status);
2478
2479 /* Check the queue once more if the URB returned with error, because we
2480 didn't do it before the completion function because the specification
2481 states that the queue should not restart until all it's unlinked
2482 URBs have been fully retired, with the completion functions run */
2483 if(crisv10_hcd->running) {
2484 /* Only process queue if USB controller is running */
2485 tc_dma_process_queue(epid);
2486 } else {
2487 tc_warn("No processing of queue for epid:%d, USB Controller not running\n",
2488 epid);
2489 }
2490
2491 DBFEXIT;
2492 }
2493
2494 static void tc_finish_isoc_urb(struct usb_hcd *hcd, struct urb *urb,
2495 int status) {
2496 struct crisv10_urb_priv *urb_priv = urb->hcpriv;
2497 int epid, i;
2498 volatile int timeout = 10000;
2499 int bandwidth = 0;
2500
2501 ASSERT(urb_priv);
2502 epid = urb_priv->epid;
2503
2504 ASSERT(usb_pipeisoc(urb->pipe));
2505
2506 /* Set that all isoc packets have status and length set before
2507 completing the urb. */
2508 for (i = urb_priv->isoc_packet_counter; i < urb->number_of_packets; i++){
2509 urb->iso_frame_desc[i].actual_length = 0;
2510 urb->iso_frame_desc[i].status = -EPROTO;
2511 }
2512
2513 /* Check if the URB is currently active (done or error) */
2514 if(urb == activeUrbList[epid]) {
2515 /* Check if there are another In Isoc URB queued for this epid */
2516 if (!list_empty(&urb_list[epid])&& !epid_state[epid].disabled) {
2517 /* Move it from queue to active and mark it started so Isoc transfers
2518 won't be interrupted.
2519 All Isoc URBs data transfers are already added to DMA lists so we
2520 don't have to insert anything in DMA lists here. */
2521 activeUrbList[epid] = urb_list_first(epid);
2522 ((struct crisv10_urb_priv *)(activeUrbList[epid]->hcpriv))->urb_state =
2523 STARTED;
2524 urb_list_del(activeUrbList[epid], epid);
2525
2526 if(urb->status) {
2527 errno_dbg("finish_isoc_urb (URB:0x%x[%d] %s %s) (%d of %d packets)"
2528 " status:%d, new waiting URB:0x%x[%d]\n",
2529 (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
2530 str_type(urb->pipe), urb_priv->isoc_packet_counter,
2531 urb->number_of_packets, urb->status,
2532 (unsigned int)activeUrbList[epid],
2533 ((struct crisv10_urb_priv *)(activeUrbList[epid]->hcpriv))->urb_num);
2534 }
2535
2536 } else { /* No other URB queued for this epid */
2537 if(urb->status) {
2538 errno_dbg("finish_isoc_urb (URB:0x%x[%d] %s %s) (%d of %d packets)"
2539 " status:%d, no new URB waiting\n",
2540 (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
2541 str_type(urb->pipe), urb_priv->isoc_packet_counter,
2542 urb->number_of_packets, urb->status);
2543 }
2544
2545 /* Check if EP is still enabled, then shut it down. */
2546 if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2547 isoc_dbg("Isoc EP enabled for epid:%d, disabling it\n", epid);
2548
2549 /* Should only occur for In Isoc EPs where SB isn't consumed. */
2550 ASSERT(usb_pipein(urb->pipe));
2551
2552 /* Disable it and wait for it to stop */
2553 TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2554
2555 /* Ah, the luxury of busy-wait. */
2556 while((*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid])) &&
2557 (timeout-- > 0));
2558 }
2559
2560 /* Unlink SB to say that epid is finished. */
2561 TxIsocEPList[epid].sub = 0;
2562 TxIsocEPList[epid].hw_len = 0;
2563
2564 /* No URB active for EP anymore */
2565 activeUrbList[epid] = NULL;
2566 }
2567 } else { /* Finishing of not active URB (queued up with SBs thought) */
2568 isoc_warn("finish_isoc_urb (URB:0x%x %s) (%d of %d packets) status:%d,"
2569 " SB queued but not active\n",
2570 (unsigned int)urb, str_dir(urb->pipe),
2571 urb_priv->isoc_packet_counter, urb->number_of_packets,
2572 urb->status);
2573 if(usb_pipeout(urb->pipe)) {
2574 /* Finishing of not yet active Out Isoc URB needs unlinking of SBs. */
2575 struct USB_SB_Desc *iter_sb, *prev_sb, *next_sb;
2576
2577 iter_sb = TxIsocEPList[epid].sub ?
2578 phys_to_virt(TxIsocEPList[epid].sub) : 0;
2579 prev_sb = 0;
2580
2581 /* SB that is linked before this URBs first SB */
2582 while (iter_sb && (iter_sb != urb_priv->first_sb)) {
2583 prev_sb = iter_sb;
2584 iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
2585 }
2586
2587 if (iter_sb == 0) {
2588 /* Unlink of the URB currently being transmitted. */
2589 prev_sb = 0;
2590 iter_sb = TxIsocEPList[epid].sub ? phys_to_virt(TxIsocEPList[epid].sub) : 0;
2591 }
2592
2593 while (iter_sb && (iter_sb != urb_priv->last_sb)) {
2594 iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
2595 }
2596
2597 if (iter_sb) {
2598 next_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
2599 } else {
2600 /* This should only happen if the DMA has completed
2601 processing the SB list for this EP while interrupts
2602 are disabled. */
2603 isoc_dbg("Isoc urb not found, already sent?\n");
2604 next_sb = 0;
2605 }
2606 if (prev_sb) {
2607 prev_sb->next = next_sb ? virt_to_phys(next_sb) : 0;
2608 } else {
2609 TxIsocEPList[epid].sub = next_sb ? virt_to_phys(next_sb) : 0;
2610 }
2611 }
2612 }
2613
2614 /* Free HC-private URB data*/
2615 bandwidth = urb_priv->bandwidth;
2616 urb_priv_free(hcd, urb);
2617
2618 crisv10_usb_release_bandwidth(hcd, usb_pipeisoc(urb->pipe), bandwidth);
2619
2620 /* Hand the URB from HCD to its USB device driver, using its completion
2621 functions */
2622 usb_hcd_giveback_urb (hcd, urb, status);
2623 }
2624
2625 static __u32 urb_num = 0;
2626
2627 /* allocate and initialize URB private data */
2628 static int urb_priv_create(struct usb_hcd *hcd, struct urb *urb, int epid,
2629 int mem_flags) {
2630 struct crisv10_urb_priv *urb_priv;
2631
2632 urb_priv = kmalloc(sizeof *urb_priv, mem_flags);
2633 if (!urb_priv)
2634 return -ENOMEM;
2635 memset(urb_priv, 0, sizeof *urb_priv);
2636
2637 urb_priv->epid = epid;
2638 urb_priv->urb_state = NOT_STARTED;
2639
2640 urb->hcpriv = urb_priv;
2641 /* Assign URB a sequence number, and increment counter */
2642 urb_priv->urb_num = urb_num;
2643 urb_num++;
2644 urb_priv->bandwidth = 0;
2645 return 0;
2646 }
2647
2648 /* free URB private data */
2649 static void urb_priv_free(struct usb_hcd *hcd, struct urb *urb) {
2650 int i;
2651 struct crisv10_urb_priv *urb_priv = urb->hcpriv;
2652 ASSERT(urb_priv != 0);
2653
2654 /* Check it has any SBs linked that needs to be freed*/
2655 if(urb_priv->first_sb != NULL) {
2656 struct USB_SB_Desc *next_sb, *first_sb, *last_sb;
2657 int i = 0;
2658 first_sb = urb_priv->first_sb;
2659 last_sb = urb_priv->last_sb;
2660 ASSERT(last_sb);
2661 while(first_sb != last_sb) {
2662 next_sb = (struct USB_SB_Desc *)phys_to_virt(first_sb->next);
2663 kmem_cache_free(usb_desc_cache, first_sb);
2664 first_sb = next_sb;
2665 i++;
2666 }
2667 kmem_cache_free(usb_desc_cache, last_sb);
2668 i++;
2669 }
2670
2671 /* Check if it has any EPs in its Intr pool that also needs to be freed */
2672 if(urb_priv->intr_ep_pool_length > 0) {
2673 for(i = 0; i < urb_priv->intr_ep_pool_length; i++) {
2674 kfree(urb_priv->intr_ep_pool[i]);
2675 }
2676 /*
2677 tc_dbg("Freed %d EPs from URB:0x%x EP pool\n",
2678 urb_priv->intr_ep_pool_length, (unsigned int)urb);
2679 */
2680 }
2681
2682 kfree(urb_priv);
2683 urb->hcpriv = NULL;
2684 }
2685
2686 static int ep_priv_create(struct usb_host_endpoint *ep, int mem_flags) {
2687 struct crisv10_ep_priv *ep_priv;
2688
2689 ep_priv = kmalloc(sizeof *ep_priv, mem_flags);
2690 if (!ep_priv)
2691 return -ENOMEM;
2692 memset(ep_priv, 0, sizeof *ep_priv);
2693
2694 ep->hcpriv = ep_priv;
2695 return 0;
2696 }
2697
2698 static void ep_priv_free(struct usb_host_endpoint *ep) {
2699 struct crisv10_ep_priv *ep_priv = ep->hcpriv;
2700 ASSERT(ep_priv);
2701 kfree(ep_priv);
2702 ep->hcpriv = NULL;
2703 }
2704
2705 /*
2706 * usb_check_bandwidth():
2707 *
2708 * old_alloc is from host_controller->bandwidth_allocated in microseconds;
2709 * bustime is from calc_bus_time(), but converted to microseconds.
2710 *
2711 * returns <bustime in us> if successful,
2712 * or -ENOSPC if bandwidth request fails.
2713 *
2714 * FIXME:
2715 * This initial implementation does not use Endpoint.bInterval
2716 * in managing bandwidth allocation.
2717 * It probably needs to be expanded to use Endpoint.bInterval.
2718 * This can be done as a later enhancement (correction).
2719 *
2720 * This will also probably require some kind of
2721 * frame allocation tracking...meaning, for example,
2722 * that if multiple drivers request interrupts every 10 USB frames,
2723 * they don't all have to be allocated at
2724 * frame numbers N, N+10, N+20, etc. Some of them could be at
2725 * N+11, N+21, N+31, etc., and others at
2726 * N+12, N+22, N+32, etc.
2727 *
2728 * Similarly for isochronous transfers...
2729 *
2730 * Individual HCDs can schedule more directly ... this logic
2731 * is not correct for high speed transfers.
2732 */
2733 static int crisv10_usb_check_bandwidth(
2734 struct usb_device *dev,
2735 struct urb *urb)
2736 {
2737 unsigned int pipe = urb->pipe;
2738 long bustime;
2739 int is_in = usb_pipein (pipe);
2740 int is_iso = usb_pipeisoc (pipe);
2741 int old_alloc = dev->bus->bandwidth_allocated;
2742 int new_alloc;
2743
2744 bustime = NS_TO_US (usb_calc_bus_time (dev->speed, is_in, is_iso,
2745 usb_maxpacket (dev, pipe, !is_in)));
2746 if (is_iso)
2747 bustime /= urb->number_of_packets;
2748
2749 new_alloc = old_alloc + (int) bustime;
2750 if (new_alloc > FRAME_TIME_MAX_USECS_ALLOC) {
2751 dev_dbg (&dev->dev, "usb_check_bandwidth FAILED: %d + %ld = %d usec\n",
2752 old_alloc, bustime, new_alloc);
2753 bustime = -ENOSPC; /* report error */
2754 }
2755
2756 return bustime;
2757 }
2758
2759 /**
2760 * usb_claim_bandwidth - records bandwidth for a periodic transfer
2761 * @dev: source/target of request
2762 * @urb: request (urb->dev == dev)
2763 * @bustime: bandwidth consumed, in (average) microseconds per frame
2764 * @isoc: true iff the request is isochronous
2765 *
2766 * HCDs are expected not to overcommit periodic bandwidth, and to record such
2767 * reservations whenever endpoints are added to the periodic schedule.
2768 *
2769 * FIXME averaging per-frame is suboptimal. Better to sum over the HCD's
2770 * entire periodic schedule ... 32 frames for OHCI, 1024 for UHCI, settable
2771 * for EHCI (256/512/1024 frames, default 1024) and have the bus expose how
2772 * large its periodic schedule is.
2773 */
2774 static void crisv10_usb_claim_bandwidth(
2775 struct usb_device *dev,
2776 struct urb *urb, int bustime, int isoc)
2777 {
2778 dev->bus->bandwidth_allocated += bustime;
2779 if (isoc)
2780 dev->bus->bandwidth_isoc_reqs++;
2781 else
2782 dev->bus->bandwidth_int_reqs++;
2783 struct crisv10_urb_priv *urb_priv;
2784 urb_priv = urb->hcpriv;
2785 urb_priv->bandwidth = bustime;
2786 }
2787
2788 /**
2789 * usb_release_bandwidth - reverses effect of usb_claim_bandwidth()
2790 * @hcd: host controller
2791 * @isoc: true iff the request is isochronous
2792 * @bandwidth: bandwidth returned
2793 *
2794 * This records that previously allocated bandwidth has been released.
2795 * Bandwidth is released when endpoints are removed from the host controller's
2796 * periodic schedule.
2797 */
2798 static void crisv10_usb_release_bandwidth(
2799 struct usb_hcd *hcd,
2800 int isoc,
2801 int bandwidth)
2802 {
2803 hcd_to_bus(hcd)->bandwidth_allocated -= bandwidth;
2804 if (isoc)
2805 hcd_to_bus(hcd)->bandwidth_isoc_reqs--;
2806 else
2807 hcd_to_bus(hcd)->bandwidth_int_reqs--;
2808 }
2809
2810
2811 /* EPID handling functions, managing EP-list in Etrax through wrappers */
2812 /* ------------------------------------------------------------------- */
2813
2814 /* Sets up a new EPID for an endpoint or returns existing if found */
2815 static int tc_setup_epid(struct usb_host_endpoint *ep, struct urb *urb,
2816 int mem_flags) {
2817 int epid;
2818 char devnum, endpoint, out_traffic, slow;
2819 int maxlen;
2820 __u32 epid_data;
2821 struct crisv10_ep_priv *ep_priv = ep->hcpriv;
2822
2823 DBFENTER;
2824
2825 /* Check if a valid epid already is setup for this endpoint */
2826 if(ep_priv != NULL) {
2827 return ep_priv->epid;
2828 }
2829
2830 /* We must find and initiate a new epid for this urb. */
2831 epid = tc_allocate_epid();
2832
2833 if (epid == -1) {
2834 /* Failed to allocate a new epid. */
2835 DBFEXIT;
2836 return epid;
2837 }
2838
2839 /* We now have a new epid to use. Claim it. */
2840 epid_state[epid].inuse = 1;
2841
2842 /* Init private data for new endpoint */
2843 if(ep_priv_create(ep, mem_flags) != 0) {
2844 return -ENOMEM;
2845 }
2846 ep_priv = ep->hcpriv;
2847 ep_priv->epid = epid;
2848
2849 devnum = usb_pipedevice(urb->pipe);
2850 endpoint = usb_pipeendpoint(urb->pipe);
2851 slow = (urb->dev->speed == USB_SPEED_LOW);
2852 maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
2853
2854 if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
2855 /* We want both IN and OUT control traffic to be put on the same
2856 EP/SB list. */
2857 out_traffic = 1;
2858 } else {
2859 out_traffic = usb_pipeout(urb->pipe);
2860 }
2861
2862 if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
2863 epid_data = IO_STATE(R_USB_EPT_DATA_ISO, valid, yes) |
2864 /* FIXME: Change any to the actual port? */
2865 IO_STATE(R_USB_EPT_DATA_ISO, port, any) |
2866 IO_FIELD(R_USB_EPT_DATA_ISO, max_len, maxlen) |
2867 IO_FIELD(R_USB_EPT_DATA_ISO, ep, endpoint) |
2868 IO_FIELD(R_USB_EPT_DATA_ISO, dev, devnum);
2869 etrax_epid_iso_set(epid, epid_data);
2870 } else {
2871 epid_data = IO_STATE(R_USB_EPT_DATA, valid, yes) |
2872 IO_FIELD(R_USB_EPT_DATA, low_speed, slow) |
2873 /* FIXME: Change any to the actual port? */
2874 IO_STATE(R_USB_EPT_DATA, port, any) |
2875 IO_FIELD(R_USB_EPT_DATA, max_len, maxlen) |
2876 IO_FIELD(R_USB_EPT_DATA, ep, endpoint) |
2877 IO_FIELD(R_USB_EPT_DATA, dev, devnum);
2878 etrax_epid_set(epid, epid_data);
2879 }
2880
2881 epid_state[epid].out_traffic = out_traffic;
2882 epid_state[epid].type = usb_pipetype(urb->pipe);
2883
2884 tc_warn("Setting up ep:0x%x epid:%d (addr:%d endp:%d max_len:%d %s %s %s)\n",
2885 (unsigned int)ep, epid, devnum, endpoint, maxlen,
2886 str_type(urb->pipe), out_traffic ? "out" : "in",
2887 slow ? "low" : "full");
2888
2889 /* Enable Isoc eof interrupt if we set up the first Isoc epid */
2890 if(usb_pipeisoc(urb->pipe)) {
2891 isoc_epid_counter++;
2892 if(isoc_epid_counter == 1) {
2893 isoc_warn("Enabled Isoc eof interrupt\n");
2894 *R_USB_IRQ_MASK_SET = IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set);
2895 }
2896 }
2897
2898 DBFEXIT;
2899 return epid;
2900 }
2901
2902 static void tc_free_epid(struct usb_host_endpoint *ep) {
2903 unsigned long flags;
2904 struct crisv10_ep_priv *ep_priv = ep->hcpriv;
2905 int epid;
2906 volatile int timeout = 10000;
2907
2908 DBFENTER;
2909
2910 if (ep_priv == NULL) {
2911 tc_warn("Trying to free unused epid on ep:0x%x\n", (unsigned int)ep);
2912 DBFEXIT;
2913 return;
2914 }
2915
2916 epid = ep_priv->epid;
2917
2918 /* Disable Isoc eof interrupt if we free the last Isoc epid */
2919 if(epid_isoc(epid)) {
2920 ASSERT(isoc_epid_counter > 0);
2921 isoc_epid_counter--;
2922 if(isoc_epid_counter == 0) {
2923 *R_USB_IRQ_MASK_CLR = IO_STATE(R_USB_IRQ_MASK_CLR, iso_eof, clr);
2924 isoc_warn("Disabled Isoc eof interrupt\n");
2925 }
2926 }
2927
2928 /* Take lock manualy instead of in epid_x_x wrappers,
2929 because we need to be polling here */
2930 spin_lock_irqsave(&etrax_epid_lock, flags);
2931
2932 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
2933 nop();
2934 while((*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) &&
2935 (timeout-- > 0));
2936 /* This will, among other things, set the valid field to 0. */
2937 *R_USB_EPT_DATA = 0;
2938 spin_unlock_irqrestore(&etrax_epid_lock, flags);
2939
2940 /* Free resource in software state info list */
2941 epid_state[epid].inuse = 0;
2942
2943 /* Free private endpoint data */
2944 ep_priv_free(ep);
2945
2946 DBFEXIT;
2947 }
2948
2949 static int tc_allocate_epid(void) {
2950 int i;
2951 DBFENTER;
2952 for (i = 0; i < NBR_OF_EPIDS; i++) {
2953 if (!epid_inuse(i)) {
2954 DBFEXIT;
2955 return i;
2956 }
2957 }
2958
2959 tc_warn("Found no free epids\n");
2960 DBFEXIT;
2961 return -1;
2962 }
2963
2964
2965 /* Wrappers around the list functions (include/linux/list.h). */
2966 /* ---------------------------------------------------------- */
2967 static inline int __urb_list_empty(int epid) {
2968 int retval;
2969 retval = list_empty(&urb_list[epid]);
2970 return retval;
2971 }
2972
2973 /* Returns first urb for this epid, or NULL if list is empty. */
2974 static inline struct urb *urb_list_first(int epid) {
2975 unsigned long flags;
2976 struct urb *first_urb = 0;
2977 spin_lock_irqsave(&urb_list_lock, flags);
2978 if (!__urb_list_empty(epid)) {
2979 /* Get the first urb (i.e. head->next). */
2980 urb_entry_t *urb_entry = list_entry((&urb_list[epid])->next, urb_entry_t, list);
2981 first_urb = urb_entry->urb;
2982 }
2983 spin_unlock_irqrestore(&urb_list_lock, flags);
2984 return first_urb;
2985 }
2986
2987 /* Adds an urb_entry last in the list for this epid. */
2988 static inline void urb_list_add(struct urb *urb, int epid, int mem_flags) {
2989 unsigned long flags;
2990 urb_entry_t *urb_entry = (urb_entry_t *)kmalloc(sizeof(urb_entry_t), mem_flags);
2991 ASSERT(urb_entry);
2992
2993 urb_entry->urb = urb;
2994 spin_lock_irqsave(&urb_list_lock, flags);
2995 list_add_tail(&urb_entry->list, &urb_list[epid]);
2996 spin_unlock_irqrestore(&urb_list_lock, flags);
2997 }
2998
2999 /* Search through the list for an element that contains this urb. (The list
3000 is expected to be short and the one we are about to delete will often be
3001 the first in the list.)
3002 Should be protected by spin_locks in calling function */
3003 static inline urb_entry_t *__urb_list_entry(struct urb *urb, int epid) {
3004 struct list_head *entry;
3005 struct list_head *tmp;
3006 urb_entry_t *urb_entry;
3007
3008 list_for_each_safe(entry, tmp, &urb_list[epid]) {
3009 urb_entry = list_entry(entry, urb_entry_t, list);
3010 ASSERT(urb_entry);
3011 ASSERT(urb_entry->urb);
3012
3013 if (urb_entry->urb == urb) {
3014 return urb_entry;
3015 }
3016 }
3017 return 0;
3018 }
3019
3020 /* Same function as above but for global use. Protects list by spinlock */
3021 static inline urb_entry_t *urb_list_entry(struct urb *urb, int epid) {
3022 unsigned long flags;
3023 urb_entry_t *urb_entry;
3024 spin_lock_irqsave(&urb_list_lock, flags);
3025 urb_entry = __urb_list_entry(urb, epid);
3026 spin_unlock_irqrestore(&urb_list_lock, flags);
3027 return (urb_entry);
3028 }
3029
3030 /* Delete an urb from the list. */
3031 static inline void urb_list_del(struct urb *urb, int epid) {
3032 unsigned long flags;
3033 urb_entry_t *urb_entry;
3034
3035 /* Delete entry and free. */
3036 spin_lock_irqsave(&urb_list_lock, flags);
3037 urb_entry = __urb_list_entry(urb, epid);
3038 ASSERT(urb_entry);
3039
3040 list_del(&urb_entry->list);
3041 spin_unlock_irqrestore(&urb_list_lock, flags);
3042 kfree(urb_entry);
3043 }
3044
3045 /* Move an urb to the end of the list. */
3046 static inline void urb_list_move_last(struct urb *urb, int epid) {
3047 unsigned long flags;
3048 urb_entry_t *urb_entry;
3049
3050 spin_lock_irqsave(&urb_list_lock, flags);
3051 urb_entry = __urb_list_entry(urb, epid);
3052 ASSERT(urb_entry);
3053
3054 list_del(&urb_entry->list);
3055 list_add_tail(&urb_entry->list, &urb_list[epid]);
3056 spin_unlock_irqrestore(&urb_list_lock, flags);
3057 }
3058
3059 /* Get the next urb in the list. */
3060 static inline struct urb *urb_list_next(struct urb *urb, int epid) {
3061 unsigned long flags;
3062 urb_entry_t *urb_entry;
3063
3064 spin_lock_irqsave(&urb_list_lock, flags);
3065 urb_entry = __urb_list_entry(urb, epid);
3066 ASSERT(urb_entry);
3067
3068 if (urb_entry->list.next != &urb_list[epid]) {
3069 struct list_head *elem = urb_entry->list.next;
3070 urb_entry = list_entry(elem, urb_entry_t, list);
3071 spin_unlock_irqrestore(&urb_list_lock, flags);
3072 return urb_entry->urb;
3073 } else {
3074 spin_unlock_irqrestore(&urb_list_lock, flags);
3075 return NULL;
3076 }
3077 }
3078
3079 struct USB_EP_Desc* create_ep(int epid, struct USB_SB_Desc* sb_desc,
3080 int mem_flags) {
3081 struct USB_EP_Desc *ep_desc;
3082 ep_desc = (struct USB_EP_Desc *) kmem_cache_alloc(usb_desc_cache, mem_flags);
3083 if(ep_desc == NULL)
3084 return NULL;
3085 memset(ep_desc, 0, sizeof(struct USB_EP_Desc));
3086
3087 ep_desc->hw_len = 0;
3088 ep_desc->command = (IO_FIELD(USB_EP_command, epid, epid) |
3089 IO_STATE(USB_EP_command, enable, yes));
3090 if(sb_desc == NULL) {
3091 ep_desc->sub = 0;
3092 } else {
3093 ep_desc->sub = virt_to_phys(sb_desc);
3094 }
3095 return ep_desc;
3096 }
3097
3098 #define TT_ZOUT 0
3099 #define TT_IN 1
3100 #define TT_OUT 2
3101 #define TT_SETUP 3
3102
3103 #define CMD_EOL IO_STATE(USB_SB_command, eol, yes)
3104 #define CMD_INTR IO_STATE(USB_SB_command, intr, yes)
3105 #define CMD_FULL IO_STATE(USB_SB_command, full, yes)
3106
3107 /* Allocation and setup of a generic SB. Used to create SETUP, OUT and ZOUT
3108 SBs. Also used by create_sb_in() to avoid same allocation procedure at two
3109 places */
3110 struct USB_SB_Desc* create_sb(struct USB_SB_Desc* sb_prev, int tt, void* data,
3111 int datalen, int mem_flags) {
3112 struct USB_SB_Desc *sb_desc;
3113 sb_desc = (struct USB_SB_Desc*)kmem_cache_alloc(usb_desc_cache, mem_flags);
3114 if(sb_desc == NULL)
3115 return NULL;
3116 memset(sb_desc, 0, sizeof(struct USB_SB_Desc));
3117
3118 sb_desc->command = IO_FIELD(USB_SB_command, tt, tt) |
3119 IO_STATE(USB_SB_command, eot, yes);
3120
3121 sb_desc->sw_len = datalen;
3122 if(data != NULL) {
3123 sb_desc->buf = virt_to_phys(data);
3124 } else {
3125 sb_desc->buf = 0;
3126 }
3127 if(sb_prev != NULL) {
3128 sb_prev->next = virt_to_phys(sb_desc);
3129 }
3130 return sb_desc;
3131 }
3132
3133 /* Creates a copy of an existing SB by allocation space for it and copy
3134 settings */
3135 struct USB_SB_Desc* create_sb_copy(struct USB_SB_Desc* sb_orig, int mem_flags) {
3136 struct USB_SB_Desc *sb_desc;
3137 sb_desc = (struct USB_SB_Desc*)kmem_cache_alloc(usb_desc_cache, mem_flags);
3138 if(sb_desc == NULL)
3139 return NULL;
3140
3141 memcpy(sb_desc, sb_orig, sizeof(struct USB_SB_Desc));
3142 return sb_desc;
3143 }
3144
3145 /* A specific create_sb function for creation of in SBs. This is due to
3146 that datalen in In SBs shows how many packets we are expecting. It also
3147 sets up the rem field to show if how many bytes we expect in last packet
3148 if it's not a full one */
3149 struct USB_SB_Desc* create_sb_in(struct USB_SB_Desc* sb_prev, int datalen,
3150 int maxlen, int mem_flags) {
3151 struct USB_SB_Desc *sb_desc;
3152 sb_desc = create_sb(sb_prev, TT_IN, NULL,
3153 datalen ? (datalen - 1) / maxlen + 1 : 0, mem_flags);
3154 if(sb_desc == NULL)
3155 return NULL;
3156 sb_desc->command |= IO_FIELD(USB_SB_command, rem, datalen % maxlen);
3157 return sb_desc;
3158 }
3159
3160 void set_sb_cmds(struct USB_SB_Desc *sb_desc, __u16 flags) {
3161 sb_desc->command |= flags;
3162 }
3163
3164 int create_sb_for_urb(struct urb *urb, int mem_flags) {
3165 int is_out = !usb_pipein(urb->pipe);
3166 int type = usb_pipetype(urb->pipe);
3167 int maxlen = usb_maxpacket(urb->dev, urb->pipe, is_out);
3168 int buf_len = urb->transfer_buffer_length;
3169 void *buf = buf_len > 0 ? urb->transfer_buffer : NULL;
3170 struct USB_SB_Desc *sb_desc = NULL;
3171
3172 struct crisv10_urb_priv *urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
3173 ASSERT(urb_priv != NULL);
3174
3175 switch(type) {
3176 case PIPE_CONTROL:
3177 /* Setup stage */
3178 sb_desc = create_sb(NULL, TT_SETUP, urb->setup_packet, 8, mem_flags);
3179 if(sb_desc == NULL)
3180 return -ENOMEM;
3181 set_sb_cmds(sb_desc, CMD_FULL);
3182
3183 /* Attach first SB to URB */
3184 urb_priv->first_sb = sb_desc;
3185
3186 if (is_out) { /* Out Control URB */
3187 /* If this Control OUT transfer has an optional data stage we add
3188 an OUT token before the mandatory IN (status) token */
3189 if ((buf_len > 0) && buf) {
3190 sb_desc = create_sb(sb_desc, TT_OUT, buf, buf_len, mem_flags);
3191 if(sb_desc == NULL)
3192 return -ENOMEM;
3193 set_sb_cmds(sb_desc, CMD_FULL);
3194 }
3195
3196 /* Status stage */
3197 /* The data length has to be exactly 1. This is due to a requirement
3198 of the USB specification that a host must be prepared to receive
3199 data in the status phase */
3200 sb_desc = create_sb(sb_desc, TT_IN, NULL, 1, mem_flags);
3201 if(sb_desc == NULL)
3202 return -ENOMEM;
3203 } else { /* In control URB */
3204 /* Data stage */
3205 sb_desc = create_sb_in(sb_desc, buf_len, maxlen, mem_flags);
3206 if(sb_desc == NULL)
3207 return -ENOMEM;
3208
3209 /* Status stage */
3210 /* Read comment at zout_buffer declaration for an explanation to this. */
3211 sb_desc = create_sb(sb_desc, TT_ZOUT, &zout_buffer[0], 1, mem_flags);
3212 if(sb_desc == NULL)
3213 return -ENOMEM;
3214 /* Set descriptor interrupt flag for in URBs so we can finish URB after
3215 zout-packet has been sent */
3216 set_sb_cmds(sb_desc, CMD_INTR | CMD_FULL);
3217 }
3218 /* Set end-of-list flag in last SB */
3219 set_sb_cmds(sb_desc, CMD_EOL);
3220 /* Attach last SB to URB */
3221 urb_priv->last_sb = sb_desc;
3222 break;
3223
3224 case PIPE_BULK:
3225 if (is_out) { /* Out Bulk URB */
3226 sb_desc = create_sb(NULL, TT_OUT, buf, buf_len, mem_flags);
3227 if(sb_desc == NULL)
3228 return -ENOMEM;
3229 /* The full field is set to yes, even if we don't actually check that
3230 this is a full-length transfer (i.e., that transfer_buffer_length %
3231 maxlen = 0).
3232 Setting full prevents the USB controller from sending an empty packet
3233 in that case. However, if URB_ZERO_PACKET was set we want that. */
3234 if (!(urb->transfer_flags & URB_ZERO_PACKET)) {
3235 set_sb_cmds(sb_desc, CMD_FULL);
3236 }
3237 } else { /* In Bulk URB */
3238 sb_desc = create_sb_in(NULL, buf_len, maxlen, mem_flags);
3239 if(sb_desc == NULL)
3240 return -ENOMEM;
3241 }
3242 /* Set end-of-list flag for last SB */
3243 set_sb_cmds(sb_desc, CMD_EOL);
3244
3245 /* Attach SB to URB */
3246 urb_priv->first_sb = sb_desc;
3247 urb_priv->last_sb = sb_desc;
3248 break;
3249
3250 case PIPE_INTERRUPT:
3251 if(is_out) { /* Out Intr URB */
3252 sb_desc = create_sb(NULL, TT_OUT, buf, buf_len, mem_flags);
3253 if(sb_desc == NULL)
3254 return -ENOMEM;
3255
3256 /* The full field is set to yes, even if we don't actually check that
3257 this is a full-length transfer (i.e., that transfer_buffer_length %
3258 maxlen = 0).
3259 Setting full prevents the USB controller from sending an empty packet
3260 in that case. However, if URB_ZERO_PACKET was set we want that. */
3261 if (!(urb->transfer_flags & URB_ZERO_PACKET)) {
3262 set_sb_cmds(sb_desc, CMD_FULL);
3263 }
3264 /* Only generate TX interrupt if it's a Out URB*/
3265 set_sb_cmds(sb_desc, CMD_INTR);
3266
3267 } else { /* In Intr URB */
3268 sb_desc = create_sb_in(NULL, buf_len, maxlen, mem_flags);
3269 if(sb_desc == NULL)
3270 return -ENOMEM;
3271 }
3272 /* Set end-of-list flag for last SB */
3273 set_sb_cmds(sb_desc, CMD_EOL);
3274
3275 /* Attach SB to URB */
3276 urb_priv->first_sb = sb_desc;
3277 urb_priv->last_sb = sb_desc;
3278
3279 break;
3280 case PIPE_ISOCHRONOUS:
3281 if(is_out) { /* Out Isoc URB */
3282 int i;
3283 if(urb->number_of_packets == 0) {
3284 tc_err("Can't create SBs for Isoc URB with zero packets\n");
3285 return -EPIPE;
3286 }
3287 /* Create one SB descriptor for each packet and link them together. */
3288 for(i = 0; i < urb->number_of_packets; i++) {
3289 if (urb->iso_frame_desc[i].length > 0) {
3290
3291 sb_desc = create_sb(sb_desc, TT_OUT, urb->transfer_buffer +
3292 urb->iso_frame_desc[i].offset,
3293 urb->iso_frame_desc[i].length, mem_flags);
3294 if(sb_desc == NULL)
3295 return -ENOMEM;
3296
3297 /* Check if it's a full length packet */
3298 if (urb->iso_frame_desc[i].length ==
3299 usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe))) {
3300 set_sb_cmds(sb_desc, CMD_FULL);
3301 }
3302
3303 } else { /* zero length packet */
3304 sb_desc = create_sb(sb_desc, TT_ZOUT, &zout_buffer[0], 1, mem_flags);
3305 if(sb_desc == NULL)
3306 return -ENOMEM;
3307 set_sb_cmds(sb_desc, CMD_FULL);
3308 }
3309 /* Attach first SB descriptor to URB */
3310 if (i == 0) {
3311 urb_priv->first_sb = sb_desc;
3312 }
3313 }
3314 /* Set interrupt and end-of-list flags in last SB */
3315 set_sb_cmds(sb_desc, CMD_INTR | CMD_EOL);
3316 /* Attach last SB descriptor to URB */
3317 urb_priv->last_sb = sb_desc;
3318 tc_dbg("Created %d out SBs for Isoc URB:0x%x\n",
3319 urb->number_of_packets, (unsigned int)urb);
3320 } else { /* In Isoc URB */
3321 /* Actual number of packets is not relevant for periodic in traffic as
3322 long as it is more than zero. Set to 1 always. */
3323 sb_desc = create_sb(sb_desc, TT_IN, NULL, 1, mem_flags);
3324 if(sb_desc == NULL)
3325 return -ENOMEM;
3326 /* Set end-of-list flags for SB */
3327 set_sb_cmds(sb_desc, CMD_EOL);
3328
3329 /* Attach SB to URB */
3330 urb_priv->first_sb = sb_desc;
3331 urb_priv->last_sb = sb_desc;
3332 }
3333 break;
3334 default:
3335 tc_err("Unknown pipe-type\n");
3336 return -EPIPE;
3337 break;
3338 }
3339 return 0;
3340 }
3341
3342 int init_intr_urb(struct urb *urb, int mem_flags) {
3343 struct crisv10_urb_priv *urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
3344 struct USB_EP_Desc* ep_desc;
3345 int interval;
3346 int i;
3347 int ep_count;
3348
3349 ASSERT(urb_priv != NULL);
3350 ASSERT(usb_pipeint(urb->pipe));
3351 /* We can't support interval longer than amount of eof descriptors in
3352 TxIntrEPList */
3353 if(urb->interval > MAX_INTR_INTERVAL) {
3354 tc_err("Interrupt interval %dms too big (max: %dms)\n", urb->interval,
3355 MAX_INTR_INTERVAL);
3356 return -EINVAL;
3357 }
3358
3359 /* We assume that the SB descriptors already have been setup */
3360 ASSERT(urb_priv->first_sb != NULL);
3361
3362 /* Round of the interval to 2^n, it is obvious that this code favours
3363 smaller numbers, but that is actually a good thing */
3364 /* FIXME: The "rounding error" for larger intervals will be quite
3365 large. For in traffic this shouldn't be a problem since it will only
3366 mean that we "poll" more often. */
3367 interval = urb->interval;
3368 for (i = 0; interval; i++) {
3369 interval = interval >> 1;
3370 }
3371 urb_priv->interval = 1 << (i - 1);
3372
3373 /* We can only have max interval for Out Interrupt due to that we can only
3374 handle one linked in EP for a certain epid in the Intr descr array at the
3375 time. The USB Controller in the Etrax 100LX continues to process Intr EPs
3376 so we have no way of knowing which one that caused the actual transfer if
3377 we have several linked in. */
3378 if(usb_pipeout(urb->pipe)) {
3379 urb_priv->interval = MAX_INTR_INTERVAL;
3380 }
3381
3382 /* Calculate amount of EPs needed */
3383 ep_count = MAX_INTR_INTERVAL / urb_priv->interval;
3384
3385 for(i = 0; i < ep_count; i++) {
3386 ep_desc = create_ep(urb_priv->epid, urb_priv->first_sb, mem_flags);
3387 if(ep_desc == NULL) {
3388 /* Free any descriptors that we may have allocated before failure */
3389 while(i > 0) {
3390 i--;
3391 kfree(urb_priv->intr_ep_pool[i]);
3392 }
3393 return -ENOMEM;
3394 }
3395 urb_priv->intr_ep_pool[i] = ep_desc;
3396 }
3397 urb_priv->intr_ep_pool_length = ep_count;
3398 return 0;
3399 }
3400
3401 /* DMA RX/TX functions */
3402 /* ----------------------- */
3403
3404 static void tc_dma_init_rx_list(void) {
3405 int i;
3406
3407 /* Setup descriptor list except last one */
3408 for (i = 0; i < (NBR_OF_RX_DESC - 1); i++) {
3409 RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
3410 RxDescList[i].command = 0;
3411 RxDescList[i].next = virt_to_phys(&RxDescList[i + 1]);
3412 RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
3413 RxDescList[i].hw_len = 0;
3414 RxDescList[i].status = 0;
3415
3416 /* DMA IN cache bug. (struct etrax_dma_descr has the same layout as
3417 USB_IN_Desc for the relevant fields.) */
3418 prepare_rx_descriptor((struct etrax_dma_descr*)&RxDescList[i]);
3419
3420 }
3421 /* Special handling of last descriptor */
3422 RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
3423 RxDescList[i].command = IO_STATE(USB_IN_command, eol, yes);
3424 RxDescList[i].next = virt_to_phys(&RxDescList[0]);
3425 RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
3426 RxDescList[i].hw_len = 0;
3427 RxDescList[i].status = 0;
3428
3429 /* Setup list pointers that show progress in list */
3430 myNextRxDesc = &RxDescList[0];
3431 myLastRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
3432
3433 flush_etrax_cache();
3434 /* Point DMA to first descriptor in list and start it */
3435 *R_DMA_CH9_FIRST = virt_to_phys(myNextRxDesc);
3436 *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, start);
3437 }
3438
3439
3440 static void tc_dma_init_tx_bulk_list(void) {
3441 int i;
3442 volatile struct USB_EP_Desc *epDescr;
3443
3444 for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
3445 epDescr = &(TxBulkEPList[i]);
3446 CHECK_ALIGN(epDescr);
3447 epDescr->hw_len = 0;
3448 epDescr->command = IO_FIELD(USB_EP_command, epid, i);
3449 epDescr->sub = 0;
3450 epDescr->next = virt_to_phys(&TxBulkEPList[i + 1]);
3451
3452 /* Initiate two EPs, disabled and with the eol flag set. No need for any
3453 preserved epid. */
3454
3455 /* The first one has the intr flag set so we get an interrupt when the DMA
3456 channel is about to become disabled. */
3457 CHECK_ALIGN(&TxBulkDummyEPList[i][0]);
3458 TxBulkDummyEPList[i][0].hw_len = 0;
3459 TxBulkDummyEPList[i][0].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
3460 IO_STATE(USB_EP_command, eol, yes) |
3461 IO_STATE(USB_EP_command, intr, yes));
3462 TxBulkDummyEPList[i][0].sub = 0;
3463 TxBulkDummyEPList[i][0].next = virt_to_phys(&TxBulkDummyEPList[i][1]);
3464
3465 /* The second one. */
3466 CHECK_ALIGN(&TxBulkDummyEPList[i][1]);
3467 TxBulkDummyEPList[i][1].hw_len = 0;
3468 TxBulkDummyEPList[i][1].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
3469 IO_STATE(USB_EP_command, eol, yes));
3470 TxBulkDummyEPList[i][1].sub = 0;
3471 /* The last dummy's next pointer is the same as the current EP's next pointer. */
3472 TxBulkDummyEPList[i][1].next = virt_to_phys(&TxBulkEPList[i + 1]);
3473 }
3474
3475 /* Special handling of last descr in list, make list circular */
3476 epDescr = &TxBulkEPList[i];
3477 CHECK_ALIGN(epDescr);
3478 epDescr->hw_len = 0;
3479 epDescr->command = IO_STATE(USB_EP_command, eol, yes) |
3480 IO_FIELD(USB_EP_command, epid, i);
3481 epDescr->sub = 0;
3482 epDescr->next = virt_to_phys(&TxBulkEPList[0]);
3483
3484 /* Init DMA sub-channel pointers to last item in each list */
3485 *R_DMA_CH8_SUB0_EP = virt_to_phys(&TxBulkEPList[i]);
3486 /* No point in starting the bulk channel yet.
3487 *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); */
3488 }
3489
3490 static void tc_dma_init_tx_ctrl_list(void) {
3491 int i;
3492 volatile struct USB_EP_Desc *epDescr;
3493
3494 for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
3495 epDescr = &(TxCtrlEPList[i]);
3496 CHECK_ALIGN(epDescr);
3497 epDescr->hw_len = 0;
3498 epDescr->command = IO_FIELD(USB_EP_command, epid, i);
3499 epDescr->sub = 0;
3500 epDescr->next = virt_to_phys(&TxCtrlEPList[i + 1]);
3501 }
3502 /* Special handling of last descr in list, make list circular */
3503 epDescr = &TxCtrlEPList[i];
3504 CHECK_ALIGN(epDescr);
3505 epDescr->hw_len = 0;
3506 epDescr->command = IO_STATE(USB_EP_command, eol, yes) |
3507 IO_FIELD(USB_EP_command, epid, i);
3508 epDescr->sub = 0;
3509 epDescr->next = virt_to_phys(&TxCtrlEPList[0]);
3510
3511 /* Init DMA sub-channel pointers to last item in each list */
3512 *R_DMA_CH8_SUB1_EP = virt_to_phys(&TxCtrlEPList[i]);
3513 /* No point in starting the ctrl channel yet.
3514 *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); */
3515 }
3516
3517
3518 static void tc_dma_init_tx_intr_list(void) {
3519 int i;
3520
3521 TxIntrSB_zout.sw_len = 1;
3522 TxIntrSB_zout.next = 0;
3523 TxIntrSB_zout.buf = virt_to_phys(&zout_buffer[0]);
3524 TxIntrSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
3525 IO_STATE(USB_SB_command, tt, zout) |
3526 IO_STATE(USB_SB_command, full, yes) |
3527 IO_STATE(USB_SB_command, eot, yes) |
3528 IO_STATE(USB_SB_command, eol, yes));
3529
3530 for (i = 0; i < (MAX_INTR_INTERVAL - 1); i++) {
3531 CHECK_ALIGN(&TxIntrEPList[i]);
3532 TxIntrEPList[i].hw_len = 0;
3533 TxIntrEPList[i].command =
3534 (IO_STATE(USB_EP_command, eof, yes) |
3535 IO_STATE(USB_EP_command, enable, yes) |
3536 IO_FIELD(USB_EP_command, epid, INVALID_EPID));
3537 TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
3538 TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[i + 1]);
3539 }
3540
3541 /* Special handling of last descr in list, make list circular */
3542 CHECK_ALIGN(&TxIntrEPList[i]);
3543 TxIntrEPList[i].hw_len = 0;
3544 TxIntrEPList[i].command =
3545 (IO_STATE(USB_EP_command, eof, yes) |
3546 IO_STATE(USB_EP_command, eol, yes) |
3547 IO_STATE(USB_EP_command, enable, yes) |
3548 IO_FIELD(USB_EP_command, epid, INVALID_EPID));
3549 TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
3550 TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[0]);
3551
3552 intr_dbg("Initiated Intr EP descriptor list\n");
3553
3554
3555 /* Connect DMA 8 sub-channel 2 to first in list */
3556 *R_DMA_CH8_SUB2_EP = virt_to_phys(&TxIntrEPList[0]);
3557 }
3558
3559 static void tc_dma_init_tx_isoc_list(void) {
3560 int i;
3561
3562 DBFENTER;
3563
3564 /* Read comment at zout_buffer declaration for an explanation to this. */
3565 TxIsocSB_zout.sw_len = 1;
3566 TxIsocSB_zout.next = 0;
3567 TxIsocSB_zout.buf = virt_to_phys(&zout_buffer[0]);
3568 TxIsocSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
3569 IO_STATE(USB_SB_command, tt, zout) |
3570 IO_STATE(USB_SB_command, full, yes) |
3571 IO_STATE(USB_SB_command, eot, yes) |
3572 IO_STATE(USB_SB_command, eol, yes));
3573
3574 /* The last isochronous EP descriptor is a dummy. */
3575 for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
3576 CHECK_ALIGN(&TxIsocEPList[i]);
3577 TxIsocEPList[i].hw_len = 0;
3578 TxIsocEPList[i].command = IO_FIELD(USB_EP_command, epid, i);
3579 TxIsocEPList[i].sub = 0;
3580 TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[i + 1]);
3581 }
3582
3583 CHECK_ALIGN(&TxIsocEPList[i]);
3584 TxIsocEPList[i].hw_len = 0;
3585
3586 /* Must enable the last EP descr to get eof interrupt. */
3587 TxIsocEPList[i].command = (IO_STATE(USB_EP_command, enable, yes) |
3588 IO_STATE(USB_EP_command, eof, yes) |
3589 IO_STATE(USB_EP_command, eol, yes) |
3590 IO_FIELD(USB_EP_command, epid, INVALID_EPID));
3591 TxIsocEPList[i].sub = virt_to_phys(&TxIsocSB_zout);
3592 TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[0]);
3593
3594 *R_DMA_CH8_SUB3_EP = virt_to_phys(&TxIsocEPList[0]);
3595 *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
3596 }
3597
3598 static int tc_dma_init(struct usb_hcd *hcd) {
3599 tc_dma_init_rx_list();
3600 tc_dma_init_tx_bulk_list();
3601 tc_dma_init_tx_ctrl_list();
3602 tc_dma_init_tx_intr_list();
3603 tc_dma_init_tx_isoc_list();
3604
3605 if (cris_request_dma(USB_TX_DMA_NBR,
3606 "ETRAX 100LX built-in USB (Tx)",
3607 DMA_VERBOSE_ON_ERROR,
3608 dma_usb)) {
3609 err("Could not allocate DMA ch 8 for USB");
3610 return -EBUSY;
3611 }
3612
3613 if (cris_request_dma(USB_RX_DMA_NBR,
3614 "ETRAX 100LX built-in USB (Rx)",
3615 DMA_VERBOSE_ON_ERROR,
3616 dma_usb)) {
3617 err("Could not allocate DMA ch 9 for USB");
3618 return -EBUSY;
3619 }
3620
3621 *R_IRQ_MASK2_SET =
3622 /* Note that these interrupts are not used. */
3623 IO_STATE(R_IRQ_MASK2_SET, dma8_sub0_descr, set) |
3624 /* Sub channel 1 (ctrl) descr. interrupts are used. */
3625 IO_STATE(R_IRQ_MASK2_SET, dma8_sub1_descr, set) |
3626 IO_STATE(R_IRQ_MASK2_SET, dma8_sub2_descr, set) |
3627 /* Sub channel 3 (isoc) descr. interrupts are used. */
3628 IO_STATE(R_IRQ_MASK2_SET, dma8_sub3_descr, set);
3629
3630 /* Note that the dma9_descr interrupt is not used. */
3631 *R_IRQ_MASK2_SET =
3632 IO_STATE(R_IRQ_MASK2_SET, dma9_eop, set) |
3633 IO_STATE(R_IRQ_MASK2_SET, dma9_descr, set);
3634
3635 if (request_irq(ETRAX_USB_RX_IRQ, tc_dma_rx_interrupt, 0,
3636 "ETRAX 100LX built-in USB (Rx)", hcd)) {
3637 err("Could not allocate IRQ %d for USB", ETRAX_USB_RX_IRQ);
3638 return -EBUSY;
3639 }
3640
3641 if (request_irq(ETRAX_USB_TX_IRQ, tc_dma_tx_interrupt, 0,
3642 "ETRAX 100LX built-in USB (Tx)", hcd)) {
3643 err("Could not allocate IRQ %d for USB", ETRAX_USB_TX_IRQ);
3644 return -EBUSY;
3645 }
3646
3647 return 0;
3648 }
3649
3650 static void tc_dma_destroy(void) {
3651 free_irq(ETRAX_USB_RX_IRQ, NULL);
3652 free_irq(ETRAX_USB_TX_IRQ, NULL);
3653
3654 cris_free_dma(USB_TX_DMA_NBR, "ETRAX 100LX built-in USB (Tx)");
3655 cris_free_dma(USB_RX_DMA_NBR, "ETRAX 100LX built-in USB (Rx)");
3656
3657 }
3658
3659 static void tc_dma_link_intr_urb(struct urb *urb);
3660
3661 /* Handle processing of Bulk, Ctrl and Intr queues */
3662 static void tc_dma_process_queue(int epid) {
3663 struct urb *urb;
3664 struct crisv10_urb_priv *urb_priv;
3665 unsigned long flags;
3666 char toggle;
3667
3668 if(epid_state[epid].disabled) {
3669 /* Don't process any URBs on a disabled endpoint */
3670 return;
3671 }
3672
3673 /* Do not disturb us while fiddling with EPs and epids */
3674 local_irq_save(flags);
3675
3676 /* For bulk, Ctrl and Intr can we only have one URB active at a time for
3677 a specific EP. */
3678 if(activeUrbList[epid] != NULL) {
3679 /* An URB is already active on EP, skip checking queue */
3680 local_irq_restore(flags);
3681 return;
3682 }
3683
3684 urb = urb_list_first(epid);
3685 if(urb == NULL) {
3686 /* No URB waiting in EP queue. Nothing do to */
3687 local_irq_restore(flags);
3688 return;
3689 }
3690
3691 urb_priv = urb->hcpriv;
3692 ASSERT(urb_priv != NULL);
3693 ASSERT(urb_priv->urb_state == NOT_STARTED);
3694 ASSERT(!usb_pipeisoc(urb->pipe));
3695
3696 /* Remove this URB from the queue and move it to active */
3697 activeUrbList[epid] = urb;
3698 urb_list_del(urb, epid);
3699
3700 urb_priv->urb_state = STARTED;
3701
3702 /* Reset error counters (regardless of which direction this traffic is). */
3703 etrax_epid_clear_error(epid);
3704
3705 /* Special handling of Intr EP lists */
3706 if(usb_pipeint(urb->pipe)) {
3707 tc_dma_link_intr_urb(urb);
3708 local_irq_restore(flags);
3709 return;
3710 }
3711
3712 /* Software must preset the toggle bits for Bulk and Ctrl */
3713 if(usb_pipecontrol(urb->pipe)) {
3714 /* Toggle bits are initialized only during setup transaction in a
3715 CTRL transfer */
3716 etrax_epid_set_toggle(epid, 0, 0);
3717 etrax_epid_set_toggle(epid, 1, 0);
3718 } else {
3719 toggle = usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe),
3720 usb_pipeout(urb->pipe));
3721 etrax_epid_set_toggle(epid, usb_pipeout(urb->pipe), toggle);
3722 }
3723
3724 tc_dbg("Added SBs from (URB:0x%x %s %s) to epid %d: %s\n",
3725 (unsigned int)urb, str_dir(urb->pipe), str_type(urb->pipe), epid,
3726 sblist_to_str(urb_priv->first_sb));
3727
3728 /* We start the DMA sub channel without checking if it's running or not,
3729 because:
3730 1) If it's already running, issuing the start command is a nop.
3731 2) We avoid a test-and-set race condition. */
3732 switch(usb_pipetype(urb->pipe)) {
3733 case PIPE_BULK:
3734 /* Assert that the EP descriptor is disabled. */
3735 ASSERT(!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)));
3736
3737 /* Set up and enable the EP descriptor. */
3738 TxBulkEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
3739 TxBulkEPList[epid].hw_len = 0;
3740 TxBulkEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
3741
3742 /* Check if the dummy list is already with us (if several urbs were queued). */
3743 if (usb_pipein(urb->pipe) && (TxBulkEPList[epid].next != virt_to_phys(&TxBulkDummyEPList[epid][0]))) {
3744 tc_dbg("Inviting dummy list to the party for urb 0x%lx, epid %d",
3745 (unsigned long)urb, epid);
3746
3747 /* We don't need to check if the DMA is at this EP or not before changing the
3748 next pointer, since we will do it in one 32-bit write (EP descriptors are
3749 32-bit aligned). */
3750 TxBulkEPList[epid].next = virt_to_phys(&TxBulkDummyEPList[epid][0]);
3751 }
3752
3753 restart_dma8_sub0();
3754
3755 /* Update/restart the bulk start timer since we just started the channel.*/
3756 mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
3757 /* Update/restart the bulk eot timer since we just inserted traffic. */
3758 mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
3759 break;
3760 case PIPE_CONTROL:
3761 /* Assert that the EP descriptor is disabled. */
3762 ASSERT(!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)));
3763
3764 /* Set up and enable the EP descriptor. */
3765 TxCtrlEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
3766 TxCtrlEPList[epid].hw_len = 0;
3767 TxCtrlEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
3768
3769 *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB1_CMD, cmd, start);
3770 break;
3771 }
3772 local_irq_restore(flags);
3773 }
3774
3775 static void tc_dma_link_intr_urb(struct urb *urb) {
3776 struct crisv10_urb_priv *urb_priv = urb->hcpriv;
3777 volatile struct USB_EP_Desc *tmp_ep;
3778 struct USB_EP_Desc *ep_desc;
3779 int i = 0, epid;
3780 int pool_idx = 0;
3781
3782 ASSERT(urb_priv != NULL);
3783 epid = urb_priv->epid;
3784 ASSERT(urb_priv->interval > 0);
3785 ASSERT(urb_priv->intr_ep_pool_length > 0);
3786
3787 tmp_ep = &TxIntrEPList[0];
3788
3789 /* Only insert one EP descriptor in list for Out Intr URBs.
3790 We can only handle Out Intr with interval of 128ms because
3791 it's not possible to insert several Out Intr EPs because they
3792 are not consumed by the DMA. */
3793 if(usb_pipeout(urb->pipe)) {
3794 ep_desc = urb_priv->intr_ep_pool[0];
3795 ASSERT(ep_desc);
3796 ep_desc->next = tmp_ep->next;
3797 tmp_ep->next = virt_to_phys(ep_desc);
3798 i++;
3799 } else {
3800 /* Loop through Intr EP descriptor list and insert EP for URB at
3801 specified interval */
3802 do {
3803 /* Each EP descriptor with eof flag sat signals a new frame */
3804 if (tmp_ep->command & IO_MASK(USB_EP_command, eof)) {
3805 /* Insert a EP from URBs EP pool at correct interval */
3806 if ((i % urb_priv->interval) == 0) {
3807 ep_desc = urb_priv->intr_ep_pool[pool_idx];
3808 ASSERT(ep_desc);
3809 ep_desc->next = tmp_ep->next;
3810 tmp_ep->next = virt_to_phys(ep_desc);
3811 pool_idx++;
3812 ASSERT(pool_idx <= urb_priv->intr_ep_pool_length);
3813 }
3814 i++;
3815 }
3816 tmp_ep = (struct USB_EP_Desc *)phys_to_virt(tmp_ep->next);
3817 } while(tmp_ep != &TxIntrEPList[0]);
3818 }
3819
3820 intr_dbg("Added SBs to intr epid %d: %s interval:%d (%d EP)\n", epid,
3821 sblist_to_str(urb_priv->first_sb), urb_priv->interval, pool_idx);
3822
3823 /* We start the DMA sub channel without checking if it's running or not,
3824 because:
3825 1) If it's already running, issuing the start command is a nop.
3826 2) We avoid a test-and-set race condition. */
3827 *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start);
3828 }
3829
3830 static void tc_dma_process_isoc_urb(struct urb *urb) {
3831 unsigned long flags;
3832 struct crisv10_urb_priv *urb_priv = urb->hcpriv;
3833 int epid;
3834
3835 /* Do not disturb us while fiddling with EPs and epids */
3836 local_irq_save(flags);
3837
3838 ASSERT(urb_priv);
3839 ASSERT(urb_priv->first_sb);
3840 epid = urb_priv->epid;
3841
3842 if(activeUrbList[epid] == NULL) {
3843 /* EP is idle, so make this URB active */
3844 activeUrbList[epid] = urb;
3845 urb_list_del(urb, epid);
3846 ASSERT(TxIsocEPList[epid].sub == 0);
3847 ASSERT(!(TxIsocEPList[epid].command &
3848 IO_STATE(USB_EP_command, enable, yes)));
3849
3850 /* Differentiate between In and Out Isoc. Because In SBs are not consumed*/
3851 if(usb_pipein(urb->pipe)) {
3852 /* Each EP for In Isoc will have only one SB descriptor, setup when
3853 submitting the first active urb. We do it here by copying from URBs
3854 pre-allocated SB. */
3855 memcpy((void *)&(TxIsocSBList[epid]), urb_priv->first_sb,
3856 sizeof(TxIsocSBList[epid]));
3857 TxIsocEPList[epid].hw_len = 0;
3858 TxIsocEPList[epid].sub = virt_to_phys(&(TxIsocSBList[epid]));
3859 } else {
3860 /* For Out Isoc we attach the pre-allocated list of SBs for the URB */
3861 TxIsocEPList[epid].hw_len = 0;
3862 TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
3863
3864 isoc_dbg("Attached first URB:0x%x[%d] to epid:%d first_sb:0x%x"
3865 " last_sb::0x%x\n",
3866 (unsigned int)urb, urb_priv->urb_num, epid,
3867 (unsigned int)(urb_priv->first_sb),
3868 (unsigned int)(urb_priv->last_sb));
3869 }
3870
3871 if (urb->transfer_flags & URB_ISO_ASAP) {
3872 /* The isoc transfer should be started as soon as possible. The
3873 start_frame field is a return value if URB_ISO_ASAP was set. Comparing
3874 R_USB_FM_NUMBER with a USB Chief trace shows that the first isoc IN
3875 token is sent 2 frames later. I'm not sure how this affects usage of
3876 the start_frame field by the device driver, or how it affects things
3877 when USB_ISO_ASAP is not set, so therefore there's no compensation for
3878 the 2 frame "lag" here. */
3879 urb->start_frame = (*R_USB_FM_NUMBER & 0x7ff);
3880 TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
3881 urb_priv->urb_state = STARTED;
3882 isoc_dbg("URB_ISO_ASAP set, urb->start_frame set to %d\n",
3883 urb->start_frame);
3884 } else {
3885 /* Not started yet. */
3886 urb_priv->urb_state = NOT_STARTED;
3887 isoc_warn("urb_priv->urb_state set to NOT_STARTED for URB:0x%x\n",
3888 (unsigned int)urb);
3889 }
3890
3891 } else {
3892 /* An URB is already active on the EP. Leave URB in queue and let
3893 finish_isoc_urb process it after current active URB */
3894 ASSERT(TxIsocEPList[epid].sub != 0);
3895
3896 if(usb_pipein(urb->pipe)) {
3897 /* Because there already is a active In URB on this epid we do nothing
3898 and the finish_isoc_urb() function will handle switching to next URB*/
3899
3900 } else { /* For Out Isoc, insert new URBs traffic last in SB-list. */
3901 struct USB_SB_Desc *temp_sb_desc;
3902
3903 /* Set state STARTED to all Out Isoc URBs added to SB list because we
3904 don't know how many of them that are finished before descr interrupt*/
3905 urb_priv->urb_state = STARTED;
3906
3907 /* Find end of current SB list by looking for SB with eol flag sat */
3908 temp_sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
3909 while ((temp_sb_desc->command & IO_MASK(USB_SB_command, eol)) !=
3910 IO_STATE(USB_SB_command, eol, yes)) {
3911 ASSERT(temp_sb_desc->next);
3912 temp_sb_desc = phys_to_virt(temp_sb_desc->next);
3913 }
3914
3915 isoc_dbg("Appended URB:0x%x[%d] (first:0x%x last:0x%x) to epid:%d"
3916 " sub:0x%x eol:0x%x\n",
3917 (unsigned int)urb, urb_priv->urb_num,
3918 (unsigned int)(urb_priv->first_sb),
3919 (unsigned int)(urb_priv->last_sb), epid,
3920 (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
3921 (unsigned int)temp_sb_desc);
3922
3923 /* Next pointer must be set before eol is removed. */
3924 temp_sb_desc->next = virt_to_phys(urb_priv->first_sb);
3925 /* Clear the previous end of list flag since there is a new in the
3926 added SB descriptor list. */
3927 temp_sb_desc->command &= ~IO_MASK(USB_SB_command, eol);
3928
3929 if (!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
3930 __u32 epid_data;
3931 /* 8.8.5 in Designer's Reference says we should check for and correct
3932 any errors in the EP here. That should not be necessary if
3933 epid_attn is handled correctly, so we assume all is ok. */
3934 epid_data = etrax_epid_iso_get(epid);
3935 if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) !=
3936 IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
3937 isoc_err("Disabled Isoc EP with error:%d on epid:%d when appending"
3938 " URB:0x%x[%d]\n",
3939 IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data), epid,
3940 (unsigned int)urb, urb_priv->urb_num);
3941 }
3942
3943 /* The SB list was exhausted. */
3944 if (virt_to_phys(urb_priv->last_sb) != TxIsocEPList[epid].sub) {
3945 /* The new sublist did not get processed before the EP was
3946 disabled. Setup the EP again. */
3947
3948 if(virt_to_phys(temp_sb_desc) == TxIsocEPList[epid].sub) {
3949 isoc_dbg("EP for epid:%d stoped at SB:0x%x before newly inserted"
3950 ", restarting from this URBs SB:0x%x\n",
3951 epid, (unsigned int)temp_sb_desc,
3952 (unsigned int)(urb_priv->first_sb));
3953 TxIsocEPList[epid].hw_len = 0;
3954 TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
3955 urb->start_frame = (*R_USB_FM_NUMBER & 0x7ff);
3956 /* Enable the EP again so data gets processed this time */
3957 TxIsocEPList[epid].command |=
3958 IO_STATE(USB_EP_command, enable, yes);
3959
3960 } else {
3961 /* The EP has been disabled but not at end this URB (god knows
3962 where). This should generate an epid_attn so we should not be
3963 here */
3964 isoc_warn("EP was disabled on sb:0x%x before SB list for"
3965 " URB:0x%x[%d] got processed\n",
3966 (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
3967 (unsigned int)urb, urb_priv->urb_num);
3968 }
3969 } else {
3970 /* This might happend if we are slow on this function and isn't
3971 an error. */
3972 isoc_dbg("EP was disabled and finished with SBs from appended"
3973 " URB:0x%x[%d]\n", (unsigned int)urb, urb_priv->urb_num);
3974 }
3975 }
3976 }
3977 }
3978
3979 /* Start the DMA sub channel */
3980 *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
3981
3982 local_irq_restore(flags);
3983 }
3984
3985 static void tc_dma_unlink_intr_urb(struct urb *urb) {
3986 struct crisv10_urb_priv *urb_priv = urb->hcpriv;
3987 volatile struct USB_EP_Desc *first_ep; /* First EP in the list. */
3988 volatile struct USB_EP_Desc *curr_ep; /* Current EP, the iterator. */
3989 volatile struct USB_EP_Desc *next_ep; /* The EP after current. */
3990 volatile struct USB_EP_Desc *unlink_ep; /* The one we should remove from
3991 the list. */
3992 int count = 0;
3993 volatile int timeout = 10000;
3994 int epid;
3995
3996 /* Read 8.8.4 in Designer's Reference, "Removing an EP Descriptor from the
3997 List". */
3998 ASSERT(urb_priv);
3999 ASSERT(urb_priv->intr_ep_pool_length > 0);
4000 epid = urb_priv->epid;
4001
4002 /* First disable all Intr EPs belonging to epid for this URB */
4003 first_ep = &TxIntrEPList[0];
4004 curr_ep = first_ep;
4005 do {
4006 next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
4007 if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
4008 /* Disable EP */
4009 next_ep->command &= ~IO_MASK(USB_EP_command, enable);
4010 }
4011 curr_ep = phys_to_virt(curr_ep->next);
4012 } while (curr_ep != first_ep);
4013
4014
4015 /* Now unlink all EPs belonging to this epid from Descr list */
4016 first_ep = &TxIntrEPList[0];
4017 curr_ep = first_ep;
4018 do {
4019 next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
4020 if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
4021 /* This is the one we should unlink. */
4022 unlink_ep = next_ep;
4023
4024 /* Actually unlink the EP from the DMA list. */
4025 curr_ep->next = unlink_ep->next;
4026
4027 /* Wait until the DMA is no longer at this descriptor. */
4028 while((*R_DMA_CH8_SUB2_EP == virt_to_phys(unlink_ep)) &&
4029 (timeout-- > 0));
4030
4031 count++;
4032 }
4033 curr_ep = phys_to_virt(curr_ep->next);
4034 } while (curr_ep != first_ep);
4035
4036 if(count != urb_priv->intr_ep_pool_length) {
4037 intr_warn("Unlinked %d of %d Intr EPs for URB:0x%x[%d]\n", count,
4038 urb_priv->intr_ep_pool_length, (unsigned int)urb,
4039 urb_priv->urb_num);
4040 } else {
4041 intr_dbg("Unlinked %d of %d interrupt EPs for URB:0x%x\n", count,
4042 urb_priv->intr_ep_pool_length, (unsigned int)urb);
4043 }
4044 }
4045
4046 static void check_finished_bulk_tx_epids(struct usb_hcd *hcd,
4047 int timer) {
4048 unsigned long flags;
4049 int epid;
4050 struct urb *urb;
4051 struct crisv10_urb_priv * urb_priv;
4052 __u32 epid_data;
4053
4054 /* Protect TxEPList */
4055 local_irq_save(flags);
4056
4057 for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
4058 /* A finished EP descriptor is disabled and has a valid sub pointer */
4059 if (!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) &&
4060 (TxBulkEPList[epid].sub != 0)) {
4061
4062 /* Get the active URB for this epid */
4063 urb = activeUrbList[epid];
4064 /* Sanity checks */
4065 ASSERT(urb);
4066 urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4067 ASSERT(urb_priv);
4068
4069 /* Only handle finished out Bulk EPs here,
4070 and let RX interrupt take care of the rest */
4071 if(!epid_out_traffic(epid)) {
4072 continue;
4073 }
4074
4075 if(timer) {
4076 tc_warn("Found finished %s Bulk epid:%d URB:0x%x[%d] from timeout\n",
4077 epid_out_traffic(epid) ? "Out" : "In", epid, (unsigned int)urb,
4078 urb_priv->urb_num);
4079 } else {
4080 tc_dbg("Found finished %s Bulk epid:%d URB:0x%x[%d] from interrupt\n",
4081 epid_out_traffic(epid) ? "Out" : "In", epid, (unsigned int)urb,
4082 urb_priv->urb_num);
4083 }
4084
4085 if(urb_priv->urb_state == UNLINK) {
4086 /* This Bulk URB is requested to be unlinked, that means that the EP
4087 has been disabled and we might not have sent all data */
4088 tc_finish_urb(hcd, urb, urb->status);
4089 continue;
4090 }
4091
4092 ASSERT(urb_priv->urb_state == STARTED);
4093 if (phys_to_virt(TxBulkEPList[epid].sub) != urb_priv->last_sb) {
4094 tc_err("Endpoint got disabled before reaching last sb\n");
4095 }
4096
4097 epid_data = etrax_epid_get(epid);
4098 if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) ==
4099 IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
4100 /* This means that the endpoint has no error, is disabled
4101 and had inserted traffic, i.e. transfer successfully completed. */
4102 tc_finish_urb(hcd, urb, 0);
4103 } else {
4104 /* Shouldn't happen. We expect errors to be caught by epid
4105 attention. */
4106 tc_err("Found disabled bulk EP desc (epid:%d error:%d)\n",
4107 epid, IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data));
4108 }
4109 } else {
4110 tc_dbg("Ignoring In Bulk epid:%d, let RX interrupt handle it\n", epid);
4111 }
4112 }
4113
4114 local_irq_restore(flags);
4115 }
4116
4117 static void check_finished_ctrl_tx_epids(struct usb_hcd *hcd) {
4118 unsigned long flags;
4119 int epid;
4120 struct urb *urb;
4121 struct crisv10_urb_priv * urb_priv;
4122 __u32 epid_data;
4123
4124 /* Protect TxEPList */
4125 local_irq_save(flags);
4126
4127 for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
4128 if(epid == DUMMY_EPID)
4129 continue;
4130
4131 /* A finished EP descriptor is disabled and has a valid sub pointer */
4132 if (!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) &&
4133 (TxCtrlEPList[epid].sub != 0)) {
4134
4135 /* Get the active URB for this epid */
4136 urb = activeUrbList[epid];
4137
4138 if(urb == NULL) {
4139 tc_warn("Found finished Ctrl epid:%d with no active URB\n", epid);
4140 continue;
4141 }
4142
4143 /* Sanity checks */
4144 ASSERT(usb_pipein(urb->pipe));
4145 urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4146 ASSERT(urb_priv);
4147 if (phys_to_virt(TxCtrlEPList[epid].sub) != urb_priv->last_sb) {
4148 tc_err("Endpoint got disabled before reaching last sb\n");
4149 }
4150
4151 epid_data = etrax_epid_get(epid);
4152 if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) ==
4153 IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
4154 /* This means that the endpoint has no error, is disabled
4155 and had inserted traffic, i.e. transfer successfully completed. */
4156
4157 /* Check if RX-interrupt for In Ctrl has been processed before
4158 finishing the URB */
4159 if(urb_priv->ctrl_rx_done) {
4160 tc_dbg("Finishing In Ctrl URB:0x%x[%d] in tx_interrupt\n",
4161 (unsigned int)urb, urb_priv->urb_num);
4162 tc_finish_urb(hcd, urb, 0);
4163 } else {
4164 /* If we get zout descriptor interrupt before RX was done for a
4165 In Ctrl transfer, then we flag that and it will be finished
4166 in the RX-Interrupt */
4167 urb_priv->ctrl_zout_done = 1;
4168 tc_dbg("Got zout descr interrupt before RX interrupt\n");
4169 }
4170 } else {
4171 /* Shouldn't happen. We expect errors to be caught by epid
4172 attention. */
4173 tc_err("Found disabled Ctrl EP desc (epid:%d URB:0x%x[%d]) error_code:%d\n", epid, (unsigned int)urb, urb_priv->urb_num, IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data));
4174 __dump_ep_desc(&(TxCtrlEPList[epid]));
4175 __dump_ept_data(epid);
4176 }
4177 }
4178 }
4179 local_irq_restore(flags);
4180 }
4181
4182 /* This function goes through all epids that are setup for Out Isoc transfers
4183 and marks (isoc_out_done) all queued URBs that the DMA has finished
4184 transfer for.
4185 No URB completetion is done here to make interrupt routine return quickly.
4186 URBs are completed later with help of complete_isoc_bottom_half() that
4187 becomes schedules when this functions is finished. */
4188 static void check_finished_isoc_tx_epids(void) {
4189 unsigned long flags;
4190 int epid;
4191 struct urb *urb;
4192 struct crisv10_urb_priv * urb_priv;
4193 struct USB_SB_Desc* sb_desc;
4194 int epid_done;
4195
4196 /* Protect TxIsocEPList */
4197 local_irq_save(flags);
4198
4199 for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
4200 if (TxIsocEPList[epid].sub == 0 || epid == INVALID_EPID ||
4201 !epid_out_traffic(epid)) {
4202 /* Nothing here to see. */
4203 continue;
4204 }
4205 ASSERT(epid_inuse(epid));
4206 ASSERT(epid_isoc(epid));
4207
4208 sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
4209 /* Find the last descriptor of the currently active URB for this ep.
4210 This is the first descriptor in the sub list marked for a descriptor
4211 interrupt. */
4212 while (sb_desc && !IO_EXTRACT(USB_SB_command, intr, sb_desc->command)) {
4213 sb_desc = sb_desc->next ? phys_to_virt(sb_desc->next) : 0;
4214 }
4215 ASSERT(sb_desc);
4216
4217 isoc_dbg("Descr IRQ checking epid:%d sub:0x%x intr:0x%x\n",
4218 epid, (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
4219 (unsigned int)sb_desc);
4220
4221 urb = activeUrbList[epid];
4222 if(urb == NULL) {
4223 isoc_err("Isoc Descr irq on epid:%d with no active URB\n", epid);
4224 continue;
4225 }
4226
4227 epid_done = 0;
4228 while(urb && !epid_done) {
4229 /* Sanity check. */
4230 ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
4231 ASSERT(usb_pipeout(urb->pipe));
4232
4233 urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4234 ASSERT(urb_priv);
4235 ASSERT(urb_priv->urb_state == STARTED ||
4236 urb_priv->urb_state == UNLINK);
4237
4238 if (sb_desc != urb_priv->last_sb) {
4239 /* This urb has been sent. */
4240 urb_priv->isoc_out_done = 1;
4241
4242 } else { /* Found URB that has last_sb as the interrupt reason */
4243
4244 /* Check if EP has been disabled, meaning that all transfers are done*/
4245 if(!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
4246 ASSERT((sb_desc->command & IO_MASK(USB_SB_command, eol)) ==
4247 IO_STATE(USB_SB_command, eol, yes));
4248 ASSERT(sb_desc->next == 0);
4249 urb_priv->isoc_out_done = 1;
4250 } else {
4251 isoc_dbg("Skipping URB:0x%x[%d] because EP not disabled yet\n",
4252 (unsigned int)urb, urb_priv->urb_num);
4253 }
4254 /* Stop looking any further in queue */
4255 epid_done = 1;
4256 }
4257
4258 if (!epid_done) {
4259 if(urb == activeUrbList[epid]) {
4260 urb = urb_list_first(epid);
4261 } else {
4262 urb = urb_list_next(urb, epid);
4263 }
4264 }
4265 } /* END: while(urb && !epid_done) */
4266 }
4267
4268 local_irq_restore(flags);
4269 }
4270
4271
4272 /* This is where the Out Isoc URBs are realy completed. This function is
4273 scheduled from tc_dma_tx_interrupt() when one or more Out Isoc transfers
4274 are done. This functions completes all URBs earlier marked with
4275 isoc_out_done by fast interrupt routine check_finished_isoc_tx_epids() */
4276
4277 static void complete_isoc_bottom_half(struct work_struct* work) {
4278 struct crisv10_isoc_complete_data *comp_data;
4279 struct usb_iso_packet_descriptor *packet;
4280 struct crisv10_urb_priv * urb_priv;
4281 unsigned long flags;
4282 struct urb* urb;
4283 int epid_done;
4284 int epid;
4285 int i;
4286
4287 comp_data = container_of(work, struct crisv10_isoc_complete_data, usb_bh);
4288
4289 local_irq_save(flags);
4290
4291 for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
4292 if(!epid_inuse(epid) || !epid_isoc(epid) || !epid_out_traffic(epid) || epid == DUMMY_EPID) {
4293 /* Only check valid Out Isoc epids */
4294 continue;
4295 }
4296
4297 isoc_dbg("Isoc bottom-half checking epid:%d, sub:0x%x\n", epid,
4298 (unsigned int)phys_to_virt(TxIsocEPList[epid].sub));
4299
4300 /* The descriptor interrupt handler has marked all transmitted Out Isoc
4301 URBs with isoc_out_done. Now we traverse all epids and for all that
4302 have out Isoc traffic we traverse its URB list and complete the
4303 transmitted URBs. */
4304 epid_done = 0;
4305 while (!epid_done) {
4306
4307 /* Get the active urb (if any) */
4308 urb = activeUrbList[epid];
4309 if (urb == 0) {
4310 isoc_dbg("No active URB on epid:%d anymore\n", epid);
4311 epid_done = 1;
4312 continue;
4313 }
4314
4315 /* Sanity check. */
4316 ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
4317 ASSERT(usb_pipeout(urb->pipe));
4318
4319 urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4320 ASSERT(urb_priv);
4321
4322 if (!(urb_priv->isoc_out_done)) {
4323 /* We have reached URB that isn't flaged done yet, stop traversing. */
4324 isoc_dbg("Stoped traversing Out Isoc URBs on epid:%d"
4325 " before not yet flaged URB:0x%x[%d]\n",
4326 epid, (unsigned int)urb, urb_priv->urb_num);
4327 epid_done = 1;
4328 continue;
4329 }
4330
4331 /* This urb has been sent. */
4332 isoc_dbg("Found URB:0x%x[%d] that is flaged isoc_out_done\n",
4333 (unsigned int)urb, urb_priv->urb_num);
4334
4335 /* Set ok on transfered packets for this URB and finish it */
4336 for (i = 0; i < urb->number_of_packets; i++) {
4337 packet = &urb->iso_frame_desc[i];
4338 packet->status = 0;
4339 packet->actual_length = packet->length;
4340 }
4341 urb_priv->isoc_packet_counter = urb->number_of_packets;
4342 tc_finish_urb(comp_data->hcd, urb, 0);
4343
4344 } /* END: while(!epid_done) */
4345 } /* END: for(epid...) */
4346
4347 local_irq_restore(flags);
4348 kmem_cache_free(isoc_compl_cache, comp_data);
4349 }
4350
4351
4352 static void check_finished_intr_tx_epids(struct usb_hcd *hcd) {
4353 unsigned long flags;
4354 int epid;
4355 struct urb *urb;
4356 struct crisv10_urb_priv * urb_priv;
4357 volatile struct USB_EP_Desc *curr_ep; /* Current EP, the iterator. */
4358 volatile struct USB_EP_Desc *next_ep; /* The EP after current. */
4359
4360 /* Protect TxintrEPList */
4361 local_irq_save(flags);
4362
4363 for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
4364 if(!epid_inuse(epid) || !epid_intr(epid) || !epid_out_traffic(epid)) {
4365 /* Nothing to see on this epid. Only check valid Out Intr epids */
4366 continue;
4367 }
4368
4369 urb = activeUrbList[epid];
4370 if(urb == 0) {
4371 intr_warn("Found Out Intr epid:%d with no active URB\n", epid);
4372 continue;
4373 }
4374
4375 /* Sanity check. */
4376 ASSERT(usb_pipetype(urb->pipe) == PIPE_INTERRUPT);
4377 ASSERT(usb_pipeout(urb->pipe));
4378
4379 urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4380 ASSERT(urb_priv);
4381
4382 /* Go through EPs between first and second sof-EP. It's here Out Intr EPs
4383 are inserted.*/
4384 curr_ep = &TxIntrEPList[0];
4385 do {
4386 next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
4387 if(next_ep == urb_priv->intr_ep_pool[0]) {
4388 /* We found the Out Intr EP for this epid */
4389
4390 /* Disable it so it doesn't get processed again */
4391 next_ep->command &= ~IO_MASK(USB_EP_command, enable);
4392
4393 /* Finish the active Out Intr URB with status OK */
4394 tc_finish_urb(hcd, urb, 0);
4395 }
4396 curr_ep = phys_to_virt(curr_ep->next);
4397 } while (curr_ep != &TxIntrEPList[1]);
4398
4399 }
4400 local_irq_restore(flags);
4401 }
4402
4403 /* Interrupt handler for DMA8/IRQ24 with subchannels (called from hardware intr) */
4404 static irqreturn_t tc_dma_tx_interrupt(int irq, void *vhc) {
4405 struct usb_hcd *hcd = (struct usb_hcd*)vhc;
4406 ASSERT(hcd);
4407
4408 if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub0_descr)) {
4409 /* Clear this interrupt */
4410 *R_DMA_CH8_SUB0_CLR_INTR = IO_STATE(R_DMA_CH8_SUB0_CLR_INTR, clr_descr, do);
4411 restart_dma8_sub0();
4412 }
4413
4414 if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub1_descr)) {
4415 /* Clear this interrupt */
4416 *R_DMA_CH8_SUB1_CLR_INTR = IO_STATE(R_DMA_CH8_SUB1_CLR_INTR, clr_descr, do);
4417 check_finished_ctrl_tx_epids(hcd);
4418 }
4419
4420 if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub2_descr)) {
4421 /* Clear this interrupt */
4422 *R_DMA_CH8_SUB2_CLR_INTR = IO_STATE(R_DMA_CH8_SUB2_CLR_INTR, clr_descr, do);
4423 check_finished_intr_tx_epids(hcd);
4424 }
4425
4426 if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub3_descr)) {
4427 struct crisv10_isoc_complete_data* comp_data;
4428
4429 /* Flag done Out Isoc for later completion */
4430 check_finished_isoc_tx_epids();
4431
4432 /* Clear this interrupt */
4433 *R_DMA_CH8_SUB3_CLR_INTR = IO_STATE(R_DMA_CH8_SUB3_CLR_INTR, clr_descr, do);
4434 /* Schedule bottom half of Out Isoc completion function. This function
4435 finishes the URBs marked with isoc_out_done */
4436 comp_data = (struct crisv10_isoc_complete_data*)
4437 kmem_cache_alloc(isoc_compl_cache, GFP_ATOMIC);
4438 ASSERT(comp_data != NULL);
4439 comp_data ->hcd = hcd;
4440
4441 INIT_WORK(&comp_data->usb_bh, complete_isoc_bottom_half);
4442 schedule_work(&comp_data->usb_bh);
4443 }
4444
4445 return IRQ_HANDLED;
4446 }
4447
4448 /* Interrupt handler for DMA9/IRQ25 (called from hardware intr) */
4449 static irqreturn_t tc_dma_rx_interrupt(int irq, void *vhc) {
4450 unsigned long flags;
4451 struct urb *urb;
4452 struct usb_hcd *hcd = (struct usb_hcd*)vhc;
4453 struct crisv10_urb_priv *urb_priv;
4454 int epid = 0;
4455 int real_error;
4456
4457 ASSERT(hcd);
4458
4459 /* Clear this interrupt. */
4460 *R_DMA_CH9_CLR_INTR = IO_STATE(R_DMA_CH9_CLR_INTR, clr_eop, do);
4461
4462 /* Custom clear interrupt for this interrupt */
4463 /* The reason we cli here is that we call the driver's callback functions. */
4464 local_irq_save(flags);
4465
4466 /* Note that this while loop assumes that all packets span only
4467 one rx descriptor. */
4468 while(myNextRxDesc->status & IO_MASK(USB_IN_status, eop)) {
4469 epid = IO_EXTRACT(USB_IN_status, epid, myNextRxDesc->status);
4470 /* Get the active URB for this epid */
4471 urb = activeUrbList[epid];
4472
4473 ASSERT(epid_inuse(epid));
4474 if (!urb) {
4475 dma_err("No urb for epid %d in rx interrupt\n", epid);
4476 goto skip_out;
4477 }
4478
4479 /* Check if any errors on epid */
4480 real_error = 0;
4481 if (myNextRxDesc->status & IO_MASK(USB_IN_status, error)) {
4482 __u32 r_usb_ept_data;
4483
4484 if (usb_pipeisoc(urb->pipe)) {
4485 r_usb_ept_data = etrax_epid_iso_get(epid);
4486 if((r_usb_ept_data & IO_MASK(R_USB_EPT_DATA_ISO, valid)) &&
4487 (IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code, r_usb_ept_data) == 0) &&
4488 (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata))) {
4489 /* Not an error, just a failure to receive an expected iso
4490 in packet in this frame. This is not documented
4491 in the designers reference. Continue processing.
4492 */
4493 } else real_error = 1;
4494 } else real_error = 1;
4495 }
4496
4497 if(real_error) {
4498 dma_err("Error in RX descr on epid:%d for URB 0x%x",
4499 epid, (unsigned int)urb);
4500 dump_ept_data(epid);
4501 dump_in_desc(myNextRxDesc);
4502 goto skip_out;
4503 }
4504
4505 urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4506 ASSERT(urb_priv);
4507 ASSERT(urb_priv->urb_state == STARTED ||
4508 urb_priv->urb_state == UNLINK);
4509
4510 if ((usb_pipetype(urb->pipe) == PIPE_BULK) ||
4511 (usb_pipetype(urb->pipe) == PIPE_CONTROL) ||
4512 (usb_pipetype(urb->pipe) == PIPE_INTERRUPT)) {
4513
4514 /* We get nodata for empty data transactions, and the rx descriptor's
4515 hw_len field is not valid in that case. No data to copy in other
4516 words. */
4517 if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
4518 /* No data to copy */
4519 } else {
4520 /*
4521 dma_dbg("Processing RX for URB:0x%x epid:%d (data:%d ofs:%d)\n",
4522 (unsigned int)urb, epid, myNextRxDesc->hw_len,
4523 urb_priv->rx_offset);
4524 */
4525 /* Only copy data if URB isn't flaged to be unlinked*/
4526 if(urb_priv->urb_state != UNLINK) {
4527 /* Make sure the data fits in the buffer. */
4528 if(urb_priv->rx_offset + myNextRxDesc->hw_len
4529 <= urb->transfer_buffer_length) {
4530
4531 /* Copy the data to URBs buffer */
4532 memcpy(urb->transfer_buffer + urb_priv->rx_offset,
4533 phys_to_virt(myNextRxDesc->buf), myNextRxDesc->hw_len);
4534 urb_priv->rx_offset += myNextRxDesc->hw_len;
4535 } else {
4536 /* Signal overflow when returning URB */
4537 urb->status = -EOVERFLOW;
4538 tc_finish_urb_later(hcd, urb, urb->status);
4539 }
4540 }
4541 }
4542
4543 /* Check if it was the last packet in the transfer */
4544 if (myNextRxDesc->status & IO_MASK(USB_IN_status, eot)) {
4545 /* Special handling for In Ctrl URBs. */
4546 if(usb_pipecontrol(urb->pipe) && usb_pipein(urb->pipe) &&
4547 !(urb_priv->ctrl_zout_done)) {
4548 /* Flag that RX part of Ctrl transfer is done. Because zout descr
4549 interrupt hasn't happend yet will the URB be finished in the
4550 TX-Interrupt. */
4551 urb_priv->ctrl_rx_done = 1;
4552 tc_dbg("Not finishing In Ctrl URB:0x%x from rx_interrupt, waiting"
4553 " for zout\n", (unsigned int)urb);
4554 } else {
4555 tc_finish_urb(hcd, urb, 0);
4556 }
4557 }
4558 } else { /* ISOC RX */
4559 /*
4560 isoc_dbg("Processing RX for epid:%d (URB:0x%x) ISOC pipe\n",
4561 epid, (unsigned int)urb);
4562 */
4563
4564 struct usb_iso_packet_descriptor *packet;
4565
4566 if (urb_priv->urb_state == UNLINK) {
4567 isoc_warn("Ignoring Isoc Rx data for urb being unlinked.\n");
4568 goto skip_out;
4569 } else if (urb_priv->urb_state == NOT_STARTED) {
4570 isoc_err("What? Got Rx data for Isoc urb that isn't started?\n");
4571 goto skip_out;
4572 }
4573
4574 packet = &urb->iso_frame_desc[urb_priv->isoc_packet_counter];
4575 ASSERT(packet);
4576 packet->status = 0;
4577
4578 if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
4579 /* We get nodata for empty data transactions, and the rx descriptor's
4580 hw_len field is not valid in that case. We copy 0 bytes however to
4581 stay in synch. */
4582 packet->actual_length = 0;
4583 } else {
4584 packet->actual_length = myNextRxDesc->hw_len;
4585 /* Make sure the data fits in the buffer. */
4586 ASSERT(packet->actual_length <= packet->length);
4587 memcpy(urb->transfer_buffer + packet->offset,
4588 phys_to_virt(myNextRxDesc->buf), packet->actual_length);
4589 if(packet->actual_length > 0)
4590 isoc_dbg("Copied %d bytes, packet %d for URB:0x%x[%d]\n",
4591 packet->actual_length, urb_priv->isoc_packet_counter,
4592 (unsigned int)urb, urb_priv->urb_num);
4593 }
4594
4595 /* Increment the packet counter. */
4596 urb_priv->isoc_packet_counter++;
4597
4598 /* Note that we don't care about the eot field in the rx descriptor's
4599 status. It will always be set for isoc traffic. */
4600 if (urb->number_of_packets == urb_priv->isoc_packet_counter) {
4601 /* Complete the urb with status OK. */
4602 tc_finish_urb(hcd, urb, 0);
4603 }
4604 }
4605
4606 skip_out:
4607 myNextRxDesc->status = 0;
4608 myNextRxDesc->command |= IO_MASK(USB_IN_command, eol);
4609 myLastRxDesc->command &= ~IO_MASK(USB_IN_command, eol);
4610 myLastRxDesc = myNextRxDesc;
4611 myNextRxDesc = phys_to_virt(myNextRxDesc->next);
4612 flush_etrax_cache();
4613 *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, restart);
4614 }
4615
4616 local_irq_restore(flags);
4617
4618 return IRQ_HANDLED;
4619 }
4620
4621 static void tc_bulk_start_timer_func(unsigned long dummy) {
4622 /* We might enable an EP descriptor behind the current DMA position when
4623 it's about to decide that there are no more bulk traffic and it should
4624 stop the bulk channel.
4625 Therefore we periodically check if the bulk channel is stopped and there
4626 is an enabled bulk EP descriptor, in which case we start the bulk
4627 channel. */
4628
4629 if (!(*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd))) {
4630 int epid;
4631
4632 timer_dbg("bulk_start_timer: Bulk DMA channel not running.\n");
4633
4634 for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
4635 if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
4636 timer_warn("Found enabled EP for epid %d, starting bulk channel.\n",
4637 epid);
4638 restart_dma8_sub0();
4639
4640 /* Restart the bulk eot timer since we just started the bulk channel.*/
4641 mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
4642
4643 /* No need to search any further. */
4644 break;
4645 }
4646 }
4647 } else {
4648 timer_dbg("bulk_start_timer: Bulk DMA channel running.\n");
4649 }
4650 }
4651
4652 static void tc_bulk_eot_timer_func(unsigned long dummy) {
4653 struct usb_hcd *hcd = (struct usb_hcd*)dummy;
4654 ASSERT(hcd);
4655 /* Because of a race condition in the top half, we might miss a bulk eot.
4656 This timer "simulates" a bulk eot if we don't get one for a while,
4657 hopefully correcting the situation. */
4658 timer_dbg("bulk_eot_timer timed out.\n");
4659 check_finished_bulk_tx_epids(hcd, 1);
4660 }
4661
4662
4663 /*************************************************************/
4664 /*************************************************************/
4665 /* Device driver block */
4666 /*************************************************************/
4667 /*************************************************************/
4668
4669 /* Forward declarations for device driver functions */
4670 static int devdrv_hcd_probe(struct device *);
4671 static int devdrv_hcd_remove(struct device *);
4672 #ifdef CONFIG_PM
4673 static int devdrv_hcd_suspend(struct device *, u32, u32);
4674 static int devdrv_hcd_resume(struct device *, u32);
4675 #endif /* CONFIG_PM */
4676
4677 /* the device */
4678 static struct platform_device *devdrv_hc_platform_device;
4679
4680 /* device driver interface */
4681 static struct device_driver devdrv_hc_device_driver = {
4682 .name = (char *) hc_name,
4683 .bus = &platform_bus_type,
4684
4685 .probe = devdrv_hcd_probe,
4686 .remove = devdrv_hcd_remove,
4687
4688 #ifdef CONFIG_PM
4689 .suspend = devdrv_hcd_suspend,
4690 .resume = devdrv_hcd_resume,
4691 #endif /* CONFIG_PM */
4692 };
4693
4694 /* initialize the host controller and driver */
4695 static int __init_or_module devdrv_hcd_probe(struct device *dev)
4696 {
4697 struct usb_hcd *hcd;
4698 struct crisv10_hcd *crisv10_hcd;
4699 int retval;
4700
4701 /* Check DMA burst length */
4702 if(IO_EXTRACT(R_BUS_CONFIG, dma_burst, *R_BUS_CONFIG) !=
4703 IO_STATE(R_BUS_CONFIG, dma_burst, burst32)) {
4704 devdrv_err("Invalid DMA burst length in Etrax 100LX,"
4705 " needs to be 32\n");
4706 return -EPERM;
4707 }
4708
4709 hcd = usb_create_hcd(&crisv10_hc_driver, dev, dev_name(dev));
4710 if (!hcd)
4711 return -ENOMEM;
4712
4713 crisv10_hcd = hcd_to_crisv10_hcd(hcd);
4714 spin_lock_init(&crisv10_hcd->lock);
4715 crisv10_hcd->num_ports = num_ports();
4716 crisv10_hcd->running = 0;
4717
4718 dev_set_drvdata(dev, crisv10_hcd);
4719
4720 devdrv_dbg("ETRAX USB IRQs HC:%d RX:%d TX:%d\n", ETRAX_USB_HC_IRQ,
4721 ETRAX_USB_RX_IRQ, ETRAX_USB_TX_IRQ);
4722
4723 /* Print out chip version read from registers */
4724 int rev_maj = *R_USB_REVISION & IO_MASK(R_USB_REVISION, major);
4725 int rev_min = *R_USB_REVISION & IO_MASK(R_USB_REVISION, minor);
4726 if(rev_min == 0) {
4727 devdrv_info("Etrax 100LX USB Revision %d v1,2\n", rev_maj);
4728 } else {
4729 devdrv_info("Etrax 100LX USB Revision %d v%d\n", rev_maj, rev_min);
4730 }
4731
4732 devdrv_info("Bulk timer interval, start:%d eot:%d\n",
4733 BULK_START_TIMER_INTERVAL,
4734 BULK_EOT_TIMER_INTERVAL);
4735
4736
4737 /* Init root hub data structures */
4738 if(rh_init()) {
4739 devdrv_err("Failed init data for Root Hub\n");
4740 retval = -ENOMEM;
4741 }
4742
4743 if(port_in_use(0)) {
4744 if (cris_request_io_interface(if_usb_1, "ETRAX100LX USB-HCD")) {
4745 printk(KERN_CRIT "usb-host: request IO interface usb1 failed");
4746 retval = -EBUSY;
4747 goto out;
4748 }
4749 devdrv_info("Claimed interface for USB physical port 1\n");
4750 }
4751 if(port_in_use(1)) {
4752 if (cris_request_io_interface(if_usb_2, "ETRAX100LX USB-HCD")) {
4753 /* Free first interface if second failed to be claimed */
4754 if(port_in_use(0)) {
4755 cris_free_io_interface(if_usb_1);
4756 }
4757 printk(KERN_CRIT "usb-host: request IO interface usb2 failed");
4758 retval = -EBUSY;
4759 goto out;
4760 }
4761 devdrv_info("Claimed interface for USB physical port 2\n");
4762 }
4763
4764 /* Init transfer controller structs and locks */
4765 if((retval = tc_init(hcd)) != 0) {
4766 goto out;
4767 }
4768
4769 /* Attach interrupt functions for DMA and init DMA controller */
4770 if((retval = tc_dma_init(hcd)) != 0) {
4771 goto out;
4772 }
4773
4774 /* Attach the top IRQ handler for USB controller interrupts */
4775 if (request_irq(ETRAX_USB_HC_IRQ, crisv10_hcd_top_irq, 0,
4776 "ETRAX 100LX built-in USB (HC)", hcd)) {
4777 err("Could not allocate IRQ %d for USB", ETRAX_USB_HC_IRQ);
4778 retval = -EBUSY;
4779 goto out;
4780 }
4781
4782 /* iso_eof is only enabled when isoc traffic is running. */
4783 *R_USB_IRQ_MASK_SET =
4784 /* IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set) | */
4785 IO_STATE(R_USB_IRQ_MASK_SET, bulk_eot, set) |
4786 IO_STATE(R_USB_IRQ_MASK_SET, epid_attn, set) |
4787 IO_STATE(R_USB_IRQ_MASK_SET, port_status, set) |
4788 IO_STATE(R_USB_IRQ_MASK_SET, ctl_status, set);
4789
4790
4791 crisv10_ready_wait();
4792 /* Reset the USB interface. */
4793 *R_USB_COMMAND =
4794 IO_STATE(R_USB_COMMAND, port_sel, nop) |
4795 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4796 IO_STATE(R_USB_COMMAND, ctrl_cmd, reset);
4797
4798 /* Designer's Reference, p. 8 - 10 says we should Initate R_USB_FM_PSTART to
4799 0x2A30 (10800), to guarantee that control traffic gets 10% of the
4800 bandwidth, and periodic transfer may allocate the rest (90%).
4801 This doesn't work though.
4802 The value 11960 is chosen to be just after the SOF token, with a couple
4803 of bit times extra for possible bit stuffing. */
4804 *R_USB_FM_PSTART = IO_FIELD(R_USB_FM_PSTART, value, 11960);
4805
4806 crisv10_ready_wait();
4807 /* Configure the USB interface as a host controller. */
4808 *R_USB_COMMAND =
4809 IO_STATE(R_USB_COMMAND, port_sel, nop) |
4810 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4811 IO_STATE(R_USB_COMMAND, ctrl_cmd, host_config);
4812
4813
4814 /* Check so controller not busy before enabling ports */
4815 crisv10_ready_wait();
4816
4817 /* Enable selected USB ports */
4818 if(port_in_use(0)) {
4819 *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
4820 } else {
4821 *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
4822 }
4823 if(port_in_use(1)) {
4824 *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no);
4825 } else {
4826 *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, yes);
4827 }
4828
4829 crisv10_ready_wait();
4830 /* Start processing of USB traffic. */
4831 *R_USB_COMMAND =
4832 IO_STATE(R_USB_COMMAND, port_sel, nop) |
4833 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4834 IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
4835
4836 /* Do not continue probing initialization before USB interface is done */
4837 crisv10_ready_wait();
4838
4839 /* Register our Host Controller to USB Core
4840 * Finish the remaining parts of generic HCD initialization: allocate the
4841 * buffers of consistent memory, register the bus
4842 * and call the driver's reset() and start() routines. */
4843 retval = usb_add_hcd(hcd, ETRAX_USB_HC_IRQ, IRQF_DISABLED);
4844 if (retval != 0) {
4845 devdrv_err("Failed registering HCD driver\n");
4846 goto out;
4847 }
4848
4849 return 0;
4850
4851 out:
4852 devdrv_hcd_remove(dev);
4853 return retval;
4854 }
4855
4856
4857 /* cleanup after the host controller and driver */
4858 static int __init_or_module devdrv_hcd_remove(struct device *dev)
4859 {
4860 struct crisv10_hcd *crisv10_hcd = dev_get_drvdata(dev);
4861 struct usb_hcd *hcd;
4862
4863 if (!crisv10_hcd)
4864 return 0;
4865 hcd = crisv10_hcd_to_hcd(crisv10_hcd);
4866
4867
4868 /* Stop USB Controller in Etrax 100LX */
4869 crisv10_hcd_reset(hcd);
4870
4871 usb_remove_hcd(hcd);
4872 devdrv_dbg("Removed HCD from USB Core\n");
4873
4874 /* Free USB Controller IRQ */
4875 free_irq(ETRAX_USB_HC_IRQ, NULL);
4876
4877 /* Free resources */
4878 tc_dma_destroy();
4879 tc_destroy();
4880
4881
4882 if(port_in_use(0)) {
4883 cris_free_io_interface(if_usb_1);
4884 }
4885 if(port_in_use(1)) {
4886 cris_free_io_interface(if_usb_2);
4887 }
4888
4889 devdrv_dbg("Freed all claimed resources\n");
4890
4891 return 0;
4892 }
4893
4894
4895 #ifdef CONFIG_PM
4896
4897 static int devdrv_hcd_suspend(struct usb_hcd *hcd, u32 state, u32 level)
4898 {
4899 return 0; /* no-op for now */
4900 }
4901
4902 static int devdrv_hcd_resume(struct usb_hcd *hcd, u32 level)
4903 {
4904 return 0; /* no-op for now */
4905 }
4906
4907 #endif /* CONFIG_PM */
4908
4909
4910 /*************************************************************/
4911 /*************************************************************/
4912 /* Module block */
4913 /*************************************************************/
4914 /*************************************************************/
4915
4916 /* register driver */
4917 static int __init module_hcd_init(void)
4918 {
4919
4920 if (usb_disabled())
4921 return -ENODEV;
4922
4923 /* Here we select enabled ports by following defines created from
4924 menuconfig */
4925 #ifndef CONFIG_ETRAX_USB_HOST_PORT1
4926 ports &= ~(1<<0);
4927 #endif
4928 #ifndef CONFIG_ETRAX_USB_HOST_PORT2
4929 ports &= ~(1<<1);
4930 #endif
4931
4932 printk(KERN_INFO "%s version "VERSION" "COPYRIGHT"\n", product_desc);
4933
4934 devdrv_hc_platform_device =
4935 platform_device_register_simple((char *) hc_name, 0, NULL, 0);
4936
4937 if (IS_ERR(devdrv_hc_platform_device))
4938 return PTR_ERR(devdrv_hc_platform_device);
4939 return driver_register(&devdrv_hc_device_driver);
4940 /*
4941 * Note that we do not set the DMA mask for the device,
4942 * i.e. we pretend that we will use PIO, since no specific
4943 * allocation routines are needed for DMA buffers. This will
4944 * cause the HCD buffer allocation routines to fall back to
4945 * kmalloc().
4946 */
4947 }
4948
4949 /* unregister driver */
4950 static void __exit module_hcd_exit(void)
4951 {
4952 driver_unregister(&devdrv_hc_device_driver);
4953 }
4954
4955
4956 /* Module hooks */
4957 module_init(module_hcd_init);
4958 module_exit(module_hcd_exit);
4959
Personal OpenWRT clone
This page took 0.313841 seconds and 5 git commands to generate.