adm9240.c

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