projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
hwmon: (lm85) Export in5, in6 and in7 voltage channels
[deliverable/linux.git] / drivers / hwmon / lm85.c
CommitLineData
1da177e4
LT		 1/*
2 lm85.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
5 Copyright (c) 2002, 2003 Philip Pokorny <ppokorny@penguincomputing.com>
6 Copyright (c) 2003 Margit Schubert-While <margitsw@t-online.de>
7 Copyright (c) 2004 Justin Thiessen <jthiessen@penguincomputing.com>
8
9 Chip details at <http://www.national.com/ds/LM/LM85.pdf>
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24*/
25
1da177e4
LT		 26#include <linux/module.h>
27#include <linux/init.h>
28#include <linux/slab.h>
29#include <linux/jiffies.h>
30#include <linux/i2c.h>
943b0830 31#include <linux/hwmon.h>
303760b4 32#include <linux/hwmon-vid.h>
b353a487 33#include <linux/hwmon-sysfs.h>
943b0830 34#include <linux/err.h>
9a61bf63 35#include <linux/mutex.h>
1da177e4
LT		 36
37/* Addresses to scan */
38static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
1da177e4
LT		 39
40/* Insmod parameters */
f4b50261 41I2C_CLIENT_INSMOD_6(lm85b, lm85c, adm1027, adt7463, emc6d100, emc6d102);
1da177e4
LT		 42
43/* The LM85 registers */
44
45#define LM85_REG_IN(nr) (0x20 + (nr))
46#define LM85_REG_IN_MIN(nr) (0x44 + (nr) * 2)
47#define LM85_REG_IN_MAX(nr) (0x45 + (nr) * 2)
48
49#define LM85_REG_TEMP(nr) (0x25 + (nr))
50#define LM85_REG_TEMP_MIN(nr) (0x4e + (nr) * 2)
51#define LM85_REG_TEMP_MAX(nr) (0x4f + (nr) * 2)
52
53/* Fan speeds are LSB, MSB (2 bytes) */
54#define LM85_REG_FAN(nr) (0x28 + (nr) *2)
55#define LM85_REG_FAN_MIN(nr) (0x54 + (nr) *2)
56
57#define LM85_REG_PWM(nr) (0x30 + (nr))
58
59#define ADT7463_REG_OPPOINT(nr) (0x33 + (nr))
60
61#define ADT7463_REG_TMIN_CTL1 0x36
62#define ADT7463_REG_TMIN_CTL2 0x37
63
64#define LM85_REG_DEVICE 0x3d
65#define LM85_REG_COMPANY 0x3e
66#define LM85_REG_VERSTEP 0x3f
67/* These are the recognized values for the above regs */
68#define LM85_DEVICE_ADX 0x27
69#define LM85_COMPANY_NATIONAL 0x01
70#define LM85_COMPANY_ANALOG_DEV 0x41
71#define LM85_COMPANY_SMSC 0x5c
72#define LM85_VERSTEP_VMASK 0xf0
73#define LM85_VERSTEP_GENERIC 0x60
74#define LM85_VERSTEP_LM85C 0x60
75#define LM85_VERSTEP_LM85B 0x62
76#define LM85_VERSTEP_ADM1027 0x60
77#define LM85_VERSTEP_ADT7463 0x62
78#define LM85_VERSTEP_ADT7463C 0x6A
79#define LM85_VERSTEP_EMC6D100_A0 0x60
80#define LM85_VERSTEP_EMC6D100_A1 0x61
81#define LM85_VERSTEP_EMC6D102 0x65
82
83#define LM85_REG_CONFIG 0x40
84
85#define LM85_REG_ALARM1 0x41
86#define LM85_REG_ALARM2 0x42
87
88#define LM85_REG_VID 0x43
89
90/* Automated FAN control */
91#define LM85_REG_AFAN_CONFIG(nr) (0x5c + (nr))
92#define LM85_REG_AFAN_RANGE(nr) (0x5f + (nr))
93#define LM85_REG_AFAN_SPIKE1 0x62
94#define LM85_REG_AFAN_SPIKE2 0x63
95#define LM85_REG_AFAN_MINPWM(nr) (0x64 + (nr))
96#define LM85_REG_AFAN_LIMIT(nr) (0x67 + (nr))
97#define LM85_REG_AFAN_CRITICAL(nr) (0x6a + (nr))
98#define LM85_REG_AFAN_HYST1 0x6d
99#define LM85_REG_AFAN_HYST2 0x6e
100
101#define LM85_REG_TACH_MODE 0x74
102#define LM85_REG_SPINUP_CTL 0x75
103
104#define ADM1027_REG_TEMP_OFFSET(nr) (0x70 + (nr))
105#define ADM1027_REG_CONFIG2 0x73
106#define ADM1027_REG_INTMASK1 0x74
107#define ADM1027_REG_INTMASK2 0x75
108#define ADM1027_REG_EXTEND_ADC1 0x76
109#define ADM1027_REG_EXTEND_ADC2 0x77
110#define ADM1027_REG_CONFIG3 0x78
111#define ADM1027_REG_FAN_PPR 0x7b
112
113#define ADT7463_REG_THERM 0x79
114#define ADT7463_REG_THERM_LIMIT 0x7A
115
116#define EMC6D100_REG_ALARM3 0x7d
117/* IN5, IN6 and IN7 */
118#define EMC6D100_REG_IN(nr) (0x70 + ((nr)-5))
119#define EMC6D100_REG_IN_MIN(nr) (0x73 + ((nr)-5) * 2)
120#define EMC6D100_REG_IN_MAX(nr) (0x74 + ((nr)-5) * 2)
121#define EMC6D102_REG_EXTEND_ADC1 0x85
122#define EMC6D102_REG_EXTEND_ADC2 0x86
123#define EMC6D102_REG_EXTEND_ADC3 0x87
124#define EMC6D102_REG_EXTEND_ADC4 0x88
125
126#define LM85_ALARM_IN0 0x0001
127#define LM85_ALARM_IN1 0x0002
128#define LM85_ALARM_IN2 0x0004
129#define LM85_ALARM_IN3 0x0008
130#define LM85_ALARM_TEMP1 0x0010
131#define LM85_ALARM_TEMP2 0x0020
132#define LM85_ALARM_TEMP3 0x0040
133#define LM85_ALARM_ALARM2 0x0080
134#define LM85_ALARM_IN4 0x0100
135#define LM85_ALARM_RESERVED 0x0200
136#define LM85_ALARM_FAN1 0x0400
137#define LM85_ALARM_FAN2 0x0800
138#define LM85_ALARM_FAN3 0x1000
139#define LM85_ALARM_FAN4 0x2000
140#define LM85_ALARM_TEMP1_FAULT 0x4000
141#define LM85_ALARM_TEMP3_FAULT 0x8000
142
143
144/* Conversions. Rounding and limit checking is only done on the TO_REG
145 variants. Note that you should be a bit careful with which arguments
146 these macros are called: arguments may be evaluated more than once.
147 */
148
149/* IN are scaled acording to built-in resistors */
150static int lm85_scaling[] = { /* .001 Volts */
151 2500, 2250, 3300, 5000, 12000,
152 3300, 1500, 1800 /*EMC6D100*/
153 };
154#define SCALE(val,from,to) (((val)*(to) + ((from)/2))/(from))
155
156#define INS_TO_REG(n,val) \
157 SENSORS_LIMIT(SCALE(val,lm85_scaling[n],192),0,255)
158
159#define INSEXT_FROM_REG(n,val,ext,scale) \
160 SCALE((val)*(scale) + (ext),192*(scale),lm85_scaling[n])
161
162#define INS_FROM_REG(n,val) INSEXT_FROM_REG(n,val,0,1)
163
164/* FAN speed is measured using 90kHz clock */
165#define FAN_TO_REG(val) (SENSORS_LIMIT( (val)<=0?0: 5400000/(val),0,65534))
166#define FAN_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:5400000/(val))
167
168/* Temperature is reported in .001 degC increments */
169#define TEMP_TO_REG(val) \
170 SENSORS_LIMIT(SCALE(val,1000,1),-127,127)
171#define TEMPEXT_FROM_REG(val,ext,scale) \
172 SCALE((val)*scale + (ext),scale,1000)
173#define TEMP_FROM_REG(val) \
174 TEMPEXT_FROM_REG(val,0,1)
175
176#define PWM_TO_REG(val) (SENSORS_LIMIT(val,0,255))
177#define PWM_FROM_REG(val) (val)
178
179
180/* ZONEs have the following parameters:
181 * Limit (low) temp, 1. degC
182 * Hysteresis (below limit), 1. degC (0-15)
183 * Range of speed control, .1 degC (2-80)
184 * Critical (high) temp, 1. degC
185 *
186 * FAN PWMs have the following parameters:
187 * Reference Zone, 1, 2, 3, etc.
188 * Spinup time, .05 sec
189 * PWM value at limit/low temp, 1 count
190 * PWM Frequency, 1. Hz
191 * PWM is Min or OFF below limit, flag
192 * Invert PWM output, flag
193 *
194 * Some chips filter the temp, others the fan.
195 * Filter constant (or disabled) .1 seconds
196 */
197
198/* These are the zone temperature range encodings in .001 degree C */
199static int lm85_range_map[] = {
200 2000, 2500, 3300, 4000, 5000, 6600,
201 8000, 10000, 13300, 16000, 20000, 26600,
202 32000, 40000, 53300, 80000
203 };
204static int RANGE_TO_REG( int range )
205{
206 int i;
207
208 if ( range < lm85_range_map[0] ) {
209 return 0 ;
210 } else if ( range > lm85_range_map[15] ) {
211 return 15 ;
212 } else { /* find closest match */
213 for ( i = 14 ; i >= 0 ; --i ) {
214 if ( range > lm85_range_map[i] ) { /* range bracketed */
215 if ((lm85_range_map[i+1] - range) <
216 (range - lm85_range_map[i])) {
217 i++;
218 break;
219 }
220 break;
221 }
222 }
223 }
224 return( i & 0x0f );
225}
226#define RANGE_FROM_REG(val) (lm85_range_map[(val)&0x0f])
227
228/* These are the Acoustic Enhancement, or Temperature smoothing encodings
229 * NOTE: The enable/disable bit is INCLUDED in these encodings as the
230 * MSB (bit 3, value 8). If the enable bit is 0, the encoded value
231 * is ignored, or set to 0.
232 */
233/* These are the PWM frequency encodings */
234static int lm85_freq_map[] = { /* .1 Hz */
235 100, 150, 230, 300, 380, 470, 620, 940
236 };
237static int FREQ_TO_REG( int freq )
238{
239 int i;
240
241 if( freq >= lm85_freq_map[7] ) { return 7 ; }
242 for( i = 0 ; i < 7 ; ++i )
243 if( freq <= lm85_freq_map[i] )
244 break ;
245 return( i & 0x07 );
246}
247#define FREQ_FROM_REG(val) (lm85_freq_map[(val)&0x07])
248
249/* Since we can't use strings, I'm abusing these numbers
250 * to stand in for the following meanings:
251 * 1 -- PWM responds to Zone 1
252 * 2 -- PWM responds to Zone 2
253 * 3 -- PWM responds to Zone 3
254 * 23 -- PWM responds to the higher temp of Zone 2 or 3
255 * 123 -- PWM responds to highest of Zone 1, 2, or 3
256 * 0 -- PWM is always at 0% (ie, off)
257 * -1 -- PWM is always at 100%
258 * -2 -- PWM responds to manual control
259 */
260
261static int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 };
262#define ZONE_FROM_REG(val) (lm85_zone_map[((val)>>5)&0x07])
263
264static int ZONE_TO_REG( int zone )
265{
266 int i;
267
268 for( i = 0 ; i <= 7 ; ++i )
269 if( zone == lm85_zone_map[i] )
270 break ;
271 if( i > 7 ) /* Not found. */
272 i = 3; /* Always 100% */
273 return( (i & 0x07)<<5 );
274}
275
276#define HYST_TO_REG(val) (SENSORS_LIMIT(((val)+500)/1000,0,15))
277#define HYST_FROM_REG(val) ((val)*1000)
278
279#define OFFSET_TO_REG(val) (SENSORS_LIMIT((val)/25,-127,127))
280#define OFFSET_FROM_REG(val) ((val)*25)
281
282#define PPR_MASK(fan) (0x03<<(fan *2))
283#define PPR_TO_REG(val,fan) (SENSORS_LIMIT((val)-1,0,3)<<(fan *2))
284#define PPR_FROM_REG(val,fan) ((((val)>>(fan * 2))&0x03)+1)
285
1da177e4
LT		 286/* Chip sampling rates
287 *
288 * Some sensors are not updated more frequently than once per second
289 * so it doesn't make sense to read them more often than that.
290 * We cache the results and return the saved data if the driver
291 * is called again before a second has elapsed.
292 *
293 * Also, there is significant configuration data for this chip
294 * given the automatic PWM fan control that is possible. There
295 * are about 47 bytes of config data to only 22 bytes of actual
296 * readings. So, we keep the config data up to date in the cache
297 * when it is written and only sample it once every 1 *minute*
298 */
299#define LM85_DATA_INTERVAL (HZ + HZ / 2)
300#define LM85_CONFIG_INTERVAL (1 * 60 * HZ)
301
1da177e4
LT		 302/* LM85 can automatically adjust fan speeds based on temperature
303 * This structure encapsulates an entire Zone config. There are
304 * three zones (one for each temperature input) on the lm85
305 */
306struct lm85_zone {
307 s8 limit; /* Low temp limit */
308 u8 hyst; /* Low limit hysteresis. (0-15) */
309 u8 range; /* Temp range, encoded */
310 s8 critical; /* "All fans ON" temp limit */
311 u8 off_desired; /* Actual "off" temperature specified. Preserved
312 * to prevent "drift" as other autofan control
313 * values change.
314 */
315 u8 max_desired; /* Actual "max" temperature specified. Preserved
316 * to prevent "drift" as other autofan control
317 * values change.
318 */
319};
320
321struct lm85_autofan {
322 u8 config; /* Register value */
323 u8 freq; /* PWM frequency, encoded */
324 u8 min_pwm; /* Minimum PWM value, encoded */
325 u8 min_off; /* Min PWM or OFF below "limit", flag */
326};
327
ed6bafbf
JD		 328/* For each registered chip, we need to keep some data in memory.
329 The structure is dynamically allocated. */
1da177e4
LT		 330struct lm85_data {
331 struct i2c_client client;
1beeffe4 332 struct device *hwmon_dev;
1da177e4
LT		 333 enum chips type;
334
9a61bf63 335 struct mutex update_lock;
1da177e4
LT		 336 int valid; /* !=0 if following fields are valid */
337 unsigned long last_reading; /* In jiffies */
338 unsigned long last_config; /* In jiffies */
339
340 u8 in[8]; /* Register value */
341 u8 in_max[8]; /* Register value */
342 u8 in_min[8]; /* Register value */
343 s8 temp[3]; /* Register value */
344 s8 temp_min[3]; /* Register value */
345 s8 temp_max[3]; /* Register value */
346 s8 temp_offset[3]; /* Register value */
347 u16 fan[4]; /* Register value */
348 u16 fan_min[4]; /* Register value */
349 u8 pwm[3]; /* Register value */
350 u8 spinup_ctl; /* Register encoding, combined */
351 u8 tach_mode; /* Register encoding, combined */
352 u8 temp_ext[3]; /* Decoded values */
353 u8 in_ext[8]; /* Decoded values */
354 u8 adc_scale; /* ADC Extended bits scaling factor */
355 u8 fan_ppr; /* Register value */
356 u8 smooth[3]; /* Register encoding */
357 u8 vid; /* Register value */
358 u8 vrm; /* VRM version */
359 u8 syncpwm3; /* Saved PWM3 for TACH 2,3,4 config */
360 u8 oppoint[3]; /* Register value */
361 u16 tmin_ctl; /* Register value */
362 unsigned long therm_total; /* Cummulative therm count */
363 u8 therm_limit; /* Register value */
364 u32 alarms; /* Register encoding, combined */
365 struct lm85_autofan autofan[3];
366 struct lm85_zone zone[3];
367};
368
369static int lm85_attach_adapter(struct i2c_adapter *adapter);
370static int lm85_detect(struct i2c_adapter *adapter, int address,
371 int kind);
372static int lm85_detach_client(struct i2c_client *client);
373
f6c27fc1
DJ		 374static int lm85_read_value(struct i2c_client *client, u8 reg);
375static int lm85_write_value(struct i2c_client *client, u8 reg, int value);
1da177e4
LT		 376static struct lm85_data *lm85_update_device(struct device *dev);
377static void lm85_init_client(struct i2c_client *client);
378
379
380static struct i2c_driver lm85_driver = {
cdaf7934 381 .driver = {
cdaf7934
LR		 382 .name = "lm85",
383 },
1da177e4 384 .id = I2C_DRIVERID_LM85,
1da177e4
LT		 385 .attach_adapter = lm85_attach_adapter,
386 .detach_client = lm85_detach_client,
387};
388
389
390/* 4 Fans */
b353a487
JD		 391static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
392 char *buf)
1da177e4 393{
b353a487 394 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 395 struct lm85_data *data = lm85_update_device(dev);
396 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr]) );
397}
b353a487
JD		 398
399static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
400 char *buf)
1da177e4 401{
b353a487 402 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 403 struct lm85_data *data = lm85_update_device(dev);
404 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr]) );
405}
b353a487
JD		 406
407static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
408 const char *buf, size_t count)
1da177e4 409{
b353a487 410 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 411 struct i2c_client *client = to_i2c_client(dev);
412 struct lm85_data *data = i2c_get_clientdata(client);
413 long val = simple_strtol(buf, NULL, 10);
414
9a61bf63 415 mutex_lock(&data->update_lock);
1da177e4
LT		 416 data->fan_min[nr] = FAN_TO_REG(val);
417 lm85_write_value(client, LM85_REG_FAN_MIN(nr), data->fan_min[nr]);
9a61bf63 418 mutex_unlock(&data->update_lock);
1da177e4
LT		 419 return count;
420}
421
422#define show_fan_offset(offset) \
b353a487
JD		 423static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
424 show_fan, NULL, offset - 1); \
425static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
426 show_fan_min, set_fan_min, offset - 1)
1da177e4
LT		 427
428show_fan_offset(1);
429show_fan_offset(2);
430show_fan_offset(3);
431show_fan_offset(4);
432
433/* vid, vrm, alarms */
434
8627f9ba 435static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 436{
437 struct lm85_data *data = lm85_update_device(dev);
9c516ef4
JD		 438 int vid;
439
440 if (data->type == adt7463 && (data->vid & 0x80)) {
441 /* 6-pin VID (VRM 10) */
442 vid = vid_from_reg(data->vid & 0x3f, data->vrm);
443 } else {
444 /* 5-pin VID (VRM 9) */
445 vid = vid_from_reg(data->vid & 0x1f, data->vrm);
446 }
447
448 return sprintf(buf, "%d\n", vid);
1da177e4
LT		 449}
450
451static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
452
8627f9ba 453static ssize_t show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 454{
455 struct lm85_data *data = lm85_update_device(dev);
456 return sprintf(buf, "%ld\n", (long) data->vrm);
457}
458
8627f9ba 459static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT		 460{
461 struct i2c_client *client = to_i2c_client(dev);
462 struct lm85_data *data = i2c_get_clientdata(client);
463 u32 val;
464
465 val = simple_strtoul(buf, NULL, 10);
466 data->vrm = val;
467 return count;
468}
469
470static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
471
8627f9ba 472static ssize_t show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 473{
474 struct lm85_data *data = lm85_update_device(dev);
68188ba7 475 return sprintf(buf, "%u\n", data->alarms);
1da177e4
LT		 476}
477
478static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
479
480/* pwm */
481
b353a487
JD		 482static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
483 char *buf)
1da177e4 484{
b353a487 485 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 486 struct lm85_data *data = lm85_update_device(dev);
487 return sprintf(buf,"%d\n", PWM_FROM_REG(data->pwm[nr]) );
488}
b353a487
JD		 489
490static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
491 const char *buf, size_t count)
1da177e4 492{
b353a487 493 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 494 struct i2c_client *client = to_i2c_client(dev);
495 struct lm85_data *data = i2c_get_clientdata(client);
496 long val = simple_strtol(buf, NULL, 10);
497
9a61bf63 498 mutex_lock(&data->update_lock);
1da177e4
LT		 499 data->pwm[nr] = PWM_TO_REG(val);
500 lm85_write_value(client, LM85_REG_PWM(nr), data->pwm[nr]);
9a61bf63 501 mutex_unlock(&data->update_lock);
1da177e4
LT		 502 return count;
503}
b353a487
JD		 504
505static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
506 *attr, char *buf)
1da177e4 507{
b353a487 508 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 509 struct lm85_data *data = lm85_update_device(dev);
510 int pwm_zone;
511
512 pwm_zone = ZONE_FROM_REG(data->autofan[nr].config);
513 return sprintf(buf,"%d\n", (pwm_zone != 0 && pwm_zone != -1) );
514}
515
516#define show_pwm_reg(offset) \
b353a487
JD		 517static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
518 show_pwm, set_pwm, offset - 1); \
519static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO, \
520 show_pwm_enable, NULL, offset - 1)
1da177e4
LT		 521
522show_pwm_reg(1);
523show_pwm_reg(2);
524show_pwm_reg(3);
525
526/* Voltages */
527
b353a487
JD		 528static ssize_t show_in(struct device *dev, struct device_attribute *attr,
529 char *buf)
1da177e4 530{
b353a487 531 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 532 struct lm85_data *data = lm85_update_device(dev);
533 return sprintf( buf, "%d\n", INSEXT_FROM_REG(nr,
534 data->in[nr],
535 data->in_ext[nr],
536 data->adc_scale) );
537}
b353a487
JD		 538
539static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
540 char *buf)
1da177e4 541{
b353a487 542 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 543 struct lm85_data *data = lm85_update_device(dev);
544 return sprintf(buf,"%d\n", INS_FROM_REG(nr, data->in_min[nr]) );
545}
b353a487
JD		 546
547static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
548 const char *buf, size_t count)
1da177e4 549{
b353a487 550 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 551 struct i2c_client *client = to_i2c_client(dev);
552 struct lm85_data *data = i2c_get_clientdata(client);
553 long val = simple_strtol(buf, NULL, 10);
554
9a61bf63 555 mutex_lock(&data->update_lock);
1da177e4
LT		 556 data->in_min[nr] = INS_TO_REG(nr, val);
557 lm85_write_value(client, LM85_REG_IN_MIN(nr), data->in_min[nr]);
9a61bf63 558 mutex_unlock(&data->update_lock);
1da177e4
LT		 559 return count;
560}
b353a487
JD		 561
562static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
563 char *buf)
1da177e4 564{
b353a487 565 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 566 struct lm85_data *data = lm85_update_device(dev);
567 return sprintf(buf,"%d\n", INS_FROM_REG(nr, data->in_max[nr]) );
568}
b353a487
JD		 569
570static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
571 const char *buf, size_t count)
1da177e4 572{
b353a487 573 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 574 struct i2c_client *client = to_i2c_client(dev);
575 struct lm85_data *data = i2c_get_clientdata(client);
576 long val = simple_strtol(buf, NULL, 10);
577
9a61bf63 578 mutex_lock(&data->update_lock);
1da177e4
LT		 579 data->in_max[nr] = INS_TO_REG(nr, val);
580 lm85_write_value(client, LM85_REG_IN_MAX(nr), data->in_max[nr]);
9a61bf63 581 mutex_unlock(&data->update_lock);
1da177e4
LT		 582 return count;
583}
b353a487 584
1da177e4 585#define show_in_reg(offset) \
b353a487
JD		 586static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
587 show_in, NULL, offset); \
588static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
589 show_in_min, set_in_min, offset); \
590static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
591 show_in_max, set_in_max, offset)
1da177e4
LT		 592
593show_in_reg(0);
594show_in_reg(1);
595show_in_reg(2);
596show_in_reg(3);
597show_in_reg(4);
6b9aad2d
JD		 598show_in_reg(5);
599show_in_reg(6);
600show_in_reg(7);
1da177e4
LT		 601
602/* Temps */
603
b353a487
JD		 604static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
605 char *buf)
1da177e4 606{
b353a487 607 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 608 struct lm85_data *data = lm85_update_device(dev);
609 return sprintf(buf,"%d\n", TEMPEXT_FROM_REG(data->temp[nr],
610 data->temp_ext[nr],
611 data->adc_scale) );
612}
b353a487
JD		 613
614static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
615 char *buf)
1da177e4 616{
b353a487 617 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 618 struct lm85_data *data = lm85_update_device(dev);
619 return sprintf(buf,"%d\n", TEMP_FROM_REG(data->temp_min[nr]) );
620}
b353a487
JD		 621
622static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
623 const char *buf, size_t count)
1da177e4 624{
b353a487 625 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 626 struct i2c_client *client = to_i2c_client(dev);
627 struct lm85_data *data = i2c_get_clientdata(client);
628 long val = simple_strtol(buf, NULL, 10);
629
9a61bf63 630 mutex_lock(&data->update_lock);
1da177e4
LT		 631 data->temp_min[nr] = TEMP_TO_REG(val);
632 lm85_write_value(client, LM85_REG_TEMP_MIN(nr), data->temp_min[nr]);
9a61bf63 633 mutex_unlock(&data->update_lock);
1da177e4
LT		 634 return count;
635}
b353a487
JD		 636
637static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
638 char *buf)
1da177e4 639{
b353a487 640 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 641 struct lm85_data *data = lm85_update_device(dev);
642 return sprintf(buf,"%d\n", TEMP_FROM_REG(data->temp_max[nr]) );
643}
b353a487
JD		 644
645static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
646 const char *buf, size_t count)
1da177e4 647{
b353a487 648 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 649 struct i2c_client *client = to_i2c_client(dev);
650 struct lm85_data *data = i2c_get_clientdata(client);
651 long val = simple_strtol(buf, NULL, 10);
652
9a61bf63 653 mutex_lock(&data->update_lock);
1da177e4
LT		 654 data->temp_max[nr] = TEMP_TO_REG(val);
655 lm85_write_value(client, LM85_REG_TEMP_MAX(nr), data->temp_max[nr]);
9a61bf63 656 mutex_unlock(&data->update_lock);
1da177e4
LT		 657 return count;
658}
b353a487 659
1da177e4 660#define show_temp_reg(offset) \
b353a487
JD		 661static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
662 show_temp, NULL, offset - 1); \
663static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
664 show_temp_min, set_temp_min, offset - 1); \
665static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
666 show_temp_max, set_temp_max, offset - 1);
1da177e4
LT		 667
668show_temp_reg(1);
669show_temp_reg(2);
670show_temp_reg(3);
671
672
673/* Automatic PWM control */
674
b353a487
JD		 675static ssize_t show_pwm_auto_channels(struct device *dev,
676 struct device_attribute *attr, char *buf)
1da177e4 677{
b353a487 678 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 679 struct lm85_data *data = lm85_update_device(dev);
680 return sprintf(buf,"%d\n", ZONE_FROM_REG(data->autofan[nr].config));
681}
b353a487
JD		 682
683static ssize_t set_pwm_auto_channels(struct device *dev,
684 struct device_attribute *attr, const char *buf, size_t count)
1da177e4 685{
b353a487 686 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 687 struct i2c_client *client = to_i2c_client(dev);
688 struct lm85_data *data = i2c_get_clientdata(client);
689 long val = simple_strtol(buf, NULL, 10);
690
9a61bf63 691 mutex_lock(&data->update_lock);
1da177e4
LT		 692 data->autofan[nr].config = (data->autofan[nr].config & (~0xe0))
693 | ZONE_TO_REG(val) ;
694 lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
695 data->autofan[nr].config);
9a61bf63 696 mutex_unlock(&data->update_lock);
1da177e4
LT		 697 return count;
698}
b353a487
JD		 699
700static ssize_t show_pwm_auto_pwm_min(struct device *dev,
701 struct device_attribute *attr, char *buf)
1da177e4 702{
b353a487 703 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 704 struct lm85_data *data = lm85_update_device(dev);
705 return sprintf(buf,"%d\n", PWM_FROM_REG(data->autofan[nr].min_pwm));
706}
b353a487
JD		 707
708static ssize_t set_pwm_auto_pwm_min(struct device *dev,
709 struct device_attribute *attr, const char *buf, size_t count)
1da177e4 710{
b353a487 711 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 712 struct i2c_client *client = to_i2c_client(dev);
713 struct lm85_data *data = i2c_get_clientdata(client);
714 long val = simple_strtol(buf, NULL, 10);
715
9a61bf63 716 mutex_lock(&data->update_lock);
1da177e4
LT		 717 data->autofan[nr].min_pwm = PWM_TO_REG(val);
718 lm85_write_value(client, LM85_REG_AFAN_MINPWM(nr),
719 data->autofan[nr].min_pwm);
9a61bf63 720 mutex_unlock(&data->update_lock);
1da177e4
LT		 721 return count;
722}
b353a487
JD		 723
724static ssize_t show_pwm_auto_pwm_minctl(struct device *dev,
725 struct device_attribute *attr, char *buf)
1da177e4 726{
b353a487 727 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 728 struct lm85_data *data = lm85_update_device(dev);
729 return sprintf(buf,"%d\n", data->autofan[nr].min_off);
730}
b353a487
JD		 731
732static ssize_t set_pwm_auto_pwm_minctl(struct device *dev,
733 struct device_attribute *attr, const char *buf, size_t count)
1da177e4 734{
b353a487 735 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 736 struct i2c_client *client = to_i2c_client(dev);
737 struct lm85_data *data = i2c_get_clientdata(client);
738 long val = simple_strtol(buf, NULL, 10);
739
9a61bf63 740 mutex_lock(&data->update_lock);
1da177e4
LT		 741 data->autofan[nr].min_off = val;
742 lm85_write_value(client, LM85_REG_AFAN_SPIKE1, data->smooth[0]
743 | data->syncpwm3
744 | (data->autofan[0].min_off ? 0x20 : 0)
745 | (data->autofan[1].min_off ? 0x40 : 0)
746 | (data->autofan[2].min_off ? 0x80 : 0)
747 );
9a61bf63 748 mutex_unlock(&data->update_lock);
1da177e4
LT		 749 return count;
750}
b353a487
JD		 751
752static ssize_t show_pwm_auto_pwm_freq(struct device *dev,
753 struct device_attribute *attr, char *buf)
1da177e4 754{
b353a487 755 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 756 struct lm85_data *data = lm85_update_device(dev);
757 return sprintf(buf,"%d\n", FREQ_FROM_REG(data->autofan[nr].freq));
758}
b353a487
JD		 759
760static ssize_t set_pwm_auto_pwm_freq(struct device *dev,
761 struct device_attribute *attr, const char *buf, size_t count)
1da177e4 762{
b353a487 763 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 764 struct i2c_client *client = to_i2c_client(dev);
765 struct lm85_data *data = i2c_get_clientdata(client);
766 long val = simple_strtol(buf, NULL, 10);
767
9a61bf63 768 mutex_lock(&data->update_lock);
1da177e4
LT		 769 data->autofan[nr].freq = FREQ_TO_REG(val);
770 lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
771 (data->zone[nr].range << 4)
772 | data->autofan[nr].freq
773 );
9a61bf63 774 mutex_unlock(&data->update_lock);
1da177e4
LT		 775 return count;
776}
b353a487 777
1da177e4 778#define pwm_auto(offset) \
b353a487
JD		 779static SENSOR_DEVICE_ATTR(pwm##offset##_auto_channels, \
780 S_IRUGO | S_IWUSR, show_pwm_auto_channels, \
781 set_pwm_auto_channels, offset - 1); \
782static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_min, \
783 S_IRUGO | S_IWUSR, show_pwm_auto_pwm_min, \
784 set_pwm_auto_pwm_min, offset - 1); \
785static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_minctl, \
786 S_IRUGO | S_IWUSR, show_pwm_auto_pwm_minctl, \
787 set_pwm_auto_pwm_minctl, offset - 1); \
788static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_freq, \
789 S_IRUGO | S_IWUSR, show_pwm_auto_pwm_freq, \
790 set_pwm_auto_pwm_freq, offset - 1);
791
1da177e4
LT		 792pwm_auto(1);
793pwm_auto(2);
794pwm_auto(3);
795
796/* Temperature settings for automatic PWM control */
797
b353a487
JD		 798static ssize_t show_temp_auto_temp_off(struct device *dev,
799 struct device_attribute *attr, char *buf)
1da177e4 800{
b353a487 801 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 802 struct lm85_data *data = lm85_update_device(dev);
803 return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].limit) -
804 HYST_FROM_REG(data->zone[nr].hyst));
805}
b353a487
JD		 806
807static ssize_t set_temp_auto_temp_off(struct device *dev,
808 struct device_attribute *attr, const char *buf, size_t count)
1da177e4 809{
b353a487 810 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 811 struct i2c_client *client = to_i2c_client(dev);
812 struct lm85_data *data = i2c_get_clientdata(client);
813 int min;
814 long val = simple_strtol(buf, NULL, 10);
815
9a61bf63 816 mutex_lock(&data->update_lock);
1da177e4
LT		 817 min = TEMP_FROM_REG(data->zone[nr].limit);
818 data->zone[nr].off_desired = TEMP_TO_REG(val);
819 data->zone[nr].hyst = HYST_TO_REG(min - val);
820 if ( nr == 0 || nr == 1 ) {
821 lm85_write_value(client, LM85_REG_AFAN_HYST1,
822 (data->zone[0].hyst << 4)
823 | data->zone[1].hyst
824 );
825 } else {
826 lm85_write_value(client, LM85_REG_AFAN_HYST2,
827 (data->zone[2].hyst << 4)
828 );
829 }
9a61bf63 830 mutex_unlock(&data->update_lock);
1da177e4
LT		 831 return count;
832}
b353a487
JD		 833
834static ssize_t show_temp_auto_temp_min(struct device *dev,
835 struct device_attribute *attr, char *buf)
1da177e4 836{
b353a487 837 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 838 struct lm85_data *data = lm85_update_device(dev);
839 return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].limit) );
840}
b353a487
JD		 841
842static ssize_t set_temp_auto_temp_min(struct device *dev,
843 struct device_attribute *attr, const char *buf, size_t count)
1da177e4 844{
b353a487 845 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 846 struct i2c_client *client = to_i2c_client(dev);
847 struct lm85_data *data = i2c_get_clientdata(client);
848 long val = simple_strtol(buf, NULL, 10);
849
9a61bf63 850 mutex_lock(&data->update_lock);
1da177e4
LT		 851 data->zone[nr].limit = TEMP_TO_REG(val);
852 lm85_write_value(client, LM85_REG_AFAN_LIMIT(nr),
853 data->zone[nr].limit);
854
855/* Update temp_auto_max and temp_auto_range */
856 data->zone[nr].range = RANGE_TO_REG(
857 TEMP_FROM_REG(data->zone[nr].max_desired) -
858 TEMP_FROM_REG(data->zone[nr].limit));
859 lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
860 ((data->zone[nr].range & 0x0f) << 4)
861 | (data->autofan[nr].freq & 0x07));
862
863/* Update temp_auto_hyst and temp_auto_off */
864 data->zone[nr].hyst = HYST_TO_REG(TEMP_FROM_REG(
865 data->zone[nr].limit) - TEMP_FROM_REG(
866 data->zone[nr].off_desired));
867 if ( nr == 0 || nr == 1 ) {
868 lm85_write_value(client, LM85_REG_AFAN_HYST1,
869 (data->zone[0].hyst << 4)
870 | data->zone[1].hyst
871 );
872 } else {
873 lm85_write_value(client, LM85_REG_AFAN_HYST2,
874 (data->zone[2].hyst << 4)
875 );
876 }
9a61bf63 877 mutex_unlock(&data->update_lock);
1da177e4
LT		 878 return count;
879}
b353a487
JD		 880
881static ssize_t show_temp_auto_temp_max(struct device *dev,
882 struct device_attribute *attr, char *buf)
1da177e4 883{
b353a487 884 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 885 struct lm85_data *data = lm85_update_device(dev);
886 return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].limit) +
887 RANGE_FROM_REG(data->zone[nr].range));
888}
b353a487
JD		 889
890static ssize_t set_temp_auto_temp_max(struct device *dev,
891 struct device_attribute *attr, const char *buf, size_t count)
1da177e4 892{
b353a487 893 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 894 struct i2c_client *client = to_i2c_client(dev);
895 struct lm85_data *data = i2c_get_clientdata(client);
896 int min;
897 long val = simple_strtol(buf, NULL, 10);
898
9a61bf63 899 mutex_lock(&data->update_lock);
1da177e4
LT		 900 min = TEMP_FROM_REG(data->zone[nr].limit);
901 data->zone[nr].max_desired = TEMP_TO_REG(val);
902 data->zone[nr].range = RANGE_TO_REG(
903 val - min);
904 lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
905 ((data->zone[nr].range & 0x0f) << 4)
906 | (data->autofan[nr].freq & 0x07));
9a61bf63 907 mutex_unlock(&data->update_lock);
1da177e4
LT		 908 return count;
909}
b353a487
JD		 910
911static ssize_t show_temp_auto_temp_crit(struct device *dev,
912 struct device_attribute *attr, char *buf)
1da177e4 913{
b353a487 914 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 915 struct lm85_data *data = lm85_update_device(dev);
916 return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].critical));
917}
b353a487
JD		 918
919static ssize_t set_temp_auto_temp_crit(struct device *dev,
920 struct device_attribute *attr,const char *buf, size_t count)
1da177e4 921{
b353a487 922 int nr = to_sensor_dev_attr(attr)->index;
1da177e4
LT		 923 struct i2c_client *client = to_i2c_client(dev);
924 struct lm85_data *data = i2c_get_clientdata(client);
925 long val = simple_strtol(buf, NULL, 10);
926
9a61bf63 927 mutex_lock(&data->update_lock);
1da177e4
LT		 928 data->zone[nr].critical = TEMP_TO_REG(val);
929 lm85_write_value(client, LM85_REG_AFAN_CRITICAL(nr),
930 data->zone[nr].critical);
9a61bf63 931 mutex_unlock(&data->update_lock);
1da177e4
LT		 932 return count;
933}
b353a487 934
1da177e4 935#define temp_auto(offset) \
b353a487
JD		 936static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_off, \
937 S_IRUGO | S_IWUSR, show_temp_auto_temp_off, \
938 set_temp_auto_temp_off, offset - 1); \
939static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_min, \
940 S_IRUGO | S_IWUSR, show_temp_auto_temp_min, \
941 set_temp_auto_temp_min, offset - 1); \
942static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_max, \
943 S_IRUGO | S_IWUSR, show_temp_auto_temp_max, \
944 set_temp_auto_temp_max, offset - 1); \
945static SENSOR_DEVICE_ATTR(temp##offset##_auto_temp_crit, \
946 S_IRUGO | S_IWUSR, show_temp_auto_temp_crit, \
947 set_temp_auto_temp_crit, offset - 1);
948
1da177e4
LT		 949temp_auto(1);
950temp_auto(2);
951temp_auto(3);
952
d8d20615 953static int lm85_attach_adapter(struct i2c_adapter *adapter)
1da177e4
LT		 954{
955 if (!(adapter->class & I2C_CLASS_HWMON))
956 return 0;
2ed2dc3c 957 return i2c_probe(adapter, &addr_data, lm85_detect);
1da177e4
LT		 958}
959
0501a381 960static struct attribute *lm85_attributes[] = {
b353a487
JD		 961 &sensor_dev_attr_fan1_input.dev_attr.attr,
962 &sensor_dev_attr_fan2_input.dev_attr.attr,
963 &sensor_dev_attr_fan3_input.dev_attr.attr,
964 &sensor_dev_attr_fan4_input.dev_attr.attr,
965 &sensor_dev_attr_fan1_min.dev_attr.attr,
966 &sensor_dev_attr_fan2_min.dev_attr.attr,
967 &sensor_dev_attr_fan3_min.dev_attr.attr,
968 &sensor_dev_attr_fan4_min.dev_attr.attr,
969
970 &sensor_dev_attr_pwm1.dev_attr.attr,
971 &sensor_dev_attr_pwm2.dev_attr.attr,
972 &sensor_dev_attr_pwm3.dev_attr.attr,
973 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
974 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
975 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
976
977 &sensor_dev_attr_in0_input.dev_attr.attr,
978 &sensor_dev_attr_in1_input.dev_attr.attr,
979 &sensor_dev_attr_in2_input.dev_attr.attr,
980 &sensor_dev_attr_in3_input.dev_attr.attr,
981 &sensor_dev_attr_in0_min.dev_attr.attr,
982 &sensor_dev_attr_in1_min.dev_attr.attr,
983 &sensor_dev_attr_in2_min.dev_attr.attr,
984 &sensor_dev_attr_in3_min.dev_attr.attr,
985 &sensor_dev_attr_in0_max.dev_attr.attr,
986 &sensor_dev_attr_in1_max.dev_attr.attr,
987 &sensor_dev_attr_in2_max.dev_attr.attr,
988 &sensor_dev_attr_in3_max.dev_attr.attr,
989
990 &sensor_dev_attr_temp1_input.dev_attr.attr,
991 &sensor_dev_attr_temp2_input.dev_attr.attr,
992 &sensor_dev_attr_temp3_input.dev_attr.attr,
993 &sensor_dev_attr_temp1_min.dev_attr.attr,
994 &sensor_dev_attr_temp2_min.dev_attr.attr,
995 &sensor_dev_attr_temp3_min.dev_attr.attr,
996 &sensor_dev_attr_temp1_max.dev_attr.attr,
997 &sensor_dev_attr_temp2_max.dev_attr.attr,
998 &sensor_dev_attr_temp3_max.dev_attr.attr,
999
1000 &sensor_dev_attr_pwm1_auto_channels.dev_attr.attr,
1001 &sensor_dev_attr_pwm2_auto_channels.dev_attr.attr,
1002 &sensor_dev_attr_pwm3_auto_channels.dev_attr.attr,
1003 &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
1004 &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
1005 &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
1006 &sensor_dev_attr_pwm1_auto_pwm_minctl.dev_attr.attr,
1007 &sensor_dev_attr_pwm2_auto_pwm_minctl.dev_attr.attr,
1008 &sensor_dev_attr_pwm3_auto_pwm_minctl.dev_attr.attr,
1009 &sensor_dev_attr_pwm1_auto_pwm_freq.dev_attr.attr,
1010 &sensor_dev_attr_pwm2_auto_pwm_freq.dev_attr.attr,
1011 &sensor_dev_attr_pwm3_auto_pwm_freq.dev_attr.attr,
1012
1013 &sensor_dev_attr_temp1_auto_temp_off.dev_attr.attr,
1014 &sensor_dev_attr_temp2_auto_temp_off.dev_attr.attr,
1015 &sensor_dev_attr_temp3_auto_temp_off.dev_attr.attr,
1016 &sensor_dev_attr_temp1_auto_temp_min.dev_attr.attr,
1017 &sensor_dev_attr_temp2_auto_temp_min.dev_attr.attr,
1018 &sensor_dev_attr_temp3_auto_temp_min.dev_attr.attr,
1019 &sensor_dev_attr_temp1_auto_temp_max.dev_attr.attr,
1020 &sensor_dev_attr_temp2_auto_temp_max.dev_attr.attr,
1021 &sensor_dev_attr_temp3_auto_temp_max.dev_attr.attr,
1022 &sensor_dev_attr_temp1_auto_temp_crit.dev_attr.attr,
1023 &sensor_dev_attr_temp2_auto_temp_crit.dev_attr.attr,
1024 &sensor_dev_attr_temp3_auto_temp_crit.dev_attr.attr,
1025
0501a381
MH		 1026 &dev_attr_vrm.attr,
1027 &dev_attr_cpu0_vid.attr,
1028 &dev_attr_alarms.attr,
0501a381
MH		 1029 NULL
1030};
1031
1032static const struct attribute_group lm85_group = {
1033 .attrs = lm85_attributes,
1034};
1035
6b9aad2d 1036static struct attribute *lm85_attributes_in4[] = {
b353a487
JD		 1037 &sensor_dev_attr_in4_input.dev_attr.attr,
1038 &sensor_dev_attr_in4_min.dev_attr.attr,
1039 &sensor_dev_attr_in4_max.dev_attr.attr,
0501a381
MH		 1040 NULL
1041};
1042
6b9aad2d
JD		 1043static const struct attribute_group lm85_group_in4 = {
1044 .attrs = lm85_attributes_in4,
1045};
1046
1047static struct attribute *lm85_attributes_in567[] = {
1048 &sensor_dev_attr_in5_input.dev_attr.attr,
1049 &sensor_dev_attr_in6_input.dev_attr.attr,
1050 &sensor_dev_attr_in7_input.dev_attr.attr,
1051 &sensor_dev_attr_in5_min.dev_attr.attr,
1052 &sensor_dev_attr_in6_min.dev_attr.attr,
1053 &sensor_dev_attr_in7_min.dev_attr.attr,
1054 &sensor_dev_attr_in5_max.dev_attr.attr,
1055 &sensor_dev_attr_in6_max.dev_attr.attr,
1056 &sensor_dev_attr_in7_max.dev_attr.attr,
1057 NULL
1058};
1059
1060static const struct attribute_group lm85_group_in567 = {
1061 .attrs = lm85_attributes_in567,
0501a381
MH		 1062};
1063
d8d20615 1064static int lm85_detect(struct i2c_adapter *adapter, int address,
1da177e4
LT		 1065 int kind)
1066{
1067 int company, verstep ;
1068 struct i2c_client *new_client = NULL;
1069 struct lm85_data *data;
1070 int err = 0;
1071 const char *type_name = "";
1072
1da177e4
LT		 1073 if (!i2c_check_functionality(adapter,
1074 I2C_FUNC_SMBUS_BYTE_DATA)) {
1075 /* We need to be able to do byte I/O */
1076 goto ERROR0 ;
1077 };
1078
1079 /* OK. For now, we presume we have a valid client. We now create the
1080 client structure, even though we cannot fill it completely yet.
1081 But it allows us to access lm85_{read,write}_value. */
1082
ba9c2e8d 1083 if (!(data = kzalloc(sizeof(struct lm85_data), GFP_KERNEL))) {
1da177e4
LT		 1084 err = -ENOMEM;
1085 goto ERROR0;
1086 }
1da177e4
LT		 1087
1088 new_client = &data->client;
1089 i2c_set_clientdata(new_client, data);
1090 new_client->addr = address;
1091 new_client->adapter = adapter;
1092 new_client->driver = &lm85_driver;
1093 new_client->flags = 0;
1094
1095 /* Now, we do the remaining detection. */
1096
1097 company = lm85_read_value(new_client, LM85_REG_COMPANY);
1098 verstep = lm85_read_value(new_client, LM85_REG_VERSTEP);
1099
1100 dev_dbg(&adapter->dev, "Detecting device at %d,0x%02x with"
1101 " COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
1102 i2c_adapter_id(new_client->adapter), new_client->addr,
1103 company, verstep);
1104
1105 /* If auto-detecting, Determine the chip type. */
1106 if (kind <= 0) {
1107 dev_dbg(&adapter->dev, "Autodetecting device at %d,0x%02x ...\n",
1108 i2c_adapter_id(adapter), address );
1109 if( company == LM85_COMPANY_NATIONAL
1110 && verstep == LM85_VERSTEP_LM85C ) {
1111 kind = lm85c ;
1112 } else if( company == LM85_COMPANY_NATIONAL
1113 && verstep == LM85_VERSTEP_LM85B ) {
1114 kind = lm85b ;
1115 } else if( company == LM85_COMPANY_NATIONAL
1116 && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC ) {
1117 dev_err(&adapter->dev, "Unrecognized version/stepping 0x%02x"
1118 " Defaulting to LM85.\n", verstep);
1119 kind = any_chip ;
1120 } else if( company == LM85_COMPANY_ANALOG_DEV
1121 && verstep == LM85_VERSTEP_ADM1027 ) {
1122 kind = adm1027 ;
1123 } else if( company == LM85_COMPANY_ANALOG_DEV
1124 && (verstep == LM85_VERSTEP_ADT7463
1125 || verstep == LM85_VERSTEP_ADT7463C) ) {
1126 kind = adt7463 ;
1127 } else if( company == LM85_COMPANY_ANALOG_DEV
1128 && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC ) {
1129 dev_err(&adapter->dev, "Unrecognized version/stepping 0x%02x"
1130 " Defaulting to Generic LM85.\n", verstep );
1131 kind = any_chip ;
1132 } else if( company == LM85_COMPANY_SMSC
1133 && (verstep == LM85_VERSTEP_EMC6D100_A0
1134 || verstep == LM85_VERSTEP_EMC6D100_A1) ) {
1135 /* Unfortunately, we can't tell a '100 from a '101
1136 * from the registers. Since a '101 is a '100
1137 * in a package with fewer pins and therefore no
1138 * 3.3V, 1.5V or 1.8V inputs, perhaps if those
1139 * inputs read 0, then it's a '101.
1140 */
1141 kind = emc6d100 ;
1142 } else if( company == LM85_COMPANY_SMSC
1143 && verstep == LM85_VERSTEP_EMC6D102) {
1144 kind = emc6d102 ;
1145 } else if( company == LM85_COMPANY_SMSC
1146 && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
1147 dev_err(&adapter->dev, "lm85: Detected SMSC chip\n");
1148 dev_err(&adapter->dev, "lm85: Unrecognized version/stepping 0x%02x"
1149 " Defaulting to Generic LM85.\n", verstep );
1150 kind = any_chip ;
1151 } else if( kind == any_chip
1152 && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
1153 dev_err(&adapter->dev, "Generic LM85 Version 6 detected\n");
1154 /* Leave kind as "any_chip" */
1155 } else {
1156 dev_dbg(&adapter->dev, "Autodetection failed\n");
1157 /* Not an LM85 ... */
1158 if( kind == any_chip ) { /* User used force=x,y */
1159 dev_err(&adapter->dev, "Generic LM85 Version 6 not"
1160 " found at %d,0x%02x. Try force_lm85c.\n",
1161 i2c_adapter_id(adapter), address );
1162 }
1163 err = 0 ;
1164 goto ERROR1;
1165 }
1166 }
1167
1168 /* Fill in the chip specific driver values */
1169 if ( kind == any_chip ) {
1170 type_name = "lm85";
1171 } else if ( kind == lm85b ) {
1172 type_name = "lm85b";
1173 } else if ( kind == lm85c ) {
1174 type_name = "lm85c";
1175 } else if ( kind == adm1027 ) {
1176 type_name = "adm1027";
1177 } else if ( kind == adt7463 ) {
1178 type_name = "adt7463";
1179 } else if ( kind == emc6d100){
1180 type_name = "emc6d100";
1181 } else if ( kind == emc6d102 ) {
1182 type_name = "emc6d102";
1183 }
1184 strlcpy(new_client->name, type_name, I2C_NAME_SIZE);
1185
1186 /* Fill in the remaining client fields */
1187 data->type = kind;
1188 data->valid = 0;
9a61bf63 1189 mutex_init(&data->update_lock);
1da177e4
LT		 1190
1191 /* Tell the I2C layer a new client has arrived */
1192 if ((err = i2c_attach_client(new_client)))
1193 goto ERROR1;
1194
1195 /* Set the VRM version */
303760b4 1196 data->vrm = vid_which_vrm();
1da177e4
LT		 1197
1198 /* Initialize the LM85 chip */
1199 lm85_init_client(new_client);
1200
1201 /* Register sysfs hooks */
0501a381 1202 if ((err = sysfs_create_group(&new_client->dev.kobj, &lm85_group)))
943b0830 1203 goto ERROR2;
1da177e4 1204
9c516ef4
JD		 1205 /* The ADT7463 has an optional VRM 10 mode where pin 21 is used
1206 as a sixth digital VID input rather than an analog input. */
1207 data->vid = lm85_read_value(new_client, LM85_REG_VID);
0501a381 1208 if (!(kind == adt7463 && (data->vid & 0x80)))
6b9aad2d
JD		 1209 if ((err = sysfs_create_group(&new_client->dev.kobj,
1210 &lm85_group_in4)))
1211 goto ERROR3;
1212
1213 /* The EMC6D100 has 3 additional voltage inputs */
1214 if (kind == emc6d100)
1215 if ((err = sysfs_create_group(&new_client->dev.kobj,
1216 &lm85_group_in567)))
0501a381
MH		 1217 goto ERROR3;
1218
1beeffe4
TJ		 1219 data->hwmon_dev = hwmon_device_register(&new_client->dev);
1220 if (IS_ERR(data->hwmon_dev)) {
1221 err = PTR_ERR(data->hwmon_dev);
0501a381 1222 goto ERROR3;
9c516ef4
JD		 1223 }
1224
1da177e4
LT		 1225 return 0;
1226
1227 /* Error out and cleanup code */
0501a381
MH		 1228 ERROR3:
1229 sysfs_remove_group(&new_client->dev.kobj, &lm85_group);
6b9aad2d
JD		 1230 sysfs_remove_group(&new_client->dev.kobj, &lm85_group_in4);
1231 if (kind == emc6d100)
1232 sysfs_remove_group(&new_client->dev.kobj, &lm85_group_in567);
943b0830
MH		 1233 ERROR2:
1234 i2c_detach_client(new_client);
1da177e4
LT		 1235 ERROR1:
1236 kfree(data);
1237 ERROR0:
1238 return err;
1239}
1240
d8d20615 1241static int lm85_detach_client(struct i2c_client *client)
1da177e4 1242{
943b0830 1243 struct lm85_data *data = i2c_get_clientdata(client);
1beeffe4 1244 hwmon_device_unregister(data->hwmon_dev);
0501a381 1245 sysfs_remove_group(&client->dev.kobj, &lm85_group);
6b9aad2d
JD		 1246 sysfs_remove_group(&client->dev.kobj, &lm85_group_in4);
1247 if (data->type == emc6d100)
1248 sysfs_remove_group(&client->dev.kobj, &lm85_group_in567);
1da177e4 1249 i2c_detach_client(client);
943b0830 1250 kfree(data);
1da177e4
LT		 1251 return 0;
1252}
1253
1254
d8d20615 1255static int lm85_read_value(struct i2c_client *client, u8 reg)
1da177e4
LT		 1256{
1257 int res;
1258
1259 /* What size location is it? */
1260 switch( reg ) {
1261 case LM85_REG_FAN(0) : /* Read WORD data */
1262 case LM85_REG_FAN(1) :
1263 case LM85_REG_FAN(2) :
1264 case LM85_REG_FAN(3) :
1265 case LM85_REG_FAN_MIN(0) :
1266 case LM85_REG_FAN_MIN(1) :
1267 case LM85_REG_FAN_MIN(2) :
1268 case LM85_REG_FAN_MIN(3) :
1269 case LM85_REG_ALARM1 : /* Read both bytes at once */
1270 res = i2c_smbus_read_byte_data(client, reg) & 0xff ;
1271 res |= i2c_smbus_read_byte_data(client, reg+1) << 8 ;
1272 break ;
1273 case ADT7463_REG_TMIN_CTL1 : /* Read WORD MSB, LSB */
1274 res = i2c_smbus_read_byte_data(client, reg) << 8 ;
1275 res |= i2c_smbus_read_byte_data(client, reg+1) & 0xff ;
1276 break ;
1277 default: /* Read BYTE data */
1278 res = i2c_smbus_read_byte_data(client, reg);
1279 break ;
1280 }
1281
1282 return res ;
1283}
1284
d8d20615 1285static int lm85_write_value(struct i2c_client *client, u8 reg, int value)
1da177e4
LT		 1286{
1287 int res ;
1288
1289 switch( reg ) {
1290 case LM85_REG_FAN(0) : /* Write WORD data */
1291 case LM85_REG_FAN(1) :
1292 case LM85_REG_FAN(2) :
1293 case LM85_REG_FAN(3) :
1294 case LM85_REG_FAN_MIN(0) :
1295 case LM85_REG_FAN_MIN(1) :
1296 case LM85_REG_FAN_MIN(2) :
1297 case LM85_REG_FAN_MIN(3) :
1298 /* NOTE: ALARM is read only, so not included here */
1299 res = i2c_smbus_write_byte_data(client, reg, value & 0xff) ;
1300 res |= i2c_smbus_write_byte_data(client, reg+1, (value>>8) & 0xff) ;
1301 break ;
1302 case ADT7463_REG_TMIN_CTL1 : /* Write WORD MSB, LSB */
1303 res = i2c_smbus_write_byte_data(client, reg, (value>>8) & 0xff);
1304 res |= i2c_smbus_write_byte_data(client, reg+1, value & 0xff) ;
1305 break ;
1306 default: /* Write BYTE data */
1307 res = i2c_smbus_write_byte_data(client, reg, value);
1308 break ;
1309 }
1310
1311 return res ;
1312}
1313
d8d20615 1314static void lm85_init_client(struct i2c_client *client)
1da177e4
LT		 1315{
1316 int value;
1317 struct lm85_data *data = i2c_get_clientdata(client);
1318
1319 dev_dbg(&client->dev, "Initializing device\n");
1320
1321 /* Warn if part was not "READY" */
1322 value = lm85_read_value(client, LM85_REG_CONFIG);
1323 dev_dbg(&client->dev, "LM85_REG_CONFIG is: 0x%02x\n", value);
1324 if( value & 0x02 ) {
1325 dev_err(&client->dev, "Client (%d,0x%02x) config is locked.\n",
1326 i2c_adapter_id(client->adapter), client->addr );
1327 };
1328 if( ! (value & 0x04) ) {
1329 dev_err(&client->dev, "Client (%d,0x%02x) is not ready.\n",
1330 i2c_adapter_id(client->adapter), client->addr );
1331 };
1332 if( value & 0x10
1333 && ( data->type == adm1027
1334 || data->type == adt7463 ) ) {
1335 dev_err(&client->dev, "Client (%d,0x%02x) VxI mode is set. "
1336 "Please report this to the lm85 maintainer.\n",
1337 i2c_adapter_id(client->adapter), client->addr );
1338 };
1339
1340 /* WE INTENTIONALLY make no changes to the limits,
1341 * offsets, pwms, fans and zones. If they were
1342 * configured, we don't want to mess with them.
1343 * If they weren't, the default is 100% PWM, no
1344 * control and will suffice until 'sensors -s'
1345 * can be run by the user.
1346 */
1347
1348 /* Start monitoring */
1349 value = lm85_read_value(client, LM85_REG_CONFIG);
1350 /* Try to clear LOCK, Set START, save everything else */
1351 value = (value & ~ 0x02) | 0x01 ;
1352 dev_dbg(&client->dev, "Setting CONFIG to: 0x%02x\n", value);
1353 lm85_write_value(client, LM85_REG_CONFIG, value);
1354}
1355
1356static struct lm85_data *lm85_update_device(struct device *dev)
1357{
1358 struct i2c_client *client = to_i2c_client(dev);
1359 struct lm85_data *data = i2c_get_clientdata(client);
1360 int i;
1361
9a61bf63 1362 mutex_lock(&data->update_lock);
1da177e4
LT		 1363
1364 if ( !data->valid ||
1365 time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL) ) {
1366 /* Things that change quickly */
1367 dev_dbg(&client->dev, "Reading sensor values\n");
1368
1369 /* Have to read extended bits first to "freeze" the
1370 * more significant bits that are read later.
1371 */
1372 if ( (data->type == adm1027) || (data->type == adt7463) ) {
1373 int ext1 = lm85_read_value(client,
1374 ADM1027_REG_EXTEND_ADC1);
1375 int ext2 = lm85_read_value(client,
1376 ADM1027_REG_EXTEND_ADC2);
1377 int val = (ext1 << 8) + ext2;
1378
1379 for(i = 0; i <= 4; i++)
1380 data->in_ext[i] = (val>>(i * 2))&0x03;
1381
1382 for(i = 0; i <= 2; i++)
1383 data->temp_ext[i] = (val>>((i + 5) * 2))&0x03;
1384 }
1385
1386 /* adc_scale is 2^(number of LSBs). There are 4 extra bits in
1387 the emc6d102 and 2 in the adt7463 and adm1027. In all
1388 other chips ext is always 0 and the value of scale is
1389 irrelevant. So it is left in 4*/
1390 data->adc_scale = (data->type == emc6d102 ) ? 16 : 4;
1391
9c516ef4
JD		 1392 data->vid = lm85_read_value(client, LM85_REG_VID);
1393
1394 for (i = 0; i <= 3; ++i) {
1da177e4
LT		 1395 data->in[i] =
1396 lm85_read_value(client, LM85_REG_IN(i));
1397 }
1398
9c516ef4
JD		 1399 if (!(data->type == adt7463 && (data->vid & 0x80))) {
1400 data->in[4] = lm85_read_value(client,
1401 LM85_REG_IN(4));
1402 }
1403
1da177e4
LT		 1404 for (i = 0; i <= 3; ++i) {
1405 data->fan[i] =
1406 lm85_read_value(client, LM85_REG_FAN(i));
1407 }
1408
1409 for (i = 0; i <= 2; ++i) {
1410 data->temp[i] =
1411 lm85_read_value(client, LM85_REG_TEMP(i));
1412 }
1413
1414 for (i = 0; i <= 2; ++i) {
1415 data->pwm[i] =
1416 lm85_read_value(client, LM85_REG_PWM(i));
1417 }
1418
1419 data->alarms = lm85_read_value(client, LM85_REG_ALARM1);
1420
1421 if ( data->type == adt7463 ) {
1422 if( data->therm_total < ULONG_MAX - 256 ) {
1423 data->therm_total +=
1424 lm85_read_value(client, ADT7463_REG_THERM );
1425 }
1426 } else if ( data->type == emc6d100 ) {
1427 /* Three more voltage sensors */
1428 for (i = 5; i <= 7; ++i) {
1429 data->in[i] =
1430 lm85_read_value(client, EMC6D100_REG_IN(i));
1431 }
1432 /* More alarm bits */
1433 data->alarms |=
1434 lm85_read_value(client, EMC6D100_REG_ALARM3) << 16;
1435 } else if (data->type == emc6d102 ) {
1436 /* Have to read LSB bits after the MSB ones because
1437 the reading of the MSB bits has frozen the
1438 LSBs (backward from the ADM1027).
1439 */
1440 int ext1 = lm85_read_value(client,
1441 EMC6D102_REG_EXTEND_ADC1);
1442 int ext2 = lm85_read_value(client,
1443 EMC6D102_REG_EXTEND_ADC2);
1444 int ext3 = lm85_read_value(client,
1445 EMC6D102_REG_EXTEND_ADC3);
1446 int ext4 = lm85_read_value(client,
1447 EMC6D102_REG_EXTEND_ADC4);
1448 data->in_ext[0] = ext3 & 0x0f;
1449 data->in_ext[1] = ext4 & 0x0f;
1450 data->in_ext[2] = (ext4 >> 4) & 0x0f;
1451 data->in_ext[3] = (ext3 >> 4) & 0x0f;
1452 data->in_ext[4] = (ext2 >> 4) & 0x0f;
1453
1454 data->temp_ext[0] = ext1 & 0x0f;
1455 data->temp_ext[1] = ext2 & 0x0f;
1456 data->temp_ext[2] = (ext1 >> 4) & 0x0f;
1457 }
1458
1459 data->last_reading = jiffies ;
1460 }; /* last_reading */
1461
1462 if ( !data->valid ||
1463 time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL) ) {
1464 /* Things that don't change often */
1465 dev_dbg(&client->dev, "Reading config values\n");
1466
9c516ef4 1467 for (i = 0; i <= 3; ++i) {
1da177e4
LT		 1468 data->in_min[i] =
1469 lm85_read_value(client, LM85_REG_IN_MIN(i));
1470 data->in_max[i] =
1471 lm85_read_value(client, LM85_REG_IN_MAX(i));
1472 }
1473
9c516ef4
JD		 1474 if (!(data->type == adt7463 && (data->vid & 0x80))) {
1475 data->in_min[4] = lm85_read_value(client,
1476 LM85_REG_IN_MIN(4));
1477 data->in_max[4] = lm85_read_value(client,
1478 LM85_REG_IN_MAX(4));
1479 }
1480
1da177e4
LT		 1481 if ( data->type == emc6d100 ) {
1482 for (i = 5; i <= 7; ++i) {
1483 data->in_min[i] =
1484 lm85_read_value(client, EMC6D100_REG_IN_MIN(i));
1485 data->in_max[i] =
1486 lm85_read_value(client, EMC6D100_REG_IN_MAX(i));
1487 }
1488 }
1489
1490 for (i = 0; i <= 3; ++i) {
1491 data->fan_min[i] =
1492 lm85_read_value(client, LM85_REG_FAN_MIN(i));
1493 }
1494
1495 for (i = 0; i <= 2; ++i) {
1496 data->temp_min[i] =
1497 lm85_read_value(client, LM85_REG_TEMP_MIN(i));
1498 data->temp_max[i] =
1499 lm85_read_value(client, LM85_REG_TEMP_MAX(i));
1500 }
1501
1da177e4
LT		 1502 for (i = 0; i <= 2; ++i) {
1503 int val ;
1504 data->autofan[i].config =
1505 lm85_read_value(client, LM85_REG_AFAN_CONFIG(i));
1506 val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i));
1507 data->autofan[i].freq = val & 0x07 ;
1508 data->zone[i].range = (val >> 4) & 0x0f ;
1509 data->autofan[i].min_pwm =
1510 lm85_read_value(client, LM85_REG_AFAN_MINPWM(i));
1511 data->zone[i].limit =
1512 lm85_read_value(client, LM85_REG_AFAN_LIMIT(i));
1513 data->zone[i].critical =
1514 lm85_read_value(client, LM85_REG_AFAN_CRITICAL(i));
1515 }
1516
1517 i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
1518 data->smooth[0] = i & 0x0f ;
1519 data->syncpwm3 = i & 0x10 ; /* Save PWM3 config */
1520 data->autofan[0].min_off = (i & 0x20) != 0 ;
1521 data->autofan[1].min_off = (i & 0x40) != 0 ;
1522 data->autofan[2].min_off = (i & 0x80) != 0 ;
1523 i = lm85_read_value(client, LM85_REG_AFAN_SPIKE2);
1524 data->smooth[1] = (i>>4) & 0x0f ;
1525 data->smooth[2] = i & 0x0f ;
1526
1527 i = lm85_read_value(client, LM85_REG_AFAN_HYST1);
1528 data->zone[0].hyst = (i>>4) & 0x0f ;
1529 data->zone[1].hyst = i & 0x0f ;
1530
1531 i = lm85_read_value(client, LM85_REG_AFAN_HYST2);
1532 data->zone[2].hyst = (i>>4) & 0x0f ;
1533
1534 if ( (data->type == lm85b) || (data->type == lm85c) ) {
1535 data->tach_mode = lm85_read_value(client,
1536 LM85_REG_TACH_MODE );
1537 data->spinup_ctl = lm85_read_value(client,
1538 LM85_REG_SPINUP_CTL );
1539 } else if ( (data->type == adt7463) || (data->type == adm1027) ) {
1540 if ( data->type == adt7463 ) {
1541 for (i = 0; i <= 2; ++i) {
1542 data->oppoint[i] = lm85_read_value(client,
1543 ADT7463_REG_OPPOINT(i) );
1544 }
1545 data->tmin_ctl = lm85_read_value(client,
1546 ADT7463_REG_TMIN_CTL1 );
1547 data->therm_limit = lm85_read_value(client,
1548 ADT7463_REG_THERM_LIMIT );
1549 }
1550 for (i = 0; i <= 2; ++i) {
1551 data->temp_offset[i] = lm85_read_value(client,
1552 ADM1027_REG_TEMP_OFFSET(i) );
1553 }
1554 data->tach_mode = lm85_read_value(client,
1555 ADM1027_REG_CONFIG3 );
1556 data->fan_ppr = lm85_read_value(client,
1557 ADM1027_REG_FAN_PPR );
1558 }
1559
1560 data->last_config = jiffies;
1561 }; /* last_config */
1562
1563 data->valid = 1;
1564
9a61bf63 1565 mutex_unlock(&data->update_lock);
1da177e4
LT		 1566
1567 return data;
1568}
1569
1570
1571static int __init sm_lm85_init(void)
1572{
1573 return i2c_add_driver(&lm85_driver);
1574}
1575
1576static void __exit sm_lm85_exit(void)
1577{
1578 i2c_del_driver(&lm85_driver);
1579}
1580
1581/* Thanks to Richard Barrington for adding the LM85 to sensors-detect.
1582 * Thanks to Margit Schubert-While <margitsw@t-online.de> for help with
1583 * post 2.7.0 CVS changes.
1584 */
1585MODULE_LICENSE("GPL");
1586MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, Margit Schubert-While <margitsw@t-online.de>, Justin Thiessen <jthiessen@penguincomputing.com");
1587MODULE_DESCRIPTION("LM85-B, LM85-C driver");
1588
1589module_init(sm_lm85_init);
1590module_exit(sm_lm85_exit);
Linux kernel - Deliverables
This page took 0.333384 seconds and 5 git commands to generate.