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 show_temp(struct device *dev, 160 struct device_attribute *devattr, 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 show_temp_max(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 show_temp_min(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 show_alarm(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 set_temp_max(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 set_temp_min(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(temp1_input, S_IRUGO, show_temp, NULL, 0); 291 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max, 292 set_temp_max, 0); 293 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min, 294 set_temp_min, 0); 295 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1); 296 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max, 297 set_temp_max, 1); 298 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min, 299 set_temp_min, 1); 300 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6); 301 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5); 302 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4); 303 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3); 304 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2); 305 306 static DEVICE_ATTR_RO(alarms); 307 static DEVICE_ATTR_RW(low_power); 308 309 static struct attribute *adm1021_attributes[] = { 310 &sensor_dev_attr_temp1_max.dev_attr.attr, 311 &sensor_dev_attr_temp1_input.dev_attr.attr, 312 &sensor_dev_attr_temp2_max.dev_attr.attr, 313 &sensor_dev_attr_temp2_input.dev_attr.attr, 314 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 315 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 316 &sensor_dev_attr_temp2_fault.dev_attr.attr, 317 &dev_attr_alarms.attr, 318 &dev_attr_low_power.attr, 319 NULL 320 }; 321 322 static const struct attribute_group adm1021_group = { 323 .attrs = adm1021_attributes, 324 }; 325 326 static struct attribute *adm1021_min_attributes[] = { 327 &sensor_dev_attr_temp1_min.dev_attr.attr, 328 &sensor_dev_attr_temp2_min.dev_attr.attr, 329 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 330 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 331 NULL 332 }; 333 334 static const struct attribute_group adm1021_min_group = { 335 .attrs = adm1021_min_attributes, 336 }; 337 338 /* Return 0 if detection is successful, -ENODEV otherwise */ 339 static int adm1021_detect(struct i2c_client *client, 340 struct i2c_board_info *info) 341 { 342 struct i2c_adapter *adapter = client->adapter; 343 const char *type_name; 344 int conv_rate, status, config, man_id, dev_id; 345 346 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 347 pr_debug("detect failed, smbus byte data not supported!\n"); 348 return -ENODEV; 349 } 350 351 status = i2c_smbus_read_byte_data(client, ADM1021_REG_STATUS); 352 conv_rate = i2c_smbus_read_byte_data(client, 353 ADM1021_REG_CONV_RATE_R); 354 config = i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R); 355 356 /* Check unused bits */ 357 if ((status & 0x03) || (config & 0x3F) || (conv_rate & 0xF8)) { 358 pr_debug("detect failed, chip not detected!\n"); 359 return -ENODEV; 360 } 361 362 /* Determine the chip type. */ 363 man_id = i2c_smbus_read_byte_data(client, ADM1021_REG_MAN_ID); 364 dev_id = i2c_smbus_read_byte_data(client, ADM1021_REG_DEV_ID); 365 366 if (man_id < 0 || dev_id < 0) 367 return -ENODEV; 368 369 if (man_id == 0x4d && dev_id == 0x01) 370 type_name = "max1617a"; 371 else if (man_id == 0x41) { 372 if ((dev_id & 0xF0) == 0x30) 373 type_name = "adm1023"; 374 else if ((dev_id & 0xF0) == 0x00) 375 type_name = "adm1021"; 376 else 377 return -ENODEV; 378 } else if (man_id == 0x49) 379 type_name = "thmc10"; 380 else if (man_id == 0x23) 381 type_name = "gl523sm"; 382 else if (man_id == 0x54) 383 type_name = "mc1066"; 384 else { 385 int lte, rte, lhi, rhi, llo, rlo; 386 387 /* extra checks for LM84 and MAX1617 to avoid misdetections */ 388 389 llo = i2c_smbus_read_byte_data(client, ADM1021_REG_THYST_R(0)); 390 rlo = i2c_smbus_read_byte_data(client, ADM1021_REG_THYST_R(1)); 391 392 /* fail if any of the additional register reads failed */ 393 if (llo < 0 || rlo < 0) 394 return -ENODEV; 395 396 lte = i2c_smbus_read_byte_data(client, ADM1021_REG_TEMP(0)); 397 rte = i2c_smbus_read_byte_data(client, ADM1021_REG_TEMP(1)); 398 lhi = i2c_smbus_read_byte_data(client, ADM1021_REG_TOS_R(0)); 399 rhi = i2c_smbus_read_byte_data(client, ADM1021_REG_TOS_R(1)); 400 401 /* 402 * Fail for negative temperatures and negative high limits. 403 * This check also catches read errors on the tested registers. 404 */ 405 if ((s8)lte < 0 || (s8)rte < 0 || (s8)lhi < 0 || (s8)rhi < 0) 406 return -ENODEV; 407 408 /* fail if all registers hold the same value */ 409 if (lte == rte && lte == lhi && lte == rhi && lte == llo 410 && lte == rlo) 411 return -ENODEV; 412 413 /* 414 * LM84 Mfr ID is in a different place, 415 * and it has more unused bits. 416 */ 417 if (conv_rate == 0x00 418 && (config & 0x7F) == 0x00 419 && (status & 0xAB) == 0x00) { 420 type_name = "lm84"; 421 } else { 422 /* fail if low limits are larger than high limits */ 423 if ((s8)llo > lhi || (s8)rlo > rhi) 424 return -ENODEV; 425 type_name = "max1617"; 426 } 427 } 428 429 pr_debug("Detected chip %s at adapter %d, address 0x%02x.\n", 430 type_name, i2c_adapter_id(adapter), client->addr); 431 strlcpy(info->type, type_name, I2C_NAME_SIZE); 432 433 return 0; 434 } 435 436 static void adm1021_init_client(struct i2c_client *client) 437 { 438 /* Enable ADC and disable suspend mode */ 439 i2c_smbus_write_byte_data(client, ADM1021_REG_CONFIG_W, 440 i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R) & 0xBF); 441 /* Set Conversion rate to 1/sec (this can be tinkered with) */ 442 i2c_smbus_write_byte_data(client, ADM1021_REG_CONV_RATE_W, 0x04); 443 } 444 445 static int adm1021_probe(struct i2c_client *client, 446 const struct i2c_device_id *id) 447 { 448 struct device *dev = &client->dev; 449 struct adm1021_data *data; 450 struct device *hwmon_dev; 451 452 data = devm_kzalloc(dev, sizeof(struct adm1021_data), GFP_KERNEL); 453 if (!data) 454 return -ENOMEM; 455 456 data->client = client; 457 data->type = id->driver_data; 458 mutex_init(&data->update_lock); 459 460 /* Initialize the ADM1021 chip */ 461 if (data->type != lm84 && !read_only) 462 adm1021_init_client(client); 463 464 data->groups[0] = &adm1021_group; 465 if (data->type != lm84) 466 data->groups[1] = &adm1021_min_group; 467 468 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 469 data, data->groups); 470 471 return PTR_ERR_OR_ZERO(hwmon_dev); 472 } 473 474 static const struct i2c_device_id adm1021_id[] = { 475 { "adm1021", adm1021 }, 476 { "adm1023", adm1023 }, 477 { "max1617", max1617 }, 478 { "max1617a", max1617a }, 479 { "thmc10", thmc10 }, 480 { "lm84", lm84 }, 481 { "gl523sm", gl523sm }, 482 { "mc1066", mc1066 }, 483 { } 484 }; 485 MODULE_DEVICE_TABLE(i2c, adm1021_id); 486 487 static struct i2c_driver adm1021_driver = { 488 .class = I2C_CLASS_HWMON, 489 .driver = { 490 .name = "adm1021", 491 }, 492 .probe = adm1021_probe, 493 .id_table = adm1021_id, 494 .detect = adm1021_detect, 495 .address_list = normal_i2c, 496 }; 497 498 module_i2c_driver(adm1021_driver); 499 500 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and " 501 "Philip Edelbrock <phil@netroedge.com>"); 502 MODULE_DESCRIPTION("adm1021 driver"); 503 MODULE_LICENSE("GPL"); 504 505 module_param(read_only, bool, 0); 506 MODULE_PARM_DESC(read_only, "Don't set any values, read only mode"); 507