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