Bug Summary

File:ozhcd.c
Location:line 1430, column 2
Description:Value stored to 'wvalue' is never read

Annotated Source Code

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