target/linux/etrax/files/drivers/usb/host/hc-crisv10.c

   1 /*
   2  *
   3  * ETRAX 100LX USB Host Controller Driver
   4  *
   5  * Copyright (C) 2005 - 2008  Axis Communications AB
   6  *
   7  * Author: Konrad Eriksson <konrad.eriksson@axis.se>
   8  *
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/kernel.h>
  13 #include <linux/init.h>
  14 #include <linux/moduleparam.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/usb.h>
  17 #include <linux/platform_device.h>
  18
  19 #include <asm/io.h>
  20 #include <asm/irq.h>
  21 #include <asm/arch/dma.h>
  22 #include <asm/arch/io_interface_mux.h>
  23
  24 #include "../core/hcd.h"
  25 #include "../core/hub.h"
  26 #include "hc-crisv10.h"
  27 #include "hc-cris-dbg.h"
  28
  29
  30 /***************************************************************************/
  31 /***************************************************************************/
  32 /* Host Controller settings                                                */
  33 /***************************************************************************/
  34 /***************************************************************************/
  35
  36 #define VERSION                 "1.00-openwrt_diff"
  37 #define COPYRIGHT               "(c) 2005, 2006 Axis Communications AB"
  38 #define DESCRIPTION             "ETRAX 100LX USB Host Controller"
  39
  40 #define ETRAX_USB_HC_IRQ USB_HC_IRQ_NBR
  41 #define ETRAX_USB_RX_IRQ USB_DMA_RX_IRQ_NBR
  42 #define ETRAX_USB_TX_IRQ USB_DMA_TX_IRQ_NBR
  43
  44 /* Number of physical ports in Etrax 100LX */
  45 #define USB_ROOT_HUB_PORTS 2
  46
  47 const char hc_name[] = "hc-crisv10";
  48 const char product_desc[] = DESCRIPTION;
  49
  50 /* The number of epids is, among other things, used for pre-allocating
  51    ctrl, bulk and isoc EP descriptors (one for each epid).
  52    Assumed to be > 1 when initiating the DMA lists. */
  53 #define NBR_OF_EPIDS       32
  54
  55 /* Support interrupt traffic intervals up to 128 ms. */
  56 #define MAX_INTR_INTERVAL  128
  57
  58 /* If periodic traffic (intr or isoc) is to be used, then one entry in the EP
  59    table must be "invalid". By this we mean that we shouldn't care about epid
  60    attentions for this epid, or at least handle them differently from epid
  61    attentions for "valid" epids. This define determines which one to use
  62    (don't change it). */
  63 #define INVALID_EPID       31
  64 /* A special epid for the bulk dummys. */
  65 #define DUMMY_EPID         30
  66
  67 /* Module settings */
  68
  69 MODULE_DESCRIPTION(DESCRIPTION);
  70 MODULE_LICENSE("GPL");
  71 MODULE_AUTHOR("Konrad Eriksson <konrad.eriksson@axis.se>");
  72
  73
  74 /* Module parameters */
  75
  76 /* 0 = No ports enabled
  77    1 = Only port 1 enabled (on board ethernet on devboard)
  78    2 = Only port 2 enabled (external connector on devboard)
  79    3 = Both ports enabled
  80 */
  81 static unsigned int ports = 3;
  82 module_param(ports, uint, S_IRUGO);
  83 MODULE_PARM_DESC(ports, "Bitmask indicating USB ports to use");
  84
  85
  86 /***************************************************************************/
  87 /***************************************************************************/
  88 /* Shared global variables for this module                                 */
  89 /***************************************************************************/
  90 /***************************************************************************/
  91
  92 /* EP descriptor lists for non period transfers. Must be 32-bit aligned. */
  93 static volatile struct USB_EP_Desc TxBulkEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
  94
  95 static volatile struct USB_EP_Desc TxCtrlEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
  96
  97 /* EP descriptor lists for period transfers. Must be 32-bit aligned. */
  98 static volatile struct USB_EP_Desc TxIntrEPList[MAX_INTR_INTERVAL] __attribute__ ((aligned (4)));
  99 static volatile struct USB_SB_Desc TxIntrSB_zout __attribute__ ((aligned (4)));
 100
 101 static volatile struct USB_EP_Desc TxIsocEPList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
 102 static volatile struct USB_SB_Desc TxIsocSB_zout __attribute__ ((aligned (4)));
 103
 104 static volatile struct USB_SB_Desc TxIsocSBList[NBR_OF_EPIDS] __attribute__ ((aligned (4)));
 105
 106 /* After each enabled bulk EP IN we put two disabled EP descriptors with the eol flag set,
 107    causing the DMA to stop the DMA channel. The first of these two has the intr flag set, which
 108    gives us a dma8_sub0_descr interrupt. When we receive this, we advance the DMA one step in the
 109    EP list and then restart the bulk channel, thus forcing a switch between bulk EP descriptors
 110    in each frame. */
 111 static volatile struct USB_EP_Desc TxBulkDummyEPList[NBR_OF_EPIDS][2] __attribute__ ((aligned (4)));
 112
 113 /* List of URB pointers, where each points to the active URB for a epid.
 114    For Bulk, Ctrl and Intr this means which URB that currently is added to
 115    DMA lists (Isoc URBs are all directly added to DMA lists). As soon as
 116    URB has completed is the queue examined and the first URB in queue is
 117    removed and moved to the activeUrbList while its state change to STARTED and
 118    its transfer(s) gets added to DMA list (exception Isoc where URBs enter
 119    state STARTED directly and added transfers added to DMA lists). */
 120 static struct urb *activeUrbList[NBR_OF_EPIDS];
 121
 122 /* Additional software state info for each epid */
 123 static struct etrax_epid epid_state[NBR_OF_EPIDS];
 124
 125 /* Timer handles for bulk traffic timer used to avoid DMA bug where DMA stops
 126    even if there is new data waiting to be processed */
 127 static struct timer_list bulk_start_timer = TIMER_INITIALIZER(NULL, 0, 0);
 128 static struct timer_list bulk_eot_timer = TIMER_INITIALIZER(NULL, 0, 0);
 129
 130 /* We want the start timer to expire before the eot timer, because the former
 131    might start traffic, thus making it unnecessary for the latter to time
 132    out. */
 133 #define BULK_START_TIMER_INTERVAL (HZ/50) /* 20 ms */
 134 #define BULK_EOT_TIMER_INTERVAL (HZ/16) /* 60 ms */
 135
 136 /* Delay before a URB completion happen when it's scheduled to be delayed */
 137 #define LATER_TIMER_DELAY (HZ/50) /* 20 ms */
 138
 139 /* Simplifying macros for checking software state info of a epid */
 140 /* ----------------------------------------------------------------------- */
 141 #define epid_inuse(epid)       epid_state[epid].inuse
 142 #define epid_out_traffic(epid) epid_state[epid].out_traffic
 143 #define epid_isoc(epid)   (epid_state[epid].type == PIPE_ISOCHRONOUS ? 1 : 0)
 144 #define epid_intr(epid)   (epid_state[epid].type == PIPE_INTERRUPT ? 1 : 0)
 145
 146
 147 /***************************************************************************/
 148 /***************************************************************************/
 149 /* DEBUG FUNCTIONS                                                         */
 150 /***************************************************************************/
 151 /***************************************************************************/
 152 /* Note that these functions are always available in their "__" variants,
 153    for use in error situations. The "__" missing variants are controlled by
 154    the USB_DEBUG_DESC/USB_DEBUG_URB macros. */
 155 static void __dump_urb(struct urb* purb)
 156 {
 157   struct crisv10_urb_priv *urb_priv = purb->hcpriv;
 158   int urb_num = -1;
 159   if(urb_priv) {
 160     urb_num = urb_priv->urb_num;
 161   }
 162   printk("\nURB:0x%x[%d]\n", (unsigned int)purb, urb_num);
 163   printk("dev                   :0x%08lx\n", (unsigned long)purb->dev);
 164   printk("pipe                  :0x%08x\n", purb->pipe);
 165   printk("status                :%d\n", purb->status);
 166   printk("transfer_flags        :0x%08x\n", purb->transfer_flags);
 167   printk("transfer_buffer       :0x%08lx\n", (unsigned long)purb->transfer_buffer);
 168   printk("transfer_buffer_length:%d\n", purb->transfer_buffer_length);
 169   printk("actual_length         :%d\n", purb->actual_length);
 170   printk("setup_packet          :0x%08lx\n", (unsigned long)purb->setup_packet);
 171   printk("start_frame           :%d\n", purb->start_frame);
 172   printk("number_of_packets     :%d\n", purb->number_of_packets);
 173   printk("interval              :%d\n", purb->interval);
 174   printk("error_count           :%d\n", purb->error_count);
 175   printk("context               :0x%08lx\n", (unsigned long)purb->context);
 176   printk("complete              :0x%08lx\n\n", (unsigned long)purb->complete);
 177 }
 178
 179 static void __dump_in_desc(volatile struct USB_IN_Desc *in)
 180 {
 181   printk("\nUSB_IN_Desc at 0x%08lx\n", (unsigned long)in);
 182   printk("  sw_len  : 0x%04x (%d)\n", in->sw_len, in->sw_len);
 183   printk("  command : 0x%04x\n", in->command);
 184   printk("  next    : 0x%08lx\n", in->next);
 185   printk("  buf     : 0x%08lx\n", in->buf);
 186   printk("  hw_len  : 0x%04x (%d)\n", in->hw_len, in->hw_len);
 187   printk("  status  : 0x%04x\n\n", in->status);
 188 }
 189
 190 static void __dump_sb_desc(volatile struct USB_SB_Desc *sb)
 191 {
 192   char tt = (sb->command & 0x30) >> 4;
 193   char *tt_string;
 194
 195   switch (tt) {
 196   case 0:
 197     tt_string = "zout";
 198     break;
 199   case 1:
 200     tt_string = "in";
 201     break;
 202   case 2:
 203     tt_string = "out";
 204     break;
 205   case 3:
 206     tt_string = "setup";
 207     break;
 208   default:
 209     tt_string = "unknown (weird)";
 210   }
 211
 212   printk(" USB_SB_Desc at 0x%08lx ", (unsigned long)sb);
 213   printk(" command:0x%04x (", sb->command);
 214   printk("rem:%d ", (sb->command & 0x3f00) >> 8);
 215   printk("full:%d ", (sb->command & 0x40) >> 6);
 216   printk("tt:%d(%s) ", tt, tt_string);
 217   printk("intr:%d ", (sb->command & 0x8) >> 3);
 218   printk("eot:%d ", (sb->command & 0x2) >> 1);
 219   printk("eol:%d)", sb->command & 0x1);
 220   printk(" sw_len:0x%04x(%d)", sb->sw_len, sb->sw_len);
 221   printk(" next:0x%08lx", sb->next);
 222   printk(" buf:0x%08lx\n", sb->buf);
 223 }
 224
 225
 226 static void __dump_ep_desc(volatile struct USB_EP_Desc *ep)
 227 {
 228   printk("USB_EP_Desc at 0x%08lx ", (unsigned long)ep);
 229   printk(" command:0x%04x (", ep->command);
 230   printk("ep_id:%d ", (ep->command & 0x1f00) >> 8);
 231   printk("enable:%d ", (ep->command & 0x10) >> 4);
 232   printk("intr:%d ", (ep->command & 0x8) >> 3);
 233   printk("eof:%d ", (ep->command & 0x2) >> 1);
 234   printk("eol:%d)", ep->command & 0x1);
 235   printk(" hw_len:0x%04x(%d)", ep->hw_len, ep->hw_len);
 236   printk(" next:0x%08lx", ep->next);
 237   printk(" sub:0x%08lx\n", ep->sub);
 238 }
 239
 240 static inline void __dump_ep_list(int pipe_type)
 241 {
 242   volatile struct USB_EP_Desc *ep;
 243   volatile struct USB_EP_Desc *first_ep;
 244   volatile struct USB_SB_Desc *sb;
 245
 246   switch (pipe_type)
 247     {
 248     case PIPE_BULK:
 249       first_ep = &TxBulkEPList[0];
 250       break;
 251     case PIPE_CONTROL:
 252       first_ep = &TxCtrlEPList[0];
 253       break;
 254     case PIPE_INTERRUPT:
 255       first_ep = &TxIntrEPList[0];
 256       break;
 257     case PIPE_ISOCHRONOUS:
 258       first_ep = &TxIsocEPList[0];
 259       break;
 260     default:
 261       warn("Cannot dump unknown traffic type");
 262       return;
 263     }
 264   ep = first_ep;
 265
 266   printk("\n\nDumping EP list...\n\n");
 267
 268   do {
 269     __dump_ep_desc(ep);
 270     /* Cannot phys_to_virt on 0 as it turns into 80000000, which is != 0. */
 271     sb = ep->sub ? phys_to_virt(ep->sub) : 0;
 272     while (sb) {
 273       __dump_sb_desc(sb);
 274       sb = sb->next ? phys_to_virt(sb->next) : 0;
 275     }
 276     ep = (volatile struct USB_EP_Desc *)(phys_to_virt(ep->next));
 277
 278   } while (ep != first_ep);
 279 }
 280
 281 static inline void __dump_ept_data(int epid)
 282 {
 283   unsigned long flags;
 284   __u32 r_usb_ept_data;
 285
 286   if (epid < 0 || epid > 31) {
 287     printk("Cannot dump ept data for invalid epid %d\n", epid);
 288     return;
 289   }
 290
 291   local_irq_save(flags);
 292   *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
 293   nop();
 294   r_usb_ept_data = *R_USB_EPT_DATA;
 295   local_irq_restore(flags);
 296
 297   printk(" R_USB_EPT_DATA = 0x%x for epid %d :\n", r_usb_ept_data, epid);
 298   if (r_usb_ept_data == 0) {
 299     /* No need for more detailed printing. */
 300     return;
 301   }
 302   printk("  valid           : %d\n", (r_usb_ept_data & 0x80000000) >> 31);
 303   printk("  hold            : %d\n", (r_usb_ept_data & 0x40000000) >> 30);
 304   printk("  error_count_in  : %d\n", (r_usb_ept_data & 0x30000000) >> 28);
 305   printk("  t_in            : %d\n", (r_usb_ept_data & 0x08000000) >> 27);
 306   printk("  low_speed       : %d\n", (r_usb_ept_data & 0x04000000) >> 26);
 307   printk("  port            : %d\n", (r_usb_ept_data & 0x03000000) >> 24);
 308   printk("  error_code      : %d\n", (r_usb_ept_data & 0x00c00000) >> 22);
 309   printk("  t_out           : %d\n", (r_usb_ept_data & 0x00200000) >> 21);
 310   printk("  error_count_out : %d\n", (r_usb_ept_data & 0x00180000) >> 19);
 311   printk("  max_len         : %d\n", (r_usb_ept_data & 0x0003f800) >> 11);
 312   printk("  ep              : %d\n", (r_usb_ept_data & 0x00000780) >> 7);
 313   printk("  dev             : %d\n", (r_usb_ept_data & 0x0000003f));
 314 }
 315
 316 static inline void __dump_ept_data_iso(int epid)
 317 {
 318   unsigned long flags;
 319   __u32 ept_data;
 320
 321   if (epid < 0 || epid > 31) {
 322     printk("Cannot dump ept data for invalid epid %d\n", epid);
 323     return;
 324   }
 325
 326   local_irq_save(flags);
 327   *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
 328   nop();
 329   ept_data = *R_USB_EPT_DATA_ISO;
 330   local_irq_restore(flags);
 331
 332   printk(" R_USB_EPT_DATA = 0x%x for epid %d :\n", ept_data, epid);
 333   if (ept_data == 0) {
 334     /* No need for more detailed printing. */
 335     return;
 336   }
 337   printk("  valid           : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, valid,
 338                                                 ept_data));
 339   printk("  port            : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, port,
 340                                                 ept_data));
 341   printk("  error_code      : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code,
 342                                                 ept_data));
 343   printk("  max_len         : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, max_len,
 344                                                 ept_data));
 345   printk("  ep              : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, ep,
 346                                                 ept_data));
 347   printk("  dev             : %d\n", IO_EXTRACT(R_USB_EPT_DATA_ISO, dev,
 348                                                 ept_data));
 349 }
 350
 351 static inline void __dump_ept_data_list(void)
 352 {
 353   int i;
 354
 355   printk("Dumping the whole R_USB_EPT_DATA list\n");
 356
 357   for (i = 0; i < 32; i++) {
 358     __dump_ept_data(i);
 359   }
 360 }
 361
 362 static void debug_epid(int epid) {
 363   int i;
 364
 365   if(epid_isoc(epid)) {
 366     __dump_ept_data_iso(epid);
 367   } else {
 368     __dump_ept_data(epid);
 369   }
 370
 371   printk("Bulk:\n");
 372   for(i = 0; i < 32; i++) {
 373     if(IO_EXTRACT(USB_EP_command, epid, TxBulkEPList[i].command) ==
 374        epid) {
 375       printk("%d: ", i); __dump_ep_desc(&(TxBulkEPList[i]));
 376     }
 377   }
 378
 379   printk("Ctrl:\n");
 380   for(i = 0; i < 32; i++) {
 381     if(IO_EXTRACT(USB_EP_command, epid, TxCtrlEPList[i].command) ==
 382        epid) {
 383       printk("%d: ", i); __dump_ep_desc(&(TxCtrlEPList[i]));
 384     }
 385   }
 386
 387   printk("Intr:\n");
 388   for(i = 0; i < MAX_INTR_INTERVAL; i++) {
 389     if(IO_EXTRACT(USB_EP_command, epid, TxIntrEPList[i].command) ==
 390        epid) {
 391       printk("%d: ", i); __dump_ep_desc(&(TxIntrEPList[i]));
 392     }
 393   }
 394
 395   printk("Isoc:\n");
 396   for(i = 0; i < 32; i++) {
 397     if(IO_EXTRACT(USB_EP_command, epid, TxIsocEPList[i].command) ==
 398        epid) {
 399       printk("%d: ", i); __dump_ep_desc(&(TxIsocEPList[i]));
 400     }
 401   }
 402
 403   __dump_ept_data_list();
 404   __dump_ep_list(PIPE_INTERRUPT);
 405   printk("\n\n");
 406 }
 407
 408
 409
 410 char* hcd_status_to_str(__u8 bUsbStatus) {
 411   static char hcd_status_str[128];
 412   hcd_status_str[0] = '\0';
 413   if(bUsbStatus & IO_STATE(R_USB_STATUS, ourun, yes)) {
 414     strcat(hcd_status_str, "ourun ");
 415   }
 416   if(bUsbStatus & IO_STATE(R_USB_STATUS, perror, yes)) {
 417     strcat(hcd_status_str, "perror ");
 418   }
 419   if(bUsbStatus & IO_STATE(R_USB_STATUS, device_mode, yes)) {
 420     strcat(hcd_status_str, "device_mode ");
 421   }
 422   if(bUsbStatus & IO_STATE(R_USB_STATUS, host_mode, yes)) {
 423     strcat(hcd_status_str, "host_mode ");
 424   }
 425   if(bUsbStatus & IO_STATE(R_USB_STATUS, started, yes)) {
 426     strcat(hcd_status_str, "started ");
 427   }
 428   if(bUsbStatus & IO_STATE(R_USB_STATUS, running, yes)) {
 429     strcat(hcd_status_str, "running ");
 430   }
 431   return hcd_status_str;
 432 }
 433
 434
 435 char* sblist_to_str(struct USB_SB_Desc* sb_desc) {
 436   static char sblist_to_str_buff[128];
 437   char tmp[32], tmp2[32];
 438   sblist_to_str_buff[0] = '\0';
 439   while(sb_desc != NULL) {
 440     switch(IO_EXTRACT(USB_SB_command, tt, sb_desc->command)) {
 441     case 0: sprintf(tmp, "zout");  break;
 442     case 1: sprintf(tmp, "in");    break;
 443     case 2: sprintf(tmp, "out");   break;
 444     case 3: sprintf(tmp, "setup"); break;
 445     }
 446     sprintf(tmp2, "(%s %d)", tmp, sb_desc->sw_len);
 447     strcat(sblist_to_str_buff, tmp2);
 448     if(sb_desc->next != 0) {
 449       sb_desc = phys_to_virt(sb_desc->next);
 450     } else {
 451       sb_desc = NULL;
 452     }
 453   }
 454   return sblist_to_str_buff;
 455 }
 456
 457 char* port_status_to_str(__u16 wPortStatus) {
 458   static char port_status_str[128];
 459   port_status_str[0] = '\0';
 460   if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, connected, yes)) {
 461     strcat(port_status_str, "connected ");
 462   }
 463   if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)) {
 464     strcat(port_status_str, "enabled ");
 465   }
 466   if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, suspended, yes)) {
 467     strcat(port_status_str, "suspended ");
 468   }
 469   if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, reset, yes)) {
 470     strcat(port_status_str, "reset ");
 471   }
 472   if(wPortStatus & IO_STATE(R_USB_RH_PORT_STATUS_1, speed, full)) {
 473     strcat(port_status_str, "full-speed ");
 474   } else {
 475     strcat(port_status_str, "low-speed ");
 476   }
 477   return port_status_str;
 478 }
 479
 480
 481 char* endpoint_to_str(struct usb_endpoint_descriptor *ed) {
 482   static char endpoint_to_str_buff[128];
 483   char tmp[32];
 484   int epnum = ed->bEndpointAddress & 0x0F;
 485   int dir = ed->bEndpointAddress & 0x80;
 486   int type = ed->bmAttributes & 0x03;
 487   endpoint_to_str_buff[0] = '\0';
 488   sprintf(endpoint_to_str_buff, "ep:%d ", epnum);
 489   switch(type) {
 490   case 0:
 491     sprintf(tmp, " ctrl");
 492     break;
 493   case 1:
 494     sprintf(tmp, " isoc");
 495     break;
 496   case 2:
 497     sprintf(tmp, " bulk");
 498     break;
 499   case 3:
 500     sprintf(tmp, " intr");
 501     break;
 502   }
 503   strcat(endpoint_to_str_buff, tmp);
 504   if(dir) {
 505     sprintf(tmp, " in");
 506   } else {
 507     sprintf(tmp, " out");
 508   }
 509   strcat(endpoint_to_str_buff, tmp);
 510
 511   return endpoint_to_str_buff;
 512 }
 513
 514 /* Debug helper functions for Transfer Controller */
 515 char* pipe_to_str(unsigned int pipe) {
 516   static char pipe_to_str_buff[128];
 517   char tmp[64];
 518   sprintf(pipe_to_str_buff, "dir:%s", str_dir(pipe));
 519   sprintf(tmp, " type:%s", str_type(pipe));
 520   strcat(pipe_to_str_buff, tmp);
 521
 522   sprintf(tmp, " dev:%d", usb_pipedevice(pipe));
 523   strcat(pipe_to_str_buff, tmp);
 524   sprintf(tmp, " ep:%d", usb_pipeendpoint(pipe));
 525   strcat(pipe_to_str_buff, tmp);
 526   return pipe_to_str_buff;
 527 }
 528
 529
 530 #define USB_DEBUG_DESC 1
 531
 532 #ifdef USB_DEBUG_DESC
 533 #define dump_in_desc(x) __dump_in_desc(x)
 534 #define dump_sb_desc(...) __dump_sb_desc(...)
 535 #define dump_ep_desc(x) __dump_ep_desc(x)
 536 #define dump_ept_data(x) __dump_ept_data(x)
 537 #else
 538 #define dump_in_desc(...) do {} while (0)
 539 #define dump_sb_desc(...) do {} while (0)
 540 #define dump_ep_desc(...) do {} while (0)
 541 #endif
 542
 543
 544 /* Uncomment this to enable massive function call trace
 545    #define USB_DEBUG_TRACE */
 546
 547 #ifdef USB_DEBUG_TRACE
 548 #define DBFENTER (printk(": Entering: %s\n", __FUNCTION__))
 549 #define DBFEXIT  (printk(": Exiting:  %s\n", __FUNCTION__))
 550 #else
 551 #define DBFENTER do {} while (0)
 552 #define DBFEXIT  do {} while (0)
 553 #endif
 554
 555 #define CHECK_ALIGN(x) if (((__u32)(x)) & 0x00000003) \
 556 {panic("Alignment check (DWORD) failed at %s:%s:%d\n", __FILE__, __FUNCTION__, __LINE__);}
 557
 558 /* Most helpful debugging aid */
 559 #define ASSERT(expr) ((void) ((expr) ? 0 : (err("assert failed at: %s %d",__FUNCTION__, __LINE__))))
 560
 561
 562 /***************************************************************************/
 563 /***************************************************************************/
 564 /* Forward declarations                                                    */
 565 /***************************************************************************/
 566 /***************************************************************************/
 567 void crisv10_hcd_epid_attn_irq(struct crisv10_irq_reg *reg);
 568 void crisv10_hcd_port_status_irq(struct crisv10_irq_reg *reg);
 569 void crisv10_hcd_ctl_status_irq(struct crisv10_irq_reg *reg);
 570 void crisv10_hcd_isoc_eof_irq(struct crisv10_irq_reg *reg);
 571
 572 void rh_port_status_change(__u16[]);
 573 int  rh_clear_port_feature(__u8, __u16);
 574 int  rh_set_port_feature(__u8, __u16);
 575 static void rh_disable_port(unsigned int port);
 576
 577 static void check_finished_bulk_tx_epids(struct usb_hcd *hcd,
 578                                          int timer);
 579
 580 static int  tc_setup_epid(struct usb_host_endpoint *ep, struct urb *urb,
 581                          int mem_flags);
 582 static void tc_free_epid(struct usb_host_endpoint *ep);
 583 static int  tc_allocate_epid(void);
 584 static void tc_finish_urb(struct usb_hcd *hcd, struct urb *urb, int status);
 585 static void tc_finish_urb_later(struct usb_hcd *hcd, struct urb *urb,
 586                                 int status);
 587
 588 static int  urb_priv_create(struct usb_hcd *hcd, struct urb *urb, int epid,
 589                            int mem_flags);
 590 static void urb_priv_free(struct usb_hcd *hcd, struct urb *urb);
 591
 592 static int crisv10_usb_check_bandwidth(struct usb_device *dev,struct urb *urb);
 593 static void crisv10_usb_claim_bandwidth(
 594         struct usb_device *dev, struct urb *urb, int bustime, int isoc);
 595 static void crisv10_usb_release_bandwidth(
 596         struct usb_hcd *hcd, int isoc, int bandwidth);
 597
 598 static inline struct urb *urb_list_first(int epid);
 599 static inline void        urb_list_add(struct urb *urb, int epid,
 600                                       int mem_flags);
 601 static inline urb_entry_t *urb_list_entry(struct urb *urb, int epid);
 602 static inline void        urb_list_del(struct urb *urb, int epid);
 603 static inline void        urb_list_move_last(struct urb *urb, int epid);
 604 static inline struct urb *urb_list_next(struct urb *urb, int epid);
 605
 606 int create_sb_for_urb(struct urb *urb, int mem_flags);
 607 int init_intr_urb(struct urb *urb, int mem_flags);
 608
 609 static inline void  etrax_epid_set(__u8 index, __u32 data);
 610 static inline void  etrax_epid_clear_error(__u8 index);
 611 static inline void  etrax_epid_set_toggle(__u8 index, __u8 dirout,
 612                                               __u8 toggle);
 613 static inline __u8  etrax_epid_get_toggle(__u8 index, __u8 dirout);
 614 static inline __u32 etrax_epid_get(__u8 index);
 615
 616 /* We're accessing the same register position in Etrax so
 617    when we do full access the internal difference doesn't matter */
 618 #define etrax_epid_iso_set(index, data) etrax_epid_set(index, data)
 619 #define etrax_epid_iso_get(index) etrax_epid_get(index)
 620
 621
 622 static void        tc_dma_process_isoc_urb(struct urb *urb);
 623 static void        tc_dma_process_queue(int epid);
 624 static void        tc_dma_unlink_intr_urb(struct urb *urb);
 625 static irqreturn_t tc_dma_tx_interrupt(int irq, void *vhc);
 626 static irqreturn_t tc_dma_rx_interrupt(int irq, void *vhc);
 627
 628 static void tc_bulk_start_timer_func(unsigned long dummy);
 629 static void tc_bulk_eot_timer_func(unsigned long dummy);
 630
 631
 632 /*************************************************************/
 633 /*************************************************************/
 634 /* Host Controler Driver block                               */
 635 /*************************************************************/
 636 /*************************************************************/
 637
 638 /* HCD operations */
 639 static irqreturn_t crisv10_hcd_top_irq(int irq, void*);
 640 static int crisv10_hcd_reset(struct usb_hcd *);
 641 static int crisv10_hcd_start(struct usb_hcd *);
 642 static void crisv10_hcd_stop(struct usb_hcd *);
 643 #ifdef CONFIG_PM
 644 static int crisv10_hcd_suspend(struct device *, u32, u32);
 645 static int crisv10_hcd_resume(struct device *, u32);
 646 #endif /* CONFIG_PM */
 647 static int crisv10_hcd_get_frame(struct usb_hcd *);
 648
 649 static int  tc_urb_enqueue(struct usb_hcd *, struct urb *, gfp_t mem_flags);
 650 static int  tc_urb_dequeue(struct usb_hcd *, struct urb *, int);
 651 static void tc_endpoint_disable(struct usb_hcd *, struct usb_host_endpoint *ep);
 652
 653 static int rh_status_data_request(struct usb_hcd *, char *);
 654 static int rh_control_request(struct usb_hcd *, u16, u16, u16, char*, u16);
 655
 656 #ifdef CONFIG_PM
 657 static int crisv10_hcd_hub_suspend(struct usb_hcd *);
 658 static int crisv10_hcd_hub_resume(struct usb_hcd *);
 659 #endif /* CONFIG_PM */
 660 #ifdef CONFIG_USB_OTG
 661 static int crisv10_hcd_start_port_reset(struct usb_hcd *, unsigned);
 662 #endif /* CONFIG_USB_OTG */
 663
 664 /* host controller driver interface */
 665 static const struct hc_driver crisv10_hc_driver =
 666   {
 667     .description =      hc_name,
 668     .product_desc =     product_desc,
 669     .hcd_priv_size =    sizeof(struct crisv10_hcd),
 670
 671     /* Attaching IRQ handler manualy in probe() */
 672     /* .irq =           crisv10_hcd_irq, */
 673
 674     .flags =            HCD_USB11,
 675
 676     /* called to init HCD and root hub */
 677     .reset =            crisv10_hcd_reset,
 678     .start =            crisv10_hcd_start,
 679
 680     /* cleanly make HCD stop writing memory and doing I/O */
 681     .stop =             crisv10_hcd_stop,
 682
 683     /* return current frame number */
 684     .get_frame_number = crisv10_hcd_get_frame,
 685
 686
 687     /* Manage i/o requests via the Transfer Controller */
 688     .urb_enqueue =      tc_urb_enqueue,
 689     .urb_dequeue =      tc_urb_dequeue,
 690
 691     /* hw synch, freeing endpoint resources that urb_dequeue can't */
 692     .endpoint_disable = tc_endpoint_disable,
 693
 694
 695     /* Root Hub support */
 696     .hub_status_data =  rh_status_data_request,
 697     .hub_control =      rh_control_request,
 698 #ifdef CONFIG_PM
 699     .hub_suspend =      rh_suspend_request,
 700     .hub_resume =       rh_resume_request,
 701 #endif /* CONFIG_PM */
 702 #ifdef  CONFIG_USB_OTG
 703     .start_port_reset = crisv10_hcd_start_port_reset,
 704 #endif /* CONFIG_USB_OTG */
 705   };
 706
 707
 708 /*
 709  * conversion between pointers to a hcd and the corresponding
 710  * crisv10_hcd
 711  */
 712
 713 static inline struct crisv10_hcd *hcd_to_crisv10_hcd(struct usb_hcd *hcd)
 714 {
 715         return (struct crisv10_hcd *) hcd->hcd_priv;
 716 }
 717
 718 static inline struct usb_hcd *crisv10_hcd_to_hcd(struct crisv10_hcd *hcd)
 719 {
 720         return container_of((void *) hcd, struct usb_hcd, hcd_priv);
 721 }
 722
 723 /* check if specified port is in use */
 724 static inline int port_in_use(unsigned int port)
 725 {
 726         return ports & (1 << port);
 727 }
 728
 729 /* number of ports in use */
 730 static inline unsigned int num_ports(void)
 731 {
 732         unsigned int i, num = 0;
 733         for (i = 0; i < USB_ROOT_HUB_PORTS; i++)
 734                 if (port_in_use(i))
 735                         num++;
 736         return num;
 737 }
 738
 739 /* map hub port number to the port number used internally by the HC */
 740 static inline unsigned int map_port(unsigned int port)
 741 {
 742   unsigned int i, num = 0;
 743   for (i = 0; i < USB_ROOT_HUB_PORTS; i++)
 744     if (port_in_use(i))
 745       if (++num == port)
 746         return i;
 747   return -1;
 748 }
 749
 750 /* size of descriptors in slab cache */
 751 #ifndef MAX
 752 #define MAX(x, y)               ((x) > (y) ? (x) : (y))
 753 #endif
 754
 755
 756 /******************************************************************/
 757 /* Hardware Interrupt functions                                   */
 758 /******************************************************************/
 759
 760 /* Fast interrupt handler for HC */
 761 static irqreturn_t crisv10_hcd_top_irq(int irq, void *vcd)
 762 {
 763   struct usb_hcd *hcd = vcd;
 764   struct crisv10_irq_reg reg;
 765   __u32 irq_mask;
 766   unsigned long flags;
 767
 768   DBFENTER;
 769
 770   ASSERT(hcd != NULL);
 771   reg.hcd = hcd;
 772
 773   /* Turn of other interrupts while handling these sensitive cases */
 774   local_irq_save(flags);
 775
 776   /* Read out which interrupts that are flaged */
 777   irq_mask = *R_USB_IRQ_MASK_READ;
 778   reg.r_usb_irq_mask_read = irq_mask;
 779
 780   /* Reading R_USB_STATUS clears the ctl_status interrupt. Note that
 781      R_USB_STATUS must be read before R_USB_EPID_ATTN since reading the latter
 782      clears the ourun and perror fields of R_USB_STATUS. */
 783   reg.r_usb_status = *R_USB_STATUS;
 784
 785   /* Reading R_USB_EPID_ATTN clears the iso_eof, bulk_eot and epid_attn
 786      interrupts. */
 787   reg.r_usb_epid_attn = *R_USB_EPID_ATTN;
 788
 789   /* Reading R_USB_RH_PORT_STATUS_1 and R_USB_RH_PORT_STATUS_2 clears the
 790      port_status interrupt. */
 791   reg.r_usb_rh_port_status_1 = *R_USB_RH_PORT_STATUS_1;
 792   reg.r_usb_rh_port_status_2 = *R_USB_RH_PORT_STATUS_2;
 793
 794   /* Reading R_USB_FM_NUMBER clears the sof interrupt. */
 795   /* Note: the lower 11 bits contain the actual frame number, sent with each
 796      sof. */
 797   reg.r_usb_fm_number = *R_USB_FM_NUMBER;
 798
 799   /* Interrupts are handled in order of priority. */
 800   if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, port_status)) {
 801     crisv10_hcd_port_status_irq(&reg);
 802   }
 803   if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, epid_attn)) {
 804     crisv10_hcd_epid_attn_irq(&reg);
 805   }
 806   if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, ctl_status)) {
 807     crisv10_hcd_ctl_status_irq(&reg);
 808   }
 809   if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, iso_eof)) {
 810     crisv10_hcd_isoc_eof_irq(&reg);
 811   }
 812   if (irq_mask & IO_MASK(R_USB_IRQ_MASK_READ, bulk_eot)) {
 813     /* Update/restart the bulk start timer since obviously the channel is
 814        running. */
 815     mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
 816     /* Update/restart the bulk eot timer since we just received an bulk eot
 817        interrupt. */
 818     mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
 819
 820     /* Check for finished bulk transfers on epids */
 821     check_finished_bulk_tx_epids(hcd, 0);
 822   }
 823   local_irq_restore(flags);
 824
 825   DBFEXIT;
 826   return IRQ_HANDLED;
 827 }
 828
 829
 830 void crisv10_hcd_epid_attn_irq(struct crisv10_irq_reg *reg) {
 831   struct usb_hcd *hcd = reg->hcd;
 832   struct crisv10_urb_priv *urb_priv;
 833   int epid;
 834   DBFENTER;
 835
 836   for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
 837     if (test_bit(epid, (void *)&reg->r_usb_epid_attn)) {
 838       struct urb *urb;
 839       __u32 ept_data;
 840       int error_code;
 841
 842       if (epid == DUMMY_EPID || epid == INVALID_EPID) {
 843         /* We definitely don't care about these ones. Besides, they are
 844            always disabled, so any possible disabling caused by the
 845            epid attention interrupt is irrelevant. */
 846         warn("Got epid_attn for INVALID_EPID or DUMMY_EPID (%d).", epid);
 847         continue;
 848       }
 849
 850       if(!epid_inuse(epid)) {
 851         irq_err("Epid attention on epid:%d that isn't in use\n", epid);
 852         printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
 853         debug_epid(epid);
 854         continue;
 855       }
 856
 857       /* Note that although there are separate R_USB_EPT_DATA and
 858          R_USB_EPT_DATA_ISO registers, they are located at the same address and
 859          are of the same size. In other words, this read should be ok for isoc
 860          also. */
 861       ept_data = etrax_epid_get(epid);
 862       error_code = IO_EXTRACT(R_USB_EPT_DATA, error_code, ept_data);
 863
 864       /* Get the active URB for this epid. We blatantly assume
 865          that only this URB could have caused the epid attention. */
 866       urb = activeUrbList[epid];
 867       if (urb == NULL) {
 868         irq_err("Attention on epid:%d error:%d with no active URB.\n",
 869                 epid, error_code);
 870         printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
 871         debug_epid(epid);
 872         continue;
 873       }
 874
 875       urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
 876       ASSERT(urb_priv);
 877
 878       /* Using IO_STATE_VALUE on R_USB_EPT_DATA should be ok for isoc also. */
 879       if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
 880
 881         /* Isoc traffic doesn't have error_count_in/error_count_out. */
 882         if ((usb_pipetype(urb->pipe) != PIPE_ISOCHRONOUS) &&
 883             (IO_EXTRACT(R_USB_EPT_DATA, error_count_in, ept_data) == 3 ||
 884              IO_EXTRACT(R_USB_EPT_DATA, error_count_out, ept_data) == 3)) {
 885           /* Check if URB allready is marked for late-finish, we can get
 886              several 3rd error for Intr traffic when a device is unplugged */
 887           if(urb_priv->later_data == NULL) {
 888             /* 3rd error. */
 889             irq_warn("3rd error for epid:%d (%s %s) URB:0x%x[%d]\n", epid,
 890                      str_dir(urb->pipe), str_type(urb->pipe),
 891                      (unsigned int)urb, urb_priv->urb_num);
 892
 893             tc_finish_urb_later(hcd, urb, -EPROTO);
 894           }
 895
 896         } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
 897           irq_warn("Perror for epid:%d\n", epid);
 898           printk("FM_NUMBER: %d\n", reg->r_usb_fm_number & 0x7ff);
 899           printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
 900           __dump_urb(urb);
 901           debug_epid(epid);
 902
 903           if (!(ept_data & IO_MASK(R_USB_EPT_DATA, valid))) {
 904             /* invalid ep_id */
 905             panic("Perror because of invalid epid."
 906                   " Deconfigured too early?");
 907           } else {
 908             /* past eof1, near eof, zout transfer, setup transfer */
 909             /* Dump the urb and the relevant EP descriptor. */
 910             panic("Something wrong with DMA descriptor contents."
 911                   " Too much traffic inserted?");
 912           }
 913         } else if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
 914           /* buffer ourun */
 915           printk("FM_NUMBER: %d\n", reg->r_usb_fm_number & 0x7ff);
 916           printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
 917           __dump_urb(urb);
 918           debug_epid(epid);
 919
 920           panic("Buffer overrun/underrun for epid:%d. DMA too busy?", epid);
 921         } else {
 922           irq_warn("Attention on epid:%d (%s %s) with no error code\n", epid,
 923                    str_dir(urb->pipe), str_type(urb->pipe));
 924           printk("R_USB_STATUS: 0x%x\n", reg->r_usb_status);
 925           __dump_urb(urb);
 926           debug_epid(epid);
 927         }
 928
 929       } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
 930                                               stall)) {
 931         /* Not really a protocol error, just says that the endpoint gave
 932            a stall response. Note that error_code cannot be stall for isoc. */
 933         if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
 934           panic("Isoc traffic cannot stall");
 935         }
 936
 937         tc_dbg("Stall for epid:%d (%s %s) URB:0x%x\n", epid,
 938                str_dir(urb->pipe), str_type(urb->pipe), (unsigned int)urb);
 939         tc_finish_urb(hcd, urb, -EPIPE);
 940
 941       } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
 942                                               bus_error)) {
 943         /* Two devices responded to a transaction request. Must be resolved
 944            by software. FIXME: Reset ports? */
 945         panic("Bus error for epid %d."
 946               " Two devices responded to transaction request\n",
 947               epid);
 948
 949       } else if (error_code == IO_STATE_VALUE(R_USB_EPT_DATA, error_code,
 950                                               buffer_error)) {
 951         /* DMA overrun or underrun. */
 952         irq_warn("Buffer overrun/underrun for epid:%d (%s %s)\n", epid,
 953                  str_dir(urb->pipe), str_type(urb->pipe));
 954
 955         /* It seems that error_code = buffer_error in
 956            R_USB_EPT_DATA/R_USB_EPT_DATA_ISO and ourun = yes in R_USB_STATUS
 957            are the same error. */
 958         tc_finish_urb(hcd, urb, -EPROTO);
 959       } else {
 960           irq_warn("Unknown attention on epid:%d (%s %s)\n", epid,
 961                    str_dir(urb->pipe), str_type(urb->pipe));
 962           dump_ept_data(epid);
 963       }
 964     }
 965   }
 966   DBFEXIT;
 967 }
 968
 969 void crisv10_hcd_port_status_irq(struct crisv10_irq_reg *reg)
 970 {
 971   __u16 port_reg[USB_ROOT_HUB_PORTS];
 972   DBFENTER;
 973   port_reg[0] = reg->r_usb_rh_port_status_1;
 974   port_reg[1] = reg->r_usb_rh_port_status_2;
 975   rh_port_status_change(port_reg);
 976   DBFEXIT;
 977 }
 978
 979 void crisv10_hcd_isoc_eof_irq(struct crisv10_irq_reg *reg)
 980 {
 981   int epid;
 982   struct urb *urb;
 983   struct crisv10_urb_priv *urb_priv;
 984
 985   DBFENTER;
 986
 987   for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
 988
 989     /* Only check epids that are in use, is valid and has SB list */
 990     if (!epid_inuse(epid) || epid == INVALID_EPID ||
 991         TxIsocEPList[epid].sub == 0 || epid == DUMMY_EPID) {
 992       /* Nothing here to see. */
 993       continue;
 994     }
 995     ASSERT(epid_isoc(epid));
 996
 997     /* Get the active URB for this epid (if any). */
 998     urb = activeUrbList[epid];
 999     if (urb == 0) {
1000       isoc_warn("Ignoring NULL urb for epid:%d\n", epid);
1001       continue;
1002     }
1003     if(!epid_out_traffic(epid)) {
1004       /* Sanity check. */
1005       ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
1006
1007       urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
1008       ASSERT(urb_priv);
1009
1010       if (urb_priv->urb_state == NOT_STARTED) {
1011         /* If ASAP is not set and urb->start_frame is the current frame,
1012            start the transfer. */
1013         if (!(urb->transfer_flags & URB_ISO_ASAP) &&
1014             (urb->start_frame == (*R_USB_FM_NUMBER & 0x7ff))) {
1015           /* EP should not be enabled if we're waiting for start_frame */
1016           ASSERT((TxIsocEPList[epid].command &
1017                   IO_STATE(USB_EP_command, enable, yes)) == 0);
1018
1019           isoc_warn("Enabling isoc IN EP descr for epid %d\n", epid);
1020           TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
1021
1022           /* This urb is now active. */
1023           urb_priv->urb_state = STARTED;
1024           continue;
1025         }
1026       }
1027     }
1028   }
1029
1030   DBFEXIT;
1031 }
1032
1033 void crisv10_hcd_ctl_status_irq(struct crisv10_irq_reg *reg)
1034 {
1035   struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(reg->hcd);
1036
1037   DBFENTER;
1038   ASSERT(crisv10_hcd);
1039
1040 /*  irq_dbg("ctr_status_irq, controller status: %s\n",
1041           hcd_status_to_str(reg->r_usb_status));*/
1042
1043   /* FIXME: What should we do if we get ourun or perror? Dump the EP and SB
1044      list for the corresponding epid? */
1045   if (reg->r_usb_status & IO_MASK(R_USB_STATUS, ourun)) {
1046     panic("USB controller got ourun.");
1047   }
1048   if (reg->r_usb_status & IO_MASK(R_USB_STATUS, perror)) {
1049
1050     /* Before, etrax_usb_do_intr_recover was called on this epid if it was
1051        an interrupt pipe. I don't see how re-enabling all EP descriptors
1052        will help if there was a programming error. */
1053     panic("USB controller got perror.");
1054   }
1055
1056   /* Keep track of USB Controller, if it's running or not */
1057   if(reg->r_usb_status & IO_STATE(R_USB_STATUS, running, yes)) {
1058     crisv10_hcd->running = 1;
1059   } else {
1060     crisv10_hcd->running = 0;
1061   }
1062
1063   if (reg->r_usb_status & IO_MASK(R_USB_STATUS, device_mode)) {
1064     /* We should never operate in device mode. */
1065     panic("USB controller in device mode.");
1066   }
1067
1068   /* Set the flag to avoid getting "Unlink after no-IRQ? Controller is probably
1069      using the wrong IRQ" from hcd_unlink_urb() in drivers/usb/core/hcd.c */
1070   set_bit(HCD_FLAG_SAW_IRQ, &reg->hcd->flags);
1071
1072   DBFEXIT;
1073 }
1074
1075
1076 /******************************************************************/
1077 /* Host Controller interface functions                            */
1078 /******************************************************************/
1079
1080 static inline void crisv10_ready_wait(void) {
1081   volatile int timeout = 10000;
1082   /* Check the busy bit of USB controller in Etrax */
1083   while((*R_USB_COMMAND & IO_MASK(R_USB_COMMAND, busy)) &&
1084         (timeout-- > 0));
1085   if(timeout == 0) {
1086     warn("Timeout while waiting for USB controller to be idle\n");
1087   }
1088 }
1089
1090 /* reset host controller */
1091 static int crisv10_hcd_reset(struct usb_hcd *hcd)
1092 {
1093   DBFENTER;
1094   hcd_dbg(hcd, "reset\n");
1095
1096
1097   /* Reset the USB interface. */
1098   /*
1099   *R_USB_COMMAND =
1100     IO_STATE(R_USB_COMMAND, port_sel, nop) |
1101     IO_STATE(R_USB_COMMAND, port_cmd, reset) |
1102     IO_STATE(R_USB_COMMAND, ctrl_cmd, reset);
1103   nop();
1104   */
1105   DBFEXIT;
1106   return 0;
1107 }
1108
1109 /* start host controller */
1110 static int crisv10_hcd_start(struct usb_hcd *hcd)
1111 {
1112   DBFENTER;
1113   hcd_dbg(hcd, "start\n");
1114
1115   crisv10_ready_wait();
1116
1117   /* Start processing of USB traffic. */
1118   *R_USB_COMMAND =
1119     IO_STATE(R_USB_COMMAND, port_sel, nop) |
1120     IO_STATE(R_USB_COMMAND, port_cmd, reset) |
1121     IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
1122
1123   nop();
1124
1125   hcd->state = HC_STATE_RUNNING;
1126
1127   DBFEXIT;
1128   return 0;
1129 }
1130
1131 /* stop host controller */
1132 static void crisv10_hcd_stop(struct usb_hcd *hcd)
1133 {
1134   DBFENTER;
1135   hcd_dbg(hcd, "stop\n");
1136   crisv10_hcd_reset(hcd);
1137   DBFEXIT;
1138 }
1139
1140 /* return the current frame number */
1141 static int crisv10_hcd_get_frame(struct usb_hcd *hcd)
1142 {
1143   DBFENTER;
1144   DBFEXIT;
1145   return (*R_USB_FM_NUMBER & 0x7ff);
1146 }
1147
1148 #ifdef  CONFIG_USB_OTG
1149
1150 static int crisv10_hcd_start_port_reset(struct usb_hcd *hcd, unsigned port)
1151 {
1152   return 0; /* no-op for now */
1153 }
1154
1155 #endif /* CONFIG_USB_OTG */
1156
1157
1158 /******************************************************************/
1159 /* Root Hub functions                                             */
1160 /******************************************************************/
1161
1162 /* root hub status */
1163 static const struct usb_hub_status rh_hub_status =
1164   {
1165     .wHubStatus =               0,
1166     .wHubChange =               0,
1167   };
1168
1169 /* root hub descriptor */
1170 static const u8 rh_hub_descr[] =
1171   {
1172     0x09,                       /* bDescLength         */
1173     0x29,                       /* bDescriptorType     */
1174     USB_ROOT_HUB_PORTS,         /* bNbrPorts           */
1175     0x00,                       /* wHubCharacteristics */
1176     0x00,
1177     0x01,                       /* bPwrOn2pwrGood      */
1178     0x00,                       /* bHubContrCurrent    */
1179     0x00,                       /* DeviceRemovable     */
1180     0xff                        /* PortPwrCtrlMask     */
1181   };
1182
1183 /* Actual holder of root hub status*/
1184 struct crisv10_rh rh;
1185
1186 /* Initialize root hub data structures (called from dvdrv_hcd_probe()) */
1187 int rh_init(void) {
1188   int i;
1189   /* Reset port status flags */
1190   for (i = 0; i < USB_ROOT_HUB_PORTS; i++) {
1191     rh.wPortChange[i] = 0;
1192     rh.wPortStatusPrev[i] = 0;
1193   }
1194   return 0;
1195 }
1196
1197 #define RH_FEAT_MASK ((1<<USB_PORT_FEAT_CONNECTION)|\
1198                       (1<<USB_PORT_FEAT_ENABLE)|\
1199                       (1<<USB_PORT_FEAT_SUSPEND)|\
1200                       (1<<USB_PORT_FEAT_RESET))
1201
1202 /* Handle port status change interrupt (called from bottom part interrupt) */
1203 void rh_port_status_change(__u16 port_reg[]) {
1204   int i;
1205   __u16 wChange;
1206
1207   for(i = 0; i < USB_ROOT_HUB_PORTS; i++) {
1208     /* Xor out changes since last read, masked for important flags */
1209     wChange = (port_reg[i] & RH_FEAT_MASK) ^ rh.wPortStatusPrev[i];
1210     /* Or changes together with (if any) saved changes */
1211     rh.wPortChange[i] |= wChange;
1212     /* Save new status */
1213     rh.wPortStatusPrev[i] = port_reg[i];
1214
1215     if(wChange) {
1216       rh_dbg("Interrupt port_status change port%d: %s  Current-status:%s\n", i+1,
1217              port_status_to_str(wChange),
1218              port_status_to_str(port_reg[i]));
1219     }
1220   }
1221 }
1222
1223 /* Construct port status change bitmap for the root hub */
1224 static int rh_status_data_request(struct usb_hcd *hcd, char *buf)
1225 {
1226   struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
1227   unsigned int i;
1228
1229   DBFENTER;
1230   /*
1231    * corresponds to hub status change EP (USB 2.0 spec section 11.13.4)
1232    * return bitmap indicating ports with status change
1233    */
1234   *buf = 0;
1235   spin_lock(&crisv10_hcd->lock);
1236   for (i = 1; i <= crisv10_hcd->num_ports; i++) {
1237     if (rh.wPortChange[map_port(i)]) {
1238       *buf |= (1 << i);
1239       rh_dbg("rh_status_data_request, change on port %d: %s  Current Status: %s\n", i,
1240              port_status_to_str(rh.wPortChange[map_port(i)]),
1241              port_status_to_str(rh.wPortStatusPrev[map_port(i)]));
1242     }
1243   }
1244   spin_unlock(&crisv10_hcd->lock);
1245   DBFEXIT;
1246   return *buf == 0 ? 0 : 1;
1247 }
1248
1249 /* Handle a control request for the root hub (called from hcd_driver) */
1250 static int rh_control_request(struct usb_hcd *hcd,
1251                               u16 typeReq,
1252                               u16 wValue,
1253                               u16 wIndex,
1254                               char *buf,
1255                               u16 wLength) {
1256
1257   struct crisv10_hcd *crisv10_hcd = hcd_to_crisv10_hcd(hcd);
1258   int retval = 0;
1259   int len;
1260   DBFENTER;
1261
1262   switch (typeReq) {
1263   case GetHubDescriptor:
1264     rh_dbg("GetHubDescriptor\n");
1265     len = min_t(unsigned int, sizeof rh_hub_descr, wLength);
1266     memcpy(buf, rh_hub_descr, len);
1267     buf[2] = crisv10_hcd->num_ports;
1268     break;
1269   case GetHubStatus:
1270     rh_dbg("GetHubStatus\n");
1271     len = min_t(unsigned int, sizeof rh_hub_status, wLength);
1272     memcpy(buf, &rh_hub_status, len);
1273     break;
1274   case GetPortStatus:
1275     if (!wIndex || wIndex > crisv10_hcd->num_ports)
1276       goto error;
1277     rh_dbg("GetportStatus, port:%d change:%s  status:%s\n", wIndex,
1278            port_status_to_str(rh.wPortChange[map_port(wIndex)]),
1279            port_status_to_str(rh.wPortStatusPrev[map_port(wIndex)]));
1280     *(u16 *) buf = cpu_to_le16(rh.wPortStatusPrev[map_port(wIndex)]);
1281     *(u16 *) (buf + 2) = cpu_to_le16(rh.wPortChange[map_port(wIndex)]);
1282     break;
1283   case SetHubFeature:
1284     rh_dbg("SetHubFeature\n");
1285   case ClearHubFeature:
1286     rh_dbg("ClearHubFeature\n");
1287     switch (wValue) {
1288     case C_HUB_OVER_CURRENT:
1289     case C_HUB_LOCAL_POWER:
1290       rh_warn("Not implemented hub request:%d \n", typeReq);
1291       /* not implemented */
1292       break;
1293     default:
1294       goto error;
1295     }
1296     break;
1297   case SetPortFeature:
1298     if (!wIndex || wIndex > crisv10_hcd->num_ports)
1299       goto error;
1300     if(rh_set_port_feature(map_port(wIndex), wValue))
1301       goto error;
1302     break;
1303   case ClearPortFeature:
1304     if (!wIndex || wIndex > crisv10_hcd->num_ports)
1305       goto error;
1306     if(rh_clear_port_feature(map_port(wIndex), wValue))
1307       goto error;
1308     break;
1309   default:
1310     rh_warn("Unknown hub request: %d\n", typeReq);
1311   error:
1312     retval = -EPIPE;
1313   }
1314   DBFEXIT;
1315   return retval;
1316 }
1317
1318 int rh_set_port_feature(__u8 bPort, __u16 wFeature) {
1319   __u8 bUsbCommand = 0;
1320   __u8 reset_cnt;
1321   switch(wFeature) {
1322   case USB_PORT_FEAT_RESET:
1323     rh_dbg("SetPortFeature: reset\n");
1324
1325     if (rh.wPortStatusPrev[bPort] &
1326         IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes))
1327     {
1328       __u8 restart_controller = 0;
1329
1330       if ( (rh.wPortStatusPrev[0] &
1331             IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)) &&
1332            (rh.wPortStatusPrev[1] &
1333             IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, yes)) )
1334       {
1335         /* Both ports is enabled. The USB controller will not change state. */
1336         restart_controller = 0;
1337       }
1338       else
1339       {
1340         /* Only ports is enabled. The USB controller will change state and
1341            must be restarted. */
1342         restart_controller = 1;
1343       }
1344       /*
1345         In ETRAX 100LX it's not possible to reset an enabled root hub port.
1346         The workaround is to disable and enable the port before resetting it.
1347         Disabling the port can, if both ports are disabled at once, cause the
1348         USB controller to change state to HOST_MODE state.
1349         The USB controller state transition causes a lot of unwanted
1350         interrupts that must be avoided.
1351         Disabling the USB controller status and port status interrupts before
1352         disabling/resetting the port stops these interrupts.
1353
1354         These actions are performed:
1355         1. Disable USB controller status and port status interrupts.
1356         2. Disable the port
1357         3. Wait for the port to be disabled.
1358         4. Enable the port.
1359         5. Wait for the port to be enabled.
1360         6. Reset the port.
1361         7. Wait for for the reset to end.
1362         8. Wait for the USB controller entering started state.
1363         9. Order the USB controller to running state.
1364         10. Wait for the USB controller reaching running state.
1365         11. Clear all interrupts generated during the disable/enable/reset
1366             procedure.
1367         12. Enable the USB controller status and port status interrupts.
1368       */
1369
1370       /* 1. Disable USB controller status and USB port status interrupts. */
1371       *R_USB_IRQ_MASK_CLR = IO_STATE(R_USB_IRQ_MASK_CLR, ctl_status, clr);
1372       __asm__ __volatile__ ("  nop");
1373       *R_USB_IRQ_MASK_CLR = IO_STATE(R_USB_IRQ_MASK_CLR, port_status, clr);
1374       __asm__ __volatile__ ("  nop");
1375
1376       {
1377
1378         /* Since an root hub port reset shall be 50 ms and the ETRAX 100LX
1379            root hub port reset is 10 ms we must perform 5 port resets to
1380            achieve a proper root hub port reset. */
1381         for (reset_cnt = 0; reset_cnt < 5; reset_cnt ++)
1382         {
1383           rh_dbg("Disable Port %d\n", bPort + 1);
1384
1385           /* 2. Disable the port*/
1386           if (bPort == 0)
1387           {
1388             *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
1389           }
1390           else
1391           {
1392             *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, yes);
1393           }
1394
1395           /* 3. Wait for the port to be disabled. */
1396           while ( (bPort == 0) ?
1397                   *R_USB_RH_PORT_STATUS_1 &
1398                     IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes) :
1399                   *R_USB_RH_PORT_STATUS_2 &
1400                     IO_STATE(R_USB_RH_PORT_STATUS_2, enabled, yes) ) {}
1401
1402           rh_dbg("Port %d is disabled. Enable it!\n", bPort + 1);
1403
1404           /* 4. Enable the port. */
1405           if (bPort == 0)
1406           {
1407             *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
1408           }
1409           else
1410           {
1411             *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no);
1412           }
1413
1414           /* 5. Wait for the port to be enabled again.  */
1415           while (!( (bPort == 0) ?
1416                     *R_USB_RH_PORT_STATUS_1 &
1417                       IO_STATE(R_USB_RH_PORT_STATUS_1, connected, yes) :
1418                     *R_USB_RH_PORT_STATUS_2 &
1419                       IO_STATE(R_USB_RH_PORT_STATUS_2, connected, yes) ) ) {}
1420
1421           rh_dbg("Port %d is enabled.\n", bPort + 1);
1422
1423           /* 6. Reset the port */
1424           crisv10_ready_wait();
1425           *R_USB_COMMAND =
1426             ( (bPort == 0) ?
1427               IO_STATE(R_USB_COMMAND, port_sel, port1):
1428               IO_STATE(R_USB_COMMAND, port_sel, port2) ) |
1429             IO_STATE(R_USB_COMMAND, port_cmd, reset) |
1430             IO_STATE(R_USB_COMMAND, busy,     no) |
1431             IO_STATE(R_USB_COMMAND, ctrl_cmd, nop);
1432           rh_dbg("Port %d is resetting.\n", bPort + 1);
1433
1434           /* 7. The USB specification says that we should wait for at least
1435              10ms for device recover */
1436           udelay(10500); /* 10,5ms blocking wait */
1437
1438           crisv10_ready_wait();
1439         }
1440       }
1441
1442
1443       /* Check if the USB controller needs to be restarted. */
1444       if (restart_controller)
1445       {
1446         /* 8. Wait for the USB controller entering started state. */
1447         while (!(*R_USB_STATUS & IO_STATE(R_USB_STATUS, started, yes))) {}
1448
1449         /* 9. Order the USB controller to running state. */
1450         crisv10_ready_wait();
1451         *R_USB_COMMAND =
1452           IO_STATE(R_USB_COMMAND, port_sel, nop) |
1453           IO_STATE(R_USB_COMMAND, port_cmd, reset) |
1454           IO_STATE(R_USB_COMMAND, busy,     no) |
1455           IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
1456
1457         /* 10. Wait for the USB controller reaching running state. */
1458         while (!(*R_USB_STATUS & IO_STATE(R_USB_STATUS, running, yes))) {}
1459       }
1460
1461       /* 11. Clear any controller or port satus interrupts before enabling
1462              the interrupts. */
1463       {
1464         u16 dummy;
1465
1466         /* Clear the port status interrupt of the reset port. */
1467         if (bPort == 0)
1468         {
1469           rh_dbg("Clearing port 1 interrupts\n");
1470           dummy = *R_USB_RH_PORT_STATUS_1;
1471         }
1472         else
1473         {
1474           rh_dbg("Clearing port 2 interrupts\n");
1475           dummy = *R_USB_RH_PORT_STATUS_2;
1476         }
1477
1478         if (restart_controller)
1479         {
1480           /* The USB controller is restarted. Clear all interupts. */
1481           rh_dbg("Clearing all interrupts\n");
1482           dummy = *R_USB_STATUS;
1483           dummy = *R_USB_RH_PORT_STATUS_1;
1484           dummy = *R_USB_RH_PORT_STATUS_2;
1485         }
1486       }
1487
1488       /* 12. Enable USB controller status and USB port status interrupts.  */
1489       *R_USB_IRQ_MASK_SET = IO_STATE(R_USB_IRQ_MASK_SET, ctl_status, set);
1490       __asm__ __volatile__ ("  nop");
1491       *R_USB_IRQ_MASK_SET = IO_STATE(R_USB_IRQ_MASK_SET, port_status, set);
1492       __asm__ __volatile__ ("  nop");
1493
1494     }
1495     else
1496     {
1497
1498       bUsbCommand |= IO_STATE(R_USB_COMMAND, port_cmd, reset);
1499       /* Select which port via the port_sel field */
1500       bUsbCommand |= IO_FIELD(R_USB_COMMAND, port_sel, bPort+1);
1501
1502       /* Make sure the controller isn't busy. */
1503       crisv10_ready_wait();
1504       /* Send out the actual command to the USB controller */
1505       *R_USB_COMMAND = bUsbCommand;
1506
1507       /* Wait a while for controller to first become started after port reset */
1508       udelay(12000); /* 12ms blocking wait */
1509
1510       /* Make sure the controller isn't busy. */
1511       crisv10_ready_wait();
1512
1513       /* If all enabled ports were disabled the host controller goes down into
1514          started mode, so we need to bring it back into the running state.
1515          (This is safe even if it's already in the running state.) */
1516       *R_USB_COMMAND =
1517         IO_STATE(R_USB_COMMAND, port_sel, nop) |
1518         IO_STATE(R_USB_COMMAND, port_cmd, reset) |
1519         IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
1520     }
1521
1522     break;
1523   case USB_PORT_FEAT_SUSPEND:
1524     rh_dbg("SetPortFeature: suspend\n");
1525     bUsbCommand |= IO_STATE(R_USB_COMMAND, port_cmd, suspend);
1526     goto set;
1527     break;
1528   case USB_PORT_FEAT_POWER:
1529     rh_dbg("SetPortFeature: power\n");
1530     break;
1531   case USB_PORT_FEAT_C_CONNECTION:
1532     rh_dbg("SetPortFeature: c_connection\n");
1533     break;
1534   case USB_PORT_FEAT_C_RESET:
1535     rh_dbg("SetPortFeature: c_reset\n");
1536     break;
1537   case USB_PORT_FEAT_C_OVER_CURRENT:
1538     rh_dbg("SetPortFeature: c_over_current\n");
1539     break;
1540
1541   set:
1542     /* Select which port via the port_sel field */
1543     bUsbCommand |= IO_FIELD(R_USB_COMMAND, port_sel, bPort+1);
1544
1545     /* Make sure the controller isn't busy. */
1546     crisv10_ready_wait();
1547     /* Send out the actual command to the USB controller */
1548     *R_USB_COMMAND = bUsbCommand;
1549     break;
1550   default:
1551     rh_dbg("SetPortFeature: unknown feature\n");
1552     return -1;
1553   }
1554   return 0;
1555 }
1556
1557 int rh_clear_port_feature(__u8 bPort, __u16 wFeature) {
1558   switch(wFeature) {
1559   case USB_PORT_FEAT_ENABLE:
1560     rh_dbg("ClearPortFeature: enable\n");
1561     rh_disable_port(bPort);
1562     break;
1563   case USB_PORT_FEAT_SUSPEND:
1564     rh_dbg("ClearPortFeature: suspend\n");
1565     break;
1566   case USB_PORT_FEAT_POWER:
1567     rh_dbg("ClearPortFeature: power\n");
1568     break;
1569
1570   case USB_PORT_FEAT_C_ENABLE:
1571     rh_dbg("ClearPortFeature: c_enable\n");
1572     goto clear;
1573   case USB_PORT_FEAT_C_SUSPEND:
1574     rh_dbg("ClearPortFeature: c_suspend\n");
1575     goto clear;
1576   case USB_PORT_FEAT_C_CONNECTION:
1577     rh_dbg("ClearPortFeature: c_connection\n");
1578     goto clear;
1579   case USB_PORT_FEAT_C_OVER_CURRENT:
1580     rh_dbg("ClearPortFeature: c_over_current\n");
1581     goto clear;
1582   case USB_PORT_FEAT_C_RESET:
1583     rh_dbg("ClearPortFeature: c_reset\n");
1584     goto clear;
1585   clear:
1586     rh.wPortChange[bPort] &= ~(1 << (wFeature - 16));
1587     break;
1588   default:
1589     rh_dbg("ClearPortFeature: unknown feature\n");
1590     return -1;
1591   }
1592   return 0;
1593 }
1594
1595
1596 #ifdef  CONFIG_PM
1597 /* Handle a suspend request for the root hub (called from hcd_driver) */
1598 static int rh_suspend_request(struct usb_hcd *hcd)
1599 {
1600   return 0; /* no-op for now */
1601 }
1602
1603 /* Handle a resume request for the root hub (called from hcd_driver) */
1604 static int rh_resume_request(struct usb_hcd *hcd)
1605 {
1606   return 0; /* no-op for now */
1607 }
1608 #endif /* CONFIG_PM */
1609
1610
1611
1612 /* Wrapper function for workaround port disable registers in USB controller  */
1613 static void rh_disable_port(unsigned int port) {
1614   volatile int timeout = 10000;
1615   volatile char* usb_portx_disable;
1616   switch(port) {
1617   case 0:
1618     usb_portx_disable = R_USB_PORT1_DISABLE;
1619     break;
1620   case 1:
1621     usb_portx_disable = R_USB_PORT2_DISABLE;
1622     break;
1623   default:
1624     /* Invalid port index */
1625     return;
1626   }
1627   /* Set disable flag in special register  */
1628   *usb_portx_disable = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
1629   /* Wait until not enabled anymore */
1630   while((rh.wPortStatusPrev[port] &
1631         IO_STATE(R_USB_RH_PORT_STATUS_1, enabled, yes)) &&
1632         (timeout-- > 0));
1633   if(timeout == 0) {
1634     warn("Timeout while waiting for port %d to become disabled\n", port);
1635   }
1636   /* clear disable flag in special register  */
1637   *usb_portx_disable = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
1638   rh_info("Physical port %d disabled\n", port+1);
1639 }
1640
1641
1642 /******************************************************************/
1643 /* Transfer Controller (TC) functions                             */
1644 /******************************************************************/
1645
1646 /* FIXME: Should RX_BUF_SIZE be a config option, or maybe we should adjust it
1647    dynamically?
1648    To adjust it dynamically we would have to get an interrupt when we reach
1649    the end of the rx descriptor list, or when we get close to the end, and
1650    then allocate more descriptors. */
1651 #define NBR_OF_RX_DESC     512
1652 #define RX_DESC_BUF_SIZE   1024
1653 #define RX_BUF_SIZE        (NBR_OF_RX_DESC * RX_DESC_BUF_SIZE)
1654
1655
1656 /* Local variables for Transfer Controller */
1657 /* --------------------------------------- */
1658
1659 /* This is a circular (double-linked) list of the active urbs for each epid.
1660    The head is never removed, and new urbs are linked onto the list as
1661    urb_entry_t elements. Don't reference urb_list directly; use the wrapper
1662    functions instead (which includes spin_locks) */
1663 static struct list_head urb_list[NBR_OF_EPIDS];
1664
1665 /* Read about the need and usage of this lock in submit_ctrl_urb. */
1666 /* Lock for URB lists for each EPID */
1667 static spinlock_t urb_list_lock;
1668
1669 /* Lock for EPID array register (R_USB_EPT_x) in Etrax */
1670 static spinlock_t etrax_epid_lock;
1671
1672 /* Lock for dma8 sub0 handling */
1673 static spinlock_t etrax_dma8_sub0_lock;
1674
1675 /* DMA IN cache bug. Align the DMA IN buffers to 32 bytes, i.e. a cache line.
1676    Since RX_DESC_BUF_SIZE is 1024 is a multiple of 32, all rx buffers will be
1677    cache aligned. */
1678 static volatile unsigned char RxBuf[RX_BUF_SIZE] __attribute__ ((aligned (32)));
1679 static volatile struct USB_IN_Desc RxDescList[NBR_OF_RX_DESC] __attribute__ ((aligned (4)));
1680
1681 /* Pointers into RxDescList. */
1682 static volatile struct USB_IN_Desc *myNextRxDesc;
1683 static volatile struct USB_IN_Desc *myLastRxDesc;
1684
1685 /* A zout transfer makes a memory access at the address of its buf pointer,
1686    which means that setting this buf pointer to 0 will cause an access to the
1687    flash. In addition to this, setting sw_len to 0 results in a 16/32 bytes
1688    (depending on DMA burst size) transfer.
1689    Instead, we set it to 1, and point it to this buffer. */
1690 static int zout_buffer[4] __attribute__ ((aligned (4)));
1691
1692 /* Cache for allocating new EP and SB descriptors. */
1693 static struct kmem_cache *usb_desc_cache;
1694
1695 /* Cache for the data allocated in the isoc descr top half. */
1696 static struct kmem_cache *isoc_compl_cache;
1697
1698 /* Cache for the data allocated when delayed finishing of URBs */
1699 static struct kmem_cache *later_data_cache;
1700
1701
1702 /* Counter to keep track of how many Isoc EP we have sat up. Used to enable
1703    and disable iso_eof interrupt. We only need these interrupts when we have
1704    Isoc data endpoints (consumes CPU cycles).
1705    FIXME: This could be more fine granular, so this interrupt is only enabled
1706    when we have a In Isoc URB not URB_ISO_ASAP flaged queued. */
1707 static int isoc_epid_counter;
1708
1709 /* Protecting wrapper functions for R_USB_EPT_x */
1710 /* -------------------------------------------- */
1711 static inline void etrax_epid_set(__u8 index, __u32 data) {
1712   unsigned long flags;
1713   spin_lock_irqsave(&etrax_epid_lock, flags);
1714   *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
1715   nop();
1716   *R_USB_EPT_DATA = data;
1717   spin_unlock_irqrestore(&etrax_epid_lock, flags);
1718 }
1719
1720 static inline void etrax_epid_clear_error(__u8 index) {
1721   unsigned long flags;
1722   spin_lock_irqsave(&etrax_epid_lock, flags);
1723   *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
1724   nop();
1725   *R_USB_EPT_DATA &=
1726     ~(IO_MASK(R_USB_EPT_DATA, error_count_in) |
1727       IO_MASK(R_USB_EPT_DATA, error_count_out) |
1728       IO_MASK(R_USB_EPT_DATA, error_code));
1729   spin_unlock_irqrestore(&etrax_epid_lock, flags);
1730 }
1731
1732 static inline void etrax_epid_set_toggle(__u8 index, __u8 dirout,
1733                                              __u8 toggle) {
1734   unsigned long flags;
1735   spin_lock_irqsave(&etrax_epid_lock, flags);
1736   *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
1737   nop();
1738   if(dirout) {
1739     *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_out);
1740     *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_out, toggle);
1741   } else {
1742     *R_USB_EPT_DATA &= ~IO_MASK(R_USB_EPT_DATA, t_in);
1743     *R_USB_EPT_DATA |= IO_FIELD(R_USB_EPT_DATA, t_in, toggle);
1744   }
1745   spin_unlock_irqrestore(&etrax_epid_lock, flags);
1746 }
1747
1748 static inline __u8 etrax_epid_get_toggle(__u8 index, __u8 dirout) {
1749   unsigned long flags;
1750   __u8 toggle;
1751   spin_lock_irqsave(&etrax_epid_lock, flags);
1752   *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
1753   nop();
1754   if (dirout) {
1755     toggle = IO_EXTRACT(R_USB_EPT_DATA, t_out, *R_USB_EPT_DATA);
1756   } else {
1757     toggle = IO_EXTRACT(R_USB_EPT_DATA, t_in, *R_USB_EPT_DATA);
1758   }
1759   spin_unlock_irqrestore(&etrax_epid_lock, flags);
1760   return toggle;
1761 }
1762
1763
1764 static inline __u32 etrax_epid_get(__u8 index) {
1765   unsigned long flags;
1766   __u32 data;
1767   spin_lock_irqsave(&etrax_epid_lock, flags);
1768   *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, index);
1769   nop();
1770   data = *R_USB_EPT_DATA;
1771   spin_unlock_irqrestore(&etrax_epid_lock, flags);
1772   return data;
1773 }
1774
1775
1776
1777
1778 /* Main functions for Transfer Controller */
1779 /* -------------------------------------- */
1780
1781 /* Init structs, memories and lists used by Transfer Controller */
1782 int tc_init(struct usb_hcd *hcd) {
1783   int i;
1784   /* Clear software state info for all epids */
1785   memset(epid_state, 0, sizeof(struct etrax_epid) * NBR_OF_EPIDS);
1786
1787   /* Set Invalid and Dummy as being in use and disabled */
1788   epid_state[INVALID_EPID].inuse = 1;
1789   epid_state[DUMMY_EPID].inuse = 1;
1790   epid_state[INVALID_EPID].disabled = 1;
1791   epid_state[DUMMY_EPID].disabled = 1;
1792
1793   /* Clear counter for how many Isoc epids we have sat up */
1794   isoc_epid_counter = 0;
1795
1796   /* Initialize the urb list by initiating a head for each list.
1797      Also reset list hodling active URB for each epid */
1798   for (i = 0; i < NBR_OF_EPIDS; i++) {
1799     INIT_LIST_HEAD(&urb_list[i]);
1800     activeUrbList[i] = NULL;
1801   }
1802
1803   /* Init lock for URB lists */
1804   spin_lock_init(&urb_list_lock);
1805   /* Init lock for Etrax R_USB_EPT register */
1806   spin_lock_init(&etrax_epid_lock);
1807   /* Init lock for Etrax dma8 sub0 handling */
1808   spin_lock_init(&etrax_dma8_sub0_lock);
1809
1810   /* We use kmem_cache_* to make sure that all DMA desc. are dword aligned */
1811
1812   /* Note that we specify sizeof(struct USB_EP_Desc) as the size, but also
1813      allocate SB descriptors from this cache. This is ok since
1814      sizeof(struct USB_EP_Desc) == sizeof(struct USB_SB_Desc). */
1815   usb_desc_cache = kmem_cache_create("usb_desc_cache",
1816                                      sizeof(struct USB_EP_Desc), 0,
1817                                      SLAB_HWCACHE_ALIGN, 0);
1818   if(usb_desc_cache == NULL) {
1819     return -ENOMEM;
1820   }
1821
1822   /* Create slab cache for speedy allocation of memory for isoc bottom-half
1823      interrupt handling */
1824   isoc_compl_cache =
1825     kmem_cache_create("isoc_compl_cache",
1826                       sizeof(struct crisv10_isoc_complete_data),
1827                       0, SLAB_HWCACHE_ALIGN, 0);
1828   if(isoc_compl_cache == NULL) {
1829     return -ENOMEM;
1830   }
1831
1832   /* Create slab cache for speedy allocation of memory for later URB finish
1833      struct */
1834   later_data_cache =
1835     kmem_cache_create("later_data_cache",
1836                       sizeof(struct urb_later_data),
1837                       0, SLAB_HWCACHE_ALIGN, 0);
1838   if(later_data_cache == NULL) {
1839     return -ENOMEM;
1840   }
1841
1842
1843   /* Initiate the bulk start timer. */
1844   init_timer(&bulk_start_timer);
1845   bulk_start_timer.expires = jiffies + BULK_START_TIMER_INTERVAL;
1846   bulk_start_timer.function = tc_bulk_start_timer_func;
1847   add_timer(&bulk_start_timer);
1848
1849
1850   /* Initiate the bulk eot timer. */
1851   init_timer(&bulk_eot_timer);
1852   bulk_eot_timer.expires = jiffies + BULK_EOT_TIMER_INTERVAL;
1853   bulk_eot_timer.function = tc_bulk_eot_timer_func;
1854   bulk_eot_timer.data = (unsigned long)hcd;
1855   add_timer(&bulk_eot_timer);
1856
1857   return 0;
1858 }
1859
1860 /* Uninitialize all resources used by Transfer Controller */
1861 void tc_destroy(void) {
1862
1863   /* Destroy all slab cache */
1864   kmem_cache_destroy(usb_desc_cache);
1865   kmem_cache_destroy(isoc_compl_cache);
1866   kmem_cache_destroy(later_data_cache);
1867
1868   /* Remove timers */
1869   del_timer(&bulk_start_timer);
1870   del_timer(&bulk_eot_timer);
1871 }
1872
1873 static void restart_dma8_sub0(void) {
1874   unsigned long flags;
1875   spin_lock_irqsave(&etrax_dma8_sub0_lock, flags);
1876   /* Verify that the dma is not running */
1877   if ((*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd)) == 0) {
1878     struct USB_EP_Desc *ep = (struct USB_EP_Desc *)phys_to_virt(*R_DMA_CH8_SUB0_EP);
1879     while (DUMMY_EPID == IO_EXTRACT(USB_EP_command, epid, ep->command)) {
1880       ep = (struct USB_EP_Desc *)phys_to_virt(ep->next);
1881     }
1882     /* Advance the DMA to the next EP descriptor that is not a DUMMY_EPID. */
1883     *R_DMA_CH8_SUB0_EP = virt_to_phys(ep);
1884     /* Restart the DMA */
1885     *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start);
1886   }
1887   spin_unlock_irqrestore(&etrax_dma8_sub0_lock, flags);
1888 }
1889
1890 /* queue an URB with the transfer controller (called from hcd_driver) */
1891 static int tc_urb_enqueue(struct usb_hcd *hcd,
1892                           struct urb *urb,
1893                           gfp_t mem_flags) {
1894   int epid;
1895   int retval;
1896   int bustime = 0;
1897   int maxpacket;
1898   unsigned long flags;
1899   struct crisv10_urb_priv *urb_priv;
1900   struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
1901   DBFENTER;
1902
1903   if(!(crisv10_hcd->running)) {
1904     /* The USB Controller is not running, probably because no device is
1905        attached. No idea to enqueue URBs then */
1906     tc_warn("Rejected enqueueing of URB:0x%x because no dev attached\n",
1907             (unsigned int)urb);
1908     return -ENOENT;
1909   }
1910
1911   maxpacket = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
1912   /* Special case check for In Isoc transfers. Specification states that each
1913      In Isoc transfer consists of one packet and therefore it should fit into
1914      the transfer-buffer of an URB.
1915      We do the check here to be sure (an invalid scenario can be produced with
1916      parameters to the usbtest suite) */
1917   if(usb_pipeisoc(urb->pipe) && usb_pipein(urb->pipe) &&
1918      (urb->transfer_buffer_length < maxpacket)) {
1919     tc_err("Submit In Isoc URB with buffer length:%d to pipe with maxpacketlen: %d\n", urb->transfer_buffer_length, maxpacket);
1920     return -EMSGSIZE;
1921   }
1922
1923   /* Check if there is a epid for URBs destination, if not this function
1924      set up one. */
1925   epid = tc_setup_epid(urb->ep, urb, mem_flags);
1926   if (epid < 0) {
1927     tc_err("Failed setup epid:%d for URB:0x%x\n", epid, (unsigned int)urb);
1928     DBFEXIT;
1929     return -ENOMEM;
1930   }
1931
1932   if(urb == activeUrbList[epid]) {
1933     tc_err("Resubmition of allready active URB:0x%x\n", (unsigned int)urb);
1934     return -ENXIO;
1935   }
1936
1937   if(urb_list_entry(urb, epid)) {
1938     tc_err("Resubmition of allready queued URB:0x%x\n", (unsigned int)urb);
1939     return -ENXIO;
1940   }
1941
1942   /* If we actively have flaged endpoint as disabled then refuse submition */
1943   if(epid_state[epid].disabled) {
1944     return -ENOENT;
1945   }
1946
1947   /* Allocate and init HC-private data for URB */
1948   if(urb_priv_create(hcd, urb, epid, mem_flags) != 0) {
1949     DBFEXIT;
1950     return -ENOMEM;
1951   }
1952   urb_priv = urb->hcpriv;
1953
1954   /* Check if there is enough bandwidth for periodic transfer  */
1955   if(usb_pipeint(urb->pipe) || usb_pipeisoc(urb->pipe)) {
1956     /* only check (and later claim) if not already claimed */
1957     if (urb_priv->bandwidth == 0) {
1958       bustime = crisv10_usb_check_bandwidth(urb->dev, urb);
1959       if (bustime < 0) {
1960         tc_err("Not enough periodic bandwidth\n");
1961         urb_priv_free(hcd, urb);
1962         DBFEXIT;
1963         return -ENOSPC;
1964       }
1965     }
1966   }
1967
1968   tc_dbg("Enqueue URB:0x%x[%d] epid:%d (%s) bufflen:%d\n",
1969          (unsigned int)urb, urb_priv->urb_num, epid,
1970          pipe_to_str(urb->pipe), urb->transfer_buffer_length);
1971
1972   /* Create and link SBs required for this URB */
1973   retval = create_sb_for_urb(urb, mem_flags);
1974   if(retval != 0) {
1975     tc_err("Failed to create SBs for URB:0x%x[%d]\n", (unsigned int)urb,
1976            urb_priv->urb_num);
1977     urb_priv_free(hcd, urb);
1978     DBFEXIT;
1979     return retval;
1980   }
1981
1982   /* Init intr EP pool if this URB is a INTR transfer. This pool is later
1983      used when inserting EPs in the TxIntrEPList. We do the alloc here
1984      so we can't run out of memory later */
1985   if(usb_pipeint(urb->pipe)) {
1986     retval = init_intr_urb(urb, mem_flags);
1987     if(retval != 0) {
1988       tc_warn("Failed to init Intr URB\n");
1989       urb_priv_free(hcd, urb);
1990       DBFEXIT;
1991       return retval;
1992     }
1993   }
1994
1995   /* Disable other access when inserting USB */
1996   local_irq_save(flags);
1997
1998   /* Claim bandwidth, if needed */
1999   if(bustime) {
2000     crisv10_usb_claim_bandwidth(urb->dev,
2001                                 urb,
2002                                 bustime,
2003                                 (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS));
2004   }
2005
2006   /* Add URB to EP queue */
2007   urb_list_add(urb, epid, mem_flags);
2008
2009   if(usb_pipeisoc(urb->pipe)) {
2010     /* Special processing of Isoc URBs. */
2011     tc_dma_process_isoc_urb(urb);
2012   } else {
2013     /* Process EP queue for rest of the URB types (Bulk, Ctrl, Intr) */
2014     tc_dma_process_queue(epid);
2015   }
2016
2017   local_irq_restore(flags);
2018
2019   DBFEXIT;
2020   return 0;
2021 }
2022
2023 /* remove an URB from the transfer controller queues (called from hcd_driver)*/
2024 static int tc_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) {
2025   struct crisv10_urb_priv *urb_priv;
2026   unsigned long flags;
2027   int epid;
2028
2029   DBFENTER;
2030   /* Disable interrupts here since a descriptor interrupt for the isoc epid
2031      will modify the sb list.  This could possibly be done more granular, but
2032      urb_dequeue should not be used frequently anyway.
2033   */
2034   local_irq_save(flags);
2035
2036   urb->status = status;
2037   urb_priv = urb->hcpriv;
2038
2039   if (!urb_priv) {
2040     /* This happens if a device driver calls unlink on an urb that
2041        was never submitted (lazy driver) or if the urb was completed
2042        while dequeue was being called. */
2043     tc_warn("Dequeing of not enqueued URB:0x%x\n", (unsigned int)urb);
2044     local_irq_restore(flags);
2045     return 0;
2046   }
2047   epid = urb_priv->epid;
2048
2049   tc_warn("Dequeing %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
2050           (urb == activeUrbList[epid]) ? "active" : "queued",
2051           (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
2052           str_type(urb->pipe), epid, urb->status,
2053           (urb_priv->later_data) ? "later-sched" : "");
2054
2055   /* For Bulk, Ctrl and Intr are only one URB active at a time. So any URB
2056      that isn't active can be dequeued by just removing it from the queue */
2057   if(usb_pipebulk(urb->pipe) || usb_pipecontrol(urb->pipe) ||
2058      usb_pipeint(urb->pipe)) {
2059
2060     /* Check if URB haven't gone further than the queue */
2061     if(urb != activeUrbList[epid]) {
2062       ASSERT(urb_priv->later_data == NULL);
2063       tc_warn("Dequeing URB:0x%x[%d] (%s %s epid:%d) from queue"
2064               " (not active)\n", (unsigned int)urb, urb_priv->urb_num,
2065               str_dir(urb->pipe), str_type(urb->pipe), epid);
2066
2067       /* Finish the URB with error status from USB core */
2068       tc_finish_urb(hcd, urb, urb->status);
2069       local_irq_restore(flags);
2070       return 0;
2071     }
2072   }
2073
2074   /* Set URB status to Unlink for handling when interrupt comes. */
2075   urb_priv->urb_state = UNLINK;
2076
2077   /* Differentiate dequeing of Bulk and Ctrl from Isoc and Intr */
2078   switch(usb_pipetype(urb->pipe)) {
2079   case PIPE_BULK:
2080     /* Check if EP still is enabled */
2081     if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2082       /* The EP was enabled, disable it. */
2083       TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2084     }
2085     /* Kicking dummy list out of the party. */
2086     TxBulkEPList[epid].next = virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
2087     break;
2088   case PIPE_CONTROL:
2089     /* Check if EP still is enabled */
2090     if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2091       /* The EP was enabled, disable it. */
2092       TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2093     }
2094     break;
2095   case PIPE_ISOCHRONOUS:
2096     /* Disabling, busy-wait and unlinking of Isoc SBs will be done in
2097        finish_isoc_urb(). Because there might the case when URB is dequeued
2098        but there are other valid URBs waiting */
2099
2100     /* Check if In Isoc EP still is enabled */
2101     if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2102       /* The EP was enabled, disable it. */
2103       TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2104     }
2105     break;
2106   case PIPE_INTERRUPT:
2107     /* Special care is taken for interrupt URBs. EPs are unlinked in
2108        tc_finish_urb */
2109     break;
2110   default:
2111     break;
2112   }
2113
2114   /* Asynchronous unlink, finish the URB later from scheduled or other
2115      event (data finished, error) */
2116   tc_finish_urb_later(hcd, urb, urb->status);
2117
2118   local_irq_restore(flags);
2119   DBFEXIT;
2120   return 0;
2121 }
2122
2123
2124 static void tc_sync_finish_epid(struct usb_hcd *hcd, int epid) {
2125   volatile int timeout = 10000;
2126   struct urb* urb;
2127   struct crisv10_urb_priv* urb_priv;
2128   unsigned long flags;
2129
2130   volatile struct USB_EP_Desc *first_ep;  /* First EP in the list. */
2131   volatile struct USB_EP_Desc *curr_ep;   /* Current EP, the iterator. */
2132   volatile struct USB_EP_Desc *next_ep;   /* The EP after current. */
2133
2134   int type = epid_state[epid].type;
2135
2136   /* Setting this flag will cause enqueue() to return -ENOENT for new
2137      submitions on this endpoint and finish_urb() wont process queue further */
2138   epid_state[epid].disabled = 1;
2139
2140   switch(type) {
2141   case PIPE_BULK:
2142     /* Check if EP still is enabled */
2143     if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2144       /* The EP was enabled, disable it. */
2145       TxBulkEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2146       tc_warn("sync_finish: Disabling EP for epid:%d\n", epid);
2147
2148       /* Do busy-wait until DMA not using this EP descriptor anymore */
2149       while((*R_DMA_CH8_SUB0_EP ==
2150              virt_to_phys(&TxBulkEPList[epid])) &&
2151             (timeout-- > 0));
2152       if(timeout == 0) {
2153         warn("Timeout while waiting for DMA-TX-Bulk to leave EP for"
2154              " epid:%d\n", epid);
2155       }
2156     }
2157     break;
2158
2159   case PIPE_CONTROL:
2160     /* Check if EP still is enabled */
2161     if (TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2162       /* The EP was enabled, disable it. */
2163       TxCtrlEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2164       tc_warn("sync_finish: Disabling EP for epid:%d\n", epid);
2165
2166       /* Do busy-wait until DMA not using this EP descriptor anymore */
2167       while((*R_DMA_CH8_SUB1_EP ==
2168              virt_to_phys(&TxCtrlEPList[epid])) &&
2169             (timeout-- > 0));
2170       if(timeout == 0) {
2171         warn("Timeout while waiting for DMA-TX-Ctrl to leave EP for"
2172              " epid:%d\n", epid);
2173       }
2174     }
2175     break;
2176
2177   case PIPE_INTERRUPT:
2178     local_irq_save(flags);
2179     /* Disable all Intr EPs belonging to epid */
2180     first_ep = &TxIntrEPList[0];
2181     curr_ep = first_ep;
2182     do {
2183       next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
2184       if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
2185         /* Disable EP */
2186         next_ep->command &= ~IO_MASK(USB_EP_command, enable);
2187       }
2188       curr_ep = phys_to_virt(curr_ep->next);
2189     } while (curr_ep != first_ep);
2190
2191     local_irq_restore(flags);
2192     break;
2193
2194   case PIPE_ISOCHRONOUS:
2195     /* Check if EP still is enabled */
2196     if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2197       tc_warn("sync_finish: Disabling Isoc EP for epid:%d\n", epid);
2198       /* The EP was enabled, disable it. */
2199       TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2200
2201       while((*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid])) &&
2202             (timeout-- > 0));
2203       if(timeout == 0) {
2204         warn("Timeout while waiting for DMA-TX-Isoc to leave EP for"
2205              " epid:%d\n", epid);
2206       }
2207     }
2208     break;
2209   }
2210
2211   local_irq_save(flags);
2212
2213   /* Finish if there is active URB for this endpoint */
2214   if(activeUrbList[epid] != NULL) {
2215     urb = activeUrbList[epid];
2216     urb_priv = urb->hcpriv;
2217     ASSERT(urb_priv);
2218     tc_warn("Sync finish %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
2219             (urb == activeUrbList[epid]) ? "active" : "queued",
2220             (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
2221             str_type(urb->pipe), epid, urb->status,
2222             (urb_priv->later_data) ? "later-sched" : "");
2223
2224     tc_finish_urb(hcd, activeUrbList[epid], -ENOENT);
2225     ASSERT(activeUrbList[epid] == NULL);
2226   }
2227
2228   /* Finish any queued URBs for this endpoint. There won't be any resubmitions
2229      because epid_disabled causes enqueue() to fail for this endpoint */
2230   while((urb = urb_list_first(epid)) != NULL) {
2231     urb_priv = urb->hcpriv;
2232     ASSERT(urb_priv);
2233
2234     tc_warn("Sync finish %s URB:0x%x[%d] (%s %s epid:%d) status:%d %s\n",
2235             (urb == activeUrbList[epid]) ? "active" : "queued",
2236             (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
2237             str_type(urb->pipe), epid, urb->status,
2238             (urb_priv->later_data) ? "later-sched" : "");
2239
2240     tc_finish_urb(hcd, urb, -ENOENT);
2241   }
2242   epid_state[epid].disabled = 0;
2243   local_irq_restore(flags);
2244 }
2245
2246 /* free resources associated with an endpoint (called from hcd_driver) */
2247 static void tc_endpoint_disable(struct usb_hcd *hcd,
2248                                 struct usb_host_endpoint *ep) {
2249   DBFENTER;
2250   /* Only free epid if it has been allocated. We get two endpoint_disable
2251      requests for ctrl endpoints so ignore the second one */
2252   if(ep->hcpriv != NULL) {
2253     struct crisv10_ep_priv *ep_priv = ep->hcpriv;
2254     int epid = ep_priv->epid;
2255     tc_warn("endpoint_disable ep:0x%x ep-priv:0x%x (%s) (epid:%d freed)\n",
2256            (unsigned int)ep, (unsigned int)ep->hcpriv,
2257            endpoint_to_str(&(ep->desc)), epid);
2258
2259     tc_sync_finish_epid(hcd, epid);
2260
2261     ASSERT(activeUrbList[epid] == NULL);
2262     ASSERT(list_empty(&urb_list[epid]));
2263
2264     tc_free_epid(ep);
2265   } else {
2266     tc_dbg("endpoint_disable ep:0x%x ep-priv:0x%x (%s)\n", (unsigned int)ep,
2267            (unsigned int)ep->hcpriv, endpoint_to_str(&(ep->desc)));
2268   }
2269   DBFEXIT;
2270 }
2271
2272 static void tc_finish_urb_later_proc(struct work_struct* work) {
2273   unsigned long flags;
2274   struct urb_later_data* uld;
2275
2276   local_irq_save(flags);
2277   uld = container_of(work, struct urb_later_data, dws.work);
2278   if(uld->urb == NULL) {
2279     late_dbg("Later finish of URB = NULL (allready finished)\n");
2280   } else {
2281     struct crisv10_urb_priv* urb_priv = uld->urb->hcpriv;
2282     ASSERT(urb_priv);
2283     if(urb_priv->urb_num == uld->urb_num) {
2284       late_dbg("Later finish of URB:0x%x[%d]\n", (unsigned int)(uld->urb),
2285                urb_priv->urb_num);
2286       if(uld->status != uld->urb->status) {
2287         errno_dbg("Later-finish URB with status:%d, later-status:%d\n",
2288                   uld->urb->status, uld->status);
2289       }
2290       if(uld != urb_priv->later_data) {
2291         panic("Scheduled uld not same as URBs uld\n");
2292       }
2293       tc_finish_urb(uld->hcd, uld->urb, uld->status);
2294     } else {
2295       late_warn("Ignoring later finish of URB:0x%x[%d]"
2296                 ", urb_num doesn't match current URB:0x%x[%d]",
2297                 (unsigned int)(uld->urb), uld->urb_num,
2298                 (unsigned int)(uld->urb), urb_priv->urb_num);
2299     }
2300   }
2301   local_irq_restore(flags);
2302   kmem_cache_free(later_data_cache, uld);
2303 }
2304
2305 static void tc_finish_urb_later(struct usb_hcd *hcd, struct urb *urb,
2306                                 int status) {
2307   struct crisv10_urb_priv *urb_priv = urb->hcpriv;
2308   struct urb_later_data* uld;
2309
2310   ASSERT(urb_priv);
2311
2312   if(urb_priv->later_data != NULL) {
2313     /* Later-finish allready scheduled for this URB, just update status to
2314        return when finishing later */
2315     errno_dbg("Later-finish schedule change URB status:%d with new"
2316               " status:%d\n", urb_priv->later_data->status, status);
2317
2318     urb_priv->later_data->status = status;
2319     return;
2320   }
2321
2322   uld = kmem_cache_alloc(later_data_cache, GFP_ATOMIC);
2323   ASSERT(uld);
2324
2325   uld->hcd = hcd;
2326   uld->urb = urb;
2327   uld->urb_num = urb_priv->urb_num;
2328   uld->status = status;
2329
2330   INIT_DELAYED_WORK(&uld->dws, tc_finish_urb_later_proc);
2331   urb_priv->later_data = uld;
2332
2333   /* Schedule the finishing of the URB to happen later */
2334   schedule_delayed_work(&uld->dws, LATER_TIMER_DELAY);
2335 }
2336
2337 static void tc_finish_isoc_urb(struct usb_hcd *hcd, struct urb *urb,
2338                                int status);
2339
2340 static void tc_finish_urb(struct usb_hcd *hcd, struct urb *urb, int status) {
2341   struct crisv10_hcd* crisv10_hcd = hcd_to_crisv10_hcd(hcd);
2342   struct crisv10_urb_priv *urb_priv = urb->hcpriv;
2343   int epid;
2344   char toggle;
2345   int urb_num;
2346
2347   DBFENTER;
2348   ASSERT(urb_priv != NULL);
2349   epid = urb_priv->epid;
2350   urb_num = urb_priv->urb_num;
2351
2352   if(urb != activeUrbList[epid]) {
2353     if(urb_list_entry(urb, epid)) {
2354       /* Remove this URB from the list. Only happens when URB are finished
2355          before having been processed (dequeing) */
2356       urb_list_del(urb, epid);
2357     } else {
2358       tc_warn("Finishing of URB:0x%x[%d] neither active or in queue for"
2359               " epid:%d\n", (unsigned int)urb, urb_num, epid);
2360     }
2361   }
2362
2363   /* Cancel any pending later-finish of this URB */
2364   if(urb_priv->later_data) {
2365     urb_priv->later_data->urb = NULL;
2366   }
2367
2368   /* For an IN pipe, we always set the actual length, regardless of whether
2369      there was an error or not (which means the device driver can use the data
2370      if it wants to). */
2371   if(usb_pipein(urb->pipe)) {
2372     urb->actual_length = urb_priv->rx_offset;
2373   } else {
2374     /* Set actual_length for OUT urbs also; the USB mass storage driver seems
2375        to want that. */
2376     if (status == 0 && urb->status == -EINPROGRESS) {
2377       urb->actual_length = urb->transfer_buffer_length;
2378     } else {
2379       /*  We wouldn't know of any partial writes if there was an error. */
2380       urb->actual_length = 0;
2381     }
2382   }
2383
2384
2385   /* URB status mangling */
2386   if(urb->status == -EINPROGRESS) {
2387     /* The USB core hasn't changed the status, let's set our finish status */
2388     urb->status = status;
2389
2390     if ((status == 0) && (urb->transfer_flags & URB_SHORT_NOT_OK) &&
2391         usb_pipein(urb->pipe) &&
2392         (urb->actual_length != urb->transfer_buffer_length)) {
2393       /* URB_SHORT_NOT_OK means that short reads (shorter than the endpoint's
2394          max length) is to be treated as an error. */
2395       errno_dbg("Finishing URB:0x%x[%d] with SHORT_NOT_OK flag and short"
2396                 " data:%d\n", (unsigned int)urb, urb_num,
2397                 urb->actual_length);
2398       urb->status = -EREMOTEIO;
2399     }
2400
2401     if(urb_priv->urb_state == UNLINK) {
2402       /* URB has been requested to be unlinked asynchronously */
2403       urb->status = -ECONNRESET;
2404       errno_dbg("Fixing unlink status of URB:0x%x[%d] to:%d\n",
2405                 (unsigned int)urb, urb_num, urb->status);
2406     }
2407   } else {
2408     /* The USB Core wants to signal some error via the URB, pass it through */
2409   }
2410
2411   /* use completely different finish function for Isoc URBs */
2412   if(usb_pipeisoc(urb->pipe)) {
2413     tc_finish_isoc_urb(hcd, urb, status);
2414     return;
2415   }
2416
2417   /* Do special unlinking of EPs for Intr traffic */
2418   if(usb_pipeint(urb->pipe)) {
2419     tc_dma_unlink_intr_urb(urb);
2420   }
2421
2422   /* Release allocated bandwidth for periodic transfers */
2423   if(usb_pipeint(urb->pipe) || usb_pipeisoc(urb->pipe))
2424     crisv10_usb_release_bandwidth(hcd,
2425                                   usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS,
2426                                   urb_priv->bandwidth);
2427
2428   /* This URB is active on EP */
2429   if(urb == activeUrbList[epid]) {
2430     /* We need to fiddle with the toggle bits because the hardware doesn't do
2431        it for us. */
2432     toggle = etrax_epid_get_toggle(epid, usb_pipeout(urb->pipe));
2433     usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
2434                   usb_pipeout(urb->pipe), toggle);
2435
2436     /* Checks for Ctrl and Bulk EPs */
2437     switch(usb_pipetype(urb->pipe)) {
2438     case PIPE_BULK:
2439       /* Check so Bulk EP realy is disabled before finishing active URB  */
2440       ASSERT((TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) ==
2441              IO_STATE(USB_EP_command, enable, no));
2442       /* Disable sub-pointer for EP to avoid next tx_interrupt() to
2443          process Bulk EP. */
2444       TxBulkEPList[epid].sub = 0;
2445       /* No need to wait for the DMA before changing the next pointer.
2446          The modulo NBR_OF_EPIDS isn't actually necessary, since we will never use
2447          the last one (INVALID_EPID) for actual traffic. */
2448       TxBulkEPList[epid].next =
2449         virt_to_phys(&TxBulkEPList[(epid + 1) % NBR_OF_EPIDS]);
2450       break;
2451     case PIPE_CONTROL:
2452       /* Check so Ctrl EP realy is disabled before finishing active URB  */
2453       ASSERT((TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) ==
2454              IO_STATE(USB_EP_command, enable, no));
2455       /* Disable sub-pointer for EP to avoid next tx_interrupt() to
2456          process Ctrl EP. */
2457       TxCtrlEPList[epid].sub = 0;
2458       break;
2459     }
2460   }
2461
2462   /* Free HC-private URB data*/
2463   urb_priv_free(hcd, urb);
2464
2465   if(urb->status) {
2466     errno_dbg("finish_urb (URB:0x%x[%d] %s %s) (data:%d) status:%d\n",
2467               (unsigned int)urb, urb_num, str_dir(urb->pipe),
2468               str_type(urb->pipe), urb->actual_length, urb->status);
2469   } else {
2470     tc_dbg("finish_urb (URB:0x%x[%d] %s %s) (data:%d) status:%d\n",
2471            (unsigned int)urb, urb_num, str_dir(urb->pipe),
2472            str_type(urb->pipe), urb->actual_length, urb->status);
2473   }
2474
2475   /* If we just finished an active URB, clear active pointer. */
2476   if (urb == activeUrbList[epid]) {
2477     /* Make URB not active on EP anymore */
2478     activeUrbList[epid] = NULL;
2479
2480     if(urb->status == 0) {
2481       /* URB finished sucessfully, process queue to see if there are any more
2482          URBs waiting before we call completion function.*/
2483       if(crisv10_hcd->running) {
2484         /* Only process queue if USB controller is running */
2485         tc_dma_process_queue(epid);
2486       } else {
2487         tc_warn("No processing of queue for epid:%d, USB Controller not"
2488                 " running\n", epid);
2489       }
2490     }
2491   }
2492
2493   /*  Hand the URB from HCD to its USB device driver, using its completion
2494       functions */
2495   usb_hcd_giveback_urb (hcd, urb, status);
2496
2497   /* Check the queue once more if the URB returned with error, because we
2498      didn't do it before the completion function because the specification
2499      states that the queue should not restart until all it's unlinked
2500      URBs have been fully retired, with the completion functions run */
2501   if(crisv10_hcd->running) {
2502     /* Only process queue if USB controller is running */
2503     tc_dma_process_queue(epid);
2504   } else {
2505     tc_warn("No processing of queue for epid:%d, USB Controller not running\n",
2506             epid);
2507   }
2508
2509   DBFEXIT;
2510 }
2511
2512 static void tc_finish_isoc_urb(struct usb_hcd *hcd, struct urb *urb,
2513                                int status) {
2514   struct crisv10_urb_priv *urb_priv = urb->hcpriv;
2515   int epid, i;
2516   volatile int timeout = 10000;
2517   int bandwidth = 0;
2518
2519   ASSERT(urb_priv);
2520   epid = urb_priv->epid;
2521
2522   ASSERT(usb_pipeisoc(urb->pipe));
2523
2524   /* Set that all isoc packets have status and length set before
2525      completing the urb. */
2526   for (i = urb_priv->isoc_packet_counter; i < urb->number_of_packets; i++){
2527     urb->iso_frame_desc[i].actual_length = 0;
2528     urb->iso_frame_desc[i].status = -EPROTO;
2529   }
2530
2531   /* Check if the URB is currently active (done or error) */
2532   if(urb == activeUrbList[epid]) {
2533     /* Check if there are another In Isoc URB queued for this epid */
2534     if (!list_empty(&urb_list[epid])&& !epid_state[epid].disabled) {
2535       /* Move it from queue to active and mark it started so Isoc transfers
2536          won't be interrupted.
2537          All Isoc URBs data transfers are already added to DMA lists so we
2538          don't have to insert anything in DMA lists here. */
2539       activeUrbList[epid] = urb_list_first(epid);
2540       ((struct crisv10_urb_priv *)(activeUrbList[epid]->hcpriv))->urb_state =
2541         STARTED;
2542       urb_list_del(activeUrbList[epid], epid);
2543
2544       if(urb->status) {
2545         errno_dbg("finish_isoc_urb (URB:0x%x[%d] %s %s) (%d of %d packets)"
2546                   " status:%d, new waiting URB:0x%x[%d]\n",
2547                   (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
2548                   str_type(urb->pipe), urb_priv->isoc_packet_counter,
2549                   urb->number_of_packets, urb->status,
2550                   (unsigned int)activeUrbList[epid],
2551                   ((struct crisv10_urb_priv *)(activeUrbList[epid]->hcpriv))->urb_num);
2552       }
2553
2554     } else { /* No other URB queued for this epid */
2555       if(urb->status) {
2556         errno_dbg("finish_isoc_urb (URB:0x%x[%d] %s %s) (%d of %d packets)"
2557                   " status:%d, no new URB waiting\n",
2558                   (unsigned int)urb, urb_priv->urb_num, str_dir(urb->pipe),
2559                   str_type(urb->pipe), urb_priv->isoc_packet_counter,
2560                   urb->number_of_packets, urb->status);
2561       }
2562
2563       /* Check if EP is still enabled, then shut it down. */
2564       if (TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
2565         isoc_dbg("Isoc EP enabled for epid:%d, disabling it\n", epid);
2566
2567         /* Should only occur for In Isoc EPs where SB isn't consumed. */
2568         ASSERT(usb_pipein(urb->pipe));
2569
2570         /* Disable it and wait for it to stop */
2571         TxIsocEPList[epid].command &= ~IO_MASK(USB_EP_command, enable);
2572
2573         /* Ah, the luxury of busy-wait. */
2574         while((*R_DMA_CH8_SUB3_EP == virt_to_phys(&TxIsocEPList[epid])) &&
2575               (timeout-- > 0));
2576         if(timeout == 0) {
2577           warn("Timeout while waiting for DMA-TX-Isoc to leave EP for epid:%d\n", epid);
2578         }
2579       }
2580
2581       /* Unlink SB to say that epid is finished. */
2582       TxIsocEPList[epid].sub = 0;
2583       TxIsocEPList[epid].hw_len = 0;
2584
2585       /* No URB active for EP anymore */
2586       activeUrbList[epid] = NULL;
2587     }
2588   } else { /* Finishing of not active URB (queued up with SBs thought) */
2589     isoc_warn("finish_isoc_urb (URB:0x%x %s) (%d of %d packets) status:%d,"
2590               " SB queued but not active\n",
2591               (unsigned int)urb, str_dir(urb->pipe),
2592               urb_priv->isoc_packet_counter, urb->number_of_packets,
2593               urb->status);
2594     if(usb_pipeout(urb->pipe)) {
2595       /* Finishing of not yet active Out Isoc URB needs unlinking of SBs. */
2596       struct USB_SB_Desc *iter_sb, *prev_sb, *next_sb;
2597
2598       iter_sb = TxIsocEPList[epid].sub ?
2599         phys_to_virt(TxIsocEPList[epid].sub) : 0;
2600       prev_sb = 0;
2601
2602       /* SB that is linked before this URBs first SB */
2603       while (iter_sb && (iter_sb != urb_priv->first_sb)) {
2604         prev_sb = iter_sb;
2605         iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
2606       }
2607
2608       if (iter_sb == 0) {
2609         /* Unlink of the URB currently being transmitted. */
2610         prev_sb = 0;
2611         iter_sb = TxIsocEPList[epid].sub ? phys_to_virt(TxIsocEPList[epid].sub) : 0;
2612       }
2613
2614       while (iter_sb && (iter_sb != urb_priv->last_sb)) {
2615         iter_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
2616       }
2617
2618       if (iter_sb) {
2619         next_sb = iter_sb->next ? phys_to_virt(iter_sb->next) : 0;
2620       } else {
2621         /* This should only happen if the DMA has completed
2622            processing the SB list for this EP while interrupts
2623            are disabled. */
2624         isoc_dbg("Isoc urb not found, already sent?\n");
2625         next_sb = 0;
2626       }
2627       if (prev_sb) {
2628         prev_sb->next = next_sb ? virt_to_phys(next_sb) : 0;
2629       } else {
2630         TxIsocEPList[epid].sub = next_sb ? virt_to_phys(next_sb) : 0;
2631       }
2632     }
2633   }
2634
2635   /* Free HC-private URB data*/
2636   bandwidth = urb_priv->bandwidth;
2637   urb_priv_free(hcd, urb);
2638
2639   crisv10_usb_release_bandwidth(hcd, usb_pipeisoc(urb->pipe), bandwidth);
2640
2641   /*  Hand the URB from HCD to its USB device driver, using its completion
2642       functions */
2643   usb_hcd_giveback_urb (hcd, urb, status);
2644 }
2645
2646 static __u32 urb_num = 0;
2647
2648 /* allocate and initialize URB private data */
2649 static int urb_priv_create(struct usb_hcd *hcd, struct urb *urb, int epid,
2650                            int mem_flags) {
2651   struct crisv10_urb_priv *urb_priv;
2652
2653   urb_priv = kmalloc(sizeof *urb_priv, mem_flags);
2654   if (!urb_priv)
2655     return -ENOMEM;
2656   memset(urb_priv, 0, sizeof *urb_priv);
2657
2658   urb_priv->epid = epid;
2659   urb_priv->urb_state = NOT_STARTED;
2660
2661   urb->hcpriv = urb_priv;
2662   /* Assign URB a sequence number, and increment counter */
2663   urb_priv->urb_num = urb_num;
2664   urb_num++;
2665   urb_priv->bandwidth = 0;
2666   return 0;
2667 }
2668
2669 /* free URB private data */
2670 static void urb_priv_free(struct usb_hcd *hcd, struct urb *urb) {
2671   int i;
2672   struct crisv10_urb_priv *urb_priv = urb->hcpriv;
2673   ASSERT(urb_priv != 0);
2674
2675   /* Check it has any SBs linked that needs to be freed*/
2676   if(urb_priv->first_sb != NULL) {
2677     struct USB_SB_Desc *next_sb, *first_sb, *last_sb;
2678     int i = 0;
2679     first_sb = urb_priv->first_sb;
2680     last_sb = urb_priv->last_sb;
2681     ASSERT(last_sb);
2682     while(first_sb != last_sb) {
2683       next_sb = (struct USB_SB_Desc *)phys_to_virt(first_sb->next);
2684       kmem_cache_free(usb_desc_cache, first_sb);
2685       first_sb = next_sb;
2686       i++;
2687     }
2688     kmem_cache_free(usb_desc_cache, last_sb);
2689     i++;
2690   }
2691
2692   /* Check if it has any EPs in its Intr pool that also needs to be freed */
2693   if(urb_priv->intr_ep_pool_length > 0) {
2694     for(i = 0; i < urb_priv->intr_ep_pool_length; i++) {
2695       kfree(urb_priv->intr_ep_pool[i]);
2696     }
2697     /*
2698     tc_dbg("Freed %d EPs from URB:0x%x EP pool\n",
2699              urb_priv->intr_ep_pool_length, (unsigned int)urb);
2700     */
2701   }
2702
2703   kfree(urb_priv);
2704   urb->hcpriv = NULL;
2705 }
2706
2707 static int ep_priv_create(struct usb_host_endpoint *ep, int mem_flags) {
2708   struct crisv10_ep_priv *ep_priv;
2709
2710   ep_priv = kmalloc(sizeof *ep_priv, mem_flags);
2711   if (!ep_priv)
2712     return -ENOMEM;
2713   memset(ep_priv, 0, sizeof *ep_priv);
2714
2715   ep->hcpriv = ep_priv;
2716   return 0;
2717 }
2718
2719 static void ep_priv_free(struct usb_host_endpoint *ep) {
2720   struct crisv10_ep_priv *ep_priv = ep->hcpriv;
2721   ASSERT(ep_priv);
2722   kfree(ep_priv);
2723   ep->hcpriv = NULL;
2724 }
2725
2726 /*
2727  * usb_check_bandwidth():
2728  *
2729  * old_alloc is from host_controller->bandwidth_allocated in microseconds;
2730  * bustime is from calc_bus_time(), but converted to microseconds.
2731  *
2732  * returns <bustime in us> if successful,
2733  * or -ENOSPC if bandwidth request fails.
2734  *
2735  * FIXME:
2736  * This initial implementation does not use Endpoint.bInterval
2737  * in managing bandwidth allocation.
2738  * It probably needs to be expanded to use Endpoint.bInterval.
2739  * This can be done as a later enhancement (correction).
2740  *
2741  * This will also probably require some kind of
2742  * frame allocation tracking...meaning, for example,
2743  * that if multiple drivers request interrupts every 10 USB frames,
2744  * they don't all have to be allocated at
2745  * frame numbers N, N+10, N+20, etc.  Some of them could be at
2746  * N+11, N+21, N+31, etc., and others at
2747  * N+12, N+22, N+32, etc.
2748  *
2749  * Similarly for isochronous transfers...
2750  *
2751  * Individual HCDs can schedule more directly ... this logic
2752  * is not correct for high speed transfers.
2753  */
2754 static int crisv10_usb_check_bandwidth(
2755   struct usb_device *dev,
2756   struct urb *urb)
2757 {
2758   unsigned int  pipe = urb->pipe;
2759   long                                  bustime;
2760   int                                           is_in = usb_pipein (pipe);
2761   int                                           is_iso = usb_pipeisoc (pipe);
2762   int                                           old_alloc = dev->bus->bandwidth_allocated;
2763   int                                           new_alloc;
2764
2765   bustime = NS_TO_US (usb_calc_bus_time (dev->speed, is_in, is_iso,
2766                                          usb_maxpacket (dev, pipe, !is_in)));
2767   if (is_iso)
2768     bustime /= urb->number_of_packets;
2769
2770   new_alloc = old_alloc + (int) bustime;
2771   if (new_alloc > FRAME_TIME_MAX_USECS_ALLOC) {
2772     dev_dbg (&dev->dev, "usb_check_bandwidth FAILED: %d + %ld = %d usec\n",
2773              old_alloc, bustime, new_alloc);
2774     bustime = -ENOSPC;      /* report error */
2775   }
2776
2777   return bustime;
2778 }
2779
2780 /**
2781  * usb_claim_bandwidth - records bandwidth for a periodic transfer
2782  * @dev: source/target of request
2783  * @urb: request (urb->dev == dev)
2784  * @bustime: bandwidth consumed, in (average) microseconds per frame
2785  * @isoc: true iff the request is isochronous
2786  *
2787  * HCDs are expected not to overcommit periodic bandwidth, and to record such
2788  * reservations whenever endpoints are added to the periodic schedule.
2789  *
2790  * FIXME averaging per-frame is suboptimal.  Better to sum over the HCD's
2791  * entire periodic schedule ... 32 frames for OHCI, 1024 for UHCI, settable
2792  * for EHCI (256/512/1024 frames, default 1024) and have the bus expose how
2793  * large its periodic schedule is.
2794  */
2795 static void crisv10_usb_claim_bandwidth(
2796   struct usb_device *dev,
2797   struct urb *urb, int bustime, int isoc)
2798 {
2799   dev->bus->bandwidth_allocated += bustime;
2800   if (isoc)
2801     dev->bus->bandwidth_isoc_reqs++;
2802   else
2803     dev->bus->bandwidth_int_reqs++;
2804   struct crisv10_urb_priv *urb_priv;
2805   urb_priv = urb->hcpriv;
2806   urb_priv->bandwidth = bustime;
2807 }
2808
2809 /**
2810  * usb_release_bandwidth - reverses effect of usb_claim_bandwidth()
2811  * @hcd: host controller
2812  * @isoc: true iff the request is isochronous
2813  * @bandwidth: bandwidth returned
2814  *
2815  * This records that previously allocated bandwidth has been released.
2816  * Bandwidth is released when endpoints are removed from the host controller's
2817  * periodic schedule.
2818  */
2819 static void crisv10_usb_release_bandwidth(
2820   struct usb_hcd *hcd,
2821   int isoc,
2822   int bandwidth)
2823 {
2824   hcd_to_bus(hcd)->bandwidth_allocated -= bandwidth;
2825   if (isoc)
2826     hcd_to_bus(hcd)->bandwidth_isoc_reqs--;
2827   else
2828     hcd_to_bus(hcd)->bandwidth_int_reqs--;
2829 }
2830
2831
2832 /* EPID handling functions, managing EP-list in Etrax through wrappers */
2833 /* ------------------------------------------------------------------- */
2834
2835 /* Sets up a new EPID for an endpoint or returns existing if found */
2836 static int tc_setup_epid(struct usb_host_endpoint *ep, struct urb *urb,
2837                          int mem_flags) {
2838   int epid;
2839   char devnum, endpoint, out_traffic, slow;
2840   int maxlen;
2841   __u32 epid_data;
2842   struct crisv10_ep_priv *ep_priv = ep->hcpriv;
2843
2844   DBFENTER;
2845
2846   /* Check if a valid epid already is setup for this endpoint */
2847   if(ep_priv != NULL) {
2848     return ep_priv->epid;
2849   }
2850
2851   /* We must find and initiate a new epid for this urb. */
2852   epid = tc_allocate_epid();
2853
2854   if (epid == -1) {
2855     /* Failed to allocate a new epid. */
2856     DBFEXIT;
2857     return epid;
2858   }
2859
2860   /* We now have a new epid to use. Claim it. */
2861   epid_state[epid].inuse = 1;
2862
2863   /* Init private data for new endpoint */
2864   if(ep_priv_create(ep, mem_flags) != 0) {
2865     return -ENOMEM;
2866   }
2867   ep_priv = ep->hcpriv;
2868   ep_priv->epid = epid;
2869
2870   devnum = usb_pipedevice(urb->pipe);
2871   endpoint = usb_pipeendpoint(urb->pipe);
2872   slow = (urb->dev->speed == USB_SPEED_LOW);
2873   maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
2874
2875   if (usb_pipetype(urb->pipe) == PIPE_CONTROL) {
2876     /* We want both IN and OUT control traffic to be put on the same
2877        EP/SB list. */
2878     out_traffic = 1;
2879   } else {
2880     out_traffic = usb_pipeout(urb->pipe);
2881   }
2882
2883   if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
2884     epid_data = IO_STATE(R_USB_EPT_DATA_ISO, valid, yes) |
2885       /* FIXME: Change any to the actual port? */
2886       IO_STATE(R_USB_EPT_DATA_ISO, port, any) |
2887       IO_FIELD(R_USB_EPT_DATA_ISO, max_len, maxlen) |
2888       IO_FIELD(R_USB_EPT_DATA_ISO, ep, endpoint) |
2889       IO_FIELD(R_USB_EPT_DATA_ISO, dev, devnum);
2890     etrax_epid_iso_set(epid, epid_data);
2891   } else {
2892     epid_data = IO_STATE(R_USB_EPT_DATA, valid, yes) |
2893       IO_FIELD(R_USB_EPT_DATA, low_speed, slow) |
2894       /* FIXME: Change any to the actual port? */
2895       IO_STATE(R_USB_EPT_DATA, port, any) |
2896       IO_FIELD(R_USB_EPT_DATA, max_len, maxlen) |
2897       IO_FIELD(R_USB_EPT_DATA, ep, endpoint) |
2898       IO_FIELD(R_USB_EPT_DATA, dev, devnum);
2899     etrax_epid_set(epid, epid_data);
2900   }
2901
2902   epid_state[epid].out_traffic = out_traffic;
2903   epid_state[epid].type = usb_pipetype(urb->pipe);
2904
2905   tc_warn("Setting up ep:0x%x epid:%d (addr:%d endp:%d max_len:%d %s %s %s)\n",
2906           (unsigned int)ep, epid, devnum, endpoint, maxlen,
2907           str_type(urb->pipe), out_traffic ? "out" : "in",
2908           slow ? "low" : "full");
2909
2910   /* Enable Isoc eof interrupt if we set up the first Isoc epid */
2911   if(usb_pipeisoc(urb->pipe)) {
2912     isoc_epid_counter++;
2913     if(isoc_epid_counter == 1) {
2914       isoc_warn("Enabled Isoc eof interrupt\n");
2915       *R_USB_IRQ_MASK_SET = IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set);
2916     }
2917   }
2918
2919   DBFEXIT;
2920   return epid;
2921 }
2922
2923 static void tc_free_epid(struct usb_host_endpoint *ep) {
2924   unsigned long flags;
2925   struct crisv10_ep_priv *ep_priv = ep->hcpriv;
2926   int epid;
2927   volatile int timeout = 10000;
2928
2929   DBFENTER;
2930
2931   if (ep_priv == NULL) {
2932     tc_warn("Trying to free unused epid on ep:0x%x\n", (unsigned int)ep);
2933     DBFEXIT;
2934     return;
2935   }
2936
2937   epid = ep_priv->epid;
2938
2939   /* Disable Isoc eof interrupt if we free the last Isoc epid */
2940   if(epid_isoc(epid)) {
2941     ASSERT(isoc_epid_counter > 0);
2942     isoc_epid_counter--;
2943     if(isoc_epid_counter == 0) {
2944       *R_USB_IRQ_MASK_CLR = IO_STATE(R_USB_IRQ_MASK_CLR, iso_eof, clr);
2945       isoc_warn("Disabled Isoc eof interrupt\n");
2946     }
2947   }
2948
2949   /* Take lock manualy instead of in epid_x_x wrappers,
2950      because we need to be polling here */
2951   spin_lock_irqsave(&etrax_epid_lock, flags);
2952
2953   *R_USB_EPT_INDEX = IO_FIELD(R_USB_EPT_INDEX, value, epid);
2954   nop();
2955   while((*R_USB_EPT_DATA & IO_MASK(R_USB_EPT_DATA, hold)) &&
2956         (timeout-- > 0));
2957   if(timeout == 0) {
2958     warn("Timeout while waiting for epid:%d to drop hold\n", epid);
2959   }
2960   /* This will, among other things, set the valid field to 0. */
2961   *R_USB_EPT_DATA = 0;
2962   spin_unlock_irqrestore(&etrax_epid_lock, flags);
2963
2964   /* Free resource in software state info list */
2965   epid_state[epid].inuse = 0;
2966
2967   /* Free private endpoint data */
2968   ep_priv_free(ep);
2969
2970   DBFEXIT;
2971 }
2972
2973 static int tc_allocate_epid(void) {
2974   int i;
2975   DBFENTER;
2976   for (i = 0; i < NBR_OF_EPIDS; i++) {
2977     if (!epid_inuse(i)) {
2978       DBFEXIT;
2979       return i;
2980     }
2981   }
2982
2983   tc_warn("Found no free epids\n");
2984   DBFEXIT;
2985   return -1;
2986 }
2987
2988
2989 /* Wrappers around the list functions (include/linux/list.h). */
2990 /* ---------------------------------------------------------- */
2991 static inline int __urb_list_empty(int epid) {
2992   int retval;
2993   retval = list_empty(&urb_list[epid]);
2994   return retval;
2995 }
2996
2997 /* Returns first urb for this epid, or NULL if list is empty. */
2998 static inline struct urb *urb_list_first(int epid) {
2999   unsigned long flags;
3000   struct urb *first_urb = 0;
3001   spin_lock_irqsave(&urb_list_lock, flags);
3002   if (!__urb_list_empty(epid)) {
3003     /* Get the first urb (i.e. head->next). */
3004     urb_entry_t *urb_entry = list_entry((&urb_list[epid])->next, urb_entry_t, list);
3005     first_urb = urb_entry->urb;
3006   }
3007   spin_unlock_irqrestore(&urb_list_lock, flags);
3008   return first_urb;
3009 }
3010
3011 /* Adds an urb_entry last in the list for this epid. */
3012 static inline void urb_list_add(struct urb *urb, int epid, int mem_flags) {
3013   unsigned long flags;
3014   urb_entry_t *urb_entry = (urb_entry_t *)kmalloc(sizeof(urb_entry_t), mem_flags);
3015   ASSERT(urb_entry);
3016
3017   urb_entry->urb = urb;
3018   spin_lock_irqsave(&urb_list_lock, flags);
3019   list_add_tail(&urb_entry->list, &urb_list[epid]);
3020   spin_unlock_irqrestore(&urb_list_lock, flags);
3021 }
3022
3023 /* Search through the list for an element that contains this urb. (The list
3024    is expected to be short and the one we are about to delete will often be
3025    the first in the list.)
3026    Should be protected by spin_locks in calling function */
3027 static inline urb_entry_t *__urb_list_entry(struct urb *urb, int epid) {
3028   struct list_head *entry;
3029   struct list_head *tmp;
3030   urb_entry_t *urb_entry;
3031
3032   list_for_each_safe(entry, tmp, &urb_list[epid]) {
3033     urb_entry = list_entry(entry, urb_entry_t, list);
3034     ASSERT(urb_entry);
3035     ASSERT(urb_entry->urb);
3036
3037     if (urb_entry->urb == urb) {
3038       return urb_entry;
3039     }
3040   }
3041   return 0;
3042 }
3043
3044 /* Same function as above but for global use. Protects list by spinlock */
3045 static inline urb_entry_t *urb_list_entry(struct urb *urb, int epid) {
3046   unsigned long flags;
3047   urb_entry_t *urb_entry;
3048   spin_lock_irqsave(&urb_list_lock, flags);
3049   urb_entry = __urb_list_entry(urb, epid);
3050   spin_unlock_irqrestore(&urb_list_lock, flags);
3051   return (urb_entry);
3052 }
3053
3054 /* Delete an urb from the list. */
3055 static inline void urb_list_del(struct urb *urb, int epid) {
3056   unsigned long flags;
3057   urb_entry_t *urb_entry;
3058
3059   /* Delete entry and free. */
3060   spin_lock_irqsave(&urb_list_lock, flags);
3061   urb_entry = __urb_list_entry(urb, epid);
3062   ASSERT(urb_entry);
3063
3064   list_del(&urb_entry->list);
3065   spin_unlock_irqrestore(&urb_list_lock, flags);
3066   kfree(urb_entry);
3067 }
3068
3069 /* Move an urb to the end of the list. */
3070 static inline void urb_list_move_last(struct urb *urb, int epid) {
3071   unsigned long flags;
3072   urb_entry_t *urb_entry;
3073
3074   spin_lock_irqsave(&urb_list_lock, flags);
3075   urb_entry = __urb_list_entry(urb, epid);
3076   ASSERT(urb_entry);
3077
3078   list_del(&urb_entry->list);
3079   list_add_tail(&urb_entry->list, &urb_list[epid]);
3080   spin_unlock_irqrestore(&urb_list_lock, flags);
3081 }
3082
3083 /* Get the next urb in the list. */
3084 static inline struct urb *urb_list_next(struct urb *urb, int epid) {
3085   unsigned long flags;
3086   urb_entry_t *urb_entry;
3087
3088   spin_lock_irqsave(&urb_list_lock, flags);
3089   urb_entry = __urb_list_entry(urb, epid);
3090   ASSERT(urb_entry);
3091
3092   if (urb_entry->list.next != &urb_list[epid]) {
3093     struct list_head *elem = urb_entry->list.next;
3094     urb_entry = list_entry(elem, urb_entry_t, list);
3095     spin_unlock_irqrestore(&urb_list_lock, flags);
3096     return urb_entry->urb;
3097   } else {
3098     spin_unlock_irqrestore(&urb_list_lock, flags);
3099     return NULL;
3100   }
3101 }
3102
3103 struct USB_EP_Desc* create_ep(int epid, struct USB_SB_Desc* sb_desc,
3104                               int mem_flags) {
3105   struct USB_EP_Desc *ep_desc;
3106   ep_desc = (struct USB_EP_Desc *) kmem_cache_alloc(usb_desc_cache, mem_flags);
3107   if(ep_desc == NULL)
3108     return NULL;
3109   memset(ep_desc, 0, sizeof(struct USB_EP_Desc));
3110
3111   ep_desc->hw_len = 0;
3112   ep_desc->command = (IO_FIELD(USB_EP_command, epid, epid) |
3113                       IO_STATE(USB_EP_command, enable, yes));
3114   if(sb_desc == NULL) {
3115     ep_desc->sub = 0;
3116   } else {
3117     ep_desc->sub = virt_to_phys(sb_desc);
3118   }
3119   return ep_desc;
3120 }
3121
3122 #define TT_ZOUT  0
3123 #define TT_IN    1
3124 #define TT_OUT   2
3125 #define TT_SETUP 3
3126
3127 #define CMD_EOL  IO_STATE(USB_SB_command, eol, yes)
3128 #define CMD_INTR IO_STATE(USB_SB_command, intr, yes)
3129 #define CMD_FULL IO_STATE(USB_SB_command, full, yes)
3130
3131 /* Allocation and setup of a generic SB. Used to create SETUP, OUT and ZOUT
3132    SBs. Also used by create_sb_in() to avoid same allocation procedure at two
3133    places */
3134 struct USB_SB_Desc* create_sb(struct USB_SB_Desc* sb_prev, int tt, void* data,
3135                               int datalen, int mem_flags) {
3136   struct USB_SB_Desc *sb_desc;
3137   sb_desc = (struct USB_SB_Desc*)kmem_cache_alloc(usb_desc_cache, mem_flags);
3138   if(sb_desc == NULL)
3139     return NULL;
3140   memset(sb_desc, 0, sizeof(struct USB_SB_Desc));
3141
3142   sb_desc->command = IO_FIELD(USB_SB_command, tt, tt) |
3143                      IO_STATE(USB_SB_command, eot, yes);
3144
3145   sb_desc->sw_len = datalen;
3146   if(data != NULL) {
3147     sb_desc->buf = virt_to_phys(data);
3148   } else {
3149     sb_desc->buf = 0;
3150   }
3151   if(sb_prev != NULL) {
3152     sb_prev->next = virt_to_phys(sb_desc);
3153   }
3154   return sb_desc;
3155 }
3156
3157 /* Creates a copy of an existing SB by allocation space for it and copy
3158    settings */
3159 struct USB_SB_Desc* create_sb_copy(struct USB_SB_Desc* sb_orig, int mem_flags) {
3160   struct USB_SB_Desc *sb_desc;
3161   sb_desc = (struct USB_SB_Desc*)kmem_cache_alloc(usb_desc_cache, mem_flags);
3162   if(sb_desc == NULL)
3163     return NULL;
3164
3165   memcpy(sb_desc, sb_orig, sizeof(struct USB_SB_Desc));
3166   return sb_desc;
3167 }
3168
3169 /* A specific create_sb function for creation of in SBs. This is due to
3170    that datalen in In SBs shows how many packets we are expecting. It also
3171    sets up the rem field to show if how many bytes we expect in last packet
3172    if it's not a full one */
3173 struct USB_SB_Desc* create_sb_in(struct USB_SB_Desc* sb_prev, int datalen,
3174                                  int maxlen, int mem_flags) {
3175   struct USB_SB_Desc *sb_desc;
3176   sb_desc = create_sb(sb_prev, TT_IN, NULL,
3177                       datalen ? (datalen - 1) / maxlen + 1 : 0, mem_flags);
3178   if(sb_desc == NULL)
3179     return NULL;
3180   sb_desc->command |= IO_FIELD(USB_SB_command, rem, datalen % maxlen);
3181   return sb_desc;
3182 }
3183
3184 void set_sb_cmds(struct USB_SB_Desc *sb_desc, __u16 flags) {
3185   sb_desc->command |= flags;
3186 }
3187
3188 int create_sb_for_urb(struct urb *urb, int mem_flags) {
3189   int is_out = !usb_pipein(urb->pipe);
3190   int type = usb_pipetype(urb->pipe);
3191   int maxlen = usb_maxpacket(urb->dev, urb->pipe, is_out);
3192   int buf_len = urb->transfer_buffer_length;
3193   void *buf = buf_len > 0 ? urb->transfer_buffer : NULL;
3194   struct USB_SB_Desc *sb_desc = NULL;
3195
3196   struct crisv10_urb_priv *urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
3197   ASSERT(urb_priv != NULL);
3198
3199   switch(type) {
3200   case PIPE_CONTROL:
3201     /* Setup stage */
3202     sb_desc = create_sb(NULL, TT_SETUP, urb->setup_packet, 8, mem_flags);
3203     if(sb_desc == NULL)
3204       return -ENOMEM;
3205     set_sb_cmds(sb_desc, CMD_FULL);
3206
3207     /* Attach first SB to URB */
3208     urb_priv->first_sb = sb_desc;
3209
3210     if (is_out) { /* Out Control URB */
3211       /* If this Control OUT transfer has an optional data stage we add
3212          an OUT token before the mandatory IN (status) token */
3213       if ((buf_len > 0) && buf) {
3214         sb_desc = create_sb(sb_desc, TT_OUT, buf, buf_len, mem_flags);
3215         if(sb_desc == NULL)
3216           return -ENOMEM;
3217         set_sb_cmds(sb_desc, CMD_FULL);
3218       }
3219
3220       /* Status stage */
3221       /* The data length has to be exactly 1. This is due to a requirement
3222          of the USB specification that a host must be prepared to receive
3223          data in the status phase */
3224       sb_desc = create_sb(sb_desc, TT_IN, NULL, 1, mem_flags);
3225       if(sb_desc == NULL)
3226         return -ENOMEM;
3227     } else { /* In control URB */
3228       /* Data stage */
3229       sb_desc = create_sb_in(sb_desc, buf_len, maxlen, mem_flags);
3230       if(sb_desc == NULL)
3231         return -ENOMEM;
3232
3233       /* Status stage */
3234       /* Read comment at zout_buffer declaration for an explanation to this. */
3235       sb_desc = create_sb(sb_desc, TT_ZOUT, &zout_buffer[0], 1, mem_flags);
3236       if(sb_desc == NULL)
3237         return -ENOMEM;
3238       /* Set descriptor interrupt flag for in URBs so we can finish URB after
3239          zout-packet has been sent */
3240       set_sb_cmds(sb_desc, CMD_INTR | CMD_FULL);
3241     }
3242     /* Set end-of-list flag in last SB */
3243     set_sb_cmds(sb_desc, CMD_EOL);
3244     /* Attach last SB to URB */
3245     urb_priv->last_sb = sb_desc;
3246     break;
3247
3248   case PIPE_BULK:
3249     if (is_out) { /* Out Bulk URB */
3250       sb_desc = create_sb(NULL, TT_OUT, buf, buf_len, mem_flags);
3251       if(sb_desc == NULL)
3252         return -ENOMEM;
3253       /* The full field is set to yes, even if we don't actually check that
3254          this is a full-length transfer (i.e., that transfer_buffer_length %
3255          maxlen = 0).
3256          Setting full prevents the USB controller from sending an empty packet
3257          in that case.  However, if URB_ZERO_PACKET was set we want that. */
3258       if (!(urb->transfer_flags & URB_ZERO_PACKET)) {
3259         set_sb_cmds(sb_desc, CMD_FULL);
3260       }
3261     } else { /* In Bulk URB */
3262       sb_desc = create_sb_in(NULL, buf_len, maxlen, mem_flags);
3263       if(sb_desc == NULL)
3264         return -ENOMEM;
3265     }
3266     /* Set end-of-list flag for last SB */
3267     set_sb_cmds(sb_desc, CMD_EOL);
3268
3269     /* Attach SB to URB */
3270     urb_priv->first_sb = sb_desc;
3271     urb_priv->last_sb = sb_desc;
3272     break;
3273
3274   case PIPE_INTERRUPT:
3275     if(is_out) { /* Out Intr URB */
3276       sb_desc = create_sb(NULL, TT_OUT, buf, buf_len, mem_flags);
3277       if(sb_desc == NULL)
3278         return -ENOMEM;
3279
3280       /* The full field is set to yes, even if we don't actually check that
3281          this is a full-length transfer (i.e., that transfer_buffer_length %
3282          maxlen = 0).
3283          Setting full prevents the USB controller from sending an empty packet
3284          in that case.  However, if URB_ZERO_PACKET was set we want that. */
3285       if (!(urb->transfer_flags & URB_ZERO_PACKET)) {
3286         set_sb_cmds(sb_desc, CMD_FULL);
3287       }
3288       /* Only generate TX interrupt if it's a Out URB*/
3289       set_sb_cmds(sb_desc, CMD_INTR);
3290
3291     } else { /* In Intr URB */
3292       sb_desc = create_sb_in(NULL, buf_len, maxlen, mem_flags);
3293       if(sb_desc == NULL)
3294         return -ENOMEM;
3295     }
3296     /* Set end-of-list flag for last SB */
3297     set_sb_cmds(sb_desc, CMD_EOL);
3298
3299     /* Attach SB to URB */
3300     urb_priv->first_sb = sb_desc;
3301     urb_priv->last_sb = sb_desc;
3302
3303     break;
3304   case PIPE_ISOCHRONOUS:
3305     if(is_out) { /* Out Isoc URB */
3306       int i;
3307       if(urb->number_of_packets == 0) {
3308         tc_err("Can't create SBs for Isoc URB with zero packets\n");
3309         return -EPIPE;
3310       }
3311       /* Create one SB descriptor for each packet and link them together. */
3312       for(i = 0; i < urb->number_of_packets; i++) {
3313         if (urb->iso_frame_desc[i].length > 0) {
3314
3315           sb_desc = create_sb(sb_desc, TT_OUT, urb->transfer_buffer +
3316                               urb->iso_frame_desc[i].offset,
3317                               urb->iso_frame_desc[i].length, mem_flags);
3318           if(sb_desc == NULL)
3319             return -ENOMEM;
3320
3321           /* Check if it's a full length packet */
3322           if (urb->iso_frame_desc[i].length ==
3323               usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe))) {
3324             set_sb_cmds(sb_desc, CMD_FULL);
3325           }
3326
3327         } else { /* zero length packet */
3328           sb_desc = create_sb(sb_desc, TT_ZOUT, &zout_buffer[0], 1, mem_flags);
3329           if(sb_desc == NULL)
3330             return -ENOMEM;
3331           set_sb_cmds(sb_desc, CMD_FULL);
3332         }
3333         /* Attach first SB descriptor to URB */
3334         if (i == 0) {
3335           urb_priv->first_sb = sb_desc;
3336         }
3337       }
3338       /* Set interrupt and end-of-list flags in last SB */
3339       set_sb_cmds(sb_desc, CMD_INTR | CMD_EOL);
3340       /* Attach last SB descriptor to URB */
3341       urb_priv->last_sb = sb_desc;
3342       tc_dbg("Created %d out SBs for Isoc URB:0x%x\n",
3343                urb->number_of_packets, (unsigned int)urb);
3344     } else { /* In Isoc URB */
3345       /* Actual number of packets is not relevant for periodic in traffic as
3346          long as it is more than zero.  Set to 1 always. */
3347       sb_desc = create_sb(sb_desc, TT_IN, NULL, 1, mem_flags);
3348       if(sb_desc == NULL)
3349         return -ENOMEM;
3350       /* Set end-of-list flags for SB */
3351       set_sb_cmds(sb_desc, CMD_EOL);
3352
3353       /* Attach SB to URB */
3354       urb_priv->first_sb = sb_desc;
3355       urb_priv->last_sb = sb_desc;
3356     }
3357     break;
3358   default:
3359     tc_err("Unknown pipe-type\n");
3360     return -EPIPE;
3361     break;
3362   }
3363   return 0;
3364 }
3365
3366 int init_intr_urb(struct urb *urb, int mem_flags) {
3367   struct crisv10_urb_priv *urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
3368   struct USB_EP_Desc* ep_desc;
3369   int interval;
3370   int i;
3371   int ep_count;
3372
3373   ASSERT(urb_priv != NULL);
3374   ASSERT(usb_pipeint(urb->pipe));
3375   /* We can't support interval longer than amount of eof descriptors in
3376      TxIntrEPList */
3377   if(urb->interval > MAX_INTR_INTERVAL) {
3378     tc_err("Interrupt interval %dms too big (max: %dms)\n", urb->interval,
3379            MAX_INTR_INTERVAL);
3380     return -EINVAL;
3381   }
3382
3383   /* We assume that the SB descriptors already have been setup */
3384   ASSERT(urb_priv->first_sb != NULL);
3385
3386   /* Round of the interval to 2^n, it is obvious that this code favours
3387      smaller numbers, but that is actually a good thing */
3388   /* FIXME: The "rounding error" for larger intervals will be quite
3389      large. For in traffic this shouldn't be a problem since it will only
3390      mean that we "poll" more often. */
3391   interval = urb->interval;
3392   for (i = 0; interval; i++) {
3393     interval = interval >> 1;
3394   }
3395   urb_priv->interval = 1 << (i - 1);
3396
3397   /* We can only have max interval for Out Interrupt due to that we can only
3398      handle one linked in EP for a certain epid in the Intr descr array at the
3399      time. The USB Controller in the Etrax 100LX continues to process Intr EPs
3400      so we have no way of knowing which one that caused the actual transfer if
3401      we have several linked in. */
3402   if(usb_pipeout(urb->pipe)) {
3403     urb_priv->interval = MAX_INTR_INTERVAL;
3404   }
3405
3406   /* Calculate amount of EPs needed */
3407   ep_count = MAX_INTR_INTERVAL / urb_priv->interval;
3408
3409   for(i = 0; i < ep_count; i++) {
3410     ep_desc = create_ep(urb_priv->epid, urb_priv->first_sb, mem_flags);
3411     if(ep_desc == NULL) {
3412       /* Free any descriptors that we may have allocated before failure */
3413       while(i > 0) {
3414         i--;
3415         kfree(urb_priv->intr_ep_pool[i]);
3416       }
3417       return -ENOMEM;
3418     }
3419     urb_priv->intr_ep_pool[i] = ep_desc;
3420   }
3421   urb_priv->intr_ep_pool_length = ep_count;
3422   return 0;
3423 }
3424
3425 /* DMA RX/TX functions */
3426 /* ----------------------- */
3427
3428 static void tc_dma_init_rx_list(void) {
3429   int i;
3430
3431   /* Setup descriptor list except last one */
3432   for (i = 0; i < (NBR_OF_RX_DESC - 1); i++) {
3433     RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
3434     RxDescList[i].command = 0;
3435     RxDescList[i].next = virt_to_phys(&RxDescList[i + 1]);
3436     RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
3437     RxDescList[i].hw_len = 0;
3438     RxDescList[i].status = 0;
3439
3440     /* DMA IN cache bug. (struct etrax_dma_descr has the same layout as
3441        USB_IN_Desc for the relevant fields.) */
3442     prepare_rx_descriptor((struct etrax_dma_descr*)&RxDescList[i]);
3443
3444   }
3445   /* Special handling of last descriptor */
3446   RxDescList[i].sw_len = RX_DESC_BUF_SIZE;
3447   RxDescList[i].command = IO_STATE(USB_IN_command, eol, yes);
3448   RxDescList[i].next = virt_to_phys(&RxDescList[0]);
3449   RxDescList[i].buf = virt_to_phys(RxBuf + (i * RX_DESC_BUF_SIZE));
3450   RxDescList[i].hw_len = 0;
3451   RxDescList[i].status = 0;
3452
3453   /* Setup list pointers that show progress in list */
3454   myNextRxDesc = &RxDescList[0];
3455   myLastRxDesc = &RxDescList[NBR_OF_RX_DESC - 1];
3456
3457   flush_etrax_cache();
3458   /* Point DMA to first descriptor in list and start it */
3459   *R_DMA_CH9_FIRST = virt_to_phys(myNextRxDesc);
3460   *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, start);
3461 }
3462
3463
3464 static void tc_dma_init_tx_bulk_list(void) {
3465   int i;
3466   volatile struct USB_EP_Desc *epDescr;
3467
3468   for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
3469     epDescr = &(TxBulkEPList[i]);
3470     CHECK_ALIGN(epDescr);
3471     epDescr->hw_len = 0;
3472     epDescr->command = IO_FIELD(USB_EP_command, epid, i);
3473     epDescr->sub = 0;
3474     epDescr->next = virt_to_phys(&TxBulkEPList[i + 1]);
3475
3476     /* Initiate two EPs, disabled and with the eol flag set. No need for any
3477        preserved epid. */
3478
3479     /* The first one has the intr flag set so we get an interrupt when the DMA
3480        channel is about to become disabled. */
3481     CHECK_ALIGN(&TxBulkDummyEPList[i][0]);
3482     TxBulkDummyEPList[i][0].hw_len = 0;
3483     TxBulkDummyEPList[i][0].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
3484                                        IO_STATE(USB_EP_command, eol, yes) |
3485                                        IO_STATE(USB_EP_command, intr, yes));
3486     TxBulkDummyEPList[i][0].sub = 0;
3487     TxBulkDummyEPList[i][0].next = virt_to_phys(&TxBulkDummyEPList[i][1]);
3488
3489     /* The second one. */
3490     CHECK_ALIGN(&TxBulkDummyEPList[i][1]);
3491     TxBulkDummyEPList[i][1].hw_len = 0;
3492     TxBulkDummyEPList[i][1].command = (IO_FIELD(USB_EP_command, epid, DUMMY_EPID) |
3493                                        IO_STATE(USB_EP_command, eol, yes));
3494     TxBulkDummyEPList[i][1].sub = 0;
3495     /* The last dummy's next pointer is the same as the current EP's next pointer. */
3496     TxBulkDummyEPList[i][1].next = virt_to_phys(&TxBulkEPList[i + 1]);
3497   }
3498
3499   /* Special handling of last descr in list, make list circular */
3500   epDescr = &TxBulkEPList[i];
3501   CHECK_ALIGN(epDescr);
3502   epDescr->hw_len = 0;
3503   epDescr->command = IO_STATE(USB_EP_command, eol, yes) |
3504     IO_FIELD(USB_EP_command, epid, i);
3505   epDescr->sub = 0;
3506   epDescr->next = virt_to_phys(&TxBulkEPList[0]);
3507
3508   /* Init DMA sub-channel pointers to last item in each list */
3509   *R_DMA_CH8_SUB0_EP = virt_to_phys(&TxBulkEPList[i]);
3510   /* No point in starting the bulk channel yet.
3511    *R_DMA_CH8_SUB0_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); */
3512 }
3513
3514 static void tc_dma_init_tx_ctrl_list(void) {
3515   int i;
3516   volatile struct USB_EP_Desc *epDescr;
3517
3518   for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
3519     epDescr = &(TxCtrlEPList[i]);
3520     CHECK_ALIGN(epDescr);
3521     epDescr->hw_len = 0;
3522     epDescr->command = IO_FIELD(USB_EP_command, epid, i);
3523     epDescr->sub = 0;
3524     epDescr->next = virt_to_phys(&TxCtrlEPList[i + 1]);
3525   }
3526   /* Special handling of last descr in list, make list circular */
3527   epDescr = &TxCtrlEPList[i];
3528   CHECK_ALIGN(epDescr);
3529   epDescr->hw_len = 0;
3530   epDescr->command = IO_STATE(USB_EP_command, eol, yes) |
3531     IO_FIELD(USB_EP_command, epid, i);
3532   epDescr->sub = 0;
3533   epDescr->next = virt_to_phys(&TxCtrlEPList[0]);
3534
3535   /* Init DMA sub-channel pointers to last item in each list */
3536   *R_DMA_CH8_SUB1_EP = virt_to_phys(&TxCtrlEPList[i]);
3537   /* No point in starting the ctrl channel yet.
3538    *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB0_CMD, cmd, start); */
3539 }
3540
3541
3542 static void tc_dma_init_tx_intr_list(void) {
3543   int i;
3544
3545   TxIntrSB_zout.sw_len = 1;
3546   TxIntrSB_zout.next = 0;
3547   TxIntrSB_zout.buf = virt_to_phys(&zout_buffer[0]);
3548   TxIntrSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
3549                            IO_STATE(USB_SB_command, tt, zout) |
3550                            IO_STATE(USB_SB_command, full, yes) |
3551                            IO_STATE(USB_SB_command, eot, yes) |
3552                            IO_STATE(USB_SB_command, eol, yes));
3553
3554   for (i = 0; i < (MAX_INTR_INTERVAL - 1); i++) {
3555     CHECK_ALIGN(&TxIntrEPList[i]);
3556     TxIntrEPList[i].hw_len = 0;
3557     TxIntrEPList[i].command =
3558       (IO_STATE(USB_EP_command, eof, yes) |
3559        IO_STATE(USB_EP_command, enable, yes) |
3560        IO_FIELD(USB_EP_command, epid, INVALID_EPID));
3561     TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
3562     TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[i + 1]);
3563   }
3564
3565   /* Special handling of last descr in list, make list circular */
3566   CHECK_ALIGN(&TxIntrEPList[i]);
3567   TxIntrEPList[i].hw_len = 0;
3568   TxIntrEPList[i].command =
3569     (IO_STATE(USB_EP_command, eof, yes) |
3570      IO_STATE(USB_EP_command, eol, yes) |
3571      IO_STATE(USB_EP_command, enable, yes) |
3572      IO_FIELD(USB_EP_command, epid, INVALID_EPID));
3573   TxIntrEPList[i].sub = virt_to_phys(&TxIntrSB_zout);
3574   TxIntrEPList[i].next = virt_to_phys(&TxIntrEPList[0]);
3575
3576   intr_dbg("Initiated Intr EP descriptor list\n");
3577
3578
3579   /* Connect DMA 8 sub-channel 2 to first in list */
3580   *R_DMA_CH8_SUB2_EP = virt_to_phys(&TxIntrEPList[0]);
3581 }
3582
3583 static void tc_dma_init_tx_isoc_list(void) {
3584   int i;
3585
3586   DBFENTER;
3587
3588   /* Read comment at zout_buffer declaration for an explanation to this. */
3589   TxIsocSB_zout.sw_len = 1;
3590   TxIsocSB_zout.next = 0;
3591   TxIsocSB_zout.buf = virt_to_phys(&zout_buffer[0]);
3592   TxIsocSB_zout.command = (IO_FIELD(USB_SB_command, rem, 0) |
3593                            IO_STATE(USB_SB_command, tt, zout) |
3594                            IO_STATE(USB_SB_command, full, yes) |
3595                            IO_STATE(USB_SB_command, eot, yes) |
3596                            IO_STATE(USB_SB_command, eol, yes));
3597
3598   /* The last isochronous EP descriptor is a dummy. */
3599   for (i = 0; i < (NBR_OF_EPIDS - 1); i++) {
3600     CHECK_ALIGN(&TxIsocEPList[i]);
3601     TxIsocEPList[i].hw_len = 0;
3602     TxIsocEPList[i].command = IO_FIELD(USB_EP_command, epid, i);
3603     TxIsocEPList[i].sub = 0;
3604     TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[i + 1]);
3605   }
3606
3607   CHECK_ALIGN(&TxIsocEPList[i]);
3608   TxIsocEPList[i].hw_len = 0;
3609
3610   /* Must enable the last EP descr to get eof interrupt. */
3611   TxIsocEPList[i].command = (IO_STATE(USB_EP_command, enable, yes) |
3612                              IO_STATE(USB_EP_command, eof, yes) |
3613                              IO_STATE(USB_EP_command, eol, yes) |
3614                              IO_FIELD(USB_EP_command, epid, INVALID_EPID));
3615   TxIsocEPList[i].sub = virt_to_phys(&TxIsocSB_zout);
3616   TxIsocEPList[i].next = virt_to_phys(&TxIsocEPList[0]);
3617
3618   *R_DMA_CH8_SUB3_EP = virt_to_phys(&TxIsocEPList[0]);
3619   *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
3620 }
3621
3622 static int tc_dma_init(struct usb_hcd *hcd) {
3623   tc_dma_init_rx_list();
3624   tc_dma_init_tx_bulk_list();
3625   tc_dma_init_tx_ctrl_list();
3626   tc_dma_init_tx_intr_list();
3627   tc_dma_init_tx_isoc_list();
3628
3629   if (cris_request_dma(USB_TX_DMA_NBR,
3630                        "ETRAX 100LX built-in USB (Tx)",
3631                        DMA_VERBOSE_ON_ERROR,
3632                        dma_usb)) {
3633     err("Could not allocate DMA ch 8 for USB");
3634     return -EBUSY;
3635   }
3636
3637   if (cris_request_dma(USB_RX_DMA_NBR,
3638                        "ETRAX 100LX built-in USB (Rx)",
3639                        DMA_VERBOSE_ON_ERROR,
3640                        dma_usb)) {
3641     err("Could not allocate DMA ch 9 for USB");
3642     return -EBUSY;
3643   }
3644
3645   *R_IRQ_MASK2_SET =
3646     /* Note that these interrupts are not used. */
3647     IO_STATE(R_IRQ_MASK2_SET, dma8_sub0_descr, set) |
3648     /* Sub channel 1 (ctrl) descr. interrupts are used. */
3649     IO_STATE(R_IRQ_MASK2_SET, dma8_sub1_descr, set) |
3650     IO_STATE(R_IRQ_MASK2_SET, dma8_sub2_descr, set) |
3651     /* Sub channel 3 (isoc) descr. interrupts are used. */
3652     IO_STATE(R_IRQ_MASK2_SET, dma8_sub3_descr, set);
3653
3654   /* Note that the dma9_descr interrupt is not used. */
3655   *R_IRQ_MASK2_SET =
3656     IO_STATE(R_IRQ_MASK2_SET, dma9_eop, set) |
3657     IO_STATE(R_IRQ_MASK2_SET, dma9_descr, set);
3658
3659   if (request_irq(ETRAX_USB_RX_IRQ, tc_dma_rx_interrupt, 0,
3660                   "ETRAX 100LX built-in USB (Rx)", hcd)) {
3661     err("Could not allocate IRQ %d for USB", ETRAX_USB_RX_IRQ);
3662     return -EBUSY;
3663   }
3664
3665   if (request_irq(ETRAX_USB_TX_IRQ, tc_dma_tx_interrupt, 0,
3666                   "ETRAX 100LX built-in USB (Tx)", hcd)) {
3667     err("Could not allocate IRQ %d for USB", ETRAX_USB_TX_IRQ);
3668     return -EBUSY;
3669   }
3670
3671   return 0;
3672 }
3673
3674 static void tc_dma_destroy(void) {
3675   free_irq(ETRAX_USB_RX_IRQ, NULL);
3676   free_irq(ETRAX_USB_TX_IRQ, NULL);
3677
3678   cris_free_dma(USB_TX_DMA_NBR, "ETRAX 100LX built-in USB (Tx)");
3679   cris_free_dma(USB_RX_DMA_NBR, "ETRAX 100LX built-in USB (Rx)");
3680
3681 }
3682
3683 static void tc_dma_link_intr_urb(struct urb *urb);
3684
3685 /* Handle processing of Bulk, Ctrl and Intr queues */
3686 static void tc_dma_process_queue(int epid) {
3687   struct urb *urb;
3688   struct crisv10_urb_priv *urb_priv;
3689   unsigned long flags;
3690   char toggle;
3691
3692   if(epid_state[epid].disabled) {
3693     /* Don't process any URBs on a disabled endpoint */
3694     return;
3695   }
3696
3697   /* Do not disturb us while fiddling with EPs and epids */
3698   local_irq_save(flags);
3699
3700   /* For bulk, Ctrl and Intr can we only have one URB active at a time for
3701      a specific EP. */
3702   if(activeUrbList[epid] != NULL) {
3703     /* An URB is already active on EP, skip checking queue */
3704     local_irq_restore(flags);
3705     return;
3706   }
3707
3708   urb = urb_list_first(epid);
3709   if(urb == NULL) {
3710     /* No URB waiting in EP queue. Nothing do to */
3711     local_irq_restore(flags);
3712     return;
3713   }
3714
3715   urb_priv = urb->hcpriv;
3716   ASSERT(urb_priv != NULL);
3717   ASSERT(urb_priv->urb_state == NOT_STARTED);
3718   ASSERT(!usb_pipeisoc(urb->pipe));
3719
3720   /* Remove this URB from the queue and move it to active */
3721   activeUrbList[epid] = urb;
3722   urb_list_del(urb, epid);
3723
3724   urb_priv->urb_state = STARTED;
3725
3726   /* Reset error counters (regardless of which direction this traffic is). */
3727   etrax_epid_clear_error(epid);
3728
3729   /* Special handling of Intr EP lists */
3730   if(usb_pipeint(urb->pipe)) {
3731     tc_dma_link_intr_urb(urb);
3732     local_irq_restore(flags);
3733     return;
3734   }
3735
3736   /* Software must preset the toggle bits for Bulk and Ctrl */
3737   if(usb_pipecontrol(urb->pipe)) {
3738     /* Toggle bits are initialized only during setup transaction in a
3739        CTRL transfer */
3740     etrax_epid_set_toggle(epid, 0, 0);
3741     etrax_epid_set_toggle(epid, 1, 0);
3742   } else {
3743     toggle = usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe),
3744                            usb_pipeout(urb->pipe));
3745     etrax_epid_set_toggle(epid, usb_pipeout(urb->pipe), toggle);
3746   }
3747
3748   tc_dbg("Added SBs from (URB:0x%x %s %s) to epid %d: %s\n",
3749          (unsigned int)urb, str_dir(urb->pipe), str_type(urb->pipe), epid,
3750          sblist_to_str(urb_priv->first_sb));
3751
3752   /* We start the DMA sub channel without checking if it's running or not,
3753      because:
3754      1) If it's already running, issuing the start command is a nop.
3755      2) We avoid a test-and-set race condition. */
3756   switch(usb_pipetype(urb->pipe)) {
3757   case PIPE_BULK:
3758     /* Assert that the EP descriptor is disabled. */
3759     ASSERT(!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)));
3760
3761     /* Set up and enable the EP descriptor. */
3762     TxBulkEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
3763     TxBulkEPList[epid].hw_len = 0;
3764     TxBulkEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
3765
3766     /* Check if the dummy list is already with us (if several urbs were queued). */
3767     if (usb_pipein(urb->pipe) && (TxBulkEPList[epid].next != virt_to_phys(&TxBulkDummyEPList[epid][0]))) {
3768       tc_dbg("Inviting dummy list to the party for urb 0x%lx, epid %d",
3769              (unsigned long)urb, epid);
3770
3771       /* We don't need to check if the DMA is at this EP or not before changing the
3772          next pointer, since we will do it in one 32-bit write (EP descriptors are
3773          32-bit aligned). */
3774       TxBulkEPList[epid].next = virt_to_phys(&TxBulkDummyEPList[epid][0]);
3775     }
3776
3777     restart_dma8_sub0();
3778
3779     /* Update/restart the bulk start timer since we just started the channel.*/
3780     mod_timer(&bulk_start_timer, jiffies + BULK_START_TIMER_INTERVAL);
3781     /* Update/restart the bulk eot timer since we just inserted traffic. */
3782     mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
3783     break;
3784   case PIPE_CONTROL:
3785     /* Assert that the EP descriptor is disabled. */
3786     ASSERT(!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)));
3787
3788     /* Set up and enable the EP descriptor. */
3789     TxCtrlEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
3790     TxCtrlEPList[epid].hw_len = 0;
3791     TxCtrlEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
3792
3793     *R_DMA_CH8_SUB1_CMD = IO_STATE(R_DMA_CH8_SUB1_CMD, cmd, start);
3794     break;
3795   }
3796   local_irq_restore(flags);
3797 }
3798
3799 static void tc_dma_link_intr_urb(struct urb *urb) {
3800   struct crisv10_urb_priv *urb_priv = urb->hcpriv;
3801   volatile struct USB_EP_Desc *tmp_ep;
3802   struct USB_EP_Desc *ep_desc;
3803   int i = 0, epid;
3804   int pool_idx = 0;
3805
3806   ASSERT(urb_priv != NULL);
3807   epid = urb_priv->epid;
3808   ASSERT(urb_priv->interval > 0);
3809   ASSERT(urb_priv->intr_ep_pool_length > 0);
3810
3811   tmp_ep = &TxIntrEPList[0];
3812
3813   /* Only insert one EP descriptor in list for Out Intr URBs.
3814      We can only handle Out Intr with interval of 128ms because
3815      it's not possible to insert several Out Intr EPs because they
3816      are not consumed by the DMA. */
3817   if(usb_pipeout(urb->pipe)) {
3818     ep_desc = urb_priv->intr_ep_pool[0];
3819     ASSERT(ep_desc);
3820     ep_desc->next = tmp_ep->next;
3821     tmp_ep->next = virt_to_phys(ep_desc);
3822     i++;
3823   } else {
3824     /* Loop through Intr EP descriptor list and insert EP for URB at
3825        specified interval */
3826     do {
3827       /* Each EP descriptor with eof flag sat signals a new frame */
3828       if (tmp_ep->command & IO_MASK(USB_EP_command, eof)) {
3829         /* Insert a EP from URBs EP pool at correct interval */
3830         if ((i % urb_priv->interval) == 0) {
3831           ep_desc = urb_priv->intr_ep_pool[pool_idx];
3832           ASSERT(ep_desc);
3833           ep_desc->next = tmp_ep->next;
3834           tmp_ep->next = virt_to_phys(ep_desc);
3835           pool_idx++;
3836           ASSERT(pool_idx <= urb_priv->intr_ep_pool_length);
3837         }
3838         i++;
3839       }
3840       tmp_ep = (struct USB_EP_Desc *)phys_to_virt(tmp_ep->next);
3841     } while(tmp_ep != &TxIntrEPList[0]);
3842   }
3843
3844   intr_dbg("Added SBs to intr epid %d: %s interval:%d (%d EP)\n", epid,
3845            sblist_to_str(urb_priv->first_sb), urb_priv->interval, pool_idx);
3846
3847   /* We start the DMA sub channel without checking if it's running or not,
3848      because:
3849      1) If it's already running, issuing the start command is a nop.
3850      2) We avoid a test-and-set race condition. */
3851   *R_DMA_CH8_SUB2_CMD = IO_STATE(R_DMA_CH8_SUB2_CMD, cmd, start);
3852 }
3853
3854 static void tc_dma_process_isoc_urb(struct urb *urb) {
3855   unsigned long flags;
3856   struct crisv10_urb_priv *urb_priv = urb->hcpriv;
3857   int epid;
3858
3859   /* Do not disturb us while fiddling with EPs and epids */
3860   local_irq_save(flags);
3861
3862   ASSERT(urb_priv);
3863   ASSERT(urb_priv->first_sb);
3864   epid = urb_priv->epid;
3865
3866   if(activeUrbList[epid] == NULL) {
3867     /* EP is idle, so make this URB active */
3868     activeUrbList[epid] = urb;
3869     urb_list_del(urb, epid);
3870     ASSERT(TxIsocEPList[epid].sub == 0);
3871     ASSERT(!(TxIsocEPList[epid].command &
3872              IO_STATE(USB_EP_command, enable, yes)));
3873
3874     /* Differentiate between In and Out Isoc. Because In SBs are not consumed*/
3875     if(usb_pipein(urb->pipe)) {
3876     /* Each EP for In Isoc will have only one SB descriptor, setup when
3877        submitting the first active urb. We do it here by copying from URBs
3878        pre-allocated SB. */
3879       memcpy((void *)&(TxIsocSBList[epid]), urb_priv->first_sb,
3880              sizeof(TxIsocSBList[epid]));
3881       TxIsocEPList[epid].hw_len = 0;
3882       TxIsocEPList[epid].sub = virt_to_phys(&(TxIsocSBList[epid]));
3883     } else {
3884       /* For Out Isoc we attach the pre-allocated list of SBs for the URB */
3885       TxIsocEPList[epid].hw_len = 0;
3886       TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
3887
3888       isoc_dbg("Attached first URB:0x%x[%d] to epid:%d first_sb:0x%x"
3889                " last_sb::0x%x\n",
3890                (unsigned int)urb, urb_priv->urb_num, epid,
3891                (unsigned int)(urb_priv->first_sb),
3892                (unsigned int)(urb_priv->last_sb));
3893     }
3894
3895     if (urb->transfer_flags & URB_ISO_ASAP) {
3896       /* The isoc transfer should be started as soon as possible. The
3897          start_frame field is a return value if URB_ISO_ASAP was set. Comparing
3898          R_USB_FM_NUMBER with a USB Chief trace shows that the first isoc IN
3899          token is sent 2 frames later. I'm not sure how this affects usage of
3900          the start_frame field by the device driver, or how it affects things
3901          when USB_ISO_ASAP is not set, so therefore there's no compensation for
3902          the 2 frame "lag" here. */
3903       urb->start_frame = (*R_USB_FM_NUMBER & 0x7ff);
3904       TxIsocEPList[epid].command |= IO_STATE(USB_EP_command, enable, yes);
3905       urb_priv->urb_state = STARTED;
3906       isoc_dbg("URB_ISO_ASAP set, urb->start_frame set to %d\n",
3907                urb->start_frame);
3908     } else {
3909       /* Not started yet. */
3910       urb_priv->urb_state = NOT_STARTED;
3911       isoc_warn("urb_priv->urb_state set to NOT_STARTED for URB:0x%x\n",
3912                 (unsigned int)urb);
3913     }
3914
3915   } else {
3916     /* An URB is already active on the EP. Leave URB in queue and let
3917        finish_isoc_urb process it after current active URB */
3918     ASSERT(TxIsocEPList[epid].sub != 0);
3919
3920     if(usb_pipein(urb->pipe)) {
3921       /* Because there already is a active In URB on this epid we do nothing
3922          and the finish_isoc_urb() function will handle switching to next URB*/
3923
3924     } else { /* For Out Isoc, insert new URBs traffic last in SB-list. */
3925       struct USB_SB_Desc *temp_sb_desc;
3926
3927       /* Set state STARTED to all Out Isoc URBs added to SB list because we
3928          don't know how many of them that are finished before descr interrupt*/
3929       urb_priv->urb_state = STARTED;
3930
3931       /* Find end of current SB list by looking for SB with eol flag sat */
3932       temp_sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
3933       while ((temp_sb_desc->command & IO_MASK(USB_SB_command, eol)) !=
3934              IO_STATE(USB_SB_command, eol, yes)) {
3935         ASSERT(temp_sb_desc->next);
3936         temp_sb_desc = phys_to_virt(temp_sb_desc->next);
3937       }
3938
3939       isoc_dbg("Appended URB:0x%x[%d] (first:0x%x last:0x%x) to epid:%d"
3940                " sub:0x%x eol:0x%x\n",
3941                (unsigned int)urb, urb_priv->urb_num,
3942                (unsigned int)(urb_priv->first_sb),
3943                (unsigned int)(urb_priv->last_sb), epid,
3944                (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
3945                (unsigned int)temp_sb_desc);
3946
3947       /* Next pointer must be set before eol is removed. */
3948       temp_sb_desc->next = virt_to_phys(urb_priv->first_sb);
3949       /* Clear the previous end of list flag since there is a new in the
3950          added SB descriptor list. */
3951       temp_sb_desc->command &= ~IO_MASK(USB_SB_command, eol);
3952
3953       if (!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
3954         __u32 epid_data;
3955         /* 8.8.5 in Designer's Reference says we should check for and correct
3956            any errors in the EP here.  That should not be necessary if
3957            epid_attn is handled correctly, so we assume all is ok. */
3958         epid_data = etrax_epid_iso_get(epid);
3959         if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) !=
3960             IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
3961           isoc_err("Disabled Isoc EP with error:%d on epid:%d when appending"
3962                    " URB:0x%x[%d]\n",
3963                    IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data), epid,
3964                    (unsigned int)urb, urb_priv->urb_num);
3965         }
3966
3967         /* The SB list was exhausted. */
3968         if (virt_to_phys(urb_priv->last_sb) != TxIsocEPList[epid].sub) {
3969           /* The new sublist did not get processed before the EP was
3970              disabled.  Setup the EP again. */
3971
3972           if(virt_to_phys(temp_sb_desc) == TxIsocEPList[epid].sub) {
3973             isoc_dbg("EP for epid:%d stoped at SB:0x%x before newly inserted"
3974                      ", restarting from this URBs SB:0x%x\n",
3975                      epid, (unsigned int)temp_sb_desc,
3976                      (unsigned int)(urb_priv->first_sb));
3977             TxIsocEPList[epid].hw_len = 0;
3978             TxIsocEPList[epid].sub = virt_to_phys(urb_priv->first_sb);
3979             urb->start_frame = (*R_USB_FM_NUMBER & 0x7ff);
3980             /* Enable the EP again so data gets processed this time */
3981             TxIsocEPList[epid].command |=
3982               IO_STATE(USB_EP_command, enable, yes);
3983
3984           } else {
3985             /* The EP has been disabled but not at end this URB (god knows
3986                where). This should generate an epid_attn so we should not be
3987                here */
3988             isoc_warn("EP was disabled on sb:0x%x before SB list for"
3989                      " URB:0x%x[%d] got processed\n",
3990                      (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
3991                      (unsigned int)urb, urb_priv->urb_num);
3992           }
3993         } else {
3994           /* This might happend if we are slow on this function and isn't
3995              an error. */
3996           isoc_dbg("EP was disabled and finished with SBs from appended"
3997                    " URB:0x%x[%d]\n", (unsigned int)urb, urb_priv->urb_num);
3998         }
3999       }
4000     }
4001   }
4002
4003   /* Start the DMA sub channel */
4004   *R_DMA_CH8_SUB3_CMD = IO_STATE(R_DMA_CH8_SUB3_CMD, cmd, start);
4005
4006   local_irq_restore(flags);
4007 }
4008
4009 static void tc_dma_unlink_intr_urb(struct urb *urb) {
4010   struct crisv10_urb_priv *urb_priv = urb->hcpriv;
4011   volatile struct USB_EP_Desc *first_ep;  /* First EP in the list. */
4012   volatile struct USB_EP_Desc *curr_ep;   /* Current EP, the iterator. */
4013   volatile struct USB_EP_Desc *next_ep;   /* The EP after current. */
4014   volatile struct USB_EP_Desc *unlink_ep; /* The one we should remove from
4015                                              the list. */
4016   int count = 0;
4017   volatile int timeout = 10000;
4018   int epid;
4019
4020   /* Read 8.8.4 in Designer's Reference, "Removing an EP Descriptor from the
4021      List". */
4022   ASSERT(urb_priv);
4023   ASSERT(urb_priv->intr_ep_pool_length > 0);
4024   epid = urb_priv->epid;
4025
4026   /* First disable all Intr EPs belonging to epid for this URB */
4027   first_ep = &TxIntrEPList[0];
4028   curr_ep = first_ep;
4029   do {
4030     next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
4031     if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
4032       /* Disable EP */
4033       next_ep->command &= ~IO_MASK(USB_EP_command, enable);
4034     }
4035     curr_ep = phys_to_virt(curr_ep->next);
4036   } while (curr_ep != first_ep);
4037
4038
4039   /* Now unlink all EPs belonging to this epid from Descr list */
4040   first_ep = &TxIntrEPList[0];
4041   curr_ep = first_ep;
4042   do {
4043     next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
4044     if (IO_EXTRACT(USB_EP_command, epid, next_ep->command) == epid) {
4045       /* This is the one we should unlink. */
4046       unlink_ep = next_ep;
4047
4048       /* Actually unlink the EP from the DMA list. */
4049       curr_ep->next = unlink_ep->next;
4050
4051       /* Wait until the DMA is no longer at this descriptor. */
4052       while((*R_DMA_CH8_SUB2_EP == virt_to_phys(unlink_ep)) &&
4053             (timeout-- > 0));
4054       if(timeout == 0) {
4055         warn("Timeout while waiting for DMA-TX-Intr to leave unlink EP\n");
4056       }
4057
4058       count++;
4059     }
4060     curr_ep = phys_to_virt(curr_ep->next);
4061   } while (curr_ep != first_ep);
4062
4063   if(count != urb_priv->intr_ep_pool_length) {
4064     intr_warn("Unlinked %d of %d Intr EPs for URB:0x%x[%d]\n", count,
4065               urb_priv->intr_ep_pool_length, (unsigned int)urb,
4066               urb_priv->urb_num);
4067   } else {
4068     intr_dbg("Unlinked %d of %d interrupt EPs for URB:0x%x\n", count,
4069              urb_priv->intr_ep_pool_length, (unsigned int)urb);
4070   }
4071 }
4072
4073 static void check_finished_bulk_tx_epids(struct usb_hcd *hcd,
4074                                                     int timer) {
4075   unsigned long flags;
4076   int epid;
4077   struct urb *urb;
4078   struct crisv10_urb_priv * urb_priv;
4079   __u32 epid_data;
4080
4081   /* Protect TxEPList */
4082   local_irq_save(flags);
4083
4084   for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
4085     /* A finished EP descriptor is disabled and has a valid sub pointer */
4086     if (!(TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) &&
4087         (TxBulkEPList[epid].sub != 0)) {
4088
4089       /* Get the active URB for this epid */
4090       urb = activeUrbList[epid];
4091       /* Sanity checks */
4092       ASSERT(urb);
4093       urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4094       ASSERT(urb_priv);
4095
4096       /* Only handle finished out Bulk EPs here,
4097          and let RX interrupt take care of the rest */
4098       if(!epid_out_traffic(epid)) {
4099         continue;
4100       }
4101
4102       if(timer) {
4103         tc_warn("Found finished %s Bulk epid:%d URB:0x%x[%d] from timeout\n",
4104                 epid_out_traffic(epid) ? "Out" : "In", epid, (unsigned int)urb,
4105                 urb_priv->urb_num);
4106       } else {
4107         tc_dbg("Found finished %s Bulk epid:%d URB:0x%x[%d] from interrupt\n",
4108                epid_out_traffic(epid) ? "Out" : "In", epid, (unsigned int)urb,
4109                urb_priv->urb_num);
4110       }
4111
4112       if(urb_priv->urb_state == UNLINK) {
4113         /* This Bulk URB is requested to be unlinked, that means that the EP
4114            has been disabled and we might not have sent all data */
4115         tc_finish_urb(hcd, urb, urb->status);
4116         continue;
4117       }
4118
4119       ASSERT(urb_priv->urb_state == STARTED);
4120       if (phys_to_virt(TxBulkEPList[epid].sub) != urb_priv->last_sb) {
4121         tc_err("Endpoint got disabled before reaching last sb\n");
4122       }
4123
4124       epid_data = etrax_epid_get(epid);
4125       if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) ==
4126           IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
4127         /* This means that the endpoint has no error, is disabled
4128            and had inserted traffic, i.e. transfer successfully completed. */
4129         tc_finish_urb(hcd, urb, 0);
4130       } else {
4131         /* Shouldn't happen. We expect errors to be caught by epid
4132            attention. */
4133         tc_err("Found disabled bulk EP desc (epid:%d error:%d)\n",
4134                epid, IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data));
4135       }
4136     } else {
4137       tc_dbg("Ignoring In Bulk epid:%d, let RX interrupt handle it\n", epid);
4138     }
4139   }
4140
4141   local_irq_restore(flags);
4142 }
4143
4144 static void check_finished_ctrl_tx_epids(struct usb_hcd *hcd) {
4145   unsigned long flags;
4146   int epid;
4147   struct urb *urb;
4148   struct crisv10_urb_priv * urb_priv;
4149   __u32 epid_data;
4150
4151   /* Protect TxEPList */
4152   local_irq_save(flags);
4153
4154   for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
4155     if(epid == DUMMY_EPID)
4156       continue;
4157
4158     /* A finished EP descriptor is disabled and has a valid sub pointer */
4159     if (!(TxCtrlEPList[epid].command & IO_MASK(USB_EP_command, enable)) &&
4160         (TxCtrlEPList[epid].sub != 0)) {
4161
4162       /* Get the active URB for this epid */
4163       urb = activeUrbList[epid];
4164
4165       if(urb == NULL) {
4166         tc_warn("Found finished Ctrl epid:%d with no active URB\n", epid);
4167         continue;
4168       }
4169
4170       /* Sanity checks */
4171       ASSERT(usb_pipein(urb->pipe));
4172       urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4173       ASSERT(urb_priv);
4174       if (phys_to_virt(TxCtrlEPList[epid].sub) != urb_priv->last_sb) {
4175         tc_err("Endpoint got disabled before reaching last sb\n");
4176       }
4177
4178       epid_data = etrax_epid_get(epid);
4179       if (IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data) ==
4180           IO_STATE_VALUE(R_USB_EPT_DATA, error_code, no_error)) {
4181         /* This means that the endpoint has no error, is disabled
4182            and had inserted traffic, i.e. transfer successfully completed. */
4183
4184         /* Check if RX-interrupt for In Ctrl has been processed before
4185            finishing the URB */
4186         if(urb_priv->ctrl_rx_done) {
4187           tc_dbg("Finishing In Ctrl URB:0x%x[%d] in tx_interrupt\n",
4188                  (unsigned int)urb, urb_priv->urb_num);
4189           tc_finish_urb(hcd, urb, 0);
4190         } else {
4191           /* If we get zout descriptor interrupt before RX was done for a
4192              In Ctrl transfer, then we flag that and it will be finished
4193              in the RX-Interrupt */
4194           urb_priv->ctrl_zout_done = 1;
4195           tc_dbg("Got zout descr interrupt before RX interrupt\n");
4196         }
4197       } else {
4198         /* Shouldn't happen. We expect errors to be caught by epid
4199            attention. */
4200         tc_err("Found disabled Ctrl EP desc (epid:%d URB:0x%x[%d]) error_code:%d\n", epid, (unsigned int)urb, urb_priv->urb_num, IO_EXTRACT(R_USB_EPT_DATA, error_code, epid_data));
4201         __dump_ep_desc(&(TxCtrlEPList[epid]));
4202         __dump_ept_data(epid);
4203       }
4204     }
4205   }
4206   local_irq_restore(flags);
4207 }
4208
4209 /* This function goes through all epids that are setup for Out Isoc transfers
4210    and marks (isoc_out_done) all queued URBs that the DMA has finished
4211    transfer for.
4212    No URB completetion is done here to make interrupt routine return quickly.
4213    URBs are completed later with help of complete_isoc_bottom_half() that
4214    becomes schedules when this functions is finished. */
4215 static void check_finished_isoc_tx_epids(void) {
4216   unsigned long flags;
4217   int epid;
4218   struct urb *urb;
4219   struct crisv10_urb_priv * urb_priv;
4220   struct USB_SB_Desc* sb_desc;
4221   int epid_done;
4222
4223   /* Protect TxIsocEPList */
4224   local_irq_save(flags);
4225
4226   for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
4227     if (TxIsocEPList[epid].sub == 0 || epid == INVALID_EPID ||
4228         !epid_out_traffic(epid)) {
4229       /* Nothing here to see. */
4230       continue;
4231     }
4232     ASSERT(epid_inuse(epid));
4233     ASSERT(epid_isoc(epid));
4234
4235     sb_desc = phys_to_virt(TxIsocEPList[epid].sub);
4236     /* Find the last descriptor of the currently active URB for this ep.
4237        This is the first descriptor in the sub list marked for a descriptor
4238        interrupt. */
4239     while (sb_desc && !IO_EXTRACT(USB_SB_command, intr, sb_desc->command)) {
4240       sb_desc = sb_desc->next ? phys_to_virt(sb_desc->next) : 0;
4241     }
4242     ASSERT(sb_desc);
4243
4244     isoc_dbg("Descr IRQ checking epid:%d sub:0x%x intr:0x%x\n",
4245              epid, (unsigned int)phys_to_virt(TxIsocEPList[epid].sub),
4246              (unsigned int)sb_desc);
4247
4248     urb = activeUrbList[epid];
4249     if(urb == NULL) {
4250       isoc_err("Isoc Descr irq on epid:%d with no active URB\n", epid);
4251       continue;
4252     }
4253
4254     epid_done = 0;
4255     while(urb && !epid_done) {
4256       /* Sanity check. */
4257       ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
4258       ASSERT(usb_pipeout(urb->pipe));
4259
4260       urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4261       ASSERT(urb_priv);
4262       ASSERT(urb_priv->urb_state == STARTED ||
4263              urb_priv->urb_state == UNLINK);
4264
4265       if (sb_desc != urb_priv->last_sb) {
4266         /* This urb has been sent. */
4267         urb_priv->isoc_out_done = 1;
4268
4269       } else { /* Found URB that has last_sb as the interrupt reason */
4270
4271         /* Check if EP has been disabled, meaning that all transfers are done*/
4272         if(!(TxIsocEPList[epid].command & IO_MASK(USB_EP_command, enable))) {
4273           ASSERT((sb_desc->command & IO_MASK(USB_SB_command, eol)) ==
4274                  IO_STATE(USB_SB_command, eol, yes));
4275           ASSERT(sb_desc->next == 0);
4276           urb_priv->isoc_out_done = 1;
4277         } else {
4278           isoc_dbg("Skipping URB:0x%x[%d] because EP not disabled yet\n",
4279                    (unsigned int)urb, urb_priv->urb_num);
4280         }
4281         /* Stop looking any further in queue */
4282         epid_done = 1;
4283       }
4284
4285       if (!epid_done) {
4286         if(urb == activeUrbList[epid]) {
4287           urb = urb_list_first(epid);
4288         } else {
4289           urb = urb_list_next(urb, epid);
4290         }
4291       }
4292     } /* END: while(urb && !epid_done) */
4293   }
4294
4295   local_irq_restore(flags);
4296 }
4297
4298
4299 /* This is where the Out Isoc URBs are realy completed. This function is
4300    scheduled from tc_dma_tx_interrupt() when one or more Out Isoc transfers
4301    are done. This functions completes all URBs earlier marked with
4302    isoc_out_done by fast interrupt routine check_finished_isoc_tx_epids() */
4303
4304 static void complete_isoc_bottom_half(struct work_struct* work) {
4305   struct crisv10_isoc_complete_data *comp_data;
4306   struct usb_iso_packet_descriptor *packet;
4307   struct crisv10_urb_priv * urb_priv;
4308   unsigned long flags;
4309   struct urb* urb;
4310   int epid_done;
4311   int epid;
4312   int i;
4313
4314   comp_data = container_of(work, struct crisv10_isoc_complete_data, usb_bh);
4315
4316   local_irq_save(flags);
4317
4318   for (epid = 0; epid < NBR_OF_EPIDS - 1; epid++) {
4319     if(!epid_inuse(epid) || !epid_isoc(epid) || !epid_out_traffic(epid) || epid == DUMMY_EPID) {
4320       /* Only check valid Out Isoc epids */
4321       continue;
4322     }
4323
4324     isoc_dbg("Isoc bottom-half checking epid:%d, sub:0x%x\n", epid,
4325              (unsigned int)phys_to_virt(TxIsocEPList[epid].sub));
4326
4327     /* The descriptor interrupt handler has marked all transmitted Out Isoc
4328        URBs with isoc_out_done.  Now we traverse all epids and for all that
4329        have out Isoc traffic we traverse its URB list and complete the
4330        transmitted URBs. */
4331     epid_done = 0;
4332     while (!epid_done) {
4333
4334       /* Get the active urb (if any) */
4335       urb = activeUrbList[epid];
4336       if (urb == 0) {
4337         isoc_dbg("No active URB on epid:%d anymore\n", epid);
4338         epid_done = 1;
4339         continue;
4340       }
4341
4342       /* Sanity check. */
4343       ASSERT(usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS);
4344       ASSERT(usb_pipeout(urb->pipe));
4345
4346       urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4347       ASSERT(urb_priv);
4348
4349       if (!(urb_priv->isoc_out_done)) {
4350         /* We have reached URB that isn't flaged done yet, stop traversing. */
4351         isoc_dbg("Stoped traversing Out Isoc URBs on epid:%d"
4352                  " before not yet flaged URB:0x%x[%d]\n",
4353                  epid, (unsigned int)urb, urb_priv->urb_num);
4354         epid_done = 1;
4355         continue;
4356       }
4357
4358       /* This urb has been sent. */
4359       isoc_dbg("Found URB:0x%x[%d] that is flaged isoc_out_done\n",
4360                (unsigned int)urb, urb_priv->urb_num);
4361
4362       /* Set ok on transfered packets for this URB and finish it */
4363       for (i = 0; i < urb->number_of_packets; i++) {
4364         packet = &urb->iso_frame_desc[i];
4365         packet->status = 0;
4366         packet->actual_length = packet->length;
4367       }
4368       urb_priv->isoc_packet_counter = urb->number_of_packets;
4369       tc_finish_urb(comp_data->hcd, urb, 0);
4370
4371     } /* END: while(!epid_done) */
4372   } /* END: for(epid...) */
4373
4374   local_irq_restore(flags);
4375   kmem_cache_free(isoc_compl_cache, comp_data);
4376 }
4377
4378
4379 static void check_finished_intr_tx_epids(struct usb_hcd *hcd) {
4380   unsigned long flags;
4381   int epid;
4382   struct urb *urb;
4383   struct crisv10_urb_priv * urb_priv;
4384   volatile struct USB_EP_Desc *curr_ep;   /* Current EP, the iterator. */
4385   volatile struct USB_EP_Desc *next_ep;   /* The EP after current. */
4386
4387   /* Protect TxintrEPList */
4388   local_irq_save(flags);
4389
4390   for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
4391     if(!epid_inuse(epid) || !epid_intr(epid) || !epid_out_traffic(epid)) {
4392       /* Nothing to see on this epid. Only check valid Out Intr epids */
4393       continue;
4394     }
4395
4396     urb = activeUrbList[epid];
4397     if(urb == 0) {
4398       intr_warn("Found Out Intr epid:%d with no active URB\n", epid);
4399       continue;
4400     }
4401
4402     /* Sanity check. */
4403     ASSERT(usb_pipetype(urb->pipe) == PIPE_INTERRUPT);
4404     ASSERT(usb_pipeout(urb->pipe));
4405
4406     urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4407     ASSERT(urb_priv);
4408
4409     /* Go through EPs between first and second sof-EP. It's here Out Intr EPs
4410        are inserted.*/
4411     curr_ep = &TxIntrEPList[0];
4412     do {
4413       next_ep = (struct USB_EP_Desc *)phys_to_virt(curr_ep->next);
4414       if(next_ep == urb_priv->intr_ep_pool[0]) {
4415         /* We found the Out Intr EP for this epid */
4416
4417         /* Disable it so it doesn't get processed again */
4418         next_ep->command &= ~IO_MASK(USB_EP_command, enable);
4419
4420         /* Finish the active Out Intr URB with status OK */
4421         tc_finish_urb(hcd, urb, 0);
4422       }
4423       curr_ep = phys_to_virt(curr_ep->next);
4424     } while (curr_ep != &TxIntrEPList[1]);
4425
4426   }
4427   local_irq_restore(flags);
4428 }
4429
4430 /* Interrupt handler for DMA8/IRQ24 with subchannels (called from hardware intr) */
4431 static irqreturn_t tc_dma_tx_interrupt(int irq, void *vhc) {
4432   struct usb_hcd *hcd = (struct usb_hcd*)vhc;
4433   ASSERT(hcd);
4434
4435   if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub0_descr)) {
4436     /* Clear this interrupt */
4437     *R_DMA_CH8_SUB0_CLR_INTR = IO_STATE(R_DMA_CH8_SUB0_CLR_INTR, clr_descr, do);
4438     restart_dma8_sub0();
4439   }
4440
4441   if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub1_descr)) {
4442     /* Clear this interrupt */
4443     *R_DMA_CH8_SUB1_CLR_INTR = IO_STATE(R_DMA_CH8_SUB1_CLR_INTR, clr_descr, do);
4444     check_finished_ctrl_tx_epids(hcd);
4445   }
4446
4447   if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub2_descr)) {
4448     /* Clear this interrupt */
4449     *R_DMA_CH8_SUB2_CLR_INTR = IO_STATE(R_DMA_CH8_SUB2_CLR_INTR, clr_descr, do);
4450     check_finished_intr_tx_epids(hcd);
4451   }
4452
4453   if (*R_IRQ_READ2 & IO_MASK(R_IRQ_READ2, dma8_sub3_descr)) {
4454     struct crisv10_isoc_complete_data* comp_data;
4455
4456     /* Flag done Out Isoc for later completion */
4457     check_finished_isoc_tx_epids();
4458
4459     /* Clear this interrupt */
4460     *R_DMA_CH8_SUB3_CLR_INTR = IO_STATE(R_DMA_CH8_SUB3_CLR_INTR, clr_descr, do);
4461     /* Schedule bottom half of Out Isoc completion function. This function
4462        finishes the URBs marked with isoc_out_done */
4463     comp_data = (struct crisv10_isoc_complete_data*)
4464       kmem_cache_alloc(isoc_compl_cache, GFP_ATOMIC);
4465     ASSERT(comp_data != NULL);
4466     comp_data ->hcd = hcd;
4467
4468     INIT_WORK(&comp_data->usb_bh, complete_isoc_bottom_half);
4469     schedule_work(&comp_data->usb_bh);
4470   }
4471
4472   return IRQ_HANDLED;
4473 }
4474
4475 /* Interrupt handler for DMA9/IRQ25 (called from hardware intr) */
4476 static irqreturn_t tc_dma_rx_interrupt(int irq, void *vhc) {
4477   unsigned long flags;
4478   struct urb *urb;
4479   struct usb_hcd *hcd = (struct usb_hcd*)vhc;
4480   struct crisv10_urb_priv *urb_priv;
4481   int epid = 0;
4482   int real_error;
4483
4484   ASSERT(hcd);
4485
4486   /* Clear this interrupt. */
4487   *R_DMA_CH9_CLR_INTR = IO_STATE(R_DMA_CH9_CLR_INTR, clr_eop, do);
4488
4489   /* Custom clear interrupt for this interrupt */
4490   /* The reason we cli here is that we call the driver's callback functions. */
4491   local_irq_save(flags);
4492
4493   /* Note that this while loop assumes that all packets span only
4494      one rx descriptor. */
4495   while(myNextRxDesc->status & IO_MASK(USB_IN_status, eop)) {
4496     epid = IO_EXTRACT(USB_IN_status, epid, myNextRxDesc->status);
4497     /* Get the active URB for this epid */
4498     urb = activeUrbList[epid];
4499
4500     ASSERT(epid_inuse(epid));
4501     if (!urb) {
4502       dma_err("No urb for epid %d in rx interrupt\n", epid);
4503       goto skip_out;
4504     }
4505
4506     /* Check if any errors on epid */
4507     real_error = 0;
4508     if (myNextRxDesc->status & IO_MASK(USB_IN_status, error)) {
4509       __u32 r_usb_ept_data;
4510
4511       if (usb_pipeisoc(urb->pipe)) {
4512         r_usb_ept_data = etrax_epid_iso_get(epid);
4513         if((r_usb_ept_data & IO_MASK(R_USB_EPT_DATA_ISO, valid)) &&
4514            (IO_EXTRACT(R_USB_EPT_DATA_ISO, error_code, r_usb_ept_data) == 0) &&
4515            (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata))) {
4516           /* Not an error, just a failure to receive an expected iso
4517              in packet in this frame.  This is not documented
4518              in the designers reference. Continue processing.
4519           */
4520         } else real_error = 1;
4521       } else real_error = 1;
4522     }
4523
4524     if(real_error) {
4525       dma_err("Error in RX descr on epid:%d for URB 0x%x",
4526               epid, (unsigned int)urb);
4527       dump_ept_data(epid);
4528       dump_in_desc(myNextRxDesc);
4529       goto skip_out;
4530     }
4531
4532     urb_priv = (struct crisv10_urb_priv *)urb->hcpriv;
4533     ASSERT(urb_priv);
4534     ASSERT(urb_priv->urb_state == STARTED ||
4535            urb_priv->urb_state == UNLINK);
4536
4537     if ((usb_pipetype(urb->pipe) == PIPE_BULK) ||
4538         (usb_pipetype(urb->pipe) == PIPE_CONTROL) ||
4539         (usb_pipetype(urb->pipe) == PIPE_INTERRUPT)) {
4540
4541       /* We get nodata for empty data transactions, and the rx descriptor's
4542          hw_len field is not valid in that case. No data to copy in other
4543          words. */
4544       if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
4545         /* No data to copy */
4546       } else {
4547         /*
4548         dma_dbg("Processing RX for URB:0x%x epid:%d (data:%d ofs:%d)\n",
4549                 (unsigned int)urb, epid, myNextRxDesc->hw_len,
4550                 urb_priv->rx_offset);
4551         */
4552         /* Only copy data if URB isn't flaged to be unlinked*/
4553         if(urb_priv->urb_state != UNLINK) {
4554           /* Make sure the data fits in the buffer. */
4555           if(urb_priv->rx_offset + myNextRxDesc->hw_len
4556              <= urb->transfer_buffer_length) {
4557
4558             /* Copy the data to URBs buffer */
4559             memcpy(urb->transfer_buffer + urb_priv->rx_offset,
4560                    phys_to_virt(myNextRxDesc->buf), myNextRxDesc->hw_len);
4561             urb_priv->rx_offset += myNextRxDesc->hw_len;
4562           } else {
4563             /* Signal overflow when returning URB */
4564             urb->status = -EOVERFLOW;
4565             tc_finish_urb_later(hcd, urb, urb->status);
4566           }
4567         }
4568       }
4569
4570       /* Check if it was the last packet in the transfer */
4571       if (myNextRxDesc->status & IO_MASK(USB_IN_status, eot)) {
4572         /* Special handling for In Ctrl URBs. */
4573         if(usb_pipecontrol(urb->pipe) && usb_pipein(urb->pipe) &&
4574            !(urb_priv->ctrl_zout_done)) {
4575           /* Flag that RX part of Ctrl transfer is done. Because zout descr
4576              interrupt hasn't happend yet will the URB be finished in the
4577              TX-Interrupt. */
4578           urb_priv->ctrl_rx_done = 1;
4579           tc_dbg("Not finishing In Ctrl URB:0x%x from rx_interrupt, waiting"
4580                  " for zout\n", (unsigned int)urb);
4581         } else {
4582           tc_finish_urb(hcd, urb, 0);
4583         }
4584       }
4585     } else { /* ISOC RX */
4586       /*
4587       isoc_dbg("Processing RX for epid:%d (URB:0x%x) ISOC pipe\n",
4588                epid, (unsigned int)urb);
4589       */
4590
4591       struct usb_iso_packet_descriptor *packet;
4592
4593       if (urb_priv->urb_state == UNLINK) {
4594         isoc_warn("Ignoring Isoc Rx data for urb being unlinked.\n");
4595         goto skip_out;
4596       } else if (urb_priv->urb_state == NOT_STARTED) {
4597         isoc_err("What? Got Rx data for Isoc urb that isn't started?\n");
4598         goto skip_out;
4599       }
4600
4601       packet = &urb->iso_frame_desc[urb_priv->isoc_packet_counter];
4602       ASSERT(packet);
4603       packet->status = 0;
4604
4605       if (myNextRxDesc->status & IO_MASK(USB_IN_status, nodata)) {
4606         /* We get nodata for empty data transactions, and the rx descriptor's
4607            hw_len field is not valid in that case. We copy 0 bytes however to
4608            stay in synch. */
4609         packet->actual_length = 0;
4610       } else {
4611         packet->actual_length = myNextRxDesc->hw_len;
4612         /* Make sure the data fits in the buffer. */
4613         ASSERT(packet->actual_length <= packet->length);
4614         memcpy(urb->transfer_buffer + packet->offset,
4615                phys_to_virt(myNextRxDesc->buf), packet->actual_length);
4616         if(packet->actual_length > 0)
4617           isoc_dbg("Copied %d bytes, packet %d for URB:0x%x[%d]\n",
4618                    packet->actual_length, urb_priv->isoc_packet_counter,
4619                    (unsigned int)urb, urb_priv->urb_num);
4620       }
4621
4622       /* Increment the packet counter. */
4623       urb_priv->isoc_packet_counter++;
4624
4625       /* Note that we don't care about the eot field in the rx descriptor's
4626          status. It will always be set for isoc traffic. */
4627       if (urb->number_of_packets == urb_priv->isoc_packet_counter) {
4628         /* Complete the urb with status OK. */
4629         tc_finish_urb(hcd, urb, 0);
4630       }
4631     }
4632
4633   skip_out:
4634     myNextRxDesc->status = 0;
4635     myNextRxDesc->command |= IO_MASK(USB_IN_command, eol);
4636     myLastRxDesc->command &= ~IO_MASK(USB_IN_command, eol);
4637     myLastRxDesc = myNextRxDesc;
4638     myNextRxDesc = phys_to_virt(myNextRxDesc->next);
4639     flush_etrax_cache();
4640     *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, restart);
4641   }
4642
4643   local_irq_restore(flags);
4644
4645   return IRQ_HANDLED;
4646 }
4647
4648 static void tc_bulk_start_timer_func(unsigned long dummy) {
4649   /* We might enable an EP descriptor behind the current DMA position when
4650      it's about to decide that there are no more bulk traffic and it should
4651      stop the bulk channel.
4652      Therefore we periodically check if the bulk channel is stopped and there
4653      is an enabled bulk EP descriptor, in which case we start the bulk
4654      channel. */
4655
4656   if (!(*R_DMA_CH8_SUB0_CMD & IO_MASK(R_DMA_CH8_SUB0_CMD, cmd))) {
4657     int epid;
4658
4659     timer_dbg("bulk_start_timer: Bulk DMA channel not running.\n");
4660
4661     for (epid = 0; epid < NBR_OF_EPIDS; epid++) {
4662       if (TxBulkEPList[epid].command & IO_MASK(USB_EP_command, enable)) {
4663         timer_warn("Found enabled EP for epid %d, starting bulk channel.\n",
4664                    epid);
4665         restart_dma8_sub0();
4666
4667         /* Restart the bulk eot timer since we just started the bulk channel.*/
4668         mod_timer(&bulk_eot_timer, jiffies + BULK_EOT_TIMER_INTERVAL);
4669
4670         /* No need to search any further. */
4671         break;
4672       }
4673     }
4674   } else {
4675     timer_dbg("bulk_start_timer: Bulk DMA channel running.\n");
4676   }
4677 }
4678
4679 static void tc_bulk_eot_timer_func(unsigned long dummy) {
4680   struct usb_hcd *hcd = (struct usb_hcd*)dummy;
4681   ASSERT(hcd);
4682   /* Because of a race condition in the top half, we might miss a bulk eot.
4683      This timer "simulates" a bulk eot if we don't get one for a while,
4684      hopefully correcting the situation. */
4685   timer_dbg("bulk_eot_timer timed out.\n");
4686   check_finished_bulk_tx_epids(hcd, 1);
4687 }
4688
4689
4690 /*************************************************************/
4691 /*************************************************************/
4692 /* Device driver block                                       */
4693 /*************************************************************/
4694 /*************************************************************/
4695
4696 /* Forward declarations for device driver functions */
4697 static int devdrv_hcd_probe(struct device *);
4698 static int devdrv_hcd_remove(struct device *);
4699 #ifdef CONFIG_PM
4700 static int devdrv_hcd_suspend(struct device *, u32, u32);
4701 static int devdrv_hcd_resume(struct device *, u32);
4702 #endif /* CONFIG_PM */
4703
4704 /* the device */
4705 static struct platform_device *devdrv_hc_platform_device;
4706
4707 /* device driver interface */
4708 static struct device_driver devdrv_hc_device_driver = {
4709   .name =                       (char *) hc_name,
4710   .bus =                        &platform_bus_type,
4711
4712   .probe =              devdrv_hcd_probe,
4713   .remove =             devdrv_hcd_remove,
4714
4715 #ifdef CONFIG_PM
4716   .suspend =            devdrv_hcd_suspend,
4717   .resume =             devdrv_hcd_resume,
4718 #endif /* CONFIG_PM */
4719 };
4720
4721 /* initialize the host controller and driver  */
4722 static int __init_or_module devdrv_hcd_probe(struct device *dev)
4723 {
4724   struct usb_hcd *hcd;
4725   struct crisv10_hcd *crisv10_hcd;
4726   int retval;
4727
4728   /* Check DMA burst length */
4729   if(IO_EXTRACT(R_BUS_CONFIG, dma_burst, *R_BUS_CONFIG) !=
4730      IO_STATE(R_BUS_CONFIG, dma_burst, burst32)) {
4731     devdrv_err("Invalid DMA burst length in Etrax 100LX,"
4732                " needs to be 32\n");
4733     return -EPERM;
4734   }
4735
4736   hcd = usb_create_hcd(&crisv10_hc_driver, dev, dev->bus_id);
4737   if (!hcd)
4738     return -ENOMEM;
4739
4740   crisv10_hcd = hcd_to_crisv10_hcd(hcd);
4741   spin_lock_init(&crisv10_hcd->lock);
4742   crisv10_hcd->num_ports = num_ports();
4743   crisv10_hcd->running = 0;
4744
4745   dev_set_drvdata(dev, crisv10_hcd);
4746
4747   devdrv_dbg("ETRAX USB IRQs HC:%d  RX:%d  TX:%d\n", ETRAX_USB_HC_IRQ,
4748           ETRAX_USB_RX_IRQ, ETRAX_USB_TX_IRQ);
4749
4750   /* Print out chip version read from registers */
4751   int rev_maj = *R_USB_REVISION & IO_MASK(R_USB_REVISION, major);
4752   int rev_min = *R_USB_REVISION & IO_MASK(R_USB_REVISION, minor);
4753   if(rev_min == 0) {
4754     devdrv_info("Etrax 100LX USB Revision %d v1,2\n", rev_maj);
4755   } else {
4756     devdrv_info("Etrax 100LX USB Revision %d v%d\n", rev_maj, rev_min);
4757   }
4758
4759   devdrv_info("Bulk timer interval, start:%d eot:%d\n",
4760               BULK_START_TIMER_INTERVAL,
4761               BULK_EOT_TIMER_INTERVAL);
4762
4763
4764   /* Init root hub data structures */
4765   if(rh_init()) {
4766     devdrv_err("Failed init data for Root Hub\n");
4767     retval = -ENOMEM;
4768   }
4769
4770   if(port_in_use(0)) {
4771     if (cris_request_io_interface(if_usb_1, "ETRAX100LX USB-HCD")) {
4772       printk(KERN_CRIT "usb-host: request IO interface usb1 failed");
4773       retval = -EBUSY;
4774       goto out;
4775     }
4776     devdrv_info("Claimed interface for USB physical port 1\n");
4777   }
4778   if(port_in_use(1)) {
4779     if (cris_request_io_interface(if_usb_2, "ETRAX100LX USB-HCD")) {
4780       /* Free first interface if second failed to be claimed */
4781       if(port_in_use(0)) {
4782         cris_free_io_interface(if_usb_1);
4783       }
4784       printk(KERN_CRIT "usb-host: request IO interface usb2 failed");
4785       retval = -EBUSY;
4786       goto out;
4787     }
4788     devdrv_info("Claimed interface for USB physical port 2\n");
4789   }
4790
4791   /* Init transfer controller structs and locks */
4792   if((retval = tc_init(hcd)) != 0) {
4793     goto out;
4794   }
4795
4796   /* Attach interrupt functions for DMA and init DMA controller */
4797   if((retval = tc_dma_init(hcd)) != 0) {
4798     goto out;
4799   }
4800
4801   /* Attach the top IRQ handler for USB controller interrupts */
4802   if (request_irq(ETRAX_USB_HC_IRQ, crisv10_hcd_top_irq, 0,
4803                   "ETRAX 100LX built-in USB (HC)", hcd)) {
4804     err("Could not allocate IRQ %d for USB", ETRAX_USB_HC_IRQ);
4805     retval = -EBUSY;
4806     goto out;
4807   }
4808
4809   /* iso_eof is only enabled when isoc traffic is running. */
4810   *R_USB_IRQ_MASK_SET =
4811     /* IO_STATE(R_USB_IRQ_MASK_SET, iso_eof, set) | */
4812     IO_STATE(R_USB_IRQ_MASK_SET, bulk_eot, set) |
4813     IO_STATE(R_USB_IRQ_MASK_SET, epid_attn, set) |
4814     IO_STATE(R_USB_IRQ_MASK_SET, port_status, set) |
4815     IO_STATE(R_USB_IRQ_MASK_SET, ctl_status, set);
4816
4817
4818   crisv10_ready_wait();
4819   /* Reset the USB interface. */
4820   *R_USB_COMMAND =
4821     IO_STATE(R_USB_COMMAND, port_sel, nop) |
4822     IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4823     IO_STATE(R_USB_COMMAND, ctrl_cmd, reset);
4824
4825   /* Designer's Reference, p. 8 - 10 says we should Initate R_USB_FM_PSTART to
4826      0x2A30 (10800), to guarantee that control traffic gets 10% of the
4827      bandwidth, and periodic transfer may allocate the rest (90%).
4828      This doesn't work though.
4829      The value 11960 is chosen to be just after the SOF token, with a couple
4830      of bit times extra for possible bit stuffing. */
4831   *R_USB_FM_PSTART = IO_FIELD(R_USB_FM_PSTART, value, 11960);
4832
4833   crisv10_ready_wait();
4834   /* Configure the USB interface as a host controller. */
4835   *R_USB_COMMAND =
4836     IO_STATE(R_USB_COMMAND, port_sel, nop) |
4837     IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4838     IO_STATE(R_USB_COMMAND, ctrl_cmd, host_config);
4839
4840
4841   /* Check so controller not busy before enabling ports */
4842   crisv10_ready_wait();
4843
4844   /* Enable selected USB ports */
4845   if(port_in_use(0)) {
4846     *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, no);
4847   } else {
4848     *R_USB_PORT1_DISABLE = IO_STATE(R_USB_PORT1_DISABLE, disable, yes);
4849   }
4850   if(port_in_use(1)) {
4851     *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, no);
4852   } else {
4853     *R_USB_PORT2_DISABLE = IO_STATE(R_USB_PORT2_DISABLE, disable, yes);
4854   }
4855
4856   crisv10_ready_wait();
4857   /* Start processing of USB traffic. */
4858   *R_USB_COMMAND =
4859     IO_STATE(R_USB_COMMAND, port_sel, nop) |
4860     IO_STATE(R_USB_COMMAND, port_cmd, reset) |
4861     IO_STATE(R_USB_COMMAND, ctrl_cmd, host_run);
4862
4863   /* Do not continue probing initialization before USB interface is done */
4864   crisv10_ready_wait();
4865
4866   /* Register our Host Controller to USB Core
4867    * Finish the remaining parts of generic HCD initialization: allocate the
4868    * buffers of consistent memory, register the bus
4869    * and call the driver's reset() and start() routines. */
4870   retval = usb_add_hcd(hcd, ETRAX_USB_HC_IRQ, IRQF_DISABLED);
4871   if (retval != 0) {
4872     devdrv_err("Failed registering HCD driver\n");
4873     goto out;
4874   }
4875
4876   return 0;
4877
4878  out:
4879   devdrv_hcd_remove(dev);
4880   return retval;
4881 }
4882
4883
4884 /* cleanup after the host controller and driver */
4885 static int __init_or_module devdrv_hcd_remove(struct device *dev)
4886 {
4887   struct crisv10_hcd *crisv10_hcd = dev_get_drvdata(dev);
4888   struct usb_hcd *hcd;
4889
4890   if (!crisv10_hcd)
4891     return 0;
4892   hcd = crisv10_hcd_to_hcd(crisv10_hcd);
4893
4894
4895   /* Stop USB Controller in Etrax 100LX */
4896   crisv10_hcd_reset(hcd);
4897
4898   usb_remove_hcd(hcd);
4899   devdrv_dbg("Removed HCD from USB Core\n");
4900
4901   /* Free USB Controller IRQ */
4902   free_irq(ETRAX_USB_HC_IRQ, NULL);
4903
4904   /* Free resources */
4905   tc_dma_destroy();
4906   tc_destroy();
4907
4908
4909   if(port_in_use(0)) {
4910     cris_free_io_interface(if_usb_1);
4911   }
4912   if(port_in_use(1)) {
4913     cris_free_io_interface(if_usb_2);
4914   }
4915
4916   devdrv_dbg("Freed all claimed resources\n");
4917
4918   return 0;
4919 }
4920
4921
4922 #ifdef  CONFIG_PM
4923
4924 static int devdrv_hcd_suspend(struct usb_hcd *hcd, u32 state, u32 level)
4925 {
4926   return 0; /* no-op for now */
4927 }
4928
4929 static int devdrv_hcd_resume(struct usb_hcd *hcd, u32 level)
4930 {
4931   return 0; /* no-op for now */
4932 }
4933
4934 #endif /* CONFIG_PM */
4935
4936
4937 /*************************************************************/
4938 /*************************************************************/
4939 /* Module block                                              */
4940 /*************************************************************/
4941 /*************************************************************/
4942
4943 /* register driver */
4944 static int __init module_hcd_init(void)
4945 {
4946
4947   if (usb_disabled())
4948     return -ENODEV;
4949
4950   /* Here we select enabled ports by following defines created from
4951      menuconfig */
4952 #ifndef CONFIG_ETRAX_USB_HOST_PORT1
4953   ports &= ~(1<<0);
4954 #endif
4955 #ifndef CONFIG_ETRAX_USB_HOST_PORT2
4956   ports &= ~(1<<1);
4957 #endif
4958
4959   printk(KERN_INFO "%s version "VERSION" "COPYRIGHT"\n", product_desc);
4960
4961   devdrv_hc_platform_device =
4962     platform_device_register_simple((char *) hc_name, 0, NULL, 0);
4963
4964   if (IS_ERR(devdrv_hc_platform_device))
4965     return PTR_ERR(devdrv_hc_platform_device);
4966   return driver_register(&devdrv_hc_device_driver);
4967   /*
4968    * Note that we do not set the DMA mask for the device,
4969    * i.e. we pretend that we will use PIO, since no specific
4970    * allocation routines are needed for DMA buffers. This will
4971    * cause the HCD buffer allocation routines to fall back to
4972    * kmalloc().
4973    */
4974 }
4975
4976 /* unregister driver */
4977 static void __exit module_hcd_exit(void)
4978 {
4979   driver_unregister(&devdrv_hc_device_driver);
4980 }
4981
4982
4983 /* Module hooks */
4984 module_init(module_hcd_init);
4985 module_exit(module_hcd_exit);