[mirror_ubuntu-artful-kernel.git] / drivers / usb / host / ehci-platform.c

/*
 * Generic platform ehci driver
 *
 * Copyright 2007 Steven Brown <sbrown@cortland.com>
 * Copyright 2010-2012 Hauke Mehrtens <hauke@hauke-m.de>
 * Copyright 2014 Hans de Goede <hdegoede@redhat.com>
 *
 * Derived from the ohci-ssb driver
 * Copyright 2007 Michael Buesch <m@bues.ch>
 *
 * Derived from the EHCI-PCI driver
 * Copyright (c) 2000-2004 by David Brownell
 *
 * Derived from the ohci-pci driver
 * Copyright 1999 Roman Weissgaerber
 * Copyright 2000-2002 David Brownell
 * Copyright 1999 Linus Torvalds
 * Copyright 1999 Gregory P. Smith
 *
 * Licensed under the GNU/GPL. See COPYING for details.
 */
#include <linux/clk.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/hrtimer.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/phy/phy.h>
#include <linux/platform_device.h>
#include <linux/reset.h>
#include <linux/usb.h>
#include <linux/usb/hcd.h>
#include <linux/usb/ehci_pdriver.h>

#include "ehci.h"

#define DRIVER_DESC "EHCI generic platform driver"
#define EHCI_MAX_CLKS 3
#define hcd_to_ehci_priv(h) ((struct ehci_platform_priv *)hcd_to_ehci(h)->priv)

struct ehci_platform_priv {
	struct clk *clks[EHCI_MAX_CLKS];
	struct reset_control *rst;
	struct phy **phys;
	int num_phys;
};

static const char hcd_name[] = "ehci-platform";

static int ehci_platform_reset(struct usb_hcd *hcd)
{
	struct platform_device *pdev = to_platform_device(hcd->self.controller);
	struct usb_ehci_pdata *pdata = dev_get_platdata(&pdev->dev);
	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
	int retval;

	hcd->has_tt = pdata->has_tt;
	ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug;

	if (pdata->pre_setup) {
		retval = pdata->pre_setup(hcd);
		if (retval < 0)
			return retval;
	}

	ehci->caps = hcd->regs + pdata->caps_offset;
	retval = ehci_setup(hcd);
	if (retval)
		return retval;

	if (pdata->no_io_watchdog)
		ehci->need_io_watchdog = 0;
	return 0;
}

static int ehci_platform_power_on(struct platform_device *dev)
{
	struct usb_hcd *hcd = platform_get_drvdata(dev);
	struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
	int clk, ret, phy_num;

	for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++) {
		ret = clk_prepare_enable(priv->clks[clk]);
		if (ret)
			goto err_disable_clks;
	}

	for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
		if (priv->phys[phy_num]) {
			ret = phy_init(priv->phys[phy_num]);
			if (ret)
				goto err_exit_phy;
			ret = phy_power_on(priv->phys[phy_num]);
			if (ret) {
				phy_exit(priv->phys[phy_num]);
				goto err_exit_phy;
			}
		}
	}

	return 0;

err_exit_phy:
	while (--phy_num >= 0) {
		if (priv->phys[phy_num]) {
			phy_power_off(priv->phys[phy_num]);
			phy_exit(priv->phys[phy_num]);
		}
	}
err_disable_clks:
	while (--clk >= 0)
		clk_disable_unprepare(priv->clks[clk]);

	return ret;
}

static void ehci_platform_power_off(struct platform_device *dev)
{
	struct usb_hcd *hcd = platform_get_drvdata(dev);
	struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
	int clk, phy_num;

	for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
		if (priv->phys[phy_num]) {
			phy_power_off(priv->phys[phy_num]);
			phy_exit(priv->phys[phy_num]);
		}
	}

	for (clk = EHCI_MAX_CLKS - 1; clk >= 0; clk--)
		if (priv->clks[clk])
			clk_disable_unprepare(priv->clks[clk]);
}

static struct hc_driver __read_mostly ehci_platform_hc_driver;

