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