1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * Copyright (C) 2003-2008 Takahiro Hirofuchi |
4 | * Copyright (C) 2015-2016 Nobuo Iwata |
5 | */ |
6 | |
7 | #include <linux/init.h> |
8 | #include <linux/file.h> |
9 | #include <linux/kernel.h> |
10 | #include <linux/kthread.h> |
11 | #include <linux/module.h> |
12 | #include <linux/platform_device.h> |
13 | #include <linux/slab.h> |
14 | |
15 | #include "usbip_common.h" |
16 | #include "vhci.h" |
17 | |
18 | #define DRIVER_AUTHOR "Takahiro Hirofuchi" |
19 | #define DRIVER_DESC "USB/IP 'Virtual' Host Controller (VHCI) Driver" |
20 | |
21 | /* |
22 | * TODO |
23 | * - update root hub emulation |
24 | * - move the emulation code to userland ? |
25 | * porting to other operating systems |
26 | * minimize kernel code |
27 | * - add suspend/resume code |
28 | * - clean up everything |
29 | */ |
30 | |
31 | /* See usb gadget dummy hcd */ |
32 | |
33 | static int vhci_hub_status(struct usb_hcd *hcd, char *buff); |
34 | static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, |
35 | u16 wIndex, char *buff, u16 wLength); |
36 | static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, |
37 | gfp_t mem_flags); |
38 | static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status); |
39 | static int vhci_start(struct usb_hcd *vhci_hcd); |
40 | static void vhci_stop(struct usb_hcd *hcd); |
41 | static int vhci_get_frame_number(struct usb_hcd *hcd); |
42 | |
43 | static const char driver_name[] = "vhci_hcd" ; |
44 | static const char driver_desc[] = "USB/IP Virtual Host Controller" ; |
45 | |
46 | int vhci_num_controllers = VHCI_NR_HCS; |
47 | struct vhci *vhcis; |
48 | |
49 | static const char * const bit_desc[] = { |
50 | "CONNECTION" , /*0*/ |
51 | "ENABLE" , /*1*/ |
52 | "SUSPEND" , /*2*/ |
53 | "OVER_CURRENT" , /*3*/ |
54 | "RESET" , /*4*/ |
55 | "L1" , /*5*/ |
56 | "R6" , /*6*/ |
57 | "R7" , /*7*/ |
58 | "POWER" , /*8*/ |
59 | "LOWSPEED" , /*9*/ |
60 | "HIGHSPEED" , /*10*/ |
61 | "PORT_TEST" , /*11*/ |
62 | "INDICATOR" , /*12*/ |
63 | "R13" , /*13*/ |
64 | "R14" , /*14*/ |
65 | "R15" , /*15*/ |
66 | "C_CONNECTION" , /*16*/ |
67 | "C_ENABLE" , /*17*/ |
68 | "C_SUSPEND" , /*18*/ |
69 | "C_OVER_CURRENT" , /*19*/ |
70 | "C_RESET" , /*20*/ |
71 | "C_L1" , /*21*/ |
72 | "R22" , /*22*/ |
73 | "R23" , /*23*/ |
74 | "R24" , /*24*/ |
75 | "R25" , /*25*/ |
76 | "R26" , /*26*/ |
77 | "R27" , /*27*/ |
78 | "R28" , /*28*/ |
79 | "R29" , /*29*/ |
80 | "R30" , /*30*/ |
81 | "R31" , /*31*/ |
82 | }; |
83 | |
84 | static const char * const bit_desc_ss[] = { |
85 | "CONNECTION" , /*0*/ |
86 | "ENABLE" , /*1*/ |
87 | "SUSPEND" , /*2*/ |
88 | "OVER_CURRENT" , /*3*/ |
89 | "RESET" , /*4*/ |
90 | "L1" , /*5*/ |
91 | "R6" , /*6*/ |
92 | "R7" , /*7*/ |
93 | "R8" , /*8*/ |
94 | "POWER" , /*9*/ |
95 | "HIGHSPEED" , /*10*/ |
96 | "PORT_TEST" , /*11*/ |
97 | "INDICATOR" , /*12*/ |
98 | "R13" , /*13*/ |
99 | "R14" , /*14*/ |
100 | "R15" , /*15*/ |
101 | "C_CONNECTION" , /*16*/ |
102 | "C_ENABLE" , /*17*/ |
103 | "C_SUSPEND" , /*18*/ |
104 | "C_OVER_CURRENT" , /*19*/ |
105 | "C_RESET" , /*20*/ |
106 | "C_BH_RESET" , /*21*/ |
107 | "C_LINK_STATE" , /*22*/ |
108 | "C_CONFIG_ERROR" , /*23*/ |
109 | "R24" , /*24*/ |
110 | "R25" , /*25*/ |
111 | "R26" , /*26*/ |
112 | "R27" , /*27*/ |
113 | "R28" , /*28*/ |
114 | "R29" , /*29*/ |
115 | "R30" , /*30*/ |
116 | "R31" , /*31*/ |
117 | }; |
118 | |
119 | static void dump_port_status_diff(u32 prev_status, u32 new_status, bool usb3) |
120 | { |
121 | int i = 0; |
122 | u32 bit = 1; |
123 | const char * const *desc = bit_desc; |
124 | |
125 | if (usb3) |
126 | desc = bit_desc_ss; |
127 | |
128 | pr_debug("status prev -> new: %08x -> %08x\n" , prev_status, new_status); |
129 | while (bit) { |
130 | u32 prev = prev_status & bit; |
131 | u32 new = new_status & bit; |
132 | char change; |
133 | |
134 | if (!prev && new) |
135 | change = '+'; |
136 | else if (prev && !new) |
137 | change = '-'; |
138 | else |
139 | change = ' '; |
140 | |
141 | if (prev || new) { |
142 | pr_debug(" %c%s\n" , change, desc[i]); |
143 | |
144 | if (bit == 1) /* USB_PORT_STAT_CONNECTION */ |
145 | pr_debug(" %c%s\n" , change, "USB_PORT_STAT_SPEED_5GBPS" ); |
146 | } |
147 | bit <<= 1; |
148 | i++; |
149 | } |
150 | pr_debug("\n" ); |
151 | } |
152 | |
153 | void rh_port_connect(struct vhci_device *vdev, enum usb_device_speed speed) |
154 | { |
155 | struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev); |
156 | struct vhci *vhci = vhci_hcd->vhci; |
157 | int rhport = vdev->rhport; |
158 | u32 status; |
159 | unsigned long flags; |
160 | |
161 | usbip_dbg_vhci_rh("rh_port_connect %d\n" , rhport); |
162 | |
163 | spin_lock_irqsave(&vhci->lock, flags); |
164 | |
165 | status = vhci_hcd->port_status[rhport]; |
166 | |
167 | status |= USB_PORT_STAT_CONNECTION | (1 << USB_PORT_FEAT_C_CONNECTION); |
168 | |
169 | switch (speed) { |
170 | case USB_SPEED_HIGH: |
171 | status |= USB_PORT_STAT_HIGH_SPEED; |
172 | break; |
173 | case USB_SPEED_LOW: |
174 | status |= USB_PORT_STAT_LOW_SPEED; |
175 | break; |
176 | default: |
177 | break; |
178 | } |
179 | |
180 | vhci_hcd->port_status[rhport] = status; |
181 | |
182 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
183 | |
184 | usb_hcd_poll_rh_status(hcd: vhci_hcd_to_hcd(vhci_hcd)); |
185 | } |
186 | |
187 | static void rh_port_disconnect(struct vhci_device *vdev) |
188 | { |
189 | struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev); |
190 | struct vhci *vhci = vhci_hcd->vhci; |
191 | int rhport = vdev->rhport; |
192 | u32 status; |
193 | unsigned long flags; |
194 | |
195 | usbip_dbg_vhci_rh("rh_port_disconnect %d\n" , rhport); |
196 | |
197 | spin_lock_irqsave(&vhci->lock, flags); |
198 | |
199 | status = vhci_hcd->port_status[rhport]; |
200 | |
201 | status &= ~USB_PORT_STAT_CONNECTION; |
202 | status |= (1 << USB_PORT_FEAT_C_CONNECTION); |
203 | |
204 | vhci_hcd->port_status[rhport] = status; |
205 | |
206 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
207 | usb_hcd_poll_rh_status(hcd: vhci_hcd_to_hcd(vhci_hcd)); |
208 | } |
209 | |
210 | #define PORT_C_MASK \ |
211 | ((USB_PORT_STAT_C_CONNECTION \ |
212 | | USB_PORT_STAT_C_ENABLE \ |
213 | | USB_PORT_STAT_C_SUSPEND \ |
214 | | USB_PORT_STAT_C_OVERCURRENT \ |
215 | | USB_PORT_STAT_C_RESET) << 16) |
216 | |
217 | /* |
218 | * Returns 0 if the status hasn't changed, or the number of bytes in buf. |
219 | * Ports are 0-indexed from the HCD point of view, |
220 | * and 1-indexed from the USB core pointer of view. |
221 | * |
222 | * @buf: a bitmap to show which port status has been changed. |
223 | * bit 0: reserved |
224 | * bit 1: the status of port 0 has been changed. |
225 | * bit 2: the status of port 1 has been changed. |
226 | * ... |
227 | */ |
228 | static int vhci_hub_status(struct usb_hcd *hcd, char *buf) |
229 | { |
230 | struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd); |
231 | struct vhci *vhci = vhci_hcd->vhci; |
232 | int retval = DIV_ROUND_UP(VHCI_HC_PORTS + 1, 8); |
233 | int rhport; |
234 | int changed = 0; |
235 | unsigned long flags; |
236 | |
237 | memset(buf, 0, retval); |
238 | |
239 | spin_lock_irqsave(&vhci->lock, flags); |
240 | if (!HCD_HW_ACCESSIBLE(hcd)) { |
241 | usbip_dbg_vhci_rh("hw accessible flag not on?\n" ); |
242 | goto done; |
243 | } |
244 | |
245 | /* check pseudo status register for each port */ |
246 | for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) { |
247 | if ((vhci_hcd->port_status[rhport] & PORT_C_MASK)) { |
248 | /* The status of a port has been changed, */ |
249 | usbip_dbg_vhci_rh("port %d status changed\n" , rhport); |
250 | |
251 | buf[(rhport + 1) / 8] |= 1 << (rhport + 1) % 8; |
252 | changed = 1; |
253 | } |
254 | } |
255 | |
256 | if ((hcd->state == HC_STATE_SUSPENDED) && (changed == 1)) |
257 | usb_hcd_resume_root_hub(hcd); |
258 | |
259 | done: |
260 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
261 | return changed ? retval : 0; |
262 | } |
263 | |
264 | /* usb 3.0 root hub device descriptor */ |
265 | static struct { |
266 | struct usb_bos_descriptor bos; |
267 | struct usb_ss_cap_descriptor ss_cap; |
268 | } __packed usb3_bos_desc = { |
269 | |
270 | .bos = { |
271 | .bLength = USB_DT_BOS_SIZE, |
272 | .bDescriptorType = USB_DT_BOS, |
273 | .wTotalLength = cpu_to_le16(sizeof(usb3_bos_desc)), |
274 | .bNumDeviceCaps = 1, |
275 | }, |
276 | .ss_cap = { |
277 | .bLength = USB_DT_USB_SS_CAP_SIZE, |
278 | .bDescriptorType = USB_DT_DEVICE_CAPABILITY, |
279 | .bDevCapabilityType = USB_SS_CAP_TYPE, |
280 | .wSpeedSupported = cpu_to_le16(USB_5GBPS_OPERATION), |
281 | .bFunctionalitySupport = ilog2(USB_5GBPS_OPERATION), |
282 | }, |
283 | }; |
284 | |
285 | static inline void |
286 | ss_hub_descriptor(struct usb_hub_descriptor *desc) |
287 | { |
288 | memset(desc, 0, sizeof *desc); |
289 | desc->bDescriptorType = USB_DT_SS_HUB; |
290 | desc->bDescLength = 12; |
291 | desc->wHubCharacteristics = cpu_to_le16( |
292 | HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_COMMON_OCPM); |
293 | desc->bNbrPorts = VHCI_HC_PORTS; |
294 | desc->u.ss.bHubHdrDecLat = 0x04; /* Worst case: 0.4 micro sec*/ |
295 | desc->u.ss.DeviceRemovable = 0xffff; |
296 | } |
297 | |
298 | static inline void hub_descriptor(struct usb_hub_descriptor *desc) |
299 | { |
300 | int width; |
301 | |
302 | memset(desc, 0, sizeof(*desc)); |
303 | desc->bDescriptorType = USB_DT_HUB; |
304 | desc->wHubCharacteristics = cpu_to_le16( |
305 | HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_COMMON_OCPM); |
306 | |
307 | desc->bNbrPorts = VHCI_HC_PORTS; |
308 | BUILD_BUG_ON(VHCI_HC_PORTS > USB_MAXCHILDREN); |
309 | width = desc->bNbrPorts / 8 + 1; |
310 | desc->bDescLength = USB_DT_HUB_NONVAR_SIZE + 2 * width; |
311 | memset(&desc->u.hs.DeviceRemovable[0], 0, width); |
312 | memset(&desc->u.hs.DeviceRemovable[width], 0xff, width); |
313 | } |
314 | |
315 | static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, |
316 | u16 wIndex, char *buf, u16 wLength) |
317 | { |
318 | struct vhci_hcd *vhci_hcd; |
319 | struct vhci *vhci; |
320 | int retval = 0; |
321 | int rhport = -1; |
322 | unsigned long flags; |
323 | bool invalid_rhport = false; |
324 | |
325 | u32 prev_port_status[VHCI_HC_PORTS]; |
326 | |
327 | if (!HCD_HW_ACCESSIBLE(hcd)) |
328 | return -ETIMEDOUT; |
329 | |
330 | /* |
331 | * NOTE: |
332 | * wIndex (bits 0-7) shows the port number and begins from 1? |
333 | */ |
334 | wIndex = ((__u8)(wIndex & 0x00ff)); |
335 | usbip_dbg_vhci_rh("typeReq %x wValue %x wIndex %x\n" , typeReq, wValue, |
336 | wIndex); |
337 | |
338 | /* |
339 | * wIndex can be 0 for some request types (typeReq). rhport is |
340 | * in valid range when wIndex >= 1 and < VHCI_HC_PORTS. |
341 | * |
342 | * Reference port_status[] only with valid rhport when |
343 | * invalid_rhport is false. |
344 | */ |
345 | if (wIndex < 1 || wIndex > VHCI_HC_PORTS) { |
346 | invalid_rhport = true; |
347 | if (wIndex > VHCI_HC_PORTS) |
348 | pr_err("invalid port number %d\n" , wIndex); |
349 | } else |
350 | rhport = wIndex - 1; |
351 | |
352 | vhci_hcd = hcd_to_vhci_hcd(hcd); |
353 | vhci = vhci_hcd->vhci; |
354 | |
355 | spin_lock_irqsave(&vhci->lock, flags); |
356 | |
357 | /* store old status and compare now and old later */ |
358 | if (usbip_dbg_flag_vhci_rh) { |
359 | if (!invalid_rhport) |
360 | memcpy(prev_port_status, vhci_hcd->port_status, |
361 | sizeof(prev_port_status)); |
362 | } |
363 | |
364 | switch (typeReq) { |
365 | case ClearHubFeature: |
366 | usbip_dbg_vhci_rh(" ClearHubFeature\n" ); |
367 | break; |
368 | case ClearPortFeature: |
369 | if (invalid_rhport) { |
370 | pr_err("invalid port number %d\n" , wIndex); |
371 | goto error; |
372 | } |
373 | switch (wValue) { |
374 | case USB_PORT_FEAT_SUSPEND: |
375 | if (hcd->speed == HCD_USB3) { |
376 | pr_err(" ClearPortFeature: USB_PORT_FEAT_SUSPEND req not " |
377 | "supported for USB 3.0 roothub\n" ); |
378 | goto error; |
379 | } |
380 | usbip_dbg_vhci_rh( |
381 | " ClearPortFeature: USB_PORT_FEAT_SUSPEND\n" ); |
382 | if (vhci_hcd->port_status[rhport] & USB_PORT_STAT_SUSPEND) { |
383 | /* 20msec signaling */ |
384 | vhci_hcd->resuming = 1; |
385 | vhci_hcd->re_timeout = jiffies + msecs_to_jiffies(m: 20); |
386 | } |
387 | break; |
388 | case USB_PORT_FEAT_POWER: |
389 | usbip_dbg_vhci_rh( |
390 | " ClearPortFeature: USB_PORT_FEAT_POWER\n" ); |
391 | if (hcd->speed == HCD_USB3) |
392 | vhci_hcd->port_status[rhport] &= ~USB_SS_PORT_STAT_POWER; |
393 | else |
394 | vhci_hcd->port_status[rhport] &= ~USB_PORT_STAT_POWER; |
395 | break; |
396 | default: |
397 | usbip_dbg_vhci_rh(" ClearPortFeature: default %x\n" , |
398 | wValue); |
399 | if (wValue >= 32) |
400 | goto error; |
401 | vhci_hcd->port_status[rhport] &= ~(1 << wValue); |
402 | break; |
403 | } |
404 | break; |
405 | case GetHubDescriptor: |
406 | usbip_dbg_vhci_rh(" GetHubDescriptor\n" ); |
407 | if (hcd->speed == HCD_USB3 && |
408 | (wLength < USB_DT_SS_HUB_SIZE || |
409 | wValue != (USB_DT_SS_HUB << 8))) { |
410 | pr_err("Wrong hub descriptor type for USB 3.0 roothub.\n" ); |
411 | goto error; |
412 | } |
413 | if (hcd->speed == HCD_USB3) |
414 | ss_hub_descriptor(desc: (struct usb_hub_descriptor *) buf); |
415 | else |
416 | hub_descriptor(desc: (struct usb_hub_descriptor *) buf); |
417 | break; |
418 | case DeviceRequest | USB_REQ_GET_DESCRIPTOR: |
419 | if (hcd->speed != HCD_USB3) |
420 | goto error; |
421 | |
422 | if ((wValue >> 8) != USB_DT_BOS) |
423 | goto error; |
424 | |
425 | memcpy(buf, &usb3_bos_desc, sizeof(usb3_bos_desc)); |
426 | retval = sizeof(usb3_bos_desc); |
427 | break; |
428 | case GetHubStatus: |
429 | usbip_dbg_vhci_rh(" GetHubStatus\n" ); |
430 | *(__le32 *) buf = cpu_to_le32(0); |
431 | break; |
432 | case GetPortStatus: |
433 | usbip_dbg_vhci_rh(" GetPortStatus port %x\n" , wIndex); |
434 | if (invalid_rhport) { |
435 | pr_err("invalid port number %d\n" , wIndex); |
436 | retval = -EPIPE; |
437 | goto error; |
438 | } |
439 | |
440 | /* we do not care about resume. */ |
441 | |
442 | /* whoever resets or resumes must GetPortStatus to |
443 | * complete it!! |
444 | */ |
445 | if (vhci_hcd->resuming && time_after(jiffies, vhci_hcd->re_timeout)) { |
446 | vhci_hcd->port_status[rhport] |= (1 << USB_PORT_FEAT_C_SUSPEND); |
447 | vhci_hcd->port_status[rhport] &= ~(1 << USB_PORT_FEAT_SUSPEND); |
448 | vhci_hcd->resuming = 0; |
449 | vhci_hcd->re_timeout = 0; |
450 | } |
451 | |
452 | if ((vhci_hcd->port_status[rhport] & (1 << USB_PORT_FEAT_RESET)) != |
453 | 0 && time_after(jiffies, vhci_hcd->re_timeout)) { |
454 | vhci_hcd->port_status[rhport] |= (1 << USB_PORT_FEAT_C_RESET); |
455 | vhci_hcd->port_status[rhport] &= ~(1 << USB_PORT_FEAT_RESET); |
456 | vhci_hcd->re_timeout = 0; |
457 | |
458 | /* |
459 | * A few drivers do usb reset during probe when |
460 | * the device could be in VDEV_ST_USED state |
461 | */ |
462 | if (vhci_hcd->vdev[rhport].ud.status == |
463 | VDEV_ST_NOTASSIGNED || |
464 | vhci_hcd->vdev[rhport].ud.status == |
465 | VDEV_ST_USED) { |
466 | usbip_dbg_vhci_rh( |
467 | " enable rhport %d (status %u)\n" , |
468 | rhport, |
469 | vhci_hcd->vdev[rhport].ud.status); |
470 | vhci_hcd->port_status[rhport] |= |
471 | USB_PORT_STAT_ENABLE; |
472 | } |
473 | |
474 | if (hcd->speed < HCD_USB3) { |
475 | switch (vhci_hcd->vdev[rhport].speed) { |
476 | case USB_SPEED_HIGH: |
477 | vhci_hcd->port_status[rhport] |= |
478 | USB_PORT_STAT_HIGH_SPEED; |
479 | break; |
480 | case USB_SPEED_LOW: |
481 | vhci_hcd->port_status[rhport] |= |
482 | USB_PORT_STAT_LOW_SPEED; |
483 | break; |
484 | default: |
485 | pr_err("vhci_device speed not set\n" ); |
486 | break; |
487 | } |
488 | } |
489 | } |
490 | ((__le16 *) buf)[0] = cpu_to_le16(vhci_hcd->port_status[rhport]); |
491 | ((__le16 *) buf)[1] = |
492 | cpu_to_le16(vhci_hcd->port_status[rhport] >> 16); |
493 | |
494 | usbip_dbg_vhci_rh(" GetPortStatus bye %x %x\n" , ((u16 *)buf)[0], |
495 | ((u16 *)buf)[1]); |
496 | break; |
497 | case SetHubFeature: |
498 | usbip_dbg_vhci_rh(" SetHubFeature\n" ); |
499 | retval = -EPIPE; |
500 | break; |
501 | case SetPortFeature: |
502 | switch (wValue) { |
503 | case USB_PORT_FEAT_LINK_STATE: |
504 | usbip_dbg_vhci_rh( |
505 | " SetPortFeature: USB_PORT_FEAT_LINK_STATE\n" ); |
506 | if (hcd->speed != HCD_USB3) { |
507 | pr_err("USB_PORT_FEAT_LINK_STATE req not " |
508 | "supported for USB 2.0 roothub\n" ); |
509 | goto error; |
510 | } |
511 | /* |
512 | * Since this is dummy we don't have an actual link so |
513 | * there is nothing to do for the SET_LINK_STATE cmd |
514 | */ |
515 | break; |
516 | case USB_PORT_FEAT_U1_TIMEOUT: |
517 | usbip_dbg_vhci_rh( |
518 | " SetPortFeature: USB_PORT_FEAT_U1_TIMEOUT\n" ); |
519 | fallthrough; |
520 | case USB_PORT_FEAT_U2_TIMEOUT: |
521 | usbip_dbg_vhci_rh( |
522 | " SetPortFeature: USB_PORT_FEAT_U2_TIMEOUT\n" ); |
523 | /* TODO: add suspend/resume support! */ |
524 | if (hcd->speed != HCD_USB3) { |
525 | pr_err("USB_PORT_FEAT_U1/2_TIMEOUT req not " |
526 | "supported for USB 2.0 roothub\n" ); |
527 | goto error; |
528 | } |
529 | break; |
530 | case USB_PORT_FEAT_SUSPEND: |
531 | usbip_dbg_vhci_rh( |
532 | " SetPortFeature: USB_PORT_FEAT_SUSPEND\n" ); |
533 | /* Applicable only for USB2.0 hub */ |
534 | if (hcd->speed == HCD_USB3) { |
535 | pr_err("USB_PORT_FEAT_SUSPEND req not " |
536 | "supported for USB 3.0 roothub\n" ); |
537 | goto error; |
538 | } |
539 | |
540 | if (invalid_rhport) { |
541 | pr_err("invalid port number %d\n" , wIndex); |
542 | goto error; |
543 | } |
544 | |
545 | vhci_hcd->port_status[rhport] |= USB_PORT_STAT_SUSPEND; |
546 | break; |
547 | case USB_PORT_FEAT_POWER: |
548 | usbip_dbg_vhci_rh( |
549 | " SetPortFeature: USB_PORT_FEAT_POWER\n" ); |
550 | if (invalid_rhport) { |
551 | pr_err("invalid port number %d\n" , wIndex); |
552 | goto error; |
553 | } |
554 | if (hcd->speed == HCD_USB3) |
555 | vhci_hcd->port_status[rhport] |= USB_SS_PORT_STAT_POWER; |
556 | else |
557 | vhci_hcd->port_status[rhport] |= USB_PORT_STAT_POWER; |
558 | break; |
559 | case USB_PORT_FEAT_BH_PORT_RESET: |
560 | usbip_dbg_vhci_rh( |
561 | " SetPortFeature: USB_PORT_FEAT_BH_PORT_RESET\n" ); |
562 | if (invalid_rhport) { |
563 | pr_err("invalid port number %d\n" , wIndex); |
564 | goto error; |
565 | } |
566 | /* Applicable only for USB3.0 hub */ |
567 | if (hcd->speed != HCD_USB3) { |
568 | pr_err("USB_PORT_FEAT_BH_PORT_RESET req not " |
569 | "supported for USB 2.0 roothub\n" ); |
570 | goto error; |
571 | } |
572 | fallthrough; |
573 | case USB_PORT_FEAT_RESET: |
574 | usbip_dbg_vhci_rh( |
575 | " SetPortFeature: USB_PORT_FEAT_RESET\n" ); |
576 | if (invalid_rhport) { |
577 | pr_err("invalid port number %d\n" , wIndex); |
578 | goto error; |
579 | } |
580 | /* if it's already enabled, disable */ |
581 | if (hcd->speed == HCD_USB3) { |
582 | vhci_hcd->port_status[rhport] = 0; |
583 | vhci_hcd->port_status[rhport] = |
584 | (USB_SS_PORT_STAT_POWER | |
585 | USB_PORT_STAT_CONNECTION | |
586 | USB_PORT_STAT_RESET); |
587 | } else if (vhci_hcd->port_status[rhport] & USB_PORT_STAT_ENABLE) { |
588 | vhci_hcd->port_status[rhport] &= ~(USB_PORT_STAT_ENABLE |
589 | | USB_PORT_STAT_LOW_SPEED |
590 | | USB_PORT_STAT_HIGH_SPEED); |
591 | } |
592 | |
593 | /* 50msec reset signaling */ |
594 | vhci_hcd->re_timeout = jiffies + msecs_to_jiffies(m: 50); |
595 | fallthrough; |
596 | default: |
597 | usbip_dbg_vhci_rh(" SetPortFeature: default %d\n" , |
598 | wValue); |
599 | if (invalid_rhport) { |
600 | pr_err("invalid port number %d\n" , wIndex); |
601 | goto error; |
602 | } |
603 | if (wValue >= 32) |
604 | goto error; |
605 | if (hcd->speed == HCD_USB3) { |
606 | if ((vhci_hcd->port_status[rhport] & |
607 | USB_SS_PORT_STAT_POWER) != 0) { |
608 | vhci_hcd->port_status[rhport] |= (1 << wValue); |
609 | } |
610 | } else |
611 | if ((vhci_hcd->port_status[rhport] & |
612 | USB_PORT_STAT_POWER) != 0) { |
613 | vhci_hcd->port_status[rhport] |= (1 << wValue); |
614 | } |
615 | } |
616 | break; |
617 | case GetPortErrorCount: |
618 | usbip_dbg_vhci_rh(" GetPortErrorCount\n" ); |
619 | if (hcd->speed != HCD_USB3) { |
620 | pr_err("GetPortErrorCount req not " |
621 | "supported for USB 2.0 roothub\n" ); |
622 | goto error; |
623 | } |
624 | /* We'll always return 0 since this is a dummy hub */ |
625 | *(__le32 *) buf = cpu_to_le32(0); |
626 | break; |
627 | case SetHubDepth: |
628 | usbip_dbg_vhci_rh(" SetHubDepth\n" ); |
629 | if (hcd->speed != HCD_USB3) { |
630 | pr_err("SetHubDepth req not supported for " |
631 | "USB 2.0 roothub\n" ); |
632 | goto error; |
633 | } |
634 | break; |
635 | default: |
636 | pr_err("default hub control req: %04x v%04x i%04x l%d\n" , |
637 | typeReq, wValue, wIndex, wLength); |
638 | error: |
639 | /* "protocol stall" on error */ |
640 | retval = -EPIPE; |
641 | } |
642 | |
643 | if (usbip_dbg_flag_vhci_rh) { |
644 | pr_debug("port %d\n" , rhport); |
645 | /* Only dump valid port status */ |
646 | if (!invalid_rhport) { |
647 | dump_port_status_diff(prev_status: prev_port_status[rhport], |
648 | new_status: vhci_hcd->port_status[rhport], |
649 | usb3: hcd->speed == HCD_USB3); |
650 | } |
651 | } |
652 | usbip_dbg_vhci_rh(" bye\n" ); |
653 | |
654 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
655 | |
656 | if (!invalid_rhport && |
657 | (vhci_hcd->port_status[rhport] & PORT_C_MASK) != 0) { |
658 | usb_hcd_poll_rh_status(hcd); |
659 | } |
660 | |
661 | return retval; |
662 | } |
663 | |
664 | static void vhci_tx_urb(struct urb *urb, struct vhci_device *vdev) |
665 | { |
666 | struct vhci_priv *priv; |
667 | struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev); |
668 | unsigned long flags; |
669 | |
670 | priv = kzalloc(size: sizeof(struct vhci_priv), GFP_ATOMIC); |
671 | if (!priv) { |
672 | usbip_event_add(ud: &vdev->ud, VDEV_EVENT_ERROR_MALLOC); |
673 | return; |
674 | } |
675 | |
676 | spin_lock_irqsave(&vdev->priv_lock, flags); |
677 | |
678 | priv->seqnum = atomic_inc_return(v: &vhci_hcd->seqnum); |
679 | if (priv->seqnum == 0xffff) |
680 | dev_info(&urb->dev->dev, "seqnum max\n" ); |
681 | |
682 | priv->vdev = vdev; |
683 | priv->urb = urb; |
684 | |
685 | urb->hcpriv = (void *) priv; |
686 | |
687 | list_add_tail(new: &priv->list, head: &vdev->priv_tx); |
688 | |
689 | wake_up(&vdev->waitq_tx); |
690 | spin_unlock_irqrestore(lock: &vdev->priv_lock, flags); |
691 | } |
692 | |
693 | static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags) |
694 | { |
695 | struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd); |
696 | struct vhci *vhci = vhci_hcd->vhci; |
697 | struct device *dev = &urb->dev->dev; |
698 | u8 portnum = urb->dev->portnum; |
699 | int ret = 0; |
700 | struct vhci_device *vdev; |
701 | unsigned long flags; |
702 | |
703 | if (portnum > VHCI_HC_PORTS) { |
704 | pr_err("invalid port number %d\n" , portnum); |
705 | return -ENODEV; |
706 | } |
707 | vdev = &vhci_hcd->vdev[portnum-1]; |
708 | |
709 | if (!urb->transfer_buffer && !urb->num_sgs && |
710 | urb->transfer_buffer_length) { |
711 | dev_dbg(dev, "Null URB transfer buffer\n" ); |
712 | return -EINVAL; |
713 | } |
714 | |
715 | spin_lock_irqsave(&vhci->lock, flags); |
716 | |
717 | if (urb->status != -EINPROGRESS) { |
718 | dev_err(dev, "URB already unlinked!, status %d\n" , urb->status); |
719 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
720 | return urb->status; |
721 | } |
722 | |
723 | /* refuse enqueue for dead connection */ |
724 | spin_lock(lock: &vdev->ud.lock); |
725 | if (vdev->ud.status == VDEV_ST_NULL || |
726 | vdev->ud.status == VDEV_ST_ERROR) { |
727 | dev_err(dev, "enqueue for inactive port %d\n" , vdev->rhport); |
728 | spin_unlock(lock: &vdev->ud.lock); |
729 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
730 | return -ENODEV; |
731 | } |
732 | spin_unlock(lock: &vdev->ud.lock); |
733 | |
734 | ret = usb_hcd_link_urb_to_ep(hcd, urb); |
735 | if (ret) |
736 | goto no_need_unlink; |
737 | |
738 | /* |
739 | * The enumeration process is as follows; |
740 | * |
741 | * 1. Get_Descriptor request to DevAddrs(0) EndPoint(0) |
742 | * to get max packet length of default pipe |
743 | * |
744 | * 2. Set_Address request to DevAddr(0) EndPoint(0) |
745 | * |
746 | */ |
747 | if (usb_pipedevice(urb->pipe) == 0) { |
748 | __u8 type = usb_pipetype(urb->pipe); |
749 | struct usb_ctrlrequest *ctrlreq = |
750 | (struct usb_ctrlrequest *) urb->setup_packet; |
751 | |
752 | if (type != PIPE_CONTROL || !ctrlreq) { |
753 | dev_err(dev, "invalid request to devnum 0\n" ); |
754 | ret = -EINVAL; |
755 | goto no_need_xmit; |
756 | } |
757 | |
758 | switch (ctrlreq->bRequest) { |
759 | case USB_REQ_SET_ADDRESS: |
760 | /* set_address may come when a device is reset */ |
761 | dev_info(dev, "SetAddress Request (%d) to port %d\n" , |
762 | ctrlreq->wValue, vdev->rhport); |
763 | |
764 | usb_put_dev(dev: vdev->udev); |
765 | vdev->udev = usb_get_dev(dev: urb->dev); |
766 | |
767 | spin_lock(lock: &vdev->ud.lock); |
768 | vdev->ud.status = VDEV_ST_USED; |
769 | spin_unlock(lock: &vdev->ud.lock); |
770 | |
771 | if (urb->status == -EINPROGRESS) { |
772 | /* This request is successfully completed. */ |
773 | /* If not -EINPROGRESS, possibly unlinked. */ |
774 | urb->status = 0; |
775 | } |
776 | |
777 | goto no_need_xmit; |
778 | |
779 | case USB_REQ_GET_DESCRIPTOR: |
780 | if (ctrlreq->wValue == cpu_to_le16(USB_DT_DEVICE << 8)) |
781 | usbip_dbg_vhci_hc( |
782 | "Not yet?:Get_Descriptor to device 0 (get max pipe size)\n" ); |
783 | |
784 | usb_put_dev(dev: vdev->udev); |
785 | vdev->udev = usb_get_dev(dev: urb->dev); |
786 | goto out; |
787 | |
788 | default: |
789 | /* NOT REACHED */ |
790 | dev_err(dev, |
791 | "invalid request to devnum 0 bRequest %u, wValue %u\n" , |
792 | ctrlreq->bRequest, |
793 | ctrlreq->wValue); |
794 | ret = -EINVAL; |
795 | goto no_need_xmit; |
796 | } |
797 | |
798 | } |
799 | |
800 | out: |
801 | vhci_tx_urb(urb, vdev); |
802 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
803 | |
804 | return 0; |
805 | |
806 | no_need_xmit: |
807 | usb_hcd_unlink_urb_from_ep(hcd, urb); |
808 | no_need_unlink: |
809 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
810 | if (!ret) { |
811 | /* usb_hcd_giveback_urb() should be called with |
812 | * irqs disabled |
813 | */ |
814 | local_irq_disable(); |
815 | usb_hcd_giveback_urb(hcd, urb, status: urb->status); |
816 | local_irq_enable(); |
817 | } |
818 | return ret; |
819 | } |
820 | |
821 | /* |
822 | * vhci_rx gives back the urb after receiving the reply of the urb. If an |
823 | * unlink pdu is sent or not, vhci_rx receives a normal return pdu and gives |
824 | * back its urb. For the driver unlinking the urb, the content of the urb is |
825 | * not important, but the calling to its completion handler is important; the |
826 | * completion of unlinking is notified by the completion handler. |
827 | * |
828 | * |
829 | * CLIENT SIDE |
830 | * |
831 | * - When vhci_hcd receives RET_SUBMIT, |
832 | * |
833 | * - case 1a). the urb of the pdu is not unlinking. |
834 | * - normal case |
835 | * => just give back the urb |
836 | * |
837 | * - case 1b). the urb of the pdu is unlinking. |
838 | * - usbip.ko will return a reply of the unlinking request. |
839 | * => give back the urb now and go to case 2b). |
840 | * |
841 | * - When vhci_hcd receives RET_UNLINK, |
842 | * |
843 | * - case 2a). a submit request is still pending in vhci_hcd. |
844 | * - urb was really pending in usbip.ko and urb_unlink_urb() was |
845 | * completed there. |
846 | * => free a pending submit request |
847 | * => notify unlink completeness by giving back the urb |
848 | * |
849 | * - case 2b). a submit request is *not* pending in vhci_hcd. |
850 | * - urb was already given back to the core driver. |
851 | * => do not give back the urb |
852 | * |
853 | * |
854 | * SERVER SIDE |
855 | * |
856 | * - When usbip receives CMD_UNLINK, |
857 | * |
858 | * - case 3a). the urb of the unlink request is now in submission. |
859 | * => do usb_unlink_urb(). |
860 | * => after the unlink is completed, send RET_UNLINK. |
861 | * |
862 | * - case 3b). the urb of the unlink request is not in submission. |
863 | * - may be already completed or never be received |
864 | * => send RET_UNLINK |
865 | * |
866 | */ |
867 | static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) |
868 | { |
869 | struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd); |
870 | struct vhci *vhci = vhci_hcd->vhci; |
871 | struct vhci_priv *priv; |
872 | struct vhci_device *vdev; |
873 | unsigned long flags; |
874 | |
875 | spin_lock_irqsave(&vhci->lock, flags); |
876 | |
877 | priv = urb->hcpriv; |
878 | if (!priv) { |
879 | /* URB was never linked! or will be soon given back by |
880 | * vhci_rx. */ |
881 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
882 | return -EIDRM; |
883 | } |
884 | |
885 | { |
886 | int ret = 0; |
887 | |
888 | ret = usb_hcd_check_unlink_urb(hcd, urb, status); |
889 | if (ret) { |
890 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
891 | return ret; |
892 | } |
893 | } |
894 | |
895 | /* send unlink request here? */ |
896 | vdev = priv->vdev; |
897 | |
898 | if (!vdev->ud.tcp_socket) { |
899 | /* tcp connection is closed */ |
900 | spin_lock(lock: &vdev->priv_lock); |
901 | |
902 | list_del(entry: &priv->list); |
903 | kfree(objp: priv); |
904 | urb->hcpriv = NULL; |
905 | |
906 | spin_unlock(lock: &vdev->priv_lock); |
907 | |
908 | /* |
909 | * If tcp connection is alive, we have sent CMD_UNLINK. |
910 | * vhci_rx will receive RET_UNLINK and give back the URB. |
911 | * Otherwise, we give back it here. |
912 | */ |
913 | usb_hcd_unlink_urb_from_ep(hcd, urb); |
914 | |
915 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
916 | usb_hcd_giveback_urb(hcd, urb, status: urb->status); |
917 | spin_lock_irqsave(&vhci->lock, flags); |
918 | |
919 | } else { |
920 | /* tcp connection is alive */ |
921 | struct vhci_unlink *unlink; |
922 | |
923 | spin_lock(lock: &vdev->priv_lock); |
924 | |
925 | /* setup CMD_UNLINK pdu */ |
926 | unlink = kzalloc(size: sizeof(struct vhci_unlink), GFP_ATOMIC); |
927 | if (!unlink) { |
928 | spin_unlock(lock: &vdev->priv_lock); |
929 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
930 | usbip_event_add(ud: &vdev->ud, VDEV_EVENT_ERROR_MALLOC); |
931 | return -ENOMEM; |
932 | } |
933 | |
934 | unlink->seqnum = atomic_inc_return(v: &vhci_hcd->seqnum); |
935 | if (unlink->seqnum == 0xffff) |
936 | pr_info("seqnum max\n" ); |
937 | |
938 | unlink->unlink_seqnum = priv->seqnum; |
939 | |
940 | /* send cmd_unlink and try to cancel the pending URB in the |
941 | * peer */ |
942 | list_add_tail(new: &unlink->list, head: &vdev->unlink_tx); |
943 | wake_up(&vdev->waitq_tx); |
944 | |
945 | spin_unlock(lock: &vdev->priv_lock); |
946 | } |
947 | |
948 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
949 | |
950 | usbip_dbg_vhci_hc("leave\n" ); |
951 | return 0; |
952 | } |
953 | |
954 | static void vhci_cleanup_unlink_list(struct vhci_device *vdev, |
955 | struct list_head *unlink_list) |
956 | { |
957 | struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev); |
958 | struct usb_hcd *hcd = vhci_hcd_to_hcd(vhci_hcd); |
959 | struct vhci *vhci = vhci_hcd->vhci; |
960 | struct vhci_unlink *unlink, *tmp; |
961 | unsigned long flags; |
962 | |
963 | spin_lock_irqsave(&vhci->lock, flags); |
964 | spin_lock(lock: &vdev->priv_lock); |
965 | |
966 | list_for_each_entry_safe(unlink, tmp, unlink_list, list) { |
967 | struct urb *urb; |
968 | |
969 | urb = pickup_urb_and_free_priv(vdev, seqnum: unlink->unlink_seqnum); |
970 | if (!urb) { |
971 | list_del(entry: &unlink->list); |
972 | kfree(objp: unlink); |
973 | continue; |
974 | } |
975 | |
976 | urb->status = -ENODEV; |
977 | |
978 | usb_hcd_unlink_urb_from_ep(hcd, urb); |
979 | |
980 | list_del(entry: &unlink->list); |
981 | |
982 | spin_unlock(lock: &vdev->priv_lock); |
983 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
984 | |
985 | usb_hcd_giveback_urb(hcd, urb, status: urb->status); |
986 | |
987 | spin_lock_irqsave(&vhci->lock, flags); |
988 | spin_lock(lock: &vdev->priv_lock); |
989 | |
990 | kfree(objp: unlink); |
991 | } |
992 | |
993 | spin_unlock(lock: &vdev->priv_lock); |
994 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
995 | } |
996 | |
997 | static void vhci_device_unlink_cleanup(struct vhci_device *vdev) |
998 | { |
999 | /* give back URB of unsent unlink request */ |
1000 | vhci_cleanup_unlink_list(vdev, unlink_list: &vdev->unlink_tx); |
1001 | |
1002 | /* give back URB of unanswered unlink request */ |
1003 | vhci_cleanup_unlink_list(vdev, unlink_list: &vdev->unlink_rx); |
1004 | } |
1005 | |
1006 | /* |
1007 | * The important thing is that only one context begins cleanup. |
1008 | * This is why error handling and cleanup become simple. |
1009 | * We do not want to consider race condition as possible. |
1010 | */ |
1011 | static void vhci_shutdown_connection(struct usbip_device *ud) |
1012 | { |
1013 | struct vhci_device *vdev = container_of(ud, struct vhci_device, ud); |
1014 | |
1015 | /* need this? see stub_dev.c */ |
1016 | if (ud->tcp_socket) { |
1017 | pr_debug("shutdown tcp_socket %d\n" , ud->sockfd); |
1018 | kernel_sock_shutdown(sock: ud->tcp_socket, how: SHUT_RDWR); |
1019 | } |
1020 | |
1021 | /* kill threads related to this sdev */ |
1022 | if (vdev->ud.tcp_rx) { |
1023 | kthread_stop_put(k: vdev->ud.tcp_rx); |
1024 | vdev->ud.tcp_rx = NULL; |
1025 | } |
1026 | if (vdev->ud.tcp_tx) { |
1027 | kthread_stop_put(k: vdev->ud.tcp_tx); |
1028 | vdev->ud.tcp_tx = NULL; |
1029 | } |
1030 | pr_info("stop threads\n" ); |
1031 | |
1032 | /* active connection is closed */ |
1033 | if (vdev->ud.tcp_socket) { |
1034 | sockfd_put(vdev->ud.tcp_socket); |
1035 | vdev->ud.tcp_socket = NULL; |
1036 | vdev->ud.sockfd = -1; |
1037 | } |
1038 | pr_info("release socket\n" ); |
1039 | |
1040 | vhci_device_unlink_cleanup(vdev); |
1041 | |
1042 | /* |
1043 | * rh_port_disconnect() is a trigger of ... |
1044 | * usb_disable_device(): |
1045 | * disable all the endpoints for a USB device. |
1046 | * usb_disable_endpoint(): |
1047 | * disable endpoints. pending urbs are unlinked(dequeued). |
1048 | * |
1049 | * NOTE: After calling rh_port_disconnect(), the USB device drivers of a |
1050 | * detached device should release used urbs in a cleanup function (i.e. |
1051 | * xxx_disconnect()). Therefore, vhci_hcd does not need to release |
1052 | * pushed urbs and their private data in this function. |
1053 | * |
1054 | * NOTE: vhci_dequeue() must be considered carefully. When shutting down |
1055 | * a connection, vhci_shutdown_connection() expects vhci_dequeue() |
1056 | * gives back pushed urbs and frees their private data by request of |
1057 | * the cleanup function of a USB driver. When unlinking a urb with an |
1058 | * active connection, vhci_dequeue() does not give back the urb which |
1059 | * is actually given back by vhci_rx after receiving its return pdu. |
1060 | * |
1061 | */ |
1062 | rh_port_disconnect(vdev); |
1063 | |
1064 | pr_info("disconnect device\n" ); |
1065 | } |
1066 | |
1067 | static void vhci_device_reset(struct usbip_device *ud) |
1068 | { |
1069 | struct vhci_device *vdev = container_of(ud, struct vhci_device, ud); |
1070 | unsigned long flags; |
1071 | |
1072 | spin_lock_irqsave(&ud->lock, flags); |
1073 | |
1074 | vdev->speed = 0; |
1075 | vdev->devid = 0; |
1076 | |
1077 | usb_put_dev(dev: vdev->udev); |
1078 | vdev->udev = NULL; |
1079 | |
1080 | if (ud->tcp_socket) { |
1081 | sockfd_put(ud->tcp_socket); |
1082 | ud->tcp_socket = NULL; |
1083 | ud->sockfd = -1; |
1084 | } |
1085 | ud->status = VDEV_ST_NULL; |
1086 | |
1087 | spin_unlock_irqrestore(lock: &ud->lock, flags); |
1088 | } |
1089 | |
1090 | static void vhci_device_unusable(struct usbip_device *ud) |
1091 | { |
1092 | unsigned long flags; |
1093 | |
1094 | spin_lock_irqsave(&ud->lock, flags); |
1095 | ud->status = VDEV_ST_ERROR; |
1096 | spin_unlock_irqrestore(lock: &ud->lock, flags); |
1097 | } |
1098 | |
1099 | static void vhci_device_init(struct vhci_device *vdev) |
1100 | { |
1101 | memset(vdev, 0, sizeof(struct vhci_device)); |
1102 | |
1103 | vdev->ud.side = USBIP_VHCI; |
1104 | vdev->ud.status = VDEV_ST_NULL; |
1105 | spin_lock_init(&vdev->ud.lock); |
1106 | mutex_init(&vdev->ud.sysfs_lock); |
1107 | |
1108 | INIT_LIST_HEAD(list: &vdev->priv_rx); |
1109 | INIT_LIST_HEAD(list: &vdev->priv_tx); |
1110 | INIT_LIST_HEAD(list: &vdev->unlink_tx); |
1111 | INIT_LIST_HEAD(list: &vdev->unlink_rx); |
1112 | spin_lock_init(&vdev->priv_lock); |
1113 | |
1114 | init_waitqueue_head(&vdev->waitq_tx); |
1115 | |
1116 | vdev->ud.eh_ops.shutdown = vhci_shutdown_connection; |
1117 | vdev->ud.eh_ops.reset = vhci_device_reset; |
1118 | vdev->ud.eh_ops.unusable = vhci_device_unusable; |
1119 | |
1120 | usbip_start_eh(ud: &vdev->ud); |
1121 | } |
1122 | |
1123 | static int hcd_name_to_id(const char *name) |
1124 | { |
1125 | char *c; |
1126 | long val; |
1127 | int ret; |
1128 | |
1129 | c = strchr(name, '.'); |
1130 | if (c == NULL) |
1131 | return 0; |
1132 | |
1133 | ret = kstrtol(s: c+1, base: 10, res: &val); |
1134 | if (ret < 0) |
1135 | return ret; |
1136 | |
1137 | return val; |
1138 | } |
1139 | |
1140 | static int vhci_setup(struct usb_hcd *hcd) |
1141 | { |
1142 | struct vhci *vhci = *((void **)dev_get_platdata(dev: hcd->self.controller)); |
1143 | |
1144 | if (usb_hcd_is_primary_hcd(hcd)) { |
1145 | vhci->vhci_hcd_hs = hcd_to_vhci_hcd(hcd); |
1146 | vhci->vhci_hcd_hs->vhci = vhci; |
1147 | /* |
1148 | * Mark the first roothub as being USB 2.0. |
1149 | * The USB 3.0 roothub will be registered later by |
1150 | * vhci_hcd_probe() |
1151 | */ |
1152 | hcd->speed = HCD_USB2; |
1153 | hcd->self.root_hub->speed = USB_SPEED_HIGH; |
1154 | } else { |
1155 | vhci->vhci_hcd_ss = hcd_to_vhci_hcd(hcd); |
1156 | vhci->vhci_hcd_ss->vhci = vhci; |
1157 | hcd->speed = HCD_USB3; |
1158 | hcd->self.root_hub->speed = USB_SPEED_SUPER; |
1159 | } |
1160 | |
1161 | /* |
1162 | * Support SG. |
1163 | * sg_tablesize is an arbitrary value to alleviate memory pressure |
1164 | * on the host. |
1165 | */ |
1166 | hcd->self.sg_tablesize = 32; |
1167 | hcd->self.no_sg_constraint = 1; |
1168 | |
1169 | return 0; |
1170 | } |
1171 | |
1172 | static int vhci_start(struct usb_hcd *hcd) |
1173 | { |
1174 | struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd); |
1175 | int id, rhport; |
1176 | int err; |
1177 | |
1178 | usbip_dbg_vhci_hc("enter vhci_start\n" ); |
1179 | |
1180 | if (usb_hcd_is_primary_hcd(hcd)) |
1181 | spin_lock_init(&vhci_hcd->vhci->lock); |
1182 | |
1183 | /* initialize private data of usb_hcd */ |
1184 | |
1185 | for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) { |
1186 | struct vhci_device *vdev = &vhci_hcd->vdev[rhport]; |
1187 | |
1188 | vhci_device_init(vdev); |
1189 | vdev->rhport = rhport; |
1190 | } |
1191 | |
1192 | atomic_set(v: &vhci_hcd->seqnum, i: 0); |
1193 | |
1194 | hcd->power_budget = 0; /* no limit */ |
1195 | hcd->uses_new_polling = 1; |
1196 | |
1197 | #ifdef CONFIG_USB_OTG |
1198 | hcd->self.otg_port = 1; |
1199 | #endif |
1200 | |
1201 | id = hcd_name_to_id(name: hcd_name(hcd)); |
1202 | if (id < 0) { |
1203 | pr_err("invalid vhci name %s\n" , hcd_name(hcd)); |
1204 | return -EINVAL; |
1205 | } |
1206 | |
1207 | /* vhci_hcd is now ready to be controlled through sysfs */ |
1208 | if (id == 0 && usb_hcd_is_primary_hcd(hcd)) { |
1209 | err = vhci_init_attr_group(); |
1210 | if (err) { |
1211 | dev_err(hcd_dev(hcd), "init attr group failed, err = %d\n" , err); |
1212 | return err; |
1213 | } |
1214 | err = sysfs_create_group(kobj: &hcd_dev(hcd)->kobj, grp: &vhci_attr_group); |
1215 | if (err) { |
1216 | dev_err(hcd_dev(hcd), "create sysfs files failed, err = %d\n" , err); |
1217 | vhci_finish_attr_group(); |
1218 | return err; |
1219 | } |
1220 | pr_info("created sysfs %s\n" , hcd_name(hcd)); |
1221 | } |
1222 | |
1223 | return 0; |
1224 | } |
1225 | |
1226 | static void vhci_stop(struct usb_hcd *hcd) |
1227 | { |
1228 | struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd); |
1229 | int id, rhport; |
1230 | |
1231 | usbip_dbg_vhci_hc("stop VHCI controller\n" ); |
1232 | |
1233 | /* 1. remove the userland interface of vhci_hcd */ |
1234 | id = hcd_name_to_id(name: hcd_name(hcd)); |
1235 | if (id == 0 && usb_hcd_is_primary_hcd(hcd)) { |
1236 | sysfs_remove_group(kobj: &hcd_dev(hcd)->kobj, grp: &vhci_attr_group); |
1237 | vhci_finish_attr_group(); |
1238 | } |
1239 | |
1240 | /* 2. shutdown all the ports of vhci_hcd */ |
1241 | for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) { |
1242 | struct vhci_device *vdev = &vhci_hcd->vdev[rhport]; |
1243 | |
1244 | usbip_event_add(ud: &vdev->ud, VDEV_EVENT_REMOVED); |
1245 | usbip_stop_eh(ud: &vdev->ud); |
1246 | } |
1247 | } |
1248 | |
1249 | static int vhci_get_frame_number(struct usb_hcd *hcd) |
1250 | { |
1251 | dev_err_ratelimited(&hcd->self.root_hub->dev, "Not yet implemented\n" ); |
1252 | return 0; |
1253 | } |
1254 | |
1255 | #ifdef CONFIG_PM |
1256 | |
1257 | /* FIXME: suspend/resume */ |
1258 | static int vhci_bus_suspend(struct usb_hcd *hcd) |
1259 | { |
1260 | struct vhci *vhci = *((void **)dev_get_platdata(dev: hcd->self.controller)); |
1261 | unsigned long flags; |
1262 | |
1263 | dev_dbg(&hcd->self.root_hub->dev, "%s\n" , __func__); |
1264 | |
1265 | spin_lock_irqsave(&vhci->lock, flags); |
1266 | hcd->state = HC_STATE_SUSPENDED; |
1267 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
1268 | |
1269 | return 0; |
1270 | } |
1271 | |
1272 | static int vhci_bus_resume(struct usb_hcd *hcd) |
1273 | { |
1274 | struct vhci *vhci = *((void **)dev_get_platdata(dev: hcd->self.controller)); |
1275 | int rc = 0; |
1276 | unsigned long flags; |
1277 | |
1278 | dev_dbg(&hcd->self.root_hub->dev, "%s\n" , __func__); |
1279 | |
1280 | spin_lock_irqsave(&vhci->lock, flags); |
1281 | if (!HCD_HW_ACCESSIBLE(hcd)) |
1282 | rc = -ESHUTDOWN; |
1283 | else |
1284 | hcd->state = HC_STATE_RUNNING; |
1285 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
1286 | |
1287 | return rc; |
1288 | } |
1289 | |
1290 | #else |
1291 | |
1292 | #define vhci_bus_suspend NULL |
1293 | #define vhci_bus_resume NULL |
1294 | #endif |
1295 | |
1296 | /* Change a group of bulk endpoints to support multiple stream IDs */ |
1297 | static int vhci_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev, |
1298 | struct usb_host_endpoint **eps, unsigned int num_eps, |
1299 | unsigned int num_streams, gfp_t mem_flags) |
1300 | { |
1301 | dev_dbg(&hcd->self.root_hub->dev, "vhci_alloc_streams not implemented\n" ); |
1302 | return 0; |
1303 | } |
1304 | |
1305 | /* Reverts a group of bulk endpoints back to not using stream IDs. */ |
1306 | static int vhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev, |
1307 | struct usb_host_endpoint **eps, unsigned int num_eps, |
1308 | gfp_t mem_flags) |
1309 | { |
1310 | dev_dbg(&hcd->self.root_hub->dev, "vhci_free_streams not implemented\n" ); |
1311 | return 0; |
1312 | } |
1313 | |
1314 | static const struct hc_driver vhci_hc_driver = { |
1315 | .description = driver_name, |
1316 | .product_desc = driver_desc, |
1317 | .hcd_priv_size = sizeof(struct vhci_hcd), |
1318 | |
1319 | .flags = HCD_USB3 | HCD_SHARED, |
1320 | |
1321 | .reset = vhci_setup, |
1322 | .start = vhci_start, |
1323 | .stop = vhci_stop, |
1324 | |
1325 | .urb_enqueue = vhci_urb_enqueue, |
1326 | .urb_dequeue = vhci_urb_dequeue, |
1327 | |
1328 | .get_frame_number = vhci_get_frame_number, |
1329 | |
1330 | .hub_status_data = vhci_hub_status, |
1331 | .hub_control = vhci_hub_control, |
1332 | .bus_suspend = vhci_bus_suspend, |
1333 | .bus_resume = vhci_bus_resume, |
1334 | |
1335 | .alloc_streams = vhci_alloc_streams, |
1336 | .free_streams = vhci_free_streams, |
1337 | }; |
1338 | |
1339 | static int vhci_hcd_probe(struct platform_device *pdev) |
1340 | { |
1341 | struct vhci *vhci = *((void **)dev_get_platdata(dev: &pdev->dev)); |
1342 | struct usb_hcd *hcd_hs; |
1343 | struct usb_hcd *hcd_ss; |
1344 | int ret; |
1345 | |
1346 | usbip_dbg_vhci_hc("name %s id %d\n" , pdev->name, pdev->id); |
1347 | |
1348 | /* |
1349 | * Allocate and initialize hcd. |
1350 | * Our private data is also allocated automatically. |
1351 | */ |
1352 | hcd_hs = usb_create_hcd(driver: &vhci_hc_driver, dev: &pdev->dev, bus_name: dev_name(dev: &pdev->dev)); |
1353 | if (!hcd_hs) { |
1354 | pr_err("create primary hcd failed\n" ); |
1355 | return -ENOMEM; |
1356 | } |
1357 | hcd_hs->has_tt = 1; |
1358 | |
1359 | /* |
1360 | * Finish generic HCD structure initialization and register. |
1361 | * Call the driver's reset() and start() routines. |
1362 | */ |
1363 | ret = usb_add_hcd(hcd: hcd_hs, irqnum: 0, irqflags: 0); |
1364 | if (ret != 0) { |
1365 | pr_err("usb_add_hcd hs failed %d\n" , ret); |
1366 | goto put_usb2_hcd; |
1367 | } |
1368 | |
1369 | hcd_ss = usb_create_shared_hcd(driver: &vhci_hc_driver, dev: &pdev->dev, |
1370 | bus_name: dev_name(dev: &pdev->dev), shared_hcd: hcd_hs); |
1371 | if (!hcd_ss) { |
1372 | ret = -ENOMEM; |
1373 | pr_err("create shared hcd failed\n" ); |
1374 | goto remove_usb2_hcd; |
1375 | } |
1376 | |
1377 | ret = usb_add_hcd(hcd: hcd_ss, irqnum: 0, irqflags: 0); |
1378 | if (ret) { |
1379 | pr_err("usb_add_hcd ss failed %d\n" , ret); |
1380 | goto put_usb3_hcd; |
1381 | } |
1382 | |
1383 | usbip_dbg_vhci_hc("bye\n" ); |
1384 | return 0; |
1385 | |
1386 | put_usb3_hcd: |
1387 | usb_put_hcd(hcd: hcd_ss); |
1388 | remove_usb2_hcd: |
1389 | usb_remove_hcd(hcd: hcd_hs); |
1390 | put_usb2_hcd: |
1391 | usb_put_hcd(hcd: hcd_hs); |
1392 | vhci->vhci_hcd_hs = NULL; |
1393 | vhci->vhci_hcd_ss = NULL; |
1394 | return ret; |
1395 | } |
1396 | |
1397 | static void vhci_hcd_remove(struct platform_device *pdev) |
1398 | { |
1399 | struct vhci *vhci = *((void **)dev_get_platdata(dev: &pdev->dev)); |
1400 | |
1401 | /* |
1402 | * Disconnects the root hub, |
1403 | * then reverses the effects of usb_add_hcd(), |
1404 | * invoking the HCD's stop() methods. |
1405 | */ |
1406 | usb_remove_hcd(hcd: vhci_hcd_to_hcd(vhci_hcd: vhci->vhci_hcd_ss)); |
1407 | usb_put_hcd(hcd: vhci_hcd_to_hcd(vhci_hcd: vhci->vhci_hcd_ss)); |
1408 | |
1409 | usb_remove_hcd(hcd: vhci_hcd_to_hcd(vhci_hcd: vhci->vhci_hcd_hs)); |
1410 | usb_put_hcd(hcd: vhci_hcd_to_hcd(vhci_hcd: vhci->vhci_hcd_hs)); |
1411 | |
1412 | vhci->vhci_hcd_hs = NULL; |
1413 | vhci->vhci_hcd_ss = NULL; |
1414 | } |
1415 | |
1416 | #ifdef CONFIG_PM |
1417 | |
1418 | /* what should happen for USB/IP under suspend/resume? */ |
1419 | static int vhci_hcd_suspend(struct platform_device *pdev, pm_message_t state) |
1420 | { |
1421 | struct usb_hcd *hcd; |
1422 | struct vhci *vhci; |
1423 | int rhport; |
1424 | int connected = 0; |
1425 | int ret = 0; |
1426 | unsigned long flags; |
1427 | |
1428 | dev_dbg(&pdev->dev, "%s\n" , __func__); |
1429 | |
1430 | hcd = platform_get_drvdata(pdev); |
1431 | if (!hcd) |
1432 | return 0; |
1433 | |
1434 | vhci = *((void **)dev_get_platdata(dev: hcd->self.controller)); |
1435 | |
1436 | spin_lock_irqsave(&vhci->lock, flags); |
1437 | |
1438 | for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) { |
1439 | if (vhci->vhci_hcd_hs->port_status[rhport] & |
1440 | USB_PORT_STAT_CONNECTION) |
1441 | connected += 1; |
1442 | |
1443 | if (vhci->vhci_hcd_ss->port_status[rhport] & |
1444 | USB_PORT_STAT_CONNECTION) |
1445 | connected += 1; |
1446 | } |
1447 | |
1448 | spin_unlock_irqrestore(lock: &vhci->lock, flags); |
1449 | |
1450 | if (connected > 0) { |
1451 | dev_info(&pdev->dev, |
1452 | "We have %d active connection%s. Do not suspend.\n" , |
1453 | connected, (connected == 1 ? "" : "s" )); |
1454 | ret = -EBUSY; |
1455 | } else { |
1456 | dev_info(&pdev->dev, "suspend vhci_hcd" ); |
1457 | clear_bit(HCD_FLAG_HW_ACCESSIBLE, addr: &hcd->flags); |
1458 | } |
1459 | |
1460 | return ret; |
1461 | } |
1462 | |
1463 | static int vhci_hcd_resume(struct platform_device *pdev) |
1464 | { |
1465 | struct usb_hcd *hcd; |
1466 | |
1467 | dev_dbg(&pdev->dev, "%s\n" , __func__); |
1468 | |
1469 | hcd = platform_get_drvdata(pdev); |
1470 | if (!hcd) |
1471 | return 0; |
1472 | set_bit(HCD_FLAG_HW_ACCESSIBLE, addr: &hcd->flags); |
1473 | usb_hcd_poll_rh_status(hcd); |
1474 | |
1475 | return 0; |
1476 | } |
1477 | |
1478 | #else |
1479 | |
1480 | #define vhci_hcd_suspend NULL |
1481 | #define vhci_hcd_resume NULL |
1482 | |
1483 | #endif |
1484 | |
1485 | static struct platform_driver vhci_driver = { |
1486 | .probe = vhci_hcd_probe, |
1487 | .remove_new = vhci_hcd_remove, |
1488 | .suspend = vhci_hcd_suspend, |
1489 | .resume = vhci_hcd_resume, |
1490 | .driver = { |
1491 | .name = driver_name, |
1492 | }, |
1493 | }; |
1494 | |
1495 | static void del_platform_devices(void) |
1496 | { |
1497 | int i; |
1498 | |
1499 | for (i = 0; i < vhci_num_controllers; i++) { |
1500 | platform_device_unregister(vhcis[i].pdev); |
1501 | vhcis[i].pdev = NULL; |
1502 | } |
1503 | sysfs_remove_link(kobj: &platform_bus.kobj, name: driver_name); |
1504 | } |
1505 | |
1506 | static int __init vhci_hcd_init(void) |
1507 | { |
1508 | int i, ret; |
1509 | |
1510 | if (usb_disabled()) |
1511 | return -ENODEV; |
1512 | |
1513 | if (vhci_num_controllers < 1) |
1514 | vhci_num_controllers = 1; |
1515 | |
1516 | vhcis = kcalloc(n: vhci_num_controllers, size: sizeof(struct vhci), GFP_KERNEL); |
1517 | if (vhcis == NULL) |
1518 | return -ENOMEM; |
1519 | |
1520 | ret = platform_driver_register(&vhci_driver); |
1521 | if (ret) |
1522 | goto err_driver_register; |
1523 | |
1524 | for (i = 0; i < vhci_num_controllers; i++) { |
1525 | void *vhci = &vhcis[i]; |
1526 | struct platform_device_info pdevinfo = { |
1527 | .name = driver_name, |
1528 | .id = i, |
1529 | .data = &vhci, |
1530 | .size_data = sizeof(void *), |
1531 | }; |
1532 | |
1533 | vhcis[i].pdev = platform_device_register_full(pdevinfo: &pdevinfo); |
1534 | ret = PTR_ERR_OR_ZERO(ptr: vhcis[i].pdev); |
1535 | if (ret < 0) { |
1536 | while (i--) |
1537 | platform_device_unregister(vhcis[i].pdev); |
1538 | goto err_add_hcd; |
1539 | } |
1540 | } |
1541 | |
1542 | return 0; |
1543 | |
1544 | err_add_hcd: |
1545 | platform_driver_unregister(&vhci_driver); |
1546 | err_driver_register: |
1547 | kfree(objp: vhcis); |
1548 | return ret; |
1549 | } |
1550 | |
1551 | static void __exit vhci_hcd_exit(void) |
1552 | { |
1553 | del_platform_devices(); |
1554 | platform_driver_unregister(&vhci_driver); |
1555 | kfree(objp: vhcis); |
1556 | } |
1557 | |
1558 | module_init(vhci_hcd_init); |
1559 | module_exit(vhci_hcd_exit); |
1560 | |
1561 | MODULE_AUTHOR(DRIVER_AUTHOR); |
1562 | MODULE_DESCRIPTION(DRIVER_DESC); |
1563 | MODULE_LICENSE("GPL" ); |
1564 | |