drivers/hwmon/max6639.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * max6639.c - Support for Maxim MAX6639
   4  *
   5  * 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
   6  *
   7  * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
   8  *
   9  * based on the initial MAX6639 support from semptian.net
  10  * by He Changqing <hechangqing@semptian.com>
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/slab.h>
  16 #include <linux/jiffies.h>
  17 #include <linux/i2c.h>
  18 #include <linux/hwmon.h>
  19 #include <linux/hwmon-sysfs.h>
  20 #include <linux/err.h>
  21 #include <linux/mutex.h>
  22 #include <linux/regmap.h>
  23 #include <linux/util_macros.h>
  24
  25 /* Addresses to scan */
  26 static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
  27
  28 /* The MAX6639 registers, valid channel numbers: 0, 1 */
  29 #define MAX6639_REG_TEMP(ch)                    (0x00 + (ch))
  30 #define MAX6639_REG_STATUS                      0x02
  31 #define MAX6639_REG_OUTPUT_MASK                 0x03
  32 #define MAX6639_REG_GCONFIG                     0x04
  33 #define MAX6639_REG_TEMP_EXT(ch)                (0x05 + (ch))
  34 #define MAX6639_REG_ALERT_LIMIT(ch)             (0x08 + (ch))
  35 #define MAX6639_REG_OT_LIMIT(ch)                (0x0A + (ch))
  36 #define MAX6639_REG_THERM_LIMIT(ch)             (0x0C + (ch))
  37 #define MAX6639_REG_FAN_CONFIG1(ch)             (0x10 + (ch) * 4)
  38 #define MAX6639_REG_FAN_CONFIG2a(ch)            (0x11 + (ch) * 4)
  39 #define MAX6639_REG_FAN_CONFIG2b(ch)            (0x12 + (ch) * 4)
  40 #define MAX6639_REG_FAN_CONFIG3(ch)             (0x13 + (ch) * 4)
  41 #define MAX6639_REG_FAN_CNT(ch)                 (0x20 + (ch))
  42 #define MAX6639_REG_TARGET_CNT(ch)              (0x22 + (ch))
  43 #define MAX6639_REG_FAN_PPR(ch)                 (0x24 + (ch))
  44 #define MAX6639_REG_TARGTDUTY(ch)               (0x26 + (ch))
  45 #define MAX6639_REG_FAN_START_TEMP(ch)          (0x28 + (ch))
  46 #define MAX6639_REG_DEVID                       0x3D
  47 #define MAX6639_REG_MANUID                      0x3E
  48 #define MAX6639_REG_DEVREV                      0x3F
  49
  50 /* Register bits */
  51 #define MAX6639_GCONFIG_STANDBY                 0x80
  52 #define MAX6639_GCONFIG_POR                     0x40
  53 #define MAX6639_GCONFIG_DISABLE_TIMEOUT         0x20
  54 #define MAX6639_GCONFIG_CH2_LOCAL               0x10
  55 #define MAX6639_GCONFIG_PWM_FREQ_HI             0x08
  56
  57 #define MAX6639_FAN_CONFIG1_PWM                 0x80
  58 #define MAX6639_FAN_CONFIG3_FREQ_MASK           0x03
  59 #define MAX6639_FAN_CONFIG3_THERM_FULL_SPEED    0x40
  60
  61 #define MAX6639_NUM_CHANNELS                    2
  62
  63 static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
  64
  65 /* Supported PWM frequency */
  66 static const unsigned int freq_table[] = { 20, 33, 50, 100, 5000, 8333, 12500,
  67                                            25000 };
  68
  69 #define FAN_FROM_REG(val, rpm_range)    ((val) == 0 || (val) == 255 ? \
  70                                 0 : (rpm_ranges[rpm_range] * 30) / (val))
  71 #define TEMP_LIMIT_TO_REG(val)  clamp_val((val) / 1000, 0, 255)
  72
  73 /*
  74  * Client data (each client gets its own)
  75  */
  76 struct max6639_data {
  77         struct regmap *regmap;
  78         struct mutex update_lock;
  79
  80         /* Register values initialized only once */
  81         u8 ppr[MAX6639_NUM_CHANNELS];   /* Pulses per rotation 0..3 for 1..4 ppr */
  82         u8 rpm_range[MAX6639_NUM_CHANNELS]; /* Index in above rpm_ranges table */
  83
  84         /* Optional regulator for FAN supply */
  85         struct regulator *reg;
  86 };
  87
  88 static int max6639_temp_read_input(struct device *dev, int channel, long *temp)
  89 {
  90         u32 regs[2] = { MAX6639_REG_TEMP_EXT(channel), MAX6639_REG_TEMP(channel) };
  91         struct max6639_data *data = dev_get_drvdata(dev);
  92         u8 regvals[2];
  93         int res;
  94
  95         res = regmap_multi_reg_read(data->regmap, regs, regvals, 2);
  96         if (res < 0)
  97                 return res;
  98
  99         *temp = ((regvals[0] >> 5) | (regvals[1] << 3)) * 125;
 100
 101         return 0;
 102 }
 103
 104 static int max6639_temp_read_fault(struct device *dev, int channel, long *fault)
 105 {
 106         struct max6639_data *data = dev_get_drvdata(dev);
 107         unsigned int val;
 108         int res;
 109
 110         res = regmap_read(data->regmap, MAX6639_REG_TEMP_EXT(channel), &val);
 111         if (res < 0)
 112                 return res;
 113
 114         *fault = val & 1;
 115
 116         return 0;
 117 }
 118
 119 static int max6639_temp_read_max(struct device *dev, int channel, long *max)
 120 {
 121         struct max6639_data *data = dev_get_drvdata(dev);
 122         unsigned int val;
 123         int res;
 124
 125         res = regmap_read(data->regmap, MAX6639_REG_THERM_LIMIT(channel), &val);
 126         if (res < 0)
 127                 return res;
 128
 129         *max = (long)val * 1000;
 130
 131         return 0;
 132 }
 133
 134 static int max6639_temp_read_crit(struct device *dev, int channel, long *crit)
 135 {
 136         struct max6639_data *data = dev_get_drvdata(dev);
 137         unsigned int val;
 138         int res;
 139
 140         res = regmap_read(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), &val);
 141         if (res < 0)
 142                 return res;
 143
 144         *crit = (long)val * 1000;
 145
 146         return 0;
 147 }
 148
 149 static int max6639_temp_read_emergency(struct device *dev, int channel, long *emerg)
 150 {
 151         struct max6639_data *data = dev_get_drvdata(dev);
 152         unsigned int val;
 153         int res;
 154
 155         res = regmap_read(data->regmap, MAX6639_REG_OT_LIMIT(channel), &val);
 156         if (res < 0)
 157                 return res;
 158
 159         *emerg = (long)val * 1000;
 160
 161         return 0;
 162 }
 163
 164 static int max6639_get_status(struct device *dev, unsigned int *status)
 165 {
 166         struct max6639_data *data = dev_get_drvdata(dev);
 167         unsigned int val;
 168         int res;
 169
 170         res = regmap_read(data->regmap, MAX6639_REG_STATUS, &val);
 171         if (res < 0)
 172                 return res;
 173
 174         *status = val;
 175
 176         return 0;
 177 }
 178
 179 static int max6639_temp_set_max(struct max6639_data *data, int channel, long val)
 180 {
 181         int res;
 182
 183         res = regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(channel),
 184                            TEMP_LIMIT_TO_REG(val));
 185         return res;
 186 }
 187
 188 static int max6639_temp_set_crit(struct max6639_data *data, int channel, long val)
 189 {
 190         int res;
 191
 192         res = regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
 193
 194         return res;
 195 }
 196
 197 static int max6639_temp_set_emergency(struct max6639_data *data, int channel, long val)
 198 {
 199         int res;
 200
 201         res = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(channel), TEMP_LIMIT_TO_REG(val));
 202
 203         return res;
 204 }
 205
 206 static int max6639_read_fan(struct device *dev, u32 attr, int channel,
 207                             long *fan_val)
 208 {
 209         struct max6639_data *data = dev_get_drvdata(dev);
 210         unsigned int val;
 211         int res;
 212
 213         switch (attr) {
 214         case hwmon_fan_input:
 215                 res = regmap_read(data->regmap, MAX6639_REG_FAN_CNT(channel), &val);
 216                 if (res < 0)
 217                         return res;
 218                 *fan_val = FAN_FROM_REG(val, data->rpm_range[channel]);
 219                 return 0;
 220         case hwmon_fan_fault:
 221                 res = max6639_get_status(dev, &val);
 222                 if (res < 0)
 223                         return res;
 224                 *fan_val = !!(val & BIT(1 - channel));
 225                 return 0;
 226         case hwmon_fan_pulses:
 227                 *fan_val = data->ppr[channel];
 228                 return 0;
 229         default:
 230                 return -EOPNOTSUPP;
 231         }
 232 }
 233
 234 static int max6639_set_ppr(struct max6639_data *data, int channel, u8 ppr)
 235 {
 236         /* Decrement the PPR value and shift left by 6 to match the register format */
 237         return regmap_write(data->regmap, MAX6639_REG_FAN_PPR(channel), ppr-- << 6);
 238 }
 239
 240 static int max6639_write_fan(struct device *dev, u32 attr, int channel,
 241                              long val)
 242 {
 243         struct max6639_data *data = dev_get_drvdata(dev);
 244         int err;
 245
 246         switch (attr) {
 247         case hwmon_fan_pulses:
 248                 if (val <= 0 || val > 4)
 249                         return -EINVAL;
 250
 251                 mutex_lock(&data->update_lock);
 252                 /* Set Fan pulse per revolution */
 253                 err = max6639_set_ppr(data, channel, val);
 254                 if (err < 0) {
 255                         mutex_unlock(&data->update_lock);
 256                         return err;
 257                 }
 258                 data->ppr[channel] = val;
 259
 260                 mutex_unlock(&data->update_lock);
 261                 return 0;
 262         default:
 263                 return -EOPNOTSUPP;
 264         }
 265 }
 266
 267 static umode_t max6639_fan_is_visible(const void *_data, u32 attr, int channel)
 268 {
 269         switch (attr) {
 270         case hwmon_fan_input:
 271         case hwmon_fan_fault:
 272                 return 0444;
 273         case hwmon_fan_pulses:
 274                 return 0644;
 275         default:
 276                 return 0;
 277         }
 278 }
 279
 280 static int max6639_read_pwm(struct device *dev, u32 attr, int channel,
 281                             long *pwm_val)
 282 {
 283         u32 regs[2] = { MAX6639_REG_FAN_CONFIG3(channel), MAX6639_REG_GCONFIG };
 284         struct max6639_data *data = dev_get_drvdata(dev);
 285         unsigned int val;
 286         u8 regvals[2];
 287         int res;
 288         u8 i;
 289
 290         switch (attr) {
 291         case hwmon_pwm_input:
 292                 res = regmap_read(data->regmap, MAX6639_REG_TARGTDUTY(channel), &val);
 293                 if (res < 0)
 294                         return res;
 295                 *pwm_val = val * 255 / 120;
 296                 return 0;
 297         case hwmon_pwm_freq:
 298                 res = regmap_multi_reg_read(data->regmap, regs, regvals, 2);
 299                 if (res < 0)
 300                         return res;
 301                 i = regvals[0] & MAX6639_FAN_CONFIG3_FREQ_MASK;
 302                 if (regvals[1] & MAX6639_GCONFIG_PWM_FREQ_HI)
 303                         i |= 0x4;
 304                 *pwm_val = freq_table[i];
 305                 return 0;
 306         default:
 307                 return -EOPNOTSUPP;
 308         }
 309 }
 310
 311 static int max6639_write_pwm(struct device *dev, u32 attr, int channel,
 312                              long val)
 313 {
 314         struct max6639_data *data = dev_get_drvdata(dev);
 315         int err;
 316         u8 i;
 317
 318         switch (attr) {
 319         case hwmon_pwm_input:
 320                 if (val < 0 || val > 255)
 321                         return -EINVAL;
 322                 err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(channel),
 323                                    val * 120 / 255);
 324                 return err;
 325         case hwmon_pwm_freq:
 326                 val = clamp_val(val, 0, 25000);
 327
 328                 i = find_closest(val, freq_table, ARRAY_SIZE(freq_table));
 329
 330                 mutex_lock(&data->update_lock);
 331                 err = regmap_update_bits(data->regmap, MAX6639_REG_FAN_CONFIG3(channel),
 332                                          MAX6639_FAN_CONFIG3_FREQ_MASK, i);
 333                 if (err < 0) {
 334                         mutex_unlock(&data->update_lock);
 335                         return err;
 336                 }
 337
 338                 if (i >> 2)
 339                         err = regmap_set_bits(data->regmap, MAX6639_REG_GCONFIG,
 340                                               MAX6639_GCONFIG_PWM_FREQ_HI);
 341                 else
 342                         err = regmap_clear_bits(data->regmap, MAX6639_REG_GCONFIG,
 343                                                 MAX6639_GCONFIG_PWM_FREQ_HI);
 344
 345                 mutex_unlock(&data->update_lock);
 346                 return err;
 347         default:
 348                 return -EOPNOTSUPP;
 349         }
 350 }
 351
 352 static umode_t max6639_pwm_is_visible(const void *_data, u32 attr, int channel)
 353 {
 354         switch (attr) {
 355         case hwmon_pwm_input:
 356         case hwmon_pwm_freq:
 357                 return 0644;
 358         default:
 359                 return 0;
 360         }
 361 }
 362
 363 static int max6639_read_temp(struct device *dev, u32 attr, int channel,
 364                              long *val)
 365 {
 366         unsigned int status;
 367         int res;
 368
 369         switch (attr) {
 370         case hwmon_temp_input:
 371                 res = max6639_temp_read_input(dev, channel, val);
 372                 return res;
 373         case hwmon_temp_fault:
 374                 res = max6639_temp_read_fault(dev, channel, val);
 375                 return res;
 376         case hwmon_temp_max:
 377                 res = max6639_temp_read_max(dev, channel, val);
 378                 return res;
 379         case hwmon_temp_crit:
 380                 res = max6639_temp_read_crit(dev, channel, val);
 381                 return res;
 382         case hwmon_temp_emergency:
 383                 res = max6639_temp_read_emergency(dev, channel, val);
 384                 return res;
 385         case hwmon_temp_max_alarm:
 386                 res = max6639_get_status(dev, &status);
 387                 if (res < 0)
 388                         return res;
 389                 *val = !!(status & BIT(3 - channel));
 390                 return 0;
 391         case hwmon_temp_crit_alarm:
 392                 res = max6639_get_status(dev, &status);
 393                 if (res < 0)
 394                         return res;
 395                 *val = !!(status & BIT(7 - channel));
 396                 return 0;
 397         case hwmon_temp_emergency_alarm:
 398                 res = max6639_get_status(dev, &status);
 399                 if (res < 0)
 400                         return res;
 401                 *val = !!(status & BIT(5 - channel));
 402                 return 0;
 403         default:
 404                 return -EOPNOTSUPP;
 405         }
 406 }
 407
 408 static int max6639_write_temp(struct device *dev, u32 attr, int channel,
 409                               long val)
 410 {
 411         struct max6639_data *data = dev_get_drvdata(dev);
 412
 413         switch (attr) {
 414         case hwmon_temp_max:
 415                 return max6639_temp_set_max(data, channel, val);
 416         case hwmon_temp_crit:
 417                 return max6639_temp_set_crit(data, channel, val);
 418         case hwmon_temp_emergency:
 419                 return max6639_temp_set_emergency(data, channel, val);
 420         default:
 421                 return -EOPNOTSUPP;
 422         }
 423 }
 424
 425 static umode_t max6639_temp_is_visible(const void *_data, u32 attr, int channel)
 426 {
 427         switch (attr) {
 428         case hwmon_temp_input:
 429         case hwmon_temp_fault:
 430         case hwmon_temp_max_alarm:
 431         case hwmon_temp_crit_alarm:
 432         case hwmon_temp_emergency_alarm:
 433                 return 0444;
 434         case hwmon_temp_max:
 435         case hwmon_temp_crit:
 436         case hwmon_temp_emergency:
 437                 return 0644;
 438         default:
 439                 return 0;
 440         }
 441 }
 442
 443 static int max6639_read(struct device *dev, enum hwmon_sensor_types type,
 444                         u32 attr, int channel, long *val)
 445 {
 446         switch (type) {
 447         case hwmon_fan:
 448                 return max6639_read_fan(dev, attr, channel, val);
 449         case hwmon_pwm:
 450                 return max6639_read_pwm(dev, attr, channel, val);
 451         case hwmon_temp:
 452                 return max6639_read_temp(dev, attr, channel, val);
 453         default:
 454                 return -EOPNOTSUPP;
 455         }
 456 }
 457
 458 static int max6639_write(struct device *dev, enum hwmon_sensor_types type,
 459                          u32 attr, int channel, long val)
 460 {
 461         switch (type) {
 462         case hwmon_fan:
 463                 return max6639_write_fan(dev, attr, channel, val);
 464         case hwmon_pwm:
 465                 return max6639_write_pwm(dev, attr, channel, val);
 466         case hwmon_temp:
 467                 return max6639_write_temp(dev, attr, channel, val);
 468         default:
 469                 return -EOPNOTSUPP;
 470         }
 471 }
 472
 473 static umode_t max6639_is_visible(const void *data,
 474                                   enum hwmon_sensor_types type,
 475                                   u32 attr, int channel)
 476 {
 477         switch (type) {
 478         case hwmon_fan:
 479                 return max6639_fan_is_visible(data, attr, channel);
 480         case hwmon_pwm:
 481                 return max6639_pwm_is_visible(data, attr, channel);
 482         case hwmon_temp:
 483                 return max6639_temp_is_visible(data, attr, channel);
 484         default:
 485                 return 0;
 486         }
 487 }
 488
 489 static const struct hwmon_channel_info * const max6639_info[] = {
 490         HWMON_CHANNEL_INFO(fan,
 491                            HWMON_F_INPUT | HWMON_F_FAULT | HWMON_F_PULSES,
 492                            HWMON_F_INPUT | HWMON_F_FAULT | HWMON_F_PULSES),
 493         HWMON_CHANNEL_INFO(pwm,
 494                            HWMON_PWM_INPUT | HWMON_PWM_FREQ,
 495                            HWMON_PWM_INPUT | HWMON_PWM_FREQ),
 496         HWMON_CHANNEL_INFO(temp,
 497                            HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_MAX | HWMON_T_MAX_ALARM |
 498                            HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_EMERGENCY |
 499                            HWMON_T_EMERGENCY_ALARM,
 500                            HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_MAX | HWMON_T_MAX_ALARM |
 501                            HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_EMERGENCY |
 502                            HWMON_T_EMERGENCY_ALARM),
 503         NULL
 504 };
 505
 506 static const struct hwmon_ops max6639_hwmon_ops = {
 507         .is_visible = max6639_is_visible,
 508         .read = max6639_read,
 509         .write = max6639_write,
 510 };
 511
 512 static const struct hwmon_chip_info max6639_chip_info = {
 513         .ops = &max6639_hwmon_ops,
 514         .info = max6639_info,
 515 };
 516
 517 /*
 518  *  returns respective index in rpm_ranges table
 519  *  1 by default on invalid range
 520  */
 521 static int rpm_range_to_reg(int range)
 522 {
 523         int i;
 524
 525         for (i = 0; i < ARRAY_SIZE(rpm_ranges); i++) {
 526                 if (rpm_ranges[i] == range)
 527                         return i;
 528         }
 529
 530         return 1; /* default: 4000 RPM */
 531 }
 532
 533 static int max6639_probe_child_from_dt(struct i2c_client *client,
 534                                        struct device_node *child,
 535                                        struct max6639_data *data)
 536
 537 {
 538         struct device *dev = &client->dev;
 539         u32 i;
 540         int err, val;
 541
 542         err = of_property_read_u32(child, "reg", &i);
 543         if (err) {
 544                 dev_err(dev, "missing reg property of %pOFn\n", child);
 545                 return err;
 546         }
 547
 548         if (i > 1) {
 549                 dev_err(dev, "Invalid fan index reg %d\n", i);
 550                 return -EINVAL;
 551         }
 552
 553         err = of_property_read_u32(child, "pulses-per-revolution", &val);
 554         if (!err) {
 555                 if (val < 1 || val > 5) {
 556                         dev_err(dev, "invalid pulses-per-revolution %d of %pOFn\n", val, child);
 557                         return -EINVAL;
 558                 }
 559                 data->ppr[i] = val;
 560         }
 561
 562         err = of_property_read_u32(child, "max-rpm", &val);
 563         if (!err)
 564                 data->rpm_range[i] = rpm_range_to_reg(val);
 565
 566         return 0;
 567 }
 568
 569 static int max6639_init_client(struct i2c_client *client,
 570                                struct max6639_data *data)
 571 {
 572         struct device *dev = &client->dev;
 573         const struct device_node *np = dev->of_node;
 574         struct device_node *child;
 575         int i, err;
 576
 577         /* Reset chip to default values, see below for GCONFIG setup */
 578         err = regmap_write(data->regmap, MAX6639_REG_GCONFIG, MAX6639_GCONFIG_POR);
 579         if (err)
 580                 return err;
 581
 582         /* Fans pulse per revolution is 2 by default */
 583         data->ppr[0] = 2;
 584         data->ppr[1] = 2;
 585
 586         /* default: 4000 RPM */
 587         data->rpm_range[0] = 1;
 588         data->rpm_range[1] = 1;
 589
 590         for_each_child_of_node(np, child) {
 591                 if (strcmp(child->name, "fan"))
 592                         continue;
 593
 594                 err = max6639_probe_child_from_dt(client, child, data);
 595                 if (err) {
 596                         of_node_put(child);
 597                         return err;
 598                 }
 599         }
 600
 601         for (i = 0; i < MAX6639_NUM_CHANNELS; i++) {
 602                 err = regmap_set_bits(data->regmap, MAX6639_REG_OUTPUT_MASK, BIT(1 - i));
 603                 if (err)
 604                         return err;
 605
 606                 /* Set Fan pulse per revolution */
 607                 err = max6639_set_ppr(data, i, data->ppr[i]);
 608                 if (err)
 609                         return err;
 610
 611                 /* Fans config PWM, RPM */
 612                 err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG1(i),
 613                                    MAX6639_FAN_CONFIG1_PWM | data->rpm_range[i]);
 614                 if (err)
 615                         return err;
 616
 617                 /* Fans PWM polarity high by default */
 618                 err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG2a(i), 0x00);
 619                 if (err)
 620                         return err;
 621
 622                 /*
 623                  * /THERM full speed enable,
 624                  * PWM frequency 25kHz, see also GCONFIG below
 625                  */
 626                 err = regmap_write(data->regmap, MAX6639_REG_FAN_CONFIG3(i),
 627                                    MAX6639_FAN_CONFIG3_THERM_FULL_SPEED | 0x03);
 628                 if (err)
 629                         return err;
 630
 631                 /* Max. temp. 80C/90C/100C */
 632                 err = regmap_write(data->regmap, MAX6639_REG_THERM_LIMIT(i), 80);
 633                 if (err)
 634                         return err;
 635                 err = regmap_write(data->regmap, MAX6639_REG_ALERT_LIMIT(i), 90);
 636                 if (err)
 637                         return err;
 638                 err = regmap_write(data->regmap, MAX6639_REG_OT_LIMIT(i), 100);
 639                 if (err)
 640                         return err;
 641
 642                 /* PWM 120/120 (i.e. 100%) */
 643                 err = regmap_write(data->regmap, MAX6639_REG_TARGTDUTY(i), 120);
 644                 if (err)
 645                         return err;
 646         }
 647         /* Start monitoring */
 648         return regmap_write(data->regmap, MAX6639_REG_GCONFIG,
 649                             MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL |
 650                             MAX6639_GCONFIG_PWM_FREQ_HI);
 651
 652 }
 653
 654 /* Return 0 if detection is successful, -ENODEV otherwise */
 655 static int max6639_detect(struct i2c_client *client,
 656                           struct i2c_board_info *info)
 657 {
 658         struct i2c_adapter *adapter = client->adapter;
 659         int dev_id, manu_id;
 660
 661         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 662                 return -ENODEV;
 663
 664         /* Actual detection via device and manufacturer ID */
 665         dev_id = i2c_smbus_read_byte_data(client, MAX6639_REG_DEVID);
 666         manu_id = i2c_smbus_read_byte_data(client, MAX6639_REG_MANUID);
 667         if (dev_id != 0x58 || manu_id != 0x4D)
 668                 return -ENODEV;
 669
 670         strscpy(info->type, "max6639", I2C_NAME_SIZE);
 671
 672         return 0;
 673 }
 674
 675 static void max6639_regulator_disable(void *data)
 676 {
 677         regulator_disable(data);
 678 }
 679
 680 static bool max6639_regmap_is_volatile(struct device *dev, unsigned int reg)
 681 {
 682         switch (reg) {
 683         case MAX6639_REG_TEMP(0):
 684         case MAX6639_REG_TEMP_EXT(0):
 685         case MAX6639_REG_TEMP(1):
 686         case MAX6639_REG_TEMP_EXT(1):
 687         case MAX6639_REG_STATUS:
 688         case MAX6639_REG_FAN_CNT(0):
 689         case MAX6639_REG_FAN_CNT(1):
 690         case MAX6639_REG_TARGTDUTY(0):
 691         case MAX6639_REG_TARGTDUTY(1):
 692                 return true;
 693         default:
 694                 return false;
 695         }
 696 }
 697
 698 static const struct regmap_config max6639_regmap_config = {
 699         .reg_bits = 8,
 700         .val_bits = 8,
 701         .max_register = MAX6639_REG_DEVREV,
 702         .cache_type = REGCACHE_MAPLE,
 703         .volatile_reg = max6639_regmap_is_volatile,
 704 };
 705
 706 static int max6639_probe(struct i2c_client *client)
 707 {
 708         struct device *dev = &client->dev;
 709         struct max6639_data *data;
 710         struct device *hwmon_dev;
 711         int err;
 712
 713         data = devm_kzalloc(dev, sizeof(struct max6639_data), GFP_KERNEL);
 714         if (!data)
 715                 return -ENOMEM;
 716
 717         data->regmap = devm_regmap_init_i2c(client, &max6639_regmap_config);
 718         if (IS_ERR(data->regmap))
 719                 return dev_err_probe(dev,
 720                                      PTR_ERR(data->regmap),
 721                                      "regmap initialization failed\n");
 722
 723         data->reg = devm_regulator_get_optional(dev, "fan");
 724         if (IS_ERR(data->reg)) {
 725                 if (PTR_ERR(data->reg) != -ENODEV)
 726                         return PTR_ERR(data->reg);
 727
 728                 data->reg = NULL;
 729         } else {
 730                 /* Spin up fans */
 731                 err = regulator_enable(data->reg);
 732                 if (err) {
 733                         dev_err(dev, "Failed to enable fan supply: %d\n", err);
 734                         return err;
 735                 }
 736                 err = devm_add_action_or_reset(dev, max6639_regulator_disable,
 737                                                data->reg);
 738                 if (err) {
 739                         dev_err(dev, "Failed to register action: %d\n", err);
 740                         return err;
 741                 }
 742         }
 743
 744         mutex_init(&data->update_lock);
 745
 746         /* Initialize the max6639 chip */
 747         err = max6639_init_client(client, data);
 748         if (err < 0)
 749                 return err;
 750
 751         hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
 752                                                          data, &max6639_chip_info,
 753                                                          NULL);
 754
 755         return PTR_ERR_OR_ZERO(hwmon_dev);
 756 }
 757
 758 static int max6639_suspend(struct device *dev)
 759 {
 760         struct max6639_data *data = dev_get_drvdata(dev);
 761
 762         if (data->reg)
 763                 regulator_disable(data->reg);
 764
 765         return regmap_write_bits(data->regmap, MAX6639_REG_GCONFIG, MAX6639_GCONFIG_STANDBY,
 766                                  MAX6639_GCONFIG_STANDBY);
 767 }
 768
 769 static int max6639_resume(struct device *dev)
 770 {
 771         struct max6639_data *data = dev_get_drvdata(dev);
 772         int ret;
 773
 774         if (data->reg) {
 775                 ret = regulator_enable(data->reg);
 776                 if (ret) {
 777                         dev_err(dev, "Failed to enable fan supply: %d\n", ret);
 778                         return ret;
 779                 }
 780         }
 781
 782         return regmap_write_bits(data->regmap, MAX6639_REG_GCONFIG, MAX6639_GCONFIG_STANDBY,
 783                                  ~MAX6639_GCONFIG_STANDBY);
 784 }
 785
 786 static const struct i2c_device_id max6639_id[] = {
 787         {"max6639"},
 788         { }
 789 };
 790
 791 MODULE_DEVICE_TABLE(i2c, max6639_id);
 792
 793 static DEFINE_SIMPLE_DEV_PM_OPS(max6639_pm_ops, max6639_suspend, max6639_resume);
 794
 795 static const struct of_device_id max6639_of_match[] = {
 796         { .compatible = "maxim,max6639", },
 797         { },
 798 };
 799
 800 static struct i2c_driver max6639_driver = {
 801         .class = I2C_CLASS_HWMON,
 802         .driver = {
 803                    .name = "max6639",
 804                    .pm = pm_sleep_ptr(&max6639_pm_ops),
 805                    .of_match_table = max6639_of_match,
 806                    },
 807         .probe = max6639_probe,
 808         .id_table = max6639_id,
 809         .detect = max6639_detect,
 810         .address_list = normal_i2c,
 811 };
 812
 813 module_i2c_driver(max6639_driver);
 814
 815 MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
 816 MODULE_DESCRIPTION("max6639 driver");
 817 MODULE_LICENSE("GPL");