2 * Driver for SMSC USB3503 USB 2.0 hub controller driver
4 * Copyright (c) 2012-2013 Dongjin Kim (tobetter@gmail.com)
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.
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.
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
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>
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
39 #define USB3503_CFG1 0x06
40 #define USB3503_SELF_BUS_PWR (1 << 7)
42 #define USB3503_CFG2 0x07
43 #define USB3503_CFG3 0x08
44 #define USB3503_NRD 0x09
46 #define USB3503_PDS 0x0a
48 #define USB3503_SP_ILOCK 0xe7
49 #define USB3503_SPILOCK_CONNECT (1 << 1)
50 #define USB3503_SPILOCK_CONFIG (1 << 0)
52 #define USB3503_CFGP 0xee
53 #define USB3503_CLKSUSP (1 << 7)
55 #define USB3503_RESET 0xff
58 enum usb3503_mode mode
;
59 struct regmap
*regmap
;
66 bool secondary_ref_clk
;
69 static int usb3503_reset(struct usb3503
*hub
, int state
)
71 if (!state
&& gpio_is_valid(hub
->gpio_connect
))
72 gpio_set_value_cansleep(hub
->gpio_connect
, 0);
74 if (gpio_is_valid(hub
->gpio_reset
))
75 gpio_set_value_cansleep(hub
->gpio_reset
, state
);
77 /* Wait T_HUBINIT == 4ms for hub logic to stabilize */
79 usleep_range(4000, 10000);
84 static int usb3503_connect(struct usb3503
*hub
)
86 struct device
*dev
= hub
->dev
;
89 usb3503_reset(hub
, 1);
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
));
97 dev_err(dev
, "SP_ILOCK failed (%d)\n", err
);
101 /* PDS : Disable For Self Powered Operation */
102 if (hub
->port_off_mask
) {
103 err
= regmap_update_bits(hub
->regmap
, USB3503_PDS
,
107 dev_err(dev
, "PDS failed (%d)\n", err
);
112 /* CFG1 : SELF_BUS_PWR -> Self-Powerd operation */
113 err
= regmap_update_bits(hub
->regmap
, USB3503_CFG1
,
114 USB3503_SELF_BUS_PWR
,
115 USB3503_SELF_BUS_PWR
);
117 dev_err(dev
, "CFG1 failed (%d)\n", err
);
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);
126 dev_err(dev
, "SP_ILOCK failed (%d)\n", err
);
131 if (gpio_is_valid(hub
->gpio_connect
))
132 gpio_set_value_cansleep(hub
->gpio_connect
, 1);
134 hub
->mode
= USB3503_MODE_HUB
;
135 dev_info(dev
, "switched to HUB mode\n");
140 static int usb3503_switch_mode(struct usb3503
*hub
, enum usb3503_mode mode
)
142 struct device
*dev
= hub
->dev
;
146 case USB3503_MODE_HUB
:
147 err
= usb3503_connect(hub
);
150 case USB3503_MODE_STANDBY
:
151 usb3503_reset(hub
, 0);
152 dev_info(dev
, "switched to STANDBY mode\n");
156 dev_err(dev
, "unknown mode is requested\n");
164 static const struct regmap_config usb3503_regmap_config
= {
168 .max_register
= USB3503_RESET
,
171 static int usb3503_probe(struct usb3503
*hub
)
173 struct device
*dev
= hub
->dev
;
174 struct usb3503_platform_data
*pdata
= dev_get_platdata(dev
);
175 struct device_node
*np
= dev
->of_node
;
177 u32 mode
= USB3503_MODE_HUB
;
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
;
189 hub
->port_off_mask
= 0;
191 clk
= devm_clk_get(dev
, "refclk");
192 if (IS_ERR(clk
) && PTR_ERR(clk
) != -ENOENT
) {
193 dev_err(dev
, "unable to request refclk (%ld)\n",
202 if (!of_property_read_u32(np
, "refclk-frequency",
210 hub
->secondary_ref_clk
= 0;
216 hub
->secondary_ref_clk
= 1;
220 "unsupported reference clock rate (%d)\n",
224 err
= clk_set_rate(hub
->clk
, rate
);
227 "unable to set reference clock rate to %d\n",
233 err
= clk_prepare_enable(hub
->clk
);
236 "unable to enable reference clock\n");
241 property
= of_get_property(np
, "disabled-ports", &len
);
242 if (property
&& (len
/ sizeof(u32
)) > 0) {
244 for (i
= 0; i
< len
/ sizeof(u32
); i
++) {
245 u32 port
= be32_to_cpu(property
[i
]);
246 if ((1 <= port
) && (port
<= 3))
247 hub
->port_off_mask
|= (1 << port
);
251 hub
->gpio_intn
= of_get_named_gpio(np
, "intn-gpios", 0);
252 if (hub
->gpio_intn
== -EPROBE_DEFER
)
253 return -EPROBE_DEFER
;
254 hub
->gpio_connect
= of_get_named_gpio(np
, "connect-gpios", 0);
255 if (hub
->gpio_connect
== -EPROBE_DEFER
)
256 return -EPROBE_DEFER
;
257 hub
->gpio_reset
= of_get_named_gpio(np
, "reset-gpios", 0);
258 if (hub
->gpio_reset
== -EPROBE_DEFER
)
259 return -EPROBE_DEFER
;
260 of_property_read_u32(np
, "initial-mode", &mode
);
264 if (hub
->port_off_mask
&& !hub
->regmap
)
265 dev_err(dev
, "Ports disabled with no control interface\n");
267 if (gpio_is_valid(hub
->gpio_intn
)) {
268 int val
= hub
->secondary_ref_clk
? GPIOF_OUT_INIT_LOW
:
270 err
= devm_gpio_request_one(dev
, hub
->gpio_intn
, val
,
274 "unable to request GPIO %d as interrupt pin (%d)\n",
275 hub
->gpio_intn
, err
);
280 if (gpio_is_valid(hub
->gpio_connect
)) {
281 err
= devm_gpio_request_one(dev
, hub
->gpio_connect
,
282 GPIOF_OUT_INIT_LOW
, "usb3503 connect");
285 "unable to request GPIO %d as connect pin (%d)\n",
286 hub
->gpio_connect
, err
);
291 if (gpio_is_valid(hub
->gpio_reset
)) {
292 err
= devm_gpio_request_one(dev
, hub
->gpio_reset
,
293 GPIOF_OUT_INIT_LOW
, "usb3503 reset");
296 "unable to request GPIO %d as reset pin (%d)\n",
297 hub
->gpio_reset
, err
);
302 usb3503_switch_mode(hub
, hub
->mode
);
304 dev_info(dev
, "%s: probed in %s mode\n", __func__
,
305 (hub
->mode
== USB3503_MODE_HUB
) ? "hub" : "standby");
310 static int usb3503_i2c_probe(struct i2c_client
*i2c
,
311 const struct i2c_device_id
*id
)
316 hub
= devm_kzalloc(&i2c
->dev
, sizeof(struct usb3503
), GFP_KERNEL
);
318 dev_err(&i2c
->dev
, "private data alloc fail\n");
322 i2c_set_clientdata(i2c
, hub
);
323 hub
->regmap
= devm_regmap_init_i2c(i2c
, &usb3503_regmap_config
);
324 if (IS_ERR(hub
->regmap
)) {
325 err
= PTR_ERR(hub
->regmap
);
326 dev_err(&i2c
->dev
, "Failed to initialise regmap: %d\n", err
);
329 hub
->dev
= &i2c
->dev
;
331 return usb3503_probe(hub
);
334 static int usb3503_platform_probe(struct platform_device
*pdev
)
338 hub
= devm_kzalloc(&pdev
->dev
, sizeof(struct usb3503
), GFP_KERNEL
);
340 dev_err(&pdev
->dev
, "private data alloc fail\n");
343 hub
->dev
= &pdev
->dev
;
345 return usb3503_probe(hub
);
348 #ifdef CONFIG_PM_SLEEP
349 static int usb3503_i2c_suspend(struct device
*dev
)
351 struct i2c_client
*client
= to_i2c_client(dev
);
352 struct usb3503
*hub
= i2c_get_clientdata(client
);
354 usb3503_switch_mode(hub
, USB3503_MODE_STANDBY
);
357 clk_disable_unprepare(hub
->clk
);
362 static int usb3503_i2c_resume(struct device
*dev
)
364 struct i2c_client
*client
= to_i2c_client(dev
);
365 struct usb3503
*hub
= i2c_get_clientdata(client
);
368 clk_prepare_enable(hub
->clk
);
370 usb3503_switch_mode(hub
, hub
->mode
);
376 static SIMPLE_DEV_PM_OPS(usb3503_i2c_pm_ops
, usb3503_i2c_suspend
,
379 static const struct i2c_device_id usb3503_id
[] = {
380 { USB3503_I2C_NAME
, 0 },
383 MODULE_DEVICE_TABLE(i2c
, usb3503_id
);
386 static const struct of_device_id usb3503_of_match
[] = {
387 { .compatible
= "smsc,usb3503", },
388 { .compatible
= "smsc,usb3503a", },
391 MODULE_DEVICE_TABLE(of
, usb3503_of_match
);
394 static struct i2c_driver usb3503_i2c_driver
= {
396 .name
= USB3503_I2C_NAME
,
397 .pm
= &usb3503_i2c_pm_ops
,
398 .of_match_table
= of_match_ptr(usb3503_of_match
),
400 .probe
= usb3503_i2c_probe
,
401 .id_table
= usb3503_id
,
404 static struct platform_driver usb3503_platform_driver
= {
406 .name
= USB3503_I2C_NAME
,
407 .of_match_table
= of_match_ptr(usb3503_of_match
),
408 .owner
= THIS_MODULE
,
410 .probe
= usb3503_platform_probe
,
413 static int __init
usb3503_init(void)
417 err
= i2c_register_driver(THIS_MODULE
, &usb3503_i2c_driver
);
419 pr_err("usb3503: Failed to register I2C driver: %d\n", err
);
421 err
= platform_driver_register(&usb3503_platform_driver
);
423 pr_err("usb3503: Failed to register platform driver: %d\n",
428 module_init(usb3503_init
);
430 static void __exit
usb3503_exit(void)
432 platform_driver_unregister(&usb3503_platform_driver
);
433 i2c_del_driver(&usb3503_i2c_driver
);
435 module_exit(usb3503_exit
);
437 MODULE_AUTHOR("Dongjin Kim <tobetter@gmail.com>");
438 MODULE_DESCRIPTION("USB3503 USB HUB driver");
439 MODULE_LICENSE("GPL");