1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2008, 2010 Davide Rizzo <elpa.rizzo@gmail.com> 4 * 5 * The LM95241 is a sensor chip made by National Semiconductors. 6 * It reports up to three temperatures (its own plus up to two external ones). 7 * Complete datasheet can be obtained from National's website at: 8 * http://www.national.com/ds.cgi/LM/LM95241.pdf 9 */ 10 11 #include <linux/bitops.h> 12 #include <linux/err.h> 13 #include <linux/i2c.h> 14 #include <linux/init.h> 15 #include <linux/jiffies.h> 16 #include <linux/hwmon.h> 17 #include <linux/module.h> 18 #include <linux/slab.h> 19 20 #define DEVNAME "lm95241" 21 22 static const unsigned short normal_i2c[] = { 23 0x19, 0x2a, 0x2b, I2C_CLIENT_END }; 24 25 /* LM95241 registers */ 26 #define LM95241_REG_R_MAN_ID 0xFE 27 #define LM95241_REG_R_CHIP_ID 0xFF 28 #define LM95241_REG_R_STATUS 0x02 29 #define LM95241_REG_RW_CONFIG 0x03 30 #define LM95241_REG_RW_REM_FILTER 0x06 31 #define LM95241_REG_RW_TRUTHERM 0x07 32 #define LM95241_REG_W_ONE_SHOT 0x0F 33 #define LM95241_REG_R_LOCAL_TEMPH 0x10 34 #define LM95241_REG_R_REMOTE1_TEMPH 0x11 35 #define LM95241_REG_R_REMOTE2_TEMPH 0x12 36 #define LM95241_REG_R_LOCAL_TEMPL 0x20 37 #define LM95241_REG_R_REMOTE1_TEMPL 0x21 38 #define LM95241_REG_R_REMOTE2_TEMPL 0x22 39 #define LM95241_REG_RW_REMOTE_MODEL 0x30 40 41 /* LM95241 specific bitfields */ 42 #define CFG_STOP BIT(6) 43 #define CFG_CR0076 0x00 44 #define CFG_CR0182 BIT(4) 45 #define CFG_CR1000 BIT(5) 46 #define CFG_CR2700 (BIT(4) | BIT(5)) 47 #define CFG_CRMASK (BIT(4) | BIT(5)) 48 #define R1MS_MASK BIT(0) 49 #define R2MS_MASK BIT(2) 50 #define R1DF_MASK BIT(1) 51 #define R2DF_MASK BIT(2) 52 #define R1FE_MASK BIT(0) 53 #define R2FE_MASK BIT(2) 54 #define R1DM BIT(0) 55 #define R2DM BIT(1) 56 #define TT1_SHIFT 0 57 #define TT2_SHIFT 4 58 #define TT_OFF 0 59 #define TT_ON 1 60 #define TT_MASK 7 61 #define NATSEMI_MAN_ID 0x01 62 #define LM95231_CHIP_ID 0xA1 63 #define LM95241_CHIP_ID 0xA4 64 65 static const u8 lm95241_reg_address[] = { 66 LM95241_REG_R_LOCAL_TEMPH, 67 LM95241_REG_R_LOCAL_TEMPL, 68 LM95241_REG_R_REMOTE1_TEMPH, 69 LM95241_REG_R_REMOTE1_TEMPL, 70 LM95241_REG_R_REMOTE2_TEMPH, 71 LM95241_REG_R_REMOTE2_TEMPL 72 }; 73 74 /* Client data (each client gets its own) */ 75 struct lm95241_data { 76 struct i2c_client *client; 77 unsigned long last_updated; /* in jiffies */ 78 unsigned long interval; /* in milli-seconds */ 79 bool valid; /* false until following fields are valid */ 80 /* registers values */ 81 u8 temp[ARRAY_SIZE(lm95241_reg_address)]; 82 u8 status, config, model, trutherm; 83 }; 84 85 /* Conversions */ 86 static int temp_from_reg_signed(u8 val_h, u8 val_l) 87 { 88 s16 val_hl = (val_h << 8) | val_l; 89 return val_hl * 1000 / 256; 90 } 91 92 static int temp_from_reg_unsigned(u8 val_h, u8 val_l) 93 { 94 u16 val_hl = (val_h << 8) | val_l; 95 return val_hl * 1000 / 256; 96 } 97 98 static struct lm95241_data *lm95241_update_device(struct device *dev) 99 { 100 struct lm95241_data *data = dev_get_drvdata(dev); 101 struct i2c_client *client = data->client; 102 103 if (time_after(jiffies, data->last_updated 104 + msecs_to_jiffies(data->interval)) || 105 !data->valid) { 106 int i; 107 108 dev_dbg(dev, "Updating lm95241 data.\n"); 109 for (i = 0; i < ARRAY_SIZE(lm95241_reg_address); i++) 110 data->temp[i] 111 = i2c_smbus_read_byte_data(client, 112 lm95241_reg_address[i]); 113 114 data->status = i2c_smbus_read_byte_data(client, 115 LM95241_REG_R_STATUS); 116 data->last_updated = jiffies; 117 data->valid = true; 118 } 119 return data; 120 } 121 122 static int lm95241_read_chip(struct device *dev, u32 attr, int channel, 123 long *val) 124 { 125 struct lm95241_data *data = dev_get_drvdata(dev); 126 127 switch (attr) { 128 case hwmon_chip_update_interval: 129 *val = data->interval; 130 return 0; 131 default: 132 return -EOPNOTSUPP; 133 } 134 } 135 136 static int lm95241_read_temp(struct device *dev, u32 attr, int channel, 137 long *val) 138 { 139 struct lm95241_data *data = lm95241_update_device(dev); 140 141 switch (attr) { 142 case hwmon_temp_input: 143 if (!channel || (data->config & BIT(channel - 1))) 144 *val = temp_from_reg_signed(data->temp[channel * 2], 145 data->temp[channel * 2 + 1]); 146 else 147 *val = temp_from_reg_unsigned(data->temp[channel * 2], 148 data->temp[channel * 2 + 1]); 149 return 0; 150 case hwmon_temp_min: 151 if (channel == 1) 152 *val = (data->config & R1DF_MASK) ? -128000 : 0; 153 else 154 *val = (data->config & R2DF_MASK) ? -128000 : 0; 155 return 0; 156 case hwmon_temp_max: 157 if (channel == 1) 158 *val = (data->config & R1DF_MASK) ? 127875 : 255875; 159 else 160 *val = (data->config & R2DF_MASK) ? 127875 : 255875; 161 return 0; 162 case hwmon_temp_type: 163 if (channel == 1) 164 *val = (data->model & R1MS_MASK) ? 1 : 2; 165 else 166 *val = (data->model & R2MS_MASK) ? 1 : 2; 167 return 0; 168 case hwmon_temp_fault: 169 if (channel == 1) 170 *val = !!(data->status & R1DM); 171 else 172 *val = !!(data->status & R2DM); 173 return 0; 174 default: 175 return -EOPNOTSUPP; 176 } 177 } 178 179 static int lm95241_read(struct device *dev, enum hwmon_sensor_types type, 180 u32 attr, int channel, long *val) 181 { 182 switch (type) { 183 case hwmon_chip: 184 return lm95241_read_chip(dev, attr, channel, val); 185 case hwmon_temp: 186 return lm95241_read_temp(dev, attr, channel, val); 187 default: 188 return -EOPNOTSUPP; 189 } 190 } 191 192 static int lm95241_write_chip(struct device *dev, u32 attr, int channel, 193 long val) 194 { 195 struct lm95241_data *data = dev_get_drvdata(dev); 196 int convrate; 197 u8 config; 198 int ret; 199 200 switch (attr) { 201 case hwmon_chip_update_interval: 202 config = data->config & ~CFG_CRMASK; 203 if (val < 130) { 204 convrate = 76; 205 config |= CFG_CR0076; 206 } else if (val < 590) { 207 convrate = 182; 208 config |= CFG_CR0182; 209 } else if (val < 1850) { 210 convrate = 1000; 211 config |= CFG_CR1000; 212 } else { 213 convrate = 2700; 214 config |= CFG_CR2700; 215 } 216 data->interval = convrate; 217 data->config = config; 218 ret = i2c_smbus_write_byte_data(data->client, 219 LM95241_REG_RW_CONFIG, config); 220 break; 221 default: 222 ret = -EOPNOTSUPP; 223 break; 224 } 225 return ret; 226 } 227 228 static int lm95241_write_temp(struct device *dev, u32 attr, int channel, 229 long val) 230 { 231 struct lm95241_data *data = dev_get_drvdata(dev); 232 struct i2c_client *client = data->client; 233 int ret; 234 235 switch (attr) { 236 case hwmon_temp_min: 237 if (channel == 1) { 238 if (val < 0) 239 data->config |= R1DF_MASK; 240 else 241 data->config &= ~R1DF_MASK; 242 } else { 243 if (val < 0) 244 data->config |= R2DF_MASK; 245 else 246 data->config &= ~R2DF_MASK; 247 } 248 data->valid = false; 249 ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, 250 data->config); 251 break; 252 case hwmon_temp_max: 253 if (channel == 1) { 254 if (val <= 127875) 255 data->config |= R1DF_MASK; 256 else 257 data->config &= ~R1DF_MASK; 258 } else { 259 if (val <= 127875) 260 data->config |= R2DF_MASK; 261 else 262 data->config &= ~R2DF_MASK; 263 } 264 data->valid = false; 265 ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, 266 data->config); 267 break; 268 case hwmon_temp_type: 269 if (val != 1 && val != 2) { 270 ret = -EINVAL; 271 break; 272 } 273 if (channel == 1) { 274 data->trutherm &= ~(TT_MASK << TT1_SHIFT); 275 if (val == 1) { 276 data->model |= R1MS_MASK; 277 data->trutherm |= (TT_ON << TT1_SHIFT); 278 } else { 279 data->model &= ~R1MS_MASK; 280 data->trutherm |= (TT_OFF << TT1_SHIFT); 281 } 282 } else { 283 data->trutherm &= ~(TT_MASK << TT2_SHIFT); 284 if (val == 1) { 285 data->model |= R2MS_MASK; 286 data->trutherm |= (TT_ON << TT2_SHIFT); 287 } else { 288 data->model &= ~R2MS_MASK; 289 data->trutherm |= (TT_OFF << TT2_SHIFT); 290 } 291 } 292 ret = i2c_smbus_write_byte_data(client, 293 LM95241_REG_RW_REMOTE_MODEL, 294 data->model); 295 if (ret < 0) 296 break; 297 ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM, 298 data->trutherm); 299 break; 300 default: 301 ret = -EOPNOTSUPP; 302 break; 303 } 304 return ret; 305 } 306 307 static int lm95241_write(struct device *dev, enum hwmon_sensor_types type, 308 u32 attr, int channel, long val) 309 { 310 switch (type) { 311 case hwmon_chip: 312 return lm95241_write_chip(dev, attr, channel, val); 313 case hwmon_temp: 314 return lm95241_write_temp(dev, attr, channel, val); 315 default: 316 return -EOPNOTSUPP; 317 } 318 } 319 320 static umode_t lm95241_is_visible(const void *data, 321 enum hwmon_sensor_types type, 322 u32 attr, int channel) 323 { 324 switch (type) { 325 case hwmon_chip: 326 switch (attr) { 327 case hwmon_chip_update_interval: 328 return 0644; 329 } 330 break; 331 case hwmon_temp: 332 switch (attr) { 333 case hwmon_temp_input: 334 return 0444; 335 case hwmon_temp_fault: 336 return 0444; 337 case hwmon_temp_min: 338 case hwmon_temp_max: 339 case hwmon_temp_type: 340 return 0644; 341 } 342 break; 343 default: 344 break; 345 } 346 return 0; 347 } 348 349 /* Return 0 if detection is successful, -ENODEV otherwise */ 350 static int lm95241_detect(struct i2c_client *new_client, 351 struct i2c_board_info *info) 352 { 353 struct i2c_adapter *adapter = new_client->adapter; 354 const char *name; 355 int mfg_id, chip_id; 356 357 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 358 return -ENODEV; 359 360 mfg_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID); 361 if (mfg_id != NATSEMI_MAN_ID) 362 return -ENODEV; 363 364 chip_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID); 365 switch (chip_id) { 366 case LM95231_CHIP_ID: 367 name = "lm95231"; 368 break; 369 case LM95241_CHIP_ID: 370 name = "lm95241"; 371 break; 372 default: 373 return -ENODEV; 374 } 375 376 /* Fill the i2c board info */ 377 strscpy(info->type, name, I2C_NAME_SIZE); 378 return 0; 379 } 380 381 static void lm95241_init_client(struct i2c_client *client, 382 struct lm95241_data *data) 383 { 384 data->interval = 1000; 385 data->config = CFG_CR1000; 386 data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT); 387 388 i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config); 389 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REM_FILTER, 390 R1FE_MASK | R2FE_MASK); 391 i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM, 392 data->trutherm); 393 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL, 394 data->model); 395 } 396 397 static const struct hwmon_channel_info * const lm95241_info[] = { 398 HWMON_CHANNEL_INFO(chip, 399 HWMON_C_UPDATE_INTERVAL), 400 HWMON_CHANNEL_INFO(temp, 401 HWMON_T_INPUT, 402 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN | 403 HWMON_T_TYPE | HWMON_T_FAULT, 404 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN | 405 HWMON_T_TYPE | HWMON_T_FAULT), 406 NULL 407 }; 408 409 static const struct hwmon_ops lm95241_hwmon_ops = { 410 .is_visible = lm95241_is_visible, 411 .read = lm95241_read, 412 .write = lm95241_write, 413 }; 414 415 static const struct hwmon_chip_info lm95241_chip_info = { 416 .ops = &lm95241_hwmon_ops, 417 .info = lm95241_info, 418 }; 419 420 static int lm95241_probe(struct i2c_client *client) 421 { 422 struct device *dev = &client->dev; 423 struct lm95241_data *data; 424 struct device *hwmon_dev; 425 426 data = devm_kzalloc(dev, sizeof(struct lm95241_data), GFP_KERNEL); 427 if (!data) 428 return -ENOMEM; 429 430 data->client = client; 431 432 /* Initialize the LM95241 chip */ 433 lm95241_init_client(client, data); 434 435 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, 436 data, 437 &lm95241_chip_info, 438 NULL); 439 return PTR_ERR_OR_ZERO(hwmon_dev); 440 } 441 442 /* Driver data (common to all clients) */ 443 static const struct i2c_device_id lm95241_id[] = { 444 { "lm95231" }, 445 { "lm95241" }, 446 { } 447 }; 448 MODULE_DEVICE_TABLE(i2c, lm95241_id); 449 450 static struct i2c_driver lm95241_driver = { 451 .class = I2C_CLASS_HWMON, 452 .driver = { 453 .name = DEVNAME, 454 }, 455 .probe = lm95241_probe, 456 .id_table = lm95241_id, 457 .detect = lm95241_detect, 458 .address_list = normal_i2c, 459 }; 460 461 module_i2c_driver(lm95241_driver); 462 463 MODULE_AUTHOR("Davide Rizzo <elpa.rizzo@gmail.com>"); 464 MODULE_DESCRIPTION("LM95231/LM95241 sensor driver"); 465 MODULE_LICENSE("GPL"); 466