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