Orange Pi5 kernel

// 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;
}