1 // SPDX-License-Identifier: GPL-2.0+ 2 3 #include <linux/bitops.h> 4 #include <linux/bitfield.h> 5 #include <linux/util_macros.h> 6 #include <linux/module.h> 7 #include <linux/i2c.h> 8 #include <linux/regmap.h> 9 #include <linux/regulator/driver.h> 10 #include <linux/regulator/machine.h> 11 #include <linux/regulator/of_regulator.h> 12 13 /* Register */ 14 #define RTQ2208_REG_GLOBAL_INT1 0x12 15 #define RTQ2208_REG_FLT_RECORDBUCK_CB 0x18 16 #define RTQ2208_REG_GLOBAL_INT1_MASK 0x1D 17 #define RTQ2208_REG_FLT_MASKBUCK_CB 0x1F 18 #define RTQ2208_REG_BUCK_C_CFG0 0x32 19 #define RTQ2208_REG_BUCK_B_CFG0 0x42 20 #define RTQ2208_REG_BUCK_A_CFG0 0x52 21 #define RTQ2208_REG_BUCK_D_CFG0 0x62 22 #define RTQ2208_REG_BUCK_G_CFG0 0x72 23 #define RTQ2208_REG_BUCK_F_CFG0 0x82 24 #define RTQ2208_REG_BUCK_E_CFG0 0x92 25 #define RTQ2208_REG_BUCK_H_CFG0 0xA2 26 #define RTQ2208_REG_LDO1_CFG 0xB1 27 #define RTQ2208_REG_LDO2_CFG 0xC1 28 #define RTQ2208_REG_LDO_DVS_CTRL 0xD0 29 #define RTQ2208_REG_HIDDEN_BUCKPH 0x55 30 #define RTQ2208_REG_HIDDEN_LDOCFG0 0x8F 31 #define RTQ2208_REG_HIDDEN_LDOCFG1 0x96 32 #define RTQ2208_REG_HIDDEN0 0xFE 33 #define RTQ2208_REG_HIDDEN1 0xFF 34 35 /* Mask */ 36 #define RTQ2208_BUCK_NR_MTP_SEL_MASK GENMASK(7, 0) 37 #define RTQ2208_BUCK_EN_NR_MTP_SEL0_MASK BIT(0) 38 #define RTQ2208_BUCK_EN_NR_MTP_SEL1_MASK BIT(1) 39 #define RTQ2208_BUCK_RSPUP_MASK GENMASK(6, 4) 40 #define RTQ2208_BUCK_RSPDN_MASK GENMASK(2, 0) 41 #define RTQ2208_BUCK_NRMODE_MASK BIT(5) 42 #define RTQ2208_BUCK_STRMODE_MASK BIT(5) 43 #define RTQ2208_BUCK_EN_STR_MASK BIT(0) 44 #define RTQ2208_LDO_EN_STR_MASK BIT(7) 45 #define RTQ2208_EN_DIS_MASK BIT(0) 46 #define RTQ2208_BUCK_RAMP_SEL_MASK GENMASK(2, 0) 47 #define RTQ2208_HD_INT_MASK BIT(0) 48 #define RTQ2208_LDO1_DISCHG_EN_MASK BIT(4) 49 #define RTQ2208_LDO1_VOSEL_SD_MASK BIT(5) 50 #define RTQ2208_LDO2_DISCHG_EN_MASK BIT(6) 51 #define RTQ2208_LDO2_VOSEL_SD_MASK BIT(7) 52 #define RTQ2208_MASK_BUCKPH_GROUP1 GENMASK(6, 4) 53 #define RTQ2208_MASK_BUCKPH_GROUP2 GENMASK(2, 0) 54 #define RTQ2208_MASK_LDO2_OPT0 BIT(7) 55 #define RTQ2208_MASK_LDO2_OPT1 BIT(7) 56 #define RTQ2208_MASK_LDO1_FIXED BIT(6) 57 58 /* Size */ 59 #define RTQ2208_VOUT_MAXNUM 256 60 #define RTQ2208_BUCK_NUM_IRQ_REGS 5 61 #define RTQ2208_STS_NUM_IRQ_REGS 2 62 63 /* Value */ 64 #define RTQ2208_RAMP_VALUE_MIN_uV 500 65 #define RTQ2208_RAMP_VALUE_MAX_uV 16000 66 67 #define RTQ2208_BUCK_MASK(uv_irq, ov_irq) (1 << ((uv_irq) % 8) | 1 << ((ov_irq) % 8)) 68 69 enum { 70 RTQ2208_BUCK_B = 0, 71 RTQ2208_BUCK_C, 72 RTQ2208_BUCK_D, 73 RTQ2208_BUCK_A, 74 RTQ2208_BUCK_F, 75 RTQ2208_BUCK_G, 76 RTQ2208_BUCK_H, 77 RTQ2208_BUCK_E, 78 RTQ2208_LDO2, 79 RTQ2208_LDO1, 80 RTQ2208_LDO_MAX, 81 }; 82 83 enum { 84 RTQ2208_AUTO_MODE = 0, 85 RTQ2208_FCCM, 86 }; 87 88 struct rtq2208_regulator_desc { 89 struct regulator_desc desc; 90 unsigned int mtp_sel_reg; 91 unsigned int mtp_sel_mask; 92 unsigned int mode_reg; 93 unsigned int mode_mask; 94 unsigned int suspend_config_reg; 95 unsigned int suspend_enable_mask; 96 unsigned int suspend_mode_mask; 97 }; 98 99 struct rtq2208_rdev_map { 100 struct regulator_dev *rdev[RTQ2208_LDO_MAX]; 101 struct regmap *regmap; 102 struct device *dev; 103 }; 104 105 /* set Normal Auto/FCCM mode */ 106 static int rtq2208_set_mode(struct regulator_dev *rdev, unsigned int mode) 107 { 108 const struct rtq2208_regulator_desc *rdesc = 109 (const struct rtq2208_regulator_desc *)rdev->desc; 110 unsigned int val, shift; 111 112 switch (mode) { 113 case REGULATOR_MODE_NORMAL: 114 val = RTQ2208_AUTO_MODE; 115 break; 116 case REGULATOR_MODE_FAST: 117 val = RTQ2208_FCCM; 118 break; 119 default: 120 return -EINVAL; 121 } 122 123 shift = ffs(rdesc->mode_mask) - 1; 124 return regmap_update_bits(rdev->regmap, rdesc->mode_reg, 125 rdesc->mode_mask, val << shift); 126 } 127 128 static unsigned int rtq2208_get_mode(struct regulator_dev *rdev) 129 { 130 const struct rtq2208_regulator_desc *rdesc = 131 (const struct rtq2208_regulator_desc *)rdev->desc; 132 unsigned int mode_val; 133 int ret; 134 135 ret = regmap_read(rdev->regmap, rdesc->mode_reg, &mode_val); 136 if (ret) 137 return REGULATOR_MODE_INVALID; 138 139 return (mode_val & rdesc->mode_mask) ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL; 140 } 141 142 static int rtq2208_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay) 143 { 144 const struct regulator_desc *desc = rdev->desc; 145 unsigned int sel = 0, val; 146 147 ramp_delay = max(ramp_delay, RTQ2208_RAMP_VALUE_MIN_uV); 148 ramp_delay = min(ramp_delay, RTQ2208_RAMP_VALUE_MAX_uV); 149 150 ramp_delay /= RTQ2208_RAMP_VALUE_MIN_uV; 151 152 /* 153 * fls(ramp_delay) - 1: doing LSB shift, let it starts from 0 154 * 155 * RTQ2208_BUCK_RAMP_SEL_MASK - sel: doing descending order shifting. 156 * Because the relation of seleltion and value is like that 157 * 158 * seletion: value 159 * 010: 16mv 160 * ... 161 * 111: 0.5mv 162 * 163 * For example, if I would like to select 16mv, the fls(ramp_delay) - 1 will be 0b010, 164 * and I need to use 0b111 - sel to do the shifting 165 */ 166 167 sel = fls(ramp_delay) - 1; 168 sel = RTQ2208_BUCK_RAMP_SEL_MASK - sel; 169 170 val = FIELD_PREP(RTQ2208_BUCK_RSPUP_MASK, sel) | FIELD_PREP(RTQ2208_BUCK_RSPDN_MASK, sel); 171 172 return regmap_update_bits(rdev->regmap, desc->ramp_reg, 173 RTQ2208_BUCK_RSPUP_MASK | RTQ2208_BUCK_RSPDN_MASK, val); 174 } 175 176 static int rtq2208_set_suspend_enable(struct regulator_dev *rdev) 177 { 178 const struct rtq2208_regulator_desc *rdesc = 179 (const struct rtq2208_regulator_desc *)rdev->desc; 180 181 return regmap_set_bits(rdev->regmap, rdesc->suspend_config_reg, rdesc->suspend_enable_mask); 182 } 183 184 static int rtq2208_set_suspend_disable(struct regulator_dev *rdev) 185 { 186 const struct rtq2208_regulator_desc *rdesc = 187 (const struct rtq2208_regulator_desc *)rdev->desc; 188 189 return regmap_update_bits(rdev->regmap, rdesc->suspend_config_reg, rdesc->suspend_enable_mask, 0); 190 } 191 192 static int rtq2208_set_suspend_mode(struct regulator_dev *rdev, unsigned int mode) 193 { 194 const struct rtq2208_regulator_desc *rdesc = 195 (const struct rtq2208_regulator_desc *)rdev->desc; 196 unsigned int val, shift; 197 198 switch (mode) { 199 case REGULATOR_MODE_NORMAL: 200 val = RTQ2208_AUTO_MODE; 201 break; 202 case REGULATOR_MODE_FAST: 203 val = RTQ2208_FCCM; 204 break; 205 default: 206 return -EINVAL; 207 } 208 209 shift = ffs(rdesc->suspend_mode_mask) - 1; 210 211 return regmap_update_bits(rdev->regmap, rdesc->suspend_config_reg, 212 rdesc->suspend_mode_mask, val << shift); 213 } 214 215 static const struct regulator_ops rtq2208_regulator_buck_ops = { 216 .enable = regulator_enable_regmap, 217 .disable = regulator_disable_regmap, 218 .is_enabled = regulator_is_enabled_regmap, 219 .list_voltage = regulator_list_voltage_linear_range, 220 .set_voltage_sel = regulator_set_voltage_sel_regmap, 221 .get_voltage_sel = regulator_get_voltage_sel_regmap, 222 .set_mode = rtq2208_set_mode, 223 .get_mode = rtq2208_get_mode, 224 .set_ramp_delay = rtq2208_set_ramp_delay, 225 .set_active_discharge = regulator_set_active_discharge_regmap, 226 .set_suspend_enable = rtq2208_set_suspend_enable, 227 .set_suspend_disable = rtq2208_set_suspend_disable, 228 .set_suspend_mode = rtq2208_set_suspend_mode, 229 }; 230 231 static const struct regulator_ops rtq2208_regulator_ldo_fix_ops = { 232 .enable = regulator_enable_regmap, 233 .disable = regulator_disable_regmap, 234 .is_enabled = regulator_is_enabled_regmap, 235 .set_active_discharge = regulator_set_active_discharge_regmap, 236 .set_suspend_enable = rtq2208_set_suspend_enable, 237 .set_suspend_disable = rtq2208_set_suspend_disable, 238 }; 239 240 static const struct regulator_ops rtq2208_regulator_ldo_adj_ops = { 241 .enable = regulator_enable_regmap, 242 .disable = regulator_disable_regmap, 243 .is_enabled = regulator_is_enabled_regmap, 244 .list_voltage = regulator_list_voltage_table, 245 .set_voltage_sel = regulator_set_voltage_sel_regmap, 246 .get_voltage_sel = regulator_get_voltage_sel_regmap, 247 .set_active_discharge = regulator_set_active_discharge_regmap, 248 .set_suspend_enable = rtq2208_set_suspend_enable, 249 .set_suspend_disable = rtq2208_set_suspend_disable, 250 }; 251 252 static const unsigned int rtq2208_ldo_volt_table[] = { 253 1800000, 254 3300000, 255 }; 256 257 static unsigned int rtq2208_of_map_mode(unsigned int mode) 258 { 259 switch (mode) { 260 case RTQ2208_AUTO_MODE: 261 return REGULATOR_MODE_NORMAL; 262 case RTQ2208_FCCM: 263 return REGULATOR_MODE_FAST; 264 default: 265 return REGULATOR_MODE_INVALID; 266 } 267 } 268 269 static int rtq2208_init_irq_mask(struct rtq2208_rdev_map *rdev_map, unsigned int *buck_masks) 270 { 271 unsigned char buck_clr_masks[5] = {0x33, 0x33, 0x33, 0x33, 0x33}, 272 sts_clr_masks[2] = {0xE7, 0xF7}, sts_masks[2] = {0xE6, 0xF6}; 273 int ret; 274 275 /* write clear all buck irq once */ 276 ret = regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB, buck_clr_masks, 5); 277 if (ret) 278 return dev_err_probe(rdev_map->dev, ret, "Failed to clr buck irqs\n"); 279 280 /* write clear general irq once */ 281 ret = regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1, sts_clr_masks, 2); 282 if (ret) 283 return dev_err_probe(rdev_map->dev, ret, "Failed to clr general irqs\n"); 284 285 /* unmask buck ov/uv irq */ 286 ret = regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_FLT_MASKBUCK_CB, buck_masks, 5); 287 if (ret) 288 return dev_err_probe(rdev_map->dev, ret, "Failed to unmask buck irqs\n"); 289 290 /* unmask needed general irq */ 291 return regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1_MASK, sts_masks, 2); 292 } 293 294 static irqreturn_t rtq2208_irq_handler(int irqno, void *devid) 295 { 296 unsigned char buck_flags[RTQ2208_BUCK_NUM_IRQ_REGS], sts_flags[RTQ2208_STS_NUM_IRQ_REGS]; 297 int ret = 0, i, uv_bit, ov_bit; 298 struct rtq2208_rdev_map *rdev_map = devid; 299 struct regulator_dev *rdev; 300 301 if (!rdev_map) 302 return IRQ_NONE; 303 304 /* read irq event */ 305 ret = regmap_bulk_read(rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB, 306 buck_flags, ARRAY_SIZE(buck_flags)); 307 if (ret) 308 return IRQ_NONE; 309 310 ret = regmap_bulk_read(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1, 311 sts_flags, ARRAY_SIZE(sts_flags)); 312 if (ret) 313 return IRQ_NONE; 314 315 /* clear irq event */ 316 ret = regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB, 317 buck_flags, ARRAY_SIZE(buck_flags)); 318 if (ret) 319 return IRQ_NONE; 320 321 ret = regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1, 322 sts_flags, ARRAY_SIZE(sts_flags)); 323 if (ret) 324 return IRQ_NONE; 325 326 for (i = 0; i < RTQ2208_LDO_MAX; i++) { 327 if (!rdev_map->rdev[i]) 328 continue; 329 330 rdev = rdev_map->rdev[i]; 331 /* uv irq */ 332 uv_bit = (i & 1) ? 4 : 0; 333 if (buck_flags[i >> 1] & (1 << uv_bit)) 334 regulator_notifier_call_chain(rdev, 335 REGULATOR_EVENT_UNDER_VOLTAGE, NULL); 336 /* ov irq */ 337 ov_bit = uv_bit + 1; 338 if (buck_flags[i >> 1] & (1 << ov_bit)) 339 regulator_notifier_call_chain(rdev, 340 REGULATOR_EVENT_REGULATION_OUT, NULL); 341 342 /* hd irq */ 343 if (sts_flags[1] & RTQ2208_HD_INT_MASK) 344 regulator_notifier_call_chain(rdev, 345 REGULATOR_EVENT_OVER_TEMP, NULL); 346 } 347 348 return IRQ_HANDLED; 349 } 350 351 #define BUCK_INFO(_name, _id) \ 352 { \ 353 .name = _name, \ 354 .base = RTQ2208_REG_BUCK_##_id##_CFG0, \ 355 .enable_reg = BUCK_RG_SHIFT(RTQ2208_REG_BUCK_##_id##_CFG0, 2), \ 356 .dis_reg = RTQ2208_REG_BUCK_##_id##_CFG0, \ 357 } 358 359 #define LDO_INFO(_name, _id) \ 360 { \ 361 .name = _name, \ 362 .base = RTQ2208_REG_LDO##_id##_CFG, \ 363 .enable_reg = RTQ2208_REG_LDO##_id##_CFG, \ 364 .dis_mask = RTQ2208_LDO##_id##_DISCHG_EN_MASK, \ 365 .dis_on = RTQ2208_LDO##_id##_DISCHG_EN_MASK, \ 366 .vsel_mask = RTQ2208_LDO##_id##_VOSEL_SD_MASK, \ 367 } 368 369 #define BUCK_RG_SHIFT(_base, _shift) (_base + _shift) 370 #define VSEL_SHIFT(_sel) (_sel ? 3 : 1) 371 #define MTP_SEL_MASK(_sel) RTQ2208_BUCK_EN_NR_MTP_SEL##_sel##_MASK 372 373 static const struct linear_range rtq2208_vout_range[] = { 374 REGULATOR_LINEAR_RANGE(400000, 0, 180, 5000), 375 REGULATOR_LINEAR_RANGE(1310000, 181, 255, 10000), 376 }; 377 378 static void rtq2208_init_regulator_desc(struct rtq2208_regulator_desc *rdesc, int mtp_sel, int idx, 379 unsigned int ldo1_fixed, unsigned int ldo2_fixed) 380 { 381 struct regulator_desc *desc; 382 unsigned int fixed_uV; 383 static const struct { 384 char *name; 385 int base; 386 int enable_reg; 387 int dis_reg; 388 int dis_mask; 389 int dis_on; 390 int vsel_mask; 391 } regulator_info[] = { 392 BUCK_INFO("buck-b", B), 393 BUCK_INFO("buck-c", C), 394 BUCK_INFO("buck-d", D), 395 BUCK_INFO("buck-a", A), 396 BUCK_INFO("buck-f", F), 397 BUCK_INFO("buck-g", G), 398 BUCK_INFO("buck-h", H), 399 BUCK_INFO("buck-e", E), 400 LDO_INFO("ldo2", 2), 401 LDO_INFO("ldo1", 1), 402 }, *curr_info; 403 404 curr_info = regulator_info + idx; 405 desc = &rdesc->desc; 406 desc->name = curr_info->name; 407 desc->of_match = of_match_ptr(curr_info->name); 408 desc->regulators_node = of_match_ptr("regulators"); 409 desc->id = idx; 410 desc->owner = THIS_MODULE; 411 desc->type = REGULATOR_VOLTAGE; 412 desc->enable_mask = mtp_sel ? MTP_SEL_MASK(1) : MTP_SEL_MASK(0); 413 desc->enable_reg = curr_info->enable_reg; 414 desc->active_discharge_off = 0; 415 416 rdesc->mode_mask = RTQ2208_BUCK_NRMODE_MASK; 417 418 switch (idx) { 419 case RTQ2208_BUCK_B ... RTQ2208_BUCK_E: 420 /* init buck desc */ 421 desc->ops = &rtq2208_regulator_buck_ops; 422 desc->vsel_reg = curr_info->base + VSEL_SHIFT(mtp_sel); 423 desc->vsel_mask = RTQ2208_BUCK_NR_MTP_SEL_MASK; 424 desc->n_voltages = RTQ2208_VOUT_MAXNUM; 425 desc->linear_ranges = rtq2208_vout_range; 426 desc->n_linear_ranges = ARRAY_SIZE(rtq2208_vout_range); 427 desc->ramp_reg = BUCK_RG_SHIFT(curr_info->base, 5); 428 desc->of_map_mode = rtq2208_of_map_mode; 429 desc->active_discharge_reg = curr_info->dis_reg; 430 desc->active_discharge_on = RTQ2208_EN_DIS_MASK; 431 desc->active_discharge_mask = RTQ2208_EN_DIS_MASK; 432 433 rdesc->mode_reg = BUCK_RG_SHIFT(curr_info->base, 2); 434 rdesc->suspend_config_reg = BUCK_RG_SHIFT(curr_info->base, 4); 435 rdesc->suspend_enable_mask = RTQ2208_BUCK_EN_STR_MASK; 436 rdesc->suspend_mode_mask = RTQ2208_BUCK_STRMODE_MASK; 437 break; 438 default: 439 fixed_uV = idx == RTQ2208_LDO2 ? ldo2_fixed : ldo1_fixed; 440 if (fixed_uV) { 441 desc->n_voltages = 1; 442 desc->fixed_uV = fixed_uV; 443 desc->ops = &rtq2208_regulator_ldo_fix_ops; 444 } else { 445 desc->n_voltages = ARRAY_SIZE(rtq2208_ldo_volt_table); 446 desc->volt_table = rtq2208_ldo_volt_table; 447 desc->ops = &rtq2208_regulator_ldo_adj_ops; 448 } 449 450 /* init ldo desc */ 451 desc->active_discharge_reg = RTQ2208_REG_LDO_DVS_CTRL; 452 desc->active_discharge_on = curr_info->dis_on; 453 desc->active_discharge_mask = curr_info->dis_mask; 454 desc->vsel_reg = RTQ2208_REG_LDO_DVS_CTRL; 455 desc->vsel_mask = curr_info->vsel_mask; 456 457 rdesc->suspend_config_reg = curr_info->base; 458 rdesc->suspend_enable_mask = RTQ2208_LDO_EN_STR_MASK; 459 break; 460 } 461 } 462 463 static int rtq2208_parse_regulator_dt_data(int n_regulator, const unsigned int *regulator_idx_table, 464 struct rtq2208_regulator_desc *rdesc[RTQ2208_LDO_MAX], struct device *dev, 465 unsigned int ldo1_fixed, unsigned int ldo2_fixed) 466 { 467 int mtp_sel, i, idx; 468 469 /* get mtp_sel0 or mtp_sel1 */ 470 mtp_sel = device_property_read_bool(dev, "richtek,mtp-sel-high"); 471 472 for (i = 0; i < n_regulator; i++) { 473 idx = regulator_idx_table[i]; 474 475 rdesc[i] = devm_kcalloc(dev, 1, sizeof(*rdesc[0]), GFP_KERNEL); 476 if (!rdesc[i]) 477 return -ENOMEM; 478 479 rtq2208_init_regulator_desc(rdesc[i], mtp_sel, idx, ldo1_fixed, ldo2_fixed); 480 } 481 482 return 0; 483 484 } 485 486 static int rtq2208_regulator_check(struct device *dev, int *num, int *regulator_idx_table, 487 unsigned int *buck_masks, unsigned int *ldo1_fixed_uV, 488 unsigned int *ldo2_fixed_uV) 489 { 490 struct regmap *regmap = dev_get_regmap(dev, NULL); 491 bool rtq2208_used_table[RTQ2208_LDO_MAX] = {0}; 492 u8 entry_key[] = { 0x69, 0x01 }; 493 unsigned int buck_phase, ldo_cfg0, ldo_cfg1; 494 int i, ret; 495 u8 mask; 496 497 ret = regmap_raw_write(regmap, RTQ2208_REG_HIDDEN0, entry_key, ARRAY_SIZE(entry_key)); 498 if (ret) 499 return dev_err_probe(dev, ret, "Failed to enter hidden page\n"); 500 501 ret = regmap_read(regmap, RTQ2208_REG_HIDDEN_BUCKPH, &buck_phase); 502 if (ret) 503 return dev_err_probe(dev, ret, "Failed to read buck phase configuration\n"); 504 505 ret = regmap_read(regmap, RTQ2208_REG_HIDDEN_LDOCFG0, &ldo_cfg0); 506 if (ret) 507 return dev_err_probe(dev, ret, "Failed to read ldo cfg0\n"); 508 509 ret = regmap_read(regmap, RTQ2208_REG_HIDDEN_LDOCFG1, &ldo_cfg1); 510 if (ret) 511 return dev_err_probe(dev, ret, "Failed to read ldo cfg1\n"); 512 513 ret = regmap_write(regmap, RTQ2208_REG_HIDDEN1, 0x00); 514 if (ret) 515 return dev_err_probe(dev, ret, "Failed to exit hidden page\n"); 516 517 dev_info(dev, "BUCK Phase 0x%x\n", buck_phase); 518 /* 519 * Use buck phase configuration to assign used table mask 520 * GROUP1 GROUP2 521 * 0 -> 2P + 2P BC FG 522 * 1 -> 2P + 1P + 1P BCA FGE 523 * 2 -> 1P + 1P + 1P + 1P BCDA FGHE 524 * 3 -> 3P + 1P BC FG 525 * others -> 4P C G 526 */ 527 switch (FIELD_GET(RTQ2208_MASK_BUCKPH_GROUP1, buck_phase)) { 528 case 2: 529 rtq2208_used_table[RTQ2208_BUCK_D] = true; 530 fallthrough; 531 case 1: 532 rtq2208_used_table[RTQ2208_BUCK_A] = true; 533 fallthrough; 534 case 0: 535 case 3: 536 rtq2208_used_table[RTQ2208_BUCK_B] = true; 537 fallthrough; 538 default: 539 rtq2208_used_table[RTQ2208_BUCK_C] = true; 540 break; 541 } 542 543 switch (FIELD_GET(RTQ2208_MASK_BUCKPH_GROUP2, buck_phase)) { 544 case 2: 545 rtq2208_used_table[RTQ2208_BUCK_H] = true; 546 fallthrough; 547 case 1: 548 rtq2208_used_table[RTQ2208_BUCK_E] = true; 549 fallthrough; 550 case 0: 551 case 3: 552 rtq2208_used_table[RTQ2208_BUCK_F] = true; 553 fallthrough; 554 default: 555 rtq2208_used_table[RTQ2208_BUCK_G] = true; 556 break; 557 } 558 559 *ldo1_fixed_uV = FIELD_GET(RTQ2208_MASK_LDO1_FIXED, ldo_cfg1) ? 1200000 : 0; 560 561 if (!FIELD_GET(RTQ2208_MASK_LDO2_OPT0, ldo_cfg0) && 562 !FIELD_GET(RTQ2208_MASK_LDO2_OPT1, ldo_cfg1)) 563 *ldo2_fixed_uV = 0; 564 else if (FIELD_GET(RTQ2208_MASK_LDO2_OPT1, ldo_cfg1)) 565 *ldo2_fixed_uV = 900000; 566 else 567 *ldo2_fixed_uV = 1200000; 568 569 /* By default, LDO1 & LDO2 are always used */ 570 rtq2208_used_table[RTQ2208_LDO1] = rtq2208_used_table[RTQ2208_LDO2] = true; 571 572 for (i = 0; i < RTQ2208_LDO_MAX; i++) { 573 if (!rtq2208_used_table[i]) 574 continue; 575 576 regulator_idx_table[(*num)++] = i; 577 578 mask = RTQ2208_BUCK_MASK(4 * i, 4 * i + 1); 579 buck_masks[i >> 1] &= ~mask; 580 } 581 582 return 0; 583 } 584 585 static const struct regmap_config rtq2208_regmap_config = { 586 .reg_bits = 8, 587 .val_bits = 8, 588 .max_register = 0xFF, 589 }; 590 591 static int rtq2208_probe(struct i2c_client *i2c) 592 { 593 struct device *dev = &i2c->dev; 594 struct regmap *regmap; 595 struct rtq2208_regulator_desc *rdesc[RTQ2208_LDO_MAX]; 596 struct regulator_dev *rdev; 597 struct regulator_config cfg = {}; 598 struct rtq2208_rdev_map *rdev_map; 599 int i, ret = 0, idx, n_regulator = 0; 600 unsigned int regulator_idx_table[RTQ2208_LDO_MAX], 601 buck_masks[RTQ2208_BUCK_NUM_IRQ_REGS] = {0x33, 0x33, 0x33, 0x33, 0x33}; 602 unsigned int ldo1_fixed_uV, ldo2_fixed_uV; 603 604 rdev_map = devm_kzalloc(dev, sizeof(struct rtq2208_rdev_map), GFP_KERNEL); 605 if (!rdev_map) 606 return -ENOMEM; 607 608 regmap = devm_regmap_init_i2c(i2c, &rtq2208_regmap_config); 609 if (IS_ERR(regmap)) 610 return dev_err_probe(dev, PTR_ERR(regmap), "Failed to allocate regmap\n"); 611 612 /* get needed regulator */ 613 ret = rtq2208_regulator_check(dev, &n_regulator, regulator_idx_table, buck_masks, 614 &ldo1_fixed_uV, &ldo2_fixed_uV); 615 if (ret) 616 return dev_err_probe(dev, ret, "Failed to check used regulators\n"); 617 618 rdev_map->regmap = regmap; 619 rdev_map->dev = dev; 620 621 cfg.dev = dev; 622 623 /* init regulator desc */ 624 ret = rtq2208_parse_regulator_dt_data(n_regulator, regulator_idx_table, rdesc, dev, 625 ldo1_fixed_uV, ldo2_fixed_uV); 626 if (ret) 627 return ret; 628 629 for (i = 0; i < n_regulator; i++) { 630 idx = regulator_idx_table[i]; 631 632 /* register regulator */ 633 rdev = devm_regulator_register(dev, &rdesc[i]->desc, &cfg); 634 if (IS_ERR(rdev)) 635 return PTR_ERR(rdev); 636 637 rdev_map->rdev[idx] = rdev; 638 } 639 640 /* init interrupt mask */ 641 ret = rtq2208_init_irq_mask(rdev_map, buck_masks); 642 if (ret) 643 return ret; 644 645 /* register interrupt */ 646 return devm_request_threaded_irq(dev, i2c->irq, NULL, rtq2208_irq_handler, 647 IRQF_ONESHOT, dev_name(dev), rdev_map); 648 } 649 650 static const struct of_device_id rtq2208_device_tables[] = { 651 { .compatible = "richtek,rtq2208" }, 652 {} 653 }; 654 MODULE_DEVICE_TABLE(of, rtq2208_device_tables); 655 656 static struct i2c_driver rtq2208_driver = { 657 .driver = { 658 .name = "rtq2208", 659 .of_match_table = rtq2208_device_tables, 660 }, 661 .probe = rtq2208_probe, 662 }; 663 module_i2c_driver(rtq2208_driver); 664 665 MODULE_AUTHOR("Alina Yu <alina_yu@richtek.com>"); 666 MODULE_DESCRIPTION("Richtek RTQ2208 Regulator Driver"); 667 MODULE_LICENSE("GPL"); 668