Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // max8997.c - Regulator driver for the Maxim 8997/8966
0004 //
0005 // Copyright (C) 2011 Samsung Electronics
0006 // MyungJoo Ham <myungjoo.ham@samsung.com>
0007 //
0008 // This driver is based on max8998.c
0009 
0010 #include <linux/bug.h>
0011 #include <linux/err.h>
0012 #include <linux/gpio.h>
0013 #include <linux/of_gpio.h>
0014 #include <linux/slab.h>
0015 #include <linux/module.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/regulator/driver.h>
0018 #include <linux/regulator/machine.h>
0019 #include <linux/mfd/max8997.h>
0020 #include <linux/mfd/max8997-private.h>
0021 #include <linux/regulator/of_regulator.h>
0022 
0023 struct max8997_data {
0024     struct device *dev;
0025     struct max8997_dev *iodev;
0026     int num_regulators;
0027     int ramp_delay; /* in mV/us */
0028 
0029     bool buck1_gpiodvs;
0030     bool buck2_gpiodvs;
0031     bool buck5_gpiodvs;
0032     u8 buck1_vol[8];
0033     u8 buck2_vol[8];
0034     u8 buck5_vol[8];
0035     int buck125_gpios[3];
0036     int buck125_gpioindex;
0037     bool ignore_gpiodvs_side_effect;
0038 
0039     u8 saved_states[MAX8997_REG_MAX];
0040 };
0041 
0042 static const unsigned int safeoutvolt[] = {
0043     4850000,
0044     4900000,
0045     4950000,
0046     3300000,
0047 };
0048 
0049 static inline void max8997_set_gpio(struct max8997_data *max8997)
0050 {
0051     int set3 = (max8997->buck125_gpioindex) & 0x1;
0052     int set2 = ((max8997->buck125_gpioindex) >> 1) & 0x1;
0053     int set1 = ((max8997->buck125_gpioindex) >> 2) & 0x1;
0054 
0055     gpio_set_value(max8997->buck125_gpios[0], set1);
0056     gpio_set_value(max8997->buck125_gpios[1], set2);
0057     gpio_set_value(max8997->buck125_gpios[2], set3);
0058 }
0059 
0060 struct voltage_map_desc {
0061     int min;
0062     int max;
0063     int step;
0064 };
0065 
0066 /* Voltage maps in uV */
0067 static const struct voltage_map_desc ldo_voltage_map_desc = {
0068     .min = 800000,  .max = 3950000, .step = 50000,
0069 }; /* LDO1 ~ 18, 21 all */
0070 
0071 static const struct voltage_map_desc buck1245_voltage_map_desc = {
0072     .min = 650000,  .max = 2225000, .step = 25000,
0073 }; /* Buck1, 2, 4, 5 */
0074 
0075 static const struct voltage_map_desc buck37_voltage_map_desc = {
0076     .min = 750000,  .max = 3900000, .step = 50000,
0077 }; /* Buck3, 7 */
0078 
0079 /* current map in uA */
0080 static const struct voltage_map_desc charger_current_map_desc = {
0081     .min = 200000,  .max = 950000,  .step = 50000,
0082 };
0083 
0084 static const struct voltage_map_desc topoff_current_map_desc = {
0085     .min = 50000,   .max = 200000,  .step = 10000,
0086 };
0087 
0088 static const struct voltage_map_desc *reg_voltage_map[] = {
0089     [MAX8997_LDO1] = &ldo_voltage_map_desc,
0090     [MAX8997_LDO2] = &ldo_voltage_map_desc,
0091     [MAX8997_LDO3] = &ldo_voltage_map_desc,
0092     [MAX8997_LDO4] = &ldo_voltage_map_desc,
0093     [MAX8997_LDO5] = &ldo_voltage_map_desc,
0094     [MAX8997_LDO6] = &ldo_voltage_map_desc,
0095     [MAX8997_LDO7] = &ldo_voltage_map_desc,
0096     [MAX8997_LDO8] = &ldo_voltage_map_desc,
0097     [MAX8997_LDO9] = &ldo_voltage_map_desc,
0098     [MAX8997_LDO10] = &ldo_voltage_map_desc,
0099     [MAX8997_LDO11] = &ldo_voltage_map_desc,
0100     [MAX8997_LDO12] = &ldo_voltage_map_desc,
0101     [MAX8997_LDO13] = &ldo_voltage_map_desc,
0102     [MAX8997_LDO14] = &ldo_voltage_map_desc,
0103     [MAX8997_LDO15] = &ldo_voltage_map_desc,
0104     [MAX8997_LDO16] = &ldo_voltage_map_desc,
0105     [MAX8997_LDO17] = &ldo_voltage_map_desc,
0106     [MAX8997_LDO18] = &ldo_voltage_map_desc,
0107     [MAX8997_LDO21] = &ldo_voltage_map_desc,
0108     [MAX8997_BUCK1] = &buck1245_voltage_map_desc,
0109     [MAX8997_BUCK2] = &buck1245_voltage_map_desc,
0110     [MAX8997_BUCK3] = &buck37_voltage_map_desc,
0111     [MAX8997_BUCK4] = &buck1245_voltage_map_desc,
0112     [MAX8997_BUCK5] = &buck1245_voltage_map_desc,
0113     [MAX8997_BUCK6] = NULL,
0114     [MAX8997_BUCK7] = &buck37_voltage_map_desc,
0115     [MAX8997_EN32KHZ_AP] = NULL,
0116     [MAX8997_EN32KHZ_CP] = NULL,
0117     [MAX8997_ENVICHG] = NULL,
0118     [MAX8997_ESAFEOUT1] = NULL,
0119     [MAX8997_ESAFEOUT2] = NULL,
0120     [MAX8997_CHARGER_CV] = NULL,
0121     [MAX8997_CHARGER] = &charger_current_map_desc,
0122     [MAX8997_CHARGER_TOPOFF] = &topoff_current_map_desc,
0123 };
0124 
0125 static int max8997_list_voltage_charger_cv(struct regulator_dev *rdev,
0126         unsigned int selector)
0127 {
0128     int rid = rdev_get_id(rdev);
0129 
0130     if (rid != MAX8997_CHARGER_CV)
0131         goto err;
0132 
0133     switch (selector) {
0134     case 0x00:
0135         return 4200000;
0136     case 0x01 ... 0x0E:
0137         return 4000000 + 20000 * (selector - 0x01);
0138     case 0x0F:
0139         return 4350000;
0140     default:
0141         return -EINVAL;
0142     }
0143 err:
0144     return -EINVAL;
0145 }
0146 
0147 static int max8997_list_voltage(struct regulator_dev *rdev,
0148         unsigned int selector)
0149 {
0150     const struct voltage_map_desc *desc;
0151     int rid = rdev_get_id(rdev);
0152     int val;
0153 
0154     if (rid < 0 || rid >= ARRAY_SIZE(reg_voltage_map))
0155         return -EINVAL;
0156 
0157     desc = reg_voltage_map[rid];
0158     if (desc == NULL)
0159         return -EINVAL;
0160 
0161     val = desc->min + desc->step * selector;
0162     if (val > desc->max)
0163         return -EINVAL;
0164 
0165     return val;
0166 }
0167 
0168 static int max8997_get_enable_register(struct regulator_dev *rdev,
0169         int *reg, int *mask, int *pattern)
0170 {
0171     int rid = rdev_get_id(rdev);
0172 
0173     switch (rid) {
0174     case MAX8997_LDO1 ... MAX8997_LDO21:
0175         *reg = MAX8997_REG_LDO1CTRL + (rid - MAX8997_LDO1);
0176         *mask = 0xC0;
0177         *pattern = 0xC0;
0178         break;
0179     case MAX8997_BUCK1:
0180         *reg = MAX8997_REG_BUCK1CTRL;
0181         *mask = 0x01;
0182         *pattern = 0x01;
0183         break;
0184     case MAX8997_BUCK2:
0185         *reg = MAX8997_REG_BUCK2CTRL;
0186         *mask = 0x01;
0187         *pattern = 0x01;
0188         break;
0189     case MAX8997_BUCK3:
0190         *reg = MAX8997_REG_BUCK3CTRL;
0191         *mask = 0x01;
0192         *pattern = 0x01;
0193         break;
0194     case MAX8997_BUCK4:
0195         *reg = MAX8997_REG_BUCK4CTRL;
0196         *mask = 0x01;
0197         *pattern = 0x01;
0198         break;
0199     case MAX8997_BUCK5:
0200         *reg = MAX8997_REG_BUCK5CTRL;
0201         *mask = 0x01;
0202         *pattern = 0x01;
0203         break;
0204     case MAX8997_BUCK6:
0205         *reg = MAX8997_REG_BUCK6CTRL;
0206         *mask = 0x01;
0207         *pattern = 0x01;
0208         break;
0209     case MAX8997_BUCK7:
0210         *reg = MAX8997_REG_BUCK7CTRL;
0211         *mask = 0x01;
0212         *pattern = 0x01;
0213         break;
0214     case MAX8997_EN32KHZ_AP ... MAX8997_EN32KHZ_CP:
0215         *reg = MAX8997_REG_MAINCON1;
0216         *mask = 0x01 << (rid - MAX8997_EN32KHZ_AP);
0217         *pattern = 0x01 << (rid - MAX8997_EN32KHZ_AP);
0218         break;
0219     case MAX8997_ENVICHG:
0220         *reg = MAX8997_REG_MBCCTRL1;
0221         *mask = 0x80;
0222         *pattern = 0x80;
0223         break;
0224     case MAX8997_ESAFEOUT1 ... MAX8997_ESAFEOUT2:
0225         *reg = MAX8997_REG_SAFEOUTCTRL;
0226         *mask = 0x40 << (rid - MAX8997_ESAFEOUT1);
0227         *pattern = 0x40 << (rid - MAX8997_ESAFEOUT1);
0228         break;
0229     case MAX8997_CHARGER:
0230         *reg = MAX8997_REG_MBCCTRL2;
0231         *mask = 0x40;
0232         *pattern = 0x40;
0233         break;
0234     default:
0235         /* Not controllable or not exists */
0236         return -EINVAL;
0237     }
0238 
0239     return 0;
0240 }
0241 
0242 static int max8997_reg_is_enabled(struct regulator_dev *rdev)
0243 {
0244     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0245     struct i2c_client *i2c = max8997->iodev->i2c;
0246     int ret, reg, mask, pattern;
0247     u8 val;
0248 
0249     ret = max8997_get_enable_register(rdev, &reg, &mask, &pattern);
0250     if (ret)
0251         return ret;
0252 
0253     ret = max8997_read_reg(i2c, reg, &val);
0254     if (ret)
0255         return ret;
0256 
0257     return (val & mask) == pattern;
0258 }
0259 
0260 static int max8997_reg_enable(struct regulator_dev *rdev)
0261 {
0262     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0263     struct i2c_client *i2c = max8997->iodev->i2c;
0264     int ret, reg, mask, pattern;
0265 
0266     ret = max8997_get_enable_register(rdev, &reg, &mask, &pattern);
0267     if (ret)
0268         return ret;
0269 
0270     return max8997_update_reg(i2c, reg, pattern, mask);
0271 }
0272 
0273 static int max8997_reg_disable(struct regulator_dev *rdev)
0274 {
0275     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0276     struct i2c_client *i2c = max8997->iodev->i2c;
0277     int ret, reg, mask, pattern;
0278 
0279     ret = max8997_get_enable_register(rdev, &reg, &mask, &pattern);
0280     if (ret)
0281         return ret;
0282 
0283     return max8997_update_reg(i2c, reg, ~pattern, mask);
0284 }
0285 
0286 static int max8997_get_voltage_register(struct regulator_dev *rdev,
0287         int *_reg, int *_shift, int *_mask)
0288 {
0289     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0290     int rid = rdev_get_id(rdev);
0291     int reg, shift = 0, mask = 0x3f;
0292 
0293     switch (rid) {
0294     case MAX8997_LDO1 ... MAX8997_LDO21:
0295         reg = MAX8997_REG_LDO1CTRL + (rid - MAX8997_LDO1);
0296         break;
0297     case MAX8997_BUCK1:
0298         reg = MAX8997_REG_BUCK1DVS1;
0299         if (max8997->buck1_gpiodvs)
0300             reg += max8997->buck125_gpioindex;
0301         break;
0302     case MAX8997_BUCK2:
0303         reg = MAX8997_REG_BUCK2DVS1;
0304         if (max8997->buck2_gpiodvs)
0305             reg += max8997->buck125_gpioindex;
0306         break;
0307     case MAX8997_BUCK3:
0308         reg = MAX8997_REG_BUCK3DVS;
0309         break;
0310     case MAX8997_BUCK4:
0311         reg = MAX8997_REG_BUCK4DVS;
0312         break;
0313     case MAX8997_BUCK5:
0314         reg = MAX8997_REG_BUCK5DVS1;
0315         if (max8997->buck5_gpiodvs)
0316             reg += max8997->buck125_gpioindex;
0317         break;
0318     case MAX8997_BUCK7:
0319         reg = MAX8997_REG_BUCK7DVS;
0320         break;
0321     case MAX8997_ESAFEOUT1 ...  MAX8997_ESAFEOUT2:
0322         reg = MAX8997_REG_SAFEOUTCTRL;
0323         shift = (rid == MAX8997_ESAFEOUT2) ? 2 : 0;
0324         mask = 0x3;
0325         break;
0326     case MAX8997_CHARGER_CV:
0327         reg = MAX8997_REG_MBCCTRL3;
0328         shift = 0;
0329         mask = 0xf;
0330         break;
0331     case MAX8997_CHARGER:
0332         reg = MAX8997_REG_MBCCTRL4;
0333         shift = 0;
0334         mask = 0xf;
0335         break;
0336     case MAX8997_CHARGER_TOPOFF:
0337         reg = MAX8997_REG_MBCCTRL5;
0338         shift = 0;
0339         mask = 0xf;
0340         break;
0341     default:
0342         return -EINVAL;
0343     }
0344 
0345     *_reg = reg;
0346     *_shift = shift;
0347     *_mask = mask;
0348 
0349     return 0;
0350 }
0351 
0352 static int max8997_get_voltage_sel(struct regulator_dev *rdev)
0353 {
0354     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0355     struct i2c_client *i2c = max8997->iodev->i2c;
0356     int reg, shift, mask, ret;
0357     u8 val;
0358 
0359     ret = max8997_get_voltage_register(rdev, &reg, &shift, &mask);
0360     if (ret)
0361         return ret;
0362 
0363     ret = max8997_read_reg(i2c, reg, &val);
0364     if (ret)
0365         return ret;
0366 
0367     val >>= shift;
0368     val &= mask;
0369 
0370     return val;
0371 }
0372 
0373 static inline int max8997_get_voltage_proper_val(
0374         const struct voltage_map_desc *desc,
0375         int min_vol, int max_vol)
0376 {
0377     int i;
0378 
0379     if (desc == NULL)
0380         return -EINVAL;
0381 
0382     if (max_vol < desc->min || min_vol > desc->max)
0383         return -EINVAL;
0384 
0385     if (min_vol < desc->min)
0386         min_vol = desc->min;
0387 
0388     i = DIV_ROUND_UP(min_vol - desc->min, desc->step);
0389 
0390     if (desc->min + desc->step * i > max_vol)
0391         return -EINVAL;
0392 
0393     return i;
0394 }
0395 
0396 static int max8997_set_voltage_charger_cv(struct regulator_dev *rdev,
0397         int min_uV, int max_uV, unsigned *selector)
0398 {
0399     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0400     struct i2c_client *i2c = max8997->iodev->i2c;
0401     int rid = rdev_get_id(rdev);
0402     int lb, ub;
0403     int reg, shift = 0, mask, ret = 0;
0404     u8 val = 0x0;
0405 
0406     if (rid != MAX8997_CHARGER_CV)
0407         return -EINVAL;
0408 
0409     ret = max8997_get_voltage_register(rdev, &reg, &shift, &mask);
0410     if (ret)
0411         return ret;
0412 
0413     if (max_uV < 4000000 || min_uV > 4350000)
0414         return -EINVAL;
0415 
0416     if (min_uV <= 4000000)
0417         val = 0x1;
0418     else if (min_uV <= 4200000 && max_uV >= 4200000)
0419         val = 0x0;
0420     else {
0421         lb = (min_uV - 4000001) / 20000 + 2;
0422         ub = (max_uV - 4000000) / 20000 + 1;
0423 
0424         if (lb > ub)
0425             return -EINVAL;
0426 
0427         if (lb < 0xf)
0428             val = lb;
0429         else {
0430             if (ub >= 0xf)
0431                 val = 0xf;
0432             else
0433                 return -EINVAL;
0434         }
0435     }
0436 
0437     *selector = val;
0438 
0439     ret = max8997_update_reg(i2c, reg, val << shift, mask);
0440 
0441     return ret;
0442 }
0443 
0444 /*
0445  * For LDO1 ~ LDO21, BUCK1~5, BUCK7, CHARGER, CHARGER_TOPOFF
0446  * BUCK1, 2, and 5 are available if they are not controlled by gpio
0447  */
0448 static int max8997_set_voltage_ldobuck(struct regulator_dev *rdev,
0449         int min_uV, int max_uV, unsigned *selector)
0450 {
0451     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0452     struct i2c_client *i2c = max8997->iodev->i2c;
0453     const struct voltage_map_desc *desc;
0454     int rid = rdev_get_id(rdev);
0455     int i, reg, shift, mask, ret;
0456 
0457     switch (rid) {
0458     case MAX8997_LDO1 ... MAX8997_LDO21:
0459         break;
0460     case MAX8997_BUCK1 ... MAX8997_BUCK5:
0461         break;
0462     case MAX8997_BUCK6:
0463         return -EINVAL;
0464     case MAX8997_BUCK7:
0465         break;
0466     case MAX8997_CHARGER:
0467         break;
0468     case MAX8997_CHARGER_TOPOFF:
0469         break;
0470     default:
0471         return -EINVAL;
0472     }
0473 
0474     desc = reg_voltage_map[rid];
0475 
0476     i = max8997_get_voltage_proper_val(desc, min_uV, max_uV);
0477     if (i < 0)
0478         return i;
0479 
0480     ret = max8997_get_voltage_register(rdev, &reg, &shift, &mask);
0481     if (ret)
0482         return ret;
0483 
0484     ret = max8997_update_reg(i2c, reg, i << shift, mask << shift);
0485     *selector = i;
0486 
0487     return ret;
0488 }
0489 
0490 static int max8997_set_voltage_buck_time_sel(struct regulator_dev *rdev,
0491                         unsigned int old_selector,
0492                         unsigned int new_selector)
0493 {
0494     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0495     int rid = rdev_get_id(rdev);
0496     const struct voltage_map_desc *desc = reg_voltage_map[rid];
0497 
0498     /* Delay is required only if the voltage is increasing */
0499     if (old_selector >= new_selector)
0500         return 0;
0501 
0502     /* No need to delay if gpio_dvs_mode */
0503     switch (rid) {
0504     case MAX8997_BUCK1:
0505         if (max8997->buck1_gpiodvs)
0506             return 0;
0507         break;
0508     case MAX8997_BUCK2:
0509         if (max8997->buck2_gpiodvs)
0510             return 0;
0511         break;
0512     case MAX8997_BUCK5:
0513         if (max8997->buck5_gpiodvs)
0514             return 0;
0515         break;
0516     }
0517 
0518     switch (rid) {
0519     case MAX8997_BUCK1:
0520     case MAX8997_BUCK2:
0521     case MAX8997_BUCK4:
0522     case MAX8997_BUCK5:
0523         return DIV_ROUND_UP(desc->step * (new_selector - old_selector),
0524                     max8997->ramp_delay * 1000);
0525     }
0526 
0527     return 0;
0528 }
0529 
0530 /*
0531  * Assess the damage on the voltage setting of BUCK1,2,5 by the change.
0532  *
0533  * When GPIO-DVS mode is used for multiple bucks, changing the voltage value
0534  * of one of the bucks may affect that of another buck, which is the side
0535  * effect of the change (set_voltage). This function examines the GPIO-DVS
0536  * configurations and checks whether such side-effect exists.
0537  */
0538 static int max8997_assess_side_effect(struct regulator_dev *rdev,
0539         u8 new_val, int *best)
0540 {
0541     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0542     int rid = rdev_get_id(rdev);
0543     u8 *buckx_val[3];
0544     bool buckx_gpiodvs[3];
0545     int side_effect[8];
0546     int min_side_effect = INT_MAX;
0547     int i;
0548 
0549     *best = -1;
0550 
0551     switch (rid) {
0552     case MAX8997_BUCK1:
0553         rid = 0;
0554         break;
0555     case MAX8997_BUCK2:
0556         rid = 1;
0557         break;
0558     case MAX8997_BUCK5:
0559         rid = 2;
0560         break;
0561     default:
0562         return -EINVAL;
0563     }
0564 
0565     buckx_val[0] = max8997->buck1_vol;
0566     buckx_val[1] = max8997->buck2_vol;
0567     buckx_val[2] = max8997->buck5_vol;
0568     buckx_gpiodvs[0] = max8997->buck1_gpiodvs;
0569     buckx_gpiodvs[1] = max8997->buck2_gpiodvs;
0570     buckx_gpiodvs[2] = max8997->buck5_gpiodvs;
0571 
0572     for (i = 0; i < 8; i++) {
0573         int others;
0574 
0575         if (new_val != (buckx_val[rid])[i]) {
0576             side_effect[i] = -1;
0577             continue;
0578         }
0579 
0580         side_effect[i] = 0;
0581         for (others = 0; others < 3; others++) {
0582             int diff;
0583 
0584             if (others == rid)
0585                 continue;
0586             if (buckx_gpiodvs[others] == false)
0587                 continue; /* Not affected */
0588             diff = (buckx_val[others])[i] -
0589                 (buckx_val[others])[max8997->buck125_gpioindex];
0590             if (diff > 0)
0591                 side_effect[i] += diff;
0592             else if (diff < 0)
0593                 side_effect[i] -= diff;
0594         }
0595         if (side_effect[i] == 0) {
0596             *best = i;
0597             return 0; /* NO SIDE EFFECT! Use This! */
0598         }
0599         if (side_effect[i] < min_side_effect) {
0600             min_side_effect = side_effect[i];
0601             *best = i;
0602         }
0603     }
0604 
0605     if (*best == -1)
0606         return -EINVAL;
0607 
0608     return side_effect[*best];
0609 }
0610 
0611 /*
0612  * For Buck 1 ~ 5 and 7. If it is not controlled by GPIO, this calls
0613  * max8997_set_voltage_ldobuck to do the job.
0614  */
0615 static int max8997_set_voltage_buck(struct regulator_dev *rdev,
0616         int min_uV, int max_uV, unsigned *selector)
0617 {
0618     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0619     int rid = rdev_get_id(rdev);
0620     const struct voltage_map_desc *desc;
0621     int new_val, new_idx, damage, tmp_val, tmp_idx, tmp_dmg;
0622     bool gpio_dvs_mode = false;
0623 
0624     if (rid < MAX8997_BUCK1 || rid > MAX8997_BUCK7)
0625         return -EINVAL;
0626 
0627     switch (rid) {
0628     case MAX8997_BUCK1:
0629         if (max8997->buck1_gpiodvs)
0630             gpio_dvs_mode = true;
0631         break;
0632     case MAX8997_BUCK2:
0633         if (max8997->buck2_gpiodvs)
0634             gpio_dvs_mode = true;
0635         break;
0636     case MAX8997_BUCK5:
0637         if (max8997->buck5_gpiodvs)
0638             gpio_dvs_mode = true;
0639         break;
0640     }
0641 
0642     if (!gpio_dvs_mode)
0643         return max8997_set_voltage_ldobuck(rdev, min_uV, max_uV,
0644                         selector);
0645 
0646     desc = reg_voltage_map[rid];
0647     new_val = max8997_get_voltage_proper_val(desc, min_uV, max_uV);
0648     if (new_val < 0)
0649         return new_val;
0650 
0651     tmp_dmg = INT_MAX;
0652     tmp_idx = -1;
0653     tmp_val = -1;
0654     do {
0655         damage = max8997_assess_side_effect(rdev, new_val, &new_idx);
0656         if (damage == 0)
0657             goto out;
0658 
0659         if (tmp_dmg > damage) {
0660             tmp_idx = new_idx;
0661             tmp_val = new_val;
0662             tmp_dmg = damage;
0663         }
0664 
0665         new_val++;
0666     } while (desc->min + desc->step * new_val <= desc->max);
0667 
0668     new_idx = tmp_idx;
0669     new_val = tmp_val;
0670 
0671     if (max8997->ignore_gpiodvs_side_effect == false)
0672         return -EINVAL;
0673 
0674     dev_warn(&rdev->dev,
0675         "MAX8997 GPIO-DVS Side Effect Warning: GPIO SET:  %d -> %d\n",
0676         max8997->buck125_gpioindex, tmp_idx);
0677 
0678 out:
0679     if (new_idx < 0 || new_val < 0)
0680         return -EINVAL;
0681 
0682     max8997->buck125_gpioindex = new_idx;
0683     max8997_set_gpio(max8997);
0684     *selector = new_val;
0685 
0686     return 0;
0687 }
0688 
0689 /* For SAFEOUT1 and SAFEOUT2 */
0690 static int max8997_set_voltage_safeout_sel(struct regulator_dev *rdev,
0691                        unsigned selector)
0692 {
0693     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0694     struct i2c_client *i2c = max8997->iodev->i2c;
0695     int rid = rdev_get_id(rdev);
0696     int reg, shift = 0, mask, ret;
0697 
0698     if (rid != MAX8997_ESAFEOUT1 && rid != MAX8997_ESAFEOUT2)
0699         return -EINVAL;
0700 
0701     ret = max8997_get_voltage_register(rdev, &reg, &shift, &mask);
0702     if (ret)
0703         return ret;
0704 
0705     return max8997_update_reg(i2c, reg, selector << shift, mask << shift);
0706 }
0707 
0708 static int max8997_reg_disable_suspend(struct regulator_dev *rdev)
0709 {
0710     struct max8997_data *max8997 = rdev_get_drvdata(rdev);
0711     struct i2c_client *i2c = max8997->iodev->i2c;
0712     int ret, reg, mask, pattern;
0713     int rid = rdev_get_id(rdev);
0714 
0715     ret = max8997_get_enable_register(rdev, &reg, &mask, &pattern);
0716     if (ret)
0717         return ret;
0718 
0719     max8997_read_reg(i2c, reg, &max8997->saved_states[rid]);
0720 
0721     if (rid == MAX8997_LDO1 ||
0722             rid == MAX8997_LDO10 ||
0723             rid == MAX8997_LDO21) {
0724         dev_dbg(&rdev->dev, "Conditional Power-Off for %s\n",
0725                 rdev->desc->name);
0726         return max8997_update_reg(i2c, reg, 0x40, mask);
0727     }
0728 
0729     dev_dbg(&rdev->dev, "Full Power-Off for %s (%xh -> %xh)\n",
0730             rdev->desc->name, max8997->saved_states[rid] & mask,
0731             (~pattern) & mask);
0732     return max8997_update_reg(i2c, reg, ~pattern, mask);
0733 }
0734 
0735 static const struct regulator_ops max8997_ldo_ops = {
0736     .list_voltage       = max8997_list_voltage,
0737     .is_enabled     = max8997_reg_is_enabled,
0738     .enable         = max8997_reg_enable,
0739     .disable        = max8997_reg_disable,
0740     .get_voltage_sel    = max8997_get_voltage_sel,
0741     .set_voltage        = max8997_set_voltage_ldobuck,
0742     .set_suspend_disable    = max8997_reg_disable_suspend,
0743 };
0744 
0745 static const struct regulator_ops max8997_buck_ops = {
0746     .list_voltage       = max8997_list_voltage,
0747     .is_enabled     = max8997_reg_is_enabled,
0748     .enable         = max8997_reg_enable,
0749     .disable        = max8997_reg_disable,
0750     .get_voltage_sel    = max8997_get_voltage_sel,
0751     .set_voltage        = max8997_set_voltage_buck,
0752     .set_voltage_time_sel   = max8997_set_voltage_buck_time_sel,
0753     .set_suspend_disable    = max8997_reg_disable_suspend,
0754 };
0755 
0756 static const struct regulator_ops max8997_fixedvolt_ops = {
0757     .list_voltage       = max8997_list_voltage,
0758     .is_enabled     = max8997_reg_is_enabled,
0759     .enable         = max8997_reg_enable,
0760     .disable        = max8997_reg_disable,
0761     .set_suspend_disable    = max8997_reg_disable_suspend,
0762 };
0763 
0764 static const struct regulator_ops max8997_safeout_ops = {
0765     .list_voltage       = regulator_list_voltage_table,
0766     .is_enabled     = max8997_reg_is_enabled,
0767     .enable         = max8997_reg_enable,
0768     .disable        = max8997_reg_disable,
0769     .get_voltage_sel    = max8997_get_voltage_sel,
0770     .set_voltage_sel    = max8997_set_voltage_safeout_sel,
0771     .set_suspend_disable    = max8997_reg_disable_suspend,
0772 };
0773 
0774 static const struct regulator_ops max8997_fixedstate_ops = {
0775     .list_voltage       = max8997_list_voltage_charger_cv,
0776     .get_voltage_sel    = max8997_get_voltage_sel,
0777     .set_voltage        = max8997_set_voltage_charger_cv,
0778 };
0779 
0780 static int max8997_set_current_limit(struct regulator_dev *rdev,
0781                      int min_uA, int max_uA)
0782 {
0783     unsigned dummy;
0784     int rid = rdev_get_id(rdev);
0785 
0786     if (rid != MAX8997_CHARGER && rid != MAX8997_CHARGER_TOPOFF)
0787         return -EINVAL;
0788 
0789     /* Reuse max8997_set_voltage_ldobuck to set current_limit. */
0790     return max8997_set_voltage_ldobuck(rdev, min_uA, max_uA, &dummy);
0791 }
0792 
0793 static int max8997_get_current_limit(struct regulator_dev *rdev)
0794 {
0795     int sel, rid = rdev_get_id(rdev);
0796 
0797     if (rid != MAX8997_CHARGER && rid != MAX8997_CHARGER_TOPOFF)
0798         return -EINVAL;
0799 
0800     sel = max8997_get_voltage_sel(rdev);
0801     if (sel < 0)
0802         return sel;
0803 
0804     /* Reuse max8997_list_voltage to get current_limit. */
0805     return max8997_list_voltage(rdev, sel);
0806 }
0807 
0808 static const struct regulator_ops max8997_charger_ops = {
0809     .is_enabled     = max8997_reg_is_enabled,
0810     .enable         = max8997_reg_enable,
0811     .disable        = max8997_reg_disable,
0812     .get_current_limit  = max8997_get_current_limit,
0813     .set_current_limit  = max8997_set_current_limit,
0814 };
0815 
0816 static const struct regulator_ops max8997_charger_fixedstate_ops = {
0817     .get_current_limit  = max8997_get_current_limit,
0818     .set_current_limit  = max8997_set_current_limit,
0819 };
0820 
0821 #define MAX8997_VOLTAGE_REGULATOR(_name, _ops) {\
0822     .name       = #_name,       \
0823     .id     = MAX8997_##_name,  \
0824     .ops        = &_ops,        \
0825     .type       = REGULATOR_VOLTAGE,    \
0826     .owner      = THIS_MODULE,      \
0827 }
0828 
0829 #define MAX8997_CURRENT_REGULATOR(_name, _ops) {\
0830     .name       = #_name,       \
0831     .id     = MAX8997_##_name,  \
0832     .ops        = &_ops,        \
0833     .type       = REGULATOR_CURRENT,    \
0834     .owner      = THIS_MODULE,      \
0835 }
0836 
0837 static struct regulator_desc regulators[] = {
0838     MAX8997_VOLTAGE_REGULATOR(LDO1, max8997_ldo_ops),
0839     MAX8997_VOLTAGE_REGULATOR(LDO2, max8997_ldo_ops),
0840     MAX8997_VOLTAGE_REGULATOR(LDO3, max8997_ldo_ops),
0841     MAX8997_VOLTAGE_REGULATOR(LDO4, max8997_ldo_ops),
0842     MAX8997_VOLTAGE_REGULATOR(LDO5, max8997_ldo_ops),
0843     MAX8997_VOLTAGE_REGULATOR(LDO6, max8997_ldo_ops),
0844     MAX8997_VOLTAGE_REGULATOR(LDO7, max8997_ldo_ops),
0845     MAX8997_VOLTAGE_REGULATOR(LDO8, max8997_ldo_ops),
0846     MAX8997_VOLTAGE_REGULATOR(LDO9, max8997_ldo_ops),
0847     MAX8997_VOLTAGE_REGULATOR(LDO10, max8997_ldo_ops),
0848     MAX8997_VOLTAGE_REGULATOR(LDO11, max8997_ldo_ops),
0849     MAX8997_VOLTAGE_REGULATOR(LDO12, max8997_ldo_ops),
0850     MAX8997_VOLTAGE_REGULATOR(LDO13, max8997_ldo_ops),
0851     MAX8997_VOLTAGE_REGULATOR(LDO14, max8997_ldo_ops),
0852     MAX8997_VOLTAGE_REGULATOR(LDO15, max8997_ldo_ops),
0853     MAX8997_VOLTAGE_REGULATOR(LDO16, max8997_ldo_ops),
0854     MAX8997_VOLTAGE_REGULATOR(LDO17, max8997_ldo_ops),
0855     MAX8997_VOLTAGE_REGULATOR(LDO18, max8997_ldo_ops),
0856     MAX8997_VOLTAGE_REGULATOR(LDO21, max8997_ldo_ops),
0857     MAX8997_VOLTAGE_REGULATOR(BUCK1, max8997_buck_ops),
0858     MAX8997_VOLTAGE_REGULATOR(BUCK2, max8997_buck_ops),
0859     MAX8997_VOLTAGE_REGULATOR(BUCK3, max8997_buck_ops),
0860     MAX8997_VOLTAGE_REGULATOR(BUCK4, max8997_buck_ops),
0861     MAX8997_VOLTAGE_REGULATOR(BUCK5, max8997_buck_ops),
0862     MAX8997_VOLTAGE_REGULATOR(BUCK6, max8997_fixedvolt_ops),
0863     MAX8997_VOLTAGE_REGULATOR(BUCK7, max8997_buck_ops),
0864     MAX8997_VOLTAGE_REGULATOR(EN32KHZ_AP, max8997_fixedvolt_ops),
0865     MAX8997_VOLTAGE_REGULATOR(EN32KHZ_CP, max8997_fixedvolt_ops),
0866     MAX8997_VOLTAGE_REGULATOR(ENVICHG, max8997_fixedvolt_ops),
0867     MAX8997_VOLTAGE_REGULATOR(ESAFEOUT1, max8997_safeout_ops),
0868     MAX8997_VOLTAGE_REGULATOR(ESAFEOUT2, max8997_safeout_ops),
0869     MAX8997_VOLTAGE_REGULATOR(CHARGER_CV, max8997_fixedstate_ops),
0870     MAX8997_CURRENT_REGULATOR(CHARGER, max8997_charger_ops),
0871     MAX8997_CURRENT_REGULATOR(CHARGER_TOPOFF,
0872                   max8997_charger_fixedstate_ops),
0873 };
0874 
0875 #ifdef CONFIG_OF
0876 static int max8997_pmic_dt_parse_dvs_gpio(struct platform_device *pdev,
0877             struct max8997_platform_data *pdata,
0878             struct device_node *pmic_np)
0879 {
0880     int i, gpio;
0881 
0882     for (i = 0; i < 3; i++) {
0883         gpio = of_get_named_gpio(pmic_np,
0884                     "max8997,pmic-buck125-dvs-gpios", i);
0885         if (!gpio_is_valid(gpio)) {
0886             dev_err(&pdev->dev, "invalid gpio[%d]: %d\n", i, gpio);
0887             return -EINVAL;
0888         }
0889         pdata->buck125_gpios[i] = gpio;
0890     }
0891     return 0;
0892 }
0893 
0894 static int max8997_pmic_dt_parse_pdata(struct platform_device *pdev,
0895                     struct max8997_platform_data *pdata)
0896 {
0897     struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
0898     struct device_node *pmic_np, *regulators_np, *reg_np;
0899     struct max8997_regulator_data *rdata;
0900     unsigned int i, dvs_voltage_nr = 1, ret;
0901 
0902     pmic_np = iodev->dev->of_node;
0903     if (!pmic_np) {
0904         dev_err(&pdev->dev, "could not find pmic sub-node\n");
0905         return -ENODEV;
0906     }
0907 
0908     regulators_np = of_get_child_by_name(pmic_np, "regulators");
0909     if (!regulators_np) {
0910         dev_err(&pdev->dev, "could not find regulators sub-node\n");
0911         return -EINVAL;
0912     }
0913 
0914     /* count the number of regulators to be supported in pmic */
0915     pdata->num_regulators = of_get_child_count(regulators_np);
0916 
0917     rdata = devm_kcalloc(&pdev->dev,
0918                  pdata->num_regulators, sizeof(*rdata),
0919                  GFP_KERNEL);
0920     if (!rdata) {
0921         of_node_put(regulators_np);
0922         return -ENOMEM;
0923     }
0924 
0925     pdata->regulators = rdata;
0926     for_each_child_of_node(regulators_np, reg_np) {
0927         for (i = 0; i < ARRAY_SIZE(regulators); i++)
0928             if (of_node_name_eq(reg_np, regulators[i].name))
0929                 break;
0930 
0931         if (i == ARRAY_SIZE(regulators)) {
0932             dev_warn(&pdev->dev, "don't know how to configure regulator %pOFn\n",
0933                  reg_np);
0934             continue;
0935         }
0936 
0937         rdata->id = i;
0938         rdata->initdata = of_get_regulator_init_data(&pdev->dev,
0939                                  reg_np,
0940                                  &regulators[i]);
0941         rdata->reg_node = reg_np;
0942         rdata++;
0943     }
0944     of_node_put(regulators_np);
0945 
0946     if (of_get_property(pmic_np, "max8997,pmic-buck1-uses-gpio-dvs", NULL))
0947         pdata->buck1_gpiodvs = true;
0948 
0949     if (of_get_property(pmic_np, "max8997,pmic-buck2-uses-gpio-dvs", NULL))
0950         pdata->buck2_gpiodvs = true;
0951 
0952     if (of_get_property(pmic_np, "max8997,pmic-buck5-uses-gpio-dvs", NULL))
0953         pdata->buck5_gpiodvs = true;
0954 
0955     if (pdata->buck1_gpiodvs || pdata->buck2_gpiodvs ||
0956                         pdata->buck5_gpiodvs) {
0957         ret = max8997_pmic_dt_parse_dvs_gpio(pdev, pdata, pmic_np);
0958         if (ret)
0959             return -EINVAL;
0960 
0961         if (of_property_read_u32(pmic_np,
0962                 "max8997,pmic-buck125-default-dvs-idx",
0963                 &pdata->buck125_default_idx)) {
0964             pdata->buck125_default_idx = 0;
0965         } else {
0966             if (pdata->buck125_default_idx >= 8) {
0967                 pdata->buck125_default_idx = 0;
0968                 dev_info(&pdev->dev, "invalid value for default dvs index, using 0 instead\n");
0969             }
0970         }
0971 
0972         if (of_get_property(pmic_np,
0973             "max8997,pmic-ignore-gpiodvs-side-effect", NULL))
0974             pdata->ignore_gpiodvs_side_effect = true;
0975 
0976         dvs_voltage_nr = 8;
0977     }
0978 
0979     if (of_property_read_u32_array(pmic_np,
0980                 "max8997,pmic-buck1-dvs-voltage",
0981                 pdata->buck1_voltage, dvs_voltage_nr)) {
0982         dev_err(&pdev->dev, "buck1 voltages not specified\n");
0983         return -EINVAL;
0984     }
0985 
0986     if (of_property_read_u32_array(pmic_np,
0987                 "max8997,pmic-buck2-dvs-voltage",
0988                 pdata->buck2_voltage, dvs_voltage_nr)) {
0989         dev_err(&pdev->dev, "buck2 voltages not specified\n");
0990         return -EINVAL;
0991     }
0992 
0993     if (of_property_read_u32_array(pmic_np,
0994                 "max8997,pmic-buck5-dvs-voltage",
0995                 pdata->buck5_voltage, dvs_voltage_nr)) {
0996         dev_err(&pdev->dev, "buck5 voltages not specified\n");
0997         return -EINVAL;
0998     }
0999 
1000     return 0;
1001 }
1002 #else
1003 static int max8997_pmic_dt_parse_pdata(struct platform_device *pdev,
1004                     struct max8997_platform_data *pdata)
1005 {
1006     return 0;
1007 }
1008 #endif /* CONFIG_OF */
1009 
1010 static int max8997_pmic_probe(struct platform_device *pdev)
1011 {
1012     struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
1013     struct max8997_platform_data *pdata = iodev->pdata;
1014     struct regulator_config config = { };
1015     struct regulator_dev *rdev;
1016     struct max8997_data *max8997;
1017     struct i2c_client *i2c;
1018     int i, ret, nr_dvs;
1019     u8 max_buck1 = 0, max_buck2 = 0, max_buck5 = 0;
1020 
1021     if (!pdata) {
1022         dev_err(&pdev->dev, "No platform init data supplied.\n");
1023         return -ENODEV;
1024     }
1025 
1026     if (iodev->dev->of_node) {
1027         ret = max8997_pmic_dt_parse_pdata(pdev, pdata);
1028         if (ret)
1029             return ret;
1030     }
1031 
1032     max8997 = devm_kzalloc(&pdev->dev, sizeof(struct max8997_data),
1033                    GFP_KERNEL);
1034     if (!max8997)
1035         return -ENOMEM;
1036 
1037     max8997->dev = &pdev->dev;
1038     max8997->iodev = iodev;
1039     max8997->num_regulators = pdata->num_regulators;
1040     platform_set_drvdata(pdev, max8997);
1041     i2c = max8997->iodev->i2c;
1042 
1043     max8997->buck125_gpioindex = pdata->buck125_default_idx;
1044     max8997->buck1_gpiodvs = pdata->buck1_gpiodvs;
1045     max8997->buck2_gpiodvs = pdata->buck2_gpiodvs;
1046     max8997->buck5_gpiodvs = pdata->buck5_gpiodvs;
1047     memcpy(max8997->buck125_gpios, pdata->buck125_gpios, sizeof(int) * 3);
1048     max8997->ignore_gpiodvs_side_effect = pdata->ignore_gpiodvs_side_effect;
1049 
1050     nr_dvs = (pdata->buck1_gpiodvs || pdata->buck2_gpiodvs ||
1051             pdata->buck5_gpiodvs) ? 8 : 1;
1052 
1053     for (i = 0; i < nr_dvs; i++) {
1054         max8997->buck1_vol[i] = ret =
1055             max8997_get_voltage_proper_val(
1056                     &buck1245_voltage_map_desc,
1057                     pdata->buck1_voltage[i],
1058                     pdata->buck1_voltage[i] +
1059                     buck1245_voltage_map_desc.step);
1060         if (ret < 0)
1061             return ret;
1062 
1063         max8997->buck2_vol[i] = ret =
1064             max8997_get_voltage_proper_val(
1065                     &buck1245_voltage_map_desc,
1066                     pdata->buck2_voltage[i],
1067                     pdata->buck2_voltage[i] +
1068                     buck1245_voltage_map_desc.step);
1069         if (ret < 0)
1070             return ret;
1071 
1072         max8997->buck5_vol[i] = ret =
1073             max8997_get_voltage_proper_val(
1074                     &buck1245_voltage_map_desc,
1075                     pdata->buck5_voltage[i],
1076                     pdata->buck5_voltage[i] +
1077                     buck1245_voltage_map_desc.step);
1078         if (ret < 0)
1079             return ret;
1080 
1081         if (max_buck1 < max8997->buck1_vol[i])
1082             max_buck1 = max8997->buck1_vol[i];
1083         if (max_buck2 < max8997->buck2_vol[i])
1084             max_buck2 = max8997->buck2_vol[i];
1085         if (max_buck5 < max8997->buck5_vol[i])
1086             max_buck5 = max8997->buck5_vol[i];
1087     }
1088 
1089     /* For the safety, set max voltage before setting up */
1090     for (i = 0; i < 8; i++) {
1091         max8997_update_reg(i2c, MAX8997_REG_BUCK1DVS1 + i,
1092                 max_buck1, 0x3f);
1093         max8997_update_reg(i2c, MAX8997_REG_BUCK2DVS1 + i,
1094                 max_buck2, 0x3f);
1095         max8997_update_reg(i2c, MAX8997_REG_BUCK5DVS1 + i,
1096                 max_buck5, 0x3f);
1097     }
1098 
1099     /* Initialize all the DVS related BUCK registers */
1100     for (i = 0; i < nr_dvs; i++) {
1101         max8997_update_reg(i2c, MAX8997_REG_BUCK1DVS1 + i,
1102                 max8997->buck1_vol[i],
1103                 0x3f);
1104         max8997_update_reg(i2c, MAX8997_REG_BUCK2DVS1 + i,
1105                 max8997->buck2_vol[i],
1106                 0x3f);
1107         max8997_update_reg(i2c, MAX8997_REG_BUCK5DVS1 + i,
1108                 max8997->buck5_vol[i],
1109                 0x3f);
1110     }
1111 
1112     /*
1113      * If buck 1, 2, and 5 do not care DVS GPIO settings, ignore them.
1114      * If at least one of them cares, set gpios.
1115      */
1116     if (pdata->buck1_gpiodvs || pdata->buck2_gpiodvs ||
1117             pdata->buck5_gpiodvs) {
1118 
1119         if (!gpio_is_valid(pdata->buck125_gpios[0]) ||
1120                 !gpio_is_valid(pdata->buck125_gpios[1]) ||
1121                 !gpio_is_valid(pdata->buck125_gpios[2])) {
1122             dev_err(&pdev->dev, "GPIO NOT VALID\n");
1123             return -EINVAL;
1124         }
1125 
1126         ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[0],
1127                     "MAX8997 SET1");
1128         if (ret)
1129             return ret;
1130 
1131         ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[1],
1132                     "MAX8997 SET2");
1133         if (ret)
1134             return ret;
1135 
1136         ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[2],
1137                 "MAX8997 SET3");
1138         if (ret)
1139             return ret;
1140 
1141         gpio_direction_output(pdata->buck125_gpios[0],
1142                 (max8997->buck125_gpioindex >> 2)
1143                 & 0x1); /* SET1 */
1144         gpio_direction_output(pdata->buck125_gpios[1],
1145                 (max8997->buck125_gpioindex >> 1)
1146                 & 0x1); /* SET2 */
1147         gpio_direction_output(pdata->buck125_gpios[2],
1148                 (max8997->buck125_gpioindex >> 0)
1149                 & 0x1); /* SET3 */
1150     }
1151 
1152     /* DVS-GPIO disabled */
1153     max8997_update_reg(i2c, MAX8997_REG_BUCK1CTRL, (pdata->buck1_gpiodvs) ?
1154             (1 << 1) : (0 << 1), 1 << 1);
1155     max8997_update_reg(i2c, MAX8997_REG_BUCK2CTRL, (pdata->buck2_gpiodvs) ?
1156             (1 << 1) : (0 << 1), 1 << 1);
1157     max8997_update_reg(i2c, MAX8997_REG_BUCK5CTRL, (pdata->buck5_gpiodvs) ?
1158             (1 << 1) : (0 << 1), 1 << 1);
1159 
1160     /* Misc Settings */
1161     max8997->ramp_delay = 10; /* set 10mV/us, which is the default */
1162     max8997_write_reg(i2c, MAX8997_REG_BUCKRAMP, (0xf << 4) | 0x9);
1163 
1164     for (i = 0; i < pdata->num_regulators; i++) {
1165         const struct voltage_map_desc *desc;
1166         int id = pdata->regulators[i].id;
1167 
1168         desc = reg_voltage_map[id];
1169         if (desc) {
1170             regulators[id].n_voltages =
1171                 (desc->max - desc->min) / desc->step + 1;
1172         } else if (id == MAX8997_ESAFEOUT1 || id == MAX8997_ESAFEOUT2) {
1173             regulators[id].volt_table = safeoutvolt;
1174             regulators[id].n_voltages = ARRAY_SIZE(safeoutvolt);
1175         } else if (id == MAX8997_CHARGER_CV) {
1176             regulators[id].n_voltages = 16;
1177         }
1178 
1179         config.dev = max8997->dev;
1180         config.init_data = pdata->regulators[i].initdata;
1181         config.driver_data = max8997;
1182         config.of_node = pdata->regulators[i].reg_node;
1183 
1184         rdev = devm_regulator_register(&pdev->dev, &regulators[id],
1185                            &config);
1186         if (IS_ERR(rdev)) {
1187             dev_err(max8997->dev, "regulator init failed for %d\n",
1188                     id);
1189             return PTR_ERR(rdev);
1190         }
1191     }
1192 
1193     return 0;
1194 }
1195 
1196 static const struct platform_device_id max8997_pmic_id[] = {
1197     { "max8997-pmic", 0},
1198     { },
1199 };
1200 MODULE_DEVICE_TABLE(platform, max8997_pmic_id);
1201 
1202 static struct platform_driver max8997_pmic_driver = {
1203     .driver = {
1204         .name = "max8997-pmic",
1205     },
1206     .probe = max8997_pmic_probe,
1207     .id_table = max8997_pmic_id,
1208 };
1209 
1210 static int __init max8997_pmic_init(void)
1211 {
1212     return platform_driver_register(&max8997_pmic_driver);
1213 }
1214 subsys_initcall(max8997_pmic_init);
1215 
1216 static void __exit max8997_pmic_cleanup(void)
1217 {
1218     platform_driver_unregister(&max8997_pmic_driver);
1219 }
1220 module_exit(max8997_pmic_cleanup);
1221 
1222 MODULE_DESCRIPTION("MAXIM 8997/8966 Regulator Driver");
1223 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
1224 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!