예제 #1
0
파일: max1619.c 프로젝트: OPSF/uClinux
static void max1619_remote_crit(struct i2c_client *client, int operation,
	int ctl_name, int *nrels_mag, long *results)
{
	struct max1619_data *data = client->data;

	if (operation == SENSORS_PROC_REAL_INFO)
		*nrels_mag = 0; /* magnitude */
	else if (operation == SENSORS_PROC_REAL_READ) {
		max1619_update_client(client);
		results[0] = TEMP_FROM_REG(data->remote_max);
		results[1] = TEMP_FROM_REG(data->remote_hyst);
		*nrels_mag = 2;
	} else if (operation == SENSORS_PROC_REAL_WRITE) {
		if (*nrels_mag >= 1) {
			data->remote_max = TEMP_TO_REG(results[0]);
			i2c_smbus_write_byte_data(client,
				MAX1619_REG_W_REMOTE_TMAX, data->remote_max);
		}
		if (*nrels_mag >= 2) {
			data->remote_hyst = TEMP_TO_REG(results[1]);
			i2c_smbus_write_byte_data(client,
				MAX1619_REG_W_REMOTE_THYST, data->remote_hyst);
		}
	}
}
예제 #2
0
/* Return 0 for temp and disallow writes if pin used for in4 */
void sis5595_temp(struct i2c_client *client, int operation, int ctl_name,
		  int *nrels_mag, long *results)
{
	struct sis5595_data *data = client->data;
	if (operation == SENSORS_PROC_REAL_INFO)
		*nrels_mag = 1;
	else if (operation == SENSORS_PROC_REAL_READ) {
		if(data->maxins == 3) {
			sis5595_update_client(client);
			results[0] = TEMP_FROM_REG(data->temp_over);
			results[1] = TEMP_FROM_REG(data->temp_hyst);
			results[2] = TEMP_FROM_REG(data->temp);
		} else {
			results[0] = 0;
			results[1] = 0;
			results[2] = 0;
		}
		*nrels_mag = 3;
	} else if (operation == SENSORS_PROC_REAL_WRITE) {
		if(data->maxins == 3) {
			if (*nrels_mag >= 1) {
				data->temp_over = TEMP_TO_REG(results[0]);
				sis5595_write_value(client,
				    SIS5595_REG_TEMP_OVER, data->temp_over);
			}
			if (*nrels_mag >= 2) {
				data->temp_hyst = TEMP_TO_REG(results[1]);
				sis5595_write_value(client,
				    SIS5595_REG_TEMP_HYST, data->temp_hyst);
			}
		}
	}
}
예제 #3
0
/* Called when we have found a new GL520SM. It should set limits, etc. */
void gl520_init_client(struct i2c_client *client)
{
	/* Power-on defaults (bit 7=1) */
	gl520_write_value(client, GL520_REG_CONF, 0x80);

	/* No noisy output (bit 2=1), Comparator mode (bit 3=0), two fans (bit4=0),
	   standby mode (bit6=0) */
	gl520_write_value(client, GL520_REG_CONF, 0x04);

	/* Never interrupts */
	gl520_write_value(client, GL520_REG_MASK, 0x00);

	gl520_write_value(client, GL520_REG_TEMP1_HYST,
			  TEMP_TO_REG(GL520_INIT_TEMP_HYST));
	gl520_write_value(client, GL520_REG_TEMP1_OVER,
			  TEMP_TO_REG(GL520_INIT_TEMP_OVER));

	/* We set Temp2, but not Vin4. */
	gl520_write_value(client, GL520_REG_TEMP2_HYST,
			  TEMP_TO_REG(GL520_INIT_TEMP_HYST));
	gl520_write_value(client, GL520_REG_TEMP2_OVER,
			  TEMP_TO_REG(GL520_INIT_TEMP_OVER));

	gl520_write_value(client, GL520_REG_MISC, (DIV_TO_REG(2) << 6) |
			  (DIV_TO_REG(2) << 4));
	gl520_write_value(client, GL520_REG_FAN_LIMIT,
			  (FAN_TO_REG(GL520_INIT_FAN_MIN_1, 2) << 8) |
			  FAN_TO_REG(GL520_INIT_FAN_MIN_2, 2));

	gl520_write_value(client, GL520_REG_VIN1_LIMIT,
			  (IN_TO_REG(GL520_INIT_VIN_MAX_1) << 8) |
			  IN_TO_REG(GL520_INIT_VIN_MIN_1));
	gl520_write_value(client, GL520_REG_VIN2_LIMIT,
			  (IN_TO_REG(GL520_INIT_VIN_MAX_2) << 8) |
			  IN_TO_REG(GL520_INIT_VIN_MIN_2));
	gl520_write_value(client, GL520_REG_VIN3_LIMIT,
			  (IN_TO_REG(GL520_INIT_VIN_MAX_3) << 8) |
			  IN_TO_REG(GL520_INIT_VIN_MIN_3));
	gl520_write_value(client, GL520_REG_VDD_LIMIT,
			  (VDD_TO_REG(GL520_INIT_VDD_MAX) << 8) |
			  VDD_TO_REG(GL520_INIT_VDD_MIN));

	/* Clear status register (bit 5=1), start (bit6=1) */
	gl520_write_value(client, GL520_REG_CONF, 0x24);
	gl520_write_value(client, GL520_REG_CONF, 0x44);
}
예제 #4
0
/* Called when we have found a new SIS5595. It should set limits, etc. */
void sis5595_init_client(struct i2c_client *client)
{
	struct sis5595_data *data = client->data;

	/* Reset all except Watchdog values and last conversion values
	   This sets fan-divs to 2, among others */
	sis5595_write_value(client, SIS5595_REG_CONFIG, 0x80);

	sis5595_write_value(client, SIS5595_REG_IN_MIN(0),
			    IN_TO_REG(SIS5595_INIT_IN_MIN_0));
	sis5595_write_value(client, SIS5595_REG_IN_MAX(0),
			    IN_TO_REG(SIS5595_INIT_IN_MAX_0));
	sis5595_write_value(client, SIS5595_REG_IN_MIN(1),
			    IN_TO_REG(SIS5595_INIT_IN_MIN_1));
	sis5595_write_value(client, SIS5595_REG_IN_MAX(1),
			    IN_TO_REG(SIS5595_INIT_IN_MAX_1));
	sis5595_write_value(client, SIS5595_REG_IN_MIN(2),
			    IN_TO_REG(SIS5595_INIT_IN_MIN_2));
	sis5595_write_value(client, SIS5595_REG_IN_MAX(2),
			    IN_TO_REG(SIS5595_INIT_IN_MAX_2));
	sis5595_write_value(client, SIS5595_REG_IN_MIN(3),
			    IN_TO_REG(SIS5595_INIT_IN_MIN_3));
	sis5595_write_value(client, SIS5595_REG_IN_MAX(3),
			    IN_TO_REG(SIS5595_INIT_IN_MAX_3));
	sis5595_write_value(client, SIS5595_REG_FAN_MIN(1),
			    FAN_TO_REG(SIS5595_INIT_FAN_MIN_1, 2));
	sis5595_write_value(client, SIS5595_REG_FAN_MIN(2),
			    FAN_TO_REG(SIS5595_INIT_FAN_MIN_2, 2));
	if(data->maxins == 4) {
		sis5595_write_value(client, SIS5595_REG_IN_MIN(4),
				    IN_TO_REG(SIS5595_INIT_IN_MIN_4));
		sis5595_write_value(client, SIS5595_REG_IN_MAX(4),
				    IN_TO_REG(SIS5595_INIT_IN_MAX_4));
	} else {
		sis5595_write_value(client, SIS5595_REG_TEMP_OVER,
				    TEMP_TO_REG(SIS5595_INIT_TEMP_OVER));
		sis5595_write_value(client, SIS5595_REG_TEMP_HYST,
				    TEMP_TO_REG(SIS5595_INIT_TEMP_HYST));
	}

	/* Start monitoring */
	sis5595_write_value(client, SIS5595_REG_CONFIG,
			    (sis5595_read_value(client, SIS5595_REG_CONFIG)
			     & 0xf7) | 0x01);

}
예제 #5
0
static void set_temp_high(struct device *dev, const char *buf, int nr)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lm87_data *data = i2c_get_clientdata(client);
	long val = simple_strtol(buf, NULL, 10);

	mutex_lock(&data->update_lock);
	data->temp_high[nr] = TEMP_TO_REG(val);
	lm87_write_value(client, LM87_REG_TEMP_HIGH[nr], data->temp_high[nr]);
	mutex_unlock(&data->update_lock);
}
예제 #6
0
파일: lm78.c 프로젝트: 285452612/ali_kernel
static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
			     const char *buf, size_t count)
{
	struct lm78_data *data = dev_get_drvdata(dev);
	long val = simple_strtol(buf, NULL, 10);

	mutex_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;
}
예제 #7
0
static ssize_t set_temp1_crit_hyst(struct device *dev, struct device_attribute *attr, const char *buf,
	size_t count)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lm92_data *data = i2c_get_clientdata(client);
	long val = simple_strtol(buf, NULL, 10);

	mutex_lock(&data->update_lock);
	data->temp1_hyst = TEMP_FROM_REG(data->temp1_crit) - val;
	i2c_smbus_write_word_data(client, LM92_REG_TEMP_HYST,
				  swab16(TEMP_TO_REG(data->temp1_hyst)));
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #8
0
static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct gl520_data *data = i2c_get_clientdata(client);
	int n = to_sensor_dev_attr(attr)->index;
	long v = simple_strtol(buf, NULL, 10);

	mutex_lock(&data->update_lock);
	data->temp_max[n] = TEMP_TO_REG(v);
	gl520_write_value(client, GL520_REG_TEMP_MAX[n], data->temp_max[n]);
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #9
0
파일: adm1025.c 프로젝트: CSCLOG/beaglebone
static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
	const char *buf, size_t count)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct i2c_client *client = to_i2c_client(dev);
	struct adm1025_data *data = i2c_get_clientdata(client);
	long val = simple_strtol(buf, NULL, 10);

	mutex_lock(&data->update_lock);
	data->temp_max[index] = TEMP_TO_REG(val);
	i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_HIGH(index),
				  data->temp_max[index]);
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #10
0
static ssize_t set_temp(struct device *dev, struct device_attribute *devattr,
			const char *buf, size_t count)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct i2c_client *client = to_i2c_client(dev);
	struct lm83_data *data = i2c_get_clientdata(client);
	long val = simple_strtol(buf, NULL, 10);
	int nr = attr->index;

	mutex_lock(&data->update_lock);
	data->temp[nr] = TEMP_TO_REG(val);
	i2c_smbus_write_byte_data(client, LM83_REG_W_HIGH[nr - 4],
				  data->temp[nr]);
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #11
0
파일: lm78.c 프로젝트: AiWinters/linux
static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
			     const char *buf, size_t count)
{
	struct lm78_data *data = dev_get_drvdata(dev);
	long val;
	int err;

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

	mutex_lock(&data->update_lock);
	data->temp_over = TEMP_TO_REG(val);
	lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #12
0
파일: lm92.c 프로젝트: GDGroup/linux
static ssize_t set_temp(struct device *dev, struct device_attribute *devattr,
			   const char *buf, size_t count)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct lm92_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	int nr = attr->index;
	long val;
	int err;
	
	err = kstrtol(buf, 10, &val);
	if (err)
		return err;

	mutex_lock(&data->update_lock);
	data->temp[nr] = TEMP_TO_REG(val);
	i2c_smbus_write_word_swapped(client, regs[nr], data->temp[nr]);
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #13
0
파일: adm1025.c 프로젝트: MohdVara/linux
static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
	const char *buf, size_t count)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1025_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	long val;
	int err;

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

	mutex_lock(&data->update_lock);
	data->temp_max[index] = TEMP_TO_REG(val);
	i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_HIGH(index),
				  data->temp_max[index]);
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #14
0
static ssize_t set_temp1_crit_hyst(struct device *dev,
				   struct device_attribute *attr,
				   const char *buf, size_t count)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lm92_data *data = i2c_get_clientdata(client);
	long val;
	int err;

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

	mutex_lock(&data->update_lock);
	data->temp1_hyst = TEMP_FROM_REG(data->temp1_crit) - val;
	i2c_smbus_write_word_swapped(client, LM92_REG_TEMP_HYST,
				     TEMP_TO_REG(data->temp1_hyst));
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #15
0
static ssize_t set_temp_max_hyst(struct device *dev, struct device_attribute
				 *attr, const char *buf, size_t count)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct gl520_data *data = i2c_get_clientdata(client);
	int n = to_sensor_dev_attr(attr)->index;
	long v;
	int err;

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

	mutex_lock(&data->update_lock);
	data->temp_max_hyst[n] = TEMP_TO_REG(v);
	gl520_write_value(client, GL520_REG_TEMP_MAX_HYST[n],
			  data->temp_max_hyst[n]);
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #16
0
static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
		const char *buf, size_t count)
{
	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
	int nr = sensor_attr->index;
	struct smsc47m192_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	long val;
	int err;

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

	mutex_lock(&data->update_lock);
	data->temp_max[nr] = TEMP_TO_REG(val);
	i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MAX[nr],
						data->temp_max[nr]);
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #17
0
파일: lm92.c 프로젝트: GDGroup/linux
static ssize_t set_temp_hyst(struct device *dev,
			     struct device_attribute *devattr,
			     const char *buf, size_t count)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
	struct lm92_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	long val;
	int err;

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

	mutex_lock(&data->update_lock);
	data->temp[t_hyst] = TEMP_FROM_REG(data->temp[attr->index]) - val;
	i2c_smbus_write_word_swapped(client, LM92_REG_TEMP_HYST,
				     TEMP_TO_REG(data->temp[t_hyst]));
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #18
0
static ssize_t set_temp_offset(struct device *dev, struct device_attribute
		*attr, const char *buf, size_t count)
{
	struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
	int nr = sensor_attr->index;
	struct smsc47m192_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;
	u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
	long val;
	int err;

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

	mutex_lock(&data->update_lock);
	data->temp_offset[nr] = TEMP_TO_REG(val);
	if (nr > 1)
		i2c_smbus_write_byte_data(client,
			SMSC47M192_REG_TEMP_OFFSET(nr), data->temp_offset[nr]);
	else if (data->temp_offset[nr] != 0) {
		/*
		 * offset[0] and offset[1] share the same register,
		 * SFR bit 4 activates offset[0]
		 */
		i2c_smbus_write_byte_data(client, SMSC47M192_REG_SFR,
					(sfr & 0xef) | (nr == 0 ? 0x10 : 0));
		data->temp_offset[1-nr] = 0;
		i2c_smbus_write_byte_data(client,
			SMSC47M192_REG_TEMP_OFFSET(nr), data->temp_offset[nr]);
	} else if ((sfr & 0x10) == (nr == 0 ? 0x10 : 0))
		i2c_smbus_write_byte_data(client,
					SMSC47M192_REG_TEMP_OFFSET(nr), 0);
	mutex_unlock(&data->update_lock);
	return count;
}
예제 #19
0
/* Called when we have found a new MTP008. It should set limits, etc. */
void mtp008_init_client(struct i2c_client *client)
{
	int vid;
	u8 save1, save2;
	struct mtp008_data *data;

	data = client->data;

	/*
	 * Initialize the Myson MTP008 hardware monitoring chip.
	 * Save the pin settings that the BIOS hopefully set.
	 */
	save1 = mtp008_read_value(client, MTP008_REG_PIN_CTRL1);
	save2 = mtp008_read_value(client, MTP008_REG_PIN_CTRL2);
	mtp008_write_value(client, MTP008_REG_CONFIG,
	     (mtp008_read_value(client, MTP008_REG_CONFIG) & 0x7f) | 0x80);
	mtp008_write_value(client, MTP008_REG_PIN_CTRL1, save1);
	mtp008_write_value(client, MTP008_REG_PIN_CTRL2, save2);

	mtp008_getsensortype(data, save2);

	/*
	 * Retrieve the VID setting (needed for the default limits).
	 */
	vid = mtp008_read_value(client, MTP008_REG_VID_FANDIV) & 0x0f;
	vid |= (mtp008_read_value(client, MTP008_REG_RESET_VID4) & 0x01) << 4;
	vid = VID_FROM_REG(vid);

	/*
	 * Set the default limits.
	 *
	 * Setting temp sensors is done as follows:
	 *
	 *          Register 0x57: 0 0 0 0 x x x x
	 *                                 | \ / +-- AIN5/VT3
	 *                                 |  +----- AIN4/VT2/PII
	 *                                 +-------- VT1/PII
	 */

	mtp008_write_value(client, MTP008_REG_IN_MAX(0),
			   IN_TO_REG(MTP008_INIT_IN_MAX_0));
	mtp008_write_value(client, MTP008_REG_IN_MIN(0),
			   IN_TO_REG(MTP008_INIT_IN_MIN_0));
	mtp008_write_value(client, MTP008_REG_IN_MAX(1),
			   IN_TO_REG(MTP008_INIT_IN_MAX_1));
	mtp008_write_value(client, MTP008_REG_IN_MIN(1),
			   IN_TO_REG(MTP008_INIT_IN_MIN_1));
	mtp008_write_value(client, MTP008_REG_IN_MAX(2),
			   IN_TO_REG(MTP008_INIT_IN_MAX_2));
	mtp008_write_value(client, MTP008_REG_IN_MIN(2),
			   IN_TO_REG(MTP008_INIT_IN_MIN_2));
	mtp008_write_value(client, MTP008_REG_IN_MAX(3),
			   IN_TO_REG(MTP008_INIT_IN_MAX_3));
	mtp008_write_value(client, MTP008_REG_IN_MIN(3),
			   IN_TO_REG(MTP008_INIT_IN_MIN_3));

	mtp008_write_value(client, MTP008_REG_IN_MAX(5),
			   IN_TO_REG(MTP008_INIT_IN_MAX_5));
	mtp008_write_value(client, MTP008_REG_IN_MIN(5),
			   IN_TO_REG(MTP008_INIT_IN_MIN_5));
	mtp008_write_value(client, MTP008_REG_IN_MAX(6),
			   IN_TO_REG(MTP008_INIT_IN_MAX_6));
	mtp008_write_value(client, MTP008_REG_IN_MIN(6),
			   IN_TO_REG(MTP008_INIT_IN_MIN_6));

	mtp008_write_value(client, MTP008_REG_TEMP_MAX,
			   TEMP_TO_REG(MTP008_INIT_TEMP_OVER));
	mtp008_write_value(client, MTP008_REG_TEMP_MIN,
			   TEMP_TO_REG(MTP008_INIT_TEMP_HYST));
	mtp008_write_value(client, MTP008_REG_IN_MAX(4),
			   TEMP_TO_REG(MTP008_INIT_TEMP2_OVER));
	mtp008_write_value(client, MTP008_REG_IN_MIN(4),
			   TEMP_TO_REG(MTP008_INIT_TEMP2_HYST));

	mtp008_write_value(client, MTP008_REG_FAN_MIN(1),
			   FAN_TO_REG(MTP008_INIT_FAN_MIN_1, 2));
	mtp008_write_value(client, MTP008_REG_FAN_MIN(2),
			   FAN_TO_REG(MTP008_INIT_FAN_MIN_2, 2));
	mtp008_write_value(client, MTP008_REG_FAN_MIN(3),
			   FAN_TO_REG(MTP008_INIT_FAN_MIN_3, 2));

	/*
	 * Start monitoring.
	 */
	mtp008_write_value(
		client, MTP008_REG_CONFIG,
		(mtp008_read_value(client, MTP008_REG_CONFIG) & 0xf7) | 0x01
	);
}