?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mm: make wait_on_page_writeback() wait for multiple pending writebacks
[linux/fpc-iii.git] / arch / arm / mach-omap1 / usb.c
blob86d3b3c157af444901d69033a7e24a82bc0addd7
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Platform level USB initialization for FS USB OTG controller on omap1
4 *
5 * Copyright (C) 2004 Texas Instruments, Inc.
6 */
7
8 #include <linux/module.h>
9 #include <linux/kernel.h>
10 #include <linux/init.h>
11 #include <linux/platform_device.h>
12 #include <linux/dma-map-ops.h>
13 #include <linux/io.h>
14
15 #include <asm/irq.h>
16
17 #include <mach/mux.h>
18
19 #include <mach/usb.h>
20
21 #include "common.h"
22
23 /* These routines should handle the standard chip-specific modes
24 * for usb0/1/2 ports, covering basic mux and transceiver setup.
25 *
26 * Some board-*.c files will need to set up additional mux options,
27 * like for suspend handling, vbus sensing, GPIOs, and the D+ pullup.
28 */
29
30 /* TESTED ON:
31 * - 1611B H2 (with usb1 mini-AB) using standard Mini-B or OTG cables
32 * - 5912 OSK OHCI (with usb0 standard-A), standard A-to-B cables
33 * - 5912 OSK UDC, with *nonstandard* A-to-A cable
34 * - 1510 Innovator UDC with bundled usb0 cable
35 * - 1510 Innovator OHCI with bundled usb1/usb2 cable
36 * - 1510 Innovator OHCI with custom usb0 cable, feeding 5V VBUS
37 * - 1710 custom development board using alternate pin group
38 * - 1710 H3 (with usb1 mini-AB) using standard Mini-B or OTG cables
39 */
40
41 #define INT_USB_IRQ_GEN IH2_BASE + 20
42 #define INT_USB_IRQ_NISO IH2_BASE + 30
43 #define INT_USB_IRQ_ISO IH2_BASE + 29
44 #define INT_USB_IRQ_HGEN INT_USB_HHC_1
45 #define INT_USB_IRQ_OTG IH2_BASE + 8
46
47 #ifdef CONFIG_ARCH_OMAP_OTG
48
49 static void __init
50 omap_otg_init(struct omap_usb_config *config)
51 {
52 u32 syscon;
53 int alt_pingroup = 0;
54 u16 w;
55
56 /* NOTE: no bus or clock setup (yet?) */
57
58 syscon = omap_readl(OTG_SYSCON_1) & 0xffff;
59 if (!(syscon & OTG_RESET_DONE))
60 pr_debug("USB resets not complete?\n");
61
62 //omap_writew(0, OTG_IRQ_EN);
63
64 /* pin muxing and transceiver pinouts */
65 if (config->pins[0] > 2) /* alt pingroup 2 */
66 alt_pingroup = 1;
67 syscon |= config->usb0_init(config->pins[0], is_usb0_device(config));
68 syscon |= config->usb1_init(config->pins[1]);
69 syscon |= config->usb2_init(config->pins[2], alt_pingroup);
70 pr_debug("OTG_SYSCON_1 = %08x\n", omap_readl(OTG_SYSCON_1));
71 omap_writel(syscon, OTG_SYSCON_1);
72
73 syscon = config->hmc_mode;
74 syscon |= USBX_SYNCHRO | (4 << 16) /* B_ASE0_BRST */;
75 #ifdef CONFIG_USB_OTG
76 if (config->otg)
77 syscon |= OTG_EN;
78 #endif
79 pr_debug("USB_TRANSCEIVER_CTRL = %03x\n",
80 omap_readl(USB_TRANSCEIVER_CTRL));
81 pr_debug("OTG_SYSCON_2 = %08x\n", omap_readl(OTG_SYSCON_2));
82 omap_writel(syscon, OTG_SYSCON_2);
83
84 printk("USB: hmc %d", config->hmc_mode);
85 if (!alt_pingroup)
86 pr_cont(", usb2 alt %d wires", config->pins[2]);
87 else if (config->pins[0])
88 pr_cont(", usb0 %d wires%s", config->pins[0],
89 is_usb0_device(config) ? " (dev)" : "");
90 if (config->pins[1])
91 pr_cont(", usb1 %d wires", config->pins[1]);
92 if (!alt_pingroup && config->pins[2])
93 pr_cont(", usb2 %d wires", config->pins[2]);
94 if (config->otg)
95 pr_cont(", Mini-AB on usb%d", config->otg - 1);
96 pr_cont("\n");
97
98 /* leave USB clocks/controllers off until needed */
99 w = omap_readw(ULPD_SOFT_REQ);
100 w &= ~SOFT_USB_CLK_REQ;
101 omap_writew(w, ULPD_SOFT_REQ);
102
103 w = omap_readw(ULPD_CLOCK_CTRL);
104 w &= ~USB_MCLK_EN;
105 w |= DIS_USB_PVCI_CLK;
106 omap_writew(w, ULPD_CLOCK_CTRL);
107
108 syscon = omap_readl(OTG_SYSCON_1);
109 syscon |= HST_IDLE_EN|DEV_IDLE_EN|OTG_IDLE_EN;
110
111 #if IS_ENABLED(CONFIG_USB_OMAP)
112 if (config->otg || config->register_dev) {
113 struct platform_device *udc_device = config->udc_device;
114 int status;
115
116 syscon &= ~DEV_IDLE_EN;
117 udc_device->dev.platform_data = config;
118 status = platform_device_register(udc_device);
119 if (status)
120 pr_debug("can't register UDC device, %d\n", status);
121 }
122 #endif
123
124 #if IS_ENABLED(CONFIG_USB_OHCI_HCD)
125 if (config->otg || config->register_host) {
126 struct platform_device *ohci_device = config->ohci_device;
127 int status;
128
129 syscon &= ~HST_IDLE_EN;
130 ohci_device->dev.platform_data = config;
131 status = platform_device_register(ohci_device);
132 if (status)
133 pr_debug("can't register OHCI device, %d\n", status);
134 }
135 #endif
136
137 #ifdef CONFIG_USB_OTG
138 if (config->otg) {
139 struct platform_device *otg_device = config->otg_device;
140 int status;
141
142 syscon &= ~OTG_IDLE_EN;
143 otg_device->dev.platform_data = config;
144 status = platform_device_register(otg_device);
145 if (status)
146 pr_debug("can't register OTG device, %d\n", status);
147 }
148 #endif
149 pr_debug("OTG_SYSCON_1 = %08x\n", omap_readl(OTG_SYSCON_1));
150 omap_writel(syscon, OTG_SYSCON_1);
151 }
152
153 #else
154 static void omap_otg_init(struct omap_usb_config *config) {}
155 #endif
156
157 #if IS_ENABLED(CONFIG_USB_OMAP)
158
159 static struct resource udc_resources[] = {
160 /* order is significant! */
161 { /* registers */
162 .start = UDC_BASE,
163 .end = UDC_BASE + 0xff,
164 .flags = IORESOURCE_MEM,
165 }, { /* general IRQ */
166 .start = INT_USB_IRQ_GEN,
167 .flags = IORESOURCE_IRQ,
168 }, { /* PIO IRQ */
169 .start = INT_USB_IRQ_NISO,
170 .flags = IORESOURCE_IRQ,
171 }, { /* SOF IRQ */
172 .start = INT_USB_IRQ_ISO,
173 .flags = IORESOURCE_IRQ,
174 },
175 };
176
177 static u64 udc_dmamask = ~(u32)0;
178
179 static struct platform_device udc_device = {
180 .name = "omap_udc",
181 .id = -1,
182 .dev = {
183 .dma_mask = &udc_dmamask,
184 .coherent_dma_mask = 0xffffffff,
185 },
186 .num_resources = ARRAY_SIZE(udc_resources),
187 .resource = udc_resources,
188 };
189
190 static inline void udc_device_init(struct omap_usb_config *pdata)
191 {
192 /* IRQ numbers for omap7xx */
193 if(cpu_is_omap7xx()) {
194 udc_resources[1].start = INT_7XX_USB_GENI;
195 udc_resources[2].start = INT_7XX_USB_NON_ISO;
196 udc_resources[3].start = INT_7XX_USB_ISO;
197 }
198 pdata->udc_device = &udc_device;
199 }
200
201 #else
202
203 static inline void udc_device_init(struct omap_usb_config *pdata)
204 {
205 }
206
207 #endif
208
209 #if IS_ENABLED(CONFIG_USB_OHCI_HCD)
210
211 /* The dmamask must be set for OHCI to work */
212 static u64 ohci_dmamask = ~(u32)0;
213
214 static struct resource ohci_resources[] = {
215 {
216 .start = OMAP_OHCI_BASE,
217 .end = OMAP_OHCI_BASE + 0xff,
218 .flags = IORESOURCE_MEM,
219 },
220 {
221 .start = INT_USB_IRQ_HGEN,
222 .flags = IORESOURCE_IRQ,
223 },
224 };
225
226 static struct platform_device ohci_device = {
227 .name = "ohci",
228 .id = -1,
229 .dev = {
230 .dma_mask = &ohci_dmamask,
231 .coherent_dma_mask = 0xffffffff,
232 },
233 .num_resources = ARRAY_SIZE(ohci_resources),
234 .resource = ohci_resources,
235 };
236
237 static inline void ohci_device_init(struct omap_usb_config *pdata)
238 {
239 if (cpu_is_omap7xx())
240 ohci_resources[1].start = INT_7XX_USB_HHC_1;
241 pdata->ohci_device = &ohci_device;
242 pdata->ocpi_enable = &ocpi_enable;
243 }
244
245 #else
246
247 static inline void ohci_device_init(struct omap_usb_config *pdata)
248 {
249 }
250
251 #endif
252
253 #if defined(CONFIG_USB_OTG) && defined(CONFIG_ARCH_OMAP_OTG)
254
255 static struct resource otg_resources[] = {
256 /* order is significant! */
257 {
258 .start = OTG_BASE,
259 .end = OTG_BASE + 0xff,
260 .flags = IORESOURCE_MEM,
261 }, {
262 .start = INT_USB_IRQ_OTG,
263 .flags = IORESOURCE_IRQ,
264 },
265 };
266
267 static struct platform_device otg_device = {
268 .name = "omap_otg",
269 .id = -1,
270 .num_resources = ARRAY_SIZE(otg_resources),
271 .resource = otg_resources,
272 };
273
274 static inline void otg_device_init(struct omap_usb_config *pdata)
275 {
276 if (cpu_is_omap7xx())
277 otg_resources[1].start = INT_7XX_USB_OTG;
278 pdata->otg_device = &otg_device;
279 }
280
281 #else
282
283 static inline void otg_device_init(struct omap_usb_config *pdata)
284 {
285 }
286
287 #endif
288
289 static u32 __init omap1_usb0_init(unsigned nwires, unsigned is_device)
290 {
291 u32 syscon1 = 0;
292
293 if (nwires == 0) {
294 if (!cpu_is_omap15xx()) {
295 u32 l;
296
297 /* pulldown D+/D- */
298 l = omap_readl(USB_TRANSCEIVER_CTRL);
299 l &= ~(3 << 1);
300 omap_writel(l, USB_TRANSCEIVER_CTRL);
301 }
302 return 0;
303 }
304
305 if (is_device) {
306 if (cpu_is_omap7xx()) {
307 omap_cfg_reg(AA17_7XX_USB_DM);
308 omap_cfg_reg(W16_7XX_USB_PU_EN);
309 omap_cfg_reg(W17_7XX_USB_VBUSI);
310 omap_cfg_reg(W18_7XX_USB_DMCK_OUT);
311 omap_cfg_reg(W19_7XX_USB_DCRST);
312 } else
313 omap_cfg_reg(W4_USB_PUEN);
314 }
315
316 if (nwires == 2) {
317 u32 l;
318
319 // omap_cfg_reg(P9_USB_DP);
320 // omap_cfg_reg(R8_USB_DM);
321
322 if (cpu_is_omap15xx()) {
323 /* This works on 1510-Innovator */
324 return 0;
325 }
326
327 /* NOTES:
328 * - peripheral should configure VBUS detection!
329 * - only peripherals may use the internal D+/D- pulldowns
330 * - OTG support on this port not yet written
331 */
332
333 /* Don't do this for omap7xx -- it causes USB to not work correctly */
334 if (!cpu_is_omap7xx()) {
335 l = omap_readl(USB_TRANSCEIVER_CTRL);
336 l &= ~(7 << 4);
337 if (!is_device)
338 l |= (3 << 1);
339 omap_writel(l, USB_TRANSCEIVER_CTRL);
340 }
341
342 return 3 << 16;
343 }
344
345 /* alternate pin config, external transceiver */
346 if (cpu_is_omap15xx()) {
347 printk(KERN_ERR "no usb0 alt pin config on 15xx\n");
348 return 0;
349 }
350
351 omap_cfg_reg(V6_USB0_TXD);
352 omap_cfg_reg(W9_USB0_TXEN);
353 omap_cfg_reg(W5_USB0_SE0);
354 if (nwires != 3)
355 omap_cfg_reg(Y5_USB0_RCV);
356
357 /* NOTE: SPEED and SUSP aren't configured here. OTG hosts
358 * may be able to use I2C requests to set those bits along
359 * with VBUS switching and overcurrent detection.
360 */
361
362 if (nwires != 6) {
363 u32 l;
364
365 l = omap_readl(USB_TRANSCEIVER_CTRL);
366 l &= ~CONF_USB2_UNI_R;
367 omap_writel(l, USB_TRANSCEIVER_CTRL);
368 }
369
370 switch (nwires) {
371 case 3:
372 syscon1 = 2;
373 break;
374 case 4:
375 syscon1 = 1;
376 break;
377 case 6:
378 syscon1 = 3;
379 {
380 u32 l;
381
382 omap_cfg_reg(AA9_USB0_VP);
383 omap_cfg_reg(R9_USB0_VM);
384 l = omap_readl(USB_TRANSCEIVER_CTRL);
385 l |= CONF_USB2_UNI_R;
386 omap_writel(l, USB_TRANSCEIVER_CTRL);
387 }
388 break;
389 default:
390 printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
391 0, nwires);
392 }
393
394 return syscon1 << 16;
395 }
396
397 static u32 __init omap1_usb1_init(unsigned nwires)
398 {
399 u32 syscon1 = 0;
400
401 if (!cpu_is_omap15xx() && nwires != 6) {
402 u32 l;
403
404 l = omap_readl(USB_TRANSCEIVER_CTRL);
405 l &= ~CONF_USB1_UNI_R;
406 omap_writel(l, USB_TRANSCEIVER_CTRL);
407 }
408 if (nwires == 0)
409 return 0;
410
411 /* external transceiver */
412 omap_cfg_reg(USB1_TXD);
413 omap_cfg_reg(USB1_TXEN);
414 if (nwires != 3)
415 omap_cfg_reg(USB1_RCV);
416
417 if (cpu_is_omap15xx()) {
418 omap_cfg_reg(USB1_SEO);
419 omap_cfg_reg(USB1_SPEED);
420 // SUSP
421 } else if (cpu_is_omap1610() || cpu_is_omap5912()) {
422 omap_cfg_reg(W13_1610_USB1_SE0);
423 omap_cfg_reg(R13_1610_USB1_SPEED);
424 // SUSP
425 } else if (cpu_is_omap1710()) {
426 omap_cfg_reg(R13_1710_USB1_SE0);
427 // SUSP
428 } else {
429 pr_debug("usb%d cpu unrecognized\n", 1);
430 return 0;
431 }
432
433 switch (nwires) {
434 case 2:
435 goto bad;
436 case 3:
437 syscon1 = 2;
438 break;
439 case 4:
440 syscon1 = 1;
441 break;
442 case 6:
443 syscon1 = 3;
444 omap_cfg_reg(USB1_VP);
445 omap_cfg_reg(USB1_VM);
446 if (!cpu_is_omap15xx()) {
447 u32 l;
448
449 l = omap_readl(USB_TRANSCEIVER_CTRL);
450 l |= CONF_USB1_UNI_R;
451 omap_writel(l, USB_TRANSCEIVER_CTRL);
452 }
453 break;
454 default:
455 bad:
456 printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
457 1, nwires);
458 }
459
460 return syscon1 << 20;
461 }
462
463 static u32 __init omap1_usb2_init(unsigned nwires, unsigned alt_pingroup)
464 {
465 u32 syscon1 = 0;
466
467 /* NOTE omap1 erratum: must leave USB2_UNI_R set if usb0 in use */
468 if (alt_pingroup || nwires == 0)
469 return 0;
470
471 if (!cpu_is_omap15xx() && nwires != 6) {
472 u32 l;
473
474 l = omap_readl(USB_TRANSCEIVER_CTRL);
475 l &= ~CONF_USB2_UNI_R;
476 omap_writel(l, USB_TRANSCEIVER_CTRL);
477 }
478
479 /* external transceiver */
480 if (cpu_is_omap15xx()) {
481 omap_cfg_reg(USB2_TXD);
482 omap_cfg_reg(USB2_TXEN);
483 omap_cfg_reg(USB2_SEO);
484 if (nwires != 3)
485 omap_cfg_reg(USB2_RCV);
486 /* there is no USB2_SPEED */
487 } else if (cpu_is_omap16xx()) {
488 omap_cfg_reg(V6_USB2_TXD);
489 omap_cfg_reg(W9_USB2_TXEN);
490 omap_cfg_reg(W5_USB2_SE0);
491 if (nwires != 3)
492 omap_cfg_reg(Y5_USB2_RCV);
493 // FIXME omap_cfg_reg(USB2_SPEED);
494 } else {
495 pr_debug("usb%d cpu unrecognized\n", 1);
496 return 0;
497 }
498
499 // omap_cfg_reg(USB2_SUSP);
500
501 switch (nwires) {
502 case 2:
503 goto bad;
504 case 3:
505 syscon1 = 2;
506 break;
507 case 4:
508 syscon1 = 1;
509 break;
510 case 5:
511 goto bad;
512 case 6:
513 syscon1 = 3;
514 if (cpu_is_omap15xx()) {
515 omap_cfg_reg(USB2_VP);
516 omap_cfg_reg(USB2_VM);
517 } else {
518 u32 l;
519
520 omap_cfg_reg(AA9_USB2_VP);
521 omap_cfg_reg(R9_USB2_VM);
522 l = omap_readl(USB_TRANSCEIVER_CTRL);
523 l |= CONF_USB2_UNI_R;
524 omap_writel(l, USB_TRANSCEIVER_CTRL);
525 }
526 break;
527 default:
528 bad:
529 printk(KERN_ERR "illegal usb%d %d-wire transceiver\n",
530 2, nwires);
531 }
532
533 return syscon1 << 24;
534 }
535
536 #ifdef CONFIG_ARCH_OMAP15XX
537
538 /* ULPD_DPLL_CTRL */
539 #define DPLL_IOB (1 << 13)
540 #define DPLL_PLL_ENABLE (1 << 4)
541 #define DPLL_LOCK (1 << 0)
542
543 /* ULPD_APLL_CTRL */
544 #define APLL_NDPLL_SWITCH (1 << 0)
545
546 static int omap_1510_usb_ohci_notifier(struct notifier_block *nb,
547 unsigned long event, void *data)
548 {
549 struct device *dev = data;
550
551 if (event != BUS_NOTIFY_ADD_DEVICE)
552 return NOTIFY_DONE;
553
554 if (strncmp(dev_name(dev), "ohci", 4) == 0 &&
555 dma_direct_set_offset(dev, PHYS_OFFSET, OMAP1510_LB_OFFSET,
556 (u64)-1))
557 WARN_ONCE(1, "failed to set DMA offset\n");
558 return NOTIFY_OK;
559 }
560
561 static struct notifier_block omap_1510_usb_ohci_nb = {
562 .notifier_call = omap_1510_usb_ohci_notifier,
563 };
564
565 static void __init omap_1510_usb_init(struct omap_usb_config *config)
566 {
567 unsigned int val;
568 u16 w;
569
570 config->usb0_init(config->pins[0], is_usb0_device(config));
571 config->usb1_init(config->pins[1]);
572 config->usb2_init(config->pins[2], 0);
573
574 val = omap_readl(MOD_CONF_CTRL_0) & ~(0x3f << 1);
575 val |= (config->hmc_mode << 1);
576 omap_writel(val, MOD_CONF_CTRL_0);
577
578 printk("USB: hmc %d", config->hmc_mode);
579 if (config->pins[0])
580 pr_cont(", usb0 %d wires%s", config->pins[0],
581 is_usb0_device(config) ? " (dev)" : "");
582 if (config->pins[1])
583 pr_cont(", usb1 %d wires", config->pins[1]);
584 if (config->pins[2])
585 pr_cont(", usb2 %d wires", config->pins[2]);
586 pr_cont("\n");
587
588 /* use DPLL for 48 MHz function clock */
589 pr_debug("APLL %04x DPLL %04x REQ %04x\n", omap_readw(ULPD_APLL_CTRL),
590 omap_readw(ULPD_DPLL_CTRL), omap_readw(ULPD_SOFT_REQ));
591
592 w = omap_readw(ULPD_APLL_CTRL);
593 w &= ~APLL_NDPLL_SWITCH;
594 omap_writew(w, ULPD_APLL_CTRL);
595
596 w = omap_readw(ULPD_DPLL_CTRL);
597 w |= DPLL_IOB | DPLL_PLL_ENABLE;
598 omap_writew(w, ULPD_DPLL_CTRL);
599
600 w = omap_readw(ULPD_SOFT_REQ);
601 w |= SOFT_UDC_REQ | SOFT_DPLL_REQ;
602 omap_writew(w, ULPD_SOFT_REQ);
603
604 while (!(omap_readw(ULPD_DPLL_CTRL) & DPLL_LOCK))
605 cpu_relax();
606
607 #if IS_ENABLED(CONFIG_USB_OMAP)
608 if (config->register_dev) {
609 int status;
610
611 udc_device.dev.platform_data = config;
612 status = platform_device_register(&udc_device);
613 if (status)
614 pr_debug("can't register UDC device, %d\n", status);
615 /* udc driver gates 48MHz by D+ pullup */
616 }
617 #endif
618
619 #if IS_ENABLED(CONFIG_USB_OHCI_HCD)
620 if (config->register_host) {
621 int status;
622
623 bus_register_notifier(&platform_bus_type,
624 &omap_1510_usb_ohci_nb);
625 ohci_device.dev.platform_data = config;
626 status = platform_device_register(&ohci_device);
627 if (status)
628 pr_debug("can't register OHCI device, %d\n", status);
629 /* hcd explicitly gates 48MHz */
630 }
631 #endif
632 }
633
634 #else
635 static inline void omap_1510_usb_init(struct omap_usb_config *config) {}
636 #endif
637
638 void __init omap1_usb_init(struct omap_usb_config *_pdata)
639 {
640 struct omap_usb_config *pdata;
641
642 pdata = kmemdup(_pdata, sizeof(*pdata), GFP_KERNEL);
643 if (!pdata)
644 return;
645
646 pdata->usb0_init = omap1_usb0_init;
647 pdata->usb1_init = omap1_usb1_init;
648 pdata->usb2_init = omap1_usb2_init;
649 udc_device_init(pdata);
650 ohci_device_init(pdata);
651 otg_device_init(pdata);
652
653 if (cpu_is_omap7xx() || cpu_is_omap16xx())
654 omap_otg_init(pdata);
655 else if (cpu_is_omap15xx())
656 omap_1510_usb_init(pdata);
657 else
658 printk(KERN_ERR "USB: No init for your chip yet\n");
659 }
Linux with added FPC-III support