1/*
2 * Driver for SMSC USB3503 USB 2.0 hub controller driver
3 *
4 * Copyright (c) 2012-2013 Dongjin Kim (tobetter@gmail.com)
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19 */
20
21#include <linux/clk.h>
22#include <linux/i2c.h>
23#include <linux/gpio.h>
24#include <linux/delay.h>
25#include <linux/slab.h>
26#include <linux/module.h>
27#include <linux/of_gpio.h>
28#include <linux/platform_device.h>
29#include <linux/platform_data/usb3503.h>
30#include <linux/regmap.h>
31
32#define USB3503_VIDL		0x00
33#define USB3503_VIDM		0x01
34#define USB3503_PIDL		0x02
35#define USB3503_PIDM		0x03
36#define USB3503_DIDL		0x04
37#define USB3503_DIDM		0x05
38
39#define USB3503_CFG1		0x06
40#define USB3503_SELF_BUS_PWR	(1 << 7)
41
42#define USB3503_CFG2		0x07
43#define USB3503_CFG3		0x08
44#define USB3503_NRD		0x09
45
46#define USB3503_PDS		0x0a
47
48#define USB3503_SP_ILOCK	0xe7
49#define USB3503_SPILOCK_CONNECT	(1 << 1)
50#define USB3503_SPILOCK_CONFIG	(1 << 0)
51
52#define USB3503_CFGP		0xee
53#define USB3503_CLKSUSP		(1 << 7)
54
55#define USB3503_RESET		0xff
56
57struct usb3503 {
58	enum usb3503_mode	mode;
59	struct regmap		*regmap;
60	struct device		*dev;
61	struct clk		*clk;
62	u8	port_off_mask;
63	int	gpio_intn;
64	int	gpio_reset;
65	int	gpio_connect;
66	bool	secondary_ref_clk;
67};
68
69static int usb3503_reset(struct usb3503 *hub, int state)
70{
71	if (!state && gpio_is_valid(hub->gpio_connect))
72		gpio_set_value_cansleep(hub->gpio_connect, 0);
73
74	if (gpio_is_valid(hub->gpio_reset))
75		gpio_set_value_cansleep(hub->gpio_reset, state);
76
77	/* Wait T_HUBINIT == 4ms for hub logic to stabilize */
78	if (state)
79		usleep_range(4000, 10000);
80
81	return 0;
82}
83
84static int usb3503_connect(struct usb3503 *hub)
85{
86	struct device *dev = hub->dev;
87	int err;
88
89	usb3503_reset(hub, 1);
90
91	if (hub->regmap) {
92		/* SP_ILOCK: set connect_n, config_n for config */
93		err = regmap_write(hub->regmap, USB3503_SP_ILOCK,
94			   (USB3503_SPILOCK_CONNECT
95				 | USB3503_SPILOCK_CONFIG));
96		if (err < 0) {
97			dev_err(dev, "SP_ILOCK failed (%d)\n", err);
98			return err;
99		}
100
101		/* PDS : Set the ports which are disabled in self-powered mode. */
102		if (hub->port_off_mask) {
103			err = regmap_update_bits(hub->regmap, USB3503_PDS,
104					hub->port_off_mask,
105					hub->port_off_mask);
106			if (err < 0) {
107				dev_err(dev, "PDS failed (%d)\n", err);
108				return err;
109			}
110		}
111
112		/* CFG1 : Set SELF_BUS_PWR, this enables self-powered operation. */
113		err = regmap_update_bits(hub->regmap, USB3503_CFG1,
114					 USB3503_SELF_BUS_PWR,
115					 USB3503_SELF_BUS_PWR);
116		if (err < 0) {
117			dev_err(dev, "CFG1 failed (%d)\n", err);
118			return err;
119		}
120
121		/* SP_LOCK: clear connect_n, config_n for hub connect */
122		err = regmap_update_bits(hub->regmap, USB3503_SP_ILOCK,
123					 (USB3503_SPILOCK_CONNECT
124					  | USB3503_SPILOCK_CONFIG), 0);
125		if (err < 0) {
126			dev_err(dev, "SP_ILOCK failed (%d)\n", err);
127			return err;
128		}
129	}
130
131	if (gpio_is_valid(hub->gpio_connect))
132		gpio_set_value_cansleep(hub->gpio_connect, 1);
133
134	hub->mode = USB3503_MODE_HUB;
135	dev_info(dev, "switched to HUB mode\n");
136
137	return 0;
138}
139
140static int usb3503_switch_mode(struct usb3503 *hub, enum usb3503_mode mode)
141{
142	struct device *dev = hub->dev;
143	int err = 0;
144
145	switch (mode) {
146	case USB3503_MODE_HUB:
147		err = usb3503_connect(hub);
148		break;
149
150	case USB3503_MODE_STANDBY:
151		usb3503_reset(hub, 0);
152		dev_info(dev, "switched to STANDBY mode\n");
153		break;
154
155	default:
156		dev_err(dev, "unknown mode is requested\n");
157		err = -EINVAL;
158		break;
159	}
160
161	return err;
162}
163
164static const struct regmap_config usb3503_regmap_config = {
165	.reg_bits = 8,
166	.val_bits = 8,
167
168	.max_register = USB3503_RESET,
169};
170
171static int usb3503_probe(struct usb3503 *hub)
172{
173	struct device *dev = hub->dev;
174	struct usb3503_platform_data *pdata = dev_get_platdata(dev);
175	struct device_node *np = dev->of_node;
176	int err;
177	u32 mode = USB3503_MODE_HUB;
178	const u32 *property;
179	int len;
180
181	if (pdata) {
182		hub->port_off_mask	= pdata->port_off_mask;
183		hub->gpio_intn		= pdata->gpio_intn;
184		hub->gpio_connect	= pdata->gpio_connect;
185		hub->gpio_reset		= pdata->gpio_reset;
186		hub->mode		= pdata->initial_mode;
187	} else if (np) {
188		struct clk *clk;
189		u32 rate = 0;
190		hub->port_off_mask = 0;
191
192		if (!of_property_read_u32(np, "refclk-frequency", &rate)) {
193			switch (rate) {
194			case 38400000:
195			case 26000000:
196			case 19200000:
197			case 12000000:
198				hub->secondary_ref_clk = 0;
199				break;
200			case 24000000:
201			case 27000000:
202			case 25000000:
203			case 50000000:
204				hub->secondary_ref_clk = 1;
205				break;
206			default:
207				dev_err(dev,
208					"unsupported reference clock rate (%d)\n",
209					(int) rate);
210				return -EINVAL;
211			}
212		}
213
214		clk = devm_clk_get(dev, "refclk");
215		if (IS_ERR(clk) && PTR_ERR(clk) != -ENOENT) {
216			dev_err(dev, "unable to request refclk (%ld)\n",
217					PTR_ERR(clk));
218			return PTR_ERR(clk);
219		}
220
221		if (!IS_ERR(clk)) {
222			hub->clk = clk;
223
224			if (rate != 0) {
225				err = clk_set_rate(hub->clk, rate);
226				if (err) {
227					dev_err(dev,
228						"unable to set reference clock rate to %d\n",
229						(int) rate);
230					return err;
231				}
232			}
233
234			err = clk_prepare_enable(hub->clk);
235			if (err) {
236				dev_err(dev,
237					"unable to enable reference clock\n");
238				return err;
239			}
240		}
241
242		property = of_get_property(np, "disabled-ports", &len);
243		if (property && (len / sizeof(u32)) > 0) {
244			int i;
245			for (i = 0; i < len / sizeof(u32); i++) {
246				u32 port = be32_to_cpu(property[i]);
247				if ((1 <= port) && (port <= 3))
248					hub->port_off_mask |= (1 << port);
249			}
250		}
251
252		hub->gpio_intn	= of_get_named_gpio(np, "intn-gpios", 0);
253		if (hub->gpio_intn == -EPROBE_DEFER)
254			return -EPROBE_DEFER;
255		hub->gpio_connect = of_get_named_gpio(np, "connect-gpios", 0);
256		if (hub->gpio_connect == -EPROBE_DEFER)
257			return -EPROBE_DEFER;
258		hub->gpio_reset = of_get_named_gpio(np, "reset-gpios", 0);
259		if (hub->gpio_reset == -EPROBE_DEFER)
260			return -EPROBE_DEFER;
261		of_property_read_u32(np, "initial-mode", &mode);
262		hub->mode = mode;
263	}
264
265	if (hub->port_off_mask && !hub->regmap)
266		dev_err(dev, "Ports disabled with no control interface\n");
267
268	if (gpio_is_valid(hub->gpio_intn)) {
269		int val = hub->secondary_ref_clk ? GPIOF_OUT_INIT_LOW :
270						   GPIOF_OUT_INIT_HIGH;
271		err = devm_gpio_request_one(dev, hub->gpio_intn, val,
272					    "usb3503 intn");
273		if (err) {
274			dev_err(dev,
275				"unable to request GPIO %d as interrupt pin (%d)\n",
276				hub->gpio_intn, err);
277			return err;
278		}
279	}
280
281	if (gpio_is_valid(hub->gpio_connect)) {
282		err = devm_gpio_request_one(dev, hub->gpio_connect,
283				GPIOF_OUT_INIT_LOW, "usb3503 connect");
284		if (err) {
285			dev_err(dev,
286				"unable to request GPIO %d as connect pin (%d)\n",
287				hub->gpio_connect, err);
288			return err;
289		}
290	}
291
292	if (gpio_is_valid(hub->gpio_reset)) {
293		err = devm_gpio_request_one(dev, hub->gpio_reset,
294				GPIOF_OUT_INIT_LOW, "usb3503 reset");
295		if (err) {
296			dev_err(dev,
297				"unable to request GPIO %d as reset pin (%d)\n",
298				hub->gpio_reset, err);
299			return err;
300		}
301	}
302
303	usb3503_switch_mode(hub, hub->mode);
304
305	dev_info(dev, "%s: probed in %s mode\n", __func__,
306			(hub->mode == USB3503_MODE_HUB) ? "hub" : "standby");
307
308	return 0;
309}
310
311static int usb3503_i2c_probe(struct i2c_client *i2c,
312			     const struct i2c_device_id *id)
313{
314	struct usb3503 *hub;
315	int err;
316
317	hub = devm_kzalloc(&i2c->dev, sizeof(struct usb3503), GFP_KERNEL);
318	if (!hub)
319		return -ENOMEM;
320
321	i2c_set_clientdata(i2c, hub);
322	hub->regmap = devm_regmap_init_i2c(i2c, &usb3503_regmap_config);
323	if (IS_ERR(hub->regmap)) {
324		err = PTR_ERR(hub->regmap);
325		dev_err(&i2c->dev, "Failed to initialise regmap: %d\n", err);
326		return err;
327	}
328	hub->dev = &i2c->dev;
329
330	return usb3503_probe(hub);
331}
332
333static int usb3503_platform_probe(struct platform_device *pdev)
334{
335	struct usb3503 *hub;
336
337	hub = devm_kzalloc(&pdev->dev, sizeof(struct usb3503), GFP_KERNEL);
338	if (!hub)
339		return -ENOMEM;
340	hub->dev = &pdev->dev;
341
342	return usb3503_probe(hub);
343}
344
345#ifdef CONFIG_PM_SLEEP
346static int usb3503_i2c_suspend(struct device *dev)
347{
348	struct i2c_client *client = to_i2c_client(dev);
349	struct usb3503 *hub = i2c_get_clientdata(client);
350
351	usb3503_switch_mode(hub, USB3503_MODE_STANDBY);
352
353	if (hub->clk)
354		clk_disable_unprepare(hub->clk);
355
356	return 0;
357}
358
359static int usb3503_i2c_resume(struct device *dev)
360{
361	struct i2c_client *client = to_i2c_client(dev);
362	struct usb3503 *hub = i2c_get_clientdata(client);
363
364	if (hub->clk)
365		clk_prepare_enable(hub->clk);
366
367	usb3503_switch_mode(hub, hub->mode);
368
369	return 0;
370}
371#endif
372
373static SIMPLE_DEV_PM_OPS(usb3503_i2c_pm_ops, usb3503_i2c_suspend,
374		usb3503_i2c_resume);
375
376static const struct i2c_device_id usb3503_id[] = {
377	{ USB3503_I2C_NAME, 0 },
378	{ }
379};
380MODULE_DEVICE_TABLE(i2c, usb3503_id);
381
382#ifdef CONFIG_OF
383static const struct of_device_id usb3503_of_match[] = {
384	{ .compatible = "smsc,usb3503", },
385	{ .compatible = "smsc,usb3503a", },
386	{},
387};
388MODULE_DEVICE_TABLE(of, usb3503_of_match);
389#endif
390
391static struct i2c_driver usb3503_i2c_driver = {
392	.driver = {
393		.name = USB3503_I2C_NAME,
394		.pm = &usb3503_i2c_pm_ops,
395		.of_match_table = of_match_ptr(usb3503_of_match),
396	},
397	.probe		= usb3503_i2c_probe,
398	.id_table	= usb3503_id,
399};
400
401static struct platform_driver usb3503_platform_driver = {
402	.driver = {
403		.name = USB3503_I2C_NAME,
404		.of_match_table = of_match_ptr(usb3503_of_match),
405	},
406	.probe		= usb3503_platform_probe,
407};
408
409static int __init usb3503_init(void)
410{
411	int err;
412
413	err = i2c_add_driver(&usb3503_i2c_driver);
414	if (err != 0)
415		pr_err("usb3503: Failed to register I2C driver: %d\n", err);
416
417	err = platform_driver_register(&usb3503_platform_driver);
418	if (err != 0)
419		pr_err("usb3503: Failed to register platform driver: %d\n",
420		       err);
421
422	return 0;
423}
424module_init(usb3503_init);
425
426static void __exit usb3503_exit(void)
427{
428	platform_driver_unregister(&usb3503_platform_driver);
429	i2c_del_driver(&usb3503_i2c_driver);
430}
431module_exit(usb3503_exit);
432
433MODULE_AUTHOR("Dongjin Kim <tobetter@gmail.com>");
434MODULE_DESCRIPTION("USB3503 USB HUB driver");
435MODULE_LICENSE("GPL");
436