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/i2c.h> 22 #include <linux/gpio.h> 23 #include <linux/delay.h> 24 #include <linux/slab.h> 25 #include <linux/module.h> 26 #include <linux/of_gpio.h> 27 #include <linux/platform_device.h> 28 #include <linux/platform_data/usb3503.h> 29 30 #define USB3503_VIDL 0x00 31 #define USB3503_VIDM 0x01 32 #define USB3503_PIDL 0x02 33 #define USB3503_PIDM 0x03 34 #define USB3503_DIDL 0x04 35 #define USB3503_DIDM 0x05 36 37 #define USB3503_CFG1 0x06 38 #define USB3503_SELF_BUS_PWR (1 << 7) 39 40 #define USB3503_CFG2 0x07 41 #define USB3503_CFG3 0x08 42 #define USB3503_NRD 0x09 43 44 #define USB3503_PDS 0x0a 45 46 #define USB3503_SP_ILOCK 0xe7 47 #define USB3503_SPILOCK_CONNECT (1 << 1) 48 #define USB3503_SPILOCK_CONFIG (1 << 0) 49 50 #define USB3503_CFGP 0xee 51 #define USB3503_CLKSUSP (1 << 7) 52 53 struct usb3503 { 54 enum usb3503_mode mode; 55 struct i2c_client *client; 56 u8 port_off_mask; 57 int gpio_intn; 58 int gpio_reset; 59 int gpio_connect; 60 }; 61 62 static int usb3503_write_register(struct i2c_client *client, 63 char reg, char data) 64 { 65 return i2c_smbus_write_byte_data(client, reg, data); 66 } 67 68 static int usb3503_read_register(struct i2c_client *client, char reg) 69 { 70 return i2c_smbus_read_byte_data(client, reg); 71 } 72 73 static int usb3503_set_bits(struct i2c_client *client, char reg, char req) 74 { 75 int err; 76 77 err = usb3503_read_register(client, reg); 78 if (err < 0) 79 return err; 80 81 err = usb3503_write_register(client, reg, err | req); 82 if (err < 0) 83 return err; 84 85 return 0; 86 } 87 88 static int usb3503_clear_bits(struct i2c_client *client, char reg, char req) 89 { 90 int err; 91 92 err = usb3503_read_register(client, reg); 93 if (err < 0) 94 return err; 95 96 err = usb3503_write_register(client, reg, err & ~req); 97 if (err < 0) 98 return err; 99 100 return 0; 101 } 102 103 static int usb3503_reset(int gpio_reset, int state) 104 { 105 if (gpio_is_valid(gpio_reset)) 106 gpio_set_value(gpio_reset, state); 107 108 /* Wait T_HUBINIT == 4ms for hub logic to stabilize */ 109 if (state) 110 usleep_range(4000, 10000); 111 112 return 0; 113 } 114 115 static int usb3503_switch_mode(struct usb3503 *hub, enum usb3503_mode mode) 116 { 117 struct i2c_client *i2c = hub->client; 118 int err = 0; 119 120 switch (mode) { 121 case USB3503_MODE_HUB: 122 usb3503_reset(hub->gpio_reset, 1); 123 124 /* SP_ILOCK: set connect_n, config_n for config */ 125 err = usb3503_write_register(i2c, USB3503_SP_ILOCK, 126 (USB3503_SPILOCK_CONNECT 127 | USB3503_SPILOCK_CONFIG)); 128 if (err < 0) { 129 dev_err(&i2c->dev, "SP_ILOCK failed (%d)\n", err); 130 goto err_hubmode; 131 } 132 133 /* PDS : Disable For Self Powered Operation */ 134 if (hub->port_off_mask) { 135 err = usb3503_set_bits(i2c, USB3503_PDS, 136 hub->port_off_mask); 137 if (err < 0) { 138 dev_err(&i2c->dev, "PDS failed (%d)\n", err); 139 goto err_hubmode; 140 } 141 } 142 143 /* CFG1 : SELF_BUS_PWR -> Self-Powerd operation */ 144 err = usb3503_set_bits(i2c, USB3503_CFG1, USB3503_SELF_BUS_PWR); 145 if (err < 0) { 146 dev_err(&i2c->dev, "CFG1 failed (%d)\n", err); 147 goto err_hubmode; 148 } 149 150 /* SP_LOCK: clear connect_n, config_n for hub connect */ 151 err = usb3503_clear_bits(i2c, USB3503_SP_ILOCK, 152 (USB3503_SPILOCK_CONNECT 153 | USB3503_SPILOCK_CONFIG)); 154 if (err < 0) { 155 dev_err(&i2c->dev, "SP_ILOCK failed (%d)\n", err); 156 goto err_hubmode; 157 } 158 159 hub->mode = mode; 160 dev_info(&i2c->dev, "switched to HUB mode\n"); 161 break; 162 163 case USB3503_MODE_STANDBY: 164 usb3503_reset(hub->gpio_reset, 0); 165 166 hub->mode = mode; 167 dev_info(&i2c->dev, "switched to STANDBY mode\n"); 168 break; 169 170 default: 171 dev_err(&i2c->dev, "unknown mode is request\n"); 172 err = -EINVAL; 173 break; 174 } 175 176 err_hubmode: 177 return err; 178 } 179 180 static int usb3503_probe(struct i2c_client *i2c, const struct i2c_device_id *id) 181 { 182 struct usb3503_platform_data *pdata = i2c->dev.platform_data; 183 struct device_node *np = i2c->dev.of_node; 184 struct usb3503 *hub; 185 int err = -ENOMEM; 186 u32 mode = USB3503_MODE_UNKNOWN; 187 const u32 *property; 188 int len; 189 190 hub = kzalloc(sizeof(struct usb3503), GFP_KERNEL); 191 if (!hub) { 192 dev_err(&i2c->dev, "private data alloc fail\n"); 193 return err; 194 } 195 196 i2c_set_clientdata(i2c, hub); 197 hub->client = i2c; 198 199 if (pdata) { 200 hub->port_off_mask = pdata->port_off_mask; 201 hub->gpio_intn = pdata->gpio_intn; 202 hub->gpio_connect = pdata->gpio_connect; 203 hub->gpio_reset = pdata->gpio_reset; 204 hub->mode = pdata->initial_mode; 205 } else if (np) { 206 hub->port_off_mask = 0; 207 208 property = of_get_property(np, "disabled-ports", &len); 209 if (property && (len / sizeof(u32)) > 0) { 210 int i; 211 for (i = 0; i < len / sizeof(u32); i++) { 212 u32 port = be32_to_cpu(property[i]); 213 if ((1 <= port) && (port <= 3)) 214 hub->port_off_mask |= (1 << port); 215 } 216 } 217 218 hub->gpio_intn = of_get_named_gpio(np, "connect-gpios", 0); 219 if (hub->gpio_intn == -EPROBE_DEFER) 220 return -EPROBE_DEFER; 221 hub->gpio_connect = of_get_named_gpio(np, "intn-gpios", 0); 222 if (hub->gpio_connect == -EPROBE_DEFER) 223 return -EPROBE_DEFER; 224 hub->gpio_reset = of_get_named_gpio(np, "reset-gpios", 0); 225 if (hub->gpio_reset == -EPROBE_DEFER) 226 return -EPROBE_DEFER; 227 of_property_read_u32(np, "initial-mode", &mode); 228 hub->mode = mode; 229 } 230 231 if (gpio_is_valid(hub->gpio_intn)) { 232 err = gpio_request_one(hub->gpio_intn, 233 GPIOF_OUT_INIT_HIGH, "usb3503 intn"); 234 if (err) { 235 dev_err(&i2c->dev, 236 "unable to request GPIO %d as connect pin (%d)\n", 237 hub->gpio_intn, err); 238 goto err_out; 239 } 240 } 241 242 if (gpio_is_valid(hub->gpio_connect)) { 243 err = gpio_request_one(hub->gpio_connect, 244 GPIOF_OUT_INIT_HIGH, "usb3503 connect"); 245 if (err) { 246 dev_err(&i2c->dev, 247 "unable to request GPIO %d as connect pin (%d)\n", 248 hub->gpio_connect, err); 249 goto err_gpio_connect; 250 } 251 } 252 253 if (gpio_is_valid(hub->gpio_reset)) { 254 err = gpio_request_one(hub->gpio_reset, 255 GPIOF_OUT_INIT_LOW, "usb3503 reset"); 256 if (err) { 257 dev_err(&i2c->dev, 258 "unable to request GPIO %d as reset pin (%d)\n", 259 hub->gpio_reset, err); 260 goto err_gpio_reset; 261 } 262 } 263 264 usb3503_switch_mode(hub, hub->mode); 265 266 dev_info(&i2c->dev, "%s: probed on %s mode\n", __func__, 267 (hub->mode == USB3503_MODE_HUB) ? "hub" : "standby"); 268 269 return 0; 270 271 err_gpio_reset: 272 if (gpio_is_valid(hub->gpio_connect)) 273 gpio_free(hub->gpio_connect); 274 err_gpio_connect: 275 if (gpio_is_valid(hub->gpio_intn)) 276 gpio_free(hub->gpio_intn); 277 err_out: 278 kfree(hub); 279 280 return err; 281 } 282 283 static int usb3503_remove(struct i2c_client *i2c) 284 { 285 struct usb3503 *hub = i2c_get_clientdata(i2c); 286 287 if (gpio_is_valid(hub->gpio_intn)) 288 gpio_free(hub->gpio_intn); 289 if (gpio_is_valid(hub->gpio_connect)) 290 gpio_free(hub->gpio_connect); 291 if (gpio_is_valid(hub->gpio_reset)) 292 gpio_free(hub->gpio_reset); 293 294 kfree(hub); 295 296 return 0; 297 } 298 299 static const struct i2c_device_id usb3503_id[] = { 300 { USB3503_I2C_NAME, 0 }, 301 { } 302 }; 303 MODULE_DEVICE_TABLE(i2c, usb3503_id); 304 305 #ifdef CONFIG_OF 306 static const struct of_device_id usb3503_of_match[] = { 307 { .compatible = "smsc,usb3503", }, 308 {}, 309 }; 310 MODULE_DEVICE_TABLE(of, usb3503_of_match); 311 #endif 312 313 static struct i2c_driver usb3503_driver = { 314 .driver = { 315 .name = USB3503_I2C_NAME, 316 .of_match_table = of_match_ptr(usb3503_of_match), 317 }, 318 .probe = usb3503_probe, 319 .remove = usb3503_remove, 320 .id_table = usb3503_id, 321 }; 322 323 module_i2c_driver(usb3503_driver); 324 325 MODULE_AUTHOR("Dongjin Kim <tobetter@gmail.com>"); 326 MODULE_DESCRIPTION("USB3503 USB HUB driver"); 327 MODULE_LICENSE("GPL"); 328