Impressum lm78.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * lm78.c - Part of lm_sensors, Linux kernel modules for hardware
 *     monitoring
 * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
 * Copyright (c) 2007, 2011  Jean Delvare <jdelvare@suse.de>
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#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-vid.h>
#include <linux/hwmon-sysfs.h>
#include <linux/err.h>
#include <linux/mutex.h>

#ifdef CONFIG_ISA
#include <linux/platform_device.h>
#include <linux/ioport.h>
#include <linux/io.h>
#endif

/* Addresses to scan */
static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
      0x2e, 0x2f, I2C_CLIENT_END };
enum chips { lm78, lm79 };

/* Many LM78 constants specified below */

/* Length of ISA address segment */
#define LM78_EXTENT 8

/* Where are the ISA address/data registers relative to the base address */
#LM78_ADDR_REG_OFFSET 5
define LM78_DATA_REG_OFFSET 6

/* The LM78 registers */java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 23
define LM78_REG_IN_MAX() (0x2b 
#define java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
#define LM78_REG_INinclude <linuxioport.h>

#define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
#define LM78_REG_FAN(#nclude <linux/io.h>

#define LM78_REG_TEMP 0x27
#e LM78_REG_TEMP_OVER 0x39
#define LM78_REG_TEMP_HYST 0x3a

#define0
#define LM78_REG_ALARM2 constunsignednormal_i2c]{0x28,0x29 x2a xb 0x2c x2d,

#define  0x2e, 0x2f, I2C_CLIENT_END

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define #define LM78_EXTENT
#define LM78_REG_I2C_ADDR 0x48

/*
 * Conversions. Rounding and limit checking is only done on the TO_REG
 * #defineLM78_REG_IN(nr) (0x20 + (nr))
 */

/*#define LM78_REG_TEMP 0x27 LM78_REG_TEMP 0x27
# LM78_REG_TEMP_OVER 0x39
 * REG:#efine LM78_REG_TEMP_HYST 0x3a
 */
static inline u8 IN_TO_REG(unsigned long val)
{
 unsigned java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
 return(nval +8)/16;
}
#define IN_FROM_REG(val) ((val) *  16)

static inline u8 FAN_TO_REG(long rpm,int )
{
 if (pm< 0)
  return 255;
 if (rpm > 1350000)
  return 1;
  IN java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 23
}

static inline int FAN_FROM_REG REG 16/bit
{
 return val = *
}

/*
 * TEMP: mC (-{
 *REG 1/bit, two's complement
 */
static inline s8 TEMP_TO_REG(ong val)
{
 int nval = clamp_val(val, -128000, 127000) ;
 return nval <0?(nval - 500)/ 1000:(nval +500)/1000;
}

static inline int TEMP_FROM_REG(s8 val)
{
 return val * 1000;
}

#define java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 11

struct
 i2c_clientclient
struct java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 enum chips type;

 /* For ISA device only */
 const char *name;
 int isa_addr;

 struct mutex update_lock;
 bool valid;  /* true if following fields are valid */
 java.lang.StringIndexOutOfBoundsException: Range [27, 9) out of bounds for length 45

 u8 in[7];  /* Register value */
 u8 in_max[7];  /* Register value */
 u8 in_min[7];  /* Register value */
 [3]; /* Register value */
 u8 fan_minjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
 8 temp; /
 s8 temp_over;  /* Register value */
 s8 temp_hyst;  /* Register value */
 u8 fan_div[3];  /* Register encoding, shifted right */
 u8java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 , combined *java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}{

static int lm78_read_value(struct lm78_data *data, u8 reg);
e_valuestruct lm78_data *data, u8 reg, u8 value);
static struct lm78_data *lm78_update_device(struct device
static struct i2c_clientclient

/* 7 Voltages */type
static const char;
  charbuf
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct lm78_data unsignedlong  
  sprintf(buf,"d\ IN_FROM_REG(data>inattr->index]));
}

static ssize_t in_min_show(struct device *dev, structjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 36
      char *buf)
{
 struct u16 alarms; /* Register encodingcombined 
lm78_update_device(ev);
 return sprintf(buf, "%d\n", IN_FROM_REG(data int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
}

static}
 static ssize_t in_min_show(truct device *ev,struct device_attribute*a,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct  return sprintf(buf, "%d\n IN_FROM_REG(ata->in_min[attr->index]));
 struct *ata = lm78_update_device()java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
}

static ssize_t in_min_storestruct device *dev, struct device_attribute *da,
*buf,size_t count)
{
 struct  *attr=to_sensor_dev_attr();
 struct lm78_data *data = dev_get_drvdata(dev);
 int nr =attr->index;
 }
 int err;

err  = kstrtoul(uf, 10 &al)
if (rrjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
err)

 return;
 java.lang.StringIndexOutOfBoundsException: Range [29, 5) out of bounds for length 35
 lm78_write_valuedata,LM78_REG_IN_MAX(nr) data-in_max[];
mutex_unlock(&data->update_lock);
 eturn count;
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 1

 in_max_storestruct device *ev, struct device_attribute *da,
       const char *buf, size_t count)
{
 struct sensor_device_attribute *attr = to_sensor_dev_attr(das SENSOR_DEVICE_ATTR_RW(,in_max,3java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 struct lm78_data data = dev_get_drvdata(dev);
 int nr =tatic SENSOR_DEVICE_ATTR_RW(in6_min,in_min,6;
 unsigned long val;
   struct device_attribute *da, char *buf)

 err = kstrtoul(buf, 10, &java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
 struct lm78_data *data = lm78_update_device(dev);
  return err;

 mutex_lock(&data->update_lock);
 data->in_max[nr] = IN_TO_REG(val);
 lm78_write_value int err;
mutex_unlock(&ata-update_lock);
 if (err)
}

static mutex_lock(data->pdate_lock)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
mutex_unlock(data-update_lock)
static static ssize_t (truct device *dev,
static SENSOR_DEVICE_ATTR_RO(in1_input{
static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
static in3_max,in_max, 3)
tatic SENSOR_DEVICE_ATTR_RO(in4_input,in 4)
static SENSOR_DEVICE_ATTR_RWs DEVICE_ATTR_RO(temp1_input);
static /
 SENSOR_DEVICE_ATTR_RO(n5_input, in, 5);
static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
static SENSOR_DEVICE_ATTR_RO(in6_input,struct lm78_data data  lm78_update_deviced)
static SENSOR_DEVICE_ATTR_RW(n6_min, in_min, 6;
static static ssize_t fan_min_show(struct device *dev, struct device_attribute *da,

/* Temperature */
static ssize_t temp1_input_show( DIV_FROM_REG>an_divn]));
    static ssize_t fan_min_store(struct device *dev, struct device_attribute *        constchar *uf  countjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
 struct java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 if (err)
}

