// 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>
 */

#include <net/sock.h>
#include <linux/list.h>
#include <linux/kthread.h>

#include "usbip_common.h"
#include "vudc.h"

static int alloc_urb_from_cmd(struct urb **urbp,
                              struct usbip_header *pdu, u8 type)
{
        struct urb *urb;

        if (type == USB_ENDPOINT_XFER_ISOC)
                urb = usb_alloc_urb(pdu->u.cmd_submit.number_of_packets,
                                          GFP_KERNEL);
        else
                urb = usb_alloc_urb(0, GFP_KERNEL);

        if (!urb)
                goto err;

        usbip_pack_pdu(pdu, urb, USBIP_CMD_SUBMIT, 0);

        if (urb->transfer_buffer_length > 0) {
                urb->transfer_buffer = kzalloc(urb->transfer_buffer_length,
                        GFP_KERNEL);
                if (!urb->transfer_buffer)
                        goto free_urb;
        }

        urb->setup_packet = kmemdup(&pdu->u.cmd_submit.setup, 8,
                            GFP_KERNEL);
        if (!urb->setup_packet)
                goto free_buffer;

        /*
         * FIXME - we only setup pipe enough for usbip functions
         * to behave nicely
         */
        urb->pipe |= pdu->base.direction == USBIP_DIR_IN ?
                        USB_DIR_IN : USB_DIR_OUT;

        *urbp = urb;
        return 0;

free_buffer:
        kfree(urb->transfer_buffer);
        urb->transfer_buffer = NULL;
free_urb:
        usb_free_urb(urb);
err:
        return -ENOMEM;
}

static int v_recv_cmd_unlink(struct vudc *udc,
                                struct usbip_header *pdu)
{
        unsigned long flags;
        struct urbp *urb_p;

        spin_lock_irqsave(&udc->lock, flags);
        list_for_each_entry(urb_p, &udc->urb_queue, urb_entry) {
                if (urb_p->seqnum != pdu->u.cmd_unlink.seqnum)
                        continue;
                urb_p->urb->unlinked = -ECONNRESET;
                urb_p->seqnum = pdu->base.seqnum;
                v_kick_timer(udc, jiffies);
                spin_unlock_irqrestore(&udc->lock, flags);
                return 0;
        }
        /* Not found, completed / not queued */
        spin_lock(&udc->lock_tx);
        v_enqueue_ret_unlink(udc, pdu->base.seqnum, 0);
        wake_up(&udc->tx_waitq);
        spin_unlock(&udc->lock_tx);
        spin_unlock_irqrestore(&udc->lock, flags);

        return 0;
}

static int v_recv_cmd_submit(struct vudc *udc,
                                 struct usbip_header *pdu)
{
        int ret = 0;
        struct urbp *urb_p;
        u8 address;
        unsigned long flags;

        urb_p = alloc_urbp();
        if (!urb_p) {
                usbip_event_add(&udc->ud, VUDC_EVENT_ERROR_MALLOC);
                return -ENOMEM;
        }

        /* base.ep is pipeendpoint(pipe) */
        address = pdu->base.ep;
        if (pdu->base.direction == USBIP_DIR_IN)
                address |= USB_DIR_IN;

        spin_lock_irqsave(&udc->lock, flags);
        urb_p->ep = vudc_find_endpoint(udc, address);
        if (!urb_p->ep) {
                /* we don't know the type, there may be isoc data! */
                dev_err(&udc->pdev->dev, "request to nonexistent endpoint");
                spin_unlock_irqrestore(&udc->lock, flags);
                usbip_event_add(&udc->ud, VUDC_EVENT_ERROR_TCP);
                ret = -EPIPE;
                goto free_urbp;
        }
        urb_p->type = urb_p->ep->type;
        spin_unlock_irqrestore(&udc->lock, flags);

        urb_p->new = 1;
        urb_p->seqnum = pdu->base.seqnum;

