drivers/iio/adc/hx711.c

   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 <[email protected]>
   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 <[email protected]>");
 571 MODULE_DESCRIPTION("HX711 bitbanging driver - ADC for weight cells");
 572 MODULE_LICENSE("GPL");
 573 MODULE_ALIAS("platform:hx711-gpio");
 574