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 /* Insmod parameters */ 38 I2C_CLIENT_INSMOD_8(adm1021, adm1023, max1617, max1617a, thmc10, lm84, gl523sm, 39 mc1066); 40 41 /* adm1021 constants specified below */ 42 43 /* The adm1021 registers */ 44 /* Read-only */ 45 /* For nr in 0-1 */ 46 #define ADM1021_REG_TEMP(nr) (nr) 47 #define ADM1021_REG_STATUS 0x02 48 /* 0x41 = AD, 0x49 = TI, 0x4D = Maxim, 0x23 = Genesys , 0x54 = Onsemi */ 49 #define ADM1021_REG_MAN_ID 0xFE 50 /* ADM1021 = 0x0X, ADM1023 = 0x3X */ 51 #define ADM1021_REG_DEV_ID 0xFF 52 /* These use different addresses for reading/writing */ 53 #define ADM1021_REG_CONFIG_R 0x03 54 #define ADM1021_REG_CONFIG_W 0x09 55 #define ADM1021_REG_CONV_RATE_R 0x04 56 #define ADM1021_REG_CONV_RATE_W 0x0A 57 /* These are for the ADM1023's additional precision on the remote temp sensor */ 58 #define ADM1023_REG_REM_TEMP_PREC 0x10 59 #define ADM1023_REG_REM_OFFSET 0x11 60 #define ADM1023_REG_REM_OFFSET_PREC 0x12 61 #define ADM1023_REG_REM_TOS_PREC 0x13 62 #define ADM1023_REG_REM_THYST_PREC 0x14 63 /* limits */ 64 /* For nr in 0-1 */ 65 #define ADM1021_REG_TOS_R(nr) (0x05 + 2 * (nr)) 66 #define ADM1021_REG_TOS_W(nr) (0x0B + 2 * (nr)) 67 #define ADM1021_REG_THYST_R(nr) (0x06 + 2 * (nr)) 68 #define ADM1021_REG_THYST_W(nr) (0x0C + 2 * (nr)) 69 /* write-only */ 70 #define ADM1021_REG_ONESHOT 0x0F 71 72 /* Initial values */ 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 /* Each client has this additional data */ 80 struct adm1021_data { 81 struct i2c_client client; 82 struct device *hwmon_dev; 83 enum chips type; 84 85 struct mutex update_lock; 86 char valid; /* !=0 if following fields are valid */ 87 unsigned long last_updated; /* In jiffies */ 88 89 s8 temp_max[2]; /* Register values */ 90 s8 temp_min[2]; 91 s8 temp[2]; 92 u8 alarms; 93 /* Special values for ADM1023 only */ 94 u8 remote_temp_prec; 95 u8 remote_temp_os_prec; 96 u8 remote_temp_hyst_prec; 97 u8 remote_temp_offset; 98 u8 remote_temp_offset_prec; 99 }; 100 101 static int adm1021_attach_adapter(struct i2c_adapter *adapter); 102 static int adm1021_detect(struct i2c_adapter *adapter, int address, int kind); 103 static void adm1021_init_client(struct i2c_client *client); 104 static int adm1021_detach_client(struct i2c_client *client); 105 static struct adm1021_data *adm1021_update_device(struct device *dev); 106 107 /* (amalysh) read only mode, otherwise any limit's writing confuse BIOS */ 108 static int read_only; 109 110 111 /* This is the driver that will be inserted */ 112 static struct i2c_driver adm1021_driver = { 113 .driver = { 114 .name = "adm1021", 115 }, 116 .attach_adapter = adm1021_attach_adapter, 117 .detach_client = adm1021_detach_client, 118 }; 119 120 static ssize_t show_temp(struct device *dev, 121 struct device_attribute *devattr, char *buf) 122 { 123 int index = to_sensor_dev_attr(devattr)->index; 124 struct adm1021_data *data = adm1021_update_device(dev); 125 126 return sprintf(buf, "%d\n", 1000 * data->temp[index]); 127 } 128 129 static ssize_t show_temp_max(struct device *dev, 130 struct device_attribute *devattr, char *buf) 131 { 132 int index = to_sensor_dev_attr(devattr)->index; 133 struct adm1021_data *data = adm1021_update_device(dev); 134 135 return sprintf(buf, "%d\n", 1000 * data->temp_max[index]); 136 } 137 138 static ssize_t show_temp_min(struct device *dev, 139 struct device_attribute *devattr, char *buf) 140 { 141 int index = to_sensor_dev_attr(devattr)->index; 142 struct adm1021_data *data = adm1021_update_device(dev); 143 144 return sprintf(buf, "%d\n", 1000 * data->temp_min[index]); 145 } 146 147 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 148 char *buf) 149 { 150 int index = to_sensor_dev_attr(attr)->index; 151 struct adm1021_data *data = adm1021_update_device(dev); 152 return sprintf(buf, "%u\n", (data->alarms >> index) & 1); 153 } 154 155 static ssize_t show_alarms(struct device *dev, 156 struct device_attribute *attr, 157 char *buf) 158 { 159 struct adm1021_data *data = adm1021_update_device(dev); 160 return sprintf(buf, "%u\n", data->alarms); 161 } 162 163 static ssize_t set_temp_max(struct device *dev, 164 struct device_attribute *devattr, 165 const char *buf, size_t count) 166 { 167 int index = to_sensor_dev_attr(devattr)->index; 168 struct i2c_client *client = to_i2c_client(dev); 169 struct adm1021_data *data = i2c_get_clientdata(client); 170 long temp = simple_strtol(buf, NULL, 10) / 1000; 171 172 mutex_lock(&data->update_lock); 173 data->temp_max[index] = SENSORS_LIMIT(temp, -128, 127); 174 if (!read_only) 175 i2c_smbus_write_byte_data(client, ADM1021_REG_TOS_W(index), 176 data->temp_max[index]); 177 mutex_unlock(&data->update_lock); 178 179 return count; 180 } 181 182 static ssize_t set_temp_min(struct device *dev, 183 struct device_attribute *devattr, 184 const char *buf, size_t count) 185 { 186 int index = to_sensor_dev_attr(devattr)->index; 187 struct i2c_client *client = to_i2c_client(dev); 188 struct adm1021_data *data = i2c_get_clientdata(client); 189 long temp = simple_strtol(buf, NULL, 10) / 1000; 190 191 mutex_lock(&data->update_lock); 192 data->temp_min[index] = SENSORS_LIMIT(temp, -128, 127); 193 if (!read_only) 194 i2c_smbus_write_byte_data(client, ADM1021_REG_THYST_W(index), 195 data->temp_min[index]); 196 mutex_unlock(&data->update_lock); 197 198 return count; 199 } 200 201 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); 202 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max, 203 set_temp_max, 0); 204 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min, 205 set_temp_min, 0); 206 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1); 207 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max, 208 set_temp_max, 1); 209 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min, 210 set_temp_min, 1); 211 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6); 212 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5); 213 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4); 214 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3); 215 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2); 216 217 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 218 219 static int adm1021_attach_adapter(struct i2c_adapter *adapter) 220 { 221 if (!(adapter->class & I2C_CLASS_HWMON)) 222 return 0; 223 return i2c_probe(adapter, &addr_data, adm1021_detect); 224 } 225 226 static struct attribute *adm1021_attributes[] = { 227 &sensor_dev_attr_temp1_max.dev_attr.attr, 228 &sensor_dev_attr_temp1_min.dev_attr.attr, 229 &sensor_dev_attr_temp1_input.dev_attr.attr, 230 &sensor_dev_attr_temp2_max.dev_attr.attr, 231 &sensor_dev_attr_temp2_min.dev_attr.attr, 232 &sensor_dev_attr_temp2_input.dev_attr.attr, 233 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 234 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 235 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 236 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 237 &sensor_dev_attr_temp2_fault.dev_attr.attr, 238 &dev_attr_alarms.attr, 239 NULL 240 }; 241 242 static const struct attribute_group adm1021_group = { 243 .attrs = adm1021_attributes, 244 }; 245 246 static int adm1021_detect(struct i2c_adapter *adapter, int address, int kind) 247 { 248 int i; 249 struct i2c_client *client; 250 struct adm1021_data *data; 251 int err = 0; 252 const char *type_name = ""; 253 int conv_rate, status, config; 254 255 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 256 pr_debug("adm1021: detect failed, " 257 "smbus byte data not supported!\n"); 258 goto error0; 259 } 260 261 /* OK. For now, we presume we have a valid client. We now create the 262 client structure, even though we cannot fill it completely yet. 263 But it allows us to access adm1021 register values. */ 264 265 if (!(data = kzalloc(sizeof(struct adm1021_data), GFP_KERNEL))) { 266 pr_debug("adm1021: detect failed, kzalloc failed!\n"); 267 err = -ENOMEM; 268 goto error0; 269 } 270 271 client = &data->client; 272 i2c_set_clientdata(client, data); 273 client->addr = address; 274 client->adapter = adapter; 275 client->driver = &adm1021_driver; 276 status = i2c_smbus_read_byte_data(client, ADM1021_REG_STATUS); 277 conv_rate = i2c_smbus_read_byte_data(client, 278 ADM1021_REG_CONV_RATE_R); 279 config = i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R); 280 281 /* Now, we do the remaining detection. */ 282 if (kind < 0) { 283 if ((status & 0x03) != 0x00 || (config & 0x3F) != 0x00 284 || (conv_rate & 0xF8) != 0x00) { 285 pr_debug("adm1021: detect failed, " 286 "chip not detected!\n"); 287 err = -ENODEV; 288 goto error1; 289 } 290 } 291 292 /* Determine the chip type. */ 293 if (kind <= 0) { 294 i = i2c_smbus_read_byte_data(client, ADM1021_REG_MAN_ID); 295 if (i == 0x41) 296 if ((i2c_smbus_read_byte_data(client, 297 ADM1021_REG_DEV_ID) & 0xF0) == 0x30) 298 kind = adm1023; 299 else 300 kind = adm1021; 301 else if (i == 0x49) 302 kind = thmc10; 303 else if (i == 0x23) 304 kind = gl523sm; 305 else if ((i == 0x4d) && 306 (i2c_smbus_read_byte_data(client, 307 ADM1021_REG_DEV_ID) == 0x01)) 308 kind = max1617a; 309 else if (i == 0x54) 310 kind = mc1066; 311 /* LM84 Mfr ID in a different place, and it has more unused bits */ 312 else if (conv_rate == 0x00 313 && (kind == 0 /* skip extra detection */ 314 || ((config & 0x7F) == 0x00 315 && (status & 0xAB) == 0x00))) 316 kind = lm84; 317 else 318 kind = max1617; 319 } 320 321 if (kind == max1617) { 322 type_name = "max1617"; 323 } else if (kind == max1617a) { 324 type_name = "max1617a"; 325 } else if (kind == adm1021) { 326 type_name = "adm1021"; 327 } else if (kind == adm1023) { 328 type_name = "adm1023"; 329 } else if (kind == thmc10) { 330 type_name = "thmc10"; 331 } else if (kind == lm84) { 332 type_name = "lm84"; 333 } else if (kind == gl523sm) { 334 type_name = "gl523sm"; 335 } else if (kind == mc1066) { 336 type_name = "mc1066"; 337 } 338 pr_debug("adm1021: Detected chip %s at adapter %d, address 0x%02x.\n", 339 type_name, i2c_adapter_id(adapter), address); 340 341 /* Fill in the remaining client fields */ 342 strlcpy(client->name, type_name, I2C_NAME_SIZE); 343 data->type = kind; 344 mutex_init(&data->update_lock); 345 346 /* Tell the I2C layer a new client has arrived */ 347 if ((err = i2c_attach_client(client))) 348 goto error1; 349 350 /* Initialize the ADM1021 chip */ 351 if (kind != lm84 && !read_only) 352 adm1021_init_client(client); 353 354 /* Register sysfs hooks */ 355 if ((err = sysfs_create_group(&client->dev.kobj, &adm1021_group))) 356 goto error2; 357 358 data->hwmon_dev = hwmon_device_register(&client->dev); 359 if (IS_ERR(data->hwmon_dev)) { 360 err = PTR_ERR(data->hwmon_dev); 361 goto error3; 362 } 363 364 return 0; 365 366 error3: 367 sysfs_remove_group(&client->dev.kobj, &adm1021_group); 368 error2: 369 i2c_detach_client(client); 370 error1: 371 kfree(data); 372 error0: 373 return err; 374 } 375 376 static void adm1021_init_client(struct i2c_client *client) 377 { 378 /* Enable ADC and disable suspend mode */ 379 i2c_smbus_write_byte_data(client, ADM1021_REG_CONFIG_W, 380 i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R) & 0xBF); 381 /* Set Conversion rate to 1/sec (this can be tinkered with) */ 382 i2c_smbus_write_byte_data(client, ADM1021_REG_CONV_RATE_W, 0x04); 383 } 384 385 static int adm1021_detach_client(struct i2c_client *client) 386 { 387 struct adm1021_data *data = i2c_get_clientdata(client); 388 int err; 389 390 hwmon_device_unregister(data->hwmon_dev); 391 sysfs_remove_group(&client->dev.kobj, &adm1021_group); 392 393 if ((err = i2c_detach_client(client))) 394 return err; 395 396 kfree(data); 397 return 0; 398 } 399 400 static struct adm1021_data *adm1021_update_device(struct device *dev) 401 { 402 struct i2c_client *client = to_i2c_client(dev); 403 struct adm1021_data *data = i2c_get_clientdata(client); 404 405 mutex_lock(&data->update_lock); 406 407 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 408 || !data->valid) { 409 int i; 410 411 dev_dbg(&client->dev, "Starting adm1021 update\n"); 412 413 for (i = 0; i < 2; i++) { 414 data->temp[i] = i2c_smbus_read_byte_data(client, 415 ADM1021_REG_TEMP(i)); 416 data->temp_max[i] = i2c_smbus_read_byte_data(client, 417 ADM1021_REG_TOS_R(i)); 418 data->temp_min[i] = i2c_smbus_read_byte_data(client, 419 ADM1021_REG_THYST_R(i)); 420 } 421 data->alarms = i2c_smbus_read_byte_data(client, 422 ADM1021_REG_STATUS) & 0x7c; 423 if (data->type == adm1023) { 424 data->remote_temp_prec = 425 i2c_smbus_read_byte_data(client, 426 ADM1023_REG_REM_TEMP_PREC); 427 data->remote_temp_os_prec = 428 i2c_smbus_read_byte_data(client, 429 ADM1023_REG_REM_TOS_PREC); 430 data->remote_temp_hyst_prec = 431 i2c_smbus_read_byte_data(client, 432 ADM1023_REG_REM_THYST_PREC); 433 data->remote_temp_offset = 434 i2c_smbus_read_byte_data(client, 435 ADM1023_REG_REM_OFFSET); 436 data->remote_temp_offset_prec = 437 i2c_smbus_read_byte_data(client, 438 ADM1023_REG_REM_OFFSET_PREC); 439 } 440 data->last_updated = jiffies; 441 data->valid = 1; 442 } 443 444 mutex_unlock(&data->update_lock); 445 446 return data; 447 } 448 449 static int __init sensors_adm1021_init(void) 450 { 451 return i2c_add_driver(&adm1021_driver); 452 } 453 454 static void __exit sensors_adm1021_exit(void) 455 { 456 i2c_del_driver(&adm1021_driver); 457 } 458 459 MODULE_AUTHOR ("Frodo Looijaard <frodol@dds.nl> and " 460 "Philip Edelbrock <phil@netroedge.com>"); 461 MODULE_DESCRIPTION("adm1021 driver"); 462 MODULE_LICENSE("GPL"); 463 464 module_param(read_only, bool, 0); 465 MODULE_PARM_DESC(read_only, "Don't set any values, read only mode"); 466 467 module_init(sensors_adm1021_init) 468 module_exit(sensors_adm1021_exit) 469