1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * max1586.c -- Voltage and current regulation for the Maxim 1586 |
4 | * |
5 | * Copyright (C) 2008 Robert Jarzmik |
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> |
12 | #include <linux/slab.h> |
13 | #include <linux/regulator/max1586.h> |
14 | #include <linux/of.h> |
15 | #include <linux/regulator/of_regulator.h> |
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 |
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 | |
29 | struct max1586_data { |
30 | struct i2c_client *client; |
31 | |
32 | /* min/max V3 voltage */ |
33 | unsigned int min_uV; |
34 | unsigned int max_uV; |
35 | |
36 | unsigned int v3_curr_sel; |
37 | unsigned int v6_curr_sel; |
38 | }; |
39 | |
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 | */ |
46 | static const unsigned int v6_voltages_uv[] = { 1, 1800000, 2500000, 3000000 }; |
47 | |
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 |
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 |
55 | */ |
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 | |
63 | static int max1586_v3_set_voltage_sel(struct regulator_dev *rdev, |
64 | unsigned selector) |
65 | { |
66 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); |
67 | struct i2c_client *client = max1586->client; |
68 | int ret; |
69 | u8 v3_prog; |
70 | |
71 | dev_dbg(&client->dev, "changing voltage v3 to %dmv\n" , |
72 | regulator_list_voltage_linear(rdev, selector) / 1000); |
73 | |
74 | v3_prog = I2C_V3_SELECT | (u8) selector; |
75 | ret = i2c_smbus_write_byte(client, value: 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; |
89 | } |
90 | |
91 | static int max1586_v6_set_voltage_sel(struct regulator_dev *rdev, |
92 | unsigned int selector) |
93 | { |
94 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); |
95 | struct i2c_client *client = max1586->client; |
96 | u8 v6_prog; |
97 | int ret; |
98 | |
99 | dev_dbg(&client->dev, "changing voltage v6 to %dmv\n" , |
100 | rdev->desc->volt_table[selector] / 1000); |
101 | |
102 | v6_prog = I2C_V6_SELECT | (u8) selector; |
103 | ret = i2c_smbus_write_byte(client, value: v6_prog); |
104 | if (ret) |
105 | return ret; |
106 | |
107 | max1586->v6_curr_sel = selector; |
108 | |
109 | return 0; |
110 | } |
111 | |
112 | /* |
113 | * The Maxim 1586 controls V3 and V6 voltages, but offers no way of reading back |
114 | * the set up value. |
115 | */ |
116 | static const struct regulator_ops max1586_v3_ops = { |
117 | .get_voltage_sel = max1586_v3_get_voltage_sel, |
118 | .set_voltage_sel = max1586_v3_set_voltage_sel, |
119 | .list_voltage = regulator_list_voltage_linear, |
120 | .map_voltage = regulator_map_voltage_linear, |
121 | }; |
122 | |
123 | static const struct regulator_ops max1586_v6_ops = { |
124 | .get_voltage_sel = max1586_v6_get_voltage_sel, |
125 | .set_voltage_sel = max1586_v6_set_voltage_sel, |
126 | .list_voltage = regulator_list_voltage_table, |
127 | }; |
128 | |
129 | static struct regulator_desc max1586_reg[] = { |
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, |
144 | .volt_table = v6_voltages_uv, |
145 | .owner = THIS_MODULE, |
146 | }, |
147 | }; |
148 | |
149 | static int of_get_max1586_platform_data(struct device *dev, |
150 | struct max1586_platform_data *pdata) |
151 | { |
152 | struct max1586_subdev_data *sub; |
153 | struct of_regulator_match rmatch[ARRAY_SIZE(max1586_reg)] = { }; |
154 | struct device_node *np = dev->of_node; |
155 | int i, matched; |
156 | |
157 | if (of_property_read_u32(np, propname: "v3-gain" , |
158 | out_value: &pdata->v3_gain) < 0) { |
159 | dev_err(dev, "%pOF has no 'v3-gain' property\n" , np); |
160 | return -EINVAL; |
161 | } |
162 | |
163 | np = of_get_child_by_name(node: np, name: "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, node: np, matches: rmatch, ARRAY_SIZE(rmatch)); |
173 | of_node_put(node: 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 | |
184 | pdata->subdevs = devm_kcalloc(dev, |
185 | n: matched, |
186 | size: sizeof(struct max1586_subdev_data), |
187 | GFP_KERNEL); |
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 | |
204 | static const struct of_device_id __maybe_unused max1586_of_match[] = { |
205 | { .compatible = "maxim,max1586" , }, |
206 | {}, |
207 | }; |
208 | MODULE_DEVICE_TABLE(of, max1586_of_match); |
209 | |
210 | static int max1586_pmic_probe(struct i2c_client *client) |
211 | { |
212 | struct max1586_platform_data *pdata, pdata_of; |
213 | struct regulator_config config = { }; |
214 | struct max1586_data *max1586; |
215 | int i, id, ret; |
216 | |
217 | pdata = dev_get_platdata(dev: &client->dev); |
218 | if (client->dev.of_node && !pdata) { |
219 | ret = of_get_max1586_platform_data(dev: &client->dev, pdata: &pdata_of); |
220 | if (ret < 0) |
221 | return ret; |
222 | pdata = &pdata_of; |
223 | } |
224 | |
225 | max1586 = devm_kzalloc(dev: &client->dev, size: sizeof(struct max1586_data), |
226 | GFP_KERNEL); |
227 | if (!max1586) |
228 | return -ENOMEM; |
229 | |
230 | max1586->client = client; |
231 | |
232 | if (!pdata->v3_gain) |
233 | return -EINVAL; |
234 | |
235 | max1586->min_uV = MAX1586_V3_MIN_UV / 1000 * pdata->v3_gain / 1000; |
236 | max1586->max_uV = MAX1586_V3_MAX_UV / 1000 * pdata->v3_gain / 1000; |
237 | |
238 | /* Set curr_sel to default voltage on power-up */ |
239 | max1586->v3_curr_sel = 24; /* 1.3V */ |
240 | max1586->v6_curr_sel = 0; |
241 | |
242 | for (i = 0; i < pdata->num_subdevs && i <= MAX1586_V6; i++) { |
243 | struct regulator_dev *rdev; |
244 | |
245 | id = pdata->subdevs[i].id; |
246 | if (!pdata->subdevs[i].platform_data) |
247 | continue; |
248 | if (id < MAX1586_V3 || id > MAX1586_V6) { |
249 | dev_err(&client->dev, "invalid regulator id %d\n" , id); |
250 | return -EINVAL; |
251 | } |
252 | |
253 | if (id == MAX1586_V3) { |
254 | max1586_reg[id].min_uV = max1586->min_uV; |
255 | max1586_reg[id].uV_step = |
256 | (max1586->max_uV - max1586->min_uV) / |
257 | MAX1586_V3_MAX_VSEL; |
258 | } |
259 | |
260 | config.dev = &client->dev; |
261 | config.init_data = pdata->subdevs[i].platform_data; |
262 | config.driver_data = max1586; |
263 | |
264 | rdev = devm_regulator_register(dev: &client->dev, |
265 | regulator_desc: &max1586_reg[id], config: &config); |
266 | if (IS_ERR(ptr: rdev)) { |
267 | dev_err(&client->dev, "failed to register %s\n" , |
268 | max1586_reg[id].name); |
269 | return PTR_ERR(ptr: rdev); |
270 | } |
271 | } |
272 | |
273 | i2c_set_clientdata(client, data: max1586); |
274 | dev_info(&client->dev, "Maxim 1586 regulator driver loaded\n" ); |
275 | return 0; |
276 | } |
277 | |
278 | static const struct i2c_device_id max1586_id[] = { |
279 | { "max1586" , 0 }, |
280 | { } |
281 | }; |
282 | MODULE_DEVICE_TABLE(i2c, max1586_id); |
283 | |
284 | static struct i2c_driver max1586_pmic_driver = { |
285 | .probe = max1586_pmic_probe, |
286 | .driver = { |
287 | .name = "max1586" , |
288 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
289 | .of_match_table = of_match_ptr(max1586_of_match), |
290 | }, |
291 | .id_table = max1586_id, |
292 | }; |
293 | |
294 | static int __init max1586_pmic_init(void) |
295 | { |
296 | return i2c_add_driver(&max1586_pmic_driver); |
297 | } |
298 | subsys_initcall(max1586_pmic_init); |
299 | |
300 | static void __exit max1586_pmic_exit(void) |
301 | { |
302 | i2c_del_driver(driver: &max1586_pmic_driver); |
303 | } |
304 | module_exit(max1586_pmic_exit); |
305 | |
306 | /* Module information */ |
307 | MODULE_DESCRIPTION("MAXIM 1586 voltage regulator driver" ); |
308 | MODULE_AUTHOR("Robert Jarzmik" ); |
309 | MODULE_LICENSE("GPL" ); |
310 | |