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