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                 pr_err("HS USB OTG: no transceiver configured\n");
 281                 return -EPROBE_DEFER;
 282         }
 283
 284         if (IS_ERR(musb->phy)) {
 285                 pr_err("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         pr_debug("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         pm_runtime_use_autosuspend(glue->dev);
 517         pm_runtime_set_autosuspend_delay(glue->dev, 100);
 518
 519         ret = platform_device_add(musb);
 520         if (ret) {
 521                 dev_err(&pdev->dev, "failed to register musb device\n");
 522                 goto err2;
 523         }
 524
 525         return 0;
 526
 527 err2:
 528         platform_device_put(musb);
 529
 530 err0:
 531         return ret;
 532 }
 533
 534 static int omap2430_remove(struct platform_device *pdev)
 535 {
 536         struct omap2430_glue *glue = platform_get_drvdata(pdev);
 537
 538         pm_runtime_get_sync(glue->dev);
 539         platform_device_unregister(glue->musb);
 540         pm_runtime_put_sync(glue->dev);
 541         pm_runtime_dont_use_autosuspend(glue->dev);
 542         pm_runtime_disable(glue->dev);
 543
 544         return 0;
 545 }
 546
 547 #ifdef CONFIG_PM
 548
 549 static int omap2430_runtime_suspend(struct device *dev)
 550 {
 551         struct omap2430_glue            *glue = dev_get_drvdata(dev);
 552         struct musb                     *musb = glue_to_musb(glue);
 553
 554         if (!musb)
 555                 return 0;
 556
 557         musb->context.otg_interfsel = musb_readl(musb->mregs,
 558                                                  OTG_INTERFSEL);
 559
 560         omap2430_low_level_exit(musb);
 561
 562         return 0;
 563 }
 564
 565 static int omap2430_runtime_resume(struct device *dev)
 566 {
 567         struct omap2430_glue            *glue = dev_get_drvdata(dev);
 568         struct musb                     *musb = glue_to_musb(glue);
 569
 570         if (!musb)
 571                 return 0;
 572
 573         omap2430_low_level_init(musb);
 574         musb_writel(musb->mregs, OTG_INTERFSEL,
 575                     musb->context.otg_interfsel);
 576
 577         return 0;
 578 }
 579
 580 static struct dev_pm_ops omap2430_pm_ops = {
 581         .runtime_suspend = omap2430_runtime_suspend,
 582         .runtime_resume = omap2430_runtime_resume,
 583 };
 584
 585 #define DEV_PM_OPS      (&omap2430_pm_ops)
 586 #else
 587 #define DEV_PM_OPS      NULL
 588 #endif
 589
 590 #ifdef CONFIG_OF
 591 static const struct of_device_id omap2430_id_table[] = {
 592         {
 593                 .compatible = "ti,omap4-musb"
 594         },
 595         {
 596                 .compatible = "ti,omap3-musb"
 597         },
 598         {},
 599 };
 600 MODULE_DEVICE_TABLE(of, omap2430_id_table);
 601 #endif
 602
 603 static struct platform_driver omap2430_driver = {
 604         .probe          = omap2430_probe,
 605         .remove         = omap2430_remove,
 606         .driver         = {
 607                 .name   = "musb-omap2430",
 608                 .pm     = DEV_PM_OPS,
 609                 .of_match_table = of_match_ptr(omap2430_id_table),
 610         },
 611 };
 612
 613 module_platform_driver(omap2430_driver);
 614
 615 MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
 616 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
 617 MODULE_LICENSE("GPL v2");