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