Blame view
drivers/hwmon/adm1031.c
33.8 KB
1da177e4c
|
1 |
/* |
fbb6670d9
|
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
* adm1031.c - Part of lm_sensors, Linux kernel modules for hardware * monitoring * Based on lm75.c and lm85.c * Supports adm1030 / adm1031 * Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org> * Reworked by Jean Delvare <khali@linux-fr.org> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ |
1da177e4c
|
23 24 25 26 27 28 |
#include <linux/module.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/jiffies.h> #include <linux/i2c.h> |
943b0830c
|
29 |
#include <linux/hwmon.h> |
c801082d7
|
30 |
#include <linux/hwmon-sysfs.h> |
943b0830c
|
31 |
#include <linux/err.h> |
9a61bf630
|
32 |
#include <linux/mutex.h> |
1da177e4c
|
33 34 35 |
/* Following macros takes channel parameter starting from 0 to 2 */ #define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr)) |
6d6006b8d
|
36 |
#define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr)) |
1da177e4c
|
37 38 |
#define ADM1031_REG_PWM (0x22) #define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr)) |
87c33daad
|
39 |
#define ADM1031_REG_FAN_FILTER (0x23) |
1da177e4c
|
40 |
|
49dc9efed
|
41 |
#define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr)) |
6d6006b8d
|
42 43 44 |
#define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr)) #define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr)) #define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr)) |
1da177e4c
|
45 |
|
6d6006b8d
|
46 |
#define ADM1031_REG_TEMP(nr) (0x0a + (nr)) |
1da177e4c
|
47 48 49 |
#define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr)) #define ADM1031_REG_STATUS(nr) (0x2 + (nr)) |
6d6006b8d
|
50 51 52 |
#define ADM1031_REG_CONF1 0x00 #define ADM1031_REG_CONF2 0x01 #define ADM1031_REG_EXT_TEMP 0x06 |
1da177e4c
|
53 54 55 56 57 58 59 60 61 62 |
#define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */ #define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */ #define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */ #define ADM1031_CONF2_PWM1_ENABLE 0x01 #define ADM1031_CONF2_PWM2_ENABLE 0x02 #define ADM1031_CONF2_TACH1_ENABLE 0x04 #define ADM1031_CONF2_TACH2_ENABLE 0x08 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan)) |
87c33daad
|
63 64 |
#define ADM1031_UPDATE_RATE_MASK 0x1c #define ADM1031_UPDATE_RATE_SHIFT 2 |
1da177e4c
|
65 |
/* Addresses to scan */ |
25e9c86d5
|
66 |
static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END }; |
1da177e4c
|
67 |
|
e5e9f44c2
|
68 |
enum chips { adm1030, adm1031 }; |
1da177e4c
|
69 70 71 72 73 |
typedef u8 auto_chan_table_t[8][2]; /* Each client has this additional data */ struct adm1031_data { |
1beeffe43
|
74 |
struct device *hwmon_dev; |
9a61bf630
|
75 |
struct mutex update_lock; |
1da177e4c
|
76 77 78 |
int chip_type; char valid; /* !=0 if following fields are valid */ unsigned long last_updated; /* In jiffies */ |
a51b9944a
|
79 |
unsigned int update_interval; /* In milliseconds */ |
fbb6670d9
|
80 81 |
/* * The chan_select_table contains the possible configurations for |
1da177e4c
|
82 83 |
* auto fan control. */ |
6d6006b8d
|
84 |
const auto_chan_table_t *chan_select_table; |
1da177e4c
|
85 86 87 88 89 90 91 92 93 94 95 96 97 98 |
u16 alarm; u8 conf1; u8 conf2; u8 fan[2]; u8 fan_div[2]; u8 fan_min[2]; u8 pwm[2]; u8 old_pwm[2]; s8 temp[3]; u8 ext_temp[3]; u8 auto_temp[3]; u8 auto_temp_min[3]; u8 auto_temp_off[3]; u8 auto_temp_max[3]; |
49dc9efed
|
99 |
s8 temp_offset[3]; |
1da177e4c
|
100 101 102 103 |
s8 temp_min[3]; s8 temp_max[3]; s8 temp_crit[3]; }; |
af200f881
|
104 105 |
static int adm1031_probe(struct i2c_client *client, const struct i2c_device_id *id); |
310ec7921
|
106 |
static int adm1031_detect(struct i2c_client *client, |
af200f881
|
107 |
struct i2c_board_info *info); |
1da177e4c
|
108 |
static void adm1031_init_client(struct i2c_client *client); |
af200f881
|
109 |
static int adm1031_remove(struct i2c_client *client); |
1da177e4c
|
110 |
static struct adm1031_data *adm1031_update_device(struct device *dev); |
af200f881
|
111 112 113 114 115 116 |
static const struct i2c_device_id adm1031_id[] = { { "adm1030", adm1030 }, { "adm1031", adm1031 }, { } }; MODULE_DEVICE_TABLE(i2c, adm1031_id); |
1da177e4c
|
117 118 |
/* This is the driver that will be inserted */ static struct i2c_driver adm1031_driver = { |
af200f881
|
119 |
.class = I2C_CLASS_HWMON, |
cdaf79349
|
120 |
.driver = { |
cdaf79349
|
121 122 |
.name = "adm1031", }, |
af200f881
|
123 124 125 126 |
.probe = adm1031_probe, .remove = adm1031_remove, .id_table = adm1031_id, .detect = adm1031_detect, |
c3813d6af
|
127 |
.address_list = normal_i2c, |
1da177e4c
|
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 |
}; static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg) { return i2c_smbus_read_byte_data(client, reg); } static inline int adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value) { return i2c_smbus_write_byte_data(client, reg, value); } #define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \ ((val + 500) / 1000))) #define TEMP_FROM_REG(val) ((val) * 1000) #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125) |
49dc9efed
|
148 149 150 |
#define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f) #define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \ (val) | 0x70 : (val)) |
1c720093f
|
151 152 |
#define FAN_FROM_REG(reg, div) ((reg) ? \ (11250 * 60) / ((reg) * (div)) : 0) |
1da177e4c
|
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 |
static int FAN_TO_REG(int reg, int div) { int tmp; tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div); return tmp > 255 ? 255 : tmp; } #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6)) #define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4) #define PWM_FROM_REG(val) ((val) << 4) #define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7) #define FAN_CHAN_TO_REG(val, reg) \ (((reg) & 0x1F) | (((val) << 5) & 0xe0)) #define AUTO_TEMP_MIN_TO_REG(val, reg) \ |
1c720093f
|
171 172 |
((((val) / 500) & 0xf8) | ((reg) & 0x7)) #define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1 << ((reg) & 0x7))) |
1da177e4c
|
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 |
#define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2)) #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2) #define AUTO_TEMP_OFF_FROM_REG(reg) \ (AUTO_TEMP_MIN_FROM_REG(reg) - 5000) #define AUTO_TEMP_MAX_FROM_REG(reg) \ (AUTO_TEMP_RANGE_FROM_REG(reg) + \ AUTO_TEMP_MIN_FROM_REG(reg)) static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm) { int ret; int range = val - AUTO_TEMP_MIN_FROM_REG(reg); range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm); ret = ((reg & 0xf8) | (range < 10000 ? 0 : range < 20000 ? 1 : range < 40000 ? 2 : range < 80000 ? 3 : 4)); return ret; } /* FAN auto control */ #define GET_FAN_AUTO_BITFIELD(data, idx) \ |
1c720093f
|
199 |
(*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx % 2] |
1da177e4c
|
200 |
|
fbb6670d9
|
201 202 |
/* * The tables below contains the possible values for the auto fan |
1da177e4c
|
203 204 205 206 |
* control bitfields. the index in the table is the register value. * MSb is the auto fan control enable bit, so the four first entries * in the table disables auto fan control when both bitfields are zero. */ |
6d6006b8d
|
207 208 209 210 211 212 |
static const auto_chan_table_t auto_channel_select_table_adm1031 = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 2 /* 0b010 */ , 4 /* 0b100 */ }, { 2 /* 0b010 */ , 2 /* 0b010 */ }, { 4 /* 0b100 */ , 4 /* 0b100 */ }, { 7 /* 0b111 */ , 7 /* 0b111 */ }, |
1da177e4c
|
213 |
}; |
6d6006b8d
|
214 215 216 217 218 219 |
static const auto_chan_table_t auto_channel_select_table_adm1030 = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 2 /* 0b10 */ , 0 }, { 0xff /* invalid */ , 0 }, { 0xff /* invalid */ , 0 }, { 3 /* 0b11 */ , 0 }, |
1da177e4c
|
220 |
}; |
fbb6670d9
|
221 222 |
/* * That function checks if a bitfield is valid and returns the other bitfield |
1da177e4c
|
223 224 225 |
* nearest match if no exact match where found. */ static int |
ce15a81da
|
226 |
get_fan_auto_nearest(struct adm1031_data *data, int chan, u8 val, u8 reg) |
1da177e4c
|
227 228 229 230 231 |
{ int i; int first_match = -1, exact_match = -1; u8 other_reg_val = (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1]; |
ce15a81da
|
232 |
if (val == 0) |
1da177e4c
|
233 |
return 0; |
1da177e4c
|
234 235 236 237 238 239 240 241 242 243 |
for (i = 0; i < 8; i++) { if ((val == (*data->chan_select_table)[i][chan]) && ((*data->chan_select_table)[i][chan ? 0 : 1] == other_reg_val)) { /* We found an exact match */ exact_match = i; break; } else if (val == (*data->chan_select_table)[i][chan] && first_match == -1) { |
fbb6670d9
|
244 245 |
/* * Save the first match in case of an exact match has |
6d6006b8d
|
246 |
* not been found |
1da177e4c
|
247 248 249 250 |
*/ first_match = i; } } |
1c720093f
|
251 |
if (exact_match >= 0) |
ce15a81da
|
252 |
return exact_match; |
1c720093f
|
253 |
else if (first_match >= 0) |
ce15a81da
|
254 |
return first_match; |
1c720093f
|
255 |
|
ce15a81da
|
256 |
return -EINVAL; |
1da177e4c
|
257 |
} |
c801082d7
|
258 259 |
static ssize_t show_fan_auto_channel(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
260 |
{ |
c801082d7
|
261 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
262 263 264 265 266 267 |
struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", GET_FAN_AUTO_BITFIELD(data, nr)); } static ssize_t |
c801082d7
|
268 269 |
set_fan_auto_channel(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
1da177e4c
|
270 271 272 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
c801082d7
|
273 |
int nr = to_sensor_dev_attr(attr)->index; |
1c720093f
|
274 |
long val; |
1da177e4c
|
275 276 277 |
u8 reg; int ret; u8 old_fan_mode; |
1c720093f
|
278 279 280 |
ret = kstrtol(buf, 10, &val); if (ret) return ret; |
1da177e4c
|
281 |
old_fan_mode = data->conf1; |
9a61bf630
|
282 |
mutex_lock(&data->update_lock); |
6d6006b8d
|
283 |
|
ce15a81da
|
284 285 |
ret = get_fan_auto_nearest(data, nr, val, data->conf1); if (ret < 0) { |
9a61bf630
|
286 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
287 288 |
return ret; } |
ce15a81da
|
289 |
reg = ret; |
6d6006b8d
|
290 291 |
data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1); if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^ |
1da177e4c
|
292 |
(old_fan_mode & ADM1031_CONF1_AUTO_MODE)) { |
1c720093f
|
293 |
if (data->conf1 & ADM1031_CONF1_AUTO_MODE) { |
fbb6670d9
|
294 295 |
/* * Switch to Auto Fan Mode |
6d6006b8d
|
296 |
* Save PWM registers |
fbb6670d9
|
297 298 |
* Set PWM registers to 33% Both */ |
1da177e4c
|
299 300 301 302 303 304 305 306 |
data->old_pwm[0] = data->pwm[0]; data->old_pwm[1] = data->pwm[1]; adm1031_write_value(client, ADM1031_REG_PWM, 0x55); } else { /* Switch to Manual Mode */ data->pwm[0] = data->old_pwm[0]; data->pwm[1] = data->old_pwm[1]; /* Restore PWM registers */ |
6d6006b8d
|
307 |
adm1031_write_value(client, ADM1031_REG_PWM, |
1da177e4c
|
308 309 310 311 312 |
data->pwm[0] | (data->pwm[1] << 4)); } } data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1); adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1); |
9a61bf630
|
313 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
314 315 |
return count; } |
c801082d7
|
316 317 318 319 |
static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR, show_fan_auto_channel, set_fan_auto_channel, 0); static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR, show_fan_auto_channel, set_fan_auto_channel, 1); |
1da177e4c
|
320 321 |
/* Auto Temps */ |
c801082d7
|
322 323 |
static ssize_t show_auto_temp_off(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
324 |
{ |
c801082d7
|
325 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
326 |
struct adm1031_data *data = adm1031_update_device(dev); |
6d6006b8d
|
327 328 |
return sprintf(buf, "%d ", |
1da177e4c
|
329 330 |
AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr])); } |
c801082d7
|
331 332 |
static ssize_t show_auto_temp_min(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
333 |
{ |
c801082d7
|
334 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
335 336 337 338 339 340 |
struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr])); } static ssize_t |
c801082d7
|
341 342 |
set_auto_temp_min(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
1da177e4c
|
343 344 345 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
c801082d7
|
346 |
int nr = to_sensor_dev_attr(attr)->index; |
1c720093f
|
347 348 349 350 351 352 |
long val; int ret; ret = kstrtol(buf, 10, &val); if (ret) return ret; |
1da177e4c
|
353 |
|
9a61bf630
|
354 |
mutex_lock(&data->update_lock); |
1da177e4c
|
355 356 357 |
data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]); adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr), data->auto_temp[nr]); |
9a61bf630
|
358 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
359 360 |
return count; } |
c801082d7
|
361 362 |
static ssize_t show_auto_temp_max(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
363 |
{ |
c801082d7
|
364 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
365 366 367 368 369 370 |
struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr])); } static ssize_t |
c801082d7
|
371 372 |
set_auto_temp_max(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
1da177e4c
|
373 374 375 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
c801082d7
|
376 |
int nr = to_sensor_dev_attr(attr)->index; |
1c720093f
|
377 378 379 380 381 382 |
long val; int ret; ret = kstrtol(buf, 10, &val); if (ret) return ret; |
1da177e4c
|
383 |
|
9a61bf630
|
384 |
mutex_lock(&data->update_lock); |
1c720093f
|
385 386 |
data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr], data->pwm[nr]); |
1da177e4c
|
387 388 |
adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr), data->temp_max[nr]); |
9a61bf630
|
389 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
390 391 |
return count; } |
c801082d7
|
392 393 394 395 396 397 398 |
#define auto_temp_reg(offset) \ static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \ show_auto_temp_off, NULL, offset - 1); \ static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \ show_auto_temp_min, set_auto_temp_min, offset - 1); \ static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \ show_auto_temp_max, set_auto_temp_max, offset - 1) |
1da177e4c
|
399 400 401 402 403 404 |
auto_temp_reg(1); auto_temp_reg(2); auto_temp_reg(3); /* pwm */ |
c801082d7
|
405 406 |
static ssize_t show_pwm(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
407 |
{ |
c801082d7
|
408 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
409 410 411 412 |
struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", PWM_FROM_REG(data->pwm[nr])); } |
c801082d7
|
413 414 |
static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
1da177e4c
|
415 416 417 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
c801082d7
|
418 |
int nr = to_sensor_dev_attr(attr)->index; |
1c720093f
|
419 420 421 422 423 424 |
long val; int ret, reg; ret = kstrtol(buf, 10, &val); if (ret) return ret; |
1da177e4c
|
425 |
|
9a61bf630
|
426 |
mutex_lock(&data->update_lock); |
6d6006b8d
|
427 |
if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) && |
1da177e4c
|
428 429 |
(((val>>4) & 0xf) != 5)) { /* In automatic mode, the only PWM accepted is 33% */ |
9a61bf630
|
430 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
431 432 433 434 435 436 437 |
return -EINVAL; } data->pwm[nr] = PWM_TO_REG(val); reg = adm1031_read_value(client, ADM1031_REG_PWM); adm1031_write_value(client, ADM1031_REG_PWM, nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf) : (data->pwm[nr] & 0xf) | (reg & 0xf0)); |
9a61bf630
|
438 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
439 440 |
return count; } |
c801082d7
|
441 442 443 444 445 446 |
static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0); static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1); static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0); static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1); |
1da177e4c
|
447 448 449 450 451 |
/* Fans */ /* * That function checks the cases where the fan reading is not |
44bbe87e9
|
452 |
* relevant. It is used to provide 0 as fan reading when the fan is |
1da177e4c
|
453 454 455 456 457 458 459 460 |
* not supposed to run */ static int trust_fan_readings(struct adm1031_data *data, int chan) { int res = 0; if (data->conf1 & ADM1031_CONF1_AUTO_MODE) { switch (data->conf1 & 0x60) { |
1c720093f
|
461 462 463 464 465 |
case 0x00: /* * remote temp1 controls fan1, * remote temp2 controls fan2 */ |
1da177e4c
|
466 |
res = data->temp[chan+1] >= |
1c720093f
|
467 |
AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]); |
1da177e4c
|
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 |
break; case 0x20: /* remote temp1 controls both fans */ res = data->temp[1] >= AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]); break; case 0x40: /* remote temp2 controls both fans */ res = data->temp[2] >= AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]); break; case 0x60: /* max controls both fans */ res = data->temp[0] >= AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0]) || data->temp[1] >= AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]) |
6d6006b8d
|
485 |
|| (data->chip_type == adm1031 |
1da177e4c
|
486 487 488 489 490 491 492 493 494 |
&& data->temp[2] >= AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2])); break; } } else { res = data->pwm[chan] > 0; } return res; } |
c801082d7
|
495 496 |
static ssize_t show_fan(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
497 |
{ |
c801082d7
|
498 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
499 500 501 502 503 504 505 506 |
struct adm1031_data *data = adm1031_update_device(dev); int value; value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr], FAN_DIV_FROM_REG(data->fan_div[nr])) : 0; return sprintf(buf, "%d ", value); } |
c801082d7
|
507 508 |
static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
509 |
{ |
c801082d7
|
510 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
511 512 513 514 |
struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", FAN_DIV_FROM_REG(data->fan_div[nr])); } |
c801082d7
|
515 516 |
static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
517 |
{ |
c801082d7
|
518 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
519 520 521 522 523 524 |
struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", FAN_FROM_REG(data->fan_min[nr], FAN_DIV_FROM_REG(data->fan_div[nr]))); } |
c801082d7
|
525 526 |
static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
1da177e4c
|
527 528 529 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
c801082d7
|
530 |
int nr = to_sensor_dev_attr(attr)->index; |
1c720093f
|
531 532 533 534 535 536 |
long val; int ret; ret = kstrtol(buf, 10, &val); if (ret) return ret; |
1da177e4c
|
537 |
|
9a61bf630
|
538 |
mutex_lock(&data->update_lock); |
1da177e4c
|
539 |
if (val) { |
6d6006b8d
|
540 |
data->fan_min[nr] = |
1da177e4c
|
541 542 543 544 545 |
FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr])); } else { data->fan_min[nr] = 0xff; } adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]); |
9a61bf630
|
546 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
547 548 |
return count; } |
c801082d7
|
549 550 |
static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
1da177e4c
|
551 552 553 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
c801082d7
|
554 |
int nr = to_sensor_dev_attr(attr)->index; |
1c720093f
|
555 |
long val; |
1da177e4c
|
556 557 558 |
u8 tmp; int old_div; int new_min; |
1c720093f
|
559 560 561 562 563 |
int ret; ret = kstrtol(buf, 10, &val); if (ret) return ret; |
1da177e4c
|
564 565 566 |
tmp = val == 8 ? 0xc0 : val == 4 ? 0x80 : |
6d6006b8d
|
567 568 |
val == 2 ? 0x40 : val == 1 ? 0x00 : |
1da177e4c
|
569 570 571 |
0xff; if (tmp == 0xff) return -EINVAL; |
6d6006b8d
|
572 |
|
9a61bf630
|
573 |
mutex_lock(&data->update_lock); |
38a1f0e9a
|
574 575 576 577 578 579 580 |
/* Get fresh readings */ data->fan_div[nr] = adm1031_read_value(client, ADM1031_REG_FAN_DIV(nr)); data->fan_min[nr] = adm1031_read_value(client, ADM1031_REG_FAN_MIN(nr)); /* Write the new clock divider and fan min */ |
1da177e4c
|
581 |
old_div = FAN_DIV_FROM_REG(data->fan_div[nr]); |
6d6006b8d
|
582 583 |
data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]); new_min = data->fan_min[nr] * old_div / val; |
1da177e4c
|
584 |
data->fan_min[nr] = new_min > 0xff ? 0xff : new_min; |
1da177e4c
|
585 |
|
6d6006b8d
|
586 |
adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr), |
1da177e4c
|
587 |
data->fan_div[nr]); |
6d6006b8d
|
588 |
adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), |
1da177e4c
|
589 |
data->fan_min[nr]); |
38a1f0e9a
|
590 591 592 |
/* Invalidate the cache: fan speed is no longer valid */ data->valid = 0; |
9a61bf630
|
593 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
594 595 596 597 |
return count; } #define fan_offset(offset) \ |
c801082d7
|
598 599 600 601 602 603 |
static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \ show_fan, NULL, offset - 1); \ static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ show_fan_min, set_fan_min, offset - 1); \ static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ show_fan_div, set_fan_div, offset - 1) |
1da177e4c
|
604 605 606 607 608 609 |
fan_offset(1); fan_offset(2); /* Temps */ |
c801082d7
|
610 611 |
static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
612 |
{ |
c801082d7
|
613 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
614 615 616 617 618 619 620 621 |
struct adm1031_data *data = adm1031_update_device(dev); int ext; ext = nr == 0 ? ((data->ext_temp[nr] >> 6) & 0x3) * 2 : (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7)); return sprintf(buf, "%d ", TEMP_FROM_REG_EXT(data->temp[nr], ext)); } |
49dc9efed
|
622 623 624 625 626 627 628 629 630 |
static ssize_t show_temp_offset(struct device *dev, struct device_attribute *attr, char *buf) { int nr = to_sensor_dev_attr(attr)->index; struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", TEMP_OFFSET_FROM_REG(data->temp_offset[nr])); } |
c801082d7
|
631 632 |
static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
633 |
{ |
c801082d7
|
634 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
635 636 637 638 |
struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", TEMP_FROM_REG(data->temp_min[nr])); } |
c801082d7
|
639 640 |
static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
641 |
{ |
c801082d7
|
642 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
643 644 645 646 |
struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", TEMP_FROM_REG(data->temp_max[nr])); } |
c801082d7
|
647 648 |
static ssize_t show_temp_crit(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
649 |
{ |
c801082d7
|
650 |
int nr = to_sensor_dev_attr(attr)->index; |
1da177e4c
|
651 652 653 654 |
struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", TEMP_FROM_REG(data->temp_crit[nr])); } |
49dc9efed
|
655 656 657 658 659 660 661 |
static ssize_t set_temp_offset(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); int nr = to_sensor_dev_attr(attr)->index; |
1c720093f
|
662 663 664 665 666 667 |
long val; int ret; ret = kstrtol(buf, 10, &val); if (ret) return ret; |
49dc9efed
|
668 |
|
49dc9efed
|
669 670 671 672 673 674 675 676 |
val = SENSORS_LIMIT(val, -15000, 15000); mutex_lock(&data->update_lock); data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val); adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr), data->temp_offset[nr]); mutex_unlock(&data->update_lock); return count; } |
c801082d7
|
677 678 |
static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
1da177e4c
|
679 680 681 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
c801082d7
|
682 |
int nr = to_sensor_dev_attr(attr)->index; |
1c720093f
|
683 684 685 686 687 688 |
long val; int ret; ret = kstrtol(buf, 10, &val); if (ret) return ret; |
1da177e4c
|
689 |
|
1da177e4c
|
690 |
val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); |
9a61bf630
|
691 |
mutex_lock(&data->update_lock); |
1da177e4c
|
692 693 694 |
data->temp_min[nr] = TEMP_TO_REG(val); adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr), data->temp_min[nr]); |
9a61bf630
|
695 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
696 697 |
return count; } |
c801082d7
|
698 699 |
static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
1da177e4c
|
700 701 702 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
c801082d7
|
703 |
int nr = to_sensor_dev_attr(attr)->index; |
1c720093f
|
704 705 706 707 708 709 |
long val; int ret; ret = kstrtol(buf, 10, &val); if (ret) return ret; |
1da177e4c
|
710 |
|
1da177e4c
|
711 |
val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); |
9a61bf630
|
712 |
mutex_lock(&data->update_lock); |
1da177e4c
|
713 714 715 |
data->temp_max[nr] = TEMP_TO_REG(val); adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr), data->temp_max[nr]); |
9a61bf630
|
716 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
717 718 |
return count; } |
c801082d7
|
719 720 |
static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
1da177e4c
|
721 722 723 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
c801082d7
|
724 |
int nr = to_sensor_dev_attr(attr)->index; |
1c720093f
|
725 726 727 728 729 730 |
long val; int ret; ret = kstrtol(buf, 10, &val); if (ret) return ret; |
1da177e4c
|
731 |
|
1da177e4c
|
732 |
val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); |
9a61bf630
|
733 |
mutex_lock(&data->update_lock); |
1da177e4c
|
734 735 736 |
data->temp_crit[nr] = TEMP_TO_REG(val); adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr), data->temp_crit[nr]); |
9a61bf630
|
737 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
738 739 |
return count; } |
c801082d7
|
740 741 742 |
#define temp_reg(offset) \ static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \ show_temp, NULL, offset - 1); \ |
49dc9efed
|
743 744 |
static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \ show_temp_offset, set_temp_offset, offset - 1); \ |
c801082d7
|
745 746 747 748 749 750 |
static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \ show_temp_min, set_temp_min, offset - 1); \ static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ show_temp_max, set_temp_max, offset - 1); \ static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \ show_temp_crit, set_temp_crit, offset - 1) |
1da177e4c
|
751 752 753 754 755 756 |
temp_reg(1); temp_reg(2); temp_reg(3); /* Alarms */ |
1c720093f
|
757 758 |
static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4c
|
759 760 761 762 763 764 765 |
{ struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", data->alarm); } static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); |
050ab8789
|
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 |
static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, char *buf) { int bitnr = to_sensor_dev_attr(attr)->index; struct adm1031_data *data = adm1031_update_device(dev); return sprintf(buf, "%d ", (data->alarm >> bitnr) & 1); } static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0); static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1); static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2); static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3); static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4); static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5); static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6); static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7); static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8); static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9); static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10); static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11); static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12); static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13); static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14); |
1da177e4c
|
790 |
|
a51b9944a
|
791 792 |
/* Update Interval */ static const unsigned int update_intervals[] = { |
87c33daad
|
793 794 |
16000, 8000, 4000, 2000, 1000, 500, 250, 125, }; |
a51b9944a
|
795 796 |
static ssize_t show_update_interval(struct device *dev, struct device_attribute *attr, char *buf) |
87c33daad
|
797 798 799 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
a51b9944a
|
800 801 |
return sprintf(buf, "%u ", data->update_interval); |
87c33daad
|
802 |
} |
a51b9944a
|
803 804 805 |
static ssize_t set_update_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
87c33daad
|
806 807 808 809 810 811 |
{ struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); unsigned long val; int i, err; u8 reg; |
179c4fdb5
|
812 |
err = kstrtoul(buf, 10, &val); |
87c33daad
|
813 814 |
if (err) return err; |
a51b9944a
|
815 816 817 818 819 820 |
/* * Find the nearest update interval from the table. * Use it to determine the matching update rate. */ for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) { if (val >= update_intervals[i]) |
87c33daad
|
821 822 |
break; } |
a51b9944a
|
823 |
/* if not found, we point to the last entry (lowest update interval) */ |
87c33daad
|
824 825 826 827 828 829 830 831 |
/* set the new update rate while preserving other settings */ reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER); reg &= ~ADM1031_UPDATE_RATE_MASK; reg |= i << ADM1031_UPDATE_RATE_SHIFT; adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg); mutex_lock(&data->update_lock); |
a51b9944a
|
832 |
data->update_interval = update_intervals[i]; |
87c33daad
|
833 834 835 836 |
mutex_unlock(&data->update_lock); return count; } |
a51b9944a
|
837 838 |
static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval, set_update_interval); |
87c33daad
|
839 |
|
681c6f7a6
|
840 |
static struct attribute *adm1031_attributes[] = { |
c801082d7
|
841 842 843 |
&sensor_dev_attr_fan1_input.dev_attr.attr, &sensor_dev_attr_fan1_div.dev_attr.attr, &sensor_dev_attr_fan1_min.dev_attr.attr, |
050ab8789
|
844 845 |
&sensor_dev_attr_fan1_alarm.dev_attr.attr, &sensor_dev_attr_fan1_fault.dev_attr.attr, |
c801082d7
|
846 847 848 |
&sensor_dev_attr_pwm1.dev_attr.attr, &sensor_dev_attr_auto_fan1_channel.dev_attr.attr, &sensor_dev_attr_temp1_input.dev_attr.attr, |
49dc9efed
|
849 |
&sensor_dev_attr_temp1_offset.dev_attr.attr, |
c801082d7
|
850 |
&sensor_dev_attr_temp1_min.dev_attr.attr, |
050ab8789
|
851 |
&sensor_dev_attr_temp1_min_alarm.dev_attr.attr, |
c801082d7
|
852 |
&sensor_dev_attr_temp1_max.dev_attr.attr, |
050ab8789
|
853 |
&sensor_dev_attr_temp1_max_alarm.dev_attr.attr, |
c801082d7
|
854 |
&sensor_dev_attr_temp1_crit.dev_attr.attr, |
050ab8789
|
855 |
&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, |
c801082d7
|
856 |
&sensor_dev_attr_temp2_input.dev_attr.attr, |
49dc9efed
|
857 |
&sensor_dev_attr_temp2_offset.dev_attr.attr, |
c801082d7
|
858 |
&sensor_dev_attr_temp2_min.dev_attr.attr, |
050ab8789
|
859 |
&sensor_dev_attr_temp2_min_alarm.dev_attr.attr, |
c801082d7
|
860 |
&sensor_dev_attr_temp2_max.dev_attr.attr, |
050ab8789
|
861 |
&sensor_dev_attr_temp2_max_alarm.dev_attr.attr, |
c801082d7
|
862 |
&sensor_dev_attr_temp2_crit.dev_attr.attr, |
050ab8789
|
863 864 |
&sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, &sensor_dev_attr_temp2_fault.dev_attr.attr, |
c801082d7
|
865 866 867 868 869 870 871 872 873 874 |
&sensor_dev_attr_auto_temp1_off.dev_attr.attr, &sensor_dev_attr_auto_temp1_min.dev_attr.attr, &sensor_dev_attr_auto_temp1_max.dev_attr.attr, &sensor_dev_attr_auto_temp2_off.dev_attr.attr, &sensor_dev_attr_auto_temp2_min.dev_attr.attr, &sensor_dev_attr_auto_temp2_max.dev_attr.attr, &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr, |
681c6f7a6
|
875 |
|
a51b9944a
|
876 |
&dev_attr_update_interval.attr, |
681c6f7a6
|
877 878 879 880 881 882 883 884 885 886 |
&dev_attr_alarms.attr, NULL }; static const struct attribute_group adm1031_group = { .attrs = adm1031_attributes, }; static struct attribute *adm1031_attributes_opt[] = { |
c801082d7
|
887 888 889 |
&sensor_dev_attr_fan2_input.dev_attr.attr, &sensor_dev_attr_fan2_div.dev_attr.attr, &sensor_dev_attr_fan2_min.dev_attr.attr, |
050ab8789
|
890 891 |
&sensor_dev_attr_fan2_alarm.dev_attr.attr, &sensor_dev_attr_fan2_fault.dev_attr.attr, |
c801082d7
|
892 893 894 |
&sensor_dev_attr_pwm2.dev_attr.attr, &sensor_dev_attr_auto_fan2_channel.dev_attr.attr, &sensor_dev_attr_temp3_input.dev_attr.attr, |
49dc9efed
|
895 |
&sensor_dev_attr_temp3_offset.dev_attr.attr, |
c801082d7
|
896 |
&sensor_dev_attr_temp3_min.dev_attr.attr, |
050ab8789
|
897 |
&sensor_dev_attr_temp3_min_alarm.dev_attr.attr, |
c801082d7
|
898 |
&sensor_dev_attr_temp3_max.dev_attr.attr, |
050ab8789
|
899 |
&sensor_dev_attr_temp3_max_alarm.dev_attr.attr, |
c801082d7
|
900 |
&sensor_dev_attr_temp3_crit.dev_attr.attr, |
050ab8789
|
901 902 |
&sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, &sensor_dev_attr_temp3_fault.dev_attr.attr, |
c801082d7
|
903 904 905 906 |
&sensor_dev_attr_auto_temp3_off.dev_attr.attr, &sensor_dev_attr_auto_temp3_min.dev_attr.attr, &sensor_dev_attr_auto_temp3_max.dev_attr.attr, &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr, |
681c6f7a6
|
907 908 909 910 911 912 |
NULL }; static const struct attribute_group adm1031_group_opt = { .attrs = adm1031_attributes_opt, }; |
af200f881
|
913 |
/* Return 0 if detection is successful, -ENODEV otherwise */ |
310ec7921
|
914 |
static int adm1031_detect(struct i2c_client *client, |
af200f881
|
915 |
struct i2c_board_info *info) |
1da177e4c
|
916 |
{ |
af200f881
|
917 |
struct i2c_adapter *adapter = client->adapter; |
52df6440a
|
918 919 |
const char *name; int id, co; |
1da177e4c
|
920 921 |
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) |
af200f881
|
922 |
return -ENODEV; |
1da177e4c
|
923 |
|
52df6440a
|
924 925 |
id = i2c_smbus_read_byte_data(client, 0x3d); co = i2c_smbus_read_byte_data(client, 0x3e); |
1da177e4c
|
926 |
|
52df6440a
|
927 928 929 |
if (!((id == 0x31 || id == 0x30) && co == 0x41)) return -ENODEV; name = (id == 0x30) ? "adm1030" : "adm1031"; |
1da177e4c
|
930 |
|
af200f881
|
931 |
strlcpy(info->type, name, I2C_NAME_SIZE); |
1da177e4c
|
932 |
|
af200f881
|
933 934 935 936 937 938 939 940 |
return 0; } static int adm1031_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct adm1031_data *data; int err; |
dc2fd6632
|
941 942 943 944 |
data = devm_kzalloc(&client->dev, sizeof(struct adm1031_data), GFP_KERNEL); if (!data) return -ENOMEM; |
af200f881
|
945 946 947 |
i2c_set_clientdata(client, data); data->chip_type = id->driver_data; |
9a61bf630
|
948 |
mutex_init(&data->update_lock); |
1da177e4c
|
949 |
|
af200f881
|
950 951 952 953 |
if (data->chip_type == adm1030) data->chan_select_table = &auto_channel_select_table_adm1030; else data->chan_select_table = &auto_channel_select_table_adm1031; |
1da177e4c
|
954 955 |
/* Initialize the ADM1031 chip */ |
6d6006b8d
|
956 |
adm1031_init_client(client); |
1da177e4c
|
957 958 |
/* Register sysfs hooks */ |
1c720093f
|
959 960 |
err = sysfs_create_group(&client->dev.kobj, &adm1031_group); if (err) |
dc2fd6632
|
961 |
return err; |
1da177e4c
|
962 |
|
af200f881
|
963 |
if (data->chip_type == adm1031) { |
1c720093f
|
964 965 |
err = sysfs_create_group(&client->dev.kobj, &adm1031_group_opt); if (err) |
681c6f7a6
|
966 967 |
goto exit_remove; } |
6d6006b8d
|
968 |
data->hwmon_dev = hwmon_device_register(&client->dev); |
1beeffe43
|
969 970 |
if (IS_ERR(data->hwmon_dev)) { err = PTR_ERR(data->hwmon_dev); |
681c6f7a6
|
971 |
goto exit_remove; |
1da177e4c
|
972 973 974 |
} return 0; |
681c6f7a6
|
975 |
exit_remove: |
6d6006b8d
|
976 977 |
sysfs_remove_group(&client->dev.kobj, &adm1031_group); sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt); |
1da177e4c
|
978 979 |
return err; } |
af200f881
|
980 |
static int adm1031_remove(struct i2c_client *client) |
1da177e4c
|
981 |
{ |
943b0830c
|
982 |
struct adm1031_data *data = i2c_get_clientdata(client); |
943b0830c
|
983 |
|
1beeffe43
|
984 |
hwmon_device_unregister(data->hwmon_dev); |
681c6f7a6
|
985 986 |
sysfs_remove_group(&client->dev.kobj, &adm1031_group); sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt); |
1da177e4c
|
987 988 989 990 991 992 993 |
return 0; } static void adm1031_init_client(struct i2c_client *client) { unsigned int read_val; unsigned int mask; |
87c33daad
|
994 |
int i; |
1da177e4c
|
995 996 997 998 999 1000 |
struct adm1031_data *data = i2c_get_clientdata(client); mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE); if (data->chip_type == adm1031) { mask |= (ADM1031_CONF2_PWM2_ENABLE | ADM1031_CONF2_TACH2_ENABLE); |
6d6006b8d
|
1001 |
} |
1da177e4c
|
1002 1003 |
/* Initialize the ADM1031 chip (enables fan speed reading ) */ read_val = adm1031_read_value(client, ADM1031_REG_CONF2); |
1c720093f
|
1004 1005 |
if ((read_val | mask) != read_val) adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask); |
1da177e4c
|
1006 1007 1008 |
read_val = adm1031_read_value(client, ADM1031_REG_CONF1); if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) { |
1c720093f
|
1009 1010 |
adm1031_write_value(client, ADM1031_REG_CONF1, read_val | ADM1031_CONF1_MONITOR_ENABLE); |
1da177e4c
|
1011 |
} |
87c33daad
|
1012 1013 1014 1015 |
/* Read the chip's update rate */ mask = ADM1031_UPDATE_RATE_MASK; read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER); i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT; |
a51b9944a
|
1016 1017 |
/* Save it as update interval */ data->update_interval = update_intervals[i]; |
1da177e4c
|
1018 1019 1020 1021 1022 1023 |
} static struct adm1031_data *adm1031_update_device(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct adm1031_data *data = i2c_get_clientdata(client); |
87c33daad
|
1024 |
unsigned long next_update; |
1da177e4c
|
1025 |
int chan; |
9a61bf630
|
1026 |
mutex_lock(&data->update_lock); |
1da177e4c
|
1027 |
|
a51b9944a
|
1028 1029 |
next_update = data->last_updated + msecs_to_jiffies(data->update_interval); |
87c33daad
|
1030 |
if (time_after(jiffies, next_update) || !data->valid) { |
1da177e4c
|
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 |
dev_dbg(&client->dev, "Starting adm1031 update "); for (chan = 0; chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) { u8 oldh, newh; oldh = adm1031_read_value(client, ADM1031_REG_TEMP(chan)); data->ext_temp[chan] = adm1031_read_value(client, ADM1031_REG_EXT_TEMP); newh = adm1031_read_value(client, ADM1031_REG_TEMP(chan)); if (newh != oldh) { data->ext_temp[chan] = adm1031_read_value(client, ADM1031_REG_EXT_TEMP); #ifdef DEBUG oldh = adm1031_read_value(client, ADM1031_REG_TEMP(chan)); /* oldh is actually newer */ if (newh != oldh) dev_warn(&client->dev, |
1c720093f
|
1056 1057 |
"Remote temperature may be wrong. "); |
1da177e4c
|
1058 1059 1060 |
#endif } data->temp[chan] = newh; |
49dc9efed
|
1061 1062 1063 |
data->temp_offset[chan] = adm1031_read_value(client, ADM1031_REG_TEMP_OFFSET(chan)); |
1da177e4c
|
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 |
data->temp_min[chan] = adm1031_read_value(client, ADM1031_REG_TEMP_MIN(chan)); data->temp_max[chan] = adm1031_read_value(client, ADM1031_REG_TEMP_MAX(chan)); data->temp_crit[chan] = adm1031_read_value(client, ADM1031_REG_TEMP_CRIT(chan)); data->auto_temp[chan] = adm1031_read_value(client, ADM1031_REG_AUTO_TEMP(chan)); } data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1); data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2); data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0)) |
1c720093f
|
1083 1084 |
| (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8); if (data->chip_type == adm1030) |
1da177e4c
|
1085 |
data->alarm &= 0xc0ff; |
6d6006b8d
|
1086 |
|
1c720093f
|
1087 1088 |
for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2); chan++) { |
1da177e4c
|
1089 |
data->fan_div[chan] = |
1c720093f
|
1090 1091 |
adm1031_read_value(client, ADM1031_REG_FAN_DIV(chan)); |
1da177e4c
|
1092 |
data->fan_min[chan] = |
1c720093f
|
1093 1094 |
adm1031_read_value(client, ADM1031_REG_FAN_MIN(chan)); |
1da177e4c
|
1095 |
data->fan[chan] = |
1c720093f
|
1096 1097 |
adm1031_read_value(client, ADM1031_REG_FAN_SPEED(chan)); |
1da177e4c
|
1098 |
data->pwm[chan] = |
1c720093f
|
1099 1100 |
(adm1031_read_value(client, ADM1031_REG_PWM) >> (4 * chan)) & 0x0f; |
1da177e4c
|
1101 1102 1103 1104 |
} data->last_updated = jiffies; data->valid = 1; } |
9a61bf630
|
1105 |
mutex_unlock(&data->update_lock); |
1da177e4c
|
1106 1107 1108 |
return data; } |
f0967eea8
|
1109 |
module_i2c_driver(adm1031_driver); |
1da177e4c
|
1110 1111 1112 1113 |
MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>"); MODULE_DESCRIPTION("ADM1031/ADM1030 driver"); MODULE_LICENSE("GPL"); |