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