1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Device driver for regulators in MAX5970 and MAX5978 IC |
4 | * |
5 | * Copyright (c) 2022 9elements GmbH |
6 | * |
7 | * Author: Patrick Rudolph <patrick.rudolph@9elements.com> |
8 | */ |
9 | |
10 | #include <linux/bitops.h> |
11 | #include <linux/device.h> |
12 | #include <linux/err.h> |
13 | #include <linux/hwmon.h> |
14 | #include <linux/module.h> |
15 | #include <linux/io.h> |
16 | #include <linux/of.h> |
17 | #include <linux/i2c.h> |
18 | #include <linux/regmap.h> |
19 | #include <linux/regulator/driver.h> |
20 | #include <linux/regulator/machine.h> |
21 | #include <linux/regulator/of_regulator.h> |
22 | #include <linux/platform_device.h> |
23 | |
24 | #include <linux/mfd/max5970.h> |
25 | |
26 | struct max5970_regulator { |
27 | int num_switches, mon_rng, irng, shunt_micro_ohms, lim_uA; |
28 | struct regmap *regmap; |
29 | }; |
30 | |
31 | enum max597x_regulator_id { |
32 | MAX597X_sw0, |
33 | MAX597X_sw1, |
34 | }; |
35 | |
36 | static int max5970_read_adc(struct regmap *regmap, int reg, long *val) |
37 | { |
38 | u8 reg_data[2]; |
39 | int ret; |
40 | |
41 | ret = regmap_bulk_read(map: regmap, reg, val: ®_data[0], val_count: 2); |
42 | if (ret < 0) |
43 | return ret; |
44 | |
45 | *val = (reg_data[0] << 2) | (reg_data[1] & 3); |
46 | |
47 | return 0; |
48 | } |
49 | |
50 | static int max5970_read(struct device *dev, enum hwmon_sensor_types type, |
51 | u32 attr, int channel, long *val) |
52 | { |
53 | struct regulator_dev **rdevs = dev_get_drvdata(dev); |
54 | struct max5970_regulator *ddata = rdev_get_drvdata(rdev: rdevs[channel]); |
55 | struct regmap *regmap = ddata->regmap; |
56 | int ret; |
57 | |
58 | switch (type) { |
59 | case hwmon_curr: |
60 | switch (attr) { |
61 | case hwmon_curr_input: |
62 | ret = max5970_read_adc(regmap, MAX5970_REG_CURRENT_H(channel), val); |
63 | if (ret < 0) |
64 | return ret; |
65 | /* |
66 | * Calculate current from ADC value, IRNG range & shunt resistor value. |
67 | * ddata->irng holds the voltage corresponding to the maximum value the |
68 | * 10-bit ADC can measure. |
69 | * To obtain the output, multiply the ADC value by the IRNG range (in |
70 | * millivolts) and then divide it by the maximum value of the 10-bit ADC. |
71 | */ |
72 | *val = (*val * ddata->irng) >> 10; |
73 | /* Convert the voltage meansurement across shunt resistor to current */ |
74 | *val = (*val * 1000) / ddata->shunt_micro_ohms; |
75 | return 0; |
76 | default: |
77 | return -EOPNOTSUPP; |
78 | } |
79 | |
80 | case hwmon_in: |
81 | switch (attr) { |
82 | case hwmon_in_input: |
83 | ret = max5970_read_adc(regmap, MAX5970_REG_VOLTAGE_H(channel), val); |
84 | if (ret < 0) |
85 | return ret; |
86 | /* |
87 | * Calculate voltage from ADC value and MON range. |
88 | * ddata->mon_rng holds the voltage corresponding to the maximum value the |
89 | * 10-bit ADC can measure. |
90 | * To obtain the output, multiply the ADC value by the MON range (in |
91 | * microvolts) and then divide it by the maximum value of the 10-bit ADC. |
92 | */ |
93 | *val = mul_u64_u32_shr(a: *val, mul: ddata->mon_rng, shift: 10); |
94 | /* uV to mV */ |
95 | *val = *val / 1000; |
96 | return 0; |
97 | default: |
98 | return -EOPNOTSUPP; |
99 | } |
100 | default: |
101 | return -EOPNOTSUPP; |
102 | } |
103 | } |
104 | |
105 | static umode_t max5970_is_visible(const void *data, |
106 | enum hwmon_sensor_types type, |
107 | u32 attr, int channel) |
108 | { |
109 | struct regulator_dev **rdevs = (struct regulator_dev **)data; |
110 | struct max5970_regulator *ddata; |
111 | |
112 | if (channel >= MAX5970_NUM_SWITCHES || !rdevs[channel]) |
113 | return 0; |
114 | |
115 | ddata = rdev_get_drvdata(rdev: rdevs[channel]); |
116 | |
117 | if (channel >= ddata->num_switches) |
118 | return 0; |
119 | |
120 | switch (type) { |
121 | case hwmon_in: |
122 | switch (attr) { |
123 | case hwmon_in_input: |
124 | return 0444; |
125 | default: |
126 | break; |
127 | } |
128 | break; |
129 | case hwmon_curr: |
130 | switch (attr) { |
131 | case hwmon_curr_input: |
132 | /* Current measurement requires knowledge of the shunt resistor value. */ |
133 | if (ddata->shunt_micro_ohms) |
134 | return 0444; |
135 | break; |
136 | default: |
137 | break; |
138 | } |
139 | break; |
140 | default: |
141 | break; |
142 | } |
143 | return 0; |
144 | } |
145 | |
146 | static const struct hwmon_ops max5970_hwmon_ops = { |
147 | .is_visible = max5970_is_visible, |
148 | .read = max5970_read, |
149 | }; |
150 | |
151 | static const struct hwmon_channel_info *max5970_info[] = { |
152 | HWMON_CHANNEL_INFO(in, HWMON_I_INPUT, HWMON_I_INPUT), |
153 | HWMON_CHANNEL_INFO(curr, HWMON_C_INPUT, HWMON_C_INPUT), |
154 | NULL |
155 | }; |
156 | |
157 | static const struct hwmon_chip_info max5970_chip_info = { |
158 | .ops = &max5970_hwmon_ops, |
159 | .info = max5970_info, |
160 | }; |
161 | |
162 | static int max597x_uvp_ovp_check_mode(struct regulator_dev *rdev, int severity) |
163 | { |
164 | int ret, reg; |
165 | |
166 | /* Status1 register contains the soft strap values sampled at POR */ |
167 | ret = regmap_read(map: rdev->regmap, MAX5970_REG_STATUS1, val: ®); |
168 | if (ret) |
169 | return ret; |
170 | |
171 | /* Check soft straps match requested mode */ |
172 | if (severity == REGULATOR_SEVERITY_PROT) { |
173 | if (STATUS1_PROT(reg) != STATUS1_PROT_SHUTDOWN) |
174 | return -EOPNOTSUPP; |
175 | |
176 | return 0; |
177 | } |
178 | if (STATUS1_PROT(reg) == STATUS1_PROT_SHUTDOWN) |
179 | return -EOPNOTSUPP; |
180 | |
181 | return 0; |
182 | } |
183 | |
184 | static int max597x_set_vp(struct regulator_dev *rdev, int lim_uV, int severity, |
185 | bool enable, bool overvoltage) |
186 | { |
187 | int off_h, off_l, reg, ret; |
188 | struct max5970_regulator *data = rdev_get_drvdata(rdev); |
189 | int channel = rdev_get_id(rdev); |
190 | |
191 | if (overvoltage) { |
192 | if (severity == REGULATOR_SEVERITY_WARN) { |
193 | off_h = MAX5970_REG_CH_OV_WARN_H(channel); |
194 | off_l = MAX5970_REG_CH_OV_WARN_L(channel); |
195 | } else { |
196 | off_h = MAX5970_REG_CH_OV_CRIT_H(channel); |
197 | off_l = MAX5970_REG_CH_OV_CRIT_L(channel); |
198 | } |
199 | } else { |
200 | if (severity == REGULATOR_SEVERITY_WARN) { |
201 | off_h = MAX5970_REG_CH_UV_WARN_H(channel); |
202 | off_l = MAX5970_REG_CH_UV_WARN_L(channel); |
203 | } else { |
204 | off_h = MAX5970_REG_CH_UV_CRIT_H(channel); |
205 | off_l = MAX5970_REG_CH_UV_CRIT_L(channel); |
206 | } |
207 | } |
208 | |
209 | if (enable) |
210 | /* reg = ADC_MASK * (lim_uV / 1000000) / (data->mon_rng / 1000000) */ |
211 | reg = ADC_MASK * lim_uV / data->mon_rng; |
212 | else |
213 | reg = 0; |
214 | |
215 | ret = regmap_write(map: rdev->regmap, reg: off_h, MAX5970_VAL2REG_H(reg)); |
216 | if (ret) |
217 | return ret; |
218 | |
219 | ret = regmap_write(map: rdev->regmap, reg: off_l, MAX5970_VAL2REG_L(reg)); |
220 | if (ret) |
221 | return ret; |
222 | |
223 | return 0; |
224 | } |
225 | |
226 | static int max597x_set_uvp(struct regulator_dev *rdev, int lim_uV, int severity, |
227 | bool enable) |
228 | { |
229 | int ret; |
230 | |
231 | /* |
232 | * MAX5970 has enable control as a special value in limit reg. Can't |
233 | * set limit but keep feature disabled or enable W/O given limit. |
234 | */ |
235 | if ((lim_uV && !enable) || (!lim_uV && enable)) |
236 | return -EINVAL; |
237 | |
238 | ret = max597x_uvp_ovp_check_mode(rdev, severity); |
239 | if (ret) |
240 | return ret; |
241 | |
242 | return max597x_set_vp(rdev, lim_uV, severity, enable, overvoltage: false); |
243 | } |
244 | |
245 | static int max597x_set_ovp(struct regulator_dev *rdev, int lim_uV, int severity, |
246 | bool enable) |
247 | { |
248 | int ret; |
249 | |
250 | /* |
251 | * MAX5970 has enable control as a special value in limit reg. Can't |
252 | * set limit but keep feature disabled or enable W/O given limit. |
253 | */ |
254 | if ((lim_uV && !enable) || (!lim_uV && enable)) |
255 | return -EINVAL; |
256 | |
257 | ret = max597x_uvp_ovp_check_mode(rdev, severity); |
258 | if (ret) |
259 | return ret; |
260 | |
261 | return max597x_set_vp(rdev, lim_uV, severity, enable, overvoltage: true); |
262 | } |
263 | |
264 | static int max597x_set_ocp(struct regulator_dev *rdev, int lim_uA, |
265 | int severity, bool enable) |
266 | { |
267 | int val, reg; |
268 | unsigned int vthst, vthfst; |
269 | |
270 | struct max5970_regulator *data = rdev_get_drvdata(rdev); |
271 | int rdev_id = rdev_get_id(rdev); |
272 | /* |
273 | * MAX5970 doesn't has enable control for ocp. |
274 | * If limit is specified but enable is not set then hold the value in |
275 | * variable & later use it when ocp needs to be enabled. |
276 | */ |
277 | if (lim_uA != 0 && lim_uA != data->lim_uA) |
278 | data->lim_uA = lim_uA; |
279 | |
280 | if (severity != REGULATOR_SEVERITY_PROT) |
281 | return -EINVAL; |
282 | |
283 | if (enable) { |
284 | |
285 | /* Calc Vtrip threshold in uV. */ |
286 | vthst = |
287 | div_u64(dividend: mul_u32_u32(a: data->shunt_micro_ohms, b: data->lim_uA), |
288 | divisor: 1000000); |
289 | |
290 | /* |
291 | * As recommended in datasheed, add 20% margin to avoid |
292 | * spurious event & passive component tolerance. |
293 | */ |
294 | vthst = div_u64(dividend: mul_u32_u32(a: vthst, b: 120), divisor: 100); |
295 | |
296 | /* Calc fast Vtrip threshold in uV */ |
297 | vthfst = vthst * (MAX5970_FAST2SLOW_RATIO / 100); |
298 | |
299 | if (vthfst > data->irng) { |
300 | dev_err(&rdev->dev, "Current limit out of range\n" ); |
301 | return -EINVAL; |
302 | } |
303 | /* Fast trip threshold to be programmed */ |
304 | val = div_u64(dividend: mul_u32_u32(a: 0xFF, b: vthfst), divisor: data->irng); |
305 | } else |
306 | /* |
307 | * Since there is no option to disable ocp, set limit to max |
308 | * value |
309 | */ |
310 | val = 0xFF; |
311 | |
312 | reg = MAX5970_REG_DAC_FAST(rdev_id); |
313 | |
314 | return regmap_write(map: rdev->regmap, reg, val); |
315 | } |
316 | |
317 | static int max597x_get_status(struct regulator_dev *rdev) |
318 | { |
319 | int val, ret; |
320 | |
321 | ret = regmap_read(map: rdev->regmap, MAX5970_REG_STATUS3, val: &val); |
322 | if (ret) |
323 | return ret; |
324 | |
325 | if (val & MAX5970_STATUS3_ALERT) |
326 | return REGULATOR_STATUS_ERROR; |
327 | |
328 | ret = regulator_is_enabled_regmap(rdev); |
329 | if (ret < 0) |
330 | return ret; |
331 | |
332 | if (ret) |
333 | return REGULATOR_STATUS_ON; |
334 | |
335 | return REGULATOR_STATUS_OFF; |
336 | } |
337 | |
338 | static const struct regulator_ops max597x_switch_ops = { |
339 | .enable = regulator_enable_regmap, |
340 | .disable = regulator_disable_regmap, |
341 | .is_enabled = regulator_is_enabled_regmap, |
342 | .get_status = max597x_get_status, |
343 | .set_over_voltage_protection = max597x_set_ovp, |
344 | .set_under_voltage_protection = max597x_set_uvp, |
345 | .set_over_current_protection = max597x_set_ocp, |
346 | }; |
347 | |
348 | static int max597x_dt_parse(struct device_node *np, |
349 | const struct regulator_desc *desc, |
350 | struct regulator_config *cfg) |
351 | { |
352 | struct max5970_regulator *data = cfg->driver_data; |
353 | int ret = 0; |
354 | |
355 | ret = |
356 | of_property_read_u32(np, propname: "shunt-resistor-micro-ohms" , |
357 | out_value: &data->shunt_micro_ohms); |
358 | if (ret < 0) |
359 | dev_err(cfg->dev, |
360 | "property 'shunt-resistor-micro-ohms' not found, err %d\n" , |
361 | ret); |
362 | return ret; |
363 | |
364 | } |
365 | |
366 | #define MAX597X_SWITCH(_ID, _ereg, _chan, _supply) { \ |
367 | .name = #_ID, \ |
368 | .of_match = of_match_ptr(#_ID), \ |
369 | .ops = &max597x_switch_ops, \ |
370 | .regulators_node = of_match_ptr("regulators"), \ |
371 | .type = REGULATOR_VOLTAGE, \ |
372 | .id = MAX597X_##_ID, \ |
373 | .owner = THIS_MODULE, \ |
374 | .supply_name = _supply, \ |
375 | .enable_reg = _ereg, \ |
376 | .enable_mask = CHXEN((_chan)), \ |
377 | .of_parse_cb = max597x_dt_parse, \ |
378 | } |
379 | |
380 | static const struct regulator_desc regulators[] = { |
381 | MAX597X_SWITCH(sw0, MAX5970_REG_CHXEN, 0, "vss1" ), |
382 | MAX597X_SWITCH(sw1, MAX5970_REG_CHXEN, 1, "vss2" ), |
383 | }; |
384 | |
385 | static int max597x_regmap_read_clear(struct regmap *map, unsigned int reg, |
386 | unsigned int *val) |
387 | { |
388 | int ret; |
389 | |
390 | ret = regmap_read(map, reg, val); |
391 | if (ret) |
392 | return ret; |
393 | |
394 | if (*val) |
395 | return regmap_write(map, reg, val: 0); |
396 | |
397 | return 0; |
398 | } |
399 | |
400 | static int max597x_irq_handler(int irq, struct regulator_irq_data *rid, |
401 | unsigned long *dev_mask) |
402 | { |
403 | struct regulator_err_state *stat; |
404 | struct max5970_regulator *d = (struct max5970_regulator *)rid->data; |
405 | int val, ret, i; |
406 | |
407 | ret = max597x_regmap_read_clear(map: d->regmap, MAX5970_REG_FAULT0, val: &val); |
408 | if (ret) |
409 | return REGULATOR_FAILED_RETRY; |
410 | |
411 | *dev_mask = 0; |
412 | for (i = 0; i < d->num_switches; i++) { |
413 | stat = &rid->states[i]; |
414 | stat->notifs = 0; |
415 | stat->errors = 0; |
416 | } |
417 | |
418 | for (i = 0; i < d->num_switches; i++) { |
419 | stat = &rid->states[i]; |
420 | |
421 | if (val & UV_STATUS_CRIT(i)) { |
422 | *dev_mask |= 1 << i; |
423 | stat->notifs |= REGULATOR_EVENT_UNDER_VOLTAGE; |
424 | stat->errors |= REGULATOR_ERROR_UNDER_VOLTAGE; |
425 | } else if (val & UV_STATUS_WARN(i)) { |
426 | *dev_mask |= 1 << i; |
427 | stat->notifs |= REGULATOR_EVENT_UNDER_VOLTAGE_WARN; |
428 | stat->errors |= REGULATOR_ERROR_UNDER_VOLTAGE_WARN; |
429 | } |
430 | } |
431 | |
432 | ret = max597x_regmap_read_clear(map: d->regmap, MAX5970_REG_FAULT1, val: &val); |
433 | if (ret) |
434 | return REGULATOR_FAILED_RETRY; |
435 | |
436 | for (i = 0; i < d->num_switches; i++) { |
437 | stat = &rid->states[i]; |
438 | |
439 | if (val & OV_STATUS_CRIT(i)) { |
440 | *dev_mask |= 1 << i; |
441 | stat->notifs |= REGULATOR_EVENT_REGULATION_OUT; |
442 | stat->errors |= REGULATOR_ERROR_REGULATION_OUT; |
443 | } else if (val & OV_STATUS_WARN(i)) { |
444 | *dev_mask |= 1 << i; |
445 | stat->notifs |= REGULATOR_EVENT_OVER_VOLTAGE_WARN; |
446 | stat->errors |= REGULATOR_ERROR_OVER_VOLTAGE_WARN; |
447 | } |
448 | } |
449 | |
450 | ret = max597x_regmap_read_clear(map: d->regmap, MAX5970_REG_FAULT2, val: &val); |
451 | if (ret) |
452 | return REGULATOR_FAILED_RETRY; |
453 | |
454 | for (i = 0; i < d->num_switches; i++) { |
455 | stat = &rid->states[i]; |
456 | |
457 | if (val & OC_STATUS_WARN(i)) { |
458 | *dev_mask |= 1 << i; |
459 | stat->notifs |= REGULATOR_EVENT_OVER_CURRENT_WARN; |
460 | stat->errors |= REGULATOR_ERROR_OVER_CURRENT_WARN; |
461 | } |
462 | } |
463 | |
464 | ret = regmap_read(map: d->regmap, MAX5970_REG_STATUS0, val: &val); |
465 | if (ret) |
466 | return REGULATOR_FAILED_RETRY; |
467 | |
468 | for (i = 0; i < d->num_switches; i++) { |
469 | stat = &rid->states[i]; |
470 | |
471 | if ((val & MAX5970_CB_IFAULTF(i)) |
472 | || (val & MAX5970_CB_IFAULTS(i))) { |
473 | *dev_mask |= 1 << i; |
474 | stat->notifs |= |
475 | REGULATOR_EVENT_OVER_CURRENT | |
476 | REGULATOR_EVENT_DISABLE; |
477 | stat->errors |= |
478 | REGULATOR_ERROR_OVER_CURRENT | REGULATOR_ERROR_FAIL; |
479 | |
480 | /* Clear the sub-IRQ status */ |
481 | regulator_disable_regmap(rdev: stat->rdev); |
482 | } |
483 | } |
484 | return 0; |
485 | } |
486 | |
487 | static int max597x_adc_range(struct regmap *regmap, const int ch, |
488 | u32 *irng, u32 *mon_rng) |
489 | { |
490 | unsigned int reg; |
491 | int ret; |
492 | |
493 | /* Decode current ADC range */ |
494 | ret = regmap_read(map: regmap, MAX5970_REG_STATUS2, val: ®); |
495 | if (ret) |
496 | return ret; |
497 | switch (MAX5970_IRNG(reg, ch)) { |
498 | case 0: |
499 | *irng = 100000; /* 100 mV */ |
500 | break; |
501 | case 1: |
502 | *irng = 50000; /* 50 mV */ |
503 | break; |
504 | case 2: |
505 | *irng = 25000; /* 25 mV */ |
506 | break; |
507 | default: |
508 | return -EINVAL; |
509 | } |
510 | |
511 | /* Decode current voltage monitor range */ |
512 | ret = regmap_read(map: regmap, MAX5970_REG_MON_RANGE, val: ®); |
513 | if (ret) |
514 | return ret; |
515 | |
516 | *mon_rng = MAX5970_MON_MAX_RANGE_UV >> MAX5970_MON(reg, ch); |
517 | |
518 | return 0; |
519 | } |
520 | |
521 | static int max597x_setup_irq(struct device *dev, |
522 | int irq, |
523 | struct regulator_dev *rdevs[MAX5970_NUM_SWITCHES], |
524 | int num_switches, struct max5970_regulator *data) |
525 | { |
526 | struct regulator_irq_desc max597x_notif = { |
527 | .name = "max597x-irq" , |
528 | .map_event = max597x_irq_handler, |
529 | .data = data, |
530 | }; |
531 | int errs = REGULATOR_ERROR_UNDER_VOLTAGE | |
532 | REGULATOR_ERROR_UNDER_VOLTAGE_WARN | |
533 | REGULATOR_ERROR_OVER_VOLTAGE_WARN | |
534 | REGULATOR_ERROR_REGULATION_OUT | |
535 | REGULATOR_ERROR_OVER_CURRENT | |
536 | REGULATOR_ERROR_OVER_CURRENT_WARN | REGULATOR_ERROR_FAIL; |
537 | void *irq_helper; |
538 | |
539 | /* Register notifiers - can fail if IRQ is not given */ |
540 | irq_helper = devm_regulator_irq_helper(dev, d: &max597x_notif, |
541 | irq, irq_flags: 0, common_errs: errs, NULL, |
542 | rdev: &rdevs[0], rdev_amount: num_switches); |
543 | if (IS_ERR(ptr: irq_helper)) { |
544 | if (PTR_ERR(ptr: irq_helper) == -EPROBE_DEFER) |
545 | return -EPROBE_DEFER; |
546 | |
547 | dev_warn(dev, "IRQ disabled %pe\n" , irq_helper); |
548 | } |
549 | |
550 | return 0; |
551 | } |
552 | |
553 | static int max597x_regulator_probe(struct platform_device *pdev) |
554 | { |
555 | struct max5970_data *max597x; |
556 | struct regmap *regmap = dev_get_regmap(dev: pdev->dev.parent, NULL); |
557 | struct max5970_regulator *data; |
558 | struct i2c_client *i2c = to_i2c_client(pdev->dev.parent); |
559 | struct regulator_config config = { }; |
560 | struct regulator_dev *rdev; |
561 | struct regulator_dev **rdevs = NULL; |
562 | struct device *hwmon_dev; |
563 | int num_switches; |
564 | int ret, i; |
565 | |
566 | if (!regmap) |
567 | return -EPROBE_DEFER; |
568 | |
569 | max597x = devm_kzalloc(dev: &i2c->dev, size: sizeof(struct max5970_data), GFP_KERNEL); |
570 | if (!max597x) |
571 | return -ENOMEM; |
572 | |
573 | rdevs = devm_kcalloc(dev: &i2c->dev, MAX5970_NUM_SWITCHES, size: sizeof(struct regulator_dev *), |
574 | GFP_KERNEL); |
575 | if (!rdevs) |
576 | return -ENOMEM; |
577 | |
578 | i2c_set_clientdata(client: i2c, data: max597x); |
579 | |
580 | if (of_device_is_compatible(device: i2c->dev.of_node, "maxim,max5978" )) |
581 | max597x->num_switches = MAX5978_NUM_SWITCHES; |
582 | else if (of_device_is_compatible(device: i2c->dev.of_node, "maxim,max5970" )) |
583 | max597x->num_switches = MAX5970_NUM_SWITCHES; |
584 | else |
585 | return -ENODEV; |
586 | |
587 | num_switches = max597x->num_switches; |
588 | |
589 | for (i = 0; i < num_switches; i++) { |
590 | data = |
591 | devm_kzalloc(dev: &i2c->dev, size: sizeof(struct max5970_regulator), |
592 | GFP_KERNEL); |
593 | if (!data) |
594 | return -ENOMEM; |
595 | |
596 | data->num_switches = num_switches; |
597 | data->regmap = regmap; |
598 | |
599 | ret = max597x_adc_range(regmap, ch: i, irng: &max597x->irng[i], mon_rng: &max597x->mon_rng[i]); |
600 | if (ret < 0) |
601 | return ret; |
602 | |
603 | data->irng = max597x->irng[i]; |
604 | data->mon_rng = max597x->mon_rng[i]; |
605 | |
606 | config.dev = &i2c->dev; |
607 | config.driver_data = (void *)data; |
608 | config.regmap = data->regmap; |
609 | rdev = devm_regulator_register(dev: &i2c->dev, |
610 | regulator_desc: ®ulators[i], config: &config); |
611 | if (IS_ERR(ptr: rdev)) { |
612 | dev_err(&i2c->dev, "failed to register regulator %s\n" , |
613 | regulators[i].name); |
614 | return PTR_ERR(ptr: rdev); |
615 | } |
616 | rdevs[i] = rdev; |
617 | max597x->shunt_micro_ohms[i] = data->shunt_micro_ohms; |
618 | } |
619 | |
620 | if (IS_REACHABLE(CONFIG_HWMON)) { |
621 | hwmon_dev = devm_hwmon_device_register_with_info(dev: &i2c->dev, name: "max5970" , drvdata: rdevs, |
622 | info: &max5970_chip_info, NULL); |
623 | if (IS_ERR(ptr: hwmon_dev)) { |
624 | return dev_err_probe(dev: &i2c->dev, err: PTR_ERR(ptr: hwmon_dev), |
625 | fmt: "Unable to register hwmon device\n" ); |
626 | } |
627 | } |
628 | |
629 | if (i2c->irq) { |
630 | ret = |
631 | max597x_setup_irq(dev: &i2c->dev, irq: i2c->irq, rdevs, num_switches, |
632 | data); |
633 | if (ret) { |
634 | dev_err(&i2c->dev, "IRQ setup failed" ); |
635 | return ret; |
636 | } |
637 | } |
638 | |
639 | return ret; |
640 | } |
641 | |
642 | static struct platform_driver max597x_regulator_driver = { |
643 | .driver = { |
644 | .name = "max5970-regulator" , |
645 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
646 | }, |
647 | .probe = max597x_regulator_probe, |
648 | }; |
649 | |
650 | module_platform_driver(max597x_regulator_driver); |
651 | |
652 | |
653 | MODULE_AUTHOR("Patrick Rudolph <patrick.rudolph@9elements.com>" ); |
654 | MODULE_DESCRIPTION("MAX5970_hot-swap controller driver" ); |
655 | MODULE_LICENSE("GPL v2" ); |
656 | |