davinci.c 16.9 KB
Newer Older
F
Felipe Balbi 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
/*
 * Copyright (C) 2005-2006 by Texas Instruments
 *
 * This file is part of the Inventra Controller Driver for Linux.
 *
 * The Inventra Controller Driver for Linux is free software; you
 * can redistribute it and/or modify it under the terms of the GNU
 * General Public License version 2 as published by the Free Software
 * Foundation.
 *
 * The Inventra Controller Driver for Linux is distributed in
 * the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 * License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with The Inventra Controller Driver for Linux ; if not,
 * write to the Free Software Foundation, Inc., 59 Temple Place,
 * Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/io.h>
D
David Brownell 已提交
32
#include <linux/gpio.h>
33 34
#include <linux/platform_device.h>
#include <linux/dma-mapping.h>
F
Felipe Balbi 已提交
35

D
David Brownell 已提交
36 37
#include <mach/hardware.h>
#include <mach/memory.h>
38
#include <asm/gpio.h>
39
#include <mach/cputype.h>
D
David Brownell 已提交
40

F
Felipe Balbi 已提交
41 42 43 44 45
#include <asm/mach-types.h>

#include "musb_core.h"

#ifdef CONFIG_MACH_DAVINCI_EVM
46
#define GPIO_nVBUS_DRV		160
F
Felipe Balbi 已提交
47 48 49 50 51 52
#endif

#include "davinci.h"
#include "cppi_dma.h"


53 54 55
#define USB_PHY_CTRL	IO_ADDRESS(USBPHY_CTL_PADDR)
#define DM355_DEEPSLEEP	IO_ADDRESS(DM355_DEEPSLEEP_PADDR)

56 57 58
struct davinci_glue {
	struct device		*dev;
	struct platform_device	*musb;
59
	struct clk		*clk;
60 61
};

F
Felipe Balbi 已提交
62 63 64 65 66 67 68 69
/* REVISIT (PM) we should be able to keep the PHY in low power mode most
 * of the time (24 MHZ oscillator and PLL off, etc) by setting POWER.D0
 * and, when in host mode, autosuspending idle root ports... PHYPLLON
 * (overriding SUSPENDM?) then likely needs to stay off.
 */

static inline void phy_on(void)
{
70 71 72 73 74 75 76 77 78
	u32	phy_ctrl = __raw_readl(USB_PHY_CTRL);

	/* power everything up; start the on-chip PHY and its PLL */
	phy_ctrl &= ~(USBPHY_OSCPDWN | USBPHY_OTGPDWN | USBPHY_PHYPDWN);
	phy_ctrl |= USBPHY_SESNDEN | USBPHY_VBDTCTEN | USBPHY_PHYPLLON;
	__raw_writel(phy_ctrl, USB_PHY_CTRL);

	/* wait for PLL to lock before proceeding */
	while ((__raw_readl(USB_PHY_CTRL) & USBPHY_PHYCLKGD) == 0)
F
Felipe Balbi 已提交
79 80 81 82 83
		cpu_relax();
}

static inline void phy_off(void)
{
84 85 86 87 88 89
	u32	phy_ctrl = __raw_readl(USB_PHY_CTRL);

	/* powerdown the on-chip PHY, its PLL, and the OTG block */
	phy_ctrl &= ~(USBPHY_SESNDEN | USBPHY_VBDTCTEN | USBPHY_PHYPLLON);
	phy_ctrl |= USBPHY_OSCPDWN | USBPHY_OTGPDWN | USBPHY_PHYPDWN;
	__raw_writel(phy_ctrl, USB_PHY_CTRL);
F
Felipe Balbi 已提交
90 91 92 93
}

static int dma_off = 1;

94
static void davinci_musb_enable(struct musb *musb)
F
Felipe Balbi 已提交
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
{
	u32	tmp, old, val;

	/* workaround:  setup irqs through both register sets */
	tmp = (musb->epmask & DAVINCI_USB_TX_ENDPTS_MASK)
			<< DAVINCI_USB_TXINT_SHIFT;
	musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_SET_REG, tmp);
	old = tmp;
	tmp = (musb->epmask & (0xfffe & DAVINCI_USB_RX_ENDPTS_MASK))
			<< DAVINCI_USB_RXINT_SHIFT;
	musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_SET_REG, tmp);
	tmp |= old;

	val = ~MUSB_INTR_SOF;
	tmp |= ((val & 0x01ff) << DAVINCI_USB_USBINT_SHIFT);
	musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_SET_REG, tmp);

	if (is_dma_capable() && !dma_off)
		printk(KERN_WARNING "%s %s: dma not reactivated\n",
				__FILE__, __func__);
	else
		dma_off = 0;

	/* force a DRVVBUS irq so we can start polling for ID change */
	if (is_otg_enabled(musb))
		musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
			DAVINCI_INTR_DRVVBUS << DAVINCI_USB_USBINT_SHIFT);
}

