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