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