drivers/gpio/gpio-tpic2810.c

   1 /*
   2  * Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com/
   3  *      Andrew F. Davis <afd@ti.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  10  * kind, whether expressed or implied; without even the implied warranty
  11  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License version 2 for more details.
  13  */
  14
  15 #include <linux/gpio/driver.h>
  16 #include <linux/i2c.h>
  17 #include <linux/module.h>
  18 #include <linux/mutex.h>
  19
  20 #define TPIC2810_WS_COMMAND 0x44
  21
  22 /**
  23  * struct tpic2810 - GPIO driver data
  24  * @chip: GPIO controller chip
  25  * @client: I2C device pointer
  26  * @buffer: Buffer for device register
  27  * @lock: Protects write sequences
  28  */
  29 struct tpic2810 {
  30         struct gpio_chip chip;
  31         struct i2c_client *client;
  32         u8 buffer;
  33         struct mutex lock;
  34 };
  35
  36 static void tpic2810_set(struct gpio_chip *chip, unsigned offset, int value);
  37
  38 static int tpic2810_get_direction(struct gpio_chip *chip,
  39                                   unsigned offset)
  40 {
  41         /* This device always output */
  42         return 0;
  43 }
  44
  45 static int tpic2810_direction_input(struct gpio_chip *chip,
  46                                     unsigned offset)
  47 {
  48         /* This device is output only */
  49         return -EINVAL;
  50 }
  51
  52 static int tpic2810_direction_output(struct gpio_chip *chip,
  53                                      unsigned offset, int value)
  54 {
  55         /* This device always output */
  56         tpic2810_set(chip, offset, value);
  57         return 0;
  58 }
  59
  60 static void tpic2810_set(struct gpio_chip *chip, unsigned offset, int value)
  61 {
  62         struct tpic2810 *gpio = gpiochip_get_data(chip);
  63
  64         mutex_lock(&gpio->lock);
  65
  66         if (value)
  67                 gpio->buffer |= BIT(offset);
  68         else
  69                 gpio->buffer &= ~BIT(offset);
  70
  71         i2c_smbus_write_byte_data(gpio->client, TPIC2810_WS_COMMAND,
  72                                   gpio->buffer);
  73
  74         mutex_unlock(&gpio->lock);
  75 }
  76
  77 static void tpic2810_set_multiple(struct gpio_chip *chip, unsigned long *mask,
  78                                   unsigned long *bits)
  79 {
  80         struct tpic2810 *gpio = gpiochip_get_data(chip);
  81
  82         mutex_lock(&gpio->lock);
  83
  84         /* clear bits under mask */
  85         gpio->buffer &= ~(*mask);
  86         /* set bits under mask */
  87         gpio->buffer |= ((*mask) & (*bits));
  88
  89         i2c_smbus_write_byte_data(gpio->client, TPIC2810_WS_COMMAND,
  90                                   gpio->buffer);
  91
  92         mutex_unlock(&gpio->lock);
  93 }
  94
  95 static struct gpio_chip template_chip = {
  96         .label                  = "tpic2810",
  97         .owner                  = THIS_MODULE,
  98         .get_direction          = tpic2810_get_direction,
  99         .direction_input        = tpic2810_direction_input,
 100         .direction_output       = tpic2810_direction_output,
 101         .set                    = tpic2810_set,
 102         .set_multiple           = tpic2810_set_multiple,
 103         .base                   = -1,
 104         .ngpio                  = 8,
 105         .can_sleep              = true,
 106 };
 107
 108 static const struct of_device_id tpic2810_of_match_table[] = {
 109         { .compatible = "ti,tpic2810" },
 110         { /* sentinel */ }
 111 };
 112 MODULE_DEVICE_TABLE(of, tpic2810_of_match_table);
 113
 114 static int tpic2810_probe(struct i2c_client *client,
 115                           const struct i2c_device_id *id)
 116 {
 117         struct tpic2810 *gpio;
 118         int ret;
 119
 120         gpio = devm_kzalloc(&client->dev, sizeof(*gpio), GFP_KERNEL);
 121         if (!gpio)
 122                 return -ENOMEM;
 123
 124         i2c_set_clientdata(client, gpio);
 125
 126         gpio->chip = template_chip;
 127         gpio->chip.parent = &client->dev;
 128
 129         gpio->client = client;
 130
 131         mutex_init(&gpio->lock);
 132
 133         ret = gpiochip_add_data(&gpio->chip, gpio);
 134         if (ret < 0) {
 135                 dev_err(&client->dev, "Unable to register gpiochip\n");
 136                 return ret;
 137         }
 138
 139         return 0;
 140 }
 141
 142 static int tpic2810_remove(struct i2c_client *client)
 143 {
 144         struct tpic2810 *gpio = i2c_get_clientdata(client);
 145
 146         gpiochip_remove(&gpio->chip);
 147
 148         return 0;
 149 }
 150
 151 static const struct i2c_device_id tpic2810_id_table[] = {
 152         { "tpic2810", },
 153         { /* sentinel */ }
 154 };
 155 MODULE_DEVICE_TABLE(i2c, tpic2810_id_table);
 156
 157 static struct i2c_driver tpic2810_driver = {
 158         .driver = {
 159                 .name = "tpic2810",
 160                 .of_match_table = tpic2810_of_match_table,
 161         },
 162         .probe = tpic2810_probe,
 163         .remove = tpic2810_remove,
 164         .id_table = tpic2810_id_table,
 165 };
 166 module_i2c_driver(tpic2810_driver);
 167
 168 MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
 169 MODULE_DESCRIPTION("TPIC2810 8-Bit LED Driver GPIO Driver");
 170 MODULE_LICENSE("GPL v2");