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