/*
 * Disable the HDRC and flush interrupts
 */
127
static void davinci_musb_disable(struct musb *musb)
F
Felipe Balbi 已提交
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
{
	/* because we don't set CTRLR.UINT, "important" to:
	 *  - not read/write INTRUSB/INTRUSBE
	 *  - (except during initial setup, as workaround)
	 *  - use INTSETR/INTCLRR instead
	 */
	musb_writel(musb->ctrl_base, DAVINCI_USB_INT_MASK_CLR_REG,
			  DAVINCI_USB_USBINT_MASK
			| DAVINCI_USB_TXINT_MASK
			| DAVINCI_USB_RXINT_MASK);
	musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
	musb_writel(musb->ctrl_base, DAVINCI_USB_EOI_REG, 0);

	if (is_dma_capable() && !dma_off)
		WARNING("dma still active\n");
}


#define	portstate(stmt)		stmt

148 149 150 151 152 153 154 155
/*
 * VBUS SWITCHING IS BOARD-SPECIFIC ... at least for the DM6446 EVM,
 * which doesn't wire DRVVBUS to the FET that switches it.  Unclear
 * if that's a problem with the DM6446 chip or just with that board.
 *
 * In either case, the DM355 EVM automates DRVVBUS the normal way,
 * when J10 is out, and TI documents it as handling OTG.
 */
F
Felipe Balbi 已提交
156 157 158

#ifdef CONFIG_MACH_DAVINCI_EVM

159 160
static int vbus_state = -1;

F
Felipe Balbi 已提交
161 162 163 164 165 166
/* I2C operations are always synchronous, and require a task context.
 * With unloaded systems, using the shared workqueue seems to suffice
 * to satisfy the 100msec A_WAIT_VRISE timeout...
 */
static void evm_deferred_drvvbus(struct work_struct *ignored)
{
D
David Brownell 已提交
167
	gpio_set_value_cansleep(GPIO_nVBUS_DRV, vbus_state);
F
Felipe Balbi 已提交
168 169 170 171 172
	vbus_state = !vbus_state;
}

#endif	/* EVM */

173
static void davinci_musb_source_power(struct musb *musb, int is_on, int immediate)
F
Felipe Balbi 已提交
174
{
175
#ifdef CONFIG_MACH_DAVINCI_EVM
F
Felipe Balbi 已提交
176 177 178 179 180 181 182 183
	if (is_on)
		is_on = 1;

	if (vbus_state == is_on)
		return;
	vbus_state = !is_on;		/* 0/1 vs "-1 == unknown/init" */

	if (machine_is_davinci_evm()) {
184 185
		static DECLARE_WORK(evm_vbus_work, evm_deferred_drvvbus);

F
Felipe Balbi 已提交
186
		if (immediate)
D
David Brownell 已提交
187
			gpio_set_value_cansleep(GPIO_nVBUS_DRV, vbus_state);
F
Felipe Balbi 已提交
188 189 190 191 192
		else
			schedule_work(&evm_vbus_work);
	}
	if (immediate)
		vbus_state = is_on;
193
#endif
F
Felipe Balbi 已提交
194 195
}

196
static void davinci_musb_set_vbus(struct musb *musb, int is_on)
F
Felipe Balbi 已提交
197 198
{
	WARN_ON(is_on && is_peripheral_active(musb));
199
	davinci_musb_source_power(musb, is_on, 0);
F
Felipe Balbi 已提交
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
}


#define	POLL_SECONDS	2

static struct timer_list otg_workaround;

