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