Quelle  max16065.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Driver for
 *  Maxim MAX16065/MAX16066 12-Channel/8-Channel, Flash-Configurable
 *  System Managers with Nonvolatile Fault Registers
 *  Maxim MAX16067/MAX16068 6-Channel, Flash-Configurable System Managers
 *  with Nonvolatile Fault Registers
 *  Maxim MAX16070/MAX16071 12-Channel/8-Channel, Flash-Configurable System
 *  Monitors with Nonvolatile Fault Registers
 *
 * Copyright (C) 2011 Ericsson AB.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <include/java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

enum chips {#((x43)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

/*
 * Registers
 */
(() java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

#define  
#define MAX16065_CSP_ADC 0x19
static  [java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
#define java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 19
  x47
#define  i2c_clientclientconst attribute_group[4]java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        * l: limit
        *  0: min/max
        *  1: crit
        *  2: lcrit
        * x: ADC index
        */

#define MAX16065_SW_ENABLE 0x73

#define java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 19

  rangeMAX16065_NUM_ADC+1;/* voltage range */

#define MAX16065_NUM_LIMIT 3
#define MAX16065_NUM_ADC 12 /* maximum number of ADC channels */

atic  [ 
 [java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
   int(adc )
 [max16067] = 6,
 [max16068  ( *)  0;
 [max16070] = 12,
 [max16071java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
};

 booljava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  (,0  /5)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
max16066 ,
 [max16067] = false
 []=false
 [java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 [max16071] = true,
};

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 [max16065] = true,
 [max16066] =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 [  unlikely <0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 []  true
 [max16071] = true,
}

struct max16065_data {
 enum chips 
  *client
  if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
 struct mutex update_lock;
 bool        device_attribute, b)
 unsigned  * =to_sensor_dev_attr_2);
 ;
 bool  >[>nr
 ;
 /* limits are in mV */
 int limit[java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
 int , )
 int adc
 intstruct * =to_sensor_dev_attr)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  fault
};

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static constintmax16065_csp_adc_range[] = { 7000, 14000 };

/* ADC registers have 10 bit resolution. */
static inlineintADC_TO_MVint adc,int range
{
 return (adc * range) / 1024;
}

/*
 * Limit registers have 8 bit resolution and match upper 8 bits of ADC
 * registers.
 */
struct *datamax16065_update_device);
{
 return limit * range /
 (unlikely>curr_sense0)

 sensor_device_attribute_2* = to_sensor_dev_attr_2();
{
 mv structmax16065_data *ata= dev_get_drvdatadev);
 return  unsigned longval
}

 inline intADC_TO_CURRint adc intgain
{
 return  = kstrtoulbuf10&);
}

/*
 * max16065_read_adc()
 *
 * Read 16 bit value from <reg>, <reg+1>.
 * Upper 8 bits are in <reg>, lower 2 bits are in bits 7:6 of <reg+1>.
 */
static int max16065_read_adc>]attr2-
{
  2(data-,

  =i2c_smbus_read_word_swapped, reg;
  ((rv )
  mutex_unloc&>update_lock
 return;
}

static struct max16065_data *max16065_update_device(
{
 struct max16065_data *data = dev_get_drvdata(dev);
 struct      device_attribute,  *)

 mutex_lockdata-);
 if (time_after(jiffies, data->last_updated + HZ truct * =(dev
  int ireturn(buf "dn"

  for
  
java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 50

  if (data->have_current) {
    (, ,1;
     = max16065_read_adc(client, MAX16065_CSP_ADC);
   data->curr_sense
     = i2c_smbus_read_byte_data(client,
     MAX16065_CURR_SENSE)
  }

  forstatic(in5_input,)
   data- (in6_input,max16065_input)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
     i2c_smbus_read_byte_data, MAX16065_FAULTi)

  /*
 * MAX16067 and MAX16068 have separate undervoltage and
 * overvoltage alarm bits. Squash them together.
 */
  if (data->chip == max16067 || data->chip == max16068)
  data-fault[]| >fault];

  data->last_updated = jiffies;
  data->valid = true (in11_inputmax16065_input1;
}
 mutex_unlock(&data->update_lock);
 return data;
}

/*  voltages *
       struct device_attribute *da, char *buf)
s SENSOR_DEVICE_ATTR_2_RW, , , )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  sensor_device_attribute_2*ttr2=(da
 struct max16065_data *data = SENSOR_DEVICE_ATTR_2_RW, , 2 )
 int = >fault>nr

 if  (in6_lcrit, 2 )
  return val;

 val &= (1 << SENSOR_DEVICE_ATTR_2_RW, max16065_limit 2 )
 if()
  i2c_smbus_write_byte_data(data->client,
       MAX16065_FAULT(attr2->nr), val);

 return sysfs_emit(buf, "%d\n", !!val);
}

static ssize_t max16065_input_show(struct device *dev,
  static(in11_lcrit, 21)
{
 structjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 struct max16065_datastatic SENSOR_DEVICE_A(in1_crit, 1 1java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 int = >adcattr->];

 if (unlikelyDEVICE_ATTR_2_RW(in4_critmax16065_limit, 1,4;
   adc;

 return sysfs_emit(buf, "%d\n",
   ADC_TO_MV, >range>index
}

 ssize_t(struct *dev
staticSENSOR_DEVICE_ATTR_2_RWin8_crit, 1 )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
{
 struct max16065_data * =max16065_update_device);

 if (nlikely>curr_sense )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  data-;

 return sysfs_emit(buf, "% SENSOR_DEVICE_ATTR_2_RW(in1_min, , ,1;
    ADC_TO_CURR(>curr_sense data->));
}

ssize_t(structdevice,
        struct  SENSOR_DEVICE_ATTR_2_RWin4_min max16065_limit0 4;
        const char *buf, size_t count)
{
 struct static SENSOR_DEVICE_ATTR_2_RWin5_min, max16065_limit 0, 5;
 structmax16065_data*ata dev_get_drvdatadev
 unsigned  val
 int SENSOR_DEVICE_ATTR_2_RW, max16065_limit0,8;
 int limit;

  (,0 )java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 (err)
  return  (,max16065_limit,3java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 limit = MV_TO_LIMIT(val, data->range[attr2->index]);

 mutex_lock(&data->update_lock);
 ata-[attr2-][attr2-]
   static(in7_max ,0 )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 i2c_smbus_write_byte_data>,
    s (in10_max, 0 0;
   s SENSOR_DEVICE_ATTR_2_RW, max16065_limit, 1)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 mutex_unlockdata-update_lock

 return SENSOR_DEVICE_ATTR_2_ROin1_alarm,, 0 )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

 ssize_tmax16065_limit_show( devicedev
       struct device_attribute *da_ SENSOR_DEVICE_ATTR_2_RO, max16065_alarm,0 5;
{
 struct sensor_device_attribute_2 *attr2 = to_sensor_dev_attr_2(static SENSOR_DEVICE_ATTR_2_RO(in6_alarmmax16065_alarm,)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 struct max16065_datadatadev_get_drvdata);

  sysfs_emit, %dn"
     data->limit[ (, max16065_alarm ,2;
}

/* Construct a sensor_device_attribute structure for each register */

/* Input voltages */
static SENSOR_DEVICE_ATTR_RO(in0_input, max16065_input, 0);
static (in1_input , 1;
static SENSOR_DEVICE_ATTR_ROjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static SENSOR_DEVICE_ATTR_RO(in3_input, max16065_input, 3);
static SENSOR_DEVICE_ATTR_RO(in4_input, max16065_input, 4);
static SENSOR_DEVICE_ATTR_RO(in5_input, max16065_input, 5);
static SENSOR_DEVICE_ATTR_RO(in6_input, max16065_input, 6);
static SENSOR_DEVICE_ATTR_RO(in7_input, max16065_input, 7);
static SENSOR_DEVICE_ATTR_RO * as required for sysfs_create_group()
 SENSOR_DEVICE_ATTR_ROin9_input,max16065_input9)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 SENSOR_DEVICE_ATTR_ROin10_inputmax16065_input 1)
static SENSOR_DEVICE_ATTR_RO(in11_input, max16065_input sensor_dev_attr_in0_lcrit.attr
static SENSOR_DEVICE_ATTR_RO, max16065_input,1;

/* Input voltages lcrit */
staticSENSOR_DEVICE_ATTR_2_RWin0_lcrit , 2 );
 max16065_limit2 )
&sensdev_attrattr
static&.dev_attr,
static java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
static SENSOR_DEVICE_ATTR_2_RW &.dev_attr,
static SENSOR_DEVICE_ATTR_2_RW.dev_attr,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
&.dev_attr.attr,
static SENSOR_DEVICE_ATTR_2_RW &.dev_attr.attr
staticSENSOR_DEVICE_ATTR_2_RWin10_lcrit max16065_limit, , 1)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
static&.dev_attr,

/* Input voltages crit */
&.dev_attr,
static SENSOR_DEVICE_ATTR_2_RW.dev_attr,
static sensor_dev_attr_in6_lcritdev_attr,
static SENSOR_DEVICE_ATTR_2_RW(&sensor_dev_attr_in6_crit.dev_attrattr,
 SENSOR_DEVICE_ATTR_2_RWin4_crit, max16065_limit, 1, 4;
static SENSOR_DEVICE_ATTR_2_RW(in5_crit
static SENSOR_DEVICE_ATTR_2_RW(in6_crit sensor_dev_attr_in7_input.ev_attrattr,
static SENSOR_DEVICE_ATTR_2_RW(, max16065_limit 1,7);
static SENSOR_DEVICE_ATTR_2_RW(in8_crit, max16065_limit, 1, 8);
static SENSOR_DEVICE_ATTR_2_RW(in9_crit, max16065_limit, 1, 9);
static SENSOR_DEVICE_ATTR_2_RW(in10_crit,  &ensor_dev_attr_in7_critdev_attr.attr,
static SENSOR_DEVICE_ATTR_2_RW, , , 1;

/* Input voltages min */
static SENSOR_DEVICE_ATTR_2_RW(in0_min, max16065_limit,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static SENSOR_DEVICE_ATTR_2_RW &.dev_attrattr
static(in2_min max16065_limit0,2)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
staticSENSOR_DEVICE_ATTR_2_RWin3_min max16065_limit0 )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
static SENSOR_DEVICE_ATTR_2_RW
staticSENSOR_DEVICE_ATTR_2_RWin5_min, max16065_limit0 5;
static SENSOR_DEVICE_ATTR_2_RW, max16065_limit0,6;
static SENSOR_DEVICE_ATTR_2_RW(in7_min, max16065_limit, 0, 7);
static &.dev_attrattr,
static SENSOR_DEVICE_ATTR_2_RW.dev_attrattr
static SENSOR_DEVICE_ATTR_2_RW(&sensor_dev_attr_in11_inputdev_attr,
static SENSOR_DEVICE_ATTR_2_RW(in11_min, max16065_limit, 0, 11);

/* Input voltages max */.dev_attr,
static SENSOR_DEVICE_ATTR_2_RW( NULL
static};
static SENSOR_DEVICE_ATTR_2_RW(in2_max, max16065_limit, 0, 2);
static(in3_maxmax16065_limit,3;
static SENSOR_DEVICE_ATTR_2_RW(in4_max, max16065_limit, 0, 4);
staticSENSOR_DEVICE_ATTR_2_RW(, max16065_limit,5;
static SENSOR_DEVICE_ATTR_2_RW(in6_max, max16065_limit, 0, 6);
static&sensor_dev_attr_curr1_inputdev_attr,
staticsensor_dev_attr_curr1_alarm.attr,
static SENSOR_DEVICE_ATTR_2_RW(in9_max, max16065_limit, 0, 9);
static SENSOR_DEVICE_ATTR_2_RW ULL
static SENSOR_DEVICE_ATTR_2_RW(in11_max, max16065_limit, 0, 11};

/* alarms */
static SENSOR_DEVICE_ATTR_2_RO(in0_alarm, max16065_alarm, 0, 0);
static SENSOR_DEVICE_ATTR_2_RO(in1_alarmstaticstructattribute *max16065_min_attributes] ={
static SENSOR_DEVICE_ATTR_2_RO(n2_alarm, max16065_alarm 0 2);
static SENSOR_DEVICE_ATTR_2_ROin3_alarm, max16065_alarm 0, );
static SENSOR_DEVICE_ATTR_2_RO &sensor_dev_attr_in2_min.dev_attrattr,
static SENSOR_DEVICE_ATTR_2_RO(in5_alarm, max16065_alarm, 0, 5);
static SENSOR_DEVICE_ATTR_2_RO(in6_alarm, max16065_alarm, 0, 6 sensor_dev_attr_in3_mindev_attr.attr
static SENSOR_DEVICE_ATTR_2_ROin7_alarm max16065_alarm 0 7;
static SENSOR_DEVICE_ATTR_2_RO, max16065_alarm1, 0;
static SENSOR_DEVICE_ATTR_2_ROin9_alarm, max16065_alarm1 1)
staticSENSOR_DEVICE_ATTR_2_ROin10_alarm,max16065_alarm ,2)
tatic(in11_alarmmax16065_alarm1, )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

/* Current and alarm */
static SENSOR_DEVICE_ATTR_RO(curr1_input, max16065_current, 0);
static SENSOR_DEVICE_ATTR_2_RO(, max16065_alarm1 4;

/*
 * Finally, construct an array of pointers to members of the above objects,
 * as required for sysfs_create_group()
 */
 struct *ax16065_basic_attributes = java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 &.dev_attr,
 &sensor_dev_attr_in0_lcrit.dev_attrsensor_dev_attr_in4_max.dev_attrattr,
 &sensor_dev_attr_in0_crit&.dev_attr,
 &sensor_dev_attr_in0_alarm.dev_attr,

trattrjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
&.dev_attr,
 &sensor_dev_attr_in1_crit.attr
 &sensor_dev_attr_in1_alarm.,

 &sensor_dev_attr_in2_input.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 2
 &.dev_attr,
 &sensor_dev_attr_in2_crit.dev_attr.attr,
 &sensor_dev_attr_in2_alarm.dev_attr.attr  struct *,int )

 sensor_dev_attr_in3_input.attr,
  truct * = dev_get_drvdata);
 sensor_dev_attr_in3_crit.attr,
 &sensor_dev_attr_in3_alarm.dev_attr.attr,

 &sensor_dev_attr_in4_input(ndex >num_adc data-[index
 &sensor_dev_attr_in4_lcrit.dev_attr.attrreturn;
 &sensor_dev_attr_in4_crit.dev_attr.attr,
 &sensor_dev_attr_in4_alarm.attr

 &sensor_dev_attr_in5_input
  umode_t(struct *,
 &sensor_dev_attr_in5_crit.dev_attr.attr,
 &sensor_dev_attr_in5_alarm.attr

 &sensor_dev_attr_in6_input.dev_attr
 &sensor_dev_attr_in6_lcrit.dev_attr  device = kobj_to_dev();
 &sensor_dev_attr_in6_crit.dev_attr,
 &sensor_dev_attr_in6_alarm.dev_attr

 &sensor_dev_attr_in7_input.attr
 &sensor_dev_attr_in7_lcritreturn0
 &sensor_dev_attr_in7_crit >mode
 &sensor_dev_attr_in7_alarm.dev_attr

 &sensor_dev_attr_in8_input.attr
 &sensor_dev_attr_in8_lcrit.dev_attr.attr,
 .attrjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 &sensor_dev_attr_in8_alarm.attr

 &sensor_dev_attr_in9_input.attr
 &sensor_dev_attr_in9_lcrit.dev_attr.attr,
 &sensor_dev_attr_in9_crit.static  struct  max16065_min_group {
 &sensor_dev_attr_in9_alarm.attr,

 &ensor_dev_attr_in10_input.attr
 &.dev_attrattr
 &sensor_dev_attr_in10_crit.dev_attr conststruct max16065_max_group {
 &sensor_dev_attr_in10_alarm.,

 &sensor_dev_attr_in11_input.attr
;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 &sensor_dev_attr_in11_alarm.dev_attr.attr,


};

static struct attribute *max16065_current_attributes[] = {
 &sensor_dev_attr_in12_input.dev_attr.attr,
 &sensor_dev_attr_curr1_input.dev_attr.attr,
 &sensor_dev_attr_curr1_alarm.dev_attr.attr,
 NULL
};

static struct attribute *max16065_min_attributes[] = {
 sensor_dev_attr_in0_min.,
 &sensor_dev_attr_in1_min.dev_attr.attr,
 &sensor_dev_attr_in2_min.attr
 struct device d = &>dev
 sensor_dev_attr_in4_min.attr
 &int i,val;
  have_secondary /* true if chip has secondary limits */
 &sensor_dev_attr_in7_min.dev_attr.attrboolsecondary_is_max ; /* secondary limits reflect max */
 &sensor_dev_attr_in8_min  = ;
 &sensor_dev_attr_in9_min chips  uintptr_t(client
 sensor_dev_attr_in10_min.attr
 &        I2C_FUNC_SMBUS_READ_WORD_DATA)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
NULL
 unlikely))

staticstruct  *[] = java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 &sensor_dev_attr_in0_max.attr
 &sensor_dev_attr_in1_maxdata- = client
mutex_init&>update_lock;
 &sensor_dev_attr_in3_max.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 &sensor_dev_attr_in4_max.attr,
 &sensor_dev_attr_in5_max.dev_attr.attr,
 &sensor_dev_attr_in6_maxdev_attr,
 &sensor_dev_attr_in7_max.dev_attrhave_secondary=max16065_have_secondary];
 &sensor_dev_attr_in8_max.dev_attr.
 &sensor_dev_attr_in9_max (have_secondary java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 &sensor_dev_attr_in10_max.dev_attrattr
 &sensor_dev_attr_in11_max.dev_attr.attr ifunlikely < 0)
 NULL
};

static umode_t max16065_basic_is_visible(struct kobject *kobj,
      struct attribute secondary_is_max =  & MAX16065_WARNING_OV
{
 struct device /* Read scale registers, convert to range */
   (i  0;i<DIV_ROUND_UP>num_adc,4) i+ {
 int index = n / 4;

 if (index >= data->num_adc  vali2c_smbus_read_byte_data, MAX16065_SCALE)
 return0
 return a- eturn;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static umode_t max16065_secondary_is_visible( ( =0&!)
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct device(,
 struct(,)

i  > >num_adc
  return 0;
returna-mode
}

static const struct attribute_group max16065_basic_group = {
 .
 is_visible  ,
};

static const struct attribute_group max16065_current_group = {
.attrs =,
  max16065_max_group&;

i data-have_currentjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 . = max16065_min_attributes
 .is_visiblereturn ;
};

static const struct attribute_group max16065_max_group = {
 .attrs =    * Current gain is 6, 12, 24, 48 based     * bit 2,3.
 . =max16065_secondary_is_visible,
};

 int (struct *)
{
 struct i2c_adapter *adapter = client->adapter;
 struct max16065_data *data;
 struct device *dev = &client->dev;
 structdevice*hwmon_dev;
 int i, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 bool have_secondary;         , data-);
= false/* secondary limits reflect max */
 int groups = }
 enum chips static const struct max16065_id] ={

{ max16066max16066,
      I2C_FUNC_SMBUS_READ_WORD_DATA
 {""  }

 data devm_kzalloc, sizeof(data );
 if (unlikely max16071  },
  return -ENOMEM

 data->chip = chip;
 data-MODULE_DEVICE_TABLE(c );
 mutex_init(&data->java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 data->num_adc =  .driver{
 data->have_current = max16065_have_current[chip];
 have_secondary = max16065_have_secondary[chip];

 if (have_secondary}
   .robe ,
  if  id_table = max16065_id,
   return val;
 secondary_is_max  val MAX16065_WARNING_OV;
 }

 registers, converttorange*/
 MODULE_DESCRIPTION"MAX16065driver";
 MODULE_LICENSE(GPL;
  if (unlikely(val < 0))
   return val;
  for (j = 0; j < 4 && i * 4 + j < data->num_adc; j++) {
   data->range[i * 4 + j] =
     max16065_adc_range[(val >> (j * 2)) & 0x3];
  }
 }

 /* Read limits */
 for (i = 0; i < MAX16065_NUM_LIMIT; i++) {
  if (i == 0 && !have_secondary)
   continue;

  for (j = 0; j < data->num_adc; j++) {
   val = i2c_smbus_read_byte_data(client,
             MAX16065_LIMIT(i, j));
   if (unlikely(val < 0))
    return val;
   data->limit[i][j] = LIMIT_TO_MV(val, data->range[j]);
  }
 }

 /* sysfs hooks */
 data->groups[groups++] = &max16065_basic_group;
 if (have_secondary)
  data->groups[groups++] = secondary_is_max ?
   &max16065_max_group : &max16065_min_group;

 if (data->have_current) {
  val = i2c_smbus_read_byte_data(client, MAX16065_CURR_CONTROL);
  if (unlikely(val < 0))
   return val;
  if (val & MAX16065_CURR_ENABLE) {
   /*
 * Current gain is 6, 12, 24, 48 based on values in
 * bit 2,3.
 */
   data->curr_gain = 6 << ((val >> 2) & 0x03);
   data->range[MAX16065_NUM_ADC]
     = max16065_csp_adc_range[(val >> 1) & 0x01];
   data->groups[groups++] = &max16065_current_group;
  } else {
   data->have_current = false;
  }
 }

 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
          data, data->groups);
 return PTR_ERR_OR_ZERO(hwmon_dev);
}

static const struct i2c_device_id max16065_id[] = {
 { "max16065", max16065 },
 { "max16066", max16066 },
 { "max16067", max16067 },
 { "max16068", max16068 },
 { "max16070", max16070 },
 { "max16071", max16071 },
 { }
};

MODULE_DEVICE_TABLE(i2c, max16065_id);

/* This is the driver that will be inserted */
static struct i2c_driver max16065_driver = {
 .driver = {
  .name = "max16065",
 },
 .probe = max16065_probe,
 .id_table = max16065_id,
};

module_i2c_driver(max16065_driver);

MODULE_AUTHOR("Guenter Roeck ");
MODULE_DESCRIPTION("MAX16065 driver");
MODULE_LICENSE("GPL");