// SPDX-License-Identifier: GPL-2.0
/*
 * Cadence CDNSP DRD Driver.
 *
 * Copyright (C) 2020 Cadence.
 *
 * Author: Pawel Laszczak <pawell@cadence.com>
 *
 */

#include <linux/usb/composite.h>
#include <linux/usb/gadget.h>
#include <linux/list.h>

#include "cdnsp-gadget.h"
#include "cdnsp-trace.h"

static void cdnsp_ep0_stall(struct cdnsp_device *pdev)
{
        struct cdnsp_request *preq;
        struct cdnsp_ep *pep;

        pep = &pdev->eps[0];
        preq = next_request(&pep->pending_list);

        if (pdev->three_stage_setup) {
                cdnsp_halt_endpoint(pdev, pep, true);

                if (preq)
                        cdnsp_gadget_giveback(pep, preq, -ECONNRESET);
        } else {
                pep->ep_state |= EP0_HALTED_STATUS;

                if (preq)
                        list_del(&preq->list);

                cdnsp_status_stage(pdev);
        }
}

static int cdnsp_ep0_delegate_req(struct cdnsp_device *pdev,
                                  struct usb_ctrlrequest *ctrl)
{
        int ret;

        spin_unlock(&pdev->lock);
        ret = pdev->gadget_driver->setup(&pdev->gadget, ctrl);
        spin_lock(&pdev->lock);

        return ret;
}

static int cdnsp_ep0_set_config(struct cdnsp_device *pdev,
                                struct usb_ctrlrequest *ctrl)
{
        enum usb_device_state state = pdev->gadget.state;
        u32 cfg;
        int ret;

        cfg = le16_to_cpu(ctrl->wValue);

        switch (state) {
        case USB_STATE_ADDRESS:
                trace_cdnsp_ep0_set_config("from Address state");
                break;
        case USB_STATE_CONFIGURED:
                trace_cdnsp_ep0_set_config("from Configured state");
                break;
        default:
                dev_err(pdev->dev, "Set Configuration - bad device state\n");
                return -EINVAL;
        }

        ret = cdnsp_ep0_delegate_req(pdev, ctrl);
        if (ret)
                return ret;

        if (!cfg)
                usb_gadget_set_state(&pdev->gadget, USB_STATE_ADDRESS);

        return 0;
}

static int cdnsp_ep0_set_address(struct cdnsp_device *pdev,
                                 struct usb_ctrlrequest *ctrl)
{
        enum usb_device_state state = pdev->gadget.state;
        struct cdnsp_slot_ctx *slot_ctx;
        unsigned int slot_state;
        int ret;
        u32 addr;

        addr = le16_to_cpu(ctrl->wValue);

        if (addr > 127) {
                dev_err(pdev->dev, "Invalid device address %d\n", addr);
                return -EINVAL;
        }

        slot_ctx = cdnsp_get_slot_ctx(&pdev->out_ctx);

        if (state == USB_STATE_CONFIGURED) {
                dev_err(pdev->dev, "Can't Set Address from Configured State\n");
                return -EINVAL;
        }

        pdev->device_address = le16_to_cpu(ctrl->wValue);

        slot_ctx = cdnsp_get_slot_ctx(&pdev->out_ctx);
        slot_state = GET_SLOT_STATE(le32_to_cpu(slot_ctx->dev_state));
        if (slot_state == SLOT_STATE_ADDRESSED)
                cdnsp_reset_device(pdev);

        /*set device address*/
        ret = cdnsp_setup_device(pdev, SETUP_CONTEXT_ADDRESS);
        if (ret)
                return ret;

        if (addr)
                usb_gadget_set_state(&pdev->gadget, USB_STATE_ADDRESS);
        else
                usb_gadget_set_state(&pdev->gadget, USB_STATE_DEFAULT);

        return 0;
}

int cdnsp_status_stage(struct cdnsp_device *pdev)
{
        pdev->ep0_stage = CDNSP_STATUS_STAGE;
        pdev->ep0_preq.request.length = 0;

        return cdnsp_ep_enqueue(pdev->ep0_preq.pep, &pdev->ep0_preq);
}

