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