1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * HX711: analog to digital converter for weight sensor module |
4 | * |
5 | * Copyright (c) 2016 Andreas Klinger <ak@it-klinger.de> |
6 | */ |
7 | #include <linux/err.h> |
8 | #include <linux/kernel.h> |
9 | #include <linux/module.h> |
10 | #include <linux/of.h> |
11 | #include <linux/platform_device.h> |
12 | #include <linux/property.h> |
13 | #include <linux/slab.h> |
14 | #include <linux/sched.h> |
15 | #include <linux/delay.h> |
16 | #include <linux/iio/iio.h> |
17 | #include <linux/iio/sysfs.h> |
18 | #include <linux/iio/buffer.h> |
19 | #include <linux/iio/trigger_consumer.h> |
20 | #include <linux/iio/triggered_buffer.h> |
21 | #include <linux/gpio/consumer.h> |
22 | #include <linux/regulator/consumer.h> |
23 | |
24 | /* gain to pulse and scale conversion */ |
25 | #define HX711_GAIN_MAX 3 |
26 | #define HX711_RESET_GAIN 128 |
27 | |
28 | struct hx711_gain_to_scale { |
29 | int gain; |
30 | int gain_pulse; |
31 | int scale; |
32 | int channel; |
33 | }; |
34 | |
35 | /* |
36 | * .scale depends on AVDD which in turn is known as soon as the regulator |
37 | * is available |
38 | * therefore we set .scale in hx711_probe() |
39 | * |
40 | * channel A in documentation is channel 0 in source code |
41 | * channel B in documentation is channel 1 in source code |
42 | */ |
43 | static struct hx711_gain_to_scale hx711_gain_to_scale[HX711_GAIN_MAX] = { |
44 | { 128, 1, 0, 0 }, |
45 | { 32, 2, 0, 1 }, |
46 | { 64, 3, 0, 0 } |
47 | }; |
48 | |
49 | static int hx711_get_gain_to_pulse(int gain) |
50 | { |
51 | int i; |
52 | |
53 | for (i = 0; i < HX711_GAIN_MAX; i++) |
54 | if (hx711_gain_to_scale[i].gain == gain) |
55 | return hx711_gain_to_scale[i].gain_pulse; |
56 | return 1; |
57 | } |
58 | |
59 | static int hx711_get_gain_to_scale(int gain) |
60 | { |
61 | int i; |
62 | |
63 | for (i = 0; i < HX711_GAIN_MAX; i++) |
64 | if (hx711_gain_to_scale[i].gain == gain) |
65 | return hx711_gain_to_scale[i].scale; |
66 | return 0; |
67 | } |
68 | |
69 | static int hx711_get_scale_to_gain(int scale) |
70 | { |
71 | int i; |
72 | |
73 | for (i = 0; i < HX711_GAIN_MAX; i++) |
74 | if (hx711_gain_to_scale[i].scale == scale) |
75 | return hx711_gain_to_scale[i].gain; |
76 | return -EINVAL; |
77 | } |
78 | |
79 | struct hx711_data { |
80 | struct device *dev; |
81 | struct gpio_desc *gpiod_pd_sck; |
82 | struct gpio_desc *gpiod_dout; |
83 | struct regulator *reg_avdd; |
84 | int gain_set; /* gain set on device */ |
85 | int gain_chan_a; /* gain for channel A */ |
86 | struct mutex lock; |
87 | /* |
88 | * triggered buffer |
89 | * 2x32-bit channel + 64-bit naturally aligned timestamp |
90 | */ |
91 | u32 buffer[4] __aligned(8); |
92 | /* |
93 | * delay after a rising edge on SCK until the data is ready DOUT |
94 | * this is dependent on the hx711 where the datasheet tells a |
95 | * maximum value of 100 ns |
96 | * but also on potential parasitic capacities on the wiring |
97 | */ |
98 | u32 data_ready_delay_ns; |
99 | u32 clock_frequency; |
100 | }; |
101 | |
102 | static int hx711_cycle(struct hx711_data *hx711_data) |
103 | { |
104 | unsigned long flags; |
105 | |
106 | /* |
107 | * if preempted for more then 60us while PD_SCK is high: |
108 | * hx711 is going in reset |
109 | * ==> measuring is false |
110 | */ |
111 | local_irq_save(flags); |
112 | gpiod_set_value(desc: hx711_data->gpiod_pd_sck, value: 1); |
113 | |
114 | /* |
115 | * wait until DOUT is ready |
116 | * it turned out that parasitic capacities are extending the time |
117 | * until DOUT has reached it's value |
118 | */ |
119 | ndelay(hx711_data->data_ready_delay_ns); |
120 | |
121 | /* |
122 | * here we are not waiting for 0.2 us as suggested by the datasheet, |
123 | * because the oscilloscope showed in a test scenario |
124 | * at least 1.15 us for PD_SCK high (T3 in datasheet) |
125 | * and 0.56 us for PD_SCK low on TI Sitara with 800 MHz |
126 | */ |
127 | gpiod_set_value(desc: hx711_data->gpiod_pd_sck, value: 0); |
128 | local_irq_restore(flags); |
129 | |
130 | /* |
131 | * make it a square wave for addressing cases with capacitance on |
132 | * PC_SCK |
133 | */ |
134 | ndelay(hx711_data->data_ready_delay_ns); |
135 | |
136 | /* sample as late as possible */ |
137 | return gpiod_get_value(desc: hx711_data->gpiod_dout); |
138 | } |
139 | |
140 | static int hx711_read(struct hx711_data *hx711_data) |
141 | { |
142 | int i, ret; |
143 | int value = 0; |
144 | int val = gpiod_get_value(desc: hx711_data->gpiod_dout); |
145 | |
146 | /* we double check if it's really down */ |
147 | if (val) |
148 | return -EIO; |
149 | |
150 | for (i = 0; i < 24; i++) { |
151 | value <<= 1; |
152 | ret = hx711_cycle(hx711_data); |
153 | if (ret) |
154 | value++; |
155 | } |
156 | |
157 | value ^= 0x800000; |
158 | |
159 | for (i = 0; i < hx711_get_gain_to_pulse(gain: hx711_data->gain_set); i++) |
160 | hx711_cycle(hx711_data); |
161 | |
162 | return value; |
163 | } |
164 | |
165 | static int hx711_wait_for_ready(struct hx711_data *hx711_data) |
166 | { |
167 | int i, val; |
168 | |
169 | /* |
170 | * in some rare cases the reset takes quite a long time |
171 | * especially when the channel is changed. |
172 | * Allow up to one second for it |
173 | */ |
174 | for (i = 0; i < 100; i++) { |
175 | val = gpiod_get_value(desc: hx711_data->gpiod_dout); |
176 | if (!val) |
177 | break; |
178 | /* sleep at least 10 ms */ |
179 | msleep(msecs: 10); |
180 | } |
181 | if (val) |
182 | return -EIO; |
183 | |
184 | return 0; |
185 | } |
186 | |
187 | static int hx711_reset(struct hx711_data *hx711_data) |
188 | { |
189 | int val = hx711_wait_for_ready(hx711_data); |
190 | |
191 | if (val) { |
192 | /* |
193 | * an examination with the oszilloscope indicated |
194 | * that the first value read after the reset is not stable |
195 | * if we reset too short; |
196 | * the shorter the reset cycle |
197 | * the less reliable the first value after reset is; |
198 | * there were no problems encountered with a value |
199 | * of 10 ms or higher |
200 | */ |
201 | gpiod_set_value(desc: hx711_data->gpiod_pd_sck, value: 1); |
202 | msleep(msecs: 10); |
203 | gpiod_set_value(desc: hx711_data->gpiod_pd_sck, value: 0); |
204 | |
205 | val = hx711_wait_for_ready(hx711_data); |
206 | |
207 | /* after a reset the gain is 128 */ |
208 | hx711_data->gain_set = HX711_RESET_GAIN; |
209 | } |
210 | |
211 | return val; |
212 | } |
213 | |
214 | static int hx711_set_gain_for_channel(struct hx711_data *hx711_data, int chan) |
215 | { |
216 | int ret; |
217 | |
218 | if (chan == 0) { |
219 | if (hx711_data->gain_set == 32) { |
220 | hx711_data->gain_set = hx711_data->gain_chan_a; |
221 | |
222 | ret = hx711_read(hx711_data); |
223 | if (ret < 0) |
224 | return ret; |
225 | |
226 | ret = hx711_wait_for_ready(hx711_data); |
227 | if (ret) |
228 | return ret; |
229 | } |
230 | } else { |
231 | if (hx711_data->gain_set != 32) { |
232 | hx711_data->gain_set = 32; |
233 | |
234 | ret = hx711_read(hx711_data); |
235 | if (ret < 0) |
236 | return ret; |
237 | |
238 | ret = hx711_wait_for_ready(hx711_data); |
239 | if (ret) |
240 | return ret; |
241 | } |
242 | } |
243 | |
244 | return 0; |
245 | } |
246 | |
247 | static int hx711_reset_read(struct hx711_data *hx711_data, int chan) |
248 | { |
249 | int ret; |
250 | int val; |
251 | |
252 | /* |
253 | * hx711_reset() must be called from here |
254 | * because it could be calling hx711_read() by itself |
255 | */ |
256 | if (hx711_reset(hx711_data)) { |
257 | dev_err(hx711_data->dev, "reset failed!" ); |
258 | return -EIO; |
259 | } |
260 | |
261 | ret = hx711_set_gain_for_channel(hx711_data, chan); |
262 | if (ret < 0) |
263 | return ret; |
264 | |
265 | val = hx711_read(hx711_data); |
266 | |
267 | return val; |
268 | } |
269 | |
270 | static int hx711_read_raw(struct iio_dev *indio_dev, |
271 | const struct iio_chan_spec *chan, |
272 | int *val, int *val2, long mask) |
273 | { |
274 | struct hx711_data *hx711_data = iio_priv(indio_dev); |
275 | |
276 | switch (mask) { |
277 | case IIO_CHAN_INFO_RAW: |
278 | mutex_lock(&hx711_data->lock); |
279 | |
280 | *val = hx711_reset_read(hx711_data, chan: chan->channel); |
281 | |
282 | mutex_unlock(lock: &hx711_data->lock); |
283 | |
284 | if (*val < 0) |
285 | return *val; |
286 | return IIO_VAL_INT; |
287 | case IIO_CHAN_INFO_SCALE: |
288 | *val = 0; |
289 | mutex_lock(&hx711_data->lock); |
290 | |
291 | *val2 = hx711_get_gain_to_scale(gain: hx711_data->gain_set); |
292 | |
293 | mutex_unlock(lock: &hx711_data->lock); |
294 | |
295 | return IIO_VAL_INT_PLUS_NANO; |
296 | default: |
297 | return -EINVAL; |
298 | } |
299 | } |
300 | |
301 | static int hx711_write_raw(struct iio_dev *indio_dev, |
302 | struct iio_chan_spec const *chan, |
303 | int val, |
304 | int val2, |
305 | long mask) |
306 | { |
307 | struct hx711_data *hx711_data = iio_priv(indio_dev); |
308 | int ret; |
309 | int gain; |
310 | |
311 | switch (mask) { |
312 | case IIO_CHAN_INFO_SCALE: |
313 | /* |
314 | * a scale greater than 1 mV per LSB is not possible |
315 | * with the HX711, therefore val must be 0 |
316 | */ |
317 | if (val != 0) |
318 | return -EINVAL; |
319 | |
320 | mutex_lock(&hx711_data->lock); |
321 | |
322 | gain = hx711_get_scale_to_gain(scale: val2); |
323 | if (gain < 0) { |
324 | mutex_unlock(lock: &hx711_data->lock); |
325 | return gain; |
326 | } |
327 | |
328 | if (gain != hx711_data->gain_set) { |
329 | hx711_data->gain_set = gain; |
330 | if (gain != 32) |
331 | hx711_data->gain_chan_a = gain; |
332 | |
333 | ret = hx711_read(hx711_data); |
334 | if (ret < 0) { |
335 | mutex_unlock(lock: &hx711_data->lock); |
336 | return ret; |
337 | } |
338 | } |
339 | |
340 | mutex_unlock(lock: &hx711_data->lock); |
341 | return 0; |
342 | default: |
343 | return -EINVAL; |
344 | } |
345 | |
346 | return 0; |
347 | } |
348 | |
349 | static int hx711_write_raw_get_fmt(struct iio_dev *indio_dev, |
350 | struct iio_chan_spec const *chan, |
351 | long mask) |
352 | { |
353 | return IIO_VAL_INT_PLUS_NANO; |
354 | } |
355 | |
356 | static irqreturn_t hx711_trigger(int irq, void *p) |
357 | { |
358 | struct iio_poll_func *pf = p; |
359 | struct iio_dev *indio_dev = pf->indio_dev; |
360 | struct hx711_data *hx711_data = iio_priv(indio_dev); |
361 | int i, j = 0; |
362 | |
363 | mutex_lock(&hx711_data->lock); |
364 | |
365 | memset(hx711_data->buffer, 0, sizeof(hx711_data->buffer)); |
366 | |
367 | for (i = 0; i < indio_dev->masklength; i++) { |
368 | if (!test_bit(i, indio_dev->active_scan_mask)) |
369 | continue; |
370 | |
371 | hx711_data->buffer[j] = hx711_reset_read(hx711_data, |
372 | chan: indio_dev->channels[i].channel); |
373 | j++; |
374 | } |
375 | |
376 | iio_push_to_buffers_with_timestamp(indio_dev, data: hx711_data->buffer, |
377 | timestamp: pf->timestamp); |
378 | |
379 | mutex_unlock(lock: &hx711_data->lock); |
380 | |
381 | iio_trigger_notify_done(trig: indio_dev->trig); |
382 | |
383 | return IRQ_HANDLED; |
384 | } |
385 | |
386 | static ssize_t hx711_scale_available_show(struct device *dev, |
387 | struct device_attribute *attr, |
388 | char *buf) |
389 | { |
390 | struct iio_dev_attr *iio_attr = to_iio_dev_attr(attr); |
391 | int channel = iio_attr->address; |
392 | int i, len = 0; |
393 | |
394 | for (i = 0; i < HX711_GAIN_MAX; i++) |
395 | if (hx711_gain_to_scale[i].channel == channel) |
396 | len += sprintf(buf: buf + len, fmt: "0.%09d " , |
397 | hx711_gain_to_scale[i].scale); |
398 | |
399 | len += sprintf(buf: buf + len, fmt: "\n" ); |
400 | |
401 | return len; |
402 | } |
403 | |
404 | static IIO_DEVICE_ATTR(in_voltage0_scale_available, S_IRUGO, |
405 | hx711_scale_available_show, NULL, 0); |
406 | |
407 | static IIO_DEVICE_ATTR(in_voltage1_scale_available, S_IRUGO, |
408 | hx711_scale_available_show, NULL, 1); |
409 | |
410 | static struct attribute *hx711_attributes[] = { |
411 | &iio_dev_attr_in_voltage0_scale_available.dev_attr.attr, |
412 | &iio_dev_attr_in_voltage1_scale_available.dev_attr.attr, |
413 | NULL, |
414 | }; |
415 | |
416 | static const struct attribute_group hx711_attribute_group = { |
417 | .attrs = hx711_attributes, |
418 | }; |
419 | |
420 | static const struct iio_info hx711_iio_info = { |
421 | .read_raw = hx711_read_raw, |
422 | .write_raw = hx711_write_raw, |
423 | .write_raw_get_fmt = hx711_write_raw_get_fmt, |
424 | .attrs = &hx711_attribute_group, |
425 | }; |
426 | |
427 | static const struct iio_chan_spec hx711_chan_spec[] = { |
428 | { |
429 | .type = IIO_VOLTAGE, |
430 | .channel = 0, |
431 | .indexed = 1, |
432 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
433 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), |
434 | .scan_index = 0, |
435 | .scan_type = { |
436 | .sign = 'u', |
437 | .realbits = 24, |
438 | .storagebits = 32, |
439 | .endianness = IIO_CPU, |
440 | }, |
441 | }, |
442 | { |
443 | .type = IIO_VOLTAGE, |
444 | .channel = 1, |
445 | .indexed = 1, |
446 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
447 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), |
448 | .scan_index = 1, |
449 | .scan_type = { |
450 | .sign = 'u', |
451 | .realbits = 24, |
452 | .storagebits = 32, |
453 | .endianness = IIO_CPU, |
454 | }, |
455 | }, |
456 | IIO_CHAN_SOFT_TIMESTAMP(2), |
457 | }; |
458 | |
459 | static int hx711_probe(struct platform_device *pdev) |
460 | { |
461 | struct device *dev = &pdev->dev; |
462 | struct device_node *np = dev->of_node; |
463 | struct hx711_data *hx711_data; |
464 | struct iio_dev *indio_dev; |
465 | int ret; |
466 | int i; |
467 | |
468 | indio_dev = devm_iio_device_alloc(parent: dev, sizeof_priv: sizeof(struct hx711_data)); |
469 | if (!indio_dev) { |
470 | dev_err(dev, "failed to allocate IIO device\n" ); |
471 | return -ENOMEM; |
472 | } |
473 | |
474 | hx711_data = iio_priv(indio_dev); |
475 | hx711_data->dev = dev; |
476 | |
477 | mutex_init(&hx711_data->lock); |
478 | |
479 | /* |
480 | * PD_SCK stands for power down and serial clock input of HX711 |
481 | * in the driver it is an output |
482 | */ |
483 | hx711_data->gpiod_pd_sck = devm_gpiod_get(dev, con_id: "sck" , flags: GPIOD_OUT_LOW); |
484 | if (IS_ERR(ptr: hx711_data->gpiod_pd_sck)) { |
485 | dev_err(dev, "failed to get sck-gpiod: err=%ld\n" , |
486 | PTR_ERR(hx711_data->gpiod_pd_sck)); |
487 | return PTR_ERR(ptr: hx711_data->gpiod_pd_sck); |
488 | } |
489 | |
490 | /* |
491 | * DOUT stands for serial data output of HX711 |
492 | * for the driver it is an input |
493 | */ |
494 | hx711_data->gpiod_dout = devm_gpiod_get(dev, con_id: "dout" , flags: GPIOD_IN); |
495 | if (IS_ERR(ptr: hx711_data->gpiod_dout)) { |
496 | dev_err(dev, "failed to get dout-gpiod: err=%ld\n" , |
497 | PTR_ERR(hx711_data->gpiod_dout)); |
498 | return PTR_ERR(ptr: hx711_data->gpiod_dout); |
499 | } |
500 | |
501 | hx711_data->reg_avdd = devm_regulator_get(dev, id: "avdd" ); |
502 | if (IS_ERR(ptr: hx711_data->reg_avdd)) |
503 | return PTR_ERR(ptr: hx711_data->reg_avdd); |
504 | |
505 | ret = regulator_enable(regulator: hx711_data->reg_avdd); |
506 | if (ret < 0) |
507 | return ret; |
508 | |
509 | /* |
510 | * with |
511 | * full scale differential input range: AVDD / GAIN |
512 | * full scale output data: 2^24 |
513 | * we can say: |
514 | * AVDD / GAIN = 2^24 |
515 | * therefore: |
516 | * 1 LSB = AVDD / GAIN / 2^24 |
517 | * AVDD is in uV, but we need 10^-9 mV |
518 | * approximately to fit into a 32 bit number: |
519 | * 1 LSB = (AVDD * 100) / GAIN / 1678 [10^-9 mV] |
520 | */ |
521 | ret = regulator_get_voltage(regulator: hx711_data->reg_avdd); |
522 | if (ret < 0) |
523 | goto error_regulator; |
524 | |
525 | /* we need 10^-9 mV */ |
526 | ret *= 100; |
527 | |
528 | for (i = 0; i < HX711_GAIN_MAX; i++) |
529 | hx711_gain_to_scale[i].scale = |
530 | ret / hx711_gain_to_scale[i].gain / 1678; |
531 | |
532 | hx711_data->gain_set = 128; |
533 | hx711_data->gain_chan_a = 128; |
534 | |
535 | hx711_data->clock_frequency = 400000; |
536 | ret = of_property_read_u32(np, propname: "clock-frequency" , |
537 | out_value: &hx711_data->clock_frequency); |
538 | |
539 | /* |
540 | * datasheet says the high level of PD_SCK has a maximum duration |
541 | * of 50 microseconds |
542 | */ |
543 | if (hx711_data->clock_frequency < 20000) { |
544 | dev_warn(dev, "clock-frequency too low - assuming 400 kHz\n" ); |
545 | hx711_data->clock_frequency = 400000; |
546 | } |
547 | |
548 | hx711_data->data_ready_delay_ns = |
549 | 1000000000 / hx711_data->clock_frequency; |
550 | |
551 | platform_set_drvdata(pdev, data: indio_dev); |
552 | |
553 | indio_dev->name = "hx711" ; |
554 | indio_dev->info = &hx711_iio_info; |
555 | indio_dev->modes = INDIO_DIRECT_MODE; |
556 | indio_dev->channels = hx711_chan_spec; |
557 | indio_dev->num_channels = ARRAY_SIZE(hx711_chan_spec); |
558 | |
559 | ret = iio_triggered_buffer_setup(indio_dev, iio_pollfunc_store_time, |
560 | hx711_trigger, NULL); |
561 | if (ret < 0) { |
562 | dev_err(dev, "setup of iio triggered buffer failed\n" ); |
563 | goto error_regulator; |
564 | } |
565 | |
566 | ret = iio_device_register(indio_dev); |
567 | if (ret < 0) { |
568 | dev_err(dev, "Couldn't register the device\n" ); |
569 | goto error_buffer; |
570 | } |
571 | |
572 | return 0; |
573 | |
574 | error_buffer: |
575 | iio_triggered_buffer_cleanup(indio_dev); |
576 | |
577 | error_regulator: |
578 | regulator_disable(regulator: hx711_data->reg_avdd); |
579 | |
580 | return ret; |
581 | } |
582 | |
583 | static void hx711_remove(struct platform_device *pdev) |
584 | { |
585 | struct hx711_data *hx711_data; |
586 | struct iio_dev *indio_dev; |
587 | |
588 | indio_dev = platform_get_drvdata(pdev); |
589 | hx711_data = iio_priv(indio_dev); |
590 | |
591 | iio_device_unregister(indio_dev); |
592 | |
593 | iio_triggered_buffer_cleanup(indio_dev); |
594 | |
595 | regulator_disable(regulator: hx711_data->reg_avdd); |
596 | } |
597 | |
598 | static const struct of_device_id of_hx711_match[] = { |
599 | { .compatible = "avia,hx711" , }, |
600 | {}, |
601 | }; |
602 | |
603 | MODULE_DEVICE_TABLE(of, of_hx711_match); |
604 | |
605 | static struct platform_driver hx711_driver = { |
606 | .probe = hx711_probe, |
607 | .remove_new = hx711_remove, |
608 | .driver = { |
609 | .name = "hx711-gpio" , |
610 | .of_match_table = of_hx711_match, |
611 | }, |
612 | }; |
613 | |
614 | module_platform_driver(hx711_driver); |
615 | |
616 | MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>" ); |
617 | MODULE_DESCRIPTION("HX711 bitbanging driver - ADC for weight cells" ); |
618 | MODULE_LICENSE("GPL" ); |
619 | MODULE_ALIAS("platform:hx711-gpio" ); |
620 | |
621 | |