1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2015 Karol Kosik <karo9@interia.eu> 4 * Copyright (C) 2015-2016 Samsung Electronics 5 * Igor Kotrasinski <i.kotrasinsk@samsung.com> 6 * Krzysztof Opasiak <k.opasiak@samsung.com> 7 */ 8 9 #include <linux/device.h> 10 #include <linux/kernel.h> 11 #include <linux/list.h> 12 #include <linux/platform_device.h> 13 #include <linux/usb.h> 14 #include <linux/usb/gadget.h> 15 #include <linux/usb/hcd.h> 16 #include <linux/kthread.h> 17 #include <linux/file.h> 18 #include <linux/byteorder/generic.h> 19 20 #include "usbip_common.h" 21 #include "vudc.h" 22 23 #define VIRTUAL_ENDPOINTS (1 /* ep0 */ + 15 /* in eps */ + 15 /* out eps */) 24 25 /* urb-related structures alloc / free */ 26 27 28 static void free_urb(struct urb *urb) 29 { 30 if (!urb) 31 return; 32 33 kfree(urb->setup_packet); 34 urb->setup_packet = NULL; 35 36 kfree(urb->transfer_buffer); 37 urb->transfer_buffer = NULL; 38 39 usb_free_urb(urb); 40 } 41 42 struct urbp *alloc_urbp(void) 43 { 44 struct urbp *urb_p; 45 46 urb_p = kzalloc(sizeof(*urb_p), GFP_KERNEL); 47 if (!urb_p) 48 return urb_p; 49 50 urb_p->urb = NULL; 51 urb_p->ep = NULL; 52 INIT_LIST_HEAD(&urb_p->urb_entry); 53 return urb_p; 54 } 55 56 static void free_urbp(struct urbp *urb_p) 57 { 58 kfree(urb_p); 59 } 60 61 void free_urbp_and_urb(struct urbp *urb_p) 62 { 63 if (!urb_p) 64 return; 65 free_urb(urb_p->urb); 66 free_urbp(urb_p); 67 } 68 69 70 /* utilities ; almost verbatim from dummy_hcd.c */ 71 72 /* called with spinlock held */ 73 static void nuke(struct vudc *udc, struct vep *ep) 74 { 75 struct vrequest *req; 76 77 while (!list_empty(&ep->req_queue)) { 78 req = list_first_entry(&ep->req_queue, struct vrequest, 79 req_entry); 80 list_del_init(&req->req_entry); 81 req->req.status = -ESHUTDOWN; 82 83 spin_unlock(&udc->lock); 84 usb_gadget_giveback_request(&ep->ep, &req->req); 85 spin_lock(&udc->lock); 86 } 87 } 88 89 /* caller must hold lock */ 90 static void stop_activity(struct vudc *udc) 91 { 92 int i; 93 struct urbp *urb_p, *tmp; 94 95 udc->address = 0; 96 97 for (i = 0; i < VIRTUAL_ENDPOINTS; i++) 98 nuke(udc, &udc->ep[i]); 99 100 list_for_each_entry_safe(urb_p, tmp, &udc->urb_queue, urb_entry) { 101 list_del(&urb_p->urb_entry); 102 free_urbp_and_urb(urb_p); 103 } 104 } 105 106 struct vep *vudc_find_endpoint(struct vudc *udc, u8 address) 107 { 108 int i; 109 110 if ((address & ~USB_DIR_IN) == 0) 111 return &udc->ep[0]; 112 113 for (i = 1; i < VIRTUAL_ENDPOINTS; i++) { 114 struct vep *ep = &udc->ep[i]; 115 116 if (!ep->desc) 117 continue; 118 if (ep->desc->bEndpointAddress == address) 119 return ep; 120 } 121 return NULL; 122 } 123 124 /* gadget ops */ 125 126 static int vgadget_get_frame(struct usb_gadget *_gadget) 127 { 128 struct timespec64 now; 129 struct vudc *udc = usb_gadget_to_vudc(_gadget); 130 131 ktime_get_ts64(&now); 132 return ((now.tv_sec - udc->start_time.tv_sec) * 1000 + 133 (now.tv_nsec - udc->start_time.tv_nsec) / NSEC_PER_MSEC) 134 & 0x7FF; 135 } 136 137 static int vgadget_set_selfpowered(struct usb_gadget *_gadget, int value) 138 { 139 struct vudc *udc = usb_gadget_to_vudc(_gadget); 140 141 if (value) 142 udc->devstatus |= (1 << USB_DEVICE_SELF_POWERED); 143 else 144 udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED); 145 return 0; 146 } 147 148 static int vgadget_pullup(struct usb_gadget *_gadget, int value) 149 { 150 struct vudc *udc = usb_gadget_to_vudc(_gadget); 151 unsigned long flags; 152 int ret; 153 154 155 spin_lock_irqsave(&udc->lock, flags); 156 value = !!value; 157 if (value == udc->pullup) 158 goto unlock; 159 160 udc->pullup = value; 161 if (value) { 162 udc->gadget.speed = min_t(u8, USB_SPEED_HIGH, 163 udc->driver->max_speed); 164 udc->ep[0].ep.maxpacket = 64; 165 /* 166 * This is the first place where we can ask our 167 * gadget driver for descriptors. 168 */ 169 ret = get_gadget_descs(udc); 170 if (ret) { 171 dev_err(&udc->gadget.dev, "Unable go get desc: %d", ret); 172 goto unlock; 173 } 174 175 spin_unlock_irqrestore(&udc->lock, flags); 176 usbip_start_eh(&udc->ud); 177 } else { 178 /* Invalidate descriptors */ 179 udc->desc_cached = 0; 180 181 spin_unlock_irqrestore(&udc->lock, flags); 182 usbip_event_add(&udc->ud, VUDC_EVENT_REMOVED); 183 usbip_stop_eh(&udc->ud); /* Wait for eh completion */ 184 } 185 186 return 0; 187 188 unlock: 189 spin_unlock_irqrestore(&udc->lock, flags); 190 return 0; 191 } 192 193 static int vgadget_udc_start(struct usb_gadget *g, 194 struct usb_gadget_driver *driver) 195 { 196 struct vudc *udc = usb_gadget_to_vudc(g); 197 unsigned long flags; 198 199 spin_lock_irqsave(&udc->lock, flags); 200 udc->driver = driver; 201 udc->pullup = udc->connected = udc->desc_cached = 0; 202 spin_unlock_irqrestore(&udc->lock, flags); 203 204 return 0; 205 } 206 207 static int vgadget_udc_stop(struct usb_gadget *g) 208 { 209 struct vudc *udc = usb_gadget_to_vudc(g); 210 unsigned long flags; 211 212 spin_lock_irqsave(&udc->lock, flags); 213 udc->driver = NULL; 214 spin_unlock_irqrestore(&udc->lock, flags); 215 return 0; 216 } 217 218 static const struct usb_gadget_ops vgadget_ops = { 219 .get_frame = vgadget_get_frame, 220 .set_selfpowered = vgadget_set_selfpowered, 221 .pullup = vgadget_pullup, 222 .udc_start = vgadget_udc_start, 223 .udc_stop = vgadget_udc_stop, 224 }; 225 226 227 /* endpoint ops */ 228 229 static int vep_enable(struct usb_ep *_ep, 230 const struct usb_endpoint_descriptor *desc) 231 { 232 struct vep *ep; 233 struct vudc *udc; 234 unsigned int maxp; 235 unsigned long flags; 236 237 ep = to_vep(_ep); 238 udc = ep_to_vudc(ep); 239 240 if (!_ep || !desc || ep->desc || _ep->caps.type_control 241 || desc->bDescriptorType != USB_DT_ENDPOINT) 242 return -EINVAL; 243 244 if (!udc->driver) 245 return -ESHUTDOWN; 246 247 spin_lock_irqsave(&udc->lock, flags); 248 249 maxp = usb_endpoint_maxp(desc); 250 _ep->maxpacket = maxp; 251 ep->desc = desc; 252 ep->type = usb_endpoint_type(desc); 253 ep->halted = ep->wedged = 0; 254 255 spin_unlock_irqrestore(&udc->lock, flags); 256 257 return 0; 258 } 259 260 static int vep_disable(struct usb_ep *_ep) 261 { 262 struct vep *ep; 263 struct vudc *udc; 264 unsigned long flags; 265 266 ep = to_vep(_ep); 267 udc = ep_to_vudc(ep); 268 if (!_ep || !ep->desc || _ep->caps.type_control) 269 return -EINVAL; 270 271 spin_lock_irqsave(&udc->lock, flags); 272 ep->desc = NULL; 273 nuke(udc, ep); 274 spin_unlock_irqrestore(&udc->lock, flags); 275 276 return 0; 277 } 278 279 static struct usb_request *vep_alloc_request(struct usb_ep *_ep, 280 gfp_t mem_flags) 281 { 282 struct vrequest *req; 283 284 if (!_ep) 285 return NULL; 286 287 req = kzalloc(sizeof(*req), mem_flags); 288 if (!req) 289 return NULL; 290 291 INIT_LIST_HEAD(&req->req_entry); 292 293 return &req->req; 294 } 295 296 static void vep_free_request(struct usb_ep *_ep, struct usb_request *_req) 297 { 298 struct vrequest *req; 299 300 if (WARN_ON(!_ep || !_req)) 301 return; 302 303 req = to_vrequest(_req); 304 kfree(req); 305 } 306 307 static int vep_queue(struct usb_ep *_ep, struct usb_request *_req, 308 gfp_t mem_flags) 309 { 310 struct vep *ep; 311 struct vrequest *req; 312 struct vudc *udc; 313 unsigned long flags; 314 315 if (!_ep || !_req) 316 return -EINVAL; 317 318 ep = to_vep(_ep); 319 req = to_vrequest(_req); 320 udc = ep_to_vudc(ep); 321 322 spin_lock_irqsave(&udc->lock, flags); 323 _req->actual = 0; 324 _req->status = -EINPROGRESS; 325 326 list_add_tail(&req->req_entry, &ep->req_queue); 327 spin_unlock_irqrestore(&udc->lock, flags); 328 329 return 0; 330 } 331 332 static int vep_dequeue(struct usb_ep *_ep, struct usb_request *_req) 333 { 334 struct vep *ep; 335 struct vrequest *req; 336 struct vudc *udc; 337 struct vrequest *lst; 338 unsigned long flags; 339 int ret = -EINVAL; 340 341 if (!_ep || !_req) 342 return ret; 343 344 ep = to_vep(_ep); 345 req = to_vrequest(_req); 346 udc = req->udc; 347 348 if (!udc->driver) 349 return -ESHUTDOWN; 350 351 spin_lock_irqsave(&udc->lock, flags); 352 list_for_each_entry(lst, &ep->req_queue, req_entry) { 353 if (&lst->req == _req) { 354 list_del_init(&lst->req_entry); 355 _req->status = -ECONNRESET; 356 ret = 0; 357 break; 358 } 359 } 360 spin_unlock_irqrestore(&udc->lock, flags); 361 362 if (ret == 0) 363 usb_gadget_giveback_request(_ep, _req); 364 365 return ret; 366 } 367 368 static int 369 vep_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged) 370 { 371 struct vep *ep; 372 struct vudc *udc; 373 unsigned long flags; 374 int ret = 0; 375 376 ep = to_vep(_ep); 377 if (!_ep) 378 return -EINVAL; 379 380 udc = ep_to_vudc(ep); 381 if (!udc->driver) 382 return -ESHUTDOWN; 383 384 spin_lock_irqsave(&udc->lock, flags); 385 if (!value) 386 ep->halted = ep->wedged = 0; 387 else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) && 388 !list_empty(&ep->req_queue)) 389 ret = -EAGAIN; 390 else { 391 ep->halted = 1; 392 if (wedged) 393 ep->wedged = 1; 394 } 395 396 spin_unlock_irqrestore(&udc->lock, flags); 397 return ret; 398 } 399 400 static int 401 vep_set_halt(struct usb_ep *_ep, int value) 402 { 403 return vep_set_halt_and_wedge(_ep, value, 0); 404 } 405 406 static int vep_set_wedge(struct usb_ep *_ep) 407 { 408 return vep_set_halt_and_wedge(_ep, 1, 1); 409 } 410 411 static const struct usb_ep_ops vep_ops = { 412 .enable = vep_enable, 413 .disable = vep_disable, 414 415 .alloc_request = vep_alloc_request, 416 .free_request = vep_free_request, 417 418 .queue = vep_queue, 419 .dequeue = vep_dequeue, 420 421 .set_halt = vep_set_halt, 422 .set_wedge = vep_set_wedge, 423 }; 424 425 426 /* shutdown / reset / error handlers */ 427 428 static void vudc_shutdown(struct usbip_device *ud) 429 { 430 struct vudc *udc = container_of(ud, struct vudc, ud); 431 int call_disconnect = 0; 432 unsigned long flags; 433 434 dev_dbg(&udc->pdev->dev, "device shutdown"); 435 if (ud->tcp_socket) 436 kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR); 437 438 if (ud->tcp_rx) { 439 kthread_stop_put(ud->tcp_rx); 440 ud->tcp_rx = NULL; 441 } 442 if (ud->tcp_tx) { 443 kthread_stop_put(ud->tcp_tx); 444 ud->tcp_tx = NULL; 445 } 446 447 if (ud->tcp_socket) { 448 sockfd_put(ud->tcp_socket); 449 ud->tcp_socket = NULL; 450 } 451 452 spin_lock_irqsave(&udc->lock, flags); 453 stop_activity(udc); 454 if (udc->connected && udc->driver->disconnect) 455 call_disconnect = 1; 456 udc->connected = 0; 457 spin_unlock_irqrestore(&udc->lock, flags); 458 if (call_disconnect) 459 udc->driver->disconnect(&udc->gadget); 460 } 461 462 static void vudc_device_reset(struct usbip_device *ud) 463 { 464 struct vudc *udc = container_of(ud, struct vudc, ud); 465 unsigned long flags; 466 467 dev_dbg(&udc->pdev->dev, "device reset"); 468 spin_lock_irqsave(&udc->lock, flags); 469 stop_activity(udc); 470 spin_unlock_irqrestore(&udc->lock, flags); 471 if (udc->driver) 472 usb_gadget_udc_reset(&udc->gadget, udc->driver); 473 spin_lock_irqsave(&ud->lock, flags); 474 ud->status = SDEV_ST_AVAILABLE; 475 spin_unlock_irqrestore(&ud->lock, flags); 476 } 477 478 static void vudc_device_unusable(struct usbip_device *ud) 479 { 480 unsigned long flags; 481 482 spin_lock_irqsave(&ud->lock, flags); 483 ud->status = SDEV_ST_ERROR; 484 spin_unlock_irqrestore(&ud->lock, flags); 485 } 486 487 /* device setup / cleanup */ 488 489 struct vudc_device *alloc_vudc_device(int devid) 490 { 491 struct vudc_device *udc_dev = NULL; 492 493 udc_dev = kzalloc(sizeof(*udc_dev), GFP_KERNEL); 494 if (!udc_dev) 495 goto out; 496 497 INIT_LIST_HEAD(&udc_dev->dev_entry); 498 499 udc_dev->pdev = platform_device_alloc(GADGET_NAME, devid); 500 if (!udc_dev->pdev) { 501 kfree(udc_dev); 502 udc_dev = NULL; 503 } 504 505 out: 506 return udc_dev; 507 } 508 509 void put_vudc_device(struct vudc_device *udc_dev) 510 { 511 platform_device_put(udc_dev->pdev); 512 kfree(udc_dev); 513 } 514 515 static int init_vudc_hw(struct vudc *udc) 516 { 517 int i; 518 struct usbip_device *ud = &udc->ud; 519 struct vep *ep; 520 521 udc->ep = kcalloc(VIRTUAL_ENDPOINTS, sizeof(*udc->ep), GFP_KERNEL); 522 if (!udc->ep) 523 goto nomem_ep; 524 525 INIT_LIST_HEAD(&udc->gadget.ep_list); 526 527 /* create ep0 and 15 in, 15 out general purpose eps */ 528 for (i = 0; i < VIRTUAL_ENDPOINTS; ++i) { 529 int is_out = i % 2; 530 int num = (i + 1) / 2; 531 532 ep = &udc->ep[i]; 533 534 sprintf(ep->name, "ep%d%s", num, 535 i ? (is_out ? "out" : "in") : ""); 536 ep->ep.name = ep->name; 537 538 ep->ep.ops = &vep_ops; 539 540 usb_ep_set_maxpacket_limit(&ep->ep, ~0); 541 ep->ep.max_streams = 16; 542 ep->gadget = &udc->gadget; 543 INIT_LIST_HEAD(&ep->req_queue); 544 545 if (i == 0) { 546 /* ep0 */ 547 ep->ep.caps.type_control = true; 548 ep->ep.caps.dir_out = true; 549 ep->ep.caps.dir_in = true; 550 551 udc->gadget.ep0 = &ep->ep; 552 } else { 553 /* All other eps */ 554 ep->ep.caps.type_iso = true; 555 ep->ep.caps.type_int = true; 556 ep->ep.caps.type_bulk = true; 557 558 if (is_out) 559 ep->ep.caps.dir_out = true; 560 else 561 ep->ep.caps.dir_in = true; 562 563 list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list); 564 } 565 } 566 567 spin_lock_init(&udc->lock); 568 spin_lock_init(&udc->lock_tx); 569 INIT_LIST_HEAD(&udc->urb_queue); 570 INIT_LIST_HEAD(&udc->tx_queue); 571 init_waitqueue_head(&udc->tx_waitq); 572 573 spin_lock_init(&ud->lock); 574 ud->status = SDEV_ST_AVAILABLE; 575 ud->side = USBIP_VUDC; 576 577 ud->eh_ops.shutdown = vudc_shutdown; 578 ud->eh_ops.reset = vudc_device_reset; 579 ud->eh_ops.unusable = vudc_device_unusable; 580 581 v_init_timer(udc); 582 return 0; 583 584 nomem_ep: 585 return -ENOMEM; 586 } 587 588 static void cleanup_vudc_hw(struct vudc *udc) 589 { 590 kfree(udc->ep); 591 } 592 593 /* platform driver ops */ 594 595 int vudc_probe(struct platform_device *pdev) 596 { 597 struct vudc *udc; 598 int ret = -ENOMEM; 599 600 udc = kzalloc(sizeof(*udc), GFP_KERNEL); 601 if (!udc) 602 goto out; 603 604 udc->gadget.name = GADGET_NAME; 605 udc->gadget.ops = &vgadget_ops; 606 udc->gadget.max_speed = USB_SPEED_HIGH; 607 udc->gadget.dev.parent = &pdev->dev; 608 udc->pdev = pdev; 609 610 ret = init_vudc_hw(udc); 611 if (ret) 612 goto err_init_vudc_hw; 613 614 ret = usb_add_gadget_udc(&pdev->dev, &udc->gadget); 615 if (ret < 0) 616 goto err_add_udc; 617 618 ret = sysfs_create_group(&pdev->dev.kobj, &vudc_attr_group); 619 if (ret) { 620 dev_err(&udc->pdev->dev, "create sysfs files\n"); 621 goto err_sysfs; 622 } 623 624 platform_set_drvdata(pdev, udc); 625 626 return ret; 627 628 err_sysfs: 629 usb_del_gadget_udc(&udc->gadget); 630 err_add_udc: 631 cleanup_vudc_hw(udc); 632 err_init_vudc_hw: 633 kfree(udc); 634 out: 635 return ret; 636 } 637 638 int vudc_remove(struct platform_device *pdev) 639 { 640 struct vudc *udc = platform_get_drvdata(pdev); 641 642 sysfs_remove_group(&pdev->dev.kobj, &vudc_attr_group); 643 usb_del_gadget_udc(&udc->gadget); 644 cleanup_vudc_hw(udc); 645 kfree(udc); 646 return 0; 647 } 648