1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Dialog DA9062 pinctrl and GPIO driver. 4 * Based on DA9055 GPIO driver. 5 * 6 * TODO: 7 * - add pinmux and pinctrl support (gpio alternate mode) 8 * 9 * Documents: 10 * [1] https://www.dialog-semiconductor.com/sites/default/files/da9062_datasheet_3v6.pdf 11 * 12 * Copyright (C) 2019 Pengutronix, Marco Felsch <kernel@pengutronix.de> 13 */ 14 #include <linux/bits.h> 15 #include <linux/module.h> 16 #include <linux/platform_device.h> 17 #include <linux/property.h> 18 #include <linux/regmap.h> 19 20 #include <linux/gpio/driver.h> 21 22 #include <linux/mfd/da9062/core.h> 23 #include <linux/mfd/da9062/registers.h> 24 25 /* 26 * We need this get the gpio_desc from a <gpio_chip,offset> tuple to decide if 27 * the gpio is active low without a vendor specific dt-binding. 28 */ 29 #include "../gpio/gpiolib.h" 30 31 #define DA9062_TYPE(offset) (4 * (offset % 2)) 32 #define DA9062_PIN_SHIFT(offset) (4 * (offset % 2)) 33 #define DA9062_PIN_ALTERNATE 0x00 /* gpio alternate mode */ 34 #define DA9062_PIN_GPI 0x01 /* gpio in */ 35 #define DA9062_PIN_GPO_OD 0x02 /* gpio out open-drain */ 36 #define DA9062_PIN_GPO_PP 0x03 /* gpio out push-pull */ 37 #define DA9062_GPIO_NUM 5 38 39 struct da9062_pctl { 40 struct da9062 *da9062; 41 struct gpio_chip gc; 42 unsigned int pin_config[DA9062_GPIO_NUM]; 43 }; 44 45 static int da9062_pctl_get_pin_mode(struct da9062_pctl *pctl, 46 unsigned int offset) 47 { 48 struct regmap *regmap = pctl->da9062->regmap; 49 int ret, val; 50 51 ret = regmap_read(regmap, DA9062AA_GPIO_0_1 + (offset >> 1), &val); 52 if (ret < 0) 53 return ret; 54 55 val >>= DA9062_PIN_SHIFT(offset); 56 val &= DA9062AA_GPIO0_PIN_MASK; 57 58 return val; 59 } 60 61 static int da9062_pctl_set_pin_mode(struct da9062_pctl *pctl, 62 unsigned int offset, unsigned int mode_req) 63 { 64 struct regmap *regmap = pctl->da9062->regmap; 65 unsigned int mode = mode_req; 66 unsigned int mask; 67 int ret; 68 69 mode &= DA9062AA_GPIO0_PIN_MASK; 70 mode <<= DA9062_PIN_SHIFT(offset); 71 mask = DA9062AA_GPIO0_PIN_MASK << DA9062_PIN_SHIFT(offset); 72 73 ret = regmap_update_bits(regmap, DA9062AA_GPIO_0_1 + (offset >> 1), 74 mask, mode); 75 if (!ret) 76 pctl->pin_config[offset] = mode_req; 77 78 return ret; 79 } 80 81 static int da9062_gpio_get(struct gpio_chip *gc, unsigned int offset) 82 { 83 struct da9062_pctl *pctl = gpiochip_get_data(gc); 84 struct regmap *regmap = pctl->da9062->regmap; 85 int gpio_mode, val; 86 int ret; 87 88 gpio_mode = da9062_pctl_get_pin_mode(pctl, offset); 89 if (gpio_mode < 0) 90 return gpio_mode; 91 92 switch (gpio_mode) { 93 case DA9062_PIN_ALTERNATE: 94 return -ENOTSUPP; 95 case DA9062_PIN_GPI: 96 ret = regmap_read(regmap, DA9062AA_STATUS_B, &val); 97 if (ret < 0) 98 return ret; 99 break; 100 case DA9062_PIN_GPO_OD: 101 case DA9062_PIN_GPO_PP: 102 ret = regmap_read(regmap, DA9062AA_GPIO_MODE0_4, &val); 103 if (ret < 0) 104 return ret; 105 } 106 107 return !!(val & BIT(offset)); 108 } 109 110 static void da9062_gpio_set(struct gpio_chip *gc, unsigned int offset, 111 int value) 112 { 113 struct da9062_pctl *pctl = gpiochip_get_data(gc); 114 struct regmap *regmap = pctl->da9062->regmap; 115 116 regmap_update_bits(regmap, DA9062AA_GPIO_MODE0_4, BIT(offset), 117 value << offset); 118 } 119 120 static int da9062_gpio_get_direction(struct gpio_chip *gc, unsigned int offset) 121 { 122 struct da9062_pctl *pctl = gpiochip_get_data(gc); 123 int gpio_mode; 124 125 gpio_mode = da9062_pctl_get_pin_mode(pctl, offset); 126 if (gpio_mode < 0) 127 return gpio_mode; 128 129 switch (gpio_mode) { 130 case DA9062_PIN_ALTERNATE: 131 return -ENOTSUPP; 132 case DA9062_PIN_GPI: 133 return GPIO_LINE_DIRECTION_IN; 134 case DA9062_PIN_GPO_OD: 135 case DA9062_PIN_GPO_PP: 136 return GPIO_LINE_DIRECTION_OUT; 137 } 138 139 return -EINVAL; 140 } 141 142 static int da9062_gpio_direction_input(struct gpio_chip *gc, 143 unsigned int offset) 144 { 145 struct da9062_pctl *pctl = gpiochip_get_data(gc); 146 struct regmap *regmap = pctl->da9062->regmap; 147 struct gpio_desc *desc = gpiochip_get_desc(gc, offset); 148 unsigned int gpi_type; 149 int ret; 150 151 ret = da9062_pctl_set_pin_mode(pctl, offset, DA9062_PIN_GPI); 152 if (ret) 153 return ret; 154 155 /* 156 * If the gpio is active low we should set it in hw too. No worries 157 * about gpio_get() because we read and return the gpio-level. So the 158 * gpiolib active_low handling is still correct. 159 * 160 * 0 - active low, 1 - active high 161 */ 162 gpi_type = !gpiod_is_active_low(desc); 163 164 return regmap_update_bits(regmap, DA9062AA_GPIO_0_1 + (offset >> 1), 165 DA9062AA_GPIO0_TYPE_MASK << DA9062_TYPE(offset), 166 gpi_type << DA9062_TYPE(offset)); 167 } 168 169 static int da9062_gpio_direction_output(struct gpio_chip *gc, 170 unsigned int offset, int value) 171 { 172 struct da9062_pctl *pctl = gpiochip_get_data(gc); 173 unsigned int pin_config = pctl->pin_config[offset]; 174 int ret; 175 176 ret = da9062_pctl_set_pin_mode(pctl, offset, pin_config); 177 if (ret) 178 return ret; 179 180 da9062_gpio_set(gc, offset, value); 181 182 return 0; 183 } 184 185 static int da9062_gpio_set_config(struct gpio_chip *gc, unsigned int offset, 186 unsigned long config) 187 { 188 struct da9062_pctl *pctl = gpiochip_get_data(gc); 189 struct regmap *regmap = pctl->da9062->regmap; 190 int gpio_mode; 191 192 /* 193 * We need to meet the following restrictions [1, Figure 18]: 194 * - PIN_CONFIG_BIAS_PULL_DOWN -> only allowed if the pin is used as 195 * gpio input 196 * - PIN_CONFIG_BIAS_PULL_UP -> only allowed if the pin is used as 197 * gpio output open-drain. 198 */ 199 200 switch (pinconf_to_config_param(config)) { 201 case PIN_CONFIG_BIAS_DISABLE: 202 return regmap_update_bits(regmap, DA9062AA_CONFIG_K, 203 BIT(offset), 0); 204 case PIN_CONFIG_BIAS_PULL_DOWN: 205 gpio_mode = da9062_pctl_get_pin_mode(pctl, offset); 206 if (gpio_mode < 0) 207 return -EINVAL; 208 else if (gpio_mode != DA9062_PIN_GPI) 209 return -ENOTSUPP; 210 return regmap_update_bits(regmap, DA9062AA_CONFIG_K, 211 BIT(offset), BIT(offset)); 212 case PIN_CONFIG_BIAS_PULL_UP: 213 gpio_mode = da9062_pctl_get_pin_mode(pctl, offset); 214 if (gpio_mode < 0) 215 return -EINVAL; 216 else if (gpio_mode != DA9062_PIN_GPO_OD) 217 return -ENOTSUPP; 218 return regmap_update_bits(regmap, DA9062AA_CONFIG_K, 219 BIT(offset), BIT(offset)); 220 case PIN_CONFIG_DRIVE_OPEN_DRAIN: 221 return da9062_pctl_set_pin_mode(pctl, offset, 222 DA9062_PIN_GPO_OD); 223 case PIN_CONFIG_DRIVE_PUSH_PULL: 224 return da9062_pctl_set_pin_mode(pctl, offset, 225 DA9062_PIN_GPO_PP); 226 default: 227 return -ENOTSUPP; 228 } 229 } 230 231 static int da9062_gpio_to_irq(struct gpio_chip *gc, unsigned int offset) 232 { 233 struct da9062_pctl *pctl = gpiochip_get_data(gc); 234 struct da9062 *da9062 = pctl->da9062; 235 236 return regmap_irq_get_virq(da9062->regmap_irq, 237 DA9062_IRQ_GPI0 + offset); 238 } 239 240 static const struct gpio_chip reference_gc = { 241 .owner = THIS_MODULE, 242 .get = da9062_gpio_get, 243 .set = da9062_gpio_set, 244 .get_direction = da9062_gpio_get_direction, 245 .direction_input = da9062_gpio_direction_input, 246 .direction_output = da9062_gpio_direction_output, 247 .set_config = da9062_gpio_set_config, 248 .to_irq = da9062_gpio_to_irq, 249 .can_sleep = true, 250 .ngpio = DA9062_GPIO_NUM, 251 .base = -1, 252 }; 253 254 static int da9062_pctl_probe(struct platform_device *pdev) 255 { 256 struct device *parent = pdev->dev.parent; 257 struct da9062_pctl *pctl; 258 int i; 259 260 device_set_node(&pdev->dev, dev_fwnode(pdev->dev.parent)); 261 262 pctl = devm_kzalloc(&pdev->dev, sizeof(*pctl), GFP_KERNEL); 263 if (!pctl) 264 return -ENOMEM; 265 266 pctl->da9062 = dev_get_drvdata(parent); 267 if (!pctl->da9062) 268 return -EINVAL; 269 270 if (!device_property_present(parent, "gpio-controller")) 271 return 0; 272 273 for (i = 0; i < ARRAY_SIZE(pctl->pin_config); i++) 274 pctl->pin_config[i] = DA9062_PIN_GPO_PP; 275 276 /* 277 * Currently the driver handles only the GPIO support. The 278 * pinctrl/pinmux support can be added later if needed. 279 */ 280 pctl->gc = reference_gc; 281 pctl->gc.label = dev_name(&pdev->dev); 282 pctl->gc.parent = &pdev->dev; 283 284 platform_set_drvdata(pdev, pctl); 285 286 return devm_gpiochip_add_data(&pdev->dev, &pctl->gc, pctl); 287 } 288 289 static struct platform_driver da9062_pctl_driver = { 290 .probe = da9062_pctl_probe, 291 .driver = { 292 .name = "da9062-gpio", 293 }, 294 }; 295 module_platform_driver(da9062_pctl_driver); 296 297 MODULE_AUTHOR("Marco Felsch <kernel@pengutronix.de>"); 298 MODULE_DESCRIPTION("DA9062 PMIC pinctrl and GPIO Driver"); 299 MODULE_LICENSE("GPL v2"); 300 MODULE_ALIAS("platform:da9062-gpio"); 301