static const struct ehci_driver_overrides platform_overrides __initconst = {
	.reset =		ehci_platform_reset,
	.extra_priv_size =	sizeof(struct ehci_platform_priv),
};

static struct usb_ehci_pdata ehci_platform_defaults = {
	.power_on =		ehci_platform_power_on,
	.power_suspend =	ehci_platform_power_off,
	.power_off =		ehci_platform_power_off,
};

static int ehci_platform_probe(struct platform_device *dev)
{
	struct usb_hcd *hcd;
	struct resource *res_mem;
	struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
	struct ehci_platform_priv *priv;
	struct ehci_hcd *ehci;
	const char *phy_name;
	int err, irq, phy_num, clk = 0;

	if (usb_disabled())
		return -ENODEV;

	/*
	 * Use reasonable defaults so platforms don't have to provide these
	 * with DT probing on ARM.
	 */
	if (!pdata)
		pdata = &ehci_platform_defaults;

	err = dma_coerce_mask_and_coherent(&dev->dev,
		pdata->dma_mask_64 ? DMA_BIT_MASK(64) : DMA_BIT_MASK(32));
	if (err)
		return err;

	irq = platform_get_irq(dev, 0);
	if (irq < 0) {
		dev_err(&dev->dev, "no irq provided");
		return irq;
	}

	hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
			     dev_name(&dev->dev));
	if (!hcd)
		return -ENOMEM;

	platform_set_drvdata(dev, hcd);
	dev->dev.platform_data = pdata;
	priv = hcd_to_ehci_priv(hcd);
	ehci = hcd_to_ehci(hcd);

	if (pdata == &ehci_platform_defaults && dev->dev.of_node) {
		if (of_property_read_bool(dev->dev.of_node, "big-endian-regs"))
			ehci->big_endian_mmio = 1;

		if (of_property_read_bool(dev->dev.of_node, "big-endian-desc"))
			ehci->big_endian_desc = 1;

		if (of_property_read_bool(dev->dev.of_node, "big-endian"))
			ehci->big_endian_mmio = ehci->big_endian_desc = 1;

		if (of_property_read_bool(dev->dev.of_node,
					  "needs-reset-on-resume"))
			pdata->reset_on_resume = 1;

		priv->num_phys = of_count_phandle_with_args(dev->dev.of_node,
				"phys", "#phy-cells");
		priv->num_phys = priv->num_phys > 0 ? priv->num_phys : 1;

		priv->phys = devm_kcalloc(&dev->dev, priv->num_phys,
				sizeof(struct phy *), GFP_KERNEL);
		if (!priv->phys)
			return -ENOMEM;

		for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
				err = of_property_read_string_index(
						dev->dev.of_node,
						"phy-names", phy_num,
						&phy_name);

				if (err < 0) {
					if (priv->num_phys > 1) {
						dev_err(&dev->dev, "phy-names not provided");
						goto err_put_hcd;
					} else
						phy_name = "usb";
				}

				priv->phys[phy_num] = devm_phy_get(&dev->dev,
						phy_name);
				if (IS_ERR(priv->phys[phy_num])) {
					err = PTR_ERR(priv->phys[phy_num]);
					if ((priv->num_phys > 1) ||
					    (err == -EPROBE_DEFER))
						goto err_put_hcd;
					priv->phys[phy_num] = NULL;
				}
		}

		for (clk = 0; clk < EHCI_MAX_CLKS; clk++) {
			priv->clks[clk] = of_clk_get(dev->dev.of_node, clk);
			if (IS_ERR(priv->clks[clk])) {
				err = PTR_ERR(priv->clks[clk]);
				if (err == -EPROBE_DEFER)
					goto err_put_clks;
				priv->clks[clk] = NULL;
				break;
			}
		}
	}

	priv->rst = devm_reset_control_get_optional(&dev->dev, NULL);
	if (IS_ERR(priv->rst)) {
		err = PTR_ERR(priv->rst);
		if (err == -EPROBE_DEFER)
			goto err_put_clks;
		priv->rst = NULL;
	} else {
		err = reset_control_deassert(priv->rst);
		if (err)
			goto err_put_clks;
	}

	if (pdata->big_endian_desc)
		ehci->big_endian_desc = 1;
	if (pdata->big_endian_mmio)
		ehci->big_endian_mmio = 1;