static void otg_timer(unsigned long _musb)
{
	struct musb		*musb = (void *)_musb;
	void __iomem		*mregs = musb->mregs;
	u8			devctl;
	unsigned long		flags;

	/* We poll because DaVinci's won't expose several OTG-critical
	* status change events (from the transceiver) otherwise.
	 */
	devctl = musb_readb(mregs, MUSB_DEVCTL);
218
	dev_dbg(musb->controller, "poll devctl %02x (%s)\n", devctl,
219
		otg_state_string(musb->xceiv->state));
F
Felipe Balbi 已提交
220 221

	spin_lock_irqsave(&musb->lock, flags);
222
	switch (musb->xceiv->state) {
F
Felipe Balbi 已提交
223 224 225 226 227 228 229 230 231 232
	case OTG_STATE_A_WAIT_VFALL:
		/* Wait till VBUS falls below SessionEnd (~0.2V); the 1.3 RTL
		 * seems to mis-handle session "start" otherwise (or in our
		 * case "recover"), in routine "VBUS was valid by the time
		 * VBUSERR got reported during enumeration" cases.
		 */
		if (devctl & MUSB_DEVCTL_VBUS) {
			mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
			break;
		}
233
		musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
F
Felipe Balbi 已提交
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
		musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
			MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT);
		break;
	case OTG_STATE_B_IDLE:
		if (!is_peripheral_enabled(musb))
			break;

		/* There's no ID-changed IRQ, so we have no good way to tell
		 * when to switch to the A-Default state machine (by setting
		 * the DEVCTL.SESSION flag).
		 *
		 * Workaround:  whenever we're in B_IDLE, try setting the
		 * session flag every few seconds.  If it works, ID was
		 * grounded and we're now in the A-Default state machine.
		 *
		 * NOTE setting the session flag is _supposed_ to trigger
		 * SRP, but clearly it doesn't.
		 */
		musb_writeb(mregs, MUSB_DEVCTL,
				devctl | MUSB_DEVCTL_SESSION);
		devctl = musb_readb(mregs, MUSB_DEVCTL);
		if (devctl & MUSB_DEVCTL_BDEVICE)
			mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
		else
258
			musb->xceiv->state = OTG_STATE_A_IDLE;
F
Felipe Balbi 已提交
259 260 261 262 263 264 265
		break;
	default:
		break;
	}
	spin_unlock_irqrestore(&musb->lock, flags);
}

