?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add linux-next specific files for 20110421
[linux-2.6/next.git] / drivers / usb / gadget / imx_udc.c
blob5408186afc35c41dee81ff8afb7bcc55163a68a4
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 /* A workaround of serious IMX UDC bug.
1114 Handling of CFG_CHG should be delayed for some time, because
1115 IMX does not NACK the host when CFG_CHG interrupt is pending.
1116 There is no time to handle current CFG_CHG
1117 if next CFG_CHG or SETUP packed is send immediately.
1118 We have to clear CFG_CHG, start the timer and
1119 NACK the host by setting CTRL_CMDOVER
1120 if it sends any SETUP packet.
1121 When timer expires, handler is called to handle configuration
1122 changes. While CFG_CHG is not handled (set_config=1),
1123 we must NACK the host to every SETUP packed.
1124 This delay prevents from going out of sync with host.
1125 */
1126 __raw_writel(INTR_CFG_CHG, imx_usb->base + USB_INTR);
1127 imx_usb->set_config = 1;
1128 mod_timer(&imx_usb->timer, jiffies + 5);
1129 goto end_irq;
1130 }
1131
1132 if (intr & INTR_WAKEUP) {
1133 if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN
1134 && imx_usb->driver && imx_usb->driver->resume)
1135 imx_usb->driver->resume(&imx_usb->gadget);
1136 imx_usb->set_config = 0;
1137 del_timer(&imx_usb->timer);
1138 imx_usb->gadget.speed = USB_SPEED_FULL;
1139 }
1140
1141 if (intr & INTR_SUSPEND) {
1142 if (imx_usb->gadget.speed != USB_SPEED_UNKNOWN
1143 && imx_usb->driver && imx_usb->driver->suspend)
1144 imx_usb->driver->suspend(&imx_usb->gadget);
1145 imx_usb->set_config = 0;
1146 del_timer(&imx_usb->timer);
1147 imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
1148 }
1149
1150 if (intr & INTR_RESET_START) {
1151 __raw_writel(intr, imx_usb->base + USB_INTR);
1152 udc_stop_activity(imx_usb, imx_usb->driver);
1153 imx_usb->set_config = 0;
1154 del_timer(&imx_usb->timer);
1155 imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
1156 }
1157
1158 if (intr & INTR_RESET_STOP)
1159 imx_usb->gadget.speed = USB_SPEED_FULL;
1160
1161 end_irq:
1162 __raw_writel(intr, imx_usb->base + USB_INTR);
1163 return IRQ_HANDLED;
1164 }
1165
1166 static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
1167 {
1168 struct imx_udc_struct *imx_usb = dev;
1169 struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
1170 int intr = __raw_readl(imx_usb->base + USB_EP_INTR(0));
1171
1172 dump_ep_intr(__func__, 0, intr, imx_usb->dev);
1173
1174 if (!imx_usb->driver) {
1175 __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
1176 return IRQ_HANDLED;
1177 }
1178
1179 /* DEVREQ has highest priority */
1180 if (intr & (EPINTR_DEVREQ | EPINTR_MDEVREQ))
1181 handle_ep0_devreq(imx_usb);
1182 /* Seem i.MX is missing EOF interrupt sometimes.
1183 * Therefore we don't monitor EOF.
1184 * We call handle_ep0() only if a request is queued for ep0.
1185 */
1186 else if (!list_empty(&imx_ep->queue))
1187 handle_ep0(imx_ep);
1188
1189 __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
1190
1191 return IRQ_HANDLED;
1192 }
1193
1194 #ifndef MX1_INT_USBD0
1195 #define MX1_INT_USBD0 MX1_USBD_INT0
1196 #endif
1197
1198 static irqreturn_t imx_udc_bulk_irq(int irq, void *dev)
1199 {
1200 struct imx_udc_struct *imx_usb = dev;
1201 struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - MX1_INT_USBD0];
1202 int intr = __raw_readl(imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1203
1204 dump_ep_intr(__func__, irq - MX1_INT_USBD0, intr, imx_usb->dev);
1205
1206 if (!imx_usb->driver) {
1207 __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1208 return IRQ_HANDLED;
1209 }
1210
1211 handle_ep(imx_ep);
1212
1213 __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
1214
1215 return IRQ_HANDLED;
1216 }
1217
1218 irq_handler_t intr_handler(int i)
1219 {
1220 switch (i) {
1221 case 0:
1222 return imx_udc_ctrl_irq;
1223 case 1:
1224 case 2:
1225 case 3:
1226 case 4:
1227 case 5:
1228 return imx_udc_bulk_irq;
1229 default:
1230 return imx_udc_irq;
1231 }
1232 }
1233
1234 /*******************************************************************************
1235 * Static defined IMX UDC structure
1236 *******************************************************************************
1237 */
1238
1239 static const struct usb_gadget_ops imx_udc_ops = {
1240 .get_frame = imx_udc_get_frame,
1241 .wakeup = imx_udc_wakeup,
1242 };
1243
1244 static struct imx_udc_struct controller = {
1245 .gadget = {
1246 .ops = &imx_udc_ops,
1247 .ep0 = &controller.imx_ep[0].ep,
1248 .name = driver_name,
1249 .dev = {
1250 .init_name = "gadget",
1251 },
1252 },
1253
1254 .imx_ep[0] = {
1255 .ep = {
1256 .name = ep0name,
1257 .ops = &imx_ep_ops,
1258 .maxpacket = 32,
1259 },
1260 .imx_usb = &controller,
1261 .fifosize = 32,
1262 .bEndpointAddress = 0,
1263 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
1264 },
1265 .imx_ep[1] = {
1266 .ep = {
1267 .name = "ep1in-bulk",
1268 .ops = &imx_ep_ops,
1269 .maxpacket = 64,
1270 },
1271 .imx_usb = &controller,
1272 .fifosize = 64,
1273 .bEndpointAddress = USB_DIR_IN | 1,
1274 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1275 },
1276 .imx_ep[2] = {
1277 .ep = {
1278 .name = "ep2out-bulk",
1279 .ops = &imx_ep_ops,
1280 .maxpacket = 64,
1281 },
1282 .imx_usb = &controller,
1283 .fifosize = 64,
1284 .bEndpointAddress = USB_DIR_OUT | 2,
1285 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1286 },
1287 .imx_ep[3] = {
1288 .ep = {
1289 .name = "ep3out-bulk",
1290 .ops = &imx_ep_ops,
1291 .maxpacket = 32,
1292 },
1293 .imx_usb = &controller,
1294 .fifosize = 32,
1295 .bEndpointAddress = USB_DIR_OUT | 3,
1296 .bmAttributes = USB_ENDPOINT_XFER_BULK,
1297 },
1298 .imx_ep[4] = {
1299 .ep = {
1300 .name = "ep4in-int",
1301 .ops = &imx_ep_ops,
1302 .maxpacket = 32,
1303 },
1304 .imx_usb = &controller,
1305 .fifosize = 32,
1306 .bEndpointAddress = USB_DIR_IN | 4,
1307 .bmAttributes = USB_ENDPOINT_XFER_INT,
1308 },
1309 .imx_ep[5] = {
1310 .ep = {
1311 .name = "ep5out-int",
1312 .ops = &imx_ep_ops,
1313 .maxpacket = 32,
1314 },
1315 .imx_usb = &controller,
1316 .fifosize = 32,
1317 .bEndpointAddress = USB_DIR_OUT | 5,
1318 .bmAttributes = USB_ENDPOINT_XFER_INT,
1319 },
1320 };
1321
1322 /*******************************************************************************
1323 * USB gadget driver functions
1324 *******************************************************************************
1325 */
1326 int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
1327 int (*bind)(struct usb_gadget *))
1328 {
1329 struct imx_udc_struct *imx_usb = &controller;
1330 int retval;
1331
1332 if (!driver
1333 || driver->speed < USB_SPEED_FULL
1334 || !bind
1335 || !driver->disconnect
1336 || !driver->setup)
1337 return -EINVAL;
1338 if (!imx_usb)
1339 return -ENODEV;
1340 if (imx_usb->driver)
1341 return -EBUSY;
1342
1343 /* first hook up the driver ... */
1344 imx_usb->driver = driver;
1345 imx_usb->gadget.dev.driver = &driver->driver;
1346
1347 retval = device_add(&imx_usb->gadget.dev);
1348 if (retval)
1349 goto fail;
1350 retval = bind(&imx_usb->gadget);
1351 if (retval) {
1352 D_ERR(imx_usb->dev, "<%s> bind to driver %s --> error %d\n",
1353 __func__, driver->driver.name, retval);
1354 device_del(&imx_usb->gadget.dev);
1355
1356 goto fail;
1357 }
1358
1359 D_INI(imx_usb->dev, "<%s> registered gadget driver '%s'\n",
1360 __func__, driver->driver.name);
1361
1362 imx_udc_enable(imx_usb);
1363
1364 return 0;
1365 fail:
1366 imx_usb->driver = NULL;
1367 imx_usb->gadget.dev.driver = NULL;
1368 return retval;
1369 }
1370 EXPORT_SYMBOL(usb_gadget_probe_driver);
1371
1372 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
1373 {
1374 struct imx_udc_struct *imx_usb = &controller;
1375
1376 if (!imx_usb)
1377 return -ENODEV;
1378 if (!driver || driver != imx_usb->driver || !driver->unbind)
1379 return -EINVAL;
1380
1381 udc_stop_activity(imx_usb, driver);
1382 imx_udc_disable(imx_usb);
1383 del_timer(&imx_usb->timer);
1384
1385 driver->unbind(&imx_usb->gadget);
1386 imx_usb->gadget.dev.driver = NULL;
1387 imx_usb->driver = NULL;
1388
1389 device_del(&imx_usb->gadget.dev);
1390
1391 D_INI(imx_usb->dev, "<%s> unregistered gadget driver '%s'\n",
1392 __func__, driver->driver.name);
1393
1394 return 0;
1395 }
1396 EXPORT_SYMBOL(usb_gadget_unregister_driver);
1397
1398 /*******************************************************************************
1399 * Module functions
1400 *******************************************************************************
1401 */
1402
1403 static int __init imx_udc_probe(struct platform_device *pdev)
1404 {
1405 struct imx_udc_struct *imx_usb = &controller;
1406 struct resource *res;
1407 struct imxusb_platform_data *pdata;
1408 struct clk *clk;
1409 void __iomem *base;
1410 int ret = 0;
1411 int i;
1412 resource_size_t res_size;
1413
1414 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1415 if (!res) {
1416 dev_err(&pdev->dev, "can't get device resources\n");
1417 return -ENODEV;
1418 }
1419
1420 pdata = pdev->dev.platform_data;
1421 if (!pdata) {
1422 dev_err(&pdev->dev, "driver needs platform data\n");
1423 return -ENODEV;
1424 }
1425
1426 res_size = resource_size(res);
1427 if (!request_mem_region(res->start, res_size, res->name)) {
1428 dev_err(&pdev->dev, "can't allocate %d bytes at %d address\n",
1429 res_size, res->start);
1430 return -ENOMEM;
1431 }
1432
1433 if (pdata->init) {
1434 ret = pdata->init(&pdev->dev);
1435 if (ret)
1436 goto fail0;
1437 }
1438
1439 base = ioremap(res->start, res_size);
1440 if (!base) {
1441 dev_err(&pdev->dev, "ioremap failed\n");
1442 ret = -EIO;
1443 goto fail1;
1444 }
1445
1446 clk = clk_get(NULL, "usbd_clk");
1447 if (IS_ERR(clk)) {
1448 ret = PTR_ERR(clk);
1449 dev_err(&pdev->dev, "can't get USB clock\n");
1450 goto fail2;
1451 }
1452 clk_enable(clk);
1453
1454 if (clk_get_rate(clk) != 48000000) {
1455 D_INI(&pdev->dev,
1456 "Bad USB clock (%d Hz), changing to 48000000 Hz\n",
1457 (int)clk_get_rate(clk));
1458 if (clk_set_rate(clk, 48000000)) {
1459 dev_err(&pdev->dev,
1460 "Unable to set correct USB clock (48MHz)\n");
1461 ret = -EIO;
1462 goto fail3;
1463 }
1464 }
1465
1466 for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
1467 imx_usb->usbd_int[i] = platform_get_irq(pdev, i);
1468 if (imx_usb->usbd_int[i] < 0) {
1469 dev_err(&pdev->dev, "can't get irq number\n");
1470 ret = -ENODEV;
1471 goto fail3;
1472 }
1473 }
1474
1475 for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
1476 ret = request_irq(imx_usb->usbd_int[i], intr_handler(i),
1477 IRQF_DISABLED, driver_name, imx_usb);
1478 if (ret) {
1479 dev_err(&pdev->dev, "can't get irq %i, err %d\n",
1480 imx_usb->usbd_int[i], ret);
1481 for (--i; i >= 0; i--)
1482 free_irq(imx_usb->usbd_int[i], imx_usb);
1483 goto fail3;
1484 }
1485 }
1486
1487 imx_usb->res = res;
1488 imx_usb->base = base;
1489 imx_usb->clk = clk;
1490 imx_usb->dev = &pdev->dev;
1491
1492 device_initialize(&imx_usb->gadget.dev);
1493
1494 imx_usb->gadget.dev.parent = &pdev->dev;
1495 imx_usb->gadget.dev.dma_mask = pdev->dev.dma_mask;
1496
1497 platform_set_drvdata(pdev, imx_usb);
1498
1499 usb_init_data(imx_usb);
1500 imx_udc_init(imx_usb);
1501
1502 init_timer(&imx_usb->timer);
1503 imx_usb->timer.function = handle_config;
1504 imx_usb->timer.data = (unsigned long)imx_usb;
1505
1506 return 0;
1507
1508 fail3:
1509 clk_put(clk);
1510 clk_disable(clk);
1511 fail2:
1512 iounmap(base);
1513 fail1:
1514 if (pdata->exit)
1515 pdata->exit(&pdev->dev);
1516 fail0:
1517 release_mem_region(res->start, res_size);
1518 return ret;
1519 }
1520
1521 static int __exit imx_udc_remove(struct platform_device *pdev)
1522 {
1523 struct imx_udc_struct *imx_usb = platform_get_drvdata(pdev);
1524 struct imxusb_platform_data *pdata = pdev->dev.platform_data;
1525 int i;
1526
1527 imx_udc_disable(imx_usb);
1528 del_timer(&imx_usb->timer);
1529
1530 for (i = 0; i < IMX_USB_NB_EP + 1; i++)
1531 free_irq(imx_usb->usbd_int[i], imx_usb);
1532
1533 clk_put(imx_usb->clk);
1534 clk_disable(imx_usb->clk);
1535 iounmap(imx_usb->base);
1536
1537 release_mem_region(imx_usb->res->start, resource_size(imx_usb->res));
1538
1539 if (pdata->exit)
1540 pdata->exit(&pdev->dev);
1541
1542 platform_set_drvdata(pdev, NULL);
1543
1544 return 0;
1545 }
1546
1547 /*----------------------------------------------------------------------------*/
1548
1549 #ifdef CONFIG_PM
1550 #define imx_udc_suspend NULL
1551 #define imx_udc_resume NULL
1552 #else
1553 #define imx_udc_suspend NULL
1554 #define imx_udc_resume NULL
1555 #endif
1556
1557 /*----------------------------------------------------------------------------*/
1558
1559 static struct platform_driver udc_driver = {
1560 .driver = {
1561 .name = driver_name,
1562 .owner = THIS_MODULE,
1563 },
1564 .remove = __exit_p(imx_udc_remove),
1565 .suspend = imx_udc_suspend,
1566 .resume = imx_udc_resume,
1567 };
1568
1569 static int __init udc_init(void)
1570 {
1571 return platform_driver_probe(&udc_driver, imx_udc_probe);
1572 }
1573 module_init(udc_init);
1574
1575 static void __exit udc_exit(void)
1576 {
1577 platform_driver_unregister(&udc_driver);
1578 }
1579 module_exit(udc_exit);
1580
1581 MODULE_DESCRIPTION("IMX USB Device Controller driver");
1582 MODULE_AUTHOR("Darius Augulis <augulis.darius@gmail.com>");
1583 MODULE_LICENSE("GPL");
1584 MODULE_ALIAS("platform:imx_udc");
linux-next