[mirror_ubuntu-bionic-kernel.git] / drivers / usb / musb / omap2430.c

/*
 * Copyright (C) 2005-2007 by Texas Instruments
 * Some code has been taken from tusb6010.c
 * Copyrights for that are attributable to:
 * Copyright (C) 2006 Nokia Corporation
 * Tony Lindgren <tony@atomide.com>
 *
 * 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/io.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/dma-mapping.h>
#include <linux/pm_runtime.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/usb/musb.h>
#include <linux/phy/omap_control_phy.h>
#include <linux/of_platform.h>

#include "musb_core.h"
#include "omap2430.h"

struct omap2430_glue {
	struct device		*dev;
	struct platform_device	*musb;
	enum musb_vbus_id_status status;
	struct work_struct	omap_musb_mailbox_work;
	struct device		*control_otghs;
};
#define glue_to_musb(g)		platform_get_drvdata(g->musb)

static struct omap2430_glue	*_glue;

static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
{
	struct usb_otg	*otg = musb->xceiv->otg;
	u8		devctl;
	unsigned long timeout = jiffies + msecs_to_jiffies(1000);
	/* HDRC controls CPEN, but beware current surges during device
	 * connect.  They can trigger transient overcurrent conditions
	 * that must be ignored.
	 */

	devctl = musb_readb(musb->mregs, MUSB_DEVCTL);

	if (is_on) {
		if (musb->xceiv->otg->state == OTG_STATE_A_IDLE) {
			int loops = 100;
			/* start the session */
			devctl |= MUSB_DEVCTL_SESSION;
			musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
			/*
			 * Wait for the musb to set as A device to enable the
			 * VBUS
			 */
			while (musb_readb(musb->mregs, MUSB_DEVCTL) &
			       MUSB_DEVCTL_BDEVICE) {

				mdelay(5);
				cpu_relax();

				if (time_after(jiffies, timeout)
				    || loops-- <= 0) {
					dev_err(musb->controller,
					"configured as A device timeout");
					break;
				}
			}

			otg_set_vbus(otg, 1);
		} else {
			musb->is_active = 1;
			otg->default_a = 1;
			musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
			devctl |= MUSB_DEVCTL_SESSION;
			MUSB_HST_MODE(musb);
		}
	} else {
		musb->is_active = 0;

		/* NOTE:  we're skipping A_WAIT_VFALL -> A_IDLE and
		 * jumping right to B_IDLE...
		 */

		otg->default_a = 0;
		musb->xceiv->otg->state = OTG_STATE_B_IDLE;
		devctl &= ~MUSB_DEVCTL_SESSION;

		MUSB_DEV_MODE(musb);
	}
	musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);

	dev_dbg(musb->controller, "VBUS %s, devctl %02x "
		/* otg %3x conf %08x prcm %08x */ "\n",
		usb_otg_state_string(musb->xceiv->otg->state),
		musb_readb(musb->mregs, MUSB_DEVCTL));
}

static inline void omap2430_low_level_exit(struct musb *musb)
{
	u32 l;

	/* in any role */
	l = musb_readl(musb->mregs, OTG_FORCESTDBY);
	l |= ENABLEFORCE;	/* enable MSTANDBY */
	musb_writel(musb->mregs, OTG_FORCESTDBY, l);
}

static inline void omap2430_low_level_init(struct musb *musb)
{
	u32 l;

	l = musb_readl(musb->mregs, OTG_FORCESTDBY);
	l &= ~ENABLEFORCE;	/* disable MSTANDBY */
	musb_writel(musb->mregs, OTG_FORCESTDBY, l);
}

static int omap2430_musb_mailbox(enum musb_vbus_id_status status)
{
	struct omap2430_glue	*glue = _glue;

	if (!glue) {
		pr_err("%s: musb core is not yet initialized\n", __func__);
		return -EPROBE_DEFER;
	}
	glue->status = status;

	if (!glue_to_musb(glue)) {
		pr_err("%s: musb core is not yet ready\n", __func__);
		return -EPROBE_DEFER;
	}

	schedule_work(&glue->omap_musb_mailbox_work);

	return 0;
}