static int cdnsp_w_index_to_ep_index(u16 wIndex)
{
        if (!(wIndex & USB_ENDPOINT_NUMBER_MASK))
                return 0;

        return ((wIndex & USB_ENDPOINT_NUMBER_MASK) * 2) +
                (wIndex & USB_ENDPOINT_DIR_MASK ? 1 : 0) - 1;
}

static int cdnsp_ep0_handle_status(struct cdnsp_device *pdev,
                                   struct usb_ctrlrequest *ctrl)
{
        struct cdnsp_ep *pep;
        __le16 *response;
        int ep_sts = 0;
        u16 status = 0;
        u32 recipient;

        recipient = ctrl->bRequestType & USB_RECIP_MASK;

        switch (recipient) {
        case USB_RECIP_DEVICE:
                status = pdev->gadget.is_selfpowered;
                status |= pdev->may_wakeup << USB_DEVICE_REMOTE_WAKEUP;

                if (pdev->gadget.speed >= USB_SPEED_SUPER) {
                        status |= pdev->u1_allowed << USB_DEV_STAT_U1_ENABLED;
                        status |= pdev->u2_allowed << USB_DEV_STAT_U2_ENABLED;
                }
                break;
        case USB_RECIP_INTERFACE:
                /*
                 * Function Remote Wake Capable D0
                 * Function Remote Wakeup       D1
                 */
                return cdnsp_ep0_delegate_req(pdev, ctrl);
        case USB_RECIP_ENDPOINT:
                ep_sts = cdnsp_w_index_to_ep_index(le16_to_cpu(ctrl->wIndex));
                pep = &pdev->eps[ep_sts];
                ep_sts = GET_EP_CTX_STATE(pep->out_ctx);

                /* check if endpoint is stalled */
                if (ep_sts == EP_STATE_HALTED)
                        status =  BIT(USB_ENDPOINT_HALT);
                break;
        default:
                return -EINVAL;
        }

        response = (__le16 *)pdev->setup_buf;
        *response = cpu_to_le16(status);

        pdev->ep0_preq.request.length = sizeof(*response);
        pdev->ep0_preq.request.buf = pdev->setup_buf;

        return cdnsp_ep_enqueue(pdev->ep0_preq.pep, &pdev->ep0_preq);
}

static void cdnsp_enter_test_mode(struct cdnsp_device *pdev)
{
        u32 temp;

        temp = readl(&pdev->active_port->regs->portpmsc) & ~GENMASK(31, 28);
        temp |= PORT_TEST_MODE(pdev->test_mode);
        writel(temp, &pdev->active_port->regs->portpmsc);
}

static int cdnsp_ep0_handle_feature_device(struct cdnsp_device *pdev,
                                           struct usb_ctrlrequest *ctrl,
                                           int set)
{
        enum usb_device_state state;
        enum usb_device_speed speed;
        u16 tmode;

        state = pdev->gadget.state;
        speed = pdev->gadget.speed;

        switch (le16_to_cpu(ctrl->wValue)) {
        case USB_DEVICE_REMOTE_WAKEUP:
                pdev->may_wakeup = !!set;
                trace_cdnsp_may_wakeup(set);
                break;
        case USB_DEVICE_U1_ENABLE:
                if (state != USB_STATE_CONFIGURED || speed < USB_SPEED_SUPER)
                        return -EINVAL;

                pdev->u1_allowed = !!set;
                trace_cdnsp_u1(set);
                break;
        case USB_DEVICE_U2_ENABLE:
                if (state != USB_STATE_CONFIGURED || speed < USB_SPEED_SUPER)
                        return -EINVAL;

                pdev->u2_allowed = !!set;
                trace_cdnsp_u2(set);
                break;
        case USB_DEVICE_LTM_ENABLE:
                return -EINVAL;
        case USB_DEVICE_TEST_MODE:
                if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH)
                        return -EINVAL;

                tmode = le16_to_cpu(ctrl->wIndex);

                if (!set || (tmode & 0xff) != 0)
                        return -EINVAL;

                tmode = tmode >> 8;

                if (tmode > USB_TEST_FORCE_ENABLE || tmode < USB_TEST_J)
                        return -EINVAL;

                pdev->test_mode = tmode;

                /*
                 * Test mode must be set before Status Stage but controller
                 * will start testing sequence after Status Stage.
                 */
                cdnsp_enter_test_mode(pdev);
                break;
        default:
                return -EINVAL;
        }

        return 0;
}

