1 /* 2 * ISP116x HCD (Host Controller Driver) for USB. 3 * 4 * Derived from the SL811 HCD, rewritten for ISP116x. 5 * Copyright (C) 2005 Olav Kongas <ok@artecdesign.ee> 6 * 7 * Portions: 8 * Copyright (C) 2004 Psion Teklogix (for NetBook PRO) 9 * Copyright (C) 2004 David Brownell 10 * 11 * Periodic scheduling is based on Roman's OHCI code 12 * Copyright (C) 1999 Roman Weissgaerber 13 * 14 */ 15 16 /* 17 * The driver basically works. A number of people have used it with a range 18 * of devices. 19 * 20 * The driver passes all usbtests 1-14. 21 * 22 * Suspending/resuming of root hub via sysfs works. Remote wakeup works too. 23 * And suspending/resuming of platform device works too. Suspend/resume 24 * via HCD operations vector is not implemented. 25 * 26 * Iso transfer support is not implemented. Adding this would include 27 * implementing recovery from the failure to service the processed ITL 28 * fifo ram in time, which will involve chip reset. 29 * 30 * TODO: 31 + More testing of suspend/resume. 32 */ 33 34 /* 35 ISP116x chips require certain delays between accesses to its 36 registers. The following timing options exist. 37 38 1. Configure your memory controller (the best) 39 2. Implement platform-specific delay function possibly 40 combined with configuring the memory controller; see 41 include/linux/usb-isp116x.h for more info. Some broken 42 memory controllers line LH7A400 SMC need this. Also, 43 uncomment for that to work the following 44 USE_PLATFORM_DELAY macro. 45 3. Use ndelay (easiest, poorest). For that, uncomment 46 the following USE_NDELAY macro. 47 */ 48 #define USE_PLATFORM_DELAY 49 //#define USE_NDELAY 50 51 //#define DEBUG 52 //#define VERBOSE 53 /* Transfer descriptors. See dump_ptd() for printout format */ 54 //#define PTD_TRACE 55 /* enqueuing/finishing log of urbs */ 56 //#define URB_TRACE 57 58 #include <linux/config.h> 59 #include <linux/module.h> 60 #include <linux/moduleparam.h> 61 #include <linux/kernel.h> 62 #include <linux/delay.h> 63 #include <linux/ioport.h> 64 #include <linux/sched.h> 65 #include <linux/slab.h> 66 #include <linux/smp_lock.h> 67 #include <linux/errno.h> 68 #include <linux/init.h> 69 #include <linux/list.h> 70 #include <linux/interrupt.h> 71 #include <linux/usb.h> 72 #include <linux/usb_isp116x.h> 73 74 #include <asm/io.h> 75 #include <asm/irq.h> 76 #include <asm/system.h> 77 #include <asm/byteorder.h> 78 79 #ifndef DEBUG 80 # define STUB_DEBUG_FILE 81 #endif 82 83 #include "../core/hcd.h" 84 #include "isp116x.h" 85 86 #define DRIVER_VERSION "08 Apr 2005" 87 #define DRIVER_DESC "ISP116x USB Host Controller Driver" 88 89 MODULE_DESCRIPTION(DRIVER_DESC); 90 MODULE_LICENSE("GPL"); 91 92 static const char hcd_name[] = "isp116x-hcd"; 93 94 /*-----------------------------------------------------------------*/ 95 96 /* 97 Write len bytes to fifo, pad till 32-bit boundary 98 */ 99 static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len) 100 { 101 u8 *dp = (u8 *) buf; 102 u16 *dp2 = (u16 *) buf; 103 u16 w; 104 int quot = len % 4; 105 106 if ((unsigned long)dp2 & 1) { 107 /* not aligned */ 108 for (; len > 1; len -= 2) { 109 w = *dp++; 110 w |= *dp++ << 8; 111 isp116x_raw_write_data16(isp116x, w); 112 } 113 if (len) 114 isp116x_write_data16(isp116x, (u16) * dp); 115 } else { 116 /* aligned */ 117 for (; len > 1; len -= 2) 118 isp116x_raw_write_data16(isp116x, *dp2++); 119 if (len) 120 isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2)); 121 } 122 if (quot == 1 || quot == 2) 123 isp116x_raw_write_data16(isp116x, 0); 124 } 125 126 /* 127 Read len bytes from fifo and then read till 32-bit boundary. 128 */ 129 static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len) 130 { 131 u8 *dp = (u8 *) buf; 132 u16 *dp2 = (u16 *) buf; 133 u16 w; 134 int quot = len % 4; 135 136 if ((unsigned long)dp2 & 1) { 137 /* not aligned */ 138 for (; len > 1; len -= 2) { 139 w = isp116x_raw_read_data16(isp116x); 140 *dp++ = w & 0xff; 141 *dp++ = (w >> 8) & 0xff; 142 } 143 if (len) 144 *dp = 0xff & isp116x_read_data16(isp116x); 145 } else { 146 /* aligned */ 147 for (; len > 1; len -= 2) 148 *dp2++ = isp116x_raw_read_data16(isp116x); 149 if (len) 150 *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x); 151 } 152 if (quot == 1 || quot == 2) 153 isp116x_raw_read_data16(isp116x); 154 } 155 156 /* 157 Write ptd's and data for scheduled transfers into 158 the fifo ram. Fifo must be empty and ready. 159 */ 160 static void pack_fifo(struct isp116x *isp116x) 161 { 162 struct isp116x_ep *ep; 163 struct ptd *ptd; 164 int buflen = isp116x->atl_last_dir == PTD_DIR_IN 165 ? isp116x->atl_bufshrt : isp116x->atl_buflen; 166 int ptd_count = 0; 167 168 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT); 169 isp116x_write_reg16(isp116x, HCXFERCTR, buflen); 170 isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET); 171 for (ep = isp116x->atl_active; ep; ep = ep->active) { 172 ++ptd_count; 173 ptd = &ep->ptd; 174 dump_ptd(ptd); 175 dump_ptd_out_data(ptd, ep->data); 176 isp116x_write_data16(isp116x, ptd->count); 177 isp116x_write_data16(isp116x, ptd->mps); 178 isp116x_write_data16(isp116x, ptd->len); 179 isp116x_write_data16(isp116x, ptd->faddr); 180 buflen -= sizeof(struct ptd); 181 /* Skip writing data for last IN PTD */ 182 if (ep->active || (isp116x->atl_last_dir != PTD_DIR_IN)) { 183 write_ptddata_to_fifo(isp116x, ep->data, ep->length); 184 buflen -= ALIGN(ep->length, 4); 185 } 186 } 187 BUG_ON(buflen); 188 } 189 190 /* 191 Read the processed ptd's and data from fifo ram back to 192 URBs' buffers. Fifo must be full and done 193 */ 194 static void unpack_fifo(struct isp116x *isp116x) 195 { 196 struct isp116x_ep *ep; 197 struct ptd *ptd; 198 int buflen = isp116x->atl_last_dir == PTD_DIR_IN 199 ? isp116x->atl_buflen : isp116x->atl_bufshrt; 200 201 isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT); 202 isp116x_write_reg16(isp116x, HCXFERCTR, buflen); 203 isp116x_write_addr(isp116x, HCATLPORT); 204 for (ep = isp116x->atl_active; ep; ep = ep->active) { 205 ptd = &ep->ptd; 206 ptd->count = isp116x_read_data16(isp116x); 207 ptd->mps = isp116x_read_data16(isp116x); 208 ptd->len = isp116x_read_data16(isp116x); 209 ptd->faddr = isp116x_read_data16(isp116x); 210 buflen -= sizeof(struct ptd); 211 /* Skip reading data for last Setup or Out PTD */ 212 if (ep->active || (isp116x->atl_last_dir == PTD_DIR_IN)) { 213 read_ptddata_from_fifo(isp116x, ep->data, ep->length); 214 buflen -= ALIGN(ep->length, 4); 215 } 216 dump_ptd(ptd); 217 dump_ptd_in_data(ptd, ep->data); 218 } 219 BUG_ON(buflen); 220 } 221 222 /*---------------------------------------------------------------*/ 223 224 /* 225 Set up PTD's. 226 */ 227 static void preproc_atl_queue(struct isp116x *isp116x) 228 { 229 struct isp116x_ep *ep; 230 struct urb *urb; 231 struct ptd *ptd; 232 u16 toggle = 0, dir = PTD_DIR_SETUP, len; 233 234 for (ep = isp116x->atl_active; ep; ep = ep->active) { 235 BUG_ON(list_empty(&ep->hep->urb_list)); 236 urb = container_of(ep->hep->urb_list.next, 237 struct urb, urb_list); 238 ptd = &ep->ptd; 239 len = ep->length; 240 spin_lock(&urb->lock); 241 ep->data = (unsigned char *)urb->transfer_buffer 242 + urb->actual_length; 243 244 switch (ep->nextpid) { 245 case USB_PID_IN: 246 toggle = usb_gettoggle(urb->dev, ep->epnum, 0); 247 dir = PTD_DIR_IN; 248 break; 249 case USB_PID_OUT: 250 toggle = usb_gettoggle(urb->dev, ep->epnum, 1); 251 dir = PTD_DIR_OUT; 252 break; 253 case USB_PID_SETUP: 254 len = sizeof(struct usb_ctrlrequest); 255 ep->data = urb->setup_packet; 256 break; 257 case USB_PID_ACK: 258 toggle = 1; 259 len = 0; 260 dir = (urb->transfer_buffer_length 261 && usb_pipein(urb->pipe)) 262 ? PTD_DIR_OUT : PTD_DIR_IN; 263 break; 264 default: 265 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__, 266 ep->nextpid); 267 BUG(); 268 } 269 270 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle); 271 ptd->mps = PTD_MPS(ep->maxpacket) 272 | PTD_SPD(urb->dev->speed == USB_SPEED_LOW) 273 | PTD_EP(ep->epnum); 274 ptd->len = PTD_LEN(len) | PTD_DIR(dir); 275 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe)); 276 spin_unlock(&urb->lock); 277 if (!ep->active) { 278 ptd->mps |= PTD_LAST_MSK; 279 isp116x->atl_last_dir = dir; 280 } 281 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen; 282 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4); 283 } 284 } 285 286 /* 287 Analyze transfer results, handle partial transfers and errors 288 */ 289 static void postproc_atl_queue(struct isp116x *isp116x) 290 { 291 struct isp116x_ep *ep; 292 struct urb *urb; 293 struct usb_device *udev; 294 struct ptd *ptd; 295 int short_not_ok; 296 u8 cc; 297 298 for (ep = isp116x->atl_active; ep; ep = ep->active) { 299 BUG_ON(list_empty(&ep->hep->urb_list)); 300 urb = 301 container_of(ep->hep->urb_list.next, struct urb, urb_list); 302 udev = urb->dev; 303 ptd = &ep->ptd; 304 cc = PTD_GET_CC(ptd); 305 306 spin_lock(&urb->lock); 307 short_not_ok = 1; 308 309 /* Data underrun is special. For allowed underrun 310 we clear the error and continue as normal. For 311 forbidden underrun we finish the DATA stage 312 immediately while for control transfer, 313 we do a STATUS stage. */ 314 if (cc == TD_DATAUNDERRUN) { 315 if (!(urb->transfer_flags & URB_SHORT_NOT_OK)) { 316 DBG("Allowed data underrun\n"); 317 cc = TD_CC_NOERROR; 318 short_not_ok = 0; 319 } else { 320 ep->error_count = 1; 321 if (usb_pipecontrol(urb->pipe)) 322 ep->nextpid = USB_PID_ACK; 323 else 324 usb_settoggle(udev, ep->epnum, 325 ep->nextpid == 326 USB_PID_OUT, 327 PTD_GET_TOGGLE(ptd) ^ 1); 328 urb->status = cc_to_error[TD_DATAUNDERRUN]; 329 spin_unlock(&urb->lock); 330 continue; 331 } 332 } 333 /* Keep underrun error through the STATUS stage */ 334 if (urb->status == cc_to_error[TD_DATAUNDERRUN]) 335 cc = TD_DATAUNDERRUN; 336 337 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED 338 && (++ep->error_count >= 3 || cc == TD_CC_STALL 339 || cc == TD_DATAOVERRUN)) { 340 if (urb->status == -EINPROGRESS) 341 urb->status = cc_to_error[cc]; 342 if (ep->nextpid == USB_PID_ACK) 343 ep->nextpid = 0; 344 spin_unlock(&urb->lock); 345 continue; 346 } 347 /* According to usb spec, zero-length Int transfer signals 348 finishing of the urb. Hey, does this apply only 349 for IN endpoints? */ 350 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) { 351 if (urb->status == -EINPROGRESS) 352 urb->status = 0; 353 spin_unlock(&urb->lock); 354 continue; 355 } 356 357 /* Relax after previously failed, but later succeeded 358 or correctly NAK'ed retransmission attempt */ 359 if (ep->error_count 360 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED)) 361 ep->error_count = 0; 362 363 /* Take into account idiosyncracies of the isp116x chip 364 regarding toggle bit for failed transfers */ 365 if (ep->nextpid == USB_PID_OUT) 366 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd) 367 ^ (ep->error_count > 0)); 368 else if (ep->nextpid == USB_PID_IN) 369 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd) 370 ^ (ep->error_count > 0)); 371 372 switch (ep->nextpid) { 373 case USB_PID_IN: 374 case USB_PID_OUT: 375 urb->actual_length += PTD_GET_COUNT(ptd); 376 if (PTD_GET_ACTIVE(ptd) 377 || (cc != TD_CC_NOERROR && cc < 0x0E)) 378 break; 379 if (urb->transfer_buffer_length != urb->actual_length) { 380 if (short_not_ok) 381 break; 382 } else { 383 if (urb->transfer_flags & URB_ZERO_PACKET 384 && ep->nextpid == USB_PID_OUT 385 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) { 386 DBG("Zero packet requested\n"); 387 break; 388 } 389 } 390 /* All data for this URB is transferred, let's finish */ 391 if (usb_pipecontrol(urb->pipe)) 392 ep->nextpid = USB_PID_ACK; 393 else if (urb->status == -EINPROGRESS) 394 urb->status = 0; 395 break; 396 case USB_PID_SETUP: 397 if (PTD_GET_ACTIVE(ptd) 398 || (cc != TD_CC_NOERROR && cc < 0x0E)) 399 break; 400 if (urb->transfer_buffer_length == urb->actual_length) 401 ep->nextpid = USB_PID_ACK; 402 else if (usb_pipeout(urb->pipe)) { 403 usb_settoggle(udev, 0, 1, 1); 404 ep->nextpid = USB_PID_OUT; 405 } else { 406 usb_settoggle(udev, 0, 0, 1); 407 ep->nextpid = USB_PID_IN; 408 } 409 break; 410 case USB_PID_ACK: 411 if (PTD_GET_ACTIVE(ptd) 412 || (cc != TD_CC_NOERROR && cc < 0x0E)) 413 break; 414 if (urb->status == -EINPROGRESS) 415 urb->status = 0; 416 ep->nextpid = 0; 417 break; 418 default: 419 BUG_ON(1); 420 } 421 spin_unlock(&urb->lock); 422 } 423 } 424 425 /* 426 Take done or failed requests out of schedule. Give back 427 processed urbs. 428 */ 429 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep, 430 struct urb *urb, struct pt_regs *regs) 431 __releases(isp116x->lock) __acquires(isp116x->lock) 432 { 433 unsigned i; 434 435 urb->hcpriv = NULL; 436 ep->error_count = 0; 437 438 if (usb_pipecontrol(urb->pipe)) 439 ep->nextpid = USB_PID_SETUP; 440 441 urb_dbg(urb, "Finish"); 442 443 spin_unlock(&isp116x->lock); 444 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, regs); 445 spin_lock(&isp116x->lock); 446 447 /* take idle endpoints out of the schedule */ 448 if (!list_empty(&ep->hep->urb_list)) 449 return; 450 451 /* async deschedule */ 452 if (!list_empty(&ep->schedule)) { 453 list_del_init(&ep->schedule); 454 return; 455 } 456 457 /* periodic deschedule */ 458 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch); 459 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) { 460 struct isp116x_ep *temp; 461 struct isp116x_ep **prev = &isp116x->periodic[i]; 462 463 while (*prev && ((temp = *prev) != ep)) 464 prev = &temp->next; 465 if (*prev) 466 *prev = ep->next; 467 isp116x->load[i] -= ep->load; 468 } 469 ep->branch = PERIODIC_SIZE; 470 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -= 471 ep->load / ep->period; 472 473 /* switch irq type? */ 474 if (!--isp116x->periodic_count) { 475 isp116x->irqenb &= ~HCuPINT_SOF; 476 isp116x->irqenb |= HCuPINT_ATL; 477 } 478 } 479 480 /* 481 Scan transfer lists, schedule transfers, send data off 482 to chip. 483 */ 484 static void start_atl_transfers(struct isp116x *isp116x) 485 { 486 struct isp116x_ep *last_ep = NULL, *ep; 487 struct urb *urb; 488 u16 load = 0; 489 int len, index, speed, byte_time; 490 491 if (atomic_read(&isp116x->atl_finishing)) 492 return; 493 494 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) 495 return; 496 497 /* FIFO not empty? */ 498 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL) 499 return; 500 501 isp116x->atl_active = NULL; 502 isp116x->atl_buflen = isp116x->atl_bufshrt = 0; 503 504 /* Schedule int transfers */ 505 if (isp116x->periodic_count) { 506 isp116x->fmindex = index = 507 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1); 508 if ((load = isp116x->load[index])) { 509 /* Bring all int transfers for this frame 510 into the active queue */ 511 isp116x->atl_active = last_ep = 512 isp116x->periodic[index]; 513 while (last_ep->next) 514 last_ep = (last_ep->active = last_ep->next); 515 last_ep->active = NULL; 516 } 517 } 518 519 /* Schedule control/bulk transfers */ 520 list_for_each_entry(ep, &isp116x->async, schedule) { 521 urb = container_of(ep->hep->urb_list.next, 522 struct urb, urb_list); 523 speed = urb->dev->speed; 524 byte_time = speed == USB_SPEED_LOW 525 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED; 526 527 if (ep->nextpid == USB_PID_SETUP) { 528 len = sizeof(struct usb_ctrlrequest); 529 } else if (ep->nextpid == USB_PID_ACK) { 530 len = 0; 531 } else { 532 /* Find current free length ... */ 533 len = (MAX_LOAD_LIMIT - load) / byte_time; 534 535 /* ... then limit it to configured max size ... */ 536 len = min(len, speed == USB_SPEED_LOW ? 537 MAX_TRANSFER_SIZE_LOWSPEED : 538 MAX_TRANSFER_SIZE_FULLSPEED); 539 540 /* ... and finally cut to the multiple of MaxPacketSize, 541 or to the real length if there's enough room. */ 542 if (len < 543 (urb->transfer_buffer_length - 544 urb->actual_length)) { 545 len -= len % ep->maxpacket; 546 if (!len) 547 continue; 548 } else 549 len = urb->transfer_buffer_length - 550 urb->actual_length; 551 BUG_ON(len < 0); 552 } 553 554 load += len * byte_time; 555 if (load > MAX_LOAD_LIMIT) 556 break; 557 558 ep->active = NULL; 559 ep->length = len; 560 if (last_ep) 561 last_ep->active = ep; 562 else 563 isp116x->atl_active = ep; 564 last_ep = ep; 565 } 566 567 /* Avoid starving of endpoints */ 568 if ((&isp116x->async)->next != (&isp116x->async)->prev) 569 list_move(&isp116x->async, (&isp116x->async)->next); 570 571 if (isp116x->atl_active) { 572 preproc_atl_queue(isp116x); 573 pack_fifo(isp116x); 574 } 575 } 576 577 /* 578 Finish the processed transfers 579 */ 580 static void finish_atl_transfers(struct isp116x *isp116x, struct pt_regs *regs) 581 { 582 struct isp116x_ep *ep; 583 struct urb *urb; 584 585 if (!isp116x->atl_active) 586 return; 587 /* Fifo not ready? */ 588 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE)) 589 return; 590 591 atomic_inc(&isp116x->atl_finishing); 592 unpack_fifo(isp116x); 593 postproc_atl_queue(isp116x); 594 for (ep = isp116x->atl_active; ep; ep = ep->active) { 595 urb = 596 container_of(ep->hep->urb_list.next, struct urb, urb_list); 597 /* USB_PID_ACK check here avoids finishing of 598 control transfers, for which TD_DATAUNDERRUN 599 occured, while URB_SHORT_NOT_OK was set */ 600 if (urb && urb->status != -EINPROGRESS 601 && ep->nextpid != USB_PID_ACK) 602 finish_request(isp116x, ep, urb, regs); 603 } 604 atomic_dec(&isp116x->atl_finishing); 605 } 606 607 static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs) 608 { 609 struct isp116x *isp116x = hcd_to_isp116x(hcd); 610 u16 irqstat; 611 irqreturn_t ret = IRQ_NONE; 612 613 spin_lock(&isp116x->lock); 614 isp116x_write_reg16(isp116x, HCuPINTENB, 0); 615 irqstat = isp116x_read_reg16(isp116x, HCuPINT); 616 isp116x_write_reg16(isp116x, HCuPINT, irqstat); 617 618 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) { 619 ret = IRQ_HANDLED; 620 finish_atl_transfers(isp116x, regs); 621 } 622 623 if (irqstat & HCuPINT_OPR) { 624 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT); 625 isp116x_write_reg32(isp116x, HCINTSTAT, intstat); 626 if (intstat & HCINT_UE) { 627 ERR("Unrecoverable error\n"); 628 /* What should we do here? Reset? */ 629 } 630 if (intstat & HCINT_RHSC) { 631 isp116x->rhstatus = 632 isp116x_read_reg32(isp116x, HCRHSTATUS); 633 isp116x->rhport[0] = 634 isp116x_read_reg32(isp116x, HCRHPORT1); 635 isp116x->rhport[1] = 636 isp116x_read_reg32(isp116x, HCRHPORT2); 637 } 638 if (intstat & HCINT_RD) { 639 DBG("---- remote wakeup\n"); 640 schedule_work(&isp116x->rh_resume); 641 ret = IRQ_HANDLED; 642 } 643 irqstat &= ~HCuPINT_OPR; 644 ret = IRQ_HANDLED; 645 } 646 647 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) { 648 start_atl_transfers(isp116x); 649 } 650 651 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb); 652 spin_unlock(&isp116x->lock); 653 return ret; 654 } 655 656 /*-----------------------------------------------------------------*/ 657 658 /* usb 1.1 says max 90% of a frame is available for periodic transfers. 659 * this driver doesn't promise that much since it's got to handle an 660 * IRQ per packet; irq handling latencies also use up that time. 661 */ 662 663 /* out of 1000 us */ 664 #define MAX_PERIODIC_LOAD 600 665 static int balance(struct isp116x *isp116x, u16 period, u16 load) 666 { 667 int i, branch = -ENOSPC; 668 669 /* search for the least loaded schedule branch of that period 670 which has enough bandwidth left unreserved. */ 671 for (i = 0; i < period; i++) { 672 if (branch < 0 || isp116x->load[branch] > isp116x->load[i]) { 673 int j; 674 675 for (j = i; j < PERIODIC_SIZE; j += period) { 676 if ((isp116x->load[j] + load) 677 > MAX_PERIODIC_LOAD) 678 break; 679 } 680 if (j < PERIODIC_SIZE) 681 continue; 682 branch = i; 683 } 684 } 685 return branch; 686 } 687 688 /* NB! ALL the code above this point runs with isp116x->lock 689 held, irqs off 690 */ 691 692 /*-----------------------------------------------------------------*/ 693 694 static int isp116x_urb_enqueue(struct usb_hcd *hcd, 695 struct usb_host_endpoint *hep, struct urb *urb, 696 unsigned mem_flags) 697 { 698 struct isp116x *isp116x = hcd_to_isp116x(hcd); 699 struct usb_device *udev = urb->dev; 700 unsigned int pipe = urb->pipe; 701 int is_out = !usb_pipein(pipe); 702 int type = usb_pipetype(pipe); 703 int epnum = usb_pipeendpoint(pipe); 704 struct isp116x_ep *ep = NULL; 705 unsigned long flags; 706 int i; 707 int ret = 0; 708 709 urb_dbg(urb, "Enqueue"); 710 711 if (type == PIPE_ISOCHRONOUS) { 712 ERR("Isochronous transfers not supported\n"); 713 urb_dbg(urb, "Refused to enqueue"); 714 return -ENXIO; 715 } 716 /* avoid all allocations within spinlocks: request or endpoint */ 717 if (!hep->hcpriv) { 718 ep = kcalloc(1, sizeof *ep, mem_flags); 719 if (!ep) 720 return -ENOMEM; 721 } 722 723 spin_lock_irqsave(&isp116x->lock, flags); 724 if (!HC_IS_RUNNING(hcd->state)) { 725 ret = -ENODEV; 726 goto fail; 727 } 728 729 if (hep->hcpriv) 730 ep = hep->hcpriv; 731 else { 732 INIT_LIST_HEAD(&ep->schedule); 733 ep->udev = usb_get_dev(udev); 734 ep->epnum = epnum; 735 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out); 736 usb_settoggle(udev, epnum, is_out, 0); 737 738 if (type == PIPE_CONTROL) { 739 ep->nextpid = USB_PID_SETUP; 740 } else if (is_out) { 741 ep->nextpid = USB_PID_OUT; 742 } else { 743 ep->nextpid = USB_PID_IN; 744 } 745 746 if (urb->interval) { 747 /* 748 With INT URBs submitted, the driver works with SOF 749 interrupt enabled and ATL interrupt disabled. After 750 the PTDs are written to fifo ram, the chip starts 751 fifo processing and usb transfers after the next 752 SOF and continues until the transfers are finished 753 (succeeded or failed) or the frame ends. Therefore, 754 the transfers occur only in every second frame, 755 while fifo reading/writing and data processing 756 occur in every other second frame. */ 757 if (urb->interval < 2) 758 urb->interval = 2; 759 if (urb->interval > 2 * PERIODIC_SIZE) 760 urb->interval = 2 * PERIODIC_SIZE; 761 ep->period = urb->interval >> 1; 762 ep->branch = PERIODIC_SIZE; 763 ep->load = usb_calc_bus_time(udev->speed, 764 !is_out, 765 (type == PIPE_ISOCHRONOUS), 766 usb_maxpacket(udev, pipe, 767 is_out)) / 768 1000; 769 } 770 hep->hcpriv = ep; 771 ep->hep = hep; 772 } 773 774 /* maybe put endpoint into schedule */ 775 switch (type) { 776 case PIPE_CONTROL: 777 case PIPE_BULK: 778 if (list_empty(&ep->schedule)) 779 list_add_tail(&ep->schedule, &isp116x->async); 780 break; 781 case PIPE_INTERRUPT: 782 urb->interval = ep->period; 783 ep->length = min((int)ep->maxpacket, 784 urb->transfer_buffer_length); 785 786 /* urb submitted for already existing endpoint */ 787 if (ep->branch < PERIODIC_SIZE) 788 break; 789 790 ret = ep->branch = balance(isp116x, ep->period, ep->load); 791 if (ret < 0) 792 goto fail; 793 ret = 0; 794 795 urb->start_frame = (isp116x->fmindex & (PERIODIC_SIZE - 1)) 796 + ep->branch; 797 798 /* sort each schedule branch by period (slow before fast) 799 to share the faster parts of the tree without needing 800 dummy/placeholder nodes */ 801 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch); 802 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) { 803 struct isp116x_ep **prev = &isp116x->periodic[i]; 804 struct isp116x_ep *here = *prev; 805 806 while (here && ep != here) { 807 if (ep->period > here->period) 808 break; 809 prev = &here->next; 810 here = *prev; 811 } 812 if (ep != here) { 813 ep->next = here; 814 *prev = ep; 815 } 816 isp116x->load[i] += ep->load; 817 } 818 hcd->self.bandwidth_allocated += ep->load / ep->period; 819 820 /* switch over to SOFint */ 821 if (!isp116x->periodic_count++) { 822 isp116x->irqenb &= ~HCuPINT_ATL; 823 isp116x->irqenb |= HCuPINT_SOF; 824 isp116x_write_reg16(isp116x, HCuPINTENB, 825 isp116x->irqenb); 826 } 827 } 828 829 /* in case of unlink-during-submit */ 830 spin_lock(&urb->lock); 831 if (urb->status != -EINPROGRESS) { 832 spin_unlock(&urb->lock); 833 finish_request(isp116x, ep, urb, NULL); 834 ret = 0; 835 goto fail; 836 } 837 urb->hcpriv = hep; 838 spin_unlock(&urb->lock); 839 start_atl_transfers(isp116x); 840 841 fail: 842 spin_unlock_irqrestore(&isp116x->lock, flags); 843 return ret; 844 } 845 846 /* 847 Dequeue URBs. 848 */ 849 static int isp116x_urb_dequeue(struct usb_hcd *hcd, struct urb *urb) 850 { 851 struct isp116x *isp116x = hcd_to_isp116x(hcd); 852 struct usb_host_endpoint *hep; 853 struct isp116x_ep *ep, *ep_act; 854 unsigned long flags; 855 856 spin_lock_irqsave(&isp116x->lock, flags); 857 hep = urb->hcpriv; 858 /* URB already unlinked (or never linked)? */ 859 if (!hep) { 860 spin_unlock_irqrestore(&isp116x->lock, flags); 861 return 0; 862 } 863 ep = hep->hcpriv; 864 WARN_ON(hep != ep->hep); 865 866 /* In front of queue? */ 867 if (ep->hep->urb_list.next == &urb->urb_list) 868 /* active? */ 869 for (ep_act = isp116x->atl_active; ep_act; 870 ep_act = ep_act->active) 871 if (ep_act == ep) { 872 VDBG("dequeue, urb %p active; wait for irq\n", 873 urb); 874 urb = NULL; 875 break; 876 } 877 878 if (urb) 879 finish_request(isp116x, ep, urb, NULL); 880 881 spin_unlock_irqrestore(&isp116x->lock, flags); 882 return 0; 883 } 884 885 static void isp116x_endpoint_disable(struct usb_hcd *hcd, 886 struct usb_host_endpoint *hep) 887 { 888 int i; 889 struct isp116x_ep *ep = hep->hcpriv;; 890 891 if (!ep) 892 return; 893 894 /* assume we'd just wait for the irq */ 895 for (i = 0; i < 100 && !list_empty(&hep->urb_list); i++) 896 msleep(3); 897 if (!list_empty(&hep->urb_list)) 898 WARN("ep %p not empty?\n", ep); 899 900 usb_put_dev(ep->udev); 901 kfree(ep); 902 hep->hcpriv = NULL; 903 } 904 905 static int isp116x_get_frame(struct usb_hcd *hcd) 906 { 907 struct isp116x *isp116x = hcd_to_isp116x(hcd); 908 u32 fmnum; 909 unsigned long flags; 910 911 spin_lock_irqsave(&isp116x->lock, flags); 912 fmnum = isp116x_read_reg32(isp116x, HCFMNUM); 913 spin_unlock_irqrestore(&isp116x->lock, flags); 914 return (int)fmnum; 915 } 916 917 /*----------------------------------------------------------------*/ 918 919 /* 920 Adapted from ohci-hub.c. Currently we don't support autosuspend. 921 */ 922 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf) 923 { 924 struct isp116x *isp116x = hcd_to_isp116x(hcd); 925 int ports, i, changed = 0; 926 927 if (!HC_IS_RUNNING(hcd->state)) 928 return -ESHUTDOWN; 929 930 ports = isp116x->rhdesca & RH_A_NDP; 931 932 /* init status */ 933 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC)) 934 buf[0] = changed = 1; 935 else 936 buf[0] = 0; 937 938 for (i = 0; i < ports; i++) { 939 u32 status = isp116x->rhport[i]; 940 941 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC 942 | RH_PS_OCIC | RH_PS_PRSC)) { 943 changed = 1; 944 buf[0] |= 1 << (i + 1); 945 continue; 946 } 947 } 948 return changed; 949 } 950 951 static void isp116x_hub_descriptor(struct isp116x *isp116x, 952 struct usb_hub_descriptor *desc) 953 { 954 u32 reg = isp116x->rhdesca; 955 956 desc->bDescriptorType = 0x29; 957 desc->bDescLength = 9; 958 desc->bHubContrCurrent = 0; 959 desc->bNbrPorts = (u8) (reg & 0x3); 960 /* Power switching, device type, overcurrent. */ 961 desc->wHubCharacteristics = 962 (__force __u16) cpu_to_le16((u16) ((reg >> 8) & 0x1f)); 963 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff); 964 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */ 965 desc->bitmap[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1; 966 desc->bitmap[1] = ~0; 967 } 968 969 /* Perform reset of a given port. 970 It would be great to just start the reset and let the 971 USB core to clear the reset in due time. However, 972 root hub ports should be reset for at least 50 ms, while 973 our chip stays in reset for about 10 ms. I.e., we must 974 repeatedly reset it ourself here. 975 */ 976 static inline void root_port_reset(struct isp116x *isp116x, unsigned port) 977 { 978 u32 tmp; 979 unsigned long flags, t; 980 981 /* Root hub reset should be 50 ms, but some devices 982 want it even longer. */ 983 t = jiffies + msecs_to_jiffies(100); 984 985 while (time_before(jiffies, t)) { 986 spin_lock_irqsave(&isp116x->lock, flags); 987 /* spin until any current reset finishes */ 988 for (;;) { 989 tmp = isp116x_read_reg32(isp116x, port ? 990 HCRHPORT2 : HCRHPORT1); 991 if (!(tmp & RH_PS_PRS)) 992 break; 993 udelay(500); 994 } 995 /* Don't reset a disconnected port */ 996 if (!(tmp & RH_PS_CCS)) { 997 spin_unlock_irqrestore(&isp116x->lock, flags); 998 break; 999 } 1000 /* Reset lasts 10ms (claims datasheet) */ 1001 isp116x_write_reg32(isp116x, port ? HCRHPORT2 : 1002 HCRHPORT1, (RH_PS_PRS)); 1003 spin_unlock_irqrestore(&isp116x->lock, flags); 1004 msleep(10); 1005 } 1006 } 1007 1008 /* Adapted from ohci-hub.c */ 1009 static int isp116x_hub_control(struct usb_hcd *hcd, 1010 u16 typeReq, 1011 u16 wValue, u16 wIndex, char *buf, u16 wLength) 1012 { 1013 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1014 int ret = 0; 1015 unsigned long flags; 1016 int ports = isp116x->rhdesca & RH_A_NDP; 1017 u32 tmp = 0; 1018 1019 switch (typeReq) { 1020 case ClearHubFeature: 1021 DBG("ClearHubFeature: "); 1022 switch (wValue) { 1023 case C_HUB_OVER_CURRENT: 1024 DBG("C_HUB_OVER_CURRENT\n"); 1025 spin_lock_irqsave(&isp116x->lock, flags); 1026 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC); 1027 spin_unlock_irqrestore(&isp116x->lock, flags); 1028 case C_HUB_LOCAL_POWER: 1029 DBG("C_HUB_LOCAL_POWER\n"); 1030 break; 1031 default: 1032 goto error; 1033 } 1034 break; 1035 case SetHubFeature: 1036 DBG("SetHubFeature: "); 1037 switch (wValue) { 1038 case C_HUB_OVER_CURRENT: 1039 case C_HUB_LOCAL_POWER: 1040 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n"); 1041 break; 1042 default: 1043 goto error; 1044 } 1045 break; 1046 case GetHubDescriptor: 1047 DBG("GetHubDescriptor\n"); 1048 isp116x_hub_descriptor(isp116x, 1049 (struct usb_hub_descriptor *)buf); 1050 break; 1051 case GetHubStatus: 1052 DBG("GetHubStatus\n"); 1053 *(__le32 *) buf = 0; 1054 break; 1055 case GetPortStatus: 1056 DBG("GetPortStatus\n"); 1057 if (!wIndex || wIndex > ports) 1058 goto error; 1059 tmp = isp116x->rhport[--wIndex]; 1060 *(__le32 *) buf = cpu_to_le32(tmp); 1061 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp); 1062 break; 1063 case ClearPortFeature: 1064 DBG("ClearPortFeature: "); 1065 if (!wIndex || wIndex > ports) 1066 goto error; 1067 wIndex--; 1068 1069 switch (wValue) { 1070 case USB_PORT_FEAT_ENABLE: 1071 DBG("USB_PORT_FEAT_ENABLE\n"); 1072 tmp = RH_PS_CCS; 1073 break; 1074 case USB_PORT_FEAT_C_ENABLE: 1075 DBG("USB_PORT_FEAT_C_ENABLE\n"); 1076 tmp = RH_PS_PESC; 1077 break; 1078 case USB_PORT_FEAT_SUSPEND: 1079 DBG("USB_PORT_FEAT_SUSPEND\n"); 1080 tmp = RH_PS_POCI; 1081 break; 1082 case USB_PORT_FEAT_C_SUSPEND: 1083 DBG("USB_PORT_FEAT_C_SUSPEND\n"); 1084 tmp = RH_PS_PSSC; 1085 break; 1086 case USB_PORT_FEAT_POWER: 1087 DBG("USB_PORT_FEAT_POWER\n"); 1088 tmp = RH_PS_LSDA; 1089 break; 1090 case USB_PORT_FEAT_C_CONNECTION: 1091 DBG("USB_PORT_FEAT_C_CONNECTION\n"); 1092 tmp = RH_PS_CSC; 1093 break; 1094 case USB_PORT_FEAT_C_OVER_CURRENT: 1095 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n"); 1096 tmp = RH_PS_OCIC; 1097 break; 1098 case USB_PORT_FEAT_C_RESET: 1099 DBG("USB_PORT_FEAT_C_RESET\n"); 1100 tmp = RH_PS_PRSC; 1101 break; 1102 default: 1103 goto error; 1104 } 1105 spin_lock_irqsave(&isp116x->lock, flags); 1106 isp116x_write_reg32(isp116x, wIndex 1107 ? HCRHPORT2 : HCRHPORT1, tmp); 1108 isp116x->rhport[wIndex] = 1109 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1); 1110 spin_unlock_irqrestore(&isp116x->lock, flags); 1111 break; 1112 case SetPortFeature: 1113 DBG("SetPortFeature: "); 1114 if (!wIndex || wIndex > ports) 1115 goto error; 1116 wIndex--; 1117 switch (wValue) { 1118 case USB_PORT_FEAT_SUSPEND: 1119 DBG("USB_PORT_FEAT_SUSPEND\n"); 1120 spin_lock_irqsave(&isp116x->lock, flags); 1121 isp116x_write_reg32(isp116x, wIndex 1122 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS); 1123 break; 1124 case USB_PORT_FEAT_POWER: 1125 DBG("USB_PORT_FEAT_POWER\n"); 1126 spin_lock_irqsave(&isp116x->lock, flags); 1127 isp116x_write_reg32(isp116x, wIndex 1128 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS); 1129 break; 1130 case USB_PORT_FEAT_RESET: 1131 DBG("USB_PORT_FEAT_RESET\n"); 1132 root_port_reset(isp116x, wIndex); 1133 spin_lock_irqsave(&isp116x->lock, flags); 1134 break; 1135 default: 1136 goto error; 1137 } 1138 isp116x->rhport[wIndex] = 1139 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1); 1140 spin_unlock_irqrestore(&isp116x->lock, flags); 1141 break; 1142 1143 default: 1144 error: 1145 /* "protocol stall" on error */ 1146 DBG("PROTOCOL STALL\n"); 1147 ret = -EPIPE; 1148 } 1149 return ret; 1150 } 1151 1152 #ifdef CONFIG_PM 1153 1154 static int isp116x_hub_suspend(struct usb_hcd *hcd) 1155 { 1156 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1157 unsigned long flags; 1158 u32 val; 1159 int ret = 0; 1160 1161 spin_lock_irqsave(&isp116x->lock, flags); 1162 1163 val = isp116x_read_reg32(isp116x, HCCONTROL); 1164 switch (val & HCCONTROL_HCFS) { 1165 case HCCONTROL_USB_OPER: 1166 hcd->state = HC_STATE_QUIESCING; 1167 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE); 1168 val |= HCCONTROL_USB_SUSPEND; 1169 if (hcd->remote_wakeup) 1170 val |= HCCONTROL_RWE; 1171 /* Wait for usb transfers to finish */ 1172 mdelay(2); 1173 isp116x_write_reg32(isp116x, HCCONTROL, val); 1174 hcd->state = HC_STATE_SUSPENDED; 1175 /* Wait for devices to suspend */ 1176 mdelay(5); 1177 case HCCONTROL_USB_SUSPEND: 1178 break; 1179 case HCCONTROL_USB_RESUME: 1180 isp116x_write_reg32(isp116x, HCCONTROL, 1181 (val & ~HCCONTROL_HCFS) | 1182 HCCONTROL_USB_RESET); 1183 case HCCONTROL_USB_RESET: 1184 ret = -EBUSY; 1185 break; 1186 default: 1187 ret = -EINVAL; 1188 } 1189 1190 spin_unlock_irqrestore(&isp116x->lock, flags); 1191 return ret; 1192 } 1193 1194 static int isp116x_hub_resume(struct usb_hcd *hcd) 1195 { 1196 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1197 u32 val; 1198 int ret = -EINPROGRESS; 1199 1200 msleep(5); 1201 spin_lock_irq(&isp116x->lock); 1202 1203 val = isp116x_read_reg32(isp116x, HCCONTROL); 1204 switch (val & HCCONTROL_HCFS) { 1205 case HCCONTROL_USB_SUSPEND: 1206 val &= ~HCCONTROL_HCFS; 1207 val |= HCCONTROL_USB_RESUME; 1208 isp116x_write_reg32(isp116x, HCCONTROL, val); 1209 case HCCONTROL_USB_RESUME: 1210 break; 1211 case HCCONTROL_USB_OPER: 1212 /* Without setting power_state here the 1213 SUSPENDED state won't be removed from 1214 sysfs/usbN/power.state as a response to remote 1215 wakeup. Maybe in the future. */ 1216 hcd->self.root_hub->dev.power.power_state = PMSG_ON; 1217 ret = 0; 1218 break; 1219 default: 1220 ret = -EBUSY; 1221 } 1222 1223 if (ret != -EINPROGRESS) { 1224 spin_unlock_irq(&isp116x->lock); 1225 return ret; 1226 } 1227 1228 val = isp116x->rhdesca & RH_A_NDP; 1229 while (val--) { 1230 u32 stat = 1231 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1); 1232 /* force global, not selective, resume */ 1233 if (!(stat & RH_PS_PSS)) 1234 continue; 1235 DBG("%s: Resuming port %d\n", __func__, val); 1236 isp116x_write_reg32(isp116x, RH_PS_POCI, val 1237 ? HCRHPORT2 : HCRHPORT1); 1238 } 1239 spin_unlock_irq(&isp116x->lock); 1240 1241 hcd->state = HC_STATE_RESUMING; 1242 mdelay(20); 1243 1244 /* Go operational */ 1245 spin_lock_irq(&isp116x->lock); 1246 val = isp116x_read_reg32(isp116x, HCCONTROL); 1247 isp116x_write_reg32(isp116x, HCCONTROL, 1248 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER); 1249 spin_unlock_irq(&isp116x->lock); 1250 /* see analogous comment above */ 1251 hcd->self.root_hub->dev.power.power_state = PMSG_ON; 1252 hcd->state = HC_STATE_RUNNING; 1253 1254 return 0; 1255 } 1256 1257 static void isp116x_rh_resume(void *_hcd) 1258 { 1259 struct usb_hcd *hcd = _hcd; 1260 1261 usb_resume_device(hcd->self.root_hub); 1262 } 1263 1264 #else 1265 1266 #define isp116x_hub_suspend NULL 1267 #define isp116x_hub_resume NULL 1268 1269 static void isp116x_rh_resume(void *_hcd) 1270 { 1271 } 1272 1273 #endif 1274 1275 /*-----------------------------------------------------------------*/ 1276 1277 #ifdef STUB_DEBUG_FILE 1278 1279 static inline void create_debug_file(struct isp116x *isp116x) 1280 { 1281 } 1282 1283 static inline void remove_debug_file(struct isp116x *isp116x) 1284 { 1285 } 1286 1287 #else 1288 1289 #include <linux/proc_fs.h> 1290 #include <linux/seq_file.h> 1291 1292 static void dump_irq(struct seq_file *s, char *label, u16 mask) 1293 { 1294 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask, 1295 mask & HCuPINT_CLKRDY ? " clkrdy" : "", 1296 mask & HCuPINT_SUSP ? " susp" : "", 1297 mask & HCuPINT_OPR ? " opr" : "", 1298 mask & HCuPINT_AIIEOT ? " eot" : "", 1299 mask & HCuPINT_ATL ? " atl" : "", 1300 mask & HCuPINT_SOF ? " sof" : ""); 1301 } 1302 1303 static void dump_int(struct seq_file *s, char *label, u32 mask) 1304 { 1305 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask, 1306 mask & HCINT_MIE ? " MIE" : "", 1307 mask & HCINT_RHSC ? " rhsc" : "", 1308 mask & HCINT_FNO ? " fno" : "", 1309 mask & HCINT_UE ? " ue" : "", 1310 mask & HCINT_RD ? " rd" : "", 1311 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : ""); 1312 } 1313 1314 static int proc_isp116x_show(struct seq_file *s, void *unused) 1315 { 1316 struct isp116x *isp116x = s->private; 1317 struct isp116x_ep *ep; 1318 struct urb *urb; 1319 unsigned i; 1320 char *str; 1321 1322 seq_printf(s, "%s\n%s version %s\n", 1323 isp116x_to_hcd(isp116x)->product_desc, hcd_name, 1324 DRIVER_VERSION); 1325 1326 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) { 1327 seq_printf(s, "HCD is suspended\n"); 1328 return 0; 1329 } 1330 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) { 1331 seq_printf(s, "HCD not running\n"); 1332 return 0; 1333 } 1334 1335 spin_lock_irq(&isp116x->lock); 1336 1337 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB)); 1338 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT)); 1339 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB)); 1340 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT)); 1341 1342 list_for_each_entry(ep, &isp116x->async, schedule) { 1343 1344 switch (ep->nextpid) { 1345 case USB_PID_IN: 1346 str = "in"; 1347 break; 1348 case USB_PID_OUT: 1349 str = "out"; 1350 break; 1351 case USB_PID_SETUP: 1352 str = "setup"; 1353 break; 1354 case USB_PID_ACK: 1355 str = "status"; 1356 break; 1357 default: 1358 str = "?"; 1359 break; 1360 }; 1361 seq_printf(s, "%p, ep%d%s, maxpacket %d:\n", ep, 1362 ep->epnum, str, ep->maxpacket); 1363 list_for_each_entry(urb, &ep->hep->urb_list, urb_list) { 1364 seq_printf(s, " urb%p, %d/%d\n", urb, 1365 urb->actual_length, 1366 urb->transfer_buffer_length); 1367 } 1368 } 1369 if (!list_empty(&isp116x->async)) 1370 seq_printf(s, "\n"); 1371 1372 seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE); 1373 1374 for (i = 0; i < PERIODIC_SIZE; i++) { 1375 ep = isp116x->periodic[i]; 1376 if (!ep) 1377 continue; 1378 seq_printf(s, "%2d [%3d]:\n", i, isp116x->load[i]); 1379 1380 /* DUMB: prints shared entries multiple times */ 1381 do { 1382 seq_printf(s, " %d/%p (%sdev%d ep%d%s max %d)\n", 1383 ep->period, ep, 1384 (ep->udev->speed == 1385 USB_SPEED_FULL) ? "" : "ls ", 1386 ep->udev->devnum, ep->epnum, 1387 (ep->epnum == 1388 0) ? "" : ((ep->nextpid == 1389 USB_PID_IN) ? "in" : "out"), 1390 ep->maxpacket); 1391 ep = ep->next; 1392 } while (ep); 1393 } 1394 spin_unlock_irq(&isp116x->lock); 1395 seq_printf(s, "\n"); 1396 1397 return 0; 1398 } 1399 1400 static int proc_isp116x_open(struct inode *inode, struct file *file) 1401 { 1402 return single_open(file, proc_isp116x_show, PDE(inode)->data); 1403 } 1404 1405 static struct file_operations proc_ops = { 1406 .open = proc_isp116x_open, 1407 .read = seq_read, 1408 .llseek = seq_lseek, 1409 .release = single_release, 1410 }; 1411 1412 /* expect just one isp116x per system */ 1413 static const char proc_filename[] = "driver/isp116x"; 1414 1415 static void create_debug_file(struct isp116x *isp116x) 1416 { 1417 struct proc_dir_entry *pde; 1418 1419 pde = create_proc_entry(proc_filename, 0, NULL); 1420 if (pde == NULL) 1421 return; 1422 1423 pde->proc_fops = &proc_ops; 1424 pde->data = isp116x; 1425 isp116x->pde = pde; 1426 } 1427 1428 static void remove_debug_file(struct isp116x *isp116x) 1429 { 1430 if (isp116x->pde) 1431 remove_proc_entry(proc_filename, NULL); 1432 } 1433 1434 #endif 1435 1436 /*-----------------------------------------------------------------*/ 1437 1438 /* 1439 Software reset - can be called from any contect. 1440 */ 1441 static int isp116x_sw_reset(struct isp116x *isp116x) 1442 { 1443 int retries = 15; 1444 unsigned long flags; 1445 int ret = 0; 1446 1447 spin_lock_irqsave(&isp116x->lock, flags); 1448 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC); 1449 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR); 1450 while (--retries) { 1451 /* It usually resets within 1 ms */ 1452 mdelay(1); 1453 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR)) 1454 break; 1455 } 1456 if (!retries) { 1457 ERR("Software reset timeout\n"); 1458 ret = -ETIME; 1459 } 1460 spin_unlock_irqrestore(&isp116x->lock, flags); 1461 return ret; 1462 } 1463 1464 /* 1465 Reset. Tries to perform platform-specific hardware 1466 reset first; falls back to software reset. 1467 */ 1468 static int isp116x_reset(struct usb_hcd *hcd) 1469 { 1470 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1471 unsigned long t; 1472 u16 clkrdy = 0; 1473 int ret = 0, timeout = 15 /* ms */ ; 1474 1475 if (isp116x->board && isp116x->board->reset) { 1476 /* Hardware reset */ 1477 isp116x->board->reset(hcd->self.controller, 1); 1478 msleep(10); 1479 if (isp116x->board->clock) 1480 isp116x->board->clock(hcd->self.controller, 1); 1481 msleep(1); 1482 isp116x->board->reset(hcd->self.controller, 0); 1483 } else 1484 ret = isp116x_sw_reset(isp116x); 1485 1486 if (ret) 1487 return ret; 1488 1489 t = jiffies + msecs_to_jiffies(timeout); 1490 while (time_before_eq(jiffies, t)) { 1491 msleep(4); 1492 spin_lock_irq(&isp116x->lock); 1493 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY; 1494 spin_unlock_irq(&isp116x->lock); 1495 if (clkrdy) 1496 break; 1497 } 1498 if (!clkrdy) { 1499 ERR("Clock not ready after 20ms\n"); 1500 /* After sw_reset the clock won't report to be ready, if 1501 H_WAKEUP pin is high. */ 1502 if (!isp116x->board || !isp116x->board->reset) 1503 ERR("The driver does not support hardware wakeup.\n"); 1504 ERR("Please make sure that the H_WAKEUP pin " 1505 "is pulled low!\n"); 1506 ret = -ENODEV; 1507 } 1508 return ret; 1509 } 1510 1511 static void isp116x_stop(struct usb_hcd *hcd) 1512 { 1513 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1514 unsigned long flags; 1515 u32 val; 1516 1517 spin_lock_irqsave(&isp116x->lock, flags); 1518 isp116x_write_reg16(isp116x, HCuPINTENB, 0); 1519 1520 /* Switch off ports' power, some devices don't come up 1521 after next 'insmod' without this */ 1522 val = isp116x_read_reg32(isp116x, HCRHDESCA); 1523 val &= ~(RH_A_NPS | RH_A_PSM); 1524 isp116x_write_reg32(isp116x, HCRHDESCA, val); 1525 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS); 1526 spin_unlock_irqrestore(&isp116x->lock, flags); 1527 1528 /* Put the chip into reset state */ 1529 if (isp116x->board && isp116x->board->reset) 1530 isp116x->board->reset(hcd->self.controller, 0); 1531 else 1532 isp116x_sw_reset(isp116x); 1533 1534 /* Stop the clock */ 1535 if (isp116x->board && isp116x->board->clock) 1536 isp116x->board->clock(hcd->self.controller, 0); 1537 } 1538 1539 /* 1540 Configure the chip. The chip must be successfully reset by now. 1541 */ 1542 static int isp116x_start(struct usb_hcd *hcd) 1543 { 1544 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1545 struct isp116x_platform_data *board = isp116x->board; 1546 u32 val; 1547 unsigned long flags; 1548 1549 spin_lock_irqsave(&isp116x->lock, flags); 1550 1551 /* clear interrupt status and disable all interrupt sources */ 1552 isp116x_write_reg16(isp116x, HCuPINT, 0xff); 1553 isp116x_write_reg16(isp116x, HCuPINTENB, 0); 1554 1555 val = isp116x_read_reg16(isp116x, HCCHIPID); 1556 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) { 1557 ERR("Invalid chip ID %04x\n", val); 1558 spin_unlock_irqrestore(&isp116x->lock, flags); 1559 return -ENODEV; 1560 } 1561 1562 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE); 1563 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE); 1564 1565 /* ----- HW conf */ 1566 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1); 1567 if (board->sel15Kres) 1568 val |= HCHWCFG_15KRSEL; 1569 /* Remote wakeup won't work without working clock */ 1570 if (board->clknotstop || board->remote_wakeup_enable) 1571 val |= HCHWCFG_CLKNOTSTOP; 1572 if (board->oc_enable) 1573 val |= HCHWCFG_ANALOG_OC; 1574 if (board->int_act_high) 1575 val |= HCHWCFG_INT_POL; 1576 if (board->int_edge_triggered) 1577 val |= HCHWCFG_INT_TRIGGER; 1578 isp116x_write_reg16(isp116x, HCHWCFG, val); 1579 1580 /* ----- Root hub conf */ 1581 val = 0; 1582 /* AN10003_1.pdf recommends NPS to be always 1 */ 1583 if (board->no_power_switching) 1584 val |= RH_A_NPS; 1585 if (board->power_switching_mode) 1586 val |= RH_A_PSM; 1587 if (board->potpg) 1588 val |= (board->potpg << 24) & RH_A_POTPGT; 1589 else 1590 val |= (25 << 24) & RH_A_POTPGT; 1591 isp116x_write_reg32(isp116x, HCRHDESCA, val); 1592 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA); 1593 1594 val = RH_B_PPCM; 1595 isp116x_write_reg32(isp116x, HCRHDESCB, val); 1596 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB); 1597 1598 val = 0; 1599 if (board->remote_wakeup_enable) { 1600 hcd->can_wakeup = 1; 1601 val |= RH_HS_DRWE; 1602 } 1603 isp116x_write_reg32(isp116x, HCRHSTATUS, val); 1604 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS); 1605 1606 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf); 1607 1608 hcd->state = HC_STATE_RUNNING; 1609 1610 /* Set up interrupts */ 1611 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE; 1612 if (board->remote_wakeup_enable) 1613 isp116x->intenb |= HCINT_RD; 1614 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */ 1615 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb); 1616 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb); 1617 1618 /* Go operational */ 1619 val = HCCONTROL_USB_OPER; 1620 /* Remote wakeup connected - NOT SUPPORTED */ 1621 /* if (board->remote_wakeup_connected) 1622 val |= HCCONTROL_RWC; */ 1623 if (board->remote_wakeup_enable) 1624 val |= HCCONTROL_RWE; 1625 isp116x_write_reg32(isp116x, HCCONTROL, val); 1626 1627 /* Disable ports to avoid race in device enumeration */ 1628 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS); 1629 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS); 1630 1631 isp116x_show_regs(isp116x); 1632 spin_unlock_irqrestore(&isp116x->lock, flags); 1633 return 0; 1634 } 1635 1636 /*-----------------------------------------------------------------*/ 1637 1638 static struct hc_driver isp116x_hc_driver = { 1639 .description = hcd_name, 1640 .product_desc = "ISP116x Host Controller", 1641 .hcd_priv_size = sizeof(struct isp116x), 1642 1643 .irq = isp116x_irq, 1644 .flags = HCD_USB11, 1645 1646 .reset = isp116x_reset, 1647 .start = isp116x_start, 1648 .stop = isp116x_stop, 1649 1650 .urb_enqueue = isp116x_urb_enqueue, 1651 .urb_dequeue = isp116x_urb_dequeue, 1652 .endpoint_disable = isp116x_endpoint_disable, 1653 1654 .get_frame_number = isp116x_get_frame, 1655 1656 .hub_status_data = isp116x_hub_status_data, 1657 .hub_control = isp116x_hub_control, 1658 .hub_suspend = isp116x_hub_suspend, 1659 .hub_resume = isp116x_hub_resume, 1660 }; 1661 1662 /*----------------------------------------------------------------*/ 1663 1664 static int __init_or_module isp116x_remove(struct device *dev) 1665 { 1666 struct usb_hcd *hcd = dev_get_drvdata(dev); 1667 struct isp116x *isp116x; 1668 struct platform_device *pdev; 1669 struct resource *res; 1670 1671 if(!hcd) 1672 return 0; 1673 isp116x = hcd_to_isp116x(hcd); 1674 pdev = container_of(dev, struct platform_device, dev); 1675 remove_debug_file(isp116x); 1676 usb_remove_hcd(hcd); 1677 1678 iounmap(isp116x->data_reg); 1679 res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 1680 release_mem_region(res->start, 2); 1681 iounmap(isp116x->addr_reg); 1682 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1683 release_mem_region(res->start, 2); 1684 1685 usb_put_hcd(hcd); 1686 return 0; 1687 } 1688 1689 #define resource_len(r) (((r)->end - (r)->start) + 1) 1690 1691 static int __init isp116x_probe(struct device *dev) 1692 { 1693 struct usb_hcd *hcd; 1694 struct isp116x *isp116x; 1695 struct platform_device *pdev; 1696 struct resource *addr, *data; 1697 void __iomem *addr_reg; 1698 void __iomem *data_reg; 1699 int irq; 1700 int ret = 0; 1701 1702 pdev = container_of(dev, struct platform_device, dev); 1703 if (pdev->num_resources < 3) { 1704 ret = -ENODEV; 1705 goto err1; 1706 } 1707 1708 data = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1709 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1); 1710 irq = platform_get_irq(pdev, 0); 1711 if (!addr || !data || irq < 0) { 1712 ret = -ENODEV; 1713 goto err1; 1714 } 1715 1716 if (dev->dma_mask) { 1717 DBG("DMA not supported\n"); 1718 ret = -EINVAL; 1719 goto err1; 1720 } 1721 1722 if (!request_mem_region(addr->start, 2, hcd_name)) { 1723 ret = -EBUSY; 1724 goto err1; 1725 } 1726 addr_reg = ioremap(addr->start, resource_len(addr)); 1727 if (addr_reg == NULL) { 1728 ret = -ENOMEM; 1729 goto err2; 1730 } 1731 if (!request_mem_region(data->start, 2, hcd_name)) { 1732 ret = -EBUSY; 1733 goto err3; 1734 } 1735 data_reg = ioremap(data->start, resource_len(data)); 1736 if (data_reg == NULL) { 1737 ret = -ENOMEM; 1738 goto err4; 1739 } 1740 1741 /* allocate and initialize hcd */ 1742 hcd = usb_create_hcd(&isp116x_hc_driver, dev, dev->bus_id); 1743 if (!hcd) { 1744 ret = -ENOMEM; 1745 goto err5; 1746 } 1747 /* this rsrc_start is bogus */ 1748 hcd->rsrc_start = addr->start; 1749 isp116x = hcd_to_isp116x(hcd); 1750 isp116x->data_reg = data_reg; 1751 isp116x->addr_reg = addr_reg; 1752 spin_lock_init(&isp116x->lock); 1753 INIT_LIST_HEAD(&isp116x->async); 1754 INIT_WORK(&isp116x->rh_resume, isp116x_rh_resume, hcd); 1755 isp116x->board = dev->platform_data; 1756 1757 if (!isp116x->board) { 1758 ERR("Platform data structure not initialized\n"); 1759 ret = -ENODEV; 1760 goto err6; 1761 } 1762 if (isp116x_check_platform_delay(isp116x)) { 1763 ERR("USE_PLATFORM_DELAY defined, but delay function not " 1764 "implemented.\n"); 1765 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n"); 1766 ret = -ENODEV; 1767 goto err6; 1768 } 1769 1770 ret = usb_add_hcd(hcd, irq, SA_INTERRUPT); 1771 if (ret != 0) 1772 goto err6; 1773 1774 create_debug_file(isp116x); 1775 return 0; 1776 1777 err6: 1778 usb_put_hcd(hcd); 1779 err5: 1780 iounmap(data_reg); 1781 err4: 1782 release_mem_region(data->start, 2); 1783 err3: 1784 iounmap(addr_reg); 1785 err2: 1786 release_mem_region(addr->start, 2); 1787 err1: 1788 ERR("init error, %d\n", ret); 1789 return ret; 1790 } 1791 1792 #ifdef CONFIG_PM 1793 /* 1794 Suspend of platform device 1795 */ 1796 static int isp116x_suspend(struct device *dev, pm_message_t state, u32 phase) 1797 { 1798 int ret = 0; 1799 struct usb_hcd *hcd = dev_get_drvdata(dev); 1800 1801 VDBG("%s: state %x, phase %x\n", __func__, state, phase); 1802 1803 if (phase != SUSPEND_DISABLE && phase != SUSPEND_POWER_DOWN) 1804 return 0; 1805 1806 ret = usb_suspend_device(hcd->self.root_hub, state); 1807 if (!ret) { 1808 dev->power.power_state = state; 1809 INFO("%s suspended\n", hcd_name); 1810 } else 1811 ERR("%s suspend failed\n", hcd_name); 1812 1813 return ret; 1814 } 1815 1816 /* 1817 Resume platform device 1818 */ 1819 static int isp116x_resume(struct device *dev, u32 phase) 1820 { 1821 int ret = 0; 1822 struct usb_hcd *hcd = dev_get_drvdata(dev); 1823 1824 VDBG("%s: state %x, phase %x\n", __func__, dev->power.power_state, 1825 phase); 1826 if (phase != RESUME_POWER_ON) 1827 return 0; 1828 1829 ret = usb_resume_device(hcd->self.root_hub); 1830 if (!ret) { 1831 dev->power.power_state = PMSG_ON; 1832 VDBG("%s resumed\n", (char *)hcd_name); 1833 } 1834 return ret; 1835 } 1836 1837 #else 1838 1839 #define isp116x_suspend NULL 1840 #define isp116x_resume NULL 1841 1842 #endif 1843 1844 static struct device_driver isp116x_driver = { 1845 .name = (char *)hcd_name, 1846 .bus = &platform_bus_type, 1847 .probe = isp116x_probe, 1848 .remove = isp116x_remove, 1849 .suspend = isp116x_suspend, 1850 .resume = isp116x_resume, 1851 }; 1852 1853 /*-----------------------------------------------------------------*/ 1854 1855 static int __init isp116x_init(void) 1856 { 1857 if (usb_disabled()) 1858 return -ENODEV; 1859 1860 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION); 1861 return driver_register(&isp116x_driver); 1862 } 1863 1864 module_init(isp116x_init); 1865 1866 static void __exit isp116x_cleanup(void) 1867 { 1868 driver_unregister(&isp116x_driver); 1869 } 1870 1871 module_exit(isp116x_cleanup); 1872