1 /* 2 * ADT7316 digital temperature sensor driver supporting ADT7316/7/8 ADT7516/7/9 3 * 4 * 5 * Copyright 2010 Analog Devices Inc. 6 * 7 * Licensed under the GPL-2 or later. 8 */ 9 10 #include <linux/interrupt.h> 11 #include <linux/gpio.h> 12 #include <linux/workqueue.h> 13 #include <linux/device.h> 14 #include <linux/kernel.h> 15 #include <linux/slab.h> 16 #include <linux/sysfs.h> 17 #include <linux/list.h> 18 #include <linux/i2c.h> 19 #include <linux/rtc.h> 20 #include <linux/module.h> 21 22 #include <linux/iio/iio.h> 23 #include <linux/iio/events.h> 24 #include <linux/iio/sysfs.h> 25 #include "adt7316.h" 26 27 /* 28 * ADT7316 registers definition 29 */ 30 #define ADT7316_INT_STAT1 0x0 31 #define ADT7316_INT_STAT2 0x1 32 #define ADT7316_LSB_IN_TEMP_VDD 0x3 33 #define ADT7316_LSB_IN_TEMP_MASK 0x3 34 #define ADT7316_LSB_VDD_MASK 0xC 35 #define ADT7316_LSB_VDD_OFFSET 2 36 #define ADT7316_LSB_EX_TEMP_AIN 0x4 37 #define ADT7316_LSB_EX_TEMP_MASK 0x3 38 #define ADT7516_LSB_AIN_SHIFT 2 39 #define ADT7316_AD_MSB_DATA_BASE 0x6 40 #define ADT7316_AD_MSB_DATA_REGS 3 41 #define ADT7516_AD_MSB_DATA_REGS 6 42 #define ADT7316_MSB_VDD 0x6 43 #define ADT7316_MSB_IN_TEMP 0x7 44 #define ADT7316_MSB_EX_TEMP 0x8 45 #define ADT7516_MSB_AIN1 0x8 46 #define ADT7516_MSB_AIN2 0x9 47 #define ADT7516_MSB_AIN3 0xA 48 #define ADT7516_MSB_AIN4 0xB 49 #define ADT7316_DA_DATA_BASE 0x10 50 #define ADT7316_DA_MSB_DATA_REGS 4 51 #define ADT7316_LSB_DAC_A 0x10 52 #define ADT7316_MSB_DAC_A 0x11 53 #define ADT7316_LSB_DAC_B 0x12 54 #define ADT7316_MSB_DAC_B 0x13 55 #define ADT7316_LSB_DAC_C 0x14 56 #define ADT7316_MSB_DAC_C 0x15 57 #define ADT7316_LSB_DAC_D 0x16 58 #define ADT7316_MSB_DAC_D 0x17 59 #define ADT7316_CONFIG1 0x18 60 #define ADT7316_CONFIG2 0x19 61 #define ADT7316_CONFIG3 0x1A 62 #define ADT7316_LDAC_CONFIG 0x1B 63 #define ADT7316_DAC_CONFIG 0x1C 64 #define ADT7316_INT_MASK1 0x1D 65 #define ADT7316_INT_MASK2 0x1E 66 #define ADT7316_IN_TEMP_OFFSET 0x1F 67 #define ADT7316_EX_TEMP_OFFSET 0x20 68 #define ADT7316_IN_ANALOG_TEMP_OFFSET 0x21 69 #define ADT7316_EX_ANALOG_TEMP_OFFSET 0x22 70 #define ADT7316_VDD_HIGH 0x23 71 #define ADT7316_VDD_LOW 0x24 72 #define ADT7316_IN_TEMP_HIGH 0x25 73 #define ADT7316_IN_TEMP_LOW 0x26 74 #define ADT7316_EX_TEMP_HIGH 0x27 75 #define ADT7316_EX_TEMP_LOW 0x28 76 #define ADT7516_AIN2_HIGH 0x2B 77 #define ADT7516_AIN2_LOW 0x2C 78 #define ADT7516_AIN3_HIGH 0x2D 79 #define ADT7516_AIN3_LOW 0x2E 80 #define ADT7516_AIN4_HIGH 0x2F 81 #define ADT7516_AIN4_LOW 0x30 82 #define ADT7316_DEVICE_ID 0x4D 83 #define ADT7316_MANUFACTURE_ID 0x4E 84 #define ADT7316_DEVICE_REV 0x4F 85 #define ADT7316_SPI_LOCK_STAT 0x7F 86 87 /* 88 * ADT7316 config1 89 */ 90 #define ADT7316_EN 0x1 91 #define ADT7516_SEL_EX_TEMP 0x4 92 #define ADT7516_SEL_AIN1_2_EX_TEMP_MASK 0x6 93 #define ADT7516_SEL_AIN3 0x8 94 #define ADT7316_INT_EN 0x20 95 #define ADT7316_INT_POLARITY 0x40 96 #define ADT7316_PD 0x80 97 98 /* 99 * ADT7316 config2 100 */ 101 #define ADT7316_AD_SINGLE_CH_MASK 0x3 102 #define ADT7516_AD_SINGLE_CH_MASK 0x7 103 #define ADT7316_AD_SINGLE_CH_VDD 0 104 #define ADT7316_AD_SINGLE_CH_IN 1 105 #define ADT7316_AD_SINGLE_CH_EX 2 106 #define ADT7516_AD_SINGLE_CH_AIN1 2 107 #define ADT7516_AD_SINGLE_CH_AIN2 3 108 #define ADT7516_AD_SINGLE_CH_AIN3 4 109 #define ADT7516_AD_SINGLE_CH_AIN4 5 110 #define ADT7316_AD_SINGLE_CH_MODE 0x10 111 #define ADT7316_DISABLE_AVERAGING 0x20 112 #define ADT7316_EN_SMBUS_TIMEOUT 0x40 113 #define ADT7316_RESET 0x80 114 115 /* 116 * ADT7316 config3 117 */ 118 #define ADT7316_ADCLK_22_5 0x1 119 #define ADT7316_DA_HIGH_RESOLUTION 0x2 120 #define ADT7316_DA_EN_VIA_DAC_LDCA 0x4 121 #define ADT7516_AIN_IN_VREF 0x10 122 #define ADT7316_EN_IN_TEMP_PROP_DACA 0x20 123 #define ADT7316_EN_EX_TEMP_PROP_DACB 0x40 124 125 /* 126 * ADT7316 DAC config 127 */ 128 #define ADT7316_DA_2VREF_CH_MASK 0xF 129 #define ADT7316_DA_EN_MODE_MASK 0x30 130 #define ADT7316_DA_EN_MODE_SINGLE 0x00 131 #define ADT7316_DA_EN_MODE_AB_CD 0x10 132 #define ADT7316_DA_EN_MODE_ABCD 0x20 133 #define ADT7316_DA_EN_MODE_LDAC 0x30 134 #define ADT7316_VREF_BYPASS_DAC_AB 0x40 135 #define ADT7316_VREF_BYPASS_DAC_CD 0x80 136 137 /* 138 * ADT7316 LDAC config 139 */ 140 #define ADT7316_LDAC_EN_DA_MASK 0xF 141 #define ADT7316_DAC_IN_VREF 0x10 142 #define ADT7516_DAC_AB_IN_VREF 0x10 143 #define ADT7516_DAC_CD_IN_VREF 0x20 144 #define ADT7516_DAC_IN_VREF_OFFSET 4 145 #define ADT7516_DAC_IN_VREF_MASK 0x30 146 147 /* 148 * ADT7316 INT_MASK2 149 */ 150 #define ADT7316_INT_MASK2_VDD 0x10 151 152 /* 153 * ADT7316 value masks 154 */ 155 #define ADT7316_VALUE_MASK 0xfff 156 #define ADT7316_T_VALUE_SIGN 0x400 157 #define ADT7316_T_VALUE_FLOAT_OFFSET 2 158 #define ADT7316_T_VALUE_FLOAT_MASK 0x2 159 160 /* 161 * Chip ID 162 */ 163 #define ID_ADT7316 0x1 164 #define ID_ADT7317 0x2 165 #define ID_ADT7318 0x3 166 #define ID_ADT7516 0x11 167 #define ID_ADT7517 0x12 168 #define ID_ADT7519 0x14 169 170 #define ID_FAMILY_MASK 0xF0 171 #define ID_ADT73XX 0x0 172 #define ID_ADT75XX 0x10 173 174 /* 175 * struct adt7316_chip_info - chip specific information 176 */ 177 178 struct adt7316_chip_info { 179 struct adt7316_bus bus; 180 u16 ldac_pin; 181 u16 int_mask; /* 0x2f */ 182 u8 config1; 183 u8 config2; 184 u8 config3; 185 u8 dac_config; /* DAC config */ 186 u8 ldac_config; /* LDAC config */ 187 u8 dac_bits; /* 8, 10, 12 */ 188 u8 id; /* chip id */ 189 }; 190 191 /* 192 * Logic interrupt mask for user application to enable 193 * interrupts. 194 */ 195 #define ADT7316_IN_TEMP_HIGH_INT_MASK 0x1 196 #define ADT7316_IN_TEMP_LOW_INT_MASK 0x2 197 #define ADT7316_EX_TEMP_HIGH_INT_MASK 0x4 198 #define ADT7316_EX_TEMP_LOW_INT_MASK 0x8 199 #define ADT7316_EX_TEMP_FAULT_INT_MASK 0x10 200 #define ADT7516_AIN1_INT_MASK 0x4 201 #define ADT7516_AIN2_INT_MASK 0x20 202 #define ADT7516_AIN3_INT_MASK 0x40 203 #define ADT7516_AIN4_INT_MASK 0x80 204 #define ADT7316_VDD_INT_MASK 0x100 205 #define ADT7316_TEMP_INT_MASK 0x1F 206 #define ADT7516_AIN_INT_MASK 0xE0 207 #define ADT7316_TEMP_AIN_INT_MASK \ 208 (ADT7316_TEMP_INT_MASK) 209 210 /* 211 * struct adt7316_chip_info - chip specific information 212 */ 213 214 struct adt7316_limit_regs { 215 u16 data_high; 216 u16 data_low; 217 }; 218 219 static ssize_t adt7316_show_enabled(struct device *dev, 220 struct device_attribute *attr, 221 char *buf) 222 { 223 struct iio_dev *dev_info = dev_to_iio_dev(dev); 224 struct adt7316_chip_info *chip = iio_priv(dev_info); 225 226 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_EN)); 227 } 228 229 static ssize_t _adt7316_store_enabled(struct adt7316_chip_info *chip, 230 int enable) 231 { 232 u8 config1; 233 int ret; 234 235 if (enable) 236 config1 = chip->config1 | ADT7316_EN; 237 else 238 config1 = chip->config1 & ~ADT7316_EN; 239 240 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1); 241 if (ret) 242 return -EIO; 243 244 chip->config1 = config1; 245 246 return ret; 247 248 } 249 250 static ssize_t adt7316_store_enabled(struct device *dev, 251 struct device_attribute *attr, 252 const char *buf, 253 size_t len) 254 { 255 struct iio_dev *dev_info = dev_to_iio_dev(dev); 256 struct adt7316_chip_info *chip = iio_priv(dev_info); 257 int enable; 258 259 if (buf[0] == '1') 260 enable = 1; 261 else 262 enable = 0; 263 264 if (_adt7316_store_enabled(chip, enable) < 0) 265 return -EIO; 266 267 return len; 268 } 269 270 static IIO_DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR, 271 adt7316_show_enabled, 272 adt7316_store_enabled, 273 0); 274 275 static ssize_t adt7316_show_select_ex_temp(struct device *dev, 276 struct device_attribute *attr, 277 char *buf) 278 { 279 struct iio_dev *dev_info = dev_to_iio_dev(dev); 280 struct adt7316_chip_info *chip = iio_priv(dev_info); 281 282 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX) 283 return -EPERM; 284 285 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7516_SEL_EX_TEMP)); 286 } 287 288 static ssize_t adt7316_store_select_ex_temp(struct device *dev, 289 struct device_attribute *attr, 290 const char *buf, 291 size_t len) 292 { 293 struct iio_dev *dev_info = dev_to_iio_dev(dev); 294 struct adt7316_chip_info *chip = iio_priv(dev_info); 295 u8 config1; 296 int ret; 297 298 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX) 299 return -EPERM; 300 301 config1 = chip->config1 & (~ADT7516_SEL_EX_TEMP); 302 if (buf[0] == '1') 303 config1 |= ADT7516_SEL_EX_TEMP; 304 305 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1); 306 if (ret) 307 return -EIO; 308 309 chip->config1 = config1; 310 311 return len; 312 } 313 314 static IIO_DEVICE_ATTR(select_ex_temp, S_IRUGO | S_IWUSR, 315 adt7316_show_select_ex_temp, 316 adt7316_store_select_ex_temp, 317 0); 318 319 static ssize_t adt7316_show_mode(struct device *dev, 320 struct device_attribute *attr, 321 char *buf) 322 { 323 struct iio_dev *dev_info = dev_to_iio_dev(dev); 324 struct adt7316_chip_info *chip = iio_priv(dev_info); 325 326 if (chip->config2 & ADT7316_AD_SINGLE_CH_MODE) 327 return sprintf(buf, "single_channel\n"); 328 329 return sprintf(buf, "round_robin\n"); 330 } 331 332 static ssize_t adt7316_store_mode(struct device *dev, 333 struct device_attribute *attr, 334 const char *buf, 335 size_t len) 336 { 337 struct iio_dev *dev_info = dev_to_iio_dev(dev); 338 struct adt7316_chip_info *chip = iio_priv(dev_info); 339 u8 config2; 340 int ret; 341 342 config2 = chip->config2 & (~ADT7316_AD_SINGLE_CH_MODE); 343 if (!memcmp(buf, "single_channel", 14)) 344 config2 |= ADT7316_AD_SINGLE_CH_MODE; 345 346 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2); 347 if (ret) 348 return -EIO; 349 350 chip->config2 = config2; 351 352 return len; 353 } 354 355 static IIO_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, 356 adt7316_show_mode, 357 adt7316_store_mode, 358 0); 359 360 static ssize_t adt7316_show_all_modes(struct device *dev, 361 struct device_attribute *attr, 362 char *buf) 363 { 364 return sprintf(buf, "single_channel\nround_robin\n"); 365 } 366 367 static IIO_DEVICE_ATTR(all_modes, S_IRUGO, adt7316_show_all_modes, NULL, 0); 368 369 static ssize_t adt7316_show_ad_channel(struct device *dev, 370 struct device_attribute *attr, 371 char *buf) 372 { 373 struct iio_dev *dev_info = dev_to_iio_dev(dev); 374 struct adt7316_chip_info *chip = iio_priv(dev_info); 375 376 if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE)) 377 return -EPERM; 378 379 switch (chip->config2 & ADT7516_AD_SINGLE_CH_MASK) { 380 case ADT7316_AD_SINGLE_CH_VDD: 381 return sprintf(buf, "0 - VDD\n"); 382 case ADT7316_AD_SINGLE_CH_IN: 383 return sprintf(buf, "1 - Internal Temperature\n"); 384 case ADT7316_AD_SINGLE_CH_EX: 385 if (((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) && 386 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0) 387 return sprintf(buf, "2 - AIN1\n"); 388 389 return sprintf(buf, "2 - External Temperature\n"); 390 case ADT7516_AD_SINGLE_CH_AIN2: 391 if ((chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0) 392 return sprintf(buf, "3 - AIN2\n"); 393 394 return sprintf(buf, "N/A\n"); 395 case ADT7516_AD_SINGLE_CH_AIN3: 396 if (chip->config1 & ADT7516_SEL_AIN3) 397 return sprintf(buf, "4 - AIN3\n"); 398 399 return sprintf(buf, "N/A\n"); 400 case ADT7516_AD_SINGLE_CH_AIN4: 401 return sprintf(buf, "5 - AIN4\n"); 402 default: 403 return sprintf(buf, "N/A\n"); 404 } 405 } 406 407 static ssize_t adt7316_store_ad_channel(struct device *dev, 408 struct device_attribute *attr, 409 const char *buf, 410 size_t len) 411 { 412 struct iio_dev *dev_info = dev_to_iio_dev(dev); 413 struct adt7316_chip_info *chip = iio_priv(dev_info); 414 u8 config2; 415 u8 data; 416 int ret; 417 418 if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE)) 419 return -EPERM; 420 421 ret = kstrtou8(buf, 10, &data); 422 if (ret) 423 return -EINVAL; 424 425 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) { 426 if (data > 5) 427 return -EINVAL; 428 429 config2 = chip->config2 & (~ADT7516_AD_SINGLE_CH_MASK); 430 } else { 431 if (data > 2) 432 return -EINVAL; 433 434 config2 = chip->config2 & (~ADT7316_AD_SINGLE_CH_MASK); 435 } 436 437 438 config2 |= data; 439 440 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2); 441 if (ret) 442 return -EIO; 443 444 chip->config2 = config2; 445 446 return len; 447 } 448 449 static IIO_DEVICE_ATTR(ad_channel, S_IRUGO | S_IWUSR, 450 adt7316_show_ad_channel, 451 adt7316_store_ad_channel, 452 0); 453 454 static ssize_t adt7316_show_all_ad_channels(struct device *dev, 455 struct device_attribute *attr, 456 char *buf) 457 { 458 struct iio_dev *dev_info = dev_to_iio_dev(dev); 459 struct adt7316_chip_info *chip = iio_priv(dev_info); 460 461 if (!(chip->config2 & ADT7316_AD_SINGLE_CH_MODE)) 462 return -EPERM; 463 464 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) 465 return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n" 466 "2 - External Temperature or AIN1\n" 467 "3 - AIN2\n4 - AIN3\n5 - AIN4\n"); 468 return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n" 469 "2 - External Temperature\n"); 470 } 471 472 static IIO_DEVICE_ATTR(all_ad_channels, S_IRUGO, 473 adt7316_show_all_ad_channels, NULL, 0); 474 475 static ssize_t adt7316_show_disable_averaging(struct device *dev, 476 struct device_attribute *attr, 477 char *buf) 478 { 479 struct iio_dev *dev_info = dev_to_iio_dev(dev); 480 struct adt7316_chip_info *chip = iio_priv(dev_info); 481 482 return sprintf(buf, "%d\n", 483 !!(chip->config2 & ADT7316_DISABLE_AVERAGING)); 484 } 485 486 static ssize_t adt7316_store_disable_averaging(struct device *dev, 487 struct device_attribute *attr, 488 const char *buf, 489 size_t len) 490 { 491 struct iio_dev *dev_info = dev_to_iio_dev(dev); 492 struct adt7316_chip_info *chip = iio_priv(dev_info); 493 u8 config2; 494 int ret; 495 496 config2 = chip->config2 & (~ADT7316_DISABLE_AVERAGING); 497 if (buf[0] == '1') 498 config2 |= ADT7316_DISABLE_AVERAGING; 499 500 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2); 501 if (ret) 502 return -EIO; 503 504 chip->config2 = config2; 505 506 return len; 507 } 508 509 static IIO_DEVICE_ATTR(disable_averaging, S_IRUGO | S_IWUSR, 510 adt7316_show_disable_averaging, 511 adt7316_store_disable_averaging, 512 0); 513 514 static ssize_t adt7316_show_enable_smbus_timeout(struct device *dev, 515 struct device_attribute *attr, 516 char *buf) 517 { 518 struct iio_dev *dev_info = dev_to_iio_dev(dev); 519 struct adt7316_chip_info *chip = iio_priv(dev_info); 520 521 return sprintf(buf, "%d\n", 522 !!(chip->config2 & ADT7316_EN_SMBUS_TIMEOUT)); 523 } 524 525 static ssize_t adt7316_store_enable_smbus_timeout(struct device *dev, 526 struct device_attribute *attr, 527 const char *buf, 528 size_t len) 529 { 530 struct iio_dev *dev_info = dev_to_iio_dev(dev); 531 struct adt7316_chip_info *chip = iio_priv(dev_info); 532 u8 config2; 533 int ret; 534 535 config2 = chip->config2 & (~ADT7316_EN_SMBUS_TIMEOUT); 536 if (buf[0] == '1') 537 config2 |= ADT7316_EN_SMBUS_TIMEOUT; 538 539 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG2, config2); 540 if (ret) 541 return -EIO; 542 543 chip->config2 = config2; 544 545 return len; 546 } 547 548 static IIO_DEVICE_ATTR(enable_smbus_timeout, S_IRUGO | S_IWUSR, 549 adt7316_show_enable_smbus_timeout, 550 adt7316_store_enable_smbus_timeout, 551 0); 552 553 static ssize_t adt7316_show_powerdown(struct device *dev, 554 struct device_attribute *attr, 555 char *buf) 556 { 557 struct iio_dev *dev_info = dev_to_iio_dev(dev); 558 struct adt7316_chip_info *chip = iio_priv(dev_info); 559 560 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_PD)); 561 } 562 563 static ssize_t adt7316_store_powerdown(struct device *dev, 564 struct device_attribute *attr, 565 const char *buf, 566 size_t len) 567 { 568 struct iio_dev *dev_info = dev_to_iio_dev(dev); 569 struct adt7316_chip_info *chip = iio_priv(dev_info); 570 u8 config1; 571 int ret; 572 573 config1 = chip->config1 & (~ADT7316_PD); 574 if (buf[0] == '1') 575 config1 |= ADT7316_PD; 576 577 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1); 578 if (ret) 579 return -EIO; 580 581 chip->config1 = config1; 582 583 return len; 584 } 585 586 static IIO_DEVICE_ATTR(powerdown, S_IRUGO | S_IWUSR, 587 adt7316_show_powerdown, 588 adt7316_store_powerdown, 589 0); 590 591 static ssize_t adt7316_show_fast_ad_clock(struct device *dev, 592 struct device_attribute *attr, 593 char *buf) 594 { 595 struct iio_dev *dev_info = dev_to_iio_dev(dev); 596 struct adt7316_chip_info *chip = iio_priv(dev_info); 597 598 return sprintf(buf, "%d\n", !!(chip->config3 & ADT7316_ADCLK_22_5)); 599 } 600 601 static ssize_t adt7316_store_fast_ad_clock(struct device *dev, 602 struct device_attribute *attr, 603 const char *buf, 604 size_t len) 605 { 606 struct iio_dev *dev_info = dev_to_iio_dev(dev); 607 struct adt7316_chip_info *chip = iio_priv(dev_info); 608 u8 config3; 609 int ret; 610 611 config3 = chip->config3 & (~ADT7316_ADCLK_22_5); 612 if (buf[0] == '1') 613 config3 |= ADT7316_ADCLK_22_5; 614 615 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3); 616 if (ret) 617 return -EIO; 618 619 chip->config3 = config3; 620 621 return len; 622 } 623 624 static IIO_DEVICE_ATTR(fast_ad_clock, S_IRUGO | S_IWUSR, 625 adt7316_show_fast_ad_clock, 626 adt7316_store_fast_ad_clock, 627 0); 628 629 static ssize_t adt7316_show_da_high_resolution(struct device *dev, 630 struct device_attribute *attr, 631 char *buf) 632 { 633 struct iio_dev *dev_info = dev_to_iio_dev(dev); 634 struct adt7316_chip_info *chip = iio_priv(dev_info); 635 636 if (chip->config3 & ADT7316_DA_HIGH_RESOLUTION) { 637 if (chip->id == ID_ADT7316 || chip->id == ID_ADT7516) 638 return sprintf(buf, "1 (12 bits)\n"); 639 if (chip->id == ID_ADT7317 || chip->id == ID_ADT7517) 640 return sprintf(buf, "1 (10 bits)\n"); 641 } 642 643 return sprintf(buf, "0 (8 bits)\n"); 644 } 645 646 static ssize_t adt7316_store_da_high_resolution(struct device *dev, 647 struct device_attribute *attr, 648 const char *buf, 649 size_t len) 650 { 651 struct iio_dev *dev_info = dev_to_iio_dev(dev); 652 struct adt7316_chip_info *chip = iio_priv(dev_info); 653 u8 config3; 654 int ret; 655 656 chip->dac_bits = 8; 657 658 if (buf[0] == '1') { 659 config3 = chip->config3 | ADT7316_DA_HIGH_RESOLUTION; 660 if (chip->id == ID_ADT7316 || chip->id == ID_ADT7516) 661 chip->dac_bits = 12; 662 else if (chip->id == ID_ADT7317 || chip->id == ID_ADT7517) 663 chip->dac_bits = 10; 664 } else 665 config3 = chip->config3 & (~ADT7316_DA_HIGH_RESOLUTION); 666 667 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3); 668 if (ret) 669 return -EIO; 670 671 chip->config3 = config3; 672 673 return len; 674 } 675 676 static IIO_DEVICE_ATTR(da_high_resolution, S_IRUGO | S_IWUSR, 677 adt7316_show_da_high_resolution, 678 adt7316_store_da_high_resolution, 679 0); 680 681 static ssize_t adt7316_show_AIN_internal_Vref(struct device *dev, 682 struct device_attribute *attr, 683 char *buf) 684 { 685 struct iio_dev *dev_info = dev_to_iio_dev(dev); 686 struct adt7316_chip_info *chip = iio_priv(dev_info); 687 688 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX) 689 return -EPERM; 690 691 return sprintf(buf, "%d\n", 692 !!(chip->config3 & ADT7516_AIN_IN_VREF)); 693 } 694 695 static ssize_t adt7316_store_AIN_internal_Vref(struct device *dev, 696 struct device_attribute *attr, 697 const char *buf, 698 size_t len) 699 { 700 struct iio_dev *dev_info = dev_to_iio_dev(dev); 701 struct adt7316_chip_info *chip = iio_priv(dev_info); 702 u8 config3; 703 int ret; 704 705 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX) 706 return -EPERM; 707 708 if (buf[0] != '1') 709 config3 = chip->config3 & (~ADT7516_AIN_IN_VREF); 710 else 711 config3 = chip->config3 | ADT7516_AIN_IN_VREF; 712 713 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3); 714 if (ret) 715 return -EIO; 716 717 chip->config3 = config3; 718 719 return len; 720 } 721 722 static IIO_DEVICE_ATTR(AIN_internal_Vref, S_IRUGO | S_IWUSR, 723 adt7316_show_AIN_internal_Vref, 724 adt7316_store_AIN_internal_Vref, 725 0); 726 727 728 static ssize_t adt7316_show_enable_prop_DACA(struct device *dev, 729 struct device_attribute *attr, 730 char *buf) 731 { 732 struct iio_dev *dev_info = dev_to_iio_dev(dev); 733 struct adt7316_chip_info *chip = iio_priv(dev_info); 734 735 return sprintf(buf, "%d\n", 736 !!(chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)); 737 } 738 739 static ssize_t adt7316_store_enable_prop_DACA(struct device *dev, 740 struct device_attribute *attr, 741 const char *buf, 742 size_t len) 743 { 744 struct iio_dev *dev_info = dev_to_iio_dev(dev); 745 struct adt7316_chip_info *chip = iio_priv(dev_info); 746 u8 config3; 747 int ret; 748 749 config3 = chip->config3 & (~ADT7316_EN_IN_TEMP_PROP_DACA); 750 if (buf[0] == '1') 751 config3 |= ADT7316_EN_IN_TEMP_PROP_DACA; 752 753 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3); 754 if (ret) 755 return -EIO; 756 757 chip->config3 = config3; 758 759 return len; 760 } 761 762 static IIO_DEVICE_ATTR(enable_proportion_DACA, S_IRUGO | S_IWUSR, 763 adt7316_show_enable_prop_DACA, 764 adt7316_store_enable_prop_DACA, 765 0); 766 767 static ssize_t adt7316_show_enable_prop_DACB(struct device *dev, 768 struct device_attribute *attr, 769 char *buf) 770 { 771 struct iio_dev *dev_info = dev_to_iio_dev(dev); 772 struct adt7316_chip_info *chip = iio_priv(dev_info); 773 774 return sprintf(buf, "%d\n", 775 !!(chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB)); 776 } 777 778 static ssize_t adt7316_store_enable_prop_DACB(struct device *dev, 779 struct device_attribute *attr, 780 const char *buf, 781 size_t len) 782 { 783 struct iio_dev *dev_info = dev_to_iio_dev(dev); 784 struct adt7316_chip_info *chip = iio_priv(dev_info); 785 u8 config3; 786 int ret; 787 788 config3 = chip->config3 & (~ADT7316_EN_EX_TEMP_PROP_DACB); 789 if (buf[0] == '1') 790 config3 |= ADT7316_EN_EX_TEMP_PROP_DACB; 791 792 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, config3); 793 if (ret) 794 return -EIO; 795 796 chip->config3 = config3; 797 798 return len; 799 } 800 801 static IIO_DEVICE_ATTR(enable_proportion_DACB, S_IRUGO | S_IWUSR, 802 adt7316_show_enable_prop_DACB, 803 adt7316_store_enable_prop_DACB, 804 0); 805 806 static ssize_t adt7316_show_DAC_2Vref_ch_mask(struct device *dev, 807 struct device_attribute *attr, 808 char *buf) 809 { 810 struct iio_dev *dev_info = dev_to_iio_dev(dev); 811 struct adt7316_chip_info *chip = iio_priv(dev_info); 812 813 return sprintf(buf, "0x%x\n", 814 chip->dac_config & ADT7316_DA_2VREF_CH_MASK); 815 } 816 817 static ssize_t adt7316_store_DAC_2Vref_ch_mask(struct device *dev, 818 struct device_attribute *attr, 819 const char *buf, 820 size_t len) 821 { 822 struct iio_dev *dev_info = dev_to_iio_dev(dev); 823 struct adt7316_chip_info *chip = iio_priv(dev_info); 824 u8 dac_config; 825 u8 data; 826 int ret; 827 828 ret = kstrtou8(buf, 16, &data); 829 if (ret || data > ADT7316_DA_2VREF_CH_MASK) 830 return -EINVAL; 831 832 dac_config = chip->dac_config & (~ADT7316_DA_2VREF_CH_MASK); 833 dac_config |= data; 834 835 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config); 836 if (ret) 837 return -EIO; 838 839 chip->dac_config = dac_config; 840 841 return len; 842 } 843 844 static IIO_DEVICE_ATTR(DAC_2Vref_channels_mask, S_IRUGO | S_IWUSR, 845 adt7316_show_DAC_2Vref_ch_mask, 846 adt7316_store_DAC_2Vref_ch_mask, 847 0); 848 849 static ssize_t adt7316_show_DAC_update_mode(struct device *dev, 850 struct device_attribute *attr, 851 char *buf) 852 { 853 struct iio_dev *dev_info = dev_to_iio_dev(dev); 854 struct adt7316_chip_info *chip = iio_priv(dev_info); 855 856 if (!(chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA)) 857 return sprintf(buf, "manual\n"); 858 859 switch (chip->dac_config & ADT7316_DA_EN_MODE_MASK) { 860 case ADT7316_DA_EN_MODE_SINGLE: 861 return sprintf(buf, 862 "0 - auto at any MSB DAC writing\n"); 863 case ADT7316_DA_EN_MODE_AB_CD: 864 return sprintf(buf, 865 "1 - auto at MSB DAC AB and CD writing\n"); 866 case ADT7316_DA_EN_MODE_ABCD: 867 return sprintf(buf, 868 "2 - auto at MSB DAC ABCD writing\n"); 869 default: /* ADT7316_DA_EN_MODE_LDAC */ 870 return sprintf(buf, "3 - manual\n"); 871 } 872 } 873 874 static ssize_t adt7316_store_DAC_update_mode(struct device *dev, 875 struct device_attribute *attr, 876 const char *buf, 877 size_t len) 878 { 879 struct iio_dev *dev_info = dev_to_iio_dev(dev); 880 struct adt7316_chip_info *chip = iio_priv(dev_info); 881 u8 dac_config; 882 u8 data; 883 int ret; 884 885 if (!(chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA)) 886 return -EPERM; 887 888 ret = kstrtou8(buf, 10, &data); 889 if (ret || data > ADT7316_DA_EN_MODE_MASK) 890 return -EINVAL; 891 892 dac_config = chip->dac_config & (~ADT7316_DA_EN_MODE_MASK); 893 dac_config |= data; 894 895 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config); 896 if (ret) 897 return -EIO; 898 899 chip->dac_config = dac_config; 900 901 return len; 902 } 903 904 static IIO_DEVICE_ATTR(DAC_update_mode, S_IRUGO | S_IWUSR, 905 adt7316_show_DAC_update_mode, 906 adt7316_store_DAC_update_mode, 907 0); 908 909 static ssize_t adt7316_show_all_DAC_update_modes(struct device *dev, 910 struct device_attribute *attr, 911 char *buf) 912 { 913 struct iio_dev *dev_info = dev_to_iio_dev(dev); 914 struct adt7316_chip_info *chip = iio_priv(dev_info); 915 916 if (chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA) 917 return sprintf(buf, "0 - auto at any MSB DAC writing\n" 918 "1 - auto at MSB DAC AB and CD writing\n" 919 "2 - auto at MSB DAC ABCD writing\n" 920 "3 - manual\n"); 921 return sprintf(buf, "manual\n"); 922 } 923 924 static IIO_DEVICE_ATTR(all_DAC_update_modes, S_IRUGO, 925 adt7316_show_all_DAC_update_modes, NULL, 0); 926 927 928 static ssize_t adt7316_store_update_DAC(struct device *dev, 929 struct device_attribute *attr, 930 const char *buf, 931 size_t len) 932 { 933 struct iio_dev *dev_info = dev_to_iio_dev(dev); 934 struct adt7316_chip_info *chip = iio_priv(dev_info); 935 u8 ldac_config; 936 u8 data; 937 int ret; 938 939 if (chip->config3 & ADT7316_DA_EN_VIA_DAC_LDCA) { 940 if ((chip->dac_config & ADT7316_DA_EN_MODE_MASK) != 941 ADT7316_DA_EN_MODE_LDAC) 942 return -EPERM; 943 944 ret = kstrtou8(buf, 16, &data); 945 if (ret || data > ADT7316_LDAC_EN_DA_MASK) 946 return -EINVAL; 947 948 ldac_config = chip->ldac_config & (~ADT7316_LDAC_EN_DA_MASK); 949 ldac_config |= data; 950 951 ret = chip->bus.write(chip->bus.client, ADT7316_LDAC_CONFIG, 952 ldac_config); 953 if (ret) 954 return -EIO; 955 } else { 956 gpio_set_value(chip->ldac_pin, 0); 957 gpio_set_value(chip->ldac_pin, 1); 958 } 959 960 return len; 961 } 962 963 static IIO_DEVICE_ATTR(update_DAC, S_IRUGO | S_IWUSR, 964 NULL, 965 adt7316_store_update_DAC, 966 0); 967 968 static ssize_t adt7316_show_DA_AB_Vref_bypass(struct device *dev, 969 struct device_attribute *attr, 970 char *buf) 971 { 972 struct iio_dev *dev_info = dev_to_iio_dev(dev); 973 struct adt7316_chip_info *chip = iio_priv(dev_info); 974 975 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) 976 return -EPERM; 977 978 return sprintf(buf, "%d\n", 979 !!(chip->dac_config & ADT7316_VREF_BYPASS_DAC_AB)); 980 } 981 982 static ssize_t adt7316_store_DA_AB_Vref_bypass(struct device *dev, 983 struct device_attribute *attr, 984 const char *buf, 985 size_t len) 986 { 987 struct iio_dev *dev_info = dev_to_iio_dev(dev); 988 struct adt7316_chip_info *chip = iio_priv(dev_info); 989 u8 dac_config; 990 int ret; 991 992 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) 993 return -EPERM; 994 995 dac_config = chip->dac_config & (~ADT7316_VREF_BYPASS_DAC_AB); 996 if (buf[0] == '1') 997 dac_config |= ADT7316_VREF_BYPASS_DAC_AB; 998 999 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config); 1000 if (ret) 1001 return -EIO; 1002 1003 chip->dac_config = dac_config; 1004 1005 return len; 1006 } 1007 1008 static IIO_DEVICE_ATTR(DA_AB_Vref_bypass, S_IRUGO | S_IWUSR, 1009 adt7316_show_DA_AB_Vref_bypass, 1010 adt7316_store_DA_AB_Vref_bypass, 1011 0); 1012 1013 static ssize_t adt7316_show_DA_CD_Vref_bypass(struct device *dev, 1014 struct device_attribute *attr, 1015 char *buf) 1016 { 1017 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1018 struct adt7316_chip_info *chip = iio_priv(dev_info); 1019 1020 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) 1021 return -EPERM; 1022 1023 return sprintf(buf, "%d\n", 1024 !!(chip->dac_config & ADT7316_VREF_BYPASS_DAC_CD)); 1025 } 1026 1027 static ssize_t adt7316_store_DA_CD_Vref_bypass(struct device *dev, 1028 struct device_attribute *attr, 1029 const char *buf, 1030 size_t len) 1031 { 1032 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1033 struct adt7316_chip_info *chip = iio_priv(dev_info); 1034 u8 dac_config; 1035 int ret; 1036 1037 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) 1038 return -EPERM; 1039 1040 dac_config = chip->dac_config & (~ADT7316_VREF_BYPASS_DAC_CD); 1041 if (buf[0] == '1') 1042 dac_config |= ADT7316_VREF_BYPASS_DAC_CD; 1043 1044 ret = chip->bus.write(chip->bus.client, ADT7316_DAC_CONFIG, dac_config); 1045 if (ret) 1046 return -EIO; 1047 1048 chip->dac_config = dac_config; 1049 1050 return len; 1051 } 1052 1053 static IIO_DEVICE_ATTR(DA_CD_Vref_bypass, S_IRUGO | S_IWUSR, 1054 adt7316_show_DA_CD_Vref_bypass, 1055 adt7316_store_DA_CD_Vref_bypass, 1056 0); 1057 1058 static ssize_t adt7316_show_DAC_internal_Vref(struct device *dev, 1059 struct device_attribute *attr, 1060 char *buf) 1061 { 1062 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1063 struct adt7316_chip_info *chip = iio_priv(dev_info); 1064 1065 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) 1066 return sprintf(buf, "0x%x\n", 1067 (chip->dac_config & ADT7516_DAC_IN_VREF_MASK) >> 1068 ADT7516_DAC_IN_VREF_OFFSET); 1069 return sprintf(buf, "%d\n", 1070 !!(chip->dac_config & ADT7316_DAC_IN_VREF)); 1071 } 1072 1073 static ssize_t adt7316_store_DAC_internal_Vref(struct device *dev, 1074 struct device_attribute *attr, 1075 const char *buf, 1076 size_t len) 1077 { 1078 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1079 struct adt7316_chip_info *chip = iio_priv(dev_info); 1080 u8 ldac_config; 1081 u8 data; 1082 int ret; 1083 1084 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) { 1085 ret = kstrtou8(buf, 16, &data); 1086 if (ret || data > 3) 1087 return -EINVAL; 1088 1089 ldac_config = chip->ldac_config & (~ADT7516_DAC_IN_VREF_MASK); 1090 if (data & 0x1) 1091 ldac_config |= ADT7516_DAC_AB_IN_VREF; 1092 else if (data & 0x2) 1093 ldac_config |= ADT7516_DAC_CD_IN_VREF; 1094 } else { 1095 ret = kstrtou8(buf, 16, &data); 1096 if (ret) 1097 return -EINVAL; 1098 1099 ldac_config = chip->ldac_config & (~ADT7316_DAC_IN_VREF); 1100 if (data) 1101 ldac_config = chip->ldac_config | ADT7316_DAC_IN_VREF; 1102 } 1103 1104 ret = chip->bus.write(chip->bus.client, ADT7316_LDAC_CONFIG, 1105 ldac_config); 1106 if (ret) 1107 return -EIO; 1108 1109 chip->ldac_config = ldac_config; 1110 1111 return len; 1112 } 1113 1114 static IIO_DEVICE_ATTR(DAC_internal_Vref, S_IRUGO | S_IWUSR, 1115 adt7316_show_DAC_internal_Vref, 1116 adt7316_store_DAC_internal_Vref, 1117 0); 1118 1119 static ssize_t adt7316_show_ad(struct adt7316_chip_info *chip, 1120 int channel, char *buf) 1121 { 1122 u16 data; 1123 u8 msb, lsb; 1124 char sign = ' '; 1125 int ret; 1126 1127 if ((chip->config2 & ADT7316_AD_SINGLE_CH_MODE) && 1128 channel != (chip->config2 & ADT7516_AD_SINGLE_CH_MASK)) 1129 return -EPERM; 1130 1131 switch (channel) { 1132 case ADT7316_AD_SINGLE_CH_IN: 1133 ret = chip->bus.read(chip->bus.client, 1134 ADT7316_LSB_IN_TEMP_VDD, &lsb); 1135 if (ret) 1136 return -EIO; 1137 1138 ret = chip->bus.read(chip->bus.client, 1139 ADT7316_AD_MSB_DATA_BASE + channel, &msb); 1140 if (ret) 1141 return -EIO; 1142 1143 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET; 1144 data |= lsb & ADT7316_LSB_IN_TEMP_MASK; 1145 break; 1146 case ADT7316_AD_SINGLE_CH_VDD: 1147 ret = chip->bus.read(chip->bus.client, 1148 ADT7316_LSB_IN_TEMP_VDD, &lsb); 1149 if (ret) 1150 return -EIO; 1151 1152 ret = chip->bus.read(chip->bus.client, 1153 1154 ADT7316_AD_MSB_DATA_BASE + channel, &msb); 1155 if (ret) 1156 return -EIO; 1157 1158 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET; 1159 data |= (lsb & ADT7316_LSB_VDD_MASK) >> ADT7316_LSB_VDD_OFFSET; 1160 return sprintf(buf, "%d\n", data); 1161 default: /* ex_temp and ain */ 1162 ret = chip->bus.read(chip->bus.client, 1163 ADT7316_LSB_EX_TEMP_AIN, &lsb); 1164 if (ret) 1165 return -EIO; 1166 1167 ret = chip->bus.read(chip->bus.client, 1168 ADT7316_AD_MSB_DATA_BASE + channel, &msb); 1169 if (ret) 1170 return -EIO; 1171 1172 data = msb << ADT7316_T_VALUE_FLOAT_OFFSET; 1173 data |= lsb & (ADT7316_LSB_EX_TEMP_MASK << 1174 (ADT7516_LSB_AIN_SHIFT * (channel - 1175 (ADT7316_MSB_EX_TEMP - ADT7316_AD_MSB_DATA_BASE)))); 1176 1177 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) 1178 return sprintf(buf, "%d\n", data); 1179 1180 break; 1181 } 1182 1183 if (data & ADT7316_T_VALUE_SIGN) { 1184 /* convert supplement to positive value */ 1185 data = (ADT7316_T_VALUE_SIGN << 1) - data; 1186 sign = '-'; 1187 } 1188 1189 return sprintf(buf, "%c%d.%.2d\n", sign, 1190 (data >> ADT7316_T_VALUE_FLOAT_OFFSET), 1191 (data & ADT7316_T_VALUE_FLOAT_MASK) * 25); 1192 } 1193 1194 static ssize_t adt7316_show_VDD(struct device *dev, 1195 struct device_attribute *attr, 1196 char *buf) 1197 { 1198 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1199 struct adt7316_chip_info *chip = iio_priv(dev_info); 1200 1201 return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_VDD, buf); 1202 } 1203 static IIO_DEVICE_ATTR(VDD, S_IRUGO, adt7316_show_VDD, NULL, 0); 1204 1205 static ssize_t adt7316_show_in_temp(struct device *dev, 1206 struct device_attribute *attr, 1207 char *buf) 1208 { 1209 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1210 struct adt7316_chip_info *chip = iio_priv(dev_info); 1211 1212 return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_IN, buf); 1213 } 1214 1215 static IIO_DEVICE_ATTR(in_temp, S_IRUGO, adt7316_show_in_temp, NULL, 0); 1216 1217 static ssize_t adt7316_show_ex_temp_AIN1(struct device *dev, 1218 struct device_attribute *attr, 1219 char *buf) 1220 { 1221 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1222 struct adt7316_chip_info *chip = iio_priv(dev_info); 1223 1224 return adt7316_show_ad(chip, ADT7316_AD_SINGLE_CH_EX, buf); 1225 } 1226 1227 static IIO_DEVICE_ATTR(ex_temp_AIN1, S_IRUGO, adt7316_show_ex_temp_AIN1, 1228 NULL, 0); 1229 static IIO_DEVICE_ATTR(ex_temp, S_IRUGO, adt7316_show_ex_temp_AIN1, NULL, 0); 1230 1231 static ssize_t adt7316_show_AIN2(struct device *dev, 1232 struct device_attribute *attr, 1233 char *buf) 1234 { 1235 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1236 struct adt7316_chip_info *chip = iio_priv(dev_info); 1237 1238 return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN2, buf); 1239 } 1240 static IIO_DEVICE_ATTR(AIN2, S_IRUGO, adt7316_show_AIN2, NULL, 0); 1241 1242 static ssize_t adt7316_show_AIN3(struct device *dev, 1243 struct device_attribute *attr, 1244 char *buf) 1245 { 1246 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1247 struct adt7316_chip_info *chip = iio_priv(dev_info); 1248 1249 return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN3, buf); 1250 } 1251 static IIO_DEVICE_ATTR(AIN3, S_IRUGO, adt7316_show_AIN3, NULL, 0); 1252 1253 static ssize_t adt7316_show_AIN4(struct device *dev, 1254 struct device_attribute *attr, 1255 char *buf) 1256 { 1257 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1258 struct adt7316_chip_info *chip = iio_priv(dev_info); 1259 1260 return adt7316_show_ad(chip, ADT7516_AD_SINGLE_CH_AIN4, buf); 1261 } 1262 static IIO_DEVICE_ATTR(AIN4, S_IRUGO, adt7316_show_AIN4, NULL, 0); 1263 1264 static ssize_t adt7316_show_temp_offset(struct adt7316_chip_info *chip, 1265 int offset_addr, char *buf) 1266 { 1267 int data; 1268 u8 val; 1269 int ret; 1270 1271 ret = chip->bus.read(chip->bus.client, offset_addr, &val); 1272 if (ret) 1273 return -EIO; 1274 1275 data = (int)val; 1276 if (val & 0x80) 1277 data -= 256; 1278 1279 return sprintf(buf, "%d\n", data); 1280 } 1281 1282 static ssize_t adt7316_store_temp_offset(struct adt7316_chip_info *chip, 1283 int offset_addr, const char *buf, size_t len) 1284 { 1285 int data; 1286 u8 val; 1287 int ret; 1288 1289 ret = kstrtoint(buf, 10, &data); 1290 if (ret || data > 127 || data < -128) 1291 return -EINVAL; 1292 1293 if (data < 0) 1294 data += 256; 1295 1296 val = (u8)data; 1297 1298 ret = chip->bus.write(chip->bus.client, offset_addr, val); 1299 if (ret) 1300 return -EIO; 1301 1302 return len; 1303 } 1304 1305 static ssize_t adt7316_show_in_temp_offset(struct device *dev, 1306 struct device_attribute *attr, 1307 char *buf) 1308 { 1309 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1310 struct adt7316_chip_info *chip = iio_priv(dev_info); 1311 1312 return adt7316_show_temp_offset(chip, ADT7316_IN_TEMP_OFFSET, buf); 1313 } 1314 1315 static ssize_t adt7316_store_in_temp_offset(struct device *dev, 1316 struct device_attribute *attr, 1317 const char *buf, 1318 size_t len) 1319 { 1320 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1321 struct adt7316_chip_info *chip = iio_priv(dev_info); 1322 1323 return adt7316_store_temp_offset(chip, ADT7316_IN_TEMP_OFFSET, buf, 1324 len); 1325 } 1326 1327 static IIO_DEVICE_ATTR(in_temp_offset, S_IRUGO | S_IWUSR, 1328 adt7316_show_in_temp_offset, 1329 adt7316_store_in_temp_offset, 0); 1330 1331 static ssize_t adt7316_show_ex_temp_offset(struct device *dev, 1332 struct device_attribute *attr, 1333 char *buf) 1334 { 1335 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1336 struct adt7316_chip_info *chip = iio_priv(dev_info); 1337 1338 return adt7316_show_temp_offset(chip, ADT7316_EX_TEMP_OFFSET, buf); 1339 } 1340 1341 static ssize_t adt7316_store_ex_temp_offset(struct device *dev, 1342 struct device_attribute *attr, 1343 const char *buf, 1344 size_t len) 1345 { 1346 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1347 struct adt7316_chip_info *chip = iio_priv(dev_info); 1348 1349 return adt7316_store_temp_offset(chip, ADT7316_EX_TEMP_OFFSET, buf, 1350 len); 1351 } 1352 1353 static IIO_DEVICE_ATTR(ex_temp_offset, S_IRUGO | S_IWUSR, 1354 adt7316_show_ex_temp_offset, 1355 adt7316_store_ex_temp_offset, 0); 1356 1357 static ssize_t adt7316_show_in_analog_temp_offset(struct device *dev, 1358 struct device_attribute *attr, 1359 char *buf) 1360 { 1361 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1362 struct adt7316_chip_info *chip = iio_priv(dev_info); 1363 1364 return adt7316_show_temp_offset(chip, 1365 ADT7316_IN_ANALOG_TEMP_OFFSET, buf); 1366 } 1367 1368 static ssize_t adt7316_store_in_analog_temp_offset(struct device *dev, 1369 struct device_attribute *attr, 1370 const char *buf, 1371 size_t len) 1372 { 1373 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1374 struct adt7316_chip_info *chip = iio_priv(dev_info); 1375 1376 return adt7316_store_temp_offset(chip, 1377 ADT7316_IN_ANALOG_TEMP_OFFSET, buf, len); 1378 } 1379 1380 static IIO_DEVICE_ATTR(in_analog_temp_offset, S_IRUGO | S_IWUSR, 1381 adt7316_show_in_analog_temp_offset, 1382 adt7316_store_in_analog_temp_offset, 0); 1383 1384 static ssize_t adt7316_show_ex_analog_temp_offset(struct device *dev, 1385 struct device_attribute *attr, 1386 char *buf) 1387 { 1388 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1389 struct adt7316_chip_info *chip = iio_priv(dev_info); 1390 1391 return adt7316_show_temp_offset(chip, 1392 ADT7316_EX_ANALOG_TEMP_OFFSET, buf); 1393 } 1394 1395 static ssize_t adt7316_store_ex_analog_temp_offset(struct device *dev, 1396 struct device_attribute *attr, 1397 const char *buf, 1398 size_t len) 1399 { 1400 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1401 struct adt7316_chip_info *chip = iio_priv(dev_info); 1402 1403 return adt7316_store_temp_offset(chip, 1404 ADT7316_EX_ANALOG_TEMP_OFFSET, buf, len); 1405 } 1406 1407 static IIO_DEVICE_ATTR(ex_analog_temp_offset, S_IRUGO | S_IWUSR, 1408 adt7316_show_ex_analog_temp_offset, 1409 adt7316_store_ex_analog_temp_offset, 0); 1410 1411 static ssize_t adt7316_show_DAC(struct adt7316_chip_info *chip, 1412 int channel, char *buf) 1413 { 1414 u16 data; 1415 u8 msb, lsb, offset; 1416 int ret; 1417 1418 if (channel >= ADT7316_DA_MSB_DATA_REGS || 1419 (channel == 0 && 1420 (chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)) || 1421 (channel == 1 && 1422 (chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB))) 1423 return -EPERM; 1424 1425 offset = chip->dac_bits - 8; 1426 1427 if (chip->dac_bits > 8) { 1428 ret = chip->bus.read(chip->bus.client, 1429 ADT7316_DA_DATA_BASE + channel * 2, &lsb); 1430 if (ret) 1431 return -EIO; 1432 } 1433 1434 ret = chip->bus.read(chip->bus.client, 1435 ADT7316_DA_DATA_BASE + 1 + channel * 2, &msb); 1436 if (ret) 1437 return -EIO; 1438 1439 data = (msb << offset) + (lsb & ((1 << offset) - 1)); 1440 1441 return sprintf(buf, "%d\n", data); 1442 } 1443 1444 static ssize_t adt7316_store_DAC(struct adt7316_chip_info *chip, 1445 int channel, const char *buf, size_t len) 1446 { 1447 u8 msb, lsb, offset; 1448 u16 data; 1449 int ret; 1450 1451 if (channel >= ADT7316_DA_MSB_DATA_REGS || 1452 (channel == 0 && 1453 (chip->config3 & ADT7316_EN_IN_TEMP_PROP_DACA)) || 1454 (channel == 1 && 1455 (chip->config3 & ADT7316_EN_EX_TEMP_PROP_DACB))) 1456 return -EPERM; 1457 1458 offset = chip->dac_bits - 8; 1459 1460 ret = kstrtou16(buf, 10, &data); 1461 if (ret || data >= (1 << chip->dac_bits)) 1462 return -EINVAL; 1463 1464 if (chip->dac_bits > 8) { 1465 lsb = data & (1 << offset); 1466 ret = chip->bus.write(chip->bus.client, 1467 ADT7316_DA_DATA_BASE + channel * 2, lsb); 1468 if (ret) 1469 return -EIO; 1470 } 1471 1472 msb = data >> offset; 1473 ret = chip->bus.write(chip->bus.client, 1474 ADT7316_DA_DATA_BASE + 1 + channel * 2, msb); 1475 if (ret) 1476 return -EIO; 1477 1478 return len; 1479 } 1480 1481 static ssize_t adt7316_show_DAC_A(struct device *dev, 1482 struct device_attribute *attr, 1483 char *buf) 1484 { 1485 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1486 struct adt7316_chip_info *chip = iio_priv(dev_info); 1487 1488 return adt7316_show_DAC(chip, 0, buf); 1489 } 1490 1491 static ssize_t adt7316_store_DAC_A(struct device *dev, 1492 struct device_attribute *attr, 1493 const char *buf, 1494 size_t len) 1495 { 1496 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1497 struct adt7316_chip_info *chip = iio_priv(dev_info); 1498 1499 return adt7316_store_DAC(chip, 0, buf, len); 1500 } 1501 1502 static IIO_DEVICE_ATTR(DAC_A, S_IRUGO | S_IWUSR, adt7316_show_DAC_A, 1503 adt7316_store_DAC_A, 0); 1504 1505 static ssize_t adt7316_show_DAC_B(struct device *dev, 1506 struct device_attribute *attr, 1507 char *buf) 1508 { 1509 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1510 struct adt7316_chip_info *chip = iio_priv(dev_info); 1511 1512 return adt7316_show_DAC(chip, 1, buf); 1513 } 1514 1515 static ssize_t adt7316_store_DAC_B(struct device *dev, 1516 struct device_attribute *attr, 1517 const char *buf, 1518 size_t len) 1519 { 1520 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1521 struct adt7316_chip_info *chip = iio_priv(dev_info); 1522 1523 return adt7316_store_DAC(chip, 1, buf, len); 1524 } 1525 1526 static IIO_DEVICE_ATTR(DAC_B, S_IRUGO | S_IWUSR, adt7316_show_DAC_B, 1527 adt7316_store_DAC_B, 0); 1528 1529 static ssize_t adt7316_show_DAC_C(struct device *dev, 1530 struct device_attribute *attr, 1531 char *buf) 1532 { 1533 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1534 struct adt7316_chip_info *chip = iio_priv(dev_info); 1535 1536 return adt7316_show_DAC(chip, 2, buf); 1537 } 1538 1539 static ssize_t adt7316_store_DAC_C(struct device *dev, 1540 struct device_attribute *attr, 1541 const char *buf, 1542 size_t len) 1543 { 1544 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1545 struct adt7316_chip_info *chip = iio_priv(dev_info); 1546 1547 return adt7316_store_DAC(chip, 2, buf, len); 1548 } 1549 1550 static IIO_DEVICE_ATTR(DAC_C, S_IRUGO | S_IWUSR, adt7316_show_DAC_C, 1551 adt7316_store_DAC_C, 0); 1552 1553 static ssize_t adt7316_show_DAC_D(struct device *dev, 1554 struct device_attribute *attr, 1555 char *buf) 1556 { 1557 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1558 struct adt7316_chip_info *chip = iio_priv(dev_info); 1559 1560 return adt7316_show_DAC(chip, 3, buf); 1561 } 1562 1563 static ssize_t adt7316_store_DAC_D(struct device *dev, 1564 struct device_attribute *attr, 1565 const char *buf, 1566 size_t len) 1567 { 1568 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1569 struct adt7316_chip_info *chip = iio_priv(dev_info); 1570 1571 return adt7316_store_DAC(chip, 3, buf, len); 1572 } 1573 1574 static IIO_DEVICE_ATTR(DAC_D, S_IRUGO | S_IWUSR, adt7316_show_DAC_D, 1575 adt7316_store_DAC_D, 0); 1576 1577 static ssize_t adt7316_show_device_id(struct device *dev, 1578 struct device_attribute *attr, 1579 char *buf) 1580 { 1581 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1582 struct adt7316_chip_info *chip = iio_priv(dev_info); 1583 u8 id; 1584 int ret; 1585 1586 ret = chip->bus.read(chip->bus.client, ADT7316_DEVICE_ID, &id); 1587 if (ret) 1588 return -EIO; 1589 1590 return sprintf(buf, "%d\n", id); 1591 } 1592 1593 static IIO_DEVICE_ATTR(device_id, S_IRUGO, adt7316_show_device_id, NULL, 0); 1594 1595 static ssize_t adt7316_show_manufactorer_id(struct device *dev, 1596 struct device_attribute *attr, 1597 char *buf) 1598 { 1599 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1600 struct adt7316_chip_info *chip = iio_priv(dev_info); 1601 u8 id; 1602 int ret; 1603 1604 ret = chip->bus.read(chip->bus.client, ADT7316_MANUFACTURE_ID, &id); 1605 if (ret) 1606 return -EIO; 1607 1608 return sprintf(buf, "%d\n", id); 1609 } 1610 1611 static IIO_DEVICE_ATTR(manufactorer_id, S_IRUGO, 1612 adt7316_show_manufactorer_id, NULL, 0); 1613 1614 static ssize_t adt7316_show_device_rev(struct device *dev, 1615 struct device_attribute *attr, 1616 char *buf) 1617 { 1618 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1619 struct adt7316_chip_info *chip = iio_priv(dev_info); 1620 u8 rev; 1621 int ret; 1622 1623 ret = chip->bus.read(chip->bus.client, ADT7316_DEVICE_REV, &rev); 1624 if (ret) 1625 return -EIO; 1626 1627 return sprintf(buf, "%d\n", rev); 1628 } 1629 1630 static IIO_DEVICE_ATTR(device_rev, S_IRUGO, adt7316_show_device_rev, NULL, 0); 1631 1632 static ssize_t adt7316_show_bus_type(struct device *dev, 1633 struct device_attribute *attr, 1634 char *buf) 1635 { 1636 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1637 struct adt7316_chip_info *chip = iio_priv(dev_info); 1638 u8 stat; 1639 int ret; 1640 1641 ret = chip->bus.read(chip->bus.client, ADT7316_SPI_LOCK_STAT, &stat); 1642 if (ret) 1643 return -EIO; 1644 1645 if (stat) 1646 return sprintf(buf, "spi\n"); 1647 1648 return sprintf(buf, "i2c\n"); 1649 } 1650 1651 static IIO_DEVICE_ATTR(bus_type, S_IRUGO, adt7316_show_bus_type, NULL, 0); 1652 1653 static struct attribute *adt7316_attributes[] = { 1654 &iio_dev_attr_all_modes.dev_attr.attr, 1655 &iio_dev_attr_mode.dev_attr.attr, 1656 &iio_dev_attr_enabled.dev_attr.attr, 1657 &iio_dev_attr_ad_channel.dev_attr.attr, 1658 &iio_dev_attr_all_ad_channels.dev_attr.attr, 1659 &iio_dev_attr_disable_averaging.dev_attr.attr, 1660 &iio_dev_attr_enable_smbus_timeout.dev_attr.attr, 1661 &iio_dev_attr_powerdown.dev_attr.attr, 1662 &iio_dev_attr_fast_ad_clock.dev_attr.attr, 1663 &iio_dev_attr_da_high_resolution.dev_attr.attr, 1664 &iio_dev_attr_enable_proportion_DACA.dev_attr.attr, 1665 &iio_dev_attr_enable_proportion_DACB.dev_attr.attr, 1666 &iio_dev_attr_DAC_2Vref_channels_mask.dev_attr.attr, 1667 &iio_dev_attr_DAC_update_mode.dev_attr.attr, 1668 &iio_dev_attr_all_DAC_update_modes.dev_attr.attr, 1669 &iio_dev_attr_update_DAC.dev_attr.attr, 1670 &iio_dev_attr_DA_AB_Vref_bypass.dev_attr.attr, 1671 &iio_dev_attr_DA_CD_Vref_bypass.dev_attr.attr, 1672 &iio_dev_attr_DAC_internal_Vref.dev_attr.attr, 1673 &iio_dev_attr_VDD.dev_attr.attr, 1674 &iio_dev_attr_in_temp.dev_attr.attr, 1675 &iio_dev_attr_ex_temp.dev_attr.attr, 1676 &iio_dev_attr_in_temp_offset.dev_attr.attr, 1677 &iio_dev_attr_ex_temp_offset.dev_attr.attr, 1678 &iio_dev_attr_in_analog_temp_offset.dev_attr.attr, 1679 &iio_dev_attr_ex_analog_temp_offset.dev_attr.attr, 1680 &iio_dev_attr_DAC_A.dev_attr.attr, 1681 &iio_dev_attr_DAC_B.dev_attr.attr, 1682 &iio_dev_attr_DAC_C.dev_attr.attr, 1683 &iio_dev_attr_DAC_D.dev_attr.attr, 1684 &iio_dev_attr_device_id.dev_attr.attr, 1685 &iio_dev_attr_manufactorer_id.dev_attr.attr, 1686 &iio_dev_attr_device_rev.dev_attr.attr, 1687 &iio_dev_attr_bus_type.dev_attr.attr, 1688 NULL, 1689 }; 1690 1691 static const struct attribute_group adt7316_attribute_group = { 1692 .attrs = adt7316_attributes, 1693 }; 1694 1695 static struct attribute *adt7516_attributes[] = { 1696 &iio_dev_attr_all_modes.dev_attr.attr, 1697 &iio_dev_attr_mode.dev_attr.attr, 1698 &iio_dev_attr_select_ex_temp.dev_attr.attr, 1699 &iio_dev_attr_enabled.dev_attr.attr, 1700 &iio_dev_attr_ad_channel.dev_attr.attr, 1701 &iio_dev_attr_all_ad_channels.dev_attr.attr, 1702 &iio_dev_attr_disable_averaging.dev_attr.attr, 1703 &iio_dev_attr_enable_smbus_timeout.dev_attr.attr, 1704 &iio_dev_attr_powerdown.dev_attr.attr, 1705 &iio_dev_attr_fast_ad_clock.dev_attr.attr, 1706 &iio_dev_attr_AIN_internal_Vref.dev_attr.attr, 1707 &iio_dev_attr_da_high_resolution.dev_attr.attr, 1708 &iio_dev_attr_enable_proportion_DACA.dev_attr.attr, 1709 &iio_dev_attr_enable_proportion_DACB.dev_attr.attr, 1710 &iio_dev_attr_DAC_2Vref_channels_mask.dev_attr.attr, 1711 &iio_dev_attr_DAC_update_mode.dev_attr.attr, 1712 &iio_dev_attr_all_DAC_update_modes.dev_attr.attr, 1713 &iio_dev_attr_update_DAC.dev_attr.attr, 1714 &iio_dev_attr_DA_AB_Vref_bypass.dev_attr.attr, 1715 &iio_dev_attr_DA_CD_Vref_bypass.dev_attr.attr, 1716 &iio_dev_attr_DAC_internal_Vref.dev_attr.attr, 1717 &iio_dev_attr_VDD.dev_attr.attr, 1718 &iio_dev_attr_in_temp.dev_attr.attr, 1719 &iio_dev_attr_ex_temp_AIN1.dev_attr.attr, 1720 &iio_dev_attr_AIN2.dev_attr.attr, 1721 &iio_dev_attr_AIN3.dev_attr.attr, 1722 &iio_dev_attr_AIN4.dev_attr.attr, 1723 &iio_dev_attr_in_temp_offset.dev_attr.attr, 1724 &iio_dev_attr_ex_temp_offset.dev_attr.attr, 1725 &iio_dev_attr_in_analog_temp_offset.dev_attr.attr, 1726 &iio_dev_attr_ex_analog_temp_offset.dev_attr.attr, 1727 &iio_dev_attr_DAC_A.dev_attr.attr, 1728 &iio_dev_attr_DAC_B.dev_attr.attr, 1729 &iio_dev_attr_DAC_C.dev_attr.attr, 1730 &iio_dev_attr_DAC_D.dev_attr.attr, 1731 &iio_dev_attr_device_id.dev_attr.attr, 1732 &iio_dev_attr_manufactorer_id.dev_attr.attr, 1733 &iio_dev_attr_device_rev.dev_attr.attr, 1734 &iio_dev_attr_bus_type.dev_attr.attr, 1735 NULL, 1736 }; 1737 1738 static const struct attribute_group adt7516_attribute_group = { 1739 .attrs = adt7516_attributes, 1740 }; 1741 1742 static irqreturn_t adt7316_event_handler(int irq, void *private) 1743 { 1744 struct iio_dev *indio_dev = private; 1745 struct adt7316_chip_info *chip = iio_priv(indio_dev); 1746 u8 stat1, stat2; 1747 int ret; 1748 s64 time; 1749 1750 ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT1, &stat1); 1751 if (!ret) { 1752 if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX) 1753 stat1 &= 0x1F; 1754 1755 time = iio_get_time_ns(); 1756 if (stat1 & BIT(0)) 1757 iio_push_event(indio_dev, 1758 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0, 1759 IIO_EV_TYPE_THRESH, 1760 IIO_EV_DIR_RISING), 1761 time); 1762 if (stat1 & BIT(1)) 1763 iio_push_event(indio_dev, 1764 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0, 1765 IIO_EV_TYPE_THRESH, 1766 IIO_EV_DIR_FALLING), 1767 time); 1768 if (stat1 & BIT(2)) 1769 iio_push_event(indio_dev, 1770 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1, 1771 IIO_EV_TYPE_THRESH, 1772 IIO_EV_DIR_RISING), 1773 time); 1774 if (stat1 & BIT(3)) 1775 iio_push_event(indio_dev, 1776 IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1, 1777 IIO_EV_TYPE_THRESH, 1778 IIO_EV_DIR_FALLING), 1779 time); 1780 if (stat1 & BIT(5)) 1781 iio_push_event(indio_dev, 1782 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 1, 1783 IIO_EV_TYPE_THRESH, 1784 IIO_EV_DIR_EITHER), 1785 time); 1786 if (stat1 & BIT(6)) 1787 iio_push_event(indio_dev, 1788 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 2, 1789 IIO_EV_TYPE_THRESH, 1790 IIO_EV_DIR_EITHER), 1791 time); 1792 if (stat1 & BIT(7)) 1793 iio_push_event(indio_dev, 1794 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 3, 1795 IIO_EV_TYPE_THRESH, 1796 IIO_EV_DIR_EITHER), 1797 time); 1798 } 1799 ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT2, &stat2); 1800 if (!ret) { 1801 if (stat2 & ADT7316_INT_MASK2_VDD) 1802 iio_push_event(indio_dev, 1803 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 1804 0, 1805 IIO_EV_TYPE_THRESH, 1806 IIO_EV_DIR_RISING), 1807 iio_get_time_ns()); 1808 } 1809 1810 return IRQ_HANDLED; 1811 } 1812 1813 /* 1814 * Show mask of enabled interrupts in Hex. 1815 */ 1816 static ssize_t adt7316_show_int_mask(struct device *dev, 1817 struct device_attribute *attr, 1818 char *buf) 1819 { 1820 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1821 struct adt7316_chip_info *chip = iio_priv(dev_info); 1822 1823 return sprintf(buf, "0x%x\n", chip->int_mask); 1824 } 1825 1826 /* 1827 * Set 1 to the mask in Hex to enabled interrupts. 1828 */ 1829 static ssize_t adt7316_set_int_mask(struct device *dev, 1830 struct device_attribute *attr, 1831 const char *buf, 1832 size_t len) 1833 { 1834 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1835 struct adt7316_chip_info *chip = iio_priv(dev_info); 1836 u16 data; 1837 int ret; 1838 u8 mask; 1839 1840 ret = kstrtou16(buf, 16, &data); 1841 if (ret || data >= ADT7316_VDD_INT_MASK + 1) 1842 return -EINVAL; 1843 1844 if (data & ADT7316_VDD_INT_MASK) 1845 mask = 0; /* enable vdd int */ 1846 else 1847 mask = ADT7316_INT_MASK2_VDD; /* disable vdd int */ 1848 1849 ret = chip->bus.write(chip->bus.client, ADT7316_INT_MASK2, mask); 1850 if (!ret) { 1851 chip->int_mask &= ~ADT7316_VDD_INT_MASK; 1852 chip->int_mask |= data & ADT7316_VDD_INT_MASK; 1853 } 1854 1855 if (data & ADT7316_TEMP_AIN_INT_MASK) { 1856 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX) 1857 /* mask in reg is opposite, set 1 to disable */ 1858 mask = (~data) & ADT7316_TEMP_INT_MASK; 1859 else 1860 /* mask in reg is opposite, set 1 to disable */ 1861 mask = (~data) & ADT7316_TEMP_AIN_INT_MASK; 1862 } 1863 ret = chip->bus.write(chip->bus.client, ADT7316_INT_MASK1, mask); 1864 1865 chip->int_mask = mask; 1866 1867 return len; 1868 } 1869 static inline ssize_t adt7316_show_ad_bound(struct device *dev, 1870 struct device_attribute *attr, 1871 char *buf) 1872 { 1873 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 1874 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1875 struct adt7316_chip_info *chip = iio_priv(dev_info); 1876 u8 val; 1877 int data; 1878 int ret; 1879 1880 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX && 1881 this_attr->address > ADT7316_EX_TEMP_LOW) 1882 return -EPERM; 1883 1884 ret = chip->bus.read(chip->bus.client, this_attr->address, &val); 1885 if (ret) 1886 return -EIO; 1887 1888 data = (int)val; 1889 1890 if (!((chip->id & ID_FAMILY_MASK) == ID_ADT75XX && 1891 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0)) { 1892 if (data & 0x80) 1893 data -= 256; 1894 } 1895 1896 return sprintf(buf, "%d\n", data); 1897 } 1898 1899 static inline ssize_t adt7316_set_ad_bound(struct device *dev, 1900 struct device_attribute *attr, 1901 const char *buf, 1902 size_t len) 1903 { 1904 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 1905 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1906 struct adt7316_chip_info *chip = iio_priv(dev_info); 1907 int data; 1908 u8 val; 1909 int ret; 1910 1911 if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX && 1912 this_attr->address > ADT7316_EX_TEMP_LOW) 1913 return -EPERM; 1914 1915 ret = kstrtoint(buf, 10, &data); 1916 if (ret) 1917 return -EINVAL; 1918 1919 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX && 1920 (chip->config1 & ADT7516_SEL_AIN1_2_EX_TEMP_MASK) == 0) { 1921 if (data > 255 || data < 0) 1922 return -EINVAL; 1923 } else { 1924 if (data > 127 || data < -128) 1925 return -EINVAL; 1926 1927 if (data < 0) 1928 data += 256; 1929 } 1930 1931 val = (u8)data; 1932 1933 ret = chip->bus.write(chip->bus.client, this_attr->address, val); 1934 if (ret) 1935 return -EIO; 1936 1937 return len; 1938 } 1939 1940 static ssize_t adt7316_show_int_enabled(struct device *dev, 1941 struct device_attribute *attr, 1942 char *buf) 1943 { 1944 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1945 struct adt7316_chip_info *chip = iio_priv(dev_info); 1946 1947 return sprintf(buf, "%d\n", !!(chip->config1 & ADT7316_INT_EN)); 1948 } 1949 1950 static ssize_t adt7316_set_int_enabled(struct device *dev, 1951 struct device_attribute *attr, 1952 const char *buf, 1953 size_t len) 1954 { 1955 struct iio_dev *dev_info = dev_to_iio_dev(dev); 1956 struct adt7316_chip_info *chip = iio_priv(dev_info); 1957 u8 config1; 1958 int ret; 1959 1960 config1 = chip->config1 & (~ADT7316_INT_EN); 1961 if (buf[0] == '1') 1962 config1 |= ADT7316_INT_EN; 1963 1964 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, config1); 1965 if (ret) 1966 return -EIO; 1967 1968 chip->config1 = config1; 1969 1970 return len; 1971 } 1972 1973 static IIO_DEVICE_ATTR(int_mask, 1974 S_IRUGO | S_IWUSR, 1975 adt7316_show_int_mask, adt7316_set_int_mask, 1976 0); 1977 static IIO_DEVICE_ATTR(in_temp_high_value, 1978 S_IRUGO | S_IWUSR, 1979 adt7316_show_ad_bound, adt7316_set_ad_bound, 1980 ADT7316_IN_TEMP_HIGH); 1981 static IIO_DEVICE_ATTR(in_temp_low_value, 1982 S_IRUGO | S_IWUSR, 1983 adt7316_show_ad_bound, adt7316_set_ad_bound, 1984 ADT7316_IN_TEMP_LOW); 1985 static IIO_DEVICE_ATTR(ex_temp_high_value, 1986 S_IRUGO | S_IWUSR, 1987 adt7316_show_ad_bound, adt7316_set_ad_bound, 1988 ADT7316_EX_TEMP_HIGH); 1989 static IIO_DEVICE_ATTR(ex_temp_low_value, 1990 S_IRUGO | S_IWUSR, 1991 adt7316_show_ad_bound, adt7316_set_ad_bound, 1992 ADT7316_EX_TEMP_LOW); 1993 1994 /* NASTY duplication to be fixed */ 1995 static IIO_DEVICE_ATTR(ex_temp_ain1_high_value, 1996 S_IRUGO | S_IWUSR, 1997 adt7316_show_ad_bound, adt7316_set_ad_bound, 1998 ADT7316_EX_TEMP_HIGH); 1999 static IIO_DEVICE_ATTR(ex_temp_ain1_low_value, 2000 S_IRUGO | S_IWUSR, 2001 adt7316_show_ad_bound, adt7316_set_ad_bound, 2002 ADT7316_EX_TEMP_LOW); 2003 static IIO_DEVICE_ATTR(ain2_high_value, 2004 S_IRUGO | S_IWUSR, 2005 adt7316_show_ad_bound, adt7316_set_ad_bound, 2006 ADT7516_AIN2_HIGH); 2007 static IIO_DEVICE_ATTR(ain2_low_value, 2008 S_IRUGO | S_IWUSR, 2009 adt7316_show_ad_bound, adt7316_set_ad_bound, 2010 ADT7516_AIN2_LOW); 2011 static IIO_DEVICE_ATTR(ain3_high_value, 2012 S_IRUGO | S_IWUSR, 2013 adt7316_show_ad_bound, adt7316_set_ad_bound, 2014 ADT7516_AIN3_HIGH); 2015 static IIO_DEVICE_ATTR(ain3_low_value, 2016 S_IRUGO | S_IWUSR, 2017 adt7316_show_ad_bound, adt7316_set_ad_bound, 2018 ADT7516_AIN3_LOW); 2019 static IIO_DEVICE_ATTR(ain4_high_value, 2020 S_IRUGO | S_IWUSR, 2021 adt7316_show_ad_bound, adt7316_set_ad_bound, 2022 ADT7516_AIN4_HIGH); 2023 static IIO_DEVICE_ATTR(ain4_low_value, 2024 S_IRUGO | S_IWUSR, 2025 adt7316_show_ad_bound, adt7316_set_ad_bound, 2026 ADT7516_AIN4_LOW); 2027 static IIO_DEVICE_ATTR(int_enabled, 2028 S_IRUGO | S_IWUSR, 2029 adt7316_show_int_enabled, 2030 adt7316_set_int_enabled, 0); 2031 2032 static struct attribute *adt7316_event_attributes[] = { 2033 &iio_dev_attr_int_mask.dev_attr.attr, 2034 &iio_dev_attr_in_temp_high_value.dev_attr.attr, 2035 &iio_dev_attr_in_temp_low_value.dev_attr.attr, 2036 &iio_dev_attr_ex_temp_high_value.dev_attr.attr, 2037 &iio_dev_attr_ex_temp_low_value.dev_attr.attr, 2038 &iio_dev_attr_int_enabled.dev_attr.attr, 2039 NULL, 2040 }; 2041 2042 static struct attribute_group adt7316_event_attribute_group = { 2043 .attrs = adt7316_event_attributes, 2044 .name = "events", 2045 }; 2046 2047 static struct attribute *adt7516_event_attributes[] = { 2048 &iio_dev_attr_int_mask.dev_attr.attr, 2049 &iio_dev_attr_in_temp_high_value.dev_attr.attr, 2050 &iio_dev_attr_in_temp_low_value.dev_attr.attr, 2051 &iio_dev_attr_ex_temp_ain1_high_value.dev_attr.attr, 2052 &iio_dev_attr_ex_temp_ain1_low_value.dev_attr.attr, 2053 &iio_dev_attr_ain2_high_value.dev_attr.attr, 2054 &iio_dev_attr_ain2_low_value.dev_attr.attr, 2055 &iio_dev_attr_ain3_high_value.dev_attr.attr, 2056 &iio_dev_attr_ain3_low_value.dev_attr.attr, 2057 &iio_dev_attr_ain4_high_value.dev_attr.attr, 2058 &iio_dev_attr_ain4_low_value.dev_attr.attr, 2059 &iio_dev_attr_int_enabled.dev_attr.attr, 2060 NULL, 2061 }; 2062 2063 static struct attribute_group adt7516_event_attribute_group = { 2064 .attrs = adt7516_event_attributes, 2065 .name = "events", 2066 }; 2067 2068 #ifdef CONFIG_PM_SLEEP 2069 static int adt7316_disable(struct device *dev) 2070 { 2071 struct iio_dev *dev_info = dev_get_drvdata(dev); 2072 struct adt7316_chip_info *chip = iio_priv(dev_info); 2073 2074 return _adt7316_store_enabled(chip, 0); 2075 } 2076 2077 static int adt7316_enable(struct device *dev) 2078 { 2079 struct iio_dev *dev_info = dev_get_drvdata(dev); 2080 struct adt7316_chip_info *chip = iio_priv(dev_info); 2081 2082 return _adt7316_store_enabled(chip, 1); 2083 } 2084 2085 SIMPLE_DEV_PM_OPS(adt7316_pm_ops, adt7316_disable, adt7316_enable); 2086 EXPORT_SYMBOL_GPL(adt7316_pm_ops); 2087 #endif 2088 2089 static const struct iio_info adt7316_info = { 2090 .attrs = &adt7316_attribute_group, 2091 .event_attrs = &adt7316_event_attribute_group, 2092 .driver_module = THIS_MODULE, 2093 }; 2094 2095 static const struct iio_info adt7516_info = { 2096 .attrs = &adt7516_attribute_group, 2097 .event_attrs = &adt7516_event_attribute_group, 2098 .driver_module = THIS_MODULE, 2099 }; 2100 2101 /* 2102 * device probe and remove 2103 */ 2104 int adt7316_probe(struct device *dev, struct adt7316_bus *bus, 2105 const char *name) 2106 { 2107 struct adt7316_chip_info *chip; 2108 struct iio_dev *indio_dev; 2109 unsigned short *adt7316_platform_data = dev->platform_data; 2110 int ret = 0; 2111 2112 indio_dev = devm_iio_device_alloc(dev, sizeof(*chip)); 2113 if (!indio_dev) 2114 return -ENOMEM; 2115 chip = iio_priv(indio_dev); 2116 /* this is only used for device removal purposes */ 2117 dev_set_drvdata(dev, indio_dev); 2118 2119 chip->bus = *bus; 2120 2121 if (name[4] == '3') 2122 chip->id = ID_ADT7316 + (name[6] - '6'); 2123 else if (name[4] == '5') 2124 chip->id = ID_ADT7516 + (name[6] - '6'); 2125 else 2126 return -ENODEV; 2127 2128 chip->ldac_pin = adt7316_platform_data[1]; 2129 if (chip->ldac_pin) { 2130 chip->config3 |= ADT7316_DA_EN_VIA_DAC_LDCA; 2131 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) 2132 chip->config1 |= ADT7516_SEL_AIN3; 2133 } 2134 chip->int_mask = ADT7316_TEMP_INT_MASK | ADT7316_VDD_INT_MASK; 2135 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) 2136 chip->int_mask |= ADT7516_AIN_INT_MASK; 2137 2138 indio_dev->dev.parent = dev; 2139 if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) 2140 indio_dev->info = &adt7516_info; 2141 else 2142 indio_dev->info = &adt7316_info; 2143 indio_dev->name = name; 2144 indio_dev->modes = INDIO_DIRECT_MODE; 2145 2146 if (chip->bus.irq > 0) { 2147 if (adt7316_platform_data[0]) 2148 chip->bus.irq_flags = adt7316_platform_data[0]; 2149 2150 ret = devm_request_threaded_irq(dev, chip->bus.irq, 2151 NULL, 2152 adt7316_event_handler, 2153 chip->bus.irq_flags | 2154 IRQF_ONESHOT, 2155 indio_dev->name, 2156 indio_dev); 2157 if (ret) 2158 return ret; 2159 2160 if (chip->bus.irq_flags & IRQF_TRIGGER_HIGH) 2161 chip->config1 |= ADT7316_INT_POLARITY; 2162 } 2163 2164 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG1, chip->config1); 2165 if (ret) 2166 return -EIO; 2167 2168 ret = chip->bus.write(chip->bus.client, ADT7316_CONFIG3, chip->config3); 2169 if (ret) 2170 return -EIO; 2171 2172 ret = devm_iio_device_register(dev, indio_dev); 2173 if (ret) 2174 return ret; 2175 2176 dev_info(dev, "%s temperature sensor, ADC and DAC registered.\n", 2177 indio_dev->name); 2178 2179 return 0; 2180 } 2181 EXPORT_SYMBOL(adt7316_probe); 2182 2183 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>"); 2184 MODULE_DESCRIPTION("Analog Devices ADT7316/7/8 and ADT7516/7/9 digital temperature sensor, ADC and DAC driver"); 2185 MODULE_LICENSE("GPL v2"); 2186