1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Copyright (c) 2024 MediaTek Inc. 4 // Copyright (c) 2025 Collabora Ltd 5 // AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com> 6 7 #include <linux/delay.h> 8 #include <linux/devm-helpers.h> 9 #include <linux/err.h> 10 #include <linux/interrupt.h> 11 #include <linux/irq.h> 12 #include <linux/irqdomain.h> 13 #include <linux/kernel.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/of_device.h> 17 #include <linux/of_irq.h> 18 #include <linux/platform_device.h> 19 #include <linux/regmap.h> 20 #include <linux/spmi.h> 21 22 #include <linux/regulator/driver.h> 23 #include <linux/regulator/machine.h> 24 #include <linux/regulator/mt6363-regulator.h> 25 #include <linux/regulator/of_regulator.h> 26 27 #define MT6363_REGULATOR_MODE_NORMAL 0 28 #define MT6363_REGULATOR_MODE_FCCM 1 29 #define MT6363_REGULATOR_MODE_LP 2 30 #define MT6363_REGULATOR_MODE_ULP 3 31 32 #define EN_SET_OFFSET 0x1 33 #define EN_CLR_OFFSET 0x2 34 #define OP_CFG_OFFSET 0x5 35 36 #define NORMAL_OP_CFG 0x10 37 #define NORMAL_OP_EN 0x800000 38 39 #define OC_IRQ_ENABLE_DELAY_MS 10 40 41 /* Unlock keys for TMA and BUCK_TOP */ 42 #define MT6363_TMA_UNLOCK_VALUE 0x9c9c 43 #define MT6363_BUCK_TOP_UNLOCK_VALUE 0x5543 44 45 enum { 46 MT6363_ID_VBUCK1, 47 MT6363_ID_VBUCK2, 48 MT6363_ID_VBUCK3, 49 MT6363_ID_VBUCK4, 50 MT6363_ID_VBUCK5, 51 MT6363_ID_VBUCK6, 52 MT6363_ID_VBUCK7, 53 MT6363_ID_VS1, 54 MT6363_ID_VS2, 55 MT6363_ID_VS3, 56 MT6363_ID_VA12_1, 57 MT6363_ID_VA12_2, 58 MT6363_ID_VA15, 59 MT6363_ID_VAUX18, 60 MT6363_ID_VCN13, 61 MT6363_ID_VCN15, 62 MT6363_ID_VEMC, 63 MT6363_ID_VIO075, 64 MT6363_ID_VIO18, 65 MT6363_ID_VM18, 66 MT6363_ID_VSRAM_APU, 67 MT6363_ID_VSRAM_CPUB, 68 MT6363_ID_VSRAM_CPUM, 69 MT6363_ID_VSRAM_CPUL, 70 MT6363_ID_VSRAM_DIGRF, 71 MT6363_ID_VSRAM_MDFE, 72 MT6363_ID_VSRAM_MODEM, 73 MT6363_ID_VRF09, 74 MT6363_ID_VRF12, 75 MT6363_ID_VRF13, 76 MT6363_ID_VRF18, 77 MT6363_ID_VRFIO18, 78 MT6363_ID_VTREF18, 79 MT6363_ID_VUFS12, 80 MT6363_ID_VUFS18, 81 }; 82 83 /** 84 * struct mt6363_regulator_info - MT6363 regulators information 85 * @desc: Regulator description structure 86 * @lp_mode_reg: Low Power mode register (normal/idle) 87 * @lp_mode_mask: Low Power mode regulator mask 88 * @hw_lp_mode_reg: Hardware voted Low Power mode register (normal/idle) 89 * @hw_lp_mode_mask: Hardware voted Low Power mode regulator mask 90 * @modeset_reg: AUTO/PWM mode register 91 * @modeset_mask: AUTO/PWM regulator mask 92 * @lp_imax_uA: Maximum load current (microamps), for Low Power mode only 93 * @op_en_reg: Operation mode enablement register 94 * @orig_op_en: Backup of a regulator's operation mode enablement register 95 * @orig_op_cfg: Backup of a regulator's operation mode configuration register 96 * @oc_work: Delayed work for enabling overcurrent IRQ 97 * @hwirq: PMIC-Internal HW Interrupt for overcurrent event 98 * @virq: Mapped Interrupt for overcurrent event 99 */ 100 struct mt6363_regulator_info { 101 struct regulator_desc desc; 102 u16 lp_mode_reg; 103 u16 lp_mode_mask; 104 u16 hw_lp_mode_reg; 105 u16 hw_lp_mode_mask; 106 u16 modeset_reg; 107 u16 modeset_mask; 108 int lp_imax_uA; 109 u16 op_en_reg; 110 u32 orig_op_en; 111 u8 orig_op_cfg; 112 struct delayed_work oc_work; 113 u8 hwirq; 114 int virq; 115 }; 116 117 #define MT6363_BUCK(match, vreg, min, max, step, en_reg, lp_reg, \ 118 mset_reg, ocp_intn) \ 119 [MT6363_ID_##vreg] = { \ 120 .desc = { \ 121 .name = match, \ 122 .supply_name = "vsys-"match, \ 123 .of_match = of_match_ptr(match), \ 124 .ops = &mt6363_vreg_setclr_ops, \ 125 .type = REGULATOR_VOLTAGE, \ 126 .id = MT6363_ID_##vreg, \ 127 .owner = THIS_MODULE, \ 128 .n_voltages = (max - min) / step + 1, \ 129 .min_uV = min, \ 130 .uV_step = step, \ 131 .enable_reg = en_reg, \ 132 .enable_mask = BIT(MT6363_RG_BUCK_##vreg##_EN_BIT), \ 133 .vsel_reg = MT6363_RG_BUCK_##vreg##_VOSEL_ADDR, \ 134 .vsel_mask = MT6363_RG_BUCK_##vreg##_VOSEL_MASK, \ 135 .of_map_mode = mt6363_map_mode, \ 136 }, \ 137 .lp_mode_reg = lp_reg, \ 138 .lp_mode_mask = BIT(MT6363_RG_BUCK_##vreg##_LP_BIT), \ 139 .hw_lp_mode_reg = MT6363_BUCK_##vreg##_HW_LP_MODE, \ 140 .hw_lp_mode_mask = 0xc, \ 141 .modeset_reg = mset_reg, \ 142 .modeset_mask = BIT(MT6363_RG_##vreg##_FCCM_BIT), \ 143 .lp_imax_uA = 100000, \ 144 .op_en_reg = MT6363_BUCK_##vreg##_OP_EN_0, \ 145 .hwirq = ocp_intn, \ 146 } 147 148 #define MT6363_LDO_LINEAR_OPS(match, vreg, in_sup, vops, min, max, \ 149 step, en_reg, lp_reg, ocp_intn) \ 150 [MT6363_ID_##vreg] = { \ 151 .desc = { \ 152 .name = match, \ 153 .supply_name = in_sup, \ 154 .of_match = of_match_ptr(match), \ 155 .ops = &vops, \ 156 .type = REGULATOR_VOLTAGE, \ 157 .id = MT6363_ID_##vreg, \ 158 .owner = THIS_MODULE, \ 159 .n_voltages = (max - min) / step + 1, \ 160 .min_uV = min, \ 161 .uV_step = step, \ 162 .enable_reg = en_reg, \ 163 .enable_mask = BIT(MT6363_RG_LDO_##vreg##_EN_BIT), \ 164 .vsel_reg = MT6363_RG_LDO_##vreg##_VOSEL_ADDR, \ 165 .vsel_mask = MT6363_RG_LDO_##vreg##_VOSEL_MASK, \ 166 .of_map_mode = mt6363_map_mode, \ 167 }, \ 168 .lp_mode_reg = lp_reg, \ 169 .lp_mode_mask = BIT(MT6363_RG_LDO_##vreg##_LP_BIT), \ 170 .hw_lp_mode_reg = MT6363_LDO_##vreg##_HW_LP_MODE, \ 171 .hw_lp_mode_mask = 0x4, \ 172 .hwirq = ocp_intn, \ 173 } 174 175 #define MT6363_LDO_L_SC(match, vreg, inp, min, max, step, buck_reg, \ 176 ocp_intn) \ 177 MT6363_LDO_LINEAR_OPS(match, vreg, inp, mt6363_vreg_setclr_ops, \ 178 min, max, step, \ 179 MT6363_RG_##buck_reg##_EN_ADDR, \ 180 MT6363_RG_##buck_reg##_LP_ADDR, ocp_intn) 181 182 #define MT6363_LDO_L(match, vreg, inp, min, max, step, ocp_intn) \ 183 MT6363_LDO_LINEAR_OPS(match, vreg, inp, mt6363_ldo_linear_ops, \ 184 min, max, step, \ 185 MT6363_RG_LDO_##vreg##_ADDR, \ 186 MT6363_RG_LDO_##vreg##_ADDR, ocp_intn) 187 188 #define MT6363_LDO_LINEAR_CAL_OPS(match, vreg, in_sup, vops, vrnum, \ 189 ocp_intn) \ 190 [MT6363_ID_##vreg] = { \ 191 .desc = { \ 192 .name = match, \ 193 .supply_name = in_sup, \ 194 .of_match = of_match_ptr(match), \ 195 .ops = &vops, \ 196 .type = REGULATOR_VOLTAGE, \ 197 .id = MT6363_ID_##vreg, \ 198 .owner = THIS_MODULE, \ 199 .n_voltages = ARRAY_SIZE(ldo_volt_ranges##vrnum) * 11, \ 200 .linear_ranges = ldo_volt_ranges##vrnum, \ 201 .n_linear_ranges = ARRAY_SIZE(ldo_volt_ranges##vrnum), \ 202 .linear_range_selectors_bitfield = ldos_cal_selectors, \ 203 .enable_reg = MT6363_RG_LDO_##vreg##_ADDR, \ 204 .enable_mask = BIT(MT6363_RG_LDO_##vreg##_EN_BIT), \ 205 .vsel_reg = MT6363_RG_##vreg##_VOCAL_ADDR, \ 206 .vsel_mask = MT6363_RG_##vreg##_VOCAL_MASK, \ 207 .vsel_range_reg = MT6363_RG_##vreg##_VOSEL_ADDR, \ 208 .vsel_range_mask = MT6363_RG_##vreg##_VOSEL_MASK, \ 209 .of_map_mode = mt6363_map_mode, \ 210 }, \ 211 .lp_mode_reg = MT6363_RG_LDO_##vreg##_ADDR, \ 212 .lp_mode_mask = BIT(MT6363_RG_LDO_##vreg##_LP_BIT), \ 213 .hw_lp_mode_reg = MT6363_LDO_##vreg##_HW_LP_MODE, \ 214 .hw_lp_mode_mask = 0x4, \ 215 .lp_imax_uA = 10000, \ 216 .op_en_reg = MT6363_LDO_##vreg##_OP_EN0, \ 217 .hwirq = ocp_intn, \ 218 } 219 220 #define MT6363_LDO_VT(match, vreg, inp, vranges_num, ocp_intn) \ 221 MT6363_LDO_LINEAR_CAL_OPS(match, vreg, inp, mt6363_ldo_vtable_ops,\ 222 vranges_num, ocp_intn) 223 224 static const unsigned int ldos_cal_selectors[] = { 225 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 226 }; 227 228 static const struct linear_range ldo_volt_ranges0[] = { 229 REGULATOR_LINEAR_RANGE(1200000, 0, 10, 10000), 230 REGULATOR_LINEAR_RANGE(1300000, 0, 10, 10000), 231 REGULATOR_LINEAR_RANGE(1500000, 0, 10, 10000), 232 REGULATOR_LINEAR_RANGE(1700000, 0, 10, 10000), 233 REGULATOR_LINEAR_RANGE(1800000, 0, 10, 10000), 234 REGULATOR_LINEAR_RANGE(2000000, 0, 10, 10000), 235 REGULATOR_LINEAR_RANGE(2500000, 0, 10, 10000), 236 REGULATOR_LINEAR_RANGE(2600000, 0, 10, 10000), 237 REGULATOR_LINEAR_RANGE(2700000, 0, 10, 10000), 238 REGULATOR_LINEAR_RANGE(2800000, 0, 10, 10000), 239 REGULATOR_LINEAR_RANGE(2900000, 0, 10, 10000), 240 REGULATOR_LINEAR_RANGE(3000000, 0, 10, 10000), 241 REGULATOR_LINEAR_RANGE(3100000, 0, 10, 10000), 242 REGULATOR_LINEAR_RANGE(3300000, 0, 10, 10000), 243 REGULATOR_LINEAR_RANGE(3400000, 0, 10, 10000), 244 REGULATOR_LINEAR_RANGE(3500000, 0, 10, 10000) 245 }; 246 247 static const struct linear_range ldo_volt_ranges1[] = { 248 REGULATOR_LINEAR_RANGE(900000, 0, 10, 10000), 249 REGULATOR_LINEAR_RANGE(1000000, 0, 10, 10000), 250 REGULATOR_LINEAR_RANGE(1100000, 0, 10, 10000), 251 REGULATOR_LINEAR_RANGE(1200000, 0, 10, 10000), 252 REGULATOR_LINEAR_RANGE(1300000, 0, 10, 10000), 253 REGULATOR_LINEAR_RANGE(1700000, 0, 10, 10000), 254 REGULATOR_LINEAR_RANGE(1800000, 0, 10, 10000), 255 REGULATOR_LINEAR_RANGE(1810000, 0, 10, 10000) 256 }; 257 258 static const struct linear_range ldo_volt_ranges2[] = { 259 REGULATOR_LINEAR_RANGE(1800000, 0, 10, 10000), 260 REGULATOR_LINEAR_RANGE(1900000, 0, 10, 10000), 261 REGULATOR_LINEAR_RANGE(2000000, 0, 10, 10000), 262 REGULATOR_LINEAR_RANGE(2100000, 0, 10, 10000), 263 REGULATOR_LINEAR_RANGE(2200000, 0, 10, 10000), 264 REGULATOR_LINEAR_RANGE(2300000, 0, 10, 10000), 265 REGULATOR_LINEAR_RANGE(2400000, 0, 10, 10000), 266 REGULATOR_LINEAR_RANGE(2500000, 0, 10, 10000), 267 REGULATOR_LINEAR_RANGE(2600000, 0, 10, 10000), 268 REGULATOR_LINEAR_RANGE(2700000, 0, 10, 10000), 269 REGULATOR_LINEAR_RANGE(2800000, 0, 10, 10000), 270 REGULATOR_LINEAR_RANGE(2900000, 0, 10, 10000), 271 REGULATOR_LINEAR_RANGE(3000000, 0, 10, 10000), 272 REGULATOR_LINEAR_RANGE(3100000, 0, 10, 10000), 273 REGULATOR_LINEAR_RANGE(3200000, 0, 10, 10000), 274 REGULATOR_LINEAR_RANGE(3300000, 0, 10, 10000) 275 }; 276 277 static const struct linear_range ldo_volt_ranges3[] = { 278 REGULATOR_LINEAR_RANGE(600000, 0, 10, 10000), 279 REGULATOR_LINEAR_RANGE(700000, 0, 10, 10000), 280 REGULATOR_LINEAR_RANGE(800000, 0, 10, 10000), 281 REGULATOR_LINEAR_RANGE(900000, 0, 10, 10000), 282 REGULATOR_LINEAR_RANGE(1000000, 0, 10, 10000), 283 REGULATOR_LINEAR_RANGE(1100000, 0, 10, 10000), 284 REGULATOR_LINEAR_RANGE(1200000, 0, 10, 10000), 285 REGULATOR_LINEAR_RANGE(1300000, 0, 10, 10000), 286 REGULATOR_LINEAR_RANGE(1400000, 0, 10, 10000), 287 REGULATOR_LINEAR_RANGE(1500000, 0, 10, 10000), 288 REGULATOR_LINEAR_RANGE(1600000, 0, 10, 10000), 289 REGULATOR_LINEAR_RANGE(1700000, 0, 10, 10000), 290 REGULATOR_LINEAR_RANGE(1800000, 0, 10, 10000), 291 REGULATOR_LINEAR_RANGE(1900000, 0, 10, 10000), 292 REGULATOR_LINEAR_RANGE(2000000, 0, 10, 10000), 293 REGULATOR_LINEAR_RANGE(2100000, 0, 10, 10000) 294 }; 295 296 static const struct linear_range ldo_volt_ranges4[] = { 297 REGULATOR_LINEAR_RANGE(550000, 0, 10, 5000), 298 REGULATOR_LINEAR_RANGE(600000, 0, 10, 5000), 299 REGULATOR_LINEAR_RANGE(650000, 0, 10, 5000), 300 REGULATOR_LINEAR_RANGE(700000, 0, 10, 5000), 301 REGULATOR_LINEAR_RANGE(750000, 0, 10, 5000), 302 REGULATOR_LINEAR_RANGE(800000, 0, 10, 5000), 303 REGULATOR_LINEAR_RANGE(900000, 0, 10, 5000), 304 REGULATOR_LINEAR_RANGE(950000, 0, 10, 5000), 305 REGULATOR_LINEAR_RANGE(1000000, 0, 10, 5000), 306 REGULATOR_LINEAR_RANGE(1050000, 0, 10, 5000), 307 REGULATOR_LINEAR_RANGE(1100000, 0, 10, 5000), 308 REGULATOR_LINEAR_RANGE(1150000, 0, 10, 5000), 309 REGULATOR_LINEAR_RANGE(1700000, 0, 10, 5000), 310 REGULATOR_LINEAR_RANGE(1750000, 0, 10, 5000), 311 REGULATOR_LINEAR_RANGE(1800000, 0, 10, 5000), 312 REGULATOR_LINEAR_RANGE(1850000, 0, 10, 5000) 313 }; 314 315 static const struct linear_range ldo_volt_ranges5[] = { 316 REGULATOR_LINEAR_RANGE(600000, 0, 10, 5000), 317 REGULATOR_LINEAR_RANGE(650000, 0, 10, 5000), 318 REGULATOR_LINEAR_RANGE(700000, 0, 10, 5000), 319 REGULATOR_LINEAR_RANGE(750000, 0, 10, 5000), 320 REGULATOR_LINEAR_RANGE(800000, 0, 10, 5000) 321 }; 322 323 static int mt6363_vreg_enable_setclr(struct regulator_dev *rdev) 324 { 325 return regmap_write(rdev->regmap, rdev->desc->enable_reg + EN_SET_OFFSET, 326 rdev->desc->enable_mask); 327 } 328 329 static int mt6363_vreg_disable_setclr(struct regulator_dev *rdev) 330 { 331 return regmap_write(rdev->regmap, rdev->desc->enable_reg + EN_CLR_OFFSET, 332 rdev->desc->enable_mask); 333 } 334 335 static inline unsigned int mt6363_map_mode(unsigned int mode) 336 { 337 switch (mode) { 338 case MT6363_REGULATOR_MODE_NORMAL: 339 return REGULATOR_MODE_NORMAL; 340 case MT6363_REGULATOR_MODE_FCCM: 341 return REGULATOR_MODE_FAST; 342 case MT6363_REGULATOR_MODE_LP: 343 return REGULATOR_MODE_IDLE; 344 case MT6363_REGULATOR_MODE_ULP: 345 return REGULATOR_MODE_STANDBY; 346 default: 347 return REGULATOR_MODE_INVALID; 348 } 349 } 350 351 static unsigned int mt6363_regulator_get_mode(struct regulator_dev *rdev) 352 { 353 struct mt6363_regulator_info *info = rdev_get_drvdata(rdev); 354 unsigned int val; 355 int ret; 356 357 if (info->modeset_reg) { 358 ret = regmap_read(rdev->regmap, info->modeset_reg, &val); 359 if (ret) { 360 dev_err(&rdev->dev, "Failed to get mt6363 mode: %d\n", ret); 361 return ret; 362 } 363 364 if (val & info->modeset_mask) 365 return REGULATOR_MODE_FAST; 366 } else { 367 val = 0; 368 } 369 370 ret = regmap_read(rdev->regmap, info->hw_lp_mode_reg, &val); 371 val &= info->hw_lp_mode_mask; 372 373 if (ret) { 374 dev_err(&rdev->dev, "Failed to get lp mode: %d\n", ret); 375 return ret; 376 } 377 378 if (val) 379 return REGULATOR_MODE_IDLE; 380 else 381 return REGULATOR_MODE_NORMAL; 382 } 383 384 static int mt6363_buck_unlock(struct regmap *map, bool unlock) 385 { 386 __le16 buf = cpu_to_le16(unlock ? MT6363_BUCK_TOP_UNLOCK_VALUE : 0); 387 388 return regmap_bulk_write(map, MT6363_BUCK_TOP_KEY_PROT_LO, &buf, sizeof(buf)); 389 } 390 391 static int mt6363_regulator_set_mode(struct regulator_dev *rdev, 392 unsigned int mode) 393 { 394 struct mt6363_regulator_info *info = rdev_get_drvdata(rdev); 395 struct regmap *regmap = rdev->regmap; 396 int cur_mode, ret; 397 398 if (!info->modeset_reg && mode == REGULATOR_MODE_FAST) 399 return -EOPNOTSUPP; 400 401 switch (mode) { 402 case REGULATOR_MODE_FAST: 403 ret = mt6363_buck_unlock(regmap, true); 404 if (ret) 405 break; 406 407 ret = regmap_set_bits(regmap, info->modeset_reg, info->modeset_mask); 408 409 mt6363_buck_unlock(regmap, false); 410 break; 411 case REGULATOR_MODE_NORMAL: 412 cur_mode = mt6363_regulator_get_mode(rdev); 413 if (cur_mode < 0) { 414 ret = cur_mode; 415 break; 416 } 417 418 if (cur_mode == REGULATOR_MODE_FAST) { 419 ret = mt6363_buck_unlock(regmap, true); 420 if (ret) 421 break; 422 423 ret = regmap_clear_bits(regmap, info->modeset_reg, info->modeset_mask); 424 425 mt6363_buck_unlock(regmap, false); 426 break; 427 } else if (cur_mode == REGULATOR_MODE_IDLE) { 428 ret = regmap_clear_bits(regmap, info->lp_mode_reg, info->lp_mode_mask); 429 if (ret == 0) 430 usleep_range(100, 200); 431 } else { 432 ret = 0; 433 } 434 break; 435 case REGULATOR_MODE_IDLE: 436 ret = regmap_set_bits(regmap, info->lp_mode_reg, info->lp_mode_mask); 437 break; 438 default: 439 ret = -EINVAL; 440 } 441 442 if (ret) { 443 dev_err(&rdev->dev, "Failed to set mode %u: %d\n", mode, ret); 444 return ret; 445 } 446 447 return 0; 448 } 449 450 static int mt6363_regulator_set_load(struct regulator_dev *rdev, int load_uA) 451 { 452 struct mt6363_regulator_info *info = rdev_get_drvdata(rdev); 453 unsigned int opmode_cfg, opmode_en; 454 int i, ret; 455 456 if (!info->lp_imax_uA) 457 return -EINVAL; 458 459 if (load_uA >= info->lp_imax_uA) { 460 ret = mt6363_regulator_set_mode(rdev, REGULATOR_MODE_NORMAL); 461 if (ret) 462 return ret; 463 464 opmode_cfg = NORMAL_OP_CFG; 465 opmode_en = NORMAL_OP_EN; 466 } else { 467 opmode_cfg = info->orig_op_cfg; 468 opmode_en = info->orig_op_en; 469 } 470 471 ret = regmap_write(rdev->regmap, info->op_en_reg + OP_CFG_OFFSET, opmode_cfg); 472 if (ret) 473 return ret; 474 475 for (i = 0; i < 3; i++) { 476 ret = regmap_write(rdev->regmap, info->op_en_reg + i, 477 (opmode_en >> (i * 8)) & GENMASK(7, 0)); 478 if (ret) 479 return ret; 480 } 481 482 return 0; 483 } 484 485 static int mt6363_vemc_set_voltage_sel(struct regulator_dev *rdev, unsigned int sel) 486 { 487 const __le16 tma_unlock_key = cpu_to_le16(MT6363_TMA_UNLOCK_VALUE); 488 const __le16 tma_lock_key = cpu_to_le16(0); 489 int ret; 490 491 /* Unlock TMA for writing */ 492 ret = regmap_bulk_write(rdev->regmap, MT6363_TOP_TMA_KEY_L, 493 &tma_unlock_key, sizeof(tma_unlock_key)); 494 if (ret) 495 return ret; 496 497 ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel); 498 499 /* Unconditionally re-lock TMA */ 500 regmap_bulk_write(rdev->regmap, MT6363_TOP_TMA_KEY_L, 501 &tma_lock_key, sizeof(tma_lock_key)); 502 503 return ret; 504 } 505 506 static int mt6363_va15_set_voltage_sel(struct regulator_dev *rdev, unsigned int sel) 507 { 508 struct regmap *regmap = rdev->regmap; 509 int ret; 510 511 ret = mt6363_buck_unlock(regmap, true); 512 if (ret) 513 return ret; 514 515 ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel); 516 if (ret) 517 goto va15_unlock; 518 519 ret = regmap_update_bits(regmap, MT6363_RG_BUCK_EFUSE_RSV1, 520 MT6363_RG_BUCK_EFUSE_RSV1_MASK, sel); 521 if (ret) 522 goto va15_unlock; 523 524 va15_unlock: 525 mt6363_buck_unlock(rdev->regmap, false); 526 return ret; 527 } 528 529 static void mt6363_oc_irq_enable_work(struct work_struct *work) 530 { 531 struct delayed_work *dwork = to_delayed_work(work); 532 struct mt6363_regulator_info *info = 533 container_of(dwork, struct mt6363_regulator_info, oc_work); 534 535 enable_irq(info->virq); 536 } 537 538 static irqreturn_t mt6363_oc_isr(int irq, void *data) 539 { 540 struct regulator_dev *rdev = (struct regulator_dev *)data; 541 struct mt6363_regulator_info *info = rdev_get_drvdata(rdev); 542 543 disable_irq_nosync(info->virq); 544 545 if (regulator_is_enabled_regmap(rdev)) 546 regulator_notifier_call_chain(rdev, REGULATOR_EVENT_OVER_CURRENT, NULL); 547 548 schedule_delayed_work(&info->oc_work, msecs_to_jiffies(OC_IRQ_ENABLE_DELAY_MS)); 549 550 return IRQ_HANDLED; 551 } 552 553 static int mt6363_set_ocp(struct regulator_dev *rdev, int lim, int severity, bool enable) 554 { 555 struct mt6363_regulator_info *info = rdev_get_drvdata(rdev); 556 557 /* MT6363 supports only enabling protection and does not support limits */ 558 if (lim || severity != REGULATOR_SEVERITY_PROT || !enable) 559 return -EOPNOTSUPP; 560 561 /* If there is no OCP interrupt, there's nothing to set */ 562 if (info->virq <= 0) 563 return -EOPNOTSUPP; 564 565 return devm_request_threaded_irq(&rdev->dev, info->virq, NULL, 566 mt6363_oc_isr, IRQF_ONESHOT, 567 info->desc.name, rdev); 568 } 569 570 static const struct regulator_ops mt6363_vreg_setclr_ops = { 571 .list_voltage = regulator_list_voltage_linear, 572 .map_voltage = regulator_map_voltage_linear, 573 .set_voltage_sel = regulator_set_voltage_sel_regmap, 574 .get_voltage_sel = regulator_get_voltage_sel_regmap, 575 .set_voltage_time_sel = regulator_set_voltage_time_sel, 576 .enable = mt6363_vreg_enable_setclr, 577 .disable = mt6363_vreg_disable_setclr, 578 .is_enabled = regulator_is_enabled_regmap, 579 .set_mode = mt6363_regulator_set_mode, 580 .get_mode = mt6363_regulator_get_mode, 581 .set_load = mt6363_regulator_set_load, 582 .set_over_current_protection = mt6363_set_ocp, 583 }; 584 585 static const struct regulator_ops mt6363_ldo_linear_ops = { 586 .list_voltage = regulator_list_voltage_linear, 587 .map_voltage = regulator_map_voltage_linear, 588 .set_voltage_sel = regulator_set_voltage_sel_regmap, 589 .get_voltage_sel = regulator_get_voltage_sel_regmap, 590 .set_voltage_time_sel = regulator_set_voltage_time_sel, 591 .enable = regulator_enable_regmap, 592 .disable = regulator_disable_regmap, 593 .is_enabled = regulator_is_enabled_regmap, 594 .set_mode = mt6363_regulator_set_mode, 595 .get_mode = mt6363_regulator_get_mode, 596 .set_over_current_protection = mt6363_set_ocp, 597 }; 598 599 static const struct regulator_ops mt6363_ldo_vtable_ops = { 600 .list_voltage = regulator_list_voltage_pickable_linear_range, 601 .map_voltage = regulator_map_voltage_pickable_linear_range, 602 .set_voltage_sel = regulator_set_voltage_sel_pickable_regmap, 603 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap, 604 .set_voltage_time_sel = regulator_set_voltage_time_sel, 605 .enable = regulator_enable_regmap, 606 .disable = regulator_disable_regmap, 607 .is_enabled = regulator_is_enabled_regmap, 608 .set_mode = mt6363_regulator_set_mode, 609 .get_mode = mt6363_regulator_get_mode, 610 .set_load = mt6363_regulator_set_load, 611 .set_over_current_protection = mt6363_set_ocp, 612 }; 613 614 static const struct regulator_ops mt6363_ldo_vemc_ops = { 615 .list_voltage = regulator_list_voltage_pickable_linear_range, 616 .map_voltage = regulator_map_voltage_pickable_linear_range, 617 .set_voltage_sel = mt6363_vemc_set_voltage_sel, 618 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap, 619 .set_voltage_time_sel = regulator_set_voltage_time_sel, 620 .enable = regulator_enable_regmap, 621 .disable = regulator_disable_regmap, 622 .is_enabled = regulator_is_enabled_regmap, 623 .set_mode = mt6363_regulator_set_mode, 624 .get_mode = mt6363_regulator_get_mode, 625 .set_load = mt6363_regulator_set_load, 626 .set_over_current_protection = mt6363_set_ocp, 627 }; 628 629 static const struct regulator_ops mt6363_ldo_va15_ops = { 630 .list_voltage = regulator_list_voltage_pickable_linear_range, 631 .map_voltage = regulator_map_voltage_pickable_linear_range, 632 .set_voltage_sel = mt6363_va15_set_voltage_sel, 633 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap, 634 .set_voltage_time_sel = regulator_set_voltage_time_sel, 635 .enable = regulator_enable_regmap, 636 .disable = regulator_disable_regmap, 637 .is_enabled = regulator_is_enabled_regmap, 638 .set_mode = mt6363_regulator_set_mode, 639 .get_mode = mt6363_regulator_get_mode, 640 .set_load = mt6363_regulator_set_load, 641 .set_over_current_protection = mt6363_set_ocp, 642 }; 643 644 /* The array is indexed by id(MT6363_ID_XXX) */ 645 static struct mt6363_regulator_info mt6363_regulators[] = { 646 MT6363_BUCK("vbuck1", VBUCK1, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR, 647 MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_FCCM_ADDR, 1), 648 MT6363_BUCK("vbuck2", VBUCK2, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR, 649 MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_FCCM_ADDR, 2), 650 MT6363_BUCK("vbuck3", VBUCK3, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR, 651 MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_FCCM_ADDR, 3), 652 MT6363_BUCK("vbuck4", VBUCK4, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR, 653 MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_1_FCCM_ADDR, 4), 654 MT6363_BUCK("vbuck5", VBUCK5, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR, 655 MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_1_FCCM_ADDR, 5), 656 MT6363_BUCK("vbuck6", VBUCK6, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR, 657 MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_1_FCCM_ADDR, 6), 658 MT6363_BUCK("vbuck7", VBUCK7, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR, 659 MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_1_FCCM_ADDR, 7), 660 MT6363_BUCK("vs1", VS1, 0, 2200000, 12500, MT6363_RG_BUCK1_EN_ADDR, 661 MT6363_RG_BUCK1_LP_ADDR, MT6363_RG_VS1_FCCM_ADDR, 8), 662 MT6363_BUCK("vs2", VS2, 0, 1600000, 12500, MT6363_RG_BUCK0_EN_ADDR, 663 MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_FCCM_ADDR, 0), 664 MT6363_BUCK("vs3", VS3, 0, 1193750, 6250, MT6363_RG_BUCK1_EN_ADDR, 665 MT6363_RG_BUCK1_LP_ADDR, MT6363_RG_VS3_FCCM_ADDR, 9), 666 MT6363_LDO_VT("va12-1", VA12_1, "vs2-ldo2", 3, 37), 667 MT6363_LDO_VT("va12-2", VA12_2, "vs2-ldo2", 3, 38), 668 MT6363_LDO_LINEAR_CAL_OPS("va15", VA15, "vs1-ldo1", mt6363_ldo_va15_ops, 3, 39), 669 MT6363_LDO_VT("vaux18", VAUX18, "vsys-ldo1", 2, 31), 670 MT6363_LDO_VT("vcn13", VCN13, "vs2-ldo2", 1, 17), 671 MT6363_LDO_VT("vcn15", VCN15, "vs1-ldo2", 3, 16), 672 MT6363_LDO_LINEAR_CAL_OPS("vemc", VEMC, "vsys-ldo1", mt6363_ldo_vemc_ops, 0, 32), 673 MT6363_LDO_VT("vio0p75", VIO075, "vs1-ldo1", 5, 36), 674 MT6363_LDO_VT("vio18", VIO18, "vs1-ldo2", 3, 35), 675 MT6363_LDO_VT("vm18", VM18, "vs1-ldo1", 4, 40), 676 MT6363_LDO_L("vsram-apu", VSRAM_APU, "vs3-ldo1", 400000, 1193750, 6250, 30), 677 MT6363_LDO_L("vsram-cpub", VSRAM_CPUB, "vs2-ldo1", 400000, 1193750, 6250, 27), 678 MT6363_LDO_L("vsram-cpum", VSRAM_CPUM, "vs2-ldo1", 400000, 1193750, 6250, 28), 679 MT6363_LDO_L("vsram-cpul", VSRAM_CPUL, "vs2-ldo2", 400000, 1193750, 6250, 29), 680 MT6363_LDO_L_SC("vsram-digrf", VSRAM_DIGRF, "vs3-ldo1", 400000, 1193750, 6250, BUCK1, 23), 681 MT6363_LDO_L_SC("vsram-mdfe", VSRAM_MDFE, "vs3-ldo1", 400000, 1193750, 6250, BUCK1, 24), 682 MT6363_LDO_L_SC("vsram-modem", VSRAM_MODEM, "vs3-ldo2", 400000, 1193750, 6250, BUCK1, 25), 683 MT6363_LDO_VT("vrf0p9", VRF09, "vs3-ldo2", 1, 18), 684 MT6363_LDO_VT("vrf12", VRF12, "vs2-ldo1", 3, 19), 685 MT6363_LDO_VT("vrf13", VRF13, "vs2-ldo1", 1, 20), 686 MT6363_LDO_VT("vrf18", VRF18, "vs1-ldo1", 3, 21), 687 MT6363_LDO_VT("vrf-io18", VRFIO18, "vs1-ldo1", 3, 22), 688 MT6363_LDO_VT("vtref18", VTREF18, "vsys-ldo1", 2, 26), 689 MT6363_LDO_VT("vufs12", VUFS12, "vs2-ldo1", 4, 33), 690 MT6363_LDO_VT("vufs18", VUFS18, "vs1-ldo2", 3, 34), 691 }; 692 693 static int mt6363_backup_op_setting(struct regmap *map, struct mt6363_regulator_info *info) 694 { 695 unsigned int i, val; 696 int ret; 697 698 ret = regmap_read(map, info->op_en_reg + OP_CFG_OFFSET, &val); 699 if (ret) 700 return ret; 701 702 info->orig_op_cfg = val; 703 704 for (i = 0; i < 3; i++) { 705 ret = regmap_read(map, info->op_en_reg + i, &val); 706 if (ret) 707 return ret; 708 709 info->orig_op_en |= val << (i * 8); 710 } 711 712 return 0; 713 } 714 715 static int mt6363_vemc_select_bank(struct regmap *map, struct regulator_desc *desc) 716 { 717 unsigned int trap; 718 int ret; 719 720 ret = regmap_read(map, MT6363_TOP_TRAP, &trap); 721 if (ret) 722 return ret; 723 724 /* The hardware trap value selects which VEMC voltage controls are used */ 725 switch (trap) { 726 case 0: 727 desc->vsel_reg = MT6363_RG_VEMC_VOCAL_ADDR; 728 desc->vsel_range_mask = MT6363_RG_VEMC_VOSEL_MASK; 729 return 0; 730 case 1: 731 desc->vsel_reg = MT6363_RG_VEMC_VOCAL_1_ADDR; 732 desc->vsel_range_mask = MT6363_RG_VEMC_VOSEL_1_MASK; 733 return 0; 734 default: 735 return -EINVAL; 736 } 737 } 738 739 static void mt6363_irq_remove(void *data) 740 { 741 int *virq = data; 742 743 irq_dispose_mapping(*virq); 744 } 745 746 static void mt6363_spmi_remove(void *data) 747 { 748 struct spmi_device *sdev = data; 749 750 spmi_device_remove(sdev); 751 }; 752 753 static struct regmap *mt6363_spmi_register_regmap(struct device *dev) 754 { 755 struct regmap_config mt6363_regmap_config = { 756 .reg_bits = 16, 757 .val_bits = 8, 758 .max_register = 0x1f90, 759 .fast_io = true, 760 }; 761 struct spmi_device *sdev, *sparent; 762 u32 base; 763 int ret; 764 765 if (!dev->parent) 766 return ERR_PTR(-ENODEV); 767 768 ret = device_property_read_u32(dev, "reg", &base); 769 if (ret) 770 return ERR_PTR(ret); 771 772 sparent = to_spmi_device(dev->parent); 773 if (!sparent) 774 return ERR_PTR(-ENODEV); 775 776 sdev = spmi_device_alloc(sparent->ctrl); 777 if (!sdev) 778 return ERR_PTR(-ENODEV); 779 780 sdev->usid = sparent->usid; 781 dev_set_name(&sdev->dev, "%d-%02x-regulator", sdev->ctrl->nr, sdev->usid); 782 ret = device_add(&sdev->dev); 783 if (ret) { 784 put_device(&sdev->dev); 785 return ERR_PTR(ret); 786 }; 787 788 ret = devm_add_action_or_reset(dev, mt6363_spmi_remove, sdev); 789 if (ret) 790 return ERR_PTR(ret); 791 792 mt6363_regmap_config.reg_base = base; 793 794 return devm_regmap_init_spmi_ext(sdev, &mt6363_regmap_config); 795 } 796 797 static int mt6363_regulator_probe(struct platform_device *pdev) 798 { 799 struct device_node *interrupt_parent; 800 struct regulator_config config = {}; 801 struct mt6363_regulator_info *info; 802 struct device *dev = &pdev->dev; 803 struct regulator_dev *rdev; 804 struct irq_domain *domain; 805 struct irq_fwspec fwspec; 806 struct spmi_device *sdev; 807 int i, ret, val; 808 809 config.regmap = mt6363_spmi_register_regmap(dev); 810 if (IS_ERR(config.regmap)) 811 return dev_err_probe(dev, PTR_ERR(config.regmap), 812 "Cannot get regmap\n"); 813 config.dev = dev; 814 sdev = to_spmi_device(dev->parent); 815 816 /* 817 * The first read may fail if the bootloader sets sleep mode: wake up 818 * this PMIC with W/R on the SPMI bus and ignore the first result. 819 * This matches the MT6373 driver behavior. 820 */ 821 regmap_read(config.regmap, MT6363_TOP_TRAP, &val); 822 823 ret = mt6363_vemc_select_bank(config.regmap, 824 &mt6363_regulators[MT6363_ID_VEMC].desc); 825 if (ret) 826 return dev_err_probe(dev, ret, "Failed to select VEMC bank\n"); 827 828 interrupt_parent = of_irq_find_parent(dev->of_node); 829 if (!interrupt_parent) 830 return dev_err_probe(dev, -EINVAL, "Cannot find IRQ parent\n"); 831 832 domain = irq_find_host(interrupt_parent); 833 of_node_put(interrupt_parent); 834 fwspec.fwnode = domain->fwnode; 835 836 fwspec.param_count = 3; 837 fwspec.param[0] = sdev->usid; 838 fwspec.param[2] = IRQ_TYPE_LEVEL_HIGH; 839 840 for (i = 0; i < ARRAY_SIZE(mt6363_regulators); i++) { 841 info = &mt6363_regulators[i]; 842 843 fwspec.param[1] = info->hwirq; 844 info->virq = irq_create_fwspec_mapping(&fwspec); 845 if (!info->virq) 846 return dev_err_probe(dev, -EINVAL, 847 "Failed to map IRQ%d\n", info->hwirq); 848 849 ret = devm_add_action_or_reset(dev, mt6363_irq_remove, &info->virq); 850 if (ret) 851 return ret; 852 853 config.driver_data = info; 854 INIT_DELAYED_WORK(&info->oc_work, mt6363_oc_irq_enable_work); 855 856 rdev = devm_regulator_register(dev, &info->desc, &config); 857 if (IS_ERR(rdev)) 858 return dev_err_probe(dev, PTR_ERR(rdev), 859 "failed to register %s\n", info->desc.name); 860 861 if (info->lp_imax_uA) { 862 ret = mt6363_backup_op_setting(config.regmap, info); 863 if (ret) { 864 dev_warn(dev, "Failed to backup op_setting for %s\n", 865 info->desc.name); 866 info->lp_imax_uA = 0; 867 } 868 } 869 } 870 871 return 0; 872 } 873 874 static const struct of_device_id mt6363_regulator_match[] = { 875 { .compatible = "mediatek,mt6363-regulator" }, 876 { /* sentinel */ } 877 }; 878 MODULE_DEVICE_TABLE(of, mt6363_regulator_match); 879 880 static struct platform_driver mt6363_regulator_driver = { 881 .driver = { 882 .name = "mt6363-regulator", 883 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 884 .of_match_table = mt6363_regulator_match, 885 }, 886 .probe = mt6363_regulator_probe, 887 }; 888 module_platform_driver(mt6363_regulator_driver); 889 890 MODULE_AUTHOR("AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>"); 891 MODULE_DESCRIPTION("Regulator Driver for MediaTek MT6363 PMIC"); 892 MODULE_LICENSE("GPL"); 893