drivers/usb/misc/usb3503.c

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