usb: dwc2: gadget: initialize controller in pullup callback
[deliverable/linux.git] / drivers / usb / phy / phy-generic.c
CommitLineData
f6d92a05 1/*
f6d92a05
AKG
2 * NOP USB transceiver for all USB transceiver which are either built-in
3 * into USB IP or which are mostly autonomous.
4 *
5 * Copyright (C) 2009 Texas Instruments Inc
6 * Author: Ajay Kumar Gupta <ajay.gupta@ti.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
22 * Current status:
cc835e32
DB
23 * This provides a "nop" transceiver for PHYs which are
24 * autonomous such as isp1504, isp1707, etc.
f6d92a05
AKG
25 */
26
27#include <linux/module.h>
28#include <linux/platform_device.h>
29#include <linux/dma-mapping.h>
7acc9973 30#include <linux/usb/gadget.h>
f6d92a05 31#include <linux/usb/otg.h>
d7078df6 32#include <linux/usb/usb_phy_generic.h>
5a0e3ad6 33#include <linux/slab.h>
2319fb88 34#include <linux/clk.h>
58f735fe 35#include <linux/regulator/consumer.h>
0eba3879 36#include <linux/of.h>
bd27fa44
RQ
37#include <linux/of_gpio.h>
38#include <linux/gpio.h>
39#include <linux/delay.h>
f6d92a05 40
53b6fc28 41#include "phy-generic.h"
f6d92a05 42
7acc9973
RJ
43#define VBUS_IRQ_FLAGS \
44 (IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)
45
2f36ff69 46struct platform_device *usb_phy_generic_register(void)
f6d92a05 47{
2f36ff69
FB
48 return platform_device_register_simple("usb_phy_generic",
49 PLATFORM_DEVID_AUTO, NULL, 0);
f6d92a05 50}
4525beeb 51EXPORT_SYMBOL_GPL(usb_phy_generic_register);
f6d92a05 52
2f36ff69 53void usb_phy_generic_unregister(struct platform_device *pdev)
f6d92a05 54{
2f36ff69 55 platform_device_unregister(pdev);
f6d92a05 56}
4525beeb 57EXPORT_SYMBOL_GPL(usb_phy_generic_unregister);
f6d92a05 58
86753811 59static int nop_set_suspend(struct usb_phy *x, int suspend)
f6d92a05
AKG
60{
61 return 0;
62}
63
4525beeb 64static void nop_reset_set(struct usb_phy_generic *nop, int asserted)
bd27fa44 65{
e9f2cefb
RJ
66 if (nop->gpiod_reset)
67 gpiod_set_value(nop->gpiod_reset, asserted);
bd27fa44
RQ
68
69 if (!asserted)
70 usleep_range(10000, 20000);
71}
72
7acc9973
RJ
73/* interface to regulator framework */
74static void nop_set_vbus_draw(struct usb_phy_generic *nop, unsigned mA)
75{
76 struct regulator *vbus_draw = nop->vbus_draw;
77 int enabled;
78 int ret;
79
80 if (!vbus_draw)
81 return;
82
83 enabled = nop->vbus_draw_enabled;
84 if (mA) {
85 regulator_set_current_limit(vbus_draw, 0, 1000 * mA);
86 if (!enabled) {
87 ret = regulator_enable(vbus_draw);
88 if (ret < 0)
89 return;
90 nop->vbus_draw_enabled = 1;
91 }
92 } else {
93 if (enabled) {
94 ret = regulator_disable(vbus_draw);
95 if (ret < 0)
96 return;
97 nop->vbus_draw_enabled = 0;
98 }
99 }
100 nop->mA = mA;
101}
102
103
104static irqreturn_t nop_gpio_vbus_thread(int irq, void *data)
105{
106 struct usb_phy_generic *nop = data;
107 struct usb_otg *otg = nop->phy.otg;
108 int vbus, status;
109
110 vbus = gpiod_get_value(nop->gpiod_vbus);
111 if ((vbus ^ nop->vbus) == 0)
112 return IRQ_HANDLED;
113 nop->vbus = vbus;
114
115 if (vbus) {
116 status = USB_EVENT_VBUS;
117 otg->state = OTG_STATE_B_PERIPHERAL;
118 nop->phy.last_event = status;
119 usb_gadget_vbus_connect(otg->gadget);
120
121 /* drawing a "unit load" is *always* OK, except for OTG */
122 nop_set_vbus_draw(nop, 100);
123
124 atomic_notifier_call_chain(&nop->phy.notifier, status,
125 otg->gadget);
126 } else {
127 nop_set_vbus_draw(nop, 0);
128
129 usb_gadget_vbus_disconnect(otg->gadget);
130 status = USB_EVENT_NONE;
131 otg->state = OTG_STATE_B_IDLE;
132 nop->phy.last_event = status;
133
134 atomic_notifier_call_chain(&nop->phy.notifier, status,
135 otg->gadget);
136 }
137 return IRQ_HANDLED;
138}
139
53b6fc28 140int usb_gen_phy_init(struct usb_phy *phy)
2319fb88 141{
4525beeb 142 struct usb_phy_generic *nop = dev_get_drvdata(phy->dev);
2319fb88 143
58f735fe
RQ
144 if (!IS_ERR(nop->vcc)) {
145 if (regulator_enable(nop->vcc))
146 dev_err(phy->dev, "Failed to enable power\n");
147 }
148
2319fb88 149 if (!IS_ERR(nop->clk))
4d175f34 150 clk_prepare_enable(nop->clk);
2319fb88 151
bd27fa44
RQ
152 /* De-assert RESET */
153 nop_reset_set(nop, 0);
ad63ebfc 154
2319fb88
RQ
155 return 0;
156}
53b6fc28 157EXPORT_SYMBOL_GPL(usb_gen_phy_init);
2319fb88 158
53b6fc28 159void usb_gen_phy_shutdown(struct usb_phy *phy)
2319fb88 160{
4525beeb 161 struct usb_phy_generic *nop = dev_get_drvdata(phy->dev);
2319fb88 162
bd27fa44
RQ
163 /* Assert RESET */
164 nop_reset_set(nop, 1);
ad63ebfc 165
2319fb88 166 if (!IS_ERR(nop->clk))
4d175f34 167 clk_disable_unprepare(nop->clk);
58f735fe
RQ
168
169 if (!IS_ERR(nop->vcc)) {
170 if (regulator_disable(nop->vcc))
171 dev_err(phy->dev, "Failed to disable power\n");
172 }
2319fb88 173}
53b6fc28 174EXPORT_SYMBOL_GPL(usb_gen_phy_shutdown);
2319fb88 175
41adf109 176static int nop_set_peripheral(struct usb_otg *otg, struct usb_gadget *gadget)
f6d92a05 177{
41adf109 178 if (!otg)
f6d92a05
AKG
179 return -ENODEV;
180
f6d92a05 181 if (!gadget) {
41adf109 182 otg->gadget = NULL;
f6d92a05
AKG
183 return -ENODEV;
184 }
185
41adf109 186 otg->gadget = gadget;
e47d9254 187 otg->state = OTG_STATE_B_IDLE;
f6d92a05
AKG
188 return 0;
189}
190
41adf109 191static int nop_set_host(struct usb_otg *otg, struct usb_bus *host)
f6d92a05 192{
41adf109 193 if (!otg)
f6d92a05
AKG
194 return -ENODEV;
195
f6d92a05 196 if (!host) {
41adf109 197 otg->host = NULL;
f6d92a05
AKG
198 return -ENODEV;
199 }
200
41adf109 201 otg->host = host;
f6d92a05
AKG
202 return 0;
203}
204
4525beeb
FB
205int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_generic *nop,
206 struct usb_phy_generic_platform_data *pdata)
f6d92a05 207{
af9f51c5 208 enum usb_phy_type type = USB_PHY_TYPE_USB2;
e9f2cefb 209 int err = 0;
f6d92a05 210
af9f51c5
FB
211 u32 clk_rate = 0;
212 bool needs_vcc = false;
213
af9f51c5
FB
214 if (dev->of_node) {
215 struct device_node *node = dev->of_node;
af9f51c5
FB
216
217 if (of_property_read_u32(node, "clock-frequency", &clk_rate))
218 clk_rate = 0;
219
220 needs_vcc = of_property_read_bool(node, "vcc-supply");
da89dba1 221 nop->gpiod_reset = devm_gpiod_get_optional(dev, "reset-gpios");
e9f2cefb 222 err = PTR_ERR(nop->gpiod_reset);
7acc9973 223 if (!err) {
da89dba1 224 nop->gpiod_vbus = devm_gpiod_get_optional(dev,
7acc9973
RJ
225 "vbus-detect-gpio");
226 err = PTR_ERR(nop->gpiod_vbus);
227 }
af9f51c5
FB
228 } else if (pdata) {
229 type = pdata->type;
230 clk_rate = pdata->clk_rate;
231 needs_vcc = pdata->needs_vcc;
7acc9973 232 if (gpio_is_valid(pdata->gpio_reset)) {
e9f2cefb
RJ
233 err = devm_gpio_request_one(dev, pdata->gpio_reset, 0,
234 dev_name(dev));
235 if (!err)
236 nop->gpiod_reset =
237 gpio_to_desc(pdata->gpio_reset);
238 }
7acc9973 239 nop->gpiod_vbus = pdata->gpiod_vbus;
e9f2cefb
RJ
240 }
241
242 if (err == -EPROBE_DEFER)
243 return -EPROBE_DEFER;
244 if (err) {
245 dev_err(dev, "Error requesting RESET GPIO\n");
246 return err;
af9f51c5
FB
247 }
248
53b6fc28
SAS
249 nop->phy.otg = devm_kzalloc(dev, sizeof(*nop->phy.otg),
250 GFP_KERNEL);
e4d7dc66 251 if (!nop->phy.otg)
41adf109 252 return -ENOMEM;
41adf109 253
53b6fc28 254 nop->clk = devm_clk_get(dev, "main_clk");
2319fb88 255 if (IS_ERR(nop->clk)) {
53b6fc28 256 dev_dbg(dev, "Can't get phy clock: %ld\n",
2319fb88
RQ
257 PTR_ERR(nop->clk));
258 }
259
0eba3879
RQ
260 if (!IS_ERR(nop->clk) && clk_rate) {
261 err = clk_set_rate(nop->clk, clk_rate);
2319fb88 262 if (err) {
53b6fc28 263 dev_err(dev, "Error setting clock rate\n");
2319fb88
RQ
264 return err;
265 }
266 }
267
53b6fc28 268 nop->vcc = devm_regulator_get(dev, "vcc");
58f735fe 269 if (IS_ERR(nop->vcc)) {
53b6fc28 270 dev_dbg(dev, "Error getting vcc regulator: %ld\n",
58f735fe 271 PTR_ERR(nop->vcc));
b54b5f56
RQ
272 if (needs_vcc)
273 return -EPROBE_DEFER;
58f735fe
RQ
274 }
275
53b6fc28 276 nop->dev = dev;
41adf109
HK
277 nop->phy.dev = nop->dev;
278 nop->phy.label = "nop-xceiv";
279 nop->phy.set_suspend = nop_set_suspend;
90f4232f 280 nop->phy.type = type;
41adf109 281
e47d9254 282 nop->phy.otg->state = OTG_STATE_UNDEFINED;
19c1eac2 283 nop->phy.otg->usb_phy = &nop->phy;
41adf109
HK
284 nop->phy.otg->set_host = nop_set_host;
285 nop->phy.otg->set_peripheral = nop_set_peripheral;
286
53b6fc28
SAS
287 return 0;
288}
289EXPORT_SYMBOL_GPL(usb_phy_gen_create_phy);
290
4525beeb 291static int usb_phy_generic_probe(struct platform_device *pdev)
53b6fc28
SAS
292{
293 struct device *dev = &pdev->dev;
4525beeb 294 struct usb_phy_generic *nop;
53b6fc28 295 int err;
bd27fa44
RQ
296
297 nop = devm_kzalloc(dev, sizeof(*nop), GFP_KERNEL);
298 if (!nop)
299 return -ENOMEM;
300
af9f51c5 301 err = usb_phy_gen_create_phy(dev, nop, dev_get_platdata(&pdev->dev));
53b6fc28
SAS
302 if (err)
303 return err;
7acc9973
RJ
304 if (nop->gpiod_vbus) {
305 err = devm_request_threaded_irq(&pdev->dev,
306 gpiod_to_irq(nop->gpiod_vbus),
307 NULL, nop_gpio_vbus_thread,
308 VBUS_IRQ_FLAGS, "vbus_detect",
309 nop);
310 if (err) {
311 dev_err(&pdev->dev, "can't request irq %i, err: %d\n",
312 gpiod_to_irq(nop->gpiod_vbus), err);
313 return err;
314 }
315 }
53b6fc28
SAS
316
317 nop->phy.init = usb_gen_phy_init;
318 nop->phy.shutdown = usb_gen_phy_shutdown;
319
90f4232f 320 err = usb_add_phy_dev(&nop->phy);
f6d92a05
AKG
321 if (err) {
322 dev_err(&pdev->dev, "can't register transceiver, err: %d\n",
323 err);
4d175f34 324 return err;
f6d92a05
AKG
325 }
326
327 platform_set_drvdata(pdev, nop);
328
329 return 0;
f6d92a05
AKG
330}
331
4525beeb 332static int usb_phy_generic_remove(struct platform_device *pdev)
f6d92a05 333{
4525beeb 334 struct usb_phy_generic *nop = platform_get_drvdata(pdev);
f6d92a05 335
662dca54 336 usb_remove_phy(&nop->phy);
f6d92a05 337
f6d92a05
AKG
338 return 0;
339}
340
0eba3879
RQ
341static const struct of_device_id nop_xceiv_dt_ids[] = {
342 { .compatible = "usb-nop-xceiv" },
343 { }
344};
345
346MODULE_DEVICE_TABLE(of, nop_xceiv_dt_ids);
347
4525beeb
FB
348static struct platform_driver usb_phy_generic_driver = {
349 .probe = usb_phy_generic_probe,
350 .remove = usb_phy_generic_remove,
f6d92a05 351 .driver = {
4525beeb 352 .name = "usb_phy_generic",
5462b0db 353 .of_match_table = nop_xceiv_dt_ids,
f6d92a05
AKG
354 },
355};
356
4525beeb 357static int __init usb_phy_generic_init(void)
f6d92a05 358{
4525beeb 359 return platform_driver_register(&usb_phy_generic_driver);
f6d92a05 360}
4525beeb 361subsys_initcall(usb_phy_generic_init);
f6d92a05 362
4525beeb 363static void __exit usb_phy_generic_exit(void)
f6d92a05 364{
4525beeb 365 platform_driver_unregister(&usb_phy_generic_driver);
f6d92a05 366}
4525beeb 367module_exit(usb_phy_generic_exit);
f6d92a05 368
4525beeb 369MODULE_ALIAS("platform:usb_phy_generic");
f6d92a05
AKG
370MODULE_AUTHOR("Texas Instruments Inc");
371MODULE_DESCRIPTION("NOP USB Transceiver driver");
372MODULE_LICENSE("GPL");
This page took 0.479572 seconds and 5 git commands to generate.