diff options
Diffstat (limited to 'drivers/usb/phy/phy-rcar-gen2-usb.c')
-rw-r--r-- | drivers/usb/phy/phy-rcar-gen2-usb.c | 248 |
1 files changed, 248 insertions, 0 deletions
diff --git a/drivers/usb/phy/phy-rcar-gen2-usb.c b/drivers/usb/phy/phy-rcar-gen2-usb.c new file mode 100644 index 000000000000..a99a6953f11c --- /dev/null +++ b/drivers/usb/phy/phy-rcar-gen2-usb.c | |||
@@ -0,0 +1,248 @@ | |||
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 | |||
21 | struct 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 */ | ||
53 | static 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 */ | ||
83 | static 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 */ | ||
103 | static 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); | ||
111 | val &= ~(USBHS_UGCTRL2_USB0_HS | USBHS_UGCTRL2_USB2_SS); | ||
112 | val |= priv->ugctrl2; | ||
113 | iowrite32(val, priv->base); | ||
114 | } | ||
115 | |||
116 | /* Shutdown USB channels */ | ||
117 | static 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 | |||
123 | static 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 | |||
136 | static 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 | |||
152 | static 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); | ||
166 | out: | ||
167 | spin_unlock_irqrestore(&priv->lock, flags); | ||
168 | } | ||
169 | |||
170 | static 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(&pdev->dev); | ||
181 | if (!pdata) { | ||
182 | dev_err(dev, "No platform data\n"); | ||
183 | return -EINVAL; | ||
184 | } | ||
185 | |||
186 | clk = devm_clk_get(&pdev->dev, "usbhs"); | ||
187 | if (IS_ERR(clk)) { | ||
188 | dev_err(&pdev->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(&priv->phy, USB_PHY_TYPE_USB2); | ||
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 | |||
227 | static 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 | |||
236 | static 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 | |||
244 | module_platform_driver(rcar_gen2_usb_phy_driver); | ||
245 | |||
246 | MODULE_LICENSE("GPL v2"); | ||
247 | MODULE_DESCRIPTION("Renesas R-Car Gen2 USB phy"); | ||
248 | MODULE_AUTHOR("Valentine Barshak <valentine.barshak@cogentembedded.com>"); | ||