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