projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / usb / host / hc_crisv10.c
1 /*
2 * usb-host.c: ETRAX 100LX USB Host Controller Driver (HCD)
3 *
4 * Copyright (c) 2002, 2003 Axis Communications AB.
5 */
6
7 #include <linux/kernel.h>
8 #include <linux/delay.h>
9 #include <linux/ioport.h>
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/errno.h>
13 #include <linux/unistd.h>
14 #include <linux/interrupt.h>
15 #include <linux/init.h>
16 #include <linux/list.h>
17 #include <linux/spinlock.h>
18
19 #include <asm/uaccess.h>
20 #include <asm/io.h>
21 #include <asm/irq.h>
22 #include <asm/dma.h>
23 #include <asm/system.h>
24 #include <asm/arch/svinto.h>
25
26 #include <linux/usb.h>
27 /* Ugly include because we don't live with the other host drivers. */
28 #include <../drivers/usb/core/hcd.h>
29 #include <../drivers/usb/core/usb.h>
30
31 #include "hc_crisv10.h"
32
33 #define ETRAX_USB_HC_IRQ USB_HC_IRQ_NBR
34 #define ETRAX_USB_RX_IRQ USB_DMA_RX_IRQ_NBR
35 #define ETRAX_USB_TX_IRQ USB_DMA_TX_IRQ_NBR
36
37 static const char *usb_hcd_version = "$Revision: 1.2 $";
38
39 #undef KERN_DEBUG
40 #define KERN_DEBUG ""
41
42
43 #undef USB_DEBUG_RH
44 #undef USB_DEBUG_EPID
45 #undef USB_DEBUG_SB
46 #undef USB_DEBUG_DESC
47 #undef USB_DEBUG_URB
48 #undef USB_DEBUG_TRACE
49 #undef USB_DEBUG_BULK
50 #undef USB_DEBUG_CTRL
51 #undef USB_DEBUG_INTR
52 #undef USB_DEBUG_ISOC
53
54 #ifdef USB_DEBUG_RH
55 #define dbg_rh(format, arg...) printk(KERN_DEBUG __FILE__ ": (RH) " format "\n" , ## arg)
56 #else
57 #define dbg_rh(format, arg...) do {} while (0)
58 #endif
59
60 #ifdef USB_DEBUG_EPID
61 #define dbg_epid(format, arg...) printk(KERN_DEBUG __FILE__ ": (EPID) " format "\n" , ## arg)
62 #else
63 #define dbg_epid(format, arg...) do {} while (0)
64 #endif
65
66 #ifdef USB_DEBUG_SB
67 #define dbg_sb(format, arg...) printk(KERN_DEBUG __FILE__ ": (SB) " format "\n" , ## arg)
68 #else
69 #define dbg_sb(format, arg...) do {} while (0)
70 #endif
71
72 #ifdef USB_DEBUG_CTRL
73 #define dbg_ctrl(format, arg...) printk(KERN_DEBUG __FILE__ ": (CTRL) " format "\n" , ## arg)
74 #else
75 #define dbg_ctrl(format, arg...) do {} while (0)
76 #endif
77
78 #ifdef USB_DEBUG_BULK
79 #define dbg_bulk(format, arg...) printk(KERN_DEBUG __FILE__ ": (BULK) " format "\n" , ## arg)
80 #else
81 #define dbg_bulk(format, arg...) do {} while (0)
82 #endif
83
84 #ifdef USB_DEBUG_INTR
85 #define dbg_intr(format, arg...) printk(KERN_DEBUG __FILE__ ": (INTR) " format "\n" , ## arg)
86 #else
87 #define dbg_intr(format, arg...) do {} while (0)
88 #endif
89
90 #ifdef USB_DEBUG_ISOC
91 #define dbg_isoc(format, arg...) printk(KERN_DEBUG __FILE__ ": (ISOC) " format "\n" , ## arg)
92 #else
93 #define dbg_isoc(format, arg...) do {} while (0)
94 #endif
95
96 #ifdef USB_DEBUG_TRACE
97 #define DBFENTER (printk(": Entering: %s\n", __FUNCTION__))
98 #define DBFEXIT (printk(": Exiting: %s\n", __FUNCTION__))
99 #else
100 #define DBFENTER do {} while (0)
101 #define DBFEXIT do {} while (0)
102 #endif
103
104 #define usb_pipeslow(pipe) (((pipe) >> 26) & 1)
105
106 /*-------------------------------------------------------------------
107 Virtual Root Hub
108 -------------------------------------------------------------------*/
109
110 static __u8 root_hub_dev_des[] =
111 {
112 0x12, /* __u8 bLength; */
113 0x01, /* __u8 bDescriptorType; Device */
114 0x00, /* __le16 bcdUSB; v1.0 */
115 0x01,
116 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
117 0x00, /* __u8 bDeviceSubClass; */
118 0x00, /* __u8 bDeviceProtocol; */
119 0x08, /* __u8 bMaxPacketSize0; 8 Bytes */
120 0x00, /* __le16 idVendor; */
121 0x00,
122 0x00, /* __le16 idProduct; */
123 0x00,
124 0x00, /* __le16 bcdDevice; */
125 0x00,
126 0x00, /* __u8 iManufacturer; */
127 0x02, /* __u8 iProduct; */
128 0x01, /* __u8 iSerialNumber; */
129 0x01 /* __u8 bNumConfigurations; */
130 };
131
132 /* Configuration descriptor */
133 static __u8 root_hub_config_des[] =
134 {
135 0x09, /* __u8 bLength; */
136 0x02, /* __u8 bDescriptorType; Configuration */
137 0x19, /* __le16 wTotalLength; */
138 0x00,
139 0x01, /* __u8 bNumInterfaces; */
140 0x01, /* __u8 bConfigurationValue; */
141 0x00, /* __u8 iConfiguration; */
142 0x40, /* __u8 bmAttributes; Bit 7: Bus-powered */
143 0x00, /* __u8 MaxPower; */
144
145 /* interface */
146 0x09, /* __u8 if_bLength; */
147 0x04, /* __u8 if_bDescriptorType; Interface */
148 0x00, /* __u8 if_bInterfaceNumber; */
149 0x00, /* __u8 if_bAlternateSetting; */
150 0x01, /* __u8 if_bNumEndpoints; */
151 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
152 0x00, /* __u8 if_bInterfaceSubClass; */
153 0x00, /* __u8 if_bInterfaceProtocol; */
154 0x00, /* __u8 if_iInterface; */
155
156 /* endpoint */
157 0x07, /* __u8 ep_bLength; */
158 0x05, /* __u8 ep_bDescriptorType; Endpoint */
159 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
160 0x03, /* __u8 ep_bmAttributes; Interrupt */
161 0x08, /* __le16 ep_wMaxPacketSize; 8 Bytes */
162 0x00,
163 0xff /* __u8 ep_bInterval; 255 ms */
164 };
165
166 static __u8 root_hub_hub_des[] =
167 {
168 0x09, /* __u8 bLength; */
169 0x29, /* __u8 bDescriptorType; Hub-descriptor */
170 0x02, /* __u8 bNbrPorts; */
171 0x00, /* __u16 wHubCharacteristics; */
172 0x00,
173 0x01, /* __u8 bPwrOn2pwrGood; 2ms */
174 0x00, /* __u8 bHubContrCurrent; 0 mA */
175 0x00, /* __u8 DeviceRemovable; *** 7 Ports max *** */
176 0xff /* __u8 PortPwrCtrlMask; *** 7 ports max *** */
177 };
178
179 static DEFINE_TIMER(bulk_start_timer, NULL, 0, 0);
180 static DEFINE_TIMER(bulk_eot_timer, NULL, 0, 0);
181
182 /* We want the start timer to expire before the eot timer, because the former might start
183 traffic, thus making it unnecessary for the latter to time out. */
184 #define BULK_START_TIMER_INTERVAL (HZ/10) /* 100 ms */
185 #define BULK_EOT_TIMER_INTERVAL (HZ/10+2) /* 120 ms */
186
187 #define OK(x) len = (x); dbg_rh("OK(%d): line: %d", x, __LINE__); break
188 #define CHECK_ALIGN(x) if (((__u32)(x)) & 0x00000003) \
189 {panic("Alignment check (DWORD) failed at %s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);}
190
191 #define SLAB_FLAG (in_interrupt() ? SLAB_ATOMIC : SLAB_KERNEL)
192 #define KMALLOC_FLAG (in_interrupt() ? GFP_ATOMIC : GFP_KERNEL)
193
194 /* Most helpful debugging aid */
195 #define assert(expr) ((void) ((expr) ? 0 : (err("assert failed at line %d",__LINE__))))
196
197 /* Alternative assert define which stops after a failed assert. */
198 /*
199 #define assert(expr) \
200 { \
201 if (!(expr)) { \
202 err("assert failed at line %d",__LINE__); \
203 while (1); \
204 } \
205 }
206 */
207
208
209 /* FIXME: Should RX_BUF_SIZE be a config option, or maybe we should adjust it dynamically?
210 To adjust it dynamically we would have to get an interrupt when we reach the end
211 of the rx descriptor list, or when we get close to the end, and then allocate more
212 descriptors. */
213
214 #define NBR_OF_RX_DESC 512
215 #define RX_DESC_BUF_SIZE 1024
216 #define RX_BUF_SIZE (NBR_OF_RX_DESC * RX_DESC_BUF_SIZE)
217
218 /* The number of epids is, among other things, used for pre-allocating
219 ctrl, bulk and isoc EP descriptors (one for each epid).
220 Assumed to be > 1 when initiating the DMA lists. */
221 #define NBR_OF_EPIDS 32
222
223 /* Support interrupt traffic intervals up to 128 ms. */
224 #define MAX_INTR_INTERVAL 128
225
226 /* If periodic traffic (intr or isoc) is to be used, then one entry in the EP table
227 must be "invalid". By this we mean that we shouldn't care about epid attentions
228 for this epid, or at least handle them differently from epid attentions for "valid"
229 epids. This define determines which one to use (don't change it). */
230 #define INVALID_EPID 31
231 /* A special epid for the bulk dummys. */
232 #define DUMMY_EPID 30
233
234 /* This is just a software cache for the valid entries in R_USB_EPT_DATA. */
235 static __u32 epid_usage_bitmask;
236
237 /* A bitfield to keep information on in/out traffic is needed to uniquely identify
238 an endpoint on a device, since the most significant bit which indicates traffic
239 direction is lacking in the ep_id field (ETRAX epids can handle both in and
240 out traffic on endpoints that are otherwise identical). The USB framework, however,
241 relies on them to be handled separately. For example, bulk IN and OUT urbs cannot
242 be queued in the same list, since they would block each other. */
243 static __u32 epid_out_traffic;
244
245 /* DMA IN cache bug. Align the DMA IN buffers to 32 bytes, i.e. a cache line.
246 Since RX_DESC_BUF_SIZE is 1024 is a multiple of 32, all rx buffers will be cache aligned. */
247 static volatile unsigned char RxBuf[RX_BUF_SIZE] __attribute__ ((aligned (32)));
248 static volatile USB_IN_Desc_t RxDescList[NBR_OF_RX_DESC] __attribute__ ((aligned (4)));
249
250 /* Pointers into RxDescList. */
251 static volatile USB_IN_Desc_t *myNextRxDesc;
252 static volatile USB_IN_Desc_t *myLastRxDesc;
253 static volatile USB_IN_Desc_t *myPrevRxDesc;
254
255 /* EP descriptors must be 32-bit aligned. */
256 static volatile USB_EP_Desc_t TxCtrlEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
257 static volatile USB_EP_Desc_t TxBulkEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
258 /* After each enabled bulk EP (IN or OUT) we put two disabled EP descriptors with the eol flag set,
259 causing the DMA to stop the DMA channel. The first of these two has the intr flag set, which
260 gives us a dma8_sub0_descr interrupt. When we receive this, we advance the DMA one step in the
261 EP list and then restart the bulk channel, thus forcing a switch between bulk EP descriptors
262 in each frame. */
263 static volatile USB_EP_Desc_t TxBulkDummyEPList[NBR_OF_EPIDS][2] __attribute__ ((aligned (4)));
264
265 static volatile USB_EP_Desc_t TxIsocEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
266 static volatile USB_SB_Desc_t TxIsocSB_zout __attribute__ ((aligned (4)));
267
268 static volatile USB_EP_Desc_t TxIntrEPList[MAX_INTR_INTERVAL] __attribute__ ((aligned (4)));
269 static volatile USB_SB_Desc_t TxIntrSB_zout __attribute__ ((aligned (4)));
270
271 /* A zout transfer makes a memory access at the address of its buf pointer, which means that setting
272 this buf pointer to 0 will cause an access to the flash. In addition to this, setting sw_len to 0
273 results in a 16/32 bytes (depending on DMA burst size) transfer. Instead, we set it to 1, and point
274 it to this buffer. */
275 static int zout_buffer[4] __attribute__ ((aligned (4)));
276
277 /* Cache for allocating new EP and SB descriptors. */
278 static kmem_cache_t *usb_desc_cache;
279
280 /* Cache for the registers allocated in the top half. */
281 static kmem_cache_t *top_half_reg_cache;
282
283 /* Cache for the data allocated in the isoc descr top half. */
284 static kmem_cache_t *isoc_compl_cache;
285
286 static struct usb_bus *etrax_usb_bus;
287
288 /* This is a circular (double-linked) list of the active urbs for each epid.
289 The head is never removed, and new urbs are linked onto the list as
290 urb_entry_t elements. Don't reference urb_list directly; use the wrapper
291 functions instead. Note that working with these lists might require spinlock
292 protection. */
293 static struct list_head urb_list[NBR_OF_EPIDS];
294
295 /* Read about the need and usage of this lock in submit_ctrl_urb. */
296 static spinlock_t urb_list_lock;
297
298 /* Used when unlinking asynchronously. */
299 static struct list_head urb_unlink_list;
300
301 /* for returning string descriptors in UTF-16LE */
302 static int ascii2utf (char *ascii, __u8 *utf, int utfmax)
303 {
304 int retval;
305
306 for (retval = 0; *ascii && utfmax > 1; utfmax -= 2, retval += 2) {
307 *utf++ = *ascii++ & 0x7f;
308 *utf++ = 0;
309 }
310 return retval;
311 }
312
313 static int usb_root_hub_string (int id, int serial, char *type, __u8 *data, int len)
314 {
315 char buf [30];
316
317 // assert (len > (2 * (sizeof (buf) + 1)));
318 // assert (strlen (type) <= 8);
319
320 // language ids
321 if (id == 0) {
322 *data++ = 4; *data++ = 3; /* 4 bytes data */
323 *data++ = 0; *data++ = 0; /* some language id */
324 return 4;
325
326 // serial number
327 } else if (id == 1) {
328 sprintf (buf, "%x", serial);
329
330 // product description
331 } else if (id == 2) {
332 sprintf (buf, "USB %s Root Hub", type);
333
334 // id 3 == vendor description
335
336 // unsupported IDs --> "stall"
337 } else
338 return 0;
339
340 data [0] = 2 + ascii2utf (buf, data + 2, len - 2);
341 data [1] = 3;
342 return data [0];
343 }
344
345 /* Wrappers around the list functions (include/linux/list.h). */
346
347 static inline int urb_list_empty(int epid)
348 {
349 return list_empty(&urb_list[epid]);
350 }
351
352 /* Returns first urb for this epid, or NULL if list is empty. */
353 static inline struct urb *urb_list_first(int epid)
354 {
355 struct urb *first_urb = 0;
356
357 if (!urb_list_empty(epid)) {
358 /* Get the first urb (i.e. head->next). */
359 urb_entry_t *urb_entry = list_entry((&urb_list[epid])->next, urb_entry_t, list);
360 first_urb = urb_entry->urb;
361 }
362 return first_urb;
363 }
364
365 /* Adds an urb_entry last in the list for this epid. */
366 static inline void urb_list_add(struct urb *urb, int epid)
367 {
368 urb_entry_t *urb_entry = (urb_entry_t *)kmalloc(sizeof(urb_entry_t), KMALLOC_FLAG);
369 assert(urb_entry);
370
371 urb_entry->urb = urb;
372 list_add_tail(&urb_entry->list, &urb_list[epid]);
373 }
374
375 /* Search through the list for an element that contains this urb. (The list
376 is expected to be short and the one we are about to delete will often be
377 the first in the list.) */
378 static inline urb_entry_t *__urb_list_entry(struct urb *urb, int epid)
379 {
380 struct list_head *entry;
381 struct list_head *tmp;
382 urb_entry_t *urb_entry;
383
384 list_for_each_safe(entry, tmp, &urb_list[epid]) {
385 urb_entry = list_entry(entry, urb_entry_t, list);
386 assert(urb_entry);
387 assert(urb_entry->urb);
388
389 if (urb_entry->urb == urb) {
390 return urb_entry;
391 }
392 }
393 return 0;
394 }
395
396 /* Delete an urb from the list. */
397 static inline void urb_list_del(struct urb *urb, int epid)
398 {
399 urb_entry_t *urb_entry = __urb_list_entry(urb, epid);
400 assert(urb_entry);
401
402 /* Delete entry and free. */
403 list_del(&urb_entry->list);
404 kfree(urb_entry);
405 }
406
407 /* Move an urb to the end of the list. */
408 static inline void urb_list_move_last(struct urb *urb, int epid)
409 {
410 urb_entry_t *urb_entry = __urb_list_entry(urb, epid);
411 assert(urb_entry);
412
413 list_move_tail(&urb_entry->list, &urb_list[epid]);
414 }
415
416 /* Get the next urb in the list. */
417 static inline struct urb *urb_list_next(struct urb *urb, int epid)
418 {
419 urb_entry_t *urb_entry = __urb_list_entry(urb, epid);
420
421 assert(urb_entry);
422
423 if (urb_entry->list.next != &urb_list[epid]) {
424 struct list_head *elem = urb_entry->list.next;
425 urb_entry = list_entry(elem, urb_entry_t, list);
426 return urb_entry->urb;
427 } else {
428 return NULL;
429 }
430 }
431
432
433
434 /* For debug purposes only. */
435 static inline void urb_list_dump(int epid)
436 {
437 struct list_head *entry;
438 struct list_head *tmp;
439 urb_entry_t *urb_entry;
440 int i = 0;
441
442 info("Dumping urb list for epid %d", epid);
443
444 list_for_each_safe(entry, tmp, &urb_list[epid]) {
445 urb_entry = list_entry(entry, urb_entry_t, list);
446 info(" entry %d, urb = 0x%lx", i, (unsigned long)urb_entry->urb);
447 }
448 }
449
450 static void init_rx_buffers(void);
451 static int etrax_rh_unlink_urb(struct urb *urb);
452 static void etrax_rh_send_irq(struct urb *urb);
453 static void etrax_rh_init_int_timer(struct urb *urb);
454 static void etrax_rh_int_timer_do(unsigned long ptr);
455
456 static int etrax_usb_setup_epid(struct urb *urb);
457 static int etrax_usb_lookup_epid(struct urb *urb);
458 static int etrax_usb_allocate_epid(void);
459 static void etrax_usb_free_epid(int epid);
460
461 static int etrax_remove_from_sb_list(struct urb *urb);
462
463 static void* etrax_usb_buffer_alloc(struct usb_bus* bus, size_t size,
464 unsigned mem_flags, dma_addr_t *dma);
465 static void etrax_usb_buffer_free(struct usb_bus *bus, size_t size, void *addr, dma_addr_t dma);
466
467 static void etrax_usb_add_to_bulk_sb_list(struct urb *urb, int epid);
468 static void etrax_usb_add_to_ctrl_sb_list(struct urb *urb, int epid);
469 static void etrax_usb_add_to_intr_sb_list(struct urb *urb, int epid);
470 static void etrax_usb_add_to_isoc_sb_list(struct urb *urb, int epid);
471
472 static int etrax_usb_submit_bulk_urb(struct urb *urb);
473 static int etrax_usb_submit_ctrl_urb(struct urb *urb);
474 static int etrax_usb_submit_intr_urb(struct urb *urb);
475 static int etrax_usb_submit_isoc_urb(struct urb *urb);
476
477 static int etrax_usb_submit_urb(struct urb *urb, unsigned mem_flags);
478 static int etrax_usb_unlink_urb(struct urb *urb, int status);
479 static int etrax_usb_get_frame_number(struct usb_device *usb_dev);
480
481 static irqreturn_t etrax_usb_tx_interrupt(int irq, void *vhc);
482 static irqreturn_t etrax_usb_rx_interrupt(int irq, void *vhc);
483 static irqreturn_t etrax_usb_hc_interrupt_top_half(int irq, void *vhc);
484 static void etrax_usb_hc_interrupt_bottom_half(void *data);
485
486 static void etrax_usb_isoc_descr_interrupt_bottom_half(void *data);
487
488
489 /* The following is a list of interrupt handlers for the host controller interrupts we use.
490 They are called from etrax_usb_hc_interrupt_bottom_half. */
491 static void etrax_usb_hc_isoc_eof_interrupt(void);
492 static void etrax_usb_hc_bulk_eot_interrupt(int timer_induced);
493 static void etrax_usb_hc_epid_attn_interrupt(usb_interrupt_registers_t *reg);
494 static void etrax_usb_hc_port_status_interrupt(usb_interrupt_registers_t *reg);
495 static void etrax_usb_hc_ctl_status_interrupt(usb_interrupt_registers_t *reg);
496
497 static int etrax_rh_submit_urb (struct urb *urb);
498
499 /* Forward declaration needed because they are used in the rx interrupt routine. */
500 static void etrax_usb_complete_urb(struct urb *urb, int status);
501 static void etrax_usb_complete_bulk_urb(struct urb *urb, int status);
502 static void etrax_usb_complete_ctrl_urb(struct urb *urb, int status);
503 static void etrax_usb_complete_intr_urb(struct urb *urb, int status);
504 static void etrax_usb_complete_isoc_urb(struct urb *urb, int status);
505
506 static int etrax_usb_hc_init(void);
507 static void etrax_usb_hc_cleanup(void);
508
509 static struct usb_operations etrax_usb_device_operations =
510 {
511 .get_frame_number = etrax_usb_get_frame_number,
512 .submit_urb = etrax_usb_submit_urb,
513 .unlink_urb = etrax_usb_unlink_urb,
514 .buffer_alloc = etrax_usb_buffer_alloc,
515 .buffer_free = etrax_usb_buffer_free
516 };
517
518 /* Note that these functions are always available in their "__" variants, for use in
519 error situations. The "__" missing variants are controlled by the USB_DEBUG_DESC/
520 USB_DEBUG_URB macros. */
521 static void __dump_urb(struct urb* purb)
522 {
523 printk("\nurb :0x%08lx\n", (unsigned long)purb);
524 printk("dev :0x%08lx\n", (unsigned long)purb->dev);
525 printk("pipe :0x%08x\n", purb->pipe);
526 printk("status :%d\n", purb->status);
527 printk("transfer_flags :0x%08x\n", purb->transfer_flags);
528 printk("transfer_buffer :0x%08lx\n", (unsigned long)purb->transfer_buffer);
529 printk("transfer_buffer_length:%d\n", purb->transfer_buffer_length);
530 printk("actual_length :%d\n", purb->actual_length);
531 printk("setup_packet :0x%08lx\n", (unsigned long)purb->setup_packet);
532 printk("start_frame :%d\n", purb->start_frame);
533 printk("number_of_packets :%d\n", purb->number_of_packets);
534 printk("interval :%d\n", purb->interval);
535 printk("error_count :%d\n", purb->error_count);
536 printk("context :0x%08lx\n", (unsigned long)purb->context);
537 printk("complete :0x%08lx\n\n", (unsigned long)purb->complete);
538 }
539
540 static void __dump_in_desc(volatile USB_IN_Desc_t *in)
541 {
542 printk("\nUSB_IN_Desc at 0x%08lx\n", (unsigned long)in);
543 printk(" sw_len : 0x%04x (%d)\n", in->sw_len, in->sw_len);
544 printk(" command : 0x%04x\n", in->command);
545 printk(" next : 0x%08lx\n", in->next);
546 printk(" buf : 0x%08lx\n", in->buf);
547 printk(" hw_len : 0x%04x (%d)\n", in->hw_len, in->hw_len);
548 printk(" status : 0x%04x\n\n", in->status);
549 }
550
551 static void __dump_sb_desc(volatile USB_SB_Desc_t *sb)
552 {
553 char tt = (sb->command & 0x30) >> 4;
554 char *tt_string;
555
556 switch (tt) {
557 case 0:
558 tt_string = "zout";
559 break;
560 case 1:
561 tt_string = "in";
562 break;
563 case 2:
564 tt_string = "out";
565 break;
566 case 3:
567 tt_string = "setup";
568 break;
569 default:
570 tt_string = "unknown (weird)";
571 }
572
573 printk("\n USB_SB_Desc at 0x%08lx\n", (unsigned long)sb);
574 printk(" command : 0x%04x\n", sb->command);
575 printk(" rem : %d\n", (sb->command & 0x3f00) >> 8);
576 printk(" full : %d\n", (sb->command & 0x40) >> 6);
577 printk(" tt : %d (%s)\n", tt, tt_string);
578 printk(" intr : %d\n", (sb->command & 0x8) >> 3);
579 printk(" eot : %d\n", (sb->command & 0x2) >> 1);
580 printk(" eol : %d\n", sb->command & 0x1);
581 printk(" sw_len : 0x%04x (%d)\n", sb->sw_len, sb->sw_len);
582 printk(" next : 0x%08lx\n", sb->next);
583 printk(" buf : 0x%08lx\n\n", sb->buf);
584 }
585
586
587 static void __dump_ep_desc(volatile USB_EP_Desc_t *ep)
588 {
589 printk("\nUSB_EP_Desc at 0x%08lx\n", (unsigned long)ep);
590 printk(" command : 0x%04x\n", ep->command);
591 printk(" ep_id : %d\n", (ep->command & 0x1f00) >> 8);
592 printk(" enable : %d\n", (ep->command & 0x10) >> 4);
593 printk(" intr : %d\n", (ep->command & 0x8) >> 3);
594 printk(" eof : %d\n", (ep->command & 0x2) >> 1);
595 printk(" eol : %d\n", ep->command & 0x1);
596 printk(" hw_len : 0x%04x (%d)\n", ep->hw_len, ep->hw_len);
597 printk(" next : 0x%08lx\n", ep->next);
598 printk(" sub : 0x%08lx\n\n", ep->sub);
599 }
600
601 static inline void __dump_ep_list(int pipe_type)
602 {
603 volatile USB_EP_Desc_t *ep;
604 volatile USB_EP_Desc_t *first_ep;
605 volatile USB_SB_Desc_t *sb;
606
607 switch (pipe_type)
608 {
609 case PIPE_BULK:
610 first_ep = &TxBulkEPList[0];
611 break;
612 case PIPE_CONTROL:
613 first_ep = &TxCtrlEPList[0];
614 break;
615 case PIPE_INTERRUPT:
616 first_ep = &TxIntrEPList[0];
617 break;
618 case PIPE_ISOCHRONOUS:
619 first_ep = &TxIsocEPList[0];
620 break;
621 default:
622 warn("Cannot dump unknown traffic type");
623 return;
624 }
625 ep = first_ep;
626
627 printk("\n\nDumping EP list...\n\n");
628
629 do {
630 __dump_ep_desc(ep);
631 /* Cannot phys_to_virt on 0 as it turns into 80000000, which is != 0. */
632 sb = ep->sub ? phys_to_virt(ep->sub) : 0;
633 while (sb) {
634 __dump_sb_desc(sb);
635 sb = sb->next ? phys_to_virt(sb->next) : 0;
636 }
637 ep = (volatile USB_EP_Desc_t *)(phys_to_virt(ep->next));
638
639 } while (ep != first_ep);
640 }
641
642 static inline void __dump_ept_data(int epid)
643 {
644 unsigned long flags;
645 __u32 r_usb_ept_data;
646
647 if (epid < 0 || epid > 31) {
648 printk("Cannot dump ept data for invalid epid %d\n", epid);
649 return;
650 }
651
652 save_flags(flags);
653 cli();
654 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
655 nop();
656 r_usb_ept_data = *R_USB_EPT_DATA;
657 restore_flags(flags);
658
659 printk("\nR_USB_EPT_DATA = 0x%x for epid %d :\n", r_usb_ept_data, epid);
660 if (r_usb_ept_data == 0) {
661 /* No need for more detailed printing. */
662 return;
663 }
664 printk(" valid : %d\n", (r_usb_ept_data & 0x80000000) >> 31);
665 printk(" hold : %d\n", (r_usb_ept_data & 0x40000000) >> 30);
666 printk(" error_count_in : %d\n", (r_usb_ept_data & 0x30000000) >> 28);
667 printk(" t_in : %d\n", (r_usb_ept_data & 0x08000000) >> 27);
668 printk(" low_speed : %d\n", (r_usb_ept_data & 0x04000000) >> 26);
669 printk(" port : %d\n", (r_usb_ept_data & 0x03000000) >> 24);
670 printk(" error_code : %d\n", (r_usb_ept_data & 0x00c00000) >> 22);
671 printk(" t_out : %d\n", (r_usb_ept_data & 0x00200000) >> 21);
672 printk(" error_count_out : %d\n", (r_usb_ept_data & 0x00180000) >> 19);
673 printk(" max_len : %d\n", (r_usb_ept_data & 0x0003f800) >> 11);
674 printk(" ep : %d\n", (r_usb_ept_data & 0x00000780) >> 7);
675 printk(" dev : %d\n", (r_usb_ept_data & 0x0000003f));
676 }
677
678 static inline void __dump_ept_data_list(void)
679 {
680 int i;
681
682 printk("Dumping the whole R_USB_EPT_DATA list\n");
683
684 for (i = 0; i < 32; i++) {
685 __dump_ept_data(i);
686 }
687 }
688 #ifdef USB_DEBUG_DESC
689 #define dump_in_desc(...) __dump_in_desc(...)
690 #define dump_sb_desc(...) __dump_sb_desc(...)
691 #define dump_ep_desc(...) __dump_ep_desc(...)
692 #else
693 #define dump_in_desc(...) do {} while (0)
694 #define dump_sb_desc(...) do {} while (0)
695 #define dump_ep_desc(...) do {} while (0)
696 #endif
697
698 #ifdef USB_DEBUG_URB
699 #define dump_urb(x) __dump_urb(x)
700 #else
701 #define dump_urb(x) do {} while (0)
702 #endif
703
704 static void init_rx_buffers(void)
705 {
706 int i;
707
708 DBFENTER;
709
710 for (i = 0; i < (NBR_OF_RX_DESC - 1); i++) {
711 RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
712 RxDescList[i].command = 0;
713 RxDescList[i].next = virt_to_phys(&RxDescList[i + 1]);
714 RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
715 RxDescList[i].hw_len = 0;
716 RxDescList[i].status = 0;
717
718 /* DMA IN cache bug. (struct etrax_dma_descr has the same layout as USB_IN_Desc
719 for the relevant fields.) */
720 prepare_rx_descriptor((struct etrax_dma_descr*)&RxDescList[i]);
721
722 }
723
724 RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
725 RxDescList[i].command = IO_STATE(USB_IN_command, eol, yes);
726 RxDescList[i].next = virt_to_phys(&RxDescList[0]);
727 RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
728 RxDescList[i].hw_len = 0;
729 RxDescList[i].status = 0;
730
731 myNextRxDesc = &RxDescList[0];
732 myLastRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
733 myPrevRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
734
735 *R_DMA_CH9_FIRST = virt_to_phys(myNextRxDesc);
736 *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, start);
737
738 DBFEXIT;
739 }
740
741 static void init_tx_bulk_ep(void)
742 {
743 int i;
744
745 DBFENTER;
746
747 for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
748 CHECK_ALIGN(&TxBulkEPList[i]);
749 TxBulkEPList[i].hw_len = 0;
750 TxBulkEPList[i].command = IO_FIELD(USB_EP_command, epid, i);
751 TxBulkEPList[i].sub = 0;
752 TxBulkEPList[i].next = virt_to_phys(&TxBulkEPList[i + 1]);
753
754 /* Initiate two EPs, disabled and with the eol flag set. No need for any
755 preserved epid. */
756
757 /* The first one has the intr flag set so we get an interrupt when the DMA
758 channel is about to become disabled. */
759 CHECK_ALIGN(&TxBulkDummyEPList[i][0]);
760 TxBulkDummyEPList[i][0].hw_len = 0;
761 TxBulkDummyEPList[i][0].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
762 IO_STATE(USB_EP_command, eol, yes) |
763 IO_STATE(USB_EP_command, intr, yes));
764 TxBulkDummyEPList[i][0].sub = 0;
765 TxBulkDummyEPList[i][0].next = virt_to_phys(&TxBulkDummyEPList[i][1]);
766
767 /* The second one. */
768 CHECK_ALIGN(&TxBulkDummyEPList[i][1]);
769 TxBulkDummyEPList[i][1].hw_len = 0;
770 TxBulkDummyEPList[i][1].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
771 IO_STATE(USB_EP_command, eol, yes));
772 TxBulkDummyEPList[i][1].sub = 0;
773 /* The last dummy's next pointer is the same as the current EP's next pointer. */
774 TxBulkDummyEPList[i][1].next = virt_to_phys(&TxBulkEPList[i + 1]);
775 }
776
777 /* Configure the last one. */
778 CHECK_ALIGN(&TxBulkEPList[i]);
779 TxBulkEPList[i].hw_len = 0;
780 TxBulkEPList[i].command = (IO_STATE(USB_EP_command, eol, yes) |
781 IO_FIELD(USB_EP_command, epid, i));
782 TxBulkEPList[i].sub = 0;
783 TxBulkEPList[i].next = virt_to_phys(&TxBulkEPList[0]);
784
785 /* No need configuring dummy EPs for the last one as it will never be used for
786 bulk traffic (i == INVALD_EPID at this point). */
787
788 /* Set up to start on the last EP so we will enable it when inserting traffic
789 for the first time (imitating the situation where the DMA has stopped
790 because there was no more traffic). */
791 *R_DMA_CH8_SUB0_EP = virt_to_phys(&TxBulkEPList[i]);
792 /* No point in starting the bulk channel yet.
793 *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); */
794 DBFEXIT;
795 }
796
797 static void init_tx_ctrl_ep(void)
798 {
799 int i;
800
801 DBFENTER;
802
803 for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
804 CHECK_ALIGN(&TxCtrlEPList[i]);
805 TxCtrlEPList[i].hw_len = 0;
806 TxCtrlEPList[i].command = IO_FIELD(USB_EP_command, epid, i);
807 TxCtrlEPList[i].sub = 0;
808 TxCtrlEPList[i].next = virt_to_phys(&TxCtrlEPList[i + 1]);
809 }
810
811 CHECK_ALIGN(&TxCtrlEPList[i]);
812 TxCtrlEPList[i].hw_len = 0;
813 TxCtrlEPList[i].command = (IO_STATE(USB_EP_command, eol, yes) |
814 IO_FIELD(USB_EP_command, epid, i));
815
816 TxCtrlEPList[i].sub = 0;
817 TxCtrlEPList[i].next = virt_to_phys(&TxCtrlEPList[0]);
818
819 *R_DMA_CH8_SUB1_EP = virt_to_phys(&TxCtrlEPList[0]);
820 *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB1_CMD, cmd, start);
821
822 DBFEXIT;
823 }
824
825
826 static void init_tx_intr_ep(void)
827 {
828 int i;
829
830 DBFENTER;
831
832 /* Read comment at zout_buffer declaration for an explanation to this. */
833 TxIntrSB_zout.sw_len = 1;
834 TxIntrSB_zout.next = 0;
835 TxIntrSB_zout.buf = virt_to_phys(&zout_buffer[0]);
836 TxIntrSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
837 IO_STATE(USB_SB_command, tt, zout) |
838 IO_STATE(USB_SB_command, full, yes) |
839 IO_STATE(USB_SB_command, eot, yes) |
840 IO_STATE(USB_SB_command, eol, yes));
841
842 for (i = 0; i < (MAX_INTR_INTERVAL - 1); i++) {
843 CHECK_ALIGN(&TxIntrEPList[i]);
844 TxIntrEPList[i].hw_len = 0;
845 TxIntrEPList[i].command =
846 (IO_STATE(USB_EP_command, eof, yes) |
847 IO_STATE(USB_EP_command, enable, yes) |
848 IO_FIELD(USB_EP_command, epid, INVALID_EPID));
849 TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
850 TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[i + 1]);
851 }
852
853 CHECK_ALIGN(&TxIntrEPList[i]);
854 TxIntrEPList[i].hw_len = 0;
855 TxIntrEPList[i].command =
856 (IO_STATE(USB_EP_command, eof, yes) |
857 IO_STATE(USB_EP_command, eol, yes) |
858 IO_STATE(USB_EP_command, enable, yes) |
859 IO_FIELD(USB_EP_command, epid, INVALID_EPID));
860 TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
861 TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[0]);
862
863 *R_DMA_CH8_SUB2_EP = virt_to_phys(&TxIntrEPList[0]);
864 *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start);
865 DBFEXIT;
866 }
867
868 static void init_tx_isoc_ep(void)
869 {
870 int i;
871
872 DBFENTER;
873
874 /* Read comment at zout_buffer declaration for an explanation to this. */
875 TxIsocSB_zout.sw_len = 1;
876 TxIsocSB_zout.next = 0;
877 TxIsocSB_zout.buf = virt_to_phys(&zout_buffer[0]);
878 TxIsocSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
879 IO_STATE(USB_SB_command, tt, zout) |
880 IO_STATE(USB_SB_command, full, yes) |
881 IO_STATE(USB_SB_command, eot, yes) |
882 IO_STATE(USB_SB_command, eol, yes));
883
884 /* The last isochronous EP descriptor is a dummy. */
885
886 for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
887 CHECK_ALIGN(&TxIsocEPList[i]);
888 TxIsocEPList[i].hw_len = 0;
889 TxIsocEPList[i].command = IO_FIELD(USB_EP_command, epid, i);
890 TxIsocEPList[i].sub = 0;
891 TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[i + 1]);
892 }
893
894 CHECK_ALIGN(&TxIsocEPList[i]);
895 TxIsocEPList[i].hw_len = 0;
896
897 /* Must enable the last EP descr to get eof interrupt. */
898 TxIsocEPList[i].command = (IO_STATE(USB_EP_command, enable, yes) |
899 IO_STATE(USB_EP_command, eof, yes) |
900 IO_STATE(USB_EP_command, eol, yes) |
901 IO_FIELD(USB_EP_command, epid, INVALID_EPID));
902 TxIsocEPList[i].sub = virt_to_phys(&TxIsocSB_zout);
903 TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[0]);
904
905 *R_DMA_CH8_SUB3_EP = virt_to_phys(&TxIsocEPList[0]);
906 *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
907
908 DBFEXIT;
909 }
910
911 static void etrax_usb_unlink_intr_urb(struct urb *urb)
912 {
913 volatile USB_EP_Desc_t *first_ep; /* First EP in the list. */
914 volatile USB_EP_Desc_t *curr_ep; /* Current EP, the iterator. */
915 volatile USB_EP_Desc_t *next_ep; /* The EP after current. */
916 volatile USB_EP_Desc_t *unlink_ep; /* The one we should remove from the list. */
917
918 int epid;
919
920 /* Read 8.8.4 in Designer's Reference, "Removing an EP Descriptor from the List". */
921
922 DBFENTER;
923
924 epid = ((etrax_urb_priv_t *)urb->hcpriv)->epid;
925
926 first_ep = &TxIntrEPList[0];
927 curr_ep = first_ep;
928
929
930 /* Note that this loop removes all EP descriptors with this epid. This assumes
931 that all EP descriptors belong to the one and only urb for this epid. */
932
933 do {
934 next_ep = (USB_EP_Desc_t *)phys_to_virt(curr_ep->next);
935
936 if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
937
938 dbg_intr("Found EP to unlink for epid %d", epid);
939
940 /* This is the one we should unlink. */
941 unlink_ep = next_ep;
942
943 /* Actually unlink the EP from the DMA list. */
944 curr_ep->next = unlink_ep->next;
945
946 /* Wait until the DMA is no longer at this descriptor. */
947 while (*R_DMA_CH8_SUB2_EP == virt_to_phys(unlink_ep));
948
949 /* Now we are free to remove it and its SB descriptor.
950 Note that it is assumed here that there is only one sb in the
951 sb list for this ep. */
952 kmem_cache_free(usb_desc_cache, phys_to_virt(unlink_ep->sub));
953 kmem_cache_free(usb_desc_cache, (USB_EP_Desc_t *)unlink_ep);
954 }
955
956 curr_ep = phys_to_virt(curr_ep->next);
957
958 } while (curr_ep != first_ep);
959 urb->hcpriv = NULL;
960 }
961
962 void etrax_usb_do_intr_recover(int epid)
963 {
964 USB_EP_Desc_t *first_ep, *tmp_ep;
965
966 DBFENTER;
967
968 first_ep = (USB_EP_Desc_t *)phys_to_virt(*R_DMA_CH8_SUB2_EP);
969 tmp_ep = first_ep;
970
971 /* What this does is simply to walk the list of interrupt
972 ep descriptors and enable those that are disabled. */
973
974 do {
975 if (IO_EXTRACT(USB_EP_command, epid, tmp_ep->command) == epid &&
976 !(tmp_ep->command & IO_MASK(USB_EP_command, enable))) {
977 tmp_ep->command |= IO_STATE(USB_EP_command, enable, yes);
978 }
979
980 tmp_ep = (USB_EP_Desc_t *)phys_to_virt(tmp_ep->next);
981
982 } while (tmp_ep != first_ep);
983
984
985 DBFEXIT;
986 }
987
988 static int etrax_rh_unlink_urb (struct urb *urb)
989 {
990 etrax_hc_t *hc;
991
992 DBFENTER;
993
994 hc = urb->dev->bus->hcpriv;
995
996 if (hc->rh.urb == urb) {
997 hc->rh.send = 0;
998 del_timer(&hc->rh.rh_int_timer);
999 }
1000
1001 DBFEXIT;
1002 return 0;
1003 }
1004
1005 static void etrax_rh_send_irq(struct urb *urb)
1006 {
1007 __u16 data = 0;
1008 etrax_hc_t *hc = urb->dev->bus->hcpriv;
1009 DBFENTER;
1010
1011 /*
1012 dbg_rh("R_USB_FM_NUMBER : 0x%08X", *R_USB_FM_NUMBER);
1013 dbg_rh("R_USB_FM_REMAINING: 0x%08X", *R_USB_FM_REMAINING);
1014 */
1015
1016 data |= (hc->rh.wPortChange_1) ? (1 << 1) : 0;
1017 data |= (hc->rh.wPortChange_2) ? (1 << 2) : 0;
1018
1019 *((__u16 *)urb->transfer_buffer) = cpu_to_le16(data);
1020 /* FIXME: Why is actual_length set to 1 when data is 2 bytes?
1021 Since only 1 byte is used, why not declare data as __u8? */
1022 urb->actual_length = 1;
1023 urb->status = 0;
1024
1025 if (hc->rh.send && urb->complete) {
1026 dbg_rh("wPortChange_1: 0x%04X", hc->rh.wPortChange_1);
1027 dbg_rh("wPortChange_2: 0x%04X", hc->rh.wPortChange_2);
1028
1029 urb->complete(urb, NULL);
1030 }
1031
1032 DBFEXIT;
1033 }
1034
1035 static void etrax_rh_init_int_timer(struct urb *urb)
1036 {
1037 etrax_hc_t *hc;
1038
1039 DBFENTER;
1040
1041 hc = urb->dev->bus->hcpriv;
1042 hc->rh.interval = urb->interval;
1043 init_timer(&hc->rh.rh_int_timer);
1044 hc->rh.rh_int_timer.function = etrax_rh_int_timer_do;
1045 hc->rh.rh_int_timer.data = (unsigned long)urb;
1046 /* FIXME: Is the jiffies resolution enough? All intervals < 10 ms will be mapped
1047 to 0, and the rest to the nearest lower 10 ms. */
1048 hc->rh.rh_int_timer.expires = jiffies + ((HZ * hc->rh.interval) / 1000);
1049 add_timer(&hc->rh.rh_int_timer);
1050
1051 DBFEXIT;
1052 }
1053
1054 static void etrax_rh_int_timer_do(unsigned long ptr)
1055 {
1056 struct urb *urb;
1057 etrax_hc_t *hc;
1058
1059 DBFENTER;
1060
1061 urb = (struct urb*)ptr;
1062 hc = urb->dev->bus->hcpriv;
1063
1064 if (hc->rh.send) {
1065 etrax_rh_send_irq(urb);
1066 }
1067
1068 DBFEXIT;
1069 }
1070
1071 static int etrax_usb_setup_epid(struct urb *urb)
1072 {
1073 int epid;
1074 char devnum, endpoint, out_traffic, slow;
1075 int maxlen;
1076 unsigned long flags;
1077
1078 DBFENTER;
1079
1080 epid = etrax_usb_lookup_epid(urb);
1081 if ((epid != -1)){
1082 /* An epid that fits this urb has been found. */
1083 DBFEXIT;
1084 return epid;
1085 }
1086
1087 /* We must find and initiate a new epid for this urb. */
1088 epid = etrax_usb_allocate_epid();
1089
1090 if (epid == -1) {
1091 /* Failed to allocate a new epid. */
1092 DBFEXIT;
1093 return epid;
1094 }
1095
1096 /* We now have a new epid to use. Initiate it. */
1097 set_bit(epid, (void *)&epid_usage_bitmask);
1098
1099 devnum = usb_pipedevice(urb->pipe);
1100 endpoint = usb_pipeendpoint(urb->pipe);
1101 slow = usb_pipeslow(urb->pipe);
1102 maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
1103 if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
1104 /* We want both IN and OUT control traffic to be put on the same EP/SB list. */
1105 out_traffic = 1;
1106 } else {
1107 out_traffic = usb_pipeout(urb->pipe);
1108 }
1109
1110 save_flags(flags);
1111 cli();
1112
1113 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
1114 nop();
1115
1116 if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
1117 *R_USB_EPT_DATA_ISO = IO_STATE(R_USB_EPT_DATA_ISO, valid, yes) |
1118 /* FIXME: Change any to the actual port? */
1119 IO_STATE(R_USB_EPT_DATA_ISO, port, any) |
1120 IO_FIELD(R_USB_EPT_DATA_ISO, max_len, maxlen) |
1121 IO_FIELD(R_USB_EPT_DATA_ISO, ep, endpoint) |
1122 IO_FIELD(R_USB_EPT_DATA_ISO, dev, devnum);
1123 } else {
1124 *R_USB_EPT_DATA = IO_STATE(R_USB_EPT_DATA, valid, yes) |
1125 IO_FIELD(R_USB_EPT_DATA, low_speed, slow) |
1126 /* FIXME: Change any to the actual port? */
1127 IO_STATE(R_USB_EPT_DATA, port, any) |
1128 IO_FIELD(R_USB_EPT_DATA, max_len, maxlen) |
1129 IO_FIELD(R_USB_EPT_DATA, ep, endpoint) |
1130 IO_FIELD(R_USB_EPT_DATA, dev, devnum);
1131 }
1132
1133 restore_flags(flags);
1134
1135 if (out_traffic) {
1136 set_bit(epid, (void *)&epid_out_traffic);
1137 } else {
1138 clear_bit(epid, (void *)&epid_out_traffic);
1139 }
1140
1141 dbg_epid("Setting up epid %d with devnum %d, endpoint %d and max_len %d (%s)",
1142 epid, devnum, endpoint, maxlen, out_traffic ? "OUT" : "IN");
1143
1144 DBFEXIT;
1145 return epid;
1146 }
1147
1148 static void etrax_usb_free_epid(int epid)
1149 {
1150 unsigned long flags;
1151
1152 DBFENTER;
1153
1154 if (!test_bit(epid, (void *)&epid_usage_bitmask)) {
1155 warn("Trying to free unused epid %d", epid);
1156 DBFEXIT;
1157 return;
1158 }
1159
1160 save_flags(flags);
1161 cli();
1162
1163 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
1164 nop();
1165 while (*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold));
1166 /* This will, among other things, set the valid field to 0. */
1167 *R_USB_EPT_DATA = 0;
1168 restore_flags(flags);
1169
1170 clear_bit(epid, (void *)&epid_usage_bitmask);
1171
1172
1173 dbg_epid("Freed epid %d", epid);
1174
1175 DBFEXIT;
1176 }
1177
1178 static int etrax_usb_lookup_epid(struct urb *urb)
1179 {
1180 int i;
1181 __u32 data;
1182 char devnum, endpoint, slow, out_traffic;
1183 int maxlen;
1184 unsigned long flags;
1185
1186 DBFENTER;
1187
1188 devnum = usb_pipedevice(urb->pipe);
1189 endpoint = usb_pipeendpoint(urb->pipe);
1190 slow = usb_pipeslow(urb->pipe);
1191 maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
1192 if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
1193 /* We want both IN and OUT control traffic to be put on the same EP/SB list. */
1194 out_traffic = 1;
1195 } else {
1196 out_traffic = usb_pipeout(urb->pipe);
1197 }
1198
1199 /* Step through att epids. */
1200 for (i = 0; i < NBR_OF_EPIDS; i++) {
1201 if (test_bit(i, (void *)&epid_usage_bitmask) &&
1202 test_bit(i, (void *)&epid_out_traffic) == out_traffic) {
1203
1204 save_flags(flags);
1205 cli();
1206 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, i);
1207 nop();
1208
1209 if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
1210 data = *R_USB_EPT_DATA_ISO;
1211 restore_flags(flags);
1212
1213 if ((IO_MASK(R_USB_EPT_DATA_ISO, valid) & data) &&
1214 (IO_EXTRACT(R_USB_EPT_DATA_ISO, dev, data) == devnum) &&
1215 (IO_EXTRACT(R_USB_EPT_DATA_ISO, ep, data) == endpoint) &&
1216 (IO_EXTRACT(R_USB_EPT_DATA_ISO, max_len, data) == maxlen)) {
1217 dbg_epid("Found epid %d for devnum %d, endpoint %d (%s)",
1218 i, devnum, endpoint, out_traffic ? "OUT" : "IN");
1219 DBFEXIT;
1220 return i;
1221 }
1222 } else {
1223 data = *R_USB_EPT_DATA;
1224 restore_flags(flags);
1225
1226 if ((IO_MASK(R_USB_EPT_DATA, valid) & data) &&
1227 (IO_EXTRACT(R_USB_EPT_DATA, dev, data) == devnum) &&
1228 (IO_EXTRACT(R_USB_EPT_DATA, ep, data) == endpoint) &&
1229 (IO_EXTRACT(R_USB_EPT_DATA, low_speed, data) == slow) &&
1230 (IO_EXTRACT(R_USB_EPT_DATA, max_len, data) == maxlen)) {
1231 dbg_epid("Found epid %d for devnum %d, endpoint %d (%s)",
1232 i, devnum, endpoint, out_traffic ? "OUT" : "IN");
1233 DBFEXIT;
1234 return i;
1235 }
1236 }
1237 }
1238 }
1239
1240 DBFEXIT;
1241 return -1;
1242 }
1243
1244 static int etrax_usb_allocate_epid(void)
1245 {
1246 int i;
1247
1248 DBFENTER;
1249
1250 for (i = 0; i < NBR_OF_EPIDS; i++) {
1251 if (!test_bit(i, (void *)&epid_usage_bitmask)) {
1252 dbg_epid("Found free epid %d", i);
1253 DBFEXIT;
1254 return i;
1255 }
1256 }
1257
1258 dbg_epid("Found no free epids");
1259 DBFEXIT;
1260 return -1;
1261 }
1262
1263 static int etrax_usb_submit_urb(struct urb *urb, unsigned mem_flags)
1264 {
1265 etrax_hc_t *hc;
1266 int ret = -EINVAL;
1267
1268 DBFENTER;
1269
1270 if (!urb->dev || !urb->dev->bus) {
1271 return -ENODEV;
1272 }
1273 if (usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)) <= 0) {
1274 info("Submit urb to pipe with maxpacketlen 0, pipe 0x%X\n", urb->pipe);
1275 return -EMSGSIZE;
1276 }
1277
1278 if (urb->timeout) {
1279 /* FIXME. */
1280 warn("urb->timeout specified, ignoring.");
1281 }
1282
1283 hc = (etrax_hc_t*)urb->dev->bus->hcpriv;
1284
1285 if (usb_pipedevice(urb->pipe) == hc->rh.devnum) {
1286 /* This request is for the Virtual Root Hub. */
1287 ret = etrax_rh_submit_urb(urb);
1288
1289 } else if (usb_pipetype(urb->pipe) == PIPE_BULK) {
1290
1291 ret = etrax_usb_submit_bulk_urb(urb);
1292
1293 } else if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
1294
1295 ret = etrax_usb_submit_ctrl_urb(urb);
1296
1297 } else if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
1298 int bustime;
1299
1300 if (urb->bandwidth == 0) {
1301 bustime = usb_check_bandwidth(urb->dev, urb);
1302 if (bustime < 0) {
1303 ret = bustime;
1304 } else {
1305 ret = etrax_usb_submit_intr_urb(urb);
1306 if (ret == 0)
1307 usb_claim_bandwidth(urb->dev, urb, bustime, 0);
1308 }
1309 } else {
1310 /* Bandwidth already set. */
1311 ret = etrax_usb_submit_intr_urb(urb);
1312 }
1313
1314 } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
1315 int bustime;
1316
1317 if (urb->bandwidth == 0) {
1318 bustime = usb_check_bandwidth(urb->dev, urb);
1319 if (bustime < 0) {
1320 ret = bustime;
1321 } else {
1322 ret = etrax_usb_submit_isoc_urb(urb);
1323 if (ret == 0)
1324 usb_claim_bandwidth(urb->dev, urb, bustime, 0);
1325 }
1326 } else {
1327 /* Bandwidth already set. */
1328 ret = etrax_usb_submit_isoc_urb(urb);
1329 }
1330 }
1331
1332 DBFEXIT;
1333
1334 if (ret != 0)
1335 printk("Submit URB error %d\n", ret);
1336
1337 return ret;
1338 }
1339
1340 static int etrax_usb_unlink_urb(struct urb *urb, int status)
1341 {
1342 etrax_hc_t *hc;
1343 etrax_urb_priv_t *urb_priv;
1344 int epid;
1345 unsigned int flags;
1346
1347 DBFENTER;
1348
1349 if (!urb) {
1350 return -EINVAL;
1351 }
1352
1353 /* Disable interrupts here since a descriptor interrupt for the isoc epid
1354 will modify the sb list. This could possibly be done more granular, but
1355 unlink_urb should not be used frequently anyway.
1356 */
1357
1358 save_flags(flags);
1359 cli();
1360
1361 if (!urb->dev || !urb->dev->bus) {
1362 restore_flags(flags);
1363 return -ENODEV;
1364 }
1365 if (!urb->hcpriv) {
1366 /* This happens if a device driver calls unlink on an urb that
1367 was never submitted (lazy driver) or if the urb was completed
1368 while unlink was being called. */
1369 restore_flags(flags);
1370 return 0;
1371 }
1372 if (urb->transfer_flags & URB_ASYNC_UNLINK) {
1373 /* FIXME. */
1374 /* If URB_ASYNC_UNLINK is set:
1375 unlink
1376 move to a separate urb list
1377 call complete at next sof with ECONNRESET
1378
1379 If not:
1380 wait 1 ms
1381 unlink
1382 call complete with ENOENT
1383 */
1384 warn("URB_ASYNC_UNLINK set, ignoring.");
1385 }
1386
1387 /* One might think that urb->status = -EINPROGRESS would be a requirement for unlinking,
1388 but that doesn't work for interrupt and isochronous traffic since they are completed
1389 repeatedly, and urb->status is set then. That may in itself be a bug though. */
1390
1391 hc = urb->dev->bus->hcpriv;
1392 urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
1393 epid = urb_priv->epid;
1394
1395 /* Set the urb status (synchronous unlink). */
1396 urb->status = -ENOENT;
1397 urb_priv->urb_state = UNLINK;
1398
1399 if (usb_pipedevice(urb->pipe) == hc->rh.devnum) {
1400 int ret;
1401 ret = etrax_rh_unlink_urb(urb);
1402 DBFEXIT;
1403 restore_flags(flags);
1404 return ret;
1405
1406 } else if (usb_pipetype(urb->pipe) == PIPE_BULK) {
1407
1408 dbg_bulk("Unlink of bulk urb (0x%lx)", (unsigned long)urb);
1409
1410 if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
1411 /* The EP was enabled, disable it and wait. */
1412 TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
1413
1414 /* Ah, the luxury of busy-wait. */
1415 while (*R_DMA_CH8_SUB0_EP == virt_to_phys(&TxBulkEPList[epid]));
1416 }
1417 /* Kicking dummy list out of the party. */
1418 TxBulkEPList[epid].next = virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
1419
1420 } else if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
1421
1422 dbg_ctrl("Unlink of ctrl urb (0x%lx)", (unsigned long)urb);
1423
1424 if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
1425 /* The EP was enabled, disable it and wait. */
1426 TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
1427
1428 /* Ah, the luxury of busy-wait. */
1429 while (*R_DMA_CH8_SUB1_EP == virt_to_phys(&TxCtrlEPList[epid]));
1430 }
1431
1432 } else if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
1433
1434 dbg_intr("Unlink of intr urb (0x%lx)", (unsigned long)urb);
1435
1436 /* Separate function because it's a tad more complicated. */
1437 etrax_usb_unlink_intr_urb(urb);
1438
1439 } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
1440
1441 dbg_isoc("Unlink of isoc urb (0x%lx)", (unsigned long)urb);
1442
1443 if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
1444 /* The EP was enabled, disable it and wait. */
1445 TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
1446
1447 /* Ah, the luxury of busy-wait. */
1448 while (*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid]));
1449 }
1450 }
1451
1452 /* Note that we need to remove the urb from the urb list *before* removing its SB
1453 descriptors. (This means that the isoc eof handler might get a null urb when we
1454 are unlinking the last urb.) */
1455
1456 if (usb_pipetype(urb->pipe) == PIPE_BULK) {
1457
1458 urb_list_del(urb, epid);
1459 TxBulkEPList[epid].sub = 0;
1460 etrax_remove_from_sb_list(urb);
1461
1462 } else if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
1463
1464 urb_list_del(urb, epid);
1465 TxCtrlEPList[epid].sub = 0;
1466 etrax_remove_from_sb_list(urb);
1467
1468 } else if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
1469
1470 urb_list_del(urb, epid);
1471 /* Sanity check (should never happen). */
1472 assert(urb_list_empty(epid));
1473
1474 /* Release allocated bandwidth. */
1475 usb_release_bandwidth(urb->dev, urb, 0);
1476
1477 } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
1478
1479 if (usb_pipeout(urb->pipe)) {
1480
1481 USB_SB_Desc_t *iter_sb, *prev_sb, *next_sb;
1482
1483 if (__urb_list_entry(urb, epid)) {
1484
1485 urb_list_del(urb, epid);
1486 iter_sb = TxIsocEPList[epid].sub ? phys_to_virt(TxIsocEPList[epid].sub) : 0;
1487 prev_sb = 0;
1488 while (iter_sb && (iter_sb != urb_priv->first_sb)) {
1489 prev_sb = iter_sb;
1490 iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
1491 }
1492
1493 if (iter_sb == 0) {
1494 /* Unlink of the URB currently being transmitted. */
1495 prev_sb = 0;
1496 iter_sb = TxIsocEPList[epid].sub ? phys_to_virt(TxIsocEPList[epid].sub) : 0;
1497 }
1498
1499 while (iter_sb && (iter_sb != urb_priv->last_sb)) {
1500 iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
1501 }
1502 if (iter_sb) {
1503 next_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
1504 } else {
1505 /* This should only happen if the DMA has completed
1506 processing the SB list for this EP while interrupts
1507 are disabled. */
1508 dbg_isoc("Isoc urb not found, already sent?");
1509 next_sb = 0;
1510 }
1511 if (prev_sb) {
1512 prev_sb->next = next_sb ? virt_to_phys(next_sb) : 0;
1513 } else {
1514 TxIsocEPList[epid].sub = next_sb ? virt_to_phys(next_sb) : 0;
1515 }
1516
1517 etrax_remove_from_sb_list(urb);
1518 if (urb_list_empty(epid)) {
1519 TxIsocEPList[epid].sub = 0;
1520 dbg_isoc("Last isoc out urb epid %d", epid);
1521 } else if (next_sb || prev_sb) {
1522 dbg_isoc("Re-enable isoc out epid %d", epid);
1523
1524 TxIsocEPList[epid].hw_len = 0;
1525 TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
1526 } else {
1527 TxIsocEPList[epid].sub = 0;
1528 dbg_isoc("URB list non-empty and no SB list, EP disabled");
1529 }
1530 } else {
1531 dbg_isoc("Urb 0x%p not found, completed already?", urb);
1532 }
1533 } else {
1534
1535 urb_list_del(urb, epid);
1536
1537 /* For in traffic there is only one SB descriptor for each EP even
1538 though there may be several urbs (all urbs point at the same SB). */
1539 if (urb_list_empty(epid)) {
1540 /* No more urbs, remove the SB. */
1541 TxIsocEPList[epid].sub = 0;
1542 etrax_remove_from_sb_list(urb);
1543 } else {
1544 TxIsocEPList[epid].hw_len = 0;
1545 TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
1546 }
1547 }
1548 /* Release allocated bandwidth. */
1549 usb_release_bandwidth(urb->dev, urb, 1);
1550 }
1551 /* Free the epid if urb list is empty. */
1552 if (urb_list_empty(epid)) {
1553 etrax_usb_free_epid(epid);
1554 }
1555 restore_flags(flags);
1556
1557 /* Must be done before calling completion handler. */
1558 kfree(urb_priv);
1559 urb->hcpriv = 0;
1560
1561 if (urb->complete) {
1562 urb->complete(urb, NULL);
1563 }
1564
1565 DBFEXIT;
1566 return 0;
1567 }
1568
1569 static int etrax_usb_get_frame_number(struct usb_device *usb_dev)
1570 {
1571 DBFENTER;
1572 DBFEXIT;
1573 return (*R_USB_FM_NUMBER & 0x7ff);
1574 }
1575
1576 static irqreturn_t etrax_usb_tx_interrupt(int irq, void *vhc)
1577 {
1578 DBFENTER;
1579
1580 /* This interrupt handler could be used when unlinking EP descriptors. */
1581
1582 if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub0_descr)) {
1583 USB_EP_Desc_t *ep;
1584
1585 //dbg_bulk("dma8_sub0_descr (BULK) intr.");
1586
1587 /* It should be safe clearing the interrupt here, since we don't expect to get a new
1588 one until we restart the bulk channel. */
1589 *R_DMA_CH8_SUB0_CLR_INTR = IO_STATE(R_DMA_CH8_SUB0_CLR_INTR, clr_descr, do);
1590
1591 /* Wait while the DMA is running (though we don't expect it to be). */
1592 while (*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd));
1593
1594 /* Advance the DMA to the next EP descriptor. */
1595 ep = (USB_EP_Desc_t *)phys_to_virt(*R_DMA_CH8_SUB0_EP);
1596
1597 //dbg_bulk("descr intr: DMA is at 0x%lx", (unsigned long)ep);
1598
1599 /* ep->next is already a physical address; no need for a virt_to_phys. */
1600 *R_DMA_CH8_SUB0_EP = ep->next;
1601
1602 /* Start the DMA bulk channel again. */
1603 *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start);
1604 }
1605 if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub1_descr)) {
1606 struct urb *urb;
1607 int epid;
1608 etrax_urb_priv_t *urb_priv;
1609 unsigned long int flags;
1610
1611 dbg_ctrl("dma8_sub1_descr (CTRL) intr.");
1612 *R_DMA_CH8_SUB1_CLR_INTR = IO_STATE(R_DMA_CH8_SUB1_CLR_INTR, clr_descr, do);
1613
1614 /* The complete callback gets called so we cli. */
1615 save_flags(flags);
1616 cli();
1617
1618 for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
1619 if ((TxCtrlEPList[epid].sub == 0) ||
1620 (epid == DUMMY_EPID) ||
1621 (epid == INVALID_EPID)) {
1622 /* Nothing here to see. */
1623 continue;
1624 }
1625
1626 /* Get the first urb (if any). */
1627 urb = urb_list_first(epid);
1628
1629 if (urb) {
1630
1631 /* Sanity check. */
1632 assert(usb_pipetype(urb->pipe) == PIPE_CONTROL);
1633
1634 urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
1635 assert(urb_priv);
1636
1637 if (urb_priv->urb_state == WAITING_FOR_DESCR_INTR) {
1638 assert(!(TxCtrlEPList[urb_priv->epid].command & IO_MASK(USB_EP_command, enable)));
1639
1640 etrax_usb_complete_urb(urb, 0);
1641 }
1642 }
1643 }
1644 restore_flags(flags);
1645 }
1646 if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub2_descr)) {
1647 dbg_intr("dma8_sub2_descr (INTR) intr.");
1648 *R_DMA_CH8_SUB2_CLR_INTR = IO_STATE(R_DMA_CH8_SUB2_CLR_INTR, clr_descr, do);
1649 }
1650 if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub3_descr)) {
1651 struct urb *urb;
1652 int epid;
1653 int epid_done;
1654 etrax_urb_priv_t *urb_priv;
1655 USB_SB_Desc_t *sb_desc;
1656
1657 usb_isoc_complete_data_t *comp_data = NULL;
1658
1659 /* One or more isoc out transfers are done. */
1660 dbg_isoc("dma8_sub3_descr (ISOC) intr.");
1661
1662 /* For each isoc out EP search for the first sb_desc with the intr flag
1663 set. This descriptor must be the last packet from an URB. Then
1664 traverse the URB list for the EP until the URB with urb_priv->last_sb
1665 matching the intr-marked sb_desc is found. All URBs before this have
1666 been sent.
1667 */
1668
1669 for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
1670 /* Skip past epids with no SB lists, epids used for in traffic,
1671 and special (dummy, invalid) epids. */
1672 if ((TxIsocEPList[epid].sub == 0) ||
1673 (test_bit(epid, (void *)&epid_out_traffic) == 0) ||
1674 (epid == DUMMY_EPID) ||
1675 (epid == INVALID_EPID)) {
1676 /* Nothing here to see. */
1677 continue;
1678 }
1679 sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
1680
1681 /* Find the last descriptor of the currently active URB for this ep.
1682 This is the first descriptor in the sub list marked for a descriptor
1683 interrupt. */
1684 while (sb_desc && !IO_EXTRACT(USB_SB_command, intr, sb_desc->command)) {
1685 sb_desc = sb_desc->next ? phys_to_virt(sb_desc->next) : 0;
1686 }
1687 assert(sb_desc);
1688
1689 dbg_isoc("Check epid %d, sub 0x%p, SB 0x%p",
1690 epid,
1691 phys_to_virt(TxIsocEPList[epid].sub),
1692 sb_desc);
1693
1694 epid_done = 0;
1695
1696 /* Get the first urb (if any). */
1697 urb = urb_list_first(epid);
1698 assert(urb);
1699
1700 while (urb && !epid_done) {
1701
1702 /* Sanity check. */
1703 assert(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
1704
1705 if (!usb_pipeout(urb->pipe)) {
1706 /* descr interrupts are generated only for out pipes. */
1707 epid_done = 1;
1708 continue;
1709 }
1710
1711 urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
1712 assert(urb_priv);
1713
1714 if (sb_desc != urb_priv->last_sb) {
1715
1716 /* This urb has been sent. */
1717 dbg_isoc("out URB 0x%p sent", urb);
1718
1719 urb_priv->urb_state = TRANSFER_DONE;
1720
1721 } else if ((sb_desc == urb_priv->last_sb) &&
1722 !(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
1723
1724 assert((sb_desc->command & IO_MASK(USB_SB_command, eol)) == IO_STATE(USB_SB_command, eol, yes));
1725 assert(sb_desc->next == 0);
1726
1727 dbg_isoc("out URB 0x%p last in list, epid disabled", urb);
1728 TxIsocEPList[epid].sub = 0;
1729 TxIsocEPList[epid].hw_len = 0;
1730 urb_priv->urb_state = TRANSFER_DONE;
1731
1732 epid_done = 1;
1733
1734 } else {
1735 epid_done = 1;
1736 }
1737 if (!epid_done) {
1738 urb = urb_list_next(urb, epid);
1739 }
1740 }
1741
1742 }
1743
1744 *R_DMA_CH8_SUB3_CLR_INTR = IO_STATE(R_DMA_CH8_SUB3_CLR_INTR, clr_descr, do);
1745
1746 comp_data = (usb_isoc_complete_data_t*)kmem_cache_alloc(isoc_compl_cache, SLAB_ATOMIC);
1747 assert(comp_data != NULL);
1748
1749 INIT_WORK(&comp_data->usb_bh, etrax_usb_isoc_descr_interrupt_bottom_half, comp_data);
1750 schedule_work(&comp_data->usb_bh);
1751 }
1752
1753 DBFEXIT;
1754 return IRQ_HANDLED;
1755 }
1756
1757 static void etrax_usb_isoc_descr_interrupt_bottom_half(void *data)
1758 {
1759 usb_isoc_complete_data_t *comp_data = (usb_isoc_complete_data_t*)data;
1760
1761 struct urb *urb;
1762 int epid;
1763 int epid_done;
1764 etrax_urb_priv_t *urb_priv;
1765
1766 DBFENTER;
1767
1768 dbg_isoc("dma8_sub3_descr (ISOC) bottom half.");
1769
1770 for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
1771 unsigned long flags;
1772
1773 save_flags(flags);
1774 cli();
1775
1776 epid_done = 0;
1777
1778 /* The descriptor interrupt handler has marked all transmitted isoch. out
1779 URBs with TRANSFER_DONE. Now we traverse all epids and for all that
1780 have isoch. out traffic traverse its URB list and complete the
1781 transmitted URB.
1782 */
1783
1784 while (!epid_done) {
1785
1786 /* Get the first urb (if any). */
1787 urb = urb_list_first(epid);
1788 if (urb == 0) {
1789 epid_done = 1;
1790 continue;
1791 }
1792
1793 if (usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS) {
1794 epid_done = 1;
1795 continue;
1796 }
1797
1798 if (!usb_pipeout(urb->pipe)) {
1799 /* descr interrupts are generated only for out pipes. */
1800 epid_done = 1;
1801 continue;
1802 }
1803
1804 dbg_isoc("Check epid %d, SB 0x%p", epid, (char*)TxIsocEPList[epid].sub);
1805
1806 urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
1807 assert(urb_priv);
1808
1809 if (urb_priv->urb_state == TRANSFER_DONE) {
1810 int i;
1811 struct usb_iso_packet_descriptor *packet;
1812
1813 /* This urb has been sent. */
1814 dbg_isoc("Completing isoc out URB 0x%p", urb);
1815
1816 for (i = 0; i < urb->number_of_packets; i++) {
1817 packet = &urb->iso_frame_desc[i];
1818 packet->status = 0;
1819 packet->actual_length = packet->length;
1820 }
1821
1822 etrax_usb_complete_isoc_urb(urb, 0);
1823
1824 if (urb_list_empty(epid)) {
1825 etrax_usb_free_epid(epid);
1826 epid_done = 1;
1827 }
1828 } else {
1829 epid_done = 1;
1830 }
1831 }
1832 restore_flags(flags);
1833
1834 }
1835 kmem_cache_free(isoc_compl_cache, comp_data);
1836
1837 DBFEXIT;
1838 }
1839
1840
1841
1842 static irqreturn_t etrax_usb_rx_interrupt(int irq, void *vhc)
1843 {
1844 struct urb *urb;
1845 etrax_urb_priv_t *urb_priv;
1846 int epid = 0;
1847 unsigned long flags;
1848
1849 /* Isoc diagnostics. */
1850 static int curr_fm = 0;
1851 static int prev_fm = 0;
1852
1853 DBFENTER;
1854
1855 /* Clear this interrupt. */
1856 *R_DMA_CH9_CLR_INTR = IO_STATE(R_DMA_CH9_CLR_INTR, clr_eop, do);
1857
1858 /* Note that this while loop assumes that all packets span only
1859 one rx descriptor. */
1860
1861 /* The reason we cli here is that we call the driver's callback functions. */
1862 save_flags(flags);
1863 cli();
1864
1865 while (myNextRxDesc->status & IO_MASK(USB_IN_status, eop)) {
1866
1867 epid = IO_EXTRACT(USB_IN_status, epid, myNextRxDesc->status);
1868 urb = urb_list_first(epid);
1869
1870 //printk("eop for epid %d, first urb 0x%lx\n", epid, (unsigned long)urb);
1871
1872 if (!urb) {
1873 err("No urb for epid %d in rx interrupt", epid);
1874 __dump_ept_data(epid);
1875 goto skip_out;
1876 }
1877
1878 /* Note that we cannot indescriminately assert(usb_pipein(urb->pipe)) since
1879 ctrl pipes are not. */
1880
1881 if (myNextRxDesc->status & IO_MASK(USB_IN_status, error)) {
1882 __u32 r_usb_ept_data;
1883 int no_error = 0;
1884
1885 assert(test_bit(epid, (void *)&epid_usage_bitmask));
1886
1887 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
1888 nop();
1889 if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
1890 r_usb_ept_data = *R_USB_EPT_DATA_ISO;
1891
1892 if ((r_usb_ept_data & IO_MASK(R_USB_EPT_DATA_ISO, valid)) &&
1893 (IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code, r_usb_ept_data) == 0) &&
1894 (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata))) {
1895 /* Not an error, just a failure to receive an expected iso
1896 in packet in this frame. This is not documented
1897 in the designers reference.
1898 */
1899 no_error++;
1900 } else {
1901 warn("R_USB_EPT_DATA_ISO for epid %d = 0x%x", epid, r_usb_ept_data);
1902 }
1903 } else {
1904 r_usb_ept_data = *R_USB_EPT_DATA;
1905 warn("R_USB_EPT_DATA for epid %d = 0x%x", epid, r_usb_ept_data);
1906 }
1907
1908 if (!no_error){
1909 warn("error in rx desc->status, epid %d, first urb = 0x%lx",
1910 epid, (unsigned long)urb);
1911 __dump_in_desc(myNextRxDesc);
1912
1913 warn("R_USB_STATUS = 0x%x", *R_USB_STATUS);
1914
1915 /* Check that ept was disabled when error occurred. */
1916 switch (usb_pipetype(urb->pipe)) {
1917 case PIPE_BULK:
1918 assert(!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)));
1919 break;
1920 case PIPE_CONTROL:
1921 assert(!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)));
1922 break;
1923 case PIPE_INTERRUPT:
1924 assert(!(TxIntrEPList[epid].command & IO_MASK(USB_EP_command, enable)));
1925 break;
1926 case PIPE_ISOCHRONOUS:
1927 assert(!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)));
1928 break;
1929 default:
1930 warn("etrax_usb_rx_interrupt: bad pipetype %d in urb 0x%p",
1931 usb_pipetype(urb->pipe),
1932 urb);
1933 }
1934 etrax_usb_complete_urb(urb, -EPROTO);
1935 goto skip_out;
1936 }
1937 }
1938
1939 urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
1940 assert(urb_priv);
1941
1942 if ((usb_pipetype(urb->pipe) == PIPE_BULK) ||
1943 (usb_pipetype(urb->pipe) == PIPE_CONTROL) ||
1944 (usb_pipetype(urb->pipe) == PIPE_INTERRUPT)) {
1945
1946 if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
1947 /* We get nodata for empty data transactions, and the rx descriptor's
1948 hw_len field is not valid in that case. No data to copy in other
1949 words. */
1950 } else {
1951 /* Make sure the data fits in the buffer. */
1952 assert(urb_priv->rx_offset + myNextRxDesc->hw_len
1953 <= urb->transfer_buffer_length);
1954
1955 memcpy(urb->transfer_buffer + urb_priv->rx_offset,
1956 phys_to_virt(myNextRxDesc->buf), myNextRxDesc->hw_len);
1957 urb_priv->rx_offset += myNextRxDesc->hw_len;
1958 }
1959
1960 if (myNextRxDesc->status & IO_MASK(USB_IN_status, eot)) {
1961 if ((usb_pipetype(urb->pipe) == PIPE_CONTROL) &&
1962 ((TxCtrlEPList[urb_priv->epid].command & IO_MASK(USB_EP_command, enable)) ==
1963 IO_STATE(USB_EP_command, enable, yes))) {
1964 /* The EP is still enabled, so the OUT packet used to ack
1965 the in data is probably not processed yet. If the EP
1966 sub pointer has not moved beyond urb_priv->last_sb mark
1967 it for a descriptor interrupt and complete the urb in
1968 the descriptor interrupt handler.
1969 */
1970 USB_SB_Desc_t *sub = TxCtrlEPList[urb_priv->epid].sub ? phys_to_virt(TxCtrlEPList[urb_priv->epid].sub) : 0;
1971
1972 while ((sub != NULL) && (sub != urb_priv->last_sb)) {
1973 sub = sub->next ? phys_to_virt(sub->next) : 0;
1974 }
1975 if (sub != NULL) {
1976 /* The urb has not been fully processed. */
1977 urb_priv->urb_state = WAITING_FOR_DESCR_INTR;
1978 } else {
1979 warn("(CTRL) epid enabled and urb (0x%p) processed, ep->sub=0x%p", urb, (char*)TxCtrlEPList[urb_priv->epid].sub);
1980 etrax_usb_complete_urb(urb, 0);
1981 }
1982 } else {
1983 etrax_usb_complete_urb(urb, 0);
1984 }
1985 }
1986
1987 } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
1988
1989 struct usb_iso_packet_descriptor *packet;
1990
1991 if (urb_priv->urb_state == UNLINK) {
1992 info("Ignoring rx data for urb being unlinked.");
1993 goto skip_out;
1994 } else if (urb_priv->urb_state == NOT_STARTED) {
1995 info("What? Got rx data for urb that isn't started?");
1996 goto skip_out;
1997 }
1998
1999 packet = &urb->iso_frame_desc[urb_priv->isoc_packet_counter];
2000 packet->status = 0;
2001
2002 if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
2003 /* We get nodata for empty data transactions, and the rx descriptor's
2004 hw_len field is not valid in that case. We copy 0 bytes however to
2005 stay in synch. */
2006 packet->actual_length = 0;
2007 } else {
2008 packet->actual_length = myNextRxDesc->hw_len;
2009 /* Make sure the data fits in the buffer. */
2010 assert(packet->actual_length <= packet->length);
2011 memcpy(urb->transfer_buffer + packet->offset,
2012 phys_to_virt(myNextRxDesc->buf), packet->actual_length);
2013 }
2014
2015 /* Increment the packet counter. */
2016 urb_priv->isoc_packet_counter++;
2017
2018 /* Note that we don't care about the eot field in the rx descriptor's status.
2019 It will always be set for isoc traffic. */
2020 if (urb->number_of_packets == urb_priv->isoc_packet_counter) {
2021
2022 /* Out-of-synch diagnostics. */
2023 curr_fm = (*R_USB_FM_NUMBER & 0x7ff);
2024 if (((prev_fm + urb_priv->isoc_packet_counter) % (0x7ff + 1)) != curr_fm) {
2025 /* This test is wrong, if there is more than one isoc
2026 in endpoint active it will always calculate wrong
2027 since prev_fm is shared by all endpoints.
2028
2029 FIXME Make this check per URB using urb->start_frame.
2030 */
2031 dbg_isoc("Out of synch? Previous frame = %d, current frame = %d",
2032 prev_fm, curr_fm);
2033
2034 }
2035 prev_fm = curr_fm;
2036
2037 /* Complete the urb with status OK. */
2038 etrax_usb_complete_isoc_urb(urb, 0);
2039 }
2040 }
2041
2042 skip_out:
2043
2044 /* DMA IN cache bug. Flush the DMA IN buffer from the cache. (struct etrax_dma_descr
2045 has the same layout as USB_IN_Desc for the relevant fields.) */
2046 prepare_rx_descriptor((struct etrax_dma_descr*)myNextRxDesc);
2047
2048 myPrevRxDesc = myNextRxDesc;
2049 myPrevRxDesc->command |= IO_MASK(USB_IN_command, eol);
2050 myLastRxDesc->command &= ~IO_MASK(USB_IN_command, eol);
2051 myLastRxDesc = myPrevRxDesc;
2052
2053 myNextRxDesc->status = 0;
2054 myNextRxDesc = phys_to_virt(myNextRxDesc->next);
2055 }
2056
2057 restore_flags(flags);
2058
2059 DBFEXIT;
2060
2061 return IRQ_HANDLED;
2062 }
2063
2064
2065 /* This function will unlink the SB descriptors associated with this urb. */
2066 static int etrax_remove_from_sb_list(struct urb *urb)
2067 {
2068 USB_SB_Desc_t *next_sb, *first_sb, *last_sb;
2069 etrax_urb_priv_t *urb_priv;
2070 int i = 0;
2071
2072 DBFENTER;
2073
2074 urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
2075 assert(urb_priv);
2076
2077 /* Just a sanity check. Since we don't fiddle with the DMA list the EP descriptor
2078 doesn't really need to be disabled, it's just that we expect it to be. */
2079 if (usb_pipetype(urb->pipe) == PIPE_BULK) {
2080 assert(!(TxBulkEPList[urb_priv->epid].command & IO_MASK(USB_EP_command, enable)));
2081 } else if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
2082 assert(!(TxCtrlEPList[urb_priv->epid].command & IO_MASK(USB_EP_command, enable)));
2083 }
2084
2085 first_sb = urb_priv->first_sb;
2086 last_sb = urb_priv->last_sb;
2087
2088 assert(first_sb);
2089 assert(last_sb);
2090
2091 while (first_sb != last_sb) {
2092 next_sb = (USB_SB_Desc_t *)phys_to_virt(first_sb->next);
2093 kmem_cache_free(usb_desc_cache, first_sb);
2094 first_sb = next_sb;
2095 i++;
2096 }
2097 kmem_cache_free(usb_desc_cache, last_sb);
2098 i++;
2099 dbg_sb("%d SB descriptors freed", i);
2100 /* Compare i with urb->number_of_packets for Isoc traffic.
2101 Should be same when calling unlink_urb */
2102
2103 DBFEXIT;
2104
2105 return i;
2106 }
2107
2108 static int etrax_usb_submit_bulk_urb(struct urb *urb)
2109 {
2110 int epid;
2111 int empty;
2112 unsigned long flags;
2113 etrax_urb_priv_t *urb_priv;
2114
2115 DBFENTER;
2116
2117 /* Epid allocation, empty check and list add must be protected.
2118 Read about this in etrax_usb_submit_ctrl_urb. */
2119
2120 spin_lock_irqsave(&urb_list_lock, flags);
2121 epid = etrax_usb_setup_epid(urb);
2122 if (epid == -1) {
2123 DBFEXIT;
2124 spin_unlock_irqrestore(&urb_list_lock, flags);
2125 return -ENOMEM;
2126 }
2127 empty = urb_list_empty(epid);
2128 urb_list_add(urb, epid);
2129 spin_unlock_irqrestore(&urb_list_lock, flags);
2130
2131 dbg_bulk("Adding bulk %s urb 0x%lx to %s list, epid %d",
2132 usb_pipein(urb->pipe) ? "IN" : "OUT", (unsigned long)urb, empty ? "empty" : "", epid);
2133
2134 /* Mark the urb as being in progress. */
2135 urb->status = -EINPROGRESS;
2136
2137 /* Setup the hcpriv data. */
2138 urb_priv = kzalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
2139 assert(urb_priv != NULL);
2140 /* This sets rx_offset to 0. */
2141 urb_priv->urb_state = NOT_STARTED;
2142 urb->hcpriv = urb_priv;
2143
2144 if (empty) {
2145 etrax_usb_add_to_bulk_sb_list(urb, epid);
2146 }
2147
2148 DBFEXIT;
2149
2150 return 0;
2151 }
2152
2153 static void etrax_usb_add_to_bulk_sb_list(struct urb *urb, int epid)
2154 {
2155 USB_SB_Desc_t *sb_desc;
2156 etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
2157 unsigned long flags;
2158 char maxlen;
2159
2160 DBFENTER;
2161
2162 dbg_bulk("etrax_usb_add_to_bulk_sb_list, urb 0x%lx", (unsigned long)urb);
2163
2164 maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
2165
2166 sb_desc = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
2167 assert(sb_desc != NULL);
2168 memset(sb_desc, 0, sizeof(USB_SB_Desc_t));
2169
2170
2171 if (usb_pipeout(urb->pipe)) {
2172
2173 dbg_bulk("Grabbing bulk OUT, urb 0x%lx, epid %d", (unsigned long)urb, epid);
2174
2175 /* This is probably a sanity check of the bulk transaction length
2176 not being larger than 64 kB. */
2177 if (urb->transfer_buffer_length > 0xffff) {
2178 panic("urb->transfer_buffer_length > 0xffff");
2179 }
2180
2181 sb_desc->sw_len = urb->transfer_buffer_length;
2182
2183 /* The rem field is don't care if it's not a full-length transfer, so setting
2184 it shouldn't hurt. Also, rem isn't used for OUT traffic. */
2185 sb_desc->command = (IO_FIELD(USB_SB_command, rem, 0) |
2186 IO_STATE(USB_SB_command, tt, out) |
2187 IO_STATE(USB_SB_command, eot, yes) |
2188 IO_STATE(USB_SB_command, eol, yes));
2189
2190 /* The full field is set to yes, even if we don't actually check that this is
2191 a full-length transfer (i.e., that transfer_buffer_length % maxlen = 0).
2192 Setting full prevents the USB controller from sending an empty packet in
2193 that case. However, if URB_ZERO_PACKET was set we want that. */
2194 if (!(urb->transfer_flags & URB_ZERO_PACKET)) {
2195 sb_desc->command |= IO_STATE(USB_SB_command, full, yes);
2196 }
2197
2198 sb_desc->buf = virt_to_phys(urb->transfer_buffer);
2199 sb_desc->next = 0;
2200
2201 } else if (usb_pipein(urb->pipe)) {
2202
2203 dbg_bulk("Grabbing bulk IN, urb 0x%lx, epid %d", (unsigned long)urb, epid);
2204
2205 sb_desc->sw_len = urb->transfer_buffer_length ?
2206 (urb->transfer_buffer_length - 1) / maxlen + 1 : 0;
2207
2208 /* The rem field is don't care if it's not a full-length transfer, so setting
2209 it shouldn't hurt. */
2210 sb_desc->command =
2211 (IO_FIELD(USB_SB_command, rem,
2212 urb->transfer_buffer_length % maxlen) |
2213 IO_STATE(USB_SB_command, tt, in) |
2214 IO_STATE(USB_SB_command, eot, yes) |
2215 IO_STATE(USB_SB_command, eol, yes));
2216
2217 sb_desc->buf = 0;
2218 sb_desc->next = 0;
2219 }
2220
2221 urb_priv->first_sb = sb_desc;
2222 urb_priv->last_sb = sb_desc;
2223 urb_priv->epid = epid;
2224
2225 urb->hcpriv = urb_priv;
2226
2227 /* Reset toggle bits and reset error count. */
2228 save_flags(flags);
2229 cli();
2230
2231 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
2232 nop();
2233
2234 /* FIXME: Is this a special case since the hold field is checked,
2235 or should we check hold in a lot of other cases as well? */
2236 if (*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) {
2237 panic("Hold was set in %s", __FUNCTION__);
2238 }
2239
2240 /* Reset error counters (regardless of which direction this traffic is). */
2241 *R_USB_EPT_DATA &=
2242 ~(IO_MASK(R_USB_EPT_DATA, error_count_in) |
2243 IO_MASK(R_USB_EPT_DATA, error_count_out));
2244
2245 /* Software must preset the toggle bits. */
2246 if (usb_pipeout(urb->pipe)) {
2247 char toggle =
2248 usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe));
2249 *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_out);
2250 *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_out, toggle);
2251 } else {
2252 char toggle =
2253 usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe));
2254 *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_in);
2255 *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_in, toggle);
2256 }
2257
2258 /* Assert that the EP descriptor is disabled. */
2259 assert(!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)));
2260
2261 /* The reason we set the EP's sub pointer directly instead of
2262 walking the SB list and linking it last in the list is that we only
2263 have one active urb at a time (the rest are queued). */
2264
2265 /* Note that we cannot have interrupts running when we have set the SB descriptor
2266 but the EP is not yet enabled. If a bulk eot happens for another EP, we will
2267 find this EP disabled and with a SB != 0, which will make us think that it's done. */
2268 TxBulkEPList[epid].sub = virt_to_phys(sb_desc);
2269 TxBulkEPList[epid].hw_len = 0;
2270 /* Note that we don't have to fill in the ep_id field since this
2271 was done when we allocated the EP descriptors in init_tx_bulk_ep. */
2272
2273 /* Check if the dummy list is already with us (if several urbs were queued). */
2274 if (TxBulkEPList[epid].next != virt_to_phys(&TxBulkDummyEPList[epid][0])) {
2275
2276 dbg_bulk("Inviting dummy list to the party for urb 0x%lx, epid %d",
2277 (unsigned long)urb, epid);
2278
2279 /* The last EP in the dummy list already has its next pointer set to
2280 TxBulkEPList[epid].next. */
2281
2282 /* We don't need to check if the DMA is at this EP or not before changing the
2283 next pointer, since we will do it in one 32-bit write (EP descriptors are
2284 32-bit aligned). */
2285 TxBulkEPList[epid].next = virt_to_phys(&TxBulkDummyEPList[epid][0]);
2286 }
2287 /* Enable the EP descr. */
2288 dbg_bulk("Enabling bulk EP for urb 0x%lx, epid %d", (unsigned long)urb, epid);
2289 TxBulkEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
2290
2291 /* Everything is set up, safe to enable interrupts again. */
2292 restore_flags(flags);
2293
2294 /* If the DMA bulk channel isn't running, we need to restart it if it
2295 has stopped at the last EP descriptor (DMA stopped because there was
2296 no more traffic) or if it has stopped at a dummy EP with the intr flag
2297 set (DMA stopped because we were too slow in inserting new traffic). */
2298 if (!(*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd))) {
2299
2300 USB_EP_Desc_t *ep;
2301 ep = (USB_EP_Desc_t *)phys_to_virt(*R_DMA_CH8_SUB0_EP);
2302 dbg_bulk("DMA channel not running in add");
2303 dbg_bulk("DMA is at 0x%lx", (unsigned long)ep);
2304
2305 if (*R_DMA_CH8_SUB0_EP == virt_to_phys(&TxBulkEPList[NBR_OF_EPIDS - 1]) ||
2306 (ep->command & 0x8) >> 3) {
2307 *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start);
2308 /* Update/restart the bulk start timer since we just started the channel. */
2309 mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
2310 /* Update/restart the bulk eot timer since we just inserted traffic. */
2311 mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
2312 }
2313 }
2314
2315 DBFEXIT;
2316 }
2317
2318 static void etrax_usb_complete_bulk_urb(struct urb *urb, int status)
2319 {
2320 etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
2321 int epid = urb_priv->epid;
2322 unsigned long flags;
2323
2324 DBFENTER;
2325
2326 if (status)
2327 warn("Completing bulk urb with status %d.", status);
2328
2329 dbg_bulk("Completing bulk urb 0x%lx for epid %d", (unsigned long)urb, epid);
2330
2331 /* Update the urb list. */
2332 urb_list_del(urb, epid);
2333
2334 /* For an IN pipe, we always set the actual length, regardless of whether there was
2335 an error or not (which means the device driver can use the data if it wants to). */
2336 if (usb_pipein(urb->pipe)) {
2337 urb->actual_length = urb_priv->rx_offset;
2338 } else {
2339 /* Set actual_length for OUT urbs also; the USB mass storage driver seems
2340 to want that. We wouldn't know of any partial writes if there was an error. */
2341 if (status == 0) {
2342 urb->actual_length = urb->transfer_buffer_length;
2343 } else {
2344 urb->actual_length = 0;
2345 }
2346 }
2347
2348 /* FIXME: Is there something of the things below we shouldn't do if there was an error?
2349 Like, maybe we shouldn't toggle the toggle bits, or maybe we shouldn't insert more traffic. */
2350
2351 save_flags(flags);
2352 cli();
2353
2354 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
2355 nop();
2356
2357 /* We need to fiddle with the toggle bits because the hardware doesn't do it for us. */
2358 if (usb_pipeout(urb->pipe)) {
2359 char toggle =
2360 IO_EXTRACT(R_USB_EPT_DATA, t_out, *R_USB_EPT_DATA);
2361 usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
2362 usb_pipeout(urb->pipe), toggle);
2363 } else {
2364 char toggle =
2365 IO_EXTRACT(R_USB_EPT_DATA, t_in, *R_USB_EPT_DATA);
2366 usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
2367 usb_pipeout(urb->pipe), toggle);
2368 }
2369 restore_flags(flags);
2370
2371 /* Remember to free the SBs. */
2372 etrax_remove_from_sb_list(urb);
2373 kfree(urb_priv);
2374 urb->hcpriv = 0;
2375
2376 /* If there are any more urb's in the list we'd better start sending */
2377 if (!urb_list_empty(epid)) {
2378
2379 struct urb *new_urb;
2380
2381 /* Get the first urb. */
2382 new_urb = urb_list_first(epid);
2383 assert(new_urb);
2384
2385 dbg_bulk("More bulk for epid %d", epid);
2386
2387 etrax_usb_add_to_bulk_sb_list(new_urb, epid);
2388 }
2389
2390 urb->status = status;
2391
2392 /* We let any non-zero status from the layer above have precedence. */
2393 if (status == 0) {
2394 /* URB_SHORT_NOT_OK means that short reads (shorter than the endpoint's max length)
2395 is to be treated as an error. */
2396 if (urb->transfer_flags & URB_SHORT_NOT_OK) {
2397 if (usb_pipein(urb->pipe) &&
2398 (urb->actual_length !=
2399 usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)))) {
2400 urb->status = -EREMOTEIO;
2401 }
2402 }
2403 }
2404
2405 if (urb->complete) {
2406 urb->complete(urb, NULL);
2407 }
2408
2409 if (urb_list_empty(epid)) {
2410 /* This means that this EP is now free, deconfigure it. */
2411 etrax_usb_free_epid(epid);
2412
2413 /* No more traffic; time to clean up.
2414 Must set sub pointer to 0, since we look at the sub pointer when handling
2415 the bulk eot interrupt. */
2416
2417 dbg_bulk("No bulk for epid %d", epid);
2418
2419 TxBulkEPList[epid].sub = 0;
2420
2421 /* Unlink the dummy list. */
2422
2423 dbg_bulk("Kicking dummy list out of party for urb 0x%lx, epid %d",
2424 (unsigned long)urb, epid);
2425
2426 /* No need to wait for the DMA before changing the next pointer.
2427 The modulo NBR_OF_EPIDS isn't actually necessary, since we will never use
2428 the last one (INVALID_EPID) for actual traffic. */
2429 TxBulkEPList[epid].next =
2430 virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
2431 }
2432
2433 DBFEXIT;
2434 }
2435
2436 static int etrax_usb_submit_ctrl_urb(struct urb *urb)
2437 {
2438 int epid;
2439 int empty;
2440 unsigned long flags;
2441 etrax_urb_priv_t *urb_priv;
2442
2443 DBFENTER;
2444
2445 /* FIXME: Return -ENXIO if there is already a queued urb for this endpoint? */
2446
2447 /* Epid allocation, empty check and list add must be protected.
2448
2449 Epid allocation because if we find an existing epid for this endpoint an urb might be
2450 completed (emptying the list) before we add the new urb to the list, causing the epid
2451 to be de-allocated. We would then start the transfer with an invalid epid -> epid attn.
2452
2453 Empty check and add because otherwise we might conclude that the list is not empty,
2454 after which it becomes empty before we add the new urb to the list, causing us not to
2455 insert the new traffic into the SB list. */
2456
2457 spin_lock_irqsave(&urb_list_lock, flags);
2458 epid = etrax_usb_setup_epid(urb);
2459 if (epid == -1) {
2460 spin_unlock_irqrestore(&urb_list_lock, flags);
2461 DBFEXIT;
2462 return -ENOMEM;
2463 }
2464 empty = urb_list_empty(epid);
2465 urb_list_add(urb, epid);
2466 spin_unlock_irqrestore(&urb_list_lock, flags);
2467
2468 dbg_ctrl("Adding ctrl urb 0x%lx to %s list, epid %d",
2469 (unsigned long)urb, empty ? "empty" : "", epid);
2470
2471 /* Mark the urb as being in progress. */
2472 urb->status = -EINPROGRESS;
2473
2474 /* Setup the hcpriv data. */
2475 urb_priv = kzalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
2476 assert(urb_priv != NULL);
2477 /* This sets rx_offset to 0. */
2478 urb_priv->urb_state = NOT_STARTED;
2479 urb->hcpriv = urb_priv;
2480
2481 if (empty) {
2482 etrax_usb_add_to_ctrl_sb_list(urb, epid);
2483 }
2484
2485 DBFEXIT;
2486
2487 return 0;
2488 }
2489
2490 static void etrax_usb_add_to_ctrl_sb_list(struct urb *urb, int epid)
2491 {
2492 USB_SB_Desc_t *sb_desc_setup;
2493 USB_SB_Desc_t *sb_desc_data;
2494 USB_SB_Desc_t *sb_desc_status;
2495
2496 etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
2497
2498 unsigned long flags;
2499 char maxlen;
2500
2501 DBFENTER;
2502
2503 maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
2504
2505 sb_desc_setup = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
2506 assert(sb_desc_setup != NULL);
2507 sb_desc_status = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
2508 assert(sb_desc_status != NULL);
2509
2510 /* Initialize the mandatory setup SB descriptor (used only in control transfers) */
2511 sb_desc_setup->sw_len = 8;
2512 sb_desc_setup->command = (IO_FIELD(USB_SB_command, rem, 0) |
2513 IO_STATE(USB_SB_command, tt, setup) |
2514 IO_STATE(USB_SB_command, full, yes) |
2515 IO_STATE(USB_SB_command, eot, yes));
2516
2517 sb_desc_setup->buf = virt_to_phys(urb->setup_packet);
2518
2519 if (usb_pipeout(urb->pipe)) {
2520 dbg_ctrl("Transfer for epid %d is OUT", epid);
2521
2522 /* If this Control OUT transfer has an optional data stage we add an OUT token
2523 before the mandatory IN (status) token, hence the reordered SB list */
2524
2525 sb_desc_setup->next = virt_to_phys(sb_desc_status);
2526 if (urb->transfer_buffer) {
2527
2528 dbg_ctrl("This OUT transfer has an extra data stage");
2529
2530 sb_desc_data = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
2531 assert(sb_desc_data != NULL);
2532
2533 sb_desc_setup->next = virt_to_phys(sb_desc_data);
2534
2535 sb_desc_data->sw_len = urb->transfer_buffer_length;
2536 sb_desc_data->command = (IO_STATE(USB_SB_command, tt, out) |
2537 IO_STATE(USB_SB_command, full, yes) |
2538 IO_STATE(USB_SB_command, eot, yes));
2539 sb_desc_data->buf = virt_to_phys(urb->transfer_buffer);
2540 sb_desc_data->next = virt_to_phys(sb_desc_status);
2541 }
2542
2543 sb_desc_status->sw_len = 1;
2544 sb_desc_status->command = (IO_FIELD(USB_SB_command, rem, 0) |
2545 IO_STATE(USB_SB_command, tt, in) |
2546 IO_STATE(USB_SB_command, eot, yes) |
2547 IO_STATE(USB_SB_command, intr, yes) |
2548 IO_STATE(USB_SB_command, eol, yes));
2549
2550 sb_desc_status->buf = 0;
2551 sb_desc_status->next = 0;
2552
2553 } else if (usb_pipein(urb->pipe)) {
2554
2555 dbg_ctrl("Transfer for epid %d is IN", epid);
2556 dbg_ctrl("transfer_buffer_length = %d", urb->transfer_buffer_length);
2557 dbg_ctrl("rem is calculated to %d", urb->transfer_buffer_length % maxlen);
2558
2559 sb_desc_data = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
2560 assert(sb_desc_data != NULL);
2561
2562 sb_desc_setup->next = virt_to_phys(sb_desc_data);
2563
2564 sb_desc_data->sw_len = urb->transfer_buffer_length ?
2565 (urb->transfer_buffer_length - 1) / maxlen + 1 : 0;
2566 dbg_ctrl("sw_len got %d", sb_desc_data->sw_len);
2567
2568 sb_desc_data->command =
2569 (IO_FIELD(USB_SB_command, rem,
2570 urb->transfer_buffer_length % maxlen) |
2571 IO_STATE(USB_SB_command, tt, in) |
2572 IO_STATE(USB_SB_command, eot, yes));
2573
2574 sb_desc_data->buf = 0;
2575 sb_desc_data->next = virt_to_phys(sb_desc_status);
2576
2577 /* Read comment at zout_buffer declaration for an explanation to this. */
2578 sb_desc_status->sw_len = 1;
2579 sb_desc_status->command = (IO_FIELD(USB_SB_command, rem, 0) |
2580 IO_STATE(USB_SB_command, tt, zout) |
2581 IO_STATE(USB_SB_command, full, yes) |
2582 IO_STATE(USB_SB_command, eot, yes) |
2583 IO_STATE(USB_SB_command, intr, yes) |
2584 IO_STATE(USB_SB_command, eol, yes));
2585
2586 sb_desc_status->buf = virt_to_phys(&zout_buffer[0]);
2587 sb_desc_status->next = 0;
2588 }
2589
2590 urb_priv->first_sb = sb_desc_setup;
2591 urb_priv->last_sb = sb_desc_status;
2592 urb_priv->epid = epid;
2593
2594 urb_priv->urb_state = STARTED;
2595
2596 /* Reset toggle bits and reset error count, remember to di and ei */
2597 /* Warning: it is possible that this locking doesn't work with bottom-halves */
2598
2599 save_flags(flags);
2600 cli();
2601
2602 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
2603 nop();
2604 if (*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) {
2605 panic("Hold was set in %s", __FUNCTION__);
2606 }
2607
2608
2609 /* FIXME: Compare with etrax_usb_add_to_bulk_sb_list where the toggle bits
2610 are set to a specific value. Why the difference? Read "Transfer and Toggle Bits
2611 in Designer's Reference, p. 8 - 11. */
2612 *R_USB_EPT_DATA &=
2613 ~(IO_MASK(R_USB_EPT_DATA, error_count_in) |
2614 IO_MASK(R_USB_EPT_DATA, error_count_out) |
2615 IO_MASK(R_USB_EPT_DATA, t_in) |
2616 IO_MASK(R_USB_EPT_DATA, t_out));
2617
2618 /* Since we use the rx interrupt to complete ctrl urbs, we can enable interrupts now
2619 (i.e. we don't check the sub pointer on an eot interrupt like we do for bulk traffic). */
2620 restore_flags(flags);
2621
2622 /* Assert that the EP descriptor is disabled. */
2623 assert(!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)));
2624
2625 /* Set up and enable the EP descriptor. */
2626 TxCtrlEPList[epid].sub = virt_to_phys(sb_desc_setup);
2627 TxCtrlEPList[epid].hw_len = 0;
2628 TxCtrlEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
2629
2630 /* We start the DMA sub channel without checking if it's running or not, because:
2631 1) If it's already running, issuing the start command is a nop.
2632 2) We avoid a test-and-set race condition. */
2633 *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB1_CMD, cmd, start);
2634
2635 DBFEXIT;
2636 }
2637
2638 static void etrax_usb_complete_ctrl_urb(struct urb *urb, int status)
2639 {
2640 etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
2641 int epid = urb_priv->epid;
2642
2643 DBFENTER;
2644
2645 if (status)
2646 warn("Completing ctrl urb with status %d.", status);
2647
2648 dbg_ctrl("Completing ctrl epid %d, urb 0x%lx", epid, (unsigned long)urb);
2649
2650 /* Remove this urb from the list. */
2651 urb_list_del(urb, epid);
2652
2653 /* For an IN pipe, we always set the actual length, regardless of whether there was
2654 an error or not (which means the device driver can use the data if it wants to). */
2655 if (usb_pipein(urb->pipe)) {
2656 urb->actual_length = urb_priv->rx_offset;
2657 }
2658
2659 /* FIXME: Is there something of the things below we shouldn't do if there was an error?
2660 Like, maybe we shouldn't insert more traffic. */
2661
2662 /* Remember to free the SBs. */
2663 etrax_remove_from_sb_list(urb);
2664 kfree(urb_priv);
2665 urb->hcpriv = 0;
2666
2667 /* If there are any more urbs in the list we'd better start sending. */
2668 if (!urb_list_empty(epid)) {
2669 struct urb *new_urb;
2670
2671 /* Get the first urb. */
2672 new_urb = urb_list_first(epid);
2673 assert(new_urb);
2674
2675 dbg_ctrl("More ctrl for epid %d, first urb = 0x%lx", epid, (unsigned long)new_urb);
2676
2677 etrax_usb_add_to_ctrl_sb_list(new_urb, epid);
2678 }
2679
2680 urb->status = status;
2681
2682 /* We let any non-zero status from the layer above have precedence. */
2683 if (status == 0) {
2684 /* URB_SHORT_NOT_OK means that short reads (shorter than the endpoint's max length)
2685 is to be treated as an error. */
2686 if (urb->transfer_flags & URB_SHORT_NOT_OK) {
2687 if (usb_pipein(urb->pipe) &&
2688 (urb->actual_length !=
2689 usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe)))) {
2690 urb->status = -EREMOTEIO;
2691 }
2692 }
2693 }
2694
2695 if (urb->complete) {
2696 urb->complete(urb, NULL);
2697 }
2698
2699 if (urb_list_empty(epid)) {
2700 /* No more traffic. Time to clean up. */
2701 etrax_usb_free_epid(epid);
2702 /* Must set sub pointer to 0. */
2703 dbg_ctrl("No ctrl for epid %d", epid);
2704 TxCtrlEPList[epid].sub = 0;
2705 }
2706
2707 DBFEXIT;
2708 }
2709
2710 static int etrax_usb_submit_intr_urb(struct urb *urb)
2711 {
2712
2713 int epid;
2714
2715 DBFENTER;
2716
2717 if (usb_pipeout(urb->pipe)) {
2718 /* Unsupported transfer type.
2719 We don't support interrupt out traffic. (If we do, we can't support
2720 intervals for neither in or out traffic, but are forced to schedule all
2721 interrupt traffic in one frame.) */
2722 return -EINVAL;
2723 }
2724
2725 epid = etrax_usb_setup_epid(urb);
2726 if (epid == -1) {
2727 DBFEXIT;
2728 return -ENOMEM;
2729 }
2730
2731 if (!urb_list_empty(epid)) {
2732 /* There is already a queued urb for this endpoint. */
2733 etrax_usb_free_epid(epid);
2734 return -ENXIO;
2735 }
2736
2737 urb->status = -EINPROGRESS;
2738
2739 dbg_intr("Add intr urb 0x%lx, to list, epid %d", (unsigned long)urb, epid);
2740
2741 urb_list_add(urb, epid);
2742 etrax_usb_add_to_intr_sb_list(urb, epid);
2743
2744 return 0;
2745
2746 DBFEXIT;
2747 }
2748
2749 static void etrax_usb_add_to_intr_sb_list(struct urb *urb, int epid)
2750 {
2751
2752 volatile USB_EP_Desc_t *tmp_ep;
2753 volatile USB_EP_Desc_t *first_ep;
2754
2755 char maxlen;
2756 int interval;
2757 int i;
2758
2759 etrax_urb_priv_t *urb_priv;
2760
2761 DBFENTER;
2762
2763 maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
2764 interval = urb->interval;
2765
2766 urb_priv = kzalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
2767 assert(urb_priv != NULL);
2768 urb->hcpriv = urb_priv;
2769
2770 first_ep = &TxIntrEPList[0];
2771
2772 /* Round of the interval to 2^n, it is obvious that this code favours
2773 smaller numbers, but that is actually a good thing */
2774 /* FIXME: The "rounding error" for larger intervals will be quite
2775 large. For in traffic this shouldn't be a problem since it will only
2776 mean that we "poll" more often. */
2777 for (i = 0; interval; i++) {
2778 interval = interval >> 1;
2779 }
2780 interval = 1 << (i - 1);
2781
2782 dbg_intr("Interval rounded to %d", interval);
2783
2784 tmp_ep = first_ep;
2785 i = 0;
2786 do {
2787 if (tmp_ep->command & IO_MASK(USB_EP_command, eof)) {
2788 if ((i % interval) == 0) {
2789 /* Insert the traffic ep after tmp_ep */
2790 USB_EP_Desc_t *ep_desc;
2791 USB_SB_Desc_t *sb_desc;
2792
2793 dbg_intr("Inserting EP for epid %d", epid);
2794
2795 ep_desc = (USB_EP_Desc_t *)
2796 kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
2797 sb_desc = (USB_SB_Desc_t *)
2798 kmem_cache_alloc(usb_desc_cache, SLAB_FLAG);
2799 assert(ep_desc != NULL);
2800 CHECK_ALIGN(ep_desc);
2801 assert(sb_desc != NULL);
2802
2803 ep_desc->sub = virt_to_phys(sb_desc);
2804 ep_desc->hw_len = 0;
2805 ep_desc->command = (IO_FIELD(USB_EP_command, epid, epid) |
2806 IO_STATE(USB_EP_command, enable, yes));
2807
2808
2809 /* Round upwards the number of packets of size maxlen
2810 that this SB descriptor should receive. */
2811 sb_desc->sw_len = urb->transfer_buffer_length ?
2812 (urb->transfer_buffer_length - 1) / maxlen + 1 : 0;
2813 sb_desc->next = 0;
2814 sb_desc->buf = 0;
2815 sb_desc->command =
2816 (IO_FIELD(USB_SB_command, rem, urb->transfer_buffer_length % maxlen) |
2817 IO_STATE(USB_SB_command, tt, in) |
2818 IO_STATE(USB_SB_command, eot, yes) |
2819 IO_STATE(USB_SB_command, eol, yes));
2820
2821 ep_desc->next = tmp_ep->next;
2822 tmp_ep->next = virt_to_phys(ep_desc);
2823 }
2824 i++;
2825 }
2826 tmp_ep = (USB_EP_Desc_t *)phys_to_virt(tmp_ep->next);
2827 } while (tmp_ep != first_ep);
2828
2829
2830 /* Note that first_sb/last_sb doesn't apply to interrupt traffic. */
2831 urb_priv->epid = epid;
2832
2833 /* We start the DMA sub channel without checking if it's running or not, because:
2834 1) If it's already running, issuing the start command is a nop.
2835 2) We avoid a test-and-set race condition. */
2836 *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start);
2837
2838 DBFEXIT;
2839 }
2840
2841
2842
2843 static void etrax_usb_complete_intr_urb(struct urb *urb, int status)
2844 {
2845 etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
2846 int epid = urb_priv->epid;
2847
2848 DBFENTER;
2849
2850 if (status)
2851 warn("Completing intr urb with status %d.", status);
2852
2853 dbg_intr("Completing intr epid %d, urb 0x%lx", epid, (unsigned long)urb);
2854
2855 urb->status = status;
2856 urb->actual_length = urb_priv->rx_offset;
2857
2858 dbg_intr("interrupt urb->actual_length = %d", urb->actual_length);
2859
2860 /* We let any non-zero status from the layer above have precedence. */
2861 if (status == 0) {
2862 /* URB_SHORT_NOT_OK means that short reads (shorter than the endpoint's max length)
2863 is to be treated as an error. */
2864 if (urb->transfer_flags & URB_SHORT_NOT_OK) {
2865 if (urb->actual_length !=
2866 usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe))) {
2867 urb->status = -EREMOTEIO;
2868 }
2869 }
2870 }
2871
2872 /* The driver will resubmit the URB so we need to remove it first */
2873 etrax_usb_unlink_urb(urb, 0);
2874 if (urb->complete) {
2875 urb->complete(urb, NULL);
2876 }
2877
2878 DBFEXIT;
2879 }
2880
2881
2882 static int etrax_usb_submit_isoc_urb(struct urb *urb)
2883 {
2884 int epid;
2885 unsigned long flags;
2886
2887 DBFENTER;
2888
2889 dbg_isoc("Submitting isoc urb = 0x%lx", (unsigned long)urb);
2890
2891 /* Epid allocation, empty check and list add must be protected.
2892 Read about this in etrax_usb_submit_ctrl_urb. */
2893
2894 spin_lock_irqsave(&urb_list_lock, flags);
2895 /* Is there an active epid for this urb ? */
2896 epid = etrax_usb_setup_epid(urb);
2897 if (epid == -1) {
2898 DBFEXIT;
2899 spin_unlock_irqrestore(&urb_list_lock, flags);
2900 return -ENOMEM;
2901 }
2902
2903 /* Ok, now we got valid endpoint, lets insert some traffic */
2904
2905 urb->status = -EINPROGRESS;
2906
2907 /* Find the last urb in the URB_List and add this urb after that one.
2908 Also add the traffic, that is do an etrax_usb_add_to_isoc_sb_list. This
2909 is important to make this in "real time" since isochronous traffic is
2910 time sensitive. */
2911
2912 dbg_isoc("Adding isoc urb to (possibly empty) list");
2913 urb_list_add(urb, epid);
2914 etrax_usb_add_to_isoc_sb_list(urb, epid);
2915 spin_unlock_irqrestore(&urb_list_lock, flags);
2916
2917 DBFEXIT;
2918
2919 return 0;
2920 }
2921
2922 static void etrax_usb_check_error_isoc_ep(const int epid)
2923 {
2924 unsigned long int flags;
2925 int error_code;
2926 __u32 r_usb_ept_data;
2927
2928 /* We can't read R_USB_EPID_ATTN here since it would clear the iso_eof,
2929 bulk_eot and epid_attn interrupts. So we just check the status of
2930 the epid without testing if for it in R_USB_EPID_ATTN. */
2931
2932
2933 save_flags(flags);
2934 cli();
2935 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
2936 nop();
2937 /* Note that although there are separate R_USB_EPT_DATA and R_USB_EPT_DATA_ISO
2938 registers, they are located at the same address and are of the same size.
2939 In other words, this read should be ok for isoc also. */
2940 r_usb_ept_data = *R_USB_EPT_DATA;
2941 restore_flags(flags);
2942
2943 error_code = IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code, r_usb_ept_data);
2944
2945 if (r_usb_ept_data & IO_MASK(R_USB_EPT_DATA, hold)) {
2946 warn("Hold was set for epid %d.", epid);
2947 return;
2948 }
2949
2950 if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA_ISO, error_code, no_error)) {
2951
2952 /* This indicates that the SB list of the ept was completed before
2953 new data was appended to it. This is not an error, but indicates
2954 large system or USB load and could possibly cause trouble for
2955 very timing sensitive USB device drivers so we log it.
2956 */
2957 info("Isoc. epid %d disabled with no error", epid);
2958 return;
2959
2960 } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA_ISO, error_code, stall)) {
2961 /* Not really a protocol error, just says that the endpoint gave
2962 a stall response. Note that error_code cannot be stall for isoc. */
2963 panic("Isoc traffic cannot stall");
2964
2965 } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA_ISO, error_code, bus_error)) {
2966 /* Two devices responded to a transaction request. Must be resolved
2967 by software. FIXME: Reset ports? */
2968 panic("Bus error for epid %d."
2969 " Two devices responded to transaction request",
2970 epid);
2971
2972 } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, buffer_error)) {
2973 /* DMA overrun or underrun. */
2974 warn("Buffer overrun/underrun for epid %d. DMA too busy?", epid);
2975
2976 /* It seems that error_code = buffer_error in
2977 R_USB_EPT_DATA/R_USB_EPT_DATA_ISO and ourun = yes in R_USB_STATUS
2978 are the same error. */
2979 }
2980 }
2981
2982
2983 static void etrax_usb_add_to_isoc_sb_list(struct urb *urb, int epid)
2984 {
2985
2986 int i = 0;
2987
2988 etrax_urb_priv_t *urb_priv;
2989 USB_SB_Desc_t *prev_sb_desc, *next_sb_desc, *temp_sb_desc;
2990
2991 DBFENTER;
2992
2993 prev_sb_desc = next_sb_desc = temp_sb_desc = NULL;
2994
2995 urb_priv = kzalloc(sizeof(etrax_urb_priv_t), GFP_ATOMIC);
2996 assert(urb_priv != NULL);
2997
2998 urb->hcpriv = urb_priv;
2999 urb_priv->epid = epid;
3000
3001 if (usb_pipeout(urb->pipe)) {
3002
3003 if (urb->number_of_packets == 0) panic("etrax_usb_add_to_isoc_sb_list 0 packets\n");
3004
3005 dbg_isoc("Transfer for epid %d is OUT", epid);
3006 dbg_isoc("%d packets in URB", urb->number_of_packets);
3007
3008 /* Create one SB descriptor for each packet and link them together. */
3009 for (i = 0; i < urb->number_of_packets; i++) {
3010 if (!urb->iso_frame_desc[i].length)
3011 continue;
3012
3013 next_sb_desc = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_ATOMIC);
3014 assert(next_sb_desc != NULL);
3015
3016 if (urb->iso_frame_desc[i].length > 0) {
3017
3018 next_sb_desc->command = (IO_STATE(USB_SB_command, tt, out) |
3019 IO_STATE(USB_SB_command, eot, yes));
3020
3021 next_sb_desc->sw_len = urb->iso_frame_desc[i].length;
3022 next_sb_desc->buf = virt_to_phys((char*)urb->transfer_buffer + urb->iso_frame_desc[i].offset);
3023
3024 /* Check if full length transfer. */
3025 if (urb->iso_frame_desc[i].length ==
3026 usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe))) {
3027 next_sb_desc->command |= IO_STATE(USB_SB_command, full, yes);
3028 }
3029 } else {
3030 dbg_isoc("zero len packet");
3031 next_sb_desc->command = (IO_FIELD(USB_SB_command, rem, 0) |
3032 IO_STATE(USB_SB_command, tt, zout) |
3033 IO_STATE(USB_SB_command, eot, yes) |
3034 IO_STATE(USB_SB_command, full, yes));
3035
3036 next_sb_desc->sw_len = 1;
3037 next_sb_desc->buf = virt_to_phys(&zout_buffer[0]);
3038 }
3039
3040 /* First SB descriptor that belongs to this urb */
3041 if (i == 0)
3042 urb_priv->first_sb = next_sb_desc;
3043 else
3044 prev_sb_desc->next = virt_to_phys(next_sb_desc);
3045
3046 prev_sb_desc = next_sb_desc;
3047 }
3048
3049 next_sb_desc->command |= (IO_STATE(USB_SB_command, intr, yes) |
3050 IO_STATE(USB_SB_command, eol, yes));
3051 next_sb_desc->next = 0;
3052 urb_priv->last_sb = next_sb_desc;
3053
3054 } else if (usb_pipein(urb->pipe)) {
3055
3056 dbg_isoc("Transfer for epid %d is IN", epid);
3057 dbg_isoc("transfer_buffer_length = %d", urb->transfer_buffer_length);
3058 dbg_isoc("rem is calculated to %d", urb->iso_frame_desc[urb->number_of_packets - 1].length);
3059
3060 /* Note that in descriptors for periodic traffic are not consumed. This means that
3061 the USB controller never propagates in the SB list. In other words, if there already
3062 is an SB descriptor in the list for this EP we don't have to do anything. */
3063 if (TxIsocEPList[epid].sub == 0) {
3064 dbg_isoc("Isoc traffic not already running, allocating SB");
3065
3066 next_sb_desc = (USB_SB_Desc_t*)kmem_cache_alloc(usb_desc_cache, SLAB_ATOMIC);
3067 assert(next_sb_desc != NULL);
3068
3069 next_sb_desc->command = (IO_STATE(USB_SB_command, tt, in) |
3070 IO_STATE(USB_SB_command, eot, yes) |
3071 IO_STATE(USB_SB_command, eol, yes));
3072
3073 next_sb_desc->next = 0;
3074 next_sb_desc->sw_len = 1; /* Actual number of packets is not relevant
3075 for periodic in traffic as long as it is more
3076 than zero. Set to 1 always. */
3077 next_sb_desc->buf = 0;
3078
3079 /* The rem field is don't care for isoc traffic, so we don't set it. */
3080
3081 /* Only one SB descriptor that belongs to this urb. */
3082 urb_priv->first_sb = next_sb_desc;
3083 urb_priv->last_sb = next_sb_desc;
3084
3085 } else {
3086
3087 dbg_isoc("Isoc traffic already running, just setting first/last_sb");
3088
3089 /* Each EP for isoc in will have only one SB descriptor, setup when submitting the
3090 already active urb. Note that even though we may have several first_sb/last_sb
3091 pointing at the same SB descriptor, they are freed only once (when the list has
3092 become empty). */
3093 urb_priv->first_sb = phys_to_virt(TxIsocEPList[epid].sub);
3094 urb_priv->last_sb = phys_to_virt(TxIsocEPList[epid].sub);
3095 return;
3096 }
3097
3098 }
3099
3100 /* Find the spot to insert this urb and add it. */
3101 if (TxIsocEPList[epid].sub == 0) {
3102 /* First SB descriptor inserted in this list (in or out). */
3103 dbg_isoc("Inserting SB desc first in list");
3104 TxIsocEPList[epid].hw_len = 0;
3105 TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
3106
3107 } else {
3108 /* Isochronous traffic is already running, insert new traffic last (only out). */
3109 dbg_isoc("Inserting SB desc last in list");
3110 temp_sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
3111 while ((temp_sb_desc->command & IO_MASK(USB_SB_command, eol)) !=
3112 IO_STATE(USB_SB_command, eol, yes)) {
3113 assert(temp_sb_desc->next);
3114 temp_sb_desc = phys_to_virt(temp_sb_desc->next);
3115 }
3116 dbg_isoc("Appending list on desc 0x%p", temp_sb_desc);
3117
3118 /* Next pointer must be set before eol is removed. */
3119 temp_sb_desc->next = virt_to_phys(urb_priv->first_sb);
3120 /* Clear the previous end of list flag since there is a new in the
3121 added SB descriptor list. */
3122 temp_sb_desc->command &= ~IO_MASK(USB_SB_command, eol);
3123
3124 if (!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
3125 /* 8.8.5 in Designer's Reference says we should check for and correct
3126 any errors in the EP here. That should not be necessary if epid_attn
3127 is handled correctly, so we assume all is ok. */
3128 dbg_isoc("EP disabled");
3129 etrax_usb_check_error_isoc_ep(epid);
3130
3131 /* The SB list was exhausted. */
3132 if (virt_to_phys(urb_priv->last_sb) != TxIsocEPList[epid].sub) {
3133 /* The new sublist did not get processed before the EP was
3134 disabled. Setup the EP again. */
3135 dbg_isoc("Set EP sub to new list");
3136 TxIsocEPList[epid].hw_len = 0;
3137 TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
3138 }
3139 }
3140 }
3141
3142 if (urb->transfer_flags & URB_ISO_ASAP) {
3143 /* The isoc transfer should be started as soon as possible. The start_frame
3144 field is a return value if URB_ISO_ASAP was set. Comparing R_USB_FM_NUMBER
3145 with a USB Chief trace shows that the first isoc IN token is sent 2 frames
3146 later. I'm not sure how this affects usage of the start_frame field by the
3147 device driver, or how it affects things when USB_ISO_ASAP is not set, so
3148 therefore there's no compensation for the 2 frame "lag" here. */
3149 urb->start_frame = (*R_USB_FM_NUMBER & 0x7ff);
3150 TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
3151 urb_priv->urb_state = STARTED;
3152 dbg_isoc("URB_ISO_ASAP set, urb->start_frame set to %d", urb->start_frame);
3153 } else {
3154 /* Not started yet. */
3155 urb_priv->urb_state = NOT_STARTED;
3156 dbg_isoc("urb_priv->urb_state set to NOT_STARTED");
3157 }
3158
3159 /* We start the DMA sub channel without checking if it's running or not, because:
3160 1) If it's already running, issuing the start command is a nop.
3161 2) We avoid a test-and-set race condition. */
3162 *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
3163
3164 DBFEXIT;
3165 }
3166
3167 static void etrax_usb_complete_isoc_urb(struct urb *urb, int status)
3168 {
3169 etrax_urb_priv_t *urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
3170 int epid = urb_priv->epid;
3171 int auto_resubmit = 0;
3172
3173 DBFENTER;
3174 dbg_isoc("complete urb 0x%p, status %d", urb, status);
3175
3176 if (status)
3177 warn("Completing isoc urb with status %d.", status);
3178
3179 if (usb_pipein(urb->pipe)) {
3180 int i;
3181
3182 /* Make that all isoc packets have status and length set before
3183 completing the urb. */
3184 for (i = urb_priv->isoc_packet_counter; i < urb->number_of_packets; i++) {
3185 urb->iso_frame_desc[i].actual_length = 0;
3186 urb->iso_frame_desc[i].status = -EPROTO;
3187 }
3188
3189 urb_list_del(urb, epid);
3190
3191 if (!list_empty(&urb_list[epid])) {
3192 ((etrax_urb_priv_t *)(urb_list_first(epid)->hcpriv))->urb_state = STARTED;
3193 } else {
3194 unsigned long int flags;
3195 if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
3196 /* The EP was enabled, disable it and wait. */
3197 TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
3198
3199 /* Ah, the luxury of busy-wait. */
3200 while (*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid]));
3201 }
3202
3203 etrax_remove_from_sb_list(urb);
3204 TxIsocEPList[epid].sub = 0;
3205 TxIsocEPList[epid].hw_len = 0;
3206
3207 save_flags(flags);
3208 cli();
3209 etrax_usb_free_epid(epid);
3210 restore_flags(flags);
3211 }
3212
3213 urb->hcpriv = 0;
3214 kfree(urb_priv);
3215
3216 /* Release allocated bandwidth. */
3217 usb_release_bandwidth(urb->dev, urb, 0);
3218 } else if (usb_pipeout(urb->pipe)) {
3219 int freed_descr;
3220
3221 dbg_isoc("Isoc out urb complete 0x%p", urb);
3222
3223 /* Update the urb list. */
3224 urb_list_del(urb, epid);
3225
3226 freed_descr = etrax_remove_from_sb_list(urb);
3227 dbg_isoc("freed %d descriptors of %d packets", freed_descr, urb->number_of_packets);
3228 assert(freed_descr == urb->number_of_packets);
3229 urb->hcpriv = 0;
3230 kfree(urb_priv);
3231
3232 /* Release allocated bandwidth. */
3233 usb_release_bandwidth(urb->dev, urb, 0);
3234 }
3235
3236 urb->status = status;
3237 if (urb->complete) {
3238 urb->complete(urb, NULL);
3239 }
3240
3241 if (auto_resubmit) {
3242 /* Check that urb was not unlinked by the complete callback. */
3243 if (__urb_list_entry(urb, epid)) {
3244 /* Move this one down the list. */
3245 urb_list_move_last(urb, epid);
3246
3247 /* Mark the now first urb as started (may already be). */
3248 ((etrax_urb_priv_t *)(urb_list_first(epid)->hcpriv))->urb_state = STARTED;
3249
3250 /* Must set this to 0 since this urb is still active after
3251 completion. */
3252 urb_priv->isoc_packet_counter = 0;
3253 } else {
3254 warn("(ISOC) automatic resubmit urb 0x%p removed by complete.", urb);
3255 }
3256 }
3257
3258 DBFEXIT;
3259 }
3260
3261 static void etrax_usb_complete_urb(struct urb *urb, int status)
3262 {
3263 switch (usb_pipetype(urb->pipe)) {
3264 case PIPE_BULK:
3265 etrax_usb_complete_bulk_urb(urb, status);
3266 break;
3267 case PIPE_CONTROL:
3268 etrax_usb_complete_ctrl_urb(urb, status);
3269 break;
3270 case PIPE_INTERRUPT:
3271 etrax_usb_complete_intr_urb(urb, status);
3272 break;
3273 case PIPE_ISOCHRONOUS:
3274 etrax_usb_complete_isoc_urb(urb, status);
3275 break;
3276 default:
3277 err("Unknown pipetype");
3278 }
3279 }
3280
3281
3282
3283 static irqreturn_t etrax_usb_hc_interrupt_top_half(int irq, void *vhc)
3284 {
3285 usb_interrupt_registers_t *reg;
3286 unsigned long flags;
3287 __u32 irq_mask;
3288 __u8 status;
3289 __u32 epid_attn;
3290 __u16 port_status_1;
3291 __u16 port_status_2;
3292 __u32 fm_number;
3293
3294 DBFENTER;
3295
3296 /* Read critical registers into local variables, do kmalloc afterwards. */
3297 save_flags(flags);
3298 cli();
3299
3300 irq_mask = *R_USB_IRQ_MASK_READ;
3301 /* Reading R_USB_STATUS clears the ctl_status interrupt. Note that R_USB_STATUS
3302 must be read before R_USB_EPID_ATTN since reading the latter clears the
3303 ourun and perror fields of R_USB_STATUS. */
3304 status = *R_USB_STATUS;
3305
3306 /* Reading R_USB_EPID_ATTN clears the iso_eof, bulk_eot and epid_attn interrupts. */
3307 epid_attn = *R_USB_EPID_ATTN;
3308
3309 /* Reading R_USB_RH_PORT_STATUS_1 and R_USB_RH_PORT_STATUS_2 clears the
3310 port_status interrupt. */
3311 port_status_1 = *R_USB_RH_PORT_STATUS_1;
3312 port_status_2 = *R_USB_RH_PORT_STATUS_2;
3313
3314 /* Reading R_USB_FM_NUMBER clears the sof interrupt. */
3315 /* Note: the lower 11 bits contain the actual frame number, sent with each sof. */
3316 fm_number = *R_USB_FM_NUMBER;
3317
3318 restore_flags(flags);
3319
3320 reg = (usb_interrupt_registers_t *)kmem_cache_alloc(top_half_reg_cache, SLAB_ATOMIC);
3321
3322 assert(reg != NULL);
3323
3324 reg->hc = (etrax_hc_t *)vhc;
3325
3326 /* Now put register values into kmalloc'd area. */
3327 reg->r_usb_irq_mask_read = irq_mask;
3328 reg->r_usb_status = status;
3329 reg->r_usb_epid_attn = epid_attn;
3330 reg->r_usb_rh_port_status_1 = port_status_1;
3331 reg->r_usb_rh_port_status_2 = port_status_2;
3332 reg->r_usb_fm_number = fm_number;
3333
3334 INIT_WORK(&reg->usb_bh, etrax_usb_hc_interrupt_bottom_half, reg);
3335 schedule_work(&reg->usb_bh);
3336
3337 DBFEXIT;
3338
3339 return IRQ_HANDLED;
3340 }
3341
3342 static void etrax_usb_hc_interrupt_bottom_half(void *data)
3343 {
3344 usb_interrupt_registers_t *reg = (usb_interrupt_registers_t *)data;
3345 __u32 irq_mask = reg->r_usb_irq_mask_read;
3346
3347 DBFENTER;
3348
3349 /* Interrupts are handled in order of priority. */
3350 if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, epid_attn)) {
3351 etrax_usb_hc_epid_attn_interrupt(reg);
3352 }
3353 if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, port_status)) {
3354 etrax_usb_hc_port_status_interrupt(reg);
3355 }
3356 if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, ctl_status)) {
3357 etrax_usb_hc_ctl_status_interrupt(reg);
3358 }
3359 if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, iso_eof)) {
3360 etrax_usb_hc_isoc_eof_interrupt();
3361 }
3362 if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, bulk_eot)) {
3363 /* Update/restart the bulk start timer since obviously the channel is running. */
3364 mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
3365 /* Update/restart the bulk eot timer since we just received an bulk eot interrupt. */
3366 mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
3367
3368 etrax_usb_hc_bulk_eot_interrupt(0);
3369 }
3370
3371 kmem_cache_free(top_half_reg_cache, reg);
3372
3373 DBFEXIT;
3374 }
3375
3376
3377 void etrax_usb_hc_isoc_eof_interrupt(void)
3378 {
3379 struct urb *urb;
3380 etrax_urb_priv_t *urb_priv;
3381 int epid;
3382 unsigned long flags;
3383
3384 DBFENTER;
3385
3386 /* Do not check the invalid epid (it has a valid sub pointer). */
3387 for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
3388
3389 /* Do not check the invalid epid (it has a valid sub pointer). */
3390 if ((epid == DUMMY_EPID) || (epid == INVALID_EPID))
3391 continue;
3392
3393 /* Disable interrupts to block the isoc out descriptor interrupt handler
3394 from being called while the isoc EPID list is being checked.
3395 */
3396 save_flags(flags);
3397 cli();
3398
3399 if (TxIsocEPList[epid].sub == 0) {
3400 /* Nothing here to see. */
3401 restore_flags(flags);
3402 continue;
3403 }
3404
3405 /* Get the first urb (if any). */
3406 urb = urb_list_first(epid);
3407 if (urb == 0) {
3408 warn("Ignoring NULL urb");
3409 restore_flags(flags);
3410 continue;
3411 }
3412 if (usb_pipein(urb->pipe)) {
3413
3414 /* Sanity check. */
3415 assert(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
3416
3417 urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
3418 assert(urb_priv);
3419
3420 if (urb_priv->urb_state == NOT_STARTED) {
3421
3422 /* If ASAP is not set and urb->start_frame is the current frame,
3423 start the transfer. */
3424 if (!(urb->transfer_flags & URB_ISO_ASAP) &&
3425 (urb->start_frame == (*R_USB_FM_NUMBER & 0x7ff))) {
3426
3427 dbg_isoc("Enabling isoc IN EP descr for epid %d", epid);
3428 TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
3429
3430 /* This urb is now active. */
3431 urb_priv->urb_state = STARTED;
3432 continue;
3433 }
3434 }
3435 }
3436 restore_flags(flags);
3437 }
3438
3439 DBFEXIT;
3440
3441 }
3442
3443 void etrax_usb_hc_bulk_eot_interrupt(int timer_induced)
3444 {
3445 int epid;
3446
3447 /* The technique is to run one urb at a time, wait for the eot interrupt at which
3448 point the EP descriptor has been disabled. */
3449
3450 DBFENTER;
3451 dbg_bulk("bulk eot%s", timer_induced ? ", called by timer" : "");
3452
3453 for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
3454
3455 if (!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) &&
3456 (TxBulkEPList[epid].sub != 0)) {
3457
3458 struct urb *urb;
3459 etrax_urb_priv_t *urb_priv;
3460 unsigned long flags;
3461 __u32 r_usb_ept_data;
3462
3463 /* Found a disabled EP descriptor which has a non-null sub pointer.
3464 Verify that this ctrl EP descriptor got disabled no errors.
3465 FIXME: Necessary to check error_code? */
3466 dbg_bulk("for epid %d?", epid);
3467
3468 /* Get the first urb. */
3469 urb = urb_list_first(epid);
3470
3471 /* FIXME: Could this happen for valid reasons? Why did it disappear? Because of
3472 wrong unlinking? */
3473 if (!urb) {
3474 warn("NULL urb for epid %d", epid);
3475 continue;
3476 }
3477
3478 assert(urb);
3479 urb_priv = (etrax_urb_priv_t *)urb->hcpriv;
3480 assert(urb_priv);
3481
3482 /* Sanity checks. */
3483 assert(usb_pipetype(urb->pipe) == PIPE_BULK);
3484 if (phys_to_virt(TxBulkEPList[epid].sub) != urb_priv->last_sb) {
3485 err("bulk endpoint got disabled before reaching last sb");
3486 }
3487
3488 /* For bulk IN traffic, there seems to be a race condition between
3489 between the bulk eot and eop interrupts, or rather an uncertainty regarding
3490 the order in which they happen. Normally we expect the eop interrupt from
3491 DMA channel 9 to happen before the eot interrupt.
3492
3493 Therefore, we complete the bulk IN urb in the rx interrupt handler instead. */
3494
3495 if (usb_pipein(urb->pipe)) {
3496 dbg_bulk("in urb, continuing");
3497 continue;
3498 }
3499
3500 save_flags(flags);
3501 cli();
3502 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
3503 nop();
3504 r_usb_ept_data = *R_USB_EPT_DATA;
3505 restore_flags(flags);
3506
3507 if (IO_EXTRACT(R_USB_EPT_DATA, error_code, r_usb_ept_data) ==
3508 IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
3509 /* This means that the endpoint has no error, is disabled
3510 and had inserted traffic, i.e. transfer successfully completed. */
3511 etrax_usb_complete_bulk_urb(urb, 0);
3512 } else {
3513 /* Shouldn't happen. We expect errors to be caught by epid attention. */
3514 err("Found disabled bulk EP desc, error_code != no_error");
3515 }
3516 }
3517 }
3518
3519 /* Normally, we should find (at least) one disabled EP descriptor with a valid sub pointer.
3520 However, because of the uncertainty in the deliverance of the eop/eot interrupts, we may
3521 not. Also, we might find two disabled EPs when handling an eot interrupt, and then find
3522 none the next time. */
3523
3524 DBFEXIT;
3525
3526 }
3527
3528 void etrax_usb_hc_epid_attn_interrupt(usb_interrupt_registers_t *reg)
3529 {
3530 /* This function handles the epid attention interrupt. There are a variety of reasons
3531 for this interrupt to happen (Designer's Reference, p. 8 - 22 for the details):
3532
3533 invalid ep_id - Invalid epid in an EP (EP disabled).
3534 stall - Not strictly an error condition (EP disabled).
3535 3rd error - Three successive transaction errors (EP disabled).
3536 buffer ourun - Buffer overrun or underrun (EP disabled).
3537 past eof1 - Intr or isoc transaction proceeds past EOF1.
3538 near eof - Intr or isoc transaction would not fit inside the frame.
3539 zout transfer - If zout transfer for a bulk endpoint (EP disabled).
3540 setup transfer - If setup transfer for a non-ctrl endpoint (EP disabled). */
3541
3542 int epid;
3543
3544
3545 DBFENTER;
3546
3547 assert(reg != NULL);
3548
3549 /* Note that we loop through all epids. We still want to catch errors for
3550 the invalid one, even though we might handle them differently. */
3551 for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
3552
3553 if (test_bit(epid, (void *)&reg->r_usb_epid_attn)) {
3554
3555 struct urb *urb;
3556 __u32 r_usb_ept_data;
3557 unsigned long flags;
3558 int error_code;
3559
3560 save_flags(flags);
3561 cli();
3562 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
3563 nop();
3564 /* Note that although there are separate R_USB_EPT_DATA and R_USB_EPT_DATA_ISO
3565 registers, they are located at the same address and are of the same size.
3566 In other words, this read should be ok for isoc also. */
3567 r_usb_ept_data = *R_USB_EPT_DATA;
3568 restore_flags(flags);
3569
3570 /* First some sanity checks. */
3571 if (epid == INVALID_EPID) {
3572 /* FIXME: What if it became disabled? Could seriously hurt interrupt
3573 traffic. (Use do_intr_recover.) */
3574 warn("Got epid_attn for INVALID_EPID (%d).", epid);
3575 err("R_USB_EPT_DATA = 0x%x", r_usb_ept_data);
3576 err("R_USB_STATUS = 0x%x", reg->r_usb_status);
3577 continue;
3578 } else if (epid == DUMMY_EPID) {
3579 /* We definitely don't care about these ones. Besides, they are
3580 always disabled, so any possible disabling caused by the
3581 epid attention interrupt is irrelevant. */
3582 warn("Got epid_attn for DUMMY_EPID (%d).", epid);
3583 continue;
3584 }
3585
3586 /* Get the first urb in the urb list for this epid. We blatantly assume
3587 that only the first urb could have caused the epid attention.
3588 (For bulk and ctrl, only one urb is active at any one time. For intr
3589 and isoc we remove them once they are completed.) */
3590 urb = urb_list_first(epid);
3591
3592 if (urb == NULL) {
3593 err("Got epid_attn for epid %i with no urb.", epid);
3594 err("R_USB_EPT_DATA = 0x%x", r_usb_ept_data);
3595 err("R_USB_STATUS = 0x%x", reg->r_usb_status);
3596 continue;
3597 }
3598
3599 switch (usb_pipetype(urb->pipe)) {
3600 case PIPE_BULK:
3601 warn("Got epid attn for bulk endpoint, epid %d", epid);
3602 break;
3603 case PIPE_CONTROL:
3604 warn("Got epid attn for control endpoint, epid %d", epid);
3605 break;
3606 case PIPE_INTERRUPT:
3607 warn("Got epid attn for interrupt endpoint, epid %d", epid);
3608 break;
3609 case PIPE_ISOCHRONOUS:
3610 warn("Got epid attn for isochronous endpoint, epid %d", epid);
3611 break;
3612 }
3613
3614 if (usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS) {
3615 if (r_usb_ept_data & IO_MASK(R_USB_EPT_DATA, hold)) {
3616 warn("Hold was set for epid %d.", epid);
3617 continue;
3618 }
3619 }
3620
3621 /* Even though error_code occupies bits 22 - 23 in both R_USB_EPT_DATA and
3622 R_USB_EPT_DATA_ISOC, we separate them here so we don't forget in other places. */
3623 if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
3624 error_code = IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code, r_usb_ept_data);
3625 } else {
3626 error_code = IO_EXTRACT(R_USB_EPT_DATA, error_code, r_usb_ept_data);
3627 }
3628
3629 /* Using IO_STATE_VALUE on R_USB_EPT_DATA should be ok for isoc also. */
3630 if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
3631
3632 /* Isoc traffic doesn't have error_count_in/error_count_out. */
3633 if ((usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS) &&
3634 (IO_EXTRACT(R_USB_EPT_DATA, error_count_in, r_usb_ept_data) == 3 ||
3635 IO_EXTRACT(R_USB_EPT_DATA, error_count_out, r_usb_ept_data) == 3)) {
3636 /* 3rd error. */
3637 warn("3rd error for epid %i", epid);
3638 etrax_usb_complete_urb(urb, -EPROTO);
3639
3640 } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
3641
3642 warn("Perror for epid %d", epid);
3643
3644 if (!(r_usb_ept_data & IO_MASK(R_USB_EPT_DATA, valid))) {
3645 /* invalid ep_id */
3646 panic("Perror because of invalid epid."
3647 " Deconfigured too early?");
3648 } else {
3649 /* past eof1, near eof, zout transfer, setup transfer */
3650
3651 /* Dump the urb and the relevant EP descriptor list. */
3652
3653 __dump_urb(urb);
3654 __dump_ept_data(epid);
3655 __dump_ep_list(usb_pipetype(urb->pipe));
3656
3657 panic("Something wrong with DMA descriptor contents."
3658 " Too much traffic inserted?");
3659 }
3660 } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
3661 /* buffer ourun */
3662 panic("Buffer overrun/underrun for epid %d. DMA too busy?", epid);
3663 }
3664
3665 } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, stall)) {
3666 /* Not really a protocol error, just says that the endpoint gave
3667 a stall response. Note that error_code cannot be stall for isoc. */
3668 if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
3669 panic("Isoc traffic cannot stall");
3670 }
3671
3672 warn("Stall for epid %d", epid);
3673 etrax_usb_complete_urb(urb, -EPIPE);
3674
3675 } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, bus_error)) {
3676 /* Two devices responded to a transaction request. Must be resolved
3677 by software. FIXME: Reset ports? */
3678 panic("Bus error for epid %d."
3679 " Two devices responded to transaction request",
3680 epid);
3681
3682 } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, buffer_error)) {
3683 /* DMA overrun or underrun. */
3684 warn("Buffer overrun/underrun for epid %d. DMA too busy?", epid);
3685
3686 /* It seems that error_code = buffer_error in
3687 R_USB_EPT_DATA/R_USB_EPT_DATA_ISO and ourun = yes in R_USB_STATUS
3688 are the same error. */
3689 etrax_usb_complete_urb(urb, -EPROTO);
3690 }
3691 }
3692 }
3693
3694 DBFEXIT;
3695
3696 }
3697
3698 void etrax_usb_bulk_start_timer_func(unsigned long dummy)
3699 {
3700
3701 /* We might enable an EP descriptor behind the current DMA position when it's about
3702 to decide that there are no more bulk traffic and it should stop the bulk channel.
3703 Therefore we periodically check if the bulk channel is stopped and there is an
3704 enabled bulk EP descriptor, in which case we start the bulk channel. */
3705 dbg_bulk("bulk_start_timer timed out.");
3706
3707 if (!(*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd))) {
3708 int epid;
3709
3710 dbg_bulk("Bulk DMA channel not running.");
3711
3712 for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
3713 if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
3714 dbg_bulk("Found enabled EP for epid %d, starting bulk channel.\n",
3715 epid);
3716 *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start);
3717
3718 /* Restart the bulk eot timer since we just started the bulk channel. */
3719 mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
3720
3721 /* No need to search any further. */
3722 break;
3723 }
3724 }
3725 } else {
3726 dbg_bulk("Bulk DMA channel running.");
3727 }
3728 }
3729
3730 void etrax_usb_hc_port_status_interrupt(usb_interrupt_registers_t *reg)
3731 {
3732 etrax_hc_t *hc = reg->hc;
3733 __u16 r_usb_rh_port_status_1 = reg->r_usb_rh_port_status_1;
3734 __u16 r_usb_rh_port_status_2 = reg->r_usb_rh_port_status_2;
3735
3736 DBFENTER;
3737
3738 /* The Etrax RH does not include a wPortChange register, so this has to be handled in software
3739 (by saving the old port status value for comparison when the port status interrupt happens).
3740 See section 11.16.2.6.2 in the USB 1.1 spec for details. */
3741
3742 dbg_rh("hc->rh.prev_wPortStatus_1 = 0x%x", hc->rh.prev_wPortStatus_1);
3743 dbg_rh("hc->rh.prev_wPortStatus_2 = 0x%x", hc->rh.prev_wPortStatus_2);
3744 dbg_rh("r_usb_rh_port_status_1 = 0x%x", r_usb_rh_port_status_1);
3745 dbg_rh("r_usb_rh_port_status_2 = 0x%x", r_usb_rh_port_status_2);
3746
3747 /* C_PORT_CONNECTION is set on any transition. */
3748 hc->rh.wPortChange_1 |=
3749 ((r_usb_rh_port_status_1 & (1 << RH_PORT_CONNECTION)) !=
3750 (hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_CONNECTION))) ?
3751 (1 << RH_PORT_CONNECTION) : 0;
3752
3753 hc->rh.wPortChange_2 |=
3754 ((r_usb_rh_port_status_2 & (1 << RH_PORT_CONNECTION)) !=
3755 (hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_CONNECTION))) ?
3756 (1 << RH_PORT_CONNECTION) : 0;
3757
3758 /* C_PORT_ENABLE is _only_ set on a one to zero transition, i.e. when
3759 the port is disabled, not when it's enabled. */
3760 hc->rh.wPortChange_1 |=
3761 ((hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_ENABLE))
3762 && !(r_usb_rh_port_status_1 & (1 << RH_PORT_ENABLE))) ?
3763 (1 << RH_PORT_ENABLE) : 0;
3764
3765 hc->rh.wPortChange_2 |=
3766 ((hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_ENABLE))
3767 && !(r_usb_rh_port_status_2 & (1 << RH_PORT_ENABLE))) ?
3768 (1 << RH_PORT_ENABLE) : 0;
3769
3770 /* C_PORT_SUSPEND is set to one when the device has transitioned out
3771 of the suspended state, i.e. when suspend goes from one to zero. */
3772 hc->rh.wPortChange_1 |=
3773 ((hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_SUSPEND))
3774 && !(r_usb_rh_port_status_1 & (1 << RH_PORT_SUSPEND))) ?
3775 (1 << RH_PORT_SUSPEND) : 0;
3776
3777 hc->rh.wPortChange_2 |=
3778 ((hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_SUSPEND))
3779 && !(r_usb_rh_port_status_2 & (1 << RH_PORT_SUSPEND))) ?
3780 (1 << RH_PORT_SUSPEND) : 0;
3781
3782
3783 /* C_PORT_RESET is set when reset processing on this port is complete. */
3784 hc->rh.wPortChange_1 |=
3785 ((hc->rh.prev_wPortStatus_1 & (1 << RH_PORT_RESET))
3786 && !(r_usb_rh_port_status_1 & (1 << RH_PORT_RESET))) ?
3787 (1 << RH_PORT_RESET) : 0;
3788
3789 hc->rh.wPortChange_2 |=
3790 ((hc->rh.prev_wPortStatus_2 & (1 << RH_PORT_RESET))
3791 && !(r_usb_rh_port_status_2 & (1 << RH_PORT_RESET))) ?
3792 (1 << RH_PORT_RESET) : 0;
3793
3794 /* Save the new values for next port status change. */
3795 hc->rh.prev_wPortStatus_1 = r_usb_rh_port_status_1;
3796 hc->rh.prev_wPortStatus_2 = r_usb_rh_port_status_2;
3797
3798 dbg_rh("hc->rh.wPortChange_1 set to 0x%x", hc->rh.wPortChange_1);
3799 dbg_rh("hc->rh.wPortChange_2 set to 0x%x", hc->rh.wPortChange_2);
3800
3801 DBFEXIT;
3802
3803 }
3804
3805 void etrax_usb_hc_ctl_status_interrupt(usb_interrupt_registers_t *reg)
3806 {
3807 DBFENTER;
3808
3809 /* FIXME: What should we do if we get ourun or perror? Dump the EP and SB
3810 list for the corresponding epid? */
3811 if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
3812 panic("USB controller got ourun.");
3813 }
3814 if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
3815
3816 /* Before, etrax_usb_do_intr_recover was called on this epid if it was
3817 an interrupt pipe. I don't see how re-enabling all EP descriptors
3818 will help if there was a programming error. */
3819 panic("USB controller got perror.");
3820 }
3821
3822 if (reg->r_usb_status & IO_MASK(R_USB_STATUS, device_mode)) {
3823 /* We should never operate in device mode. */
3824 panic("USB controller in device mode.");
3825 }
3826
3827 /* These if-statements could probably be nested. */
3828 if (reg->r_usb_status & IO_MASK(R_USB_STATUS, host_mode)) {
3829 info("USB controller in host mode.");
3830 }
3831 if (reg->r_usb_status & IO_MASK(R_USB_STATUS, started)) {
3832 info("USB controller started.");
3833 }
3834 if (reg->r_usb_status & IO_MASK(R_USB_STATUS, running)) {
3835 info("USB controller running.");
3836 }
3837
3838 DBFEXIT;
3839
3840 }
3841
3842
3843 static int etrax_rh_submit_urb(struct urb *urb)
3844 {
3845 struct usb_device *usb_dev = urb->dev;
3846 etrax_hc_t *hc = usb_dev->bus->hcpriv;
3847 unsigned int pipe = urb->pipe;
3848 struct usb_ctrlrequest *cmd = (struct usb_ctrlrequest *) urb->setup_packet;
3849 void *data = urb->transfer_buffer;
3850 int leni = urb->transfer_buffer_length;
3851 int len = 0;
3852 int stat = 0;
3853
3854 __u16 bmRType_bReq;
3855 __u16 wValue;
3856 __u16 wIndex;
3857 __u16 wLength;
3858
3859 DBFENTER;
3860
3861 /* FIXME: What is this interrupt urb that is sent to the root hub? */
3862 if (usb_pipetype (pipe) == PIPE_INTERRUPT) {
3863 dbg_rh("Root-Hub submit IRQ: every %d ms", urb->interval);
3864 hc->rh.urb = urb;
3865 hc->rh.send = 1;
3866 /* FIXME: We could probably remove this line since it's done
3867 in etrax_rh_init_int_timer. (Don't remove it from
3868 etrax_rh_init_int_timer though.) */
3869 hc->rh.interval = urb->interval;
3870 etrax_rh_init_int_timer(urb);
3871 DBFEXIT;
3872
3873 return 0;
3874 }
3875
3876 bmRType_bReq = cmd->bRequestType | (cmd->bRequest << 8);
3877 wValue = le16_to_cpu(cmd->wValue);
3878 wIndex = le16_to_cpu(cmd->wIndex);
3879 wLength = le16_to_cpu(cmd->wLength);
3880
3881 dbg_rh("bmRType_bReq : 0x%04x (%d)", bmRType_bReq, bmRType_bReq);
3882 dbg_rh("wValue : 0x%04x (%d)", wValue, wValue);
3883 dbg_rh("wIndex : 0x%04x (%d)", wIndex, wIndex);
3884 dbg_rh("wLength : 0x%04x (%d)", wLength, wLength);
3885
3886 switch (bmRType_bReq) {
3887
3888 /* Request Destination:
3889 without flags: Device,
3890 RH_INTERFACE: interface,
3891 RH_ENDPOINT: endpoint,
3892 RH_CLASS means HUB here,
3893 RH_OTHER | RH_CLASS almost ever means HUB_PORT here
3894 */
3895
3896 case RH_GET_STATUS:
3897 *(__u16 *) data = cpu_to_le16 (1);
3898 OK (2);
3899
3900 case RH_GET_STATUS | RH_INTERFACE:
3901 *(__u16 *) data = cpu_to_le16 (0);
3902 OK (2);
3903
3904 case RH_GET_STATUS | RH_ENDPOINT:
3905 *(__u16 *) data = cpu_to_le16 (0);
3906 OK (2);
3907
3908 case RH_GET_STATUS | RH_CLASS:
3909 *(__u32 *) data = cpu_to_le32 (0);
3910 OK (4); /* hub power ** */
3911
3912 case RH_GET_STATUS | RH_OTHER | RH_CLASS:
3913 if (wIndex == 1) {
3914 *((__u16*)data) = cpu_to_le16(hc->rh.prev_wPortStatus_1);
3915 *((__u16*)data + 1) = cpu_to_le16(hc->rh.wPortChange_1);
3916 } else if (wIndex == 2) {
3917 *((__u16*)data) = cpu_to_le16(hc->rh.prev_wPortStatus_2);
3918 *((__u16*)data + 1) = cpu_to_le16(hc->rh.wPortChange_2);
3919 } else {
3920 dbg_rh("RH_GET_STATUS whith invalid wIndex!");
3921 OK(0);
3922 }
3923
3924 OK(4);
3925
3926 case RH_CLEAR_FEATURE | RH_ENDPOINT:
3927 switch (wValue) {
3928 case (RH_ENDPOINT_STALL):
3929 OK (0);
3930 }
3931 break;
3932
3933 case RH_CLEAR_FEATURE | RH_CLASS:
3934 switch (wValue) {
3935 case (RH_C_HUB_OVER_CURRENT):
3936 OK (0); /* hub power over current ** */
3937 }
3938 break;
3939
3940 case RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS:
3941 switch (wValue) {
3942 case (RH_PORT_ENABLE):
3943 if (wIndex == 1) {
3944
3945 dbg_rh("trying to do disable port 1");
3946
3947 *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
3948
3949 while (hc->rh.prev_wPortStatus_1 &
3950 IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes));
3951 *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
3952 dbg_rh("Port 1 is disabled");
3953
3954 } else if (wIndex == 2) {
3955
3956 dbg_rh("trying to do disable port 2");
3957
3958 *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, yes);
3959
3960 while (hc->rh.prev_wPortStatus_2 &
3961 IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, yes));
3962 *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no);
3963 dbg_rh("Port 2 is disabled");
3964
3965 } else {
3966 dbg_rh("RH_CLEAR_FEATURE->RH_PORT_ENABLE "
3967 "with invalid wIndex == %d!", wIndex);
3968 }
3969
3970 OK (0);
3971 case (RH_PORT_SUSPEND):
3972 /* Opposite to suspend should be resume, so we'll do a resume. */
3973 /* FIXME: USB 1.1, 11.16.2.2 says:
3974 "Clearing the PORT_SUSPEND feature causes a host-initiated resume
3975 on the specified port. If the port is not in the Suspended state,
3976 the hub should treat this request as a functional no-operation."
3977 Shouldn't we check if the port is in a suspended state before
3978 resuming? */
3979
3980 /* Make sure the controller isn't busy. */
3981 while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
3982
3983 if (wIndex == 1) {
3984 *R_USB_COMMAND =
3985 IO_STATE(R_USB_COMMAND, port_sel, port1) |
3986 IO_STATE(R_USB_COMMAND, port_cmd, resume) |
3987 IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
3988 } else if (wIndex == 2) {
3989 *R_USB_COMMAND =
3990 IO_STATE(R_USB_COMMAND, port_sel, port2) |
3991 IO_STATE(R_USB_COMMAND, port_cmd, resume) |
3992 IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
3993 } else {
3994 dbg_rh("RH_CLEAR_FEATURE->RH_PORT_SUSPEND "
3995 "with invalid wIndex == %d!", wIndex);
3996 }
3997
3998 OK (0);
3999 case (RH_PORT_POWER):
4000 OK (0); /* port power ** */
4001 case (RH_C_PORT_CONNECTION):
4002 if (wIndex == 1) {
4003 hc->rh.wPortChange_1 &= ~(1 << RH_PORT_CONNECTION);
4004 } else if (wIndex == 2) {
4005 hc->rh.wPortChange_2 &= ~(1 << RH_PORT_CONNECTION);
4006 } else {
4007 dbg_rh("RH_CLEAR_FEATURE->RH_C_PORT_CONNECTION "
4008 "with invalid wIndex == %d!", wIndex);
4009 }
4010
4011 OK (0);
4012 case (RH_C_PORT_ENABLE):
4013 if (wIndex == 1) {
4014 hc->rh.wPortChange_1 &= ~(1 << RH_PORT_ENABLE);
4015 } else if (wIndex == 2) {
4016 hc->rh.wPortChange_2 &= ~(1 << RH_PORT_ENABLE);
4017 } else {
4018 dbg_rh("RH_CLEAR_FEATURE->RH_C_PORT_ENABLE "
4019 "with invalid wIndex == %d!", wIndex);
4020 }
4021 OK (0);
4022 case (RH_C_PORT_SUSPEND):
4023 /*** WR_RH_PORTSTAT(RH_PS_PSSC); */
4024 OK (0);
4025 case (RH_C_PORT_OVER_CURRENT):
4026 OK (0); /* port power over current ** */
4027 case (RH_C_PORT_RESET):
4028 if (wIndex == 1) {
4029 hc->rh.wPortChange_1 &= ~(1 << RH_PORT_RESET);
4030 } else if (wIndex == 2) {
4031 hc->rh.wPortChange_2 &= ~(1 << RH_PORT_RESET);
4032 } else {
4033 dbg_rh("RH_CLEAR_FEATURE->RH_C_PORT_RESET "
4034 "with invalid index == %d!", wIndex);
4035 }
4036
4037 OK (0);
4038
4039 }
4040 break;
4041
4042 case RH_SET_FEATURE | RH_OTHER | RH_CLASS:
4043 switch (wValue) {
4044 case (RH_PORT_SUSPEND):
4045
4046 /* Make sure the controller isn't busy. */
4047 while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
4048
4049 if (wIndex == 1) {
4050 *R_USB_COMMAND =
4051 IO_STATE(R_USB_COMMAND, port_sel, port1) |
4052 IO_STATE(R_USB_COMMAND, port_cmd, suspend) |
4053 IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
4054 } else if (wIndex == 2) {
4055 *R_USB_COMMAND =
4056 IO_STATE(R_USB_COMMAND, port_sel, port2) |
4057 IO_STATE(R_USB_COMMAND, port_cmd, suspend) |
4058 IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
4059 } else {
4060 dbg_rh("RH_SET_FEATURE->RH_PORT_SUSPEND "
4061 "with invalid wIndex == %d!", wIndex);
4062 }
4063
4064 OK (0);
4065 case (RH_PORT_RESET):
4066 if (wIndex == 1) {
4067
4068 port_1_reset:
4069 dbg_rh("Doing reset of port 1");
4070
4071 /* Make sure the controller isn't busy. */
4072 while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
4073
4074 *R_USB_COMMAND =
4075 IO_STATE(R_USB_COMMAND, port_sel, port1) |
4076 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4077 IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
4078
4079 /* We must wait at least 10 ms for the device to recover.
4080 15 ms should be enough. */
4081 udelay(15000);
4082
4083 /* Wait for reset bit to go low (should be done by now). */
4084 while (hc->rh.prev_wPortStatus_1 &
4085 IO_STATE(R_USB_RH_PORT_STATUS_1, reset, yes));
4086
4087 /* If the port status is
4088 1) connected and enabled then there is a device and everything is fine
4089 2) neither connected nor enabled then there is no device, also fine
4090 3) connected and not enabled then we try again
4091 (Yes, there are other port status combinations besides these.) */
4092
4093 if ((hc->rh.prev_wPortStatus_1 &
4094 IO_STATE(R_USB_RH_PORT_STATUS_1, connected, yes)) &&
4095 (hc->rh.prev_wPortStatus_1 &
4096 IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, no))) {
4097 dbg_rh("Connected device on port 1, but port not enabled?"
4098 " Trying reset again.");
4099 goto port_2_reset;
4100 }
4101
4102 /* Diagnostic printouts. */
4103 if ((hc->rh.prev_wPortStatus_1 &
4104 IO_STATE(R_USB_RH_PORT_STATUS_1, connected, no)) &&
4105 (hc->rh.prev_wPortStatus_1 &
4106 IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, no))) {
4107 dbg_rh("No connected device on port 1");
4108 } else if ((hc->rh.prev_wPortStatus_1 &
4109 IO_STATE(R_USB_RH_PORT_STATUS_1, connected, yes)) &&
4110 (hc->rh.prev_wPortStatus_1 &
4111 IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes))) {
4112 dbg_rh("Connected device on port 1, port 1 enabled");
4113 }
4114
4115 } else if (wIndex == 2) {
4116
4117 port_2_reset:
4118 dbg_rh("Doing reset of port 2");
4119
4120 /* Make sure the controller isn't busy. */
4121 while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
4122
4123 /* Issue the reset command. */
4124 *R_USB_COMMAND =
4125 IO_STATE(R_USB_COMMAND, port_sel, port2) |
4126 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4127 IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
4128
4129 /* We must wait at least 10 ms for the device to recover.
4130 15 ms should be enough. */
4131 udelay(15000);
4132
4133 /* Wait for reset bit to go low (should be done by now). */
4134 while (hc->rh.prev_wPortStatus_2 &
4135 IO_STATE(R_USB_RH_PORT_STATUS_2, reset, yes));
4136
4137 /* If the port status is
4138 1) connected and enabled then there is a device and everything is fine
4139 2) neither connected nor enabled then there is no device, also fine
4140 3) connected and not enabled then we try again
4141 (Yes, there are other port status combinations besides these.) */
4142
4143 if ((hc->rh.prev_wPortStatus_2 &
4144 IO_STATE(R_USB_RH_PORT_STATUS_2, connected, yes)) &&
4145 (hc->rh.prev_wPortStatus_2 &
4146 IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, no))) {
4147 dbg_rh("Connected device on port 2, but port not enabled?"
4148 " Trying reset again.");
4149 goto port_2_reset;
4150 }
4151
4152 /* Diagnostic printouts. */
4153 if ((hc->rh.prev_wPortStatus_2 &
4154 IO_STATE(R_USB_RH_PORT_STATUS_2, connected, no)) &&
4155 (hc->rh.prev_wPortStatus_2 &
4156 IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, no))) {
4157 dbg_rh("No connected device on port 2");
4158 } else if ((hc->rh.prev_wPortStatus_2 &
4159 IO_STATE(R_USB_RH_PORT_STATUS_2, connected, yes)) &&
4160 (hc->rh.prev_wPortStatus_2 &
4161 IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, yes))) {
4162 dbg_rh("Connected device on port 2, port 2 enabled");
4163 }
4164
4165 } else {
4166 dbg_rh("RH_SET_FEATURE->RH_PORT_RESET with invalid wIndex = %d", wIndex);
4167 }
4168
4169 /* Make sure the controller isn't busy. */
4170 while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
4171
4172 /* If all enabled ports were disabled the host controller goes down into
4173 started mode, so we need to bring it back into the running state.
4174 (This is safe even if it's already in the running state.) */
4175 *R_USB_COMMAND =
4176 IO_STATE(R_USB_COMMAND, port_sel, nop) |
4177 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4178 IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
4179
4180 dbg_rh("...Done");
4181 OK(0);
4182
4183 case (RH_PORT_POWER):
4184 OK (0); /* port power ** */
4185 case (RH_PORT_ENABLE):
4186 /* There is no port enable command in the host controller, so if the
4187 port is already enabled, we do nothing. If not, we reset the port
4188 (with an ugly goto). */
4189
4190 if (wIndex == 1) {
4191 if (hc->rh.prev_wPortStatus_1 &
4192 IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, no)) {
4193 goto port_1_reset;
4194 }
4195 } else if (wIndex == 2) {
4196 if (hc->rh.prev_wPortStatus_2 &
4197 IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, no)) {
4198 goto port_2_reset;
4199 }
4200 } else {
4201 dbg_rh("RH_SET_FEATURE->RH_GET_STATUS with invalid wIndex = %d", wIndex);
4202 }
4203 OK (0);
4204 }
4205 break;
4206
4207 case RH_SET_ADDRESS:
4208 hc->rh.devnum = wValue;
4209 dbg_rh("RH address set to: %d", hc->rh.devnum);
4210 OK (0);
4211
4212 case RH_GET_DESCRIPTOR:
4213 switch ((wValue & 0xff00) >> 8) {
4214 case (0x01): /* device descriptor */
4215 len = min_t(unsigned int, leni, min_t(unsigned int, sizeof (root_hub_dev_des), wLength));
4216 memcpy (data, root_hub_dev_des, len);
4217 OK (len);
4218 case (0x02): /* configuration descriptor */
4219 len = min_t(unsigned int, leni, min_t(unsigned int, sizeof (root_hub_config_des), wLength));
4220 memcpy (data, root_hub_config_des, len);
4221 OK (len);
4222 case (0x03): /* string descriptors */
4223 len = usb_root_hub_string (wValue & 0xff,
4224 0xff, "ETRAX 100LX",
4225 data, wLength);
4226 if (len > 0) {
4227 OK(min(leni, len));
4228 } else {
4229 stat = -EPIPE;
4230 }
4231
4232 }
4233 break;
4234
4235 case RH_GET_DESCRIPTOR | RH_CLASS:
4236 root_hub_hub_des[2] = hc->rh.numports;
4237 len = min_t(unsigned int, leni, min_t(unsigned int, sizeof (root_hub_hub_des), wLength));
4238 memcpy (data, root_hub_hub_des, len);
4239 OK (len);
4240
4241 case RH_GET_CONFIGURATION:
4242 *(__u8 *) data = 0x01;
4243 OK (1);
4244
4245 case RH_SET_CONFIGURATION:
4246 OK (0);
4247
4248 default:
4249 stat = -EPIPE;
4250 }
4251
4252 urb->actual_length = len;
4253 urb->status = stat;
4254 urb->dev = NULL;
4255 if (urb->complete) {
4256 urb->complete(urb, NULL);
4257 }
4258 DBFEXIT;
4259
4260 return 0;
4261 }
4262
4263 static void
4264 etrax_usb_bulk_eot_timer_func(unsigned long dummy)
4265 {
4266 /* Because of a race condition in the top half, we might miss a bulk eot.
4267 This timer "simulates" a bulk eot if we don't get one for a while, hopefully
4268 correcting the situation. */
4269 dbg_bulk("bulk_eot_timer timed out.");
4270 etrax_usb_hc_bulk_eot_interrupt(1);
4271 }
4272
4273 static void*
4274 etrax_usb_buffer_alloc(struct usb_bus* bus, size_t size,
4275 unsigned mem_flags, dma_addr_t *dma)
4276 {
4277 return kmalloc(size, mem_flags);
4278 }
4279
4280 static void
4281 etrax_usb_buffer_free(struct usb_bus *bus, size_t size, void *addr, dma_addr_t dma)
4282 {
4283 kfree(addr);
4284 }
4285
4286
4287 static struct device fake_device;
4288
4289 static int __init etrax_usb_hc_init(void)
4290 {
4291 static etrax_hc_t *hc;
4292 struct usb_bus *bus;
4293 struct usb_device *usb_rh;
4294 int i;
4295
4296 DBFENTER;
4297
4298 info("ETRAX 100LX USB-HCD %s (c) 2001-2003 Axis Communications AB\n", usb_hcd_version);
4299
4300 hc = kmalloc(sizeof(etrax_hc_t), GFP_KERNEL);
4301 assert(hc != NULL);
4302
4303 /* We use kmem_cache_* to make sure that all DMA desc. are dword aligned */
4304 /* Note that we specify sizeof(USB_EP_Desc_t) as the size, but also allocate
4305 SB descriptors from this cache. This is ok since sizeof(USB_EP_Desc_t) ==
4306 sizeof(USB_SB_Desc_t). */
4307
4308 usb_desc_cache = kmem_cache_create("usb_desc_cache", sizeof(USB_EP_Desc_t), 0,
4309 SLAB_HWCACHE_ALIGN, 0, 0);
4310 assert(usb_desc_cache != NULL);
4311
4312 top_half_reg_cache = kmem_cache_create("top_half_reg_cache",
4313 sizeof(usb_interrupt_registers_t),
4314 0, SLAB_HWCACHE_ALIGN, 0, 0);
4315 assert(top_half_reg_cache != NULL);
4316
4317 isoc_compl_cache = kmem_cache_create("isoc_compl_cache",
4318 sizeof(usb_isoc_complete_data_t),
4319 0, SLAB_HWCACHE_ALIGN, 0, 0);
4320 assert(isoc_compl_cache != NULL);
4321
4322 etrax_usb_bus = bus = usb_alloc_bus(&etrax_usb_device_operations);
4323 hc->bus = bus;
4324 bus->bus_name="ETRAX 100LX";
4325 bus->hcpriv = hc;
4326
4327 /* Initialize RH to the default address.
4328 And make sure that we have no status change indication */
4329 hc->rh.numports = 2; /* The RH has two ports */
4330 hc->rh.devnum = 1;
4331 hc->rh.wPortChange_1 = 0;
4332 hc->rh.wPortChange_2 = 0;
4333
4334 /* Also initate the previous values to zero */
4335 hc->rh.prev_wPortStatus_1 = 0;
4336 hc->rh.prev_wPortStatus_2 = 0;
4337
4338 /* Initialize the intr-traffic flags */
4339 /* FIXME: This isn't used. (Besides, the error field isn't initialized.) */
4340 hc->intr.sleeping = 0;
4341 hc->intr.wq = NULL;
4342
4343 epid_usage_bitmask = 0;
4344 epid_out_traffic = 0;
4345
4346 /* Mark the invalid epid as being used. */
4347 set_bit(INVALID_EPID, (void *)&epid_usage_bitmask);
4348 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, INVALID_EPID);
4349 nop();
4350 /* The valid bit should still be set ('invalid' is in our world; not the hardware's). */
4351 *R_USB_EPT_DATA = (IO_STATE(R_USB_EPT_DATA, valid, yes) |
4352 IO_FIELD(R_USB_EPT_DATA, max_len, 1));
4353
4354 /* Mark the dummy epid as being used. */
4355 set_bit(DUMMY_EPID, (void *)&epid_usage_bitmask);
4356 *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, DUMMY_EPID);
4357 nop();
4358 *R_USB_EPT_DATA = (IO_STATE(R_USB_EPT_DATA, valid, no) |
4359 IO_FIELD(R_USB_EPT_DATA, max_len, 1));
4360
4361 /* Initialize the urb list by initiating a head for each list. */
4362 for (i = 0; i < NBR_OF_EPIDS; i++) {
4363 INIT_LIST_HEAD(&urb_list[i]);
4364 }
4365 spin_lock_init(&urb_list_lock);
4366
4367 INIT_LIST_HEAD(&urb_unlink_list);
4368
4369
4370 /* Initiate the bulk start timer. */
4371 init_timer(&bulk_start_timer);
4372 bulk_start_timer.expires = jiffies + BULK_START_TIMER_INTERVAL;
4373 bulk_start_timer.function = etrax_usb_bulk_start_timer_func;
4374 add_timer(&bulk_start_timer);
4375
4376
4377 /* Initiate the bulk eot timer. */
4378 init_timer(&bulk_eot_timer);
4379 bulk_eot_timer.expires = jiffies + BULK_EOT_TIMER_INTERVAL;
4380 bulk_eot_timer.function = etrax_usb_bulk_eot_timer_func;
4381 add_timer(&bulk_eot_timer);
4382
4383 /* Set up the data structures for USB traffic. Note that this must be done before
4384 any interrupt that relies on sane DMA list occurrs. */
4385 init_rx_buffers();
4386 init_tx_bulk_ep();
4387 init_tx_ctrl_ep();
4388 init_tx_intr_ep();
4389 init_tx_isoc_ep();
4390
4391 device_initialize(&fake_device);
4392 kobject_set_name(&fake_device.kobj, "etrax_usb");
4393 kobject_add(&fake_device.kobj);
4394 kobject_uevent(&fake_device.kobj, KOBJ_ADD);
4395 hc->bus->controller = &fake_device;
4396 usb_register_bus(hc->bus);
4397
4398 *R_IRQ_MASK2_SET =
4399 /* Note that these interrupts are not used. */
4400 IO_STATE(R_IRQ_MASK2_SET, dma8_sub0_descr, set) |
4401 /* Sub channel 1 (ctrl) descr. interrupts are used. */
4402 IO_STATE(R_IRQ_MASK2_SET, dma8_sub1_descr, set) |
4403 IO_STATE(R_IRQ_MASK2_SET, dma8_sub2_descr, set) |
4404 /* Sub channel 3 (isoc) descr. interrupts are used. */
4405 IO_STATE(R_IRQ_MASK2_SET, dma8_sub3_descr, set);
4406
4407 /* Note that the dma9_descr interrupt is not used. */
4408 *R_IRQ_MASK2_SET =
4409 IO_STATE(R_IRQ_MASK2_SET, dma9_eop, set) |
4410 IO_STATE(R_IRQ_MASK2_SET, dma9_descr, set);
4411
4412 /* FIXME: Enable iso_eof only when isoc traffic is running. */
4413 *R_USB_IRQ_MASK_SET =
4414 IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set) |
4415 IO_STATE(R_USB_IRQ_MASK_SET, bulk_eot, set) |
4416 IO_STATE(R_USB_IRQ_MASK_SET, epid_attn, set) |
4417 IO_STATE(R_USB_IRQ_MASK_SET, port_status, set) |
4418 IO_STATE(R_USB_IRQ_MASK_SET, ctl_status, set);
4419
4420
4421 if (request_irq(ETRAX_USB_HC_IRQ, etrax_usb_hc_interrupt_top_half, 0,
4422 "ETRAX 100LX built-in USB (HC)", hc)) {
4423 err("Could not allocate IRQ %d for USB", ETRAX_USB_HC_IRQ);
4424 etrax_usb_hc_cleanup();
4425 DBFEXIT;
4426 return -1;
4427 }
4428
4429 if (request_irq(ETRAX_USB_RX_IRQ, etrax_usb_rx_interrupt, 0,
4430 "ETRAX 100LX built-in USB (Rx)", hc)) {
4431 err("Could not allocate IRQ %d for USB", ETRAX_USB_RX_IRQ);
4432 etrax_usb_hc_cleanup();
4433 DBFEXIT;
4434 return -1;
4435 }
4436
4437 if (request_irq(ETRAX_USB_TX_IRQ, etrax_usb_tx_interrupt, 0,
4438 "ETRAX 100LX built-in USB (Tx)", hc)) {
4439 err("Could not allocate IRQ %d for USB", ETRAX_USB_TX_IRQ);
4440 etrax_usb_hc_cleanup();
4441 DBFEXIT;
4442 return -1;
4443 }
4444
4445 /* R_USB_COMMAND:
4446 USB commands in host mode. The fields in this register should all be
4447 written to in one write. Do not read-modify-write one field at a time. A
4448 write to this register will trigger events in the USB controller and an
4449 incomplete command may lead to unpredictable results, and in worst case
4450 even to a deadlock in the controller.
4451 (Note however that the busy field is read-only, so no need to write to it.) */
4452
4453 /* Check the busy bit before writing to R_USB_COMMAND. */
4454
4455 while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
4456
4457 /* Reset the USB interface. */
4458 *R_USB_COMMAND =
4459 IO_STATE(R_USB_COMMAND, port_sel, nop) |
4460 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4461 IO_STATE(R_USB_COMMAND, ctrl_cmd, reset);
4462
4463 /* Designer's Reference, p. 8 - 10 says we should Initate R_USB_FM_PSTART to 0x2A30 (10800),
4464 to guarantee that control traffic gets 10% of the bandwidth, and periodic transfer may
4465 allocate the rest (90%). This doesn't work though. Read on for a lenghty explanation.
4466
4467 While there is a difference between rev. 2 and rev. 3 of the ETRAX 100LX regarding the NAK
4468 behaviour, it doesn't solve this problem. What happens is that a control transfer will not
4469 be interrupted in its data stage when PSTART happens (the point at which periodic traffic
4470 is started). Thus, if PSTART is set to 10800 and its IN or OUT token is NAKed until just before
4471 PSTART happens, it will continue the IN/OUT transfer as long as it's ACKed. After it's done,
4472 there may be too little time left for an isochronous transfer, causing an epid attention
4473 interrupt due to perror. The work-around for this is to let the control transfers run at the
4474 end of the frame instead of at the beginning, and will be interrupted just fine if it doesn't
4475 fit into the frame. However, since there will *always* be a control transfer at the beginning
4476 of the frame, regardless of what we set PSTART to, that transfer might be a 64-byte transfer
4477 which consumes up to 15% of the frame, leaving only 85% for periodic traffic. The solution to
4478 this would be to 'dummy allocate' 5% of the frame with the usb_claim_bandwidth function to make
4479 sure that the periodic transfers that are inserted will always fit in the frame.
4480
4481 The idea was suggested that a control transfer could be split up into several 8 byte transfers,
4482 so that it would be interrupted by PSTART, but since this can't be done for an IN transfer this
4483 hasn't been implemented.
4484
4485 The value 11960 is chosen to be just after the SOF token, with a couple of bit times extra
4486 for possible bit stuffing. */
4487
4488 *R_USB_FM_PSTART = IO_FIELD(R_USB_FM_PSTART, value, 11960);
4489
4490 #ifdef CONFIG_ETRAX_USB_HOST_PORT1
4491 *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
4492 #endif
4493
4494 #ifdef CONFIG_ETRAX_USB_HOST_PORT2
4495 *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no);
4496 #endif
4497
4498 while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
4499
4500 /* Configure the USB interface as a host controller. */
4501 *R_USB_COMMAND =
4502 IO_STATE(R_USB_COMMAND, port_sel, nop) |
4503 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4504 IO_STATE(R_USB_COMMAND, ctrl_cmd, host_config);
4505
4506 /* Note: Do not reset any ports here. Await the port status interrupts, to have a controlled
4507 sequence of resetting the ports. If we reset both ports now, and there are devices
4508 on both ports, we will get a bus error because both devices will answer the set address
4509 request. */
4510
4511 while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
4512
4513 /* Start processing of USB traffic. */
4514 *R_USB_COMMAND =
4515 IO_STATE(R_USB_COMMAND, port_sel, nop) |
4516 IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4517 IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
4518
4519 while (*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy));
4520
4521 usb_rh = usb_alloc_dev(NULL, hc->bus, 0);
4522 hc->bus->root_hub = usb_rh;
4523 usb_rh->state = USB_STATE_ADDRESS;
4524 usb_rh->speed = USB_SPEED_FULL;
4525 usb_rh->devnum = 1;
4526 hc->bus->devnum_next = 2;
4527 usb_rh->ep0.desc.wMaxPacketSize = __const_cpu_to_le16(64);
4528 usb_get_device_descriptor(usb_rh, USB_DT_DEVICE_SIZE);
4529 usb_new_device(usb_rh);
4530
4531 DBFEXIT;
4532
4533 return 0;
4534 }
4535
4536 static void etrax_usb_hc_cleanup(void)
4537 {
4538 DBFENTER;
4539
4540 free_irq(ETRAX_USB_HC_IRQ, NULL);
4541 free_irq(ETRAX_USB_RX_IRQ, NULL);
4542 free_irq(ETRAX_USB_TX_IRQ, NULL);
4543
4544 usb_deregister_bus(etrax_usb_bus);
4545
4546 /* FIXME: call kmem_cache_destroy here? */
4547
4548 DBFEXIT;
4549 }
4550
4551 module_init(etrax_usb_hc_init);
4552 module_exit(etrax_usb_hc_cleanup);
kernel source for telekom puls (alcatel/mediatek)