1 /* 2 thmc50.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 Copyright (C) 2007 Krzysztof Helt <krzysztof.h1@wp.pl> 5 Based on 2.4 driver by Frodo Looijaard <frodol@dds.nl> and 6 Philip Edelbrock <phil@netroedge.com> 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 */ 22 23 #include <linux/module.h> 24 #include <linux/init.h> 25 #include <linux/slab.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 MODULE_LICENSE("GPL"); 33 34 /* Addresses to scan */ 35 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END }; 36 37 /* Insmod parameters */ 38 I2C_CLIENT_INSMOD_2(thmc50, adm1022); 39 I2C_CLIENT_MODULE_PARM(adm1022_temp3, "List of adapter,address pairs " 40 "to enable 3rd temperature (ADM1022 only)"); 41 42 /* Many THMC50 constants specified below */ 43 44 /* The THMC50 registers */ 45 #define THMC50_REG_CONF 0x40 46 #define THMC50_REG_COMPANY_ID 0x3E 47 #define THMC50_REG_DIE_CODE 0x3F 48 #define THMC50_REG_ANALOG_OUT 0x19 49 /* 50 * The mirror status register cannot be used as 51 * reading it does not clear alarms. 52 */ 53 #define THMC50_REG_INTR 0x41 54 55 static const u8 THMC50_REG_TEMP[] = { 0x27, 0x26, 0x20 }; 56 static const u8 THMC50_REG_TEMP_MIN[] = { 0x3A, 0x38, 0x2C }; 57 static const u8 THMC50_REG_TEMP_MAX[] = { 0x39, 0x37, 0x2B }; 58 static const u8 THMC50_REG_TEMP_CRITICAL[] = { 0x13, 0x14, 0x14 }; 59 static const u8 THMC50_REG_TEMP_DEFAULT[] = { 0x17, 0x18, 0x18 }; 60 61 #define THMC50_REG_CONF_nFANOFF 0x20 62 #define THMC50_REG_CONF_PROGRAMMED 0x08 63 64 /* Each client has this additional data */ 65 struct thmc50_data { 66 struct device *hwmon_dev; 67 68 struct mutex update_lock; 69 enum chips type; 70 unsigned long last_updated; /* In jiffies */ 71 char has_temp3; /* !=0 if it is ADM1022 in temp3 mode */ 72 char valid; /* !=0 if following fields are valid */ 73 74 /* Register values */ 75 s8 temp_input[3]; 76 s8 temp_max[3]; 77 s8 temp_min[3]; 78 s8 temp_critical[3]; 79 u8 analog_out; 80 u8 alarms; 81 }; 82 83 static int thmc50_detect(struct i2c_client *client, int kind, 84 struct i2c_board_info *info); 85 static int thmc50_probe(struct i2c_client *client, 86 const struct i2c_device_id *id); 87 static int thmc50_remove(struct i2c_client *client); 88 static void thmc50_init_client(struct i2c_client *client); 89 static struct thmc50_data *thmc50_update_device(struct device *dev); 90 91 static const struct i2c_device_id thmc50_id[] = { 92 { "adm1022", adm1022 }, 93 { "thmc50", thmc50 }, 94 { } 95 }; 96 MODULE_DEVICE_TABLE(i2c, thmc50_id); 97 98 static struct i2c_driver thmc50_driver = { 99 .class = I2C_CLASS_HWMON, 100 .driver = { 101 .name = "thmc50", 102 }, 103 .probe = thmc50_probe, 104 .remove = thmc50_remove, 105 .id_table = thmc50_id, 106 .detect = thmc50_detect, 107 .address_data = &addr_data, 108 }; 109 110 static ssize_t show_analog_out(struct device *dev, 111 struct device_attribute *attr, char *buf) 112 { 113 struct thmc50_data *data = thmc50_update_device(dev); 114 return sprintf(buf, "%d\n", data->analog_out); 115 } 116 117 static ssize_t set_analog_out(struct device *dev, 118 struct device_attribute *attr, 119 const char *buf, size_t count) 120 { 121 struct i2c_client *client = to_i2c_client(dev); 122 struct thmc50_data *data = i2c_get_clientdata(client); 123 int tmp = simple_strtoul(buf, NULL, 10); 124 int config; 125 126 mutex_lock(&data->update_lock); 127 data->analog_out = SENSORS_LIMIT(tmp, 0, 255); 128 i2c_smbus_write_byte_data(client, THMC50_REG_ANALOG_OUT, 129 data->analog_out); 130 131 config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF); 132 if (data->analog_out == 0) 133 config &= ~THMC50_REG_CONF_nFANOFF; 134 else 135 config |= THMC50_REG_CONF_nFANOFF; 136 i2c_smbus_write_byte_data(client, THMC50_REG_CONF, config); 137 138 mutex_unlock(&data->update_lock); 139 return count; 140 } 141 142 /* There is only one PWM mode = DC */ 143 static ssize_t show_pwm_mode(struct device *dev, struct device_attribute *attr, 144 char *buf) 145 { 146 return sprintf(buf, "0\n"); 147 } 148 149 /* Temperatures */ 150 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, 151 char *buf) 152 { 153 int nr = to_sensor_dev_attr(attr)->index; 154 struct thmc50_data *data = thmc50_update_device(dev); 155 return sprintf(buf, "%d\n", data->temp_input[nr] * 1000); 156 } 157 158 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr, 159 char *buf) 160 { 161 int nr = to_sensor_dev_attr(attr)->index; 162 struct thmc50_data *data = thmc50_update_device(dev); 163 return sprintf(buf, "%d\n", data->temp_min[nr] * 1000); 164 } 165 166 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr, 167 const char *buf, size_t count) 168 { 169 int nr = to_sensor_dev_attr(attr)->index; 170 struct i2c_client *client = to_i2c_client(dev); 171 struct thmc50_data *data = i2c_get_clientdata(client); 172 int val = simple_strtol(buf, NULL, 10); 173 174 mutex_lock(&data->update_lock); 175 data->temp_min[nr] = SENSORS_LIMIT(val / 1000, -128, 127); 176 i2c_smbus_write_byte_data(client, THMC50_REG_TEMP_MIN[nr], 177 data->temp_min[nr]); 178 mutex_unlock(&data->update_lock); 179 return count; 180 } 181 182 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr, 183 char *buf) 184 { 185 int nr = to_sensor_dev_attr(attr)->index; 186 struct thmc50_data *data = thmc50_update_device(dev); 187 return sprintf(buf, "%d\n", data->temp_max[nr] * 1000); 188 } 189 190 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, 191 const char *buf, size_t count) 192 { 193 int nr = to_sensor_dev_attr(attr)->index; 194 struct i2c_client *client = to_i2c_client(dev); 195 struct thmc50_data *data = i2c_get_clientdata(client); 196 int val = simple_strtol(buf, NULL, 10); 197 198 mutex_lock(&data->update_lock); 199 data->temp_max[nr] = SENSORS_LIMIT(val / 1000, -128, 127); 200 i2c_smbus_write_byte_data(client, THMC50_REG_TEMP_MAX[nr], 201 data->temp_max[nr]); 202 mutex_unlock(&data->update_lock); 203 return count; 204 } 205 206 static ssize_t show_temp_critical(struct device *dev, 207 struct device_attribute *attr, 208 char *buf) 209 { 210 int nr = to_sensor_dev_attr(attr)->index; 211 struct thmc50_data *data = thmc50_update_device(dev); 212 return sprintf(buf, "%d\n", data->temp_critical[nr] * 1000); 213 } 214 215 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 216 char *buf) 217 { 218 int index = to_sensor_dev_attr(attr)->index; 219 struct thmc50_data *data = thmc50_update_device(dev); 220 221 return sprintf(buf, "%u\n", (data->alarms >> index) & 1); 222 } 223 224 #define temp_reg(offset) \ 225 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp, \ 226 NULL, offset - 1); \ 227 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \ 228 show_temp_min, set_temp_min, offset - 1); \ 229 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ 230 show_temp_max, set_temp_max, offset - 1); \ 231 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO, \ 232 show_temp_critical, NULL, offset - 1); 233 234 temp_reg(1); 235 temp_reg(2); 236 temp_reg(3); 237 238 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 0); 239 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5); 240 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 1); 241 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 7); 242 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 2); 243 244 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_analog_out, 245 set_analog_out, 0); 246 static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO, show_pwm_mode, NULL, 0); 247 248 static struct attribute *thmc50_attributes[] = { 249 &sensor_dev_attr_temp1_max.dev_attr.attr, 250 &sensor_dev_attr_temp1_min.dev_attr.attr, 251 &sensor_dev_attr_temp1_input.dev_attr.attr, 252 &sensor_dev_attr_temp1_crit.dev_attr.attr, 253 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 254 &sensor_dev_attr_temp2_max.dev_attr.attr, 255 &sensor_dev_attr_temp2_min.dev_attr.attr, 256 &sensor_dev_attr_temp2_input.dev_attr.attr, 257 &sensor_dev_attr_temp2_crit.dev_attr.attr, 258 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 259 &sensor_dev_attr_temp2_fault.dev_attr.attr, 260 &sensor_dev_attr_pwm1.dev_attr.attr, 261 &sensor_dev_attr_pwm1_mode.dev_attr.attr, 262 NULL 263 }; 264 265 static const struct attribute_group thmc50_group = { 266 .attrs = thmc50_attributes, 267 }; 268 269 /* for ADM1022 3rd temperature mode */ 270 static struct attribute *temp3_attributes[] = { 271 &sensor_dev_attr_temp3_max.dev_attr.attr, 272 &sensor_dev_attr_temp3_min.dev_attr.attr, 273 &sensor_dev_attr_temp3_input.dev_attr.attr, 274 &sensor_dev_attr_temp3_crit.dev_attr.attr, 275 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 276 &sensor_dev_attr_temp3_fault.dev_attr.attr, 277 NULL 278 }; 279 280 static const struct attribute_group temp3_group = { 281 .attrs = temp3_attributes, 282 }; 283 284 /* Return 0 if detection is successful, -ENODEV otherwise */ 285 static int thmc50_detect(struct i2c_client *client, int kind, 286 struct i2c_board_info *info) 287 { 288 unsigned company; 289 unsigned revision; 290 unsigned config; 291 struct i2c_adapter *adapter = client->adapter; 292 int err = 0; 293 const char *type_name; 294 295 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 296 pr_debug("thmc50: detect failed, " 297 "smbus byte data not supported!\n"); 298 return -ENODEV; 299 } 300 301 pr_debug("thmc50: Probing for THMC50 at 0x%2X on bus %d\n", 302 client->addr, i2c_adapter_id(client->adapter)); 303 304 /* Now, we do the remaining detection. */ 305 company = i2c_smbus_read_byte_data(client, THMC50_REG_COMPANY_ID); 306 revision = i2c_smbus_read_byte_data(client, THMC50_REG_DIE_CODE); 307 config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF); 308 309 if (kind == 0) 310 kind = thmc50; 311 else if (kind < 0) { 312 err = -ENODEV; 313 if (revision >= 0xc0 && ((config & 0x10) == 0)) { 314 if (company == 0x49) { 315 kind = thmc50; 316 err = 0; 317 } else if (company == 0x41) { 318 kind = adm1022; 319 err = 0; 320 } 321 } 322 } 323 if (err == -ENODEV) { 324 pr_debug("thmc50: Detection of THMC50/ADM1022 failed\n"); 325 return err; 326 } 327 328 if (kind == adm1022) { 329 int id = i2c_adapter_id(client->adapter); 330 int i; 331 332 type_name = "adm1022"; 333 for (i = 0; i + 1 < adm1022_temp3_num; i += 2) 334 if (adm1022_temp3[i] == id && 335 adm1022_temp3[i + 1] == client->addr) { 336 /* enable 2nd remote temp */ 337 config |= (1 << 7); 338 i2c_smbus_write_byte_data(client, 339 THMC50_REG_CONF, 340 config); 341 break; 342 } 343 } else { 344 type_name = "thmc50"; 345 } 346 pr_debug("thmc50: Detected %s (version %x, revision %x)\n", 347 type_name, (revision >> 4) - 0xc, revision & 0xf); 348 349 strlcpy(info->type, type_name, I2C_NAME_SIZE); 350 351 return 0; 352 } 353 354 static int thmc50_probe(struct i2c_client *client, 355 const struct i2c_device_id *id) 356 { 357 struct thmc50_data *data; 358 int err; 359 360 data = kzalloc(sizeof(struct thmc50_data), GFP_KERNEL); 361 if (!data) { 362 pr_debug("thmc50: detect failed, kzalloc failed!\n"); 363 err = -ENOMEM; 364 goto exit; 365 } 366 367 i2c_set_clientdata(client, data); 368 data->type = id->driver_data; 369 mutex_init(&data->update_lock); 370 371 thmc50_init_client(client); 372 373 /* Register sysfs hooks */ 374 if ((err = sysfs_create_group(&client->dev.kobj, &thmc50_group))) 375 goto exit_free; 376 377 /* Register ADM1022 sysfs hooks */ 378 if (data->has_temp3) 379 if ((err = sysfs_create_group(&client->dev.kobj, 380 &temp3_group))) 381 goto exit_remove_sysfs_thmc50; 382 383 /* Register a new directory entry with module sensors */ 384 data->hwmon_dev = hwmon_device_register(&client->dev); 385 if (IS_ERR(data->hwmon_dev)) { 386 err = PTR_ERR(data->hwmon_dev); 387 goto exit_remove_sysfs; 388 } 389 390 return 0; 391 392 exit_remove_sysfs: 393 if (data->has_temp3) 394 sysfs_remove_group(&client->dev.kobj, &temp3_group); 395 exit_remove_sysfs_thmc50: 396 sysfs_remove_group(&client->dev.kobj, &thmc50_group); 397 exit_free: 398 kfree(data); 399 exit: 400 return err; 401 } 402 403 static int thmc50_remove(struct i2c_client *client) 404 { 405 struct thmc50_data *data = i2c_get_clientdata(client); 406 407 hwmon_device_unregister(data->hwmon_dev); 408 sysfs_remove_group(&client->dev.kobj, &thmc50_group); 409 if (data->has_temp3) 410 sysfs_remove_group(&client->dev.kobj, &temp3_group); 411 412 kfree(data); 413 414 return 0; 415 } 416 417 static void thmc50_init_client(struct i2c_client *client) 418 { 419 struct thmc50_data *data = i2c_get_clientdata(client); 420 int config; 421 422 data->analog_out = i2c_smbus_read_byte_data(client, 423 THMC50_REG_ANALOG_OUT); 424 /* set up to at least 1 */ 425 if (data->analog_out == 0) { 426 data->analog_out = 1; 427 i2c_smbus_write_byte_data(client, THMC50_REG_ANALOG_OUT, 428 data->analog_out); 429 } 430 config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF); 431 config |= 0x1; /* start the chip if it is in standby mode */ 432 if (data->type == adm1022 && (config & (1 << 7))) 433 data->has_temp3 = 1; 434 i2c_smbus_write_byte_data(client, THMC50_REG_CONF, config); 435 } 436 437 static struct thmc50_data *thmc50_update_device(struct device *dev) 438 { 439 struct i2c_client *client = to_i2c_client(dev); 440 struct thmc50_data *data = i2c_get_clientdata(client); 441 int timeout = HZ / 5 + (data->type == thmc50 ? HZ : 0); 442 443 mutex_lock(&data->update_lock); 444 445 if (time_after(jiffies, data->last_updated + timeout) 446 || !data->valid) { 447 448 int temps = data->has_temp3 ? 3 : 2; 449 int i; 450 int prog = i2c_smbus_read_byte_data(client, THMC50_REG_CONF); 451 452 prog &= THMC50_REG_CONF_PROGRAMMED; 453 454 for (i = 0; i < temps; i++) { 455 data->temp_input[i] = i2c_smbus_read_byte_data(client, 456 THMC50_REG_TEMP[i]); 457 data->temp_max[i] = i2c_smbus_read_byte_data(client, 458 THMC50_REG_TEMP_MAX[i]); 459 data->temp_min[i] = i2c_smbus_read_byte_data(client, 460 THMC50_REG_TEMP_MIN[i]); 461 data->temp_critical[i] = 462 i2c_smbus_read_byte_data(client, 463 prog ? THMC50_REG_TEMP_CRITICAL[i] 464 : THMC50_REG_TEMP_DEFAULT[i]); 465 } 466 data->analog_out = 467 i2c_smbus_read_byte_data(client, THMC50_REG_ANALOG_OUT); 468 data->alarms = 469 i2c_smbus_read_byte_data(client, THMC50_REG_INTR); 470 data->last_updated = jiffies; 471 data->valid = 1; 472 } 473 474 mutex_unlock(&data->update_lock); 475 476 return data; 477 } 478 479 static int __init sm_thmc50_init(void) 480 { 481 return i2c_add_driver(&thmc50_driver); 482 } 483 484 static void __exit sm_thmc50_exit(void) 485 { 486 i2c_del_driver(&thmc50_driver); 487 } 488 489 MODULE_AUTHOR("Krzysztof Helt <krzysztof.h1@wp.pl>"); 490 MODULE_DESCRIPTION("THMC50 driver"); 491 492 module_init(sm_thmc50_init); 493 module_exit(sm_thmc50_exit); 494