regulator: max77812: add max77812 regulator driver
[linux-4.4.git] / drivers / regulator / max77812-regulator.c
1 /*
2  * MAXIM max77812 Regulator driver
3  *
4  * Copyright (C) 2017 NVIDIA CORPORATION. All rights reserved.
5  *
6  * Author: Venkat Reddy Talla <vreddytalla@nvidia.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of the
11  * License, or (at your option) any later version.
12  *
13  * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
14  * whether express or implied; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  */
18
19 #include <linux/err.h>
20 #include <linux/i2c.h>
21 #include <linux/module.h>
22 #include <linux/of.h>
23 #include <linux/platform_device.h>
24 #include <linux/regmap.h>
25 #include <linux/regulator/driver.h>
26 #include <linux/regulator/machine.h>
27
28 #define max77812_rails(_name)   "max77812-"#_name
29
30 #define MAX77812_REG_RSET               0x00
31 #define MAX77812_REG_INT_SRC            0x01
32 #define MAX77812_REG_INT_SRC_M          0x02
33 #define MAX77812_REG_TOPSYS_INT         0x03
34 #define MAX77812_REG_TOPSYS_INT_M       0x04
35 #define MAX77812_REG_TOPSYS_STAT        0x05
36 #define MAX77812_REG_EN_CTRL            0x06
37 #define MAX77812_REG_STUP_DLY1          0x07
38 #define MAX77812_REG_STUP_DLY2          0x08
39 #define MAX77812_REG_STUP_DLY3          0x09
40 #define MAX77812_REG_SHDN_DLY1          0x0A
41 #define MAX77812_REG_SHDN_DLY2          0x0B
42 #define MAX77812_REG_SHDN_DLY3          0x0C
43 #define MAX77812_REG_SHDN_DLY4          0x0D
44 #define MAX77812_REG_WDTRSTB_DEB        0x0E
45 #define MAX77812_REG_GPI_FUNC           0x0F
46 #define MAX77812_REG_GPI_DEB1           0x10
47 #define MAX77812_REG_GPI_DEB2           0x11
48 #define MAX77812_REG_GPI_PD_CTRL        0x12
49 #define MAX77812_REG_PROT_CFG           0x13
50 #define MAX77812_REG_I2C_CFG            0x15
51 #define MAX77812_REG_BUCK_INT           0x20
52 #define MAX77812_REG_BUCK_INT_M         0x21
53 #define MAX77812_REG_BUCK_STAT          0x22
54 #define MAX77812_REG_M1_VOUT            0x23
55 #define MAX77812_REG_M2_VOUT            0x24
56 #define MAX77812_REG_M3_VOUT            0x25
57 #define MAX77812_REG_M4_VOUT            0x26
58 #define MAX77812_REG_M1_VOUT_D          0x27
59 #define MAX77812_REG_M2_VOUT_D          0x28
60 #define MAX77812_REG_M3_VOUT_D          0x29
61 #define MAX77812_REG_M4_VOUT_D          0x2A
62 #define MAX77812_REG_M1_VOUT_S          0x2B
63 #define MAX77812_REG_M2_VOUT_S          0x2C
64 #define MAX77812_REG_M3_VOUT_S          0x2D
65 #define MAX77812_REG_M4_VOUT_S          0x2E
66 #define MAX77812_REG_M1_CGF             0x2F
67 #define MAX77812_REG_M2_CGF             0x30
68 #define MAX77812_REG_M3_CGF             0x31
69 #define MAX77812_REG_M4_CGF             0x32
70 #define MAX77812_REG_GLB_CFG1           0x33
71 #define MAX77812_REG_GLB_CFG2           0x34
72 #define MAX77812_REG_MAX                0x35
73
74 #define MAX77812_REG_EN_CTRL_MASK(n)            BIT(n)
75 #define MAX77812_START_SLEW_RATE_MASK           0x07
76 #define MAX77812_SHDN_SLEW_RATE_MASK            0x70
77 #define MAX77812_RAMPDOWN_SLEW_RATE_MASK        0x07
78 #define MAX77812_RAMPUP_SLEW_RATE_MASK          0x70
79
80 #define MAX77812_VOUT_MASK              0xFF
81 #define MAX77812_VOUT_N_VOLTAGE         0xFF
82 #define MAX77812_VOUT_VMIN              250000
83 #define MAX77812_VOUT_VMAX              1525000
84 #define MAX77812_VOUT_STEP              5000
85
86 #define MAX77812_REGULATOR_ID_M1        0
87 #define MAX77812_REGULATOR_ID_M2        1
88 #define MAX77812_REGULATOR_ID_M3        2
89 #define MAX77812_REGULATOR_ID_M4        3
90 #define MAX77812_MAX_REGULATORS         4
91
92 static unsigned int slew_rate_table[] = {
93         1250, 2500, 5000, 10000, 20000, 40000, 60000,
94 };
95
96 struct max77812_reg_pdata {
97         struct regulator_init_data *ridata;
98 };
99
100 struct max77812_regulator {
101         struct device *dev;
102         struct regmap *rmap;
103         struct regulator_desc *rdesc[MAX77812_MAX_REGULATORS];
104         struct max77812_reg_pdata reg_pdata[MAX77812_MAX_REGULATORS];
105         struct regulator_dev *rdev[MAX77812_MAX_REGULATORS];
106         u32 ramp_up_slew_rate;
107         u32 ramp_down_slew_rate;
108         u32 shutdown_slew_rate;
109         u32 softstart_slew_rate;
110 };
111
112 static int max77812_regulator_enable(struct regulator_dev *rdev)
113 {
114         struct max77812_regulator *max77812 = rdev_get_drvdata(rdev);
115         int ret;
116
117         ret = regmap_update_bits(max77812->rmap, rdev->desc->enable_reg,
118                         rdev->desc->enable_mask,
119                         rdev->desc->enable_mask);
120         if (ret < 0) {
121                 dev_err(max77812->dev, "Regulator enable failed: %d\n", ret);
122                 return ret;
123         }
124
125         return ret;
126 }
127
128 static int max77812_regulator_disable(struct regulator_dev *rdev)
129 {
130         struct max77812_regulator *max77812 = rdev_get_drvdata(rdev);
131         int ret;
132
133         ret = regmap_update_bits(max77812->rmap, rdev->desc->enable_reg,
134                                 rdev->desc->enable_mask, 0);
135         if (ret < 0) {
136                 dev_err(max77812->dev, "Regulator disable failed: %d\n", ret);
137                 return ret;
138         }
139
140         return ret;
141 }
142
143 static u8 max77802_slew_rate_to_reg(const unsigned int sr_limits[],
144                         u8 cnt, unsigned int slew_rate)
145 {
146         int i;
147
148         for (i = 0; i < cnt; i++) {
149                 if (slew_rate <= sr_limits[i])
150                         return i;
151         }
152
153         return cnt - 1;
154 }
155
156 static int max77812_reg_init(struct max77812_regulator *max77812)
157 {
158         u8 slew_rate = 0;
159         u8 rampdelay = 0;
160         u8 mask = 0;
161         int ret;
162
163         if (max77812->softstart_slew_rate) {
164                 slew_rate = max77802_slew_rate_to_reg(slew_rate_table,
165                                 ARRAY_SIZE(slew_rate_table),
166                                 max77812->softstart_slew_rate);
167                 mask = MAX77812_START_SLEW_RATE_MASK;
168         }
169
170         if (max77812->shutdown_slew_rate) {
171                 rampdelay = max77802_slew_rate_to_reg(slew_rate_table,
172                                 ARRAY_SIZE(slew_rate_table),
173                                 max77812->shutdown_slew_rate);
174                 slew_rate |= rampdelay;
175                 mask |= MAX77812_SHDN_SLEW_RATE_MASK;
176         }
177
178         if (slew_rate && mask) {
179                 ret = regmap_update_bits(max77812->rmap,
180                                         MAX77812_REG_GLB_CFG1,
181                                         mask, slew_rate);
182                 if (ret < 0) {
183                         dev_err(max77812->dev, "slew rate cfg1 update failed %d\n",
184                                                 ret);
185                         return ret;
186                 }
187         }
188
189         slew_rate = 0;
190         mask = 0;
191
192         if (max77812->ramp_up_slew_rate) {
193                 slew_rate = max77802_slew_rate_to_reg(slew_rate_table,
194                                 ARRAY_SIZE(slew_rate_table),
195                                 max77812->ramp_up_slew_rate);
196                 mask = MAX77812_RAMPUP_SLEW_RATE_MASK;
197         }
198
199         if (max77812->ramp_down_slew_rate) {
200                 rampdelay = max77802_slew_rate_to_reg(slew_rate_table,
201                                 ARRAY_SIZE(slew_rate_table),
202                                 max77812->ramp_down_slew_rate);
203                 slew_rate |= rampdelay;
204                 mask |= MAX77812_RAMPDOWN_SLEW_RATE_MASK;
205         }
206
207         if (slew_rate && mask) {
208                 ret = regmap_update_bits(max77812->rmap,
209                                         MAX77812_REG_GLB_CFG2,
210                                         mask, slew_rate);
211                 if (ret < 0) {
212                         dev_err(max77812->dev, "slew rate cfg2 update failed %d\n",
213                                                 ret);
214                         return ret;
215                 }
216         }
217
218         return 0;
219 }
220
221 static struct regulator_ops max77812_regulator_ops = {
222         .enable = max77812_regulator_enable,
223         .disable = max77812_regulator_disable,
224         .list_voltage = regulator_list_voltage_linear,
225         .map_voltage = regulator_map_voltage_linear,
226         .get_voltage_sel = regulator_get_voltage_sel_regmap,
227         .set_voltage_sel = regulator_set_voltage_sel_regmap,
228 };
229
230 #define MAX77812_REGULATOR_DESC(_id, _name, _en_bit)            \
231         [MAX77812_REGULATOR_ID_##_id] = {               \
232                 .name = max77812_rails(_name),          \
233                 .of_match = of_match_ptr(#_name),               \
234                 .regulators_node = of_match_ptr("regulators"),  \
235                 .supply_name = "vin",                   \
236                 .id = MAX77812_REGULATOR_ID_##_id,      \
237                 .ops = &max77812_regulator_ops,         \
238                 .n_voltages = MAX77812_VOUT_N_VOLTAGE,  \
239                 .min_uV = MAX77812_VOUT_VMIN,           \
240                 .uV_step = MAX77812_VOUT_STEP,          \
241                 .enable_time = 500,                     \
242                 .vsel_mask = MAX77812_VOUT_MASK,        \
243                 .vsel_reg = MAX77812_REG_##_id##_VOUT,  \
244                 .enable_reg     = MAX77812_REG_EN_CTRL,         \
245                 .enable_mask = BIT(_en_bit),                    \
246                 .type = REGULATOR_VOLTAGE,              \
247                 .owner = THIS_MODULE,                   \
248         }
249
250 static struct regulator_desc max77812_regs_desc[MAX77812_MAX_REGULATORS] = {
251         MAX77812_REGULATOR_DESC(M1, m1vout, 0),
252         MAX77812_REGULATOR_DESC(M2, m2vout, 2),
253         MAX77812_REGULATOR_DESC(M3, m3vout, 4),
254         MAX77812_REGULATOR_DESC(M4, m4vout, 6),
255 };
256
257 static int max77812_reg_parse_dt(struct device *dev,
258                 struct max77812_regulator *max77812_regs)
259 {
260         struct device_node *np = dev->of_node;
261         u32 pval;
262         int ret;
263
264         ret = of_property_read_u32(np, "maxim,ramp-up-slew-rate", &pval);
265         if (!ret)
266                 max77812_regs->ramp_up_slew_rate = pval;
267
268         ret = of_property_read_u32(np, "maxim,ramp-down-slew-rate", &pval);
269         if (!ret)
270                 max77812_regs->ramp_down_slew_rate = pval;
271
272         ret = of_property_read_u32(np, "maxim,shutdown-slew-rate", &pval);
273         if (!ret)
274                 max77812_regs->shutdown_slew_rate = pval;
275
276         ret = of_property_read_u32(np, "maxim,soft-start-slew-rate", &pval);
277         if (!ret)
278                 max77812_regs->softstart_slew_rate = pval;
279
280         return 0;
281 }
282
283 static const struct regmap_config max77812_regmap_config = {
284         .reg_bits               = 8,
285         .val_bits               = 8,
286         .max_register   = MAX77812_REG_MAX - 1,
287         .cache_type             = REGCACHE_NONE,
288 };
289
290 static int max77812_probe(struct i2c_client *client,
291                         const struct i2c_device_id *client_id)
292 {
293         struct device *dev = &client->dev;
294         struct max77812_reg_pdata *rpdata;
295         struct regulator_config config = { };
296         struct regulator_desc *rdesc;
297         struct max77812_regulator *max77812;
298         int id;
299         int ret;
300
301         max77812 = devm_kzalloc(dev, sizeof(*max77812), GFP_KERNEL);
302         if (!max77812)
303                 return -ENOMEM;
304
305         ret = max77812_reg_parse_dt(dev, max77812);
306         if (ret < 0) {
307                 dev_err(dev, "Reading data from DT failed: %d\n", ret);
308                 return ret;
309         }
310
311         max77812->rmap = devm_regmap_init_i2c(client, &max77812_regmap_config);
312         if (IS_ERR(max77812->rmap)) {
313                 ret = PTR_ERR(max77812->rmap);
314                 dev_err(dev, "regmap init failed: %d\n", ret);
315                 return ret;
316         }
317
318         i2c_set_clientdata(client, max77812);
319         max77812->dev = dev;
320
321         ret = max77812_reg_init(max77812);
322         if (ret < 0) {
323                 dev_err(dev, "max77812 Init failed: %d\n", ret);
324                 return ret;
325         }
326
327         for (id = 0; id < MAX77812_MAX_REGULATORS; ++id) {
328                 rdesc = &max77812_regs_desc[id];
329                 max77812->rdesc[id] = rdesc;
330                 rpdata = &max77812->reg_pdata[id];
331
332                 config.regmap = max77812->rmap;
333                 config.dev = dev;
334                 config.init_data = rpdata->ridata;
335                 config.driver_data = max77812;
336
337                 max77812->rdev[id] = devm_regulator_register(dev,
338                                         rdesc, &config);
339                 if (IS_ERR(max77812->rdev[id])) {
340                         ret = PTR_ERR(max77812->rdev[id]);
341                         dev_err(dev, "regulator %s register failed: %d\n",
342                                                 rdesc->name, ret);
343                         return ret;
344                 }
345         }
346
347         return 0;
348 }
349
350 static const struct of_device_id max77812_of_match[] = {
351         { .compatible = "maxim,max77812-regulator", },
352         {},
353 };
354 MODULE_DEVICE_TABLE(of, max77812_of_match);
355
356 static const struct i2c_device_id max77812_id[] = {
357         {.name = "max77812",},
358         {},
359 };
360
361 static struct i2c_driver max77812_i2c_driver = {
362         .driver = {
363                 .name = "max77812",
364                 .owner = THIS_MODULE,
365                 .of_match_table = max77812_of_match,
366         },
367         .probe = max77812_probe,
368         .id_table = max77812_id,
369 };
370 module_i2c_driver(max77812_i2c_driver);
371
372 MODULE_AUTHOR("Venkat Reddy Talla <vreddytalla@nvidia.com>");
373 MODULE_LICENSE("GPL v2");
374 MODULE_DESCRIPTION("max77812 regulator driver");