1/*
  2 * SAMSUNG EXYNOS USB HOST OHCI Controller
  3 *
  4 * Copyright (C) 2011 Samsung Electronics Co.Ltd
  5 * Author: Jingoo Han <jg1.han@samsung.com>
  6 *
  7 * This program is free software; you can redistribute  it and/or modify it
  8 * under  the terms of  the GNU General  Public License as published by the
  9 * Free Software Foundation;  either version 2 of the  License, or (at your
 10 * option) any later version.
 11 *
 12 */
 13
 14#include <linux/clk.h>
 15#include <linux/dma-mapping.h>
 16#include <linux/io.h>
 17#include <linux/kernel.h>
 18#include <linux/module.h>
 19#include <linux/of.h>
 20#include <linux/platform_device.h>
 21#include <linux/usb/phy.h>
 22#include <linux/usb/samsung_usb_phy.h>
 23#include <linux/usb.h>
 24#include <linux/usb/hcd.h>
 25#include <linux/usb/otg.h>
 26
 27#include "ohci.h"
 28
 29#define DRIVER_DESC "OHCI EXYNOS driver"
 30
 31static const char hcd_name[] = "ohci-exynos";
 32static struct hc_driver __read_mostly exynos_ohci_hc_driver;
 33
 34#define to_exynos_ohci(hcd) (struct exynos_ohci_hcd *)(hcd_to_ohci(hcd)->priv)
 35
 36struct exynos_ohci_hcd {
 37	struct clk *clk;
 38	struct usb_phy *phy;
 39	struct usb_otg *otg;
 40};
 41
 42static void exynos_ohci_phy_enable(struct platform_device *pdev)
 43{
 44	struct usb_hcd *hcd = platform_get_drvdata(pdev);
 45	struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
 46
 47	if (exynos_ohci->phy)
 48		usb_phy_init(exynos_ohci->phy);
 49}
 50
 51static void exynos_ohci_phy_disable(struct platform_device *pdev)
 52{
 53	struct usb_hcd *hcd = platform_get_drvdata(pdev);
 54	struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
 55
 56	if (exynos_ohci->phy)
 57		usb_phy_shutdown(exynos_ohci->phy);
 58}
 59
 60static int exynos_ohci_probe(struct platform_device *pdev)
 61{
 62	struct exynos_ohci_hcd *exynos_ohci;
 63	struct usb_hcd *hcd;
 64	struct resource *res;
 65	struct usb_phy *phy;
 66	int irq;
 67	int err;
 68
 69	/*
 70	 * Right now device-tree probed devices don't get dma_mask set.
 71	 * Since shared usb code relies on it, set it here for now.
 72	 * Once we move to full device tree support this will vanish off.
 73	 */
 74	err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
 75	if (err)
 76		return err;
 77
 78	hcd = usb_create_hcd(&exynos_ohci_hc_driver,
 79				&pdev->dev, dev_name(&pdev->dev));
 80	if (!hcd) {
 81		dev_err(&pdev->dev, "Unable to create HCD\n");
 82		return -ENOMEM;
 83	}
 84
 85	exynos_ohci = to_exynos_ohci(hcd);
 86
 87	if (of_device_is_compatible(pdev->dev.of_node,
 88					"samsung,exynos5440-ohci"))
 89		goto skip_phy;
 90
 91	phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
 92	if (IS_ERR(phy)) {
 93		usb_put_hcd(hcd);
 94		dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
 95		return -EPROBE_DEFER;
 96	} else {
 97		exynos_ohci->phy = phy;
 98		exynos_ohci->otg = phy->otg;
 99	}
100
101skip_phy:
102	exynos_ohci->clk = devm_clk_get(&pdev->dev, "usbhost");
103
104	if (IS_ERR(exynos_ohci->clk)) {
105		dev_err(&pdev->dev, "Failed to get usbhost clock\n");
106		err = PTR_ERR(exynos_ohci->clk);
107		goto fail_clk;
108	}
109
110	err = clk_prepare_enable(exynos_ohci->clk);
111	if (err)
112		goto fail_clk;
113
114	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
115	if (!res) {
116		dev_err(&pdev->dev, "Failed to get I/O memory\n");
117		err = -ENXIO;
118		goto fail_io;
119	}
120
121	hcd->rsrc_start = res->start;
122	hcd->rsrc_len = resource_size(res);
123	hcd->regs = devm_ioremap(&pdev->dev, res->start, hcd->rsrc_len);
124	if (!hcd->regs) {
125		dev_err(&pdev->dev, "Failed to remap I/O memory\n");
126		err = -ENOMEM;
127		goto fail_io;
128	}
129
130	irq = platform_get_irq(pdev, 0);
131	if (!irq) {
132		dev_err(&pdev->dev, "Failed to get IRQ\n");
133		err = -ENODEV;
134		goto fail_io;
135	}
136
137	if (exynos_ohci->otg)
138		exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
139
140	platform_set_drvdata(pdev, hcd);
141
142	exynos_ohci_phy_enable(pdev);
143
144	err = usb_add_hcd(hcd, irq, IRQF_SHARED);
145	if (err) {
146		dev_err(&pdev->dev, "Failed to add USB HCD\n");
147		goto fail_add_hcd;
148	}
149	device_wakeup_enable(hcd->self.controller);
150	return 0;
151
152fail_add_hcd:
153	exynos_ohci_phy_disable(pdev);
154fail_io:
155	clk_disable_unprepare(exynos_ohci->clk);
156fail_clk:
157	usb_put_hcd(hcd);
158	return err;
159}
160
161static int exynos_ohci_remove(struct platform_device *pdev)
162{
163	struct usb_hcd *hcd = platform_get_drvdata(pdev);
164	struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
165
166	usb_remove_hcd(hcd);
167
168	if (exynos_ohci->otg)
169		exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
170
171	exynos_ohci_phy_disable(pdev);
172
173	clk_disable_unprepare(exynos_ohci->clk);
174
175	usb_put_hcd(hcd);
176
177	return 0;
178}
179
180static void exynos_ohci_shutdown(struct platform_device *pdev)
181{
182	struct usb_hcd *hcd = platform_get_drvdata(pdev);
183
184	if (hcd->driver->shutdown)
185		hcd->driver->shutdown(hcd);
186}
187
188#ifdef CONFIG_PM
189static int exynos_ohci_suspend(struct device *dev)
190{
191	struct usb_hcd *hcd = dev_get_drvdata(dev);
192	struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
193	struct ohci_hcd *ohci = hcd_to_ohci(hcd);
194	struct platform_device *pdev = to_platform_device(dev);
195	bool do_wakeup = device_may_wakeup(dev);
196	unsigned long flags;
197	int rc = ohci_suspend(hcd, do_wakeup);
198
199	if (rc)
200		return rc;
201
202	spin_lock_irqsave(&ohci->lock, flags);
203
204	if (exynos_ohci->otg)
205		exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
206
207	exynos_ohci_phy_disable(pdev);
208
209	clk_disable_unprepare(exynos_ohci->clk);
210
211	spin_unlock_irqrestore(&ohci->lock, flags);
212
213	return 0;
214}
215
216static int exynos_ohci_resume(struct device *dev)
217{
218	struct usb_hcd *hcd			= dev_get_drvdata(dev);
219	struct exynos_ohci_hcd *exynos_ohci	= to_exynos_ohci(hcd);
220	struct platform_device *pdev		= to_platform_device(dev);
221
222	clk_prepare_enable(exynos_ohci->clk);
223
224	if (exynos_ohci->otg)
225		exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
226
227	exynos_ohci_phy_enable(pdev);
228
229	ohci_resume(hcd, false);
230
231	return 0;
232}
233#else
234#define exynos_ohci_suspend	NULL
235#define exynos_ohci_resume	NULL
236#endif
237
238static const struct ohci_driver_overrides exynos_overrides __initconst = {
239	.extra_priv_size =	sizeof(struct exynos_ohci_hcd),
240};
241
242static const struct dev_pm_ops exynos_ohci_pm_ops = {
243	.suspend	= exynos_ohci_suspend,
244	.resume		= exynos_ohci_resume,
245};
246
247#ifdef CONFIG_OF
248static const struct of_device_id exynos_ohci_match[] = {
249	{ .compatible = "samsung,exynos4210-ohci" },
250	{ .compatible = "samsung,exynos5440-ohci" },
251	{},
252};
253MODULE_DEVICE_TABLE(of, exynos_ohci_match);
254#endif
255
256static struct platform_driver exynos_ohci_driver = {
257	.probe		= exynos_ohci_probe,
258	.remove		= exynos_ohci_remove,
259	.shutdown	= exynos_ohci_shutdown,
260	.driver = {
261		.name	= "exynos-ohci",
262		.owner	= THIS_MODULE,
263		.pm	= &exynos_ohci_pm_ops,
264		.of_match_table	= of_match_ptr(exynos_ohci_match),
265	}
266};
267static int __init ohci_exynos_init(void)
268{
269	if (usb_disabled())
270		return -ENODEV;
271
272	pr_info("%s: " DRIVER_DESC "\n", hcd_name);
273	ohci_init_driver(&exynos_ohci_hc_driver, &exynos_overrides);
274	return platform_driver_register(&exynos_ohci_driver);
275}
276module_init(ohci_exynos_init);
277
278static void __exit ohci_exynos_cleanup(void)
279{
280	platform_driver_unregister(&exynos_ohci_driver);
281}
282module_exit(ohci_exynos_cleanup);
283
284MODULE_ALIAS("platform:exynos-ohci");
285MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
286MODULE_LICENSE("GPL v2");