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 } 497