1/*
  2 * Renesas R-Car Gen2 USB phy driver
  3 *
  4 * Copyright (C) 2013 Renesas Solutions Corp.
  5 * Copyright (C) 2013 Cogent Embedded, Inc.
  6 *
  7 * This program is free software; you can redistribute it and/or modify
  8 * it under the terms of the GNU General Public License version 2 as
  9 * published by the Free Software Foundation.
 10 */
 11
 12#include <linux/clk.h>
 13#include <linux/delay.h>
 14#include <linux/io.h>
 15#include <linux/module.h>
 16#include <linux/platform_data/usb-rcar-gen2-phy.h>
 17#include <linux/platform_device.h>
 18#include <linux/spinlock.h>
 19#include <linux/usb/otg.h>
 20
 21struct rcar_gen2_usb_phy_priv {
 22	struct usb_phy phy;
 23	void __iomem *base;
 24	struct clk *clk;
 25	spinlock_t lock;
 26	int usecount;
 27	u32 ugctrl2;
 28};
 29
 30#define usb_phy_to_priv(p) container_of(p, struct rcar_gen2_usb_phy_priv, phy)
 31
 32/* Low Power Status register */
 33#define USBHS_LPSTS_REG			0x02
 34#define USBHS_LPSTS_SUSPM		(1 << 14)
 35
 36/* USB General control register */
 37#define USBHS_UGCTRL_REG		0x80
 38#define USBHS_UGCTRL_CONNECT		(1 << 2)
 39#define USBHS_UGCTRL_PLLRESET		(1 << 0)
 40
 41/* USB General control register 2 */
 42#define USBHS_UGCTRL2_REG		0x84
 43#define USBHS_UGCTRL2_USB0_PCI		(1 << 4)
 44#define USBHS_UGCTRL2_USB0_HS		(3 << 4)
 45#define USBHS_UGCTRL2_USB2_PCI		(0 << 31)
 46#define USBHS_UGCTRL2_USB2_SS		(1 << 31)
 47
 48/* USB General status register */
 49#define USBHS_UGSTS_REG			0x88
 50#define USBHS_UGSTS_LOCK		(3 << 8)
 51
 52/* Enable USBHS internal phy */
 53static int __rcar_gen2_usbhs_phy_enable(void __iomem *base)
 54{
 55	u32 val;
 56	int i;
 57
 58	/* USBHS PHY power on */
 59	val = ioread32(base + USBHS_UGCTRL_REG);
 60	val &= ~USBHS_UGCTRL_PLLRESET;
 61	iowrite32(val, base + USBHS_UGCTRL_REG);
 62
 63	val = ioread16(base + USBHS_LPSTS_REG);
 64	val |= USBHS_LPSTS_SUSPM;
 65	iowrite16(val, base + USBHS_LPSTS_REG);
 66
 67	for (i = 0; i < 20; i++) {
 68		val = ioread32(base + USBHS_UGSTS_REG);
 69		if ((val & USBHS_UGSTS_LOCK) == USBHS_UGSTS_LOCK) {
 70			val = ioread32(base + USBHS_UGCTRL_REG);
 71			val |= USBHS_UGCTRL_CONNECT;
 72			iowrite32(val, base + USBHS_UGCTRL_REG);
 73			return 0;
 74		}
 75		udelay(1);
 76	}
 77
 78	/* Timed out waiting for the PLL lock */
 79	return -ETIMEDOUT;
 80}
 81
 82/* Disable USBHS internal phy */
 83static int __rcar_gen2_usbhs_phy_disable(void __iomem *base)
 84{
 85	u32 val;
 86
 87	/* USBHS PHY power off */
 88	val = ioread32(base + USBHS_UGCTRL_REG);
 89	val &= ~USBHS_UGCTRL_CONNECT;
 90	iowrite32(val, base + USBHS_UGCTRL_REG);
 91
 92	val = ioread16(base + USBHS_LPSTS_REG);
 93	val &= ~USBHS_LPSTS_SUSPM;
 94	iowrite16(val, base + USBHS_LPSTS_REG);
 95
 96	val = ioread32(base + USBHS_UGCTRL_REG);
 97	val |= USBHS_UGCTRL_PLLRESET;
 98	iowrite32(val, base + USBHS_UGCTRL_REG);
 99	return 0;
100}
101
102/* Setup USB channels */
103static void __rcar_gen2_usb_phy_init(struct rcar_gen2_usb_phy_priv *priv)
104{
105	u32 val;
106
107	clk_prepare_enable(priv->clk);
108
109	/* Set USB channels in the USBHS UGCTRL2 register */
110	val = ioread32(priv->base + USBHS_UGCTRL2_REG);
111	val &= ~(USBHS_UGCTRL2_USB0_HS | USBHS_UGCTRL2_USB2_SS);
112	val |= priv->ugctrl2;
113	iowrite32(val, priv->base + USBHS_UGCTRL2_REG);
114}
115
116/* Shutdown USB channels */
117static void __rcar_gen2_usb_phy_shutdown(struct rcar_gen2_usb_phy_priv *priv)
118{
119	__rcar_gen2_usbhs_phy_disable(priv->base);
120	clk_disable_unprepare(priv->clk);
121}
122
123static int rcar_gen2_usb_phy_set_suspend(struct usb_phy *phy, int suspend)
124{
125	struct rcar_gen2_usb_phy_priv *priv = usb_phy_to_priv(phy);
126	unsigned long flags;
127	int retval;
128
129	spin_lock_irqsave(&priv->lock, flags);
130	retval = suspend ? __rcar_gen2_usbhs_phy_disable(priv->base) :
131			   __rcar_gen2_usbhs_phy_enable(priv->base);
132	spin_unlock_irqrestore(&priv->lock, flags);
133	return retval;
134}
135
136static int rcar_gen2_usb_phy_init(struct usb_phy *phy)
137{
138	struct rcar_gen2_usb_phy_priv *priv = usb_phy_to_priv(phy);
139	unsigned long flags;
140
141	spin_lock_irqsave(&priv->lock, flags);
142	/*
143	 * Enable the clock and setup USB channels
144	 * if it's the first user
145	 */
146	if (!priv->usecount++)
147		__rcar_gen2_usb_phy_init(priv);
148	spin_unlock_irqrestore(&priv->lock, flags);
149	return 0;
150}
151
152static void rcar_gen2_usb_phy_shutdown(struct usb_phy *phy)
153{
154	struct rcar_gen2_usb_phy_priv *priv = usb_phy_to_priv(phy);
155	unsigned long flags;
156
157	spin_lock_irqsave(&priv->lock, flags);
158	if (!priv->usecount) {
159		dev_warn(phy->dev, "Trying to disable phy with 0 usecount\n");
160		goto out;
161	}
162
163	/* Disable everything if it's the last user */
164	if (!--priv->usecount)
165		__rcar_gen2_usb_phy_shutdown(priv);
166out:
167	spin_unlock_irqrestore(&priv->lock, flags);
168}
169
170static int rcar_gen2_usb_phy_probe(struct platform_device *pdev)
171{
172	struct device *dev = &pdev->dev;
173	struct rcar_gen2_phy_platform_data *pdata;
174	struct rcar_gen2_usb_phy_priv *priv;
175	struct resource *res;
176	void __iomem *base;
177	struct clk *clk;
178	int retval;
179
180	pdata = dev_get_platdata(dev);
181	if (!pdata) {
182		dev_err(dev, "No platform data\n");
183		return -EINVAL;
184	}
185
186	clk = devm_clk_get(dev, "usbhs");
187	if (IS_ERR(clk)) {
188		dev_err(dev, "Can't get the clock\n");
189		return PTR_ERR(clk);
190	}
191
192	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
193	base = devm_ioremap_resource(dev, res);
194	if (IS_ERR(base))
195		return PTR_ERR(base);
196
197	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
198	if (!priv) {
199		dev_err(dev, "Memory allocation failed\n");
200		return -ENOMEM;
201	}
202
203	spin_lock_init(&priv->lock);
204	priv->clk = clk;
205	priv->base = base;
206	priv->ugctrl2 = pdata->chan0_pci ?
207			USBHS_UGCTRL2_USB0_PCI : USBHS_UGCTRL2_USB0_HS;
208	priv->ugctrl2 |= pdata->chan2_pci ?
209			USBHS_UGCTRL2_USB2_PCI : USBHS_UGCTRL2_USB2_SS;
210	priv->phy.dev = dev;
211	priv->phy.label = dev_name(dev);
212	priv->phy.init = rcar_gen2_usb_phy_init;
213	priv->phy.shutdown = rcar_gen2_usb_phy_shutdown;
214	priv->phy.set_suspend = rcar_gen2_usb_phy_set_suspend;
215
216	retval = usb_add_phy_dev(&priv->phy);
217	if (retval < 0) {
218		dev_err(dev, "Failed to add USB phy\n");
219		return retval;
220	}
221
222	platform_set_drvdata(pdev, priv);
223
224	return retval;
225}
226
227static int rcar_gen2_usb_phy_remove(struct platform_device *pdev)
228{
229	struct rcar_gen2_usb_phy_priv *priv = platform_get_drvdata(pdev);
230
231	usb_remove_phy(&priv->phy);
232
233	return 0;
234}
235
236static struct platform_driver rcar_gen2_usb_phy_driver = {
237	.driver = {
238		.name = "usb_phy_rcar_gen2",
239	},
240	.probe = rcar_gen2_usb_phy_probe,
241	.remove = rcar_gen2_usb_phy_remove,
242};
243
244module_platform_driver(rcar_gen2_usb_phy_driver);
245
246MODULE_LICENSE("GPL v2");
247MODULE_DESCRIPTION("Renesas R-Car Gen2 USB phy");
248MODULE_AUTHOR("Valentine Barshak <valentine.barshak@cogentembedded.com>");