root/lm-sensors/trunk/kernel/chips/fscscy.c @ 3147

Revision 3147, 33.9 KB (checked in by khali, 8 years ago)

Drop a common comment about limits being set in initialization
functions. We no more do that.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2    fscscy.c - Part of lm_sensors, Linux kernel modules for hardware
3             monitoring
4    Copyright (c) 2001 Martin Knoblauch <mkn@teraport.de, knobi@knobisoft.de>
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19*/
20
21/*
22    fujitsu siemens scylla chip,
23    module based on lm80.c, fscpos.c
24    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
25    and Philip Edelbrock <phil@netroedge.com>
26*/
27
28#include <linux/module.h>
29#include <linux/slab.h>
30#include <linux/i2c.h>
31#include <linux/i2c-proc.h>
32#include <linux/init.h>
33#include "version.h"
34
35MODULE_LICENSE("GPL");
36
37/* Addresses to scan */
38static unsigned short normal_i2c[] = { 0x73, SENSORS_I2C_END };
39static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
40static unsigned int normal_isa[] = { SENSORS_ISA_END };
41static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
42
43/* Insmod parameters */
44SENSORS_INSMOD_1(fscscy);
45
46/* The FSCSCY registers */
47
48/* chip identification */
49#define FSCSCY_REG_IDENT_0    0x00
50#define FSCSCY_REG_IDENT_1    0x01
51#define FSCSCY_REG_IDENT_2    0x02
52#define FSCSCY_REG_REVISION   0x03
53
54/* global control and status */
55#define FSCSCY_REG_EVENT_STATE  0x04
56#define FSCSCY_REG_CONTROL       0x05
57
58/* watchdog */
59#define FSCSCY_REG_WDOG_PRESET      0x28
60#define FSCSCY_REG_WDOG_STATE       0x23
61#define FSCSCY_REG_WDOG_CONTROL     0x21
62
63/*
64** Fan definitions
65**
66** _RPMMIN: Minimum speed. Can be set via interface, but only for three of the fans
67**          FAN1_RPMMIN is wired to Fan 0 (CPU Fans)
68**          FAN4_RPMMIN is wired to Fan 2 (PS Fans ??)
69**          FAN5_RPMMIN is wired to Fan 3 (AUX Fans ??)
70** _ACT:    Actual Fan Speed
71** _STATE:  Fan status register
72** _RIPPLE: Fan speed multiplier
73*/
74
75/* fan 0  */
76#define FSCSCY_REG_FAN0_RPMMIN  0x65
77#define FSCSCY_REG_FAN0_ACT     0x6b
78#define FSCSCY_REG_FAN0_STATE   0x62
79#define FSCSCY_REG_FAN0_RIPPLE  0x6f
80
81/* fan 1  */
82#define FSCSCY_REG_FAN1_RPMMIN     FSCSCY_REG_FAN0_RPMMIN
83#define FSCSCY_REG_FAN1_ACT     0x6c
84#define FSCSCY_REG_FAN1_STATE   0x61
85#define FSCSCY_REG_FAN1_RIPPLE  0x6f
86
87/* fan 2  */
88#define FSCSCY_REG_FAN2_RPMMIN     0x55
89#define FSCSCY_REG_FAN2_ACT     0x0e
90#define FSCSCY_REG_FAN2_STATE   0x0d
91#define FSCSCY_REG_FAN2_RIPPLE  0x0f
92
93/* fan 3  */
94#define FSCSCY_REG_FAN3_RPMMIN     0xa5
95#define FSCSCY_REG_FAN3_ACT     0xab
96#define FSCSCY_REG_FAN3_STATE   0xa2
97#define FSCSCY_REG_FAN3_RIPPLE  0xaf
98
99/* fan 4  */
100#define FSCSCY_REG_FAN4_RPMMIN     FSCSCY_REG_FAN2_RPMMIN
101#define FSCSCY_REG_FAN4_ACT     0x5c
102#define FSCSCY_REG_FAN4_STATE   0x52
103#define FSCSCY_REG_FAN4_RIPPLE  0x0f
104
105/* fan 5  */
106#define FSCSCY_REG_FAN5_RPMMIN     FSCSCY_REG_FAN3_RPMMIN
107#define FSCSCY_REG_FAN5_ACT     0xbb
108#define FSCSCY_REG_FAN5_STATE   0xb2
109#define FSCSCY_REG_FAN5_RIPPLE  0xbf
110
111/* voltage supervision */
112#define FSCSCY_REG_VOLT_12       0x45
113#define FSCSCY_REG_VOLT_5        0x42
114#define FSCSCY_REG_VOLT_BATT     0x48
115
116/* temperatures */
117/* sensor 0 */
118#define FSCSCY_REG_TEMP0_ACT    0x64
119#define FSCSCY_REG_TEMP0_STATE  0x71
120#define FSCSCY_REG_TEMP0_LIM    0x76
121
122/* sensor 1 */
123#define FSCSCY_REG_TEMP1_ACT    0xD0
124#define FSCSCY_REG_TEMP1_STATE  0xD1
125#define FSCSCY_REG_TEMP1_LIM    0xD6
126
127/* sensor 2 */
128#define FSCSCY_REG_TEMP2_ACT    0x32
129#define FSCSCY_REG_TEMP2_STATE  0x81
130#define FSCSCY_REG_TEMP2_LIM    0x86
131
132/* sensor3 */
133#define FSCSCY_REG_TEMP3_ACT    0x35
134#define FSCSCY_REG_TEMP3_STATE  0x91
135#define FSCSCY_REG_TEMP3_LIM    0x96
136
137/* PCI Load */
138#define FSCSCY_REG_PCILOAD      0x1a
139
140/* Intrusion Sensor */
141#define FSCSCY_REG_INTR_STATE   0x13
142#define FSCSCY_REG_INTR_CTRL    0x12
143
144/* Conversions. Rounding and limit checking is only done on the TO_REG
145   variants. Note that you should be a bit careful with which arguments
146   these macros are called: arguments may be evaluated more than once.
147   Fixing this is just not worth it. */
148
149#define IN_TO_REG(val,nr) (SENSORS_LIMIT((val),0,255))
150#define IN_FROM_REG(val,nr) (val)
151
152/* Initial limits */
153
154/* For each registered FSCSCY, we need to keep some data in memory. That
155   data is pointed to by fscscy_list[NR]->data. The structure itself is
156   dynamically allocated, at the same time when a new fscscy client is
157   allocated. */
158struct fscscy_data {
159        struct i2c_client client;
160        int sysctl_id;
161
162        struct semaphore update_lock;
163        char valid;             /* !=0 if following fields are valid */
164        unsigned long last_updated;     /* In jiffies */
165
166        u8  revision;        /* revision of chip */
167        u8  global_event;    /* global event status */
168        u8  global_control;  /* global control register */
169        u8  watchdog[3];     /* watchdog */
170        u8  volt[3];         /* 12, 5, battery current */ 
171        u8  volt_min[3];     /* minimum voltages over module "lifetime" */
172        u8  volt_max[3];     /* maximum voltages over module "lifetime" */
173        u8  temp_act[4];     /* temperature */
174        u8  temp_status[4];  /* status of temp. sensor */
175        u8  temp_lim[4];     /* limit temperature of temp. sensor */
176        u8  temp_min[4];     /* minimum of temp. sensor, this is just calculated by the module */
177        u8  temp_max[4];     /* maximum of temp. sensor, this is just calculsted by the module */
178        u8  fan_act[6];      /* fans revolutions per second */
179        u8  fan_status[6];   /* fan status */
180        u8  fan_rpmmin[6];   /* fan min value for rps */
181        u8  fan_ripple[6];   /* divider for rps */
182        u8  fan_min[6];      /* minimum RPM over module "lifetime" */
183        u8  fan_max[6];      /* maximum RPM over module "lifetime" */
184        u8  pciload;         /* PCILoad value */
185        u8  intr_status;     /* Intrusion Status */
186        u8  intr_control;    /* Intrusion Control */
187};
188
189
190static int fscscy_attach_adapter(struct i2c_adapter *adapter);
191static int fscscy_detect(struct i2c_adapter *adapter, int address,
192                       unsigned short flags, int kind);
193static int fscscy_detach_client(struct i2c_client *client);
194
195static int fscscy_read_value(struct i2c_client *client, u8 register);
196static int fscscy_write_value(struct i2c_client *client, u8 register,
197                            u8 value);
198static void fscscy_update_client(struct i2c_client *client);
199static void fscscy_init_client(struct i2c_client *client);
200
201
202static void fscscy_in(struct i2c_client *client, int operation, int ctl_name,
203                        int *nrels_mag, long *results);
204static void fscscy_fan(struct i2c_client *client, int operation,
205                        int ctl_name, int *nrels_mag, long *results);
206static void fscscy_fan_internal(struct i2c_client *client, int operation,
207                        int ctl_name, int *nrels_mag, long *results, 
208                        int nr, int reg_state, int reg_min, int res_ripple);
209static void fscscy_temp(struct i2c_client *client, int operation,
210                        int ctl_name, int *nrels_mag, long *results);
211static void fscscy_volt(struct i2c_client *client, int operation,
212                        int ctl_name, int *nrels_mag, long *results);
213static void fscscy_wdog(struct i2c_client *client, int operation,
214                        int ctl_name, int *nrels_mag, long *results);
215static void fscscy_pciload(struct i2c_client *client, int operation,
216                        int ctl_name, int *nrels_mag, long *results);
217static void fscscy_intrusion(struct i2c_client *client, int operation,
218                        int ctl_name, int *nrels_mag, long *results);
219
220static struct i2c_driver fscscy_driver = {
221        .name           = "FSCSCY sensor driver",
222        .id             = I2C_DRIVERID_FSCSCY,
223        .flags          = I2C_DF_NOTIFY,
224        .attach_adapter = fscscy_attach_adapter,
225        .detach_client  = fscscy_detach_client,
226};
227
228/* The /proc/sys entries */
229
230/* -- SENSORS SYSCTL START -- */
231#define FSCSCY_SYSCTL_VOLT0    1000       /* 12 volt supply */
232#define FSCSCY_SYSCTL_VOLT1    1001       /* 5 volt supply */
233#define FSCSCY_SYSCTL_VOLT2    1002       /* batterie voltage*/
234#define FSCSCY_SYSCTL_FAN0     1101       /* state, min, ripple, actual value fan 0 */
235#define FSCSCY_SYSCTL_FAN1     1102       /* state, min, ripple, actual value fan 1 */
236#define FSCSCY_SYSCTL_FAN2     1103       /* state, min, ripple, actual value fan 2 */
237#define FSCSCY_SYSCTL_FAN3     1104       /* state, min, ripple, actual value fan 3 */
238#define FSCSCY_SYSCTL_FAN4     1105       /* state, min, ripple, actual value fan 4 */
239#define FSCSCY_SYSCTL_FAN5     1106       /* state, min, ripple, actual value fan 5 */
240#define FSCSCY_SYSCTL_TEMP0    1201       /* state and value of sensor 0, cpu die */
241#define FSCSCY_SYSCTL_TEMP1    1202       /* state and value of sensor 1, motherboard */
242#define FSCSCY_SYSCTL_TEMP2    1203       /* state and value of sensor 2, chassis */
243#define FSCSCY_SYSCTL_TEMP3    1204       /* state and value of sensor 3, chassis */
244#define FSCSCY_SYSCTL_REV     2000        /* Revision */
245#define FSCSCY_SYSCTL_EVENT   2001        /* global event status */
246#define FSCSCY_SYSCTL_CONTROL 2002        /* global control byte */
247#define FSCSCY_SYSCTL_WDOG     2003       /* state, min, ripple, actual value fan 2 */
248#define FSCSCY_SYSCTL_PCILOAD  2004       /* PCILoad value */
249#define FSCSCY_SYSCTL_INTRUSION 2005      /* state, control for intrusion sensor */
250
251/* -- SENSORS SYSCTL END -- */
252
253/* These files are created for each detected FSCSCY. This is just a template;
254   though at first sight, you might think we could use a statically
255   allocated list, we need some way to get back to the parent - which
256   is done through one of the 'extra' fields which are initialized
257   when a new copy is allocated. */
258static ctl_table fscscy_dir_table_template[] = {
259        {FSCSCY_SYSCTL_REV, "rev", NULL, 0, 0444, NULL, &i2c_proc_real,
260         &i2c_sysctl_real, NULL, &fscscy_in},
261        {FSCSCY_SYSCTL_EVENT, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
262         &i2c_sysctl_real, NULL, &fscscy_in},
263        {FSCSCY_SYSCTL_CONTROL, "control", NULL, 0, 0644, NULL, &i2c_proc_real,
264         &i2c_sysctl_real, NULL, &fscscy_in},
265        {FSCSCY_SYSCTL_TEMP0, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
266         &i2c_sysctl_real, NULL, &fscscy_temp},
267        {FSCSCY_SYSCTL_TEMP1, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
268         &i2c_sysctl_real, NULL, &fscscy_temp},
269        {FSCSCY_SYSCTL_TEMP2, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
270         &i2c_sysctl_real, NULL, &fscscy_temp},
271        {FSCSCY_SYSCTL_TEMP3, "temp4", NULL, 0, 0644, NULL, &i2c_proc_real,
272         &i2c_sysctl_real, NULL, &fscscy_temp},
273        {FSCSCY_SYSCTL_VOLT0, "in0", NULL, 0, 0444, NULL, &i2c_proc_real,
274         &i2c_sysctl_real, NULL, &fscscy_volt},
275        {FSCSCY_SYSCTL_VOLT1, "in1", NULL, 0, 0444, NULL, &i2c_proc_real,
276         &i2c_sysctl_real, NULL, &fscscy_volt},
277        {FSCSCY_SYSCTL_VOLT2, "in2", NULL, 0, 0444, NULL, &i2c_proc_real,
278         &i2c_sysctl_real, NULL, &fscscy_volt},
279        {FSCSCY_SYSCTL_FAN0, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
280         &i2c_sysctl_real, NULL, &fscscy_fan},
281        {FSCSCY_SYSCTL_FAN1, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
282         &i2c_sysctl_real, NULL, &fscscy_fan},
283        {FSCSCY_SYSCTL_FAN2, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
284         &i2c_sysctl_real, NULL, &fscscy_fan},
285        {FSCSCY_SYSCTL_FAN3, "fan4", NULL, 0, 0644, NULL, &i2c_proc_real,
286         &i2c_sysctl_real, NULL, &fscscy_fan},
287        {FSCSCY_SYSCTL_FAN4, "fan5", NULL, 0, 0644, NULL, &i2c_proc_real,
288         &i2c_sysctl_real, NULL, &fscscy_fan},
289        {FSCSCY_SYSCTL_FAN5, "fan6", NULL, 0, 0644, NULL, &i2c_proc_real,
290         &i2c_sysctl_real, NULL, &fscscy_fan},
291        {FSCSCY_SYSCTL_WDOG, "wdog", NULL, 0, 0644, NULL, &i2c_proc_real,
292         &i2c_sysctl_real, NULL, &fscscy_wdog},
293        {FSCSCY_SYSCTL_PCILOAD, "pciload", NULL, 0, 0444, NULL, &i2c_proc_real,
294         &i2c_sysctl_real, NULL, &fscscy_pciload},
295        {FSCSCY_SYSCTL_INTRUSION, "intrusion", NULL, 0, 0644, NULL, &i2c_proc_real,
296         &i2c_sysctl_real, NULL, &fscscy_intrusion},
297        {0}
298};
299
300static int fscscy_attach_adapter(struct i2c_adapter *adapter)
301{
302        return i2c_detect(adapter, &addr_data, fscscy_detect);
303}
304
305int fscscy_detect(struct i2c_adapter *adapter, int address,
306                unsigned short flags, int kind)
307{
308        int i;
309        struct i2c_client *new_client;
310        struct fscscy_data *data;
311        int err = 0;
312        const char *type_name, *client_name;
313
314        /* Make sure we aren't probing the ISA bus!! This is just a safety check
315           at this moment; i2c_detect really won't call us. */
316#ifdef DEBUG
317        if (i2c_is_isa_adapter(adapter)) {
318                printk
319                    ("fscscy.o: fscscy_detect called for an ISA bus adapter?!?\n");
320                return 0;
321        }
322#endif
323
324        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
325                goto ERROR0;
326
327        /* OK. For now, we presume we have a valid client. We now create the
328           client structure, even though we cannot fill it completely yet.
329           But it allows us to access fscscy_{read,write}_value. */
330        if (!(data = kmalloc(sizeof(struct fscscy_data), GFP_KERNEL))) {
331                err = -ENOMEM;
332                goto ERROR0;
333        }
334
335        new_client = &data->client;
336        new_client->addr = address;
337        new_client->data = data;
338        new_client->adapter = adapter;
339        new_client->driver = &fscscy_driver;
340        new_client->flags = 0;
341
342        /* Do the remaining detection unless force or force_fscscy parameter */
343        if (kind < 0) {
344                if (fscscy_read_value(new_client, FSCSCY_REG_IDENT_0) != 0x53)
345                        goto ERROR1;
346                if (fscscy_read_value(new_client, FSCSCY_REG_IDENT_1) != 0x43)
347                        goto ERROR1;
348                if (fscscy_read_value(new_client, FSCSCY_REG_IDENT_2) != 0x59)
349                        goto ERROR1;
350        }
351
352        kind = fscscy;
353
354        type_name = "fscscy";
355        client_name = "fsc scylla chip";
356
357        /* Fill in the remaining client fields and put it into the global list */
358        strcpy(new_client->name, client_name);
359        data->valid = 0;
360        init_MUTEX(&data->update_lock);
361
362        /* Tell the I2C layer a new client has arrived */
363        if ((err = i2c_attach_client(new_client)))
364                goto ERROR3;
365
366        /* Register a new directory entry with module sensors */
367        if ((i = i2c_register_entry(new_client, type_name,
368                                        fscscy_dir_table_template,
369                                        THIS_MODULE)) < 0) {
370                err = i;
371                goto ERROR4;
372        }
373        data->sysctl_id = i;
374
375        fscscy_init_client(new_client);
376        return 0;
377
378/* OK, this is not exactly good programming practice, usually. But it is
379   very code-efficient in this case. */
380      ERROR4:
381        i2c_detach_client(new_client);
382      ERROR3:
383      ERROR1:
384        kfree(data);
385      ERROR0:
386        return err;
387}
388
389static int fscscy_detach_client(struct i2c_client *client)
390{
391        int err;
392
393        i2c_deregister_entry(((struct fscscy_data *) (client->data))->
394                                 sysctl_id);
395
396        if ((err = i2c_detach_client(client))) {
397                printk
398                    ("fscscy.o: Client deregistration failed, client not detached.\n");
399                return err;
400        }
401
402        kfree(client->data);
403
404        return 0;
405}
406
407static int fscscy_read_value(struct i2c_client *client, u8 reg)
408{
409#ifdef DEBUG
410        printk("fscscy: read reg 0x%02x\n",reg);
411#endif
412        return i2c_smbus_read_byte_data(client, reg);
413}
414
415static int fscscy_write_value(struct i2c_client *client, u8 reg, u8 value)
416{
417#ifdef DEBUG
418        printk("fscscy: write reg 0x%02x, val 0x%02x\n",reg, value);
419#endif
420        return i2c_smbus_write_byte_data(client, reg, value);
421}
422
423/* Called when we have found a new FSCSCY. */
424static void fscscy_init_client(struct i2c_client *client)
425{
426        struct fscscy_data *data = client->data;
427
428        /* read revision from chip */
429        data->revision =  fscscy_read_value(client,FSCSCY_REG_REVISION);
430
431        /* Initialize min/max values from chip */
432        data->fan_min[0]  = data->fan_max[0]  = fscscy_read_value(client, FSCSCY_REG_FAN0_ACT);
433        data->fan_min[1]  = data->fan_max[1]  = fscscy_read_value(client, FSCSCY_REG_FAN1_ACT);
434        data->fan_min[2]  = data->fan_max[2]  = fscscy_read_value(client, FSCSCY_REG_FAN2_ACT);
435        data->fan_min[3]  = data->fan_max[3]  = fscscy_read_value(client, FSCSCY_REG_FAN3_ACT);
436        data->fan_min[4]  = data->fan_max[4]  = fscscy_read_value(client, FSCSCY_REG_FAN4_ACT);
437        data->fan_min[4]  = data->fan_max[5]  = fscscy_read_value(client, FSCSCY_REG_FAN5_ACT);
438        data->temp_min[0] = data->temp_max[0] = fscscy_read_value(client, FSCSCY_REG_TEMP0_ACT);
439        data->temp_min[1] = data->temp_max[1] = fscscy_read_value(client, FSCSCY_REG_TEMP1_ACT);
440        data->temp_min[2] = data->temp_max[2] = fscscy_read_value(client, FSCSCY_REG_TEMP2_ACT);
441        data->temp_min[3] = data->temp_max[3] = fscscy_read_value(client, FSCSCY_REG_TEMP3_ACT);
442        data->volt_min[0] = data->volt_max[0] = fscscy_read_value(client, FSCSCY_REG_VOLT_12);
443        data->volt_min[1] = data->volt_max[1] = fscscy_read_value(client, FSCSCY_REG_VOLT_5);
444        data->volt_min[2] = data->volt_max[2] = fscscy_read_value(client, FSCSCY_REG_VOLT_BATT);
445}
446
447static void fscscy_update_client(struct i2c_client *client)
448{
449        struct fscscy_data *data = client->data;
450
451        down(&data->update_lock);
452
453        if ((jiffies - data->last_updated > 2 * HZ) ||
454            (jiffies < data->last_updated) || !data->valid) {
455
456#ifdef DEBUG
457                printk("Starting fscscy update\n");
458#endif
459                data->temp_act[0] = fscscy_read_value(client, FSCSCY_REG_TEMP0_ACT);
460                  if (data->temp_min[0] > data->temp_act[0]) data->temp_min[0] = data->temp_act[0];
461                  if (data->temp_max[0] < data->temp_act[0]) data->temp_max[0] = data->temp_act[0];
462                data->temp_act[1] = fscscy_read_value(client, FSCSCY_REG_TEMP1_ACT);
463                  if (data->temp_min[1] > data->temp_act[1]) data->temp_min[1] = data->temp_act[1];
464                  if (data->temp_max[1] < data->temp_act[1]) data->temp_max[1] = data->temp_act[1];
465                data->temp_act[2] = fscscy_read_value(client, FSCSCY_REG_TEMP2_ACT);
466                  if (data->temp_min[2] > data->temp_act[2]) data->temp_min[2] = data->temp_act[2];
467                  if (data->temp_max[2] < data->temp_act[2]) data->temp_max[2] = data->temp_act[2];
468                data->temp_act[3] = fscscy_read_value(client, FSCSCY_REG_TEMP3_ACT);
469                  if (data->temp_min[3] > data->temp_act[3]) data->temp_min[3] = data->temp_act[3];
470                  if (data->temp_max[3] < data->temp_act[3]) data->temp_max[3] = data->temp_act[3];
471                data->temp_status[0] = fscscy_read_value(client, FSCSCY_REG_TEMP0_STATE);
472                data->temp_status[1] = fscscy_read_value(client, FSCSCY_REG_TEMP1_STATE);
473                data->temp_status[2] = fscscy_read_value(client, FSCSCY_REG_TEMP2_STATE);
474                data->temp_status[3] = fscscy_read_value(client, FSCSCY_REG_TEMP3_STATE);
475                data->temp_lim[0] = fscscy_read_value(client, FSCSCY_REG_TEMP0_LIM);
476                data->temp_lim[1] = fscscy_read_value(client, FSCSCY_REG_TEMP1_LIM);
477                data->temp_lim[2] = fscscy_read_value(client, FSCSCY_REG_TEMP2_LIM);
478                data->temp_lim[3] = fscscy_read_value(client, FSCSCY_REG_TEMP3_LIM);
479
480                data->volt[0] = fscscy_read_value(client, FSCSCY_REG_VOLT_12);
481                  if (data->volt_min[0] > data->volt[0]) data->volt_min[0] = data->volt[0];
482                  if (data->volt_max[0] < data->volt[0]) data->volt_max[0] = data->volt[0];
483                data->volt[1] = fscscy_read_value(client, FSCSCY_REG_VOLT_5);
484                  if (data->volt_min[1] > data->volt[1]) data->volt_min[1] = data->volt[1];
485                  if (data->volt_max[1] < data->volt[1]) data->volt_max[1] = data->volt[1];
486                data->volt[2] = fscscy_read_value(client, FSCSCY_REG_VOLT_BATT);
487                  if (data->volt_min[2] > data->volt[2]) data->volt_min[2] = data->volt[2];
488                  if (data->volt_max[2] < data->volt[2]) data->volt_max[2] = data->volt[2];
489
490                data->fan_act[0] = fscscy_read_value(client, FSCSCY_REG_FAN0_ACT);
491                  if (data->fan_min[0] > data->fan_act[0]) data->fan_min[0] = data->fan_act[0];
492                  if (data->fan_max[0] < data->fan_act[0]) data->fan_max[0] = data->fan_act[0];
493                data->fan_act[1] = fscscy_read_value(client, FSCSCY_REG_FAN1_ACT);
494                  if (data->fan_min[1] > data->fan_act[1]) data->fan_min[1] = data->fan_act[1];
495                  if (data->fan_max[1] < data->fan_act[1]) data->fan_max[1] = data->fan_act[1];
496                data->fan_act[2] = fscscy_read_value(client, FSCSCY_REG_FAN2_ACT);
497                  if (data->fan_min[2] > data->fan_act[2]) data->fan_min[2] = data->fan_act[2];
498                  if (data->fan_max[2] < data->fan_act[2]) data->fan_max[2] = data->fan_act[2];
499                data->fan_act[3] = fscscy_read_value(client, FSCSCY_REG_FAN3_ACT);
500                  if (data->fan_min[3] > data->fan_act[3]) data->fan_min[3] = data->fan_act[3];
501                  if (data->fan_max[3] < data->fan_act[3]) data->fan_max[3] = data->fan_act[3];
502                data->fan_act[4] = fscscy_read_value(client, FSCSCY_REG_FAN4_ACT);
503                  if (data->fan_min[4] > data->fan_act[4]) data->fan_min[4] = data->fan_act[4];
504                  if (data->fan_max[4] < data->fan_act[4]) data->fan_max[4] = data->fan_act[4];
505                data->fan_act[5] = fscscy_read_value(client, FSCSCY_REG_FAN5_ACT);
506                  if (data->fan_min[5] > data->fan_act[5]) data->fan_min[5] = data->fan_act[5];
507                  if (data->fan_max[5] < data->fan_act[5]) data->fan_max[5] = data->fan_act[5];
508                data->fan_status[0] = fscscy_read_value(client, FSCSCY_REG_FAN0_STATE);
509                data->fan_status[1] = fscscy_read_value(client, FSCSCY_REG_FAN1_STATE);
510                data->fan_status[2] = fscscy_read_value(client, FSCSCY_REG_FAN2_STATE);
511                data->fan_status[3] = fscscy_read_value(client, FSCSCY_REG_FAN3_STATE);
512                data->fan_status[4] = fscscy_read_value(client, FSCSCY_REG_FAN4_STATE);
513                data->fan_status[5] = fscscy_read_value(client, FSCSCY_REG_FAN5_STATE);
514                data->fan_rpmmin[0] = fscscy_read_value(client, FSCSCY_REG_FAN0_RPMMIN);
515                data->fan_rpmmin[1] = fscscy_read_value(client, FSCSCY_REG_FAN1_RPMMIN);
516                data->fan_rpmmin[2] = fscscy_read_value(client, FSCSCY_REG_FAN2_RPMMIN);
517                data->fan_rpmmin[3] = fscscy_read_value(client, FSCSCY_REG_FAN3_RPMMIN);
518                data->fan_rpmmin[4] = fscscy_read_value(client, FSCSCY_REG_FAN4_RPMMIN);
519                data->fan_rpmmin[5] = fscscy_read_value(client, FSCSCY_REG_FAN5_RPMMIN);
520                data->fan_ripple[0] = fscscy_read_value(client, FSCSCY_REG_FAN0_RIPPLE);
521                data->fan_ripple[1] = fscscy_read_value(client, FSCSCY_REG_FAN1_RIPPLE);
522                data->fan_ripple[2] = fscscy_read_value(client, FSCSCY_REG_FAN2_RIPPLE);
523                data->fan_ripple[3] = fscscy_read_value(client, FSCSCY_REG_FAN3_RIPPLE);
524                data->fan_ripple[4] = fscscy_read_value(client, FSCSCY_REG_FAN4_RIPPLE);
525                data->fan_ripple[5] = fscscy_read_value(client, FSCSCY_REG_FAN5_RIPPLE);
526
527                data->watchdog[0] = fscscy_read_value(client, FSCSCY_REG_WDOG_PRESET);
528                data->watchdog[1] = fscscy_read_value(client, FSCSCY_REG_WDOG_STATE);
529                data->watchdog[2] = fscscy_read_value(client, FSCSCY_REG_WDOG_CONTROL);
530
531                data->global_event = fscscy_read_value(client, FSCSCY_REG_EVENT_STATE);
532                data->global_control = fscscy_read_value(client, FSCSCY_REG_CONTROL);
533                data->pciload = fscscy_read_value(client, FSCSCY_REG_PCILOAD);
534                data->intr_status = fscscy_read_value(client, FSCSCY_REG_INTR_STATE);
535                data->intr_control = fscscy_read_value(client, FSCSCY_REG_INTR_CTRL);
536
537                data->last_updated = jiffies;
538                data->valid = 1;                 
539        }
540
541        up(&data->update_lock);
542}
543
544
545/* The next few functions are the call-back functions of the /proc/sys and
546   sysctl files. Which function is used is defined in the ctl_table in
547   the extra1 field.
548   Each function must return the magnitude (power of 10 to divide the date
549   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
550   put a maximum of *nrels elements in results reflecting the data of this
551   file, and set *nrels to the number it actually put in it, if operation==
552   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
553   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
554   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
555   large enough (by checking the incoming value of *nrels). This is not very
556   good practice, but as long as you put less than about 5 values in results,
557   you can assume it is large enough. */
558void fscscy_in(struct i2c_client *client, int operation, int ctl_name,
559             int *nrels_mag, long *results)
560{
561        struct fscscy_data *data = client->data;
562
563        if (operation == SENSORS_PROC_REAL_INFO)
564                *nrels_mag = 0;
565        else if (operation == SENSORS_PROC_REAL_READ) {
566                fscscy_update_client(client);
567                switch(ctl_name) {
568                        case FSCSCY_SYSCTL_REV:
569                                results[0] = data->revision ;
570                                break;
571                        case FSCSCY_SYSCTL_EVENT:
572                                results[0] = data->global_event & 0x9f; /* MKN */
573                                break;
574                        case FSCSCY_SYSCTL_CONTROL:
575                                results[0] = data->global_control & 0x19; /* MKN */
576                                break;
577                        default:
578                                printk("fscscy: ctl_name %d not supported\n",
579                                        ctl_name);
580                                *nrels_mag = 0;
581                                return;
582                }
583                *nrels_mag = 1;
584        } else if (operation == SENSORS_PROC_REAL_WRITE) {
585                if((ctl_name == FSCSCY_SYSCTL_CONTROL) && (*nrels_mag >= 1)) {
586                        data->global_control = (data->global_control & 0x18) | (results[0] & 0x01); /* MKN */
587                        printk("fscscy: writing 0x%02x to global_control\n",
588                                data->global_control);
589                        fscscy_write_value(client,FSCSCY_REG_CONTROL,
590                                data->global_control);
591                }
592                else
593                        printk("fscscy: writing to chip not supported\n");
594        }
595}
596
597#define TEMP_FROM_REG(val)    (val-128)
598
599
600void fscscy_temp(struct i2c_client *client, int operation, int ctl_name,
601               int *nrels_mag, long *results)
602{
603        struct fscscy_data *data = client->data;
604
605        if (operation == SENSORS_PROC_REAL_INFO)
606                *nrels_mag = 0;
607        else if (operation == SENSORS_PROC_REAL_READ) {
608                fscscy_update_client(client);
609                switch(ctl_name) {
610                        case FSCSCY_SYSCTL_TEMP0:
611                                results[0] = data->temp_status[0] & 0x03;
612                                results[1] = TEMP_FROM_REG(data->temp_act[0]);
613                                results[2] = TEMP_FROM_REG(data->temp_lim[0]);
614                                results[3] = TEMP_FROM_REG(data->temp_min[0]);
615                                results[4] = TEMP_FROM_REG(data->temp_max[0]);
616                                break;
617                        case FSCSCY_SYSCTL_TEMP1:
618                                results[0] = data->temp_status[1] & 0x03;
619                                results[1] = TEMP_FROM_REG(data->temp_act[1]);
620                                results[2] = TEMP_FROM_REG(data->temp_lim[1]);
621                                results[3] = TEMP_FROM_REG(data->temp_min[1]);
622                                results[4] = TEMP_FROM_REG(data->temp_max[1]);
623                                break;
624                        case FSCSCY_SYSCTL_TEMP2:
625                                results[0] = data->temp_status[2] & 0x03;
626                                results[1] = TEMP_FROM_REG(data->temp_act[2]);
627                                results[2] = TEMP_FROM_REG(data->temp_lim[2]);
628                                results[3] = TEMP_FROM_REG(data->temp_min[2]);
629                                results[4] = TEMP_FROM_REG(data->temp_max[2]);
630                                break;
631                        case FSCSCY_SYSCTL_TEMP3:
632                                results[0] = data->temp_status[3] & 0x03;
633                                results[1] = TEMP_FROM_REG(data->temp_act[3]);
634                                results[2] = TEMP_FROM_REG(data->temp_lim[3]);
635                                results[3] = TEMP_FROM_REG(data->temp_min[3]);
636                                results[4] = TEMP_FROM_REG(data->temp_max[3]);
637                                break;
638                        default:
639                                printk("fscscy: ctl_name %d not supported\n",
640                                        ctl_name);
641                                *nrels_mag = 0;
642                                return;
643                }
644                *nrels_mag = 5;
645        } else if (operation == SENSORS_PROC_REAL_WRITE) {
646                if(*nrels_mag >= 1) {
647                        switch(ctl_name) {
648                                case FSCSCY_SYSCTL_TEMP0:
649                                        data->temp_status[0] = 
650                                                (data->temp_status[0] & ~0x02) 
651                                                | (results[0] & 0x02);
652                                        printk("fscscy: writing value 0x%02x "
653                                                "to temp0_status\n",
654                                                data->temp_status[0]);
655                                        fscscy_write_value(client,
656                                                FSCSCY_REG_TEMP0_STATE,
657                                                data->temp_status[0] & 0x02);
658                                        break;
659                                case FSCSCY_SYSCTL_TEMP1:
660                                        data->temp_status[1] = (data->temp_status[1] & ~0x02) | (results[0] & 0x02);
661                                        printk("fscscy: writing value 0x%02x to temp1_status\n", data->temp_status[1]);
662                                        fscscy_write_value(client,FSCSCY_REG_TEMP1_STATE,
663                                                data->temp_status[1] & 0x02);
664                                        break;
665                                case FSCSCY_SYSCTL_TEMP2:
666                                        data->temp_status[2] = (data->temp_status[2] & ~0x02) | (results[0] & 0x02);
667                                        printk("fscscy: writing value 0x%02x to temp2_status\n", data->temp_status[2]);
668                                        fscscy_write_value(client,FSCSCY_REG_TEMP2_STATE,
669                                                data->temp_status[2] & 0x02);
670                                        break;
671                                case FSCSCY_SYSCTL_TEMP3:
672                                        data->temp_status[3] = (data->temp_status[3] & ~0x02) | (results[0] & 0x02);
673                                        printk("fscscy: writing value 0x%02x to temp3_status\n", data->temp_status[3]);
674                                        fscscy_write_value(client,FSCSCY_REG_TEMP3_STATE,
675                                                data->temp_status[3] & 0x02);
676                                        break;
677                                default:
678                                        printk("fscscy: ctl_name %d not supported\n",ctl_name);
679                        }
680                }
681                else
682                        printk("fscscy: writing to chip not supported\n");
683        }
684}
685
686#define VOLT_FROM_REG(val,mult)    (val*mult/255)
687
688void fscscy_volt(struct i2c_client *client, int operation, int ctl_name,
689               int *nrels_mag, long *results)
690{
691        struct fscscy_data *data = client->data;
692        if (operation == SENSORS_PROC_REAL_INFO)
693                *nrels_mag = 2;
694        else if (operation == SENSORS_PROC_REAL_READ) {
695                fscscy_update_client(client);
696                switch(ctl_name) {
697                        case FSCSCY_SYSCTL_VOLT0:
698                                results[0] = VOLT_FROM_REG(data->volt[0],1420);
699                                results[1] = VOLT_FROM_REG(data->volt_min[0],1420);
700                                results[2] = VOLT_FROM_REG(data->volt_max[0],1420);
701                                break;
702                        case FSCSCY_SYSCTL_VOLT1:
703                                results[0] = VOLT_FROM_REG(data->volt[1],660);
704                                results[1] = VOLT_FROM_REG(data->volt_min[1],660);
705                                results[2] = VOLT_FROM_REG(data->volt_max[1],660);
706                                break;
707                        case FSCSCY_SYSCTL_VOLT2:
708                                results[0] = VOLT_FROM_REG(data->volt[2],330);
709                                results[1] = VOLT_FROM_REG(data->volt_min[2],330);
710                                results[2] = VOLT_FROM_REG(data->volt_max[2],330);
711                                break;
712                        default:
713                                printk("fscscy: ctl_name %d not supported\n",
714                                        ctl_name);
715                                *nrels_mag = 0;
716                                return;
717                }
718                *nrels_mag = 3;
719        } else if (operation == SENSORS_PROC_REAL_WRITE) {
720                        printk("fscscy: writing to chip not supported\n");
721        }
722}
723
724void fscscy_fan(struct i2c_client *client, int operation, int ctl_name,
725               int *nrels_mag, long *results)
726{
727
728        switch(ctl_name) {
729                case FSCSCY_SYSCTL_FAN0:
730                        fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
731                                0,FSCSCY_REG_FAN0_STATE,FSCSCY_REG_FAN0_RPMMIN,
732                                FSCSCY_REG_FAN0_RIPPLE);
733                        break;
734                case FSCSCY_SYSCTL_FAN1:
735                        fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
736                                1,FSCSCY_REG_FAN1_STATE,FSCSCY_REG_FAN1_RPMMIN,
737                                FSCSCY_REG_FAN1_RIPPLE);
738                        break;
739                case FSCSCY_SYSCTL_FAN2:
740                        fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
741                                2,FSCSCY_REG_FAN2_STATE,FSCSCY_REG_FAN2_RPMMIN,
742                                FSCSCY_REG_FAN2_RIPPLE);
743                        break;
744                case FSCSCY_SYSCTL_FAN3:
745                        fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
746                                3,FSCSCY_REG_FAN3_STATE,FSCSCY_REG_FAN3_RPMMIN,
747                                FSCSCY_REG_FAN3_RIPPLE);
748                        break;
749                case FSCSCY_SYSCTL_FAN4:
750                        fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
751                                4,FSCSCY_REG_FAN4_STATE,FSCSCY_REG_FAN4_RPMMIN,
752                                FSCSCY_REG_FAN4_RIPPLE);
753                        break;
754                case FSCSCY_SYSCTL_FAN5:
755                        fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
756                                5,FSCSCY_REG_FAN5_STATE,FSCSCY_REG_FAN5_RPMMIN,
757                                FSCSCY_REG_FAN5_RIPPLE);
758                        break;
759                default:
760                        printk("fscscy: illegal fan nr %d\n",ctl_name);
761        }
762}
763                       
764#define RPM_FROM_REG(val)   (val*60)
765
766void fscscy_fan_internal(struct i2c_client *client, int operation, int ctl_name,
767               int *nrels_mag, long *results, int nr,
768               int reg_state, int reg_min, int reg_ripple )
769{
770        struct fscscy_data *data = client->data;
771
772        if (operation == SENSORS_PROC_REAL_INFO)
773                *nrels_mag = 0;
774        else if (operation == SENSORS_PROC_REAL_READ) {
775                fscscy_update_client(client);
776                results[0] = data->fan_status[nr] & 0x0f; /* MKN */
777                results[1] = data->fan_rpmmin[nr];
778                results[2] = data->fan_ripple[nr] & 0x03;
779                results[3] = RPM_FROM_REG(data->fan_act[nr]);
780                results[4] = RPM_FROM_REG(data->fan_min[nr]);
781                results[5] = RPM_FROM_REG(data->fan_max[nr]);
782                *nrels_mag = 6;
783        } else if (operation == SENSORS_PROC_REAL_WRITE) {
784                if(*nrels_mag >= 1) {
785                        data->fan_status[nr] = (data->fan_status[nr] & 0x0b) | (results[0] & 0x04); /* MKN */
786                        printk("fscscy: writing value 0x%02x to fan%d_status\n",
787                                data->fan_status[nr],nr);
788                        fscscy_write_value(client,reg_state,
789                                data->fan_status[nr]);
790                }
791                if(*nrels_mag >= 2)  {
792                        if((results[1] & 0xff) == 0) {
793                                 printk("fscscy: fan%d rpmmin 0 not allowed for safety reasons\n",nr);
794                                 return;
795                        }
796                        data->fan_rpmmin[nr] = results[1];
797                        printk("fscscy: writing value 0x%02x to fan%d_min\n",
798                                data->fan_rpmmin[nr],nr);
799                        fscscy_write_value(client,reg_min,
800                                data->fan_rpmmin[nr]);
801                }
802                if(*nrels_mag >= 3) {
803                        if((results[2] & 0x03) == 0) {
804                                printk("fscscy: fan%d ripple 0 is nonsense/not allowed\n",nr);
805                                return;
806                        }
807                        data->fan_ripple[nr] = results[2] & 0x03;
808                        printk("fscscy: writing value 0x%02x to fan%d_ripple\n",
809                                data->fan_ripple[nr],nr);
810                        fscscy_write_value(client,reg_ripple,
811                                data->fan_ripple[nr]);
812                }       
813        }
814}
815
816void fscscy_wdog(struct i2c_client *client, int operation, int ctl_name,
817             int *nrels_mag, long *results)
818{
819        struct fscscy_data *data = client->data;
820
821        if (operation == SENSORS_PROC_REAL_INFO)
822                *nrels_mag = 0;
823        else if (operation == SENSORS_PROC_REAL_READ) {
824                fscscy_update_client(client);
825                results[0] = data->watchdog[0] ;
826                results[1] = data->watchdog[1] & 0x02;
827                results[2] = data->watchdog[2] & 0xb0;
828                *nrels_mag = 3;
829        } else if (operation == SENSORS_PROC_REAL_WRITE) {
830                if (*nrels_mag >= 1) {
831                        data->watchdog[0] = results[0] & 0xff;
832                        printk("fscscy: writing value 0x%02x to wdog_preset\n",
833                                data->watchdog[0]); 
834                        fscscy_write_value(client,FSCSCY_REG_WDOG_PRESET,
835                                data->watchdog[0]);
836                } 
837                if (*nrels_mag >= 2) {
838                        data->watchdog[1] = results[1] & 0x02;
839                        printk("fscscy: writing value 0x%02x to wdog_state\n",
840                                data->watchdog[1]); 
841                        fscscy_write_value(client,FSCSCY_REG_WDOG_STATE,
842                                data->watchdog[1]);
843                }
844                if (*nrels_mag >= 3) {
845                        data->watchdog[2] = results[2] & 0xb0;
846                        printk("fscscy: writing value 0x%02x to wdog_control\n",
847                                data->watchdog[2]); 
848                        fscscy_write_value(client,FSCSCY_REG_WDOG_CONTROL,
849                                data->watchdog[2]);
850                }
851        }
852}
853
854void fscscy_pciload(struct i2c_client *client, int operation, int ctl_name,
855               int *nrels_mag, long *results)
856{
857        struct fscscy_data *data = client->data;
858        if (operation == SENSORS_PROC_REAL_INFO)
859                *nrels_mag = 0;
860        else if (operation == SENSORS_PROC_REAL_READ) {
861                fscscy_update_client(client);
862                results[0] = data->pciload;
863                *nrels_mag = 1;
864        } else if (operation == SENSORS_PROC_REAL_WRITE) {
865                        printk("fscscy: writing PCILOAD to chip not supported\n");
866        }
867}
868
869void fscscy_intrusion(struct i2c_client *client, int operation, int ctl_name,
870             int *nrels_mag, long *results)
871{
872        struct fscscy_data *data = client->data;
873
874        if (operation == SENSORS_PROC_REAL_INFO)
875                *nrels_mag = 0;
876        else if (operation == SENSORS_PROC_REAL_READ) {
877                fscscy_update_client(client);
878                results[0] = data->intr_control & 0x80;
879                results[1] = data->intr_status & 0xc0;
880                *nrels_mag = 2;
881        } else if (operation == SENSORS_PROC_REAL_WRITE) {
882                if (*nrels_mag >= 1) {
883                        data->intr_control = results[0] & 0x80;
884                        printk("fscscy: writing value 0x%02x to intr_control\n",
885                                data->intr_control); 
886                        fscscy_write_value(client,FSCSCY_REG_INTR_CTRL,
887                                data->intr_control);
888                } 
889        }
890}
891
892static int __init sm_fscscy_init(void)
893{
894        printk("fscscy.o version %s (%s)\n", LM_VERSION, LM_DATE);
895        return i2c_add_driver(&fscscy_driver);
896}
897
898static void __exit sm_fscscy_exit(void)
899{
900        i2c_del_driver(&fscscy_driver);
901}
902
903
904
905MODULE_AUTHOR
906    ("Martin Knoblauch <mkn@teraport.de> based on work (fscpos) from  Hermann Jung <hej@odn.de>");
907MODULE_DESCRIPTION("fujitsu siemens scylla chip driver");
908
909module_init(sm_fscscy_init);
910module_exit(sm_fscscy_exit);
Note: See TracBrowser for help on using the browser.