drivers/usb/usbip/vudc_transfer.c

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