This source file includes following definitions.
- usbhsh_ureq_alloc
- usbhsh_ureq_free
- usbhsh_is_running
- usbhsh_endpoint_sequence_save
- usbhsh_pipe_attach
- usbhsh_pipe_detach
- usbhsh_endpoint_attach
- usbhsh_endpoint_detach
- usbhsh_endpoint_detach_all
- usbhsh_connected_to_rhdev
- usbhsh_device_has_endpoint
- usbhsh_device_get
- usbhsh_device_attach
- usbhsh_device_detach
- usbhsh_queue_done
- usbhsh_queue_push
- usbhsh_queue_force_pop
- usbhsh_queue_force_pop_all
- usbhsh_is_request_address
- usbhsh_setup_stage_packet_push
- usbhsh_data_stage_packet_done
- usbhsh_data_stage_packet_push
- usbhsh_status_stage_packet_push
- usbhsh_dcp_queue_push
- usbhsh_dma_map_ctrl
- usbhsh_host_start
- usbhsh_host_stop
- usbhsh_urb_enqueue
- usbhsh_urb_dequeue
- usbhsh_endpoint_disable
- usbhsh_hub_status_data
- __usbhsh_hub_hub_feature
- __usbhsh_hub_port_feature
- __usbhsh_hub_get_status
- usbhsh_hub_control
- usbhsh_bus_nop
- usbhsh_irq_attch
- usbhsh_irq_dtch
- usbhsh_irq_setup_ack
- usbhsh_irq_setup_err
- usbhsh_pipe_init_for_host
- usbhsh_start
- usbhsh_stop
- usbhs_mod_host_probe
- usbhs_mod_host_remove
1
2
3
4
5
6
7
8 #include <linux/io.h>
9 #include <linux/list.h>
10 #include <linux/module.h>
11 #include <linux/platform_device.h>
12 #include <linux/slab.h>
13 #include <linux/usb.h>
14 #include <linux/usb/hcd.h>
15 #include "common.h"
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64 struct usbhsh_request {
65 struct urb *urb;
66 struct usbhs_pkt pkt;
67 };
68
69 struct usbhsh_device {
70 struct usb_device *usbv;
71 struct list_head ep_list_head;
72 };
73
74 struct usbhsh_ep {
75 struct usbhs_pipe *pipe;
76 struct usbhsh_device *udev;
77 struct usb_host_endpoint *ep;
78 struct list_head ep_list;
79 unsigned int counter;
80 };
81
82 #define USBHSH_DEVICE_MAX 10
83 #define USBHSH_PORT_MAX 7
84 struct usbhsh_hpriv {
85 struct usbhs_mod mod;
86 struct usbhs_pipe *dcp;
87
88 struct usbhsh_device udev[USBHSH_DEVICE_MAX];
89
90 u32 port_stat;
91
92 struct completion setup_ack_done;
93 };
94
95
96 static const char usbhsh_hcd_name[] = "renesas_usbhs host";
97
98
99
100
101 #define usbhsh_priv_to_hpriv(priv) \
102 container_of(usbhs_mod_get(priv, USBHS_HOST), struct usbhsh_hpriv, mod)
103
104 #define __usbhsh_for_each_udev(start, pos, h, i) \
105 for ((i) = start; \
106 ((i) < USBHSH_DEVICE_MAX) && ((pos) = (h)->udev + (i)); \
107 (i)++)
108
109 #define usbhsh_for_each_udev(pos, hpriv, i) \
110 __usbhsh_for_each_udev(1, pos, hpriv, i)
111
112 #define usbhsh_for_each_udev_with_dev0(pos, hpriv, i) \
113 __usbhsh_for_each_udev(0, pos, hpriv, i)
114
115 #define usbhsh_hcd_to_hpriv(h) (struct usbhsh_hpriv *)((h)->hcd_priv)
116 #define usbhsh_hcd_to_dev(h) ((h)->self.controller)
117
118 #define usbhsh_hpriv_to_priv(h) ((h)->mod.priv)
119 #define usbhsh_hpriv_to_dcp(h) ((h)->dcp)
120 #define usbhsh_hpriv_to_hcd(h) \
121 container_of((void *)h, struct usb_hcd, hcd_priv)
122
123 #define usbhsh_ep_to_uep(u) ((u)->hcpriv)
124 #define usbhsh_uep_to_pipe(u) ((u)->pipe)
125 #define usbhsh_uep_to_udev(u) ((u)->udev)
126 #define usbhsh_uep_to_ep(u) ((u)->ep)
127
128 #define usbhsh_urb_to_ureq(u) ((u)->hcpriv)
129 #define usbhsh_urb_to_usbv(u) ((u)->dev)
130
131 #define usbhsh_usbv_to_udev(d) dev_get_drvdata(&(d)->dev)
132
133 #define usbhsh_udev_to_usbv(h) ((h)->usbv)
134 #define usbhsh_udev_is_used(h) usbhsh_udev_to_usbv(h)
135
136 #define usbhsh_pipe_to_uep(p) ((p)->mod_private)
137
138 #define usbhsh_device_parent(d) (usbhsh_usbv_to_udev((d)->usbv->parent))
139 #define usbhsh_device_hubport(d) ((d)->usbv->portnum)
140 #define usbhsh_device_number(h, d) ((int)((d) - (h)->udev))
141 #define usbhsh_device_nth(h, d) ((h)->udev + d)
142 #define usbhsh_device0(h) usbhsh_device_nth(h, 0)
143
144 #define usbhsh_port_stat_init(h) ((h)->port_stat = 0)
145 #define usbhsh_port_stat_set(h, s) ((h)->port_stat |= (s))
146 #define usbhsh_port_stat_clear(h, s) ((h)->port_stat &= ~(s))
147 #define usbhsh_port_stat_get(h) ((h)->port_stat)
148
149 #define usbhsh_pkt_to_ureq(p) \
150 container_of((void *)p, struct usbhsh_request, pkt)
151
152
153
154
155 static struct usbhsh_request *usbhsh_ureq_alloc(struct usbhsh_hpriv *hpriv,
156 struct urb *urb,
157 gfp_t mem_flags)
158 {
159 struct usbhsh_request *ureq;
160
161 ureq = kzalloc(sizeof(struct usbhsh_request), mem_flags);
162 if (!ureq)
163 return NULL;
164
165 usbhs_pkt_init(&ureq->pkt);
166 ureq->urb = urb;
167 usbhsh_urb_to_ureq(urb) = ureq;
168
169 return ureq;
170 }
171
172 static void usbhsh_ureq_free(struct usbhsh_hpriv *hpriv,
173 struct usbhsh_request *ureq)
174 {
175 usbhsh_urb_to_ureq(ureq->urb) = NULL;
176 ureq->urb = NULL;
177
178 kfree(ureq);
179 }
180
181
182
183
184 static int usbhsh_is_running(struct usbhsh_hpriv *hpriv)
185 {
186
187
188
189
190
191
192
193 return (hpriv->mod.irq_attch == NULL);
194 }
195
196
197
198
199 static void usbhsh_endpoint_sequence_save(struct usbhsh_hpriv *hpriv,
200 struct urb *urb,
201 struct usbhs_pkt *pkt)
202 {
203 int len = urb->actual_length;
204 int maxp = usb_endpoint_maxp(&urb->ep->desc);
205 int t = 0;
206
207
208 if (usb_pipecontrol(urb->pipe))
209 return;
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228 t = len / maxp;
229 if (len % maxp)
230 t++;
231 if (pkt->zero)
232 t++;
233 t %= 2;
234
235 if (t)
236 usb_dotoggle(urb->dev,
237 usb_pipeendpoint(urb->pipe),
238 usb_pipeout(urb->pipe));
239 }
240
241 static struct usbhsh_device *usbhsh_device_get(struct usbhsh_hpriv *hpriv,
242 struct urb *urb);
243
244 static int usbhsh_pipe_attach(struct usbhsh_hpriv *hpriv,
245 struct urb *urb)
246 {
247 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
248 struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep);
249 struct usbhsh_device *udev = usbhsh_device_get(hpriv, urb);
250 struct usbhs_pipe *pipe;
251 struct usb_endpoint_descriptor *desc = &urb->ep->desc;
252 struct device *dev = usbhs_priv_to_dev(priv);
253 unsigned long flags;
254 int dir_in_req = !!usb_pipein(urb->pipe);
255 int is_dcp = usb_endpoint_xfer_control(desc);
256 int i, dir_in;
257 int ret = -EBUSY;
258
259
260 usbhs_lock(priv, flags);
261
262
263
264
265
266 if (usbhsh_uep_to_pipe(uep)) {
267 ret = 0;
268 goto usbhsh_pipe_attach_done;
269 }
270
271 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
272
273
274 if (!usbhs_pipe_type_is(pipe, usb_endpoint_type(desc)))
275 continue;
276
277
278 if (!is_dcp) {
279 dir_in = !!usbhs_pipe_is_dir_in(pipe);
280 if (0 != (dir_in - dir_in_req))
281 continue;
282 }
283
284
285 if (usbhsh_pipe_to_uep(pipe))
286 continue;
287
288
289
290
291
292
293
294
295
296 usbhsh_uep_to_pipe(uep) = pipe;
297 usbhsh_pipe_to_uep(pipe) = uep;
298
299 usbhs_pipe_config_update(pipe,
300 usbhsh_device_number(hpriv, udev),
301 usb_endpoint_num(desc),
302 usb_endpoint_maxp(desc));
303
304 dev_dbg(dev, "%s [%d-%d(%s:%s)]\n", __func__,
305 usbhsh_device_number(hpriv, udev),
306 usb_endpoint_num(desc),
307 usbhs_pipe_name(pipe),
308 dir_in_req ? "in" : "out");
309
310 ret = 0;
311 break;
312 }
313
314 usbhsh_pipe_attach_done:
315 if (0 == ret)
316 uep->counter++;
317
318 usbhs_unlock(priv, flags);
319
320
321 return ret;
322 }
323
324 static void usbhsh_pipe_detach(struct usbhsh_hpriv *hpriv,
325 struct usbhsh_ep *uep)
326 {
327 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
328 struct usbhs_pipe *pipe;
329 struct device *dev = usbhs_priv_to_dev(priv);
330 unsigned long flags;
331
332 if (unlikely(!uep)) {
333 dev_err(dev, "no uep\n");
334 return;
335 }
336
337
338 usbhs_lock(priv, flags);
339
340 pipe = usbhsh_uep_to_pipe(uep);
341
342 if (unlikely(!pipe)) {
343 dev_err(dev, "uep doesn't have pipe\n");
344 } else if (1 == uep->counter--) {
345 struct usb_host_endpoint *ep = usbhsh_uep_to_ep(uep);
346 struct usbhsh_device *udev = usbhsh_uep_to_udev(uep);
347
348
349 usbhsh_uep_to_pipe(uep) = NULL;
350 usbhsh_pipe_to_uep(pipe) = NULL;
351
352 dev_dbg(dev, "%s [%d-%d(%s)]\n", __func__,
353 usbhsh_device_number(hpriv, udev),
354 usb_endpoint_num(&ep->desc),
355 usbhs_pipe_name(pipe));
356 }
357
358 usbhs_unlock(priv, flags);
359
360 }
361
362
363
364
365 static int usbhsh_endpoint_attach(struct usbhsh_hpriv *hpriv,
366 struct urb *urb,
367 gfp_t mem_flags)
368 {
369 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
370 struct usbhsh_device *udev = usbhsh_device_get(hpriv, urb);
371 struct usb_host_endpoint *ep = urb->ep;
372 struct usbhsh_ep *uep;
373 struct device *dev = usbhs_priv_to_dev(priv);
374 struct usb_endpoint_descriptor *desc = &ep->desc;
375 unsigned long flags;
376
377 uep = kzalloc(sizeof(struct usbhsh_ep), mem_flags);
378 if (!uep)
379 return -ENOMEM;
380
381
382 usbhs_lock(priv, flags);
383
384
385
386
387 uep->counter = 0;
388 INIT_LIST_HEAD(&uep->ep_list);
389 list_add_tail(&uep->ep_list, &udev->ep_list_head);
390
391 usbhsh_uep_to_udev(uep) = udev;
392 usbhsh_uep_to_ep(uep) = ep;
393 usbhsh_ep_to_uep(ep) = uep;
394
395 usbhs_unlock(priv, flags);
396
397
398 dev_dbg(dev, "%s [%d-%d]\n", __func__,
399 usbhsh_device_number(hpriv, udev),
400 usb_endpoint_num(desc));
401
402 return 0;
403 }
404
405 static void usbhsh_endpoint_detach(struct usbhsh_hpriv *hpriv,
406 struct usb_host_endpoint *ep)
407 {
408 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
409 struct device *dev = usbhs_priv_to_dev(priv);
410 struct usbhsh_ep *uep = usbhsh_ep_to_uep(ep);
411 unsigned long flags;
412
413 if (!uep)
414 return;
415
416 dev_dbg(dev, "%s [%d-%d]\n", __func__,
417 usbhsh_device_number(hpriv, usbhsh_uep_to_udev(uep)),
418 usb_endpoint_num(&ep->desc));
419
420 if (usbhsh_uep_to_pipe(uep))
421 usbhsh_pipe_detach(hpriv, uep);
422
423
424 usbhs_lock(priv, flags);
425
426
427 list_del_init(&uep->ep_list);
428
429 usbhsh_uep_to_udev(uep) = NULL;
430 usbhsh_uep_to_ep(uep) = NULL;
431 usbhsh_ep_to_uep(ep) = NULL;
432
433 usbhs_unlock(priv, flags);
434
435
436 kfree(uep);
437 }
438
439 static void usbhsh_endpoint_detach_all(struct usbhsh_hpriv *hpriv,
440 struct usbhsh_device *udev)
441 {
442 struct usbhsh_ep *uep, *next;
443
444 list_for_each_entry_safe(uep, next, &udev->ep_list_head, ep_list)
445 usbhsh_endpoint_detach(hpriv, usbhsh_uep_to_ep(uep));
446 }
447
448
449
450
451 static int usbhsh_connected_to_rhdev(struct usb_hcd *hcd,
452 struct usbhsh_device *udev)
453 {
454 struct usb_device *usbv = usbhsh_udev_to_usbv(udev);
455
456 return hcd->self.root_hub == usbv->parent;
457 }
458
459 static int usbhsh_device_has_endpoint(struct usbhsh_device *udev)
460 {
461 return !list_empty(&udev->ep_list_head);
462 }
463
464 static struct usbhsh_device *usbhsh_device_get(struct usbhsh_hpriv *hpriv,
465 struct urb *urb)
466 {
467 struct usb_device *usbv = usbhsh_urb_to_usbv(urb);
468 struct usbhsh_device *udev = usbhsh_usbv_to_udev(usbv);
469
470
471 if (!udev)
472 return NULL;
473
474
475 if (0 == usb_pipedevice(urb->pipe))
476 return usbhsh_device0(hpriv);
477
478
479 return udev;
480 }
481
482 static struct usbhsh_device *usbhsh_device_attach(struct usbhsh_hpriv *hpriv,
483 struct urb *urb)
484 {
485 struct usbhsh_device *udev = NULL;
486 struct usbhsh_device *udev0 = usbhsh_device0(hpriv);
487 struct usbhsh_device *pos;
488 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
489 struct device *dev = usbhsh_hcd_to_dev(hcd);
490 struct usb_device *usbv = usbhsh_urb_to_usbv(urb);
491 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
492 unsigned long flags;
493 u16 upphub, hubport;
494 int i;
495
496
497
498
499
500
501
502
503 if (0 != usb_pipedevice(urb->pipe)) {
504 dev_err(dev, "%s fail: urb isn't pointing device0\n", __func__);
505 return NULL;
506 }
507
508
509 usbhs_lock(priv, flags);
510
511
512
513
514 usbhsh_for_each_udev(pos, hpriv, i) {
515 if (usbhsh_udev_is_used(pos))
516 continue;
517 udev = pos;
518 break;
519 }
520
521 if (udev) {
522
523
524
525
526
527 dev_set_drvdata(&usbv->dev, udev);
528 udev->usbv = usbv;
529 }
530
531 usbhs_unlock(priv, flags);
532
533
534 if (!udev) {
535 dev_err(dev, "no free usbhsh_device\n");
536 return NULL;
537 }
538
539 if (usbhsh_device_has_endpoint(udev)) {
540 dev_warn(dev, "udev have old endpoint\n");
541 usbhsh_endpoint_detach_all(hpriv, udev);
542 }
543
544 if (usbhsh_device_has_endpoint(udev0)) {
545 dev_warn(dev, "udev0 have old endpoint\n");
546 usbhsh_endpoint_detach_all(hpriv, udev0);
547 }
548
549
550 INIT_LIST_HEAD(&udev0->ep_list_head);
551 INIT_LIST_HEAD(&udev->ep_list_head);
552
553
554
555
556 usbhs_set_device_config(priv,
557 0, 0, 0, usbv->speed);
558
559
560
561
562 upphub = 0;
563 hubport = 0;
564 if (!usbhsh_connected_to_rhdev(hcd, udev)) {
565
566 struct usbhsh_device *parent = usbhsh_device_parent(udev);
567
568 upphub = usbhsh_device_number(hpriv, parent);
569 hubport = usbhsh_device_hubport(udev);
570
571 dev_dbg(dev, "%s connected to Hub [%d:%d](%p)\n", __func__,
572 upphub, hubport, parent);
573 }
574
575 usbhs_set_device_config(priv,
576 usbhsh_device_number(hpriv, udev),
577 upphub, hubport, usbv->speed);
578
579 dev_dbg(dev, "%s [%d](%p)\n", __func__,
580 usbhsh_device_number(hpriv, udev), udev);
581
582 return udev;
583 }
584
585 static void usbhsh_device_detach(struct usbhsh_hpriv *hpriv,
586 struct usbhsh_device *udev)
587 {
588 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
589 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
590 struct device *dev = usbhsh_hcd_to_dev(hcd);
591 struct usb_device *usbv = usbhsh_udev_to_usbv(udev);
592 unsigned long flags;
593
594 dev_dbg(dev, "%s [%d](%p)\n", __func__,
595 usbhsh_device_number(hpriv, udev), udev);
596
597 if (usbhsh_device_has_endpoint(udev)) {
598 dev_warn(dev, "udev still have endpoint\n");
599 usbhsh_endpoint_detach_all(hpriv, udev);
600 }
601
602
603
604
605
606
607
608 if (0 == usbhsh_device_number(hpriv, udev))
609 return;
610
611
612 usbhs_lock(priv, flags);
613
614
615
616
617
618
619 dev_set_drvdata(&usbv->dev, NULL);
620 udev->usbv = NULL;
621
622 usbhs_unlock(priv, flags);
623
624 }
625
626
627
628
629 static void usbhsh_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt)
630 {
631 struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt);
632 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
633 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
634 struct urb *urb = ureq->urb;
635 struct device *dev = usbhs_priv_to_dev(priv);
636 int status = 0;
637
638 dev_dbg(dev, "%s\n", __func__);
639
640 if (!urb) {
641 dev_warn(dev, "pkt doesn't have urb\n");
642 return;
643 }
644
645 if (!usbhsh_is_running(hpriv))
646 status = -ESHUTDOWN;
647
648 urb->actual_length = pkt->actual;
649
650 usbhsh_endpoint_sequence_save(hpriv, urb, pkt);
651 usbhsh_ureq_free(hpriv, ureq);
652
653 usbhsh_pipe_detach(hpriv, usbhsh_ep_to_uep(urb->ep));
654
655 usb_hcd_unlink_urb_from_ep(hcd, urb);
656 usb_hcd_giveback_urb(hcd, urb, status);
657 }
658
659 static int usbhsh_queue_push(struct usb_hcd *hcd,
660 struct urb *urb,
661 gfp_t mem_flags)
662 {
663 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
664 struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep);
665 struct usbhs_pipe *pipe = usbhsh_uep_to_pipe(uep);
666 struct device *dev = usbhsh_hcd_to_dev(hcd);
667 struct usbhsh_request *ureq;
668 void *buf;
669 int len, sequence;
670
671 if (usb_pipeisoc(urb->pipe)) {
672 dev_err(dev, "pipe iso is not supported now\n");
673 return -EIO;
674 }
675
676
677 ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags);
678 if (unlikely(!ureq)) {
679 dev_err(dev, "ureq alloc fail\n");
680 return -ENOMEM;
681 }
682
683 if (usb_pipein(urb->pipe))
684 pipe->handler = &usbhs_fifo_dma_pop_handler;
685 else
686 pipe->handler = &usbhs_fifo_dma_push_handler;
687
688 buf = (void *)(urb->transfer_buffer + urb->actual_length);
689 len = urb->transfer_buffer_length - urb->actual_length;
690
691 sequence = usb_gettoggle(urb->dev,
692 usb_pipeendpoint(urb->pipe),
693 usb_pipeout(urb->pipe));
694
695 dev_dbg(dev, "%s\n", __func__);
696 usbhs_pkt_push(pipe, &ureq->pkt, usbhsh_queue_done,
697 buf, len, (urb->transfer_flags & URB_ZERO_PACKET),
698 sequence);
699
700 usbhs_pkt_start(pipe);
701
702 return 0;
703 }
704
705 static void usbhsh_queue_force_pop(struct usbhs_priv *priv,
706 struct usbhs_pipe *pipe)
707 {
708 struct usbhs_pkt *pkt;
709
710 while (1) {
711 pkt = usbhs_pkt_pop(pipe, NULL);
712 if (!pkt)
713 break;
714
715
716
717
718
719
720 usbhsh_queue_done(priv, pkt);
721 }
722 }
723
724 static void usbhsh_queue_force_pop_all(struct usbhs_priv *priv)
725 {
726 struct usbhs_pipe *pos;
727 int i;
728
729 usbhs_for_each_pipe_with_dcp(pos, priv, i)
730 usbhsh_queue_force_pop(priv, pos);
731 }
732
733
734
735
736 static int usbhsh_is_request_address(struct urb *urb)
737 {
738 struct usb_ctrlrequest *req;
739
740 req = (struct usb_ctrlrequest *)urb->setup_packet;
741
742 if ((DeviceOutRequest == req->bRequestType << 8) &&
743 (USB_REQ_SET_ADDRESS == req->bRequest))
744 return 1;
745 else
746 return 0;
747 }
748
749 static void usbhsh_setup_stage_packet_push(struct usbhsh_hpriv *hpriv,
750 struct urb *urb,
751 struct usbhs_pipe *pipe)
752 {
753 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
754 struct usb_ctrlrequest req;
755 struct device *dev = usbhs_priv_to_dev(priv);
756
757
758
759
760
761
762
763 init_completion(&hpriv->setup_ack_done);
764
765
766 memcpy(&req, urb->setup_packet, sizeof(struct usb_ctrlrequest));
767
768
769
770
771
772
773
774 if (usbhsh_is_request_address(urb)) {
775 struct usb_device *usbv = usbhsh_urb_to_usbv(urb);
776 struct usbhsh_device *udev = usbhsh_usbv_to_udev(usbv);
777
778
779 req.wValue = usbhsh_device_number(hpriv, udev);
780 dev_dbg(dev, "create new address - %d\n", req.wValue);
781 }
782
783
784 usbhs_usbreq_set_val(priv, &req);
785
786
787
788
789 wait_for_completion(&hpriv->setup_ack_done);
790
791 dev_dbg(dev, "%s done\n", __func__);
792 }
793
794
795
796
797 static void usbhsh_data_stage_packet_done(struct usbhs_priv *priv,
798 struct usbhs_pkt *pkt)
799 {
800 struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt);
801 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
802
803
804
805 usbhsh_ureq_free(hpriv, ureq);
806 }
807
808 static int usbhsh_data_stage_packet_push(struct usbhsh_hpriv *hpriv,
809 struct urb *urb,
810 struct usbhs_pipe *pipe,
811 gfp_t mem_flags)
812
813 {
814 struct usbhsh_request *ureq;
815
816
817 ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags);
818 if (unlikely(!ureq))
819 return -ENOMEM;
820
821 if (usb_pipein(urb->pipe))
822 pipe->handler = &usbhs_dcp_data_stage_in_handler;
823 else
824 pipe->handler = &usbhs_dcp_data_stage_out_handler;
825
826 usbhs_pkt_push(pipe, &ureq->pkt,
827 usbhsh_data_stage_packet_done,
828 urb->transfer_buffer,
829 urb->transfer_buffer_length,
830 (urb->transfer_flags & URB_ZERO_PACKET),
831 -1);
832
833 return 0;
834 }
835
836
837
838
839 static int usbhsh_status_stage_packet_push(struct usbhsh_hpriv *hpriv,
840 struct urb *urb,
841 struct usbhs_pipe *pipe,
842 gfp_t mem_flags)
843 {
844 struct usbhsh_request *ureq;
845
846
847 ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags);
848 if (unlikely(!ureq))
849 return -ENOMEM;
850
851 if (usb_pipein(urb->pipe))
852 pipe->handler = &usbhs_dcp_status_stage_in_handler;
853 else
854 pipe->handler = &usbhs_dcp_status_stage_out_handler;
855
856 usbhs_pkt_push(pipe, &ureq->pkt,
857 usbhsh_queue_done,
858 NULL,
859 urb->transfer_buffer_length,
860 0, -1);
861
862 return 0;
863 }
864
865 static int usbhsh_dcp_queue_push(struct usb_hcd *hcd,
866 struct urb *urb,
867 gfp_t mflags)
868 {
869 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
870 struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep);
871 struct usbhs_pipe *pipe = usbhsh_uep_to_pipe(uep);
872 struct device *dev = usbhsh_hcd_to_dev(hcd);
873 int ret;
874
875 dev_dbg(dev, "%s\n", __func__);
876
877
878
879
880
881
882 usbhsh_setup_stage_packet_push(hpriv, urb, pipe);
883
884
885
886
887
888
889 if (urb->transfer_buffer_length) {
890 ret = usbhsh_data_stage_packet_push(hpriv, urb, pipe, mflags);
891 if (ret < 0) {
892 dev_err(dev, "data stage failed\n");
893 return ret;
894 }
895 }
896
897
898
899
900 ret = usbhsh_status_stage_packet_push(hpriv, urb, pipe, mflags);
901 if (ret < 0) {
902 dev_err(dev, "status stage failed\n");
903 return ret;
904 }
905
906
907
908
909 usbhs_pkt_start(pipe);
910
911 return 0;
912 }
913
914
915
916
917 static int usbhsh_dma_map_ctrl(struct device *dma_dev, struct usbhs_pkt *pkt,
918 int map)
919 {
920 if (map) {
921 struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt);
922 struct urb *urb = ureq->urb;
923
924
925 if (urb->num_sgs)
926 return -EINVAL;
927
928 pkt->dma = urb->transfer_dma;
929 if (!pkt->dma)
930 return -EINVAL;
931 }
932
933 return 0;
934 }
935
936
937
938
939 static int usbhsh_host_start(struct usb_hcd *hcd)
940 {
941 return 0;
942 }
943
944 static void usbhsh_host_stop(struct usb_hcd *hcd)
945 {
946 }
947
948 static int usbhsh_urb_enqueue(struct usb_hcd *hcd,
949 struct urb *urb,
950 gfp_t mem_flags)
951 {
952 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
953 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
954 struct device *dev = usbhs_priv_to_dev(priv);
955 struct usb_host_endpoint *ep = urb->ep;
956 struct usbhsh_device *new_udev = NULL;
957 int is_dir_in = usb_pipein(urb->pipe);
958 int ret;
959
960 dev_dbg(dev, "%s (%s)\n", __func__, is_dir_in ? "in" : "out");
961
962 if (!usbhsh_is_running(hpriv)) {
963 ret = -EIO;
964 dev_err(dev, "host is not running\n");
965 goto usbhsh_urb_enqueue_error_not_linked;
966 }
967
968 ret = usb_hcd_link_urb_to_ep(hcd, urb);
969 if (ret) {
970 dev_err(dev, "urb link failed\n");
971 goto usbhsh_urb_enqueue_error_not_linked;
972 }
973
974
975
976
977
978 if (!usbhsh_device_get(hpriv, urb)) {
979 new_udev = usbhsh_device_attach(hpriv, urb);
980 if (!new_udev) {
981 ret = -EIO;
982 dev_err(dev, "device attach failed\n");
983 goto usbhsh_urb_enqueue_error_not_linked;
984 }
985 }
986
987
988
989
990
991 if (!usbhsh_ep_to_uep(ep)) {
992 ret = usbhsh_endpoint_attach(hpriv, urb, mem_flags);
993 if (ret < 0) {
994 dev_err(dev, "endpoint attach failed\n");
995 goto usbhsh_urb_enqueue_error_free_device;
996 }
997 }
998
999
1000
1001
1002
1003 ret = usbhsh_pipe_attach(hpriv, urb);
1004 if (ret < 0) {
1005 dev_err(dev, "pipe attach failed\n");
1006 goto usbhsh_urb_enqueue_error_free_endpoint;
1007 }
1008
1009
1010
1011
1012 if (usb_pipecontrol(urb->pipe))
1013 ret = usbhsh_dcp_queue_push(hcd, urb, mem_flags);
1014 else
1015 ret = usbhsh_queue_push(hcd, urb, mem_flags);
1016
1017 return ret;
1018
1019 usbhsh_urb_enqueue_error_free_endpoint:
1020 usbhsh_endpoint_detach(hpriv, ep);
1021 usbhsh_urb_enqueue_error_free_device:
1022 if (new_udev)
1023 usbhsh_device_detach(hpriv, new_udev);
1024 usbhsh_urb_enqueue_error_not_linked:
1025
1026 dev_dbg(dev, "%s error\n", __func__);
1027
1028 return ret;
1029 }
1030
1031 static int usbhsh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1032 {
1033 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
1034 struct usbhsh_request *ureq = usbhsh_urb_to_ureq(urb);
1035
1036 if (ureq) {
1037 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1038 struct usbhs_pkt *pkt = &ureq->pkt;
1039
1040 usbhs_pkt_pop(pkt->pipe, pkt);
1041 usbhsh_queue_done(priv, pkt);
1042 }
1043
1044 return 0;
1045 }
1046
1047 static void usbhsh_endpoint_disable(struct usb_hcd *hcd,
1048 struct usb_host_endpoint *ep)
1049 {
1050 struct usbhsh_ep *uep = usbhsh_ep_to_uep(ep);
1051 struct usbhsh_device *udev;
1052 struct usbhsh_hpriv *hpriv;
1053
1054
1055
1056
1057
1058 if (!uep)
1059 return;
1060
1061 udev = usbhsh_uep_to_udev(uep);
1062 hpriv = usbhsh_hcd_to_hpriv(hcd);
1063
1064 usbhsh_endpoint_detach(hpriv, ep);
1065
1066
1067
1068
1069
1070 if (!usbhsh_device_has_endpoint(udev))
1071 usbhsh_device_detach(hpriv, udev);
1072 }
1073
1074 static int usbhsh_hub_status_data(struct usb_hcd *hcd, char *buf)
1075 {
1076 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
1077 int roothub_id = 1;
1078
1079
1080
1081
1082
1083 if (usbhsh_port_stat_get(hpriv) & 0xFFFF0000)
1084 *buf = (1 << roothub_id);
1085 else
1086 *buf = 0;
1087
1088 return !!(*buf);
1089 }
1090
1091 static int __usbhsh_hub_hub_feature(struct usbhsh_hpriv *hpriv,
1092 u16 typeReq, u16 wValue,
1093 u16 wIndex, char *buf, u16 wLength)
1094 {
1095 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1096 struct device *dev = usbhs_priv_to_dev(priv);
1097
1098 switch (wValue) {
1099 case C_HUB_OVER_CURRENT:
1100 case C_HUB_LOCAL_POWER:
1101 dev_dbg(dev, "%s :: C_HUB_xx\n", __func__);
1102 return 0;
1103 }
1104
1105 return -EPIPE;
1106 }
1107
1108 static int __usbhsh_hub_port_feature(struct usbhsh_hpriv *hpriv,
1109 u16 typeReq, u16 wValue,
1110 u16 wIndex, char *buf, u16 wLength)
1111 {
1112 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1113 struct device *dev = usbhs_priv_to_dev(priv);
1114 int enable = (typeReq == SetPortFeature);
1115 int speed, i, timeout = 128;
1116 int roothub_id = 1;
1117
1118
1119 if (wIndex > roothub_id || wLength != 0)
1120 return -EPIPE;
1121
1122
1123 switch (wValue) {
1124 case USB_PORT_FEAT_POWER:
1125 usbhs_vbus_ctrl(priv, enable);
1126 dev_dbg(dev, "%s :: USB_PORT_FEAT_POWER\n", __func__);
1127 break;
1128
1129 case USB_PORT_FEAT_ENABLE:
1130 case USB_PORT_FEAT_SUSPEND:
1131 case USB_PORT_FEAT_C_ENABLE:
1132 case USB_PORT_FEAT_C_SUSPEND:
1133 case USB_PORT_FEAT_C_CONNECTION:
1134 case USB_PORT_FEAT_C_OVER_CURRENT:
1135 case USB_PORT_FEAT_C_RESET:
1136 dev_dbg(dev, "%s :: USB_PORT_FEAT_xxx\n", __func__);
1137 break;
1138
1139 case USB_PORT_FEAT_RESET:
1140 if (!enable)
1141 break;
1142
1143 usbhsh_port_stat_clear(hpriv,
1144 USB_PORT_STAT_HIGH_SPEED |
1145 USB_PORT_STAT_LOW_SPEED);
1146
1147 usbhsh_queue_force_pop_all(priv);
1148
1149 usbhs_bus_send_reset(priv);
1150 msleep(20);
1151 usbhs_bus_send_sof_enable(priv);
1152
1153 for (i = 0; i < timeout ; i++) {
1154 switch (usbhs_bus_get_speed(priv)) {
1155 case USB_SPEED_LOW:
1156 speed = USB_PORT_STAT_LOW_SPEED;
1157 goto got_usb_bus_speed;
1158 case USB_SPEED_HIGH:
1159 speed = USB_PORT_STAT_HIGH_SPEED;
1160 goto got_usb_bus_speed;
1161 case USB_SPEED_FULL:
1162 speed = 0;
1163 goto got_usb_bus_speed;
1164 }
1165
1166 msleep(20);
1167 }
1168 return -EPIPE;
1169
1170 got_usb_bus_speed:
1171 usbhsh_port_stat_set(hpriv, speed);
1172 usbhsh_port_stat_set(hpriv, USB_PORT_STAT_ENABLE);
1173
1174 dev_dbg(dev, "%s :: USB_PORT_FEAT_RESET (speed = %d)\n",
1175 __func__, speed);
1176
1177
1178 return 0;
1179
1180 default:
1181 return -EPIPE;
1182 }
1183
1184
1185 if (enable)
1186 usbhsh_port_stat_set(hpriv, (1 << wValue));
1187 else
1188 usbhsh_port_stat_clear(hpriv, (1 << wValue));
1189
1190 return 0;
1191 }
1192
1193 static int __usbhsh_hub_get_status(struct usbhsh_hpriv *hpriv,
1194 u16 typeReq, u16 wValue,
1195 u16 wIndex, char *buf, u16 wLength)
1196 {
1197 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1198 struct usb_hub_descriptor *desc = (struct usb_hub_descriptor *)buf;
1199 struct device *dev = usbhs_priv_to_dev(priv);
1200 int roothub_id = 1;
1201
1202 switch (typeReq) {
1203 case GetHubStatus:
1204 dev_dbg(dev, "%s :: GetHubStatus\n", __func__);
1205
1206 *buf = 0x00;
1207 break;
1208
1209 case GetPortStatus:
1210 if (wIndex != roothub_id)
1211 return -EPIPE;
1212
1213 dev_dbg(dev, "%s :: GetPortStatus\n", __func__);
1214 *(__le32 *)buf = cpu_to_le32(usbhsh_port_stat_get(hpriv));
1215 break;
1216
1217 case GetHubDescriptor:
1218 desc->bDescriptorType = USB_DT_HUB;
1219 desc->bHubContrCurrent = 0;
1220 desc->bNbrPorts = roothub_id;
1221 desc->bDescLength = 9;
1222 desc->bPwrOn2PwrGood = 0;
1223 desc->wHubCharacteristics =
1224 cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_NO_OCPM);
1225 desc->u.hs.DeviceRemovable[0] = (roothub_id << 1);
1226 desc->u.hs.DeviceRemovable[1] = ~0;
1227 dev_dbg(dev, "%s :: GetHubDescriptor\n", __func__);
1228 break;
1229 }
1230
1231 return 0;
1232 }
1233
1234 static int usbhsh_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
1235 u16 wIndex, char *buf, u16 wLength)
1236 {
1237 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
1238 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1239 struct device *dev = usbhs_priv_to_dev(priv);
1240 int ret = -EPIPE;
1241
1242 switch (typeReq) {
1243
1244
1245 case ClearHubFeature:
1246 case SetHubFeature:
1247 ret = __usbhsh_hub_hub_feature(hpriv, typeReq,
1248 wValue, wIndex, buf, wLength);
1249 break;
1250
1251
1252 case SetPortFeature:
1253 case ClearPortFeature:
1254 ret = __usbhsh_hub_port_feature(hpriv, typeReq,
1255 wValue, wIndex, buf, wLength);
1256 break;
1257
1258
1259 case GetHubStatus:
1260 case GetPortStatus:
1261 case GetHubDescriptor:
1262 ret = __usbhsh_hub_get_status(hpriv, typeReq,
1263 wValue, wIndex, buf, wLength);
1264 break;
1265 }
1266
1267 dev_dbg(dev, "typeReq = %x, ret = %d, port_stat = %x\n",
1268 typeReq, ret, usbhsh_port_stat_get(hpriv));
1269
1270 return ret;
1271 }
1272
1273 static int usbhsh_bus_nop(struct usb_hcd *hcd)
1274 {
1275
1276 return 0;
1277 }
1278
1279 static const struct hc_driver usbhsh_driver = {
1280 .description = usbhsh_hcd_name,
1281 .hcd_priv_size = sizeof(struct usbhsh_hpriv),
1282
1283
1284
1285
1286 .flags = HCD_DMA | HCD_USB2,
1287
1288 .start = usbhsh_host_start,
1289 .stop = usbhsh_host_stop,
1290
1291
1292
1293
1294 .urb_enqueue = usbhsh_urb_enqueue,
1295 .urb_dequeue = usbhsh_urb_dequeue,
1296 .endpoint_disable = usbhsh_endpoint_disable,
1297
1298
1299
1300
1301 .hub_status_data = usbhsh_hub_status_data,
1302 .hub_control = usbhsh_hub_control,
1303 .bus_suspend = usbhsh_bus_nop,
1304 .bus_resume = usbhsh_bus_nop,
1305 };
1306
1307
1308
1309
1310 static int usbhsh_irq_attch(struct usbhs_priv *priv,
1311 struct usbhs_irq_state *irq_state)
1312 {
1313 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1314 struct device *dev = usbhs_priv_to_dev(priv);
1315
1316 dev_dbg(dev, "device attached\n");
1317
1318 usbhsh_port_stat_set(hpriv, USB_PORT_STAT_CONNECTION);
1319 usbhsh_port_stat_set(hpriv, USB_PORT_STAT_C_CONNECTION << 16);
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332 hpriv->mod.irq_attch = NULL;
1333 usbhs_irq_callback_update(priv, &hpriv->mod);
1334
1335 return 0;
1336 }
1337
1338 static int usbhsh_irq_dtch(struct usbhs_priv *priv,
1339 struct usbhs_irq_state *irq_state)
1340 {
1341 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1342 struct device *dev = usbhs_priv_to_dev(priv);
1343
1344 dev_dbg(dev, "device detached\n");
1345
1346 usbhsh_port_stat_clear(hpriv, USB_PORT_STAT_CONNECTION);
1347 usbhsh_port_stat_set(hpriv, USB_PORT_STAT_C_CONNECTION << 16);
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358 hpriv->mod.irq_attch = usbhsh_irq_attch;
1359 usbhs_irq_callback_update(priv, &hpriv->mod);
1360
1361
1362
1363
1364
1365 usbhsh_queue_force_pop_all(priv);
1366
1367 return 0;
1368 }
1369
1370 static int usbhsh_irq_setup_ack(struct usbhs_priv *priv,
1371 struct usbhs_irq_state *irq_state)
1372 {
1373 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1374 struct device *dev = usbhs_priv_to_dev(priv);
1375
1376 dev_dbg(dev, "setup packet OK\n");
1377
1378 complete(&hpriv->setup_ack_done);
1379
1380 return 0;
1381 }
1382
1383 static int usbhsh_irq_setup_err(struct usbhs_priv *priv,
1384 struct usbhs_irq_state *irq_state)
1385 {
1386 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1387 struct device *dev = usbhs_priv_to_dev(priv);
1388
1389 dev_dbg(dev, "setup packet Err\n");
1390
1391 complete(&hpriv->setup_ack_done);
1392
1393 return 0;
1394 }
1395
1396
1397
1398
1399 static void usbhsh_pipe_init_for_host(struct usbhs_priv *priv)
1400 {
1401 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1402 struct usbhs_pipe *pipe;
1403 struct renesas_usbhs_driver_pipe_config *pipe_configs =
1404 usbhs_get_dparam(priv, pipe_configs);
1405 int pipe_size = usbhs_get_dparam(priv, pipe_size);
1406 int old_type, dir_in, i;
1407
1408
1409 old_type = USB_ENDPOINT_XFER_CONTROL;
1410 for (i = 0; i < pipe_size; i++) {
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432 dir_in = (pipe_configs[i].type == old_type);
1433 old_type = pipe_configs[i].type;
1434
1435 if (USB_ENDPOINT_XFER_CONTROL == pipe_configs[i].type) {
1436 pipe = usbhs_dcp_malloc(priv);
1437 usbhsh_hpriv_to_dcp(hpriv) = pipe;
1438 } else {
1439 pipe = usbhs_pipe_malloc(priv,
1440 pipe_configs[i].type,
1441 dir_in);
1442 }
1443
1444 pipe->mod_private = NULL;
1445 }
1446 }
1447
1448 static int usbhsh_start(struct usbhs_priv *priv)
1449 {
1450 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1451 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
1452 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
1453 struct device *dev = usbhs_priv_to_dev(priv);
1454 int ret;
1455
1456
1457 ret = usb_add_hcd(hcd, 0, 0);
1458 if (ret < 0)
1459 return 0;
1460 device_wakeup_enable(hcd->self.controller);
1461
1462
1463
1464
1465 usbhs_fifo_init(priv);
1466 usbhs_pipe_init(priv,
1467 usbhsh_dma_map_ctrl);
1468 usbhsh_pipe_init_for_host(priv);
1469
1470
1471
1472
1473
1474
1475
1476 usbhs_sys_host_ctrl(priv, 1);
1477
1478
1479
1480
1481 mod->irq_attch = usbhsh_irq_attch;
1482 mod->irq_dtch = usbhsh_irq_dtch;
1483 mod->irq_sack = usbhsh_irq_setup_ack;
1484 mod->irq_sign = usbhsh_irq_setup_err;
1485 usbhs_irq_callback_update(priv, mod);
1486
1487 dev_dbg(dev, "start host\n");
1488
1489 return ret;
1490 }
1491
1492 static int usbhsh_stop(struct usbhs_priv *priv)
1493 {
1494 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1495 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
1496 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
1497 struct device *dev = usbhs_priv_to_dev(priv);
1498
1499
1500
1501
1502 mod->irq_attch = NULL;
1503 mod->irq_dtch = NULL;
1504 mod->irq_sack = NULL;
1505 mod->irq_sign = NULL;
1506 usbhs_irq_callback_update(priv, mod);
1507
1508 usb_remove_hcd(hcd);
1509
1510
1511 usbhs_sys_host_ctrl(priv, 0);
1512
1513 dev_dbg(dev, "quit host\n");
1514
1515 return 0;
1516 }
1517
1518 int usbhs_mod_host_probe(struct usbhs_priv *priv)
1519 {
1520 struct usbhsh_hpriv *hpriv;
1521 struct usb_hcd *hcd;
1522 struct usbhsh_device *udev;
1523 struct device *dev = usbhs_priv_to_dev(priv);
1524 int i;
1525
1526
1527 hcd = usb_create_hcd(&usbhsh_driver, dev, usbhsh_hcd_name);
1528 if (!hcd) {
1529 dev_err(dev, "Failed to create hcd\n");
1530 return -ENOMEM;
1531 }
1532 hcd->has_tt = 1;
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542 hpriv = usbhsh_hcd_to_hpriv(hcd);
1543
1544
1545
1546
1547 usbhs_mod_register(priv, &hpriv->mod, USBHS_HOST);
1548
1549
1550 hpriv->mod.name = "host";
1551 hpriv->mod.start = usbhsh_start;
1552 hpriv->mod.stop = usbhsh_stop;
1553 usbhsh_port_stat_init(hpriv);
1554
1555
1556 usbhsh_for_each_udev_with_dev0(udev, hpriv, i) {
1557 udev->usbv = NULL;
1558 INIT_LIST_HEAD(&udev->ep_list_head);
1559 }
1560
1561 dev_info(dev, "host probed\n");
1562
1563 return 0;
1564 }
1565
1566 int usbhs_mod_host_remove(struct usbhs_priv *priv)
1567 {
1568 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1569 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
1570
1571 usb_put_hcd(hcd);
1572
1573 return 0;
1574 }