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 */
srr_dqp_index_advc(struct bdc * bdc,u32 srr_num)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 */
bdc_uspc_connected(struct bdc * bdc)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 */
bdc_uspc_disconnected(struct bdc * bdc,bool reinit)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 */
bdc_func_wake_timer(struct work_struct * work)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 */
handle_link_state_change(struct bdc * bdc,u32 uspc)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 */
bdc_sr_uspc(struct bdc * bdc,struct bdc_sr * sreport)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 */
bdc_udc_interrupt(int irq,void * _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 */
bdc_udc_start(struct usb_gadget * gadget,struct usb_gadget_driver * driver)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 
bdc_udc_stop(struct usb_gadget * gadget)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 
bdc_udc_pullup(struct usb_gadget * gadget,int is_on)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 
bdc_udc_set_selfpowered(struct usb_gadget * gadget,int is_self)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 
bdc_udc_wakeup(struct usb_gadget * gadget)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 */
bdc_udc_init(struct bdc * bdc)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 
bdc_udc_exit(struct bdc * bdc)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 }
591