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