wt/lm-sensors
1
0 Fork 0
mirror of https://github.com/lm-sensors/lm-sensors.git synced 2026-10-15 10:39:31 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
dcdd19ed72ca8953fdf397bedc33c0e751dcbfb2
lm-sensors/kernel/chips/lm63.c
T
Jean Delvare fcc01c5c83 Spelling fixes. Contributed by Steven Cole. 
git-svn-id: http://lm-sensors.org/svn/lm-sensors/trunk@2994 7894878c-1315-0410-8ee3-d5d059ff63e0
2005-05-10 18:43:48 +00:00

646 lines
19 KiB
C
Raw Blame History

/*
* lm63.c - driver for the National Semiconductor LM63 temperature sensor
* with integrated fan control
* Copyright (C) 2004 Jean Delvare <khali@linux-fr.org>
* Based on the lm90 driver.
*
* The LM63 is a sensor chip made by National Semiconductor. It measures
* two temperatures (its own and one external one) and the speed of one
* fan, those speed it can additionally control. Complete datasheet can be
* obtained from National's website at:
* http://www.national.com/pf/LM/LM63.html
*
* The LM63 is basically an LM86 with fan speed monitoring and control
* capabilities added. It misses some of the LM86 features though:
* - No low limit for local temperature.
* - No critical limit for local temperature.
* - Critical limit for remote temperature can be changed only once. We
* will consider that the critical limit is read-only.
*
* The datasheet isn't very clear about what the tachometer reading is.
* I had a explanation from National Semiconductor though. The two lower
* bits of the read value have to be masked out. The value is still 16 bit
* in width.
*
* 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.
*/
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/i2c-proc.h>
#include <linux/init.h>
#include "version.h"
/*
* Addresses to scan
* Address is fully defined internally and cannot be changed.
*/
static unsigned short normal_i2c[] = { 0x4c, SENSORS_I2C_END };
static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
static unsigned int normal_isa[] = { SENSORS_ISA_END };
static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
/*
* Insmod parameters
*/
SENSORS_INSMOD_1(lm63);
/*
* The LM63 registers
*/
#define LM63_REG_CONFIG1 0x03
#define LM63_REG_CONFIG2 0xBF
#define LM63_REG_CONFIG_FAN 0x4A
#define LM63_REG_TACH_COUNT_MSB 0x47
#define LM63_REG_TACH_COUNT_LSB 0x46
#define LM63_REG_TACH_LIMIT_MSB 0x49
#define LM63_REG_TACH_LIMIT_LSB 0x48
#define LM63_REG_PWM_VALUE 0x4C
#define LM63_REG_PWM_FREQ 0x4D
#define LM63_REG_LOCAL_TEMP 0x00
#define LM63_REG_LOCAL_HIGH 0x05
#define LM63_REG_REMOTE_TEMP_MSB 0x01
#define LM63_REG_REMOTE_TEMP_LSB 0x10
#define LM63_REG_REMOTE_OFFSET_MSB 0x11
#define LM63_REG_REMOTE_OFFSET_LSB 0x12
#define LM63_REG_REMOTE_HIGH_MSB 0x07
#define LM63_REG_REMOTE_HIGH_LSB 0x13
#define LM63_REG_REMOTE_LOW_MSB 0x08
#define LM63_REG_REMOTE_LOW_LSB 0x14
#define LM63_REG_REMOTE_TCRIT 0x19
#define LM63_REG_REMOTE_TCRIT_HYST 0x21
#define LM63_REG_ALERT_STATUS 0x02
#define LM63_REG_ALERT_MASK 0x16
#define LM63_REG_MAN_ID 0xFE
#define LM63_REG_CHIP_ID 0xFF
/*
* Conversions and various macros
* For tachometer counts, the LM63 uses 16-bit values.
* For local temperature and high limit, remote critical limit and hysteresis
* value, it uses signed 8-bit values with LSB = 1 degree Celsius.
* For remote temperature, low and high limits, it uses signed 11-bit values
* with LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
*/
#define FAN_FROM_REG(reg) ((reg) == 0xFFFC || (reg) == 0 ? 0 : \
5400000 / (reg))
#define FAN_TO_REG(val) ((val) <= 82 ? 0xFFFF : \
(5400000 / (val)) & 0xFFFC)
#define TEMP8_FROM_REG(reg) (reg)
#define TEMP8_TO_REG(val) ((val) <= -128 ? -128 : \
(val) >= 127 ? 127 : \
val)
#define TEMP11_FROM_REG(reg) ((reg) / 32 * 125)
#define TEMP11_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
(val) >= 127875 ? 0x7FE0 : \
(val) < 0 ? ((val) - 62) / 125 * 32 : \
((val) + 62) / 125 * 32)
#define HYST_TO_REG(val) ((val) <= 0 ? 0 : \
(val) >= 127 ? 127 : \
val)
/*
* Functions declaration
*/
static int lm63_attach_adapter(struct i2c_adapter *adapter);
static int lm63_detect(struct i2c_adapter *adapter, int address,
unsigned short flags, int kind);
static void lm63_init_client(struct i2c_client *client);
static int lm63_detach_client(struct i2c_client *client);
static void lm63_local_temp(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
static void lm63_remote_temp(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
static void lm63_remote_tcrit(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
static void lm63_remote_tcrit_hyst(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
static void lm63_alarms(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
static void lm63_fan(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
static void lm63_pwm(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results);
/*
* Driver data (common to all clients)
*/
static struct i2c_driver lm63_driver = {
.name = "LM63 sensor driver",
.flags = I2C_DF_NOTIFY,
.attach_adapter = lm63_attach_adapter,
.detach_client = lm63_detach_client,
};
/*
* Client data (each client gets its own)
*/
struct lm63_data {
struct i2c_client client;
int sysctl_id;
struct semaphore update_lock;
char valid; /* zero until following fields are valid */
unsigned long last_updated; /* in jiffies */
/* registers values */
u8 config, config_fan;
u16 fan1_input;
u16 fan1_low;
u8 pwm1_freq;
u8 pwm1_value;
s8 temp1_input;
s8 temp1_high;
s16 temp2_input;
s16 temp2_high;
s16 temp2_low;
s8 temp2_crit;
u8 temp2_crit_hyst;
u8 alarms;
};
/*
* Proc entries
* These files are created for each detected LM63.
*/
/* -- SENSORS SYSCTL START -- */
#define LM63_SYSCTL_TEMP1 1200
#define LM63_SYSCTL_TEMP2 1201
#define LM63_SYSCTL_TEMP2_TCRIT 1205
#define LM63_SYSCTL_TEMP2_TCRIT_HYST 1208
#define LM63_SYSCTL_ALARMS 1210
#define LM63_SYSCTL_FAN1 1220
#define LM63_SYSCTL_PWM1 1230
#define LM63_ALARM_LOCAL_HIGH 0x40
#define LM63_ALARM_REMOTE_HIGH 0x10
#define LM63_ALARM_REMOTE_LOW 0x08
#define LM63_ALARM_REMOTE_CRIT 0x02
#define LM63_ALARM_REMOTE_OPEN 0x04
#define LM63_ALARM_FAN_LOW 0x01
/* -- SENSORS SYSCTL END -- */
static ctl_table lm63_dir_table_template[] =
{
{LM63_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL,
&i2c_proc_real, &i2c_sysctl_real, NULL, &lm63_local_temp},
{LM63_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL,
&i2c_proc_real, &i2c_sysctl_real, NULL, &lm63_remote_temp},
{LM63_SYSCTL_TEMP2_TCRIT, "temp2_crit", NULL, 0, 0444, NULL,
&i2c_proc_real, &i2c_sysctl_real, NULL, &lm63_remote_tcrit},
{LM63_SYSCTL_TEMP2_TCRIT_HYST, "temp2_crit_hyst", NULL, 0, 0644, NULL,
&i2c_proc_real, &i2c_sysctl_real, NULL, &lm63_remote_tcrit_hyst},
{LM63_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL,
&i2c_proc_real, &i2c_sysctl_real, NULL, &lm63_alarms},
{LM63_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL,
&i2c_proc_real, &i2c_sysctl_real, NULL, &lm63_fan},
{LM63_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL,
&i2c_proc_real, &i2c_sysctl_real, NULL, &lm63_pwm},
{0}
};
/*
* Real code
*/
static int lm63_attach_adapter(struct i2c_adapter *adapter)
{
return i2c_detect(adapter, &addr_data, lm63_detect);
}
/*
* The following function does more than just detection. If detection
* succeeds, it also registers the new chip.
*/
static int lm63_detect(struct i2c_adapter *adapter, int address,
unsigned short flags, int kind)
{
struct i2c_client *new_client;
struct lm63_data *data;
int err = 0;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
#ifdef DEBUG
printk(KERN_DEBUG "lm63: adapter doesn't support SMBus byte "
"data mode, skipping.\n");
#endif
return 0;
}
if (!(data = kmalloc(sizeof(struct lm63_data), GFP_KERNEL))) {
printk(KERN_ERR "lm63: Out of memory in lm63_detect\n");
return -ENOMEM;
}
/*
* The common I2C client data is placed right before the
* LM63-specific data. The LM63-specific data is pointed to by the
* data field from the i2c_client structure.
*/
new_client = &data->client;
new_client->addr = address;
new_client->data = data;
new_client->adapter = adapter;
new_client->driver = &lm63_driver;
new_client->flags = 0;
/* Default to an LM63 if forced */
if (kind == 0)
kind = lm63;
if (kind < 0) { /* must identify */
u8 man_id, chip_id, reg_config1, reg_config2;
u8 reg_alert_status, reg_alert_mask;
man_id = i2c_smbus_read_byte_data(new_client,
LM63_REG_MAN_ID);
chip_id = i2c_smbus_read_byte_data(new_client,
LM63_REG_CHIP_ID);
reg_config1 = i2c_smbus_read_byte_data(new_client,
LM63_REG_CONFIG1);
reg_config2 = i2c_smbus_read_byte_data(new_client,
LM63_REG_CONFIG2);
reg_alert_status = i2c_smbus_read_byte_data(new_client,
LM63_REG_ALERT_STATUS);
reg_alert_mask = i2c_smbus_read_byte_data(new_client,
LM63_REG_ALERT_MASK);
if (man_id == 0x01 /* National Semiconductor */
&& chip_id == 0x41 /* LM63 */
&& (reg_config1 & 0x18) == 0x00
&& (reg_config2 & 0xF8) == 0x00
&& (reg_alert_status & 0x20) == 0x00
&& (reg_alert_mask & 0xA4) == 0xA4) {
kind = lm63;
} else {
#ifdef DEBUG
printk(KERN_DEBUG "lm63: Unsupported chip "
"(man_id=0x%02X, chip_id=0x%02X)\n",
man_id, chip_id);
#endif
goto ERROR1;
}
}
/* Fill in the remaining client fields */
strcpy(new_client->name, "LM63 chip");
data->valid = 0;
init_MUTEX(&data->update_lock);
/* Tell the I2C layer a new client has arrived */
if ((err = i2c_attach_client(new_client))) {
printk(KERN_ERR "lm63: Failed attaching client\n");
goto ERROR1;
}
/* Register a new directory entry */
if ((err = i2c_register_entry(new_client, "lm63",
lm63_dir_table_template, THIS_MODULE)) < 0) {
printk(KERN_ERR "lm63: Failed registering directory entry\n");
goto ERROR2;
}
data->sysctl_id = err;
/* Initialize the LM63 chip */
lm63_init_client(new_client);
return 0;
ERROR2:
i2c_detach_client(new_client);
ERROR1:
kfree(data);
return err;
}
/* Idealy we shouldn't have to initialize anything, since the BIOS
should have taken care of everything */
static void lm63_init_client(struct i2c_client *client)
{
struct lm63_data *data = client->data;
data->config = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
data->config_fan = i2c_smbus_read_byte_data(client,
LM63_REG_CONFIG_FAN);
/* Start converting if needed */
if (data->config & 0x40) { /* standby */
#ifdef DEBUG
printk(KERN_DEBUG "lm63: Switching to operational mode");
#endif
data->config &= 0xA7;
i2c_smbus_write_byte_data(client, LM63_REG_CONFIG1,
data->config);
}
/* We may need pwm1_freq before ever updating the client data */
data->pwm1_freq = i2c_smbus_read_byte_data(client, LM63_REG_PWM_FREQ);
if (data->pwm1_freq == 0)
data->pwm1_freq = 1;
#ifdef DEBUG
/* Show some debug info about the LM63 configuration */
printk(KERN_DEBUG "lm63: Alert/tach pin configured for %s\n",
(data->config & 0x04) ? "tachometer input" :
"alert output");
printk(KERN_DEBUG "lm63: PWM clock %s kHz, output frequency %u Hz\n",
(data->config_fan & 0x08) ? "1.4" : "360",
((data->config_fan & 0x08) ? 700 : 180000) / data->pwm1_freq);
printk(KERN_DEBUG "lm63: PWM output active %s, %s mode\n",
(data->config_fan & 0x10) ? "low" : "high",
(data->config_fan & 0x20) ? "manual" : "auto");
#endif
}
static int lm63_detach_client(struct i2c_client *client)
{
struct lm63_data *data = client->data;
int err;
i2c_deregister_entry(data->sysctl_id);
if ((err = i2c_detach_client(client))) {
printk(KERN_ERR "lm63: Client deregistration failed, client "
"not detached.\n");
return err;
}
kfree(data);
return 0;
}
static void lm63_update_client(struct i2c_client *client)
{
struct lm63_data *data = client->data;
down(&data->update_lock);
if ((jiffies - data->last_updated > HZ) ||
(jiffies < data->last_updated) ||
!data->valid) {
if (data->config & 0x04) { /* tachometer enabled */
/* order matters for fan1_input */
data->fan1_input = i2c_smbus_read_byte_data(client,
LM63_REG_TACH_COUNT_LSB) & 0xFC;
data->fan1_input |= i2c_smbus_read_byte_data(client,
LM63_REG_TACH_COUNT_MSB) << 8;
data->fan1_low = (i2c_smbus_read_byte_data(client,
LM63_REG_TACH_LIMIT_LSB) & 0xFC)
| (i2c_smbus_read_byte_data(client,
LM63_REG_TACH_LIMIT_MSB) << 8);
}
data->pwm1_freq = i2c_smbus_read_byte_data(client,
LM63_REG_PWM_FREQ);
if (data->pwm1_freq == 0)
data->pwm1_freq = 1;
data->pwm1_value = i2c_smbus_read_byte_data(client,
LM63_REG_PWM_VALUE);
data->temp1_input = i2c_smbus_read_byte_data(client,
LM63_REG_LOCAL_TEMP);
data->temp1_high = i2c_smbus_read_byte_data(client,
LM63_REG_LOCAL_HIGH);
/* order matters for temp2_input */
data->temp2_input = i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_TEMP_MSB) << 8;
data->temp2_input |= i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_TEMP_LSB);
data->temp2_high = (i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_HIGH_MSB) << 8)
| i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_HIGH_LSB);
data->temp2_low = (i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_LOW_MSB) << 8)
| i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_LOW_LSB);
data->temp2_crit = i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_TCRIT);
data->temp2_crit_hyst = i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_TCRIT_HYST);
/* Mask out Busy bit in status register */
data->alarms = i2c_smbus_read_byte_data(client,
LM63_REG_ALERT_STATUS) & 0x7F;
data->last_updated = jiffies;
data->valid = 1;
}
up(&data->update_lock);
}
static void lm63_local_temp(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results)
{
struct lm63_data *data = client->data;
if (operation == SENSORS_PROC_REAL_INFO)
*nrels_mag = 0; /* magnitude */
else if (operation == SENSORS_PROC_REAL_READ) {
lm63_update_client(client);
results[0] = TEMP8_FROM_REG(data->temp1_high);
results[1] = TEMP8_FROM_REG(data->temp1_input);
*nrels_mag = 2;
} else if (operation == SENSORS_PROC_REAL_WRITE) {
if (*nrels_mag >= 1) {
data->temp1_high = TEMP8_TO_REG(results[0]);
i2c_smbus_write_byte_data(client, LM63_REG_LOCAL_HIGH,
data->temp1_high);
}
}
}
static void lm63_remote_temp(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results)
{
struct lm63_data *data = client->data;
if (operation == SENSORS_PROC_REAL_INFO)
*nrels_mag = 3; /* magnitude */
else if (operation == SENSORS_PROC_REAL_READ) {
lm63_update_client(client);
results[0] = TEMP11_FROM_REG(data->temp2_high);
results[1] = TEMP11_FROM_REG(data->temp2_low);
results[2] = TEMP11_FROM_REG(data->temp2_input);
*nrels_mag = 3;
} else if (operation == SENSORS_PROC_REAL_WRITE) {
if (*nrels_mag >= 1) {
data->temp2_high = TEMP11_TO_REG(results[0]);
i2c_smbus_write_byte_data(client,
LM63_REG_REMOTE_HIGH_MSB,
data->temp2_high >> 8);
i2c_smbus_write_byte_data(client,
LM63_REG_REMOTE_HIGH_LSB,
data->temp2_high & 0xFF);
}
if (*nrels_mag >= 2) {
data->temp2_low = TEMP11_TO_REG(results[1]);
i2c_smbus_write_byte_data(client,
LM63_REG_REMOTE_LOW_MSB,
data->temp2_low >> 8);
i2c_smbus_write_byte_data(client,
LM63_REG_REMOTE_LOW_LSB,
data->temp2_low & 0xFF);
}
}
}
static void lm63_remote_tcrit(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results)
{
struct lm63_data *data = client->data;
if (operation == SENSORS_PROC_REAL_INFO)
*nrels_mag = 0; /* magnitude */
else if (operation == SENSORS_PROC_REAL_READ) {
lm63_update_client(client);
results[0] = TEMP8_FROM_REG(data->temp2_crit);
*nrels_mag = 1;
}
}
static void lm63_remote_tcrit_hyst(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results)
{
struct lm63_data *data = client->data;
if (operation == SENSORS_PROC_REAL_INFO)
*nrels_mag = 0; /* magnitude */
else if (operation == SENSORS_PROC_REAL_READ) {
lm63_update_client(client);
results[0] = TEMP8_FROM_REG(data->temp2_crit) -
TEMP8_FROM_REG(data->temp2_crit_hyst);
*nrels_mag = 1;
} else if (operation == SENSORS_PROC_REAL_WRITE) {
if (*nrels_mag >= 1) {
data->temp2_crit_hyst = HYST_TO_REG(data->temp2_crit -
results[0]);
i2c_smbus_write_byte_data(client,
LM63_REG_REMOTE_TCRIT_HYST,
data->temp2_crit_hyst);
}
}
}
static void lm63_alarms(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results)
{
struct lm63_data *data = client->data;
if (operation == SENSORS_PROC_REAL_INFO)
*nrels_mag = 0; /* magnitude */
else if (operation == SENSORS_PROC_REAL_READ) {
lm63_update_client(client);
results[0] = data->alarms;
*nrels_mag = 1;
}
}
static void lm63_fan(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results)
{
struct lm63_data *data = client->data;
if (operation == SENSORS_PROC_REAL_INFO)
*nrels_mag = 0; /* magnitude */
else if (operation == SENSORS_PROC_REAL_READ) {
if (!(data->config & 0x04)) { /* tachometer disabled */
results[0] = 0;
*nrels_mag = 1;
return;
}
lm63_update_client(client);
results[0] = FAN_FROM_REG(data->fan1_low);
results[1] = FAN_FROM_REG(data->fan1_input);
*nrels_mag = 2;
} else if (operation == SENSORS_PROC_REAL_WRITE) {
if (!(data->config & 0x04)) /* tachometer disabled */
return;
if (*nrels_mag >= 1) {
data->fan1_low = FAN_TO_REG(results[0]);
i2c_smbus_write_byte_data(client,
LM63_REG_TACH_LIMIT_LSB,
data->fan1_low & 0xFF);
i2c_smbus_write_byte_data(client,
LM63_REG_TACH_LIMIT_MSB,
data->fan1_low >> 8);
}
}
}
static void lm63_pwm(struct i2c_client *client, int operation,
int ctl_name, int *nrels_mag, long *results)
{
struct lm63_data *data = client->data;
if (operation == SENSORS_PROC_REAL_INFO)
*nrels_mag = 0; /* magnitude */
else if (operation == SENSORS_PROC_REAL_READ) {
lm63_update_client(client);
results[0] = data->pwm1_value >= 2 * data->pwm1_freq ? 255 :
(data->pwm1_value * 255 + data->pwm1_freq) /
(2 * data->pwm1_freq);
results[1] = data->config_fan & 0x20 ? 1 : 2;
*nrels_mag = 2;
} else if (operation == SENSORS_PROC_REAL_WRITE) {
if (*nrels_mag >= 1 && (data->config_fan & 0x20)) {
data->pwm1_value = results[0] <= 0 ? 0 :
results[0] >= 255 ? 2 * data->pwm1_freq :
(results[0] * data->pwm1_freq * 2 + 127) / 255;
i2c_smbus_write_byte_data(client, LM63_REG_PWM_VALUE,
data->pwm1_value);
}
}
}
static int __init lm63_init(void)
{
printk(KERN_INFO "lm63 version %s (%s)\n", LM_VERSION, LM_DATE);
return i2c_add_driver(&lm63_driver);
}
static void __exit lm63_exit(void)
{
i2c_del_driver(&lm63_driver);
}
MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
MODULE_DESCRIPTION("LM63 sensor driver");
MODULE_LICENSE("GPL");
module_init(lm63_init);
module_exit(lm63_exit);
Reference in new issue View Git Blame Copy Permalink