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 "05 Aug 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 len; 233 234 for (ep = isp116x->atl_active; ep; ep = ep->active) { 235 u16 toggle = 0, dir = PTD_DIR_SETUP; 236 237 BUG_ON(list_empty(&ep->hep->urb_list)); 238 urb = container_of(ep->hep->urb_list.next, 239 struct urb, urb_list); 240 ptd = &ep->ptd; 241 len = ep->length; 242 spin_lock(&urb->lock); 243 ep->data = (unsigned char *)urb->transfer_buffer 244 + urb->actual_length; 245 246 switch (ep->nextpid) { 247 case USB_PID_IN: 248 toggle = usb_gettoggle(urb->dev, ep->epnum, 0); 249 dir = PTD_DIR_IN; 250 break; 251 case USB_PID_OUT: 252 toggle = usb_gettoggle(urb->dev, ep->epnum, 1); 253 dir = PTD_DIR_OUT; 254 break; 255 case USB_PID_SETUP: 256 len = sizeof(struct usb_ctrlrequest); 257 ep->data = urb->setup_packet; 258 break; 259 case USB_PID_ACK: 260 toggle = 1; 261 len = 0; 262 dir = (urb->transfer_buffer_length 263 && usb_pipein(urb->pipe)) 264 ? PTD_DIR_OUT : PTD_DIR_IN; 265 break; 266 default: 267 ERR("%s %d: ep->nextpid %d\n", __func__, __LINE__, 268 ep->nextpid); 269 BUG(); 270 } 271 272 ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK | PTD_TOGGLE(toggle); 273 ptd->mps = PTD_MPS(ep->maxpacket) 274 | PTD_SPD(urb->dev->speed == USB_SPEED_LOW) 275 | PTD_EP(ep->epnum); 276 ptd->len = PTD_LEN(len) | PTD_DIR(dir); 277 ptd->faddr = PTD_FA(usb_pipedevice(urb->pipe)); 278 spin_unlock(&urb->lock); 279 if (!ep->active) { 280 ptd->mps |= PTD_LAST_MSK; 281 isp116x->atl_last_dir = dir; 282 } 283 isp116x->atl_bufshrt = sizeof(struct ptd) + isp116x->atl_buflen; 284 isp116x->atl_buflen = isp116x->atl_bufshrt + ALIGN(len, 4); 285 } 286 } 287 288 /* 289 Analyze transfer results, handle partial transfers and errors 290 */ 291 static void postproc_atl_queue(struct isp116x *isp116x) 292 { 293 struct isp116x_ep *ep; 294 struct urb *urb; 295 struct usb_device *udev; 296 struct ptd *ptd; 297 int short_not_ok; 298 u8 cc; 299 300 for (ep = isp116x->atl_active; ep; ep = ep->active) { 301 BUG_ON(list_empty(&ep->hep->urb_list)); 302 urb = 303 container_of(ep->hep->urb_list.next, struct urb, urb_list); 304 udev = urb->dev; 305 ptd = &ep->ptd; 306 cc = PTD_GET_CC(ptd); 307 308 spin_lock(&urb->lock); 309 short_not_ok = 1; 310 311 /* Data underrun is special. For allowed underrun 312 we clear the error and continue as normal. For 313 forbidden underrun we finish the DATA stage 314 immediately while for control transfer, 315 we do a STATUS stage. */ 316 if (cc == TD_DATAUNDERRUN) { 317 if (!(urb->transfer_flags & URB_SHORT_NOT_OK)) { 318 DBG("Allowed data underrun\n"); 319 cc = TD_CC_NOERROR; 320 short_not_ok = 0; 321 } else { 322 ep->error_count = 1; 323 if (usb_pipecontrol(urb->pipe)) 324 ep->nextpid = USB_PID_ACK; 325 else 326 usb_settoggle(udev, ep->epnum, 327 ep->nextpid == 328 USB_PID_OUT, 329 PTD_GET_TOGGLE(ptd) ^ 1); 330 urb->status = cc_to_error[TD_DATAUNDERRUN]; 331 spin_unlock(&urb->lock); 332 continue; 333 } 334 } 335 /* Keep underrun error through the STATUS stage */ 336 if (urb->status == cc_to_error[TD_DATAUNDERRUN]) 337 cc = TD_DATAUNDERRUN; 338 339 if (cc != TD_CC_NOERROR && cc != TD_NOTACCESSED 340 && (++ep->error_count >= 3 || cc == TD_CC_STALL 341 || cc == TD_DATAOVERRUN)) { 342 if (urb->status == -EINPROGRESS) 343 urb->status = cc_to_error[cc]; 344 if (ep->nextpid == USB_PID_ACK) 345 ep->nextpid = 0; 346 spin_unlock(&urb->lock); 347 continue; 348 } 349 /* According to usb spec, zero-length Int transfer signals 350 finishing of the urb. Hey, does this apply only 351 for IN endpoints? */ 352 if (usb_pipeint(urb->pipe) && !PTD_GET_LEN(ptd)) { 353 if (urb->status == -EINPROGRESS) 354 urb->status = 0; 355 spin_unlock(&urb->lock); 356 continue; 357 } 358 359 /* Relax after previously failed, but later succeeded 360 or correctly NAK'ed retransmission attempt */ 361 if (ep->error_count 362 && (cc == TD_CC_NOERROR || cc == TD_NOTACCESSED)) 363 ep->error_count = 0; 364 365 /* Take into account idiosyncracies of the isp116x chip 366 regarding toggle bit for failed transfers */ 367 if (ep->nextpid == USB_PID_OUT) 368 usb_settoggle(udev, ep->epnum, 1, PTD_GET_TOGGLE(ptd) 369 ^ (ep->error_count > 0)); 370 else if (ep->nextpid == USB_PID_IN) 371 usb_settoggle(udev, ep->epnum, 0, PTD_GET_TOGGLE(ptd) 372 ^ (ep->error_count > 0)); 373 374 switch (ep->nextpid) { 375 case USB_PID_IN: 376 case USB_PID_OUT: 377 urb->actual_length += PTD_GET_COUNT(ptd); 378 if (PTD_GET_ACTIVE(ptd) 379 || (cc != TD_CC_NOERROR && cc < 0x0E)) 380 break; 381 if (urb->transfer_buffer_length != urb->actual_length) { 382 if (short_not_ok) 383 break; 384 } else { 385 if (urb->transfer_flags & URB_ZERO_PACKET 386 && ep->nextpid == USB_PID_OUT 387 && !(PTD_GET_COUNT(ptd) % ep->maxpacket)) { 388 DBG("Zero packet requested\n"); 389 break; 390 } 391 } 392 /* All data for this URB is transferred, let's finish */ 393 if (usb_pipecontrol(urb->pipe)) 394 ep->nextpid = USB_PID_ACK; 395 else if (urb->status == -EINPROGRESS) 396 urb->status = 0; 397 break; 398 case USB_PID_SETUP: 399 if (PTD_GET_ACTIVE(ptd) 400 || (cc != TD_CC_NOERROR && cc < 0x0E)) 401 break; 402 if (urb->transfer_buffer_length == urb->actual_length) 403 ep->nextpid = USB_PID_ACK; 404 else if (usb_pipeout(urb->pipe)) { 405 usb_settoggle(udev, 0, 1, 1); 406 ep->nextpid = USB_PID_OUT; 407 } else { 408 usb_settoggle(udev, 0, 0, 1); 409 ep->nextpid = USB_PID_IN; 410 } 411 break; 412 case USB_PID_ACK: 413 if (PTD_GET_ACTIVE(ptd) 414 || (cc != TD_CC_NOERROR && cc < 0x0E)) 415 break; 416 if (urb->status == -EINPROGRESS) 417 urb->status = 0; 418 ep->nextpid = 0; 419 break; 420 default: 421 BUG_ON(1); 422 } 423 spin_unlock(&urb->lock); 424 } 425 } 426 427 /* 428 Take done or failed requests out of schedule. Give back 429 processed urbs. 430 */ 431 static void finish_request(struct isp116x *isp116x, struct isp116x_ep *ep, 432 struct urb *urb, struct pt_regs *regs) 433 __releases(isp116x->lock) __acquires(isp116x->lock) 434 { 435 unsigned i; 436 437 urb->hcpriv = NULL; 438 ep->error_count = 0; 439 440 if (usb_pipecontrol(urb->pipe)) 441 ep->nextpid = USB_PID_SETUP; 442 443 urb_dbg(urb, "Finish"); 444 445 spin_unlock(&isp116x->lock); 446 usb_hcd_giveback_urb(isp116x_to_hcd(isp116x), urb, regs); 447 spin_lock(&isp116x->lock); 448 449 /* take idle endpoints out of the schedule */ 450 if (!list_empty(&ep->hep->urb_list)) 451 return; 452 453 /* async deschedule */ 454 if (!list_empty(&ep->schedule)) { 455 list_del_init(&ep->schedule); 456 return; 457 } 458 459 /* periodic deschedule */ 460 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch); 461 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) { 462 struct isp116x_ep *temp; 463 struct isp116x_ep **prev = &isp116x->periodic[i]; 464 465 while (*prev && ((temp = *prev) != ep)) 466 prev = &temp->next; 467 if (*prev) 468 *prev = ep->next; 469 isp116x->load[i] -= ep->load; 470 } 471 ep->branch = PERIODIC_SIZE; 472 isp116x_to_hcd(isp116x)->self.bandwidth_allocated -= 473 ep->load / ep->period; 474 475 /* switch irq type? */ 476 if (!--isp116x->periodic_count) { 477 isp116x->irqenb &= ~HCuPINT_SOF; 478 isp116x->irqenb |= HCuPINT_ATL; 479 } 480 } 481 482 /* 483 Scan transfer lists, schedule transfers, send data off 484 to chip. 485 */ 486 static void start_atl_transfers(struct isp116x *isp116x) 487 { 488 struct isp116x_ep *last_ep = NULL, *ep; 489 struct urb *urb; 490 u16 load = 0; 491 int len, index, speed, byte_time; 492 493 if (atomic_read(&isp116x->atl_finishing)) 494 return; 495 496 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) 497 return; 498 499 /* FIFO not empty? */ 500 if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL) 501 return; 502 503 isp116x->atl_active = NULL; 504 isp116x->atl_buflen = isp116x->atl_bufshrt = 0; 505 506 /* Schedule int transfers */ 507 if (isp116x->periodic_count) { 508 isp116x->fmindex = index = 509 (isp116x->fmindex + 1) & (PERIODIC_SIZE - 1); 510 if ((load = isp116x->load[index])) { 511 /* Bring all int transfers for this frame 512 into the active queue */ 513 isp116x->atl_active = last_ep = 514 isp116x->periodic[index]; 515 while (last_ep->next) 516 last_ep = (last_ep->active = last_ep->next); 517 last_ep->active = NULL; 518 } 519 } 520 521 /* Schedule control/bulk transfers */ 522 list_for_each_entry(ep, &isp116x->async, schedule) { 523 urb = container_of(ep->hep->urb_list.next, 524 struct urb, urb_list); 525 speed = urb->dev->speed; 526 byte_time = speed == USB_SPEED_LOW 527 ? BYTE_TIME_LOWSPEED : BYTE_TIME_FULLSPEED; 528 529 if (ep->nextpid == USB_PID_SETUP) { 530 len = sizeof(struct usb_ctrlrequest); 531 } else if (ep->nextpid == USB_PID_ACK) { 532 len = 0; 533 } else { 534 /* Find current free length ... */ 535 len = (MAX_LOAD_LIMIT - load) / byte_time; 536 537 /* ... then limit it to configured max size ... */ 538 len = min(len, speed == USB_SPEED_LOW ? 539 MAX_TRANSFER_SIZE_LOWSPEED : 540 MAX_TRANSFER_SIZE_FULLSPEED); 541 542 /* ... and finally cut to the multiple of MaxPacketSize, 543 or to the real length if there's enough room. */ 544 if (len < 545 (urb->transfer_buffer_length - 546 urb->actual_length)) { 547 len -= len % ep->maxpacket; 548 if (!len) 549 continue; 550 } else 551 len = urb->transfer_buffer_length - 552 urb->actual_length; 553 BUG_ON(len < 0); 554 } 555 556 load += len * byte_time; 557 if (load > MAX_LOAD_LIMIT) 558 break; 559 560 ep->active = NULL; 561 ep->length = len; 562 if (last_ep) 563 last_ep->active = ep; 564 else 565 isp116x->atl_active = ep; 566 last_ep = ep; 567 } 568 569 /* Avoid starving of endpoints */ 570 if ((&isp116x->async)->next != (&isp116x->async)->prev) 571 list_move(&isp116x->async, (&isp116x->async)->next); 572 573 if (isp116x->atl_active) { 574 preproc_atl_queue(isp116x); 575 pack_fifo(isp116x); 576 } 577 } 578 579 /* 580 Finish the processed transfers 581 */ 582 static void finish_atl_transfers(struct isp116x *isp116x, struct pt_regs *regs) 583 { 584 struct isp116x_ep *ep; 585 struct urb *urb; 586 587 if (!isp116x->atl_active) 588 return; 589 /* Fifo not ready? */ 590 if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE)) 591 return; 592 593 atomic_inc(&isp116x->atl_finishing); 594 unpack_fifo(isp116x); 595 postproc_atl_queue(isp116x); 596 for (ep = isp116x->atl_active; ep; ep = ep->active) { 597 urb = 598 container_of(ep->hep->urb_list.next, struct urb, urb_list); 599 /* USB_PID_ACK check here avoids finishing of 600 control transfers, for which TD_DATAUNDERRUN 601 occured, while URB_SHORT_NOT_OK was set */ 602 if (urb && urb->status != -EINPROGRESS 603 && ep->nextpid != USB_PID_ACK) 604 finish_request(isp116x, ep, urb, regs); 605 } 606 atomic_dec(&isp116x->atl_finishing); 607 } 608 609 static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs) 610 { 611 struct isp116x *isp116x = hcd_to_isp116x(hcd); 612 u16 irqstat; 613 irqreturn_t ret = IRQ_NONE; 614 615 spin_lock(&isp116x->lock); 616 isp116x_write_reg16(isp116x, HCuPINTENB, 0); 617 irqstat = isp116x_read_reg16(isp116x, HCuPINT); 618 isp116x_write_reg16(isp116x, HCuPINT, irqstat); 619 620 if (irqstat & (HCuPINT_ATL | HCuPINT_SOF)) { 621 ret = IRQ_HANDLED; 622 finish_atl_transfers(isp116x, regs); 623 } 624 625 if (irqstat & HCuPINT_OPR) { 626 u32 intstat = isp116x_read_reg32(isp116x, HCINTSTAT); 627 isp116x_write_reg32(isp116x, HCINTSTAT, intstat); 628 if (intstat & HCINT_UE) { 629 ERR("Unrecoverable error\n"); 630 /* What should we do here? Reset? */ 631 } 632 if (intstat & HCINT_RHSC) 633 /* When root hub or any of its ports is going 634 to come out of suspend, it may take more 635 than 10ms for status bits to stabilize. */ 636 mod_timer(&hcd->rh_timer, jiffies 637 + msecs_to_jiffies(20) + 1); 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 = kzalloc(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 unsigned long flags; 927 928 if (!HC_IS_RUNNING(hcd->state)) 929 return -ESHUTDOWN; 930 931 /* Report no status change now, if we are scheduled to be 932 called later */ 933 if (timer_pending(&hcd->rh_timer)) 934 return 0; 935 936 ports = isp116x->rhdesca & RH_A_NDP; 937 spin_lock_irqsave(&isp116x->lock, flags); 938 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS); 939 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC)) 940 buf[0] = changed = 1; 941 else 942 buf[0] = 0; 943 944 for (i = 0; i < ports; i++) { 945 u32 status = isp116x->rhport[i] = 946 isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1); 947 948 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC 949 | RH_PS_OCIC | RH_PS_PRSC)) { 950 changed = 1; 951 buf[0] |= 1 << (i + 1); 952 continue; 953 } 954 } 955 spin_unlock_irqrestore(&isp116x->lock, flags); 956 return changed; 957 } 958 959 static void isp116x_hub_descriptor(struct isp116x *isp116x, 960 struct usb_hub_descriptor *desc) 961 { 962 u32 reg = isp116x->rhdesca; 963 964 desc->bDescriptorType = 0x29; 965 desc->bDescLength = 9; 966 desc->bHubContrCurrent = 0; 967 desc->bNbrPorts = (u8) (reg & 0x3); 968 /* Power switching, device type, overcurrent. */ 969 desc->wHubCharacteristics = 970 (__force __u16) cpu_to_le16((u16) ((reg >> 8) & 0x1f)); 971 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff); 972 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */ 973 desc->bitmap[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1; 974 desc->bitmap[1] = ~0; 975 } 976 977 /* Perform reset of a given port. 978 It would be great to just start the reset and let the 979 USB core to clear the reset in due time. However, 980 root hub ports should be reset for at least 50 ms, while 981 our chip stays in reset for about 10 ms. I.e., we must 982 repeatedly reset it ourself here. 983 */ 984 static inline void root_port_reset(struct isp116x *isp116x, unsigned port) 985 { 986 u32 tmp; 987 unsigned long flags, t; 988 989 /* Root hub reset should be 50 ms, but some devices 990 want it even longer. */ 991 t = jiffies + msecs_to_jiffies(100); 992 993 while (time_before(jiffies, t)) { 994 spin_lock_irqsave(&isp116x->lock, flags); 995 /* spin until any current reset finishes */ 996 for (;;) { 997 tmp = isp116x_read_reg32(isp116x, port ? 998 HCRHPORT2 : HCRHPORT1); 999 if (!(tmp & RH_PS_PRS)) 1000 break; 1001 udelay(500); 1002 } 1003 /* Don't reset a disconnected port */ 1004 if (!(tmp & RH_PS_CCS)) { 1005 spin_unlock_irqrestore(&isp116x->lock, flags); 1006 break; 1007 } 1008 /* Reset lasts 10ms (claims datasheet) */ 1009 isp116x_write_reg32(isp116x, port ? HCRHPORT2 : 1010 HCRHPORT1, (RH_PS_PRS)); 1011 spin_unlock_irqrestore(&isp116x->lock, flags); 1012 msleep(10); 1013 } 1014 } 1015 1016 /* Adapted from ohci-hub.c */ 1017 static int isp116x_hub_control(struct usb_hcd *hcd, 1018 u16 typeReq, 1019 u16 wValue, u16 wIndex, char *buf, u16 wLength) 1020 { 1021 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1022 int ret = 0; 1023 unsigned long flags; 1024 int ports = isp116x->rhdesca & RH_A_NDP; 1025 u32 tmp = 0; 1026 1027 switch (typeReq) { 1028 case ClearHubFeature: 1029 DBG("ClearHubFeature: "); 1030 switch (wValue) { 1031 case C_HUB_OVER_CURRENT: 1032 DBG("C_HUB_OVER_CURRENT\n"); 1033 spin_lock_irqsave(&isp116x->lock, flags); 1034 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC); 1035 spin_unlock_irqrestore(&isp116x->lock, flags); 1036 case C_HUB_LOCAL_POWER: 1037 DBG("C_HUB_LOCAL_POWER\n"); 1038 break; 1039 default: 1040 goto error; 1041 } 1042 break; 1043 case SetHubFeature: 1044 DBG("SetHubFeature: "); 1045 switch (wValue) { 1046 case C_HUB_OVER_CURRENT: 1047 case C_HUB_LOCAL_POWER: 1048 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n"); 1049 break; 1050 default: 1051 goto error; 1052 } 1053 break; 1054 case GetHubDescriptor: 1055 DBG("GetHubDescriptor\n"); 1056 isp116x_hub_descriptor(isp116x, 1057 (struct usb_hub_descriptor *)buf); 1058 break; 1059 case GetHubStatus: 1060 DBG("GetHubStatus\n"); 1061 *(__le32 *) buf = 0; 1062 break; 1063 case GetPortStatus: 1064 DBG("GetPortStatus\n"); 1065 if (!wIndex || wIndex > ports) 1066 goto error; 1067 tmp = isp116x->rhport[--wIndex]; 1068 *(__le32 *) buf = cpu_to_le32(tmp); 1069 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp); 1070 break; 1071 case ClearPortFeature: 1072 DBG("ClearPortFeature: "); 1073 if (!wIndex || wIndex > ports) 1074 goto error; 1075 wIndex--; 1076 1077 switch (wValue) { 1078 case USB_PORT_FEAT_ENABLE: 1079 DBG("USB_PORT_FEAT_ENABLE\n"); 1080 tmp = RH_PS_CCS; 1081 break; 1082 case USB_PORT_FEAT_C_ENABLE: 1083 DBG("USB_PORT_FEAT_C_ENABLE\n"); 1084 tmp = RH_PS_PESC; 1085 break; 1086 case USB_PORT_FEAT_SUSPEND: 1087 DBG("USB_PORT_FEAT_SUSPEND\n"); 1088 tmp = RH_PS_POCI; 1089 break; 1090 case USB_PORT_FEAT_C_SUSPEND: 1091 DBG("USB_PORT_FEAT_C_SUSPEND\n"); 1092 tmp = RH_PS_PSSC; 1093 break; 1094 case USB_PORT_FEAT_POWER: 1095 DBG("USB_PORT_FEAT_POWER\n"); 1096 tmp = RH_PS_LSDA; 1097 break; 1098 case USB_PORT_FEAT_C_CONNECTION: 1099 DBG("USB_PORT_FEAT_C_CONNECTION\n"); 1100 tmp = RH_PS_CSC; 1101 break; 1102 case USB_PORT_FEAT_C_OVER_CURRENT: 1103 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n"); 1104 tmp = RH_PS_OCIC; 1105 break; 1106 case USB_PORT_FEAT_C_RESET: 1107 DBG("USB_PORT_FEAT_C_RESET\n"); 1108 tmp = RH_PS_PRSC; 1109 break; 1110 default: 1111 goto error; 1112 } 1113 spin_lock_irqsave(&isp116x->lock, flags); 1114 isp116x_write_reg32(isp116x, wIndex 1115 ? HCRHPORT2 : HCRHPORT1, tmp); 1116 isp116x->rhport[wIndex] = 1117 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1); 1118 spin_unlock_irqrestore(&isp116x->lock, flags); 1119 break; 1120 case SetPortFeature: 1121 DBG("SetPortFeature: "); 1122 if (!wIndex || wIndex > ports) 1123 goto error; 1124 wIndex--; 1125 switch (wValue) { 1126 case USB_PORT_FEAT_SUSPEND: 1127 DBG("USB_PORT_FEAT_SUSPEND\n"); 1128 spin_lock_irqsave(&isp116x->lock, flags); 1129 isp116x_write_reg32(isp116x, wIndex 1130 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS); 1131 break; 1132 case USB_PORT_FEAT_POWER: 1133 DBG("USB_PORT_FEAT_POWER\n"); 1134 spin_lock_irqsave(&isp116x->lock, flags); 1135 isp116x_write_reg32(isp116x, wIndex 1136 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS); 1137 break; 1138 case USB_PORT_FEAT_RESET: 1139 DBG("USB_PORT_FEAT_RESET\n"); 1140 root_port_reset(isp116x, wIndex); 1141 spin_lock_irqsave(&isp116x->lock, flags); 1142 break; 1143 default: 1144 goto error; 1145 } 1146 isp116x->rhport[wIndex] = 1147 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1); 1148 spin_unlock_irqrestore(&isp116x->lock, flags); 1149 break; 1150 1151 default: 1152 error: 1153 /* "protocol stall" on error */ 1154 DBG("PROTOCOL STALL\n"); 1155 ret = -EPIPE; 1156 } 1157 return ret; 1158 } 1159 1160 #ifdef CONFIG_PM 1161 1162 static int isp116x_hub_suspend(struct usb_hcd *hcd) 1163 { 1164 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1165 unsigned long flags; 1166 u32 val; 1167 int ret = 0; 1168 1169 spin_lock_irqsave(&isp116x->lock, flags); 1170 1171 val = isp116x_read_reg32(isp116x, HCCONTROL); 1172 switch (val & HCCONTROL_HCFS) { 1173 case HCCONTROL_USB_OPER: 1174 hcd->state = HC_STATE_QUIESCING; 1175 val &= (~HCCONTROL_HCFS & ~HCCONTROL_RWE); 1176 val |= HCCONTROL_USB_SUSPEND; 1177 if (hcd->remote_wakeup) 1178 val |= HCCONTROL_RWE; 1179 /* Wait for usb transfers to finish */ 1180 mdelay(2); 1181 isp116x_write_reg32(isp116x, HCCONTROL, val); 1182 hcd->state = HC_STATE_SUSPENDED; 1183 /* Wait for devices to suspend */ 1184 mdelay(5); 1185 case HCCONTROL_USB_SUSPEND: 1186 break; 1187 case HCCONTROL_USB_RESUME: 1188 isp116x_write_reg32(isp116x, HCCONTROL, 1189 (val & ~HCCONTROL_HCFS) | 1190 HCCONTROL_USB_RESET); 1191 case HCCONTROL_USB_RESET: 1192 ret = -EBUSY; 1193 break; 1194 default: 1195 ret = -EINVAL; 1196 } 1197 1198 spin_unlock_irqrestore(&isp116x->lock, flags); 1199 return ret; 1200 } 1201 1202 static int isp116x_hub_resume(struct usb_hcd *hcd) 1203 { 1204 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1205 u32 val; 1206 int ret = -EINPROGRESS; 1207 1208 msleep(5); 1209 spin_lock_irq(&isp116x->lock); 1210 1211 val = isp116x_read_reg32(isp116x, HCCONTROL); 1212 switch (val & HCCONTROL_HCFS) { 1213 case HCCONTROL_USB_SUSPEND: 1214 val &= ~HCCONTROL_HCFS; 1215 val |= HCCONTROL_USB_RESUME; 1216 isp116x_write_reg32(isp116x, HCCONTROL, val); 1217 case HCCONTROL_USB_RESUME: 1218 break; 1219 case HCCONTROL_USB_OPER: 1220 /* Without setting power_state here the 1221 SUSPENDED state won't be removed from 1222 sysfs/usbN/power.state as a response to remote 1223 wakeup. Maybe in the future. */ 1224 hcd->self.root_hub->dev.power.power_state = PMSG_ON; 1225 ret = 0; 1226 break; 1227 default: 1228 ret = -EBUSY; 1229 } 1230 1231 if (ret != -EINPROGRESS) { 1232 spin_unlock_irq(&isp116x->lock); 1233 return ret; 1234 } 1235 1236 val = isp116x->rhdesca & RH_A_NDP; 1237 while (val--) { 1238 u32 stat = 1239 isp116x_read_reg32(isp116x, val ? HCRHPORT2 : HCRHPORT1); 1240 /* force global, not selective, resume */ 1241 if (!(stat & RH_PS_PSS)) 1242 continue; 1243 DBG("%s: Resuming port %d\n", __func__, val); 1244 isp116x_write_reg32(isp116x, RH_PS_POCI, val 1245 ? HCRHPORT2 : HCRHPORT1); 1246 } 1247 spin_unlock_irq(&isp116x->lock); 1248 1249 hcd->state = HC_STATE_RESUMING; 1250 mdelay(20); 1251 1252 /* Go operational */ 1253 spin_lock_irq(&isp116x->lock); 1254 val = isp116x_read_reg32(isp116x, HCCONTROL); 1255 isp116x_write_reg32(isp116x, HCCONTROL, 1256 (val & ~HCCONTROL_HCFS) | HCCONTROL_USB_OPER); 1257 spin_unlock_irq(&isp116x->lock); 1258 /* see analogous comment above */ 1259 hcd->self.root_hub->dev.power.power_state = PMSG_ON; 1260 hcd->state = HC_STATE_RUNNING; 1261 1262 return 0; 1263 } 1264 1265 static void isp116x_rh_resume(void *_hcd) 1266 { 1267 struct usb_hcd *hcd = _hcd; 1268 1269 usb_resume_device(hcd->self.root_hub); 1270 } 1271 1272 #else 1273 1274 #define isp116x_hub_suspend NULL 1275 #define isp116x_hub_resume NULL 1276 1277 static void isp116x_rh_resume(void *_hcd) 1278 { 1279 } 1280 1281 #endif 1282 1283 /*-----------------------------------------------------------------*/ 1284 1285 #ifdef STUB_DEBUG_FILE 1286 1287 static inline void create_debug_file(struct isp116x *isp116x) 1288 { 1289 } 1290 1291 static inline void remove_debug_file(struct isp116x *isp116x) 1292 { 1293 } 1294 1295 #else 1296 1297 #include <linux/proc_fs.h> 1298 #include <linux/seq_file.h> 1299 1300 static void dump_irq(struct seq_file *s, char *label, u16 mask) 1301 { 1302 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask, 1303 mask & HCuPINT_CLKRDY ? " clkrdy" : "", 1304 mask & HCuPINT_SUSP ? " susp" : "", 1305 mask & HCuPINT_OPR ? " opr" : "", 1306 mask & HCuPINT_AIIEOT ? " eot" : "", 1307 mask & HCuPINT_ATL ? " atl" : "", 1308 mask & HCuPINT_SOF ? " sof" : ""); 1309 } 1310 1311 static void dump_int(struct seq_file *s, char *label, u32 mask) 1312 { 1313 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask, 1314 mask & HCINT_MIE ? " MIE" : "", 1315 mask & HCINT_RHSC ? " rhsc" : "", 1316 mask & HCINT_FNO ? " fno" : "", 1317 mask & HCINT_UE ? " ue" : "", 1318 mask & HCINT_RD ? " rd" : "", 1319 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : ""); 1320 } 1321 1322 static int proc_isp116x_show(struct seq_file *s, void *unused) 1323 { 1324 struct isp116x *isp116x = s->private; 1325 struct isp116x_ep *ep; 1326 struct urb *urb; 1327 unsigned i; 1328 char *str; 1329 1330 seq_printf(s, "%s\n%s version %s\n", 1331 isp116x_to_hcd(isp116x)->product_desc, hcd_name, 1332 DRIVER_VERSION); 1333 1334 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) { 1335 seq_printf(s, "HCD is suspended\n"); 1336 return 0; 1337 } 1338 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) { 1339 seq_printf(s, "HCD not running\n"); 1340 return 0; 1341 } 1342 1343 spin_lock_irq(&isp116x->lock); 1344 1345 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB)); 1346 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT)); 1347 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB)); 1348 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT)); 1349 1350 list_for_each_entry(ep, &isp116x->async, schedule) { 1351 1352 switch (ep->nextpid) { 1353 case USB_PID_IN: 1354 str = "in"; 1355 break; 1356 case USB_PID_OUT: 1357 str = "out"; 1358 break; 1359 case USB_PID_SETUP: 1360 str = "setup"; 1361 break; 1362 case USB_PID_ACK: 1363 str = "status"; 1364 break; 1365 default: 1366 str = "?"; 1367 break; 1368 }; 1369 seq_printf(s, "%p, ep%d%s, maxpacket %d:\n", ep, 1370 ep->epnum, str, ep->maxpacket); 1371 list_for_each_entry(urb, &ep->hep->urb_list, urb_list) { 1372 seq_printf(s, " urb%p, %d/%d\n", urb, 1373 urb->actual_length, 1374 urb->transfer_buffer_length); 1375 } 1376 } 1377 if (!list_empty(&isp116x->async)) 1378 seq_printf(s, "\n"); 1379 1380 seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE); 1381 1382 for (i = 0; i < PERIODIC_SIZE; i++) { 1383 ep = isp116x->periodic[i]; 1384 if (!ep) 1385 continue; 1386 seq_printf(s, "%2d [%3d]:\n", i, isp116x->load[i]); 1387 1388 /* DUMB: prints shared entries multiple times */ 1389 do { 1390 seq_printf(s, " %d/%p (%sdev%d ep%d%s max %d)\n", 1391 ep->period, ep, 1392 (ep->udev->speed == 1393 USB_SPEED_FULL) ? "" : "ls ", 1394 ep->udev->devnum, ep->epnum, 1395 (ep->epnum == 1396 0) ? "" : ((ep->nextpid == 1397 USB_PID_IN) ? "in" : "out"), 1398 ep->maxpacket); 1399 ep = ep->next; 1400 } while (ep); 1401 } 1402 spin_unlock_irq(&isp116x->lock); 1403 seq_printf(s, "\n"); 1404 1405 return 0; 1406 } 1407 1408 static int proc_isp116x_open(struct inode *inode, struct file *file) 1409 { 1410 return single_open(file, proc_isp116x_show, PDE(inode)->data); 1411 } 1412 1413 static struct file_operations proc_ops = { 1414 .open = proc_isp116x_open, 1415 .read = seq_read, 1416 .llseek = seq_lseek, 1417 .release = single_release, 1418 }; 1419 1420 /* expect just one isp116x per system */ 1421 static const char proc_filename[] = "driver/isp116x"; 1422 1423 static void create_debug_file(struct isp116x *isp116x) 1424 { 1425 struct proc_dir_entry *pde; 1426 1427 pde = create_proc_entry(proc_filename, 0, NULL); 1428 if (pde == NULL) 1429 return; 1430 1431 pde->proc_fops = &proc_ops; 1432 pde->data = isp116x; 1433 isp116x->pde = pde; 1434 } 1435 1436 static void remove_debug_file(struct isp116x *isp116x) 1437 { 1438 if (isp116x->pde) 1439 remove_proc_entry(proc_filename, NULL); 1440 } 1441 1442 #endif 1443 1444 /*-----------------------------------------------------------------*/ 1445 1446 /* 1447 Software reset - can be called from any contect. 1448 */ 1449 static int isp116x_sw_reset(struct isp116x *isp116x) 1450 { 1451 int retries = 15; 1452 unsigned long flags; 1453 int ret = 0; 1454 1455 spin_lock_irqsave(&isp116x->lock, flags); 1456 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC); 1457 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR); 1458 while (--retries) { 1459 /* It usually resets within 1 ms */ 1460 mdelay(1); 1461 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR)) 1462 break; 1463 } 1464 if (!retries) { 1465 ERR("Software reset timeout\n"); 1466 ret = -ETIME; 1467 } 1468 spin_unlock_irqrestore(&isp116x->lock, flags); 1469 return ret; 1470 } 1471 1472 static int isp116x_reset(struct usb_hcd *hcd) 1473 { 1474 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1475 unsigned long t; 1476 u16 clkrdy = 0; 1477 int ret = 0, timeout = 15 /* ms */ ; 1478 1479 ret = isp116x_sw_reset(isp116x); 1480 if (ret) 1481 return ret; 1482 1483 t = jiffies + msecs_to_jiffies(timeout); 1484 while (time_before_eq(jiffies, t)) { 1485 msleep(4); 1486 spin_lock_irq(&isp116x->lock); 1487 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY; 1488 spin_unlock_irq(&isp116x->lock); 1489 if (clkrdy) 1490 break; 1491 } 1492 if (!clkrdy) { 1493 ERR("Clock not ready after 20ms\n"); 1494 /* After sw_reset the clock won't report to be ready, if 1495 H_WAKEUP pin is high. */ 1496 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n"); 1497 ret = -ENODEV; 1498 } 1499 return ret; 1500 } 1501 1502 static void isp116x_stop(struct usb_hcd *hcd) 1503 { 1504 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1505 unsigned long flags; 1506 u32 val; 1507 1508 spin_lock_irqsave(&isp116x->lock, flags); 1509 isp116x_write_reg16(isp116x, HCuPINTENB, 0); 1510 1511 /* Switch off ports' power, some devices don't come up 1512 after next 'insmod' without this */ 1513 val = isp116x_read_reg32(isp116x, HCRHDESCA); 1514 val &= ~(RH_A_NPS | RH_A_PSM); 1515 isp116x_write_reg32(isp116x, HCRHDESCA, val); 1516 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS); 1517 spin_unlock_irqrestore(&isp116x->lock, flags); 1518 1519 isp116x_sw_reset(isp116x); 1520 } 1521 1522 /* 1523 Configure the chip. The chip must be successfully reset by now. 1524 */ 1525 static int isp116x_start(struct usb_hcd *hcd) 1526 { 1527 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1528 struct isp116x_platform_data *board = isp116x->board; 1529 u32 val; 1530 unsigned long flags; 1531 1532 spin_lock_irqsave(&isp116x->lock, flags); 1533 1534 /* clear interrupt status and disable all interrupt sources */ 1535 isp116x_write_reg16(isp116x, HCuPINT, 0xff); 1536 isp116x_write_reg16(isp116x, HCuPINTENB, 0); 1537 1538 val = isp116x_read_reg16(isp116x, HCCHIPID); 1539 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) { 1540 ERR("Invalid chip ID %04x\n", val); 1541 spin_unlock_irqrestore(&isp116x->lock, flags); 1542 return -ENODEV; 1543 } 1544 1545 /* To be removed in future */ 1546 hcd->uses_new_polling = 1; 1547 1548 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE); 1549 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE); 1550 1551 /* ----- HW conf */ 1552 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1); 1553 if (board->sel15Kres) 1554 val |= HCHWCFG_15KRSEL; 1555 /* Remote wakeup won't work without working clock */ 1556 if (board->remote_wakeup_enable) 1557 val |= HCHWCFG_CLKNOTSTOP; 1558 if (board->oc_enable) 1559 val |= HCHWCFG_ANALOG_OC; 1560 if (board->int_act_high) 1561 val |= HCHWCFG_INT_POL; 1562 if (board->int_edge_triggered) 1563 val |= HCHWCFG_INT_TRIGGER; 1564 isp116x_write_reg16(isp116x, HCHWCFG, val); 1565 1566 /* ----- Root hub conf */ 1567 val = (25 << 24) & RH_A_POTPGT; 1568 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to 1569 be always set. Yet, instead, we request individual port 1570 power switching. */ 1571 val |= RH_A_PSM; 1572 /* Report overcurrent per port */ 1573 val |= RH_A_OCPM; 1574 isp116x_write_reg32(isp116x, HCRHDESCA, val); 1575 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA); 1576 1577 val = RH_B_PPCM; 1578 isp116x_write_reg32(isp116x, HCRHDESCB, val); 1579 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB); 1580 1581 val = 0; 1582 if (board->remote_wakeup_enable) { 1583 hcd->can_wakeup = 1; 1584 val |= RH_HS_DRWE; 1585 } 1586 isp116x_write_reg32(isp116x, HCRHSTATUS, val); 1587 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS); 1588 1589 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf); 1590 1591 hcd->state = HC_STATE_RUNNING; 1592 1593 /* Set up interrupts */ 1594 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE; 1595 if (board->remote_wakeup_enable) 1596 isp116x->intenb |= HCINT_RD; 1597 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */ 1598 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb); 1599 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb); 1600 1601 /* Go operational */ 1602 val = HCCONTROL_USB_OPER; 1603 if (board->remote_wakeup_enable) 1604 val |= HCCONTROL_RWE; 1605 isp116x_write_reg32(isp116x, HCCONTROL, val); 1606 1607 /* Disable ports to avoid race in device enumeration */ 1608 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS); 1609 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS); 1610 1611 isp116x_show_regs(isp116x); 1612 spin_unlock_irqrestore(&isp116x->lock, flags); 1613 return 0; 1614 } 1615 1616 /*-----------------------------------------------------------------*/ 1617 1618 static struct hc_driver isp116x_hc_driver = { 1619 .description = hcd_name, 1620 .product_desc = "ISP116x Host Controller", 1621 .hcd_priv_size = sizeof(struct isp116x), 1622 1623 .irq = isp116x_irq, 1624 .flags = HCD_USB11, 1625 1626 .reset = isp116x_reset, 1627 .start = isp116x_start, 1628 .stop = isp116x_stop, 1629 1630 .urb_enqueue = isp116x_urb_enqueue, 1631 .urb_dequeue = isp116x_urb_dequeue, 1632 .endpoint_disable = isp116x_endpoint_disable, 1633 1634 .get_frame_number = isp116x_get_frame, 1635 1636 .hub_status_data = isp116x_hub_status_data, 1637 .hub_control = isp116x_hub_control, 1638 .hub_suspend = isp116x_hub_suspend, 1639 .hub_resume = isp116x_hub_resume, 1640 }; 1641 1642 /*----------------------------------------------------------------*/ 1643 1644 static int __init_or_module isp116x_remove(struct device *dev) 1645 { 1646 struct usb_hcd *hcd = dev_get_drvdata(dev); 1647 struct isp116x *isp116x; 1648 struct platform_device *pdev; 1649 struct resource *res; 1650 1651 if (!hcd) 1652 return 0; 1653 isp116x = hcd_to_isp116x(hcd); 1654 pdev = container_of(dev, struct platform_device, dev); 1655 remove_debug_file(isp116x); 1656 usb_remove_hcd(hcd); 1657 1658 iounmap(isp116x->data_reg); 1659 res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 1660 release_mem_region(res->start, 2); 1661 iounmap(isp116x->addr_reg); 1662 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1663 release_mem_region(res->start, 2); 1664 1665 usb_put_hcd(hcd); 1666 return 0; 1667 } 1668 1669 #define resource_len(r) (((r)->end - (r)->start) + 1) 1670 1671 static int __init isp116x_probe(struct device *dev) 1672 { 1673 struct usb_hcd *hcd; 1674 struct isp116x *isp116x; 1675 struct platform_device *pdev; 1676 struct resource *addr, *data; 1677 void __iomem *addr_reg; 1678 void __iomem *data_reg; 1679 int irq; 1680 int ret = 0; 1681 1682 pdev = container_of(dev, struct platform_device, dev); 1683 if (pdev->num_resources < 3) { 1684 ret = -ENODEV; 1685 goto err1; 1686 } 1687 1688 data = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1689 addr = platform_get_resource(pdev, IORESOURCE_MEM, 1); 1690 irq = platform_get_irq(pdev, 0); 1691 if (!addr || !data || irq < 0) { 1692 ret = -ENODEV; 1693 goto err1; 1694 } 1695 1696 if (dev->dma_mask) { 1697 DBG("DMA not supported\n"); 1698 ret = -EINVAL; 1699 goto err1; 1700 } 1701 1702 if (!request_mem_region(addr->start, 2, hcd_name)) { 1703 ret = -EBUSY; 1704 goto err1; 1705 } 1706 addr_reg = ioremap(addr->start, resource_len(addr)); 1707 if (addr_reg == NULL) { 1708 ret = -ENOMEM; 1709 goto err2; 1710 } 1711 if (!request_mem_region(data->start, 2, hcd_name)) { 1712 ret = -EBUSY; 1713 goto err3; 1714 } 1715 data_reg = ioremap(data->start, resource_len(data)); 1716 if (data_reg == NULL) { 1717 ret = -ENOMEM; 1718 goto err4; 1719 } 1720 1721 /* allocate and initialize hcd */ 1722 hcd = usb_create_hcd(&isp116x_hc_driver, dev, dev->bus_id); 1723 if (!hcd) { 1724 ret = -ENOMEM; 1725 goto err5; 1726 } 1727 /* this rsrc_start is bogus */ 1728 hcd->rsrc_start = addr->start; 1729 isp116x = hcd_to_isp116x(hcd); 1730 isp116x->data_reg = data_reg; 1731 isp116x->addr_reg = addr_reg; 1732 spin_lock_init(&isp116x->lock); 1733 INIT_LIST_HEAD(&isp116x->async); 1734 INIT_WORK(&isp116x->rh_resume, isp116x_rh_resume, hcd); 1735 isp116x->board = dev->platform_data; 1736 1737 if (!isp116x->board) { 1738 ERR("Platform data structure not initialized\n"); 1739 ret = -ENODEV; 1740 goto err6; 1741 } 1742 if (isp116x_check_platform_delay(isp116x)) { 1743 ERR("USE_PLATFORM_DELAY defined, but delay function not " 1744 "implemented.\n"); 1745 ERR("See comments in drivers/usb/host/isp116x-hcd.c\n"); 1746 ret = -ENODEV; 1747 goto err6; 1748 } 1749 1750 ret = usb_add_hcd(hcd, irq, SA_INTERRUPT); 1751 if (ret != 0) 1752 goto err6; 1753 1754 create_debug_file(isp116x); 1755 return 0; 1756 1757 err6: 1758 usb_put_hcd(hcd); 1759 err5: 1760 iounmap(data_reg); 1761 err4: 1762 release_mem_region(data->start, 2); 1763 err3: 1764 iounmap(addr_reg); 1765 err2: 1766 release_mem_region(addr->start, 2); 1767 err1: 1768 ERR("init error, %d\n", ret); 1769 return ret; 1770 } 1771 1772 #ifdef CONFIG_PM 1773 /* 1774 Suspend of platform device 1775 */ 1776 static int isp116x_suspend(struct device *dev, pm_message_t state, u32 phase) 1777 { 1778 int ret = 0; 1779 struct usb_hcd *hcd = dev_get_drvdata(dev); 1780 1781 VDBG("%s: state %x, phase %x\n", __func__, state, phase); 1782 1783 if (phase != SUSPEND_DISABLE && phase != SUSPEND_POWER_DOWN) 1784 return 0; 1785 1786 ret = usb_suspend_device(hcd->self.root_hub, state); 1787 if (!ret) { 1788 dev->power.power_state = state; 1789 INFO("%s suspended\n", hcd_name); 1790 } else 1791 ERR("%s suspend failed\n", hcd_name); 1792 1793 return ret; 1794 } 1795 1796 /* 1797 Resume platform device 1798 */ 1799 static int isp116x_resume(struct device *dev, u32 phase) 1800 { 1801 int ret = 0; 1802 struct usb_hcd *hcd = dev_get_drvdata(dev); 1803 1804 VDBG("%s: state %x, phase %x\n", __func__, dev->power.power_state, 1805 phase); 1806 if (phase != RESUME_POWER_ON) 1807 return 0; 1808 1809 ret = usb_resume_device(hcd->self.root_hub); 1810 if (!ret) { 1811 dev->power.power_state = PMSG_ON; 1812 VDBG("%s resumed\n", (char *)hcd_name); 1813 } 1814 return ret; 1815 } 1816 1817 #else 1818 1819 #define isp116x_suspend NULL 1820 #define isp116x_resume NULL 1821 1822 #endif 1823 1824 static struct device_driver isp116x_driver = { 1825 .name = (char *)hcd_name, 1826 .bus = &platform_bus_type, 1827 .probe = isp116x_probe, 1828 .remove = isp116x_remove, 1829 .suspend = isp116x_suspend, 1830 .resume = isp116x_resume, 1831 }; 1832 1833 /*-----------------------------------------------------------------*/ 1834 1835 static int __init isp116x_init(void) 1836 { 1837 if (usb_disabled()) 1838 return -ENODEV; 1839 1840 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION); 1841 return driver_register(&isp116x_driver); 1842 } 1843 1844 module_init(isp116x_init); 1845 1846 static void __exit isp116x_cleanup(void) 1847 { 1848 driver_unregister(&isp116x_driver); 1849 } 1850 1851 module_exit(isp116x_cleanup); 1852