usb/usbip/vudc_dev.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Copyright (C) 2015 Karol Kosik <karo9@interia.eu>
0004  * Copyright (C) 2015-2016 Samsung Electronics
0005  *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
0006  *               Krzysztof Opasiak <k.opasiak@samsung.com>
0007  */
0008
0009 #include <linux/device.h>
0010 #include <linux/kernel.h>
0011 #include <linux/list.h>
0012 #include <linux/platform_device.h>
0013 #include <linux/usb.h>
0014 #include <linux/usb/gadget.h>
0015 #include <linux/usb/hcd.h>
0016 #include <linux/kthread.h>
0017 #include <linux/file.h>
0018 #include <linux/byteorder/generic.h>
0019
0020 #include "usbip_common.h"
0021 #include "vudc.h"
0022
0023 #define VIRTUAL_ENDPOINTS (1 /* ep0 */ + 15 /* in eps */ + 15 /* out eps */)
0024
0025 /* urb-related structures alloc / free */
0026
0027
0028 static void free_urb(struct urb *urb)
0029 {
0030     if (!urb)
0031         return;
0032
0033     kfree(urb->setup_packet);
0034     urb->setup_packet = NULL;
0035
0036     kfree(urb->transfer_buffer);
0037     urb->transfer_buffer = NULL;
0038
0039     usb_free_urb(urb);
0040 }
0041
0042 struct urbp *alloc_urbp(void)
0043 {
0044     struct urbp *urb_p;
0045
0046     urb_p = kzalloc(sizeof(*urb_p), GFP_KERNEL);
0047     if (!urb_p)
0048         return urb_p;
0049
0050     urb_p->urb = NULL;
0051     urb_p->ep = NULL;
0052     INIT_LIST_HEAD(&urb_p->urb_entry);
0053     return urb_p;
0054 }
0055
0056 static void free_urbp(struct urbp *urb_p)
0057 {
0058     kfree(urb_p);
0059 }
0060
0061 void free_urbp_and_urb(struct urbp *urb_p)
0062 {
0063     if (!urb_p)
0064         return;
0065     free_urb(urb_p->urb);
0066     free_urbp(urb_p);
0067 }
0068
0069
0070 /* utilities ; almost verbatim from dummy_hcd.c */
0071
0072 /* called with spinlock held */
0073 static void nuke(struct vudc *udc, struct vep *ep)
0074 {
0075     struct vrequest *req;
0076
0077     while (!list_empty(&ep->req_queue)) {
0078         req = list_first_entry(&ep->req_queue, struct vrequest,
0079                        req_entry);
0080         list_del_init(&req->req_entry);
0081         req->req.status = -ESHUTDOWN;
0082
0083         spin_unlock(&udc->lock);
0084         usb_gadget_giveback_request(&ep->ep, &req->req);
0085         spin_lock(&udc->lock);
0086     }
0087 }
0088
0089 /* caller must hold lock */
0090 static void stop_activity(struct vudc *udc)
0091 {
0092     int i;
0093     struct urbp *urb_p, *tmp;
0094
0095     udc->address = 0;
0096
0097     for (i = 0; i < VIRTUAL_ENDPOINTS; i++)
0098         nuke(udc, &udc->ep[i]);
0099
0100     list_for_each_entry_safe(urb_p, tmp, &udc->urb_queue, urb_entry) {
0101         list_del(&urb_p->urb_entry);
0102         free_urbp_and_urb(urb_p);
0103     }
0104 }
0105
0106 struct vep *vudc_find_endpoint(struct vudc *udc, u8 address)
0107 {
0108     int i;
0109
0110     if ((address & ~USB_DIR_IN) == 0)
0111         return &udc->ep[0];
0112
0113     for (i = 1; i < VIRTUAL_ENDPOINTS; i++) {
0114         struct vep *ep = &udc->ep[i];
0115
0116         if (!ep->desc)
0117             continue;
0118         if (ep->desc->bEndpointAddress == address)
0119             return ep;
0120     }
0121     return NULL;
0122 }
0123
0124 /* gadget ops */
0125
0126 static int vgadget_get_frame(struct usb_gadget *_gadget)
0127 {
0128     struct timespec64 now;
0129     struct vudc *udc = usb_gadget_to_vudc(_gadget);
0130
0131     ktime_get_ts64(&now);
0132     return ((now.tv_sec - udc->start_time.tv_sec) * 1000 +
0133         (now.tv_nsec - udc->start_time.tv_nsec) / NSEC_PER_MSEC)
0134             & 0x7FF;
0135 }
0136
0137 static int vgadget_set_selfpowered(struct usb_gadget *_gadget, int value)
0138 {
0139     struct vudc *udc = usb_gadget_to_vudc(_gadget);
0140
0141     if (value)
0142         udc->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
0143     else
0144         udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
0145     return 0;
0146 }
0147
0148 static int vgadget_pullup(struct usb_gadget *_gadget, int value)
0149 {
0150     struct vudc *udc = usb_gadget_to_vudc(_gadget);
0151     unsigned long flags;
0152     int ret;
0153
0154
0155     spin_lock_irqsave(&udc->lock, flags);
0156     value = !!value;
0157     if (value == udc->pullup)
0158         goto unlock;
0159
0160     udc->pullup = value;
0161     if (value) {
0162         udc->gadget.speed = min_t(u8, USB_SPEED_HIGH,
0163                        udc->driver->max_speed);
0164         udc->ep[0].ep.maxpacket = 64;
0165         /*
0166          * This is the first place where we can ask our
0167          * gadget driver for descriptors.
0168          */
0169         ret = get_gadget_descs(udc);
0170         if (ret) {
0171             dev_err(&udc->gadget.dev, "Unable go get desc: %d", ret);
0172             goto unlock;
0173         }
0174
0175         spin_unlock_irqrestore(&udc->lock, flags);
0176         usbip_start_eh(&udc->ud);
0177     } else {
0178         /* Invalidate descriptors */
0179         udc->desc_cached = 0;
0180
0181         spin_unlock_irqrestore(&udc->lock, flags);
0182         usbip_event_add(&udc->ud, VUDC_EVENT_REMOVED);
0183         usbip_stop_eh(&udc->ud); /* Wait for eh completion */
0184     }
0185
0186     return 0;
0187
0188 unlock:
0189     spin_unlock_irqrestore(&udc->lock, flags);
0190     return 0;
0191 }
0192
0193 static int vgadget_udc_start(struct usb_gadget *g,
0194         struct usb_gadget_driver *driver)
0195 {
0196     struct vudc *udc = usb_gadget_to_vudc(g);
0197     unsigned long flags;
0198
0199     spin_lock_irqsave(&udc->lock, flags);
0200     udc->driver = driver;
0201     udc->pullup = udc->connected = udc->desc_cached = 0;
0202     spin_unlock_irqrestore(&udc->lock, flags);
0203
0204     return 0;
0205 }
0206
0207 static int vgadget_udc_stop(struct usb_gadget *g)
0208 {
0209     struct vudc *udc = usb_gadget_to_vudc(g);
0210     unsigned long flags;
0211
0212     spin_lock_irqsave(&udc->lock, flags);
0213     udc->driver = NULL;
0214     spin_unlock_irqrestore(&udc->lock, flags);
0215     return 0;
0216 }
0217
0218 static const struct usb_gadget_ops vgadget_ops = {
0219     .get_frame  = vgadget_get_frame,
0220     .set_selfpowered = vgadget_set_selfpowered,
0221     .pullup     = vgadget_pullup,
0222     .udc_start  = vgadget_udc_start,
0223     .udc_stop   = vgadget_udc_stop,
0224 };
0225
0226
0227 /* endpoint ops */
0228
0229 static int vep_enable(struct usb_ep *_ep,
0230         const struct usb_endpoint_descriptor *desc)
0231 {
0232     struct vep  *ep;
0233     struct vudc *udc;
0234     unsigned int    maxp;
0235     unsigned long   flags;
0236
0237     ep = to_vep(_ep);
0238     udc = ep_to_vudc(ep);
0239
0240     if (!_ep || !desc || ep->desc || _ep->caps.type_control
0241             || desc->bDescriptorType != USB_DT_ENDPOINT)
0242         return -EINVAL;
0243
0244     if (!udc->driver)
0245         return -ESHUTDOWN;
0246
0247     spin_lock_irqsave(&udc->lock, flags);
0248
0249     maxp = usb_endpoint_maxp(desc);
0250     _ep->maxpacket = maxp;
0251     ep->desc = desc;
0252     ep->type = usb_endpoint_type(desc);
0253     ep->halted = ep->wedged = 0;
0254
0255     spin_unlock_irqrestore(&udc->lock, flags);
0256
0257     return 0;
0258 }
0259
0260 static int vep_disable(struct usb_ep *_ep)
0261 {
0262     struct vep *ep;
0263     struct vudc *udc;
0264     unsigned long flags;
0265
0266     ep = to_vep(_ep);
0267     udc = ep_to_vudc(ep);
0268     if (!_ep || !ep->desc || _ep->caps.type_control)
0269         return -EINVAL;
0270
0271     spin_lock_irqsave(&udc->lock, flags);
0272     ep->desc = NULL;
0273     nuke(udc, ep);
0274     spin_unlock_irqrestore(&udc->lock, flags);
0275
0276     return 0;
0277 }
0278
0279 static struct usb_request *vep_alloc_request(struct usb_ep *_ep,
0280         gfp_t mem_flags)
0281 {
0282     struct vrequest *req;
0283
0284     if (!_ep)
0285         return NULL;
0286
0287     req = kzalloc(sizeof(*req), mem_flags);
0288     if (!req)
0289         return NULL;
0290
0291     INIT_LIST_HEAD(&req->req_entry);
0292
0293     return &req->req;
0294 }
0295
0296 static void vep_free_request(struct usb_ep *_ep, struct usb_request *_req)
0297 {
0298     struct vrequest *req;
0299
0300     /* ep is always valid here - see usb_ep_free_request() */
0301     if (!_req)
0302         return;
0303
0304     req = to_vrequest(_req);
0305     kfree(req);
0306 }
0307
0308 static int vep_queue(struct usb_ep *_ep, struct usb_request *_req,
0309         gfp_t mem_flags)
0310 {
0311     struct vep *ep;
0312     struct vrequest *req;
0313     struct vudc *udc;
0314     unsigned long flags;
0315
0316     if (!_ep || !_req)
0317         return -EINVAL;
0318
0319     ep = to_vep(_ep);
0320     req = to_vrequest(_req);
0321     udc = ep_to_vudc(ep);
0322
0323     spin_lock_irqsave(&udc->lock, flags);
0324     _req->actual = 0;
0325     _req->status = -EINPROGRESS;
0326
0327     list_add_tail(&req->req_entry, &ep->req_queue);
0328     spin_unlock_irqrestore(&udc->lock, flags);
0329
0330     return 0;
0331 }
0332
0333 static int vep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
0334 {
0335     struct vep *ep;
0336     struct vrequest *req;
0337     struct vudc *udc;
0338     struct vrequest *lst;
0339     unsigned long flags;
0340     int ret = -EINVAL;
0341
0342     if (!_ep || !_req)
0343         return ret;
0344
0345     ep = to_vep(_ep);
0346     req = to_vrequest(_req);
0347     udc = req->udc;
0348
0349     if (!udc->driver)
0350         return -ESHUTDOWN;
0351
0352     spin_lock_irqsave(&udc->lock, flags);
0353     list_for_each_entry(lst, &ep->req_queue, req_entry) {
0354         if (&lst->req == _req) {
0355             list_del_init(&lst->req_entry);
0356             _req->status = -ECONNRESET;
0357             ret = 0;
0358             break;
0359         }
0360     }
0361     spin_unlock_irqrestore(&udc->lock, flags);
0362
0363     if (ret == 0)
0364         usb_gadget_giveback_request(_ep, _req);
0365
0366     return ret;
0367 }
0368
0369 static int
0370 vep_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
0371 {
0372     struct vep *ep;
0373     struct vudc *udc;
0374     unsigned long flags;
0375     int ret = 0;
0376
0377     ep = to_vep(_ep);
0378     if (!_ep)
0379         return -EINVAL;
0380
0381     udc = ep_to_vudc(ep);
0382     if (!udc->driver)
0383         return -ESHUTDOWN;
0384
0385     spin_lock_irqsave(&udc->lock, flags);
0386     if (!value)
0387         ep->halted = ep->wedged = 0;
0388     else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
0389             !list_empty(&ep->req_queue))
0390         ret = -EAGAIN;
0391     else {
0392         ep->halted = 1;
0393         if (wedged)
0394             ep->wedged = 1;
0395     }
0396
0397     spin_unlock_irqrestore(&udc->lock, flags);
0398     return ret;
0399 }
0400
0401 static int
0402 vep_set_halt(struct usb_ep *_ep, int value)
0403 {
0404     return vep_set_halt_and_wedge(_ep, value, 0);
0405 }
0406
0407 static int vep_set_wedge(struct usb_ep *_ep)
0408 {
0409     return vep_set_halt_and_wedge(_ep, 1, 1);
0410 }
0411
0412 static const struct usb_ep_ops vep_ops = {
0413     .enable     = vep_enable,
0414     .disable    = vep_disable,
0415
0416     .alloc_request  = vep_alloc_request,
0417     .free_request   = vep_free_request,
0418
0419     .queue      = vep_queue,
0420     .dequeue    = vep_dequeue,
0421
0422     .set_halt   = vep_set_halt,
0423     .set_wedge  = vep_set_wedge,
0424 };
0425
0426
0427 /* shutdown / reset / error handlers */
0428
0429 static void vudc_shutdown(struct usbip_device *ud)
0430 {
0431     struct vudc *udc = container_of(ud, struct vudc, ud);
0432     int call_disconnect = 0;
0433     unsigned long flags;
0434
0435     dev_dbg(&udc->pdev->dev, "device shutdown");
0436     if (ud->tcp_socket)
0437         kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);
0438
0439     if (ud->tcp_rx) {
0440         kthread_stop_put(ud->tcp_rx);
0441         ud->tcp_rx = NULL;
0442     }
0443     if (ud->tcp_tx) {
0444         kthread_stop_put(ud->tcp_tx);
0445         ud->tcp_tx = NULL;
0446     }
0447
0448     if (ud->tcp_socket) {
0449         sockfd_put(ud->tcp_socket);
0450         ud->tcp_socket = NULL;
0451     }
0452
0453     spin_lock_irqsave(&udc->lock, flags);
0454     stop_activity(udc);
0455     if (udc->connected && udc->driver->disconnect)
0456         call_disconnect = 1;
0457     udc->connected = 0;
0458     spin_unlock_irqrestore(&udc->lock, flags);
0459     if (call_disconnect)
0460         udc->driver->disconnect(&udc->gadget);
0461 }
0462
0463 static void vudc_device_reset(struct usbip_device *ud)
0464 {
0465     struct vudc *udc = container_of(ud, struct vudc, ud);
0466     unsigned long flags;
0467
0468     dev_dbg(&udc->pdev->dev, "device reset");
0469     spin_lock_irqsave(&udc->lock, flags);
0470     stop_activity(udc);
0471     spin_unlock_irqrestore(&udc->lock, flags);
0472     if (udc->driver)
0473         usb_gadget_udc_reset(&udc->gadget, udc->driver);
0474     spin_lock_irqsave(&ud->lock, flags);
0475     ud->status = SDEV_ST_AVAILABLE;
0476     spin_unlock_irqrestore(&ud->lock, flags);
0477 }
0478
0479 static void vudc_device_unusable(struct usbip_device *ud)
0480 {
0481     unsigned long flags;
0482
0483     spin_lock_irqsave(&ud->lock, flags);
0484     ud->status = SDEV_ST_ERROR;
0485     spin_unlock_irqrestore(&ud->lock, flags);
0486 }
0487
0488 /* device setup / cleanup */
0489
0490 struct vudc_device *alloc_vudc_device(int devid)
0491 {
0492     struct vudc_device *udc_dev = NULL;
0493
0494     udc_dev = kzalloc(sizeof(*udc_dev), GFP_KERNEL);
0495     if (!udc_dev)
0496         goto out;
0497
0498     INIT_LIST_HEAD(&udc_dev->dev_entry);
0499
0500     udc_dev->pdev = platform_device_alloc(GADGET_NAME, devid);
0501     if (!udc_dev->pdev) {
0502         kfree(udc_dev);
0503         udc_dev = NULL;
0504     }
0505
0506 out:
0507     return udc_dev;
0508 }
0509
0510 void put_vudc_device(struct vudc_device *udc_dev)
0511 {
0512     platform_device_put(udc_dev->pdev);
0513     kfree(udc_dev);
0514 }
0515
0516 static int init_vudc_hw(struct vudc *udc)
0517 {
0518     int i;
0519     struct usbip_device *ud = &udc->ud;
0520     struct vep *ep;
0521
0522     udc->ep = kcalloc(VIRTUAL_ENDPOINTS, sizeof(*udc->ep), GFP_KERNEL);
0523     if (!udc->ep)
0524         goto nomem_ep;
0525
0526     INIT_LIST_HEAD(&udc->gadget.ep_list);
0527
0528     /* create ep0 and 15 in, 15 out general purpose eps */
0529     for (i = 0; i < VIRTUAL_ENDPOINTS; ++i) {
0530         int is_out = i % 2;
0531         int num = (i + 1) / 2;
0532
0533         ep = &udc->ep[i];
0534
0535         sprintf(ep->name, "ep%d%s", num,
0536             i ? (is_out ? "out" : "in") : "");
0537         ep->ep.name = ep->name;
0538
0539         ep->ep.ops = &vep_ops;
0540
0541         usb_ep_set_maxpacket_limit(&ep->ep, ~0);
0542         ep->ep.max_streams = 16;
0543         ep->gadget = &udc->gadget;
0544         INIT_LIST_HEAD(&ep->req_queue);
0545
0546         if (i == 0) {
0547             /* ep0 */
0548             ep->ep.caps.type_control = true;
0549             ep->ep.caps.dir_out = true;
0550             ep->ep.caps.dir_in = true;
0551
0552             udc->gadget.ep0 = &ep->ep;
0553         } else {
0554             /* All other eps */
0555             ep->ep.caps.type_iso = true;
0556             ep->ep.caps.type_int = true;
0557             ep->ep.caps.type_bulk = true;
0558
0559             if (is_out)
0560                 ep->ep.caps.dir_out = true;
0561             else
0562                 ep->ep.caps.dir_in = true;
0563
0564             list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
0565         }
0566     }
0567
0568     spin_lock_init(&udc->lock);
0569     spin_lock_init(&udc->lock_tx);
0570     INIT_LIST_HEAD(&udc->urb_queue);
0571     INIT_LIST_HEAD(&udc->tx_queue);
0572     init_waitqueue_head(&udc->tx_waitq);
0573
0574     spin_lock_init(&ud->lock);
0575     mutex_init(&ud->sysfs_lock);
0576     ud->status = SDEV_ST_AVAILABLE;
0577     ud->side = USBIP_VUDC;
0578
0579     ud->eh_ops.shutdown = vudc_shutdown;
0580     ud->eh_ops.reset    = vudc_device_reset;
0581     ud->eh_ops.unusable = vudc_device_unusable;
0582
0583     v_init_timer(udc);
0584     return 0;
0585
0586 nomem_ep:
0587         return -ENOMEM;
0588 }
0589
0590 static void cleanup_vudc_hw(struct vudc *udc)
0591 {
0592     kfree(udc->ep);
0593 }
0594
0595 /* platform driver ops */
0596
0597 int vudc_probe(struct platform_device *pdev)
0598 {
0599     struct vudc *udc;
0600     int ret = -ENOMEM;
0601
0602     udc = kzalloc(sizeof(*udc), GFP_KERNEL);
0603     if (!udc)
0604         goto out;
0605
0606     udc->gadget.name = GADGET_NAME;
0607     udc->gadget.ops = &vgadget_ops;
0608     udc->gadget.max_speed = USB_SPEED_HIGH;
0609     udc->gadget.dev.parent = &pdev->dev;
0610     udc->pdev = pdev;
0611
0612     ret = init_vudc_hw(udc);
0613     if (ret)
0614         goto err_init_vudc_hw;
0615
0616     ret = usb_add_gadget_udc(&pdev->dev, &udc->gadget);
0617     if (ret < 0)
0618         goto err_add_udc;
0619
0620     platform_set_drvdata(pdev, udc);
0621
0622     return ret;
0623
0624 err_add_udc:
0625     cleanup_vudc_hw(udc);
0626 err_init_vudc_hw:
0627     kfree(udc);
0628 out:
0629     return ret;
0630 }
0631
0632 int vudc_remove(struct platform_device *pdev)
0633 {
0634     struct vudc *udc = platform_get_drvdata(pdev);
0635
0636     usb_del_gadget_udc(&udc->gadget);
0637     cleanup_vudc_hw(udc);
0638     kfree(udc);
0639     return 0;
0640 }