639 lines · c
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 0x1216#define RTQ2208_REG_FLT_RECORDBUCK_CB 0x1817#define RTQ2208_REG_GLOBAL_INT1_MASK 0x1D18#define RTQ2208_REG_FLT_MASKBUCK_CB 0x1F19#define RTQ2208_REG_BUCK_C_CFG0 0x3220#define RTQ2208_REG_BUCK_B_CFG0 0x4221#define RTQ2208_REG_BUCK_A_CFG0 0x5222#define RTQ2208_REG_BUCK_D_CFG0 0x6223#define RTQ2208_REG_BUCK_G_CFG0 0x7224#define RTQ2208_REG_BUCK_F_CFG0 0x8225#define RTQ2208_REG_BUCK_E_CFG0 0x9226#define RTQ2208_REG_BUCK_H_CFG0 0xA227#define RTQ2208_REG_LDO1_CFG 0xB128#define RTQ2208_REG_LDO2_CFG 0xC129#define RTQ2208_REG_LDO_DVS_CTRL 0xD030 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 25651#define RTQ2208_BUCK_NUM_IRQ_REGS 552#define RTQ2208_STS_NUM_IRQ_REGS 253 54/* Value */55#define RTQ2208_RAMP_VALUE_MIN_uV 50056#define RTQ2208_RAMP_VALUE_MAX_uV 1600057 58#define RTQ2208_BUCK_MASK(uv_irq, ov_irq) (1 << ((uv_irq) % 8) | 1 << ((ov_irq) % 8))59 60enum {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 74enum {75 RTQ2208_AUTO_MODE = 0,76 RTQ2208_FCCM,77};78 79struct 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 90struct 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 */97static 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 119static 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 133static 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 0145 *146 * RTQ2208_BUCK_RAMP_SEL_MASK - sel: doing descending order shifting.147 * Because the relation of seleltion and value is like that148 *149 * seletion: value150 * 010: 16mv151 * ...152 * 111: 0.5mv153 *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 shifting156 */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 167static 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 175static 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 183static 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 206static 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 222static 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 231static 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 243static const unsigned int rtq2208_ldo_volt_table[] = {244 1800000,245 3300000,246};247 248static struct of_regulator_match rtq2208_ldo_match[] = {249 {.name = "ldo2", },250 {.name = "ldo1", },251};252 253static 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 265static 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 290static 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 347static 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##_MASK421 422static 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 427static 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 496static 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 bucks528 * slave address 0x10: BUCK[BCA FGE]529 * slave address 0x20: BUCK[BC FGHE]530 * slave address 0x40: BUCK[C G]531 */532static 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 559static const struct regmap_config rtq2208_regmap_config = {560 .reg_bits = 8,561 .val_bits = 8,562 .max_register = 0xEF,563};564 565static 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 621static const struct of_device_id rtq2208_device_tables[] = {622 { .compatible = "richtek,rtq2208" },623 {}624};625MODULE_DEVICE_TABLE(of, rtq2208_device_tables);626 627static struct i2c_driver rtq2208_driver = {628 .driver = {629 .name = "rtq2208",630 .of_match_table = rtq2208_device_tables,631 },632 .probe = rtq2208_probe,633};634module_i2c_driver(rtq2208_driver);635 636MODULE_AUTHOR("Alina Yu <alina_yu@richtek.com>");637MODULE_DESCRIPTION("Richtek RTQ2208 Regulator Driver");638MODULE_LICENSE("GPL");639