1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Driver for MAX31730 3-Channel Remote Temperature Sensor 4 * 5 * Copyright (c) 2019 Guenter Roeck <linux@roeck-us.net> 6 */ 7 8 #include <linux/bits.h> 9 #include <linux/err.h> 10 #include <linux/i2c.h> 11 #include <linux/init.h> 12 #include <linux/hwmon.h> 13 #include <linux/module.h> 14 #include <linux/of.h> 15 #include <linux/slab.h> 16 17 /* Addresses scanned */ 18 static const unsigned short normal_i2c[] = { 0x1c, 0x1d, 0x1e, 0x1f, 0x4c, 19 0x4d, 0x4e, 0x4f, I2C_CLIENT_END }; 20 21 /* The MAX31730 registers */ 22 #define MAX31730_REG_TEMP 0x00 23 #define MAX31730_REG_CONF 0x13 24 #define MAX31730_STOP BIT(7) 25 #define MAX31730_EXTRANGE BIT(1) 26 #define MAX31730_REG_TEMP_OFFSET 0x16 27 #define MAX31730_TEMP_OFFSET_BASELINE 0x77 28 #define MAX31730_REG_OFFSET_ENABLE 0x17 29 #define MAX31730_REG_TEMP_MAX 0x20 30 #define MAX31730_REG_TEMP_MIN 0x30 31 #define MAX31730_REG_STATUS_HIGH 0x32 32 #define MAX31730_REG_STATUS_LOW 0x33 33 #define MAX31730_REG_CHANNEL_ENABLE 0x35 34 #define MAX31730_REG_TEMP_FAULT 0x36 35 36 #define MAX31730_REG_MFG_ID 0x50 37 #define MAX31730_MFG_ID 0x4d 38 #define MAX31730_REG_MFG_REV 0x51 39 #define MAX31730_MFG_REV 0x01 40 41 #define MAX31730_TEMP_MIN (-128000) 42 #define MAX31730_TEMP_MAX 127937 43 44 /* Each client has this additional data */ 45 struct max31730_data { 46 struct i2c_client *client; 47 u8 orig_conf; 48 u8 current_conf; 49 u8 offset_enable; 50 u8 channel_enable; 51 }; 52 53 /*-----------------------------------------------------------------------*/ 54 55 static inline long max31730_reg_to_mc(s16 temp) 56 { 57 return DIV_ROUND_CLOSEST((temp >> 4) * 1000, 16); 58 } 59 60 static int max31730_write_config(struct max31730_data *data, u8 set_mask, 61 u8 clr_mask) 62 { 63 u8 value; 64 65 clr_mask |= MAX31730_EXTRANGE; 66 value = data->current_conf & ~clr_mask; 67 value |= set_mask; 68 69 if (data->current_conf != value) { 70 s32 err; 71 72 err = i2c_smbus_write_byte_data(data->client, MAX31730_REG_CONF, 73 value); 74 if (err) 75 return err; 76 data->current_conf = value; 77 } 78 return 0; 79 } 80 81 static int max31730_set_enable(struct i2c_client *client, int reg, 82 u8 *confdata, int channel, bool enable) 83 { 84 u8 regval = *confdata; 85 int err; 86 87 if (enable) 88 regval |= BIT(channel); 89 else 90 regval &= ~BIT(channel); 91 92 if (regval != *confdata) { 93 err = i2c_smbus_write_byte_data(client, reg, regval); 94 if (err) 95 return err; 96 *confdata = regval; 97 } 98 return 0; 99 } 100 101 static int max31730_set_offset_enable(struct max31730_data *data, int channel, 102 bool enable) 103 { 104 return max31730_set_enable(data->client, MAX31730_REG_OFFSET_ENABLE, 105 &data->offset_enable, channel, enable); 106 } 107 108 static int max31730_set_channel_enable(struct max31730_data *data, int channel, 109 bool enable) 110 { 111 return max31730_set_enable(data->client, MAX31730_REG_CHANNEL_ENABLE, 112 &data->channel_enable, channel, enable); 113 } 114 115 static int max31730_read(struct device *dev, enum hwmon_sensor_types type, 116 u32 attr, int channel, long *val) 117 { 118 struct max31730_data *data = dev_get_drvdata(dev); 119 int regval, reg, offset; 120 121 if (type != hwmon_temp) 122 return -EINVAL; 123 124 switch (attr) { 125 case hwmon_temp_input: 126 if (!(data->channel_enable & BIT(channel))) 127 return -ENODATA; 128 reg = MAX31730_REG_TEMP + (channel * 2); 129 break; 130 case hwmon_temp_max: 131 reg = MAX31730_REG_TEMP_MAX + (channel * 2); 132 break; 133 case hwmon_temp_min: 134 reg = MAX31730_REG_TEMP_MIN; 135 break; 136 case hwmon_temp_enable: 137 *val = !!(data->channel_enable & BIT(channel)); 138 return 0; 139 case hwmon_temp_offset: 140 if (!channel) 141 return -EINVAL; 142 if (!(data->offset_enable & BIT(channel))) { 143 *val = 0; 144 return 0; 145 } 146 offset = i2c_smbus_read_byte_data(data->client, 147 MAX31730_REG_TEMP_OFFSET); 148 if (offset < 0) 149 return offset; 150 *val = (offset - MAX31730_TEMP_OFFSET_BASELINE) * 125; 151 return 0; 152 case hwmon_temp_fault: 153 regval = i2c_smbus_read_byte_data(data->client, 154 MAX31730_REG_TEMP_FAULT); 155 if (regval < 0) 156 return regval; 157 *val = !!(regval & BIT(channel)); 158 return 0; 159 case hwmon_temp_min_alarm: 160 regval = i2c_smbus_read_byte_data(data->client, 161 MAX31730_REG_STATUS_LOW); 162 if (regval < 0) 163 return regval; 164 *val = !!(regval & BIT(channel)); 165 return 0; 166 case hwmon_temp_max_alarm: 167 regval = i2c_smbus_read_byte_data(data->client, 168 MAX31730_REG_STATUS_HIGH); 169 if (regval < 0) 170 return regval; 171 *val = !!(regval & BIT(channel)); 172 return 0; 173 default: 174 return -EINVAL; 175 } 176 regval = i2c_smbus_read_word_swapped(data->client, reg); 177 if (regval < 0) 178 return regval; 179 180 *val = max31730_reg_to_mc(regval); 181 182 return 0; 183 } 184 185 static int max31730_write(struct device *dev, enum hwmon_sensor_types type, 186 u32 attr, int channel, long val) 187 { 188 struct max31730_data *data = dev_get_drvdata(dev); 189 int reg, err; 190 191 if (type != hwmon_temp) 192 return -EINVAL; 193 194 switch (attr) { 195 case hwmon_temp_max: 196 reg = MAX31730_REG_TEMP_MAX + channel * 2; 197 break; 198 case hwmon_temp_min: 199 reg = MAX31730_REG_TEMP_MIN; 200 break; 201 case hwmon_temp_enable: 202 if (val != 0 && val != 1) 203 return -EINVAL; 204 return max31730_set_channel_enable(data, channel, val); 205 case hwmon_temp_offset: 206 val = clamp_val(val, -14875, 17000) + 14875; 207 val = DIV_ROUND_CLOSEST(val, 125); 208 err = max31730_set_offset_enable(data, channel, 209 val != MAX31730_TEMP_OFFSET_BASELINE); 210 if (err) 211 return err; 212 return i2c_smbus_write_byte_data(data->client, 213 MAX31730_REG_TEMP_OFFSET, val); 214 default: 215 return -EINVAL; 216 } 217 218 val = clamp_val(val, MAX31730_TEMP_MIN, MAX31730_TEMP_MAX); 219 val = DIV_ROUND_CLOSEST(val << 4, 1000) << 4; 220 221 return i2c_smbus_write_word_swapped(data->client, reg, (u16)val); 222 } 223 224 static umode_t max31730_is_visible(const void *data, 225 enum hwmon_sensor_types type, 226 u32 attr, int channel) 227 { 228 switch (type) { 229 case hwmon_temp: 230 switch (attr) { 231 case hwmon_temp_input: 232 case hwmon_temp_min_alarm: 233 case hwmon_temp_max_alarm: 234 case hwmon_temp_fault: 235 return 0444; 236 case hwmon_temp_min: 237 return channel ? 0444 : 0644; 238 case hwmon_temp_offset: 239 case hwmon_temp_enable: 240 case hwmon_temp_max: 241 return 0644; 242 } 243 break; 244 default: 245 break; 246 } 247 return 0; 248 } 249 250 static const struct hwmon_channel_info * const max31730_info[] = { 251 HWMON_CHANNEL_INFO(chip, 252 HWMON_C_REGISTER_TZ), 253 HWMON_CHANNEL_INFO(temp, 254 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 255 HWMON_T_ENABLE | 256 HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM, 257 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 258 HWMON_T_OFFSET | HWMON_T_ENABLE | 259 HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM | 260 HWMON_T_FAULT, 261 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 262 HWMON_T_OFFSET | HWMON_T_ENABLE | 263 HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM | 264 HWMON_T_FAULT, 265 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 266 HWMON_T_OFFSET | HWMON_T_ENABLE | 267 HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM | 268 HWMON_T_FAULT 269 ), 270 NULL 271 }; 272 273 static const struct hwmon_ops max31730_hwmon_ops = { 274 .is_visible = max31730_is_visible, 275 .read = max31730_read, 276 .write = max31730_write, 277 }; 278 279 static const struct hwmon_chip_info max31730_chip_info = { 280 .ops = &max31730_hwmon_ops, 281 .info = max31730_info, 282 }; 283 284 static void max31730_remove(void *data) 285 { 286 struct max31730_data *max31730 = data; 287 struct i2c_client *client = max31730->client; 288 289 i2c_smbus_write_byte_data(client, MAX31730_REG_CONF, 290 max31730->orig_conf); 291 } 292 293 static int 294 max31730_probe(struct i2c_client *client) 295 { 296 struct device *dev = &client->dev; 297 struct device *hwmon_dev; 298 struct max31730_data *data; 299 int status, err; 300 301 if (!i2c_check_functionality(client->adapter, 302 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA)) 303 return -EIO; 304 305 data = devm_kzalloc(dev, sizeof(struct max31730_data), GFP_KERNEL); 306 if (!data) 307 return -ENOMEM; 308 309 data->client = client; 310 311 /* Cache original configuration and enable status */ 312 status = i2c_smbus_read_byte_data(client, MAX31730_REG_CHANNEL_ENABLE); 313 if (status < 0) 314 return status; 315 data->channel_enable = status; 316 317 status = i2c_smbus_read_byte_data(client, MAX31730_REG_OFFSET_ENABLE); 318 if (status < 0) 319 return status; 320 data->offset_enable = status; 321 322 status = i2c_smbus_read_byte_data(client, MAX31730_REG_CONF); 323 if (status < 0) 324 return status; 325 data->orig_conf = status; 326 data->current_conf = status; 327 328 err = max31730_write_config(data, 329 data->channel_enable ? 0 : MAX31730_STOP, 330 data->channel_enable ? MAX31730_STOP : 0); 331 if (err) 332 return err; 333 334 dev_set_drvdata(dev, data); 335 336 err = devm_add_action_or_reset(dev, max31730_remove, data); 337 if (err) 338 return err; 339 340 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, 341 data, 342 &max31730_chip_info, 343 NULL); 344 return PTR_ERR_OR_ZERO(hwmon_dev); 345 } 346 347 static const struct i2c_device_id max31730_ids[] = { 348 { "max31730" }, 349 { } 350 }; 351 MODULE_DEVICE_TABLE(i2c, max31730_ids); 352 353 static const struct of_device_id __maybe_unused max31730_of_match[] = { 354 { 355 .compatible = "maxim,max31730", 356 }, 357 { }, 358 }; 359 MODULE_DEVICE_TABLE(of, max31730_of_match); 360 361 static bool max31730_check_reg_temp(struct i2c_client *client, 362 int reg) 363 { 364 int regval; 365 366 regval = i2c_smbus_read_byte_data(client, reg + 1); 367 return regval < 0 || (regval & 0x0f); 368 } 369 370 /* Return 0 if detection is successful, -ENODEV otherwise */ 371 static int max31730_detect(struct i2c_client *client, 372 struct i2c_board_info *info) 373 { 374 struct i2c_adapter *adapter = client->adapter; 375 int regval; 376 int i; 377 378 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 379 I2C_FUNC_SMBUS_WORD_DATA)) 380 return -ENODEV; 381 382 regval = i2c_smbus_read_byte_data(client, MAX31730_REG_MFG_ID); 383 if (regval != MAX31730_MFG_ID) 384 return -ENODEV; 385 regval = i2c_smbus_read_byte_data(client, MAX31730_REG_MFG_REV); 386 if (regval != MAX31730_MFG_REV) 387 return -ENODEV; 388 389 /* lower 4 bit of temperature and limit registers must be 0 */ 390 if (max31730_check_reg_temp(client, MAX31730_REG_TEMP_MIN)) 391 return -ENODEV; 392 393 for (i = 0; i < 4; i++) { 394 if (max31730_check_reg_temp(client, MAX31730_REG_TEMP + i * 2)) 395 return -ENODEV; 396 if (max31730_check_reg_temp(client, 397 MAX31730_REG_TEMP_MAX + i * 2)) 398 return -ENODEV; 399 } 400 401 strscpy(info->type, "max31730", I2C_NAME_SIZE); 402 403 return 0; 404 } 405 406 static int max31730_suspend(struct device *dev) 407 { 408 struct max31730_data *data = dev_get_drvdata(dev); 409 410 return max31730_write_config(data, MAX31730_STOP, 0); 411 } 412 413 static int max31730_resume(struct device *dev) 414 { 415 struct max31730_data *data = dev_get_drvdata(dev); 416 417 return max31730_write_config(data, 0, MAX31730_STOP); 418 } 419 420 static DEFINE_SIMPLE_DEV_PM_OPS(max31730_pm_ops, max31730_suspend, max31730_resume); 421 422 static struct i2c_driver max31730_driver = { 423 .class = I2C_CLASS_HWMON, 424 .driver = { 425 .name = "max31730", 426 .of_match_table = of_match_ptr(max31730_of_match), 427 .pm = pm_sleep_ptr(&max31730_pm_ops), 428 }, 429 .probe = max31730_probe, 430 .id_table = max31730_ids, 431 .detect = max31730_detect, 432 .address_list = normal_i2c, 433 }; 434 435 module_i2c_driver(max31730_driver); 436 437 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>"); 438 MODULE_DESCRIPTION("MAX31730 driver"); 439 MODULE_LICENSE("GPL"); 440