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 = 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 ep->branch = ret = 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 kfree(ep); 895 hep->hcpriv = NULL; 896 } 897 898 static int isp116x_get_frame(struct usb_hcd *hcd) 899 { 900 struct isp116x *isp116x = hcd_to_isp116x(hcd); 901 u32 fmnum; 902 unsigned long flags; 903 904 spin_lock_irqsave(&isp116x->lock, flags); 905 fmnum = isp116x_read_reg32(isp116x, HCFMNUM); 906 spin_unlock_irqrestore(&isp116x->lock, flags); 907 return (int)fmnum; 908 } 909 910 /* 911 Adapted from ohci-hub.c. Currently we don't support autosuspend. 912 */ 913 static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf) 914 { 915 struct isp116x *isp116x = hcd_to_isp116x(hcd); 916 int ports, i, changed = 0; 917 unsigned long flags; 918 919 if (!HC_IS_RUNNING(hcd->state)) 920 return -ESHUTDOWN; 921 922 /* Report no status change now, if we are scheduled to be 923 called later */ 924 if (timer_pending(&hcd->rh_timer)) 925 return 0; 926 927 ports = isp116x->rhdesca & RH_A_NDP; 928 spin_lock_irqsave(&isp116x->lock, flags); 929 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS); 930 if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC)) 931 buf[0] = changed = 1; 932 else 933 buf[0] = 0; 934 935 for (i = 0; i < ports; i++) { 936 u32 status = isp116x->rhport[i] = 937 isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1); 938 939 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC 940 | RH_PS_OCIC | RH_PS_PRSC)) { 941 changed = 1; 942 buf[0] |= 1 << (i + 1); 943 continue; 944 } 945 } 946 spin_unlock_irqrestore(&isp116x->lock, flags); 947 return changed; 948 } 949 950 static void isp116x_hub_descriptor(struct isp116x *isp116x, 951 struct usb_hub_descriptor *desc) 952 { 953 u32 reg = isp116x->rhdesca; 954 955 desc->bDescriptorType = 0x29; 956 desc->bDescLength = 9; 957 desc->bHubContrCurrent = 0; 958 desc->bNbrPorts = (u8) (reg & 0x3); 959 /* Power switching, device type, overcurrent. */ 960 desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f)); 961 desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff); 962 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */ 963 desc->bitmap[0] = 0; 964 desc->bitmap[1] = ~0; 965 } 966 967 /* Perform reset of a given port. 968 It would be great to just start the reset and let the 969 USB core to clear the reset in due time. However, 970 root hub ports should be reset for at least 50 ms, while 971 our chip stays in reset for about 10 ms. I.e., we must 972 repeatedly reset it ourself here. 973 */ 974 static inline void root_port_reset(struct isp116x *isp116x, unsigned port) 975 { 976 u32 tmp; 977 unsigned long flags, t; 978 979 /* Root hub reset should be 50 ms, but some devices 980 want it even longer. */ 981 t = jiffies + msecs_to_jiffies(100); 982 983 while (time_before(jiffies, t)) { 984 spin_lock_irqsave(&isp116x->lock, flags); 985 /* spin until any current reset finishes */ 986 for (;;) { 987 tmp = isp116x_read_reg32(isp116x, port ? 988 HCRHPORT2 : HCRHPORT1); 989 if (!(tmp & RH_PS_PRS)) 990 break; 991 udelay(500); 992 } 993 /* Don't reset a disconnected port */ 994 if (!(tmp & RH_PS_CCS)) { 995 spin_unlock_irqrestore(&isp116x->lock, flags); 996 break; 997 } 998 /* Reset lasts 10ms (claims datasheet) */ 999 isp116x_write_reg32(isp116x, port ? HCRHPORT2 : 1000 HCRHPORT1, (RH_PS_PRS)); 1001 spin_unlock_irqrestore(&isp116x->lock, flags); 1002 msleep(10); 1003 } 1004 } 1005 1006 /* Adapted from ohci-hub.c */ 1007 static int isp116x_hub_control(struct usb_hcd *hcd, 1008 u16 typeReq, 1009 u16 wValue, u16 wIndex, char *buf, u16 wLength) 1010 { 1011 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1012 int ret = 0; 1013 unsigned long flags; 1014 int ports = isp116x->rhdesca & RH_A_NDP; 1015 u32 tmp = 0; 1016 1017 switch (typeReq) { 1018 case ClearHubFeature: 1019 DBG("ClearHubFeature: "); 1020 switch (wValue) { 1021 case C_HUB_OVER_CURRENT: 1022 DBG("C_HUB_OVER_CURRENT\n"); 1023 spin_lock_irqsave(&isp116x->lock, flags); 1024 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC); 1025 spin_unlock_irqrestore(&isp116x->lock, flags); 1026 case C_HUB_LOCAL_POWER: 1027 DBG("C_HUB_LOCAL_POWER\n"); 1028 break; 1029 default: 1030 goto error; 1031 } 1032 break; 1033 case SetHubFeature: 1034 DBG("SetHubFeature: "); 1035 switch (wValue) { 1036 case C_HUB_OVER_CURRENT: 1037 case C_HUB_LOCAL_POWER: 1038 DBG("C_HUB_OVER_CURRENT or C_HUB_LOCAL_POWER\n"); 1039 break; 1040 default: 1041 goto error; 1042 } 1043 break; 1044 case GetHubDescriptor: 1045 DBG("GetHubDescriptor\n"); 1046 isp116x_hub_descriptor(isp116x, 1047 (struct usb_hub_descriptor *)buf); 1048 break; 1049 case GetHubStatus: 1050 DBG("GetHubStatus\n"); 1051 *(__le32 *) buf = 0; 1052 break; 1053 case GetPortStatus: 1054 DBG("GetPortStatus\n"); 1055 if (!wIndex || wIndex > ports) 1056 goto error; 1057 tmp = isp116x->rhport[--wIndex]; 1058 *(__le32 *) buf = cpu_to_le32(tmp); 1059 DBG("GetPortStatus: port[%d] %08x\n", wIndex + 1, tmp); 1060 break; 1061 case ClearPortFeature: 1062 DBG("ClearPortFeature: "); 1063 if (!wIndex || wIndex > ports) 1064 goto error; 1065 wIndex--; 1066 1067 switch (wValue) { 1068 case USB_PORT_FEAT_ENABLE: 1069 DBG("USB_PORT_FEAT_ENABLE\n"); 1070 tmp = RH_PS_CCS; 1071 break; 1072 case USB_PORT_FEAT_C_ENABLE: 1073 DBG("USB_PORT_FEAT_C_ENABLE\n"); 1074 tmp = RH_PS_PESC; 1075 break; 1076 case USB_PORT_FEAT_SUSPEND: 1077 DBG("USB_PORT_FEAT_SUSPEND\n"); 1078 tmp = RH_PS_POCI; 1079 break; 1080 case USB_PORT_FEAT_C_SUSPEND: 1081 DBG("USB_PORT_FEAT_C_SUSPEND\n"); 1082 tmp = RH_PS_PSSC; 1083 break; 1084 case USB_PORT_FEAT_POWER: 1085 DBG("USB_PORT_FEAT_POWER\n"); 1086 tmp = RH_PS_LSDA; 1087 break; 1088 case USB_PORT_FEAT_C_CONNECTION: 1089 DBG("USB_PORT_FEAT_C_CONNECTION\n"); 1090 tmp = RH_PS_CSC; 1091 break; 1092 case USB_PORT_FEAT_C_OVER_CURRENT: 1093 DBG("USB_PORT_FEAT_C_OVER_CURRENT\n"); 1094 tmp = RH_PS_OCIC; 1095 break; 1096 case USB_PORT_FEAT_C_RESET: 1097 DBG("USB_PORT_FEAT_C_RESET\n"); 1098 tmp = RH_PS_PRSC; 1099 break; 1100 default: 1101 goto error; 1102 } 1103 spin_lock_irqsave(&isp116x->lock, flags); 1104 isp116x_write_reg32(isp116x, wIndex 1105 ? HCRHPORT2 : HCRHPORT1, tmp); 1106 isp116x->rhport[wIndex] = 1107 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1); 1108 spin_unlock_irqrestore(&isp116x->lock, flags); 1109 break; 1110 case SetPortFeature: 1111 DBG("SetPortFeature: "); 1112 if (!wIndex || wIndex > ports) 1113 goto error; 1114 wIndex--; 1115 switch (wValue) { 1116 case USB_PORT_FEAT_SUSPEND: 1117 DBG("USB_PORT_FEAT_SUSPEND\n"); 1118 spin_lock_irqsave(&isp116x->lock, flags); 1119 isp116x_write_reg32(isp116x, wIndex 1120 ? HCRHPORT2 : HCRHPORT1, RH_PS_PSS); 1121 break; 1122 case USB_PORT_FEAT_POWER: 1123 DBG("USB_PORT_FEAT_POWER\n"); 1124 spin_lock_irqsave(&isp116x->lock, flags); 1125 isp116x_write_reg32(isp116x, wIndex 1126 ? HCRHPORT2 : HCRHPORT1, RH_PS_PPS); 1127 break; 1128 case USB_PORT_FEAT_RESET: 1129 DBG("USB_PORT_FEAT_RESET\n"); 1130 root_port_reset(isp116x, wIndex); 1131 spin_lock_irqsave(&isp116x->lock, flags); 1132 break; 1133 default: 1134 goto error; 1135 } 1136 isp116x->rhport[wIndex] = 1137 isp116x_read_reg32(isp116x, wIndex ? HCRHPORT2 : HCRHPORT1); 1138 spin_unlock_irqrestore(&isp116x->lock, flags); 1139 break; 1140 1141 default: 1142 error: 1143 /* "protocol stall" on error */ 1144 DBG("PROTOCOL STALL\n"); 1145 ret = -EPIPE; 1146 } 1147 return ret; 1148 } 1149 1150 /*-----------------------------------------------------------------*/ 1151 1152 #ifdef CONFIG_DEBUG_FS 1153 1154 static void dump_irq(struct seq_file *s, char *label, u16 mask) 1155 { 1156 seq_printf(s, "%s %04x%s%s%s%s%s%s\n", label, mask, 1157 mask & HCuPINT_CLKRDY ? " clkrdy" : "", 1158 mask & HCuPINT_SUSP ? " susp" : "", 1159 mask & HCuPINT_OPR ? " opr" : "", 1160 mask & HCuPINT_AIIEOT ? " eot" : "", 1161 mask & HCuPINT_ATL ? " atl" : "", 1162 mask & HCuPINT_SOF ? " sof" : ""); 1163 } 1164 1165 static void dump_int(struct seq_file *s, char *label, u32 mask) 1166 { 1167 seq_printf(s, "%s %08x%s%s%s%s%s%s%s\n", label, mask, 1168 mask & HCINT_MIE ? " MIE" : "", 1169 mask & HCINT_RHSC ? " rhsc" : "", 1170 mask & HCINT_FNO ? " fno" : "", 1171 mask & HCINT_UE ? " ue" : "", 1172 mask & HCINT_RD ? " rd" : "", 1173 mask & HCINT_SF ? " sof" : "", mask & HCINT_SO ? " so" : ""); 1174 } 1175 1176 static int isp116x_show_dbg(struct seq_file *s, void *unused) 1177 { 1178 struct isp116x *isp116x = s->private; 1179 1180 seq_printf(s, "%s\n%s version %s\n", 1181 isp116x_to_hcd(isp116x)->product_desc, hcd_name, 1182 DRIVER_VERSION); 1183 1184 if (HC_IS_SUSPENDED(isp116x_to_hcd(isp116x)->state)) { 1185 seq_printf(s, "HCD is suspended\n"); 1186 return 0; 1187 } 1188 if (!HC_IS_RUNNING(isp116x_to_hcd(isp116x)->state)) { 1189 seq_printf(s, "HCD not running\n"); 1190 return 0; 1191 } 1192 1193 spin_lock_irq(&isp116x->lock); 1194 dump_irq(s, "hc_irq_enable", isp116x_read_reg16(isp116x, HCuPINTENB)); 1195 dump_irq(s, "hc_irq_status", isp116x_read_reg16(isp116x, HCuPINT)); 1196 dump_int(s, "hc_int_enable", isp116x_read_reg32(isp116x, HCINTENB)); 1197 dump_int(s, "hc_int_status", isp116x_read_reg32(isp116x, HCINTSTAT)); 1198 isp116x_show_regs_seq(isp116x, s); 1199 spin_unlock_irq(&isp116x->lock); 1200 seq_printf(s, "\n"); 1201 1202 return 0; 1203 } 1204 1205 static int isp116x_open_seq(struct inode *inode, struct file *file) 1206 { 1207 return single_open(file, isp116x_show_dbg, inode->u.generic_ip); 1208 } 1209 1210 static struct file_operations isp116x_debug_fops = { 1211 .open = isp116x_open_seq, 1212 .read = seq_read, 1213 .llseek = seq_lseek, 1214 .release = single_release, 1215 }; 1216 1217 static int create_debug_file(struct isp116x *isp116x) 1218 { 1219 isp116x->dentry = debugfs_create_file(hcd_name, 1220 S_IRUGO, NULL, isp116x, 1221 &isp116x_debug_fops); 1222 if (!isp116x->dentry) 1223 return -ENOMEM; 1224 return 0; 1225 } 1226 1227 static void remove_debug_file(struct isp116x *isp116x) 1228 { 1229 debugfs_remove(isp116x->dentry); 1230 } 1231 1232 #else 1233 1234 #define create_debug_file(d) 0 1235 #define remove_debug_file(d) do{}while(0) 1236 1237 #endif /* CONFIG_DEBUG_FS */ 1238 1239 /*-----------------------------------------------------------------*/ 1240 1241 /* 1242 Software reset - can be called from any contect. 1243 */ 1244 static int isp116x_sw_reset(struct isp116x *isp116x) 1245 { 1246 int retries = 15; 1247 unsigned long flags; 1248 int ret = 0; 1249 1250 spin_lock_irqsave(&isp116x->lock, flags); 1251 isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC); 1252 isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR); 1253 while (--retries) { 1254 /* It usually resets within 1 ms */ 1255 mdelay(1); 1256 if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR)) 1257 break; 1258 } 1259 if (!retries) { 1260 ERR("Software reset timeout\n"); 1261 ret = -ETIME; 1262 } 1263 spin_unlock_irqrestore(&isp116x->lock, flags); 1264 return ret; 1265 } 1266 1267 static int isp116x_reset(struct usb_hcd *hcd) 1268 { 1269 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1270 unsigned long t; 1271 u16 clkrdy = 0; 1272 int ret, timeout = 15 /* ms */ ; 1273 1274 ret = isp116x_sw_reset(isp116x); 1275 if (ret) 1276 return ret; 1277 1278 t = jiffies + msecs_to_jiffies(timeout); 1279 while (time_before_eq(jiffies, t)) { 1280 msleep(4); 1281 spin_lock_irq(&isp116x->lock); 1282 clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY; 1283 spin_unlock_irq(&isp116x->lock); 1284 if (clkrdy) 1285 break; 1286 } 1287 if (!clkrdy) { 1288 ERR("Clock not ready after %dms\n", timeout); 1289 /* After sw_reset the clock won't report to be ready, if 1290 H_WAKEUP pin is high. */ 1291 ERR("Please make sure that the H_WAKEUP pin is pulled low!\n"); 1292 ret = -ENODEV; 1293 } 1294 return ret; 1295 } 1296 1297 static void isp116x_stop(struct usb_hcd *hcd) 1298 { 1299 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1300 unsigned long flags; 1301 u32 val; 1302 1303 spin_lock_irqsave(&isp116x->lock, flags); 1304 isp116x_write_reg16(isp116x, HCuPINTENB, 0); 1305 1306 /* Switch off ports' power, some devices don't come up 1307 after next 'insmod' without this */ 1308 val = isp116x_read_reg32(isp116x, HCRHDESCA); 1309 val &= ~(RH_A_NPS | RH_A_PSM); 1310 isp116x_write_reg32(isp116x, HCRHDESCA, val); 1311 isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS); 1312 spin_unlock_irqrestore(&isp116x->lock, flags); 1313 1314 isp116x_sw_reset(isp116x); 1315 } 1316 1317 /* 1318 Configure the chip. The chip must be successfully reset by now. 1319 */ 1320 static int isp116x_start(struct usb_hcd *hcd) 1321 { 1322 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1323 struct isp116x_platform_data *board = isp116x->board; 1324 u32 val; 1325 unsigned long flags; 1326 1327 spin_lock_irqsave(&isp116x->lock, flags); 1328 1329 /* clear interrupt status and disable all interrupt sources */ 1330 isp116x_write_reg16(isp116x, HCuPINT, 0xff); 1331 isp116x_write_reg16(isp116x, HCuPINTENB, 0); 1332 1333 val = isp116x_read_reg16(isp116x, HCCHIPID); 1334 if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) { 1335 ERR("Invalid chip ID %04x\n", val); 1336 spin_unlock_irqrestore(&isp116x->lock, flags); 1337 return -ENODEV; 1338 } 1339 1340 /* To be removed in future */ 1341 hcd->uses_new_polling = 1; 1342 1343 isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE); 1344 isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE); 1345 1346 /* ----- HW conf */ 1347 val = HCHWCFG_INT_ENABLE | HCHWCFG_DBWIDTH(1); 1348 if (board->sel15Kres) 1349 val |= HCHWCFG_15KRSEL; 1350 /* Remote wakeup won't work without working clock */ 1351 if (board->remote_wakeup_enable) 1352 val |= HCHWCFG_CLKNOTSTOP; 1353 if (board->oc_enable) 1354 val |= HCHWCFG_ANALOG_OC; 1355 if (board->int_act_high) 1356 val |= HCHWCFG_INT_POL; 1357 if (board->int_edge_triggered) 1358 val |= HCHWCFG_INT_TRIGGER; 1359 isp116x_write_reg16(isp116x, HCHWCFG, val); 1360 1361 /* ----- Root hub conf */ 1362 val = (25 << 24) & RH_A_POTPGT; 1363 /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to 1364 be always set. Yet, instead, we request individual port 1365 power switching. */ 1366 val |= RH_A_PSM; 1367 /* Report overcurrent per port */ 1368 val |= RH_A_OCPM; 1369 isp116x_write_reg32(isp116x, HCRHDESCA, val); 1370 isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA); 1371 1372 val = RH_B_PPCM; 1373 isp116x_write_reg32(isp116x, HCRHDESCB, val); 1374 isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB); 1375 1376 val = 0; 1377 if (board->remote_wakeup_enable) { 1378 if (!device_can_wakeup(hcd->self.controller)) 1379 device_init_wakeup(hcd->self.controller, 1); 1380 val |= RH_HS_DRWE; 1381 } 1382 isp116x_write_reg32(isp116x, HCRHSTATUS, val); 1383 isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS); 1384 1385 isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf); 1386 1387 hcd->state = HC_STATE_RUNNING; 1388 1389 /* Set up interrupts */ 1390 isp116x->intenb = HCINT_MIE | HCINT_RHSC | HCINT_UE; 1391 if (board->remote_wakeup_enable) 1392 isp116x->intenb |= HCINT_RD; 1393 isp116x->irqenb = HCuPINT_ATL | HCuPINT_OPR; /* | HCuPINT_SUSP; */ 1394 isp116x_write_reg32(isp116x, HCINTENB, isp116x->intenb); 1395 isp116x_write_reg16(isp116x, HCuPINTENB, isp116x->irqenb); 1396 1397 /* Go operational */ 1398 val = HCCONTROL_USB_OPER; 1399 if (board->remote_wakeup_enable) 1400 val |= HCCONTROL_RWE; 1401 isp116x_write_reg32(isp116x, HCCONTROL, val); 1402 1403 /* Disable ports to avoid race in device enumeration */ 1404 isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS); 1405 isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS); 1406 1407 isp116x_show_regs_log(isp116x); 1408 spin_unlock_irqrestore(&isp116x->lock, flags); 1409 return 0; 1410 } 1411 1412 #ifdef CONFIG_PM 1413 1414 static int isp116x_bus_suspend(struct usb_hcd *hcd) 1415 { 1416 struct isp116x *isp116x = hcd_to_isp116x(hcd); 1417 unsigned long flags; 1418 u32 val; 1419 int ret = 0; 1420 1421 spin_lock_irqsave(&isp116x->lock, flags); 1422 val = isp116x_read_reg32(isp116x, HCCONTROL); 1423 1424 switch (val & HCCONTROL_HCFS) { 1425 case HCCONTROL_USB_OPER: 1426 spin_unlock_irqrestore(&isp116x->lock, flags); 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 msleep(2); 1433 spin_lock_irqsave(&isp116x->lock, flags); 1434 isp116x_write_reg32(isp116x, HCCONTROL, val); 1435 spin_unlock_irqrestore(&isp116x->lock, flags); 1436 /* Wait for devices to suspend */ 1437 msleep(5); 1438 break; 1439 case HCCONTROL_USB_RESUME: 1440 isp116x_write_reg32(isp116x, HCCONTROL, 1441 (val & ~HCCONTROL_HCFS) | 1442 HCCONTROL_USB_RESET); 1443 case HCCONTROL_USB_RESET: 1444 ret = -EBUSY; 1445 default: /* HCCONTROL_USB_SUSPEND */ 1446 spin_unlock_irqrestore(&isp116x->lock, flags); 1447 break; 1448 } 1449 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 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, IRQF_DISABLED); 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