497 lines
12 KiB
C
497 lines
12 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright (C) 2015 Karol Kosik <karo9@interia.eu>
|
|
* Copyright (C) 2015-2016 Samsung Electronics
|
|
* Igor Kotrasinski <i.kotrasinsk@samsung.com>
|
|
*
|
|
* 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;
|
|
}
|