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 <[email protected]>
   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
 291         l = musb_readl(musb->mregs, OTG_INTERFSEL);
 292
 293         if (data->interface_type == MUSB_INTERFACE_UTMI) {
 294                 /* OMAP4 uses Internal PHY GS70 which uses UTMI interface */
 295                 l &= ~ULPI_12PIN;       /* Disable ULPI */
 296                 l |= UTMI_8BIT;         /* Enable UTMI  */
 297         } else {
 298                 l |= ULPI_12PIN;
 299         }
 300
 301         musb_writel(musb->mregs, OTG_INTERFSEL, l);
 302
 303         pr_debug("HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
 304                         "sysstatus 0x%x, intrfsel 0x%x, simenable  0x%x\n",
 305                         musb_readl(musb->mregs, OTG_REVISION),
 306                         musb_readl(musb->mregs, OTG_SYSCONFIG),
 307                         musb_readl(musb->mregs, OTG_SYSSTATUS),
 308                         musb_readl(musb->mregs, OTG_INTERFSEL),
 309                         musb_readl(musb->mregs, OTG_SIMENABLE));
 310
 311         if (glue->status != MUSB_UNKNOWN)
 312                 omap_musb_set_mailbox(glue);
 313
 314         return 0;
 315 }
 316
 317 static void omap2430_musb_enable(struct musb *musb)
 318 {
 319         u8              devctl;
 320         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
 321         struct device *dev = musb->controller;
 322         struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
 323         struct musb_hdrc_platform_data *pdata = dev_get_platdata(dev);
 324         struct omap_musb_board_data *data = pdata->board_data;
 325
 326         if (!WARN_ON(!musb->phy))
 327                 phy_power_on(musb->phy);
 328
 329         switch (glue->status) {
 330
 331         case MUSB_ID_GROUND:
 332                 omap_control_usb_set_mode(glue->control_otghs, USB_MODE_HOST);
 333                 if (data->interface_type != MUSB_INTERFACE_UTMI)
 334                         break;
 335                 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 336                 /* start the session */
 337                 devctl |= MUSB_DEVCTL_SESSION;
 338                 musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 339                 while (musb_readb(musb->mregs, MUSB_DEVCTL) &
 340                                 MUSB_DEVCTL_BDEVICE) {
 341                         cpu_relax();
 342
 343                         if (time_after(jiffies, timeout)) {
 344                                 dev_err(dev, "configured as A device timeout");
 345                                 break;
 346                         }
 347                 }
 348                 break;
 349
 350         case MUSB_VBUS_VALID:
 351                 omap_control_usb_set_mode(glue->control_otghs, USB_MODE_DEVICE);
 352                 break;
 353
 354         default:
 355                 break;
 356         }
 357 }
 358
 359 static void omap2430_musb_disable(struct musb *musb)
 360 {
 361         struct device *dev = musb->controller;
 362         struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
 363
 364         if (!WARN_ON(!musb->phy))
 365                 phy_power_off(musb->phy);
 366
 367         if (glue->status != MUSB_UNKNOWN)
 368                 omap_control_usb_set_mode(glue->control_otghs,
 369                         USB_MODE_DISCONNECT);
 370 }
 371
 372 static int omap2430_musb_exit(struct musb *musb)
 373 {
 374         struct device *dev = musb->controller;
 375         struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
 376
 377         omap2430_low_level_exit(musb);
 378         phy_exit(musb->phy);
 379         musb->phy = NULL;
 380         cancel_work_sync(&glue->omap_musb_mailbox_work);
 381
 382         return 0;
 383 }
 384
 385 static const struct musb_platform_ops omap2430_ops = {
 386         .quirks         = MUSB_DMA_INVENTRA,
 387 #ifdef CONFIG_USB_INVENTRA_DMA
 388         .dma_init       = musbhs_dma_controller_create,
 389         .dma_exit       = musbhs_dma_controller_destroy,
 390 #endif
 391         .init           = omap2430_musb_init,
 392         .exit           = omap2430_musb_exit,
 393
 394         .set_vbus       = omap2430_musb_set_vbus,
 395
 396         .enable         = omap2430_musb_enable,
 397         .disable        = omap2430_musb_disable,
 398
 399         .phy_callback   = omap2430_musb_mailbox,
 400 };
 401
 402 static u64 omap2430_dmamask = DMA_BIT_MASK(32);
 403
 404 static int omap2430_probe(struct platform_device *pdev)
 405 {
 406         struct resource                 musb_resources[3];
 407         struct musb_hdrc_platform_data  *pdata = dev_get_platdata(&pdev->dev);
 408         struct omap_musb_board_data     *data;
 409         struct platform_device          *musb;
 410         struct omap2430_glue            *glue;
 411         struct device_node              *np = pdev->dev.of_node;
 412         struct musb_hdrc_config         *config;
 413         int                             ret = -ENOMEM, val;
 414
 415         glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL);
 416         if (!glue)
 417                 goto err0;
 418
 419         musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
 420         if (!musb) {
 421                 dev_err(&pdev->dev, "failed to allocate musb device\n");
 422                 goto err0;
 423         }
 424
 425         musb->dev.parent                = &pdev->dev;
 426         musb->dev.dma_mask              = &omap2430_dmamask;
 427         musb->dev.coherent_dma_mask     = omap2430_dmamask;
 428
 429         glue->dev                       = &pdev->dev;
 430         glue->musb                      = musb;
 431         glue->status                    = MUSB_UNKNOWN;
 432         glue->control_otghs = ERR_PTR(-ENODEV);
 433
 434         if (np) {
 435                 struct device_node *control_node;
 436                 struct platform_device *control_pdev;
 437
 438                 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
 439                 if (!pdata)
 440                         goto err2;
 441
 442                 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
 443                 if (!data)
 444                         goto err2;
 445
 446                 config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
 447                 if (!config)
 448                         goto err2;
 449
 450                 of_property_read_u32(np, "mode", (u32 *)&pdata->mode);
 451                 of_property_read_u32(np, "interface-type",
 452                                                 (u32 *)&data->interface_type);
 453                 of_property_read_u32(np, "num-eps", (u32 *)&config->num_eps);
 454                 of_property_read_u32(np, "ram-bits", (u32 *)&config->ram_bits);
 455                 of_property_read_u32(np, "power", (u32 *)&pdata->power);
 456
 457                 ret = of_property_read_u32(np, "multipoint", &val);
 458                 if (!ret && val)
 459                         config->multipoint = true;
 460
 461                 pdata->board_data       = data;
 462                 pdata->config           = config;
 463
 464                 control_node = of_parse_phandle(np, "ctrl-module", 0);
 465                 if (control_node) {
 466                         control_pdev = of_find_device_by_node(control_node);
 467                         if (!control_pdev) {
 468                                 dev_err(&pdev->dev, "Failed to get control device\n");
 469                                 ret = -EINVAL;
 470                                 goto err2;
 471                         }
 472                         glue->control_otghs = &control_pdev->dev;
 473                 }
 474         }
 475         pdata->platform_ops             = &omap2430_ops;
 476
 477         platform_set_drvdata(pdev, glue);
 478
 479         /*
 480          * REVISIT if we ever have two instances of the wrapper, we will be
 481          * in big trouble
 482          */
 483         _glue   = glue;
 484
 485         INIT_WORK(&glue->omap_musb_mailbox_work, omap_musb_mailbox_work);
 486
 487         memset(musb_resources, 0x00, sizeof(*musb_resources) *
 488                         ARRAY_SIZE(musb_resources));
 489
 490         musb_resources[0].name = pdev->resource[0].name;
 491         musb_resources[0].start = pdev->resource[0].start;
 492         musb_resources[0].end = pdev->resource[0].end;
 493         musb_resources[0].flags = pdev->resource[0].flags;
 494
 495         musb_resources[1].name = pdev->resource[1].name;
 496         musb_resources[1].start = pdev->resource[1].start;
 497         musb_resources[1].end = pdev->resource[1].end;
 498         musb_resources[1].flags = pdev->resource[1].flags;
 499
 500         musb_resources[2].name = pdev->resource[2].name;
 501         musb_resources[2].start = pdev->resource[2].start;
 502         musb_resources[2].end = pdev->resource[2].end;
 503         musb_resources[2].flags = pdev->resource[2].flags;
 504
 505         ret = platform_device_add_resources(musb, musb_resources,
 506                         ARRAY_SIZE(musb_resources));
 507         if (ret) {
 508                 dev_err(&pdev->dev, "failed to add resources\n");
 509                 goto err2;
 510         }
 511
 512         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
 513         if (ret) {
 514                 dev_err(&pdev->dev, "failed to add platform_data\n");
 515                 goto err2;
 516         }
 517
 518         pm_runtime_enable(glue->dev);
 519         pm_runtime_use_autosuspend(glue->dev);
 520         pm_runtime_set_autosuspend_delay(glue->dev, 100);
 521
 522         ret = platform_device_add(musb);
 523         if (ret) {
 524                 dev_err(&pdev->dev, "failed to register musb device\n");
 525                 goto err2;
 526         }
 527
 528         return 0;
 529
 530 err2:
 531         platform_device_put(musb);
 532
 533 err0:
 534         return ret;
 535 }
 536
 537 static int omap2430_remove(struct platform_device *pdev)
 538 {
 539         struct omap2430_glue *glue = platform_get_drvdata(pdev);
 540
 541         pm_runtime_get_sync(glue->dev);
 542         platform_device_unregister(glue->musb);
 543         pm_runtime_put_sync(glue->dev);
 544         pm_runtime_dont_use_autosuspend(glue->dev);
 545         pm_runtime_disable(glue->dev);
 546
 547         return 0;
 548 }
 549
 550 #ifdef CONFIG_PM
 551
 552 static int omap2430_runtime_suspend(struct device *dev)
 553 {
 554         struct omap2430_glue            *glue = dev_get_drvdata(dev);
 555         struct musb                     *musb = glue_to_musb(glue);
 556
 557         if (!musb)
 558                 return 0;
 559
 560         musb->context.otg_interfsel = musb_readl(musb->mregs,
 561                                                  OTG_INTERFSEL);
 562
 563         omap2430_low_level_exit(musb);
 564
 565         return 0;
 566 }
 567
 568 static int omap2430_runtime_resume(struct device *dev)
 569 {
 570         struct omap2430_glue            *glue = dev_get_drvdata(dev);
 571         struct musb                     *musb = glue_to_musb(glue);
 572
 573         if (!musb)
 574                 return 0;
 575
 576         omap2430_low_level_init(musb);
 577         musb_writel(musb->mregs, OTG_INTERFSEL,
 578                     musb->context.otg_interfsel);
 579
 580         return 0;
 581 }
 582
 583 static struct dev_pm_ops omap2430_pm_ops = {
 584         .runtime_suspend = omap2430_runtime_suspend,
 585         .runtime_resume = omap2430_runtime_resume,
 586 };
 587
 588 #define DEV_PM_OPS      (&omap2430_pm_ops)
 589 #else
 590 #define DEV_PM_OPS      NULL
 591 #endif
 592
 593 #ifdef CONFIG_OF
 594 static const struct of_device_id omap2430_id_table[] = {
 595         {
 596                 .compatible = "ti,omap4-musb"
 597         },
 598         {
 599                 .compatible = "ti,omap3-musb"
 600         },
 601         {},
 602 };
 603 MODULE_DEVICE_TABLE(of, omap2430_id_table);
 604 #endif
 605
 606 static struct platform_driver omap2430_driver = {
 607         .probe          = omap2430_probe,
 608         .remove         = omap2430_remove,
 609         .driver         = {
 610                 .name   = "musb-omap2430",
 611                 .pm     = DEV_PM_OPS,
 612                 .of_match_table = of_match_ptr(omap2430_id_table),
 613         },
 614 };
 615
 616 module_platform_driver(omap2430_driver);
 617
 618 MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
 619 MODULE_AUTHOR("Felipe Balbi <[email protected]>");
 620 MODULE_LICENSE("GPL v2");