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/gpio/consumer.h> 28 #include <linux/regulator/consumer.h> 29 30 /* gain to pulse and scale conversion */ 31 #define HX711_GAIN_MAX 3 32 33 struct hx711_gain_to_scale { 34 int gain; 35 int gain_pulse; 36 int scale; 37 int channel; 38 }; 39 40 /* 41 * .scale depends on AVDD which in turn is known as soon as the regulator 42 * is available 43 * therefore we set .scale in hx711_probe() 44 * 45 * channel A in documentation is channel 0 in source code 46 * channel B in documentation is channel 1 in source code 47 */ 48 static struct hx711_gain_to_scale hx711_gain_to_scale[HX711_GAIN_MAX] = { 49 { 128, 1, 0, 0 }, 50 { 32, 2, 0, 1 }, 51 { 64, 3, 0, 0 } 52 }; 53 54 static int hx711_get_gain_to_pulse(int gain) 55 { 56 int i; 57 58 for (i = 0; i < HX711_GAIN_MAX; i++) 59 if (hx711_gain_to_scale[i].gain == gain) 60 return hx711_gain_to_scale[i].gain_pulse; 61 return 1; 62 } 63 64 static int hx711_get_gain_to_scale(int gain) 65 { 66 int i; 67 68 for (i = 0; i < HX711_GAIN_MAX; i++) 69 if (hx711_gain_to_scale[i].gain == gain) 70 return hx711_gain_to_scale[i].scale; 71 return 0; 72 } 73 74 static int hx711_get_scale_to_gain(int scale) 75 { 76 int i; 77 78 for (i = 0; i < HX711_GAIN_MAX; i++) 79 if (hx711_gain_to_scale[i].scale == scale) 80 return hx711_gain_to_scale[i].gain; 81 return -EINVAL; 82 } 83 84 struct hx711_data { 85 struct device *dev; 86 struct gpio_desc *gpiod_pd_sck; 87 struct gpio_desc *gpiod_dout; 88 struct regulator *reg_avdd; 89 int gain_set; /* gain set on device */ 90 int gain_chan_a; /* gain for channel A */ 91 struct mutex lock; 92 }; 93 94 static int hx711_cycle(struct hx711_data *hx711_data) 95 { 96 int val; 97 98 /* 99 * if preempted for more then 60us while PD_SCK is high: 100 * hx711 is going in reset 101 * ==> measuring is false 102 */ 103 preempt_disable(); 104 gpiod_set_value(hx711_data->gpiod_pd_sck, 1); 105 val = gpiod_get_value(hx711_data->gpiod_dout); 106 /* 107 * here we are not waiting for 0.2 us as suggested by the datasheet, 108 * because the oscilloscope showed in a test scenario 109 * at least 1.15 us for PD_SCK high (T3 in datasheet) 110 * and 0.56 us for PD_SCK low on TI Sitara with 800 MHz 111 */ 112 gpiod_set_value(hx711_data->gpiod_pd_sck, 0); 113 preempt_enable(); 114 115 return val; 116 } 117 118 static int hx711_read(struct hx711_data *hx711_data) 119 { 120 int i, ret; 121 int value = 0; 122 int val = gpiod_get_value(hx711_data->gpiod_dout); 123 124 /* we double check if it's really down */ 125 if (val) 126 return -EIO; 127 128 for (i = 0; i < 24; i++) { 129 value <<= 1; 130 ret = hx711_cycle(hx711_data); 131 if (ret) 132 value++; 133 } 134 135 value ^= 0x800000; 136 137 for (i = 0; i < hx711_get_gain_to_pulse(hx711_data->gain_set); i++) 138 hx711_cycle(hx711_data); 139 140 return value; 141 } 142 143 static int hx711_wait_for_ready(struct hx711_data *hx711_data) 144 { 145 int i, val; 146 147 /* 148 * a maximum reset cycle time of 56 ms was measured. 149 * we round it up to 100 ms 150 */ 151 for (i = 0; i < 100; i++) { 152 val = gpiod_get_value(hx711_data->gpiod_dout); 153 if (!val) 154 break; 155 /* sleep at least 1 ms */ 156 msleep(1); 157 } 158 if (val) 159 return -EIO; 160 161 return 0; 162 } 163 164 static int hx711_reset(struct hx711_data *hx711_data) 165 { 166 int ret; 167 int val = gpiod_get_value(hx711_data->gpiod_dout); 168 169 if (val) { 170 /* 171 * an examination with the oszilloscope indicated 172 * that the first value read after the reset is not stable 173 * if we reset too short; 174 * the shorter the reset cycle 175 * the less reliable the first value after reset is; 176 * there were no problems encountered with a value 177 * of 10 ms or higher 178 */ 179 gpiod_set_value(hx711_data->gpiod_pd_sck, 1); 180 msleep(10); 181 gpiod_set_value(hx711_data->gpiod_pd_sck, 0); 182 183 ret = hx711_wait_for_ready(hx711_data); 184 if (ret) 185 return ret; 186 /* 187 * after a reset the gain is 128 so we do a dummy read 188 * to set the gain for the next read 189 */ 190 ret = hx711_read(hx711_data); 191 if (ret < 0) 192 return ret; 193 194 /* 195 * after a dummy read we need to wait vor readiness 196 * for not mixing gain pulses with the clock 197 */ 198 ret = hx711_wait_for_ready(hx711_data); 199 if (ret) 200 return ret; 201 } 202 203 return val; 204 } 205 206 static int hx711_set_gain_for_channel(struct hx711_data *hx711_data, int chan) 207 { 208 int ret; 209 210 if (chan == 0) { 211 if (hx711_data->gain_set == 32) { 212 hx711_data->gain_set = hx711_data->gain_chan_a; 213 214 ret = hx711_read(hx711_data); 215 if (ret < 0) 216 return ret; 217 218 ret = hx711_wait_for_ready(hx711_data); 219 if (ret) 220 return ret; 221 } 222 } else { 223 if (hx711_data->gain_set != 32) { 224 hx711_data->gain_set = 32; 225 226 ret = hx711_read(hx711_data); 227 if (ret < 0) 228 return ret; 229 230 ret = hx711_wait_for_ready(hx711_data); 231 if (ret) 232 return ret; 233 } 234 } 235 236 return 0; 237 } 238 239 static int hx711_read_raw(struct iio_dev *indio_dev, 240 const struct iio_chan_spec *chan, 241 int *val, int *val2, long mask) 242 { 243 struct hx711_data *hx711_data = iio_priv(indio_dev); 244 int ret; 245 246 switch (mask) { 247 case IIO_CHAN_INFO_RAW: 248 mutex_lock(&hx711_data->lock); 249 250 /* 251 * hx711_reset() must be called from here 252 * because it could be calling hx711_read() by itself 253 */ 254 if (hx711_reset(hx711_data)) { 255 mutex_unlock(&hx711_data->lock); 256 dev_err(hx711_data->dev, "reset failed!"); 257 return -EIO; 258 } 259 260 ret = hx711_set_gain_for_channel(hx711_data, chan->channel); 261 if (ret < 0) { 262 mutex_unlock(&hx711_data->lock); 263 return ret; 264 } 265 266 *val = hx711_read(hx711_data); 267 268 mutex_unlock(&hx711_data->lock); 269 270 if (*val < 0) 271 return *val; 272 return IIO_VAL_INT; 273 case IIO_CHAN_INFO_SCALE: 274 *val = 0; 275 mutex_lock(&hx711_data->lock); 276 277 *val2 = hx711_get_gain_to_scale(hx711_data->gain_set); 278 279 mutex_unlock(&hx711_data->lock); 280 281 return IIO_VAL_INT_PLUS_NANO; 282 default: 283 return -EINVAL; 284 } 285 } 286 287 static int hx711_write_raw(struct iio_dev *indio_dev, 288 struct iio_chan_spec const *chan, 289 int val, 290 int val2, 291 long mask) 292 { 293 struct hx711_data *hx711_data = iio_priv(indio_dev); 294 int ret; 295 int gain; 296 297 switch (mask) { 298 case IIO_CHAN_INFO_SCALE: 299 /* 300 * a scale greater than 1 mV per LSB is not possible 301 * with the HX711, therefore val must be 0 302 */ 303 if (val != 0) 304 return -EINVAL; 305 306 mutex_lock(&hx711_data->lock); 307 308 gain = hx711_get_scale_to_gain(val2); 309 if (gain < 0) { 310 mutex_unlock(&hx711_data->lock); 311 return gain; 312 } 313 314 if (gain != hx711_data->gain_set) { 315 hx711_data->gain_set = gain; 316 if (gain != 32) 317 hx711_data->gain_chan_a = gain; 318 319 ret = hx711_read(hx711_data); 320 if (ret < 0) { 321 mutex_unlock(&hx711_data->lock); 322 return ret; 323 } 324 } 325 326 mutex_unlock(&hx711_data->lock); 327 return 0; 328 default: 329 return -EINVAL; 330 } 331 332 return 0; 333 } 334 335 static int hx711_write_raw_get_fmt(struct iio_dev *indio_dev, 336 struct iio_chan_spec const *chan, 337 long mask) 338 { 339 return IIO_VAL_INT_PLUS_NANO; 340 } 341 342 static ssize_t hx711_scale_available_show(struct device *dev, 343 struct device_attribute *attr, 344 char *buf) 345 { 346 struct iio_dev_attr *iio_attr = to_iio_dev_attr(attr); 347 int channel = iio_attr->address; 348 int i, len = 0; 349 350 for (i = 0; i < HX711_GAIN_MAX; i++) 351 if (hx711_gain_to_scale[i].channel == channel) 352 len += sprintf(buf + len, "0.%09d ", 353 hx711_gain_to_scale[i].scale); 354 355 len += sprintf(buf + len, "\n"); 356 357 return len; 358 } 359 360 static IIO_DEVICE_ATTR(in_voltage0_scale_available, S_IRUGO, 361 hx711_scale_available_show, NULL, 0); 362 363 static IIO_DEVICE_ATTR(in_voltage1_scale_available, S_IRUGO, 364 hx711_scale_available_show, NULL, 1); 365 366 static struct attribute *hx711_attributes[] = { 367 &iio_dev_attr_in_voltage0_scale_available.dev_attr.attr, 368 &iio_dev_attr_in_voltage1_scale_available.dev_attr.attr, 369 NULL, 370 }; 371 372 static struct attribute_group hx711_attribute_group = { 373 .attrs = hx711_attributes, 374 }; 375 376 static const struct iio_info hx711_iio_info = { 377 .driver_module = THIS_MODULE, 378 .read_raw = hx711_read_raw, 379 .write_raw = hx711_write_raw, 380 .write_raw_get_fmt = hx711_write_raw_get_fmt, 381 .attrs = &hx711_attribute_group, 382 }; 383 384 static const struct iio_chan_spec hx711_chan_spec[] = { 385 { 386 .type = IIO_VOLTAGE, 387 .channel = 0, 388 .indexed = 1, 389 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 390 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), 391 }, 392 { 393 .type = IIO_VOLTAGE, 394 .channel = 1, 395 .indexed = 1, 396 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 397 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), 398 }, 399 }; 400 401 static int hx711_probe(struct platform_device *pdev) 402 { 403 struct device *dev = &pdev->dev; 404 struct hx711_data *hx711_data; 405 struct iio_dev *indio_dev; 406 int ret; 407 int i; 408 409 indio_dev = devm_iio_device_alloc(dev, sizeof(struct hx711_data)); 410 if (!indio_dev) { 411 dev_err(dev, "failed to allocate IIO device\n"); 412 return -ENOMEM; 413 } 414 415 hx711_data = iio_priv(indio_dev); 416 hx711_data->dev = dev; 417 418 mutex_init(&hx711_data->lock); 419 420 /* 421 * PD_SCK stands for power down and serial clock input of HX711 422 * in the driver it is an output 423 */ 424 hx711_data->gpiod_pd_sck = devm_gpiod_get(dev, "sck", GPIOD_OUT_LOW); 425 if (IS_ERR(hx711_data->gpiod_pd_sck)) { 426 dev_err(dev, "failed to get sck-gpiod: err=%ld\n", 427 PTR_ERR(hx711_data->gpiod_pd_sck)); 428 return PTR_ERR(hx711_data->gpiod_pd_sck); 429 } 430 431 /* 432 * DOUT stands for serial data output of HX711 433 * for the driver it is an input 434 */ 435 hx711_data->gpiod_dout = devm_gpiod_get(dev, "dout", GPIOD_IN); 436 if (IS_ERR(hx711_data->gpiod_dout)) { 437 dev_err(dev, "failed to get dout-gpiod: err=%ld\n", 438 PTR_ERR(hx711_data->gpiod_dout)); 439 return PTR_ERR(hx711_data->gpiod_dout); 440 } 441 442 hx711_data->reg_avdd = devm_regulator_get(dev, "avdd"); 443 if (IS_ERR(hx711_data->reg_avdd)) 444 return PTR_ERR(hx711_data->reg_avdd); 445 446 ret = regulator_enable(hx711_data->reg_avdd); 447 if (ret < 0) 448 return ret; 449 450 /* 451 * with 452 * full scale differential input range: AVDD / GAIN 453 * full scale output data: 2^24 454 * we can say: 455 * AVDD / GAIN = 2^24 456 * therefore: 457 * 1 LSB = AVDD / GAIN / 2^24 458 * AVDD is in uV, but we need 10^-9 mV 459 * approximately to fit into a 32 bit number: 460 * 1 LSB = (AVDD * 100) / GAIN / 1678 [10^-9 mV] 461 */ 462 ret = regulator_get_voltage(hx711_data->reg_avdd); 463 if (ret < 0) { 464 regulator_disable(hx711_data->reg_avdd); 465 return ret; 466 } 467 /* we need 10^-9 mV */ 468 ret *= 100; 469 470 for (i = 0; i < HX711_GAIN_MAX; i++) 471 hx711_gain_to_scale[i].scale = 472 ret / hx711_gain_to_scale[i].gain / 1678; 473 474 hx711_data->gain_set = 128; 475 hx711_data->gain_chan_a = 128; 476 477 platform_set_drvdata(pdev, indio_dev); 478 479 indio_dev->name = "hx711"; 480 indio_dev->dev.parent = &pdev->dev; 481 indio_dev->info = &hx711_iio_info; 482 indio_dev->modes = INDIO_DIRECT_MODE; 483 indio_dev->channels = hx711_chan_spec; 484 indio_dev->num_channels = ARRAY_SIZE(hx711_chan_spec); 485 486 ret = iio_device_register(indio_dev); 487 if (ret < 0) { 488 dev_err(dev, "Couldn't register the device\n"); 489 regulator_disable(hx711_data->reg_avdd); 490 } 491 492 return ret; 493 } 494 495 static int hx711_remove(struct platform_device *pdev) 496 { 497 struct hx711_data *hx711_data; 498 struct iio_dev *indio_dev; 499 500 indio_dev = platform_get_drvdata(pdev); 501 hx711_data = iio_priv(indio_dev); 502 503 iio_device_unregister(indio_dev); 504 505 regulator_disable(hx711_data->reg_avdd); 506 507 return 0; 508 } 509 510 static const struct of_device_id of_hx711_match[] = { 511 { .compatible = "avia,hx711", }, 512 {}, 513 }; 514 515 MODULE_DEVICE_TABLE(of, of_hx711_match); 516 517 static struct platform_driver hx711_driver = { 518 .probe = hx711_probe, 519 .remove = hx711_remove, 520 .driver = { 521 .name = "hx711-gpio", 522 .of_match_table = of_hx711_match, 523 }, 524 }; 525 526 module_platform_driver(hx711_driver); 527 528 MODULE_AUTHOR("Andreas Klinger <ak@it-klinger.de>"); 529 MODULE_DESCRIPTION("HX711 bitbanging driver - ADC for weight cells"); 530 MODULE_LICENSE("GPL"); 531 MODULE_ALIAS("platform:hx711-gpio"); 532 533