static int cdnsp_ep0_handle_feature_intf(struct cdnsp_device *pdev,
                                         struct usb_ctrlrequest *ctrl,
                                         int set)
{
        u16 wValue, wIndex;
        int ret;

        wValue = le16_to_cpu(ctrl->wValue);
        wIndex = le16_to_cpu(ctrl->wIndex);

        switch (wValue) {
        case USB_INTRF_FUNC_SUSPEND:
                ret = cdnsp_ep0_delegate_req(pdev, ctrl);
                if (ret)
                        return ret;

                /*
                 * Remote wakeup is enabled when any function within a device
                 * is enabled for function remote wakeup.
                 */
                if (wIndex & USB_INTRF_FUNC_SUSPEND_RW)
                        pdev->may_wakeup++;
                else
                        if (pdev->may_wakeup > 0)
                                pdev->may_wakeup--;

                return 0;
        default:
                return -EINVAL;
        }

        return 0;
}

static int cdnsp_ep0_handle_feature_endpoint(struct cdnsp_device *pdev,
                                             struct usb_ctrlrequest *ctrl,
                                             int set)
{
        struct cdnsp_ep *pep;
        u16 wValue;

        wValue = le16_to_cpu(ctrl->wValue);
        pep = &pdev->eps[cdnsp_w_index_to_ep_index(le16_to_cpu(ctrl->wIndex))];

        switch (wValue) {
        case USB_ENDPOINT_HALT:
                if (!set && (pep->ep_state & EP_WEDGE)) {
                        /* Resets Sequence Number */
                        cdnsp_halt_endpoint(pdev, pep, 0);
                        cdnsp_halt_endpoint(pdev, pep, 1);
                        break;
                }

                return cdnsp_halt_endpoint(pdev, pep, set);
        default:
                dev_warn(pdev->dev, "WARN Incorrect wValue %04x\n", wValue);
                return -EINVAL;
        }

        return 0;
}

static int cdnsp_ep0_handle_feature(struct cdnsp_device *pdev,
                                    struct usb_ctrlrequest *ctrl,
                                    int set)
{
        switch (ctrl->bRequestType & USB_RECIP_MASK) {
        case USB_RECIP_DEVICE:
                return cdnsp_ep0_handle_feature_device(pdev, ctrl, set);
        case USB_RECIP_INTERFACE:
                return cdnsp_ep0_handle_feature_intf(pdev, ctrl, set);
        case USB_RECIP_ENDPOINT:
                return cdnsp_ep0_handle_feature_endpoint(pdev, ctrl, set);
        default:
                return -EINVAL;
        }
}

static int cdnsp_ep0_set_sel(struct cdnsp_device *pdev,
                             struct usb_ctrlrequest *ctrl)
{
        enum usb_device_state state = pdev->gadget.state;
        u16 wLength;

        if (state == USB_STATE_DEFAULT)
                return -EINVAL;

        wLength = le16_to_cpu(ctrl->wLength);

        if (wLength != 6) {
                dev_err(pdev->dev, "Set SEL should be 6 bytes, got %d\n",
                        wLength);
                return -EINVAL;
        }

        /*
         * To handle Set SEL we need to receive 6 bytes from Host. So let's
         * queue a usb_request for 6 bytes.
         */
        pdev->ep0_preq.request.length = 6;
        pdev->ep0_preq.request.buf = pdev->setup_buf;

        return cdnsp_ep_enqueue(pdev->ep0_preq.pep, &pdev->ep0_preq);
}

