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