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