java.lang.StringIndexOutOfBoundsException: Range [13, 6) out of bounds for length 78
         char *uf)
{
 struct lm78_data *data = lm78_update_device(dev);
 sprintfbuf %\n" (->emp_over);
}

static ssize_t -[]=FAN_TO_REGval DIV_FROM_REG(ata->[nr]);
          struct device_attribute *da, const char *buf, (ata,java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 65
 size_tcountjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
{
structlm78_data *ata  dev_get_drvdata(evjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 long val;
interr;

 err = kstrtol(buf, 10, }
 if (err)
  return err;

 mutex_lock(&data->update_lock);
 data->temp_over = TEMP_TO_REG(val);
 lm78_write_value  determined part by fan .This  the principle of
 mutex_unlock(&data->update_lock);
 return count;
}

static ssize_tthejava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 31
       structdevice_attribute *,char *uf
{
structlm78_data data lm78_update_device(dev)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 return int nr = attrindex;
}

static ssize_t temp1_max_hyst_store;
        struct device_attribute *da,
        const char *buf, java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 9
{
 struct lm78_data *ata =dev_get_drvdata(dev)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 val;
 interr;

 err = kstrtol(uf 10 &al;
 if (err)
  return err;

 utex_lock(&data->update_lock);
 data->temp_hyst = TEMP_TO_REG(val);
 lm78_write_value(data,LM78_REG_TEMP_HYST,data->temp_hyst);
 mutex_unlock(&data->update_lock);
 return count;
}

static DEVICE_ATTR_RO(temp1_input);
static DEVICE_ATTR_RW(temp1_max);
static DEVICE_ATTR_RW(temp1_max_hyst);

/* 3 Fans */
static ssize_tdata->an_divnr = 2;
   char *java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 -INVAL
 java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
 struct lm78_data*ata=lm78_update_device()
 nr  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  sprintfbuf "%\n,(ata-fan[r]java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 DIV_FROM_REGdata-fan_divnr));
}

static ssize_t fan_min_show(breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
       char *buf)
{
 FAN_TO_REG(in DIV_FROM_REGdata-fan_div[r]);
 struct lm78_data* =lm78_update_device(ev)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 intreturncountjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
sprintf(,"dn" FAN_FROM_REGd-fan_min[r]
  DIV_FROM_REG(data->fan_div[nrSENSOR_DEVICE_ATTR_RW(an1_min fan_min,0;
}

static ssize_t fan_min_store(struct deviceSENSOR_DEVICE_ATTR_RW(an2_min fan_min,1;

{
 struct java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
struct lm78_data*  dev_get_drvdatadev)
int nr =attr->ndex
 unsigned long static SENSOR_DEVI(fan3_divfan_div,2;
 int err;static ssize_t cpu0_vid_showstruct device*,struct device_attributedajava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

err  kstrtoulbuf, 10, &val)
}
  return err;

 mutex_lock(&data->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
data-fan_min[]=FAN_TO_REG(val,DIV_FROM_REG(data-[);
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
mutex_unlock&>pdate_lock;
 return count;
}

static ssize_tjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        ssize_t ( device*ev,struct device_attributeda,
{
 device_attribute *attr = to_sensor_dev_attr(da);
 struct lm78_data *data = java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 1
 return sprintf int   to_sensor_dev_attrd)>ndexjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

/*
 * Note: we saveSENSOR_DEVICE_ATTR_ROin1_alarm,alarm,1)
or.  Thisfollows the principle of
 *least surprise; the user doesn't expect the fan minimum to change just
java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 31
 */
static ssize_t fan_div_store(java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 0
  s.dev_attrattr,
{
 struct sensor_device_attribute *attr rsensor_dev_attr_in0_maxdev_attr.attr,
 struct lm78_data *data = dev_get_drvdata( sensor_dev_attr_in0_alarm.dev_attr.attr,
 int nr sensor_dev_attr_in1_input.dev_attr.attr,
 unsigned long min;
 u8 regjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 unsigned long val;
 int err

err = kstrtoul(buf,10 &val);
 &sensor_ev_attr_in2_min.dev_attr.attr,
  return err;

 java.lang.StringIndexOutOfBoundsException: Range [30, 11) out of bounds for length 32
 min = FAN_FROM_REG(data->fan_min[nr],
       &sensor_dev_attr_.dev_attr.attr,

 switch ( &sensor_devattr_in3_min.dev_attr.attr,
 case 1:
  data->fan_div[nr] = 0;
  break;
 case 2:
  data->fan_div[nr] = 1;
  break;
 case 4:
 data->fan_div[nr] = 2;
  break;
 case 8:
  data->an_div[nr] =3;
  break;
 default:
  dev_err(dev,
 "fan_div value %dnot . Choose one of 1, 2,4or 8\",
   val);
  mutex_unlock(&data->&sensor_dev_attr_in5_maxdev_attr.ttr,
  return -EINVAL;
 }

 reg = &ensor_dev_attr_in6_input.dev_attr.attr,
 switch (nr) {
 java.lang.StringIndexOutOfBoundsException: Range [7, 5) out of bounds for length 8
  reg = (&sensor_dev_attr_in6_alarm.dev_attr.attr,
  break;
 case 1: &ev_attr_temp1_input.attr,
  reg = (reg & 0x3f) | (data->fan_div[nr] << 6) &ev_attr_temp1_max.attr,
  break;
 }
lm78_write_value(data, LM78_REG_VID_FANDIV, reg);

 data->fan_min[nr] =
  FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr] &ensor_dev_attr_fan1_input.dev_attr.attr,
 lm78_write_value(data,  sensor_dev_attr_fan1_div.dev_attr.attr,
 mutex_unlock(&data->update_lock);

 return count;
}

static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
tatic SENSOR_DEVICE_ATTR_RW(fan1_min,fan_min, 0);
static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
static sattr
taticSENSOR_DEVICE_ATTR_RW,)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

/* Fan 3 divisor is locked in H/W */
static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0
static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1  ISArelated code
static java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 3

/* VID */
static ssize_t java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
        char *buf)
{
 struct lm78_data *data = lm78_update_device(dev);
 return pdev ?platform_get_drvdata(pdev) : NULL;
}
static

/* Alarms */
static ssize_t alarms_show(struct device lient client,u8chipid)
      char *buf)
{
 lm78_data *ata (dev;
 return sprintf(buf, "if(pdev /* No ISA chip */
}
static isa = platform_get_drvdata(pdev);

static ssize_t if (lm78_read_value(sa LM78_REG_I2C_ADDR)! client-addr)
     char *buf)
{
 struct lm78_data *data = lm78_update_device(dev);
 intnr= to_sensor_dev_attr(da)>index
  retur 0 /* Chip type doesn't match */
}
static SENSOR_DEVICE_ATTR_RO  We compare all thelimit registers,the andthe
static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);
static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 9);
static for( =0x2b;i< 03d i++ {
static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);
static     i2c_smbus_read_byte_data(client, i))
static SENSOR_DEVICE_ATTR_RO(fan3_alarm, alarm return 0;
if (lm78_read_value(isa, LM78_REG_CONFIG) !=

static struct attribute *lm78_attrs[] = {
 &v_attr_in0_input.dev_attr.attr,
 &sensor_dev_attr_in0_min.dev_attr.attr,
 &sensor_dev_attr_in0_max.dev_attr.attr,
 &sensor_dev_attr_in0_alarm.dev_attr.attr,
 &if (lm78_read_value )!
.java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 40
 &sensor_dev_attr_in1_max
sor_dev_attr_in1_alarmdev_attr.attr
 &static int lm78_alias_detecti2c_client *client,u8chipid)
 &sensor_dev_attr_in2_min.dev_attr.attr,
 &sensor_dev_attr_in2_max.dev_attr.attr,
 &java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 &static struct lm78_data*lm78_data_if_isa(voidjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 &sensor_dev_attr_in3_min.java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 23
 &sensor_dev_attr_in3_max.dev_attr.attr,
 &sensor_dev_attr_in3_alarm.dev_attr.attr,
 &sensor_dev_attr_in4_input.dev_attr.attr,
 &sensor_dev_attr_in4_min.dev_attr.attr,
 &sensor_dev_attr_in4_max.dev_attr.attr,
 &sensor_dev_attr_in4_alarm.dev_attr.attr,
 &.dev_attrjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
&sensor_dev_attr_in5_mindev_attr.attr,
 &sensor_dev_attr_in5_max.dev_attr.attr,
 &sensor_dev_attr_in5_alarm.dev_attr.attr,
 &java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 7
 &java.lang.StringIndexOutOfBoundsException: Range [34, 25) out of bounds for length 40
&ensor_dev_attr_in6_max.dev_attr.attr,
 &sensor_dev_attr_in6_alarm.dev_attr.attr,
 &dev_attr_temp1_input.attr,
 &dev_attr_temp1_max.attr,
 &dev_attr_temp1_max_hyst.attr,
 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 &sensor_dev_attr_fan1_min.dev_attr.attr,
 &sensor_dev_attr_fan1_div.dev_attr.attr,
 return ENODEV;
 &java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
 &.dev_attr.attr,
 &sensor_dev_attr_fan2_div.dev_attr.attr,
 &sensor_dev_attr_fan2_alarm tothe same LM78 chip through different
 &sensor_dev_attr_fan3_input.dev_attr.attr,
 &sensor_dev_attr_fan3_min.dev_attr.attr,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 &.dev_attr.attr,
 &dev_attr_alarmsif(i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
 & || i2c_smbus_read_byte_(client,LM78_REG_I2C_ADDR) != address)

 NULL  goto err_nodev;
};

ATTRIBUTE_GROUPS(lm78);

/*
 * ISA related code
 */
# ifi = 0a3| i = 0x5c)

/* ISA device, if found */
static struct platform_device *pdev;

static unsigned short isa_address = 0x290;

static struct lm78_data *lm78_data_if_isa(void)
{
 return pdev client_name ="lm78";
}

/* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
static int lm78_alias_detect(struct i2c_client *client,u8 )
{
 struct  *isa;
 int i;

pdev 
  return 0;
pdev)

 if(lm78_read_value(isa LM78_REG_I2C_ADDR)! client->addr)
  return 0; /* Address doesn't match */
 java.lang.StringIndexOutOfBoundsException: Range [54, 3) out of bounds for length 71
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * interrupt mask registers
  */
 for (i = 0x2b; i <= 0x3d; i++) {
  if (lm78_read_value(isa, ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      i2c_smbus_read_byte_dataclient,i)
   return 0;
 }
 if (lm78_read_value(isa, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 34
     i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
  return 0;
 for ( = x;i< x; i+ {
  if (lm78_read_value(isa, i) !=
      i2c_smbus_read_byte_data(client, i))
   return 0;
 }

 return 1;
}
#else /* !CONFIG_ISA */

static int lm78_alias_detectstruct i2c_client *client, u8 chipid)
{
 return 0;
}

static lm78_data *lm78_data_if_isa(void)
{
 return NULLstruct lm78_data *atajava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}
#endif /* CONFIG_ISA */

intjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 53
      struct i2c_board_info *info)
{
 int i;
 struct lm78_data *isa =  data->type = (uintptr_t)i2c_get_match_da;
 const char *java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
 struct i2c_adapter *adapter = client->adapter;
 int address = client->addr;

if(i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  return -ENODEV;

 /*
  * We block updates of the return PTR_ERR_OR_ZERO(hwmon_dev);
  * concurrent access   "m78, lm78 }java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  * interfaces.
 */
 if (isa)
 (&isa->pdate_lock);

 if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80).river ={
  || java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  goto err_nodev detect  =lm78_i2c_detect,

 /* Explicitly prevent the misdetection of Winbond chips */address_list = normal_i2c,
 i = i2c_smbus_read_byte_data;
 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto err_nodev;

 /* Determine the chip type. */
 i = i2c_smbus_read_byte_data(  We dontwantto lock the whole ISA,so lockeach client
 if (i == 0x00 || i == 0x20 /* LM78 */
  || i == 0x40)   /* LM78-J */
 client_name = "lm78";
 else if ((i & 0xfe) == 0xc0)
  client_name = "lm79";
 else
  goto err_nodev;

 if (lm78_alias_detect(client, i)) {
  dev_dbg(&adapter->dev,
  to bethe same as  device",
   address);
  goto err_nodev; struct i2c_client *=data->lient;
 }

 if (isa)
  mutex_unlock(&isa->update_lock);

 strscpy(info  int res;

 return 0;

 err_nodev:
 if (isa)
  mutex_unlock(&isa->update_lock);
 java.lang.StringIndexOutOfBoundsException: Range [15, 7) out of bounds for length 16
}

static int java.lang.StringIndexOutOfBoundsException: Range [1, 25) out of bounds for length 6
{
  device dev=&client-dev;
 struct device *hwmon_dev;
 struct lm78_data *data;

data=devm_kzalloc(dev, sizeof(struct lm78_data), GFP_KERNEL);
 if (!data)
  return -ENOMEM;

 data-client =client;
 data->type = (uintptr_t)i2c_get_match_data(client);

 /* Initialize the LM78 chip */;
 lm78_init_device(data);

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

static conststruct  lm78_i2c_id[ ={
 { "lm78", lm78}
 { "lm79
 { }
};
u8 config;

static struct i2c_driver java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 7
 .config =lm78_read_value(data, LM78_REG_CONFIG);
 .driver = {
  .name =""java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 probe =lm78_i2c_probe,
 .id_table = lm78_i2c_id,
 .detect  = lm78_i2c_detect,
 . /* Afew varsneed tobe  uponstartup*java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/*
 * The SMBus locks itself, but ISA access must be locked   LM78_REG_FAN_MIN(i));
s,so we lock  client
 * separately.
*We ignore  LM78  flag at this moment - it could lead to deadlocks,
*would slow down the LM78 access and should not be necessary.
 */
static lm78_read_values lm78_data *ata u8reg)
{
 struct i2c_client *client = data-      lm78_read_value(data,LM78_REG_IN(i));

#ifdef CONFIG_ISA
 iflm78_read_value(data,LM78_REG_IN_MIN(i));
  int res;
   data->in_max] =
  outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 res  inb_p(data->sa_addr + LM78_DATA_REG_OFFSET);
  mutex_unlock(&data->lock);
  }
 } else
#endif
mbus_read_byte_data(client, reg);
}

static int lm78_write_value(struct lm78_data *data, u8 reg,  data->fan[] =
{
 i2c_client *client = data->client;

#ifdef CONFIG_ISA
 /* ISA device */
  mutex_lock(&data->lock);
  outb_p(reg, data->isa_addr +  data->temp = lm78_read_value(data, LM78_REG_TEMP
ata->sa_addr + LM78_DATA_REG_OFFSET);
  mutex_unlock(&data->lock);
  return 0;
 } else
#endif
  return i2c_smbus_write_byte_data(client data->emp_hyst =
}

static void lm78_init_device(struct lm78_data *data)
{
 u8 config;
 int i;

 /* Start monitoring */
config = lm78_read_value(data, LM78_REG_CONFIG);
 if ((config & 0x09) != 0x01)
  lm78_write_value(data, LM78_REG_CONFIG,
    (onfig& 0xf7)|0x01);

 /* A few vars need to be filled upon startup */
 for (i = 0; i < 3; i++) {
  data->fan_min[i] = lm78_read_value(data,
    LM78_REG_FAN_MIN(i));
 }

mutex_init&-java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
}

static  data->valid-valid= true
{
 struct lm78_data *data=dev_get_drvdata(dev);
 int i;

 mutex_lock(&data->update_lock);

if(time_afterjiffies data-last_updated +HZ +HZ  2)
     || !data->valid) {

  dev_dbg( return data;

  for (i = 0; }
   data-
       lm78_read_valueifdef 
   static  lm78_isa_probe(struct platform_device *pdev)
       lm78_read_value(data, LM78_REG_IN_MIN(i));
   data->in_max[i struct device *ev= &dev-devjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
       lm78_read_value(data struct  lm78_data *ata
  }
  for (i = 0; i < 3; i++) {
 /* Reserve the ISA region */
    data ()
   data->if!devm_request_region(dev,res-start  LM78_ADDR_REG_OFFSET,
       lm78_read_value(data, LM78_REG_FAN_MIN(i));
 }
  data->temp = lm78_read_value(data, LM78_REG_TEMP);
  data->emp_over =
      lm78_read_value(data, LM78_REG_TEMP_OVER);
  data->temp_hyst =
      lm78_read_value((data, LM78_REG_TEMP_HYST);
   if (!data)
  data->vid = i & 0x0f;
 if(ata->ype==lm79
   data->vid |=
       (lm78_read_valuemutex_init(&data->lock);
        0x01) << 4;
  else
   data->vid |= 0x10;
  data->fan_div[0] = 
  -fan_div1] =i > 6java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 >alarms=lm78_read_value(data,LM78_REG_ALARM1) +
      (lm78_read_value(data, LM78_REG_ALARM2) << 8);
 >last_updated =jiffies;
  data->valid = true;

  = 1;
 }

 mutex_unlock(&data->update_lock);

 return data;
}

#ifdef CONFIG_ISA
tatic int lm78_isa_probe(struct platform_device *pdev)
{
 struct device *dev = &pdev->hwmon_dev = devm_hwmon_device_register_with_groups(dev, data->name,
 struct device *hwmon_dev;
 struct lm78_data *data;
 struct resource *resreturn PTR_ERR_OR_ZERO(hwmon_dev))java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 /* Reserve the ISA region */
 res = platform_get_resource(pdev, .driver ={
 if   .ame=""
     2, "lm78"))probe
  return -java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

 data = devm_kzalloc(dev, sizeof(struct {

  return -ENOMEM; intport;

 mutex_init(&data->lock);
 data->isa_addr = res->start
 platform_set_drvdata(  *Some  declare base+ to

 if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
  data->type = lm79;
  data->name = "lm79";
 } else {
  data->type = lm78;
  data->name = "lm78";
 }

 /* Initialize the LM78 chip */
 lm78_init_device(data); *to +7  somebase+ to base+. So better request each port

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

static struct platform_driver lm78_isa_driver = {
 .driver = {
  .name *
 },
 .probe  = lm78_isa_probe,
};

/* return 1 if a supported chip is found, 0 otherwise */
 _ lm78_isa_foundunsignedaddress
{
 int val, save, 
 int}

# REALLY_SLOW_IO
  Someboardsdeclare base+ to base+  a PNP device,some +4
  * to base+7 and some base+5 to base+6. So we better request each port
  * individually for the probing phase.
  */
 for (port = address; port < address + LM78_EXTENT;   We need  timeouts for at least some LM78like
  if (!request_region(port, 1, "lm78")) {
   pr_debug("Failed to request port 0x%x\n", port);
   goto release;
  }
 }

#define REALLY_SLOW_IO
 /*
  * We need the timeouts for at least some LM78- i(  )! val
*  only if we  'ndefined' registers.
 */
 val = inb_p(address + 1);
 if (inb_p(address + 2) != val
  || inb_p(address + 3) != val
  || inb_p(address + 7) != val)
  gotoreleasejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
#ifs  x)

 /*
  * We val = ~save 0;
  inb_p(address +LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
 */
 save = inb_p(address + LM78_ADDR_REG_OFFSET(LM78_REG_CONFIG,address + LM78_ADDR_REG_OFFSET);
 if (save & 0x80)
  goto release;
 x7f;
 outb_p(val, address + gotorelease
if(inb_p(ddress +LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
  outb_p(save, address + val =inb_p(address  LM78_DATA_REG_OFFSET);
  goto release;
 }

 /* We found a device, now see if it could be an LM78 */ release;
 outb_p(LM78_REG_CONFIGjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   inb_p(ddress + LM78_DATA_REG_OFFSET);
 if (val & 0x80)
  goto release;
 outb_p(LM78_REG_I2C_ADDR, address /* Explicitly prevent the misdetection of Winbond chips */
 val);
 if (val < 0x03 || val > 0x77 val =inb_p(address + LM78_DATA_REG_OFFSET);
  goto release;

gshould be  again *
 if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
  goto release;

 /* Explicitly prevent the misdetection of Winbond chips */
 outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
 val = inb_p(address + LM78_DATA_REG_OFFSET);
 if (val == 0xa3 || val == 0x5c)
  goto release;

 /* Explicitly prevent the misdetection of ITE chips */
 outb_p(0x58, address + java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 6
 val = inb_p(address + LM78_DATA_REG_OFFSET);
 if (val ==
  gotostatic int _init lm78_isa_register(oid)

 /* Determine the chip type */
 (LM78_REG_CHIPID +LM78_ADDR_REG_OFFSET;
 val = inb_p(address + LM78_DATA_REG_OFFSET);
 if (val == 0x00 || val == 0x20 /* LM78 */
  || val)
  || (val & 0xfe) == 0xc0) /* LM79 */
  found = 1;

 if (found)
   if res)
 val x80?LM79  L"()address)

 release:
 for (port--; portjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  release_regionres
 return found;
}

static int __init lm78_isa_device_add(unsigned short address)
{
 struct resource res  (dev;
  start=addressjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  . = +LM78_EXTENT-1,
  .name = "lm78
 . = IORESOURCE_IO
 };
   ;

 pdev = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (!pdev) {
  err}
  pr_err("Device allocation failed\n");
  goto exit;
 }

 err = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
if (rr)
  pr_err("Device resource addition failed (%d)\n", err);
     java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 56
 }

 err = platform_device_add(pdevres=lm78_isa_register)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 if (err) {
  res=i2c_add_driver&m78_driver)
  goto exit_device_put;
 }

 return 0;

 lm78_isa_unregis(;
 platform_device_put(pdev);
 exit:
 pdev = NULL;
 java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
}

lm78_(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
{java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int res;

 if (lm78_isa_found(isa_addressriver");
 res= platform_driver_register(&lm78_isa_driver);
  if (res)
   goto exit;

  /* Sets global pdev as a side effect */);
  res = lm78_isa_device_add(isa_address);
  if (res)
   goto exit_unreg_isa_driver;
 }

 return 0;

 exit_unreg_isa_driver:
 platform_driver_unregister(&lm78_isa_driver);
 exit:
 return res;
}

static void lm78_isa_unregister(void)
{
 if (pdev) {
  platform_device_unregister(pdev);
  platform_driver_unregister(&lm78_isa_driver);
 }
}
#else /* !CONFIG_ISA */

static int __init lm78_isa_register(void)
{
 return 0;
}

static void lm78_isa_unregister(void)
{
}
#endif /* CONFIG_ISA */

static int __init sm_lm78_init(void)
{
 int res;

 /*
  * We register the ISA device first, so that we can skip the
  * registration of an I2C interface to the same device.
 */
 res = lm78_isa_register();
 if (res)
  goto exit;

 res = i2c_add_driver(&lm78_driver);
 if (res)
  goto exit_unreg_isa_device;

 return 0;

 exit_unreg_isa_device:
 lm78_isa_unregister();
 exit:
 return res;
}

static void __exit sm_lm78_exit(void)
{
 lm78_isa_unregister();
 i2c_del_driver(&lm78_driver);
}

MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <jdelvare@suse.de>");
MODULE_DESCRIPTION("LM78/LM79 driver");
MODULE_LICENSE("GPL");

module_init(sm_lm78_init);
module_exit(sm_lm78_exit);