1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Cadence USBHS-DEV driver. 4 * 5 * Copyright (C) 2023 Cadence Design Systems. 6 * 7 * Authors: Pawel Laszczak <pawell@cadence.com> 8 */ 9 10 #include <linux/usb/composite.h> 11 #include <asm/unaligned.h> 12 13 #include "cdns2-gadget.h" 14 #include "cdns2-trace.h" 15 16 static struct usb_endpoint_descriptor cdns2_gadget_ep0_desc = { 17 .bLength = USB_DT_ENDPOINT_SIZE, 18 .bDescriptorType = USB_DT_ENDPOINT, 19 .bmAttributes = USB_ENDPOINT_XFER_CONTROL, 20 .wMaxPacketSize = cpu_to_le16(64) 21 }; 22 23 static int cdns2_w_index_to_ep_index(u16 wIndex) 24 { 25 if (!(wIndex & USB_ENDPOINT_NUMBER_MASK)) 26 return 0; 27 28 return ((wIndex & USB_ENDPOINT_NUMBER_MASK) * 2) + 29 (wIndex & USB_ENDPOINT_DIR_MASK ? 1 : 0) - 1; 30 } 31 32 static bool cdns2_check_new_setup(struct cdns2_device *pdev) 33 { 34 u8 reg; 35 36 reg = readb(&pdev->ep0_regs->cs); 37 38 return !!(reg & EP0CS_CHGSET); 39 } 40 41 static void cdns2_ep0_enqueue(struct cdns2_device *pdev, dma_addr_t dma_addr, 42 unsigned int length, int zlp) 43 { 44 struct cdns2_adma_regs __iomem *regs = pdev->adma_regs; 45 struct cdns2_endpoint *pep = &pdev->eps[0]; 46 struct cdns2_ring *ring = &pep->ring; 47 48 ring->trbs[0].buffer = cpu_to_le32(TRB_BUFFER(dma_addr)); 49 ring->trbs[0].length = cpu_to_le32(TRB_LEN(length)); 50 51 if (zlp) { 52 ring->trbs[0].control = cpu_to_le32(TRB_CYCLE | 53 TRB_TYPE(TRB_NORMAL)); 54 ring->trbs[1].buffer = cpu_to_le32(TRB_BUFFER(dma_addr)); 55 ring->trbs[1].length = cpu_to_le32(TRB_LEN(0)); 56 ring->trbs[1].control = cpu_to_le32(TRB_CYCLE | TRB_IOC | 57 TRB_TYPE(TRB_NORMAL)); 58 } else { 59 ring->trbs[0].control = cpu_to_le32(TRB_CYCLE | TRB_IOC | 60 TRB_TYPE(TRB_NORMAL)); 61 ring->trbs[1].control = 0; 62 } 63 64 trace_cdns2_queue_trb(pep, ring->trbs); 65 66 if (!pep->dir) 67 writel(0, &pdev->ep0_regs->rxbc); 68 69 cdns2_select_ep(pdev, pep->dir); 70 71 writel(DMA_EP_STS_TRBERR, ®s->ep_sts); 72 writel(pep->ring.dma, ®s->ep_traddr); 73 74 trace_cdns2_doorbell_ep0(pep, readl(®s->ep_traddr)); 75 76 writel(DMA_EP_CMD_DRDY, ®s->ep_cmd); 77 } 78 79 static int cdns2_ep0_delegate_req(struct cdns2_device *pdev) 80 { 81 int ret; 82 83 spin_unlock(&pdev->lock); 84 ret = pdev->gadget_driver->setup(&pdev->gadget, &pdev->setup); 85 spin_lock(&pdev->lock); 86 87 return ret; 88 } 89 90 static void cdns2_ep0_stall(struct cdns2_device *pdev) 91 { 92 struct cdns2_endpoint *pep = &pdev->eps[0]; 93 struct cdns2_request *preq; 94 95 preq = cdns2_next_preq(&pep->pending_list); 96 set_reg_bit_8(&pdev->ep0_regs->cs, EP0CS_DSTALL); 97 98 if (pdev->ep0_stage == CDNS2_DATA_STAGE && preq) 99 cdns2_gadget_giveback(pep, preq, -ECONNRESET); 100 else if (preq) 101 list_del_init(&preq->list); 102 103 pdev->ep0_stage = CDNS2_SETUP_STAGE; 104 pep->ep_state |= EP_STALLED; 105 } 106 107 static void cdns2_status_stage(struct cdns2_device *pdev) 108 { 109 struct cdns2_endpoint *pep = &pdev->eps[0]; 110 struct cdns2_request *preq; 111 112 preq = cdns2_next_preq(&pep->pending_list); 113 if (preq) 114 list_del_init(&preq->list); 115 116 pdev->ep0_stage = CDNS2_SETUP_STAGE; 117 writeb(EP0CS_HSNAK, &pdev->ep0_regs->cs); 118 } 119 120 static int cdns2_req_ep0_set_configuration(struct cdns2_device *pdev, 121 struct usb_ctrlrequest *ctrl_req) 122 { 123 enum usb_device_state state = pdev->gadget.state; 124 u32 config = le16_to_cpu(ctrl_req->wValue); 125 int ret; 126 127 if (state < USB_STATE_ADDRESS) { 128 dev_err(pdev->dev, "Set Configuration - bad device state\n"); 129 return -EINVAL; 130 } 131 132 ret = cdns2_ep0_delegate_req(pdev); 133 if (ret) 134 return ret; 135 136 trace_cdns2_device_state(config ? "configured" : "addressed"); 137 138 if (!config) 139 usb_gadget_set_state(&pdev->gadget, USB_STATE_ADDRESS); 140 141 return 0; 142 } 143 144 static int cdns2_req_ep0_set_address(struct cdns2_device *pdev, u32 addr) 145 { 146 enum usb_device_state device_state = pdev->gadget.state; 147 u8 reg; 148 149 if (addr > USB_DEVICE_MAX_ADDRESS) { 150 dev_err(pdev->dev, 151 "Device address (%d) cannot be greater than %d\n", 152 addr, USB_DEVICE_MAX_ADDRESS); 153 return -EINVAL; 154 } 155 156 if (device_state == USB_STATE_CONFIGURED) { 157 dev_err(pdev->dev, 158 "can't set_address from configured state\n"); 159 return -EINVAL; 160 } 161 162 reg = readb(&pdev->usb_regs->fnaddr); 163 pdev->dev_address = reg; 164 165 usb_gadget_set_state(&pdev->gadget, 166 (addr ? USB_STATE_ADDRESS : USB_STATE_DEFAULT)); 167 168 trace_cdns2_device_state(addr ? "addressed" : "default"); 169 170 return 0; 171 } 172 173 static int cdns2_req_ep0_handle_status(struct cdns2_device *pdev, 174 struct usb_ctrlrequest *ctrl) 175 { 176 struct cdns2_endpoint *pep; 177 __le16 *response_pkt; 178 u16 status = 0; 179 int ep_sts; 180 u32 recip; 181 182 recip = ctrl->bRequestType & USB_RECIP_MASK; 183 184 switch (recip) { 185 case USB_RECIP_DEVICE: 186 status = pdev->gadget.is_selfpowered; 187 status |= pdev->may_wakeup << USB_DEVICE_REMOTE_WAKEUP; 188 break; 189 case USB_RECIP_INTERFACE: 190 return cdns2_ep0_delegate_req(pdev); 191 case USB_RECIP_ENDPOINT: 192 ep_sts = cdns2_w_index_to_ep_index(le16_to_cpu(ctrl->wIndex)); 193 pep = &pdev->eps[ep_sts]; 194 195 if (pep->ep_state & EP_STALLED) 196 status = BIT(USB_ENDPOINT_HALT); 197 break; 198 default: 199 return -EINVAL; 200 } 201 202 put_unaligned_le16(status, (__le16 *)pdev->ep0_preq.request.buf); 203 204 cdns2_ep0_enqueue(pdev, pdev->ep0_preq.request.dma, 205 sizeof(*response_pkt), 0); 206 207 return 0; 208 } 209 210 static int cdns2_ep0_handle_feature_device(struct cdns2_device *pdev, 211 struct usb_ctrlrequest *ctrl, 212 int set) 213 { 214 enum usb_device_state state; 215 enum usb_device_speed speed; 216 int ret = 0; 217 u32 wValue; 218 u16 tmode; 219 220 wValue = le16_to_cpu(ctrl->wValue); 221 state = pdev->gadget.state; 222 speed = pdev->gadget.speed; 223 224 switch (wValue) { 225 case USB_DEVICE_REMOTE_WAKEUP: 226 pdev->may_wakeup = !!set; 227 break; 228 case USB_DEVICE_TEST_MODE: 229 if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH) 230 return -EINVAL; 231 232 tmode = le16_to_cpu(ctrl->wIndex); 233 234 if (!set || (tmode & 0xff) != 0) 235 return -EINVAL; 236 237 tmode >>= 8; 238 switch (tmode) { 239 case USB_TEST_J: 240 case USB_TEST_K: 241 case USB_TEST_SE0_NAK: 242 case USB_TEST_PACKET: 243 /* 244 * The USBHS controller automatically handles the 245 * Set_Feature(testmode) request. Standard test modes 246 * that use values of test mode selector from 247 * 01h to 04h (Test_J, Test_K, Test_SE0_NAK, 248 * Test_Packet) are supported by the 249 * controller(HS - ack, FS - stall). 250 */ 251 break; 252 default: 253 ret = -EINVAL; 254 } 255 break; 256 default: 257 ret = -EINVAL; 258 } 259 260 return ret; 261 } 262 263 static int cdns2_ep0_handle_feature_intf(struct cdns2_device *pdev, 264 struct usb_ctrlrequest *ctrl, 265 int set) 266 { 267 int ret = 0; 268 u32 wValue; 269 270 wValue = le16_to_cpu(ctrl->wValue); 271 272 switch (wValue) { 273 case USB_INTRF_FUNC_SUSPEND: 274 break; 275 default: 276 ret = -EINVAL; 277 } 278 279 return ret; 280 } 281 282 static int cdns2_ep0_handle_feature_endpoint(struct cdns2_device *pdev, 283 struct usb_ctrlrequest *ctrl, 284 int set) 285 { 286 struct cdns2_endpoint *pep; 287 u8 wValue; 288 289 wValue = le16_to_cpu(ctrl->wValue); 290 pep = &pdev->eps[cdns2_w_index_to_ep_index(le16_to_cpu(ctrl->wIndex))]; 291 292 if (wValue != USB_ENDPOINT_HALT) 293 return -EINVAL; 294 295 if (!(le16_to_cpu(ctrl->wIndex) & ~USB_DIR_IN)) 296 return 0; 297 298 switch (wValue) { 299 case USB_ENDPOINT_HALT: 300 if (set || !(pep->ep_state & EP_WEDGE)) 301 return cdns2_halt_endpoint(pdev, pep, set); 302 break; 303 default: 304 dev_warn(pdev->dev, "WARN Incorrect wValue %04x\n", wValue); 305 return -EINVAL; 306 } 307 308 return 0; 309 } 310 311 static int cdns2_req_ep0_handle_feature(struct cdns2_device *pdev, 312 struct usb_ctrlrequest *ctrl, 313 int set) 314 { 315 switch (ctrl->bRequestType & USB_RECIP_MASK) { 316 case USB_RECIP_DEVICE: 317 return cdns2_ep0_handle_feature_device(pdev, ctrl, set); 318 case USB_RECIP_INTERFACE: 319 return cdns2_ep0_handle_feature_intf(pdev, ctrl, set); 320 case USB_RECIP_ENDPOINT: 321 return cdns2_ep0_handle_feature_endpoint(pdev, ctrl, set); 322 default: 323 return -EINVAL; 324 } 325 } 326 327 static int cdns2_ep0_std_request(struct cdns2_device *pdev) 328 { 329 struct usb_ctrlrequest *ctrl = &pdev->setup; 330 int ret; 331 332 switch (ctrl->bRequest) { 333 case USB_REQ_SET_ADDRESS: 334 ret = cdns2_req_ep0_set_address(pdev, 335 le16_to_cpu(ctrl->wValue)); 336 break; 337 case USB_REQ_SET_CONFIGURATION: 338 ret = cdns2_req_ep0_set_configuration(pdev, ctrl); 339 break; 340 case USB_REQ_GET_STATUS: 341 ret = cdns2_req_ep0_handle_status(pdev, ctrl); 342 break; 343 case USB_REQ_CLEAR_FEATURE: 344 ret = cdns2_req_ep0_handle_feature(pdev, ctrl, 0); 345 break; 346 case USB_REQ_SET_FEATURE: 347 ret = cdns2_req_ep0_handle_feature(pdev, ctrl, 1); 348 break; 349 default: 350 ret = cdns2_ep0_delegate_req(pdev); 351 break; 352 } 353 354 return ret; 355 } 356 357 static void __pending_setup_status_handler(struct cdns2_device *pdev) 358 { 359 struct usb_request *request = pdev->pending_status_request; 360 361 if (pdev->status_completion_no_call && request && request->complete) { 362 request->complete(&pdev->eps[0].endpoint, request); 363 pdev->status_completion_no_call = 0; 364 } 365 } 366 367 void cdns2_pending_setup_status_handler(struct work_struct *work) 368 { 369 struct cdns2_device *pdev = container_of(work, struct cdns2_device, 370 pending_status_wq); 371 unsigned long flags; 372 373 spin_lock_irqsave(&pdev->lock, flags); 374 __pending_setup_status_handler(pdev); 375 spin_unlock_irqrestore(&pdev->lock, flags); 376 } 377 378 void cdns2_handle_setup_packet(struct cdns2_device *pdev) 379 { 380 struct usb_ctrlrequest *ctrl = &pdev->setup; 381 struct cdns2_endpoint *pep = &pdev->eps[0]; 382 struct cdns2_request *preq; 383 int ret = 0; 384 u16 len; 385 u8 reg; 386 int i; 387 388 writeb(EP0CS_CHGSET, &pdev->ep0_regs->cs); 389 390 for (i = 0; i < 8; i++) 391 ((u8 *)&pdev->setup)[i] = readb(&pdev->ep0_regs->setupdat[i]); 392 393 /* 394 * If SETUP packet was modified while reading just simple ignore it. 395 * The new one will be handled latter. 396 */ 397 if (cdns2_check_new_setup(pdev)) { 398 trace_cdns2_ep0_setup("overridden"); 399 return; 400 } 401 402 trace_cdns2_ctrl_req(ctrl); 403 404 if (!pdev->gadget_driver) 405 goto out; 406 407 if (pdev->gadget.state == USB_STATE_NOTATTACHED) { 408 dev_err(pdev->dev, "ERR: Setup detected in unattached state\n"); 409 ret = -EINVAL; 410 goto out; 411 } 412 413 pep = &pdev->eps[0]; 414 415 /* Halt for Ep0 is cleared automatically when SETUP packet arrives. */ 416 pep->ep_state &= ~EP_STALLED; 417 418 if (!list_empty(&pep->pending_list)) { 419 preq = cdns2_next_preq(&pep->pending_list); 420 cdns2_gadget_giveback(pep, preq, -ECONNRESET); 421 } 422 423 len = le16_to_cpu(ctrl->wLength); 424 if (len) 425 pdev->ep0_stage = CDNS2_DATA_STAGE; 426 else 427 pdev->ep0_stage = CDNS2_STATUS_STAGE; 428 429 pep->dir = ctrl->bRequestType & USB_DIR_IN; 430 431 /* 432 * SET_ADDRESS request is acknowledged automatically by controller and 433 * in the worse case driver may not notice this request. To check 434 * whether this request has been processed driver can use 435 * fnaddr register. 436 */ 437 reg = readb(&pdev->usb_regs->fnaddr); 438 if (pdev->setup.bRequest != USB_REQ_SET_ADDRESS && 439 pdev->dev_address != reg) 440 cdns2_req_ep0_set_address(pdev, reg); 441 442 if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) 443 ret = cdns2_ep0_std_request(pdev); 444 else 445 ret = cdns2_ep0_delegate_req(pdev); 446 447 if (ret == USB_GADGET_DELAYED_STATUS) { 448 trace_cdns2_ep0_status_stage("delayed"); 449 return; 450 } 451 452 out: 453 if (ret < 0) 454 cdns2_ep0_stall(pdev); 455 else if (pdev->ep0_stage == CDNS2_STATUS_STAGE) 456 cdns2_status_stage(pdev); 457 } 458 459 static void cdns2_transfer_completed(struct cdns2_device *pdev) 460 { 461 struct cdns2_endpoint *pep = &pdev->eps[0]; 462 463 if (!list_empty(&pep->pending_list)) { 464 struct cdns2_request *preq; 465 466 trace_cdns2_complete_trb(pep, pep->ring.trbs); 467 preq = cdns2_next_preq(&pep->pending_list); 468 469 preq->request.actual = 470 TRB_LEN(le32_to_cpu(pep->ring.trbs->length)); 471 cdns2_gadget_giveback(pep, preq, 0); 472 } 473 474 cdns2_status_stage(pdev); 475 } 476 477 void cdns2_handle_ep0_interrupt(struct cdns2_device *pdev, int dir) 478 { 479 u32 ep_sts_reg; 480 481 cdns2_select_ep(pdev, dir); 482 483 trace_cdns2_ep0_irq(pdev); 484 485 ep_sts_reg = readl(&pdev->adma_regs->ep_sts); 486 writel(ep_sts_reg, &pdev->adma_regs->ep_sts); 487 488 __pending_setup_status_handler(pdev); 489 490 if ((ep_sts_reg & DMA_EP_STS_IOC) || (ep_sts_reg & DMA_EP_STS_ISP)) { 491 pdev->eps[0].dir = dir; 492 cdns2_transfer_completed(pdev); 493 } 494 } 495 496 /* 497 * Function shouldn't be called by gadget driver, 498 * endpoint 0 is allways active. 499 */ 500 static int cdns2_gadget_ep0_enable(struct usb_ep *ep, 501 const struct usb_endpoint_descriptor *desc) 502 { 503 return -EINVAL; 504 } 505 506 /* 507 * Function shouldn't be called by gadget driver, 508 * endpoint 0 is allways active. 509 */ 510 static int cdns2_gadget_ep0_disable(struct usb_ep *ep) 511 { 512 return -EINVAL; 513 } 514 515 static int cdns2_gadget_ep0_set_halt(struct usb_ep *ep, int value) 516 { 517 struct cdns2_endpoint *pep = ep_to_cdns2_ep(ep); 518 struct cdns2_device *pdev = pep->pdev; 519 unsigned long flags; 520 521 if (!value) 522 return 0; 523 524 spin_lock_irqsave(&pdev->lock, flags); 525 cdns2_ep0_stall(pdev); 526 spin_unlock_irqrestore(&pdev->lock, flags); 527 528 return 0; 529 } 530 531 static int cdns2_gadget_ep0_set_wedge(struct usb_ep *ep) 532 { 533 return cdns2_gadget_ep0_set_halt(ep, 1); 534 } 535 536 static int cdns2_gadget_ep0_queue(struct usb_ep *ep, 537 struct usb_request *request, 538 gfp_t gfp_flags) 539 { 540 struct cdns2_endpoint *pep = ep_to_cdns2_ep(ep); 541 struct cdns2_device *pdev = pep->pdev; 542 struct cdns2_request *preq; 543 unsigned long flags; 544 u8 zlp = 0; 545 int ret; 546 547 spin_lock_irqsave(&pdev->lock, flags); 548 549 preq = to_cdns2_request(request); 550 551 trace_cdns2_request_enqueue(preq); 552 553 /* Cancel the request if controller receive new SETUP packet. */ 554 if (cdns2_check_new_setup(pdev)) { 555 trace_cdns2_ep0_setup("overridden"); 556 spin_unlock_irqrestore(&pdev->lock, flags); 557 return -ECONNRESET; 558 } 559 560 /* Send STATUS stage. Should be called only for SET_CONFIGURATION. */ 561 if (pdev->ep0_stage == CDNS2_STATUS_STAGE) { 562 cdns2_status_stage(pdev); 563 564 request->actual = 0; 565 pdev->status_completion_no_call = true; 566 pdev->pending_status_request = request; 567 usb_gadget_set_state(&pdev->gadget, USB_STATE_CONFIGURED); 568 spin_unlock_irqrestore(&pdev->lock, flags); 569 570 /* 571 * Since there is no completion interrupt for status stage, 572 * it needs to call ->completion in software after 573 * cdns2_gadget_ep0_queue is back. 574 */ 575 queue_work(system_freezable_wq, &pdev->pending_status_wq); 576 return 0; 577 } 578 579 if (!list_empty(&pep->pending_list)) { 580 trace_cdns2_ep0_setup("pending"); 581 dev_err(pdev->dev, 582 "can't handle multiple requests for ep0\n"); 583 spin_unlock_irqrestore(&pdev->lock, flags); 584 return -EBUSY; 585 } 586 587 ret = usb_gadget_map_request_by_dev(pdev->dev, request, pep->dir); 588 if (ret) { 589 spin_unlock_irqrestore(&pdev->lock, flags); 590 dev_err(pdev->dev, "failed to map request\n"); 591 return -EINVAL; 592 } 593 594 request->status = -EINPROGRESS; 595 list_add_tail(&preq->list, &pep->pending_list); 596 597 if (request->zero && request->length && 598 (request->length % ep->maxpacket == 0)) 599 zlp = 1; 600 601 cdns2_ep0_enqueue(pdev, request->dma, request->length, zlp); 602 603 spin_unlock_irqrestore(&pdev->lock, flags); 604 605 return 0; 606 } 607 608 static const struct usb_ep_ops cdns2_gadget_ep0_ops = { 609 .enable = cdns2_gadget_ep0_enable, 610 .disable = cdns2_gadget_ep0_disable, 611 .alloc_request = cdns2_gadget_ep_alloc_request, 612 .free_request = cdns2_gadget_ep_free_request, 613 .queue = cdns2_gadget_ep0_queue, 614 .dequeue = cdns2_gadget_ep_dequeue, 615 .set_halt = cdns2_gadget_ep0_set_halt, 616 .set_wedge = cdns2_gadget_ep0_set_wedge, 617 }; 618 619 void cdns2_ep0_config(struct cdns2_device *pdev) 620 { 621 struct cdns2_endpoint *pep; 622 623 pep = &pdev->eps[0]; 624 625 if (!list_empty(&pep->pending_list)) { 626 struct cdns2_request *preq; 627 628 preq = cdns2_next_preq(&pep->pending_list); 629 list_del_init(&preq->list); 630 } 631 632 writeb(EP0_FIFO_AUTO, &pdev->ep0_regs->fifo); 633 cdns2_select_ep(pdev, USB_DIR_OUT); 634 writel(DMA_EP_CFG_ENABLE, &pdev->adma_regs->ep_cfg); 635 636 writeb(EP0_FIFO_IO_TX | EP0_FIFO_AUTO, &pdev->ep0_regs->fifo); 637 cdns2_select_ep(pdev, USB_DIR_IN); 638 writel(DMA_EP_CFG_ENABLE, &pdev->adma_regs->ep_cfg); 639 640 writeb(pdev->gadget.ep0->maxpacket, &pdev->ep0_regs->maxpack); 641 writel(DMA_EP_IEN_EP_OUT0 | DMA_EP_IEN_EP_IN0, 642 &pdev->adma_regs->ep_ien); 643 } 644 645 void cdns2_init_ep0(struct cdns2_device *pdev, 646 struct cdns2_endpoint *pep) 647 { 648 u16 maxpacket = le16_to_cpu(cdns2_gadget_ep0_desc.wMaxPacketSize); 649 650 usb_ep_set_maxpacket_limit(&pep->endpoint, maxpacket); 651 652 pep->endpoint.ops = &cdns2_gadget_ep0_ops; 653 pep->endpoint.desc = &cdns2_gadget_ep0_desc; 654 pep->endpoint.caps.type_control = true; 655 pep->endpoint.caps.dir_in = true; 656 pep->endpoint.caps.dir_out = true; 657 658 pdev->gadget.ep0 = &pep->endpoint; 659 } 660