linux/drivers/hwmon/max6639.c
<<
>>
Prefs
   1/*
   2 * max6639.c - Support for Maxim MAX6639
   3 *
   4 * 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
   5 *
   6 * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
   7 *
   8 * based on the initial MAX6639 support from semptian.net
   9 * by He Changqing <hechangqing@semptian.com>
  10 *
  11 * This program is free software; you can redistribute it and/or modify
  12 * it under the terms of the GNU General Public License as published by
  13 * the Free Software Foundation; either version 2 of the License, or
  14 * (at your option) any later version.
  15 *
  16 * This program is distributed in the hope that it will be useful,
  17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 * GNU General Public License for more details.
  20 *
  21 * You should have received a copy of the GNU General Public License
  22 * along with this program; if not, write to the Free Software
  23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24 */
  25
  26#include <linux/module.h>
  27#include <linux/init.h>
  28#include <linux/slab.h>
  29#include <linux/jiffies.h>
  30#include <linux/i2c.h>
  31#include <linux/hwmon.h>
  32#include <linux/hwmon-sysfs.h>
  33#include <linux/err.h>
  34#include <linux/mutex.h>
  35#include <linux/i2c/max6639.h>
  36
  37/* Addresses to scan */
  38static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
  39
  40/* The MAX6639 registers, valid channel numbers: 0, 1 */
  41#define MAX6639_REG_TEMP(ch)                    (0x00 + (ch))
  42#define MAX6639_REG_STATUS                      0x02
  43#define MAX6639_REG_OUTPUT_MASK                 0x03
  44#define MAX6639_REG_GCONFIG                     0x04
  45#define MAX6639_REG_TEMP_EXT(ch)                (0x05 + (ch))
  46#define MAX6639_REG_ALERT_LIMIT(ch)             (0x08 + (ch))
  47#define MAX6639_REG_OT_LIMIT(ch)                (0x0A + (ch))
  48#define MAX6639_REG_THERM_LIMIT(ch)             (0x0C + (ch))
  49#define MAX6639_REG_FAN_CONFIG1(ch)             (0x10 + (ch) * 4)
  50#define MAX6639_REG_FAN_CONFIG2a(ch)            (0x11 + (ch) * 4)
  51#define MAX6639_REG_FAN_CONFIG2b(ch)            (0x12 + (ch) * 4)
  52#define MAX6639_REG_FAN_CONFIG3(ch)             (0x13 + (ch) * 4)
  53#define MAX6639_REG_FAN_CNT(ch)                 (0x20 + (ch))
  54#define MAX6639_REG_TARGET_CNT(ch)              (0x22 + (ch))
  55#define MAX6639_REG_FAN_PPR(ch)                 (0x24 + (ch))
  56#define MAX6639_REG_TARGTDUTY(ch)               (0x26 + (ch))
  57#define MAX6639_REG_FAN_START_TEMP(ch)          (0x28 + (ch))
  58#define MAX6639_REG_DEVID                       0x3D
  59#define MAX6639_REG_MANUID                      0x3E
  60#define MAX6639_REG_DEVREV                      0x3F
  61
  62/* Register bits */
  63#define MAX6639_GCONFIG_STANDBY                 0x80
  64#define MAX6639_GCONFIG_POR                     0x40
  65#define MAX6639_GCONFIG_DISABLE_TIMEOUT         0x20
  66#define MAX6639_GCONFIG_CH2_LOCAL               0x10
  67#define MAX6639_GCONFIG_PWM_FREQ_HI             0x08
  68
  69#define MAX6639_FAN_CONFIG1_PWM                 0x80
  70
  71#define MAX6639_FAN_CONFIG3_THERM_FULL_SPEED    0x40
  72
  73static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
  74
  75#define FAN_FROM_REG(val, rpm_range)    ((val) == 0 || (val) == 255 ? \
  76                                0 : (rpm_ranges[rpm_range] * 30) / (val))
  77#define TEMP_LIMIT_TO_REG(val)  clamp_val((val) / 1000, 0, 255)
  78
  79/*
  80 * Client data (each client gets its own)
  81 */
  82struct max6639_data {
  83        struct i2c_client *client;
  84        struct mutex update_lock;
  85        char valid;             /* !=0 if following fields are valid */
  86        unsigned long last_updated;     /* In jiffies */
  87
  88        /* Register values sampled regularly */
  89        u16 temp[2];            /* Temperature, in 1/8 C, 0..255 C */
  90        bool temp_fault[2];     /* Detected temperature diode failure */
  91        u8 fan[2];              /* Register value: TACH count for fans >=30 */
  92        u8 status;              /* Detected channel alarms and fan failures */
  93
  94        /* Register values only written to */
  95        u8 pwm[2];              /* Register value: Duty cycle 0..120 */
  96        u8 temp_therm[2];       /* THERM Temperature, 0..255 C (->_max) */
  97        u8 temp_alert[2];       /* ALERT Temperature, 0..255 C (->_crit) */
  98        u8 temp_ot[2];          /* OT Temperature, 0..255 C (->_emergency) */
  99
 100        /* Register values initialized only once */
 101        u8 ppr;                 /* Pulses per rotation 0..3 for 1..4 ppr */
 102        u8 rpm_range;           /* Index in above rpm_ranges table */
 103};
 104
 105static struct max6639_data *max6639_update_device(struct device *dev)
 106{
 107        struct max6639_data *data = dev_get_drvdata(dev);
 108        struct i2c_client *client = data->client;
 109        struct max6639_data *ret = data;
 110        int i;
 111        int status_reg;
 112
 113        mutex_lock(&data->update_lock);
 114
 115        if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
 116                int res;
 117
 118                dev_dbg(&client->dev, "Starting max6639 update\n");
 119
 120                status_reg = i2c_smbus_read_byte_data(client,
 121                                                      MAX6639_REG_STATUS);
 122                if (status_reg < 0) {
 123                        ret = ERR_PTR(status_reg);
 124                        goto abort;
 125                }
 126
 127                data->status = status_reg;
 128
 129                for (i = 0; i < 2; i++) {
 130                        res = i2c_smbus_read_byte_data(client,
 131                                        MAX6639_REG_FAN_CNT(i));
 132                        if (res < 0) {
 133                                ret = ERR_PTR(res);
 134                                goto abort;
 135                        }
 136                        data->fan[i] = res;
 137
 138                        res = i2c_smbus_read_byte_data(client,
 139                                        MAX6639_REG_TEMP_EXT(i));
 140                        if (res < 0) {
 141                                ret = ERR_PTR(res);
 142                                goto abort;
 143                        }
 144                        data->temp[i] = res >> 5;
 145                        data->temp_fault[i] = res & 0x01;
 146
 147                        res = i2c_smbus_read_byte_data(client,
 148                                        MAX6639_REG_TEMP(i));
 149                        if (res < 0) {
 150                                ret = ERR_PTR(res);
 151                                goto abort;
 152                        }
 153                        data->temp[i] |= res << 3;
 154                }
 155
 156                data->last_updated = jiffies;
 157                data->valid = 1;
 158        }
 159abort:
 160        mutex_unlock(&data->update_lock);
 161
 162        return ret;
 163}
 164
 165static ssize_t show_temp_input(struct device *dev,
 166                               struct device_attribute *dev_attr, char *buf)
 167{
 168        long temp;
 169        struct max6639_data *data = max6639_update_device(dev);
 170        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 171
 172        if (IS_ERR(data))
 173                return PTR_ERR(data);
 174
 175        temp = data->temp[attr->index] * 125;
 176        return sprintf(buf, "%ld\n", temp);
 177}
 178
 179static ssize_t show_temp_fault(struct device *dev,
 180                               struct device_attribute *dev_attr, char *buf)
 181{
 182        struct max6639_data *data = max6639_update_device(dev);
 183        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 184
 185        if (IS_ERR(data))
 186                return PTR_ERR(data);
 187
 188        return sprintf(buf, "%d\n", data->temp_fault[attr->index]);
 189}
 190
 191static ssize_t show_temp_max(struct device *dev,
 192                             struct device_attribute *dev_attr, char *buf)
 193{
 194        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 195        struct max6639_data *data = dev_get_drvdata(dev);
 196
 197        return sprintf(buf, "%d\n", (data->temp_therm[attr->index] * 1000));
 198}
 199
 200static ssize_t set_temp_max(struct device *dev,
 201                            struct device_attribute *dev_attr,
 202                            const char *buf, size_t count)
 203{
 204        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 205        struct max6639_data *data = dev_get_drvdata(dev);
 206        struct i2c_client *client = data->client;
 207        unsigned long val;
 208        int res;
 209
 210        res = kstrtoul(buf, 10, &val);
 211        if (res)
 212                return res;
 213
 214        mutex_lock(&data->update_lock);
 215        data->temp_therm[attr->index] = TEMP_LIMIT_TO_REG(val);
 216        i2c_smbus_write_byte_data(client,
 217                                  MAX6639_REG_THERM_LIMIT(attr->index),
 218                                  data->temp_therm[attr->index]);
 219        mutex_unlock(&data->update_lock);
 220        return count;
 221}
 222
 223static ssize_t show_temp_crit(struct device *dev,
 224                              struct device_attribute *dev_attr, char *buf)
 225{
 226        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 227        struct max6639_data *data = dev_get_drvdata(dev);
 228
 229        return sprintf(buf, "%d\n", (data->temp_alert[attr->index] * 1000));
 230}
 231
 232static ssize_t set_temp_crit(struct device *dev,
 233                             struct device_attribute *dev_attr,
 234                             const char *buf, size_t count)
 235{
 236        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 237        struct max6639_data *data = dev_get_drvdata(dev);
 238        struct i2c_client *client = data->client;
 239        unsigned long val;
 240        int res;
 241
 242        res = kstrtoul(buf, 10, &val);
 243        if (res)
 244                return res;
 245
 246        mutex_lock(&data->update_lock);
 247        data->temp_alert[attr->index] = TEMP_LIMIT_TO_REG(val);
 248        i2c_smbus_write_byte_data(client,
 249                                  MAX6639_REG_ALERT_LIMIT(attr->index),
 250                                  data->temp_alert[attr->index]);
 251        mutex_unlock(&data->update_lock);
 252        return count;
 253}
 254
 255static ssize_t show_temp_emergency(struct device *dev,
 256                                   struct device_attribute *dev_attr,
 257                                   char *buf)
 258{
 259        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 260        struct max6639_data *data = dev_get_drvdata(dev);
 261
 262        return sprintf(buf, "%d\n", (data->temp_ot[attr->index] * 1000));
 263}
 264
 265static ssize_t set_temp_emergency(struct device *dev,
 266                                  struct device_attribute *dev_attr,
 267                                  const char *buf, size_t count)
 268{
 269        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 270        struct max6639_data *data = dev_get_drvdata(dev);
 271        struct i2c_client *client = data->client;
 272        unsigned long val;
 273        int res;
 274
 275        res = kstrtoul(buf, 10, &val);
 276        if (res)
 277                return res;
 278
 279        mutex_lock(&data->update_lock);
 280        data->temp_ot[attr->index] = TEMP_LIMIT_TO_REG(val);
 281        i2c_smbus_write_byte_data(client,
 282                                  MAX6639_REG_OT_LIMIT(attr->index),
 283                                  data->temp_ot[attr->index]);
 284        mutex_unlock(&data->update_lock);
 285        return count;
 286}
 287
 288static ssize_t show_pwm(struct device *dev,
 289                        struct device_attribute *dev_attr, char *buf)
 290{
 291        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 292        struct max6639_data *data = dev_get_drvdata(dev);
 293
 294        return sprintf(buf, "%d\n", data->pwm[attr->index] * 255 / 120);
 295}
 296
 297static ssize_t set_pwm(struct device *dev,
 298                       struct device_attribute *dev_attr,
 299                       const char *buf, size_t count)
 300{
 301        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 302        struct max6639_data *data = dev_get_drvdata(dev);
 303        struct i2c_client *client = data->client;
 304        unsigned long val;
 305        int res;
 306
 307        res = kstrtoul(buf, 10, &val);
 308        if (res)
 309                return res;
 310
 311        val = clamp_val(val, 0, 255);
 312
 313        mutex_lock(&data->update_lock);
 314        data->pwm[attr->index] = (u8)(val * 120 / 255);
 315        i2c_smbus_write_byte_data(client,
 316                                  MAX6639_REG_TARGTDUTY(attr->index),
 317                                  data->pwm[attr->index]);
 318        mutex_unlock(&data->update_lock);
 319        return count;
 320}
 321
 322static ssize_t show_fan_input(struct device *dev,
 323                              struct device_attribute *dev_attr, char *buf)
 324{
 325        struct max6639_data *data = max6639_update_device(dev);
 326        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 327
 328        if (IS_ERR(data))
 329                return PTR_ERR(data);
 330
 331        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index],
 332                       data->rpm_range));
 333}
 334
 335static ssize_t show_alarm(struct device *dev,
 336                          struct device_attribute *dev_attr, char *buf)
 337{
 338        struct max6639_data *data = max6639_update_device(dev);
 339        struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 340
 341        if (IS_ERR(data))
 342                return PTR_ERR(data);
 343
 344        return sprintf(buf, "%d\n", !!(data->status & (1 << attr->index)));
 345}
 346
 347static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
 348static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1);
 349static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
 350static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
 351static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
 352                set_temp_max, 0);
 353static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
 354                set_temp_max, 1);
 355static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_crit,
 356                set_temp_crit, 0);
 357static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp_crit,
 358                set_temp_crit, 1);
 359static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO,
 360                show_temp_emergency, set_temp_emergency, 0);
 361static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO,
 362                show_temp_emergency, set_temp_emergency, 1);
 363static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
 364static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
 365static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
 366static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
 367static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
 368static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 0);
 369static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 3);
 370static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
 371static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 7);
 372static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 6);
 373static SENSOR_DEVICE_ATTR(temp1_emergency_alarm, S_IRUGO, show_alarm, NULL, 5);
 374static SENSOR_DEVICE_ATTR(temp2_emergency_alarm, S_IRUGO, show_alarm, NULL, 4);
 375
 376
 377static struct attribute *max6639_attrs[] = {
 378        &sensor_dev_attr_temp1_input.dev_attr.attr,
 379        &sensor_dev_attr_temp2_input.dev_attr.attr,
 380        &sensor_dev_attr_temp1_fault.dev_attr.attr,
 381        &sensor_dev_attr_temp2_fault.dev_attr.attr,
 382        &sensor_dev_attr_temp1_max.dev_attr.attr,
 383        &sensor_dev_attr_temp2_max.dev_attr.attr,
 384        &sensor_dev_attr_temp1_crit.dev_attr.attr,
 385        &sensor_dev_attr_temp2_crit.dev_attr.attr,
 386        &sensor_dev_attr_temp1_emergency.dev_attr.attr,
 387        &sensor_dev_attr_temp2_emergency.dev_attr.attr,
 388        &sensor_dev_attr_pwm1.dev_attr.attr,
 389        &sensor_dev_attr_pwm2.dev_attr.attr,
 390        &sensor_dev_attr_fan1_input.dev_attr.attr,
 391        &sensor_dev_attr_fan2_input.dev_attr.attr,
 392        &sensor_dev_attr_fan1_fault.dev_attr.attr,
 393        &sensor_dev_attr_fan2_fault.dev_attr.attr,
 394        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 395        &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 396        &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 397        &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 398        &sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr,
 399        &sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr,
 400        NULL
 401};
 402ATTRIBUTE_GROUPS(max6639);
 403
 404/*
 405 *  returns respective index in rpm_ranges table
 406 *  1 by default on invalid range
 407 */
 408static int rpm_range_to_reg(int range)
 409{
 410        int i;
 411
 412        for (i = 0; i < ARRAY_SIZE(rpm_ranges); i++) {
 413                if (rpm_ranges[i] == range)
 414                        return i;
 415        }
 416
 417        return 1; /* default: 4000 RPM */
 418}
 419
 420static int max6639_init_client(struct i2c_client *client,
 421                               struct max6639_data *data)
 422{
 423        struct max6639_platform_data *max6639_info =
 424                dev_get_platdata(&client->dev);
 425        int i;
 426        int rpm_range = 1; /* default: 4000 RPM */
 427        int err;
 428
 429        /* Reset chip to default values, see below for GCONFIG setup */
 430        err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG,
 431                                  MAX6639_GCONFIG_POR);
 432        if (err)
 433                goto exit;
 434
 435        /* Fans pulse per revolution is 2 by default */
 436        if (max6639_info && max6639_info->ppr > 0 &&
 437                        max6639_info->ppr < 5)
 438                data->ppr = max6639_info->ppr;
 439        else
 440                data->ppr = 2;
 441        data->ppr -= 1;
 442
 443        if (max6639_info)
 444                rpm_range = rpm_range_to_reg(max6639_info->rpm_range);
 445        data->rpm_range = rpm_range;
 446
 447        for (i = 0; i < 2; i++) {
 448
 449                /* Set Fan pulse per revolution */
 450                err = i2c_smbus_write_byte_data(client,
 451                                MAX6639_REG_FAN_PPR(i),
 452                                data->ppr << 6);
 453                if (err)
 454                        goto exit;
 455
 456                /* Fans config PWM, RPM */
 457                err = i2c_smbus_write_byte_data(client,
 458                        MAX6639_REG_FAN_CONFIG1(i),
 459                        MAX6639_FAN_CONFIG1_PWM | rpm_range);
 460                if (err)
 461                        goto exit;
 462
 463                /* Fans PWM polarity high by default */
 464                if (max6639_info && max6639_info->pwm_polarity == 0)
 465                        err = i2c_smbus_write_byte_data(client,
 466                                MAX6639_REG_FAN_CONFIG2a(i), 0x00);
 467                else
 468                        err = i2c_smbus_write_byte_data(client,
 469                                MAX6639_REG_FAN_CONFIG2a(i), 0x02);
 470                if (err)
 471                        goto exit;
 472
 473                /*
 474                 * /THERM full speed enable,
 475                 * PWM frequency 25kHz, see also GCONFIG below
 476                 */
 477                err = i2c_smbus_write_byte_data(client,
 478                        MAX6639_REG_FAN_CONFIG3(i),
 479                        MAX6639_FAN_CONFIG3_THERM_FULL_SPEED | 0x03);
 480                if (err)
 481                        goto exit;
 482
 483                /* Max. temp. 80C/90C/100C */
 484                data->temp_therm[i] = 80;
 485                data->temp_alert[i] = 90;
 486                data->temp_ot[i] = 100;
 487                err = i2c_smbus_write_byte_data(client,
 488                                MAX6639_REG_THERM_LIMIT(i),
 489                                data->temp_therm[i]);
 490                if (err)
 491                        goto exit;
 492                err = i2c_smbus_write_byte_data(client,
 493                                MAX6639_REG_ALERT_LIMIT(i),
 494                                data->temp_alert[i]);
 495                if (err)
 496                        goto exit;
 497                err = i2c_smbus_write_byte_data(client,
 498                                MAX6639_REG_OT_LIMIT(i), data->temp_ot[i]);
 499                if (err)
 500                        goto exit;
 501
 502                /* PWM 120/120 (i.e. 100%) */
 503                data->pwm[i] = 120;
 504                err = i2c_smbus_write_byte_data(client,
 505                                MAX6639_REG_TARGTDUTY(i), data->pwm[i]);
 506                if (err)
 507                        goto exit;
 508        }
 509        /* Start monitoring */
 510        err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG,
 511                MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL |
 512                MAX6639_GCONFIG_PWM_FREQ_HI);
 513exit:
 514        return err;
 515}
 516
 517/* Return 0 if detection is successful, -ENODEV otherwise */
 518static int max6639_detect(struct i2c_client *client,
 519                          struct i2c_board_info *info)
 520{
 521        struct i2c_adapter *adapter = client->adapter;
 522        int dev_id, manu_id;
 523
 524        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 525                return -ENODEV;
 526
 527        /* Actual detection via device and manufacturer ID */
 528        dev_id = i2c_smbus_read_byte_data(client, MAX6639_REG_DEVID);
 529        manu_id = i2c_smbus_read_byte_data(client, MAX6639_REG_MANUID);
 530        if (dev_id != 0x58 || manu_id != 0x4D)
 531                return -ENODEV;
 532
 533        strlcpy(info->type, "max6639", I2C_NAME_SIZE);
 534
 535        return 0;
 536}
 537
 538static int max6639_probe(struct i2c_client *client,
 539                         const struct i2c_device_id *id)
 540{
 541        struct device *dev = &client->dev;
 542        struct max6639_data *data;
 543        struct device *hwmon_dev;
 544        int err;
 545
 546        data = devm_kzalloc(dev, sizeof(struct max6639_data), GFP_KERNEL);
 547        if (!data)
 548                return -ENOMEM;
 549
 550        data->client = client;
 551        mutex_init(&data->update_lock);
 552
 553        /* Initialize the max6639 chip */
 554        err = max6639_init_client(client, data);
 555        if (err < 0)
 556                return err;
 557
 558        hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
 559                                                           data,
 560                                                           max6639_groups);
 561        return PTR_ERR_OR_ZERO(hwmon_dev);
 562}
 563
 564#ifdef CONFIG_PM_SLEEP
 565static int max6639_suspend(struct device *dev)
 566{
 567        struct i2c_client *client = to_i2c_client(dev);
 568        int data = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG);
 569        if (data < 0)
 570                return data;
 571
 572        return i2c_smbus_write_byte_data(client,
 573                        MAX6639_REG_GCONFIG, data | MAX6639_GCONFIG_STANDBY);
 574}
 575
 576static int max6639_resume(struct device *dev)
 577{
 578        struct i2c_client *client = to_i2c_client(dev);
 579        int data = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG);
 580        if (data < 0)
 581                return data;
 582
 583        return i2c_smbus_write_byte_data(client,
 584                        MAX6639_REG_GCONFIG, data & ~MAX6639_GCONFIG_STANDBY);
 585}
 586#endif /* CONFIG_PM_SLEEP */
 587
 588static const struct i2c_device_id max6639_id[] = {
 589        {"max6639", 0},
 590        { }
 591};
 592
 593MODULE_DEVICE_TABLE(i2c, max6639_id);
 594
 595static SIMPLE_DEV_PM_OPS(max6639_pm_ops, max6639_suspend, max6639_resume);
 596
 597static struct i2c_driver max6639_driver = {
 598        .class = I2C_CLASS_HWMON,
 599        .driver = {
 600                   .name = "max6639",
 601                   .pm = &max6639_pm_ops,
 602                   },
 603        .probe = max6639_probe,
 604        .id_table = max6639_id,
 605        .detect = max6639_detect,
 606        .address_list = normal_i2c,
 607};
 608
 609module_i2c_driver(max6639_driver);
 610
 611MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
 612MODULE_DESCRIPTION("max6639 driver");
 613MODULE_LICENSE("GPL");
 614