266
static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
F
Felipe Balbi 已提交
267 268 269 270 271
{
	unsigned long	flags;
	irqreturn_t	retval = IRQ_NONE;
	struct musb	*musb = __hci;
	void __iomem	*tibase = musb->ctrl_base;
272
	struct cppi	*cppi;
F
Felipe Balbi 已提交
273 274 275 276 277 278 279
	u32		tmp;

	spin_lock_irqsave(&musb->lock, flags);

	/* NOTE: DaVinci shadows the Mentor IRQs.  Don't manage them through
	 * the Mentor registers (except for setup), use the TI ones and EOI.
	 *
280
	 * Docs describe irq "vector" registers associated with the CPPI and
F
Felipe Balbi 已提交
281 282 283 284 285 286 287 288
	 * USB EOI registers.  These hold a bitmask corresponding to the
	 * current IRQ, not an irq handler address.  Would using those bits
	 * resolve some of the races observed in this dispatch code??
	 */

	/* CPPI interrupts share the same IRQ line, but have their own
	 * mask, state, "vector", and EOI registers.
	 */
289 290 291
	cppi = container_of(musb->dma_controller, struct cppi, controller);
	if (is_cppi_enabled() && musb->dma_controller && !cppi->irq)
		retval = cppi_interrupt(irq, __hci);
F
Felipe Balbi 已提交
292 293 294 295

	/* ack and handle non-CPPI interrupts */
	tmp = musb_readl(tibase, DAVINCI_USB_INT_SRC_MASKED_REG);
	musb_writel(tibase, DAVINCI_USB_INT_SRC_CLR_REG, tmp);
296
	dev_dbg(musb->controller, "IRQ %08x\n", tmp);
F
Felipe Balbi 已提交
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331

	musb->int_rx = (tmp & DAVINCI_USB_RXINT_MASK)
			>> DAVINCI_USB_RXINT_SHIFT;
	musb->int_tx = (tmp & DAVINCI_USB_TXINT_MASK)
			>> DAVINCI_USB_TXINT_SHIFT;
	musb->int_usb = (tmp & DAVINCI_USB_USBINT_MASK)
			>> DAVINCI_USB_USBINT_SHIFT;

	/* DRVVBUS irqs are the only proxy we have (a very poor one!) for
	 * DaVinci's missing ID change IRQ.  We need an ID change IRQ to
	 * switch appropriately between halves of the OTG state machine.
	 * Managing DEVCTL.SESSION per Mentor docs requires we know its
	 * value, but DEVCTL.BDEVICE is invalid without DEVCTL.SESSION set.
	 * Also, DRVVBUS pulses for SRP (but not at 5V) ...
	 */
	if (tmp & (DAVINCI_INTR_DRVVBUS << DAVINCI_USB_USBINT_SHIFT)) {
		int	drvvbus = musb_readl(tibase, DAVINCI_USB_STAT_REG);
		void __iomem *mregs = musb->mregs;
		u8	devctl = musb_readb(mregs, MUSB_DEVCTL);
		int	err = musb->int_usb & MUSB_INTR_VBUSERROR;

		err = is_host_enabled(musb)
				&& (musb->int_usb & MUSB_INTR_VBUSERROR);
		if (err) {
			/* The Mentor core doesn't debounce VBUS as needed
			 * to cope with device connect current spikes. This
			 * means it's not uncommon for bus-powered devices
			 * to get VBUS errors during enumeration.
			 *
			 * This is a workaround, but newer RTL from Mentor
			 * seems to allow a better one: "re"starting sessions
			 * without waiting (on EVM, a **long** time) for VBUS
			 * to stop registering in devctl.
			 */
			musb->int_usb &= ~MUSB_INTR_VBUSERROR;
332
			musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
F
Felipe Balbi 已提交
333 334 335 336
			mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
			WARNING("VBUS error workaround (delay coming)\n");
		} else if (is_host_enabled(musb) && drvvbus) {
			MUSB_HST_MODE(musb);
337 338
			musb->xceiv->default_a = 1;
			musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
F
Felipe Balbi 已提交
339 340 341 342 343
			portstate(musb->port1_status |= USB_PORT_STAT_POWER);
			del_timer(&otg_workaround);
		} else {
			musb->is_active = 0;
			MUSB_DEV_MODE(musb);
344 345
			musb->xceiv->default_a = 0;
			musb->xceiv->state = OTG_STATE_B_IDLE;
F
Felipe Balbi 已提交
346 347 348
			portstate(musb->port1_status &= ~USB_PORT_STAT_POWER);
		}

349 350 351
		/* NOTE:  this must complete poweron within 100 msec
		 * (OTG_TIME_A_WAIT_VRISE) but we don't check for that.
		 */
352
		davinci_musb_source_power(musb, drvvbus, 0);
353
		dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n",
F
Felipe Balbi 已提交
354
				drvvbus ? "on" : "off",
355
				otg_state_string(musb->xceiv->state),
F
Felipe Balbi 已提交
356 357 358 359 360 361 362 363 364 365 366 367 368
				err ? " ERROR" : "",
				devctl);
		retval = IRQ_HANDLED;
	}

	if (musb->int_tx || musb->int_rx || musb->int_usb)
		retval |= musb_interrupt(musb);

	/* irq stays asserted until EOI is written */
	musb_writel(tibase, DAVINCI_USB_EOI_REG, 0);

	/* poll for ID change */
	if (is_otg_enabled(musb)
369
			&& musb->xceiv->state == OTG_STATE_B_IDLE)
F
Felipe Balbi 已提交
370 371 372 373
		mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);

	spin_unlock_irqrestore(&musb->lock, flags);

374
	return retval;
F
Felipe Balbi 已提交
375 376
}

377
static int davinci_musb_set_mode(struct musb *musb, u8 mode)
D
David Brownell 已提交
378 379 380 381 382
{
	/* EVM can't do this (right?) */
	return -EIO;
}

383
static int davinci_musb_init(struct musb *musb)
F
Felipe Balbi 已提交
384 385 386 387
{
	void __iomem	*tibase = musb->ctrl_base;
	u32		revision;

388 389 390 391 392
	usb_nop_xceiv_register();
	musb->xceiv = otg_get_transceiver();
	if (!musb->xceiv)
		return -ENODEV;

F
Felipe Balbi 已提交
393 394 395 396 397
	musb->mregs += DAVINCI_BASE_OFFSET;

	/* returns zero if e.g. not clocked */
	revision = musb_readl(tibase, DAVINCI_USB_VERSION_REG);
	if (revision == 0)
398
		goto fail;
F
Felipe Balbi 已提交
399 400 401 402

	if (is_host_enabled(musb))
		setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);

