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