static void omap_musb_set_mailbox(struct omap2430_glue *glue)
{
	struct musb *musb = glue_to_musb(glue);
	struct musb_hdrc_platform_data *pdata =
		dev_get_platdata(musb->controller);
	struct omap_musb_board_data *data = pdata->board_data;
	struct usb_otg *otg = musb->xceiv->otg;

	pm_runtime_get_sync(musb->controller);
	switch (glue->status) {
	case MUSB_ID_GROUND:
		dev_dbg(musb->controller, "ID GND\n");

		otg->default_a = true;
		musb->xceiv->otg->state = OTG_STATE_A_IDLE;
		musb->xceiv->last_event = USB_EVENT_ID;
		if (musb->gadget_driver) {
			omap_control_usb_set_mode(glue->control_otghs,
				USB_MODE_HOST);
			omap2430_musb_set_vbus(musb, 1);
		}
		break;

	case MUSB_VBUS_VALID:
		dev_dbg(musb->controller, "VBUS Connect\n");

		otg->default_a = false;
		musb->xceiv->otg->state = OTG_STATE_B_IDLE;
		musb->xceiv->last_event = USB_EVENT_VBUS;
		omap_control_usb_set_mode(glue->control_otghs, USB_MODE_DEVICE);
		break;

	case MUSB_ID_FLOAT:
	case MUSB_VBUS_OFF:
		dev_dbg(musb->controller, "VBUS Disconnect\n");

		musb->xceiv->last_event = USB_EVENT_NONE;
		if (musb->gadget_driver)
			omap2430_musb_set_vbus(musb, 0);

		if (data->interface_type == MUSB_INTERFACE_UTMI)
			otg_set_vbus(musb->xceiv->otg, 0);

		omap_control_usb_set_mode(glue->control_otghs,
			USB_MODE_DISCONNECT);
		break;
	default:
		dev_dbg(musb->controller, "ID float\n");
	}
	pm_runtime_mark_last_busy(musb->controller);
	pm_runtime_put_autosuspend(musb->controller);
	atomic_notifier_call_chain(&musb->xceiv->notifier,
			musb->xceiv->last_event, NULL);
}


static void omap_musb_mailbox_work(struct work_struct *mailbox_work)
{
	struct omap2430_glue *glue = container_of(mailbox_work,
				struct omap2430_glue, omap_musb_mailbox_work);

	omap_musb_set_mailbox(glue);
}

static irqreturn_t omap2430_musb_interrupt(int irq, void *__hci)
{
	unsigned long   flags;
	irqreturn_t     retval = IRQ_NONE;
	struct musb     *musb = __hci;

	spin_lock_irqsave(&musb->lock, flags);

	musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
	musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
	musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);

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

	spin_unlock_irqrestore(&musb->lock, flags);

	return retval;
}

static int omap2430_musb_init(struct musb *musb)
{
	u32 l;
	int status = 0;
	struct device *dev = musb->controller;
	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
	struct musb_hdrc_platform_data *plat = dev_get_platdata(dev);
	struct omap_musb_board_data *data = plat->board_data;

	/* We require some kind of external transceiver, hooked
	 * up through ULPI.  TWL4030-family PMICs include one,
	 * which needs a driver, drivers aren't always needed.
	 */
	if (dev->parent->of_node) {
		musb->phy = devm_phy_get(dev->parent, "usb2-phy");

		/* We can't totally remove musb->xceiv as of now because
		 * musb core uses xceiv.state and xceiv.otg. Once we have
		 * a separate state machine to handle otg, these can be moved
		 * out of xceiv and then we can start using the generic PHY
		 * framework
		 */
		musb->xceiv = devm_usb_get_phy_by_phandle(dev->parent,
		    "usb-phy", 0);
	} else {
		musb->xceiv = devm_usb_get_phy_dev(dev, 0);
		musb->phy = devm_phy_get(dev, "usb");
	}

	if (IS_ERR(musb->xceiv)) {
		status = PTR_ERR(musb->xceiv);

		if (status == -ENXIO)
			return status;

		dev_dbg(dev, "HS USB OTG: no transceiver configured\n");
		return -EPROBE_DEFER;
	}

	if (IS_ERR(musb->phy)) {
		dev_err(dev, "HS USB OTG: no PHY configured\n");
		return PTR_ERR(musb->phy);
	}
	musb->isr = omap2430_musb_interrupt;
	phy_init(musb->phy);
	phy_power_on(musb->phy);

	l = musb_readl(musb->mregs, OTG_INTERFSEL);

	if (data->interface_type == MUSB_INTERFACE_UTMI) {
		/* OMAP4 uses Internal PHY GS70 which uses UTMI interface */
		l &= ~ULPI_12PIN;       /* Disable ULPI */
		l |= UTMI_8BIT;         /* Enable UTMI  */
	} else {
		l |= ULPI_12PIN;
	}

	musb_writel(musb->mregs, OTG_INTERFSEL, l);

	dev_dbg(dev, "HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
			"sysstatus 0x%x, intrfsel 0x%x, simenable  0x%x\n",
			musb_readl(musb->mregs, OTG_REVISION),
			musb_readl(musb->mregs, OTG_SYSCONFIG),
			musb_readl(musb->mregs, OTG_SYSSTATUS),
			musb_readl(musb->mregs, OTG_INTERFSEL),
			musb_readl(musb->mregs, OTG_SIMENABLE));

	if (glue->status != MUSB_UNKNOWN)
		omap_musb_set_mailbox(glue);

	return 0;
}

static void omap2430_musb_enable(struct musb *musb)
{
	u8		devctl;
	unsigned long timeout = jiffies + msecs_to_jiffies(1000);
	struct device *dev = musb->controller;
	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
	struct musb_hdrc_platform_data *pdata = dev_get_platdata(dev);
	struct omap_musb_board_data *data = pdata->board_data;


	switch (glue->status) {

	case MUSB_ID_GROUND:
		omap_control_usb_set_mode(glue->control_otghs, USB_MODE_HOST);
		if (data->interface_type != MUSB_INTERFACE_UTMI)
			break;
		devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
		/* start the session */
		devctl |= MUSB_DEVCTL_SESSION;
		musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
		while (musb_readb(musb->mregs, MUSB_DEVCTL) &
				MUSB_DEVCTL_BDEVICE) {
			cpu_relax();

			if (time_after(jiffies, timeout)) {
				dev_err(dev, "configured as A device timeout");
				break;
			}
		}
		break;

	case MUSB_VBUS_VALID:
		omap_control_usb_set_mode(glue->control_otghs, USB_MODE_DEVICE);
		break;

	default:
		break;
	}
}

