1 /* 2 gl520sm.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>, 5 Kyösti Mälkki <kmalkki@cc.hut.fi> 6 Copyright (c) 2005 Maarten Deprez <maartendeprez@users.sourceforge.net> 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 24 #include <linux/module.h> 25 #include <linux/init.h> 26 #include <linux/slab.h> 27 #include <linux/jiffies.h> 28 #include <linux/i2c.h> 29 #include <linux/hwmon.h> 30 #include <linux/hwmon-sysfs.h> 31 #include <linux/hwmon-vid.h> 32 #include <linux/err.h> 33 #include <linux/mutex.h> 34 #include <linux/sysfs.h> 35 36 /* Type of the extra sensor */ 37 static unsigned short extra_sensor_type; 38 module_param(extra_sensor_type, ushort, 0); 39 MODULE_PARM_DESC(extra_sensor_type, "Type of extra sensor (0=autodetect, 1=temperature, 2=voltage)"); 40 41 /* Addresses to scan */ 42 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END }; 43 44 /* Insmod parameters */ 45 I2C_CLIENT_INSMOD_1(gl520sm); 46 47 /* Many GL520 constants specified below 48 One of the inputs can be configured as either temp or voltage. 49 That's why _TEMP2 and _IN4 access the same register 50 */ 51 52 /* The GL520 registers */ 53 #define GL520_REG_CHIP_ID 0x00 54 #define GL520_REG_REVISION 0x01 55 #define GL520_REG_CONF 0x03 56 #define GL520_REG_MASK 0x11 57 58 #define GL520_REG_VID_INPUT 0x02 59 60 static const u8 GL520_REG_IN_INPUT[] = { 0x15, 0x14, 0x13, 0x0d, 0x0e }; 61 static const u8 GL520_REG_IN_LIMIT[] = { 0x0c, 0x09, 0x0a, 0x0b }; 62 static const u8 GL520_REG_IN_MIN[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x18 }; 63 static const u8 GL520_REG_IN_MAX[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x17 }; 64 65 static const u8 GL520_REG_TEMP_INPUT[] = { 0x04, 0x0e }; 66 static const u8 GL520_REG_TEMP_MAX[] = { 0x05, 0x17 }; 67 static const u8 GL520_REG_TEMP_MAX_HYST[] = { 0x06, 0x18 }; 68 69 #define GL520_REG_FAN_INPUT 0x07 70 #define GL520_REG_FAN_MIN 0x08 71 #define GL520_REG_FAN_DIV 0x0f 72 #define GL520_REG_FAN_OFF GL520_REG_FAN_DIV 73 74 #define GL520_REG_ALARMS 0x12 75 #define GL520_REG_BEEP_MASK 0x10 76 #define GL520_REG_BEEP_ENABLE GL520_REG_CONF 77 78 /* 79 * Function declarations 80 */ 81 82 static int gl520_probe(struct i2c_client *client, 83 const struct i2c_device_id *id); 84 static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info); 85 static void gl520_init_client(struct i2c_client *client); 86 static int gl520_remove(struct i2c_client *client); 87 static int gl520_read_value(struct i2c_client *client, u8 reg); 88 static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value); 89 static struct gl520_data *gl520_update_device(struct device *dev); 90 91 /* Driver data */ 92 static const struct i2c_device_id gl520_id[] = { 93 { "gl520sm", gl520sm }, 94 { } 95 }; 96 MODULE_DEVICE_TABLE(i2c, gl520_id); 97 98 static struct i2c_driver gl520_driver = { 99 .class = I2C_CLASS_HWMON, 100 .driver = { 101 .name = "gl520sm", 102 }, 103 .probe = gl520_probe, 104 .remove = gl520_remove, 105 .id_table = gl520_id, 106 .detect = gl520_detect, 107 .address_list = normal_i2c, 108 }; 109 110 /* Client data */ 111 struct gl520_data { 112 struct device *hwmon_dev; 113 struct mutex update_lock; 114 char valid; /* zero until the following fields are valid */ 115 unsigned long last_updated; /* in jiffies */ 116 117 u8 vid; 118 u8 vrm; 119 u8 in_input[5]; /* [0] = VVD */ 120 u8 in_min[5]; /* [0] = VDD */ 121 u8 in_max[5]; /* [0] = VDD */ 122 u8 fan_input[2]; 123 u8 fan_min[2]; 124 u8 fan_div[2]; 125 u8 fan_off; 126 u8 temp_input[2]; 127 u8 temp_max[2]; 128 u8 temp_max_hyst[2]; 129 u8 alarms; 130 u8 beep_enable; 131 u8 beep_mask; 132 u8 alarm_mask; 133 u8 two_temps; 134 }; 135 136 /* 137 * Sysfs stuff 138 */ 139 140 static ssize_t get_cpu_vid(struct device *dev, struct device_attribute *attr, 141 char *buf) 142 { 143 struct gl520_data *data = gl520_update_device(dev); 144 return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm)); 145 } 146 static DEVICE_ATTR(cpu0_vid, S_IRUGO, get_cpu_vid, NULL); 147 148 #define VDD_FROM_REG(val) (((val)*95+2)/4) 149 #define VDD_TO_REG(val) (SENSORS_LIMIT((((val)*4+47)/95),0,255)) 150 151 #define IN_FROM_REG(val) ((val)*19) 152 #define IN_TO_REG(val) (SENSORS_LIMIT((((val)+9)/19),0,255)) 153 154 static ssize_t get_in_input(struct device *dev, struct device_attribute *attr, 155 char *buf) 156 { 157 int n = to_sensor_dev_attr(attr)->index; 158 struct gl520_data *data = gl520_update_device(dev); 159 u8 r = data->in_input[n]; 160 161 if (n == 0) 162 return sprintf(buf, "%d\n", VDD_FROM_REG(r)); 163 else 164 return sprintf(buf, "%d\n", IN_FROM_REG(r)); 165 } 166 167 static ssize_t get_in_min(struct device *dev, struct device_attribute *attr, 168 char *buf) 169 { 170 int n = to_sensor_dev_attr(attr)->index; 171 struct gl520_data *data = gl520_update_device(dev); 172 u8 r = data->in_min[n]; 173 174 if (n == 0) 175 return sprintf(buf, "%d\n", VDD_FROM_REG(r)); 176 else 177 return sprintf(buf, "%d\n", IN_FROM_REG(r)); 178 } 179 180 static ssize_t get_in_max(struct device *dev, struct device_attribute *attr, 181 char *buf) 182 { 183 int n = to_sensor_dev_attr(attr)->index; 184 struct gl520_data *data = gl520_update_device(dev); 185 u8 r = data->in_max[n]; 186 187 if (n == 0) 188 return sprintf(buf, "%d\n", VDD_FROM_REG(r)); 189 else 190 return sprintf(buf, "%d\n", IN_FROM_REG(r)); 191 } 192 193 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr, 194 const char *buf, size_t count) 195 { 196 struct i2c_client *client = to_i2c_client(dev); 197 struct gl520_data *data = i2c_get_clientdata(client); 198 int n = to_sensor_dev_attr(attr)->index; 199 long v = simple_strtol(buf, NULL, 10); 200 u8 r; 201 202 mutex_lock(&data->update_lock); 203 204 if (n == 0) 205 r = VDD_TO_REG(v); 206 else 207 r = IN_TO_REG(v); 208 209 data->in_min[n] = r; 210 211 if (n < 4) 212 gl520_write_value(client, GL520_REG_IN_MIN[n], 213 (gl520_read_value(client, GL520_REG_IN_MIN[n]) 214 & ~0xff) | r); 215 else 216 gl520_write_value(client, GL520_REG_IN_MIN[n], r); 217 218 mutex_unlock(&data->update_lock); 219 return count; 220 } 221 222 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr, 223 const char *buf, size_t count) 224 { 225 struct i2c_client *client = to_i2c_client(dev); 226 struct gl520_data *data = i2c_get_clientdata(client); 227 int n = to_sensor_dev_attr(attr)->index; 228 long v = simple_strtol(buf, NULL, 10); 229 u8 r; 230 231 if (n == 0) 232 r = VDD_TO_REG(v); 233 else 234 r = IN_TO_REG(v); 235 236 mutex_lock(&data->update_lock); 237 238 data->in_max[n] = r; 239 240 if (n < 4) 241 gl520_write_value(client, GL520_REG_IN_MAX[n], 242 (gl520_read_value(client, GL520_REG_IN_MAX[n]) 243 & ~0xff00) | (r << 8)); 244 else 245 gl520_write_value(client, GL520_REG_IN_MAX[n], r); 246 247 mutex_unlock(&data->update_lock); 248 return count; 249 } 250 251 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, get_in_input, NULL, 0); 252 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, get_in_input, NULL, 1); 253 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, get_in_input, NULL, 2); 254 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, get_in_input, NULL, 3); 255 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, get_in_input, NULL, 4); 256 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR, 257 get_in_min, set_in_min, 0); 258 static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR, 259 get_in_min, set_in_min, 1); 260 static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR, 261 get_in_min, set_in_min, 2); 262 static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S_IWUSR, 263 get_in_min, set_in_min, 3); 264 static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S_IWUSR, 265 get_in_min, set_in_min, 4); 266 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR, 267 get_in_max, set_in_max, 0); 268 static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR, 269 get_in_max, set_in_max, 1); 270 static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR, 271 get_in_max, set_in_max, 2); 272 static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S_IWUSR, 273 get_in_max, set_in_max, 3); 274 static SENSOR_DEVICE_ATTR(in4_max, S_IRUGO | S_IWUSR, 275 get_in_max, set_in_max, 4); 276 277 #define DIV_FROM_REG(val) (1 << (val)) 278 #define FAN_FROM_REG(val,div) ((val)==0 ? 0 : (480000/((val) << (div)))) 279 #define FAN_TO_REG(val,div) ((val)<=0?0:SENSORS_LIMIT((480000 + ((val) << ((div)-1))) / ((val) << (div)), 1, 255)); 280 281 static ssize_t get_fan_input(struct device *dev, struct device_attribute *attr, 282 char *buf) 283 { 284 int n = to_sensor_dev_attr(attr)->index; 285 struct gl520_data *data = gl520_update_device(dev); 286 287 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_input[n], 288 data->fan_div[n])); 289 } 290 291 static ssize_t get_fan_min(struct device *dev, struct device_attribute *attr, 292 char *buf) 293 { 294 int n = to_sensor_dev_attr(attr)->index; 295 struct gl520_data *data = gl520_update_device(dev); 296 297 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[n], 298 data->fan_div[n])); 299 } 300 301 static ssize_t get_fan_div(struct device *dev, struct device_attribute *attr, 302 char *buf) 303 { 304 int n = to_sensor_dev_attr(attr)->index; 305 struct gl520_data *data = gl520_update_device(dev); 306 307 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[n])); 308 } 309 310 static ssize_t get_fan_off(struct device *dev, struct device_attribute *attr, 311 char *buf) 312 { 313 struct gl520_data *data = gl520_update_device(dev); 314 return sprintf(buf, "%d\n", data->fan_off); 315 } 316 317 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 318 const char *buf, size_t count) 319 { 320 struct i2c_client *client = to_i2c_client(dev); 321 struct gl520_data *data = i2c_get_clientdata(client); 322 int n = to_sensor_dev_attr(attr)->index; 323 unsigned long v = simple_strtoul(buf, NULL, 10); 324 u8 r; 325 326 mutex_lock(&data->update_lock); 327 r = FAN_TO_REG(v, data->fan_div[n]); 328 data->fan_min[n] = r; 329 330 if (n == 0) 331 gl520_write_value(client, GL520_REG_FAN_MIN, 332 (gl520_read_value(client, GL520_REG_FAN_MIN) 333 & ~0xff00) | (r << 8)); 334 else 335 gl520_write_value(client, GL520_REG_FAN_MIN, 336 (gl520_read_value(client, GL520_REG_FAN_MIN) 337 & ~0xff) | r); 338 339 data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK); 340 if (data->fan_min[n] == 0) 341 data->alarm_mask &= (n == 0) ? ~0x20 : ~0x40; 342 else 343 data->alarm_mask |= (n == 0) ? 0x20 : 0x40; 344 data->beep_mask &= data->alarm_mask; 345 gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask); 346 347 mutex_unlock(&data->update_lock); 348 return count; 349 } 350 351 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 352 const char *buf, size_t count) 353 { 354 struct i2c_client *client = to_i2c_client(dev); 355 struct gl520_data *data = i2c_get_clientdata(client); 356 int n = to_sensor_dev_attr(attr)->index; 357 unsigned long v = simple_strtoul(buf, NULL, 10); 358 u8 r; 359 360 switch (v) { 361 case 1: r = 0; break; 362 case 2: r = 1; break; 363 case 4: r = 2; break; 364 case 8: r = 3; break; 365 default: 366 dev_err(&client->dev, "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", v); 367 return -EINVAL; 368 } 369 370 mutex_lock(&data->update_lock); 371 data->fan_div[n] = r; 372 373 if (n == 0) 374 gl520_write_value(client, GL520_REG_FAN_DIV, 375 (gl520_read_value(client, GL520_REG_FAN_DIV) 376 & ~0xc0) | (r << 6)); 377 else 378 gl520_write_value(client, GL520_REG_FAN_DIV, 379 (gl520_read_value(client, GL520_REG_FAN_DIV) 380 & ~0x30) | (r << 4)); 381 382 mutex_unlock(&data->update_lock); 383 return count; 384 } 385 386 static ssize_t set_fan_off(struct device *dev, struct device_attribute *attr, 387 const char *buf, size_t count) 388 { 389 struct i2c_client *client = to_i2c_client(dev); 390 struct gl520_data *data = i2c_get_clientdata(client); 391 u8 r = simple_strtoul(buf, NULL, 10)?1:0; 392 393 mutex_lock(&data->update_lock); 394 data->fan_off = r; 395 gl520_write_value(client, GL520_REG_FAN_OFF, 396 (gl520_read_value(client, GL520_REG_FAN_OFF) 397 & ~0x0c) | (r << 2)); 398 mutex_unlock(&data->update_lock); 399 return count; 400 } 401 402 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan_input, NULL, 0); 403 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan_input, NULL, 1); 404 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR, 405 get_fan_min, set_fan_min, 0); 406 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR, 407 get_fan_min, set_fan_min, 1); 408 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, 409 get_fan_div, set_fan_div, 0); 410 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR, 411 get_fan_div, set_fan_div, 1); 412 static DEVICE_ATTR(fan1_off, S_IRUGO | S_IWUSR, 413 get_fan_off, set_fan_off); 414 415 #define TEMP_FROM_REG(val) (((val) - 130) * 1000) 416 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((((val)<0?(val)-500:(val)+500) / 1000)+130),0,255)) 417 418 static ssize_t get_temp_input(struct device *dev, struct device_attribute *attr, 419 char *buf) 420 { 421 int n = to_sensor_dev_attr(attr)->index; 422 struct gl520_data *data = gl520_update_device(dev); 423 424 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_input[n])); 425 } 426 427 static ssize_t get_temp_max(struct device *dev, struct device_attribute *attr, 428 char *buf) 429 { 430 int n = to_sensor_dev_attr(attr)->index; 431 struct gl520_data *data = gl520_update_device(dev); 432 433 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[n])); 434 } 435 436 static ssize_t get_temp_max_hyst(struct device *dev, struct device_attribute 437 *attr, char *buf) 438 { 439 int n = to_sensor_dev_attr(attr)->index; 440 struct gl520_data *data = gl520_update_device(dev); 441 442 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[n])); 443 } 444 445 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, 446 const char *buf, size_t count) 447 { 448 struct i2c_client *client = to_i2c_client(dev); 449 struct gl520_data *data = i2c_get_clientdata(client); 450 int n = to_sensor_dev_attr(attr)->index; 451 long v = simple_strtol(buf, NULL, 10); 452 453 mutex_lock(&data->update_lock); 454 data->temp_max[n] = TEMP_TO_REG(v); 455 gl520_write_value(client, GL520_REG_TEMP_MAX[n], data->temp_max[n]); 456 mutex_unlock(&data->update_lock); 457 return count; 458 } 459 460 static ssize_t set_temp_max_hyst(struct device *dev, struct device_attribute 461 *attr, const char *buf, size_t count) 462 { 463 struct i2c_client *client = to_i2c_client(dev); 464 struct gl520_data *data = i2c_get_clientdata(client); 465 int n = to_sensor_dev_attr(attr)->index; 466 long v = simple_strtol(buf, NULL, 10); 467 468 mutex_lock(&data->update_lock); 469 data->temp_max_hyst[n] = TEMP_TO_REG(v); 470 gl520_write_value(client, GL520_REG_TEMP_MAX_HYST[n], 471 data->temp_max_hyst[n]); 472 mutex_unlock(&data->update_lock); 473 return count; 474 } 475 476 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, get_temp_input, NULL, 0); 477 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, get_temp_input, NULL, 1); 478 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, 479 get_temp_max, set_temp_max, 0); 480 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, 481 get_temp_max, set_temp_max, 1); 482 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, 483 get_temp_max_hyst, set_temp_max_hyst, 0); 484 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, 485 get_temp_max_hyst, set_temp_max_hyst, 1); 486 487 static ssize_t get_alarms(struct device *dev, struct device_attribute *attr, 488 char *buf) 489 { 490 struct gl520_data *data = gl520_update_device(dev); 491 return sprintf(buf, "%d\n", data->alarms); 492 } 493 494 static ssize_t get_beep_enable(struct device *dev, struct device_attribute 495 *attr, char *buf) 496 { 497 struct gl520_data *data = gl520_update_device(dev); 498 return sprintf(buf, "%d\n", data->beep_enable); 499 } 500 501 static ssize_t get_beep_mask(struct device *dev, struct device_attribute *attr, 502 char *buf) 503 { 504 struct gl520_data *data = gl520_update_device(dev); 505 return sprintf(buf, "%d\n", data->beep_mask); 506 } 507 508 static ssize_t set_beep_enable(struct device *dev, struct device_attribute 509 *attr, const char *buf, size_t count) 510 { 511 struct i2c_client *client = to_i2c_client(dev); 512 struct gl520_data *data = i2c_get_clientdata(client); 513 u8 r = simple_strtoul(buf, NULL, 10)?0:1; 514 515 mutex_lock(&data->update_lock); 516 data->beep_enable = !r; 517 gl520_write_value(client, GL520_REG_BEEP_ENABLE, 518 (gl520_read_value(client, GL520_REG_BEEP_ENABLE) 519 & ~0x04) | (r << 2)); 520 mutex_unlock(&data->update_lock); 521 return count; 522 } 523 524 static ssize_t set_beep_mask(struct device *dev, struct device_attribute *attr, 525 const char *buf, size_t count) 526 { 527 struct i2c_client *client = to_i2c_client(dev); 528 struct gl520_data *data = i2c_get_clientdata(client); 529 u8 r = simple_strtoul(buf, NULL, 10); 530 531 mutex_lock(&data->update_lock); 532 r &= data->alarm_mask; 533 data->beep_mask = r; 534 gl520_write_value(client, GL520_REG_BEEP_MASK, r); 535 mutex_unlock(&data->update_lock); 536 return count; 537 } 538 539 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL); 540 static DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR, 541 get_beep_enable, set_beep_enable); 542 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR, 543 get_beep_mask, set_beep_mask); 544 545 static ssize_t get_alarm(struct device *dev, struct device_attribute *attr, 546 char *buf) 547 { 548 int bit_nr = to_sensor_dev_attr(attr)->index; 549 struct gl520_data *data = gl520_update_device(dev); 550 551 return sprintf(buf, "%d\n", (data->alarms >> bit_nr) & 1); 552 } 553 554 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, get_alarm, NULL, 0); 555 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, get_alarm, NULL, 1); 556 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, get_alarm, NULL, 2); 557 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, get_alarm, NULL, 3); 558 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, get_alarm, NULL, 4); 559 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, get_alarm, NULL, 5); 560 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, get_alarm, NULL, 6); 561 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, get_alarm, NULL, 7); 562 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, get_alarm, NULL, 7); 563 564 static ssize_t get_beep(struct device *dev, struct device_attribute *attr, 565 char *buf) 566 { 567 int bitnr = to_sensor_dev_attr(attr)->index; 568 struct gl520_data *data = gl520_update_device(dev); 569 570 return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1); 571 } 572 573 static ssize_t set_beep(struct device *dev, struct device_attribute *attr, 574 const char *buf, size_t count) 575 { 576 struct i2c_client *client = to_i2c_client(dev); 577 struct gl520_data *data = i2c_get_clientdata(client); 578 int bitnr = to_sensor_dev_attr(attr)->index; 579 unsigned long bit; 580 581 bit = simple_strtoul(buf, NULL, 10); 582 if (bit & ~1) 583 return -EINVAL; 584 585 mutex_lock(&data->update_lock); 586 data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK); 587 if (bit) 588 data->beep_mask |= (1 << bitnr); 589 else 590 data->beep_mask &= ~(1 << bitnr); 591 gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask); 592 mutex_unlock(&data->update_lock); 593 return count; 594 } 595 596 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 0); 597 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 1); 598 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 2); 599 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 3); 600 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 4); 601 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 5); 602 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 6); 603 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7); 604 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7); 605 606 static struct attribute *gl520_attributes[] = { 607 &dev_attr_cpu0_vid.attr, 608 609 &sensor_dev_attr_in0_input.dev_attr.attr, 610 &sensor_dev_attr_in0_min.dev_attr.attr, 611 &sensor_dev_attr_in0_max.dev_attr.attr, 612 &sensor_dev_attr_in0_alarm.dev_attr.attr, 613 &sensor_dev_attr_in0_beep.dev_attr.attr, 614 &sensor_dev_attr_in1_input.dev_attr.attr, 615 &sensor_dev_attr_in1_min.dev_attr.attr, 616 &sensor_dev_attr_in1_max.dev_attr.attr, 617 &sensor_dev_attr_in1_alarm.dev_attr.attr, 618 &sensor_dev_attr_in1_beep.dev_attr.attr, 619 &sensor_dev_attr_in2_input.dev_attr.attr, 620 &sensor_dev_attr_in2_min.dev_attr.attr, 621 &sensor_dev_attr_in2_max.dev_attr.attr, 622 &sensor_dev_attr_in2_alarm.dev_attr.attr, 623 &sensor_dev_attr_in2_beep.dev_attr.attr, 624 &sensor_dev_attr_in3_input.dev_attr.attr, 625 &sensor_dev_attr_in3_min.dev_attr.attr, 626 &sensor_dev_attr_in3_max.dev_attr.attr, 627 &sensor_dev_attr_in3_alarm.dev_attr.attr, 628 &sensor_dev_attr_in3_beep.dev_attr.attr, 629 630 &sensor_dev_attr_fan1_input.dev_attr.attr, 631 &sensor_dev_attr_fan1_min.dev_attr.attr, 632 &sensor_dev_attr_fan1_div.dev_attr.attr, 633 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 634 &sensor_dev_attr_fan1_beep.dev_attr.attr, 635 &dev_attr_fan1_off.attr, 636 &sensor_dev_attr_fan2_input.dev_attr.attr, 637 &sensor_dev_attr_fan2_min.dev_attr.attr, 638 &sensor_dev_attr_fan2_div.dev_attr.attr, 639 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 640 &sensor_dev_attr_fan2_beep.dev_attr.attr, 641 642 &sensor_dev_attr_temp1_input.dev_attr.attr, 643 &sensor_dev_attr_temp1_max.dev_attr.attr, 644 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 645 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 646 &sensor_dev_attr_temp1_beep.dev_attr.attr, 647 648 &dev_attr_alarms.attr, 649 &dev_attr_beep_enable.attr, 650 &dev_attr_beep_mask.attr, 651 NULL 652 }; 653 654 static const struct attribute_group gl520_group = { 655 .attrs = gl520_attributes, 656 }; 657 658 static struct attribute *gl520_attributes_opt[] = { 659 &sensor_dev_attr_in4_input.dev_attr.attr, 660 &sensor_dev_attr_in4_min.dev_attr.attr, 661 &sensor_dev_attr_in4_max.dev_attr.attr, 662 &sensor_dev_attr_in4_alarm.dev_attr.attr, 663 &sensor_dev_attr_in4_beep.dev_attr.attr, 664 665 &sensor_dev_attr_temp2_input.dev_attr.attr, 666 &sensor_dev_attr_temp2_max.dev_attr.attr, 667 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr, 668 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 669 &sensor_dev_attr_temp2_beep.dev_attr.attr, 670 NULL 671 }; 672 673 static const struct attribute_group gl520_group_opt = { 674 .attrs = gl520_attributes_opt, 675 }; 676 677 678 /* 679 * Real code 680 */ 681 682 /* Return 0 if detection is successful, -ENODEV otherwise */ 683 static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info) 684 { 685 struct i2c_adapter *adapter = client->adapter; 686 687 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 688 I2C_FUNC_SMBUS_WORD_DATA)) 689 return -ENODEV; 690 691 /* Determine the chip type. */ 692 if ((gl520_read_value(client, GL520_REG_CHIP_ID) != 0x20) || 693 ((gl520_read_value(client, GL520_REG_REVISION) & 0x7f) != 0x00) || 694 ((gl520_read_value(client, GL520_REG_CONF) & 0x80) != 0x00)) { 695 dev_dbg(&client->dev, "Unknown chip type, skipping\n"); 696 return -ENODEV; 697 } 698 699 strlcpy(info->type, "gl520sm", I2C_NAME_SIZE); 700 701 return 0; 702 } 703 704 static int gl520_probe(struct i2c_client *client, 705 const struct i2c_device_id *id) 706 { 707 struct gl520_data *data; 708 int err; 709 710 data = kzalloc(sizeof(struct gl520_data), GFP_KERNEL); 711 if (!data) { 712 err = -ENOMEM; 713 goto exit; 714 } 715 716 i2c_set_clientdata(client, data); 717 mutex_init(&data->update_lock); 718 719 /* Initialize the GL520SM chip */ 720 gl520_init_client(client); 721 722 /* Register sysfs hooks */ 723 if ((err = sysfs_create_group(&client->dev.kobj, &gl520_group))) 724 goto exit_free; 725 726 if (data->two_temps) { 727 if ((err = device_create_file(&client->dev, 728 &sensor_dev_attr_temp2_input.dev_attr)) 729 || (err = device_create_file(&client->dev, 730 &sensor_dev_attr_temp2_max.dev_attr)) 731 || (err = device_create_file(&client->dev, 732 &sensor_dev_attr_temp2_max_hyst.dev_attr)) 733 || (err = device_create_file(&client->dev, 734 &sensor_dev_attr_temp2_alarm.dev_attr)) 735 || (err = device_create_file(&client->dev, 736 &sensor_dev_attr_temp2_beep.dev_attr))) 737 goto exit_remove_files; 738 } else { 739 if ((err = device_create_file(&client->dev, 740 &sensor_dev_attr_in4_input.dev_attr)) 741 || (err = device_create_file(&client->dev, 742 &sensor_dev_attr_in4_min.dev_attr)) 743 || (err = device_create_file(&client->dev, 744 &sensor_dev_attr_in4_max.dev_attr)) 745 || (err = device_create_file(&client->dev, 746 &sensor_dev_attr_in4_alarm.dev_attr)) 747 || (err = device_create_file(&client->dev, 748 &sensor_dev_attr_in4_beep.dev_attr))) 749 goto exit_remove_files; 750 } 751 752 753 data->hwmon_dev = hwmon_device_register(&client->dev); 754 if (IS_ERR(data->hwmon_dev)) { 755 err = PTR_ERR(data->hwmon_dev); 756 goto exit_remove_files; 757 } 758 759 return 0; 760 761 exit_remove_files: 762 sysfs_remove_group(&client->dev.kobj, &gl520_group); 763 sysfs_remove_group(&client->dev.kobj, &gl520_group_opt); 764 exit_free: 765 kfree(data); 766 exit: 767 return err; 768 } 769 770 771 /* Called when we have found a new GL520SM. */ 772 static void gl520_init_client(struct i2c_client *client) 773 { 774 struct gl520_data *data = i2c_get_clientdata(client); 775 u8 oldconf, conf; 776 777 conf = oldconf = gl520_read_value(client, GL520_REG_CONF); 778 779 data->alarm_mask = 0xff; 780 data->vrm = vid_which_vrm(); 781 782 if (extra_sensor_type == 1) 783 conf &= ~0x10; 784 else if (extra_sensor_type == 2) 785 conf |= 0x10; 786 data->two_temps = !(conf & 0x10); 787 788 /* If IRQ# is disabled, we can safely force comparator mode */ 789 if (!(conf & 0x20)) 790 conf &= 0xf7; 791 792 /* Enable monitoring if needed */ 793 conf |= 0x40; 794 795 if (conf != oldconf) 796 gl520_write_value(client, GL520_REG_CONF, conf); 797 798 gl520_update_device(&(client->dev)); 799 800 if (data->fan_min[0] == 0) 801 data->alarm_mask &= ~0x20; 802 if (data->fan_min[1] == 0) 803 data->alarm_mask &= ~0x40; 804 805 data->beep_mask &= data->alarm_mask; 806 gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask); 807 } 808 809 static int gl520_remove(struct i2c_client *client) 810 { 811 struct gl520_data *data = i2c_get_clientdata(client); 812 813 hwmon_device_unregister(data->hwmon_dev); 814 sysfs_remove_group(&client->dev.kobj, &gl520_group); 815 sysfs_remove_group(&client->dev.kobj, &gl520_group_opt); 816 817 kfree(data); 818 return 0; 819 } 820 821 822 /* Registers 0x07 to 0x0c are word-sized, others are byte-sized 823 GL520 uses a high-byte first convention */ 824 static int gl520_read_value(struct i2c_client *client, u8 reg) 825 { 826 if ((reg >= 0x07) && (reg <= 0x0c)) 827 return swab16(i2c_smbus_read_word_data(client, reg)); 828 else 829 return i2c_smbus_read_byte_data(client, reg); 830 } 831 832 static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value) 833 { 834 if ((reg >= 0x07) && (reg <= 0x0c)) 835 return i2c_smbus_write_word_data(client, reg, swab16(value)); 836 else 837 return i2c_smbus_write_byte_data(client, reg, value); 838 } 839 840 841 static struct gl520_data *gl520_update_device(struct device *dev) 842 { 843 struct i2c_client *client = to_i2c_client(dev); 844 struct gl520_data *data = i2c_get_clientdata(client); 845 int val, i; 846 847 mutex_lock(&data->update_lock); 848 849 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) { 850 851 dev_dbg(&client->dev, "Starting gl520sm update\n"); 852 853 data->alarms = gl520_read_value(client, GL520_REG_ALARMS); 854 data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK); 855 data->vid = gl520_read_value(client, GL520_REG_VID_INPUT) & 0x1f; 856 857 for (i = 0; i < 4; i++) { 858 data->in_input[i] = gl520_read_value(client, 859 GL520_REG_IN_INPUT[i]); 860 val = gl520_read_value(client, GL520_REG_IN_LIMIT[i]); 861 data->in_min[i] = val & 0xff; 862 data->in_max[i] = (val >> 8) & 0xff; 863 } 864 865 val = gl520_read_value(client, GL520_REG_FAN_INPUT); 866 data->fan_input[0] = (val >> 8) & 0xff; 867 data->fan_input[1] = val & 0xff; 868 869 val = gl520_read_value(client, GL520_REG_FAN_MIN); 870 data->fan_min[0] = (val >> 8) & 0xff; 871 data->fan_min[1] = val & 0xff; 872 873 data->temp_input[0] = gl520_read_value(client, 874 GL520_REG_TEMP_INPUT[0]); 875 data->temp_max[0] = gl520_read_value(client, 876 GL520_REG_TEMP_MAX[0]); 877 data->temp_max_hyst[0] = gl520_read_value(client, 878 GL520_REG_TEMP_MAX_HYST[0]); 879 880 val = gl520_read_value(client, GL520_REG_FAN_DIV); 881 data->fan_div[0] = (val >> 6) & 0x03; 882 data->fan_div[1] = (val >> 4) & 0x03; 883 data->fan_off = (val >> 2) & 0x01; 884 885 data->alarms &= data->alarm_mask; 886 887 val = gl520_read_value(client, GL520_REG_CONF); 888 data->beep_enable = !((val >> 2) & 1); 889 890 /* Temp1 and Vin4 are the same input */ 891 if (data->two_temps) { 892 data->temp_input[1] = gl520_read_value(client, 893 GL520_REG_TEMP_INPUT[1]); 894 data->temp_max[1] = gl520_read_value(client, 895 GL520_REG_TEMP_MAX[1]); 896 data->temp_max_hyst[1] = gl520_read_value(client, 897 GL520_REG_TEMP_MAX_HYST[1]); 898 } else { 899 data->in_input[4] = gl520_read_value(client, 900 GL520_REG_IN_INPUT[4]); 901 data->in_min[4] = gl520_read_value(client, 902 GL520_REG_IN_MIN[4]); 903 data->in_max[4] = gl520_read_value(client, 904 GL520_REG_IN_MAX[4]); 905 } 906 907 data->last_updated = jiffies; 908 data->valid = 1; 909 } 910 911 mutex_unlock(&data->update_lock); 912 913 return data; 914 } 915 916 917 static int __init sensors_gl520sm_init(void) 918 { 919 return i2c_add_driver(&gl520_driver); 920 } 921 922 static void __exit sensors_gl520sm_exit(void) 923 { 924 i2c_del_driver(&gl520_driver); 925 } 926 927 928 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, " 929 "Kyösti Mälkki <kmalkki@cc.hut.fi>, " 930 "Maarten Deprez <maartendeprez@users.sourceforge.net>"); 931 MODULE_DESCRIPTION("GL520SM driver"); 932 MODULE_LICENSE("GPL"); 933 934 module_init(sensors_gl520sm_init); 935 module_exit(sensors_gl520sm_exit); 936