linux/drivers/usb/musb/ux500.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2010 ST-Ericsson AB
   3 * Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>
   4 *
   5 * Based on omap2430.c
   6 *
   7 * This program is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 2 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22#include <linux/module.h>
  23#include <linux/kernel.h>
  24#include <linux/init.h>
  25#include <linux/clk.h>
  26#include <linux/err.h>
  27#include <linux/io.h>
  28#include <linux/of.h>
  29#include <linux/platform_device.h>
  30#include <linux/usb/musb-ux500.h>
  31
  32#include "musb_core.h"
  33
  34static struct musb_hdrc_config ux500_musb_hdrc_config = {
  35        .multipoint     = true,
  36        .dyn_fifo       = true,
  37        .num_eps        = 16,
  38        .ram_bits       = 16,
  39};
  40
  41struct ux500_glue {
  42        struct device           *dev;
  43        struct platform_device  *musb;
  44        struct clk              *clk;
  45};
  46#define glue_to_musb(g) platform_get_drvdata(g->musb)
  47
  48static void ux500_musb_set_vbus(struct musb *musb, int is_on)
  49{
  50        u8            devctl;
  51        unsigned long timeout = jiffies + msecs_to_jiffies(1000);
  52        /* HDRC controls CPEN, but beware current surges during device
  53         * connect.  They can trigger transient overcurrent conditions
  54         * that must be ignored.
  55         */
  56
  57        devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
  58
  59        if (is_on) {
  60                if (musb->xceiv->state == OTG_STATE_A_IDLE) {
  61                        /* start the session */
  62                        devctl |= MUSB_DEVCTL_SESSION;
  63                        musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
  64                        /*
  65                         * Wait for the musb to set as A device to enable the
  66                         * VBUS
  67                         */
  68                        while (musb_readb(musb->mregs, MUSB_DEVCTL) & 0x80) {
  69
  70                                if (time_after(jiffies, timeout)) {
  71                                        dev_err(musb->controller,
  72                                        "configured as A device timeout");
  73                                        break;
  74                                }
  75                        }
  76
  77                } else {
  78                        musb->is_active = 1;
  79                        musb->xceiv->otg->default_a = 1;
  80                        musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
  81                        devctl |= MUSB_DEVCTL_SESSION;
  82                        MUSB_HST_MODE(musb);
  83                }
  84        } else {
  85                musb->is_active = 0;
  86
  87                /* NOTE: we're skipping A_WAIT_VFALL -> A_IDLE and jumping
  88                 * right to B_IDLE...
  89                 */
  90                musb->xceiv->otg->default_a = 0;
  91                devctl &= ~MUSB_DEVCTL_SESSION;
  92                MUSB_DEV_MODE(musb);
  93        }
  94        musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
  95
  96        /*
  97         * Devctl values will be updated after vbus goes below
  98         * session_valid. The time taken depends on the capacitance
  99         * on VBUS line. The max discharge time can be upto 1 sec
 100         * as per the spec. Typically on our platform, it is 200ms
 101         */
 102        if (!is_on)
 103                mdelay(200);
 104
 105        dev_dbg(musb->controller, "VBUS %s, devctl %02x\n",
 106                usb_otg_state_string(musb->xceiv->state),
 107                musb_readb(musb->mregs, MUSB_DEVCTL));
 108}
 109
 110static int musb_otg_notifications(struct notifier_block *nb,
 111                unsigned long event, void *unused)
 112{
 113        struct musb *musb = container_of(nb, struct musb, nb);
 114
 115        dev_dbg(musb->controller, "musb_otg_notifications %ld %s\n",
 116                        event, usb_otg_state_string(musb->xceiv->state));
 117
 118        switch (event) {
 119        case UX500_MUSB_ID:
 120                dev_dbg(musb->controller, "ID GND\n");
 121                ux500_musb_set_vbus(musb, 1);
 122                break;
 123        case UX500_MUSB_VBUS:
 124                dev_dbg(musb->controller, "VBUS Connect\n");
 125                break;
 126        case UX500_MUSB_NONE:
 127                dev_dbg(musb->controller, "VBUS Disconnect\n");
 128                if (is_host_active(musb))
 129                        ux500_musb_set_vbus(musb, 0);
 130                else
 131                        musb->xceiv->state = OTG_STATE_B_IDLE;
 132                break;
 133        default:
 134                dev_dbg(musb->controller, "ID float\n");
 135                return NOTIFY_DONE;
 136        }
 137        return NOTIFY_OK;
 138}
 139
 140static irqreturn_t ux500_musb_interrupt(int irq, void *__hci)
 141{
 142        unsigned long   flags;
 143        irqreturn_t     retval = IRQ_NONE;
 144        struct musb     *musb = __hci;
 145
 146        spin_lock_irqsave(&musb->lock, flags);
 147
 148        musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
 149        musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
 150        musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);
 151
 152        if (musb->int_usb || musb->int_tx || musb->int_rx)
 153                retval = musb_interrupt(musb);
 154
 155        spin_unlock_irqrestore(&musb->lock, flags);
 156
 157        return retval;
 158}
 159
 160static int ux500_musb_init(struct musb *musb)
 161{
 162        int status;
 163
 164        musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
 165        if (IS_ERR_OR_NULL(musb->xceiv)) {
 166                pr_err("HS USB OTG: no transceiver configured\n");
 167                return -EPROBE_DEFER;
 168        }
 169
 170        musb->nb.notifier_call = musb_otg_notifications;
 171        status = usb_register_notifier(musb->xceiv, &musb->nb);
 172        if (status < 0) {
 173                dev_dbg(musb->controller, "notification register failed\n");
 174                return status;
 175        }
 176
 177        musb->isr = ux500_musb_interrupt;
 178
 179        return 0;
 180}
 181
 182static int ux500_musb_exit(struct musb *musb)
 183{
 184        usb_unregister_notifier(musb->xceiv, &musb->nb);
 185
 186        usb_put_phy(musb->xceiv);
 187
 188        return 0;
 189}
 190
 191static const struct musb_platform_ops ux500_ops = {
 192        .init           = ux500_musb_init,
 193        .exit           = ux500_musb_exit,
 194
 195        .set_vbus       = ux500_musb_set_vbus,
 196};
 197
 198static struct musb_hdrc_platform_data *
 199ux500_of_probe(struct platform_device *pdev, struct device_node *np)
 200{
 201        struct musb_hdrc_platform_data *pdata;
 202        const char *mode;
 203        int strlen;
 204
 205        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
 206        if (!pdata)
 207                return NULL;
 208
 209        mode = of_get_property(np, "dr_mode", &strlen);
 210        if (!mode) {
 211                dev_err(&pdev->dev, "No 'dr_mode' property found\n");
 212                return NULL;
 213        }
 214
 215        if (strlen > 0) {
 216                if (!strcmp(mode, "host"))
 217                        pdata->mode = MUSB_HOST;
 218                if (!strcmp(mode, "otg"))
 219                        pdata->mode = MUSB_OTG;
 220                if (!strcmp(mode, "peripheral"))
 221                        pdata->mode = MUSB_PERIPHERAL;
 222        }
 223
 224        return pdata;
 225}
 226
 227static int ux500_probe(struct platform_device *pdev)
 228{
 229        struct resource musb_resources[2];
 230        struct musb_hdrc_platform_data  *pdata = dev_get_platdata(&pdev->dev);
 231        struct device_node              *np = pdev->dev.of_node;
 232        struct platform_device          *musb;
 233        struct ux500_glue               *glue;
 234        struct clk                      *clk;
 235        int                             ret = -ENOMEM;
 236
 237        if (!pdata) {
 238                if (np) {
 239                        pdata = ux500_of_probe(pdev, np);
 240                        if (!pdata)
 241                                goto err0;
 242
 243                        pdev->dev.platform_data = pdata;
 244                } else {
 245                        dev_err(&pdev->dev, "no pdata or device tree found\n");
 246                        goto err0;
 247                }
 248        }
 249
 250        glue = kzalloc(sizeof(*glue), GFP_KERNEL);
 251        if (!glue) {
 252                dev_err(&pdev->dev, "failed to allocate glue context\n");
 253                goto err0;
 254        }
 255
 256        musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
 257        if (!musb) {
 258                dev_err(&pdev->dev, "failed to allocate musb device\n");
 259                goto err1;
 260        }
 261
 262        clk = clk_get(&pdev->dev, NULL);
 263        if (IS_ERR(clk)) {
 264                dev_err(&pdev->dev, "failed to get clock\n");
 265                ret = PTR_ERR(clk);
 266                goto err3;
 267        }
 268
 269        ret = clk_prepare_enable(clk);
 270        if (ret) {
 271                dev_err(&pdev->dev, "failed to enable clock\n");
 272                goto err4;
 273        }
 274
 275        musb->dev.parent                = &pdev->dev;
 276        musb->dev.dma_mask              = &pdev->dev.coherent_dma_mask;
 277        musb->dev.coherent_dma_mask     = pdev->dev.coherent_dma_mask;
 278        musb->dev.of_node               = pdev->dev.of_node;
 279
 280        glue->dev                       = &pdev->dev;
 281        glue->musb                      = musb;
 282        glue->clk                       = clk;
 283
 284        pdata->platform_ops             = &ux500_ops;
 285        pdata->config                   = &ux500_musb_hdrc_config;
 286
 287        platform_set_drvdata(pdev, glue);
 288
 289        memset(musb_resources, 0x00, sizeof(*musb_resources) *
 290                        ARRAY_SIZE(musb_resources));
 291
 292        musb_resources[0].name = pdev->resource[0].name;
 293        musb_resources[0].start = pdev->resource[0].start;
 294        musb_resources[0].end = pdev->resource[0].end;
 295        musb_resources[0].flags = pdev->resource[0].flags;
 296
 297        musb_resources[1].name = pdev->resource[1].name;
 298        musb_resources[1].start = pdev->resource[1].start;
 299        musb_resources[1].end = pdev->resource[1].end;
 300        musb_resources[1].flags = pdev->resource[1].flags;
 301
 302        ret = platform_device_add_resources(musb, musb_resources,
 303                        ARRAY_SIZE(musb_resources));
 304        if (ret) {
 305                dev_err(&pdev->dev, "failed to add resources\n");
 306                goto err5;
 307        }
 308
 309        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
 310        if (ret) {
 311                dev_err(&pdev->dev, "failed to add platform_data\n");
 312                goto err5;
 313        }
 314
 315        ret = platform_device_add(musb);
 316        if (ret) {
 317                dev_err(&pdev->dev, "failed to register musb device\n");
 318                goto err5;
 319        }
 320
 321        return 0;
 322
 323err5:
 324        clk_disable_unprepare(clk);
 325
 326err4:
 327        clk_put(clk);
 328
 329err3:
 330        platform_device_put(musb);
 331
 332err1:
 333        kfree(glue);
 334
 335err0:
 336        return ret;
 337}
 338
 339static int ux500_remove(struct platform_device *pdev)
 340{
 341        struct ux500_glue       *glue = platform_get_drvdata(pdev);
 342
 343        platform_device_unregister(glue->musb);
 344        clk_disable_unprepare(glue->clk);
 345        clk_put(glue->clk);
 346        kfree(glue);
 347
 348        return 0;
 349}
 350
 351#ifdef CONFIG_PM
 352static int ux500_suspend(struct device *dev)
 353{
 354        struct ux500_glue       *glue = dev_get_drvdata(dev);
 355        struct musb             *musb = glue_to_musb(glue);
 356
 357        usb_phy_set_suspend(musb->xceiv, 1);
 358        clk_disable_unprepare(glue->clk);
 359
 360        return 0;
 361}
 362
 363static int ux500_resume(struct device *dev)
 364{
 365        struct ux500_glue       *glue = dev_get_drvdata(dev);
 366        struct musb             *musb = glue_to_musb(glue);
 367        int                     ret;
 368
 369        ret = clk_prepare_enable(glue->clk);
 370        if (ret) {
 371                dev_err(dev, "failed to enable clock\n");
 372                return ret;
 373        }
 374
 375        usb_phy_set_suspend(musb->xceiv, 0);
 376
 377        return 0;
 378}
 379#endif
 380
 381static SIMPLE_DEV_PM_OPS(ux500_pm_ops, ux500_suspend, ux500_resume);
 382
 383static const struct of_device_id ux500_match[] = {
 384        { .compatible = "stericsson,db8500-musb", },
 385        {}
 386};
 387
 388static struct platform_driver ux500_driver = {
 389        .probe          = ux500_probe,
 390        .remove         = ux500_remove,
 391        .driver         = {
 392                .name   = "musb-ux500",
 393                .pm     = &ux500_pm_ops,
 394                .of_match_table = ux500_match,
 395        },
 396};
 397
 398MODULE_DESCRIPTION("UX500 MUSB Glue Layer");
 399MODULE_AUTHOR("Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com>");
 400MODULE_LICENSE("GPL v2");
 401module_platform_driver(ux500_driver);
 402