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