1 /* 2 * tps65217.c 3 * 4 * TPS65217 chip family multi-function driver 5 * 6 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/ 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation version 2. 11 * 12 * This program is distributed "as is" WITHOUT ANY WARRANTY of any 13 * kind, whether express or implied; without even the implied warranty 14 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 */ 17 18 #include <linux/device.h> 19 #include <linux/err.h> 20 #include <linux/init.h> 21 #include <linux/interrupt.h> 22 #include <linux/i2c.h> 23 #include <linux/irq.h> 24 #include <linux/irqdomain.h> 25 #include <linux/kernel.h> 26 #include <linux/module.h> 27 #include <linux/of.h> 28 #include <linux/of_device.h> 29 #include <linux/platform_device.h> 30 #include <linux/regmap.h> 31 #include <linux/slab.h> 32 33 #include <linux/mfd/core.h> 34 #include <linux/mfd/tps65217.h> 35 36 static struct resource charger_resources[] = { 37 DEFINE_RES_IRQ_NAMED(TPS65217_IRQ_AC, "AC"), 38 DEFINE_RES_IRQ_NAMED(TPS65217_IRQ_USB, "USB"), 39 }; 40 41 static struct resource pb_resources[] = { 42 DEFINE_RES_IRQ_NAMED(TPS65217_IRQ_PB, "PB"), 43 }; 44 45 struct tps65217_irq { 46 int mask; 47 int interrupt; 48 }; 49 50 static const struct tps65217_irq tps65217_irqs[] = { 51 [TPS65217_IRQ_PB] = { 52 .mask = TPS65217_INT_PBM, 53 .interrupt = TPS65217_INT_PBI, 54 }, 55 [TPS65217_IRQ_AC] = { 56 .mask = TPS65217_INT_ACM, 57 .interrupt = TPS65217_INT_ACI, 58 }, 59 [TPS65217_IRQ_USB] = { 60 .mask = TPS65217_INT_USBM, 61 .interrupt = TPS65217_INT_USBI, 62 }, 63 }; 64 65 static void tps65217_irq_lock(struct irq_data *data) 66 { 67 struct tps65217 *tps = irq_data_get_irq_chip_data(data); 68 69 mutex_lock(&tps->irq_lock); 70 } 71 72 static void tps65217_irq_sync_unlock(struct irq_data *data) 73 { 74 struct tps65217 *tps = irq_data_get_irq_chip_data(data); 75 int ret; 76 77 ret = tps65217_reg_write(tps, TPS65217_REG_INT, tps->irq_mask, 78 TPS65217_PROTECT_NONE); 79 if (ret != 0) 80 dev_err(tps->dev, "Failed to sync IRQ masks\n"); 81 82 mutex_unlock(&tps->irq_lock); 83 } 84 85 static inline const struct tps65217_irq * 86 irq_to_tps65217_irq(struct tps65217 *tps, struct irq_data *data) 87 { 88 return &tps65217_irqs[data->hwirq]; 89 } 90 91 static void tps65217_irq_enable(struct irq_data *data) 92 { 93 struct tps65217 *tps = irq_data_get_irq_chip_data(data); 94 const struct tps65217_irq *irq_data = irq_to_tps65217_irq(tps, data); 95 96 tps->irq_mask &= ~irq_data->mask; 97 } 98 99 static void tps65217_irq_disable(struct irq_data *data) 100 { 101 struct tps65217 *tps = irq_data_get_irq_chip_data(data); 102 const struct tps65217_irq *irq_data = irq_to_tps65217_irq(tps, data); 103 104 tps->irq_mask |= irq_data->mask; 105 } 106 107 static struct irq_chip tps65217_irq_chip = { 108 .irq_bus_lock = tps65217_irq_lock, 109 .irq_bus_sync_unlock = tps65217_irq_sync_unlock, 110 .irq_enable = tps65217_irq_enable, 111 .irq_disable = tps65217_irq_disable, 112 }; 113 114 static struct mfd_cell tps65217s[] = { 115 { 116 .name = "tps65217-pmic", 117 .of_compatible = "ti,tps65217-pmic", 118 }, 119 { 120 .name = "tps65217-bl", 121 .of_compatible = "ti,tps65217-bl", 122 }, 123 { 124 .name = "tps65217-charger", 125 .num_resources = ARRAY_SIZE(charger_resources), 126 .resources = charger_resources, 127 .of_compatible = "ti,tps65217-charger", 128 }, 129 { 130 .name = "tps65217-pwrbutton", 131 .num_resources = ARRAY_SIZE(pb_resources), 132 .resources = pb_resources, 133 .of_compatible = "ti,tps65217-pwrbutton", 134 }, 135 }; 136 137 static irqreturn_t tps65217_irq_thread(int irq, void *data) 138 { 139 struct tps65217 *tps = data; 140 unsigned int status; 141 bool handled = false; 142 int i; 143 int ret; 144 145 ret = tps65217_reg_read(tps, TPS65217_REG_INT, &status); 146 if (ret < 0) { 147 dev_err(tps->dev, "Failed to read IRQ status: %d\n", 148 ret); 149 return IRQ_NONE; 150 } 151 152 for (i = 0; i < ARRAY_SIZE(tps65217_irqs); i++) { 153 if (status & tps65217_irqs[i].interrupt) { 154 handle_nested_irq(irq_find_mapping(tps->irq_domain, i)); 155 handled = true; 156 } 157 } 158 159 if (handled) 160 return IRQ_HANDLED; 161 162 return IRQ_NONE; 163 } 164 165 static int tps65217_irq_map(struct irq_domain *h, unsigned int virq, 166 irq_hw_number_t hw) 167 { 168 struct tps65217 *tps = h->host_data; 169 170 irq_set_chip_data(virq, tps); 171 irq_set_chip_and_handler(virq, &tps65217_irq_chip, handle_edge_irq); 172 irq_set_nested_thread(virq, 1); 173 irq_set_parent(virq, tps->irq); 174 irq_set_noprobe(virq); 175 176 return 0; 177 } 178 179 static const struct irq_domain_ops tps65217_irq_domain_ops = { 180 .map = tps65217_irq_map, 181 }; 182 183 static int tps65217_irq_init(struct tps65217 *tps, int irq) 184 { 185 int ret; 186 187 mutex_init(&tps->irq_lock); 188 tps->irq = irq; 189 190 /* Mask all interrupt sources */ 191 tps->irq_mask = (TPS65217_INT_RESERVEDM | TPS65217_INT_PBM 192 | TPS65217_INT_ACM | TPS65217_INT_USBM); 193 tps65217_reg_write(tps, TPS65217_REG_INT, tps->irq_mask, 194 TPS65217_PROTECT_NONE); 195 196 tps->irq_domain = irq_domain_add_linear(tps->dev->of_node, 197 TPS65217_NUM_IRQ, &tps65217_irq_domain_ops, tps); 198 if (!tps->irq_domain) { 199 dev_err(tps->dev, "Could not create IRQ domain\n"); 200 return -ENOMEM; 201 } 202 203 ret = devm_request_threaded_irq(tps->dev, irq, NULL, 204 tps65217_irq_thread, IRQF_ONESHOT, 205 "tps65217-irq", tps); 206 if (ret) { 207 dev_err(tps->dev, "Failed to request IRQ %d: %d\n", 208 irq, ret); 209 return ret; 210 } 211 212 return 0; 213 } 214 215 /** 216 * tps65217_reg_read: Read a single tps65217 register. 217 * 218 * @tps: Device to read from. 219 * @reg: Register to read. 220 * @val: Contians the value 221 */ 222 int tps65217_reg_read(struct tps65217 *tps, unsigned int reg, 223 unsigned int *val) 224 { 225 return regmap_read(tps->regmap, reg, val); 226 } 227 EXPORT_SYMBOL_GPL(tps65217_reg_read); 228 229 /** 230 * tps65217_reg_write: Write a single tps65217 register. 231 * 232 * @tps65217: Device to write to. 233 * @reg: Register to write to. 234 * @val: Value to write. 235 * @level: Password protected level 236 */ 237 int tps65217_reg_write(struct tps65217 *tps, unsigned int reg, 238 unsigned int val, unsigned int level) 239 { 240 int ret; 241 unsigned int xor_reg_val; 242 243 switch (level) { 244 case TPS65217_PROTECT_NONE: 245 return regmap_write(tps->regmap, reg, val); 246 case TPS65217_PROTECT_L1: 247 xor_reg_val = reg ^ TPS65217_PASSWORD_REGS_UNLOCK; 248 ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD, 249 xor_reg_val); 250 if (ret < 0) 251 return ret; 252 253 return regmap_write(tps->regmap, reg, val); 254 case TPS65217_PROTECT_L2: 255 xor_reg_val = reg ^ TPS65217_PASSWORD_REGS_UNLOCK; 256 ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD, 257 xor_reg_val); 258 if (ret < 0) 259 return ret; 260 ret = regmap_write(tps->regmap, reg, val); 261 if (ret < 0) 262 return ret; 263 ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD, 264 xor_reg_val); 265 if (ret < 0) 266 return ret; 267 return regmap_write(tps->regmap, reg, val); 268 default: 269 return -EINVAL; 270 } 271 } 272 EXPORT_SYMBOL_GPL(tps65217_reg_write); 273 274 /** 275 * tps65217_update_bits: Modify bits w.r.t mask, val and level. 276 * 277 * @tps65217: Device to write to. 278 * @reg: Register to read-write to. 279 * @mask: Mask. 280 * @val: Value to write. 281 * @level: Password protected level 282 */ 283 static int tps65217_update_bits(struct tps65217 *tps, unsigned int reg, 284 unsigned int mask, unsigned int val, unsigned int level) 285 { 286 int ret; 287 unsigned int data; 288 289 ret = tps65217_reg_read(tps, reg, &data); 290 if (ret) { 291 dev_err(tps->dev, "Read from reg 0x%x failed\n", reg); 292 return ret; 293 } 294 295 data &= ~mask; 296 data |= val & mask; 297 298 ret = tps65217_reg_write(tps, reg, data, level); 299 if (ret) 300 dev_err(tps->dev, "Write for reg 0x%x failed\n", reg); 301 302 return ret; 303 } 304 305 int tps65217_set_bits(struct tps65217 *tps, unsigned int reg, 306 unsigned int mask, unsigned int val, unsigned int level) 307 { 308 return tps65217_update_bits(tps, reg, mask, val, level); 309 } 310 EXPORT_SYMBOL_GPL(tps65217_set_bits); 311 312 int tps65217_clear_bits(struct tps65217 *tps, unsigned int reg, 313 unsigned int mask, unsigned int level) 314 { 315 return tps65217_update_bits(tps, reg, mask, 0, level); 316 } 317 EXPORT_SYMBOL_GPL(tps65217_clear_bits); 318 319 static bool tps65217_volatile_reg(struct device *dev, unsigned int reg) 320 { 321 switch (reg) { 322 case TPS65217_REG_INT: 323 return true; 324 default: 325 return false; 326 } 327 } 328 329 static const struct regmap_config tps65217_regmap_config = { 330 .reg_bits = 8, 331 .val_bits = 8, 332 333 .max_register = TPS65217_REG_MAX, 334 .volatile_reg = tps65217_volatile_reg, 335 }; 336 337 static const struct of_device_id tps65217_of_match[] = { 338 { .compatible = "ti,tps65217", .data = (void *)TPS65217 }, 339 { /* sentinel */ }, 340 }; 341 MODULE_DEVICE_TABLE(of, tps65217_of_match); 342 343 static int tps65217_probe(struct i2c_client *client, 344 const struct i2c_device_id *ids) 345 { 346 struct tps65217 *tps; 347 unsigned int version; 348 unsigned long chip_id = ids->driver_data; 349 const struct of_device_id *match; 350 bool status_off = false; 351 int ret; 352 353 if (client->dev.of_node) { 354 match = of_match_device(tps65217_of_match, &client->dev); 355 if (!match) { 356 dev_err(&client->dev, 357 "Failed to find matching dt id\n"); 358 return -EINVAL; 359 } 360 chip_id = (unsigned long)match->data; 361 status_off = of_property_read_bool(client->dev.of_node, 362 "ti,pmic-shutdown-controller"); 363 } 364 365 if (!chip_id) { 366 dev_err(&client->dev, "id is null.\n"); 367 return -ENODEV; 368 } 369 370 tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL); 371 if (!tps) 372 return -ENOMEM; 373 374 i2c_set_clientdata(client, tps); 375 tps->dev = &client->dev; 376 tps->id = chip_id; 377 378 tps->regmap = devm_regmap_init_i2c(client, &tps65217_regmap_config); 379 if (IS_ERR(tps->regmap)) { 380 ret = PTR_ERR(tps->regmap); 381 dev_err(tps->dev, "Failed to allocate register map: %d\n", 382 ret); 383 return ret; 384 } 385 386 if (client->irq) { 387 tps65217_irq_init(tps, client->irq); 388 } else { 389 int i; 390 391 /* Don't tell children about IRQ resources which won't fire */ 392 for (i = 0; i < ARRAY_SIZE(tps65217s); i++) 393 tps65217s[i].num_resources = 0; 394 } 395 396 ret = devm_mfd_add_devices(tps->dev, -1, tps65217s, 397 ARRAY_SIZE(tps65217s), NULL, 0, 398 tps->irq_domain); 399 if (ret < 0) { 400 dev_err(tps->dev, "mfd_add_devices failed: %d\n", ret); 401 return ret; 402 } 403 404 ret = tps65217_reg_read(tps, TPS65217_REG_CHIPID, &version); 405 if (ret < 0) { 406 dev_err(tps->dev, "Failed to read revision register: %d\n", 407 ret); 408 return ret; 409 } 410 411 /* Set the PMIC to shutdown on PWR_EN toggle */ 412 if (status_off) { 413 ret = tps65217_set_bits(tps, TPS65217_REG_STATUS, 414 TPS65217_STATUS_OFF, TPS65217_STATUS_OFF, 415 TPS65217_PROTECT_NONE); 416 if (ret) 417 dev_warn(tps->dev, "unable to set the status OFF\n"); 418 } 419 420 dev_info(tps->dev, "TPS65217 ID %#x version 1.%d\n", 421 (version & TPS65217_CHIPID_CHIP_MASK) >> 4, 422 version & TPS65217_CHIPID_REV_MASK); 423 424 return 0; 425 } 426 427 static const struct i2c_device_id tps65217_id_table[] = { 428 {"tps65217", TPS65217}, 429 { /* sentinel */ } 430 }; 431 MODULE_DEVICE_TABLE(i2c, tps65217_id_table); 432 433 static struct i2c_driver tps65217_driver = { 434 .driver = { 435 .name = "tps65217", 436 .of_match_table = tps65217_of_match, 437 }, 438 .id_table = tps65217_id_table, 439 .probe = tps65217_probe, 440 }; 441 442 static int __init tps65217_init(void) 443 { 444 return i2c_add_driver(&tps65217_driver); 445 } 446 subsys_initcall(tps65217_init); 447 448 static void __exit tps65217_exit(void) 449 { 450 i2c_del_driver(&tps65217_driver); 451 } 452 module_exit(tps65217_exit); 453 454 MODULE_AUTHOR("AnilKumar Ch <anilkumar@ti.com>"); 455 MODULE_DESCRIPTION("TPS65217 chip family multi-function driver"); 456 MODULE_LICENSE("GPL v2"); 457