#ifndef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
	if (ehci->big_endian_mmio) {
		dev_err(&dev->dev,
			"Error: CONFIG_USB_EHCI_BIG_ENDIAN_MMIO not set\n");
		err = -EINVAL;
		goto err_reset;
	}
#endif
#ifndef CONFIG_USB_EHCI_BIG_ENDIAN_DESC
	if (ehci->big_endian_desc) {
		dev_err(&dev->dev,
			"Error: CONFIG_USB_EHCI_BIG_ENDIAN_DESC not set\n");
		err = -EINVAL;
		goto err_reset;
	}
#endif

	if (pdata->power_on) {
		err = pdata->power_on(dev);
		if (err < 0)
			goto err_reset;
	}

	res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
	hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
	if (IS_ERR(hcd->regs)) {
		err = PTR_ERR(hcd->regs);
		goto err_power;
	}
	hcd->rsrc_start = res_mem->start;
	hcd->rsrc_len = resource_size(res_mem);

	err = usb_add_hcd(hcd, irq, IRQF_SHARED);
	if (err)
		goto err_power;

	device_wakeup_enable(hcd->self.controller);
	platform_set_drvdata(dev, hcd);

	return err;

err_power:
	if (pdata->power_off)
		pdata->power_off(dev);
err_reset:
	if (priv->rst)
		reset_control_assert(priv->rst);
err_put_clks:
	while (--clk >= 0)
		clk_put(priv->clks[clk]);
err_put_hcd:
	if (pdata == &ehci_platform_defaults)
		dev->dev.platform_data = NULL;

	usb_put_hcd(hcd);

	return err;
}

static int ehci_platform_remove(struct platform_device *dev)
{
	struct usb_hcd *hcd = platform_get_drvdata(dev);
	struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
	struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
	int clk;

	usb_remove_hcd(hcd);

	if (pdata->power_off)
		pdata->power_off(dev);

	if (priv->rst)
		reset_control_assert(priv->rst);

	for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++)
		clk_put(priv->clks[clk]);

	usb_put_hcd(hcd);

	if (pdata == &ehci_platform_defaults)
		dev->dev.platform_data = NULL;

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int ehci_platform_suspend(struct device *dev)
{
	struct usb_hcd *hcd = dev_get_drvdata(dev);
	struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
	struct platform_device *pdev =
		container_of(dev, struct platform_device, dev);
	bool do_wakeup = device_may_wakeup(dev);
	int ret;

	ret = ehci_suspend(hcd, do_wakeup);
	if (ret)
		return ret;

	if (pdata->power_suspend)
		pdata->power_suspend(pdev);

	return ret;
}

static int ehci_platform_resume(struct device *dev)
{
	struct usb_hcd *hcd = dev_get_drvdata(dev);
	struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
	struct platform_device *pdev =
		container_of(dev, struct platform_device, dev);

	if (pdata->power_on) {
		int err = pdata->power_on(pdev);
		if (err < 0)
			return err;
	}

	ehci_resume(hcd, pdata->reset_on_resume);
	return 0;
}
#endif /* CONFIG_PM_SLEEP */

static const struct of_device_id vt8500_ehci_ids[] = {
	{ .compatible = "via,vt8500-ehci", },
	{ .compatible = "wm,prizm-ehci", },
	{ .compatible = "generic-ehci", },
	{ .compatible = "cavium,octeon-6335-ehci", },
	{}
};
MODULE_DEVICE_TABLE(of, vt8500_ehci_ids);

static const struct platform_device_id ehci_platform_table[] = {
	{ "ehci-platform", 0 },
	{ }
};
MODULE_DEVICE_TABLE(platform, ehci_platform_table);

static SIMPLE_DEV_PM_OPS(ehci_platform_pm_ops, ehci_platform_suspend,
	ehci_platform_resume);

