Commit | Line | Data |
---|---|---|
2fa720b4 | 1 | // SPDX-License-Identifier: GPL-2.0 |
69780a3b JM |
2 | /* |
3 | * iio/adc/max9611.c | |
4 | * | |
5 | * Maxim max9611/max9612 high side current sense amplifier with | |
6 | * 12-bit ADC interface. | |
7 | * | |
8 | * Copyright (C) 2017 Jacopo Mondi | |
69780a3b JM |
9 | */ |
10 | ||
11 | /* | |
12 | * This driver supports input common-mode voltage, current-sense | |
13 | * amplifier with programmable gains and die temperature reading from | |
14 | * Maxim max9611/max9612. | |
15 | * | |
16 | * Op-amp, analog comparator, and watchdog functionalities are not | |
17 | * supported by this driver. | |
18 | */ | |
19 | ||
20 | #include <linux/delay.h> | |
21 | #include <linux/i2c.h> | |
22 | #include <linux/iio/iio.h> | |
23 | #include <linux/iio/sysfs.h> | |
24 | #include <linux/module.h> | |
c88eba5a JC |
25 | #include <linux/mod_devicetable.h> |
26 | #include <linux/property.h> | |
69780a3b JM |
27 | |
28 | #define DRIVER_NAME "max9611" | |
29 | ||
30 | /* max9611 register addresses */ | |
31 | #define MAX9611_REG_CSA_DATA 0x00 | |
32 | #define MAX9611_REG_RS_DATA 0x02 | |
33 | #define MAX9611_REG_TEMP_DATA 0x08 | |
34 | #define MAX9611_REG_CTRL1 0x0a | |
35 | #define MAX9611_REG_CTRL2 0x0b | |
36 | ||
37 | /* max9611 REG1 mux configuration options */ | |
38 | #define MAX9611_MUX_MASK GENMASK(3, 0) | |
39 | #define MAX9611_MUX_SENSE_1x 0x00 | |
40 | #define MAX9611_MUX_SENSE_4x 0x01 | |
41 | #define MAX9611_MUX_SENSE_8x 0x02 | |
42 | #define MAX9611_INPUT_VOLT 0x03 | |
43 | #define MAX9611_MUX_TEMP 0x06 | |
44 | ||
45 | /* max9611 voltage (both csa and input) helper macros */ | |
46 | #define MAX9611_VOLTAGE_SHIFT 0x04 | |
47 | #define MAX9611_VOLTAGE_RAW(_r) ((_r) >> MAX9611_VOLTAGE_SHIFT) | |
48 | ||
49 | /* | |
50 | * max9611 current sense amplifier voltage output: | |
51 | * LSB and offset values depends on selected gain (1x, 4x, 8x) | |
52 | * | |
53 | * GAIN LSB (nV) OFFSET (LSB steps) | |
54 | * 1x 107500 1 | |
55 | * 4x 26880 1 | |
56 | * 8x 13440 3 | |
57 | * | |
58 | * The complete formula to calculate current sense voltage is: | |
59 | * (((adc_read >> 4) - offset) / ((1 / LSB) * 10^-3) | |
60 | */ | |
61 | #define MAX9611_CSA_1X_LSB_nV 107500 | |
62 | #define MAX9611_CSA_4X_LSB_nV 26880 | |
63 | #define MAX9611_CSA_8X_LSB_nV 13440 | |
64 | ||
65 | #define MAX9611_CSA_1X_OFFS_RAW 1 | |
66 | #define MAX9611_CSA_4X_OFFS_RAW 1 | |
67 | #define MAX9611_CSA_8X_OFFS_RAW 3 | |
68 | ||
69 | /* | |
70 | * max9611 common input mode (CIM): LSB is 14mV, with 14mV offset at 25 C | |
71 | * | |
72 | * The complete formula to calculate input common voltage is: | |
73 | * (((adc_read >> 4) * 1000) - offset) / (1 / 14 * 1000) | |
74 | */ | |
75 | #define MAX9611_CIM_LSB_mV 14 | |
76 | #define MAX9611_CIM_OFFSET_RAW 1 | |
77 | ||
78 | /* | |
79 | * max9611 temperature reading: LSB is 480 milli degrees Celsius | |
80 | * | |
81 | * The complete formula to calculate temperature is: | |
82 | * ((adc_read >> 7) * 1000) / (1 / 480 * 1000) | |
83 | */ | |
84 | #define MAX9611_TEMP_MAX_POS 0x7f80 | |
85 | #define MAX9611_TEMP_MAX_NEG 0xff80 | |
86 | #define MAX9611_TEMP_MIN_NEG 0xd980 | |
ae8cc91a | 87 | #define MAX9611_TEMP_MASK GENMASK(15, 7) |
69780a3b JM |
88 | #define MAX9611_TEMP_SHIFT 0x07 |
89 | #define MAX9611_TEMP_RAW(_r) ((_r) >> MAX9611_TEMP_SHIFT) | |
90 | #define MAX9611_TEMP_SCALE_NUM 1000000 | |
91 | #define MAX9611_TEMP_SCALE_DIV 2083 | |
92 | ||
9fd229c4 GU |
93 | /* |
94 | * Conversion time is 2 ms (typically) at Ta=25 degreeC | |
95 | * No maximum value is known, so play it safe. | |
96 | */ | |
97 | #define MAX9611_CONV_TIME_US_RANGE 3000, 3300 | |
98 | ||
69780a3b JM |
99 | struct max9611_dev { |
100 | struct device *dev; | |
101 | struct i2c_client *i2c_client; | |
102 | struct mutex lock; | |
103 | unsigned int shunt_resistor_uohm; | |
104 | }; | |
105 | ||
106 | enum max9611_conf_ids { | |
107 | CONF_SENSE_1x, | |
108 | CONF_SENSE_4x, | |
109 | CONF_SENSE_8x, | |
110 | CONF_IN_VOLT, | |
111 | CONF_TEMP, | |
112 | }; | |
113 | ||
922fdc19 | 114 | /* |
69780a3b JM |
115 | * max9611_mux_conf - associate ADC mux configuration with register address |
116 | * where data shall be read from | |
117 | */ | |
118 | static const unsigned int max9611_mux_conf[][2] = { | |
a33db947 GU |
119 | [CONF_SENSE_1x] = { MAX9611_MUX_SENSE_1x, MAX9611_REG_CSA_DATA }, |
120 | [CONF_SENSE_4x] = { MAX9611_MUX_SENSE_4x, MAX9611_REG_CSA_DATA }, | |
121 | [CONF_SENSE_8x] = { MAX9611_MUX_SENSE_8x, MAX9611_REG_CSA_DATA }, | |
122 | [CONF_IN_VOLT] = { MAX9611_INPUT_VOLT, MAX9611_REG_RS_DATA }, | |
123 | [CONF_TEMP] = { MAX9611_MUX_TEMP, MAX9611_REG_TEMP_DATA }, | |
69780a3b JM |
124 | }; |
125 | ||
126 | enum max9611_csa_gain { | |
a33db947 GU |
127 | CSA_GAIN_1x = CONF_SENSE_1x, |
128 | CSA_GAIN_4x = CONF_SENSE_4x, | |
129 | CSA_GAIN_8x = CONF_SENSE_8x, | |
69780a3b JM |
130 | }; |
131 | ||
132 | enum max9611_csa_gain_params { | |
133 | CSA_GAIN_LSB_nV, | |
134 | CSA_GAIN_OFFS_RAW, | |
135 | }; | |
136 | ||
922fdc19 | 137 | /* |
69780a3b JM |
138 | * max9611_csa_gain_conf - associate gain multiplier with LSB and |
139 | * offset values. | |
140 | * | |
141 | * Group together parameters associated with configurable gain | |
142 | * on current sense amplifier path to ADC interface. | |
143 | * Current sense read routine adjusts gain until it gets a meaningful | |
144 | * value; use this structure to retrieve the correct LSB and offset values. | |
145 | */ | |
146 | static const unsigned int max9611_gain_conf[][2] = { | |
a33db947 GU |
147 | [CSA_GAIN_1x] = { MAX9611_CSA_1X_LSB_nV, MAX9611_CSA_1X_OFFS_RAW, }, |
148 | [CSA_GAIN_4x] = { MAX9611_CSA_4X_LSB_nV, MAX9611_CSA_4X_OFFS_RAW, }, | |
149 | [CSA_GAIN_8x] = { MAX9611_CSA_8X_LSB_nV, MAX9611_CSA_8X_OFFS_RAW, }, | |
69780a3b JM |
150 | }; |
151 | ||
152 | enum max9611_chan_addrs { | |
153 | MAX9611_CHAN_VOLTAGE_INPUT, | |
154 | MAX9611_CHAN_VOLTAGE_SENSE, | |
155 | MAX9611_CHAN_TEMPERATURE, | |
156 | MAX9611_CHAN_CURRENT_LOAD, | |
157 | MAX9611_CHAN_POWER_LOAD, | |
158 | }; | |
159 | ||
160 | static const struct iio_chan_spec max9611_channels[] = { | |
161 | { | |
162 | .type = IIO_TEMP, | |
163 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | | |
164 | BIT(IIO_CHAN_INFO_SCALE), | |
165 | .address = MAX9611_CHAN_TEMPERATURE, | |
166 | }, | |
167 | { | |
168 | .type = IIO_VOLTAGE, | |
169 | .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), | |
170 | .address = MAX9611_CHAN_VOLTAGE_SENSE, | |
171 | .indexed = 1, | |
172 | .channel = 0, | |
173 | }, | |
174 | { | |
175 | .type = IIO_VOLTAGE, | |
176 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | | |
177 | BIT(IIO_CHAN_INFO_SCALE) | | |
178 | BIT(IIO_CHAN_INFO_OFFSET), | |
179 | .address = MAX9611_CHAN_VOLTAGE_INPUT, | |
180 | .indexed = 1, | |
181 | .channel = 1, | |
182 | }, | |
183 | { | |
184 | .type = IIO_CURRENT, | |
185 | .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), | |
186 | .address = MAX9611_CHAN_CURRENT_LOAD, | |
187 | }, | |
188 | { | |
189 | .type = IIO_POWER, | |
190 | .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), | |
191 | .address = MAX9611_CHAN_POWER_LOAD | |
192 | }, | |
193 | }; | |
194 | ||
195 | /** | |
196 | * max9611_read_single() - read a single value from ADC interface | |
197 | * | |
198 | * Data registers are 16 bit long, spread between two 8 bit registers | |
199 | * with consecutive addresses. | |
200 | * Configure ADC mux first, then read register at address "reg_addr". | |
201 | * The smbus_read_word routine asks for 16 bits and the ADC is kind enough | |
202 | * to return values from "reg_addr" and "reg_addr + 1" consecutively. | |
203 | * Data are transmitted with big-endian ordering: MSB arrives first. | |
204 | * | |
205 | * @max9611: max9611 device | |
206 | * @selector: index for mux and register configuration | |
207 | * @raw_val: the value returned from ADC | |
208 | */ | |
209 | static int max9611_read_single(struct max9611_dev *max9611, | |
210 | enum max9611_conf_ids selector, | |
211 | u16 *raw_val) | |
212 | { | |
213 | int ret; | |
214 | ||
215 | u8 mux_conf = max9611_mux_conf[selector][0] & MAX9611_MUX_MASK; | |
216 | u8 reg_addr = max9611_mux_conf[selector][1]; | |
217 | ||
218 | /* | |
219 | * Keep mutex lock held during read-write to avoid mux register | |
220 | * (CTRL1) re-configuration. | |
221 | */ | |
222 | mutex_lock(&max9611->lock); | |
223 | ret = i2c_smbus_write_byte_data(max9611->i2c_client, | |
224 | MAX9611_REG_CTRL1, mux_conf); | |
225 | if (ret) { | |
226 | dev_err(max9611->dev, "i2c write byte failed: 0x%2x - 0x%2x\n", | |
227 | MAX9611_REG_CTRL1, mux_conf); | |
228 | mutex_unlock(&max9611->lock); | |
229 | return ret; | |
230 | } | |
231 | ||
9fd229c4 GU |
232 | /* need a delay here to make register configuration stabilize. */ |
233 | ||
234 | usleep_range(MAX9611_CONV_TIME_US_RANGE); | |
69780a3b JM |
235 | |
236 | ret = i2c_smbus_read_word_swapped(max9611->i2c_client, reg_addr); | |
237 | if (ret < 0) { | |
238 | dev_err(max9611->dev, "i2c read word from 0x%2x failed\n", | |
239 | reg_addr); | |
240 | mutex_unlock(&max9611->lock); | |
241 | return ret; | |
242 | } | |
243 | ||
244 | *raw_val = ret; | |
245 | mutex_unlock(&max9611->lock); | |
246 | ||
247 | return 0; | |
248 | } | |
249 | ||
250 | /** | |
251 | * max9611_read_csa_voltage() - read current sense amplifier output voltage | |
252 | * | |
253 | * Current sense amplifier output voltage is read through a configurable | |
254 | * 1x, 4x or 8x gain. | |
255 | * Start with plain 1x gain, and adjust gain control properly until a | |
256 | * meaningful value is read from ADC output. | |
257 | * | |
258 | * @max9611: max9611 device | |
259 | * @adc_raw: raw value read from ADC output | |
260 | * @csa_gain: gain configuration option selector | |
261 | */ | |
262 | static int max9611_read_csa_voltage(struct max9611_dev *max9611, | |
263 | u16 *adc_raw, | |
264 | enum max9611_csa_gain *csa_gain) | |
265 | { | |
266 | enum max9611_conf_ids gain_selectors[] = { | |
267 | CONF_SENSE_1x, | |
268 | CONF_SENSE_4x, | |
269 | CONF_SENSE_8x | |
270 | }; | |
271 | unsigned int i; | |
272 | int ret; | |
273 | ||
274 | for (i = 0; i < ARRAY_SIZE(gain_selectors); ++i) { | |
275 | ret = max9611_read_single(max9611, gain_selectors[i], adc_raw); | |
276 | if (ret) | |
277 | return ret; | |
278 | ||
279 | if (*adc_raw > 0) { | |
b1ec0802 | 280 | *csa_gain = (enum max9611_csa_gain)gain_selectors[i]; |
69780a3b JM |
281 | return 0; |
282 | } | |
283 | } | |
284 | ||
285 | return -EIO; | |
286 | } | |
287 | ||
288 | static int max9611_read_raw(struct iio_dev *indio_dev, | |
289 | struct iio_chan_spec const *chan, | |
290 | int *val, int *val2, long mask) | |
291 | { | |
292 | struct max9611_dev *dev = iio_priv(indio_dev); | |
293 | enum max9611_csa_gain gain_selector; | |
294 | const unsigned int *csa_gain; | |
295 | u16 adc_data; | |
296 | int ret; | |
297 | ||
298 | switch (mask) { | |
299 | case IIO_CHAN_INFO_RAW: | |
300 | ||
301 | switch (chan->address) { | |
302 | case MAX9611_CHAN_TEMPERATURE: | |
303 | ret = max9611_read_single(dev, CONF_TEMP, | |
304 | &adc_data); | |
305 | if (ret) | |
306 | return -EINVAL; | |
307 | ||
308 | *val = MAX9611_TEMP_RAW(adc_data); | |
309 | return IIO_VAL_INT; | |
310 | ||
311 | case MAX9611_CHAN_VOLTAGE_INPUT: | |
312 | ret = max9611_read_single(dev, CONF_IN_VOLT, | |
313 | &adc_data); | |
314 | if (ret) | |
315 | return -EINVAL; | |
316 | ||
317 | *val = MAX9611_VOLTAGE_RAW(adc_data); | |
318 | return IIO_VAL_INT; | |
319 | } | |
320 | ||
321 | break; | |
322 | ||
323 | case IIO_CHAN_INFO_OFFSET: | |
324 | /* MAX9611_CHAN_VOLTAGE_INPUT */ | |
325 | *val = MAX9611_CIM_OFFSET_RAW; | |
326 | ||
327 | return IIO_VAL_INT; | |
328 | ||
329 | case IIO_CHAN_INFO_SCALE: | |
330 | ||
331 | switch (chan->address) { | |
332 | case MAX9611_CHAN_TEMPERATURE: | |
333 | *val = MAX9611_TEMP_SCALE_NUM; | |
334 | *val2 = MAX9611_TEMP_SCALE_DIV; | |
335 | ||
336 | return IIO_VAL_FRACTIONAL; | |
337 | ||
338 | case MAX9611_CHAN_VOLTAGE_INPUT: | |
339 | *val = MAX9611_CIM_LSB_mV; | |
340 | ||
341 | return IIO_VAL_INT; | |
342 | } | |
343 | ||
344 | break; | |
345 | ||
346 | case IIO_CHAN_INFO_PROCESSED: | |
347 | ||
348 | switch (chan->address) { | |
349 | case MAX9611_CHAN_VOLTAGE_SENSE: | |
350 | /* | |
351 | * processed (mV): (raw - offset) * LSB (nV) / 10^6 | |
352 | * | |
353 | * Even if max9611 can output raw csa voltage readings, | |
354 | * use a produced value as scale depends on gain. | |
355 | */ | |
356 | ret = max9611_read_csa_voltage(dev, &adc_data, | |
357 | &gain_selector); | |
358 | if (ret) | |
359 | return -EINVAL; | |
360 | ||
361 | csa_gain = max9611_gain_conf[gain_selector]; | |
362 | ||
363 | adc_data -= csa_gain[CSA_GAIN_OFFS_RAW]; | |
364 | *val = MAX9611_VOLTAGE_RAW(adc_data) * | |
365 | csa_gain[CSA_GAIN_LSB_nV]; | |
366 | *val2 = 1000000; | |
367 | ||
368 | return IIO_VAL_FRACTIONAL; | |
369 | ||
370 | case MAX9611_CHAN_CURRENT_LOAD: | |
371 | /* processed (mA): Vcsa (nV) / Rshunt (uOhm) */ | |
372 | ret = max9611_read_csa_voltage(dev, &adc_data, | |
373 | &gain_selector); | |
374 | if (ret) | |
375 | return -EINVAL; | |
376 | ||
377 | csa_gain = max9611_gain_conf[gain_selector]; | |
378 | ||
379 | adc_data -= csa_gain[CSA_GAIN_OFFS_RAW]; | |
380 | *val = MAX9611_VOLTAGE_RAW(adc_data) * | |
381 | csa_gain[CSA_GAIN_LSB_nV]; | |
382 | *val2 = dev->shunt_resistor_uohm; | |
383 | ||
384 | return IIO_VAL_FRACTIONAL; | |
385 | ||
386 | case MAX9611_CHAN_POWER_LOAD: | |
387 | /* | |
388 | * processed (mW): Vin (mV) * Vcsa (uV) / | |
389 | * Rshunt (uOhm) | |
390 | */ | |
391 | ret = max9611_read_single(dev, CONF_IN_VOLT, | |
392 | &adc_data); | |
393 | if (ret) | |
394 | return -EINVAL; | |
395 | ||
396 | adc_data -= MAX9611_CIM_OFFSET_RAW; | |
397 | *val = MAX9611_VOLTAGE_RAW(adc_data) * | |
398 | MAX9611_CIM_LSB_mV; | |
399 | ||
400 | ret = max9611_read_csa_voltage(dev, &adc_data, | |
401 | &gain_selector); | |
402 | if (ret) | |
403 | return -EINVAL; | |
404 | ||
405 | csa_gain = max9611_gain_conf[gain_selector]; | |
406 | ||
407 | /* divide by 10^3 here to avoid 32bit overflow */ | |
408 | adc_data -= csa_gain[CSA_GAIN_OFFS_RAW]; | |
409 | *val *= MAX9611_VOLTAGE_RAW(adc_data) * | |
410 | csa_gain[CSA_GAIN_LSB_nV] / 1000; | |
411 | *val2 = dev->shunt_resistor_uohm; | |
412 | ||
413 | return IIO_VAL_FRACTIONAL; | |
414 | } | |
415 | ||
416 | break; | |
417 | } | |
418 | ||
419 | return -EINVAL; | |
420 | } | |
421 | ||
422 | static ssize_t max9611_shunt_resistor_show(struct device *dev, | |
423 | struct device_attribute *attr, | |
424 | char *buf) | |
425 | { | |
426 | struct max9611_dev *max9611 = iio_priv(dev_to_iio_dev(dev)); | |
427 | unsigned int i, r; | |
428 | ||
c5451719 JM |
429 | i = max9611->shunt_resistor_uohm / 1000000; |
430 | r = max9611->shunt_resistor_uohm % 1000000; | |
69780a3b | 431 | |
d42b626d | 432 | return sysfs_emit(buf, "%u.%06u\n", i, r); |
69780a3b JM |
433 | } |
434 | ||
435 | static IIO_DEVICE_ATTR(in_power_shunt_resistor, 0444, | |
436 | max9611_shunt_resistor_show, NULL, 0); | |
437 | static IIO_DEVICE_ATTR(in_current_shunt_resistor, 0444, | |
438 | max9611_shunt_resistor_show, NULL, 0); | |
439 | ||
440 | static struct attribute *max9611_attributes[] = { | |
441 | &iio_dev_attr_in_power_shunt_resistor.dev_attr.attr, | |
442 | &iio_dev_attr_in_current_shunt_resistor.dev_attr.attr, | |
443 | NULL, | |
444 | }; | |
445 | ||
446 | static const struct attribute_group max9611_attribute_group = { | |
447 | .attrs = max9611_attributes, | |
448 | }; | |
449 | ||
450 | static const struct iio_info indio_info = { | |
69780a3b JM |
451 | .read_raw = max9611_read_raw, |
452 | .attrs = &max9611_attribute_group, | |
453 | }; | |
454 | ||
455 | static int max9611_init(struct max9611_dev *max9611) | |
456 | { | |
457 | struct i2c_client *client = max9611->i2c_client; | |
458 | u16 regval; | |
459 | int ret; | |
460 | ||
461 | if (!i2c_check_functionality(client->adapter, | |
462 | I2C_FUNC_SMBUS_WRITE_BYTE | | |
463 | I2C_FUNC_SMBUS_READ_WORD_DATA)) { | |
464 | dev_err(max9611->dev, | |
465 | "I2c adapter does not support smbus write_byte or read_word functionalities: aborting probe.\n"); | |
466 | return -EINVAL; | |
467 | } | |
468 | ||
469 | /* Make sure die temperature is in range to test communications. */ | |
470 | ret = max9611_read_single(max9611, CONF_TEMP, ®val); | |
471 | if (ret) | |
472 | return ret; | |
473 | ||
b9ddd509 | 474 | regval &= MAX9611_TEMP_MASK; |
69780a3b JM |
475 | |
476 | if ((regval > MAX9611_TEMP_MAX_POS && | |
477 | regval < MAX9611_TEMP_MIN_NEG) || | |
478 | regval > MAX9611_TEMP_MAX_NEG) { | |
479 | dev_err(max9611->dev, | |
480 | "Invalid value received from ADC 0x%4x: aborting\n", | |
481 | regval); | |
482 | return -EIO; | |
483 | } | |
484 | ||
485 | /* Mux shall be zeroed back before applying other configurations */ | |
486 | ret = i2c_smbus_write_byte_data(max9611->i2c_client, | |
487 | MAX9611_REG_CTRL1, 0); | |
488 | if (ret) { | |
489 | dev_err(max9611->dev, "i2c write byte failed: 0x%2x - 0x%2x\n", | |
490 | MAX9611_REG_CTRL1, 0); | |
491 | return ret; | |
492 | } | |
493 | ||
494 | ret = i2c_smbus_write_byte_data(max9611->i2c_client, | |
495 | MAX9611_REG_CTRL2, 0); | |
496 | if (ret) { | |
497 | dev_err(max9611->dev, "i2c write byte failed: 0x%2x - 0x%2x\n", | |
498 | MAX9611_REG_CTRL2, 0); | |
499 | return ret; | |
500 | } | |
9fd229c4 | 501 | usleep_range(MAX9611_CONV_TIME_US_RANGE); |
69780a3b JM |
502 | |
503 | return 0; | |
504 | } | |
505 | ||
506 | static const struct of_device_id max9611_of_table[] = { | |
09e3bdfe JC |
507 | { .compatible = "maxim,max9611", .data = "max9611" }, |
508 | { .compatible = "maxim,max9612", .data = "max9612" }, | |
509 | { } | |
69780a3b JM |
510 | }; |
511 | ||
512 | MODULE_DEVICE_TABLE(of, max9611_of_table); | |
d59ecbc4 | 513 | static int max9611_probe(struct i2c_client *client) |
69780a3b JM |
514 | { |
515 | const char * const shunt_res_prop = "shunt-resistor-micro-ohms"; | |
69780a3b JM |
516 | struct max9611_dev *max9611; |
517 | struct iio_dev *indio_dev; | |
c88eba5a | 518 | struct device *dev = &client->dev; |
69780a3b JM |
519 | unsigned int of_shunt; |
520 | int ret; | |
521 | ||
522 | indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*max9611)); | |
35fa70df DC |
523 | if (!indio_dev) |
524 | return -ENOMEM; | |
69780a3b JM |
525 | |
526 | i2c_set_clientdata(client, indio_dev); | |
527 | ||
528 | max9611 = iio_priv(indio_dev); | |
c88eba5a | 529 | max9611->dev = dev; |
69780a3b JM |
530 | max9611->i2c_client = client; |
531 | mutex_init(&max9611->lock); | |
532 | ||
c88eba5a | 533 | ret = device_property_read_u32(dev, shunt_res_prop, &of_shunt); |
69780a3b | 534 | if (ret) { |
c88eba5a JC |
535 | dev_err(dev, "Missing %s property for %pfw node\n", |
536 | shunt_res_prop, dev_fwnode(dev)); | |
69780a3b JM |
537 | return ret; |
538 | } | |
539 | max9611->shunt_resistor_uohm = of_shunt; | |
540 | ||
541 | ret = max9611_init(max9611); | |
542 | if (ret) | |
543 | return ret; | |
544 | ||
c88eba5a | 545 | indio_dev->name = device_get_match_data(dev); |
69780a3b JM |
546 | indio_dev->modes = INDIO_DIRECT_MODE; |
547 | indio_dev->info = &indio_info; | |
548 | indio_dev->channels = max9611_channels; | |
549 | indio_dev->num_channels = ARRAY_SIZE(max9611_channels); | |
550 | ||
c88eba5a | 551 | return devm_iio_device_register(dev, indio_dev); |
69780a3b JM |
552 | } |
553 | ||
554 | static struct i2c_driver max9611_driver = { | |
555 | .driver = { | |
556 | .name = DRIVER_NAME, | |
69780a3b JM |
557 | .of_match_table = max9611_of_table, |
558 | }, | |
7cf15f42 | 559 | .probe = max9611_probe, |
69780a3b JM |
560 | }; |
561 | module_i2c_driver(max9611_driver); | |
562 | ||
563 | MODULE_AUTHOR("Jacopo Mondi <jacopo+renesas@jmondi.org>"); | |
564 | MODULE_DESCRIPTION("Maxim max9611/12 current sense amplifier with 12bit ADC"); | |
565 | MODULE_LICENSE("GPL v2"); |