LP8758 pre version
[mlp-open-source/kernel.git] / drivers / regulator / lp8758.c
1 /*
2 * Simple driver for Texas Instruments lp8758 Regulator chip
3 *
4 * Copyright (C) 2015 Texas Instruments
5 * Author: Daniel Jeong  <daniel.jeong@ti.com>
6 *         Ldd Mlp <ldd-mlp@list.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 */
14 /********************************************************************
15 Notice : 
16         It is a preliminary version based on f0 for reference. 
17         A consolidated verson will be released soon.
18 ********************************************************************/
22 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <linux/err.h>
25 #include <linux/i2c.h>
26 #include <linux/regmap.h>
27 #include <linux/interrupt.h>
28 #include <linux/gpio.h>
29 #include <linux/of.h>
30 #include <linux/of_gpio.h>
31 #include <linux/uaccess.h>
32 #include <linux/regulator/driver.h>
33 #include <linux/regulator/machine.h>
34 #include <linux/regulator/of_regulator.h>
35 #include <linux/platform_data/lp8758.h>
37 struct lp8758_chip {
38         struct device *dev;
39         struct regmap *regmap;
40         struct lp8758_platform_data *pdata;
42         int irq;
43         struct regulator_dev *rdev[LP8758_BUCK_MAX];
44 };
46 /* voltage map */
47 static const unsigned int lp8758_buck_voltage_map[] = {
48         /* 0.50V - 0.73V : 10mV steps */
49          500000,  510000,  520000,  530000,  540000,  550000,  560000,  570000,
50          580000,  590000,  600000,  610000,  620000,  630000,  640000,  650000,
51          660000,  670000,  680000,  690000,  700000,  710000,  720000,  730000,
52         /* 0.73V - 1.40V :  5mV steps */
53          735000,  740000,  745000,  750000,  755000,  760000,  765000,  770000,
54          775000,  780000,  785000,  790000,  795000,  800000,  805000,  810000,
55          815000,  820000,  825000,  830000,  835000,  840000,  845000,  850000,
56          855000,  860000,  865000,  870000,  875000,  880000,  885000,  890000, 
57          895000,  900000,  905000,  910000,  915000,  920000,  925000,  930000,
58          935000,  940000,  945000,  950000,  955000,  960000,  965000,  970000,
59          975000,  980000,  985000,  990000,  995000, 1000000, 1005000, 1010000,
60         1015000, 1020000, 1025000, 1030000, 1035000, 1040000, 1045000, 1050000,
61         1055000, 1060000, 1065000, 1070000, 1075000, 1080000, 1085000, 1090000,
62         1095000, 1100000, 1105000, 1110000, 1115000, 1120000, 1125000, 1130000,
63         1135000, 1140000, 1145000, 1150000,     1155000, 1160000, 1165000, 1170000,
64         1175000, 1180000, 1185000, 1190000, 1195000, 1200000, 1205000, 1210000,
65         1215000, 1220000, 1225000, 1230000, 1235000, 1240000, 1245000, 1250000,
66         1255000, 1260000, 1265000, 1270000, 1275000, 1280000, 1285000, 1290000,
67         1295000, 1300000, 1305000, 1310000, 1315000, 1320000, 1325000, 1330000,
68         1335000, 1340000, 1345000, 1350000,     1355000, 1360000, 1365000, 1370000,
69         1375000, 1380000, 1385000, 1390000, 1395000, 1400000,
70         /* 1.40V - 3.36V : 20mV steps */
71         1420000, 1440000, 1460000, 1480000, 1500000, 1520000, 1540000, 1560000,
72         1580000, 1600000, 1620000, 1640000, 1660000, 1680000, 1700000, 1720000,
73         1740000, 1760000, 1780000, 1800000, 1820000, 1840000, 1860000, 1880000,
74         1900000, 1920000, 1940000, 1960000, 1980000, 2000000, 2020000, 2040000,
75         2060000, 2080000, 2100000, 2120000, 2140000, 2160000, 2180000, 2200000,
76         2220000, 2240000, 2260000, 2280000, 2300000, 2320000, 2340000, 2360000,
77         2380000, 2400000, 2420000, 2440000, 2460000, 2480000, 2500000, 2520000,
78         2540000, 2560000, 2580000, 2600000, 2620000, 2640000, 2660000, 2680000,
79         2700000, 2720000, 2740000, 2760000, 2780000, 2800000, 2820000, 2840000,
80         2860000, 2880000, 2900000, 2920000, 2940000, 2960000, 2980000, 3000000,
81         3020000, 3040000, 3060000, 3080000, 3100000, 3120000, 3140000, 3160000,
82         3180000, 3200000, 3220000, 3240000, 3260000, 3280000, 3300000, 3320000,
83         3340000, 3360000,
84 };
86 /* current limit */
87 static const unsigned int lp8758_current_limit_uA[] = {
88         1500000, 2000000, 2500000, 3000000, 3500000, 4000000, 4500000, 5000000
89 };
91 static int lp8758_read(struct lp8758_chip *pchip, unsigned int reg,
92                        unsigned int *val)
93 {
94         return regmap_read(pchip->regmap, reg, val);
95 }
97 static int lp8758_write(struct lp8758_chip *pchip, unsigned int reg,
98                         unsigned int val)
99 {
100         return regmap_write(pchip->regmap, reg, val);
103 static int lp8758_update_bits(struct lp8758_chip *pchip, unsigned int reg,
104                               unsigned int mask, unsigned int val)
106         return regmap_update_bits(pchip->regmap, reg, mask, val);
109 static int lp8758_buck_set_current_limit(struct regulator_dev *rdev,
110                                         int min_uA, int max_uA)
112         struct lp8758_chip *pchip = rdev_get_drvdata(rdev);
113         enum lp8758_bucks buck = rdev_get_id(rdev);
114         int icnt;
115         u8 addr;
117         switch (buck) {
118         case LP8758_BUCK0:
119                 addr = LP8758_REG_BUCK0_CTRL2;
120                 break;
121         case LP8758_BUCK2:
122                 addr = LP8758_REG_BUCK2_CTRL2;
123                 break;
124         default:
125                 return -EINVAL;
126         }
128         for (icnt = ARRAY_SIZE(lp8758_current_limit_uA) - 1; icnt >= 0; icnt--) {
129                 if (lp8758_current_limit_uA[icnt] >= min_uA &&
130                         lp8758_current_limit_uA[icnt] <= max_uA)
131                         return lp8758_update_bits(pchip, addr,
132                                                   LP8758_ILIM_MASK, icnt << LP8758_ILIM_SHIFT);
133         }
135         return -EINVAL;
138 static int lp8758_buck_get_current_limit(struct regulator_dev *rdev)
140         struct lp8758_chip *pchip = rdev_get_drvdata(rdev);
141         enum lp8758_bucks buck = rdev_get_id(rdev);
142         u8 addr;
143         unsigned int val;
144         int ret;
146         switch (buck) {
147         case LP8758_BUCK0:
148                 addr = LP8758_REG_BUCK0_CTRL2;
149                 break;
150         case LP8758_BUCK2:
151                 addr = LP8758_REG_BUCK2_CTRL2;
152                 break;
153         default:
154                 return -EINVAL;
155         }
157         ret = lp8758_read(pchip, addr, &val);
158         if (ret)
159                 return ret;
161         val = (val & LP8758_ILIM_MASK) >> LP8758_ILIM_SHIFT;
163         return (val < ARRAY_SIZE(lp8758_current_limit_uA)) ?
164                         lp8758_current_limit_uA[val] : -EINVAL;
167 static int lp8758_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
169         struct lp8758_chip *pchip = rdev_get_drvdata(rdev);
170         enum lp8758_bucks buck = rdev_get_id(rdev);
171         u8 addr;
173         switch (buck) {
174         case LP8758_BUCK0:
175                 addr = LP8758_REG_BUCK0_CTRL1;
176                 break;
177         case LP8758_BUCK2:
178                 addr = LP8758_REG_BUCK2_CTRL1;
179                 break;
180         default:
181                 return -EINVAL;
182         }
184         if (mode == REGULATOR_MODE_FAST)
185                 return lp8758_update_bits(pchip, addr, 0x02, 0x02);
186         else if (mode == REGULATOR_MODE_NORMAL)
187                 return lp8758_update_bits(pchip, addr, 0x02, 0x00);
188         else
189                 return -EINVAL;
192 static unsigned int lp8758_buck_get_mode(struct regulator_dev *rdev)
194         struct lp8758_chip *pchip = rdev_get_drvdata(rdev);
195         enum lp8758_bucks buck = rdev_get_id(rdev);
196         unsigned int val;
197         u8 addr;
198         int ret;
200         switch (buck) {
201         case LP8758_BUCK0:
202                 addr = LP8758_REG_BUCK0_CTRL1;
203                 break;
204         case LP8758_BUCK2:
205                 addr = LP8758_REG_BUCK2_CTRL1;
206                 break;
207         default:
208                 return -EINVAL;
209         }
211         ret = lp8758_read(pchip, addr, &val);
212         if (ret)
213                 return ret;
215         return val & 0x02 ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
218 static struct regulator_ops lp8758_buck_ops = {
219         .map_voltage = regulator_map_voltage_ascend,
220         .list_voltage = regulator_list_voltage_table,
221         .set_voltage_sel = regulator_set_voltage_sel_regmap,
222         .get_voltage_sel = regulator_get_voltage_sel_regmap,
223         .enable = regulator_enable_regmap,
224         .disable = regulator_disable_regmap,
225         .is_enabled = regulator_is_enabled_regmap,
226         .set_mode = lp8758_buck_set_mode,
227         .get_mode = lp8758_buck_get_mode,
228         .set_current_limit = lp8758_buck_set_current_limit,
229         .get_current_limit = lp8758_buck_get_current_limit,
230 };
232 static struct regulator_desc lp8758_regulators[LP8758_BUCK_MAX] = {
233         {
234                 .name = "lp8758-buck0",
235                 .id = LP8758_BUCK0,
236                 .ops = &lp8758_buck_ops,
237                 .n_voltages = ARRAY_SIZE(lp8758_buck_voltage_map),
238                 .volt_table = lp8758_buck_voltage_map,
239                 .type = REGULATOR_VOLTAGE,
240                 .owner = THIS_MODULE,
241                 .enable_reg = LP8758_REG_BUCK0_CTRL1,
242                 .enable_mask = LP8758_BUCK_EN_MASK,
243                 .vsel_reg = LP8758_REG_BUCK0_VOUT,
244                 .vsel_mask = LP8758_BUCK_VOUT_MASK,
245         },
246         {
247                 .name = "lp8758-buck2",
248                 .id = LP8758_BUCK2,
249                 .ops = &lp8758_buck_ops,
250                 .n_voltages = ARRAY_SIZE(lp8758_buck_voltage_map),
251                 .volt_table = lp8758_buck_voltage_map,
252                 .type = REGULATOR_VOLTAGE,
253                 .owner = THIS_MODULE,
254                 .enable_reg = LP8758_REG_BUCK2_CTRL1,
255                 .enable_mask = LP8758_BUCK_EN_MASK,
256                 .vsel_reg = LP8758_REG_BUCK2_VOUT,
257                 .vsel_mask = LP8758_BUCK_VOUT_MASK,
258         }
259 };
261 static int lp8758_regulator_init(struct lp8758_chip *pchip)
263         int ret, icnt;
264         struct lp8758_platform_data *pdata = pchip->pdata;
265         struct regulator_config rconfig = { };
267         rconfig.regmap = pchip->regmap;
268         rconfig.dev = pchip->dev;
269         rconfig.driver_data = pchip;
271         for(icnt = 0; icnt < LP8758_BUCK_MAX; icnt++){
272                 rconfig.init_data = pdata->buck_data[icnt];
273                 rconfig.of_node = pchip->dev->of_node;
274                 pchip->rdev[icnt] =
275                     devm_regulator_register(pchip->dev,
276                                     &lp8758_regulators[icnt], &rconfig);
277                 if (IS_ERR(pchip->rdev[icnt])) {
278                         ret = PTR_ERR(pchip->rdev[icnt]);
279                         pchip->rdev[icnt] = NULL;
280                         dev_err(pchip->dev,
281                                                 "regulator init failed: buck %d\n",     icnt);
282                         return ret;
283                 }
284                 dev_info(pchip->dev, "lp8758 regulator %d\n is registered",icnt);
285         }
286         return 0;
289 static irqreturn_t lp8758_irq_handler(int irq, void *data)
291         int ret, icnt;
292         unsigned int int_top;
293         struct lp8758_chip *pchip = data;
295         ret = lp8758_read(pchip, LP8758_REG_INT_TOP, &int_top);
296         if(int_top & LP8758_OVERTEMP_MASK)
297                 for(icnt = LP8758_BUCK0; icnt < LP8758_BUCK_MAX; icnt++)
298                         regulator_notifier_call_chain(pchip->rdev[icnt],
299                                                                         REGULATOR_EVENT_OVER_TEMP, NULL);
301         lp8758_write(pchip, LP8758_REG_INT_BUCK_0_1, 0x77);
302         lp8758_write(pchip, LP8758_REG_INT_BUCK_2_3, 0x77);
303         lp8758_write(pchip, LP8758_REG_INT_TOP, 0x0f);
305         dev_info(pchip->dev, "lp8758 IRQ Handeled");
306         return IRQ_HANDLED;
309 static int lp8758_intr_config(struct lp8758_chip *pchip)
311         int ret, irq;
313         if (pchip->irq == 0) {
314                 dev_warn(pchip->dev, "not use interrupt : %s\n", __func__);
315                 return 0;
316         }
318         lp8758_write(pchip, LP8758_REG_INT_BUCK_0_1, 0x77);
319         lp8758_write(pchip, LP8758_REG_INT_BUCK_2_3, 0x77);
320         lp8758_write(pchip, LP8758_REG_INT_TOP, 0x0f);
322         gpio_request_one(pchip->irq, GPIOF_DIR_IN,"lp8758-irq");
323         irq = gpio_to_irq(pchip->irq);
324         if(irq < 0){
325                 dev_warn(pchip->dev, "irq can't be configurated\n");
326                 return -EINVAL;
327         }
329         ret = request_threaded_irq(irq, NULL, lp8758_irq_handler,
330                                    IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
331                                    "lp8758-irq", pchip);
332         dev_info(pchip->dev, "irq config is configured gpio %d irq %d\n",
333                                                         pchip->irq, irq);
335         return ret;
338 static struct of_regulator_match lp8758_matches[LP8758_BUCK_MAX] = {
339         { .name = "buck0", .driver_data = (void *)LP8758_BUCK0, },
340         { .name = "buck2", .driver_data = (void *)LP8758_BUCK2, },
341 };
343 static int lp8758_parse_dt(struct i2c_client *client,
344                                                                 struct lp8758_chip *pchip)
346         struct device_node *node = client->dev.of_node;
347         int count, icnt;
349         pchip->pdata = devm_kzalloc(&client->dev,
350                      sizeof(struct lp8758_platform_data), GFP_KERNEL);
351         if(pchip->pdata == NULL){
352                 dev_err(&client->dev, "lp8758 -- platform data is null\n");
353                 return -ENOMEM;
354         }
356         count = of_regulator_match(&client->dev, node,
357                                                                 lp8758_matches, LP8758_BUCK_MAX);
358         if (count <= 0)
359                 dev_err(&client->dev, "lp8758 --ERR - of regulator match\n");
361         for(icnt = 0; icnt < LP8758_BUCK_MAX; icnt++){
362                 pchip->pdata->buck_data[icnt] = lp8758_matches[icnt].init_data;
363         }
365         pchip->irq = of_get_named_gpio(node,"irq-gpio", 0);
366         
367         return 0;
370 static const struct regmap_config lp8758_regmap = {
371         .reg_bits = 8,
372         .val_bits = 8,
373         .max_register = LP8758_REG_MAX,
374 };
376 static const struct of_device_id of_lp8758_bl_match[] = {
377         { .compatible = "ti,lp8758", },
378         {},
379 };
381 static int lp8758_probe(struct i2c_client *client,
382                         const struct i2c_device_id *id)
384         struct lp8758_chip *pchip;
385         int ret = 0;
387         dev_info(&client->dev, "lp8758 module probe\n");
388         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
389                 dev_err(&client->dev, "i2c functionality check fail.\n");
390                 return -EOPNOTSUPP;
391         }
393         pchip = devm_kzalloc(&client->dev,
394                              sizeof(struct lp8758_chip), GFP_KERNEL);
395         if (!pchip)
396                 return -ENOMEM;
398         pchip->regmap = devm_regmap_init_i2c(client, &lp8758_regmap);
399         if (IS_ERR(pchip->regmap)) {
400                 ret = PTR_ERR(pchip->regmap);
401                 dev_err(&client->dev, "fail : allocate i2c register map\n");
402                 return ret;
403         }
405         ret = lp8758_parse_dt(client, pchip);
406         if(ret < 0)
407                 return ret;
409         pchip->dev = &client->dev;
410         i2c_set_clientdata(client, pchip);
412         ret = lp8758_regulator_init(pchip);
413         if (ret < 0) {
414                 dev_err(&client->dev, "fail to initialize regulators\n");
415                 return ret;
416         }
418         ret = lp8758_intr_config(pchip);
419         if (ret < 0) {
420                 dev_err(&client->dev, "fail to irq config\n");
421                 return ret;
422         }
424         dev_info(&client->dev, "lp8758 probe done\n");
425         return 0;
428 static const struct i2c_device_id lp8758_id[] = {
429         {LP8758_NAME, 0},
430         {}
431 };
433 MODULE_DEVICE_TABLE(i2c, lp8758_id);
434 static struct i2c_driver lp8758_i2c_driver = {
435         .driver = {
436                 .name = LP8758_NAME,
437                 .owner   = THIS_MODULE,
438                 .of_match_table = of_match_ptr(of_lp8758_bl_match),
439         },
440         .probe = lp8758_probe,
441         .id_table = lp8758_id,
442 };
444 module_i2c_driver(lp8758_i2c_driver);
446 MODULE_DESCRIPTION("Texas Instruments lp8758 driver");
447 MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>");
448 MODULE_AUTHOR("Ldd Mlp <ldd-mlp@list.ti.com>");
449 MODULE_LICENSE("GPL v2");