* Re: [lm-sensors] Working on adt7475 driver
2007-10-05 8:09 [lm-sensors] Working on adt7475 driver Hans de Goede
` (4 preceding siblings ...)
2007-11-27 17:10 ` Juerg Haefliger
@ 2007-12-18 10:24 ` Hans de Goede
2007-12-18 17:39 ` Jean Delvare
2007-12-19 21:28 ` Jordan Crouse
7 siblings, 0 replies; 9+ messages in thread
From: Hans de Goede @ 2007-12-18 10:24 UTC (permalink / raw)
To: lm-sensors
[-- Attachment #1: Type: text/plain, Size: 1230 bytes --]
Juerg Haefliger wrote:
> Hi Hans,
>
>
> On Nov 16, 2007 12:29 AM, Hans de Goede <j.w.r.degoede@hhs.nl> wrote:
>> Juerg Haefliger wrote:
>>> Hi Hans,
>>>
>>> Are your students in fact working on this driver? I ordered some
>>> samples of the ADT7475 & ADT7476 and could slap together a demo board
>>> and start working on a driver.
>>>
>> Yes,
>>
>> They are actually working on this, still a demo bord would be good, as on the
>> motherboard they are using for testing (Asus M2N SLI Deluxe) it is the second
>> hwmon chip, mainly used to monitor and control additional fans.
>>
>> I'll ask them to send what they have sofar my way and I'll send it to you, I'll
>> see them again coming wednesday.
>
> OK I have a demo board with an ADT7476 ready. Whenever there's a
> driver ready that I can play around with, let me know. I have some
> other things I'm currently working on so no pressure.
>
I'm afraid that the motherboard used by the student has broken down somehow, so
they can no longer continue their work. I've attached their latest wip, perhaps
that can come in handy for you when working on a driver. The motherboard has
been send in for repair once it returns I can use it for testing your work.
Regards,
Hans
[-- Attachment #2: adt7475.c --]
[-- Type: text/x-csrc, Size: 25957 bytes --]
/*
* adt7475.c - Part of lm_sensors, Linux kernel modules for hardware
* monitoring
* Copyright (C) 2007 Hans de Goede <j.w.r.degoede@hhs.nl>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
* New merged Fujitsu Siemens hwmon driver, supporting the Poseidon, Hermes,
* Scylla, Hercules and Heimdall chips
*
* Based on the original 2.4 fscscy, 2.6 fscpos, 2.6 fscher and 2.6
* (candidate) fschmd drivers:
* Copyright (C) 2006 Thilo Cestonaro <thilo.cestonaro.external@fujitsu-siemens.com>
* Copyright (C) 2003, 2004 Reinhard Nissl <rnissl@gmx.de>
* Copyright (C) 2000 Hermann Jung <hej@odn.de>
* Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
* and Philip Edelbrock <phil@netroedge.com>
*/
#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/err.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
/* Addresses to scan */
static unsigned short normal_i2c[] = { 0x2e, I2C_CLIENT_END };
/* Insmod parameters */
I2C_CLIENT_INSMOD_1(adt7475);
/* voltage supervision */
#define ADT7475_REG_IN_HIGH(nr) (0x21 + (nr))
#define ADT7475_REG_IN_LOW 0x76
/* voltage low, high limit registers */
#define ADT7475_REG_IN_LOW_LIMIT(nr) (0x46 + 2 * (nr))
#define ADT7475_REG_IN_HIGH_LIMIT(nr) (0x47 + 2 * (nr))
/* actual fan speed */
#define ADT7475_REG_FAN_ACT_LOW(nr) (0x28 + 2 * (nr))
#define ADT7475_REG_FAN_ACT_HIGH(nr) (0x29 + 2 * (nr))
/* ??? fan status registers */
static const u8 ADT7475_REG_FAN_STATE[1] = {1};
/* ??? fan ripple / divider registers */
static const u8 ADT7475_REG_FAN_RIPPLE[1] = {1};
/* fan low, high limit registers */
#define ADT7475_REG_FAN_LOW_LIMIT(nr) (0x54 + 2 * (nr))
#define ADT7475_REG_FAN_HIGH_LIMIT(nr) (0x55 + 2 * (nr))
/* fan puls register */
#define ADT7475_REG_FAN_PULS 0x7B
/* actual temperature registers */
#define ADT7475_REG_TEMP_ACT(nr) (0x25 + (nr))
#define ADT7475_REG_TEMP_LOW 0x77
/* temperature offset registers, NOTE only for twocomplement-mode*/
#define ADT7475_REG_TEMP_OFFSET(nr) (0x70 + (nr))
/* ??? temperature state registers */
#define ADT7475_REG_TEMP_STATE(nr) (0x25 + (nr))
/* temperature low, high limit registers */
#define ADT7475_REG_TEMP_LOW_LIMIT(nr) (0x4E + 2 * (nr))
#define ADT7475_REG_TEMP_HIGH_LIMIT(nr) (0x4F + 2 * (nr))
/* (Interrupt) status registers */
#define ADT7475_REG_INTR_STATUS(nr) (0x41 + (nr))
/* Interrupt mask registers */
#define ADT7475_REG_INTR_MASK(nr) (0x74 + (nr))
/* Configuration Registers */
static const u8 ADT7475_REG_CONFIG[7] = {0x40, 0x73, 0x78, 0x7D, 0x7C, 0x10, 0x11};
/* name */
#define ADT7475_NAME "adt7475"
/*
* Functions declarations
*/
static int adt7475_attach_adapter(struct i2c_adapter *adapter);
static int adt7475_detach_client(struct i2c_client *client);
static struct adt7475_data *adt7475_update_device(struct device *dev);
/*
* Driver data (common to all clients)
*/
static struct i2c_driver adt7475_driver = {
.driver = {
.name = ADT7475_NAME,
},
.attach_adapter = adt7475_attach_adapter,
.detach_client = adt7475_detach_client,
};
/*
* Client data (each client gets its own)
*/
struct adt7475_data {
enum chips kind;
struct i2c_client client;
struct class_device *class_dev;
struct mutex update_lock;
char valid; /* zero until following fields are valid */
unsigned long last_updated; /* in jiffies */
/* register values */
u8 global_control; /* ??? global control register */
u16 in[2]; /* voltage */
u8 in_max[2]; /* high voltage limit */
u8 in_min[2]; /* low voltage limit */
u16 temp_act[3]; /* temperature 10 bit */
u8 temp_status[3]; /* ??? status of sensor */
u8 config[7]; /* Configuration Register 1-7*/
u8 temp_max[3]; /* high temp limit */
u8 temp_min[3]; /* low temp limit */
u16 fan_act[4]; /* fans revolutions per second */
u8 fan_status[4]; /* ??? fan status */
u8 fan_min[4]; /* fan min value for rps */
u8 fan_max[4]; /* fan max value for rps */
u8 fan_ripple[4]; /* ??? divider for rps */
u8 intr_status[2]; /* Interrupt status registers 1+2 */
};
/*
* Sysfs attr show / store functions
*/
static ssize_t show_in_value(struct device *dev, struct device_attribute *devattr, char *buf)
{
const int factor[2] = {293, 420};
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
return sprintf(buf, "%d\n", (data->in[attr->index] * factor[attr->index]) / 10);
}
static ssize_t show_in_max(struct device *dev, struct device_attribute *devattr, char *buf)
{
const int factor[2] = {293, 420};
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
return sprintf(buf, "%d\n", (data->in_max[attr->index] * factor[attr->index]) / 10 );
}
static ssize_t store_in_max(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = i2c_get_clientdata(to_i2c_client(dev));
long v = simple_strtol(buf, NULL, 10) / 1000;
v = SENSORS_LIMIT(v, -128, 127);
v += 128;
mutex_lock(&data->update_lock);
i2c_smbus_write_byte_data(&data->client, ADT7475_REG_IN_HIGH_LIMIT(attr->index), v);
data->in_max[attr->index] = v;
mutex_unlock(&data->update_lock);
return count;
}
static ssize_t show_in_min(struct device *dev, struct device_attribute *devattr, char *buf)
{
const int factor[2] = {293, 420};
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
return sprintf(buf, "%d\n", (data->in_min[attr->index] * factor[attr->index]) / 10 );
}
static ssize_t store_in_min(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = i2c_get_clientdata(to_i2c_client(dev));
long v = simple_strtol(buf, NULL, 10) / 1000;
v = SENSORS_LIMIT(v, -128, 127);
v += 128;
mutex_lock(&data->update_lock);
i2c_smbus_write_byte_data(&data->client, ADT7475_REG_IN_LOW_LIMIT(attr->index), v);
data->in_min[attr->index] = v;
mutex_unlock(&data->update_lock);
return count;
}
#define TEMP_FROM_REG_TWOSCOMPLEMENT_8(val) ((((val) & 0x80) ? (((val) & 0x01FF) - 128) : ((val) & 0x01FF)) * 1000)
#define TEMP_FROM_REG_EXTENDED(val) (((val) - 256) * 250)
#define TEMP_FROM_REG_TWOSCOMPLEMENT_10(val) ((((val) & 0x0200) ? (((val) & 0x01FF) - 512) : ((val) & 0x01FF)) * 250)
static ssize_t show_temp_value(struct device *dev, struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
if(data->config[4] & 0x01) return sprintf(buf, "%d\n", TEMP_FROM_REG_TWOSCOMPLEMENT_10(data->temp_act[attr->index]));
else return sprintf(buf, "%d\n", TEMP_FROM_REG_EXTENDED(data->temp_act[attr->index]));
}
static ssize_t show_temp_max(struct device *dev, struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
return sprintf(buf, "%d\n", TEMP_FROM_REG_TWOSCOMPLEMENT_8( data->temp_max[attr->index]));
}
static ssize_t store_temp_max(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = i2c_get_clientdata(to_i2c_client(dev));
long v = simple_strtol(buf, NULL, 10) / 1000;
v = SENSORS_LIMIT(v, -128, 127);
v += 128;
mutex_lock(&data->update_lock);
i2c_smbus_write_byte_data(&data->client, ADT7475_REG_TEMP_HIGH_LIMIT(attr->index), v);
data->temp_max[attr->index] = v;
mutex_unlock(&data->update_lock);
return count;
}
static ssize_t show_temp_min(struct device *dev, struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
return sprintf(buf, "%d\n", TEMP_FROM_REG_TWOSCOMPLEMENT_8( data->temp_min[attr->index]));
}
static ssize_t store_temp_min(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = i2c_get_clientdata(to_i2c_client(dev));
long v = simple_strtol(buf, NULL, 10) / 1000;
v = SENSORS_LIMIT(v, -128, 127);
v += 128;
mutex_lock(&data->update_lock);
i2c_smbus_write_byte_data(&data->client, ADT7475_REG_TEMP_LOW_LIMIT(attr->index), v);
data->temp_min[attr->index] = v;
mutex_unlock(&data->update_lock);
return count;
}
static ssize_t show_temp_fault(struct device *dev, struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
u8 mask = 0x40 << attr->index;
return sprintf(buf, "%d\n", ((data->intr_status[1] & mask) != 0));
}
/*
static ssize_t show_temp_fault(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct fschmd_data *data = fschmd_update_device(dev);
*//* bit 0 set means sensor working ok, so no fault! *//*
if (data->temp_status[attr->index] & 0x01)
return sprintf(buf, "0\n");
else
return sprintf(buf, "1\n");
}
static ssize_t show_temp_alarm(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct fschmd_data *data = fschmd_update_device(dev);
*//* only signal an alarm if the sensor is working and alert == 1 *//*
if ((data->temp_status[attr->index] & 0x03) == 0x03)
return sprintf(buf, "1\n");
else
return sprintf(buf, "0\n");
}
*/
#define RPM_FROM_REG(val) (val == 0xFFFF) ? 0 : ((90000*60)/(val))
static ssize_t show_fan_value(struct device *dev, struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
return sprintf(buf, "%d\n", RPM_FROM_REG(data->fan_act[attr->index]));
}
static ssize_t show_fan_max(struct device *dev, struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
return sprintf(buf, "%d\n", data->fan_max[attr->index]);
}
static ssize_t store_fan_max(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = i2c_get_clientdata(to_i2c_client(dev));
long v = simple_strtol(buf, NULL, 10) / 1000;
v = SENSORS_LIMIT(v, -128, 127);
v += 128;
mutex_lock(&data->update_lock);
i2c_smbus_write_byte_data(&data->client, ADT7475_REG_FAN_HIGH_LIMIT(attr->index), v);
data->fan_max[attr->index] = v;
mutex_unlock(&data->update_lock);
return count;
}
static ssize_t show_fan_min(struct device *dev, struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
return sprintf(buf, "%d\n", data->fan_min[attr->index]);
}
static ssize_t store_fan_min(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = i2c_get_clientdata(to_i2c_client(dev));
long v = simple_strtol(buf, NULL, 10) / 1000;
v = SENSORS_LIMIT(v, -128, 127);
v += 128;
mutex_lock(&data->update_lock);
i2c_smbus_write_byte_data(&data->client, ADT7475_REG_FAN_LOW_LIMIT(attr->index), v);
data->fan_min[attr->index] = v;
mutex_unlock(&data->update_lock);
return count;
}
static ssize_t show_fan_fault(struct device *dev, struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct adt7475_data *data = adt7475_update_device(dev);
u8 mask = 0x02 << attr->index;
return sprintf(buf, "%d\n", (data->config[1] & mask));
}
/*
static ssize_t show_fan_div(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct fschmd_data *data = fschmd_update_device(dev);
*//* bits 2..7 reserved => mask with 3 *//*
return sprintf(buf, "%d\n", 1 << (data->fan_ripple[attr->index] & 3));
}
static ssize_t store_fan_div(struct device *dev, struct device_attribute
*devattr, const char *buf, size_t count)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct fschmd_data *data = fschmd_update_device(dev);
*//* supported values: 2, 4, 8 *//*
unsigned long v = simple_strtoul(buf, NULL, 10);
switch (v) {
case 2: v = 1; break;
case 4: v = 2; break;
case 8: v = 3; break;
default:
dev_err(&data->client.dev, "fan_div value %lu not "
"supported. Choose one of 2, 4 or 8!\n", v);
return -EINVAL;
}
mutex_lock(&data->update_lock);
*//* bits 2..7 reserved => mask with 0x03 *//*
data->fan_ripple[attr->index] &= ~0x03;
data->fan_ripple[attr->index] |= v;
i2c_smbus_write_byte_data(&data->client,
FSCHMD_REG_FAN_RIPPLE[data->kind][attr->index],
data->fan_ripple[attr->index]);
mutex_unlock(&data->update_lock);
return count;
}
static ssize_t show_fan_alarm(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct fschmd_data *data = fschmd_update_device(dev);
if (data->fan_status[attr->index] & 0x04)
return sprintf(buf, "1\n");
else
return sprintf(buf, "0\n");
}
static ssize_t show_pwm_auto_point1_pwm(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
int val = fschmd_update_device(dev)->fan_min[attr->index];
*//* 0 = allow turning off, 1-255 = 50-100% *//*
if (val)
val = val / 2 + 128;
return sprintf(buf, "%d\n", val);
}
static ssize_t store_pwm_auto_point1_pwm(struct device *dev,
struct device_attribute *devattr, const char *buf, size_t count)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
struct fschmd_data *data = i2c_get_clientdata(to_i2c_client(dev));
unsigned long v = simple_strtoul(buf, NULL, 10);
*//* register: 0 = allow turning off, 1-255 = 50-100% *//*
if (v) {
SENSORS_LIMIT(v, 128, 255);
v = (v - 128) * 2 + 1;
}
mutex_lock(&data->update_lock);
i2c_smbus_write_byte_data(&data->client,
FSCHMD_REG_FAN_MIN[data->kind][attr->index], v);
data->fan_min[attr->index] = v;
mutex_unlock(&data->update_lock);
return count;
}
*/
/* The FSC hwmon family has the ability to force an attached alert led to flash
from software, we export this as an alert_led sysfs attr */
/*static ssize_t show_alert_led(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct fschmd_data *data = fschmd_update_device(dev);
if (data->global_control & 0x01)
return sprintf(buf, "1\n");
else
return sprintf(buf, "0\n");
}
static ssize_t store_alert_led(struct device *dev,
struct device_attribute *devattr, const char *buf, size_t count)
{
struct fschmd_data *data = fschmd_update_device(dev);
unsigned long v = simple_strtoul(buf, NULL, 10);
mutex_lock(&data->update_lock);
if (v)
data->global_control |= 0x01;
else
data->global_control &= ~0x01;
i2c_smbus_write_byte_data(&data->client, FSCHMD_REG_CONTROL, v);
mutex_unlock(&data->update_lock);
return count;
}*/
static struct sensor_device_attribute adt7475_in_attr[] = {
SENSOR_ATTR(in0_input, 0444, show_in_value, NULL, 0),
SENSOR_ATTR(in0_min, 0644, show_in_min, store_in_min, 0),
SENSOR_ATTR(in0_max, 0644, show_in_max, store_in_max, 0),
SENSOR_ATTR(in0_fault, 0444, show_in_fault, NULL, 0),
SENSOR_ATTR(in1_input, 0444, show_in_value, NULL, 1),
SENSOR_ATTR(in1_min, 0644, show_in_min, store_in_min, 1),
SENSOR_ATTR(in1_max, 0644, show_in_max, store_in_max, 1),
SENSOR_ATTR(in1_fault, 0444, show_in_fault, NULL, 1),
//SENSOR_ATTR(alert_led, 0644, show_alert_led, store_alert_led, 0),
};
static struct sensor_device_attribute adt7475_temp_attr[] = {
SENSOR_ATTR(temp1_input, 0444, show_temp_value, NULL, 0),
SENSOR_ATTR(temp1_min, 0644, show_temp_min, store_temp_min, 0),
SENSOR_ATTR(temp1_max, 0644, show_temp_max, store_temp_max, 0),
//SENSOR_ATTR(temp1_fault, 0444, show_temp_fault, NULL, 0),
//SENSOR_ATTR(temp1_alarm, 0444, show_temp_alarm, NULL, 0),
SENSOR_ATTR(temp2_input, 0444, show_temp_value, NULL, 1),
SENSOR_ATTR(temp2_min, 0644, show_temp_min, store_temp_min, 1),
SENSOR_ATTR(temp2_max, 0644, show_temp_max, store_temp_max, 1),
//SENSOR_ATTR(temp2_fault, 0444, show_temp_fault, NULL, 1),
//SENSOR_ATTR(temp2_alarm, 0444, show_temp_alarm, NULL, 1),
SENSOR_ATTR(temp3_input, 0444, show_temp_value, NULL, 2),
SENSOR_ATTR(temp3_min, 0644, show_temp_min, store_temp_min, 2),
SENSOR_ATTR(temp3_max, 0644, show_temp_max, store_temp_max, 2),
//SENSOR_ATTR(temp3_fault, 0444, show_temp_fault, NULL, 2),
//SENSOR_ATTR(temp3_alarm, 0444, show_temp_alarm, NULL, 2),
};
static struct sensor_device_attribute adt7475_fan_attr[] = {
SENSOR_ATTR(fan1_input, 0444, show_fan_value, NULL, 0),
SENSOR_ATTR(fan1_min, 0644, show_fan_min, store_fan_min, 0),
SENSOR_ATTR(fan1_max, 0644, show_fan_max, store_fan_max, 0),
//SENSOR_ATTR(fan1_div, 0644, show_fan_div, store_fan_div, 0),
//SENSOR_ATTR(fan1_alarm, 0444, show_fan_alarm, NULL, 0),
//SENSOR_ATTR(pwm1_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm, store_pwm_auto_point1_pwm, 0),
SENSOR_ATTR(fan2_input, 0444, show_fan_value, NULL, 1),
SENSOR_ATTR(fan2_min, 0644, show_fan_min, store_fan_min, 1),
SENSOR_ATTR(fan2_max, 0644, show_fan_max, store_fan_max, 1),
//SENSOR_ATTR(fan2_div, 0644, show_fan_div, store_fan_div, 1),
//SENSOR_ATTR(fan2_alarm, 0444, show_fan_alarm, NULL, 1),
//SENSOR_ATTR(pwm2_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,store_pwm_auto_point1_pwm, 1),
SENSOR_ATTR(fan3_input, 0444, show_fan_value, NULL, 2),
SENSOR_ATTR(fan3_min, 0644, show_fan_min, store_fan_min, 2),
SENSOR_ATTR(fan3_max, 0644, show_fan_max, store_fan_max, 2),
//SENSOR_ATTR(fan3_div, 0644, show_fan_div, store_fan_div, 2),
//SENSOR_ATTR(fan3_alarm, 0444, show_fan_alarm, NULL, 2),
//SENSOR_ATTR(pwm3_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm, store_pwm_auto_point1_pwm, 2),
SENSOR_ATTR(fan4_input, 0444, show_fan_value, NULL, 3),
SENSOR_ATTR(fan4_min, 0644, show_fan_min, store_fan_min, 3),
SENSOR_ATTR(fan4_max, 0644, show_fan_max, store_fan_max, 3),
//SENSOR_ATTR(fan4_div, 0644, show_fan_div, store_fan_div, 3),
//SENSOR_ATTR(fan4_alarm, 0444, show_fan_alarm, NULL, 3),
//SENSOR_ATTR(pwm4_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,store_pwm_auto_point1_pwm, 3),
};
/*
* Real code
*/
static int adt7475_detect(struct i2c_adapter *adapter, int address, int kind)
{
struct i2c_client *new_client;
struct adt7475_data *data;
u8 revision;
int i, err = 0;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return 0;
/* OK. For now, we presume we have a valid client. We now create the
* client structure, even though we cannot fill it completely yet.
* But it allows us to access i2c_smbus_read_byte_data. */
if (!(data = kzalloc(sizeof(struct adt7475_data), GFP_KERNEL)))
return -ENOMEM;
/* The common I2C client data is placed right before the
* Poseidon-specific data. */
new_client = &data->client;
i2c_set_clientdata(new_client, data);
new_client->addr = address;
new_client->adapter = adapter;
new_client->driver = &adt7475_driver;
new_client->flags = 0;
strlcpy(new_client->name, ADT7475_NAME, I2C_NAME_SIZE);
data->valid = 0;
mutex_init(&data->update_lock);
/* i2c kind goes from 1-4, we want from 0-3 to address arrays */
data->kind = kind - 1;
/* Tell the I2C layer a new client has arrived */
if ((err = i2c_attach_client(new_client)))
goto exit_free;
/* Add attributes */
for(i = 0; i < ARRAY_SIZE(adt7475_in_attr); ++i)
{
err = device_create_file(&new_client->dev, &adt7475_in_attr[i].dev_attr);
if (err) goto exit_remove_files;
}
for(i = 0; i < ARRAY_SIZE(adt7475_temp_attr); ++i)
{
err = device_create_file(&new_client->dev, &adt7475_temp_attr[i].dev_attr);
if (err) goto exit_remove_files;
}
for(i = 0; i < ARRAY_SIZE(adt7475_fan_attr); ++i)
{
err = device_create_file(&new_client->dev,&adt7475_fan_attr[i].dev_attr);
if (err) goto exit_remove_files;
}
data->class_dev = hwmon_device_register(&new_client->dev);
if (IS_ERR(data->class_dev)) {
err = PTR_ERR(data->class_dev);
goto exit_remove_files;
}
// ??? revision = i2c_smbus_read_byte_data(new_client, ADT7475_REG_REVISION);
printk(KERN_INFO "adt7475: Detected adt7475 chip\n");
return 0;
exit_remove_files:
for(i = 0; i < ARRAY_SIZE(adt7475_in_attr); ++i) device_remove_file(&new_client->dev, &adt7475_in_attr[i].dev_attr);
for(i = 0; i < ARRAY_SIZE(adt7475_temp_attr); ++i) device_remove_file(&new_client->dev, &adt7475_temp_attr[i].dev_attr);
for(i = 0; i < ARRAY_SIZE(adt7475_fan_attr); ++i) device_remove_file(&new_client->dev, &adt7475_fan_attr[i].dev_attr);
i2c_detach_client(new_client);
exit_free:
kfree(data);
return err;
}
static int adt7475_attach_adapter(struct i2c_adapter *adapter)
{
if (!(adapter->class & I2C_CLASS_HWMON)) return 0;
return i2c_probe(adapter, &addr_data, adt7475_detect);
}
static int adt7475_detach_client(struct i2c_client *client)
{
struct adt7475_data *data = i2c_get_clientdata(client);
int i, err;
hwmon_device_unregister(data->class_dev);
for(i = 0; i < ARRAY_SIZE(adt7475_in_attr); ++i) device_remove_file(&client->dev, &adt7475_in_attr[i].dev_attr);
for(i = 0; i < ARRAY_SIZE(adt7475_temp_attr); ++i) device_remove_file(&client->dev, &adt7475_temp_attr[i].dev_attr);
for(i = 0; i < ARRAY_SIZE(adt7475_fan_attr); ++i) device_remove_file(&client->dev, &adt7475_fan_attr[i].dev_attr);
if ((err = i2c_detach_client(client)))
return err;
kfree(data);
return 0;
}
static struct adt7475_data *adt7475_update_device(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct adt7475_data *data = i2c_get_clientdata(client);
u8 reg_in_low, reg_temp_low, fan_act_low;
int i;
mutex_lock(&data->update_lock);
if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid)
{
/* Read voltage */
/* First read low byte because otherwise the high-registers will be frozen */
reg_in_low = i2c_smbus_read_byte_data(client, ADT7475_REG_IN_LOW);
for(i = 0; i < 2; i++)
{
/* Read high voltage */
data->in[i] = i2c_smbus_read_byte_data(client, ADT7475_REG_IN_HIGH(i)) << 2 | (reg_in_low >> (2 + 2 * i) & 0x03);
/* Read high limit, low limit voltage */
data->in_max[i] = i2c_smbus_read_byte_data(client, ADT7475_REG_IN_HIGH_LIMIT(i));
data->in_min[i] = i2c_smbus_read_byte_data(client, ADT7475_REG_IN_LOW_LIMIT(i));
}
/* Read Temperatures */
/* First read low byte because otherwise the high-registers will be frozen */
reg_temp_low = i2c_smbus_read_byte_data(client, ADT7475_REG_TEMP_LOW);
for(i = 0; i < 3; i++)
{
/* Read high temp*/
data->temp_act[i] = i2c_smbus_read_byte_data(client, ADT7475_REG_TEMP_ACT(i)) << 2 | (reg_temp_low >> (6 - 2 * i)& 0x03);
/* Read high limit, low limit temperatures */
data->temp_max[i] = i2c_smbus_read_byte_data(client, ADT7475_REG_TEMP_HIGH_LIMIT(i));
data->temp_min[i] = i2c_smbus_read_byte_data(client, ADT7475_REG_TEMP_LOW_LIMIT(i));
}
/* Read fan speeds */
// !!! Er is geen maximale fan speed, dit is een 16 bit waarde
// !!! Need to read the HIGH register first to activate the fan measurement! adt7475 manual page 28
/* First read low byte because otherwise the high-registers will be frozen */
for(i = 0; i < 4; i++)
{
fan_act_low = i2c_smbus_read_byte_data(client, ADT7475_REG_FAN_ACT_LOW(i));
data->fan_act[i] = i2c_smbus_read_byte_data(client, ADT7475_REG_FAN_ACT_HIGH(i)) << 8 | fan_act_low;
// lees minimale fan waarde. 16bit
}
/* Read Configuration Registers */
for(i = 0; i < ARRAY_SIZE(ADT7475_REG_CONFIG); i++)
data->config[i] = i2c_smbus_read_byte_data(client, ADT7475_REG_CONFIG[i]);
/* Read Status Registers */
for(i = 0; i < 2; i++)
data->intr_status[i] = i2c_smbus_read_byte_data(client, ADT7475_REG_INTR_STATUS(i));
/* ??? Read Global */
// data->global_control = i2c_smbus_read_byte_data(client, ADT7475_REG_CONTROL);
data->last_updated = jiffies;
data->valid = 1;
}
mutex_unlock(&data->update_lock);
return data;
}
static int __init adt7475_init(void)
{
printk(KERN_INFO "adt7475 driver loaded\n");
return i2c_add_driver(&adt7475_driver);
}
static void __exit adt7475_exit(void)
{
printk(KERN_INFO "adt7475 driver unloaded\n");
i2c_del_driver(&adt7475_driver);
}
MODULE_AUTHOR("Hans de Goede <j.w.r.degoede@hhs.nl>");
MODULE_DESCRIPTION("ADT7475 driver");
MODULE_LICENSE("GPL");
module_init(adt7475_init);
module_exit(adt7475_exit);
[-- Attachment #3: Type: text/plain, Size: 153 bytes --]
_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [lm-sensors] Working on adt7475 driver
2007-10-05 8:09 [lm-sensors] Working on adt7475 driver Hans de Goede
` (6 preceding siblings ...)
2007-12-18 17:39 ` Jean Delvare
@ 2007-12-19 21:28 ` Jordan Crouse
7 siblings, 0 replies; 9+ messages in thread
From: Jordan Crouse @ 2007-12-19 21:28 UTC (permalink / raw)
To: lm-sensors
[-- Attachment #1: Type: text/plain, Size: 555 bytes --]
In true open source style, I had also been working on an adt7475 driver
around the same time as Hans and Juerg. I previously sent it to them in
the hopes that it could be useful, and they kindly responded with
some suggestions, which I have integrated here.
So I offer this freely - if this is interesting to anybody, please feel
free to use it, otherwise ignore it. I also offer myself up as a testing
resource if anybody needs it for subsequent drivers.
Jordan
--
Jordan Crouse
Systems Software Development Engineer
Advanced Micro Devices, Inc.
[-- Attachment #2: adt7475.patch --]
[-- Type: text/plain, Size: 37623 bytes --]
[PATCH] hwmon: Add a driver for the ADT7475 thermal sensor
From: Jordan Crouse <jordan.crouse@amd.com>
HWMON driver for the ADT7475 thermal sensor.
Signed-off-by: Jordan Crouse <jordan.crouse@amd.com>
---
Documentation/hwmon/adt7475 | 110 +++++
drivers/hwmon/Kconfig | 10
drivers/hwmon/Makefile | 1
drivers/hwmon/adt7475.c | 965 +++++++++++++++++++++++++++++++++++++++++++
include/linux/i2c-id.h | 2
5 files changed, 1087 insertions(+), 1 deletions(-)
diff --git a/Documentation/hwmon/adt7475 b/Documentation/hwmon/adt7475
new file mode 100644
index 0000000..491e5e0
--- /dev/null
+++ b/Documentation/hwmon/adt7475
@@ -0,0 +1,110 @@
+This describes the interface for the ADT7475 driver:
+
+(there are 4 fans, numbered fan1 to fan4):
+
+fanX_input Read the current speed of the fan (in RPMs)
+fanX_min Read/write the minimum speed of the fan. Dropping
+ below this sets an alarm.
+
+(there are three PWMs, numbered pwm1 to pwm3):
+
+pwmX Read/write the current duty cycle of the PWM. Writes
+ only have effect when auto mode is turned off (see
+ below).
+
+pwmX_enable Read/write the PWM configuration based on the following
+ table:
+
+ 0 - Remote1 temp controls PWMx (auto mode)
+ 1 - local temp controls PWMx (auto mode)
+ 2 - remote2 temp controls PWMx (auto mode)
+ 3 - PWMx runs at full speed
+ 4 - PWMx is disabled
+ 5 - Use fastest speed calculated by local and remote2
+ 6 - Use fastest speed calculated by all three channels
+ 7 - Manual mode
+
+pwmX_freq Read/write the PWM frequency. The value returned is
+ an index into the following table:
+
+ 0x0 - 11.0 Hz
+ 0x1 - 14.7 Hz
+ 0x2 - 22.1 Hz
+ 0x3 - 29.4 Hz
+ 0x4 - 35.3 Hz
+ 0x5 - 44.1 Hz
+ 0x6 - 58.8 Hz
+ 0x7 - 88.2 Hz
+
+pwmX_max Read/write the maximum PWM duty cycle. The PWM
+ duty cycle will never exceed this.
+
+pwmX_min Read/write the minimum PWM duty cycle in automatic mode
+
+(there are three temperature settings numbered temp1 to temp3):
+
+tempX_input Read the current temperature. The value is in milli
+ degrees of Celsius.
+
+tempX_label Returns the "name" of the sensor as described in the
+ datasheet (remote1, local, or remote2)
+
+tempX_max Read/write the upper temperature limit - exceeding this
+ will cause an alarm.
+
+tempX_min Read/write the lower temperature limit - exceeding this
+ will cause an alarm.
+
+tempX_offset Read/write the temperature adjustment offset
+
+tempX_crit_max Read/write the THERM limit for remote1. Exceeding this
+ causes the chip to force the processor off.
+
+tempX_auto_min Read/write the minimum temperature where the fans will
+ turn on in automatic mode.
+
+tempX_auto_range Read/write the range over which the automatic fan
+ control will be executed. The value returned is a
+ index into the following table:
+
+ 0x0 - 2 C
+ 0x1 - 2.5 C
+ 0x2 - 3.33 C
+ 0x3 - 4 C
+ 0x4 - 5 C
+ 0x5 - 6.67 C
+ 0x6 - 8 C
+ 0x7 - 10 C
+ 0x8 - 13.33 C
+ 0x9 - 16 C
+ 0xA - 20 C
+ 0xB - 26.67 C
+ 0xC - 32 C
+ 0xD - 40 C
+ 0xE - 53.33 C
+ 0xF - 80 C
+
+tempX_crit_hyst set the temperature range below crit_max where the
+ fans will stay on - this helps drive the temperature
+ low enough so it doesn't stay near the edge and
+ cause THERM to keep tripping.
+
+tempX_alarm Read a 1 if the max/min alarm is set
+tempX_crit_alarm Read a 1 if the critical limit is exceeded
+tempX_fault Read a 1 if either temp1 or temp3 diode has a fault
+
+(There are two voltage settings, in1 and in2):
+
+inX_input Read the current voltage on VCC. Value is in
+ millivolts.
+
+inX_min read/write the minimum voltage limit.
+ Dropping below this causes an alarm.
+
+inX_max read/write the maximum voltage limit.
+ Exceeding this causes an alarm.
+
+inX_label Return the name of the input as specified in the
+ datasheet (vcc or vccp)
+
+inX_alarm Read a 1 if the max/min alarm is set.
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index a0445be..5c25fde 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -143,6 +143,16 @@ config SENSORS_ADT7470
This driver can also be built as a module. If so, the module
will be called adt7470.
+config SENSORS_ADT7475
+ tristate "Analog Devices ADT7475"
+ depends on I2C && EXPERIMENTAL
+ help
+ If you say yes here you get support for the Analog Devices
+ ADT7475 sensor chip.
+
+ This driver can also be build as a module. If so, the module
+ will be called adt7475.
+
config SENSORS_K8TEMP
tristate "AMD Athlon64/FX or Opteron temperature sensor"
depends on X86 && PCI && EXPERIMENTAL
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 55595f6..5c95b2b 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -23,6 +23,7 @@ obj-$(CONFIG_SENSORS_ADM1029) += adm1029.o
obj-$(CONFIG_SENSORS_ADM1031) += adm1031.o
obj-$(CONFIG_SENSORS_ADM9240) += adm9240.o
obj-$(CONFIG_SENSORS_ADT7470) += adt7470.o
+obj-$(CONFIG_SENSORS_ADT7475) += adt7475.o
obj-$(CONFIG_SENSORS_APPLESMC) += applesmc.o
obj-$(CONFIG_SENSORS_AMS) += ams/
obj-$(CONFIG_SENSORS_ATXP1) += atxp1.o
diff --git a/drivers/hwmon/adt7475.c b/drivers/hwmon/adt7475.c
new file mode 100644
index 0000000..6d1068e
--- /dev/null
+++ b/drivers/hwmon/adt7475.c
@@ -0,0 +1,965 @@
+/*
+ * adt7475 - Thermal sensor driver for the ADT7475 chip and derivatives
+ * Copyright (C) 2007, Advanced Micro Devices, Inc.
+ *
+ * Derived from the lm83 driver by Jean Delvare
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/* 7475 Notes:
+ * Addeded by: Jordan Crouse <jordan.crouse@amd.com>
+ * Datasheet: http://www.analog.com/UploadedFiles/Data_Sheets/ADT7475.pdf
+ * TODO: enhanced acoustics
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+
+/* Indexes for the sysfs hooks */
+
+#define INPUT 0
+#define MIN 1
+#define MAX 2
+#define CONTROL 3
+#define OFFSET 3
+#define AUTOMIN 4
+#define FREQ 4
+#define THERM 5
+#define HYSTERSIS 6
+#define RANGE 7
+#define LABEL 8
+#define ALARM 9
+#define CRIT_ALARM 10
+#define FAULT 11
+
+
+/* 7475 Common Registers */
+
+#define REG_VOLTAGE_BASE 0x21
+#define REG_TEMP_BASE 0x25
+#define REG_TACH_BASE 0x28
+#define REG_PWM_BASE 0x30
+#define REG_PWM_MAX_BASE 0x38
+
+#define REG_DEVID 0x3D
+#define REG_VENDID 0x3E
+
+#define REG_CONFIG1 0x40
+#define REG_STATUS1 0x41
+#define REG_STATUS2 0x42
+
+/* Not all the alarm bits are enabled - mask the ones we don't use */
+#define ALARM_MASK 0xFE76
+
+#define REG_VOLTAGE_MIN_BASE 0x46
+#define REG_VOLTAGE_MAX_BASE 0x47
+
+#define REG_TEMP_MIN_BASE 0x4E
+#define REG_TEMP_MAX_BASE 0x4F
+
+#define REG_TACH_MIN_BASE 0x54
+
+#define REG_PWM_CONFIG_BASE 0x5C
+
+#define REG_TEMP_TRANGE_BASE 0x5F
+
+#define REG_ACOUSTICS1 0x62
+#define REG_ACOUSTICS2 0x63
+
+#define REG_PWM_MIN_BASE 0x64
+
+#define REG_TEMP_TMIN_BASE 0x67
+#define REG_TEMP_THERM_BASE 0x6A
+
+#define REG_REMOTE1_HYSTERSIS 0x6D
+#define REG_REMOTE2_HYSTERSIS 0x6E
+
+#define REG_TEMP_OFFSET_BASE 0x70
+
+#define REG_CONFIG2 0x73
+#define REG_INTERRUPT_MASK1 0x74
+#define REG_INTERRUPT_MASK2 0x75
+#define REG_EXTEND1 0x76
+#define REG_EXTEND2 0x77
+#define REG_CONFIG3 0x78
+#define REG_THERM_TIMER_STATUS 0x79
+#define REG_THERM_TIMER_LIMIT 0x7A
+#define REG_TACH_PULSES 0x7B
+#define REG_CONFIG5 0x7C
+
+#define CONFIG5_TWOSCOMP 0x01
+#define CONFIG5_TEMPOFFSET 0x02
+
+#define REG_CONFIG4 0x7D
+
+/* ADT7475 Settings */
+
+#define ADT7475_VOLTAGE_COUNT 2
+#define ADT7475_TEMP_COUNT 3
+#define ADT7475_TACH_COUNT 4
+#define ADT7475_PWM_COUNT 3
+
+/* 7475 specific registers */
+
+#define REG_CONFIG6 0x10
+#define REG_CONFIG7 0x11
+
+
+/* Macro to read the registers */
+
+#define adt7475_read(reg) i2c_smbus_read_byte_data(client, (reg))
+
+/* Macros to easily index the registers */
+
+#define TACH_REG(idx) (REG_TACH_BASE + ((idx) * 2))
+#define TACH_MIN_REG(idx) (REG_TACH_MIN_BASE + ((idx) * 2))
+
+#define PWM_REG(idx) (REG_PWM_BASE + (idx))
+#define PWM_MAX_REG(idx) (REG_PWM_MAX_BASE + (idx))
+#define PWM_MIN_REG(idx) (REG_PWM_MIN_BASE + (idx))
+#define PWM_CONFIG_REG(idx) (REG_PWM_CONFIG_BASE + (idx))
+
+#define VOLTAGE_REG(idx) (REG_VOLTAGE_BASE + (idx))
+#define VOLTAGE_MIN_REG(idx) (REG_VOLTAGE_MIN_BASE + ((idx) * 2))
+#define VOLTAGE_MAX_REG(idx) (REG_VOLTAGE_MAX_BASE + ((idx) * 2))
+
+#define TEMP_REG(idx) (REG_TEMP_BASE + (idx))
+#define TEMP_MIN_REG(idx) (REG_TEMP_MIN_BASE + ((idx) * 2))
+#define TEMP_MAX_REG(idx) (REG_TEMP_MAX_BASE + ((idx) * 2))
+#define TEMP_TMIN_REG(idx) (REG_TEMP_TMIN_BASE + (idx))
+#define TEMP_THERM_REG(idx) (REG_TEMP_THERM_BASE + (idx))
+#define TEMP_OFFSET_REG(idx) (REG_TEMP_OFFSET_BASE + (idx))
+#define TEMP_TRANGE_REG(idx) (REG_TEMP_TRANGE_BASE + (idx))
+
+/* Convert the tach reading into RPMs */
+
+#define TACH2RPM(val) ((90000 * 60) / (val))
+#define RPM2TACH(val) ((90000 * 60) / (val))
+
+/* Convert the voltage registers into mW */
+
+#define REG2VCC(val) ((42 * (int)(val)) / 10)
+#define REG2VCCP(val) ((293 * (int)(val)) / 100)
+
+#define VCC2REG(val) (((val) * 10) / 42)
+#define VCCP2REG(val) (((val) * 100) / 293)
+
+/* 2's complement temp conversion - this is used when CONFIG5 bit 0 is set */
+
+#define REG2TEMP(val) ((((val) >> 2) * 1000) + (((val) & 3) * 250))
+
+#define TEMP2REG(val) ((val) <= -128000 ? -128 : \
+ (val) >= 127000 ? 127 : \
+ (val) < 0 ? ((val) - 500) / 1000 : \
+ ((val) + 500) / 1000)
+
+
+/* Offset 64 temp conversion - this is used when CONFIG5 bit 0 is clear */
+
+#define OFF64_REG2TEMP(val) (((((val) >> 2) - 64) * 1000) + (((val) & 3) * 250))
+#define OFF64_TEMP2REG(val) ((((val) + 64500) / 1000) << 2)
+
+static unsigned short normal_i2c[] = { 0x2e, I2C_CLIENT_END };
+
+I2C_CLIENT_INSMOD_1(adt7475);
+
+struct adt7475_data {
+ struct i2c_client client;
+ struct class_device *class_dev;
+ struct mutex lock;
+
+ int type;
+ char temptype;
+
+ char valid;
+ unsigned long updated;
+
+ u16 alarms;
+ u16 voltage[3][3];
+ s16 temp[6][3];
+ u16 tach[2][4];
+ u8 pwm[4][3];
+ u8 range[3];
+};
+
+static struct i2c_driver adt7475_driver;
+static struct adt7475_data *adt7475_update_device(struct device *dev);
+
+static u16 adt7475_read_word(struct i2c_client *client, int reg)
+{
+ u16 val;
+
+ val = i2c_smbus_read_byte_data(client, reg);
+ val |= (i2c_smbus_read_byte_data(client, reg + 1) << 8);
+
+ return val;
+}
+
+static void adt7475_write_word(struct i2c_client *client, int reg, u16 val)
+{
+ i2c_smbus_write_byte_data(client, reg + 1, val >> 8);
+ i2c_smbus_write_byte_data(client, reg, val & 0xFF);
+}
+
+static ssize_t show_voltage(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct adt7475_data *data = adt7475_update_device(dev);
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+ unsigned short val = data->voltage[sattr->nr][sattr->index];
+
+ switch(sattr->nr) {
+ case LABEL:
+ return sprintf(buf, "%s\n",
+ sattr->index == 0 ? "vccp" : "vcc");
+ case ALARM:
+ return sprintf(buf, "%d\n",
+ (data->alarms >> (sattr->index)) & 1);
+ default:
+ return sprintf(buf, "%d\n",
+ sattr->index == 0 ? REG2VCCP(val) : REG2VCC(val));
+ }
+}
+
+static ssize_t set_voltage(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count) {
+
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+ struct i2c_client *client = to_i2c_client(dev);
+ struct adt7475_data *data = i2c_get_clientdata(client);
+ long val = simple_strtol(buf, NULL, 10);
+ unsigned char reg;
+
+ mutex_lock(&data->lock);
+
+ data->voltage[sattr->nr][sattr->index] =
+ sattr->index ? VCC2REG(val) : VCCP2REG(val);
+
+ if (sattr->nr == MIN)
+ reg = VOLTAGE_MIN_REG(sattr->index);
+ else
+ reg = VOLTAGE_MAX_REG(sattr->index);
+
+ i2c_smbus_write_byte_data(client, reg, (u8) (data->voltage[sattr->nr][sattr->index] >> 2));
+ mutex_unlock(&data->lock);
+
+ return count;
+}
+
+static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ static const char *labels[] = {"remote1", "local", "remote2"};
+
+ struct adt7475_data *data = adt7475_update_device(dev);
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+ unsigned short val = data->temp[sattr->nr][sattr->index];
+ int ret = 0;
+ u8 out;
+
+ switch(sattr->nr) {
+ case LABEL:
+ if (sattr->index <= 2)
+ ret = sprintf(buf, "%s\n", labels[sattr->index]);
+ break;
+
+ case HYSTERSIS:
+ if (sattr->index != 1)
+ out = (val >> 4) & 0xF;
+ else
+ out = (val & 0xF);
+
+ ret = sprintf(buf, "%d\n", out);
+ break;
+
+ case OFFSET:
+ /* Offset is always 2's complement, regardless of the setting in CONFIG5 */
+
+ if (data->temptype & CONFIG5_TEMPOFFSET)
+ ret = sprintf(buf, "%d\n", (s8) val);
+ else
+ ret = sprintf(buf, "%d\n", ((s8)val) >> 1);
+ break;
+
+ case ALARM:
+ ret = sprintf(buf, "%d\n",
+ (data->alarms >> (sattr->index + 4)) & 1);
+ break;
+
+ case CRIT_ALARM:
+ ret = sprintf(buf, "%d\n",
+ (data->alarms & 0x20));
+ break;
+
+ case FAULT:
+ /* Note - only for remote1 and remote2 */
+
+ ret = sprintf(buf, "%d\n",
+ (data->alarms & (sattr->index ? 0x4000 : 0x8000)));
+ break;
+
+ default:
+ /* All other temp values are in the configured format */
+
+ ret = sprintf(buf, "%d\n",
+ (data->temptype & CONFIG5_TWOSCOMP) ? REG2TEMP(val) : OFF64_REG2TEMP(val));
+ }
+
+ return ret;
+}
+
+static ssize_t set_temp(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+ struct i2c_client *client = to_i2c_client(dev);
+ struct adt7475_data *data = i2c_get_clientdata(client);
+ long val = simple_strtol(buf, NULL, 10);
+ unsigned char reg = 0;
+ u8 out;
+ int l;
+
+ mutex_lock(&data->lock);
+
+ switch(sattr->nr) {
+ case OFFSET:
+ l = val;
+
+ if (data->temptype & CONFIG5_TEMPOFFSET) {
+ if (l > 127)
+ l = 127;
+ else if (l < -127)
+ l = -126;
+ }
+ else {
+ if (l > 64)
+ l = 64;
+ else if (l < -63)
+ l = -63;
+
+ l <<= 1;
+ }
+
+ out = data->temp[OFFSET][sattr->index] = (u8) l;
+ break;
+
+ case HYSTERSIS:
+ if (sattr->index != 1) {
+ data->temp[HYSTERSIS][sattr->index] &= 0xF0;
+ data->temp[HYSTERSIS][sattr->index] |= (val & 0xF) << 4;
+ }
+ else {
+ data->temp[HYSTERSIS][sattr->index] &= 0x0F;
+ data->temp[HYSTERSIS][sattr->index] |= (val & 0xF);
+ }
+
+ out = data->temp[HYSTERSIS][sattr->index];
+ break;
+
+ default:
+ data->temp[sattr->nr][sattr->index] =
+ (data->temptype & CONFIG5_TWOSCOMP) ? TEMP2REG(val) : OFF64_TEMP2REG(val);
+
+ /* We maintain an extra 2 digits of precision for simplicity - shift those back off
+ before writing the value
+ */
+
+ out = (u8) (data->temp[sattr->nr][sattr->index] >> 2);
+ }
+
+ switch(sattr->nr) {
+ case MIN:
+ reg = TEMP_MIN_REG(sattr->index);
+ break;
+ case MAX:
+ reg = TEMP_MAX_REG(sattr->index);
+ break;
+ case OFFSET:
+ reg = TEMP_OFFSET_REG(sattr->index);
+ break;
+ case AUTOMIN:
+ reg = TEMP_TMIN_REG(sattr->index);
+ break;
+ case THERM:
+ reg = TEMP_THERM_REG(sattr->index);
+ break;
+ case HYSTERSIS:
+ if (sattr->index != 2)
+ reg = REG_REMOTE1_HYSTERSIS;
+ else
+ reg = REG_REMOTE2_HYSTERSIS;
+
+ break;
+ }
+
+ i2c_smbus_write_byte_data(client, reg, out);
+
+ mutex_unlock(&data->lock);
+ return count;
+}
+
+static ssize_t show_range(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct adt7475_data *data = adt7475_update_device(dev);
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+
+ unsigned short val = data->range[sattr->index];
+ return sprintf(buf, "%d\n", (val >> 4) & 0xF);
+}
+
+static ssize_t set_range(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct adt7475_data *data = adt7475_update_device(dev);
+ struct i2c_client *client = to_i2c_client(dev);
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+ long val = simple_strtol(buf, NULL, 10);
+
+ mutex_lock(&data->lock);
+
+ data->range[sattr->index] &= ~0xF0;
+ data->range[sattr->index] |= (val & 0xF) << 4;
+
+ i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index),
+ data->range[sattr->index]);
+
+ mutex_unlock(&data->lock);
+ return count;
+}
+
+static ssize_t show_tach(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct adt7475_data *data = adt7475_update_device(dev);
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+
+
+ /* 0xFFFF means the period was invalid */
+
+ switch(sattr->nr) {
+ case ALARM:
+ return sprintf(buf, "%d\n",
+ (data->alarms >> (sattr->index + 10) & 1));
+ default:
+ if (data->tach[sattr->nr][sattr->index] == 0xFFFF)
+ return sprintf(buf, "0\n");
+ else
+ return sprintf(buf, "%d\n",
+ TACH2RPM(data->tach[sattr->nr][sattr->index]));
+ }
+}
+
+
+
+
+static ssize_t set_tach(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+ struct i2c_client *client = to_i2c_client(dev);
+ struct adt7475_data *data = i2c_get_clientdata(client);
+
+ long val = simple_strtol(buf, NULL, 10);
+
+ mutex_lock(&data->lock);
+
+ data->tach[MIN][sattr->index] = (u16) RPM2TACH(val);
+
+ adt7475_write_word(client, TACH_MIN_REG(sattr->index),
+ data->tach[MIN][sattr->index]);
+
+ mutex_unlock(&data->lock);
+ return count;
+}
+
+static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct adt7475_data *data = adt7475_update_device(dev);
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+
+ return sprintf(buf, "%d\n", data->pwm[sattr->nr][sattr->index]);
+}
+
+static ssize_t show_pwmctrl(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct adt7475_data *data = adt7475_update_device(dev);
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+
+ return sprintf(buf, "%d\n", (data->pwm[CONTROL][sattr->index] >> 5) & 7);
+}
+
+static ssize_t show_pwmfreq(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct adt7475_data *data = adt7475_update_device(dev);
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+
+ return sprintf(buf, "%d\n", data->range[sattr->index] & 3);
+}
+
+static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+ struct i2c_client *client = to_i2c_client(dev);
+ struct adt7475_data *data = i2c_get_clientdata(client);
+
+ long val = simple_strtol(buf, NULL, 10);
+ unsigned char reg = 0;
+
+ mutex_lock(&data->lock);
+
+ data->pwm[sattr->nr][sattr->index] = (u8) val;
+
+ switch(sattr->nr) {
+ case INPUT:
+ /* If we are not in manual mode, then we shouldn't allow the user to set
+ the pwm speed */
+
+ if (((data->pwm[CONTROL][sattr->index] >> 5) & 7) != 7)
+ return 0;
+
+ reg = PWM_REG(sattr->index);
+ break;
+
+ case MIN:
+ reg = PWM_MIN_REG(sattr->index);
+ break;
+
+ case MAX:
+ reg = PWM_MAX_REG(sattr->index);
+ break;
+ }
+
+ i2c_smbus_write_byte_data(client, reg, data->pwm[sattr->nr][sattr->index]);
+ mutex_unlock(&data->lock);
+
+ return count;
+}
+
+static ssize_t set_pwmctrl(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+ struct i2c_client *client = to_i2c_client(dev);
+ struct adt7475_data *data = i2c_get_clientdata(client);
+
+ long val = simple_strtol(buf, NULL, 10);
+
+ mutex_lock(&data->lock);
+
+ data->pwm[CONTROL][sattr->index] &= ~0xE0;
+ data->pwm[CONTROL][sattr->index] |= (val & 7) << 5;
+
+ i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(sattr->index),
+ data->pwm[CONTROL][sattr->index]);
+
+ mutex_unlock(&data->lock);
+ return count;
+}
+
+static ssize_t set_pwmfreq(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+ struct i2c_client *client = to_i2c_client(dev);
+ struct adt7475_data *data = i2c_get_clientdata(client);
+
+ long val = simple_strtol(buf, NULL, 10);
+
+ mutex_lock(&data->lock);
+
+ data->range[sattr->index] &= ~3;
+ data->range[sattr->index] |= val & 0x03;
+
+ i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index),
+ data->range[sattr->index]);
+
+ mutex_unlock(&data->lock);
+ return count;
+}
+
+static SENSOR_DEVICE_ATTR_2(in1_input, S_IRUGO, show_voltage, NULL, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(in1_max, S_IRUGO | S_IWUSR, show_voltage, set_voltage, MAX, 0);
+static SENSOR_DEVICE_ATTR_2(in1_min, S_IRUGO | S_IWUSR, show_voltage, set_voltage, MIN, 0);
+static SENSOR_DEVICE_ATTR_2(in1_label, S_IRUGO, show_voltage, NULL, LABEL, 0);
+static SENSOR_DEVICE_ATTR_2(in1_alarm, S_IRUGO, show_voltage, NULL, ALARM, 0);
+static SENSOR_DEVICE_ATTR_2(in2_input, S_IRUGO, show_voltage, NULL, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_voltage, set_voltage, MAX, 1);
+static SENSOR_DEVICE_ATTR_2(in2_min, S_IRUGO | S_IWUSR, show_voltage, set_voltage, MIN, 1);
+static SENSOR_DEVICE_ATTR_2(in2_label, S_IRUGO, show_voltage, NULL, LABEL, 1);
+static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_voltage, NULL, ALARM, 1);
+static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_label, S_IRUGO, show_temp, NULL, LABEL, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_alarm, S_IRUGO, show_temp, NULL, ALARM, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO, show_temp, NULL, CRIT_ALARM, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_fault, S_IRUGO, show_temp, NULL, FAULT, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, show_temp, set_temp, MAX, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_min, S_IRUGO | S_IWUSR, show_temp, set_temp, MIN, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_offset, S_IRUGO | S_IWUSR, show_temp, set_temp, OFFSET, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_min, S_IRUGO | S_IWUSR, show_temp, set_temp, AUTOMIN, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_range, S_IRUGO | S_IWUSR, show_range, set_range, 0, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_crit_max, S_IRUGO | S_IWUSR, show_temp, set_temp, THERM, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_crit_hyst, S_IRUGO | S_IWUSR, show_temp, set_temp, HYSTERSIS, 0);
+static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_label, S_IRUGO, show_temp, NULL, LABEL, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_alarm, S_IRUGO, show_temp, NULL, ALARM, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO, show_temp, NULL, CRIT_ALARM, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp, set_temp, MAX, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_min, S_IRUGO | S_IWUSR, show_temp, set_temp, MIN, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IRUGO | S_IWUSR, show_temp, set_temp, OFFSET, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_min, S_IRUGO | S_IWUSR, show_temp, set_temp, AUTOMIN, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_range, S_IRUGO | S_IWUSR, show_range, set_range, 0, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_crit_max, S_IRUGO | S_IWUSR, show_temp, set_temp, THERM, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_crit_hyst, S_IRUGO | S_IWUSR, show_temp, set_temp, HYSTERSIS, 1);
+static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_label, S_IRUGO, show_temp, NULL, LABEL, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_alarm, S_IRUGO, show_temp, NULL, ALARM, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO, show_temp, NULL, CRIT_ALARM, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_fault, S_IRUGO, show_temp, NULL, FAULT, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp, set_temp, MAX, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_min, S_IRUGO | S_IWUSR, show_temp, set_temp, MIN, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_offset, S_IRUGO | S_IWUSR, show_temp, set_temp, OFFSET, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_min, S_IRUGO | S_IWUSR, show_temp, set_temp, AUTOMIN, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_range, S_IRUGO | S_IWUSR, show_range, set_range, 0, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_crit_max, S_IRUGO | S_IWUSR, show_temp, set_temp, THERM, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_crit_hyst, S_IRUGO | S_IWUSR, show_temp, set_temp, HYSTERSIS, 2);
+static SENSOR_DEVICE_ATTR_2(fan1_input, S_IRUGO, show_tach, NULL, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(fan1_min, S_IRUGO | S_IWUSR, show_tach, set_tach, MIN, 0);
+static SENSOR_DEVICE_ATTR_2(fan1_alarm, S_IRUGO, show_tach, NULL, ALARM, 0);
+static SENSOR_DEVICE_ATTR_2(fan2_input, S_IRUGO, show_tach, NULL, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(fan2_min, S_IRUGO | S_IWUSR, show_tach, set_tach, MIN, 1);
+static SENSOR_DEVICE_ATTR_2(fan2_alarm, S_IRUGO, show_tach, NULL, ALARM, 1);
+static SENSOR_DEVICE_ATTR_2(fan3_input, S_IRUGO, show_tach, NULL, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(fan3_min, S_IRUGO | S_IWUSR, show_tach, set_tach, MIN, 2);
+static SENSOR_DEVICE_ATTR_2(fan3_alarm, S_IRUGO, show_tach, NULL, ALARM, 2);
+static SENSOR_DEVICE_ATTR_2(fan4_input, S_IRUGO, show_tach, NULL, INPUT, 3);
+static SENSOR_DEVICE_ATTR_2(fan4_min, S_IRUGO | S_IWUSR, show_tach, set_tach, MIN, 3);
+static SENSOR_DEVICE_ATTR_2(fan4_alarm, S_IRUGO, show_tach, NULL, ALARM, 3);
+static SENSOR_DEVICE_ATTR_2(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(pwm1_freq, S_IRUGO | S_IWUSR, show_pwmfreq, set_pwmfreq, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(pwm1_enable, S_IRUGO | S_IWUSR, show_pwmctrl, set_pwmctrl, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(pwm1_max, S_IRUGO | S_IWUSR, show_pwm, set_pwm, MAX, 0);
+static SENSOR_DEVICE_ATTR_2(pwm1_min, S_IRUGO | S_IWUSR, show_pwm, set_pwm, MIN, 0);
+static SENSOR_DEVICE_ATTR_2(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(pwm2_freq, S_IRUGO | S_IWUSR, show_pwmfreq, set_pwmfreq, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(pwm2_enable, S_IRUGO | S_IWUSR, show_pwmctrl, set_pwmctrl, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(pwm2_max, S_IRUGO | S_IWUSR, show_pwm, set_pwm, MAX, 1);
+static SENSOR_DEVICE_ATTR_2(pwm2_min, S_IRUGO | S_IWUSR, show_pwm, set_pwm, MIN, 1);
+static SENSOR_DEVICE_ATTR_2(pwm3, S_IRUGO | S_IWUSR, show_pwm, set_pwm, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(pwm3_freq, S_IRUGO | S_IWUSR, show_pwmfreq, set_pwmfreq, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(pwm3_enable, S_IRUGO | S_IWUSR, show_pwmctrl, set_pwmctrl, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(pwm3_max, S_IRUGO | S_IWUSR, show_pwm, set_pwm, MAX, 2);
+static SENSOR_DEVICE_ATTR_2(pwm3_min, S_IRUGO | S_IWUSR, show_pwm, set_pwm, MIN, 2);
+
+static struct attribute *adt7475_attrs[] = {
+ &sensor_dev_attr_in1_input.dev_attr.attr,
+ &sensor_dev_attr_in1_label.dev_attr.attr,
+ &sensor_dev_attr_in1_max.dev_attr.attr,
+ &sensor_dev_attr_in1_min.dev_attr.attr,
+ &sensor_dev_attr_in1_alarm.dev_attr.attr,
+ &sensor_dev_attr_in2_input.dev_attr.attr,
+ &sensor_dev_attr_in2_label.dev_attr.attr,
+ &sensor_dev_attr_in2_max.dev_attr.attr,
+ &sensor_dev_attr_in2_min.dev_attr.attr,
+ &sensor_dev_attr_in2_alarm.dev_attr.attr,
+ &sensor_dev_attr_temp1_input.dev_attr.attr,
+ &sensor_dev_attr_temp1_label.dev_attr.attr,
+ &sensor_dev_attr_temp1_alarm.dev_attr.attr,
+ &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
+ &sensor_dev_attr_temp1_fault.dev_attr.attr,
+ &sensor_dev_attr_temp1_max.dev_attr.attr,
+ &sensor_dev_attr_temp1_min.dev_attr.attr,
+ &sensor_dev_attr_temp1_offset.dev_attr.attr,
+ &sensor_dev_attr_temp1_auto_min.dev_attr.attr,
+ &sensor_dev_attr_temp1_auto_range.dev_attr.attr,
+ &sensor_dev_attr_temp1_crit_max.dev_attr.attr,
+ &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
+ &sensor_dev_attr_temp2_input.dev_attr.attr,
+ &sensor_dev_attr_temp2_label.dev_attr.attr,
+ &sensor_dev_attr_temp2_alarm.dev_attr.attr,
+ &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
+ &sensor_dev_attr_temp2_max.dev_attr.attr,
+ &sensor_dev_attr_temp2_min.dev_attr.attr,
+ &sensor_dev_attr_temp2_offset.dev_attr.attr,
+ &sensor_dev_attr_temp2_auto_min.dev_attr.attr,
+ &sensor_dev_attr_temp2_auto_range.dev_attr.attr,
+ &sensor_dev_attr_temp2_crit_max.dev_attr.attr,
+ &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
+ &sensor_dev_attr_temp3_input.dev_attr.attr,
+ &sensor_dev_attr_temp3_label.dev_attr.attr,
+ &sensor_dev_attr_temp3_fault.dev_attr.attr,
+ &sensor_dev_attr_temp3_alarm.dev_attr.attr,
+ &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
+ &sensor_dev_attr_temp3_max.dev_attr.attr,
+ &sensor_dev_attr_temp3_min.dev_attr.attr,
+ &sensor_dev_attr_temp3_offset.dev_attr.attr,
+ &sensor_dev_attr_temp3_auto_min.dev_attr.attr,
+ &sensor_dev_attr_temp3_auto_range.dev_attr.attr,
+ &sensor_dev_attr_temp3_crit_max.dev_attr.attr,
+ &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
+ &sensor_dev_attr_fan1_input.dev_attr.attr,
+ &sensor_dev_attr_fan1_min.dev_attr.attr,
+ &sensor_dev_attr_fan1_alarm.dev_attr.attr,
+ &sensor_dev_attr_fan2_input.dev_attr.attr,
+ &sensor_dev_attr_fan2_min.dev_attr.attr,
+ &sensor_dev_attr_fan2_alarm.dev_attr.attr,
+ &sensor_dev_attr_fan3_input.dev_attr.attr,
+ &sensor_dev_attr_fan3_min.dev_attr.attr,
+ &sensor_dev_attr_fan3_alarm.dev_attr.attr,
+ &sensor_dev_attr_fan4_input.dev_attr.attr,
+ &sensor_dev_attr_fan4_min.dev_attr.attr,
+ &sensor_dev_attr_fan4_alarm.dev_attr.attr,
+ &sensor_dev_attr_pwm1.dev_attr.attr,
+ &sensor_dev_attr_pwm1_freq.dev_attr.attr,
+ &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+ &sensor_dev_attr_pwm1_max.dev_attr.attr,
+ &sensor_dev_attr_pwm1_min.dev_attr.attr,
+ &sensor_dev_attr_pwm2.dev_attr.attr,
+ &sensor_dev_attr_pwm2_freq.dev_attr.attr,
+ &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+ &sensor_dev_attr_pwm2_max.dev_attr.attr,
+ &sensor_dev_attr_pwm2_min.dev_attr.attr,
+ &sensor_dev_attr_pwm3.dev_attr.attr,
+ &sensor_dev_attr_pwm3_freq.dev_attr.attr,
+ &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+ &sensor_dev_attr_pwm3_max.dev_attr.attr,
+ &sensor_dev_attr_pwm3_min.dev_attr.attr,
+ NULL,
+};
+
+/* The list of chips we support - these index into the following structure */
+
+#define ADT7475 0
+#define ADT7475_MAX_ID 1
+
+static struct adt7475_chip {
+ const char *name;
+ struct attribute_group group;
+} adt7475_chips[ADT7475_MAX_ID] = {
+ { .name = "ADT7475",
+ .group = {
+ .attrs = adt7475_attrs,
+ }
+ },
+};
+
+static int adt7475_detect(struct i2c_adapter *adapter, int address, int kind)
+{
+ struct i2c_client *client;
+ struct adt7475_data *data;
+ unsigned char val;
+ int ret = 0;
+
+ if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+ return 0;
+ }
+
+ /* Figure out what type of sensor is attached */
+ data = kzalloc(sizeof(*data), GFP_KERNEL);
+
+ if (data == NULL) {
+ return -ENOMEM;
+ }
+
+ client = &data->client;
+ i2c_set_clientdata(client, data);
+ client->addr = address;
+ client->adapter = adapter;
+ client->driver = &adt7475_driver;
+ client->flags = 0;
+
+ /* Check the company version first */
+
+ if (i2c_smbus_read_byte_data(client, REG_VENDID) != 0x41) {
+ dev_err(&adapter->dev, "This is not an ADT part\n");
+ goto efree;
+ }
+
+ /* Then check the part number */
+ val = i2c_smbus_read_byte_data(client, REG_DEVID);
+
+ if (val == 0x75)
+ data->type = ADT7475;
+ else {
+ dev_err(&adapter->dev,
+ "Couldn't detect a ADT7475 part at 0x%02x\n", address);
+
+ goto efree;
+ }
+
+ /* Record how the temp registers are presented, either 2's complement
+ or offset 64
+ */
+
+ data->temptype = i2c_smbus_read_byte_data(client, REG_CONFIG5) & 3;
+
+ /* FIXME: Get teh reading type */
+ /* FIXME: Get the scale of the temprature readings */
+
+ strlcpy(client->name, adt7475_chips[data->type].name, I2C_NAME_SIZE);
+
+ data->valid = 0;
+ mutex_init(&data->lock);
+
+ ret = i2c_attach_client(client);
+
+ if (ret) {
+ goto efree;
+ }
+
+ ret = sysfs_create_group(&client->dev.kobj, &adt7475_chips[data->type].group);
+ if (ret) {
+ goto edetach;
+ }
+
+ data->class_dev = hwmon_device_register(&client->dev);
+
+ if (!IS_ERR(data->class_dev))
+ return 0;
+
+ ret = PTR_ERR(data->class_dev);
+
+ sysfs_remove_group(&client->dev.kobj, &adt7475_chips[data->type].group);
+ edetach:
+ i2c_detach_client(client);
+ efree:
+ kfree(data);
+ return ret;
+}
+
+static int adt7475_attach_adapter(struct i2c_adapter *adapter)
+{
+ if (!(adapter->class & I2C_CLASS_HWMON))
+ return 0;
+
+ return i2c_probe(adapter, &addr_data, adt7475_detect);
+}
+
+static int adt7475_detach_client(struct i2c_client *client)
+{
+ struct adt7475_data *data = i2c_get_clientdata(client);
+ int ret = 0;
+
+ hwmon_device_unregister(data->class_dev);
+ sysfs_remove_group(&client->dev.kobj, &adt7475_chips[data->type].group);
+
+ ret = i2c_detach_client(client);
+ if (!ret)
+ kfree(data);
+ return ret;
+}
+
+static struct i2c_driver adt7475_driver = {
+ .driver = {
+ .name = "adt7475",
+ },
+ .id = I2C_DRIVERID_ADT7475,
+ .attach_adapter = adt7475_attach_adapter,
+ .detach_client = adt7475_detach_client,
+};
+
+static struct adt7475_data *adt7475_update_device(struct device *dev)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct adt7475_data *data = i2c_get_clientdata(client);
+ u8 ext;
+ int i;
+
+ mutex_lock(&data->lock);
+
+ if (!time_after(jiffies, data->updated + HZ * 2) && data->valid) {
+ mutex_unlock(&data->lock);
+ return data;
+ }
+
+ data->alarms = adt7475_read(REG_STATUS2) << 8;
+ data->alarms |= adt7475_read(REG_STATUS1);
+
+ ext = adt7475_read(REG_EXTEND1);
+
+ /* Get the voltage readings */
+
+ for(i = 0; i < ADT7475_VOLTAGE_COUNT; i++) {
+ data->voltage[INPUT][i] = (adt7475_read(VOLTAGE_REG(i)) << 2) |
+ ((ext >> ((i + 1) * 2)) & 3);
+
+ /* Adjust these values so they match the input precision */
+
+ data->voltage[MIN][i] = adt7475_read(VOLTAGE_MIN_REG(i)) << 2;
+ data->voltage[MAX][i] = adt7475_read(VOLTAGE_MAX_REG(i)) << 2;
+ }
+
+ ext = adt7475_read(REG_EXTEND2);
+
+ for(i = 0; i < ADT7475_TEMP_COUNT; i++) {
+ data->temp[INPUT][i] = (adt7475_read(TEMP_REG(i)) << 2) |
+ ((ext >> ((i + 1) * 2)) & 3);
+
+ /* Adjust these values so they match the input precision */
+
+ data->temp[MIN][i] = adt7475_read(TEMP_MIN_REG(i)) << 2;
+ data->temp[MAX][i] = adt7475_read(TEMP_MAX_REG(i)) << 2;
+ data->temp[AUTOMIN][i] = adt7475_read(TEMP_TMIN_REG(i)) << 2;
+ data->temp[THERM][i] = adt7475_read(TEMP_THERM_REG(i)) << 2;
+
+ data->temp[OFFSET][i] = adt7475_read(TEMP_OFFSET_REG(i));
+ }
+
+ data->temp[HYSTERSIS][0] = (u16) adt7475_read(REG_REMOTE1_HYSTERSIS);
+ data->temp[HYSTERSIS][1] = (u16) adt7475_read(REG_REMOTE1_HYSTERSIS);
+ data->temp[HYSTERSIS][2] = (u16) adt7475_read(REG_REMOTE2_HYSTERSIS);
+
+ for(i = 0; i < ADT7475_TACH_COUNT; i++) {
+ data->tach[INPUT][i] = adt7475_read_word(client, TACH_REG(i));
+ data->tach[MIN][i] = adt7475_read_word(client, TACH_MIN_REG(i));
+ }
+
+ for(i = 0; i < ADT7475_PWM_COUNT; i++) {
+ data->pwm[INPUT][i] = adt7475_read(PWM_REG(i));
+ data->pwm[MAX][i] = adt7475_read(PWM_MAX_REG(i));
+ data->pwm[MIN][i] = adt7475_read(PWM_MIN_REG(i));
+ data->pwm[CONTROL][i] = adt7475_read(PWM_CONFIG_REG(i));
+ }
+
+ data->range[0] = adt7475_read(TEMP_TRANGE_REG(0));
+ data->range[1] = adt7475_read(TEMP_TRANGE_REG(1));
+ data->range[2] = adt7475_read(TEMP_TRANGE_REG(2));
+
+ data->updated = jiffies;
+ data->valid = 1;
+
+ mutex_unlock(&data->lock);
+
+ return data;
+}
+
+static int __init sensors_adt7475_init(void)
+{
+ return i2c_add_driver(&adt7475_driver);
+}
+
+static void __exit sensors_adt7475_exit(void)
+{
+ i2c_del_driver(&adt7475_driver);
+}
+
+MODULE_AUTHOR("Advanced Micro Devices, Inc");
+MODULE_DESCRIPTION("adt7475 driver");
+MODULE_LICENSE("GPL");
+
+module_init(sensors_adt7475_init);
+module_exit(sensors_adt7475_exit);
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 88c8140..6e3f8e0 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -163,7 +163,7 @@
#define I2C_DRIVERID_FSCHER 1046
#define I2C_DRIVERID_W83L785TS 1047
#define I2C_DRIVERID_OV7670 1048 /* Omnivision 7670 camera */
-
+#define I2C_DRIVERID_ADT74XX 1049
/*
* ---- Adapter types ----------------------------------------------------
*/
[-- Attachment #3: Type: text/plain, Size: 153 bytes --]
_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
^ permalink raw reply related [flat|nested] 9+ messages in thread