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