drivers/gpio/gpio-bd70528.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (C) 2018 ROHM Semiconductors
   3 // gpio-bd70528.c ROHM BD70528MWV gpio driver
   4
   5 #include <linux/gpio/driver.h>
   6 #include <linux/mfd/rohm-bd70528.h>
   7 #include <linux/module.h>
   8 #include <linux/platform_device.h>
   9 #include <linux/regmap.h>
  10
  11 #define GPIO_IN_REG(offset) (BD70528_REG_GPIO1_IN + (offset) * 2)
  12 #define GPIO_OUT_REG(offset) (BD70528_REG_GPIO1_OUT + (offset) * 2)
  13
  14 struct bd70528_gpio {
  15         struct regmap *regmap;
  16         struct device *dev;
  17         struct gpio_chip gpio;
  18 };
  19
  20 static int bd70528_set_debounce(struct bd70528_gpio *bdgpio,
  21                                 unsigned int offset, unsigned int debounce)
  22 {
  23         u8 val;
  24
  25         switch (debounce) {
  26         case 0:
  27                 val = BD70528_DEBOUNCE_DISABLE;
  28                 break;
  29         case 1 ... 15000:
  30                 val = BD70528_DEBOUNCE_15MS;
  31                 break;
  32         case 15001 ... 30000:
  33                 val = BD70528_DEBOUNCE_30MS;
  34                 break;
  35         case 30001 ... 50000:
  36                 val = BD70528_DEBOUNCE_50MS;
  37                 break;
  38         default:
  39                 dev_err(bdgpio->dev,
  40                         "Invalid debounce value %u\n", debounce);
  41                 return -EINVAL;
  42         }
  43         return regmap_update_bits(bdgpio->regmap, GPIO_IN_REG(offset),
  44                                  BD70528_DEBOUNCE_MASK, val);
  45 }
  46
  47 static int bd70528_get_direction(struct gpio_chip *chip, unsigned int offset)
  48 {
  49         struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
  50         int val, ret;
  51
  52         /* Do we need to do something to IRQs here? */
  53         ret = regmap_read(bdgpio->regmap, GPIO_OUT_REG(offset), &val);
  54         if (ret) {
  55                 dev_err(bdgpio->dev, "Could not read gpio direction\n");
  56                 return ret;
  57         }
  58         if (val & BD70528_GPIO_OUT_EN_MASK)
  59                 return GPIO_LINE_DIRECTION_OUT;
  60
  61         return GPIO_LINE_DIRECTION_IN;
  62 }
  63
  64 static int bd70528_gpio_set_config(struct gpio_chip *chip, unsigned int offset,
  65                                    unsigned long config)
  66 {
  67         struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
  68
  69         switch (pinconf_to_config_param(config)) {
  70         case PIN_CONFIG_DRIVE_OPEN_DRAIN:
  71                 return regmap_update_bits(bdgpio->regmap,
  72                                           GPIO_OUT_REG(offset),
  73                                           BD70528_GPIO_DRIVE_MASK,
  74                                           BD70528_GPIO_OPEN_DRAIN);
  75                 break;
  76         case PIN_CONFIG_DRIVE_PUSH_PULL:
  77                 return regmap_update_bits(bdgpio->regmap,
  78                                           GPIO_OUT_REG(offset),
  79                                           BD70528_GPIO_DRIVE_MASK,
  80                                           BD70528_GPIO_PUSH_PULL);
  81                 break;
  82         case PIN_CONFIG_INPUT_DEBOUNCE:
  83                 return bd70528_set_debounce(bdgpio, offset,
  84                                             pinconf_to_config_argument(config));
  85                 break;
  86         default:
  87                 break;
  88         }
  89         return -ENOTSUPP;
  90 }
  91
  92 static int bd70528_direction_input(struct gpio_chip *chip, unsigned int offset)
  93 {
  94         struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
  95
  96         /* Do we need to do something to IRQs here? */
  97         return regmap_update_bits(bdgpio->regmap, GPIO_OUT_REG(offset),
  98                                  BD70528_GPIO_OUT_EN_MASK,
  99                                  BD70528_GPIO_OUT_DISABLE);
 100 }
 101
 102 static void bd70528_gpio_set(struct gpio_chip *chip, unsigned int offset,
 103                              int value)
 104 {
 105         int ret;
 106         struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
 107         u8 val = (value) ? BD70528_GPIO_OUT_HI : BD70528_GPIO_OUT_LO;
 108
 109         ret = regmap_update_bits(bdgpio->regmap, GPIO_OUT_REG(offset),
 110                                  BD70528_GPIO_OUT_MASK, val);
 111         if (ret)
 112                 dev_err(bdgpio->dev, "Could not set gpio to %d\n", value);
 113 }
 114
 115 static int bd70528_direction_output(struct gpio_chip *chip, unsigned int offset,
 116                                     int value)
 117 {
 118         struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
 119
 120         bd70528_gpio_set(chip, offset, value);
 121         return regmap_update_bits(bdgpio->regmap, GPIO_OUT_REG(offset),
 122                                  BD70528_GPIO_OUT_EN_MASK,
 123                                  BD70528_GPIO_OUT_ENABLE);
 124 }
 125
 126 #define GPIO_IN_STATE_MASK(offset) (BD70528_GPIO_IN_STATE_BASE << (offset))
 127
 128 static int bd70528_gpio_get_o(struct bd70528_gpio *bdgpio, unsigned int offset)
 129 {
 130         int ret;
 131         unsigned int val;
 132
 133         ret = regmap_read(bdgpio->regmap, GPIO_OUT_REG(offset), &val);
 134         if (!ret)
 135                 ret = !!(val & BD70528_GPIO_OUT_MASK);
 136         else
 137                 dev_err(bdgpio->dev, "GPIO (out) state read failed\n");
 138
 139         return ret;
 140 }
 141
 142 static int bd70528_gpio_get_i(struct bd70528_gpio *bdgpio, unsigned int offset)
 143 {
 144         unsigned int val;
 145         int ret;
 146
 147         ret = regmap_read(bdgpio->regmap, BD70528_REG_GPIO_STATE, &val);
 148
 149         if (!ret)
 150                 ret = !(val & GPIO_IN_STATE_MASK(offset));
 151         else
 152                 dev_err(bdgpio->dev, "GPIO (in) state read failed\n");
 153
 154         return ret;
 155 }
 156
 157 static int bd70528_gpio_get(struct gpio_chip *chip, unsigned int offset)
 158 {
 159         int ret;
 160         struct bd70528_gpio *bdgpio = gpiochip_get_data(chip);
 161
 162         /*
 163          * There is a race condition where someone might be changing the
 164          * GPIO direction after we get it but before we read the value. But
 165          * application design where GPIO direction may be changed just when
 166          * we read GPIO value would be pointless as reader could not know
 167          * whether the returned high/low state is caused by input or output.
 168          * Or then there must be other ways to mitigate the issue. Thus
 169          * locking would make no sense.
 170          */
 171         ret = bd70528_get_direction(chip, offset);
 172         if (ret == GPIO_LINE_DIRECTION_OUT)
 173                 ret = bd70528_gpio_get_o(bdgpio, offset);
 174         else if (ret == GPIO_LINE_DIRECTION_IN)
 175                 ret = bd70528_gpio_get_i(bdgpio, offset);
 176         else
 177                 dev_err(bdgpio->dev, "failed to read GPIO direction\n");
 178
 179         return ret;
 180 }
 181
 182 static int bd70528_probe(struct platform_device *pdev)
 183 {
 184         struct device *dev = &pdev->dev;
 185         struct bd70528_gpio *bdgpio;
 186         int ret;
 187
 188         bdgpio = devm_kzalloc(dev, sizeof(*bdgpio), GFP_KERNEL);
 189         if (!bdgpio)
 190                 return -ENOMEM;
 191         bdgpio->dev = dev;
 192         bdgpio->gpio.parent = dev->parent;
 193         bdgpio->gpio.label = "bd70528-gpio";
 194         bdgpio->gpio.owner = THIS_MODULE;
 195         bdgpio->gpio.get_direction = bd70528_get_direction;
 196         bdgpio->gpio.direction_input = bd70528_direction_input;
 197         bdgpio->gpio.direction_output = bd70528_direction_output;
 198         bdgpio->gpio.set_config = bd70528_gpio_set_config;
 199         bdgpio->gpio.can_sleep = true;
 200         bdgpio->gpio.get = bd70528_gpio_get;
 201         bdgpio->gpio.set = bd70528_gpio_set;
 202         bdgpio->gpio.ngpio = 4;
 203         bdgpio->gpio.base = -1;
 204 #ifdef CONFIG_OF_GPIO
 205         bdgpio->gpio.of_node = dev->parent->of_node;
 206 #endif
 207         bdgpio->regmap = dev_get_regmap(dev->parent, NULL);
 208         if (!bdgpio->regmap)
 209                 return -ENODEV;
 210
 211         ret = devm_gpiochip_add_data(dev, &bdgpio->gpio, bdgpio);
 212         if (ret)
 213                 dev_err(dev, "gpio_init: Failed to add bd70528-gpio\n");
 214
 215         return ret;
 216 }
 217
 218 static struct platform_driver bd70528_gpio = {
 219         .driver = {
 220                 .name = "bd70528-gpio"
 221         },
 222         .probe = bd70528_probe,
 223 };
 224
 225 module_platform_driver(bd70528_gpio);
 226
 227 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
 228 MODULE_DESCRIPTION("BD70528 voltage regulator driver");
 229 MODULE_LICENSE("GPL");
 230 MODULE_ALIAS("platform:bd70528-gpio");