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 } 253 254 /* Change in VBus and VBus is present */ 255 if ((uspc & BDC_VBC) && (uspc & BDC_VBS)) { 256 if (bdc->pullup) { 257 dev_dbg(bdc->dev, "Do a softconnect\n"); 258 /* Attached state, do a softconnect */ 259 bdc_softconn(bdc); 260 usb_gadget_set_state(&bdc->gadget, USB_STATE_POWERED); 261 } 262 clear_flags = BDC_VBC; 263 } else if ((uspc & BDC_PRS) || (uspc & BDC_PRC) || disconn) { 264 /* Hot reset, warm reset, 2.0 bus reset or disconn */ 265 dev_dbg(bdc->dev, "Port reset or disconn\n"); 266 bdc_uspc_disconnected(bdc, disconn); 267 clear_flags = BDC_PCC|BDC_PCS|BDC_PRS|BDC_PRC; 268 } else if ((uspc & BDC_PSC) && (uspc & BDC_PCS)) { 269 /* Change in Link state */ 270 handle_link_state_change(bdc, uspc); 271 clear_flags = BDC_PSC|BDC_PCS; 272 } 273 274 /* 275 * In SS we might not have PRC bit set before connection, but in 2.0 276 * the PRC bit is set before connection, so moving this condition out 277 * of bus reset to handle both SS/2.0 speeds. 278 */ 279 if (connected) { 280 /* This is the connect event for U0/L0 */ 281 dev_dbg(bdc->dev, "Connected\n"); 282 bdc_uspc_connected(bdc); 283 bdc->devstatus &= ~(DEVICE_SUSPENDED); 284 } 285 uspc = bdc_readl(bdc->regs, BDC_USPC); 286 uspc &= (~BDC_USPSC_RW); 287 dev_dbg(bdc->dev, "uspc=%x\n", uspc); 288 bdc_writel(bdc->regs, BDC_USPC, clear_flags); 289 } 290 291 /* Main interrupt handler for bdc */ 292 static irqreturn_t bdc_udc_interrupt(int irq, void *_bdc) 293 { 294 u32 eqp_index, dqp_index, sr_type, srr_int; 295 struct bdc_sr *sreport; 296 struct bdc *bdc = _bdc; 297 u32 status; 298 int ret; 299 300 spin_lock(&bdc->lock); 301 status = bdc_readl(bdc->regs, BDC_BDCSC); 302 if (!(status & BDC_GIP)) { 303 spin_unlock(&bdc->lock); 304 return IRQ_NONE; 305 } 306 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0)); 307 /* Check if the SRR IP bit it set? */ 308 if (!(srr_int & BDC_SRR_IP)) { 309 dev_warn(bdc->dev, "Global irq pending but SRR IP is 0\n"); 310 spin_unlock(&bdc->lock); 311 return IRQ_NONE; 312 } 313 eqp_index = BDC_SRR_EPI(srr_int); 314 dqp_index = BDC_SRR_DPI(srr_int); 315 dev_dbg(bdc->dev, 316 "%s eqp_index=%d dqp_index=%d srr.dqp_index=%d\n\n", 317 __func__, eqp_index, dqp_index, bdc->srr.dqp_index); 318 319 /* check for ring empty condition */ 320 if (eqp_index == dqp_index) { 321 dev_dbg(bdc->dev, "SRR empty?\n"); 322 spin_unlock(&bdc->lock); 323 return IRQ_HANDLED; 324 } 325 326 while (bdc->srr.dqp_index != eqp_index) { 327 sreport = &bdc->srr.sr_bds[bdc->srr.dqp_index]; 328 /* sreport is read before using it */ 329 rmb(); 330 sr_type = le32_to_cpu(sreport->offset[3]) & BD_TYPE_BITMASK; 331 dev_dbg_ratelimited(bdc->dev, "sr_type=%d\n", sr_type); 332 switch (sr_type) { 333 case SR_XSF: 334 bdc->sr_handler[0](bdc, sreport); 335 break; 336 337 case SR_USPC: 338 bdc->sr_handler[1](bdc, sreport); 339 break; 340 default: 341 dev_warn(bdc->dev, "SR:%d not handled\n", sr_type); 342 } 343 /* Advance the srr dqp index */ 344 srr_dqp_index_advc(bdc, 0); 345 } 346 /* update the hw dequeue pointer */ 347 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0)); 348 srr_int &= ~BDC_SRR_DPI_MASK; 349 srr_int &= ~(BDC_SRR_RWS|BDC_SRR_RST|BDC_SRR_ISR); 350 srr_int |= ((bdc->srr.dqp_index) << 16); 351 srr_int |= BDC_SRR_IP; 352 bdc_writel(bdc->regs, BDC_SRRINT(0), srr_int); 353 srr_int = bdc_readl(bdc->regs, BDC_SRRINT(0)); 354 if (bdc->reinit) { 355 ret = bdc_reinit(bdc); 356 if (ret) 357 dev_err(bdc->dev, "err in bdc reinit\n"); 358 } 359 360 spin_unlock(&bdc->lock); 361 362 return IRQ_HANDLED; 363 } 364 365 /* Gadget ops */ 366 static int bdc_udc_start(struct usb_gadget *gadget, 367 struct usb_gadget_driver *driver) 368 { 369 struct bdc *bdc = gadget_to_bdc(gadget); 370 unsigned long flags; 371 int ret = 0; 372 373 dev_dbg(bdc->dev, "%s()\n", __func__); 374 spin_lock_irqsave(&bdc->lock, flags); 375 if (bdc->gadget_driver) { 376 dev_err(bdc->dev, "%s is already bound to %s\n", 377 bdc->gadget.name, 378 bdc->gadget_driver->driver.name); 379 ret = -EBUSY; 380 goto err; 381 } 382 /* 383 * Run the controller from here and when BDC is connected to 384 * Host then driver will receive a USPC SR with VBUS present 385 * and then driver will do a softconnect. 386 */ 387 ret = bdc_run(bdc); 388 if (ret) { 389 dev_err(bdc->dev, "%s bdc run fail\n", __func__); 390 goto err; 391 } 392 bdc->gadget_driver = driver; 393 bdc->gadget.dev.driver = &driver->driver; 394 err: 395 spin_unlock_irqrestore(&bdc->lock, flags); 396 397 return ret; 398 } 399 400 static int bdc_udc_stop(struct usb_gadget *gadget) 401 { 402 struct bdc *bdc = gadget_to_bdc(gadget); 403 unsigned long flags; 404 405 dev_dbg(bdc->dev, "%s()\n", __func__); 406 spin_lock_irqsave(&bdc->lock, flags); 407 bdc_stop(bdc); 408 bdc->gadget_driver = NULL; 409 bdc->gadget.dev.driver = NULL; 410 spin_unlock_irqrestore(&bdc->lock, flags); 411 412 return 0; 413 } 414 415 static int bdc_udc_pullup(struct usb_gadget *gadget, int is_on) 416 { 417 struct bdc *bdc = gadget_to_bdc(gadget); 418 unsigned long flags; 419 u32 uspc; 420 421 dev_dbg(bdc->dev, "%s() is_on:%d\n", __func__, is_on); 422 if (!gadget) 423 return -EINVAL; 424 425 spin_lock_irqsave(&bdc->lock, flags); 426 if (!is_on) { 427 bdc_softdisconn(bdc); 428 bdc->pullup = false; 429 } else { 430 /* 431 * For a self powered device, we need to wait till we receive 432 * a VBUS change and Vbus present event, then if pullup flag 433 * is set, then only we present the Termintation. 434 */ 435 bdc->pullup = true; 436 /* 437 * Check if BDC is already connected to Host i.e Vbus=1, 438 * if yes, then present TERM now, this is typical for bus 439 * powered devices. 440 */ 441 uspc = bdc_readl(bdc->regs, BDC_USPC); 442 if (uspc & BDC_VBS) 443 bdc_softconn(bdc); 444 } 445 spin_unlock_irqrestore(&bdc->lock, flags); 446 447 return 0; 448 } 449 450 static int bdc_udc_set_selfpowered(struct usb_gadget *gadget, 451 int is_self) 452 { 453 struct bdc *bdc = gadget_to_bdc(gadget); 454 unsigned long flags; 455 456 dev_dbg(bdc->dev, "%s()\n", __func__); 457 gadget->is_selfpowered = (is_self != 0); 458 spin_lock_irqsave(&bdc->lock, flags); 459 if (!is_self) 460 bdc->devstatus |= 1 << USB_DEVICE_SELF_POWERED; 461 else 462 bdc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED); 463 464 spin_unlock_irqrestore(&bdc->lock, flags); 465 466 return 0; 467 } 468 469 static int bdc_udc_wakeup(struct usb_gadget *gadget) 470 { 471 struct bdc *bdc = gadget_to_bdc(gadget); 472 unsigned long flags; 473 u8 link_state; 474 u32 uspc; 475 int ret = 0; 476 477 dev_dbg(bdc->dev, 478 "%s() bdc->devstatus=%08x\n", 479 __func__, bdc->devstatus); 480 481 if (!(bdc->devstatus & REMOTE_WAKE_ENABLE)) 482 return -EOPNOTSUPP; 483 484 spin_lock_irqsave(&bdc->lock, flags); 485 uspc = bdc_readl(bdc->regs, BDC_USPC); 486 link_state = BDC_PST(uspc); 487 dev_dbg(bdc->dev, "link_state =%d portsc=%x", link_state, uspc); 488 if (link_state != BDC_LINK_STATE_U3) { 489 dev_warn(bdc->dev, 490 "can't wakeup from link state %d\n", 491 link_state); 492 ret = -EINVAL; 493 goto out; 494 } 495 if (bdc->gadget.speed == USB_SPEED_SUPER) 496 bdc->devstatus |= REMOTE_WAKEUP_ISSUED; 497 498 uspc &= ~BDC_PST_MASK; 499 uspc &= (~BDC_USPSC_RW); 500 uspc |= BDC_PST(BDC_LINK_STATE_U0); 501 uspc |= BDC_SWS; 502 bdc_writel(bdc->regs, BDC_USPC, uspc); 503 uspc = bdc_readl(bdc->regs, BDC_USPC); 504 link_state = BDC_PST(uspc); 505 dev_dbg(bdc->dev, "link_state =%d portsc=%x", link_state, uspc); 506 out: 507 spin_unlock_irqrestore(&bdc->lock, flags); 508 509 return ret; 510 } 511 512 static const struct usb_gadget_ops bdc_gadget_ops = { 513 .wakeup = bdc_udc_wakeup, 514 .set_selfpowered = bdc_udc_set_selfpowered, 515 .pullup = bdc_udc_pullup, 516 .udc_start = bdc_udc_start, 517 .udc_stop = bdc_udc_stop, 518 }; 519 520 /* Init the gadget interface and register the udc */ 521 int bdc_udc_init(struct bdc *bdc) 522 { 523 u32 temp; 524 int ret; 525 526 dev_dbg(bdc->dev, "%s()\n", __func__); 527 bdc->gadget.ops = &bdc_gadget_ops; 528 bdc->gadget.max_speed = USB_SPEED_SUPER; 529 bdc->gadget.speed = USB_SPEED_UNKNOWN; 530 bdc->gadget.dev.parent = bdc->dev; 531 532 bdc->gadget.sg_supported = false; 533 534 535 bdc->gadget.name = BRCM_BDC_NAME; 536 ret = devm_request_irq(bdc->dev, bdc->irq, bdc_udc_interrupt, 537 IRQF_SHARED , BRCM_BDC_NAME, bdc); 538 if (ret) { 539 dev_err(bdc->dev, 540 "failed to request irq #%d %d\n", 541 bdc->irq, ret); 542 return ret; 543 } 544 545 ret = bdc_init_ep(bdc); 546 if (ret) { 547 dev_err(bdc->dev, "bdc init ep fail: %d\n", ret); 548 return ret; 549 } 550 551 ret = usb_add_gadget_udc(bdc->dev, &bdc->gadget); 552 if (ret) { 553 dev_err(bdc->dev, "failed to register udc\n"); 554 goto err0; 555 } 556 usb_gadget_set_state(&bdc->gadget, USB_STATE_NOTATTACHED); 557 bdc->bdc_ep_array[1]->desc = &bdc_gadget_ep0_desc; 558 /* 559 * Allocate bd list for ep0 only, ep0 will be enabled on connect 560 * status report when the speed is known 561 */ 562 ret = bdc_ep_enable(bdc->bdc_ep_array[1]); 563 if (ret) { 564 dev_err(bdc->dev, "fail to enable %s\n", 565 bdc->bdc_ep_array[1]->name); 566 goto err1; 567 } 568 INIT_DELAYED_WORK(&bdc->func_wake_notify, bdc_func_wake_timer); 569 /* Enable Interrupts */ 570 temp = bdc_readl(bdc->regs, BDC_BDCSC); 571 temp |= BDC_GIE; 572 bdc_writel(bdc->regs, BDC_BDCSC, temp); 573 return 0; 574 err1: 575 usb_del_gadget_udc(&bdc->gadget); 576 err0: 577 bdc_free_ep(bdc); 578 579 return ret; 580 } 581 582 void bdc_udc_exit(struct bdc *bdc) 583 { 584 unsigned long flags; 585 586 dev_dbg(bdc->dev, "%s()\n", __func__); 587 spin_lock_irqsave(&bdc->lock, flags); 588 bdc_ep_disable(bdc->bdc_ep_array[1]); 589 spin_unlock_irqrestore(&bdc->lock, flags); 590 591 usb_del_gadget_udc(&bdc->gadget); 592 bdc_free_ep(bdc); 593 } 594