1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Core driver for TI TPS65090 PMIC family 4 * 5 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved. 6 * 7 * Author: Venu Byravarasu <vbyravarasu@nvidia.com> 8 */ 9 10 #include <linux/interrupt.h> 11 #include <linux/irq.h> 12 #include <linux/kernel.h> 13 #include <linux/init.h> 14 #include <linux/mutex.h> 15 #include <linux/slab.h> 16 #include <linux/i2c.h> 17 #include <linux/mfd/core.h> 18 #include <linux/mfd/tps65090.h> 19 #include <linux/of.h> 20 #include <linux/err.h> 21 22 #define NUM_INT_REG 2 23 24 #define TPS65090_INT1_MASK_VAC_STATUS_CHANGE 1 25 #define TPS65090_INT1_MASK_VSYS_STATUS_CHANGE 2 26 #define TPS65090_INT1_MASK_BAT_STATUS_CHANGE 3 27 #define TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE 4 28 #define TPS65090_INT1_MASK_CHARGING_COMPLETE 5 29 #define TPS65090_INT1_MASK_OVERLOAD_DCDC1 6 30 #define TPS65090_INT1_MASK_OVERLOAD_DCDC2 7 31 #define TPS65090_INT2_MASK_OVERLOAD_DCDC3 0 32 #define TPS65090_INT2_MASK_OVERLOAD_FET1 1 33 #define TPS65090_INT2_MASK_OVERLOAD_FET2 2 34 #define TPS65090_INT2_MASK_OVERLOAD_FET3 3 35 #define TPS65090_INT2_MASK_OVERLOAD_FET4 4 36 #define TPS65090_INT2_MASK_OVERLOAD_FET5 5 37 #define TPS65090_INT2_MASK_OVERLOAD_FET6 6 38 #define TPS65090_INT2_MASK_OVERLOAD_FET7 7 39 40 static const struct resource charger_resources[] = { 41 { 42 .start = TPS65090_IRQ_VAC_STATUS_CHANGE, 43 .end = TPS65090_IRQ_VAC_STATUS_CHANGE, 44 .flags = IORESOURCE_IRQ, 45 } 46 }; 47 48 enum tps65090_cells { 49 PMIC = 0, 50 CHARGER = 1, 51 }; 52 53 static struct mfd_cell tps65090s[] = { 54 [PMIC] = { 55 .name = "tps65090-pmic", 56 }, 57 [CHARGER] = { 58 .name = "tps65090-charger", 59 .num_resources = ARRAY_SIZE(charger_resources), 60 .resources = &charger_resources[0], 61 .of_compatible = "ti,tps65090-charger", 62 }, 63 }; 64 65 static const struct regmap_irq tps65090_irqs[] = { 66 /* INT1 IRQs*/ 67 [TPS65090_IRQ_VAC_STATUS_CHANGE] = { 68 .mask = TPS65090_INT1_MASK_VAC_STATUS_CHANGE, 69 }, 70 [TPS65090_IRQ_VSYS_STATUS_CHANGE] = { 71 .mask = TPS65090_INT1_MASK_VSYS_STATUS_CHANGE, 72 }, 73 [TPS65090_IRQ_BAT_STATUS_CHANGE] = { 74 .mask = TPS65090_INT1_MASK_BAT_STATUS_CHANGE, 75 }, 76 [TPS65090_IRQ_CHARGING_STATUS_CHANGE] = { 77 .mask = TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE, 78 }, 79 [TPS65090_IRQ_CHARGING_COMPLETE] = { 80 .mask = TPS65090_INT1_MASK_CHARGING_COMPLETE, 81 }, 82 [TPS65090_IRQ_OVERLOAD_DCDC1] = { 83 .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC1, 84 }, 85 [TPS65090_IRQ_OVERLOAD_DCDC2] = { 86 .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC2, 87 }, 88 /* INT2 IRQs*/ 89 [TPS65090_IRQ_OVERLOAD_DCDC3] = { 90 .reg_offset = 1, 91 .mask = TPS65090_INT2_MASK_OVERLOAD_DCDC3, 92 }, 93 [TPS65090_IRQ_OVERLOAD_FET1] = { 94 .reg_offset = 1, 95 .mask = TPS65090_INT2_MASK_OVERLOAD_FET1, 96 }, 97 [TPS65090_IRQ_OVERLOAD_FET2] = { 98 .reg_offset = 1, 99 .mask = TPS65090_INT2_MASK_OVERLOAD_FET2, 100 }, 101 [TPS65090_IRQ_OVERLOAD_FET3] = { 102 .reg_offset = 1, 103 .mask = TPS65090_INT2_MASK_OVERLOAD_FET3, 104 }, 105 [TPS65090_IRQ_OVERLOAD_FET4] = { 106 .reg_offset = 1, 107 .mask = TPS65090_INT2_MASK_OVERLOAD_FET4, 108 }, 109 [TPS65090_IRQ_OVERLOAD_FET5] = { 110 .reg_offset = 1, 111 .mask = TPS65090_INT2_MASK_OVERLOAD_FET5, 112 }, 113 [TPS65090_IRQ_OVERLOAD_FET6] = { 114 .reg_offset = 1, 115 .mask = TPS65090_INT2_MASK_OVERLOAD_FET6, 116 }, 117 [TPS65090_IRQ_OVERLOAD_FET7] = { 118 .reg_offset = 1, 119 .mask = TPS65090_INT2_MASK_OVERLOAD_FET7, 120 }, 121 }; 122 123 static struct regmap_irq_chip tps65090_irq_chip = { 124 .name = "tps65090", 125 .irqs = tps65090_irqs, 126 .num_irqs = ARRAY_SIZE(tps65090_irqs), 127 .num_regs = NUM_INT_REG, 128 .status_base = TPS65090_REG_INTR_STS, 129 .unmask_base = TPS65090_REG_INTR_MASK, 130 }; 131 132 static bool is_volatile_reg(struct device *dev, unsigned int reg) 133 { 134 /* Nearly all registers have status bits mixed in, except a few */ 135 switch (reg) { 136 case TPS65090_REG_INTR_MASK: 137 case TPS65090_REG_INTR_MASK2: 138 case TPS65090_REG_CG_CTRL0: 139 case TPS65090_REG_CG_CTRL1: 140 case TPS65090_REG_CG_CTRL2: 141 case TPS65090_REG_CG_CTRL3: 142 case TPS65090_REG_CG_CTRL4: 143 case TPS65090_REG_CG_CTRL5: 144 return false; 145 } 146 return true; 147 } 148 149 static const struct regmap_config tps65090_regmap_config = { 150 .reg_bits = 8, 151 .val_bits = 8, 152 .max_register = TPS65090_MAX_REG, 153 .num_reg_defaults_raw = TPS65090_NUM_REGS, 154 .cache_type = REGCACHE_MAPLE, 155 .volatile_reg = is_volatile_reg, 156 }; 157 158 #ifdef CONFIG_OF 159 static const struct of_device_id tps65090_of_match[] = { 160 { .compatible = "ti,tps65090",}, 161 {}, 162 }; 163 #endif 164 165 static int tps65090_i2c_probe(struct i2c_client *client) 166 { 167 struct tps65090_platform_data *pdata = dev_get_platdata(&client->dev); 168 int irq_base = 0; 169 struct tps65090 *tps65090; 170 int ret; 171 172 if (!pdata && !client->dev.of_node) { 173 dev_err(&client->dev, 174 "tps65090 requires platform data or of_node\n"); 175 return -EINVAL; 176 } 177 178 if (pdata) 179 irq_base = pdata->irq_base; 180 181 tps65090 = devm_kzalloc(&client->dev, sizeof(*tps65090), GFP_KERNEL); 182 if (!tps65090) 183 return -ENOMEM; 184 185 tps65090->dev = &client->dev; 186 i2c_set_clientdata(client, tps65090); 187 188 tps65090->rmap = devm_regmap_init_i2c(client, &tps65090_regmap_config); 189 if (IS_ERR(tps65090->rmap)) { 190 ret = PTR_ERR(tps65090->rmap); 191 dev_err(&client->dev, "regmap_init failed with err: %d\n", ret); 192 return ret; 193 } 194 195 if (client->irq) { 196 ret = regmap_add_irq_chip(tps65090->rmap, client->irq, 197 IRQF_ONESHOT | IRQF_TRIGGER_LOW, irq_base, 198 &tps65090_irq_chip, &tps65090->irq_data); 199 if (ret) { 200 dev_err(&client->dev, 201 "IRQ init failed with err: %d\n", ret); 202 return ret; 203 } 204 } else { 205 /* Don't tell children they have an IRQ that'll never fire */ 206 tps65090s[CHARGER].num_resources = 0; 207 } 208 209 ret = mfd_add_devices(tps65090->dev, -1, tps65090s, 210 ARRAY_SIZE(tps65090s), NULL, 211 0, regmap_irq_get_domain(tps65090->irq_data)); 212 if (ret) { 213 dev_err(&client->dev, "add mfd devices failed with err: %d\n", 214 ret); 215 goto err_irq_exit; 216 } 217 218 return 0; 219 220 err_irq_exit: 221 if (client->irq) 222 regmap_del_irq_chip(client->irq, tps65090->irq_data); 223 return ret; 224 } 225 226 227 static const struct i2c_device_id tps65090_id_table[] = { 228 { "tps65090", 0 }, 229 { }, 230 }; 231 232 static struct i2c_driver tps65090_driver = { 233 .driver = { 234 .name = "tps65090", 235 .suppress_bind_attrs = true, 236 .of_match_table = of_match_ptr(tps65090_of_match), 237 }, 238 .probe = tps65090_i2c_probe, 239 .id_table = tps65090_id_table, 240 }; 241 242 static int __init tps65090_init(void) 243 { 244 return i2c_add_driver(&tps65090_driver); 245 } 246 subsys_initcall(tps65090_init); 247