drivers/gpio/pca953x.c

   1 /*
   2  *  pca953x.c - 4/8/16 bit I/O ports
   3  *
   4  *  Copyright (C) 2005 Ben Gardner <bgardner@wabtec.com>
   5  *  Copyright (C) 2007 Marvell International Ltd.
   6  *
   7  *  Derived from drivers/i2c/chips/pca9539.c
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; version 2 of the License.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/i2c.h>
  17 #include <linux/i2c/pca953x.h>
  18
  19 #include <asm/gpio.h>
  20
  21 #define PCA953X_INPUT          0
  22 #define PCA953X_OUTPUT         1
  23 #define PCA953X_INVERT         2
  24 #define PCA953X_DIRECTION      3
  25
  26 static const struct i2c_device_id pca953x_id[] = {
  27         { "pca9534", 8, },
  28         { "pca9535", 16, },
  29         { "pca9536", 4, },
  30         { "pca9537", 4, },
  31         { "pca9538", 8, },
  32         { "pca9539", 16, },
  33         { "pca9554", 8, },
  34         { "pca9555", 16, },
  35         { "pca9557", 8, },
  36         { "max7310", 8, },
  37         { }
  38 };
  39 MODULE_DEVICE_TABLE(i2c, pca953x_id);
  40
  41 struct pca953x_chip {
  42         unsigned gpio_start;
  43         uint16_t reg_output;
  44         uint16_t reg_direction;
  45
  46         struct i2c_client *client;
  47         struct gpio_chip gpio_chip;
  48 };
  49
  50 /* NOTE:  we can't currently rely on fault codes to come from SMBus
  51  * calls, so we map all errors to EIO here and return zero otherwise.
  52  */
  53 static int pca953x_write_reg(struct pca953x_chip *chip, int reg, uint16_t val)
  54 {
  55         int ret;
  56
  57         if (chip->gpio_chip.ngpio <= 8)
  58                 ret = i2c_smbus_write_byte_data(chip->client, reg, val);
  59         else
  60                 ret = i2c_smbus_write_word_data(chip->client, reg << 1, val);
  61
  62         if (ret < 0) {
  63                 dev_err(&chip->client->dev, "failed writing register\n");
  64                 return -EIO;
  65         }
  66
  67         return 0;
  68 }
  69
  70 static int pca953x_read_reg(struct pca953x_chip *chip, int reg, uint16_t *val)
  71 {
  72         int ret;
  73
  74         if (chip->gpio_chip.ngpio <= 8)
  75                 ret = i2c_smbus_read_byte_data(chip->client, reg);
  76         else
  77                 ret = i2c_smbus_read_word_data(chip->client, reg << 1);
  78
  79         if (ret < 0) {
  80                 dev_err(&chip->client->dev, "failed reading register\n");
  81                 return -EIO;
  82         }
  83
  84         *val = (uint16_t)ret;
  85         return 0;
  86 }
  87
  88 static int pca953x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
  89 {
  90         struct pca953x_chip *chip;
  91         uint16_t reg_val;
  92         int ret;
  93
  94         chip = container_of(gc, struct pca953x_chip, gpio_chip);
  95
  96         reg_val = chip->reg_direction | (1u << off);
  97         ret = pca953x_write_reg(chip, PCA953X_DIRECTION, reg_val);
  98         if (ret)
  99                 return ret;
 100
 101         chip->reg_direction = reg_val;
 102         return 0;
 103 }
 104
 105 static int pca953x_gpio_direction_output(struct gpio_chip *gc,
 106                 unsigned off, int val)
 107 {
 108         struct pca953x_chip *chip;
 109         uint16_t reg_val;
 110         int ret;
 111
 112         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 113
 114         /* set output level */
 115         if (val)
 116                 reg_val = chip->reg_output | (1u << off);
 117         else
 118                 reg_val = chip->reg_output & ~(1u << off);
 119
 120         ret = pca953x_write_reg(chip, PCA953X_OUTPUT, reg_val);
 121         if (ret)
 122                 return ret;
 123
 124         chip->reg_output = reg_val;
 125
 126         /* then direction */
 127         reg_val = chip->reg_direction & ~(1u << off);
 128         ret = pca953x_write_reg(chip, PCA953X_DIRECTION, reg_val);
 129         if (ret)
 130                 return ret;
 131
 132         chip->reg_direction = reg_val;
 133         return 0;
 134 }
 135
 136 static int pca953x_gpio_get_value(struct gpio_chip *gc, unsigned off)
 137 {
 138         struct pca953x_chip *chip;
 139         uint16_t reg_val;
 140         int ret;
 141
 142         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 143
 144         ret = pca953x_read_reg(chip, PCA953X_INPUT, &reg_val);
 145         if (ret < 0) {
 146                 /* NOTE:  diagnostic already emitted; that's all we should
 147                  * do unless gpio_*_value_cansleep() calls become different
 148                  * from their nonsleeping siblings (and report faults).
 149                  */
 150                 return 0;
 151         }
 152
 153         return (reg_val & (1u << off)) ? 1 : 0;
 154 }
 155
 156 static void pca953x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
 157 {
 158         struct pca953x_chip *chip;
 159         uint16_t reg_val;
 160         int ret;
 161
 162         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 163
 164         if (val)
 165                 reg_val = chip->reg_output | (1u << off);
 166         else
 167                 reg_val = chip->reg_output & ~(1u << off);
 168
 169         ret = pca953x_write_reg(chip, PCA953X_OUTPUT, reg_val);
 170         if (ret)
 171                 return;
 172
 173         chip->reg_output = reg_val;
 174 }
 175
 176 static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
 177 {
 178         struct gpio_chip *gc;
 179
 180         gc = &chip->gpio_chip;
 181
 182         gc->direction_input  = pca953x_gpio_direction_input;
 183         gc->direction_output = pca953x_gpio_direction_output;
 184         gc->get = pca953x_gpio_get_value;
 185         gc->set = pca953x_gpio_set_value;
 186         gc->can_sleep = 1;
 187
 188         gc->base = chip->gpio_start;
 189         gc->ngpio = gpios;
 190         gc->label = chip->client->name;
 191         gc->dev = &chip->client->dev;
 192         gc->owner = THIS_MODULE;
 193 }
 194
 195 static int __devinit pca953x_probe(struct i2c_client *client,
 196                                    const struct i2c_device_id *id)
 197 {
 198         struct pca953x_platform_data *pdata;
 199         struct pca953x_chip *chip;
 200         int ret;
 201
 202         pdata = client->dev.platform_data;
 203         if (pdata == NULL)
 204                 return -ENODEV;
 205
 206         chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL);
 207         if (chip == NULL)
 208                 return -ENOMEM;
 209
 210         chip->client = client;
 211
 212         chip->gpio_start = pdata->gpio_base;
 213
 214         /* initialize cached registers from their original values.
 215          * we can't share this chip with another i2c master.
 216          */
 217         pca953x_setup_gpio(chip, id->driver_data);
 218
 219         ret = pca953x_read_reg(chip, PCA953X_OUTPUT, &chip->reg_output);
 220         if (ret)
 221                 goto out_failed;
 222
 223         ret = pca953x_read_reg(chip, PCA953X_DIRECTION, &chip->reg_direction);
 224         if (ret)
 225                 goto out_failed;
 226
 227         /* set platform specific polarity inversion */
 228         ret = pca953x_write_reg(chip, PCA953X_INVERT, pdata->invert);
 229         if (ret)
 230                 goto out_failed;
 231
 232
 233         ret = gpiochip_add(&chip->gpio_chip);
 234         if (ret)
 235                 goto out_failed;
 236
 237         if (pdata->setup) {
 238                 ret = pdata->setup(client, chip->gpio_chip.base,
 239                                 chip->gpio_chip.ngpio, pdata->context);
 240                 if (ret < 0)
 241                         dev_warn(&client->dev, "setup failed, %d\n", ret);
 242         }
 243
 244         i2c_set_clientdata(client, chip);
 245         return 0;
 246
 247 out_failed:
 248         kfree(chip);
 249         return ret;
 250 }
 251
 252 static int pca953x_remove(struct i2c_client *client)
 253 {
 254         struct pca953x_platform_data *pdata = client->dev.platform_data;
 255         struct pca953x_chip *chip = i2c_get_clientdata(client);
 256         int ret = 0;
 257
 258         if (pdata->teardown) {
 259                 ret = pdata->teardown(client, chip->gpio_chip.base,
 260                                 chip->gpio_chip.ngpio, pdata->context);
 261                 if (ret < 0) {
 262                         dev_err(&client->dev, "%s failed, %d\n",
 263                                         "teardown", ret);
 264                         return ret;
 265                 }
 266         }
 267
 268         ret = gpiochip_remove(&chip->gpio_chip);
 269         if (ret) {
 270                 dev_err(&client->dev, "%s failed, %d\n",
 271                                 "gpiochip_remove()", ret);
 272                 return ret;
 273         }
 274
 275         kfree(chip);
 276         return 0;
 277 }
 278
 279 static struct i2c_driver pca953x_driver = {
 280         .driver = {
 281                 .name   = "pca953x",
 282         },
 283         .probe          = pca953x_probe,
 284         .remove         = pca953x_remove,
 285         .id_table       = pca953x_id,
 286 };
 287
 288 static int __init pca953x_init(void)
 289 {
 290         return i2c_add_driver(&pca953x_driver);
 291 }
 292 module_init(pca953x_init);
 293
 294 static void __exit pca953x_exit(void)
 295 {
 296         i2c_del_driver(&pca953x_driver);
 297 }
 298 module_exit(pca953x_exit);
 299
 300 MODULE_AUTHOR("eric miao <eric.miao@marvell.com>");
 301 MODULE_DESCRIPTION("GPIO expander driver for PCA953x");
 302 MODULE_LICENSE("GPL");