static void omap2430_musb_disable(struct musb *musb)
{
	struct device *dev = musb->controller;
	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);

	if (glue->status != MUSB_UNKNOWN)
		omap_control_usb_set_mode(glue->control_otghs,
			USB_MODE_DISCONNECT);
}

static int omap2430_musb_exit(struct musb *musb)
{
	struct device *dev = musb->controller;
	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);

	omap2430_low_level_exit(musb);
	phy_power_off(musb->phy);
	phy_exit(musb->phy);
	musb->phy = NULL;
	cancel_work_sync(&glue->omap_musb_mailbox_work);

	return 0;
}

static const struct musb_platform_ops omap2430_ops = {
	.quirks		= MUSB_DMA_INVENTRA,
#ifdef CONFIG_USB_INVENTRA_DMA
	.dma_init	= musbhs_dma_controller_create,
	.dma_exit	= musbhs_dma_controller_destroy,
#endif
	.init		= omap2430_musb_init,
	.exit		= omap2430_musb_exit,

	.set_vbus	= omap2430_musb_set_vbus,

	.enable		= omap2430_musb_enable,
	.disable	= omap2430_musb_disable,

	.phy_callback	= omap2430_musb_mailbox,
};

static u64 omap2430_dmamask = DMA_BIT_MASK(32);

static int omap2430_probe(struct platform_device *pdev)
{
	struct resource			musb_resources[3];
	struct musb_hdrc_platform_data	*pdata = dev_get_platdata(&pdev->dev);
	struct omap_musb_board_data	*data;
	struct platform_device		*musb;
	struct omap2430_glue		*glue;
	struct device_node		*np = pdev->dev.of_node;
	struct musb_hdrc_config		*config;
	int				ret = -ENOMEM, val;

	glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL);
	if (!glue)
		goto err0;

	musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
	if (!musb) {
		dev_err(&pdev->dev, "failed to allocate musb device\n");
		goto err0;
	}

	musb->dev.parent		= &pdev->dev;
	musb->dev.dma_mask		= &omap2430_dmamask;
	musb->dev.coherent_dma_mask	= omap2430_dmamask;

	glue->dev			= &pdev->dev;
	glue->musb			= musb;
	glue->status			= MUSB_UNKNOWN;
	glue->control_otghs = ERR_PTR(-ENODEV);

	if (np) {
		struct device_node *control_node;
		struct platform_device *control_pdev;

		pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
		if (!pdata)
			goto err2;

		data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
		if (!data)
			goto err2;

		config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
		if (!config)
			goto err2;

		of_property_read_u32(np, "mode", (u32 *)&pdata->mode);
		of_property_read_u32(np, "interface-type",
						(u32 *)&data->interface_type);
		of_property_read_u32(np, "num-eps", (u32 *)&config->num_eps);
		of_property_read_u32(np, "ram-bits", (u32 *)&config->ram_bits);
		of_property_read_u32(np, "power", (u32 *)&pdata->power);

		ret = of_property_read_u32(np, "multipoint", &val);
		if (!ret && val)
			config->multipoint = true;

		pdata->board_data	= data;
		pdata->config		= config;

		control_node = of_parse_phandle(np, "ctrl-module", 0);
		if (control_node) {
			control_pdev = of_find_device_by_node(control_node);
			if (!control_pdev) {
				dev_err(&pdev->dev, "Failed to get control device\n");
				ret = -EINVAL;
				goto err2;
			}
			glue->control_otghs = &control_pdev->dev;
		}
	}
	pdata->platform_ops		= &omap2430_ops;

	platform_set_drvdata(pdev, glue);

	/*
	 * REVISIT if we ever have two instances of the wrapper, we will be
	 * in big trouble
	 */
	_glue	= glue;

	INIT_WORK(&glue->omap_musb_mailbox_work, omap_musb_mailbox_work);

	memset(musb_resources, 0x00, sizeof(*musb_resources) *
			ARRAY_SIZE(musb_resources));

	musb_resources[0].name = pdev->resource[0].name;
	musb_resources[0].start = pdev->resource[0].start;
	musb_resources[0].end = pdev->resource[0].end;
	musb_resources[0].flags = pdev->resource[0].flags;

	musb_resources[1].name = pdev->resource[1].name;
	musb_resources[1].start = pdev->resource[1].start;
	musb_resources[1].end = pdev->resource[1].end;
	musb_resources[1].flags = pdev->resource[1].flags;

	musb_resources[2].name = pdev->resource[2].name;
	musb_resources[2].start = pdev->resource[2].start;
	musb_resources[2].end = pdev->resource[2].end;
	musb_resources[2].flags = pdev->resource[2].flags;

	ret = platform_device_add_resources(musb, musb_resources,
			ARRAY_SIZE(musb_resources));
	if (ret) {
		dev_err(&pdev->dev, "failed to add resources\n");
		goto err2;
	}

	ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
	if (ret) {
		dev_err(&pdev->dev, "failed to add platform_data\n");
		goto err2;
	}

	pm_runtime_enable(glue->dev);

	ret = platform_device_add(musb);
	if (ret) {
		dev_err(&pdev->dev, "failed to register musb device\n");
		goto err3;
	}

	return 0;

