Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
imx_udc.c
Go to the documentation of this file.
1 /*
2  * driver/usb/gadget/imx_udc.c
3  *
4  * Copyright (C) 2005 Mike Lee <[email protected]>
5  * Copyright (C) 2008 Darius Augulis <[email protected]>
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 <linux/platform_data/usb-imx_udc.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 *gadget,
1241  struct usb_gadget_driver *driver);
1242 static int imx_udc_stop(struct usb_gadget *gadget,
1243  struct usb_gadget_driver *driver);
1244 static const struct usb_gadget_ops imx_udc_ops = {
1245  .get_frame = imx_udc_get_frame,
1246  .wakeup = imx_udc_wakeup,
1247  .udc_start = imx_udc_start,
1248  .udc_stop = imx_udc_stop,
1249 };
1250 
1251 static struct imx_udc_struct controller = {
1252  .gadget = {
1253  .ops = &imx_udc_ops,
1254  .ep0 = &controller.imx_ep[0].ep,
1255  .name = driver_name,
1256  .dev = {
1257  .init_name = "gadget",
1258  },
1259  },
1260 
1261  .imx_ep[0] = {
1262  .ep = {
1263  .name = ep0name,
1264  .ops = &imx_ep_ops,
1265  .maxpacket = 32,
1266  },
1267  .imx_usb = &controller,
1268  .fifosize = 32,
1269  .bEndpointAddress = 0,
1270  .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
1271  },
1272  .imx_ep[1] = {
1273  .ep = {
1274  .name = "ep1in-bulk",
1275  .ops = &imx_ep_ops,
1276  .maxpacket = 64,
1277  },
1278  .imx_usb = &controller,
1279  .fifosize = 64,
1280  .bEndpointAddress = USB_DIR_IN | 1,
1281  .bmAttributes = USB_ENDPOINT_XFER_BULK,
1282  },
1283  .imx_ep[2] = {
1284  .ep = {
1285  .name = "ep2out-bulk",
1286  .ops = &imx_ep_ops,
1287  .maxpacket = 64,
1288  },
1289  .imx_usb = &controller,
1290  .fifosize = 64,
1291  .bEndpointAddress = USB_DIR_OUT | 2,
1292  .bmAttributes = USB_ENDPOINT_XFER_BULK,
1293  },
1294  .imx_ep[3] = {
1295  .ep = {
1296  .name = "ep3out-bulk",
1297  .ops = &imx_ep_ops,
1298  .maxpacket = 32,
1299  },
1300  .imx_usb = &controller,
1301  .fifosize = 32,
1302  .bEndpointAddress = USB_DIR_OUT | 3,
1303  .bmAttributes = USB_ENDPOINT_XFER_BULK,
1304  },
1305  .imx_ep[4] = {
1306  .ep = {
1307  .name = "ep4in-int",
1308  .ops = &imx_ep_ops,
1309  .maxpacket = 32,
1310  },
1311  .imx_usb = &controller,
1312  .fifosize = 32,
1313  .bEndpointAddress = USB_DIR_IN | 4,
1314  .bmAttributes = USB_ENDPOINT_XFER_INT,
1315  },
1316  .imx_ep[5] = {
1317  .ep = {
1318  .name = "ep5out-int",
1319  .ops = &imx_ep_ops,
1320  .maxpacket = 32,
1321  },
1322  .imx_usb = &controller,
1323  .fifosize = 32,
1324  .bEndpointAddress = USB_DIR_OUT | 5,
1325  .bmAttributes = USB_ENDPOINT_XFER_INT,
1326  },
1327 };
1328 
1329 /*******************************************************************************
1330  * USB gadget driver functions
1331  *******************************************************************************
1332  */
1333 static int imx_udc_start(struct usb_gadget *gadget,
1334  struct usb_gadget_driver *driver)
1335 {
1336  struct imx_udc_struct *imx_usb;
1337  int retval;
1338 
1339  imx_usb = container_of(gadget, struct imx_udc_struct, gadget);
1340  /* first hook up the driver ... */
1341  imx_usb->driver = driver;
1342  imx_usb->gadget.dev.driver = &driver->driver;
1343 
1344  retval = device_add(&imx_usb->gadget.dev);
1345  if (retval)
1346  goto fail;
1347 
1348  D_INI(imx_usb->dev, "<%s> registered gadget driver '%s'\n",
1349  __func__, driver->driver.name);
1350 
1351  imx_udc_enable(imx_usb);
1352 
1353  return 0;
1354 fail:
1355  imx_usb->driver = NULL;
1356  imx_usb->gadget.dev.driver = NULL;
1357  return retval;
1358 }
1359 
1360 static int imx_udc_stop(struct usb_gadget *gadget,
1361  struct usb_gadget_driver *driver)
1362 {
1363  struct imx_udc_struct *imx_usb = container_of(gadget,
1364  struct imx_udc_struct, gadget);
1365 
1366  udc_stop_activity(imx_usb, driver);
1367  imx_udc_disable(imx_usb);
1368  del_timer(&imx_usb->timer);
1369 
1370  imx_usb->gadget.dev.driver = NULL;
1371  imx_usb->driver = NULL;
1372 
1373  device_del(&imx_usb->gadget.dev);
1374 
1375  D_INI(imx_usb->dev, "<%s> unregistered gadget driver '%s'\n",
1376  __func__, driver->driver.name);
1377 
1378  return 0;
1379 }
1380 
1381 /*******************************************************************************
1382  * Module functions
1383  *******************************************************************************
1384  */
1385 
1386 static int __init imx_udc_probe(struct platform_device *pdev)
1387 {
1388  struct imx_udc_struct *imx_usb = &controller;
1389  struct resource *res;
1390  struct imxusb_platform_data *pdata;
1391  struct clk *clk;
1392  void __iomem *base;
1393  int ret = 0;
1394  int i;
1395  resource_size_t res_size;
1396 
1397  res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1398  if (!res) {
1399  dev_err(&pdev->dev, "can't get device resources\n");
1400  return -ENODEV;
1401  }
1402 
1403  pdata = pdev->dev.platform_data;
1404  if (!pdata) {
1405  dev_err(&pdev->dev, "driver needs platform data\n");
1406  return -ENODEV;
1407  }
1408 
1409  res_size = resource_size(res);
1410  if (!request_mem_region(res->start, res_size, res->name)) {
1411  dev_err(&pdev->dev, "can't allocate %d bytes at %d address\n",
1412  res_size, res->start);
1413  return -ENOMEM;
1414  }
1415 
1416  if (pdata->init) {
1417  ret = pdata->init(&pdev->dev);
1418  if (ret)
1419  goto fail0;
1420  }
1421 
1422  base = ioremap(res->start, res_size);
1423  if (!base) {
1424  dev_err(&pdev->dev, "ioremap failed\n");
1425  ret = -EIO;
1426  goto fail1;
1427  }
1428 
1429  clk = clk_get(NULL, "usbd_clk");
1430  if (IS_ERR(clk)) {
1431  ret = PTR_ERR(clk);
1432  dev_err(&pdev->dev, "can't get USB clock\n");
1433  goto fail2;
1434  }
1435  clk_prepare_enable(clk);
1436 
1437  if (clk_get_rate(clk) != 48000000) {
1438  D_INI(&pdev->dev,
1439  "Bad USB clock (%d Hz), changing to 48000000 Hz\n",
1440  (int)clk_get_rate(clk));
1441  if (clk_set_rate(clk, 48000000)) {
1442  dev_err(&pdev->dev,
1443  "Unable to set correct USB clock (48MHz)\n");
1444  ret = -EIO;
1445  goto fail3;
1446  }
1447  }
1448 
1449  for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
1450  imx_usb->usbd_int[i] = platform_get_irq(pdev, i);
1451  if (imx_usb->usbd_int[i] < 0) {
1452  dev_err(&pdev->dev, "can't get irq number\n");
1453  ret = -ENODEV;
1454  goto fail3;
1455  }
1456  }
1457 
1458  for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
1459  ret = request_irq(imx_usb->usbd_int[i], intr_handler(i),
1460  0, driver_name, imx_usb);
1461  if (ret) {
1462  dev_err(&pdev->dev, "can't get irq %i, err %d\n",
1463  imx_usb->usbd_int[i], ret);
1464  for (--i; i >= 0; i--)
1465  free_irq(imx_usb->usbd_int[i], imx_usb);
1466  goto fail3;
1467  }
1468  }
1469 
1470  imx_usb->res = res;
1471  imx_usb->base = base;
1472  imx_usb->clk = clk;
1473  imx_usb->dev = &pdev->dev;
1474 
1475  device_initialize(&imx_usb->gadget.dev);
1476 
1477  imx_usb->gadget.dev.parent = &pdev->dev;
1478  imx_usb->gadget.dev.dma_mask = pdev->dev.dma_mask;
1479 
1480  platform_set_drvdata(pdev, imx_usb);
1481 
1482  usb_init_data(imx_usb);
1483  imx_udc_init(imx_usb);
1484 
1485  init_timer(&imx_usb->timer);
1486  imx_usb->timer.function = handle_config;
1487  imx_usb->timer.data = (unsigned long)imx_usb;
1488 
1489  ret = usb_add_gadget_udc(&pdev->dev, &imx_usb->gadget);
1490  if (ret)
1491  goto fail4;
1492 
1493  return 0;
1494 fail4:
1495  for (i = 0; i < IMX_USB_NB_EP + 1; i++)
1496  free_irq(imx_usb->usbd_int[i], imx_usb);
1497 fail3:
1498  clk_put(clk);
1499  clk_disable_unprepare(clk);
1500 fail2:
1501  iounmap(base);
1502 fail1:
1503  if (pdata->exit)
1504  pdata->exit(&pdev->dev);
1505 fail0:
1506  release_mem_region(res->start, res_size);
1507  return ret;
1508 }
1509 
1510 static int __exit imx_udc_remove(struct platform_device *pdev)
1511 {
1512  struct imx_udc_struct *imx_usb = platform_get_drvdata(pdev);
1513  struct imxusb_platform_data *pdata = pdev->dev.platform_data;
1514  int i;
1515 
1516  usb_del_gadget_udc(&imx_usb->gadget);
1517  imx_udc_disable(imx_usb);
1518  del_timer(&imx_usb->timer);
1519 
1520  for (i = 0; i < IMX_USB_NB_EP + 1; i++)
1521  free_irq(imx_usb->usbd_int[i], imx_usb);
1522 
1523  clk_put(imx_usb->clk);
1524  clk_disable_unprepare(imx_usb->clk);
1525  iounmap(imx_usb->base);
1526 
1527  release_mem_region(imx_usb->res->start, resource_size(imx_usb->res));
1528 
1529  if (pdata->exit)
1530  pdata->exit(&pdev->dev);
1531 
1532  platform_set_drvdata(pdev, NULL);
1533 
1534  return 0;
1535 }
1536 
1537 /*----------------------------------------------------------------------------*/
1538 
1539 #ifdef CONFIG_PM
1540 #define imx_udc_suspend NULL
1541 #define imx_udc_resume NULL
1542 #else
1543 #define imx_udc_suspend NULL
1544 #define imx_udc_resume NULL
1545 #endif
1546 
1547 /*----------------------------------------------------------------------------*/
1548 
1549 static struct platform_driver udc_driver = {
1550  .driver = {
1551  .name = driver_name,
1552  .owner = THIS_MODULE,
1553  },
1554  .remove = __exit_p(imx_udc_remove),
1555  .suspend = imx_udc_suspend,
1556  .resume = imx_udc_resume,
1557 };
1558 
1559 static int __init udc_init(void)
1560 {
1561  return platform_driver_probe(&udc_driver, imx_udc_probe);
1562 }
1563 module_init(udc_init);
1564 
1565 static void __exit udc_exit(void)
1566 {
1567  platform_driver_unregister(&udc_driver);
1568 }
1569 module_exit(udc_exit);
1570 
1571 MODULE_DESCRIPTION("IMX USB Device Controller driver");
1572 MODULE_AUTHOR("Darius Augulis <[email protected]>");
1573 MODULE_LICENSE("GPL");
1574 MODULE_ALIAS("platform:imx_udc");
Generated on Thu Jan 10 2013 14:36:23 for Linux Kernel by   doxygen 1.8.2