1 /* 2 * bdc_udc.c - BRCM BDC USB3.0 device controller gagdet ops 3 * 4 * Copyright (C) 2014 Broadcom Corporation 5 * 6 * Author: Ashwini Pahuja 7 * 8 * Based on drivers under drivers/usb/gadget/udc/ 9 * 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the 12 * Free Software Foundation; either version 2 of the License, or (at your 13 * option) any later version. 14 * 15 */ 16 #include <linux/module.h> 17 #include <linux/pci.h> 18 #include <linux/dma-mapping.h> 19 #include <linux/kernel.h> 20 #include <linux/delay.h> 21 #include <linux/ioport.h> 22 #include <linux/sched.h> 23 #include <linux/slab.h> 24 #include <linux/errno.h> 25 #include <linux/init.h> 26 #include <linux/timer.h> 27 #include <linux/list.h> 28 #include <linux/interrupt.h> 29 #include <linux/moduleparam.h> 30 #include <linux/device.h> 31 #include <linux/usb/ch9.h> 32 #include <linux/usb/gadget.h> 33 #include <linux/usb/otg.h> 34 #include <linux/pm.h> 35 #include <linux/io.h> 36 #include <linux/irq.h> 37 #include <asm/unaligned.h> 38 #include <linux/platform_device.h> 39 40 #include "bdc.h" 41 #include "bdc_ep.h" 42 #include "bdc_cmd.h" 43 #include "bdc_dbg.h" 44 45 static const struct usb_gadget_ops bdc_gadget_ops; 46 47 static const char * const conn_speed_str[] = { 48 "Not connected", 49 "Full Speed", 50 "Low Speed", 51 "High Speed", 52 "Super Speed", 53 }; 54 55 /* EP0 initial descripror */ 56 static struct usb_endpoint_descriptor bdc_gadget_ep0_desc = { 57 .bLength = USB_DT_ENDPOINT_SIZE, 58 .bDescriptorType = USB_DT_ENDPOINT, 59 .bmAttributes = USB_ENDPOINT_XFER_CONTROL, 60 .bEndpointAddress = 0, 61 .wMaxPacketSize = cpu_to_le16(EP0_MAX_PKT_SIZE), 62 }; 63 64 /* Advance the srr dqp maintained by SW */ 65 static void srr_dqp_index_advc(struct bdc *bdc, u32 srr_num) 66 { 67 struct srr *srr; 68 69 srr = &bdc->srr; 70 dev_dbg_ratelimited(bdc->dev, "srr->dqp_index:%d\n", srr->dqp_index); 71 srr->dqp_index++; 72 /* rollback to 0 if we are past the last */ 73 if (srr->dqp_index == NUM_SR_ENTRIES) 74 srr->dqp_index = 0; 75 } 76 77 /* connect sr */ 78 static void bdc_uspc_connected(struct bdc *bdc) 79 { 80 u32 speed, temp; 81 u32 usppms; 82 int ret; 83 84 temp = bdc_readl(bdc->regs, BDC_USPC); 85 speed = BDC_PSP(temp); 86 dev_dbg(bdc->dev, "%s speed=%x\n", __func__, speed); 87 switch (speed) { 88 case BDC_SPEED_SS: 89 bdc_gadget_ep0_desc.wMaxPacketSize = 90 cpu_to_le16(EP0_MAX_PKT_SIZE); 91 bdc->gadget.ep0->maxpacket = EP0_MAX_PKT_SIZE; 92 bdc->gadget.speed = USB_SPEED_SUPER; 93 /* Enable U1T in SS mode */ 94 usppms = bdc_readl(bdc->regs, BDC_USPPMS); 95 usppms &= ~BDC_U1T(0xff); 96 usppms |= BDC_U1T(U1_TIMEOUT); 97 usppms |= BDC_PORT_W1S; 98 bdc_writel(bdc->regs, BDC_USPPMS, usppms); 99 break; 100 101 case BDC_SPEED_HS: 102 bdc_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(64); 103 bdc->gadget.ep0->maxpacket = 64; 104 bdc->gadget.speed = USB_SPEED_HIGH; 105 break; 106 107 case BDC_SPEED_FS: 108 bdc_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(64); 109 bdc->gadget.ep0->maxpacket = 64; 110 bdc->gadget.speed = USB_SPEED_FULL; 111 break; 112 113 case BDC_SPEED_LS: 114 bdc_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(8); 115 bdc->gadget.ep0->maxpacket = 8; 116 bdc->gadget.speed = USB_SPEED_LOW; 117 break; 118 default: 119 dev_err(bdc->dev, "UNDEFINED SPEED\n"); 120 return; 121 } 122 dev_dbg(bdc->dev, "connected at %s\n", conn_speed_str[speed]); 123 /* Now we know the speed, configure ep0 */ 124 bdc->bdc_ep_array[1]->desc = &bdc_gadget_ep0_desc; 125 ret = bdc_config_ep(bdc, bdc->bdc_ep_array[1]); 126 if (ret) 127 dev_err(bdc->dev, "EP0 config failed\n"); 128 bdc->bdc_ep_array[1]->usb_ep.desc = &bdc_gadget_ep0_desc; 129 bdc->bdc_ep_array[1]->flags |= BDC_EP_ENABLED; 130 usb_gadget_set_state(&bdc->gadget, USB_STATE_DEFAULT); 131 } 132 133 /* device got disconnected */ 134 static void bdc_uspc_disconnected(struct bdc *bdc, bool reinit) 135 { 136 struct bdc_ep *ep; 137 138 dev_dbg(bdc->dev, "%s\n", __func__); 139 /* 140 * Only stop ep0 from here, rest of the endpoints will be disabled 141 * from gadget_disconnect 142 */ 143 ep = bdc->bdc_ep_array[1]; 144 if (ep && (ep->flags & BDC_EP_ENABLED)) 145 /* if enabled then stop and remove requests */ 146 bdc_ep_disable(ep); 147 148 if (bdc->gadget_driver && bdc->gadget_driver->disconnect) { 149 spin_unlock(&bdc->lock); 150 bdc->gadget_driver->disconnect(&bdc->gadget); 151 spin_lock(&bdc->lock); 152 } 153 /* Set Unknown speed */ 154 bdc->gadget.speed = USB_SPEED_UNKNOWN; 155 bdc->devstatus &= DEVSTATUS_CLEAR; 156 bdc->delayed_status = false; 157 bdc->reinit = reinit; 158 bdc->test_mode = false; 159 } 160 161 /* TNotify wkaeup timer */ 162 static void bdc_func_wake_timer(struct work_struct *work) 163 { 164 struct bdc *bdc = container_of(work, struct bdc, func_wake_notify.work); 165 unsigned long flags; 166 167 dev_dbg(bdc->dev, "%s\n", __func__); 168 spin_lock_irqsave(&bdc->lock, flags); 169 /* 170 * Check if host has started transferring on endpoints 171 * FUNC_WAKE_ISSUED is cleared when transfer has started after resume 172 */ 173 if (bdc->devstatus & FUNC_WAKE_ISSUED) { 174 dev_dbg(bdc->dev, "FUNC_WAKE_ISSUED FLAG IS STILL SET\n"); 175 /* flag is still set, so again send func wake */ 176 bdc_function_wake_fh(bdc, 0); 177 schedule_delayed_work(&bdc->func_wake_notify, 178 msecs_to_jiffies(BDC_TNOTIFY)); 179 } 180 spin_unlock_irqrestore(&bdc->lock, flags); 181 } 182 183 /* handler for Link state change condition */ 184 static void handle_link_state_change(struct bdc *bdc, u32 uspc) 185 { 186 u32 link_state; 187 188 dev_dbg(bdc->dev, "Link state change"); 189 link_state = BDC_PST(uspc); 190 switch (link_state) { 191 case BDC_LINK_STATE_U3: 192 if ((bdc->gadget.speed != USB_SPEED_UNKNOWN) && 193 bdc->gadget_driver->suspend) { 194 dev_dbg(bdc->dev, "Entered Suspend mode\n"); 195 spin_unlock(&bdc->lock); 196 bdc->devstatus |= DEVICE_SUSPENDED; 197 bdc->gadget_driver->suspend(&bdc->gadget); 198 spin_lock(&bdc->lock); 199 } 200 break; 201 case BDC_LINK_STATE_U0: 202 if (bdc->devstatus & REMOTE_WAKEUP_ISSUED) { 203 bdc->devstatus &= ~REMOTE_WAKEUP_ISSUED; 204 if (bdc->gadget.speed == USB_SPEED_SUPER) { 205 bdc_function_wake_fh(bdc, 0); 206 bdc->devstatus |= FUNC_WAKE_ISSUED; 207 /* 208 * Start a Notification timer and check if the 209 * Host transferred anything on any of the EPs, 210 * if not then send function wake again every 211 * TNotification secs until host initiates 212 * transfer to BDC, USB3 spec Table 8.13 213 */ 214 schedule_delayed_work( 215 &bdc->func_wake_notify, 216 msecs_to_jiffies(BDC_TNOTIFY)); 217 dev_dbg(bdc->dev, "sched func_wake_notify\n"); 218 } 219 } 220 break; 221 222 case BDC_LINK_STATE_RESUME: 223 dev_dbg(bdc->dev, "Resumed from Suspend\n"); 224 if (bdc->devstatus & DEVICE_SUSPENDED) { 225 bdc->gadget_driver->resume(&bdc->gadget); 226 bdc->devstatus &= ~DEVICE_SUSPENDED; 227 } 228 break; 229 default: 230 dev_dbg(bdc->dev, "link state:%d\n", link_state); 231 } 232 } 233 234 /* something changes on upstream port, handle it here */ 235 void bdc_sr_uspc(struct bdc *bdc, struct bdc_sr *sreport) 236 { 237 u32 clear_flags = 0; 238 u32 uspc; 239 bool connected = false; 240 bool disconn = false; 241 242 uspc = bdc_readl(bdc->regs, BDC_USPC); 243 dev_dbg(bdc->dev, "%s uspc=0x%08x\n", __func__, uspc); 244 245 /* Port connect changed */ 246 if (uspc & BDC_PCC) { 247 /* Vbus not present, and not connected to Downstream port */ 248 if ((uspc & BDC_VBC) && !(uspc & BDC_VBS) && !(uspc & BDC_PCS)) 249 disconn = true; 250 else if ((uspc & BDC_PCS) && !BDC_PST(uspc)) 251 connected = true; 252 clear_flags |= BDC_PCC; 253 } 254 255 /* Change in VBus and VBus is present */ 256 if ((uspc & BDC_VBC) && (uspc & BDC_VBS)) { 257 if (bdc->pullup) { 258 dev_dbg(bdc->dev, "Do a softconnect\n"); 259 /* Attached state, do a softconnect */ 260 bdc_softconn(bdc); 261 usb_gadget_set_state(&bdc->gadget, USB_STATE_POWERED); 262 } 263 clear_flags |= BDC_VBC; 264 } else if ((uspc & BDC_PRS) || (uspc & BDC_PRC) || disconn) { 265 /* Hot reset, warm reset, 2.0 bus reset or disconn */ 266 dev_dbg(bdc->dev, "Port reset or disconn\n"); 267 bdc_uspc_disconnected(bdc, disconn); 268 clear_flags |= BDC_PRC; 269 } else if ((uspc & BDC_PSC) && (uspc & BDC_PCS)) { 270 /* Change in Link state */ 271 handle_link_state_change(bdc, uspc); 272 clear_flags |= BDC_PSC; 273 } 274 275 /* 276 * In SS we might not have PRC bit set before connection, but in 2.0 277 * the PRC bit is set before connection, so moving this condition out 278 * of bus reset to handle both SS/2.0 speeds. 279 */ 280 if (connected) { 281 /* This is the connect event for U0/L0 */ 282 dev_dbg(bdc->dev, "Connected\n"); 283 bdc_uspc_connected(bdc); 284 bdc->devstatus &= ~(DEVICE_SUSPENDED); 285 } 286 uspc = bdc_readl(bdc->regs, BDC_USPC); 287 uspc &= (~BDC_USPSC_RW); 288 dev_dbg(bdc->dev, "uspc=%x\n", uspc); 289 bdc_writel(bdc->regs, BDC_USPC, clear_flags); 290 } 291 292 /* Main interrupt handler for bdc */ 293 static irqreturn_t bdc_udc_interrupt(int irq, void *_bdc) 294 { 295 u32 eqp_index, dqp_index, sr_type, srr_int; 296 struct bdc_sr *sreport; 297 struct bdc *bdc = _bdc; 298 u32 status; 299 int ret; 300 301 spin_lock(&bdc->lock); 302 status = bdc_readl(bdc->regs, BDC_BDCSC); 303 if (!(status & BDC_GIP)) { 304 spin_unlock(&bdc->lock); 305 return IRQ_NONE; 306 } 307 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0)); 308 /* Check if the SRR IP bit it set? */ 309 if (!(srr_int & BDC_SRR_IP)) { 310 dev_warn(bdc->dev, "Global irq pending but SRR IP is 0\n"); 311 spin_unlock(&bdc->lock); 312 return IRQ_NONE; 313 } 314 eqp_index = BDC_SRR_EPI(srr_int); 315 dqp_index = BDC_SRR_DPI(srr_int); 316 dev_dbg(bdc->dev, 317 "%s eqp_index=%d dqp_index=%d srr.dqp_index=%d\n\n", 318 __func__, eqp_index, dqp_index, bdc->srr.dqp_index); 319 320 /* check for ring empty condition */ 321 if (eqp_index == dqp_index) { 322 dev_dbg(bdc->dev, "SRR empty?\n"); 323 spin_unlock(&bdc->lock); 324 return IRQ_HANDLED; 325 } 326 327 while (bdc->srr.dqp_index != eqp_index) { 328 sreport = &bdc->srr.sr_bds[bdc->srr.dqp_index]; 329 /* sreport is read before using it */ 330 rmb(); 331 sr_type = le32_to_cpu(sreport->offset[3]) & BD_TYPE_BITMASK; 332 dev_dbg_ratelimited(bdc->dev, "sr_type=%d\n", sr_type); 333 switch (sr_type) { 334 case SR_XSF: 335 bdc->sr_handler[0](bdc, sreport); 336 break; 337 338 case SR_USPC: 339 bdc->sr_handler[1](bdc, sreport); 340 break; 341 default: 342 dev_warn(bdc->dev, "SR:%d not handled\n", sr_type); 343 } 344 /* Advance the srr dqp index */ 345 srr_dqp_index_advc(bdc, 0); 346 } 347 /* update the hw dequeue pointer */ 348 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0)); 349 srr_int &= ~BDC_SRR_DPI_MASK; 350 srr_int &= ~(BDC_SRR_RWS|BDC_SRR_RST|BDC_SRR_ISR); 351 srr_int |= ((bdc->srr.dqp_index) << 16); 352 srr_int |= BDC_SRR_IP; 353 bdc_writel(bdc->regs, BDC_SRRINT(0), srr_int); 354 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0)); 355 if (bdc->reinit) { 356 ret = bdc_reinit(bdc); 357 if (ret) 358 dev_err(bdc->dev, "err in bdc reinit\n"); 359 } 360 361 spin_unlock(&bdc->lock); 362 363 return IRQ_HANDLED; 364 } 365 366 /* Gadget ops */ 367 static int bdc_udc_start(struct usb_gadget *gadget, 368 struct usb_gadget_driver *driver) 369 { 370 struct bdc *bdc = gadget_to_bdc(gadget); 371 unsigned long flags; 372 int ret = 0; 373 374 dev_dbg(bdc->dev, "%s()\n", __func__); 375 spin_lock_irqsave(&bdc->lock, flags); 376 if (bdc->gadget_driver) { 377 dev_err(bdc->dev, "%s is already bound to %s\n", 378 bdc->gadget.name, 379 bdc->gadget_driver->driver.name); 380 ret = -EBUSY; 381 goto err; 382 } 383 /* 384 * Run the controller from here and when BDC is connected to 385 * Host then driver will receive a USPC SR with VBUS present 386 * and then driver will do a softconnect. 387 */ 388 ret = bdc_run(bdc); 389 if (ret) { 390 dev_err(bdc->dev, "%s bdc run fail\n", __func__); 391 goto err; 392 } 393 bdc->gadget_driver = driver; 394 bdc->gadget.dev.driver = &driver->driver; 395 err: 396 spin_unlock_irqrestore(&bdc->lock, flags); 397 398 return ret; 399 } 400 401 static int bdc_udc_stop(struct usb_gadget *gadget) 402 { 403 struct bdc *bdc = gadget_to_bdc(gadget); 404 unsigned long flags; 405 406 dev_dbg(bdc->dev, "%s()\n", __func__); 407 spin_lock_irqsave(&bdc->lock, flags); 408 bdc_stop(bdc); 409 bdc->gadget_driver = NULL; 410 bdc->gadget.dev.driver = NULL; 411 spin_unlock_irqrestore(&bdc->lock, flags); 412 413 return 0; 414 } 415 416 static int bdc_udc_pullup(struct usb_gadget *gadget, int is_on) 417 { 418 struct bdc *bdc = gadget_to_bdc(gadget); 419 unsigned long flags; 420 u32 uspc; 421 422 dev_dbg(bdc->dev, "%s() is_on:%d\n", __func__, is_on); 423 if (!gadget) 424 return -EINVAL; 425 426 spin_lock_irqsave(&bdc->lock, flags); 427 if (!is_on) { 428 bdc_softdisconn(bdc); 429 bdc->pullup = false; 430 } else { 431 /* 432 * For a self powered device, we need to wait till we receive 433 * a VBUS change and Vbus present event, then if pullup flag 434 * is set, then only we present the Termintation. 435 */ 436 bdc->pullup = true; 437 /* 438 * Check if BDC is already connected to Host i.e Vbus=1, 439 * if yes, then present TERM now, this is typical for bus 440 * powered devices. 441 */ 442 uspc = bdc_readl(bdc->regs, BDC_USPC); 443 if (uspc & BDC_VBS) 444 bdc_softconn(bdc); 445 } 446 spin_unlock_irqrestore(&bdc->lock, flags); 447 448 return 0; 449 } 450 451 static int bdc_udc_set_selfpowered(struct usb_gadget *gadget, 452 int is_self) 453 { 454 struct bdc *bdc = gadget_to_bdc(gadget); 455 unsigned long flags; 456 457 dev_dbg(bdc->dev, "%s()\n", __func__); 458 gadget->is_selfpowered = (is_self != 0); 459 spin_lock_irqsave(&bdc->lock, flags); 460 if (!is_self) 461 bdc->devstatus |= 1 << USB_DEVICE_SELF_POWERED; 462 else 463 bdc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED); 464 465 spin_unlock_irqrestore(&bdc->lock, flags); 466 467 return 0; 468 } 469 470 static int bdc_udc_wakeup(struct usb_gadget *gadget) 471 { 472 struct bdc *bdc = gadget_to_bdc(gadget); 473 unsigned long flags; 474 u8 link_state; 475 u32 uspc; 476 int ret = 0; 477 478 dev_dbg(bdc->dev, 479 "%s() bdc->devstatus=%08x\n", 480 __func__, bdc->devstatus); 481 482 if (!(bdc->devstatus & REMOTE_WAKE_ENABLE)) 483 return -EOPNOTSUPP; 484 485 spin_lock_irqsave(&bdc->lock, flags); 486 uspc = bdc_readl(bdc->regs, BDC_USPC); 487 link_state = BDC_PST(uspc); 488 dev_dbg(bdc->dev, "link_state =%d portsc=%x", link_state, uspc); 489 if (link_state != BDC_LINK_STATE_U3) { 490 dev_warn(bdc->dev, 491 "can't wakeup from link state %d\n", 492 link_state); 493 ret = -EINVAL; 494 goto out; 495 } 496 if (bdc->gadget.speed == USB_SPEED_SUPER) 497 bdc->devstatus |= REMOTE_WAKEUP_ISSUED; 498 499 uspc &= ~BDC_PST_MASK; 500 uspc &= (~BDC_USPSC_RW); 501 uspc |= BDC_PST(BDC_LINK_STATE_U0); 502 uspc |= BDC_SWS; 503 bdc_writel(bdc->regs, BDC_USPC, uspc); 504 uspc = bdc_readl(bdc->regs, BDC_USPC); 505 link_state = BDC_PST(uspc); 506 dev_dbg(bdc->dev, "link_state =%d portsc=%x", link_state, uspc); 507 out: 508 spin_unlock_irqrestore(&bdc->lock, flags); 509 510 return ret; 511 } 512 513 static const struct usb_gadget_ops bdc_gadget_ops = { 514 .wakeup = bdc_udc_wakeup, 515 .set_selfpowered = bdc_udc_set_selfpowered, 516 .pullup = bdc_udc_pullup, 517 .udc_start = bdc_udc_start, 518 .udc_stop = bdc_udc_stop, 519 }; 520 521 /* Init the gadget interface and register the udc */ 522 int bdc_udc_init(struct bdc *bdc) 523 { 524 u32 temp; 525 int ret; 526 527 dev_dbg(bdc->dev, "%s()\n", __func__); 528 bdc->gadget.ops = &bdc_gadget_ops; 529 bdc->gadget.max_speed = USB_SPEED_SUPER; 530 bdc->gadget.speed = USB_SPEED_UNKNOWN; 531 bdc->gadget.dev.parent = bdc->dev; 532 533 bdc->gadget.sg_supported = false; 534 535 536 bdc->gadget.name = BRCM_BDC_NAME; 537 ret = devm_request_irq(bdc->dev, bdc->irq, bdc_udc_interrupt, 538 IRQF_SHARED , BRCM_BDC_NAME, bdc); 539 if (ret) { 540 dev_err(bdc->dev, 541 "failed to request irq #%d %d\n", 542 bdc->irq, ret); 543 return ret; 544 } 545 546 ret = bdc_init_ep(bdc); 547 if (ret) { 548 dev_err(bdc->dev, "bdc init ep fail: %d\n", ret); 549 return ret; 550 } 551 552 ret = usb_add_gadget_udc(bdc->dev, &bdc->gadget); 553 if (ret) { 554 dev_err(bdc->dev, "failed to register udc\n"); 555 goto err0; 556 } 557 usb_gadget_set_state(&bdc->gadget, USB_STATE_NOTATTACHED); 558 bdc->bdc_ep_array[1]->desc = &bdc_gadget_ep0_desc; 559 /* 560 * Allocate bd list for ep0 only, ep0 will be enabled on connect 561 * status report when the speed is known 562 */ 563 ret = bdc_ep_enable(bdc->bdc_ep_array[1]); 564 if (ret) { 565 dev_err(bdc->dev, "fail to enable %s\n", 566 bdc->bdc_ep_array[1]->name); 567 goto err1; 568 } 569 INIT_DELAYED_WORK(&bdc->func_wake_notify, bdc_func_wake_timer); 570 /* Enable Interrupts */ 571 temp = bdc_readl(bdc->regs, BDC_BDCSC); 572 temp |= BDC_GIE; 573 bdc_writel(bdc->regs, BDC_BDCSC, temp); 574 return 0; 575 err1: 576 usb_del_gadget_udc(&bdc->gadget); 577 err0: 578 bdc_free_ep(bdc); 579 580 return ret; 581 } 582 583 void bdc_udc_exit(struct bdc *bdc) 584 { 585 unsigned long flags; 586 587 dev_dbg(bdc->dev, "%s()\n", __func__); 588 spin_lock_irqsave(&bdc->lock, flags); 589 bdc_ep_disable(bdc->bdc_ep_array[1]); 590 spin_unlock_irqrestore(&bdc->lock, flags); 591 592 usb_del_gadget_udc(&bdc->gadget); 593 bdc_free_ep(bdc); 594 } 595