drivers/usb/host/isp1362-hcd.c

   1 /*
   2  * ISP1362 HCD (Host Controller Driver) for USB.
   3  *
   4  * Copyright (C) 2005 Lothar Wassmann <LW@KARO-electronics.de>
   5  *
   6  * Derived from the SL811 HCD, rewritten for ISP116x.
   7  * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee>
   8  *
   9  * Portions:
  10  * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
  11  * Copyright (C) 2004 David Brownell
  12  */
  13
  14 /*
  15  * The ISP1362 chip requires a large delay (300ns and 462ns) between
  16  * accesses to the address and data register.
  17  * The following timing options exist:
  18  *
  19  * 1. Configure your memory controller to add such delays if it can (the best)
  20  * 2. Implement platform-specific delay function possibly
  21  *    combined with configuring the memory controller; see
  22  *    include/linux/usb_isp1362.h for more info.
  23  * 3. Use ndelay (easiest, poorest).
  24  *
  25  * Use the corresponding macros USE_PLATFORM_DELAY and USE_NDELAY in the
  26  * platform specific section of isp1362.h to select the appropriate variant.
  27  *
  28  * Also note that according to the Philips "ISP1362 Errata" document
  29  * Rev 1.00 from 27 May data corruption may occur when the #WR signal
  30  * is reasserted (even with #CS deasserted) within 132ns after a
  31  * write cycle to any controller register. If the hardware doesn't
  32  * implement the recommended fix (gating the #WR with #CS) software
  33  * must ensure that no further write cycle (not necessarily to the chip!)
  34  * is issued by the CPU within this interval.
  35
  36  * For PXA25x this can be ensured by using VLIO with the maximum
  37  * recovery time (MSCx = 0x7f8c) with a memory clock of 99.53 MHz.
  38  */
  39
  40 #ifdef CONFIG_USB_DEBUG
  41 # define ISP1362_DEBUG
  42 #else
  43 # undef ISP1362_DEBUG
  44 #endif
  45
  46 /*
  47  * The PXA255 UDC apparently doesn't handle GET_STATUS, GET_CONFIG and
  48  * GET_INTERFACE requests correctly when the SETUP and DATA stages of the
  49  * requests are carried out in separate frames. This will delay any SETUP
  50  * packets until the start of the next frame so that this situation is
  51  * unlikely to occur (and makes usbtest happy running with a PXA255 target
  52  * device).
  53  */
  54 #undef BUGGY_PXA2XX_UDC_USBTEST
  55
  56 #undef PTD_TRACE
  57 #undef URB_TRACE
  58 #undef VERBOSE
  59 #undef REGISTERS
  60
  61 /* This enables a memory test on the ISP1362 chip memory to make sure the
  62  * chip access timing is correct.
  63  */
  64 #undef CHIP_BUFFER_TEST
  65
  66 #include <linux/module.h>
  67 #include <linux/moduleparam.h>
  68 #include <linux/kernel.h>
  69 #include <linux/delay.h>
  70 #include <linux/ioport.h>
  71 #include <linux/sched.h>
  72 #include <linux/slab.h>
  73 #include <linux/smp_lock.h>
  74 #include <linux/errno.h>
  75 #include <linux/init.h>
  76 #include <linux/list.h>
  77 #include <linux/interrupt.h>
  78 #include <linux/usb.h>
  79 #include <linux/usb/isp1362.h>
  80 #include <linux/platform_device.h>
  81 #include <linux/pm.h>
  82 #include <linux/io.h>
  83 #include <linux/bitmap.h>
  84
  85 #include <asm/irq.h>
  86 #include <asm/system.h>
  87 #include <asm/byteorder.h>
  88 #include <asm/unaligned.h>
  89
  90 static int dbg_level;
  91 #ifdef ISP1362_DEBUG
  92 module_param(dbg_level, int, 0644);
  93 #else
  94 module_param(dbg_level, int, 0);
  95 #define STUB_DEBUG_FILE
  96 #endif
  97
  98 #include "../core/hcd.h"
  99 #include "../core/usb.h"
 100 #include "isp1362.h"
 101
 102
 103 #define DRIVER_VERSION  "2005-04-04"
 104 #define DRIVER_DESC     "ISP1362 USB Host Controller Driver"
 105
 106 MODULE_DESCRIPTION(DRIVER_DESC);
 107 MODULE_LICENSE("GPL");
 108
 109 static const char hcd_name[] = "isp1362-hcd";
 110
 111 static void isp1362_hc_stop(struct usb_hcd *hcd);
 112 static int isp1362_hc_start(struct usb_hcd *hcd);
 113
 114 /*-------------------------------------------------------------------------*/
 115
 116 /*
 117  * When called from the interrupthandler only isp1362_hcd->irqenb is modified,
 118  * since the interrupt handler will write isp1362_hcd->irqenb to HCuPINT upon
 119  * completion.
 120  * We don't need a 'disable' counterpart, since interrupts will be disabled
 121  * only by the interrupt handler.
 122  */
 123 static inline void isp1362_enable_int(struct isp1362_hcd *isp1362_hcd, u16 mask)
 124 {
 125         if ((isp1362_hcd->irqenb | mask) == isp1362_hcd->irqenb)
 126                 return;
 127         if (mask & ~isp1362_hcd->irqenb)
 128                 isp1362_write_reg16(isp1362_hcd, HCuPINT, mask & ~isp1362_hcd->irqenb);
 129         isp1362_hcd->irqenb |= mask;
 130         if (isp1362_hcd->irq_active)
 131                 return;
 132         isp1362_write_reg16(isp1362_hcd, HCuPINTENB, isp1362_hcd->irqenb);
 133 }
 134
 135 /*-------------------------------------------------------------------------*/
 136
 137 static inline struct isp1362_ep_queue *get_ptd_queue(struct isp1362_hcd *isp1362_hcd,
 138                                                      u16 offset)
 139 {
 140         struct isp1362_ep_queue *epq = NULL;
 141
 142         if (offset < isp1362_hcd->istl_queue[1].buf_start)
 143                 epq = &isp1362_hcd->istl_queue[0];
 144         else if (offset < isp1362_hcd->intl_queue.buf_start)
 145                 epq = &isp1362_hcd->istl_queue[1];
 146         else if (offset < isp1362_hcd->atl_queue.buf_start)
 147                 epq = &isp1362_hcd->intl_queue;
 148         else if (offset < isp1362_hcd->atl_queue.buf_start +
 149                    isp1362_hcd->atl_queue.buf_size)
 150                 epq = &isp1362_hcd->atl_queue;
 151
 152         if (epq)
 153                 DBG(1, "%s: PTD $%04x is on %s queue\n", __func__, offset, epq->name);
 154         else
 155                 pr_warning("%s: invalid PTD $%04x\n", __func__, offset);
 156
 157         return epq;
 158 }
 159
 160 static inline int get_ptd_offset(struct isp1362_ep_queue *epq, u8 index)
 161 {
 162         int offset;
 163
 164         if (index * epq->blk_size > epq->buf_size) {
 165                 pr_warning("%s: Bad %s index %d(%d)\n", __func__, epq->name, index,
 166                      epq->buf_size / epq->blk_size);
 167                 return -EINVAL;
 168         }
 169         offset = epq->buf_start + index * epq->blk_size;
 170         DBG(3, "%s: %s PTD[%02x] # %04x\n", __func__, epq->name, index, offset);
 171
 172         return offset;
 173 }
 174
 175 /*-------------------------------------------------------------------------*/
 176
 177 static inline u16 max_transfer_size(struct isp1362_ep_queue *epq, size_t size,
 178                                     int mps)
 179 {
 180         u16 xfer_size = min_t(size_t, MAX_XFER_SIZE, size);
 181
 182         xfer_size = min_t(size_t, xfer_size, epq->buf_avail * epq->blk_size - PTD_HEADER_SIZE);
 183         if (xfer_size < size && xfer_size % mps)
 184                 xfer_size -= xfer_size % mps;
 185
 186         return xfer_size;
 187 }
 188
 189 static int claim_ptd_buffers(struct isp1362_ep_queue *epq,
 190                              struct isp1362_ep *ep, u16 len)
 191 {
 192         int ptd_offset = -EINVAL;
 193         int num_ptds = ((len + PTD_HEADER_SIZE - 1) / epq->blk_size) + 1;
 194         int found;
 195
 196         BUG_ON(len > epq->buf_size);
 197
 198         if (!epq->buf_avail)
 199                 return -ENOMEM;
 200
 201         if (ep->num_ptds)
 202                 pr_err("%s: %s len %d/%d num_ptds %d buf_map %08lx skip_map %08lx\n", __func__,
 203                     epq->name, len, epq->blk_size, num_ptds, epq->buf_map, epq->skip_map);
 204         BUG_ON(ep->num_ptds != 0);
 205
 206         found = bitmap_find_next_zero_area(&epq->buf_map, epq->buf_count, 0,
 207                                                 num_ptds, 0);
 208         if (found >= epq->buf_count)
 209                 return -EOVERFLOW;
 210
 211         DBG(1, "%s: Found %d PTDs[%d] for %d/%d byte\n", __func__,
 212             num_ptds, found, len, (int)(epq->blk_size - PTD_HEADER_SIZE));
 213         ptd_offset = get_ptd_offset(epq, found);
 214         WARN_ON(ptd_offset < 0);
 215         ep->ptd_offset = ptd_offset;
 216         ep->num_ptds += num_ptds;
 217         epq->buf_avail -= num_ptds;
 218         BUG_ON(epq->buf_avail > epq->buf_count);
 219         ep->ptd_index = found;
 220         bitmap_set(&epq->buf_map, found, num_ptds);
 221         DBG(1, "%s: Done %s PTD[%d] $%04x, avail %d count %d claimed %d %08lx:%08lx\n",
 222             __func__, epq->name, ep->ptd_index, ep->ptd_offset,
 223             epq->buf_avail, epq->buf_count, num_ptds, epq->buf_map, epq->skip_map);
 224
 225         return found;
 226 }
 227
 228 static inline void release_ptd_buffers(struct isp1362_ep_queue *epq, struct isp1362_ep *ep)
 229 {
 230         int index = ep->ptd_index;
 231         int last = ep->ptd_index + ep->num_ptds;
 232
 233         if (last > epq->buf_count)
 234                 pr_err("%s: ep %p req %d len %d %s PTD[%d] $%04x num_ptds %d buf_count %d buf_avail %d buf_map %08lx skip_map %08lx\n",
 235                     __func__, ep, ep->num_req, ep->length, epq->name, ep->ptd_index,
 236                     ep->ptd_offset, ep->num_ptds, epq->buf_count, epq->buf_avail,
 237                     epq->buf_map, epq->skip_map);
 238         BUG_ON(last > epq->buf_count);
 239
 240         for (; index < last; index++) {
 241                 __clear_bit(index, &epq->buf_map);
 242                 __set_bit(index, &epq->skip_map);
 243         }
 244         epq->buf_avail += ep->num_ptds;
 245         epq->ptd_count--;
 246
 247         BUG_ON(epq->buf_avail > epq->buf_count);
 248         BUG_ON(epq->ptd_count > epq->buf_count);
 249
 250         DBG(1, "%s: Done %s PTDs $%04x released %d avail %d count %d\n",
 251             __func__, epq->name,
 252             ep->ptd_offset, ep->num_ptds, epq->buf_avail, epq->buf_count);
 253         DBG(1, "%s: buf_map %08lx skip_map %08lx\n", __func__,
 254             epq->buf_map, epq->skip_map);
 255
 256         ep->num_ptds = 0;
 257         ep->ptd_offset = -EINVAL;
 258         ep->ptd_index = -EINVAL;
 259 }
 260
 261 /*-------------------------------------------------------------------------*/
 262
 263 /*
 264   Set up PTD's.
 265 */
 266 static void prepare_ptd(struct isp1362_hcd *isp1362_hcd, struct urb *urb,
 267                         struct isp1362_ep *ep, struct isp1362_ep_queue *epq,
 268                         u16 fno)
 269 {
 270         struct ptd *ptd;
 271         int toggle;
 272         int dir;
 273         u16 len;
 274         size_t buf_len = urb->transfer_buffer_length - urb->actual_length;
 275
 276         DBG(3, "%s: %s ep %p\n", __func__, epq->name, ep);
 277
 278         ptd = &ep->ptd;
 279
 280         ep->data = (unsigned char *)urb->transfer_buffer + urb->actual_length;
 281
 282         switch (ep->nextpid) {
 283         case USB_PID_IN:
 284                 toggle = usb_gettoggle(urb->dev, ep->epnum, 0);
 285                 dir = PTD_DIR_IN;
 286                 if (usb_pipecontrol(urb->pipe)) {
 287                         len = min_t(size_t, ep->maxpacket, buf_len);
 288                 } else if (usb_pipeisoc(urb->pipe)) {
 289                         len = min_t(size_t, urb->iso_frame_desc[fno].length, MAX_XFER_SIZE);
 290                         ep->data = urb->transfer_buffer + urb->iso_frame_desc[fno].offset;
 291                 } else
 292                         len = max_transfer_size(epq, buf_len, ep->maxpacket);
 293                 DBG(1, "%s: IN    len %d/%d/%d from URB\n", __func__, len, ep->maxpacket,
 294                     (int)buf_len);
 295                 break;
 296         case USB_PID_OUT:
 297                 toggle = usb_gettoggle(urb->dev, ep->epnum, 1);
 298                 dir = PTD_DIR_OUT;
 299                 if (usb_pipecontrol(urb->pipe))
 300                         len = min_t(size_t, ep->maxpacket, buf_len);
 301                 else if (usb_pipeisoc(urb->pipe))
 302                         len = min_t(size_t, urb->iso_frame_desc[0].length, MAX_XFER_SIZE);
 303                 else
 304                         len = max_transfer_size(epq, buf_len, ep->maxpacket);
 305                 if (len == 0)
 306                         pr_info("%s: Sending ZERO packet: %d\n", __func__,
 307                              urb->transfer_flags & URB_ZERO_PACKET);
 308                 DBG(1, "%s: OUT   len %d/%d/%d from URB\n", __func__, len, ep->maxpacket,
 309                     (int)buf_len);
 310                 break;
 311         case USB_PID_SETUP:
 312                 toggle = 0;
 313                 dir = PTD_DIR_SETUP;
 314                 len = sizeof(struct usb_ctrlrequest);
 315                 DBG(1, "%s: SETUP len %d\n", __func__, len);
 316                 ep->data = urb->setup_packet;
 317                 break;
 318         case USB_PID_ACK:
 319                 toggle = 1;
 320                 len = 0;
 321                 dir = (urb->transfer_buffer_length && usb_pipein(urb->pipe)) ?
 322                         PTD_DIR_OUT : PTD_DIR_IN;
 323                 DBG(1, "%s: ACK   len %d\n", __func__, len);
 324                 break;
 325         default:
 326                 toggle = dir = len = 0;
 327                 pr_err("%s@%d: ep->nextpid %02x\n", __func__, __LINE__, ep->nextpid);
 328                 BUG_ON(1);
 329         }
 330
 331         ep->length = len;
 332         if (!len)
 333                 ep->data = NULL;
 334
 335         ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle);
 336         ptd->mps = PTD_MPS(ep->maxpacket) | PTD_SPD(urb->dev->speed == USB_SPEED_LOW) |
 337                 PTD_EP(ep->epnum);
 338         ptd->len = PTD_LEN(len) | PTD_DIR(dir);
 339         ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe));
 340
 341         if (usb_pipeint(urb->pipe)) {
 342                 ptd->faddr |= PTD_SF_INT(ep->branch);
 343                 ptd->faddr |= PTD_PR(ep->interval ? __ffs(ep->interval) : 0);
 344         }
 345         if (usb_pipeisoc(urb->pipe))
 346                 ptd->faddr |= PTD_SF_ISO(fno);
 347
 348         DBG(1, "%s: Finished\n", __func__);
 349 }
 350
 351 static void isp1362_write_ptd(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep,
 352                               struct isp1362_ep_queue *epq)
 353 {
 354         struct ptd *ptd = &ep->ptd;
 355         int len = PTD_GET_DIR(ptd) == PTD_DIR_IN ? 0 : ep->length;
 356
 357         _BUG_ON(ep->ptd_offset < 0);
 358
 359         prefetch(ptd);
 360         isp1362_write_buffer(isp1362_hcd, ptd, ep->ptd_offset, PTD_HEADER_SIZE);
 361         if (len)
 362                 isp1362_write_buffer(isp1362_hcd, ep->data,
 363                                      ep->ptd_offset + PTD_HEADER_SIZE, len);
 364
 365         dump_ptd(ptd);
 366         dump_ptd_out_data(ptd, ep->data);
 367 }
 368
 369 static void isp1362_read_ptd(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep,
 370                              struct isp1362_ep_queue *epq)
 371 {
 372         struct ptd *ptd = &ep->ptd;
 373         int act_len;
 374
 375         WARN_ON(list_empty(&ep->active));
 376         BUG_ON(ep->ptd_offset < 0);
 377
 378         list_del_init(&ep->active);
 379         DBG(1, "%s: ep %p removed from active list %p\n", __func__, ep, &epq->active);
 380
 381         prefetchw(ptd);
 382         isp1362_read_buffer(isp1362_hcd, ptd, ep->ptd_offset, PTD_HEADER_SIZE);
 383         dump_ptd(ptd);
 384         act_len = PTD_GET_COUNT(ptd);
 385         if (PTD_GET_DIR(ptd) != PTD_DIR_IN || act_len == 0)
 386                 return;
 387         if (act_len > ep->length)
 388                 pr_err("%s: ep %p PTD $%04x act_len %d ep->length %d\n", __func__, ep,
 389                          ep->ptd_offset, act_len, ep->length);
 390         BUG_ON(act_len > ep->length);
 391         /* Only transfer the amount of data that has actually been overwritten
 392          * in the chip buffer. We don't want any data that doesn't belong to the
 393          * transfer to leak out of the chip to the callers transfer buffer!
 394          */
 395         prefetchw(ep->data);
 396         isp1362_read_buffer(isp1362_hcd, ep->data,
 397                             ep->ptd_offset + PTD_HEADER_SIZE, act_len);
 398         dump_ptd_in_data(ptd, ep->data);
 399 }
 400
 401 /*
 402  * INT PTDs will stay in the chip until data is available.
 403  * This function will remove a PTD from the chip when the URB is dequeued.
 404  * Must be called with the spinlock held and IRQs disabled
 405  */
 406 static void remove_ptd(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep)
 407
 408 {
 409         int index;
 410         struct isp1362_ep_queue *epq;
 411
 412         DBG(1, "%s: ep %p PTD[%d] $%04x\n", __func__, ep, ep->ptd_index, ep->ptd_offset);
 413         BUG_ON(ep->ptd_offset < 0);
 414
 415         epq = get_ptd_queue(isp1362_hcd, ep->ptd_offset);
 416         BUG_ON(!epq);
 417
 418         /* put ep in remove_list for cleanup */
 419         WARN_ON(!list_empty(&ep->remove_list));
 420         list_add_tail(&ep->remove_list, &isp1362_hcd->remove_list);
 421         /* let SOF interrupt handle the cleanup */
 422         isp1362_enable_int(isp1362_hcd, HCuPINT_SOF);
 423
 424         index = ep->ptd_index;
 425         if (index < 0)
 426                 /* ISO queues don't have SKIP registers */
 427                 return;
 428
 429         DBG(1, "%s: Disabling PTD[%02x] $%04x %08lx|%08x\n", __func__,
 430             index, ep->ptd_offset, epq->skip_map, 1 << index);
 431
 432         /* prevent further processing of PTD (will be effective after next SOF) */
 433         epq->skip_map |= 1 << index;
 434         if (epq == &isp1362_hcd->atl_queue) {
 435                 DBG(2, "%s: ATLSKIP = %08x -> %08lx\n", __func__,
 436                     isp1362_read_reg32(isp1362_hcd, HCATLSKIP), epq->skip_map);
 437                 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, epq->skip_map);
 438                 if (~epq->skip_map == 0)
 439                         isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
 440         } else if (epq == &isp1362_hcd->intl_queue) {
 441                 DBG(2, "%s: INTLSKIP = %08x -> %08lx\n", __func__,
 442                     isp1362_read_reg32(isp1362_hcd, HCINTLSKIP), epq->skip_map);
 443                 isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, epq->skip_map);
 444                 if (~epq->skip_map == 0)
 445                         isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_INTL_ACTIVE);
 446         }
 447 }
 448
 449 /*
 450   Take done or failed requests out of schedule. Give back
 451   processed urbs.
 452 */
 453 static void finish_request(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep,
 454                            struct urb *urb, int status)
 455      __releases(isp1362_hcd->lock)
 456      __acquires(isp1362_hcd->lock)
 457 {
 458         urb->hcpriv = NULL;
 459         ep->error_count = 0;
 460
 461         if (usb_pipecontrol(urb->pipe))
 462                 ep->nextpid = USB_PID_SETUP;
 463
 464         URB_DBG("%s: req %d FA %d ep%d%s %s: len %d/%d %s stat %d\n", __func__,
 465                 ep->num_req, usb_pipedevice(urb->pipe),
 466                 usb_pipeendpoint(urb->pipe),
 467                 !usb_pipein(urb->pipe) ? "out" : "in",
 468                 usb_pipecontrol(urb->pipe) ? "ctrl" :
 469                         usb_pipeint(urb->pipe) ? "int" :
 470                         usb_pipebulk(urb->pipe) ? "bulk" :
 471                         "iso",
 472                 urb->actual_length, urb->transfer_buffer_length,
 473                 !(urb->transfer_flags & URB_SHORT_NOT_OK) ?
 474                 "short_ok" : "", urb->status);
 475
 476
 477         usb_hcd_unlink_urb_from_ep(isp1362_hcd_to_hcd(isp1362_hcd), urb);
 478         spin_unlock(&isp1362_hcd->lock);
 479         usb_hcd_giveback_urb(isp1362_hcd_to_hcd(isp1362_hcd), urb, status);
 480         spin_lock(&isp1362_hcd->lock);
 481
 482         /* take idle endpoints out of the schedule right away */
 483         if (!list_empty(&ep->hep->urb_list))
 484                 return;
 485
 486         /* async deschedule */
 487         if (!list_empty(&ep->schedule)) {
 488                 list_del_init(&ep->schedule);
 489                 return;
 490         }
 491
 492
 493         if (ep->interval) {
 494                 /* periodic deschedule */
 495                 DBG(1, "deschedule qh%d/%p branch %d load %d bandwidth %d -> %d\n", ep->interval,
 496                     ep, ep->branch, ep->load,
 497                     isp1362_hcd->load[ep->branch],
 498                     isp1362_hcd->load[ep->branch] - ep->load);
 499                 isp1362_hcd->load[ep->branch] -= ep->load;
 500                 ep->branch = PERIODIC_SIZE;
 501         }
 502 }
 503
 504 /*
 505  * Analyze transfer results, handle partial transfers and errors
 506 */
 507 static void postproc_ep(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep *ep)
 508 {
 509         struct urb *urb = get_urb(ep);
 510         struct usb_device *udev;
 511         struct ptd *ptd;
 512         int short_ok;
 513         u16 len;
 514         int urbstat = -EINPROGRESS;
 515         u8 cc;
 516
 517         DBG(2, "%s: ep %p req %d\n", __func__, ep, ep->num_req);
 518
 519         udev = urb->dev;
 520         ptd = &ep->ptd;
 521         cc = PTD_GET_CC(ptd);
 522         if (cc == PTD_NOTACCESSED) {
 523                 pr_err("%s: req %d PTD %p Untouched by ISP1362\n", __func__,
 524                     ep->num_req, ptd);
 525                 cc = PTD_DEVNOTRESP;
 526         }
 527
 528         short_ok = !(urb->transfer_flags & URB_SHORT_NOT_OK);
 529         len = urb->transfer_buffer_length - urb->actual_length;
 530
 531         /* Data underrun is special. For allowed underrun
 532            we clear the error and continue as normal. For
 533            forbidden underrun we finish the DATA stage
 534            immediately while for control transfer,
 535            we do a STATUS stage.
 536         */
 537         if (cc == PTD_DATAUNDERRUN) {
 538                 if (short_ok) {
 539                         DBG(1, "%s: req %d Allowed data underrun short_%sok %d/%d/%d byte\n",
 540                             __func__, ep->num_req, short_ok ? "" : "not_",
 541                             PTD_GET_COUNT(ptd), ep->maxpacket, len);
 542                         cc = PTD_CC_NOERROR;
 543                         urbstat = 0;
 544                 } else {
 545                         DBG(1, "%s: req %d Data Underrun %s nextpid %02x short_%sok %d/%d/%d byte\n",
 546                             __func__, ep->num_req,
 547                             usb_pipein(urb->pipe) ? "IN" : "OUT", ep->nextpid,
 548                             short_ok ? "" : "not_",
 549                             PTD_GET_COUNT(ptd), ep->maxpacket, len);
 550                         if (usb_pipecontrol(urb->pipe)) {
 551                                 ep->nextpid = USB_PID_ACK;
 552                                 /* save the data underrun error code for later and
 553                                  * procede with the status stage
 554                                  */
 555                                 urb->actual_length += PTD_GET_COUNT(ptd);
 556                                 BUG_ON(urb->actual_length > urb->transfer_buffer_length);
 557
 558                                 if (urb->status == -EINPROGRESS)
 559                                         urb->status = cc_to_error[PTD_DATAUNDERRUN];
 560                         } else {
 561                                 usb_settoggle(udev, ep->epnum, ep->nextpid == USB_PID_OUT,
 562                                               PTD_GET_TOGGLE(ptd));
 563                                 urbstat = cc_to_error[PTD_DATAUNDERRUN];
 564                         }
 565                         goto out;
 566                 }
 567         }
 568
 569         if (cc != PTD_CC_NOERROR) {
 570                 if (++ep->error_count >= 3 || cc == PTD_CC_STALL || cc == PTD_DATAOVERRUN) {
 571                         urbstat = cc_to_error[cc];
 572                         DBG(1, "%s: req %d nextpid %02x, status %d, error %d, error_count %d\n",
 573                             __func__, ep->num_req, ep->nextpid, urbstat, cc,
 574                             ep->error_count);
 575                 }
 576                 goto out;
 577         }
 578
 579         switch (ep->nextpid) {
 580         case USB_PID_OUT:
 581                 if (PTD_GET_COUNT(ptd) != ep->length)
 582                         pr_err("%s: count=%d len=%d\n", __func__,
 583                            PTD_GET_COUNT(ptd), ep->length);
 584                 BUG_ON(PTD_GET_COUNT(ptd) != ep->length);
 585                 urb->actual_length += ep->length;
 586                 BUG_ON(urb->actual_length > urb->transfer_buffer_length);
 587                 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd));
 588                 if (urb->actual_length == urb->transfer_buffer_length) {
 589                         DBG(3, "%s: req %d xfer complete %d/%d status %d -> 0\n", __func__,
 590                             ep->num_req, len, ep->maxpacket, urbstat);
 591                         if (usb_pipecontrol(urb->pipe)) {
 592                                 DBG(3, "%s: req %d %s Wait for ACK\n", __func__,
 593                                     ep->num_req,
 594                                     usb_pipein(urb->pipe) ? "IN" : "OUT");
 595                                 ep->nextpid = USB_PID_ACK;
 596                         } else {
 597                                 if (len % ep->maxpacket ||
 598                                     !(urb->transfer_flags & URB_ZERO_PACKET)) {
 599                                         urbstat = 0;
 600                                         DBG(3, "%s: req %d URB %s status %d count %d/%d/%d\n",
 601                                             __func__, ep->num_req, usb_pipein(urb->pipe) ? "IN" : "OUT",
 602                                             urbstat, len, ep->maxpacket, urb->actual_length);
 603                                 }
 604                         }
 605                 }
 606                 break;
 607         case USB_PID_IN:
 608                 len = PTD_GET_COUNT(ptd);
 609                 BUG_ON(len > ep->length);
 610                 urb->actual_length += len;
 611                 BUG_ON(urb->actual_length > urb->transfer_buffer_length);
 612                 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd));
 613                 /* if transfer completed or (allowed) data underrun */
 614                 if ((urb->transfer_buffer_length == urb->actual_length) ||
 615                     len % ep->maxpacket) {
 616                         DBG(3, "%s: req %d xfer complete %d/%d status %d -> 0\n", __func__,
 617                             ep->num_req, len, ep->maxpacket, urbstat);
 618                         if (usb_pipecontrol(urb->pipe)) {
 619                                 DBG(3, "%s: req %d %s Wait for ACK\n", __func__,
 620                                     ep->num_req,
 621                                     usb_pipein(urb->pipe) ? "IN" : "OUT");
 622                                 ep->nextpid = USB_PID_ACK;
 623                         } else {
 624                                 urbstat = 0;
 625                                 DBG(3, "%s: req %d URB %s status %d count %d/%d/%d\n",
 626                                     __func__, ep->num_req, usb_pipein(urb->pipe) ? "IN" : "OUT",
 627                                     urbstat, len, ep->maxpacket, urb->actual_length);
 628                         }
 629                 }
 630                 break;
 631         case USB_PID_SETUP:
 632                 if (urb->transfer_buffer_length == urb->actual_length) {
 633                         ep->nextpid = USB_PID_ACK;
 634                 } else if (usb_pipeout(urb->pipe)) {
 635                         usb_settoggle(udev, 0, 1, 1);
 636                         ep->nextpid = USB_PID_OUT;
 637                 } else {
 638                         usb_settoggle(udev, 0, 0, 1);
 639                         ep->nextpid = USB_PID_IN;
 640                 }
 641                 break;
 642         case USB_PID_ACK:
 643                 DBG(3, "%s: req %d got ACK %d -> 0\n", __func__, ep->num_req,
 644                     urbstat);
 645                 WARN_ON(urbstat != -EINPROGRESS);
 646                 urbstat = 0;
 647                 ep->nextpid = 0;
 648                 break;
 649         default:
 650                 BUG_ON(1);
 651         }
 652
 653  out:
 654         if (urbstat != -EINPROGRESS) {
 655                 DBG(2, "%s: Finishing ep %p req %d urb %p status %d\n", __func__,
 656                     ep, ep->num_req, urb, urbstat);
 657                 finish_request(isp1362_hcd, ep, urb, urbstat);
 658         }
 659 }
 660
 661 static void finish_unlinks(struct isp1362_hcd *isp1362_hcd)
 662 {
 663         struct isp1362_ep *ep;
 664         struct isp1362_ep *tmp;
 665
 666         list_for_each_entry_safe(ep, tmp, &isp1362_hcd->remove_list, remove_list) {
 667                 struct isp1362_ep_queue *epq =
 668                         get_ptd_queue(isp1362_hcd, ep->ptd_offset);
 669                 int index = ep->ptd_index;
 670
 671                 BUG_ON(epq == NULL);
 672                 if (index >= 0) {
 673                         DBG(1, "%s: remove PTD[%d] $%04x\n", __func__, index, ep->ptd_offset);
 674                         BUG_ON(ep->num_ptds == 0);
 675                         release_ptd_buffers(epq, ep);
 676                 }
 677                 if (!list_empty(&ep->hep->urb_list)) {
 678                         struct urb *urb = get_urb(ep);
 679
 680                         DBG(1, "%s: Finishing req %d ep %p from remove_list\n", __func__,
 681                             ep->num_req, ep);
 682                         finish_request(isp1362_hcd, ep, urb, -ESHUTDOWN);
 683                 }
 684                 WARN_ON(list_empty(&ep->active));
 685                 if (!list_empty(&ep->active)) {
 686                         list_del_init(&ep->active);
 687                         DBG(1, "%s: ep %p removed from active list\n", __func__, ep);
 688                 }
 689                 list_del_init(&ep->remove_list);
 690                 DBG(1, "%s: ep %p removed from remove_list\n", __func__, ep);
 691         }
 692         DBG(1, "%s: Done\n", __func__);
 693 }
 694
 695 static inline void enable_atl_transfers(struct isp1362_hcd *isp1362_hcd, int count)
 696 {
 697         if (count > 0) {
 698                 if (count < isp1362_hcd->atl_queue.ptd_count)
 699                         isp1362_write_reg16(isp1362_hcd, HCATLDTC, count);
 700                 isp1362_enable_int(isp1362_hcd, HCuPINT_ATL);
 701                 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, isp1362_hcd->atl_queue.skip_map);
 702                 isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
 703         } else
 704                 isp1362_enable_int(isp1362_hcd, HCuPINT_SOF);
 705 }
 706
 707 static inline void enable_intl_transfers(struct isp1362_hcd *isp1362_hcd)
 708 {
 709         isp1362_enable_int(isp1362_hcd, HCuPINT_INTL);
 710         isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_INTL_ACTIVE);
 711         isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, isp1362_hcd->intl_queue.skip_map);
 712 }
 713
 714 static inline void enable_istl_transfers(struct isp1362_hcd *isp1362_hcd, int flip)
 715 {
 716         isp1362_enable_int(isp1362_hcd, flip ? HCuPINT_ISTL1 : HCuPINT_ISTL0);
 717         isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, flip ?
 718                            HCBUFSTAT_ISTL1_FULL : HCBUFSTAT_ISTL0_FULL);
 719 }
 720
 721 static int submit_req(struct isp1362_hcd *isp1362_hcd, struct urb *urb,
 722                       struct isp1362_ep *ep, struct isp1362_ep_queue *epq)
 723 {
 724         int index = epq->free_ptd;
 725
 726         prepare_ptd(isp1362_hcd, urb, ep, epq, 0);
 727         index = claim_ptd_buffers(epq, ep, ep->length);
 728         if (index == -ENOMEM) {
 729                 DBG(1, "%s: req %d No free %s PTD available: %d, %08lx:%08lx\n", __func__,
 730                     ep->num_req, epq->name, ep->num_ptds, epq->buf_map, epq->skip_map);
 731                 return index;
 732         } else if (index == -EOVERFLOW) {
 733                 DBG(1, "%s: req %d Not enough space for %d byte %s PTD %d %08lx:%08lx\n",
 734                     __func__, ep->num_req, ep->length, epq->name, ep->num_ptds,
 735                     epq->buf_map, epq->skip_map);
 736                 return index;
 737         } else
 738                 BUG_ON(index < 0);
 739         list_add_tail(&ep->active, &epq->active);
 740         DBG(1, "%s: ep %p req %d len %d added to active list %p\n", __func__,
 741             ep, ep->num_req, ep->length, &epq->active);
 742         DBG(1, "%s: Submitting %s PTD $%04x for ep %p req %d\n", __func__, epq->name,
 743             ep->ptd_offset, ep, ep->num_req);
 744         isp1362_write_ptd(isp1362_hcd, ep, epq);
 745         __clear_bit(ep->ptd_index, &epq->skip_map);
 746
 747         return 0;
 748 }
 749
 750 static void start_atl_transfers(struct isp1362_hcd *isp1362_hcd)
 751 {
 752         int ptd_count = 0;
 753         struct isp1362_ep_queue *epq = &isp1362_hcd->atl_queue;
 754         struct isp1362_ep *ep;
 755         int defer = 0;
 756
 757         if (atomic_read(&epq->finishing)) {
 758                 DBG(1, "%s: finish_transfers is active for %s\n", __func__, epq->name);
 759                 return;
 760         }
 761
 762         list_for_each_entry(ep, &isp1362_hcd->async, schedule) {
 763                 struct urb *urb = get_urb(ep);
 764                 int ret;
 765
 766                 if (!list_empty(&ep->active)) {
 767                         DBG(2, "%s: Skipping active %s ep %p\n", __func__, epq->name, ep);
 768                         continue;
 769                 }
 770
 771                 DBG(1, "%s: Processing %s ep %p req %d\n", __func__, epq->name,
 772                     ep, ep->num_req);
 773
 774                 ret = submit_req(isp1362_hcd, urb, ep, epq);
 775                 if (ret == -ENOMEM) {
 776                         defer = 1;
 777                         break;
 778                 } else if (ret == -EOVERFLOW) {
 779                         defer = 1;
 780                         continue;
 781                 }
 782 #ifdef BUGGY_PXA2XX_UDC_USBTEST
 783                 defer = ep->nextpid == USB_PID_SETUP;
 784 #endif
 785                 ptd_count++;
 786         }
 787
 788         /* Avoid starving of endpoints */
 789         if (isp1362_hcd->async.next != isp1362_hcd->async.prev) {
 790                 DBG(2, "%s: Cycling ASYNC schedule %d\n", __func__, ptd_count);
 791                 list_move(&isp1362_hcd->async, isp1362_hcd->async.next);
 792         }
 793         if (ptd_count || defer)
 794                 enable_atl_transfers(isp1362_hcd, defer ? 0 : ptd_count);
 795
 796         epq->ptd_count += ptd_count;
 797         if (epq->ptd_count > epq->stat_maxptds) {
 798                 epq->stat_maxptds = epq->ptd_count;
 799                 DBG(0, "%s: max_ptds: %d\n", __func__, epq->stat_maxptds);
 800         }
 801 }
 802
 803 static void start_intl_transfers(struct isp1362_hcd *isp1362_hcd)
 804 {
 805         int ptd_count = 0;
 806         struct isp1362_ep_queue *epq = &isp1362_hcd->intl_queue;
 807         struct isp1362_ep *ep;
 808
 809         if (atomic_read(&epq->finishing)) {
 810                 DBG(1, "%s: finish_transfers is active for %s\n", __func__, epq->name);
 811                 return;
 812         }
 813
 814         list_for_each_entry(ep, &isp1362_hcd->periodic, schedule) {
 815                 struct urb *urb = get_urb(ep);
 816                 int ret;
 817
 818                 if (!list_empty(&ep->active)) {
 819                         DBG(1, "%s: Skipping active %s ep %p\n", __func__,
 820                             epq->name, ep);
 821                         continue;
 822                 }
 823
 824                 DBG(1, "%s: Processing %s ep %p req %d\n", __func__,
 825                     epq->name, ep, ep->num_req);
 826                 ret = submit_req(isp1362_hcd, urb, ep, epq);
 827                 if (ret == -ENOMEM)
 828                         break;
 829                 else if (ret == -EOVERFLOW)
 830                         continue;
 831                 ptd_count++;
 832         }
 833
 834         if (ptd_count) {
 835                 static int last_count;
 836
 837                 if (ptd_count != last_count) {
 838                         DBG(0, "%s: ptd_count: %d\n", __func__, ptd_count);
 839                         last_count = ptd_count;
 840                 }
 841                 enable_intl_transfers(isp1362_hcd);
 842         }
 843
 844         epq->ptd_count += ptd_count;
 845         if (epq->ptd_count > epq->stat_maxptds)
 846                 epq->stat_maxptds = epq->ptd_count;
 847 }
 848
 849 static inline int next_ptd(struct isp1362_ep_queue *epq, struct isp1362_ep *ep)
 850 {
 851         u16 ptd_offset = ep->ptd_offset;
 852         int num_ptds = (ep->length + PTD_HEADER_SIZE + (epq->blk_size - 1)) / epq->blk_size;
 853
 854         DBG(2, "%s: PTD offset $%04x + %04x => %d * %04x -> $%04x\n", __func__, ptd_offset,
 855             ep->length, num_ptds, epq->blk_size, ptd_offset + num_ptds * epq->blk_size);
 856
 857         ptd_offset += num_ptds * epq->blk_size;
 858         if (ptd_offset < epq->buf_start + epq->buf_size)
 859                 return ptd_offset;
 860         else
 861                 return -ENOMEM;
 862 }
 863
 864 static void start_iso_transfers(struct isp1362_hcd *isp1362_hcd)
 865 {
 866         int ptd_count = 0;
 867         int flip = isp1362_hcd->istl_flip;
 868         struct isp1362_ep_queue *epq;
 869         int ptd_offset;
 870         struct isp1362_ep *ep;
 871         struct isp1362_ep *tmp;
 872         u16 fno = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
 873
 874  fill2:
 875         epq = &isp1362_hcd->istl_queue[flip];
 876         if (atomic_read(&epq->finishing)) {
 877                 DBG(1, "%s: finish_transfers is active for %s\n", __func__, epq->name);
 878                 return;
 879         }
 880
 881         if (!list_empty(&epq->active))
 882                 return;
 883
 884         ptd_offset = epq->buf_start;
 885         list_for_each_entry_safe(ep, tmp, &isp1362_hcd->isoc, schedule) {
 886                 struct urb *urb = get_urb(ep);
 887                 s16 diff = fno - (u16)urb->start_frame;
 888
 889                 DBG(1, "%s: Processing %s ep %p\n", __func__, epq->name, ep);
 890
 891                 if (diff > urb->number_of_packets) {
 892                         /* time frame for this URB has elapsed */
 893                         finish_request(isp1362_hcd, ep, urb, -EOVERFLOW);
 894                         continue;
 895                 } else if (diff < -1) {
 896                         /* URB is not due in this frame or the next one.
 897                          * Comparing with '-1' instead of '0' accounts for double
 898                          * buffering in the ISP1362 which enables us to queue the PTD
 899                          * one frame ahead of time
 900                          */
 901                 } else if (diff == -1) {
 902                         /* submit PTD's that are due in the next frame */
 903                         prepare_ptd(isp1362_hcd, urb, ep, epq, fno);
 904                         if (ptd_offset + PTD_HEADER_SIZE + ep->length >
 905                             epq->buf_start + epq->buf_size) {
 906                                 pr_err("%s: Not enough ISO buffer space for %d byte PTD\n",
 907                                     __func__, ep->length);
 908                                 continue;
 909                         }
 910                         ep->ptd_offset = ptd_offset;
 911                         list_add_tail(&ep->active, &epq->active);
 912
 913                         ptd_offset = next_ptd(epq, ep);
 914                         if (ptd_offset < 0) {
 915                                 pr_warning("%s: req %d No more %s PTD buffers available\n", __func__,
 916                                      ep->num_req, epq->name);
 917                                 break;
 918                         }
 919                 }
 920         }
 921         list_for_each_entry(ep, &epq->active, active) {
 922                 if (epq->active.next == &ep->active)
 923                         ep->ptd.mps |= PTD_LAST_MSK;
 924                 isp1362_write_ptd(isp1362_hcd, ep, epq);
 925                 ptd_count++;
 926         }
 927
 928         if (ptd_count)
 929                 enable_istl_transfers(isp1362_hcd, flip);
 930
 931         epq->ptd_count += ptd_count;
 932         if (epq->ptd_count > epq->stat_maxptds)
 933                 epq->stat_maxptds = epq->ptd_count;
 934
 935         /* check, whether the second ISTL buffer may also be filled */
 936         if (!(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
 937               (flip ? HCBUFSTAT_ISTL0_FULL : HCBUFSTAT_ISTL1_FULL))) {
 938                 fno++;
 939                 ptd_count = 0;
 940                 flip = 1 - flip;
 941                 goto fill2;
 942         }
 943 }
 944
 945 static void finish_transfers(struct isp1362_hcd *isp1362_hcd, unsigned long done_map,
 946                              struct isp1362_ep_queue *epq)
 947 {
 948         struct isp1362_ep *ep;
 949         struct isp1362_ep *tmp;
 950
 951         if (list_empty(&epq->active)) {
 952                 DBG(1, "%s: Nothing to do for %s queue\n", __func__, epq->name);
 953                 return;
 954         }
 955
 956         DBG(1, "%s: Finishing %s transfers %08lx\n", __func__, epq->name, done_map);
 957
 958         atomic_inc(&epq->finishing);
 959         list_for_each_entry_safe(ep, tmp, &epq->active, active) {
 960                 int index = ep->ptd_index;
 961
 962                 DBG(1, "%s: Checking %s PTD[%02x] $%04x\n", __func__, epq->name,
 963                     index, ep->ptd_offset);
 964
 965                 BUG_ON(index < 0);
 966                 if (__test_and_clear_bit(index, &done_map)) {
 967                         isp1362_read_ptd(isp1362_hcd, ep, epq);
 968                         epq->free_ptd = index;
 969                         BUG_ON(ep->num_ptds == 0);
 970                         release_ptd_buffers(epq, ep);
 971
 972                         DBG(1, "%s: ep %p req %d removed from active list\n", __func__,
 973                             ep, ep->num_req);
 974                         if (!list_empty(&ep->remove_list)) {
 975                                 list_del_init(&ep->remove_list);
 976                                 DBG(1, "%s: ep %p removed from remove list\n", __func__, ep);
 977                         }
 978                         DBG(1, "%s: Postprocessing %s ep %p req %d\n", __func__, epq->name,
 979                             ep, ep->num_req);
 980                         postproc_ep(isp1362_hcd, ep);
 981                 }
 982                 if (!done_map)
 983                         break;
 984         }
 985         if (done_map)
 986                 pr_warning("%s: done_map not clear: %08lx:%08lx\n", __func__, done_map,
 987                      epq->skip_map);
 988         atomic_dec(&epq->finishing);
 989 }
 990
 991 static void finish_iso_transfers(struct isp1362_hcd *isp1362_hcd, struct isp1362_ep_queue *epq)
 992 {
 993         struct isp1362_ep *ep;
 994         struct isp1362_ep *tmp;
 995
 996         if (list_empty(&epq->active)) {
 997                 DBG(1, "%s: Nothing to do for %s queue\n", __func__, epq->name);
 998                 return;
 999         }
1000
1001         DBG(1, "%s: Finishing %s transfers\n", __func__, epq->name);
1002
1003         atomic_inc(&epq->finishing);
1004         list_for_each_entry_safe(ep, tmp, &epq->active, active) {
1005                 DBG(1, "%s: Checking PTD $%04x\n", __func__, ep->ptd_offset);
1006
1007                 isp1362_read_ptd(isp1362_hcd, ep, epq);
1008                 DBG(1, "%s: Postprocessing %s ep %p\n", __func__, epq->name, ep);
1009                 postproc_ep(isp1362_hcd, ep);
1010         }
1011         WARN_ON(epq->blk_size != 0);
1012         atomic_dec(&epq->finishing);
1013 }
1014
1015 static irqreturn_t isp1362_irq(struct usb_hcd *hcd)
1016 {
1017         int handled = 0;
1018         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1019         u16 irqstat;
1020         u16 svc_mask;
1021
1022         spin_lock(&isp1362_hcd->lock);
1023
1024         BUG_ON(isp1362_hcd->irq_active++);
1025
1026         isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
1027
1028         irqstat = isp1362_read_reg16(isp1362_hcd, HCuPINT);
1029         DBG(3, "%s: got IRQ %04x:%04x\n", __func__, irqstat, isp1362_hcd->irqenb);
1030
1031         /* only handle interrupts that are currently enabled */
1032         irqstat &= isp1362_hcd->irqenb;
1033         isp1362_write_reg16(isp1362_hcd, HCuPINT, irqstat);
1034         svc_mask = irqstat;
1035
1036         if (irqstat & HCuPINT_SOF) {
1037                 isp1362_hcd->irqenb &= ~HCuPINT_SOF;
1038                 isp1362_hcd->irq_stat[ISP1362_INT_SOF]++;
1039                 handled = 1;
1040                 svc_mask &= ~HCuPINT_SOF;
1041                 DBG(3, "%s: SOF\n", __func__);
1042                 isp1362_hcd->fmindex = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
1043                 if (!list_empty(&isp1362_hcd->remove_list))
1044                         finish_unlinks(isp1362_hcd);
1045                 if (!list_empty(&isp1362_hcd->async) && !(irqstat & HCuPINT_ATL)) {
1046                         if (list_empty(&isp1362_hcd->atl_queue.active)) {
1047                                 start_atl_transfers(isp1362_hcd);
1048                         } else {
1049                                 isp1362_enable_int(isp1362_hcd, HCuPINT_ATL);
1050                                 isp1362_write_reg32(isp1362_hcd, HCATLSKIP,
1051                                                     isp1362_hcd->atl_queue.skip_map);
1052                                 isp1362_set_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
1053                         }
1054                 }
1055         }
1056
1057         if (irqstat & HCuPINT_ISTL0) {
1058                 isp1362_hcd->irq_stat[ISP1362_INT_ISTL0]++;
1059                 handled = 1;
1060                 svc_mask &= ~HCuPINT_ISTL0;
1061                 isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ISTL0_FULL);
1062                 DBG(1, "%s: ISTL0\n", __func__);
1063                 WARN_ON((int)!!isp1362_hcd->istl_flip);
1064                 WARN_ON(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
1065                         HCBUFSTAT_ISTL0_ACTIVE);
1066                 WARN_ON(!(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
1067                         HCBUFSTAT_ISTL0_DONE));
1068                 isp1362_hcd->irqenb &= ~HCuPINT_ISTL0;
1069         }
1070
1071         if (irqstat & HCuPINT_ISTL1) {
1072                 isp1362_hcd->irq_stat[ISP1362_INT_ISTL1]++;
1073                 handled = 1;
1074                 svc_mask &= ~HCuPINT_ISTL1;
1075                 isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ISTL1_FULL);
1076                 DBG(1, "%s: ISTL1\n", __func__);
1077                 WARN_ON(!(int)isp1362_hcd->istl_flip);
1078                 WARN_ON(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
1079                         HCBUFSTAT_ISTL1_ACTIVE);
1080                 WARN_ON(!(isp1362_read_reg16(isp1362_hcd, HCBUFSTAT) &
1081                         HCBUFSTAT_ISTL1_DONE));
1082                 isp1362_hcd->irqenb &= ~HCuPINT_ISTL1;
1083         }
1084
1085         if (irqstat & (HCuPINT_ISTL0 | HCuPINT_ISTL1)) {
1086                 WARN_ON((irqstat & (HCuPINT_ISTL0 | HCuPINT_ISTL1)) ==
1087                         (HCuPINT_ISTL0 | HCuPINT_ISTL1));
1088                 finish_iso_transfers(isp1362_hcd,
1089                                      &isp1362_hcd->istl_queue[isp1362_hcd->istl_flip]);
1090                 start_iso_transfers(isp1362_hcd);
1091                 isp1362_hcd->istl_flip = 1 - isp1362_hcd->istl_flip;
1092         }
1093
1094         if (irqstat & HCuPINT_INTL) {
1095                 u32 done_map = isp1362_read_reg32(isp1362_hcd, HCINTLDONE);
1096                 u32 skip_map = isp1362_read_reg32(isp1362_hcd, HCINTLSKIP);
1097                 isp1362_hcd->irq_stat[ISP1362_INT_INTL]++;
1098
1099                 DBG(2, "%s: INTL\n", __func__);
1100
1101                 svc_mask &= ~HCuPINT_INTL;
1102
1103                 isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, skip_map | done_map);
1104                 if (~(done_map | skip_map) == 0)
1105                         /* All PTDs are finished, disable INTL processing entirely */
1106                         isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_INTL_ACTIVE);
1107
1108                 handled = 1;
1109                 WARN_ON(!done_map);
1110                 if (done_map) {
1111                         DBG(3, "%s: INTL done_map %08x\n", __func__, done_map);
1112                         finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->intl_queue);
1113                         start_intl_transfers(isp1362_hcd);
1114                 }
1115         }
1116
1117         if (irqstat & HCuPINT_ATL) {
1118                 u32 done_map = isp1362_read_reg32(isp1362_hcd, HCATLDONE);
1119                 u32 skip_map = isp1362_read_reg32(isp1362_hcd, HCATLSKIP);
1120                 isp1362_hcd->irq_stat[ISP1362_INT_ATL]++;
1121
1122                 DBG(2, "%s: ATL\n", __func__);
1123
1124                 svc_mask &= ~HCuPINT_ATL;
1125
1126                 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, skip_map | done_map);
1127                 if (~(done_map | skip_map) == 0)
1128                         isp1362_clr_mask16(isp1362_hcd, HCBUFSTAT, HCBUFSTAT_ATL_ACTIVE);
1129                 if (done_map) {
1130                         DBG(3, "%s: ATL done_map %08x\n", __func__, done_map);
1131                         finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->atl_queue);
1132                         start_atl_transfers(isp1362_hcd);
1133                 }
1134                 handled = 1;
1135         }
1136
1137         if (irqstat & HCuPINT_OPR) {
1138                 u32 intstat = isp1362_read_reg32(isp1362_hcd, HCINTSTAT);
1139                 isp1362_hcd->irq_stat[ISP1362_INT_OPR]++;
1140
1141                 svc_mask &= ~HCuPINT_OPR;
1142                 DBG(2, "%s: OPR %08x:%08x\n", __func__, intstat, isp1362_hcd->intenb);
1143                 intstat &= isp1362_hcd->intenb;
1144                 if (intstat & OHCI_INTR_UE) {
1145                         pr_err("Unrecoverable error\n");
1146                         /* FIXME: do here reset or cleanup or whatever */
1147                 }
1148                 if (intstat & OHCI_INTR_RHSC) {
1149                         isp1362_hcd->rhstatus = isp1362_read_reg32(isp1362_hcd, HCRHSTATUS);
1150                         isp1362_hcd->rhport[0] = isp1362_read_reg32(isp1362_hcd, HCRHPORT1);
1151                         isp1362_hcd->rhport[1] = isp1362_read_reg32(isp1362_hcd, HCRHPORT2);
1152                 }
1153                 if (intstat & OHCI_INTR_RD) {
1154                         pr_info("%s: RESUME DETECTED\n", __func__);
1155                         isp1362_show_reg(isp1362_hcd, HCCONTROL);
1156                         usb_hcd_resume_root_hub(hcd);
1157                 }
1158                 isp1362_write_reg32(isp1362_hcd, HCINTSTAT, intstat);
1159                 irqstat &= ~HCuPINT_OPR;
1160                 handled = 1;
1161         }
1162
1163         if (irqstat & HCuPINT_SUSP) {
1164                 isp1362_hcd->irq_stat[ISP1362_INT_SUSP]++;
1165                 handled = 1;
1166                 svc_mask &= ~HCuPINT_SUSP;
1167
1168                 pr_info("%s: SUSPEND IRQ\n", __func__);
1169         }
1170
1171         if (irqstat & HCuPINT_CLKRDY) {
1172                 isp1362_hcd->irq_stat[ISP1362_INT_CLKRDY]++;
1173                 handled = 1;
1174                 isp1362_hcd->irqenb &= ~HCuPINT_CLKRDY;
1175                 svc_mask &= ~HCuPINT_CLKRDY;
1176                 pr_info("%s: CLKRDY IRQ\n", __func__);
1177         }
1178
1179         if (svc_mask)
1180                 pr_err("%s: Unserviced interrupt(s) %04x\n", __func__, svc_mask);
1181
1182         isp1362_write_reg16(isp1362_hcd, HCuPINTENB, isp1362_hcd->irqenb);
1183         isp1362_hcd->irq_active--;
1184         spin_unlock(&isp1362_hcd->lock);
1185
1186         return IRQ_RETVAL(handled);
1187 }
1188
1189 /*-------------------------------------------------------------------------*/
1190
1191 #define MAX_PERIODIC_LOAD       900     /* out of 1000 usec */
1192 static int balance(struct isp1362_hcd *isp1362_hcd, u16 interval, u16 load)
1193 {
1194         int i, branch = -ENOSPC;
1195
1196         /* search for the least loaded schedule branch of that interval
1197          * which has enough bandwidth left unreserved.
1198          */
1199         for (i = 0; i < interval; i++) {
1200                 if (branch < 0 || isp1362_hcd->load[branch] > isp1362_hcd->load[i]) {
1201                         int j;
1202
1203                         for (j = i; j < PERIODIC_SIZE; j += interval) {
1204                                 if ((isp1362_hcd->load[j] + load) > MAX_PERIODIC_LOAD) {
1205                                         pr_err("%s: new load %d load[%02x] %d max %d\n", __func__,
1206                                             load, j, isp1362_hcd->load[j], MAX_PERIODIC_LOAD);
1207                                         break;
1208                                 }
1209                         }
1210                         if (j < PERIODIC_SIZE)
1211                                 continue;
1212                         branch = i;
1213                 }
1214         }
1215         return branch;
1216 }
1217
1218 /* NB! ALL the code above this point runs with isp1362_hcd->lock
1219    held, irqs off
1220 */
1221
1222 /*-------------------------------------------------------------------------*/
1223
1224 static int isp1362_urb_enqueue(struct usb_hcd *hcd,
1225                                struct urb *urb,
1226                                gfp_t mem_flags)
1227 {
1228         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1229         struct usb_device *udev = urb->dev;
1230         unsigned int pipe = urb->pipe;
1231         int is_out = !usb_pipein(pipe);
1232         int type = usb_pipetype(pipe);
1233         int epnum = usb_pipeendpoint(pipe);
1234         struct usb_host_endpoint *hep = urb->ep;
1235         struct isp1362_ep *ep = NULL;
1236         unsigned long flags;
1237         int retval = 0;
1238
1239         DBG(3, "%s: urb %p\n", __func__, urb);
1240
1241         if (type == PIPE_ISOCHRONOUS) {
1242                 pr_err("Isochronous transfers not supported\n");
1243                 return -ENOSPC;
1244         }
1245
1246         URB_DBG("%s: FA %d ep%d%s %s: len %d %s%s\n", __func__,
1247                 usb_pipedevice(pipe), epnum,
1248                 is_out ? "out" : "in",
1249                 usb_pipecontrol(pipe) ? "ctrl" :
1250                         usb_pipeint(pipe) ? "int" :
1251                         usb_pipebulk(pipe) ? "bulk" :
1252                         "iso",
1253                 urb->transfer_buffer_length,
1254                 (urb->transfer_flags & URB_ZERO_PACKET) ? "ZERO_PACKET " : "",
1255                 !(urb->transfer_flags & URB_SHORT_NOT_OK) ?
1256                 "short_ok" : "");
1257
1258         /* avoid all allocations within spinlocks: request or endpoint */
1259         if (!hep->hcpriv) {
1260                 ep = kcalloc(1, sizeof *ep, mem_flags);
1261                 if (!ep)
1262                         return -ENOMEM;
1263         }
1264         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1265
1266         /* don't submit to a dead or disabled port */
1267         if (!((isp1362_hcd->rhport[0] | isp1362_hcd->rhport[1]) &
1268               (1 << USB_PORT_FEAT_ENABLE)) ||
1269             !HC_IS_RUNNING(hcd->state)) {
1270                 kfree(ep);
1271                 retval = -ENODEV;
1272                 goto fail_not_linked;
1273         }
1274
1275         retval = usb_hcd_link_urb_to_ep(hcd, urb);
1276         if (retval) {
1277                 kfree(ep);
1278                 goto fail_not_linked;
1279         }
1280
1281         if (hep->hcpriv) {
1282                 ep = hep->hcpriv;
1283         } else {
1284                 INIT_LIST_HEAD(&ep->schedule);
1285                 INIT_LIST_HEAD(&ep->active);
1286                 INIT_LIST_HEAD(&ep->remove_list);
1287                 ep->udev = usb_get_dev(udev);
1288                 ep->hep = hep;
1289                 ep->epnum = epnum;
1290                 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out);
1291                 ep->ptd_offset = -EINVAL;
1292                 ep->ptd_index = -EINVAL;
1293                 usb_settoggle(udev, epnum, is_out, 0);
1294
1295                 if (type == PIPE_CONTROL)
1296                         ep->nextpid = USB_PID_SETUP;
1297                 else if (is_out)
1298                         ep->nextpid = USB_PID_OUT;
1299                 else
1300                         ep->nextpid = USB_PID_IN;
1301
1302                 switch (type) {
1303                 case PIPE_ISOCHRONOUS:
1304                 case PIPE_INTERRUPT:
1305                         if (urb->interval > PERIODIC_SIZE)
1306                                 urb->interval = PERIODIC_SIZE;
1307                         ep->interval = urb->interval;
1308                         ep->branch = PERIODIC_SIZE;
1309                         ep->load = usb_calc_bus_time(udev->speed, !is_out,
1310                                                      (type == PIPE_ISOCHRONOUS),
1311                                                      usb_maxpacket(udev, pipe, is_out)) / 1000;
1312                         break;
1313                 }
1314                 hep->hcpriv = ep;
1315         }
1316         ep->num_req = isp1362_hcd->req_serial++;
1317
1318         /* maybe put endpoint into schedule */
1319         switch (type) {
1320         case PIPE_CONTROL:
1321         case PIPE_BULK:
1322                 if (list_empty(&ep->schedule)) {
1323                         DBG(1, "%s: Adding ep %p req %d to async schedule\n",
1324                                 __func__, ep, ep->num_req);
1325                         list_add_tail(&ep->schedule, &isp1362_hcd->async);
1326                 }
1327                 break;
1328         case PIPE_ISOCHRONOUS:
1329         case PIPE_INTERRUPT:
1330                 urb->interval = ep->interval;
1331
1332                 /* urb submitted for already existing EP */
1333                 if (ep->branch < PERIODIC_SIZE)
1334                         break;
1335
1336                 retval = balance(isp1362_hcd, ep->interval, ep->load);
1337                 if (retval < 0) {
1338                         pr_err("%s: balance returned %d\n", __func__, retval);
1339                         goto fail;
1340                 }
1341                 ep->branch = retval;
1342                 retval = 0;
1343                 isp1362_hcd->fmindex = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
1344                 DBG(1, "%s: Current frame %04x branch %02x start_frame %04x(%04x)\n",
1345                     __func__, isp1362_hcd->fmindex, ep->branch,
1346                     ((isp1362_hcd->fmindex + PERIODIC_SIZE - 1) &
1347                      ~(PERIODIC_SIZE - 1)) + ep->branch,
1348                     (isp1362_hcd->fmindex & (PERIODIC_SIZE - 1)) + ep->branch);
1349
1350                 if (list_empty(&ep->schedule)) {
1351                         if (type == PIPE_ISOCHRONOUS) {
1352                                 u16 frame = isp1362_hcd->fmindex;
1353
1354                                 frame += max_t(u16, 8, ep->interval);
1355                                 frame &= ~(ep->interval - 1);
1356                                 frame |= ep->branch;
1357                                 if (frame_before(frame, isp1362_hcd->fmindex))
1358                                         frame += ep->interval;
1359                                 urb->start_frame = frame;
1360
1361                                 DBG(1, "%s: Adding ep %p to isoc schedule\n", __func__, ep);
1362                                 list_add_tail(&ep->schedule, &isp1362_hcd->isoc);
1363                         } else {
1364                                 DBG(1, "%s: Adding ep %p to periodic schedule\n", __func__, ep);
1365                                 list_add_tail(&ep->schedule, &isp1362_hcd->periodic);
1366                         }
1367                 } else
1368                         DBG(1, "%s: ep %p already scheduled\n", __func__, ep);
1369
1370                 DBG(2, "%s: load %d bandwidth %d -> %d\n", __func__,
1371                     ep->load / ep->interval, isp1362_hcd->load[ep->branch],
1372                     isp1362_hcd->load[ep->branch] + ep->load);
1373                 isp1362_hcd->load[ep->branch] += ep->load;
1374         }
1375
1376         urb->hcpriv = hep;
1377         ALIGNSTAT(isp1362_hcd, urb->transfer_buffer);
1378
1379         switch (type) {
1380         case PIPE_CONTROL:
1381         case PIPE_BULK:
1382                 start_atl_transfers(isp1362_hcd);
1383                 break;
1384         case PIPE_INTERRUPT:
1385                 start_intl_transfers(isp1362_hcd);
1386                 break;
1387         case PIPE_ISOCHRONOUS:
1388                 start_iso_transfers(isp1362_hcd);
1389                 break;
1390         default:
1391                 BUG();
1392         }
1393  fail:
1394         if (retval)
1395                 usb_hcd_unlink_urb_from_ep(hcd, urb);
1396
1397
1398  fail_not_linked:
1399         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1400         if (retval)
1401                 DBG(0, "%s: urb %p failed with %d\n", __func__, urb, retval);
1402         return retval;
1403 }
1404
1405 static int isp1362_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1406 {
1407         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1408         struct usb_host_endpoint *hep;
1409         unsigned long flags;
1410         struct isp1362_ep *ep;
1411         int retval = 0;
1412
1413         DBG(3, "%s: urb %p\n", __func__, urb);
1414
1415         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1416         retval = usb_hcd_check_unlink_urb(hcd, urb, status);
1417         if (retval)
1418                 goto done;
1419
1420         hep = urb->hcpriv;
1421
1422         if (!hep) {
1423                 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1424                 return -EIDRM;
1425         }
1426
1427         ep = hep->hcpriv;
1428         if (ep) {
1429                 /* In front of queue? */
1430                 if (ep->hep->urb_list.next == &urb->urb_list) {
1431                         if (!list_empty(&ep->active)) {
1432                                 DBG(1, "%s: urb %p ep %p req %d active PTD[%d] $%04x\n", __func__,
1433                                     urb, ep, ep->num_req, ep->ptd_index, ep->ptd_offset);
1434                                 /* disable processing and queue PTD for removal */
1435                                 remove_ptd(isp1362_hcd, ep);
1436                                 urb = NULL;
1437                         }
1438                 }
1439                 if (urb) {
1440                         DBG(1, "%s: Finishing ep %p req %d\n", __func__, ep,
1441                             ep->num_req);
1442                         finish_request(isp1362_hcd, ep, urb, status);
1443                 } else
1444                         DBG(1, "%s: urb %p active; wait4irq\n", __func__, urb);
1445         } else {
1446                 pr_warning("%s: No EP in URB %p\n", __func__, urb);
1447                 retval = -EINVAL;
1448         }
1449 done:
1450         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1451
1452         DBG(3, "%s: exit\n", __func__);
1453
1454         return retval;
1455 }
1456
1457 static void isp1362_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep)
1458 {
1459         struct isp1362_ep *ep = hep->hcpriv;
1460         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1461         unsigned long flags;
1462
1463         DBG(1, "%s: ep %p\n", __func__, ep);
1464         if (!ep)
1465                 return;
1466         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1467         if (!list_empty(&hep->urb_list)) {
1468                 if (!list_empty(&ep->active) && list_empty(&ep->remove_list)) {
1469                         DBG(1, "%s: Removing ep %p req %d PTD[%d] $%04x\n", __func__,
1470                             ep, ep->num_req, ep->ptd_index, ep->ptd_offset);
1471                         remove_ptd(isp1362_hcd, ep);
1472                         pr_info("%s: Waiting for Interrupt to clean up\n", __func__);
1473                 }
1474         }
1475         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1476         /* Wait for interrupt to clear out active list */
1477         while (!list_empty(&ep->active))
1478                 msleep(1);
1479
1480         DBG(1, "%s: Freeing EP %p\n", __func__, ep);
1481
1482         usb_put_dev(ep->udev);
1483         kfree(ep);
1484         hep->hcpriv = NULL;
1485 }
1486
1487 static int isp1362_get_frame(struct usb_hcd *hcd)
1488 {
1489         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1490         u32 fmnum;
1491         unsigned long flags;
1492
1493         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1494         fmnum = isp1362_read_reg32(isp1362_hcd, HCFMNUM);
1495         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1496
1497         return (int)fmnum;
1498 }
1499
1500 /*-------------------------------------------------------------------------*/
1501
1502 /* Adapted from ohci-hub.c */
1503 static int isp1362_hub_status_data(struct usb_hcd *hcd, char *buf)
1504 {
1505         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1506         int ports, i, changed = 0;
1507         unsigned long flags;
1508
1509         if (!HC_IS_RUNNING(hcd->state))
1510                 return -ESHUTDOWN;
1511
1512         /* Report no status change now, if we are scheduled to be
1513            called later */
1514         if (timer_pending(&hcd->rh_timer))
1515                 return 0;
1516
1517         ports = isp1362_hcd->rhdesca & RH_A_NDP;
1518         BUG_ON(ports > 2);
1519
1520         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1521         /* init status */
1522         if (isp1362_hcd->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
1523                 buf[0] = changed = 1;
1524         else
1525                 buf[0] = 0;
1526
1527         for (i = 0; i < ports; i++) {
1528                 u32 status = isp1362_hcd->rhport[i];
1529
1530                 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC |
1531                               RH_PS_OCIC | RH_PS_PRSC)) {
1532                         changed = 1;
1533                         buf[0] |= 1 << (i + 1);
1534                         continue;
1535                 }
1536
1537                 if (!(status & RH_PS_CCS))
1538                         continue;
1539         }
1540         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1541         return changed;
1542 }
1543
1544 static void isp1362_hub_descriptor(struct isp1362_hcd *isp1362_hcd,
1545                                    struct usb_hub_descriptor *desc)
1546 {
1547         u32 reg = isp1362_hcd->rhdesca;
1548
1549         DBG(3, "%s: enter\n", __func__);
1550
1551         desc->bDescriptorType = 0x29;
1552         desc->bDescLength = 9;
1553         desc->bHubContrCurrent = 0;
1554         desc->bNbrPorts = reg & 0x3;
1555         /* Power switching, device type, overcurrent. */
1556         desc->wHubCharacteristics = cpu_to_le16((reg >> 8) & 0x1f);
1557         DBG(0, "%s: hubcharacteristics = %02x\n", __func__, cpu_to_le16((reg >> 8) & 0x1f));
1558         desc->bPwrOn2PwrGood = (reg >> 24) & 0xff;
1559         /* two bitmaps:  ports removable, and legacy PortPwrCtrlMask */
1560         desc->bitmap[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1;
1561         desc->bitmap[1] = ~0;
1562
1563         DBG(3, "%s: exit\n", __func__);
1564 }
1565
1566 /* Adapted from ohci-hub.c */
1567 static int isp1362_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
1568                                u16 wIndex, char *buf, u16 wLength)
1569 {
1570         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1571         int retval = 0;
1572         unsigned long flags;
1573         unsigned long t1;
1574         int ports = isp1362_hcd->rhdesca & RH_A_NDP;
1575         u32 tmp = 0;
1576
1577         switch (typeReq) {
1578         case ClearHubFeature:
1579                 DBG(0, "ClearHubFeature: ");
1580                 switch (wValue) {
1581                 case C_HUB_OVER_CURRENT:
1582                         _DBG(0, "C_HUB_OVER_CURRENT\n");
1583                         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1584                         isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_OCIC);
1585                         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1586                 case C_HUB_LOCAL_POWER:
1587                         _DBG(0, "C_HUB_LOCAL_POWER\n");
1588                         break;
1589                 default:
1590                         goto error;
1591                 }
1592                 break;
1593         case SetHubFeature:
1594                 DBG(0, "SetHubFeature: ");
1595                 switch (wValue) {
1596                 case C_HUB_OVER_CURRENT:
1597                 case C_HUB_LOCAL_POWER:
1598                         _DBG(0, "C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n");
1599                         break;
1600                 default:
1601                         goto error;
1602                 }
1603                 break;
1604         case GetHubDescriptor:
1605                 DBG(0, "GetHubDescriptor\n");
1606                 isp1362_hub_descriptor(isp1362_hcd, (struct usb_hub_descriptor *)buf);
1607                 break;
1608         case GetHubStatus:
1609                 DBG(0, "GetHubStatus\n");
1610                 put_unaligned(cpu_to_le32(0), (__le32 *) buf);
1611                 break;
1612         case GetPortStatus:
1613 #ifndef VERBOSE
1614                 DBG(0, "GetPortStatus\n");
1615 #endif
1616                 if (!wIndex || wIndex > ports)
1617                         goto error;
1618                 tmp = isp1362_hcd->rhport[--wIndex];
1619                 put_unaligned(cpu_to_le32(tmp), (__le32 *) buf);
1620                 break;
1621         case ClearPortFeature:
1622                 DBG(0, "ClearPortFeature: ");
1623                 if (!wIndex || wIndex > ports)
1624                         goto error;
1625                 wIndex--;
1626
1627                 switch (wValue) {
1628                 case USB_PORT_FEAT_ENABLE:
1629                         _DBG(0, "USB_PORT_FEAT_ENABLE\n");
1630                         tmp = RH_PS_CCS;
1631                         break;
1632                 case USB_PORT_FEAT_C_ENABLE:
1633                         _DBG(0, "USB_PORT_FEAT_C_ENABLE\n");
1634                         tmp = RH_PS_PESC;
1635                         break;
1636                 case USB_PORT_FEAT_SUSPEND:
1637                         _DBG(0, "USB_PORT_FEAT_SUSPEND\n");
1638                         tmp = RH_PS_POCI;
1639                         break;
1640                 case USB_PORT_FEAT_C_SUSPEND:
1641                         _DBG(0, "USB_PORT_FEAT_C_SUSPEND\n");
1642                         tmp = RH_PS_PSSC;
1643                         break;
1644                 case USB_PORT_FEAT_POWER:
1645                         _DBG(0, "USB_PORT_FEAT_POWER\n");
1646                         tmp = RH_PS_LSDA;
1647
1648                         break;
1649                 case USB_PORT_FEAT_C_CONNECTION:
1650                         _DBG(0, "USB_PORT_FEAT_C_CONNECTION\n");
1651                         tmp = RH_PS_CSC;
1652                         break;
1653                 case USB_PORT_FEAT_C_OVER_CURRENT:
1654                         _DBG(0, "USB_PORT_FEAT_C_OVER_CURRENT\n");
1655                         tmp = RH_PS_OCIC;
1656                         break;
1657                 case USB_PORT_FEAT_C_RESET:
1658                         _DBG(0, "USB_PORT_FEAT_C_RESET\n");
1659                         tmp = RH_PS_PRSC;
1660                         break;
1661                 default:
1662                         goto error;
1663                 }
1664
1665                 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1666                 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, tmp);
1667                 isp1362_hcd->rhport[wIndex] =
1668                         isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1669                 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1670                 break;
1671         case SetPortFeature:
1672                 DBG(0, "SetPortFeature: ");
1673                 if (!wIndex || wIndex > ports)
1674                         goto error;
1675                 wIndex--;
1676                 switch (wValue) {
1677                 case USB_PORT_FEAT_SUSPEND:
1678                         _DBG(0, "USB_PORT_FEAT_SUSPEND\n");
1679 #ifdef  CONFIG_USB_OTG
1680                         if (ohci->hcd.self.otg_port == (wIndex + 1) &&
1681                             ohci->hcd.self.b_hnp_enable) {
1682                                 start_hnp(ohci);
1683                                 break;
1684                         }
1685 #endif
1686                         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1687                         isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PSS);
1688                         isp1362_hcd->rhport[wIndex] =
1689                                 isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1690                         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1691                         break;
1692                 case USB_PORT_FEAT_POWER:
1693                         _DBG(0, "USB_PORT_FEAT_POWER\n");
1694                         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1695                         isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, RH_PS_PPS);
1696                         isp1362_hcd->rhport[wIndex] =
1697                                 isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1698                         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1699                         break;
1700                 case USB_PORT_FEAT_RESET:
1701                         _DBG(0, "USB_PORT_FEAT_RESET\n");
1702                         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1703
1704                         t1 = jiffies + msecs_to_jiffies(USB_RESET_WIDTH);
1705                         while (time_before(jiffies, t1)) {
1706                                 /* spin until any current reset finishes */
1707                                 for (;;) {
1708                                         tmp = isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + wIndex);
1709                                         if (!(tmp & RH_PS_PRS))
1710                                                 break;
1711                                         udelay(500);
1712                                 }
1713                                 if (!(tmp & RH_PS_CCS))
1714                                         break;
1715                                 /* Reset lasts 10ms (claims datasheet) */
1716                                 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + wIndex, (RH_PS_PRS));
1717
1718                                 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1719                                 msleep(10);
1720                                 spin_lock_irqsave(&isp1362_hcd->lock, flags);
1721                         }
1722
1723                         isp1362_hcd->rhport[wIndex] = isp1362_read_reg32(isp1362_hcd,
1724                                                                          HCRHPORT1 + wIndex);
1725                         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1726                         break;
1727                 default:
1728                         goto error;
1729                 }
1730                 break;
1731
1732         default:
1733  error:
1734                 /* "protocol stall" on error */
1735                 _DBG(0, "PROTOCOL STALL\n");
1736                 retval = -EPIPE;
1737         }
1738
1739         return retval;
1740 }
1741
1742 #ifdef  CONFIG_PM
1743 static int isp1362_bus_suspend(struct usb_hcd *hcd)
1744 {
1745         int status = 0;
1746         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1747         unsigned long flags;
1748
1749         if (time_before(jiffies, isp1362_hcd->next_statechange))
1750                 msleep(5);
1751
1752         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1753
1754         isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
1755         switch (isp1362_hcd->hc_control & OHCI_CTRL_HCFS) {
1756         case OHCI_USB_RESUME:
1757                 DBG(0, "%s: resume/suspend?\n", __func__);
1758                 isp1362_hcd->hc_control &= ~OHCI_CTRL_HCFS;
1759                 isp1362_hcd->hc_control |= OHCI_USB_RESET;
1760                 isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1761                 /* FALL THROUGH */
1762         case OHCI_USB_RESET:
1763                 status = -EBUSY;
1764                 pr_warning("%s: needs reinit!\n", __func__);
1765                 goto done;
1766         case OHCI_USB_SUSPEND:
1767                 pr_warning("%s: already suspended?\n", __func__);
1768                 goto done;
1769         }
1770         DBG(0, "%s: suspend root hub\n", __func__);
1771
1772         /* First stop any processing */
1773         hcd->state = HC_STATE_QUIESCING;
1774         if (!list_empty(&isp1362_hcd->atl_queue.active) ||
1775             !list_empty(&isp1362_hcd->intl_queue.active) ||
1776             !list_empty(&isp1362_hcd->istl_queue[0] .active) ||
1777             !list_empty(&isp1362_hcd->istl_queue[1] .active)) {
1778                 int limit;
1779
1780                 isp1362_write_reg32(isp1362_hcd, HCATLSKIP, ~0);
1781                 isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, ~0);
1782                 isp1362_write_reg16(isp1362_hcd, HCBUFSTAT, 0);
1783                 isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
1784                 isp1362_write_reg32(isp1362_hcd, HCINTSTAT, OHCI_INTR_SF);
1785
1786                 DBG(0, "%s: stopping schedules ...\n", __func__);
1787                 limit = 2000;
1788                 while (limit > 0) {
1789                         udelay(250);
1790                         limit -= 250;
1791                         if (isp1362_read_reg32(isp1362_hcd, HCINTSTAT) & OHCI_INTR_SF)
1792                                 break;
1793                 }
1794                 mdelay(7);
1795                 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ATL) {
1796                         u32 done_map = isp1362_read_reg32(isp1362_hcd, HCATLDONE);
1797                         finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->atl_queue);
1798                 }
1799                 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_INTL) {
1800                         u32 done_map = isp1362_read_reg32(isp1362_hcd, HCINTLDONE);
1801                         finish_transfers(isp1362_hcd, done_map, &isp1362_hcd->intl_queue);
1802                 }
1803                 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ISTL0)
1804                         finish_iso_transfers(isp1362_hcd, &isp1362_hcd->istl_queue[0]);
1805                 if (isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_ISTL1)
1806                         finish_iso_transfers(isp1362_hcd, &isp1362_hcd->istl_queue[1]);
1807         }
1808         DBG(0, "%s: HCINTSTAT: %08x\n", __func__,
1809                     isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
1810         isp1362_write_reg32(isp1362_hcd, HCINTSTAT,
1811                             isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
1812
1813         /* Suspend hub */
1814         isp1362_hcd->hc_control = OHCI_USB_SUSPEND;
1815         isp1362_show_reg(isp1362_hcd, HCCONTROL);
1816         isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1817         isp1362_show_reg(isp1362_hcd, HCCONTROL);
1818
1819 #if 1
1820         isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
1821         if ((isp1362_hcd->hc_control & OHCI_CTRL_HCFS) != OHCI_USB_SUSPEND) {
1822                 pr_err("%s: controller won't suspend %08x\n", __func__,
1823                     isp1362_hcd->hc_control);
1824                 status = -EBUSY;
1825         } else
1826 #endif
1827         {
1828                 /* no resumes until devices finish suspending */
1829                 isp1362_hcd->next_statechange = jiffies + msecs_to_jiffies(5);
1830         }
1831 done:
1832         if (status == 0) {
1833                 hcd->state = HC_STATE_SUSPENDED;
1834                 DBG(0, "%s: HCD suspended: %08x\n", __func__,
1835                     isp1362_read_reg32(isp1362_hcd, HCCONTROL));
1836         }
1837         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1838         return status;
1839 }
1840
1841 static int isp1362_bus_resume(struct usb_hcd *hcd)
1842 {
1843         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
1844         u32 port;
1845         unsigned long flags;
1846         int status = -EINPROGRESS;
1847
1848         if (time_before(jiffies, isp1362_hcd->next_statechange))
1849                 msleep(5);
1850
1851         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1852         isp1362_hcd->hc_control = isp1362_read_reg32(isp1362_hcd, HCCONTROL);
1853         pr_info("%s: HCCONTROL: %08x\n", __func__, isp1362_hcd->hc_control);
1854         if (hcd->state == HC_STATE_RESUMING) {
1855                 pr_warning("%s: duplicate resume\n", __func__);
1856                 status = 0;
1857         } else
1858                 switch (isp1362_hcd->hc_control & OHCI_CTRL_HCFS) {
1859                 case OHCI_USB_SUSPEND:
1860                         DBG(0, "%s: resume root hub\n", __func__);
1861                         isp1362_hcd->hc_control &= ~OHCI_CTRL_HCFS;
1862                         isp1362_hcd->hc_control |= OHCI_USB_RESUME;
1863                         isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1864                         break;
1865                 case OHCI_USB_RESUME:
1866                         /* HCFS changes sometime after INTR_RD */
1867                         DBG(0, "%s: remote wakeup\n", __func__);
1868                         break;
1869                 case OHCI_USB_OPER:
1870                         DBG(0, "%s: odd resume\n", __func__);
1871                         status = 0;
1872                         hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1873                         break;
1874                 default:                /* RESET, we lost power */
1875                         DBG(0, "%s: root hub hardware reset\n", __func__);
1876                         status = -EBUSY;
1877                 }
1878         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1879         if (status == -EBUSY) {
1880                 DBG(0, "%s: Restarting HC\n", __func__);
1881                 isp1362_hc_stop(hcd);
1882                 return isp1362_hc_start(hcd);
1883         }
1884         if (status != -EINPROGRESS)
1885                 return status;
1886         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1887         port = isp1362_read_reg32(isp1362_hcd, HCRHDESCA) & RH_A_NDP;
1888         while (port--) {
1889                 u32 stat = isp1362_read_reg32(isp1362_hcd, HCRHPORT1 + port);
1890
1891                 /* force global, not selective, resume */
1892                 if (!(stat & RH_PS_PSS)) {
1893                         DBG(0, "%s: Not Resuming RH port %d\n", __func__, port);
1894                         continue;
1895                 }
1896                 DBG(0, "%s: Resuming RH port %d\n", __func__, port);
1897                 isp1362_write_reg32(isp1362_hcd, HCRHPORT1 + port, RH_PS_POCI);
1898         }
1899         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1900
1901         /* Some controllers (lucent) need extra-long delays */
1902         hcd->state = HC_STATE_RESUMING;
1903         mdelay(20 /* usb 11.5.1.10 */ + 15);
1904
1905         isp1362_hcd->hc_control = OHCI_USB_OPER;
1906         spin_lock_irqsave(&isp1362_hcd->lock, flags);
1907         isp1362_show_reg(isp1362_hcd, HCCONTROL);
1908         isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
1909         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
1910         /* TRSMRCY */
1911         msleep(10);
1912
1913         /* keep it alive for ~5x suspend + resume costs */
1914         isp1362_hcd->next_statechange = jiffies + msecs_to_jiffies(250);
1915
1916         hcd->self.root_hub->dev.power.power_state = PMSG_ON;
1917         hcd->state = HC_STATE_RUNNING;
1918         return 0;
1919 }
1920 #else
1921 #define isp1362_bus_suspend     NULL
1922 #define isp1362_bus_resume      NULL
1923 #endif
1924
1925 /*-------------------------------------------------------------------------*/
1926
1927 #ifdef STUB_DEBUG_FILE
1928
1929 static inline void create_debug_file(struct isp1362_hcd *isp1362_hcd)
1930 {
1931 }
1932 static inline void remove_debug_file(struct isp1362_hcd *isp1362_hcd)
1933 {
1934 }
1935
1936 #else
1937
1938 #include <linux/proc_fs.h>
1939 #include <linux/seq_file.h>
1940
1941 static void dump_irq(struct seq_file *s, char *label, u16 mask)
1942 {
1943         seq_printf(s, "%-15s %04x%s%s%s%s%s%s\n", label, mask,
1944                    mask & HCuPINT_CLKRDY ? " clkrdy" : "",
1945                    mask & HCuPINT_SUSP ? " susp" : "",
1946                    mask & HCuPINT_OPR ? " opr" : "",
1947                    mask & HCuPINT_EOT ? " eot" : "",
1948                    mask & HCuPINT_ATL ? " atl" : "",
1949                    mask & HCuPINT_SOF ? " sof" : "");
1950 }
1951
1952 static void dump_int(struct seq_file *s, char *label, u32 mask)
1953 {
1954         seq_printf(s, "%-15s %08x%s%s%s%s%s%s%s\n", label, mask,
1955                    mask & OHCI_INTR_MIE ? " MIE" : "",
1956                    mask & OHCI_INTR_RHSC ? " rhsc" : "",
1957                    mask & OHCI_INTR_FNO ? " fno" : "",
1958                    mask & OHCI_INTR_UE ? " ue" : "",
1959                    mask & OHCI_INTR_RD ? " rd" : "",
1960                    mask & OHCI_INTR_SF ? " sof" : "",
1961                    mask & OHCI_INTR_SO ? " so" : "");
1962 }
1963
1964 static void dump_ctrl(struct seq_file *s, char *label, u32 mask)
1965 {
1966         seq_printf(s, "%-15s %08x%s%s%s\n", label, mask,
1967                    mask & OHCI_CTRL_RWC ? " rwc" : "",
1968                    mask & OHCI_CTRL_RWE ? " rwe" : "",
1969                    ({
1970                            char *hcfs;
1971                            switch (mask & OHCI_CTRL_HCFS) {
1972                            case OHCI_USB_OPER:
1973                                    hcfs = " oper";
1974                                    break;
1975                            case OHCI_USB_RESET:
1976                                    hcfs = " reset";
1977                                    break;
1978                            case OHCI_USB_RESUME:
1979                                    hcfs = " resume";
1980                                    break;
1981                            case OHCI_USB_SUSPEND:
1982                                    hcfs = " suspend";
1983                                    break;
1984                            default:
1985                                    hcfs = " ?";
1986                            }
1987                            hcfs;
1988                    }));
1989 }
1990
1991 static void dump_regs(struct seq_file *s, struct isp1362_hcd *isp1362_hcd)
1992 {
1993         seq_printf(s, "HCREVISION [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCREVISION),
1994                    isp1362_read_reg32(isp1362_hcd, HCREVISION));
1995         seq_printf(s, "HCCONTROL  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCCONTROL),
1996                    isp1362_read_reg32(isp1362_hcd, HCCONTROL));
1997         seq_printf(s, "HCCMDSTAT  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCCMDSTAT),
1998                    isp1362_read_reg32(isp1362_hcd, HCCMDSTAT));
1999         seq_printf(s, "HCINTSTAT  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTSTAT),
2000                    isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
2001         seq_printf(s, "HCINTENB   [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTENB),
2002                    isp1362_read_reg32(isp1362_hcd, HCINTENB));
2003         seq_printf(s, "HCFMINTVL  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMINTVL),
2004                    isp1362_read_reg32(isp1362_hcd, HCFMINTVL));
2005         seq_printf(s, "HCFMREM    [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMREM),
2006                    isp1362_read_reg32(isp1362_hcd, HCFMREM));
2007         seq_printf(s, "HCFMNUM    [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCFMNUM),
2008                    isp1362_read_reg32(isp1362_hcd, HCFMNUM));
2009         seq_printf(s, "HCLSTHRESH [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCLSTHRESH),
2010                    isp1362_read_reg32(isp1362_hcd, HCLSTHRESH));
2011         seq_printf(s, "HCRHDESCA  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHDESCA),
2012                    isp1362_read_reg32(isp1362_hcd, HCRHDESCA));
2013         seq_printf(s, "HCRHDESCB  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHDESCB),
2014                    isp1362_read_reg32(isp1362_hcd, HCRHDESCB));
2015         seq_printf(s, "HCRHSTATUS [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHSTATUS),
2016                    isp1362_read_reg32(isp1362_hcd, HCRHSTATUS));
2017         seq_printf(s, "HCRHPORT1  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHPORT1),
2018                    isp1362_read_reg32(isp1362_hcd, HCRHPORT1));
2019         seq_printf(s, "HCRHPORT2  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCRHPORT2),
2020                    isp1362_read_reg32(isp1362_hcd, HCRHPORT2));
2021         seq_printf(s, "\n");
2022         seq_printf(s, "HCHWCFG    [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCHWCFG),
2023                    isp1362_read_reg16(isp1362_hcd, HCHWCFG));
2024         seq_printf(s, "HCDMACFG   [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCDMACFG),
2025                    isp1362_read_reg16(isp1362_hcd, HCDMACFG));
2026         seq_printf(s, "HCXFERCTR  [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCXFERCTR),
2027                    isp1362_read_reg16(isp1362_hcd, HCXFERCTR));
2028         seq_printf(s, "HCuPINT    [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCuPINT),
2029                    isp1362_read_reg16(isp1362_hcd, HCuPINT));
2030         seq_printf(s, "HCuPINTENB [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCuPINTENB),
2031                    isp1362_read_reg16(isp1362_hcd, HCuPINTENB));
2032         seq_printf(s, "HCCHIPID   [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCCHIPID),
2033                    isp1362_read_reg16(isp1362_hcd, HCCHIPID));
2034         seq_printf(s, "HCSCRATCH  [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCSCRATCH),
2035                    isp1362_read_reg16(isp1362_hcd, HCSCRATCH));
2036         seq_printf(s, "HCBUFSTAT  [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCBUFSTAT),
2037                    isp1362_read_reg16(isp1362_hcd, HCBUFSTAT));
2038         seq_printf(s, "HCDIRADDR  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCDIRADDR),
2039                    isp1362_read_reg32(isp1362_hcd, HCDIRADDR));
2040 #if 0
2041         seq_printf(s, "HCDIRDATA  [%02x]     %04x\n", ISP1362_REG_NO(HCDIRDATA),
2042                    isp1362_read_reg16(isp1362_hcd, HCDIRDATA));
2043 #endif
2044         seq_printf(s, "HCISTLBUFSZ[%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCISTLBUFSZ),
2045                    isp1362_read_reg16(isp1362_hcd, HCISTLBUFSZ));
2046         seq_printf(s, "HCISTLRATE [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCISTLRATE),
2047                    isp1362_read_reg16(isp1362_hcd, HCISTLRATE));
2048         seq_printf(s, "\n");
2049         seq_printf(s, "HCINTLBUFSZ[%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLBUFSZ),
2050                    isp1362_read_reg16(isp1362_hcd, HCINTLBUFSZ));
2051         seq_printf(s, "HCINTLBLKSZ[%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLBLKSZ),
2052                    isp1362_read_reg16(isp1362_hcd, HCINTLBLKSZ));
2053         seq_printf(s, "HCINTLDONE [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLDONE),
2054                    isp1362_read_reg32(isp1362_hcd, HCINTLDONE));
2055         seq_printf(s, "HCINTLSKIP [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLSKIP),
2056                    isp1362_read_reg32(isp1362_hcd, HCINTLSKIP));
2057         seq_printf(s, "HCINTLLAST [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLLAST),
2058                    isp1362_read_reg32(isp1362_hcd, HCINTLLAST));
2059         seq_printf(s, "HCINTLCURR [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCINTLCURR),
2060                    isp1362_read_reg16(isp1362_hcd, HCINTLCURR));
2061         seq_printf(s, "\n");
2062         seq_printf(s, "HCATLBUFSZ [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLBUFSZ),
2063                    isp1362_read_reg16(isp1362_hcd, HCATLBUFSZ));
2064         seq_printf(s, "HCATLBLKSZ [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLBLKSZ),
2065                    isp1362_read_reg16(isp1362_hcd, HCATLBLKSZ));
2066 #if 0
2067         seq_printf(s, "HCATLDONE  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDONE),
2068                    isp1362_read_reg32(isp1362_hcd, HCATLDONE));
2069 #endif
2070         seq_printf(s, "HCATLSKIP  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLSKIP),
2071                    isp1362_read_reg32(isp1362_hcd, HCATLSKIP));
2072         seq_printf(s, "HCATLLAST  [%02x] %08x\n", ISP1362_REG_NO(ISP1362_REG_HCATLLAST),
2073                    isp1362_read_reg32(isp1362_hcd, HCATLLAST));
2074         seq_printf(s, "HCATLCURR  [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLCURR),
2075                    isp1362_read_reg16(isp1362_hcd, HCATLCURR));
2076         seq_printf(s, "\n");
2077         seq_printf(s, "HCATLDTC   [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDTC),
2078                    isp1362_read_reg16(isp1362_hcd, HCATLDTC));
2079         seq_printf(s, "HCATLDTCTO [%02x]     %04x\n", ISP1362_REG_NO(ISP1362_REG_HCATLDTCTO),
2080                    isp1362_read_reg16(isp1362_hcd, HCATLDTCTO));
2081 }
2082
2083 static int proc_isp1362_show(struct seq_file *s, void *unused)
2084 {
2085         struct isp1362_hcd *isp1362_hcd = s->private;
2086         struct isp1362_ep *ep;
2087         int i;
2088
2089         seq_printf(s, "%s\n%s version %s\n",
2090                    isp1362_hcd_to_hcd(isp1362_hcd)->product_desc, hcd_name, DRIVER_VERSION);
2091
2092         /* collect statistics to help estimate potential win for
2093          * DMA engines that care about alignment (PXA)
2094          */
2095         seq_printf(s, "alignment:  16b/%ld 8b/%ld 4b/%ld 2b/%ld 1b/%ld\n",
2096                    isp1362_hcd->stat16, isp1362_hcd->stat8, isp1362_hcd->stat4,
2097                    isp1362_hcd->stat2, isp1362_hcd->stat1);
2098         seq_printf(s, "max # ptds in ATL  fifo: %d\n", isp1362_hcd->atl_queue.stat_maxptds);
2099         seq_printf(s, "max # ptds in INTL fifo: %d\n", isp1362_hcd->intl_queue.stat_maxptds);
2100         seq_printf(s, "max # ptds in ISTL fifo: %d\n",
2101                    max(isp1362_hcd->istl_queue[0] .stat_maxptds,
2102                        isp1362_hcd->istl_queue[1] .stat_maxptds));
2103
2104         /* FIXME: don't show the following in suspended state */
2105         spin_lock_irq(&isp1362_hcd->lock);
2106
2107         dump_irq(s, "hc_irq_enable", isp1362_read_reg16(isp1362_hcd, HCuPINTENB));
2108         dump_irq(s, "hc_irq_status", isp1362_read_reg16(isp1362_hcd, HCuPINT));
2109         dump_int(s, "ohci_int_enable", isp1362_read_reg32(isp1362_hcd, HCINTENB));
2110         dump_int(s, "ohci_int_status", isp1362_read_reg32(isp1362_hcd, HCINTSTAT));
2111         dump_ctrl(s, "ohci_control", isp1362_read_reg32(isp1362_hcd, HCCONTROL));
2112
2113         for (i = 0; i < NUM_ISP1362_IRQS; i++)
2114                 if (isp1362_hcd->irq_stat[i])
2115                         seq_printf(s, "%-15s: %d\n",
2116                                    ISP1362_INT_NAME(i), isp1362_hcd->irq_stat[i]);
2117
2118         dump_regs(s, isp1362_hcd);
2119         list_for_each_entry(ep, &isp1362_hcd->async, schedule) {
2120                 struct urb *urb;
2121
2122                 seq_printf(s, "%p, ep%d%s, maxpacket %d:\n", ep, ep->epnum,
2123                            ({
2124                                    char *s;
2125                                    switch (ep->nextpid) {
2126                                    case USB_PID_IN:
2127                                            s = "in";
2128                                            break;
2129                                    case USB_PID_OUT:
2130                                            s = "out";
2131                                            break;
2132                                    case USB_PID_SETUP:
2133                                            s = "setup";
2134                                            break;
2135                                    case USB_PID_ACK:
2136                                            s = "status";
2137                                            break;
2138                                    default:
2139                                            s = "?";
2140                                            break;
2141                                    };
2142                                    s;}), ep->maxpacket) ;
2143                 list_for_each_entry(urb, &ep->hep->urb_list, urb_list) {
2144                         seq_printf(s, "  urb%p, %d/%d\n", urb,
2145                                    urb->actual_length,
2146                                    urb->transfer_buffer_length);
2147                 }
2148         }
2149         if (!list_empty(&isp1362_hcd->async))
2150                 seq_printf(s, "\n");
2151         dump_ptd_queue(&isp1362_hcd->atl_queue);
2152
2153         seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE);
2154
2155         list_for_each_entry(ep, &isp1362_hcd->periodic, schedule) {
2156                 seq_printf(s, "branch:%2d load:%3d PTD[%d] $%04x:\n", ep->branch,
2157                            isp1362_hcd->load[ep->branch], ep->ptd_index, ep->ptd_offset);
2158
2159                 seq_printf(s, "   %d/%p (%sdev%d ep%d%s max %d)\n",
2160                            ep->interval, ep,
2161                            (ep->udev->speed == USB_SPEED_FULL) ? "" : "ls ",
2162                            ep->udev->devnum, ep->epnum,
2163                            (ep->epnum == 0) ? "" :
2164                            ((ep->nextpid == USB_PID_IN) ?
2165                             "in" : "out"), ep->maxpacket);
2166         }
2167         dump_ptd_queue(&isp1362_hcd->intl_queue);
2168
2169         seq_printf(s, "ISO:\n");
2170
2171         list_for_each_entry(ep, &isp1362_hcd->isoc, schedule) {
2172                 seq_printf(s, "   %d/%p (%sdev%d ep%d%s max %d)\n",
2173                            ep->interval, ep,
2174                            (ep->udev->speed == USB_SPEED_FULL) ? "" : "ls ",
2175                            ep->udev->devnum, ep->epnum,
2176                            (ep->epnum == 0) ? "" :
2177                            ((ep->nextpid == USB_PID_IN) ?
2178                             "in" : "out"), ep->maxpacket);
2179         }
2180
2181         spin_unlock_irq(&isp1362_hcd->lock);
2182         seq_printf(s, "\n");
2183
2184         return 0;
2185 }
2186
2187 static int proc_isp1362_open(struct inode *inode, struct file *file)
2188 {
2189         return single_open(file, proc_isp1362_show, PDE(inode)->data);
2190 }
2191
2192 static const struct file_operations proc_ops = {
2193         .open = proc_isp1362_open,
2194         .read = seq_read,
2195         .llseek = seq_lseek,
2196         .release = single_release,
2197 };
2198
2199 /* expect just one isp1362_hcd per system */
2200 static const char proc_filename[] = "driver/isp1362";
2201
2202 static void create_debug_file(struct isp1362_hcd *isp1362_hcd)
2203 {
2204         struct proc_dir_entry *pde;
2205
2206         pde = create_proc_entry(proc_filename, 0, NULL);
2207         if (pde == NULL) {
2208                 pr_warning("%s: Failed to create debug file '%s'\n", __func__, proc_filename);
2209                 return;
2210         }
2211
2212         pde->proc_fops = &proc_ops;
2213         pde->data = isp1362_hcd;
2214         isp1362_hcd->pde = pde;
2215 }
2216
2217 static void remove_debug_file(struct isp1362_hcd *isp1362_hcd)
2218 {
2219         if (isp1362_hcd->pde)
2220                 remove_proc_entry(proc_filename, 0);
2221 }
2222
2223 #endif
2224
2225 /*-------------------------------------------------------------------------*/
2226
2227 static void isp1362_sw_reset(struct isp1362_hcd *isp1362_hcd)
2228 {
2229         int tmp = 20;
2230         unsigned long flags;
2231
2232         spin_lock_irqsave(&isp1362_hcd->lock, flags);
2233
2234         isp1362_write_reg16(isp1362_hcd, HCSWRES, HCSWRES_MAGIC);
2235         isp1362_write_reg32(isp1362_hcd, HCCMDSTAT, OHCI_HCR);
2236         while (--tmp) {
2237                 mdelay(1);
2238                 if (!(isp1362_read_reg32(isp1362_hcd, HCCMDSTAT) & OHCI_HCR))
2239                         break;
2240         }
2241         if (!tmp)
2242                 pr_err("Software reset timeout\n");
2243         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2244 }
2245
2246 static int isp1362_mem_config(struct usb_hcd *hcd)
2247 {
2248         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2249         unsigned long flags;
2250         u32 total;
2251         u16 istl_size = ISP1362_ISTL_BUFSIZE;
2252         u16 intl_blksize = ISP1362_INTL_BLKSIZE + PTD_HEADER_SIZE;
2253         u16 intl_size = ISP1362_INTL_BUFFERS * intl_blksize;
2254         u16 atl_blksize = ISP1362_ATL_BLKSIZE + PTD_HEADER_SIZE;
2255         u16 atl_buffers = (ISP1362_BUF_SIZE - (istl_size + intl_size)) / atl_blksize;
2256         u16 atl_size;
2257         int i;
2258
2259         WARN_ON(istl_size & 3);
2260         WARN_ON(atl_blksize & 3);
2261         WARN_ON(intl_blksize & 3);
2262         WARN_ON(atl_blksize < PTD_HEADER_SIZE);
2263         WARN_ON(intl_blksize < PTD_HEADER_SIZE);
2264
2265         BUG_ON((unsigned)ISP1362_INTL_BUFFERS > 32);
2266         if (atl_buffers > 32)
2267                 atl_buffers = 32;
2268         atl_size = atl_buffers * atl_blksize;
2269         total = atl_size + intl_size + istl_size;
2270         dev_info(hcd->self.controller, "ISP1362 Memory usage:\n");
2271         dev_info(hcd->self.controller, "  ISTL:    2 * %4d:     %4d @ $%04x:$%04x\n",
2272                  istl_size / 2, istl_size, 0, istl_size / 2);
2273         dev_info(hcd->self.controller, "  INTL: %4d * (%3lu+8):  %4d @ $%04x\n",
2274                  ISP1362_INTL_BUFFERS, intl_blksize - PTD_HEADER_SIZE,
2275                  intl_size, istl_size);
2276         dev_info(hcd->self.controller, "  ATL : %4d * (%3lu+8):  %4d @ $%04x\n",
2277                  atl_buffers, atl_blksize - PTD_HEADER_SIZE,
2278                  atl_size, istl_size + intl_size);
2279         dev_info(hcd->self.controller, "  USED/FREE:   %4d      %4d\n", total,
2280                  ISP1362_BUF_SIZE - total);
2281
2282         if (total > ISP1362_BUF_SIZE) {
2283                 dev_err(hcd->self.controller, "%s: Memory requested: %d, available %d\n",
2284                         __func__, total, ISP1362_BUF_SIZE);
2285                 return -ENOMEM;
2286         }
2287
2288         total = istl_size + intl_size + atl_size;
2289         spin_lock_irqsave(&isp1362_hcd->lock, flags);
2290
2291         for (i = 0; i < 2; i++) {
2292                 isp1362_hcd->istl_queue[i].buf_start = i * istl_size / 2,
2293                 isp1362_hcd->istl_queue[i].buf_size = istl_size / 2;
2294                 isp1362_hcd->istl_queue[i].blk_size = 4;
2295                 INIT_LIST_HEAD(&isp1362_hcd->istl_queue[i].active);
2296                 snprintf(isp1362_hcd->istl_queue[i].name,
2297                          sizeof(isp1362_hcd->istl_queue[i].name), "ISTL%d", i);
2298                 DBG(3, "%s: %5s buf $%04x %d\n", __func__,
2299                      isp1362_hcd->istl_queue[i].name,
2300                      isp1362_hcd->istl_queue[i].buf_start,
2301                      isp1362_hcd->istl_queue[i].buf_size);
2302         }
2303         isp1362_write_reg16(isp1362_hcd, HCISTLBUFSZ, istl_size / 2);
2304
2305         isp1362_hcd->intl_queue.buf_start = istl_size;
2306         isp1362_hcd->intl_queue.buf_size = intl_size;
2307         isp1362_hcd->intl_queue.buf_count = ISP1362_INTL_BUFFERS;
2308         isp1362_hcd->intl_queue.blk_size = intl_blksize;
2309         isp1362_hcd->intl_queue.buf_avail = isp1362_hcd->intl_queue.buf_count;
2310         isp1362_hcd->intl_queue.skip_map = ~0;
2311         INIT_LIST_HEAD(&isp1362_hcd->intl_queue.active);
2312
2313         isp1362_write_reg16(isp1362_hcd, HCINTLBUFSZ,
2314                             isp1362_hcd->intl_queue.buf_size);
2315         isp1362_write_reg16(isp1362_hcd, HCINTLBLKSZ,
2316                             isp1362_hcd->intl_queue.blk_size - PTD_HEADER_SIZE);
2317         isp1362_write_reg32(isp1362_hcd, HCINTLSKIP, ~0);
2318         isp1362_write_reg32(isp1362_hcd, HCINTLLAST,
2319                             1 << (ISP1362_INTL_BUFFERS - 1));
2320
2321         isp1362_hcd->atl_queue.buf_start = istl_size + intl_size;
2322         isp1362_hcd->atl_queue.buf_size = atl_size;
2323         isp1362_hcd->atl_queue.buf_count = atl_buffers;
2324         isp1362_hcd->atl_queue.blk_size = atl_blksize;
2325         isp1362_hcd->atl_queue.buf_avail = isp1362_hcd->atl_queue.buf_count;
2326         isp1362_hcd->atl_queue.skip_map = ~0;
2327         INIT_LIST_HEAD(&isp1362_hcd->atl_queue.active);
2328
2329         isp1362_write_reg16(isp1362_hcd, HCATLBUFSZ,
2330                             isp1362_hcd->atl_queue.buf_size);
2331         isp1362_write_reg16(isp1362_hcd, HCATLBLKSZ,
2332                             isp1362_hcd->atl_queue.blk_size - PTD_HEADER_SIZE);
2333         isp1362_write_reg32(isp1362_hcd, HCATLSKIP, ~0);
2334         isp1362_write_reg32(isp1362_hcd, HCATLLAST,
2335                             1 << (atl_buffers - 1));
2336
2337         snprintf(isp1362_hcd->atl_queue.name,
2338                  sizeof(isp1362_hcd->atl_queue.name), "ATL");
2339         snprintf(isp1362_hcd->intl_queue.name,
2340                  sizeof(isp1362_hcd->intl_queue.name), "INTL");
2341         DBG(3, "%s: %5s buf $%04x %2d * %4d = %4d\n", __func__,
2342              isp1362_hcd->intl_queue.name,
2343              isp1362_hcd->intl_queue.buf_start,
2344              ISP1362_INTL_BUFFERS, isp1362_hcd->intl_queue.blk_size,
2345              isp1362_hcd->intl_queue.buf_size);
2346         DBG(3, "%s: %5s buf $%04x %2d * %4d = %4d\n", __func__,
2347              isp1362_hcd->atl_queue.name,
2348              isp1362_hcd->atl_queue.buf_start,
2349              atl_buffers, isp1362_hcd->atl_queue.blk_size,
2350              isp1362_hcd->atl_queue.buf_size);
2351
2352         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2353
2354         return 0;
2355 }
2356
2357 static int isp1362_hc_reset(struct usb_hcd *hcd)
2358 {
2359         int ret = 0;
2360         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2361         unsigned long t;
2362         unsigned long timeout = 100;
2363         unsigned long flags;
2364         int clkrdy = 0;
2365
2366         pr_info("%s:\n", __func__);
2367
2368         if (isp1362_hcd->board && isp1362_hcd->board->reset) {
2369                 isp1362_hcd->board->reset(hcd->self.controller, 1);
2370                 msleep(20);
2371                 if (isp1362_hcd->board->clock)
2372                         isp1362_hcd->board->clock(hcd->self.controller, 1);
2373                 isp1362_hcd->board->reset(hcd->self.controller, 0);
2374         } else
2375                 isp1362_sw_reset(isp1362_hcd);
2376
2377         /* chip has been reset. First we need to see a clock */
2378         t = jiffies + msecs_to_jiffies(timeout);
2379         while (!clkrdy && time_before_eq(jiffies, t)) {
2380                 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2381                 clkrdy = isp1362_read_reg16(isp1362_hcd, HCuPINT) & HCuPINT_CLKRDY;
2382                 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2383                 if (!clkrdy)
2384                         msleep(4);
2385         }
2386
2387         spin_lock_irqsave(&isp1362_hcd->lock, flags);
2388         isp1362_write_reg16(isp1362_hcd, HCuPINT, HCuPINT_CLKRDY);
2389         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2390         if (!clkrdy) {
2391                 pr_err("Clock not ready after %lums\n", timeout);
2392                 ret = -ENODEV;
2393         }
2394         return ret;
2395 }
2396
2397 static void isp1362_hc_stop(struct usb_hcd *hcd)
2398 {
2399         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2400         unsigned long flags;
2401         u32 tmp;
2402
2403         pr_info("%s:\n", __func__);
2404
2405         del_timer_sync(&hcd->rh_timer);
2406
2407         spin_lock_irqsave(&isp1362_hcd->lock, flags);
2408
2409         isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
2410
2411         /* Switch off power for all ports */
2412         tmp = isp1362_read_reg32(isp1362_hcd, HCRHDESCA);
2413         tmp &= ~(RH_A_NPS | RH_A_PSM);
2414         isp1362_write_reg32(isp1362_hcd, HCRHDESCA, tmp);
2415         isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPS);
2416
2417         /* Reset the chip */
2418         if (isp1362_hcd->board && isp1362_hcd->board->reset)
2419                 isp1362_hcd->board->reset(hcd->self.controller, 1);
2420         else
2421                 isp1362_sw_reset(isp1362_hcd);
2422
2423         if (isp1362_hcd->board && isp1362_hcd->board->clock)
2424                 isp1362_hcd->board->clock(hcd->self.controller, 0);
2425
2426         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2427 }
2428
2429 #ifdef CHIP_BUFFER_TEST
2430 static int isp1362_chip_test(struct isp1362_hcd *isp1362_hcd)
2431 {
2432         int ret = 0;
2433         u16 *ref;
2434         unsigned long flags;
2435
2436         ref = kmalloc(2 * ISP1362_BUF_SIZE, GFP_KERNEL);
2437         if (ref) {
2438                 int offset;
2439                 u16 *tst = &ref[ISP1362_BUF_SIZE / 2];
2440
2441                 for (offset = 0; offset < ISP1362_BUF_SIZE / 2; offset++) {
2442                         ref[offset] = ~offset;
2443                         tst[offset] = offset;
2444                 }
2445
2446                 for (offset = 0; offset < 4; offset++) {
2447                         int j;
2448
2449                         for (j = 0; j < 8; j++) {
2450                                 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2451                                 isp1362_write_buffer(isp1362_hcd, (u8 *)ref + offset, 0, j);
2452                                 isp1362_read_buffer(isp1362_hcd, (u8 *)tst + offset, 0, j);
2453                                 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2454
2455                                 if (memcmp(ref, tst, j)) {
2456                                         ret = -ENODEV;
2457                                         pr_err("%s: memory check with %d byte offset %d failed\n",
2458                                             __func__, j, offset);
2459                                         dump_data((u8 *)ref + offset, j);
2460                                         dump_data((u8 *)tst + offset, j);
2461                                 }
2462                         }
2463                 }
2464
2465                 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2466                 isp1362_write_buffer(isp1362_hcd, ref, 0, ISP1362_BUF_SIZE);
2467                 isp1362_read_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
2468                 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2469
2470                 if (memcmp(ref, tst, ISP1362_BUF_SIZE)) {
2471                         ret = -ENODEV;
2472                         pr_err("%s: memory check failed\n", __func__);
2473                         dump_data((u8 *)tst, ISP1362_BUF_SIZE / 2);
2474                 }
2475
2476                 for (offset = 0; offset < 256; offset++) {
2477                         int test_size = 0;
2478
2479                         yield();
2480
2481                         memset(tst, 0, ISP1362_BUF_SIZE);
2482                         spin_lock_irqsave(&isp1362_hcd->lock, flags);
2483                         isp1362_write_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
2484                         isp1362_read_buffer(isp1362_hcd, tst, 0, ISP1362_BUF_SIZE);
2485                         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2486                         if (memcmp(tst, tst + (ISP1362_BUF_SIZE / (2 * sizeof(*tst))),
2487                                    ISP1362_BUF_SIZE / 2)) {
2488                                 pr_err("%s: Failed to clear buffer\n", __func__);
2489                                 dump_data((u8 *)tst, ISP1362_BUF_SIZE);
2490                                 break;
2491                         }
2492                         spin_lock_irqsave(&isp1362_hcd->lock, flags);
2493                         isp1362_write_buffer(isp1362_hcd, ref, offset * 2, PTD_HEADER_SIZE);
2494                         isp1362_write_buffer(isp1362_hcd, ref + PTD_HEADER_SIZE / sizeof(*ref),
2495                                              offset * 2 + PTD_HEADER_SIZE, test_size);
2496                         isp1362_read_buffer(isp1362_hcd, tst, offset * 2,
2497                                             PTD_HEADER_SIZE + test_size);
2498                         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2499                         if (memcmp(ref, tst, PTD_HEADER_SIZE + test_size)) {
2500                                 dump_data(((u8 *)ref) + offset, PTD_HEADER_SIZE + test_size);
2501                                 dump_data((u8 *)tst, PTD_HEADER_SIZE + test_size);
2502                                 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2503                                 isp1362_read_buffer(isp1362_hcd, tst, offset * 2,
2504                                                     PTD_HEADER_SIZE + test_size);
2505                                 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2506                                 if (memcmp(ref, tst, PTD_HEADER_SIZE + test_size)) {
2507                                         ret = -ENODEV;
2508                                         pr_err("%s: memory check with offset %02x failed\n",
2509                                             __func__, offset);
2510                                         break;
2511                                 }
2512                                 pr_warning("%s: memory check with offset %02x ok after second read\n",
2513                                      __func__, offset);
2514                         }
2515                 }
2516                 kfree(ref);
2517         }
2518         return ret;
2519 }
2520 #endif
2521
2522 static int isp1362_hc_start(struct usb_hcd *hcd)
2523 {
2524         int ret;
2525         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2526         struct isp1362_platform_data *board = isp1362_hcd->board;
2527         u16 hwcfg;
2528         u16 chipid;
2529         unsigned long flags;
2530
2531         pr_info("%s:\n", __func__);
2532
2533         spin_lock_irqsave(&isp1362_hcd->lock, flags);
2534         chipid = isp1362_read_reg16(isp1362_hcd, HCCHIPID);
2535         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2536
2537         if ((chipid & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
2538                 pr_err("%s: Invalid chip ID %04x\n", __func__, chipid);
2539                 return -ENODEV;
2540         }
2541
2542 #ifdef CHIP_BUFFER_TEST
2543         ret = isp1362_chip_test(isp1362_hcd);
2544         if (ret)
2545                 return -ENODEV;
2546 #endif
2547         spin_lock_irqsave(&isp1362_hcd->lock, flags);
2548         /* clear interrupt status and disable all interrupt sources */
2549         isp1362_write_reg16(isp1362_hcd, HCuPINT, 0xff);
2550         isp1362_write_reg16(isp1362_hcd, HCuPINTENB, 0);
2551
2552         /* HW conf */
2553         hwcfg = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1);
2554         if (board->sel15Kres)
2555                 hwcfg |= HCHWCFG_PULLDOWN_DS2 |
2556                         ((MAX_ROOT_PORTS > 1) ? HCHWCFG_PULLDOWN_DS1 : 0);
2557         if (board->clknotstop)
2558                 hwcfg |= HCHWCFG_CLKNOTSTOP;
2559         if (board->oc_enable)
2560                 hwcfg |= HCHWCFG_ANALOG_OC;
2561         if (board->int_act_high)
2562                 hwcfg |= HCHWCFG_INT_POL;
2563         if (board->int_edge_triggered)
2564                 hwcfg |= HCHWCFG_INT_TRIGGER;
2565         if (board->dreq_act_high)
2566                 hwcfg |= HCHWCFG_DREQ_POL;
2567         if (board->dack_act_high)
2568                 hwcfg |= HCHWCFG_DACK_POL;
2569         isp1362_write_reg16(isp1362_hcd, HCHWCFG, hwcfg);
2570         isp1362_show_reg(isp1362_hcd, HCHWCFG);
2571         isp1362_write_reg16(isp1362_hcd, HCDMACFG, 0);
2572         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2573
2574         ret = isp1362_mem_config(hcd);
2575         if (ret)
2576                 return ret;
2577
2578         spin_lock_irqsave(&isp1362_hcd->lock, flags);
2579
2580         /* Root hub conf */
2581         isp1362_hcd->rhdesca = 0;
2582         if (board->no_power_switching)
2583                 isp1362_hcd->rhdesca |= RH_A_NPS;
2584         if (board->power_switching_mode)
2585                 isp1362_hcd->rhdesca |= RH_A_PSM;
2586         if (board->potpg)
2587                 isp1362_hcd->rhdesca |= (board->potpg << 24) & RH_A_POTPGT;
2588         else
2589                 isp1362_hcd->rhdesca |= (25 << 24) & RH_A_POTPGT;
2590
2591         isp1362_write_reg32(isp1362_hcd, HCRHDESCA, isp1362_hcd->rhdesca & ~RH_A_OCPM);
2592         isp1362_write_reg32(isp1362_hcd, HCRHDESCA, isp1362_hcd->rhdesca | RH_A_OCPM);
2593         isp1362_hcd->rhdesca = isp1362_read_reg32(isp1362_hcd, HCRHDESCA);
2594
2595         isp1362_hcd->rhdescb = RH_B_PPCM;
2596         isp1362_write_reg32(isp1362_hcd, HCRHDESCB, isp1362_hcd->rhdescb);
2597         isp1362_hcd->rhdescb = isp1362_read_reg32(isp1362_hcd, HCRHDESCB);
2598
2599         isp1362_read_reg32(isp1362_hcd, HCFMINTVL);
2600         isp1362_write_reg32(isp1362_hcd, HCFMINTVL, (FSMP(FI) << 16) | FI);
2601         isp1362_write_reg32(isp1362_hcd, HCLSTHRESH, LSTHRESH);
2602
2603         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2604
2605         isp1362_hcd->hc_control = OHCI_USB_OPER;
2606         hcd->state = HC_STATE_RUNNING;
2607
2608         spin_lock_irqsave(&isp1362_hcd->lock, flags);
2609         /* Set up interrupts */
2610         isp1362_hcd->intenb = OHCI_INTR_MIE | OHCI_INTR_RHSC | OHCI_INTR_UE;
2611         isp1362_hcd->intenb |= OHCI_INTR_RD;
2612         isp1362_hcd->irqenb = HCuPINT_OPR | HCuPINT_SUSP;
2613         isp1362_write_reg32(isp1362_hcd, HCINTENB, isp1362_hcd->intenb);
2614         isp1362_write_reg16(isp1362_hcd, HCuPINTENB, isp1362_hcd->irqenb);
2615
2616         /* Go operational */
2617         isp1362_write_reg32(isp1362_hcd, HCCONTROL, isp1362_hcd->hc_control);
2618         /* enable global power */
2619         isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPSC | RH_HS_DRWE);
2620
2621         spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2622
2623         return 0;
2624 }
2625
2626 /*-------------------------------------------------------------------------*/
2627
2628 static struct hc_driver isp1362_hc_driver = {
2629         .description =          hcd_name,
2630         .product_desc =         "ISP1362 Host Controller",
2631         .hcd_priv_size =        sizeof(struct isp1362_hcd),
2632
2633         .irq =                  isp1362_irq,
2634         .flags =                HCD_USB11 | HCD_MEMORY,
2635
2636         .reset =                isp1362_hc_reset,
2637         .start =                isp1362_hc_start,
2638         .stop =                 isp1362_hc_stop,
2639
2640         .urb_enqueue =          isp1362_urb_enqueue,
2641         .urb_dequeue =          isp1362_urb_dequeue,
2642         .endpoint_disable =     isp1362_endpoint_disable,
2643
2644         .get_frame_number =     isp1362_get_frame,
2645
2646         .hub_status_data =      isp1362_hub_status_data,
2647         .hub_control =          isp1362_hub_control,
2648         .bus_suspend =          isp1362_bus_suspend,
2649         .bus_resume =           isp1362_bus_resume,
2650 };
2651
2652 /*-------------------------------------------------------------------------*/
2653
2654 #define resource_len(r) (((r)->end - (r)->start) + 1)
2655
2656 static int __devexit isp1362_remove(struct platform_device *pdev)
2657 {
2658         struct usb_hcd *hcd = platform_get_drvdata(pdev);
2659         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2660         struct resource *res;
2661
2662         remove_debug_file(isp1362_hcd);
2663         DBG(0, "%s: Removing HCD\n", __func__);
2664         usb_remove_hcd(hcd);
2665
2666         DBG(0, "%s: Unmapping data_reg @ %p\n", __func__,
2667             isp1362_hcd->data_reg);
2668         iounmap(isp1362_hcd->data_reg);
2669
2670         DBG(0, "%s: Unmapping addr_reg @ %p\n", __func__,
2671             isp1362_hcd->addr_reg);
2672         iounmap(isp1362_hcd->addr_reg);
2673
2674         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
2675         DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
2676         if (res)
2677                 release_mem_region(res->start, resource_len(res));
2678
2679         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2680         DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
2681         if (res)
2682                 release_mem_region(res->start, resource_len(res));
2683
2684         DBG(0, "%s: put_hcd\n", __func__);
2685         usb_put_hcd(hcd);
2686         DBG(0, "%s: Done\n", __func__);
2687
2688         return 0;
2689 }
2690
2691 static int __init isp1362_probe(struct platform_device *pdev)
2692 {
2693         struct usb_hcd *hcd;
2694         struct isp1362_hcd *isp1362_hcd;
2695         struct resource *addr, *data;
2696         void __iomem *addr_reg;
2697         void __iomem *data_reg;
2698         int irq;
2699         int retval = 0;
2700
2701         /* basic sanity checks first.  board-specific init logic should
2702          * have initialized this the three resources and probably board
2703          * specific platform_data.  we don't probe for IRQs, and do only
2704          * minimal sanity checking.
2705          */
2706         if (pdev->num_resources < 3) {
2707                 retval = -ENODEV;
2708                 goto err1;
2709         }
2710
2711         data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2712         addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
2713         irq = platform_get_irq(pdev, 0);
2714         if (!addr || !data || irq < 0) {
2715                 retval = -ENODEV;
2716                 goto err1;
2717         }
2718
2719 #ifdef CONFIG_USB_HCD_DMA
2720         if (pdev->dev.dma_mask) {
2721                 struct resource *dma_res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
2722
2723                 if (!dma_res) {
2724                         retval = -ENODEV;
2725                         goto err1;
2726                 }
2727                 isp1362_hcd->data_dma = dma_res->start;
2728                 isp1362_hcd->max_dma_size = resource_len(dma_res);
2729         }
2730 #else
2731         if (pdev->dev.dma_mask) {
2732                 DBG(1, "won't do DMA");
2733                 retval = -ENODEV;
2734                 goto err1;
2735         }
2736 #endif
2737
2738         if (!request_mem_region(addr->start, resource_len(addr), hcd_name)) {
2739                 retval = -EBUSY;
2740                 goto err1;
2741         }
2742         addr_reg = ioremap(addr->start, resource_len(addr));
2743         if (addr_reg == NULL) {
2744                 retval = -ENOMEM;
2745                 goto err2;
2746         }
2747
2748         if (!request_mem_region(data->start, resource_len(data), hcd_name)) {
2749                 retval = -EBUSY;
2750                 goto err3;
2751         }
2752         data_reg = ioremap(data->start, resource_len(data));
2753         if (data_reg == NULL) {
2754                 retval = -ENOMEM;
2755                 goto err4;
2756         }
2757
2758         /* allocate and initialize hcd */
2759         hcd = usb_create_hcd(&isp1362_hc_driver, &pdev->dev, dev_name(&pdev->dev));
2760         if (!hcd) {
2761                 retval = -ENOMEM;
2762                 goto err5;
2763         }
2764         hcd->rsrc_start = data->start;
2765         isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2766         isp1362_hcd->data_reg = data_reg;
2767         isp1362_hcd->addr_reg = addr_reg;
2768
2769         isp1362_hcd->next_statechange = jiffies;
2770         spin_lock_init(&isp1362_hcd->lock);
2771         INIT_LIST_HEAD(&isp1362_hcd->async);
2772         INIT_LIST_HEAD(&isp1362_hcd->periodic);
2773         INIT_LIST_HEAD(&isp1362_hcd->isoc);
2774         INIT_LIST_HEAD(&isp1362_hcd->remove_list);
2775         isp1362_hcd->board = pdev->dev.platform_data;
2776 #if USE_PLATFORM_DELAY
2777         if (!isp1362_hcd->board->delay) {
2778                 dev_err(hcd->self.controller, "No platform delay function given\n");
2779                 retval = -ENODEV;
2780                 goto err6;
2781         }
2782 #endif
2783
2784 #ifdef CONFIG_ARM
2785         if (isp1362_hcd->board)
2786                 set_irq_type(irq, isp1362_hcd->board->int_act_high ? IRQT_RISING : IRQT_FALLING);
2787 #endif
2788
2789         retval = usb_add_hcd(hcd, irq, IRQF_TRIGGER_LOW | IRQF_DISABLED | IRQF_SHARED);
2790         if (retval != 0)
2791                 goto err6;
2792         pr_info("%s, irq %d\n", hcd->product_desc, irq);
2793
2794         create_debug_file(isp1362_hcd);
2795
2796         return 0;
2797
2798  err6:
2799         DBG(0, "%s: Freeing dev %p\n", __func__, isp1362_hcd);
2800         usb_put_hcd(hcd);
2801  err5:
2802         DBG(0, "%s: Unmapping data_reg @ %p\n", __func__, data_reg);
2803         iounmap(data_reg);
2804  err4:
2805         DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)data->start);
2806         release_mem_region(data->start, resource_len(data));
2807  err3:
2808         DBG(0, "%s: Unmapping addr_reg @ %p\n", __func__, addr_reg);
2809         iounmap(addr_reg);
2810  err2:
2811         DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)addr->start);
2812         release_mem_region(addr->start, resource_len(addr));
2813  err1:
2814         pr_err("%s: init error, %d\n", __func__, retval);
2815
2816         return retval;
2817 }
2818
2819 #ifdef  CONFIG_PM
2820 static int isp1362_suspend(struct platform_device *pdev, pm_message_t state)
2821 {
2822         struct usb_hcd *hcd = platform_get_drvdata(pdev);
2823         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2824         unsigned long flags;
2825         int retval = 0;
2826
2827         DBG(0, "%s: Suspending device\n", __func__);
2828
2829         if (state.event == PM_EVENT_FREEZE) {
2830                 DBG(0, "%s: Suspending root hub\n", __func__);
2831                 retval = isp1362_bus_suspend(hcd);
2832         } else {
2833                 DBG(0, "%s: Suspending RH ports\n", __func__);
2834                 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2835                 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPS);
2836                 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2837         }
2838         if (retval == 0)
2839                 pdev->dev.power.power_state = state;
2840         return retval;
2841 }
2842
2843 static int isp1362_resume(struct platform_device *pdev)
2844 {
2845         struct usb_hcd *hcd = platform_get_drvdata(pdev);
2846         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
2847         unsigned long flags;
2848
2849         DBG(0, "%s: Resuming\n", __func__);
2850
2851         if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
2852                 DBG(0, "%s: Resume RH ports\n", __func__);
2853                 spin_lock_irqsave(&isp1362_hcd->lock, flags);
2854                 isp1362_write_reg32(isp1362_hcd, HCRHSTATUS, RH_HS_LPSC);
2855                 spin_unlock_irqrestore(&isp1362_hcd->lock, flags);
2856                 return 0;
2857         }
2858
2859         pdev->dev.power.power_state = PMSG_ON;
2860
2861         return isp1362_bus_resume(isp1362_hcd_to_hcd(isp1362_hcd));
2862 }
2863 #else
2864 #define isp1362_suspend NULL
2865 #define isp1362_resume  NULL
2866 #endif
2867
2868 static struct platform_driver isp1362_driver = {
2869         .probe = isp1362_probe,
2870         .remove = __devexit_p(isp1362_remove),
2871
2872         .suspend = isp1362_suspend,
2873         .resume = isp1362_resume,
2874         .driver = {
2875                 .name = (char *)hcd_name,
2876                 .owner = THIS_MODULE,
2877         },
2878 };
2879
2880 /*-------------------------------------------------------------------------*/
2881
2882 static int __init isp1362_init(void)
2883 {
2884         if (usb_disabled())
2885                 return -ENODEV;
2886         pr_info("driver %s, %s\n", hcd_name, DRIVER_VERSION);
2887         return platform_driver_register(&isp1362_driver);
2888 }
2889 module_init(isp1362_init);
2890
2891 static void __exit isp1362_cleanup(void)
2892 {
2893         platform_driver_unregister(&isp1362_driver);
2894 }
2895 module_exit(isp1362_cleanup);