err3:
	pm_runtime_disable(glue->dev);

err2:
	platform_device_put(musb);

err0:
	return ret;
}

static int omap2430_remove(struct platform_device *pdev)
{
	struct omap2430_glue *glue = platform_get_drvdata(pdev);

	platform_device_unregister(glue->musb);
	pm_runtime_disable(glue->dev);

	return 0;
}

#ifdef CONFIG_PM

static int omap2430_runtime_suspend(struct device *dev)
{
	struct omap2430_glue		*glue = dev_get_drvdata(dev);
	struct musb			*musb = glue_to_musb(glue);

	if (!musb)
		return 0;

	musb->context.otg_interfsel = musb_readl(musb->mregs,
						 OTG_INTERFSEL);

	omap2430_low_level_exit(musb);

	return 0;
}

static int omap2430_runtime_resume(struct device *dev)
{
	struct omap2430_glue		*glue = dev_get_drvdata(dev);
	struct musb			*musb = glue_to_musb(glue);

	if (!musb)
		return 0;

	omap2430_low_level_init(musb);
	musb_writel(musb->mregs, OTG_INTERFSEL,
		    musb->context.otg_interfsel);

	return 0;
}

static const struct dev_pm_ops omap2430_pm_ops = {
	.runtime_suspend = omap2430_runtime_suspend,
	.runtime_resume = omap2430_runtime_resume,
};

#define DEV_PM_OPS	(&omap2430_pm_ops)
#else
#define DEV_PM_OPS	NULL
#endif

#ifdef CONFIG_OF
static const struct of_device_id omap2430_id_table[] = {
	{
		.compatible = "ti,omap4-musb"
	},
	{
		.compatible = "ti,omap3-musb"
	},
	{},
};
MODULE_DEVICE_TABLE(of, omap2430_id_table);
#endif

static struct platform_driver omap2430_driver = {
	.probe		= omap2430_probe,
	.remove		= omap2430_remove,
	.driver		= {
		.name	= "musb-omap2430",
		.pm	= DEV_PM_OPS,
		.of_match_table = of_match_ptr(omap2430_id_table),
	},
};

module_platform_driver(omap2430_driver);

MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
550a7375 FB	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
550a7375 FB	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>
550a7375 FB	30	#include <linux/init.h>
550a7375 FB	31	#include <linux/list.h>
550a7375	32	#include <linux/io.h>
00a0b1d5	33	#include <linux/of.h>
dc09886b FB	34	#include <linux/platform_device.h>
dc09886b FB	35	#include <linux/dma-mapping.h>
207b0e1f HH	36	#include <linux/pm_runtime.h>
207b0e1f HH	37	#include <linux/err.h>
12a19b5f	38	#include <linux/delay.h>
8055555f	39	#include <linux/usb/musb.h>
14da699b	40	#include <linux/phy/omap_control_phy.h>
8934d3e4	41	#include <linux/of_platform.h>
550a7375	42
550a7375 FB	43	#include "musb_core.h"
	44	#include "omap2430.h"
	45
a3cee12a FB	46	struct omap2430_glue {
	47	struct device *dev;
	48	struct platform_device *musb;
8055555f	49	enum musb_vbus_id_status status;
1e5acb8d	50	struct work_struct omap_musb_mailbox_work;
ca784be3	51	struct device *control_otghs;
a3cee12a	52	};
c20aebb9	53	#define glue_to_musb(g) platform_get_drvdata(g->musb)
a3cee12a	54
4b58ed11	55	static struct omap2430_glue *_glue;
c9721438	56
743411b3	57	static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
550a7375	58	{
d445b6da	59	struct usb_otg *otg = musb->xceiv->otg;
550a7375	60	u8 devctl;
594632ef	61	unsigned long timeout = jiffies + msecs_to_jiffies(1000);
550a7375 FB	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) {
e47d9254	70	if (musb->xceiv->otg->state == OTG_STATE_A_IDLE) {
12a19b5f	71	int loops = 100;
594632ef HH	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	*/
5a805309 SS	79	while (musb_readb(musb->mregs, MUSB_DEVCTL) &
5a805309 SS	80	MUSB_DEVCTL_BDEVICE) {
594632ef	81
12a19b5f	82	mdelay(5);
594632ef HH	83	cpu_relax();
594632ef HH	84
12a19b5f N	85	if (time_after(jiffies, timeout)
12a19b5f N	86	\|\| loops-- <= 0) {
594632ef HH	87	dev_err(musb->controller,
594632ef HH	88	"configured as A device timeout");
594632ef HH	89	break;
	90	}
	91	}
	92
bb467cf5	93	otg_set_vbus(otg, 1);
594632ef HH	94	} else {
594632ef HH	95	musb->is_active = 1;
d445b6da	96	otg->default_a = 1;
e47d9254	97	musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE;
594632ef HH	98	devctl \|= MUSB_DEVCTL_SESSION;
	99	MUSB_HST_MODE(musb);
	100	}
550a7375 FB	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
d445b6da	108	otg->default_a = 0;
e47d9254	109	musb->xceiv->otg->state = OTG_STATE_B_IDLE;
550a7375 FB	110	devctl &= ~MUSB_DEVCTL_SESSION;
	111
	112	MUSB_DEV_MODE(musb);
	113	}
	114	musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
	115
