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