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