regulator: palmas: implement sleep mode configuration
[linux-2.6.git] / drivers / regulator / max8973-regulator.c
1 /*
2  * max8973-regulator.c -- Maxim max8973
3  *
4  * Regulator driver for MAXIM 8973 DC-DC step-down switching regulator.
5  *
6  * Copyright (c) 2012, NVIDIA Corporation.
7  *
8  * Author: Laxman Dewangan <ldewangan@nvidia.com>
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation version 2.
13  *
14  * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
15  * whether express or implied; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
22  * 02111-1307, USA
23  */
24
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/err.h>
29 #include <linux/platform_device.h>
30 #include <linux/regulator/driver.h>
31 #include <linux/regulator/machine.h>
32 #include <linux/regulator/max8973-regulator.h>
33 #include <linux/gpio.h>
34 #include <linux/i2c.h>
35 #include <linux/slab.h>
36 #include <linux/regmap.h>
37
38 /* Register definitions */
39 #define MAX8973_VOUT                    0x0
40 #define MAX8973_VOUT_DVS                0x1
41 #define MAX8973_CONTROL1                0x2
42 #define MAX8973_CONTROL2                0x3
43 #define MAX8973_CHIPID1                 0x4
44 #define MAX8973_CHIPID2                 0x5
45
46 #define MAX8973_MAX_VOUT_REG            2
47
48 /* MAX8973_VOUT */
49 #define MAX8973_VOUT_ENABLE             BIT(7)
50 #define MAX8973_VOUT_MASK               0x7F
51
52 /* MAX8973_VOUT_DVS */
53 #define MAX8973_DVS_VOUT_MASK           0x7F
54
55 /* MAX8973_CONTROL1 */
56 #define MAX8973_SNS_ENABLE              BIT(7)
57 #define MAX8973_FPWM_EN_M               BIT(6)
58 #define MAX8973_NFSR_ENABLE             BIT(5)
59 #define MAX8973_AD_ENABLE               BIT(4)
60 #define MAX8973_BIAS_ENABLE             BIT(3)
61 #define MAX8973_FREQSHIFT_9PER          BIT(2)
62
63 #define MAX8973_RAMP_12mV_PER_US        0x0
64 #define MAX8973_RAMP_25mV_PER_US        0x1
65 #define MAX8973_RAMP_50mV_PER_US        0x2
66 #define MAX8973_RAMP_200mV_PER_US       0x3
67
68 /* MAX8973_CONTROL2 */
69 #define MAX8973_WDTMR_ENABLE            BIT(6)
70 #define MAX8973_DISCH_ENBABLE           BIT(5)
71 #define MAX8973_FT_ENABLE               BIT(4)
72
73 #define MAX8973_CKKADV_TRIP_DISABLE                     0xC
74 #define MAX8973_CKKADV_TRIP_75mV_PER_US                 0x0
75 #define MAX8973_CKKADV_TRIP_150mV_PER_US                0x4
76 #define MAX8973_CKKADV_TRIP_75mV_PER_US_HIST_DIS        0x8
77
78 #define MAX8973_INDUCTOR_MIN_30_PER     0x0
79 #define MAX8973_INDUCTOR_NOMINAL        0x1
80 #define MAX8973_INDUCTOR_PLUS_30_PER    0x2
81 #define MAX8973_INDUCTOR_PLUS_60_PER    0x3
82
83 #define MAX8973_MIN_VOLATGE             606250
84 #define MAX8973_MAX_VOLATGE             1400000
85 #define MAX8973_VOLATGE_STEP            6250
86 #define MAX8973_BUCK_N_VOLTAGE  \
87         (((MAX8973_MAX_VOLATGE - MAX8973_MIN_VOLATGE) / MAX8973_VOLATGE_STEP) \
88                         + 1)
89
90 /* Maxim 8973 chip information */
91 struct max8973_chip {
92         struct device *dev;
93         struct regulator_desc desc;
94         struct regulator_dev *rdev;
95         struct regmap *regmap;
96         bool enable_external_control;
97         int dvs_gpio;
98         int lru_index[MAX8973_MAX_VOUT_REG];
99         int curr_vout_val[MAX8973_MAX_VOUT_REG];
100         int curr_vout_reg;
101         int curr_gpio_val;
102         int change_uv_per_us;
103         bool valid_dvs_gpio;
104 };
105
106 /*
107  * find_voltage_set_register: Find new voltage configuration register (VOUT).
108  * The finding of the new VOUT register will be based on the LRU mechanism.
109  * Each VOUT register will have different voltage configured . This
110  * Function will look if any of the VOUT register have requested voltage set
111  * or not.
112  *     - If it is already there then it will make that register as most
113  *       recently used and return as found so that caller need not to set
114  *       the VOUT register but need to set the proper gpios to select this
115  *       VOUT register.
116  *     - If requested voltage is not found then it will use the least
117  *       recently mechanism to get new VOUT register for new configuration
118  *       and will return not_found so that caller need to set new VOUT
119  *       register and then gpios (both).
120  */
121 static bool find_voltage_set_register(struct max8973_chip *tps,
122                 int req_vsel, int *vout_reg, int *gpio_val)
123 {
124         int i;
125         bool found = false;
126         int new_vout_reg = tps->lru_index[MAX8973_MAX_VOUT_REG - 1];
127         int found_index = MAX8973_MAX_VOUT_REG - 1;
128
129         for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i) {
130                 if (tps->curr_vout_val[tps->lru_index[i]] == req_vsel) {
131                         new_vout_reg = tps->lru_index[i];
132                         found_index = i;
133                         found = true;
134                         goto update_lru_index;
135                 }
136         }
137
138 update_lru_index:
139         for (i = found_index; i > 0; i--)
140                 tps->lru_index[i] = tps->lru_index[i - 1];
141
142         tps->lru_index[0] = new_vout_reg;
143         *gpio_val = new_vout_reg;
144         *vout_reg = MAX8973_VOUT + new_vout_reg;
145         return found;
146 }
147
148 static int max8973_dcdc_get_voltage_sel(struct regulator_dev *rdev)
149 {
150         struct max8973_chip *max = rdev_get_drvdata(rdev);
151         unsigned int data;
152         int ret;
153
154         ret = regmap_read(max->regmap, max->curr_vout_reg, &data);
155         if (ret < 0) {
156                 dev_err(max->dev, "%s(): register %d read failed with err %d\n",
157                         __func__, max->curr_vout_reg, ret);
158                 return ret;
159         }
160         return data & MAX8973_VOUT_MASK;
161 }
162
163 static int max8973_dcdc_set_voltage(struct regulator_dev *rdev,
164              int min_uV, int max_uV, unsigned *selector)
165 {
166         struct max8973_chip *max = rdev_get_drvdata(rdev);
167         int vsel;
168         int ret;
169         bool found = false;
170         int vout_reg = max->curr_vout_reg;
171         int gpio_val = max->curr_gpio_val;
172
173         if ((max_uV < min_uV) || (max_uV < MAX8973_MIN_VOLATGE) ||
174                         (min_uV > MAX8973_MAX_VOLATGE))
175                 return -EINVAL;
176
177         vsel = DIV_ROUND_UP(min_uV - MAX8973_MIN_VOLATGE, MAX8973_VOLATGE_STEP);
178         if (selector)
179                 *selector = (vsel & MAX8973_VOUT_MASK);
180
181         /*
182          * If gpios are available to select the VOUT register then least
183          * recently used register for new configuration.
184          */
185         if (max->valid_dvs_gpio)
186                 found = find_voltage_set_register(max, vsel,
187                                         &vout_reg, &gpio_val);
188
189         if (!found) {
190                 ret = regmap_update_bits(max->regmap, vout_reg,
191                                                 MAX8973_VOUT_MASK, vsel);
192                 if (ret < 0) {
193                         dev_err(max->dev,
194                                 "%s(): register %d update failed with err %d\n",
195                                  __func__, vout_reg, ret);
196                         return ret;
197                 }
198                 max->curr_vout_reg = vout_reg;
199                 max->curr_vout_val[gpio_val] = vsel;
200         }
201
202         /* Select proper VOUT register vio gpios */
203         if (max->valid_dvs_gpio) {
204                 gpio_set_value_cansleep(max->dvs_gpio, gpio_val & 0x1);
205                 max->curr_gpio_val = gpio_val;
206         }
207         return 0;
208 }
209
210 static int max8973_dcdc_list_voltage(struct regulator_dev *rdev,
211                                         unsigned selector)
212 {
213         if (selector >= MAX8973_BUCK_N_VOLTAGE)
214                 return -EINVAL;
215
216         return MAX8973_MIN_VOLATGE + selector * MAX8973_VOLATGE_STEP;
217 }
218
219 static int max8973_dcdc_set_voltage_time_sel(struct regulator_dev *rdev,
220                 unsigned int old_selector, unsigned int new_selector)
221 {
222         struct max8973_chip *max = rdev_get_drvdata(rdev);
223         int old_uV, new_uV;
224
225         old_uV = max8973_dcdc_list_voltage(rdev, old_selector);
226         if (old_uV < 0)
227                 return old_uV;
228
229         new_uV = max8973_dcdc_list_voltage(rdev, new_selector);
230         if (new_uV < 0)
231                 return new_uV;
232
233         return DIV_ROUND_UP(abs(old_uV - new_uV), max->change_uv_per_us);
234 }
235 static int max8973_dcdc_enable(struct regulator_dev *rdev)
236 {
237         struct max8973_chip *max = rdev_get_drvdata(rdev);
238         int ret;
239
240         if (max->enable_external_control)
241                 return 0;
242
243         ret = regmap_update_bits(max->regmap, MAX8973_VOUT,
244                         MAX8973_VOUT_ENABLE, MAX8973_VOUT_ENABLE);
245         if (ret < 0)
246                 dev_err(max->dev, "%s(): register %d update failed with err %d",
247                          __func__, MAX8973_VOUT, ret);
248         return ret;
249 }
250
251 static int max8973_dcdc_disable(struct regulator_dev *rdev)
252 {
253         struct max8973_chip *max = rdev_get_drvdata(rdev);
254         int ret = 0;
255
256         if (max->enable_external_control)
257                 return 0;
258
259         ret = regmap_update_bits(max->regmap, MAX8973_VOUT,
260                                         MAX8973_VOUT_ENABLE, 0);
261         if (ret < 0)
262                 dev_err(max->dev, "%s(): register %d update failed with err %d",
263                          __func__, MAX8973_VOUT, ret);
264         return ret;
265 }
266
267 static int max8973_dcdc_is_enabled(struct regulator_dev *rdev)
268 {
269         struct max8973_chip *max = rdev_get_drvdata(rdev);
270         int ret;
271         unsigned int data;
272
273         if (max->enable_external_control)
274                 return 1;
275
276         ret = regmap_read(max->regmap, MAX8973_VOUT, &data);
277         if (ret < 0) {
278                 dev_err(max->dev, "%s(): register %d read failed with err %d",
279                         __func__, max->curr_vout_reg, ret);
280                 return ret;
281         }
282
283         return !!(data & MAX8973_VOUT_ENABLE);
284 }
285
286 static int max8973_dcdc_set_mode(struct regulator_dev *rdev, unsigned int mode)
287 {
288         struct max8973_chip *max = rdev_get_drvdata(rdev);
289         int ret;
290         int pwm;
291
292         /* Enable force PWM mode in FAST mode only. */
293         switch (mode) {
294         case REGULATOR_MODE_FAST:
295                 pwm = MAX8973_FPWM_EN_M;
296                 break;
297
298         case REGULATOR_MODE_NORMAL:
299                 pwm = 0;
300                 break;
301
302         default:
303                 return -EINVAL;
304         }
305
306         ret = regmap_update_bits(max->regmap, MAX8973_CONTROL1,
307                                 MAX8973_FPWM_EN_M, pwm);
308         if (ret < 0)
309                 dev_err(max->dev,
310                         "%s(): register %d update failed with err %d\n",
311                         __func__, MAX8973_CONTROL1, ret);
312         return ret;
313 }
314
315 static unsigned int max8973_dcdc_get_mode(struct regulator_dev *rdev)
316 {
317         struct max8973_chip *max = rdev_get_drvdata(rdev);
318         unsigned int data;
319         int ret;
320
321         ret = regmap_read(max->regmap, MAX8973_CONTROL1, &data);
322         if (ret < 0) {
323                 dev_err(max->dev, "%s(): register %d read failed with err %d\n",
324                         __func__, MAX8973_CONTROL1, ret);
325                 return ret;
326         }
327         return (data & MAX8973_FPWM_EN_M) ?
328                 REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
329 }
330
331 static struct regulator_ops max8973_dcdc_ops = {
332         .get_voltage_sel        = max8973_dcdc_get_voltage_sel,
333         .set_voltage            = max8973_dcdc_set_voltage,
334         .list_voltage           = max8973_dcdc_list_voltage,
335         .set_voltage_time_sel   = max8973_dcdc_set_voltage_time_sel,
336         .enable                 = max8973_dcdc_enable,
337         .disable                = max8973_dcdc_disable,
338         .is_enabled             = max8973_dcdc_is_enabled,
339         .set_mode               = max8973_dcdc_set_mode,
340         .get_mode               = max8973_dcdc_get_mode,
341 };
342
343 static int __devinit max8973_init_dcdc(struct max8973_chip *max,
344                 struct max8973_regulator_platform_data *pdata)
345 {
346         int ret;
347         uint8_t control1 = 0;
348         uint8_t control2 = 0;
349
350         if (pdata->control_flags & MAX8973_CONTROL_REMOTE_SENSE_ENABLE)
351                 control1 |= MAX8973_SNS_ENABLE;
352
353         if (!(pdata->control_flags & MAX8973_CONTROL_FALLING_SLEW_RATE_ENABLE))
354                 control1 |= MAX8973_NFSR_ENABLE;
355
356         if (pdata->control_flags & MAX8973_CONTROL_OUTPUT_ACTIVE_DISCH_ENABLE)
357                 control1 |= MAX8973_AD_ENABLE;
358
359         if (pdata->control_flags & MAX8973_CONTROL_BIAS_ENABLE)
360                 control1 |= MAX8973_BIAS_ENABLE;
361
362         if (pdata->control_flags & MAX8973_CONTROL_FREQ_SHIFT_9PER_ENABLE)
363                 control1 |= MAX8973_FREQSHIFT_9PER;
364
365         switch (pdata->control_flags & MAX8973_CONTROL_SLEW_RATE_200MV_PER_US) {
366         case MAX8973_CONTROL_SLEW_RATE_12_5mV_PER_US:
367                 control1 = MAX8973_RAMP_12mV_PER_US;
368                 max->change_uv_per_us = 12500;
369                 break;
370
371         case MAX8973_CONTROL_SLEW_RATE_25mV_PER_US:
372                 control1 = MAX8973_RAMP_25mV_PER_US;
373                 max->change_uv_per_us = 25000;
374                 break;
375
376         case MAX8973_CONTROL_SLEW_RATE_50mV_PER_US:
377                 control1 = MAX8973_RAMP_50mV_PER_US;
378                 max->change_uv_per_us = 50000;
379                 break;
380
381         case MAX8973_CONTROL_SLEW_RATE_200MV_PER_US:
382                 control1 = MAX8973_RAMP_200mV_PER_US;
383                 max->change_uv_per_us = 200000;
384                 break;
385         }
386
387         if (!(pdata->control_flags & MAX8973_CONTROL_PULL_DOWN_ENABLE))
388                 control2 |= MAX8973_DISCH_ENBABLE;
389
390         switch (pdata->control_flags &
391                                 MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US) {
392         case MAX8973_CONTROL_CLKADV_TRIP_DISABLED:
393                 control2 |= MAX8973_CKKADV_TRIP_DISABLE;
394                 break;
395
396         case MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US:
397                 control2 |= MAX8973_CKKADV_TRIP_75mV_PER_US;
398                 break;
399
400         case MAX8973_CONTROL_CLKADV_TRIP_150mV_PER_US:
401                 control2 |= MAX8973_CKKADV_TRIP_150mV_PER_US;
402                 break;
403
404         case MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US_HIST_DIS:
405                 control2 |= MAX8973_CKKADV_TRIP_75mV_PER_US_HIST_DIS;
406                 break;
407         }
408
409         switch (pdata->control_flags &
410                         MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_60_PER) {
411         case MAX8973_CONTROL_INDUCTOR_VALUE_NOMINAL:
412                 control2 |= MAX8973_INDUCTOR_NOMINAL;
413                 break;
414
415         case MAX8973_CONTROL_INDUCTOR_VALUE_MINUS_30_PER:
416                 control2 |= MAX8973_INDUCTOR_MIN_30_PER;
417                 break;
418
419         case MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_30_PER:
420                 control2 |= MAX8973_INDUCTOR_PLUS_30_PER;
421                 break;
422
423         case MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_60_PER:
424                 control2 |= MAX8973_INDUCTOR_PLUS_60_PER;
425                 break;
426         }
427
428         ret = regmap_write(max->regmap, MAX8973_CONTROL1, control1);
429         if (ret < 0) {
430                 dev_err(max->dev, "%s(): register %d write failed with err %d",
431                         __func__, MAX8973_CONTROL1, ret);
432                 return ret;
433         }
434
435         ret = regmap_write(max->regmap, MAX8973_CONTROL2, control2);
436         if (ret < 0) {
437                 dev_err(max->dev, "%s(): register %d write failed with err %d",
438                         __func__, MAX8973_CONTROL2, ret);
439                 return ret;
440         }
441
442         /* If external control is enabled then disable EN bit */
443         if (max->enable_external_control) {
444                 ret = regmap_update_bits(max->regmap, MAX8973_VOUT,
445                                                 MAX8973_VOUT_ENABLE, 0);
446                 if (ret < 0)
447                         dev_err(max->dev, "%s(): register %d update failed with err %d",
448                         __func__, MAX8973_VOUT, ret);
449         }
450         return ret;
451 }
452
453 static const struct regmap_config max8973_regmap_config = {
454         .reg_bits               = 8,
455         .val_bits               = 8,
456         .max_register           = MAX8973_CHIPID2,
457         .cache_type             = REGCACHE_RBTREE,
458 };
459
460 static int __devinit max8973_probe(struct i2c_client *client,
461                                      const struct i2c_device_id *id)
462 {
463         struct max8973_regulator_platform_data *pdata;
464         struct regulator_dev *rdev;
465         struct max8973_chip *max;
466         int ret;
467
468         pdata = client->dev.platform_data;
469         if (!pdata) {
470                 dev_err(&client->dev, "%s(): No Platform data", __func__);
471                 return -EIO;
472         }
473
474         max = devm_kzalloc(&client->dev, sizeof(*max), GFP_KERNEL);
475         if (!max) {
476                 dev_err(&client->dev, "%s(): Memory allocation failed\n",
477                                                 __func__);
478                 return -ENOMEM;
479         }
480
481         max->dev = &client->dev;
482
483         max->desc.name = id->name;
484         max->desc.id = 0;
485         max->desc.ops = &max8973_dcdc_ops;
486         max->desc.type = REGULATOR_VOLTAGE;
487         max->desc.owner = THIS_MODULE;
488         max->regmap = devm_regmap_init_i2c(client, &max8973_regmap_config);
489         if (IS_ERR(max->regmap)) {
490                 ret = PTR_ERR(max->regmap);
491                 dev_err(&client->dev,
492                         "%s(): regmap allocation failed with err %d\n",
493                         __func__, ret);
494                 return ret;
495         }
496         i2c_set_clientdata(client, max);
497
498         max->enable_external_control = pdata->enable_ext_control;
499         max->dvs_gpio = pdata->dvs_gpio;
500         max->curr_gpio_val = pdata->dvs_def_state;
501         max->curr_vout_reg = MAX8973_VOUT + pdata->dvs_def_state;
502         max->lru_index[0] = max->curr_vout_reg;
503         max->valid_dvs_gpio = false;
504
505         if (gpio_is_valid(max->dvs_gpio)) {
506                 int gpio_flags;
507                 int i;
508
509                 gpio_flags = (pdata->dvs_def_state) ?
510                                 GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
511                 ret = gpio_request_one(max->dvs_gpio,
512                                 gpio_flags, "max8973-dvs");
513                 if (ret) {
514                         dev_err(&client->dev,
515                                 "%s(): Could not obtain dvs GPIO %d: %d\n",
516                                 __func__, max->dvs_gpio, ret);
517                         return ret;
518                 }
519                 max->valid_dvs_gpio = true;
520
521                 /*
522                  * Initialize the lru index with vout_reg id
523                  * The index 0 will be most recently used and
524                  * set with the max->curr_vout_reg */
525                 for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i)
526                         max->lru_index[i] = i;
527                 max->lru_index[0] = max->curr_vout_reg;
528                 max->lru_index[max->curr_vout_reg] = 0;
529         }
530
531         ret = max8973_init_dcdc(max, pdata);
532         if (ret < 0) {
533                 dev_err(max->dev, "%s(): Init failed with err = %d\n",
534                                 __func__, ret);
535                 goto err_init;
536         }
537
538         /* Register the regulators */
539         rdev = regulator_register(&max->desc, &client->dev,
540                         pdata->reg_init_data, max, NULL);
541         if (IS_ERR(rdev)) {
542                 dev_err(max->dev,
543                         "%s(): regulator register failed with err %s\n",
544                         __func__, id->name);
545                 ret = PTR_ERR(rdev);
546                 goto err_init;
547         }
548
549         max->rdev = rdev;
550         return 0;
551
552 err_init:
553         if (gpio_is_valid(max->dvs_gpio))
554                 gpio_free(max->dvs_gpio);
555         return ret;
556 }
557
558 /**
559  * max8973_remove - max8973 driver i2c remove handler
560  * @client: i2c driver client device structure
561  *
562  * Unregister TPS driver as an i2c client device driver
563  */
564 static int __devexit max8973_remove(struct i2c_client *client)
565 {
566         struct max8973_chip *max = i2c_get_clientdata(client);
567
568         if (gpio_is_valid(max->dvs_gpio))
569                 gpio_free(max->dvs_gpio);
570
571         regulator_unregister(max->rdev);
572         return 0;
573 }
574
575 static const struct i2c_device_id max8973_id[] = {
576         {.name = "max8973",},
577         {},
578 };
579
580 MODULE_DEVICE_TABLE(i2c, max8973_id);
581
582 static struct i2c_driver max8973_i2c_driver = {
583         .driver = {
584                 .name = "max8973",
585                 .owner = THIS_MODULE,
586         },
587         .probe = max8973_probe,
588         .remove = __devexit_p(max8973_remove),
589         .id_table = max8973_id,
590 };
591
592 static int __init max8973_init(void)
593 {
594         return i2c_add_driver(&max8973_i2c_driver);
595 }
596 subsys_initcall(max8973_init);
597
598 static void __exit max8973_cleanup(void)
599 {
600         i2c_del_driver(&max8973_i2c_driver);
601 }
602 module_exit(max8973_cleanup);
603
604 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
605 MODULE_DESCRIPTION("MAX8973 voltage regulator driver");
606 MODULE_LICENSE("GPL v2");