usb/cdns3/cdns3-ep0.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Cadence USBSS DRD Driver - gadget side.
0004  *
0005  * Copyright (C) 2018 Cadence Design Systems.
0006  * Copyright (C) 2017-2018 NXP
0007  *
0008  * Authors: Pawel Jez <pjez@cadence.com>,
0009  *          Pawel Laszczak <pawell@cadence.com>
0010  *          Peter Chen <peter.chen@nxp.com>
0011  */
0012
0013 #include <linux/usb/composite.h>
0014 #include <linux/iopoll.h>
0015
0016 #include "cdns3-gadget.h"
0017 #include "cdns3-trace.h"
0018
0019 static struct usb_endpoint_descriptor cdns3_gadget_ep0_desc = {
0020     .bLength = USB_DT_ENDPOINT_SIZE,
0021     .bDescriptorType = USB_DT_ENDPOINT,
0022     .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
0023 };
0024
0025 /**
0026  * cdns3_ep0_run_transfer - Do transfer on default endpoint hardware
0027  * @priv_dev: extended gadget object
0028  * @dma_addr: physical address where data is/will be stored
0029  * @length: data length
0030  * @erdy: set it to 1 when ERDY packet should be sent -
0031  *        exit from flow control state
0032  * @zlp: add zero length packet
0033  */
0034 static void cdns3_ep0_run_transfer(struct cdns3_device *priv_dev,
0035                    dma_addr_t dma_addr,
0036                    unsigned int length, int erdy, int zlp)
0037 {
0038     struct cdns3_usb_regs __iomem *regs = priv_dev->regs;
0039     struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
0040
0041     priv_ep->trb_pool[0].buffer = cpu_to_le32(TRB_BUFFER(dma_addr));
0042     priv_ep->trb_pool[0].length = cpu_to_le32(TRB_LEN(length));
0043
0044     if (zlp) {
0045         priv_ep->trb_pool[0].control = cpu_to_le32(TRB_CYCLE | TRB_TYPE(TRB_NORMAL));
0046         priv_ep->trb_pool[1].buffer = cpu_to_le32(TRB_BUFFER(dma_addr));
0047         priv_ep->trb_pool[1].length = cpu_to_le32(TRB_LEN(0));
0048         priv_ep->trb_pool[1].control = cpu_to_le32(TRB_CYCLE | TRB_IOC |
0049             TRB_TYPE(TRB_NORMAL));
0050     } else {
0051         priv_ep->trb_pool[0].control = cpu_to_le32(TRB_CYCLE | TRB_IOC |
0052             TRB_TYPE(TRB_NORMAL));
0053         priv_ep->trb_pool[1].control = 0;
0054     }
0055
0056     trace_cdns3_prepare_trb(priv_ep, priv_ep->trb_pool);
0057
0058     cdns3_select_ep(priv_dev, priv_dev->ep0_data_dir);
0059
0060     writel(EP_STS_TRBERR, &regs->ep_sts);
0061     writel(EP_TRADDR_TRADDR(priv_ep->trb_pool_dma), &regs->ep_traddr);
0062     trace_cdns3_doorbell_ep0(priv_dev->ep0_data_dir ? "ep0in" : "ep0out",
0063                  readl(&regs->ep_traddr));
0064
0065     /* TRB should be prepared before starting transfer. */
0066     writel(EP_CMD_DRDY, &regs->ep_cmd);
0067
0068     /* Resume controller before arming transfer. */
0069     __cdns3_gadget_wakeup(priv_dev);
0070
0071     if (erdy)
0072         writel(EP_CMD_ERDY, &priv_dev->regs->ep_cmd);
0073 }
0074
0075 /**
0076  * cdns3_ep0_delegate_req - Returns status of handling setup packet
0077  * Setup is handled by gadget driver
0078  * @priv_dev: extended gadget object
0079  * @ctrl_req: pointer to received setup packet
0080  *
0081  * Returns zero on success or negative value on failure
0082  */
0083 static int cdns3_ep0_delegate_req(struct cdns3_device *priv_dev,
0084                   struct usb_ctrlrequest *ctrl_req)
0085 {
0086     int ret;
0087
0088     spin_unlock(&priv_dev->lock);
0089     priv_dev->setup_pending = 1;
0090     ret = priv_dev->gadget_driver->setup(&priv_dev->gadget, ctrl_req);
0091     priv_dev->setup_pending = 0;
0092     spin_lock(&priv_dev->lock);
0093     return ret;
0094 }
0095
0096 static void cdns3_prepare_setup_packet(struct cdns3_device *priv_dev)
0097 {
0098     priv_dev->ep0_data_dir = 0;
0099     priv_dev->ep0_stage = CDNS3_SETUP_STAGE;
0100     cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
0101                    sizeof(struct usb_ctrlrequest), 0, 0);
0102 }
0103
0104 static void cdns3_ep0_complete_setup(struct cdns3_device *priv_dev,
0105                      u8 send_stall, u8 send_erdy)
0106 {
0107     struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
0108     struct usb_request *request;
0109
0110     request = cdns3_next_request(&priv_ep->pending_req_list);
0111     if (request)
0112         list_del_init(&request->list);
0113
0114     if (send_stall) {
0115         trace_cdns3_halt(priv_ep, send_stall, 0);
0116         /* set_stall on ep0 */
0117         cdns3_select_ep(priv_dev, 0x00);
0118         writel(EP_CMD_SSTALL, &priv_dev->regs->ep_cmd);
0119     } else {
0120         cdns3_prepare_setup_packet(priv_dev);
0121     }
0122
0123     priv_dev->ep0_stage = CDNS3_SETUP_STAGE;
0124     writel((send_erdy ? EP_CMD_ERDY : 0) | EP_CMD_REQ_CMPL,
0125            &priv_dev->regs->ep_cmd);
0126 }
0127
0128 /**
0129  * cdns3_req_ep0_set_configuration - Handling of SET_CONFIG standard USB request
0130  * @priv_dev: extended gadget object
0131  * @ctrl_req: pointer to received setup packet
0132  *
0133  * Returns 0 if success, USB_GADGET_DELAYED_STATUS on deferred status stage,
0134  * error code on error
0135  */
0136 static int cdns3_req_ep0_set_configuration(struct cdns3_device *priv_dev,
0137                        struct usb_ctrlrequest *ctrl_req)
0138 {
0139     enum usb_device_state device_state = priv_dev->gadget.state;
0140     u32 config = le16_to_cpu(ctrl_req->wValue);
0141     int result = 0;
0142
0143     switch (device_state) {
0144     case USB_STATE_ADDRESS:
0145         result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
0146
0147         if (result || !config)
0148             goto reset_config;
0149
0150         break;
0151     case USB_STATE_CONFIGURED:
0152         result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
0153         if (!config && !result)
0154             goto reset_config;
0155
0156         break;
0157     default:
0158         return -EINVAL;
0159     }
0160
0161     return 0;
0162
0163 reset_config:
0164     if (result != USB_GADGET_DELAYED_STATUS)
0165         cdns3_hw_reset_eps_config(priv_dev);
0166
0167     usb_gadget_set_state(&priv_dev->gadget,
0168                  USB_STATE_ADDRESS);
0169
0170     return result;
0171 }
0172
0173 /**
0174  * cdns3_req_ep0_set_address - Handling of SET_ADDRESS standard USB request
0175  * @priv_dev: extended gadget object
0176  * @ctrl_req: pointer to received setup packet
0177  *
0178  * Returns 0 if success, error code on error
0179  */
0180 static int cdns3_req_ep0_set_address(struct cdns3_device *priv_dev,
0181                      struct usb_ctrlrequest *ctrl_req)
0182 {
0183     enum usb_device_state device_state = priv_dev->gadget.state;
0184     u32 reg;
0185     u32 addr;
0186
0187     addr = le16_to_cpu(ctrl_req->wValue);
0188
0189     if (addr > USB_DEVICE_MAX_ADDRESS) {
0190         dev_err(priv_dev->dev,
0191             "Device address (%d) cannot be greater than %d\n",
0192             addr, USB_DEVICE_MAX_ADDRESS);
0193         return -EINVAL;
0194     }
0195
0196     if (device_state == USB_STATE_CONFIGURED) {
0197         dev_err(priv_dev->dev,
0198             "can't set_address from configured state\n");
0199         return -EINVAL;
0200     }
0201
0202     reg = readl(&priv_dev->regs->usb_cmd);
0203
0204     writel(reg | USB_CMD_FADDR(addr) | USB_CMD_SET_ADDR,
0205            &priv_dev->regs->usb_cmd);
0206
0207     usb_gadget_set_state(&priv_dev->gadget,
0208                  (addr ? USB_STATE_ADDRESS : USB_STATE_DEFAULT));
0209
0210     return 0;
0211 }
0212
0213 /**
0214  * cdns3_req_ep0_get_status - Handling of GET_STATUS standard USB request
0215  * @priv_dev: extended gadget object
0216  * @ctrl: pointer to received setup packet
0217  *
0218  * Returns 0 if success, error code on error
0219  */
0220 static int cdns3_req_ep0_get_status(struct cdns3_device *priv_dev,
0221                     struct usb_ctrlrequest *ctrl)
0222 {
0223     struct cdns3_endpoint *priv_ep;
0224     __le16 *response_pkt;
0225     u16 usb_status = 0;
0226     u32 recip;
0227     u8 index;
0228
0229     recip = ctrl->bRequestType & USB_RECIP_MASK;
0230
0231     switch (recip) {
0232     case USB_RECIP_DEVICE:
0233         /* self powered */
0234         if (priv_dev->is_selfpowered)
0235             usb_status = BIT(USB_DEVICE_SELF_POWERED);
0236
0237         if (priv_dev->wake_up_flag)
0238             usb_status |= BIT(USB_DEVICE_REMOTE_WAKEUP);
0239
0240         if (priv_dev->gadget.speed != USB_SPEED_SUPER)
0241             break;
0242
0243         if (priv_dev->u1_allowed)
0244             usb_status |= BIT(USB_DEV_STAT_U1_ENABLED);
0245
0246         if (priv_dev->u2_allowed)
0247             usb_status |= BIT(USB_DEV_STAT_U2_ENABLED);
0248
0249         break;
0250     case USB_RECIP_INTERFACE:
0251         return cdns3_ep0_delegate_req(priv_dev, ctrl);
0252     case USB_RECIP_ENDPOINT:
0253         index = cdns3_ep_addr_to_index(le16_to_cpu(ctrl->wIndex));
0254         priv_ep = priv_dev->eps[index];
0255
0256         /* check if endpoint is stalled or stall is pending */
0257         cdns3_select_ep(priv_dev, le16_to_cpu(ctrl->wIndex));
0258         if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)) ||
0259             (priv_ep->flags & EP_STALL_PENDING))
0260             usb_status =  BIT(USB_ENDPOINT_HALT);
0261         break;
0262     default:
0263         return -EINVAL;
0264     }
0265
0266     response_pkt = (__le16 *)priv_dev->setup_buf;
0267     *response_pkt = cpu_to_le16(usb_status);
0268
0269     cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
0270                    sizeof(*response_pkt), 1, 0);
0271     return 0;
0272 }
0273
0274 static int cdns3_ep0_feature_handle_device(struct cdns3_device *priv_dev,
0275                        struct usb_ctrlrequest *ctrl,
0276                        int set)
0277 {
0278     enum usb_device_state state;
0279     enum usb_device_speed speed;
0280     int ret = 0;
0281     u32 wValue;
0282     u16 tmode;
0283
0284     wValue = le16_to_cpu(ctrl->wValue);
0285     state = priv_dev->gadget.state;
0286     speed = priv_dev->gadget.speed;
0287
0288     switch (wValue) {
0289     case USB_DEVICE_REMOTE_WAKEUP:
0290         priv_dev->wake_up_flag = !!set;
0291         break;
0292     case USB_DEVICE_U1_ENABLE:
0293         if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
0294             return -EINVAL;
0295
0296         priv_dev->u1_allowed = !!set;
0297         break;
0298     case USB_DEVICE_U2_ENABLE:
0299         if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
0300             return -EINVAL;
0301
0302         priv_dev->u2_allowed = !!set;
0303         break;
0304     case USB_DEVICE_LTM_ENABLE:
0305         ret = -EINVAL;
0306         break;
0307     case USB_DEVICE_TEST_MODE:
0308         if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH)
0309             return -EINVAL;
0310
0311         tmode = le16_to_cpu(ctrl->wIndex);
0312
0313         if (!set || (tmode & 0xff) != 0)
0314             return -EINVAL;
0315
0316         tmode >>= 8;
0317         switch (tmode) {
0318         case USB_TEST_J:
0319         case USB_TEST_K:
0320         case USB_TEST_SE0_NAK:
0321         case USB_TEST_PACKET:
0322             cdns3_set_register_bit(&priv_dev->regs->usb_cmd,
0323                            USB_CMD_STMODE |
0324                            USB_STS_TMODE_SEL(tmode - 1));
0325             break;
0326         default:
0327             ret = -EINVAL;
0328         }
0329         break;
0330     default:
0331         ret = -EINVAL;
0332     }
0333
0334     return ret;
0335 }
0336
0337 static int cdns3_ep0_feature_handle_intf(struct cdns3_device *priv_dev,
0338                      struct usb_ctrlrequest *ctrl,
0339                      int set)
0340 {
0341     u32 wValue;
0342     int ret = 0;
0343
0344     wValue = le16_to_cpu(ctrl->wValue);
0345
0346     switch (wValue) {
0347     case USB_INTRF_FUNC_SUSPEND:
0348         break;
0349     default:
0350         ret = -EINVAL;
0351     }
0352
0353     return ret;
0354 }
0355
0356 static int cdns3_ep0_feature_handle_endpoint(struct cdns3_device *priv_dev,
0357                          struct usb_ctrlrequest *ctrl,
0358                          int set)
0359 {
0360     struct cdns3_endpoint *priv_ep;
0361     int ret = 0;
0362     u8 index;
0363
0364     if (le16_to_cpu(ctrl->wValue) != USB_ENDPOINT_HALT)
0365         return -EINVAL;
0366
0367     if (!(le16_to_cpu(ctrl->wIndex) & ~USB_DIR_IN))
0368         return 0;
0369
0370     index = cdns3_ep_addr_to_index(le16_to_cpu(ctrl->wIndex));
0371     priv_ep = priv_dev->eps[index];
0372
0373     cdns3_select_ep(priv_dev, le16_to_cpu(ctrl->wIndex));
0374
0375     if (set)
0376         __cdns3_gadget_ep_set_halt(priv_ep);
0377     else if (!(priv_ep->flags & EP_WEDGE))
0378         ret = __cdns3_gadget_ep_clear_halt(priv_ep);
0379
0380     cdns3_select_ep(priv_dev, 0x00);
0381
0382     return ret;
0383 }
0384
0385 /**
0386  * cdns3_req_ep0_handle_feature -
0387  * Handling of GET/SET_FEATURE standard USB request
0388  *
0389  * @priv_dev: extended gadget object
0390  * @ctrl: pointer to received setup packet
0391  * @set: must be set to 1 for SET_FEATURE request
0392  *
0393  * Returns 0 if success, error code on error
0394  */
0395 static int cdns3_req_ep0_handle_feature(struct cdns3_device *priv_dev,
0396                     struct usb_ctrlrequest *ctrl,
0397                     int set)
0398 {
0399     int ret = 0;
0400     u32 recip;
0401
0402     recip = ctrl->bRequestType & USB_RECIP_MASK;
0403
0404     switch (recip) {
0405     case USB_RECIP_DEVICE:
0406         ret = cdns3_ep0_feature_handle_device(priv_dev, ctrl, set);
0407         break;
0408     case USB_RECIP_INTERFACE:
0409         ret = cdns3_ep0_feature_handle_intf(priv_dev, ctrl, set);
0410         break;
0411     case USB_RECIP_ENDPOINT:
0412         ret = cdns3_ep0_feature_handle_endpoint(priv_dev, ctrl, set);
0413         break;
0414     default:
0415         return -EINVAL;
0416     }
0417
0418     return ret;
0419 }
0420
0421 /**
0422  * cdns3_req_ep0_set_sel - Handling of SET_SEL standard USB request
0423  * @priv_dev: extended gadget object
0424  * @ctrl_req: pointer to received setup packet
0425  *
0426  * Returns 0 if success, error code on error
0427  */
0428 static int cdns3_req_ep0_set_sel(struct cdns3_device *priv_dev,
0429                  struct usb_ctrlrequest *ctrl_req)
0430 {
0431     if (priv_dev->gadget.state < USB_STATE_ADDRESS)
0432         return -EINVAL;
0433
0434     if (le16_to_cpu(ctrl_req->wLength) != 6) {
0435         dev_err(priv_dev->dev, "Set SEL should be 6 bytes, got %d\n",
0436             ctrl_req->wLength);
0437         return -EINVAL;
0438     }
0439
0440     cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma, 6, 1, 0);
0441     return 0;
0442 }
0443
0444 /**
0445  * cdns3_req_ep0_set_isoch_delay -
0446  * Handling of GET_ISOCH_DELAY standard USB request
0447  * @priv_dev: extended gadget object
0448  * @ctrl_req: pointer to received setup packet
0449  *
0450  * Returns 0 if success, error code on error
0451  */
0452 static int cdns3_req_ep0_set_isoch_delay(struct cdns3_device *priv_dev,
0453                      struct usb_ctrlrequest *ctrl_req)
0454 {
0455     if (ctrl_req->wIndex || ctrl_req->wLength)
0456         return -EINVAL;
0457
0458     priv_dev->isoch_delay = le16_to_cpu(ctrl_req->wValue);
0459
0460     return 0;
0461 }
0462
0463 /**
0464  * cdns3_ep0_standard_request - Handling standard USB requests
0465  * @priv_dev: extended gadget object
0466  * @ctrl_req: pointer to received setup packet
0467  *
0468  * Returns 0 if success, error code on error
0469  */
0470 static int cdns3_ep0_standard_request(struct cdns3_device *priv_dev,
0471                       struct usb_ctrlrequest *ctrl_req)
0472 {
0473     int ret;
0474
0475     switch (ctrl_req->bRequest) {
0476     case USB_REQ_SET_ADDRESS:
0477         ret = cdns3_req_ep0_set_address(priv_dev, ctrl_req);
0478         break;
0479     case USB_REQ_SET_CONFIGURATION:
0480         ret = cdns3_req_ep0_set_configuration(priv_dev, ctrl_req);
0481         break;
0482     case USB_REQ_GET_STATUS:
0483         ret = cdns3_req_ep0_get_status(priv_dev, ctrl_req);
0484         break;
0485     case USB_REQ_CLEAR_FEATURE:
0486         ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 0);
0487         break;
0488     case USB_REQ_SET_FEATURE:
0489         ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 1);
0490         break;
0491     case USB_REQ_SET_SEL:
0492         ret = cdns3_req_ep0_set_sel(priv_dev, ctrl_req);
0493         break;
0494     case USB_REQ_SET_ISOCH_DELAY:
0495         ret = cdns3_req_ep0_set_isoch_delay(priv_dev, ctrl_req);
0496         break;
0497     default:
0498         ret = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
0499         break;
0500     }
0501
0502     return ret;
0503 }
0504
0505 static void __pending_setup_status_handler(struct cdns3_device *priv_dev)
0506 {
0507     struct usb_request *request = priv_dev->pending_status_request;
0508
0509     if (priv_dev->status_completion_no_call && request &&
0510         request->complete) {
0511         request->complete(&priv_dev->eps[0]->endpoint, request);
0512         priv_dev->status_completion_no_call = 0;
0513     }
0514 }
0515
0516 void cdns3_pending_setup_status_handler(struct work_struct *work)
0517 {
0518     struct cdns3_device *priv_dev = container_of(work, struct cdns3_device,
0519             pending_status_wq);
0520     unsigned long flags;
0521
0522     spin_lock_irqsave(&priv_dev->lock, flags);
0523     __pending_setup_status_handler(priv_dev);
0524     spin_unlock_irqrestore(&priv_dev->lock, flags);
0525 }
0526
0527 /**
0528  * cdns3_ep0_setup_phase - Handling setup USB requests
0529  * @priv_dev: extended gadget object
0530  */
0531 static void cdns3_ep0_setup_phase(struct cdns3_device *priv_dev)
0532 {
0533     struct usb_ctrlrequest *ctrl = priv_dev->setup_buf;
0534     struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
0535     int result;
0536
0537     priv_dev->ep0_data_dir = ctrl->bRequestType & USB_DIR_IN;
0538
0539     trace_cdns3_ctrl_req(ctrl);
0540
0541     if (!list_empty(&priv_ep->pending_req_list)) {
0542         struct usb_request *request;
0543
0544         request = cdns3_next_request(&priv_ep->pending_req_list);
0545         priv_ep->dir = priv_dev->ep0_data_dir;
0546         cdns3_gadget_giveback(priv_ep, to_cdns3_request(request),
0547                       -ECONNRESET);
0548     }
0549
0550     if (le16_to_cpu(ctrl->wLength))
0551         priv_dev->ep0_stage = CDNS3_DATA_STAGE;
0552     else
0553         priv_dev->ep0_stage = CDNS3_STATUS_STAGE;
0554
0555     if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
0556         result = cdns3_ep0_standard_request(priv_dev, ctrl);
0557     else
0558         result = cdns3_ep0_delegate_req(priv_dev, ctrl);
0559
0560     if (result == USB_GADGET_DELAYED_STATUS)
0561         return;
0562
0563     if (result < 0)
0564         cdns3_ep0_complete_setup(priv_dev, 1, 1);
0565     else if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE)
0566         cdns3_ep0_complete_setup(priv_dev, 0, 1);
0567 }
0568
0569 static void cdns3_transfer_completed(struct cdns3_device *priv_dev)
0570 {
0571     struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
0572
0573     if (!list_empty(&priv_ep->pending_req_list)) {
0574         struct usb_request *request;
0575
0576         trace_cdns3_complete_trb(priv_ep, priv_ep->trb_pool);
0577         request = cdns3_next_request(&priv_ep->pending_req_list);
0578
0579         request->actual =
0580             TRB_LEN(le32_to_cpu(priv_ep->trb_pool->length));
0581
0582         priv_ep->dir = priv_dev->ep0_data_dir;
0583         cdns3_gadget_giveback(priv_ep, to_cdns3_request(request), 0);
0584     }
0585
0586     cdns3_ep0_complete_setup(priv_dev, 0, 0);
0587 }
0588
0589 /**
0590  * cdns3_check_new_setup - Check if controller receive new SETUP packet.
0591  * @priv_dev: extended gadget object
0592  *
0593  * The SETUP packet can be kept in on-chip memory or in system memory.
0594  */
0595 static bool cdns3_check_new_setup(struct cdns3_device *priv_dev)
0596 {
0597     u32 ep_sts_reg;
0598
0599     cdns3_select_ep(priv_dev, USB_DIR_OUT);
0600     ep_sts_reg = readl(&priv_dev->regs->ep_sts);
0601
0602     return !!(ep_sts_reg & (EP_STS_SETUP | EP_STS_STPWAIT));
0603 }
0604
0605 /**
0606  * cdns3_check_ep0_interrupt_proceed - Processes interrupt related to endpoint 0
0607  * @priv_dev: extended gadget object
0608  * @dir: USB_DIR_IN for IN direction, USB_DIR_OUT for OUT direction
0609  */
0610 void cdns3_check_ep0_interrupt_proceed(struct cdns3_device *priv_dev, int dir)
0611 {
0612     u32 ep_sts_reg;
0613
0614     cdns3_select_ep(priv_dev, dir);
0615
0616     ep_sts_reg = readl(&priv_dev->regs->ep_sts);
0617     writel(ep_sts_reg, &priv_dev->regs->ep_sts);
0618
0619     trace_cdns3_ep0_irq(priv_dev, ep_sts_reg);
0620
0621     __pending_setup_status_handler(priv_dev);
0622
0623     if (ep_sts_reg & EP_STS_SETUP)
0624         priv_dev->wait_for_setup = 1;
0625
0626     if (priv_dev->wait_for_setup && ep_sts_reg & EP_STS_IOC) {
0627         priv_dev->wait_for_setup = 0;
0628         cdns3_ep0_setup_phase(priv_dev);
0629     } else if ((ep_sts_reg & EP_STS_IOC) || (ep_sts_reg & EP_STS_ISP)) {
0630         priv_dev->ep0_data_dir = dir;
0631         cdns3_transfer_completed(priv_dev);
0632     }
0633
0634     if (ep_sts_reg & EP_STS_DESCMIS) {
0635         if (dir == 0 && !priv_dev->setup_pending)
0636             cdns3_prepare_setup_packet(priv_dev);
0637     }
0638 }
0639
0640 /**
0641  * cdns3_gadget_ep0_enable
0642  * @ep: pointer to endpoint zero object
0643  * @desc: pointer to usb endpoint descriptor
0644  *
0645  * Function shouldn't be called by gadget driver,
0646  * endpoint 0 is allways active
0647  */
0648 static int cdns3_gadget_ep0_enable(struct usb_ep *ep,
0649                    const struct usb_endpoint_descriptor *desc)
0650 {
0651     return -EINVAL;
0652 }
0653
0654 /**
0655  * cdns3_gadget_ep0_disable
0656  * @ep: pointer to endpoint zero object
0657  *
0658  * Function shouldn't be called by gadget driver,
0659  * endpoint 0 is allways active
0660  */
0661 static int cdns3_gadget_ep0_disable(struct usb_ep *ep)
0662 {
0663     return -EINVAL;
0664 }
0665
0666 /**
0667  * cdns3_gadget_ep0_set_halt
0668  * @ep: pointer to endpoint zero object
0669  * @value: 1 for set stall, 0 for clear stall
0670  *
0671  * Returns 0
0672  */
0673 static int cdns3_gadget_ep0_set_halt(struct usb_ep *ep, int value)
0674 {
0675     /* TODO */
0676     return 0;
0677 }
0678
0679 /**
0680  * cdns3_gadget_ep0_queue - Transfer data on endpoint zero
0681  * @ep: pointer to endpoint zero object
0682  * @request: pointer to request object
0683  * @gfp_flags: gfp flags
0684  *
0685  * Returns 0 on success, error code elsewhere
0686  */
0687 static int cdns3_gadget_ep0_queue(struct usb_ep *ep,
0688                   struct usb_request *request,
0689                   gfp_t gfp_flags)
0690 {
0691     struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
0692     struct cdns3_device *priv_dev = priv_ep->cdns3_dev;
0693     unsigned long flags;
0694     int ret = 0;
0695     u8 zlp = 0;
0696     int i;
0697
0698     spin_lock_irqsave(&priv_dev->lock, flags);
0699     trace_cdns3_ep0_queue(priv_dev, request);
0700
0701     /* cancel the request if controller receive new SETUP packet. */
0702     if (cdns3_check_new_setup(priv_dev)) {
0703         spin_unlock_irqrestore(&priv_dev->lock, flags);
0704         return -ECONNRESET;
0705     }
0706
0707     /* send STATUS stage. Should be called only for SET_CONFIGURATION */
0708     if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE) {
0709         u32 val;
0710
0711         cdns3_select_ep(priv_dev, 0x00);
0712
0713         /*
0714          * Configure all non-control EPs which are not enabled by class driver
0715          */
0716         for (i = 0; i < CDNS3_ENDPOINTS_MAX_COUNT; i++) {
0717             priv_ep = priv_dev->eps[i];
0718             if (priv_ep && priv_ep->flags & EP_CLAIMED &&
0719                 !(priv_ep->flags & EP_ENABLED))
0720                 cdns3_ep_config(priv_ep, 0);
0721         }
0722
0723         cdns3_set_hw_configuration(priv_dev);
0724         cdns3_ep0_complete_setup(priv_dev, 0, 1);
0725         /* wait until configuration set */
0726         ret = readl_poll_timeout_atomic(&priv_dev->regs->usb_sts, val,
0727                       val & USB_STS_CFGSTS_MASK, 1, 100);
0728         if (ret == -ETIMEDOUT)
0729             dev_warn(priv_dev->dev, "timeout for waiting configuration set\n");
0730
0731         request->actual = 0;
0732         priv_dev->status_completion_no_call = true;
0733         priv_dev->pending_status_request = request;
0734         usb_gadget_set_state(&priv_dev->gadget, USB_STATE_CONFIGURED);
0735         spin_unlock_irqrestore(&priv_dev->lock, flags);
0736
0737         /*
0738          * Since there is no completion interrupt for status stage,
0739          * it needs to call ->completion in software after
0740          * ep0_queue is back.
0741          */
0742         queue_work(system_freezable_wq, &priv_dev->pending_status_wq);
0743         return ret;
0744     }
0745
0746     if (!list_empty(&priv_ep->pending_req_list)) {
0747         dev_err(priv_dev->dev,
0748             "can't handle multiple requests for ep0\n");
0749         spin_unlock_irqrestore(&priv_dev->lock, flags);
0750         return -EBUSY;
0751     }
0752
0753     ret = usb_gadget_map_request_by_dev(priv_dev->sysdev, request,
0754                         priv_dev->ep0_data_dir);
0755     if (ret) {
0756         spin_unlock_irqrestore(&priv_dev->lock, flags);
0757         dev_err(priv_dev->dev, "failed to map request\n");
0758         return -EINVAL;
0759     }
0760
0761     request->status = -EINPROGRESS;
0762     list_add_tail(&request->list, &priv_ep->pending_req_list);
0763
0764     if (request->zero && request->length &&
0765         (request->length % ep->maxpacket == 0))
0766         zlp = 1;
0767
0768     cdns3_ep0_run_transfer(priv_dev, request->dma, request->length, 1, zlp);
0769
0770     spin_unlock_irqrestore(&priv_dev->lock, flags);
0771
0772     return ret;
0773 }
0774
0775 /**
0776  * cdns3_gadget_ep_set_wedge - Set wedge on selected endpoint
0777  * @ep: endpoint object
0778  *
0779  * Returns 0
0780  */
0781 int cdns3_gadget_ep_set_wedge(struct usb_ep *ep)
0782 {
0783     struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
0784     struct cdns3_device *priv_dev = priv_ep->cdns3_dev;
0785
0786     dev_dbg(priv_dev->dev, "Wedge for %s\n", ep->name);
0787     cdns3_gadget_ep_set_halt(ep, 1);
0788     priv_ep->flags |= EP_WEDGE;
0789
0790     return 0;
0791 }
0792
0793 static const struct usb_ep_ops cdns3_gadget_ep0_ops = {
0794     .enable = cdns3_gadget_ep0_enable,
0795     .disable = cdns3_gadget_ep0_disable,
0796     .alloc_request = cdns3_gadget_ep_alloc_request,
0797     .free_request = cdns3_gadget_ep_free_request,
0798     .queue = cdns3_gadget_ep0_queue,
0799     .dequeue = cdns3_gadget_ep_dequeue,
0800     .set_halt = cdns3_gadget_ep0_set_halt,
0801     .set_wedge = cdns3_gadget_ep_set_wedge,
0802 };
0803
0804 /**
0805  * cdns3_ep0_config - Configures default endpoint
0806  * @priv_dev: extended gadget object
0807  *
0808  * Functions sets parameters: maximal packet size and enables interrupts
0809  */
0810 void cdns3_ep0_config(struct cdns3_device *priv_dev)
0811 {
0812     struct cdns3_usb_regs __iomem *regs;
0813     struct cdns3_endpoint *priv_ep;
0814     u32 max_packet_size = 64;
0815     u32 ep_cfg;
0816
0817     regs = priv_dev->regs;
0818
0819     if (priv_dev->gadget.speed == USB_SPEED_SUPER)
0820         max_packet_size = 512;
0821
0822     priv_ep = priv_dev->eps[0];
0823
0824     if (!list_empty(&priv_ep->pending_req_list)) {
0825         struct usb_request *request;
0826
0827         request = cdns3_next_request(&priv_ep->pending_req_list);
0828         list_del_init(&request->list);
0829     }
0830
0831     priv_dev->u1_allowed = 0;
0832     priv_dev->u2_allowed = 0;
0833
0834     priv_dev->gadget.ep0->maxpacket = max_packet_size;
0835     cdns3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(max_packet_size);
0836
0837     /* init ep out */
0838     cdns3_select_ep(priv_dev, USB_DIR_OUT);
0839
0840     if (priv_dev->dev_ver >= DEV_VER_V3) {
0841         cdns3_set_register_bit(&priv_dev->regs->dtrans,
0842                        BIT(0) | BIT(16));
0843         cdns3_set_register_bit(&priv_dev->regs->tdl_from_trb,
0844                        BIT(0) | BIT(16));
0845     }
0846
0847     ep_cfg = EP_CFG_ENABLE | EP_CFG_MAXPKTSIZE(max_packet_size);
0848
0849     if (!(priv_ep->flags & EP_CONFIGURED))
0850         writel(ep_cfg, &regs->ep_cfg);
0851
0852     writel(EP_STS_EN_SETUPEN | EP_STS_EN_DESCMISEN | EP_STS_EN_TRBERREN,
0853            &regs->ep_sts_en);
0854
0855     /* init ep in */
0856     cdns3_select_ep(priv_dev, USB_DIR_IN);
0857
0858     if (!(priv_ep->flags & EP_CONFIGURED))
0859         writel(ep_cfg, &regs->ep_cfg);
0860
0861     priv_ep->flags |= EP_CONFIGURED;
0862
0863     writel(EP_STS_EN_SETUPEN | EP_STS_EN_TRBERREN, &regs->ep_sts_en);
0864
0865     cdns3_set_register_bit(&regs->usb_conf, USB_CONF_U1DS | USB_CONF_U2DS);
0866 }
0867
0868 /**
0869  * cdns3_init_ep0 - Initializes software endpoint 0 of gadget
0870  * @priv_dev: extended gadget object
0871  * @priv_ep: extended endpoint object
0872  *
0873  * Returns 0 on success else error code.
0874  */
0875 int cdns3_init_ep0(struct cdns3_device *priv_dev,
0876            struct cdns3_endpoint *priv_ep)
0877 {
0878     sprintf(priv_ep->name, "ep0");
0879
0880     /* fill linux fields */
0881     priv_ep->endpoint.ops = &cdns3_gadget_ep0_ops;
0882     priv_ep->endpoint.maxburst = 1;
0883     usb_ep_set_maxpacket_limit(&priv_ep->endpoint,
0884                    CDNS3_EP0_MAX_PACKET_LIMIT);
0885     priv_ep->endpoint.address = 0;
0886     priv_ep->endpoint.caps.type_control = 1;
0887     priv_ep->endpoint.caps.dir_in = 1;
0888     priv_ep->endpoint.caps.dir_out = 1;
0889     priv_ep->endpoint.name = priv_ep->name;
0890     priv_ep->endpoint.desc = &cdns3_gadget_ep0_desc;
0891     priv_dev->gadget.ep0 = &priv_ep->endpoint;
0892     priv_ep->type = USB_ENDPOINT_XFER_CONTROL;
0893
0894     return cdns3_allocate_trb_pool(priv_ep);
0895 }