1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * atlas-sensor.c - Support for Atlas Scientific OEM SM sensors 4 * 5 * Copyright (C) 2015-2019 Konsulko Group 6 * Author: Matt Ranostay <matt.ranostay@konsulko.com> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/init.h> 11 #include <linux/interrupt.h> 12 #include <linux/delay.h> 13 #include <linux/mutex.h> 14 #include <linux/err.h> 15 #include <linux/irq.h> 16 #include <linux/irq_work.h> 17 #include <linux/i2c.h> 18 #include <linux/of_device.h> 19 #include <linux/regmap.h> 20 #include <linux/iio/iio.h> 21 #include <linux/iio/buffer.h> 22 #include <linux/iio/trigger.h> 23 #include <linux/iio/trigger_consumer.h> 24 #include <linux/iio/triggered_buffer.h> 25 #include <linux/pm_runtime.h> 26 27 #define ATLAS_REGMAP_NAME "atlas_regmap" 28 #define ATLAS_DRV_NAME "atlas" 29 30 #define ATLAS_REG_DEV_TYPE 0x00 31 #define ATLAS_REG_DEV_VERSION 0x01 32 33 #define ATLAS_REG_INT_CONTROL 0x04 34 #define ATLAS_REG_INT_CONTROL_EN BIT(3) 35 36 #define ATLAS_REG_PWR_CONTROL 0x06 37 38 #define ATLAS_REG_PH_CALIB_STATUS 0x0d 39 #define ATLAS_REG_PH_CALIB_STATUS_MASK 0x07 40 #define ATLAS_REG_PH_CALIB_STATUS_LOW BIT(0) 41 #define ATLAS_REG_PH_CALIB_STATUS_MID BIT(1) 42 #define ATLAS_REG_PH_CALIB_STATUS_HIGH BIT(2) 43 44 #define ATLAS_REG_EC_CALIB_STATUS 0x0f 45 #define ATLAS_REG_EC_CALIB_STATUS_MASK 0x0f 46 #define ATLAS_REG_EC_CALIB_STATUS_DRY BIT(0) 47 #define ATLAS_REG_EC_CALIB_STATUS_SINGLE BIT(1) 48 #define ATLAS_REG_EC_CALIB_STATUS_LOW BIT(2) 49 #define ATLAS_REG_EC_CALIB_STATUS_HIGH BIT(3) 50 51 #define ATLAS_REG_PH_TEMP_DATA 0x0e 52 #define ATLAS_REG_PH_DATA 0x16 53 54 #define ATLAS_REG_EC_PROBE 0x08 55 #define ATLAS_REG_EC_TEMP_DATA 0x10 56 #define ATLAS_REG_EC_DATA 0x18 57 #define ATLAS_REG_TDS_DATA 0x1c 58 #define ATLAS_REG_PSS_DATA 0x20 59 60 #define ATLAS_REG_ORP_CALIB_STATUS 0x0d 61 #define ATLAS_REG_ORP_DATA 0x0e 62 63 #define ATLAS_PH_INT_TIME_IN_MS 450 64 #define ATLAS_EC_INT_TIME_IN_MS 650 65 #define ATLAS_ORP_INT_TIME_IN_MS 450 66 67 enum { 68 ATLAS_PH_SM, 69 ATLAS_EC_SM, 70 ATLAS_ORP_SM, 71 }; 72 73 struct atlas_data { 74 struct i2c_client *client; 75 struct iio_trigger *trig; 76 struct atlas_device *chip; 77 struct regmap *regmap; 78 struct irq_work work; 79 80 __be32 buffer[6]; /* 96-bit data + 32-bit pad + 64-bit timestamp */ 81 }; 82 83 static const struct regmap_config atlas_regmap_config = { 84 .name = ATLAS_REGMAP_NAME, 85 .reg_bits = 8, 86 .val_bits = 8, 87 }; 88 89 static const struct iio_chan_spec atlas_ph_channels[] = { 90 { 91 .type = IIO_PH, 92 .address = ATLAS_REG_PH_DATA, 93 .info_mask_separate = 94 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 95 .scan_index = 0, 96 .scan_type = { 97 .sign = 'u', 98 .realbits = 32, 99 .storagebits = 32, 100 .endianness = IIO_BE, 101 }, 102 }, 103 IIO_CHAN_SOFT_TIMESTAMP(1), 104 { 105 .type = IIO_TEMP, 106 .address = ATLAS_REG_PH_TEMP_DATA, 107 .info_mask_separate = 108 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 109 .output = 1, 110 .scan_index = -1 111 }, 112 }; 113 114 #define ATLAS_EC_CHANNEL(_idx, _addr) \ 115 {\ 116 .type = IIO_CONCENTRATION, \ 117 .indexed = 1, \ 118 .channel = _idx, \ 119 .address = _addr, \ 120 .info_mask_separate = \ 121 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), \ 122 .scan_index = _idx + 1, \ 123 .scan_type = { \ 124 .sign = 'u', \ 125 .realbits = 32, \ 126 .storagebits = 32, \ 127 .endianness = IIO_BE, \ 128 }, \ 129 } 130 131 static const struct iio_chan_spec atlas_ec_channels[] = { 132 { 133 .type = IIO_ELECTRICALCONDUCTIVITY, 134 .address = ATLAS_REG_EC_DATA, 135 .info_mask_separate = 136 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 137 .scan_index = 0, 138 .scan_type = { 139 .sign = 'u', 140 .realbits = 32, 141 .storagebits = 32, 142 .endianness = IIO_BE, 143 }, 144 }, 145 ATLAS_EC_CHANNEL(0, ATLAS_REG_TDS_DATA), 146 ATLAS_EC_CHANNEL(1, ATLAS_REG_PSS_DATA), 147 IIO_CHAN_SOFT_TIMESTAMP(3), 148 { 149 .type = IIO_TEMP, 150 .address = ATLAS_REG_EC_TEMP_DATA, 151 .info_mask_separate = 152 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 153 .output = 1, 154 .scan_index = -1 155 }, 156 }; 157 158 static const struct iio_chan_spec atlas_orp_channels[] = { 159 { 160 .type = IIO_VOLTAGE, 161 .address = ATLAS_REG_ORP_DATA, 162 .info_mask_separate = 163 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 164 .scan_index = 0, 165 .scan_type = { 166 .sign = 's', 167 .realbits = 32, 168 .storagebits = 32, 169 .endianness = IIO_BE, 170 }, 171 }, 172 IIO_CHAN_SOFT_TIMESTAMP(1), 173 }; 174 175 static int atlas_check_ph_calibration(struct atlas_data *data) 176 { 177 struct device *dev = &data->client->dev; 178 int ret; 179 unsigned int val; 180 181 ret = regmap_read(data->regmap, ATLAS_REG_PH_CALIB_STATUS, &val); 182 if (ret) 183 return ret; 184 185 if (!(val & ATLAS_REG_PH_CALIB_STATUS_MASK)) { 186 dev_warn(dev, "device has not been calibrated\n"); 187 return 0; 188 } 189 190 if (!(val & ATLAS_REG_PH_CALIB_STATUS_LOW)) 191 dev_warn(dev, "device missing low point calibration\n"); 192 193 if (!(val & ATLAS_REG_PH_CALIB_STATUS_MID)) 194 dev_warn(dev, "device missing mid point calibration\n"); 195 196 if (!(val & ATLAS_REG_PH_CALIB_STATUS_HIGH)) 197 dev_warn(dev, "device missing high point calibration\n"); 198 199 return 0; 200 } 201 202 static int atlas_check_ec_calibration(struct atlas_data *data) 203 { 204 struct device *dev = &data->client->dev; 205 int ret; 206 unsigned int val; 207 __be16 rval; 208 209 ret = regmap_bulk_read(data->regmap, ATLAS_REG_EC_PROBE, &rval, 2); 210 if (ret) 211 return ret; 212 213 val = be16_to_cpu(rval); 214 dev_info(dev, "probe set to K = %d.%.2d", val / 100, val % 100); 215 216 ret = regmap_read(data->regmap, ATLAS_REG_EC_CALIB_STATUS, &val); 217 if (ret) 218 return ret; 219 220 if (!(val & ATLAS_REG_EC_CALIB_STATUS_MASK)) { 221 dev_warn(dev, "device has not been calibrated\n"); 222 return 0; 223 } 224 225 if (!(val & ATLAS_REG_EC_CALIB_STATUS_DRY)) 226 dev_warn(dev, "device missing dry point calibration\n"); 227 228 if (val & ATLAS_REG_EC_CALIB_STATUS_SINGLE) { 229 dev_warn(dev, "device using single point calibration\n"); 230 } else { 231 if (!(val & ATLAS_REG_EC_CALIB_STATUS_LOW)) 232 dev_warn(dev, "device missing low point calibration\n"); 233 234 if (!(val & ATLAS_REG_EC_CALIB_STATUS_HIGH)) 235 dev_warn(dev, "device missing high point calibration\n"); 236 } 237 238 return 0; 239 } 240 241 static int atlas_check_orp_calibration(struct atlas_data *data) 242 { 243 struct device *dev = &data->client->dev; 244 int ret; 245 unsigned int val; 246 247 ret = regmap_read(data->regmap, ATLAS_REG_ORP_CALIB_STATUS, &val); 248 if (ret) 249 return ret; 250 251 if (!val) 252 dev_warn(dev, "device has not been calibrated\n"); 253 254 return 0; 255 }; 256 257 struct atlas_device { 258 const struct iio_chan_spec *channels; 259 int num_channels; 260 int data_reg; 261 262 int (*calibration)(struct atlas_data *data); 263 int delay; 264 }; 265 266 static struct atlas_device atlas_devices[] = { 267 [ATLAS_PH_SM] = { 268 .channels = atlas_ph_channels, 269 .num_channels = 3, 270 .data_reg = ATLAS_REG_PH_DATA, 271 .calibration = &atlas_check_ph_calibration, 272 .delay = ATLAS_PH_INT_TIME_IN_MS, 273 }, 274 [ATLAS_EC_SM] = { 275 .channels = atlas_ec_channels, 276 .num_channels = 5, 277 .data_reg = ATLAS_REG_EC_DATA, 278 .calibration = &atlas_check_ec_calibration, 279 .delay = ATLAS_EC_INT_TIME_IN_MS, 280 }, 281 [ATLAS_ORP_SM] = { 282 .channels = atlas_orp_channels, 283 .num_channels = 2, 284 .data_reg = ATLAS_REG_ORP_DATA, 285 .calibration = &atlas_check_orp_calibration, 286 .delay = ATLAS_ORP_INT_TIME_IN_MS, 287 }, 288 }; 289 290 static int atlas_set_powermode(struct atlas_data *data, int on) 291 { 292 return regmap_write(data->regmap, ATLAS_REG_PWR_CONTROL, on); 293 } 294 295 static int atlas_set_interrupt(struct atlas_data *data, bool state) 296 { 297 return regmap_update_bits(data->regmap, ATLAS_REG_INT_CONTROL, 298 ATLAS_REG_INT_CONTROL_EN, 299 state ? ATLAS_REG_INT_CONTROL_EN : 0); 300 } 301 302 static int atlas_buffer_postenable(struct iio_dev *indio_dev) 303 { 304 struct atlas_data *data = iio_priv(indio_dev); 305 int ret; 306 307 ret = iio_triggered_buffer_postenable(indio_dev); 308 if (ret) 309 return ret; 310 311 ret = pm_runtime_get_sync(&data->client->dev); 312 if (ret < 0) { 313 pm_runtime_put_noidle(&data->client->dev); 314 return ret; 315 } 316 317 return atlas_set_interrupt(data, true); 318 } 319 320 static int atlas_buffer_predisable(struct iio_dev *indio_dev) 321 { 322 struct atlas_data *data = iio_priv(indio_dev); 323 int ret; 324 325 ret = atlas_set_interrupt(data, false); 326 if (ret) 327 return ret; 328 329 pm_runtime_mark_last_busy(&data->client->dev); 330 ret = pm_runtime_put_autosuspend(&data->client->dev); 331 if (ret) 332 return ret; 333 334 return iio_triggered_buffer_predisable(indio_dev); 335 } 336 337 static const struct iio_trigger_ops atlas_interrupt_trigger_ops = { 338 }; 339 340 static const struct iio_buffer_setup_ops atlas_buffer_setup_ops = { 341 .postenable = atlas_buffer_postenable, 342 .predisable = atlas_buffer_predisable, 343 }; 344 345 static void atlas_work_handler(struct irq_work *work) 346 { 347 struct atlas_data *data = container_of(work, struct atlas_data, work); 348 349 iio_trigger_poll(data->trig); 350 } 351 352 static irqreturn_t atlas_trigger_handler(int irq, void *private) 353 { 354 struct iio_poll_func *pf = private; 355 struct iio_dev *indio_dev = pf->indio_dev; 356 struct atlas_data *data = iio_priv(indio_dev); 357 int ret; 358 359 ret = regmap_bulk_read(data->regmap, data->chip->data_reg, 360 (u8 *) &data->buffer, 361 sizeof(__be32) * (data->chip->num_channels - 2)); 362 363 if (!ret) 364 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer, 365 iio_get_time_ns(indio_dev)); 366 367 iio_trigger_notify_done(indio_dev->trig); 368 369 return IRQ_HANDLED; 370 } 371 372 static irqreturn_t atlas_interrupt_handler(int irq, void *private) 373 { 374 struct iio_dev *indio_dev = private; 375 struct atlas_data *data = iio_priv(indio_dev); 376 377 irq_work_queue(&data->work); 378 379 return IRQ_HANDLED; 380 } 381 382 static int atlas_read_measurement(struct atlas_data *data, int reg, __be32 *val) 383 { 384 struct device *dev = &data->client->dev; 385 int suspended = pm_runtime_suspended(dev); 386 int ret; 387 388 ret = pm_runtime_get_sync(dev); 389 if (ret < 0) { 390 pm_runtime_put_noidle(dev); 391 return ret; 392 } 393 394 if (suspended) 395 msleep(data->chip->delay); 396 397 ret = regmap_bulk_read(data->regmap, reg, (u8 *) val, sizeof(*val)); 398 399 pm_runtime_mark_last_busy(dev); 400 pm_runtime_put_autosuspend(dev); 401 402 return ret; 403 } 404 405 static int atlas_read_raw(struct iio_dev *indio_dev, 406 struct iio_chan_spec const *chan, 407 int *val, int *val2, long mask) 408 { 409 struct atlas_data *data = iio_priv(indio_dev); 410 411 switch (mask) { 412 case IIO_CHAN_INFO_RAW: { 413 int ret; 414 __be32 reg; 415 416 switch (chan->type) { 417 case IIO_TEMP: 418 ret = regmap_bulk_read(data->regmap, chan->address, 419 (u8 *) ®, sizeof(reg)); 420 break; 421 case IIO_PH: 422 case IIO_CONCENTRATION: 423 case IIO_ELECTRICALCONDUCTIVITY: 424 case IIO_VOLTAGE: 425 ret = iio_device_claim_direct_mode(indio_dev); 426 if (ret) 427 return ret; 428 429 ret = atlas_read_measurement(data, chan->address, ®); 430 431 iio_device_release_direct_mode(indio_dev); 432 break; 433 default: 434 ret = -EINVAL; 435 } 436 437 if (!ret) { 438 *val = be32_to_cpu(reg); 439 ret = IIO_VAL_INT; 440 } 441 return ret; 442 } 443 case IIO_CHAN_INFO_SCALE: 444 switch (chan->type) { 445 case IIO_TEMP: 446 *val = 10; 447 return IIO_VAL_INT; 448 case IIO_PH: 449 *val = 1; /* 0.001 */ 450 *val2 = 1000; 451 break; 452 case IIO_ELECTRICALCONDUCTIVITY: 453 *val = 1; /* 0.00001 */ 454 *val2 = 100000; 455 break; 456 case IIO_CONCENTRATION: 457 *val = 0; /* 0.000000001 */ 458 *val2 = 1000; 459 return IIO_VAL_INT_PLUS_NANO; 460 case IIO_VOLTAGE: 461 *val = 1; /* 0.1 */ 462 *val2 = 10; 463 break; 464 default: 465 return -EINVAL; 466 } 467 return IIO_VAL_FRACTIONAL; 468 } 469 470 return -EINVAL; 471 } 472 473 static int atlas_write_raw(struct iio_dev *indio_dev, 474 struct iio_chan_spec const *chan, 475 int val, int val2, long mask) 476 { 477 struct atlas_data *data = iio_priv(indio_dev); 478 __be32 reg = cpu_to_be32(val / 10); 479 480 if (val2 != 0 || val < 0 || val > 20000) 481 return -EINVAL; 482 483 if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_TEMP) 484 return -EINVAL; 485 486 return regmap_bulk_write(data->regmap, chan->address, 487 ®, sizeof(reg)); 488 } 489 490 static const struct iio_info atlas_info = { 491 .read_raw = atlas_read_raw, 492 .write_raw = atlas_write_raw, 493 }; 494 495 static const struct i2c_device_id atlas_id[] = { 496 { "atlas-ph-sm", ATLAS_PH_SM}, 497 { "atlas-ec-sm", ATLAS_EC_SM}, 498 { "atlas-orp-sm", ATLAS_ORP_SM}, 499 {} 500 }; 501 MODULE_DEVICE_TABLE(i2c, atlas_id); 502 503 static const struct of_device_id atlas_dt_ids[] = { 504 { .compatible = "atlas,ph-sm", .data = (void *)ATLAS_PH_SM, }, 505 { .compatible = "atlas,ec-sm", .data = (void *)ATLAS_EC_SM, }, 506 { .compatible = "atlas,orp-sm", .data = (void *)ATLAS_ORP_SM, }, 507 { } 508 }; 509 MODULE_DEVICE_TABLE(of, atlas_dt_ids); 510 511 static int atlas_probe(struct i2c_client *client, 512 const struct i2c_device_id *id) 513 { 514 struct atlas_data *data; 515 struct atlas_device *chip; 516 const struct of_device_id *of_id; 517 struct iio_trigger *trig; 518 struct iio_dev *indio_dev; 519 int ret; 520 521 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 522 if (!indio_dev) 523 return -ENOMEM; 524 525 of_id = of_match_device(atlas_dt_ids, &client->dev); 526 if (!of_id) 527 chip = &atlas_devices[id->driver_data]; 528 else 529 chip = &atlas_devices[(unsigned long)of_id->data]; 530 531 indio_dev->info = &atlas_info; 532 indio_dev->name = ATLAS_DRV_NAME; 533 indio_dev->channels = chip->channels; 534 indio_dev->num_channels = chip->num_channels; 535 indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE; 536 indio_dev->dev.parent = &client->dev; 537 538 trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d", 539 indio_dev->name, indio_dev->id); 540 541 if (!trig) 542 return -ENOMEM; 543 544 data = iio_priv(indio_dev); 545 data->client = client; 546 data->trig = trig; 547 data->chip = chip; 548 trig->dev.parent = indio_dev->dev.parent; 549 trig->ops = &atlas_interrupt_trigger_ops; 550 iio_trigger_set_drvdata(trig, indio_dev); 551 552 i2c_set_clientdata(client, indio_dev); 553 554 data->regmap = devm_regmap_init_i2c(client, &atlas_regmap_config); 555 if (IS_ERR(data->regmap)) { 556 dev_err(&client->dev, "regmap initialization failed\n"); 557 return PTR_ERR(data->regmap); 558 } 559 560 ret = pm_runtime_set_active(&client->dev); 561 if (ret) 562 return ret; 563 564 if (client->irq <= 0) { 565 dev_err(&client->dev, "no valid irq defined\n"); 566 return -EINVAL; 567 } 568 569 ret = chip->calibration(data); 570 if (ret) 571 return ret; 572 573 ret = iio_trigger_register(trig); 574 if (ret) { 575 dev_err(&client->dev, "failed to register trigger\n"); 576 return ret; 577 } 578 579 ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time, 580 &atlas_trigger_handler, &atlas_buffer_setup_ops); 581 if (ret) { 582 dev_err(&client->dev, "cannot setup iio trigger\n"); 583 goto unregister_trigger; 584 } 585 586 init_irq_work(&data->work, atlas_work_handler); 587 588 /* interrupt pin toggles on new conversion */ 589 ret = devm_request_threaded_irq(&client->dev, client->irq, 590 NULL, atlas_interrupt_handler, 591 IRQF_TRIGGER_RISING | 592 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 593 "atlas_irq", 594 indio_dev); 595 if (ret) { 596 dev_err(&client->dev, "request irq (%d) failed\n", client->irq); 597 goto unregister_buffer; 598 } 599 600 ret = atlas_set_powermode(data, 1); 601 if (ret) { 602 dev_err(&client->dev, "cannot power device on"); 603 goto unregister_buffer; 604 } 605 606 pm_runtime_enable(&client->dev); 607 pm_runtime_set_autosuspend_delay(&client->dev, 2500); 608 pm_runtime_use_autosuspend(&client->dev); 609 610 ret = iio_device_register(indio_dev); 611 if (ret) { 612 dev_err(&client->dev, "unable to register device\n"); 613 goto unregister_pm; 614 } 615 616 return 0; 617 618 unregister_pm: 619 pm_runtime_disable(&client->dev); 620 atlas_set_powermode(data, 0); 621 622 unregister_buffer: 623 iio_triggered_buffer_cleanup(indio_dev); 624 625 unregister_trigger: 626 iio_trigger_unregister(data->trig); 627 628 return ret; 629 } 630 631 static int atlas_remove(struct i2c_client *client) 632 { 633 struct iio_dev *indio_dev = i2c_get_clientdata(client); 634 struct atlas_data *data = iio_priv(indio_dev); 635 636 iio_device_unregister(indio_dev); 637 iio_triggered_buffer_cleanup(indio_dev); 638 iio_trigger_unregister(data->trig); 639 640 pm_runtime_disable(&client->dev); 641 pm_runtime_set_suspended(&client->dev); 642 pm_runtime_put_noidle(&client->dev); 643 644 return atlas_set_powermode(data, 0); 645 } 646 647 #ifdef CONFIG_PM 648 static int atlas_runtime_suspend(struct device *dev) 649 { 650 struct atlas_data *data = 651 iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 652 653 return atlas_set_powermode(data, 0); 654 } 655 656 static int atlas_runtime_resume(struct device *dev) 657 { 658 struct atlas_data *data = 659 iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 660 661 return atlas_set_powermode(data, 1); 662 } 663 #endif 664 665 static const struct dev_pm_ops atlas_pm_ops = { 666 SET_RUNTIME_PM_OPS(atlas_runtime_suspend, 667 atlas_runtime_resume, NULL) 668 }; 669 670 static struct i2c_driver atlas_driver = { 671 .driver = { 672 .name = ATLAS_DRV_NAME, 673 .of_match_table = of_match_ptr(atlas_dt_ids), 674 .pm = &atlas_pm_ops, 675 }, 676 .probe = atlas_probe, 677 .remove = atlas_remove, 678 .id_table = atlas_id, 679 }; 680 module_i2c_driver(atlas_driver); 681 682 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>"); 683 MODULE_DESCRIPTION("Atlas Scientific SM sensors"); 684 MODULE_LICENSE("GPL"); 685