drivers/mfd/tps65217.c

   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
  27 static 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
  32 static const struct resource pb_resources[] = {
  33         DEFINE_RES_IRQ_NAMED(TPS65217_IRQ_PB, "PB"),
  34 };
  35
  36 static 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
  43 static 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
  56 static 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
  64 static 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
  72 static 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
  80 static 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
 103 static 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
 131 static 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
 145 static const struct irq_domain_ops tps65217_irq_domain_ops = {
 146         .map = tps65217_irq_map,
 147 };
 148
 149 static 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  */
 189 int tps65217_reg_read(struct tps65217 *tps, unsigned int reg,
 190                         unsigned int *val)
 191 {
 192         return regmap_read(tps->regmap, reg, val);
 193 }
 194 EXPORT_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  */
 204 int 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 }
 239 EXPORT_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  */
 250 static 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
 272 int 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 }
 277 EXPORT_SYMBOL_GPL(tps65217_set_bits);
 278
 279 int 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 }
 284 EXPORT_SYMBOL_GPL(tps65217_clear_bits);
 285
 286 static 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
 296 static 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
 304 static const struct of_device_id tps65217_of_match[] = {
 305         { .compatible = "ti,tps65217"},
 306         { /* sentinel */ },
 307 };
 308 MODULE_DEVICE_TABLE(of, tps65217_of_match);
 309
 310 static 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
 376 static 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
 392 static const struct i2c_device_id tps65217_id_table[] = {
 393         {"tps65217", TPS65217},
 394         { /* sentinel */ }
 395 };
 396 MODULE_DEVICE_TABLE(i2c, tps65217_id_table);
 397
 398 static 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
 408 static int __init tps65217_init(void)
 409 {
 410         return i2c_add_driver(&tps65217_driver);
 411 }
 412 subsys_initcall(tps65217_init);
 413
 414 static void __exit tps65217_exit(void)
 415 {
 416         i2c_del_driver(&tps65217_driver);
 417 }
 418 module_exit(tps65217_exit);
 419
 420 MODULE_AUTHOR("AnilKumar Ch <[email protected]>");
 421 MODULE_DESCRIPTION("TPS65217 chip family multi-function driver");
 422 MODULE_LICENSE("GPL v2");