]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/regulator/lp8788-buck.c
regulator: lp8788-buck: Kill _gpio_request function
[~shefty/rdma-dev.git] / drivers / regulator / lp8788-buck.c
1 /*
2  * TI LP8788 MFD - buck regulator driver
3  *
4  * Copyright 2012 Texas Instruments
5  *
6  * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  */
13
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/err.h>
17 #include <linux/platform_device.h>
18 #include <linux/regulator/driver.h>
19 #include <linux/mfd/lp8788.h>
20 #include <linux/gpio.h>
21
22 /* register address */
23 #define LP8788_EN_BUCK                  0x0C
24 #define LP8788_BUCK_DVS_SEL             0x1D
25 #define LP8788_BUCK1_VOUT0              0x1E
26 #define LP8788_BUCK1_VOUT1              0x1F
27 #define LP8788_BUCK1_VOUT2              0x20
28 #define LP8788_BUCK1_VOUT3              0x21
29 #define LP8788_BUCK2_VOUT0              0x22
30 #define LP8788_BUCK2_VOUT1              0x23
31 #define LP8788_BUCK2_VOUT2              0x24
32 #define LP8788_BUCK2_VOUT3              0x25
33 #define LP8788_BUCK3_VOUT               0x26
34 #define LP8788_BUCK4_VOUT               0x27
35 #define LP8788_BUCK1_TIMESTEP           0x28
36 #define LP8788_BUCK_PWM                 0x2D
37
38 /* mask/shift bits */
39 #define LP8788_EN_BUCK1_M               BIT(0)  /* Addr 0Ch */
40 #define LP8788_EN_BUCK2_M               BIT(1)
41 #define LP8788_EN_BUCK3_M               BIT(2)
42 #define LP8788_EN_BUCK4_M               BIT(3)
43 #define LP8788_BUCK1_DVS_SEL_M          0x04    /* Addr 1Dh */
44 #define LP8788_BUCK1_DVS_M              0x03
45 #define LP8788_BUCK1_DVS_S              0
46 #define LP8788_BUCK2_DVS_SEL_M          0x40
47 #define LP8788_BUCK2_DVS_M              0x30
48 #define LP8788_BUCK2_DVS_S              4
49 #define LP8788_BUCK1_DVS_I2C            BIT(2)
50 #define LP8788_BUCK2_DVS_I2C            BIT(6)
51 #define LP8788_BUCK1_DVS_PIN            (0 << 2)
52 #define LP8788_BUCK2_DVS_PIN            (0 << 6)
53 #define LP8788_VOUT_M                   0x1F    /* Addr 1Eh ~ 27h */
54 #define LP8788_STARTUP_TIME_M           0xF8    /* Addr 28h ~ 2Bh */
55 #define LP8788_STARTUP_TIME_S           3
56 #define LP8788_FPWM_BUCK1_M             BIT(0)  /* Addr 2Dh */
57 #define LP8788_FPWM_BUCK1_S             0
58 #define LP8788_FPWM_BUCK2_M             BIT(1)
59 #define LP8788_FPWM_BUCK2_S             1
60 #define LP8788_FPWM_BUCK3_M             BIT(2)
61 #define LP8788_FPWM_BUCK3_S             2
62 #define LP8788_FPWM_BUCK4_M             BIT(3)
63 #define LP8788_FPWM_BUCK4_S             3
64
65 #define INVALID_ADDR                    0xFF
66 #define LP8788_FORCE_PWM                1
67 #define LP8788_AUTO_PWM                 0
68 #define PIN_LOW                         0
69 #define PIN_HIGH                        1
70 #define ENABLE_TIME_USEC                32
71
72 #define BUCK_FPWM_MASK(x)               (1 << (x))
73 #define BUCK_FPWM_SHIFT(x)              (x)
74
75 enum lp8788_dvs_state {
76         DVS_LOW  = GPIOF_OUT_INIT_LOW,
77         DVS_HIGH = GPIOF_OUT_INIT_HIGH,
78 };
79
80 enum lp8788_dvs_mode {
81         REGISTER,
82         EXTPIN,
83 };
84
85 enum lp8788_buck_id {
86         BUCK1,
87         BUCK2,
88         BUCK3,
89         BUCK4,
90 };
91
92 struct lp8788_buck {
93         struct lp8788 *lp;
94         struct regulator_dev *regulator;
95         void *dvs;
96 };
97
98 /* BUCK 1 ~ 4 voltage table */
99 static const int lp8788_buck_vtbl[] = {
100          500000,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
101         1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
102         1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
103         1950000, 2000000,
104 };
105
106 static const u8 buck1_vout_addr[] = {
107         LP8788_BUCK1_VOUT0, LP8788_BUCK1_VOUT1,
108         LP8788_BUCK1_VOUT2, LP8788_BUCK1_VOUT3,
109 };
110
111 static const u8 buck2_vout_addr[] = {
112         LP8788_BUCK2_VOUT0, LP8788_BUCK2_VOUT1,
113         LP8788_BUCK2_VOUT2, LP8788_BUCK2_VOUT3,
114 };
115
116 static void lp8788_buck1_set_dvs(struct lp8788_buck *buck)
117 {
118         struct lp8788_buck1_dvs *dvs = (struct lp8788_buck1_dvs *)buck->dvs;
119         enum lp8788_dvs_state pinstate;
120
121         if (!dvs)
122                 return;
123
124         pinstate = dvs->vsel == DVS_SEL_V0 ? DVS_LOW : DVS_HIGH;
125         if (gpio_is_valid(dvs->gpio))
126                 gpio_set_value(dvs->gpio, pinstate);
127 }
128
129 static void lp8788_buck2_set_dvs(struct lp8788_buck *buck)
130 {
131         struct lp8788_buck2_dvs *dvs = (struct lp8788_buck2_dvs *)buck->dvs;
132         enum lp8788_dvs_state pin1, pin2;
133
134         if (!dvs)
135                 return;
136
137         switch (dvs->vsel) {
138         case DVS_SEL_V0:
139                 pin1 = DVS_LOW;
140                 pin2 = DVS_LOW;
141                 break;
142         case DVS_SEL_V1:
143                 pin1 = DVS_HIGH;
144                 pin2 = DVS_LOW;
145                 break;
146         case DVS_SEL_V2:
147                 pin1 = DVS_LOW;
148                 pin2 = DVS_HIGH;
149                 break;
150         case DVS_SEL_V3:
151                 pin1 = DVS_HIGH;
152                 pin2 = DVS_HIGH;
153                 break;
154         default:
155                 return;
156         }
157
158         if (gpio_is_valid(dvs->gpio[0]))
159                 gpio_set_value(dvs->gpio[0], pin1);
160
161         if (gpio_is_valid(dvs->gpio[1]))
162                 gpio_set_value(dvs->gpio[1], pin2);
163 }
164
165 static void lp8788_set_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
166 {
167         switch (id) {
168         case BUCK1:
169                 lp8788_buck1_set_dvs(buck);
170                 break;
171         case BUCK2:
172                 lp8788_buck2_set_dvs(buck);
173                 break;
174         default:
175                 break;
176         }
177 }
178
179 static enum lp8788_dvs_mode
180 lp8788_get_buck_dvs_ctrl_mode(struct lp8788_buck *buck, enum lp8788_buck_id id)
181 {
182         u8 val, mask;
183
184         switch (id) {
185         case BUCK1:
186                 mask = LP8788_BUCK1_DVS_SEL_M;
187                 break;
188         case BUCK2:
189                 mask = LP8788_BUCK2_DVS_SEL_M;
190                 break;
191         default:
192                 return REGISTER;
193         }
194
195         lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
196
197         return val & mask ? REGISTER : EXTPIN;
198 }
199
200 static bool lp8788_is_valid_buck_addr(u8 addr)
201 {
202         switch (addr) {
203         case LP8788_BUCK1_VOUT0:
204         case LP8788_BUCK1_VOUT1:
205         case LP8788_BUCK1_VOUT2:
206         case LP8788_BUCK1_VOUT3:
207         case LP8788_BUCK2_VOUT0:
208         case LP8788_BUCK2_VOUT1:
209         case LP8788_BUCK2_VOUT2:
210         case LP8788_BUCK2_VOUT3:
211                 return true;
212         default:
213                 return false;
214         }
215 }
216
217 static u8 lp8788_select_buck_vout_addr(struct lp8788_buck *buck,
218                                         enum lp8788_buck_id id)
219 {
220         enum lp8788_dvs_mode mode = lp8788_get_buck_dvs_ctrl_mode(buck, id);
221         struct lp8788_buck1_dvs *b1_dvs;
222         struct lp8788_buck2_dvs *b2_dvs;
223         u8 val, idx, addr;
224         int pin1, pin2;
225
226         switch (id) {
227         case BUCK1:
228                 if (mode == EXTPIN) {
229                         b1_dvs = (struct lp8788_buck1_dvs *)buck->dvs;
230                         if (!b1_dvs)
231                                 goto err;
232
233                         idx = gpio_get_value(b1_dvs->gpio) ? 1 : 0;
234                 } else {
235                         lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
236                         idx = (val & LP8788_BUCK1_DVS_M) >> LP8788_BUCK1_DVS_S;
237                 }
238                 addr = buck1_vout_addr[idx];
239                 break;
240         case BUCK2:
241                 if (mode == EXTPIN) {
242                         b2_dvs = (struct lp8788_buck2_dvs *)buck->dvs;
243                         if (!b2_dvs)
244                                 goto err;
245
246                         pin1 = gpio_get_value(b2_dvs->gpio[0]);
247                         pin2 = gpio_get_value(b2_dvs->gpio[1]);
248
249                         if (pin1 == PIN_LOW && pin2 == PIN_LOW)
250                                 idx = 0;
251                         else if (pin1 == PIN_LOW && pin2 == PIN_HIGH)
252                                 idx = 2;
253                         else if (pin1 == PIN_HIGH && pin2 == PIN_LOW)
254                                 idx = 1;
255                         else
256                                 idx = 3;
257                 } else {
258                         lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
259                         idx = (val & LP8788_BUCK2_DVS_M) >> LP8788_BUCK2_DVS_S;
260                 }
261                 addr = buck2_vout_addr[idx];
262                 break;
263         default:
264                 goto err;
265         }
266
267         return addr;
268 err:
269         return INVALID_ADDR;
270 }
271
272 static int lp8788_buck12_set_voltage_sel(struct regulator_dev *rdev,
273                                         unsigned selector)
274 {
275         struct lp8788_buck *buck = rdev_get_drvdata(rdev);
276         enum lp8788_buck_id id = rdev_get_id(rdev);
277         u8 addr;
278
279         if (buck->dvs)
280                 lp8788_set_dvs(buck, id);
281
282         addr = lp8788_select_buck_vout_addr(buck, id);
283         if (!lp8788_is_valid_buck_addr(addr))
284                 return -EINVAL;
285
286         return lp8788_update_bits(buck->lp, addr, LP8788_VOUT_M, selector);
287 }
288
289 static int lp8788_buck12_get_voltage_sel(struct regulator_dev *rdev)
290 {
291         struct lp8788_buck *buck = rdev_get_drvdata(rdev);
292         enum lp8788_buck_id id = rdev_get_id(rdev);
293         int ret;
294         u8 val, addr;
295
296         addr = lp8788_select_buck_vout_addr(buck, id);
297         if (!lp8788_is_valid_buck_addr(addr))
298                 return -EINVAL;
299
300         ret = lp8788_read_byte(buck->lp, addr, &val);
301         if (ret)
302                 return ret;
303
304         return val & LP8788_VOUT_M;
305 }
306
307 static int lp8788_buck_enable_time(struct regulator_dev *rdev)
308 {
309         struct lp8788_buck *buck = rdev_get_drvdata(rdev);
310         enum lp8788_buck_id id = rdev_get_id(rdev);
311         u8 val, addr = LP8788_BUCK1_TIMESTEP + id;
312
313         if (lp8788_read_byte(buck->lp, addr, &val))
314                 return -EINVAL;
315
316         val = (val & LP8788_STARTUP_TIME_M) >> LP8788_STARTUP_TIME_S;
317
318         return ENABLE_TIME_USEC * val;
319 }
320
321 static int lp8788_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
322 {
323         struct lp8788_buck *buck = rdev_get_drvdata(rdev);
324         enum lp8788_buck_id id = rdev_get_id(rdev);
325         u8 mask, val;
326
327         mask = BUCK_FPWM_MASK(id);
328         switch (mode) {
329         case REGULATOR_MODE_FAST:
330                 val = LP8788_FORCE_PWM << BUCK_FPWM_SHIFT(id);
331                 break;
332         case REGULATOR_MODE_NORMAL:
333                 val = LP8788_AUTO_PWM << BUCK_FPWM_SHIFT(id);
334                 break;
335         default:
336                 return -EINVAL;
337         }
338
339         return lp8788_update_bits(buck->lp, LP8788_BUCK_PWM, mask, val);
340 }
341
342 static unsigned int lp8788_buck_get_mode(struct regulator_dev *rdev)
343 {
344         struct lp8788_buck *buck = rdev_get_drvdata(rdev);
345         enum lp8788_buck_id id = rdev_get_id(rdev);
346         u8 val;
347         int ret;
348
349         ret = lp8788_read_byte(buck->lp, LP8788_BUCK_PWM, &val);
350         if (ret)
351                 return ret;
352
353         return val & BUCK_FPWM_MASK(id) ?
354                                 REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
355 }
356
357 static struct regulator_ops lp8788_buck12_ops = {
358         .list_voltage = regulator_list_voltage_table,
359         .set_voltage_sel = lp8788_buck12_set_voltage_sel,
360         .get_voltage_sel = lp8788_buck12_get_voltage_sel,
361         .enable = regulator_enable_regmap,
362         .disable = regulator_disable_regmap,
363         .is_enabled = regulator_is_enabled_regmap,
364         .enable_time = lp8788_buck_enable_time,
365         .set_mode = lp8788_buck_set_mode,
366         .get_mode = lp8788_buck_get_mode,
367 };
368
369 static struct regulator_ops lp8788_buck34_ops = {
370         .list_voltage = regulator_list_voltage_table,
371         .set_voltage_sel = regulator_set_voltage_sel_regmap,
372         .get_voltage_sel = regulator_get_voltage_sel_regmap,
373         .enable = regulator_enable_regmap,
374         .disable = regulator_disable_regmap,
375         .is_enabled = regulator_is_enabled_regmap,
376         .enable_time = lp8788_buck_enable_time,
377         .set_mode = lp8788_buck_set_mode,
378         .get_mode = lp8788_buck_get_mode,
379 };
380
381 static struct regulator_desc lp8788_buck_desc[] = {
382         {
383                 .name = "buck1",
384                 .id = BUCK1,
385                 .ops = &lp8788_buck12_ops,
386                 .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
387                 .volt_table = lp8788_buck_vtbl,
388                 .type = REGULATOR_VOLTAGE,
389                 .owner = THIS_MODULE,
390                 .enable_reg = LP8788_EN_BUCK,
391                 .enable_mask = LP8788_EN_BUCK1_M,
392         },
393         {
394                 .name = "buck2",
395                 .id = BUCK2,
396                 .ops = &lp8788_buck12_ops,
397                 .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
398                 .volt_table = lp8788_buck_vtbl,
399                 .type = REGULATOR_VOLTAGE,
400                 .owner = THIS_MODULE,
401                 .enable_reg = LP8788_EN_BUCK,
402                 .enable_mask = LP8788_EN_BUCK2_M,
403         },
404         {
405                 .name = "buck3",
406                 .id = BUCK3,
407                 .ops = &lp8788_buck34_ops,
408                 .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
409                 .volt_table = lp8788_buck_vtbl,
410                 .type = REGULATOR_VOLTAGE,
411                 .owner = THIS_MODULE,
412                 .vsel_reg = LP8788_BUCK3_VOUT,
413                 .vsel_mask = LP8788_VOUT_M,
414                 .enable_reg = LP8788_EN_BUCK,
415                 .enable_mask = LP8788_EN_BUCK3_M,
416         },
417         {
418                 .name = "buck4",
419                 .id = BUCK4,
420                 .ops = &lp8788_buck34_ops,
421                 .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
422                 .volt_table = lp8788_buck_vtbl,
423                 .type = REGULATOR_VOLTAGE,
424                 .owner = THIS_MODULE,
425                 .vsel_reg = LP8788_BUCK4_VOUT,
426                 .vsel_mask = LP8788_VOUT_M,
427                 .enable_reg = LP8788_EN_BUCK,
428                 .enable_mask = LP8788_EN_BUCK4_M,
429         },
430 };
431
432 static int lp8788_dvs_gpio_request(struct lp8788_buck *buck,
433                                 enum lp8788_buck_id id)
434 {
435         struct lp8788_platform_data *pdata = buck->lp->pdata;
436         char *b1_name = "LP8788_B1_DVS";
437         char *b2_name[] = { "LP8788_B2_DVS1", "LP8788_B2_DVS2" };
438         int i, gpio, ret;
439
440         switch (id) {
441         case BUCK1:
442                 gpio = pdata->buck1_dvs->gpio;
443                 ret = devm_gpio_request_one(buck->lp->dev, gpio, DVS_LOW,
444                                             b1_name);
445                 if (ret)
446                         return ret;
447
448                 buck->dvs = pdata->buck1_dvs;
449                 break;
450         case BUCK2:
451                 for (i = 0 ; i < LP8788_NUM_BUCK2_DVS ; i++) {
452                         gpio = pdata->buck2_dvs->gpio[i];
453                         ret = devm_gpio_request_one(buck->lp->dev, gpio,
454                                                     DVS_LOW, b2_name[i]);
455                         if (ret)
456                                 return ret;
457                 }
458                 buck->dvs = pdata->buck2_dvs;
459                 break;
460         default:
461                 break;
462         }
463
464         return 0;
465 }
466
467 static int lp8788_init_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
468 {
469         struct lp8788_platform_data *pdata = buck->lp->pdata;
470         u8 mask[] = { LP8788_BUCK1_DVS_SEL_M, LP8788_BUCK2_DVS_SEL_M };
471         u8 val[]  = { LP8788_BUCK1_DVS_PIN, LP8788_BUCK2_DVS_PIN };
472         u8 default_dvs_mode[] = { LP8788_BUCK1_DVS_I2C, LP8788_BUCK2_DVS_I2C };
473
474         /* no dvs for buck3, 4 */
475         if (id == BUCK3 || id == BUCK4)
476                 return 0;
477
478         /* no dvs platform data, then dvs will be selected by I2C registers */
479         if (!pdata)
480                 goto set_default_dvs_mode;
481
482         if ((id == BUCK1 && !pdata->buck1_dvs) ||
483                 (id == BUCK2 && !pdata->buck2_dvs))
484                 goto set_default_dvs_mode;
485
486         if (lp8788_dvs_gpio_request(buck, id))
487                 goto set_default_dvs_mode;
488
489         return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
490                                 val[id]);
491
492 set_default_dvs_mode:
493         return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
494                                   default_dvs_mode[id]);
495 }
496
497 static __devinit int lp8788_buck_probe(struct platform_device *pdev)
498 {
499         struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
500         int id = pdev->id;
501         struct lp8788_buck *buck;
502         struct regulator_config cfg = { };
503         struct regulator_dev *rdev;
504         int ret;
505
506         buck = devm_kzalloc(lp->dev, sizeof(struct lp8788_buck), GFP_KERNEL);
507         if (!buck)
508                 return -ENOMEM;
509
510         buck->lp = lp;
511
512         ret = lp8788_init_dvs(buck, id);
513         if (ret)
514                 return ret;
515
516         cfg.dev = lp->dev;
517         cfg.init_data = lp->pdata ? lp->pdata->buck_data[id] : NULL;
518         cfg.driver_data = buck;
519         cfg.regmap = lp->regmap;
520
521         rdev = regulator_register(&lp8788_buck_desc[id], &cfg);
522         if (IS_ERR(rdev)) {
523                 ret = PTR_ERR(rdev);
524                 dev_err(lp->dev, "BUCK%d regulator register err = %d\n",
525                                 id + 1, ret);
526                 return ret;
527         }
528
529         buck->regulator = rdev;
530         platform_set_drvdata(pdev, buck);
531
532         return 0;
533 }
534
535 static int __devexit lp8788_buck_remove(struct platform_device *pdev)
536 {
537         struct lp8788_buck *buck = platform_get_drvdata(pdev);
538
539         platform_set_drvdata(pdev, NULL);
540         regulator_unregister(buck->regulator);
541
542         return 0;
543 }
544
545 static struct platform_driver lp8788_buck_driver = {
546         .probe = lp8788_buck_probe,
547         .remove = __devexit_p(lp8788_buck_remove),
548         .driver = {
549                 .name = LP8788_DEV_BUCK,
550                 .owner = THIS_MODULE,
551         },
552 };
553
554 static int __init lp8788_buck_init(void)
555 {
556         return platform_driver_register(&lp8788_buck_driver);
557 }
558 subsys_initcall(lp8788_buck_init);
559
560 static void __exit lp8788_buck_exit(void)
561 {
562         platform_driver_unregister(&lp8788_buck_driver);
563 }
564 module_exit(lp8788_buck_exit);
565
566 MODULE_DESCRIPTION("TI LP8788 BUCK Driver");
567 MODULE_AUTHOR("Milo Kim");
568 MODULE_LICENSE("GPL");
569 MODULE_ALIAS("platform:lp8788-buck");