drivers/usb/musb/omap2430.c

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