Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Driver for
0004  *  Maxim MAX16065/MAX16066 12-Channel/8-Channel, Flash-Configurable
0005  *  System Managers with Nonvolatile Fault Registers
0006  *  Maxim MAX16067/MAX16068 6-Channel, Flash-Configurable System Managers
0007  *  with Nonvolatile Fault Registers
0008  *  Maxim MAX16070/MAX16071 12-Channel/8-Channel, Flash-Configurable System
0009  *  Monitors with Nonvolatile Fault Registers
0010  *
0011  * Copyright (C) 2011 Ericsson AB.
0012  */
0013 
0014 #include <linux/kernel.h>
0015 #include <linux/module.h>
0016 #include <linux/init.h>
0017 #include <linux/err.h>
0018 #include <linux/slab.h>
0019 #include <linux/i2c.h>
0020 #include <linux/hwmon.h>
0021 #include <linux/hwmon-sysfs.h>
0022 #include <linux/jiffies.h>
0023 
0024 enum chips { max16065, max16066, max16067, max16068, max16070, max16071 };
0025 
0026 /*
0027  * Registers
0028  */
0029 #define MAX16065_ADC(x)     ((x) * 2)
0030 
0031 #define MAX16065_CURR_SENSE 0x18
0032 #define MAX16065_CSP_ADC    0x19
0033 #define MAX16065_FAULT(x)   (0x1b + (x))
0034 #define MAX16065_SCALE(x)   (0x43 + (x))
0035 #define MAX16065_CURR_CONTROL   0x47
0036 #define MAX16065_LIMIT(l, x)    (0x48 + (l) + (x) * 3)  /*
0037                              * l: limit
0038                              *  0: min/max
0039                              *  1: crit
0040                              *  2: lcrit
0041                              * x: ADC index
0042                              */
0043 
0044 #define MAX16065_SW_ENABLE  0x73
0045 
0046 #define MAX16065_WARNING_OV (1 << 3) /* Set if secondary threshold is OV
0047                         warning */
0048 
0049 #define MAX16065_CURR_ENABLE    (1 << 0)
0050 
0051 #define MAX16065_NUM_LIMIT  3
0052 #define MAX16065_NUM_ADC    12  /* maximum number of ADC channels */
0053 
0054 static const int max16065_num_adc[] = {
0055     [max16065] = 12,
0056     [max16066] = 8,
0057     [max16067] = 6,
0058     [max16068] = 6,
0059     [max16070] = 12,
0060     [max16071] = 8,
0061 };
0062 
0063 static const bool max16065_have_secondary[] = {
0064     [max16065] = true,
0065     [max16066] = true,
0066     [max16067] = false,
0067     [max16068] = false,
0068     [max16070] = true,
0069     [max16071] = true,
0070 };
0071 
0072 static const bool max16065_have_current[] = {
0073     [max16065] = true,
0074     [max16066] = true,
0075     [max16067] = false,
0076     [max16068] = false,
0077     [max16070] = true,
0078     [max16071] = true,
0079 };
0080 
0081 struct max16065_data {
0082     enum chips type;
0083     struct i2c_client *client;
0084     const struct attribute_group *groups[4];
0085     struct mutex update_lock;
0086     bool valid;
0087     unsigned long last_updated; /* in jiffies */
0088     int num_adc;
0089     bool have_current;
0090     int curr_gain;
0091     /* limits are in mV */
0092     int limit[MAX16065_NUM_LIMIT][MAX16065_NUM_ADC];
0093     int range[MAX16065_NUM_ADC + 1];/* voltage range */
0094     int adc[MAX16065_NUM_ADC + 1];  /* adc values (raw) including csp_adc */
0095     int curr_sense;
0096     int fault[2];
0097 };
0098 
0099 static const int max16065_adc_range[] = { 5560, 2780, 1390, 0 };
0100 static const int max16065_csp_adc_range[] = { 7000, 14000 };
0101 
0102 /* ADC registers have 10 bit resolution. */
0103 static inline int ADC_TO_MV(int adc, int range)
0104 {
0105     return (adc * range) / 1024;
0106 }
0107 
0108 /*
0109  * Limit registers have 8 bit resolution and match upper 8 bits of ADC
0110  * registers.
0111  */
0112 static inline int LIMIT_TO_MV(int limit, int range)
0113 {
0114     return limit * range / 256;
0115 }
0116 
0117 static inline int MV_TO_LIMIT(int mv, int range)
0118 {
0119     return clamp_val(DIV_ROUND_CLOSEST(mv * 256, range), 0, 255);
0120 }
0121 
0122 static inline int ADC_TO_CURR(int adc, int gain)
0123 {
0124     return adc * 1400000 / (gain * 255);
0125 }
0126 
0127 /*
0128  * max16065_read_adc()
0129  *
0130  * Read 16 bit value from <reg>, <reg+1>.
0131  * Upper 8 bits are in <reg>, lower 2 bits are in bits 7:6 of <reg+1>.
0132  */
0133 static int max16065_read_adc(struct i2c_client *client, int reg)
0134 {
0135     int rv;
0136 
0137     rv = i2c_smbus_read_word_swapped(client, reg);
0138     if (unlikely(rv < 0))
0139         return rv;
0140     return rv >> 6;
0141 }
0142 
0143 static struct max16065_data *max16065_update_device(struct device *dev)
0144 {
0145     struct max16065_data *data = dev_get_drvdata(dev);
0146     struct i2c_client *client = data->client;
0147 
0148     mutex_lock(&data->update_lock);
0149     if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
0150         int i;
0151 
0152         for (i = 0; i < data->num_adc; i++)
0153             data->adc[i]
0154               = max16065_read_adc(client, MAX16065_ADC(i));
0155 
0156         if (data->have_current) {
0157             data->adc[MAX16065_NUM_ADC]
0158               = max16065_read_adc(client, MAX16065_CSP_ADC);
0159             data->curr_sense
0160               = i2c_smbus_read_byte_data(client,
0161                              MAX16065_CURR_SENSE);
0162         }
0163 
0164         for (i = 0; i < DIV_ROUND_UP(data->num_adc, 8); i++)
0165             data->fault[i]
0166               = i2c_smbus_read_byte_data(client, MAX16065_FAULT(i));
0167 
0168         data->last_updated = jiffies;
0169         data->valid = true;
0170     }
0171     mutex_unlock(&data->update_lock);
0172     return data;
0173 }
0174 
0175 static ssize_t max16065_alarm_show(struct device *dev,
0176                    struct device_attribute *da, char *buf)
0177 {
0178     struct sensor_device_attribute_2 *attr2 = to_sensor_dev_attr_2(da);
0179     struct max16065_data *data = max16065_update_device(dev);
0180     int val = data->fault[attr2->nr];
0181 
0182     if (val < 0)
0183         return val;
0184 
0185     val &= (1 << attr2->index);
0186     if (val)
0187         i2c_smbus_write_byte_data(data->client,
0188                       MAX16065_FAULT(attr2->nr), val);
0189 
0190     return sysfs_emit(buf, "%d\n", !!val);
0191 }
0192 
0193 static ssize_t max16065_input_show(struct device *dev,
0194                    struct device_attribute *da, char *buf)
0195 {
0196     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0197     struct max16065_data *data = max16065_update_device(dev);
0198     int adc = data->adc[attr->index];
0199 
0200     if (unlikely(adc < 0))
0201         return adc;
0202 
0203     return sysfs_emit(buf, "%d\n",
0204               ADC_TO_MV(adc, data->range[attr->index]));
0205 }
0206 
0207 static ssize_t max16065_current_show(struct device *dev,
0208                      struct device_attribute *da, char *buf)
0209 {
0210     struct max16065_data *data = max16065_update_device(dev);
0211 
0212     if (unlikely(data->curr_sense < 0))
0213         return data->curr_sense;
0214 
0215     return sysfs_emit(buf, "%d\n",
0216               ADC_TO_CURR(data->curr_sense, data->curr_gain));
0217 }
0218 
0219 static ssize_t max16065_limit_store(struct device *dev,
0220                     struct device_attribute *da,
0221                     const char *buf, size_t count)
0222 {
0223     struct sensor_device_attribute_2 *attr2 = to_sensor_dev_attr_2(da);
0224     struct max16065_data *data = dev_get_drvdata(dev);
0225     unsigned long val;
0226     int err;
0227     int limit;
0228 
0229     err = kstrtoul(buf, 10, &val);
0230     if (unlikely(err < 0))
0231         return err;
0232 
0233     limit = MV_TO_LIMIT(val, data->range[attr2->index]);
0234 
0235     mutex_lock(&data->update_lock);
0236     data->limit[attr2->nr][attr2->index]
0237       = LIMIT_TO_MV(limit, data->range[attr2->index]);
0238     i2c_smbus_write_byte_data(data->client,
0239                   MAX16065_LIMIT(attr2->nr, attr2->index),
0240                   limit);
0241     mutex_unlock(&data->update_lock);
0242 
0243     return count;
0244 }
0245 
0246 static ssize_t max16065_limit_show(struct device *dev,
0247                    struct device_attribute *da, char *buf)
0248 {
0249     struct sensor_device_attribute_2 *attr2 = to_sensor_dev_attr_2(da);
0250     struct max16065_data *data = dev_get_drvdata(dev);
0251 
0252     return sysfs_emit(buf, "%d\n",
0253               data->limit[attr2->nr][attr2->index]);
0254 }
0255 
0256 /* Construct a sensor_device_attribute structure for each register */
0257 
0258 /* Input voltages */
0259 static SENSOR_DEVICE_ATTR_RO(in0_input, max16065_input, 0);
0260 static SENSOR_DEVICE_ATTR_RO(in1_input, max16065_input, 1);
0261 static SENSOR_DEVICE_ATTR_RO(in2_input, max16065_input, 2);
0262 static SENSOR_DEVICE_ATTR_RO(in3_input, max16065_input, 3);
0263 static SENSOR_DEVICE_ATTR_RO(in4_input, max16065_input, 4);
0264 static SENSOR_DEVICE_ATTR_RO(in5_input, max16065_input, 5);
0265 static SENSOR_DEVICE_ATTR_RO(in6_input, max16065_input, 6);
0266 static SENSOR_DEVICE_ATTR_RO(in7_input, max16065_input, 7);
0267 static SENSOR_DEVICE_ATTR_RO(in8_input, max16065_input, 8);
0268 static SENSOR_DEVICE_ATTR_RO(in9_input, max16065_input, 9);
0269 static SENSOR_DEVICE_ATTR_RO(in10_input, max16065_input, 10);
0270 static SENSOR_DEVICE_ATTR_RO(in11_input, max16065_input, 11);
0271 static SENSOR_DEVICE_ATTR_RO(in12_input, max16065_input, 12);
0272 
0273 /* Input voltages lcrit */
0274 static SENSOR_DEVICE_ATTR_2_RW(in0_lcrit, max16065_limit, 2, 0);
0275 static SENSOR_DEVICE_ATTR_2_RW(in1_lcrit, max16065_limit, 2, 1);
0276 static SENSOR_DEVICE_ATTR_2_RW(in2_lcrit, max16065_limit, 2, 2);
0277 static SENSOR_DEVICE_ATTR_2_RW(in3_lcrit, max16065_limit, 2, 3);
0278 static SENSOR_DEVICE_ATTR_2_RW(in4_lcrit, max16065_limit, 2, 4);
0279 static SENSOR_DEVICE_ATTR_2_RW(in5_lcrit, max16065_limit, 2, 5);
0280 static SENSOR_DEVICE_ATTR_2_RW(in6_lcrit, max16065_limit, 2, 6);
0281 static SENSOR_DEVICE_ATTR_2_RW(in7_lcrit, max16065_limit, 2, 7);
0282 static SENSOR_DEVICE_ATTR_2_RW(in8_lcrit, max16065_limit, 2, 8);
0283 static SENSOR_DEVICE_ATTR_2_RW(in9_lcrit, max16065_limit, 2, 9);
0284 static SENSOR_DEVICE_ATTR_2_RW(in10_lcrit, max16065_limit, 2, 10);
0285 static SENSOR_DEVICE_ATTR_2_RW(in11_lcrit, max16065_limit, 2, 11);
0286 
0287 /* Input voltages crit */
0288 static SENSOR_DEVICE_ATTR_2_RW(in0_crit, max16065_limit, 1, 0);
0289 static SENSOR_DEVICE_ATTR_2_RW(in1_crit, max16065_limit, 1, 1);
0290 static SENSOR_DEVICE_ATTR_2_RW(in2_crit, max16065_limit, 1, 2);
0291 static SENSOR_DEVICE_ATTR_2_RW(in3_crit, max16065_limit, 1, 3);
0292 static SENSOR_DEVICE_ATTR_2_RW(in4_crit, max16065_limit, 1, 4);
0293 static SENSOR_DEVICE_ATTR_2_RW(in5_crit, max16065_limit, 1, 5);
0294 static SENSOR_DEVICE_ATTR_2_RW(in6_crit, max16065_limit, 1, 6);
0295 static SENSOR_DEVICE_ATTR_2_RW(in7_crit, max16065_limit, 1, 7);
0296 static SENSOR_DEVICE_ATTR_2_RW(in8_crit, max16065_limit, 1, 8);
0297 static SENSOR_DEVICE_ATTR_2_RW(in9_crit, max16065_limit, 1, 9);
0298 static SENSOR_DEVICE_ATTR_2_RW(in10_crit, max16065_limit, 1, 10);
0299 static SENSOR_DEVICE_ATTR_2_RW(in11_crit, max16065_limit, 1, 11);
0300 
0301 /* Input voltages min */
0302 static SENSOR_DEVICE_ATTR_2_RW(in0_min, max16065_limit, 0, 0);
0303 static SENSOR_DEVICE_ATTR_2_RW(in1_min, max16065_limit, 0, 1);
0304 static SENSOR_DEVICE_ATTR_2_RW(in2_min, max16065_limit, 0, 2);
0305 static SENSOR_DEVICE_ATTR_2_RW(in3_min, max16065_limit, 0, 3);
0306 static SENSOR_DEVICE_ATTR_2_RW(in4_min, max16065_limit, 0, 4);
0307 static SENSOR_DEVICE_ATTR_2_RW(in5_min, max16065_limit, 0, 5);
0308 static SENSOR_DEVICE_ATTR_2_RW(in6_min, max16065_limit, 0, 6);
0309 static SENSOR_DEVICE_ATTR_2_RW(in7_min, max16065_limit, 0, 7);
0310 static SENSOR_DEVICE_ATTR_2_RW(in8_min, max16065_limit, 0, 8);
0311 static SENSOR_DEVICE_ATTR_2_RW(in9_min, max16065_limit, 0, 9);
0312 static SENSOR_DEVICE_ATTR_2_RW(in10_min, max16065_limit, 0, 10);
0313 static SENSOR_DEVICE_ATTR_2_RW(in11_min, max16065_limit, 0, 11);
0314 
0315 /* Input voltages max */
0316 static SENSOR_DEVICE_ATTR_2_RW(in0_max, max16065_limit, 0, 0);
0317 static SENSOR_DEVICE_ATTR_2_RW(in1_max, max16065_limit, 0, 1);
0318 static SENSOR_DEVICE_ATTR_2_RW(in2_max, max16065_limit, 0, 2);
0319 static SENSOR_DEVICE_ATTR_2_RW(in3_max, max16065_limit, 0, 3);
0320 static SENSOR_DEVICE_ATTR_2_RW(in4_max, max16065_limit, 0, 4);
0321 static SENSOR_DEVICE_ATTR_2_RW(in5_max, max16065_limit, 0, 5);
0322 static SENSOR_DEVICE_ATTR_2_RW(in6_max, max16065_limit, 0, 6);
0323 static SENSOR_DEVICE_ATTR_2_RW(in7_max, max16065_limit, 0, 7);
0324 static SENSOR_DEVICE_ATTR_2_RW(in8_max, max16065_limit, 0, 8);
0325 static SENSOR_DEVICE_ATTR_2_RW(in9_max, max16065_limit, 0, 9);
0326 static SENSOR_DEVICE_ATTR_2_RW(in10_max, max16065_limit, 0, 10);
0327 static SENSOR_DEVICE_ATTR_2_RW(in11_max, max16065_limit, 0, 11);
0328 
0329 /* alarms */
0330 static SENSOR_DEVICE_ATTR_2_RO(in0_alarm, max16065_alarm, 0, 0);
0331 static SENSOR_DEVICE_ATTR_2_RO(in1_alarm, max16065_alarm, 0, 1);
0332 static SENSOR_DEVICE_ATTR_2_RO(in2_alarm, max16065_alarm, 0, 2);
0333 static SENSOR_DEVICE_ATTR_2_RO(in3_alarm, max16065_alarm, 0, 3);
0334 static SENSOR_DEVICE_ATTR_2_RO(in4_alarm, max16065_alarm, 0, 4);
0335 static SENSOR_DEVICE_ATTR_2_RO(in5_alarm, max16065_alarm, 0, 5);
0336 static SENSOR_DEVICE_ATTR_2_RO(in6_alarm, max16065_alarm, 0, 6);
0337 static SENSOR_DEVICE_ATTR_2_RO(in7_alarm, max16065_alarm, 0, 7);
0338 static SENSOR_DEVICE_ATTR_2_RO(in8_alarm, max16065_alarm, 1, 0);
0339 static SENSOR_DEVICE_ATTR_2_RO(in9_alarm, max16065_alarm, 1, 1);
0340 static SENSOR_DEVICE_ATTR_2_RO(in10_alarm, max16065_alarm, 1, 2);
0341 static SENSOR_DEVICE_ATTR_2_RO(in11_alarm, max16065_alarm, 1, 3);
0342 
0343 /* Current and alarm */
0344 static SENSOR_DEVICE_ATTR_RO(curr1_input, max16065_current, 0);
0345 static SENSOR_DEVICE_ATTR_2_RO(curr1_alarm, max16065_alarm, 1, 4);
0346 
0347 /*
0348  * Finally, construct an array of pointers to members of the above objects,
0349  * as required for sysfs_create_group()
0350  */
0351 static struct attribute *max16065_basic_attributes[] = {
0352     &sensor_dev_attr_in0_input.dev_attr.attr,
0353     &sensor_dev_attr_in0_lcrit.dev_attr.attr,
0354     &sensor_dev_attr_in0_crit.dev_attr.attr,
0355     &sensor_dev_attr_in0_alarm.dev_attr.attr,
0356 
0357     &sensor_dev_attr_in1_input.dev_attr.attr,
0358     &sensor_dev_attr_in1_lcrit.dev_attr.attr,
0359     &sensor_dev_attr_in1_crit.dev_attr.attr,
0360     &sensor_dev_attr_in1_alarm.dev_attr.attr,
0361 
0362     &sensor_dev_attr_in2_input.dev_attr.attr,
0363     &sensor_dev_attr_in2_lcrit.dev_attr.attr,
0364     &sensor_dev_attr_in2_crit.dev_attr.attr,
0365     &sensor_dev_attr_in2_alarm.dev_attr.attr,
0366 
0367     &sensor_dev_attr_in3_input.dev_attr.attr,
0368     &sensor_dev_attr_in3_lcrit.dev_attr.attr,
0369     &sensor_dev_attr_in3_crit.dev_attr.attr,
0370     &sensor_dev_attr_in3_alarm.dev_attr.attr,
0371 
0372     &sensor_dev_attr_in4_input.dev_attr.attr,
0373     &sensor_dev_attr_in4_lcrit.dev_attr.attr,
0374     &sensor_dev_attr_in4_crit.dev_attr.attr,
0375     &sensor_dev_attr_in4_alarm.dev_attr.attr,
0376 
0377     &sensor_dev_attr_in5_input.dev_attr.attr,
0378     &sensor_dev_attr_in5_lcrit.dev_attr.attr,
0379     &sensor_dev_attr_in5_crit.dev_attr.attr,
0380     &sensor_dev_attr_in5_alarm.dev_attr.attr,
0381 
0382     &sensor_dev_attr_in6_input.dev_attr.attr,
0383     &sensor_dev_attr_in6_lcrit.dev_attr.attr,
0384     &sensor_dev_attr_in6_crit.dev_attr.attr,
0385     &sensor_dev_attr_in6_alarm.dev_attr.attr,
0386 
0387     &sensor_dev_attr_in7_input.dev_attr.attr,
0388     &sensor_dev_attr_in7_lcrit.dev_attr.attr,
0389     &sensor_dev_attr_in7_crit.dev_attr.attr,
0390     &sensor_dev_attr_in7_alarm.dev_attr.attr,
0391 
0392     &sensor_dev_attr_in8_input.dev_attr.attr,
0393     &sensor_dev_attr_in8_lcrit.dev_attr.attr,
0394     &sensor_dev_attr_in8_crit.dev_attr.attr,
0395     &sensor_dev_attr_in8_alarm.dev_attr.attr,
0396 
0397     &sensor_dev_attr_in9_input.dev_attr.attr,
0398     &sensor_dev_attr_in9_lcrit.dev_attr.attr,
0399     &sensor_dev_attr_in9_crit.dev_attr.attr,
0400     &sensor_dev_attr_in9_alarm.dev_attr.attr,
0401 
0402     &sensor_dev_attr_in10_input.dev_attr.attr,
0403     &sensor_dev_attr_in10_lcrit.dev_attr.attr,
0404     &sensor_dev_attr_in10_crit.dev_attr.attr,
0405     &sensor_dev_attr_in10_alarm.dev_attr.attr,
0406 
0407     &sensor_dev_attr_in11_input.dev_attr.attr,
0408     &sensor_dev_attr_in11_lcrit.dev_attr.attr,
0409     &sensor_dev_attr_in11_crit.dev_attr.attr,
0410     &sensor_dev_attr_in11_alarm.dev_attr.attr,
0411 
0412     NULL
0413 };
0414 
0415 static struct attribute *max16065_current_attributes[] = {
0416     &sensor_dev_attr_in12_input.dev_attr.attr,
0417     &sensor_dev_attr_curr1_input.dev_attr.attr,
0418     &sensor_dev_attr_curr1_alarm.dev_attr.attr,
0419     NULL
0420 };
0421 
0422 static struct attribute *max16065_min_attributes[] = {
0423     &sensor_dev_attr_in0_min.dev_attr.attr,
0424     &sensor_dev_attr_in1_min.dev_attr.attr,
0425     &sensor_dev_attr_in2_min.dev_attr.attr,
0426     &sensor_dev_attr_in3_min.dev_attr.attr,
0427     &sensor_dev_attr_in4_min.dev_attr.attr,
0428     &sensor_dev_attr_in5_min.dev_attr.attr,
0429     &sensor_dev_attr_in6_min.dev_attr.attr,
0430     &sensor_dev_attr_in7_min.dev_attr.attr,
0431     &sensor_dev_attr_in8_min.dev_attr.attr,
0432     &sensor_dev_attr_in9_min.dev_attr.attr,
0433     &sensor_dev_attr_in10_min.dev_attr.attr,
0434     &sensor_dev_attr_in11_min.dev_attr.attr,
0435     NULL
0436 };
0437 
0438 static struct attribute *max16065_max_attributes[] = {
0439     &sensor_dev_attr_in0_max.dev_attr.attr,
0440     &sensor_dev_attr_in1_max.dev_attr.attr,
0441     &sensor_dev_attr_in2_max.dev_attr.attr,
0442     &sensor_dev_attr_in3_max.dev_attr.attr,
0443     &sensor_dev_attr_in4_max.dev_attr.attr,
0444     &sensor_dev_attr_in5_max.dev_attr.attr,
0445     &sensor_dev_attr_in6_max.dev_attr.attr,
0446     &sensor_dev_attr_in7_max.dev_attr.attr,
0447     &sensor_dev_attr_in8_max.dev_attr.attr,
0448     &sensor_dev_attr_in9_max.dev_attr.attr,
0449     &sensor_dev_attr_in10_max.dev_attr.attr,
0450     &sensor_dev_attr_in11_max.dev_attr.attr,
0451     NULL
0452 };
0453 
0454 static umode_t max16065_basic_is_visible(struct kobject *kobj,
0455                      struct attribute *a, int n)
0456 {
0457     struct device *dev = kobj_to_dev(kobj);
0458     struct max16065_data *data = dev_get_drvdata(dev);
0459     int index = n / 4;
0460 
0461     if (index >= data->num_adc || !data->range[index])
0462         return 0;
0463     return a->mode;
0464 }
0465 
0466 static umode_t max16065_secondary_is_visible(struct kobject *kobj,
0467                          struct attribute *a, int index)
0468 {
0469     struct device *dev = kobj_to_dev(kobj);
0470     struct max16065_data *data = dev_get_drvdata(dev);
0471 
0472     if (index >= data->num_adc)
0473         return 0;
0474     return a->mode;
0475 }
0476 
0477 static const struct attribute_group max16065_basic_group = {
0478     .attrs = max16065_basic_attributes,
0479     .is_visible = max16065_basic_is_visible,
0480 };
0481 
0482 static const struct attribute_group max16065_current_group = {
0483     .attrs = max16065_current_attributes,
0484 };
0485 
0486 static const struct attribute_group max16065_min_group = {
0487     .attrs = max16065_min_attributes,
0488     .is_visible = max16065_secondary_is_visible,
0489 };
0490 
0491 static const struct attribute_group max16065_max_group = {
0492     .attrs = max16065_max_attributes,
0493     .is_visible = max16065_secondary_is_visible,
0494 };
0495 
0496 static const struct i2c_device_id max16065_id[];
0497 
0498 static int max16065_probe(struct i2c_client *client)
0499 {
0500     struct i2c_adapter *adapter = client->adapter;
0501     struct max16065_data *data;
0502     struct device *dev = &client->dev;
0503     struct device *hwmon_dev;
0504     int i, j, val;
0505     bool have_secondary;        /* true if chip has secondary limits */
0506     bool secondary_is_max = false;  /* secondary limits reflect max */
0507     int groups = 0;
0508     const struct i2c_device_id *id = i2c_match_id(max16065_id, client);
0509 
0510     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
0511                      | I2C_FUNC_SMBUS_READ_WORD_DATA))
0512         return -ENODEV;
0513 
0514     data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
0515     if (unlikely(!data))
0516         return -ENOMEM;
0517 
0518     data->client = client;
0519     mutex_init(&data->update_lock);
0520 
0521     data->num_adc = max16065_num_adc[id->driver_data];
0522     data->have_current = max16065_have_current[id->driver_data];
0523     have_secondary = max16065_have_secondary[id->driver_data];
0524 
0525     if (have_secondary) {
0526         val = i2c_smbus_read_byte_data(client, MAX16065_SW_ENABLE);
0527         if (unlikely(val < 0))
0528             return val;
0529         secondary_is_max = val & MAX16065_WARNING_OV;
0530     }
0531 
0532     /* Read scale registers, convert to range */
0533     for (i = 0; i < DIV_ROUND_UP(data->num_adc, 4); i++) {
0534         val = i2c_smbus_read_byte_data(client, MAX16065_SCALE(i));
0535         if (unlikely(val < 0))
0536             return val;
0537         for (j = 0; j < 4 && i * 4 + j < data->num_adc; j++) {
0538             data->range[i * 4 + j] =
0539               max16065_adc_range[(val >> (j * 2)) & 0x3];
0540         }
0541     }
0542 
0543     /* Read limits */
0544     for (i = 0; i < MAX16065_NUM_LIMIT; i++) {
0545         if (i == 0 && !have_secondary)
0546             continue;
0547 
0548         for (j = 0; j < data->num_adc; j++) {
0549             val = i2c_smbus_read_byte_data(client,
0550                                MAX16065_LIMIT(i, j));
0551             if (unlikely(val < 0))
0552                 return val;
0553             data->limit[i][j] = LIMIT_TO_MV(val, data->range[j]);
0554         }
0555     }
0556 
0557     /* sysfs hooks */
0558     data->groups[groups++] = &max16065_basic_group;
0559     if (have_secondary)
0560         data->groups[groups++] = secondary_is_max ?
0561             &max16065_max_group : &max16065_min_group;
0562 
0563     if (data->have_current) {
0564         val = i2c_smbus_read_byte_data(client, MAX16065_CURR_CONTROL);
0565         if (unlikely(val < 0))
0566             return val;
0567         if (val & MAX16065_CURR_ENABLE) {
0568             /*
0569              * Current gain is 6, 12, 24, 48 based on values in
0570              * bit 2,3.
0571              */
0572             data->curr_gain = 6 << ((val >> 2) & 0x03);
0573             data->range[MAX16065_NUM_ADC]
0574               = max16065_csp_adc_range[(val >> 1) & 0x01];
0575             data->groups[groups++] = &max16065_current_group;
0576         } else {
0577             data->have_current = false;
0578         }
0579     }
0580 
0581     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
0582                                data, data->groups);
0583     return PTR_ERR_OR_ZERO(hwmon_dev);
0584 }
0585 
0586 static const struct i2c_device_id max16065_id[] = {
0587     { "max16065", max16065 },
0588     { "max16066", max16066 },
0589     { "max16067", max16067 },
0590     { "max16068", max16068 },
0591     { "max16070", max16070 },
0592     { "max16071", max16071 },
0593     { }
0594 };
0595 
0596 MODULE_DEVICE_TABLE(i2c, max16065_id);
0597 
0598 /* This is the driver that will be inserted */
0599 static struct i2c_driver max16065_driver = {
0600     .driver = {
0601         .name = "max16065",
0602     },
0603     .probe_new = max16065_probe,
0604     .id_table = max16065_id,
0605 };
0606 
0607 module_i2c_driver(max16065_driver);
0608 
0609 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
0610 MODULE_DESCRIPTION("MAX16065 driver");
0611 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!