1 /* 2 * max6650.c - Part of lm_sensors, Linux kernel modules for hardware 3 * monitoring. 4 * 5 * (C) 2007 by Hans J. Koch <hjk@linutronix.de> 6 * 7 * based on code written by John Morris <john.morris@spirentcom.com> 8 * Copyright (c) 2003 Spirent Communications 9 * and Claus Gindhart <claus.gindhart@kontron.com> 10 * 11 * This module has only been tested with the MAX6650 chip. It should 12 * also work with the MAX6651. It does not distinguish max6650 and max6651 13 * chips. 14 * 15 * The datasheet was last seen at: 16 * 17 * http://pdfserv.maxim-ic.com/en/ds/MAX6650-MAX6651.pdf 18 * 19 * This program is free software; you can redistribute it and/or modify 20 * it under the terms of the GNU General Public License as published by 21 * the Free Software Foundation; either version 2 of the License, or 22 * (at your option) any later version. 23 * 24 * This program is distributed in the hope that it will be useful, 25 * but WITHOUT ANY WARRANTY; without even the implied warranty of 26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 27 * GNU General Public License for more details. 28 * 29 * You should have received a copy of the GNU General Public License 30 * along with this program; if not, write to the Free Software 31 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 32 */ 33 34 #include <linux/module.h> 35 #include <linux/init.h> 36 #include <linux/slab.h> 37 #include <linux/jiffies.h> 38 #include <linux/i2c.h> 39 #include <linux/hwmon.h> 40 #include <linux/hwmon-sysfs.h> 41 #include <linux/err.h> 42 43 /* 44 * Addresses to scan. There are four disjoint possibilities, by pin config. 45 */ 46 47 static const unsigned short normal_i2c[] = {0x1b, 0x1f, 0x48, 0x4b, 48 I2C_CLIENT_END}; 49 50 /* 51 * Insmod parameters 52 */ 53 54 /* fan_voltage: 5=5V fan, 12=12V fan, 0=don't change */ 55 static int fan_voltage; 56 /* prescaler: Possible values are 1, 2, 4, 8, 16 or 0 for don't change */ 57 static int prescaler; 58 /* clock: The clock frequency of the chip the driver should assume */ 59 static int clock = 254000; 60 61 module_param(fan_voltage, int, S_IRUGO); 62 module_param(prescaler, int, S_IRUGO); 63 module_param(clock, int, S_IRUGO); 64 65 I2C_CLIENT_INSMOD_1(max6650); 66 67 /* 68 * MAX 6650/6651 registers 69 */ 70 71 #define MAX6650_REG_SPEED 0x00 72 #define MAX6650_REG_CONFIG 0x02 73 #define MAX6650_REG_GPIO_DEF 0x04 74 #define MAX6650_REG_DAC 0x06 75 #define MAX6650_REG_ALARM_EN 0x08 76 #define MAX6650_REG_ALARM 0x0A 77 #define MAX6650_REG_TACH0 0x0C 78 #define MAX6650_REG_TACH1 0x0E 79 #define MAX6650_REG_TACH2 0x10 80 #define MAX6650_REG_TACH3 0x12 81 #define MAX6650_REG_GPIO_STAT 0x14 82 #define MAX6650_REG_COUNT 0x16 83 84 /* 85 * Config register bits 86 */ 87 88 #define MAX6650_CFG_V12 0x08 89 #define MAX6650_CFG_PRESCALER_MASK 0x07 90 #define MAX6650_CFG_PRESCALER_2 0x01 91 #define MAX6650_CFG_PRESCALER_4 0x02 92 #define MAX6650_CFG_PRESCALER_8 0x03 93 #define MAX6650_CFG_PRESCALER_16 0x04 94 #define MAX6650_CFG_MODE_MASK 0x30 95 #define MAX6650_CFG_MODE_ON 0x00 96 #define MAX6650_CFG_MODE_OFF 0x10 97 #define MAX6650_CFG_MODE_CLOSED_LOOP 0x20 98 #define MAX6650_CFG_MODE_OPEN_LOOP 0x30 99 #define MAX6650_COUNT_MASK 0x03 100 101 /* 102 * Alarm status register bits 103 */ 104 105 #define MAX6650_ALRM_MAX 0x01 106 #define MAX6650_ALRM_MIN 0x02 107 #define MAX6650_ALRM_TACH 0x04 108 #define MAX6650_ALRM_GPIO1 0x08 109 #define MAX6650_ALRM_GPIO2 0x10 110 111 /* Minimum and maximum values of the FAN-RPM */ 112 #define FAN_RPM_MIN 240 113 #define FAN_RPM_MAX 30000 114 115 #define DIV_FROM_REG(reg) (1 << (reg & 7)) 116 117 static int max6650_probe(struct i2c_client *client, 118 const struct i2c_device_id *id); 119 static int max6650_detect(struct i2c_client *client, 120 struct i2c_board_info *info); 121 static int max6650_init_client(struct i2c_client *client); 122 static int max6650_remove(struct i2c_client *client); 123 static struct max6650_data *max6650_update_device(struct device *dev); 124 125 /* 126 * Driver data (common to all clients) 127 */ 128 129 static const struct i2c_device_id max6650_id[] = { 130 { "max6650", max6650 }, 131 { } 132 }; 133 MODULE_DEVICE_TABLE(i2c, max6650_id); 134 135 static struct i2c_driver max6650_driver = { 136 .class = I2C_CLASS_HWMON, 137 .driver = { 138 .name = "max6650", 139 }, 140 .probe = max6650_probe, 141 .remove = max6650_remove, 142 .id_table = max6650_id, 143 .detect = max6650_detect, 144 .address_list = normal_i2c, 145 }; 146 147 /* 148 * Client data (each client gets its own) 149 */ 150 151 struct max6650_data 152 { 153 struct device *hwmon_dev; 154 struct mutex update_lock; 155 char valid; /* zero until following fields are valid */ 156 unsigned long last_updated; /* in jiffies */ 157 158 /* register values */ 159 u8 speed; 160 u8 config; 161 u8 tach[4]; 162 u8 count; 163 u8 dac; 164 u8 alarm; 165 }; 166 167 static ssize_t get_fan(struct device *dev, struct device_attribute *devattr, 168 char *buf) 169 { 170 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 171 struct max6650_data *data = max6650_update_device(dev); 172 int rpm; 173 174 /* 175 * Calculation details: 176 * 177 * Each tachometer counts over an interval given by the "count" 178 * register (0.25, 0.5, 1 or 2 seconds). This module assumes 179 * that the fans produce two pulses per revolution (this seems 180 * to be the most common). 181 */ 182 183 rpm = ((data->tach[attr->index] * 120) / DIV_FROM_REG(data->count)); 184 return sprintf(buf, "%d\n", rpm); 185 } 186 187 /* 188 * Set the fan speed to the specified RPM (or read back the RPM setting). 189 * This works in closed loop mode only. Use pwm1 for open loop speed setting. 190 * 191 * The MAX6650/1 will automatically control fan speed when in closed loop 192 * mode. 193 * 194 * Assumptions: 195 * 196 * 1) The MAX6650/1 internal 254kHz clock frequency is set correctly. Use 197 * the clock module parameter if you need to fine tune this. 198 * 199 * 2) The prescaler (low three bits of the config register) has already 200 * been set to an appropriate value. Use the prescaler module parameter 201 * if your BIOS doesn't initialize the chip properly. 202 * 203 * The relevant equations are given on pages 21 and 22 of the datasheet. 204 * 205 * From the datasheet, the relevant equation when in regulation is: 206 * 207 * [fCLK / (128 x (KTACH + 1))] = 2 x FanSpeed / KSCALE 208 * 209 * where: 210 * 211 * fCLK is the oscillator frequency (either the 254kHz internal 212 * oscillator or the externally applied clock) 213 * 214 * KTACH is the value in the speed register 215 * 216 * FanSpeed is the speed of the fan in rps 217 * 218 * KSCALE is the prescaler value (1, 2, 4, 8, or 16) 219 * 220 * When reading, we need to solve for FanSpeed. When writing, we need to 221 * solve for KTACH. 222 * 223 * Note: this tachometer is completely separate from the tachometers 224 * used to measure the fan speeds. Only one fan's speed (fan1) is 225 * controlled. 226 */ 227 228 static ssize_t get_target(struct device *dev, struct device_attribute *devattr, 229 char *buf) 230 { 231 struct max6650_data *data = max6650_update_device(dev); 232 int kscale, ktach, rpm; 233 234 /* 235 * Use the datasheet equation: 236 * 237 * FanSpeed = KSCALE x fCLK / [256 x (KTACH + 1)] 238 * 239 * then multiply by 60 to give rpm. 240 */ 241 242 kscale = DIV_FROM_REG(data->config); 243 ktach = data->speed; 244 rpm = 60 * kscale * clock / (256 * (ktach + 1)); 245 return sprintf(buf, "%d\n", rpm); 246 } 247 248 static ssize_t set_target(struct device *dev, struct device_attribute *devattr, 249 const char *buf, size_t count) 250 { 251 struct i2c_client *client = to_i2c_client(dev); 252 struct max6650_data *data = i2c_get_clientdata(client); 253 int rpm = simple_strtoul(buf, NULL, 10); 254 int kscale, ktach; 255 256 rpm = SENSORS_LIMIT(rpm, FAN_RPM_MIN, FAN_RPM_MAX); 257 258 /* 259 * Divide the required speed by 60 to get from rpm to rps, then 260 * use the datasheet equation: 261 * 262 * KTACH = [(fCLK x KSCALE) / (256 x FanSpeed)] - 1 263 */ 264 265 mutex_lock(&data->update_lock); 266 267 kscale = DIV_FROM_REG(data->config); 268 ktach = ((clock * kscale) / (256 * rpm / 60)) - 1; 269 if (ktach < 0) 270 ktach = 0; 271 if (ktach > 255) 272 ktach = 255; 273 data->speed = ktach; 274 275 i2c_smbus_write_byte_data(client, MAX6650_REG_SPEED, data->speed); 276 277 mutex_unlock(&data->update_lock); 278 279 return count; 280 } 281 282 /* 283 * Get/set the fan speed in open loop mode using pwm1 sysfs file. 284 * Speed is given as a relative value from 0 to 255, where 255 is maximum 285 * speed. Note that this is done by writing directly to the chip's DAC, 286 * it won't change the closed loop speed set by fan1_target. 287 * Also note that due to rounding errors it is possible that you don't read 288 * back exactly the value you have set. 289 */ 290 291 static ssize_t get_pwm(struct device *dev, struct device_attribute *devattr, 292 char *buf) 293 { 294 int pwm; 295 struct max6650_data *data = max6650_update_device(dev); 296 297 /* Useful range for dac is 0-180 for 12V fans and 0-76 for 5V fans. 298 Lower DAC values mean higher speeds. */ 299 if (data->config & MAX6650_CFG_V12) 300 pwm = 255 - (255 * (int)data->dac)/180; 301 else 302 pwm = 255 - (255 * (int)data->dac)/76; 303 304 if (pwm < 0) 305 pwm = 0; 306 307 return sprintf(buf, "%d\n", pwm); 308 } 309 310 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, 311 const char *buf, size_t count) 312 { 313 struct i2c_client *client = to_i2c_client(dev); 314 struct max6650_data *data = i2c_get_clientdata(client); 315 int pwm = simple_strtoul(buf, NULL, 10); 316 317 pwm = SENSORS_LIMIT(pwm, 0, 255); 318 319 mutex_lock(&data->update_lock); 320 321 if (data->config & MAX6650_CFG_V12) 322 data->dac = 180 - (180 * pwm)/255; 323 else 324 data->dac = 76 - (76 * pwm)/255; 325 326 i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, data->dac); 327 328 mutex_unlock(&data->update_lock); 329 330 return count; 331 } 332 333 /* 334 * Get/Set controller mode: 335 * Possible values: 336 * 0 = Fan always on 337 * 1 = Open loop, Voltage is set according to speed, not regulated. 338 * 2 = Closed loop, RPM for all fans regulated by fan1 tachometer 339 */ 340 341 static ssize_t get_enable(struct device *dev, struct device_attribute *devattr, 342 char *buf) 343 { 344 struct max6650_data *data = max6650_update_device(dev); 345 int mode = (data->config & MAX6650_CFG_MODE_MASK) >> 4; 346 int sysfs_modes[4] = {0, 1, 2, 1}; 347 348 return sprintf(buf, "%d\n", sysfs_modes[mode]); 349 } 350 351 static ssize_t set_enable(struct device *dev, struct device_attribute *devattr, 352 const char *buf, size_t count) 353 { 354 struct i2c_client *client = to_i2c_client(dev); 355 struct max6650_data *data = i2c_get_clientdata(client); 356 int mode = simple_strtoul(buf, NULL, 10); 357 int max6650_modes[3] = {0, 3, 2}; 358 359 if ((mode < 0)||(mode > 2)) { 360 dev_err(&client->dev, 361 "illegal value for pwm1_enable (%d)\n", mode); 362 return -EINVAL; 363 } 364 365 mutex_lock(&data->update_lock); 366 367 data->config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG); 368 data->config = (data->config & ~MAX6650_CFG_MODE_MASK) 369 | (max6650_modes[mode] << 4); 370 371 i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, data->config); 372 373 mutex_unlock(&data->update_lock); 374 375 return count; 376 } 377 378 /* 379 * Read/write functions for fan1_div sysfs file. The MAX6650 has no such 380 * divider. We handle this by converting between divider and counttime: 381 * 382 * (counttime == k) <==> (divider == 2^k), k = 0, 1, 2, or 3 383 * 384 * Lower values of k allow to connect a faster fan without the risk of 385 * counter overflow. The price is lower resolution. You can also set counttime 386 * using the module parameter. Note that the module parameter "prescaler" also 387 * influences the behaviour. Unfortunately, there's no sysfs attribute 388 * defined for that. See the data sheet for details. 389 */ 390 391 static ssize_t get_div(struct device *dev, struct device_attribute *devattr, 392 char *buf) 393 { 394 struct max6650_data *data = max6650_update_device(dev); 395 396 return sprintf(buf, "%d\n", DIV_FROM_REG(data->count)); 397 } 398 399 static ssize_t set_div(struct device *dev, struct device_attribute *devattr, 400 const char *buf, size_t count) 401 { 402 struct i2c_client *client = to_i2c_client(dev); 403 struct max6650_data *data = i2c_get_clientdata(client); 404 int div = simple_strtoul(buf, NULL, 10); 405 406 mutex_lock(&data->update_lock); 407 switch (div) { 408 case 1: 409 data->count = 0; 410 break; 411 case 2: 412 data->count = 1; 413 break; 414 case 4: 415 data->count = 2; 416 break; 417 case 8: 418 data->count = 3; 419 break; 420 default: 421 mutex_unlock(&data->update_lock); 422 dev_err(&client->dev, 423 "illegal value for fan divider (%d)\n", div); 424 return -EINVAL; 425 } 426 427 i2c_smbus_write_byte_data(client, MAX6650_REG_COUNT, data->count); 428 mutex_unlock(&data->update_lock); 429 430 return count; 431 } 432 433 /* 434 * Get alarm stati: 435 * Possible values: 436 * 0 = no alarm 437 * 1 = alarm 438 */ 439 440 static ssize_t get_alarm(struct device *dev, struct device_attribute *devattr, 441 char *buf) 442 { 443 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 444 struct max6650_data *data = max6650_update_device(dev); 445 struct i2c_client *client = to_i2c_client(dev); 446 int alarm = 0; 447 448 if (data->alarm & attr->index) { 449 mutex_lock(&data->update_lock); 450 alarm = 1; 451 data->alarm &= ~attr->index; 452 data->alarm |= i2c_smbus_read_byte_data(client, 453 MAX6650_REG_ALARM); 454 mutex_unlock(&data->update_lock); 455 } 456 457 return sprintf(buf, "%d\n", alarm); 458 } 459 460 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, 0); 461 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan, NULL, 1); 462 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, get_fan, NULL, 2); 463 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, get_fan, NULL, 3); 464 static DEVICE_ATTR(fan1_target, S_IWUSR | S_IRUGO, get_target, set_target); 465 static DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO, get_div, set_div); 466 static DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, get_enable, set_enable); 467 static DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm, set_pwm); 468 static SENSOR_DEVICE_ATTR(fan1_max_alarm, S_IRUGO, get_alarm, NULL, 469 MAX6650_ALRM_MAX); 470 static SENSOR_DEVICE_ATTR(fan1_min_alarm, S_IRUGO, get_alarm, NULL, 471 MAX6650_ALRM_MIN); 472 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_alarm, NULL, 473 MAX6650_ALRM_TACH); 474 static SENSOR_DEVICE_ATTR(gpio1_alarm, S_IRUGO, get_alarm, NULL, 475 MAX6650_ALRM_GPIO1); 476 static SENSOR_DEVICE_ATTR(gpio2_alarm, S_IRUGO, get_alarm, NULL, 477 MAX6650_ALRM_GPIO2); 478 479 static mode_t max6650_attrs_visible(struct kobject *kobj, struct attribute *a, 480 int n) 481 { 482 struct device *dev = container_of(kobj, struct device, kobj); 483 struct i2c_client *client = to_i2c_client(dev); 484 u8 alarm_en = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN); 485 struct device_attribute *devattr; 486 487 /* 488 * Hide the alarms that have not been enabled by the firmware 489 */ 490 491 devattr = container_of(a, struct device_attribute, attr); 492 if (devattr == &sensor_dev_attr_fan1_max_alarm.dev_attr 493 || devattr == &sensor_dev_attr_fan1_min_alarm.dev_attr 494 || devattr == &sensor_dev_attr_fan1_fault.dev_attr 495 || devattr == &sensor_dev_attr_gpio1_alarm.dev_attr 496 || devattr == &sensor_dev_attr_gpio2_alarm.dev_attr) { 497 if (!(alarm_en & to_sensor_dev_attr(devattr)->index)) 498 return 0; 499 } 500 501 return a->mode; 502 } 503 504 static struct attribute *max6650_attrs[] = { 505 &sensor_dev_attr_fan1_input.dev_attr.attr, 506 &sensor_dev_attr_fan2_input.dev_attr.attr, 507 &sensor_dev_attr_fan3_input.dev_attr.attr, 508 &sensor_dev_attr_fan4_input.dev_attr.attr, 509 &dev_attr_fan1_target.attr, 510 &dev_attr_fan1_div.attr, 511 &dev_attr_pwm1_enable.attr, 512 &dev_attr_pwm1.attr, 513 &sensor_dev_attr_fan1_max_alarm.dev_attr.attr, 514 &sensor_dev_attr_fan1_min_alarm.dev_attr.attr, 515 &sensor_dev_attr_fan1_fault.dev_attr.attr, 516 &sensor_dev_attr_gpio1_alarm.dev_attr.attr, 517 &sensor_dev_attr_gpio2_alarm.dev_attr.attr, 518 NULL 519 }; 520 521 static struct attribute_group max6650_attr_grp = { 522 .attrs = max6650_attrs, 523 .is_visible = max6650_attrs_visible, 524 }; 525 526 /* 527 * Real code 528 */ 529 530 /* Return 0 if detection is successful, -ENODEV otherwise */ 531 static int max6650_detect(struct i2c_client *client, 532 struct i2c_board_info *info) 533 { 534 struct i2c_adapter *adapter = client->adapter; 535 int address = client->addr; 536 537 dev_dbg(&adapter->dev, "max6650_detect called\n"); 538 539 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 540 dev_dbg(&adapter->dev, "max6650: I2C bus doesn't support " 541 "byte read mode, skipping.\n"); 542 return -ENODEV; 543 } 544 545 if (((i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG) & 0xC0) 546 ||(i2c_smbus_read_byte_data(client, MAX6650_REG_GPIO_STAT) & 0xE0) 547 ||(i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN) & 0xE0) 548 ||(i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM) & 0xE0) 549 ||(i2c_smbus_read_byte_data(client, MAX6650_REG_COUNT) & 0xFC))) { 550 dev_dbg(&adapter->dev, 551 "max6650: detection failed at 0x%02x.\n", address); 552 return -ENODEV; 553 } 554 555 dev_info(&adapter->dev, "max6650: chip found at 0x%02x.\n", address); 556 557 strlcpy(info->type, "max6650", I2C_NAME_SIZE); 558 559 return 0; 560 } 561 562 static int max6650_probe(struct i2c_client *client, 563 const struct i2c_device_id *id) 564 { 565 struct max6650_data *data; 566 int err; 567 568 if (!(data = kzalloc(sizeof(struct max6650_data), GFP_KERNEL))) { 569 dev_err(&client->dev, "out of memory.\n"); 570 return -ENOMEM; 571 } 572 573 i2c_set_clientdata(client, data); 574 mutex_init(&data->update_lock); 575 576 /* 577 * Initialize the max6650 chip 578 */ 579 err = max6650_init_client(client); 580 if (err) 581 goto err_free; 582 583 err = sysfs_create_group(&client->dev.kobj, &max6650_attr_grp); 584 if (err) 585 goto err_free; 586 587 data->hwmon_dev = hwmon_device_register(&client->dev); 588 if (!IS_ERR(data->hwmon_dev)) 589 return 0; 590 591 err = PTR_ERR(data->hwmon_dev); 592 dev_err(&client->dev, "error registering hwmon device.\n"); 593 sysfs_remove_group(&client->dev.kobj, &max6650_attr_grp); 594 err_free: 595 kfree(data); 596 return err; 597 } 598 599 static int max6650_remove(struct i2c_client *client) 600 { 601 struct max6650_data *data = i2c_get_clientdata(client); 602 603 sysfs_remove_group(&client->dev.kobj, &max6650_attr_grp); 604 hwmon_device_unregister(data->hwmon_dev); 605 kfree(data); 606 return 0; 607 } 608 609 static int max6650_init_client(struct i2c_client *client) 610 { 611 struct max6650_data *data = i2c_get_clientdata(client); 612 int config; 613 int err = -EIO; 614 615 config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG); 616 617 if (config < 0) { 618 dev_err(&client->dev, "Error reading config, aborting.\n"); 619 return err; 620 } 621 622 switch (fan_voltage) { 623 case 0: 624 break; 625 case 5: 626 config &= ~MAX6650_CFG_V12; 627 break; 628 case 12: 629 config |= MAX6650_CFG_V12; 630 break; 631 default: 632 dev_err(&client->dev, 633 "illegal value for fan_voltage (%d)\n", 634 fan_voltage); 635 } 636 637 dev_info(&client->dev, "Fan voltage is set to %dV.\n", 638 (config & MAX6650_CFG_V12) ? 12 : 5); 639 640 switch (prescaler) { 641 case 0: 642 break; 643 case 1: 644 config &= ~MAX6650_CFG_PRESCALER_MASK; 645 break; 646 case 2: 647 config = (config & ~MAX6650_CFG_PRESCALER_MASK) 648 | MAX6650_CFG_PRESCALER_2; 649 break; 650 case 4: 651 config = (config & ~MAX6650_CFG_PRESCALER_MASK) 652 | MAX6650_CFG_PRESCALER_4; 653 break; 654 case 8: 655 config = (config & ~MAX6650_CFG_PRESCALER_MASK) 656 | MAX6650_CFG_PRESCALER_8; 657 break; 658 case 16: 659 config = (config & ~MAX6650_CFG_PRESCALER_MASK) 660 | MAX6650_CFG_PRESCALER_16; 661 break; 662 default: 663 dev_err(&client->dev, 664 "illegal value for prescaler (%d)\n", 665 prescaler); 666 } 667 668 dev_info(&client->dev, "Prescaler is set to %d.\n", 669 1 << (config & MAX6650_CFG_PRESCALER_MASK)); 670 671 /* If mode is set to "full off", we change it to "open loop" and 672 * set DAC to 255, which has the same effect. We do this because 673 * there's no "full off" mode defined in hwmon specifcations. 674 */ 675 676 if ((config & MAX6650_CFG_MODE_MASK) == MAX6650_CFG_MODE_OFF) { 677 dev_dbg(&client->dev, "Change mode to open loop, full off.\n"); 678 config = (config & ~MAX6650_CFG_MODE_MASK) 679 | MAX6650_CFG_MODE_OPEN_LOOP; 680 if (i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, 255)) { 681 dev_err(&client->dev, "DAC write error, aborting.\n"); 682 return err; 683 } 684 } 685 686 if (i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, config)) { 687 dev_err(&client->dev, "Config write error, aborting.\n"); 688 return err; 689 } 690 691 data->config = config; 692 data->count = i2c_smbus_read_byte_data(client, MAX6650_REG_COUNT); 693 694 return 0; 695 } 696 697 static const u8 tach_reg[] = { 698 MAX6650_REG_TACH0, 699 MAX6650_REG_TACH1, 700 MAX6650_REG_TACH2, 701 MAX6650_REG_TACH3, 702 }; 703 704 static struct max6650_data *max6650_update_device(struct device *dev) 705 { 706 int i; 707 struct i2c_client *client = to_i2c_client(dev); 708 struct max6650_data *data = i2c_get_clientdata(client); 709 710 mutex_lock(&data->update_lock); 711 712 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) { 713 data->speed = i2c_smbus_read_byte_data(client, 714 MAX6650_REG_SPEED); 715 data->config = i2c_smbus_read_byte_data(client, 716 MAX6650_REG_CONFIG); 717 for (i = 0; i < 4; i++) { 718 data->tach[i] = i2c_smbus_read_byte_data(client, 719 tach_reg[i]); 720 } 721 data->count = i2c_smbus_read_byte_data(client, 722 MAX6650_REG_COUNT); 723 data->dac = i2c_smbus_read_byte_data(client, MAX6650_REG_DAC); 724 725 /* Alarms are cleared on read in case the condition that 726 * caused the alarm is removed. Keep the value latched here 727 * for providing the register through different alarm files. */ 728 data->alarm |= i2c_smbus_read_byte_data(client, 729 MAX6650_REG_ALARM); 730 731 data->last_updated = jiffies; 732 data->valid = 1; 733 } 734 735 mutex_unlock(&data->update_lock); 736 737 return data; 738 } 739 740 static int __init sensors_max6650_init(void) 741 { 742 return i2c_add_driver(&max6650_driver); 743 } 744 745 static void __exit sensors_max6650_exit(void) 746 { 747 i2c_del_driver(&max6650_driver); 748 } 749 750 MODULE_AUTHOR("Hans J. Koch"); 751 MODULE_DESCRIPTION("MAX6650 sensor driver"); 752 MODULE_LICENSE("GPL"); 753 754 module_init(sensors_max6650_init); 755 module_exit(sensors_max6650_exit); 756