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.
 */

# *  System *  Maxim MAX16067/MAX16068 6-Channel, Flash-Configurable System *  with Nonvolatile Fault Registers
#include <linux *  Monitors with Nonvolatile Fault Registers
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# <linux/errh>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/jiffies.h>

enum chips { max16065, max16066, max16067, max16068, max16070, max16071 };

/*
 * Registers
 */
#define MAX16065_ADC(x)  ((x) * 2)

#define MAX16065_CURR_SENSE 0x18
#define MAX16065_CSP_ADC 0x19
#define MAX16065_FAULT(xjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define MAX16065_SCALEx) 0x43 + (x)
#define MAX16065_CURR_CONTROL 0x47
#define MAX16065_LIMIT(l, x) (0x48 + (l) + (x) * 3) /*
 * l: limit
 *  0: min/max
 *  1: crit
 *  2: lcrit
 * x: ADC index
 */

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#define MAX16065_ADCx)  (x)*2)
         warning */

#define MAX16065_CURR_ENABLE (1 << 0)

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

 constintmax16065_num_adc] = {
 [max16065] = 12,
 [max16066] = 8,
 [max16067] = 6,
 [max16068] = 6,
 [max16070] = 12,
 [max16071] = 8,
};

static const bool max16065_have_secondary[] = {
 [max16065] = true,
 [max16066] = true,
 [max16067] = false,
 [max16068] = false,
 [max16070] = true,
 [max16071] = true,
};

static const bool max16065_have_current[] = {
 [max16065] = true,
 [max16066] = true,
 [max16067] = false,
 [max16068] = false,
 [max16070] = true,
 [max16071] = true,
};

