1 /* 2 * SL811HS HCD (Host Controller Driver) for USB. 3 * 4 * Copyright (C) 2004 Psion Teklogix (for NetBook PRO) 5 * Copyright (C) 2004-2005 David Brownell 6 * 7 * Periodic scheduling is based on Roman's OHCI code 8 * Copyright (C) 1999 Roman Weissgaerber 9 * 10 * The SL811HS controller handles host side USB (like the SL11H, but with 11 * another register set and SOF generation) as well as peripheral side USB 12 * (like the SL811S). This driver version doesn't implement the Gadget API 13 * for the peripheral role; or OTG (that'd need much external circuitry). 14 * 15 * For documentation, see the SL811HS spec and the "SL811HS Embedded Host" 16 * document (providing significant pieces missing from that spec); plus 17 * the SL811S spec if you want peripheral side info. 18 */ 19 20 /* 21 * Status: Passed basic stress testing, works with hubs, mice, keyboards, 22 * and usb-storage. 23 * 24 * TODO: 25 * - usb suspend/resume triggered by sl811 (with USB_SUSPEND) 26 * - various issues noted in the code 27 * - performance work; use both register banks; ... 28 * - use urb->iso_frame_desc[] with ISO transfers 29 */ 30 31 #undef VERBOSE 32 #undef PACKET_TRACE 33 34 #include <linux/module.h> 35 #include <linux/moduleparam.h> 36 #include <linux/kernel.h> 37 #include <linux/delay.h> 38 #include <linux/ioport.h> 39 #include <linux/sched.h> 40 #include <linux/slab.h> 41 #include <linux/errno.h> 42 #include <linux/init.h> 43 #include <linux/timer.h> 44 #include <linux/list.h> 45 #include <linux/interrupt.h> 46 #include <linux/usb.h> 47 #include <linux/usb/sl811.h> 48 #include <linux/platform_device.h> 49 50 #include <asm/io.h> 51 #include <asm/irq.h> 52 #include <asm/system.h> 53 #include <asm/byteorder.h> 54 55 #include "../core/hcd.h" 56 #include "sl811.h" 57 58 59 MODULE_DESCRIPTION("SL811HS USB Host Controller Driver"); 60 MODULE_LICENSE("GPL"); 61 62 #define DRIVER_VERSION "19 May 2005" 63 64 65 #ifndef DEBUG 66 # define STUB_DEBUG_FILE 67 #endif 68 69 /* for now, use only one transfer register bank */ 70 #undef USE_B 71 72 /* this doesn't understand urb->iso_frame_desc[], but if you had a driver 73 * that just queued one ISO frame per URB then iso transfers "should" work 74 * using the normal urb status fields. 75 */ 76 #define DISABLE_ISO 77 78 // #define QUIRK2 79 #define QUIRK3 80 81 static const char hcd_name[] = "sl811-hcd"; 82 83 /*-------------------------------------------------------------------------*/ 84 85 static void port_power(struct sl811 *sl811, int is_on) 86 { 87 struct usb_hcd *hcd = sl811_to_hcd(sl811); 88 89 /* hub is inactive unless the port is powered */ 90 if (is_on) { 91 if (sl811->port1 & (1 << USB_PORT_FEAT_POWER)) 92 return; 93 94 sl811->port1 = (1 << USB_PORT_FEAT_POWER); 95 sl811->irq_enable = SL11H_INTMASK_INSRMV; 96 hcd->self.controller->power.power_state = PMSG_ON; 97 } else { 98 sl811->port1 = 0; 99 sl811->irq_enable = 0; 100 hcd->state = HC_STATE_HALT; 101 hcd->self.controller->power.power_state = PMSG_SUSPEND; 102 } 103 sl811->ctrl1 = 0; 104 sl811_write(sl811, SL11H_IRQ_ENABLE, 0); 105 sl811_write(sl811, SL11H_IRQ_STATUS, ~0); 106 107 if (sl811->board && sl811->board->port_power) { 108 /* switch VBUS, at 500mA unless hub power budget gets set */ 109 DBG("power %s\n", is_on ? "on" : "off"); 110 sl811->board->port_power(hcd->self.controller, is_on); 111 } 112 113 /* reset as thoroughly as we can */ 114 if (sl811->board && sl811->board->reset) 115 sl811->board->reset(hcd->self.controller); 116 else { 117 sl811_write(sl811, SL11H_CTLREG1, SL11H_CTL1MASK_SE0); 118 mdelay(20); 119 } 120 121 sl811_write(sl811, SL11H_IRQ_ENABLE, 0); 122 sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1); 123 sl811_write(sl811, SL811HS_CTLREG2, SL811HS_CTL2_INIT); 124 sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable); 125 126 // if !is_on, put into lowpower mode now 127 } 128 129 /*-------------------------------------------------------------------------*/ 130 131 /* This is a PIO-only HCD. Queueing appends URBs to the endpoint's queue, 132 * and may start I/O. Endpoint queues are scanned during completion irq 133 * handlers (one per packet: ACK, NAK, faults, etc) and urb cancellation. 134 * 135 * Using an external DMA engine to copy a packet at a time could work, 136 * though setup/teardown costs may be too big to make it worthwhile. 137 */ 138 139 /* SETUP starts a new control request. Devices are not allowed to 140 * STALL or NAK these; they must cancel any pending control requests. 141 */ 142 static void setup_packet( 143 struct sl811 *sl811, 144 struct sl811h_ep *ep, 145 struct urb *urb, 146 u8 bank, 147 u8 control 148 ) 149 { 150 u8 addr; 151 u8 len; 152 void __iomem *data_reg; 153 154 addr = SL811HS_PACKET_BUF(bank == 0); 155 len = sizeof(struct usb_ctrlrequest); 156 data_reg = sl811->data_reg; 157 sl811_write_buf(sl811, addr, urb->setup_packet, len); 158 159 /* autoincrementing */ 160 sl811_write(sl811, bank + SL11H_BUFADDRREG, addr); 161 writeb(len, data_reg); 162 writeb(SL_SETUP /* | ep->epnum */, data_reg); 163 writeb(usb_pipedevice(urb->pipe), data_reg); 164 165 /* always OUT/data0 */ ; 166 sl811_write(sl811, bank + SL11H_HOSTCTLREG, 167 control | SL11H_HCTLMASK_OUT); 168 ep->length = 0; 169 PACKET("SETUP qh%p\n", ep); 170 } 171 172 /* STATUS finishes control requests, often after IN or OUT data packets */ 173 static void status_packet( 174 struct sl811 *sl811, 175 struct sl811h_ep *ep, 176 struct urb *urb, 177 u8 bank, 178 u8 control 179 ) 180 { 181 int do_out; 182 void __iomem *data_reg; 183 184 do_out = urb->transfer_buffer_length && usb_pipein(urb->pipe); 185 data_reg = sl811->data_reg; 186 187 /* autoincrementing */ 188 sl811_write(sl811, bank + SL11H_BUFADDRREG, 0); 189 writeb(0, data_reg); 190 writeb((do_out ? SL_OUT : SL_IN) /* | ep->epnum */, data_reg); 191 writeb(usb_pipedevice(urb->pipe), data_reg); 192 193 /* always data1; sometimes IN */ 194 control |= SL11H_HCTLMASK_TOGGLE; 195 if (do_out) 196 control |= SL11H_HCTLMASK_OUT; 197 sl811_write(sl811, bank + SL11H_HOSTCTLREG, control); 198 ep->length = 0; 199 PACKET("STATUS%s/%s qh%p\n", ep->nak_count ? "/retry" : "", 200 do_out ? "out" : "in", ep); 201 } 202 203 /* IN packets can be used with any type of endpoint. here we just 204 * start the transfer, data from the peripheral may arrive later. 205 * urb->iso_frame_desc is currently ignored here... 206 */ 207 static void in_packet( 208 struct sl811 *sl811, 209 struct sl811h_ep *ep, 210 struct urb *urb, 211 u8 bank, 212 u8 control 213 ) 214 { 215 u8 addr; 216 u8 len; 217 void __iomem *data_reg; 218 219 /* avoid losing data on overflow */ 220 len = ep->maxpacket; 221 addr = SL811HS_PACKET_BUF(bank == 0); 222 if (!(control & SL11H_HCTLMASK_ISOCH) 223 && usb_gettoggle(urb->dev, ep->epnum, 0)) 224 control |= SL11H_HCTLMASK_TOGGLE; 225 data_reg = sl811->data_reg; 226 227 /* autoincrementing */ 228 sl811_write(sl811, bank + SL11H_BUFADDRREG, addr); 229 writeb(len, data_reg); 230 writeb(SL_IN | ep->epnum, data_reg); 231 writeb(usb_pipedevice(urb->pipe), data_reg); 232 233 sl811_write(sl811, bank + SL11H_HOSTCTLREG, control); 234 ep->length = min((int)len, 235 urb->transfer_buffer_length - urb->actual_length); 236 PACKET("IN%s/%d qh%p len%d\n", ep->nak_count ? "/retry" : "", 237 !!usb_gettoggle(urb->dev, ep->epnum, 0), ep, len); 238 } 239 240 /* OUT packets can be used with any type of endpoint. 241 * urb->iso_frame_desc is currently ignored here... 242 */ 243 static void out_packet( 244 struct sl811 *sl811, 245 struct sl811h_ep *ep, 246 struct urb *urb, 247 u8 bank, 248 u8 control 249 ) 250 { 251 void *buf; 252 u8 addr; 253 u8 len; 254 void __iomem *data_reg; 255 256 buf = urb->transfer_buffer + urb->actual_length; 257 prefetch(buf); 258 259 len = min((int)ep->maxpacket, 260 urb->transfer_buffer_length - urb->actual_length); 261 262 if (!(control & SL11H_HCTLMASK_ISOCH) 263 && usb_gettoggle(urb->dev, ep->epnum, 1)) 264 control |= SL11H_HCTLMASK_TOGGLE; 265 addr = SL811HS_PACKET_BUF(bank == 0); 266 data_reg = sl811->data_reg; 267 268 sl811_write_buf(sl811, addr, buf, len); 269 270 /* autoincrementing */ 271 sl811_write(sl811, bank + SL11H_BUFADDRREG, addr); 272 writeb(len, data_reg); 273 writeb(SL_OUT | ep->epnum, data_reg); 274 writeb(usb_pipedevice(urb->pipe), data_reg); 275 276 sl811_write(sl811, bank + SL11H_HOSTCTLREG, 277 control | SL11H_HCTLMASK_OUT); 278 ep->length = len; 279 PACKET("OUT%s/%d qh%p len%d\n", ep->nak_count ? "/retry" : "", 280 !!usb_gettoggle(urb->dev, ep->epnum, 1), ep, len); 281 } 282 283 /*-------------------------------------------------------------------------*/ 284 285 /* caller updates on-chip enables later */ 286 287 static inline void sofirq_on(struct sl811 *sl811) 288 { 289 if (sl811->irq_enable & SL11H_INTMASK_SOFINTR) 290 return; 291 VDBG("sof irq on\n"); 292 sl811->irq_enable |= SL11H_INTMASK_SOFINTR; 293 } 294 295 static inline void sofirq_off(struct sl811 *sl811) 296 { 297 if (!(sl811->irq_enable & SL11H_INTMASK_SOFINTR)) 298 return; 299 VDBG("sof irq off\n"); 300 sl811->irq_enable &= ~SL11H_INTMASK_SOFINTR; 301 } 302 303 /*-------------------------------------------------------------------------*/ 304 305 /* pick the next endpoint for a transaction, and issue it. 306 * frames start with periodic transfers (after whatever is pending 307 * from the previous frame), and the rest of the time is async 308 * transfers, scheduled round-robin. 309 */ 310 static struct sl811h_ep *start(struct sl811 *sl811, u8 bank) 311 { 312 struct sl811h_ep *ep; 313 struct urb *urb; 314 int fclock; 315 u8 control; 316 317 /* use endpoint at schedule head */ 318 if (sl811->next_periodic) { 319 ep = sl811->next_periodic; 320 sl811->next_periodic = ep->next; 321 } else { 322 if (sl811->next_async) 323 ep = sl811->next_async; 324 else if (!list_empty(&sl811->async)) 325 ep = container_of(sl811->async.next, 326 struct sl811h_ep, schedule); 327 else { 328 /* could set up the first fullspeed periodic 329 * transfer for the next frame ... 330 */ 331 return NULL; 332 } 333 334 #ifdef USE_B 335 if ((bank && sl811->active_b == ep) || sl811->active_a == ep) 336 return NULL; 337 #endif 338 339 if (ep->schedule.next == &sl811->async) 340 sl811->next_async = NULL; 341 else 342 sl811->next_async = container_of(ep->schedule.next, 343 struct sl811h_ep, schedule); 344 } 345 346 if (unlikely(list_empty(&ep->hep->urb_list))) { 347 DBG("empty %p queue?\n", ep); 348 return NULL; 349 } 350 351 urb = container_of(ep->hep->urb_list.next, struct urb, urb_list); 352 control = ep->defctrl; 353 354 /* if this frame doesn't have enough time left to transfer this 355 * packet, wait till the next frame. too-simple algorithm... 356 */ 357 fclock = sl811_read(sl811, SL11H_SOFTMRREG) << 6; 358 fclock -= 100; /* setup takes not much time */ 359 if (urb->dev->speed == USB_SPEED_LOW) { 360 if (control & SL11H_HCTLMASK_PREAMBLE) { 361 /* also note erratum 1: some hubs won't work */ 362 fclock -= 800; 363 } 364 fclock -= ep->maxpacket << 8; 365 366 /* erratum 2: AFTERSOF only works for fullspeed */ 367 if (fclock < 0) { 368 if (ep->period) 369 sl811->stat_overrun++; 370 sofirq_on(sl811); 371 return NULL; 372 } 373 } else { 374 fclock -= 12000 / 19; /* 19 64byte packets/msec */ 375 if (fclock < 0) { 376 if (ep->period) 377 sl811->stat_overrun++; 378 control |= SL11H_HCTLMASK_AFTERSOF; 379 380 /* throttle bulk/control irq noise */ 381 } else if (ep->nak_count) 382 control |= SL11H_HCTLMASK_AFTERSOF; 383 } 384 385 386 switch (ep->nextpid) { 387 case USB_PID_IN: 388 in_packet(sl811, ep, urb, bank, control); 389 break; 390 case USB_PID_OUT: 391 out_packet(sl811, ep, urb, bank, control); 392 break; 393 case USB_PID_SETUP: 394 setup_packet(sl811, ep, urb, bank, control); 395 break; 396 case USB_PID_ACK: /* for control status */ 397 status_packet(sl811, ep, urb, bank, control); 398 break; 399 default: 400 DBG("bad ep%p pid %02x\n", ep, ep->nextpid); 401 ep = NULL; 402 } 403 return ep; 404 } 405 406 #define MIN_JIFFIES ((msecs_to_jiffies(2) > 1) ? msecs_to_jiffies(2) : 2) 407 408 static inline void start_transfer(struct sl811 *sl811) 409 { 410 if (sl811->port1 & (1 << USB_PORT_FEAT_SUSPEND)) 411 return; 412 if (sl811->active_a == NULL) { 413 sl811->active_a = start(sl811, SL811_EP_A(SL811_HOST_BUF)); 414 if (sl811->active_a != NULL) 415 sl811->jiffies_a = jiffies + MIN_JIFFIES; 416 } 417 #ifdef USE_B 418 if (sl811->active_b == NULL) { 419 sl811->active_b = start(sl811, SL811_EP_B(SL811_HOST_BUF)); 420 if (sl811->active_b != NULL) 421 sl811->jiffies_b = jiffies + MIN_JIFFIES; 422 } 423 #endif 424 } 425 426 static void finish_request( 427 struct sl811 *sl811, 428 struct sl811h_ep *ep, 429 struct urb *urb, 430 int status 431 ) __releases(sl811->lock) __acquires(sl811->lock) 432 { 433 unsigned i; 434 435 if (usb_pipecontrol(urb->pipe)) 436 ep->nextpid = USB_PID_SETUP; 437 438 usb_hcd_unlink_urb_from_ep(sl811_to_hcd(sl811), urb); 439 spin_unlock(&sl811->lock); 440 usb_hcd_giveback_urb(sl811_to_hcd(sl811), urb, status); 441 spin_lock(&sl811->lock); 442 443 /* leave active endpoints in the schedule */ 444 if (!list_empty(&ep->hep->urb_list)) 445 return; 446 447 /* async deschedule? */ 448 if (!list_empty(&ep->schedule)) { 449 list_del_init(&ep->schedule); 450 if (ep == sl811->next_async) 451 sl811->next_async = NULL; 452 return; 453 } 454 455 /* periodic deschedule */ 456 DBG("deschedule qh%d/%p branch %d\n", ep->period, ep, ep->branch); 457 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) { 458 struct sl811h_ep *temp; 459 struct sl811h_ep **prev = &sl811->periodic[i]; 460 461 while (*prev && ((temp = *prev) != ep)) 462 prev = &temp->next; 463 if (*prev) 464 *prev = ep->next; 465 sl811->load[i] -= ep->load; 466 } 467 ep->branch = PERIODIC_SIZE; 468 sl811->periodic_count--; 469 sl811_to_hcd(sl811)->self.bandwidth_allocated 470 -= ep->load / ep->period; 471 if (ep == sl811->next_periodic) 472 sl811->next_periodic = ep->next; 473 474 /* we might turn SOFs back on again for the async schedule */ 475 if (sl811->periodic_count == 0) 476 sofirq_off(sl811); 477 } 478 479 static void 480 done(struct sl811 *sl811, struct sl811h_ep *ep, u8 bank) 481 { 482 u8 status; 483 struct urb *urb; 484 int urbstat = -EINPROGRESS; 485 486 if (unlikely(!ep)) 487 return; 488 489 status = sl811_read(sl811, bank + SL11H_PKTSTATREG); 490 491 urb = container_of(ep->hep->urb_list.next, struct urb, urb_list); 492 493 /* we can safely ignore NAKs */ 494 if (status & SL11H_STATMASK_NAK) { 495 // PACKET("...NAK_%02x qh%p\n", bank, ep); 496 if (!ep->period) 497 ep->nak_count++; 498 ep->error_count = 0; 499 500 /* ACK advances transfer, toggle, and maybe queue */ 501 } else if (status & SL11H_STATMASK_ACK) { 502 struct usb_device *udev = urb->dev; 503 int len; 504 unsigned char *buf; 505 506 /* urb->iso_frame_desc is currently ignored here... */ 507 508 ep->nak_count = ep->error_count = 0; 509 switch (ep->nextpid) { 510 case USB_PID_OUT: 511 // PACKET("...ACK/out_%02x qh%p\n", bank, ep); 512 urb->actual_length += ep->length; 513 usb_dotoggle(udev, ep->epnum, 1); 514 if (urb->actual_length 515 == urb->transfer_buffer_length) { 516 if (usb_pipecontrol(urb->pipe)) 517 ep->nextpid = USB_PID_ACK; 518 519 /* some bulk protocols terminate OUT transfers 520 * by a short packet, using ZLPs not padding. 521 */ 522 else if (ep->length < ep->maxpacket 523 || !(urb->transfer_flags 524 & URB_ZERO_PACKET)) 525 urbstat = 0; 526 } 527 break; 528 case USB_PID_IN: 529 // PACKET("...ACK/in_%02x qh%p\n", bank, ep); 530 buf = urb->transfer_buffer + urb->actual_length; 531 prefetchw(buf); 532 len = ep->maxpacket - sl811_read(sl811, 533 bank + SL11H_XFERCNTREG); 534 if (len > ep->length) { 535 len = ep->length; 536 urbstat = -EOVERFLOW; 537 } 538 urb->actual_length += len; 539 sl811_read_buf(sl811, SL811HS_PACKET_BUF(bank == 0), 540 buf, len); 541 usb_dotoggle(udev, ep->epnum, 0); 542 if (urbstat == -EINPROGRESS && 543 (len < ep->maxpacket || 544 urb->actual_length == 545 urb->transfer_buffer_length)) { 546 if (usb_pipecontrol(urb->pipe)) 547 ep->nextpid = USB_PID_ACK; 548 else 549 urbstat = 0; 550 } 551 break; 552 case USB_PID_SETUP: 553 // PACKET("...ACK/setup_%02x qh%p\n", bank, ep); 554 if (urb->transfer_buffer_length == urb->actual_length) 555 ep->nextpid = USB_PID_ACK; 556 else if (usb_pipeout(urb->pipe)) { 557 usb_settoggle(udev, 0, 1, 1); 558 ep->nextpid = USB_PID_OUT; 559 } else { 560 usb_settoggle(udev, 0, 0, 1); 561 ep->nextpid = USB_PID_IN; 562 } 563 break; 564 case USB_PID_ACK: 565 // PACKET("...ACK/status_%02x qh%p\n", bank, ep); 566 urbstat = 0; 567 break; 568 } 569 570 /* STALL stops all transfers */ 571 } else if (status & SL11H_STATMASK_STALL) { 572 PACKET("...STALL_%02x qh%p\n", bank, ep); 573 ep->nak_count = ep->error_count = 0; 574 urbstat = -EPIPE; 575 576 /* error? retry, until "3 strikes" */ 577 } else if (++ep->error_count >= 3) { 578 if (status & SL11H_STATMASK_TMOUT) 579 urbstat = -ETIME; 580 else if (status & SL11H_STATMASK_OVF) 581 urbstat = -EOVERFLOW; 582 else 583 urbstat = -EPROTO; 584 ep->error_count = 0; 585 PACKET("...3STRIKES_%02x %02x qh%p stat %d\n", 586 bank, status, ep, urbstat); 587 } 588 589 if (urbstat != -EINPROGRESS || urb->unlinked) 590 finish_request(sl811, ep, urb, urbstat); 591 } 592 593 static inline u8 checkdone(struct sl811 *sl811) 594 { 595 u8 ctl; 596 u8 irqstat = 0; 597 598 if (sl811->active_a && time_before_eq(sl811->jiffies_a, jiffies)) { 599 ctl = sl811_read(sl811, SL811_EP_A(SL11H_HOSTCTLREG)); 600 if (ctl & SL11H_HCTLMASK_ARM) 601 sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG), 0); 602 DBG("%s DONE_A: ctrl %02x sts %02x\n", 603 (ctl & SL11H_HCTLMASK_ARM) ? "timeout" : "lost", 604 ctl, 605 sl811_read(sl811, SL811_EP_A(SL11H_PKTSTATREG))); 606 irqstat |= SL11H_INTMASK_DONE_A; 607 } 608 #ifdef USE_B 609 if (sl811->active_b && time_before_eq(sl811->jiffies_b, jiffies)) { 610 ctl = sl811_read(sl811, SL811_EP_B(SL11H_HOSTCTLREG)); 611 if (ctl & SL11H_HCTLMASK_ARM) 612 sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG), 0); 613 DBG("%s DONE_B: ctrl %02x sts %02x\n", 614 (ctl & SL11H_HCTLMASK_ARM) ? "timeout" : "lost", 615 ctl, 616 sl811_read(sl811, SL811_EP_B(SL11H_PKTSTATREG))); 617 irqstat |= SL11H_INTMASK_DONE_A; 618 } 619 #endif 620 return irqstat; 621 } 622 623 static irqreturn_t sl811h_irq(struct usb_hcd *hcd) 624 { 625 struct sl811 *sl811 = hcd_to_sl811(hcd); 626 u8 irqstat; 627 irqreturn_t ret = IRQ_NONE; 628 unsigned retries = 5; 629 630 spin_lock(&sl811->lock); 631 632 retry: 633 irqstat = sl811_read(sl811, SL11H_IRQ_STATUS) & ~SL11H_INTMASK_DP; 634 if (irqstat) { 635 sl811_write(sl811, SL11H_IRQ_STATUS, irqstat); 636 irqstat &= sl811->irq_enable; 637 } 638 639 #ifdef QUIRK2 640 /* this may no longer be necessary ... */ 641 if (irqstat == 0) { 642 irqstat = checkdone(sl811); 643 if (irqstat) 644 sl811->stat_lost++; 645 } 646 #endif 647 648 /* USB packets, not necessarily handled in the order they're 649 * issued ... that's fine if they're different endpoints. 650 */ 651 if (irqstat & SL11H_INTMASK_DONE_A) { 652 done(sl811, sl811->active_a, SL811_EP_A(SL811_HOST_BUF)); 653 sl811->active_a = NULL; 654 sl811->stat_a++; 655 } 656 #ifdef USE_B 657 if (irqstat & SL11H_INTMASK_DONE_B) { 658 done(sl811, sl811->active_b, SL811_EP_B(SL811_HOST_BUF)); 659 sl811->active_b = NULL; 660 sl811->stat_b++; 661 } 662 #endif 663 if (irqstat & SL11H_INTMASK_SOFINTR) { 664 unsigned index; 665 666 index = sl811->frame++ % (PERIODIC_SIZE - 1); 667 sl811->stat_sof++; 668 669 /* be graceful about almost-inevitable periodic schedule 670 * overruns: continue the previous frame's transfers iff 671 * this one has nothing scheduled. 672 */ 673 if (sl811->next_periodic) { 674 // ERR("overrun to slot %d\n", index); 675 sl811->stat_overrun++; 676 } 677 if (sl811->periodic[index]) 678 sl811->next_periodic = sl811->periodic[index]; 679 } 680 681 /* khubd manages debouncing and wakeup */ 682 if (irqstat & SL11H_INTMASK_INSRMV) { 683 sl811->stat_insrmv++; 684 685 /* most stats are reset for each VBUS session */ 686 sl811->stat_wake = 0; 687 sl811->stat_sof = 0; 688 sl811->stat_a = 0; 689 sl811->stat_b = 0; 690 sl811->stat_lost = 0; 691 692 sl811->ctrl1 = 0; 693 sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1); 694 695 sl811->irq_enable = SL11H_INTMASK_INSRMV; 696 sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable); 697 698 /* usbcore nukes other pending transactions on disconnect */ 699 if (sl811->active_a) { 700 sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG), 0); 701 finish_request(sl811, sl811->active_a, 702 container_of(sl811->active_a 703 ->hep->urb_list.next, 704 struct urb, urb_list), 705 -ESHUTDOWN); 706 sl811->active_a = NULL; 707 } 708 #ifdef USE_B 709 if (sl811->active_b) { 710 sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG), 0); 711 finish_request(sl811, sl811->active_b, 712 container_of(sl811->active_b 713 ->hep->urb_list.next, 714 struct urb, urb_list), 715 NULL, -ESHUTDOWN); 716 sl811->active_b = NULL; 717 } 718 #endif 719 720 /* port status seems weird until after reset, so 721 * force the reset and make khubd clean up later. 722 */ 723 sl811->port1 |= (1 << USB_PORT_FEAT_C_CONNECTION) 724 | (1 << USB_PORT_FEAT_CONNECTION); 725 726 } else if (irqstat & SL11H_INTMASK_RD) { 727 if (sl811->port1 & (1 << USB_PORT_FEAT_SUSPEND)) { 728 DBG("wakeup\n"); 729 sl811->port1 |= 1 << USB_PORT_FEAT_C_SUSPEND; 730 sl811->stat_wake++; 731 } else 732 irqstat &= ~SL11H_INTMASK_RD; 733 } 734 735 if (irqstat) { 736 if (sl811->port1 & (1 << USB_PORT_FEAT_ENABLE)) 737 start_transfer(sl811); 738 ret = IRQ_HANDLED; 739 if (retries--) 740 goto retry; 741 } 742 743 if (sl811->periodic_count == 0 && list_empty(&sl811->async)) 744 sofirq_off(sl811); 745 sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable); 746 747 spin_unlock(&sl811->lock); 748 749 return ret; 750 } 751 752 /*-------------------------------------------------------------------------*/ 753 754 /* usb 1.1 says max 90% of a frame is available for periodic transfers. 755 * this driver doesn't promise that much since it's got to handle an 756 * IRQ per packet; irq handling latencies also use up that time. 757 * 758 * NOTE: the periodic schedule is a sparse tree, with the load for 759 * each branch minimized. see fig 3.5 in the OHCI spec for example. 760 */ 761 #define MAX_PERIODIC_LOAD 500 /* out of 1000 usec */ 762 763 static int balance(struct sl811 *sl811, u16 period, u16 load) 764 { 765 int i, branch = -ENOSPC; 766 767 /* search for the least loaded schedule branch of that period 768 * which has enough bandwidth left unreserved. 769 */ 770 for (i = 0; i < period ; i++) { 771 if (branch < 0 || sl811->load[branch] > sl811->load[i]) { 772 int j; 773 774 for (j = i; j < PERIODIC_SIZE; j += period) { 775 if ((sl811->load[j] + load) 776 > MAX_PERIODIC_LOAD) 777 break; 778 } 779 if (j < PERIODIC_SIZE) 780 continue; 781 branch = i; 782 } 783 } 784 return branch; 785 } 786 787 /*-------------------------------------------------------------------------*/ 788 789 static int sl811h_urb_enqueue( 790 struct usb_hcd *hcd, 791 struct urb *urb, 792 gfp_t mem_flags 793 ) { 794 struct sl811 *sl811 = hcd_to_sl811(hcd); 795 struct usb_device *udev = urb->dev; 796 unsigned int pipe = urb->pipe; 797 int is_out = !usb_pipein(pipe); 798 int type = usb_pipetype(pipe); 799 int epnum = usb_pipeendpoint(pipe); 800 struct sl811h_ep *ep = NULL; 801 unsigned long flags; 802 int i; 803 int retval; 804 struct usb_host_endpoint *hep = urb->ep; 805 806 #ifdef DISABLE_ISO 807 if (type == PIPE_ISOCHRONOUS) 808 return -ENOSPC; 809 #endif 810 811 /* avoid all allocations within spinlocks */ 812 if (!hep->hcpriv) 813 ep = kzalloc(sizeof *ep, mem_flags); 814 815 spin_lock_irqsave(&sl811->lock, flags); 816 817 /* don't submit to a dead or disabled port */ 818 if (!(sl811->port1 & (1 << USB_PORT_FEAT_ENABLE)) 819 || !HC_IS_RUNNING(hcd->state)) { 820 retval = -ENODEV; 821 kfree(ep); 822 goto fail_not_linked; 823 } 824 retval = usb_hcd_link_urb_to_ep(hcd, urb); 825 if (retval) { 826 kfree(ep); 827 goto fail_not_linked; 828 } 829 830 if (hep->hcpriv) { 831 kfree(ep); 832 ep = hep->hcpriv; 833 } else if (!ep) { 834 retval = -ENOMEM; 835 goto fail; 836 837 } else { 838 INIT_LIST_HEAD(&ep->schedule); 839 ep->udev = udev; 840 ep->epnum = epnum; 841 ep->maxpacket = usb_maxpacket(udev, urb->pipe, is_out); 842 ep->defctrl = SL11H_HCTLMASK_ARM | SL11H_HCTLMASK_ENABLE; 843 usb_settoggle(udev, epnum, is_out, 0); 844 845 if (type == PIPE_CONTROL) 846 ep->nextpid = USB_PID_SETUP; 847 else if (is_out) 848 ep->nextpid = USB_PID_OUT; 849 else 850 ep->nextpid = USB_PID_IN; 851 852 if (ep->maxpacket > H_MAXPACKET) { 853 /* iso packets up to 240 bytes could work... */ 854 DBG("dev %d ep%d maxpacket %d\n", 855 udev->devnum, epnum, ep->maxpacket); 856 retval = -EINVAL; 857 goto fail; 858 } 859 860 if (udev->speed == USB_SPEED_LOW) { 861 /* send preamble for external hub? */ 862 if (!(sl811->ctrl1 & SL11H_CTL1MASK_LSPD)) 863 ep->defctrl |= SL11H_HCTLMASK_PREAMBLE; 864 } 865 switch (type) { 866 case PIPE_ISOCHRONOUS: 867 case PIPE_INTERRUPT: 868 if (urb->interval > PERIODIC_SIZE) 869 urb->interval = PERIODIC_SIZE; 870 ep->period = urb->interval; 871 ep->branch = PERIODIC_SIZE; 872 if (type == PIPE_ISOCHRONOUS) 873 ep->defctrl |= SL11H_HCTLMASK_ISOCH; 874 ep->load = usb_calc_bus_time(udev->speed, !is_out, 875 (type == PIPE_ISOCHRONOUS), 876 usb_maxpacket(udev, pipe, is_out)) 877 / 1000; 878 break; 879 } 880 881 ep->hep = hep; 882 hep->hcpriv = ep; 883 } 884 885 /* maybe put endpoint into schedule */ 886 switch (type) { 887 case PIPE_CONTROL: 888 case PIPE_BULK: 889 if (list_empty(&ep->schedule)) 890 list_add_tail(&ep->schedule, &sl811->async); 891 break; 892 case PIPE_ISOCHRONOUS: 893 case PIPE_INTERRUPT: 894 urb->interval = ep->period; 895 if (ep->branch < PERIODIC_SIZE) { 896 /* NOTE: the phase is correct here, but the value 897 * needs offsetting by the transfer queue depth. 898 * All current drivers ignore start_frame, so this 899 * is unlikely to ever matter... 900 */ 901 urb->start_frame = (sl811->frame & (PERIODIC_SIZE - 1)) 902 + ep->branch; 903 break; 904 } 905 906 retval = balance(sl811, ep->period, ep->load); 907 if (retval < 0) 908 goto fail; 909 ep->branch = retval; 910 retval = 0; 911 urb->start_frame = (sl811->frame & (PERIODIC_SIZE - 1)) 912 + ep->branch; 913 914 /* sort each schedule branch by period (slow before fast) 915 * to share the faster parts of the tree without needing 916 * dummy/placeholder nodes 917 */ 918 DBG("schedule qh%d/%p branch %d\n", ep->period, ep, ep->branch); 919 for (i = ep->branch; i < PERIODIC_SIZE; i += ep->period) { 920 struct sl811h_ep **prev = &sl811->periodic[i]; 921 struct sl811h_ep *here = *prev; 922 923 while (here && ep != here) { 924 if (ep->period > here->period) 925 break; 926 prev = &here->next; 927 here = *prev; 928 } 929 if (ep != here) { 930 ep->next = here; 931 *prev = ep; 932 } 933 sl811->load[i] += ep->load; 934 } 935 sl811->periodic_count++; 936 hcd->self.bandwidth_allocated += ep->load / ep->period; 937 sofirq_on(sl811); 938 } 939 940 urb->hcpriv = hep; 941 start_transfer(sl811); 942 sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable); 943 fail: 944 if (retval) 945 usb_hcd_unlink_urb_from_ep(hcd, urb); 946 fail_not_linked: 947 spin_unlock_irqrestore(&sl811->lock, flags); 948 return retval; 949 } 950 951 static int sl811h_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) 952 { 953 struct sl811 *sl811 = hcd_to_sl811(hcd); 954 struct usb_host_endpoint *hep; 955 unsigned long flags; 956 struct sl811h_ep *ep; 957 int retval; 958 959 spin_lock_irqsave(&sl811->lock, flags); 960 retval = usb_hcd_check_unlink_urb(hcd, urb, status); 961 if (retval) 962 goto fail; 963 964 hep = urb->hcpriv; 965 ep = hep->hcpriv; 966 if (ep) { 967 /* finish right away if this urb can't be active ... 968 * note that some drivers wrongly expect delays 969 */ 970 if (ep->hep->urb_list.next != &urb->urb_list) { 971 /* not front of queue? never active */ 972 973 /* for active transfers, we expect an IRQ */ 974 } else if (sl811->active_a == ep) { 975 if (time_before_eq(sl811->jiffies_a, jiffies)) { 976 /* happens a lot with lowspeed?? */ 977 DBG("giveup on DONE_A: ctrl %02x sts %02x\n", 978 sl811_read(sl811, 979 SL811_EP_A(SL11H_HOSTCTLREG)), 980 sl811_read(sl811, 981 SL811_EP_A(SL11H_PKTSTATREG))); 982 sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG), 983 0); 984 sl811->active_a = NULL; 985 } else 986 urb = NULL; 987 #ifdef USE_B 988 } else if (sl811->active_b == ep) { 989 if (time_before_eq(sl811->jiffies_a, jiffies)) { 990 /* happens a lot with lowspeed?? */ 991 DBG("giveup on DONE_B: ctrl %02x sts %02x\n", 992 sl811_read(sl811, 993 SL811_EP_B(SL11H_HOSTCTLREG)), 994 sl811_read(sl811, 995 SL811_EP_B(SL11H_PKTSTATREG))); 996 sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG), 997 0); 998 sl811->active_b = NULL; 999 } else 1000 urb = NULL; 1001 #endif 1002 } else { 1003 /* front of queue for inactive endpoint */ 1004 } 1005 1006 if (urb) 1007 finish_request(sl811, ep, urb, 0); 1008 else 1009 VDBG("dequeue, urb %p active %s; wait4irq\n", urb, 1010 (sl811->active_a == ep) ? "A" : "B"); 1011 } else 1012 retval = -EINVAL; 1013 fail: 1014 spin_unlock_irqrestore(&sl811->lock, flags); 1015 return retval; 1016 } 1017 1018 static void 1019 sl811h_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep) 1020 { 1021 struct sl811h_ep *ep = hep->hcpriv; 1022 1023 if (!ep) 1024 return; 1025 1026 /* assume we'd just wait for the irq */ 1027 if (!list_empty(&hep->urb_list)) 1028 msleep(3); 1029 if (!list_empty(&hep->urb_list)) 1030 WARN("ep %p not empty?\n", ep); 1031 1032 kfree(ep); 1033 hep->hcpriv = NULL; 1034 } 1035 1036 static int 1037 sl811h_get_frame(struct usb_hcd *hcd) 1038 { 1039 struct sl811 *sl811 = hcd_to_sl811(hcd); 1040 1041 /* wrong except while periodic transfers are scheduled; 1042 * never matches the on-the-wire frame; 1043 * subject to overruns. 1044 */ 1045 return sl811->frame; 1046 } 1047 1048 1049 /*-------------------------------------------------------------------------*/ 1050 1051 /* the virtual root hub timer IRQ checks for hub status */ 1052 static int 1053 sl811h_hub_status_data(struct usb_hcd *hcd, char *buf) 1054 { 1055 struct sl811 *sl811 = hcd_to_sl811(hcd); 1056 #ifdef QUIRK3 1057 unsigned long flags; 1058 1059 /* non-SMP HACK: use root hub timer as i/o watchdog 1060 * this seems essential when SOF IRQs aren't in use... 1061 */ 1062 local_irq_save(flags); 1063 if (!timer_pending(&sl811->timer)) { 1064 if (sl811h_irq( /* ~0, */ hcd) != IRQ_NONE) 1065 sl811->stat_lost++; 1066 } 1067 local_irq_restore(flags); 1068 #endif 1069 1070 if (!(sl811->port1 & (0xffff << 16))) 1071 return 0; 1072 1073 /* tell khubd port 1 changed */ 1074 *buf = (1 << 1); 1075 return 1; 1076 } 1077 1078 static void 1079 sl811h_hub_descriptor ( 1080 struct sl811 *sl811, 1081 struct usb_hub_descriptor *desc 1082 ) { 1083 u16 temp = 0; 1084 1085 desc->bDescriptorType = 0x29; 1086 desc->bHubContrCurrent = 0; 1087 1088 desc->bNbrPorts = 1; 1089 desc->bDescLength = 9; 1090 1091 /* per-port power switching (gang of one!), or none */ 1092 desc->bPwrOn2PwrGood = 0; 1093 if (sl811->board && sl811->board->port_power) { 1094 desc->bPwrOn2PwrGood = sl811->board->potpg; 1095 if (!desc->bPwrOn2PwrGood) 1096 desc->bPwrOn2PwrGood = 10; 1097 temp = 0x0001; 1098 } else 1099 temp = 0x0002; 1100 1101 /* no overcurrent errors detection/handling */ 1102 temp |= 0x0010; 1103 1104 desc->wHubCharacteristics = (__force __u16)cpu_to_le16(temp); 1105 1106 /* two bitmaps: ports removable, and legacy PortPwrCtrlMask */ 1107 desc->bitmap[0] = 0 << 1; 1108 desc->bitmap[1] = ~0; 1109 } 1110 1111 static void 1112 sl811h_timer(unsigned long _sl811) 1113 { 1114 struct sl811 *sl811 = (void *) _sl811; 1115 unsigned long flags; 1116 u8 irqstat; 1117 u8 signaling = sl811->ctrl1 & SL11H_CTL1MASK_FORCE; 1118 const u32 mask = (1 << USB_PORT_FEAT_CONNECTION) 1119 | (1 << USB_PORT_FEAT_ENABLE) 1120 | (1 << USB_PORT_FEAT_LOWSPEED); 1121 1122 spin_lock_irqsave(&sl811->lock, flags); 1123 1124 /* stop special signaling */ 1125 sl811->ctrl1 &= ~SL11H_CTL1MASK_FORCE; 1126 sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1); 1127 udelay(3); 1128 1129 irqstat = sl811_read(sl811, SL11H_IRQ_STATUS); 1130 1131 switch (signaling) { 1132 case SL11H_CTL1MASK_SE0: 1133 DBG("end reset\n"); 1134 sl811->port1 = (1 << USB_PORT_FEAT_C_RESET) 1135 | (1 << USB_PORT_FEAT_POWER); 1136 sl811->ctrl1 = 0; 1137 /* don't wrongly ack RD */ 1138 if (irqstat & SL11H_INTMASK_INSRMV) 1139 irqstat &= ~SL11H_INTMASK_RD; 1140 break; 1141 case SL11H_CTL1MASK_K: 1142 DBG("end resume\n"); 1143 sl811->port1 &= ~(1 << USB_PORT_FEAT_SUSPEND); 1144 break; 1145 default: 1146 DBG("odd timer signaling: %02x\n", signaling); 1147 break; 1148 } 1149 sl811_write(sl811, SL11H_IRQ_STATUS, irqstat); 1150 1151 if (irqstat & SL11H_INTMASK_RD) { 1152 /* usbcore nukes all pending transactions on disconnect */ 1153 if (sl811->port1 & (1 << USB_PORT_FEAT_CONNECTION)) 1154 sl811->port1 |= (1 << USB_PORT_FEAT_C_CONNECTION) 1155 | (1 << USB_PORT_FEAT_C_ENABLE); 1156 sl811->port1 &= ~mask; 1157 sl811->irq_enable = SL11H_INTMASK_INSRMV; 1158 } else { 1159 sl811->port1 |= mask; 1160 if (irqstat & SL11H_INTMASK_DP) 1161 sl811->port1 &= ~(1 << USB_PORT_FEAT_LOWSPEED); 1162 sl811->irq_enable = SL11H_INTMASK_INSRMV | SL11H_INTMASK_RD; 1163 } 1164 1165 if (sl811->port1 & (1 << USB_PORT_FEAT_CONNECTION)) { 1166 u8 ctrl2 = SL811HS_CTL2_INIT; 1167 1168 sl811->irq_enable |= SL11H_INTMASK_DONE_A; 1169 #ifdef USE_B 1170 sl811->irq_enable |= SL11H_INTMASK_DONE_B; 1171 #endif 1172 if (sl811->port1 & (1 << USB_PORT_FEAT_LOWSPEED)) { 1173 sl811->ctrl1 |= SL11H_CTL1MASK_LSPD; 1174 ctrl2 |= SL811HS_CTL2MASK_DSWAP; 1175 } 1176 1177 /* start SOFs flowing, kickstarting with A registers */ 1178 sl811->ctrl1 |= SL11H_CTL1MASK_SOF_ENA; 1179 sl811_write(sl811, SL11H_SOFLOWREG, 0xe0); 1180 sl811_write(sl811, SL811HS_CTLREG2, ctrl2); 1181 1182 /* autoincrementing */ 1183 sl811_write(sl811, SL811_EP_A(SL11H_BUFLNTHREG), 0); 1184 writeb(SL_SOF, sl811->data_reg); 1185 writeb(0, sl811->data_reg); 1186 sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG), 1187 SL11H_HCTLMASK_ARM); 1188 1189 /* khubd provides debounce delay */ 1190 } else { 1191 sl811->ctrl1 = 0; 1192 } 1193 sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1); 1194 1195 /* reenable irqs */ 1196 sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable); 1197 spin_unlock_irqrestore(&sl811->lock, flags); 1198 } 1199 1200 static int 1201 sl811h_hub_control( 1202 struct usb_hcd *hcd, 1203 u16 typeReq, 1204 u16 wValue, 1205 u16 wIndex, 1206 char *buf, 1207 u16 wLength 1208 ) { 1209 struct sl811 *sl811 = hcd_to_sl811(hcd); 1210 int retval = 0; 1211 unsigned long flags; 1212 1213 spin_lock_irqsave(&sl811->lock, flags); 1214 1215 switch (typeReq) { 1216 case ClearHubFeature: 1217 case SetHubFeature: 1218 switch (wValue) { 1219 case C_HUB_OVER_CURRENT: 1220 case C_HUB_LOCAL_POWER: 1221 break; 1222 default: 1223 goto error; 1224 } 1225 break; 1226 case ClearPortFeature: 1227 if (wIndex != 1 || wLength != 0) 1228 goto error; 1229 1230 switch (wValue) { 1231 case USB_PORT_FEAT_ENABLE: 1232 sl811->port1 &= (1 << USB_PORT_FEAT_POWER); 1233 sl811->ctrl1 = 0; 1234 sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1); 1235 sl811->irq_enable = SL11H_INTMASK_INSRMV; 1236 sl811_write(sl811, SL11H_IRQ_ENABLE, 1237 sl811->irq_enable); 1238 break; 1239 case USB_PORT_FEAT_SUSPEND: 1240 if (!(sl811->port1 & (1 << USB_PORT_FEAT_SUSPEND))) 1241 break; 1242 1243 /* 20 msec of resume/K signaling, other irqs blocked */ 1244 DBG("start resume...\n"); 1245 sl811->irq_enable = 0; 1246 sl811_write(sl811, SL11H_IRQ_ENABLE, 1247 sl811->irq_enable); 1248 sl811->ctrl1 |= SL11H_CTL1MASK_K; 1249 sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1); 1250 1251 mod_timer(&sl811->timer, jiffies 1252 + msecs_to_jiffies(20)); 1253 break; 1254 case USB_PORT_FEAT_POWER: 1255 port_power(sl811, 0); 1256 break; 1257 case USB_PORT_FEAT_C_ENABLE: 1258 case USB_PORT_FEAT_C_SUSPEND: 1259 case USB_PORT_FEAT_C_CONNECTION: 1260 case USB_PORT_FEAT_C_OVER_CURRENT: 1261 case USB_PORT_FEAT_C_RESET: 1262 break; 1263 default: 1264 goto error; 1265 } 1266 sl811->port1 &= ~(1 << wValue); 1267 break; 1268 case GetHubDescriptor: 1269 sl811h_hub_descriptor(sl811, (struct usb_hub_descriptor *) buf); 1270 break; 1271 case GetHubStatus: 1272 *(__le32 *) buf = cpu_to_le32(0); 1273 break; 1274 case GetPortStatus: 1275 if (wIndex != 1) 1276 goto error; 1277 *(__le32 *) buf = cpu_to_le32(sl811->port1); 1278 1279 #ifndef VERBOSE 1280 if (*(u16*)(buf+2)) /* only if wPortChange is interesting */ 1281 #endif 1282 DBG("GetPortStatus %08x\n", sl811->port1); 1283 break; 1284 case SetPortFeature: 1285 if (wIndex != 1 || wLength != 0) 1286 goto error; 1287 switch (wValue) { 1288 case USB_PORT_FEAT_SUSPEND: 1289 if (sl811->port1 & (1 << USB_PORT_FEAT_RESET)) 1290 goto error; 1291 if (!(sl811->port1 & (1 << USB_PORT_FEAT_ENABLE))) 1292 goto error; 1293 1294 DBG("suspend...\n"); 1295 sl811->ctrl1 &= ~SL11H_CTL1MASK_SOF_ENA; 1296 sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1); 1297 break; 1298 case USB_PORT_FEAT_POWER: 1299 port_power(sl811, 1); 1300 break; 1301 case USB_PORT_FEAT_RESET: 1302 if (sl811->port1 & (1 << USB_PORT_FEAT_SUSPEND)) 1303 goto error; 1304 if (!(sl811->port1 & (1 << USB_PORT_FEAT_POWER))) 1305 break; 1306 1307 /* 50 msec of reset/SE0 signaling, irqs blocked */ 1308 sl811->irq_enable = 0; 1309 sl811_write(sl811, SL11H_IRQ_ENABLE, 1310 sl811->irq_enable); 1311 sl811->ctrl1 = SL11H_CTL1MASK_SE0; 1312 sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1); 1313 sl811->port1 |= (1 << USB_PORT_FEAT_RESET); 1314 mod_timer(&sl811->timer, jiffies 1315 + msecs_to_jiffies(50)); 1316 break; 1317 default: 1318 goto error; 1319 } 1320 sl811->port1 |= 1 << wValue; 1321 break; 1322 1323 default: 1324 error: 1325 /* "protocol stall" on error */ 1326 retval = -EPIPE; 1327 } 1328 1329 spin_unlock_irqrestore(&sl811->lock, flags); 1330 return retval; 1331 } 1332 1333 #ifdef CONFIG_PM 1334 1335 static int 1336 sl811h_bus_suspend(struct usb_hcd *hcd) 1337 { 1338 // SOFs off 1339 DBG("%s\n", __FUNCTION__); 1340 return 0; 1341 } 1342 1343 static int 1344 sl811h_bus_resume(struct usb_hcd *hcd) 1345 { 1346 // SOFs on 1347 DBG("%s\n", __FUNCTION__); 1348 return 0; 1349 } 1350 1351 #else 1352 1353 #define sl811h_bus_suspend NULL 1354 #define sl811h_bus_resume NULL 1355 1356 #endif 1357 1358 1359 /*-------------------------------------------------------------------------*/ 1360 1361 #ifdef STUB_DEBUG_FILE 1362 1363 static inline void create_debug_file(struct sl811 *sl811) { } 1364 static inline void remove_debug_file(struct sl811 *sl811) { } 1365 1366 #else 1367 1368 #include <linux/proc_fs.h> 1369 #include <linux/seq_file.h> 1370 1371 static void dump_irq(struct seq_file *s, char *label, u8 mask) 1372 { 1373 seq_printf(s, "%s %02x%s%s%s%s%s%s\n", label, mask, 1374 (mask & SL11H_INTMASK_DONE_A) ? " done_a" : "", 1375 (mask & SL11H_INTMASK_DONE_B) ? " done_b" : "", 1376 (mask & SL11H_INTMASK_SOFINTR) ? " sof" : "", 1377 (mask & SL11H_INTMASK_INSRMV) ? " ins/rmv" : "", 1378 (mask & SL11H_INTMASK_RD) ? " rd" : "", 1379 (mask & SL11H_INTMASK_DP) ? " dp" : ""); 1380 } 1381 1382 static int proc_sl811h_show(struct seq_file *s, void *unused) 1383 { 1384 struct sl811 *sl811 = s->private; 1385 struct sl811h_ep *ep; 1386 unsigned i; 1387 1388 seq_printf(s, "%s\n%s version %s\nportstatus[1] = %08x\n", 1389 sl811_to_hcd(sl811)->product_desc, 1390 hcd_name, DRIVER_VERSION, 1391 sl811->port1); 1392 1393 seq_printf(s, "insert/remove: %ld\n", sl811->stat_insrmv); 1394 seq_printf(s, "current session: done_a %ld done_b %ld " 1395 "wake %ld sof %ld overrun %ld lost %ld\n\n", 1396 sl811->stat_a, sl811->stat_b, 1397 sl811->stat_wake, sl811->stat_sof, 1398 sl811->stat_overrun, sl811->stat_lost); 1399 1400 spin_lock_irq(&sl811->lock); 1401 1402 if (sl811->ctrl1 & SL11H_CTL1MASK_SUSPEND) 1403 seq_printf(s, "(suspended)\n\n"); 1404 else { 1405 u8 t = sl811_read(sl811, SL11H_CTLREG1); 1406 1407 seq_printf(s, "ctrl1 %02x%s%s%s%s\n", t, 1408 (t & SL11H_CTL1MASK_SOF_ENA) ? " sofgen" : "", 1409 ({char *s; switch (t & SL11H_CTL1MASK_FORCE) { 1410 case SL11H_CTL1MASK_NORMAL: s = ""; break; 1411 case SL11H_CTL1MASK_SE0: s = " se0/reset"; break; 1412 case SL11H_CTL1MASK_K: s = " k/resume"; break; 1413 default: s = "j"; break; 1414 }; s; }), 1415 (t & SL11H_CTL1MASK_LSPD) ? " lowspeed" : "", 1416 (t & SL11H_CTL1MASK_SUSPEND) ? " suspend" : ""); 1417 1418 dump_irq(s, "irq_enable", 1419 sl811_read(sl811, SL11H_IRQ_ENABLE)); 1420 dump_irq(s, "irq_status", 1421 sl811_read(sl811, SL11H_IRQ_STATUS)); 1422 seq_printf(s, "frame clocks remaining: %d\n", 1423 sl811_read(sl811, SL11H_SOFTMRREG) << 6); 1424 } 1425 1426 seq_printf(s, "A: qh%p ctl %02x sts %02x\n", sl811->active_a, 1427 sl811_read(sl811, SL811_EP_A(SL11H_HOSTCTLREG)), 1428 sl811_read(sl811, SL811_EP_A(SL11H_PKTSTATREG))); 1429 seq_printf(s, "B: qh%p ctl %02x sts %02x\n", sl811->active_b, 1430 sl811_read(sl811, SL811_EP_B(SL11H_HOSTCTLREG)), 1431 sl811_read(sl811, SL811_EP_B(SL11H_PKTSTATREG))); 1432 seq_printf(s, "\n"); 1433 list_for_each_entry (ep, &sl811->async, schedule) { 1434 struct urb *urb; 1435 1436 seq_printf(s, "%s%sqh%p, ep%d%s, maxpacket %d" 1437 " nak %d err %d\n", 1438 (ep == sl811->active_a) ? "(A) " : "", 1439 (ep == sl811->active_b) ? "(B) " : "", 1440 ep, ep->epnum, 1441 ({ char *s; switch (ep->nextpid) { 1442 case USB_PID_IN: s = "in"; break; 1443 case USB_PID_OUT: s = "out"; break; 1444 case USB_PID_SETUP: s = "setup"; break; 1445 case USB_PID_ACK: s = "status"; break; 1446 default: s = "?"; break; 1447 }; s;}), 1448 ep->maxpacket, 1449 ep->nak_count, ep->error_count); 1450 list_for_each_entry (urb, &ep->hep->urb_list, urb_list) { 1451 seq_printf(s, " urb%p, %d/%d\n", urb, 1452 urb->actual_length, 1453 urb->transfer_buffer_length); 1454 } 1455 } 1456 if (!list_empty(&sl811->async)) 1457 seq_printf(s, "\n"); 1458 1459 seq_printf(s, "periodic size= %d\n", PERIODIC_SIZE); 1460 1461 for (i = 0; i < PERIODIC_SIZE; i++) { 1462 ep = sl811->periodic[i]; 1463 if (!ep) 1464 continue; 1465 seq_printf(s, "%2d [%3d]:\n", i, sl811->load[i]); 1466 1467 /* DUMB: prints shared entries multiple times */ 1468 do { 1469 seq_printf(s, 1470 " %s%sqh%d/%p (%sdev%d ep%d%s max %d) " 1471 "err %d\n", 1472 (ep == sl811->active_a) ? "(A) " : "", 1473 (ep == sl811->active_b) ? "(B) " : "", 1474 ep->period, ep, 1475 (ep->udev->speed == USB_SPEED_FULL) 1476 ? "" : "ls ", 1477 ep->udev->devnum, ep->epnum, 1478 (ep->epnum == 0) ? "" 1479 : ((ep->nextpid == USB_PID_IN) 1480 ? "in" 1481 : "out"), 1482 ep->maxpacket, ep->error_count); 1483 ep = ep->next; 1484 } while (ep); 1485 } 1486 1487 spin_unlock_irq(&sl811->lock); 1488 seq_printf(s, "\n"); 1489 1490 return 0; 1491 } 1492 1493 static int proc_sl811h_open(struct inode *inode, struct file *file) 1494 { 1495 return single_open(file, proc_sl811h_show, PDE(inode)->data); 1496 } 1497 1498 static const struct file_operations proc_ops = { 1499 .open = proc_sl811h_open, 1500 .read = seq_read, 1501 .llseek = seq_lseek, 1502 .release = single_release, 1503 }; 1504 1505 /* expect just one sl811 per system */ 1506 static const char proc_filename[] = "driver/sl811h"; 1507 1508 static void create_debug_file(struct sl811 *sl811) 1509 { 1510 struct proc_dir_entry *pde; 1511 1512 pde = create_proc_entry(proc_filename, 0, NULL); 1513 if (pde == NULL) 1514 return; 1515 1516 pde->proc_fops = &proc_ops; 1517 pde->data = sl811; 1518 sl811->pde = pde; 1519 } 1520 1521 static void remove_debug_file(struct sl811 *sl811) 1522 { 1523 if (sl811->pde) 1524 remove_proc_entry(proc_filename, NULL); 1525 } 1526 1527 #endif 1528 1529 /*-------------------------------------------------------------------------*/ 1530 1531 static void 1532 sl811h_stop(struct usb_hcd *hcd) 1533 { 1534 struct sl811 *sl811 = hcd_to_sl811(hcd); 1535 unsigned long flags; 1536 1537 del_timer_sync(&hcd->rh_timer); 1538 1539 spin_lock_irqsave(&sl811->lock, flags); 1540 port_power(sl811, 0); 1541 spin_unlock_irqrestore(&sl811->lock, flags); 1542 } 1543 1544 static int 1545 sl811h_start(struct usb_hcd *hcd) 1546 { 1547 struct sl811 *sl811 = hcd_to_sl811(hcd); 1548 1549 /* chip has been reset, VBUS power is off */ 1550 hcd->state = HC_STATE_RUNNING; 1551 1552 if (sl811->board) { 1553 if (!device_can_wakeup(hcd->self.controller)) 1554 device_init_wakeup(hcd->self.controller, 1555 sl811->board->can_wakeup); 1556 hcd->power_budget = sl811->board->power * 2; 1557 } 1558 1559 /* enable power and interrupts */ 1560 port_power(sl811, 1); 1561 1562 return 0; 1563 } 1564 1565 /*-------------------------------------------------------------------------*/ 1566 1567 static struct hc_driver sl811h_hc_driver = { 1568 .description = hcd_name, 1569 .hcd_priv_size = sizeof(struct sl811), 1570 1571 /* 1572 * generic hardware linkage 1573 */ 1574 .irq = sl811h_irq, 1575 .flags = HCD_USB11 | HCD_MEMORY, 1576 1577 /* Basic lifecycle operations */ 1578 .start = sl811h_start, 1579 .stop = sl811h_stop, 1580 1581 /* 1582 * managing i/o requests and associated device resources 1583 */ 1584 .urb_enqueue = sl811h_urb_enqueue, 1585 .urb_dequeue = sl811h_urb_dequeue, 1586 .endpoint_disable = sl811h_endpoint_disable, 1587 1588 /* 1589 * periodic schedule support 1590 */ 1591 .get_frame_number = sl811h_get_frame, 1592 1593 /* 1594 * root hub support 1595 */ 1596 .hub_status_data = sl811h_hub_status_data, 1597 .hub_control = sl811h_hub_control, 1598 .bus_suspend = sl811h_bus_suspend, 1599 .bus_resume = sl811h_bus_resume, 1600 }; 1601 1602 /*-------------------------------------------------------------------------*/ 1603 1604 static int __devexit 1605 sl811h_remove(struct platform_device *dev) 1606 { 1607 struct usb_hcd *hcd = platform_get_drvdata(dev); 1608 struct sl811 *sl811 = hcd_to_sl811(hcd); 1609 struct resource *res; 1610 1611 remove_debug_file(sl811); 1612 usb_remove_hcd(hcd); 1613 1614 /* some platforms may use IORESOURCE_IO */ 1615 res = platform_get_resource(dev, IORESOURCE_MEM, 1); 1616 if (res) 1617 iounmap(sl811->data_reg); 1618 1619 res = platform_get_resource(dev, IORESOURCE_MEM, 0); 1620 if (res) 1621 iounmap(sl811->addr_reg); 1622 1623 usb_put_hcd(hcd); 1624 return 0; 1625 } 1626 1627 static int __devinit 1628 sl811h_probe(struct platform_device *dev) 1629 { 1630 struct usb_hcd *hcd; 1631 struct sl811 *sl811; 1632 struct resource *addr, *data; 1633 int irq; 1634 void __iomem *addr_reg; 1635 void __iomem *data_reg; 1636 int retval; 1637 u8 tmp, ioaddr = 0; 1638 1639 /* basic sanity checks first. board-specific init logic should 1640 * have initialized these three resources and probably board 1641 * specific platform_data. we don't probe for IRQs, and do only 1642 * minimal sanity checking. 1643 */ 1644 irq = platform_get_irq(dev, 0); 1645 if (dev->num_resources < 3 || irq < 0) 1646 return -ENODEV; 1647 1648 /* refuse to confuse usbcore */ 1649 if (dev->dev.dma_mask) { 1650 DBG("no we won't dma\n"); 1651 return -EINVAL; 1652 } 1653 1654 /* the chip may be wired for either kind of addressing */ 1655 addr = platform_get_resource(dev, IORESOURCE_MEM, 0); 1656 data = platform_get_resource(dev, IORESOURCE_MEM, 1); 1657 retval = -EBUSY; 1658 if (!addr || !data) { 1659 addr = platform_get_resource(dev, IORESOURCE_IO, 0); 1660 data = platform_get_resource(dev, IORESOURCE_IO, 1); 1661 if (!addr || !data) 1662 return -ENODEV; 1663 ioaddr = 1; 1664 /* 1665 * NOTE: 64-bit resource->start is getting truncated 1666 * to avoid compiler warning, assuming that ->start 1667 * is always 32-bit for this case 1668 */ 1669 addr_reg = (void __iomem *) (unsigned long) addr->start; 1670 data_reg = (void __iomem *) (unsigned long) data->start; 1671 } else { 1672 addr_reg = ioremap(addr->start, 1); 1673 if (addr_reg == NULL) { 1674 retval = -ENOMEM; 1675 goto err2; 1676 } 1677 1678 data_reg = ioremap(data->start, 1); 1679 if (data_reg == NULL) { 1680 retval = -ENOMEM; 1681 goto err4; 1682 } 1683 } 1684 1685 /* allocate and initialize hcd */ 1686 hcd = usb_create_hcd(&sl811h_hc_driver, &dev->dev, dev->dev.bus_id); 1687 if (!hcd) { 1688 retval = -ENOMEM; 1689 goto err5; 1690 } 1691 hcd->rsrc_start = addr->start; 1692 sl811 = hcd_to_sl811(hcd); 1693 1694 spin_lock_init(&sl811->lock); 1695 INIT_LIST_HEAD(&sl811->async); 1696 sl811->board = dev->dev.platform_data; 1697 init_timer(&sl811->timer); 1698 sl811->timer.function = sl811h_timer; 1699 sl811->timer.data = (unsigned long) sl811; 1700 sl811->addr_reg = addr_reg; 1701 sl811->data_reg = data_reg; 1702 1703 spin_lock_irq(&sl811->lock); 1704 port_power(sl811, 0); 1705 spin_unlock_irq(&sl811->lock); 1706 msleep(200); 1707 1708 tmp = sl811_read(sl811, SL11H_HWREVREG); 1709 switch (tmp >> 4) { 1710 case 1: 1711 hcd->product_desc = "SL811HS v1.2"; 1712 break; 1713 case 2: 1714 hcd->product_desc = "SL811HS v1.5"; 1715 break; 1716 default: 1717 /* reject case 0, SL11S is less functional */ 1718 DBG("chiprev %02x\n", tmp); 1719 retval = -ENXIO; 1720 goto err6; 1721 } 1722 1723 /* The chip's IRQ is level triggered, active high. A requirement 1724 * for platform device setup is to cope with things like signal 1725 * inverters (e.g. CF is active low) or working only with edge 1726 * triggers (e.g. most ARM CPUs). Initial driver stress testing 1727 * was on a system with single edge triggering, so most sorts of 1728 * triggering arrangement should work. 1729 */ 1730 retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED); 1731 if (retval != 0) 1732 goto err6; 1733 1734 create_debug_file(sl811); 1735 return retval; 1736 1737 err6: 1738 usb_put_hcd(hcd); 1739 err5: 1740 if (!ioaddr) 1741 iounmap(data_reg); 1742 err4: 1743 if (!ioaddr) 1744 iounmap(addr_reg); 1745 err2: 1746 DBG("init error, %d\n", retval); 1747 return retval; 1748 } 1749 1750 #ifdef CONFIG_PM 1751 1752 /* for this device there's no useful distinction between the controller 1753 * and its root hub, except that the root hub only gets direct PM calls 1754 * when CONFIG_USB_SUSPEND is enabled. 1755 */ 1756 1757 static int 1758 sl811h_suspend(struct platform_device *dev, pm_message_t state) 1759 { 1760 struct usb_hcd *hcd = platform_get_drvdata(dev); 1761 struct sl811 *sl811 = hcd_to_sl811(hcd); 1762 int retval = 0; 1763 1764 switch (state.event) { 1765 case PM_EVENT_FREEZE: 1766 retval = sl811h_bus_suspend(hcd); 1767 break; 1768 case PM_EVENT_SUSPEND: 1769 case PM_EVENT_PRETHAW: /* explicitly discard hw state */ 1770 port_power(sl811, 0); 1771 break; 1772 } 1773 if (retval == 0) 1774 dev->dev.power.power_state = state; 1775 return retval; 1776 } 1777 1778 static int 1779 sl811h_resume(struct platform_device *dev) 1780 { 1781 struct usb_hcd *hcd = platform_get_drvdata(dev); 1782 struct sl811 *sl811 = hcd_to_sl811(hcd); 1783 1784 /* with no "check to see if VBUS is still powered" board hook, 1785 * let's assume it'd only be powered to enable remote wakeup. 1786 */ 1787 if (dev->dev.power.power_state.event == PM_EVENT_SUSPEND 1788 || !device_can_wakeup(&hcd->self.root_hub->dev)) { 1789 sl811->port1 = 0; 1790 port_power(sl811, 1); 1791 usb_root_hub_lost_power(hcd->self.root_hub); 1792 return 0; 1793 } 1794 1795 dev->dev.power.power_state = PMSG_ON; 1796 return sl811h_bus_resume(hcd); 1797 } 1798 1799 #else 1800 1801 #define sl811h_suspend NULL 1802 #define sl811h_resume NULL 1803 1804 #endif 1805 1806 1807 /* this driver is exported so sl811_cs can depend on it */ 1808 struct platform_driver sl811h_driver = { 1809 .probe = sl811h_probe, 1810 .remove = __devexit_p(sl811h_remove), 1811 1812 .suspend = sl811h_suspend, 1813 .resume = sl811h_resume, 1814 .driver = { 1815 .name = (char *) hcd_name, 1816 .owner = THIS_MODULE, 1817 }, 1818 }; 1819 EXPORT_SYMBOL(sl811h_driver); 1820 1821 /*-------------------------------------------------------------------------*/ 1822 1823 static int __init sl811h_init(void) 1824 { 1825 if (usb_disabled()) 1826 return -ENODEV; 1827 1828 INFO("driver %s, %s\n", hcd_name, DRIVER_VERSION); 1829 return platform_driver_register(&sl811h_driver); 1830 } 1831 module_init(sl811h_init); 1832 1833 static void __exit sl811h_cleanup(void) 1834 { 1835 platform_driver_unregister(&sl811h_driver); 1836 } 1837 module_exit(sl811h_cleanup); 1838