drivers/iio/adc/hx711.c

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