linux/drivers/usb/cdns3/cdnsp-ep0.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Cadence CDNSP DRD Driver.
   4 *
   5 * Copyright (C) 2020 Cadence.
   6 *
   7 * Author: Pawel Laszczak <pawell@cadence.com>
   8 *
   9 */
  10
  11#include <linux/usb/composite.h>
  12#include <linux/usb/gadget.h>
  13#include <linux/list.h>
  14
  15#include "cdnsp-gadget.h"
  16#include "cdnsp-trace.h"
  17
  18static void cdnsp_ep0_stall(struct cdnsp_device *pdev)
  19{
  20        struct cdnsp_request *preq;
  21        struct cdnsp_ep *pep;
  22
  23        pep = &pdev->eps[0];
  24        preq = next_request(&pep->pending_list);
  25
  26        if (pdev->three_stage_setup) {
  27                cdnsp_halt_endpoint(pdev, pep, true);
  28
  29                if (preq)
  30                        cdnsp_gadget_giveback(pep, preq, -ECONNRESET);
  31        } else {
  32                pep->ep_state |= EP0_HALTED_STATUS;
  33
  34                if (preq)
  35                        list_del(&preq->list);
  36
  37                cdnsp_status_stage(pdev);
  38        }
  39}
  40
  41static int cdnsp_ep0_delegate_req(struct cdnsp_device *pdev,
  42                                  struct usb_ctrlrequest *ctrl)
  43{
  44        int ret;
  45
  46        spin_unlock(&pdev->lock);
  47        ret = pdev->gadget_driver->setup(&pdev->gadget, ctrl);
  48        spin_lock(&pdev->lock);
  49
  50        return ret;
  51}
  52
  53static int cdnsp_ep0_set_config(struct cdnsp_device *pdev,
  54                                struct usb_ctrlrequest *ctrl)
  55{
  56        enum usb_device_state state = pdev->gadget.state;
  57        u32 cfg;
  58        int ret;
  59
  60        cfg = le16_to_cpu(ctrl->wValue);
  61
  62        switch (state) {
  63        case USB_STATE_ADDRESS:
  64                trace_cdnsp_ep0_set_config("from Address state");
  65                break;
  66        case USB_STATE_CONFIGURED:
  67                trace_cdnsp_ep0_set_config("from Configured state");
  68                break;
  69        default:
  70                dev_err(pdev->dev, "Set Configuration - bad device state\n");
  71                return -EINVAL;
  72        }
  73
  74        ret = cdnsp_ep0_delegate_req(pdev, ctrl);
  75        if (ret)
  76                return ret;
  77
  78        if (!cfg)
  79                usb_gadget_set_state(&pdev->gadget, USB_STATE_ADDRESS);
  80
  81        return 0;
  82}
  83
  84static int cdnsp_ep0_set_address(struct cdnsp_device *pdev,
  85                                 struct usb_ctrlrequest *ctrl)
  86{
  87        enum usb_device_state state = pdev->gadget.state;
  88        struct cdnsp_slot_ctx *slot_ctx;
  89        unsigned int slot_state;
  90        int ret;
  91        u32 addr;
  92
  93        addr = le16_to_cpu(ctrl->wValue);
  94
  95        if (addr > 127) {
  96                dev_err(pdev->dev, "Invalid device address %d\n", addr);
  97                return -EINVAL;
  98        }
  99
 100        slot_ctx = cdnsp_get_slot_ctx(&pdev->out_ctx);
 101
 102        if (state == USB_STATE_CONFIGURED) {
 103                dev_err(pdev->dev, "Can't Set Address from Configured State\n");
 104                return -EINVAL;
 105        }
 106
 107        pdev->device_address = le16_to_cpu(ctrl->wValue);
 108
 109        slot_ctx = cdnsp_get_slot_ctx(&pdev->out_ctx);
 110        slot_state = GET_SLOT_STATE(le32_to_cpu(slot_ctx->dev_state));
 111        if (slot_state == SLOT_STATE_ADDRESSED)
 112                cdnsp_reset_device(pdev);
 113
 114        /*set device address*/
 115        ret = cdnsp_setup_device(pdev, SETUP_CONTEXT_ADDRESS);
 116        if (ret)
 117                return ret;
 118
 119        if (addr)
 120                usb_gadget_set_state(&pdev->gadget, USB_STATE_ADDRESS);
 121        else
 122                usb_gadget_set_state(&pdev->gadget, USB_STATE_DEFAULT);
 123
 124        return 0;
 125}
 126
 127int cdnsp_status_stage(struct cdnsp_device *pdev)
 128{
 129        pdev->ep0_stage = CDNSP_STATUS_STAGE;
 130        pdev->ep0_preq.request.length = 0;
 131
 132        return cdnsp_ep_enqueue(pdev->ep0_preq.pep, &pdev->ep0_preq);
 133}
 134
 135static int cdnsp_w_index_to_ep_index(u16 wIndex)
 136{
 137        if (!(wIndex & USB_ENDPOINT_NUMBER_MASK))
 138                return 0;
 139
 140        return ((wIndex & USB_ENDPOINT_NUMBER_MASK) * 2) +
 141                (wIndex & USB_ENDPOINT_DIR_MASK ? 1 : 0) - 1;
 142}
 143
 144static int cdnsp_ep0_handle_status(struct cdnsp_device *pdev,
 145                                   struct usb_ctrlrequest *ctrl)
 146{
 147        struct cdnsp_ep *pep;
 148        __le16 *response;
 149        int ep_sts = 0;
 150        u16 status = 0;
 151        u32 recipient;
 152
 153        recipient = ctrl->bRequestType & USB_RECIP_MASK;
 154
 155        switch (recipient) {
 156        case USB_RECIP_DEVICE:
 157                status = pdev->gadget.is_selfpowered;
 158                status |= pdev->may_wakeup << USB_DEVICE_REMOTE_WAKEUP;
 159
 160                if (pdev->gadget.speed >= USB_SPEED_SUPER) {
 161                        status |= pdev->u1_allowed << USB_DEV_STAT_U1_ENABLED;
 162                        status |= pdev->u2_allowed << USB_DEV_STAT_U2_ENABLED;
 163                }
 164                break;
 165        case USB_RECIP_INTERFACE:
 166                /*
 167                 * Function Remote Wake Capable D0
 168                 * Function Remote Wakeup       D1
 169                 */
 170                return cdnsp_ep0_delegate_req(pdev, ctrl);
 171        case USB_RECIP_ENDPOINT:
 172                ep_sts = cdnsp_w_index_to_ep_index(le16_to_cpu(ctrl->wIndex));
 173                pep = &pdev->eps[ep_sts];
 174                ep_sts = GET_EP_CTX_STATE(pep->out_ctx);
 175
 176                /* check if endpoint is stalled */
 177                if (ep_sts == EP_STATE_HALTED)
 178                        status =  BIT(USB_ENDPOINT_HALT);
 179                break;
 180        default:
 181                return -EINVAL;
 182        }
 183
 184        response = (__le16 *)pdev->setup_buf;
 185        *response = cpu_to_le16(status);
 186
 187        pdev->ep0_preq.request.length = sizeof(*response);
 188        pdev->ep0_preq.request.buf = pdev->setup_buf;
 189
 190        return cdnsp_ep_enqueue(pdev->ep0_preq.pep, &pdev->ep0_preq);
 191}
 192
 193static void cdnsp_enter_test_mode(struct cdnsp_device *pdev)
 194{
 195        u32 temp;
 196
 197        temp = readl(&pdev->active_port->regs->portpmsc) & ~GENMASK(31, 28);
 198        temp |= PORT_TEST_MODE(pdev->test_mode);
 199        writel(temp, &pdev->active_port->regs->portpmsc);
 200}
 201
 202static int cdnsp_ep0_handle_feature_device(struct cdnsp_device *pdev,
 203                                           struct usb_ctrlrequest *ctrl,
 204                                           int set)
 205{
 206        enum usb_device_state state;
 207        enum usb_device_speed speed;
 208        u16 tmode;
 209
 210        state = pdev->gadget.state;
 211        speed = pdev->gadget.speed;
 212
 213        switch (le16_to_cpu(ctrl->wValue)) {
 214        case USB_DEVICE_REMOTE_WAKEUP:
 215                pdev->may_wakeup = !!set;
 216                trace_cdnsp_may_wakeup(set);
 217                break;
 218        case USB_DEVICE_U1_ENABLE:
 219                if (state != USB_STATE_CONFIGURED || speed < USB_SPEED_SUPER)
 220                        return -EINVAL;
 221
 222                pdev->u1_allowed = !!set;
 223                trace_cdnsp_u1(set);
 224                break;
 225        case USB_DEVICE_U2_ENABLE:
 226                if (state != USB_STATE_CONFIGURED || speed < USB_SPEED_SUPER)
 227                        return -EINVAL;
 228
 229                pdev->u2_allowed = !!set;
 230                trace_cdnsp_u2(set);
 231                break;
 232        case USB_DEVICE_LTM_ENABLE:
 233                return -EINVAL;
 234        case USB_DEVICE_TEST_MODE:
 235                if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH)
 236                        return -EINVAL;
 237
 238                tmode = le16_to_cpu(ctrl->wIndex);
 239
 240                if (!set || (tmode & 0xff) != 0)
 241                        return -EINVAL;
 242
 243                tmode = tmode >> 8;
 244
 245                if (tmode > USB_TEST_FORCE_ENABLE || tmode < USB_TEST_J)
 246                        return -EINVAL;
 247
 248                pdev->test_mode = tmode;
 249
 250                /*
 251                 * Test mode must be set before Status Stage but controller
 252                 * will start testing sequence after Status Stage.
 253                 */
 254                cdnsp_enter_test_mode(pdev);
 255                break;
 256        default:
 257                return -EINVAL;
 258        }
 259
 260        return 0;
 261}
 262
 263static int cdnsp_ep0_handle_feature_intf(struct cdnsp_device *pdev,
 264                                         struct usb_ctrlrequest *ctrl,
 265                                         int set)
 266{
 267        u16 wValue, wIndex;
 268        int ret;
 269
 270        wValue = le16_to_cpu(ctrl->wValue);
 271        wIndex = le16_to_cpu(ctrl->wIndex);
 272
 273        switch (wValue) {
 274        case USB_INTRF_FUNC_SUSPEND:
 275                ret = cdnsp_ep0_delegate_req(pdev, ctrl);
 276                if (ret)
 277                        return ret;
 278
 279                /*
 280                 * Remote wakeup is enabled when any function within a device
 281                 * is enabled for function remote wakeup.
 282                 */
 283                if (wIndex & USB_INTRF_FUNC_SUSPEND_RW)
 284                        pdev->may_wakeup++;
 285                else
 286                        if (pdev->may_wakeup > 0)
 287                                pdev->may_wakeup--;
 288
 289                return 0;
 290        default:
 291                return -EINVAL;
 292        }
 293
 294        return 0;
 295}
 296
 297static int cdnsp_ep0_handle_feature_endpoint(struct cdnsp_device *pdev,
 298                                             struct usb_ctrlrequest *ctrl,
 299                                             int set)
 300{
 301        struct cdnsp_ep *pep;
 302        u16 wValue;
 303
 304        wValue = le16_to_cpu(ctrl->wValue);
 305        pep = &pdev->eps[cdnsp_w_index_to_ep_index(le16_to_cpu(ctrl->wIndex))];
 306
 307        switch (wValue) {
 308        case USB_ENDPOINT_HALT:
 309                if (!set && (pep->ep_state & EP_WEDGE)) {
 310                        /* Resets Sequence Number */
 311                        cdnsp_halt_endpoint(pdev, pep, 0);
 312                        cdnsp_halt_endpoint(pdev, pep, 1);
 313                        break;
 314                }
 315
 316                return cdnsp_halt_endpoint(pdev, pep, set);
 317        default:
 318                dev_warn(pdev->dev, "WARN Incorrect wValue %04x\n", wValue);
 319                return -EINVAL;
 320        }
 321
 322        return 0;
 323}
 324
 325static int cdnsp_ep0_handle_feature(struct cdnsp_device *pdev,
 326                                    struct usb_ctrlrequest *ctrl,
 327                                    int set)
 328{
 329        switch (ctrl->bRequestType & USB_RECIP_MASK) {
 330        case USB_RECIP_DEVICE:
 331                return cdnsp_ep0_handle_feature_device(pdev, ctrl, set);
 332        case USB_RECIP_INTERFACE:
 333                return cdnsp_ep0_handle_feature_intf(pdev, ctrl, set);
 334        case USB_RECIP_ENDPOINT:
 335                return cdnsp_ep0_handle_feature_endpoint(pdev, ctrl, set);
 336        default:
 337                return -EINVAL;
 338        }
 339}
 340
 341static int cdnsp_ep0_set_sel(struct cdnsp_device *pdev,
 342                             struct usb_ctrlrequest *ctrl)
 343{
 344        enum usb_device_state state = pdev->gadget.state;
 345        u16 wLength;
 346
 347        if (state == USB_STATE_DEFAULT)
 348                return -EINVAL;
 349
 350        wLength = le16_to_cpu(ctrl->wLength);
 351
 352        if (wLength != 6) {
 353                dev_err(pdev->dev, "Set SEL should be 6 bytes, got %d\n",
 354                        wLength);
 355                return -EINVAL;
 356        }
 357
 358        /*
 359         * To handle Set SEL we need to receive 6 bytes from Host. So let's
 360         * queue a usb_request for 6 bytes.
 361         */
 362        pdev->ep0_preq.request.length = 6;
 363        pdev->ep0_preq.request.buf = pdev->setup_buf;
 364
 365        return cdnsp_ep_enqueue(pdev->ep0_preq.pep, &pdev->ep0_preq);
 366}
 367
 368static int cdnsp_ep0_set_isoch_delay(struct cdnsp_device *pdev,
 369                                     struct usb_ctrlrequest *ctrl)
 370{
 371        if (le16_to_cpu(ctrl->wIndex) || le16_to_cpu(ctrl->wLength))
 372                return -EINVAL;
 373
 374        pdev->gadget.isoch_delay = le16_to_cpu(ctrl->wValue);
 375
 376        return 0;
 377}
 378
 379static int cdnsp_ep0_std_request(struct cdnsp_device *pdev,
 380                                 struct usb_ctrlrequest *ctrl)
 381{
 382        int ret;
 383
 384        switch (ctrl->bRequest) {
 385        case USB_REQ_GET_STATUS:
 386                ret = cdnsp_ep0_handle_status(pdev, ctrl);
 387                break;
 388        case USB_REQ_CLEAR_FEATURE:
 389                ret = cdnsp_ep0_handle_feature(pdev, ctrl, 0);
 390                break;
 391        case USB_REQ_SET_FEATURE:
 392                ret = cdnsp_ep0_handle_feature(pdev, ctrl, 1);
 393                break;
 394        case USB_REQ_SET_ADDRESS:
 395                ret = cdnsp_ep0_set_address(pdev, ctrl);
 396                break;
 397        case USB_REQ_SET_CONFIGURATION:
 398                ret = cdnsp_ep0_set_config(pdev, ctrl);
 399                break;
 400        case USB_REQ_SET_SEL:
 401                ret = cdnsp_ep0_set_sel(pdev, ctrl);
 402                break;
 403        case USB_REQ_SET_ISOCH_DELAY:
 404                ret = cdnsp_ep0_set_isoch_delay(pdev, ctrl);
 405                break;
 406        case USB_REQ_SET_INTERFACE:
 407                /*
 408                 * Add request into pending list to block sending status stage
 409                 * by libcomposite.
 410                 */
 411                list_add_tail(&pdev->ep0_preq.list,
 412                              &pdev->ep0_preq.pep->pending_list);
 413
 414                ret = cdnsp_ep0_delegate_req(pdev, ctrl);
 415                if (ret == -EBUSY)
 416                        ret = 0;
 417
 418                list_del(&pdev->ep0_preq.list);
 419                break;
 420        default:
 421                ret = cdnsp_ep0_delegate_req(pdev, ctrl);
 422                break;
 423        }
 424
 425        return ret;
 426}
 427
 428void cdnsp_setup_analyze(struct cdnsp_device *pdev)
 429{
 430        struct usb_ctrlrequest *ctrl = &pdev->setup;
 431        int ret = 0;
 432        u16 len;
 433
 434        trace_cdnsp_ctrl_req(ctrl);
 435
 436        if (!pdev->gadget_driver)
 437                goto out;
 438
 439        if (pdev->gadget.state == USB_STATE_NOTATTACHED) {
 440                dev_err(pdev->dev, "ERR: Setup detected in unattached state\n");
 441                ret = -EINVAL;
 442                goto out;
 443        }
 444
 445        /* Restore the ep0 to Stopped/Running state. */
 446        if (pdev->eps[0].ep_state & EP_HALTED) {
 447                trace_cdnsp_ep0_halted("Restore to normal state");
 448                cdnsp_halt_endpoint(pdev, &pdev->eps[0], 0);
 449        }
 450
 451        /*
 452         * Finishing previous SETUP transfer by removing request from
 453         * list and informing upper layer
 454         */
 455        if (!list_empty(&pdev->eps[0].pending_list)) {
 456                struct cdnsp_request    *req;
 457
 458                trace_cdnsp_ep0_request("Remove previous");
 459                req = next_request(&pdev->eps[0].pending_list);
 460                cdnsp_ep_dequeue(&pdev->eps[0], req);
 461        }
 462
 463        len = le16_to_cpu(ctrl->wLength);
 464        if (!len) {
 465                pdev->three_stage_setup = false;
 466                pdev->ep0_expect_in = false;
 467        } else {
 468                pdev->three_stage_setup = true;
 469                pdev->ep0_expect_in = !!(ctrl->bRequestType & USB_DIR_IN);
 470        }
 471
 472        if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
 473                ret = cdnsp_ep0_std_request(pdev, ctrl);
 474        else
 475                ret = cdnsp_ep0_delegate_req(pdev, ctrl);
 476
 477        if (!len)
 478                pdev->ep0_stage = CDNSP_STATUS_STAGE;
 479
 480        if (ret == USB_GADGET_DELAYED_STATUS) {
 481                trace_cdnsp_ep0_status_stage("delayed");
 482                return;
 483        }
 484out:
 485        if (ret < 0)
 486                cdnsp_ep0_stall(pdev);
 487        else if (pdev->ep0_stage == CDNSP_STATUS_STAGE)
 488                cdnsp_status_stage(pdev);
 489}
 490