1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Analog Devices LTC2983 Multi-Sensor Digital Temperature Measurement System 4 * driver 5 * 6 * Copyright 2019 Analog Devices Inc. 7 */ 8 #include <linux/bitfield.h> 9 #include <linux/completion.h> 10 #include <linux/device.h> 11 #include <linux/kernel.h> 12 #include <linux/iio/iio.h> 13 #include <linux/interrupt.h> 14 #include <linux/list.h> 15 #include <linux/module.h> 16 #include <linux/of_gpio.h> 17 #include <linux/regmap.h> 18 #include <linux/spi/spi.h> 19 20 /* register map */ 21 #define LTC2983_STATUS_REG 0x0000 22 #define LTC2983_TEMP_RES_START_REG 0x0010 23 #define LTC2983_TEMP_RES_END_REG 0x005F 24 #define LTC2983_GLOBAL_CONFIG_REG 0x00F0 25 #define LTC2983_MULT_CHANNEL_START_REG 0x00F4 26 #define LTC2983_MULT_CHANNEL_END_REG 0x00F7 27 #define LTC2983_MUX_CONFIG_REG 0x00FF 28 #define LTC2983_CHAN_ASSIGN_START_REG 0x0200 29 #define LTC2983_CHAN_ASSIGN_END_REG 0x024F 30 #define LTC2983_CUST_SENS_TBL_START_REG 0x0250 31 #define LTC2983_CUST_SENS_TBL_END_REG 0x03CF 32 33 #define LTC2983_DIFFERENTIAL_CHAN_MIN 2 34 #define LTC2983_MAX_CHANNELS_NR 20 35 #define LTC2983_MIN_CHANNELS_NR 1 36 #define LTC2983_SLEEP 0x97 37 #define LTC2983_CUSTOM_STEINHART_SIZE 24 38 #define LTC2983_CUSTOM_SENSOR_ENTRY_SZ 6 39 #define LTC2983_CUSTOM_STEINHART_ENTRY_SZ 4 40 41 #define LTC2983_CHAN_START_ADDR(chan) \ 42 (((chan - 1) * 4) + LTC2983_CHAN_ASSIGN_START_REG) 43 #define LTC2983_CHAN_RES_ADDR(chan) \ 44 (((chan - 1) * 4) + LTC2983_TEMP_RES_START_REG) 45 #define LTC2983_THERMOCOUPLE_DIFF_MASK BIT(3) 46 #define LTC2983_THERMOCOUPLE_SGL(x) \ 47 FIELD_PREP(LTC2983_THERMOCOUPLE_DIFF_MASK, x) 48 #define LTC2983_THERMOCOUPLE_OC_CURR_MASK GENMASK(1, 0) 49 #define LTC2983_THERMOCOUPLE_OC_CURR(x) \ 50 FIELD_PREP(LTC2983_THERMOCOUPLE_OC_CURR_MASK, x) 51 #define LTC2983_THERMOCOUPLE_OC_CHECK_MASK BIT(2) 52 #define LTC2983_THERMOCOUPLE_OC_CHECK(x) \ 53 FIELD_PREP(LTC2983_THERMOCOUPLE_OC_CHECK_MASK, x) 54 55 #define LTC2983_THERMISTOR_DIFF_MASK BIT(2) 56 #define LTC2983_THERMISTOR_SGL(x) \ 57 FIELD_PREP(LTC2983_THERMISTOR_DIFF_MASK, x) 58 #define LTC2983_THERMISTOR_R_SHARE_MASK BIT(1) 59 #define LTC2983_THERMISTOR_R_SHARE(x) \ 60 FIELD_PREP(LTC2983_THERMISTOR_R_SHARE_MASK, x) 61 #define LTC2983_THERMISTOR_C_ROTATE_MASK BIT(0) 62 #define LTC2983_THERMISTOR_C_ROTATE(x) \ 63 FIELD_PREP(LTC2983_THERMISTOR_C_ROTATE_MASK, x) 64 65 #define LTC2983_DIODE_DIFF_MASK BIT(2) 66 #define LTC2983_DIODE_SGL(x) \ 67 FIELD_PREP(LTC2983_DIODE_DIFF_MASK, x) 68 #define LTC2983_DIODE_3_CONV_CYCLE_MASK BIT(1) 69 #define LTC2983_DIODE_3_CONV_CYCLE(x) \ 70 FIELD_PREP(LTC2983_DIODE_3_CONV_CYCLE_MASK, x) 71 #define LTC2983_DIODE_AVERAGE_ON_MASK BIT(0) 72 #define LTC2983_DIODE_AVERAGE_ON(x) \ 73 FIELD_PREP(LTC2983_DIODE_AVERAGE_ON_MASK, x) 74 75 #define LTC2983_RTD_4_WIRE_MASK BIT(3) 76 #define LTC2983_RTD_ROTATION_MASK BIT(1) 77 #define LTC2983_RTD_C_ROTATE(x) \ 78 FIELD_PREP(LTC2983_RTD_ROTATION_MASK, x) 79 #define LTC2983_RTD_KELVIN_R_SENSE_MASK GENMASK(3, 2) 80 #define LTC2983_RTD_N_WIRES_MASK GENMASK(3, 2) 81 #define LTC2983_RTD_N_WIRES(x) \ 82 FIELD_PREP(LTC2983_RTD_N_WIRES_MASK, x) 83 #define LTC2983_RTD_R_SHARE_MASK BIT(0) 84 #define LTC2983_RTD_R_SHARE(x) \ 85 FIELD_PREP(LTC2983_RTD_R_SHARE_MASK, 1) 86 87 #define LTC2983_COMMON_HARD_FAULT_MASK GENMASK(31, 30) 88 #define LTC2983_COMMON_SOFT_FAULT_MASK GENMASK(27, 25) 89 90 #define LTC2983_STATUS_START_MASK BIT(7) 91 #define LTC2983_STATUS_START(x) FIELD_PREP(LTC2983_STATUS_START_MASK, x) 92 93 #define LTC2983_STATUS_CHAN_SEL_MASK GENMASK(4, 0) 94 #define LTC2983_STATUS_CHAN_SEL(x) \ 95 FIELD_PREP(LTC2983_STATUS_CHAN_SEL_MASK, x) 96 97 #define LTC2983_TEMP_UNITS_MASK BIT(2) 98 #define LTC2983_TEMP_UNITS(x) FIELD_PREP(LTC2983_TEMP_UNITS_MASK, x) 99 100 #define LTC2983_NOTCH_FREQ_MASK GENMASK(1, 0) 101 #define LTC2983_NOTCH_FREQ(x) FIELD_PREP(LTC2983_NOTCH_FREQ_MASK, x) 102 103 #define LTC2983_RES_VALID_MASK BIT(24) 104 #define LTC2983_DATA_MASK GENMASK(23, 0) 105 #define LTC2983_DATA_SIGN_BIT 23 106 107 #define LTC2983_CHAN_TYPE_MASK GENMASK(31, 27) 108 #define LTC2983_CHAN_TYPE(x) FIELD_PREP(LTC2983_CHAN_TYPE_MASK, x) 109 110 /* cold junction for thermocouples and rsense for rtd's and thermistor's */ 111 #define LTC2983_CHAN_ASSIGN_MASK GENMASK(26, 22) 112 #define LTC2983_CHAN_ASSIGN(x) FIELD_PREP(LTC2983_CHAN_ASSIGN_MASK, x) 113 114 #define LTC2983_CUSTOM_LEN_MASK GENMASK(5, 0) 115 #define LTC2983_CUSTOM_LEN(x) FIELD_PREP(LTC2983_CUSTOM_LEN_MASK, x) 116 117 #define LTC2983_CUSTOM_ADDR_MASK GENMASK(11, 6) 118 #define LTC2983_CUSTOM_ADDR(x) FIELD_PREP(LTC2983_CUSTOM_ADDR_MASK, x) 119 120 #define LTC2983_THERMOCOUPLE_CFG_MASK GENMASK(21, 18) 121 #define LTC2983_THERMOCOUPLE_CFG(x) \ 122 FIELD_PREP(LTC2983_THERMOCOUPLE_CFG_MASK, x) 123 #define LTC2983_THERMOCOUPLE_HARD_FAULT_MASK GENMASK(31, 29) 124 #define LTC2983_THERMOCOUPLE_SOFT_FAULT_MASK GENMASK(28, 25) 125 126 #define LTC2983_RTD_CFG_MASK GENMASK(21, 18) 127 #define LTC2983_RTD_CFG(x) FIELD_PREP(LTC2983_RTD_CFG_MASK, x) 128 #define LTC2983_RTD_EXC_CURRENT_MASK GENMASK(17, 14) 129 #define LTC2983_RTD_EXC_CURRENT(x) \ 130 FIELD_PREP(LTC2983_RTD_EXC_CURRENT_MASK, x) 131 #define LTC2983_RTD_CURVE_MASK GENMASK(13, 12) 132 #define LTC2983_RTD_CURVE(x) FIELD_PREP(LTC2983_RTD_CURVE_MASK, x) 133 134 #define LTC2983_THERMISTOR_CFG_MASK GENMASK(21, 19) 135 #define LTC2983_THERMISTOR_CFG(x) \ 136 FIELD_PREP(LTC2983_THERMISTOR_CFG_MASK, x) 137 #define LTC2983_THERMISTOR_EXC_CURRENT_MASK GENMASK(18, 15) 138 #define LTC2983_THERMISTOR_EXC_CURRENT(x) \ 139 FIELD_PREP(LTC2983_THERMISTOR_EXC_CURRENT_MASK, x) 140 141 #define LTC2983_DIODE_CFG_MASK GENMASK(26, 24) 142 #define LTC2983_DIODE_CFG(x) FIELD_PREP(LTC2983_DIODE_CFG_MASK, x) 143 #define LTC2983_DIODE_EXC_CURRENT_MASK GENMASK(23, 22) 144 #define LTC2983_DIODE_EXC_CURRENT(x) \ 145 FIELD_PREP(LTC2983_DIODE_EXC_CURRENT_MASK, x) 146 #define LTC2983_DIODE_IDEAL_FACTOR_MASK GENMASK(21, 0) 147 #define LTC2983_DIODE_IDEAL_FACTOR(x) \ 148 FIELD_PREP(LTC2983_DIODE_IDEAL_FACTOR_MASK, x) 149 150 #define LTC2983_R_SENSE_VAL_MASK GENMASK(26, 0) 151 #define LTC2983_R_SENSE_VAL(x) FIELD_PREP(LTC2983_R_SENSE_VAL_MASK, x) 152 153 #define LTC2983_ADC_SINGLE_ENDED_MASK BIT(26) 154 #define LTC2983_ADC_SINGLE_ENDED(x) \ 155 FIELD_PREP(LTC2983_ADC_SINGLE_ENDED_MASK, x) 156 157 enum { 158 LTC2983_SENSOR_THERMOCOUPLE = 1, 159 LTC2983_SENSOR_THERMOCOUPLE_CUSTOM = 9, 160 LTC2983_SENSOR_RTD = 10, 161 LTC2983_SENSOR_RTD_CUSTOM = 18, 162 LTC2983_SENSOR_THERMISTOR = 19, 163 LTC2983_SENSOR_THERMISTOR_STEINHART = 26, 164 LTC2983_SENSOR_THERMISTOR_CUSTOM = 27, 165 LTC2983_SENSOR_DIODE = 28, 166 LTC2983_SENSOR_SENSE_RESISTOR = 29, 167 LTC2983_SENSOR_DIRECT_ADC = 30, 168 }; 169 170 #define to_thermocouple(_sensor) \ 171 container_of(_sensor, struct ltc2983_thermocouple, sensor) 172 173 #define to_rtd(_sensor) \ 174 container_of(_sensor, struct ltc2983_rtd, sensor) 175 176 #define to_thermistor(_sensor) \ 177 container_of(_sensor, struct ltc2983_thermistor, sensor) 178 179 #define to_diode(_sensor) \ 180 container_of(_sensor, struct ltc2983_diode, sensor) 181 182 #define to_rsense(_sensor) \ 183 container_of(_sensor, struct ltc2983_rsense, sensor) 184 185 #define to_adc(_sensor) \ 186 container_of(_sensor, struct ltc2983_adc, sensor) 187 188 struct ltc2983_data { 189 struct regmap *regmap; 190 struct spi_device *spi; 191 struct mutex lock; 192 struct completion completion; 193 struct iio_chan_spec *iio_chan; 194 struct ltc2983_sensor **sensors; 195 u32 mux_delay_config; 196 u32 filter_notch_freq; 197 u16 custom_table_size; 198 u8 num_channels; 199 u8 iio_channels; 200 /* 201 * DMA (thus cache coherency maintenance) requires the 202 * transfer buffers to live in their own cache lines. 203 * Holds the converted temperature 204 */ 205 __be32 temp ____cacheline_aligned; 206 }; 207 208 struct ltc2983_sensor { 209 int (*fault_handler)(const struct ltc2983_data *st, const u32 result); 210 int (*assign_chan)(struct ltc2983_data *st, 211 const struct ltc2983_sensor *sensor); 212 /* specifies the sensor channel */ 213 u32 chan; 214 /* sensor type */ 215 u32 type; 216 }; 217 218 struct ltc2983_custom_sensor { 219 /* raw table sensor data */ 220 u8 *table; 221 size_t size; 222 /* address offset */ 223 s8 offset; 224 bool is_steinhart; 225 }; 226 227 struct ltc2983_thermocouple { 228 struct ltc2983_sensor sensor; 229 struct ltc2983_custom_sensor *custom; 230 u32 sensor_config; 231 u32 cold_junction_chan; 232 }; 233 234 struct ltc2983_rtd { 235 struct ltc2983_sensor sensor; 236 struct ltc2983_custom_sensor *custom; 237 u32 sensor_config; 238 u32 r_sense_chan; 239 u32 excitation_current; 240 u32 rtd_curve; 241 }; 242 243 struct ltc2983_thermistor { 244 struct ltc2983_sensor sensor; 245 struct ltc2983_custom_sensor *custom; 246 u32 sensor_config; 247 u32 r_sense_chan; 248 u32 excitation_current; 249 }; 250 251 struct ltc2983_diode { 252 struct ltc2983_sensor sensor; 253 u32 sensor_config; 254 u32 excitation_current; 255 u32 ideal_factor_value; 256 }; 257 258 struct ltc2983_rsense { 259 struct ltc2983_sensor sensor; 260 u32 r_sense_val; 261 }; 262 263 struct ltc2983_adc { 264 struct ltc2983_sensor sensor; 265 bool single_ended; 266 }; 267 268 /* 269 * Convert to Q format numbers. These number's are integers where 270 * the number of integer and fractional bits are specified. The resolution 271 * is given by 1/@resolution and tell us the number of fractional bits. For 272 * instance a resolution of 2^-10 means we have 10 fractional bits. 273 */ 274 static u32 __convert_to_raw(const u64 val, const u32 resolution) 275 { 276 u64 __res = val * resolution; 277 278 /* all values are multiplied by 1000000 to remove the fraction */ 279 do_div(__res, 1000000); 280 281 return __res; 282 } 283 284 static u32 __convert_to_raw_sign(const u64 val, const u32 resolution) 285 { 286 s64 __res = -(s32)val; 287 288 __res = __convert_to_raw(__res, resolution); 289 290 return (u32)-__res; 291 } 292 293 static int __ltc2983_fault_handler(const struct ltc2983_data *st, 294 const u32 result, const u32 hard_mask, 295 const u32 soft_mask) 296 { 297 const struct device *dev = &st->spi->dev; 298 299 if (result & hard_mask) { 300 dev_err(dev, "Invalid conversion: Sensor HARD fault\n"); 301 return -EIO; 302 } else if (result & soft_mask) { 303 /* just print a warning */ 304 dev_warn(dev, "Suspicious conversion: Sensor SOFT fault\n"); 305 } 306 307 return 0; 308 } 309 310 static int __ltc2983_chan_assign_common(const struct ltc2983_data *st, 311 const struct ltc2983_sensor *sensor, 312 u32 chan_val) 313 { 314 u32 reg = LTC2983_CHAN_START_ADDR(sensor->chan); 315 __be32 __chan_val; 316 317 chan_val |= LTC2983_CHAN_TYPE(sensor->type); 318 dev_dbg(&st->spi->dev, "Assign reg:0x%04X, val:0x%08X\n", reg, 319 chan_val); 320 __chan_val = cpu_to_be32(chan_val); 321 return regmap_bulk_write(st->regmap, reg, &__chan_val, 322 sizeof(__chan_val)); 323 } 324 325 static int __ltc2983_chan_custom_sensor_assign(struct ltc2983_data *st, 326 struct ltc2983_custom_sensor *custom, 327 u32 *chan_val) 328 { 329 u32 reg; 330 u8 mult = custom->is_steinhart ? LTC2983_CUSTOM_STEINHART_ENTRY_SZ : 331 LTC2983_CUSTOM_SENSOR_ENTRY_SZ; 332 const struct device *dev = &st->spi->dev; 333 /* 334 * custom->size holds the raw size of the table. However, when 335 * configuring the sensor channel, we must write the number of 336 * entries of the table minus 1. For steinhart sensors 0 is written 337 * since the size is constant! 338 */ 339 const u8 len = custom->is_steinhart ? 0 : 340 (custom->size / LTC2983_CUSTOM_SENSOR_ENTRY_SZ) - 1; 341 /* 342 * Check if the offset was assigned already. It should be for steinhart 343 * sensors. When coming from sleep, it should be assigned for all. 344 */ 345 if (custom->offset < 0) { 346 /* 347 * This needs to be done again here because, from the moment 348 * when this test was done (successfully) for this custom 349 * sensor, a steinhart sensor might have been added changing 350 * custom_table_size... 351 */ 352 if (st->custom_table_size + custom->size > 353 (LTC2983_CUST_SENS_TBL_END_REG - 354 LTC2983_CUST_SENS_TBL_START_REG) + 1) { 355 dev_err(dev, 356 "Not space left(%d) for new custom sensor(%zu)", 357 st->custom_table_size, 358 custom->size); 359 return -EINVAL; 360 } 361 362 custom->offset = st->custom_table_size / 363 LTC2983_CUSTOM_SENSOR_ENTRY_SZ; 364 st->custom_table_size += custom->size; 365 } 366 367 reg = (custom->offset * mult) + LTC2983_CUST_SENS_TBL_START_REG; 368 369 *chan_val |= LTC2983_CUSTOM_LEN(len); 370 *chan_val |= LTC2983_CUSTOM_ADDR(custom->offset); 371 dev_dbg(dev, "Assign custom sensor, reg:0x%04X, off:%d, sz:%zu", 372 reg, custom->offset, 373 custom->size); 374 /* write custom sensor table */ 375 return regmap_bulk_write(st->regmap, reg, custom->table, custom->size); 376 } 377 378 static struct ltc2983_custom_sensor *__ltc2983_custom_sensor_new( 379 struct ltc2983_data *st, 380 const struct device_node *np, 381 const char *propname, 382 const bool is_steinhart, 383 const u32 resolution, 384 const bool has_signed) 385 { 386 struct ltc2983_custom_sensor *new_custom; 387 u8 index, n_entries, tbl = 0; 388 struct device *dev = &st->spi->dev; 389 /* 390 * For custom steinhart, the full u32 is taken. For all the others 391 * the MSB is discarded. 392 */ 393 const u8 n_size = is_steinhart ? 4 : 3; 394 const u8 e_size = is_steinhart ? sizeof(u32) : sizeof(u64); 395 396 n_entries = of_property_count_elems_of_size(np, propname, e_size); 397 /* n_entries must be an even number */ 398 if (!n_entries || (n_entries % 2) != 0) { 399 dev_err(dev, "Number of entries either 0 or not even\n"); 400 return ERR_PTR(-EINVAL); 401 } 402 403 new_custom = devm_kzalloc(dev, sizeof(*new_custom), GFP_KERNEL); 404 if (!new_custom) 405 return ERR_PTR(-ENOMEM); 406 407 new_custom->size = n_entries * n_size; 408 /* check Steinhart size */ 409 if (is_steinhart && new_custom->size != LTC2983_CUSTOM_STEINHART_SIZE) { 410 dev_err(dev, "Steinhart sensors size(%zu) must be 24", 411 new_custom->size); 412 return ERR_PTR(-EINVAL); 413 } 414 /* Check space on the table. */ 415 if (st->custom_table_size + new_custom->size > 416 (LTC2983_CUST_SENS_TBL_END_REG - 417 LTC2983_CUST_SENS_TBL_START_REG) + 1) { 418 dev_err(dev, "No space left(%d) for new custom sensor(%zu)", 419 st->custom_table_size, new_custom->size); 420 return ERR_PTR(-EINVAL); 421 } 422 423 /* allocate the table */ 424 new_custom->table = devm_kzalloc(dev, new_custom->size, GFP_KERNEL); 425 if (!new_custom->table) 426 return ERR_PTR(-ENOMEM); 427 428 for (index = 0; index < n_entries; index++) { 429 u64 temp = 0, j; 430 /* 431 * Steinhart sensors are configured with raw values in the 432 * devicetree. For the other sensors we must convert the 433 * value to raw. The odd index's correspond to temperarures 434 * and always have 1/1024 of resolution. Temperatures also 435 * come in kelvin, so signed values is not possible 436 */ 437 if (!is_steinhart) { 438 of_property_read_u64_index(np, propname, index, &temp); 439 440 if ((index % 2) != 0) 441 temp = __convert_to_raw(temp, 1024); 442 else if (has_signed && (s64)temp < 0) 443 temp = __convert_to_raw_sign(temp, resolution); 444 else 445 temp = __convert_to_raw(temp, resolution); 446 } else { 447 u32 t32; 448 449 of_property_read_u32_index(np, propname, index, &t32); 450 temp = t32; 451 } 452 453 for (j = 0; j < n_size; j++) 454 new_custom->table[tbl++] = 455 temp >> (8 * (n_size - j - 1)); 456 } 457 458 new_custom->is_steinhart = is_steinhart; 459 /* 460 * This is done to first add all the steinhart sensors to the table, 461 * in order to maximize the table usage. If we mix adding steinhart 462 * with the other sensors, we might have to do some roundup to make 463 * sure that sensor_addr - 0x250(start address) is a multiple of 4 464 * (for steinhart), and a multiple of 6 for all the other sensors. 465 * Since we have const 24 bytes for steinhart sensors and 24 is 466 * also a multiple of 6, we guarantee that the first non-steinhart 467 * sensor will sit in a correct address without the need of filling 468 * addresses. 469 */ 470 if (is_steinhart) { 471 new_custom->offset = st->custom_table_size / 472 LTC2983_CUSTOM_STEINHART_ENTRY_SZ; 473 st->custom_table_size += new_custom->size; 474 } else { 475 /* mark as unset. This is checked later on the assign phase */ 476 new_custom->offset = -1; 477 } 478 479 return new_custom; 480 } 481 482 static int ltc2983_thermocouple_fault_handler(const struct ltc2983_data *st, 483 const u32 result) 484 { 485 return __ltc2983_fault_handler(st, result, 486 LTC2983_THERMOCOUPLE_HARD_FAULT_MASK, 487 LTC2983_THERMOCOUPLE_SOFT_FAULT_MASK); 488 } 489 490 static int ltc2983_common_fault_handler(const struct ltc2983_data *st, 491 const u32 result) 492 { 493 return __ltc2983_fault_handler(st, result, 494 LTC2983_COMMON_HARD_FAULT_MASK, 495 LTC2983_COMMON_SOFT_FAULT_MASK); 496 } 497 498 static int ltc2983_thermocouple_assign_chan(struct ltc2983_data *st, 499 const struct ltc2983_sensor *sensor) 500 { 501 struct ltc2983_thermocouple *thermo = to_thermocouple(sensor); 502 u32 chan_val; 503 504 chan_val = LTC2983_CHAN_ASSIGN(thermo->cold_junction_chan); 505 chan_val |= LTC2983_THERMOCOUPLE_CFG(thermo->sensor_config); 506 507 if (thermo->custom) { 508 int ret; 509 510 ret = __ltc2983_chan_custom_sensor_assign(st, thermo->custom, 511 &chan_val); 512 if (ret) 513 return ret; 514 } 515 return __ltc2983_chan_assign_common(st, sensor, chan_val); 516 } 517 518 static int ltc2983_rtd_assign_chan(struct ltc2983_data *st, 519 const struct ltc2983_sensor *sensor) 520 { 521 struct ltc2983_rtd *rtd = to_rtd(sensor); 522 u32 chan_val; 523 524 chan_val = LTC2983_CHAN_ASSIGN(rtd->r_sense_chan); 525 chan_val |= LTC2983_RTD_CFG(rtd->sensor_config); 526 chan_val |= LTC2983_RTD_EXC_CURRENT(rtd->excitation_current); 527 chan_val |= LTC2983_RTD_CURVE(rtd->rtd_curve); 528 529 if (rtd->custom) { 530 int ret; 531 532 ret = __ltc2983_chan_custom_sensor_assign(st, rtd->custom, 533 &chan_val); 534 if (ret) 535 return ret; 536 } 537 return __ltc2983_chan_assign_common(st, sensor, chan_val); 538 } 539 540 static int ltc2983_thermistor_assign_chan(struct ltc2983_data *st, 541 const struct ltc2983_sensor *sensor) 542 { 543 struct ltc2983_thermistor *thermistor = to_thermistor(sensor); 544 u32 chan_val; 545 546 chan_val = LTC2983_CHAN_ASSIGN(thermistor->r_sense_chan); 547 chan_val |= LTC2983_THERMISTOR_CFG(thermistor->sensor_config); 548 chan_val |= 549 LTC2983_THERMISTOR_EXC_CURRENT(thermistor->excitation_current); 550 551 if (thermistor->custom) { 552 int ret; 553 554 ret = __ltc2983_chan_custom_sensor_assign(st, 555 thermistor->custom, 556 &chan_val); 557 if (ret) 558 return ret; 559 } 560 return __ltc2983_chan_assign_common(st, sensor, chan_val); 561 } 562 563 static int ltc2983_diode_assign_chan(struct ltc2983_data *st, 564 const struct ltc2983_sensor *sensor) 565 { 566 struct ltc2983_diode *diode = to_diode(sensor); 567 u32 chan_val; 568 569 chan_val = LTC2983_DIODE_CFG(diode->sensor_config); 570 chan_val |= LTC2983_DIODE_EXC_CURRENT(diode->excitation_current); 571 chan_val |= LTC2983_DIODE_IDEAL_FACTOR(diode->ideal_factor_value); 572 573 return __ltc2983_chan_assign_common(st, sensor, chan_val); 574 } 575 576 static int ltc2983_r_sense_assign_chan(struct ltc2983_data *st, 577 const struct ltc2983_sensor *sensor) 578 { 579 struct ltc2983_rsense *rsense = to_rsense(sensor); 580 u32 chan_val; 581 582 chan_val = LTC2983_R_SENSE_VAL(rsense->r_sense_val); 583 584 return __ltc2983_chan_assign_common(st, sensor, chan_val); 585 } 586 587 static int ltc2983_adc_assign_chan(struct ltc2983_data *st, 588 const struct ltc2983_sensor *sensor) 589 { 590 struct ltc2983_adc *adc = to_adc(sensor); 591 u32 chan_val; 592 593 chan_val = LTC2983_ADC_SINGLE_ENDED(adc->single_ended); 594 595 return __ltc2983_chan_assign_common(st, sensor, chan_val); 596 } 597 598 static struct ltc2983_sensor *ltc2983_thermocouple_new( 599 const struct device_node *child, 600 struct ltc2983_data *st, 601 const struct ltc2983_sensor *sensor) 602 { 603 struct ltc2983_thermocouple *thermo; 604 struct device_node *phandle; 605 u32 oc_current; 606 int ret; 607 608 thermo = devm_kzalloc(&st->spi->dev, sizeof(*thermo), GFP_KERNEL); 609 if (!thermo) 610 return ERR_PTR(-ENOMEM); 611 612 if (of_property_read_bool(child, "adi,single-ended")) 613 thermo->sensor_config = LTC2983_THERMOCOUPLE_SGL(1); 614 615 ret = of_property_read_u32(child, "adi,sensor-oc-current-microamp", 616 &oc_current); 617 if (!ret) { 618 switch (oc_current) { 619 case 10: 620 thermo->sensor_config |= 621 LTC2983_THERMOCOUPLE_OC_CURR(0); 622 break; 623 case 100: 624 thermo->sensor_config |= 625 LTC2983_THERMOCOUPLE_OC_CURR(1); 626 break; 627 case 500: 628 thermo->sensor_config |= 629 LTC2983_THERMOCOUPLE_OC_CURR(2); 630 break; 631 case 1000: 632 thermo->sensor_config |= 633 LTC2983_THERMOCOUPLE_OC_CURR(3); 634 break; 635 default: 636 dev_err(&st->spi->dev, 637 "Invalid open circuit current:%u", oc_current); 638 return ERR_PTR(-EINVAL); 639 } 640 641 thermo->sensor_config |= LTC2983_THERMOCOUPLE_OC_CHECK(1); 642 } 643 /* validate channel index */ 644 if (!(thermo->sensor_config & LTC2983_THERMOCOUPLE_DIFF_MASK) && 645 sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) { 646 dev_err(&st->spi->dev, 647 "Invalid chann:%d for differential thermocouple", 648 sensor->chan); 649 return ERR_PTR(-EINVAL); 650 } 651 652 phandle = of_parse_phandle(child, "adi,cold-junction-handle", 0); 653 if (phandle) { 654 int ret; 655 656 ret = of_property_read_u32(phandle, "reg", 657 &thermo->cold_junction_chan); 658 if (ret) { 659 /* 660 * This would be catched later but we can just return 661 * the error right away. 662 */ 663 dev_err(&st->spi->dev, "Property reg must be given\n"); 664 of_node_put(phandle); 665 return ERR_PTR(-EINVAL); 666 } 667 } 668 669 /* check custom sensor */ 670 if (sensor->type == LTC2983_SENSOR_THERMOCOUPLE_CUSTOM) { 671 const char *propname = "adi,custom-thermocouple"; 672 673 thermo->custom = __ltc2983_custom_sensor_new(st, child, 674 propname, false, 675 16384, true); 676 if (IS_ERR(thermo->custom)) { 677 of_node_put(phandle); 678 return ERR_CAST(thermo->custom); 679 } 680 } 681 682 /* set common parameters */ 683 thermo->sensor.fault_handler = ltc2983_thermocouple_fault_handler; 684 thermo->sensor.assign_chan = ltc2983_thermocouple_assign_chan; 685 686 of_node_put(phandle); 687 return &thermo->sensor; 688 } 689 690 static struct ltc2983_sensor *ltc2983_rtd_new(const struct device_node *child, 691 struct ltc2983_data *st, 692 const struct ltc2983_sensor *sensor) 693 { 694 struct ltc2983_rtd *rtd; 695 int ret = 0; 696 struct device *dev = &st->spi->dev; 697 struct device_node *phandle; 698 u32 excitation_current = 0, n_wires = 0; 699 700 rtd = devm_kzalloc(dev, sizeof(*rtd), GFP_KERNEL); 701 if (!rtd) 702 return ERR_PTR(-ENOMEM); 703 704 phandle = of_parse_phandle(child, "adi,rsense-handle", 0); 705 if (!phandle) { 706 dev_err(dev, "Property adi,rsense-handle missing or invalid"); 707 return ERR_PTR(-EINVAL); 708 } 709 710 ret = of_property_read_u32(phandle, "reg", &rtd->r_sense_chan); 711 if (ret) { 712 dev_err(dev, "Property reg must be given\n"); 713 goto fail; 714 } 715 716 ret = of_property_read_u32(child, "adi,number-of-wires", &n_wires); 717 if (!ret) { 718 switch (n_wires) { 719 case 2: 720 rtd->sensor_config = LTC2983_RTD_N_WIRES(0); 721 break; 722 case 3: 723 rtd->sensor_config = LTC2983_RTD_N_WIRES(1); 724 break; 725 case 4: 726 rtd->sensor_config = LTC2983_RTD_N_WIRES(2); 727 break; 728 case 5: 729 /* 4 wires, Kelvin Rsense */ 730 rtd->sensor_config = LTC2983_RTD_N_WIRES(3); 731 break; 732 default: 733 dev_err(dev, "Invalid number of wires:%u\n", n_wires); 734 ret = -EINVAL; 735 goto fail; 736 } 737 } 738 739 if (of_property_read_bool(child, "adi,rsense-share")) { 740 /* Current rotation is only available with rsense sharing */ 741 if (of_property_read_bool(child, "adi,current-rotate")) { 742 if (n_wires == 2 || n_wires == 3) { 743 dev_err(dev, 744 "Rotation not allowed for 2/3 Wire RTDs"); 745 ret = -EINVAL; 746 goto fail; 747 } 748 rtd->sensor_config |= LTC2983_RTD_C_ROTATE(1); 749 } else { 750 rtd->sensor_config |= LTC2983_RTD_R_SHARE(1); 751 } 752 } 753 /* 754 * rtd channel indexes are a bit more complicated to validate. 755 * For 4wire RTD with rotation, the channel selection cannot be 756 * >=19 since the chann + 1 is used in this configuration. 757 * For 4wire RTDs with kelvin rsense, the rsense channel cannot be 758 * <=1 since chanel - 1 and channel - 2 are used. 759 */ 760 if (rtd->sensor_config & LTC2983_RTD_4_WIRE_MASK) { 761 /* 4-wire */ 762 u8 min = LTC2983_DIFFERENTIAL_CHAN_MIN, 763 max = LTC2983_MAX_CHANNELS_NR; 764 765 if (rtd->sensor_config & LTC2983_RTD_ROTATION_MASK) 766 max = LTC2983_MAX_CHANNELS_NR - 1; 767 768 if (((rtd->sensor_config & LTC2983_RTD_KELVIN_R_SENSE_MASK) 769 == LTC2983_RTD_KELVIN_R_SENSE_MASK) && 770 (rtd->r_sense_chan <= min)) { 771 /* kelvin rsense*/ 772 dev_err(dev, 773 "Invalid rsense chann:%d to use in kelvin rsense", 774 rtd->r_sense_chan); 775 776 ret = -EINVAL; 777 goto fail; 778 } 779 780 if (sensor->chan < min || sensor->chan > max) { 781 dev_err(dev, "Invalid chann:%d for the rtd config", 782 sensor->chan); 783 784 ret = -EINVAL; 785 goto fail; 786 } 787 } else { 788 /* same as differential case */ 789 if (sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) { 790 dev_err(&st->spi->dev, 791 "Invalid chann:%d for RTD", sensor->chan); 792 793 ret = -EINVAL; 794 goto fail; 795 } 796 } 797 798 /* check custom sensor */ 799 if (sensor->type == LTC2983_SENSOR_RTD_CUSTOM) { 800 rtd->custom = __ltc2983_custom_sensor_new(st, child, 801 "adi,custom-rtd", 802 false, 2048, false); 803 if (IS_ERR(rtd->custom)) { 804 of_node_put(phandle); 805 return ERR_CAST(rtd->custom); 806 } 807 } 808 809 /* set common parameters */ 810 rtd->sensor.fault_handler = ltc2983_common_fault_handler; 811 rtd->sensor.assign_chan = ltc2983_rtd_assign_chan; 812 813 ret = of_property_read_u32(child, "adi,excitation-current-microamp", 814 &excitation_current); 815 if (ret) { 816 /* default to 5uA */ 817 rtd->excitation_current = 1; 818 } else { 819 switch (excitation_current) { 820 case 5: 821 rtd->excitation_current = 0x01; 822 break; 823 case 10: 824 rtd->excitation_current = 0x02; 825 break; 826 case 25: 827 rtd->excitation_current = 0x03; 828 break; 829 case 50: 830 rtd->excitation_current = 0x04; 831 break; 832 case 100: 833 rtd->excitation_current = 0x05; 834 break; 835 case 250: 836 rtd->excitation_current = 0x06; 837 break; 838 case 500: 839 rtd->excitation_current = 0x07; 840 break; 841 case 1000: 842 rtd->excitation_current = 0x08; 843 break; 844 default: 845 dev_err(&st->spi->dev, 846 "Invalid value for excitation current(%u)", 847 excitation_current); 848 ret = -EINVAL; 849 goto fail; 850 } 851 } 852 853 of_property_read_u32(child, "adi,rtd-curve", &rtd->rtd_curve); 854 855 of_node_put(phandle); 856 return &rtd->sensor; 857 fail: 858 of_node_put(phandle); 859 return ERR_PTR(ret); 860 } 861 862 static struct ltc2983_sensor *ltc2983_thermistor_new( 863 const struct device_node *child, 864 struct ltc2983_data *st, 865 const struct ltc2983_sensor *sensor) 866 { 867 struct ltc2983_thermistor *thermistor; 868 struct device *dev = &st->spi->dev; 869 struct device_node *phandle; 870 u32 excitation_current = 0; 871 int ret = 0; 872 873 thermistor = devm_kzalloc(dev, sizeof(*thermistor), GFP_KERNEL); 874 if (!thermistor) 875 return ERR_PTR(-ENOMEM); 876 877 phandle = of_parse_phandle(child, "adi,rsense-handle", 0); 878 if (!phandle) { 879 dev_err(dev, "Property adi,rsense-handle missing or invalid"); 880 return ERR_PTR(-EINVAL); 881 } 882 883 ret = of_property_read_u32(phandle, "reg", &thermistor->r_sense_chan); 884 if (ret) { 885 dev_err(dev, "rsense channel must be configured...\n"); 886 goto fail; 887 } 888 889 if (of_property_read_bool(child, "adi,single-ended")) { 890 thermistor->sensor_config = LTC2983_THERMISTOR_SGL(1); 891 } else if (of_property_read_bool(child, "adi,rsense-share")) { 892 /* rotation is only possible if sharing rsense */ 893 if (of_property_read_bool(child, "adi,current-rotate")) 894 thermistor->sensor_config = 895 LTC2983_THERMISTOR_C_ROTATE(1); 896 else 897 thermistor->sensor_config = 898 LTC2983_THERMISTOR_R_SHARE(1); 899 } 900 /* validate channel index */ 901 if (!(thermistor->sensor_config & LTC2983_THERMISTOR_DIFF_MASK) && 902 sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) { 903 dev_err(&st->spi->dev, 904 "Invalid chann:%d for differential thermistor", 905 sensor->chan); 906 ret = -EINVAL; 907 goto fail; 908 } 909 910 /* check custom sensor */ 911 if (sensor->type >= LTC2983_SENSOR_THERMISTOR_STEINHART) { 912 bool steinhart = false; 913 const char *propname; 914 915 if (sensor->type == LTC2983_SENSOR_THERMISTOR_STEINHART) { 916 steinhart = true; 917 propname = "adi,custom-steinhart"; 918 } else { 919 propname = "adi,custom-thermistor"; 920 } 921 922 thermistor->custom = __ltc2983_custom_sensor_new(st, child, 923 propname, 924 steinhart, 925 64, false); 926 if (IS_ERR(thermistor->custom)) { 927 of_node_put(phandle); 928 return ERR_CAST(thermistor->custom); 929 } 930 } 931 /* set common parameters */ 932 thermistor->sensor.fault_handler = ltc2983_common_fault_handler; 933 thermistor->sensor.assign_chan = ltc2983_thermistor_assign_chan; 934 935 ret = of_property_read_u32(child, "adi,excitation-current-nanoamp", 936 &excitation_current); 937 if (ret) { 938 /* Auto range is not allowed for custom sensors */ 939 if (sensor->type >= LTC2983_SENSOR_THERMISTOR_STEINHART) 940 /* default to 1uA */ 941 thermistor->excitation_current = 0x03; 942 else 943 /* default to auto-range */ 944 thermistor->excitation_current = 0x0c; 945 } else { 946 switch (excitation_current) { 947 case 0: 948 /* auto range */ 949 if (sensor->type >= 950 LTC2983_SENSOR_THERMISTOR_STEINHART) { 951 dev_err(&st->spi->dev, 952 "Auto Range not allowed for custom sensors\n"); 953 ret = -EINVAL; 954 goto fail; 955 } 956 thermistor->excitation_current = 0x0c; 957 break; 958 case 250: 959 thermistor->excitation_current = 0x01; 960 break; 961 case 500: 962 thermistor->excitation_current = 0x02; 963 break; 964 case 1000: 965 thermistor->excitation_current = 0x03; 966 break; 967 case 5000: 968 thermistor->excitation_current = 0x04; 969 break; 970 case 10000: 971 thermistor->excitation_current = 0x05; 972 break; 973 case 25000: 974 thermistor->excitation_current = 0x06; 975 break; 976 case 50000: 977 thermistor->excitation_current = 0x07; 978 break; 979 case 100000: 980 thermistor->excitation_current = 0x08; 981 break; 982 case 250000: 983 thermistor->excitation_current = 0x09; 984 break; 985 case 500000: 986 thermistor->excitation_current = 0x0a; 987 break; 988 case 1000000: 989 thermistor->excitation_current = 0x0b; 990 break; 991 default: 992 dev_err(&st->spi->dev, 993 "Invalid value for excitation current(%u)", 994 excitation_current); 995 ret = -EINVAL; 996 goto fail; 997 } 998 } 999 1000 of_node_put(phandle); 1001 return &thermistor->sensor; 1002 fail: 1003 of_node_put(phandle); 1004 return ERR_PTR(ret); 1005 } 1006 1007 static struct ltc2983_sensor *ltc2983_diode_new( 1008 const struct device_node *child, 1009 const struct ltc2983_data *st, 1010 const struct ltc2983_sensor *sensor) 1011 { 1012 struct ltc2983_diode *diode; 1013 u32 temp = 0, excitation_current = 0; 1014 int ret; 1015 1016 diode = devm_kzalloc(&st->spi->dev, sizeof(*diode), GFP_KERNEL); 1017 if (!diode) 1018 return ERR_PTR(-ENOMEM); 1019 1020 if (of_property_read_bool(child, "adi,single-ended")) 1021 diode->sensor_config = LTC2983_DIODE_SGL(1); 1022 1023 if (of_property_read_bool(child, "adi,three-conversion-cycles")) 1024 diode->sensor_config |= LTC2983_DIODE_3_CONV_CYCLE(1); 1025 1026 if (of_property_read_bool(child, "adi,average-on")) 1027 diode->sensor_config |= LTC2983_DIODE_AVERAGE_ON(1); 1028 1029 /* validate channel index */ 1030 if (!(diode->sensor_config & LTC2983_DIODE_DIFF_MASK) && 1031 sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) { 1032 dev_err(&st->spi->dev, 1033 "Invalid chann:%d for differential thermistor", 1034 sensor->chan); 1035 return ERR_PTR(-EINVAL); 1036 } 1037 /* set common parameters */ 1038 diode->sensor.fault_handler = ltc2983_common_fault_handler; 1039 diode->sensor.assign_chan = ltc2983_diode_assign_chan; 1040 1041 ret = of_property_read_u32(child, "adi,excitation-current-microamp", 1042 &excitation_current); 1043 if (!ret) { 1044 switch (excitation_current) { 1045 case 10: 1046 diode->excitation_current = 0x00; 1047 break; 1048 case 20: 1049 diode->excitation_current = 0x01; 1050 break; 1051 case 40: 1052 diode->excitation_current = 0x02; 1053 break; 1054 case 80: 1055 diode->excitation_current = 0x03; 1056 break; 1057 default: 1058 dev_err(&st->spi->dev, 1059 "Invalid value for excitation current(%u)", 1060 excitation_current); 1061 return ERR_PTR(-EINVAL); 1062 } 1063 } 1064 1065 of_property_read_u32(child, "adi,ideal-factor-value", &temp); 1066 1067 /* 2^20 resolution */ 1068 diode->ideal_factor_value = __convert_to_raw(temp, 1048576); 1069 1070 return &diode->sensor; 1071 } 1072 1073 static struct ltc2983_sensor *ltc2983_r_sense_new(struct device_node *child, 1074 struct ltc2983_data *st, 1075 const struct ltc2983_sensor *sensor) 1076 { 1077 struct ltc2983_rsense *rsense; 1078 int ret; 1079 u32 temp; 1080 1081 rsense = devm_kzalloc(&st->spi->dev, sizeof(*rsense), GFP_KERNEL); 1082 if (!rsense) 1083 return ERR_PTR(-ENOMEM); 1084 1085 /* validate channel index */ 1086 if (sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) { 1087 dev_err(&st->spi->dev, "Invalid chann:%d for r_sense", 1088 sensor->chan); 1089 return ERR_PTR(-EINVAL); 1090 } 1091 1092 ret = of_property_read_u32(child, "adi,rsense-val-milli-ohms", &temp); 1093 if (ret) { 1094 dev_err(&st->spi->dev, "Property adi,rsense-val-milli-ohms missing\n"); 1095 return ERR_PTR(-EINVAL); 1096 } 1097 /* 1098 * Times 1000 because we have milli-ohms and __convert_to_raw 1099 * expects scales of 1000000 which are used for all other 1100 * properties. 1101 * 2^10 resolution 1102 */ 1103 rsense->r_sense_val = __convert_to_raw((u64)temp * 1000, 1024); 1104 1105 /* set common parameters */ 1106 rsense->sensor.assign_chan = ltc2983_r_sense_assign_chan; 1107 1108 return &rsense->sensor; 1109 } 1110 1111 static struct ltc2983_sensor *ltc2983_adc_new(struct device_node *child, 1112 struct ltc2983_data *st, 1113 const struct ltc2983_sensor *sensor) 1114 { 1115 struct ltc2983_adc *adc; 1116 1117 adc = devm_kzalloc(&st->spi->dev, sizeof(*adc), GFP_KERNEL); 1118 if (!adc) 1119 return ERR_PTR(-ENOMEM); 1120 1121 if (of_property_read_bool(child, "adi,single-ended")) 1122 adc->single_ended = true; 1123 1124 if (!adc->single_ended && 1125 sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) { 1126 dev_err(&st->spi->dev, "Invalid chan:%d for differential adc\n", 1127 sensor->chan); 1128 return ERR_PTR(-EINVAL); 1129 } 1130 /* set common parameters */ 1131 adc->sensor.assign_chan = ltc2983_adc_assign_chan; 1132 adc->sensor.fault_handler = ltc2983_common_fault_handler; 1133 1134 return &adc->sensor; 1135 } 1136 1137 static int ltc2983_chan_read(struct ltc2983_data *st, 1138 const struct ltc2983_sensor *sensor, int *val) 1139 { 1140 u32 start_conversion = 0; 1141 int ret; 1142 unsigned long time; 1143 1144 start_conversion = LTC2983_STATUS_START(true); 1145 start_conversion |= LTC2983_STATUS_CHAN_SEL(sensor->chan); 1146 dev_dbg(&st->spi->dev, "Start conversion on chan:%d, status:%02X\n", 1147 sensor->chan, start_conversion); 1148 /* start conversion */ 1149 ret = regmap_write(st->regmap, LTC2983_STATUS_REG, start_conversion); 1150 if (ret) 1151 return ret; 1152 1153 reinit_completion(&st->completion); 1154 /* 1155 * wait for conversion to complete. 1156 * 300 ms should be more than enough to complete the conversion. 1157 * Depending on the sensor configuration, there are 2/3 conversions 1158 * cycles of 82ms. 1159 */ 1160 time = wait_for_completion_timeout(&st->completion, 1161 msecs_to_jiffies(300)); 1162 if (!time) { 1163 dev_warn(&st->spi->dev, "Conversion timed out\n"); 1164 return -ETIMEDOUT; 1165 } 1166 1167 /* read the converted data */ 1168 ret = regmap_bulk_read(st->regmap, LTC2983_CHAN_RES_ADDR(sensor->chan), 1169 &st->temp, sizeof(st->temp)); 1170 if (ret) 1171 return ret; 1172 1173 *val = __be32_to_cpu(st->temp); 1174 1175 if (!(LTC2983_RES_VALID_MASK & *val)) { 1176 dev_err(&st->spi->dev, "Invalid conversion detected\n"); 1177 return -EIO; 1178 } 1179 1180 ret = sensor->fault_handler(st, *val); 1181 if (ret) 1182 return ret; 1183 1184 *val = sign_extend32((*val) & LTC2983_DATA_MASK, LTC2983_DATA_SIGN_BIT); 1185 return 0; 1186 } 1187 1188 static int ltc2983_read_raw(struct iio_dev *indio_dev, 1189 struct iio_chan_spec const *chan, 1190 int *val, int *val2, long mask) 1191 { 1192 struct ltc2983_data *st = iio_priv(indio_dev); 1193 int ret; 1194 1195 /* sanity check */ 1196 if (chan->address >= st->num_channels) { 1197 dev_err(&st->spi->dev, "Invalid chan address:%ld", 1198 chan->address); 1199 return -EINVAL; 1200 } 1201 1202 switch (mask) { 1203 case IIO_CHAN_INFO_RAW: 1204 mutex_lock(&st->lock); 1205 ret = ltc2983_chan_read(st, st->sensors[chan->address], val); 1206 mutex_unlock(&st->lock); 1207 return ret ?: IIO_VAL_INT; 1208 case IIO_CHAN_INFO_SCALE: 1209 switch (chan->type) { 1210 case IIO_TEMP: 1211 /* value in milli degrees */ 1212 *val = 1000; 1213 /* 2^10 */ 1214 *val2 = 1024; 1215 return IIO_VAL_FRACTIONAL; 1216 case IIO_VOLTAGE: 1217 /* value in millivolt */ 1218 *val = 1000; 1219 /* 2^21 */ 1220 *val2 = 2097152; 1221 return IIO_VAL_FRACTIONAL; 1222 default: 1223 return -EINVAL; 1224 } 1225 } 1226 1227 return -EINVAL; 1228 } 1229 1230 static int ltc2983_reg_access(struct iio_dev *indio_dev, 1231 unsigned int reg, 1232 unsigned int writeval, 1233 unsigned int *readval) 1234 { 1235 struct ltc2983_data *st = iio_priv(indio_dev); 1236 1237 if (readval) 1238 return regmap_read(st->regmap, reg, readval); 1239 else 1240 return regmap_write(st->regmap, reg, writeval); 1241 } 1242 1243 static irqreturn_t ltc2983_irq_handler(int irq, void *data) 1244 { 1245 struct ltc2983_data *st = data; 1246 1247 complete(&st->completion); 1248 return IRQ_HANDLED; 1249 } 1250 1251 #define LTC2983_CHAN(__type, index, __address) ({ \ 1252 struct iio_chan_spec __chan = { \ 1253 .type = __type, \ 1254 .indexed = 1, \ 1255 .channel = index, \ 1256 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 1257 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 1258 .address = __address, \ 1259 }; \ 1260 __chan; \ 1261 }) 1262 1263 static int ltc2983_parse_dt(struct ltc2983_data *st) 1264 { 1265 struct device_node *child; 1266 struct device *dev = &st->spi->dev; 1267 int ret = 0, chan = 0, channel_avail_mask = 0; 1268 1269 of_property_read_u32(dev->of_node, "adi,mux-delay-config-us", 1270 &st->mux_delay_config); 1271 1272 of_property_read_u32(dev->of_node, "adi,filter-notch-freq", 1273 &st->filter_notch_freq); 1274 1275 st->num_channels = of_get_available_child_count(dev->of_node); 1276 st->sensors = devm_kcalloc(dev, st->num_channels, sizeof(*st->sensors), 1277 GFP_KERNEL); 1278 if (!st->sensors) 1279 return -ENOMEM; 1280 1281 st->iio_channels = st->num_channels; 1282 for_each_available_child_of_node(dev->of_node, child) { 1283 struct ltc2983_sensor sensor; 1284 1285 ret = of_property_read_u32(child, "reg", &sensor.chan); 1286 if (ret) { 1287 dev_err(dev, "reg property must given for child nodes\n"); 1288 return ret; 1289 } 1290 1291 /* check if we have a valid channel */ 1292 if (sensor.chan < LTC2983_MIN_CHANNELS_NR || 1293 sensor.chan > LTC2983_MAX_CHANNELS_NR) { 1294 dev_err(dev, 1295 "chan:%d must be from 1 to 20\n", sensor.chan); 1296 return -EINVAL; 1297 } else if (channel_avail_mask & BIT(sensor.chan)) { 1298 dev_err(dev, "chan:%d already in use\n", sensor.chan); 1299 return -EINVAL; 1300 } 1301 1302 ret = of_property_read_u32(child, "adi,sensor-type", 1303 &sensor.type); 1304 if (ret) { 1305 dev_err(dev, 1306 "adi,sensor-type property must given for child nodes\n"); 1307 return ret; 1308 } 1309 1310 dev_dbg(dev, "Create new sensor, type %u, chann %u", 1311 sensor.type, 1312 sensor.chan); 1313 1314 if (sensor.type >= LTC2983_SENSOR_THERMOCOUPLE && 1315 sensor.type <= LTC2983_SENSOR_THERMOCOUPLE_CUSTOM) { 1316 st->sensors[chan] = ltc2983_thermocouple_new(child, st, 1317 &sensor); 1318 } else if (sensor.type >= LTC2983_SENSOR_RTD && 1319 sensor.type <= LTC2983_SENSOR_RTD_CUSTOM) { 1320 st->sensors[chan] = ltc2983_rtd_new(child, st, &sensor); 1321 } else if (sensor.type >= LTC2983_SENSOR_THERMISTOR && 1322 sensor.type <= LTC2983_SENSOR_THERMISTOR_CUSTOM) { 1323 st->sensors[chan] = ltc2983_thermistor_new(child, st, 1324 &sensor); 1325 } else if (sensor.type == LTC2983_SENSOR_DIODE) { 1326 st->sensors[chan] = ltc2983_diode_new(child, st, 1327 &sensor); 1328 } else if (sensor.type == LTC2983_SENSOR_SENSE_RESISTOR) { 1329 st->sensors[chan] = ltc2983_r_sense_new(child, st, 1330 &sensor); 1331 /* don't add rsense to iio */ 1332 st->iio_channels--; 1333 } else if (sensor.type == LTC2983_SENSOR_DIRECT_ADC) { 1334 st->sensors[chan] = ltc2983_adc_new(child, st, &sensor); 1335 } else { 1336 dev_err(dev, "Unknown sensor type %d\n", sensor.type); 1337 return -EINVAL; 1338 } 1339 1340 if (IS_ERR(st->sensors[chan])) { 1341 dev_err(dev, "Failed to create sensor %ld", 1342 PTR_ERR(st->sensors[chan])); 1343 return PTR_ERR(st->sensors[chan]); 1344 } 1345 /* set generic sensor parameters */ 1346 st->sensors[chan]->chan = sensor.chan; 1347 st->sensors[chan]->type = sensor.type; 1348 1349 channel_avail_mask |= BIT(sensor.chan); 1350 chan++; 1351 } 1352 1353 return 0; 1354 } 1355 1356 static int ltc2983_setup(struct ltc2983_data *st, bool assign_iio) 1357 { 1358 u32 iio_chan_t = 0, iio_chan_v = 0, chan, iio_idx = 0; 1359 int ret; 1360 unsigned long time; 1361 1362 /* make sure the device is up */ 1363 time = wait_for_completion_timeout(&st->completion, 1364 msecs_to_jiffies(250)); 1365 1366 if (!time) { 1367 dev_err(&st->spi->dev, "Device startup timed out\n"); 1368 return -ETIMEDOUT; 1369 } 1370 1371 st->iio_chan = devm_kzalloc(&st->spi->dev, 1372 st->iio_channels * sizeof(*st->iio_chan), 1373 GFP_KERNEL); 1374 1375 if (!st->iio_chan) 1376 return -ENOMEM; 1377 1378 ret = regmap_update_bits(st->regmap, LTC2983_GLOBAL_CONFIG_REG, 1379 LTC2983_NOTCH_FREQ_MASK, 1380 LTC2983_NOTCH_FREQ(st->filter_notch_freq)); 1381 if (ret) 1382 return ret; 1383 1384 ret = regmap_write(st->regmap, LTC2983_MUX_CONFIG_REG, 1385 st->mux_delay_config); 1386 if (ret) 1387 return ret; 1388 1389 for (chan = 0; chan < st->num_channels; chan++) { 1390 u32 chan_type = 0, *iio_chan; 1391 1392 ret = st->sensors[chan]->assign_chan(st, st->sensors[chan]); 1393 if (ret) 1394 return ret; 1395 /* 1396 * The assign_iio flag is necessary for when the device is 1397 * coming out of sleep. In that case, we just need to 1398 * re-configure the device channels. 1399 * We also don't assign iio channels for rsense. 1400 */ 1401 if (st->sensors[chan]->type == LTC2983_SENSOR_SENSE_RESISTOR || 1402 !assign_iio) 1403 continue; 1404 1405 /* assign iio channel */ 1406 if (st->sensors[chan]->type != LTC2983_SENSOR_DIRECT_ADC) { 1407 chan_type = IIO_TEMP; 1408 iio_chan = &iio_chan_t; 1409 } else { 1410 chan_type = IIO_VOLTAGE; 1411 iio_chan = &iio_chan_v; 1412 } 1413 1414 /* 1415 * add chan as the iio .address so that, we can directly 1416 * reference the sensor given the iio_chan_spec 1417 */ 1418 st->iio_chan[iio_idx++] = LTC2983_CHAN(chan_type, (*iio_chan)++, 1419 chan); 1420 } 1421 1422 return 0; 1423 } 1424 1425 static const struct regmap_range ltc2983_reg_ranges[] = { 1426 regmap_reg_range(LTC2983_STATUS_REG, LTC2983_STATUS_REG), 1427 regmap_reg_range(LTC2983_TEMP_RES_START_REG, LTC2983_TEMP_RES_END_REG), 1428 regmap_reg_range(LTC2983_GLOBAL_CONFIG_REG, LTC2983_GLOBAL_CONFIG_REG), 1429 regmap_reg_range(LTC2983_MULT_CHANNEL_START_REG, 1430 LTC2983_MULT_CHANNEL_END_REG), 1431 regmap_reg_range(LTC2983_MUX_CONFIG_REG, LTC2983_MUX_CONFIG_REG), 1432 regmap_reg_range(LTC2983_CHAN_ASSIGN_START_REG, 1433 LTC2983_CHAN_ASSIGN_END_REG), 1434 regmap_reg_range(LTC2983_CUST_SENS_TBL_START_REG, 1435 LTC2983_CUST_SENS_TBL_END_REG), 1436 }; 1437 1438 static const struct regmap_access_table ltc2983_reg_table = { 1439 .yes_ranges = ltc2983_reg_ranges, 1440 .n_yes_ranges = ARRAY_SIZE(ltc2983_reg_ranges), 1441 }; 1442 1443 /* 1444 * The reg_bits are actually 12 but the device needs the first *complete* 1445 * byte for the command (R/W). 1446 */ 1447 static const struct regmap_config ltc2983_regmap_config = { 1448 .reg_bits = 24, 1449 .val_bits = 8, 1450 .wr_table = <c2983_reg_table, 1451 .rd_table = <c2983_reg_table, 1452 .read_flag_mask = GENMASK(1, 0), 1453 .write_flag_mask = BIT(1), 1454 }; 1455 1456 static const struct iio_info ltc2983_iio_info = { 1457 .read_raw = ltc2983_read_raw, 1458 .debugfs_reg_access = ltc2983_reg_access, 1459 }; 1460 1461 static int ltc2983_probe(struct spi_device *spi) 1462 { 1463 struct ltc2983_data *st; 1464 struct iio_dev *indio_dev; 1465 const char *name = spi_get_device_id(spi)->name; 1466 int ret; 1467 1468 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); 1469 if (!indio_dev) 1470 return -ENOMEM; 1471 1472 st = iio_priv(indio_dev); 1473 1474 st->regmap = devm_regmap_init_spi(spi, <c2983_regmap_config); 1475 if (IS_ERR(st->regmap)) { 1476 dev_err(&spi->dev, "Failed to initialize regmap\n"); 1477 return PTR_ERR(st->regmap); 1478 } 1479 1480 mutex_init(&st->lock); 1481 init_completion(&st->completion); 1482 st->spi = spi; 1483 spi_set_drvdata(spi, st); 1484 1485 ret = ltc2983_parse_dt(st); 1486 if (ret) 1487 return ret; 1488 /* 1489 * let's request the irq now so it is used to sync the device 1490 * startup in ltc2983_setup() 1491 */ 1492 ret = devm_request_irq(&spi->dev, spi->irq, ltc2983_irq_handler, 1493 IRQF_TRIGGER_RISING, name, st); 1494 if (ret) { 1495 dev_err(&spi->dev, "failed to request an irq, %d", ret); 1496 return ret; 1497 } 1498 1499 ret = ltc2983_setup(st, true); 1500 if (ret) 1501 return ret; 1502 1503 indio_dev->dev.parent = &spi->dev; 1504 indio_dev->name = name; 1505 indio_dev->num_channels = st->iio_channels; 1506 indio_dev->channels = st->iio_chan; 1507 indio_dev->modes = INDIO_DIRECT_MODE; 1508 indio_dev->info = <c2983_iio_info; 1509 1510 return devm_iio_device_register(&spi->dev, indio_dev); 1511 } 1512 1513 static int __maybe_unused ltc2983_resume(struct device *dev) 1514 { 1515 struct ltc2983_data *st = spi_get_drvdata(to_spi_device(dev)); 1516 int dummy; 1517 1518 /* dummy read to bring the device out of sleep */ 1519 regmap_read(st->regmap, LTC2983_STATUS_REG, &dummy); 1520 /* we need to re-assign the channels */ 1521 return ltc2983_setup(st, false); 1522 } 1523 1524 static int __maybe_unused ltc2983_suspend(struct device *dev) 1525 { 1526 struct ltc2983_data *st = spi_get_drvdata(to_spi_device(dev)); 1527 1528 return regmap_write(st->regmap, LTC2983_STATUS_REG, LTC2983_SLEEP); 1529 } 1530 1531 static SIMPLE_DEV_PM_OPS(ltc2983_pm_ops, ltc2983_suspend, ltc2983_resume); 1532 1533 static const struct spi_device_id ltc2983_id_table[] = { 1534 { "ltc2983" }, 1535 {}, 1536 }; 1537 MODULE_DEVICE_TABLE(spi, ltc2983_id_table); 1538 1539 static const struct of_device_id ltc2983_of_match[] = { 1540 { .compatible = "adi,ltc2983" }, 1541 {}, 1542 }; 1543 MODULE_DEVICE_TABLE(of, ltc2983_of_match); 1544 1545 static struct spi_driver ltc2983_driver = { 1546 .driver = { 1547 .name = "ltc2983", 1548 .of_match_table = ltc2983_of_match, 1549 .pm = <c2983_pm_ops, 1550 }, 1551 .probe = ltc2983_probe, 1552 .id_table = ltc2983_id_table, 1553 }; 1554 1555 module_spi_driver(ltc2983_driver); 1556 1557 MODULE_AUTHOR("Nuno Sa <nuno.sa@analog.com>"); 1558 MODULE_DESCRIPTION("Analog Devices LTC2983 SPI Temperature sensors"); 1559 MODULE_LICENSE("GPL"); 1560