5c8a86e1	116	dev_dbg(musb->controller, "VBUS %s, devctl %02x "
550a7375	117	/* otg %3x conf %08x prcm %08x */ "\n",
e47d9254	118	usb_otg_state_string(musb->xceiv->otg->state),
550a7375 FB	119	musb_readb(musb->mregs, MUSB_DEVCTL));
550a7375 FB	120	}
550a7375	121
c20aebb9 FB	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);
c20aebb9 FB	130	}
	131
	132	static inline void omap2430_low_level_init(struct musb *musb)
	133	{
	134	u32 l;
	135
c20aebb9 FB	136	l = musb_readl(musb->mregs, OTG_FORCESTDBY);
	137	l &= ~ENABLEFORCE; /* disable MSTANDBY */
	138	musb_writel(musb->mregs, OTG_FORCESTDBY, l);
	139	}
	140
12b7db2b	141	static int omap2430_musb_mailbox(enum musb_vbus_id_status status)
594632ef	142	{
c9721438	143	struct omap2430_glue *glue = _glue;
712d8efa	144
f8c4b0e7 AK	145	if (!glue) {
f8c4b0e7 AK	146	pr_err("%s: musb core is not yet initialized\n", __func__);
12b7db2b	147	return -EPROBE_DEFER;
f8c4b0e7 AK	148	}
	149	glue->status = status;
	150
	151	if (!glue_to_musb(glue)) {
80ab72e1	152	pr_err("%s: musb core is not yet ready\n", __func__);
12b7db2b	153	return -EPROBE_DEFER;
c9721438	154	}
712d8efa	155
c9721438	156	schedule_work(&glue->omap_musb_mailbox_work);
12b7db2b TL	157
12b7db2b TL	158	return 0;
712d8efa VP	159	}
712d8efa VP	160
c9721438	161	static void omap_musb_set_mailbox(struct omap2430_glue *glue)
712d8efa	162	{
1e5acb8d	163	struct musb *musb = glue_to_musb(glue);
ae909fe4 TL	164	struct musb_hdrc_platform_data *pdata =
ae909fe4 TL	165	dev_get_platdata(musb->controller);
594632ef	166	struct omap_musb_board_data *data = pdata->board_data;
c83a8542	167	struct usb_otg *otg = musb->xceiv->otg;
594632ef	168
ae909fe4	169	pm_runtime_get_sync(musb->controller);
c9721438	170	switch (glue->status) {
8055555f	171	case MUSB_ID_GROUND:
ae909fe4	172	dev_dbg(musb->controller, "ID GND\n");
594632ef	173
c83a8542	174	otg->default_a = true;
e47d9254	175	musb->xceiv->otg->state = OTG_STATE_A_IDLE;
c9721438	176	musb->xceiv->last_event = USB_EVENT_ID;
032ec49f	177	if (musb->gadget_driver) {
ca784be3 KVA	178	omap_control_usb_set_mode(glue->control_otghs,
ca784be3 KVA	179	USB_MODE_HOST);
70045c57	180	omap2430_musb_set_vbus(musb, 1);
594632ef HH	181	}
	182	break;
	183
8055555f	184	case MUSB_VBUS_VALID:
ae909fe4	185	dev_dbg(musb->controller, "VBUS Connect\n");
594632ef	186
c83a8542	187	otg->default_a = false;
e47d9254	188	musb->xceiv->otg->state = OTG_STATE_B_IDLE;
c9721438	189	musb->xceiv->last_event = USB_EVENT_VBUS;
ca784be3	190	omap_control_usb_set_mode(glue->control_otghs, USB_MODE_DEVICE);
594632ef HH	191	break;
594632ef HH	192
8055555f TL	193	case MUSB_ID_FLOAT:
8055555f TL	194	case MUSB_VBUS_OFF:
ae909fe4	195	dev_dbg(musb->controller, "VBUS Disconnect\n");
594632ef	196
c9721438	197	musb->xceiv->last_event = USB_EVENT_NONE;
21f77bee	198	if (musb->gadget_driver)
2c1fe89d	199	omap2430_musb_set_vbus(musb, 0);
7acc6197	200
bb467cf5 KVA	201	if (data->interface_type == MUSB_INTERFACE_UTMI)
	202	otg_set_vbus(musb->xceiv->otg, 0);
	203
ca784be3 KVA	204	omap_control_usb_set_mode(glue->control_otghs,
ca784be3 KVA	205	USB_MODE_DISCONNECT);
594632ef HH	206	break;
594632ef HH	207	default:
ae909fe4	208	dev_dbg(musb->controller, "ID float\n");
594632ef	209	}
ae909fe4 TL	210	pm_runtime_mark_last_busy(musb->controller);
ae909fe4 TL	211	pm_runtime_put_autosuspend(musb->controller);
6fa7178c PR	212	atomic_notifier_call_chain(&musb->xceiv->notifier,
6fa7178c PR	213	musb->xceiv->last_event, NULL);
594632ef HH	214	}
594632ef HH	215
c9721438 KVA	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);
8b2bc2c9	221
c9721438 KVA	222	omap_musb_set_mailbox(glue);
	223	}
	224
