Pileus Git - ~andy/linux/blob - drivers/staging/ozwpan/ozhcd.c

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