403
	davinci_musb_source_power(musb, 0, 1);
F
Felipe Balbi 已提交
404

405 406 407 408 409 410 411 412 413 414 415
	/* dm355 EVM swaps D+/D- for signal integrity, and
	 * is clocked from the main 24 MHz crystal.
	 */
	if (machine_is_davinci_dm355_evm()) {
		u32	phy_ctrl = __raw_readl(USB_PHY_CTRL);

		phy_ctrl &= ~(3 << 9);
		phy_ctrl |= USBPHY_DATAPOL;
		__raw_writel(phy_ctrl, USB_PHY_CTRL);
	}

416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
	/* On dm355, the default-A state machine needs DRVVBUS control.
	 * If we won't be a host, there's no need to turn it on.
	 */
	if (cpu_is_davinci_dm355()) {
		u32	deepsleep = __raw_readl(DM355_DEEPSLEEP);

		if (is_host_enabled(musb)) {
			deepsleep &= ~DRVVBUS_OVERRIDE;
		} else {
			deepsleep &= ~DRVVBUS_FORCE;
			deepsleep |= DRVVBUS_OVERRIDE;
		}
		__raw_writel(deepsleep, DM355_DEEPSLEEP);
	}

F
Felipe Balbi 已提交
431 432 433 434 435 436 437 438 439 440
	/* reset the controller */
	musb_writel(tibase, DAVINCI_USB_CTRL_REG, 0x1);

	/* start the on-chip PHY and its PLL */
	phy_on();

	msleep(5);

	/* NOTE:  irqs are in mixed mode, not bypass to pure-musb */
	pr_debug("DaVinci OTG revision %08x phy %03x control %02x\n",
441
		revision, __raw_readl(USB_PHY_CTRL),
F
Felipe Balbi 已提交
442 443
		musb_readb(tibase, DAVINCI_USB_CTRL_REG));

444
	musb->isr = davinci_musb_interrupt;
F
Felipe Balbi 已提交
445
	return 0;
446 447

fail:
448
	otg_put_transceiver(musb->xceiv);
449 450
	usb_nop_xceiv_unregister();
	return -ENODEV;
F
Felipe Balbi 已提交
451 452
}

453
static int davinci_musb_exit(struct musb *musb)
F
Felipe Balbi 已提交
454 455 456 457
{
	if (is_host_enabled(musb))
		del_timer_sync(&otg_workaround);

458 459 460 461 462 463 464 465 466
	/* force VBUS off */
	if (cpu_is_davinci_dm355()) {
		u32	deepsleep = __raw_readl(DM355_DEEPSLEEP);

		deepsleep &= ~DRVVBUS_FORCE;
		deepsleep |= DRVVBUS_OVERRIDE;
		__raw_writel(deepsleep, DM355_DEEPSLEEP);
	}

467
	davinci_musb_source_power(musb, 0 /*off*/, 1);
F
Felipe Balbi 已提交
468 469

	/* delay, to avoid problems with module reload */
470
	if (is_host_enabled(musb) && musb->xceiv->default_a) {
F
Felipe Balbi 已提交
471 472 473 474 475 476 477 478 479 480 481 482
		int	maxdelay = 30;
		u8	devctl, warn = 0;

		/* if there's no peripheral connected, this can take a
		 * long time to fall, especially on EVM with huge C133.
		 */
		do {
			devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
			if (!(devctl & MUSB_DEVCTL_VBUS))
				break;
			if ((devctl & MUSB_DEVCTL_VBUS) != warn) {
				warn = devctl & MUSB_DEVCTL_VBUS;
483
				dev_dbg(musb->controller, "VBUS %d\n",
F
Felipe Balbi 已提交
484 485 486 487 488 489 490 491
					warn >> MUSB_DEVCTL_VBUS_SHIFT);
			}
			msleep(1000);
			maxdelay--;
		} while (maxdelay > 0);

		/* in OTG mode, another host might be connected */
		if (devctl & MUSB_DEVCTL_VBUS)
492
			dev_dbg(musb->controller, "VBUS off timeout (devctl %02x)\n", devctl);
F
Felipe Balbi 已提交
493 494 495
	}

	phy_off();
496

497
	otg_put_transceiver(musb->xceiv);
498 499
	usb_nop_xceiv_unregister();

F
Felipe Balbi 已提交
500 501
	return 0;
}
502

