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 int palmas_gpio_get(struct gpio_chip *gc, unsigned offset) 39 { 40 struct palmas_gpio *pg = gpiochip_get_data(gc); 41 struct palmas *palmas = pg->palmas; 42 unsigned int val; 43 int ret; 44 unsigned int reg; 45 int gpio16 = (offset/8); 46 47 offset %= 8; 48 reg = (gpio16) ? PALMAS_GPIO_DATA_DIR2 : PALMAS_GPIO_DATA_DIR; 49 50 ret = palmas_read(palmas, PALMAS_GPIO_BASE, reg, &val); 51 if (ret < 0) { 52 dev_err(gc->parent, "Reg 0x%02x read failed, %d\n", reg, ret); 53 return ret; 54 } 55 56 if (val & BIT(offset)) 57 reg = (gpio16) ? PALMAS_GPIO_DATA_OUT2 : PALMAS_GPIO_DATA_OUT; 58 else 59 reg = (gpio16) ? PALMAS_GPIO_DATA_IN2 : PALMAS_GPIO_DATA_IN; 60 61 ret = palmas_read(palmas, PALMAS_GPIO_BASE, reg, &val); 62 if (ret < 0) { 63 dev_err(gc->parent, "Reg 0x%02x read failed, %d\n", reg, ret); 64 return ret; 65 } 66 return !!(val & BIT(offset)); 67 } 68 69 static void palmas_gpio_set(struct gpio_chip *gc, unsigned offset, 70 int value) 71 { 72 struct palmas_gpio *pg = gpiochip_get_data(gc); 73 struct palmas *palmas = pg->palmas; 74 int ret; 75 unsigned int reg; 76 int gpio16 = (offset/8); 77 78 offset %= 8; 79 if (gpio16) 80 reg = (value) ? 81 PALMAS_GPIO_SET_DATA_OUT2 : PALMAS_GPIO_CLEAR_DATA_OUT2; 82 else 83 reg = (value) ? 84 PALMAS_GPIO_SET_DATA_OUT : PALMAS_GPIO_CLEAR_DATA_OUT; 85 86 ret = palmas_write(palmas, PALMAS_GPIO_BASE, reg, BIT(offset)); 87 if (ret < 0) 88 dev_err(gc->parent, "Reg 0x%02x write failed, %d\n", reg, ret); 89 } 90 91 static int palmas_gpio_output(struct gpio_chip *gc, unsigned offset, 92 int value) 93 { 94 struct palmas_gpio *pg = gpiochip_get_data(gc); 95 struct palmas *palmas = pg->palmas; 96 int ret; 97 unsigned int reg; 98 int gpio16 = (offset/8); 99 100 offset %= 8; 101 reg = (gpio16) ? PALMAS_GPIO_DATA_DIR2 : PALMAS_GPIO_DATA_DIR; 102 103 /* Set the initial value */ 104 palmas_gpio_set(gc, offset, value); 105 106 ret = palmas_update_bits(palmas, PALMAS_GPIO_BASE, reg, 107 BIT(offset), BIT(offset)); 108 if (ret < 0) 109 dev_err(gc->parent, "Reg 0x%02x update failed, %d\n", reg, 110 ret); 111 return ret; 112 } 113 114 static int palmas_gpio_input(struct gpio_chip *gc, unsigned offset) 115 { 116 struct palmas_gpio *pg = gpiochip_get_data(gc); 117 struct palmas *palmas = pg->palmas; 118 int ret; 119 unsigned int reg; 120 int gpio16 = (offset/8); 121 122 offset %= 8; 123 reg = (gpio16) ? PALMAS_GPIO_DATA_DIR2 : PALMAS_GPIO_DATA_DIR; 124 125 ret = palmas_update_bits(palmas, PALMAS_GPIO_BASE, reg, BIT(offset), 0); 126 if (ret < 0) 127 dev_err(gc->parent, "Reg 0x%02x update failed, %d\n", reg, 128 ret); 129 return ret; 130 } 131 132 static int palmas_gpio_to_irq(struct gpio_chip *gc, unsigned offset) 133 { 134 struct palmas_gpio *pg = gpiochip_get_data(gc); 135 struct palmas *palmas = pg->palmas; 136 137 return palmas_irq_get_virq(palmas, PALMAS_GPIO_0_IRQ + offset); 138 } 139 140 static const struct palmas_device_data palmas_dev_data = { 141 .ngpio = 8, 142 }; 143 144 static const struct palmas_device_data tps80036_dev_data = { 145 .ngpio = 16, 146 }; 147 148 static const struct of_device_id of_palmas_gpio_match[] = { 149 { .compatible = "ti,palmas-gpio", .data = &palmas_dev_data,}, 150 { .compatible = "ti,tps65913-gpio", .data = &palmas_dev_data,}, 151 { .compatible = "ti,tps65914-gpio", .data = &palmas_dev_data,}, 152 { .compatible = "ti,tps80036-gpio", .data = &tps80036_dev_data,}, 153 { }, 154 }; 155 MODULE_DEVICE_TABLE(of, of_palmas_gpio_match); 156 157 static int palmas_gpio_probe(struct platform_device *pdev) 158 { 159 struct palmas *palmas = dev_get_drvdata(pdev->dev.parent); 160 struct palmas_platform_data *palmas_pdata; 161 struct palmas_gpio *palmas_gpio; 162 int ret; 163 const struct of_device_id *match; 164 const struct palmas_device_data *dev_data; 165 166 match = of_match_device(of_palmas_gpio_match, &pdev->dev); 167 if (!match) 168 return -ENODEV; 169 dev_data = match->data; 170 if (!dev_data) 171 dev_data = &palmas_dev_data; 172 173 palmas_gpio = devm_kzalloc(&pdev->dev, 174 sizeof(*palmas_gpio), GFP_KERNEL); 175 if (!palmas_gpio) 176 return -ENOMEM; 177 178 palmas_gpio->palmas = palmas; 179 palmas_gpio->gpio_chip.owner = THIS_MODULE; 180 palmas_gpio->gpio_chip.label = dev_name(&pdev->dev); 181 palmas_gpio->gpio_chip.ngpio = dev_data->ngpio; 182 palmas_gpio->gpio_chip.can_sleep = true; 183 palmas_gpio->gpio_chip.direction_input = palmas_gpio_input; 184 palmas_gpio->gpio_chip.direction_output = palmas_gpio_output; 185 palmas_gpio->gpio_chip.to_irq = palmas_gpio_to_irq; 186 palmas_gpio->gpio_chip.set = palmas_gpio_set; 187 palmas_gpio->gpio_chip.get = palmas_gpio_get; 188 palmas_gpio->gpio_chip.parent = &pdev->dev; 189 #ifdef CONFIG_OF_GPIO 190 palmas_gpio->gpio_chip.of_node = pdev->dev.of_node; 191 #endif 192 palmas_pdata = dev_get_platdata(palmas->dev); 193 if (palmas_pdata && palmas_pdata->gpio_base) 194 palmas_gpio->gpio_chip.base = palmas_pdata->gpio_base; 195 else 196 palmas_gpio->gpio_chip.base = -1; 197 198 ret = devm_gpiochip_add_data(&pdev->dev, &palmas_gpio->gpio_chip, 199 palmas_gpio); 200 if (ret < 0) { 201 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret); 202 return ret; 203 } 204 205 platform_set_drvdata(pdev, palmas_gpio); 206 return ret; 207 } 208 209 static struct platform_driver palmas_gpio_driver = { 210 .driver.name = "palmas-gpio", 211 .driver.owner = THIS_MODULE, 212 .driver.of_match_table = of_palmas_gpio_match, 213 .probe = palmas_gpio_probe, 214 }; 215 216 static int __init palmas_gpio_init(void) 217 { 218 return platform_driver_register(&palmas_gpio_driver); 219 } 220 subsys_initcall(palmas_gpio_init); 221 222 static void __exit palmas_gpio_exit(void) 223 { 224 platform_driver_unregister(&palmas_gpio_driver); 225 } 226 module_exit(palmas_gpio_exit); 227 228 MODULE_ALIAS("platform:palmas-gpio"); 229 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>"); 230 MODULE_DESCRIPTION("GPIO driver for TI Palmas series PMICs"); 231 MODULE_LICENSE("GPL v2"); 232