baef653a PDS	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
743411b3	245	static int omap2430_musb_init(struct musb *musb)
550a7375	246	{
ad579699 S	247	u32 l;
ad579699 S	248	int status = 0;
ea65df57	249	struct device *dev = musb->controller;
c9721438	250	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
c1a7d67c	251	struct musb_hdrc_platform_data *plat = dev_get_platdata(dev);
ea65df57	252	struct omap_musb_board_data *data = plat->board_data;
550a7375	253
84e250ff DB	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	*/
3e3101d5 KVA	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	*/
b16604f2 KVA	267	musb->xceiv = devm_usb_get_phy_by_phandle(dev->parent,
b16604f2 KVA	268	"usb-phy", 0);
3e3101d5	269	} else {
b16604f2	270	musb->xceiv = devm_usb_get_phy_dev(dev, 0);
3e3101d5 KVA	271	musb->phy = devm_phy_get(dev, "usb");
3e3101d5 KVA	272	}
b16604f2	273
a90199bb FB	274	if (IS_ERR(musb->xceiv)) {
	275	status = PTR_ERR(musb->xceiv);
	276
	277	if (status == -ENXIO)
	278	return status;
	279
dc66ba8d	280	dev_dbg(dev, "HS USB OTG: no transceiver configured\n");
25736e0c	281	return -EPROBE_DEFER;
84e250ff DB	282	}
84e250ff DB	283
3e3101d5	284	if (IS_ERR(musb->phy)) {
71127a79	285	dev_err(dev, "HS USB OTG: no PHY configured\n");
3e3101d5 KVA	286	return PTR_ERR(musb->phy);
3e3101d5 KVA	287	}
baef653a	288	musb->isr = omap2430_musb_interrupt;
a83e17d0	289	phy_init(musb->phy);
d8e5f0ec	290	phy_power_on(musb->phy);
baef653a	291
8573e6a6	292	l = musb_readl(musb->mregs, OTG_INTERFSEL);
de2e1b0c MM	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
8573e6a6	302	musb_writel(musb->mregs, OTG_INTERFSEL, l);
550a7375	303
71127a79	304	dev_dbg(dev, "HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
550a7375	305	"sysstatus 0x%x, intrfsel 0x%x, simenable 0x%x\n",
8573e6a6 FB	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));
550a7375	311
8055555f	312	if (glue->status != MUSB_UNKNOWN)
c9721438 KVA	313	omap_musb_set_mailbox(glue);
c9721438 KVA	314
550a7375 FB	315	return 0;
	316	}
	317
002eda13 HH	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;
c9721438	323	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
c1a7d67c	324	struct musb_hdrc_platform_data *pdata = dev_get_platdata(dev);
002eda13 HH	325	struct omap_musb_board_data *data = pdata->board_data;
002eda13 HH	326
a83e17d0	327
c9721438	328	switch (glue->status) {
002eda13	329
8055555f	330	case MUSB_ID_GROUND:
ca784be3	331	omap_control_usb_set_mode(glue->control_otghs, USB_MODE_HOST);
08dec56e FC	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;
002eda13 HH	345	}
	346	}
	347	break;
	348
8055555f	349	case MUSB_VBUS_VALID:
ca784be3	350	omap_control_usb_set_mode(glue->control_otghs, USB_MODE_DEVICE);
002eda13 HH	351	break;
	352
	353	default:
	354	break;
	355	}
	356	}
	357
	358	static void omap2430_musb_disable(struct musb *musb)
	359	{
c9721438 KVA	360	struct device *dev = musb->controller;
	361	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
	362
8055555f	363	if (glue->status != MUSB_UNKNOWN)
ca784be3 KVA	364	omap_control_usb_set_mode(glue->control_otghs,
ca784be3 KVA	365	USB_MODE_DISCONNECT);
550a7375 FB	366	}
550a7375 FB	367
743411b3	368	static int omap2430_musb_exit(struct musb *musb)
550a7375	369	{
a83e17d0 TL	370	struct device *dev = musb->controller;
a83e17d0 TL	371	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
550a7375	372
c20aebb9	373	omap2430_low_level_exit(musb);
d8e5f0ec	374	phy_power_off(musb->phy);
3e3101d5	375	phy_exit(musb->phy);
a83e17d0 TL	376	musb->phy = NULL;
a83e17d0 TL	377	cancel_work_sync(&glue->omap_musb_mailbox_work);
c20aebb9	378
550a7375 FB	379	return 0;
550a7375 FB	380	}
743411b3	381
f7ec9437	382	static const struct musb_platform_ops omap2430_ops = {
f8e9f34f	383	.quirks = MUSB_DMA_INVENTRA,
7f6283ed TL	384	#ifdef CONFIG_USB_INVENTRA_DMA
	385	.dma_init = musbhs_dma_controller_create,
	386	.dma_exit = musbhs_dma_controller_destroy,
	387	#endif
743411b3 FB	388	.init = omap2430_musb_init,
	389	.exit = omap2430_musb_exit,
	390
743411b3	391	.set_vbus = omap2430_musb_set_vbus,
002eda13 HH	392
	393	.enable = omap2430_musb_enable,
	394	.disable = omap2430_musb_disable,
8055555f TL	395
8055555f TL	396	.phy_callback = omap2430_musb_mailbox,
743411b3	397	};
dc09886b FB	398
	399	static u64 omap2430_dmamask = DMA_BIT_MASK(32);
	400