static struct platform_driver ehci_platform_driver = {
	.id_table	= ehci_platform_table,
	.probe		= ehci_platform_probe,
	.remove		= ehci_platform_remove,
	.shutdown	= usb_hcd_platform_shutdown,
	.driver		= {
		.name	= "ehci-platform",
		.pm	= &ehci_platform_pm_ops,
		.of_match_table = vt8500_ehci_ids,
	}
};

static int __init ehci_platform_init(void)
{
	if (usb_disabled())
		return -ENODEV;

	pr_info("%s: " DRIVER_DESC "\n", hcd_name);

	ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides);
	return platform_driver_register(&ehci_platform_driver);
}
module_init(ehci_platform_init);

static void __exit ehci_platform_cleanup(void)
{
	platform_driver_unregister(&ehci_platform_driver);
}
module_exit(ehci_platform_cleanup);

MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("Hauke Mehrtens");
MODULE_AUTHOR("Alan Stern");
MODULE_LICENSE("GPL");
Commit	Line	Data
7a7a4a59 HM	1	/*
	2	* Generic platform ehci driver
	3	*
	4	* Copyright 2007 Steven Brown <sbrown@cortland.com>
	5	* Copyright 2010-2012 Hauke Mehrtens <hauke@hauke-m.de>
a4aeb211	6	* Copyright 2014 Hans de Goede <hdegoede@redhat.com>
7a7a4a59 HM	7	*
	8	* Derived from the ohci-ssb driver
	9	* Copyright 2007 Michael Buesch <m@bues.ch>
	10	*
	11	* Derived from the EHCI-PCI driver
	12	* Copyright (c) 2000-2004 by David Brownell
	13	*
	14	* Derived from the ohci-pci driver
	15	* Copyright 1999 Roman Weissgaerber
	16	* Copyright 2000-2002 David Brownell
	17	* Copyright 1999 Linus Torvalds
	18	* Copyright 1999 Gregory P. Smith
	19	*
	20	* Licensed under the GNU/GPL. See COPYING for details.
	21	*/
a4aeb211	22	#include <linux/clk.h>
f3bc64d6	23	#include <linux/dma-mapping.h>
148e1134	24	#include <linux/err.h>
99f91934	25	#include <linux/kernel.h>
d1bb67a7 AS	26	#include <linux/hrtimer.h>
d1bb67a7 AS	27	#include <linux/io.h>
99f91934	28	#include <linux/module.h>
f3bc64d6	29	#include <linux/of.h>
a4aeb211	30	#include <linux/phy/phy.h>
7a7a4a59	31	#include <linux/platform_device.h>
2d87bbd6	32	#include <linux/reset.h>
99f91934 AS	33	#include <linux/usb.h>
99f91934 AS	34	#include <linux/usb/hcd.h>
7a7a4a59 HM	35	#include <linux/usb/ehci_pdriver.h>
7a7a4a59 HM	36
99f91934 AS	37	#include "ehci.h"
	38
	39	#define DRIVER_DESC "EHCI generic platform driver"
a4aeb211 HG	40	#define EHCI_MAX_CLKS 3
	41	#define hcd_to_ehci_priv(h) ((struct ehci_platform_priv *)hcd_to_ehci(h)->priv)
	42
	43	struct ehci_platform_priv {
	44	struct clk *clks[EHCI_MAX_CLKS];
2d87bbd6	45	struct reset_control *rst;
7e7a0e67 AR	46	struct phy **phys;
7e7a0e67 AR	47	int num_phys;
a4aeb211	48	};
99f91934 AS	49
	50	static const char hcd_name[] = "ehci-platform";
	51
7a7a4a59 HM	52	static int ehci_platform_reset(struct usb_hcd *hcd)
	53	{
	54	struct platform_device *pdev = to_platform_device(hcd->self.controller);
d4f09e28	55	struct usb_ehci_pdata *pdata = dev_get_platdata(&pdev->dev);
7a7a4a59 HM	56	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
	57	int retval;
	58
	59	hcd->has_tt = pdata->has_tt;
	60	ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug;
7a7a4a59	61
743fcce0 SS	62	if (pdata->pre_setup) {
	63	retval = pdata->pre_setup(hcd);
	64	if (retval < 0)
	65	return retval;
	66	}
	67
7a7a4a59 HM	68	ehci->caps = hcd->regs + pdata->caps_offset;
	69	retval = ehci_setup(hcd);
	70	if (retval)
	71	return retval;
	72
4534874a FF	73	if (pdata->no_io_watchdog)
4534874a FF	74	ehci->need_io_watchdog = 0;
7a7a4a59 HM	75	return 0;
	76	}
	77
