drivers/gpio/gpio-palmas.c

   1 /*
   2  * TI Palma series PMIC's GPIO driver.
   3  *
   4  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
   5  *
   6  * Author: Laxman Dewangan <ldewangan@nvidia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms and conditions of the GNU General Public License,
  10  * version 2, as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <linux/gpio.h>
  22 #include <linux/kernel.h>
  23 #include <linux/module.h>
  24 #include <linux/mfd/palmas.h>
  25 #include <linux/of.h>
  26 #include <linux/of_device.h>
  27 #include <linux/platform_device.h>
  28
  29 struct palmas_gpio {
  30         struct gpio_chip gpio_chip;
  31         struct palmas *palmas;
  32 };
  33
  34 struct palmas_device_data {
  35         int ngpio;
  36 };
  37
  38 static inline struct palmas_gpio *to_palmas_gpio(struct gpio_chip *chip)
  39 {
  40         return container_of(chip, struct palmas_gpio, gpio_chip);
  41 }
  42
  43 static int palmas_gpio_get(struct gpio_chip *gc, unsigned offset)
  44 {
  45         struct palmas_gpio *pg = to_palmas_gpio(gc);
  46         struct palmas *palmas = pg->palmas;
  47         unsigned int val;
  48         int ret;
  49         unsigned int reg;
  50         int gpio16 = (offset/8);
  51
  52         offset %= 8;
  53         reg = (gpio16) ? PALMAS_GPIO_DATA_DIR2 : PALMAS_GPIO_DATA_DIR;
  54
  55         ret = palmas_read(palmas, PALMAS_GPIO_BASE, reg, &val);
  56         if (ret < 0) {
  57                 dev_err(gc->parent, "Reg 0x%02x read failed, %d\n", reg, ret);
  58                 return ret;
  59         }
  60
  61         if (val & BIT(offset))
  62                 reg = (gpio16) ? PALMAS_GPIO_DATA_OUT2 : PALMAS_GPIO_DATA_OUT;
  63         else
  64                 reg = (gpio16) ? PALMAS_GPIO_DATA_IN2 : PALMAS_GPIO_DATA_IN;
  65
  66         ret = palmas_read(palmas, PALMAS_GPIO_BASE, reg, &val);
  67         if (ret < 0) {
  68                 dev_err(gc->parent, "Reg 0x%02x read failed, %d\n", reg, ret);
  69                 return ret;
  70         }
  71         return !!(val & BIT(offset));
  72 }
  73
  74 static void palmas_gpio_set(struct gpio_chip *gc, unsigned offset,
  75                         int value)
  76 {
  77         struct palmas_gpio *pg = to_palmas_gpio(gc);
  78         struct palmas *palmas = pg->palmas;
  79         int ret;
  80         unsigned int reg;
  81         int gpio16 = (offset/8);
  82
  83         offset %= 8;
  84         if (gpio16)
  85                 reg = (value) ?
  86                         PALMAS_GPIO_SET_DATA_OUT2 : PALMAS_GPIO_CLEAR_DATA_OUT2;
  87         else
  88                 reg = (value) ?
  89                         PALMAS_GPIO_SET_DATA_OUT : PALMAS_GPIO_CLEAR_DATA_OUT;
  90
  91         ret = palmas_write(palmas, PALMAS_GPIO_BASE, reg, BIT(offset));
  92         if (ret < 0)
  93                 dev_err(gc->parent, "Reg 0x%02x write failed, %d\n", reg, ret);
  94 }
  95
  96 static int palmas_gpio_output(struct gpio_chip *gc, unsigned offset,
  97                                 int value)
  98 {
  99         struct palmas_gpio *pg = to_palmas_gpio(gc);
 100         struct palmas *palmas = pg->palmas;
 101         int ret;
 102         unsigned int reg;
 103         int gpio16 = (offset/8);
 104
 105         offset %= 8;
 106         reg = (gpio16) ? PALMAS_GPIO_DATA_DIR2 : PALMAS_GPIO_DATA_DIR;
 107
 108         /* Set the initial value */
 109         palmas_gpio_set(gc, offset, value);
 110
 111         ret = palmas_update_bits(palmas, PALMAS_GPIO_BASE, reg,
 112                                 BIT(offset), BIT(offset));
 113         if (ret < 0)
 114                 dev_err(gc->parent, "Reg 0x%02x update failed, %d\n", reg,
 115                         ret);
 116         return ret;
 117 }
 118
 119 static int palmas_gpio_input(struct gpio_chip *gc, unsigned offset)
 120 {
 121         struct palmas_gpio *pg = to_palmas_gpio(gc);
 122         struct palmas *palmas = pg->palmas;
 123         int ret;
 124         unsigned int reg;
 125         int gpio16 = (offset/8);
 126
 127         offset %= 8;
 128         reg = (gpio16) ? PALMAS_GPIO_DATA_DIR2 : PALMAS_GPIO_DATA_DIR;
 129
 130         ret = palmas_update_bits(palmas, PALMAS_GPIO_BASE, reg, BIT(offset), 0);
 131         if (ret < 0)
 132                 dev_err(gc->parent, "Reg 0x%02x update failed, %d\n", reg,
 133                         ret);
 134         return ret;
 135 }
 136
 137 static int palmas_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
 138 {
 139         struct palmas_gpio *pg = to_palmas_gpio(gc);
 140         struct palmas *palmas = pg->palmas;
 141
 142         return palmas_irq_get_virq(palmas, PALMAS_GPIO_0_IRQ + offset);
 143 }
 144
 145 static const struct palmas_device_data palmas_dev_data = {
 146         .ngpio = 8,
 147 };
 148
 149 static const struct palmas_device_data tps80036_dev_data = {
 150         .ngpio = 16,
 151 };
 152
 153 static const struct of_device_id of_palmas_gpio_match[] = {
 154         { .compatible = "ti,palmas-gpio", .data = &palmas_dev_data,},
 155         { .compatible = "ti,tps65913-gpio", .data = &palmas_dev_data,},
 156         { .compatible = "ti,tps65914-gpio", .data = &palmas_dev_data,},
 157         { .compatible = "ti,tps80036-gpio", .data = &tps80036_dev_data,},
 158         { },
 159 };
 160 MODULE_DEVICE_TABLE(of, of_palmas_gpio_match);
 161
 162 static int palmas_gpio_probe(struct platform_device *pdev)
 163 {
 164         struct palmas *palmas = dev_get_drvdata(pdev->dev.parent);
 165         struct palmas_platform_data *palmas_pdata;
 166         struct palmas_gpio *palmas_gpio;
 167         int ret;
 168         const struct of_device_id *match;
 169         const struct palmas_device_data *dev_data;
 170
 171         match = of_match_device(of_palmas_gpio_match, &pdev->dev);
 172         if (!match)
 173                 return -ENODEV;
 174         dev_data = match->data;
 175         if (!dev_data)
 176                 dev_data = &palmas_dev_data;
 177
 178         palmas_gpio = devm_kzalloc(&pdev->dev,
 179                                 sizeof(*palmas_gpio), GFP_KERNEL);
 180         if (!palmas_gpio)
 181                 return -ENOMEM;
 182
 183         palmas_gpio->palmas = palmas;
 184         palmas_gpio->gpio_chip.owner = THIS_MODULE;
 185         palmas_gpio->gpio_chip.label = dev_name(&pdev->dev);
 186         palmas_gpio->gpio_chip.ngpio = dev_data->ngpio;
 187         palmas_gpio->gpio_chip.can_sleep = true;
 188         palmas_gpio->gpio_chip.direction_input = palmas_gpio_input;
 189         palmas_gpio->gpio_chip.direction_output = palmas_gpio_output;
 190         palmas_gpio->gpio_chip.to_irq = palmas_gpio_to_irq;
 191         palmas_gpio->gpio_chip.set      = palmas_gpio_set;
 192         palmas_gpio->gpio_chip.get      = palmas_gpio_get;
 193         palmas_gpio->gpio_chip.parent = &pdev->dev;
 194 #ifdef CONFIG_OF_GPIO
 195         palmas_gpio->gpio_chip.of_node = pdev->dev.of_node;
 196 #endif
 197         palmas_pdata = dev_get_platdata(palmas->dev);
 198         if (palmas_pdata && palmas_pdata->gpio_base)
 199                 palmas_gpio->gpio_chip.base = palmas_pdata->gpio_base;
 200         else
 201                 palmas_gpio->gpio_chip.base = -1;
 202
 203         ret = gpiochip_add(&palmas_gpio->gpio_chip);
 204         if (ret < 0) {
 205                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
 206                 return ret;
 207         }
 208
 209         platform_set_drvdata(pdev, palmas_gpio);
 210         return ret;
 211 }
 212
 213 static int palmas_gpio_remove(struct platform_device *pdev)
 214 {
 215         struct palmas_gpio *palmas_gpio = platform_get_drvdata(pdev);
 216
 217         gpiochip_remove(&palmas_gpio->gpio_chip);
 218         return 0;
 219 }
 220
 221 static struct platform_driver palmas_gpio_driver = {
 222         .driver.name    = "palmas-gpio",
 223         .driver.owner   = THIS_MODULE,
 224         .driver.of_match_table = of_palmas_gpio_match,
 225         .probe          = palmas_gpio_probe,
 226         .remove         = palmas_gpio_remove,
 227 };
 228
 229 static int __init palmas_gpio_init(void)
 230 {
 231         return platform_driver_register(&palmas_gpio_driver);
 232 }
 233 subsys_initcall(palmas_gpio_init);
 234
 235 static void __exit palmas_gpio_exit(void)
 236 {
 237         platform_driver_unregister(&palmas_gpio_driver);
 238 }
 239 module_exit(palmas_gpio_exit);
 240
 241 MODULE_ALIAS("platform:palmas-gpio");
 242 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
 243 MODULE_DESCRIPTION("GPIO driver for TI Palmas series PMICs");
 244 MODULE_LICENSE("GPL v2");