41ac7b3a	401	static int omap2430_probe(struct platform_device *pdev)
dc09886b	402	{
c1f01be4	403	struct resource musb_resources[3];
c1a7d67c	404	struct musb_hdrc_platform_data *pdata = dev_get_platdata(&pdev->dev);
00a0b1d5	405	struct omap_musb_board_data *data;
dc09886b	406	struct platform_device *musb;
a3cee12a	407	struct omap2430_glue *glue;
00a0b1d5 KVA	408	struct device_node *np = pdev->dev.of_node;
00a0b1d5 KVA	409	struct musb_hdrc_config *config;
606bf4d5	410	int ret = -ENOMEM, val;
dc09886b	411
b1183c24	412	glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL);
af1bdfc9	413	if (!glue)
a3cee12a	414	goto err0;
a3cee12a	415
2f771164	416	musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
dc09886b FB	417	if (!musb) {
dc09886b FB	418	dev_err(&pdev->dev, "failed to allocate musb device\n");
2f771164	419	goto err0;
dc09886b FB	420	}
	421
	422	musb->dev.parent = &pdev->dev;
	423	musb->dev.dma_mask = &omap2430_dmamask;
	424	musb->dev.coherent_dma_mask = omap2430_dmamask;
	425
a3cee12a FB	426	glue->dev = &pdev->dev;
a3cee12a FB	427	glue->musb = musb;
8055555f	428	glue->status = MUSB_UNKNOWN;
8934d3e4	429	glue->control_otghs = ERR_PTR(-ENODEV);
a3cee12a	430
00a0b1d5	431	if (np) {
8934d3e4 RQ	432	struct device_node *control_node;
	433	struct platform_device *control_pdev;
	434
00a0b1d5	435	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
af1bdfc9	436	if (!pdata)
2f771164	437	goto err2;
00a0b1d5 KVA	438
00a0b1d5 KVA	439	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
af1bdfc9	440	if (!data)
2f771164	441	goto err2;
00a0b1d5 KVA	442
00a0b1d5 KVA	443	config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
af1bdfc9	444	if (!config)
2f771164	445	goto err2;
00a0b1d5 KVA	446
00a0b1d5 KVA	447	of_property_read_u32(np, "mode", (u32 *)&pdata->mode);
eee44da0	448	of_property_read_u32(np, "interface-type",
00a0b1d5	449	(u32 *)&data->interface_type);
eee44da0 KVA	450	of_property_read_u32(np, "num-eps", (u32 *)&config->num_eps);
eee44da0 KVA	451	of_property_read_u32(np, "ram-bits", (u32 *)&config->ram_bits);
00a0b1d5	452	of_property_read_u32(np, "power", (u32 *)&pdata->power);
606bf4d5 TL	453
	454	ret = of_property_read_u32(np, "multipoint", &val);
	455	if (!ret && val)
	456	config->multipoint = true;
00a0b1d5 KVA	457
	458	pdata->board_data = data;
	459	pdata->config = config;
00a0b1d5	460
8934d3e4 RQ	461	control_node = of_parse_phandle(np, "ctrl-module", 0);
	462	if (control_node) {
	463	control_pdev = of_find_device_by_node(control_node);
	464	if (!control_pdev) {
	465	dev_err(&pdev->dev, "Failed to get control device\n");
	466	ret = -EINVAL;
	467	goto err2;
	468	}
	469	glue->control_otghs = &control_pdev->dev;
ca784be3	470	}
ca784be3	471	}
f7ec9437 FB	472	pdata->platform_ops = &omap2430_ops;
f7ec9437 FB	473
a3cee12a	474	platform_set_drvdata(pdev, glue);
dc09886b	475
c9721438 KVA	476	/*
	477	* REVISIT if we ever have two instances of the wrapper, we will be
	478	* in big trouble
	479	*/
	480	_glue = glue;
	481
1e5acb8d KVA	482	INIT_WORK(&glue->omap_musb_mailbox_work, omap_musb_mailbox_work);
1e5acb8d KVA	483
3a0ddc71	484	memset(musb_resources, 0x00, sizeof(musb_resources)
09fc7d22 FB	485	ARRAY_SIZE(musb_resources));
	486
	487	musb_resources[0].name = pdev->resource[0].name;
	488	musb_resources[0].start = pdev->resource[0].start;
	489	musb_resources[0].end = pdev->resource[0].end;
	490	musb_resources[0].flags = pdev->resource[0].flags;
	491
	492	musb_resources[1].name = pdev->resource[1].name;
	493	musb_resources[1].start = pdev->resource[1].start;
	494	musb_resources[1].end = pdev->resource[1].end;
	495	musb_resources[1].flags = pdev->resource[1].flags;
	496
