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