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