503
static const struct musb_platform_ops davinci_ops = {
504 505 506 507 508 509 510 511 512 513
	.init		= davinci_musb_init,
	.exit		= davinci_musb_exit,

	.enable		= davinci_musb_enable,
	.disable	= davinci_musb_disable,

	.set_mode	= davinci_musb_set_mode,

	.set_vbus	= davinci_musb_set_vbus,
};
514 515 516 517 518 519 520

static u64 davinci_dmamask = DMA_BIT_MASK(32);

static int __init davinci_probe(struct platform_device *pdev)
{
	struct musb_hdrc_platform_data	*pdata = pdev->dev.platform_data;
	struct platform_device		*musb;
521
	struct davinci_glue		*glue;
522
	struct clk			*clk;
523 524 525

	int				ret = -ENOMEM;

526 527 528 529 530 531
	glue = kzalloc(sizeof(*glue), GFP_KERNEL);
	if (!glue) {
		dev_err(&pdev->dev, "failed to allocate glue context\n");
		goto err0;
	}

532 533 534
	musb = platform_device_alloc("musb-hdrc", -1);
	if (!musb) {
		dev_err(&pdev->dev, "failed to allocate musb device\n");
535
		goto err1;
536 537
	}

538 539 540 541 542 543 544 545 546 547 548 549 550
	clk = clk_get(&pdev->dev, "usb");
	if (IS_ERR(clk)) {
		dev_err(&pdev->dev, "failed to get clock\n");
		ret = PTR_ERR(clk);
		goto err2;
	}

	ret = clk_enable(clk);
	if (ret) {
		dev_err(&pdev->dev, "failed to enable clock\n");
		goto err3;
	}

551 552 553 554
	musb->dev.parent		= &pdev->dev;
	musb->dev.dma_mask		= &davinci_dmamask;
	musb->dev.coherent_dma_mask	= davinci_dmamask;

555 556
	glue->dev			= &pdev->dev;
	glue->musb			= musb;
557
	glue->clk			= clk;
558

559 560
	pdata->platform_ops		= &davinci_ops;

561
	platform_set_drvdata(pdev, glue);
562 563 564 565 566

	ret = platform_device_add_resources(musb, pdev->resource,
			pdev->num_resources);
	if (ret) {
		dev_err(&pdev->dev, "failed to add resources\n");
567
		goto err4;
568 569 570 571 572
	}

	ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
	if (ret) {
		dev_err(&pdev->dev, "failed to add platform_data\n");
573
		goto err4;
574 575 576 577 578
	}

	ret = platform_device_add(musb);
	if (ret) {
		dev_err(&pdev->dev, "failed to register musb device\n");
579
		goto err4;
580 581 582 583
	}

	return 0;

584 585 586 587 588 589
err4:
	clk_disable(clk);

err3:
	clk_put(clk);

590
err2:
591 592
	platform_device_put(musb);

593 594 595
err1:
	kfree(glue);

596 597 598 599 600 601
err0:
	return ret;
}

static int __exit davinci_remove(struct platform_device *pdev)
{
602
	struct davinci_glue		*glue = platform_get_drvdata(pdev);
603

604 605
	platform_device_del(glue->musb);
	platform_device_put(glue->musb);
606 607
	clk_disable(glue->clk);
	clk_put(glue->clk);
608
	kfree(glue);
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634

	return 0;
}

static struct platform_driver davinci_driver = {
	.remove		= __exit_p(davinci_remove),
	.driver		= {
		.name	= "musb-davinci",
	},
};

MODULE_DESCRIPTION("DaVinci MUSB Glue Layer");
MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
MODULE_LICENSE("GPL v2");

static int __init davinci_init(void)
{
	return platform_driver_probe(&davinci_driver, davinci_probe);
}
subsys_initcall(davinci_init);

static void __exit davinci_exit(void)
{
	platform_driver_unregister(&davinci_driver);
}
module_exit(davinci_exit);