blob: 5aaad3636c9876f489a2a41c11a1e1d78bdb8dce [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4 Based on lm75.c and lm85.c
5 Supports adm1030 / adm1031
6 Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org>
7 Reworked by Jean Delvare <khali@linux-fr.org>
Jean Delvare6d6006b2007-12-02 23:33:57 +01008
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22*/
23
24#include <linux/module.h>
25#include <linux/init.h>
26#include <linux/slab.h>
27#include <linux/jiffies.h>
28#include <linux/i2c.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040029#include <linux/hwmon.h>
Jean Delvarec8010822007-12-02 23:39:38 +010030#include <linux/hwmon-sysfs.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040031#include <linux/err.h>
Ingo Molnar9a61bf62006-01-18 23:19:26 +010032#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
34/* Following macros takes channel parameter starting from 0 to 2 */
35#define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr))
Jean Delvare6d6006b2007-12-02 23:33:57 +010036#define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr))
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#define ADM1031_REG_PWM (0x22)
38#define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr))
39
Jean Delvare6d6006b2007-12-02 23:33:57 +010040#define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr))
41#define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr))
42#define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr))
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Jean Delvare6d6006b2007-12-02 23:33:57 +010044#define ADM1031_REG_TEMP(nr) (0x0a + (nr))
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr))
46
47#define ADM1031_REG_STATUS(nr) (0x2 + (nr))
48
Jean Delvare6d6006b2007-12-02 23:33:57 +010049#define ADM1031_REG_CONF1 0x00
50#define ADM1031_REG_CONF2 0x01
51#define ADM1031_REG_EXT_TEMP 0x06
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53#define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */
54#define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */
55#define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */
56
57#define ADM1031_CONF2_PWM1_ENABLE 0x01
58#define ADM1031_CONF2_PWM2_ENABLE 0x02
59#define ADM1031_CONF2_TACH1_ENABLE 0x04
60#define ADM1031_CONF2_TACH2_ENABLE 0x08
61#define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
62
63/* Addresses to scan */
64static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66/* Insmod parameters */
Jean Delvaref4b50262005-07-31 21:49:03 +020067I2C_CLIENT_INSMOD_2(adm1030, adm1031);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
69typedef u8 auto_chan_table_t[8][2];
70
71/* Each client has this additional data */
72struct adm1031_data {
73 struct i2c_client client;
Tony Jones1beeffe2007-08-20 13:46:20 -070074 struct device *hwmon_dev;
Ingo Molnar9a61bf62006-01-18 23:19:26 +010075 struct mutex update_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 int chip_type;
77 char valid; /* !=0 if following fields are valid */
78 unsigned long last_updated; /* In jiffies */
79 /* The chan_select_table contains the possible configurations for
80 * auto fan control.
81 */
Jean Delvare6d6006b2007-12-02 23:33:57 +010082 const auto_chan_table_t *chan_select_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 u16 alarm;
84 u8 conf1;
85 u8 conf2;
86 u8 fan[2];
87 u8 fan_div[2];
88 u8 fan_min[2];
89 u8 pwm[2];
90 u8 old_pwm[2];
91 s8 temp[3];
92 u8 ext_temp[3];
93 u8 auto_temp[3];
94 u8 auto_temp_min[3];
95 u8 auto_temp_off[3];
96 u8 auto_temp_max[3];
97 s8 temp_min[3];
98 s8 temp_max[3];
99 s8 temp_crit[3];
100};
101
102static int adm1031_attach_adapter(struct i2c_adapter *adapter);
103static int adm1031_detect(struct i2c_adapter *adapter, int address, int kind);
104static void adm1031_init_client(struct i2c_client *client);
105static int adm1031_detach_client(struct i2c_client *client);
106static struct adm1031_data *adm1031_update_device(struct device *dev);
107
108/* This is the driver that will be inserted */
109static struct i2c_driver adm1031_driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100110 .driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +0100111 .name = "adm1031",
112 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 .attach_adapter = adm1031_attach_adapter,
114 .detach_client = adm1031_detach_client,
115};
116
117static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
118{
119 return i2c_smbus_read_byte_data(client, reg);
120}
121
122static inline int
123adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
124{
125 return i2c_smbus_write_byte_data(client, reg, value);
126}
127
128
129#define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
130 ((val + 500) / 1000)))
131
132#define TEMP_FROM_REG(val) ((val) * 1000)
133
134#define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
135
136#define FAN_FROM_REG(reg, div) ((reg) ? (11250 * 60) / ((reg) * (div)) : 0)
137
138static int FAN_TO_REG(int reg, int div)
139{
140 int tmp;
141 tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div);
142 return tmp > 255 ? 255 : tmp;
143}
144
145#define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6))
146
147#define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4)
148#define PWM_FROM_REG(val) ((val) << 4)
149
150#define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7)
151#define FAN_CHAN_TO_REG(val, reg) \
152 (((reg) & 0x1F) | (((val) << 5) & 0xe0))
153
154#define AUTO_TEMP_MIN_TO_REG(val, reg) \
155 ((((val)/500) & 0xf8)|((reg) & 0x7))
156#define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1<< ((reg)&0x7)))
157#define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2))
158
159#define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
160
161#define AUTO_TEMP_OFF_FROM_REG(reg) \
162 (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
163
164#define AUTO_TEMP_MAX_FROM_REG(reg) \
165 (AUTO_TEMP_RANGE_FROM_REG(reg) + \
166 AUTO_TEMP_MIN_FROM_REG(reg))
167
168static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
169{
170 int ret;
171 int range = val - AUTO_TEMP_MIN_FROM_REG(reg);
172
173 range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm);
174 ret = ((reg & 0xf8) |
175 (range < 10000 ? 0 :
176 range < 20000 ? 1 :
177 range < 40000 ? 2 : range < 80000 ? 3 : 4));
178 return ret;
179}
180
181/* FAN auto control */
182#define GET_FAN_AUTO_BITFIELD(data, idx) \
183 (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx%2]
184
Jean Delvare6d6006b2007-12-02 23:33:57 +0100185/* The tables below contains the possible values for the auto fan
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 * control bitfields. the index in the table is the register value.
187 * MSb is the auto fan control enable bit, so the four first entries
188 * in the table disables auto fan control when both bitfields are zero.
189 */
Jean Delvare6d6006b2007-12-02 23:33:57 +0100190static const auto_chan_table_t auto_channel_select_table_adm1031 = {
191 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
192 { 2 /* 0b010 */ , 4 /* 0b100 */ },
193 { 2 /* 0b010 */ , 2 /* 0b010 */ },
194 { 4 /* 0b100 */ , 4 /* 0b100 */ },
195 { 7 /* 0b111 */ , 7 /* 0b111 */ },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196};
197
Jean Delvare6d6006b2007-12-02 23:33:57 +0100198static const auto_chan_table_t auto_channel_select_table_adm1030 = {
199 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
200 { 2 /* 0b10 */ , 0 },
201 { 0xff /* invalid */ , 0 },
202 { 0xff /* invalid */ , 0 },
203 { 3 /* 0b11 */ , 0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204};
205
206/* That function checks if a bitfield is valid and returns the other bitfield
207 * nearest match if no exact match where found.
208 */
209static int
210get_fan_auto_nearest(struct adm1031_data *data,
211 int chan, u8 val, u8 reg, u8 * new_reg)
212{
213 int i;
214 int first_match = -1, exact_match = -1;
215 u8 other_reg_val =
216 (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
217
218 if (val == 0) {
219 *new_reg = 0;
220 return 0;
221 }
222
223 for (i = 0; i < 8; i++) {
224 if ((val == (*data->chan_select_table)[i][chan]) &&
225 ((*data->chan_select_table)[i][chan ? 0 : 1] ==
226 other_reg_val)) {
227 /* We found an exact match */
228 exact_match = i;
229 break;
230 } else if (val == (*data->chan_select_table)[i][chan] &&
231 first_match == -1) {
Jean Delvare6d6006b2007-12-02 23:33:57 +0100232 /* Save the first match in case of an exact match has
233 * not been found
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 */
235 first_match = i;
236 }
237 }
238
239 if (exact_match >= 0) {
240 *new_reg = exact_match;
241 } else if (first_match >= 0) {
242 *new_reg = first_match;
243 } else {
244 return -EINVAL;
245 }
246 return 0;
247}
248
Jean Delvarec8010822007-12-02 23:39:38 +0100249static ssize_t show_fan_auto_channel(struct device *dev,
250 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251{
Jean Delvarec8010822007-12-02 23:39:38 +0100252 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 struct adm1031_data *data = adm1031_update_device(dev);
254 return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
255}
256
257static ssize_t
Jean Delvarec8010822007-12-02 23:39:38 +0100258set_fan_auto_channel(struct device *dev, struct device_attribute *attr,
259 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260{
261 struct i2c_client *client = to_i2c_client(dev);
262 struct adm1031_data *data = i2c_get_clientdata(client);
Jean Delvarec8010822007-12-02 23:39:38 +0100263 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 int val = simple_strtol(buf, NULL, 10);
265 u8 reg;
266 int ret;
267 u8 old_fan_mode;
268
269 old_fan_mode = data->conf1;
270
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100271 mutex_lock(&data->update_lock);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 if ((ret = get_fan_auto_nearest(data, nr, val, data->conf1, &reg))) {
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100274 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 return ret;
276 }
Jean Delvare6d6006b2007-12-02 23:33:57 +0100277 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
278 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
280 if (data->conf1 & ADM1031_CONF1_AUTO_MODE){
Jean Delvare6d6006b2007-12-02 23:33:57 +0100281 /* Switch to Auto Fan Mode
282 * Save PWM registers
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 * Set PWM registers to 33% Both */
284 data->old_pwm[0] = data->pwm[0];
285 data->old_pwm[1] = data->pwm[1];
286 adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
287 } else {
288 /* Switch to Manual Mode */
289 data->pwm[0] = data->old_pwm[0];
290 data->pwm[1] = data->old_pwm[1];
291 /* Restore PWM registers */
Jean Delvare6d6006b2007-12-02 23:33:57 +0100292 adm1031_write_value(client, ADM1031_REG_PWM,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 data->pwm[0] | (data->pwm[1] << 4));
294 }
295 }
296 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
297 adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100298 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 return count;
300}
301
Jean Delvarec8010822007-12-02 23:39:38 +0100302static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR,
303 show_fan_auto_channel, set_fan_auto_channel, 0);
304static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR,
305 show_fan_auto_channel, set_fan_auto_channel, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
307/* Auto Temps */
Jean Delvarec8010822007-12-02 23:39:38 +0100308static ssize_t show_auto_temp_off(struct device *dev,
309 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310{
Jean Delvarec8010822007-12-02 23:39:38 +0100311 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 struct adm1031_data *data = adm1031_update_device(dev);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100313 return sprintf(buf, "%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
315}
Jean Delvarec8010822007-12-02 23:39:38 +0100316static ssize_t show_auto_temp_min(struct device *dev,
317 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318{
Jean Delvarec8010822007-12-02 23:39:38 +0100319 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 struct adm1031_data *data = adm1031_update_device(dev);
321 return sprintf(buf, "%d\n",
322 AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
323}
324static ssize_t
Jean Delvarec8010822007-12-02 23:39:38 +0100325set_auto_temp_min(struct device *dev, struct device_attribute *attr,
326 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
328 struct i2c_client *client = to_i2c_client(dev);
329 struct adm1031_data *data = i2c_get_clientdata(client);
Jean Delvarec8010822007-12-02 23:39:38 +0100330 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 int val = simple_strtol(buf, NULL, 10);
332
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100333 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
335 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
336 data->auto_temp[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100337 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 return count;
339}
Jean Delvarec8010822007-12-02 23:39:38 +0100340static ssize_t show_auto_temp_max(struct device *dev,
341 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
Jean Delvarec8010822007-12-02 23:39:38 +0100343 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 struct adm1031_data *data = adm1031_update_device(dev);
345 return sprintf(buf, "%d\n",
346 AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
347}
348static ssize_t
Jean Delvarec8010822007-12-02 23:39:38 +0100349set_auto_temp_max(struct device *dev, struct device_attribute *attr,
350 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351{
352 struct i2c_client *client = to_i2c_client(dev);
353 struct adm1031_data *data = i2c_get_clientdata(client);
Jean Delvarec8010822007-12-02 23:39:38 +0100354 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 int val = simple_strtol(buf, NULL, 10);
356
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100357 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr], data->pwm[nr]);
359 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
360 data->temp_max[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100361 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 return count;
363}
364
Jean Delvarec8010822007-12-02 23:39:38 +0100365#define auto_temp_reg(offset) \
366static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \
367 show_auto_temp_off, NULL, offset - 1); \
368static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \
369 show_auto_temp_min, set_auto_temp_min, offset - 1); \
370static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \
371 show_auto_temp_max, set_auto_temp_max, offset - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
373auto_temp_reg(1);
374auto_temp_reg(2);
375auto_temp_reg(3);
376
377/* pwm */
Jean Delvarec8010822007-12-02 23:39:38 +0100378static ssize_t show_pwm(struct device *dev,
379 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
Jean Delvarec8010822007-12-02 23:39:38 +0100381 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 struct adm1031_data *data = adm1031_update_device(dev);
383 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
384}
Jean Delvarec8010822007-12-02 23:39:38 +0100385static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
386 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
388 struct i2c_client *client = to_i2c_client(dev);
389 struct adm1031_data *data = i2c_get_clientdata(client);
Jean Delvarec8010822007-12-02 23:39:38 +0100390 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 int val = simple_strtol(buf, NULL, 10);
392 int reg;
393
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100394 mutex_lock(&data->update_lock);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100395 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 (((val>>4) & 0xf) != 5)) {
397 /* In automatic mode, the only PWM accepted is 33% */
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100398 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 return -EINVAL;
400 }
401 data->pwm[nr] = PWM_TO_REG(val);
402 reg = adm1031_read_value(client, ADM1031_REG_PWM);
403 adm1031_write_value(client, ADM1031_REG_PWM,
404 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
405 : (data->pwm[nr] & 0xf) | (reg & 0xf0));
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100406 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 return count;
408}
409
Jean Delvarec8010822007-12-02 23:39:38 +0100410static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);
411static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1);
412static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR,
413 show_pwm, set_pwm, 0);
414static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR,
415 show_pwm, set_pwm, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
417/* Fans */
418
419/*
420 * That function checks the cases where the fan reading is not
Steven Cole44bbe872005-05-03 18:21:25 -0600421 * relevant. It is used to provide 0 as fan reading when the fan is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 * not supposed to run
423 */
424static int trust_fan_readings(struct adm1031_data *data, int chan)
425{
426 int res = 0;
427
428 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
429 switch (data->conf1 & 0x60) {
430 case 0x00: /* remote temp1 controls fan1 remote temp2 controls fan2 */
431 res = data->temp[chan+1] >=
432 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
433 break;
434 case 0x20: /* remote temp1 controls both fans */
435 res =
436 data->temp[1] >=
437 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
438 break;
439 case 0x40: /* remote temp2 controls both fans */
440 res =
441 data->temp[2] >=
442 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
443 break;
444 case 0x60: /* max controls both fans */
445 res =
446 data->temp[0] >=
447 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
448 || data->temp[1] >=
449 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
Jean Delvare6d6006b2007-12-02 23:33:57 +0100450 || (data->chip_type == adm1031
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 && data->temp[2] >=
452 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
453 break;
454 }
455 } else {
456 res = data->pwm[chan] > 0;
457 }
458 return res;
459}
460
461
Jean Delvarec8010822007-12-02 23:39:38 +0100462static ssize_t show_fan(struct device *dev,
463 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464{
Jean Delvarec8010822007-12-02 23:39:38 +0100465 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 struct adm1031_data *data = adm1031_update_device(dev);
467 int value;
468
469 value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
470 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
471 return sprintf(buf, "%d\n", value);
472}
473
Jean Delvarec8010822007-12-02 23:39:38 +0100474static ssize_t show_fan_div(struct device *dev,
475 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476{
Jean Delvarec8010822007-12-02 23:39:38 +0100477 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 struct adm1031_data *data = adm1031_update_device(dev);
479 return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
480}
Jean Delvarec8010822007-12-02 23:39:38 +0100481static ssize_t show_fan_min(struct device *dev,
482 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483{
Jean Delvarec8010822007-12-02 23:39:38 +0100484 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 struct adm1031_data *data = adm1031_update_device(dev);
486 return sprintf(buf, "%d\n",
487 FAN_FROM_REG(data->fan_min[nr],
488 FAN_DIV_FROM_REG(data->fan_div[nr])));
489}
Jean Delvarec8010822007-12-02 23:39:38 +0100490static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
491 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492{
493 struct i2c_client *client = to_i2c_client(dev);
494 struct adm1031_data *data = i2c_get_clientdata(client);
Jean Delvarec8010822007-12-02 23:39:38 +0100495 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 int val = simple_strtol(buf, NULL, 10);
497
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100498 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 if (val) {
Jean Delvare6d6006b2007-12-02 23:33:57 +0100500 data->fan_min[nr] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
502 } else {
503 data->fan_min[nr] = 0xff;
504 }
505 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100506 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 return count;
508}
Jean Delvarec8010822007-12-02 23:39:38 +0100509static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
510 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
512 struct i2c_client *client = to_i2c_client(dev);
513 struct adm1031_data *data = i2c_get_clientdata(client);
Jean Delvarec8010822007-12-02 23:39:38 +0100514 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 int val = simple_strtol(buf, NULL, 10);
516 u8 tmp;
517 int old_div;
518 int new_min;
519
520 tmp = val == 8 ? 0xc0 :
521 val == 4 ? 0x80 :
Jean Delvare6d6006b2007-12-02 23:33:57 +0100522 val == 2 ? 0x40 :
523 val == 1 ? 0x00 :
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 0xff;
525 if (tmp == 0xff)
526 return -EINVAL;
Jean Delvare6d6006b2007-12-02 23:33:57 +0100527
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100528 mutex_lock(&data->update_lock);
Jean Delvare38a1f0e2007-12-02 23:32:42 +0100529 /* Get fresh readings */
530 data->fan_div[nr] = adm1031_read_value(client,
531 ADM1031_REG_FAN_DIV(nr));
532 data->fan_min[nr] = adm1031_read_value(client,
533 ADM1031_REG_FAN_MIN(nr));
534
535 /* Write the new clock divider and fan min */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100537 data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
538 new_min = data->fan_min[nr] * old_div / val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
Jean Delvare6d6006b2007-12-02 23:33:57 +0100541 adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 data->fan_div[nr]);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100543 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 data->fan_min[nr]);
Jean Delvare38a1f0e2007-12-02 23:32:42 +0100545
546 /* Invalidate the cache: fan speed is no longer valid */
547 data->valid = 0;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100548 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 return count;
550}
551
552#define fan_offset(offset) \
Jean Delvarec8010822007-12-02 23:39:38 +0100553static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
554 show_fan, NULL, offset - 1); \
555static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
556 show_fan_min, set_fan_min, offset - 1); \
557static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
558 show_fan_div, set_fan_div, offset - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
560fan_offset(1);
561fan_offset(2);
562
563
564/* Temps */
Jean Delvarec8010822007-12-02 23:39:38 +0100565static ssize_t show_temp(struct device *dev,
566 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567{
Jean Delvarec8010822007-12-02 23:39:38 +0100568 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 struct adm1031_data *data = adm1031_update_device(dev);
570 int ext;
571 ext = nr == 0 ?
572 ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
573 (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
574 return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
575}
Jean Delvarec8010822007-12-02 23:39:38 +0100576static ssize_t show_temp_min(struct device *dev,
577 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578{
Jean Delvarec8010822007-12-02 23:39:38 +0100579 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 struct adm1031_data *data = adm1031_update_device(dev);
581 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
582}
Jean Delvarec8010822007-12-02 23:39:38 +0100583static ssize_t show_temp_max(struct device *dev,
584 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Jean Delvarec8010822007-12-02 23:39:38 +0100586 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 struct adm1031_data *data = adm1031_update_device(dev);
588 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
589}
Jean Delvarec8010822007-12-02 23:39:38 +0100590static ssize_t show_temp_crit(struct device *dev,
591 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592{
Jean Delvarec8010822007-12-02 23:39:38 +0100593 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 struct adm1031_data *data = adm1031_update_device(dev);
595 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
596}
Jean Delvarec8010822007-12-02 23:39:38 +0100597static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
598 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599{
600 struct i2c_client *client = to_i2c_client(dev);
601 struct adm1031_data *data = i2c_get_clientdata(client);
Jean Delvarec8010822007-12-02 23:39:38 +0100602 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 int val;
604
605 val = simple_strtol(buf, NULL, 10);
606 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100607 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 data->temp_min[nr] = TEMP_TO_REG(val);
609 adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
610 data->temp_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100611 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 return count;
613}
Jean Delvarec8010822007-12-02 23:39:38 +0100614static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
615 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616{
617 struct i2c_client *client = to_i2c_client(dev);
618 struct adm1031_data *data = i2c_get_clientdata(client);
Jean Delvarec8010822007-12-02 23:39:38 +0100619 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 int val;
621
622 val = simple_strtol(buf, NULL, 10);
623 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100624 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 data->temp_max[nr] = TEMP_TO_REG(val);
626 adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
627 data->temp_max[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100628 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 return count;
630}
Jean Delvarec8010822007-12-02 23:39:38 +0100631static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
632 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633{
634 struct i2c_client *client = to_i2c_client(dev);
635 struct adm1031_data *data = i2c_get_clientdata(client);
Jean Delvarec8010822007-12-02 23:39:38 +0100636 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 int val;
638
639 val = simple_strtol(buf, NULL, 10);
640 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100641 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 data->temp_crit[nr] = TEMP_TO_REG(val);
643 adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
644 data->temp_crit[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100645 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 return count;
647}
648
Jean Delvarec8010822007-12-02 23:39:38 +0100649#define temp_reg(offset) \
650static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
651 show_temp, NULL, offset - 1); \
652static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
653 show_temp_min, set_temp_min, offset - 1); \
654static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
655 show_temp_max, set_temp_max, offset - 1); \
656static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \
657 show_temp_crit, set_temp_crit, offset - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
659temp_reg(1);
660temp_reg(2);
661temp_reg(3);
662
663/* Alarms */
Yani Ioannou30f74292005-05-17 06:41:35 -0400664static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665{
666 struct adm1031_data *data = adm1031_update_device(dev);
667 return sprintf(buf, "%d\n", data->alarm);
668}
669
670static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
671
Jean Delvare050ab872007-12-02 23:42:24 +0100672static ssize_t show_alarm(struct device *dev,
673 struct device_attribute *attr, char *buf)
674{
675 int bitnr = to_sensor_dev_attr(attr)->index;
676 struct adm1031_data *data = adm1031_update_device(dev);
677 return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
678}
679
680static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
681static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
682static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
683static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
684static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4);
685static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5);
686static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
687static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7);
688static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8);
689static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9);
690static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10);
691static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
692static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
693static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
694static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696static int adm1031_attach_adapter(struct i2c_adapter *adapter)
697{
698 if (!(adapter->class & I2C_CLASS_HWMON))
699 return 0;
Jean Delvare2ed2dc32005-07-31 21:42:02 +0200700 return i2c_probe(adapter, &addr_data, adm1031_detect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701}
702
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200703static struct attribute *adm1031_attributes[] = {
Jean Delvarec8010822007-12-02 23:39:38 +0100704 &sensor_dev_attr_fan1_input.dev_attr.attr,
705 &sensor_dev_attr_fan1_div.dev_attr.attr,
706 &sensor_dev_attr_fan1_min.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100707 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
708 &sensor_dev_attr_fan1_fault.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100709 &sensor_dev_attr_pwm1.dev_attr.attr,
710 &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
711 &sensor_dev_attr_temp1_input.dev_attr.attr,
712 &sensor_dev_attr_temp1_min.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100713 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100714 &sensor_dev_attr_temp1_max.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100715 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100716 &sensor_dev_attr_temp1_crit.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100717 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100718 &sensor_dev_attr_temp2_input.dev_attr.attr,
719 &sensor_dev_attr_temp2_min.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100720 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100721 &sensor_dev_attr_temp2_max.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100722 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100723 &sensor_dev_attr_temp2_crit.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100724 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
725 &sensor_dev_attr_temp2_fault.dev_attr.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200726
Jean Delvarec8010822007-12-02 23:39:38 +0100727 &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
728 &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
729 &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200730
Jean Delvarec8010822007-12-02 23:39:38 +0100731 &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
732 &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
733 &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200734
Jean Delvarec8010822007-12-02 23:39:38 +0100735 &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200736
737 &dev_attr_alarms.attr,
738
739 NULL
740};
741
742static const struct attribute_group adm1031_group = {
743 .attrs = adm1031_attributes,
744};
745
746static struct attribute *adm1031_attributes_opt[] = {
Jean Delvarec8010822007-12-02 23:39:38 +0100747 &sensor_dev_attr_fan2_input.dev_attr.attr,
748 &sensor_dev_attr_fan2_div.dev_attr.attr,
749 &sensor_dev_attr_fan2_min.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100750 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
751 &sensor_dev_attr_fan2_fault.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100752 &sensor_dev_attr_pwm2.dev_attr.attr,
753 &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
754 &sensor_dev_attr_temp3_input.dev_attr.attr,
755 &sensor_dev_attr_temp3_min.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100756 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100757 &sensor_dev_attr_temp3_max.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100758 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100759 &sensor_dev_attr_temp3_crit.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100760 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
761 &sensor_dev_attr_temp3_fault.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100762 &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
763 &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
764 &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
765 &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200766 NULL
767};
768
769static const struct attribute_group adm1031_group_opt = {
770 .attrs = adm1031_attributes_opt,
771};
772
Jean Delvare2ed2dc32005-07-31 21:42:02 +0200773/* This function is called by i2c_probe */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774static int adm1031_detect(struct i2c_adapter *adapter, int address, int kind)
775{
Jean Delvare6d6006b2007-12-02 23:33:57 +0100776 struct i2c_client *client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 struct adm1031_data *data;
778 int err = 0;
779 const char *name = "";
780
781 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
782 goto exit;
783
Deepak Saxenaba9c2e82005-10-17 23:08:32 +0200784 if (!(data = kzalloc(sizeof(struct adm1031_data), GFP_KERNEL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 err = -ENOMEM;
786 goto exit;
787 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Jean Delvare6d6006b2007-12-02 23:33:57 +0100789 client = &data->client;
790 i2c_set_clientdata(client, data);
791 client->addr = address;
792 client->adapter = adapter;
793 client->driver = &adm1031_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
795 if (kind < 0) {
796 int id, co;
Jean Delvare6d6006b2007-12-02 23:33:57 +0100797 id = i2c_smbus_read_byte_data(client, 0x3d);
798 co = i2c_smbus_read_byte_data(client, 0x3e);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
800 if (!((id == 0x31 || id == 0x30) && co == 0x41))
801 goto exit_free;
802 kind = (id == 0x30) ? adm1030 : adm1031;
803 }
804
805 if (kind <= 0)
806 kind = adm1031;
807
808 /* Given the detected chip type, set the chip name and the
809 * auto fan control helper table. */
810 if (kind == adm1030) {
811 name = "adm1030";
812 data->chan_select_table = &auto_channel_select_table_adm1030;
813 } else if (kind == adm1031) {
814 name = "adm1031";
815 data->chan_select_table = &auto_channel_select_table_adm1031;
816 }
817 data->chip_type = kind;
818
Jean Delvare6d6006b2007-12-02 23:33:57 +0100819 strlcpy(client->name, name, I2C_NAME_SIZE);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100820 mutex_init(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
822 /* Tell the I2C layer a new client has arrived */
Jean Delvare6d6006b2007-12-02 23:33:57 +0100823 if ((err = i2c_attach_client(client)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 goto exit_free;
825
826 /* Initialize the ADM1031 chip */
Jean Delvare6d6006b2007-12-02 23:33:57 +0100827 adm1031_init_client(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
829 /* Register sysfs hooks */
Jean Delvare6d6006b2007-12-02 23:33:57 +0100830 if ((err = sysfs_create_group(&client->dev.kobj, &adm1031_group)))
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200831 goto exit_detach;
832
833 if (kind == adm1031) {
Jean Delvare6d6006b2007-12-02 23:33:57 +0100834 if ((err = sysfs_create_group(&client->dev.kobj,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200835 &adm1031_group_opt)))
836 goto exit_remove;
837 }
838
Jean Delvare6d6006b2007-12-02 23:33:57 +0100839 data->hwmon_dev = hwmon_device_register(&client->dev);
Tony Jones1beeffe2007-08-20 13:46:20 -0700840 if (IS_ERR(data->hwmon_dev)) {
841 err = PTR_ERR(data->hwmon_dev);
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200842 goto exit_remove;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 }
844
845 return 0;
846
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200847exit_remove:
Jean Delvare6d6006b2007-12-02 23:33:57 +0100848 sysfs_remove_group(&client->dev.kobj, &adm1031_group);
849 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400850exit_detach:
Jean Delvare6d6006b2007-12-02 23:33:57 +0100851 i2c_detach_client(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852exit_free:
Alexey Dobriyan1f57ff82005-08-26 01:49:14 +0400853 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854exit:
855 return err;
856}
857
858static int adm1031_detach_client(struct i2c_client *client)
859{
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400860 struct adm1031_data *data = i2c_get_clientdata(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 int ret;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400862
Tony Jones1beeffe2007-08-20 13:46:20 -0700863 hwmon_device_unregister(data->hwmon_dev);
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200864 sysfs_remove_group(&client->dev.kobj, &adm1031_group);
865 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 if ((ret = i2c_detach_client(client)) != 0) {
867 return ret;
868 }
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400869 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 return 0;
871}
872
873static void adm1031_init_client(struct i2c_client *client)
874{
875 unsigned int read_val;
876 unsigned int mask;
877 struct adm1031_data *data = i2c_get_clientdata(client);
878
879 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
880 if (data->chip_type == adm1031) {
881 mask |= (ADM1031_CONF2_PWM2_ENABLE |
882 ADM1031_CONF2_TACH2_ENABLE);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100883 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 /* Initialize the ADM1031 chip (enables fan speed reading ) */
885 read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
886 if ((read_val | mask) != read_val) {
887 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
888 }
889
890 read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
891 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
892 adm1031_write_value(client, ADM1031_REG_CONF1, read_val |
893 ADM1031_CONF1_MONITOR_ENABLE);
894 }
895
896}
897
898static struct adm1031_data *adm1031_update_device(struct device *dev)
899{
900 struct i2c_client *client = to_i2c_client(dev);
901 struct adm1031_data *data = i2c_get_clientdata(client);
902 int chan;
903
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100904 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
906 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
907 || !data->valid) {
908
909 dev_dbg(&client->dev, "Starting adm1031 update\n");
910 for (chan = 0;
911 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
912 u8 oldh, newh;
913
914 oldh =
915 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
916 data->ext_temp[chan] =
917 adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
918 newh =
919 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
920 if (newh != oldh) {
921 data->ext_temp[chan] =
922 adm1031_read_value(client,
923 ADM1031_REG_EXT_TEMP);
924#ifdef DEBUG
925 oldh =
926 adm1031_read_value(client,
927 ADM1031_REG_TEMP(chan));
928
929 /* oldh is actually newer */
930 if (newh != oldh)
931 dev_warn(&client->dev,
932 "Remote temperature may be "
933 "wrong.\n");
934#endif
935 }
936 data->temp[chan] = newh;
937
938 data->temp_min[chan] =
939 adm1031_read_value(client,
940 ADM1031_REG_TEMP_MIN(chan));
941 data->temp_max[chan] =
942 adm1031_read_value(client,
943 ADM1031_REG_TEMP_MAX(chan));
944 data->temp_crit[chan] =
945 adm1031_read_value(client,
946 ADM1031_REG_TEMP_CRIT(chan));
947 data->auto_temp[chan] =
948 adm1031_read_value(client,
949 ADM1031_REG_AUTO_TEMP(chan));
950
951 }
952
953 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
954 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
955
956 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
957 | (adm1031_read_value(client, ADM1031_REG_STATUS(1))
958 << 8);
959 if (data->chip_type == adm1030) {
960 data->alarm &= 0xc0ff;
961 }
Jean Delvare6d6006b2007-12-02 23:33:57 +0100962
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 for (chan=0; chan<(data->chip_type == adm1030 ? 1 : 2); chan++) {
964 data->fan_div[chan] =
965 adm1031_read_value(client, ADM1031_REG_FAN_DIV(chan));
966 data->fan_min[chan] =
967 adm1031_read_value(client, ADM1031_REG_FAN_MIN(chan));
968 data->fan[chan] =
969 adm1031_read_value(client, ADM1031_REG_FAN_SPEED(chan));
970 data->pwm[chan] =
Jean Delvare6d6006b2007-12-02 23:33:57 +0100971 0xf & (adm1031_read_value(client, ADM1031_REG_PWM) >>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 (4*chan));
973 }
974 data->last_updated = jiffies;
975 data->valid = 1;
976 }
977
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100978 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
980 return data;
981}
982
983static int __init sensors_adm1031_init(void)
984{
985 return i2c_add_driver(&adm1031_driver);
986}
987
988static void __exit sensors_adm1031_exit(void)
989{
990 i2c_del_driver(&adm1031_driver);
991}
992
993MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
994MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
995MODULE_LICENSE("GPL");
996
997module_init(sensors_adm1031_init);
998module_exit(sensors_adm1031_exit);