1 /* 2 * Core driver for TI TPS65090 PMIC family 3 * 4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved. 5 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 15 * You should have received a copy of the GNU General Public License 16 * along with this program. If not, see <http://www.gnu.org/licenses/>. 17 */ 18 19 #include <linux/interrupt.h> 20 #include <linux/irq.h> 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/mutex.h> 24 #include <linux/slab.h> 25 #include <linux/i2c.h> 26 #include <linux/mfd/core.h> 27 #include <linux/mfd/tps65090.h> 28 #include <linux/regmap.h> 29 #include <linux/err.h> 30 31 #define NUM_INT_REG 2 32 #define TOTAL_NUM_REG 0x18 33 34 /* interrupt status registers */ 35 #define TPS65090_INT_STS 0x0 36 #define TPS65090_INT_STS2 0x1 37 38 /* interrupt mask registers */ 39 #define TPS65090_INT_MSK 0x2 40 #define TPS65090_INT_MSK2 0x3 41 42 struct tps65090_irq_data { 43 u8 mask_reg; 44 u8 mask_pos; 45 }; 46 47 #define TPS65090_IRQ(_reg, _mask_pos) \ 48 { \ 49 .mask_reg = (_reg), \ 50 .mask_pos = (_mask_pos), \ 51 } 52 53 static const struct tps65090_irq_data tps65090_irqs[] = { 54 [0] = TPS65090_IRQ(0, 0), 55 [1] = TPS65090_IRQ(0, 1), 56 [2] = TPS65090_IRQ(0, 2), 57 [3] = TPS65090_IRQ(0, 3), 58 [4] = TPS65090_IRQ(0, 4), 59 [5] = TPS65090_IRQ(0, 5), 60 [6] = TPS65090_IRQ(0, 6), 61 [7] = TPS65090_IRQ(0, 7), 62 [8] = TPS65090_IRQ(1, 0), 63 [9] = TPS65090_IRQ(1, 1), 64 [10] = TPS65090_IRQ(1, 2), 65 [11] = TPS65090_IRQ(1, 3), 66 [12] = TPS65090_IRQ(1, 4), 67 [13] = TPS65090_IRQ(1, 5), 68 [14] = TPS65090_IRQ(1, 6), 69 [15] = TPS65090_IRQ(1, 7), 70 }; 71 72 static struct mfd_cell tps65090s[] = { 73 { 74 .name = "tps65090-pmic", 75 }, 76 { 77 .name = "tps65090-regulator", 78 }, 79 }; 80 81 int tps65090_write(struct device *dev, int reg, uint8_t val) 82 { 83 struct tps65090 *tps = dev_get_drvdata(dev); 84 return regmap_write(tps->rmap, reg, val); 85 } 86 EXPORT_SYMBOL_GPL(tps65090_write); 87 88 int tps65090_read(struct device *dev, int reg, uint8_t *val) 89 { 90 struct tps65090 *tps = dev_get_drvdata(dev); 91 unsigned int temp_val; 92 int ret; 93 ret = regmap_read(tps->rmap, reg, &temp_val); 94 if (!ret) 95 *val = temp_val; 96 return ret; 97 } 98 EXPORT_SYMBOL_GPL(tps65090_read); 99 100 int tps65090_set_bits(struct device *dev, int reg, uint8_t bit_num) 101 { 102 struct tps65090 *tps = dev_get_drvdata(dev); 103 return regmap_update_bits(tps->rmap, reg, BIT(bit_num), ~0u); 104 } 105 EXPORT_SYMBOL_GPL(tps65090_set_bits); 106 107 int tps65090_clr_bits(struct device *dev, int reg, uint8_t bit_num) 108 { 109 struct tps65090 *tps = dev_get_drvdata(dev); 110 return regmap_update_bits(tps->rmap, reg, BIT(bit_num), 0u); 111 } 112 EXPORT_SYMBOL_GPL(tps65090_clr_bits); 113 114 static void tps65090_irq_lock(struct irq_data *data) 115 { 116 struct tps65090 *tps65090 = irq_data_get_irq_chip_data(data); 117 118 mutex_lock(&tps65090->irq_lock); 119 } 120 121 static void tps65090_irq_mask(struct irq_data *irq_data) 122 { 123 struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data); 124 unsigned int __irq = irq_data->hwirq; 125 const struct tps65090_irq_data *data = &tps65090_irqs[__irq]; 126 127 tps65090_set_bits(tps65090->dev, (TPS65090_INT_MSK + data->mask_reg), 128 data->mask_pos); 129 } 130 131 static void tps65090_irq_unmask(struct irq_data *irq_data) 132 { 133 struct tps65090 *tps65090 = irq_data_get_irq_chip_data(irq_data); 134 unsigned int __irq = irq_data->irq - tps65090->irq_base; 135 const struct tps65090_irq_data *data = &tps65090_irqs[__irq]; 136 137 tps65090_clr_bits(tps65090->dev, (TPS65090_INT_MSK + data->mask_reg), 138 data->mask_pos); 139 } 140 141 static void tps65090_irq_sync_unlock(struct irq_data *data) 142 { 143 struct tps65090 *tps65090 = irq_data_get_irq_chip_data(data); 144 145 mutex_unlock(&tps65090->irq_lock); 146 } 147 148 static irqreturn_t tps65090_irq(int irq, void *data) 149 { 150 struct tps65090 *tps65090 = data; 151 int ret = 0; 152 u8 status, mask; 153 unsigned long int acks = 0; 154 int i; 155 156 for (i = 0; i < NUM_INT_REG; i++) { 157 ret = tps65090_read(tps65090->dev, TPS65090_INT_MSK + i, &mask); 158 if (ret < 0) { 159 dev_err(tps65090->dev, 160 "failed to read mask reg [addr:%d]\n", 161 TPS65090_INT_MSK + i); 162 return IRQ_NONE; 163 } 164 ret = tps65090_read(tps65090->dev, TPS65090_INT_STS + i, 165 &status); 166 if (ret < 0) { 167 dev_err(tps65090->dev, 168 "failed to read status reg [addr:%d]\n", 169 TPS65090_INT_STS + i); 170 return IRQ_NONE; 171 } 172 if (status) { 173 /* Ack only those interrupts which are not masked */ 174 status &= (~mask); 175 ret = tps65090_write(tps65090->dev, 176 TPS65090_INT_STS + i, status); 177 if (ret < 0) { 178 dev_err(tps65090->dev, 179 "failed to write interrupt status\n"); 180 return IRQ_NONE; 181 } 182 acks |= (status << (i * 8)); 183 } 184 } 185 186 for_each_set_bit(i, &acks, ARRAY_SIZE(tps65090_irqs)) 187 handle_nested_irq(tps65090->irq_base + i); 188 return acks ? IRQ_HANDLED : IRQ_NONE; 189 } 190 191 static int __devinit tps65090_irq_init(struct tps65090 *tps65090, int irq, 192 int irq_base) 193 { 194 int i, ret; 195 196 if (!irq_base) { 197 dev_err(tps65090->dev, "IRQ base not set\n"); 198 return -EINVAL; 199 } 200 201 mutex_init(&tps65090->irq_lock); 202 203 for (i = 0; i < NUM_INT_REG; i++) 204 tps65090_write(tps65090->dev, TPS65090_INT_MSK + i, 0xFF); 205 206 for (i = 0; i < NUM_INT_REG; i++) 207 tps65090_write(tps65090->dev, TPS65090_INT_STS + i, 0xff); 208 209 tps65090->irq_base = irq_base; 210 tps65090->irq_chip.name = "tps65090"; 211 tps65090->irq_chip.irq_mask = tps65090_irq_mask; 212 tps65090->irq_chip.irq_unmask = tps65090_irq_unmask; 213 tps65090->irq_chip.irq_bus_lock = tps65090_irq_lock; 214 tps65090->irq_chip.irq_bus_sync_unlock = tps65090_irq_sync_unlock; 215 216 for (i = 0; i < ARRAY_SIZE(tps65090_irqs); i++) { 217 int __irq = i + tps65090->irq_base; 218 irq_set_chip_data(__irq, tps65090); 219 irq_set_chip_and_handler(__irq, &tps65090->irq_chip, 220 handle_simple_irq); 221 irq_set_nested_thread(__irq, 1); 222 #ifdef CONFIG_ARM 223 set_irq_flags(__irq, IRQF_VALID); 224 #endif 225 } 226 227 ret = request_threaded_irq(irq, NULL, tps65090_irq, IRQF_ONESHOT, 228 "tps65090", tps65090); 229 if (!ret) { 230 device_init_wakeup(tps65090->dev, 1); 231 enable_irq_wake(irq); 232 } 233 234 return ret; 235 } 236 237 static bool is_volatile_reg(struct device *dev, unsigned int reg) 238 { 239 if (reg == TPS65090_INT_STS) 240 return true; 241 else 242 return false; 243 } 244 245 static const struct regmap_config tps65090_regmap_config = { 246 .reg_bits = 8, 247 .val_bits = 8, 248 .max_register = TOTAL_NUM_REG, 249 .num_reg_defaults_raw = TOTAL_NUM_REG, 250 .cache_type = REGCACHE_RBTREE, 251 .volatile_reg = is_volatile_reg, 252 }; 253 254 static int __devinit tps65090_i2c_probe(struct i2c_client *client, 255 const struct i2c_device_id *id) 256 { 257 struct tps65090_platform_data *pdata = client->dev.platform_data; 258 struct tps65090 *tps65090; 259 int ret; 260 261 if (!pdata) { 262 dev_err(&client->dev, "tps65090 requires platform data\n"); 263 return -EINVAL; 264 } 265 266 tps65090 = devm_kzalloc(&client->dev, sizeof(struct tps65090), 267 GFP_KERNEL); 268 if (tps65090 == NULL) 269 return -ENOMEM; 270 271 tps65090->client = client; 272 tps65090->dev = &client->dev; 273 i2c_set_clientdata(client, tps65090); 274 275 mutex_init(&tps65090->lock); 276 277 if (client->irq) { 278 ret = tps65090_irq_init(tps65090, client->irq, pdata->irq_base); 279 if (ret) { 280 dev_err(&client->dev, "IRQ init failed with err: %d\n", 281 ret); 282 goto err_exit; 283 } 284 } 285 286 tps65090->rmap = devm_regmap_init_i2c(tps65090->client, 287 &tps65090_regmap_config); 288 if (IS_ERR(tps65090->rmap)) { 289 ret = PTR_ERR(tps65090->rmap); 290 dev_err(&client->dev, "regmap_init failed with err: %d\n", ret); 291 goto err_irq_exit; 292 } 293 294 ret = mfd_add_devices(tps65090->dev, -1, tps65090s, 295 ARRAY_SIZE(tps65090s), NULL, 0, NULL); 296 if (ret) { 297 dev_err(&client->dev, "add mfd devices failed with err: %d\n", 298 ret); 299 goto err_irq_exit; 300 } 301 302 return 0; 303 304 err_irq_exit: 305 if (client->irq) 306 free_irq(client->irq, tps65090); 307 err_exit: 308 return ret; 309 } 310 311 static int __devexit tps65090_i2c_remove(struct i2c_client *client) 312 { 313 struct tps65090 *tps65090 = i2c_get_clientdata(client); 314 315 mfd_remove_devices(tps65090->dev); 316 if (client->irq) 317 free_irq(client->irq, tps65090); 318 319 return 0; 320 } 321 322 #ifdef CONFIG_PM_SLEEP 323 static int tps65090_suspend(struct device *dev) 324 { 325 struct i2c_client *client = to_i2c_client(dev); 326 if (client->irq) 327 disable_irq(client->irq); 328 return 0; 329 } 330 331 static int tps65090_resume(struct device *dev) 332 { 333 struct i2c_client *client = to_i2c_client(dev); 334 if (client->irq) 335 enable_irq(client->irq); 336 return 0; 337 } 338 #endif 339 340 static const struct dev_pm_ops tps65090_pm_ops = { 341 SET_SYSTEM_SLEEP_PM_OPS(tps65090_suspend, tps65090_resume) 342 }; 343 344 static const struct i2c_device_id tps65090_id_table[] = { 345 { "tps65090", 0 }, 346 { }, 347 }; 348 MODULE_DEVICE_TABLE(i2c, tps65090_id_table); 349 350 static struct i2c_driver tps65090_driver = { 351 .driver = { 352 .name = "tps65090", 353 .owner = THIS_MODULE, 354 .pm = &tps65090_pm_ops, 355 }, 356 .probe = tps65090_i2c_probe, 357 .remove = tps65090_i2c_remove, 358 .id_table = tps65090_id_table, 359 }; 360 361 static int __init tps65090_init(void) 362 { 363 return i2c_add_driver(&tps65090_driver); 364 } 365 subsys_initcall(tps65090_init); 366 367 static void __exit tps65090_exit(void) 368 { 369 i2c_del_driver(&tps65090_driver); 370 } 371 module_exit(tps65090_exit); 372 373 MODULE_DESCRIPTION("TPS65090 core driver"); 374 MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>"); 375 MODULE_LICENSE("GPL v2"); 376