Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * max6639.c - Support for Maxim MAX6639
0004  *
0005  * 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
0006  *
0007  * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
0008  *
0009  * based on the initial MAX6639 support from semptian.net
0010  * by He Changqing <hechangqing@semptian.com>
0011  */
0012 
0013 #include <linux/module.h>
0014 #include <linux/init.h>
0015 #include <linux/slab.h>
0016 #include <linux/jiffies.h>
0017 #include <linux/i2c.h>
0018 #include <linux/hwmon.h>
0019 #include <linux/hwmon-sysfs.h>
0020 #include <linux/err.h>
0021 #include <linux/mutex.h>
0022 #include <linux/platform_data/max6639.h>
0023 
0024 /* Addresses to scan */
0025 static const unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
0026 
0027 /* The MAX6639 registers, valid channel numbers: 0, 1 */
0028 #define MAX6639_REG_TEMP(ch)            (0x00 + (ch))
0029 #define MAX6639_REG_STATUS          0x02
0030 #define MAX6639_REG_OUTPUT_MASK         0x03
0031 #define MAX6639_REG_GCONFIG         0x04
0032 #define MAX6639_REG_TEMP_EXT(ch)        (0x05 + (ch))
0033 #define MAX6639_REG_ALERT_LIMIT(ch)     (0x08 + (ch))
0034 #define MAX6639_REG_OT_LIMIT(ch)        (0x0A + (ch))
0035 #define MAX6639_REG_THERM_LIMIT(ch)     (0x0C + (ch))
0036 #define MAX6639_REG_FAN_CONFIG1(ch)     (0x10 + (ch) * 4)
0037 #define MAX6639_REG_FAN_CONFIG2a(ch)        (0x11 + (ch) * 4)
0038 #define MAX6639_REG_FAN_CONFIG2b(ch)        (0x12 + (ch) * 4)
0039 #define MAX6639_REG_FAN_CONFIG3(ch)     (0x13 + (ch) * 4)
0040 #define MAX6639_REG_FAN_CNT(ch)         (0x20 + (ch))
0041 #define MAX6639_REG_TARGET_CNT(ch)      (0x22 + (ch))
0042 #define MAX6639_REG_FAN_PPR(ch)         (0x24 + (ch))
0043 #define MAX6639_REG_TARGTDUTY(ch)       (0x26 + (ch))
0044 #define MAX6639_REG_FAN_START_TEMP(ch)      (0x28 + (ch))
0045 #define MAX6639_REG_DEVID           0x3D
0046 #define MAX6639_REG_MANUID          0x3E
0047 #define MAX6639_REG_DEVREV          0x3F
0048 
0049 /* Register bits */
0050 #define MAX6639_GCONFIG_STANDBY         0x80
0051 #define MAX6639_GCONFIG_POR         0x40
0052 #define MAX6639_GCONFIG_DISABLE_TIMEOUT     0x20
0053 #define MAX6639_GCONFIG_CH2_LOCAL       0x10
0054 #define MAX6639_GCONFIG_PWM_FREQ_HI     0x08
0055 
0056 #define MAX6639_FAN_CONFIG1_PWM         0x80
0057 
0058 #define MAX6639_FAN_CONFIG3_THERM_FULL_SPEED    0x40
0059 
0060 static const int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
0061 
0062 #define FAN_FROM_REG(val, rpm_range)    ((val) == 0 || (val) == 255 ? \
0063                 0 : (rpm_ranges[rpm_range] * 30) / (val))
0064 #define TEMP_LIMIT_TO_REG(val)  clamp_val((val) / 1000, 0, 255)
0065 
0066 /*
0067  * Client data (each client gets its own)
0068  */
0069 struct max6639_data {
0070     struct i2c_client *client;
0071     struct mutex update_lock;
0072     bool valid;     /* true if following fields are valid */
0073     unsigned long last_updated; /* In jiffies */
0074 
0075     /* Register values sampled regularly */
0076     u16 temp[2];        /* Temperature, in 1/8 C, 0..255 C */
0077     bool temp_fault[2]; /* Detected temperature diode failure */
0078     u8 fan[2];      /* Register value: TACH count for fans >=30 */
0079     u8 status;      /* Detected channel alarms and fan failures */
0080 
0081     /* Register values only written to */
0082     u8 pwm[2];      /* Register value: Duty cycle 0..120 */
0083     u8 temp_therm[2];   /* THERM Temperature, 0..255 C (->_max) */
0084     u8 temp_alert[2];   /* ALERT Temperature, 0..255 C (->_crit) */
0085     u8 temp_ot[2];      /* OT Temperature, 0..255 C (->_emergency) */
0086 
0087     /* Register values initialized only once */
0088     u8 ppr;         /* Pulses per rotation 0..3 for 1..4 ppr */
0089     u8 rpm_range;       /* Index in above rpm_ranges table */
0090 
0091     /* Optional regulator for FAN supply */
0092     struct regulator *reg;
0093 };
0094 
0095 static struct max6639_data *max6639_update_device(struct device *dev)
0096 {
0097     struct max6639_data *data = dev_get_drvdata(dev);
0098     struct i2c_client *client = data->client;
0099     struct max6639_data *ret = data;
0100     int i;
0101     int status_reg;
0102 
0103     mutex_lock(&data->update_lock);
0104 
0105     if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
0106         int res;
0107 
0108         dev_dbg(&client->dev, "Starting max6639 update\n");
0109 
0110         status_reg = i2c_smbus_read_byte_data(client,
0111                               MAX6639_REG_STATUS);
0112         if (status_reg < 0) {
0113             ret = ERR_PTR(status_reg);
0114             goto abort;
0115         }
0116 
0117         data->status = status_reg;
0118 
0119         for (i = 0; i < 2; i++) {
0120             res = i2c_smbus_read_byte_data(client,
0121                     MAX6639_REG_FAN_CNT(i));
0122             if (res < 0) {
0123                 ret = ERR_PTR(res);
0124                 goto abort;
0125             }
0126             data->fan[i] = res;
0127 
0128             res = i2c_smbus_read_byte_data(client,
0129                     MAX6639_REG_TEMP_EXT(i));
0130             if (res < 0) {
0131                 ret = ERR_PTR(res);
0132                 goto abort;
0133             }
0134             data->temp[i] = res >> 5;
0135             data->temp_fault[i] = res & 0x01;
0136 
0137             res = i2c_smbus_read_byte_data(client,
0138                     MAX6639_REG_TEMP(i));
0139             if (res < 0) {
0140                 ret = ERR_PTR(res);
0141                 goto abort;
0142             }
0143             data->temp[i] |= res << 3;
0144         }
0145 
0146         data->last_updated = jiffies;
0147         data->valid = true;
0148     }
0149 abort:
0150     mutex_unlock(&data->update_lock);
0151 
0152     return ret;
0153 }
0154 
0155 static ssize_t temp_input_show(struct device *dev,
0156                    struct device_attribute *dev_attr, char *buf)
0157 {
0158     long temp;
0159     struct max6639_data *data = max6639_update_device(dev);
0160     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0161 
0162     if (IS_ERR(data))
0163         return PTR_ERR(data);
0164 
0165     temp = data->temp[attr->index] * 125;
0166     return sprintf(buf, "%ld\n", temp);
0167 }
0168 
0169 static ssize_t temp_fault_show(struct device *dev,
0170                    struct device_attribute *dev_attr, char *buf)
0171 {
0172     struct max6639_data *data = max6639_update_device(dev);
0173     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0174 
0175     if (IS_ERR(data))
0176         return PTR_ERR(data);
0177 
0178     return sprintf(buf, "%d\n", data->temp_fault[attr->index]);
0179 }
0180 
0181 static ssize_t temp_max_show(struct device *dev,
0182                  struct device_attribute *dev_attr, char *buf)
0183 {
0184     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0185     struct max6639_data *data = dev_get_drvdata(dev);
0186 
0187     return sprintf(buf, "%d\n", (data->temp_therm[attr->index] * 1000));
0188 }
0189 
0190 static ssize_t temp_max_store(struct device *dev,
0191                   struct device_attribute *dev_attr,
0192                   const char *buf, size_t count)
0193 {
0194     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0195     struct max6639_data *data = dev_get_drvdata(dev);
0196     struct i2c_client *client = data->client;
0197     unsigned long val;
0198     int res;
0199 
0200     res = kstrtoul(buf, 10, &val);
0201     if (res)
0202         return res;
0203 
0204     mutex_lock(&data->update_lock);
0205     data->temp_therm[attr->index] = TEMP_LIMIT_TO_REG(val);
0206     i2c_smbus_write_byte_data(client,
0207                   MAX6639_REG_THERM_LIMIT(attr->index),
0208                   data->temp_therm[attr->index]);
0209     mutex_unlock(&data->update_lock);
0210     return count;
0211 }
0212 
0213 static ssize_t temp_crit_show(struct device *dev,
0214                   struct device_attribute *dev_attr, char *buf)
0215 {
0216     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0217     struct max6639_data *data = dev_get_drvdata(dev);
0218 
0219     return sprintf(buf, "%d\n", (data->temp_alert[attr->index] * 1000));
0220 }
0221 
0222 static ssize_t temp_crit_store(struct device *dev,
0223                    struct device_attribute *dev_attr,
0224                    const char *buf, size_t count)
0225 {
0226     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0227     struct max6639_data *data = dev_get_drvdata(dev);
0228     struct i2c_client *client = data->client;
0229     unsigned long val;
0230     int res;
0231 
0232     res = kstrtoul(buf, 10, &val);
0233     if (res)
0234         return res;
0235 
0236     mutex_lock(&data->update_lock);
0237     data->temp_alert[attr->index] = TEMP_LIMIT_TO_REG(val);
0238     i2c_smbus_write_byte_data(client,
0239                   MAX6639_REG_ALERT_LIMIT(attr->index),
0240                   data->temp_alert[attr->index]);
0241     mutex_unlock(&data->update_lock);
0242     return count;
0243 }
0244 
0245 static ssize_t temp_emergency_show(struct device *dev,
0246                    struct device_attribute *dev_attr,
0247                    char *buf)
0248 {
0249     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0250     struct max6639_data *data = dev_get_drvdata(dev);
0251 
0252     return sprintf(buf, "%d\n", (data->temp_ot[attr->index] * 1000));
0253 }
0254 
0255 static ssize_t temp_emergency_store(struct device *dev,
0256                     struct device_attribute *dev_attr,
0257                     const char *buf, size_t count)
0258 {
0259     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0260     struct max6639_data *data = dev_get_drvdata(dev);
0261     struct i2c_client *client = data->client;
0262     unsigned long val;
0263     int res;
0264 
0265     res = kstrtoul(buf, 10, &val);
0266     if (res)
0267         return res;
0268 
0269     mutex_lock(&data->update_lock);
0270     data->temp_ot[attr->index] = TEMP_LIMIT_TO_REG(val);
0271     i2c_smbus_write_byte_data(client,
0272                   MAX6639_REG_OT_LIMIT(attr->index),
0273                   data->temp_ot[attr->index]);
0274     mutex_unlock(&data->update_lock);
0275     return count;
0276 }
0277 
0278 static ssize_t pwm_show(struct device *dev, struct device_attribute *dev_attr,
0279             char *buf)
0280 {
0281     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0282     struct max6639_data *data = dev_get_drvdata(dev);
0283 
0284     return sprintf(buf, "%d\n", data->pwm[attr->index] * 255 / 120);
0285 }
0286 
0287 static ssize_t pwm_store(struct device *dev,
0288              struct device_attribute *dev_attr, const char *buf,
0289              size_t count)
0290 {
0291     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0292     struct max6639_data *data = dev_get_drvdata(dev);
0293     struct i2c_client *client = data->client;
0294     unsigned long val;
0295     int res;
0296 
0297     res = kstrtoul(buf, 10, &val);
0298     if (res)
0299         return res;
0300 
0301     val = clamp_val(val, 0, 255);
0302 
0303     mutex_lock(&data->update_lock);
0304     data->pwm[attr->index] = (u8)(val * 120 / 255);
0305     i2c_smbus_write_byte_data(client,
0306                   MAX6639_REG_TARGTDUTY(attr->index),
0307                   data->pwm[attr->index]);
0308     mutex_unlock(&data->update_lock);
0309     return count;
0310 }
0311 
0312 static ssize_t fan_input_show(struct device *dev,
0313                   struct device_attribute *dev_attr, char *buf)
0314 {
0315     struct max6639_data *data = max6639_update_device(dev);
0316     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0317 
0318     if (IS_ERR(data))
0319         return PTR_ERR(data);
0320 
0321     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index],
0322                data->rpm_range));
0323 }
0324 
0325 static ssize_t alarm_show(struct device *dev,
0326               struct device_attribute *dev_attr, char *buf)
0327 {
0328     struct max6639_data *data = max6639_update_device(dev);
0329     struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
0330 
0331     if (IS_ERR(data))
0332         return PTR_ERR(data);
0333 
0334     return sprintf(buf, "%d\n", !!(data->status & (1 << attr->index)));
0335 }
0336 
0337 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0);
0338 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_input, 1);
0339 static SENSOR_DEVICE_ATTR_RO(temp1_fault, temp_fault, 0);
0340 static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp_fault, 1);
0341 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
0342 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
0343 static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp_crit, 0);
0344 static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp_crit, 1);
0345 static SENSOR_DEVICE_ATTR_RW(temp1_emergency, temp_emergency, 0);
0346 static SENSOR_DEVICE_ATTR_RW(temp2_emergency, temp_emergency, 1);
0347 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
0348 static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
0349 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan_input, 0);
0350 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan_input, 1);
0351 static SENSOR_DEVICE_ATTR_RO(fan1_fault, alarm, 1);
0352 static SENSOR_DEVICE_ATTR_RO(fan2_fault, alarm, 0);
0353 static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 3);
0354 static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, 2);
0355 static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, alarm, 7);
0356 static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, 6);
0357 static SENSOR_DEVICE_ATTR_RO(temp1_emergency_alarm, alarm, 5);
0358 static SENSOR_DEVICE_ATTR_RO(temp2_emergency_alarm, alarm, 4);
0359 
0360 
0361 static struct attribute *max6639_attrs[] = {
0362     &sensor_dev_attr_temp1_input.dev_attr.attr,
0363     &sensor_dev_attr_temp2_input.dev_attr.attr,
0364     &sensor_dev_attr_temp1_fault.dev_attr.attr,
0365     &sensor_dev_attr_temp2_fault.dev_attr.attr,
0366     &sensor_dev_attr_temp1_max.dev_attr.attr,
0367     &sensor_dev_attr_temp2_max.dev_attr.attr,
0368     &sensor_dev_attr_temp1_crit.dev_attr.attr,
0369     &sensor_dev_attr_temp2_crit.dev_attr.attr,
0370     &sensor_dev_attr_temp1_emergency.dev_attr.attr,
0371     &sensor_dev_attr_temp2_emergency.dev_attr.attr,
0372     &sensor_dev_attr_pwm1.dev_attr.attr,
0373     &sensor_dev_attr_pwm2.dev_attr.attr,
0374     &sensor_dev_attr_fan1_input.dev_attr.attr,
0375     &sensor_dev_attr_fan2_input.dev_attr.attr,
0376     &sensor_dev_attr_fan1_fault.dev_attr.attr,
0377     &sensor_dev_attr_fan2_fault.dev_attr.attr,
0378     &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
0379     &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
0380     &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
0381     &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
0382     &sensor_dev_attr_temp1_emergency_alarm.dev_attr.attr,
0383     &sensor_dev_attr_temp2_emergency_alarm.dev_attr.attr,
0384     NULL
0385 };
0386 ATTRIBUTE_GROUPS(max6639);
0387 
0388 /*
0389  *  returns respective index in rpm_ranges table
0390  *  1 by default on invalid range
0391  */
0392 static int rpm_range_to_reg(int range)
0393 {
0394     int i;
0395 
0396     for (i = 0; i < ARRAY_SIZE(rpm_ranges); i++) {
0397         if (rpm_ranges[i] == range)
0398             return i;
0399     }
0400 
0401     return 1; /* default: 4000 RPM */
0402 }
0403 
0404 static int max6639_init_client(struct i2c_client *client,
0405                    struct max6639_data *data)
0406 {
0407     struct max6639_platform_data *max6639_info =
0408         dev_get_platdata(&client->dev);
0409     int i;
0410     int rpm_range = 1; /* default: 4000 RPM */
0411     int err;
0412 
0413     /* Reset chip to default values, see below for GCONFIG setup */
0414     err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG,
0415                   MAX6639_GCONFIG_POR);
0416     if (err)
0417         goto exit;
0418 
0419     /* Fans pulse per revolution is 2 by default */
0420     if (max6639_info && max6639_info->ppr > 0 &&
0421             max6639_info->ppr < 5)
0422         data->ppr = max6639_info->ppr;
0423     else
0424         data->ppr = 2;
0425     data->ppr -= 1;
0426 
0427     if (max6639_info)
0428         rpm_range = rpm_range_to_reg(max6639_info->rpm_range);
0429     data->rpm_range = rpm_range;
0430 
0431     for (i = 0; i < 2; i++) {
0432 
0433         /* Set Fan pulse per revolution */
0434         err = i2c_smbus_write_byte_data(client,
0435                 MAX6639_REG_FAN_PPR(i),
0436                 data->ppr << 6);
0437         if (err)
0438             goto exit;
0439 
0440         /* Fans config PWM, RPM */
0441         err = i2c_smbus_write_byte_data(client,
0442             MAX6639_REG_FAN_CONFIG1(i),
0443             MAX6639_FAN_CONFIG1_PWM | rpm_range);
0444         if (err)
0445             goto exit;
0446 
0447         /* Fans PWM polarity high by default */
0448         if (max6639_info && max6639_info->pwm_polarity == 0)
0449             err = i2c_smbus_write_byte_data(client,
0450                 MAX6639_REG_FAN_CONFIG2a(i), 0x00);
0451         else
0452             err = i2c_smbus_write_byte_data(client,
0453                 MAX6639_REG_FAN_CONFIG2a(i), 0x02);
0454         if (err)
0455             goto exit;
0456 
0457         /*
0458          * /THERM full speed enable,
0459          * PWM frequency 25kHz, see also GCONFIG below
0460          */
0461         err = i2c_smbus_write_byte_data(client,
0462             MAX6639_REG_FAN_CONFIG3(i),
0463             MAX6639_FAN_CONFIG3_THERM_FULL_SPEED | 0x03);
0464         if (err)
0465             goto exit;
0466 
0467         /* Max. temp. 80C/90C/100C */
0468         data->temp_therm[i] = 80;
0469         data->temp_alert[i] = 90;
0470         data->temp_ot[i] = 100;
0471         err = i2c_smbus_write_byte_data(client,
0472                 MAX6639_REG_THERM_LIMIT(i),
0473                 data->temp_therm[i]);
0474         if (err)
0475             goto exit;
0476         err = i2c_smbus_write_byte_data(client,
0477                 MAX6639_REG_ALERT_LIMIT(i),
0478                 data->temp_alert[i]);
0479         if (err)
0480             goto exit;
0481         err = i2c_smbus_write_byte_data(client,
0482                 MAX6639_REG_OT_LIMIT(i), data->temp_ot[i]);
0483         if (err)
0484             goto exit;
0485 
0486         /* PWM 120/120 (i.e. 100%) */
0487         data->pwm[i] = 120;
0488         err = i2c_smbus_write_byte_data(client,
0489                 MAX6639_REG_TARGTDUTY(i), data->pwm[i]);
0490         if (err)
0491             goto exit;
0492     }
0493     /* Start monitoring */
0494     err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG,
0495         MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL |
0496         MAX6639_GCONFIG_PWM_FREQ_HI);
0497 exit:
0498     return err;
0499 }
0500 
0501 /* Return 0 if detection is successful, -ENODEV otherwise */
0502 static int max6639_detect(struct i2c_client *client,
0503               struct i2c_board_info *info)
0504 {
0505     struct i2c_adapter *adapter = client->adapter;
0506     int dev_id, manu_id;
0507 
0508     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0509         return -ENODEV;
0510 
0511     /* Actual detection via device and manufacturer ID */
0512     dev_id = i2c_smbus_read_byte_data(client, MAX6639_REG_DEVID);
0513     manu_id = i2c_smbus_read_byte_data(client, MAX6639_REG_MANUID);
0514     if (dev_id != 0x58 || manu_id != 0x4D)
0515         return -ENODEV;
0516 
0517     strlcpy(info->type, "max6639", I2C_NAME_SIZE);
0518 
0519     return 0;
0520 }
0521 
0522 static void max6639_regulator_disable(void *data)
0523 {
0524     regulator_disable(data);
0525 }
0526 
0527 static int max6639_probe(struct i2c_client *client)
0528 {
0529     struct device *dev = &client->dev;
0530     struct max6639_data *data;
0531     struct device *hwmon_dev;
0532     int err;
0533 
0534     data = devm_kzalloc(dev, sizeof(struct max6639_data), GFP_KERNEL);
0535     if (!data)
0536         return -ENOMEM;
0537 
0538     data->client = client;
0539 
0540     data->reg = devm_regulator_get_optional(dev, "fan");
0541     if (IS_ERR(data->reg)) {
0542         if (PTR_ERR(data->reg) != -ENODEV)
0543             return PTR_ERR(data->reg);
0544 
0545         data->reg = NULL;
0546     } else {
0547         /* Spin up fans */
0548         err = regulator_enable(data->reg);
0549         if (err) {
0550             dev_err(dev, "Failed to enable fan supply: %d\n", err);
0551             return err;
0552         }
0553         err = devm_add_action_or_reset(dev, max6639_regulator_disable,
0554                            data->reg);
0555         if (err) {
0556             dev_err(dev, "Failed to register action: %d\n", err);
0557             return err;
0558         }
0559     }
0560 
0561     mutex_init(&data->update_lock);
0562 
0563     /* Initialize the max6639 chip */
0564     err = max6639_init_client(client, data);
0565     if (err < 0)
0566         return err;
0567 
0568     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
0569                                data,
0570                                max6639_groups);
0571     return PTR_ERR_OR_ZERO(hwmon_dev);
0572 }
0573 
0574 #ifdef CONFIG_PM_SLEEP
0575 static int max6639_suspend(struct device *dev)
0576 {
0577     struct i2c_client *client = to_i2c_client(dev);
0578     struct max6639_data *data = dev_get_drvdata(dev);
0579     int ret = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG);
0580 
0581     if (ret < 0)
0582         return ret;
0583 
0584     if (data->reg)
0585         regulator_disable(data->reg);
0586 
0587     return i2c_smbus_write_byte_data(client,
0588             MAX6639_REG_GCONFIG, ret | MAX6639_GCONFIG_STANDBY);
0589 }
0590 
0591 static int max6639_resume(struct device *dev)
0592 {
0593     struct i2c_client *client = to_i2c_client(dev);
0594     struct max6639_data *data = dev_get_drvdata(dev);
0595     int ret;
0596 
0597     if (data->reg) {
0598         ret = regulator_enable(data->reg);
0599         if (ret) {
0600             dev_err(dev, "Failed to enable fan supply: %d\n", ret);
0601             return ret;
0602         }
0603     }
0604 
0605     ret = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG);
0606     if (ret < 0)
0607         return ret;
0608 
0609     return i2c_smbus_write_byte_data(client,
0610             MAX6639_REG_GCONFIG, ret & ~MAX6639_GCONFIG_STANDBY);
0611 }
0612 #endif /* CONFIG_PM_SLEEP */
0613 
0614 static const struct i2c_device_id max6639_id[] = {
0615     {"max6639", 0},
0616     { }
0617 };
0618 
0619 MODULE_DEVICE_TABLE(i2c, max6639_id);
0620 
0621 static SIMPLE_DEV_PM_OPS(max6639_pm_ops, max6639_suspend, max6639_resume);
0622 
0623 static struct i2c_driver max6639_driver = {
0624     .class = I2C_CLASS_HWMON,
0625     .driver = {
0626            .name = "max6639",
0627            .pm = &max6639_pm_ops,
0628            },
0629     .probe_new = max6639_probe,
0630     .id_table = max6639_id,
0631     .detect = max6639_detect,
0632     .address_list = normal_i2c,
0633 };
0634 
0635 module_i2c_driver(max6639_driver);
0636 
0637 MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
0638 MODULE_DESCRIPTION("max6639 driver");
0639 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!