c1f01be4 KVA	497	musb_resources[2].name = pdev->resource[2].name;
	498	musb_resources[2].start = pdev->resource[2].start;
	499	musb_resources[2].end = pdev->resource[2].end;
	500	musb_resources[2].flags = pdev->resource[2].flags;
	501
09fc7d22 FB	502	ret = platform_device_add_resources(musb, musb_resources,
09fc7d22 FB	503	ARRAY_SIZE(musb_resources));
dc09886b FB	504	if (ret) {
dc09886b FB	505	dev_err(&pdev->dev, "failed to add resources\n");
65b3d52d	506	goto err2;
dc09886b FB	507	}
	508
	509	ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
	510	if (ret) {
	511	dev_err(&pdev->dev, "failed to add platform_data\n");
65b3d52d	512	goto err2;
dc09886b FB	513	}
dc09886b FB	514
87326e85	515	pm_runtime_enable(glue->dev);
3006dc8c	516
dc09886b FB	517	ret = platform_device_add(musb);
	518	if (ret) {
	519	dev_err(&pdev->dev, "failed to register musb device\n");
536d599d	520	goto err3;
dc09886b FB	521	}
dc09886b FB	522
207b0e1f	523	return 0;
03491761	524
536d599d TL	525	err3:
	526	pm_runtime_disable(glue->dev);
	527
65b3d52d	528	err2:
b1183c24	529	platform_device_put(musb);
a3cee12a	530
dc09886b FB	531	err0:
	532	return ret;
	533	}
	534
fb4e98ab	535	static int omap2430_remove(struct platform_device *pdev)
dc09886b	536	{
21f77bee	537	struct omap2430_glue *glue = platform_get_drvdata(pdev);
dc09886b	538
f039df58	539	platform_device_unregister(glue->musb);
03e43528	540	pm_runtime_disable(glue->dev);
dc09886b FB	541
	542	return 0;
	543	}
	544
c20aebb9	545	#ifdef CONFIG_PM
c20aebb9	546
7acc6197	547	static int omap2430_runtime_suspend(struct device *dev)
c20aebb9 FB	548	{
	549	struct omap2430_glue *glue = dev_get_drvdata(dev);
	550	struct musb *musb = glue_to_musb(glue);
	551
a83e17d0 TL	552	if (!musb)
a83e17d0 TL	553	return 0;
e25bec16	554
a83e17d0 TL	555	musb->context.otg_interfsel = musb_readl(musb->mregs,
	556	OTG_INTERFSEL);
	557
	558	omap2430_low_level_exit(musb);
c20aebb9 FB	559
	560	return 0;
	561	}
	562
7acc6197	563	static int omap2430_runtime_resume(struct device *dev)
c20aebb9 FB	564	{
	565	struct omap2430_glue *glue = dev_get_drvdata(dev);
	566	struct musb *musb = glue_to_musb(glue);
c20aebb9	567
8f2279d5	568	if (!musb)
a83e17d0	569	return 0;
8f2279d5 TL	570
	571	omap2430_low_level_init(musb);
	572	musb_writel(musb->mregs, OTG_INTERFSEL,
	573	musb->context.otg_interfsel);
c20aebb9 FB	574
	575	return 0;
	576	}
	577
c0927fea	578	static const struct dev_pm_ops omap2430_pm_ops = {
7acc6197 HH	579	.runtime_suspend = omap2430_runtime_suspend,
7acc6197 HH	580	.runtime_resume = omap2430_runtime_resume,
c20aebb9 FB	581	};
	582
	583	#define DEV_PM_OPS (&omap2430_pm_ops)
	584	#else
	585	#define DEV_PM_OPS NULL
	586	#endif
	587
00a0b1d5 KVA	588	#ifdef CONFIG_OF
	589	static const struct of_device_id omap2430_id_table[] = {
	590	{
	591	.compatible = "ti,omap4-musb"
	592	},
	593	{
	594	.compatible = "ti,omap3-musb"
	595	},
	596	{},
	597	};
	598	MODULE_DEVICE_TABLE(of, omap2430_id_table);
	599	#endif
	600
dc09886b	601	static struct platform_driver omap2430_driver = {
e9e8c85e	602	.probe = omap2430_probe,
7690417d	603	.remove = omap2430_remove,
dc09886b FB	604	.driver = {
dc09886b FB	605	.name = "musb-omap2430",
c20aebb9	606	.pm = DEV_PM_OPS,
00a0b1d5	607	.of_match_table = of_match_ptr(omap2430_id_table),
dc09886b FB	608	},
	609	};
	610
aec373c1 TL	611	module_platform_driver(omap2430_driver);
aec373c1 TL	612
dc09886b FB	613	MODULE_DESCRIPTION("OMAP2PLUS MUSB Glue Layer");
	614	MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
	615	MODULE_LICENSE("GPL v2");