1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/module.h>
25#include <linux/kernel.h>
26#include <linux/sched.h>
27#include <linux/init.h>
28#include <linux/list.h>
29#include <linux/delay.h>
30#include <linux/clk.h>
31#include <linux/err.h>
32#include <linux/io.h>
33#include <linux/gpio.h>
34#include <linux/platform_device.h>
35#include <linux/dma-mapping.h>
36#include <linux/usb/nop-usb-xceiv.h>
37
38#include <mach/cputype.h>
39#include <mach/hardware.h>
40
41#include <asm/mach-types.h>
42
43#include "musb_core.h"
44
45#ifdef CONFIG_MACH_DAVINCI_EVM
46#define GPIO_nVBUS_DRV 160
47#endif
48
49#include "davinci.h"
50#include "cppi_dma.h"
51
52
53#define USB_PHY_CTRL IO_ADDRESS(USBPHY_CTL_PADDR)
54#define DM355_DEEPSLEEP IO_ADDRESS(DM355_DEEPSLEEP_PADDR)
55
56struct davinci_glue {
57 struct device *dev;
58 struct platform_device *musb;
59 struct clk *clk;
60};
61
62
63
64
65
66
67
68static inline void phy_on(void)
69{
70 u32 phy_ctrl = __raw_readl(USB_PHY_CTRL);
71
72
73 phy_ctrl &= ~(USBPHY_OSCPDWN | USBPHY_OTGPDWN | USBPHY_PHYPDWN);
74 phy_ctrl |= USBPHY_SESNDEN | USBPHY_VBDTCTEN | USBPHY_PHYPLLON;
75 __raw_writel(phy_ctrl, USB_PHY_CTRL);
76
77
78 while ((__raw_readl(USB_PHY_CTRL) & USBPHY_PHYCLKGD) == 0)
79 cpu_relax();
80}
81
82static inline void phy_off(void)
83{
84 u32 phy_ctrl = __raw_readl(USB_PHY_CTRL);
85
86
87 phy_ctrl &= ~(USBPHY_SESNDEN | USBPHY_VBDTCTEN | USBPHY_PHYPLLON);
88 phy_ctrl |= USBPHY_OSCPDWN | USBPHY_OTGPDWN | USBPHY_PHYPDWN;
89 __raw_writel(phy_ctrl, USB_PHY_CTRL);
90}
91
92static int dma_off = 1;
93
94static void davinci_musb_enable(struct musb *musb)
95{
96 u32 tmp, old, val;
97
98
99 tmp = (musb->epmask & DAVINCI_USB_TX_ENDPTS_MASK)
100 << DAVINCI_USB_TXINT_SHIFT;
101 musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_SET_REG, tmp);
102 old = tmp;
103 tmp = (musb->epmask & (0xfffe & DAVINCI_USB_RX_ENDPTS_MASK))
104 << DAVINCI_USB_RXINT_SHIFT;
105 musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_SET_REG, tmp);
106 tmp |= old;
107
108 val = ~MUSB_INTR_SOF;
109 tmp |= ((val & 0x01ff) << DAVINCI_USB_USBINT_SHIFT);
110 musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_SET_REG, tmp);
111
112 if (is_dma_capable() && !dma_off)
113 printk(KERN_WARNING "%s %s: dma not reactivated\n",
114 __FILE__, __func__);
115 else
116 dma_off = 0;
117
118
119 musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
120 DAVINCI_INTR_DRVVBUS << DAVINCI_USB_USBINT_SHIFT);
121}
122
123
124
125
126static void davinci_musb_disable(struct musb *musb)
127{
128
129
130
131
132
133 musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_CLR_REG,
134 DAVINCI_USB_USBINT_MASK
135 | DAVINCI_USB_TXINT_MASK
136 | DAVINCI_USB_RXINT_MASK);
137 musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
138 musb_writel(musb->ctrl_base, DAVINCI_USB_EOI_REG, 0);
139
140 if (is_dma_capable() && !dma_off)
141 WARNING("dma still active\n");
142}
143
144
145#define portstate(stmt) stmt
146
147
148
149
150
151
152
153
154
155
156#ifdef CONFIG_MACH_DAVINCI_EVM
157
158static int vbus_state = -1;
159
160
161
162
163
164static void evm_deferred_drvvbus(struct work_struct *ignored)
165{
166 gpio_set_value_cansleep(GPIO_nVBUS_DRV, vbus_state);
167 vbus_state = !vbus_state;
168}
169
170#endif
171
172static void davinci_musb_source_power(struct musb *musb, int is_on, int immediate)
173{
174#ifdef CONFIG_MACH_DAVINCI_EVM
175 if (is_on)
176 is_on = 1;
177
178 if (vbus_state == is_on)
179 return;
180 vbus_state = !is_on;
181
182 if (machine_is_davinci_evm()) {
183 static DECLARE_WORK(evm_vbus_work, evm_deferred_drvvbus);
184
185 if (immediate)
186 gpio_set_value_cansleep(GPIO_nVBUS_DRV, vbus_state);
187 else
188 schedule_work(&evm_vbus_work);
189 }
190 if (immediate)
191 vbus_state = is_on;
192#endif
193}
194
195static void davinci_musb_set_vbus(struct musb *musb, int is_on)
196{
197 WARN_ON(is_on && is_peripheral_active(musb));
198 davinci_musb_source_power(musb, is_on, 0);
199}
200
201
202#define POLL_SECONDS 2
203
204static struct timer_list otg_workaround;
205
206static void otg_timer(unsigned long _musb)
207{
208 struct musb *musb = (void *)_musb;
209 void __iomem *mregs = musb->mregs;
210 u8 devctl;
211 unsigned long flags;
212
213
214
215
216 devctl = musb_readb(mregs, MUSB_DEVCTL);
217 dev_dbg(musb->controller, "poll devctl %02x (%s)\n", devctl,
218 usb_otg_state_string(musb->xceiv->state));
219
220 spin_lock_irqsave(&musb->lock, flags);
221 switch (musb->xceiv->state) {
222 case OTG_STATE_A_WAIT_VFALL:
223
224
225
226
227
228 if (devctl & MUSB_DEVCTL_VBUS) {
229 mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
230 break;
231 }
232 musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
233 musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
234 MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT);
235 break;
236 case OTG_STATE_B_IDLE:
237
238
239
240
241
242
243
244
245
246
247
248
249 musb_writeb(mregs, MUSB_DEVCTL,
250 devctl | MUSB_DEVCTL_SESSION);
251 devctl = musb_readb(mregs, MUSB_DEVCTL);
252 if (devctl & MUSB_DEVCTL_BDEVICE)
253 mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
254 else
255 musb->xceiv->state = OTG_STATE_A_IDLE;
256 break;
257 default:
258 break;
259 }
260 spin_unlock_irqrestore(&musb->lock, flags);
261}
262
263static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
264{
265 unsigned long flags;
266 irqreturn_t retval = IRQ_NONE;
267 struct musb *musb = __hci;
268 struct usb_otg *otg = musb->xceiv->otg;
269 void __iomem *tibase = musb->ctrl_base;
270 struct cppi *cppi;
271 u32 tmp;
272
273 spin_lock_irqsave(&musb->lock, flags);
274
275
276
277
278
279
280
281
282
283
284
285
286
287 cppi = container_of(musb->dma_controller, struct cppi, controller);
288 if (is_cppi_enabled() && musb->dma_controller && !cppi->irq)
289 retval = cppi_interrupt(irq, __hci);
290
291
292 tmp = musb_readl(tibase, DAVINCI_USB_INT_SRC_MASKED_REG);
293 musb_writel(tibase, DAVINCI_USB_INT_SRC_CLR_REG, tmp);
294 dev_dbg(musb->controller, "IRQ %08x\n", tmp);
295
296 musb->int_rx = (tmp & DAVINCI_USB_RXINT_MASK)
297 >> DAVINCI_USB_RXINT_SHIFT;
298 musb->int_tx = (tmp & DAVINCI_USB_TXINT_MASK)
299 >> DAVINCI_USB_TXINT_SHIFT;
300 musb->int_usb = (tmp & DAVINCI_USB_USBINT_MASK)
301 >> DAVINCI_USB_USBINT_SHIFT;
302
303
304
305
306
307
308
309
310 if (tmp & (DAVINCI_INTR_DRVVBUS << DAVINCI_USB_USBINT_SHIFT)) {
311 int drvvbus = musb_readl(tibase, DAVINCI_USB_STAT_REG);
312 void __iomem *mregs = musb->mregs;
313 u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
314 int err = musb->int_usb & MUSB_INTR_VBUSERROR;
315
316 err = musb->int_usb & MUSB_INTR_VBUSERROR;
317 if (err) {
318
319
320
321
322
323
324
325
326
327
328 musb->int_usb &= ~MUSB_INTR_VBUSERROR;
329 musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
330 mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
331 WARNING("VBUS error workaround (delay coming)\n");
332 } else if (drvvbus) {
333 MUSB_HST_MODE(musb);
334 otg->default_a = 1;
335 musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
336 portstate(musb->port1_status |= USB_PORT_STAT_POWER);
337 del_timer(&otg_workaround);
338 } else {
339 musb->is_active = 0;
340 MUSB_DEV_MODE(musb);
341 otg->default_a = 0;
342 musb->xceiv->state = OTG_STATE_B_IDLE;
343 portstate(musb->port1_status &= ~USB_PORT_STAT_POWER);
344 }
345
346
347
348
349 davinci_musb_source_power(musb, drvvbus, 0);
350 dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",
351 drvvbus ? "on" : "off",
352 usb_otg_state_string(musb->xceiv->state),
353 err ? " ERROR" : "",
354 devctl);
355 retval = IRQ_HANDLED;
356 }
357
358 if (musb->int_tx || musb->int_rx || musb->int_usb)
359 retval |= musb_interrupt(musb);
360
361
362 musb_writel(tibase, DAVINCI_USB_EOI_REG, 0);
363
364
365 if (musb->xceiv->state == OTG_STATE_B_IDLE)
366 mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
367
368 spin_unlock_irqrestore(&musb->lock, flags);
369
370 return retval;
371}
372
373static int davinci_musb_set_mode(struct musb *musb, u8 mode)
374{
375
376 return -EIO;
377}
378
379static int davinci_musb_init(struct musb *musb)
380{
381 void __iomem *tibase = musb->ctrl_base;
382 u32 revision;
383 int ret = -ENODEV;
384
385 usb_nop_xceiv_register();
386 musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
387 if (IS_ERR_OR_NULL(musb->xceiv)) {
388 ret = -EPROBE_DEFER;
389 goto unregister;
390 }
391
392 musb->mregs += DAVINCI_BASE_OFFSET;
393
394
395 revision = musb_readl(tibase, DAVINCI_USB_VERSION_REG);
396 if (revision == 0)
397 goto fail;
398
399 setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
400
401 davinci_musb_source_power(musb, 0, 1);
402
403
404
405
406 if (machine_is_davinci_dm355_evm()) {
407 u32 phy_ctrl = __raw_readl(USB_PHY_CTRL);
408
409 phy_ctrl &= ~(3 << 9);
410 phy_ctrl |= USBPHY_DATAPOL;
411 __raw_writel(phy_ctrl, USB_PHY_CTRL);
412 }
413
414
415
416
417 if (cpu_is_davinci_dm355()) {
418 u32 deepsleep = __raw_readl(DM355_DEEPSLEEP);
419
420 deepsleep &= ~DRVVBUS_FORCE;
421 __raw_writel(deepsleep, DM355_DEEPSLEEP);
422 }
423
424
425 musb_writel(tibase, DAVINCI_USB_CTRL_REG, 0x1);
426
427
428 phy_on();
429
430 msleep(5);
431
432
433 pr_debug("DaVinci OTG revision %08x phy %03x control %02x\n",
434 revision, __raw_readl(USB_PHY_CTRL),
435 musb_readb(tibase, DAVINCI_USB_CTRL_REG));
436
437 musb->isr = davinci_musb_interrupt;
438 return 0;
439
440fail:
441 usb_put_phy(musb->xceiv);
442unregister:
443 usb_nop_xceiv_unregister();
444 return ret;
445}
446
447static int davinci_musb_exit(struct musb *musb)
448{
449 del_timer_sync(&otg_workaround);
450
451
452 if (cpu_is_davinci_dm355()) {
453 u32 deepsleep = __raw_readl(DM355_DEEPSLEEP);
454
455 deepsleep &= ~DRVVBUS_FORCE;
456 deepsleep |= DRVVBUS_OVERRIDE;
457 __raw_writel(deepsleep, DM355_DEEPSLEEP);
458 }
459
460 davinci_musb_source_power(musb, 0 , 1);
461
462
463 if (musb->xceiv->otg->default_a) {
464 int maxdelay = 30;
465 u8 devctl, warn = 0;
466
467
468
469
470 do {
471 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
472 if (!(devctl & MUSB_DEVCTL_VBUS))
473 break;
474 if ((devctl & MUSB_DEVCTL_VBUS) != warn) {
475 warn = devctl & MUSB_DEVCTL_VBUS;
476 dev_dbg(musb->controller, "VBUS %d\n",
477 warn >> MUSB_DEVCTL_VBUS_SHIFT);
478 }
479 msleep(1000);
480 maxdelay--;
481 } while (maxdelay > 0);
482
483
484 if (devctl & MUSB_DEVCTL_VBUS)
485 dev_dbg(musb->controller, "VBUS off timeout (devctl %02x)\n", devctl);
486 }
487
488 phy_off();
489
490 usb_put_phy(musb->xceiv);
491 usb_nop_xceiv_unregister();
492
493 return 0;
494}
495
496static const struct musb_platform_ops davinci_ops = {
497 .init = davinci_musb_init,
498 .exit = davinci_musb_exit,
499
500 .enable = davinci_musb_enable,
501 .disable = davinci_musb_disable,
502
503 .set_mode = davinci_musb_set_mode,
504
505 .set_vbus = davinci_musb_set_vbus,
506};
507
508static u64 davinci_dmamask = DMA_BIT_MASK(32);
509
510static int davinci_probe(struct platform_device *pdev)
511{
512 struct resource musb_resources[2];
513 struct musb_hdrc_platform_data *pdata = pdev->dev.platform_data;
514 struct platform_device *musb;
515 struct davinci_glue *glue;
516 struct clk *clk;
517
518 int ret = -ENOMEM;
519
520 glue = kzalloc(sizeof(*glue), GFP_KERNEL);
521 if (!glue) {
522 dev_err(&pdev->dev, "failed to allocate glue context\n");
523 goto err0;
524 }
525
526 musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
527 if (!musb) {
528 dev_err(&pdev->dev, "failed to allocate musb device\n");
529 goto err1;
530 }
531
532 clk = clk_get(&pdev->dev, "usb");
533 if (IS_ERR(clk)) {
534 dev_err(&pdev->dev, "failed to get clock\n");
535 ret = PTR_ERR(clk);
536 goto err3;
537 }
538
539 ret = clk_enable(clk);
540 if (ret) {
541 dev_err(&pdev->dev, "failed to enable clock\n");
542 goto err4;
543 }
544
545 musb->dev.parent = &pdev->dev;
546 musb->dev.dma_mask = &davinci_dmamask;
547 musb->dev.coherent_dma_mask = davinci_dmamask;
548
549 glue->dev = &pdev->dev;
550 glue->musb = musb;
551 glue->clk = clk;
552
553 pdata->platform_ops = &davinci_ops;
554
555 platform_set_drvdata(pdev, glue);
556
557 memset(musb_resources, 0x00, sizeof(*musb_resources) *
558 ARRAY_SIZE(musb_resources));
559
560 musb_resources[0].name = pdev->resource[0].name;
561 musb_resources[0].start = pdev->resource[0].start;
562 musb_resources[0].end = pdev->resource[0].end;
563 musb_resources[0].flags = pdev->resource[0].flags;
564
565 musb_resources[1].name = pdev->resource[1].name;
566 musb_resources[1].start = pdev->resource[1].start;
567 musb_resources[1].end = pdev->resource[1].end;
568 musb_resources[1].flags = pdev->resource[1].flags;
569
570 ret = platform_device_add_resources(musb, musb_resources,
571 ARRAY_SIZE(musb_resources));
572 if (ret) {
573 dev_err(&pdev->dev, "failed to add resources\n");
574 goto err5;
575 }
576
577 ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
578 if (ret) {
579 dev_err(&pdev->dev, "failed to add platform_data\n");
580 goto err5;
581 }
582
583 ret = platform_device_add(musb);
584 if (ret) {
585 dev_err(&pdev->dev, "failed to register musb device\n");
586 goto err5;
587 }
588
589 return 0;
590
591err5:
592 clk_disable(clk);
593
594err4:
595 clk_put(clk);
596
597err3:
598 platform_device_put(musb);
599
600err1:
601 kfree(glue);
602
603err0:
604 return ret;
605}
606
607static int davinci_remove(struct platform_device *pdev)
608{
609 struct davinci_glue *glue = platform_get_drvdata(pdev);
610
611 platform_device_unregister(glue->musb);
612 clk_disable(glue->clk);
613 clk_put(glue->clk);
614 kfree(glue);
615
616 return 0;
617}
618
619static struct platform_driver davinci_driver = {
620 .probe = davinci_probe,
621 .remove = davinci_remove,
622 .driver = {
623 .name = "musb-davinci",
624 },
625};
626
627MODULE_DESCRIPTION("DaVinci MUSB Glue Layer");
628MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
629MODULE_LICENSE("GPL v2");
630module_platform_driver(davinci_driver);
631