1 /* 2 * TI Palma series PMIC's GPIO driver. 3 * 4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved. 5 * 6 * Author: Laxman Dewangan <ldewangan@nvidia.com> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms and conditions of the GNU General Public License, 10 * version 2, as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope it will be useful, but WITHOUT 13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 15 * more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 */ 20 21 #include <linux/gpio.h> 22 #include <linux/kernel.h> 23 #include <linux/module.h> 24 #include <linux/mfd/palmas.h> 25 #include <linux/of.h> 26 #include <linux/of_device.h> 27 #include <linux/platform_device.h> 28 29 struct palmas_gpio { 30 struct gpio_chip gpio_chip; 31 struct palmas *palmas; 32 }; 33 34 struct palmas_device_data { 35 int ngpio; 36 }; 37 38 static inline struct palmas_gpio *to_palmas_gpio(struct gpio_chip *chip) 39 { 40 return container_of(chip, struct palmas_gpio, gpio_chip); 41 } 42 43 static int palmas_gpio_get(struct gpio_chip *gc, unsigned offset) 44 { 45 struct palmas_gpio *pg = to_palmas_gpio(gc); 46 struct palmas *palmas = pg->palmas; 47 unsigned int val; 48 int ret; 49 unsigned int reg; 50 int gpio16 = (offset/8); 51 52 offset %= 8; 53 reg = (gpio16) ? PALMAS_GPIO_DATA_DIR2 : PALMAS_GPIO_DATA_DIR; 54 55 ret = palmas_read(palmas, PALMAS_GPIO_BASE, reg, &val); 56 if (ret < 0) { 57 dev_err(gc->parent, "Reg 0x%02x read failed, %d\n", reg, ret); 58 return ret; 59 } 60 61 if (val & BIT(offset)) 62 reg = (gpio16) ? PALMAS_GPIO_DATA_OUT2 : PALMAS_GPIO_DATA_OUT; 63 else 64 reg = (gpio16) ? PALMAS_GPIO_DATA_IN2 : PALMAS_GPIO_DATA_IN; 65 66 ret = palmas_read(palmas, PALMAS_GPIO_BASE, reg, &val); 67 if (ret < 0) { 68 dev_err(gc->parent, "Reg 0x%02x read failed, %d\n", reg, ret); 69 return ret; 70 } 71 return !!(val & BIT(offset)); 72 } 73 74 static void palmas_gpio_set(struct gpio_chip *gc, unsigned offset, 75 int value) 76 { 77 struct palmas_gpio *pg = to_palmas_gpio(gc); 78 struct palmas *palmas = pg->palmas; 79 int ret; 80 unsigned int reg; 81 int gpio16 = (offset/8); 82 83 offset %= 8; 84 if (gpio16) 85 reg = (value) ? 86 PALMAS_GPIO_SET_DATA_OUT2 : PALMAS_GPIO_CLEAR_DATA_OUT2; 87 else 88 reg = (value) ? 89 PALMAS_GPIO_SET_DATA_OUT : PALMAS_GPIO_CLEAR_DATA_OUT; 90 91 ret = palmas_write(palmas, PALMAS_GPIO_BASE, reg, BIT(offset)); 92 if (ret < 0) 93 dev_err(gc->parent, "Reg 0x%02x write failed, %d\n", reg, ret); 94 } 95 96 static int palmas_gpio_output(struct gpio_chip *gc, unsigned offset, 97 int value) 98 { 99 struct palmas_gpio *pg = to_palmas_gpio(gc); 100 struct palmas *palmas = pg->palmas; 101 int ret; 102 unsigned int reg; 103 int gpio16 = (offset/8); 104 105 offset %= 8; 106 reg = (gpio16) ? PALMAS_GPIO_DATA_DIR2 : PALMAS_GPIO_DATA_DIR; 107 108 /* Set the initial value */ 109 palmas_gpio_set(gc, offset, value); 110 111 ret = palmas_update_bits(palmas, PALMAS_GPIO_BASE, reg, 112 BIT(offset), BIT(offset)); 113 if (ret < 0) 114 dev_err(gc->parent, "Reg 0x%02x update failed, %d\n", reg, 115 ret); 116 return ret; 117 } 118 119 static int palmas_gpio_input(struct gpio_chip *gc, unsigned offset) 120 { 121 struct palmas_gpio *pg = to_palmas_gpio(gc); 122 struct palmas *palmas = pg->palmas; 123 int ret; 124 unsigned int reg; 125 int gpio16 = (offset/8); 126 127 offset %= 8; 128 reg = (gpio16) ? PALMAS_GPIO_DATA_DIR2 : PALMAS_GPIO_DATA_DIR; 129 130 ret = palmas_update_bits(palmas, PALMAS_GPIO_BASE, reg, BIT(offset), 0); 131 if (ret < 0) 132 dev_err(gc->parent, "Reg 0x%02x update failed, %d\n", reg, 133 ret); 134 return ret; 135 } 136 137 static int palmas_gpio_to_irq(struct gpio_chip *gc, unsigned offset) 138 { 139 struct palmas_gpio *pg = to_palmas_gpio(gc); 140 struct palmas *palmas = pg->palmas; 141 142 return palmas_irq_get_virq(palmas, PALMAS_GPIO_0_IRQ + offset); 143 } 144 145 static const struct palmas_device_data palmas_dev_data = { 146 .ngpio = 8, 147 }; 148 149 static const struct palmas_device_data tps80036_dev_data = { 150 .ngpio = 16, 151 }; 152 153 static const struct of_device_id of_palmas_gpio_match[] = { 154 { .compatible = "ti,palmas-gpio", .data = &palmas_dev_data,}, 155 { .compatible = "ti,tps65913-gpio", .data = &palmas_dev_data,}, 156 { .compatible = "ti,tps65914-gpio", .data = &palmas_dev_data,}, 157 { .compatible = "ti,tps80036-gpio", .data = &tps80036_dev_data,}, 158 { }, 159 }; 160 MODULE_DEVICE_TABLE(of, of_palmas_gpio_match); 161 162 static int palmas_gpio_probe(struct platform_device *pdev) 163 { 164 struct palmas *palmas = dev_get_drvdata(pdev->dev.parent); 165 struct palmas_platform_data *palmas_pdata; 166 struct palmas_gpio *palmas_gpio; 167 int ret; 168 const struct of_device_id *match; 169 const struct palmas_device_data *dev_data; 170 171 match = of_match_device(of_palmas_gpio_match, &pdev->dev); 172 if (!match) 173 return -ENODEV; 174 dev_data = match->data; 175 if (!dev_data) 176 dev_data = &palmas_dev_data; 177 178 palmas_gpio = devm_kzalloc(&pdev->dev, 179 sizeof(*palmas_gpio), GFP_KERNEL); 180 if (!palmas_gpio) 181 return -ENOMEM; 182 183 palmas_gpio->palmas = palmas; 184 palmas_gpio->gpio_chip.owner = THIS_MODULE; 185 palmas_gpio->gpio_chip.label = dev_name(&pdev->dev); 186 palmas_gpio->gpio_chip.ngpio = dev_data->ngpio; 187 palmas_gpio->gpio_chip.can_sleep = true; 188 palmas_gpio->gpio_chip.direction_input = palmas_gpio_input; 189 palmas_gpio->gpio_chip.direction_output = palmas_gpio_output; 190 palmas_gpio->gpio_chip.to_irq = palmas_gpio_to_irq; 191 palmas_gpio->gpio_chip.set = palmas_gpio_set; 192 palmas_gpio->gpio_chip.get = palmas_gpio_get; 193 palmas_gpio->gpio_chip.parent = &pdev->dev; 194 #ifdef CONFIG_OF_GPIO 195 palmas_gpio->gpio_chip.of_node = pdev->dev.of_node; 196 #endif 197 palmas_pdata = dev_get_platdata(palmas->dev); 198 if (palmas_pdata && palmas_pdata->gpio_base) 199 palmas_gpio->gpio_chip.base = palmas_pdata->gpio_base; 200 else 201 palmas_gpio->gpio_chip.base = -1; 202 203 ret = gpiochip_add(&palmas_gpio->gpio_chip); 204 if (ret < 0) { 205 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret); 206 return ret; 207 } 208 209 platform_set_drvdata(pdev, palmas_gpio); 210 return ret; 211 } 212 213 static int palmas_gpio_remove(struct platform_device *pdev) 214 { 215 struct palmas_gpio *palmas_gpio = platform_get_drvdata(pdev); 216 217 gpiochip_remove(&palmas_gpio->gpio_chip); 218 return 0; 219 } 220 221 static struct platform_driver palmas_gpio_driver = { 222 .driver.name = "palmas-gpio", 223 .driver.owner = THIS_MODULE, 224 .driver.of_match_table = of_palmas_gpio_match, 225 .probe = palmas_gpio_probe, 226 .remove = palmas_gpio_remove, 227 }; 228 229 static int __init palmas_gpio_init(void) 230 { 231 return platform_driver_register(&palmas_gpio_driver); 232 } 233 subsys_initcall(palmas_gpio_init); 234 235 static void __exit palmas_gpio_exit(void) 236 { 237 platform_driver_unregister(&palmas_gpio_driver); 238 } 239 module_exit(palmas_gpio_exit); 240 241 MODULE_ALIAS("platform:palmas-gpio"); 242 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>"); 243 MODULE_DESCRIPTION("GPIO driver for TI Palmas series PMICs"); 244 MODULE_LICENSE("GPL v2"); 245