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