1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * lm83.c - Part of lm_sensors, Linux kernel modules for hardware 4 * monitoring 5 * Copyright (C) 2003-2009 Jean Delvare <jdelvare@suse.de> 6 * 7 * Heavily inspired from the lm78, lm75 and adm1021 drivers. The LM83 is 8 * a sensor chip made by National Semiconductor. It reports up to four 9 * temperatures (its own plus up to three external ones) with a 1 deg 10 * resolution and a 3-4 deg accuracy. Complete datasheet can be obtained 11 * from National's website at: 12 * http://www.national.com/pf/LM/LM83.html 13 * Since the datasheet omits to give the chip stepping code, I give it 14 * here: 0x03 (at register 0xff). 15 * 16 * Also supports the LM82 temp sensor, which is basically a stripped down 17 * model of the LM83. Datasheet is here: 18 * http://www.national.com/pf/LM/LM82.html 19 */ 20 21#include <linux/module.h> 22#include <linux/init.h> 23#include <linux/slab.h> 24#include <linux/jiffies.h> 25#include <linux/i2c.h> 26#include <linux/hwmon-sysfs.h> 27#include <linux/hwmon.h> 28#include <linux/err.h> 29#include <linux/mutex.h> 30#include <linux/sysfs.h> 31 32/* 33 * Addresses to scan 34 * Address is selected using 2 three-level pins, resulting in 9 possible 35 * addresses. 36 */ 37 38static const unsigned short normal_i2c[] = { 39 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END }; 40 41enum chips { lm83, lm82 }; 42 43/* 44 * The LM83 registers 45 * Manufacturer ID is 0x01 for National Semiconductor. 46 */ 47 48#define LM83_REG_R_MAN_ID 0xFE 49#define LM83_REG_R_CHIP_ID 0xFF 50#define LM83_REG_R_CONFIG 0x03 51#define LM83_REG_W_CONFIG 0x09 52#define LM83_REG_R_STATUS1 0x02 53#define LM83_REG_R_STATUS2 0x35 54#define LM83_REG_R_LOCAL_TEMP 0x00 55#define LM83_REG_R_LOCAL_HIGH 0x05 56#define LM83_REG_W_LOCAL_HIGH 0x0B 57#define LM83_REG_R_REMOTE1_TEMP 0x30 58#define LM83_REG_R_REMOTE1_HIGH 0x38 59#define LM83_REG_W_REMOTE1_HIGH 0x50 60#define LM83_REG_R_REMOTE2_TEMP 0x01 61#define LM83_REG_R_REMOTE2_HIGH 0x07 62#define LM83_REG_W_REMOTE2_HIGH 0x0D 63#define LM83_REG_R_REMOTE3_TEMP 0x31 64#define LM83_REG_R_REMOTE3_HIGH 0x3A 65#define LM83_REG_W_REMOTE3_HIGH 0x52 66#define LM83_REG_R_TCRIT 0x42 67#define LM83_REG_W_TCRIT 0x5A 68 69/* 70 * Conversions and various macros 71 * The LM83 uses signed 8-bit values with LSB = 1 degree Celsius. 72 */ 73 74#define TEMP_FROM_REG(val) ((val) * 1000) 75#define TEMP_TO_REG(val) ((val) <= -128000 ? -128 : \ 76 (val) >= 127000 ? 127 : \ 77 (val) < 0 ? ((val) - 500) / 1000 : \ 78 ((val) + 500) / 1000) 79 80static const u8 LM83_REG_R_TEMP[] = { 81 LM83_REG_R_LOCAL_TEMP, 82 LM83_REG_R_REMOTE1_TEMP, 83 LM83_REG_R_REMOTE2_TEMP, 84 LM83_REG_R_REMOTE3_TEMP, 85 LM83_REG_R_LOCAL_HIGH, 86 LM83_REG_R_REMOTE1_HIGH, 87 LM83_REG_R_REMOTE2_HIGH, 88 LM83_REG_R_REMOTE3_HIGH, 89 LM83_REG_R_TCRIT, 90}; 91 92static const u8 LM83_REG_W_HIGH[] = { 93 LM83_REG_W_LOCAL_HIGH, 94 LM83_REG_W_REMOTE1_HIGH, 95 LM83_REG_W_REMOTE2_HIGH, 96 LM83_REG_W_REMOTE3_HIGH, 97 LM83_REG_W_TCRIT, 98}; 99 100/* 101 * Client data (each client gets its own) 102 */ 103 104struct lm83_data { 105 struct i2c_client *client; 106 const struct attribute_group *groups[3]; 107 struct mutex update_lock; 108 char valid; /* zero until following fields are valid */ 109 unsigned long last_updated; /* in jiffies */ 110 111 /* registers values */ 112 s8 temp[9]; /* 0..3: input 1-4, 113 4..7: high limit 1-4, 114 8 : critical limit */ 115 u16 alarms; /* bitvector, combined */ 116}; 117 118static struct lm83_data *lm83_update_device(struct device *dev) 119{ 120 struct lm83_data *data = dev_get_drvdata(dev); 121 struct i2c_client *client = data->client; 122 123 mutex_lock(&data->update_lock); 124 125 if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) { 126 int nr; 127 128 dev_dbg(&client->dev, "Updating lm83 data.\n"); 129 for (nr = 0; nr < 9; nr++) { 130 data->temp[nr] = 131 i2c_smbus_read_byte_data(client, 132 LM83_REG_R_TEMP[nr]); 133 } 134 data->alarms = 135 i2c_smbus_read_byte_data(client, LM83_REG_R_STATUS1) 136 + (i2c_smbus_read_byte_data(client, LM83_REG_R_STATUS2) 137 << 8); 138 139 data->last_updated = jiffies; 140 data->valid = 1; 141 } 142 143 mutex_unlock(&data->update_lock); 144 145 return data; 146} 147 148/* 149 * Sysfs stuff 150 */ 151 152static ssize_t temp_show(struct device *dev, struct device_attribute *devattr, 153 char *buf) 154{ 155 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 156 struct lm83_data *data = lm83_update_device(dev); 157 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[attr->index])); 158} 159 160static ssize_t temp_store(struct device *dev, 161 struct device_attribute *devattr, const char *buf, 162 size_t count) 163{ 164 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 165 struct lm83_data *data = dev_get_drvdata(dev); 166 struct i2c_client *client = data->client; 167 long val; 168 int nr = attr->index; 169 int err; 170 171 err = kstrtol(buf, 10, &val); 172 if (err < 0) 173 return err; 174 175 mutex_lock(&data->update_lock); 176 data->temp[nr] = TEMP_TO_REG(val); 177 i2c_smbus_write_byte_data(client, LM83_REG_W_HIGH[nr - 4], 178 data->temp[nr]); 179 mutex_unlock(&data->update_lock); 180 return count; 181} 182 183static ssize_t alarms_show(struct device *dev, struct device_attribute *dummy, 184 char *buf) 185{ 186 struct lm83_data *data = lm83_update_device(dev); 187 return sprintf(buf, "%d\n", data->alarms); 188} 189 190static ssize_t alarm_show(struct device *dev, 191 struct device_attribute *devattr, char *buf) 192{ 193 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 194 struct lm83_data *data = lm83_update_device(dev); 195 int bitnr = attr->index; 196 197 return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1); 198} 199 200static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0); 201static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1); 202static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2); 203static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3); 204static SENSOR_DEVICE_ATTR_RW(temp1_max, temp, 4); 205static SENSOR_DEVICE_ATTR_RW(temp2_max, temp, 5); 206static SENSOR_DEVICE_ATTR_RW(temp3_max, temp, 6); 207static SENSOR_DEVICE_ATTR_RW(temp4_max, temp, 7); 208static SENSOR_DEVICE_ATTR_RO(temp1_crit, temp, 8); 209static SENSOR_DEVICE_ATTR_RO(temp2_crit, temp, 8); 210static SENSOR_DEVICE_ATTR_RW(temp3_crit, temp, 8); 211static SENSOR_DEVICE_ATTR_RO(temp4_crit, temp, 8); 212 213/* Individual alarm files */ 214static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, alarm, 0); 215static SENSOR_DEVICE_ATTR_RO(temp3_crit_alarm, alarm, 1); 216static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 2); 217static SENSOR_DEVICE_ATTR_RO(temp3_max_alarm, alarm, 4); 218static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 6); 219static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, 8); 220static SENSOR_DEVICE_ATTR_RO(temp4_crit_alarm, alarm, 9); 221static SENSOR_DEVICE_ATTR_RO(temp4_fault, alarm, 10); 222static SENSOR_DEVICE_ATTR_RO(temp4_max_alarm, alarm, 12); 223static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 13); 224static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, 15); 225/* Raw alarm file for compatibility */ 226static DEVICE_ATTR_RO(alarms); 227 228static struct attribute *lm83_attributes[] = { 229 &sensor_dev_attr_temp1_input.dev_attr.attr, 230 &sensor_dev_attr_temp3_input.dev_attr.attr, 231 &sensor_dev_attr_temp1_max.dev_attr.attr, 232 &sensor_dev_attr_temp3_max.dev_attr.attr, 233 &sensor_dev_attr_temp1_crit.dev_attr.attr, 234 &sensor_dev_attr_temp3_crit.dev_attr.attr, 235 236 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 237 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 238 &sensor_dev_attr_temp3_fault.dev_attr.attr, 239 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 240 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 241 &dev_attr_alarms.attr, 242 NULL 243}; 244 245static const struct attribute_group lm83_group = { 246 .attrs = lm83_attributes, 247}; 248 249static struct attribute *lm83_attributes_opt[] = { 250 &sensor_dev_attr_temp2_input.dev_attr.attr, 251 &sensor_dev_attr_temp4_input.dev_attr.attr, 252 &sensor_dev_attr_temp2_max.dev_attr.attr, 253 &sensor_dev_attr_temp4_max.dev_attr.attr, 254 &sensor_dev_attr_temp2_crit.dev_attr.attr, 255 &sensor_dev_attr_temp4_crit.dev_attr.attr, 256 257 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 258 &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr, 259 &sensor_dev_attr_temp4_fault.dev_attr.attr, 260 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr, 261 &sensor_dev_attr_temp2_fault.dev_attr.attr, 262 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 263 NULL 264}; 265 266static const struct attribute_group lm83_group_opt = { 267 .attrs = lm83_attributes_opt, 268}; 269 270/* 271 * Real code 272 */ 273 274/* Return 0 if detection is successful, -ENODEV otherwise */ 275static int lm83_detect(struct i2c_client *new_client, 276 struct i2c_board_info *info) 277{ 278 struct i2c_adapter *adapter = new_client->adapter; 279 const char *name; 280 u8 man_id, chip_id; 281 282 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 283 return -ENODEV; 284 285 /* Detection */ 286 if ((i2c_smbus_read_byte_data(new_client, LM83_REG_R_STATUS1) & 0xA8) || 287 (i2c_smbus_read_byte_data(new_client, LM83_REG_R_STATUS2) & 0x48) || 288 (i2c_smbus_read_byte_data(new_client, LM83_REG_R_CONFIG) & 0x41)) { 289 dev_dbg(&adapter->dev, "LM83 detection failed at 0x%02x\n", 290 new_client->addr); 291 return -ENODEV; 292 } 293 294 /* Identification */ 295 man_id = i2c_smbus_read_byte_data(new_client, LM83_REG_R_MAN_ID); 296 if (man_id != 0x01) /* National Semiconductor */ 297 return -ENODEV; 298 299 chip_id = i2c_smbus_read_byte_data(new_client, LM83_REG_R_CHIP_ID); 300 switch (chip_id) { 301 case 0x03: 302 name = "lm83"; 303 break; 304 case 0x01: 305 name = "lm82"; 306 break; 307 default: 308 /* identification failed */ 309 dev_info(&adapter->dev, 310 "Unsupported chip (man_id=0x%02X, chip_id=0x%02X)\n", 311 man_id, chip_id); 312 return -ENODEV; 313 } 314 315 strlcpy(info->type, name, I2C_NAME_SIZE); 316 317 return 0; 318} 319 320static const struct i2c_device_id lm83_id[]; 321 322static int lm83_probe(struct i2c_client *new_client) 323{ 324 struct device *hwmon_dev; 325 struct lm83_data *data; 326 327 data = devm_kzalloc(&new_client->dev, sizeof(struct lm83_data), 328 GFP_KERNEL); 329 if (!data) 330 return -ENOMEM; 331 332 data->client = new_client; 333 mutex_init(&data->update_lock); 334 335 /* 336 * Register sysfs hooks 337 * The LM82 can only monitor one external diode which is 338 * at the same register as the LM83 temp3 entry - so we 339 * declare 1 and 3 common, and then 2 and 4 only for the LM83. 340 */ 341 data->groups[0] = &lm83_group; 342 if (i2c_match_id(lm83_id, new_client)->driver_data == lm83) 343 data->groups[1] = &lm83_group_opt; 344 345 hwmon_dev = devm_hwmon_device_register_with_groups(&new_client->dev, 346 new_client->name, 347 data, data->groups); 348 return PTR_ERR_OR_ZERO(hwmon_dev); 349} 350 351/* 352 * Driver data (common to all clients) 353 */ 354 355static const struct i2c_device_id lm83_id[] = { 356 { "lm83", lm83 }, 357 { "lm82", lm82 }, 358 { } 359}; 360MODULE_DEVICE_TABLE(i2c, lm83_id); 361 362static struct i2c_driver lm83_driver = { 363 .class = I2C_CLASS_HWMON, 364 .driver = { 365 .name = "lm83", 366 }, 367 .probe_new = lm83_probe, 368 .id_table = lm83_id, 369 .detect = lm83_detect, 370 .address_list = normal_i2c, 371}; 372 373module_i2c_driver(lm83_driver); 374 375MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>"); 376MODULE_DESCRIPTION("LM83 driver"); 377MODULE_LICENSE("GPL"); 378