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