Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * xen-hcd.c
4 *
5 * Xen USB Virtual Host Controller driver
6 *
7 * Copyright (C) 2009, FUJITSU LABORATORIES LTD.
8 * Author: Noboru Iwamatsu <n_iwamatsu@jp.fujitsu.com>
9 */
10
11#include <linux/module.h>
12#include <linux/usb.h>
13#include <linux/list.h>
14#include <linux/usb/hcd.h>
15#include <linux/io.h>
16
17#include <xen/xen.h>
18#include <xen/xenbus.h>
19#include <xen/grant_table.h>
20#include <xen/events.h>
21#include <xen/page.h>
22
23#include <xen/interface/io/usbif.h>
24
25/* Private per-URB data */
26struct urb_priv {
27 struct list_head list;
28 struct urb *urb;
29 int req_id; /* RING_REQUEST id for submitting */
30 int unlink_req_id; /* RING_REQUEST id for unlinking */
31 int status;
32 bool unlinked; /* dequeued marker */
33};
34
35/* virtual roothub port status */
36struct rhport_status {
37 __u32 status;
38 bool resuming; /* in resuming */
39 bool c_connection; /* connection changed */
40 unsigned long timeout;
41};
42
43/* status of attached device */
44struct vdevice_status {
45 int devnum;
46 enum usb_device_state status;
47 enum usb_device_speed speed;
48};
49
50/* RING request shadow */
51struct usb_shadow {
52 struct xenusb_urb_request req;
53 struct urb *urb;
54 bool in_flight;
55};
56
57struct xenhcd_info {
58 /* Virtual Host Controller has 4 urb queues */
59 struct list_head pending_submit_list;
60 struct list_head pending_unlink_list;
61 struct list_head in_progress_list;
62 struct list_head giveback_waiting_list;
63
64 spinlock_t lock;
65
66 /* timer that kick pending and giveback waiting urbs */
67 struct timer_list watchdog;
68 unsigned long actions;
69
70 /* virtual root hub */
71 int rh_numports;
72 struct rhport_status ports[XENUSB_MAX_PORTNR];
73 struct vdevice_status devices[XENUSB_MAX_PORTNR];
74
75 /* Xen related staff */
76 struct xenbus_device *xbdev;
77 int urb_ring_ref;
78 int conn_ring_ref;
79 struct xenusb_urb_front_ring urb_ring;
80 struct xenusb_conn_front_ring conn_ring;
81
82 unsigned int evtchn;
83 unsigned int irq;
84 struct usb_shadow shadow[XENUSB_URB_RING_SIZE];
85 unsigned int shadow_free;
86
87 bool error;
88};
89
90#define XENHCD_RING_JIFFIES (HZ/200)
91#define XENHCD_SCAN_JIFFIES 1
92
93enum xenhcd_timer_action {
94 TIMER_RING_WATCHDOG,
95 TIMER_SCAN_PENDING_URBS,
96};
97
98static struct kmem_cache *xenhcd_urbp_cachep;
99
100static inline struct xenhcd_info *xenhcd_hcd_to_info(struct usb_hcd *hcd)
101{
102 return (struct xenhcd_info *)hcd->hcd_priv;
103}
104
105static inline struct usb_hcd *xenhcd_info_to_hcd(struct xenhcd_info *info)
106{
107 return container_of((void *)info, struct usb_hcd, hcd_priv);
108}
109
110static void xenhcd_set_error(struct xenhcd_info *info, const char *msg)
111{
112 info->error = true;
113
114 pr_alert("xen-hcd: protocol error: %s!\n", msg);
115}
116
117static inline void xenhcd_timer_action_done(struct xenhcd_info *info,
118 enum xenhcd_timer_action action)
119{
120 clear_bit(action, &info->actions);
121}
122
123static void xenhcd_timer_action(struct xenhcd_info *info,
124 enum xenhcd_timer_action action)
125{
126 if (timer_pending(&info->watchdog) &&
127 test_bit(TIMER_SCAN_PENDING_URBS, &info->actions))
128 return;
129
130 if (!test_and_set_bit(action, &info->actions)) {
131 unsigned long t;
132
133 switch (action) {
134 case TIMER_RING_WATCHDOG:
135 t = XENHCD_RING_JIFFIES;
136 break;
137 default:
138 t = XENHCD_SCAN_JIFFIES;
139 break;
140 }
141 mod_timer(&info->watchdog, t + jiffies);
142 }
143}
144
145/*
146 * set virtual port connection status
147 */
148static void xenhcd_set_connect_state(struct xenhcd_info *info, int portnum)
149{
150 int port;
151
152 port = portnum - 1;
153 if (info->ports[port].status & USB_PORT_STAT_POWER) {
154 switch (info->devices[port].speed) {
155 case XENUSB_SPEED_NONE:
156 info->ports[port].status &=
157 ~(USB_PORT_STAT_CONNECTION |
158 USB_PORT_STAT_ENABLE |
159 USB_PORT_STAT_LOW_SPEED |
160 USB_PORT_STAT_HIGH_SPEED |
161 USB_PORT_STAT_SUSPEND);
162 break;
163 case XENUSB_SPEED_LOW:
164 info->ports[port].status |= USB_PORT_STAT_CONNECTION;
165 info->ports[port].status |= USB_PORT_STAT_LOW_SPEED;
166 break;
167 case XENUSB_SPEED_FULL:
168 info->ports[port].status |= USB_PORT_STAT_CONNECTION;
169 break;
170 case XENUSB_SPEED_HIGH:
171 info->ports[port].status |= USB_PORT_STAT_CONNECTION;
172 info->ports[port].status |= USB_PORT_STAT_HIGH_SPEED;
173 break;
174 default: /* error */
175 return;
176 }
177 info->ports[port].status |= (USB_PORT_STAT_C_CONNECTION << 16);
178 }
179}
180
181/*
182 * set virtual device connection status
183 */
184static int xenhcd_rhport_connect(struct xenhcd_info *info, __u8 portnum,
185 __u8 speed)
186{
187 int port;
188
189 if (portnum < 1 || portnum > info->rh_numports)
190 return -EINVAL; /* invalid port number */
191
192 port = portnum - 1;
193 if (info->devices[port].speed != speed) {
194 switch (speed) {
195 case XENUSB_SPEED_NONE: /* disconnect */
196 info->devices[port].status = USB_STATE_NOTATTACHED;
197 break;
198 case XENUSB_SPEED_LOW:
199 case XENUSB_SPEED_FULL:
200 case XENUSB_SPEED_HIGH:
201 info->devices[port].status = USB_STATE_ATTACHED;
202 break;
203 default: /* error */
204 return -EINVAL;
205 }
206 info->devices[port].speed = speed;
207 info->ports[port].c_connection = true;
208
209 xenhcd_set_connect_state(info, portnum);
210 }
211
212 return 0;
213}
214
215/*
216 * SetPortFeature(PORT_SUSPENDED)
217 */
218static void xenhcd_rhport_suspend(struct xenhcd_info *info, int portnum)
219{
220 int port;
221
222 port = portnum - 1;
223 info->ports[port].status |= USB_PORT_STAT_SUSPEND;
224 info->devices[port].status = USB_STATE_SUSPENDED;
225}
226
227/*
228 * ClearPortFeature(PORT_SUSPENDED)
229 */
230static void xenhcd_rhport_resume(struct xenhcd_info *info, int portnum)
231{
232 int port;
233
234 port = portnum - 1;
235 if (info->ports[port].status & USB_PORT_STAT_SUSPEND) {
236 info->ports[port].resuming = true;
237 info->ports[port].timeout = jiffies + msecs_to_jiffies(20);
238 }
239}
240
241/*
242 * SetPortFeature(PORT_POWER)
243 */
244static void xenhcd_rhport_power_on(struct xenhcd_info *info, int portnum)
245{
246 int port;
247
248 port = portnum - 1;
249 if ((info->ports[port].status & USB_PORT_STAT_POWER) == 0) {
250 info->ports[port].status |= USB_PORT_STAT_POWER;
251 if (info->devices[port].status != USB_STATE_NOTATTACHED)
252 info->devices[port].status = USB_STATE_POWERED;
253 if (info->ports[port].c_connection)
254 xenhcd_set_connect_state(info, portnum);
255 }
256}
257
258/*
259 * ClearPortFeature(PORT_POWER)
260 * SetConfiguration(non-zero)
261 * Power_Source_Off
262 * Over-current
263 */
264static void xenhcd_rhport_power_off(struct xenhcd_info *info, int portnum)
265{
266 int port;
267
268 port = portnum - 1;
269 if (info->ports[port].status & USB_PORT_STAT_POWER) {
270 info->ports[port].status = 0;
271 if (info->devices[port].status != USB_STATE_NOTATTACHED)
272 info->devices[port].status = USB_STATE_ATTACHED;
273 }
274}
275
276/*
277 * ClearPortFeature(PORT_ENABLE)
278 */
279static void xenhcd_rhport_disable(struct xenhcd_info *info, int portnum)
280{
281 int port;
282
283 port = portnum - 1;
284 info->ports[port].status &= ~USB_PORT_STAT_ENABLE;
285 info->ports[port].status &= ~USB_PORT_STAT_SUSPEND;
286 info->ports[port].resuming = false;
287 if (info->devices[port].status != USB_STATE_NOTATTACHED)
288 info->devices[port].status = USB_STATE_POWERED;
289}
290
291/*
292 * SetPortFeature(PORT_RESET)
293 */
294static void xenhcd_rhport_reset(struct xenhcd_info *info, int portnum)
295{
296 int port;
297
298 port = portnum - 1;
299 info->ports[port].status &= ~(USB_PORT_STAT_ENABLE |
300 USB_PORT_STAT_LOW_SPEED |
301 USB_PORT_STAT_HIGH_SPEED);
302 info->ports[port].status |= USB_PORT_STAT_RESET;
303
304 if (info->devices[port].status != USB_STATE_NOTATTACHED)
305 info->devices[port].status = USB_STATE_ATTACHED;
306
307 /* 10msec reset signaling */
308 info->ports[port].timeout = jiffies + msecs_to_jiffies(10);
309}
310
311#ifdef CONFIG_PM
312static int xenhcd_bus_suspend(struct usb_hcd *hcd)
313{
314 struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
315 int ret = 0;
316 int i, ports;
317
318 ports = info->rh_numports;
319
320 spin_lock_irq(&info->lock);
321 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
322 ret = -ESHUTDOWN;
323 } else {
324 /* suspend any active ports*/
325 for (i = 1; i <= ports; i++)
326 xenhcd_rhport_suspend(info, i);
327 }
328 spin_unlock_irq(&info->lock);
329
330 del_timer_sync(&info->watchdog);
331
332 return ret;
333}
334
335static int xenhcd_bus_resume(struct usb_hcd *hcd)
336{
337 struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
338 int ret = 0;
339 int i, ports;
340
341 ports = info->rh_numports;
342
343 spin_lock_irq(&info->lock);
344 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
345 ret = -ESHUTDOWN;
346 } else {
347 /* resume any suspended ports*/
348 for (i = 1; i <= ports; i++)
349 xenhcd_rhport_resume(info, i);
350 }
351 spin_unlock_irq(&info->lock);
352
353 return ret;
354}
355#endif
356
357static void xenhcd_hub_descriptor(struct xenhcd_info *info,
358 struct usb_hub_descriptor *desc)
359{
360 __u16 temp;
361 int ports = info->rh_numports;
362
363 desc->bDescriptorType = 0x29;
364 desc->bPwrOn2PwrGood = 10; /* EHCI says 20ms max */
365 desc->bHubContrCurrent = 0;
366 desc->bNbrPorts = ports;
367
368 /* size of DeviceRemovable and PortPwrCtrlMask fields */
369 temp = 1 + (ports / 8);
370 desc->bDescLength = 7 + 2 * temp;
371
372 /* bitmaps for DeviceRemovable and PortPwrCtrlMask */
373 memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
374 memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
375
376 /* per-port over current reporting and no power switching */
377 temp = 0x000a;
378 desc->wHubCharacteristics = cpu_to_le16(temp);
379}
380
381/* port status change mask for hub_status_data */
382#define PORT_C_MASK ((USB_PORT_STAT_C_CONNECTION | \
383 USB_PORT_STAT_C_ENABLE | \
384 USB_PORT_STAT_C_SUSPEND | \
385 USB_PORT_STAT_C_OVERCURRENT | \
386 USB_PORT_STAT_C_RESET) << 16)
387
388/*
389 * See USB 2.0 Spec, 11.12.4 Hub and Port Status Change Bitmap.
390 * If port status changed, writes the bitmap to buf and return
391 * that length(number of bytes).
392 * If Nothing changed, return 0.
393 */
394static int xenhcd_hub_status_data(struct usb_hcd *hcd, char *buf)
395{
396 struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
397 int ports;
398 int i;
399 unsigned long flags;
400 int ret;
401 int changed = 0;
402
403 /* initialize the status to no-changes */
404 ports = info->rh_numports;
405 ret = 1 + (ports / 8);
406 memset(buf, 0, ret);
407
408 spin_lock_irqsave(&info->lock, flags);
409
410 for (i = 0; i < ports; i++) {
411 /* check status for each port */
412 if (info->ports[i].status & PORT_C_MASK) {
413 buf[(i + 1) / 8] |= 1 << (i + 1) % 8;
414 changed = 1;
415 }
416 }
417
418 if ((hcd->state == HC_STATE_SUSPENDED) && (changed == 1))
419 usb_hcd_resume_root_hub(hcd);
420
421 spin_unlock_irqrestore(&info->lock, flags);
422
423 return changed ? ret : 0;
424}
425
426static int xenhcd_hub_control(struct usb_hcd *hcd, __u16 typeReq, __u16 wValue,
427 __u16 wIndex, char *buf, __u16 wLength)
428{
429 struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
430 int ports = info->rh_numports;
431 unsigned long flags;
432 int ret = 0;
433 int i;
434 int changed = 0;
435
436 spin_lock_irqsave(&info->lock, flags);
437 switch (typeReq) {
438 case ClearHubFeature:
439 /* ignore this request */
440 break;
441 case ClearPortFeature:
442 if (!wIndex || wIndex > ports)
443 goto error;
444
445 switch (wValue) {
446 case USB_PORT_FEAT_SUSPEND:
447 xenhcd_rhport_resume(info, wIndex);
448 break;
449 case USB_PORT_FEAT_POWER:
450 xenhcd_rhport_power_off(info, wIndex);
451 break;
452 case USB_PORT_FEAT_ENABLE:
453 xenhcd_rhport_disable(info, wIndex);
454 break;
455 case USB_PORT_FEAT_C_CONNECTION:
456 info->ports[wIndex - 1].c_connection = false;
457 fallthrough;
458 default:
459 info->ports[wIndex - 1].status &= ~(1 << wValue);
460 break;
461 }
462 break;
463 case GetHubDescriptor:
464 xenhcd_hub_descriptor(info, (struct usb_hub_descriptor *)buf);
465 break;
466 case GetHubStatus:
467 /* always local power supply good and no over-current exists. */
468 *(__le32 *)buf = cpu_to_le32(0);
469 break;
470 case GetPortStatus:
471 if (!wIndex || wIndex > ports)
472 goto error;
473
474 wIndex--;
475
476 /* resume completion */
477 if (info->ports[wIndex].resuming &&
478 time_after_eq(jiffies, info->ports[wIndex].timeout)) {
479 info->ports[wIndex].status |=
480 USB_PORT_STAT_C_SUSPEND << 16;
481 info->ports[wIndex].status &= ~USB_PORT_STAT_SUSPEND;
482 }
483
484 /* reset completion */
485 if ((info->ports[wIndex].status & USB_PORT_STAT_RESET) != 0 &&
486 time_after_eq(jiffies, info->ports[wIndex].timeout)) {
487 info->ports[wIndex].status |=
488 USB_PORT_STAT_C_RESET << 16;
489 info->ports[wIndex].status &= ~USB_PORT_STAT_RESET;
490
491 if (info->devices[wIndex].status !=
492 USB_STATE_NOTATTACHED) {
493 info->ports[wIndex].status |=
494 USB_PORT_STAT_ENABLE;
495 info->devices[wIndex].status =
496 USB_STATE_DEFAULT;
497 }
498
499 switch (info->devices[wIndex].speed) {
500 case XENUSB_SPEED_LOW:
501 info->ports[wIndex].status |=
502 USB_PORT_STAT_LOW_SPEED;
503 break;
504 case XENUSB_SPEED_HIGH:
505 info->ports[wIndex].status |=
506 USB_PORT_STAT_HIGH_SPEED;
507 break;
508 default:
509 break;
510 }
511 }
512
513 *(__le32 *)buf = cpu_to_le32(info->ports[wIndex].status);
514 break;
515 case SetPortFeature:
516 if (!wIndex || wIndex > ports)
517 goto error;
518
519 switch (wValue) {
520 case USB_PORT_FEAT_POWER:
521 xenhcd_rhport_power_on(info, wIndex);
522 break;
523 case USB_PORT_FEAT_RESET:
524 xenhcd_rhport_reset(info, wIndex);
525 break;
526 case USB_PORT_FEAT_SUSPEND:
527 xenhcd_rhport_suspend(info, wIndex);
528 break;
529 default:
530 if (info->ports[wIndex-1].status & USB_PORT_STAT_POWER)
531 info->ports[wIndex-1].status |= (1 << wValue);
532 }
533 break;
534
535 case SetHubFeature:
536 /* not supported */
537 default:
538error:
539 ret = -EPIPE;
540 }
541 spin_unlock_irqrestore(&info->lock, flags);
542
543 /* check status for each port */
544 for (i = 0; i < ports; i++) {
545 if (info->ports[i].status & PORT_C_MASK)
546 changed = 1;
547 }
548 if (changed)
549 usb_hcd_poll_rh_status(hcd);
550
551 return ret;
552}
553
554static void xenhcd_free_urb_priv(struct urb_priv *urbp)
555{
556 urbp->urb->hcpriv = NULL;
557 kmem_cache_free(xenhcd_urbp_cachep, urbp);
558}
559
560static inline unsigned int xenhcd_get_id_from_freelist(struct xenhcd_info *info)
561{
562 unsigned int free;
563
564 free = info->shadow_free;
565 info->shadow_free = info->shadow[free].req.id;
566 info->shadow[free].req.id = 0x0fff; /* debug */
567 return free;
568}
569
570static inline void xenhcd_add_id_to_freelist(struct xenhcd_info *info,
571 unsigned int id)
572{
573 info->shadow[id].req.id = info->shadow_free;
574 info->shadow[id].urb = NULL;
575 info->shadow_free = id;
576}
577
578static inline int xenhcd_count_pages(void *addr, int length)
579{
580 unsigned long vaddr = (unsigned long)addr;
581
582 return PFN_UP(vaddr + length) - PFN_DOWN(vaddr);
583}
584
585static void xenhcd_gnttab_map(struct xenhcd_info *info, void *addr, int length,
586 grant_ref_t *gref_head,
587 struct xenusb_request_segment *seg,
588 int nr_pages, int flags)
589{
590 grant_ref_t ref;
591 unsigned int offset;
592 unsigned int len = length;
593 unsigned int bytes;
594 int i;
595
596 for (i = 0; i < nr_pages; i++) {
597 offset = offset_in_page(addr);
598
599 bytes = PAGE_SIZE - offset;
600 if (bytes > len)
601 bytes = len;
602
603 ref = gnttab_claim_grant_reference(gref_head);
604 gnttab_grant_foreign_access_ref(ref, info->xbdev->otherend_id,
605 virt_to_gfn(addr), flags);
606 seg[i].gref = ref;
607 seg[i].offset = (__u16)offset;
608 seg[i].length = (__u16)bytes;
609
610 addr += bytes;
611 len -= bytes;
612 }
613}
614
615static __u32 xenhcd_pipe_urb_to_xenusb(__u32 urb_pipe, __u8 port)
616{
617 static __u32 pipe;
618
619 pipe = usb_pipedevice(urb_pipe) << XENUSB_PIPE_DEV_SHIFT;
620 pipe |= usb_pipeendpoint(urb_pipe) << XENUSB_PIPE_EP_SHIFT;
621 if (usb_pipein(urb_pipe))
622 pipe |= XENUSB_PIPE_DIR;
623 switch (usb_pipetype(urb_pipe)) {
624 case PIPE_ISOCHRONOUS:
625 pipe |= XENUSB_PIPE_TYPE_ISOC << XENUSB_PIPE_TYPE_SHIFT;
626 break;
627 case PIPE_INTERRUPT:
628 pipe |= XENUSB_PIPE_TYPE_INT << XENUSB_PIPE_TYPE_SHIFT;
629 break;
630 case PIPE_CONTROL:
631 pipe |= XENUSB_PIPE_TYPE_CTRL << XENUSB_PIPE_TYPE_SHIFT;
632 break;
633 case PIPE_BULK:
634 pipe |= XENUSB_PIPE_TYPE_BULK << XENUSB_PIPE_TYPE_SHIFT;
635 break;
636 }
637 pipe = xenusb_setportnum_pipe(pipe, port);
638
639 return pipe;
640}
641
642static int xenhcd_map_urb_for_request(struct xenhcd_info *info, struct urb *urb,
643 struct xenusb_urb_request *req)
644{
645 grant_ref_t gref_head;
646 int nr_buff_pages = 0;
647 int nr_isodesc_pages = 0;
648 int nr_grants = 0;
649
650 if (urb->transfer_buffer_length) {
651 nr_buff_pages = xenhcd_count_pages(urb->transfer_buffer,
652 urb->transfer_buffer_length);
653
654 if (usb_pipeisoc(urb->pipe))
655 nr_isodesc_pages = xenhcd_count_pages(
656 &urb->iso_frame_desc[0],
657 sizeof(struct usb_iso_packet_descriptor) *
658 urb->number_of_packets);
659
660 nr_grants = nr_buff_pages + nr_isodesc_pages;
661 if (nr_grants > XENUSB_MAX_SEGMENTS_PER_REQUEST) {
662 pr_err("xenhcd: error: %d grants\n", nr_grants);
663 return -E2BIG;
664 }
665
666 if (gnttab_alloc_grant_references(nr_grants, &gref_head)) {
667 pr_err("xenhcd: gnttab_alloc_grant_references() error\n");
668 return -ENOMEM;
669 }
670
671 xenhcd_gnttab_map(info, urb->transfer_buffer,
672 urb->transfer_buffer_length, &gref_head,
673 &req->seg[0], nr_buff_pages,
674 usb_pipein(urb->pipe) ? 0 : GTF_readonly);
675 }
676
677 req->pipe = xenhcd_pipe_urb_to_xenusb(urb->pipe, urb->dev->portnum);
678 req->transfer_flags = 0;
679 if (urb->transfer_flags & URB_SHORT_NOT_OK)
680 req->transfer_flags |= XENUSB_SHORT_NOT_OK;
681 req->buffer_length = urb->transfer_buffer_length;
682 req->nr_buffer_segs = nr_buff_pages;
683
684 switch (usb_pipetype(urb->pipe)) {
685 case PIPE_ISOCHRONOUS:
686 req->u.isoc.interval = urb->interval;
687 req->u.isoc.start_frame = urb->start_frame;
688 req->u.isoc.number_of_packets = urb->number_of_packets;
689 req->u.isoc.nr_frame_desc_segs = nr_isodesc_pages;
690
691 xenhcd_gnttab_map(info, &urb->iso_frame_desc[0],
692 sizeof(struct usb_iso_packet_descriptor) *
693 urb->number_of_packets,
694 &gref_head, &req->seg[nr_buff_pages],
695 nr_isodesc_pages, 0);
696 break;
697 case PIPE_INTERRUPT:
698 req->u.intr.interval = urb->interval;
699 break;
700 case PIPE_CONTROL:
701 if (urb->setup_packet)
702 memcpy(req->u.ctrl, urb->setup_packet, 8);
703 break;
704 case PIPE_BULK:
705 break;
706 default:
707 break;
708 }
709
710 if (nr_grants)
711 gnttab_free_grant_references(gref_head);
712
713 return 0;
714}
715
716static void xenhcd_gnttab_done(struct xenhcd_info *info, unsigned int id)
717{
718 struct usb_shadow *shadow = info->shadow + id;
719 int nr_segs = 0;
720 int i;
721
722 if (!shadow->in_flight) {
723 xenhcd_set_error(info, "Illegal request id");
724 return;
725 }
726 shadow->in_flight = false;
727
728 nr_segs = shadow->req.nr_buffer_segs;
729
730 if (xenusb_pipeisoc(shadow->req.pipe))
731 nr_segs += shadow->req.u.isoc.nr_frame_desc_segs;
732
733 for (i = 0; i < nr_segs; i++) {
734 if (!gnttab_try_end_foreign_access(shadow->req.seg[i].gref))
735 xenhcd_set_error(info, "backend didn't release grant");
736 }
737
738 shadow->req.nr_buffer_segs = 0;
739 shadow->req.u.isoc.nr_frame_desc_segs = 0;
740}
741
742static int xenhcd_translate_status(int status)
743{
744 switch (status) {
745 case XENUSB_STATUS_OK:
746 return 0;
747 case XENUSB_STATUS_NODEV:
748 return -ENODEV;
749 case XENUSB_STATUS_INVAL:
750 return -EINVAL;
751 case XENUSB_STATUS_STALL:
752 return -EPIPE;
753 case XENUSB_STATUS_IOERROR:
754 return -EPROTO;
755 case XENUSB_STATUS_BABBLE:
756 return -EOVERFLOW;
757 default:
758 return -ESHUTDOWN;
759 }
760}
761
762static void xenhcd_giveback_urb(struct xenhcd_info *info, struct urb *urb,
763 int status)
764{
765 struct urb_priv *urbp = (struct urb_priv *)urb->hcpriv;
766 int priv_status = urbp->status;
767
768 list_del_init(&urbp->list);
769 xenhcd_free_urb_priv(urbp);
770
771 if (urb->status == -EINPROGRESS)
772 urb->status = xenhcd_translate_status(status);
773
774 spin_unlock(&info->lock);
775 usb_hcd_giveback_urb(xenhcd_info_to_hcd(info), urb,
776 priv_status <= 0 ? priv_status : urb->status);
777 spin_lock(&info->lock);
778}
779
780static int xenhcd_do_request(struct xenhcd_info *info, struct urb_priv *urbp)
781{
782 struct xenusb_urb_request *req;
783 struct urb *urb = urbp->urb;
784 unsigned int id;
785 int notify;
786 int ret;
787
788 id = xenhcd_get_id_from_freelist(info);
789 req = &info->shadow[id].req;
790 req->id = id;
791
792 if (unlikely(urbp->unlinked)) {
793 req->u.unlink.unlink_id = urbp->req_id;
794 req->pipe = xenusb_setunlink_pipe(xenhcd_pipe_urb_to_xenusb(
795 urb->pipe, urb->dev->portnum));
796 urbp->unlink_req_id = id;
797 } else {
798 ret = xenhcd_map_urb_for_request(info, urb, req);
799 if (ret) {
800 xenhcd_add_id_to_freelist(info, id);
801 return ret;
802 }
803 urbp->req_id = id;
804 }
805
806 req = RING_GET_REQUEST(&info->urb_ring, info->urb_ring.req_prod_pvt);
807 *req = info->shadow[id].req;
808
809 info->urb_ring.req_prod_pvt++;
810 info->shadow[id].urb = urb;
811 info->shadow[id].in_flight = true;
812
813 RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&info->urb_ring, notify);
814 if (notify)
815 notify_remote_via_irq(info->irq);
816
817 return 0;
818}
819
820static void xenhcd_kick_pending_urbs(struct xenhcd_info *info)
821{
822 struct urb_priv *urbp;
823
824 while (!list_empty(&info->pending_submit_list)) {
825 if (RING_FULL(&info->urb_ring)) {
826 xenhcd_timer_action(info, TIMER_RING_WATCHDOG);
827 return;
828 }
829
830 urbp = list_entry(info->pending_submit_list.next,
831 struct urb_priv, list);
832 if (!xenhcd_do_request(info, urbp))
833 list_move_tail(&urbp->list, &info->in_progress_list);
834 else
835 xenhcd_giveback_urb(info, urbp->urb, -ESHUTDOWN);
836 }
837 xenhcd_timer_action_done(info, TIMER_SCAN_PENDING_URBS);
838}
839
840/*
841 * caller must lock info->lock
842 */
843static void xenhcd_cancel_all_enqueued_urbs(struct xenhcd_info *info)
844{
845 struct urb_priv *urbp, *tmp;
846 int req_id;
847
848 list_for_each_entry_safe(urbp, tmp, &info->in_progress_list, list) {
849 req_id = urbp->req_id;
850 if (!urbp->unlinked) {
851 xenhcd_gnttab_done(info, req_id);
852 if (info->error)
853 return;
854 if (urbp->urb->status == -EINPROGRESS)
855 /* not dequeued */
856 xenhcd_giveback_urb(info, urbp->urb,
857 -ESHUTDOWN);
858 else /* dequeued */
859 xenhcd_giveback_urb(info, urbp->urb,
860 urbp->urb->status);
861 }
862 info->shadow[req_id].urb = NULL;
863 }
864
865 list_for_each_entry_safe(urbp, tmp, &info->pending_submit_list, list)
866 xenhcd_giveback_urb(info, urbp->urb, -ESHUTDOWN);
867}
868
869/*
870 * caller must lock info->lock
871 */
872static void xenhcd_giveback_unlinked_urbs(struct xenhcd_info *info)
873{
874 struct urb_priv *urbp, *tmp;
875
876 list_for_each_entry_safe(urbp, tmp, &info->giveback_waiting_list, list)
877 xenhcd_giveback_urb(info, urbp->urb, urbp->urb->status);
878}
879
880static int xenhcd_submit_urb(struct xenhcd_info *info, struct urb_priv *urbp)
881{
882 int ret;
883
884 if (RING_FULL(&info->urb_ring)) {
885 list_add_tail(&urbp->list, &info->pending_submit_list);
886 xenhcd_timer_action(info, TIMER_RING_WATCHDOG);
887 return 0;
888 }
889
890 if (!list_empty(&info->pending_submit_list)) {
891 list_add_tail(&urbp->list, &info->pending_submit_list);
892 xenhcd_timer_action(info, TIMER_SCAN_PENDING_URBS);
893 return 0;
894 }
895
896 ret = xenhcd_do_request(info, urbp);
897 if (ret == 0)
898 list_add_tail(&urbp->list, &info->in_progress_list);
899
900 return ret;
901}
902
903static int xenhcd_unlink_urb(struct xenhcd_info *info, struct urb_priv *urbp)
904{
905 int ret;
906
907 /* already unlinked? */
908 if (urbp->unlinked)
909 return -EBUSY;
910
911 urbp->unlinked = true;
912
913 /* the urb is still in pending_submit queue */
914 if (urbp->req_id == ~0) {
915 list_move_tail(&urbp->list, &info->giveback_waiting_list);
916 xenhcd_timer_action(info, TIMER_SCAN_PENDING_URBS);
917 return 0;
918 }
919
920 /* send unlink request to backend */
921 if (RING_FULL(&info->urb_ring)) {
922 list_move_tail(&urbp->list, &info->pending_unlink_list);
923 xenhcd_timer_action(info, TIMER_RING_WATCHDOG);
924 return 0;
925 }
926
927 if (!list_empty(&info->pending_unlink_list)) {
928 list_move_tail(&urbp->list, &info->pending_unlink_list);
929 xenhcd_timer_action(info, TIMER_SCAN_PENDING_URBS);
930 return 0;
931 }
932
933 ret = xenhcd_do_request(info, urbp);
934 if (ret == 0)
935 list_move_tail(&urbp->list, &info->in_progress_list);
936
937 return ret;
938}
939
940static void xenhcd_res_to_urb(struct xenhcd_info *info,
941 struct xenusb_urb_response *res, struct urb *urb)
942{
943 if (unlikely(!urb))
944 return;
945
946 if (res->actual_length > urb->transfer_buffer_length)
947 urb->actual_length = urb->transfer_buffer_length;
948 else if (res->actual_length < 0)
949 urb->actual_length = 0;
950 else
951 urb->actual_length = res->actual_length;
952 urb->error_count = res->error_count;
953 urb->start_frame = res->start_frame;
954 xenhcd_giveback_urb(info, urb, res->status);
955}
956
957static int xenhcd_urb_request_done(struct xenhcd_info *info,
958 unsigned int *eoiflag)
959{
960 struct xenusb_urb_response res;
961 RING_IDX i, rp;
962 __u16 id;
963 int more_to_do = 0;
964 unsigned long flags;
965
966 spin_lock_irqsave(&info->lock, flags);
967
968 rp = info->urb_ring.sring->rsp_prod;
969 if (RING_RESPONSE_PROD_OVERFLOW(&info->urb_ring, rp)) {
970 xenhcd_set_error(info, "Illegal index on urb-ring");
971 goto err;
972 }
973 rmb(); /* ensure we see queued responses up to "rp" */
974
975 for (i = info->urb_ring.rsp_cons; i != rp; i++) {
976 RING_COPY_RESPONSE(&info->urb_ring, i, &res);
977 id = res.id;
978 if (id >= XENUSB_URB_RING_SIZE) {
979 xenhcd_set_error(info, "Illegal data on urb-ring");
980 goto err;
981 }
982
983 if (likely(xenusb_pipesubmit(info->shadow[id].req.pipe))) {
984 xenhcd_gnttab_done(info, id);
985 if (info->error)
986 goto err;
987 xenhcd_res_to_urb(info, &res, info->shadow[id].urb);
988 }
989
990 xenhcd_add_id_to_freelist(info, id);
991
992 *eoiflag = 0;
993 }
994 info->urb_ring.rsp_cons = i;
995
996 if (i != info->urb_ring.req_prod_pvt)
997 RING_FINAL_CHECK_FOR_RESPONSES(&info->urb_ring, more_to_do);
998 else
999 info->urb_ring.sring->rsp_event = i + 1;
1000
1001 spin_unlock_irqrestore(&info->lock, flags);
1002
1003 return more_to_do;
1004
1005 err:
1006 spin_unlock_irqrestore(&info->lock, flags);
1007 return 0;
1008}
1009
1010static int xenhcd_conn_notify(struct xenhcd_info *info, unsigned int *eoiflag)
1011{
1012 struct xenusb_conn_response res;
1013 struct xenusb_conn_request *req;
1014 RING_IDX rc, rp;
1015 __u16 id;
1016 __u8 portnum, speed;
1017 int more_to_do = 0;
1018 int notify;
1019 int port_changed = 0;
1020 unsigned long flags;
1021
1022 spin_lock_irqsave(&info->lock, flags);
1023
1024 rc = info->conn_ring.rsp_cons;
1025 rp = info->conn_ring.sring->rsp_prod;
1026 if (RING_RESPONSE_PROD_OVERFLOW(&info->conn_ring, rp)) {
1027 xenhcd_set_error(info, "Illegal index on conn-ring");
1028 spin_unlock_irqrestore(&info->lock, flags);
1029 return 0;
1030 }
1031 rmb(); /* ensure we see queued responses up to "rp" */
1032
1033 while (rc != rp) {
1034 RING_COPY_RESPONSE(&info->conn_ring, rc, &res);
1035 id = res.id;
1036 portnum = res.portnum;
1037 speed = res.speed;
1038 info->conn_ring.rsp_cons = ++rc;
1039
1040 if (xenhcd_rhport_connect(info, portnum, speed)) {
1041 xenhcd_set_error(info, "Illegal data on conn-ring");
1042 spin_unlock_irqrestore(&info->lock, flags);
1043 return 0;
1044 }
1045
1046 if (info->ports[portnum - 1].c_connection)
1047 port_changed = 1;
1048
1049 barrier();
1050
1051 req = RING_GET_REQUEST(&info->conn_ring,
1052 info->conn_ring.req_prod_pvt);
1053 req->id = id;
1054 info->conn_ring.req_prod_pvt++;
1055
1056 *eoiflag = 0;
1057 }
1058
1059 if (rc != info->conn_ring.req_prod_pvt)
1060 RING_FINAL_CHECK_FOR_RESPONSES(&info->conn_ring, more_to_do);
1061 else
1062 info->conn_ring.sring->rsp_event = rc + 1;
1063
1064 RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&info->conn_ring, notify);
1065 if (notify)
1066 notify_remote_via_irq(info->irq);
1067
1068 spin_unlock_irqrestore(&info->lock, flags);
1069
1070 if (port_changed)
1071 usb_hcd_poll_rh_status(xenhcd_info_to_hcd(info));
1072
1073 return more_to_do;
1074}
1075
1076static irqreturn_t xenhcd_int(int irq, void *dev_id)
1077{
1078 struct xenhcd_info *info = (struct xenhcd_info *)dev_id;
1079 unsigned int eoiflag = XEN_EOI_FLAG_SPURIOUS;
1080
1081 if (unlikely(info->error)) {
1082 xen_irq_lateeoi(irq, XEN_EOI_FLAG_SPURIOUS);
1083 return IRQ_HANDLED;
1084 }
1085
1086 while (xenhcd_urb_request_done(info, &eoiflag) |
1087 xenhcd_conn_notify(info, &eoiflag))
1088 /* Yield point for this unbounded loop. */
1089 cond_resched();
1090
1091 xen_irq_lateeoi(irq, eoiflag);
1092 return IRQ_HANDLED;
1093}
1094
1095static void xenhcd_destroy_rings(struct xenhcd_info *info)
1096{
1097 if (info->irq)
1098 unbind_from_irqhandler(info->irq, info);
1099 info->irq = 0;
1100
1101 xenbus_teardown_ring((void **)&info->urb_ring.sring, 1,
1102 &info->urb_ring_ref);
1103 xenbus_teardown_ring((void **)&info->conn_ring.sring, 1,
1104 &info->conn_ring_ref);
1105}
1106
1107static int xenhcd_setup_rings(struct xenbus_device *dev,
1108 struct xenhcd_info *info)
1109{
1110 struct xenusb_urb_sring *urb_sring;
1111 struct xenusb_conn_sring *conn_sring;
1112 int err;
1113
1114 info->conn_ring_ref = INVALID_GRANT_REF;
1115 err = xenbus_setup_ring(dev, GFP_NOIO | __GFP_HIGH,
1116 (void **)&urb_sring, 1, &info->urb_ring_ref);
1117 if (err) {
1118 xenbus_dev_fatal(dev, err, "allocating urb ring");
1119 return err;
1120 }
1121 XEN_FRONT_RING_INIT(&info->urb_ring, urb_sring, PAGE_SIZE);
1122
1123 err = xenbus_setup_ring(dev, GFP_NOIO | __GFP_HIGH,
1124 (void **)&conn_sring, 1, &info->conn_ring_ref);
1125 if (err) {
1126 xenbus_dev_fatal(dev, err, "allocating conn ring");
1127 goto fail;
1128 }
1129 XEN_FRONT_RING_INIT(&info->conn_ring, conn_sring, PAGE_SIZE);
1130
1131 err = xenbus_alloc_evtchn(dev, &info->evtchn);
1132 if (err) {
1133 xenbus_dev_fatal(dev, err, "xenbus_alloc_evtchn");
1134 goto fail;
1135 }
1136
1137 err = bind_evtchn_to_irq_lateeoi(info->evtchn);
1138 if (err <= 0) {
1139 xenbus_dev_fatal(dev, err, "bind_evtchn_to_irq_lateeoi");
1140 goto fail;
1141 }
1142
1143 info->irq = err;
1144
1145 err = request_threaded_irq(info->irq, NULL, xenhcd_int,
1146 IRQF_ONESHOT, "xenhcd", info);
1147 if (err) {
1148 xenbus_dev_fatal(dev, err, "request_threaded_irq");
1149 goto free_irq;
1150 }
1151
1152 return 0;
1153
1154free_irq:
1155 unbind_from_irqhandler(info->irq, info);
1156fail:
1157 xenhcd_destroy_rings(info);
1158 return err;
1159}
1160
1161static int xenhcd_talk_to_backend(struct xenbus_device *dev,
1162 struct xenhcd_info *info)
1163{
1164 const char *message;
1165 struct xenbus_transaction xbt;
1166 int err;
1167
1168 err = xenhcd_setup_rings(dev, info);
1169 if (err)
1170 return err;
1171
1172again:
1173 err = xenbus_transaction_start(&xbt);
1174 if (err) {
1175 xenbus_dev_fatal(dev, err, "starting transaction");
1176 goto destroy_ring;
1177 }
1178
1179 err = xenbus_printf(xbt, dev->nodename, "urb-ring-ref", "%u",
1180 info->urb_ring_ref);
1181 if (err) {
1182 message = "writing urb-ring-ref";
1183 goto abort_transaction;
1184 }
1185
1186 err = xenbus_printf(xbt, dev->nodename, "conn-ring-ref", "%u",
1187 info->conn_ring_ref);
1188 if (err) {
1189 message = "writing conn-ring-ref";
1190 goto abort_transaction;
1191 }
1192
1193 err = xenbus_printf(xbt, dev->nodename, "event-channel", "%u",
1194 info->evtchn);
1195 if (err) {
1196 message = "writing event-channel";
1197 goto abort_transaction;
1198 }
1199
1200 err = xenbus_transaction_end(xbt, 0);
1201 if (err) {
1202 if (err == -EAGAIN)
1203 goto again;
1204 xenbus_dev_fatal(dev, err, "completing transaction");
1205 goto destroy_ring;
1206 }
1207
1208 return 0;
1209
1210abort_transaction:
1211 xenbus_transaction_end(xbt, 1);
1212 xenbus_dev_fatal(dev, err, "%s", message);
1213
1214destroy_ring:
1215 xenhcd_destroy_rings(info);
1216
1217 return err;
1218}
1219
1220static int xenhcd_connect(struct xenbus_device *dev)
1221{
1222 struct xenhcd_info *info = dev_get_drvdata(&dev->dev);
1223 struct xenusb_conn_request *req;
1224 int idx, err;
1225 int notify;
1226 char name[TASK_COMM_LEN];
1227 struct usb_hcd *hcd;
1228
1229 hcd = xenhcd_info_to_hcd(info);
1230 snprintf(name, TASK_COMM_LEN, "xenhcd.%d", hcd->self.busnum);
1231
1232 err = xenhcd_talk_to_backend(dev, info);
1233 if (err)
1234 return err;
1235
1236 /* prepare ring for hotplug notification */
1237 for (idx = 0; idx < XENUSB_CONN_RING_SIZE; idx++) {
1238 req = RING_GET_REQUEST(&info->conn_ring, idx);
1239 req->id = idx;
1240 }
1241 info->conn_ring.req_prod_pvt = idx;
1242
1243 RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&info->conn_ring, notify);
1244 if (notify)
1245 notify_remote_via_irq(info->irq);
1246
1247 return 0;
1248}
1249
1250static void xenhcd_disconnect(struct xenbus_device *dev)
1251{
1252 struct xenhcd_info *info = dev_get_drvdata(&dev->dev);
1253 struct usb_hcd *hcd = xenhcd_info_to_hcd(info);
1254
1255 usb_remove_hcd(hcd);
1256 xenbus_frontend_closed(dev);
1257}
1258
1259static void xenhcd_watchdog(struct timer_list *timer)
1260{
1261 struct xenhcd_info *info = from_timer(info, timer, watchdog);
1262 unsigned long flags;
1263
1264 spin_lock_irqsave(&info->lock, flags);
1265 if (likely(HC_IS_RUNNING(xenhcd_info_to_hcd(info)->state))) {
1266 xenhcd_timer_action_done(info, TIMER_RING_WATCHDOG);
1267 xenhcd_giveback_unlinked_urbs(info);
1268 xenhcd_kick_pending_urbs(info);
1269 }
1270 spin_unlock_irqrestore(&info->lock, flags);
1271}
1272
1273/*
1274 * one-time HC init
1275 */
1276static int xenhcd_setup(struct usb_hcd *hcd)
1277{
1278 struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
1279
1280 spin_lock_init(&info->lock);
1281 INIT_LIST_HEAD(&info->pending_submit_list);
1282 INIT_LIST_HEAD(&info->pending_unlink_list);
1283 INIT_LIST_HEAD(&info->in_progress_list);
1284 INIT_LIST_HEAD(&info->giveback_waiting_list);
1285 timer_setup(&info->watchdog, xenhcd_watchdog, 0);
1286
1287 hcd->has_tt = (hcd->driver->flags & HCD_MASK) != HCD_USB11;
1288
1289 return 0;
1290}
1291
1292/*
1293 * start HC running
1294 */
1295static int xenhcd_run(struct usb_hcd *hcd)
1296{
1297 hcd->uses_new_polling = 1;
1298 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
1299 hcd->state = HC_STATE_RUNNING;
1300 return 0;
1301}
1302
1303/*
1304 * stop running HC
1305 */
1306static void xenhcd_stop(struct usb_hcd *hcd)
1307{
1308 struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
1309
1310 del_timer_sync(&info->watchdog);
1311 spin_lock_irq(&info->lock);
1312 /* cancel all urbs */
1313 hcd->state = HC_STATE_HALT;
1314 xenhcd_cancel_all_enqueued_urbs(info);
1315 xenhcd_giveback_unlinked_urbs(info);
1316 spin_unlock_irq(&info->lock);
1317}
1318
1319/*
1320 * called as .urb_enqueue()
1321 * non-error returns are promise to giveback the urb later
1322 */
1323static int xenhcd_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
1324 gfp_t mem_flags)
1325{
1326 struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
1327 struct urb_priv *urbp;
1328 unsigned long flags;
1329 int ret;
1330
1331 if (unlikely(info->error))
1332 return -ESHUTDOWN;
1333
1334 urbp = kmem_cache_zalloc(xenhcd_urbp_cachep, mem_flags);
1335 if (!urbp)
1336 return -ENOMEM;
1337
1338 spin_lock_irqsave(&info->lock, flags);
1339
1340 urbp->urb = urb;
1341 urb->hcpriv = urbp;
1342 urbp->req_id = ~0;
1343 urbp->unlink_req_id = ~0;
1344 INIT_LIST_HEAD(&urbp->list);
1345 urbp->status = 1;
1346 urb->unlinked = false;
1347
1348 ret = xenhcd_submit_urb(info, urbp);
1349
1350 if (ret)
1351 xenhcd_free_urb_priv(urbp);
1352
1353 spin_unlock_irqrestore(&info->lock, flags);
1354
1355 return ret;
1356}
1357
1358/*
1359 * called as .urb_dequeue()
1360 */
1361static int xenhcd_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1362{
1363 struct xenhcd_info *info = xenhcd_hcd_to_info(hcd);
1364 struct urb_priv *urbp;
1365 unsigned long flags;
1366 int ret = 0;
1367
1368 spin_lock_irqsave(&info->lock, flags);
1369
1370 urbp = urb->hcpriv;
1371 if (urbp) {
1372 urbp->status = status;
1373 ret = xenhcd_unlink_urb(info, urbp);
1374 }
1375
1376 spin_unlock_irqrestore(&info->lock, flags);
1377
1378 return ret;
1379}
1380
1381/*
1382 * called from usb_get_current_frame_number(),
1383 * but, almost all drivers not use such function.
1384 */
1385static int xenhcd_get_frame(struct usb_hcd *hcd)
1386{
1387 /* it means error, but probably no problem :-) */
1388 return 0;
1389}
1390
1391static struct hc_driver xenhcd_usb20_hc_driver = {
1392 .description = "xen-hcd",
1393 .product_desc = "Xen USB2.0 Virtual Host Controller",
1394 .hcd_priv_size = sizeof(struct xenhcd_info),
1395 .flags = HCD_USB2,
1396
1397 /* basic HC lifecycle operations */
1398 .reset = xenhcd_setup,
1399 .start = xenhcd_run,
1400 .stop = xenhcd_stop,
1401
1402 /* managing urb I/O */
1403 .urb_enqueue = xenhcd_urb_enqueue,
1404 .urb_dequeue = xenhcd_urb_dequeue,
1405 .get_frame_number = xenhcd_get_frame,
1406
1407 /* root hub operations */
1408 .hub_status_data = xenhcd_hub_status_data,
1409 .hub_control = xenhcd_hub_control,
1410#ifdef CONFIG_PM
1411 .bus_suspend = xenhcd_bus_suspend,
1412 .bus_resume = xenhcd_bus_resume,
1413#endif
1414};
1415
1416static struct hc_driver xenhcd_usb11_hc_driver = {
1417 .description = "xen-hcd",
1418 .product_desc = "Xen USB1.1 Virtual Host Controller",
1419 .hcd_priv_size = sizeof(struct xenhcd_info),
1420 .flags = HCD_USB11,
1421
1422 /* basic HC lifecycle operations */
1423 .reset = xenhcd_setup,
1424 .start = xenhcd_run,
1425 .stop = xenhcd_stop,
1426
1427 /* managing urb I/O */
1428 .urb_enqueue = xenhcd_urb_enqueue,
1429 .urb_dequeue = xenhcd_urb_dequeue,
1430 .get_frame_number = xenhcd_get_frame,
1431
1432 /* root hub operations */
1433 .hub_status_data = xenhcd_hub_status_data,
1434 .hub_control = xenhcd_hub_control,
1435#ifdef CONFIG_PM
1436 .bus_suspend = xenhcd_bus_suspend,
1437 .bus_resume = xenhcd_bus_resume,
1438#endif
1439};
1440
1441static struct usb_hcd *xenhcd_create_hcd(struct xenbus_device *dev)
1442{
1443 int i;
1444 int err = 0;
1445 int num_ports;
1446 int usb_ver;
1447 struct usb_hcd *hcd = NULL;
1448 struct xenhcd_info *info;
1449
1450 err = xenbus_scanf(XBT_NIL, dev->otherend, "num-ports", "%d",
1451 &num_ports);
1452 if (err != 1) {
1453 xenbus_dev_fatal(dev, err, "reading num-ports");
1454 return ERR_PTR(-EINVAL);
1455 }
1456 if (num_ports < 1 || num_ports > XENUSB_MAX_PORTNR) {
1457 xenbus_dev_fatal(dev, err, "invalid num-ports");
1458 return ERR_PTR(-EINVAL);
1459 }
1460
1461 err = xenbus_scanf(XBT_NIL, dev->otherend, "usb-ver", "%d", &usb_ver);
1462 if (err != 1) {
1463 xenbus_dev_fatal(dev, err, "reading usb-ver");
1464 return ERR_PTR(-EINVAL);
1465 }
1466 switch (usb_ver) {
1467 case XENUSB_VER_USB11:
1468 hcd = usb_create_hcd(&xenhcd_usb11_hc_driver, &dev->dev,
1469 dev_name(&dev->dev));
1470 break;
1471 case XENUSB_VER_USB20:
1472 hcd = usb_create_hcd(&xenhcd_usb20_hc_driver, &dev->dev,
1473 dev_name(&dev->dev));
1474 break;
1475 default:
1476 xenbus_dev_fatal(dev, err, "invalid usb-ver");
1477 return ERR_PTR(-EINVAL);
1478 }
1479 if (!hcd) {
1480 xenbus_dev_fatal(dev, err,
1481 "fail to allocate USB host controller");
1482 return ERR_PTR(-ENOMEM);
1483 }
1484
1485 info = xenhcd_hcd_to_info(hcd);
1486 info->xbdev = dev;
1487 info->rh_numports = num_ports;
1488
1489 for (i = 0; i < XENUSB_URB_RING_SIZE; i++) {
1490 info->shadow[i].req.id = i + 1;
1491 info->shadow[i].urb = NULL;
1492 info->shadow[i].in_flight = false;
1493 }
1494 info->shadow[XENUSB_URB_RING_SIZE - 1].req.id = 0x0fff;
1495
1496 return hcd;
1497}
1498
1499static void xenhcd_backend_changed(struct xenbus_device *dev,
1500 enum xenbus_state backend_state)
1501{
1502 switch (backend_state) {
1503 case XenbusStateInitialising:
1504 case XenbusStateReconfiguring:
1505 case XenbusStateReconfigured:
1506 case XenbusStateUnknown:
1507 break;
1508
1509 case XenbusStateInitWait:
1510 case XenbusStateInitialised:
1511 case XenbusStateConnected:
1512 if (dev->state != XenbusStateInitialising)
1513 break;
1514 if (!xenhcd_connect(dev))
1515 xenbus_switch_state(dev, XenbusStateConnected);
1516 break;
1517
1518 case XenbusStateClosed:
1519 if (dev->state == XenbusStateClosed)
1520 break;
1521 fallthrough; /* Missed the backend's Closing state. */
1522 case XenbusStateClosing:
1523 xenhcd_disconnect(dev);
1524 break;
1525
1526 default:
1527 xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend",
1528 backend_state);
1529 break;
1530 }
1531}
1532
1533static void xenhcd_remove(struct xenbus_device *dev)
1534{
1535 struct xenhcd_info *info = dev_get_drvdata(&dev->dev);
1536 struct usb_hcd *hcd = xenhcd_info_to_hcd(info);
1537
1538 xenhcd_destroy_rings(info);
1539 usb_put_hcd(hcd);
1540}
1541
1542static int xenhcd_probe(struct xenbus_device *dev,
1543 const struct xenbus_device_id *id)
1544{
1545 int err;
1546 struct usb_hcd *hcd;
1547 struct xenhcd_info *info;
1548
1549 if (usb_disabled())
1550 return -ENODEV;
1551
1552 hcd = xenhcd_create_hcd(dev);
1553 if (IS_ERR(hcd)) {
1554 err = PTR_ERR(hcd);
1555 xenbus_dev_fatal(dev, err,
1556 "fail to create usb host controller");
1557 return err;
1558 }
1559
1560 info = xenhcd_hcd_to_info(hcd);
1561 dev_set_drvdata(&dev->dev, info);
1562
1563 err = usb_add_hcd(hcd, 0, 0);
1564 if (err) {
1565 xenbus_dev_fatal(dev, err, "fail to add USB host controller");
1566 usb_put_hcd(hcd);
1567 dev_set_drvdata(&dev->dev, NULL);
1568 }
1569
1570 return err;
1571}
1572
1573static const struct xenbus_device_id xenhcd_ids[] = {
1574 { "vusb" },
1575 { "" },
1576};
1577
1578static struct xenbus_driver xenhcd_driver = {
1579 .ids = xenhcd_ids,
1580 .probe = xenhcd_probe,
1581 .otherend_changed = xenhcd_backend_changed,
1582 .remove = xenhcd_remove,
1583};
1584
1585static int __init xenhcd_init(void)
1586{
1587 if (!xen_domain())
1588 return -ENODEV;
1589
1590 xenhcd_urbp_cachep = kmem_cache_create("xenhcd_urb_priv",
1591 sizeof(struct urb_priv), 0, 0, NULL);
1592 if (!xenhcd_urbp_cachep) {
1593 pr_err("xenhcd failed to create kmem cache\n");
1594 return -ENOMEM;
1595 }
1596
1597 return xenbus_register_frontend(&xenhcd_driver);
1598}
1599module_init(xenhcd_init);
1600
1601static void __exit xenhcd_exit(void)
1602{
1603 kmem_cache_destroy(xenhcd_urbp_cachep);
1604 xenbus_unregister_driver(&xenhcd_driver);
1605}
1606module_exit(xenhcd_exit);
1607
1608MODULE_ALIAS("xen:vusb");
1609MODULE_AUTHOR("Juergen Gross <jgross@suse.com>");
1610MODULE_DESCRIPTION("Xen USB Virtual Host Controller driver (xen-hcd)");
1611MODULE_LICENSE("Dual BSD/GPL");