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