drivers/usb/misc/usb3503.c

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