a4aeb211 HG	78	static int ehci_platform_power_on(struct platform_device *dev)
	79	{
	80	struct usb_hcd *hcd = platform_get_drvdata(dev);
	81	struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
7e7a0e67	82	int clk, ret, phy_num;
a4aeb211 HG	83
	84	for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++) {
	85	ret = clk_prepare_enable(priv->clks[clk]);
	86	if (ret)
	87	goto err_disable_clks;
	88	}
	89
7e7a0e67 AR	90	for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
	91	if (priv->phys[phy_num]) {
	92	ret = phy_init(priv->phys[phy_num]);
	93	if (ret)
	94	goto err_exit_phy;
	95	ret = phy_power_on(priv->phys[phy_num]);
	96	if (ret) {
	97	phy_exit(priv->phys[phy_num]);
	98	goto err_exit_phy;
	99	}
	100	}
a4aeb211 HG	101	}
	102
	103	return 0;
	104
	105	err_exit_phy:
7e7a0e67 AR	106	while (--phy_num >= 0) {
	107	if (priv->phys[phy_num]) {
	108	phy_power_off(priv->phys[phy_num]);
	109	phy_exit(priv->phys[phy_num]);
	110	}
	111	}
a4aeb211 HG	112	err_disable_clks:
	113	while (--clk >= 0)
	114	clk_disable_unprepare(priv->clks[clk]);
	115
	116	return ret;
	117	}
	118
	119	static void ehci_platform_power_off(struct platform_device *dev)
	120	{
	121	struct usb_hcd *hcd = platform_get_drvdata(dev);
	122	struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
7e7a0e67	123	int clk, phy_num;
a4aeb211	124
7e7a0e67 AR	125	for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
	126	if (priv->phys[phy_num]) {
	127	phy_power_off(priv->phys[phy_num]);
	128	phy_exit(priv->phys[phy_num]);
	129	}
a4aeb211 HG	130	}
	131
	132	for (clk = EHCI_MAX_CLKS - 1; clk >= 0; clk--)
	133	if (priv->clks[clk])
	134	clk_disable_unprepare(priv->clks[clk]);
	135	}
	136
99f91934	137	static struct hc_driver __read_mostly ehci_platform_hc_driver;
7a7a4a59	138
62d08a11	139	static const struct ehci_driver_overrides platform_overrides __initconst = {
a4aeb211 HG	140	.reset = ehci_platform_reset,
a4aeb211 HG	141	.extra_priv_size = sizeof(struct ehci_platform_priv),
7a7a4a59 HM	142	};
7a7a4a59 HM	143
a4aeb211 HG	144	static struct usb_ehci_pdata ehci_platform_defaults = {
	145	.power_on = ehci_platform_power_on,
	146	.power_suspend = ehci_platform_power_off,
	147	.power_off = ehci_platform_power_off,
	148	};
