Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
usb.c
Go to the documentation of this file.
1 /*
2  * Platform level USB initialization for FS USB OTG controller on omap1 and 24xx
3  *
4  * Copyright (C) 2004 Texas Instruments, Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  */
20 
21 #include <linux/module.h>
22 #include <linux/kernel.h>
23 #include <linux/init.h>
24 #include <linux/platform_device.h>
25 #include <linux/io.h>
26 
27 #include <asm/irq.h>
28 
29 #include <mach/mux.h>
30 
31 #include <mach/usb.h>
32 
33 #include "common.h"
34 
35 /* These routines should handle the standard chip-specific modes
36  * for usb0/1/2 ports, covering basic mux and transceiver setup.
37  *
38  * Some board-*.c files will need to set up additional mux options,
39  * like for suspend handling, vbus sensing, GPIOs, and the D+ pullup.
40  */
41 
42 /* TESTED ON:
43  * - 1611B H2 (with usb1 mini-AB) using standard Mini-B or OTG cables
44  * - 5912 OSK OHCI (with usb0 standard-A), standard A-to-B cables
45  * - 5912 OSK UDC, with *nonstandard* A-to-A cable
46  * - 1510 Innovator UDC with bundled usb0 cable
47  * - 1510 Innovator OHCI with bundled usb1/usb2 cable
48  * - 1510 Innovator OHCI with custom usb0 cable, feeding 5V VBUS
49  * - 1710 custom development board using alternate pin group
50  * - 1710 H3 (with usb1 mini-AB) using standard Mini-B or OTG cables
51  */
52 
53 #define INT_USB_IRQ_GEN IH2_BASE + 20
54 #define INT_USB_IRQ_NISO IH2_BASE + 30
55 #define INT_USB_IRQ_ISO IH2_BASE + 29
56 #define INT_USB_IRQ_HGEN INT_USB_HHC_1
57 #define INT_USB_IRQ_OTG IH2_BASE + 8
58 
59 #ifdef CONFIG_ARCH_OMAP_OTG
60 
61 void __init
63 {
64  u32 syscon;
65  int alt_pingroup = 0;
66 
67  /* NOTE: no bus or clock setup (yet?) */
68 
69  syscon = omap_readl(OTG_SYSCON_1) & 0xffff;
70  if (!(syscon & OTG_RESET_DONE))
71  pr_debug("USB resets not complete?\n");
72 
73  //omap_writew(0, OTG_IRQ_EN);
74 
75  /* pin muxing and transceiver pinouts */
76  if (config->pins[0] > 2) /* alt pingroup 2 */
77  alt_pingroup = 1;
78  syscon |= config->usb0_init(config->pins[0], is_usb0_device(config));
79  syscon |= config->usb1_init(config->pins[1]);
80  syscon |= config->usb2_init(config->pins[2], alt_pingroup);
81  pr_debug("OTG_SYSCON_1 = %08x\n", omap_readl(OTG_SYSCON_1));
82  omap_writel(syscon, OTG_SYSCON_1);
83 
84  syscon = config->hmc_mode;
85  syscon |= USBX_SYNCHRO | (4 << 16) /* B_ASE0_BRST */;
86 #ifdef CONFIG_USB_OTG
87  if (config->otg)
88  syscon |= OTG_EN;
89 #endif
90  if (cpu_class_is_omap1())
91  pr_debug("USB_TRANSCEIVER_CTRL = %03x\n",
93  pr_debug("OTG_SYSCON_2 = %08x\n", omap_readl(OTG_SYSCON_2));
94  omap_writel(syscon, OTG_SYSCON_2);
95 
96  printk("USB: hmc %d", config->hmc_mode);
97  if (!alt_pingroup)
98  printk(", usb2 alt %d wires", config->pins[2]);
99  else if (config->pins[0])
100  printk(", usb0 %d wires%s", config->pins[0],
101  is_usb0_device(config) ? " (dev)" : "");
102  if (config->pins[1])
103  printk(", usb1 %d wires", config->pins[1]);
104  if (!alt_pingroup && config->pins[2])
105  printk(", usb2 %d wires", config->pins[2]);
106  if (config->otg)
107  printk(", Mini-AB on usb%d", config->otg - 1);
108  printk("\n");
109 
110  if (cpu_class_is_omap1()) {
111  u16 w;
112 
113  /* leave USB clocks/controllers off until needed */
115  w &= ~SOFT_USB_CLK_REQ;
117 
119  w &= ~USB_MCLK_EN;
120  w |= DIS_USB_PVCI_CLK;
122  }
123  syscon = omap_readl(OTG_SYSCON_1);
125 
126 #ifdef CONFIG_USB_GADGET_OMAP
127  if (config->otg || config->register_dev) {
128  struct platform_device *udc_device = config->udc_device;
129  int status;
130 
131  syscon &= ~DEV_IDLE_EN;
132  udc_device->dev.platform_data = config;
133  status = platform_device_register(udc_device);
134  if (status)
135  pr_debug("can't register UDC device, %d\n", status);
136  }
137 #endif
138 
139 #if defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
140  if (config->otg || config->register_host) {
141  struct platform_device *ohci_device = config->ohci_device;
142  int status;
143 
144  syscon &= ~HST_IDLE_EN;
145  ohci_device->dev.platform_data = config;
146  status = platform_device_register(ohci_device);
147  if (status)
148  pr_debug("can't register OHCI device, %d\n", status);
149  }
150 #endif
151 
152 #ifdef CONFIG_USB_OTG
153  if (config->otg) {
154  struct platform_device *otg_device = config->otg_device;
155  int status;
156 
157  syscon &= ~OTG_IDLE_EN;
158  otg_device->dev.platform_data = config;
159  status = platform_device_register(otg_device);
160  if (status)
161  pr_debug("can't register OTG device, %d\n", status);
162  }
163 #endif
164  pr_debug("OTG_SYSCON_1 = %08x\n", omap_readl(OTG_SYSCON_1));
165  omap_writel(syscon, OTG_SYSCON_1);
166 }
167 
168 #else
170 #endif
171 
172 #ifdef CONFIG_USB_GADGET_OMAP
173 
174 static struct resource udc_resources[] = {
175  /* order is significant! */
176  { /* registers */
177  .start = UDC_BASE,
178  .end = UDC_BASE + 0xff,
179  .flags = IORESOURCE_MEM,
180  }, { /* general IRQ */
181  .start = INT_USB_IRQ_GEN,
182  .flags = IORESOURCE_IRQ,
183  }, { /* PIO IRQ */
184  .start = INT_USB_IRQ_NISO,
185  .flags = IORESOURCE_IRQ,
186  }, { /* SOF IRQ */
187  .start = INT_USB_IRQ_ISO,
188  .flags = IORESOURCE_IRQ,
189  },
190 };
191 
192 static u64 udc_dmamask = ~(u32)0;
193 
194 static struct platform_device udc_device = {
195  .name = "omap_udc",
196  .id = -1,
197  .dev = {
198  .dma_mask = &udc_dmamask,
199  .coherent_dma_mask = 0xffffffff,
200  },
201  .num_resources = ARRAY_SIZE(udc_resources),
202  .resource = udc_resources,
203 };
204 
205 static inline void udc_device_init(struct omap_usb_config *pdata)
206 {
207  /* IRQ numbers for omap7xx */
208  if(cpu_is_omap7xx()) {
209  udc_resources[1].start = INT_7XX_USB_GENI;
210  udc_resources[2].start = INT_7XX_USB_NON_ISO;
211  udc_resources[3].start = INT_7XX_USB_ISO;
212  }
213  pdata->udc_device = &udc_device;
214 }
215 
216 #else
217 
218 static inline void udc_device_init(struct omap_usb_config *pdata)
219 {
220 }
221 
222 #endif
223 
224 #if defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
225 
226 /* The dmamask must be set for OHCI to work */
227 static u64 ohci_dmamask = ~(u32)0;
228 
229 static struct resource ohci_resources[] = {
230  {
232  .end = OMAP_OHCI_BASE + 0xff,
233  .flags = IORESOURCE_MEM,
234  },
235  {
236  .start = INT_USB_IRQ_HGEN,
237  .flags = IORESOURCE_IRQ,
238  },
239 };
240 
241 static struct platform_device ohci_device = {
242  .name = "ohci",
243  .id = -1,
244  .dev = {
245  .dma_mask = &ohci_dmamask,
246  .coherent_dma_mask = 0xffffffff,
247  },
248  .num_resources = ARRAY_SIZE(ohci_resources),
249  .resource = ohci_resources,
250 };
251 
252 static inline void ohci_device_init(struct omap_usb_config *pdata)
253 {
254  if (cpu_is_omap7xx())
255  ohci_resources[1].start = INT_7XX_USB_HHC_1;
256  pdata->ohci_device = &ohci_device;
257  pdata->ocpi_enable = &ocpi_enable;
258 }
259 
260 #else
261 
262 static inline void ohci_device_init(struct omap_usb_config *pdata)
263 {
264 }
265 
266 #endif
267 
268 #if defined(CONFIG_USB_OTG) && defined(CONFIG_ARCH_OMAP_OTG)
269 
270 static struct resource otg_resources[] = {
271  /* order is significant! */
272  {
273  .start = OTG_BASE,
274  .end = OTG_BASE + 0xff,
275  .flags = IORESOURCE_MEM,
276  }, {
277  .start = INT_USB_IRQ_OTG,
278  .flags = IORESOURCE_IRQ,
279  },
280 };
281 
282 static struct platform_device otg_device = {
283  .name = "omap_otg",
284  .id = -1,
285  .num_resources = ARRAY_SIZE(otg_resources),
286  .resource = otg_resources,
287 };
288 
289 static inline void otg_device_init(struct omap_usb_config *pdata)
290 {
291  if (cpu_is_omap7xx())
292  otg_resources[1].start = INT_7XX_USB_OTG;
293  pdata->otg_device = &otg_device;
294 }
295 
296 #else
297 
298 static inline void otg_device_init(struct omap_usb_config *pdata)
299 {
300 }
301 
302 #endif
303 
304 u32 __init omap1_usb0_init(unsigned nwires, unsigned is_device)
305 {
306  u32 syscon1 = 0;
307 
308  if (nwires == 0) {
309  if (!cpu_is_omap15xx()) {
310  u32 l;
311 
312  /* pulldown D+/D- */
314  l &= ~(3 << 1);
316  }
317  return 0;
318  }
319 
320  if (is_device) {
321  if (cpu_is_omap7xx()) {
327  } else
329  }
330 
331  if (nwires == 2) {
332  u32 l;
333 
334  // omap_cfg_reg(P9_USB_DP);
335  // omap_cfg_reg(R8_USB_DM);
336 
337  if (cpu_is_omap15xx()) {
338  /* This works on 1510-Innovator */
339  return 0;
340  }
341 
342  /* NOTES:
343  * - peripheral should configure VBUS detection!
344  * - only peripherals may use the internal D+/D- pulldowns
345  * - OTG support on this port not yet written
346  */
347 
348  /* Don't do this for omap7xx -- it causes USB to not work correctly */
349  if (!cpu_is_omap7xx()) {
351  l &= ~(7 << 4);
352  if (!is_device)
353  l |= (3 << 1);
355  }
356 
357  return 3 << 16;
358  }
359 
360  /* alternate pin config, external transceiver */
361  if (cpu_is_omap15xx()) {
362  printk(KERN_ERR "no usb0 alt pin config on 15xx\n");
363  return 0;
364  }
365 
369  if (nwires != 3)
371 
372  /* NOTE: SPEED and SUSP aren't configured here. OTG hosts
373  * may be able to use I2C requests to set those bits along
374  * with VBUS switching and overcurrent detection.
375  */
376 
377  if (nwires != 6) {
378  u32 l;
379 
381  l &= ~CONF_USB2_UNI_R;
383  }
384 
385  switch (nwires) {
386  case 3:
387  syscon1 = 2;
388  break;
389  case 4:
390  syscon1 = 1;
391  break;
392  case 6:
393  syscon1 = 3;
394  {
395  u32 l;
396 
400  l |= CONF_USB2_UNI_R;
402  }
403  break;
404  default:
405  printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
406  0, nwires);
407  }
408 
409  return syscon1 << 16;
410 }
411 
412 u32 __init omap1_usb1_init(unsigned nwires)
413 {
414  u32 syscon1 = 0;
415 
416  if (!cpu_is_omap15xx() && nwires != 6) {
417  u32 l;
418 
420  l &= ~CONF_USB1_UNI_R;
422  }
423  if (nwires == 0)
424  return 0;
425 
426  /* external transceiver */
429  if (nwires != 3)
431 
432  if (cpu_is_omap15xx()) {
435  // SUSP
436  } else if (cpu_is_omap1610() || cpu_is_omap5912()) {
439  // SUSP
440  } else if (cpu_is_omap1710()) {
442  // SUSP
443  } else {
444  pr_debug("usb%d cpu unrecognized\n", 1);
445  return 0;
446  }
447 
448  switch (nwires) {
449  case 2:
450  goto bad;
451  case 3:
452  syscon1 = 2;
453  break;
454  case 4:
455  syscon1 = 1;
456  break;
457  case 6:
458  syscon1 = 3;
461  if (!cpu_is_omap15xx()) {
462  u32 l;
463 
465  l |= CONF_USB1_UNI_R;
467  }
468  break;
469  default:
470 bad:
471  printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
472  1, nwires);
473  }
474 
475  return syscon1 << 20;
476 }
477 
478 u32 __init omap1_usb2_init(unsigned nwires, unsigned alt_pingroup)
479 {
480  u32 syscon1 = 0;
481 
482  /* NOTE omap1 erratum: must leave USB2_UNI_R set if usb0 in use */
483  if (alt_pingroup || nwires == 0)
484  return 0;
485 
486  if (!cpu_is_omap15xx() && nwires != 6) {
487  u32 l;
488 
490  l &= ~CONF_USB2_UNI_R;
492  }
493 
494  /* external transceiver */
495  if (cpu_is_omap15xx()) {
499  if (nwires != 3)
501  /* there is no USB2_SPEED */
502  } else if (cpu_is_omap16xx()) {
506  if (nwires != 3)
508  // FIXME omap_cfg_reg(USB2_SPEED);
509  } else {
510  pr_debug("usb%d cpu unrecognized\n", 1);
511  return 0;
512  }
513 
514  // omap_cfg_reg(USB2_SUSP);
515 
516  switch (nwires) {
517  case 2:
518  goto bad;
519  case 3:
520  syscon1 = 2;
521  break;
522  case 4:
523  syscon1 = 1;
524  break;
525  case 5:
526  goto bad;
527  case 6:
528  syscon1 = 3;
529  if (cpu_is_omap15xx()) {
532  } else {
533  u32 l;
534 
538  l |= CONF_USB2_UNI_R;
540  }
541  break;
542  default:
543 bad:
544  printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
545  2, nwires);
546  }
547 
548  return syscon1 << 24;
549 }
550 
551 #ifdef CONFIG_ARCH_OMAP15XX
552 
553 /* ULPD_DPLL_CTRL */
554 #define DPLL_IOB (1 << 13)
555 #define DPLL_PLL_ENABLE (1 << 4)
556 #define DPLL_LOCK (1 << 0)
557 
558 /* ULPD_APLL_CTRL */
559 #define APLL_NDPLL_SWITCH (1 << 0)
560 
561 static void __init omap_1510_usb_init(struct omap_usb_config *config)
562 {
563  unsigned int val;
564  u16 w;
565 
566  config->usb0_init(config->pins[0], is_usb0_device(config));
567  config->usb1_init(config->pins[1]);
568  config->usb2_init(config->pins[2], 0);
569 
570  val = omap_readl(MOD_CONF_CTRL_0) & ~(0x3f << 1);
571  val |= (config->hmc_mode << 1);
573 
574  printk("USB: hmc %d", config->hmc_mode);
575  if (config->pins[0])
576  printk(", usb0 %d wires%s", config->pins[0],
577  is_usb0_device(config) ? " (dev)" : "");
578  if (config->pins[1])
579  printk(", usb1 %d wires", config->pins[1]);
580  if (config->pins[2])
581  printk(", usb2 %d wires", config->pins[2]);
582  printk("\n");
583 
584  /* use DPLL for 48 MHz function clock */
585  pr_debug("APLL %04x DPLL %04x REQ %04x\n", omap_readw(ULPD_APLL_CTRL),
587 
589  w &= ~APLL_NDPLL_SWITCH;
591 
593  w |= DPLL_IOB | DPLL_PLL_ENABLE;
595 
599 
600  while (!(omap_readw(ULPD_DPLL_CTRL) & DPLL_LOCK))
601  cpu_relax();
602 
603 #ifdef CONFIG_USB_GADGET_OMAP
604  if (config->register_dev) {
605  int status;
606 
607  udc_device.dev.platform_data = config;
608  status = platform_device_register(&udc_device);
609  if (status)
610  pr_debug("can't register UDC device, %d\n", status);
611  /* udc driver gates 48MHz by D+ pullup */
612  }
613 #endif
614 
615 #if defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
616  if (config->register_host) {
617  int status;
618 
619  ohci_device.dev.platform_data = config;
620  status = platform_device_register(&ohci_device);
621  if (status)
622  pr_debug("can't register OHCI device, %d\n", status);
623  /* hcd explicitly gates 48MHz */
624  }
625 #endif
626 }
627 
628 #else
629 static inline void omap_1510_usb_init(struct omap_usb_config *config) {}
630 #endif
631 
633 {
634  pdata->usb0_init = omap1_usb0_init;
635  pdata->usb1_init = omap1_usb1_init;
636  pdata->usb2_init = omap1_usb2_init;
637  udc_device_init(pdata);
638  ohci_device_init(pdata);
639  otg_device_init(pdata);
640 
641  if (cpu_is_omap7xx() || cpu_is_omap16xx())
642  omap_otg_init(pdata);
643  else if (cpu_is_omap15xx())
644  omap_1510_usb_init(pdata);
645  else
646  printk(KERN_ERR "USB: No init for your chip yet\n");
647 }