drivers/regulator/rtq2208-regulator.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                 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");