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