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