1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/init.h>
19#include <linux/kernel.h>
20#include <linux/platform_device.h>
21#include <linux/module.h>
22#include <linux/errno.h>
23#include <linux/list.h>
24#include <linux/interrupt.h>
25#include <linux/io.h>
26#include <linux/irq.h>
27#include <linux/device.h>
28#include <linux/dma-mapping.h>
29#include <linux/clk.h>
30#include <linux/delay.h>
31#include <linux/timer.h>
32
33#include <linux/usb/ch9.h>
34#include <linux/usb/gadget.h>
35
36#include <mach/usb.h>
37#include <mach/hardware.h>
38
39#include "imx_udc.h"
40
41static const char driver_name[] = "imx_udc";
42static const char ep0name[] = "ep0";
43
44void ep0_chg_stat(const char *label, struct imx_udc_struct *imx_usb,
45 enum ep0_state stat);
46
47
48
49
50
51
52void imx_udc_enable(struct imx_udc_struct *imx_usb)
53{
54 int temp = __raw_readl(imx_usb->base + USB_CTRL);
55 __raw_writel(temp | CTRL_FE_ENA | CTRL_AFE_ENA,
56 imx_usb->base + USB_CTRL);
57 imx_usb->gadget.speed = USB_SPEED_FULL;
58}
59
60void imx_udc_disable(struct imx_udc_struct *imx_usb)
61{
62 int temp = __raw_readl(imx_usb->base + USB_CTRL);
63
64 __raw_writel(temp & ~(CTRL_FE_ENA | CTRL_AFE_ENA),
65 imx_usb->base + USB_CTRL);
66
67 ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
68 imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
69}
70
71void imx_udc_reset(struct imx_udc_struct *imx_usb)
72{
73 int temp = __raw_readl(imx_usb->base + USB_ENAB);
74
75
76 __raw_writel(temp | ENAB_RST, imx_usb->base + USB_ENAB);
77
78
79 do {} while (__raw_readl(imx_usb->base + USB_ENAB) & ENAB_RST);
80
81
82 do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG));
83
84
85}
86
87void imx_udc_config(struct imx_udc_struct *imx_usb)
88{
89 u8 ep_conf[5];
90 u8 i, j, cfg;
91 struct imx_ep_struct *imx_ep;
92
93
94 do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG));
95
96
97 for (j = 0; j < 5; j++) {
98 i = (j == 2 ? imx_usb->imx_ep[0].fifosize : 0x00);
99 __raw_writeb(i, imx_usb->base + USB_DDAT);
100 do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_BSY);
101 }
102
103
104
105
106 for (cfg = 1; cfg < 3; cfg++) {
107 for (i = 1; i < IMX_USB_NB_EP; i++) {
108 imx_ep = &imx_usb->imx_ep[i];
109
110 ep_conf[0] = (i << 4) | (cfg << 2);
111
112 ep_conf[1] = (imx_ep->bmAttributes << 3) |
113 (EP_DIR(imx_ep) << 2);
114
115 ep_conf[2] = imx_ep->fifosize;
116
117 ep_conf[3] = 0xC0;
118
119 ep_conf[4] = i;
120
121 D_INI(imx_usb->dev,
122 "<%s> ep%d_conf[%d]:"
123 "[%02x-%02x-%02x-%02x-%02x]\n",
124 __func__, i, cfg,
125 ep_conf[0], ep_conf[1], ep_conf[2],
126 ep_conf[3], ep_conf[4]);
127
128 for (j = 0; j < 5; j++) {
129 __raw_writeb(ep_conf[j],
130 imx_usb->base + USB_DDAT);
131 do {} while (__raw_readl(imx_usb->base
132 + USB_DADR)
133 & DADR_BSY);
134 }
135 }
136 }
137
138
139 do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG);
140}
141
142void imx_udc_init_irq(struct imx_udc_struct *imx_usb)
143{
144 int i;
145
146
147 __raw_writel(0xFFFFFFFF, imx_usb->base + USB_MASK);
148 __raw_writel(0xFFFFFFFF, imx_usb->base + USB_INTR);
149 for (i = 0; i < IMX_USB_NB_EP; i++) {
150 __raw_writel(0x1FF, imx_usb->base + USB_EP_MASK(i));
151 __raw_writel(0x1FF, imx_usb->base + USB_EP_INTR(i));
152 }
153
154
155 __raw_writel(INTR_MSOF | INTR_FRAME_MATCH, imx_usb->base + USB_MASK);
156
157
158 __raw_writel(0x1FF & ~(EPINTR_DEVREQ | EPINTR_MDEVREQ | EPINTR_EOT
159 | EPINTR_EOF | EPINTR_FIFO_EMPTY | EPINTR_FIFO_FULL),
160 imx_usb->base + USB_EP_MASK(0));
161}
162
163void imx_udc_init_ep(struct imx_udc_struct *imx_usb)
164{
165 int i, max, temp;
166 struct imx_ep_struct *imx_ep;
167 for (i = 0; i < IMX_USB_NB_EP; i++) {
168 imx_ep = &imx_usb->imx_ep[i];
169 switch (imx_ep->fifosize) {
170 case 8:
171 max = 0;
172 break;
173 case 16:
174 max = 1;
175 break;
176 case 32:
177 max = 2;
178 break;
179 case 64:
180 max = 3;
181 break;
182 default:
183 max = 1;
184 break;
185 }
186 temp = (EP_DIR(imx_ep) << 7) | (max << 5)
187 | (imx_ep->bmAttributes << 3);
188 __raw_writel(temp, imx_usb->base + USB_EP_STAT(i));
189 __raw_writel(temp | EPSTAT_FLUSH,
190 imx_usb->base + USB_EP_STAT(i));
191 D_INI(imx_usb->dev, "<%s> ep%d_stat %08x\n", __func__, i,
192 __raw_readl(imx_usb->base + USB_EP_STAT(i)));
193 }
194}
195
196void imx_udc_init_fifo(struct imx_udc_struct *imx_usb)
197{
198 int i, temp;
199 struct imx_ep_struct *imx_ep;
200 for (i = 0; i < IMX_USB_NB_EP; i++) {
201 imx_ep = &imx_usb->imx_ep[i];
202
203
204 temp = EP_DIR(imx_ep) ? 0x0B000000 : 0x0F000000;
205 __raw_writel(temp, imx_usb->base + USB_EP_FCTRL(i));
206 D_INI(imx_usb->dev, "<%s> ep%d_fctrl %08x\n", __func__, i,
207 __raw_readl(imx_usb->base + USB_EP_FCTRL(i)));
208
209
210 temp = (i ? imx_ep->fifosize / 2 : 0);
211 __raw_writel(temp, imx_usb->base + USB_EP_FALRM(i));
212 D_INI(imx_usb->dev, "<%s> ep%d_falrm %08x\n", __func__, i,
213 __raw_readl(imx_usb->base + USB_EP_FALRM(i)));
214 }
215}
216
217static void imx_udc_init(struct imx_udc_struct *imx_usb)
218{
219
220 imx_udc_reset(imx_usb);
221
222
223 imx_udc_config(imx_usb);
224
225
226 imx_udc_init_irq(imx_usb);
227
228
229 imx_udc_init_ep(imx_usb);
230
231
232 imx_udc_init_fifo(imx_usb);
233}
234
235void imx_ep_irq_enable(struct imx_ep_struct *imx_ep)
236{
237
238 int i = EP_NO(imx_ep);
239
240 __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i));
241 __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i));
242 __raw_writel(0x1FF & ~(EPINTR_EOT | EPINTR_EOF),
243 imx_ep->imx_usb->base + USB_EP_MASK(i));
244}
245
246void imx_ep_irq_disable(struct imx_ep_struct *imx_ep)
247{
248
249 int i = EP_NO(imx_ep);
250
251 __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i));
252 __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i));
253}
254
255int imx_ep_empty(struct imx_ep_struct *imx_ep)
256{
257 struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
258
259 return __raw_readl(imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
260 & FSTAT_EMPTY;
261}
262
263unsigned imx_fifo_bcount(struct imx_ep_struct *imx_ep)
264{
265 struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
266
267 return (__raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)))
268 & EPSTAT_BCOUNT) >> 16;
269}
270
271void imx_flush(struct imx_ep_struct *imx_ep)
272{
273 struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
274
275 int temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
276 __raw_writel(temp | EPSTAT_FLUSH,
277 imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
278}
279
280void imx_ep_stall(struct imx_ep_struct *imx_ep)
281{
282 struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
283 int temp, i;
284
285 D_ERR(imx_usb->dev,
286 "<%s> Forced stall on %s\n", __func__, imx_ep->ep.name);
287
288 imx_flush(imx_ep);
289
290
291 if (!EP_NO(imx_ep)) {
292 temp = __raw_readl(imx_usb->base + USB_CTRL);
293 __raw_writel(temp | CTRL_CMDOVER | CTRL_CMDERROR,
294 imx_usb->base + USB_CTRL);
295 do { } while (__raw_readl(imx_usb->base + USB_CTRL)
296 & CTRL_CMDOVER);
297 temp = __raw_readl(imx_usb->base + USB_CTRL);
298 __raw_writel(temp & ~CTRL_CMDERROR, imx_usb->base + USB_CTRL);
299 }
300 else {
301 temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
302 __raw_writel(temp | EPSTAT_STALL,
303 imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
304
305 for (i = 0; i < 100; i ++) {
306 temp = __raw_readl(imx_usb->base
307 + USB_EP_STAT(EP_NO(imx_ep)));
308 if (!(temp & EPSTAT_STALL))
309 break;
310 udelay(20);
311 }
312 if (i == 100)
313 D_ERR(imx_usb->dev, "<%s> Non finished stall on %s\n",
314 __func__, imx_ep->ep.name);
315 }
316}
317
318static int imx_udc_get_frame(struct usb_gadget *_gadget)
319{
320 struct imx_udc_struct *imx_usb = container_of(_gadget,
321 struct imx_udc_struct, gadget);
322
323 return __raw_readl(imx_usb->base + USB_FRAME) & 0x7FF;
324}
325
326static int imx_udc_wakeup(struct usb_gadget *_gadget)
327{
328 return 0;
329}
330
331
332
333
334
335
336static void ep_add_request(struct imx_ep_struct *imx_ep,
337 struct imx_request *req)
338{
339 if (unlikely(!req))
340 return;
341
342 req->in_use = 1;
343 list_add_tail(&req->queue, &imx_ep->queue);
344}
345
346static void ep_del_request(struct imx_ep_struct *imx_ep,
347 struct imx_request *req)
348{
349 if (unlikely(!req))
350 return;
351
352 list_del_init(&req->queue);
353 req->in_use = 0;
354}
355
356static void done(struct imx_ep_struct *imx_ep,
357 struct imx_request *req, int status)
358{
359 ep_del_request(imx_ep, req);
360
361 if (likely(req->req.status == -EINPROGRESS))
362 req->req.status = status;
363 else
364 status = req->req.status;
365
366 if (status && status != -ESHUTDOWN)
367 D_ERR(imx_ep->imx_usb->dev,
368 "<%s> complete %s req %p stat %d len %u/%u\n", __func__,
369 imx_ep->ep.name, &req->req, status,
370 req->req.actual, req->req.length);
371
372 req->req.complete(&imx_ep->ep, &req->req);
373}
374
375static void nuke(struct imx_ep_struct *imx_ep, int status)
376{
377 struct imx_request *req;
378
379 while (!list_empty(&imx_ep->queue)) {
380 req = list_entry(imx_ep->queue.next, struct imx_request, queue);
381 done(imx_ep, req, status);
382 }
383}
384
385
386
387
388
389static int read_packet(struct imx_ep_struct *imx_ep, struct imx_request *req)
390{
391 u8 *buf;
392 int bytes_ep, bufferspace, count, i;
393
394 bytes_ep = imx_fifo_bcount(imx_ep);
395 bufferspace = req->req.length - req->req.actual;
396
397 buf = req->req.buf + req->req.actual;
398 prefetchw(buf);
399
400 if (unlikely(imx_ep_empty(imx_ep)))
401 count = 0;
402 else
403 count = min(bytes_ep, bufferspace);
404
405 for (i = count; i > 0; i--)
406 *buf++ = __raw_readb(imx_ep->imx_usb->base
407 + USB_EP_FDAT0(EP_NO(imx_ep)));
408 req->req.actual += count;
409
410 return count;
411}
412
413static int write_packet(struct imx_ep_struct *imx_ep, struct imx_request *req)
414{
415 u8 *buf;
416 int length, count, temp;
417
418 if (unlikely(__raw_readl(imx_ep->imx_usb->base +
419 USB_EP_STAT(EP_NO(imx_ep))) & EPSTAT_ZLPS)) {
420 D_TRX(imx_ep->imx_usb->dev, "<%s> zlp still queued in EP %s\n",
421 __func__, imx_ep->ep.name);
422 return -1;
423 }
424
425 buf = req->req.buf + req->req.actual;
426 prefetch(buf);
427
428 length = min(req->req.length - req->req.actual, (u32)imx_ep->fifosize);
429
430 if (imx_fifo_bcount(imx_ep) + length > imx_ep->fifosize) {
431 D_TRX(imx_ep->imx_usb->dev, "<%s> packet overfill %s fifo\n",
432 __func__, imx_ep->ep.name);
433 return -1;
434 }
435
436 req->req.actual += length;
437 count = length;
438
439 if (!count && req->req.zero) {
440 temp = __raw_readl(imx_ep->imx_usb->base
441 + USB_EP_STAT(EP_NO(imx_ep)));
442 __raw_writel(temp | EPSTAT_ZLPS, imx_ep->imx_usb->base
443 + USB_EP_STAT(EP_NO(imx_ep)));
444 D_TRX(imx_ep->imx_usb->dev, "<%s> zero packet\n", __func__);
445 return 0;
446 }
447
448 while (count--) {
449 if (count == 0) {
450 temp = __raw_readl(imx_ep->imx_usb->base
451 + USB_EP_FCTRL(EP_NO(imx_ep)));
452 __raw_writel(temp | FCTRL_WFR, imx_ep->imx_usb->base
453 + USB_EP_FCTRL(EP_NO(imx_ep)));
454 }
455 __raw_writeb(*buf++,
456 imx_ep->imx_usb->base + USB_EP_FDAT0(EP_NO(imx_ep)));
457 }
458
459 return length;
460}
461
462static int read_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
463{
464 int bytes = 0,
465 count,
466 completed = 0;
467
468 while (__raw_readl(imx_ep->imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
469 & FSTAT_FR) {
470 count = read_packet(imx_ep, req);
471 bytes += count;
472
473 completed = (count != imx_ep->fifosize);
474 if (completed || req->req.actual == req->req.length) {
475 completed = 1;
476 break;
477 }
478 }
479
480 if (completed || !req->req.length) {
481 done(imx_ep, req, 0);
482 D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
483 __func__, imx_ep->ep.name, req,
484 completed ? "completed" : "not completed");
485 if (!EP_NO(imx_ep))
486 ep0_chg_stat(__func__, imx_ep->imx_usb, EP0_IDLE);
487 }
488
489 D_TRX(imx_ep->imx_usb->dev, "<%s> bytes read: %d\n", __func__, bytes);
490
491 return completed;
492}
493
494static int write_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
495{
496 int bytes = 0,
497 count,
498 completed = 0;
499
500 while (!completed) {
501 count = write_packet(imx_ep, req);
502 if (count < 0)
503 break;
504 bytes += count;
505
506
507 completed = (count != imx_ep->fifosize);
508
509 if (unlikely(completed)) {
510 done(imx_ep, req, 0);
511 D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
512 __func__, imx_ep->ep.name, req,
513 completed ? "completed" : "not completed");
514 if (!EP_NO(imx_ep))
515 ep0_chg_stat(__func__,
516 imx_ep->imx_usb, EP0_IDLE);
517 }
518 }
519
520 D_TRX(imx_ep->imx_usb->dev, "<%s> bytes sent: %d\n", __func__, bytes);
521
522 return completed;
523}
524
525
526
527
528
529static int handle_ep(struct imx_ep_struct *imx_ep)
530{
531 struct imx_request *req;
532 int completed = 0;
533
534 do {
535 if (!list_empty(&imx_ep->queue))
536 req = list_entry(imx_ep->queue.next,
537 struct imx_request, queue);
538 else {
539 D_REQ(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
540 __func__, imx_ep->ep.name);
541 return 0;
542 }
543
544 if (EP_DIR(imx_ep))
545 completed = write_fifo(imx_ep, req);
546 else
547 completed = read_fifo(imx_ep, req);
548
549 dump_ep_stat(__func__, imx_ep);
550
551 } while (completed);
552
553 return 0;
554}
555
556static int handle_ep0(struct imx_ep_struct *imx_ep)
557{
558 struct imx_request *req = NULL;
559 int ret = 0;
560
561 if (!list_empty(&imx_ep->queue)) {
562 req = list_entry(imx_ep->queue.next, struct imx_request, queue);
563
564 switch (imx_ep->imx_usb->ep0state) {
565
566 case EP0_IN_DATA_PHASE:
567 write_fifo(imx_ep, req);
568 break;
569 case EP0_OUT_DATA_PHASE:
570 read_fifo(imx_ep, req);
571 break;
572 default:
573 D_EP0(imx_ep->imx_usb->dev,
574 "<%s> ep0 i/o, odd state %d\n",
575 __func__, imx_ep->imx_usb->ep0state);
576 ep_del_request(imx_ep, req);
577 ret = -EL2HLT;
578 break;
579 }
580 }
581
582 else
583 D_ERR(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
584 __func__, imx_ep->ep.name);
585
586 return ret;
587}
588
589static void handle_ep0_devreq(struct imx_udc_struct *imx_usb)
590{
591 struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
592 union {
593 struct usb_ctrlrequest r;
594 u8 raw[8];
595 u32 word[2];
596 } u;
597 int temp, i;
598
599 nuke(imx_ep, -EPROTO);
600
601
602 for (i = 0; i < 2; i++) {
603 if (imx_ep_empty(imx_ep)) {
604 D_ERR(imx_usb->dev,
605 "<%s> no setup packet received\n", __func__);
606 goto stall;
607 }
608 u.word[i] = __raw_readl(imx_usb->base
609 + USB_EP_FDAT(EP_NO(imx_ep)));
610 }
611
612 temp = imx_ep_empty(imx_ep);
613 while (!imx_ep_empty(imx_ep)) {
614 i = __raw_readl(imx_usb->base + USB_EP_FDAT(EP_NO(imx_ep)));
615 D_ERR(imx_usb->dev,
616 "<%s> wrong to have extra bytes for setup : 0x%08x\n",
617 __func__, i);
618 }
619 if (!temp)
620 goto stall;
621
622 le16_to_cpus(&u.r.wValue);
623 le16_to_cpus(&u.r.wIndex);
624 le16_to_cpus(&u.r.wLength);
625
626 D_REQ(imx_usb->dev, "<%s> SETUP %02x.%02x v%04x i%04x l%04x\n",
627 __func__, u.r.bRequestType, u.r.bRequest,
628 u.r.wValue, u.r.wIndex, u.r.wLength);
629
630 if (imx_usb->set_config) {
631
632 temp = __raw_readl(imx_usb->base + USB_CTRL);
633 __raw_writel(temp | CTRL_CMDOVER, imx_usb->base + USB_CTRL);
634
635 D_ERR(imx_usb->dev,
636 "<%s> set config req is pending, NACK the host\n",
637 __func__);
638 return;
639 }
640
641 if (u.r.bRequestType & USB_DIR_IN)
642 ep0_chg_stat(__func__, imx_usb, EP0_IN_DATA_PHASE);
643 else
644 ep0_chg_stat(__func__, imx_usb, EP0_OUT_DATA_PHASE);
645
646 i = imx_usb->driver->setup(&imx_usb->gadget, &u.r);
647 if (i < 0) {
648 D_ERR(imx_usb->dev, "<%s> device setup error %d\n",
649 __func__, i);
650 goto stall;
651 }
652
653 return;
654stall:
655 D_ERR(imx_usb->dev, "<%s> protocol STALL\n", __func__);
656 imx_ep_stall(imx_ep);
657 ep0_chg_stat(__func__, imx_usb, EP0_STALL);
658 return;
659}
660
661
662
663
664
665
666static int imx_ep_enable(struct usb_ep *usb_ep,
667 const struct usb_endpoint_descriptor *desc)
668{
669 struct imx_ep_struct *imx_ep = container_of(usb_ep,
670 struct imx_ep_struct, ep);
671 struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
672 unsigned long flags;
673
674 if (!usb_ep
675 || !desc
676 || !EP_NO(imx_ep)
677 || desc->bDescriptorType != USB_DT_ENDPOINT
678 || imx_ep->bEndpointAddress != desc->bEndpointAddress) {
679 D_ERR(imx_usb->dev,
680 "<%s> bad ep or descriptor\n", __func__);
681 return -EINVAL;
682 }
683
684 if (imx_ep->bmAttributes != desc->bmAttributes) {
685 D_ERR(imx_usb->dev,
686 "<%s> %s type mismatch\n", __func__, usb_ep->name);
687 return -EINVAL;
688 }
689
690 if (imx_ep->fifosize < le16_to_cpu(desc->wMaxPacketSize)) {
691 D_ERR(imx_usb->dev,
692 "<%s> bad %s maxpacket\n", __func__, usb_ep->name);
693 return -ERANGE;
694 }
695
696 if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
697 D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
698 return -ESHUTDOWN;
699 }
700
701 local_irq_save(flags);
702
703 imx_ep->stopped = 0;
704 imx_flush(imx_ep);
705 imx_ep_irq_enable(imx_ep);
706
707 local_irq_restore(flags);
708
709 D_EPX(imx_usb->dev, "<%s> ENABLED %s\n", __func__, usb_ep->name);
710 return 0;
711}
712
713static int imx_ep_disable(struct usb_ep *usb_ep)
714{
715 struct imx_ep_struct *imx_ep = container_of(usb_ep,
716 struct imx_ep_struct, ep);
717 unsigned long flags;
718
719 if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
720 D_ERR(imx_ep->imx_usb->dev, "<%s> %s can not be disabled\n",
721 __func__, usb_ep ? imx_ep->ep.name : NULL);
722 return -EINVAL;
723 }
724
725 local_irq_save(flags);
726
727 imx_ep->stopped = 1;
728 nuke(imx_ep, -ESHUTDOWN);
729 imx_flush(imx_ep);
730 imx_ep_irq_disable(imx_ep);
731
732 local_irq_restore(flags);
733
734 D_EPX(imx_ep->imx_usb->dev,
735 "<%s> DISABLED %s\n", __func__, usb_ep->name);
736 return 0;
737}
738
739static struct usb_request *imx_ep_alloc_request
740 (struct usb_ep *usb_ep, gfp_t gfp_flags)
741{
742 struct imx_request *req;
743
744 if (!usb_ep)
745 return NULL;
746
747 req = kzalloc(sizeof *req, gfp_flags);
748 if (!req)
749 return NULL;
750
751 INIT_LIST_HEAD(&req->queue);
752 req->in_use = 0;
753
754 return &req->req;
755}
756
757static void imx_ep_free_request
758 (struct usb_ep *usb_ep, struct usb_request *usb_req)
759{
760 struct imx_request *req;
761
762 req = container_of(usb_req, struct imx_request, req);
763 WARN_ON(!list_empty(&req->queue));
764 kfree(req);
765}
766
767static int imx_ep_queue
768 (struct usb_ep *usb_ep, struct usb_request *usb_req, gfp_t gfp_flags)
769{
770 struct imx_ep_struct *imx_ep;
771 struct imx_udc_struct *imx_usb;
772 struct imx_request *req;
773 unsigned long flags;
774 int ret = 0;
775
776 imx_ep = container_of(usb_ep, struct imx_ep_struct, ep);
777 imx_usb = imx_ep->imx_usb;
778 req = container_of(usb_req, struct imx_request, req);
779
780
781
782
783
784
785
786 if (imx_usb->set_config && !EP_NO(imx_ep)) {
787 imx_usb->set_config = 0;
788 D_ERR(imx_usb->dev,
789 "<%s> gadget reply set config\n", __func__);
790 return 0;
791 }
792
793 if (unlikely(!usb_req || !req || !usb_req->complete || !usb_req->buf)) {
794 D_ERR(imx_usb->dev, "<%s> bad params\n", __func__);
795 return -EINVAL;
796 }
797
798 if (unlikely(!usb_ep || !imx_ep)) {
799 D_ERR(imx_usb->dev, "<%s> bad ep\n", __func__);
800 return -EINVAL;
801 }
802
803 if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
804 D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
805 return -ESHUTDOWN;
806 }
807
808
809 D_REQ(imx_usb->dev, "<%s> ep%d %s request for [%d] bytes\n",
810 __func__, EP_NO(imx_ep),
811 ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state
812 == EP0_IN_DATA_PHASE)
813 || (EP_NO(imx_ep) && EP_DIR(imx_ep)))
814 ? "IN" : "OUT", usb_req->length);
815 dump_req(__func__, imx_ep, usb_req);
816
817 if (imx_ep->stopped) {
818 usb_req->status = -ESHUTDOWN;
819 return -ESHUTDOWN;
820 }
821
822 if (req->in_use) {
823 D_ERR(imx_usb->dev,
824 "<%s> refusing to queue req %p (already queued)\n",
825 __func__, req);
826 return 0;
827 }
828
829 local_irq_save(flags);
830
831 usb_req->status = -EINPROGRESS;
832 usb_req->actual = 0;
833
834 ep_add_request(imx_ep, req);
835
836 if (!EP_NO(imx_ep))
837 ret = handle_ep0(imx_ep);
838 else
839 ret = handle_ep(imx_ep);
840
841 local_irq_restore(flags);
842 return ret;
843}
844
845static int imx_ep_dequeue(struct usb_ep *usb_ep, struct usb_request *usb_req)
846{
847
848 struct imx_ep_struct *imx_ep = container_of
849 (usb_ep, struct imx_ep_struct, ep);
850 struct imx_request *req;
851 unsigned long flags;
852
853 if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
854 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
855 return -EINVAL;
856 }
857
858 local_irq_save(flags);
859
860
861 list_for_each_entry(req, &imx_ep->queue, queue) {
862 if (&req->req == usb_req)
863 break;
864 }
865 if (&req->req != usb_req) {
866 local_irq_restore(flags);
867 return -EINVAL;
868 }
869
870 done(imx_ep, req, -ECONNRESET);
871
872 local_irq_restore(flags);
873 return 0;
874}
875
876static int imx_ep_set_halt(struct usb_ep *usb_ep, int value)
877{
878 struct imx_ep_struct *imx_ep = container_of
879 (usb_ep, struct imx_ep_struct, ep);
880 unsigned long flags;
881
882 if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
883 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
884 return -EINVAL;
885 }
886
887 local_irq_save(flags);
888
889 if ((imx_ep->bEndpointAddress & USB_DIR_IN)
890 && !list_empty(&imx_ep->queue)) {
891 local_irq_restore(flags);
892 return -EAGAIN;
893 }
894
895 imx_ep_stall(imx_ep);
896
897 local_irq_restore(flags);
898
899 D_EPX(imx_ep->imx_usb->dev, "<%s> %s halt\n", __func__, usb_ep->name);
900 return 0;
901}
902
903static int imx_ep_fifo_status(struct usb_ep *usb_ep)
904{
905 struct imx_ep_struct *imx_ep = container_of
906 (usb_ep, struct imx_ep_struct, ep);
907
908 if (!usb_ep) {
909 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
910 return -ENODEV;
911 }
912
913 if (imx_ep->imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
914 return 0;
915 else
916 return imx_fifo_bcount(imx_ep);
917}
918
919static void imx_ep_fifo_flush(struct usb_ep *usb_ep)
920{
921 struct imx_ep_struct *imx_ep = container_of
922 (usb_ep, struct imx_ep_struct, ep);
923 unsigned long flags;
924
925 local_irq_save(flags);
926
927 if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
928 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
929 local_irq_restore(flags);
930 return;
931 }
932
933
934 imx_flush(imx_ep);
935
936 local_irq_restore(flags);
937}
938
939static struct usb_ep_ops imx_ep_ops = {
940 .enable = imx_ep_enable,
941 .disable = imx_ep_disable,
942
943 .alloc_request = imx_ep_alloc_request,
944 .free_request = imx_ep_free_request,
945
946 .queue = imx_ep_queue,
947 .dequeue = imx_ep_dequeue,
948
949 .set_halt = imx_ep_set_halt,
950 .fifo_status = imx_ep_fifo_status,
951 .fifo_flush = imx_ep_fifo_flush,
952};
953
954
955
956
957
958
959void ep0_chg_stat(const char *label,
960 struct imx_udc_struct *imx_usb, enum ep0_state stat)
961{
962 D_EP0(imx_usb->dev, "<%s> from %15s to %15s\n",
963 label, state_name[imx_usb->ep0state], state_name[stat]);
964
965 if (imx_usb->ep0state == stat)
966 return;
967
968 imx_usb->ep0state = stat;
969}
970
971static void usb_init_data(struct imx_udc_struct *imx_usb)
972{
973 struct imx_ep_struct *imx_ep;
974 u8 i;
975
976
977 INIT_LIST_HEAD(&imx_usb->gadget.ep_list);
978 INIT_LIST_HEAD(&imx_usb->gadget.ep0->ep_list);
979 ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
980
981
982 for (i = 0; i < IMX_USB_NB_EP; i++) {
983 imx_ep = &imx_usb->imx_ep[i];
984
985 if (i) {
986 list_add_tail(&imx_ep->ep.ep_list,
987 &imx_usb->gadget.ep_list);
988 imx_ep->stopped = 1;
989 } else
990 imx_ep->stopped = 0;
991
992 INIT_LIST_HEAD(&imx_ep->queue);
993 }
994}
995
996static void udc_stop_activity(struct imx_udc_struct *imx_usb,
997 struct usb_gadget_driver *driver)
998{
999 struct imx_ep_struct *imx_ep;
1000 int i;
1001
1002 if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
1003 driver = NULL;
1004
1005
1006 for (i = 1; i < IMX_USB_NB_EP; i++) {
1007 imx_ep = &imx_usb->imx_ep[i];
1008 imx_flush(imx_ep);
1009 imx_ep->stopped = 1;
1010 imx_ep_irq_disable(imx_ep);
1011 nuke(imx_ep, -ESHUTDOWN);
1012 }
1013
1014 imx_usb->cfg = 0;
1015 imx_usb->intf = 0;
1016 imx_usb->alt = 0;
1017
1018 if (driver)
1019 driver->disconnect(&imx_usb->gadget);
1020}
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031static void handle_config(unsigned long data)
1032{
1033 struct imx_udc_struct *imx_usb = (void *)data;
1034 struct usb_ctrlrequest u;
1035 int temp, cfg, intf, alt;
1036
1037 local_irq_disable();
1038
1039 temp = __raw_readl(imx_usb->base + USB_STAT);
1040 cfg = (temp & STAT_CFG) >> 5;
1041 intf = (temp & STAT_INTF) >> 3;
1042 alt = temp & STAT_ALTSET;
1043
1044 D_REQ(imx_usb->dev,
1045 "<%s> orig config C=%d, I=%d, A=%d / "
1046 "req config C=%d, I=%d, A=%d\n",
1047 __func__, imx_usb->cfg, imx_usb->intf, imx_usb->alt,
1048 cfg, intf, alt);
1049
1050 if (cfg == 1 || cfg == 2) {
1051
1052 if (imx_usb->cfg != cfg) {
1053 u.bRequest = USB_REQ_SET_CONFIGURATION;
1054 u.bRequestType = USB_DIR_OUT |
1055 USB_TYPE_STANDARD |
1056 USB_RECIP_DEVICE;
1057 u.wValue = cfg;
1058 u.wIndex = 0;
1059 u.wLength = 0;
1060 imx_usb->cfg = cfg;
1061 imx_usb->driver->setup(&imx_usb->gadget, &u);
1062
1063 }
1064 if (imx_usb->intf != intf || imx_usb->alt != alt) {
1065 u.bRequest = USB_REQ_SET_INTERFACE;
1066 u.bRequestType = USB_DIR_OUT |
1067 USB_TYPE_STANDARD |
1068 USB_RECIP_INTERFACE;
1069 u.wValue = alt;
1070 u.wIndex = intf;
1071 u.wLength = 0;
1072 imx_usb->intf = intf;
1073 imx_usb->alt = alt;
1074 imx_usb->driver->setup(&imx_usb->gadget, &u);
1075 }
1076 }
1077
1078 imx_usb->set_config = 0;
1079
1080 local_irq_enable();
1081}
1082
1083static irqreturn_t imx_udc_irq(int irq, void *dev)
1084{
1085 struct imx_udc_struct *imx_usb = dev;
1086 int intr = __raw_readl(imx_usb->base + USB_INTR);
1087 int temp;
1088
1089 if (intr & (INTR_WAKEUP | INTR_SUSPEND | INTR_RESUME | INTR_RESET_START
1090 | INTR_RESET_STOP | INTR_CFG_CHG)) {
1091 dump_intr(__func__, intr, imx_usb->dev);
1092 dump_usb_stat(__func__, imx_usb);
1093 }
1094
1095 if (!imx_usb->driver)
1096 goto end_irq;
1097
1098 if (intr & INTR_SOF) {
1099
1100
1101
1102
1103
1104 if (imx_usb->ep0state == EP0_IDLE) {
1105 temp = __raw_readl(imx_usb->base + USB_CTRL);
1106 __raw_writel(temp | CTRL_CMDOVER,
1107 imx_usb->base + USB_CTRL);
1108 }
1109 }
1110
1111 if (intr & INTR_CFG_CHG) {
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125 __raw_writel(INTR_CFG_CHG, imx_usb->base + USB_INTR);
1126 imx_usb->set_config = 1;
1127 mod_timer(&imx_usb->timer, jiffies + 5);
1128 goto end_irq;
1129 }
1130
1131 if (intr & INTR_WAKEUP) {
1132 if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN
1133 && imx_usb->driver && imx_usb->driver->resume)
1134 imx_usb->driver->resume(&imx_usb->gadget);
1135 imx_usb->set_config = 0;
1136 del_timer(&imx_usb->timer);
1137 imx_usb->gadget.speed = USB_SPEED_FULL;
1138 }
1139
1140 if (intr & INTR_SUSPEND) {
1141 if (imx_usb->gadget.speed != USB_SPEED_UNKNOWN
1142 && imx_usb->driver && imx_usb->driver->suspend)
1143 imx_usb->driver->suspend(&imx_usb->gadget);
1144 imx_usb->set_config = 0;
1145 del_timer(&imx_usb->timer);
1146 imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
1147 }
1148
1149 if (intr & INTR_RESET_START) {
1150 __raw_writel(intr, imx_usb->base + USB_INTR);
1151 udc_stop_activity(imx_usb, imx_usb->driver);
1152 imx_usb->set_config = 0;
1153 del_timer(&imx_usb->timer);
1154 imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
1155 }
1156
1157 if (intr & INTR_RESET_STOP)
1158 imx_usb->gadget.speed = USB_SPEED_FULL;
1159
1160end_irq:
1161 __raw_writel(intr, imx_usb->base + USB_INTR);
1162 return IRQ_HANDLED;
1163}
1164
1165static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
1166{
1167 struct imx_udc_struct *imx_usb = dev;
1168 struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
1169 int intr = __raw_readl(imx_usb->base + USB_EP_INTR(0));
1170
1171 dump_ep_intr(__func__, 0, intr, imx_usb->dev);
1172
1173 if (!imx_usb->driver) {
1174 __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
1175 return IRQ_HANDLED;
1176 }
1177
1178
1179 if (intr & (EPINTR_DEVREQ | EPINTR_MDEVREQ))
1180 handle_ep0_devreq(imx_usb);
1181
1182
1183
1184
1185 else if (!list_empty(&imx_ep->queue))
1186 handle_ep0(imx_ep);
1187
1188 __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
1189
1190 return IRQ_HANDLED;
1191}
1192
1193static irqreturn_t imx_udc_bulk_irq(int irq, void *dev)
1194{
1195 struct imx_udc_struct *imx_usb = dev;
1196 struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - USBD_INT0];
1197 int intr = __raw_readl(imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1198
1199 dump_ep_intr(__func__, irq - USBD_INT0, intr, imx_usb->dev);
1200
1201 if (!imx_usb->driver) {
1202 __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1203 return IRQ_HANDLED;
1204 }
1205
1206 handle_ep(imx_ep);
1207
1208 __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1209
1210 return IRQ_HANDLED;
1211}
1212
1213irq_handler_t intr_handler(int i)
1214{
1215 switch (i) {
1216 case 0:
1217 return imx_udc_ctrl_irq;
1218 case 1:
1219 case 2:
1220 case 3:
1221 case 4:
1222 case 5:
1223 return imx_udc_bulk_irq;
1224 default:
1225 return imx_udc_irq;
1226 }
1227}
1228
1229
1230
1231
1232
1233
1234static const struct usb_gadget_ops imx_udc_ops = {
1235 .get_frame = imx_udc_get_frame,
1236 .wakeup = imx_udc_wakeup,
1237};
1238
1239static struct imx_udc_struct controller = {
1240 .gadget = {
1241 .ops = &imx_udc_ops,
1242 .ep0 = &controller.imx_ep[0].ep,
1243 .name = driver_name,
1244 .dev = {
1245 .init_name = "gadget",
1246 },
1247 },
1248
1249 .imx_ep[0] = {
1250 .ep = {
1251 .name = ep0name,
1252 .ops = &imx_ep_ops,
1253 .maxpacket = 32,
1254 },
1255 .imx_usb = &controller,
1256 .fifosize = 32,
1257 .bEndpointAddress = 0,
1258 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
1259 },
1260 .imx_ep[1] = {
1261 .ep = {
1262 .name = "ep1in-bulk",
1263 .ops = &imx_ep_ops,
1264 .maxpacket = 64,
1265 },
1266 .imx_usb = &controller,
1267 .fifosize = 64,
1268 .bEndpointAddress = USB_DIR_IN | 1,
1269 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1270 },
1271 .imx_ep[2] = {
1272 .ep = {
1273 .name = "ep2out-bulk",
1274 .ops = &imx_ep_ops,
1275 .maxpacket = 64,
1276 },
1277 .imx_usb = &controller,
1278 .fifosize = 64,
1279 .bEndpointAddress = USB_DIR_OUT | 2,
1280 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1281 },
1282 .imx_ep[3] = {
1283 .ep = {
1284 .name = "ep3out-bulk",
1285 .ops = &imx_ep_ops,
1286 .maxpacket = 32,
1287 },
1288 .imx_usb = &controller,
1289 .fifosize = 32,
1290 .bEndpointAddress = USB_DIR_OUT | 3,
1291 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1292 },
1293 .imx_ep[4] = {
1294 .ep = {
1295 .name = "ep4in-int",
1296 .ops = &imx_ep_ops,
1297 .maxpacket = 32,
1298 },
1299 .imx_usb = &controller,
1300 .fifosize = 32,
1301 .bEndpointAddress = USB_DIR_IN | 4,
1302 .bmAttributes = USB_ENDPOINT_XFER_INT,
1303 },
1304 .imx_ep[5] = {
1305 .ep = {
1306 .name = "ep5out-int",
1307 .ops = &imx_ep_ops,
1308 .maxpacket = 32,
1309 },
1310 .imx_usb = &controller,
1311 .fifosize = 32,
1312 .bEndpointAddress = USB_DIR_OUT | 5,
1313 .bmAttributes = USB_ENDPOINT_XFER_INT,
1314 },
1315};
1316
1317
1318
1319
1320
1321int usb_gadget_register_driver(struct usb_gadget_driver *driver)
1322{
1323 struct imx_udc_struct *imx_usb = &controller;
1324 int retval;
1325
1326 if (!driver
1327 || driver->speed < USB_SPEED_FULL
1328 || !driver->bind
1329 || !driver->disconnect
1330 || !driver->setup)
1331 return -EINVAL;
1332 if (!imx_usb)
1333 return -ENODEV;
1334 if (imx_usb->driver)
1335 return -EBUSY;
1336
1337
1338 imx_usb->driver = driver;
1339 imx_usb->gadget.dev.driver = &driver->driver;
1340
1341 retval = device_add(&imx_usb->gadget.dev);
1342 if (retval)
1343 goto fail;
1344 retval = driver->bind(&imx_usb->gadget);
1345 if (retval) {
1346 D_ERR(imx_usb->dev, "<%s> bind to driver %s --> error %d\n",
1347 __func__, driver->driver.name, retval);
1348 device_del(&imx_usb->gadget.dev);
1349
1350 goto fail;
1351 }
1352
1353 D_INI(imx_usb->dev, "<%s> registered gadget driver '%s'\n",
1354 __func__, driver->driver.name);
1355
1356 imx_udc_enable(imx_usb);
1357
1358 return 0;
1359fail:
1360 imx_usb->driver = NULL;
1361 imx_usb->gadget.dev.driver = NULL;
1362 return retval;
1363}
1364EXPORT_SYMBOL(usb_gadget_register_driver);
1365
1366int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
1367{
1368 struct imx_udc_struct *imx_usb = &controller;
1369
1370 if (!imx_usb)
1371 return -ENODEV;
1372 if (!driver || driver != imx_usb->driver || !driver->unbind)
1373 return -EINVAL;
1374
1375 udc_stop_activity(imx_usb, driver);
1376 imx_udc_disable(imx_usb);
1377 del_timer(&imx_usb->timer);
1378
1379 driver->unbind(&imx_usb->gadget);
1380 imx_usb->gadget.dev.driver = NULL;
1381 imx_usb->driver = NULL;
1382
1383 device_del(&imx_usb->gadget.dev);
1384
1385 D_INI(imx_usb->dev, "<%s> unregistered gadget driver '%s'\n",
1386 __func__, driver->driver.name);
1387
1388 return 0;
1389}
1390EXPORT_SYMBOL(usb_gadget_unregister_driver);
1391
1392
1393
1394
1395
1396
1397static int __init imx_udc_probe(struct platform_device *pdev)
1398{
1399 struct imx_udc_struct *imx_usb = &controller;
1400 struct resource *res;
1401 struct imxusb_platform_data *pdata;
1402 struct clk *clk;
1403 void __iomem *base;
1404 int ret = 0;
1405 int i;
1406 resource_size_t res_size;
1407
1408 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1409 if (!res) {
1410 dev_err(&pdev->dev, "can't get device resources\n");
1411 return -ENODEV;
1412 }
1413
1414 pdata = pdev->dev.platform_data;
1415 if (!pdata) {
1416 dev_err(&pdev->dev, "driver needs platform data\n");
1417 return -ENODEV;
1418 }
1419
1420 res_size = resource_size(res);
1421 if (!request_mem_region(res->start, res_size, res->name)) {
1422 dev_err(&pdev->dev, "can't allocate %d bytes at %d address\n",
1423 res_size, res->start);
1424 return -ENOMEM;
1425 }
1426
1427 if (pdata->init) {
1428 ret = pdata->init(&pdev->dev);
1429 if (ret)
1430 goto fail0;
1431 }
1432
1433 base = ioremap(res->start, res_size);
1434 if (!base) {
1435 dev_err(&pdev->dev, "ioremap failed\n");
1436 ret = -EIO;
1437 goto fail1;
1438 }
1439
1440 clk = clk_get(NULL, "usbd_clk");
1441 if (IS_ERR(clk)) {
1442 ret = PTR_ERR(clk);
1443 dev_err(&pdev->dev, "can't get USB clock\n");
1444 goto fail2;
1445 }
1446 clk_enable(clk);
1447
1448 if (clk_get_rate(clk) != 48000000) {
1449 D_INI(&pdev->dev,
1450 "Bad USB clock (%d Hz), changing to 48000000 Hz\n",
1451 (int)clk_get_rate(clk));
1452 if (clk_set_rate(clk, 48000000)) {
1453 dev_err(&pdev->dev,
1454 "Unable to set correct USB clock (48MHz)\n");
1455 ret = -EIO;
1456 goto fail3;
1457 }
1458 }
1459
1460 for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
1461 imx_usb->usbd_int[i] = platform_get_irq(pdev, i);
1462 if (imx_usb->usbd_int[i] < 0) {
1463 dev_err(&pdev->dev, "can't get irq number\n");
1464 ret = -ENODEV;
1465 goto fail3;
1466 }
1467 }
1468
1469 for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
1470 ret = request_irq(imx_usb->usbd_int[i], intr_handler(i),
1471 IRQF_DISABLED, driver_name, imx_usb);
1472 if (ret) {
1473 dev_err(&pdev->dev, "can't get irq %i, err %d\n",
1474 imx_usb->usbd_int[i], ret);
1475 for (--i; i >= 0; i--)
1476 free_irq(imx_usb->usbd_int[i], imx_usb);
1477 goto fail3;
1478 }
1479 }
1480
1481 imx_usb->res = res;
1482 imx_usb->base = base;
1483 imx_usb->clk = clk;
1484 imx_usb->dev = &pdev->dev;
1485
1486 device_initialize(&imx_usb->gadget.dev);
1487
1488 imx_usb->gadget.dev.parent = &pdev->dev;
1489 imx_usb->gadget.dev.dma_mask = pdev->dev.dma_mask;
1490
1491 platform_set_drvdata(pdev, imx_usb);
1492
1493 usb_init_data(imx_usb);
1494 imx_udc_init(imx_usb);
1495
1496 init_timer(&imx_usb->timer);
1497 imx_usb->timer.function = handle_config;
1498 imx_usb->timer.data = (unsigned long)imx_usb;
1499
1500 return 0;
1501
1502fail3:
1503 clk_put(clk);
1504 clk_disable(clk);
1505fail2:
1506 iounmap(base);
1507fail1:
1508 if (pdata->exit)
1509 pdata->exit(&pdev->dev);
1510fail0:
1511 release_mem_region(res->start, res_size);
1512 return ret;
1513}
1514
1515static int __exit imx_udc_remove(struct platform_device *pdev)
1516{
1517 struct imx_udc_struct *imx_usb = platform_get_drvdata(pdev);
1518 struct imxusb_platform_data *pdata = pdev->dev.platform_data;
1519 int i;
1520
1521 imx_udc_disable(imx_usb);
1522 del_timer(&imx_usb->timer);
1523
1524 for (i = 0; i < IMX_USB_NB_EP + 1; i++)
1525 free_irq(imx_usb->usbd_int[i], imx_usb);
1526
1527 clk_put(imx_usb->clk);
1528 clk_disable(imx_usb->clk);
1529 iounmap(imx_usb->base);
1530
1531 release_mem_region(imx_usb->res->start, resource_size(imx_usb->res));
1532
1533 if (pdata->exit)
1534 pdata->exit(&pdev->dev);
1535
1536 platform_set_drvdata(pdev, NULL);
1537
1538 return 0;
1539}
1540
1541
1542
1543#ifdef CONFIG_PM
1544#define imx_udc_suspend NULL
1545#define imx_udc_resume NULL
1546#else
1547#define imx_udc_suspend NULL
1548#define imx_udc_resume NULL
1549#endif
1550
1551
1552
1553static struct platform_driver udc_driver = {
1554 .driver = {
1555 .name = driver_name,
1556 .owner = THIS_MODULE,
1557 },
1558 .remove = __exit_p(imx_udc_remove),
1559 .suspend = imx_udc_suspend,
1560 .resume = imx_udc_resume,
1561};
1562
1563static int __init udc_init(void)
1564{
1565 return platform_driver_probe(&udc_driver, imx_udc_probe);
1566}
1567module_init(udc_init);
1568
1569static void __exit udc_exit(void)
1570{
1571 platform_driver_unregister(&udc_driver);
1572}
1573module_exit(udc_exit);
1574
1575MODULE_DESCRIPTION("IMX USB Device Controller driver");
1576MODULE_AUTHOR("Darius Augulis <augulis.darius@gmail.com>");
1577MODULE_LICENSE("GPL");
1578MODULE_ALIAS("platform:imx_udc");
1579
