vhci_hcd.c 39 KB

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