mirror of
https://github.com/lm-sensors/lm-sensors.git
synced 2026-10-17 10:59:31 +00:00
Frodo Looijaard
76c1926109
Like the LM78 before, all chips now handle strange values written to /proc/... with grace - that is, they convert them to the most sane value considering the circumstances, instead of reacting with strange resulting values (note that they were already crash-free). I also removed a factor '2' in the computation of the fan speeds in the gl518sm module. This is conforming with the sheet; if your fan gives two 'ticks' for each rotation, just modify sensors.conf. I tried to introduce rounding and limit checking to the maxilife module. The VID computation is not yet rounded - I need the real formula for that. git-svn-id: http://lm-sensors.org/svn/lm-sensors/trunk@382 7894878c-1315-0410-8ee3-d5d059ff63e0
766 lines
25 KiB
C
766 lines
25 KiB
C
/*
|
|
sis5595.c - Part of lm_sensors, Linux kernel modules
|
|
for hardware monitoring
|
|
|
|
Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>,
|
|
Kyösti Mälkki <kmalkki@cc.hut.fi>
|
|
|
|
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/malloc.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/sysctl.h>
|
|
#include <linux/pci.h>
|
|
#if LINUX_VERSION_CODE < 0x020136 /* 2.1.54 */
|
|
#include <linux/bios32.h>
|
|
#endif
|
|
#include <asm/errno.h>
|
|
#include <asm/io.h>
|
|
#include <linux/types.h>
|
|
#include "smbus.h"
|
|
#include "version.h"
|
|
#include "i2c-isa.h"
|
|
#include "sensors.h"
|
|
#include "i2c.h"
|
|
#include "compat.h"
|
|
|
|
/* Addresses to scan.
|
|
Note that we can't determine the ISA address until we have initialized
|
|
our module */
|
|
static unsigned short normal_i2c[] = {SENSORS_I2C_END};
|
|
static unsigned short normal_i2c_range[] = {SENSORS_I2C_END};
|
|
static unsigned int normal_isa[] = {0x0000,SENSORS_ISA_END};
|
|
static unsigned int normal_isa_range[] = {SENSORS_ISA_END};
|
|
|
|
/* Insmod parameters */
|
|
SENSORS_INSMOD_1(sis5595);
|
|
|
|
/*
|
|
SiS southbridge has a LM78-like chip integrated on the same IC.
|
|
This driver is a customized copy of lm78.c
|
|
*/
|
|
|
|
/* Many SIS5595 constants specified below */
|
|
|
|
/* Length of ISA address segment */
|
|
#define SIS5595_EXTENT 8
|
|
#define SIS5595_BASE_REG 0x68
|
|
|
|
/* Where are the ISA address/data registers relative to the base address */
|
|
#define SIS5595_ADDR_REG_OFFSET 5
|
|
#define SIS5595_DATA_REG_OFFSET 6
|
|
|
|
/* The SIS5595 registers */
|
|
#define SIS5595_REG_IN_MAX(nr) (0x2b + (nr) * 2)
|
|
#define SIS5595_REG_IN_MIN(nr) (0x2c + (nr) * 2)
|
|
#define SIS5595_REG_IN(nr) (0x20 + (nr))
|
|
|
|
#define SIS5595_REG_FAN_MIN(nr) (0x3a + (nr))
|
|
#define SIS5595_REG_FAN(nr) (0x27 + (nr))
|
|
|
|
#define SIS5595_REG_TEMP 0x27
|
|
#define SIS5595_REG_TEMP_OVER 0x39
|
|
#define SIS5595_REG_TEMP_HYST 0x3a
|
|
|
|
#define SIS5595_REG_ALARM1 0x41
|
|
|
|
#define SIS5595_REG_FANDIV 0x47
|
|
|
|
#define SIS5595_REG_CONFIG 0x40
|
|
|
|
/* Conversions. Rounding and limit checking is only done on the TO_REG
|
|
variants. Note that you should be a bit careful with which arguments
|
|
these macros are called: arguments may be evaluated more than once.
|
|
Fixing this is just not worth it. */
|
|
|
|
#define IN_TO_REG(val) (SENSORS_LIMIT((((val) * 10 + 8)/16),0,255))
|
|
#define IN_FROM_REG(val) (((val) * 16) / 10)
|
|
|
|
extern inline u8 FAN_TO_REG(long rpm, int div)
|
|
{
|
|
if (rpm == 0)
|
|
return 255;
|
|
rpm = SENSORS_LIMIT(rpm,1,1000000);
|
|
return SENSORS_LIMIT((1350000 + rpm*div/2) / (rpm*div),1,254);
|
|
}
|
|
|
|
#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
|
|
|
|
#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
|
|
((val)+5)/10),0,255))
|
|
#define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*10)
|
|
|
|
#define ALARMS_FROM_REG(val) (val)
|
|
|
|
#define DIV_FROM_REG(val) (1 << (val))
|
|
#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
|
|
|
|
/* Initial limits. To keep them sane, we use the 'standard' translation as
|
|
specified in the SIS5595 sheet. Use the config file to set better limits. */
|
|
#define SIS5595_INIT_IN_0 (((1200) * 10)/38)
|
|
#define SIS5595_INIT_IN_1 (((500) * 100)/168)
|
|
#define SIS5595_INIT_IN_2 330
|
|
#define SIS5595_INIT_IN_3 250
|
|
|
|
#define SIS5595_INIT_IN_PERCENTAGE 10
|
|
|
|
#define SIS5595_INIT_IN_MIN_0 \
|
|
(SIS5595_INIT_IN_0 - SIS5595_INIT_IN_0 * SIS5595_INIT_IN_PERCENTAGE / 100)
|
|
#define SIS5595_INIT_IN_MAX_0 \
|
|
(SIS5595_INIT_IN_0 + SIS5595_INIT_IN_0 * SIS5595_INIT_IN_PERCENTAGE / 100)
|
|
#define SIS5595_INIT_IN_MIN_1 \
|
|
(SIS5595_INIT_IN_1 - SIS5595_INIT_IN_1 * SIS5595_INIT_IN_PERCENTAGE / 100)
|
|
#define SIS5595_INIT_IN_MAX_1 \
|
|
(SIS5595_INIT_IN_1 + SIS5595_INIT_IN_1 * SIS5595_INIT_IN_PERCENTAGE / 100)
|
|
#define SIS5595_INIT_IN_MIN_2 \
|
|
(SIS5595_INIT_IN_2 - SIS5595_INIT_IN_2 * SIS5595_INIT_IN_PERCENTAGE / 100)
|
|
#define SIS5595_INIT_IN_MAX_2 \
|
|
(SIS5595_INIT_IN_2 + SIS5595_INIT_IN_2 * SIS5595_INIT_IN_PERCENTAGE / 100)
|
|
#define SIS5595_INIT_IN_MIN_3 \
|
|
(SIS5595_INIT_IN_3 - SIS5595_INIT_IN_3 * SIS5595_INIT_IN_PERCENTAGE / 100)
|
|
#define SIS5595_INIT_IN_MAX_3 \
|
|
(SIS5595_INIT_IN_3 + SIS5595_INIT_IN_3 * SIS5595_INIT_IN_PERCENTAGE / 100)
|
|
|
|
#define SIS5595_INIT_FAN_MIN_1 3000
|
|
#define SIS5595_INIT_FAN_MIN_2 3000
|
|
|
|
#define SIS5595_INIT_TEMP_OVER 600
|
|
#define SIS5595_INIT_TEMP_HYST 500
|
|
|
|
#ifdef MODULE
|
|
extern int init_module(void);
|
|
extern int cleanup_module(void);
|
|
#endif /* MODULE */
|
|
|
|
/* This module may seem overly long and complicated. In fact, it is not so
|
|
bad. Quite a lot of bookkeeping is done. A real driver can often cut
|
|
some corners. */
|
|
|
|
/* For each registered SIS5595, we need to keep some data in memory. That
|
|
data is pointed to by sis5595_list[NR]->data. The structure itself is
|
|
dynamically allocated, at the same time when a new sis5595 client is
|
|
allocated. */
|
|
struct sis5595_data {
|
|
struct semaphore lock;
|
|
int sysctl_id;
|
|
|
|
struct semaphore update_lock;
|
|
char valid; /* !=0 if following fields are valid */
|
|
unsigned long last_updated; /* In jiffies */
|
|
|
|
u8 in[4]; /* Register value */
|
|
u8 in_max[4]; /* Register value */
|
|
u8 in_min[4]; /* Register value */
|
|
u8 fan[2]; /* Register value */
|
|
u8 fan_min[2]; /* Register value */
|
|
u8 temp; /* Register value */
|
|
u8 temp_over; /* Register value */
|
|
u8 temp_hyst; /* Register value */
|
|
u8 fan_div[2]; /* Register encoding, shifted right */
|
|
u8 alarms; /* Register encoding, combined */
|
|
};
|
|
|
|
|
|
static int sis5595_init(void);
|
|
static int sis5595_cleanup(void);
|
|
|
|
static int sis5595_attach_adapter(struct i2c_adapter *adapter);
|
|
static int sis5595_detect(struct i2c_adapter *adapter, int address, int kind);
|
|
static int sis5595_detach_client(struct i2c_client *client);
|
|
static int sis5595_command(struct i2c_client *client, unsigned int cmd,
|
|
void *arg);
|
|
static void sis5595_inc_use (struct i2c_client *client);
|
|
static void sis5595_dec_use (struct i2c_client *client);
|
|
|
|
static int sis5595_read_value(struct i2c_client *client, u8 register);
|
|
static int sis5595_write_value(struct i2c_client *client, u8 register, u8 value);
|
|
static void sis5595_update_client(struct i2c_client *client);
|
|
static void sis5595_init_client(struct i2c_client *client);
|
|
static int sis5595_find_sis(int *address);
|
|
|
|
|
|
static void sis5595_in(struct i2c_client *client, int operation, int ctl_name,
|
|
int *nrels_mag, long *results);
|
|
static void sis5595_fan(struct i2c_client *client, int operation, int ctl_name,
|
|
int *nrels_mag, long *results);
|
|
static void sis5595_temp(struct i2c_client *client, int operation, int ctl_name,
|
|
int *nrels_mag, long *results);
|
|
static void sis5595_alarms(struct i2c_client *client, int operation, int ctl_name,
|
|
int *nrels_mag, long *results);
|
|
static void sis5595_fan_div(struct i2c_client *client, int operation, int ctl_name,
|
|
int *nrels_mag, long *results);
|
|
|
|
/* I choose here for semi-static SIS5595 allocation. Complete dynamic
|
|
allocation could also be used; the code needed for this would probably
|
|
take more memory than the datastructure takes now. */
|
|
#define MAX_SIS5595_NR 4
|
|
static struct i2c_client *sis5595_list[MAX_SIS5595_NR];
|
|
|
|
/* The driver. I choose to use type i2c_driver, as at is identical to both
|
|
smbus_driver and isa_driver, and clients could be of either kind */
|
|
static struct i2c_driver sis5595_driver = {
|
|
/* name */ "SiS 5595",
|
|
/* id */ I2C_DRIVERID_SIS5595,
|
|
/* flags */ DF_NOTIFY,
|
|
/* attach_adapter */ &sis5595_attach_adapter,
|
|
/* detach_client */ &sis5595_detach_client,
|
|
/* command */ &sis5595_command,
|
|
/* inc_use */ &sis5595_inc_use,
|
|
/* dec_use */ &sis5595_dec_use
|
|
};
|
|
|
|
/* Used by sis5595_init/cleanup */
|
|
static int sis5595_initialized = 0;
|
|
|
|
/* The /proc/sys entries */
|
|
/* These files are created for each detected SIS5595. This is just a template;
|
|
though at first sight, you might think we could use a statically
|
|
allocated list, we need some way to get back to the parent - which
|
|
is done through one of the 'extra' fields which are initialized
|
|
when a new copy is allocated. */
|
|
static ctl_table sis5595_dir_table_template[] = {
|
|
{ SIS5595_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &sensors_proc_real,
|
|
&sensors_sysctl_real, NULL, &sis5595_in },
|
|
{ SIS5595_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &sensors_proc_real,
|
|
&sensors_sysctl_real, NULL, &sis5595_in },
|
|
{ SIS5595_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &sensors_proc_real,
|
|
&sensors_sysctl_real, NULL, &sis5595_in },
|
|
{ SIS5595_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &sensors_proc_real,
|
|
&sensors_sysctl_real, NULL, &sis5595_in },
|
|
{ SIS5595_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &sensors_proc_real,
|
|
&sensors_sysctl_real, NULL, &sis5595_fan },
|
|
{ SIS5595_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &sensors_proc_real,
|
|
&sensors_sysctl_real, NULL, &sis5595_fan },
|
|
{ SIS5595_SYSCTL_TEMP, "temp", NULL, 0, 0644, NULL, &sensors_proc_real,
|
|
&sensors_sysctl_real, NULL, &sis5595_temp },
|
|
{ SIS5595_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &sensors_proc_real,
|
|
&sensors_sysctl_real, NULL, &sis5595_fan_div },
|
|
{ SIS5595_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &sensors_proc_real,
|
|
&sensors_sysctl_real, NULL, &sis5595_alarms },
|
|
{ 0 }
|
|
};
|
|
|
|
/* This is called when the module is loaded */
|
|
int sis5595_attach_adapter(struct i2c_adapter *adapter)
|
|
{
|
|
return sensors_detect(adapter,&addr_data,sis5595_detect);
|
|
}
|
|
|
|
/* Locate SiS bridge and correct base address for SIS5595 */
|
|
int sis5595_find_sis(int *address)
|
|
{
|
|
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,54))
|
|
struct pci_dev *s_bridge;
|
|
#else
|
|
unsigned char SIS_bus, SIS_devfn;
|
|
#endif
|
|
u16 val;
|
|
|
|
if (! pci_present())
|
|
return -ENODEV;
|
|
|
|
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,54))
|
|
if (! (s_bridge = pci_find_device(
|
|
PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503, NULL)));
|
|
|
|
#else
|
|
if(pcibios_find_device(
|
|
PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503, 0,
|
|
&SIS_bus, &SIS_devfn))
|
|
#endif
|
|
return -ENODEV;
|
|
|
|
|
|
if ( PCIBIOS_SUCCESSFUL !=
|
|
pci_read_config_word_united(s_bridge, SIS_bus, SIS_devfn,
|
|
SIS5595_BASE_REG, &val))
|
|
return -ENODEV;
|
|
|
|
*address = (val & 0xfff8);
|
|
return 0;
|
|
}
|
|
|
|
int sis5595_detect(struct i2c_adapter *adapter, int address, int kind)
|
|
{
|
|
int i;
|
|
struct i2c_client *new_client;
|
|
struct sis5595_data *data;
|
|
int err=0;
|
|
const char *type_name = "";
|
|
const char *client_name = "";
|
|
|
|
/* Make sure we are probing the ISA bus!! This is just a safety check
|
|
at this moment; sensors_detect really won't call us for I2C busses. */
|
|
#ifdef DEBUG
|
|
if (!i2c_is_isa_adapter(adapter)) {
|
|
printk("sis5595.o: sis5595_detect called for an I2C bus adapter?!?\n");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
if (check_region(address,SIS5595_EXTENT))
|
|
goto ERROR0;
|
|
|
|
/* If this is the address as indicated by the SIS5595 chipset, we don't
|
|
do any futher probing */
|
|
if ((kind < 0) && (address == normal_isa[0]))
|
|
kind = 0;
|
|
|
|
/* Probe whether there is anything available on this address. */
|
|
if (kind < 0) {
|
|
#define REALLY_SLOW_IO
|
|
/* We need the timeouts for at least some LM78-like chips. But only
|
|
if we read 'undefined' registers. */
|
|
i = inb_p(address + 1);
|
|
if (inb_p(address + 2) != i)
|
|
goto ERROR0;
|
|
if (inb_p(address + 3) != i)
|
|
goto ERROR0;
|
|
if (inb_p(address + 7) != i)
|
|
goto ERROR0;
|
|
#undef REALLY_SLOW_IO
|
|
|
|
/* Let's just hope nothing breaks here */
|
|
i = inb_p(address + 5) & 0x7f;
|
|
outb_p(~i & 0x7f,address+5);
|
|
if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
|
|
outb_p(i,address+5);
|
|
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 sis5595_{read,write}_value. */
|
|
|
|
if (! (new_client = kmalloc(sizeof(struct isa_client) +
|
|
sizeof(struct sis5595_data),
|
|
GFP_KERNEL))) {
|
|
err = -ENOMEM;
|
|
goto ERROR0;
|
|
}
|
|
|
|
data = (struct sis5595_data *) (((struct isa_client *) new_client) + 1);
|
|
new_client->addr = 0;
|
|
((struct isa_client *) new_client)->isa_addr = address;
|
|
data->lock = MUTEX;
|
|
new_client->data = data;
|
|
new_client->adapter = adapter;
|
|
new_client->driver = &sis5595_driver;
|
|
|
|
/* Now, we do the remaining detection. */
|
|
|
|
if (kind < 0) {
|
|
if (sis5595_read_value(new_client,SIS5595_REG_CONFIG) & 0x80)
|
|
goto ERROR1;
|
|
}
|
|
|
|
/* Determine the chip type. */
|
|
if (kind <= 0)
|
|
kind = sis5595;
|
|
|
|
if (kind == sis5595) {
|
|
type_name = "sis5595";
|
|
client_name = "SIS5595 chip";
|
|
} else {
|
|
#ifdef DEBUG
|
|
printk("sis5595.o: Internal error: unknown kind (%d)?!?",kind);
|
|
#endif
|
|
goto ERROR1;
|
|
}
|
|
|
|
/* Reserve the ISA region */
|
|
request_region(address, SIS5595_EXTENT, type_name);
|
|
|
|
/* Fill in the remaining client fields and put it into the global list */
|
|
strcpy(new_client->name,client_name);
|
|
|
|
for(i = 0; i < MAX_SIS5595_NR; i++)
|
|
if (! sis5595_list[i])
|
|
break;
|
|
if (i == MAX_SIS5595_NR) {
|
|
printk("sis5595.o: No empty slots left, recompile and heighten "
|
|
"MAX_SIS5595_NR!\n");
|
|
err = -ENOMEM;
|
|
goto ERROR2;
|
|
}
|
|
sis5595_list[i] = new_client;
|
|
new_client->id = i;
|
|
data->valid = 0;
|
|
data->update_lock = MUTEX;
|
|
|
|
/* Tell the I2C layer a new client has arrived */
|
|
if ((err = i2c_attach_client(new_client)))
|
|
goto ERROR3;
|
|
|
|
/* Register a new directory entry with module sensors */
|
|
if ((i = sensors_register_entry((struct i2c_client *) new_client,
|
|
type_name,
|
|
sis5595_dir_table_template)) < 0) {
|
|
err = i;
|
|
goto ERROR4;
|
|
}
|
|
data->sysctl_id = i;
|
|
|
|
/* Initialize the SIS5595 chip */
|
|
sis5595_init_client(new_client);
|
|
return 0;
|
|
|
|
/* OK, this is not exactly good programming practice, usually. But it is
|
|
very code-efficient in this case. */
|
|
|
|
ERROR4:
|
|
i2c_detach_client(new_client);
|
|
ERROR3:
|
|
for (i = 0; i < MAX_SIS5595_NR; i++)
|
|
if (new_client == sis5595_list[i])
|
|
sis5595_list[i] = NULL;
|
|
ERROR2:
|
|
release_region(address,SIS5595_EXTENT);
|
|
ERROR1:
|
|
kfree(new_client);
|
|
ERROR0:
|
|
return err;
|
|
}
|
|
|
|
int sis5595_detach_client(struct i2c_client *client)
|
|
{
|
|
int err,i;
|
|
|
|
sensors_deregister_entry(((struct sis5595_data *)(client->data))->sysctl_id);
|
|
|
|
if ((err = i2c_detach_client(client))) {
|
|
printk("sis5595.o: Client deregistration failed, client not detached.\n");
|
|
return err;
|
|
}
|
|
|
|
for (i = 0; i < MAX_SIS5595_NR; i++)
|
|
if (client == sis5595_list[i])
|
|
break;
|
|
if ((i == MAX_SIS5595_NR)) {
|
|
printk("sis5595.o: Client to detach not found.\n");
|
|
return -ENOENT;
|
|
}
|
|
sis5595_list[i] = NULL;
|
|
|
|
release_region(((struct isa_client *)client)->isa_addr,SIS5595_EXTENT);
|
|
kfree(client);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* No commands defined yet */
|
|
int sis5595_command(struct i2c_client *client, unsigned int cmd, void *arg)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/* Nothing here yet */
|
|
void sis5595_inc_use (struct i2c_client *client)
|
|
{
|
|
#ifdef MODULE
|
|
MOD_INC_USE_COUNT;
|
|
#endif
|
|
}
|
|
|
|
/* Nothing here yet */
|
|
void sis5595_dec_use (struct i2c_client *client)
|
|
{
|
|
#ifdef MODULE
|
|
MOD_DEC_USE_COUNT;
|
|
#endif
|
|
}
|
|
|
|
|
|
/* The SMBus locks itself, but ISA access must be locked explicitely!
|
|
There are some ugly typecasts here, but the good new is - they should
|
|
nowhere else be necessary! */
|
|
int sis5595_read_value(struct i2c_client *client, u8 reg)
|
|
{
|
|
int res;
|
|
|
|
down((struct semaphore *) (client->data));
|
|
down(& (((struct sis5595_data *) (client->data)) -> lock));
|
|
outb_p(reg,(((struct isa_client *) client)->isa_addr) +
|
|
SIS5595_ADDR_REG_OFFSET);
|
|
res = inb_p((((struct isa_client *) client)->isa_addr) +
|
|
SIS5595_DATA_REG_OFFSET);
|
|
up( & (((struct sis5595_data *) (client->data)) -> lock));
|
|
return res;
|
|
}
|
|
|
|
/* The SMBus locks itself, but ISA access muse be locked explicitely!
|
|
There are some ugly typecasts here, but the good new is - they should
|
|
nowhere else be necessary! */
|
|
int sis5595_write_value(struct i2c_client *client, u8 reg, u8 value)
|
|
{
|
|
down(& (((struct sis5595_data *) (client->data)) -> lock));
|
|
outb_p(reg,((struct isa_client *) client)->isa_addr + SIS5595_ADDR_REG_OFFSET);
|
|
outb_p(value,((struct isa_client *) client)->isa_addr + SIS5595_DATA_REG_OFFSET);
|
|
up( & (((struct sis5595_data *) (client->data)) -> lock));
|
|
return 0;
|
|
}
|
|
|
|
/* Called when we have found a new SIS5595. It should set limits, etc. */
|
|
void sis5595_init_client(struct i2c_client *client)
|
|
{
|
|
/* 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));
|
|
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);
|
|
|
|
}
|
|
|
|
void sis5595_update_client(struct i2c_client *client)
|
|
{
|
|
struct sis5595_data *data = client->data;
|
|
int i;
|
|
|
|
down(&data->update_lock);
|
|
|
|
if ((jiffies - data->last_updated > HZ+HZ/2 ) ||
|
|
(jiffies < data->last_updated) || ! data->valid) {
|
|
|
|
#ifdef DEBUG
|
|
printk("Starting sis5595 update\n");
|
|
#endif
|
|
for (i = 0; i <= 3; i++) {
|
|
data->in[i] = sis5595_read_value(client,SIS5595_REG_IN(i));
|
|
data->in_min[i] = sis5595_read_value(client,SIS5595_REG_IN_MIN(i));
|
|
data->in_max[i] = sis5595_read_value(client,SIS5595_REG_IN_MAX(i));
|
|
}
|
|
for (i = 1; i <= 2; i++) {
|
|
data->fan[i-1] = sis5595_read_value(client,SIS5595_REG_FAN(i));
|
|
data->fan_min[i-1] = sis5595_read_value(client,SIS5595_REG_FAN_MIN(i));
|
|
}
|
|
data->temp = sis5595_read_value(client,SIS5595_REG_TEMP);
|
|
data->temp_over = sis5595_read_value(client,SIS5595_REG_TEMP_OVER);
|
|
data->temp_hyst = sis5595_read_value(client,SIS5595_REG_TEMP_HYST);
|
|
i = sis5595_read_value(client,SIS5595_REG_FANDIV);
|
|
data->fan_div[0] = (i >> 4) & 0x03;
|
|
data->fan_div[1] = i >> 6;
|
|
data->alarms = sis5595_read_value(client,SIS5595_REG_ALARM1);
|
|
data->last_updated = jiffies;
|
|
data->valid = 1;
|
|
}
|
|
|
|
up(&data->update_lock);
|
|
}
|
|
|
|
|
|
/* The next few functions are the call-back functions of the /proc/sys and
|
|
sysctl files. Which function is used is defined in the ctl_table in
|
|
the extra1 field.
|
|
Each function must return the magnitude (power of 10 to divide the date
|
|
with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
|
|
put a maximum of *nrels elements in results reflecting the data of this
|
|
file, and set *nrels to the number it actually put in it, if operation==
|
|
SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
|
|
results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
|
|
Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
|
|
large enough (by checking the incoming value of *nrels). This is not very
|
|
good practice, but as long as you put less than about 5 values in results,
|
|
you can assume it is large enough. */
|
|
void sis5595_in(struct i2c_client *client, int operation, int ctl_name,
|
|
int *nrels_mag, long *results)
|
|
{
|
|
struct sis5595_data *data = client->data;
|
|
int nr = ctl_name - SIS5595_SYSCTL_IN0;
|
|
|
|
if (operation == SENSORS_PROC_REAL_INFO)
|
|
*nrels_mag = 2;
|
|
else if (operation == SENSORS_PROC_REAL_READ) {
|
|
sis5595_update_client(client);
|
|
results[0] = IN_FROM_REG(data->in_min[nr]);
|
|
results[1] = IN_FROM_REG(data->in_max[nr]);
|
|
results[2] = IN_FROM_REG(data->in[nr]);
|
|
*nrels_mag = 3;
|
|
} else if (operation == SENSORS_PROC_REAL_WRITE) {
|
|
if (*nrels_mag >= 1) {
|
|
data->in_min[nr] = IN_TO_REG(results[0]);
|
|
sis5595_write_value(client,SIS5595_REG_IN_MIN(nr),data->in_min[nr]);
|
|
}
|
|
if (*nrels_mag >= 2) {
|
|
data->in_max[nr] = IN_TO_REG(results[1]);
|
|
sis5595_write_value(client,SIS5595_REG_IN_MAX(nr),data->in_max[nr]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void sis5595_fan(struct i2c_client *client, int operation, int ctl_name,
|
|
int *nrels_mag, long *results)
|
|
{
|
|
struct sis5595_data *data = client->data;
|
|
int nr = ctl_name - SIS5595_SYSCTL_FAN1 + 1;
|
|
|
|
if (operation == SENSORS_PROC_REAL_INFO)
|
|
*nrels_mag = 0;
|
|
else if (operation == SENSORS_PROC_REAL_READ) {
|
|
sis5595_update_client(client);
|
|
results[0] = FAN_FROM_REG(data->fan_min[nr-1],
|
|
DIV_FROM_REG(data->fan_div[nr-1]));
|
|
results[1] = FAN_FROM_REG(data->fan[nr-1],
|
|
DIV_FROM_REG(data->fan_div[nr-1]));
|
|
*nrels_mag = 2;
|
|
} else if (operation == SENSORS_PROC_REAL_WRITE) {
|
|
if (*nrels_mag >= 1) {
|
|
data->fan_min[nr-1] = FAN_TO_REG(results[0],
|
|
DIV_FROM_REG(data->fan_div[nr-1]));
|
|
sis5595_write_value(client,SIS5595_REG_FAN_MIN(nr),data->fan_min[nr-1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
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) {
|
|
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);
|
|
*nrels_mag = 3;
|
|
} else if (operation == SENSORS_PROC_REAL_WRITE) {
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
void sis5595_alarms(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 = 0;
|
|
else if (operation == SENSORS_PROC_REAL_READ) {
|
|
sis5595_update_client(client);
|
|
results[0] = ALARMS_FROM_REG(data->alarms);
|
|
*nrels_mag = 1;
|
|
}
|
|
}
|
|
|
|
void sis5595_fan_div(struct i2c_client *client, int operation, int ctl_name,
|
|
int *nrels_mag, long *results)
|
|
{
|
|
struct sis5595_data *data = client->data;
|
|
int old;
|
|
|
|
if (operation == SENSORS_PROC_REAL_INFO)
|
|
*nrels_mag = 0;
|
|
else if (operation == SENSORS_PROC_REAL_READ) {
|
|
sis5595_update_client(client);
|
|
results[0] = DIV_FROM_REG(data->fan_div[0]);
|
|
results[1] = DIV_FROM_REG(data->fan_div[1]);
|
|
*nrels_mag = 2;
|
|
} else if (operation == SENSORS_PROC_REAL_WRITE) {
|
|
old = sis5595_read_value(client,SIS5595_REG_FANDIV);
|
|
if (*nrels_mag >= 2) {
|
|
data->fan_div[1] = DIV_TO_REG(results[1]);
|
|
old = (old & 0x3f) | (data->fan_div[1] << 6);
|
|
}
|
|
if (*nrels_mag >= 1) {
|
|
data->fan_div[0] = DIV_TO_REG(results[0]);
|
|
old = (old & 0xcf) | (data->fan_div[0] << 4);
|
|
sis5595_write_value(client,SIS5595_REG_FANDIV,old);
|
|
}
|
|
}
|
|
}
|
|
|
|
int sis5595_init(void)
|
|
{
|
|
int res,addr;
|
|
|
|
printk("sis5595.o version %s (%s)\n",LM_VERSION,LM_DATE);
|
|
sis5595_initialized = 0;
|
|
|
|
if (sis5595_find_sis(&addr)) {
|
|
normal_isa[0] = SENSORS_ISA_END;
|
|
printk("sis5595.o: Warning: No SIS5595 southbridge found!\n");
|
|
} else
|
|
normal_isa[0] = addr;
|
|
|
|
if ((res =i2c_add_driver(&sis5595_driver))) {
|
|
printk("sis5595.o: Driver registration failed, module not inserted.\n");
|
|
sis5595_cleanup();
|
|
return res;
|
|
}
|
|
sis5595_initialized ++;
|
|
return 0;
|
|
}
|
|
|
|
int sis5595_cleanup(void)
|
|
{
|
|
int res;
|
|
|
|
if (sis5595_initialized >= 1) {
|
|
if ((res = i2c_del_driver(&sis5595_driver))) {
|
|
printk("sis5595.o: Driver deregistration failed, module not removed.\n");
|
|
return res;
|
|
}
|
|
sis5595_initialized --;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
#ifdef MODULE
|
|
|
|
MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>");
|
|
MODULE_DESCRIPTION("SiS 5595 Sensor device");
|
|
|
|
int init_module(void)
|
|
{
|
|
return sis5595_init();
|
|
}
|
|
|
|
int cleanup_module(void)
|
|
{
|
|
return sis5595_cleanup();
|
|
}
|
|
|
|
#endif /* MODULE */
|
|
|