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