1695 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Analog Devices LTC2983 Multi-Sensor Digital Temperature Measurement System4 * driver5 *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 <linux/unaligned.h>26 27/* register map */28#define LTC2983_STATUS_REG 0x000029#define LTC2983_TEMP_RES_START_REG 0x001030#define LTC2983_TEMP_RES_END_REG 0x005F31#define LTC2983_EEPROM_KEY_REG 0x00B032#define LTC2983_EEPROM_READ_STATUS_REG 0x00D033#define LTC2983_GLOBAL_CONFIG_REG 0x00F034#define LTC2983_MULT_CHANNEL_START_REG 0x00F435#define LTC2983_MULT_CHANNEL_END_REG 0x00F736#define LTC2986_EEPROM_STATUS_REG 0x00F937#define LTC2983_MUX_CONFIG_REG 0x00FF38#define LTC2983_CHAN_ASSIGN_START_REG 0x020039#define LTC2983_CHAN_ASSIGN_END_REG 0x024F40#define LTC2983_CUST_SENS_TBL_START_REG 0x025041#define LTC2983_CUST_SENS_TBL_END_REG 0x03CF42 43#define LTC2983_DIFFERENTIAL_CHAN_MIN 244#define LTC2983_MIN_CHANNELS_NR 145#define LTC2983_SLEEP 0x9746#define LTC2983_CUSTOM_STEINHART_SIZE 2447#define LTC2983_CUSTOM_SENSOR_ENTRY_SZ 648#define LTC2983_CUSTOM_STEINHART_ENTRY_SZ 449 50#define LTC2983_EEPROM_KEY 0xA53C0F5A51#define LTC2983_EEPROM_WRITE_CMD 0x1552#define LTC2983_EEPROM_READ_CMD 0x1653#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 260057#define LTC2983_EEPROM_READ_TIME_MS 2058 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 23126 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 177enum {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 212struct ltc2983_chip_info {213 const char *name;214 unsigned int max_channels_nr;215 bool has_temp;216 bool has_eeprom;217};218 219struct 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 the234 * transfer buffers to live in their own cache lines.235 * Holds the converted temperature236 */237 __be32 temp __aligned(IIO_DMA_MINALIGN);238 __be32 chan_val;239 __be32 eeprom_key;240};241 242struct 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 252struct 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 261struct ltc2983_thermocouple {262 struct ltc2983_sensor sensor;263 struct ltc2983_custom_sensor *custom;264 u32 sensor_config;265 u32 cold_junction_chan;266};267 268struct 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 277struct 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 285struct ltc2983_diode {286 struct ltc2983_sensor sensor;287 u32 sensor_config;288 u32 excitation_current;289 u32 ideal_factor_value;290};291 292struct ltc2983_rsense {293 struct ltc2983_sensor sensor;294 u32 r_sense_val;295};296 297struct ltc2983_adc {298 struct ltc2983_sensor sensor;299 bool single_ended;300};301 302struct 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 where310 * the number of integer and fractional bits are specified. The resolution311 * is given by 1/@resolution and tell us the number of fractional bits. For312 * instance a resolution of 2^-10 means we have 10 fractional bits.313 */314static 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 324static 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 333static 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 350static 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 364static 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, when374 * configuring the sensor channel, we must write the number of375 * entries of the table minus 1. For steinhart sensors 0 is written376 * 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 steinhart382 * 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 moment387 * when this test was done (successfully) for this custom388 * sensor, a steinhart sensor might have been added changing389 * 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 417static 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 others426 * 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 else435 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 else463 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 firmware469 * node. For the other sensors we must convert the value to raw.470 * The odd index's correspond to temperatures and always have 1/1024471 * of resolution. Temperatures also come in Kelvin, so signed values472 * 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 else493 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 steinhart503 * with the other sensors, we might have to do some roundup to make504 * sure that sensor_addr - 0x250(start address) is a multiple of 4505 * (for steinhart), and a multiple of 6 for all the other sensors.506 * Since we have const 24 bytes for steinhart sensors and 24 is507 * also a multiple of 6, we guarantee that the first non-steinhart508 * sensor will sit in a correct address without the need of filling509 * 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 523static 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 531static 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 539static 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 559static 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 581static 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 604static 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 617static 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 628static 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 639static 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 655static struct ltc2983_sensor *656ltc2983_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 return713 * 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 737static struct ltc2983_sensor *738ltc2983_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 be799 * >=19 since the chann + 1 is used in this configuration.800 * For 4wire RTDs with kelvin rsense, the rsense channel cannot be801 * <=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 887static struct ltc2983_sensor *888ltc2983_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 else919 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 else960 /* 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 1015static struct ltc2983_sensor *1016ltc2983_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 1078static 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_raw1102 * expects scales of 1000000 which are used for all other1103 * properties.1104 * 2^10 resolution1105 */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 1114static 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 1139static 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 1169static 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 conversions1190 * 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 1220static 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 1262static 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 1275static 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 1295static 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 1390static 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 1427static 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 is1468 * coming out of sleep. In that case, we just need to1469 * 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 directly1487 * reference the sensor given the iio_chan_spec1488 */1489 st->iio_chan[iio_idx++] = LTC2983_CHAN(chan_type, (*iio_chan)++,1490 chan);1491 }1492 1493 return 0;1494}1495 1496static 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 1513static 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 */1522static 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 1531static const struct iio_info ltc2983_iio_info = {1532 .read_raw = ltc2983_read_raw,1533 .debugfs_reg_access = ltc2983_reg_access,1534};1535 1536static 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 1616static 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 1627static 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 1634static DEFINE_SIMPLE_DEV_PM_OPS(ltc2983_pm_ops, ltc2983_suspend,1635 ltc2983_resume);1636 1637static const struct ltc2983_chip_info ltc2983_chip_info_data = {1638 .name = "ltc2983",1639 .max_channels_nr = 20,1640};1641 1642static const struct ltc2983_chip_info ltc2984_chip_info_data = {1643 .name = "ltc2984",1644 .max_channels_nr = 20,1645 .has_eeprom = true,1646};1647 1648static 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 1655static 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 1662static 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};1669MODULE_DEVICE_TABLE(spi, ltc2983_id_table);1670 1671static 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};1678MODULE_DEVICE_TABLE(of, ltc2983_of_match);1679 1680static 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 1690module_spi_driver(ltc2983_driver);1691 1692MODULE_AUTHOR("Nuno Sa <nuno.sa@analog.com>");1693MODULE_DESCRIPTION("Analog Devices LTC2983 SPI Temperature sensors");1694MODULE_LICENSE("GPL");1695