static int cdnsp_ep0_set_isoch_delay(struct cdnsp_device *pdev,
                                     struct usb_ctrlrequest *ctrl)
{
        if (le16_to_cpu(ctrl->wIndex) || le16_to_cpu(ctrl->wLength))
                return -EINVAL;

        pdev->gadget.isoch_delay = le16_to_cpu(ctrl->wValue);

        return 0;
}

static int cdnsp_ep0_std_request(struct cdnsp_device *pdev,
                                 struct usb_ctrlrequest *ctrl)
{
        int ret;

        switch (ctrl->bRequest) {
        case USB_REQ_GET_STATUS:
                ret = cdnsp_ep0_handle_status(pdev, ctrl);
                break;
        case USB_REQ_CLEAR_FEATURE:
                ret = cdnsp_ep0_handle_feature(pdev, ctrl, 0);
                break;
        case USB_REQ_SET_FEATURE:
                ret = cdnsp_ep0_handle_feature(pdev, ctrl, 1);
                break;
        case USB_REQ_SET_ADDRESS:
                ret = cdnsp_ep0_set_address(pdev, ctrl);
                break;
        case USB_REQ_SET_CONFIGURATION:
                ret = cdnsp_ep0_set_config(pdev, ctrl);
                break;
        case USB_REQ_SET_SEL:
                ret = cdnsp_ep0_set_sel(pdev, ctrl);
                break;
        case USB_REQ_SET_ISOCH_DELAY:
                ret = cdnsp_ep0_set_isoch_delay(pdev, ctrl);
                break;
        default:
                ret = cdnsp_ep0_delegate_req(pdev, ctrl);
                break;
        }

        return ret;
}

void cdnsp_setup_analyze(struct cdnsp_device *pdev)
{
        struct usb_ctrlrequest *ctrl = &pdev->setup;
        struct cdnsp_ep *pep;
        int ret = -EINVAL;
        u16 len;

        trace_cdnsp_ctrl_req(ctrl);

        if (!pdev->gadget_driver)
                goto out;

        if (pdev->gadget.state == USB_STATE_NOTATTACHED) {
                dev_err(pdev->dev, "ERR: Setup detected in unattached state\n");
                goto out;
        }

        pep = &pdev->eps[0];

        /* Restore the ep0 to Stopped/Running state. */
        if (pep->ep_state & EP_HALTED) {
                if (GET_EP_CTX_STATE(pep->out_ctx) == EP_STATE_HALTED)
                        cdnsp_halt_endpoint(pdev, pep, 0);

                /*
                 * Halt Endpoint Command for SSP2 for ep0 preserve current
                 * endpoint state and driver has to synchronize the
                 * software endpoint state with endpoint output context
                 * state.
                 */
                pep->ep_state &= ~EP_HALTED;
                pep->ep_state |= EP_STOPPED;
        }

        /*
         * Finishing previous SETUP transfer by removing request from
         * list and informing upper layer
         */
        if (!list_empty(&pdev->eps[0].pending_list)) {
                struct cdnsp_request    *req;

                trace_cdnsp_ep0_request("Remove previous");
                req = next_request(&pdev->eps[0].pending_list);
                cdnsp_ep_dequeue(&pdev->eps[0], req);
        }

        len = le16_to_cpu(ctrl->wLength);
        if (!len) {
                pdev->three_stage_setup = false;
                pdev->ep0_expect_in = false;
        } else {
                pdev->three_stage_setup = true;
                pdev->ep0_expect_in = !!(ctrl->bRequestType & USB_DIR_IN);
        }

        if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
                ret = cdnsp_ep0_std_request(pdev, ctrl);
        else
                ret = cdnsp_ep0_delegate_req(pdev, ctrl);

        if (ret == USB_GADGET_DELAYED_STATUS) {
                trace_cdnsp_ep0_status_stage("delayed");
                return;
        }
out:
        if (ret < 0)
                cdnsp_ep0_stall(pdev);
        else if (!len && pdev->ep0_stage != CDNSP_STATUS_STAGE)
                cdnsp_status_stage(pdev);
}