Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * adm1025.c
0004  *
0005  * Copyright (C) 2000       Chen-Yuan Wu <gwu@esoft.com>
0006  * Copyright (C) 2003-2009  Jean Delvare <jdelvare@suse.de>
0007  *
0008  * The ADM1025 is a sensor chip made by Analog Devices. It reports up to 6
0009  * voltages (including its own power source) and up to two temperatures
0010  * (its own plus up to one external one). Voltages are scaled internally
0011  * (which is not the common way) with ratios such that the nominal value
0012  * of each voltage correspond to a register value of 192 (which means a
0013  * resolution of about 0.5% of the nominal value). Temperature values are
0014  * reported with a 1 deg resolution and a 3 deg accuracy. Complete
0015  * datasheet can be obtained from Analog's website at:
0016  *   https://www.onsemi.com/PowerSolutions/product.do?id=ADM1025
0017  *
0018  * This driver also supports the ADM1025A, which differs from the ADM1025
0019  * only in that it has "open-drain VID inputs while the ADM1025 has
0020  * on-chip 100k pull-ups on the VID inputs". It doesn't make any
0021  * difference for us.
0022  *
0023  * This driver also supports the NE1619, a sensor chip made by Philips.
0024  * That chip is similar to the ADM1025A, with a few differences. The only
0025  * difference that matters to us is that the NE1619 has only two possible
0026  * addresses while the ADM1025A has a third one. Complete datasheet can be
0027  * obtained from Philips's website at:
0028  *   http://www.semiconductors.philips.com/pip/NE1619DS.html
0029  *
0030  * Since the ADM1025 was the first chipset supported by this driver, most
0031  * comments will refer to this chipset, but are actually general and
0032  * concern all supported chipsets, unless mentioned otherwise.
0033  */
0034 
0035 #include <linux/module.h>
0036 #include <linux/init.h>
0037 #include <linux/slab.h>
0038 #include <linux/jiffies.h>
0039 #include <linux/i2c.h>
0040 #include <linux/hwmon.h>
0041 #include <linux/hwmon-sysfs.h>
0042 #include <linux/hwmon-vid.h>
0043 #include <linux/err.h>
0044 #include <linux/mutex.h>
0045 
0046 /*
0047  * Addresses to scan
0048  * ADM1025 and ADM1025A have three possible addresses: 0x2c, 0x2d and 0x2e.
0049  * NE1619 has two possible addresses: 0x2c and 0x2d.
0050  */
0051 
0052 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
0053 
0054 enum chips { adm1025, ne1619 };
0055 
0056 /*
0057  * The ADM1025 registers
0058  */
0059 
0060 #define ADM1025_REG_MAN_ID      0x3E
0061 #define ADM1025_REG_CHIP_ID     0x3F
0062 #define ADM1025_REG_CONFIG      0x40
0063 #define ADM1025_REG_STATUS1     0x41
0064 #define ADM1025_REG_STATUS2     0x42
0065 #define ADM1025_REG_IN(nr)      (0x20 + (nr))
0066 #define ADM1025_REG_IN_MAX(nr)      (0x2B + (nr) * 2)
0067 #define ADM1025_REG_IN_MIN(nr)      (0x2C + (nr) * 2)
0068 #define ADM1025_REG_TEMP(nr)        (0x26 + (nr))
0069 #define ADM1025_REG_TEMP_HIGH(nr)   (0x37 + (nr) * 2)
0070 #define ADM1025_REG_TEMP_LOW(nr)    (0x38 + (nr) * 2)
0071 #define ADM1025_REG_VID         0x47
0072 #define ADM1025_REG_VID4        0x49
0073 
0074 /*
0075  * Conversions and various macros
0076  * The ADM1025 uses signed 8-bit values for temperatures.
0077  */
0078 
0079 static const int in_scale[6] = { 2500, 2250, 3300, 5000, 12000, 3300 };
0080 
0081 #define IN_FROM_REG(reg, scale) (((reg) * (scale) + 96) / 192)
0082 #define IN_TO_REG(val, scale)   ((val) <= 0 ? 0 : \
0083                  (val) >= (scale) * 255 / 192 ? 255 : \
0084                  ((val) * 192 + (scale) / 2) / (scale))
0085 
0086 #define TEMP_FROM_REG(reg)  ((reg) * 1000)
0087 #define TEMP_TO_REG(val)    ((val) <= -127500 ? -128 : \
0088                  (val) >= 126500 ? 127 : \
0089                  (((val) < 0 ? (val) - 500 : \
0090                    (val) + 500) / 1000))
0091 
0092 /*
0093  * Client data (each client gets its own)
0094  */
0095 
0096 struct adm1025_data {
0097     struct i2c_client *client;
0098     const struct attribute_group *groups[3];
0099     struct mutex update_lock;
0100     bool valid; /* false until following fields are valid */
0101     unsigned long last_updated; /* in jiffies */
0102 
0103     u8 in[6];       /* register value */
0104     u8 in_max[6];       /* register value */
0105     u8 in_min[6];       /* register value */
0106     s8 temp[2];     /* register value */
0107     s8 temp_min[2];     /* register value */
0108     s8 temp_max[2];     /* register value */
0109     u16 alarms;     /* register values, combined */
0110     u8 vid;         /* register values, combined */
0111     u8 vrm;
0112 };
0113 
0114 static struct adm1025_data *adm1025_update_device(struct device *dev)
0115 {
0116     struct adm1025_data *data = dev_get_drvdata(dev);
0117     struct i2c_client *client = data->client;
0118 
0119     mutex_lock(&data->update_lock);
0120 
0121     if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
0122         int i;
0123 
0124         dev_dbg(&client->dev, "Updating data.\n");
0125         for (i = 0; i < 6; i++) {
0126             data->in[i] = i2c_smbus_read_byte_data(client,
0127                       ADM1025_REG_IN(i));
0128             data->in_min[i] = i2c_smbus_read_byte_data(client,
0129                       ADM1025_REG_IN_MIN(i));
0130             data->in_max[i] = i2c_smbus_read_byte_data(client,
0131                       ADM1025_REG_IN_MAX(i));
0132         }
0133         for (i = 0; i < 2; i++) {
0134             data->temp[i] = i2c_smbus_read_byte_data(client,
0135                     ADM1025_REG_TEMP(i));
0136             data->temp_min[i] = i2c_smbus_read_byte_data(client,
0137                         ADM1025_REG_TEMP_LOW(i));
0138             data->temp_max[i] = i2c_smbus_read_byte_data(client,
0139                         ADM1025_REG_TEMP_HIGH(i));
0140         }
0141         data->alarms = i2c_smbus_read_byte_data(client,
0142                    ADM1025_REG_STATUS1)
0143                  | (i2c_smbus_read_byte_data(client,
0144                 ADM1025_REG_STATUS2) << 8);
0145         data->vid = (i2c_smbus_read_byte_data(client,
0146                  ADM1025_REG_VID) & 0x0f)
0147               | ((i2c_smbus_read_byte_data(client,
0148                   ADM1025_REG_VID4) & 0x01) << 4);
0149 
0150         data->last_updated = jiffies;
0151         data->valid = true;
0152     }
0153 
0154     mutex_unlock(&data->update_lock);
0155 
0156     return data;
0157 }
0158 
0159 /*
0160  * Sysfs stuff
0161  */
0162 
0163 static ssize_t
0164 in_show(struct device *dev, struct device_attribute *attr, char *buf)
0165 {
0166     int index = to_sensor_dev_attr(attr)->index;
0167     struct adm1025_data *data = adm1025_update_device(dev);
0168     return sprintf(buf, "%u\n", IN_FROM_REG(data->in[index],
0169                in_scale[index]));
0170 }
0171 
0172 static ssize_t
0173 in_min_show(struct device *dev, struct device_attribute *attr, char *buf)
0174 {
0175     int index = to_sensor_dev_attr(attr)->index;
0176     struct adm1025_data *data = adm1025_update_device(dev);
0177     return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[index],
0178                in_scale[index]));
0179 }
0180 
0181 static ssize_t
0182 in_max_show(struct device *dev, struct device_attribute *attr, char *buf)
0183 {
0184     int index = to_sensor_dev_attr(attr)->index;
0185     struct adm1025_data *data = adm1025_update_device(dev);
0186     return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[index],
0187                in_scale[index]));
0188 }
0189 
0190 static ssize_t
0191 temp_show(struct device *dev, struct device_attribute *attr, char *buf)
0192 {
0193     int index = to_sensor_dev_attr(attr)->index;
0194     struct adm1025_data *data = adm1025_update_device(dev);
0195     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[index]));
0196 }
0197 
0198 static ssize_t
0199 temp_min_show(struct device *dev, struct device_attribute *attr, char *buf)
0200 {
0201     int index = to_sensor_dev_attr(attr)->index;
0202     struct adm1025_data *data = adm1025_update_device(dev);
0203     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[index]));
0204 }
0205 
0206 static ssize_t
0207 temp_max_show(struct device *dev, struct device_attribute *attr, char *buf)
0208 {
0209     int index = to_sensor_dev_attr(attr)->index;
0210     struct adm1025_data *data = adm1025_update_device(dev);
0211     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[index]));
0212 }
0213 
0214 static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
0215                 const char *buf, size_t count)
0216 {
0217     int index = to_sensor_dev_attr(attr)->index;
0218     struct adm1025_data *data = dev_get_drvdata(dev);
0219     struct i2c_client *client = data->client;
0220     long val;
0221     int err;
0222 
0223     err = kstrtol(buf, 10, &val);
0224     if (err)
0225         return err;
0226 
0227     mutex_lock(&data->update_lock);
0228     data->in_min[index] = IN_TO_REG(val, in_scale[index]);
0229     i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MIN(index),
0230                   data->in_min[index]);
0231     mutex_unlock(&data->update_lock);
0232     return count;
0233 }
0234 
0235 static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
0236                 const char *buf, size_t count)
0237 {
0238     int index = to_sensor_dev_attr(attr)->index;
0239     struct adm1025_data *data = dev_get_drvdata(dev);
0240     struct i2c_client *client = data->client;
0241     long val;
0242     int err;
0243 
0244     err = kstrtol(buf, 10, &val);
0245     if (err)
0246         return err;
0247 
0248     mutex_lock(&data->update_lock);
0249     data->in_max[index] = IN_TO_REG(val, in_scale[index]);
0250     i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MAX(index),
0251                   data->in_max[index]);
0252     mutex_unlock(&data->update_lock);
0253     return count;
0254 }
0255 
0256 static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
0257 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
0258 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
0259 static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
0260 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
0261 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
0262 static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
0263 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
0264 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
0265 static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
0266 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
0267 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
0268 static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
0269 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
0270 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
0271 static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);
0272 static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
0273 static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
0274 
0275 static ssize_t temp_min_store(struct device *dev,
0276                   struct device_attribute *attr, const char *buf,
0277                   size_t count)
0278 {
0279     int index = to_sensor_dev_attr(attr)->index;
0280     struct adm1025_data *data = dev_get_drvdata(dev);
0281     struct i2c_client *client = data->client;
0282     long val;
0283     int err;
0284 
0285     err = kstrtol(buf, 10, &val);
0286     if (err)
0287         return err;
0288 
0289     mutex_lock(&data->update_lock);
0290     data->temp_min[index] = TEMP_TO_REG(val);
0291     i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_LOW(index),
0292                   data->temp_min[index]);
0293     mutex_unlock(&data->update_lock);
0294     return count;
0295 }
0296 
0297 static ssize_t temp_max_store(struct device *dev,
0298                   struct device_attribute *attr, const char *buf,
0299                   size_t count)
0300 {
0301     int index = to_sensor_dev_attr(attr)->index;
0302     struct adm1025_data *data = dev_get_drvdata(dev);
0303     struct i2c_client *client = data->client;
0304     long val;
0305     int err;
0306 
0307     err = kstrtol(buf, 10, &val);
0308     if (err)
0309         return err;
0310 
0311     mutex_lock(&data->update_lock);
0312     data->temp_max[index] = TEMP_TO_REG(val);
0313     i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_HIGH(index),
0314                   data->temp_max[index]);
0315     mutex_unlock(&data->update_lock);
0316     return count;
0317 }
0318 
0319 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
0320 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
0321 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
0322 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
0323 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
0324 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
0325 
0326 static ssize_t
0327 alarms_show(struct device *dev, struct device_attribute *attr, char *buf)
0328 {
0329     struct adm1025_data *data = adm1025_update_device(dev);
0330     return sprintf(buf, "%u\n", data->alarms);
0331 }
0332 static DEVICE_ATTR_RO(alarms);
0333 
0334 static ssize_t
0335 alarm_show(struct device *dev, struct device_attribute *attr, char *buf)
0336 {
0337     int bitnr = to_sensor_dev_attr(attr)->index;
0338     struct adm1025_data *data = adm1025_update_device(dev);
0339     return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
0340 }
0341 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
0342 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
0343 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
0344 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
0345 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);
0346 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 9);
0347 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 5);
0348 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 4);
0349 static SENSOR_DEVICE_ATTR_RO(temp1_fault, alarm, 14);
0350 
0351 static ssize_t
0352 cpu0_vid_show(struct device *dev, struct device_attribute *attr, char *buf)
0353 {
0354     struct adm1025_data *data = adm1025_update_device(dev);
0355     return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
0356 }
0357 static DEVICE_ATTR_RO(cpu0_vid);
0358 
0359 static ssize_t
0360 vrm_show(struct device *dev, struct device_attribute *attr, char *buf)
0361 {
0362     struct adm1025_data *data = dev_get_drvdata(dev);
0363     return sprintf(buf, "%u\n", data->vrm);
0364 }
0365 static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
0366              const char *buf, size_t count)
0367 {
0368     struct adm1025_data *data = dev_get_drvdata(dev);
0369     unsigned long val;
0370     int err;
0371 
0372     err = kstrtoul(buf, 10, &val);
0373     if (err)
0374         return err;
0375 
0376     if (val > 255)
0377         return -EINVAL;
0378 
0379     data->vrm = val;
0380     return count;
0381 }
0382 static DEVICE_ATTR_RW(vrm);
0383 
0384 /*
0385  * Real code
0386  */
0387 
0388 static struct attribute *adm1025_attributes[] = {
0389     &sensor_dev_attr_in0_input.dev_attr.attr,
0390     &sensor_dev_attr_in1_input.dev_attr.attr,
0391     &sensor_dev_attr_in2_input.dev_attr.attr,
0392     &sensor_dev_attr_in3_input.dev_attr.attr,
0393     &sensor_dev_attr_in5_input.dev_attr.attr,
0394     &sensor_dev_attr_in0_min.dev_attr.attr,
0395     &sensor_dev_attr_in1_min.dev_attr.attr,
0396     &sensor_dev_attr_in2_min.dev_attr.attr,
0397     &sensor_dev_attr_in3_min.dev_attr.attr,
0398     &sensor_dev_attr_in5_min.dev_attr.attr,
0399     &sensor_dev_attr_in0_max.dev_attr.attr,
0400     &sensor_dev_attr_in1_max.dev_attr.attr,
0401     &sensor_dev_attr_in2_max.dev_attr.attr,
0402     &sensor_dev_attr_in3_max.dev_attr.attr,
0403     &sensor_dev_attr_in5_max.dev_attr.attr,
0404     &sensor_dev_attr_in0_alarm.dev_attr.attr,
0405     &sensor_dev_attr_in1_alarm.dev_attr.attr,
0406     &sensor_dev_attr_in2_alarm.dev_attr.attr,
0407     &sensor_dev_attr_in3_alarm.dev_attr.attr,
0408     &sensor_dev_attr_in5_alarm.dev_attr.attr,
0409     &sensor_dev_attr_temp1_input.dev_attr.attr,
0410     &sensor_dev_attr_temp2_input.dev_attr.attr,
0411     &sensor_dev_attr_temp1_min.dev_attr.attr,
0412     &sensor_dev_attr_temp2_min.dev_attr.attr,
0413     &sensor_dev_attr_temp1_max.dev_attr.attr,
0414     &sensor_dev_attr_temp2_max.dev_attr.attr,
0415     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
0416     &sensor_dev_attr_temp2_alarm.dev_attr.attr,
0417     &sensor_dev_attr_temp1_fault.dev_attr.attr,
0418     &dev_attr_alarms.attr,
0419     &dev_attr_cpu0_vid.attr,
0420     &dev_attr_vrm.attr,
0421     NULL
0422 };
0423 
0424 static const struct attribute_group adm1025_group = {
0425     .attrs = adm1025_attributes,
0426 };
0427 
0428 static struct attribute *adm1025_attributes_in4[] = {
0429     &sensor_dev_attr_in4_input.dev_attr.attr,
0430     &sensor_dev_attr_in4_min.dev_attr.attr,
0431     &sensor_dev_attr_in4_max.dev_attr.attr,
0432     &sensor_dev_attr_in4_alarm.dev_attr.attr,
0433     NULL
0434 };
0435 
0436 static const struct attribute_group adm1025_group_in4 = {
0437     .attrs = adm1025_attributes_in4,
0438 };
0439 
0440 /* Return 0 if detection is successful, -ENODEV otherwise */
0441 static int adm1025_detect(struct i2c_client *client,
0442               struct i2c_board_info *info)
0443 {
0444     struct i2c_adapter *adapter = client->adapter;
0445     const char *name;
0446     u8 man_id, chip_id;
0447 
0448     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
0449         return -ENODEV;
0450 
0451     /* Check for unused bits */
0452     if ((i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG) & 0x80)
0453      || (i2c_smbus_read_byte_data(client, ADM1025_REG_STATUS1) & 0xC0)
0454      || (i2c_smbus_read_byte_data(client, ADM1025_REG_STATUS2) & 0xBC)) {
0455         dev_dbg(&adapter->dev, "ADM1025 detection failed at 0x%02x\n",
0456             client->addr);
0457         return -ENODEV;
0458     }
0459 
0460     /* Identification */
0461     chip_id = i2c_smbus_read_byte_data(client, ADM1025_REG_CHIP_ID);
0462     if ((chip_id & 0xF0) != 0x20)
0463         return -ENODEV;
0464 
0465     man_id = i2c_smbus_read_byte_data(client, ADM1025_REG_MAN_ID);
0466     if (man_id == 0x41)
0467         name = "adm1025";
0468     else if (man_id == 0xA1 && client->addr != 0x2E)
0469         name = "ne1619";
0470     else
0471         return -ENODEV;
0472 
0473     strlcpy(info->type, name, I2C_NAME_SIZE);
0474 
0475     return 0;
0476 }
0477 
0478 static void adm1025_init_client(struct i2c_client *client)
0479 {
0480     u8 reg;
0481     struct adm1025_data *data = i2c_get_clientdata(client);
0482     int i;
0483 
0484     data->vrm = vid_which_vrm();
0485 
0486     /*
0487      * Set high limits
0488      * Usually we avoid setting limits on driver init, but it happens
0489      * that the ADM1025 comes with stupid default limits (all registers
0490      * set to 0). In case the chip has not gone through any limit
0491      * setting yet, we better set the high limits to the max so that
0492      * no alarm triggers.
0493      */
0494     for (i = 0; i < 6; i++) {
0495         reg = i2c_smbus_read_byte_data(client,
0496                            ADM1025_REG_IN_MAX(i));
0497         if (reg == 0)
0498             i2c_smbus_write_byte_data(client,
0499                           ADM1025_REG_IN_MAX(i),
0500                           0xFF);
0501     }
0502     for (i = 0; i < 2; i++) {
0503         reg = i2c_smbus_read_byte_data(client,
0504                            ADM1025_REG_TEMP_HIGH(i));
0505         if (reg == 0)
0506             i2c_smbus_write_byte_data(client,
0507                           ADM1025_REG_TEMP_HIGH(i),
0508                           0x7F);
0509     }
0510 
0511     /*
0512      * Start the conversions
0513      */
0514     reg = i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG);
0515     if (!(reg & 0x01))
0516         i2c_smbus_write_byte_data(client, ADM1025_REG_CONFIG,
0517                       (reg&0x7E)|0x01);
0518 }
0519 
0520 static int adm1025_probe(struct i2c_client *client)
0521 {
0522     struct device *dev = &client->dev;
0523     struct device *hwmon_dev;
0524     struct adm1025_data *data;
0525     u8 config;
0526 
0527     data = devm_kzalloc(dev, sizeof(struct adm1025_data), GFP_KERNEL);
0528     if (!data)
0529         return -ENOMEM;
0530 
0531     i2c_set_clientdata(client, data);
0532     data->client = client;
0533     mutex_init(&data->update_lock);
0534 
0535     /* Initialize the ADM1025 chip */
0536     adm1025_init_client(client);
0537 
0538     /* sysfs hooks */
0539     data->groups[0] = &adm1025_group;
0540     /* Pin 11 is either in4 (+12V) or VID4 */
0541     config = i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG);
0542     if (!(config & 0x20))
0543         data->groups[1] = &adm1025_group_in4;
0544 
0545     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
0546                                data, data->groups);
0547     return PTR_ERR_OR_ZERO(hwmon_dev);
0548 }
0549 
0550 static const struct i2c_device_id adm1025_id[] = {
0551     { "adm1025", adm1025 },
0552     { "ne1619", ne1619 },
0553     { }
0554 };
0555 MODULE_DEVICE_TABLE(i2c, adm1025_id);
0556 
0557 static struct i2c_driver adm1025_driver = {
0558     .class      = I2C_CLASS_HWMON,
0559     .driver = {
0560         .name   = "adm1025",
0561     },
0562     .probe_new  = adm1025_probe,
0563     .id_table   = adm1025_id,
0564     .detect     = adm1025_detect,
0565     .address_list   = normal_i2c,
0566 };
0567 
0568 module_i2c_driver(adm1025_driver);
0569 
0570 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
0571 MODULE_DESCRIPTION("ADM1025 driver");
0572 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!