xref: /openbmc/linux/drivers/usb/gadget/udc/bdc/bdc_udc.c (revision c819e2cf)
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 	spin_lock_irqsave(&bdc->lock, flags);
458 	if (!is_self)
459 		bdc->devstatus |= 1 << USB_DEVICE_SELF_POWERED;
460 	else
461 		bdc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
462 
463 	spin_unlock_irqrestore(&bdc->lock, flags);
464 
465 	return 0;
466 }
467 
468 static int bdc_udc_wakeup(struct usb_gadget *gadget)
469 {
470 	struct bdc *bdc = gadget_to_bdc(gadget);
471 	unsigned long		flags;
472 	u8	link_state;
473 	u32	uspc;
474 	int ret = 0;
475 
476 	dev_dbg(bdc->dev,
477 		"%s() bdc->devstatus=%08x\n",
478 		__func__, bdc->devstatus);
479 
480 	if (!(bdc->devstatus & REMOTE_WAKE_ENABLE))
481 		return  -EOPNOTSUPP;
482 
483 	spin_lock_irqsave(&bdc->lock, flags);
484 	uspc = bdc_readl(bdc->regs, BDC_USPC);
485 	link_state = BDC_PST(uspc);
486 	dev_dbg(bdc->dev, "link_state =%d portsc=%x", link_state, uspc);
487 	if (link_state != BDC_LINK_STATE_U3) {
488 		dev_warn(bdc->dev,
489 			"can't wakeup from link state %d\n",
490 			link_state);
491 		ret = -EINVAL;
492 		goto out;
493 	}
494 	if (bdc->gadget.speed == USB_SPEED_SUPER)
495 		bdc->devstatus |= REMOTE_WAKEUP_ISSUED;
496 
497 	uspc &= ~BDC_PST_MASK;
498 	uspc &= (~BDC_USPSC_RW);
499 	uspc |=  BDC_PST(BDC_LINK_STATE_U0);
500 	uspc |=  BDC_SWS;
501 	bdc_writel(bdc->regs, BDC_USPC, uspc);
502 	uspc = bdc_readl(bdc->regs, BDC_USPC);
503 	link_state = BDC_PST(uspc);
504 	dev_dbg(bdc->dev, "link_state =%d portsc=%x", link_state, uspc);
505 out:
506 	spin_unlock_irqrestore(&bdc->lock, flags);
507 
508 	return ret;
509 }
510 
511 static const struct usb_gadget_ops bdc_gadget_ops = {
512 	.wakeup = bdc_udc_wakeup,
513 	.set_selfpowered = bdc_udc_set_selfpowered,
514 	.pullup = bdc_udc_pullup,
515 	.udc_start = bdc_udc_start,
516 	.udc_stop = bdc_udc_stop,
517 };
518 
519 /* Init the gadget interface and register the udc */
520 int bdc_udc_init(struct bdc *bdc)
521 {
522 	u32 temp;
523 	int ret;
524 
525 	dev_dbg(bdc->dev, "%s()\n", __func__);
526 	bdc->gadget.ops = &bdc_gadget_ops;
527 	bdc->gadget.max_speed = USB_SPEED_SUPER;
528 	bdc->gadget.speed = USB_SPEED_UNKNOWN;
529 	bdc->gadget.dev.parent = bdc->dev;
530 
531 	bdc->gadget.sg_supported = false;
532 
533 
534 	bdc->gadget.name = BRCM_BDC_NAME;
535 	ret = devm_request_irq(bdc->dev, bdc->irq, bdc_udc_interrupt,
536 				IRQF_SHARED , BRCM_BDC_NAME, bdc);
537 	if (ret) {
538 		dev_err(bdc->dev,
539 			"failed to request irq #%d %d\n",
540 			bdc->irq, ret);
541 		return ret;
542 	}
543 
544 	ret = bdc_init_ep(bdc);
545 	if (ret) {
546 		dev_err(bdc->dev, "bdc init ep fail: %d\n", ret);
547 		return ret;
548 	}
549 
550 	ret = usb_add_gadget_udc(bdc->dev, &bdc->gadget);
551 	if (ret) {
552 		dev_err(bdc->dev, "failed to register udc\n");
553 		goto err0;
554 	}
555 	usb_gadget_set_state(&bdc->gadget, USB_STATE_NOTATTACHED);
556 	bdc->bdc_ep_array[1]->desc = &bdc_gadget_ep0_desc;
557 	/*
558 	 * Allocate bd list for ep0 only, ep0 will be enabled on connect
559 	 * status report when the speed is known
560 	 */
561 	ret = bdc_ep_enable(bdc->bdc_ep_array[1]);
562 	if (ret) {
563 		dev_err(bdc->dev, "fail to enable %s\n",
564 						bdc->bdc_ep_array[1]->name);
565 		goto err1;
566 	}
567 	INIT_DELAYED_WORK(&bdc->func_wake_notify, bdc_func_wake_timer);
568 	/* Enable Interrupts */
569 	temp = bdc_readl(bdc->regs, BDC_BDCSC);
570 	temp |= BDC_GIE;
571 	bdc_writel(bdc->regs, BDC_BDCSC, temp);
572 	return 0;
573 err1:
574 	usb_del_gadget_udc(&bdc->gadget);
575 err0:
576 	bdc_free_ep(bdc);
577 
578 	return ret;
579 }
580 
581 void bdc_udc_exit(struct bdc *bdc)
582 {
583 	dev_dbg(bdc->dev, "%s()\n", __func__);
584 	bdc_ep_disable(bdc->bdc_ep_array[1]);
585 	usb_del_gadget_udc(&bdc->gadget);
586 	bdc_free_ep(bdc);
587 }
588