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