1/*
  2 * Copyright 2012 Freescale Semiconductor, Inc.
  3 * Copyright (C) 2012 Marek Vasut <marex@denx.de>
  4 * on behalf of DENX Software Engineering GmbH
  5 *
  6 * The code contained herein is licensed under the GNU General Public
  7 * License. You may obtain a copy of the GNU General Public License
  8 * Version 2 or later at the following locations:
  9 *
 10 * http://www.opensource.org/licenses/gpl-license.html
 11 * http://www.gnu.org/copyleft/gpl.html
 12 */
 13
 14#include <linux/module.h>
 15#include <linux/of_platform.h>
 16#include <linux/of_gpio.h>
 17#include <linux/platform_device.h>
 18#include <linux/pm_runtime.h>
 19#include <linux/dma-mapping.h>
 20#include <linux/usb/chipidea.h>
 21#include <linux/clk.h>
 22
 23#include "ci.h"
 24#include "ci_hdrc_imx.h"
 25
 26#define CI_HDRC_IMX_IMX28_WRITE_FIX BIT(0)
 27
 28struct ci_hdrc_imx_platform_flag {
 29	unsigned int flags;
 30};
 31
 32static const struct ci_hdrc_imx_platform_flag imx27_usb_data = {
 33};
 34
 35static const struct ci_hdrc_imx_platform_flag imx28_usb_data = {
 36	.flags = CI_HDRC_IMX_IMX28_WRITE_FIX,
 37};
 38
 39static const struct of_device_id ci_hdrc_imx_dt_ids[] = {
 40	{ .compatible = "fsl,imx28-usb", .data = &imx28_usb_data},
 41	{ .compatible = "fsl,imx27-usb", .data = &imx27_usb_data},
 42	{ /* sentinel */ }
 43};
 44MODULE_DEVICE_TABLE(of, ci_hdrc_imx_dt_ids);
 45
 46struct ci_hdrc_imx_data {
 47	struct usb_phy *phy;
 48	struct platform_device *ci_pdev;
 49	struct clk *clk;
 50	struct imx_usbmisc_data *usbmisc_data;
 51};
 52
 53/* Common functions shared by usbmisc drivers */
 54
 55static struct imx_usbmisc_data *usbmisc_get_init_data(struct device *dev)
 56{
 57	struct device_node *np = dev->of_node;
 58	struct of_phandle_args args;
 59	struct imx_usbmisc_data *data;
 60	int ret;
 61
 62	/*
 63	 * In case the fsl,usbmisc property is not present this device doesn't
 64	 * need usbmisc. Return NULL (which is no error here)
 65	 */
 66	if (!of_get_property(np, "fsl,usbmisc", NULL))
 67		return NULL;
 68
 69	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 70	if (!data)
 71		return ERR_PTR(-ENOMEM);
 72
 73	ret = of_parse_phandle_with_args(np, "fsl,usbmisc", "#index-cells",
 74					0, &args);
 75	if (ret) {
 76		dev_err(dev, "Failed to parse property fsl,usbmisc, errno %d\n",
 77			ret);
 78		return ERR_PTR(ret);
 79	}
 80
 81	data->index = args.args[0];
 82	of_node_put(args.np);
 83
 84	if (of_find_property(np, "disable-over-current", NULL))
 85		data->disable_oc = 1;
 86
 87	if (of_find_property(np, "external-vbus-divider", NULL))
 88		data->evdo = 1;
 89
 90	return data;
 91}
 92
 93/* End of common functions shared by usbmisc drivers*/
 94
 95static int ci_hdrc_imx_probe(struct platform_device *pdev)
 96{
 97	struct ci_hdrc_imx_data *data;
 98	struct ci_hdrc_platform_data pdata = {
 99		.name		= dev_name(&pdev->dev),
100		.capoffset	= DEF_CAPOFFSET,
101		.flags		= CI_HDRC_REQUIRE_TRANSCEIVER |
102				  CI_HDRC_DISABLE_STREAMING,
103	};
104	int ret;
105	const struct of_device_id *of_id =
106			of_match_device(ci_hdrc_imx_dt_ids, &pdev->dev);
107	const struct ci_hdrc_imx_platform_flag *imx_platform_flag = of_id->data;
108
109	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
110	if (!data) {
111		dev_err(&pdev->dev, "Failed to allocate ci_hdrc-imx data!\n");
112		return -ENOMEM;
113	}
114
115	data->usbmisc_data = usbmisc_get_init_data(&pdev->dev);
116	if (IS_ERR(data->usbmisc_data))
117		return PTR_ERR(data->usbmisc_data);
118
119	data->clk = devm_clk_get(&pdev->dev, NULL);
120	if (IS_ERR(data->clk)) {
121		dev_err(&pdev->dev,
122			"Failed to get clock, err=%ld\n", PTR_ERR(data->clk));
123		return PTR_ERR(data->clk);
124	}
125
126	ret = clk_prepare_enable(data->clk);
127	if (ret) {
128		dev_err(&pdev->dev,
129			"Failed to prepare or enable clock, err=%d\n", ret);
130		return ret;
131	}
132
133	data->phy = devm_usb_get_phy_by_phandle(&pdev->dev, "fsl,usbphy", 0);
134	if (IS_ERR(data->phy)) {
135		ret = PTR_ERR(data->phy);
136		goto err_clk;
137	}
138
139	pdata.phy = data->phy;
140
141	if (imx_platform_flag->flags & CI_HDRC_IMX_IMX28_WRITE_FIX)
142		pdata.flags |= CI_HDRC_IMX28_WRITE_FIX;
143
144	ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
145	if (ret)
146		goto err_clk;
147
148	if (data->usbmisc_data) {
149		ret = imx_usbmisc_init(data->usbmisc_data);
150		if (ret) {
151			dev_err(&pdev->dev, "usbmisc init failed, ret=%d\n",
152					ret);
153			goto err_clk;
154		}
155	}
156
157	data->ci_pdev = ci_hdrc_add_device(&pdev->dev,
158				pdev->resource, pdev->num_resources,
159				&pdata);
160	if (IS_ERR(data->ci_pdev)) {
161		ret = PTR_ERR(data->ci_pdev);
162		dev_err(&pdev->dev,
163			"Can't register ci_hdrc platform device, err=%d\n",
164			ret);
165		goto err_clk;
166	}
167
168	if (data->usbmisc_data) {
169		ret = imx_usbmisc_init_post(data->usbmisc_data);
170		if (ret) {
171			dev_err(&pdev->dev, "usbmisc post failed, ret=%d\n",
172					ret);
173			goto disable_device;
174		}
175	}
176
177	platform_set_drvdata(pdev, data);
178
179	pm_runtime_no_callbacks(&pdev->dev);
180	pm_runtime_enable(&pdev->dev);
181
182	return 0;
183
184disable_device:
185	ci_hdrc_remove_device(data->ci_pdev);
186err_clk:
187	clk_disable_unprepare(data->clk);
188	return ret;
189}
190
191static int ci_hdrc_imx_remove(struct platform_device *pdev)
192{
193	struct ci_hdrc_imx_data *data = platform_get_drvdata(pdev);
194
195	pm_runtime_disable(&pdev->dev);
196	ci_hdrc_remove_device(data->ci_pdev);
197	clk_disable_unprepare(data->clk);
198
199	return 0;
200}
201
202static struct platform_driver ci_hdrc_imx_driver = {
203	.probe = ci_hdrc_imx_probe,
204	.remove = ci_hdrc_imx_remove,
205	.driver = {
206		.name = "imx_usb",
207		.owner = THIS_MODULE,
208		.of_match_table = ci_hdrc_imx_dt_ids,
209	 },
210};
211
212module_platform_driver(ci_hdrc_imx_driver);
213
214MODULE_ALIAS("platform:imx-usb");
215MODULE_LICENSE("GPL v2");
216MODULE_DESCRIPTION("CI HDRC i.MX USB binding");
217MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
218MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");