f3bc64d6	149
41ac7b3a	150	static int ehci_platform_probe(struct platform_device *dev)
7a7a4a59 HM	151	{
	152	struct usb_hcd *hcd;
	153	struct resource *res_mem;
a4aeb211 HG	154	struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
a4aeb211 HG	155	struct ehci_platform_priv *priv;
ad3db5da	156	struct ehci_hcd *ehci;
7e7a0e67 AR	157	const char *phy_name;
7e7a0e67 AR	158	int err, irq, phy_num, clk = 0;
7a7a4a59	159
7a7a4a59 HM	160	if (usb_disabled())
	161	return -ENODEV;
	162
f3bc64d6	163	/*
a4aeb211 HG	164	* Use reasonable defaults so platforms don't have to provide these
a4aeb211 HG	165	* with DT probing on ARM.
f3bc64d6	166	*/
a4aeb211 HG	167	if (!pdata)
a4aeb211 HG	168	pdata = &ehci_platform_defaults;
e1fd7341	169
c99e76c5 AH	170	err = dma_coerce_mask_and_coherent(&dev->dev,
c99e76c5 AH	171	pdata->dma_mask_64 ? DMA_BIT_MASK(64) : DMA_BIT_MASK(32));
22d9d8e8 RK	172	if (err)
22d9d8e8 RK	173	return err;
f3bc64d6	174
7a7a4a59 HM	175	irq = platform_get_irq(dev, 0);
7a7a4a59 HM	176	if (irq < 0) {
2350cb0c	177	dev_err(&dev->dev, "no irq provided");
7a7a4a59 HM	178	return irq;
7a7a4a59 HM	179	}
7a7a4a59	180
a4aeb211 HG	181	hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
	182	dev_name(&dev->dev));
	183	if (!hcd)
	184	return -ENOMEM;
	185
	186	platform_set_drvdata(dev, hcd);
	187	dev->dev.platform_data = pdata;
	188	priv = hcd_to_ehci_priv(hcd);
ad3db5da	189	ehci = hcd_to_ehci(hcd);
a4aeb211 HG	190
a4aeb211 HG	191	if (pdata == &ehci_platform_defaults && dev->dev.of_node) {
ad3db5da HG	192	if (of_property_read_bool(dev->dev.of_node, "big-endian-regs"))
	193	ehci->big_endian_mmio = 1;
	194
	195	if (of_property_read_bool(dev->dev.of_node, "big-endian-desc"))
	196	ehci->big_endian_desc = 1;
	197
	198	if (of_property_read_bool(dev->dev.of_node, "big-endian"))
	199	ehci->big_endian_mmio = ehci->big_endian_desc = 1;
	200
314b41b1 WL	201	if (of_property_read_bool(dev->dev.of_node,
	202	"needs-reset-on-resume"))
	203	pdata->reset_on_resume = 1;
	204
7e7a0e67 AR	205	priv->num_phys = of_count_phandle_with_args(dev->dev.of_node,
	206	"phys", "#phy-cells");
	207	priv->num_phys = priv->num_phys > 0 ? priv->num_phys : 1;
	208
	209	priv->phys = devm_kcalloc(&dev->dev, priv->num_phys,
	210	sizeof(struct phy *), GFP_KERNEL);
	211	if (!priv->phys)
	212	return -ENOMEM;
	213
	214	for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
	215	err = of_property_read_string_index(
	216	dev->dev.of_node,
	217	"phy-names", phy_num,
	218	&phy_name);
	219
	220	if (err < 0) {
	221	if (priv->num_phys > 1) {
	222	dev_err(&dev->dev, "phy-names not provided");
	223	goto err_put_hcd;
	224	} else
	225	phy_name = "usb";
	226	}
	227
	228	priv->phys[phy_num] = devm_phy_get(&dev->dev,
	229	phy_name);
	230	if (IS_ERR(priv->phys[phy_num])) {
	231	err = PTR_ERR(priv->phys[phy_num]);
	232	if ((priv->num_phys > 1) \|\|
	233	(err == -EPROBE_DEFER))
	234	goto err_put_hcd;
	235	priv->phys[phy_num] = NULL;
	236	}
a4aeb211 HG	237	}
	238
	239	for (clk = 0; clk < EHCI_MAX_CLKS; clk++) {
	240	priv->clks[clk] = of_clk_get(dev->dev.of_node, clk);
	241	if (IS_ERR(priv->clks[clk])) {
	242	err = PTR_ERR(priv->clks[clk]);
	243	if (err == -EPROBE_DEFER)
	244	goto err_put_clks;
	245	priv->clks[clk] = NULL;
	246	break;
	247	}
	248	}
	249	}
	250
