Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/regulator/max8997.c

  1 /*
  2  * max8997.c - Regulator driver for the Maxim 8997/8966
  3  *
  4  * Copyright (C) 2011 Samsung Electronics
  5  * MyungJoo Ham <myungjoo.ham@smasung.com>
  6  *
  7  * This program is free software; you can redistribute it and/or modify
  8  * it under the terms of the GNU General Public License as published by
  9  * the Free Software Foundation; either version 2 of the License, or
 10  * (at your option) any later version.
 11  *
 12  * This program is distributed in the hope that it will be useful,
 13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15  * GNU General Public License for more details.
 16  *
 17  * You should have received a copy of the GNU General Public License
 18  * along with this program; if not, write to the Free Software
 19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 20  *
 21  * This driver is based on max8998.c
 22  */
 23 
 24 #include <linux/bug.h>
 25 #include <linux/err.h>
 26 #include <linux/gpio.h>
 27 #include <linux/of_gpio.h>
 28 #include <linux/slab.h>
 29 #include <linux/module.h>
 30 #include <linux/platform_device.h>
 31 #include <linux/regulator/driver.h>
 32 #include <linux/regulator/machine.h>
 33 #include <linux/mfd/max8997.h>
 34 #include <linux/mfd/max8997-private.h>
 35 #include <linux/regulator/of_regulator.h>
 36 
 37 struct max8997_data {
 38         struct device *dev;
 39         struct max8997_dev *iodev;
 40         int num_regulators;
 41         int ramp_delay; /* in mV/us */
 42 
 43         bool buck1_gpiodvs;
 44         bool buck2_gpiodvs;
 45         bool buck5_gpiodvs;
 46         u8 buck1_vol[8];
 47         u8 buck2_vol[8];
 48         u8 buck5_vol[8];
 49         int buck125_gpios[3];
 50         int buck125_gpioindex;
 51         bool ignore_gpiodvs_side_effect;
 52 
 53         u8 saved_states[MAX8997_REG_MAX];
 54 };
 55 
 56 static const unsigned int safeoutvolt[] = {
 57         4850000,
 58         4900000,
 59         4950000,
 60         3300000,
 61 };
 62 
 63 static inline void max8997_set_gpio(struct max8997_data *max8997)
 64 {
 65         int set3 = (max8997->buck125_gpioindex) & 0x1;
 66         int set2 = ((max8997->buck125_gpioindex) >> 1) & 0x1;
 67         int set1 = ((max8997->buck125_gpioindex) >> 2) & 0x1;
 68 
 69         gpio_set_value(max8997->buck125_gpios[0], set1);
 70         gpio_set_value(max8997->buck125_gpios[1], set2);
 71         gpio_set_value(max8997->buck125_gpios[2], set3);
 72 }
 73 
 74 struct voltage_map_desc {
 75         int min;
 76         int max;
 77         int step;
 78 };
 79 
 80 /* Voltage maps in uV */
 81 static const struct voltage_map_desc ldo_voltage_map_desc = {
 82         .min = 800000,  .max = 3950000, .step = 50000,
 83 }; /* LDO1 ~ 18, 21 all */
 84 
 85 static const struct voltage_map_desc buck1245_voltage_map_desc = {
 86         .min = 650000,  .max = 2225000, .step = 25000,
 87 }; /* Buck1, 2, 4, 5 */
 88 
 89 static const struct voltage_map_desc buck37_voltage_map_desc = {
 90         .min = 750000,  .max = 3900000, .step = 50000,
 91 }; /* Buck3, 7 */
 92 
 93 /* current map in uA */
 94 static const struct voltage_map_desc charger_current_map_desc = {
 95         .min = 200000,  .max = 950000,  .step = 50000,
 96 };
 97 
 98 static const struct voltage_map_desc topoff_current_map_desc = {
 99         .min = 50000,   .max = 200000,  .step = 10000,
100 };
101 
102 static const struct voltage_map_desc *reg_voltage_map[] = {
103         [MAX8997_LDO1] = &ldo_voltage_map_desc,
104         [MAX8997_LDO2] = &ldo_voltage_map_desc,
105         [MAX8997_LDO3] = &ldo_voltage_map_desc,
106         [MAX8997_LDO4] = &ldo_voltage_map_desc,
107         [MAX8997_LDO5] = &ldo_voltage_map_desc,
108         [MAX8997_LDO6] = &ldo_voltage_map_desc,
109         [MAX8997_LDO7] = &ldo_voltage_map_desc,
110         [MAX8997_LDO8] = &ldo_voltage_map_desc,
111         [MAX8997_LDO9] = &ldo_voltage_map_desc,
112         [MAX8997_LDO10] = &ldo_voltage_map_desc,
113         [MAX8997_LDO11] = &ldo_voltage_map_desc,
114         [MAX8997_LDO12] = &ldo_voltage_map_desc,
115         [MAX8997_LDO13] = &ldo_voltage_map_desc,
116         [MAX8997_LDO14] = &ldo_voltage_map_desc,
117         [MAX8997_LDO15] = &ldo_voltage_map_desc,
118         [MAX8997_LDO16] = &ldo_voltage_map_desc,
119         [MAX8997_LDO17] = &ldo_voltage_map_desc,
120         [MAX8997_LDO18] = &ldo_voltage_map_desc,
121         [MAX8997_LDO21] = &ldo_voltage_map_desc,
122         [MAX8997_BUCK1] = &buck1245_voltage_map_desc,
123         [MAX8997_BUCK2] = &buck1245_voltage_map_desc,
124         [MAX8997_BUCK3] = &buck37_voltage_map_desc,
125         [MAX8997_BUCK4] = &buck1245_voltage_map_desc,
126         [MAX8997_BUCK5] = &buck1245_voltage_map_desc,
127         [MAX8997_BUCK6] = NULL,
128         [MAX8997_BUCK7] = &buck37_voltage_map_desc,
129         [MAX8997_EN32KHZ_AP] = NULL,
130         [MAX8997_EN32KHZ_CP] = NULL,
131         [MAX8997_ENVICHG] = NULL,
132         [MAX8997_ESAFEOUT1] = NULL,
133         [MAX8997_ESAFEOUT2] = NULL,
134         [MAX8997_CHARGER_CV] = NULL,
135         [MAX8997_CHARGER] = &charger_current_map_desc,
136         [MAX8997_CHARGER_TOPOFF] = &topoff_current_map_desc,
137 };
138 
139 static int max8997_list_voltage_charger_cv(struct regulator_dev *rdev,
140                 unsigned int selector)
141 {
142         int rid = rdev_get_id(rdev);
143 
144         if (rid != MAX8997_CHARGER_CV)
145                 goto err;
146 
147         switch (selector) {
148         case 0x00:
149                 return 4200000;
150         case 0x01 ... 0x0E:
151                 return 4000000 + 20000 * (selector - 0x01);
152         case 0x0F:
153                 return 4350000;
154         default:
155                 return -EINVAL;
156         }
157 err:
158         return -EINVAL;
159 }
160 
161 static int max8997_list_voltage(struct regulator_dev *rdev,
162                 unsigned int selector)
163 {
164         const struct voltage_map_desc *desc;
165         int rid = rdev_get_id(rdev);
166         int val;
167 
168         if (rid >= ARRAY_SIZE(reg_voltage_map) ||
169                         rid < 0)
170                 return -EINVAL;
171 
172         desc = reg_voltage_map[rid];
173         if (desc == NULL)
174                 return -EINVAL;
175 
176         val = desc->min + desc->step * selector;
177         if (val > desc->max)
178                 return -EINVAL;
179 
180         return val;
181 }
182 
183 static int max8997_get_enable_register(struct regulator_dev *rdev,
184                 int *reg, int *mask, int *pattern)
185 {
186         int rid = rdev_get_id(rdev);
187 
188         switch (rid) {
189         case MAX8997_LDO1 ... MAX8997_LDO21:
190                 *reg = MAX8997_REG_LDO1CTRL + (rid - MAX8997_LDO1);
191                 *mask = 0xC0;
192                 *pattern = 0xC0;
193                 break;
194         case MAX8997_BUCK1:
195                 *reg = MAX8997_REG_BUCK1CTRL;
196                 *mask = 0x01;
197                 *pattern = 0x01;
198                 break;
199         case MAX8997_BUCK2:
200                 *reg = MAX8997_REG_BUCK2CTRL;
201                 *mask = 0x01;
202                 *pattern = 0x01;
203                 break;
204         case MAX8997_BUCK3:
205                 *reg = MAX8997_REG_BUCK3CTRL;
206                 *mask = 0x01;
207                 *pattern = 0x01;
208                 break;
209         case MAX8997_BUCK4:
210                 *reg = MAX8997_REG_BUCK4CTRL;
211                 *mask = 0x01;
212                 *pattern = 0x01;
213                 break;
214         case MAX8997_BUCK5:
215                 *reg = MAX8997_REG_BUCK5CTRL;
216                 *mask = 0x01;
217                 *pattern = 0x01;
218                 break;
219         case MAX8997_BUCK6:
220                 *reg = MAX8997_REG_BUCK6CTRL;
221                 *mask = 0x01;
222                 *pattern = 0x01;
223                 break;
224         case MAX8997_BUCK7:
225                 *reg = MAX8997_REG_BUCK7CTRL;
226                 *mask = 0x01;
227                 *pattern = 0x01;
228                 break;
229         case MAX8997_EN32KHZ_AP ... MAX8997_EN32KHZ_CP:
230                 *reg = MAX8997_REG_MAINCON1;
231                 *mask = 0x01 << (rid - MAX8997_EN32KHZ_AP);
232                 *pattern = 0x01 << (rid - MAX8997_EN32KHZ_AP);
233                 break;
234         case MAX8997_ENVICHG:
235                 *reg = MAX8997_REG_MBCCTRL1;
236                 *mask = 0x80;
237                 *pattern = 0x80;
238                 break;
239         case MAX8997_ESAFEOUT1 ... MAX8997_ESAFEOUT2:
240                 *reg = MAX8997_REG_SAFEOUTCTRL;
241                 *mask = 0x40 << (rid - MAX8997_ESAFEOUT1);
242                 *pattern = 0x40 << (rid - MAX8997_ESAFEOUT1);
243                 break;
244         case MAX8997_CHARGER:
245                 *reg = MAX8997_REG_MBCCTRL2;
246                 *mask = 0x40;
247                 *pattern = 0x40;
248                 break;
249         default:
250                 /* Not controllable or not exists */
251                 return -EINVAL;
252         }
253 
254         return 0;
255 }
256 
257 static int max8997_reg_is_enabled(struct regulator_dev *rdev)
258 {
259         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
260         struct i2c_client *i2c = max8997->iodev->i2c;
261         int ret, reg, mask, pattern;
262         u8 val;
263 
264         ret = max8997_get_enable_register(rdev, &reg, &mask, &pattern);
265         if (ret)
266                 return ret;
267 
268         ret = max8997_read_reg(i2c, reg, &val);
269         if (ret)
270                 return ret;
271 
272         return (val & mask) == pattern;
273 }
274 
275 static int max8997_reg_enable(struct regulator_dev *rdev)
276 {
277         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
278         struct i2c_client *i2c = max8997->iodev->i2c;
279         int ret, reg, mask, pattern;
280 
281         ret = max8997_get_enable_register(rdev, &reg, &mask, &pattern);
282         if (ret)
283                 return ret;
284 
285         return max8997_update_reg(i2c, reg, pattern, mask);
286 }
287 
288 static int max8997_reg_disable(struct regulator_dev *rdev)
289 {
290         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
291         struct i2c_client *i2c = max8997->iodev->i2c;
292         int ret, reg, mask, pattern;
293 
294         ret = max8997_get_enable_register(rdev, &reg, &mask, &pattern);
295         if (ret)
296                 return ret;
297 
298         return max8997_update_reg(i2c, reg, ~pattern, mask);
299 }
300 
301 static int max8997_get_voltage_register(struct regulator_dev *rdev,
302                 int *_reg, int *_shift, int *_mask)
303 {
304         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
305         int rid = rdev_get_id(rdev);
306         int reg, shift = 0, mask = 0x3f;
307 
308         switch (rid) {
309         case MAX8997_LDO1 ... MAX8997_LDO21:
310                 reg = MAX8997_REG_LDO1CTRL + (rid - MAX8997_LDO1);
311                 break;
312         case MAX8997_BUCK1:
313                 reg = MAX8997_REG_BUCK1DVS1;
314                 if (max8997->buck1_gpiodvs)
315                         reg += max8997->buck125_gpioindex;
316                 break;
317         case MAX8997_BUCK2:
318                 reg = MAX8997_REG_BUCK2DVS1;
319                 if (max8997->buck2_gpiodvs)
320                         reg += max8997->buck125_gpioindex;
321                 break;
322         case MAX8997_BUCK3:
323                 reg = MAX8997_REG_BUCK3DVS;
324                 break;
325         case MAX8997_BUCK4:
326                 reg = MAX8997_REG_BUCK4DVS;
327                 break;
328         case MAX8997_BUCK5:
329                 reg = MAX8997_REG_BUCK5DVS1;
330                 if (max8997->buck5_gpiodvs)
331                         reg += max8997->buck125_gpioindex;
332                 break;
333         case MAX8997_BUCK7:
334                 reg = MAX8997_REG_BUCK7DVS;
335                 break;
336         case MAX8997_ESAFEOUT1 ...  MAX8997_ESAFEOUT2:
337                 reg = MAX8997_REG_SAFEOUTCTRL;
338                 shift = (rid == MAX8997_ESAFEOUT2) ? 2 : 0;
339                 mask = 0x3;
340                 break;
341         case MAX8997_CHARGER_CV:
342                 reg = MAX8997_REG_MBCCTRL3;
343                 shift = 0;
344                 mask = 0xf;
345                 break;
346         case MAX8997_CHARGER:
347                 reg = MAX8997_REG_MBCCTRL4;
348                 shift = 0;
349                 mask = 0xf;
350                 break;
351         case MAX8997_CHARGER_TOPOFF:
352                 reg = MAX8997_REG_MBCCTRL5;
353                 shift = 0;
354                 mask = 0xf;
355                 break;
356         default:
357                 return -EINVAL;
358         }
359 
360         *_reg = reg;
361         *_shift = shift;
362         *_mask = mask;
363 
364         return 0;
365 }
366 
367 static int max8997_get_voltage_sel(struct regulator_dev *rdev)
368 {
369         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
370         struct i2c_client *i2c = max8997->iodev->i2c;
371         int reg, shift, mask, ret;
372         u8 val;
373 
374         ret = max8997_get_voltage_register(rdev, &reg, &shift, &mask);
375         if (ret)
376                 return ret;
377 
378         ret = max8997_read_reg(i2c, reg, &val);
379         if (ret)
380                 return ret;
381 
382         val >>= shift;
383         val &= mask;
384 
385         return val;
386 }
387 
388 static inline int max8997_get_voltage_proper_val(
389                 const struct voltage_map_desc *desc,
390                 int min_vol, int max_vol)
391 {
392         int i;
393 
394         if (desc == NULL)
395                 return -EINVAL;
396 
397         if (max_vol < desc->min || min_vol > desc->max)
398                 return -EINVAL;
399 
400         if (min_vol < desc->min)
401                 min_vol = desc->min;
402 
403         i = DIV_ROUND_UP(min_vol - desc->min, desc->step);
404 
405         if (desc->min + desc->step * i > max_vol)
406                 return -EINVAL;
407 
408         return i;
409 }
410 
411 static int max8997_set_voltage_charger_cv(struct regulator_dev *rdev,
412                 int min_uV, int max_uV, unsigned *selector)
413 {
414         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
415         struct i2c_client *i2c = max8997->iodev->i2c;
416         int rid = rdev_get_id(rdev);
417         int lb, ub;
418         int reg, shift = 0, mask, ret = 0;
419         u8 val = 0x0;
420 
421         if (rid != MAX8997_CHARGER_CV)
422                 return -EINVAL;
423 
424         ret = max8997_get_voltage_register(rdev, &reg, &shift, &mask);
425         if (ret)
426                 return ret;
427 
428         if (max_uV < 4000000 || min_uV > 4350000)
429                 return -EINVAL;
430 
431         if (min_uV <= 4000000) {
432                 if (max_uV >= 4000000)
433                         return -EINVAL;
434                 else
435                         val = 0x1;
436         } else if (min_uV <= 4200000 && max_uV >= 4200000)
437                 val = 0x0;
438         else {
439                 lb = (min_uV - 4000001) / 20000 + 2;
440                 ub = (max_uV - 4000000) / 20000 + 1;
441 
442                 if (lb > ub)
443                         return -EINVAL;
444 
445                 if (lb < 0xf)
446                         val = lb;
447                 else {
448                         if (ub >= 0xf)
449                                 val = 0xf;
450                         else
451                                 return -EINVAL;
452                 }
453         }
454 
455         *selector = val;
456 
457         ret = max8997_update_reg(i2c, reg, val << shift, mask);
458 
459         return ret;
460 }
461 
462 /*
463  * For LDO1 ~ LDO21, BUCK1~5, BUCK7, CHARGER, CHARGER_TOPOFF
464  * BUCK1, 2, and 5 are available if they are not controlled by gpio
465  */
466 static int max8997_set_voltage_ldobuck(struct regulator_dev *rdev,
467                 int min_uV, int max_uV, unsigned *selector)
468 {
469         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
470         struct i2c_client *i2c = max8997->iodev->i2c;
471         const struct voltage_map_desc *desc;
472         int rid = rdev_get_id(rdev);
473         int i, reg, shift, mask, ret;
474 
475         switch (rid) {
476         case MAX8997_LDO1 ... MAX8997_LDO21:
477                 break;
478         case MAX8997_BUCK1 ... MAX8997_BUCK5:
479                 break;
480         case MAX8997_BUCK6:
481                 return -EINVAL;
482         case MAX8997_BUCK7:
483                 break;
484         case MAX8997_CHARGER:
485                 break;
486         case MAX8997_CHARGER_TOPOFF:
487                 break;
488         default:
489                 return -EINVAL;
490         }
491 
492         desc = reg_voltage_map[rid];
493 
494         i = max8997_get_voltage_proper_val(desc, min_uV, max_uV);
495         if (i < 0)
496                 return i;
497 
498         ret = max8997_get_voltage_register(rdev, &reg, &shift, &mask);
499         if (ret)
500                 return ret;
501 
502         ret = max8997_update_reg(i2c, reg, i << shift, mask << shift);
503         *selector = i;
504 
505         return ret;
506 }
507 
508 static int max8997_set_voltage_buck_time_sel(struct regulator_dev *rdev,
509                                                 unsigned int old_selector,
510                                                 unsigned int new_selector)
511 {
512         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
513         int rid = rdev_get_id(rdev);
514         const struct voltage_map_desc *desc = reg_voltage_map[rid];
515 
516         /* Delay is required only if the voltage is increasing */
517         if (old_selector >= new_selector)
518                 return 0;
519 
520         /* No need to delay if gpio_dvs_mode */
521         switch (rid) {
522         case MAX8997_BUCK1:
523                 if (max8997->buck1_gpiodvs)
524                         return 0;
525                 break;
526         case MAX8997_BUCK2:
527                 if (max8997->buck2_gpiodvs)
528                         return 0;
529                 break;
530         case MAX8997_BUCK5:
531                 if (max8997->buck5_gpiodvs)
532                         return 0;
533                 break;
534         }
535 
536         switch (rid) {
537         case MAX8997_BUCK1:
538         case MAX8997_BUCK2:
539         case MAX8997_BUCK4:
540         case MAX8997_BUCK5:
541                 return DIV_ROUND_UP(desc->step * (new_selector - old_selector),
542                                     max8997->ramp_delay * 1000);
543         }
544 
545         return 0;
546 }
547 
548 /*
549  * Assess the damage on the voltage setting of BUCK1,2,5 by the change.
550  *
551  * When GPIO-DVS mode is used for multiple bucks, changing the voltage value
552  * of one of the bucks may affect that of another buck, which is the side
553  * effect of the change (set_voltage). This function examines the GPIO-DVS
554  * configurations and checks whether such side-effect exists.
555  */
556 static int max8997_assess_side_effect(struct regulator_dev *rdev,
557                 u8 new_val, int *best)
558 {
559         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
560         int rid = rdev_get_id(rdev);
561         u8 *buckx_val[3];
562         bool buckx_gpiodvs[3];
563         int side_effect[8];
564         int min_side_effect = INT_MAX;
565         int i;
566 
567         *best = -1;
568 
569         switch (rid) {
570         case MAX8997_BUCK1:
571                 rid = 0;
572                 break;
573         case MAX8997_BUCK2:
574                 rid = 1;
575                 break;
576         case MAX8997_BUCK5:
577                 rid = 2;
578                 break;
579         default:
580                 return -EINVAL;
581         }
582 
583         buckx_val[0] = max8997->buck1_vol;
584         buckx_val[1] = max8997->buck2_vol;
585         buckx_val[2] = max8997->buck5_vol;
586         buckx_gpiodvs[0] = max8997->buck1_gpiodvs;
587         buckx_gpiodvs[1] = max8997->buck2_gpiodvs;
588         buckx_gpiodvs[2] = max8997->buck5_gpiodvs;
589 
590         for (i = 0; i < 8; i++) {
591                 int others;
592 
593                 if (new_val != (buckx_val[rid])[i]) {
594                         side_effect[i] = -1;
595                         continue;
596                 }
597 
598                 side_effect[i] = 0;
599                 for (others = 0; others < 3; others++) {
600                         int diff;
601 
602                         if (others == rid)
603                                 continue;
604                         if (buckx_gpiodvs[others] == false)
605                                 continue; /* Not affected */
606                         diff = (buckx_val[others])[i] -
607                                 (buckx_val[others])[max8997->buck125_gpioindex];
608                         if (diff > 0)
609                                 side_effect[i] += diff;
610                         else if (diff < 0)
611                                 side_effect[i] -= diff;
612                 }
613                 if (side_effect[i] == 0) {
614                         *best = i;
615                         return 0; /* NO SIDE EFFECT! Use This! */
616                 }
617                 if (side_effect[i] < min_side_effect) {
618                         min_side_effect = side_effect[i];
619                         *best = i;
620                 }
621         }
622 
623         if (*best == -1)
624                 return -EINVAL;
625 
626         return side_effect[*best];
627 }
628 
629 /*
630  * For Buck 1 ~ 5 and 7. If it is not controlled by GPIO, this calls
631  * max8997_set_voltage_ldobuck to do the job.
632  */
633 static int max8997_set_voltage_buck(struct regulator_dev *rdev,
634                 int min_uV, int max_uV, unsigned *selector)
635 {
636         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
637         int rid = rdev_get_id(rdev);
638         const struct voltage_map_desc *desc;
639         int new_val, new_idx, damage, tmp_val, tmp_idx, tmp_dmg;
640         bool gpio_dvs_mode = false;
641 
642         if (rid < MAX8997_BUCK1 || rid > MAX8997_BUCK7)
643                 return -EINVAL;
644 
645         switch (rid) {
646         case MAX8997_BUCK1:
647                 if (max8997->buck1_gpiodvs)
648                         gpio_dvs_mode = true;
649                 break;
650         case MAX8997_BUCK2:
651                 if (max8997->buck2_gpiodvs)
652                         gpio_dvs_mode = true;
653                 break;
654         case MAX8997_BUCK5:
655                 if (max8997->buck5_gpiodvs)
656                         gpio_dvs_mode = true;
657                 break;
658         }
659 
660         if (!gpio_dvs_mode)
661                 return max8997_set_voltage_ldobuck(rdev, min_uV, max_uV,
662                                                 selector);
663 
664         desc = reg_voltage_map[rid];
665         new_val = max8997_get_voltage_proper_val(desc, min_uV, max_uV);
666         if (new_val < 0)
667                 return new_val;
668 
669         tmp_dmg = INT_MAX;
670         tmp_idx = -1;
671         tmp_val = -1;
672         do {
673                 damage = max8997_assess_side_effect(rdev, new_val, &new_idx);
674                 if (damage == 0)
675                         goto out;
676 
677                 if (tmp_dmg > damage) {
678                         tmp_idx = new_idx;
679                         tmp_val = new_val;
680                         tmp_dmg = damage;
681                 }
682 
683                 new_val++;
684         } while (desc->min + desc->step * new_val <= desc->max);
685 
686         new_idx = tmp_idx;
687         new_val = tmp_val;
688 
689         if (max8997->ignore_gpiodvs_side_effect == false)
690                 return -EINVAL;
691 
692         dev_warn(&rdev->dev,
693                 "MAX8997 GPIO-DVS Side Effect Warning: GPIO SET:  %d -> %d\n",
694                 max8997->buck125_gpioindex, tmp_idx);
695 
696 out:
697         if (new_idx < 0 || new_val < 0)
698                 return -EINVAL;
699 
700         max8997->buck125_gpioindex = new_idx;
701         max8997_set_gpio(max8997);
702         *selector = new_val;
703 
704         return 0;
705 }
706 
707 /* For SAFEOUT1 and SAFEOUT2 */
708 static int max8997_set_voltage_safeout_sel(struct regulator_dev *rdev,
709                                            unsigned selector)
710 {
711         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
712         struct i2c_client *i2c = max8997->iodev->i2c;
713         int rid = rdev_get_id(rdev);
714         int reg, shift = 0, mask, ret;
715 
716         if (rid != MAX8997_ESAFEOUT1 && rid != MAX8997_ESAFEOUT2)
717                 return -EINVAL;
718 
719         ret = max8997_get_voltage_register(rdev, &reg, &shift, &mask);
720         if (ret)
721                 return ret;
722 
723         return max8997_update_reg(i2c, reg, selector << shift, mask << shift);
724 }
725 
726 static int max8997_reg_disable_suspend(struct regulator_dev *rdev)
727 {
728         struct max8997_data *max8997 = rdev_get_drvdata(rdev);
729         struct i2c_client *i2c = max8997->iodev->i2c;
730         int ret, reg, mask, pattern;
731         int rid = rdev_get_id(rdev);
732 
733         ret = max8997_get_enable_register(rdev, &reg, &mask, &pattern);
734         if (ret)
735                 return ret;
736 
737         max8997_read_reg(i2c, reg, &max8997->saved_states[rid]);
738 
739         if (rid == MAX8997_LDO1 ||
740                         rid == MAX8997_LDO10 ||
741                         rid == MAX8997_LDO21) {
742                 dev_dbg(&rdev->dev, "Conditional Power-Off for %s\n",
743                                 rdev->desc->name);
744                 return max8997_update_reg(i2c, reg, 0x40, mask);
745         }
746 
747         dev_dbg(&rdev->dev, "Full Power-Off for %s (%xh -> %xh)\n",
748                         rdev->desc->name, max8997->saved_states[rid] & mask,
749                         (~pattern) & mask);
750         return max8997_update_reg(i2c, reg, ~pattern, mask);
751 }
752 
753 static struct regulator_ops max8997_ldo_ops = {
754         .list_voltage           = max8997_list_voltage,
755         .is_enabled             = max8997_reg_is_enabled,
756         .enable                 = max8997_reg_enable,
757         .disable                = max8997_reg_disable,
758         .get_voltage_sel        = max8997_get_voltage_sel,
759         .set_voltage            = max8997_set_voltage_ldobuck,
760         .set_suspend_disable    = max8997_reg_disable_suspend,
761 };
762 
763 static struct regulator_ops max8997_buck_ops = {
764         .list_voltage           = max8997_list_voltage,
765         .is_enabled             = max8997_reg_is_enabled,
766         .enable                 = max8997_reg_enable,
767         .disable                = max8997_reg_disable,
768         .get_voltage_sel        = max8997_get_voltage_sel,
769         .set_voltage            = max8997_set_voltage_buck,
770         .set_voltage_time_sel   = max8997_set_voltage_buck_time_sel,
771         .set_suspend_disable    = max8997_reg_disable_suspend,
772 };
773 
774 static struct regulator_ops max8997_fixedvolt_ops = {
775         .list_voltage           = max8997_list_voltage,
776         .is_enabled             = max8997_reg_is_enabled,
777         .enable                 = max8997_reg_enable,
778         .disable                = max8997_reg_disable,
779         .set_suspend_disable    = max8997_reg_disable_suspend,
780 };
781 
782 static struct regulator_ops max8997_safeout_ops = {
783         .list_voltage           = regulator_list_voltage_table,
784         .is_enabled             = max8997_reg_is_enabled,
785         .enable                 = max8997_reg_enable,
786         .disable                = max8997_reg_disable,
787         .get_voltage_sel        = max8997_get_voltage_sel,
788         .set_voltage_sel        = max8997_set_voltage_safeout_sel,
789         .set_suspend_disable    = max8997_reg_disable_suspend,
790 };
791 
792 static struct regulator_ops max8997_fixedstate_ops = {
793         .list_voltage           = max8997_list_voltage_charger_cv,
794         .get_voltage_sel        = max8997_get_voltage_sel,
795         .set_voltage            = max8997_set_voltage_charger_cv,
796 };
797 
798 static int max8997_set_current_limit(struct regulator_dev *rdev,
799                                      int min_uA, int max_uA)
800 {
801         unsigned dummy;
802         int rid = rdev_get_id(rdev);
803 
804         if (rid != MAX8997_CHARGER && rid != MAX8997_CHARGER_TOPOFF)
805                 return -EINVAL;
806 
807         /* Reuse max8997_set_voltage_ldobuck to set current_limit. */
808         return max8997_set_voltage_ldobuck(rdev, min_uA, max_uA, &dummy);
809 }
810 
811 static int max8997_get_current_limit(struct regulator_dev *rdev)
812 {
813         int sel, rid = rdev_get_id(rdev);
814 
815         if (rid != MAX8997_CHARGER && rid != MAX8997_CHARGER_TOPOFF)
816                 return -EINVAL;
817 
818         sel = max8997_get_voltage_sel(rdev);
819         if (sel < 0)
820                 return sel;
821 
822         /* Reuse max8997_list_voltage to get current_limit. */
823         return max8997_list_voltage(rdev, sel);
824 }
825 
826 static struct regulator_ops max8997_charger_ops = {
827         .is_enabled             = max8997_reg_is_enabled,
828         .enable                 = max8997_reg_enable,
829         .disable                = max8997_reg_disable,
830         .get_current_limit      = max8997_get_current_limit,
831         .set_current_limit      = max8997_set_current_limit,
832 };
833 
834 static struct regulator_ops max8997_charger_fixedstate_ops = {
835         .get_current_limit      = max8997_get_current_limit,
836         .set_current_limit      = max8997_set_current_limit,
837 };
838 
839 #define MAX8997_VOLTAGE_REGULATOR(_name, _ops) {\
840         .name           = #_name,               \
841         .id             = MAX8997_##_name,      \
842         .ops            = &_ops,                \
843         .type           = REGULATOR_VOLTAGE,    \
844         .owner          = THIS_MODULE,          \
845 }
846 
847 #define MAX8997_CURRENT_REGULATOR(_name, _ops) {\
848         .name           = #_name,               \
849         .id             = MAX8997_##_name,      \
850         .ops            = &_ops,                \
851         .type           = REGULATOR_CURRENT,    \
852         .owner          = THIS_MODULE,          \
853 }
854 
855 static struct regulator_desc regulators[] = {
856         MAX8997_VOLTAGE_REGULATOR(LDO1, max8997_ldo_ops),
857         MAX8997_VOLTAGE_REGULATOR(LDO2, max8997_ldo_ops),
858         MAX8997_VOLTAGE_REGULATOR(LDO3, max8997_ldo_ops),
859         MAX8997_VOLTAGE_REGULATOR(LDO4, max8997_ldo_ops),
860         MAX8997_VOLTAGE_REGULATOR(LDO5, max8997_ldo_ops),
861         MAX8997_VOLTAGE_REGULATOR(LDO6, max8997_ldo_ops),
862         MAX8997_VOLTAGE_REGULATOR(LDO7, max8997_ldo_ops),
863         MAX8997_VOLTAGE_REGULATOR(LDO8, max8997_ldo_ops),
864         MAX8997_VOLTAGE_REGULATOR(LDO9, max8997_ldo_ops),
865         MAX8997_VOLTAGE_REGULATOR(LDO10, max8997_ldo_ops),
866         MAX8997_VOLTAGE_REGULATOR(LDO11, max8997_ldo_ops),
867         MAX8997_VOLTAGE_REGULATOR(LDO12, max8997_ldo_ops),
868         MAX8997_VOLTAGE_REGULATOR(LDO13, max8997_ldo_ops),
869         MAX8997_VOLTAGE_REGULATOR(LDO14, max8997_ldo_ops),
870         MAX8997_VOLTAGE_REGULATOR(LDO15, max8997_ldo_ops),
871         MAX8997_VOLTAGE_REGULATOR(LDO16, max8997_ldo_ops),
872         MAX8997_VOLTAGE_REGULATOR(LDO17, max8997_ldo_ops),
873         MAX8997_VOLTAGE_REGULATOR(LDO18, max8997_ldo_ops),
874         MAX8997_VOLTAGE_REGULATOR(LDO21, max8997_ldo_ops),
875         MAX8997_VOLTAGE_REGULATOR(BUCK1, max8997_buck_ops),
876         MAX8997_VOLTAGE_REGULATOR(BUCK2, max8997_buck_ops),
877         MAX8997_VOLTAGE_REGULATOR(BUCK3, max8997_buck_ops),
878         MAX8997_VOLTAGE_REGULATOR(BUCK4, max8997_buck_ops),
879         MAX8997_VOLTAGE_REGULATOR(BUCK5, max8997_buck_ops),
880         MAX8997_VOLTAGE_REGULATOR(BUCK6, max8997_fixedvolt_ops),
881         MAX8997_VOLTAGE_REGULATOR(BUCK7, max8997_buck_ops),
882         MAX8997_VOLTAGE_REGULATOR(EN32KHZ_AP, max8997_fixedvolt_ops),
883         MAX8997_VOLTAGE_REGULATOR(EN32KHZ_CP, max8997_fixedvolt_ops),
884         MAX8997_VOLTAGE_REGULATOR(ENVICHG, max8997_fixedvolt_ops),
885         MAX8997_VOLTAGE_REGULATOR(ESAFEOUT1, max8997_safeout_ops),
886         MAX8997_VOLTAGE_REGULATOR(ESAFEOUT2, max8997_safeout_ops),
887         MAX8997_VOLTAGE_REGULATOR(CHARGER_CV, max8997_fixedstate_ops),
888         MAX8997_CURRENT_REGULATOR(CHARGER, max8997_charger_ops),
889         MAX8997_CURRENT_REGULATOR(CHARGER_TOPOFF,
890                                   max8997_charger_fixedstate_ops),
891 };
892 
893 #ifdef CONFIG_OF
894 static int max8997_pmic_dt_parse_dvs_gpio(struct platform_device *pdev,
895                         struct max8997_platform_data *pdata,
896                         struct device_node *pmic_np)
897 {
898         int i, gpio;
899 
900         for (i = 0; i < 3; i++) {
901                 gpio = of_get_named_gpio(pmic_np,
902                                         "max8997,pmic-buck125-dvs-gpios", i);
903                 if (!gpio_is_valid(gpio)) {
904                         dev_err(&pdev->dev, "invalid gpio[%d]: %d\n", i, gpio);
905                         return -EINVAL;
906                 }
907                 pdata->buck125_gpios[i] = gpio;
908         }
909         return 0;
910 }
911 
912 static int max8997_pmic_dt_parse_pdata(struct platform_device *pdev,
913                                         struct max8997_platform_data *pdata)
914 {
915         struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
916         struct device_node *pmic_np, *regulators_np, *reg_np;
917         struct max8997_regulator_data *rdata;
918         unsigned int i, dvs_voltage_nr = 1, ret;
919 
920         pmic_np = iodev->dev->of_node;
921         if (!pmic_np) {
922                 dev_err(&pdev->dev, "could not find pmic sub-node\n");
923                 return -ENODEV;
924         }
925 
926         regulators_np = of_get_child_by_name(pmic_np, "regulators");
927         if (!regulators_np) {
928                 dev_err(&pdev->dev, "could not find regulators sub-node\n");
929                 return -EINVAL;
930         }
931 
932         /* count the number of regulators to be supported in pmic */
933         pdata->num_regulators = of_get_child_count(regulators_np);
934 
935         rdata = devm_kzalloc(&pdev->dev, sizeof(*rdata) *
936                                 pdata->num_regulators, GFP_KERNEL);
937         if (!rdata) {
938                 of_node_put(regulators_np);
939                 return -ENOMEM;
940         }
941 
942         pdata->regulators = rdata;
943         for_each_child_of_node(regulators_np, reg_np) {
944                 for (i = 0; i < ARRAY_SIZE(regulators); i++)
945                         if (!of_node_cmp(reg_np->name, regulators[i].name))
946                                 break;
947 
948                 if (i == ARRAY_SIZE(regulators)) {
949                         dev_warn(&pdev->dev, "don't know how to configure regulator %s\n",
950                                  reg_np->name);
951                         continue;
952                 }
953 
954                 rdata->id = i;
955                 rdata->initdata = of_get_regulator_init_data(&pdev->dev,
956                                                              reg_np);
957                 rdata->reg_node = reg_np;
958                 rdata++;
959         }
960         of_node_put(regulators_np);
961 
962         if (of_get_property(pmic_np, "max8997,pmic-buck1-uses-gpio-dvs", NULL))
963                 pdata->buck1_gpiodvs = true;
964 
965         if (of_get_property(pmic_np, "max8997,pmic-buck2-uses-gpio-dvs", NULL))
966                 pdata->buck2_gpiodvs = true;
967 
968         if (of_get_property(pmic_np, "max8997,pmic-buck5-uses-gpio-dvs", NULL))
969                 pdata->buck5_gpiodvs = true;
970 
971         if (pdata->buck1_gpiodvs || pdata->buck2_gpiodvs ||
972                                                 pdata->buck5_gpiodvs) {
973                 ret = max8997_pmic_dt_parse_dvs_gpio(pdev, pdata, pmic_np);
974                 if (ret)
975                         return -EINVAL;
976 
977                 if (of_property_read_u32(pmic_np,
978                                 "max8997,pmic-buck125-default-dvs-idx",
979                                 &pdata->buck125_default_idx)) {
980                         pdata->buck125_default_idx = 0;
981                 } else {
982                         if (pdata->buck125_default_idx >= 8) {
983                                 pdata->buck125_default_idx = 0;
984                                 dev_info(&pdev->dev, "invalid value for default dvs index, using 0 instead\n");
985                         }
986                 }
987 
988                 if (of_get_property(pmic_np,
989                         "max8997,pmic-ignore-gpiodvs-side-effect", NULL))
990                         pdata->ignore_gpiodvs_side_effect = true;
991 
992                 dvs_voltage_nr = 8;
993         }
994 
995         if (of_property_read_u32_array(pmic_np,
996                                 "max8997,pmic-buck1-dvs-voltage",
997                                 pdata->buck1_voltage, dvs_voltage_nr)) {
998                 dev_err(&pdev->dev, "buck1 voltages not specified\n");
999                 return -EINVAL;
1000         }
1001 
1002         if (of_property_read_u32_array(pmic_np,
1003                                 "max8997,pmic-buck2-dvs-voltage",
1004                                 pdata->buck2_voltage, dvs_voltage_nr)) {
1005                 dev_err(&pdev->dev, "buck2 voltages not specified\n");
1006                 return -EINVAL;
1007         }
1008 
1009         if (of_property_read_u32_array(pmic_np,
1010                                 "max8997,pmic-buck5-dvs-voltage",
1011                                 pdata->buck5_voltage, dvs_voltage_nr)) {
1012                 dev_err(&pdev->dev, "buck5 voltages not specified\n");
1013                 return -EINVAL;
1014         }
1015 
1016         return 0;
1017 }
1018 #else
1019 static int max8997_pmic_dt_parse_pdata(struct platform_device *pdev,
1020                                         struct max8997_platform_data *pdata)
1021 {
1022         return 0;
1023 }
1024 #endif /* CONFIG_OF */
1025 
1026 static int max8997_pmic_probe(struct platform_device *pdev)
1027 {
1028         struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
1029         struct max8997_platform_data *pdata = iodev->pdata;
1030         struct regulator_config config = { };
1031         struct regulator_dev *rdev;
1032         struct max8997_data *max8997;
1033         struct i2c_client *i2c;
1034         int i, ret, nr_dvs;
1035         u8 max_buck1 = 0, max_buck2 = 0, max_buck5 = 0;
1036 
1037         if (!pdata) {
1038                 dev_err(&pdev->dev, "No platform init data supplied.\n");
1039                 return -ENODEV;
1040         }
1041 
1042         if (iodev->dev->of_node) {
1043                 ret = max8997_pmic_dt_parse_pdata(pdev, pdata);
1044                 if (ret)
1045                         return ret;
1046         }
1047 
1048         max8997 = devm_kzalloc(&pdev->dev, sizeof(struct max8997_data),
1049                                GFP_KERNEL);
1050         if (!max8997)
1051                 return -ENOMEM;
1052 
1053         max8997->dev = &pdev->dev;
1054         max8997->iodev = iodev;
1055         max8997->num_regulators = pdata->num_regulators;
1056         platform_set_drvdata(pdev, max8997);
1057         i2c = max8997->iodev->i2c;
1058 
1059         max8997->buck125_gpioindex = pdata->buck125_default_idx;
1060         max8997->buck1_gpiodvs = pdata->buck1_gpiodvs;
1061         max8997->buck2_gpiodvs = pdata->buck2_gpiodvs;
1062         max8997->buck5_gpiodvs = pdata->buck5_gpiodvs;
1063         memcpy(max8997->buck125_gpios, pdata->buck125_gpios, sizeof(int) * 3);
1064         max8997->ignore_gpiodvs_side_effect = pdata->ignore_gpiodvs_side_effect;
1065 
1066         nr_dvs = (pdata->buck1_gpiodvs || pdata->buck2_gpiodvs ||
1067                         pdata->buck5_gpiodvs) ? 8 : 1;
1068 
1069         for (i = 0; i < nr_dvs; i++) {
1070                 max8997->buck1_vol[i] = ret =
1071                         max8997_get_voltage_proper_val(
1072                                         &buck1245_voltage_map_desc,
1073                                         pdata->buck1_voltage[i],
1074                                         pdata->buck1_voltage[i] +
1075                                         buck1245_voltage_map_desc.step);
1076                 if (ret < 0)
1077                         return ret;
1078 
1079                 max8997->buck2_vol[i] = ret =
1080                         max8997_get_voltage_proper_val(
1081                                         &buck1245_voltage_map_desc,
1082                                         pdata->buck2_voltage[i],
1083                                         pdata->buck2_voltage[i] +
1084                                         buck1245_voltage_map_desc.step);
1085                 if (ret < 0)
1086                         return ret;
1087 
1088                 max8997->buck5_vol[i] = ret =
1089                         max8997_get_voltage_proper_val(
1090                                         &buck1245_voltage_map_desc,
1091                                         pdata->buck5_voltage[i],
1092                                         pdata->buck5_voltage[i] +
1093                                         buck1245_voltage_map_desc.step);
1094                 if (ret < 0)
1095                         return ret;
1096 
1097                 if (max_buck1 < max8997->buck1_vol[i])
1098                         max_buck1 = max8997->buck1_vol[i];
1099                 if (max_buck2 < max8997->buck2_vol[i])
1100                         max_buck2 = max8997->buck2_vol[i];
1101                 if (max_buck5 < max8997->buck5_vol[i])
1102                         max_buck5 = max8997->buck5_vol[i];
1103         }
1104 
1105         /* For the safety, set max voltage before setting up */
1106         for (i = 0; i < 8; i++) {
1107                 max8997_update_reg(i2c, MAX8997_REG_BUCK1DVS1 + i,
1108                                 max_buck1, 0x3f);
1109                 max8997_update_reg(i2c, MAX8997_REG_BUCK2DVS1 + i,
1110                                 max_buck2, 0x3f);
1111                 max8997_update_reg(i2c, MAX8997_REG_BUCK5DVS1 + i,
1112                                 max_buck5, 0x3f);
1113         }
1114 
1115         /* Initialize all the DVS related BUCK registers */
1116         for (i = 0; i < nr_dvs; i++) {
1117                 max8997_update_reg(i2c, MAX8997_REG_BUCK1DVS1 + i,
1118                                 max8997->buck1_vol[i],
1119                                 0x3f);
1120                 max8997_update_reg(i2c, MAX8997_REG_BUCK2DVS1 + i,
1121                                 max8997->buck2_vol[i],
1122                                 0x3f);
1123                 max8997_update_reg(i2c, MAX8997_REG_BUCK5DVS1 + i,
1124                                 max8997->buck5_vol[i],
1125                                 0x3f);
1126         }
1127 
1128         /*
1129          * If buck 1, 2, and 5 do not care DVS GPIO settings, ignore them.
1130          * If at least one of them cares, set gpios.
1131          */
1132         if (pdata->buck1_gpiodvs || pdata->buck2_gpiodvs ||
1133                         pdata->buck5_gpiodvs) {
1134 
1135                 if (!gpio_is_valid(pdata->buck125_gpios[0]) ||
1136                                 !gpio_is_valid(pdata->buck125_gpios[1]) ||
1137                                 !gpio_is_valid(pdata->buck125_gpios[2])) {
1138                         dev_err(&pdev->dev, "GPIO NOT VALID\n");
1139                         return -EINVAL;
1140                 }
1141 
1142                 ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[0],
1143                                         "MAX8997 SET1");
1144                 if (ret)
1145                         return ret;
1146 
1147                 ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[1],
1148                                         "MAX8997 SET2");
1149                 if (ret)
1150                         return ret;
1151 
1152                 ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[2],
1153                                 "MAX8997 SET3");
1154                 if (ret)
1155                         return ret;
1156 
1157                 gpio_direction_output(pdata->buck125_gpios[0],
1158                                 (max8997->buck125_gpioindex >> 2)
1159                                 & 0x1); /* SET1 */
1160                 gpio_direction_output(pdata->buck125_gpios[1],
1161                                 (max8997->buck125_gpioindex >> 1)
1162                                 & 0x1); /* SET2 */
1163                 gpio_direction_output(pdata->buck125_gpios[2],
1164                                 (max8997->buck125_gpioindex >> 0)
1165                                 & 0x1); /* SET3 */
1166         }
1167 
1168         /* DVS-GPIO disabled */
1169         max8997_update_reg(i2c, MAX8997_REG_BUCK1CTRL, (pdata->buck1_gpiodvs) ?
1170                         (1 << 1) : (0 << 1), 1 << 1);
1171         max8997_update_reg(i2c, MAX8997_REG_BUCK2CTRL, (pdata->buck2_gpiodvs) ?
1172                         (1 << 1) : (0 << 1), 1 << 1);
1173         max8997_update_reg(i2c, MAX8997_REG_BUCK5CTRL, (pdata->buck5_gpiodvs) ?
1174                         (1 << 1) : (0 << 1), 1 << 1);
1175 
1176         /* Misc Settings */
1177         max8997->ramp_delay = 10; /* set 10mV/us, which is the default */
1178         max8997_write_reg(i2c, MAX8997_REG_BUCKRAMP, (0xf << 4) | 0x9);
1179 
1180         for (i = 0; i < pdata->num_regulators; i++) {
1181                 const struct voltage_map_desc *desc;
1182                 int id = pdata->regulators[i].id;
1183 
1184                 desc = reg_voltage_map[id];
1185                 if (desc) {
1186                         regulators[id].n_voltages =
1187                                 (desc->max - desc->min) / desc->step + 1;
1188                 } else if (id == MAX8997_ESAFEOUT1 || id == MAX8997_ESAFEOUT2) {
1189                         regulators[id].volt_table = safeoutvolt;
1190                         regulators[id].n_voltages = ARRAY_SIZE(safeoutvolt);
1191                 } else if (id == MAX8997_CHARGER_CV) {
1192                         regulators[id].n_voltages = 16;
1193                 }
1194 
1195                 config.dev = max8997->dev;
1196                 config.init_data = pdata->regulators[i].initdata;
1197                 config.driver_data = max8997;
1198                 config.of_node = pdata->regulators[i].reg_node;
1199 
1200                 rdev = devm_regulator_register(&pdev->dev, &regulators[id],
1201                                                &config);
1202                 if (IS_ERR(rdev)) {
1203                         dev_err(max8997->dev, "regulator init failed for %d\n",
1204                                         id);
1205                         return PTR_ERR(rdev);
1206                 }
1207         }
1208 
1209         return 0;
1210 }
1211 
1212 static const struct platform_device_id max8997_pmic_id[] = {
1213         { "max8997-pmic", 0},
1214         { },
1215 };
1216 MODULE_DEVICE_TABLE(platform, max8997_pmic_id);
1217 
1218 static struct platform_driver max8997_pmic_driver = {
1219         .driver = {
1220                 .name = "max8997-pmic",
1221                 .owner = THIS_MODULE,
1222         },
1223         .probe = max8997_pmic_probe,
1224         .id_table = max8997_pmic_id,
1225 };
1226 
1227 static int __init max8997_pmic_init(void)
1228 {
1229         return platform_driver_register(&max8997_pmic_driver);
1230 }
1231 subsys_initcall(max8997_pmic_init);
1232 
1233 static void __exit max8997_pmic_cleanup(void)
1234 {
1235         platform_driver_unregister(&max8997_pmic_driver);
1236 }
1237 module_exit(max8997_pmic_cleanup);
1238 
1239 MODULE_DESCRIPTION("MAXIM 8997/8966 Regulator Driver");
1240 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
1241 MODULE_LICENSE("GPL");
1242 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us