drivers/usb/cdns3/ep0.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Cadence USBSS DRD Driver - gadget side.
   4  *
   5  * Copyright (C) 2018 Cadence Design Systems.
   6  * Copyright (C) 2017-2018 NXP
   7  *
   8  * Authors: Pawel Jez <pjez@cadence.com>,
   9  *          Pawel Laszczak <pawell@cadence.com>
  10  *          Peter Chen <peter.chen@nxp.com>
  11  */
  12
  13 #include <linux/usb/composite.h>
  14 #include <linux/iopoll.h>
  15
  16 #include "gadget.h"
  17 #include "trace.h"
  18
  19 static struct usb_endpoint_descriptor cdns3_gadget_ep0_desc = {
  20         .bLength = USB_DT_ENDPOINT_SIZE,
  21         .bDescriptorType = USB_DT_ENDPOINT,
  22         .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
  23 };
  24
  25 /**
  26  * cdns3_ep0_run_transfer - Do transfer on default endpoint hardware
  27  * @priv_dev: extended gadget object
  28  * @dma_addr: physical address where data is/will be stored
  29  * @length: data length
  30  * @erdy: set it to 1 when ERDY packet should be sent -
  31  *        exit from flow control state
  32  * @zlp: add zero length packet
  33  */
  34 static void cdns3_ep0_run_transfer(struct cdns3_device *priv_dev,
  35                                    dma_addr_t dma_addr,
  36                                    unsigned int length, int erdy, int zlp)
  37 {
  38         struct cdns3_usb_regs __iomem *regs = priv_dev->regs;
  39         struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
  40
  41         priv_ep->trb_pool[0].buffer = cpu_to_le32(TRB_BUFFER(dma_addr));
  42         priv_ep->trb_pool[0].length = cpu_to_le32(TRB_LEN(length));
  43
  44         if (zlp) {
  45                 priv_ep->trb_pool[0].control = cpu_to_le32(TRB_CYCLE | TRB_TYPE(TRB_NORMAL));
  46                 priv_ep->trb_pool[1].buffer = cpu_to_le32(TRB_BUFFER(dma_addr));
  47                 priv_ep->trb_pool[1].length = cpu_to_le32(TRB_LEN(0));
  48                 priv_ep->trb_pool[1].control = cpu_to_le32(TRB_CYCLE | TRB_IOC |
  49                     TRB_TYPE(TRB_NORMAL));
  50         } else {
  51                 priv_ep->trb_pool[0].control = cpu_to_le32(TRB_CYCLE | TRB_IOC |
  52                     TRB_TYPE(TRB_NORMAL));
  53                 priv_ep->trb_pool[1].control = 0;
  54         }
  55
  56         trace_cdns3_prepare_trb(priv_ep, priv_ep->trb_pool);
  57
  58         cdns3_select_ep(priv_dev, priv_dev->ep0_data_dir);
  59
  60         writel(EP_STS_TRBERR, &regs->ep_sts);
  61         writel(EP_TRADDR_TRADDR(priv_ep->trb_pool_dma), &regs->ep_traddr);
  62         trace_cdns3_doorbell_ep0(priv_dev->ep0_data_dir ? "ep0in" : "ep0out",
  63                                  readl(&regs->ep_traddr));
  64
  65         /* TRB should be prepared before starting transfer. */
  66         writel(EP_CMD_DRDY, &regs->ep_cmd);
  67
  68         /* Resume controller before arming transfer. */
  69         __cdns3_gadget_wakeup(priv_dev);
  70
  71         if (erdy)
  72                 writel(EP_CMD_ERDY, &priv_dev->regs->ep_cmd);
  73 }
  74
  75 /**
  76  * cdns3_ep0_delegate_req - Returns status of handling setup packet
  77  * Setup is handled by gadget driver
  78  * @priv_dev: extended gadget object
  79  * @ctrl_req: pointer to received setup packet
  80  *
  81  * Returns zero on success or negative value on failure
  82  */
  83 static int cdns3_ep0_delegate_req(struct cdns3_device *priv_dev,
  84                                   struct usb_ctrlrequest *ctrl_req)
  85 {
  86         int ret;
  87
  88         spin_unlock(&priv_dev->lock);
  89         priv_dev->setup_pending = 1;
  90         ret = priv_dev->gadget_driver->setup(&priv_dev->gadget, ctrl_req);
  91         priv_dev->setup_pending = 0;
  92         spin_lock(&priv_dev->lock);
  93         return ret;
  94 }
  95
  96 static void cdns3_prepare_setup_packet(struct cdns3_device *priv_dev)
  97 {
  98         priv_dev->ep0_data_dir = 0;
  99         priv_dev->ep0_stage = CDNS3_SETUP_STAGE;
 100         cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
 101                                sizeof(struct usb_ctrlrequest), 0, 0);
 102 }
 103
 104 static void cdns3_ep0_complete_setup(struct cdns3_device *priv_dev,
 105                                      u8 send_stall, u8 send_erdy)
 106 {
 107         struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
 108         struct usb_request *request;
 109
 110         request = cdns3_next_request(&priv_ep->pending_req_list);
 111         if (request)
 112                 list_del_init(&request->list);
 113
 114         if (send_stall) {
 115                 trace_cdns3_halt(priv_ep, send_stall, 0);
 116                 /* set_stall on ep0 */
 117                 cdns3_select_ep(priv_dev, 0x00);
 118                 writel(EP_CMD_SSTALL, &priv_dev->regs->ep_cmd);
 119         } else {
 120                 cdns3_prepare_setup_packet(priv_dev);
 121         }
 122
 123         priv_dev->ep0_stage = CDNS3_SETUP_STAGE;
 124         writel((send_erdy ? EP_CMD_ERDY : 0) | EP_CMD_REQ_CMPL,
 125                &priv_dev->regs->ep_cmd);
 126 }
 127
 128 /**
 129  * cdns3_req_ep0_set_configuration - Handling of SET_CONFIG standard USB request
 130  * @priv_dev: extended gadget object
 131  * @ctrl_req: pointer to received setup packet
 132  *
 133  * Returns 0 if success, USB_GADGET_DELAYED_STATUS on deferred status stage,
 134  * error code on error
 135  */
 136 static int cdns3_req_ep0_set_configuration(struct cdns3_device *priv_dev,
 137                                            struct usb_ctrlrequest *ctrl_req)
 138 {
 139         enum usb_device_state device_state = priv_dev->gadget.state;
 140         struct cdns3_endpoint *priv_ep;
 141         u32 config = le16_to_cpu(ctrl_req->wValue);
 142         int result = 0;
 143         int i;
 144
 145         switch (device_state) {
 146         case USB_STATE_ADDRESS:
 147                 /* Configure non-control EPs */
 148                 for (i = 0; i < CDNS3_ENDPOINTS_MAX_COUNT; i++) {
 149                         priv_ep = priv_dev->eps[i];
 150                         if (!priv_ep)
 151                                 continue;
 152
 153                         if (priv_ep->flags & EP_CLAIMED)
 154                                 cdns3_ep_config(priv_ep);
 155                 }
 156
 157                 result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
 158
 159                 if (result)
 160                         return result;
 161
 162                 if (!config) {
 163                         cdns3_hw_reset_eps_config(priv_dev);
 164                         usb_gadget_set_state(&priv_dev->gadget,
 165                                              USB_STATE_ADDRESS);
 166                 }
 167
 168                 break;
 169         case USB_STATE_CONFIGURED:
 170                 result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
 171
 172                 if (!config && !result) {
 173                         cdns3_hw_reset_eps_config(priv_dev);
 174                         usb_gadget_set_state(&priv_dev->gadget,
 175                                              USB_STATE_ADDRESS);
 176                 }
 177                 break;
 178         default:
 179                 result = -EINVAL;
 180         }
 181
 182         return result;
 183 }
 184
 185 /**
 186  * cdns3_req_ep0_set_address - Handling of SET_ADDRESS standard USB request
 187  * @priv_dev: extended gadget object
 188  * @ctrl_req: pointer to received setup packet
 189  *
 190  * Returns 0 if success, error code on error
 191  */
 192 static int cdns3_req_ep0_set_address(struct cdns3_device *priv_dev,
 193                                      struct usb_ctrlrequest *ctrl_req)
 194 {
 195         enum usb_device_state device_state = priv_dev->gadget.state;
 196         u32 reg;
 197         u32 addr;
 198
 199         addr = le16_to_cpu(ctrl_req->wValue);
 200
 201         if (addr > USB_DEVICE_MAX_ADDRESS) {
 202                 dev_err(priv_dev->dev,
 203                         "Device address (%d) cannot be greater than %d\n",
 204                         addr, USB_DEVICE_MAX_ADDRESS);
 205                 return -EINVAL;
 206         }
 207
 208         if (device_state == USB_STATE_CONFIGURED) {
 209                 dev_err(priv_dev->dev,
 210                         "can't set_address from configured state\n");
 211                 return -EINVAL;
 212         }
 213
 214         reg = readl(&priv_dev->regs->usb_cmd);
 215
 216         writel(reg | USB_CMD_FADDR(addr) | USB_CMD_SET_ADDR,
 217                &priv_dev->regs->usb_cmd);
 218
 219         usb_gadget_set_state(&priv_dev->gadget,
 220                              (addr ? USB_STATE_ADDRESS : USB_STATE_DEFAULT));
 221
 222         return 0;
 223 }
 224
 225 /**
 226  * cdns3_req_ep0_get_status - Handling of GET_STATUS standard USB request
 227  * @priv_dev: extended gadget object
 228  * @ctrl: pointer to received setup packet
 229  *
 230  * Returns 0 if success, error code on error
 231  */
 232 static int cdns3_req_ep0_get_status(struct cdns3_device *priv_dev,
 233                                     struct usb_ctrlrequest *ctrl)
 234 {
 235         struct cdns3_endpoint *priv_ep;
 236         __le16 *response_pkt;
 237         u16 usb_status = 0;
 238         u32 recip;
 239         u8 index;
 240
 241         recip = ctrl->bRequestType & USB_RECIP_MASK;
 242
 243         switch (recip) {
 244         case USB_RECIP_DEVICE:
 245                 /* self powered */
 246                 if (priv_dev->is_selfpowered)
 247                         usb_status = BIT(USB_DEVICE_SELF_POWERED);
 248
 249                 if (priv_dev->wake_up_flag)
 250                         usb_status |= BIT(USB_DEVICE_REMOTE_WAKEUP);
 251
 252                 if (priv_dev->gadget.speed != USB_SPEED_SUPER)
 253                         break;
 254
 255                 if (priv_dev->u1_allowed)
 256                         usb_status |= BIT(USB_DEV_STAT_U1_ENABLED);
 257
 258                 if (priv_dev->u2_allowed)
 259                         usb_status |= BIT(USB_DEV_STAT_U2_ENABLED);
 260
 261                 break;
 262         case USB_RECIP_INTERFACE:
 263                 return cdns3_ep0_delegate_req(priv_dev, ctrl);
 264         case USB_RECIP_ENDPOINT:
 265                 index = cdns3_ep_addr_to_index(le16_to_cpu(ctrl->wIndex));
 266                 priv_ep = priv_dev->eps[index];
 267
 268                 /* check if endpoint is stalled or stall is pending */
 269                 cdns3_select_ep(priv_dev, le16_to_cpu(ctrl->wIndex));
 270                 if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)) ||
 271                     (priv_ep->flags & EP_STALL_PENDING))
 272                         usb_status =  BIT(USB_ENDPOINT_HALT);
 273                 break;
 274         default:
 275                 return -EINVAL;
 276         }
 277
 278         response_pkt = (__le16 *)priv_dev->setup_buf;
 279         *response_pkt = cpu_to_le16(usb_status);
 280
 281         cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
 282                                sizeof(*response_pkt), 1, 0);
 283         return 0;
 284 }
 285
 286 static int cdns3_ep0_feature_handle_device(struct cdns3_device *priv_dev,
 287                                            struct usb_ctrlrequest *ctrl,
 288                                            int set)
 289 {
 290         enum usb_device_state state;
 291         enum usb_device_speed speed;
 292         int ret = 0;
 293         u32 wValue;
 294         u16 tmode;
 295
 296         wValue = le16_to_cpu(ctrl->wValue);
 297         state = priv_dev->gadget.state;
 298         speed = priv_dev->gadget.speed;
 299
 300         switch (wValue) {
 301         case USB_DEVICE_REMOTE_WAKEUP:
 302                 priv_dev->wake_up_flag = !!set;
 303                 break;
 304         case USB_DEVICE_U1_ENABLE:
 305                 if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
 306                         return -EINVAL;
 307
 308                 priv_dev->u1_allowed = !!set;
 309                 break;
 310         case USB_DEVICE_U2_ENABLE:
 311                 if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
 312                         return -EINVAL;
 313
 314                 priv_dev->u2_allowed = !!set;
 315                 break;
 316         case USB_DEVICE_LTM_ENABLE:
 317                 ret = -EINVAL;
 318                 break;
 319         case USB_DEVICE_TEST_MODE:
 320                 if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH)
 321                         return -EINVAL;
 322
 323                 tmode = le16_to_cpu(ctrl->wIndex);
 324
 325                 if (!set || (tmode & 0xff) != 0)
 326                         return -EINVAL;
 327
 328                 tmode >>= 8;
 329                 switch (tmode) {
 330                 case USB_TEST_J:
 331                 case USB_TEST_K:
 332                 case USB_TEST_SE0_NAK:
 333                 case USB_TEST_PACKET:
 334                         cdns3_set_register_bit(&priv_dev->regs->usb_cmd,
 335                                                USB_CMD_STMODE |
 336                                                USB_STS_TMODE_SEL(tmode - 1));
 337                         break;
 338                 default:
 339                         ret = -EINVAL;
 340                 }
 341                 break;
 342         default:
 343                 ret = -EINVAL;
 344         }
 345
 346         return ret;
 347 }
 348
 349 static int cdns3_ep0_feature_handle_intf(struct cdns3_device *priv_dev,
 350                                          struct usb_ctrlrequest *ctrl,
 351                                          int set)
 352 {
 353         u32 wValue;
 354         int ret = 0;
 355
 356         wValue = le16_to_cpu(ctrl->wValue);
 357
 358         switch (wValue) {
 359         case USB_INTRF_FUNC_SUSPEND:
 360                 break;
 361         default:
 362                 ret = -EINVAL;
 363         }
 364
 365         return ret;
 366 }
 367
 368 static int cdns3_ep0_feature_handle_endpoint(struct cdns3_device *priv_dev,
 369                                              struct usb_ctrlrequest *ctrl,
 370                                              int set)
 371 {
 372         struct cdns3_endpoint *priv_ep;
 373         int ret = 0;
 374         u8 index;
 375
 376         if (le16_to_cpu(ctrl->wValue) != USB_ENDPOINT_HALT)
 377                 return -EINVAL;
 378
 379         if (!(ctrl->wIndex & ~USB_DIR_IN))
 380                 return 0;
 381
 382         index = cdns3_ep_addr_to_index(le16_to_cpu(ctrl->wIndex));
 383         priv_ep = priv_dev->eps[index];
 384
 385         cdns3_select_ep(priv_dev, le16_to_cpu(ctrl->wIndex));
 386
 387         if (set)
 388                 __cdns3_gadget_ep_set_halt(priv_ep);
 389         else if (!(priv_ep->flags & EP_WEDGE))
 390                 ret = __cdns3_gadget_ep_clear_halt(priv_ep);
 391
 392         cdns3_select_ep(priv_dev, 0x00);
 393
 394         return ret;
 395 }
 396
 397 /**
 398  * cdns3_req_ep0_handle_feature -
 399  * Handling of GET/SET_FEATURE standard USB request
 400  *
 401  * @priv_dev: extended gadget object
 402  * @ctrl: pointer to received setup packet
 403  * @set: must be set to 1 for SET_FEATURE request
 404  *
 405  * Returns 0 if success, error code on error
 406  */
 407 static int cdns3_req_ep0_handle_feature(struct cdns3_device *priv_dev,
 408                                         struct usb_ctrlrequest *ctrl,
 409                                         int set)
 410 {
 411         int ret = 0;
 412         u32 recip;
 413
 414         recip = ctrl->bRequestType & USB_RECIP_MASK;
 415
 416         switch (recip) {
 417         case USB_RECIP_DEVICE:
 418                 ret = cdns3_ep0_feature_handle_device(priv_dev, ctrl, set);
 419                 break;
 420         case USB_RECIP_INTERFACE:
 421                 ret = cdns3_ep0_feature_handle_intf(priv_dev, ctrl, set);
 422                 break;
 423         case USB_RECIP_ENDPOINT:
 424                 ret = cdns3_ep0_feature_handle_endpoint(priv_dev, ctrl, set);
 425                 break;
 426         default:
 427                 return -EINVAL;
 428         }
 429
 430         return ret;
 431 }
 432
 433 /**
 434  * cdns3_req_ep0_set_sel - Handling of SET_SEL standard USB request
 435  * @priv_dev: extended gadget object
 436  * @ctrl_req: pointer to received setup packet
 437  *
 438  * Returns 0 if success, error code on error
 439  */
 440 static int cdns3_req_ep0_set_sel(struct cdns3_device *priv_dev,
 441                                  struct usb_ctrlrequest *ctrl_req)
 442 {
 443         if (priv_dev->gadget.state < USB_STATE_ADDRESS)
 444                 return -EINVAL;
 445
 446         if (le16_to_cpu(ctrl_req->wLength) != 6) {
 447                 dev_err(priv_dev->dev, "Set SEL should be 6 bytes, got %d\n",
 448                         ctrl_req->wLength);
 449                 return -EINVAL;
 450         }
 451
 452         cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma, 6, 1, 0);
 453         return 0;
 454 }
 455
 456 /**
 457  * cdns3_req_ep0_set_isoch_delay -
 458  * Handling of GET_ISOCH_DELAY standard USB request
 459  * @priv_dev: extended gadget object
 460  * @ctrl_req: pointer to received setup packet
 461  *
 462  * Returns 0 if success, error code on error
 463  */
 464 static int cdns3_req_ep0_set_isoch_delay(struct cdns3_device *priv_dev,
 465                                          struct usb_ctrlrequest *ctrl_req)
 466 {
 467         if (ctrl_req->wIndex || ctrl_req->wLength)
 468                 return -EINVAL;
 469
 470         priv_dev->isoch_delay = le16_to_cpu(ctrl_req->wValue);
 471
 472         return 0;
 473 }
 474
 475 /**
 476  * cdns3_ep0_standard_request - Handling standard USB requests
 477  * @priv_dev: extended gadget object
 478  * @ctrl_req: pointer to received setup packet
 479  *
 480  * Returns 0 if success, error code on error
 481  */
 482 static int cdns3_ep0_standard_request(struct cdns3_device *priv_dev,
 483                                       struct usb_ctrlrequest *ctrl_req)
 484 {
 485         int ret;
 486
 487         switch (ctrl_req->bRequest) {
 488         case USB_REQ_SET_ADDRESS:
 489                 ret = cdns3_req_ep0_set_address(priv_dev, ctrl_req);
 490                 break;
 491         case USB_REQ_SET_CONFIGURATION:
 492                 ret = cdns3_req_ep0_set_configuration(priv_dev, ctrl_req);
 493                 break;
 494         case USB_REQ_GET_STATUS:
 495                 ret = cdns3_req_ep0_get_status(priv_dev, ctrl_req);
 496                 break;
 497         case USB_REQ_CLEAR_FEATURE:
 498                 ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 0);
 499                 break;
 500         case USB_REQ_SET_FEATURE:
 501                 ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 1);
 502                 break;
 503         case USB_REQ_SET_SEL:
 504                 ret = cdns3_req_ep0_set_sel(priv_dev, ctrl_req);
 505                 break;
 506         case USB_REQ_SET_ISOCH_DELAY:
 507                 ret = cdns3_req_ep0_set_isoch_delay(priv_dev, ctrl_req);
 508                 break;
 509         default:
 510                 ret = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
 511                 break;
 512         }
 513
 514         return ret;
 515 }
 516
 517 static void __pending_setup_status_handler(struct cdns3_device *priv_dev)
 518 {
 519         struct usb_request *request = priv_dev->pending_status_request;
 520
 521         if (priv_dev->status_completion_no_call && request &&
 522             request->complete) {
 523                 request->complete(&priv_dev->eps[0]->endpoint, request);
 524                 priv_dev->status_completion_no_call = 0;
 525         }
 526 }
 527
 528 void cdns3_pending_setup_status_handler(struct work_struct *work)
 529 {
 530         struct cdns3_device *priv_dev = container_of(work, struct cdns3_device,
 531                         pending_status_wq);
 532         unsigned long flags;
 533
 534         spin_lock_irqsave(&priv_dev->lock, flags);
 535         __pending_setup_status_handler(priv_dev);
 536         spin_unlock_irqrestore(&priv_dev->lock, flags);
 537 }
 538
 539 /**
 540  * cdns3_ep0_setup_phase - Handling setup USB requests
 541  * @priv_dev: extended gadget object
 542  */
 543 static void cdns3_ep0_setup_phase(struct cdns3_device *priv_dev)
 544 {
 545         struct usb_ctrlrequest *ctrl = priv_dev->setup_buf;
 546         struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
 547         int result;
 548
 549         priv_dev->ep0_data_dir = ctrl->bRequestType & USB_DIR_IN;
 550
 551         trace_cdns3_ctrl_req(ctrl);
 552
 553         if (!list_empty(&priv_ep->pending_req_list)) {
 554                 struct usb_request *request;
 555
 556                 request = cdns3_next_request(&priv_ep->pending_req_list);
 557                 priv_ep->dir = priv_dev->ep0_data_dir;
 558                 cdns3_gadget_giveback(priv_ep, to_cdns3_request(request),
 559                                       -ECONNRESET);
 560         }
 561
 562         if (le16_to_cpu(ctrl->wLength))
 563                 priv_dev->ep0_stage = CDNS3_DATA_STAGE;
 564         else
 565                 priv_dev->ep0_stage = CDNS3_STATUS_STAGE;
 566
 567         if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
 568                 result = cdns3_ep0_standard_request(priv_dev, ctrl);
 569         else
 570                 result = cdns3_ep0_delegate_req(priv_dev, ctrl);
 571
 572         if (result == USB_GADGET_DELAYED_STATUS)
 573                 return;
 574
 575         if (result < 0)
 576                 cdns3_ep0_complete_setup(priv_dev, 1, 1);
 577         else if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE)
 578                 cdns3_ep0_complete_setup(priv_dev, 0, 1);
 579 }
 580
 581 static void cdns3_transfer_completed(struct cdns3_device *priv_dev)
 582 {
 583         struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
 584
 585         if (!list_empty(&priv_ep->pending_req_list)) {
 586                 struct usb_request *request;
 587
 588                 trace_cdns3_complete_trb(priv_ep, priv_ep->trb_pool);
 589                 request = cdns3_next_request(&priv_ep->pending_req_list);
 590
 591                 request->actual =
 592                         TRB_LEN(le32_to_cpu(priv_ep->trb_pool->length));
 593
 594                 priv_ep->dir = priv_dev->ep0_data_dir;
 595                 cdns3_gadget_giveback(priv_ep, to_cdns3_request(request), 0);
 596         }
 597
 598         cdns3_ep0_complete_setup(priv_dev, 0, 0);
 599 }
 600
 601 /**
 602  * cdns3_check_new_setup - Check if controller receive new SETUP packet.
 603  * @priv_dev: extended gadget object
 604  *
 605  * The SETUP packet can be kept in on-chip memory or in system memory.
 606  */
 607 static bool cdns3_check_new_setup(struct cdns3_device *priv_dev)
 608 {
 609         u32 ep_sts_reg;
 610
 611         cdns3_select_ep(priv_dev, USB_DIR_OUT);
 612         ep_sts_reg = readl(&priv_dev->regs->ep_sts);
 613
 614         return !!(ep_sts_reg & (EP_STS_SETUP | EP_STS_STPWAIT));
 615 }
 616
 617 /**
 618  * cdns3_check_ep0_interrupt_proceed - Processes interrupt related to endpoint 0
 619  * @priv_dev: extended gadget object
 620  * @dir: USB_DIR_IN for IN direction, USB_DIR_OUT for OUT direction
 621  */
 622 void cdns3_check_ep0_interrupt_proceed(struct cdns3_device *priv_dev, int dir)
 623 {
 624         u32 ep_sts_reg;
 625
 626         cdns3_select_ep(priv_dev, dir);
 627
 628         ep_sts_reg = readl(&priv_dev->regs->ep_sts);
 629         writel(ep_sts_reg, &priv_dev->regs->ep_sts);
 630
 631         trace_cdns3_ep0_irq(priv_dev, ep_sts_reg);
 632
 633         __pending_setup_status_handler(priv_dev);
 634
 635         if (ep_sts_reg & EP_STS_SETUP)
 636                 priv_dev->wait_for_setup = 1;
 637
 638         if (priv_dev->wait_for_setup && ep_sts_reg & EP_STS_IOC) {
 639                 priv_dev->wait_for_setup = 0;
 640                 cdns3_ep0_setup_phase(priv_dev);
 641         } else if ((ep_sts_reg & EP_STS_IOC) || (ep_sts_reg & EP_STS_ISP)) {
 642                 priv_dev->ep0_data_dir = dir;
 643                 cdns3_transfer_completed(priv_dev);
 644         }
 645
 646         if (ep_sts_reg & EP_STS_DESCMIS) {
 647                 if (dir == 0 && !priv_dev->setup_pending)
 648                         cdns3_prepare_setup_packet(priv_dev);
 649         }
 650 }
 651
 652 /**
 653  * cdns3_gadget_ep0_enable
 654  * @ep: pointer to endpoint zero object
 655  * @desc: pointer to usb endpoint descriptor
 656  *
 657  * Function shouldn't be called by gadget driver,
 658  * endpoint 0 is allways active
 659  */
 660 static int cdns3_gadget_ep0_enable(struct usb_ep *ep,
 661                                    const struct usb_endpoint_descriptor *desc)
 662 {
 663         return -EINVAL;
 664 }
 665
 666 /**
 667  * cdns3_gadget_ep0_disable
 668  * @ep: pointer to endpoint zero object
 669  *
 670  * Function shouldn't be called by gadget driver,
 671  * endpoint 0 is allways active
 672  */
 673 static int cdns3_gadget_ep0_disable(struct usb_ep *ep)
 674 {
 675         return -EINVAL;
 676 }
 677
 678 /**
 679  * cdns3_gadget_ep0_set_halt
 680  * @ep: pointer to endpoint zero object
 681  * @value: 1 for set stall, 0 for clear stall
 682  *
 683  * Returns 0
 684  */
 685 static int cdns3_gadget_ep0_set_halt(struct usb_ep *ep, int value)
 686 {
 687         /* TODO */
 688         return 0;
 689 }
 690
 691 /**
 692  * cdns3_gadget_ep0_queue Transfer data on endpoint zero
 693  * @ep: pointer to endpoint zero object
 694  * @request: pointer to request object
 695  * @gfp_flags: gfp flags
 696  *
 697  * Returns 0 on success, error code elsewhere
 698  */
 699 static int cdns3_gadget_ep0_queue(struct usb_ep *ep,
 700                                   struct usb_request *request,
 701                                   gfp_t gfp_flags)
 702 {
 703         struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
 704         struct cdns3_device *priv_dev = priv_ep->cdns3_dev;
 705         unsigned long flags;
 706         int ret = 0;
 707         u8 zlp = 0;
 708
 709         spin_lock_irqsave(&priv_dev->lock, flags);
 710         trace_cdns3_ep0_queue(priv_dev, request);
 711
 712         /* cancel the request if controller receive new SETUP packet. */
 713         if (cdns3_check_new_setup(priv_dev)) {
 714                 spin_unlock_irqrestore(&priv_dev->lock, flags);
 715                 return -ECONNRESET;
 716         }
 717
 718         /* send STATUS stage. Should be called only for SET_CONFIGURATION */
 719         if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE) {
 720                 u32 val;
 721
 722                 cdns3_select_ep(priv_dev, 0x00);
 723                 cdns3_set_hw_configuration(priv_dev);
 724                 cdns3_ep0_complete_setup(priv_dev, 0, 1);
 725                 /* wait until configuration set */
 726                 ret = readl_poll_timeout_atomic(&priv_dev->regs->usb_sts, val,
 727                                           val & USB_STS_CFGSTS_MASK, 1, 100);
 728                 if (ret == -ETIMEDOUT)
 729                         dev_warn(priv_dev->dev, "timeout for waiting configuration set\n");
 730
 731                 request->actual = 0;
 732                 priv_dev->status_completion_no_call = true;
 733                 priv_dev->pending_status_request = request;
 734                 spin_unlock_irqrestore(&priv_dev->lock, flags);
 735
 736                 /*
 737                  * Since there is no completion interrupt for status stage,
 738                  * it needs to call ->completion in software after
 739                  * ep0_queue is back.
 740                  */
 741                 queue_work(system_freezable_wq, &priv_dev->pending_status_wq);
 742                 return ret;
 743         }
 744
 745         if (!list_empty(&priv_ep->pending_req_list)) {
 746                 dev_err(priv_dev->dev,
 747                         "can't handle multiple requests for ep0\n");
 748                 spin_unlock_irqrestore(&priv_dev->lock, flags);
 749                 return -EBUSY;
 750         }
 751
 752         ret = usb_gadget_map_request_by_dev(priv_dev->sysdev, request,
 753                                             priv_dev->ep0_data_dir);
 754         if (ret) {
 755                 spin_unlock_irqrestore(&priv_dev->lock, flags);
 756                 dev_err(priv_dev->dev, "failed to map request\n");
 757                 return -EINVAL;
 758         }
 759
 760         request->status = -EINPROGRESS;
 761         list_add_tail(&request->list, &priv_ep->pending_req_list);
 762
 763         if (request->zero && request->length &&
 764             (request->length % ep->maxpacket == 0))
 765                 zlp = 1;
 766
 767         cdns3_ep0_run_transfer(priv_dev, request->dma, request->length, 1, zlp);
 768
 769         spin_unlock_irqrestore(&priv_dev->lock, flags);
 770
 771         return ret;
 772 }
 773
 774 /**
 775  * cdns3_gadget_ep_set_wedge Set wedge on selected endpoint
 776  * @ep: endpoint object
 777  *
 778  * Returns 0
 779  */
 780 int cdns3_gadget_ep_set_wedge(struct usb_ep *ep)
 781 {
 782         struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
 783         struct cdns3_device *priv_dev = priv_ep->cdns3_dev;
 784
 785         dev_dbg(priv_dev->dev, "Wedge for %s\n", ep->name);
 786         cdns3_gadget_ep_set_halt(ep, 1);
 787         priv_ep->flags |= EP_WEDGE;
 788
 789         return 0;
 790 }
 791
 792 const struct usb_ep_ops cdns3_gadget_ep0_ops = {
 793         .enable = cdns3_gadget_ep0_enable,
 794         .disable = cdns3_gadget_ep0_disable,
 795         .alloc_request = cdns3_gadget_ep_alloc_request,
 796         .free_request = cdns3_gadget_ep_free_request,
 797         .queue = cdns3_gadget_ep0_queue,
 798         .dequeue = cdns3_gadget_ep_dequeue,
 799         .set_halt = cdns3_gadget_ep0_set_halt,
 800         .set_wedge = cdns3_gadget_ep_set_wedge,
 801 };
 802
 803 /**
 804  * cdns3_ep0_config - Configures default endpoint
 805  * @priv_dev: extended gadget object
 806  *
 807  * Functions sets parameters: maximal packet size and enables interrupts
 808  */
 809 void cdns3_ep0_config(struct cdns3_device *priv_dev)
 810 {
 811         struct cdns3_usb_regs __iomem *regs;
 812         struct cdns3_endpoint *priv_ep;
 813         u32 max_packet_size = 64;
 814
 815         regs = priv_dev->regs;
 816
 817         if (priv_dev->gadget.speed == USB_SPEED_SUPER)
 818                 max_packet_size = 512;
 819
 820         priv_ep = priv_dev->eps[0];
 821
 822         if (!list_empty(&priv_ep->pending_req_list)) {
 823                 struct usb_request *request;
 824
 825                 request = cdns3_next_request(&priv_ep->pending_req_list);
 826                 list_del_init(&request->list);
 827         }
 828
 829         priv_dev->u1_allowed = 0;
 830         priv_dev->u2_allowed = 0;
 831
 832         priv_dev->gadget.ep0->maxpacket = max_packet_size;
 833         cdns3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(max_packet_size);
 834
 835         /* init ep out */
 836         cdns3_select_ep(priv_dev, USB_DIR_OUT);
 837
 838         if (priv_dev->dev_ver >= DEV_VER_V3) {
 839                 cdns3_set_register_bit(&priv_dev->regs->dtrans,
 840                                        BIT(0) | BIT(16));
 841                 cdns3_set_register_bit(&priv_dev->regs->tdl_from_trb,
 842                                        BIT(0) | BIT(16));
 843         }
 844
 845         writel(EP_CFG_ENABLE | EP_CFG_MAXPKTSIZE(max_packet_size),
 846                &regs->ep_cfg);
 847
 848         writel(EP_STS_EN_SETUPEN | EP_STS_EN_DESCMISEN | EP_STS_EN_TRBERREN,
 849                &regs->ep_sts_en);
 850
 851         /* init ep in */
 852         cdns3_select_ep(priv_dev, USB_DIR_IN);
 853
 854         writel(EP_CFG_ENABLE | EP_CFG_MAXPKTSIZE(max_packet_size),
 855                &regs->ep_cfg);
 856
 857         writel(EP_STS_EN_SETUPEN | EP_STS_EN_TRBERREN, &regs->ep_sts_en);
 858
 859         cdns3_set_register_bit(&regs->usb_conf, USB_CONF_U1DS | USB_CONF_U2DS);
 860 }
 861
 862 /**
 863  * cdns3_init_ep0 Initializes software endpoint 0 of gadget
 864  * @priv_dev: extended gadget object
 865  * @priv_ep: extended endpoint object
 866  *
 867  * Returns 0 on success else error code.
 868  */
 869 int cdns3_init_ep0(struct cdns3_device *priv_dev,
 870                    struct cdns3_endpoint *priv_ep)
 871 {
 872         sprintf(priv_ep->name, "ep0");
 873
 874         /* fill linux fields */
 875         priv_ep->endpoint.ops = &cdns3_gadget_ep0_ops;
 876         priv_ep->endpoint.maxburst = 1;
 877         usb_ep_set_maxpacket_limit(&priv_ep->endpoint,
 878                                    CDNS3_EP0_MAX_PACKET_LIMIT);
 879         priv_ep->endpoint.address = 0;
 880         priv_ep->endpoint.caps.type_control = 1;
 881         priv_ep->endpoint.caps.dir_in = 1;
 882         priv_ep->endpoint.caps.dir_out = 1;
 883         priv_ep->endpoint.name = priv_ep->name;
 884         priv_ep->endpoint.desc = &cdns3_gadget_ep0_desc;
 885         priv_dev->gadget.ep0 = &priv_ep->endpoint;
 886         priv_ep->type = USB_ENDPOINT_XFER_CONTROL;
 887
 888         return cdns3_allocate_trb_pool(priv_ep);
 889 }