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