root/lm-sensors/trunk/kernel/chips/adm1026.c @ 4651

Revision 4651, 55.8 KB (checked in by khali, 7 years ago)

Add missing new line at end of log messages. Indirectly reported
by Joe Perches.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2    adm1026.c - Part of lm_sensors, Linux kernel modules for hardware
3             monitoring
4    Copyright (c) 2002, 2003  Philip Pokorny <ppokorny@penguincomputing.com>
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    CHANGELOG
21
22    2003-03-13   Initial development
23    2003-05-07   First Release.  Includes GPIO fixup and full
24                 functionality.
25    2003-05-18   Minor fixups and tweaks.
26                 Print GPIO config after fixup.
27                 Adjust fan MIN if DIV changes.
28    2003-05-21   Fix printing of FAN/GPIO config
29                 Fix silly bug in fan_div logic
30                 Fix fan_min handling so that 0xff is 0 is 0xff
31    2003-05-25   Fix more silly typos...
32    2003-06-11   Change FAN_xx_REG macros to use different scaling
33                 Most (all?) drivers assume two pulses per rev fans
34                 and the old scaling was producing double the RPM's
35                 Thanks to Jerome Hsiao @ Arima for pointing this out.
36        2004-01-27   Remove use of temporary ID.
37                 Define addresses as a range.
38*/
39
40#include <linux/module.h>
41#include <linux/slab.h>
42#include <linux/i2c.h>
43#include <linux/i2c-proc.h>
44#include <linux/init.h>
45#include "version.h"
46#include "sensors_vid.h"
47
48#ifndef I2C_DRIVERID_ADM1026
49#define I2C_DRIVERID_ADM1026    1048
50#endif
51
52/* Addresses to scan */
53static unsigned short normal_i2c[] = { SENSORS_I2C_END };
54static unsigned short normal_i2c_range[] = { 0x2c, 0x2e, SENSORS_I2C_END };
55static unsigned int normal_isa[] = { SENSORS_ISA_END };
56static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
57
58/* Insmod parameters */
59SENSORS_INSMOD_1(adm1026);
60
61static int gpio_input[17]  = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
62                                -1, -1, -1, -1, -1, -1, -1, -1 };
63static int gpio_output[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
64                                -1, -1, -1, -1, -1, -1, -1, -1 };
65static int gpio_inverted[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
66                                -1, -1, -1, -1, -1, -1, -1, -1 };
67static int gpio_normal[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
68                                -1, -1, -1, -1, -1, -1, -1, -1 };
69static int gpio_fan[8] = { -1, -1, -1, -1, -1, -1, -1, -1 };
70MODULE_PARM(gpio_input,"1-17i");
71MODULE_PARM_DESC(gpio_input,"List of GPIO pins (0-16) to program as inputs");
72MODULE_PARM(gpio_output,"1-17i");
73MODULE_PARM_DESC(gpio_output,"List of GPIO pins (0-16) to program as outputs");
74MODULE_PARM(gpio_inverted,"1-17i");
75MODULE_PARM_DESC(gpio_inverted,"List of GPIO pins (0-16) to program as inverted");
76MODULE_PARM(gpio_normal,"1-17i");
77MODULE_PARM_DESC(gpio_normal,"List of GPIO pins (0-16) to program as normal/non-inverted");
78MODULE_PARM(gpio_fan,"1-8i");
79MODULE_PARM_DESC(gpio_fan,"List of GPIO pins (0-7) to program as fan tachs");
80
81/* Many ADM1026 constants specified below */
82
83/* The ADM1026 registers */
84#define ADM1026_REG_CONFIG1  (0x00)
85#define CFG1_MONITOR     (0x01)
86#define CFG1_INT_ENABLE  (0x02)
87#define CFG1_INT_CLEAR   (0x04)
88#define CFG1_AIN8_9      (0x08)
89#define CFG1_THERM_HOT   (0x10)
90#define CFG1_DAC_AFC     (0x20)
91#define CFG1_PWM_AFC     (0x40)
92#define CFG1_RESET       (0x80)
93#define ADM1026_REG_CONFIG2  (0x01)
94/* CONFIG2 controls FAN0/GPIO0 through FAN7/GPIO7 */
95#define ADM1026_REG_CONFIG3  (0x07)
96#define CFG3_GPIO16_ENABLE  (0x01)
97#define CFG3_CI_CLEAR  (0x02)
98#define CFG3_VREF_250  (0x04)
99#define CFG3_GPIO16_DIR  (0x40)
100#define CFG3_GPIO16_POL  (0x80)
101#define ADM1026_REG_E2CONFIG  (0x13)
102#define E2CFG_READ  (0x01)
103#define E2CFG_WRITE  (0x02)
104#define E2CFG_ERASE  (0x04)
105#define E2CFG_ROM  (0x08)
106#define E2CFG_CLK_EXT  (0x80)
107
108/* There are 10 general analog inputs and 7 dedicated inputs
109 * They are:
110 *    0 - 9  =  AIN0 - AIN9
111 *       10  =  Vbat
112 *       11  =  3.3V Standby
113 *       12  =  3.3V Main
114 *       13  =  +5V
115 *       14  =  Vccp (CPU core voltage)
116 *       15  =  +12V
117 *       16  =  -12V
118 */
119static u16 REG_IN[] = {
120                0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
121                0x36, 0x37, 0x27, 0x29, 0x26, 0x2a,
122                0x2b, 0x2c, 0x2d, 0x2e, 0x2f
123        };
124static u16 REG_IN_MIN[] = {
125                0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d,
126                0x5e, 0x5f, 0x6d, 0x49, 0x6b, 0x4a,
127                0x4b, 0x4c, 0x4d, 0x4e, 0x4f
128        };
129static u16 REG_IN_MAX[] = {
130                0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
131                0x56, 0x57, 0x6c, 0x41, 0x6a, 0x42,
132                0x43, 0x44, 0x45, 0x46, 0x47
133        };
134#define ADM1026_REG_IN(nr) (REG_IN[(nr)])
135#define ADM1026_REG_IN_MIN(nr) (REG_IN_MIN[(nr)])
136#define ADM1026_REG_IN_MAX(nr) (REG_IN_MAX[(nr)])
137
138/* Temperatures are:
139 *    0 - Internal
140 *    1 - External 1
141 *    2 - External 2
142 */
143static u16 REG_TEMP[] = { 0x1f, 0x28, 0x29 };
144static u16 REG_TEMP_MIN[] = { 0x69, 0x48, 0x49 };
145static u16 REG_TEMP_MAX[] = { 0x68, 0x40, 0x41 };
146static u16 REG_TEMP_TMIN[] = { 0x10, 0x11, 0x12 };
147static u16 REG_TEMP_THERM[] = { 0x0d, 0x0e, 0x0f };
148static u16 REG_TEMP_OFFSET[] = { 0x1e, 0x6e, 0x6f };
149#define ADM1026_REG_TEMP(nr) (REG_TEMP[(nr)])
150#define ADM1026_REG_TEMP_MIN(nr) (REG_TEMP_MIN[(nr)])
151#define ADM1026_REG_TEMP_MAX(nr) (REG_TEMP_MAX[(nr)])
152#define ADM1026_REG_TEMP_TMIN(nr) (REG_TEMP_TMIN[(nr)])
153#define ADM1026_REG_TEMP_THERM(nr) (REG_TEMP_THERM[(nr)])
154#define ADM1026_REG_TEMP_OFFSET(nr) (REG_TEMP_OFFSET[(nr)])
155
156#define ADM1026_REG_FAN(nr) (0x38 + (nr))
157#define ADM1026_REG_FAN_MIN(nr) (0x60 + (nr))
158#define ADM1026_REG_FAN_DIV_0_3 (0x02)
159#define ADM1026_REG_FAN_DIV_4_7 (0x03)
160
161#define ADM1026_REG_DAC  (0x04)
162#define ADM1026_REG_PWM  (0x05)
163
164#define ADM1026_REG_GPIO_CFG_0_3 (0x08)
165#define ADM1026_REG_GPIO_CFG_4_7 (0x09)
166#define ADM1026_REG_GPIO_CFG_8_11 (0x0a)
167#define ADM1026_REG_GPIO_CFG_12_15 (0x0b)
168/* CFG_16 in REG_CFG3 */
169#define ADM1026_REG_GPIO_STATUS_0_7 (0x24)
170#define ADM1026_REG_GPIO_STATUS_8_15 (0x25)
171/* STATUS_16 in REG_STATUS4 */
172#define ADM1026_REG_GPIO_MASK_0_7 (0x1c)
173#define ADM1026_REG_GPIO_MASK_8_15 (0x1d)
174/* MASK_16 in REG_MASK4 */
175
176#define ADM1026_REG_COMPANY 0x16
177#define ADM1026_REG_VERSTEP 0x17
178/* These are the recognized values for the above regs */
179#define ADM1026_COMPANY_ANALOG_DEV 0x41
180#define ADM1026_VERSTEP_GENERIC 0x40
181#define ADM1026_VERSTEP_ADM1026 0x44
182
183#define ADM1026_REG_MASK1 0x18
184#define ADM1026_REG_MASK2 0x19
185#define ADM1026_REG_MASK3 0x1a
186#define ADM1026_REG_MASK4 0x1b
187
188#define ADM1026_REG_STATUS1 0x20
189#define ADM1026_REG_STATUS2 0x21
190#define ADM1026_REG_STATUS3 0x22
191#define ADM1026_REG_STATUS4 0x23
192
193/* Conversions. Rounding and limit checking is only done on the TO_REG
194   variants. Note that you should be a bit careful with which arguments
195   these macros are called: arguments may be evaluated more than once.
196 */
197
198/* IN are scaled acording to built-in resistors.  These are the
199 *   voltages corresponding to 3/4 of full scale (192 or 0xc0)
200 *   NOTE: The -12V input needs an additional factor to account
201 *      for the Vref pullup resistor.
202 *      NEG12_OFFSET = SCALE * Vref / V-192 - Vref
203 *                   = 13875 * 2.50 / 1.875 - 2500
204 *                   = 16000
205 */
206#if 1
207/* The values in this table are based on Table II, page 15 of the
208 *    datasheet.
209 */
210static int adm1026_scaling[] = {  /* .001 Volts */
211                2250, 2250, 2250, 2250, 2250, 2250, 
212                1875, 1875, 1875, 1875, 3000, 3330, 
213                3330, 4995, 2250, 12000, 13875
214        };
215#define NEG12_OFFSET  16000
216#else
217/* The values in this table are based on the resistors in
218 *    Figure 5 on page 16.  But the 3.3V inputs are not in
219 *    the figure and the values for the 5V input are wrong.
220 *    For 5V, I'm guessing that R2 at 55.2k is right, but
221 *    the total resistance should be 1400 or 1449 like the
222 *    other inputs.  Using 1449, gives 4.922V at 192.
223 */
224static int adm1026_scaling[] = {  /* .001 Volts */
225                2249, 2249, 2249, 2249, 2249, 2249, 
226                1875, 1875, 1875, 1875, 3329, 3329, 
227                3329, 4922, 2249, 11969, 13889
228        };
229#define NEG12_OFFSET  16019
230#endif
231
232#define SCALE(val,from,to) (((val)*(to) + ((from)/2))/(from))
233#define INS_TO_REG(n,val)  (SENSORS_LIMIT(SCALE(val,adm1026_scaling[n],192),0,255))
234#if 0   /* If we have extended A/D bits */
235#define INSEXT_FROM_REG(n,val,ext) (SCALE((val)*4 + (ext),192*4,adm1026_scaling[n]))
236#define INS_FROM_REG(n,val) (INSEXT_FROM_REG(n,val,0))
237#else
238#define INS_FROM_REG(n,val) (SCALE(val,192,adm1026_scaling[n]))
239#endif
240
241/* FAN speed is measured using 22.5kHz clock and counts for 2 pulses
242 *   and we assume a 2 pulse-per-rev fan tach signal
243 *      22500 kHz * 60 (sec/min) * 2 (pulse) / 2 (pulse/rev) == 1350000
244 */
245#define FAN_TO_REG(val,div)  ((val)<=0 ? 0xff : SENSORS_LIMIT(1350000/((val)*(div)),1,254))
246#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==0xff ? 0 : 1350000/((val)*(div)))
247#define DIV_FROM_REG(val) (1<<(val))
248#define DIV_TO_REG(val) ((val)>=8 ? 3 : (val)>=4 ? 2 : (val)>=2 ? 1 : 0)
249
250/* Temperature is reported in 1 degC increments */
251#define TEMP_TO_REG(val) (SENSORS_LIMIT(val,-127,127))
252#define TEMP_FROM_REG(val) (val)
253#define OFFSET_TO_REG(val) (SENSORS_LIMIT(val,-127,127))
254#define OFFSET_FROM_REG(val) (val)
255
256#define PWM_TO_REG(val) (SENSORS_LIMIT(val,0,255))
257#define PWM_FROM_REG(val) (val)
258
259/* Analog output is a voltage, but it's used like a PWM
260 *   Seems like this should be scaled, but to be consistent
261 *   with other drivers, we do it this way.
262 */
263#define DAC_TO_REG(val) (SENSORS_LIMIT(val,0,255))
264#define DAC_FROM_REG(val) (val)
265
266#define ALARMS_FROM_REG(val) (val)
267
268/* Unlike some other drivers we DO NOT set initial limits.  Use
269 * the config file to set limits.
270 */
271
272/* Typically used with systems using a v9.1 VRM spec ? */
273#define ADM1026_INIT_VRM  91
274#define ADM1026_INIT_VID  -1
275
276/* Chip sampling rates
277 *
278 * Some sensors are not updated more frequently than once per second
279 *    so it doesn't make sense to read them more often than that.
280 *    We cache the results and return the saved data if the driver
281 *    is called again before a second has elapsed.
282 *
283 * Also, there is significant configuration data for this chip
284 *    So, we keep the config data up to date in the cache
285 *    when it is written and only sample it once every 5 *minutes*
286 */
287#define ADM1026_DATA_INTERVAL  (1 * HZ)
288#define ADM1026_CONFIG_INTERVAL  (5 * 60 * HZ)
289
290/* We allow for multiple chips in a single system.
291 *
292 * For each registered ADM1026, we need to keep state information
293 * at client->data. The adm1026_data structure is dynamically
294 * allocated, when a new client structure is allocated. */
295
296struct adm1026_data {
297        struct i2c_client client;
298        int sysctl_id;
299        enum chips type;
300
301        struct semaphore update_lock;
302        int valid;              /* !=0 if following fields are valid */
303        unsigned long last_reading;     /* In jiffies */
304        unsigned long last_config;      /* In jiffies */
305
306        u8 in[17];              /* Register value */
307        u8 in_max[17];          /* Register value */
308        u8 in_min[17];          /* Register value */
309        s8 temp[3];             /* Register value */
310        s8 temp_min[3];         /* Register value */
311        s8 temp_max[3];         /* Register value */
312        s8 temp_tmin[3];        /* Register value */
313        s8 temp_therm[3];       /* Register value */
314        s8 temp_offset[3];      /* Register value */
315        u8 fan[8];              /* Register value */
316        u8 fan_min[8];          /* Register value */
317        u8 fan_div[8];          /* Decoded value */
318        u8 pwm;                 /* Register value */
319        u8 analog_out;          /* Register value */
320        int vid;                /* Decoded value */
321        u8 vrm;                 /* VRM version */
322        long alarms;            /* Register encoding, combined */
323        long alarm_mask;        /* Register encoding, combined */
324        long gpio;              /* Register encoding, combined */
325        long gpio_mask;         /* Register encoding, combined */
326        u8 gpio_config[17];     /* Decoded value */
327        u8 config1;             /* Register value */
328        u8 config2;             /* Register value */
329        u8 config3;             /* Register value */
330};
331
332static int adm1026_attach_adapter(struct i2c_adapter *adapter);
333static int adm1026_detect(struct i2c_adapter *adapter, int address,
334                        unsigned short flags, int kind);
335static int adm1026_detach_client(struct i2c_client *client);
336
337static int adm1026_read_value(struct i2c_client *client, u8 register);
338static int adm1026_write_value(struct i2c_client *client, u8 register, int value);
339static void adm1026_print_gpio(struct i2c_client *client);
340static void adm1026_fixup_gpio(struct i2c_client *client);
341static void adm1026_update_client(struct i2c_client *client);
342static void adm1026_init_client(struct i2c_client *client);
343
344
345static void adm1026_in(struct i2c_client *client, int operation, int ctl_name,
346                        int *nrels_mag, long *results);
347static void adm1026_in16(struct i2c_client *client, int operation, int ctl_name,
348                        int *nrels_mag, long *results);
349static void adm1026_fan(struct i2c_client *client, int operation,
350                        int ctl_name, int *nrels_mag, long *results);
351static void adm1026_fixup_fan_min(struct i2c_client *client,
352                         int fan, int old_div);
353static void adm1026_fan_div(struct i2c_client *client, int operation,
354                        int ctl_name, int *nrels_mag, long *results);
355static void adm1026_temp(struct i2c_client *client, int operation,
356                        int ctl_name, int *nrels_mag, long *results);
357static void adm1026_temp_offset(struct i2c_client *client, int operation,
358                        int ctl_name, int *nrels_mag, long *results);
359static void adm1026_temp_tmin(struct i2c_client *client, int operation,
360                        int ctl_name, int *nrels_mag, long *results);
361static void adm1026_temp_therm(struct i2c_client *client, int operation,
362                        int ctl_name, int *nrels_mag, long *results);
363static void adm1026_vid(struct i2c_client *client, int operation,
364                        int ctl_name, int *nrels_mag, long *results);
365static void adm1026_vrm(struct i2c_client *client, int operation,
366                        int ctl_name, int *nrels_mag, long *results);
367static void adm1026_alarms(struct i2c_client *client, int operation,
368                        int ctl_name, int *nrels_mag, long *results);
369static void adm1026_alarm_mask(struct i2c_client *client, int operation,
370                        int ctl_name, int *nrels_mag, long *results);
371static void adm1026_gpio(struct i2c_client *client, int operation,
372                        int ctl_name, int *nrels_mag, long *results);
373static void adm1026_gpio_mask(struct i2c_client *client, int operation,
374                        int ctl_name, int *nrels_mag, long *results);
375static void adm1026_pwm(struct i2c_client *client, int operation,
376                        int ctl_name, int *nrels_mag, long *results);
377static void adm1026_analog_out(struct i2c_client *client, int operation,
378                        int ctl_name, int *nrels_mag, long *results);
379static void adm1026_afc(struct i2c_client *client, int operation,
380                        int ctl_name, int *nrels_mag, long *results);
381
382static struct i2c_driver adm1026_driver = {
383        .name           = "ADM1026 compatible sensor driver",
384        .id             = I2C_DRIVERID_ADM1026,
385        .flags          = I2C_DF_NOTIFY,
386        .attach_adapter = &adm1026_attach_adapter,
387        .detach_client  = &adm1026_detach_client,
388};
389
390/* Unique ID assigned to each ADM1026 detected */
391static int adm1026_id = 0;
392
393/* -- SENSORS SYSCTL START -- */
394#define ADM1026_SYSCTL_FAN0                 1000
395#define ADM1026_SYSCTL_FAN1                 1001
396#define ADM1026_SYSCTL_FAN2                 1002
397#define ADM1026_SYSCTL_FAN3                 1003
398#define ADM1026_SYSCTL_FAN4                 1004
399#define ADM1026_SYSCTL_FAN5                 1005
400#define ADM1026_SYSCTL_FAN6                 1006
401#define ADM1026_SYSCTL_FAN7                 1007
402#define ADM1026_SYSCTL_FAN_DIV              1008
403#define ADM1026_SYSCTL_GPIO                 1009
404#define ADM1026_SYSCTL_GPIO_MASK            1010
405#define ADM1026_SYSCTL_ALARMS               1011
406#define ADM1026_SYSCTL_ALARM_MASK           1012
407#define ADM1026_SYSCTL_IN0                  1013
408#define ADM1026_SYSCTL_IN1                  1014
409#define ADM1026_SYSCTL_IN2                  1015
410#define ADM1026_SYSCTL_IN3                  1016
411#define ADM1026_SYSCTL_IN4                  1017
412#define ADM1026_SYSCTL_IN5                  1018
413#define ADM1026_SYSCTL_IN6                  1019
414#define ADM1026_SYSCTL_IN7                  1020
415#define ADM1026_SYSCTL_IN8                  1021
416#define ADM1026_SYSCTL_IN9                  1022
417#define ADM1026_SYSCTL_IN10                 1023
418#define ADM1026_SYSCTL_IN11                 1024
419#define ADM1026_SYSCTL_IN12                 1025
420#define ADM1026_SYSCTL_IN13                 1026
421#define ADM1026_SYSCTL_IN14                 1027
422#define ADM1026_SYSCTL_IN15                 1028
423#define ADM1026_SYSCTL_IN16                 1029
424#define ADM1026_SYSCTL_PWM                  1030
425#define ADM1026_SYSCTL_ANALOG_OUT           1031
426#define ADM1026_SYSCTL_AFC                  1032
427#define ADM1026_SYSCTL_TEMP1                1033
428#define ADM1026_SYSCTL_TEMP2                1034
429#define ADM1026_SYSCTL_TEMP3                1035
430#define ADM1026_SYSCTL_TEMP_OFFSET1         1036
431#define ADM1026_SYSCTL_TEMP_OFFSET2         1037
432#define ADM1026_SYSCTL_TEMP_OFFSET3         1038
433#define ADM1026_SYSCTL_TEMP_THERM1          1039
434#define ADM1026_SYSCTL_TEMP_THERM2          1040
435#define ADM1026_SYSCTL_TEMP_THERM3          1041
436#define ADM1026_SYSCTL_TEMP_TMIN1           1042
437#define ADM1026_SYSCTL_TEMP_TMIN2           1043
438#define ADM1026_SYSCTL_TEMP_TMIN3           1044
439#define ADM1026_SYSCTL_VID                  1045
440#define ADM1026_SYSCTL_VRM                  1046
441
442#define ADM1026_ALARM_TEMP2   (1L <<  0)
443#define ADM1026_ALARM_TEMP3   (1L <<  1)
444#define ADM1026_ALARM_IN9     (1L <<  1)
445#define ADM1026_ALARM_IN11    (1L <<  2)
446#define ADM1026_ALARM_IN12    (1L <<  3)
447#define ADM1026_ALARM_IN13    (1L <<  4)
448#define ADM1026_ALARM_IN14    (1L <<  5)
449#define ADM1026_ALARM_IN15    (1L <<  6)
450#define ADM1026_ALARM_IN16    (1L <<  7)
451#define ADM1026_ALARM_IN0     (1L <<  8)
452#define ADM1026_ALARM_IN1     (1L <<  9)
453#define ADM1026_ALARM_IN2     (1L << 10)
454#define ADM1026_ALARM_IN3     (1L << 11)
455#define ADM1026_ALARM_IN4     (1L << 12)
456#define ADM1026_ALARM_IN5     (1L << 13)
457#define ADM1026_ALARM_IN6     (1L << 14)
458#define ADM1026_ALARM_IN7     (1L << 15)
459#define ADM1026_ALARM_FAN0    (1L << 16)
460#define ADM1026_ALARM_FAN1    (1L << 17)
461#define ADM1026_ALARM_FAN2    (1L << 18)
462#define ADM1026_ALARM_FAN3    (1L << 19)
463#define ADM1026_ALARM_FAN4    (1L << 20)
464#define ADM1026_ALARM_FAN5    (1L << 21)
465#define ADM1026_ALARM_FAN6    (1L << 22)
466#define ADM1026_ALARM_FAN7    (1L << 23)
467#define ADM1026_ALARM_TEMP1   (1L << 24)
468#define ADM1026_ALARM_IN10    (1L << 25)
469#define ADM1026_ALARM_IN8     (1L << 26)
470#define ADM1026_ALARM_THERM   (1L << 27)
471#define ADM1026_ALARM_AFC_FAN (1L << 28)
472#define ADM1026_ALARM_UNUSED  (1L << 29)
473#define ADM1026_ALARM_CI      (1L << 30)
474/* -- SENSORS SYSCTL END -- */
475
476/* The /proc/sys entries */
477/* These files are created for each detected ADM1026. This is just a template;
478 *    The actual list is built from this and additional per-chip
479 *    custom lists below.  Note the XXX_LEN macros.  These must be
480 *    compile time constants because they will be used to allocate
481 *    space for the final template passed to i2c_register_entry.
482 *    We depend on the ability of GCC to evaluate expressions at
483 *    compile time to turn these expressions into compile time
484 *    constants, but this can generate a warning.
485 */
486static ctl_table adm1026_common[] = {
487        {ADM1026_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
488                &i2c_sysctl_real, NULL, &adm1026_in},
489        {ADM1026_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
490                &i2c_sysctl_real, NULL, &adm1026_in},
491        {ADM1026_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
492                &i2c_sysctl_real, NULL, &adm1026_in},
493        {ADM1026_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
494                &i2c_sysctl_real, NULL, &adm1026_in},
495        {ADM1026_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
496                &i2c_sysctl_real, NULL, &adm1026_in},
497        {ADM1026_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
498                &i2c_sysctl_real, NULL, &adm1026_in},
499        {ADM1026_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
500                &i2c_sysctl_real, NULL, &adm1026_in},
501        {ADM1026_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
502                &i2c_sysctl_real, NULL, &adm1026_in},
503        {ADM1026_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
504                &i2c_sysctl_real, NULL, &adm1026_in},
505        {ADM1026_SYSCTL_IN9, "in9", NULL, 0, 0644, NULL, &i2c_proc_real,
506                &i2c_sysctl_real, NULL, &adm1026_in},
507        {ADM1026_SYSCTL_IN10, "in10", NULL, 0, 0644, NULL, &i2c_proc_real,
508                &i2c_sysctl_real, NULL, &adm1026_in},
509        {ADM1026_SYSCTL_IN11, "in11", NULL, 0, 0644, NULL, &i2c_proc_real,
510                &i2c_sysctl_real, NULL, &adm1026_in},
511        {ADM1026_SYSCTL_IN12, "in12", NULL, 0, 0644, NULL, &i2c_proc_real,
512                &i2c_sysctl_real, NULL, &adm1026_in},
513        {ADM1026_SYSCTL_IN13, "in13", NULL, 0, 0644, NULL, &i2c_proc_real,
514                &i2c_sysctl_real, NULL, &adm1026_in},
515        {ADM1026_SYSCTL_IN14, "in14", NULL, 0, 0644, NULL, &i2c_proc_real,
516                &i2c_sysctl_real, NULL, &adm1026_in},
517        {ADM1026_SYSCTL_IN15, "in15", NULL, 0, 0644, NULL, &i2c_proc_real,
518                &i2c_sysctl_real, NULL, &adm1026_in},
519        {ADM1026_SYSCTL_IN16, "in16", NULL, 0, 0644, NULL, &i2c_proc_real,
520                &i2c_sysctl_real, NULL, &adm1026_in16},
521
522        {ADM1026_SYSCTL_FAN0, "fan0", NULL, 0, 0644, NULL, &i2c_proc_real,
523                &i2c_sysctl_real, NULL, &adm1026_fan},
524        {ADM1026_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
525                &i2c_sysctl_real, NULL, &adm1026_fan},
526        {ADM1026_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
527                &i2c_sysctl_real, NULL, &adm1026_fan},
528        {ADM1026_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
529                &i2c_sysctl_real, NULL, &adm1026_fan},
530        {ADM1026_SYSCTL_FAN4, "fan4", NULL, 0, 0644, NULL, &i2c_proc_real,
531                &i2c_sysctl_real, NULL, &adm1026_fan},
532        {ADM1026_SYSCTL_FAN5, "fan5", NULL, 0, 0644, NULL, &i2c_proc_real,
533                &i2c_sysctl_real, NULL, &adm1026_fan},
534        {ADM1026_SYSCTL_FAN6, "fan6", NULL, 0, 0644, NULL, &i2c_proc_real,
535                &i2c_sysctl_real, NULL, &adm1026_fan},
536        {ADM1026_SYSCTL_FAN7, "fan7", NULL, 0, 0644, NULL, &i2c_proc_real,
537                &i2c_sysctl_real, NULL, &adm1026_fan},
538        {ADM1026_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL,
539                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_fan_div},
540
541        {ADM1026_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
542                &i2c_sysctl_real, NULL, &adm1026_temp},
543        {ADM1026_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
544                &i2c_sysctl_real, NULL, &adm1026_temp},
545        {ADM1026_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
546                &i2c_sysctl_real, NULL, &adm1026_temp},
547        {ADM1026_SYSCTL_TEMP_OFFSET1, "temp1_offset", NULL, 0, 0644, NULL,
548                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_offset},
549        {ADM1026_SYSCTL_TEMP_OFFSET2, "temp2_offset", NULL, 0, 0644, NULL,
550                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_offset},
551        {ADM1026_SYSCTL_TEMP_OFFSET3, "temp3_offset", NULL, 0, 0644, NULL,
552                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_offset},
553        {ADM1026_SYSCTL_TEMP_TMIN1, "temp1_tmin", NULL, 0, 0644, NULL,
554                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_tmin},
555        {ADM1026_SYSCTL_TEMP_TMIN2, "temp2_tmin", NULL, 0, 0644, NULL,
556                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_tmin},
557        {ADM1026_SYSCTL_TEMP_TMIN3, "temp3_tmin", NULL, 0, 0644, NULL,
558                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_tmin},
559        {ADM1026_SYSCTL_TEMP_THERM1, "temp1_therm", NULL, 0, 0644, NULL,
560                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_therm},
561        {ADM1026_SYSCTL_TEMP_THERM2, "temp2_therm", NULL, 0, 0644, NULL,
562                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_therm},
563        {ADM1026_SYSCTL_TEMP_THERM3, "temp3_therm", NULL, 0, 0644, NULL,
564                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_therm},
565
566        {ADM1026_SYSCTL_VID, "vid", NULL, 0, 0644, NULL, &i2c_proc_real,
567                &i2c_sysctl_real, NULL, &adm1026_vid},
568        {ADM1026_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
569                &i2c_sysctl_real, NULL, &adm1026_vrm},
570
571        {ADM1026_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
572                &i2c_sysctl_real, NULL, &adm1026_alarms},
573        {ADM1026_SYSCTL_ALARM_MASK, "alarm_mask", NULL, 0, 0644, NULL,
574                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_alarm_mask},
575
576        {ADM1026_SYSCTL_GPIO, "gpio", NULL, 0, 0644, NULL, &i2c_proc_real,
577                &i2c_sysctl_real, NULL, &adm1026_gpio},
578        {ADM1026_SYSCTL_GPIO_MASK, "gpio_mask", NULL, 0, 0644, NULL,
579                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_gpio_mask},
580
581        {ADM1026_SYSCTL_PWM, "pwm", NULL, 0, 0644, NULL, &i2c_proc_real,
582                &i2c_sysctl_real, NULL, &adm1026_pwm},
583        {ADM1026_SYSCTL_ANALOG_OUT, "analog_out", NULL, 0, 0644, NULL,
584                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_analog_out},
585        {ADM1026_SYSCTL_AFC, "afc", NULL, 0, 0644, NULL, &i2c_proc_real,
586                &i2c_sysctl_real, NULL, &adm1026_afc},
587
588        {0}
589};
590#define CTLTBL_COMMON (sizeof(adm1026_common)/sizeof(adm1026_common[0]))
591
592#define MAX2(a,b) ((a)>(b)?(a):(b))
593#define MAX3(a,b,c) ((a)>(b)?MAX2((a),(c)):MAX2((b),(c)))
594#define MAX4(a,b,c,d) ((a)>(b)?MAX3((a),(c),(d)):MAX3((b),(c),(d)))
595
596#define CTLTBL_MAX (CTLTBL_COMMON)
597
598/* This function is called when:
599     * the module is loaded
600     * a new adapter is loaded
601 */
602static int adm1026_attach_adapter(struct i2c_adapter *adapter)
603{
604        return i2c_detect(adapter, &addr_data, adm1026_detect);
605}
606
607/* This function is called by i2c_detect */
608static int adm1026_detect(struct i2c_adapter *adapter, int address,
609                          unsigned short flags, int kind)
610{
611        int i;
612        int company, verstep ;
613        struct i2c_client *new_client;
614        struct adm1026_data *data;
615        int err = 0;
616        const char *type_name = "";
617        struct ctl_table template[CTLTBL_MAX] ;
618        struct ctl_table * template_next = template ;
619
620        if (i2c_is_isa_adapter(adapter)) {
621                /* This chip has no ISA interface */
622                goto ERROR0 ;
623        }
624
625        if (!i2c_check_functionality(adapter,
626                                        I2C_FUNC_SMBUS_BYTE_DATA)) {
627                /* We need to be able to do byte I/O */
628                goto ERROR0 ;
629        }
630
631        /* OK. For now, we presume we have a valid client. We now create the
632           client structure, even though we cannot fill it completely yet.
633           But it allows us to access adm1026_{read,write}_value. */
634
635        if (!(data = kmalloc(sizeof(struct adm1026_data), GFP_KERNEL))) {
636                err = -ENOMEM;
637                goto ERROR0;
638        }
639
640        new_client = &data->client;
641        new_client->addr = address;
642        new_client->data = data;
643        new_client->adapter = adapter;
644        new_client->driver = &adm1026_driver;
645        new_client->flags = 0;
646
647        /* Now, we do the remaining detection. */
648
649        company = adm1026_read_value(new_client, ADM1026_REG_COMPANY);
650        verstep = adm1026_read_value(new_client, ADM1026_REG_VERSTEP);
651
652#ifdef DEBUG
653        printk("adm1026: Detecting device at %d,0x%02x with"
654                " COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
655                i2c_adapter_id(new_client->adapter), new_client->addr,
656                company, verstep
657            );
658#endif
659
660        /* If auto-detecting, Determine the chip type. */
661        if (kind <= 0) {
662#ifdef DEBUG
663                printk("adm1026: Autodetecting device at %d,0x%02x ...\n",
664                        i2c_adapter_id(adapter), address );
665#endif
666                if( company == ADM1026_COMPANY_ANALOG_DEV
667                    && verstep == ADM1026_VERSTEP_ADM1026 ) {
668                        kind = adm1026 ;
669                } else if( company == ADM1026_COMPANY_ANALOG_DEV
670                    && (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC ) {
671                        printk("adm1026: Unrecgonized stepping 0x%02x"
672                            " Defaulting to ADM1026.\n", verstep );
673                        kind = adm1026 ;
674                } else if( (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC ) {
675                        printk("adm1026: Found version/stepping 0x%02x"
676                            " Assuming generic ADM1026.\n", verstep );
677                        kind = any_chip ;
678                } else {
679#ifdef DEBUG
680                        printk("adm1026: Autodetection failed\n");
681#endif
682                        /* Not an ADM1026 ... */
683                        if( kind == 0 ) {  /* User used force=x,y */
684                            printk("adm1026: Generic ADM1026 Version 6 not"
685                                " found at %d,0x%02x. Try force_adm1026.\n",
686                                i2c_adapter_id(adapter), address );
687                        }
688                        goto ERROR1;
689                }
690        }
691
692        /* Fill in the chip specific driver values */
693        switch (kind) {
694        case any_chip :
695                type_name = "adm1026";
696                strcpy(new_client->name, "Generic ADM1026");
697                template_next = template ;  /* None used */
698                break ;
699        case adm1026 :
700                type_name = "adm1026";
701                strcpy(new_client->name, "Analog Devices ADM1026");
702                template_next = template ;
703                break ;
704#if 0
705        /* Example of another adm1026 "compatible" device */
706        case adx1000 :
707                type_name = "adx1000";
708                strcpy(new_client->name, "Compatible ADX1000");
709                memcpy( template, adx_specific, sizeof(adx_specific) );
710                template_next = template + CTLTBL_ADX1000 ;
711                break ;
712#endif
713        default :
714                printk("adm1026: Internal error, invalid kind (%d)!\n", kind);
715                err = -EFAULT ;
716                goto ERROR1;
717        }
718
719        /* Fill in the remaining client fields */
720        new_client->id = adm1026_id++;
721        printk("adm1026(%d): Assigning ID %d to %s at %d,0x%02x\n",
722                new_client->id, new_client->id, new_client->name,
723                i2c_adapter_id(new_client->adapter),
724                new_client->addr
725            );
726
727        /* Housekeeping values */
728        data->type = kind;
729        data->valid = 0;
730
731        /* Set the VRM version */
732        data->vrm = ADM1026_INIT_VRM ;
733        data->vid = ADM1026_INIT_VID ;
734
735        init_MUTEX(&data->update_lock);
736
737        /* Initialize the ADM1026 chip */
738        adm1026_init_client(new_client);
739
740        /* Tell the I2C layer a new client has arrived */
741        if ((err = i2c_attach_client(new_client)))
742                goto ERROR1;
743
744        /* Finish out the template */
745        memcpy(template_next, adm1026_common, sizeof(adm1026_common));
746
747        /* Register a new directory entry with module sensors */
748        if ((i = i2c_register_entry(new_client,
749                                        type_name,
750                                        template,
751                                        THIS_MODULE)) < 0) {
752                err = i;
753                goto ERROR2;
754        }
755        data->sysctl_id = i;
756
757        return 0;
758
759        /* Error out and cleanup code */
760    ERROR2:
761        i2c_detach_client(new_client);
762    ERROR1:
763        kfree(data);
764    ERROR0:
765        return err;
766}
767
768static int adm1026_detach_client(struct i2c_client *client)
769{
770        int err;
771        int id ;
772
773        id = client->id;
774        i2c_deregister_entry(((struct adm1026_data *)(client->data))->sysctl_id);
775
776        if ((err = i2c_detach_client(client))) {
777                printk("adm1026(%d): Client deregistration failed,"
778                        " client not detached.\n", id );
779                return err;
780        }
781
782        kfree(client->data);
783
784        return 0;
785}
786
787static int adm1026_read_value(struct i2c_client *client, u8 reg)
788{
789        int res;
790
791        if( reg < 0x80 ) {
792                /* "RAM" locations */
793                res = i2c_smbus_read_byte_data(client, reg) & 0xff ;
794        } else {
795                /* EEPROM, do nothing */
796                res = 0 ;
797        }
798
799        return res ;
800}
801
802static int adm1026_write_value(struct i2c_client *client, u8 reg, int value)
803{
804        int res ;
805
806        if( reg < 0x80 ) {
807                /* "RAM" locations */
808                res = i2c_smbus_write_byte_data(client, reg, value);
809        } else {
810                /* EEPROM, do nothing */
811                res = 0 ;
812        }
813
814        return res ;
815}
816
817/* Called when we have found a new ADM1026. */
818static void adm1026_init_client(struct i2c_client *client)
819{
820        int value ;
821        int i;
822        struct adm1026_data *data = client->data;
823
824#ifdef DEBUG
825        printk("adm1026(%d): Initializing device\n", client->id);
826#endif
827
828        /* Read chip config */
829        data->config1 = adm1026_read_value(client, ADM1026_REG_CONFIG1);
830        data->config2 = adm1026_read_value(client, ADM1026_REG_CONFIG2);
831        data->config3 = adm1026_read_value(client, ADM1026_REG_CONFIG3);
832
833        /* Inform user of chip config */
834#ifdef DEBUG
835        printk("adm1026(%d): ADM1026_REG_CONFIG1 is: 0x%02x\n",
836                client->id, data->config1 );
837#endif
838        if( (data->config1 & CFG1_MONITOR) == 0 ) {
839                printk("adm1026(%d): Monitoring not currently enabled.\n",
840                            client->id );
841        }
842        if( data->config1 & CFG1_INT_ENABLE ) {
843                printk("adm1026(%d): SMBALERT interrupts are enabled.\n",
844                            client->id );
845        }
846        if( data->config1 & CFG1_AIN8_9 ) {
847                printk("adm1026(%d): in8 and in9 enabled.  temp3 disabled.\n",
848                            client->id );
849        } else {
850                printk("adm1026(%d): temp3 enabled.  in8 and in9 disabled.\n",
851                            client->id );
852        }
853        if( data->config1 & CFG1_THERM_HOT ) {
854                printk("adm1026(%d): Automatic THERM, PWM, and temp limits enabled.\n",
855                            client->id );
856        }
857
858        value = data->config3 ;
859        if( data->config3 & CFG3_GPIO16_ENABLE ) {
860                printk("adm1026(%d): GPIO16 enabled.  THERM pin disabled.\n",
861                            client->id );
862        } else {
863                printk("adm1026(%d): THERM pin enabled.  GPIO16 disabled.\n",
864                            client->id );
865        }
866        if( data->config3 & CFG3_VREF_250 ) {
867                printk("adm1026(%d): Vref is 2.50 Volts.\n", client->id );
868        } else {
869                printk("adm1026(%d): Vref is 1.82 Volts.\n", client->id );
870        }
871
872        /* Read and pick apart the existing GPIO configuration */
873        value = 0 ;
874        for( i = 0 ; i <= 15 ; ++i ) {
875                if( (i & 0x03) == 0 ) {
876                        value = adm1026_read_value(client,
877                                        ADM1026_REG_GPIO_CFG_0_3 + i/4 );
878                }
879                data->gpio_config[i] = value & 0x03 ;
880                value >>= 2 ;
881        }
882        data->gpio_config[16] = (data->config3 >> 6) & 0x03 ;
883
884        /* ... and then print it */
885        adm1026_print_gpio(client);
886
887        /* If the user asks us to reprogram the GPIO config, then
888         *   do it now.  But only if this is the first ADM1026.
889         */
890        if( client->id == 0
891            && (gpio_input[0] != -1 || gpio_output[0] != -1
892                || gpio_inverted[0] != -1 || gpio_normal[0] != -1
893                || gpio_fan[0] != -1 ) ) {
894                adm1026_fixup_gpio(client);
895        }
896
897        /* WE INTENTIONALLY make no changes to the limits,
898         *   offsets, pwms and fans.  If they were
899         *   configured, we don't want to mess with them.
900         *   If they weren't, the default is generally safe
901         *   and will suffice until 'sensors -s' can be run.
902         */
903
904        /* Start monitoring */
905        value = adm1026_read_value(client, ADM1026_REG_CONFIG1);
906
907        /* Set MONITOR, clear interrupt acknowledge and s/w reset */
908        value = (value | CFG1_MONITOR) & (~CFG1_INT_CLEAR & ~CFG1_RESET) ;
909#ifdef DEBUG
910        printk("adm1026(%d): Setting CONFIG to: 0x%02x\n", client->id, value );
911#endif
912        data->config1 = value ;
913        adm1026_write_value(client, ADM1026_REG_CONFIG1, value);
914
915}
916
917static void adm1026_print_gpio(struct i2c_client *client)
918{
919        struct adm1026_data *data = client->data;
920        int  i ;
921
922        printk("adm1026(%d): GPIO config is:\nadm1026(%d):",
923                            client->id, client->id );
924        for( i = 0 ; i <= 7 ; ++i ) {
925                if( data->config2 & (1 << i) ) {
926                        printk( " %sGP%s%d",
927                                data->gpio_config[i] & 0x02 ? "" : "!",
928                                data->gpio_config[i] & 0x01 ? "OUT" : "IN",
929                                i );
930                } else {
931                        printk( " FAN%d", i );
932                }
933        }
934        printk( "\nadm1026(%d):", client->id );
935        for( i = 8 ; i <= 15 ; ++i ) {
936                printk( " %sGP%s%d",
937                        data->gpio_config[i] & 0x02 ? "" : "!",
938                        data->gpio_config[i] & 0x01 ? "OUT" : "IN",
939                        i );
940        }
941        if( data->config3 & CFG3_GPIO16_ENABLE ) {
942                printk( " %sGP%s16\n",
943                        data->gpio_config[16] & 0x02 ? "" : "!",
944                        data->gpio_config[16] & 0x01 ? "OUT" : "IN" );
945        } else {
946                /* GPIO16 is THERM */
947                printk( " THERM\n" );
948        }
949}
950
951static void adm1026_fixup_gpio(struct i2c_client *client)
952{
953        struct adm1026_data *data = client->data;
954        int  i ;
955        int  value ;
956
957        /* Make the changes requested. */
958        /* We may need to unlock/stop monitoring or soft-reset the
959         *    chip before we can make changes.  This hasn't been
960         *    tested much.  FIXME
961         */
962
963        /* Make outputs */
964        for( i = 0 ; i <= 16 ; ++i ) {
965                if( gpio_output[i] >= 0 && gpio_output[i] <= 16 ) {
966                        data->gpio_config[gpio_output[i]] |= 0x01 ;
967                }
968                /* if GPIO0-7 is output, it isn't a FAN tach */
969                if( gpio_output[i] >= 0 && gpio_output[i] <= 7 ) {
970                        data->config2 |= 1 << gpio_output[i] ;
971                }
972        }
973
974        /* Input overrides output */
975        for( i = 0 ; i <= 16 ; ++i ) {
976                if( gpio_input[i] >= 0 && gpio_input[i] <= 16 ) {
977                        data->gpio_config[gpio_input[i]] &= ~ 0x01 ;
978                }
979                /* if GPIO0-7 is input, it isn't a FAN tach */
980                if( gpio_input[i] >= 0 && gpio_input[i] <= 7 ) {
981                        data->config2 |= 1 << gpio_input[i] ;
982                }
983        }
984
985        /* Inverted  */
986        for( i = 0 ; i <= 16 ; ++i ) {
987                if( gpio_inverted[i] >= 0 && gpio_inverted[i] <= 16 ) {
988                        data->gpio_config[gpio_inverted[i]] &= ~ 0x02 ;
989                }
990        }
991
992        /* Normal overrides inverted  */
993        for( i = 0 ; i <= 16 ; ++i ) {
994                if( gpio_normal[i] >= 0 && gpio_normal[i] <= 16 ) {
995                        data->gpio_config[gpio_normal[i]] |= 0x02 ;
996                }
997        }
998
999        /* Fan overrides input and output */
1000        for( i = 0 ; i <= 7 ; ++i ) {
1001                if( gpio_fan[i] >= 0 && gpio_fan[i] <= 7 ) {
1002                        data->config2 &= ~( 1 << gpio_fan[i] );
1003                }
1004        }
1005
1006        /* Write new configs to registers */
1007        adm1026_write_value(client, ADM1026_REG_CONFIG2, data->config2);
1008        data->config3 = (data->config3 & 0x3f)
1009                        | ((data->gpio_config[16] & 0x03) << 6) ;
1010        adm1026_write_value(client, ADM1026_REG_CONFIG3, data->config3);
1011        for( i = 15, value = 0 ; i >= 0 ; --i ) {
1012                value <<= 2 ;
1013                value |= data->gpio_config[i] & 0x03 ;
1014                if( (i & 0x03) == 0 ) {
1015                        adm1026_write_value(client,
1016                                        ADM1026_REG_GPIO_CFG_0_3 + i/4,
1017                                        value );
1018                        value = 0 ;
1019                }
1020        }
1021
1022        /* Print the new config */
1023        adm1026_print_gpio(client);
1024}
1025
1026static void adm1026_update_client(struct i2c_client *client)
1027{
1028        struct adm1026_data *data = client->data;
1029        int i;
1030        long value, alarms, gpio ;
1031
1032        down(&data->update_lock);
1033
1034        if (!data->valid
1035            || (jiffies - data->last_reading > ADM1026_DATA_INTERVAL )) {
1036                /* Things that change quickly */
1037
1038#ifdef DEBUG
1039                printk("adm1026(%d): Reading sensor values\n", client->id);
1040#endif
1041                for (i = 0 ; i <= 16 ; ++i) {
1042                        data->in[i] =
1043                            adm1026_read_value(client, ADM1026_REG_IN(i));
1044                }
1045
1046                for (i = 0 ; i <= 7 ; ++i) {
1047                        data->fan[i] =
1048                            adm1026_read_value(client, ADM1026_REG_FAN(i));
1049                }
1050
1051                for (i = 0 ; i <= 2 ; ++i) {
1052                        /* NOTE: temp[] is s8 and we assume 2's complement
1053                         *   "conversion" in the assignment   */
1054                        data->temp[i] =
1055                            adm1026_read_value(client, ADM1026_REG_TEMP(i));
1056                }
1057
1058                data->pwm = adm1026_read_value(client, ADM1026_REG_PWM);
1059                data->analog_out = adm1026_read_value(client, ADM1026_REG_DAC);
1060
1061                /* GPIO16 is MSbit of alarms, move it to gpio */
1062                alarms  = adm1026_read_value(client, ADM1026_REG_STATUS4);
1063                gpio = alarms & 0x80 ? 0x0100 : 0 ;  /* GPIO16 */
1064                alarms &= 0x7f ;
1065                alarms <<= 8 ;
1066                alarms |= adm1026_read_value(client, ADM1026_REG_STATUS3);
1067                alarms <<= 8 ;
1068                alarms |= adm1026_read_value(client, ADM1026_REG_STATUS2);
1069                alarms <<= 8 ;
1070                alarms |= adm1026_read_value(client, ADM1026_REG_STATUS1);
1071                data->alarms = alarms ;
1072
1073                /* Read the GPIO values */
1074                gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_STATUS_8_15);
1075                gpio <<= 8 ;
1076                gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_STATUS_0_7);
1077                data->gpio = gpio ;
1078
1079                data->last_reading = jiffies ;
1080        };  /* last_reading */
1081
1082        if (!data->valid
1083            || (jiffies - data->last_config > ADM1026_CONFIG_INTERVAL) ) {
1084                /* Things that don't change often */
1085
1086#ifdef DEBUG
1087                printk("adm1026(%d): Reading config values\n", client->id);
1088#endif
1089                for (i = 0 ; i <= 16 ; ++i) {
1090                        data->in_min[i] =
1091                            adm1026_read_value(client, ADM1026_REG_IN_MIN(i));
1092                        data->in_max[i] =
1093                            adm1026_read_value(client, ADM1026_REG_IN_MAX(i));
1094                }
1095
1096                value = adm1026_read_value(client, ADM1026_REG_FAN_DIV_0_3)
1097                        | (adm1026_read_value(client, ADM1026_REG_FAN_DIV_4_7) << 8);
1098                for (i = 0 ; i <= 7 ; ++i) {
1099                        data->fan_min[i] =
1100                            adm1026_read_value(client, ADM1026_REG_FAN_MIN(i));
1101                        data->fan_div[i] = DIV_FROM_REG(value & 0x03);
1102                        value >>= 2 ;
1103                }
1104
1105                for (i = 0; i <= 2; ++i) {
1106                        /* NOTE: temp_xxx[] are s8 and we assume 2's complement
1107                         *   "conversion" in the assignment   */
1108                        data->temp_min[i] =
1109                            adm1026_read_value(client, ADM1026_REG_TEMP_MIN(i));
1110                        data->temp_max[i] =
1111                            adm1026_read_value(client, ADM1026_REG_TEMP_MAX(i));
1112                        data->temp_tmin[i] =
1113                            adm1026_read_value(client, ADM1026_REG_TEMP_TMIN(i));
1114                        data->temp_therm[i] =
1115                            adm1026_read_value(client, ADM1026_REG_TEMP_THERM(i));
1116                        data->temp_offset[i] =
1117                            adm1026_read_value(client, ADM1026_REG_TEMP_OFFSET(i));
1118                }
1119
1120                /* Read the STATUS/alarm masks */
1121                alarms  = adm1026_read_value(client, ADM1026_REG_MASK4);
1122                gpio    = alarms & 0x80 ? 0x0100 : 0 ;  /* GPIO16 */
1123                alarms  = (alarms & 0x7f) << 8 ;
1124                alarms |= adm1026_read_value(client, ADM1026_REG_MASK3);
1125                alarms <<= 8 ;
1126                alarms |= adm1026_read_value(client, ADM1026_REG_MASK2);
1127                alarms <<= 8 ;
1128                alarms |= adm1026_read_value(client, ADM1026_REG_MASK1);
1129                data->alarm_mask = alarms ;
1130
1131                /* Read the GPIO values */
1132                gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_MASK_8_15);
1133                gpio <<= 8 ;
1134                gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_MASK_0_7);
1135                data->gpio_mask = gpio ;
1136
1137                /* Read the GPIO config */
1138                data->config2 = adm1026_read_value(client, ADM1026_REG_CONFIG2);
1139                data->config3 = adm1026_read_value(client, ADM1026_REG_CONFIG3);
1140                data->gpio_config[16] = (data->config3 >> 6) & 0x03 ;
1141
1142                value = 0 ;
1143                for( i = 0 ; i <= 15 ; ++i ) {
1144                        if( (i & 0x03) == 0 ) {
1145                                value = adm1026_read_value(client,
1146                                            ADM1026_REG_GPIO_CFG_0_3 + i/4 );
1147                        }
1148                        data->gpio_config[i] = value & 0x03 ;
1149                        value >>= 2 ;
1150                }
1151
1152                data->last_config = jiffies;
1153        };  /* last_config */
1154
1155        /* We don't know where or even _if_ the VID might be on the GPIO
1156         *    pins.  But the datasheet gives an example config showing
1157         *    GPIO11-15 being used to monitor VID0-4, so we go with that
1158         *    but make the vid WRITEABLE so if it's wrong, the user can
1159         *    set it in /etc/sensors.conf perhaps using an expression or
1160         *    0 to trigger a re-read from the GPIO pins.
1161         */
1162        if( data->vid == ADM1026_INIT_VID ) {
1163                /* Hasn't been set yet, make a bold assumption */
1164                printk("adm1026(%d): Setting VID from GPIO11-15.\n",
1165                            client->id );
1166                data->vid = (data->gpio >> 11) & 0x1f ;
1167        }
1168       
1169        data->valid = 1;
1170
1171        up(&data->update_lock);
1172}
1173
1174
1175/* The following functions are the call-back functions of the /proc/sys and
1176   sysctl files.  The appropriate function is referenced in the ctl_table
1177   extra1 field.
1178
1179   Each function must return the magnitude (power of 10 to divide the
1180   data with) if it is called with operation set to SENSORS_PROC_REAL_INFO.
1181   It must put a maximum of *nrels elements in results reflecting the
1182   data of this file, and set *nrels to the number it actually put in
1183   it, if operation is SENSORS_PROC_REAL_READ.  Finally, it must get
1184   up to *nrels elements from results and write them to the chip, if
1185   operations is SENSORS_PROC_REAL_WRITE.
1186 */
1187void adm1026_in(struct i2c_client *client, int operation, int ctl_name,
1188             int *nrels_mag, long *results)
1189{
1190        struct adm1026_data *data = client->data;
1191        int nr = ctl_name - ADM1026_SYSCTL_IN0;
1192
1193        /* We handle in0 - in15 here.  in16 (-12V) is handled below */
1194        if (nr < 0 || nr > 15)
1195                return ;  /* ERROR */
1196
1197        if (operation == SENSORS_PROC_REAL_INFO)
1198                *nrels_mag = 3;  /* 1.000 */
1199        else if (operation == SENSORS_PROC_REAL_READ) {
1200                adm1026_update_client(client);
1201                results[0] = INS_FROM_REG(nr,data->in_min[nr]);
1202                results[1] = INS_FROM_REG(nr,data->in_max[nr]);
1203                results[2] = INS_FROM_REG(nr,data->in[nr]);
1204                *nrels_mag = 3;
1205        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1206                down(&data->update_lock);
1207                if (*nrels_mag > 1) {
1208                        data->in_max[nr] = INS_TO_REG(nr,results[1]);
1209                        adm1026_write_value(client, ADM1026_REG_IN_MAX(nr),
1210                                         data->in_max[nr]);
1211                }
1212                if (*nrels_mag > 0) {
1213                        data->in_min[nr] = INS_TO_REG(nr,results[0]);
1214                        adm1026_write_value(client, ADM1026_REG_IN_MIN(nr),
1215                                         data->in_min[nr]);
1216                }
1217                up(&data->update_lock);
1218        }
1219}
1220
1221void adm1026_in16(struct i2c_client *client, int operation, int ctl_name,
1222             int *nrels_mag, long *results)
1223{
1224        struct adm1026_data *data = client->data;
1225        int nr = ctl_name - ADM1026_SYSCTL_IN0;
1226
1227        /* We handle in16 (-12V) here */
1228        if (nr != 16)
1229                return ;  /* ERROR */
1230
1231        /* Apply offset and swap min/max so that min is 90% of
1232         *    target and max is 110% of target.
1233         */
1234
1235        if (operation == SENSORS_PROC_REAL_INFO)
1236                *nrels_mag = 3;  /* 1.000 */
1237        else if (operation == SENSORS_PROC_REAL_READ) {
1238                adm1026_update_client(client);
1239                results[0] = INS_FROM_REG(nr,data->in_max[nr])-NEG12_OFFSET ;
1240                results[1] = INS_FROM_REG(nr,data->in_min[nr])-NEG12_OFFSET ;
1241                results[2] = INS_FROM_REG(nr,data->in[nr])-NEG12_OFFSET ;
1242                *nrels_mag = 3;
1243        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1244                down(&data->update_lock);
1245                if (*nrels_mag > 1) {
1246                        data->in_min[nr] = INS_TO_REG(nr,results[1]+NEG12_OFFSET);
1247                        adm1026_write_value(client, ADM1026_REG_IN_MIN(nr),
1248                                         data->in_min[nr]);
1249                }
1250                if (*nrels_mag > 0) {
1251                        data->in_max[nr] = INS_TO_REG(nr,results[0]+NEG12_OFFSET);
1252                        adm1026_write_value(client, ADM1026_REG_IN_MAX(nr),
1253                                         data->in_max[nr]);
1254                }
1255                up(&data->update_lock);
1256        }
1257}
1258
1259void adm1026_fan(struct i2c_client *client, int operation, int ctl_name,
1260              int *nrels_mag, long *results)
1261{
1262        struct adm1026_data *data = client->data;
1263        int nr = ctl_name - ADM1026_SYSCTL_FAN0 ;
1264
1265        if (nr < 0 || nr > 7)
1266                return ;  /* ERROR */
1267
1268        if (operation == SENSORS_PROC_REAL_INFO)
1269                *nrels_mag = 0;
1270        else if (operation == SENSORS_PROC_REAL_READ) {
1271                adm1026_update_client(client);
1272                results[0] = FAN_FROM_REG(data->fan_min[nr], data->fan_div[nr]);
1273                results[1] = FAN_FROM_REG(data->fan[nr], data->fan_div[nr]);
1274                *nrels_mag = 2;
1275        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1276                down(&data->update_lock);
1277                if (*nrels_mag > 0) {
1278                        data->fan_min[nr] = FAN_TO_REG(results[0],
1279                                                        data->fan_div[nr]);
1280                        adm1026_write_value(client, ADM1026_REG_FAN_MIN(nr),
1281                                         data->fan_min[nr]);
1282                }
1283                up(&data->update_lock);
1284        }
1285}
1286
1287/* Adjust fan_min to account for new fan divisor */
1288void adm1026_fixup_fan_min(struct i2c_client *client, int fan, int old_div)
1289{
1290        struct adm1026_data *data = client->data;
1291        int  new_div = data->fan_div[fan] ;
1292        int  new_min;
1293
1294        /* 0 and 0xff are special.  Don't adjust them */
1295        if( data->fan_min[fan] == 0 || data->fan_min[fan] == 0xff ) {
1296                return ;
1297        }
1298
1299        new_min = data->fan_min[fan] * old_div / new_div ;
1300        new_min = SENSORS_LIMIT(new_min, 1, 254);
1301        data->fan_min[fan] = new_min ;
1302        adm1026_write_value(client, ADM1026_REG_FAN_MIN(fan), new_min);
1303}
1304
1305void adm1026_fan_div(struct i2c_client *client, int operation, int ctl_name,
1306                int *nrels_mag, long *results)
1307{
1308        struct adm1026_data *data = client->data;
1309        int i ;
1310        int value, div, old ;
1311
1312        if (ctl_name != ADM1026_SYSCTL_FAN_DIV)
1313                return ;  /* ERROR */
1314
1315        if (operation == SENSORS_PROC_REAL_INFO)
1316                *nrels_mag = 0;
1317        else if (operation == SENSORS_PROC_REAL_READ) {
1318                adm1026_update_client(client);
1319                for( i = 0 ; i <= 7 ; ++i ) {
1320                        results[i] = data->fan_div[i] ;
1321                }
1322                *nrels_mag = 8;
1323        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1324                down(&data->update_lock);
1325                value = 0 ;
1326                for( i = 7 ; i >= 0 ; --i ) {
1327                        value <<= 2 ;
1328                        if (*nrels_mag > i) {
1329                                old = data->fan_div[i] ;
1330                                div = DIV_TO_REG(results[i]) ;
1331                                data->fan_div[i] = DIV_FROM_REG(div) ;
1332                                if( data->fan_div[i] != old ) {
1333                                        adm1026_fixup_fan_min(client,i,old);
1334                                }
1335                        } else {
1336                                div = DIV_TO_REG(data->fan_div[i]) ;
1337                        }
1338                        value |= div ;
1339                }
1340                adm1026_write_value(client, ADM1026_REG_FAN_DIV_0_3,
1341                        value & 0xff);
1342                adm1026_write_value(client, ADM1026_REG_FAN_DIV_4_7,
1343                        (value >> 8) & 0xff);
1344                up(&data->update_lock);
1345        }
1346}
1347
1348void adm1026_temp(struct i2c_client *client, int operation, int ctl_name,
1349               int *nrels_mag, long *results)
1350{
1351        struct adm1026_data *data = client->data;
1352        int nr = ctl_name - ADM1026_SYSCTL_TEMP1 ;
1353
1354        if (nr < 0 || nr > 2)
1355                return ;  /* ERROR */
1356
1357        if (operation == SENSORS_PROC_REAL_INFO)
1358                *nrels_mag = 0;
1359        else if (operation == SENSORS_PROC_REAL_READ) {
1360                adm1026_update_client(client);
1361                results[0] = TEMP_FROM_REG(data->temp_min[nr]);
1362                results[1] = TEMP_FROM_REG(data->temp_max[nr]);
1363                results[2] = TEMP_FROM_REG(data->temp[nr]);
1364                *nrels_mag = 3;
1365        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1366                down(&data->update_lock);
1367                if (*nrels_mag > 1) {
1368                        data->temp_max[nr] = TEMP_TO_REG(results[1]);
1369                        adm1026_write_value(client, ADM1026_REG_TEMP_MAX(nr),
1370                                         data->temp_max[nr]);
1371                }
1372                if (*nrels_mag > 0) {
1373                        data->temp_min[nr] = TEMP_TO_REG(results[0]);
1374                        adm1026_write_value(client, ADM1026_REG_TEMP_MIN(nr),
1375                                         data->temp_min[nr]);
1376                }
1377                up(&data->update_lock);
1378        }
1379}
1380
1381void adm1026_temp_offset(struct i2c_client *client, int operation, int ctl_name,
1382                int *nrels_mag, long *results)
1383{
1384        struct adm1026_data *data = client->data;
1385        int nr = ctl_name - ADM1026_SYSCTL_TEMP_OFFSET1 ;
1386
1387        if (nr < 0 || nr > 2)
1388                return ;  /* ERROR */
1389
1390        if (operation == SENSORS_PROC_REAL_INFO)
1391                *nrels_mag = 0;
1392        else if (operation == SENSORS_PROC_REAL_READ) {
1393                adm1026_update_client(client);
1394                results[0] = TEMP_FROM_REG(data->temp_offset[nr]);
1395                *nrels_mag = 1;
1396        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1397                down(&data->update_lock);
1398                if (*nrels_mag > 0) {
1399                        data->temp_offset[nr] = TEMP_TO_REG(results[0]);
1400                        adm1026_write_value(client, ADM1026_REG_TEMP_OFFSET(nr),
1401                            data->temp_offset[nr]);
1402                }
1403                up(&data->update_lock);
1404        }
1405}
1406
1407void adm1026_temp_tmin(struct i2c_client *client, int operation, int ctl_name,
1408                int *nrels_mag, long *results)
1409{
1410        struct adm1026_data *data = client->data;
1411        int nr = ctl_name - ADM1026_SYSCTL_TEMP_TMIN1 ;
1412
1413        if (nr < 0 || nr > 2)
1414                return ;  /* ERROR */
1415
1416        if (operation == SENSORS_PROC_REAL_INFO)
1417                *nrels_mag = 0;
1418        else if (operation == SENSORS_PROC_REAL_READ) {
1419                adm1026_update_client(client);
1420                results[0] = TEMP_FROM_REG(data->temp_tmin[nr]);
1421                *nrels_mag = 1;
1422        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1423                down(&data->update_lock);
1424                if (*nrels_mag > 0) {
1425                        data->temp_tmin[nr] = TEMP_TO_REG(results[0]);
1426                        adm1026_write_value(client, ADM1026_REG_TEMP_TMIN(nr),
1427                            data->temp_tmin[nr]);
1428                }
1429                up(&data->update_lock);
1430        }
1431}
1432
1433void adm1026_temp_therm(struct i2c_client *client, int operation, int ctl_name,
1434                int *nrels_mag, long *results)
1435{
1436        struct adm1026_data *data = client->data;
1437        int nr = ctl_name - ADM1026_SYSCTL_TEMP_THERM1 ;
1438
1439        if (nr < 0 || nr > 2)
1440                return ;  /* ERROR */
1441
1442        if (operation == SENSORS_PROC_REAL_INFO)
1443                *nrels_mag = 0;
1444        else if (operation == SENSORS_PROC_REAL_READ) {
1445                adm1026_update_client(client);
1446                results[0] = TEMP_FROM_REG(data->temp_therm[nr]);
1447                *nrels_mag = 1;
1448        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1449                down(&data->update_lock);
1450                if (*nrels_mag > 0) {
1451                        data->temp_therm[nr] = TEMP_TO_REG(results[0]);
1452                        adm1026_write_value(client, ADM1026_REG_TEMP_THERM(nr),
1453                            data->temp_therm[nr]);
1454                }
1455                up(&data->update_lock);
1456        }
1457}
1458
1459void adm1026_pwm(struct i2c_client *client, int operation, int ctl_name,
1460              int *nrels_mag, long *results)
1461{
1462        struct adm1026_data *data = client->data;
1463
1464        if (ctl_name != ADM1026_SYSCTL_PWM)
1465                return ;  /* ERROR */
1466
1467        if (operation == SENSORS_PROC_REAL_INFO)
1468                *nrels_mag = 0;
1469        else if (operation == SENSORS_PROC_REAL_READ) {
1470                adm1026_update_client(client);
1471                results[0] = PWM_FROM_REG(data->pwm);
1472                results[1] = 1 ;  /* Always enabled */
1473                *nrels_mag = 2;
1474        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1475                down(&data->update_lock);
1476                /* PWM enable is read-only */
1477                if (*nrels_mag > 0) {
1478                        data->pwm = PWM_TO_REG(results[0]);
1479                        adm1026_write_value(client, ADM1026_REG_PWM,
1480                                         data->pwm);
1481                }
1482                up(&data->update_lock);
1483        }
1484}
1485
1486void adm1026_analog_out(struct i2c_client *client, int operation, int ctl_name,
1487              int *nrels_mag, long *results)
1488{
1489        struct adm1026_data *data = client->data;
1490
1491        if (ctl_name != ADM1026_SYSCTL_ANALOG_OUT)
1492                return ;  /* ERROR */
1493
1494        if (operation == SENSORS_PROC_REAL_INFO)
1495                *nrels_mag = 0;  /* 0 - 255 */
1496        else if (operation == SENSORS_PROC_REAL_READ) {
1497                adm1026_update_client(client);
1498                results[0] = DAC_FROM_REG(data->analog_out);
1499                *nrels_mag = 1;
1500        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1501                down(&data->update_lock);
1502                if (*nrels_mag > 0) {
1503                        data->analog_out = DAC_TO_REG(results[0]);
1504                        adm1026_write_value(client, ADM1026_REG_DAC,
1505                                         data->analog_out);
1506                }
1507                up(&data->update_lock);
1508        }
1509}
1510
1511void adm1026_afc(struct i2c_client *client, int operation, int ctl_name,
1512              int *nrels_mag, long *results)
1513{
1514        struct adm1026_data *data = client->data;
1515
1516        if (ctl_name != ADM1026_SYSCTL_AFC)
1517                return ;  /* ERROR */
1518
1519        /* PWM auto fan control, DAC auto fan control */
1520
1521        if (operation == SENSORS_PROC_REAL_INFO)
1522                *nrels_mag = 0;
1523        else if (operation == SENSORS_PROC_REAL_READ) {
1524                adm1026_update_client(client);
1525                results[0] = (data->config1 & CFG1_PWM_AFC) != 0 ;
1526                results[1] = (data->config1 & CFG1_DAC_AFC) != 0 ;
1527                *nrels_mag = 2;
1528        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1529                down(&data->update_lock);
1530                if (*nrels_mag > 1) {
1531                        data->config1 = (data->config1 & ~CFG1_DAC_AFC)
1532                                | (results[1] ? CFG1_DAC_AFC : 0) ;
1533                }
1534                if (*nrels_mag > 0) {
1535                        data->config1 = (data->config1 & ~CFG1_PWM_AFC)
1536                                | (results[0] ? CFG1_PWM_AFC : 0) ;
1537                        adm1026_write_value(client, ADM1026_REG_CONFIG1,
1538                                         data->config1);
1539                }
1540                up(&data->update_lock);
1541        }
1542}
1543
1544void adm1026_vid(struct i2c_client *client, int operation, int ctl_name,
1545              int *nrels_mag, long *results)
1546{
1547        struct adm1026_data *data = client->data;
1548
1549        if( ctl_name != ADM1026_SYSCTL_VID )
1550                return ;  /* ERROR */
1551
1552        if (operation == SENSORS_PROC_REAL_INFO)
1553                *nrels_mag = 3;
1554        else if (operation == SENSORS_PROC_REAL_READ) {
1555                adm1026_update_client(client);
1556                results[0] = vid_from_reg((data->vid)&0x3f,data->vrm);
1557                *nrels_mag = 1;
1558        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1559                down(&data->update_lock);
1560                /* Hmmm... There isn't a VID_TO_REG mapping */
1561                if (*nrels_mag > 0) {
1562                        if( results[0] >= 0 ) {
1563                                data->vid = results[0] & 0x3f ;
1564                        } else {
1565                                data->vid = ADM1026_INIT_VID ;
1566                        }
1567                }
1568                up(&data->update_lock);
1569        }
1570
1571}
1572
1573void adm1026_vrm(struct i2c_client *client, int operation, int ctl_name,
1574              int *nrels_mag, long *results)
1575{
1576        struct adm1026_data *data = client->data;
1577
1578        if( ctl_name != ADM1026_SYSCTL_VRM )
1579                return ;  /* ERROR */
1580
1581        if (operation == SENSORS_PROC_REAL_INFO)
1582                *nrels_mag = 1;
1583        else if (operation == SENSORS_PROC_REAL_READ) {
1584                results[0] = data->vrm ;
1585                *nrels_mag = 1;
1586        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1587                if (*nrels_mag > 0) {
1588                        data->vrm = results[0] ;
1589                }
1590        }
1591}
1592
1593void adm1026_alarms(struct i2c_client *client, int operation, int ctl_name,
1594                int *nrels_mag, long *results)
1595{
1596        struct adm1026_data *data = client->data;
1597
1598        if( ctl_name != ADM1026_SYSCTL_ALARMS )
1599                return ;  /* ERROR */
1600
1601        if (operation == SENSORS_PROC_REAL_INFO)
1602                *nrels_mag = 0;
1603        else if (operation == SENSORS_PROC_REAL_READ) {
1604                adm1026_update_client(client);
1605                results[0] = data->alarms ;
1606                *nrels_mag = 1;
1607        }
1608        /* FIXME: Perhaps we should implement a write function
1609         *   to clear an alarm?
1610         */
1611}
1612
1613void adm1026_alarm_mask(struct i2c_client *client, int operation,
1614                int ctl_name, int *nrels_mag, long *results)
1615{
1616        struct adm1026_data *data = client->data;
1617        unsigned long mask ;
1618
1619        if( ctl_name != ADM1026_SYSCTL_ALARM_MASK )
1620                return ;  /* ERROR */
1621
1622        if (operation == SENSORS_PROC_REAL_INFO)
1623                *nrels_mag = 0;
1624        else if (operation == SENSORS_PROC_REAL_READ) {
1625                adm1026_update_client(client);
1626                results[0] = data->alarm_mask ;
1627                *nrels_mag = 1;
1628        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1629                down(&data->update_lock);
1630                if (*nrels_mag > 0) {
1631                        data->alarm_mask = results[0] & 0x7fffffff ;
1632                        mask = data->alarm_mask
1633                                | (data->gpio_mask & 0x10000 ? 0x80000000 : 0) ;
1634                        adm1026_write_value(client, ADM1026_REG_MASK1,
1635                                        mask & 0xff);
1636                        mask >>= 8 ;
1637                        adm1026_write_value(client, ADM1026_REG_MASK2,
1638                                        mask & 0xff);
1639                        mask >>= 8 ;
1640                        adm1026_write_value(client, ADM1026_REG_MASK3,
1641                                        mask & 0xff);
1642                        mask >>= 8 ;
1643                        adm1026_write_value(client, ADM1026_REG_MASK4,
1644                                        mask & 0xff);
1645                }
1646                up(&data->update_lock);
1647        }
1648}
1649
1650void adm1026_gpio(struct i2c_client *client, int operation, int ctl_name,
1651                int *nrels_mag, long *results)
1652{
1653        struct adm1026_data *data = client->data;
1654        long gpio ;
1655
1656        if( ctl_name != ADM1026_SYSCTL_GPIO )
1657                return ;  /* ERROR */
1658
1659        if (operation == SENSORS_PROC_REAL_INFO)
1660                *nrels_mag = 0;
1661        else if (operation == SENSORS_PROC_REAL_READ) {
1662                adm1026_update_client(client);
1663                results[0] = data->gpio ;
1664                *nrels_mag = 1;
1665        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1666                down(&data->update_lock);
1667                if (*nrels_mag > 0) {
1668                        data->gpio = results[0] & 0x1ffff ;
1669                        gpio = data->gpio ;
1670                        adm1026_write_value(client,
1671                                ADM1026_REG_GPIO_STATUS_0_7,
1672                                gpio & 0xff );
1673                        gpio >>= 8 ;
1674                        adm1026_write_value(client,
1675                                ADM1026_REG_GPIO_STATUS_8_15,
1676                                gpio & 0xff );
1677                        gpio = ((gpio >> 1) & 0x80)
1678                                | (data->alarms >> 24 & 0x7f);
1679                        adm1026_write_value(client,
1680                                ADM1026_REG_STATUS4,
1681                                gpio & 0xff );
1682                }
1683                up(&data->update_lock);
1684        }
1685}
1686
1687void adm1026_gpio_mask(struct i2c_client *client, int operation,
1688                int ctl_name, int *nrels_mag, long *results)
1689{
1690        struct adm1026_data *data = client->data;
1691        long mask ;
1692
1693        if( ctl_name != ADM1026_SYSCTL_GPIO_MASK )
1694                return ;  /* ERROR */
1695
1696        if (operation == SENSORS_PROC_REAL_INFO)
1697                *nrels_mag = 0;
1698        else if (operation == SENSORS_PROC_REAL_READ) {
1699                adm1026_update_client(client);
1700                results[0] = data->gpio_mask ;
1701                *nrels_mag = 1;
1702        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1703                down(&data->update_lock);
1704                if (*nrels_mag > 0) {
1705                        data->gpio_mask = results[0] & 0x1ffff ;
1706                        mask = data->gpio_mask ;
1707                        adm1026_write_value(client, ADM1026_REG_GPIO_MASK_0_7,
1708                                        mask & 0xff);
1709                        mask >>= 8 ;
1710                        adm1026_write_value(client, ADM1026_REG_GPIO_MASK_8_15,
1711                                        mask & 0xff);
1712                        mask = ((mask >> 1) & 0x80)
1713                                | (data->alarm_mask >> 24 & 0x7f);
1714                        adm1026_write_value(client, ADM1026_REG_MASK1,
1715                                        mask & 0xff);
1716                }
1717                up(&data->update_lock);
1718        }
1719}
1720
1721static int __init sm_adm1026_init(void)
1722{
1723        printk("adm1026: Version %s (%s)\n", LM_VERSION, LM_DATE);
1724        printk("adm1026: See http://www.penguincomputing.com/lm_sensors for more info.\n" );
1725        return i2c_add_driver(&adm1026_driver);
1726}
1727
1728static void __exit sm_adm1026_exit(void)
1729{
1730        i2c_del_driver(&adm1026_driver);
1731}
1732
1733MODULE_LICENSE("GPL");
1734MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com");
1735MODULE_DESCRIPTION("ADM1026 driver");
1736
1737module_init(sm_adm1026_init);
1738module_exit(sm_adm1026_exit);
Note: See TracBrowser for help on using the browser.