// 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 = timer_container_of(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;
}