drivers/usb/usbip/vudc_transfer.c

   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  *
   7  * Based on dummy_hcd.c, which is:
   8  * Copyright (C) 2003 David Brownell
   9  * Copyright (C) 2003-2005 Alan Stern
  10  */
  11
  12 #include <linux/usb.h>
  13 #include <linux/timer.h>
  14 #include <linux/usb/ch9.h>
  15
  16 #include "vudc.h"
  17
  18 #define DEV_REQUEST     (USB_TYPE_STANDARD | USB_RECIP_DEVICE)
  19 #define DEV_INREQUEST   (DEV_REQUEST | USB_DIR_IN)
  20 #define INTF_REQUEST    (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
  21 #define INTF_INREQUEST  (INTF_REQUEST | USB_DIR_IN)
  22 #define EP_REQUEST      (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
  23 #define EP_INREQUEST    (EP_REQUEST | USB_DIR_IN)
  24
  25 static int get_frame_limit(enum usb_device_speed speed)
  26 {
  27         switch (speed) {
  28         case USB_SPEED_LOW:
  29                 return 8 /*bytes*/ * 12 /*packets*/;
  30         case USB_SPEED_FULL:
  31                 return 64 /*bytes*/ * 19 /*packets*/;
  32         case USB_SPEED_HIGH:
  33                 return 512 /*bytes*/ * 13 /*packets*/ * 8 /*uframes*/;
  34         case USB_SPEED_SUPER:
  35                 /* Bus speed is 500000 bytes/ms, so use a little less */
  36                 return 490000;
  37         default:
  38                 /* error */
  39                 return -1;
  40         }
  41
  42 }
  43
  44 /*
  45  * handle_control_request() - handles all control transfers
  46  * @udc: pointer to vudc
  47  * @urb: the urb request to handle
  48  * @setup: pointer to the setup data for a USB device control
  49  *       request
  50  * @status: pointer to request handling status
  51  *
  52  * Return 0 - if the request was handled
  53  *        1 - if the request wasn't handles
  54  *        error code on error
  55  *
  56  * Adapted from drivers/usb/gadget/udc/dummy_hcd.c
  57  */
  58 static int handle_control_request(struct vudc *udc, struct urb *urb,
  59                                   struct usb_ctrlrequest *setup,
  60                                   int *status)
  61 {
  62         struct vep      *ep2;
  63         int             ret_val = 1;
  64         unsigned int    w_index;
  65         unsigned int    w_value;
  66
  67         w_index = le16_to_cpu(setup->wIndex);
  68         w_value = le16_to_cpu(setup->wValue);
  69         switch (setup->bRequest) {
  70         case USB_REQ_SET_ADDRESS:
  71                 if (setup->bRequestType != DEV_REQUEST)
  72                         break;
  73                 udc->address = w_value;
  74                 ret_val = 0;
  75                 *status = 0;
  76                 break;
  77         case USB_REQ_SET_FEATURE:
  78                 if (setup->bRequestType == DEV_REQUEST) {
  79                         ret_val = 0;
  80                         switch (w_value) {
  81                         case USB_DEVICE_REMOTE_WAKEUP:
  82                                 break;
  83                         case USB_DEVICE_B_HNP_ENABLE:
  84                                 udc->gadget.b_hnp_enable = 1;
  85                                 break;
  86                         case USB_DEVICE_A_HNP_SUPPORT:
  87                                 udc->gadget.a_hnp_support = 1;
  88                                 break;
  89                         case USB_DEVICE_A_ALT_HNP_SUPPORT:
  90                                 udc->gadget.a_alt_hnp_support = 1;
  91                                 break;
  92                         default:
  93                                 ret_val = -EOPNOTSUPP;
  94                         }
  95                         if (ret_val == 0) {
  96                                 udc->devstatus |= (1 << w_value);
  97                                 *status = 0;
  98                         }
  99                 } else if (setup->bRequestType == EP_REQUEST) {
 100                         /* endpoint halt */
 101                         ep2 = vudc_find_endpoint(udc, w_index);
 102                         if (!ep2 || ep2->ep.name == udc->ep[0].ep.name) {
 103                                 ret_val = -EOPNOTSUPP;
 104                                 break;
 105                         }
 106                         ep2->halted = 1;
 107                         ret_val = 0;
 108                         *status = 0;
 109                 }
 110                 break;
 111         case USB_REQ_CLEAR_FEATURE:
 112                 if (setup->bRequestType == DEV_REQUEST) {
 113                         ret_val = 0;
 114                         switch (w_value) {
 115                         case USB_DEVICE_REMOTE_WAKEUP:
 116                                 w_value = USB_DEVICE_REMOTE_WAKEUP;
 117                                 break;
 118
 119                         case USB_DEVICE_U1_ENABLE:
 120                         case USB_DEVICE_U2_ENABLE:
 121                         case USB_DEVICE_LTM_ENABLE:
 122                                 ret_val = -EOPNOTSUPP;
 123                                 break;
 124                         default:
 125                                 ret_val = -EOPNOTSUPP;
 126                                 break;
 127                         }
 128                         if (ret_val == 0) {
 129                                 udc->devstatus &= ~(1 << w_value);
 130                                 *status = 0;
 131                         }
 132                 } else if (setup->bRequestType == EP_REQUEST) {
 133                         /* endpoint halt */
 134                         ep2 = vudc_find_endpoint(udc, w_index);
 135                         if (!ep2) {
 136                                 ret_val = -EOPNOTSUPP;
 137                                 break;
 138                         }
 139                         if (!ep2->wedged)
 140                                 ep2->halted = 0;
 141                         ret_val = 0;
 142                         *status = 0;
 143                 }
 144                 break;
 145         case USB_REQ_GET_STATUS:
 146                 if (setup->bRequestType == DEV_INREQUEST
 147                                 || setup->bRequestType == INTF_INREQUEST
 148                                 || setup->bRequestType == EP_INREQUEST) {
 149                         char *buf;
 150                         /*
 151                          * device: remote wakeup, selfpowered
 152                          * interface: nothing
 153                          * endpoint: halt
 154                          */
 155                         buf = (char *)urb->transfer_buffer;
 156                         if (urb->transfer_buffer_length > 0) {
 157                                 if (setup->bRequestType == EP_INREQUEST) {
 158                                         ep2 = vudc_find_endpoint(udc, w_index);
 159                                         if (!ep2) {
 160                                                 ret_val = -EOPNOTSUPP;
 161                                                 break;
 162                                         }
 163                                         buf[0] = ep2->halted;
 164                                 } else if (setup->bRequestType ==
 165                                            DEV_INREQUEST) {
 166                                         buf[0] = (u8)udc->devstatus;
 167                                 } else
 168                                         buf[0] = 0;
 169                         }
 170                         if (urb->transfer_buffer_length > 1)
 171                                 buf[1] = 0;
 172                         urb->actual_length = min_t(u32, 2,
 173                                 urb->transfer_buffer_length);
 174                         ret_val = 0;
 175                         *status = 0;
 176                 }
 177                 break;
 178         }
 179         return ret_val;
 180 }
 181
 182 /* Adapted from dummy_hcd.c ; caller must hold lock */
 183 static int transfer(struct vudc *udc,
 184                 struct urb *urb, struct vep *ep, int limit)
 185 {
 186         struct vrequest *req;
 187         int sent = 0;
 188 top:
 189         /* if there's no request queued, the device is NAKing; return */
 190         list_for_each_entry(req, &ep->req_queue, req_entry) {
 191                 unsigned int    host_len, dev_len, len;
 192                 void            *ubuf_pos, *rbuf_pos;
 193                 int             is_short, to_host;
 194                 int             rescan = 0;
 195
 196                 /*
 197                  * 1..N packets of ep->ep.maxpacket each ... the last one
 198                  * may be short (including zero length).
 199                  *
 200                  * writer can send a zlp explicitly (length 0) or implicitly
 201                  * (length mod maxpacket zero, and 'zero' flag); they always
 202                  * terminate reads.
 203                  */
 204                 host_len = urb->transfer_buffer_length - urb->actual_length;
 205                 dev_len = req->req.length - req->req.actual;
 206                 len = min(host_len, dev_len);
 207
 208                 to_host = usb_pipein(urb->pipe);
 209                 if (unlikely(len == 0))
 210                         is_short = 1;
 211                 else {
 212                         /* send multiple of maxpacket first, then remainder */
 213                         if (len >= ep->ep.maxpacket) {
 214                                 is_short = 0;
 215                                 if (len % ep->ep.maxpacket > 0)
 216                                         rescan = 1;
 217                                 len -= len % ep->ep.maxpacket;
 218                         } else {
 219                                 is_short = 1;
 220                         }
 221
 222                         ubuf_pos = urb->transfer_buffer + urb->actual_length;
 223                         rbuf_pos = req->req.buf + req->req.actual;
 224
 225                         if (urb->pipe & USB_DIR_IN)
 226                                 memcpy(ubuf_pos, rbuf_pos, len);
 227                         else
 228                                 memcpy(rbuf_pos, ubuf_pos, len);
 229
 230                         urb->actual_length += len;
 231                         req->req.actual += len;
 232                         sent += len;
 233                 }
 234
 235                 /*
 236                  * short packets terminate, maybe with overflow/underflow.
 237                  * it's only really an error to write too much.
 238                  *
 239                  * partially filling a buffer optionally blocks queue advances
 240                  * (so completion handlers can clean up the queue) but we don't
 241                  * need to emulate such data-in-flight.
 242                  */
 243                 if (is_short) {
 244                         if (host_len == dev_len) {
 245                                 req->req.status = 0;
 246                                 urb->status = 0;
 247                         } else if (to_host) {
 248                                 req->req.status = 0;
 249                                 if (dev_len > host_len)
 250                                         urb->status = -EOVERFLOW;
 251                                 else
 252                                         urb->status = 0;
 253                         } else {
 254                                 urb->status = 0;
 255                                 if (host_len > dev_len)
 256                                         req->req.status = -EOVERFLOW;
 257                                 else
 258                                         req->req.status = 0;
 259                         }
 260
 261                 /* many requests terminate without a short packet */
 262                 /* also check if we need to send zlp */
 263                 } else {
 264                         if (req->req.length == req->req.actual) {
 265                                 if (req->req.zero && to_host)
 266                                         rescan = 1;
 267                                 else
 268                                         req->req.status = 0;
 269                         }
 270                         if (urb->transfer_buffer_length == urb->actual_length) {
 271                                 if (urb->transfer_flags & URB_ZERO_PACKET &&
 272                                     !to_host)
 273                                         rescan = 1;
 274                                 else
 275                                         urb->status = 0;
 276                         }
 277                 }
 278
 279                 /* device side completion --> continuable */
 280                 if (req->req.status != -EINPROGRESS) {
 281
 282                         list_del_init(&req->req_entry);
 283                         spin_unlock(&udc->lock);
 284                         usb_gadget_giveback_request(&ep->ep, &req->req);
 285                         spin_lock(&udc->lock);
 286
 287                         /* requests might have been unlinked... */
 288                         rescan = 1;
 289                 }
 290
 291                 /* host side completion --> terminate */
 292                 if (urb->status != -EINPROGRESS)
 293                         break;
 294
 295                 /* rescan to continue with any other queued i/o */
 296                 if (rescan)
 297                         goto top;
 298         }
 299         return sent;
 300 }
 301
 302 static void v_timer(struct timer_list *t)
 303 {
 304         struct vudc *udc = from_timer(udc, t, tr_timer.timer);
 305         struct transfer_timer *timer = &udc->tr_timer;
 306         struct urbp *urb_p, *tmp;
 307         unsigned long flags;
 308         struct usb_ep *_ep;
 309         struct vep *ep;
 310         int ret = 0;
 311         int total, limit;
 312
 313         spin_lock_irqsave(&udc->lock, flags);
 314
 315         total = get_frame_limit(udc->gadget.speed);
 316         if (total < 0) {        /* unknown speed, or not set yet */
 317                 timer->state = VUDC_TR_IDLE;
 318                 spin_unlock_irqrestore(&udc->lock, flags);
 319                 return;
 320         }
 321         /* is it next frame now? */
 322         if (time_after(jiffies, timer->frame_start + msecs_to_jiffies(1))) {
 323                 timer->frame_limit = total;
 324                 /* FIXME: how to make it accurate? */
 325                 timer->frame_start = jiffies;
 326         } else {
 327                 total = timer->frame_limit;
 328         }
 329
 330         /* We have to clear ep0 flags separately as it's not on the list */
 331         udc->ep[0].already_seen = 0;
 332         list_for_each_entry(_ep, &udc->gadget.ep_list, ep_list) {
 333                 ep = to_vep(_ep);
 334                 ep->already_seen = 0;
 335         }
 336
 337 restart:
 338         list_for_each_entry_safe(urb_p, tmp, &udc->urb_queue, urb_entry) {
 339                 struct urb *urb = urb_p->urb;
 340
 341                 ep = urb_p->ep;
 342                 if (urb->unlinked)
 343                         goto return_urb;
 344                 if (timer->state != VUDC_TR_RUNNING)
 345                         continue;
 346
 347                 if (!ep) {
 348                         urb->status = -EPROTO;
 349                         goto return_urb;
 350                 }
 351
 352                 /* Used up bandwidth? */
 353                 if (total <= 0 && ep->type == USB_ENDPOINT_XFER_BULK)
 354                         continue;
 355
 356                 if (ep->already_seen)
 357                         continue;
 358                 ep->already_seen = 1;
 359                 if (ep == &udc->ep[0] && urb_p->new) {
 360                         ep->setup_stage = 1;
 361                         urb_p->new = 0;
 362                 }
 363                 if (ep->halted && !ep->setup_stage) {
 364                         urb->status = -EPIPE;
 365                         goto return_urb;
 366                 }
 367
 368                 if (ep == &udc->ep[0] && ep->setup_stage) {
 369                         /* TODO - flush any stale requests */
 370                         ep->setup_stage = 0;
 371                         ep->halted = 0;
 372
 373                         ret = handle_control_request(udc, urb,
 374                                 (struct usb_ctrlrequest *) urb->setup_packet,
 375                                 (&urb->status));
 376                         if (ret > 0) {
 377                                 spin_unlock(&udc->lock);
 378                                 ret = udc->driver->setup(&udc->gadget,
 379                                         (struct usb_ctrlrequest *)
 380                                         urb->setup_packet);
 381                                 spin_lock(&udc->lock);
 382                         }
 383                         if (ret >= 0) {
 384                                 /* no delays (max 64kb data stage) */
 385                                 limit = 64 * 1024;
 386                                 goto treat_control_like_bulk;
 387                         } else {
 388                                 urb->status = -EPIPE;
 389                                 urb->actual_length = 0;
 390                                 goto return_urb;
 391                         }
 392                 }
 393
 394                 limit = total;
 395                 switch (ep->type) {
 396                 case USB_ENDPOINT_XFER_ISOC:
 397                         /* TODO: support */
 398                         urb->status = -EXDEV;
 399                         break;
 400
 401                 case USB_ENDPOINT_XFER_INT:
 402                         /*
 403                          * TODO: figure out bandwidth guarantees
 404                          * for now, give unlimited bandwidth
 405                          */
 406                         limit += urb->transfer_buffer_length;
 407                         /* fallthrough */
 408                 default:
 409 treat_control_like_bulk:
 410                         total -= transfer(udc, urb, ep, limit);
 411                 }
 412                 if (urb->status == -EINPROGRESS)
 413                         continue;
 414
 415 return_urb:
 416                 if (ep)
 417                         ep->already_seen = ep->setup_stage = 0;
 418
 419                 spin_lock(&udc->lock_tx);
 420                 list_del(&urb_p->urb_entry);
 421                 if (!urb->unlinked) {
 422                         v_enqueue_ret_submit(udc, urb_p);
 423                 } else {
 424                         v_enqueue_ret_unlink(udc, urb_p->seqnum,
 425                                              urb->unlinked);
 426                         free_urbp_and_urb(urb_p);
 427                 }
 428                 wake_up(&udc->tx_waitq);
 429                 spin_unlock(&udc->lock_tx);
 430
 431                 goto restart;
 432         }
 433
 434         /* TODO - also wait on empty usb_request queues? */
 435         if (list_empty(&udc->urb_queue))
 436                 timer->state = VUDC_TR_IDLE;
 437         else
 438                 mod_timer(&timer->timer,
 439                           timer->frame_start + msecs_to_jiffies(1));
 440
 441         spin_unlock_irqrestore(&udc->lock, flags);
 442 }
 443
 444 /* All timer functions are run with udc->lock held */
 445
 446 void v_init_timer(struct vudc *udc)
 447 {
 448         struct transfer_timer *t = &udc->tr_timer;
 449
 450         timer_setup(&t->timer, v_timer, 0);
 451         t->state = VUDC_TR_STOPPED;
 452 }
 453
 454 void v_start_timer(struct vudc *udc)
 455 {
 456         struct transfer_timer *t = &udc->tr_timer;
 457
 458         dev_dbg(&udc->pdev->dev, "timer start");
 459         switch (t->state) {
 460         case VUDC_TR_RUNNING:
 461                 return;
 462         case VUDC_TR_IDLE:
 463                 return v_kick_timer(udc, jiffies);
 464         case VUDC_TR_STOPPED:
 465                 t->state = VUDC_TR_IDLE;
 466                 t->frame_start = jiffies;
 467                 t->frame_limit = get_frame_limit(udc->gadget.speed);
 468                 return v_kick_timer(udc, jiffies);
 469         }
 470 }
 471
 472 void v_kick_timer(struct vudc *udc, unsigned long time)
 473 {
 474         struct transfer_timer *t = &udc->tr_timer;
 475
 476         dev_dbg(&udc->pdev->dev, "timer kick");
 477         switch (t->state) {
 478         case VUDC_TR_RUNNING:
 479                 return;
 480         case VUDC_TR_IDLE:
 481                 t->state = VUDC_TR_RUNNING;
 482                 /* fallthrough */
 483         case VUDC_TR_STOPPED:
 484                 /* we may want to kick timer to unqueue urbs */
 485                 mod_timer(&t->timer, time);
 486         }
 487 }
 488
 489 void v_stop_timer(struct vudc *udc)
 490 {
 491         struct transfer_timer *t = &udc->tr_timer;
 492
 493         /* timer itself will take care of stopping */
 494         dev_dbg(&udc->pdev->dev, "timer stop");
 495         t->state = VUDC_TR_STOPPED;
 496 }