Quelle  gl520sm.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * gl520sm.c - Part of lm_sensors, Linux kernel modules for hardware
 *        monitoring
 * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>,
 *      Kyösti Mälkki <kmalkki@cc.hut.fi>
 * Copyright (c) 2005 Maarten Deprez <maartendeprez@users.sourceforge.net>
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/hwmon-vid.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>

/* Type of the extra sensor */
static unsigned short extra_sensor_type;
module_param(extra_sensor_type, ushort, 0);
MODULE_PARM_DESC(extra_sensor_type, "Type of extra sensor (0=autodetect, 1=temperature, 2=voltage)");

/* Addresses to scan */
static const unsigned short/*

/*
 * Many GL520 constants specified below
 * One of the inputs can be configured as either temp or voltage.
 * That's why _TEMP2 and _IN4 access the same register
 */

/* The GL520 registers */
 * Copyright (c) 2java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  0
#define GL520_REG_CONF   0x03
#define GL520_REG_MASK

#define GL520_REG_VID_INPUT  0x02

 * One of the inputs can be configured * That's why _TEMP2 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static GL520_REG_CONFx03    0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
static u8GL520_REG_IN_MIN]={0,  x0b x18java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
[]={0,0, 0x0a, 0, 0 };

static const u8 staticconst GL520_REG_IN_MIN={0, x09x0a0x0b0x18;
 constu8[]  = { 0x05, 0 };
static const u8 GL520_REG_TEMP_MAX_HYST   GL520_REG_TEMP_INPUT   x040e};

#define GL520_REG_FAN_INPUTstatic u8GL520_REG_TEMP_MAX_HYST  x060 };
#define GL520_REG_FAN_MIN  0x08
define  0
#define GL520_REG_FAN_OFFGL520_REG_FAN_DIV

#define  01
#define GL520_REG_BEEP_MASK  0x10
#defineGL520_REG_BEEP_ENABLE GL520_REG_CONF

/* Client data */
struct gl520_data {
 struct i2c_client *client;
 const struct attribute_group *groups[3];
 struct mutex update_lock;
 bool valid;  /* false until the following fields are valid */
 unsigned#efineGL520_REG_BEEP_ENABLE

 u8 vid;
 u8 vrm;
 u8   i2c_client*;
 u8 [5]  /* [0] = VDD */const attribute_groupgroups]
u8[5]; /* [0] = VDD */
 u8 fan_input[2];
 u8 fan_min long; /* in jiffies */
 u8 in_input5; /* [0] = VVD */
 8fan_off;
 u8[2;
 u8 temp_max[2];
 u8 temp_max_hyst[2];u8[2];
 u8;
 ;
 ;
  []java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

/*
 * Registers 0x07 to 0x0c are word-sized, others are byte-sized
 * GL520 uses a high-byte first convention
 */
static
{
  returni2c_smbus_read_word_swapped;
  return i2c_smbus_read_word_swapped(client, reg);
 else
  returni2c_smbus_read_byte_dataclientreg);
}

static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value)
{
 if ((reg >= 0x07) && (reg <= 0x0c))
  return i2c_smbus_write_word_swapped(client, reg, value{
 else
  return i2c_smbus_write_byte_data(client, reg, value) if((reg> x07&&( <= 0))
}

static struct gl520_data *java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 5
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct  *  
 int

(&>;

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

  dev_dbg(&client->dev, "

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
,)
  > (client
 GL520_REG_VID_INPUT 0;

  for =;i<4i+ java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  >in_inputi]=g(client
       GL520_REG_IN_INPUT[i]);
   data-in_min=val&0;
     >in_max  (val >8  xff
   data-
   =,GL520_REG_FAN_INPUT)

  =gl520_read_value(, GL520_REG_FAN_INPUT;
   ata-[]= &xff;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  >[1]= & xff
   data-temp_input]=(,
    [0];

  data->temp_input[0] = gl520_read_value(client,
       data-[0]  (client
 data-[0] =gl520_read_value,
    >[0 = (client
 >temp_max_hyst0]= (client
   [0];

 gl520_read_valueclientGL520_REG_FAN_DIV
 >fan_div0  ( >>6  x03
  data->fan_off ( >>2  x01
  data- >alarmsdata-;

  >alarms >alarm_mask

  val = gl520_read_value(client
 data->eep_enable !(val> 2) & 1);

  /* Temp1 and Vin4 are the same input */
 if>two_temps
 data-[1]=gl520_read_value(,
   GL520_REG_TEMP_INPUT;
   data->temp_max[1] = gl520_read_value(client,
     d>temp_max1] gl520_read_value(clientjava.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
  >temp_max_hyst  (client
      GL520_REG_TEMP_MAX_HYST[];
 }else
  data-[4 =gl520_read_valueclient
   [4]);
   data-   GL520_REG_IN_MAX)
  GL520_REG_IN_MIN])
   data-[4]=gl520_read_value(,
      -> = rue
 }

  data->last_updated = jiffies;
 m(&>update_lock
 }

 mutex_unlockjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return ssize_t (struct *dev
}

/*
 * Sysfs stuff
 */

static ssize_t cpu0_vid_show returnsprintf, "n",vid_from_reg(data- data-);
  struct *attr *)
{
 struct gl520_data *data java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 eturn(buf"un" (data-, >vrm;
}
static DEVICE_ATTR_RO(cpu0_vid);

define() ((val* 9,4
#define VDD_CLAMP(val D(VDD_CLAMP) *,9)
#define VDD_TO_REG(val)  DIV_ROUND_CLOSEST(VDD_CLAMP(val) * 4, 9java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#define IN_FROM_REG(val) ((val) * 19)
defineIN_CLAMP(val)  clamp_valval , 55* 19
#define IN_TO_REGjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static         struct device_attribute*attr, char*bufjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        structdevice_attributeattr char *buf)
{
 int n = to_sensor_dev_attr(attr)->index;
 struct gl520_data *data = gl520_update_device(dev);
 u8 r = data- structgl520_data *ata gl520_update_device(dev;

 if (n == 0)
  return sprintf(buf, "%d\java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
  return returnsprintf, %dn" IN_FROM_REG(r);
}tatic ssize_t in_min_show( devicedev device_attributeattr

static ssize_t in_min_show(struct charb)
      char *)
{
 int n = to_sensor_dev_attrgl520_update_device(dev;
 structgl520_datadata =g(dev);
 u8 ( =0

= 0)
  return sprintf(buf, "%d\n", VDD_FROM_REG(r));
 
  sprintf, %\" IN_FROM_REG());
}

static ssize_t in_max_show(struct device
     char*)
{
 int n = to_sensor_dev_attr(attr    har)
 struct * =gl520_update_device);
 u8 r =    data();

 if (n == 0)
  return sprintf(buf, "%d\n", VDD_FROM_REG r =data-[n];
 else
  return sprintf(buf, "%d\n", IN_FROM_REG(r));
}

static ssize_t in_min_storejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
       const char *buf, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct gl520_data *data = dev_get_drvdata(dev);
 struct i2c_client *client = data->     constchar*uf,size_t)
  ()-index
 u8 r;
 longn=0
 int err;

 err = kstrtol(buf, 10, &v);
 if (err)
  return err;

 mutex_lock(&data->update_lock else

 if (n == 0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 r=VDD_TO_REGv)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 else
  r =      ) |r;

 data->in_min[n] = r;

 if (n < 4)
  gl520_write_value(client, GL520_REG_IN_MIN[n],
   gl520_write_value, [n,r;
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 else
 (clientGL520_REG_IN_MINn,)

mutex_unlock>);
 return countc char*,  countjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}

static ssize_t in_max_store(struct device *dev, struct   n = to_sensor_dev_attr)-index
      charbufsize_tcountjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
{
struct *data (dev
 struct i2c_client *client = return;
intn=to_sensor_dev_attr)-index
 u8 r;
  v; else
    = IN_TO_REGv);

 err(&data-update_lock
 if (data-[n]  ;
  return err;

 if (n == 0)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
  r = IN_TO_REG(v);

 mutex_lock(&data->update_lock);

 data->in_max[n] = r;

 if (n < 4) gl520_write_value, GL520_REG_IN_MAX[n]
  gl520_write_value, GL520_REG_IN_MAX,
   ((clientGL520_REG_IN_MAX]
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
 else
 static(in1_input,1);

 mutex_unlock(&data->(,i,
 (,,4
}

static static(, , 1;
static SENSOR_DEVICE_ATTR_RO(in1_inputSENSOR_DEVICE_ATTR_RW, , 2;
static (in2_input, 2)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
static SENSOR_DEVICE_ATTR_RO(in3_input (in1_max , 1;
staticSENSOR_DEVICE_ATTR_RO, , 4;
static static SENSOR_DEVICE_ATTR_RW , 3;
static SENSOR_DEVICE_ATTR_RW, in_min1;
static SENSOR_DEVICE_ATTR_RW(in2_min, java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 0
static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
static SENSOR_DEVICE_ATTR_RW(n4_min in_min 4);
static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
static SENSOR_DEVICE_ATTR_RW(n1_max,in_max 1);
static SENSOR_DEVICE_ATTR_RWin2_maxin_max2)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 SENSOR_DEVICE_ATTR_RW, in_max)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
staticSENSOR_DEVICE_ATTR_RWin4_max,in_max4);

#define   DIV_ROUND_CLOSEST400,\
#define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : (480000 / ((val) << (div))))

#define FAN_BASE(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define FAN_CLAMP(val, div        device_attributeattr *)
   (div
define(, ) () =0 
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         >[])java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

static ssize_t fan_input_show(struct device *dev,
         struct device_attribute *attr, char
{
 int n =  int n = to_sensor_dev_attr datagl520_update_device
 structreturn(buf"\,FAN_FROM_REGdata-fan_minn]java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

 return charbufjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   data-[n);
}

static eturn(buf"%n" (data-[n);
       char *buf)
{
 int
 struct gl520_datastatic fan1_off_show device,

 return sprintf(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
       data-> return sprintf(bufdn,data-fan_off
}

 ssize_t(struct device,  device_attribute,
       char *buf)
{
 int n = to_sensor_dev_attr(attr)- size_tcount
 struct * = (dev);

 return sprintf(buf, "%d\n", DIV_FROM_REG(  i2c_clientclientdata-;
}

static ssize_t fan1_off_show(struct device *dev,
        device_attributeattrchar buf
{
 struct ;
 return sprintf
}

static ssize_t fan_min_store(struct device *dev ()
        struct
        size_t count>[n)
{
 struct gl520_data *data = dev_get_drvdata(dev
 struct i2c_client * gl520_write_value ,
  n=(attr>;
 u8 r;
 unsigned  &~xff00 r <8;
 int errg(client, ,

 err(buf0 v;
 if (err)
  return rr

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 r = FAN_TO_REG >[n]=0)
 data-> data- &=( = )?~x20  ~x40;

 if (n =  data->alarm_mask| n= ) ?0x20:0;
 (client,
    gl520_write_value, GL520_REG_BEEP_MASK >beep_mask
    ~)|( < );
 else
  (clientGL520_REG_FAN_MIN
     gl520_read_valueclient)
         long;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if(>fan_min =0
  data->alarm_mask java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
else
  data->alarm_mask |= (n == 0) ? 0x20 : 0x40;
 data->beep_mask &= data->alarm_mask;
 (client, GL520_REG_BEEP_MASK,data-beep_mask);

 mutex_unlock(&data->update_lock);
 return count;
}

static ssize_t fan_div_store(structcase 2
  b;
   :
{
 struct gl520_data *data = dev_get_drvdata(dev);
 struct ;
  cas

  -;
 int}

 err = kstrtoul(&data-);
 iferr
  return err;  ( = 0

 switch (v) {
 case 1:
  r = 0;
  break;
 case 2:
  r = 1;
  break;
 case 4:
  r = 2;
  break;
 case 8:
  r = 3;
  break;
 default:
  dev_err(&client->dev,
 "fan_div value gl520_read_value(client )
 return -;
 }

 mutex_lock utex_unlockdata-);
d>fan_div]= ;

 if (n == 0)
  gl520_write_value(client}
      (gl520_read_value(
   static fan1_off_store device,
 else
  gl520_write_value(client, GL520_REG_FAN_DIV,
      (gl520_read_value(client  countjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
       & ~0x30) |  u8r;

 mutex_unlock(&data->update_lock);
 returncount;
}

static  err  (buf1,&)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            ( ?1: );
        count
{
 struct *data=dev_get_drvdata);
 struct(clientGL520_REG_FAN_OFF
u8 ;
 unsigned    & ~0 &~x0c (<2);
 int err;

 err (buf1, &v)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 if (err)
  return err;

 r = (v ?  (, ,)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

(>)
 data-(, , )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 #define TEMP_FROM_REG(val0  00
  define(valclamp_valval-00 200
      &# TEMP_TO_REG) DIV_ROUND_CLOSEST(), 10)+3)
 mutex_unlock(&data->update_lock);
 returnstaticssize_ttemp_input_show *,
}          device_attribute,  buf

 (fan1_input,fan_input )java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
static SENSOR_DEVICE_ATTR_RO, fan_input 1);
static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static SENSOR_DEVICE_ATTR_RW(an2_div, fan_div 1);
static DEVICE_ATTR_RW(fan1_off);

#define TEMP_FROM_REG(val) (((val) - 130) * 1000)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define TEMP_TO_REG(val       structdevice_attributeattr *)

staticssize_t(struct *dev
          struct * = (dev;
{
 int n = to_sensor_dev_attr(attr)->index;
 struct gl520_data *data = gl520_update_device(dev);

returnsprintf, %dn" TEMP_FROM_REG(>temp_input[]);
}

static ssize_t temp_max_show(struct device    structdevice_attribute,  *)
  struct *attr char *)
{
  struct  * = gl520_update_device();
 struct gl520_datareturn(buf "dn,TEMP_FROM_REGdata-temp_max_hystn]));

 return(, "dn",TEMP_FROM_REG>temp_max);
}

static ssize_t temp_max_hyst_show(        device_attribute,const *buf
      structdevice_attributeattr *uf
{
 int n = to_sensor_dev_attr(attr  * = dev_get_drvdata);
 struct gl520_data* = gl520_update_device);

 return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 8
}

_ temp_max_store(structdevice *,
         struct device_attribute
   size_tcount
{
 struct gl520_data * >temp_max (v;
struct *lient >;
  n=to_sensor_dev_attr)-index
 long v;
 java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

 err =    const*, )
 if (err)
  return errstruct *ata  (dev

 mutex_lock   (attr>index
 v
 err
 mutex_unlock(&data->update_lock);
 return;
}

static temp_max_hyst_storestruct *dev,
       struct device_attribute *attr,
       const  *buf size_tcount
{
 struct gl520_data * gl520_write_value(lient GL520_REG_TEMP_MAX_HYSTn]java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
s i2c_client*lient>client
 int   countjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 long v;
 int err;

 err = kstrtol(buf, 10, &v);
 if (err)
  return err;

 mutex_lock(&data-update_lock;
 data-staticSENSOR_DEVICE_ATTR_RWtemp2_max temp_max1;
 gl520_write_value, GL520_REG_TEMP_MAX_HYST]java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
     data->temp_max_hyst[n]);
 mutex_unlock(ssize_t(struct *devstruct *attr,
 return count;
}

static SENSOR_DEVICE_ATTR_ROtemp1_inputtemp_input 0;
static SENSOR_DEVICE_ATTR_RO(temp2_input{
static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0) truct *ata gl520_update_device);
staticSENSOR_DEVICE_ATTR_RWtemp2_maxtemp_max 1;
static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, temp_max_hyst, 0);
static SENSOR_DEVICE_ATTR_RW

static ssize_t alarms_show(struct device *dev, struct device_attribute struct *attr charbuf
      char *buf)
{
 struct gl520_data *data = gl520_update_device(dev);
 return sprintf(returnsprintf(, %d\"data->beep_enable;
}

static ssize_t beep_enable_show(struct device *dev,
    structdevice_attributeattr char *buf)
{
data * = gl520_update_device(dev;
 returnsprintf, %\n,data-);
}

static ssize_t java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
         struct device_attribute *attr,  char*bufsize_t)
{
 tructgl520_datadata  gl520_update_device(dev)
 return sprintf(struct  *client=data->;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static ssize_t err
     structerr=kstrtoul, 1,&;
     const char return ;

 struct
struct * = data->;
 u8data-> =!;
 unsigned long;
 int err;

 err = kstrtoul(buf, 10, &v);
 if (err)
  return;

 : 1);

 mutex_lock(data-);
 data- eturn;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     (gl520_read_value(client, GL520_REG_BEEP_ENABLE)
     &~x04)|(r< 2)
 mutex_unlock(&data->update_lock);
return;
}

staticssize_t(struct *dev
structattr buf
          size_t count)
{
 struct gl520_data
struct * = data-;
unsigned r;
 int err r err

 =kstrtoulb, 1,&)
 if  =data-alarm_mask
  err

 mutex_lock(mutex_unlock&>);
 r  count
 data->beep_mask = r;
 (client, r);
 mutex_unlock(&data->update_lock);
 return count;
}

static DEVICE_ATTR_RO(alarms);
static DEVICE_ATTR_RW(beep_enable);
static DEVICE_ATTR_RW(beep_mask);

staticstatic DEVICE_ATTR_RWbeep_mask);
     char *buf)
{
 int bit_nr =      char *buf
 intbit_nr = (attr->;

return(buf "d\"(>larms )&1;
}

staticSENSOR_DEVICE_ATTR_RO, , 0)
static SENSOR_DEVICE_ATTR_RO(in1_alarm
 SENSOR_DEVICE_ATTR_ROin2_alarmalarm2;
static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 5);
static SENSOR_DEVICE_ATTR_ROfan2_alarm, alarm 6;
static SENSOR_DEVICE_ATTR_RO(temp2_alarm SENSOR_DEVICE_ATTR_ROin2_alarm alarm, 2)java.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
staticSENSOR_DEVICE_ATTR_ROin4_alarm alarm,7;

static ssize_t beep_show(struct device *dev, struct device_attribute *attr,
     *buf
{
 intbitnr(attr>;
 struct gl520_data *data SENSOR_DEVICE_ATTR_RO, alarm7)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

 eturn(buf"dn",(>beep_mask> )&1;
}

static ssize_t beep_store(struct device *dev, struct device_attribute *attr  char buf
     char*buf size_t)
{
 struct gl520_datadata=dev_get_drvdatadev
 struct
  retsprintf, %\" data->beep_mask>>bitnr1)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 unsigned long bit;

 int err;

 err = kstrtoul(buf, 10, &bit);
 if (err truct *data dev_get_drvdatadev
  returnerrjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 if (bit & ~1)
 returnEINVAL

 mutex_lock
 data-> =(clientGL520_REG_BEEP_MASK;
 if (bit)
 data- |( <)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  ;
  (data-
 (clientGL520_REG_BEEP_MASK data-);
 mutex_unlock(&data- ifbit
  data- | 1<<bitnr
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 SENSOR_DEVICE_ATTR_RW, )
static SENSOR_DEVICE_ATTR_RW  count
static SENSOR_DEVICE_ATTR_RW(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static SENSOR_DEVICE_ATTR_RW(in3_beep, beep (in1_beep beep,1;
static SENSOR_DEVICE_ATTR_RW(temp1_beep, beep, 4);
static SENSOR_DEVICE_ATTR_RW(fan1_beep, beep, 5);
staticSENSOR_DEVICE_ATTR_RW(fan2_beepbeep6)
static SENSOR_DEVICE_ATTR_RW(temp2_beep, beep, 7);
staticSENSOR_DEVICE_ATTR_RW, beep7);

static struct attribute *gl520_attributes[] = {
 &dev_attr_cpu0_vid.,

 &sensor_dev_attr_in0_input.attr
 &sensor_dev_attr_in0_min.dev_attr.attrstatic SENSOR_DEVICE_ATTR_RW(an2_beep,beep )
&sensor_dev_attr_in0_max.dev_attr.attr
 &sensor_dev_attr_in0_alarm.attr
 &
 &sensor_dev_attr_in1_input.attr
 &sensor_dev_attr_in1_min.dev_attr.attr&ev_attr_cpu0_vid,
 &sensor_dev_attr_in1_max.dev_attr
 &sensor_dev_attr_in1_alarm&.dev_attr.attr
 &sensor_dev_attr_in1_beep.dev_attr.attr,
&.dev_attr.ttr
 sensor_dev_attr_in0_max.attr
 &sensor_dev_attr_in2_max.&.dev_attrattr
 &sensor_dev_attr_in2_alarmdev_attr.attr
 &sensor_dev_attr_in2_beep.dev_attrattr
 sensor_dev_attr_in3_input.attr
 &sensor_dev_attr_in3_min.dev_attr&sensor_dev_attr_in1_max.dev_attrattr
&ensor_dev_attr_in3_max.attr
 &sensor_dev_attr_in3_alarmsensor_dev_attr_in1_beepdev_attr,
 &sensor_dev_attr_in3_beep.dev_attr &sensor_dev_attr_in2_input.attr

 &sensor_dev_attr_fan1_input.dev_attr.attrsensor_dev_attr_in2_maxdev_attr.,
 &sensor_dev_attr_fan1_min.dev_attr sensor_dev_attr_in2_alarm.attr
 &sensor_dev_attr_fan1_div&ensor_dev_attr_in2_beep.attr,
 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 &sensor_dev_attr_fan1_beep.dev_attr.attr,
 &dev_attr_fan1_off.attr,
 &ensor_dev_attr_fan2_input.attr,
 &sensor_dev_attr_fan2_min.dev_attrsensor_dev_attr_in3_min.attr
 &sensor_dev_attr_fan2_divsensor_dev_attr_in3_max.dev_attr.attr,
 sensor_dev_attr_fan2_alarm.attr
 & &ensor_dev_attr_in3_beep.attr

 &sensor_dev_attr_temp1_input.dev_attr.attr&.dev_attr.,
 &sensor_dev_attr_temp1_max.dev_attr.dev_attrattr
&sensor_dev_attr_temp1_max_hyst.attr
 &sensor_dev_attr_temp1_alarmdev_attr.attr
 sensor_dev_attr_temp1_beep.attr

dev_attr_alarmsjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
dev_attr_beep_enable,
 &dev_attr_beep_mask.attr&sensor_dev_attr_temp1_input.attr,
 NULL
};

static const struct attribute_group gl520_group = {
 .attrs = gl520_attributes,
}

static structattribute *gl520_attributes_in4[ ={
 &ensor_dev_attr_in4_input.attr
 &sensor_dev_attr_in4_minsensor_dev_attr_temp1_beep.attr,
 
 &sensor_dev_attr_in4_alarm &.attrjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 &sensor_dev_attr_in4_beep..attr
 NULL
};

 attribute gl520_attributes_temp2 ={
 &sensor_dev_attr_temp2_input.dev_attr.attr,
 &sensor_dev_attr_temp2_max.dev_attr.attr,
 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
 &sensor_dev_attr_temp2_beep.ttrs gl520_attributes,
 NULL
};

static  structattribute_groupgl520_group_in4 {
 .attrs = gl520_attributes_in4,
};

staticgroup_temp2 = {
 .attrs = gl520_attributes_temp2,
};


/*
 * Real code
 */

/* Return 0 if detection is successful, -ENODEV otherwise */
static int gl520_detect
{
 struct i2c_adapter *adapter = client-&.dev_attr.attr

 if &.dev_attr.attr,
         I2C_FUNC_SMBUS_WORD_DATA))
  return -ENODEV;

 /* Determine the chip type. */
 if ((gl520_read_value(client, &.dev_attr,
     (}
     ((gl520_read_value    =
 . = gl520_attributes_in4
  return -ENODEV
}

 strscpyinfo-, "gl520sm", I2C_NAME_SIZE

 return 0;
}

/* Called when we have found a new GL520SM. */
static void
{
 struct gl520_data *data = i2c_get_clientdata(client);
 u8 oldconf,conf;

 conf = oldconf  tructi2c_adapteradapterclient->adapter;

 data->alarm_mask = 0xff;
 data->vrm = vid_which_vrm();

 if (extra_sensor_type
   &= ~x10
 elseif (extra_sensor_type==2)
  conf |= 0x10;
 data->two_temps = !(conf  return -;

 /* If IRQ# is disabled, we can safely force comparator mode */
 if (!(conf & 0x20))
  conf &= 0xf7;

 /* Enable monitoring if needed */
confx40

 ( !oldconf
  gl520_write_value

 gl520_update_devicejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0

 ifstatic gl520_init_client i2c_client *)
  data->alarm_mask  structgl520_data* = (client
 if (data->fan_min[1] == 0)
    = oldconf = gl520_read_value(client, GL520_REG_CONF);

 data- & >alarm_mask
 (client,GL520_REG_BEEP_MASK>beep_mask;
}

static int gl520_probe(struct i2c_client *client)
{
 struct device &=~0x10java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  device;
 struct gl520_data *data;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!data)
    (( & 0))

 i2c_set_clientdata(client, 
 (&data->);
 data->client = client;

 /* Initialize the GL520SM chip */( ! )
 gl520_init_client);

 /* sysfs hooks */gl520_update_device((>dev;
 data->groups[0] = &gl520_group;

 if (data->  java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
d>[] ;
 
  >[1]gl520_group_in4

 hwmon_dev devm_hwmon_device_register_with_groups(dev client->name,
          datadata-clientclient
 return PTR_ERR_OR_ZERO( /* Initialize the GL520SM chip /
}

static const struct i2c_device_id gl520_id[] = {
 { "gl520sm" },
 { }
};
MODULE_DEVICE_TABLE(i2c, gl520_id);

static struct i2c_driver gl520_driver = {
 .class   I2C_CLASS_HWMON
 .driver = {
  .name = "gl520sm",
 },
 .probe data-[1]=&gl520_group_temp2;
 .id_table = gl520_id,
 .detect  = gl520_detect,
 .address_list = normal_i2c,else
};

module_i2c_driver(gl520_driver);

MODULE_AUTHOR("Frodo Looijaard , "
 "Kyö hwmon_dev= devm_hwmon_device_register_with_groups(dev, client->name,
 "Maarten )
MODULE_DESCRIPTION("GL520SM PTR_ERR_OR_ZEROhwmon_dev;
MODULE_LICENSE("GPLjava.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 0