1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Regulator driver for tps6594 PMIC 4 // 5 // Copyright (C) 2023 BayLibre Incorporated - https://www.baylibre.com/ 6 7 #include <linux/device.h> 8 #include <linux/err.h> 9 #include <linux/init.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/platform_device.h> 14 #include <linux/regmap.h> 15 #include <linux/regulator/driver.h> 16 #include <linux/regulator/machine.h> 17 #include <linux/regulator/of_regulator.h> 18 19 #include <linux/mfd/tps6594.h> 20 21 #define BUCK_NB 5 22 #define LDO_NB 4 23 #define MULTI_PHASE_NB 4 24 #define REGS_INT_NB 4 25 26 enum tps6594_regulator_id { 27 /* DCDC's */ 28 TPS6594_BUCK_1, 29 TPS6594_BUCK_2, 30 TPS6594_BUCK_3, 31 TPS6594_BUCK_4, 32 TPS6594_BUCK_5, 33 34 /* LDOs */ 35 TPS6594_LDO_1, 36 TPS6594_LDO_2, 37 TPS6594_LDO_3, 38 TPS6594_LDO_4, 39 }; 40 41 enum tps6594_multi_regulator_id { 42 /* Multi-phase DCDC's */ 43 TPS6594_BUCK_12, 44 TPS6594_BUCK_34, 45 TPS6594_BUCK_123, 46 TPS6594_BUCK_1234, 47 }; 48 49 struct tps6594_regulator_irq_type { 50 const char *irq_name; 51 const char *regulator_name; 52 const char *event_name; 53 unsigned long event; 54 }; 55 56 static struct tps6594_regulator_irq_type tps6594_ext_regulator_irq_types[] = { 57 { TPS6594_IRQ_NAME_VCCA_OV, "VCCA", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 58 { TPS6594_IRQ_NAME_VCCA_UV, "VCCA", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 59 { TPS6594_IRQ_NAME_VMON1_OV, "VMON1", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 60 { TPS6594_IRQ_NAME_VMON1_UV, "VMON1", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 61 { TPS6594_IRQ_NAME_VMON1_RV, "VMON1", "residual voltage", 62 REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 63 { TPS6594_IRQ_NAME_VMON2_OV, "VMON2", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 64 { TPS6594_IRQ_NAME_VMON2_UV, "VMON2", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 65 { TPS6594_IRQ_NAME_VMON2_RV, "VMON2", "residual voltage", 66 REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 67 }; 68 69 struct tps6594_regulator_irq_data { 70 struct device *dev; 71 struct tps6594_regulator_irq_type *type; 72 struct regulator_dev *rdev; 73 }; 74 75 struct tps6594_ext_regulator_irq_data { 76 struct device *dev; 77 struct tps6594_regulator_irq_type *type; 78 }; 79 80 #define TPS6594_REGULATOR(_name, _of, _id, _type, _ops, _n, _vr, _vm, _er, \ 81 _em, _cr, _cm, _lr, _nlr, _delay, _fuv, \ 82 _ct, _ncl, _bpm) \ 83 { \ 84 .name = _name, \ 85 .of_match = _of, \ 86 .regulators_node = of_match_ptr("regulators"), \ 87 .supply_name = _of, \ 88 .id = _id, \ 89 .ops = &(_ops), \ 90 .n_voltages = _n, \ 91 .type = _type, \ 92 .owner = THIS_MODULE, \ 93 .vsel_reg = _vr, \ 94 .vsel_mask = _vm, \ 95 .csel_reg = _cr, \ 96 .csel_mask = _cm, \ 97 .curr_table = _ct, \ 98 .n_current_limits = _ncl, \ 99 .enable_reg = _er, \ 100 .enable_mask = _em, \ 101 .volt_table = NULL, \ 102 .linear_ranges = _lr, \ 103 .n_linear_ranges = _nlr, \ 104 .ramp_delay = _delay, \ 105 .fixed_uV = _fuv, \ 106 .bypass_reg = _vr, \ 107 .bypass_mask = _bpm, \ 108 } \ 109 110 static const struct linear_range bucks_ranges[] = { 111 REGULATOR_LINEAR_RANGE(300000, 0x0, 0xe, 20000), 112 REGULATOR_LINEAR_RANGE(600000, 0xf, 0x72, 5000), 113 REGULATOR_LINEAR_RANGE(1100000, 0x73, 0xaa, 10000), 114 REGULATOR_LINEAR_RANGE(1660000, 0xab, 0xff, 20000), 115 }; 116 117 static const struct linear_range ldos_1_2_3_ranges[] = { 118 REGULATOR_LINEAR_RANGE(600000, 0x4, 0x3a, 50000), 119 }; 120 121 static const struct linear_range ldos_4_ranges[] = { 122 REGULATOR_LINEAR_RANGE(1200000, 0x20, 0x74, 25000), 123 }; 124 125 /* Operations permitted on BUCK1/2/3/4/5 */ 126 static const struct regulator_ops tps6594_bucks_ops = { 127 .is_enabled = regulator_is_enabled_regmap, 128 .enable = regulator_enable_regmap, 129 .disable = regulator_disable_regmap, 130 .get_voltage_sel = regulator_get_voltage_sel_regmap, 131 .set_voltage_sel = regulator_set_voltage_sel_regmap, 132 .list_voltage = regulator_list_voltage_linear_range, 133 .map_voltage = regulator_map_voltage_linear_range, 134 .set_voltage_time_sel = regulator_set_voltage_time_sel, 135 136 }; 137 138 /* Operations permitted on LDO1/2/3 */ 139 static const struct regulator_ops tps6594_ldos_1_2_3_ops = { 140 .is_enabled = regulator_is_enabled_regmap, 141 .enable = regulator_enable_regmap, 142 .disable = regulator_disable_regmap, 143 .get_voltage_sel = regulator_get_voltage_sel_regmap, 144 .set_voltage_sel = regulator_set_voltage_sel_regmap, 145 .list_voltage = regulator_list_voltage_linear_range, 146 .map_voltage = regulator_map_voltage_linear_range, 147 .set_bypass = regulator_set_bypass_regmap, 148 .get_bypass = regulator_get_bypass_regmap, 149 }; 150 151 /* Operations permitted on LDO4 */ 152 static const struct regulator_ops tps6594_ldos_4_ops = { 153 .is_enabled = regulator_is_enabled_regmap, 154 .enable = regulator_enable_regmap, 155 .disable = regulator_disable_regmap, 156 .get_voltage_sel = regulator_get_voltage_sel_regmap, 157 .set_voltage_sel = regulator_set_voltage_sel_regmap, 158 .list_voltage = regulator_list_voltage_linear_range, 159 .map_voltage = regulator_map_voltage_linear_range, 160 }; 161 162 static const struct regulator_desc buck_regs[] = { 163 TPS6594_REGULATOR("BUCK1", "buck1", TPS6594_BUCK_1, 164 REGULATOR_VOLTAGE, tps6594_bucks_ops, TPS6594_MASK_BUCKS_VSET, 165 TPS6594_REG_BUCKX_VOUT_1(0), 166 TPS6594_MASK_BUCKS_VSET, 167 TPS6594_REG_BUCKX_CTRL(0), 168 TPS6594_BIT_BUCK_EN, 0, 0, bucks_ranges, 169 4, 0, 0, NULL, 0, 0), 170 TPS6594_REGULATOR("BUCK2", "buck2", TPS6594_BUCK_2, 171 REGULATOR_VOLTAGE, tps6594_bucks_ops, TPS6594_MASK_BUCKS_VSET, 172 TPS6594_REG_BUCKX_VOUT_1(1), 173 TPS6594_MASK_BUCKS_VSET, 174 TPS6594_REG_BUCKX_CTRL(1), 175 TPS6594_BIT_BUCK_EN, 0, 0, bucks_ranges, 176 4, 0, 0, NULL, 0, 0), 177 TPS6594_REGULATOR("BUCK3", "buck3", TPS6594_BUCK_3, 178 REGULATOR_VOLTAGE, tps6594_bucks_ops, TPS6594_MASK_BUCKS_VSET, 179 TPS6594_REG_BUCKX_VOUT_1(2), 180 TPS6594_MASK_BUCKS_VSET, 181 TPS6594_REG_BUCKX_CTRL(2), 182 TPS6594_BIT_BUCK_EN, 0, 0, bucks_ranges, 183 4, 0, 0, NULL, 0, 0), 184 TPS6594_REGULATOR("BUCK4", "buck4", TPS6594_BUCK_4, 185 REGULATOR_VOLTAGE, tps6594_bucks_ops, TPS6594_MASK_BUCKS_VSET, 186 TPS6594_REG_BUCKX_VOUT_1(3), 187 TPS6594_MASK_BUCKS_VSET, 188 TPS6594_REG_BUCKX_CTRL(3), 189 TPS6594_BIT_BUCK_EN, 0, 0, bucks_ranges, 190 4, 0, 0, NULL, 0, 0), 191 TPS6594_REGULATOR("BUCK5", "buck5", TPS6594_BUCK_5, 192 REGULATOR_VOLTAGE, tps6594_bucks_ops, TPS6594_MASK_BUCKS_VSET, 193 TPS6594_REG_BUCKX_VOUT_1(4), 194 TPS6594_MASK_BUCKS_VSET, 195 TPS6594_REG_BUCKX_CTRL(4), 196 TPS6594_BIT_BUCK_EN, 0, 0, bucks_ranges, 197 4, 0, 0, NULL, 0, 0), 198 }; 199 200 static struct tps6594_regulator_irq_type tps6594_buck1_irq_types[] = { 201 { TPS6594_IRQ_NAME_BUCK1_OV, "BUCK1", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 202 { TPS6594_IRQ_NAME_BUCK1_UV, "BUCK1", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 203 { TPS6594_IRQ_NAME_BUCK1_SC, "BUCK1", "short circuit", REGULATOR_EVENT_REGULATION_OUT }, 204 { TPS6594_IRQ_NAME_BUCK1_ILIM, "BUCK1", "reach ilim, overcurrent", 205 REGULATOR_EVENT_OVER_CURRENT }, 206 }; 207 208 static struct tps6594_regulator_irq_type tps6594_buck2_irq_types[] = { 209 { TPS6594_IRQ_NAME_BUCK2_OV, "BUCK2", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 210 { TPS6594_IRQ_NAME_BUCK2_UV, "BUCK2", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 211 { TPS6594_IRQ_NAME_BUCK2_SC, "BUCK2", "short circuit", REGULATOR_EVENT_REGULATION_OUT }, 212 { TPS6594_IRQ_NAME_BUCK2_ILIM, "BUCK2", "reach ilim, overcurrent", 213 REGULATOR_EVENT_OVER_CURRENT }, 214 }; 215 216 static struct tps6594_regulator_irq_type tps6594_buck3_irq_types[] = { 217 { TPS6594_IRQ_NAME_BUCK3_OV, "BUCK3", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 218 { TPS6594_IRQ_NAME_BUCK3_UV, "BUCK3", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 219 { TPS6594_IRQ_NAME_BUCK3_SC, "BUCK3", "short circuit", REGULATOR_EVENT_REGULATION_OUT }, 220 { TPS6594_IRQ_NAME_BUCK3_ILIM, "BUCK3", "reach ilim, overcurrent", 221 REGULATOR_EVENT_OVER_CURRENT }, 222 }; 223 224 static struct tps6594_regulator_irq_type tps6594_buck4_irq_types[] = { 225 { TPS6594_IRQ_NAME_BUCK4_OV, "BUCK4", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 226 { TPS6594_IRQ_NAME_BUCK4_UV, "BUCK4", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 227 { TPS6594_IRQ_NAME_BUCK4_SC, "BUCK4", "short circuit", REGULATOR_EVENT_REGULATION_OUT }, 228 { TPS6594_IRQ_NAME_BUCK4_ILIM, "BUCK4", "reach ilim, overcurrent", 229 REGULATOR_EVENT_OVER_CURRENT }, 230 }; 231 232 static struct tps6594_regulator_irq_type tps6594_buck5_irq_types[] = { 233 { TPS6594_IRQ_NAME_BUCK5_OV, "BUCK5", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 234 { TPS6594_IRQ_NAME_BUCK5_UV, "BUCK5", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 235 { TPS6594_IRQ_NAME_BUCK5_SC, "BUCK5", "short circuit", REGULATOR_EVENT_REGULATION_OUT }, 236 { TPS6594_IRQ_NAME_BUCK5_ILIM, "BUCK5", "reach ilim, overcurrent", 237 REGULATOR_EVENT_OVER_CURRENT }, 238 }; 239 240 static struct tps6594_regulator_irq_type tps6594_ldo1_irq_types[] = { 241 { TPS6594_IRQ_NAME_LDO1_OV, "LDO1", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 242 { TPS6594_IRQ_NAME_LDO1_UV, "LDO1", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 243 { TPS6594_IRQ_NAME_LDO1_SC, "LDO1", "short circuit", REGULATOR_EVENT_REGULATION_OUT }, 244 { TPS6594_IRQ_NAME_LDO1_ILIM, "LDO1", "reach ilim, overcurrent", 245 REGULATOR_EVENT_OVER_CURRENT }, 246 }; 247 248 static struct tps6594_regulator_irq_type tps6594_ldo2_irq_types[] = { 249 { TPS6594_IRQ_NAME_LDO2_OV, "LDO2", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 250 { TPS6594_IRQ_NAME_LDO2_UV, "LDO2", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 251 { TPS6594_IRQ_NAME_LDO2_SC, "LDO2", "short circuit", REGULATOR_EVENT_REGULATION_OUT }, 252 { TPS6594_IRQ_NAME_LDO2_ILIM, "LDO2", "reach ilim, overcurrent", 253 REGULATOR_EVENT_OVER_CURRENT }, 254 }; 255 256 static struct tps6594_regulator_irq_type tps6594_ldo3_irq_types[] = { 257 { TPS6594_IRQ_NAME_LDO3_OV, "LDO3", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 258 { TPS6594_IRQ_NAME_LDO3_UV, "LDO3", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 259 { TPS6594_IRQ_NAME_LDO3_SC, "LDO3", "short circuit", REGULATOR_EVENT_REGULATION_OUT }, 260 { TPS6594_IRQ_NAME_LDO3_ILIM, "LDO3", "reach ilim, overcurrent", 261 REGULATOR_EVENT_OVER_CURRENT }, 262 }; 263 264 static struct tps6594_regulator_irq_type tps6594_ldo4_irq_types[] = { 265 { TPS6594_IRQ_NAME_LDO4_OV, "LDO4", "overvoltage", REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 266 { TPS6594_IRQ_NAME_LDO4_UV, "LDO4", "undervoltage", REGULATOR_EVENT_UNDER_VOLTAGE }, 267 { TPS6594_IRQ_NAME_LDO4_SC, "LDO4", "short circuit", REGULATOR_EVENT_REGULATION_OUT }, 268 { TPS6594_IRQ_NAME_LDO4_ILIM, "LDO4", "reach ilim, overcurrent", 269 REGULATOR_EVENT_OVER_CURRENT }, 270 }; 271 272 static struct tps6594_regulator_irq_type *tps6594_bucks_irq_types[] = { 273 tps6594_buck1_irq_types, 274 tps6594_buck2_irq_types, 275 tps6594_buck3_irq_types, 276 tps6594_buck4_irq_types, 277 tps6594_buck5_irq_types, 278 }; 279 280 static struct tps6594_regulator_irq_type *tps6594_ldos_irq_types[] = { 281 tps6594_ldo1_irq_types, 282 tps6594_ldo2_irq_types, 283 tps6594_ldo3_irq_types, 284 tps6594_ldo4_irq_types, 285 }; 286 287 static const struct regulator_desc multi_regs[] = { 288 TPS6594_REGULATOR("BUCK12", "buck12", TPS6594_BUCK_1, 289 REGULATOR_VOLTAGE, tps6594_bucks_ops, TPS6594_MASK_BUCKS_VSET, 290 TPS6594_REG_BUCKX_VOUT_1(1), 291 TPS6594_MASK_BUCKS_VSET, 292 TPS6594_REG_BUCKX_CTRL(1), 293 TPS6594_BIT_BUCK_EN, 0, 0, bucks_ranges, 294 4, 4000, 0, NULL, 0, 0), 295 TPS6594_REGULATOR("BUCK34", "buck34", TPS6594_BUCK_3, 296 REGULATOR_VOLTAGE, tps6594_bucks_ops, TPS6594_MASK_BUCKS_VSET, 297 TPS6594_REG_BUCKX_VOUT_1(3), 298 TPS6594_MASK_BUCKS_VSET, 299 TPS6594_REG_BUCKX_CTRL(3), 300 TPS6594_BIT_BUCK_EN, 0, 0, bucks_ranges, 301 4, 0, 0, NULL, 0, 0), 302 TPS6594_REGULATOR("BUCK123", "buck123", TPS6594_BUCK_1, 303 REGULATOR_VOLTAGE, tps6594_bucks_ops, TPS6594_MASK_BUCKS_VSET, 304 TPS6594_REG_BUCKX_VOUT_1(1), 305 TPS6594_MASK_BUCKS_VSET, 306 TPS6594_REG_BUCKX_CTRL(1), 307 TPS6594_BIT_BUCK_EN, 0, 0, bucks_ranges, 308 4, 4000, 0, NULL, 0, 0), 309 TPS6594_REGULATOR("BUCK1234", "buck1234", TPS6594_BUCK_1, 310 REGULATOR_VOLTAGE, tps6594_bucks_ops, TPS6594_MASK_BUCKS_VSET, 311 TPS6594_REG_BUCKX_VOUT_1(1), 312 TPS6594_MASK_BUCKS_VSET, 313 TPS6594_REG_BUCKX_CTRL(1), 314 TPS6594_BIT_BUCK_EN, 0, 0, bucks_ranges, 315 4, 4000, 0, NULL, 0, 0), 316 }; 317 318 static const struct regulator_desc ldo_regs[] = { 319 TPS6594_REGULATOR("LDO1", "ldo1", TPS6594_LDO_1, 320 REGULATOR_VOLTAGE, tps6594_ldos_1_2_3_ops, TPS6594_MASK_LDO123_VSET, 321 TPS6594_REG_LDOX_VOUT(0), 322 TPS6594_MASK_LDO123_VSET, 323 TPS6594_REG_LDOX_CTRL(0), 324 TPS6594_BIT_LDO_EN, 0, 0, ldos_1_2_3_ranges, 325 1, 0, 0, NULL, 0, TPS6594_BIT_LDO_BYPASS), 326 TPS6594_REGULATOR("LDO2", "ldo2", TPS6594_LDO_2, 327 REGULATOR_VOLTAGE, tps6594_ldos_1_2_3_ops, TPS6594_MASK_LDO123_VSET, 328 TPS6594_REG_LDOX_VOUT(1), 329 TPS6594_MASK_LDO123_VSET, 330 TPS6594_REG_LDOX_CTRL(1), 331 TPS6594_BIT_LDO_EN, 0, 0, ldos_1_2_3_ranges, 332 1, 0, 0, NULL, 0, TPS6594_BIT_LDO_BYPASS), 333 TPS6594_REGULATOR("LDO3", "ldo3", TPS6594_LDO_3, 334 REGULATOR_VOLTAGE, tps6594_ldos_1_2_3_ops, TPS6594_MASK_LDO123_VSET, 335 TPS6594_REG_LDOX_VOUT(2), 336 TPS6594_MASK_LDO123_VSET, 337 TPS6594_REG_LDOX_CTRL(2), 338 TPS6594_BIT_LDO_EN, 0, 0, ldos_1_2_3_ranges, 339 1, 0, 0, NULL, 0, TPS6594_BIT_LDO_BYPASS), 340 TPS6594_REGULATOR("LDO4", "ldo4", TPS6594_LDO_4, 341 REGULATOR_VOLTAGE, tps6594_ldos_4_ops, TPS6594_MASK_LDO4_VSET >> 1, 342 TPS6594_REG_LDOX_VOUT(3), 343 TPS6594_MASK_LDO4_VSET, 344 TPS6594_REG_LDOX_CTRL(3), 345 TPS6594_BIT_LDO_EN, 0, 0, ldos_4_ranges, 346 1, 0, 0, NULL, 0, 0), 347 }; 348 349 static irqreturn_t tps6594_regulator_irq_handler(int irq, void *data) 350 { 351 struct tps6594_regulator_irq_data *irq_data = data; 352 353 if (irq_data->type->event_name[0] == '\0') { 354 /* This is the timeout interrupt no specific regulator */ 355 dev_err(irq_data->dev, 356 "System was put in shutdown due to timeout during an active or standby transition.\n"); 357 return IRQ_HANDLED; 358 } 359 360 dev_err(irq_data->dev, "Error IRQ trap %s for %s\n", 361 irq_data->type->event_name, irq_data->type->regulator_name); 362 363 regulator_notifier_call_chain(irq_data->rdev, 364 irq_data->type->event, NULL); 365 366 return IRQ_HANDLED; 367 } 368 369 static int tps6594_request_reg_irqs(struct platform_device *pdev, 370 struct regulator_dev *rdev, 371 struct tps6594_regulator_irq_data *irq_data, 372 struct tps6594_regulator_irq_type *tps6594_regs_irq_types, 373 int *irq_idx) 374 { 375 struct tps6594_regulator_irq_type *irq_type; 376 struct tps6594 *tps = dev_get_drvdata(pdev->dev.parent); 377 int j; 378 int irq; 379 int error; 380 381 for (j = 0; j < REGS_INT_NB; j++) { 382 irq_type = &tps6594_regs_irq_types[j]; 383 irq = platform_get_irq_byname(pdev, irq_type->irq_name); 384 if (irq < 0) 385 return -EINVAL; 386 387 irq_data[*irq_idx].dev = tps->dev; 388 irq_data[*irq_idx].type = irq_type; 389 irq_data[*irq_idx].rdev = rdev; 390 391 error = devm_request_threaded_irq(tps->dev, irq, NULL, 392 tps6594_regulator_irq_handler, IRQF_ONESHOT, 393 irq_type->irq_name, &irq_data[*irq_idx]); 394 if (error) { 395 dev_err(tps->dev, "tps6594 failed to request %s IRQ %d: %d\n", 396 irq_type->irq_name, irq, error); 397 return error; 398 } 399 (*irq_idx)++; 400 } 401 return 0; 402 } 403 404 static int tps6594_regulator_probe(struct platform_device *pdev) 405 { 406 struct tps6594 *tps = dev_get_drvdata(pdev->dev.parent); 407 struct regulator_dev *rdev; 408 struct device_node *np = NULL; 409 struct device_node *np_pmic_parent = NULL; 410 struct regulator_config config = {}; 411 struct tps6594_regulator_irq_data *irq_data; 412 struct tps6594_ext_regulator_irq_data *irq_ext_reg_data; 413 struct tps6594_regulator_irq_type *irq_type; 414 u8 buck_configured[BUCK_NB] = { 0 }; 415 u8 buck_multi[MULTI_PHASE_NB] = { 0 }; 416 static const char * const multiphases[] = {"buck12", "buck123", "buck1234", "buck34"}; 417 static const char *npname; 418 int error, i, irq, multi, delta; 419 int irq_idx = 0; 420 int buck_idx = 0; 421 size_t ext_reg_irq_nb = 2; 422 size_t reg_irq_nb; 423 enum { 424 MULTI_BUCK12, 425 MULTI_BUCK123, 426 MULTI_BUCK1234, 427 MULTI_BUCK12_34, 428 MULTI_FIRST = MULTI_BUCK12, 429 MULTI_LAST = MULTI_BUCK12_34, 430 MULTI_NUM = MULTI_LAST - MULTI_FIRST + 1 431 }; 432 433 config.dev = tps->dev; 434 config.driver_data = tps; 435 config.regmap = tps->regmap; 436 437 /* 438 * Switch case defines different possible multi phase config 439 * This is based on dts buck node name. 440 * Buck node name must be chosen accordingly. 441 * Default case is no Multiphase buck. 442 * In case of Multiphase configuration, value should be defined for 443 * buck_configured to avoid creating bucks for every buck in multiphase 444 */ 445 for (multi = MULTI_FIRST; multi < MULTI_NUM; multi++) { 446 np = of_find_node_by_name(tps->dev->of_node, multiphases[multi]); 447 npname = of_node_full_name(np); 448 np_pmic_parent = of_get_parent(of_get_parent(np)); 449 if (of_node_cmp(of_node_full_name(np_pmic_parent), tps->dev->of_node->full_name)) 450 continue; 451 delta = strcmp(npname, multiphases[multi]); 452 if (!delta) { 453 switch (multi) { 454 case MULTI_BUCK12: 455 buck_multi[0] = 1; 456 buck_configured[0] = 1; 457 buck_configured[1] = 1; 458 break; 459 /* multiphase buck34 is supported only with buck12 */ 460 case MULTI_BUCK12_34: 461 buck_multi[0] = 1; 462 buck_multi[1] = 1; 463 buck_configured[0] = 1; 464 buck_configured[1] = 1; 465 buck_configured[2] = 1; 466 buck_configured[3] = 1; 467 break; 468 case MULTI_BUCK123: 469 buck_multi[2] = 1; 470 buck_configured[0] = 1; 471 buck_configured[1] = 1; 472 buck_configured[2] = 1; 473 break; 474 case MULTI_BUCK1234: 475 buck_multi[3] = 1; 476 buck_configured[0] = 1; 477 buck_configured[1] = 1; 478 buck_configured[2] = 1; 479 buck_configured[3] = 1; 480 break; 481 } 482 } 483 } 484 485 if (tps->chip_id == LP8764) { 486 /* There is only 4 buck on LP8764 */ 487 buck_configured[4] = 1; 488 reg_irq_nb = size_mul(REGS_INT_NB, (BUCK_NB - 1)); 489 } else { 490 reg_irq_nb = size_mul(REGS_INT_NB, (size_add(BUCK_NB, LDO_NB))); 491 } 492 493 irq_data = devm_kmalloc_array(tps->dev, reg_irq_nb, 494 sizeof(struct tps6594_regulator_irq_data), GFP_KERNEL); 495 if (!irq_data) 496 return -ENOMEM; 497 498 for (i = 0; i < MULTI_PHASE_NB; i++) { 499 if (buck_multi[i] == 0) 500 continue; 501 502 rdev = devm_regulator_register(&pdev->dev, &multi_regs[i], &config); 503 if (IS_ERR(rdev)) 504 return dev_err_probe(tps->dev, PTR_ERR(rdev), 505 "failed to register %s regulator\n", 506 pdev->name); 507 508 /* config multiphase buck12+buck34 */ 509 if (i == 1) 510 buck_idx = 2; 511 error = tps6594_request_reg_irqs(pdev, rdev, irq_data, 512 tps6594_bucks_irq_types[buck_idx], &irq_idx); 513 if (error) 514 return error; 515 error = tps6594_request_reg_irqs(pdev, rdev, irq_data, 516 tps6594_bucks_irq_types[buck_idx + 1], &irq_idx); 517 if (error) 518 return error; 519 520 if (i == 2 || i == 3) { 521 error = tps6594_request_reg_irqs(pdev, rdev, irq_data, 522 tps6594_bucks_irq_types[buck_idx + 2], 523 &irq_idx); 524 if (error) 525 return error; 526 } 527 if (i == 3) { 528 error = tps6594_request_reg_irqs(pdev, rdev, irq_data, 529 tps6594_bucks_irq_types[buck_idx + 3], 530 &irq_idx); 531 if (error) 532 return error; 533 } 534 } 535 536 for (i = 0; i < BUCK_NB; i++) { 537 if (buck_configured[i] == 1) 538 continue; 539 540 rdev = devm_regulator_register(&pdev->dev, &buck_regs[i], &config); 541 if (IS_ERR(rdev)) 542 return dev_err_probe(tps->dev, PTR_ERR(rdev), 543 "failed to register %s regulator\n", 544 pdev->name); 545 546 error = tps6594_request_reg_irqs(pdev, rdev, irq_data, 547 tps6594_bucks_irq_types[i], &irq_idx); 548 if (error) 549 return error; 550 } 551 552 /* LP8764 dosen't have LDO */ 553 if (tps->chip_id != LP8764) { 554 for (i = 0; i < ARRAY_SIZE(ldo_regs); i++) { 555 rdev = devm_regulator_register(&pdev->dev, &ldo_regs[i], &config); 556 if (IS_ERR(rdev)) 557 return dev_err_probe(tps->dev, PTR_ERR(rdev), 558 "failed to register %s regulator\n", 559 pdev->name); 560 561 error = tps6594_request_reg_irqs(pdev, rdev, irq_data, 562 tps6594_ldos_irq_types[i], 563 &irq_idx); 564 if (error) 565 return error; 566 } 567 } 568 569 if (tps->chip_id == LP8764) 570 ext_reg_irq_nb = ARRAY_SIZE(tps6594_ext_regulator_irq_types); 571 572 irq_ext_reg_data = devm_kmalloc_array(tps->dev, 573 ext_reg_irq_nb, 574 sizeof(struct tps6594_ext_regulator_irq_data), 575 GFP_KERNEL); 576 if (!irq_ext_reg_data) 577 return -ENOMEM; 578 579 for (i = 0; i < ext_reg_irq_nb; ++i) { 580 irq_type = &tps6594_ext_regulator_irq_types[i]; 581 582 irq = platform_get_irq_byname(pdev, irq_type->irq_name); 583 if (irq < 0) 584 return -EINVAL; 585 586 irq_ext_reg_data[i].dev = tps->dev; 587 irq_ext_reg_data[i].type = irq_type; 588 589 error = devm_request_threaded_irq(tps->dev, irq, NULL, 590 tps6594_regulator_irq_handler, 591 IRQF_ONESHOT, 592 irq_type->irq_name, 593 &irq_ext_reg_data[i]); 594 if (error) 595 return dev_err_probe(tps->dev, error, 596 "failed to request %s IRQ %d\n", 597 irq_type->irq_name, irq); 598 } 599 return 0; 600 } 601 602 static struct platform_driver tps6594_regulator_driver = { 603 .driver = { 604 .name = "tps6594-regulator", 605 }, 606 .probe = tps6594_regulator_probe, 607 }; 608 609 module_platform_driver(tps6594_regulator_driver); 610 611 MODULE_ALIAS("platform:tps6594-regulator"); 612 MODULE_AUTHOR("Jerome Neanne <jneanne@baylibre.com>"); 613 MODULE_DESCRIPTION("TPS6594 voltage regulator driver"); 614 MODULE_LICENSE("GPL"); 615