// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2015 Karol Kosik <[email protected]>
* Copyright (C) 2015-2016 Samsung Electronics
* Igor Kotrasinski <[email protected]>
*
* Based on dummy_hcd.c, which is:
* Copyright (C) 2003 David Brownell
* Copyright (C) 2003-2005 Alan Stern
*/
#include <linux/usb.h>
#include <linux/timer.h>
#include <linux/usb/ch9.h>
#include "vudc.h"
#define DEV_REQUEST (USB_TYPE_STANDARD | USB_RECIP_DEVICE)
#define DEV_INREQUEST (DEV_REQUEST | USB_DIR_IN)
#define INTF_REQUEST (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
#define INTF_INREQUEST (INTF_REQUEST | USB_DIR_IN)
#define EP_REQUEST (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
#define EP_INREQUEST (EP_REQUEST | USB_DIR_IN)
static int get_frame_limit(enum usb_device_speed speed)
{
switch (speed) {
case USB_SPEED_LOW:
return 8 /*bytes*/ * 12 /*packets*/;
case USB_SPEED_FULL:
return 64 /*bytes*/ * 19 /*packets*/;
case USB_SPEED_HIGH:
return 512 /*bytes*/ * 13 /*packets*/ * 8 /*uframes*/;
case USB_SPEED_SUPER:
/* Bus speed is 500000 bytes/ms, so use a little less */
return 490000;
default:
/* error */
return -1;
}
}
/*
* handle_control_request() - handles all control transfers
* @udc: pointer to vudc
* @urb: the urb request to handle
* @setup: pointer to the setup data for a USB device control
* request
* @status: pointer to request handling status
*
* Return 0 - if the request was handled
* 1 - if the request wasn't handles
* error code on error
*
* Adapted from drivers/usb/gadget/udc/dummy_hcd.c
*/
static int handle_control_request(struct vudc *udc, struct urb *urb,
struct usb_ctrlrequest *setup,
int *status)
{
struct vep *ep2;
int ret_val = 1;
unsigned int w_index;
unsigned int w_value;
w_index = le16_to_cpu(setup->wIndex);
w_value = le16_to_cpu(setup->wValue);
switch (setup->bRequest) {
case USB_REQ_SET_ADDRESS:
if (setup->bRequestType != DEV_REQUEST)
break;
udc->address = w_value;
ret_val = 0;
*status = 0;
break;
case USB_REQ_SET_FEATURE:
if (setup->bRequestType == DEV_REQUEST) {
ret_val = 0;
switch (w_value) {
case USB_DEVICE_REMOTE_WAKEUP:
break;
case USB_DEVICE_B_HNP_ENABLE:
udc->gadget.b_hnp_enable = 1;
break;
case USB_DEVICE_A_HNP_SUPPORT:
udc->gadget.a_hnp_support = 1;
break;
case USB_DEVICE_A_ALT_HNP_SUPPORT:
udc->gadget.a_alt_hnp_support = 1;
break;
default:
ret_val = -EOPNOTSUPP;
}
if (ret_val == 0) {
udc->devstatus |= (1 << w_value);
*status = 0;
}
} else if (setup->bRequestType == EP_REQUEST) {
/* endpoint halt */
ep2 = vudc_find_endpoint(udc, w_index);
if (!ep2 || ep2->ep.name == udc->ep[0].ep.name) {
ret_val = -EOPNOTSUPP;
break;
}
ep2->halted = 1;
ret_val = 0;
*status = 0;
}
break;
case USB_REQ_CLEAR_FEATURE:
if (setup->bRequestType == DEV_REQUEST) {
ret_val = 0;
switch (w_value) {
case USB_DEVICE_REMOTE_WAKEUP:
w_value = USB_DEVICE_REMOTE_WAKEUP;
break;
case USB_DEVICE_U1_ENABLE:
case USB_DEVICE_U2_ENABLE:
case USB_DEVICE_LTM_ENABLE:
ret_val = -EOPNOTSUPP;
break;
default:
ret_val = -EOPNOTSUPP;
break;
}
if (ret_val == 0) {
udc->devstatus &= ~(1 << w_value);
*status = 0;
}
} else if (setup->bRequestType == EP_REQUEST) {
/* endpoint halt */
ep2 = vudc_find_endpoint(udc, w_index);
if (!ep2) {
ret_val = -EOPNOTSUPP;
break;
}
if (!ep2->wedged)
ep2->halted = 0;
ret_val = 0;
*status = 0;
}
break;
case USB_REQ_GET_STATUS:
if (setup->bRequestType == DEV_INREQUEST
|| setup->bRequestType == INTF_INREQUEST
|| setup->bRequestType == EP_INREQUEST) {
char *buf;
/*
* device: remote wakeup, selfpowered
* interface: nothing
* endpoint: halt
*/
buf = (char *)urb->transfer_buffer;
if (urb->transfer_buffer_length > 0) {
if (setup->bRequestType == EP_INREQUEST) {
ep2 = vudc_find_endpoint(udc, w_index);
if (!ep2) {
ret_val = -EOPNOTSUPP;
break;
}
buf[0] = ep2->halted;
} else if (setup->bRequestType ==
DEV_INREQUEST) {
buf[0] = (u8)udc->devstatus;
} else
buf[0] = 0;
}
if (urb->transfer_buffer_length > 1)
buf[1] = 0;
urb->actual_length = min_t(u32, 2,
urb->transfer_buffer_length);
ret_val = 0;
*status = 0;
}
break;
}
return ret_val;
}
/* Adapted from dummy_hcd.c ; caller must hold lock */
static int transfer(struct vudc *udc,
struct urb *urb, struct vep *ep, int limit)
{
struct vrequest *req;
int sent = 0;
top:
/* if there's no request queued, the device is NAKing; return */
list_for_each_entry(req, &ep->req_queue, req_entry) {
unsigned int host_len, dev_len, len;
void *ubuf_pos, *rbuf_pos;
int is_short, to_host;
int rescan = 0;
/*
* 1..N packets of ep->ep.maxpacket each ... the last one
* may be short (including zero length).
*
* writer can send a zlp explicitly (length 0) or implicitly
* (length mod maxpacket zero, and 'zero' flag); they always
* terminate reads.
*/
host_len = urb->transfer_buffer_length - urb->actual_length;
dev_len = req->req.length - req->req.actual;
len = min(host_len, dev_len);
to_host = usb_pipein(urb->pipe);
if (unlikely(len == 0))
is_short = 1;
else {
/* send multiple of maxpacket first, then remainder */
if (len >= ep->ep.maxpacket) {
is_short = 0;
if (len % ep->ep.maxpacket > 0)
rescan = 1;
len -= len % ep->ep.maxpacket;
} else {
is_short = 1;
}
ubuf_pos = urb->transfer_buffer + urb->actual_length;
rbuf_pos = req->req.buf + req->req.actual;
if (urb->pipe & USB_DIR_IN)
memcpy(ubuf_pos, rbuf_pos, len);
else
memcpy(rbuf_pos, ubuf_pos, len);
urb->actual_length += len;
req->req.actual += len;
sent += len;
}
/*
* short packets terminate, maybe with overflow/underflow.
* it's only really an error to write too much.
*
* partially filling a buffer optionally blocks queue advances
* (so completion handlers can clean up the queue) but we don't
* need to emulate such data-in-flight.
*/
if (is_short) {
if (host_len == dev_len) {
req->req.status = 0;
urb->status = 0;
} else if (to_host) {
req->req.status = 0;
if (dev_len > host_len)
urb->status = -EOVERFLOW;
else
urb->status = 0;
} else {
urb->status = 0;
if (host_len > dev_len)
req->req.status = -EOVERFLOW;
else
req->req.status = 0;
}
/* many requests terminate without a short packet */
/* also check if we need to send zlp */
} else {
if (req->req.length == req->req.actual) {
if (req->req.zero && to_host)
rescan = 1;
else
req->req.status = 0;
}
if (urb->transfer_buffer_length == urb->actual_length) {
if (urb->transfer_flags & URB_ZERO_PACKET &&
!to_host)
rescan = 1;
else
urb->status = 0;
}
}
/* device side completion --> continuable */
if (req->req.status != -EINPROGRESS) {
list_del_init(&req->req_entry);
spin_unlock(&udc->lock);
usb_gadget_giveback_request(&ep->ep, &req->req);
spin_lock(&udc->lock);
/* requests might have been unlinked... */
rescan = 1;
}
/* host side completion --> terminate */
if (urb->status != -EINPROGRESS)
break;
/* rescan to continue with any other queued i/o */
if (rescan)
goto top;
}
return sent;
}
static void v_timer(struct timer_list *t)
{
struct vudc *udc = from_timer(udc, t, tr_timer.timer);
struct transfer_timer *timer = &udc->tr_timer;
struct urbp *urb_p, *tmp;
unsigned long flags;
struct usb_ep *_ep;
struct vep *ep;
int ret = 0;
int total, limit;
spin_lock_irqsave(&udc->lock, flags);
total = get_frame_limit(udc->gadget.speed);
if (total < 0) { /* unknown speed, or not set yet */
timer->state = VUDC_TR_IDLE;
spin_unlock_irqrestore(&udc->lock, flags);
return;
}
/* is it next frame now? */
if (time_after(jiffies, timer->frame_start + msecs_to_jiffies(1))) {
timer->frame_limit = total;
/* FIXME: how to make it accurate? */
timer->frame_start = jiffies;
} else {
total = timer->frame_limit;
}
/* We have to clear ep0 flags separately as it's not on the list */
udc->ep[0].already_seen = 0;
list_for_each_entry(_ep, &udc->gadget.ep_list, ep_list) {
ep = to_vep(_ep);
ep->already_seen = 0;
}
restart:
list_for_each_entry_safe(urb_p, tmp, &udc->urb_queue, urb_entry) {
struct urb *urb = urb_p->urb;
ep = urb_p->ep;
if (urb->unlinked)
goto return_urb;
if (timer->state != VUDC_TR_RUNNING)
continue;
if (!ep) {
urb->status = -EPROTO;
goto return_urb;
}
/* Used up bandwidth? */
if (total <= 0 && ep->type == USB_ENDPOINT_XFER_BULK)
continue;
if (ep->already_seen)
continue;
ep->already_seen = 1;
if (ep == &udc->ep[0] && urb_p->new) {
ep->setup_stage = 1;
urb_p->new = 0;
}
if (ep->halted && !ep->setup_stage) {
urb->status = -EPIPE;
goto return_urb;
}
if (ep == &udc->ep[0] && ep->setup_stage) {
/* TODO - flush any stale requests */
ep->setup_stage = 0;
ep->halted = 0;
ret = handle_control_request(udc, urb,
(struct usb_ctrlrequest *) urb->setup_packet,
(&urb->status));
if (ret > 0) {
spin_unlock(&udc->lock);
ret = udc->driver->setup(&udc->gadget,
(struct usb_ctrlrequest *)
urb->setup_packet);
spin_lock(&udc->lock);
}
if (ret >= 0) {
/* no delays (max 64kb data stage) */
limit = 64 * 1024;
goto treat_control_like_bulk;
} else {
urb->status = -EPIPE;
urb->actual_length = 0;
goto return_urb;
}
}
limit = total;
switch (ep->type) {
case USB_ENDPOINT_XFER_ISOC:
/* TODO: support */
urb->status = -EXDEV;
break;
case USB_ENDPOINT_XFER_INT:
/*
* TODO: figure out bandwidth guarantees
* for now, give unlimited bandwidth
*/
limit += urb->transfer_buffer_length;
fallthrough;
default:
treat_control_like_bulk:
total -= transfer(udc, urb, ep, limit);
}
if (urb->status == -EINPROGRESS)
continue;
return_urb:
if (ep)
ep->already_seen = ep->setup_stage = 0;
spin_lock(&udc->lock_tx);
list_del(&urb_p->urb_entry);
if (!urb->unlinked) {
v_enqueue_ret_submit(udc, urb_p);
} else {
v_enqueue_ret_unlink(udc, urb_p->seqnum,
urb->unlinked);
free_urbp_and_urb(urb_p);
}
wake_up(&udc->tx_waitq);
spin_unlock(&udc->lock_tx);
goto restart;
}
/* TODO - also wait on empty usb_request queues? */
if (list_empty(&udc->urb_queue))
timer->state = VUDC_TR_IDLE;
else
mod_timer(&timer->timer,
timer->frame_start + msecs_to_jiffies(1));
spin_unlock_irqrestore(&udc->lock, flags);
}
/* All timer functions are run with udc->lock held */
void v_init_timer(struct vudc *udc)
{
struct transfer_timer *t = &udc->tr_timer;
timer_setup(&t->timer, v_timer, 0);
t->state = VUDC_TR_STOPPED;
}
void v_start_timer(struct vudc *udc)
{
struct transfer_timer *t = &udc->tr_timer;
dev_dbg(&udc->pdev->dev, "timer start");
switch (t->state) {
case VUDC_TR_RUNNING:
return;
case VUDC_TR_IDLE:
return v_kick_timer(udc, jiffies);
case VUDC_TR_STOPPED:
t->state = VUDC_TR_IDLE;
t->frame_start = jiffies;
t->frame_limit = get_frame_limit(udc->gadget.speed);
return v_kick_timer(udc, jiffies);
}
}
void v_kick_timer(struct vudc *udc, unsigned long time)
{
struct transfer_timer *t = &udc->tr_timer;
dev_dbg(&udc->pdev->dev, "timer kick");
switch (t->state) {
case VUDC_TR_RUNNING:
return;
case VUDC_TR_IDLE:
t->state = VUDC_TR_RUNNING;
fallthrough;
case VUDC_TR_STOPPED:
/* we may want to kick timer to unqueue urbs */
mod_timer(&t->timer, time);
}
}
void v_stop_timer(struct vudc *udc)
{
struct transfer_timer *t = &udc->tr_timer;
/* timer itself will take care of stopping */
dev_dbg(&udc->pdev->dev, "timer stop");
t->state = VUDC_TR_STOPPED;
}
Codebase Browser
linux