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