drivers/gpio/gpio-adp5520.c

   1 /*
   2  * GPIO driver for Analog Devices ADP5520 MFD PMICs
   3  *
   4  * Copyright 2009 Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2 or later.
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/slab.h>
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/mfd/adp5520.h>
  15
  16 #include <linux/gpio.h>
  17
  18 struct adp5520_gpio {
  19         struct device *master;
  20         struct gpio_chip gpio_chip;
  21         unsigned char lut[ADP5520_MAXGPIOS];
  22         unsigned long output;
  23 };
  24
  25 static int adp5520_gpio_get_value(struct gpio_chip *chip, unsigned off)
  26 {
  27         struct adp5520_gpio *dev;
  28         uint8_t reg_val;
  29
  30         dev = container_of(chip, struct adp5520_gpio, gpio_chip);
  31
  32         /*
  33          * There are dedicated registers for GPIO IN/OUT.
  34          * Make sure we return the right value, even when configured as output
  35          */
  36
  37         if (test_bit(off, &dev->output))
  38                 adp5520_read(dev->master, ADP5520_GPIO_OUT, &reg_val);
  39         else
  40                 adp5520_read(dev->master, ADP5520_GPIO_IN, &reg_val);
  41
  42         return !!(reg_val & dev->lut[off]);
  43 }
  44
  45 static void adp5520_gpio_set_value(struct gpio_chip *chip,
  46                 unsigned off, int val)
  47 {
  48         struct adp5520_gpio *dev;
  49         dev = container_of(chip, struct adp5520_gpio, gpio_chip);
  50
  51         if (val)
  52                 adp5520_set_bits(dev->master, ADP5520_GPIO_OUT, dev->lut[off]);
  53         else
  54                 adp5520_clr_bits(dev->master, ADP5520_GPIO_OUT, dev->lut[off]);
  55 }
  56
  57 static int adp5520_gpio_direction_input(struct gpio_chip *chip, unsigned off)
  58 {
  59         struct adp5520_gpio *dev;
  60         dev = container_of(chip, struct adp5520_gpio, gpio_chip);
  61
  62         clear_bit(off, &dev->output);
  63
  64         return adp5520_clr_bits(dev->master, ADP5520_GPIO_CFG_2,
  65                                 dev->lut[off]);
  66 }
  67
  68 static int adp5520_gpio_direction_output(struct gpio_chip *chip,
  69                 unsigned off, int val)
  70 {
  71         struct adp5520_gpio *dev;
  72         int ret = 0;
  73         dev = container_of(chip, struct adp5520_gpio, gpio_chip);
  74
  75         set_bit(off, &dev->output);
  76
  77         if (val)
  78                 ret |= adp5520_set_bits(dev->master, ADP5520_GPIO_OUT,
  79                                         dev->lut[off]);
  80         else
  81                 ret |= adp5520_clr_bits(dev->master, ADP5520_GPIO_OUT,
  82                                         dev->lut[off]);
  83
  84         ret |= adp5520_set_bits(dev->master, ADP5520_GPIO_CFG_2,
  85                                         dev->lut[off]);
  86
  87         return ret;
  88 }
  89
  90 static int adp5520_gpio_probe(struct platform_device *pdev)
  91 {
  92         struct adp5520_gpio_platform_data *pdata = dev_get_platdata(&pdev->dev);
  93         struct adp5520_gpio *dev;
  94         struct gpio_chip *gc;
  95         int ret, i, gpios;
  96         unsigned char ctl_mask = 0;
  97
  98         if (pdata == NULL) {
  99                 dev_err(&pdev->dev, "missing platform data\n");
 100                 return -ENODEV;
 101         }
 102
 103         if (pdev->id != ID_ADP5520) {
 104                 dev_err(&pdev->dev, "only ADP5520 supports GPIO\n");
 105                 return -ENODEV;
 106         }
 107
 108         dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
 109         if (dev == NULL)
 110                 return -ENOMEM;
 111
 112         dev->master = pdev->dev.parent;
 113
 114         for (gpios = 0, i = 0; i < ADP5520_MAXGPIOS; i++)
 115                 if (pdata->gpio_en_mask & (1 << i))
 116                         dev->lut[gpios++] = 1 << i;
 117
 118         if (gpios < 1) {
 119                 ret = -EINVAL;
 120                 goto err;
 121         }
 122
 123         gc = &dev->gpio_chip;
 124         gc->direction_input  = adp5520_gpio_direction_input;
 125         gc->direction_output = adp5520_gpio_direction_output;
 126         gc->get = adp5520_gpio_get_value;
 127         gc->set = adp5520_gpio_set_value;
 128         gc->can_sleep = true;
 129
 130         gc->base = pdata->gpio_start;
 131         gc->ngpio = gpios;
 132         gc->label = pdev->name;
 133         gc->owner = THIS_MODULE;
 134
 135         ret = adp5520_clr_bits(dev->master, ADP5520_GPIO_CFG_1,
 136                 pdata->gpio_en_mask);
 137
 138         if (pdata->gpio_en_mask & ADP5520_GPIO_C3)
 139                 ctl_mask |= ADP5520_C3_MODE;
 140
 141         if (pdata->gpio_en_mask & ADP5520_GPIO_R3)
 142                 ctl_mask |= ADP5520_R3_MODE;
 143
 144         if (ctl_mask)
 145                 ret = adp5520_set_bits(dev->master, ADP5520_LED_CONTROL,
 146                         ctl_mask);
 147
 148         ret |= adp5520_set_bits(dev->master, ADP5520_GPIO_PULLUP,
 149                 pdata->gpio_pullup_mask);
 150
 151         if (ret) {
 152                 dev_err(&pdev->dev, "failed to write\n");
 153                 goto err;
 154         }
 155
 156         ret = gpiochip_add(&dev->gpio_chip);
 157         if (ret)
 158                 goto err;
 159
 160         platform_set_drvdata(pdev, dev);
 161         return 0;
 162
 163 err:
 164         return ret;
 165 }
 166
 167 static int adp5520_gpio_remove(struct platform_device *pdev)
 168 {
 169         struct adp5520_gpio *dev;
 170         int ret;
 171
 172         dev = platform_get_drvdata(pdev);
 173         ret = gpiochip_remove(&dev->gpio_chip);
 174         if (ret) {
 175                 dev_err(&pdev->dev, "%s failed, %d\n",
 176                                 "gpiochip_remove()", ret);
 177                 return ret;
 178         }
 179
 180         return 0;
 181 }
 182
 183 static struct platform_driver adp5520_gpio_driver = {
 184         .driver = {
 185                 .name   = "adp5520-gpio",
 186                 .owner  = THIS_MODULE,
 187         },
 188         .probe          = adp5520_gpio_probe,
 189         .remove         = adp5520_gpio_remove,
 190 };
 191
 192 module_platform_driver(adp5520_gpio_driver);
 193
 194 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 195 MODULE_DESCRIPTION("GPIO ADP5520 Driver");
 196 MODULE_LICENSE("GPL");
 197 MODULE_ALIAS("platform:adp5520-gpio");