drivers/hwmon/max6650.c

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