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