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