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 */ 37static unsigned short extra_sensor_type; 38module_param(extra_sensor_type, ushort, 0); 39MODULE_PARM_DESC(extra_sensor_type, "Type of extra sensor (0=autodetect, 1=temperature, 2=voltage)"); 40 41/* Addresses to scan */ 42static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END }; 43 44/* Many GL520 constants specified below 45One of the inputs can be configured as either temp or voltage. 46That'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 57static const u8 GL520_REG_IN_INPUT[] = { 0x15, 0x14, 0x13, 0x0d, 0x0e }; 58static const u8 GL520_REG_IN_LIMIT[] = { 0x0c, 0x09, 0x0a, 0x0b }; 59static const u8 GL520_REG_IN_MIN[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x18 }; 60static const u8 GL520_REG_IN_MAX[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x17 }; 61 62static const u8 GL520_REG_TEMP_INPUT[] = { 0x04, 0x0e }; 63static const u8 GL520_REG_TEMP_MAX[] = { 0x05, 0x17 }; 64static 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 79static int gl520_probe(struct i2c_client *client, 80 const struct i2c_device_id *id); 81static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info); 82static void gl520_init_client(struct i2c_client *client); 83static int gl520_remove(struct i2c_client *client); 84static int gl520_read_value(struct i2c_client *client, u8 reg); 85static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value); 86static struct gl520_data *gl520_update_device(struct device *dev); 87 88/* Driver data */ 89static const struct i2c_device_id gl520_id[] = { 90 { "gl520sm", 0 }, 91 { } 92}; 93MODULE_DEVICE_TABLE(i2c, gl520_id); 94 95static 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 */ 108struct 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 137static 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} 143static 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 151static 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 164static 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 177static 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 190static 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 219static 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 248static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, get_in_input, NULL, 0); 249static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, get_in_input, NULL, 1); 250static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, get_in_input, NULL, 2); 251static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, get_in_input, NULL, 3); 252static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, get_in_input, NULL, 4); 253static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR, 254 get_in_min, set_in_min, 0); 255static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR, 256 get_in_min, set_in_min, 1); 257static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR, 258 get_in_min, set_in_min, 2); 259static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S_IWUSR, 260 get_in_min, set_in_min, 3); 261static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S_IWUSR, 262 get_in_min, set_in_min, 4); 263static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR, 264 get_in_max, set_in_max, 0); 265static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR, 266 get_in_max, set_in_max, 1); 267static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR, 268 get_in_max, set_in_max, 2); 269static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S_IWUSR, 270 get_in_max, set_in_max, 3); 271static 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 278static 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 288static 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 298static 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 307static 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 314static 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 348static 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 383static 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 399static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan_input, NULL, 0); 400static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan_input, NULL, 1); 401static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR, 402 get_fan_min, set_fan_min, 0); 403static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR, 404 get_fan_min, set_fan_min, 1); 405static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, 406 get_fan_div, set_fan_div, 0); 407static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR, 408 get_fan_div, set_fan_div, 1); 409static 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 415static 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 424static 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 433static 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 442static 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 457static 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 473static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, get_temp_input, NULL, 0); 474static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, get_temp_input, NULL, 1); 475static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, 476 get_temp_max, set_temp_max, 0); 477static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, 478 get_temp_max, set_temp_max, 1); 479static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, 480 get_temp_max_hyst, set_temp_max_hyst, 0); 481static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, 482 get_temp_max_hyst, set_temp_max_hyst, 1); 483 484static 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 491static 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 498static 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 505static 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 521static 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 536static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL); 537static DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR, 538 get_beep_enable, set_beep_enable); 539static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR, 540 get_beep_mask, set_beep_mask); 541 542static 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 551static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, get_alarm, NULL, 0); 552static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, get_alarm, NULL, 1); 553static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, get_alarm, NULL, 2); 554static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, get_alarm, NULL, 3); 555static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, get_alarm, NULL, 4); 556static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, get_alarm, NULL, 5); 557static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, get_alarm, NULL, 6); 558static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, get_alarm, NULL, 7); 559static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, get_alarm, NULL, 7); 560 561static 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 570static 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 593static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 0); 594static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 1); 595static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 2); 596static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 3); 597static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 4); 598static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 5); 599static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 6); 600static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7); 601static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7); 602 603static 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 651static const struct attribute_group gl520_group = { 652 .attrs = gl520_attributes, 653}; 654 655static 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 670static 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 */ 680static 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 701static 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 758exit_remove_files: 759 sysfs_remove_group(&client->dev.kobj, &gl520_group); 760 sysfs_remove_group(&client->dev.kobj, &gl520_group_opt); 761exit_free: 762 kfree(data); 763exit: 764 return err; 765} 766 767 768/* Called when we have found a new GL520SM. */ 769static 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 806static 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 */ 821static int gl520_read_value(struct i2c_client *client, u8 reg) 822{ 823 if ((reg >= 0x07) && (reg <= 0x0c)) 824 return swab16(i2c_smbus_read_word_data(client, reg)); 825 else 826 return i2c_smbus_read_byte_data(client, reg); 827} 828 829static 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_data(client, reg, swab16(value)); 833 else 834 return i2c_smbus_write_byte_data(client, reg, value); 835} 836 837 838static 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 914static int __init sensors_gl520sm_init(void) 915{ 916 return i2c_add_driver(&gl520_driver); 917} 918 919static void __exit sensors_gl520sm_exit(void) 920{ 921 i2c_del_driver(&gl520_driver); 922} 923 924 925MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, " 926 "Ky��sti M��lkki <kmalkki@cc.hut.fi>, " 927 "Maarten Deprez <maartendeprez@users.sourceforge.net>"); 928MODULE_DESCRIPTION("GL520SM driver"); 929MODULE_LICENSE("GPL"); 930 931module_init(sensors_gl520sm_init); 932module_exit(sensors_gl520sm_exit); 933