Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/usb/musb/omap2430.c

  1 /*
  2  * Copyright (C) 2005-2007 by Texas Instruments
  3  * Some code has been taken from tusb6010.c
  4  * Copyrights for that are attributable to:
  5  * Copyright (C) 2006 Nokia Corporation
  6  * Tony Lindgren <tony@atomide.com>
  7  *
  8  * This file is part of the Inventra Controller Driver for Linux.
  9  *
 10  * The Inventra Controller Driver for Linux is free software; you
 11  * can redistribute it and/or modify it under the terms of the GNU
 12  * General Public License version 2 as published by the Free Software
 13  * Foundation.
 14  *
 15  * The Inventra Controller Driver for Linux is distributed in
 16  * the hope that it will be useful, but WITHOUT ANY WARRANTY;
 17  * without even the implied warranty of MERCHANTABILITY or
 18  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 19  * License for more details.
 20  *
 21  * You should have received a copy of the GNU General Public License
 22  * along with The Inventra Controller Driver for Linux ; if not,
 23  * write to the Free Software Foundation, Inc., 59 Temple Place,
 24  * Suite 330, Boston, MA  02111-1307  USA
 25  *
 26  */
 27 #include <linux/module.h>
 28 #include <linux/kernel.h>
 29 #include <linux/sched.h>
 30 #include <linux/init.h>
 31 #include <linux/list.h>
 32 #include <linux/io.h>
 33 #include <linux/of.h>
 34 #include <linux/platform_device.h>
 35 #include <linux/dma-mapping.h>
 36 #include <linux/pm_runtime.h>
 37 #include <linux/err.h>
 38 #include <linux/delay.h>
 39 #include <linux/usb/musb.h>
 40 #include <linux/phy/omap_control_phy.h>
 41 #include <linux/of_platform.h>
 42 
 43 #include "musb_core.h"
 44 #include "omap2430.h"
 45 
 46 struct omap2430_glue {
 47         struct device           *dev;
 48         struct platform_device  *musb;
 49         enum musb_vbus_id_status status;
 50         struct work_struct      omap_musb_mailbox_work;
 51         struct device           *control_otghs;
 52 };
 53 #define glue_to_musb(g)         platform_get_drvdata(g->musb)
 54 
 55 static struct omap2430_glue     *_glue;
 56 
 57 static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
 58 {
 59         struct usb_otg  *otg = musb->xceiv->otg;
 60         u8              devctl;
 61         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
 62         /* HDRC controls CPEN, but beware current surges during device
 63          * connect.  They can trigger transient overcurrent conditions
 64          * that must be ignored.
 65          */
 66 
 67         devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 68 
 69         if (is_on) {
 70                 if (musb->xceiv->otg->state == OTG_STATE_A_IDLE) {
 71                         int loops = 100;
 72                         /* start the session */
 73                         devctl |= MUSB_DEVCTL_SESSION;
 74                         musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 75                         /*
 76                          * Wait for the musb to set as A device to enable the
 77                          * VBUS
 78                          */
 79                         while (musb_readb(musb->mregs, MUSB_DEVCTL) &
 80                                MUSB_DEVCTL_BDEVICE) {
 81 
 82                                 mdelay(5);
 83                                 cpu_relax();
 84 
 85                                 if (time_after(jiffies, timeout)
 86                                     || loops-- <= 0) {
 87                                         dev_err(musb->controller,
 88                                         "configured as A device timeout");
 89                                         break;
 90                                 }
 91                         }
 92 
 93                         otg_set_vbus(otg, 1);
 94                 } else {
 95                         musb->is_active = 1;
 96                         otg->default_a = 1;
 97                         musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
 98                         devctl |= MUSB_DEVCTL_SESSION;
 99                         MUSB_HST_MODE(musb);
100                 }
101         } else {
102                 musb->is_active = 0;
103 
104                 /* NOTE:  we're skipping A_WAIT_VFALL -> A_IDLE and
105                  * jumping right to B_IDLE...
106                  */
107 
108                 otg->default_a = 0;
109                 musb->xceiv->otg->state = OTG_STATE_B_IDLE;
110                 devctl &= ~MUSB_DEVCTL_SESSION;
111 
112                 MUSB_DEV_MODE(musb);
113         }
114         musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
115 
116         dev_dbg(musb->controller, "VBUS %s, devctl %02x "
117                 /* otg %3x conf %08x prcm %08x */ "\n",
118                 usb_otg_state_string(musb->xceiv->otg->state),
119                 musb_readb(musb->mregs, MUSB_DEVCTL));
120 }
121 
122 static inline void omap2430_low_level_exit(struct musb *musb)
123 {
124         u32 l;
125 
126         /* in any role */
127         l = musb_readl(musb->mregs, OTG_FORCESTDBY);
128         l |= ENABLEFORCE;       /* enable MSTANDBY */
129         musb_writel(musb->mregs, OTG_FORCESTDBY, l);
130 }
131 
132 static inline void omap2430_low_level_init(struct musb *musb)
133 {
134         u32 l;
135 
136         l = musb_readl(musb->mregs, OTG_FORCESTDBY);
137         l &= ~ENABLEFORCE;      /* disable MSTANDBY */
138         musb_writel(musb->mregs, OTG_FORCESTDBY, l);
139 }
140 
141 static int omap2430_musb_mailbox(enum musb_vbus_id_status status)
142 {
143         struct omap2430_glue    *glue = _glue;
144 
145         if (!glue) {
146                 pr_err("%s: musb core is not yet initialized\n", __func__);
147                 return -EPROBE_DEFER;
148         }
149         glue->status = status;
150 
151         if (!glue_to_musb(glue)) {
152                 pr_err("%s: musb core is not yet ready\n", __func__);
153                 return -EPROBE_DEFER;
154         }
155 
156         schedule_work(&glue->omap_musb_mailbox_work);
157 
158         return 0;
159 }
160 
161 static void omap_musb_set_mailbox(struct omap2430_glue *glue)
162 {
163         struct musb *musb = glue_to_musb(glue);
164         struct musb_hdrc_platform_data *pdata =
165                 dev_get_platdata(musb->controller);
166         struct omap_musb_board_data *data = pdata->board_data;
167         struct usb_otg *otg = musb->xceiv->otg;
168 
169         pm_runtime_get_sync(musb->controller);
170         switch (glue->status) {
171         case MUSB_ID_GROUND:
172                 dev_dbg(musb->controller, "ID GND\n");
173 
174                 otg->default_a = true;
175                 musb->xceiv->otg->state = OTG_STATE_A_IDLE;
176                 musb->xceiv->last_event = USB_EVENT_ID;
177                 if (musb->gadget_driver) {
178                         omap_control_usb_set_mode(glue->control_otghs,
179                                 USB_MODE_HOST);
180                         omap2430_musb_set_vbus(musb, 1);
181                 }
182                 break;
183 
184         case MUSB_VBUS_VALID:
185                 dev_dbg(musb->controller, "VBUS Connect\n");
186 
187                 otg->default_a = false;
188                 musb->xceiv->otg->state = OTG_STATE_B_IDLE;
189                 musb->xceiv->last_event = USB_EVENT_VBUS;
190                 omap_control_usb_set_mode(glue->control_otghs, USB_MODE_DEVICE);
191                 break;
192 
193         case MUSB_ID_FLOAT:
194         case MUSB_VBUS_OFF:
195                 dev_dbg(musb->controller, "VBUS Disconnect\n");
196 
197                 musb->xceiv->last_event = USB_EVENT_NONE;
198                 if (musb->gadget_driver)
199                         omap2430_musb_set_vbus(musb, 0);
200 
201                 if (data->interface_type == MUSB_INTERFACE_UTMI)
202                         otg_set_vbus(musb->xceiv->otg, 0);
203 
204                 omap_control_usb_set_mode(glue->control_otghs,
205                         USB_MODE_DISCONNECT);
206                 break;
207         default:
208                 dev_dbg(musb->controller, "ID float\n");
209         }
210         pm_runtime_mark_last_busy(musb->controller);
211         pm_runtime_put_autosuspend(musb->controller);
212         atomic_notifier_call_chain(&musb->xceiv->notifier,
213                         musb->xceiv->last_event, NULL);
214 }
215 
216 
217 static void omap_musb_mailbox_work(struct work_struct *mailbox_work)
218 {
219         struct omap2430_glue *glue = container_of(mailbox_work,
220                                 struct omap2430_glue, omap_musb_mailbox_work);
221 
222         omap_musb_set_mailbox(glue);
223 }
224 
225 static irqreturn_t omap2430_musb_interrupt(int irq, void *__hci)
226 {
227         unsigned long   flags;
228         irqreturn_t     retval = IRQ_NONE;
229         struct musb     *musb = __hci;
230 
231         spin_lock_irqsave(&musb->lock, flags);
232 
233         musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
234         musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
235         musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);
236 
237         if (musb->int_usb || musb->int_tx || musb->int_rx)
238                 retval = musb_interrupt(musb);
239 
240         spin_unlock_irqrestore(&musb->lock, flags);
241 
242         return retval;
243 }
244 
245 static int omap2430_musb_init(struct musb *musb)
246 {
247         u32 l;
248         int status = 0;
249         struct device *dev = musb->controller;
250         struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
251         struct musb_hdrc_platform_data *plat = dev_get_platdata(dev);
252         struct omap_musb_board_data *data = plat->board_data;
253 
254         /* We require some kind of external transceiver, hooked
255          * up through ULPI.  TWL4030-family PMICs include one,
256          * which needs a driver, drivers aren't always needed.
257          */
258         if (dev->parent->of_node) {
259                 musb->phy = devm_phy_get(dev->parent, "usb2-phy");
260 
261                 /* We can't totally remove musb->xceiv as of now because
262                  * musb core uses xceiv.state and xceiv.otg. Once we have
263                  * a separate state machine to handle otg, these can be moved
264                  * out of xceiv and then we can start using the generic PHY
265                  * framework
266                  */
267                 musb->xceiv = devm_usb_get_phy_by_phandle(dev->parent,
268                     "usb-phy", 0);
269         } else {
270                 musb->xceiv = devm_usb_get_phy_dev(dev, 0);
271                 musb->phy = devm_phy_get(dev, "usb");
272         }
273 
274         if (IS_ERR(musb->xceiv)) {
275                 status = PTR_ERR(musb->xceiv);
276 
277                 if (status == -ENXIO)
278                         return status;
279 
280                 dev_dbg(dev, "HS USB OTG: no transceiver configured\n");
281                 return -EPROBE_DEFER;
282         }
283 
284         if (IS_ERR(musb->phy)) {
285                 dev_err(dev, "HS USB OTG: no PHY configured\n");
286                 return PTR_ERR(musb->phy);
287         }
288         musb->isr = omap2430_musb_interrupt;
289         phy_init(musb->phy);
290         phy_power_on(musb->phy);
291 
292         l = musb_readl(musb->mregs, OTG_INTERFSEL);
293 
294         if (data->interface_type == MUSB_INTERFACE_UTMI) {
295                 /* OMAP4 uses Internal PHY GS70 which uses UTMI interface */
296                 l &= ~ULPI_12PIN;       /* Disable ULPI */
297                 l |= UTMI_8BIT;         /* Enable UTMI  */
298         } else {
299                 l |= ULPI_12PIN;
300         }
301 
302         musb_writel(musb->mregs, OTG_INTERFSEL, l);
303 
304         dev_dbg(dev, "HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
305                         "sysstatus 0x%x, intrfsel 0x%x, simenable  0x%x\n",
306                         musb_readl(musb->mregs, OTG_REVISION),
307                         musb_readl(musb->mregs, OTG_SYSCONFIG),
308                         musb_readl(musb->mregs, OTG_SYSSTATUS),
309                         musb_readl(musb->mregs, OTG_INTERFSEL),
310                         musb_readl(musb->mregs, OTG_SIMENABLE));
311 
312         if (glue->status != MUSB_UNKNOWN)
313                 omap_musb_set_mailbox(glue);
314 
315         return 0;
316 }
317 
318 static void omap2430_musb_enable(struct musb *musb)
319 {
320         u8              devctl;
321         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
322         struct device *dev = musb->controller;
323         struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
324         struct musb_hdrc_platform_data *pdata = dev_get_platdata(dev);
325         struct omap_musb_board_data *data = pdata->board_data;
326 
327 
328         switch (glue->status) {
329 
330         case MUSB_ID_GROUND:
331                 omap_control_usb_set_mode(glue->control_otghs, USB_MODE_HOST);
332                 if (data->interface_type != MUSB_INTERFACE_UTMI)
333                         break;
334                 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
335                 /* start the session */
336                 devctl |= MUSB_DEVCTL_SESSION;
337                 musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
338                 while (musb_readb(musb->mregs, MUSB_DEVCTL) &
339                                 MUSB_DEVCTL_BDEVICE) {
340                         cpu_relax();
341 
342                         if (time_after(jiffies, timeout)) {
343                                 dev_err(dev, "configured as A device timeout");
344                                 break;
345                         }
346                 }
347                 break;
348 
349         case MUSB_VBUS_VALID:
350                 omap_control_usb_set_mode(glue->control_otghs, USB_MODE_DEVICE);
351                 break;
352 
353         default:
354                 break;
355         }
356 }
357 
358 static void omap2430_musb_disable(struct musb *musb)
359 {
360         struct device *dev = musb->controller;
361         struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
362 
363         if (glue->status != MUSB_UNKNOWN)
364                 omap_control_usb_set_mode(glue->control_otghs,
365                         USB_MODE_DISCONNECT);
366 }
367 
368 static int omap2430_musb_exit(struct musb *musb)
369 {
370         struct device *dev = musb->controller;
371         struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
372 
373         omap2430_low_level_exit(musb);
374         phy_power_off(musb->phy);
375         phy_exit(musb->phy);
376         musb->phy = NULL;
377         cancel_work_sync(&glue->omap_musb_mailbox_work);
378 
379         return 0;
380 }
381 
382 static const struct musb_platform_ops omap2430_ops = {
383         .quirks         = MUSB_DMA_INVENTRA,
384 #ifdef CONFIG_USB_INVENTRA_DMA
385         .dma_init       = musbhs_dma_controller_create,
386         .dma_exit       = musbhs_dma_controller_destroy,
387 #endif
388         .init           = omap2430_musb_init,
389         .exit           = omap2430_musb_exit,
390 
391         .set_vbus       = omap2430_musb_set_vbus,
392 
393         .enable         = omap2430_musb_enable,
394         .disable        = omap2430_musb_disable,
395 
396         .phy_callback   = omap2430_musb_mailbox,
397 };
398 
399 static u64 omap2430_dmamask = DMA_BIT_MASK(32);
400 
401 static int omap2430_probe(struct platform_device *pdev)
402 {
403         struct resource                 musb_resources[3];
404         struct musb_hdrc_platform_data  *pdata = dev_get_platdata(&pdev->dev);
405         struct omap_musb_board_data     *data;
406         struct platform_device          *musb;
407         struct omap2430_glue            *glue;
408         struct device_node              *np = pdev->dev.of_node;
409         struct musb_hdrc_config         *config;
410         int                             ret = -ENOMEM, val;
411 
412         glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL);
413         if (!glue)
414                 goto err0;
415 
416         musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
417         if (!musb) {
418                 dev_err(&pdev->dev, "failed to allocate musb device\n");
419                 goto err0;
420         }
421 
422         musb->dev.parent                = &pdev->dev;
423         musb->dev.dma_mask              = &omap2430_dmamask;
424         musb->dev.coherent_dma_mask     = omap2430_dmamask;
425 
426         glue->dev                       = &pdev->dev;
427         glue->musb                      = musb;
428         glue->status                    = MUSB_UNKNOWN;
429         glue->control_otghs = ERR_PTR(-ENODEV);
430 
431         if (np) {
432                 struct device_node *control_node;
433                 struct platform_device *control_pdev;
434 
435                 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
436                 if (!pdata)
437                         goto err2;
438 
439                 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
440                 if (!data)
441                         goto err2;
442 
443                 config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
444                 if (!config)
445                         goto err2;
446 
447                 of_property_read_u32(np, "mode", (u32 *)&pdata->mode);
448                 of_property_read_u32(np, "interface-type",
449                                                 (u32 *)&data->interface_type);
450                 of_property_read_u32(np, "num-eps", (u32 *)&config->num_eps);
451                 of_property_read_u32(np, "ram-bits", (u32 *)&config->ram_bits);
452                 of_property_read_u32(np, "power", (u32 *)&pdata->power);
453 
454                 ret = of_property_read_u32(np, "multipoint", &val);
455                 if (!ret && val)
456                         config->multipoint = true;
457 
458                 pdata->board_data       = data;
459                 pdata->config           = config;
460 
461                 control_node = of_parse_phandle(np, "ctrl-module", 0);
462                 if (control_node) {
463                         control_pdev = of_find_device_by_node(control_node);
464                         if (!control_pdev) {
465                                 dev_err(&pdev->dev, "Failed to get control device\n");
466                                 ret = -EINVAL;
467                                 goto err2;
468                         }
469                         glue->control_otghs = &control_pdev->dev;
470                 }
471         }
472         pdata->platform_ops             = &omap2430_ops;
473 
474         platform_set_drvdata(pdev, glue);
475 
476         /*
477          * REVISIT if we ever have two instances of the wrapper, we will be
478          * in big trouble
479          */
480         _glue   = glue;
481 
482         INIT_WORK(&glue->omap_musb_mailbox_work, omap_musb_mailbox_work);
483 
484         memset(musb_resources, 0x00, sizeof(*musb_resources) *
485                         ARRAY_SIZE(musb_resources));
486 
487         musb_resources[0].name = pdev->resource[0].name;
488         musb_resources[0].start = pdev->resource[0].start;
489         musb_resources[0].end = pdev->resource[0].end;
490         musb_resources[0].flags = pdev->resource[0].flags;
491 
492         musb_resources[1].name = pdev->resource[1].name;
493         musb_resources[1].start = pdev->resource[1].start;
494         musb_resources[1].end = pdev->resource[1].end;
495         musb_resources[1].flags = pdev->resource[1].flags;
496 
497         musb_resources[2].name = pdev->resource[2].name;
498         musb_resources[2].start = pdev->resource[2].start;
499         musb_resources[2].end = pdev->resource[2].end;
500         musb_resources[2].flags = pdev->resource[2].flags;
501 
502         ret = platform_device_add_resources(musb, musb_resources,
503                         ARRAY_SIZE(musb_resources));
504         if (ret) {
505                 dev_err(&pdev->dev, "failed to add resources\n");
506                 goto err2;
507         }
508 
509         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
510         if (ret) {
511                 dev_err(&pdev->dev, "failed to add platform_data\n");
512                 goto err2;
513         }
514 
515         pm_runtime_enable(glue->dev);
516 
517         ret = platform_device_add(musb);
518         if (ret) {
519                 dev_err(&pdev->dev, "failed to register musb device\n");
520                 goto err3;
521         }
522 
523         return 0;
524 
525 err3:
526         pm_runtime_disable(glue->dev);
527 
528 err2:
529         platform_device_put(musb);
530 
531 err0:
532         return ret;
533 }
534 
535 static int omap2430_remove(struct platform_device *pdev)
536 {
537         struct omap2430_glue *glue = platform_get_drvdata(pdev);
538 
539         platform_device_unregister(glue->musb);
540         pm_runtime_disable(glue->dev);
541 
542         return 0;
543 }
544 
545 #ifdef CONFIG_PM
546 
547 static int omap2430_runtime_suspend(struct device *dev)
548 {
549         struct omap2430_glue            *glue = dev_get_drvdata(dev);
550         struct musb                     *musb = glue_to_musb(glue);
551 
552         if (!musb)
553                 return 0;
554 
555         musb->context.otg_interfsel = musb_readl(musb->mregs,
556                                                  OTG_INTERFSEL);
557 
558         omap2430_low_level_exit(musb);
559 
560         return 0;
561 }
562 
563 static int omap2430_runtime_resume(struct device *dev)
564 {
565         struct omap2430_glue            *glue = dev_get_drvdata(dev);
566         struct musb                     *musb = glue_to_musb(glue);
567 
568         if (!musb)
569                 return 0;
570 
571         omap2430_low_level_init(musb);
572         musb_writel(musb->mregs, OTG_INTERFSEL,
573                     musb->context.otg_interfsel);
574 
575         return 0;
576 }
577 
578 static struct dev_pm_ops omap2430_pm_ops = {
579         .runtime_suspend = omap2430_runtime_suspend,
580         .runtime_resume = omap2430_runtime_resume,
581 };
582 
583 #define DEV_PM_OPS      (&omap2430_pm_ops)
584 #else
585 #define DEV_PM_OPS      NULL
586 #endif
587 
588 #ifdef CONFIG_OF
589 static const struct of_device_id omap2430_id_table[] = {
590         {
591                 .compatible = "ti,omap4-musb"
592         },
593         {
594                 .compatible = "ti,omap3-musb"
595         },
596         {},
597 };
598 MODULE_DEVICE_TABLE(of, omap2430_id_table);
599 #endif
600 
601 static struct platform_driver omap2430_driver = {
602         .probe          = omap2430_probe,
603         .remove         = omap2430_remove,
604         .driver         = {
605                 .name   = "musb-omap2430",
606                 .pm     = DEV_PM_OPS,
607                 .of_match_table = of_match_ptr(omap2430_id_table),
608         },
609 };
610 
611 module_platform_driver(omap2430_driver);
612 
613 MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
614 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
615 MODULE_LICENSE("GPL v2");
616 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us