1 /* 2 * adm1021.c - Part of lm_sensors, Linux kernel modules for hardware 3 * monitoring 4 * Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl> and 5 * Philip Edelbrock <phil@netroedge.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include <linux/module.h> 23 #include <linux/init.h> 24 #include <linux/slab.h> 25 #include <linux/jiffies.h> 26 #include <linux/i2c.h> 27 #include <linux/hwmon.h> 28 #include <linux/hwmon-sysfs.h> 29 #include <linux/err.h> 30 #include <linux/mutex.h> 31 32 33 /* Addresses to scan */ 34 static const unsigned short normal_i2c[] = { 35 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END }; 36 37 enum chips { 38 adm1021, adm1023, max1617, max1617a, thmc10, lm84, gl523sm, mc1066 }; 39 40 /* adm1021 constants specified below */ 41 42 /* The adm1021 registers */ 43 /* Read-only */ 44 /* For nr in 0-1 */ 45 #define ADM1021_REG_TEMP(nr) (nr) 46 #define ADM1021_REG_STATUS 0x02 47 /* 0x41 = AD, 0x49 = TI, 0x4D = Maxim, 0x23 = Genesys , 0x54 = Onsemi */ 48 #define ADM1021_REG_MAN_ID 0xFE 49 /* ADM1021 = 0x0X, ADM1023 = 0x3X */ 50 #define ADM1021_REG_DEV_ID 0xFF 51 /* These use different addresses for reading/writing */ 52 #define ADM1021_REG_CONFIG_R 0x03 53 #define ADM1021_REG_CONFIG_W 0x09 54 #define ADM1021_REG_CONV_RATE_R 0x04 55 #define ADM1021_REG_CONV_RATE_W 0x0A 56 /* These are for the ADM1023's additional precision on the remote temp sensor */ 57 #define ADM1023_REG_REM_TEMP_PREC 0x10 58 #define ADM1023_REG_REM_OFFSET 0x11 59 #define ADM1023_REG_REM_OFFSET_PREC 0x12 60 #define ADM1023_REG_REM_TOS_PREC 0x13 61 #define ADM1023_REG_REM_THYST_PREC 0x14 62 /* limits */ 63 /* For nr in 0-1 */ 64 #define ADM1021_REG_TOS_R(nr) (0x05 + 2 * (nr)) 65 #define ADM1021_REG_TOS_W(nr) (0x0B + 2 * (nr)) 66 #define ADM1021_REG_THYST_R(nr) (0x06 + 2 * (nr)) 67 #define ADM1021_REG_THYST_W(nr) (0x0C + 2 * (nr)) 68 /* write-only */ 69 #define ADM1021_REG_ONESHOT 0x0F 70 71 /* Initial values */ 72 73 /* 74 * Note: Even though I left the low and high limits named os and hyst, 75 * they don't quite work like a thermostat the way the LM75 does. I.e., 76 * a lower temp than THYST actually triggers an alarm instead of 77 * clearing it. Weird, ey? --Phil 78 */ 79 80 /* Each client has this additional data */ 81 struct adm1021_data { 82 struct i2c_client *client; 83 enum chips type; 84 85 const struct attribute_group *groups[3]; 86 87 struct mutex update_lock; 88 char valid; /* !=0 if following fields are valid */ 89 char low_power; /* !=0 if device in low power mode */ 90 unsigned long last_updated; /* In jiffies */ 91 92 int temp_max[2]; /* Register values */ 93 int temp_min[2]; 94 int temp[2]; 95 u8 alarms; 96 /* Special values for ADM1023 only */ 97 u8 remote_temp_offset; 98 u8 remote_temp_offset_prec; 99 }; 100 101 /* (amalysh) read only mode, otherwise any limit's writing confuse BIOS */ 102 static bool read_only; 103 104 static struct adm1021_data *adm1021_update_device(struct device *dev) 105 { 106 struct adm1021_data *data = dev_get_drvdata(dev); 107 struct i2c_client *client = data->client; 108 109 mutex_lock(&data->update_lock); 110 111 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 112 || !data->valid) { 113 int i; 114 115 dev_dbg(dev, "Starting adm1021 update\n"); 116 117 for (i = 0; i < 2; i++) { 118 data->temp[i] = 1000 * 119 (s8) i2c_smbus_read_byte_data( 120 client, ADM1021_REG_TEMP(i)); 121 data->temp_max[i] = 1000 * 122 (s8) i2c_smbus_read_byte_data( 123 client, ADM1021_REG_TOS_R(i)); 124 if (data->type != lm84) { 125 data->temp_min[i] = 1000 * 126 (s8) i2c_smbus_read_byte_data(client, 127 ADM1021_REG_THYST_R(i)); 128 } 129 } 130 data->alarms = i2c_smbus_read_byte_data(client, 131 ADM1021_REG_STATUS) & 0x7c; 132 if (data->type == adm1023) { 133 /* 134 * The ADM1023 provides 3 extra bits of precision for 135 * the remote sensor in extra registers. 136 */ 137 data->temp[1] += 125 * (i2c_smbus_read_byte_data( 138 client, ADM1023_REG_REM_TEMP_PREC) >> 5); 139 data->temp_max[1] += 125 * (i2c_smbus_read_byte_data( 140 client, ADM1023_REG_REM_TOS_PREC) >> 5); 141 data->temp_min[1] += 125 * (i2c_smbus_read_byte_data( 142 client, ADM1023_REG_REM_THYST_PREC) >> 5); 143 data->remote_temp_offset = 144 i2c_smbus_read_byte_data(client, 145 ADM1023_REG_REM_OFFSET); 146 data->remote_temp_offset_prec = 147 i2c_smbus_read_byte_data(client, 148 ADM1023_REG_REM_OFFSET_PREC); 149 } 150 data->last_updated = jiffies; 151 data->valid = 1; 152 } 153 154 mutex_unlock(&data->update_lock); 155 156 return data; 157 } 158 159 static ssize_t temp_show(struct device *dev, struct device_attribute *devattr, 160 char *buf) 161 { 162 int index = to_sensor_dev_attr(devattr)->index; 163 struct adm1021_data *data = adm1021_update_device(dev); 164 165 return sprintf(buf, "%d\n", data->temp[index]); 166 } 167 168 static ssize_t temp_max_show(struct device *dev, 169 struct device_attribute *devattr, char *buf) 170 { 171 int index = to_sensor_dev_attr(devattr)->index; 172 struct adm1021_data *data = adm1021_update_device(dev); 173 174 return sprintf(buf, "%d\n", data->temp_max[index]); 175 } 176 177 static ssize_t temp_min_show(struct device *dev, 178 struct device_attribute *devattr, char *buf) 179 { 180 int index = to_sensor_dev_attr(devattr)->index; 181 struct adm1021_data *data = adm1021_update_device(dev); 182 183 return sprintf(buf, "%d\n", data->temp_min[index]); 184 } 185 186 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr, 187 char *buf) 188 { 189 int index = to_sensor_dev_attr(attr)->index; 190 struct adm1021_data *data = adm1021_update_device(dev); 191 return sprintf(buf, "%u\n", (data->alarms >> index) & 1); 192 } 193 194 static ssize_t alarms_show(struct device *dev, 195 struct device_attribute *attr, 196 char *buf) 197 { 198 struct adm1021_data *data = adm1021_update_device(dev); 199 return sprintf(buf, "%u\n", data->alarms); 200 } 201 202 static ssize_t temp_max_store(struct device *dev, 203 struct device_attribute *devattr, 204 const char *buf, size_t count) 205 { 206 int index = to_sensor_dev_attr(devattr)->index; 207 struct adm1021_data *data = dev_get_drvdata(dev); 208 struct i2c_client *client = data->client; 209 long temp; 210 int reg_val, err; 211 212 err = kstrtol(buf, 10, &temp); 213 if (err) 214 return err; 215 temp /= 1000; 216 217 mutex_lock(&data->update_lock); 218 reg_val = clamp_val(temp, -128, 127); 219 data->temp_max[index] = reg_val * 1000; 220 if (!read_only) 221 i2c_smbus_write_byte_data(client, ADM1021_REG_TOS_W(index), 222 reg_val); 223 mutex_unlock(&data->update_lock); 224 225 return count; 226 } 227 228 static ssize_t temp_min_store(struct device *dev, 229 struct device_attribute *devattr, 230 const char *buf, size_t count) 231 { 232 int index = to_sensor_dev_attr(devattr)->index; 233 struct adm1021_data *data = dev_get_drvdata(dev); 234 struct i2c_client *client = data->client; 235 long temp; 236 int reg_val, err; 237 238 err = kstrtol(buf, 10, &temp); 239 if (err) 240 return err; 241 temp /= 1000; 242 243 mutex_lock(&data->update_lock); 244 reg_val = clamp_val(temp, -128, 127); 245 data->temp_min[index] = reg_val * 1000; 246 if (!read_only) 247 i2c_smbus_write_byte_data(client, ADM1021_REG_THYST_W(index), 248 reg_val); 249 mutex_unlock(&data->update_lock); 250 251 return count; 252 } 253 254 static ssize_t low_power_show(struct device *dev, 255 struct device_attribute *devattr, char *buf) 256 { 257 struct adm1021_data *data = adm1021_update_device(dev); 258 return sprintf(buf, "%d\n", data->low_power); 259 } 260 261 static ssize_t low_power_store(struct device *dev, 262 struct device_attribute *devattr, 263 const char *buf, size_t count) 264 { 265 struct adm1021_data *data = dev_get_drvdata(dev); 266 struct i2c_client *client = data->client; 267 char low_power; 268 unsigned long val; 269 int err; 270 271 err = kstrtoul(buf, 10, &val); 272 if (err) 273 return err; 274 low_power = val != 0; 275 276 mutex_lock(&data->update_lock); 277 if (low_power != data->low_power) { 278 int config = i2c_smbus_read_byte_data( 279 client, ADM1021_REG_CONFIG_R); 280 data->low_power = low_power; 281 i2c_smbus_write_byte_data(client, ADM1021_REG_CONFIG_W, 282 (config & 0xBF) | (low_power << 6)); 283 } 284 mutex_unlock(&data->update_lock); 285 286 return count; 287 } 288 289 290 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0); 291 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0); 292 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0); 293 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1); 294 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1); 295 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1); 296 static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 6); 297 static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, alarm, 5); 298 static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, 4); 299 static SENSOR_DEVICE_ATTR_RO(temp2_min_alarm, alarm, 3); 300 static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 2); 301 302 static DEVICE_ATTR_RO(alarms); 303 static DEVICE_ATTR_RW(low_power); 304 305 static struct attribute *adm1021_attributes[] = { 306 &sensor_dev_attr_temp1_max.dev_attr.attr, 307 &sensor_dev_attr_temp1_input.dev_attr.attr, 308 &sensor_dev_attr_temp2_max.dev_attr.attr, 309 &sensor_dev_attr_temp2_input.dev_attr.attr, 310 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 311 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 312 &sensor_dev_attr_temp2_fault.dev_attr.attr, 313 &dev_attr_alarms.attr, 314 &dev_attr_low_power.attr, 315 NULL 316 }; 317 318 static const struct attribute_group adm1021_group = { 319 .attrs = adm1021_attributes, 320 }; 321 322 static struct attribute *adm1021_min_attributes[] = { 323 &sensor_dev_attr_temp1_min.dev_attr.attr, 324 &sensor_dev_attr_temp2_min.dev_attr.attr, 325 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 326 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 327 NULL 328 }; 329 330 static const struct attribute_group adm1021_min_group = { 331 .attrs = adm1021_min_attributes, 332 }; 333 334 /* Return 0 if detection is successful, -ENODEV otherwise */ 335 static int adm1021_detect(struct i2c_client *client, 336 struct i2c_board_info *info) 337 { 338 struct i2c_adapter *adapter = client->adapter; 339 const char *type_name; 340 int conv_rate, status, config, man_id, dev_id; 341 342 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 343 pr_debug("detect failed, smbus byte data not supported!\n"); 344 return -ENODEV; 345 } 346 347 status = i2c_smbus_read_byte_data(client, ADM1021_REG_STATUS); 348 conv_rate = i2c_smbus_read_byte_data(client, 349 ADM1021_REG_CONV_RATE_R); 350 config = i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R); 351 352 /* Check unused bits */ 353 if ((status & 0x03) || (config & 0x3F) || (conv_rate & 0xF8)) { 354 pr_debug("detect failed, chip not detected!\n"); 355 return -ENODEV; 356 } 357 358 /* Determine the chip type. */ 359 man_id = i2c_smbus_read_byte_data(client, ADM1021_REG_MAN_ID); 360 dev_id = i2c_smbus_read_byte_data(client, ADM1021_REG_DEV_ID); 361 362 if (man_id < 0 || dev_id < 0) 363 return -ENODEV; 364 365 if (man_id == 0x4d && dev_id == 0x01) 366 type_name = "max1617a"; 367 else if (man_id == 0x41) { 368 if ((dev_id & 0xF0) == 0x30) 369 type_name = "adm1023"; 370 else if ((dev_id & 0xF0) == 0x00) 371 type_name = "adm1021"; 372 else 373 return -ENODEV; 374 } else if (man_id == 0x49) 375 type_name = "thmc10"; 376 else if (man_id == 0x23) 377 type_name = "gl523sm"; 378 else if (man_id == 0x54) 379 type_name = "mc1066"; 380 else { 381 int lte, rte, lhi, rhi, llo, rlo; 382 383 /* extra checks for LM84 and MAX1617 to avoid misdetections */ 384 385 llo = i2c_smbus_read_byte_data(client, ADM1021_REG_THYST_R(0)); 386 rlo = i2c_smbus_read_byte_data(client, ADM1021_REG_THYST_R(1)); 387 388 /* fail if any of the additional register reads failed */ 389 if (llo < 0 || rlo < 0) 390 return -ENODEV; 391 392 lte = i2c_smbus_read_byte_data(client, ADM1021_REG_TEMP(0)); 393 rte = i2c_smbus_read_byte_data(client, ADM1021_REG_TEMP(1)); 394 lhi = i2c_smbus_read_byte_data(client, ADM1021_REG_TOS_R(0)); 395 rhi = i2c_smbus_read_byte_data(client, ADM1021_REG_TOS_R(1)); 396 397 /* 398 * Fail for negative temperatures and negative high limits. 399 * This check also catches read errors on the tested registers. 400 */ 401 if ((s8)lte < 0 || (s8)rte < 0 || (s8)lhi < 0 || (s8)rhi < 0) 402 return -ENODEV; 403 404 /* fail if all registers hold the same value */ 405 if (lte == rte && lte == lhi && lte == rhi && lte == llo 406 && lte == rlo) 407 return -ENODEV; 408 409 /* 410 * LM84 Mfr ID is in a different place, 411 * and it has more unused bits. 412 */ 413 if (conv_rate == 0x00 414 && (config & 0x7F) == 0x00 415 && (status & 0xAB) == 0x00) { 416 type_name = "lm84"; 417 } else { 418 /* fail if low limits are larger than high limits */ 419 if ((s8)llo > lhi || (s8)rlo > rhi) 420 return -ENODEV; 421 type_name = "max1617"; 422 } 423 } 424 425 pr_debug("Detected chip %s at adapter %d, address 0x%02x.\n", 426 type_name, i2c_adapter_id(adapter), client->addr); 427 strlcpy(info->type, type_name, I2C_NAME_SIZE); 428 429 return 0; 430 } 431 432 static void adm1021_init_client(struct i2c_client *client) 433 { 434 /* Enable ADC and disable suspend mode */ 435 i2c_smbus_write_byte_data(client, ADM1021_REG_CONFIG_W, 436 i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R) & 0xBF); 437 /* Set Conversion rate to 1/sec (this can be tinkered with) */ 438 i2c_smbus_write_byte_data(client, ADM1021_REG_CONV_RATE_W, 0x04); 439 } 440 441 static int adm1021_probe(struct i2c_client *client, 442 const struct i2c_device_id *id) 443 { 444 struct device *dev = &client->dev; 445 struct adm1021_data *data; 446 struct device *hwmon_dev; 447 448 data = devm_kzalloc(dev, sizeof(struct adm1021_data), GFP_KERNEL); 449 if (!data) 450 return -ENOMEM; 451 452 data->client = client; 453 data->type = id->driver_data; 454 mutex_init(&data->update_lock); 455 456 /* Initialize the ADM1021 chip */ 457 if (data->type != lm84 && !read_only) 458 adm1021_init_client(client); 459 460 data->groups[0] = &adm1021_group; 461 if (data->type != lm84) 462 data->groups[1] = &adm1021_min_group; 463 464 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 465 data, data->groups); 466 467 return PTR_ERR_OR_ZERO(hwmon_dev); 468 } 469 470 static const struct i2c_device_id adm1021_id[] = { 471 { "adm1021", adm1021 }, 472 { "adm1023", adm1023 }, 473 { "max1617", max1617 }, 474 { "max1617a", max1617a }, 475 { "thmc10", thmc10 }, 476 { "lm84", lm84 }, 477 { "gl523sm", gl523sm }, 478 { "mc1066", mc1066 }, 479 { } 480 }; 481 MODULE_DEVICE_TABLE(i2c, adm1021_id); 482 483 static struct i2c_driver adm1021_driver = { 484 .class = I2C_CLASS_HWMON, 485 .driver = { 486 .name = "adm1021", 487 }, 488 .probe = adm1021_probe, 489 .id_table = adm1021_id, 490 .detect = adm1021_detect, 491 .address_list = normal_i2c, 492 }; 493 494 module_i2c_driver(adm1021_driver); 495 496 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and " 497 "Philip Edelbrock <phil@netroedge.com>"); 498 MODULE_DESCRIPTION("adm1021 driver"); 499 MODULE_LICENSE("GPL"); 500 501 module_param(read_only, bool, 0); 502 MODULE_PARM_DESC(read_only, "Don't set any values, read only mode"); 503