2d87bbd6 BB	251	priv->rst = devm_reset_control_get_optional(&dev->dev, NULL);
	252	if (IS_ERR(priv->rst)) {
	253	err = PTR_ERR(priv->rst);
	254	if (err == -EPROBE_DEFER)
	255	goto err_put_clks;
	256	priv->rst = NULL;
	257	} else {
	258	err = reset_control_deassert(priv->rst);
	259	if (err)
	260	goto err_put_clks;
	261	}
	262
843d5e03 AS	263	if (pdata->big_endian_desc)
	264	ehci->big_endian_desc = 1;
	265	if (pdata->big_endian_mmio)
	266	ehci->big_endian_mmio = 1;
	267
	268	#ifndef CONFIG_USB_EHCI_BIG_ENDIAN_MMIO
	269	if (ehci->big_endian_mmio) {
	270	dev_err(&dev->dev,
	271	"Error: CONFIG_USB_EHCI_BIG_ENDIAN_MMIO not set\n");
	272	err = -EINVAL;
2d87bbd6	273	goto err_reset;
843d5e03 AS	274	}
	275	#endif
	276	#ifndef CONFIG_USB_EHCI_BIG_ENDIAN_DESC
	277	if (ehci->big_endian_desc) {
	278	dev_err(&dev->dev,
	279	"Error: CONFIG_USB_EHCI_BIG_ENDIAN_DESC not set\n");
	280	err = -EINVAL;
2d87bbd6	281	goto err_reset;
843d5e03 AS	282	}
	283	#endif
	284
04216bed KM	285	if (pdata->power_on) {
	286	err = pdata->power_on(dev);
	287	if (err < 0)
2d87bbd6	288	goto err_reset;
04216bed	289	}
7a7a4a59	290
2062ff48	291	res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
148e1134 TR	292	hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
	293	if (IS_ERR(hcd->regs)) {
	294	err = PTR_ERR(hcd->regs);
a4aeb211	295	goto err_power;
ec03ad85	296	}
2062ff48 VB	297	hcd->rsrc_start = res_mem->start;
	298	hcd->rsrc_len = resource_size(res_mem);
	299
7a7a4a59 HM	300	err = usb_add_hcd(hcd, irq, IRQF_SHARED);
7a7a4a59 HM	301	if (err)
a4aeb211	302	goto err_power;
7a7a4a59	303
3c9740a1	304	device_wakeup_enable(hcd->self.controller);
7a7a4a59 HM	305	platform_set_drvdata(dev, hcd);
	306
	307	return err;
	308
04216bed KM	309	err_power:
	310	if (pdata->power_off)
	311	pdata->power_off(dev);
2d87bbd6 BB	312	err_reset:
	313	if (priv->rst)
	314	reset_control_assert(priv->rst);
a4aeb211 HG	315	err_put_clks:
	316	while (--clk >= 0)
	317	clk_put(priv->clks[clk]);
	318	err_put_hcd:
	319	if (pdata == &ehci_platform_defaults)
	320	dev->dev.platform_data = NULL;
	321
	322	usb_put_hcd(hcd);
04216bed	323
7a7a4a59 HM	324	return err;
	325	}
	326
fb4e98ab	327	static int ehci_platform_remove(struct platform_device *dev)
7a7a4a59 HM	328	{
7a7a4a59 HM	329	struct usb_hcd *hcd = platform_get_drvdata(dev);
d4f09e28	330	struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
a4aeb211 HG	331	struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
a4aeb211 HG	332	int clk;
7a7a4a59 HM	333
7a7a4a59 HM	334	usb_remove_hcd(hcd);
7a7a4a59	335
04216bed KM	336	if (pdata->power_off)
	337	pdata->power_off(dev);
	338
2d87bbd6 BB	339	if (priv->rst)
	340	reset_control_assert(priv->rst);
	341
a4aeb211 HG	342	for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++)
	343	clk_put(priv->clks[clk]);
	344
	345	usb_put_hcd(hcd);
	346
f3bc64d6 AB	347	if (pdata == &ehci_platform_defaults)
	348	dev->dev.platform_data = NULL;
	349
7a7a4a59 HM	350	return 0;
	351	}
	352
