1 // SPDX-License-Identifier: GPL-2.0+
3 * Driver for SMSC USB3503 USB 2.0 hub controller driver
5 * Copyright (c) 2012-2013 Dongjin Kim (tobetter@gmail.com)
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>
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
26 #define USB3503_CFG1 0x06
27 #define USB3503_SELF_BUS_PWR (1 << 7)
29 #define USB3503_CFG2 0x07
30 #define USB3503_CFG3 0x08
31 #define USB3503_NRD 0x09
33 #define USB3503_PDS 0x0a
35 #define USB3503_SP_ILOCK 0xe7
36 #define USB3503_SPILOCK_CONNECT (1 << 1)
37 #define USB3503_SPILOCK_CONFIG (1 << 0)
39 #define USB3503_CFGP 0xee
40 #define USB3503_CLKSUSP (1 << 7)
42 #define USB3503_RESET 0xff
45 enum usb3503_mode mode
;
46 struct regmap
*regmap
;
53 bool secondary_ref_clk
;
56 static int usb3503_reset(struct usb3503
*hub
, int state
)
58 if (!state
&& gpio_is_valid(hub
->gpio_connect
))
59 gpio_set_value_cansleep(hub
->gpio_connect
, 0);
61 if (gpio_is_valid(hub
->gpio_reset
))
62 gpio_set_value_cansleep(hub
->gpio_reset
, state
);
64 /* Wait T_HUBINIT == 4ms for hub logic to stabilize */
66 usleep_range(4000, 10000);
71 static int usb3503_connect(struct usb3503
*hub
)
73 struct device
*dev
= hub
->dev
;
76 usb3503_reset(hub
, 1);
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
));
84 dev_err(dev
, "SP_ILOCK failed (%d)\n", err
);
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
,
94 dev_err(dev
, "PDS failed (%d)\n", err
);
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
);
104 dev_err(dev
, "CFG1 failed (%d)\n", err
);
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);
113 dev_err(dev
, "SP_ILOCK failed (%d)\n", err
);
118 if (gpio_is_valid(hub
->gpio_connect
))
119 gpio_set_value_cansleep(hub
->gpio_connect
, 1);
121 hub
->mode
= USB3503_MODE_HUB
;
122 dev_info(dev
, "switched to HUB mode\n");
127 static int usb3503_switch_mode(struct usb3503
*hub
, enum usb3503_mode mode
)
129 struct device
*dev
= hub
->dev
;
133 case USB3503_MODE_HUB
:
134 err
= usb3503_connect(hub
);
137 case USB3503_MODE_STANDBY
:
138 usb3503_reset(hub
, 0);
139 dev_info(dev
, "switched to STANDBY mode\n");
143 dev_err(dev
, "unknown mode is requested\n");
151 static const struct regmap_config usb3503_regmap_config
= {
155 .max_register
= USB3503_RESET
,
158 static int usb3503_probe(struct usb3503
*hub
)
160 struct device
*dev
= hub
->dev
;
161 struct usb3503_platform_data
*pdata
= dev_get_platdata(dev
);
162 struct device_node
*np
= dev
->of_node
;
164 u32 mode
= USB3503_MODE_HUB
;
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
;
177 hub
->port_off_mask
= 0;
179 if (!of_property_read_u32(np
, "refclk-frequency", &rate
)) {
185 hub
->secondary_ref_clk
= 0;
191 hub
->secondary_ref_clk
= 1;
195 "unsupported reference clock rate (%d)\n",
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",
212 err
= clk_set_rate(hub
->clk
, rate
);
215 "unable to set reference clock rate to %d\n",
221 err
= clk_prepare_enable(hub
->clk
);
224 "unable to enable reference clock\n");
229 property
= of_get_property(np
, "disabled-ports", &len
);
230 if (property
&& (len
/ sizeof(u32
)) > 0) {
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
);
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
);
252 if (hub
->port_off_mask
&& !hub
->regmap
)
253 dev_err(dev
, "Ports disabled with no control interface\n");
255 if (gpio_is_valid(hub
->gpio_intn
)) {
256 int val
= hub
->secondary_ref_clk
? GPIOF_OUT_INIT_LOW
:
258 err
= devm_gpio_request_one(dev
, hub
->gpio_intn
, val
,
262 "unable to request GPIO %d as interrupt pin (%d)\n",
263 hub
->gpio_intn
, err
);
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");
273 "unable to request GPIO %d as connect pin (%d)\n",
274 hub
->gpio_connect
, err
);
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");
284 "unable to request GPIO %d as reset pin (%d)\n",
285 hub
->gpio_reset
, err
);
290 usb3503_switch_mode(hub
, hub
->mode
);
292 dev_info(dev
, "%s: probed in %s mode\n", __func__
,
293 (hub
->mode
== USB3503_MODE_HUB
) ? "hub" : "standby");
298 static int usb3503_i2c_probe(struct i2c_client
*i2c
,
299 const struct i2c_device_id
*id
)
304 hub
= devm_kzalloc(&i2c
->dev
, sizeof(struct usb3503
), GFP_KERNEL
);
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
);
315 hub
->dev
= &i2c
->dev
;
317 return usb3503_probe(hub
);
320 static int usb3503_i2c_remove(struct i2c_client
*i2c
)
324 hub
= i2c_get_clientdata(i2c
);
326 clk_disable_unprepare(hub
->clk
);
331 static int usb3503_platform_probe(struct platform_device
*pdev
)
335 hub
= devm_kzalloc(&pdev
->dev
, sizeof(struct usb3503
), GFP_KERNEL
);
338 hub
->dev
= &pdev
->dev
;
339 platform_set_drvdata(pdev
, hub
);
341 return usb3503_probe(hub
);
344 static int usb3503_platform_remove(struct platform_device
*pdev
)
348 hub
= platform_get_drvdata(pdev
);
350 clk_disable_unprepare(hub
->clk
);
355 #ifdef CONFIG_PM_SLEEP
356 static int usb3503_i2c_suspend(struct device
*dev
)
358 struct i2c_client
*client
= to_i2c_client(dev
);
359 struct usb3503
*hub
= i2c_get_clientdata(client
);
361 usb3503_switch_mode(hub
, USB3503_MODE_STANDBY
);
364 clk_disable_unprepare(hub
->clk
);
369 static int usb3503_i2c_resume(struct device
*dev
)
371 struct i2c_client
*client
= to_i2c_client(dev
);
372 struct usb3503
*hub
= i2c_get_clientdata(client
);
375 clk_prepare_enable(hub
->clk
);
377 usb3503_switch_mode(hub
, hub
->mode
);
383 static SIMPLE_DEV_PM_OPS(usb3503_i2c_pm_ops
, usb3503_i2c_suspend
,
386 static const struct i2c_device_id usb3503_id
[] = {
387 { USB3503_I2C_NAME
, 0 },
390 MODULE_DEVICE_TABLE(i2c
, usb3503_id
);
393 static const struct of_device_id usb3503_of_match
[] = {
394 { .compatible
= "smsc,usb3503", },
395 { .compatible
= "smsc,usb3503a", },
398 MODULE_DEVICE_TABLE(of
, usb3503_of_match
);
401 static struct i2c_driver usb3503_i2c_driver
= {
403 .name
= USB3503_I2C_NAME
,
404 .pm
= &usb3503_i2c_pm_ops
,
405 .of_match_table
= of_match_ptr(usb3503_of_match
),
407 .probe
= usb3503_i2c_probe
,
408 .remove
= usb3503_i2c_remove
,
409 .id_table
= usb3503_id
,
412 static struct platform_driver usb3503_platform_driver
= {
414 .name
= USB3503_I2C_NAME
,
415 .of_match_table
= of_match_ptr(usb3503_of_match
),
417 .probe
= usb3503_platform_probe
,
418 .remove
= usb3503_platform_remove
,
421 static int __init
usb3503_init(void)
425 err
= i2c_add_driver(&usb3503_i2c_driver
);
427 pr_err("usb3503: Failed to register I2C driver: %d\n", err
);
429 err
= platform_driver_register(&usb3503_platform_driver
);
431 pr_err("usb3503: Failed to register platform driver: %d\n",
436 module_init(usb3503_init
);
438 static void __exit
usb3503_exit(void)
440 platform_driver_unregister(&usb3503_platform_driver
);
441 i2c_del_driver(&usb3503_i2c_driver
);
443 module_exit(usb3503_exit
);
445 MODULE_AUTHOR("Dongjin Kim <tobetter@gmail.com>");
446 MODULE_DESCRIPTION("USB3503 USB HUB driver");
447 MODULE_LICENSE("GPL");