git.oblomov.eu Git - linux-2.6/blob - drivers/usb/host/hc_crisv10.c

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