5e4ccd9e	353	#ifdef CONFIG_PM_SLEEP
7a7a4a59 HM	354	static int ehci_platform_suspend(struct device *dev)
	355	{
	356	struct usb_hcd *hcd = dev_get_drvdata(dev);
d4f09e28	357	struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
04216bed KM	358	struct platform_device *pdev =
04216bed KM	359	container_of(dev, struct platform_device, dev);
c5cf9212	360	bool do_wakeup = device_may_wakeup(dev);
04216bed KM	361	int ret;
	362
	363	ret = ehci_suspend(hcd, do_wakeup);
e155b5b8 VG	364	if (ret)
e155b5b8 VG	365	return ret;
7a7a4a59	366
04216bed KM	367	if (pdata->power_suspend)
	368	pdata->power_suspend(pdev);
	369
	370	return ret;
7a7a4a59 HM	371	}
	372
	373	static int ehci_platform_resume(struct device *dev)
	374	{
	375	struct usb_hcd *hcd = dev_get_drvdata(dev);
d4f09e28	376	struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
04216bed KM	377	struct platform_device *pdev =
	378	container_of(dev, struct platform_device, dev);
	379
	380	if (pdata->power_on) {
	381	int err = pdata->power_on(pdev);
	382	if (err < 0)
	383	return err;
	384	}
7a7a4a59	385
314b41b1	386	ehci_resume(hcd, pdata->reset_on_resume);
7a7a4a59 HM	387	return 0;
7a7a4a59 HM	388	}
5e4ccd9e	389	#endif /* CONFIG_PM_SLEEP */
7a7a4a59	390
f3bc64d6 AB	391	static const struct of_device_id vt8500_ehci_ids[] = {
	392	{ .compatible = "via,vt8500-ehci", },
	393	{ .compatible = "wm,prizm-ehci", },
915974c3	394	{ .compatible = "generic-ehci", },
a95cfa6b	395	{ .compatible = "cavium,octeon-6335-ehci", },
f3bc64d6 AB	396	{}
f3bc64d6 AB	397	};
a4aeb211	398	MODULE_DEVICE_TABLE(of, vt8500_ehci_ids);
f3bc64d6	399
7a7a4a59 HM	400	static const struct platform_device_id ehci_platform_table[] = {
	401	{ "ehci-platform", 0 },
	402	{ }
	403	};
	404	MODULE_DEVICE_TABLE(platform, ehci_platform_table);
	405
5e4ccd9e WK	406	static SIMPLE_DEV_PM_OPS(ehci_platform_pm_ops, ehci_platform_suspend,
5e4ccd9e WK	407	ehci_platform_resume);
7a7a4a59 HM	408
	409	static struct platform_driver ehci_platform_driver = {
	410	.id_table = ehci_platform_table,
	411	.probe = ehci_platform_probe,
7690417d	412	.remove = ehci_platform_remove,
7a7a4a59 HM	413	.shutdown = usb_hcd_platform_shutdown,
7a7a4a59 HM	414	.driver = {
7a7a4a59 HM	415	.name = "ehci-platform",
7a7a4a59 HM	416	.pm = &ehci_platform_pm_ops,
ae5e5f7b	417	.of_match_table = vt8500_ehci_ids,
7a7a4a59 HM	418	}
7a7a4a59 HM	419	};
99f91934 AS	420
	421	static int __init ehci_platform_init(void)
	422	{
	423	if (usb_disabled())
	424	return -ENODEV;
	425
	426	pr_info("%s: " DRIVER_DESC "\n", hcd_name);
	427
	428	ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides);
	429	return platform_driver_register(&ehci_platform_driver);
	430	}
	431	module_init(ehci_platform_init);
	432
	433	static void __exit ehci_platform_cleanup(void)
	434	{
	435	platform_driver_unregister(&ehci_platform_driver);
	436	}
	437	module_exit(ehci_platform_cleanup);
	438
	439	MODULE_DESCRIPTION(DRIVER_DESC);
	440	MODULE_AUTHOR("Hauke Mehrtens");
	441	MODULE_AUTHOR("Alan Stern");
	442	MODULE_LICENSE("GPL");