drivers/usb/musb-new/am35x.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Texas Instruments AM35x "glue layer"
   4  *
   5  * Copyright (c) 2010, by Texas Instruments
   6  *
   7  * Based on the DA8xx "glue layer" code.
   8  * Copyright (c) 2008-2009, MontaVista Software, Inc. <source@mvista.com>
   9  *
  10  * This file is part of the Inventra Controller Driver for Linux.
  11  *
  12  */
  13
  14 #ifndef __UBOOT__
  15 #include <dm/device_compat.h>
  16 #include <dm/devres.h>
  17 #include <linux/init.h>
  18 #include <linux/module.h>
  19 #include <linux/clk.h>
  20 #include <linux/err.h>
  21 #include <linux/io.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/dma-mapping.h>
  24
  25 #include <plat/usb.h>
  26 #else
  27 #include <common.h>
  28 #include <asm/omap_musb.h>
  29 #include <linux/bug.h>
  30 #include "linux-compat.h"
  31 #endif
  32
  33 #include "musb_core.h"
  34
  35 /*
  36  * AM35x specific definitions
  37  */
  38 /* USB 2.0 OTG module registers */
  39 #define USB_REVISION_REG        0x00
  40 #define USB_CTRL_REG            0x04
  41 #define USB_STAT_REG            0x08
  42 #define USB_EMULATION_REG       0x0c
  43 /* 0x10 Reserved */
  44 #define USB_AUTOREQ_REG         0x14
  45 #define USB_SRP_FIX_TIME_REG    0x18
  46 #define USB_TEARDOWN_REG        0x1c
  47 #define EP_INTR_SRC_REG         0x20
  48 #define EP_INTR_SRC_SET_REG     0x24
  49 #define EP_INTR_SRC_CLEAR_REG   0x28
  50 #define EP_INTR_MASK_REG        0x2c
  51 #define EP_INTR_MASK_SET_REG    0x30
  52 #define EP_INTR_MASK_CLEAR_REG  0x34
  53 #define EP_INTR_SRC_MASKED_REG  0x38
  54 #define CORE_INTR_SRC_REG       0x40
  55 #define CORE_INTR_SRC_SET_REG   0x44
  56 #define CORE_INTR_SRC_CLEAR_REG 0x48
  57 #define CORE_INTR_MASK_REG      0x4c
  58 #define CORE_INTR_MASK_SET_REG  0x50
  59 #define CORE_INTR_MASK_CLEAR_REG 0x54
  60 #define CORE_INTR_SRC_MASKED_REG 0x58
  61 /* 0x5c Reserved */
  62 #define USB_END_OF_INTR_REG     0x60
  63
  64 /* Control register bits */
  65 #define AM35X_SOFT_RESET_MASK   1
  66
  67 /* USB interrupt register bits */
  68 #define AM35X_INTR_USB_SHIFT    16
  69 #define AM35X_INTR_USB_MASK     (0x1ff << AM35X_INTR_USB_SHIFT)
  70 #define AM35X_INTR_DRVVBUS      0x100
  71 #define AM35X_INTR_RX_SHIFT     16
  72 #define AM35X_INTR_TX_SHIFT     0
  73 #define AM35X_TX_EP_MASK        0xffff          /* EP0 + 15 Tx EPs */
  74 #define AM35X_RX_EP_MASK        0xfffe          /* 15 Rx EPs */
  75 #define AM35X_TX_INTR_MASK      (AM35X_TX_EP_MASK << AM35X_INTR_TX_SHIFT)
  76 #define AM35X_RX_INTR_MASK      (AM35X_RX_EP_MASK << AM35X_INTR_RX_SHIFT)
  77
  78 #define USB_MENTOR_CORE_OFFSET  0x400
  79
  80 struct am35x_glue {
  81         struct device           *dev;
  82         struct platform_device  *musb;
  83         struct clk              *phy_clk;
  84         struct clk              *clk;
  85 };
  86 #define glue_to_musb(g)         platform_get_drvdata(g->musb)
  87
  88 /*
  89  * am35x_musb_enable - enable interrupts
  90  */
  91 #ifndef __UBOOT__
  92 static void am35x_musb_enable(struct musb *musb)
  93 #else
  94 static int am35x_musb_enable(struct musb *musb)
  95 #endif
  96 {
  97         void __iomem *reg_base = musb->ctrl_base;
  98         u32 epmask;
  99
 100         /* Workaround: setup IRQs through both register sets. */
 101         epmask = ((musb->epmask & AM35X_TX_EP_MASK) << AM35X_INTR_TX_SHIFT) |
 102                ((musb->epmask & AM35X_RX_EP_MASK) << AM35X_INTR_RX_SHIFT);
 103
 104         musb_writel(reg_base, EP_INTR_MASK_SET_REG, epmask);
 105         musb_writel(reg_base, CORE_INTR_MASK_SET_REG, AM35X_INTR_USB_MASK);
 106
 107         /* Force the DRVVBUS IRQ so we can start polling for ID change. */
 108         if (is_otg_enabled(musb))
 109                 musb_writel(reg_base, CORE_INTR_SRC_SET_REG,
 110                             AM35X_INTR_DRVVBUS << AM35X_INTR_USB_SHIFT);
 111 #ifdef __UBOOT__
 112         return 0;
 113 #endif
 114 }
 115
 116 /*
 117  * am35x_musb_disable - disable HDRC and flush interrupts
 118  */
 119 static void am35x_musb_disable(struct musb *musb)
 120 {
 121         void __iomem *reg_base = musb->ctrl_base;
 122
 123         musb_writel(reg_base, CORE_INTR_MASK_CLEAR_REG, AM35X_INTR_USB_MASK);
 124         musb_writel(reg_base, EP_INTR_MASK_CLEAR_REG,
 125                          AM35X_TX_INTR_MASK | AM35X_RX_INTR_MASK);
 126         musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
 127         musb_writel(reg_base, USB_END_OF_INTR_REG, 0);
 128 }
 129
 130 #ifndef __UBOOT__
 131 #define portstate(stmt)         stmt
 132
 133 static void am35x_musb_set_vbus(struct musb *musb, int is_on)
 134 {
 135         WARN_ON(is_on && is_peripheral_active(musb));
 136 }
 137
 138 #define POLL_SECONDS    2
 139
 140 static struct timer_list otg_workaround;
 141
 142 static void otg_timer(unsigned long _musb)
 143 {
 144         struct musb             *musb = (void *)_musb;
 145         void __iomem            *mregs = musb->mregs;
 146         u8                      devctl;
 147         unsigned long           flags;
 148
 149         /*
 150          * We poll because AM35x's won't expose several OTG-critical
 151          * status change events (from the transceiver) otherwise.
 152          */
 153         devctl = musb_readb(mregs, MUSB_DEVCTL);
 154         dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,
 155                 otg_state_string(musb->xceiv->state));
 156
 157         spin_lock_irqsave(&musb->lock, flags);
 158         switch (musb->xceiv->state) {
 159         case OTG_STATE_A_WAIT_BCON:
 160                 devctl &= ~MUSB_DEVCTL_SESSION;
 161                 musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 162
 163                 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 164                 if (devctl & MUSB_DEVCTL_BDEVICE) {
 165                         musb->xceiv->state = OTG_STATE_B_IDLE;
 166                         MUSB_DEV_MODE(musb);
 167                 } else {
 168                         musb->xceiv->state = OTG_STATE_A_IDLE;
 169                         MUSB_HST_MODE(musb);
 170                 }
 171                 break;
 172         case OTG_STATE_A_WAIT_VFALL:
 173                 musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
 174                 musb_writel(musb->ctrl_base, CORE_INTR_SRC_SET_REG,
 175                             MUSB_INTR_VBUSERROR << AM35X_INTR_USB_SHIFT);
 176                 break;
 177         case OTG_STATE_B_IDLE:
 178                 if (!is_peripheral_enabled(musb))
 179                         break;
 180
 181                 devctl = musb_readb(mregs, MUSB_DEVCTL);
 182                 if (devctl & MUSB_DEVCTL_BDEVICE)
 183                         mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 184                 else
 185                         musb->xceiv->state = OTG_STATE_A_IDLE;
 186                 break;
 187         default:
 188                 break;
 189         }
 190         spin_unlock_irqrestore(&musb->lock, flags);
 191 }
 192
 193 static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout)
 194 {
 195         static unsigned long last_timer;
 196
 197         if (!is_otg_enabled(musb))
 198                 return;
 199
 200         if (timeout == 0)
 201                 timeout = jiffies + msecs_to_jiffies(3);
 202
 203         /* Never idle if active, or when VBUS timeout is not set as host */
 204         if (musb->is_active || (musb->a_wait_bcon == 0 &&
 205                                 musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
 206                 dev_dbg(musb->controller, "%s active, deleting timer\n",
 207                         otg_state_string(musb->xceiv->state));
 208                 del_timer(&otg_workaround);
 209                 last_timer = jiffies;
 210                 return;
 211         }
 212
 213         if (time_after(last_timer, timeout) && timer_pending(&otg_workaround)) {
 214                 dev_dbg(musb->controller, "Longer idle timer already pending, ignoring...\n");
 215                 return;
 216         }
 217         last_timer = timeout;
 218
 219         dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n",
 220                 otg_state_string(musb->xceiv->state),
 221                 jiffies_to_msecs(timeout - jiffies));
 222         mod_timer(&otg_workaround, timeout);
 223 }
 224 #endif
 225
 226 static irqreturn_t am35x_musb_interrupt(int irq, void *hci)
 227 {
 228         struct musb  *musb = hci;
 229         void __iomem *reg_base = musb->ctrl_base;
 230 #ifndef __UBOOT__
 231         struct device *dev = musb->controller;
 232         struct musb_hdrc_platform_data *plat = dev->platform_data;
 233         struct omap_musb_board_data *data = plat->board_data;
 234         struct usb_otg *otg = musb->xceiv->otg;
 235 #else
 236         struct omap_musb_board_data *data =
 237                 (struct omap_musb_board_data *)musb->controller;
 238 #endif
 239         unsigned long flags;
 240         irqreturn_t ret = IRQ_NONE;
 241         u32 epintr, usbintr;
 242
 243 #ifdef __UBOOT__
 244         /*
 245          * It seems that on AM35X interrupt registers can be updated
 246          * before core registers. This confuses the code.
 247          * As a workaround add a small delay here.
 248          */
 249         udelay(10);
 250 #endif
 251         spin_lock_irqsave(&musb->lock, flags);
 252
 253         /* Get endpoint interrupts */
 254         epintr = musb_readl(reg_base, EP_INTR_SRC_MASKED_REG);
 255
 256         if (epintr) {
 257                 musb_writel(reg_base, EP_INTR_SRC_CLEAR_REG, epintr);
 258
 259                 musb->int_rx =
 260                         (epintr & AM35X_RX_INTR_MASK) >> AM35X_INTR_RX_SHIFT;
 261                 musb->int_tx =
 262                         (epintr & AM35X_TX_INTR_MASK) >> AM35X_INTR_TX_SHIFT;
 263         }
 264
 265         /* Get usb core interrupts */
 266         usbintr = musb_readl(reg_base, CORE_INTR_SRC_MASKED_REG);
 267         if (!usbintr && !epintr)
 268                 goto eoi;
 269
 270         if (usbintr) {
 271                 musb_writel(reg_base, CORE_INTR_SRC_CLEAR_REG, usbintr);
 272
 273                 musb->int_usb =
 274                         (usbintr & AM35X_INTR_USB_MASK) >> AM35X_INTR_USB_SHIFT;
 275         }
 276 #ifndef __UBOOT__
 277         /*
 278          * DRVVBUS IRQs are the only proxy we have (a very poor one!) for
 279          * AM35x's missing ID change IRQ.  We need an ID change IRQ to
 280          * switch appropriately between halves of the OTG state machine.
 281          * Managing DEVCTL.SESSION per Mentor docs requires that we know its
 282          * value but DEVCTL.BDEVICE is invalid without DEVCTL.SESSION set.
 283          * Also, DRVVBUS pulses for SRP (but not at 5V) ...
 284          */
 285         if (usbintr & (AM35X_INTR_DRVVBUS << AM35X_INTR_USB_SHIFT)) {
 286                 int drvvbus = musb_readl(reg_base, USB_STAT_REG);
 287                 void __iomem *mregs = musb->mregs;
 288                 u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
 289                 int err;
 290
 291                 err = is_host_enabled(musb) && (musb->int_usb &
 292                                                 MUSB_INTR_VBUSERROR);
 293                 if (err) {
 294                         /*
 295                          * The Mentor core doesn't debounce VBUS as needed
 296                          * to cope with device connect current spikes. This
 297                          * means it's not uncommon for bus-powered devices
 298                          * to get VBUS errors during enumeration.
 299                          *
 300                          * This is a workaround, but newer RTL from Mentor
 301                          * seems to allow a better one: "re"-starting sessions
 302                          * without waiting for VBUS to stop registering in
 303                          * devctl.
 304                          */
 305                         musb->int_usb &= ~MUSB_INTR_VBUSERROR;
 306                         musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
 307                         mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 308                         WARNING("VBUS error workaround (delay coming)\n");
 309                 } else if (is_host_enabled(musb) && drvvbus) {
 310                         MUSB_HST_MODE(musb);
 311                         otg->default_a = 1;
 312                         musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
 313                         portstate(musb->port1_status |= USB_PORT_STAT_POWER);
 314                         del_timer(&otg_workaround);
 315                 } else {
 316                         musb->is_active = 0;
 317                         MUSB_DEV_MODE(musb);
 318                         otg->default_a = 0;
 319                         musb->xceiv->state = OTG_STATE_B_IDLE;
 320                         portstate(musb->port1_status &= ~USB_PORT_STAT_POWER);
 321                 }
 322
 323                 /* NOTE: this must complete power-on within 100 ms. */
 324                 dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",
 325                                 drvvbus ? "on" : "off",
 326                                 otg_state_string(musb->xceiv->state),
 327                                 err ? " ERROR" : "",
 328                                 devctl);
 329                 ret = IRQ_HANDLED;
 330         }
 331 #endif
 332
 333         if (musb->int_tx || musb->int_rx || musb->int_usb)
 334                 ret |= musb_interrupt(musb);
 335
 336 eoi:
 337         /* EOI needs to be written for the IRQ to be re-asserted. */
 338         if (ret == IRQ_HANDLED || epintr || usbintr) {
 339                 /* clear level interrupt */
 340                 if (data->clear_irq)
 341                         data->clear_irq(data->dev);
 342                 /* write EOI */
 343                 musb_writel(reg_base, USB_END_OF_INTR_REG, 0);
 344         }
 345
 346 #ifndef __UBOOT__
 347         /* Poll for ID change */
 348         if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
 349                 mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 350 #endif
 351
 352         spin_unlock_irqrestore(&musb->lock, flags);
 353
 354         return ret;
 355 }
 356
 357 #ifndef __UBOOT__
 358 static int am35x_musb_set_mode(struct musb *musb, u8 musb_mode)
 359 {
 360         struct device *dev = musb->controller;
 361         struct musb_hdrc_platform_data *plat = dev->platform_data;
 362         struct omap_musb_board_data *data = plat->board_data;
 363         int     retval = 0;
 364
 365         if (data->set_mode)
 366                 data->set_mode(musb_mode);
 367         else
 368                 retval = -EIO;
 369
 370         return retval;
 371 }
 372 #endif
 373
 374 static int am35x_musb_init(struct musb *musb)
 375 {
 376 #ifndef __UBOOT__
 377         struct device *dev = musb->controller;
 378         struct musb_hdrc_platform_data *plat = dev->platform_data;
 379         struct omap_musb_board_data *data = plat->board_data;
 380 #else
 381         struct omap_musb_board_data *data =
 382                 (struct omap_musb_board_data *)musb->controller;
 383 #endif
 384         void __iomem *reg_base = musb->ctrl_base;
 385         u32 rev;
 386
 387         musb->mregs += USB_MENTOR_CORE_OFFSET;
 388
 389         /* Returns zero if e.g. not clocked */
 390         rev = musb_readl(reg_base, USB_REVISION_REG);
 391         if (!rev)
 392                 return -ENODEV;
 393
 394 #ifndef __UBOOT__
 395         usb_nop_xceiv_register();
 396         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
 397         if (IS_ERR_OR_NULL(musb->xceiv))
 398                 return -ENODEV;
 399
 400         if (is_host_enabled(musb))
 401                 setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
 402 #endif
 403
 404         /* Reset the musb */
 405         if (data->reset)
 406                 data->reset(data->dev);
 407
 408         /* Reset the controller */
 409         musb_writel(reg_base, USB_CTRL_REG, AM35X_SOFT_RESET_MASK);
 410
 411         /* Start the on-chip PHY and its PLL. */
 412         if (data && data->set_phy_power)
 413                 data->set_phy_power(data->dev, 1);
 414
 415         msleep(5);
 416
 417         musb->isr = am35x_musb_interrupt;
 418
 419         /* clear level interrupt */
 420         if (data->clear_irq)
 421                 data->clear_irq(data->dev);
 422
 423         return 0;
 424 }
 425
 426 static int am35x_musb_exit(struct musb *musb)
 427 {
 428 #ifndef __UBOOT__
 429         struct device *dev = musb->controller;
 430         struct musb_hdrc_platform_data *plat = dev->platform_data;
 431         struct omap_musb_board_data *data = plat->board_data;
 432 #else
 433         struct omap_musb_board_data *data =
 434                 (struct omap_musb_board_data *)musb->controller;
 435 #endif
 436
 437 #ifndef __UBOOT__
 438         if (is_host_enabled(musb))
 439                 del_timer_sync(&otg_workaround);
 440 #endif
 441
 442         /* Shutdown the on-chip PHY and its PLL. */
 443         if (data && data->set_phy_power)
 444                 data->set_phy_power(data->dev, 0);
 445
 446 #ifndef __UBOOT__
 447         usb_put_phy(musb->xceiv);
 448         usb_nop_xceiv_unregister();
 449 #endif
 450
 451         return 0;
 452 }
 453
 454 /* AM35x supports only 32bit read operation */
 455 void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
 456 {
 457         void __iomem *fifo = hw_ep->fifo;
 458         u32             val;
 459         int             i;
 460
 461         /* Read for 32bit-aligned destination address */
 462         if (likely((0x03 & (unsigned long) dst) == 0) && len >= 4) {
 463                 readsl(fifo, dst, len >> 2);
 464                 dst += len & ~0x03;
 465                 len &= 0x03;
 466         }
 467         /*
 468          * Now read the remaining 1 to 3 byte or complete length if
 469          * unaligned address.
 470          */
 471         if (len > 4) {
 472                 for (i = 0; i < (len >> 2); i++) {
 473                         *(u32 *) dst = musb_readl(fifo, 0);
 474                         dst += 4;
 475                 }
 476                 len &= 0x03;
 477         }
 478         if (len > 0) {
 479                 val = musb_readl(fifo, 0);
 480                 memcpy(dst, &val, len);
 481         }
 482 }
 483
 484 #ifndef __UBOOT__
 485 static const struct musb_platform_ops am35x_ops = {
 486 #else
 487 const struct musb_platform_ops am35x_ops = {
 488 #endif
 489         .init           = am35x_musb_init,
 490         .exit           = am35x_musb_exit,
 491
 492         .enable         = am35x_musb_enable,
 493         .disable        = am35x_musb_disable,
 494
 495 #ifndef __UBOOT__
 496         .set_mode       = am35x_musb_set_mode,
 497         .try_idle       = am35x_musb_try_idle,
 498
 499         .set_vbus       = am35x_musb_set_vbus,
 500 #endif
 501 };
 502
 503 #ifndef __UBOOT__
 504 static u64 am35x_dmamask = DMA_BIT_MASK(32);
 505
 506 static int __devinit am35x_probe(struct platform_device *pdev)
 507 {
 508         struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
 509         struct platform_device          *musb;
 510         struct am35x_glue               *glue;
 511
 512         struct clk                      *phy_clk;
 513         struct clk                      *clk;
 514
 515         int                             ret = -ENOMEM;
 516
 517         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
 518         if (!glue) {
 519                 dev_err(&pdev->dev, "failed to allocate glue context\n");
 520                 goto err0;
 521         }
 522
 523         musb = platform_device_alloc("musb-hdrc", -1);
 524         if (!musb) {
 525                 dev_err(&pdev->dev, "failed to allocate musb device\n");
 526                 goto err1;
 527         }
 528
 529         phy_clk = clk_get(&pdev->dev, "fck");
 530         if (IS_ERR(phy_clk)) {
 531                 dev_err(&pdev->dev, "failed to get PHY clock\n");
 532                 ret = PTR_ERR(phy_clk);
 533                 goto err2;
 534         }
 535
 536         clk = clk_get(&pdev->dev, "ick");
 537         if (IS_ERR(clk)) {
 538                 dev_err(&pdev->dev, "failed to get clock\n");
 539                 ret = PTR_ERR(clk);
 540                 goto err3;
 541         }
 542
 543         ret = clk_enable(phy_clk);
 544         if (ret) {
 545                 dev_err(&pdev->dev, "failed to enable PHY clock\n");
 546                 goto err4;
 547         }
 548
 549         ret = clk_enable(clk);
 550         if (ret) {
 551                 dev_err(&pdev->dev, "failed to enable clock\n");
 552                 goto err5;
 553         }
 554
 555         musb->dev.parent                = &pdev->dev;
 556         musb->dev.dma_mask              = &am35x_dmamask;
 557         musb->dev.coherent_dma_mask     = am35x_dmamask;
 558
 559         glue->dev                       = &pdev->dev;
 560         glue->musb                      = musb;
 561         glue->phy_clk                   = phy_clk;
 562         glue->clk                       = clk;
 563
 564         pdata->platform_ops             = &am35x_ops;
 565
 566         platform_set_drvdata(pdev, glue);
 567
 568         ret = platform_device_add_resources(musb, pdev->resource,
 569                         pdev->num_resources);
 570         if (ret) {
 571                 dev_err(&pdev->dev, "failed to add resources\n");
 572                 goto err6;
 573         }
 574
 575         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
 576         if (ret) {
 577                 dev_err(&pdev->dev, "failed to add platform_data\n");
 578                 goto err6;
 579         }
 580
 581         ret = platform_device_add(musb);
 582         if (ret) {
 583                 dev_err(&pdev->dev, "failed to register musb device\n");
 584                 goto err6;
 585         }
 586
 587         return 0;
 588
 589 err6:
 590         clk_disable(clk);
 591
 592 err5:
 593         clk_disable(phy_clk);
 594
 595 err4:
 596         clk_put(clk);
 597
 598 err3:
 599         clk_put(phy_clk);
 600
 601 err2:
 602         platform_device_put(musb);
 603
 604 err1:
 605         kfree(glue);
 606
 607 err0:
 608         return ret;
 609 }
 610
 611 static int __devexit am35x_remove(struct platform_device *pdev)
 612 {
 613         struct am35x_glue       *glue = platform_get_drvdata(pdev);
 614
 615         platform_device_del(glue->musb);
 616         platform_device_put(glue->musb);
 617         clk_disable(glue->clk);
 618         clk_disable(glue->phy_clk);
 619         clk_put(glue->clk);
 620         clk_put(glue->phy_clk);
 621         kfree(glue);
 622
 623         return 0;
 624 }
 625
 626 #ifdef CONFIG_PM
 627 static int am35x_suspend(struct device *dev)
 628 {
 629         struct am35x_glue       *glue = dev_get_drvdata(dev);
 630         struct musb_hdrc_platform_data *plat = dev->platform_data;
 631         struct omap_musb_board_data *data = plat->board_data;
 632
 633         /* Shutdown the on-chip PHY and its PLL. */
 634         if (data && data->set_phy_power)
 635                 data->set_phy_power(data->dev, 0);
 636
 637         clk_disable(glue->phy_clk);
 638         clk_disable(glue->clk);
 639
 640         return 0;
 641 }
 642
 643 static int am35x_resume(struct device *dev)
 644 {
 645         struct am35x_glue       *glue = dev_get_drvdata(dev);
 646         struct musb_hdrc_platform_data *plat = dev->platform_data;
 647         struct omap_musb_board_data *data = plat->board_data;
 648         int                     ret;
 649
 650         /* Start the on-chip PHY and its PLL. */
 651         if (data && data->set_phy_power)
 652                 data->set_phy_power(data->dev, 1);
 653
 654         ret = clk_enable(glue->phy_clk);
 655         if (ret) {
 656                 dev_err(dev, "failed to enable PHY clock\n");
 657                 return ret;
 658         }
 659
 660         ret = clk_enable(glue->clk);
 661         if (ret) {
 662                 dev_err(dev, "failed to enable clock\n");
 663                 return ret;
 664         }
 665
 666         return 0;
 667 }
 668
 669 static struct dev_pm_ops am35x_pm_ops = {
 670         .suspend        = am35x_suspend,
 671         .resume         = am35x_resume,
 672 };
 673
 674 #define DEV_PM_OPS      &am35x_pm_ops
 675 #else
 676 #define DEV_PM_OPS      NULL
 677 #endif
 678
 679 static struct platform_driver am35x_driver = {
 680         .probe          = am35x_probe,
 681         .remove         = __devexit_p(am35x_remove),
 682         .driver         = {
 683                 .name   = "musb-am35x",
 684                 .pm     = DEV_PM_OPS,
 685         },
 686 };
 687
 688 MODULE_DESCRIPTION("AM35x MUSB Glue Layer");
 689 MODULE_AUTHOR("Ajay Kumar Gupta <ajay.gupta@ti.com>");
 690 MODULE_LICENSE("GPL v2");
 691
 692 static int __init am35x_init(void)
 693 {
 694         return platform_driver_register(&am35x_driver);
 695 }
 696 module_init(am35x_init);
 697
 698 static void __exit am35x_exit(void)
 699 {
 700         platform_driver_unregister(&am35x_driver);
 701 }
 702 module_exit(am35x_exit);
 703 #endif