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