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         .enable         = omap2430_musb_enable,
 392         .disable        = omap2430_musb_disable,
 393
 394         .phy_callback   = omap2430_musb_mailbox,
 395 };
 396
 397 static u64 omap2430_dmamask = DMA_BIT_MASK(32);
 398
 399 static int omap2430_probe(struct platform_device *pdev)
 400 {
 401         struct resource                 musb_resources[3];
 402         struct musb_hdrc_platform_data  *pdata = dev_get_platdata(&pdev->dev);
 403         struct omap_musb_board_data     *data;
 404         struct platform_device          *musb;
 405         struct omap2430_glue            *glue;
 406         struct device_node              *np = pdev->dev.of_node;
 407         struct musb_hdrc_config         *config;
 408         int                             ret = -ENOMEM, val;
 409
 410         glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL);
 411         if (!glue)
 412                 goto err0;
 413
 414         musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
 415         if (!musb) {
 416                 dev_err(&pdev->dev, "failed to allocate musb device\n");
 417                 goto err0;
 418         }
 419
 420         musb->dev.parent                = &pdev->dev;
 421         musb->dev.dma_mask              = &omap2430_dmamask;
 422         musb->dev.coherent_dma_mask     = omap2430_dmamask;
 423
 424         glue->dev                       = &pdev->dev;
 425         glue->musb                      = musb;
 426         glue->status                    = MUSB_UNKNOWN;
 427         glue->control_otghs = ERR_PTR(-ENODEV);
 428
 429         if (np) {
 430                 struct device_node *control_node;
 431                 struct platform_device *control_pdev;
 432
 433                 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
 434                 if (!pdata)
 435                         goto err2;
 436
 437                 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
 438                 if (!data)
 439                         goto err2;
 440
 441                 config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
 442                 if (!config)
 443                         goto err2;
 444
 445                 of_property_read_u32(np, "mode", (u32 *)&pdata->mode);
 446                 of_property_read_u32(np, "interface-type",
 447                                                 (u32 *)&data->interface_type);
 448                 of_property_read_u32(np, "num-eps", (u32 *)&config->num_eps);
 449                 of_property_read_u32(np, "ram-bits", (u32 *)&config->ram_bits);
 450                 of_property_read_u32(np, "power", (u32 *)&pdata->power);
 451
 452                 ret = of_property_read_u32(np, "multipoint", &val);
 453                 if (!ret && val)
 454                         config->multipoint = true;
 455
 456                 pdata->board_data       = data;
 457                 pdata->config           = config;
 458
 459                 control_node = of_parse_phandle(np, "ctrl-module", 0);
 460                 if (control_node) {
 461                         control_pdev = of_find_device_by_node(control_node);
 462                         if (!control_pdev) {
 463                                 dev_err(&pdev->dev, "Failed to get control device\n");
 464                                 ret = -EINVAL;
 465                                 goto err2;
 466                         }
 467                         glue->control_otghs = &control_pdev->dev;
 468                 }
 469         }
 470         pdata->platform_ops             = &omap2430_ops;
 471
 472         platform_set_drvdata(pdev, glue);
 473
 474         /*
 475          * REVISIT if we ever have two instances of the wrapper, we will be
 476          * in big trouble
 477          */
 478         _glue   = glue;
 479
 480         INIT_WORK(&glue->omap_musb_mailbox_work, omap_musb_mailbox_work);
 481
 482         memset(musb_resources, 0x00, sizeof(*musb_resources) *
 483                         ARRAY_SIZE(musb_resources));
 484
 485         musb_resources[0].name = pdev->resource[0].name;
 486         musb_resources[0].start = pdev->resource[0].start;
 487         musb_resources[0].end = pdev->resource[0].end;
 488         musb_resources[0].flags = pdev->resource[0].flags;
 489
 490         musb_resources[1].name = pdev->resource[1].name;
 491         musb_resources[1].start = pdev->resource[1].start;
 492         musb_resources[1].end = pdev->resource[1].end;
 493         musb_resources[1].flags = pdev->resource[1].flags;
 494
 495         musb_resources[2].name = pdev->resource[2].name;
 496         musb_resources[2].start = pdev->resource[2].start;
 497         musb_resources[2].end = pdev->resource[2].end;
 498         musb_resources[2].flags = pdev->resource[2].flags;
 499
 500         ret = platform_device_add_resources(musb, musb_resources,
 501                         ARRAY_SIZE(musb_resources));
 502         if (ret) {
 503                 dev_err(&pdev->dev, "failed to add resources\n");
 504                 goto err2;
 505         }
 506
 507         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
 508         if (ret) {
 509                 dev_err(&pdev->dev, "failed to add platform_data\n");
 510                 goto err2;
 511         }
 512
 513         pm_runtime_enable(glue->dev);
 514
 515         ret = platform_device_add(musb);
 516         if (ret) {
 517                 dev_err(&pdev->dev, "failed to register musb device\n");
 518                 goto err3;
 519         }
 520
 521         return 0;
 522
 523 err3:
 524         pm_runtime_disable(glue->dev);
 525
 526 err2:
 527         platform_device_put(musb);
 528
 529 err0:
 530         return ret;
 531 }
 532
 533 static int omap2430_remove(struct platform_device *pdev)
 534 {
 535         struct omap2430_glue *glue = platform_get_drvdata(pdev);
 536
 537         platform_device_unregister(glue->musb);
 538         pm_runtime_disable(glue->dev);
 539
 540         return 0;
 541 }
 542
 543 #ifdef CONFIG_PM
 544
 545 static int omap2430_runtime_suspend(struct device *dev)
 546 {
 547         struct omap2430_glue            *glue = dev_get_drvdata(dev);
 548         struct musb                     *musb = glue_to_musb(glue);
 549
 550         if (!musb)
 551                 return 0;
 552
 553         musb->context.otg_interfsel = musb_readl(musb->mregs,
 554                                                  OTG_INTERFSEL);
 555
 556         omap2430_low_level_exit(musb);
 557
 558         return 0;
 559 }
 560
 561 static int omap2430_runtime_resume(struct device *dev)
 562 {
 563         struct omap2430_glue            *glue = dev_get_drvdata(dev);
 564         struct musb                     *musb = glue_to_musb(glue);
 565
 566         if (!musb)
 567                 return 0;
 568
 569         omap2430_low_level_init(musb);
 570         musb_writel(musb->mregs, OTG_INTERFSEL,
 571                     musb->context.otg_interfsel);
 572
 573         return 0;
 574 }
 575
 576 static struct dev_pm_ops omap2430_pm_ops = {
 577         .runtime_suspend = omap2430_runtime_suspend,
 578         .runtime_resume = omap2430_runtime_resume,
 579 };
 580
 581 #define DEV_PM_OPS      (&omap2430_pm_ops)
 582 #else
 583 #define DEV_PM_OPS      NULL
 584 #endif
 585
 586 #ifdef CONFIG_OF
 587 static const struct of_device_id omap2430_id_table[] = {
 588         {
 589                 .compatible = "ti,omap4-musb"
 590         },
 591         {
 592                 .compatible = "ti,omap3-musb"
 593         },
 594         {},
 595 };
 596 MODULE_DEVICE_TABLE(of, omap2430_id_table);
 597 #endif
 598
 599 static struct platform_driver omap2430_driver = {
 600         .probe          = omap2430_probe,
 601         .remove         = omap2430_remove,
 602         .driver         = {
 603                 .name   = "musb-omap2430",
 604                 .pm     = DEV_PM_OPS,
 605                 .of_match_table = of_match_ptr(omap2430_id_table),
 606         },
 607 };
 608
 609 module_platform_driver(omap2430_driver);
 610
 611 MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
 612 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
 613 MODULE_LICENSE("GPL v2");