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

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