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