drivers/usb/gadget/udc/bdc/bdc_udc.c

   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 }