        if (urb_p->ep->type == USB_ENDPOINT_XFER_ISOC) {
                /* validate packet size and number of packets */
                unsigned int maxp, packets, bytes;

                maxp = usb_endpoint_maxp(urb_p->ep->desc);
                maxp *= usb_endpoint_maxp_mult(urb_p->ep->desc);
                bytes = pdu->u.cmd_submit.transfer_buffer_length;
                packets = DIV_ROUND_UP(bytes, maxp);

                if (pdu->u.cmd_submit.number_of_packets < 0 ||
                    pdu->u.cmd_submit.number_of_packets > packets) {
                        dev_err(&udc->gadget.dev,
                                "CMD_SUBMIT: isoc invalid num packets %d\n",
                                pdu->u.cmd_submit.number_of_packets);
                        ret = -EMSGSIZE;
                        goto free_urbp;
                }
        }

        ret = alloc_urb_from_cmd(&urb_p->urb, pdu, urb_p->ep->type);
        if (ret) {
                usbip_event_add(&udc->ud, VUDC_EVENT_ERROR_MALLOC);
                ret = -ENOMEM;
                goto free_urbp;
        }

        urb_p->urb->status = -EINPROGRESS;

        /* FIXME: more pipe setup to please usbip_common */
        BUILD_BUG_ON_MSG(PIPE_BULK != 3, "PIPE_* doesn't range from 0 to 3");

        urb_p->urb->pipe &= ~(PIPE_BULK << 30);
        switch (urb_p->ep->type) {
        case USB_ENDPOINT_XFER_BULK:
                urb_p->urb->pipe |= (PIPE_BULK << 30);
                break;
        case USB_ENDPOINT_XFER_INT:
                urb_p->urb->pipe |= (PIPE_INTERRUPT << 30);
                break;
        case USB_ENDPOINT_XFER_CONTROL:
                urb_p->urb->pipe |= (PIPE_CONTROL << 30);
                break;
        case USB_ENDPOINT_XFER_ISOC:
                urb_p->urb->pipe |= (PIPE_ISOCHRONOUS << 30);
                break;
        }
        ret = usbip_recv_xbuff(&udc->ud, urb_p->urb);
        if (ret < 0)
                goto free_urbp;

        ret = usbip_recv_iso(&udc->ud, urb_p->urb);
        if (ret < 0)
                goto free_urbp;

        spin_lock_irqsave(&udc->lock, flags);
        v_kick_timer(udc, jiffies);
        list_add_tail(&urb_p->urb_entry, &udc->urb_queue);
        spin_unlock_irqrestore(&udc->lock, flags);

        return 0;

free_urbp:
        free_urbp_and_urb(urb_p);
        return ret;
}

static int v_rx_pdu(struct usbip_device *ud)
{
        int ret;
        struct usbip_header pdu;
        struct vudc *udc = container_of(ud, struct vudc, ud);

        memset(&pdu, 0, sizeof(pdu));
        ret = usbip_recv(ud->tcp_socket, &pdu, sizeof(pdu));
        if (ret != sizeof(pdu)) {
                usbip_event_add(ud, VUDC_EVENT_ERROR_TCP);
                if (ret >= 0)
                        return -EPIPE;
                return ret;
        }
        usbip_header_correct_endian(&pdu, 0);

        spin_lock_irq(&ud->lock);
        ret = (ud->status == SDEV_ST_USED);
        spin_unlock_irq(&ud->lock);
        if (!ret) {
                usbip_event_add(ud, VUDC_EVENT_ERROR_TCP);
                return -EBUSY;
        }

        switch (pdu.base.command) {
        case USBIP_CMD_UNLINK:
                ret = v_recv_cmd_unlink(udc, &pdu);
                break;
        case USBIP_CMD_SUBMIT:
                ret = v_recv_cmd_submit(udc, &pdu);
                break;
        default:
                ret = -EPIPE;
                pr_err("rx: unknown command");
                break;
        }
        return ret;
}

int v_rx_loop(void *data)
{
        struct usbip_device *ud = data;
        int ret = 0;

        while (!kthread_should_stop()) {
                if (usbip_event_happened(ud))
                        break;
                ret = v_rx_pdu(ud);
                if (ret < 0) {
                        pr_warn("v_rx exit with error %d", ret);
                        break;
                }
        }
        return ret;
}