1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * adm9240.c Part of lm_sensors, Linux kernel modules for hardware |
4 | * monitoring |
5 | * |
6 | * Copyright (C) 1999 Frodo Looijaard <frodol@dds.nl> |
7 | * Philip Edelbrock <phil@netroedge.com> |
8 | * Copyright (C) 2003 Michiel Rook <michiel@grendelproject.nl> |
9 | * Copyright (C) 2005 Grant Coady <gcoady.lk@gmail.com> with valuable |
10 | * guidance from Jean Delvare |
11 | * |
12 | * Driver supports Analog Devices ADM9240 |
13 | * Dallas Semiconductor DS1780 |
14 | * National Semiconductor LM81 |
15 | * |
16 | * ADM9240 is the reference, DS1780 and LM81 are register compatibles |
17 | * |
18 | * Voltage Six inputs are scaled by chip, VID also reported |
19 | * Temperature Chip temperature to 0.5'C, maximum and max_hysteris |
20 | * Fans 2 fans, low speed alarm, automatic fan clock divider |
21 | * Alarms 16-bit map of active alarms |
22 | * Analog Out 0..1250 mV output |
23 | * |
24 | * Chassis Intrusion: clear CI latch with 'echo 0 > intrusion0_alarm' |
25 | * |
26 | * Test hardware: Intel SE440BX-2 desktop motherboard --Grant |
27 | * |
28 | * LM81 extended temp reading not implemented |
29 | */ |
30 | |
31 | #include <linux/bits.h> |
32 | #include <linux/init.h> |
33 | #include <linux/module.h> |
34 | #include <linux/slab.h> |
35 | #include <linux/i2c.h> |
36 | #include <linux/hwmon-sysfs.h> |
37 | #include <linux/hwmon.h> |
38 | #include <linux/hwmon-vid.h> |
39 | #include <linux/err.h> |
40 | #include <linux/mutex.h> |
41 | #include <linux/regmap.h> |
42 | |
43 | /* Addresses to scan */ |
44 | static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, |
45 | I2C_CLIENT_END }; |
46 | |
47 | enum chips { adm9240, ds1780, lm81 }; |
48 | |
49 | /* ADM9240 registers */ |
50 | #define ADM9240_REG_MAN_ID 0x3e |
51 | #define ADM9240_REG_DIE_REV 0x3f |
52 | #define ADM9240_REG_CONFIG 0x40 |
53 | |
54 | #define ADM9240_REG_IN(nr) (0x20 + (nr)) /* 0..5 */ |
55 | #define ADM9240_REG_IN_MAX(nr) (0x2b + (nr) * 2) |
56 | #define ADM9240_REG_IN_MIN(nr) (0x2c + (nr) * 2) |
57 | #define ADM9240_REG_FAN(nr) (0x28 + (nr)) /* 0..1 */ |
58 | #define ADM9240_REG_FAN_MIN(nr) (0x3b + (nr)) |
59 | #define ADM9240_REG_INT(nr) (0x41 + (nr)) |
60 | #define ADM9240_REG_INT_MASK(nr) (0x43 + (nr)) |
61 | #define ADM9240_REG_TEMP 0x27 |
62 | #define ADM9240_REG_TEMP_MAX(nr) (0x39 + (nr)) /* 0, 1 = high, hyst */ |
63 | #define ADM9240_REG_ANALOG_OUT 0x19 |
64 | #define ADM9240_REG_CHASSIS_CLEAR 0x46 |
65 | #define ADM9240_REG_VID_FAN_DIV 0x47 |
66 | #define ADM9240_REG_I2C_ADDR 0x48 |
67 | #define ADM9240_REG_VID4 0x49 |
68 | #define ADM9240_REG_TEMP_CONF 0x4b |
69 | |
70 | /* generalised scaling with integer rounding */ |
71 | static inline int SCALE(long val, int mul, int div) |
72 | { |
73 | if (val < 0) |
74 | return (val * mul - div / 2) / div; |
75 | else |
76 | return (val * mul + div / 2) / div; |
77 | } |
78 | |
79 | /* adm9240 internally scales voltage measurements */ |
80 | static const u16 nom_mv[] = { 2500, 2700, 3300, 5000, 12000, 2700 }; |
81 | |
82 | static inline unsigned int IN_FROM_REG(u8 reg, int n) |
83 | { |
84 | return SCALE(val: reg, mul: nom_mv[n], div: 192); |
85 | } |
86 | |
87 | static inline u8 IN_TO_REG(unsigned long val, int n) |
88 | { |
89 | val = clamp_val(val, 0, nom_mv[n] * 255 / 192); |
90 | return SCALE(val, mul: 192, div: nom_mv[n]); |
91 | } |
92 | |
93 | /* temperature range: -40..125, 127 disables temperature alarm */ |
94 | static inline s8 TEMP_TO_REG(long val) |
95 | { |
96 | val = clamp_val(val, -40000, 127000); |
97 | return SCALE(val, mul: 1, div: 1000); |
98 | } |
99 | |
100 | /* two fans, each with low fan speed limit */ |
101 | static inline unsigned int FAN_FROM_REG(u8 reg, u8 div) |
102 | { |
103 | if (!reg) /* error */ |
104 | return -1; |
105 | |
106 | if (reg == 255) |
107 | return 0; |
108 | |
109 | return SCALE(val: 1350000, mul: 1, div: reg * div); |
110 | } |
111 | |
112 | /* analog out 0..1250mV */ |
113 | static inline u8 AOUT_TO_REG(unsigned long val) |
114 | { |
115 | val = clamp_val(val, 0, 1250); |
116 | return SCALE(val, mul: 255, div: 1250); |
117 | } |
118 | |
119 | static inline unsigned int AOUT_FROM_REG(u8 reg) |
120 | { |
121 | return SCALE(val: reg, mul: 1250, div: 255); |
122 | } |
123 | |
124 | /* per client data */ |
125 | struct adm9240_data { |
126 | struct device *dev; |
127 | struct regmap *regmap; |
128 | struct mutex update_lock; |
129 | |
130 | u8 fan_div[2]; /* rw fan1_div, read-only accessor */ |
131 | u8 vrm; /* -- vrm set on startup, no accessor */ |
132 | }; |
133 | |
134 | /* write new fan div, callers must hold data->update_lock */ |
135 | static int adm9240_write_fan_div(struct adm9240_data *data, int channel, u8 fan_div) |
136 | { |
137 | unsigned int reg, old, shift = (channel + 2) * 2; |
138 | int err; |
139 | |
140 | err = regmap_read(map: data->regmap, ADM9240_REG_VID_FAN_DIV, val: ®); |
141 | if (err < 0) |
142 | return err; |
143 | old = (reg >> shift) & 3; |
144 | reg &= ~(3 << shift); |
145 | reg |= (fan_div << shift); |
146 | err = regmap_write(map: data->regmap, ADM9240_REG_VID_FAN_DIV, val: reg); |
147 | if (err < 0) |
148 | return err; |
149 | dev_dbg(data->dev, |
150 | "fan%d clock divider changed from %lu to %lu\n" , |
151 | channel + 1, BIT(old), BIT(fan_div)); |
152 | |
153 | return 0; |
154 | } |
155 | |
156 | /* |
157 | * set fan speed low limit: |
158 | * |
159 | * - value is zero: disable fan speed low limit alarm |
160 | * |
161 | * - value is below fan speed measurement range: enable fan speed low |
162 | * limit alarm to be asserted while fan speed too slow to measure |
163 | * |
164 | * - otherwise: select fan clock divider to suit fan speed low limit, |
165 | * measurement code may adjust registers to ensure fan speed reading |
166 | */ |
167 | static int adm9240_fan_min_write(struct adm9240_data *data, int channel, long val) |
168 | { |
169 | u8 new_div; |
170 | u8 fan_min; |
171 | int err; |
172 | |
173 | mutex_lock(&data->update_lock); |
174 | |
175 | if (!val) { |
176 | fan_min = 255; |
177 | new_div = data->fan_div[channel]; |
178 | |
179 | dev_dbg(data->dev, "fan%u low limit set disabled\n" , channel + 1); |
180 | } else if (val < 1350000 / (8 * 254)) { |
181 | new_div = 3; |
182 | fan_min = 254; |
183 | |
184 | dev_dbg(data->dev, "fan%u low limit set minimum %u\n" , |
185 | channel + 1, FAN_FROM_REG(254, BIT(new_div))); |
186 | } else { |
187 | unsigned int new_min = 1350000 / val; |
188 | |
189 | new_div = 0; |
190 | while (new_min > 192 && new_div < 3) { |
191 | new_div++; |
192 | new_min /= 2; |
193 | } |
194 | if (!new_min) /* keep > 0 */ |
195 | new_min++; |
196 | |
197 | fan_min = new_min; |
198 | |
199 | dev_dbg(data->dev, "fan%u low limit set fan speed %u\n" , |
200 | channel + 1, FAN_FROM_REG(new_min, BIT(new_div))); |
201 | } |
202 | |
203 | if (new_div != data->fan_div[channel]) { |
204 | data->fan_div[channel] = new_div; |
205 | adm9240_write_fan_div(data, channel, fan_div: new_div); |
206 | } |
207 | err = regmap_write(map: data->regmap, ADM9240_REG_FAN_MIN(channel), val: fan_min); |
208 | |
209 | mutex_unlock(lock: &data->update_lock); |
210 | |
211 | return err; |
212 | } |
213 | |
214 | static ssize_t cpu0_vid_show(struct device *dev, |
215 | struct device_attribute *attr, char *buf) |
216 | { |
217 | struct adm9240_data *data = dev_get_drvdata(dev); |
218 | unsigned int regval; |
219 | int err; |
220 | u8 vid; |
221 | |
222 | err = regmap_read(map: data->regmap, ADM9240_REG_VID_FAN_DIV, val: ®val); |
223 | if (err < 0) |
224 | return err; |
225 | vid = regval & 0x0f; |
226 | err = regmap_read(map: data->regmap, ADM9240_REG_VID4, val: ®val); |
227 | if (err < 0) |
228 | return err; |
229 | vid |= (regval & 1) << 4; |
230 | return sprintf(buf, fmt: "%d\n" , vid_from_reg(val: vid, vrm: data->vrm)); |
231 | } |
232 | static DEVICE_ATTR_RO(cpu0_vid); |
233 | |
234 | static ssize_t aout_output_show(struct device *dev, |
235 | struct device_attribute *attr, char *buf) |
236 | { |
237 | struct adm9240_data *data = dev_get_drvdata(dev); |
238 | unsigned int regval; |
239 | int err; |
240 | |
241 | err = regmap_read(map: data->regmap, ADM9240_REG_ANALOG_OUT, val: ®val); |
242 | if (err) |
243 | return err; |
244 | |
245 | return sprintf(buf, fmt: "%d\n" , AOUT_FROM_REG(reg: regval)); |
246 | } |
247 | |
248 | static ssize_t aout_output_store(struct device *dev, |
249 | struct device_attribute *attr, |
250 | const char *buf, size_t count) |
251 | { |
252 | struct adm9240_data *data = dev_get_drvdata(dev); |
253 | long val; |
254 | int err; |
255 | |
256 | err = kstrtol(s: buf, base: 10, res: &val); |
257 | if (err) |
258 | return err; |
259 | |
260 | err = regmap_write(map: data->regmap, ADM9240_REG_ANALOG_OUT, val: AOUT_TO_REG(val)); |
261 | return err < 0 ? err : count; |
262 | } |
263 | static DEVICE_ATTR_RW(aout_output); |
264 | |
265 | static struct attribute *adm9240_attrs[] = { |
266 | &dev_attr_aout_output.attr, |
267 | &dev_attr_cpu0_vid.attr, |
268 | NULL |
269 | }; |
270 | |
271 | ATTRIBUTE_GROUPS(adm9240); |
272 | |
273 | /*** sensor chip detect and driver install ***/ |
274 | |
275 | /* Return 0 if detection is successful, -ENODEV otherwise */ |
276 | static int adm9240_detect(struct i2c_client *new_client, |
277 | struct i2c_board_info *info) |
278 | { |
279 | struct i2c_adapter *adapter = new_client->adapter; |
280 | const char *name = "" ; |
281 | int address = new_client->addr; |
282 | u8 man_id, die_rev; |
283 | |
284 | if (!i2c_check_functionality(adap: adapter, I2C_FUNC_SMBUS_BYTE_DATA)) |
285 | return -ENODEV; |
286 | |
287 | /* verify chip: reg address should match i2c address */ |
288 | if (i2c_smbus_read_byte_data(client: new_client, ADM9240_REG_I2C_ADDR) != address) |
289 | return -ENODEV; |
290 | |
291 | /* check known chip manufacturer */ |
292 | man_id = i2c_smbus_read_byte_data(client: new_client, ADM9240_REG_MAN_ID); |
293 | if (man_id == 0x23) |
294 | name = "adm9240" ; |
295 | else if (man_id == 0xda) |
296 | name = "ds1780" ; |
297 | else if (man_id == 0x01) |
298 | name = "lm81" ; |
299 | else |
300 | return -ENODEV; |
301 | |
302 | /* successful detect, print chip info */ |
303 | die_rev = i2c_smbus_read_byte_data(client: new_client, ADM9240_REG_DIE_REV); |
304 | dev_info(&adapter->dev, "found %s revision %u\n" , |
305 | man_id == 0x23 ? "ADM9240" : |
306 | man_id == 0xda ? "DS1780" : "LM81" , die_rev); |
307 | |
308 | strscpy(info->type, name, I2C_NAME_SIZE); |
309 | |
310 | return 0; |
311 | } |
312 | |
313 | static int adm9240_init_client(struct adm9240_data *data) |
314 | { |
315 | unsigned int regval; |
316 | u8 conf, mode; |
317 | int err; |
318 | |
319 | err = regmap_raw_read(map: data->regmap, ADM9240_REG_CONFIG, val: &conf, val_len: 1); |
320 | if (err < 0) |
321 | return err; |
322 | err = regmap_raw_read(map: data->regmap, ADM9240_REG_TEMP_CONF, val: &mode, val_len: 1); |
323 | if (err < 0) |
324 | return err; |
325 | mode &= 3; |
326 | |
327 | data->vrm = vid_which_vrm(); /* need this to report vid as mV */ |
328 | |
329 | dev_info(data->dev, "Using VRM: %d.%d\n" , data->vrm / 10, |
330 | data->vrm % 10); |
331 | |
332 | if (conf & 1) { /* measurement cycle running: report state */ |
333 | |
334 | dev_info(data->dev, "status: config 0x%02x mode %u\n" , |
335 | conf, mode); |
336 | |
337 | } else { /* cold start: open limits before starting chip */ |
338 | int i; |
339 | |
340 | for (i = 0; i < 6; i++) { |
341 | err = regmap_write(map: data->regmap, |
342 | ADM9240_REG_IN_MIN(i), val: 0); |
343 | if (err < 0) |
344 | return err; |
345 | err = regmap_write(map: data->regmap, |
346 | ADM9240_REG_IN_MAX(i), val: 255); |
347 | if (err < 0) |
348 | return err; |
349 | } |
350 | for (i = 0; i < 2; i++) { |
351 | err = regmap_write(map: data->regmap, |
352 | ADM9240_REG_FAN_MIN(i), val: 255); |
353 | if (err < 0) |
354 | return err; |
355 | } |
356 | for (i = 0; i < 2; i++) { |
357 | err = regmap_write(map: data->regmap, |
358 | ADM9240_REG_TEMP_MAX(i), val: 127); |
359 | if (err < 0) |
360 | return err; |
361 | } |
362 | |
363 | /* start measurement cycle */ |
364 | err = regmap_write(map: data->regmap, ADM9240_REG_CONFIG, val: 1); |
365 | if (err < 0) |
366 | return err; |
367 | |
368 | dev_info(data->dev, |
369 | "cold start: config was 0x%02x mode %u\n" , conf, mode); |
370 | } |
371 | |
372 | /* read fan divs */ |
373 | err = regmap_read(map: data->regmap, ADM9240_REG_VID_FAN_DIV, val: ®val); |
374 | if (err < 0) |
375 | return err; |
376 | data->fan_div[0] = (regval >> 4) & 3; |
377 | data->fan_div[1] = (regval >> 6) & 3; |
378 | return 0; |
379 | } |
380 | |
381 | static int adm9240_chip_read(struct device *dev, u32 attr, long *val) |
382 | { |
383 | struct adm9240_data *data = dev_get_drvdata(dev); |
384 | u8 regs[2]; |
385 | int err; |
386 | |
387 | switch (attr) { |
388 | case hwmon_chip_alarms: |
389 | err = regmap_bulk_read(map: data->regmap, ADM9240_REG_INT(0), val: ®s, val_count: 2); |
390 | if (err < 0) |
391 | return err; |
392 | *val = regs[0] | regs[1] << 8; |
393 | break; |
394 | default: |
395 | return -EOPNOTSUPP; |
396 | } |
397 | return 0; |
398 | } |
399 | |
400 | static int adm9240_intrusion_read(struct device *dev, u32 attr, long *val) |
401 | { |
402 | struct adm9240_data *data = dev_get_drvdata(dev); |
403 | unsigned int regval; |
404 | int err; |
405 | |
406 | switch (attr) { |
407 | case hwmon_intrusion_alarm: |
408 | err = regmap_read(map: data->regmap, ADM9240_REG_INT(1), val: ®val); |
409 | if (err < 0) |
410 | return err; |
411 | *val = !!(regval & BIT(4)); |
412 | break; |
413 | default: |
414 | return -EOPNOTSUPP; |
415 | } |
416 | return 0; |
417 | } |
418 | |
419 | static int adm9240_intrusion_write(struct device *dev, u32 attr, long val) |
420 | { |
421 | struct adm9240_data *data = dev_get_drvdata(dev); |
422 | int err; |
423 | |
424 | switch (attr) { |
425 | case hwmon_intrusion_alarm: |
426 | if (val) |
427 | return -EINVAL; |
428 | err = regmap_write(map: data->regmap, ADM9240_REG_CHASSIS_CLEAR, val: 0x80); |
429 | if (err < 0) |
430 | return err; |
431 | dev_dbg(data->dev, "chassis intrusion latch cleared\n" ); |
432 | break; |
433 | default: |
434 | return -EOPNOTSUPP; |
435 | } |
436 | return 0; |
437 | } |
438 | |
439 | static int adm9240_in_read(struct device *dev, u32 attr, int channel, long *val) |
440 | { |
441 | struct adm9240_data *data = dev_get_drvdata(dev); |
442 | unsigned int regval; |
443 | int reg; |
444 | int err; |
445 | |
446 | switch (attr) { |
447 | case hwmon_in_input: |
448 | reg = ADM9240_REG_IN(channel); |
449 | break; |
450 | case hwmon_in_min: |
451 | reg = ADM9240_REG_IN_MIN(channel); |
452 | break; |
453 | case hwmon_in_max: |
454 | reg = ADM9240_REG_IN_MAX(channel); |
455 | break; |
456 | case hwmon_in_alarm: |
457 | if (channel < 4) { |
458 | reg = ADM9240_REG_INT(0); |
459 | } else { |
460 | reg = ADM9240_REG_INT(1); |
461 | channel -= 4; |
462 | } |
463 | err = regmap_read(map: data->regmap, reg, val: ®val); |
464 | if (err < 0) |
465 | return err; |
466 | *val = !!(regval & BIT(channel)); |
467 | return 0; |
468 | default: |
469 | return -EOPNOTSUPP; |
470 | } |
471 | err = regmap_read(map: data->regmap, reg, val: ®val); |
472 | if (err < 0) |
473 | return err; |
474 | *val = IN_FROM_REG(reg: regval, n: channel); |
475 | return 0; |
476 | } |
477 | |
478 | static int adm9240_in_write(struct device *dev, u32 attr, int channel, long val) |
479 | { |
480 | struct adm9240_data *data = dev_get_drvdata(dev); |
481 | int reg; |
482 | |
483 | switch (attr) { |
484 | case hwmon_in_min: |
485 | reg = ADM9240_REG_IN_MIN(channel); |
486 | break; |
487 | case hwmon_in_max: |
488 | reg = ADM9240_REG_IN_MAX(channel); |
489 | break; |
490 | default: |
491 | return -EOPNOTSUPP; |
492 | } |
493 | return regmap_write(map: data->regmap, reg, val: IN_TO_REG(val, n: channel)); |
494 | } |
495 | |
496 | static int adm9240_fan_read(struct device *dev, u32 attr, int channel, long *val) |
497 | { |
498 | struct adm9240_data *data = dev_get_drvdata(dev); |
499 | unsigned int regval; |
500 | int err; |
501 | |
502 | switch (attr) { |
503 | case hwmon_fan_input: |
504 | mutex_lock(&data->update_lock); |
505 | err = regmap_read(map: data->regmap, ADM9240_REG_FAN(channel), val: ®val); |
506 | if (err < 0) { |
507 | mutex_unlock(lock: &data->update_lock); |
508 | return err; |
509 | } |
510 | if (regval == 255 && data->fan_div[channel] < 3) { |
511 | /* adjust fan clock divider on overflow */ |
512 | err = adm9240_write_fan_div(data, channel, |
513 | fan_div: ++data->fan_div[channel]); |
514 | if (err) { |
515 | mutex_unlock(lock: &data->update_lock); |
516 | return err; |
517 | } |
518 | } |
519 | *val = FAN_FROM_REG(reg: regval, BIT(data->fan_div[channel])); |
520 | mutex_unlock(lock: &data->update_lock); |
521 | break; |
522 | case hwmon_fan_div: |
523 | *val = BIT(data->fan_div[channel]); |
524 | break; |
525 | case hwmon_fan_min: |
526 | err = regmap_read(map: data->regmap, ADM9240_REG_FAN_MIN(channel), val: ®val); |
527 | if (err < 0) |
528 | return err; |
529 | *val = FAN_FROM_REG(reg: regval, BIT(data->fan_div[channel])); |
530 | break; |
531 | case hwmon_fan_alarm: |
532 | err = regmap_read(map: data->regmap, ADM9240_REG_INT(0), val: ®val); |
533 | if (err < 0) |
534 | return err; |
535 | *val = !!(regval & BIT(channel + 6)); |
536 | break; |
537 | default: |
538 | return -EOPNOTSUPP; |
539 | } |
540 | return 0; |
541 | } |
542 | |
543 | static int adm9240_fan_write(struct device *dev, u32 attr, int channel, long val) |
544 | { |
545 | struct adm9240_data *data = dev_get_drvdata(dev); |
546 | int err; |
547 | |
548 | switch (attr) { |
549 | case hwmon_fan_min: |
550 | err = adm9240_fan_min_write(data, channel, val); |
551 | if (err < 0) |
552 | return err; |
553 | break; |
554 | default: |
555 | return -EOPNOTSUPP; |
556 | } |
557 | return 0; |
558 | } |
559 | |
560 | static int adm9240_temp_read(struct device *dev, u32 attr, int channel, long *val) |
561 | { |
562 | struct adm9240_data *data = dev_get_drvdata(dev); |
563 | unsigned int regval; |
564 | int err, temp; |
565 | |
566 | switch (attr) { |
567 | case hwmon_temp_input: |
568 | err = regmap_read(map: data->regmap, ADM9240_REG_TEMP, val: ®val); |
569 | if (err < 0) |
570 | return err; |
571 | temp = regval << 1; |
572 | err = regmap_read(map: data->regmap, ADM9240_REG_TEMP_CONF, val: ®val); |
573 | if (err < 0) |
574 | return err; |
575 | temp |= regval >> 7; |
576 | *val = sign_extend32(value: temp, index: 8) * 500; |
577 | break; |
578 | case hwmon_temp_max: |
579 | err = regmap_read(map: data->regmap, ADM9240_REG_TEMP_MAX(0), val: ®val); |
580 | if (err < 0) |
581 | return err; |
582 | *val = (s8)regval * 1000; |
583 | break; |
584 | case hwmon_temp_max_hyst: |
585 | err = regmap_read(map: data->regmap, ADM9240_REG_TEMP_MAX(1), val: ®val); |
586 | if (err < 0) |
587 | return err; |
588 | *val = (s8)regval * 1000; |
589 | break; |
590 | case hwmon_temp_alarm: |
591 | err = regmap_read(map: data->regmap, ADM9240_REG_INT(0), val: ®val); |
592 | if (err < 0) |
593 | return err; |
594 | *val = !!(regval & BIT(4)); |
595 | break; |
596 | default: |
597 | return -EOPNOTSUPP; |
598 | } |
599 | return 0; |
600 | } |
601 | |
602 | static int adm9240_temp_write(struct device *dev, u32 attr, int channel, long val) |
603 | { |
604 | struct adm9240_data *data = dev_get_drvdata(dev); |
605 | int reg; |
606 | |
607 | switch (attr) { |
608 | case hwmon_temp_max: |
609 | reg = ADM9240_REG_TEMP_MAX(0); |
610 | break; |
611 | case hwmon_temp_max_hyst: |
612 | reg = ADM9240_REG_TEMP_MAX(1); |
613 | break; |
614 | default: |
615 | return -EOPNOTSUPP; |
616 | } |
617 | return regmap_write(map: data->regmap, reg, val: TEMP_TO_REG(val)); |
618 | } |
619 | |
620 | static int adm9240_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, |
621 | int channel, long *val) |
622 | { |
623 | switch (type) { |
624 | case hwmon_chip: |
625 | return adm9240_chip_read(dev, attr, val); |
626 | case hwmon_intrusion: |
627 | return adm9240_intrusion_read(dev, attr, val); |
628 | case hwmon_in: |
629 | return adm9240_in_read(dev, attr, channel, val); |
630 | case hwmon_fan: |
631 | return adm9240_fan_read(dev, attr, channel, val); |
632 | case hwmon_temp: |
633 | return adm9240_temp_read(dev, attr, channel, val); |
634 | default: |
635 | return -EOPNOTSUPP; |
636 | } |
637 | } |
638 | |
639 | static int adm9240_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, |
640 | int channel, long val) |
641 | { |
642 | switch (type) { |
643 | case hwmon_intrusion: |
644 | return adm9240_intrusion_write(dev, attr, val); |
645 | case hwmon_in: |
646 | return adm9240_in_write(dev, attr, channel, val); |
647 | case hwmon_fan: |
648 | return adm9240_fan_write(dev, attr, channel, val); |
649 | case hwmon_temp: |
650 | return adm9240_temp_write(dev, attr, channel, val); |
651 | default: |
652 | return -EOPNOTSUPP; |
653 | } |
654 | } |
655 | |
656 | static umode_t adm9240_is_visible(const void *_data, enum hwmon_sensor_types type, |
657 | u32 attr, int channel) |
658 | { |
659 | umode_t mode = 0; |
660 | |
661 | switch (type) { |
662 | case hwmon_chip: |
663 | switch (attr) { |
664 | case hwmon_chip_alarms: |
665 | mode = 0444; |
666 | break; |
667 | default: |
668 | break; |
669 | } |
670 | break; |
671 | case hwmon_intrusion: |
672 | switch (attr) { |
673 | case hwmon_intrusion_alarm: |
674 | mode = 0644; |
675 | break; |
676 | default: |
677 | break; |
678 | } |
679 | break; |
680 | case hwmon_temp: |
681 | switch (attr) { |
682 | case hwmon_temp: |
683 | case hwmon_temp_alarm: |
684 | mode = 0444; |
685 | break; |
686 | case hwmon_temp_max: |
687 | case hwmon_temp_max_hyst: |
688 | mode = 0644; |
689 | break; |
690 | default: |
691 | break; |
692 | } |
693 | break; |
694 | case hwmon_fan: |
695 | switch (attr) { |
696 | case hwmon_fan_input: |
697 | case hwmon_fan_div: |
698 | case hwmon_fan_alarm: |
699 | mode = 0444; |
700 | break; |
701 | case hwmon_fan_min: |
702 | mode = 0644; |
703 | break; |
704 | default: |
705 | break; |
706 | } |
707 | break; |
708 | case hwmon_in: |
709 | switch (attr) { |
710 | case hwmon_in_input: |
711 | case hwmon_in_alarm: |
712 | mode = 0444; |
713 | break; |
714 | case hwmon_in_min: |
715 | case hwmon_in_max: |
716 | mode = 0644; |
717 | break; |
718 | default: |
719 | break; |
720 | } |
721 | break; |
722 | default: |
723 | break; |
724 | } |
725 | return mode; |
726 | } |
727 | |
728 | static const struct hwmon_ops adm9240_hwmon_ops = { |
729 | .is_visible = adm9240_is_visible, |
730 | .read = adm9240_read, |
731 | .write = adm9240_write, |
732 | }; |
733 | |
734 | static const struct hwmon_channel_info * const adm9240_info[] = { |
735 | HWMON_CHANNEL_INFO(chip, HWMON_C_ALARMS), |
736 | HWMON_CHANNEL_INFO(intrusion, HWMON_INTRUSION_ALARM), |
737 | HWMON_CHANNEL_INFO(temp, |
738 | HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST | HWMON_T_ALARM), |
739 | HWMON_CHANNEL_INFO(in, |
740 | HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM, |
741 | HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM, |
742 | HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM, |
743 | HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM, |
744 | HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM, |
745 | HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_ALARM), |
746 | HWMON_CHANNEL_INFO(fan, |
747 | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_DIV | HWMON_F_ALARM, |
748 | HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_DIV | HWMON_F_ALARM), |
749 | NULL |
750 | }; |
751 | |
752 | static const struct hwmon_chip_info adm9240_chip_info = { |
753 | .ops = &adm9240_hwmon_ops, |
754 | .info = adm9240_info, |
755 | }; |
756 | |
757 | static bool adm9240_volatile_reg(struct device *dev, unsigned int reg) |
758 | { |
759 | switch (reg) { |
760 | case ADM9240_REG_IN(0) ... ADM9240_REG_IN(5): |
761 | case ADM9240_REG_FAN(0) ... ADM9240_REG_FAN(1): |
762 | case ADM9240_REG_INT(0) ... ADM9240_REG_INT(1): |
763 | case ADM9240_REG_TEMP: |
764 | case ADM9240_REG_TEMP_CONF: |
765 | case ADM9240_REG_VID_FAN_DIV: |
766 | case ADM9240_REG_VID4: |
767 | case ADM9240_REG_ANALOG_OUT: |
768 | return true; |
769 | default: |
770 | return false; |
771 | } |
772 | } |
773 | |
774 | static const struct regmap_config adm9240_regmap_config = { |
775 | .reg_bits = 8, |
776 | .val_bits = 8, |
777 | .use_single_read = true, |
778 | .use_single_write = true, |
779 | .volatile_reg = adm9240_volatile_reg, |
780 | }; |
781 | |
782 | static int adm9240_probe(struct i2c_client *client) |
783 | { |
784 | struct device *dev = &client->dev; |
785 | struct device *hwmon_dev; |
786 | struct adm9240_data *data; |
787 | int err; |
788 | |
789 | data = devm_kzalloc(dev, size: sizeof(*data), GFP_KERNEL); |
790 | if (!data) |
791 | return -ENOMEM; |
792 | |
793 | data->dev = dev; |
794 | mutex_init(&data->update_lock); |
795 | data->regmap = devm_regmap_init_i2c(client, &adm9240_regmap_config); |
796 | if (IS_ERR(ptr: data->regmap)) |
797 | return PTR_ERR(ptr: data->regmap); |
798 | |
799 | err = adm9240_init_client(data); |
800 | if (err < 0) |
801 | return err; |
802 | |
803 | hwmon_dev = devm_hwmon_device_register_with_info(dev, name: client->name, drvdata: data, |
804 | info: &adm9240_chip_info, |
805 | extra_groups: adm9240_groups); |
806 | return PTR_ERR_OR_ZERO(ptr: hwmon_dev); |
807 | } |
808 | |
809 | static const struct i2c_device_id adm9240_id[] = { |
810 | { "adm9240" , adm9240 }, |
811 | { "ds1780" , ds1780 }, |
812 | { "lm81" , lm81 }, |
813 | { } |
814 | }; |
815 | MODULE_DEVICE_TABLE(i2c, adm9240_id); |
816 | |
817 | static struct i2c_driver adm9240_driver = { |
818 | .class = I2C_CLASS_HWMON, |
819 | .driver = { |
820 | .name = "adm9240" , |
821 | }, |
822 | .probe = adm9240_probe, |
823 | .id_table = adm9240_id, |
824 | .detect = adm9240_detect, |
825 | .address_list = normal_i2c, |
826 | }; |
827 | |
828 | module_i2c_driver(adm9240_driver); |
829 | |
830 | MODULE_AUTHOR("Michiel Rook <michiel@grendelproject.nl>, " |
831 | "Grant Coady <gcoady.lk@gmail.com> and others" ); |
832 | MODULE_DESCRIPTION("ADM9240/DS1780/LM81 driver" ); |
833 | MODULE_LICENSE("GPL" ); |
834 | |