1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // Copyright (c) 2010-2024 Analog Devices Inc.
4 // Copyright (c) 2024 Baylibre, SAS
5
6 #include <linux/bitfield.h>
7 #include <linux/device.h>
8 #include <linux/module.h>
9 #include <linux/property.h>
10 #include <linux/regulator/consumer.h>
11
12 #include "ad3552r.h"
13
14 static const s32 ad3552r_ch_ranges[AD3552R_MAX_RANGES][2] = {
15 [AD3552R_CH_OUTPUT_RANGE_0__2P5V] = { 0, 2500 },
16 [AD3552R_CH_OUTPUT_RANGE_0__5V] = { 0, 5000 },
17 [AD3552R_CH_OUTPUT_RANGE_0__10V] = { 0, 10000 },
18 [AD3552R_CH_OUTPUT_RANGE_NEG_5__5V] = { -5000, 5000 },
19 [AD3552R_CH_OUTPUT_RANGE_NEG_10__10V] = { -10000, 10000 }
20 };
21
22 static const s32 ad3542r_ch_ranges[AD3542R_MAX_RANGES][2] = {
23 [AD3542R_CH_OUTPUT_RANGE_0__2P5V] = { 0, 2500 },
24 [AD3542R_CH_OUTPUT_RANGE_0__5V] = { 0, 5000 },
25 [AD3542R_CH_OUTPUT_RANGE_0__10V] = { 0, 10000 },
26 [AD3542R_CH_OUTPUT_RANGE_NEG_5__5V] = { -5000, 5000 },
27 [AD3542R_CH_OUTPUT_RANGE_NEG_2P5__7P5V] = { -2500, 7500 }
28 };
29
30 /* Gain * AD3552R_GAIN_SCALE */
31 static const s32 gains_scaling_table[] = {
32 [AD3552R_CH_GAIN_SCALING_1] = 1000,
33 [AD3552R_CH_GAIN_SCALING_0_5] = 500,
34 [AD3552R_CH_GAIN_SCALING_0_25] = 250,
35 [AD3552R_CH_GAIN_SCALING_0_125] = 125
36 };
37
38 const struct ad3552r_model_data ad3541r_model_data = {
39 .model_name = "ad3541r",
40 .chip_id = AD3541R_ID,
41 .num_hw_channels = 1,
42 .ranges_table = ad3542r_ch_ranges,
43 .num_ranges = ARRAY_SIZE(ad3542r_ch_ranges),
44 .requires_output_range = true,
45 .num_spi_data_lanes = 2,
46 };
47 EXPORT_SYMBOL_NS_GPL(ad3541r_model_data, "IIO_AD3552R");
48
49 const struct ad3552r_model_data ad3542r_model_data = {
50 .model_name = "ad3542r",
51 .chip_id = AD3542R_ID,
52 .num_hw_channels = 2,
53 .ranges_table = ad3542r_ch_ranges,
54 .num_ranges = ARRAY_SIZE(ad3542r_ch_ranges),
55 .requires_output_range = true,
56 .num_spi_data_lanes = 2,
57 };
58 EXPORT_SYMBOL_NS_GPL(ad3542r_model_data, "IIO_AD3552R");
59
60 const struct ad3552r_model_data ad3551r_model_data = {
61 .model_name = "ad3551r",
62 .chip_id = AD3551R_ID,
63 .num_hw_channels = 1,
64 .ranges_table = ad3552r_ch_ranges,
65 .num_ranges = ARRAY_SIZE(ad3552r_ch_ranges),
66 .requires_output_range = false,
67 .num_spi_data_lanes = 4,
68 };
69 EXPORT_SYMBOL_NS_GPL(ad3551r_model_data, "IIO_AD3552R");
70
71 const struct ad3552r_model_data ad3552r_model_data = {
72 .model_name = "ad3552r",
73 .chip_id = AD3552R_ID,
74 .num_hw_channels = 2,
75 .ranges_table = ad3552r_ch_ranges,
76 .num_ranges = ARRAY_SIZE(ad3552r_ch_ranges),
77 .requires_output_range = false,
78 .num_spi_data_lanes = 4,
79 };
80 EXPORT_SYMBOL_NS_GPL(ad3552r_model_data, "IIO_AD3552R");
81
ad3552r_calc_custom_gain(u8 p,u8 n,s16 goffs)82 u16 ad3552r_calc_custom_gain(u8 p, u8 n, s16 goffs)
83 {
84 return FIELD_PREP(AD3552R_MASK_CH_RANGE_OVERRIDE, 1) |
85 FIELD_PREP(AD3552R_MASK_CH_GAIN_SCALING_P, p) |
86 FIELD_PREP(AD3552R_MASK_CH_GAIN_SCALING_N, n) |
87 FIELD_PREP(AD3552R_MASK_CH_OFFSET_BIT_8, abs(goffs)) |
88 FIELD_PREP(AD3552R_MASK_CH_OFFSET_POLARITY, goffs < 0);
89 }
90 EXPORT_SYMBOL_NS_GPL(ad3552r_calc_custom_gain, "IIO_AD3552R");
91
ad3552r_get_custom_range(struct ad3552r_ch_data * ch_data,s32 * v_min,s32 * v_max)92 static void ad3552r_get_custom_range(struct ad3552r_ch_data *ch_data,
93 s32 *v_min, s32 *v_max)
94 {
95 s64 vref, tmp, common, offset, gn, gp;
96 /*
97 * From datasheet formula (In Volts):
98 * Vmin = 2.5 + [(GainN + Offset / 1024) * 2.5 * Rfb * 1.03]
99 * Vmax = 2.5 - [(GainP + Offset / 1024) * 2.5 * Rfb * 1.03]
100 * Calculus are converted to milivolts
101 */
102 vref = 2500;
103 /* 2.5 * 1.03 * 1000 (To mV) */
104 common = 2575 * ch_data->rfb;
105 offset = ch_data->gain_offset;
106
107 gn = gains_scaling_table[ch_data->n];
108 tmp = (1024 * gn + AD3552R_GAIN_SCALE * offset) * common;
109 tmp = div_s64(tmp, 1024 * AD3552R_GAIN_SCALE);
110 *v_max = vref + tmp;
111
112 gp = gains_scaling_table[ch_data->p];
113 tmp = (1024 * gp - AD3552R_GAIN_SCALE * offset) * common;
114 tmp = div_s64(tmp, 1024 * AD3552R_GAIN_SCALE);
115 *v_min = vref - tmp;
116 }
117
ad3552r_calc_gain_and_offset(struct ad3552r_ch_data * ch_data,const struct ad3552r_model_data * model_data)118 void ad3552r_calc_gain_and_offset(struct ad3552r_ch_data *ch_data,
119 const struct ad3552r_model_data *model_data)
120 {
121 s32 idx, v_max, v_min, span, rem;
122 s64 tmp;
123
124 if (ch_data->range_override) {
125 ad3552r_get_custom_range(ch_data, &v_min, &v_max);
126 } else {
127 /* Normal range */
128 idx = ch_data->range;
129 v_min = model_data->ranges_table[idx][0];
130 v_max = model_data->ranges_table[idx][1];
131 }
132
133 /*
134 * From datasheet formula:
135 * Vout = Span * (D / 65536) + Vmin
136 * Converted to scale and offset:
137 * Scale = Span / 65536
138 * Offset = 65536 * Vmin / Span
139 *
140 * Reminders are in micros in order to be printed as
141 * IIO_VAL_INT_PLUS_MICRO
142 */
143 span = v_max - v_min;
144 ch_data->scale_int = div_s64_rem(span, 65536, &rem);
145 /* Do operations in microvolts */
146 ch_data->scale_dec = DIV_ROUND_CLOSEST((s64)rem * 1000000, 65536);
147
148 ch_data->offset_int = div_s64_rem(v_min * 65536, span, &rem);
149 tmp = (s64)rem * 1000000;
150 ch_data->offset_dec = div_s64(tmp, span);
151 }
152 EXPORT_SYMBOL_NS_GPL(ad3552r_calc_gain_and_offset, "IIO_AD3552R");
153
ad3552r_get_ref_voltage(struct device * dev,u32 * val)154 int ad3552r_get_ref_voltage(struct device *dev, u32 *val)
155 {
156 int voltage;
157 int delta = 100000;
158
159 voltage = devm_regulator_get_enable_read_voltage(dev, "vref");
160 if (voltage < 0 && voltage != -ENODEV)
161 return dev_err_probe(dev, voltage,
162 "Error getting vref voltage\n");
163
164 if (voltage == -ENODEV) {
165 if (device_property_read_bool(dev, "adi,vref-out-en"))
166 *val = AD3552R_INTERNAL_VREF_PIN_2P5V;
167 else
168 *val = AD3552R_INTERNAL_VREF_PIN_FLOATING;
169
170 return 0;
171 }
172
173 if (voltage > 2500000 + delta || voltage < 2500000 - delta) {
174 dev_warn(dev, "vref-supply must be 2.5V");
175 return -EINVAL;
176 }
177
178 *val = AD3552R_EXTERNAL_VREF_PIN_INPUT;
179
180 return 0;
181 }
182 EXPORT_SYMBOL_NS_GPL(ad3552r_get_ref_voltage, "IIO_AD3552R");
183
ad3552r_get_drive_strength(struct device * dev,u32 * val)184 int ad3552r_get_drive_strength(struct device *dev, u32 *val)
185 {
186 int err;
187 u32 drive_strength;
188
189 err = device_property_read_u32(dev, "adi,sdo-drive-strength",
190 &drive_strength);
191 if (err)
192 return err;
193
194 if (drive_strength > 3) {
195 dev_err_probe(dev, -EINVAL,
196 "adi,sdo-drive-strength must be less than 4\n");
197 return -EINVAL;
198 }
199
200 *val = drive_strength;
201
202 return 0;
203 }
204 EXPORT_SYMBOL_NS_GPL(ad3552r_get_drive_strength, "IIO_AD3552R");
205
ad3552r_get_custom_gain(struct device * dev,struct fwnode_handle * child,u8 * gs_p,u8 * gs_n,u16 * rfb,s16 * goffs)206 int ad3552r_get_custom_gain(struct device *dev, struct fwnode_handle *child,
207 u8 *gs_p, u8 *gs_n, u16 *rfb, s16 *goffs)
208 {
209 int err;
210 u32 val;
211 struct fwnode_handle *gain_child __free(fwnode_handle) =
212 fwnode_get_named_child_node(child,
213 "custom-output-range-config");
214
215 if (!gain_child)
216 return dev_err_probe(dev, -EINVAL,
217 "custom-output-range-config mandatory\n");
218
219 err = fwnode_property_read_u32(gain_child, "adi,gain-scaling-p", &val);
220 if (err)
221 return dev_err_probe(dev, err,
222 "adi,gain-scaling-p mandatory\n");
223 *gs_p = val;
224
225 err = fwnode_property_read_u32(gain_child, "adi,gain-scaling-n", &val);
226 if (err)
227 return dev_err_probe(dev, err,
228 "adi,gain-scaling-n property mandatory\n");
229 *gs_n = val;
230
231 err = fwnode_property_read_u32(gain_child, "adi,rfb-ohms", &val);
232 if (err)
233 return dev_err_probe(dev, err,
234 "adi,rfb-ohms mandatory\n");
235 *rfb = val;
236
237 err = fwnode_property_read_u32(gain_child, "adi,gain-offset", &val);
238 if (err)
239 return dev_err_probe(dev, err,
240 "adi,gain-offset mandatory\n");
241 *goffs = val;
242
243 return 0;
244 }
245 EXPORT_SYMBOL_NS_GPL(ad3552r_get_custom_gain, "IIO_AD3552R");
246
ad3552r_find_range(const struct ad3552r_model_data * model_info,s32 * vals)247 static int ad3552r_find_range(const struct ad3552r_model_data *model_info,
248 s32 *vals)
249 {
250 int i;
251
252 for (i = 0; i < model_info->num_ranges; i++)
253 if (vals[0] == model_info->ranges_table[i][0] * 1000 &&
254 vals[1] == model_info->ranges_table[i][1] * 1000)
255 return i;
256
257 return -EINVAL;
258 }
259
ad3552r_get_output_range(struct device * dev,const struct ad3552r_model_data * model_info,struct fwnode_handle * child,u32 * val)260 int ad3552r_get_output_range(struct device *dev,
261 const struct ad3552r_model_data *model_info,
262 struct fwnode_handle *child, u32 *val)
263 {
264 int ret;
265 s32 vals[2];
266
267 /* This property is optional, so returning -ENOENT if missing */
268 if (!fwnode_property_present(child, "adi,output-range-microvolt"))
269 return -ENOENT;
270
271 ret = fwnode_property_read_u32_array(child,
272 "adi,output-range-microvolt",
273 vals, 2);
274 if (ret)
275 return dev_err_probe(dev, ret,
276 "invalid adi,output-range-microvolt\n");
277
278 ret = ad3552r_find_range(model_info, vals);
279 if (ret < 0)
280 return dev_err_probe(dev, ret,
281 "invalid adi,output-range-microvolt value\n");
282
283 *val = ret;
284
285 return 0;
286 }
287 EXPORT_SYMBOL_NS_GPL(ad3552r_get_output_range, "IIO_AD3552R");
288
289 MODULE_DESCRIPTION("ad3552r common functions");
290 MODULE_LICENSE("GPL");
291