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