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