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