1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * gpiolib support for Wolfson Arizona class devices 4 * 5 * Copyright 2012 Wolfson Microelectronics PLC. 6 * 7 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 8 */ 9 10 #include <linux/gpio/driver.h> 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/platform_device.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/slab.h> 16 17 #include <linux/mfd/arizona/core.h> 18 #include <linux/mfd/arizona/pdata.h> 19 #include <linux/mfd/arizona/registers.h> 20 21 struct arizona_gpio { 22 struct arizona *arizona; 23 struct gpio_chip gpio_chip; 24 }; 25 26 static int arizona_gpio_direction_in(struct gpio_chip *chip, unsigned offset) 27 { 28 struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip); 29 struct arizona *arizona = arizona_gpio->arizona; 30 bool persistent = gpiochip_line_is_persistent(chip, offset); 31 bool change; 32 int ret; 33 34 ret = regmap_update_bits_check(arizona->regmap, 35 ARIZONA_GPIO1_CTRL + offset, 36 ARIZONA_GPN_DIR, ARIZONA_GPN_DIR, 37 &change); 38 if (ret < 0) 39 return ret; 40 41 if (change && persistent) { 42 pm_runtime_mark_last_busy(chip->parent); 43 pm_runtime_put_autosuspend(chip->parent); 44 } 45 46 return 0; 47 } 48 49 static int arizona_gpio_get(struct gpio_chip *chip, unsigned offset) 50 { 51 struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip); 52 struct arizona *arizona = arizona_gpio->arizona; 53 unsigned int reg, val; 54 int ret; 55 56 reg = ARIZONA_GPIO1_CTRL + offset; 57 ret = regmap_read(arizona->regmap, reg, &val); 58 if (ret < 0) 59 return ret; 60 61 /* Resume to read actual registers for input pins */ 62 if (val & ARIZONA_GPN_DIR) { 63 ret = pm_runtime_get_sync(chip->parent); 64 if (ret < 0) { 65 dev_err(chip->parent, "Failed to resume: %d\n", ret); 66 pm_runtime_put_autosuspend(chip->parent); 67 return ret; 68 } 69 70 /* Register is cached, drop it to ensure a physical read */ 71 ret = regcache_drop_region(arizona->regmap, reg, reg); 72 if (ret < 0) { 73 dev_err(chip->parent, "Failed to drop cache: %d\n", 74 ret); 75 pm_runtime_put_autosuspend(chip->parent); 76 return ret; 77 } 78 79 ret = regmap_read(arizona->regmap, reg, &val); 80 if (ret < 0) { 81 pm_runtime_put_autosuspend(chip->parent); 82 return ret; 83 } 84 85 pm_runtime_mark_last_busy(chip->parent); 86 pm_runtime_put_autosuspend(chip->parent); 87 } 88 89 if (val & ARIZONA_GPN_LVL) 90 return 1; 91 else 92 return 0; 93 } 94 95 static int arizona_gpio_direction_out(struct gpio_chip *chip, 96 unsigned offset, int value) 97 { 98 struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip); 99 struct arizona *arizona = arizona_gpio->arizona; 100 bool persistent = gpiochip_line_is_persistent(chip, offset); 101 unsigned int val; 102 int ret; 103 104 ret = regmap_read(arizona->regmap, ARIZONA_GPIO1_CTRL + offset, &val); 105 if (ret < 0) 106 return ret; 107 108 if ((val & ARIZONA_GPN_DIR) && persistent) { 109 ret = pm_runtime_get_sync(chip->parent); 110 if (ret < 0) { 111 dev_err(chip->parent, "Failed to resume: %d\n", ret); 112 pm_runtime_put(chip->parent); 113 return ret; 114 } 115 } 116 117 if (value) 118 value = ARIZONA_GPN_LVL; 119 120 return regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset, 121 ARIZONA_GPN_DIR | ARIZONA_GPN_LVL, value); 122 } 123 124 static void arizona_gpio_set(struct gpio_chip *chip, unsigned offset, int value) 125 { 126 struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip); 127 struct arizona *arizona = arizona_gpio->arizona; 128 129 if (value) 130 value = ARIZONA_GPN_LVL; 131 132 regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset, 133 ARIZONA_GPN_LVL, value); 134 } 135 136 static const struct gpio_chip template_chip = { 137 .label = "arizona", 138 .owner = THIS_MODULE, 139 .direction_input = arizona_gpio_direction_in, 140 .get = arizona_gpio_get, 141 .direction_output = arizona_gpio_direction_out, 142 .set = arizona_gpio_set, 143 .can_sleep = true, 144 }; 145 146 static int arizona_gpio_probe(struct platform_device *pdev) 147 { 148 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent); 149 struct arizona_pdata *pdata = &arizona->pdata; 150 struct arizona_gpio *arizona_gpio; 151 int ret; 152 153 device_set_node(&pdev->dev, dev_fwnode(pdev->dev.parent)); 154 155 arizona_gpio = devm_kzalloc(&pdev->dev, sizeof(*arizona_gpio), 156 GFP_KERNEL); 157 if (!arizona_gpio) 158 return -ENOMEM; 159 160 arizona_gpio->arizona = arizona; 161 arizona_gpio->gpio_chip = template_chip; 162 arizona_gpio->gpio_chip.parent = &pdev->dev; 163 164 switch (arizona->type) { 165 case WM5102: 166 case WM5110: 167 case WM8280: 168 case WM8997: 169 case WM8998: 170 case WM1814: 171 arizona_gpio->gpio_chip.ngpio = 5; 172 break; 173 case WM1831: 174 case CS47L24: 175 arizona_gpio->gpio_chip.ngpio = 2; 176 break; 177 default: 178 dev_err(&pdev->dev, "Unknown chip variant %d\n", 179 arizona->type); 180 return -EINVAL; 181 } 182 183 if (pdata->gpio_base) 184 arizona_gpio->gpio_chip.base = pdata->gpio_base; 185 else 186 arizona_gpio->gpio_chip.base = -1; 187 188 pm_runtime_enable(&pdev->dev); 189 190 ret = devm_gpiochip_add_data(&pdev->dev, &arizona_gpio->gpio_chip, 191 arizona_gpio); 192 if (ret < 0) { 193 pm_runtime_disable(&pdev->dev); 194 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", 195 ret); 196 return ret; 197 } 198 199 return 0; 200 } 201 202 static struct platform_driver arizona_gpio_driver = { 203 .driver.name = "arizona-gpio", 204 .probe = arizona_gpio_probe, 205 }; 206 207 module_platform_driver(arizona_gpio_driver); 208 209 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 210 MODULE_DESCRIPTION("GPIO interface for Arizona devices"); 211 MODULE_LICENSE("GPL"); 212 MODULE_ALIAS("platform:arizona-gpio"); 213