Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
55f4fa4e RJ |
2 | /* |
3 | * max1586.c -- Voltage and current regulation for the Maxim 1586 | |
4 | * | |
5 | * Copyright (C) 2008 Robert Jarzmik | |
55f4fa4e RJ |
6 | */ |
7 | #include <linux/module.h> | |
8 | #include <linux/err.h> | |
9 | #include <linux/i2c.h> | |
10 | #include <linux/platform_device.h> | |
11 | #include <linux/regulator/driver.h> | |
5a0e3ad6 | 12 | #include <linux/slab.h> |
55f4fa4e | 13 | #include <linux/regulator/max1586.h> |
4e005179 RJ |
14 | #include <linux/of_device.h> |
15 | #include <linux/regulator/of_regulator.h> | |
55f4fa4e RJ |
16 | |
17 | #define MAX1586_V3_MAX_VSEL 31 | |
18 | #define MAX1586_V6_MAX_VSEL 3 | |
19 | ||
20 | #define MAX1586_V3_MIN_UV 700000 | |
21 | #define MAX1586_V3_MAX_UV 1475000 | |
55f4fa4e RJ |
22 | |
23 | #define MAX1586_V6_MIN_UV 0 | |
24 | #define MAX1586_V6_MAX_UV 3000000 | |
25 | ||
26 | #define I2C_V3_SELECT (0 << 5) | |
27 | #define I2C_V6_SELECT (1 << 5) | |
28 | ||
b110a8fb PZ |
29 | struct max1586_data { |
30 | struct i2c_client *client; | |
31 | ||
32 | /* min/max V3 voltage */ | |
c8f1e502 PZ |
33 | unsigned int min_uV; |
34 | unsigned int max_uV; | |
b110a8fb | 35 | |
4efd9dfe AL |
36 | unsigned int v3_curr_sel; |
37 | unsigned int v6_curr_sel; | |
b110a8fb PZ |
38 | }; |
39 | ||
96d25221 AL |
40 | /* |
41 | * V6 voltage | |
42 | * On I2C bus, sending a "x" byte to the max1586 means : | |
43 | * set V6 to either 0V, 1.8V, 2.5V, 3V depending on (x & 0x3) | |
44 | * As regulator framework doesn't accept voltages to be 0V, we use 1uV. | |
45 | */ | |
d67c42cc | 46 | static const unsigned int v6_voltages_uv[] = { 1, 1800000, 2500000, 3000000 }; |
96d25221 | 47 | |
55f4fa4e RJ |
48 | /* |
49 | * V3 voltage | |
50 | * On I2C bus, sending a "x" byte to the max1586 means : | |
51 | * set V3 to 0.700V + (x & 0x1f) * 0.025V | |
b110a8fb PZ |
52 | * This voltage can be increased by external resistors |
53 | * R24 and R25=100kOhm as described in the data sheet. | |
54 | * The gain is approximately: 1 + R24/R25 + R24/185.5kOhm | |
55f4fa4e | 55 | */ |
4efd9dfe AL |
56 | static int max1586_v3_get_voltage_sel(struct regulator_dev *rdev) |
57 | { | |
58 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); | |
59 | ||
60 | return max1586->v3_curr_sel; | |
61 | } | |
62 | ||
9b558950 AL |
63 | static int max1586_v3_set_voltage_sel(struct regulator_dev *rdev, |
64 | unsigned selector) | |
55f4fa4e | 65 | { |
b110a8fb PZ |
66 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); |
67 | struct i2c_client *client = max1586->client; | |
4efd9dfe | 68 | int ret; |
55f4fa4e RJ |
69 | u8 v3_prog; |
70 | ||
55f4fa4e | 71 | dev_dbg(&client->dev, "changing voltage v3 to %dmv\n", |
9b558950 | 72 | regulator_list_voltage_linear(rdev, selector) / 1000); |
55f4fa4e | 73 | |
9b558950 | 74 | v3_prog = I2C_V3_SELECT | (u8) selector; |
4efd9dfe AL |
75 | ret = i2c_smbus_write_byte(client, v3_prog); |
76 | if (ret) | |
77 | return ret; | |
78 | ||
79 | max1586->v3_curr_sel = selector; | |
80 | ||
81 | return 0; | |
82 | } | |
83 | ||
84 | static int max1586_v6_get_voltage_sel(struct regulator_dev *rdev) | |
85 | { | |
86 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); | |
87 | ||
88 | return max1586->v6_curr_sel; | |
55f4fa4e RJ |
89 | } |
90 | ||
0d032731 AL |
91 | static int max1586_v6_set_voltage_sel(struct regulator_dev *rdev, |
92 | unsigned int selector) | |
55f4fa4e | 93 | { |
4efd9dfe AL |
94 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); |
95 | struct i2c_client *client = max1586->client; | |
55f4fa4e | 96 | u8 v6_prog; |
4efd9dfe | 97 | int ret; |
55f4fa4e | 98 | |
55f4fa4e | 99 | dev_dbg(&client->dev, "changing voltage v6 to %dmv\n", |
0d032731 | 100 | rdev->desc->volt_table[selector] / 1000); |
55f4fa4e | 101 | |
0d032731 | 102 | v6_prog = I2C_V6_SELECT | (u8) selector; |
4efd9dfe AL |
103 | ret = i2c_smbus_write_byte(client, v6_prog); |
104 | if (ret) | |
105 | return ret; | |
106 | ||
107 | max1586->v6_curr_sel = selector; | |
108 | ||
109 | return 0; | |
55f4fa4e RJ |
110 | } |
111 | ||
55f4fa4e RJ |
112 | /* |
113 | * The Maxim 1586 controls V3 and V6 voltages, but offers no way of reading back | |
114 | * the set up value. | |
115 | */ | |
0f6ce809 | 116 | static const struct regulator_ops max1586_v3_ops = { |
4efd9dfe | 117 | .get_voltage_sel = max1586_v3_get_voltage_sel, |
9b558950 | 118 | .set_voltage_sel = max1586_v3_set_voltage_sel, |
93f5de5c | 119 | .list_voltage = regulator_list_voltage_linear, |
9b558950 | 120 | .map_voltage = regulator_map_voltage_linear, |
55f4fa4e RJ |
121 | }; |
122 | ||
0f6ce809 | 123 | static const struct regulator_ops max1586_v6_ops = { |
4efd9dfe | 124 | .get_voltage_sel = max1586_v6_get_voltage_sel, |
0d032731 | 125 | .set_voltage_sel = max1586_v6_set_voltage_sel, |
96d25221 | 126 | .list_voltage = regulator_list_voltage_table, |
55f4fa4e RJ |
127 | }; |
128 | ||
93f5de5c | 129 | static struct regulator_desc max1586_reg[] = { |
55f4fa4e RJ |
130 | { |
131 | .name = "Output_V3", | |
132 | .id = MAX1586_V3, | |
133 | .ops = &max1586_v3_ops, | |
134 | .type = REGULATOR_VOLTAGE, | |
135 | .n_voltages = MAX1586_V3_MAX_VSEL + 1, | |
136 | .owner = THIS_MODULE, | |
137 | }, | |
138 | { | |
139 | .name = "Output_V6", | |
140 | .id = MAX1586_V6, | |
141 | .ops = &max1586_v6_ops, | |
142 | .type = REGULATOR_VOLTAGE, | |
143 | .n_voltages = MAX1586_V6_MAX_VSEL + 1, | |
96d25221 | 144 | .volt_table = v6_voltages_uv, |
55f4fa4e RJ |
145 | .owner = THIS_MODULE, |
146 | }, | |
147 | }; | |
148 | ||
5ccedf03 | 149 | static int of_get_max1586_platform_data(struct device *dev, |
4e005179 RJ |
150 | struct max1586_platform_data *pdata) |
151 | { | |
152 | struct max1586_subdev_data *sub; | |
d83aef13 | 153 | struct of_regulator_match rmatch[ARRAY_SIZE(max1586_reg)] = { }; |
4e005179 RJ |
154 | struct device_node *np = dev->of_node; |
155 | int i, matched; | |
156 | ||
157 | if (of_property_read_u32(np, "v3-gain", | |
158 | &pdata->v3_gain) < 0) { | |
7799167b | 159 | dev_err(dev, "%pOF has no 'v3-gain' property\n", np); |
4e005179 RJ |
160 | return -EINVAL; |
161 | } | |
162 | ||
163 | np = of_get_child_by_name(np, "regulators"); | |
164 | if (!np) { | |
165 | dev_err(dev, "missing 'regulators' subnode in DT\n"); | |
166 | return -EINVAL; | |
167 | } | |
168 | ||
169 | for (i = 0; i < ARRAY_SIZE(rmatch); i++) | |
170 | rmatch[i].name = max1586_reg[i].name; | |
171 | ||
172 | matched = of_regulator_match(dev, np, rmatch, ARRAY_SIZE(rmatch)); | |
173 | of_node_put(np); | |
174 | /* | |
175 | * If matched is 0, ie. neither Output_V3 nor Output_V6 have been found, | |
176 | * return 0, which signals the normal situation where no subregulator is | |
177 | * available. This is normal because the max1586 doesn't provide any | |
178 | * readback support, so the subregulators can't report any status | |
179 | * anyway. If matched < 0, return the error. | |
180 | */ | |
181 | if (matched <= 0) | |
182 | return matched; | |
183 | ||
a86854d0 KC |
184 | pdata->subdevs = devm_kcalloc(dev, |
185 | matched, | |
186 | sizeof(struct max1586_subdev_data), | |
187 | GFP_KERNEL); | |
4e005179 RJ |
188 | if (!pdata->subdevs) |
189 | return -ENOMEM; | |
190 | ||
191 | pdata->num_subdevs = matched; | |
192 | sub = pdata->subdevs; | |
193 | ||
194 | for (i = 0; i < matched; i++) { | |
195 | sub->id = i; | |
196 | sub->name = rmatch[i].of_node->name; | |
197 | sub->platform_data = rmatch[i].init_data; | |
198 | sub++; | |
199 | } | |
200 | ||
201 | return 0; | |
202 | } | |
203 | ||
44bc5d16 | 204 | static const struct of_device_id __maybe_unused max1586_of_match[] = { |
4e005179 RJ |
205 | { .compatible = "maxim,max1586", }, |
206 | {}, | |
207 | }; | |
208 | MODULE_DEVICE_TABLE(of, max1586_of_match); | |
209 | ||
3d54f7ba | 210 | static int max1586_pmic_probe(struct i2c_client *client) |
55f4fa4e | 211 | { |
4e005179 | 212 | struct max1586_platform_data *pdata, pdata_of; |
c172708d | 213 | struct regulator_config config = { }; |
b110a8fb | 214 | struct max1586_data *max1586; |
4e005179 RJ |
215 | int i, id, ret; |
216 | const struct of_device_id *match; | |
217 | ||
218 | pdata = dev_get_platdata(&client->dev); | |
219 | if (client->dev.of_node && !pdata) { | |
220 | match = of_match_device(of_match_ptr(max1586_of_match), | |
221 | &client->dev); | |
222 | if (!match) { | |
223 | dev_err(&client->dev, "Error: No device match found\n"); | |
224 | return -ENODEV; | |
225 | } | |
226 | ret = of_get_max1586_platform_data(&client->dev, &pdata_of); | |
227 | if (ret < 0) | |
228 | return ret; | |
229 | pdata = &pdata_of; | |
230 | } | |
b110a8fb | 231 | |
2d45e78a | 232 | max1586 = devm_kzalloc(&client->dev, sizeof(struct max1586_data), |
b110a8fb PZ |
233 | GFP_KERNEL); |
234 | if (!max1586) | |
b7bd05b8 | 235 | return -ENOMEM; |
55f4fa4e | 236 | |
b110a8fb | 237 | max1586->client = client; |
55f4fa4e | 238 | |
b7bd05b8 AL |
239 | if (!pdata->v3_gain) |
240 | return -EINVAL; | |
241 | ||
c8f1e502 PZ |
242 | max1586->min_uV = MAX1586_V3_MIN_UV / 1000 * pdata->v3_gain / 1000; |
243 | max1586->max_uV = MAX1586_V3_MAX_UV / 1000 * pdata->v3_gain / 1000; | |
b110a8fb | 244 | |
4efd9dfe AL |
245 | /* Set curr_sel to default voltage on power-up */ |
246 | max1586->v3_curr_sel = 24; /* 1.3V */ | |
247 | max1586->v6_curr_sel = 0; | |
248 | ||
55f4fa4e | 249 | for (i = 0; i < pdata->num_subdevs && i <= MAX1586_V6; i++) { |
aaa46b4b KK |
250 | struct regulator_dev *rdev; |
251 | ||
55f4fa4e RJ |
252 | id = pdata->subdevs[i].id; |
253 | if (!pdata->subdevs[i].platform_data) | |
254 | continue; | |
255 | if (id < MAX1586_V3 || id > MAX1586_V6) { | |
256 | dev_err(&client->dev, "invalid regulator id %d\n", id); | |
249cc1f2 | 257 | return -EINVAL; |
55f4fa4e | 258 | } |
c172708d | 259 | |
93f5de5c AL |
260 | if (id == MAX1586_V3) { |
261 | max1586_reg[id].min_uV = max1586->min_uV; | |
262 | max1586_reg[id].uV_step = | |
263 | (max1586->max_uV - max1586->min_uV) / | |
264 | MAX1586_V3_MAX_VSEL; | |
265 | } | |
266 | ||
c172708d MB |
267 | config.dev = &client->dev; |
268 | config.init_data = pdata->subdevs[i].platform_data; | |
269 | config.driver_data = max1586; | |
270 | ||
aaa46b4b | 271 | rdev = devm_regulator_register(&client->dev, |
249cc1f2 | 272 | &max1586_reg[id], &config); |
aaa46b4b | 273 | if (IS_ERR(rdev)) { |
55f4fa4e RJ |
274 | dev_err(&client->dev, "failed to register %s\n", |
275 | max1586_reg[id].name); | |
aaa46b4b | 276 | return PTR_ERR(rdev); |
55f4fa4e RJ |
277 | } |
278 | } | |
279 | ||
7c4c25e4 | 280 | i2c_set_clientdata(client, max1586); |
55f4fa4e RJ |
281 | dev_info(&client->dev, "Maxim 1586 regulator driver loaded\n"); |
282 | return 0; | |
55f4fa4e RJ |
283 | } |
284 | ||
285 | static const struct i2c_device_id max1586_id[] = { | |
286 | { "max1586", 0 }, | |
287 | { } | |
288 | }; | |
289 | MODULE_DEVICE_TABLE(i2c, max1586_id); | |
290 | ||
291 | static struct i2c_driver max1586_pmic_driver = { | |
964e1865 | 292 | .probe = max1586_pmic_probe, |
55f4fa4e RJ |
293 | .driver = { |
294 | .name = "max1586", | |
259b93b2 | 295 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
4e005179 | 296 | .of_match_table = of_match_ptr(max1586_of_match), |
55f4fa4e RJ |
297 | }, |
298 | .id_table = max1586_id, | |
299 | }; | |
300 | ||
301 | static int __init max1586_pmic_init(void) | |
302 | { | |
303 | return i2c_add_driver(&max1586_pmic_driver); | |
304 | } | |
305 | subsys_initcall(max1586_pmic_init); | |
306 | ||
307 | static void __exit max1586_pmic_exit(void) | |
308 | { | |
309 | i2c_del_driver(&max1586_pmic_driver); | |
310 | } | |
311 | module_exit(max1586_pmic_exit); | |
312 | ||
313 | /* Module information */ | |
314 | MODULE_DESCRIPTION("MAXIM 1586 voltage regulator driver"); | |
315 | MODULE_AUTHOR("Robert Jarzmik"); | |
316 | MODULE_LICENSE("GPL"); |