619 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Driver for4 * Maxim MAX16065/MAX16066 12-Channel/8-Channel, Flash-Configurable5 * System Managers with Nonvolatile Fault Registers6 * Maxim MAX16067/MAX16068 6-Channel, Flash-Configurable System Managers7 * with Nonvolatile Fault Registers8 * Maxim MAX16070/MAX16071 12-Channel/8-Channel, Flash-Configurable System9 * Monitors with Nonvolatile Fault Registers10 *11 * Copyright (C) 2011 Ericsson AB.12 */13 14#include <linux/kernel.h>15#include <linux/module.h>16#include <linux/init.h>17#include <linux/err.h>18#include <linux/slab.h>19#include <linux/i2c.h>20#include <linux/hwmon.h>21#include <linux/hwmon-sysfs.h>22#include <linux/jiffies.h>23 24enum chips { max16065, max16066, max16067, max16068, max16070, max16071 };25 26/*27 * Registers28 */29#define MAX16065_ADC(x) ((x) * 2)30 31#define MAX16065_CURR_SENSE 0x1832#define MAX16065_CSP_ADC 0x1933#define MAX16065_FAULT(x) (0x1b + (x))34#define MAX16065_SCALE(x) (0x43 + (x))35#define MAX16065_CURR_CONTROL 0x4736#define MAX16065_LIMIT(l, x) (0x48 + (l) + (x) * 3) /*37 * l: limit38 * 0: min/max39 * 1: crit40 * 2: lcrit41 * x: ADC index42 */43 44#define MAX16065_SW_ENABLE 0x7345 46#define MAX16065_WARNING_OV (1 << 3) /* Set if secondary threshold is OV47 warning */48 49#define MAX16065_CURR_ENABLE (1 << 0)50 51#define MAX16065_NUM_LIMIT 352#define MAX16065_NUM_ADC 12 /* maximum number of ADC channels */53 54static const int max16065_num_adc[] = {55 [max16065] = 12,56 [max16066] = 8,57 [max16067] = 6,58 [max16068] = 6,59 [max16070] = 12,60 [max16071] = 8,61};62 63static const bool max16065_have_secondary[] = {64 [max16065] = true,65 [max16066] = true,66 [max16067] = false,67 [max16068] = false,68 [max16070] = true,69 [max16071] = true,70};71 72static const bool max16065_have_current[] = {73 [max16065] = true,74 [max16066] = true,75 [max16067] = false,76 [max16068] = false,77 [max16070] = true,78 [max16071] = true,79};80 81struct max16065_data {82 enum chips chip;83 struct i2c_client *client;84 const struct attribute_group *groups[4];85 struct mutex update_lock;86 bool valid;87 unsigned long last_updated; /* in jiffies */88 int num_adc;89 bool have_current;90 int curr_gain;91 /* limits are in mV */92 int limit[MAX16065_NUM_LIMIT][MAX16065_NUM_ADC];93 int range[MAX16065_NUM_ADC + 1];/* voltage range */94 int adc[MAX16065_NUM_ADC + 1]; /* adc values (raw) including csp_adc */95 int curr_sense;96 int fault[2];97};98 99static const int max16065_adc_range[] = { 5560, 2780, 1390, 0 };100static const int max16065_csp_adc_range[] = { 7000, 14000 };101 102/* ADC registers have 10 bit resolution. */103static inline int ADC_TO_MV(int adc, int range)104{105 return (adc * range) / 1024;106}107 108/*109 * Limit registers have 8 bit resolution and match upper 8 bits of ADC110 * registers.111 */112static inline int LIMIT_TO_MV(int limit, int range)113{114 return limit * range / 256;115}116 117static inline int MV_TO_LIMIT(unsigned long mv, int range)118{119 mv = clamp_val(mv, 0, ULONG_MAX / 256);120 return DIV_ROUND_CLOSEST(clamp_val(mv * 256, 0, range * 255), range);121}122 123static inline int ADC_TO_CURR(int adc, int gain)124{125 return adc * 1400000 / (gain * 255);126}127 128/*129 * max16065_read_adc()130 *131 * Read 16 bit value from <reg>, <reg+1>.132 * Upper 8 bits are in <reg>, lower 2 bits are in bits 7:6 of <reg+1>.133 */134static int max16065_read_adc(struct i2c_client *client, int reg)135{136 int rv;137 138 rv = i2c_smbus_read_word_swapped(client, reg);139 if (unlikely(rv < 0))140 return rv;141 return rv >> 6;142}143 144static struct max16065_data *max16065_update_device(struct device *dev)145{146 struct max16065_data *data = dev_get_drvdata(dev);147 struct i2c_client *client = data->client;148 149 mutex_lock(&data->update_lock);150 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {151 int i;152 153 for (i = 0; i < data->num_adc; i++)154 data->adc[i]155 = max16065_read_adc(client, MAX16065_ADC(i));156 157 if (data->have_current) {158 data->adc[MAX16065_NUM_ADC]159 = max16065_read_adc(client, MAX16065_CSP_ADC);160 data->curr_sense161 = i2c_smbus_read_byte_data(client,162 MAX16065_CURR_SENSE);163 }164 165 for (i = 0; i < 2; i++)166 data->fault[i]167 = i2c_smbus_read_byte_data(client, MAX16065_FAULT(i));168 169 /*170 * MAX16067 and MAX16068 have separate undervoltage and171 * overvoltage alarm bits. Squash them together.172 */173 if (data->chip == max16067 || data->chip == max16068)174 data->fault[0] |= data->fault[1];175 176 data->last_updated = jiffies;177 data->valid = true;178 }179 mutex_unlock(&data->update_lock);180 return data;181}182 183static ssize_t max16065_alarm_show(struct device *dev,184 struct device_attribute *da, char *buf)185{186 struct sensor_device_attribute_2 *attr2 = to_sensor_dev_attr_2(da);187 struct max16065_data *data = max16065_update_device(dev);188 int val = data->fault[attr2->nr];189 190 if (val < 0)191 return val;192 193 val &= (1 << attr2->index);194 if (val)195 i2c_smbus_write_byte_data(data->client,196 MAX16065_FAULT(attr2->nr), val);197 198 return sysfs_emit(buf, "%d\n", !!val);199}200 201static ssize_t max16065_input_show(struct device *dev,202 struct device_attribute *da, char *buf)203{204 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);205 struct max16065_data *data = max16065_update_device(dev);206 int adc = data->adc[attr->index];207 208 if (unlikely(adc < 0))209 return adc;210 211 return sysfs_emit(buf, "%d\n",212 ADC_TO_MV(adc, data->range[attr->index]));213}214 215static ssize_t max16065_current_show(struct device *dev,216 struct device_attribute *da, char *buf)217{218 struct max16065_data *data = max16065_update_device(dev);219 220 if (unlikely(data->curr_sense < 0))221 return data->curr_sense;222 223 return sysfs_emit(buf, "%d\n",224 ADC_TO_CURR(data->curr_sense, data->curr_gain));225}226 227static ssize_t max16065_limit_store(struct device *dev,228 struct device_attribute *da,229 const char *buf, size_t count)230{231 struct sensor_device_attribute_2 *attr2 = to_sensor_dev_attr_2(da);232 struct max16065_data *data = dev_get_drvdata(dev);233 unsigned long val;234 int err;235 int limit;236 237 err = kstrtoul(buf, 10, &val);238 if (unlikely(err < 0))239 return err;240 241 limit = MV_TO_LIMIT(val, data->range[attr2->index]);242 243 mutex_lock(&data->update_lock);244 data->limit[attr2->nr][attr2->index]245 = LIMIT_TO_MV(limit, data->range[attr2->index]);246 i2c_smbus_write_byte_data(data->client,247 MAX16065_LIMIT(attr2->nr, attr2->index),248 limit);249 mutex_unlock(&data->update_lock);250 251 return count;252}253 254static ssize_t max16065_limit_show(struct device *dev,255 struct device_attribute *da, char *buf)256{257 struct sensor_device_attribute_2 *attr2 = to_sensor_dev_attr_2(da);258 struct max16065_data *data = dev_get_drvdata(dev);259 260 return sysfs_emit(buf, "%d\n",261 data->limit[attr2->nr][attr2->index]);262}263 264/* Construct a sensor_device_attribute structure for each register */265 266/* Input voltages */267static SENSOR_DEVICE_ATTR_RO(in0_input, max16065_input, 0);268static SENSOR_DEVICE_ATTR_RO(in1_input, max16065_input, 1);269static SENSOR_DEVICE_ATTR_RO(in2_input, max16065_input, 2);270static SENSOR_DEVICE_ATTR_RO(in3_input, max16065_input, 3);271static SENSOR_DEVICE_ATTR_RO(in4_input, max16065_input, 4);272static SENSOR_DEVICE_ATTR_RO(in5_input, max16065_input, 5);273static SENSOR_DEVICE_ATTR_RO(in6_input, max16065_input, 6);274static SENSOR_DEVICE_ATTR_RO(in7_input, max16065_input, 7);275static SENSOR_DEVICE_ATTR_RO(in8_input, max16065_input, 8);276static SENSOR_DEVICE_ATTR_RO(in9_input, max16065_input, 9);277static SENSOR_DEVICE_ATTR_RO(in10_input, max16065_input, 10);278static SENSOR_DEVICE_ATTR_RO(in11_input, max16065_input, 11);279static SENSOR_DEVICE_ATTR_RO(in12_input, max16065_input, 12);280 281/* Input voltages lcrit */282static SENSOR_DEVICE_ATTR_2_RW(in0_lcrit, max16065_limit, 2, 0);283static SENSOR_DEVICE_ATTR_2_RW(in1_lcrit, max16065_limit, 2, 1);284static SENSOR_DEVICE_ATTR_2_RW(in2_lcrit, max16065_limit, 2, 2);285static SENSOR_DEVICE_ATTR_2_RW(in3_lcrit, max16065_limit, 2, 3);286static SENSOR_DEVICE_ATTR_2_RW(in4_lcrit, max16065_limit, 2, 4);287static SENSOR_DEVICE_ATTR_2_RW(in5_lcrit, max16065_limit, 2, 5);288static SENSOR_DEVICE_ATTR_2_RW(in6_lcrit, max16065_limit, 2, 6);289static SENSOR_DEVICE_ATTR_2_RW(in7_lcrit, max16065_limit, 2, 7);290static SENSOR_DEVICE_ATTR_2_RW(in8_lcrit, max16065_limit, 2, 8);291static SENSOR_DEVICE_ATTR_2_RW(in9_lcrit, max16065_limit, 2, 9);292static SENSOR_DEVICE_ATTR_2_RW(in10_lcrit, max16065_limit, 2, 10);293static SENSOR_DEVICE_ATTR_2_RW(in11_lcrit, max16065_limit, 2, 11);294 295/* Input voltages crit */296static SENSOR_DEVICE_ATTR_2_RW(in0_crit, max16065_limit, 1, 0);297static SENSOR_DEVICE_ATTR_2_RW(in1_crit, max16065_limit, 1, 1);298static SENSOR_DEVICE_ATTR_2_RW(in2_crit, max16065_limit, 1, 2);299static SENSOR_DEVICE_ATTR_2_RW(in3_crit, max16065_limit, 1, 3);300static SENSOR_DEVICE_ATTR_2_RW(in4_crit, max16065_limit, 1, 4);301static SENSOR_DEVICE_ATTR_2_RW(in5_crit, max16065_limit, 1, 5);302static SENSOR_DEVICE_ATTR_2_RW(in6_crit, max16065_limit, 1, 6);303static SENSOR_DEVICE_ATTR_2_RW(in7_crit, max16065_limit, 1, 7);304static SENSOR_DEVICE_ATTR_2_RW(in8_crit, max16065_limit, 1, 8);305static SENSOR_DEVICE_ATTR_2_RW(in9_crit, max16065_limit, 1, 9);306static SENSOR_DEVICE_ATTR_2_RW(in10_crit, max16065_limit, 1, 10);307static SENSOR_DEVICE_ATTR_2_RW(in11_crit, max16065_limit, 1, 11);308 309/* Input voltages min */310static SENSOR_DEVICE_ATTR_2_RW(in0_min, max16065_limit, 0, 0);311static SENSOR_DEVICE_ATTR_2_RW(in1_min, max16065_limit, 0, 1);312static SENSOR_DEVICE_ATTR_2_RW(in2_min, max16065_limit, 0, 2);313static SENSOR_DEVICE_ATTR_2_RW(in3_min, max16065_limit, 0, 3);314static SENSOR_DEVICE_ATTR_2_RW(in4_min, max16065_limit, 0, 4);315static SENSOR_DEVICE_ATTR_2_RW(in5_min, max16065_limit, 0, 5);316static SENSOR_DEVICE_ATTR_2_RW(in6_min, max16065_limit, 0, 6);317static SENSOR_DEVICE_ATTR_2_RW(in7_min, max16065_limit, 0, 7);318static SENSOR_DEVICE_ATTR_2_RW(in8_min, max16065_limit, 0, 8);319static SENSOR_DEVICE_ATTR_2_RW(in9_min, max16065_limit, 0, 9);320static SENSOR_DEVICE_ATTR_2_RW(in10_min, max16065_limit, 0, 10);321static SENSOR_DEVICE_ATTR_2_RW(in11_min, max16065_limit, 0, 11);322 323/* Input voltages max */324static SENSOR_DEVICE_ATTR_2_RW(in0_max, max16065_limit, 0, 0);325static SENSOR_DEVICE_ATTR_2_RW(in1_max, max16065_limit, 0, 1);326static SENSOR_DEVICE_ATTR_2_RW(in2_max, max16065_limit, 0, 2);327static SENSOR_DEVICE_ATTR_2_RW(in3_max, max16065_limit, 0, 3);328static SENSOR_DEVICE_ATTR_2_RW(in4_max, max16065_limit, 0, 4);329static SENSOR_DEVICE_ATTR_2_RW(in5_max, max16065_limit, 0, 5);330static SENSOR_DEVICE_ATTR_2_RW(in6_max, max16065_limit, 0, 6);331static SENSOR_DEVICE_ATTR_2_RW(in7_max, max16065_limit, 0, 7);332static SENSOR_DEVICE_ATTR_2_RW(in8_max, max16065_limit, 0, 8);333static SENSOR_DEVICE_ATTR_2_RW(in9_max, max16065_limit, 0, 9);334static SENSOR_DEVICE_ATTR_2_RW(in10_max, max16065_limit, 0, 10);335static SENSOR_DEVICE_ATTR_2_RW(in11_max, max16065_limit, 0, 11);336 337/* alarms */338static SENSOR_DEVICE_ATTR_2_RO(in0_alarm, max16065_alarm, 0, 0);339static SENSOR_DEVICE_ATTR_2_RO(in1_alarm, max16065_alarm, 0, 1);340static SENSOR_DEVICE_ATTR_2_RO(in2_alarm, max16065_alarm, 0, 2);341static SENSOR_DEVICE_ATTR_2_RO(in3_alarm, max16065_alarm, 0, 3);342static SENSOR_DEVICE_ATTR_2_RO(in4_alarm, max16065_alarm, 0, 4);343static SENSOR_DEVICE_ATTR_2_RO(in5_alarm, max16065_alarm, 0, 5);344static SENSOR_DEVICE_ATTR_2_RO(in6_alarm, max16065_alarm, 0, 6);345static SENSOR_DEVICE_ATTR_2_RO(in7_alarm, max16065_alarm, 0, 7);346static SENSOR_DEVICE_ATTR_2_RO(in8_alarm, max16065_alarm, 1, 0);347static SENSOR_DEVICE_ATTR_2_RO(in9_alarm, max16065_alarm, 1, 1);348static SENSOR_DEVICE_ATTR_2_RO(in10_alarm, max16065_alarm, 1, 2);349static SENSOR_DEVICE_ATTR_2_RO(in11_alarm, max16065_alarm, 1, 3);350 351/* Current and alarm */352static SENSOR_DEVICE_ATTR_RO(curr1_input, max16065_current, 0);353static SENSOR_DEVICE_ATTR_2_RO(curr1_alarm, max16065_alarm, 1, 4);354 355/*356 * Finally, construct an array of pointers to members of the above objects,357 * as required for sysfs_create_group()358 */359static struct attribute *max16065_basic_attributes[] = {360 &sensor_dev_attr_in0_input.dev_attr.attr,361 &sensor_dev_attr_in0_lcrit.dev_attr.attr,362 &sensor_dev_attr_in0_crit.dev_attr.attr,363 &sensor_dev_attr_in0_alarm.dev_attr.attr,364 365 &sensor_dev_attr_in1_input.dev_attr.attr,366 &sensor_dev_attr_in1_lcrit.dev_attr.attr,367 &sensor_dev_attr_in1_crit.dev_attr.attr,368 &sensor_dev_attr_in1_alarm.dev_attr.attr,369 370 &sensor_dev_attr_in2_input.dev_attr.attr,371 &sensor_dev_attr_in2_lcrit.dev_attr.attr,372 &sensor_dev_attr_in2_crit.dev_attr.attr,373 &sensor_dev_attr_in2_alarm.dev_attr.attr,374 375 &sensor_dev_attr_in3_input.dev_attr.attr,376 &sensor_dev_attr_in3_lcrit.dev_attr.attr,377 &sensor_dev_attr_in3_crit.dev_attr.attr,378 &sensor_dev_attr_in3_alarm.dev_attr.attr,379 380 &sensor_dev_attr_in4_input.dev_attr.attr,381 &sensor_dev_attr_in4_lcrit.dev_attr.attr,382 &sensor_dev_attr_in4_crit.dev_attr.attr,383 &sensor_dev_attr_in4_alarm.dev_attr.attr,384 385 &sensor_dev_attr_in5_input.dev_attr.attr,386 &sensor_dev_attr_in5_lcrit.dev_attr.attr,387 &sensor_dev_attr_in5_crit.dev_attr.attr,388 &sensor_dev_attr_in5_alarm.dev_attr.attr,389 390 &sensor_dev_attr_in6_input.dev_attr.attr,391 &sensor_dev_attr_in6_lcrit.dev_attr.attr,392 &sensor_dev_attr_in6_crit.dev_attr.attr,393 &sensor_dev_attr_in6_alarm.dev_attr.attr,394 395 &sensor_dev_attr_in7_input.dev_attr.attr,396 &sensor_dev_attr_in7_lcrit.dev_attr.attr,397 &sensor_dev_attr_in7_crit.dev_attr.attr,398 &sensor_dev_attr_in7_alarm.dev_attr.attr,399 400 &sensor_dev_attr_in8_input.dev_attr.attr,401 &sensor_dev_attr_in8_lcrit.dev_attr.attr,402 &sensor_dev_attr_in8_crit.dev_attr.attr,403 &sensor_dev_attr_in8_alarm.dev_attr.attr,404 405 &sensor_dev_attr_in9_input.dev_attr.attr,406 &sensor_dev_attr_in9_lcrit.dev_attr.attr,407 &sensor_dev_attr_in9_crit.dev_attr.attr,408 &sensor_dev_attr_in9_alarm.dev_attr.attr,409 410 &sensor_dev_attr_in10_input.dev_attr.attr,411 &sensor_dev_attr_in10_lcrit.dev_attr.attr,412 &sensor_dev_attr_in10_crit.dev_attr.attr,413 &sensor_dev_attr_in10_alarm.dev_attr.attr,414 415 &sensor_dev_attr_in11_input.dev_attr.attr,416 &sensor_dev_attr_in11_lcrit.dev_attr.attr,417 &sensor_dev_attr_in11_crit.dev_attr.attr,418 &sensor_dev_attr_in11_alarm.dev_attr.attr,419 420 NULL421};422 423static struct attribute *max16065_current_attributes[] = {424 &sensor_dev_attr_in12_input.dev_attr.attr,425 &sensor_dev_attr_curr1_input.dev_attr.attr,426 &sensor_dev_attr_curr1_alarm.dev_attr.attr,427 NULL428};429 430static struct attribute *max16065_min_attributes[] = {431 &sensor_dev_attr_in0_min.dev_attr.attr,432 &sensor_dev_attr_in1_min.dev_attr.attr,433 &sensor_dev_attr_in2_min.dev_attr.attr,434 &sensor_dev_attr_in3_min.dev_attr.attr,435 &sensor_dev_attr_in4_min.dev_attr.attr,436 &sensor_dev_attr_in5_min.dev_attr.attr,437 &sensor_dev_attr_in6_min.dev_attr.attr,438 &sensor_dev_attr_in7_min.dev_attr.attr,439 &sensor_dev_attr_in8_min.dev_attr.attr,440 &sensor_dev_attr_in9_min.dev_attr.attr,441 &sensor_dev_attr_in10_min.dev_attr.attr,442 &sensor_dev_attr_in11_min.dev_attr.attr,443 NULL444};445 446static struct attribute *max16065_max_attributes[] = {447 &sensor_dev_attr_in0_max.dev_attr.attr,448 &sensor_dev_attr_in1_max.dev_attr.attr,449 &sensor_dev_attr_in2_max.dev_attr.attr,450 &sensor_dev_attr_in3_max.dev_attr.attr,451 &sensor_dev_attr_in4_max.dev_attr.attr,452 &sensor_dev_attr_in5_max.dev_attr.attr,453 &sensor_dev_attr_in6_max.dev_attr.attr,454 &sensor_dev_attr_in7_max.dev_attr.attr,455 &sensor_dev_attr_in8_max.dev_attr.attr,456 &sensor_dev_attr_in9_max.dev_attr.attr,457 &sensor_dev_attr_in10_max.dev_attr.attr,458 &sensor_dev_attr_in11_max.dev_attr.attr,459 NULL460};461 462static umode_t max16065_basic_is_visible(struct kobject *kobj,463 struct attribute *a, int n)464{465 struct device *dev = kobj_to_dev(kobj);466 struct max16065_data *data = dev_get_drvdata(dev);467 int index = n / 4;468 469 if (index >= data->num_adc || !data->range[index])470 return 0;471 return a->mode;472}473 474static umode_t max16065_secondary_is_visible(struct kobject *kobj,475 struct attribute *a, int index)476{477 struct device *dev = kobj_to_dev(kobj);478 struct max16065_data *data = dev_get_drvdata(dev);479 480 if (index >= data->num_adc)481 return 0;482 return a->mode;483}484 485static const struct attribute_group max16065_basic_group = {486 .attrs = max16065_basic_attributes,487 .is_visible = max16065_basic_is_visible,488};489 490static const struct attribute_group max16065_current_group = {491 .attrs = max16065_current_attributes,492};493 494static const struct attribute_group max16065_min_group = {495 .attrs = max16065_min_attributes,496 .is_visible = max16065_secondary_is_visible,497};498 499static const struct attribute_group max16065_max_group = {500 .attrs = max16065_max_attributes,501 .is_visible = max16065_secondary_is_visible,502};503 504static int max16065_probe(struct i2c_client *client)505{506 struct i2c_adapter *adapter = client->adapter;507 struct max16065_data *data;508 struct device *dev = &client->dev;509 struct device *hwmon_dev;510 int i, j, val;511 bool have_secondary; /* true if chip has secondary limits */512 bool secondary_is_max = false; /* secondary limits reflect max */513 int groups = 0;514 enum chips chip = (uintptr_t)i2c_get_match_data(client);515 516 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA517 | I2C_FUNC_SMBUS_READ_WORD_DATA))518 return -ENODEV;519 520 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);521 if (unlikely(!data))522 return -ENOMEM;523 524 data->chip = chip;525 data->client = client;526 mutex_init(&data->update_lock);527 528 data->num_adc = max16065_num_adc[chip];529 data->have_current = max16065_have_current[chip];530 have_secondary = max16065_have_secondary[chip];531 532 if (have_secondary) {533 val = i2c_smbus_read_byte_data(client, MAX16065_SW_ENABLE);534 if (unlikely(val < 0))535 return val;536 secondary_is_max = val & MAX16065_WARNING_OV;537 }538 539 /* Read scale registers, convert to range */540 for (i = 0; i < DIV_ROUND_UP(data->num_adc, 4); i++) {541 val = i2c_smbus_read_byte_data(client, MAX16065_SCALE(i));542 if (unlikely(val < 0))543 return val;544 for (j = 0; j < 4 && i * 4 + j < data->num_adc; j++) {545 data->range[i * 4 + j] =546 max16065_adc_range[(val >> (j * 2)) & 0x3];547 }548 }549 550 /* Read limits */551 for (i = 0; i < MAX16065_NUM_LIMIT; i++) {552 if (i == 0 && !have_secondary)553 continue;554 555 for (j = 0; j < data->num_adc; j++) {556 val = i2c_smbus_read_byte_data(client,557 MAX16065_LIMIT(i, j));558 if (unlikely(val < 0))559 return val;560 data->limit[i][j] = LIMIT_TO_MV(val, data->range[j]);561 }562 }563 564 /* sysfs hooks */565 data->groups[groups++] = &max16065_basic_group;566 if (have_secondary)567 data->groups[groups++] = secondary_is_max ?568 &max16065_max_group : &max16065_min_group;569 570 if (data->have_current) {571 val = i2c_smbus_read_byte_data(client, MAX16065_CURR_CONTROL);572 if (unlikely(val < 0))573 return val;574 if (val & MAX16065_CURR_ENABLE) {575 /*576 * Current gain is 6, 12, 24, 48 based on values in577 * bit 2,3.578 */579 data->curr_gain = 6 << ((val >> 2) & 0x03);580 data->range[MAX16065_NUM_ADC]581 = max16065_csp_adc_range[(val >> 1) & 0x01];582 data->groups[groups++] = &max16065_current_group;583 } else {584 data->have_current = false;585 }586 }587 588 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,589 data, data->groups);590 return PTR_ERR_OR_ZERO(hwmon_dev);591}592 593static const struct i2c_device_id max16065_id[] = {594 { "max16065", max16065 },595 { "max16066", max16066 },596 { "max16067", max16067 },597 { "max16068", max16068 },598 { "max16070", max16070 },599 { "max16071", max16071 },600 { }601};602 603MODULE_DEVICE_TABLE(i2c, max16065_id);604 605/* This is the driver that will be inserted */606static struct i2c_driver max16065_driver = {607 .driver = {608 .name = "max16065",609 },610 .probe = max16065_probe,611 .id_table = max16065_id,612};613 614module_i2c_driver(max16065_driver);615 616MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");617MODULE_DESCRIPTION("MAX16065 driver");618MODULE_LICENSE("GPL");619