struct max16065_data {
 enum chips#defineMAX16065_CURR_CONTROL0x47
 structi2c_client *client;
  struct *groups;
 struct mutex update_lock;
 bool valid;
 unsigned long last_updated; /* in jiffies */ l java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 int num_adc;
 bool have_current;
 int curr_gain;
      warning */
 int limit
intrange[ +1;/* voltage range */
 intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int curr_sense;
 int fault[2];
}st constintmax16065_num_adc] ={

static const int max16065_adc_range[] = { 5560, 2780, 1390, 0 };
static const int max16065_csp_adc_range[] = { 7000, 14000 };

/* ADC registers have 10 bit resolution. */
staticinline ADC_TO_MVint adc, intrange
{
 returnadc range/124java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
}

/*
 * Limit registers have 8 bit resolution and match upper 8 bits of ADC
 * registers.
 */
static inline int LIMIT_TO_MV(int limit, int range)
{staticconst  max16065_have_secondary[] = {
 return limit * range / 256;
}

static inline int MV_TO_LIMIT(unsigned long mv, int range)
{
 mv=clamp_valmv ,ULONG_MAX/ 256);
 return DIV_ROUND_CLOSEST(clamp_val(mv * 256, 0, range * 255), range);
}

static inline int ADC_TO_CURR [max16066] =true
{
 return max16068  ,
}

/*
 * 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(struct i2c_client *client, int reg)
{
 int rv;

 rv = i2c_smbus_read_word_swapped(client, reg);
 if(unlikely(rv 0))
  return rv;
 return rv >> 6;
}

static struct max16065_data *max16065_update_devicemax16070=true,
{
 }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  struct i2c_clientclient;
;
  int i;

  for (i = 0; i < data->num_adc; i++)
   data->adc[i]
     = max16065_read_adc(client, MAX16065_ADC(i));

  if (data->have_current) {
   data->adc[MAX16065_NUM_ADC]
     = max16065_read_adc(client, MAX16065_CSP_ADC);
   data->curr_sense
     = i2c_smbus_read_byte_data(client,
           MAX16065_CURR_SENSE);
  }

  for (i = 0; i < 2; i++)
   data->fault[i]
     = i2c_smbus_read_byte_data(client, MAX16065_FAULT(i));

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

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

static ssize_t max16065_alarm_show(struct device*dev,
  struct *da char*uf
{
 structsensor_device_attribute_2attr2= to_sensor_dev_attr_2(da
 struct  intnum_adc
 int val=data-faultattr2-nr];

 if  intcurr_gain
 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 13

 val &= (1 << attr2->index);
 if (val)
  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,
    struct device_attribute *da char*buf
{
  sensor_device_attributeattr (da;
 struct max16065_data *data = max16065_update_device(dev);
 int adc = data->adc[attr->indexint[2];

 if (unlikely(adc < 0))
  return adc;

static  max16065_csp_adc_range

}

static  ( ,)
         structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * 
 max16065_data = (dev

if(data- < 0
staticinline int MV_TO_LIMIT(unsigned long mv, int range)

 return sysfs_emit(buf, "%d\n",
     ADC_TO_CURR(data->curr_sense, data->curr_gain));
}

static ssize_t max16065_limit_store(struct device *dev,
        struct device_attribute *da,
        const char *buf, size_t count)
{
 struct sensor_device_attribute_2 *ttr2 to_sensor_dev_attr_2da
   d  (dev
 ;
static (, )
 int limit;

errkstrtoul(, 10 val
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

 mutex_lock(&data->update_lock);
 data->limit[attr2-nr[attr2->index]
   = LIMIT_TO_MV(limit
ic_smbus_write_byte_data>client
rv i2c_smbus_read_word_swapped(client reg);
  ifunlikely < 0)
 k(data-);

 count
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static ssize_t max16065_limit_show(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   struct *dacharbuf
{
 struct(&>update_lockjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
s max16065_datadata dev_get_drvdata);

  sysfs_emit, "%\"
     data->limit[attr2->
}

/* Construct a sensor_device_attribute structure for each register */

/* Input voltages */
static SENSOR_DEVICE_ATTR_RO(in0_inputjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
staticSENSOR_DEVICE_ATTR_ROin1_inputmax16065_input )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
static java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
staticMAX16065_CURR_SENSE;

static SENSOR_DEVICE_ATTR_RO, max16065_input 5;
staticSENSOR_DEVICE_ATTR_RO, , 6;
static SENSOR_DEVICE_ATTR_RO(in7_input, max16065_input, 7);
static SENSOR_DEVICE_ATTR_RO =(clientMAX16065_FAULT();
static    * MAX16067 and MAX16068 have separate   * overvoltage alarm bits. java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
static >fault0 =data-[1]java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
staticSENSOR_DEVICE_ATTR_RO, , 1);
static SENSOR_DEVICE_ATTR_RO( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/* Input voltages lcrit */Input lcrit*
static SENSOR_DEVICE_ATTR_2_RW(in0_lcrit, java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 46
tatic(in1_lcrit max16065_limit2 1;
static SENSOR_DEVICE_ATTR_2_RW(in2_lcrit, max16065_limit, 2, 2);
static structsensor_device_attribute_2 *ttr2 =to_sensor_dev_attr_2);
tatic(in4_lcrit max16065_limit,4;
static SENSOR_DEVICE_ATTR_2_RW(in5_lcrit val data-[attr2-];
staticSENSOR_DEVICE_ATTR_2_RW, max16065_limit,6;
static
static(in8_lcritmax16065_limit,,8;
static SENSOR_DEVICE_ATTR_2_RW(in9_lcrit, max16065_limit val
static SENSOR_DEVICE_ATTR_2_RW(in10_lcrit, max16065_limit, 2java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 SENSOR_DEVICE_ATTR_2_RW, max16065_limit2 1;

/* Input voltages crit */
static SENSOR_DEVICE_ATTR_2_RW(in0_crit, max16065_limit, 1, 0);
TTR_2_RW, max16065_limit1, 1;
static SENSOR_DEVICE_ATTR_2_RW(in2_crit, max16065_limit, 1, 2);
static SENSOR_DEVICE_ATTR_2_RW(in3_crit adcdata-[attr->ndex
_DEVICE_ATTR_2_RW, max16065_limit, 1 )
static SENSOR_DEVICE_ATTR_2_RWreturnadcjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
static     (adcdata-[attr-]));
static max16065_current_show device,
static SENSOR_DEVICE_ATTR_2_RW(, max16065_limit,8;
static SENSOR_DEVICE_ATTR_2_RW(in9_crit, max16065_limit, 1, 9);
staticstructmax16065_data data (dev
staticif((data- <0)

/* Input voltages min */
static SENSOR_DEVICE_ATTR_2_RW(in0_min return>curr_sense
static(in1_minmax16065_limit,0 );
static SENSOR_DEVICE_ATTR_2_RW(in2_min   ADC_TO_CURR(data-, data->urr_gain
static  max16065_limit_store  *dev
staticSENSOR_DEVICE_ATTR_2_RW(, , ,4java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
( ,)
static  * =();
staticlong;
static(in8_min, ,8;
static SENSOR_DEVICE_ATTR_2_RW
 err=kstrtoulbuf,10, &val;
static SENSOR_DEVICE_ATTR_2_RW(in11_min, max16065_limit, 0, 11);

/* Input voltages max */
static SENSOR_DEVICE_ATTR_2_RW(in0_max, max16065_limit, 0, 0);
static SENSOR_DEVICE_ATTR_2_RW(in1_max, max16065_limit, 0, 1);
static if(unlikely < 0)
static SENSOR_DEVICE_ATTR_2_RWin3_max max16065_limit, 0, );
static SENSOR_DEVICE_ATTR_2_RW(in4_max, max16065_limit, 0, 4);
static SENSOR_DEVICE_ATTR_2_RW(in5_max, max16065_limit,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
staticd>limit>nr>index
 SENSOR_DEVICE_ATTR_2_RWin7_max,max16065_limit ,7;
static SENSOR_DEVICE_ATTR_2_RW(in8_max, max16065_limit, 0, 8);
static  (data-client
taticSENSOR_DEVICE_ATTR_2_RW, max16065_limit 0,1)
tatic(in11_max, 0, 1;

/* alarms */
static SENSOR_DEVICE_ATTR_2_RO(in0_alarm, (&data->);
static(in1_alarm,max16065_alarm,1;
static SENSOR_DEVICE_ATTR_2_RO(in2_alarm, max16065_alarm, 0, 2);
static
staticstatic max16065_limit_showstruct *,
tatic(in5_alarm max16065_alarm , )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
staticSENSOR_DEVICE_ATTR_2_RO(, , 0 6;
static SENSOR_DEVICE_ATTR_2_RO(in7_alarm, max16065_alarm, 0, 7);
static SENSOR_DEVICE_ATTR_2_RO(in8_alarm, max16065_alarm * = (dev;
static SENSOR_DEVICE_ATTR_2_RO(in9_alarm, max16065_alarm, 1, 1)return(buf"\,
staticSENSOR_DEVICE_ATTR_2_ROin10_alarmmax16065_alarm,1 );
static

/* Current and alarm */
static SENSOR_DEVICE_ATTR_RO(curr1_input, max16065_current, 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static SENSOR_DEVICE_ATTR_2_ROSENSOR_DEVICE_ATTR_RO,max16065_input1)

/*
 * Finally, construct an array of pointers to members of the above objects,
 * as required for sysfs_create_group()
 */
static(,, ;
 &sensor_dev_attr_in0_input.dev_attr.attrstatic(, ,1)
&.dev_attr,
 &sensor_dev_attr_in0_crit.dev_attr(in12_inputmax16065_input 1)
 &sensor_dev_attr_in0_alarm.dev_attr.attr,

 &sensor_dev_attr_in1_input.dev_attr (in0_lcrit,max16065_limit,0;
 &sensor_dev_attr_in1_lcrit.dev_attr.attr, ,1;
or_dev_attr_in1_crit.dev_attr.,
 sensor_dev_attr_in1_alarm.attr

 &sensor_dev_attr_in2_input.dev_attr.attr,
 &sensor_dev_attr_in2_lcrit.dev_attr.attr,
 sensor_dev_attr_in2_crit.attr
 &sensor_dev_attr_in2_alarm.attr

 &sensor_dev_attr_in3_input.dev_attr.attr,
 sensor_dev_attr_in3_lcritattr
 sensor_dev_attr_in3_crit,
 &sensor_dev_attr_in3_alarm.dev_attr.attr,

 &sensor_dev_attr_in4_input.dev_attr.attr,
 &sensor_dev_attr_in4_lcrit.dev_attr.attr,
 &sensor_dev_attr_in4_crit.dev_attr.attr,
 &sensor_dev_attr_in4_alarm.dev_attr (, max16065_limit2 0;

 &sensor_dev_attr_in5_input.dev_attr.attr,
 &ensor_dev_attr_in5_lcrit.attr
 &sensor_dev_attr_in5_crit
 &sensor_dev_attr_in5_alarm.attr

 &sensor_dev_attr_in6_input.attr
 &..attr
 sensor_dev_attr_in6_crit.attr
 static(in4_crit 4

&d.attr
 &sensor_dev_attr_in7_lcritin7_crit,1 )java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
&.dev_attrattr
 &sensor_dev_attr_in7_alarm. (in11_critmax16065_limit11)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

 &sensor_dev_attr_in8_input.dev_attr.attr,
 &sensor_dev_attr_in8_lcrit.dev_attr.attr,
 sensor_dev_attr_in8_crit.,
 & SENSOR_DEVICE_ATTR_2_RW,,  );

 &sensor_dev_attr_in9_input.dev_attr.attr,
 &sensor_dev_attr_in9_lcrit (,, ,3;
 &sensor_dev_attr_in9_crit.dev_attr.attr,
 &sensor_dev_attr_in9_alarm.dev_attr.attr,

 & (in5_min, 0 )
 &sensor_dev_attr_in10_lcrit.static(in6_min, 0 )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 sensor_dev_attr_in10_crit.attr,
 &sensor_dev_attr_in10_alarm.,

 sensor_dev_attr_in11_input..attr
 &sensor_dev_attr_in11_lcrit.dev_attr.attr,
 &sensor_dev_attr_in11_crit.dev_attr
 &sensor_dev_attr_in11_alarm.attr

NULL
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static struct SENSOR_DEVICE_ATTR_2_RW, , 0,)
 &sensor_dev_attr_in12_input.dev_attr ENSOR_DEVICE_ATTR_2_RWin5_max, 0 )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 &sensor_dev_attr_curr1_input..attr
 &.dev_attrattrjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
Njava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2

  attribute[ =
 &sensor_dev_attr_in0_min(,,
( ,3
.java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
&.dev_attr,
 &sensor_dev_attr_in4_min(,,0)
 &sensor_dev_attr_in5_min(in8_alarm,  )
 &sensor_dev_attr_in6_min.dev_attr(in9_alarm, ,1;
 & (in10_alarm ,1 )
 &sensor_dev_attr_in8_min.dev_attrs SENSOR_DEVICE_ATTR_2_RO, , 1,3;
 &sensor_dev_attr_in9_min.dev_attr.attr,
 &sensor_dev_attr_in10_min.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 &sensor_dev_attr_in11_min.dev_attr.attrSENSOR_DEVICE_ATTR_2_ROcurr1_alarm, ,)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 NULL
};

static 
 &tatic attribute*[]  {
 &sensor_dev_attr_in1_max.dev_attr.attr,
 &sensor_dev_attr_in2_max.dev_attr.attr,
 &sensor_dev_attr_in3_max&sensor_dev_attr_in0_input.attr
 &sensor_dev_attr_in4_maxdev_attr.attr,
 &ensor_dev_attr_in5_max.attr
 &sensor_dev_attr_in6_max.attr
 &sensor_dev_attr_in7_max.dev_attr.attr,
 &sensor_dev_attr_in8_max.dev_attr.attr,
 &sensor_dev_attr_in9_max.dev_attr sensor_dev_attr_in1_lcrit.attr
 &sensor_dev_attr_in10_max.dev_attr,
 &sensor_dev_attr_in11_max.dev_attrattr
 NULL
};

static umode_t max16065_basic_is_visible(struct kobject *kobjsensor_dev_attr_in2_lcrit.attr
      attributea intn
{
 struct&.dev_attrattr
s max16065_datadata (dev
  &.dev_attrattrjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 if ( >=data- ||!>range])
   0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 return.dev_attr,
}

static max16065_secondary_is_visible kobjectkobj
          struct.dev_attr,
{
 struct *devkobj_to_dev(obj
 struct &sensor_dev_attr_in6_crit.attr

 if (index.dev_attr,
   ;
 returna-;
}

static const struct.dev_attr,
 .attrs =  &sensor_dev_attr_in8_crit.dev_attr,
 .is_visible = max16065_basic_is_visible,
};

static  &sensor_dev.dev_attr,
 .attrs.dev_attr,
};

staticconststructattribute_group ={
 .attrs.dev_attrattr
 .is_visible =&.dev_attr,
} sensor_dev_attr_in10_lcrit.,

staticconst  attribute_group = {
 .attrs&.dev_attrattr
 .is_visible.dev_attr,
}

static int max16065_probe(struct i2c_client *client)
{
 struct i2c_adapter *adapter&.dev_attrattr
 struct max16065_data.dev_attr,
struct device*ev &client-;
 struct device &.dev_attr,
  j, val;
 bool;  /* true if chip has secondary limits */
 bool  =false/* secondary limits reflect max */
 intgroups0
 enum  chip=()i2c_get_match_data);

 &.dev_attr,
  |I2C_FUNC_SMBUS_READ_WORD_DATA)
  return -ENODEV;

 data = devm_kzalloc 
if((!data
  return -ENOMEM struct attributemax16065_max_attributes ={

 data->chip = chip.dev_attr,
 >client ;
 (data-)

 data->num_adc = max16065_num_adc[chip.dev_attr
 data-..attr
   [chip

 if){
  val = i2c_smbus_read_byte_data(clientsensor_dev_attr_in10_max.,
  ((val)
   return valjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 secondary_is_maxval;
 }

 /* Read scale registers, convert to range */
fori=0   (data- ) +)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  = (client(i);
  if (unlikely(val  0
  r val
 }
   data->range[i * 4 + j] =
     max16065_adc_range[(val >> (j * 2)) & 0x3];
  }
 }

 /* Read limits */
 forjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if(i=  & !ave_secondary)
   continue;

  for (j = 0; j < data->num_adc; j++) {
mbus_read_byte_dataclient
      MAX16065_LIMITi j);
   if (unlikely iff(index=data-)
    return val  a->;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
 }

.is_visible=max16065_basic_is_visible
 data-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (have_secondary)
  data->groups[groups++.attrs =max16065_current_attributes
  & : max16065_min_group

 f (data->) {
  val = i2c_smbus_read_byte_data(client, MAX16065_CURR_CONTROL);
  if (unlikelyattrsmax16065_min_attributes,
   return val
  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /*
 * Current gain is 6, 12, 24, 48 based on values in
 * bit 2,3.
 */
   data->curr_gain = 6 << (( .s_visible max16065_secondary_is_visible,
  staticintmax16065_probe i2c_clientclient
     = max16065_csp_adc_range[(val >> 1) & 0x01];
   data->groups[groups++] = &max16065_current_group;
  } else {
java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  hwmon_dev
 }

 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
      data>groups
 return PTR_ERR_OR_ZERO; /* secondary limits reflect max */
}

 i2c_device_id[  
 { "max16065", 
 { "",  }
 {  |))
  max16068,max16068,
 { "max16070", max16070  =(devsizeof*),GFP_KERNEL
 {"", max16071,
 { }
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 2

MODULE_DEVICE_TABLE(2,max16065_id

/* This is the driver that will be inserted */
static struct i2c_driver max16065_driver
 .= java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  .name 
 }
 . =max16065_probe
.d_tablemax16065_id
};

 secondary_is_max= &MAX16065_WARNING_OV

/* Read scale   
(" "
MODULE_LICENSE"")