drivers/mfd/tps65217.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * tps65217.c
0004  *
0005  * TPS65217 chip family multi-function driver
0006  *
0007  * Copyright (C) 2011 Texas Instruments Incorporated - https://www.ti.com/
0008  */
0009
0010 #include <linux/device.h>
0011 #include <linux/err.h>
0012 #include <linux/init.h>
0013 #include <linux/interrupt.h>
0014 #include <linux/i2c.h>
0015 #include <linux/irq.h>
0016 #include <linux/irqdomain.h>
0017 #include <linux/kernel.h>
0018 #include <linux/module.h>
0019 #include <linux/of.h>
0020 #include <linux/of_device.h>
0021 #include <linux/platform_device.h>
0022 #include <linux/regmap.h>
0023 #include <linux/slab.h>
0024
0025 #include <linux/mfd/core.h>
0026 #include <linux/mfd/tps65217.h>
0027
0028 static const struct resource charger_resources[] = {
0029     DEFINE_RES_IRQ_NAMED(TPS65217_IRQ_AC, "AC"),
0030     DEFINE_RES_IRQ_NAMED(TPS65217_IRQ_USB, "USB"),
0031 };
0032
0033 static const struct resource pb_resources[] = {
0034     DEFINE_RES_IRQ_NAMED(TPS65217_IRQ_PB, "PB"),
0035 };
0036
0037 static void tps65217_irq_lock(struct irq_data *data)
0038 {
0039     struct tps65217 *tps = irq_data_get_irq_chip_data(data);
0040
0041     mutex_lock(&tps->irq_lock);
0042 }
0043
0044 static void tps65217_irq_sync_unlock(struct irq_data *data)
0045 {
0046     struct tps65217 *tps = irq_data_get_irq_chip_data(data);
0047     int ret;
0048
0049     ret = tps65217_set_bits(tps, TPS65217_REG_INT, TPS65217_INT_MASK,
0050                 tps->irq_mask, TPS65217_PROTECT_NONE);
0051     if (ret != 0)
0052         dev_err(tps->dev, "Failed to sync IRQ masks\n");
0053
0054     mutex_unlock(&tps->irq_lock);
0055 }
0056
0057 static void tps65217_irq_enable(struct irq_data *data)
0058 {
0059     struct tps65217 *tps = irq_data_get_irq_chip_data(data);
0060     u8 mask = BIT(data->hwirq) << TPS65217_INT_SHIFT;
0061
0062     tps->irq_mask &= ~mask;
0063 }
0064
0065 static void tps65217_irq_disable(struct irq_data *data)
0066 {
0067     struct tps65217 *tps = irq_data_get_irq_chip_data(data);
0068     u8 mask = BIT(data->hwirq) << TPS65217_INT_SHIFT;
0069
0070     tps->irq_mask |= mask;
0071 }
0072
0073 static struct irq_chip tps65217_irq_chip = {
0074     .name           = "tps65217",
0075     .irq_bus_lock       = tps65217_irq_lock,
0076     .irq_bus_sync_unlock    = tps65217_irq_sync_unlock,
0077     .irq_enable     = tps65217_irq_enable,
0078     .irq_disable        = tps65217_irq_disable,
0079 };
0080
0081 static struct mfd_cell tps65217s[] = {
0082     {
0083         .name = "tps65217-pmic",
0084         .of_compatible = "ti,tps65217-pmic",
0085     },
0086     {
0087         .name = "tps65217-bl",
0088         .of_compatible = "ti,tps65217-bl",
0089     },
0090     {
0091         .name = "tps65217-charger",
0092         .num_resources = ARRAY_SIZE(charger_resources),
0093         .resources = charger_resources,
0094         .of_compatible = "ti,tps65217-charger",
0095     },
0096     {
0097         .name = "tps65217-pwrbutton",
0098         .num_resources = ARRAY_SIZE(pb_resources),
0099         .resources = pb_resources,
0100         .of_compatible = "ti,tps65217-pwrbutton",
0101     },
0102 };
0103
0104 static irqreturn_t tps65217_irq_thread(int irq, void *data)
0105 {
0106     struct tps65217 *tps = data;
0107     unsigned int status;
0108     bool handled = false;
0109     int i;
0110     int ret;
0111
0112     ret = tps65217_reg_read(tps, TPS65217_REG_INT, &status);
0113     if (ret < 0) {
0114         dev_err(tps->dev, "Failed to read IRQ status: %d\n",
0115             ret);
0116         return IRQ_NONE;
0117     }
0118
0119     for (i = 0; i < TPS65217_NUM_IRQ; i++) {
0120         if (status & BIT(i)) {
0121             handle_nested_irq(irq_find_mapping(tps->irq_domain, i));
0122             handled = true;
0123         }
0124     }
0125
0126     if (handled)
0127         return IRQ_HANDLED;
0128
0129     return IRQ_NONE;
0130 }
0131
0132 static int tps65217_irq_map(struct irq_domain *h, unsigned int virq,
0133             irq_hw_number_t hw)
0134 {
0135     struct tps65217 *tps = h->host_data;
0136
0137     irq_set_chip_data(virq, tps);
0138     irq_set_chip_and_handler(virq, &tps65217_irq_chip, handle_edge_irq);
0139     irq_set_nested_thread(virq, 1);
0140     irq_set_parent(virq, tps->irq);
0141     irq_set_noprobe(virq);
0142
0143     return 0;
0144 }
0145
0146 static const struct irq_domain_ops tps65217_irq_domain_ops = {
0147     .map = tps65217_irq_map,
0148 };
0149
0150 static int tps65217_irq_init(struct tps65217 *tps, int irq)
0151 {
0152     int ret;
0153
0154     mutex_init(&tps->irq_lock);
0155     tps->irq = irq;
0156
0157     /* Mask all interrupt sources */
0158     tps->irq_mask = TPS65217_INT_MASK;
0159     tps65217_set_bits(tps, TPS65217_REG_INT, TPS65217_INT_MASK,
0160               TPS65217_INT_MASK, TPS65217_PROTECT_NONE);
0161
0162     tps->irq_domain = irq_domain_add_linear(tps->dev->of_node,
0163         TPS65217_NUM_IRQ, &tps65217_irq_domain_ops, tps);
0164     if (!tps->irq_domain) {
0165         dev_err(tps->dev, "Could not create IRQ domain\n");
0166         return -ENOMEM;
0167     }
0168
0169     ret = devm_request_threaded_irq(tps->dev, irq, NULL,
0170                     tps65217_irq_thread, IRQF_ONESHOT,
0171                     "tps65217-irq", tps);
0172     if (ret) {
0173         dev_err(tps->dev, "Failed to request IRQ %d: %d\n",
0174             irq, ret);
0175         return ret;
0176     }
0177
0178     enable_irq_wake(irq);
0179
0180     return 0;
0181 }
0182
0183 /**
0184  * tps65217_reg_read: Read a single tps65217 register.
0185  *
0186  * @tps: Device to read from.
0187  * @reg: Register to read.
0188  * @val: Contians the value
0189  */
0190 int tps65217_reg_read(struct tps65217 *tps, unsigned int reg,
0191             unsigned int *val)
0192 {
0193     return regmap_read(tps->regmap, reg, val);
0194 }
0195 EXPORT_SYMBOL_GPL(tps65217_reg_read);
0196
0197 /**
0198  * tps65217_reg_write: Write a single tps65217 register.
0199  *
0200  * @tps: Device to write to.
0201  * @reg: Register to write to.
0202  * @val: Value to write.
0203  * @level: Password protected level
0204  */
0205 int tps65217_reg_write(struct tps65217 *tps, unsigned int reg,
0206             unsigned int val, unsigned int level)
0207 {
0208     int ret;
0209     unsigned int xor_reg_val;
0210
0211     switch (level) {
0212     case TPS65217_PROTECT_NONE:
0213         return regmap_write(tps->regmap, reg, val);
0214     case TPS65217_PROTECT_L1:
0215         xor_reg_val = reg ^ TPS65217_PASSWORD_REGS_UNLOCK;
0216         ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD,
0217                             xor_reg_val);
0218         if (ret < 0)
0219             return ret;
0220
0221         return regmap_write(tps->regmap, reg, val);
0222     case TPS65217_PROTECT_L2:
0223         xor_reg_val = reg ^ TPS65217_PASSWORD_REGS_UNLOCK;
0224         ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD,
0225                             xor_reg_val);
0226         if (ret < 0)
0227             return ret;
0228         ret = regmap_write(tps->regmap, reg, val);
0229         if (ret < 0)
0230             return ret;
0231         ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD,
0232                             xor_reg_val);
0233         if (ret < 0)
0234             return ret;
0235         return regmap_write(tps->regmap, reg, val);
0236     default:
0237         return -EINVAL;
0238     }
0239 }
0240 EXPORT_SYMBOL_GPL(tps65217_reg_write);
0241
0242 /**
0243  * tps65217_update_bits: Modify bits w.r.t mask, val and level.
0244  *
0245  * @tps: Device to write to.
0246  * @reg: Register to read-write to.
0247  * @mask: Mask.
0248  * @val: Value to write.
0249  * @level: Password protected level
0250  */
0251 static int tps65217_update_bits(struct tps65217 *tps, unsigned int reg,
0252         unsigned int mask, unsigned int val, unsigned int level)
0253 {
0254     int ret;
0255     unsigned int data;
0256
0257     ret = tps65217_reg_read(tps, reg, &data);
0258     if (ret) {
0259         dev_err(tps->dev, "Read from reg 0x%x failed\n", reg);
0260         return ret;
0261     }
0262
0263     data &= ~mask;
0264     data |= val & mask;
0265
0266     ret = tps65217_reg_write(tps, reg, data, level);
0267     if (ret)
0268         dev_err(tps->dev, "Write for reg 0x%x failed\n", reg);
0269
0270     return ret;
0271 }
0272
0273 int tps65217_set_bits(struct tps65217 *tps, unsigned int reg,
0274         unsigned int mask, unsigned int val, unsigned int level)
0275 {
0276     return tps65217_update_bits(tps, reg, mask, val, level);
0277 }
0278 EXPORT_SYMBOL_GPL(tps65217_set_bits);
0279
0280 int tps65217_clear_bits(struct tps65217 *tps, unsigned int reg,
0281         unsigned int mask, unsigned int level)
0282 {
0283     return tps65217_update_bits(tps, reg, mask, 0, level);
0284 }
0285 EXPORT_SYMBOL_GPL(tps65217_clear_bits);
0286
0287 static bool tps65217_volatile_reg(struct device *dev, unsigned int reg)
0288 {
0289     switch (reg) {
0290     case TPS65217_REG_INT:
0291         return true;
0292     default:
0293         return false;
0294     }
0295 }
0296
0297 static const struct regmap_config tps65217_regmap_config = {
0298     .reg_bits = 8,
0299     .val_bits = 8,
0300
0301     .max_register = TPS65217_REG_MAX,
0302     .volatile_reg = tps65217_volatile_reg,
0303 };
0304
0305 static const struct of_device_id tps65217_of_match[] = {
0306     { .compatible = "ti,tps65217"},
0307     { /* sentinel */ },
0308 };
0309 MODULE_DEVICE_TABLE(of, tps65217_of_match);
0310
0311 static int tps65217_probe(struct i2c_client *client)
0312 {
0313     struct tps65217 *tps;
0314     unsigned int version;
0315     bool status_off = false;
0316     int ret;
0317
0318     status_off = of_property_read_bool(client->dev.of_node,
0319                        "ti,pmic-shutdown-controller");
0320
0321     tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
0322     if (!tps)
0323         return -ENOMEM;
0324
0325     i2c_set_clientdata(client, tps);
0326     tps->dev = &client->dev;
0327
0328     tps->regmap = devm_regmap_init_i2c(client, &tps65217_regmap_config);
0329     if (IS_ERR(tps->regmap)) {
0330         ret = PTR_ERR(tps->regmap);
0331         dev_err(tps->dev, "Failed to allocate register map: %d\n",
0332             ret);
0333         return ret;
0334     }
0335
0336     if (client->irq) {
0337         tps65217_irq_init(tps, client->irq);
0338     } else {
0339         int i;
0340
0341         /* Don't tell children about IRQ resources which won't fire */
0342         for (i = 0; i < ARRAY_SIZE(tps65217s); i++)
0343             tps65217s[i].num_resources = 0;
0344     }
0345
0346     ret = devm_mfd_add_devices(tps->dev, -1, tps65217s,
0347                    ARRAY_SIZE(tps65217s), NULL, 0,
0348                    tps->irq_domain);
0349     if (ret < 0) {
0350         dev_err(tps->dev, "mfd_add_devices failed: %d\n", ret);
0351         return ret;
0352     }
0353
0354     ret = tps65217_reg_read(tps, TPS65217_REG_CHIPID, &version);
0355     if (ret < 0) {
0356         dev_err(tps->dev, "Failed to read revision register: %d\n",
0357             ret);
0358         return ret;
0359     }
0360
0361     /* Set the PMIC to shutdown on PWR_EN toggle */
0362     if (status_off) {
0363         ret = tps65217_set_bits(tps, TPS65217_REG_STATUS,
0364                 TPS65217_STATUS_OFF, TPS65217_STATUS_OFF,
0365                 TPS65217_PROTECT_NONE);
0366         if (ret)
0367             dev_warn(tps->dev, "unable to set the status OFF\n");
0368     }
0369
0370     dev_info(tps->dev, "TPS65217 ID %#x version 1.%d\n",
0371             (version & TPS65217_CHIPID_CHIP_MASK) >> 4,
0372             version & TPS65217_CHIPID_REV_MASK);
0373
0374     return 0;
0375 }
0376
0377 static int tps65217_remove(struct i2c_client *client)
0378 {
0379     struct tps65217 *tps = i2c_get_clientdata(client);
0380     unsigned int virq;
0381     int i;
0382
0383     for (i = 0; i < TPS65217_NUM_IRQ; i++) {
0384         virq = irq_find_mapping(tps->irq_domain, i);
0385         if (virq)
0386             irq_dispose_mapping(virq);
0387     }
0388
0389     irq_domain_remove(tps->irq_domain);
0390     tps->irq_domain = NULL;
0391
0392     return 0;
0393 }
0394
0395 static const struct i2c_device_id tps65217_id_table[] = {
0396     {"tps65217", TPS65217},
0397     { /* sentinel */ }
0398 };
0399 MODULE_DEVICE_TABLE(i2c, tps65217_id_table);
0400
0401 static struct i2c_driver tps65217_driver = {
0402     .driver     = {
0403         .name   = "tps65217",
0404         .of_match_table = tps65217_of_match,
0405     },
0406     .id_table   = tps65217_id_table,
0407     .probe_new  = tps65217_probe,
0408     .remove     = tps65217_remove,
0409 };
0410
0411 static int __init tps65217_init(void)
0412 {
0413     return i2c_add_driver(&tps65217_driver);
0414 }
0415 subsys_initcall(tps65217_init);
0416
0417 static void __exit tps65217_exit(void)
0418 {
0419     i2c_del_driver(&tps65217_driver);
0420 }
0421 module_exit(tps65217_exit);
0422
0423 MODULE_AUTHOR("AnilKumar Ch <anilkumar@ti.com>");
0424 MODULE_DESCRIPTION("TPS65217 chip family multi-function driver");
0425 MODULE_LICENSE("GPL v2");