1/* ----------------------------------------------------------------------------- 2 * Copyright (c) 2011 Ozmo Inc 3 * Released under the GNU General Public License Version 2 (GPLv2). 4 * 5 * This file provides the implementation of a USB host controller device that 6 * does not have any associated hardware. Instead the virtual device is 7 * connected to the WiFi network and emulates the operation of a USB hcd by 8 * receiving and sending network frames. 9 * Note: 10 * We take great pains to reduce the amount of code where interrupts need to be 11 * disabled and in this respect we are different from standard HCD's. In 12 * particular we don't want in_irq() code bleeding over to the protocol side of 13 * the driver. 14 * The troublesome functions are the urb enqueue and dequeue functions both of 15 * which can be called in_irq(). So for these functions we put the urbs into a 16 * queue and request a tasklet to process them. This means that a spinlock with 17 * interrupts disabled must be held for insertion and removal but most code is 18 * is in tasklet or soft irq context. The lock that protects this list is called 19 * the tasklet lock and serves the purpose of the 'HCD lock' which must be held 20 * when calling the following functions. 21 * usb_hcd_link_urb_to_ep() 22 * usb_hcd_unlink_urb_from_ep() 23 * usb_hcd_flush_endpoint() 24 * usb_hcd_check_unlink_urb() 25 * ----------------------------------------------------------------------------- 26 */ 27#include <linux/platform_device.h> 28#include <linux/usb.h> 29#include <linux/slab.h> 30#include <linux/export.h> 31#include "linux/usb/hcd.h" 32#include <asm/unaligned.h> 33#include "ozdbg.h" 34#include "ozusbif.h" 35#include "ozurbparanoia.h" 36#include "ozhcd.h" 37 38/* 39 * Number of units of buffering to capture for an isochronous IN endpoint before 40 * allowing data to be indicated up. 41 */ 42#define OZ_IN_BUFFERING_UNITS 100 43 44/* Name of our platform device. 45 */ 46#define OZ_PLAT_DEV_NAME "ozwpan" 47 48/*EP0 timeout before ep0 request is again added to TX queue. (13*8 = 98mSec) 49 */ 50#define EP0_TIMEOUT_COUNTER 13 51 52/* Debounce time HCD driver should wait before unregistering. 53 */ 54#define OZ_HUB_DEBOUNCE_TIMEOUT 1500 55 56/* 57 * Used to link urbs together and also store some status information for each 58 * urb. 59 * A cache of these are kept in a pool to reduce number of calls to kmalloc. 60 */ 61struct oz_urb_link { 62 struct list_head link; 63 struct urb *urb; 64 struct oz_port *port; 65 u8 req_id; 66 u8 ep_num; 67 unsigned submit_counter; 68}; 69 70static struct kmem_cache *oz_urb_link_cache; 71 72/* Holds state information about a USB endpoint. 73 */ 74#define OZ_EP_BUFFER_SIZE_ISOC (1024 * 24) 75#define OZ_EP_BUFFER_SIZE_INT 512 76struct oz_endpoint { 77 struct list_head urb_list; /* List of oz_urb_link items. */ 78 struct list_head link; /* For isoc ep, links in to isoc 79 lists of oz_port. */ 80 struct timespec timestamp; 81 int credit; 82 int credit_ceiling; 83 u8 ep_num; 84 u8 attrib; 85 u8 *buffer; 86 int buffer_size; 87 int in_ix; 88 int out_ix; 89 int buffered_units; 90 unsigned flags; 91 int start_frame; 92}; 93 94/* Bits in the flags field. */ 95#define OZ_F_EP_BUFFERING 0x1 96#define OZ_F_EP_HAVE_STREAM 0x2 97 98/* Holds state information about a USB interface. 99 */ 100struct oz_interface { 101 unsigned ep_mask; 102 u8 alt; 103}; 104 105/* Holds state information about an hcd port. 106 */ 107#define OZ_NB_ENDPOINTS 16 108struct oz_port { 109 unsigned flags; 110 unsigned status; 111 void *hpd; 112 struct oz_hcd *ozhcd; 113 spinlock_t port_lock; 114 u8 bus_addr; 115 u8 next_req_id; 116 u8 config_num; 117 int num_iface; 118 struct oz_interface *iface; 119 struct oz_endpoint *out_ep[OZ_NB_ENDPOINTS]; 120 struct oz_endpoint *in_ep[OZ_NB_ENDPOINTS]; 121 struct list_head isoc_out_ep; 122 struct list_head isoc_in_ep; 123}; 124 125#define OZ_PORT_F_PRESENT 0x1 126#define OZ_PORT_F_CHANGED 0x2 127#define OZ_PORT_F_DYING 0x4 128 129/* Data structure in the private context area of struct usb_hcd. 130 */ 131#define OZ_NB_PORTS 8 132struct oz_hcd { 133 spinlock_t hcd_lock; 134 struct list_head urb_pending_list; 135 struct list_head urb_cancel_list; 136 struct list_head orphanage; 137 int conn_port; /* Port that is currently connecting, -1 if none.*/ 138 struct oz_port ports[OZ_NB_PORTS]; 139 uint flags; 140 struct usb_hcd *hcd; 141}; 142 143/* Bits in flags field. 144 */ 145#define OZ_HDC_F_SUSPENDED 0x1 146 147/* 148 * Static function prototypes. 149 */ 150static int oz_hcd_start(struct usb_hcd *hcd); 151static void oz_hcd_stop(struct usb_hcd *hcd); 152static void oz_hcd_shutdown(struct usb_hcd *hcd); 153static int oz_hcd_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, 154 gfp_t mem_flags); 155static int oz_hcd_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status); 156static void oz_hcd_endpoint_disable(struct usb_hcd *hcd, 157 struct usb_host_endpoint *ep); 158static void oz_hcd_endpoint_reset(struct usb_hcd *hcd, 159 struct usb_host_endpoint *ep); 160static int oz_hcd_get_frame_number(struct usb_hcd *hcd); 161static int oz_hcd_hub_status_data(struct usb_hcd *hcd, char *buf); 162static int oz_hcd_hub_control(struct usb_hcd *hcd, u16 req_type, u16 wvalue, 163 u16 windex, char *buf, u16 wlength); 164static int oz_hcd_bus_suspend(struct usb_hcd *hcd); 165static int oz_hcd_bus_resume(struct usb_hcd *hcd); 166static int oz_plat_probe(struct platform_device *dev); 167static int oz_plat_remove(struct platform_device *dev); 168static void oz_plat_shutdown(struct platform_device *dev); 169static int oz_plat_suspend(struct platform_device *dev, pm_message_t msg); 170static int oz_plat_resume(struct platform_device *dev); 171static void oz_urb_process_tasklet(unsigned long unused); 172static int oz_build_endpoints_for_config(struct usb_hcd *hcd, 173 struct oz_port *port, struct usb_host_config *config, 174 gfp_t mem_flags); 175static void oz_clean_endpoints_for_config(struct usb_hcd *hcd, 176 struct oz_port *port); 177static int oz_build_endpoints_for_interface(struct usb_hcd *hcd, 178 struct oz_port *port, 179 struct usb_host_interface *intf, gfp_t mem_flags); 180static void oz_clean_endpoints_for_interface(struct usb_hcd *hcd, 181 struct oz_port *port, int if_ix); 182static void oz_process_ep0_urb(struct oz_hcd *ozhcd, struct urb *urb, 183 gfp_t mem_flags); 184static struct oz_urb_link *oz_remove_urb(struct oz_endpoint *ep, 185 struct urb *urb); 186static void oz_hcd_clear_orphanage(struct oz_hcd *ozhcd, int status); 187 188/* 189 * Static external variables. 190 */ 191static struct platform_device *g_plat_dev; 192static struct oz_hcd *g_ozhcd; 193static DEFINE_SPINLOCK(g_hcdlock); /* Guards g_ozhcd. */ 194static const char g_hcd_name[] = "Ozmo WPAN"; 195static DEFINE_SPINLOCK(g_tasklet_lock); 196static struct tasklet_struct g_urb_process_tasklet; 197static struct tasklet_struct g_urb_cancel_tasklet; 198static atomic_t g_pending_urbs = ATOMIC_INIT(0); 199static atomic_t g_usb_frame_number = ATOMIC_INIT(0); 200static const struct hc_driver g_oz_hc_drv = { 201 .description = g_hcd_name, 202 .product_desc = "Ozmo Devices WPAN", 203 .hcd_priv_size = sizeof(struct oz_hcd), 204 .flags = HCD_USB11, 205 .start = oz_hcd_start, 206 .stop = oz_hcd_stop, 207 .shutdown = oz_hcd_shutdown, 208 .urb_enqueue = oz_hcd_urb_enqueue, 209 .urb_dequeue = oz_hcd_urb_dequeue, 210 .endpoint_disable = oz_hcd_endpoint_disable, 211 .endpoint_reset = oz_hcd_endpoint_reset, 212 .get_frame_number = oz_hcd_get_frame_number, 213 .hub_status_data = oz_hcd_hub_status_data, 214 .hub_control = oz_hcd_hub_control, 215 .bus_suspend = oz_hcd_bus_suspend, 216 .bus_resume = oz_hcd_bus_resume, 217}; 218 219static struct platform_driver g_oz_plat_drv = { 220 .probe = oz_plat_probe, 221 .remove = oz_plat_remove, 222 .shutdown = oz_plat_shutdown, 223 .suspend = oz_plat_suspend, 224 .resume = oz_plat_resume, 225 .driver = { 226 .name = OZ_PLAT_DEV_NAME, 227 .owner = THIS_MODULE, 228 }, 229}; 230 231/* 232 * Gets our private context area (which is of type struct oz_hcd) from the 233 * usb_hcd structure. 234 * Context: any 235 */ 236static inline struct oz_hcd *oz_hcd_private(struct usb_hcd *hcd) 237{ 238 return (struct oz_hcd *)hcd->hcd_priv; 239} 240 241/* 242 * Searches list of ports to find the index of the one with a specified USB 243 * bus address. If none of the ports has the bus address then the connection 244 * port is returned, if there is one or -1 otherwise. 245 * Context: any 246 */ 247static int oz_get_port_from_addr(struct oz_hcd *ozhcd, u8 bus_addr) 248{ 249 int i; 250 251 for (i = 0; i < OZ_NB_PORTS; i++) { 252 if (ozhcd->ports[i].bus_addr == bus_addr) 253 return i; 254 } 255 return ozhcd->conn_port; 256} 257 258/* 259 * Context: any 260 */ 261static struct oz_urb_link *oz_alloc_urb_link(void) 262{ 263 return kmem_cache_alloc(oz_urb_link_cache, GFP_ATOMIC); 264} 265 266/* 267 * Context: any 268 */ 269static void oz_free_urb_link(struct oz_urb_link *urbl) 270{ 271 if (!urbl) 272 return; 273 274 kmem_cache_free(oz_urb_link_cache, urbl); 275} 276 277/* 278 * Allocates endpoint structure and optionally a buffer. If a buffer is 279 * allocated it immediately follows the endpoint structure. 280 * Context: softirq 281 */ 282static struct oz_endpoint *oz_ep_alloc(int buffer_size, gfp_t mem_flags) 283{ 284 struct oz_endpoint *ep = 285 kzalloc(sizeof(struct oz_endpoint)+buffer_size, mem_flags); 286 if (ep) { 287 INIT_LIST_HEAD(&ep->urb_list); 288 INIT_LIST_HEAD(&ep->link); 289 ep->credit = -1; 290 if (buffer_size) { 291 ep->buffer_size = buffer_size; 292 ep->buffer = (u8 *)(ep+1); 293 } 294 } 295 return ep; 296} 297 298/* 299 * Pre-condition: Must be called with g_tasklet_lock held and interrupts 300 * disabled. 301 * Context: softirq or process 302 */ 303static struct oz_urb_link *oz_uncancel_urb(struct oz_hcd *ozhcd, 304 struct urb *urb) 305{ 306 struct oz_urb_link *urbl; 307 308 list_for_each_entry(urbl, &ozhcd->urb_cancel_list, link) { 309 if (urb == urbl->urb) { 310 list_del_init(&urbl->link); 311 return urbl; 312 } 313 } 314 return NULL; 315} 316 317/* 318 * This is called when we have finished processing an urb. It unlinks it from 319 * the ep and returns it to the core. 320 * Context: softirq or process 321 */ 322static void oz_complete_urb(struct usb_hcd *hcd, struct urb *urb, 323 int status) 324{ 325 struct oz_hcd *ozhcd = oz_hcd_private(hcd); 326 unsigned long irq_state; 327 struct oz_urb_link *cancel_urbl; 328 329 spin_lock_irqsave(&g_tasklet_lock, irq_state); 330 usb_hcd_unlink_urb_from_ep(hcd, urb); 331 /* Clear hcpriv which will prevent it being put in the cancel list 332 * in the event that an attempt is made to cancel it. 333 */ 334 urb->hcpriv = NULL; 335 /* Walk the cancel list in case the urb is already sitting there. 336 * Since we process the cancel list in a tasklet rather than in 337 * the dequeue function this could happen. 338 */ 339 cancel_urbl = oz_uncancel_urb(ozhcd, urb); 340 /* Note: we release lock but do not enable local irqs. 341 * It appears that usb_hcd_giveback_urb() expects irqs to be disabled, 342 * or at least other host controllers disable interrupts at this point 343 * so we do the same. We must, however, release the lock otherwise a 344 * deadlock will occur if an urb is submitted to our driver in the urb 345 * completion function. Because we disable interrupts it is possible 346 * that the urb_enqueue function can be called with them disabled. 347 */ 348 spin_unlock(&g_tasklet_lock); 349 if (oz_forget_urb(urb)) { 350 oz_dbg(ON, "ERROR Unknown URB %p\n", urb); 351 } else { 352 atomic_dec(&g_pending_urbs); 353 usb_hcd_giveback_urb(hcd, urb, status); 354 } 355 spin_lock(&g_tasklet_lock); 356 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 357 if (cancel_urbl) 358 oz_free_urb_link(cancel_urbl); 359} 360 361/* 362 * Deallocates an endpoint including deallocating any associated stream and 363 * returning any queued urbs to the core. 364 * Context: softirq 365 */ 366static void oz_ep_free(struct oz_port *port, struct oz_endpoint *ep) 367{ 368 if (port) { 369 LIST_HEAD(list); 370 struct oz_hcd *ozhcd = port->ozhcd; 371 372 if (ep->flags & OZ_F_EP_HAVE_STREAM) 373 oz_usb_stream_delete(port->hpd, ep->ep_num); 374 /* Transfer URBs to the orphanage while we hold the lock. */ 375 spin_lock_bh(&ozhcd->hcd_lock); 376 /* Note: this works even if ep->urb_list is empty.*/ 377 list_replace_init(&ep->urb_list, &list); 378 /* Put the URBs in the orphanage. */ 379 list_splice_tail(&list, &ozhcd->orphanage); 380 spin_unlock_bh(&ozhcd->hcd_lock); 381 } 382 oz_dbg(ON, "Freeing endpoint memory\n"); 383 kfree(ep); 384} 385 386/* 387 * Context: softirq 388 */ 389static void oz_complete_buffered_urb(struct oz_port *port, 390 struct oz_endpoint *ep, 391 struct urb *urb) 392{ 393 int data_len, available_space, copy_len; 394 395 data_len = ep->buffer[ep->out_ix]; 396 if (data_len <= urb->transfer_buffer_length) 397 available_space = data_len; 398 else 399 available_space = urb->transfer_buffer_length; 400 401 if (++ep->out_ix == ep->buffer_size) 402 ep->out_ix = 0; 403 copy_len = ep->buffer_size - ep->out_ix; 404 if (copy_len >= available_space) 405 copy_len = available_space; 406 memcpy(urb->transfer_buffer, &ep->buffer[ep->out_ix], copy_len); 407 408 if (copy_len < available_space) { 409 memcpy((urb->transfer_buffer + copy_len), ep->buffer, 410 (available_space - copy_len)); 411 ep->out_ix = available_space - copy_len; 412 } else { 413 ep->out_ix += copy_len; 414 } 415 urb->actual_length = available_space; 416 if (ep->out_ix == ep->buffer_size) 417 ep->out_ix = 0; 418 419 ep->buffered_units--; 420 oz_dbg(ON, "Trying to give back buffered frame of size=%d\n", 421 available_space); 422 oz_complete_urb(port->ozhcd->hcd, urb, 0); 423} 424 425/* 426 * Context: softirq 427 */ 428static int oz_enqueue_ep_urb(struct oz_port *port, u8 ep_addr, int in_dir, 429 struct urb *urb, u8 req_id) 430{ 431 struct oz_urb_link *urbl; 432 struct oz_endpoint *ep = NULL; 433 int err = 0; 434 435 if (ep_addr >= OZ_NB_ENDPOINTS) { 436 oz_dbg(ON, "%s: Invalid endpoint number\n", __func__); 437 return -EINVAL; 438 } 439 urbl = oz_alloc_urb_link(); 440 if (!urbl) 441 return -ENOMEM; 442 urbl->submit_counter = 0; 443 urbl->urb = urb; 444 urbl->req_id = req_id; 445 urbl->ep_num = ep_addr; 446 /* Hold lock while we insert the URB into the list within the 447 * endpoint structure. 448 */ 449 spin_lock_bh(&port->ozhcd->hcd_lock); 450 /* If the urb has been unlinked while out of any list then 451 * complete it now. 452 */ 453 if (urb->unlinked) { 454 spin_unlock_bh(&port->ozhcd->hcd_lock); 455 oz_dbg(ON, "urb %p unlinked so complete immediately\n", urb); 456 oz_complete_urb(port->ozhcd->hcd, urb, 0); 457 oz_free_urb_link(urbl); 458 return 0; 459 } 460 461 if (in_dir) 462 ep = port->in_ep[ep_addr]; 463 else 464 ep = port->out_ep[ep_addr]; 465 if (!ep) { 466 err = -ENOMEM; 467 goto out; 468 } 469 470 /*For interrupt endpoint check for buffered data 471 * & complete urb 472 */ 473 if (((ep->attrib & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) 474 && ep->buffered_units > 0) { 475 oz_free_urb_link(urbl); 476 spin_unlock_bh(&port->ozhcd->hcd_lock); 477 oz_complete_buffered_urb(port, ep, urb); 478 return 0; 479 } 480 481 if (port->hpd) { 482 list_add_tail(&urbl->link, &ep->urb_list); 483 if (!in_dir && ep_addr && (ep->credit < 0)) { 484 getrawmonotonic(&ep->timestamp); 485 ep->credit = 0; 486 } 487 } else { 488 err = -EPIPE; 489 } 490out: 491 spin_unlock_bh(&port->ozhcd->hcd_lock); 492 if (err) 493 oz_free_urb_link(urbl); 494 return err; 495} 496 497/* 498 * Removes an urb from the queue in the endpoint. 499 * Returns 0 if it is found and -EIDRM otherwise. 500 * Context: softirq 501 */ 502static int oz_dequeue_ep_urb(struct oz_port *port, u8 ep_addr, int in_dir, 503 struct urb *urb) 504{ 505 struct oz_urb_link *urbl = NULL; 506 struct oz_endpoint *ep; 507 508 spin_lock_bh(&port->ozhcd->hcd_lock); 509 if (in_dir) 510 ep = port->in_ep[ep_addr]; 511 else 512 ep = port->out_ep[ep_addr]; 513 if (ep) { 514 struct list_head *e; 515 516 list_for_each(e, &ep->urb_list) { 517 urbl = list_entry(e, struct oz_urb_link, link); 518 if (urbl->urb == urb) { 519 list_del_init(e); 520 break; 521 } 522 urbl = NULL; 523 } 524 } 525 spin_unlock_bh(&port->ozhcd->hcd_lock); 526 if (urbl) 527 oz_free_urb_link(urbl); 528 return urbl ? 0 : -EIDRM; 529} 530 531/* 532 * Finds an urb given its request id. 533 * Context: softirq 534 */ 535static struct urb *oz_find_urb_by_id(struct oz_port *port, int ep_ix, 536 u8 req_id) 537{ 538 struct oz_hcd *ozhcd = port->ozhcd; 539 struct urb *urb = NULL; 540 struct oz_urb_link *urbl; 541 struct oz_endpoint *ep; 542 543 spin_lock_bh(&ozhcd->hcd_lock); 544 ep = port->out_ep[ep_ix]; 545 if (ep) { 546 struct list_head *e; 547 548 list_for_each(e, &ep->urb_list) { 549 urbl = list_entry(e, struct oz_urb_link, link); 550 if (urbl->req_id == req_id) { 551 urb = urbl->urb; 552 list_del_init(e); 553 break; 554 } 555 } 556 } 557 spin_unlock_bh(&ozhcd->hcd_lock); 558 /* If urb is non-zero then we we must have an urb link to delete. 559 */ 560 if (urb) 561 oz_free_urb_link(urbl); 562 return urb; 563} 564 565/* 566 * Pre-condition: Port lock must be held. 567 * Context: softirq 568 */ 569static void oz_acquire_port(struct oz_port *port, void *hpd) 570{ 571 INIT_LIST_HEAD(&port->isoc_out_ep); 572 INIT_LIST_HEAD(&port->isoc_in_ep); 573 port->flags |= OZ_PORT_F_PRESENT | OZ_PORT_F_CHANGED; 574 port->status |= USB_PORT_STAT_CONNECTION | 575 (USB_PORT_STAT_C_CONNECTION << 16); 576 oz_usb_get(hpd); 577 port->hpd = hpd; 578} 579 580/* 581 * Context: softirq 582 */ 583static struct oz_hcd *oz_hcd_claim(void) 584{ 585 struct oz_hcd *ozhcd; 586 587 spin_lock_bh(&g_hcdlock); 588 ozhcd = g_ozhcd; 589 if (ozhcd) 590 usb_get_hcd(ozhcd->hcd); 591 spin_unlock_bh(&g_hcdlock); 592 return ozhcd; 593} 594 595/* 596 * Context: softirq 597 */ 598static inline void oz_hcd_put(struct oz_hcd *ozhcd) 599{ 600 if (ozhcd) 601 usb_put_hcd(ozhcd->hcd); 602} 603 604/* 605 * This is called by the protocol handler to notify that a PD has arrived. 606 * We allocate a port to associate with the PD and create a structure for 607 * endpoint 0. This port is made the connection port. 608 * In the event that one of the other port is already a connection port then 609 * we fail. 610 * TODO We should be able to do better than fail and should be able remember 611 * that this port needs configuring and make it the connection port once the 612 * current connection port has been assigned an address. Collisions here are 613 * probably very rare indeed. 614 * Context: softirq 615 */ 616struct oz_port *oz_hcd_pd_arrived(void *hpd) 617{ 618 int i; 619 struct oz_port *hport; 620 struct oz_hcd *ozhcd; 621 struct oz_endpoint *ep; 622 623 ozhcd = oz_hcd_claim(); 624 if (!ozhcd) 625 return NULL; 626 /* Allocate an endpoint object in advance (before holding hcd lock) to 627 * use for out endpoint 0. 628 */ 629 ep = oz_ep_alloc(0, GFP_ATOMIC); 630 if (!ep) 631 goto err_put; 632 633 spin_lock_bh(&ozhcd->hcd_lock); 634 if (ozhcd->conn_port >= 0) 635 goto err_unlock; 636 637 for (i = 0; i < OZ_NB_PORTS; i++) { 638 struct oz_port *port = &ozhcd->ports[i]; 639 640 spin_lock(&port->port_lock); 641 if (!(port->flags & (OZ_PORT_F_PRESENT | OZ_PORT_F_CHANGED))) { 642 oz_acquire_port(port, hpd); 643 spin_unlock(&port->port_lock); 644 break; 645 } 646 spin_unlock(&port->port_lock); 647 } 648 if (i == OZ_NB_PORTS) 649 goto err_unlock; 650 651 ozhcd->conn_port = i; 652 hport = &ozhcd->ports[i]; 653 hport->out_ep[0] = ep; 654 spin_unlock_bh(&ozhcd->hcd_lock); 655 if (ozhcd->flags & OZ_HDC_F_SUSPENDED) 656 usb_hcd_resume_root_hub(ozhcd->hcd); 657 usb_hcd_poll_rh_status(ozhcd->hcd); 658 oz_hcd_put(ozhcd); 659 660 return hport; 661 662err_unlock: 663 spin_unlock_bh(&ozhcd->hcd_lock); 664 oz_ep_free(NULL, ep); 665err_put: 666 oz_hcd_put(ozhcd); 667 return NULL; 668} 669 670/* 671 * This is called by the protocol handler to notify that the PD has gone away. 672 * We need to deallocate all resources and then request that the root hub is 673 * polled. We release the reference we hold on the PD. 674 * Context: softirq 675 */ 676void oz_hcd_pd_departed(struct oz_port *port) 677{ 678 struct oz_hcd *ozhcd; 679 void *hpd; 680 struct oz_endpoint *ep = NULL; 681 682 if (port == NULL) { 683 oz_dbg(ON, "%s: port = 0\n", __func__); 684 return; 685 } 686 ozhcd = port->ozhcd; 687 if (ozhcd == NULL) 688 return; 689 /* Check if this is the connection port - if so clear it. 690 */ 691 spin_lock_bh(&ozhcd->hcd_lock); 692 if ((ozhcd->conn_port >= 0) && 693 (port == &ozhcd->ports[ozhcd->conn_port])) { 694 oz_dbg(ON, "Clearing conn_port\n"); 695 ozhcd->conn_port = -1; 696 } 697 spin_lock(&port->port_lock); 698 port->flags |= OZ_PORT_F_DYING; 699 spin_unlock(&port->port_lock); 700 spin_unlock_bh(&ozhcd->hcd_lock); 701 702 oz_clean_endpoints_for_config(ozhcd->hcd, port); 703 spin_lock_bh(&port->port_lock); 704 hpd = port->hpd; 705 port->hpd = NULL; 706 port->bus_addr = 0xff; 707 port->config_num = 0; 708 port->flags &= ~(OZ_PORT_F_PRESENT | OZ_PORT_F_DYING); 709 port->flags |= OZ_PORT_F_CHANGED; 710 port->status &= ~(USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE); 711 port->status |= (USB_PORT_STAT_C_CONNECTION << 16); 712 /* If there is an endpont 0 then clear the pointer while we hold 713 * the spinlock be we deallocate it after releasing the lock. 714 */ 715 if (port->out_ep[0]) { 716 ep = port->out_ep[0]; 717 port->out_ep[0] = NULL; 718 } 719 spin_unlock_bh(&port->port_lock); 720 if (ep) 721 oz_ep_free(port, ep); 722 usb_hcd_poll_rh_status(ozhcd->hcd); 723 oz_usb_put(hpd); 724} 725 726/* 727 * Context: softirq 728 */ 729void oz_hcd_pd_reset(void *hpd, void *hport) 730{ 731 /* Cleanup the current configuration and report reset to the core. 732 */ 733 struct oz_port *port = (struct oz_port *)hport; 734 struct oz_hcd *ozhcd = port->ozhcd; 735 736 oz_dbg(ON, "PD Reset\n"); 737 spin_lock_bh(&port->port_lock); 738 port->flags |= OZ_PORT_F_CHANGED; 739 port->status |= USB_PORT_STAT_RESET; 740 port->status |= (USB_PORT_STAT_C_RESET << 16); 741 spin_unlock_bh(&port->port_lock); 742 oz_clean_endpoints_for_config(ozhcd->hcd, port); 743 usb_hcd_poll_rh_status(ozhcd->hcd); 744} 745 746/* 747 * Context: softirq 748 */ 749void oz_hcd_get_desc_cnf(void *hport, u8 req_id, int status, const u8 *desc, 750 int length, int offset, int total_size) 751{ 752 struct oz_port *port = (struct oz_port *)hport; 753 struct urb *urb; 754 int err = 0; 755 756 oz_dbg(ON, "oz_hcd_get_desc_cnf length = %d offs = %d tot_size = %d\n", 757 length, offset, total_size); 758 urb = oz_find_urb_by_id(port, 0, req_id); 759 if (!urb) 760 return; 761 if (status == 0) { 762 int copy_len; 763 int required_size = urb->transfer_buffer_length; 764 765 if (required_size > total_size) 766 required_size = total_size; 767 copy_len = required_size-offset; 768 if (length <= copy_len) 769 copy_len = length; 770 memcpy(urb->transfer_buffer+offset, desc, copy_len); 771 offset += copy_len; 772 if (offset < required_size) { 773 struct usb_ctrlrequest *setup = 774 (struct usb_ctrlrequest *)urb->setup_packet; 775 unsigned wvalue = le16_to_cpu(setup->wValue); 776 777 if (oz_enqueue_ep_urb(port, 0, 0, urb, req_id)) 778 err = -ENOMEM; 779 else if (oz_usb_get_desc_req(port->hpd, req_id, 780 setup->bRequestType, (u8)(wvalue>>8), 781 (u8)wvalue, setup->wIndex, offset, 782 required_size-offset)) { 783 oz_dequeue_ep_urb(port, 0, 0, urb); 784 err = -ENOMEM; 785 } 786 if (err == 0) 787 return; 788 } 789 } 790 urb->actual_length = total_size; 791 oz_complete_urb(port->ozhcd->hcd, urb, 0); 792} 793 794/* 795 * Context: softirq 796 */ 797static void oz_display_conf_type(u8 t) 798{ 799 switch (t) { 800 case USB_REQ_GET_STATUS: 801 oz_dbg(ON, "USB_REQ_GET_STATUS - cnf\n"); 802 break; 803 case USB_REQ_CLEAR_FEATURE: 804 oz_dbg(ON, "USB_REQ_CLEAR_FEATURE - cnf\n"); 805 break; 806 case USB_REQ_SET_FEATURE: 807 oz_dbg(ON, "USB_REQ_SET_FEATURE - cnf\n"); 808 break; 809 case USB_REQ_SET_ADDRESS: 810 oz_dbg(ON, "USB_REQ_SET_ADDRESS - cnf\n"); 811 break; 812 case USB_REQ_GET_DESCRIPTOR: 813 oz_dbg(ON, "USB_REQ_GET_DESCRIPTOR - cnf\n"); 814 break; 815 case USB_REQ_SET_DESCRIPTOR: 816 oz_dbg(ON, "USB_REQ_SET_DESCRIPTOR - cnf\n"); 817 break; 818 case USB_REQ_GET_CONFIGURATION: 819 oz_dbg(ON, "USB_REQ_GET_CONFIGURATION - cnf\n"); 820 break; 821 case USB_REQ_SET_CONFIGURATION: 822 oz_dbg(ON, "USB_REQ_SET_CONFIGURATION - cnf\n"); 823 break; 824 case USB_REQ_GET_INTERFACE: 825 oz_dbg(ON, "USB_REQ_GET_INTERFACE - cnf\n"); 826 break; 827 case USB_REQ_SET_INTERFACE: 828 oz_dbg(ON, "USB_REQ_SET_INTERFACE - cnf\n"); 829 break; 830 case USB_REQ_SYNCH_FRAME: 831 oz_dbg(ON, "USB_REQ_SYNCH_FRAME - cnf\n"); 832 break; 833 } 834} 835 836/* 837 * Context: softirq 838 */ 839static void oz_hcd_complete_set_config(struct oz_port *port, struct urb *urb, 840 u8 rcode, u8 config_num) 841{ 842 int rc = 0; 843 struct usb_hcd *hcd = port->ozhcd->hcd; 844 845 if (rcode == 0) { 846 port->config_num = config_num; 847 oz_clean_endpoints_for_config(hcd, port); 848 if (oz_build_endpoints_for_config(hcd, port, 849 &urb->dev->config[port->config_num-1], GFP_ATOMIC)) { 850 rc = -ENOMEM; 851 } 852 } else { 853 rc = -ENOMEM; 854 } 855 oz_complete_urb(hcd, urb, rc); 856} 857 858/* 859 * Context: softirq 860 */ 861static void oz_hcd_complete_set_interface(struct oz_port *port, struct urb *urb, 862 u8 rcode, u8 if_num, u8 alt) 863{ 864 struct usb_hcd *hcd = port->ozhcd->hcd; 865 int rc = 0; 866 867 if ((rcode == 0) && (port->config_num > 0)) { 868 struct usb_host_config *config; 869 struct usb_host_interface *intf; 870 871 oz_dbg(ON, "Set interface %d alt %d\n", if_num, alt); 872 oz_clean_endpoints_for_interface(hcd, port, if_num); 873 config = &urb->dev->config[port->config_num-1]; 874 intf = &config->intf_cache[if_num]->altsetting[alt]; 875 if (oz_build_endpoints_for_interface(hcd, port, intf, 876 GFP_ATOMIC)) 877 rc = -ENOMEM; 878 else 879 port->iface[if_num].alt = alt; 880 } else { 881 rc = -ENOMEM; 882 } 883 oz_complete_urb(hcd, urb, rc); 884} 885 886/* 887 * Context: softirq 888 */ 889void oz_hcd_control_cnf(void *hport, u8 req_id, u8 rcode, const u8 *data, 890 int data_len) 891{ 892 struct oz_port *port = (struct oz_port *)hport; 893 struct urb *urb; 894 struct usb_ctrlrequest *setup; 895 struct usb_hcd *hcd = port->ozhcd->hcd; 896 unsigned windex; 897 unsigned wvalue; 898 899 oz_dbg(ON, "oz_hcd_control_cnf rcode=%u len=%d\n", rcode, data_len); 900 urb = oz_find_urb_by_id(port, 0, req_id); 901 if (!urb) { 902 oz_dbg(ON, "URB not found\n"); 903 return; 904 } 905 setup = (struct usb_ctrlrequest *)urb->setup_packet; 906 windex = le16_to_cpu(setup->wIndex); 907 wvalue = le16_to_cpu(setup->wValue); 908 if ((setup->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) { 909 /* Standard requests */ 910 oz_display_conf_type(setup->bRequest); 911 switch (setup->bRequest) { 912 case USB_REQ_SET_CONFIGURATION: 913 oz_hcd_complete_set_config(port, urb, rcode, 914 (u8)wvalue); 915 break; 916 case USB_REQ_SET_INTERFACE: 917 oz_hcd_complete_set_interface(port, urb, rcode, 918 (u8)windex, (u8)wvalue); 919 break; 920 default: 921 oz_complete_urb(hcd, urb, 0); 922 } 923 924 } else { 925 int copy_len; 926 927 oz_dbg(ON, "VENDOR-CLASS - cnf\n"); 928 if (data_len) { 929 if (data_len <= urb->transfer_buffer_length) 930 copy_len = data_len; 931 else 932 copy_len = urb->transfer_buffer_length; 933 memcpy(urb->transfer_buffer, data, copy_len); 934 urb->actual_length = copy_len; 935 } 936 oz_complete_urb(hcd, urb, 0); 937 } 938} 939 940/* 941 * Context: softirq-serialized 942 */ 943static int oz_hcd_buffer_data(struct oz_endpoint *ep, const u8 *data, 944 int data_len) 945{ 946 int space; 947 int copy_len; 948 949 if (!ep->buffer) 950 return -1; 951 space = ep->out_ix-ep->in_ix-1; 952 if (space < 0) 953 space += ep->buffer_size; 954 if (space < (data_len+1)) { 955 oz_dbg(ON, "Buffer full\n"); 956 return -1; 957 } 958 ep->buffer[ep->in_ix] = (u8)data_len; 959 if (++ep->in_ix == ep->buffer_size) 960 ep->in_ix = 0; 961 copy_len = ep->buffer_size - ep->in_ix; 962 if (copy_len > data_len) 963 copy_len = data_len; 964 memcpy(&ep->buffer[ep->in_ix], data, copy_len); 965 966 if (copy_len < data_len) { 967 memcpy(ep->buffer, data+copy_len, data_len-copy_len); 968 ep->in_ix = data_len-copy_len; 969 } else { 970 ep->in_ix += copy_len; 971 } 972 if (ep->in_ix == ep->buffer_size) 973 ep->in_ix = 0; 974 ep->buffered_units++; 975 return 0; 976} 977 978/* 979 * Context: softirq-serialized 980 */ 981void oz_hcd_data_ind(void *hport, u8 endpoint, const u8 *data, int data_len) 982{ 983 struct oz_port *port = (struct oz_port *)hport; 984 struct oz_endpoint *ep; 985 struct oz_hcd *ozhcd = port->ozhcd; 986 987 spin_lock_bh(&ozhcd->hcd_lock); 988 ep = port->in_ep[endpoint & USB_ENDPOINT_NUMBER_MASK]; 989 if (ep == NULL) 990 goto done; 991 switch (ep->attrib & USB_ENDPOINT_XFERTYPE_MASK) { 992 case USB_ENDPOINT_XFER_INT: 993 case USB_ENDPOINT_XFER_BULK: 994 if (!list_empty(&ep->urb_list)) { 995 struct oz_urb_link *urbl = 996 list_first_entry(&ep->urb_list, 997 struct oz_urb_link, link); 998 struct urb *urb; 999 int copy_len; 1000 1001 list_del_init(&urbl->link); 1002 spin_unlock_bh(&ozhcd->hcd_lock); 1003 urb = urbl->urb; 1004 oz_free_urb_link(urbl); 1005 if (data_len <= urb->transfer_buffer_length) 1006 copy_len = data_len; 1007 else 1008 copy_len = urb->transfer_buffer_length; 1009 memcpy(urb->transfer_buffer, data, copy_len); 1010 urb->actual_length = copy_len; 1011 oz_complete_urb(port->ozhcd->hcd, urb, 0); 1012 return; 1013 } 1014 oz_dbg(ON, "buffering frame as URB is not available\n"); 1015 oz_hcd_buffer_data(ep, data, data_len); 1016 break; 1017 case USB_ENDPOINT_XFER_ISOC: 1018 oz_hcd_buffer_data(ep, data, data_len); 1019 break; 1020 } 1021done: 1022 spin_unlock_bh(&ozhcd->hcd_lock); 1023} 1024 1025/* 1026 * Context: unknown 1027 */ 1028static inline int oz_usb_get_frame_number(void) 1029{ 1030 return atomic_inc_return(&g_usb_frame_number); 1031} 1032 1033/* 1034 * Context: softirq 1035 */ 1036int oz_hcd_heartbeat(void *hport) 1037{ 1038 int rc = 0; 1039 struct oz_port *port = (struct oz_port *)hport; 1040 struct oz_hcd *ozhcd = port->ozhcd; 1041 struct oz_urb_link *urbl, *n; 1042 LIST_HEAD(xfr_list); 1043 struct urb *urb; 1044 struct oz_endpoint *ep; 1045 struct timespec ts, delta; 1046 1047 getrawmonotonic(&ts); 1048 /* Check the OUT isoc endpoints to see if any URB data can be sent. 1049 */ 1050 spin_lock_bh(&ozhcd->hcd_lock); 1051 list_for_each_entry(ep, &port->isoc_out_ep, link) { 1052 if (ep->credit < 0) 1053 continue; 1054 delta = timespec_sub(ts, ep->timestamp); 1055 ep->credit += div_u64(timespec_to_ns(&delta), NSEC_PER_MSEC); 1056 if (ep->credit > ep->credit_ceiling) 1057 ep->credit = ep->credit_ceiling; 1058 ep->timestamp = ts; 1059 while (ep->credit && !list_empty(&ep->urb_list)) { 1060 urbl = list_first_entry(&ep->urb_list, 1061 struct oz_urb_link, link); 1062 urb = urbl->urb; 1063 if ((ep->credit + 1) < urb->number_of_packets) 1064 break; 1065 ep->credit -= urb->number_of_packets; 1066 if (ep->credit < 0) 1067 ep->credit = 0; 1068 list_move_tail(&urbl->link, &xfr_list); 1069 } 1070 } 1071 spin_unlock_bh(&ozhcd->hcd_lock); 1072 /* Send to PD and complete URBs. 1073 */ 1074 list_for_each_entry_safe(urbl, n, &xfr_list, link) { 1075 urb = urbl->urb; 1076 list_del_init(&urbl->link); 1077 urb->error_count = 0; 1078 urb->start_frame = oz_usb_get_frame_number(); 1079 oz_usb_send_isoc(port->hpd, urbl->ep_num, urb); 1080 oz_free_urb_link(urbl); 1081 oz_complete_urb(port->ozhcd->hcd, urb, 0); 1082 } 1083 /* Check the IN isoc endpoints to see if any URBs can be completed. 1084 */ 1085 spin_lock_bh(&ozhcd->hcd_lock); 1086 list_for_each_entry(ep, &port->isoc_in_ep, link) { 1087 if (ep->flags & OZ_F_EP_BUFFERING) { 1088 if (ep->buffered_units >= OZ_IN_BUFFERING_UNITS) { 1089 ep->flags &= ~OZ_F_EP_BUFFERING; 1090 ep->credit = 0; 1091 ep->timestamp = ts; 1092 ep->start_frame = 0; 1093 } 1094 continue; 1095 } 1096 delta = timespec_sub(ts, ep->timestamp); 1097 ep->credit += div_u64(timespec_to_ns(&delta), NSEC_PER_MSEC); 1098 ep->timestamp = ts; 1099 list_for_each_entry_safe(urbl, n, &ep->urb_list, link) { 1100 struct urb *urb = urbl->urb; 1101 int len = 0; 1102 int copy_len; 1103 int i; 1104 1105 if (ep->credit < urb->number_of_packets) 1106 break; 1107 if (ep->buffered_units < urb->number_of_packets) 1108 break; 1109 urb->actual_length = 0; 1110 for (i = 0; i < urb->number_of_packets; i++) { 1111 len = ep->buffer[ep->out_ix]; 1112 if (++ep->out_ix == ep->buffer_size) 1113 ep->out_ix = 0; 1114 copy_len = ep->buffer_size - ep->out_ix; 1115 if (copy_len > len) 1116 copy_len = len; 1117 memcpy(urb->transfer_buffer, 1118 &ep->buffer[ep->out_ix], copy_len); 1119 if (copy_len < len) { 1120 memcpy(urb->transfer_buffer+copy_len, 1121 ep->buffer, len-copy_len); 1122 ep->out_ix = len-copy_len; 1123 } else 1124 ep->out_ix += copy_len; 1125 if (ep->out_ix == ep->buffer_size) 1126 ep->out_ix = 0; 1127 urb->iso_frame_desc[i].offset = 1128 urb->actual_length; 1129 urb->actual_length += len; 1130 urb->iso_frame_desc[i].actual_length = len; 1131 urb->iso_frame_desc[i].status = 0; 1132 } 1133 ep->buffered_units -= urb->number_of_packets; 1134 urb->error_count = 0; 1135 urb->start_frame = ep->start_frame; 1136 ep->start_frame += urb->number_of_packets; 1137 list_move_tail(&urbl->link, &xfr_list); 1138 ep->credit -= urb->number_of_packets; 1139 } 1140 } 1141 if (!list_empty(&port->isoc_out_ep) || !list_empty(&port->isoc_in_ep)) 1142 rc = 1; 1143 spin_unlock_bh(&ozhcd->hcd_lock); 1144 /* Complete the filled URBs. 1145 */ 1146 list_for_each_entry_safe(urbl, n, &xfr_list, link) { 1147 urb = urbl->urb; 1148 list_del_init(&urbl->link); 1149 oz_free_urb_link(urbl); 1150 oz_complete_urb(port->ozhcd->hcd, urb, 0); 1151 } 1152 /* Check if there are any ep0 requests that have timed out. 1153 * If so resent to PD. 1154 */ 1155 ep = port->out_ep[0]; 1156 if (ep) { 1157 spin_lock_bh(&ozhcd->hcd_lock); 1158 list_for_each_entry_safe(urbl, n, &ep->urb_list, link) { 1159 if (urbl->submit_counter > EP0_TIMEOUT_COUNTER) { 1160 oz_dbg(ON, "Request 0x%p timeout\n", urbl->urb); 1161 list_move_tail(&urbl->link, &xfr_list); 1162 urbl->submit_counter = 0; 1163 } else { 1164 urbl->submit_counter++; 1165 } 1166 } 1167 if (!list_empty(&ep->urb_list)) 1168 rc = 1; 1169 spin_unlock_bh(&ozhcd->hcd_lock); 1170 list_for_each_entry_safe(urbl, n, &xfr_list, link) { 1171 oz_dbg(ON, "Resending request to PD\n"); 1172 oz_process_ep0_urb(ozhcd, urbl->urb, GFP_ATOMIC); 1173 oz_free_urb_link(urbl); 1174 } 1175 } 1176 return rc; 1177} 1178 1179/* 1180 * Context: softirq 1181 */ 1182static int oz_build_endpoints_for_interface(struct usb_hcd *hcd, 1183 struct oz_port *port, 1184 struct usb_host_interface *intf, gfp_t mem_flags) 1185{ 1186 struct oz_hcd *ozhcd = port->ozhcd; 1187 int i; 1188 int if_ix = intf->desc.bInterfaceNumber; 1189 int request_heartbeat = 0; 1190 1191 oz_dbg(ON, "interface[%d] = %p\n", if_ix, intf); 1192 if (if_ix >= port->num_iface || port->iface == NULL) 1193 return -ENOMEM; 1194 for (i = 0; i < intf->desc.bNumEndpoints; i++) { 1195 struct usb_host_endpoint *hep = &intf->endpoint[i]; 1196 u8 ep_addr = hep->desc.bEndpointAddress; 1197 u8 ep_num = ep_addr & USB_ENDPOINT_NUMBER_MASK; 1198 struct oz_endpoint *ep; 1199 int buffer_size = 0; 1200 1201 oz_dbg(ON, "%d bEndpointAddress = %x\n", i, ep_addr); 1202 if (ep_addr & USB_ENDPOINT_DIR_MASK) { 1203 switch (hep->desc.bmAttributes & 1204 USB_ENDPOINT_XFERTYPE_MASK) { 1205 case USB_ENDPOINT_XFER_ISOC: 1206 buffer_size = OZ_EP_BUFFER_SIZE_ISOC; 1207 break; 1208 case USB_ENDPOINT_XFER_INT: 1209 buffer_size = OZ_EP_BUFFER_SIZE_INT; 1210 break; 1211 } 1212 } 1213 1214 ep = oz_ep_alloc(buffer_size, mem_flags); 1215 if (!ep) { 1216 oz_clean_endpoints_for_interface(hcd, port, if_ix); 1217 return -ENOMEM; 1218 } 1219 ep->attrib = hep->desc.bmAttributes; 1220 ep->ep_num = ep_num; 1221 if ((ep->attrib & USB_ENDPOINT_XFERTYPE_MASK) 1222 == USB_ENDPOINT_XFER_ISOC) { 1223 oz_dbg(ON, "wMaxPacketSize = %d\n", 1224 usb_endpoint_maxp(&hep->desc)); 1225 ep->credit_ceiling = 200; 1226 if (ep_addr & USB_ENDPOINT_DIR_MASK) { 1227 ep->flags |= OZ_F_EP_BUFFERING; 1228 } else { 1229 ep->flags |= OZ_F_EP_HAVE_STREAM; 1230 if (oz_usb_stream_create(port->hpd, ep_num)) 1231 ep->flags &= ~OZ_F_EP_HAVE_STREAM; 1232 } 1233 } 1234 spin_lock_bh(&ozhcd->hcd_lock); 1235 if (ep_addr & USB_ENDPOINT_DIR_MASK) { 1236 port->in_ep[ep_num] = ep; 1237 port->iface[if_ix].ep_mask |= 1238 (1<<(ep_num+OZ_NB_ENDPOINTS)); 1239 if ((ep->attrib & USB_ENDPOINT_XFERTYPE_MASK) 1240 == USB_ENDPOINT_XFER_ISOC) { 1241 list_add_tail(&ep->link, &port->isoc_in_ep); 1242 request_heartbeat = 1; 1243 } 1244 } else { 1245 port->out_ep[ep_num] = ep; 1246 port->iface[if_ix].ep_mask |= (1<<ep_num); 1247 if ((ep->attrib & USB_ENDPOINT_XFERTYPE_MASK) 1248 == USB_ENDPOINT_XFER_ISOC) { 1249 list_add_tail(&ep->link, &port->isoc_out_ep); 1250 request_heartbeat = 1; 1251 } 1252 } 1253 spin_unlock_bh(&ozhcd->hcd_lock); 1254 if (request_heartbeat && port->hpd) 1255 oz_usb_request_heartbeat(port->hpd); 1256 } 1257 return 0; 1258} 1259 1260/* 1261 * Context: softirq 1262 */ 1263static void oz_clean_endpoints_for_interface(struct usb_hcd *hcd, 1264 struct oz_port *port, int if_ix) 1265{ 1266 struct oz_hcd *ozhcd = port->ozhcd; 1267 unsigned mask; 1268 int i; 1269 LIST_HEAD(ep_list); 1270 struct oz_endpoint *ep, *n; 1271 1272 oz_dbg(ON, "Deleting endpoints for interface %d\n", if_ix); 1273 if (if_ix >= port->num_iface) 1274 return; 1275 spin_lock_bh(&ozhcd->hcd_lock); 1276 mask = port->iface[if_ix].ep_mask; 1277 port->iface[if_ix].ep_mask = 0; 1278 for (i = 0; i < OZ_NB_ENDPOINTS; i++) { 1279 struct list_head *e; 1280 /* Gather OUT endpoints. 1281 */ 1282 if ((mask & (1<<i)) && port->out_ep[i]) { 1283 e = &port->out_ep[i]->link; 1284 port->out_ep[i] = NULL; 1285 /* Remove from isoc list if present. 1286 */ 1287 list_move_tail(e, &ep_list); 1288 } 1289 /* Gather IN endpoints. 1290 */ 1291 if ((mask & (1<<(i+OZ_NB_ENDPOINTS))) && port->in_ep[i]) { 1292 e = &port->in_ep[i]->link; 1293 port->in_ep[i] = NULL; 1294 list_move_tail(e, &ep_list); 1295 } 1296 } 1297 spin_unlock_bh(&ozhcd->hcd_lock); 1298 list_for_each_entry_safe(ep, n, &ep_list, link) { 1299 list_del_init(&ep->link); 1300 oz_ep_free(port, ep); 1301 } 1302} 1303 1304/* 1305 * Context: softirq 1306 */ 1307static int oz_build_endpoints_for_config(struct usb_hcd *hcd, 1308 struct oz_port *port, struct usb_host_config *config, 1309 gfp_t mem_flags) 1310{ 1311 struct oz_hcd *ozhcd = port->ozhcd; 1312 int i; 1313 int num_iface = config->desc.bNumInterfaces; 1314 1315 if (num_iface) { 1316 struct oz_interface *iface; 1317 1318 iface = kmalloc_array(num_iface, sizeof(struct oz_interface), 1319 mem_flags | __GFP_ZERO); 1320 if (!iface) 1321 return -ENOMEM; 1322 spin_lock_bh(&ozhcd->hcd_lock); 1323 port->iface = iface; 1324 port->num_iface = num_iface; 1325 spin_unlock_bh(&ozhcd->hcd_lock); 1326 } 1327 for (i = 0; i < num_iface; i++) { 1328 struct usb_host_interface *intf = 1329 &config->intf_cache[i]->altsetting[0]; 1330 if (oz_build_endpoints_for_interface(hcd, port, intf, 1331 mem_flags)) 1332 goto fail; 1333 } 1334 return 0; 1335fail: 1336 oz_clean_endpoints_for_config(hcd, port); 1337 return -1; 1338} 1339 1340/* 1341 * Context: softirq 1342 */ 1343static void oz_clean_endpoints_for_config(struct usb_hcd *hcd, 1344 struct oz_port *port) 1345{ 1346 struct oz_hcd *ozhcd = port->ozhcd; 1347 int i; 1348 1349 oz_dbg(ON, "Deleting endpoints for configuration\n"); 1350 for (i = 0; i < port->num_iface; i++) 1351 oz_clean_endpoints_for_interface(hcd, port, i); 1352 spin_lock_bh(&ozhcd->hcd_lock); 1353 if (port->iface) { 1354 oz_dbg(ON, "Freeing interfaces object\n"); 1355 kfree(port->iface); 1356 port->iface = NULL; 1357 } 1358 port->num_iface = 0; 1359 spin_unlock_bh(&ozhcd->hcd_lock); 1360} 1361 1362/* 1363 * Context: tasklet 1364 */ 1365static void *oz_claim_hpd(struct oz_port *port) 1366{ 1367 void *hpd; 1368 struct oz_hcd *ozhcd = port->ozhcd; 1369 1370 spin_lock_bh(&ozhcd->hcd_lock); 1371 hpd = port->hpd; 1372 if (hpd) 1373 oz_usb_get(hpd); 1374 spin_unlock_bh(&ozhcd->hcd_lock); 1375 return hpd; 1376} 1377 1378/* 1379 * Context: tasklet 1380 */ 1381static void oz_process_ep0_urb(struct oz_hcd *ozhcd, struct urb *urb, 1382 gfp_t mem_flags) 1383{ 1384 struct usb_ctrlrequest *setup; 1385 unsigned windex; 1386 unsigned wvalue; 1387 unsigned wlength; 1388 void *hpd; 1389 u8 req_id; 1390 int rc = 0; 1391 unsigned complete = 0; 1392 1393 int port_ix = -1; 1394 struct oz_port *port = NULL; 1395 1396 oz_dbg(URB, "[%s]:(%p)\n", __func__, urb); 1397 port_ix = oz_get_port_from_addr(ozhcd, urb->dev->devnum); 1398 if (port_ix < 0) { 1399 rc = -EPIPE; 1400 goto out; 1401 } 1402 port = &ozhcd->ports[port_ix]; 1403 if (((port->flags & OZ_PORT_F_PRESENT) == 0) 1404 || (port->flags & OZ_PORT_F_DYING)) { 1405 oz_dbg(ON, "Refusing URB port_ix = %d devnum = %d\n", 1406 port_ix, urb->dev->devnum); 1407 rc = -EPIPE; 1408 goto out; 1409 } 1410 /* Store port in private context data. 1411 */ 1412 urb->hcpriv = port; 1413 setup = (struct usb_ctrlrequest *)urb->setup_packet; 1414 windex = le16_to_cpu(setup->wIndex); 1415 wvalue = le16_to_cpu(setup->wValue); 1416 wlength = le16_to_cpu(setup->wLength); 1417 oz_dbg(CTRL_DETAIL, "bRequestType = %x\n", setup->bRequestType); 1418 oz_dbg(CTRL_DETAIL, "bRequest = %x\n", setup->bRequest); 1419 oz_dbg(CTRL_DETAIL, "wValue = %x\n", wvalue); 1420 oz_dbg(CTRL_DETAIL, "wIndex = %x\n", windex); 1421 oz_dbg(CTRL_DETAIL, "wLength = %x\n", wlength); 1422 1423 req_id = port->next_req_id++; 1424 hpd = oz_claim_hpd(port); 1425 if (hpd == NULL) { 1426 oz_dbg(ON, "Cannot claim port\n"); 1427 rc = -EPIPE; 1428 goto out; 1429 } 1430 1431 if ((setup->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) { 1432 /* Standard requests 1433 */ 1434 switch (setup->bRequest) { 1435 case USB_REQ_GET_DESCRIPTOR: 1436 oz_dbg(ON, "USB_REQ_GET_DESCRIPTOR - req\n"); 1437 break; 1438 case USB_REQ_SET_ADDRESS: 1439 oz_dbg(ON, "USB_REQ_SET_ADDRESS - req\n"); 1440 oz_dbg(ON, "Port %d address is 0x%x\n", 1441 ozhcd->conn_port, 1442 (u8)le16_to_cpu(setup->wValue)); 1443 spin_lock_bh(&ozhcd->hcd_lock); 1444 if (ozhcd->conn_port >= 0) { 1445 ozhcd->ports[ozhcd->conn_port].bus_addr = 1446 (u8)le16_to_cpu(setup->wValue); 1447 oz_dbg(ON, "Clearing conn_port\n"); 1448 ozhcd->conn_port = -1; 1449 } 1450 spin_unlock_bh(&ozhcd->hcd_lock); 1451 complete = 1; 1452 break; 1453 case USB_REQ_SET_CONFIGURATION: 1454 oz_dbg(ON, "USB_REQ_SET_CONFIGURATION - req\n"); 1455 break; 1456 case USB_REQ_GET_CONFIGURATION: 1457 /* We short circuit this case and reply directly since 1458 * we have the selected configuration number cached. 1459 */ 1460 oz_dbg(ON, "USB_REQ_GET_CONFIGURATION - reply now\n"); 1461 if (urb->transfer_buffer_length >= 1) { 1462 urb->actual_length = 1; 1463 *((u8 *)urb->transfer_buffer) = 1464 port->config_num; 1465 complete = 1; 1466 } else { 1467 rc = -EPIPE; 1468 } 1469 break; 1470 case USB_REQ_GET_INTERFACE: 1471 /* We short circuit this case and reply directly since 1472 * we have the selected interface alternative cached. 1473 */ 1474 oz_dbg(ON, "USB_REQ_GET_INTERFACE - reply now\n"); 1475 if (urb->transfer_buffer_length >= 1) { 1476 urb->actual_length = 1; 1477 *((u8 *)urb->transfer_buffer) = 1478 port->iface[(u8)windex].alt; 1479 oz_dbg(ON, "interface = %d alt = %d\n", 1480 windex, port->iface[(u8)windex].alt); 1481 complete = 1; 1482 } else { 1483 rc = -EPIPE; 1484 } 1485 break; 1486 case USB_REQ_SET_INTERFACE: 1487 oz_dbg(ON, "USB_REQ_SET_INTERFACE - req\n"); 1488 break; 1489 } 1490 } 1491 if (!rc && !complete) { 1492 int data_len = 0; 1493 1494 if ((setup->bRequestType & USB_DIR_IN) == 0) 1495 data_len = wlength; 1496 urb->actual_length = data_len; 1497 if (oz_usb_control_req(port->hpd, req_id, setup, 1498 urb->transfer_buffer, data_len)) { 1499 rc = -ENOMEM; 1500 } else { 1501 /* Note: we are queuing the request after we have 1502 * submitted it to be transmitted. If the request were 1503 * to complete before we queued it then it would not 1504 * be found in the queue. It seems impossible for 1505 * this to happen but if it did the request would 1506 * be resubmitted so the problem would hopefully 1507 * resolve itself. Putting the request into the 1508 * queue before it has been sent is worse since the 1509 * urb could be cancelled while we are using it 1510 * to build the request. 1511 */ 1512 if (oz_enqueue_ep_urb(port, 0, 0, urb, req_id)) 1513 rc = -ENOMEM; 1514 } 1515 } 1516 oz_usb_put(hpd); 1517out: 1518 if (rc || complete) { 1519 oz_dbg(ON, "Completing request locally\n"); 1520 oz_complete_urb(ozhcd->hcd, urb, rc); 1521 } else { 1522 oz_usb_request_heartbeat(port->hpd); 1523 } 1524} 1525 1526/* 1527 * Context: tasklet 1528 */ 1529static int oz_urb_process(struct oz_hcd *ozhcd, struct urb *urb) 1530{ 1531 int rc = 0; 1532 struct oz_port *port = urb->hcpriv; 1533 u8 ep_addr; 1534 1535 /* When we are paranoid we keep a list of urbs which we check against 1536 * before handing one back. This is just for debugging during 1537 * development and should be turned off in the released driver. 1538 */ 1539 oz_remember_urb(urb); 1540 /* Check buffer is valid. 1541 */ 1542 if (!urb->transfer_buffer && urb->transfer_buffer_length) 1543 return -EINVAL; 1544 /* Check if there is a device at the port - refuse if not. 1545 */ 1546 if ((port->flags & OZ_PORT_F_PRESENT) == 0) 1547 return -EPIPE; 1548 ep_addr = usb_pipeendpoint(urb->pipe); 1549 if (ep_addr) { 1550 /* If the request is not for EP0 then queue it. 1551 */ 1552 if (oz_enqueue_ep_urb(port, ep_addr, usb_pipein(urb->pipe), 1553 urb, 0)) 1554 rc = -EPIPE; 1555 } else { 1556 oz_process_ep0_urb(ozhcd, urb, GFP_ATOMIC); 1557 } 1558 return rc; 1559} 1560 1561/* 1562 * Context: tasklet 1563 */ 1564static void oz_urb_process_tasklet(unsigned long unused) 1565{ 1566 unsigned long irq_state; 1567 struct urb *urb; 1568 struct oz_hcd *ozhcd = oz_hcd_claim(); 1569 struct oz_urb_link *urbl, *n; 1570 int rc = 0; 1571 1572 if (ozhcd == NULL) 1573 return; 1574 /* This is called from a tasklet so is in softirq context but the urb 1575 * list is filled from any context so we need to lock 1576 * appropriately while removing urbs. 1577 */ 1578 spin_lock_irqsave(&g_tasklet_lock, irq_state); 1579 list_for_each_entry_safe(urbl, n, &ozhcd->urb_pending_list, link) { 1580 list_del_init(&urbl->link); 1581 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 1582 urb = urbl->urb; 1583 oz_free_urb_link(urbl); 1584 rc = oz_urb_process(ozhcd, urb); 1585 if (rc) 1586 oz_complete_urb(ozhcd->hcd, urb, rc); 1587 spin_lock_irqsave(&g_tasklet_lock, irq_state); 1588 } 1589 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 1590 oz_hcd_put(ozhcd); 1591} 1592 1593/* 1594 * This function searches for the urb in any of the lists it could be in. 1595 * If it is found it is removed from the list and completed. If the urb is 1596 * being processed then it won't be in a list so won't be found. However, the 1597 * call to usb_hcd_check_unlink_urb() will set the value of the unlinked field 1598 * to a non-zero value. When an attempt is made to put the urb back in a list 1599 * the unlinked field will be checked and the urb will then be completed. 1600 * Context: tasklet 1601 */ 1602static void oz_urb_cancel(struct oz_port *port, u8 ep_num, struct urb *urb) 1603{ 1604 struct oz_urb_link *urbl = NULL; 1605 struct list_head *e; 1606 struct oz_hcd *ozhcd; 1607 unsigned long irq_state; 1608 u8 ix; 1609 1610 if (port == NULL) { 1611 oz_dbg(ON, "%s: ERROR: (%p) port is null\n", __func__, urb); 1612 return; 1613 } 1614 ozhcd = port->ozhcd; 1615 if (ozhcd == NULL) { 1616 oz_dbg(ON, "%s; ERROR: (%p) ozhcd is null\n", __func__, urb); 1617 return; 1618 } 1619 1620 /* Look in the tasklet queue. 1621 */ 1622 spin_lock_irqsave(&g_tasklet_lock, irq_state); 1623 list_for_each(e, &ozhcd->urb_cancel_list) { 1624 urbl = list_entry(e, struct oz_urb_link, link); 1625 if (urb == urbl->urb) { 1626 list_del_init(e); 1627 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 1628 goto out2; 1629 } 1630 } 1631 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 1632 urbl = NULL; 1633 1634 /* Look in the orphanage. 1635 */ 1636 spin_lock_irqsave(&ozhcd->hcd_lock, irq_state); 1637 list_for_each(e, &ozhcd->orphanage) { 1638 urbl = list_entry(e, struct oz_urb_link, link); 1639 if (urbl->urb == urb) { 1640 list_del(e); 1641 oz_dbg(ON, "Found urb in orphanage\n"); 1642 goto out; 1643 } 1644 } 1645 ix = (ep_num & 0xf); 1646 urbl = NULL; 1647 if ((ep_num & USB_DIR_IN) && ix) 1648 urbl = oz_remove_urb(port->in_ep[ix], urb); 1649 else 1650 urbl = oz_remove_urb(port->out_ep[ix], urb); 1651out: 1652 spin_unlock_irqrestore(&ozhcd->hcd_lock, irq_state); 1653out2: 1654 if (urbl) { 1655 urb->actual_length = 0; 1656 oz_free_urb_link(urbl); 1657 oz_complete_urb(ozhcd->hcd, urb, -EPIPE); 1658 } 1659} 1660 1661/* 1662 * Context: tasklet 1663 */ 1664static void oz_urb_cancel_tasklet(unsigned long unused) 1665{ 1666 unsigned long irq_state; 1667 struct urb *urb; 1668 struct oz_urb_link *urbl, *n; 1669 struct oz_hcd *ozhcd = oz_hcd_claim(); 1670 1671 if (ozhcd == NULL) 1672 return; 1673 spin_lock_irqsave(&g_tasklet_lock, irq_state); 1674 list_for_each_entry_safe(urbl, n, &ozhcd->urb_cancel_list, link) { 1675 list_del_init(&urbl->link); 1676 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 1677 urb = urbl->urb; 1678 if (urb->unlinked) 1679 oz_urb_cancel(urbl->port, urbl->ep_num, urb); 1680 oz_free_urb_link(urbl); 1681 spin_lock_irqsave(&g_tasklet_lock, irq_state); 1682 } 1683 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 1684 oz_hcd_put(ozhcd); 1685} 1686 1687/* 1688 * Context: unknown 1689 */ 1690static void oz_hcd_clear_orphanage(struct oz_hcd *ozhcd, int status) 1691{ 1692 if (ozhcd) { 1693 struct oz_urb_link *urbl, *n; 1694 1695 list_for_each_entry_safe(urbl, n, &ozhcd->orphanage, link) { 1696 list_del(&urbl->link); 1697 oz_complete_urb(ozhcd->hcd, urbl->urb, status); 1698 oz_free_urb_link(urbl); 1699 } 1700 } 1701} 1702 1703/* 1704 * Context: unknown 1705 */ 1706static int oz_hcd_start(struct usb_hcd *hcd) 1707{ 1708 hcd->power_budget = 200; 1709 hcd->state = HC_STATE_RUNNING; 1710 hcd->uses_new_polling = 1; 1711 return 0; 1712} 1713 1714/* 1715 * Context: unknown 1716 */ 1717static void oz_hcd_stop(struct usb_hcd *hcd) 1718{ 1719} 1720 1721/* 1722 * Context: unknown 1723 */ 1724static void oz_hcd_shutdown(struct usb_hcd *hcd) 1725{ 1726} 1727 1728/* 1729 * Called to queue an urb for the device. 1730 * This function should return a non-zero error code if it fails the urb but 1731 * should not call usb_hcd_giveback_urb(). 1732 * Context: any 1733 */ 1734static int oz_hcd_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, 1735 gfp_t mem_flags) 1736{ 1737 struct oz_hcd *ozhcd = oz_hcd_private(hcd); 1738 int rc; 1739 int port_ix; 1740 struct oz_port *port; 1741 unsigned long irq_state; 1742 struct oz_urb_link *urbl; 1743 1744 oz_dbg(URB, "%s: (%p)\n", __func__, urb); 1745 if (unlikely(ozhcd == NULL)) { 1746 oz_dbg(URB, "Refused urb(%p) not ozhcd\n", urb); 1747 return -EPIPE; 1748 } 1749 if (unlikely(hcd->state != HC_STATE_RUNNING)) { 1750 oz_dbg(URB, "Refused urb(%p) not running\n", urb); 1751 return -EPIPE; 1752 } 1753 port_ix = oz_get_port_from_addr(ozhcd, urb->dev->devnum); 1754 if (port_ix < 0) 1755 return -EPIPE; 1756 port = &ozhcd->ports[port_ix]; 1757 if (port == NULL) 1758 return -EPIPE; 1759 if (!(port->flags & OZ_PORT_F_PRESENT) || 1760 (port->flags & OZ_PORT_F_CHANGED)) { 1761 oz_dbg(ON, "Refusing URB port_ix = %d devnum = %d\n", 1762 port_ix, urb->dev->devnum); 1763 return -EPIPE; 1764 } 1765 urb->hcpriv = port; 1766 /* Put request in queue for processing by tasklet. 1767 */ 1768 urbl = oz_alloc_urb_link(); 1769 if (unlikely(urbl == NULL)) 1770 return -ENOMEM; 1771 urbl->urb = urb; 1772 spin_lock_irqsave(&g_tasklet_lock, irq_state); 1773 rc = usb_hcd_link_urb_to_ep(hcd, urb); 1774 if (unlikely(rc)) { 1775 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 1776 oz_free_urb_link(urbl); 1777 return rc; 1778 } 1779 list_add_tail(&urbl->link, &ozhcd->urb_pending_list); 1780 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 1781 tasklet_schedule(&g_urb_process_tasklet); 1782 atomic_inc(&g_pending_urbs); 1783 return 0; 1784} 1785 1786/* 1787 * Context: tasklet 1788 */ 1789static struct oz_urb_link *oz_remove_urb(struct oz_endpoint *ep, 1790 struct urb *urb) 1791{ 1792 struct oz_urb_link *urbl; 1793 1794 if (unlikely(ep == NULL)) 1795 return NULL; 1796 1797 list_for_each_entry(urbl, &ep->urb_list, link) { 1798 if (urbl->urb == urb) { 1799 list_del_init(&urbl->link); 1800 if (usb_pipeisoc(urb->pipe)) { 1801 ep->credit -= urb->number_of_packets; 1802 if (ep->credit < 0) 1803 ep->credit = 0; 1804 } 1805 return urbl; 1806 } 1807 } 1808 return NULL; 1809} 1810 1811/* 1812 * Called to dequeue a previously submitted urb for the device. 1813 * Context: any 1814 */ 1815static int oz_hcd_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) 1816{ 1817 struct oz_hcd *ozhcd = oz_hcd_private(hcd); 1818 struct oz_urb_link *urbl; 1819 int rc; 1820 unsigned long irq_state; 1821 1822 oz_dbg(URB, "%s: (%p)\n", __func__, urb); 1823 urbl = oz_alloc_urb_link(); 1824 if (unlikely(urbl == NULL)) 1825 return -ENOMEM; 1826 spin_lock_irqsave(&g_tasklet_lock, irq_state); 1827 /* The following function checks the urb is still in the queue 1828 * maintained by the core and that the unlinked field is zero. 1829 * If both are true the function sets the unlinked field and returns 1830 * zero. Otherwise it returns an error. 1831 */ 1832 rc = usb_hcd_check_unlink_urb(hcd, urb, status); 1833 /* We have to check we haven't completed the urb or are about 1834 * to complete it. When we do we set hcpriv to 0 so if this has 1835 * already happened we don't put the urb in the cancel queue. 1836 */ 1837 if ((rc == 0) && urb->hcpriv) { 1838 urbl->urb = urb; 1839 urbl->port = (struct oz_port *)urb->hcpriv; 1840 urbl->ep_num = usb_pipeendpoint(urb->pipe); 1841 if (usb_pipein(urb->pipe)) 1842 urbl->ep_num |= USB_DIR_IN; 1843 list_add_tail(&urbl->link, &ozhcd->urb_cancel_list); 1844 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 1845 tasklet_schedule(&g_urb_cancel_tasklet); 1846 } else { 1847 spin_unlock_irqrestore(&g_tasklet_lock, irq_state); 1848 oz_free_urb_link(urbl); 1849 } 1850 return rc; 1851} 1852 1853/* 1854 * Context: unknown 1855 */ 1856static void oz_hcd_endpoint_disable(struct usb_hcd *hcd, 1857 struct usb_host_endpoint *ep) 1858{ 1859} 1860 1861/* 1862 * Context: unknown 1863 */ 1864static void oz_hcd_endpoint_reset(struct usb_hcd *hcd, 1865 struct usb_host_endpoint *ep) 1866{ 1867} 1868 1869/* 1870 * Context: unknown 1871 */ 1872static int oz_hcd_get_frame_number(struct usb_hcd *hcd) 1873{ 1874 oz_dbg(ON, "oz_hcd_get_frame_number\n"); 1875 return oz_usb_get_frame_number(); 1876} 1877 1878/* 1879 * Context: softirq 1880 * This is called as a consquence of us calling usb_hcd_poll_rh_status() and we 1881 * always do that in softirq context. 1882 */ 1883static int oz_hcd_hub_status_data(struct usb_hcd *hcd, char *buf) 1884{ 1885 struct oz_hcd *ozhcd = oz_hcd_private(hcd); 1886 int i; 1887 1888 buf[0] = 0; 1889 buf[1] = 0; 1890 1891 spin_lock_bh(&ozhcd->hcd_lock); 1892 for (i = 0; i < OZ_NB_PORTS; i++) { 1893 if (ozhcd->ports[i].flags & OZ_PORT_F_CHANGED) { 1894 oz_dbg(HUB, "Port %d changed\n", i); 1895 ozhcd->ports[i].flags &= ~OZ_PORT_F_CHANGED; 1896 if (i < 7) 1897 buf[0] |= 1 << (i + 1); 1898 else 1899 buf[1] |= 1 << (i - 7); 1900 } 1901 } 1902 spin_unlock_bh(&ozhcd->hcd_lock); 1903 if (buf[0] != 0 || buf[1] != 0) 1904 return 2; 1905 return 0; 1906} 1907 1908/* 1909 * Context: process 1910 */ 1911static void oz_get_hub_descriptor(struct usb_hcd *hcd, 1912 struct usb_hub_descriptor *desc) 1913{ 1914 memset(desc, 0, sizeof(*desc)); 1915 desc->bDescriptorType = 0x29; 1916 desc->bDescLength = 9; 1917 desc->wHubCharacteristics = (__force __u16)cpu_to_le16(0x0001); 1918 desc->bNbrPorts = OZ_NB_PORTS; 1919} 1920 1921/* 1922 * Context: process 1923 */ 1924static int oz_set_port_feature(struct usb_hcd *hcd, u16 wvalue, u16 windex) 1925{ 1926 struct oz_port *port; 1927 u8 port_id = (u8)windex; 1928 struct oz_hcd *ozhcd = oz_hcd_private(hcd); 1929 unsigned set_bits = 0; 1930 unsigned clear_bits = 0; 1931 1932 if ((port_id < 1) || (port_id > OZ_NB_PORTS)) 1933 return -EPIPE; 1934 port = &ozhcd->ports[port_id-1]; 1935 switch (wvalue) { 1936 case USB_PORT_FEAT_CONNECTION: 1937 oz_dbg(HUB, "USB_PORT_FEAT_CONNECTION\n"); 1938 break; 1939 case USB_PORT_FEAT_ENABLE: 1940 oz_dbg(HUB, "USB_PORT_FEAT_ENABLE\n"); 1941 break; 1942 case USB_PORT_FEAT_SUSPEND: 1943 oz_dbg(HUB, "USB_PORT_FEAT_SUSPEND\n"); 1944 break; 1945 case USB_PORT_FEAT_OVER_CURRENT: 1946 oz_dbg(HUB, "USB_PORT_FEAT_OVER_CURRENT\n"); 1947 break; 1948 case USB_PORT_FEAT_RESET: 1949 oz_dbg(HUB, "USB_PORT_FEAT_RESET\n"); 1950 set_bits = USB_PORT_STAT_ENABLE | (USB_PORT_STAT_C_RESET<<16); 1951 clear_bits = USB_PORT_STAT_RESET; 1952 ozhcd->ports[port_id-1].bus_addr = 0; 1953 break; 1954 case USB_PORT_FEAT_POWER: 1955 oz_dbg(HUB, "USB_PORT_FEAT_POWER\n"); 1956 set_bits |= USB_PORT_STAT_POWER; 1957 break; 1958 case USB_PORT_FEAT_LOWSPEED: 1959 oz_dbg(HUB, "USB_PORT_FEAT_LOWSPEED\n"); 1960 break; 1961 case USB_PORT_FEAT_C_CONNECTION: 1962 oz_dbg(HUB, "USB_PORT_FEAT_C_CONNECTION\n"); 1963 break; 1964 case USB_PORT_FEAT_C_ENABLE: 1965 oz_dbg(HUB, "USB_PORT_FEAT_C_ENABLE\n"); 1966 break; 1967 case USB_PORT_FEAT_C_SUSPEND: 1968 oz_dbg(HUB, "USB_PORT_FEAT_C_SUSPEND\n"); 1969 break; 1970 case USB_PORT_FEAT_C_OVER_CURRENT: 1971 oz_dbg(HUB, "USB_PORT_FEAT_C_OVER_CURRENT\n"); 1972 break; 1973 case USB_PORT_FEAT_C_RESET: 1974 oz_dbg(HUB, "USB_PORT_FEAT_C_RESET\n"); 1975 break; 1976 case USB_PORT_FEAT_TEST: 1977 oz_dbg(HUB, "USB_PORT_FEAT_TEST\n"); 1978 break; 1979 case USB_PORT_FEAT_INDICATOR: 1980 oz_dbg(HUB, "USB_PORT_FEAT_INDICATOR\n"); 1981 break; 1982 default: 1983 oz_dbg(HUB, "Other %d\n", wvalue); 1984 break; 1985 } 1986 if (set_bits || clear_bits) { 1987 spin_lock_bh(&port->port_lock); 1988 port->status &= ~clear_bits; 1989 port->status |= set_bits; 1990 spin_unlock_bh(&port->port_lock); 1991 } 1992 oz_dbg(HUB, "Port[%d] status = 0x%x\n", port_id, port->status); 1993 return 0; 1994} 1995 1996/* 1997 * Context: process 1998 */ 1999static int oz_clear_port_feature(struct usb_hcd *hcd, u16 wvalue, u16 windex) 2000{ 2001 struct oz_port *port; 2002 u8 port_id = (u8)windex; 2003 struct oz_hcd *ozhcd = oz_hcd_private(hcd); 2004 unsigned clear_bits = 0; 2005 2006 if ((port_id < 1) || (port_id > OZ_NB_PORTS)) 2007 return -EPIPE; 2008 port = &ozhcd->ports[port_id-1]; 2009 switch (wvalue) { 2010 case USB_PORT_FEAT_CONNECTION: 2011 oz_dbg(HUB, "USB_PORT_FEAT_CONNECTION\n"); 2012 break; 2013 case USB_PORT_FEAT_ENABLE: 2014 oz_dbg(HUB, "USB_PORT_FEAT_ENABLE\n"); 2015 clear_bits = USB_PORT_STAT_ENABLE; 2016 break; 2017 case USB_PORT_FEAT_SUSPEND: 2018 oz_dbg(HUB, "USB_PORT_FEAT_SUSPEND\n"); 2019 break; 2020 case USB_PORT_FEAT_OVER_CURRENT: 2021 oz_dbg(HUB, "USB_PORT_FEAT_OVER_CURRENT\n"); 2022 break; 2023 case USB_PORT_FEAT_RESET: 2024 oz_dbg(HUB, "USB_PORT_FEAT_RESET\n"); 2025 break; 2026 case USB_PORT_FEAT_POWER: 2027 oz_dbg(HUB, "USB_PORT_FEAT_POWER\n"); 2028 clear_bits |= USB_PORT_STAT_POWER; 2029 break; 2030 case USB_PORT_FEAT_LOWSPEED: 2031 oz_dbg(HUB, "USB_PORT_FEAT_LOWSPEED\n"); 2032 break; 2033 case USB_PORT_FEAT_C_CONNECTION: 2034 oz_dbg(HUB, "USB_PORT_FEAT_C_CONNECTION\n"); 2035 clear_bits = (USB_PORT_STAT_C_CONNECTION << 16); 2036 break; 2037 case USB_PORT_FEAT_C_ENABLE: 2038 oz_dbg(HUB, "USB_PORT_FEAT_C_ENABLE\n"); 2039 clear_bits = (USB_PORT_STAT_C_ENABLE << 16); 2040 break; 2041 case USB_PORT_FEAT_C_SUSPEND: 2042 oz_dbg(HUB, "USB_PORT_FEAT_C_SUSPEND\n"); 2043 break; 2044 case USB_PORT_FEAT_C_OVER_CURRENT: 2045 oz_dbg(HUB, "USB_PORT_FEAT_C_OVER_CURRENT\n"); 2046 break; 2047 case USB_PORT_FEAT_C_RESET: 2048 oz_dbg(HUB, "USB_PORT_FEAT_C_RESET\n"); 2049 clear_bits = (USB_PORT_FEAT_C_RESET << 16); 2050 break; 2051 case USB_PORT_FEAT_TEST: 2052 oz_dbg(HUB, "USB_PORT_FEAT_TEST\n"); 2053 break; 2054 case USB_PORT_FEAT_INDICATOR: 2055 oz_dbg(HUB, "USB_PORT_FEAT_INDICATOR\n"); 2056 break; 2057 default: 2058 oz_dbg(HUB, "Other %d\n", wvalue); 2059 break; 2060 } 2061 if (clear_bits) { 2062 spin_lock_bh(&port->port_lock); 2063 port->status &= ~clear_bits; 2064 spin_unlock_bh(&port->port_lock); 2065 } 2066 oz_dbg(HUB, "Port[%d] status = 0x%x\n", 2067 port_id, ozhcd->ports[port_id-1].status); 2068 return 0; 2069} 2070 2071/* 2072 * Context: process 2073 */ 2074static int oz_get_port_status(struct usb_hcd *hcd, u16 windex, char *buf) 2075{ 2076 struct oz_hcd *ozhcd; 2077 u32 status; 2078 2079 if ((windex < 1) || (windex > OZ_NB_PORTS)) 2080 return -EPIPE; 2081 ozhcd = oz_hcd_private(hcd); 2082 oz_dbg(HUB, "GetPortStatus windex = %d\n", windex); 2083 status = ozhcd->ports[windex-1].status; 2084 put_unaligned(cpu_to_le32(status), (__le32 *)buf); 2085 oz_dbg(HUB, "Port[%d] status = %x\n", windex, status); 2086 return 0; 2087} 2088 2089/* 2090 * Context: process 2091 */ 2092static int oz_hcd_hub_control(struct usb_hcd *hcd, u16 req_type, u16 wvalue, 2093 u16 windex, char *buf, u16 wlength) 2094{ 2095 int err = 0; 2096 2097 switch (req_type) { 2098 case ClearHubFeature: 2099 oz_dbg(HUB, "ClearHubFeature: %d\n", req_type); 2100 break; 2101 case ClearPortFeature: 2102 err = oz_clear_port_feature(hcd, wvalue, windex); 2103 break; 2104 case GetHubDescriptor: 2105 oz_get_hub_descriptor(hcd, (struct usb_hub_descriptor *)buf); 2106 break; 2107 case GetHubStatus: 2108 oz_dbg(HUB, "GetHubStatus: req_type = 0x%x\n", req_type); 2109 put_unaligned(cpu_to_le32(0), (__le32 *)buf); 2110 break; 2111 case GetPortStatus: 2112 err = oz_get_port_status(hcd, windex, buf); 2113 break; 2114 case SetHubFeature: 2115 oz_dbg(HUB, "SetHubFeature: %d\n", req_type); 2116 break; 2117 case SetPortFeature: 2118 err = oz_set_port_feature(hcd, wvalue, windex); 2119 break; 2120 default: 2121 oz_dbg(HUB, "Other: %d\n", req_type); 2122 break; 2123 } 2124 return err; 2125} 2126 2127/* 2128 * Context: process 2129 */ 2130static int oz_hcd_bus_suspend(struct usb_hcd *hcd) 2131{ 2132 struct oz_hcd *ozhcd; 2133 2134 ozhcd = oz_hcd_private(hcd); 2135 spin_lock_bh(&ozhcd->hcd_lock); 2136 hcd->state = HC_STATE_SUSPENDED; 2137 ozhcd->flags |= OZ_HDC_F_SUSPENDED; 2138 spin_unlock_bh(&ozhcd->hcd_lock); 2139 return 0; 2140} 2141 2142/* 2143 * Context: process 2144 */ 2145static int oz_hcd_bus_resume(struct usb_hcd *hcd) 2146{ 2147 struct oz_hcd *ozhcd; 2148 2149 ozhcd = oz_hcd_private(hcd); 2150 spin_lock_bh(&ozhcd->hcd_lock); 2151 ozhcd->flags &= ~OZ_HDC_F_SUSPENDED; 2152 hcd->state = HC_STATE_RUNNING; 2153 spin_unlock_bh(&ozhcd->hcd_lock); 2154 return 0; 2155} 2156 2157static void oz_plat_shutdown(struct platform_device *dev) 2158{ 2159} 2160 2161/* 2162 * Context: process 2163 */ 2164static int oz_plat_probe(struct platform_device *dev) 2165{ 2166 int i; 2167 int err; 2168 struct usb_hcd *hcd; 2169 struct oz_hcd *ozhcd; 2170 2171 hcd = usb_create_hcd(&g_oz_hc_drv, &dev->dev, dev_name(&dev->dev)); 2172 if (hcd == NULL) { 2173 oz_dbg(ON, "Failed to created hcd object OK\n"); 2174 return -ENOMEM; 2175 } 2176 ozhcd = oz_hcd_private(hcd); 2177 memset(ozhcd, 0, sizeof(*ozhcd)); 2178 INIT_LIST_HEAD(&ozhcd->urb_pending_list); 2179 INIT_LIST_HEAD(&ozhcd->urb_cancel_list); 2180 INIT_LIST_HEAD(&ozhcd->orphanage); 2181 ozhcd->hcd = hcd; 2182 ozhcd->conn_port = -1; 2183 spin_lock_init(&ozhcd->hcd_lock); 2184 for (i = 0; i < OZ_NB_PORTS; i++) { 2185 struct oz_port *port = &ozhcd->ports[i]; 2186 2187 port->ozhcd = ozhcd; 2188 port->flags = 0; 2189 port->status = 0; 2190 port->bus_addr = 0xff; 2191 spin_lock_init(&port->port_lock); 2192 } 2193 err = usb_add_hcd(hcd, 0, 0); 2194 if (err) { 2195 oz_dbg(ON, "Failed to add hcd object OK\n"); 2196 usb_put_hcd(hcd); 2197 return -1; 2198 } 2199 device_wakeup_enable(hcd->self.controller); 2200 2201 spin_lock_bh(&g_hcdlock); 2202 g_ozhcd = ozhcd; 2203 spin_unlock_bh(&g_hcdlock); 2204 return 0; 2205} 2206 2207/* 2208 * Context: unknown 2209 */ 2210static int oz_plat_remove(struct platform_device *dev) 2211{ 2212 struct usb_hcd *hcd = platform_get_drvdata(dev); 2213 struct oz_hcd *ozhcd; 2214 2215 if (hcd == NULL) 2216 return -1; 2217 ozhcd = oz_hcd_private(hcd); 2218 spin_lock_bh(&g_hcdlock); 2219 if (ozhcd == g_ozhcd) 2220 g_ozhcd = NULL; 2221 spin_unlock_bh(&g_hcdlock); 2222 oz_dbg(ON, "Clearing orphanage\n"); 2223 oz_hcd_clear_orphanage(ozhcd, -EPIPE); 2224 oz_dbg(ON, "Removing hcd\n"); 2225 usb_remove_hcd(hcd); 2226 usb_put_hcd(hcd); 2227 return 0; 2228} 2229 2230/* 2231 * Context: unknown 2232 */ 2233static int oz_plat_suspend(struct platform_device *dev, pm_message_t msg) 2234{ 2235 return 0; 2236} 2237 2238 2239/* 2240 * Context: unknown 2241 */ 2242static int oz_plat_resume(struct platform_device *dev) 2243{ 2244 return 0; 2245} 2246 2247/* 2248 * Context: process 2249 */ 2250int oz_hcd_init(void) 2251{ 2252 int err; 2253 2254 if (usb_disabled()) 2255 return -ENODEV; 2256 2257 oz_urb_link_cache = KMEM_CACHE(oz_urb_link, 0); 2258 if (!oz_urb_link_cache) 2259 return -ENOMEM; 2260 2261 tasklet_init(&g_urb_process_tasklet, oz_urb_process_tasklet, 0); 2262 tasklet_init(&g_urb_cancel_tasklet, oz_urb_cancel_tasklet, 0); 2263 err = platform_driver_register(&g_oz_plat_drv); 2264 oz_dbg(ON, "platform_driver_register() returned %d\n", err); 2265 if (err) 2266 goto error; 2267 g_plat_dev = platform_device_alloc(OZ_PLAT_DEV_NAME, -1); 2268 if (g_plat_dev == NULL) { 2269 err = -ENOMEM; 2270 goto error1; 2271 } 2272 oz_dbg(ON, "platform_device_alloc() succeeded\n"); 2273 err = platform_device_add(g_plat_dev); 2274 if (err) 2275 goto error2; 2276 oz_dbg(ON, "platform_device_add() succeeded\n"); 2277 return 0; 2278error2: 2279 platform_device_put(g_plat_dev); 2280error1: 2281 platform_driver_unregister(&g_oz_plat_drv); 2282error: 2283 tasklet_disable(&g_urb_process_tasklet); 2284 tasklet_disable(&g_urb_cancel_tasklet); 2285 oz_dbg(ON, "oz_hcd_init() failed %d\n", err); 2286 return err; 2287} 2288 2289/* 2290 * Context: process 2291 */ 2292void oz_hcd_term(void) 2293{ 2294 msleep(OZ_HUB_DEBOUNCE_TIMEOUT); 2295 tasklet_kill(&g_urb_process_tasklet); 2296 tasklet_kill(&g_urb_cancel_tasklet); 2297 platform_device_unregister(g_plat_dev); 2298 platform_driver_unregister(&g_oz_plat_drv); 2299 oz_dbg(ON, "Pending urbs:%d\n", atomic_read(&g_pending_urbs)); 2300 kmem_cache_destroy(oz_urb_link_cache); 2301} 2302