1 /* -----------------------------------------------------------------------------
2 * Copyright (c) 2011 Ozmo Inc
3 * Released under the GNU General Public License Version 2 (GPLv2).
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.
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
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 * -----------------------------------------------------------------------------
27 #include <linux/platform_device.h>
28 #include <linux/usb.h>
29 #include <linux/jiffies.h>
30 #include <linux/slab.h>
31 #include <linux/export.h>
32 #include "linux/usb/hcd.h"
33 #include <asm/unaligned.h>
37 #include "ozurbparanoia.h"
40 /*------------------------------------------------------------------------------
41 * Number of units of buffering to capture for an isochronous IN endpoint before
42 * allowing data to be indicated up.
44 #define OZ_IN_BUFFERING_UNITS 50
45 /* Name of our platform device.
47 #define OZ_PLAT_DEV_NAME "ozwpan"
48 /* Maximum number of free urb links that can be kept in the pool.
50 #define OZ_MAX_LINK_POOL_SIZE 16
51 /* Get endpoint object from the containing link.
53 #define ep_from_link(__e) container_of((__e), struct oz_endpoint, link)
54 /*------------------------------------------------------------------------------
55 * Used to link urbs together and also store some status information for each
57 * A cache of these are kept in a pool to reduce number of calls to kmalloc.
60 struct list_head link
;
65 unsigned long submit_jiffies
;
68 /* Holds state information about a USB endpoint.
71 struct list_head urb_list
; /* List of oz_urb_link items. */
72 struct list_head link
; /* For isoc ep, links in to isoc
74 unsigned long last_jiffies
;
87 /* Bits in the flags field. */
88 #define OZ_F_EP_BUFFERING 0x1
89 #define OZ_F_EP_HAVE_STREAM 0x2
91 /* Holds state information about a USB interface.
98 /* Holds state information about an hcd port.
100 #define OZ_NB_ENDPOINTS 16
105 struct oz_hcd
*ozhcd
;
106 spinlock_t port_lock
;
111 struct oz_interface
*iface
;
112 struct oz_endpoint
*out_ep
[OZ_NB_ENDPOINTS
];
113 struct oz_endpoint
*in_ep
[OZ_NB_ENDPOINTS
];
114 struct list_head isoc_out_ep
;
115 struct list_head isoc_in_ep
;
117 #define OZ_PORT_F_PRESENT 0x1
118 #define OZ_PORT_F_CHANGED 0x2
119 #define OZ_PORT_F_DYING 0x4
121 /* Data structure in the private context area of struct usb_hcd.
123 #define OZ_NB_PORTS 8
126 struct list_head urb_pending_list
;
127 struct list_head urb_cancel_list
;
128 struct list_head orphanage
;
129 int conn_port
; /* Port that is currently connecting, -1 if none.*/
130 struct oz_port ports
[OZ_NB_PORTS
];
134 /* Bits in flags field.
136 #define OZ_HDC_F_SUSPENDED 0x1
138 /*------------------------------------------------------------------------------
139 * Static function prototypes.
141 static int oz_hcd_start(struct usb_hcd
*hcd
);
142 static void oz_hcd_stop(struct usb_hcd
*hcd
);
143 static void oz_hcd_shutdown(struct usb_hcd
*hcd
);
144 static int oz_hcd_urb_enqueue(struct usb_hcd
*hcd
, struct urb
*urb
,
146 static int oz_hcd_urb_dequeue(struct usb_hcd
*hcd
, struct urb
*urb
, int status
);
147 static void oz_hcd_endpoint_disable(struct usb_hcd
*hcd
,
148 struct usb_host_endpoint
*ep
);
149 static void oz_hcd_endpoint_reset(struct usb_hcd
*hcd
,
150 struct usb_host_endpoint
*ep
);
151 static int oz_hcd_get_frame_number(struct usb_hcd
*hcd
);
152 static int oz_hcd_hub_status_data(struct usb_hcd
*hcd
, char *buf
);
153 static int oz_hcd_hub_control(struct usb_hcd
*hcd
, u16 req_type
, u16 wvalue
,
154 u16 windex
, char *buf
, u16 wlength
);
155 static int oz_hcd_bus_suspend(struct usb_hcd
*hcd
);
156 static int oz_hcd_bus_resume(struct usb_hcd
*hcd
);
157 static int oz_plat_probe(struct platform_device
*dev
);
158 static int oz_plat_remove(struct platform_device
*dev
);
159 static void oz_plat_shutdown(struct platform_device
*dev
);
160 static int oz_plat_suspend(struct platform_device
*dev
, pm_message_t msg
);
161 static int oz_plat_resume(struct platform_device
*dev
);
162 static void oz_urb_process_tasklet(unsigned long unused
);
163 static int oz_build_endpoints_for_config(struct usb_hcd
*hcd
,
164 struct oz_port
*port
, struct usb_host_config
*config
,
166 static void oz_clean_endpoints_for_config(struct usb_hcd
*hcd
,
167 struct oz_port
*port
);
168 static int oz_build_endpoints_for_interface(struct usb_hcd
*hcd
,
169 struct oz_port
*port
,
170 struct usb_host_interface
*intf
, gfp_t mem_flags
);
171 static void oz_clean_endpoints_for_interface(struct usb_hcd
*hcd
,
172 struct oz_port
*port
, int if_ix
);
173 static void oz_process_ep0_urb(struct oz_hcd
*ozhcd
, struct urb
*urb
,
175 static struct oz_urb_link
*oz_remove_urb(struct oz_endpoint
*ep
,
177 static void oz_hcd_clear_orphanage(struct oz_hcd
*ozhcd
, int status
);
178 /*------------------------------------------------------------------------------
179 * Static external variables.
181 static struct platform_device
*g_plat_dev
;
182 static struct oz_hcd
*g_ozhcd
;
183 static DEFINE_SPINLOCK(g_hcdlock
); /* Guards g_ozhcd. */
184 static const char g_hcd_name
[] = "Ozmo WPAN";
185 static struct list_head
*g_link_pool
;
186 static int g_link_pool_size
;
187 static DEFINE_SPINLOCK(g_link_lock
);
188 static DEFINE_SPINLOCK(g_tasklet_lock
);
189 static struct tasklet_struct g_urb_process_tasklet
;
190 static struct tasklet_struct g_urb_cancel_tasklet
;
191 static atomic_t g_pending_urbs
= ATOMIC_INIT(0);
192 static const struct hc_driver g_oz_hc_drv
= {
193 .description
= g_hcd_name
,
194 .product_desc
= "Ozmo Devices WPAN",
195 .hcd_priv_size
= sizeof(struct oz_hcd
),
197 .start
= oz_hcd_start
,
199 .shutdown
= oz_hcd_shutdown
,
200 .urb_enqueue
= oz_hcd_urb_enqueue
,
201 .urb_dequeue
= oz_hcd_urb_dequeue
,
202 .endpoint_disable
= oz_hcd_endpoint_disable
,
203 .endpoint_reset
= oz_hcd_endpoint_reset
,
204 .get_frame_number
= oz_hcd_get_frame_number
,
205 .hub_status_data
= oz_hcd_hub_status_data
,
206 .hub_control
= oz_hcd_hub_control
,
207 .bus_suspend
= oz_hcd_bus_suspend
,
208 .bus_resume
= oz_hcd_bus_resume
,
211 static struct platform_driver g_oz_plat_drv
= {
212 .probe
= oz_plat_probe
,
213 .remove
= oz_plat_remove
,
214 .shutdown
= oz_plat_shutdown
,
215 .suspend
= oz_plat_suspend
,
216 .resume
= oz_plat_resume
,
218 .name
= OZ_PLAT_DEV_NAME
,
219 .owner
= THIS_MODULE
,
222 /*------------------------------------------------------------------------------
223 * Gets our private context area (which is of type struct oz_hcd) from the
227 static inline struct oz_hcd
*oz_hcd_private(struct usb_hcd
*hcd
)
229 return (struct oz_hcd
*)hcd
->hcd_priv
;
231 /*------------------------------------------------------------------------------
232 * Searches list of ports to find the index of the one with a specified USB
233 * bus address. If none of the ports has the bus address then the connection
234 * port is returned, if there is one or -1 otherwise.
237 static int oz_get_port_from_addr(struct oz_hcd
*ozhcd
, u8 bus_addr
)
240 for (i
= 0; i
< OZ_NB_PORTS
; i
++) {
241 if (ozhcd
->ports
[i
].bus_addr
== bus_addr
)
244 return ozhcd
->conn_port
;
246 /*------------------------------------------------------------------------------
247 * Allocates an urb link, first trying the pool but going to heap if empty.
250 static struct oz_urb_link
*oz_alloc_urb_link(void)
252 struct oz_urb_link
*urbl
= NULL
;
253 unsigned long irq_state
;
254 spin_lock_irqsave(&g_link_lock
, irq_state
);
256 urbl
= container_of(g_link_pool
, struct oz_urb_link
, link
);
257 g_link_pool
= urbl
->link
.next
;
260 spin_unlock_irqrestore(&g_link_lock
, irq_state
);
262 urbl
= kmalloc(sizeof(struct oz_urb_link
), GFP_ATOMIC
);
265 /*------------------------------------------------------------------------------
266 * Frees an urb link by putting it in the pool if there is enough space or
267 * deallocating it to heap otherwise.
270 static void oz_free_urb_link(struct oz_urb_link
*urbl
)
273 unsigned long irq_state
;
274 spin_lock_irqsave(&g_link_lock
, irq_state
);
275 if (g_link_pool_size
< OZ_MAX_LINK_POOL_SIZE
) {
276 urbl
->link
.next
= g_link_pool
;
277 g_link_pool
= &urbl
->link
;
281 spin_unlock_irqrestore(&g_link_lock
, irq_state
);
285 /*------------------------------------------------------------------------------
286 * Deallocates all the urb links in the pool.
289 static void oz_empty_link_pool(void)
292 unsigned long irq_state
;
293 spin_lock_irqsave(&g_link_lock
, irq_state
);
296 g_link_pool_size
= 0;
297 spin_unlock_irqrestore(&g_link_lock
, irq_state
);
299 struct oz_urb_link
*urbl
=
300 container_of(e
, struct oz_urb_link
, link
);
305 /*------------------------------------------------------------------------------
306 * Allocates endpoint structure and optionally a buffer. If a buffer is
307 * allocated it immediately follows the endpoint structure.
310 static struct oz_endpoint
*oz_ep_alloc(gfp_t mem_flags
, int buffer_size
)
312 struct oz_endpoint
*ep
=
313 kzalloc(sizeof(struct oz_endpoint
)+buffer_size
, mem_flags
);
315 INIT_LIST_HEAD(&ep
->urb_list
);
316 INIT_LIST_HEAD(&ep
->link
);
319 ep
->buffer_size
= buffer_size
;
320 ep
->buffer
= (u8
*)(ep
+1);
325 /*------------------------------------------------------------------------------
326 * Pre-condition: Must be called with g_tasklet_lock held and interrupts
328 * Context: softirq or process
330 static struct oz_urb_link
*oz_uncancel_urb(struct oz_hcd
*ozhcd
, struct urb
*urb
)
332 struct oz_urb_link
*urbl
;
334 list_for_each(e
, &ozhcd
->urb_cancel_list
) {
335 urbl
= container_of(e
, struct oz_urb_link
, link
);
336 if (urb
== urbl
->urb
) {
343 /*------------------------------------------------------------------------------
344 * This is called when we have finished processing an urb. It unlinks it from
345 * the ep and returns it to the core.
346 * Context: softirq or process
348 static void oz_complete_urb(struct usb_hcd
*hcd
, struct urb
*urb
,
349 int status
, unsigned long submit_jiffies
)
351 struct oz_hcd
*ozhcd
= oz_hcd_private(hcd
);
352 unsigned long irq_state
;
353 struct oz_urb_link
*cancel_urbl
= NULL
;
354 spin_lock_irqsave(&g_tasklet_lock
, irq_state
);
355 usb_hcd_unlink_urb_from_ep(hcd
, urb
);
356 /* Clear hcpriv which will prevent it being put in the cancel list
357 * in the event that an attempt is made to cancel it.
360 /* Walk the cancel list in case the urb is already sitting there.
361 * Since we process the cancel list in a tasklet rather than in
362 * the dequeue function this could happen.
364 cancel_urbl
= oz_uncancel_urb(ozhcd
, urb
);
365 /* Note: we release lock but do not enable local irqs.
366 * It appears that usb_hcd_giveback_urb() expects irqs to be disabled,
367 * or at least other host controllers disable interrupts at this point
368 * so we do the same. We must, however, release the lock otherwise a
369 * deadlock will occur if an urb is submitted to our driver in the urb
370 * completion function. Because we disable interrupts it is possible
371 * that the urb_enqueue function can be called with them disabled.
373 spin_unlock(&g_tasklet_lock
);
374 if (oz_forget_urb(urb
)) {
375 oz_trace("OZWPAN: ERROR Unknown URB %p\n", urb
);
377 static unsigned long last_time
;
378 atomic_dec(&g_pending_urbs
);
379 oz_trace2(OZ_TRACE_URB
,
380 "%lu: giveback_urb(%p,%x) %lu %lu pending:%d\n",
381 jiffies
, urb
, status
, jiffies
-submit_jiffies
,
382 jiffies
-last_time
, atomic_read(&g_pending_urbs
));
384 oz_event_log(OZ_EVT_URB_DONE
, 0, 0, urb
, status
);
385 usb_hcd_giveback_urb(hcd
, urb
, status
);
387 spin_lock(&g_tasklet_lock
);
388 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
390 oz_free_urb_link(cancel_urbl
);
392 /*------------------------------------------------------------------------------
393 * Deallocates an endpoint including deallocating any associated stream and
394 * returning any queued urbs to the core.
397 static void oz_ep_free(struct oz_port
*port
, struct oz_endpoint
*ep
)
399 oz_trace("oz_ep_free()\n");
401 struct list_head list
;
402 struct oz_hcd
*ozhcd
= port
->ozhcd
;
403 INIT_LIST_HEAD(&list
);
404 if (ep
->flags
& OZ_F_EP_HAVE_STREAM
)
405 oz_usb_stream_delete(port
->hpd
, ep
->ep_num
);
406 /* Transfer URBs to the orphanage while we hold the lock. */
407 spin_lock_bh(&ozhcd
->hcd_lock
);
408 /* Note: this works even if ep->urb_list is empty.*/
409 list_replace_init(&ep
->urb_list
, &list
);
410 /* Put the URBs in the orphanage. */
411 list_splice_tail(&list
, &ozhcd
->orphanage
);
412 spin_unlock_bh(&ozhcd
->hcd_lock
);
414 oz_trace("Freeing endpoint memory\n");
417 /*------------------------------------------------------------------------------
420 static void oz_complete_buffered_urb(struct oz_port
*port
,
421 struct oz_endpoint
*ep
,
424 u8 data_len
, available_space
, copy_len
;
426 memcpy(&data_len
, &ep
->buffer
[ep
->out_ix
], sizeof(u8
));
427 if (data_len
<= urb
->transfer_buffer_length
)
428 available_space
= data_len
;
430 available_space
= urb
->transfer_buffer_length
;
432 if (++ep
->out_ix
== ep
->buffer_size
)
434 copy_len
= ep
->buffer_size
- ep
->out_ix
;
435 if (copy_len
>= available_space
)
436 copy_len
= available_space
;
437 memcpy(urb
->transfer_buffer
, &ep
->buffer
[ep
->out_ix
], copy_len
);
439 if (copy_len
< available_space
) {
440 memcpy((urb
->transfer_buffer
+ copy_len
), ep
->buffer
,
441 (available_space
- copy_len
));
442 ep
->out_ix
= available_space
- copy_len
;
444 ep
->out_ix
+= copy_len
;
446 urb
->actual_length
= available_space
;
447 if (ep
->out_ix
== ep
->buffer_size
)
450 ep
->buffered_units
--;
451 oz_trace("Trying to give back buffered frame of size=%d\n",
453 oz_complete_urb(port
->ozhcd
->hcd
, urb
, 0, 0);
456 /*------------------------------------------------------------------------------
459 static int oz_enqueue_ep_urb(struct oz_port
*port
, u8 ep_addr
, int in_dir
,
460 struct urb
*urb
, u8 req_id
)
462 struct oz_urb_link
*urbl
;
463 struct oz_endpoint
*ep
;
465 if (ep_addr
>= OZ_NB_ENDPOINTS
) {
466 oz_trace("Invalid endpoint number in oz_enqueue_ep_urb().\n");
469 urbl
= oz_alloc_urb_link();
472 urbl
->submit_jiffies
= jiffies
;
474 urbl
->req_id
= req_id
;
475 urbl
->ep_num
= ep_addr
;
476 /* Hold lock while we insert the URB into the list within the
477 * endpoint structure.
479 spin_lock_bh(&port
->ozhcd
->hcd_lock
);
480 /* If the urb has been unlinked while out of any list then
484 spin_unlock_bh(&port
->ozhcd
->hcd_lock
);
485 oz_trace("urb %p unlinked so complete immediately\n", urb
);
486 oz_complete_urb(port
->ozhcd
->hcd
, urb
, 0, 0);
487 oz_free_urb_link(urbl
);
491 ep
= port
->in_ep
[ep_addr
];
493 ep
= port
->out_ep
[ep_addr
];
495 /*For interrupt endpoint check for buffered data
498 if (((ep
->attrib
& USB_ENDPOINT_XFERTYPE_MASK
) == USB_ENDPOINT_XFER_INT
)
499 && ep
->buffered_units
> 0) {
500 oz_free_urb_link(urbl
);
501 spin_unlock_bh(&port
->ozhcd
->hcd_lock
);
502 oz_complete_buffered_urb(port
, ep
, urb
);
506 if (ep
&& port
->hpd
) {
507 list_add_tail(&urbl
->link
, &ep
->urb_list
);
508 if (!in_dir
&& ep_addr
&& (ep
->credit
< 0)) {
509 ep
->last_jiffies
= jiffies
;
511 oz_event_log(OZ_EVT_EP_CREDIT
, ep
->ep_num
,
512 0, NULL
, ep
->credit
);
517 spin_unlock_bh(&port
->ozhcd
->hcd_lock
);
519 oz_free_urb_link(urbl
);
522 /*------------------------------------------------------------------------------
523 * Removes an urb from the queue in the endpoint.
524 * Returns 0 if it is found and -EIDRM otherwise.
527 static int oz_dequeue_ep_urb(struct oz_port
*port
, u8 ep_addr
, int in_dir
,
530 struct oz_urb_link
*urbl
= NULL
;
531 struct oz_endpoint
*ep
;
532 spin_lock_bh(&port
->ozhcd
->hcd_lock
);
534 ep
= port
->in_ep
[ep_addr
];
536 ep
= port
->out_ep
[ep_addr
];
539 list_for_each(e
, &ep
->urb_list
) {
540 urbl
= container_of(e
, struct oz_urb_link
, link
);
541 if (urbl
->urb
== urb
) {
548 spin_unlock_bh(&port
->ozhcd
->hcd_lock
);
550 oz_free_urb_link(urbl
);
551 return urbl
? 0 : -EIDRM
;
553 /*------------------------------------------------------------------------------
554 * Finds an urb given its request id.
557 static struct urb
*oz_find_urb_by_id(struct oz_port
*port
, int ep_ix
,
560 struct oz_hcd
*ozhcd
= port
->ozhcd
;
561 struct urb
*urb
= NULL
;
562 struct oz_urb_link
*urbl
= NULL
;
563 struct oz_endpoint
*ep
;
565 spin_lock_bh(&ozhcd
->hcd_lock
);
566 ep
= port
->out_ep
[ep_ix
];
569 list_for_each(e
, &ep
->urb_list
) {
570 urbl
= container_of(e
, struct oz_urb_link
, link
);
571 if (urbl
->req_id
== req_id
) {
578 spin_unlock_bh(&ozhcd
->hcd_lock
);
579 /* If urb is non-zero then we we must have an urb link to delete.
582 oz_free_urb_link(urbl
);
585 /*------------------------------------------------------------------------------
586 * Pre-condition: Port lock must be held.
589 static void oz_acquire_port(struct oz_port
*port
, void *hpd
)
591 INIT_LIST_HEAD(&port
->isoc_out_ep
);
592 INIT_LIST_HEAD(&port
->isoc_in_ep
);
593 port
->flags
|= OZ_PORT_F_PRESENT
| OZ_PORT_F_CHANGED
;
594 port
->status
|= USB_PORT_STAT_CONNECTION
|
595 (USB_PORT_STAT_C_CONNECTION
<< 16);
599 /*------------------------------------------------------------------------------
602 static struct oz_hcd
*oz_hcd_claim(void)
604 struct oz_hcd
*ozhcd
;
605 spin_lock_bh(&g_hcdlock
);
608 usb_get_hcd(ozhcd
->hcd
);
609 spin_unlock_bh(&g_hcdlock
);
612 /*------------------------------------------------------------------------------
615 static inline void oz_hcd_put(struct oz_hcd
*ozhcd
)
618 usb_put_hcd(ozhcd
->hcd
);
620 /*------------------------------------------------------------------------------
621 * This is called by the protocol handler to notify that a PD has arrived.
622 * We allocate a port to associate with the PD and create a structure for
623 * endpoint 0. This port is made the connection port.
624 * In the event that one of the other port is already a connection port then
626 * TODO We should be able to do better than fail and should be able remember
627 * that this port needs configuring and make it the connection port once the
628 * current connection port has been assigned an address. Collisions here are
629 * probably very rare indeed.
632 void *oz_hcd_pd_arrived(void *hpd
)
636 struct oz_hcd
*ozhcd
= NULL
;
637 struct oz_endpoint
*ep
;
638 oz_trace("oz_hcd_pd_arrived()\n");
639 ozhcd
= oz_hcd_claim();
642 /* Allocate an endpoint object in advance (before holding hcd lock) to
643 * use for out endpoint 0.
645 ep
= oz_ep_alloc(GFP_ATOMIC
, 0);
646 spin_lock_bh(&ozhcd
->hcd_lock
);
647 if (ozhcd
->conn_port
>= 0) {
648 spin_unlock_bh(&ozhcd
->hcd_lock
);
649 oz_trace("conn_port >= 0\n");
652 for (i
= 0; i
< OZ_NB_PORTS
; i
++) {
653 struct oz_port
*port
= &ozhcd
->ports
[i
];
654 spin_lock(&port
->port_lock
);
655 if ((port
->flags
& OZ_PORT_F_PRESENT
) == 0) {
656 oz_acquire_port(port
, hpd
);
657 spin_unlock(&port
->port_lock
);
660 spin_unlock(&port
->port_lock
);
662 if (i
< OZ_NB_PORTS
) {
663 oz_trace("Setting conn_port = %d\n", i
);
664 ozhcd
->conn_port
= i
;
665 /* Attach out endpoint 0.
667 ozhcd
->ports
[i
].out_ep
[0] = ep
;
669 hport
= &ozhcd
->ports
[i
];
670 spin_unlock_bh(&ozhcd
->hcd_lock
);
671 if (ozhcd
->flags
& OZ_HDC_F_SUSPENDED
) {
672 oz_trace("Resuming root hub\n");
673 usb_hcd_resume_root_hub(ozhcd
->hcd
);
675 usb_hcd_poll_rh_status(ozhcd
->hcd
);
677 spin_unlock_bh(&ozhcd
->hcd_lock
);
680 if (ep
) /* ep is non-null if not used. */
681 oz_ep_free(NULL
, ep
);
685 /*------------------------------------------------------------------------------
686 * This is called by the protocol handler to notify that the PD has gone away.
687 * We need to deallocate all resources and then request that the root hub is
688 * polled. We release the reference we hold on the PD.
691 void oz_hcd_pd_departed(void *hport
)
693 struct oz_port
*port
= (struct oz_port
*)hport
;
694 struct oz_hcd
*ozhcd
;
696 struct oz_endpoint
*ep
= NULL
;
698 oz_trace("oz_hcd_pd_departed()\n");
700 oz_trace("oz_hcd_pd_departed() port = 0\n");
706 /* Check if this is the connection port - if so clear it.
708 spin_lock_bh(&ozhcd
->hcd_lock
);
709 if ((ozhcd
->conn_port
>= 0) &&
710 (port
== &ozhcd
->ports
[ozhcd
->conn_port
])) {
711 oz_trace("Clearing conn_port\n");
712 ozhcd
->conn_port
= -1;
714 spin_lock(&port
->port_lock
);
715 port
->flags
|= OZ_PORT_F_DYING
;
716 spin_unlock(&port
->port_lock
);
717 spin_unlock_bh(&ozhcd
->hcd_lock
);
719 oz_clean_endpoints_for_config(ozhcd
->hcd
, port
);
720 spin_lock_bh(&port
->port_lock
);
723 port
->bus_addr
= 0xff;
724 port
->flags
&= ~(OZ_PORT_F_PRESENT
| OZ_PORT_F_DYING
);
725 port
->flags
|= OZ_PORT_F_CHANGED
;
726 port
->status
&= ~USB_PORT_STAT_CONNECTION
;
727 port
->status
|= (USB_PORT_STAT_C_CONNECTION
<< 16);
728 /* If there is an endpont 0 then clear the pointer while we hold
729 * the spinlock be we deallocate it after releasing the lock.
731 if (port
->out_ep
[0]) {
732 ep
= port
->out_ep
[0];
733 port
->out_ep
[0] = NULL
;
735 spin_unlock_bh(&port
->port_lock
);
737 oz_ep_free(port
, ep
);
738 usb_hcd_poll_rh_status(ozhcd
->hcd
);
741 /*------------------------------------------------------------------------------
744 void oz_hcd_pd_reset(void *hpd
, void *hport
)
746 /* Cleanup the current configuration and report reset to the core.
748 struct oz_port
*port
= (struct oz_port
*)hport
;
749 struct oz_hcd
*ozhcd
= port
->ozhcd
;
750 oz_trace("PD Reset\n");
751 spin_lock_bh(&port
->port_lock
);
752 port
->flags
|= OZ_PORT_F_CHANGED
;
753 port
->status
|= USB_PORT_STAT_RESET
;
754 port
->status
|= (USB_PORT_STAT_C_RESET
<< 16);
755 spin_unlock_bh(&port
->port_lock
);
756 oz_clean_endpoints_for_config(ozhcd
->hcd
, port
);
757 usb_hcd_poll_rh_status(ozhcd
->hcd
);
759 /*------------------------------------------------------------------------------
762 void oz_hcd_get_desc_cnf(void *hport
, u8 req_id
, int status
, const u8
*desc
,
763 int length
, int offset
, int total_size
)
765 struct oz_port
*port
= (struct oz_port
*)hport
;
769 oz_event_log(OZ_EVT_CTRL_CNF
, 0, req_id
, NULL
, status
);
770 oz_trace("oz_hcd_get_desc_cnf length = %d offs = %d tot_size = %d\n",
771 length
, offset
, total_size
);
772 urb
= oz_find_urb_by_id(port
, 0, req_id
);
777 int required_size
= urb
->transfer_buffer_length
;
778 if (required_size
> total_size
)
779 required_size
= total_size
;
780 copy_len
= required_size
-offset
;
781 if (length
<= copy_len
)
783 memcpy(urb
->transfer_buffer
+offset
, desc
, copy_len
);
785 if (offset
< required_size
) {
786 struct usb_ctrlrequest
*setup
=
787 (struct usb_ctrlrequest
*)urb
->setup_packet
;
788 unsigned wvalue
= le16_to_cpu(setup
->wValue
);
789 if (oz_enqueue_ep_urb(port
, 0, 0, urb
, req_id
))
791 else if (oz_usb_get_desc_req(port
->hpd
, req_id
,
792 setup
->bRequestType
, (u8
)(wvalue
>>8),
793 (u8
)wvalue
, setup
->wIndex
, offset
,
794 required_size
-offset
)) {
795 oz_dequeue_ep_urb(port
, 0, 0, urb
);
802 urb
->actual_length
= total_size
;
803 oz_complete_urb(port
->ozhcd
->hcd
, urb
, 0, 0);
805 /*------------------------------------------------------------------------------
809 static void oz_display_conf_type(u8 t
)
812 case USB_REQ_GET_STATUS
:
813 oz_trace("USB_REQ_GET_STATUS - cnf\n");
815 case USB_REQ_CLEAR_FEATURE
:
816 oz_trace("USB_REQ_CLEAR_FEATURE - cnf\n");
818 case USB_REQ_SET_FEATURE
:
819 oz_trace("USB_REQ_SET_FEATURE - cnf\n");
821 case USB_REQ_SET_ADDRESS
:
822 oz_trace("USB_REQ_SET_ADDRESS - cnf\n");
824 case USB_REQ_GET_DESCRIPTOR
:
825 oz_trace("USB_REQ_GET_DESCRIPTOR - cnf\n");
827 case USB_REQ_SET_DESCRIPTOR
:
828 oz_trace("USB_REQ_SET_DESCRIPTOR - cnf\n");
830 case USB_REQ_GET_CONFIGURATION
:
831 oz_trace("USB_REQ_GET_CONFIGURATION - cnf\n");
833 case USB_REQ_SET_CONFIGURATION
:
834 oz_trace("USB_REQ_SET_CONFIGURATION - cnf\n");
836 case USB_REQ_GET_INTERFACE
:
837 oz_trace("USB_REQ_GET_INTERFACE - cnf\n");
839 case USB_REQ_SET_INTERFACE
:
840 oz_trace("USB_REQ_SET_INTERFACE - cnf\n");
842 case USB_REQ_SYNCH_FRAME
:
843 oz_trace("USB_REQ_SYNCH_FRAME - cnf\n");
848 #define oz_display_conf_type(__x)
849 #endif /* WANT_TRACE */
850 /*------------------------------------------------------------------------------
853 static void oz_hcd_complete_set_config(struct oz_port
*port
, struct urb
*urb
,
854 u8 rcode
, u8 config_num
)
857 struct usb_hcd
*hcd
= port
->ozhcd
->hcd
;
859 port
->config_num
= config_num
;
860 oz_clean_endpoints_for_config(hcd
, port
);
861 if (oz_build_endpoints_for_config(hcd
, port
,
862 &urb
->dev
->config
[port
->config_num
-1], GFP_ATOMIC
)) {
868 oz_complete_urb(hcd
, urb
, rc
, 0);
870 /*------------------------------------------------------------------------------
873 static void oz_hcd_complete_set_interface(struct oz_port
*port
, struct urb
*urb
,
874 u8 rcode
, u8 if_num
, u8 alt
)
876 struct usb_hcd
*hcd
= port
->ozhcd
->hcd
;
879 struct usb_host_config
*config
;
880 struct usb_host_interface
*intf
;
881 oz_trace("Set interface %d alt %d\n", if_num
, alt
);
882 oz_clean_endpoints_for_interface(hcd
, port
, if_num
);
883 config
= &urb
->dev
->config
[port
->config_num
-1];
884 intf
= &config
->intf_cache
[if_num
]->altsetting
[alt
];
885 if (oz_build_endpoints_for_interface(hcd
, port
, intf
,
889 port
->iface
[if_num
].alt
= alt
;
893 oz_complete_urb(hcd
, urb
, rc
, 0);
895 /*------------------------------------------------------------------------------
898 void oz_hcd_control_cnf(void *hport
, u8 req_id
, u8 rcode
, const u8
*data
,
901 struct oz_port
*port
= (struct oz_port
*)hport
;
903 struct usb_ctrlrequest
*setup
;
904 struct usb_hcd
*hcd
= port
->ozhcd
->hcd
;
908 oz_event_log(OZ_EVT_CTRL_CNF
, 0, req_id
, NULL
, rcode
);
909 oz_trace("oz_hcd_control_cnf rcode=%u len=%d\n", rcode
, data_len
);
910 urb
= oz_find_urb_by_id(port
, 0, req_id
);
912 oz_trace("URB not found\n");
915 setup
= (struct usb_ctrlrequest
*)urb
->setup_packet
;
916 windex
= le16_to_cpu(setup
->wIndex
);
917 wvalue
= le16_to_cpu(setup
->wValue
);
918 if ((setup
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_STANDARD
) {
919 /* Standard requests */
920 oz_display_conf_type(setup
->bRequest
);
921 switch (setup
->bRequest
) {
922 case USB_REQ_SET_CONFIGURATION
:
923 oz_hcd_complete_set_config(port
, urb
, rcode
,
926 case USB_REQ_SET_INTERFACE
:
927 oz_hcd_complete_set_interface(port
, urb
, rcode
,
928 (u8
)windex
, (u8
)wvalue
);
931 oz_complete_urb(hcd
, urb
, 0, 0);
936 oz_trace("VENDOR-CLASS - cnf\n");
938 if (data_len
<= urb
->transfer_buffer_length
)
941 copy_len
= urb
->transfer_buffer_length
;
942 memcpy(urb
->transfer_buffer
, data
, copy_len
);
943 urb
->actual_length
= copy_len
;
945 oz_complete_urb(hcd
, urb
, 0, 0);
948 /*------------------------------------------------------------------------------
949 * Context: softirq-serialized
951 static int oz_hcd_buffer_data(struct oz_endpoint
*ep
, const u8
*data
,
958 space
= ep
->out_ix
-ep
->in_ix
-1;
960 space
+= ep
->buffer_size
;
961 if (space
< (data_len
+1)) {
962 oz_trace("Buffer full\n");
965 ep
->buffer
[ep
->in_ix
] = (u8
)data_len
;
966 if (++ep
->in_ix
== ep
->buffer_size
)
968 copy_len
= ep
->buffer_size
- ep
->in_ix
;
969 if (copy_len
> data_len
)
971 memcpy(&ep
->buffer
[ep
->in_ix
], data
, copy_len
);
973 if (copy_len
< data_len
) {
974 memcpy(ep
->buffer
, data
+copy_len
, data_len
-copy_len
);
975 ep
->in_ix
= data_len
-copy_len
;
977 ep
->in_ix
+= copy_len
;
979 if (ep
->in_ix
== ep
->buffer_size
)
981 ep
->buffered_units
++;
984 /*------------------------------------------------------------------------------
985 * Context: softirq-serialized
987 void oz_hcd_data_ind(void *hport
, u8 endpoint
, const u8
*data
, int data_len
)
989 struct oz_port
*port
= (struct oz_port
*)hport
;
990 struct oz_endpoint
*ep
;
991 struct oz_hcd
*ozhcd
= port
->ozhcd
;
992 spin_lock_bh(&ozhcd
->hcd_lock
);
993 ep
= port
->in_ep
[endpoint
& USB_ENDPOINT_NUMBER_MASK
];
996 switch (ep
->attrib
& USB_ENDPOINT_XFERTYPE_MASK
) {
997 case USB_ENDPOINT_XFER_INT
:
998 case USB_ENDPOINT_XFER_BULK
:
999 if (!list_empty(&ep
->urb_list
)) {
1000 struct oz_urb_link
*urbl
=
1001 list_first_entry(&ep
->urb_list
,
1002 struct oz_urb_link
, link
);
1005 list_del_init(&urbl
->link
);
1006 spin_unlock_bh(&ozhcd
->hcd_lock
);
1008 oz_free_urb_link(urbl
);
1009 if (data_len
<= urb
->transfer_buffer_length
)
1010 copy_len
= data_len
;
1012 copy_len
= urb
->transfer_buffer_length
;
1013 memcpy(urb
->transfer_buffer
, data
, copy_len
);
1014 urb
->actual_length
= copy_len
;
1015 oz_complete_urb(port
->ozhcd
->hcd
, urb
, 0, 0);
1018 oz_trace("buffering frame as URB is not available\n");
1019 oz_hcd_buffer_data(ep
, data
, data_len
);
1022 case USB_ENDPOINT_XFER_ISOC
:
1023 oz_hcd_buffer_data(ep
, data
, data_len
);
1027 spin_unlock_bh(&ozhcd
->hcd_lock
);
1029 /*------------------------------------------------------------------------------
1032 static inline int oz_usb_get_frame_number(void)
1034 return jiffies_to_msecs(get_jiffies_64());
1036 /*------------------------------------------------------------------------------
1039 int oz_hcd_heartbeat(void *hport
)
1042 struct oz_port
*port
= (struct oz_port
*)hport
;
1043 struct oz_hcd
*ozhcd
= port
->ozhcd
;
1044 struct oz_urb_link
*urbl
;
1045 struct list_head xfr_list
;
1046 struct list_head
*e
;
1047 struct list_head
*n
;
1049 struct oz_endpoint
*ep
;
1050 unsigned long now
= jiffies
;
1051 INIT_LIST_HEAD(&xfr_list
);
1052 /* Check the OUT isoc endpoints to see if any URB data can be sent.
1054 spin_lock_bh(&ozhcd
->hcd_lock
);
1055 list_for_each(e
, &port
->isoc_out_ep
) {
1056 ep
= ep_from_link(e
);
1059 ep
->credit
+= jiffies_to_msecs(now
- ep
->last_jiffies
);
1060 if (ep
->credit
> ep
->credit_ceiling
)
1061 ep
->credit
= ep
->credit_ceiling
;
1062 oz_event_log(OZ_EVT_EP_CREDIT
, ep
->ep_num
, 0, NULL
,
1064 ep
->last_jiffies
= now
;
1065 while (ep
->credit
&& !list_empty(&ep
->urb_list
)) {
1066 urbl
= list_first_entry(&ep
->urb_list
,
1067 struct oz_urb_link
, link
);
1069 if ((ep
->credit
+ 1) < urb
->number_of_packets
)
1071 ep
->credit
-= urb
->number_of_packets
;
1072 oz_event_log(OZ_EVT_EP_CREDIT
, ep
->ep_num
, 0, NULL
,
1074 list_move_tail(&urbl
->link
, &xfr_list
);
1077 spin_unlock_bh(&ozhcd
->hcd_lock
);
1078 /* Send to PD and complete URBs.
1080 list_for_each_safe(e
, n
, &xfr_list
) {
1082 urbl
= container_of(e
, struct oz_urb_link
, link
);
1084 t
= urbl
->submit_jiffies
;
1086 urb
->error_count
= 0;
1087 urb
->start_frame
= oz_usb_get_frame_number();
1088 oz_usb_send_isoc(port
->hpd
, urbl
->ep_num
, urb
);
1089 oz_free_urb_link(urbl
);
1090 oz_complete_urb(port
->ozhcd
->hcd
, urb
, 0, t
);
1092 /* Check the IN isoc endpoints to see if any URBs can be completed.
1094 spin_lock_bh(&ozhcd
->hcd_lock
);
1095 list_for_each(e
, &port
->isoc_in_ep
) {
1096 struct oz_endpoint
*ep
= ep_from_link(e
);
1097 if (ep
->flags
& OZ_F_EP_BUFFERING
) {
1098 if (ep
->buffered_units
>= OZ_IN_BUFFERING_UNITS
) {
1099 ep
->flags
&= ~OZ_F_EP_BUFFERING
;
1101 oz_event_log(OZ_EVT_EP_CREDIT
,
1102 ep
->ep_num
| USB_DIR_IN
,
1103 0, NULL
, ep
->credit
);
1104 ep
->last_jiffies
= now
;
1105 ep
->start_frame
= 0;
1106 oz_event_log(OZ_EVT_EP_BUFFERING
,
1107 ep
->ep_num
| USB_DIR_IN
, 0, NULL
, 0);
1111 ep
->credit
+= jiffies_to_msecs(now
- ep
->last_jiffies
);
1112 oz_event_log(OZ_EVT_EP_CREDIT
, ep
->ep_num
| USB_DIR_IN
,
1113 0, NULL
, ep
->credit
);
1114 ep
->last_jiffies
= now
;
1115 while (!list_empty(&ep
->urb_list
)) {
1116 struct oz_urb_link
*urbl
=
1117 list_first_entry(&ep
->urb_list
,
1118 struct oz_urb_link
, link
);
1119 struct urb
*urb
= urbl
->urb
;
1123 if ((ep
->credit
+ 1) < urb
->number_of_packets
)
1125 if (ep
->buffered_units
< urb
->number_of_packets
)
1127 urb
->actual_length
= 0;
1128 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
1129 len
= ep
->buffer
[ep
->out_ix
];
1130 if (++ep
->out_ix
== ep
->buffer_size
)
1132 copy_len
= ep
->buffer_size
- ep
->out_ix
;
1135 memcpy(urb
->transfer_buffer
,
1136 &ep
->buffer
[ep
->out_ix
], copy_len
);
1137 if (copy_len
< len
) {
1138 memcpy(urb
->transfer_buffer
+copy_len
,
1139 ep
->buffer
, len
-copy_len
);
1140 ep
->out_ix
= len
-copy_len
;
1142 ep
->out_ix
+= copy_len
;
1143 if (ep
->out_ix
== ep
->buffer_size
)
1145 urb
->iso_frame_desc
[i
].offset
=
1147 urb
->actual_length
+= len
;
1148 urb
->iso_frame_desc
[i
].actual_length
= len
;
1149 urb
->iso_frame_desc
[i
].status
= 0;
1151 ep
->buffered_units
-= urb
->number_of_packets
;
1152 urb
->error_count
= 0;
1153 urb
->start_frame
= ep
->start_frame
;
1154 ep
->start_frame
+= urb
->number_of_packets
;
1155 list_move_tail(&urbl
->link
, &xfr_list
);
1156 ep
->credit
-= urb
->number_of_packets
;
1157 oz_event_log(OZ_EVT_EP_CREDIT
, ep
->ep_num
| USB_DIR_IN
,
1158 0, NULL
, ep
->credit
);
1161 if (!list_empty(&port
->isoc_out_ep
) || !list_empty(&port
->isoc_in_ep
))
1163 spin_unlock_bh(&ozhcd
->hcd_lock
);
1164 /* Complete the filled URBs.
1166 list_for_each_safe(e
, n
, &xfr_list
) {
1167 urbl
= container_of(e
, struct oz_urb_link
, link
);
1170 oz_free_urb_link(urbl
);
1171 oz_complete_urb(port
->ozhcd
->hcd
, urb
, 0, 0);
1173 /* Check if there are any ep0 requests that have timed out.
1174 * If so resent to PD.
1176 ep
= port
->out_ep
[0];
1178 struct list_head
*e
;
1179 struct list_head
*n
;
1180 spin_lock_bh(&ozhcd
->hcd_lock
);
1181 list_for_each_safe(e
, n
, &ep
->urb_list
) {
1182 urbl
= container_of(e
, struct oz_urb_link
, link
);
1183 if (time_after(now
, urbl
->submit_jiffies
+HZ
/2)) {
1184 oz_trace("%ld: Request 0x%p timeout\n",
1186 urbl
->submit_jiffies
= now
;
1187 list_move_tail(e
, &xfr_list
);
1190 if (!list_empty(&ep
->urb_list
))
1192 spin_unlock_bh(&ozhcd
->hcd_lock
);
1194 while (e
!= &xfr_list
) {
1195 urbl
= container_of(e
, struct oz_urb_link
, link
);
1197 oz_trace("Resending request to PD.\n");
1198 oz_process_ep0_urb(ozhcd
, urbl
->urb
, GFP_ATOMIC
);
1199 oz_free_urb_link(urbl
);
1204 /*------------------------------------------------------------------------------
1207 static int oz_build_endpoints_for_interface(struct usb_hcd
*hcd
,
1208 struct oz_port
*port
,
1209 struct usb_host_interface
*intf
, gfp_t mem_flags
)
1211 struct oz_hcd
*ozhcd
= port
->ozhcd
;
1213 int if_ix
= intf
->desc
.bInterfaceNumber
;
1214 int request_heartbeat
= 0;
1215 oz_trace("interface[%d] = %p\n", if_ix
, intf
);
1216 for (i
= 0; i
< intf
->desc
.bNumEndpoints
; i
++) {
1217 struct usb_host_endpoint
*hep
= &intf
->endpoint
[i
];
1218 u8 ep_addr
= hep
->desc
.bEndpointAddress
;
1219 u8 ep_num
= ep_addr
& USB_ENDPOINT_NUMBER_MASK
;
1220 struct oz_endpoint
*ep
;
1221 int buffer_size
= 0;
1223 oz_trace("%d bEndpointAddress = %x\n", i
, ep_addr
);
1224 if (ep_addr
& USB_ENDPOINT_DIR_MASK
) {
1225 switch (hep
->desc
.bmAttributes
&
1226 USB_ENDPOINT_XFERTYPE_MASK
) {
1227 case USB_ENDPOINT_XFER_ISOC
:
1228 buffer_size
= 24*1024;
1230 case USB_ENDPOINT_XFER_INT
:
1236 ep
= oz_ep_alloc(mem_flags
, buffer_size
);
1238 oz_clean_endpoints_for_interface(hcd
, port
, if_ix
);
1241 ep
->attrib
= hep
->desc
.bmAttributes
;
1242 ep
->ep_num
= ep_num
;
1243 if ((ep
->attrib
& USB_ENDPOINT_XFERTYPE_MASK
)
1244 == USB_ENDPOINT_XFER_ISOC
) {
1245 oz_trace("wMaxPacketSize = %d\n",
1246 hep
->desc
.wMaxPacketSize
);
1247 ep
->credit_ceiling
= 200;
1248 if (ep_addr
& USB_ENDPOINT_DIR_MASK
) {
1249 ep
->flags
|= OZ_F_EP_BUFFERING
;
1250 oz_event_log(OZ_EVT_EP_BUFFERING
,
1251 ep
->ep_num
| USB_DIR_IN
, 1, NULL
, 0);
1253 ep
->flags
|= OZ_F_EP_HAVE_STREAM
;
1254 if (oz_usb_stream_create(port
->hpd
, ep_num
))
1255 ep
->flags
&= ~OZ_F_EP_HAVE_STREAM
;
1258 spin_lock_bh(&ozhcd
->hcd_lock
);
1259 if (ep_addr
& USB_ENDPOINT_DIR_MASK
) {
1260 port
->in_ep
[ep_num
] = ep
;
1261 port
->iface
[if_ix
].ep_mask
|=
1262 (1<<(ep_num
+OZ_NB_ENDPOINTS
));
1263 if ((ep
->attrib
& USB_ENDPOINT_XFERTYPE_MASK
)
1264 == USB_ENDPOINT_XFER_ISOC
) {
1265 list_add_tail(&ep
->link
, &port
->isoc_in_ep
);
1266 request_heartbeat
= 1;
1269 port
->out_ep
[ep_num
] = ep
;
1270 port
->iface
[if_ix
].ep_mask
|= (1<<ep_num
);
1271 if ((ep
->attrib
& USB_ENDPOINT_XFERTYPE_MASK
)
1272 == USB_ENDPOINT_XFER_ISOC
) {
1273 list_add_tail(&ep
->link
, &port
->isoc_out_ep
);
1274 request_heartbeat
= 1;
1277 spin_unlock_bh(&ozhcd
->hcd_lock
);
1278 if (request_heartbeat
&& port
->hpd
)
1279 oz_usb_request_heartbeat(port
->hpd
);
1283 /*------------------------------------------------------------------------------
1286 static void oz_clean_endpoints_for_interface(struct usb_hcd
*hcd
,
1287 struct oz_port
*port
, int if_ix
)
1289 struct oz_hcd
*ozhcd
= port
->ozhcd
;
1292 struct list_head ep_list
;
1294 oz_trace("Deleting endpoints for interface %d\n", if_ix
);
1295 if (if_ix
>= port
->num_iface
)
1297 INIT_LIST_HEAD(&ep_list
);
1298 spin_lock_bh(&ozhcd
->hcd_lock
);
1299 mask
= port
->iface
[if_ix
].ep_mask
;
1300 port
->iface
[if_ix
].ep_mask
= 0;
1301 for (i
= 0; i
< OZ_NB_ENDPOINTS
; i
++) {
1302 struct list_head
*e
;
1303 /* Gather OUT endpoints.
1305 if ((mask
& (1<<i
)) && port
->out_ep
[i
]) {
1306 e
= &port
->out_ep
[i
]->link
;
1307 port
->out_ep
[i
] = NULL
;
1308 /* Remove from isoc list if present.
1310 list_move_tail(e
, &ep_list
);
1312 /* Gather IN endpoints.
1314 if ((mask
& (1<<(i
+OZ_NB_ENDPOINTS
))) && port
->in_ep
[i
]) {
1315 e
= &port
->in_ep
[i
]->link
;
1316 port
->in_ep
[i
] = NULL
;
1317 list_move_tail(e
, &ep_list
);
1320 spin_unlock_bh(&ozhcd
->hcd_lock
);
1321 while (!list_empty(&ep_list
)) {
1322 struct oz_endpoint
*ep
=
1323 list_first_entry(&ep_list
, struct oz_endpoint
, link
);
1324 list_del_init(&ep
->link
);
1325 oz_ep_free(port
, ep
);
1328 /*------------------------------------------------------------------------------
1331 static int oz_build_endpoints_for_config(struct usb_hcd
*hcd
,
1332 struct oz_port
*port
, struct usb_host_config
*config
,
1335 struct oz_hcd
*ozhcd
= port
->ozhcd
;
1337 int num_iface
= config
->desc
.bNumInterfaces
;
1339 struct oz_interface
*iface
;
1341 iface
= kmalloc(num_iface
*sizeof(struct oz_interface
),
1342 mem_flags
| __GFP_ZERO
);
1345 spin_lock_bh(&ozhcd
->hcd_lock
);
1346 port
->iface
= iface
;
1347 port
->num_iface
= num_iface
;
1348 spin_unlock_bh(&ozhcd
->hcd_lock
);
1350 for (i
= 0; i
< num_iface
; i
++) {
1351 struct usb_host_interface
*intf
=
1352 &config
->intf_cache
[i
]->altsetting
[0];
1353 if (oz_build_endpoints_for_interface(hcd
, port
, intf
,
1359 oz_clean_endpoints_for_config(hcd
, port
);
1362 /*------------------------------------------------------------------------------
1365 static void oz_clean_endpoints_for_config(struct usb_hcd
*hcd
,
1366 struct oz_port
*port
)
1368 struct oz_hcd
*ozhcd
= port
->ozhcd
;
1370 oz_trace("Deleting endpoints for configuration.\n");
1371 for (i
= 0; i
< port
->num_iface
; i
++)
1372 oz_clean_endpoints_for_interface(hcd
, port
, i
);
1373 spin_lock_bh(&ozhcd
->hcd_lock
);
1375 oz_trace("Freeing interfaces object.\n");
1379 port
->num_iface
= 0;
1380 spin_unlock_bh(&ozhcd
->hcd_lock
);
1382 /*------------------------------------------------------------------------------
1385 static void *oz_claim_hpd(struct oz_port
*port
)
1388 struct oz_hcd
*ozhcd
= port
->ozhcd
;
1389 spin_lock_bh(&ozhcd
->hcd_lock
);
1393 spin_unlock_bh(&ozhcd
->hcd_lock
);
1396 /*------------------------------------------------------------------------------
1399 static void oz_process_ep0_urb(struct oz_hcd
*ozhcd
, struct urb
*urb
,
1402 struct usb_ctrlrequest
*setup
;
1409 unsigned complete
= 0;
1412 struct oz_port
*port
= NULL
;
1414 oz_trace2(OZ_TRACE_URB
, "%lu: oz_process_ep0_urb(%p)\n", jiffies
, urb
);
1415 port_ix
= oz_get_port_from_addr(ozhcd
, urb
->dev
->devnum
);
1420 port
= &ozhcd
->ports
[port_ix
];
1421 if (((port
->flags
& OZ_PORT_F_PRESENT
) == 0)
1422 || (port
->flags
& OZ_PORT_F_DYING
)) {
1423 oz_trace("Refusing URB port_ix = %d devnum = %d\n",
1424 port_ix
, urb
->dev
->devnum
);
1428 /* Store port in private context data.
1431 setup
= (struct usb_ctrlrequest
*)urb
->setup_packet
;
1432 windex
= le16_to_cpu(setup
->wIndex
);
1433 wvalue
= le16_to_cpu(setup
->wValue
);
1434 wlength
= le16_to_cpu(setup
->wLength
);
1435 oz_trace2(OZ_TRACE_CTRL_DETAIL
, "bRequestType = %x\n",
1436 setup
->bRequestType
);
1437 oz_trace2(OZ_TRACE_CTRL_DETAIL
, "bRequest = %x\n", setup
->bRequest
);
1438 oz_trace2(OZ_TRACE_CTRL_DETAIL
, "wValue = %x\n", wvalue
);
1439 oz_trace2(OZ_TRACE_CTRL_DETAIL
, "wIndex = %x\n", windex
);
1440 oz_trace2(OZ_TRACE_CTRL_DETAIL
, "wLength = %x\n", wlength
);
1442 req_id
= port
->next_req_id
++;
1443 hpd
= oz_claim_hpd(port
);
1445 oz_trace("Cannot claim port\n");
1450 if ((setup
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_STANDARD
) {
1451 /* Standard requests
1453 switch (setup
->bRequest
) {
1454 case USB_REQ_GET_DESCRIPTOR
:
1455 oz_trace("USB_REQ_GET_DESCRIPTOR - req\n");
1457 case USB_REQ_SET_ADDRESS
:
1458 oz_event_log(OZ_EVT_CTRL_LOCAL
, setup
->bRequest
,
1459 0, NULL
, setup
->bRequestType
);
1460 oz_trace("USB_REQ_SET_ADDRESS - req\n");
1461 oz_trace("Port %d address is 0x%x\n", ozhcd
->conn_port
,
1462 (u8
)le16_to_cpu(setup
->wValue
));
1463 spin_lock_bh(&ozhcd
->hcd_lock
);
1464 if (ozhcd
->conn_port
>= 0) {
1465 ozhcd
->ports
[ozhcd
->conn_port
].bus_addr
=
1466 (u8
)le16_to_cpu(setup
->wValue
);
1467 oz_trace("Clearing conn_port\n");
1468 ozhcd
->conn_port
= -1;
1470 spin_unlock_bh(&ozhcd
->hcd_lock
);
1473 case USB_REQ_SET_CONFIGURATION
:
1474 oz_trace("USB_REQ_SET_CONFIGURATION - req\n");
1476 case USB_REQ_GET_CONFIGURATION
:
1477 /* We short circuit this case and reply directly since
1478 * we have the selected configuration number cached.
1480 oz_event_log(OZ_EVT_CTRL_LOCAL
, setup
->bRequest
, 0,
1481 NULL
, setup
->bRequestType
);
1482 oz_trace("USB_REQ_GET_CONFIGURATION - reply now\n");
1483 if (urb
->transfer_buffer_length
>= 1) {
1484 urb
->actual_length
= 1;
1485 *((u8
*)urb
->transfer_buffer
) =
1492 case USB_REQ_GET_INTERFACE
:
1493 /* We short circuit this case and reply directly since
1494 * we have the selected interface alternative cached.
1496 oz_event_log(OZ_EVT_CTRL_LOCAL
, setup
->bRequest
, 0,
1497 NULL
, setup
->bRequestType
);
1498 oz_trace("USB_REQ_GET_INTERFACE - reply now\n");
1499 if (urb
->transfer_buffer_length
>= 1) {
1500 urb
->actual_length
= 1;
1501 *((u8
*)urb
->transfer_buffer
) =
1502 port
->iface
[(u8
)windex
].alt
;
1503 oz_trace("interface = %d alt = %d\n",
1504 windex
, port
->iface
[(u8
)windex
].alt
);
1510 case USB_REQ_SET_INTERFACE
:
1511 oz_trace("USB_REQ_SET_INTERFACE - req\n");
1515 if (!rc
&& !complete
) {
1517 if ((setup
->bRequestType
& USB_DIR_IN
) == 0)
1519 urb
->actual_length
= data_len
;
1520 if (oz_usb_control_req(port
->hpd
, req_id
, setup
,
1521 urb
->transfer_buffer
, data_len
)) {
1524 /* Note: we are queuing the request after we have
1525 * submitted it to be transmitted. If the request were
1526 * to complete before we queued it then it would not
1527 * be found in the queue. It seems impossible for
1528 * this to happen but if it did the request would
1529 * be resubmitted so the problem would hopefully
1530 * resolve itself. Putting the request into the
1531 * queue before it has been sent is worse since the
1532 * urb could be cancelled while we are using it
1533 * to build the request.
1535 if (oz_enqueue_ep_urb(port
, 0, 0, urb
, req_id
))
1541 if (rc
|| complete
) {
1542 oz_trace("Completing request locally\n");
1543 oz_complete_urb(ozhcd
->hcd
, urb
, rc
, 0);
1545 oz_usb_request_heartbeat(port
->hpd
);
1548 /*------------------------------------------------------------------------------
1551 static int oz_urb_process(struct oz_hcd
*ozhcd
, struct urb
*urb
)
1554 struct oz_port
*port
= urb
->hcpriv
;
1556 /* When we are paranoid we keep a list of urbs which we check against
1557 * before handing one back. This is just for debugging during
1558 * development and should be turned off in the released driver.
1560 oz_remember_urb(urb
);
1561 /* Check buffer is valid.
1563 if (!urb
->transfer_buffer
&& urb
->transfer_buffer_length
)
1565 /* Check if there is a device at the port - refuse if not.
1567 if ((port
->flags
& OZ_PORT_F_PRESENT
) == 0)
1569 ep_addr
= usb_pipeendpoint(urb
->pipe
);
1571 /* If the request is not for EP0 then queue it.
1573 if (oz_enqueue_ep_urb(port
, ep_addr
, usb_pipein(urb
->pipe
),
1577 oz_process_ep0_urb(ozhcd
, urb
, GFP_ATOMIC
);
1581 /*------------------------------------------------------------------------------
1584 static void oz_urb_process_tasklet(unsigned long unused
)
1586 unsigned long irq_state
;
1588 struct oz_hcd
*ozhcd
= oz_hcd_claim();
1592 /* This is called from a tasklet so is in softirq context but the urb
1593 * list is filled from any context so we need to lock
1594 * appropriately while removing urbs.
1596 spin_lock_irqsave(&g_tasklet_lock
, irq_state
);
1597 while (!list_empty(&ozhcd
->urb_pending_list
)) {
1598 struct oz_urb_link
*urbl
=
1599 list_first_entry(&ozhcd
->urb_pending_list
,
1600 struct oz_urb_link
, link
);
1601 list_del_init(&urbl
->link
);
1602 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
1604 oz_free_urb_link(urbl
);
1605 rc
= oz_urb_process(ozhcd
, urb
);
1607 oz_complete_urb(ozhcd
->hcd
, urb
, rc
, 0);
1608 spin_lock_irqsave(&g_tasklet_lock
, irq_state
);
1610 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
1613 /*------------------------------------------------------------------------------
1614 * This function searches for the urb in any of the lists it could be in.
1615 * If it is found it is removed from the list and completed. If the urb is
1616 * being processed then it won't be in a list so won't be found. However, the
1617 * call to usb_hcd_check_unlink_urb() will set the value of the unlinked field
1618 * to a non-zero value. When an attempt is made to put the urb back in a list
1619 * the unlinked field will be checked and the urb will then be completed.
1622 static void oz_urb_cancel(struct oz_port
*port
, u8 ep_num
, struct urb
*urb
)
1624 struct oz_urb_link
*urbl
= NULL
;
1625 struct list_head
*e
;
1626 struct oz_hcd
*ozhcd
;
1627 unsigned long irq_state
;
1630 oz_trace("ERRORERROR: oz_urb_cancel(%p) port is null\n", urb
);
1633 ozhcd
= port
->ozhcd
;
1634 if (ozhcd
== NULL
) {
1635 oz_trace("ERRORERROR: oz_urb_cancel(%p) ozhcd is null\n", urb
);
1639 /* Look in the tasklet queue.
1641 spin_lock_irqsave(&g_tasklet_lock
, irq_state
);
1642 list_for_each(e
, &ozhcd
->urb_cancel_list
) {
1643 urbl
= container_of(e
, struct oz_urb_link
, link
);
1644 if (urb
== urbl
->urb
) {
1646 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
1650 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
1653 /* Look in the orphanage.
1655 spin_lock_irqsave(&ozhcd
->hcd_lock
, irq_state
);
1656 list_for_each(e
, &ozhcd
->orphanage
) {
1657 urbl
= container_of(e
, struct oz_urb_link
, link
);
1658 if (urbl
->urb
== urb
) {
1660 oz_trace("Found urb in orphanage\n");
1664 ix
= (ep_num
& 0xf);
1666 if ((ep_num
& USB_DIR_IN
) && ix
)
1667 urbl
= oz_remove_urb(port
->in_ep
[ix
], urb
);
1669 urbl
= oz_remove_urb(port
->out_ep
[ix
], urb
);
1671 spin_unlock_irqrestore(&ozhcd
->hcd_lock
, irq_state
);
1674 urb
->actual_length
= 0;
1675 oz_free_urb_link(urbl
);
1676 oz_complete_urb(ozhcd
->hcd
, urb
, -EPIPE
, 0);
1679 /*------------------------------------------------------------------------------
1682 static void oz_urb_cancel_tasklet(unsigned long unused
)
1684 unsigned long irq_state
;
1686 struct oz_hcd
*ozhcd
= oz_hcd_claim();
1689 spin_lock_irqsave(&g_tasklet_lock
, irq_state
);
1690 while (!list_empty(&ozhcd
->urb_cancel_list
)) {
1691 struct oz_urb_link
*urbl
=
1692 list_first_entry(&ozhcd
->urb_cancel_list
,
1693 struct oz_urb_link
, link
);
1694 list_del_init(&urbl
->link
);
1695 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
1698 oz_urb_cancel(urbl
->port
, urbl
->ep_num
, urb
);
1699 oz_free_urb_link(urbl
);
1700 spin_lock_irqsave(&g_tasklet_lock
, irq_state
);
1702 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
1705 /*------------------------------------------------------------------------------
1708 static void oz_hcd_clear_orphanage(struct oz_hcd
*ozhcd
, int status
)
1711 struct oz_urb_link
*urbl
;
1712 while (!list_empty(&ozhcd
->orphanage
)) {
1713 urbl
= list_first_entry(&ozhcd
->orphanage
,
1714 struct oz_urb_link
, link
);
1715 list_del(&urbl
->link
);
1716 oz_complete_urb(ozhcd
->hcd
, urbl
->urb
, status
, 0);
1717 oz_free_urb_link(urbl
);
1721 /*------------------------------------------------------------------------------
1724 static int oz_hcd_start(struct usb_hcd
*hcd
)
1726 oz_trace("oz_hcd_start()\n");
1727 hcd
->power_budget
= 200;
1728 hcd
->state
= HC_STATE_RUNNING
;
1729 hcd
->uses_new_polling
= 1;
1732 /*------------------------------------------------------------------------------
1735 static void oz_hcd_stop(struct usb_hcd
*hcd
)
1737 oz_trace("oz_hcd_stop()\n");
1739 /*------------------------------------------------------------------------------
1742 static void oz_hcd_shutdown(struct usb_hcd
*hcd
)
1744 oz_trace("oz_hcd_shutdown()\n");
1746 /*------------------------------------------------------------------------------
1749 #ifdef WANT_EVENT_TRACE
1750 static u8
oz_get_irq_ctx(void)
1759 #endif /* WANT_EVENT_TRACE */
1760 /*------------------------------------------------------------------------------
1761 * Called to queue an urb for the device.
1762 * This function should return a non-zero error code if it fails the urb but
1763 * should not call usb_hcd_giveback_urb().
1766 static int oz_hcd_urb_enqueue(struct usb_hcd
*hcd
, struct urb
*urb
,
1769 struct oz_hcd
*ozhcd
= oz_hcd_private(hcd
);
1772 struct oz_port
*port
;
1773 unsigned long irq_state
;
1774 struct oz_urb_link
*urbl
;
1775 oz_trace2(OZ_TRACE_URB
, "%lu: oz_hcd_urb_enqueue(%p)\n",
1777 oz_event_log(OZ_EVT_URB_SUBMIT
, oz_get_irq_ctx(),
1778 (u16
)urb
->number_of_packets
, urb
, urb
->pipe
);
1779 if (unlikely(ozhcd
== NULL
)) {
1780 oz_trace2(OZ_TRACE_URB
, "%lu: Refused urb(%p) not ozhcd.\n",
1784 if (unlikely(hcd
->state
!= HC_STATE_RUNNING
)) {
1785 oz_trace2(OZ_TRACE_URB
, "%lu: Refused urb(%p) not running.\n",
1789 port_ix
= oz_get_port_from_addr(ozhcd
, urb
->dev
->devnum
);
1792 port
= &ozhcd
->ports
[port_ix
];
1795 if ((port
->flags
& OZ_PORT_F_PRESENT
) == 0) {
1796 oz_trace("Refusing URB port_ix = %d devnum = %d\n",
1797 port_ix
, urb
->dev
->devnum
);
1801 /* Put request in queue for processing by tasklet.
1803 urbl
= oz_alloc_urb_link();
1804 if (unlikely(urbl
== NULL
))
1807 spin_lock_irqsave(&g_tasklet_lock
, irq_state
);
1808 rc
= usb_hcd_link_urb_to_ep(hcd
, urb
);
1810 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
1811 oz_free_urb_link(urbl
);
1814 list_add_tail(&urbl
->link
, &ozhcd
->urb_pending_list
);
1815 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
1816 tasklet_schedule(&g_urb_process_tasklet
);
1817 atomic_inc(&g_pending_urbs
);
1820 /*------------------------------------------------------------------------------
1823 static struct oz_urb_link
*oz_remove_urb(struct oz_endpoint
*ep
,
1826 struct oz_urb_link
*urbl
= NULL
;
1827 struct list_head
*e
;
1828 if (unlikely(ep
== NULL
))
1830 list_for_each(e
, &ep
->urb_list
) {
1831 urbl
= container_of(e
, struct oz_urb_link
, link
);
1832 if (urbl
->urb
== urb
) {
1834 if (usb_pipeisoc(urb
->pipe
)) {
1835 ep
->credit
-= urb
->number_of_packets
;
1838 oz_event_log(OZ_EVT_EP_CREDIT
,
1839 usb_pipein(urb
->pipe
) ?
1840 (ep
->ep_num
| USB_DIR_IN
) : ep
->ep_num
,
1841 0, NULL
, ep
->credit
);
1848 /*------------------------------------------------------------------------------
1849 * Called to dequeue a previously submitted urb for the device.
1852 static int oz_hcd_urb_dequeue(struct usb_hcd
*hcd
, struct urb
*urb
, int status
)
1854 struct oz_hcd
*ozhcd
= oz_hcd_private(hcd
);
1855 struct oz_urb_link
*urbl
= NULL
;
1857 unsigned long irq_state
;
1858 oz_trace2(OZ_TRACE_URB
, "%lu: oz_hcd_urb_dequeue(%p)\n", jiffies
, urb
);
1859 urbl
= oz_alloc_urb_link();
1860 if (unlikely(urbl
== NULL
))
1862 spin_lock_irqsave(&g_tasklet_lock
, irq_state
);
1863 /* The following function checks the urb is still in the queue
1864 * maintained by the core and that the unlinked field is zero.
1865 * If both are true the function sets the unlinked field and returns
1866 * zero. Otherwise it returns an error.
1868 rc
= usb_hcd_check_unlink_urb(hcd
, urb
, status
);
1869 /* We have to check we haven't completed the urb or are about
1870 * to complete it. When we do we set hcpriv to 0 so if this has
1871 * already happened we don't put the urb in the cancel queue.
1873 if ((rc
== 0) && urb
->hcpriv
) {
1875 urbl
->port
= (struct oz_port
*)urb
->hcpriv
;
1876 urbl
->ep_num
= usb_pipeendpoint(urb
->pipe
);
1877 if (usb_pipein(urb
->pipe
))
1878 urbl
->ep_num
|= USB_DIR_IN
;
1879 list_add_tail(&urbl
->link
, &ozhcd
->urb_cancel_list
);
1880 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
1881 tasklet_schedule(&g_urb_cancel_tasklet
);
1883 spin_unlock_irqrestore(&g_tasklet_lock
, irq_state
);
1884 oz_free_urb_link(urbl
);
1888 /*------------------------------------------------------------------------------
1891 static void oz_hcd_endpoint_disable(struct usb_hcd
*hcd
,
1892 struct usb_host_endpoint
*ep
)
1894 oz_trace("oz_hcd_endpoint_disable\n");
1896 /*------------------------------------------------------------------------------
1899 static void oz_hcd_endpoint_reset(struct usb_hcd
*hcd
,
1900 struct usb_host_endpoint
*ep
)
1902 oz_trace("oz_hcd_endpoint_reset\n");
1904 /*------------------------------------------------------------------------------
1907 static int oz_hcd_get_frame_number(struct usb_hcd
*hcd
)
1909 oz_trace("oz_hcd_get_frame_number\n");
1910 return oz_usb_get_frame_number();
1912 /*------------------------------------------------------------------------------
1914 * This is called as a consquence of us calling usb_hcd_poll_rh_status() and we
1915 * always do that in softirq context.
1917 static int oz_hcd_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
1919 struct oz_hcd
*ozhcd
= oz_hcd_private(hcd
);
1922 oz_trace2(OZ_TRACE_HUB
, "oz_hcd_hub_status_data()\n");
1925 spin_lock_bh(&ozhcd
->hcd_lock
);
1926 for (i
= 0; i
< OZ_NB_PORTS
; i
++) {
1927 if (ozhcd
->ports
[i
].flags
& OZ_PORT_F_CHANGED
) {
1928 oz_trace2(OZ_TRACE_HUB
, "Port %d changed\n", i
);
1929 ozhcd
->ports
[i
].flags
&= ~OZ_PORT_F_CHANGED
;
1933 spin_unlock_bh(&ozhcd
->hcd_lock
);
1934 return buf
[0] ? 1 : 0;
1936 /*------------------------------------------------------------------------------
1939 static void oz_get_hub_descriptor(struct usb_hcd
*hcd
,
1940 struct usb_hub_descriptor
*desc
)
1942 oz_trace2(OZ_TRACE_HUB
, "GetHubDescriptor\n");
1943 memset(desc
, 0, sizeof(*desc
));
1944 desc
->bDescriptorType
= 0x29;
1945 desc
->bDescLength
= 9;
1946 desc
->wHubCharacteristics
= (__force __u16
)
1947 __constant_cpu_to_le16(0x0001);
1948 desc
->bNbrPorts
= OZ_NB_PORTS
;
1950 /*------------------------------------------------------------------------------
1953 static int oz_set_port_feature(struct usb_hcd
*hcd
, u16 wvalue
, u16 windex
)
1955 struct oz_port
*port
;
1957 u8 port_id
= (u8
)windex
;
1958 struct oz_hcd
*ozhcd
= oz_hcd_private(hcd
);
1959 unsigned set_bits
= 0;
1960 unsigned clear_bits
= 0;
1961 oz_trace2(OZ_TRACE_HUB
, "SetPortFeature\n");
1962 if ((port_id
< 1) || (port_id
> OZ_NB_PORTS
))
1964 port
= &ozhcd
->ports
[port_id
-1];
1966 case USB_PORT_FEAT_CONNECTION
:
1967 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_CONNECTION\n");
1969 case USB_PORT_FEAT_ENABLE
:
1970 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_ENABLE\n");
1972 case USB_PORT_FEAT_SUSPEND
:
1973 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_SUSPEND\n");
1975 case USB_PORT_FEAT_OVER_CURRENT
:
1976 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_OVER_CURRENT\n");
1978 case USB_PORT_FEAT_RESET
:
1979 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_RESET\n");
1980 set_bits
= USB_PORT_STAT_ENABLE
| (USB_PORT_STAT_C_RESET
<<16);
1981 clear_bits
= USB_PORT_STAT_RESET
;
1982 ozhcd
->ports
[port_id
-1].bus_addr
= 0;
1984 case USB_PORT_FEAT_POWER
:
1985 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_POWER\n");
1986 set_bits
|= USB_PORT_STAT_POWER
;
1988 case USB_PORT_FEAT_LOWSPEED
:
1989 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_LOWSPEED\n");
1991 case USB_PORT_FEAT_C_CONNECTION
:
1992 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_C_CONNECTION\n");
1994 case USB_PORT_FEAT_C_ENABLE
:
1995 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_C_ENABLE\n");
1997 case USB_PORT_FEAT_C_SUSPEND
:
1998 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_C_SUSPEND\n");
2000 case USB_PORT_FEAT_C_OVER_CURRENT
:
2001 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_C_OVER_CURRENT\n");
2003 case USB_PORT_FEAT_C_RESET
:
2004 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_C_RESET\n");
2006 case USB_PORT_FEAT_TEST
:
2007 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_TEST\n");
2009 case USB_PORT_FEAT_INDICATOR
:
2010 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_INDICATOR\n");
2013 oz_trace2(OZ_TRACE_HUB
, "Other %d\n", wvalue
);
2016 if (set_bits
|| clear_bits
) {
2017 spin_lock_bh(&port
->port_lock
);
2018 port
->status
&= ~clear_bits
;
2019 port
->status
|= set_bits
;
2020 spin_unlock_bh(&port
->port_lock
);
2022 oz_trace2(OZ_TRACE_HUB
, "Port[%d] status = 0x%x\n", port_id
,
2026 /*------------------------------------------------------------------------------
2029 static int oz_clear_port_feature(struct usb_hcd
*hcd
, u16 wvalue
, u16 windex
)
2031 struct oz_port
*port
;
2033 u8 port_id
= (u8
)windex
;
2034 struct oz_hcd
*ozhcd
= oz_hcd_private(hcd
);
2035 unsigned clear_bits
= 0;
2036 oz_trace2(OZ_TRACE_HUB
, "ClearPortFeature\n");
2037 if ((port_id
< 1) || (port_id
> OZ_NB_PORTS
))
2039 port
= &ozhcd
->ports
[port_id
-1];
2041 case USB_PORT_FEAT_CONNECTION
:
2042 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_CONNECTION\n");
2044 case USB_PORT_FEAT_ENABLE
:
2045 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_ENABLE\n");
2046 clear_bits
= USB_PORT_STAT_ENABLE
;
2048 case USB_PORT_FEAT_SUSPEND
:
2049 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_SUSPEND\n");
2051 case USB_PORT_FEAT_OVER_CURRENT
:
2052 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_OVER_CURRENT\n");
2054 case USB_PORT_FEAT_RESET
:
2055 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_RESET\n");
2057 case USB_PORT_FEAT_POWER
:
2058 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_POWER\n");
2059 clear_bits
|= USB_PORT_STAT_POWER
;
2061 case USB_PORT_FEAT_LOWSPEED
:
2062 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_LOWSPEED\n");
2064 case USB_PORT_FEAT_C_CONNECTION
:
2065 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_C_CONNECTION\n");
2066 clear_bits
= (USB_PORT_STAT_C_CONNECTION
<< 16);
2068 case USB_PORT_FEAT_C_ENABLE
:
2069 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_C_ENABLE\n");
2070 clear_bits
= (USB_PORT_STAT_C_ENABLE
<< 16);
2072 case USB_PORT_FEAT_C_SUSPEND
:
2073 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_C_SUSPEND\n");
2075 case USB_PORT_FEAT_C_OVER_CURRENT
:
2076 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_C_OVER_CURRENT\n");
2078 case USB_PORT_FEAT_C_RESET
:
2079 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_C_RESET\n");
2080 clear_bits
= (USB_PORT_FEAT_C_RESET
<< 16);
2082 case USB_PORT_FEAT_TEST
:
2083 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_TEST\n");
2085 case USB_PORT_FEAT_INDICATOR
:
2086 oz_trace2(OZ_TRACE_HUB
, "USB_PORT_FEAT_INDICATOR\n");
2089 oz_trace2(OZ_TRACE_HUB
, "Other %d\n", wvalue
);
2093 spin_lock_bh(&port
->port_lock
);
2094 port
->status
&= ~clear_bits
;
2095 spin_unlock_bh(&port
->port_lock
);
2097 oz_trace2(OZ_TRACE_HUB
, "Port[%d] status = 0x%x\n", port_id
,
2098 ozhcd
->ports
[port_id
-1].status
);
2101 /*------------------------------------------------------------------------------
2104 static int oz_get_port_status(struct usb_hcd
*hcd
, u16 windex
, char *buf
)
2106 struct oz_hcd
*ozhcd
;
2108 if ((windex
< 1) || (windex
> OZ_NB_PORTS
))
2110 ozhcd
= oz_hcd_private(hcd
);
2111 oz_trace2(OZ_TRACE_HUB
, "GetPortStatus windex = %d\n", windex
);
2112 status
= ozhcd
->ports
[windex
-1].status
;
2113 put_unaligned(cpu_to_le32(status
), (__le32
*)buf
);
2114 oz_trace2(OZ_TRACE_HUB
, "Port[%d] status = %x\n", windex
, status
);
2117 /*------------------------------------------------------------------------------
2120 static int oz_hcd_hub_control(struct usb_hcd
*hcd
, u16 req_type
, u16 wvalue
,
2121 u16 windex
, char *buf
, u16 wlength
)
2124 oz_trace2(OZ_TRACE_HUB
, "oz_hcd_hub_control()\n");
2126 case ClearHubFeature
:
2127 oz_trace2(OZ_TRACE_HUB
, "ClearHubFeature: %d\n", req_type
);
2129 case ClearPortFeature
:
2130 err
= oz_clear_port_feature(hcd
, wvalue
, windex
);
2132 case GetHubDescriptor
:
2133 oz_get_hub_descriptor(hcd
, (struct usb_hub_descriptor
*)buf
);
2136 oz_trace2(OZ_TRACE_HUB
, "GetHubStatus: req_type = 0x%x\n",
2138 put_unaligned(__constant_cpu_to_le32(0), (__le32
*)buf
);
2141 err
= oz_get_port_status(hcd
, windex
, buf
);
2144 oz_trace2(OZ_TRACE_HUB
, "SetHubFeature: %d\n", req_type
);
2146 case SetPortFeature
:
2147 err
= oz_set_port_feature(hcd
, wvalue
, windex
);
2150 oz_trace2(OZ_TRACE_HUB
, "Other: %d\n", req_type
);
2155 /*------------------------------------------------------------------------------
2158 static int oz_hcd_bus_suspend(struct usb_hcd
*hcd
)
2160 struct oz_hcd
*ozhcd
;
2161 oz_trace2(OZ_TRACE_HUB
, "oz_hcd_hub_suspend()\n");
2162 ozhcd
= oz_hcd_private(hcd
);
2163 spin_lock_bh(&ozhcd
->hcd_lock
);
2164 hcd
->state
= HC_STATE_SUSPENDED
;
2165 ozhcd
->flags
|= OZ_HDC_F_SUSPENDED
;
2166 spin_unlock_bh(&ozhcd
->hcd_lock
);
2169 /*------------------------------------------------------------------------------
2172 static int oz_hcd_bus_resume(struct usb_hcd
*hcd
)
2174 struct oz_hcd
*ozhcd
;
2175 oz_trace2(OZ_TRACE_HUB
, "oz_hcd_hub_resume()\n");
2176 ozhcd
= oz_hcd_private(hcd
);
2177 spin_lock_bh(&ozhcd
->hcd_lock
);
2178 ozhcd
->flags
&= ~OZ_HDC_F_SUSPENDED
;
2179 hcd
->state
= HC_STATE_RUNNING
;
2180 spin_unlock_bh(&ozhcd
->hcd_lock
);
2183 /*------------------------------------------------------------------------------
2185 static void oz_plat_shutdown(struct platform_device
*dev
)
2187 oz_trace("oz_plat_shutdown()\n");
2189 /*------------------------------------------------------------------------------
2192 static int oz_plat_probe(struct platform_device
*dev
)
2196 struct usb_hcd
*hcd
;
2197 struct oz_hcd
*ozhcd
;
2198 oz_trace("oz_plat_probe()\n");
2199 hcd
= usb_create_hcd(&g_oz_hc_drv
, &dev
->dev
, dev_name(&dev
->dev
));
2201 oz_trace("Failed to created hcd object OK\n");
2204 ozhcd
= oz_hcd_private(hcd
);
2205 memset(ozhcd
, 0, sizeof(*ozhcd
));
2206 INIT_LIST_HEAD(&ozhcd
->urb_pending_list
);
2207 INIT_LIST_HEAD(&ozhcd
->urb_cancel_list
);
2208 INIT_LIST_HEAD(&ozhcd
->orphanage
);
2210 ozhcd
->conn_port
= -1;
2211 spin_lock_init(&ozhcd
->hcd_lock
);
2212 for (i
= 0; i
< OZ_NB_PORTS
; i
++) {
2213 struct oz_port
*port
= &ozhcd
->ports
[i
];
2214 port
->ozhcd
= ozhcd
;
2217 port
->bus_addr
= 0xff;
2218 spin_lock_init(&port
->port_lock
);
2220 err
= usb_add_hcd(hcd
, 0, 0);
2222 oz_trace("Failed to add hcd object OK\n");
2226 spin_lock_bh(&g_hcdlock
);
2228 spin_unlock_bh(&g_hcdlock
);
2231 /*------------------------------------------------------------------------------
2234 static int oz_plat_remove(struct platform_device
*dev
)
2236 struct usb_hcd
*hcd
= platform_get_drvdata(dev
);
2237 struct oz_hcd
*ozhcd
;
2238 oz_trace("oz_plat_remove()\n");
2241 ozhcd
= oz_hcd_private(hcd
);
2242 spin_lock_bh(&g_hcdlock
);
2243 if (ozhcd
== g_ozhcd
)
2245 spin_unlock_bh(&g_hcdlock
);
2246 oz_trace("Clearing orphanage\n");
2247 oz_hcd_clear_orphanage(ozhcd
, -EPIPE
);
2248 oz_trace("Removing hcd\n");
2249 usb_remove_hcd(hcd
);
2251 oz_empty_link_pool();
2254 /*------------------------------------------------------------------------------
2257 static int oz_plat_suspend(struct platform_device
*dev
, pm_message_t msg
)
2259 oz_trace("oz_plat_suspend()\n");
2262 /*------------------------------------------------------------------------------
2265 static int oz_plat_resume(struct platform_device
*dev
)
2267 oz_trace("oz_plat_resume()\n");
2270 /*------------------------------------------------------------------------------
2273 int oz_hcd_init(void)
2278 tasklet_init(&g_urb_process_tasklet
, oz_urb_process_tasklet
, 0);
2279 tasklet_init(&g_urb_cancel_tasklet
, oz_urb_cancel_tasklet
, 0);
2280 err
= platform_driver_register(&g_oz_plat_drv
);
2281 oz_trace("platform_driver_register() returned %d\n", err
);
2284 g_plat_dev
= platform_device_alloc(OZ_PLAT_DEV_NAME
, -1);
2285 if (g_plat_dev
== NULL
) {
2289 oz_trace("platform_device_alloc() succeeded\n");
2290 err
= platform_device_add(g_plat_dev
);
2293 oz_trace("platform_device_add() succeeded\n");
2296 platform_device_put(g_plat_dev
);
2298 platform_driver_unregister(&g_oz_plat_drv
);
2300 tasklet_disable(&g_urb_process_tasklet
);
2301 tasklet_disable(&g_urb_cancel_tasklet
);
2302 oz_trace("oz_hcd_init() failed %d\n", err
);
2305 /*------------------------------------------------------------------------------
2308 void oz_hcd_term(void)
2310 tasklet_kill(&g_urb_process_tasklet
);
2311 tasklet_kill(&g_urb_cancel_tasklet
);
2312 platform_device_unregister(g_plat_dev
);
2313 platform_driver_unregister(&g_oz_plat_drv
);
2314 oz_trace("Pending urbs:%d\n", atomic_read(&g_pending_urbs
));