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

Revision 5374, 55.6 KB (checked in by khali, 5 years ago)

Typo fix.

  • 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
300        struct semaphore update_lock;
301        int valid;              /* !=0 if following fields are valid */
302        unsigned long last_reading;     /* In jiffies */
303        unsigned long last_config;      /* In jiffies */
304
305        u8 in[17];              /* Register value */
306        u8 in_max[17];          /* Register value */
307        u8 in_min[17];          /* Register value */
308        s8 temp[3];             /* Register value */
309        s8 temp_min[3];         /* Register value */
310        s8 temp_max[3];         /* Register value */
311        s8 temp_tmin[3];        /* Register value */
312        s8 temp_therm[3];       /* Register value */
313        s8 temp_offset[3];      /* Register value */
314        u8 fan[8];              /* Register value */
315        u8 fan_min[8];          /* Register value */
316        u8 fan_div[8];          /* Decoded value */
317        u8 pwm;                 /* Register value */
318        u8 analog_out;          /* Register value */
319        int vid;                /* Decoded value */
320        u8 vrm;                 /* VRM version */
321        long alarms;            /* Register encoding, combined */
322        long alarm_mask;        /* Register encoding, combined */
323        long gpio;              /* Register encoding, combined */
324        long gpio_mask;         /* Register encoding, combined */
325        u8 gpio_config[17];     /* Decoded value */
326        u8 config1;             /* Register value */
327        u8 config2;             /* Register value */
328        u8 config3;             /* Register value */
329};
330
331static int adm1026_attach_adapter(struct i2c_adapter *adapter);
332static int adm1026_detect(struct i2c_adapter *adapter, int address,
333                        unsigned short flags, int kind);
334static int adm1026_detach_client(struct i2c_client *client);
335
336static int adm1026_read_value(struct i2c_client *client, u8 register);
337static int adm1026_write_value(struct i2c_client *client, u8 register, int value);
338static void adm1026_print_gpio(struct i2c_client *client);
339static void adm1026_fixup_gpio(struct i2c_client *client);
340static void adm1026_update_client(struct i2c_client *client);
341static void adm1026_init_client(struct i2c_client *client);
342
343
344static void adm1026_in(struct i2c_client *client, int operation, int ctl_name,
345                        int *nrels_mag, long *results);
346static void adm1026_in16(struct i2c_client *client, int operation, int ctl_name,
347                        int *nrels_mag, long *results);
348static void adm1026_fan(struct i2c_client *client, int operation,
349                        int ctl_name, int *nrels_mag, long *results);
350static void adm1026_fixup_fan_min(struct i2c_client *client,
351                         int fan, int old_div);
352static void adm1026_fan_div(struct i2c_client *client, int operation,
353                        int ctl_name, int *nrels_mag, long *results);
354static void adm1026_temp(struct i2c_client *client, int operation,
355                        int ctl_name, int *nrels_mag, long *results);
356static void adm1026_temp_offset(struct i2c_client *client, int operation,
357                        int ctl_name, int *nrels_mag, long *results);
358static void adm1026_temp_tmin(struct i2c_client *client, int operation,
359                        int ctl_name, int *nrels_mag, long *results);
360static void adm1026_temp_therm(struct i2c_client *client, int operation,
361                        int ctl_name, int *nrels_mag, long *results);
362static void adm1026_vid(struct i2c_client *client, int operation,
363                        int ctl_name, int *nrels_mag, long *results);
364static void adm1026_vrm(struct i2c_client *client, int operation,
365                        int ctl_name, int *nrels_mag, long *results);
366static void adm1026_alarms(struct i2c_client *client, int operation,
367                        int ctl_name, int *nrels_mag, long *results);
368static void adm1026_alarm_mask(struct i2c_client *client, int operation,
369                        int ctl_name, int *nrels_mag, long *results);
370static void adm1026_gpio(struct i2c_client *client, int operation,
371                        int ctl_name, int *nrels_mag, long *results);
372static void adm1026_gpio_mask(struct i2c_client *client, int operation,
373                        int ctl_name, int *nrels_mag, long *results);
374static void adm1026_pwm(struct i2c_client *client, int operation,
375                        int ctl_name, int *nrels_mag, long *results);
376static void adm1026_analog_out(struct i2c_client *client, int operation,
377                        int ctl_name, int *nrels_mag, long *results);
378static void adm1026_afc(struct i2c_client *client, int operation,
379                        int ctl_name, int *nrels_mag, long *results);
380
381static struct i2c_driver adm1026_driver = {
382        .name           = "ADM1026 compatible sensor driver",
383        .id             = I2C_DRIVERID_ADM1026,
384        .flags          = I2C_DF_NOTIFY,
385        .attach_adapter = &adm1026_attach_adapter,
386        .detach_client  = &adm1026_detach_client,
387};
388
389/* Unique ID assigned to each ADM1026 detected */
390static int adm1026_id = 0;
391
392/* -- SENSORS SYSCTL START -- */
393#define ADM1026_SYSCTL_FAN0                 1000
394#define ADM1026_SYSCTL_FAN1                 1001
395#define ADM1026_SYSCTL_FAN2                 1002
396#define ADM1026_SYSCTL_FAN3                 1003
397#define ADM1026_SYSCTL_FAN4                 1004
398#define ADM1026_SYSCTL_FAN5                 1005
399#define ADM1026_SYSCTL_FAN6                 1006
400#define ADM1026_SYSCTL_FAN7                 1007
401#define ADM1026_SYSCTL_FAN_DIV              1008
402#define ADM1026_SYSCTL_GPIO                 1009
403#define ADM1026_SYSCTL_GPIO_MASK            1010
404#define ADM1026_SYSCTL_ALARMS               1011
405#define ADM1026_SYSCTL_ALARM_MASK           1012
406#define ADM1026_SYSCTL_IN0                  1013
407#define ADM1026_SYSCTL_IN1                  1014
408#define ADM1026_SYSCTL_IN2                  1015
409#define ADM1026_SYSCTL_IN3                  1016
410#define ADM1026_SYSCTL_IN4                  1017
411#define ADM1026_SYSCTL_IN5                  1018
412#define ADM1026_SYSCTL_IN6                  1019
413#define ADM1026_SYSCTL_IN7                  1020
414#define ADM1026_SYSCTL_IN8                  1021
415#define ADM1026_SYSCTL_IN9                  1022
416#define ADM1026_SYSCTL_IN10                 1023
417#define ADM1026_SYSCTL_IN11                 1024
418#define ADM1026_SYSCTL_IN12                 1025
419#define ADM1026_SYSCTL_IN13                 1026
420#define ADM1026_SYSCTL_IN14                 1027
421#define ADM1026_SYSCTL_IN15                 1028
422#define ADM1026_SYSCTL_IN16                 1029
423#define ADM1026_SYSCTL_PWM                  1030
424#define ADM1026_SYSCTL_ANALOG_OUT           1031
425#define ADM1026_SYSCTL_AFC                  1032
426#define ADM1026_SYSCTL_TEMP1                1033
427#define ADM1026_SYSCTL_TEMP2                1034
428#define ADM1026_SYSCTL_TEMP3                1035
429#define ADM1026_SYSCTL_TEMP_OFFSET1         1036
430#define ADM1026_SYSCTL_TEMP_OFFSET2         1037
431#define ADM1026_SYSCTL_TEMP_OFFSET3         1038
432#define ADM1026_SYSCTL_TEMP_THERM1          1039
433#define ADM1026_SYSCTL_TEMP_THERM2          1040
434#define ADM1026_SYSCTL_TEMP_THERM3          1041
435#define ADM1026_SYSCTL_TEMP_TMIN1           1042
436#define ADM1026_SYSCTL_TEMP_TMIN2           1043
437#define ADM1026_SYSCTL_TEMP_TMIN3           1044
438#define ADM1026_SYSCTL_VID                  1045
439#define ADM1026_SYSCTL_VRM                  1046
440
441#define ADM1026_ALARM_TEMP2   (1L <<  0)
442#define ADM1026_ALARM_TEMP3   (1L <<  1)
443#define ADM1026_ALARM_IN9     (1L <<  1)
444#define ADM1026_ALARM_IN11    (1L <<  2)
445#define ADM1026_ALARM_IN12    (1L <<  3)
446#define ADM1026_ALARM_IN13    (1L <<  4)
447#define ADM1026_ALARM_IN14    (1L <<  5)
448#define ADM1026_ALARM_IN15    (1L <<  6)
449#define ADM1026_ALARM_IN16    (1L <<  7)
450#define ADM1026_ALARM_IN0     (1L <<  8)
451#define ADM1026_ALARM_IN1     (1L <<  9)
452#define ADM1026_ALARM_IN2     (1L << 10)
453#define ADM1026_ALARM_IN3     (1L << 11)
454#define ADM1026_ALARM_IN4     (1L << 12)
455#define ADM1026_ALARM_IN5     (1L << 13)
456#define ADM1026_ALARM_IN6     (1L << 14)
457#define ADM1026_ALARM_IN7     (1L << 15)
458#define ADM1026_ALARM_FAN0    (1L << 16)
459#define ADM1026_ALARM_FAN1    (1L << 17)
460#define ADM1026_ALARM_FAN2    (1L << 18)
461#define ADM1026_ALARM_FAN3    (1L << 19)
462#define ADM1026_ALARM_FAN4    (1L << 20)
463#define ADM1026_ALARM_FAN5    (1L << 21)
464#define ADM1026_ALARM_FAN6    (1L << 22)
465#define ADM1026_ALARM_FAN7    (1L << 23)
466#define ADM1026_ALARM_TEMP1   (1L << 24)
467#define ADM1026_ALARM_IN10    (1L << 25)
468#define ADM1026_ALARM_IN8     (1L << 26)
469#define ADM1026_ALARM_THERM   (1L << 27)
470#define ADM1026_ALARM_AFC_FAN (1L << 28)
471#define ADM1026_ALARM_CI      (1L << 30)
472/* -- SENSORS SYSCTL END -- */
473
474/* The /proc/sys entries */
475/* These files are created for each detected ADM1026. This is just a template;
476 *    The actual list is built from this and additional per-chip
477 *    custom lists below.  Note the XXX_LEN macros.  These must be
478 *    compile time constants because they will be used to allocate
479 *    space for the final template passed to i2c_register_entry.
480 *    We depend on the ability of GCC to evaluate expressions at
481 *    compile time to turn these expressions into compile time
482 *    constants, but this can generate a warning.
483 */
484static ctl_table adm1026_common[] = {
485        {ADM1026_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
486                &i2c_sysctl_real, NULL, &adm1026_in},
487        {ADM1026_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
488                &i2c_sysctl_real, NULL, &adm1026_in},
489        {ADM1026_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
490                &i2c_sysctl_real, NULL, &adm1026_in},
491        {ADM1026_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
492                &i2c_sysctl_real, NULL, &adm1026_in},
493        {ADM1026_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
494                &i2c_sysctl_real, NULL, &adm1026_in},
495        {ADM1026_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
496                &i2c_sysctl_real, NULL, &adm1026_in},
497        {ADM1026_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
498                &i2c_sysctl_real, NULL, &adm1026_in},
499        {ADM1026_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
500                &i2c_sysctl_real, NULL, &adm1026_in},
501        {ADM1026_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
502                &i2c_sysctl_real, NULL, &adm1026_in},
503        {ADM1026_SYSCTL_IN9, "in9", NULL, 0, 0644, NULL, &i2c_proc_real,
504                &i2c_sysctl_real, NULL, &adm1026_in},
505        {ADM1026_SYSCTL_IN10, "in10", NULL, 0, 0644, NULL, &i2c_proc_real,
506                &i2c_sysctl_real, NULL, &adm1026_in},
507        {ADM1026_SYSCTL_IN11, "in11", NULL, 0, 0644, NULL, &i2c_proc_real,
508                &i2c_sysctl_real, NULL, &adm1026_in},
509        {ADM1026_SYSCTL_IN12, "in12", NULL, 0, 0644, NULL, &i2c_proc_real,
510                &i2c_sysctl_real, NULL, &adm1026_in},
511        {ADM1026_SYSCTL_IN13, "in13", NULL, 0, 0644, NULL, &i2c_proc_real,
512                &i2c_sysctl_real, NULL, &adm1026_in},
513        {ADM1026_SYSCTL_IN14, "in14", NULL, 0, 0644, NULL, &i2c_proc_real,
514                &i2c_sysctl_real, NULL, &adm1026_in},
515        {ADM1026_SYSCTL_IN15, "in15", NULL, 0, 0644, NULL, &i2c_proc_real,
516                &i2c_sysctl_real, NULL, &adm1026_in},
517        {ADM1026_SYSCTL_IN16, "in16", NULL, 0, 0644, NULL, &i2c_proc_real,
518                &i2c_sysctl_real, NULL, &adm1026_in16},
519
520        {ADM1026_SYSCTL_FAN0, "fan0", NULL, 0, 0644, NULL, &i2c_proc_real,
521                &i2c_sysctl_real, NULL, &adm1026_fan},
522        {ADM1026_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
523                &i2c_sysctl_real, NULL, &adm1026_fan},
524        {ADM1026_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
525                &i2c_sysctl_real, NULL, &adm1026_fan},
526        {ADM1026_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
527                &i2c_sysctl_real, NULL, &adm1026_fan},
528        {ADM1026_SYSCTL_FAN4, "fan4", NULL, 0, 0644, NULL, &i2c_proc_real,
529                &i2c_sysctl_real, NULL, &adm1026_fan},
530        {ADM1026_SYSCTL_FAN5, "fan5", NULL, 0, 0644, NULL, &i2c_proc_real,
531                &i2c_sysctl_real, NULL, &adm1026_fan},
532        {ADM1026_SYSCTL_FAN6, "fan6", NULL, 0, 0644, NULL, &i2c_proc_real,
533                &i2c_sysctl_real, NULL, &adm1026_fan},
534        {ADM1026_SYSCTL_FAN7, "fan7", NULL, 0, 0644, NULL, &i2c_proc_real,
535                &i2c_sysctl_real, NULL, &adm1026_fan},
536        {ADM1026_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL,
537                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_fan_div},
538
539        {ADM1026_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
540                &i2c_sysctl_real, NULL, &adm1026_temp},
541        {ADM1026_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
542                &i2c_sysctl_real, NULL, &adm1026_temp},
543        {ADM1026_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
544                &i2c_sysctl_real, NULL, &adm1026_temp},
545        {ADM1026_SYSCTL_TEMP_OFFSET1, "temp1_offset", NULL, 0, 0644, NULL,
546                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_offset},
547        {ADM1026_SYSCTL_TEMP_OFFSET2, "temp2_offset", NULL, 0, 0644, NULL,
548                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_offset},
549        {ADM1026_SYSCTL_TEMP_OFFSET3, "temp3_offset", NULL, 0, 0644, NULL,
550                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_offset},
551        {ADM1026_SYSCTL_TEMP_TMIN1, "temp1_tmin", NULL, 0, 0644, NULL,
552                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_tmin},
553        {ADM1026_SYSCTL_TEMP_TMIN2, "temp2_tmin", NULL, 0, 0644, NULL,
554                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_tmin},
555        {ADM1026_SYSCTL_TEMP_TMIN3, "temp3_tmin", NULL, 0, 0644, NULL,
556                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_tmin},
557        {ADM1026_SYSCTL_TEMP_THERM1, "temp1_therm", NULL, 0, 0644, NULL,
558                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_therm},
559        {ADM1026_SYSCTL_TEMP_THERM2, "temp2_therm", NULL, 0, 0644, NULL,
560                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_therm},
561        {ADM1026_SYSCTL_TEMP_THERM3, "temp3_therm", NULL, 0, 0644, NULL,
562                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_therm},
563
564        {ADM1026_SYSCTL_VID, "vid", NULL, 0, 0644, NULL, &i2c_proc_real,
565                &i2c_sysctl_real, NULL, &adm1026_vid},
566        {ADM1026_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
567                &i2c_sysctl_real, NULL, &adm1026_vrm},
568
569        {ADM1026_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
570                &i2c_sysctl_real, NULL, &adm1026_alarms},
571        {ADM1026_SYSCTL_ALARM_MASK, "alarm_mask", NULL, 0, 0644, NULL,
572                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_alarm_mask},
573
574        {ADM1026_SYSCTL_GPIO, "gpio", NULL, 0, 0644, NULL, &i2c_proc_real,
575                &i2c_sysctl_real, NULL, &adm1026_gpio},
576        {ADM1026_SYSCTL_GPIO_MASK, "gpio_mask", NULL, 0, 0644, NULL,
577                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_gpio_mask},
578
579        {ADM1026_SYSCTL_PWM, "pwm", NULL, 0, 0644, NULL, &i2c_proc_real,
580                &i2c_sysctl_real, NULL, &adm1026_pwm},
581        {ADM1026_SYSCTL_ANALOG_OUT, "analog_out", NULL, 0, 0644, NULL,
582                &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_analog_out},
583        {ADM1026_SYSCTL_AFC, "afc", NULL, 0, 0644, NULL, &i2c_proc_real,
584                &i2c_sysctl_real, NULL, &adm1026_afc},
585
586        {0}
587};
588#define CTLTBL_COMMON (sizeof(adm1026_common)/sizeof(adm1026_common[0]))
589
590#define MAX2(a,b) ((a)>(b)?(a):(b))
591#define MAX3(a,b,c) ((a)>(b)?MAX2((a),(c)):MAX2((b),(c)))
592#define MAX4(a,b,c,d) ((a)>(b)?MAX3((a),(c),(d)):MAX3((b),(c),(d)))
593
594#define CTLTBL_MAX (CTLTBL_COMMON)
595
596/* This function is called when:
597     * the module is loaded
598     * a new adapter is loaded
599 */
600static int adm1026_attach_adapter(struct i2c_adapter *adapter)
601{
602        return i2c_detect(adapter, &addr_data, adm1026_detect);
603}
604
605/* This function is called by i2c_detect */
606static int adm1026_detect(struct i2c_adapter *adapter, int address,
607                          unsigned short flags, int kind)
608{
609        int i;
610        int company, verstep ;
611        struct i2c_client *new_client;
612        struct adm1026_data *data;
613        int err = 0;
614        const char *type_name = "";
615        struct ctl_table template[CTLTBL_MAX] ;
616        struct ctl_table * template_next = template ;
617
618        if (i2c_is_isa_adapter(adapter)) {
619                /* This chip has no ISA interface */
620                goto ERROR0 ;
621        }
622
623        if (!i2c_check_functionality(adapter,
624                                        I2C_FUNC_SMBUS_BYTE_DATA)) {
625                /* We need to be able to do byte I/O */
626                goto ERROR0 ;
627        }
628
629        /* OK. For now, we presume we have a valid client. We now create the
630           client structure, even though we cannot fill it completely yet.
631           But it allows us to access adm1026_{read,write}_value. */
632
633        if (!(data = kmalloc(sizeof(struct adm1026_data), GFP_KERNEL))) {
634                err = -ENOMEM;
635                goto ERROR0;
636        }
637
638        new_client = &data->client;
639        new_client->addr = address;
640        new_client->data = data;
641        new_client->adapter = adapter;
642        new_client->driver = &adm1026_driver;
643        new_client->flags = 0;
644
645        /* Now, we do the remaining detection. */
646
647        company = adm1026_read_value(new_client, ADM1026_REG_COMPANY);
648        verstep = adm1026_read_value(new_client, ADM1026_REG_VERSTEP);
649
650#ifdef DEBUG
651        printk("adm1026: Detecting device at %d,0x%02x with"
652                " COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
653                i2c_adapter_id(new_client->adapter), new_client->addr,
654                company, verstep
655            );
656#endif
657
658        /* If auto-detecting, Determine the chip type. */
659        if (kind <= 0) {
660#ifdef DEBUG
661                printk("adm1026: Autodetecting device at %d,0x%02x ...\n",
662                        i2c_adapter_id(adapter), address );
663#endif
664                if( company == ADM1026_COMPANY_ANALOG_DEV
665                    && verstep == ADM1026_VERSTEP_ADM1026 ) {
666                        kind = adm1026 ;
667                } else if( company == ADM1026_COMPANY_ANALOG_DEV
668                    && (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC ) {
669                        printk("adm1026: Unrecognized stepping 0x%02x"
670                            " Defaulting to ADM1026.\n", verstep );
671                        kind = adm1026 ;
672                } else if( (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC ) {
673                        printk("adm1026: Found version/stepping 0x%02x"
674                            " Assuming generic ADM1026.\n", verstep );
675                        kind = any_chip ;
676                } else {
677#ifdef DEBUG
678                        printk("adm1026: Autodetection failed\n");
679#endif
680                        /* Not an ADM1026 ... */
681                        if( kind == 0 ) {  /* User used force=x,y */
682                            printk("adm1026: Generic ADM1026 Version 6 not"
683                                " found at %d,0x%02x. Try force_adm1026.\n",
684                                i2c_adapter_id(adapter), address );
685                        }
686                        goto ERROR1;
687                }
688        }
689
690        /* Fill in the chip specific driver values */
691        switch (kind) {
692        case any_chip :
693                type_name = "adm1026";
694                strcpy(new_client->name, "Generic ADM1026");
695                template_next = template ;  /* None used */
696                break ;
697        case adm1026 :
698                type_name = "adm1026";
699                strcpy(new_client->name, "Analog Devices ADM1026");
700                template_next = template ;
701                break ;
702#if 0
703        /* Example of another adm1026 "compatible" device */
704        case adx1000 :
705                type_name = "adx1000";
706                strcpy(new_client->name, "Compatible ADX1000");
707                memcpy( template, adx_specific, sizeof(adx_specific) );
708                template_next = template + CTLTBL_ADX1000 ;
709                break ;
710#endif
711        default :
712                printk("adm1026: Internal error, invalid kind (%d)!\n", kind);
713                err = -EFAULT ;
714                goto ERROR1;
715        }
716
717        /* Fill in the remaining client fields */
718        new_client->id = adm1026_id++;
719        printk("adm1026(%d): Assigning ID %d to %s at %d,0x%02x\n",
720                new_client->id, new_client->id, new_client->name,
721                i2c_adapter_id(new_client->adapter),
722                new_client->addr
723            );
724
725        /* Housekeeping values */
726        data->valid = 0;
727
728        /* Set the VRM version */
729        data->vrm = ADM1026_INIT_VRM ;
730        data->vid = ADM1026_INIT_VID ;
731
732        init_MUTEX(&data->update_lock);
733
734        /* Initialize the ADM1026 chip */
735        adm1026_init_client(new_client);
736
737        /* Tell the I2C layer a new client has arrived */
738        if ((err = i2c_attach_client(new_client)))
739                goto ERROR1;
740
741        /* Finish out the template */
742        memcpy(template_next, adm1026_common, sizeof(adm1026_common));
743
744        /* Register a new directory entry with module sensors */
745        if ((i = i2c_register_entry(new_client,
746                                        type_name,
747                                        template,
748                                        THIS_MODULE)) < 0) {
749                err = i;
750                goto ERROR2;
751        }
752        data->sysctl_id = i;
753
754        return 0;
755
756        /* Error out and cleanup code */
757    ERROR2:
758        i2c_detach_client(new_client);
759    ERROR1:
760        kfree(data);
761    ERROR0:
762        return err;
763}
764
765static int adm1026_detach_client(struct i2c_client *client)
766{
767        int err;
768        int id ;
769
770        id = client->id;
771        i2c_deregister_entry(((struct adm1026_data *)(client->data))->sysctl_id);
772
773        if ((err = i2c_detach_client(client))) {
774                printk("adm1026(%d): Client deregistration failed,"
775                        " client not detached.\n", id );
776                return err;
777        }
778
779        kfree(client->data);
780
781        return 0;
782}
783
784static int adm1026_read_value(struct i2c_client *client, u8 reg)
785{
786        int res;
787
788        if( reg < 0x80 ) {
789                /* "RAM" locations */
790                res = i2c_smbus_read_byte_data(client, reg) & 0xff ;
791        } else {
792                /* EEPROM, do nothing */
793                res = 0 ;
794        }
795
796        return res ;
797}
798
799static int adm1026_write_value(struct i2c_client *client, u8 reg, int value)
800{
801        int res ;
802
803        if( reg < 0x80 ) {
804                /* "RAM" locations */
805                res = i2c_smbus_write_byte_data(client, reg, value);
806        } else {
807                /* EEPROM, do nothing */
808                res = 0 ;
809        }
810
811        return res ;
812}
813
814/* Called when we have found a new ADM1026. */
815static void adm1026_init_client(struct i2c_client *client)
816{
817        int value ;
818        int i;
819        struct adm1026_data *data = client->data;
820
821#ifdef DEBUG
822        printk("adm1026(%d): Initializing device\n", client->id);
823#endif
824
825        /* Read chip config */
826        data->config1 = adm1026_read_value(client, ADM1026_REG_CONFIG1);
827        data->config2 = adm1026_read_value(client, ADM1026_REG_CONFIG2);
828        data->config3 = adm1026_read_value(client, ADM1026_REG_CONFIG3);
829
830        /* Inform user of chip config */
831#ifdef DEBUG
832        printk("adm1026(%d): ADM1026_REG_CONFIG1 is: 0x%02x\n",
833                client->id, data->config1 );
834#endif
835        if( (data->config1 & CFG1_MONITOR) == 0 ) {
836                printk("adm1026(%d): Monitoring not currently enabled.\n",
837                            client->id );
838        }
839        if( data->config1 & CFG1_INT_ENABLE ) {
840                printk("adm1026(%d): SMBALERT interrupts are enabled.\n",
841                            client->id );
842        }
843        if( data->config1 & CFG1_AIN8_9 ) {
844                printk("adm1026(%d): in8 and in9 enabled.  temp3 disabled.\n",
845                            client->id );
846        } else {
847                printk("adm1026(%d): temp3 enabled.  in8 and in9 disabled.\n",
848                            client->id );
849        }
850        if( data->config1 & CFG1_THERM_HOT ) {
851                printk("adm1026(%d): Automatic THERM, PWM, and temp limits enabled.\n",
852                            client->id );
853        }
854
855        if( data->config3 & CFG3_GPIO16_ENABLE ) {
856                printk("adm1026(%d): GPIO16 enabled.  THERM pin disabled.\n",
857                            client->id );
858        } else {
859                printk("adm1026(%d): THERM pin enabled.  GPIO16 disabled.\n",
860                            client->id );
861        }
862        if( data->config3 & CFG3_VREF_250 ) {
863                printk("adm1026(%d): Vref is 2.50 Volts.\n", client->id );
864        } else {
865                printk("adm1026(%d): Vref is 1.82 Volts.\n", client->id );
866        }
867
868        /* Read and pick apart the existing GPIO configuration */
869        value = 0 ;
870        for( i = 0 ; i <= 15 ; ++i ) {
871                if( (i & 0x03) == 0 ) {
872                        value = adm1026_read_value(client,
873                                        ADM1026_REG_GPIO_CFG_0_3 + i/4 );
874                }
875                data->gpio_config[i] = value & 0x03 ;
876                value >>= 2 ;
877        }
878        data->gpio_config[16] = (data->config3 >> 6) & 0x03 ;
879
880        /* ... and then print it */
881        adm1026_print_gpio(client);
882
883        /* If the user asks us to reprogram the GPIO config, then
884         *   do it now.  But only if this is the first ADM1026.
885         */
886        if( client->id == 0
887            && (gpio_input[0] != -1 || gpio_output[0] != -1
888                || gpio_inverted[0] != -1 || gpio_normal[0] != -1
889                || gpio_fan[0] != -1 ) ) {
890                adm1026_fixup_gpio(client);
891        }
892
893        /* WE INTENTIONALLY make no changes to the limits,
894         *   offsets, pwms and fans.  If they were
895         *   configured, we don't want to mess with them.
896         *   If they weren't, the default is generally safe
897         *   and will suffice until 'sensors -s' can be run.
898         */
899
900        /* Start monitoring */
901        value = adm1026_read_value(client, ADM1026_REG_CONFIG1);
902
903        /* Set MONITOR, clear interrupt acknowledge and s/w reset */
904        value = (value | CFG1_MONITOR) & (~CFG1_INT_CLEAR & ~CFG1_RESET) ;
905#ifdef DEBUG
906        printk("adm1026(%d): Setting CONFIG to: 0x%02x\n", client->id, value );
907#endif
908        data->config1 = value ;
909        adm1026_write_value(client, ADM1026_REG_CONFIG1, value);
910
911}
912
913static void adm1026_print_gpio(struct i2c_client *client)
914{
915        struct adm1026_data *data = client->data;
916        int  i ;
917
918        printk("adm1026(%d): GPIO config is:\nadm1026(%d):",
919                            client->id, client->id );
920        for( i = 0 ; i <= 7 ; ++i ) {
921                if( data->config2 & (1 << i) ) {
922                        printk( " %sGP%s%d",
923                                data->gpio_config[i] & 0x02 ? "" : "!",
924                                data->gpio_config[i] & 0x01 ? "OUT" : "IN",
925                                i );
926                } else {
927                        printk( " FAN%d", i );
928                }
929        }
930        printk( "\nadm1026(%d):", client->id );
931        for( i = 8 ; i <= 15 ; ++i ) {
932                printk( " %sGP%s%d",
933                        data->gpio_config[i] & 0x02 ? "" : "!",
934                        data->gpio_config[i] & 0x01 ? "OUT" : "IN",
935                        i );
936        }
937        if( data->config3 & CFG3_GPIO16_ENABLE ) {
938                printk( " %sGP%s16\n",
939                        data->gpio_config[16] & 0x02 ? "" : "!",
940                        data->gpio_config[16] & 0x01 ? "OUT" : "IN" );
941        } else {
942                /* GPIO16 is THERM */
943                printk( " THERM\n" );
944        }
945}
946
947static void adm1026_fixup_gpio(struct i2c_client *client)
948{
949        struct adm1026_data *data = client->data;
950        int  i ;
951        int  value ;
952
953        /* Make the changes requested. */
954        /* We may need to unlock/stop monitoring or soft-reset the
955         *    chip before we can make changes.  This hasn't been
956         *    tested much.  FIXME
957         */
958
959        /* Make outputs */
960        for( i = 0 ; i <= 16 ; ++i ) {
961                if( gpio_output[i] >= 0 && gpio_output[i] <= 16 ) {
962                        data->gpio_config[gpio_output[i]] |= 0x01 ;
963                }
964                /* if GPIO0-7 is output, it isn't a FAN tach */
965                if( gpio_output[i] >= 0 && gpio_output[i] <= 7 ) {
966                        data->config2 |= 1 << gpio_output[i] ;
967                }
968        }
969
970        /* Input overrides output */
971        for( i = 0 ; i <= 16 ; ++i ) {
972                if( gpio_input[i] >= 0 && gpio_input[i] <= 16 ) {
973                        data->gpio_config[gpio_input[i]] &= ~ 0x01 ;
974                }
975                /* if GPIO0-7 is input, it isn't a FAN tach */
976                if( gpio_input[i] >= 0 && gpio_input[i] <= 7 ) {
977                        data->config2 |= 1 << gpio_input[i] ;
978                }
979        }
980
981        /* Inverted  */
982        for( i = 0 ; i <= 16 ; ++i ) {
983                if( gpio_inverted[i] >= 0 && gpio_inverted[i] <= 16 ) {
984                        data->gpio_config[gpio_inverted[i]] &= ~ 0x02 ;
985                }
986        }
987
988        /* Normal overrides inverted  */
989        for( i = 0 ; i <= 16 ; ++i ) {
990                if( gpio_normal[i] >= 0 && gpio_normal[i] <= 16 ) {
991                        data->gpio_config[gpio_normal[i]] |= 0x02 ;
992                }
993        }
994
995        /* Fan overrides input and output */
996        for( i = 0 ; i <= 7 ; ++i ) {
997                if( gpio_fan[i] >= 0 && gpio_fan[i] <= 7 ) {
998                        data->config2 &= ~( 1 << gpio_fan[i] );
999                }
1000        }
1001
1002        /* Write new configs to registers */
1003        adm1026_write_value(client, ADM1026_REG_CONFIG2, data->config2);
1004        data->config3 = (data->config3 & 0x3f)
1005                        | ((data->gpio_config[16] & 0x03) << 6) ;
1006        adm1026_write_value(client, ADM1026_REG_CONFIG3, data->config3);
1007        for( i = 15, value = 0 ; i >= 0 ; --i ) {
1008                value <<= 2 ;
1009                value |= data->gpio_config[i] & 0x03 ;
1010                if( (i & 0x03) == 0 ) {
1011                        adm1026_write_value(client,
1012                                        ADM1026_REG_GPIO_CFG_0_3 + i/4,
1013                                        value );
1014                        value = 0 ;
1015                }
1016        }
1017
1018        /* Print the new config */
1019        adm1026_print_gpio(client);
1020}
1021
1022static void adm1026_update_client(struct i2c_client *client)
1023{
1024        struct adm1026_data *data = client->data;
1025        int i;
1026        long value, alarms, gpio ;
1027
1028        down(&data->update_lock);
1029
1030        if (!data->valid
1031            || (jiffies - data->last_reading > ADM1026_DATA_INTERVAL )) {
1032                /* Things that change quickly */
1033
1034#ifdef DEBUG
1035                printk("adm1026(%d): Reading sensor values\n", client->id);
1036#endif
1037                for (i = 0 ; i <= 16 ; ++i) {
1038                        data->in[i] =
1039                            adm1026_read_value(client, ADM1026_REG_IN(i));
1040                }
1041
1042                for (i = 0 ; i <= 7 ; ++i) {
1043                        data->fan[i] =
1044                            adm1026_read_value(client, ADM1026_REG_FAN(i));
1045                }
1046
1047                for (i = 0 ; i <= 2 ; ++i) {
1048                        /* NOTE: temp[] is s8 and we assume 2's complement
1049                         *   "conversion" in the assignment   */
1050                        data->temp[i] =
1051                            adm1026_read_value(client, ADM1026_REG_TEMP(i));
1052                }
1053
1054                data->pwm = adm1026_read_value(client, ADM1026_REG_PWM);
1055                data->analog_out = adm1026_read_value(client, ADM1026_REG_DAC);
1056
1057                /* GPIO16 is MSbit of alarms, move it to gpio */
1058                alarms  = adm1026_read_value(client, ADM1026_REG_STATUS4);
1059                gpio = alarms & 0x80 ? 0x0100 : 0 ;  /* GPIO16 */
1060                alarms &= 0x7f ;
1061                alarms <<= 8 ;
1062                alarms |= adm1026_read_value(client, ADM1026_REG_STATUS3);
1063                alarms <<= 8 ;
1064                alarms |= adm1026_read_value(client, ADM1026_REG_STATUS2);
1065                alarms <<= 8 ;
1066                alarms |= adm1026_read_value(client, ADM1026_REG_STATUS1);
1067                data->alarms = alarms ;
1068
1069                /* Read the GPIO values */
1070                gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_STATUS_8_15);
1071                gpio <<= 8 ;
1072                gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_STATUS_0_7);
1073                data->gpio = gpio ;
1074
1075                data->last_reading = jiffies ;
1076        };  /* last_reading */
1077
1078        if (!data->valid
1079            || (jiffies - data->last_config > ADM1026_CONFIG_INTERVAL) ) {
1080                /* Things that don't change often */
1081
1082#ifdef DEBUG
1083                printk("adm1026(%d): Reading config values\n", client->id);
1084#endif
1085                for (i = 0 ; i <= 16 ; ++i) {
1086                        data->in_min[i] =
1087                            adm1026_read_value(client, ADM1026_REG_IN_MIN(i));
1088                        data->in_max[i] =
1089                            adm1026_read_value(client, ADM1026_REG_IN_MAX(i));
1090                }
1091
1092                value = adm1026_read_value(client, ADM1026_REG_FAN_DIV_0_3)
1093                        | (adm1026_read_value(client, ADM1026_REG_FAN_DIV_4_7) << 8);
1094                for (i = 0 ; i <= 7 ; ++i) {
1095                        data->fan_min[i] =
1096                            adm1026_read_value(client, ADM1026_REG_FAN_MIN(i));
1097                        data->fan_div[i] = DIV_FROM_REG(value & 0x03);
1098                        value >>= 2 ;
1099                }
1100
1101                for (i = 0; i <= 2; ++i) {
1102                        /* NOTE: temp_xxx[] are s8 and we assume 2's complement
1103                         *   "conversion" in the assignment   */
1104                        data->temp_min[i] =
1105                            adm1026_read_value(client, ADM1026_REG_TEMP_MIN(i));
1106                        data->temp_max[i] =
1107                            adm1026_read_value(client, ADM1026_REG_TEMP_MAX(i));
1108                        data->temp_tmin[i] =
1109                            adm1026_read_value(client, ADM1026_REG_TEMP_TMIN(i));
1110                        data->temp_therm[i] =
1111                            adm1026_read_value(client, ADM1026_REG_TEMP_THERM(i));
1112                        data->temp_offset[i] =
1113                            adm1026_read_value(client, ADM1026_REG_TEMP_OFFSET(i));
1114                }
1115
1116                /* Read the STATUS/alarm masks */
1117                alarms  = adm1026_read_value(client, ADM1026_REG_MASK4);
1118                gpio    = alarms & 0x80 ? 0x0100 : 0 ;  /* GPIO16 */
1119                alarms  = (alarms & 0x7f) << 8 ;
1120                alarms |= adm1026_read_value(client, ADM1026_REG_MASK3);
1121                alarms <<= 8 ;
1122                alarms |= adm1026_read_value(client, ADM1026_REG_MASK2);
1123                alarms <<= 8 ;
1124                alarms |= adm1026_read_value(client, ADM1026_REG_MASK1);
1125                data->alarm_mask = alarms ;
1126
1127                /* Read the GPIO values */
1128                gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_MASK_8_15);
1129                gpio <<= 8 ;
1130                gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_MASK_0_7);
1131                data->gpio_mask = gpio ;
1132
1133                /* Read the GPIO config */
1134                data->config2 = adm1026_read_value(client, ADM1026_REG_CONFIG2);
1135                data->config3 = adm1026_read_value(client, ADM1026_REG_CONFIG3);
1136                data->gpio_config[16] = (data->config3 >> 6) & 0x03 ;
1137
1138                value = 0 ;
1139                for( i = 0 ; i <= 15 ; ++i ) {
1140                        if( (i & 0x03) == 0 ) {
1141                                value = adm1026_read_value(client,
1142                                            ADM1026_REG_GPIO_CFG_0_3 + i/4 );
1143                        }
1144                        data->gpio_config[i] = value & 0x03 ;
1145                        value >>= 2 ;
1146                }
1147
1148                data->last_config = jiffies;
1149        };  /* last_config */
1150
1151        /* We don't know where or even _if_ the VID might be on the GPIO
1152         *    pins.  But the datasheet gives an example config showing
1153         *    GPIO11-15 being used to monitor VID0-4, so we go with that
1154         *    but make the vid WRITEABLE so if it's wrong, the user can
1155         *    set it in /etc/sensors.conf perhaps using an expression or
1156         *    0 to trigger a re-read from the GPIO pins.
1157         */
1158        if( data->vid == ADM1026_INIT_VID ) {
1159                /* Hasn't been set yet, make a bold assumption */
1160                printk("adm1026(%d): Setting VID from GPIO11-15.\n",
1161                            client->id );
1162                data->vid = (data->gpio >> 11) & 0x1f ;
1163        }
1164       
1165        data->valid = 1;
1166
1167        up(&data->update_lock);
1168}
1169
1170
1171/* The following functions are the call-back functions of the /proc/sys and
1172   sysctl files.  The appropriate function is referenced in the ctl_table
1173   extra1 field.
1174
1175   Each function must return the magnitude (power of 10 to divide the
1176   data with) if it is called with operation set to SENSORS_PROC_REAL_INFO.
1177   It must put a maximum of *nrels elements in results reflecting the
1178   data of this file, and set *nrels to the number it actually put in
1179   it, if operation is SENSORS_PROC_REAL_READ.  Finally, it must get
1180   up to *nrels elements from results and write them to the chip, if
1181   operations is SENSORS_PROC_REAL_WRITE.
1182 */
1183void adm1026_in(struct i2c_client *client, int operation, int ctl_name,
1184             int *nrels_mag, long *results)
1185{
1186        struct adm1026_data *data = client->data;
1187        int nr = ctl_name - ADM1026_SYSCTL_IN0;
1188
1189        /* We handle in0 - in15 here.  in16 (-12V) is handled below */
1190        if (nr < 0 || nr > 15)
1191                return ;  /* ERROR */
1192
1193        if (operation == SENSORS_PROC_REAL_INFO)
1194                *nrels_mag = 3;  /* 1.000 */
1195        else if (operation == SENSORS_PROC_REAL_READ) {
1196                adm1026_update_client(client);
1197                results[0] = INS_FROM_REG(nr,data->in_min[nr]);
1198                results[1] = INS_FROM_REG(nr,data->in_max[nr]);
1199                results[2] = INS_FROM_REG(nr,data->in[nr]);
1200                *nrels_mag = 3;
1201        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1202                down(&data->update_lock);
1203                if (*nrels_mag > 1) {
1204                        data->in_max[nr] = INS_TO_REG(nr,results[1]);
1205                        adm1026_write_value(client, ADM1026_REG_IN_MAX(nr),
1206                                         data->in_max[nr]);
1207                }
1208                if (*nrels_mag > 0) {
1209                        data->in_min[nr] = INS_TO_REG(nr,results[0]);
1210                        adm1026_write_value(client, ADM1026_REG_IN_MIN(nr),
1211                                         data->in_min[nr]);
1212                }
1213                up(&data->update_lock);
1214        }
1215}
1216
1217void adm1026_in16(struct i2c_client *client, int operation, int ctl_name,
1218             int *nrels_mag, long *results)
1219{
1220        struct adm1026_data *data = client->data;
1221        int nr = ctl_name - ADM1026_SYSCTL_IN0;
1222
1223        /* We handle in16 (-12V) here */
1224        if (nr != 16)
1225                return ;  /* ERROR */
1226
1227        /* Apply offset and swap min/max so that min is 90% of
1228         *    target and max is 110% of target.
1229         */
1230
1231        if (operation == SENSORS_PROC_REAL_INFO)
1232                *nrels_mag = 3;  /* 1.000 */
1233        else if (operation == SENSORS_PROC_REAL_READ) {
1234                adm1026_update_client(client);
1235                results[0] = INS_FROM_REG(nr,data->in_max[nr])-NEG12_OFFSET ;
1236                results[1] = INS_FROM_REG(nr,data->in_min[nr])-NEG12_OFFSET ;
1237                results[2] = INS_FROM_REG(nr,data->in[nr])-NEG12_OFFSET ;
1238                *nrels_mag = 3;
1239        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1240                down(&data->update_lock);
1241                if (*nrels_mag > 1) {
1242                        data->in_min[nr] = INS_TO_REG(nr,results[1]+NEG12_OFFSET);
1243                        adm1026_write_value(client, ADM1026_REG_IN_MIN(nr),
1244                                         data->in_min[nr]);
1245                }
1246                if (*nrels_mag > 0) {
1247                        data->in_max[nr] = INS_TO_REG(nr,results[0]+NEG12_OFFSET);
1248                        adm1026_write_value(client, ADM1026_REG_IN_MAX(nr),
1249                                         data->in_max[nr]);
1250                }
1251                up(&data->update_lock);
1252        }
1253}
1254
1255void adm1026_fan(struct i2c_client *client, int operation, int ctl_name,
1256              int *nrels_mag, long *results)
1257{
1258        struct adm1026_data *data = client->data;
1259        int nr = ctl_name - ADM1026_SYSCTL_FAN0 ;
1260
1261        if (nr < 0 || nr > 7)
1262                return ;  /* ERROR */
1263
1264        if (operation == SENSORS_PROC_REAL_INFO)
1265                *nrels_mag = 0;
1266        else if (operation == SENSORS_PROC_REAL_READ) {
1267                adm1026_update_client(client);
1268                results[0] = FAN_FROM_REG(data->fan_min[nr], data->fan_div[nr]);
1269                results[1] = FAN_FROM_REG(data->fan[nr], data->fan_div[nr]);
1270                *nrels_mag = 2;
1271        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1272                down(&data->update_lock);
1273                if (*nrels_mag > 0) {
1274                        data->fan_min[nr] = FAN_TO_REG(results[0],
1275                                                        data->fan_div[nr]);
1276                        adm1026_write_value(client, ADM1026_REG_FAN_MIN(nr),
1277                                         data->fan_min[nr]);
1278                }
1279                up(&data->update_lock);
1280        }
1281}
1282
1283/* Adjust fan_min to account for new fan divisor */
1284void adm1026_fixup_fan_min(struct i2c_client *client, int fan, int old_div)
1285{
1286        struct adm1026_data *data = client->data;
1287        int  new_div = data->fan_div[fan] ;
1288        int  new_min;
1289
1290        /* 0 and 0xff are special.  Don't adjust them */
1291        if( data->fan_min[fan] == 0 || data->fan_min[fan] == 0xff ) {
1292                return ;
1293        }
1294
1295        new_min = data->fan_min[fan] * old_div / new_div ;
1296        new_min = SENSORS_LIMIT(new_min, 1, 254);
1297        data->fan_min[fan] = new_min ;
1298        adm1026_write_value(client, ADM1026_REG_FAN_MIN(fan), new_min);
1299}
1300
1301void adm1026_fan_div(struct i2c_client *client, int operation, int ctl_name,
1302                int *nrels_mag, long *results)
1303{
1304        struct adm1026_data *data = client->data;
1305        int i ;
1306        int value, div, old ;
1307
1308        if (ctl_name != ADM1026_SYSCTL_FAN_DIV)
1309                return ;  /* ERROR */
1310
1311        if (operation == SENSORS_PROC_REAL_INFO)
1312                *nrels_mag = 0;
1313        else if (operation == SENSORS_PROC_REAL_READ) {
1314                adm1026_update_client(client);
1315                for( i = 0 ; i <= 7 ; ++i ) {
1316                        results[i] = data->fan_div[i] ;
1317                }
1318                *nrels_mag = 8;
1319        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1320                down(&data->update_lock);
1321                value = 0 ;
1322                for( i = 7 ; i >= 0 ; --i ) {
1323                        value <<= 2 ;
1324                        if (*nrels_mag > i) {
1325                                old = data->fan_div[i] ;
1326                                div = DIV_TO_REG(results[i]) ;
1327                                data->fan_div[i] = DIV_FROM_REG(div) ;
1328                                if( data->fan_div[i] != old ) {
1329                                        adm1026_fixup_fan_min(client,i,old);
1330                                }
1331                        } else {
1332                                div = DIV_TO_REG(data->fan_div[i]) ;
1333                        }
1334                        value |= div ;
1335                }
1336                adm1026_write_value(client, ADM1026_REG_FAN_DIV_0_3,
1337                        value & 0xff);
1338                adm1026_write_value(client, ADM1026_REG_FAN_DIV_4_7,
1339                        (value >> 8) & 0xff);
1340                up(&data->update_lock);
1341        }
1342}
1343
1344void adm1026_temp(struct i2c_client *client, int operation, int ctl_name,
1345               int *nrels_mag, long *results)
1346{
1347        struct adm1026_data *data = client->data;
1348        int nr = ctl_name - ADM1026_SYSCTL_TEMP1 ;
1349
1350        if (nr < 0 || nr > 2)
1351                return ;  /* ERROR */
1352
1353        if (operation == SENSORS_PROC_REAL_INFO)
1354                *nrels_mag = 0;
1355        else if (operation == SENSORS_PROC_REAL_READ) {
1356                adm1026_update_client(client);
1357                results[0] = TEMP_FROM_REG(data->temp_min[nr]);
1358                results[1] = TEMP_FROM_REG(data->temp_max[nr]);
1359                results[2] = TEMP_FROM_REG(data->temp[nr]);
1360                *nrels_mag = 3;
1361        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1362                down(&data->update_lock);
1363                if (*nrels_mag > 1) {
1364                        data->temp_max[nr] = TEMP_TO_REG(results[1]);
1365                        adm1026_write_value(client, ADM1026_REG_TEMP_MAX(nr),
1366                                         data->temp_max[nr]);
1367                }
1368                if (*nrels_mag > 0) {
1369                        data->temp_min[nr] = TEMP_TO_REG(results[0]);
1370                        adm1026_write_value(client, ADM1026_REG_TEMP_MIN(nr),
1371                                         data->temp_min[nr]);
1372                }
1373                up(&data->update_lock);
1374        }
1375}
1376
1377void adm1026_temp_offset(struct i2c_client *client, int operation, int ctl_name,
1378                int *nrels_mag, long *results)
1379{
1380        struct adm1026_data *data = client->data;
1381        int nr = ctl_name - ADM1026_SYSCTL_TEMP_OFFSET1 ;
1382
1383        if (nr < 0 || nr > 2)
1384                return ;  /* ERROR */
1385
1386        if (operation == SENSORS_PROC_REAL_INFO)
1387                *nrels_mag = 0;
1388        else if (operation == SENSORS_PROC_REAL_READ) {
1389                adm1026_update_client(client);
1390                results[0] = TEMP_FROM_REG(data->temp_offset[nr]);
1391                *nrels_mag = 1;
1392        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1393                down(&data->update_lock);
1394                if (*nrels_mag > 0) {
1395                        data->temp_offset[nr] = TEMP_TO_REG(results[0]);
1396                        adm1026_write_value(client, ADM1026_REG_TEMP_OFFSET(nr),
1397                            data->temp_offset[nr]);
1398                }
1399                up(&data->update_lock);
1400        }
1401}
1402
1403void adm1026_temp_tmin(struct i2c_client *client, int operation, int ctl_name,
1404                int *nrels_mag, long *results)
1405{
1406        struct adm1026_data *data = client->data;
1407        int nr = ctl_name - ADM1026_SYSCTL_TEMP_TMIN1 ;
1408
1409        if (nr < 0 || nr > 2)
1410                return ;  /* ERROR */
1411
1412        if (operation == SENSORS_PROC_REAL_INFO)
1413                *nrels_mag = 0;
1414        else if (operation == SENSORS_PROC_REAL_READ) {
1415                adm1026_update_client(client);
1416                results[0] = TEMP_FROM_REG(data->temp_tmin[nr]);
1417                *nrels_mag = 1;
1418        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1419                down(&data->update_lock);
1420                if (*nrels_mag > 0) {
1421                        data->temp_tmin[nr] = TEMP_TO_REG(results[0]);
1422                        adm1026_write_value(client, ADM1026_REG_TEMP_TMIN(nr),
1423                            data->temp_tmin[nr]);
1424                }
1425                up(&data->update_lock);
1426        }
1427}
1428
1429void adm1026_temp_therm(struct i2c_client *client, int operation, int ctl_name,
1430                int *nrels_mag, long *results)
1431{
1432        struct adm1026_data *data = client->data;
1433        int nr = ctl_name - ADM1026_SYSCTL_TEMP_THERM1 ;
1434
1435        if (nr < 0 || nr > 2)
1436                return ;  /* ERROR */
1437
1438        if (operation == SENSORS_PROC_REAL_INFO)
1439                *nrels_mag = 0;
1440        else if (operation == SENSORS_PROC_REAL_READ) {
1441                adm1026_update_client(client);
1442                results[0] = TEMP_FROM_REG(data->temp_therm[nr]);
1443                *nrels_mag = 1;
1444        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1445                down(&data->update_lock);
1446                if (*nrels_mag > 0) {
1447                        data->temp_therm[nr] = TEMP_TO_REG(results[0]);
1448                        adm1026_write_value(client, ADM1026_REG_TEMP_THERM(nr),
1449                            data->temp_therm[nr]);
1450                }
1451                up(&data->update_lock);
1452        }
1453}
1454
1455void adm1026_pwm(struct i2c_client *client, int operation, int ctl_name,
1456              int *nrels_mag, long *results)
1457{
1458        struct adm1026_data *data = client->data;
1459
1460        if (ctl_name != ADM1026_SYSCTL_PWM)
1461                return ;  /* ERROR */
1462
1463        if (operation == SENSORS_PROC_REAL_INFO)
1464                *nrels_mag = 0;
1465        else if (operation == SENSORS_PROC_REAL_READ) {
1466                adm1026_update_client(client);
1467                results[0] = PWM_FROM_REG(data->pwm);
1468                results[1] = 1 ;  /* Always enabled */
1469                *nrels_mag = 2;
1470        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1471                down(&data->update_lock);
1472                /* PWM enable is read-only */
1473                if (*nrels_mag > 0) {
1474                        data->pwm = PWM_TO_REG(results[0]);
1475                        adm1026_write_value(client, ADM1026_REG_PWM,
1476                                         data->pwm);
1477                }
1478                up(&data->update_lock);
1479        }
1480}
1481
1482void adm1026_analog_out(struct i2c_client *client, int operation, int ctl_name,
1483              int *nrels_mag, long *results)
1484{
1485        struct adm1026_data *data = client->data;
1486
1487        if (ctl_name != ADM1026_SYSCTL_ANALOG_OUT)
1488                return ;  /* ERROR */
1489
1490        if (operation == SENSORS_PROC_REAL_INFO)
1491                *nrels_mag = 0;  /* 0 - 255 */
1492        else if (operation == SENSORS_PROC_REAL_READ) {
1493                adm1026_update_client(client);
1494                results[0] = DAC_FROM_REG(data->analog_out);
1495                *nrels_mag = 1;
1496        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1497                down(&data->update_lock);
1498                if (*nrels_mag > 0) {
1499                        data->analog_out = DAC_TO_REG(results[0]);
1500                        adm1026_write_value(client, ADM1026_REG_DAC,
1501                                         data->analog_out);
1502                }
1503                up(&data->update_lock);
1504        }
1505}
1506
1507void adm1026_afc(struct i2c_client *client, int operation, int ctl_name,
1508              int *nrels_mag, long *results)
1509{
1510        struct adm1026_data *data = client->data;
1511
1512        if (ctl_name != ADM1026_SYSCTL_AFC)
1513                return ;  /* ERROR */
1514
1515        /* PWM auto fan control, DAC auto fan control */
1516
1517        if (operation == SENSORS_PROC_REAL_INFO)
1518                *nrels_mag = 0;
1519        else if (operation == SENSORS_PROC_REAL_READ) {
1520                adm1026_update_client(client);
1521                results[0] = (data->config1 & CFG1_PWM_AFC) != 0 ;
1522                results[1] = (data->config1 & CFG1_DAC_AFC) != 0 ;
1523                *nrels_mag = 2;
1524        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1525                down(&data->update_lock);
1526                if (*nrels_mag > 1) {
1527                        data->config1 = (data->config1 & ~CFG1_DAC_AFC)
1528                                | (results[1] ? CFG1_DAC_AFC : 0) ;
1529                }
1530                if (*nrels_mag > 0) {
1531                        data->config1 = (data->config1 & ~CFG1_PWM_AFC)
1532                                | (results[0] ? CFG1_PWM_AFC : 0) ;
1533                        adm1026_write_value(client, ADM1026_REG_CONFIG1,
1534                                         data->config1);
1535                }
1536                up(&data->update_lock);
1537        }
1538}
1539
1540void adm1026_vid(struct i2c_client *client, int operation, int ctl_name,
1541              int *nrels_mag, long *results)
1542{
1543        struct adm1026_data *data = client->data;
1544
1545        if( ctl_name != ADM1026_SYSCTL_VID )
1546                return ;  /* ERROR */
1547
1548        if (operation == SENSORS_PROC_REAL_INFO)
1549                *nrels_mag = 3;
1550        else if (operation == SENSORS_PROC_REAL_READ) {
1551                adm1026_update_client(client);
1552                results[0] = vid_from_reg((data->vid)&0x3f,data->vrm);
1553                *nrels_mag = 1;
1554        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1555                down(&data->update_lock);
1556                /* Hmmm... There isn't a VID_TO_REG mapping */
1557                if (*nrels_mag > 0) {
1558                        if( results[0] >= 0 ) {
1559                                data->vid = results[0] & 0x3f ;
1560                        } else {
1561                                data->vid = ADM1026_INIT_VID ;
1562                        }
1563                }
1564                up(&data->update_lock);
1565        }
1566
1567}
1568
1569void adm1026_vrm(struct i2c_client *client, int operation, int ctl_name,
1570              int *nrels_mag, long *results)
1571{
1572        struct adm1026_data *data = client->data;
1573
1574        if( ctl_name != ADM1026_SYSCTL_VRM )
1575                return ;  /* ERROR */
1576
1577        if (operation == SENSORS_PROC_REAL_INFO)
1578                *nrels_mag = 1;
1579        else if (operation == SENSORS_PROC_REAL_READ) {
1580                results[0] = data->vrm ;
1581                *nrels_mag = 1;
1582        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1583                if (*nrels_mag > 0) {
1584                        data->vrm = results[0] ;
1585                }
1586        }
1587}
1588
1589void adm1026_alarms(struct i2c_client *client, int operation, int ctl_name,
1590                int *nrels_mag, long *results)
1591{
1592        struct adm1026_data *data = client->data;
1593
1594        if( ctl_name != ADM1026_SYSCTL_ALARMS )
1595                return ;  /* ERROR */
1596
1597        if (operation == SENSORS_PROC_REAL_INFO)
1598                *nrels_mag = 0;
1599        else if (operation == SENSORS_PROC_REAL_READ) {
1600                adm1026_update_client(client);
1601                results[0] = data->alarms ;
1602                *nrels_mag = 1;
1603        }
1604        /* FIXME: Perhaps we should implement a write function
1605         *   to clear an alarm?
1606         */
1607}
1608
1609void adm1026_alarm_mask(struct i2c_client *client, int operation,
1610                int ctl_name, int *nrels_mag, long *results)
1611{
1612        struct adm1026_data *data = client->data;
1613        unsigned long mask ;
1614
1615        if( ctl_name != ADM1026_SYSCTL_ALARM_MASK )
1616                return ;  /* ERROR */
1617
1618        if (operation == SENSORS_PROC_REAL_INFO)
1619                *nrels_mag = 0;
1620        else if (operation == SENSORS_PROC_REAL_READ) {
1621                adm1026_update_client(client);
1622                results[0] = data->alarm_mask ;
1623                *nrels_mag = 1;
1624        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1625                down(&data->update_lock);
1626                if (*nrels_mag > 0) {
1627                        data->alarm_mask = results[0] & 0x7fffffff ;
1628                        mask = data->alarm_mask
1629                                | (data->gpio_mask & 0x10000 ? 0x80000000 : 0) ;
1630                        adm1026_write_value(client, ADM1026_REG_MASK1,
1631                                        mask & 0xff);
1632                        mask >>= 8 ;
1633                        adm1026_write_value(client, ADM1026_REG_MASK2,
1634                                        mask & 0xff);
1635                        mask >>= 8 ;
1636                        adm1026_write_value(client, ADM1026_REG_MASK3,
1637                                        mask & 0xff);
1638                        mask >>= 8 ;
1639                        adm1026_write_value(client, ADM1026_REG_MASK4,
1640                                        mask & 0xff);
1641                }
1642                up(&data->update_lock);
1643        }
1644}
1645
1646void adm1026_gpio(struct i2c_client *client, int operation, int ctl_name,
1647                int *nrels_mag, long *results)
1648{
1649        struct adm1026_data *data = client->data;
1650        long gpio ;
1651
1652        if( ctl_name != ADM1026_SYSCTL_GPIO )
1653                return ;  /* ERROR */
1654
1655        if (operation == SENSORS_PROC_REAL_INFO)
1656                *nrels_mag = 0;
1657        else if (operation == SENSORS_PROC_REAL_READ) {
1658                adm1026_update_client(client);
1659                results[0] = data->gpio ;
1660                *nrels_mag = 1;
1661        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1662                down(&data->update_lock);
1663                if (*nrels_mag > 0) {
1664                        data->gpio = results[0] & 0x1ffff ;
1665                        gpio = data->gpio ;
1666                        adm1026_write_value(client,
1667                                ADM1026_REG_GPIO_STATUS_0_7,
1668                                gpio & 0xff );
1669                        gpio >>= 8 ;
1670                        adm1026_write_value(client,
1671                                ADM1026_REG_GPIO_STATUS_8_15,
1672                                gpio & 0xff );
1673                        gpio = ((gpio >> 1) & 0x80)
1674                                | (data->alarms >> 24 & 0x7f);
1675                        adm1026_write_value(client,
1676                                ADM1026_REG_STATUS4,
1677                                gpio & 0xff );
1678                }
1679                up(&data->update_lock);
1680        }
1681}
1682
1683void adm1026_gpio_mask(struct i2c_client *client, int operation,
1684                int ctl_name, int *nrels_mag, long *results)
1685{
1686        struct adm1026_data *data = client->data;
1687        long mask ;
1688
1689        if( ctl_name != ADM1026_SYSCTL_GPIO_MASK )
1690                return ;  /* ERROR */
1691
1692        if (operation == SENSORS_PROC_REAL_INFO)
1693                *nrels_mag = 0;
1694        else if (operation == SENSORS_PROC_REAL_READ) {
1695                adm1026_update_client(client);
1696                results[0] = data->gpio_mask ;
1697                *nrels_mag = 1;
1698        } else if (operation == SENSORS_PROC_REAL_WRITE) {
1699                down(&data->update_lock);
1700                if (*nrels_mag > 0) {
1701                        data->gpio_mask = results[0] & 0x1ffff ;
1702                        mask = data->gpio_mask ;
1703                        adm1026_write_value(client, ADM1026_REG_GPIO_MASK_0_7,
1704                                        mask & 0xff);
1705                        mask >>= 8 ;
1706                        adm1026_write_value(client, ADM1026_REG_GPIO_MASK_8_15,
1707                                        mask & 0xff);
1708                        mask = ((mask >> 1) & 0x80)
1709                                | (data->alarm_mask >> 24 & 0x7f);
1710                        adm1026_write_value(client, ADM1026_REG_MASK1,
1711                                        mask & 0xff);
1712                }
1713                up(&data->update_lock);
1714        }
1715}
1716
1717static int __init sm_adm1026_init(void)
1718{
1719        printk("adm1026: Version %s (%s)\n", LM_VERSION, LM_DATE);
1720        return i2c_add_driver(&adm1026_driver);
1721}
1722
1723static void __exit sm_adm1026_exit(void)
1724{
1725        i2c_del_driver(&adm1026_driver);
1726}
1727
1728MODULE_LICENSE("GPL");
1729MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com");
1730MODULE_DESCRIPTION("ADM1026 driver");
1731
1732module_init(sm_adm1026_init);
1733module_exit(sm_adm1026_exit);
Note: See TracBrowser for help on using the browser.