4 * Copyright (C) 2000 Chen-Yuan Wu <gwu@esoft.com>
5 * Copyright (C) 2003-2004 Jean Delvare <khali@linux-fr.org>
7 * The ADM1025 is a sensor chip made by Analog Devices. It reports up to 6
8 * voltages (including its own power source) and up to two temperatures
9 * (its own plus up to one external one). Voltages are scaled internally
10 * (which is not the common way) with ratios such that the nominal value
11 * of each voltage correspond to a register value of 192 (which means a
12 * resolution of about 0.5% of the nominal value). Temperature values are
13 * reported with a 1 deg resolution and a 3 deg accuracy. Complete
14 * datasheet can be obtained from Analog's website at:
15 * http://www.analog.com/Analog_Root/productPage/productHome/0,2121,ADM1025,00.html
17 * This driver also supports the ADM1025A, which differs from the ADM1025
18 * only in that it has "open-drain VID inputs while the ADM1025 has
19 * on-chip 100k pull-ups on the VID inputs". It doesn't make any
22 * This driver also supports the NE1619, a sensor chip made by Philips.
23 * That chip is similar to the ADM1025A, with a few differences. The only
24 * difference that matters to us is that the NE1619 has only two possible
25 * addresses while the ADM1025A has a third one. Complete datasheet can be
26 * obtained from Philips's website at:
27 * http://www.semiconductors.philips.com/pip/NE1619DS.html
29 * Since the ADM1025 was the first chipset supported by this driver, most
30 * comments will refer to this chipset, but are actually general and
31 * concern all supported chipsets, unless mentioned otherwise.
33 * This program is free software; you can redistribute it and/or modify
34 * it under the terms of the GNU General Public License as published by
35 * the Free Software Foundation; either version 2 of the License, or
36 * (at your option) any later version.
38 * This program is distributed in the hope that it will be useful,
39 * but WITHOUT ANY WARRANTY; without even the implied warranty of
40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
41 * GNU General Public License for more details.
43 * You should have received a copy of the GNU General Public License
44 * along with this program; if not, write to the Free Software
45 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
48 #include <linux/module.h>
49 #include <linux/init.h>
50 #include <linux/slab.h>
51 #include <linux/jiffies.h>
52 #include <linux/i2c.h>
53 #include <linux/hwmon.h>
54 #include <linux/hwmon-vid.h>
55 #include <linux/err.h>
59 * ADM1025 and ADM1025A have three possible addresses: 0x2c, 0x2d and 0x2e.
60 * NE1619 has two possible addresses: 0x2c and 0x2d.
63 static unsigned short normal_i2c
[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END
};
69 I2C_CLIENT_INSMOD_2(adm1025
, ne1619
);
72 * The ADM1025 registers
75 #define ADM1025_REG_MAN_ID 0x3E
76 #define ADM1025_REG_CHIP_ID 0x3F
77 #define ADM1025_REG_CONFIG 0x40
78 #define ADM1025_REG_STATUS1 0x41
79 #define ADM1025_REG_STATUS2 0x42
80 #define ADM1025_REG_IN(nr) (0x20 + (nr))
81 #define ADM1025_REG_IN_MAX(nr) (0x2B + (nr) * 2)
82 #define ADM1025_REG_IN_MIN(nr) (0x2C + (nr) * 2)
83 #define ADM1025_REG_TEMP(nr) (0x26 + (nr))
84 #define ADM1025_REG_TEMP_HIGH(nr) (0x37 + (nr) * 2)
85 #define ADM1025_REG_TEMP_LOW(nr) (0x38 + (nr) * 2)
86 #define ADM1025_REG_VID 0x47
87 #define ADM1025_REG_VID4 0x49
90 * Conversions and various macros
91 * The ADM1025 uses signed 8-bit values for temperatures.
94 static int in_scale
[6] = { 2500, 2250, 3300, 5000, 12000, 3300 };
96 #define IN_FROM_REG(reg,scale) (((reg) * (scale) + 96) / 192)
97 #define IN_TO_REG(val,scale) ((val) <= 0 ? 0 : \
98 (val) * 192 >= (scale) * 255 ? 255 : \
99 ((val) * 192 + (scale)/2) / (scale))
101 #define TEMP_FROM_REG(reg) ((reg) * 1000)
102 #define TEMP_TO_REG(val) ((val) <= -127500 ? -128 : \
103 (val) >= 126500 ? 127 : \
104 (((val) < 0 ? (val)-500 : (val)+500) / 1000))
107 * Functions declaration
110 static int adm1025_attach_adapter(struct i2c_adapter
*adapter
);
111 static int adm1025_detect(struct i2c_adapter
*adapter
, int address
, int kind
);
112 static void adm1025_init_client(struct i2c_client
*client
);
113 static int adm1025_detach_client(struct i2c_client
*client
);
114 static struct adm1025_data
*adm1025_update_device(struct device
*dev
);
117 * Driver data (common to all clients)
120 static struct i2c_driver adm1025_driver
= {
121 .owner
= THIS_MODULE
,
123 .id
= I2C_DRIVERID_ADM1025
,
124 .attach_adapter
= adm1025_attach_adapter
,
125 .detach_client
= adm1025_detach_client
,
129 * Client data (each client gets its own)
132 struct adm1025_data
{
133 struct i2c_client client
;
134 struct class_device
*class_dev
;
135 struct semaphore update_lock
;
136 char valid
; /* zero until following fields are valid */
137 unsigned long last_updated
; /* in jiffies */
139 u8 in
[6]; /* register value */
140 u8 in_max
[6]; /* register value */
141 u8 in_min
[6]; /* register value */
142 s8 temp
[2]; /* register value */
143 s8 temp_min
[2]; /* register value */
144 s8 temp_max
[2]; /* register value */
145 u16 alarms
; /* register values, combined */
146 u8 vid
; /* register values, combined */
154 #define show_in(offset) \
155 static ssize_t show_in##offset(struct device *dev, struct device_attribute *attr, char *buf) \
157 struct adm1025_data *data = adm1025_update_device(dev); \
158 return sprintf(buf, "%u\n", IN_FROM_REG(data->in[offset], \
159 in_scale[offset])); \
161 static ssize_t show_in##offset##_min(struct device *dev, struct device_attribute *attr, char *buf) \
163 struct adm1025_data *data = adm1025_update_device(dev); \
164 return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[offset], \
165 in_scale[offset])); \
167 static ssize_t show_in##offset##_max(struct device *dev, struct device_attribute *attr, char *buf) \
169 struct adm1025_data *data = adm1025_update_device(dev); \
170 return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[offset], \
171 in_scale[offset])); \
173 static DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in##offset, NULL);
181 #define show_temp(offset) \
182 static ssize_t show_temp##offset(struct device *dev, struct device_attribute *attr, char *buf) \
184 struct adm1025_data *data = adm1025_update_device(dev); \
185 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[offset-1])); \
187 static ssize_t show_temp##offset##_min(struct device *dev, struct device_attribute *attr, char *buf) \
189 struct adm1025_data *data = adm1025_update_device(dev); \
190 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[offset-1])); \
192 static ssize_t show_temp##offset##_max(struct device *dev, struct device_attribute *attr, char *buf) \
194 struct adm1025_data *data = adm1025_update_device(dev); \
195 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[offset-1])); \
197 static DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp##offset, NULL);
201 #define set_in(offset) \
202 static ssize_t set_in##offset##_min(struct device *dev, struct device_attribute *attr, const char *buf, \
205 struct i2c_client *client = to_i2c_client(dev); \
206 struct adm1025_data *data = i2c_get_clientdata(client); \
207 long val = simple_strtol(buf, NULL, 10); \
209 down(&data->update_lock); \
210 data->in_min[offset] = IN_TO_REG(val, in_scale[offset]); \
211 i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MIN(offset), \
212 data->in_min[offset]); \
213 up(&data->update_lock); \
216 static ssize_t set_in##offset##_max(struct device *dev, struct device_attribute *attr, const char *buf, \
219 struct i2c_client *client = to_i2c_client(dev); \
220 struct adm1025_data *data = i2c_get_clientdata(client); \
221 long val = simple_strtol(buf, NULL, 10); \
223 down(&data->update_lock); \
224 data->in_max[offset] = IN_TO_REG(val, in_scale[offset]); \
225 i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MAX(offset), \
226 data->in_max[offset]); \
227 up(&data->update_lock); \
230 static DEVICE_ATTR(in##offset##_min, S_IWUSR | S_IRUGO, \
231 show_in##offset##_min, set_in##offset##_min); \
232 static DEVICE_ATTR(in##offset##_max, S_IWUSR | S_IRUGO, \
233 show_in##offset##_max, set_in##offset##_max);
241 #define set_temp(offset) \
242 static ssize_t set_temp##offset##_min(struct device *dev, struct device_attribute *attr, const char *buf, \
245 struct i2c_client *client = to_i2c_client(dev); \
246 struct adm1025_data *data = i2c_get_clientdata(client); \
247 long val = simple_strtol(buf, NULL, 10); \
249 down(&data->update_lock); \
250 data->temp_min[offset-1] = TEMP_TO_REG(val); \
251 i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_LOW(offset-1), \
252 data->temp_min[offset-1]); \
253 up(&data->update_lock); \
256 static ssize_t set_temp##offset##_max(struct device *dev, struct device_attribute *attr, const char *buf, \
259 struct i2c_client *client = to_i2c_client(dev); \
260 struct adm1025_data *data = i2c_get_clientdata(client); \
261 long val = simple_strtol(buf, NULL, 10); \
263 down(&data->update_lock); \
264 data->temp_max[offset-1] = TEMP_TO_REG(val); \
265 i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_HIGH(offset-1), \
266 data->temp_max[offset-1]); \
267 up(&data->update_lock); \
270 static DEVICE_ATTR(temp##offset##_min, S_IWUSR | S_IRUGO, \
271 show_temp##offset##_min, set_temp##offset##_min); \
272 static DEVICE_ATTR(temp##offset##_max, S_IWUSR | S_IRUGO, \
273 show_temp##offset##_max, set_temp##offset##_max);
277 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
279 struct adm1025_data
*data
= adm1025_update_device(dev
);
280 return sprintf(buf
, "%u\n", data
->alarms
);
282 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
284 static ssize_t
show_vid(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
286 struct adm1025_data
*data
= adm1025_update_device(dev
);
287 return sprintf(buf
, "%u\n", vid_from_reg(data
->vid
, data
->vrm
));
289 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, show_vid
, NULL
);
291 static ssize_t
show_vrm(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
293 struct adm1025_data
*data
= adm1025_update_device(dev
);
294 return sprintf(buf
, "%u\n", data
->vrm
);
296 static ssize_t
set_vrm(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
298 struct i2c_client
*client
= to_i2c_client(dev
);
299 struct adm1025_data
*data
= i2c_get_clientdata(client
);
300 data
->vrm
= simple_strtoul(buf
, NULL
, 10);
303 static DEVICE_ATTR(vrm
, S_IRUGO
| S_IWUSR
, show_vrm
, set_vrm
);
309 static int adm1025_attach_adapter(struct i2c_adapter
*adapter
)
311 if (!(adapter
->class & I2C_CLASS_HWMON
))
313 return i2c_probe(adapter
, &addr_data
, adm1025_detect
);
317 * The following function does more than just detection. If detection
318 * succeeds, it also registers the new chip.
320 static int adm1025_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
322 struct i2c_client
*new_client
;
323 struct adm1025_data
*data
;
325 const char *name
= "";
328 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
331 if (!(data
= kzalloc(sizeof(struct adm1025_data
), GFP_KERNEL
))) {
336 /* The common I2C client data is placed right before the
337 ADM1025-specific data. */
338 new_client
= &data
->client
;
339 i2c_set_clientdata(new_client
, data
);
340 new_client
->addr
= address
;
341 new_client
->adapter
= adapter
;
342 new_client
->driver
= &adm1025_driver
;
343 new_client
->flags
= 0;
346 * Now we do the remaining detection. A negative kind means that
347 * the driver was loaded with no force parameter (default), so we
348 * must both detect and identify the chip. A zero kind means that
349 * the driver was loaded with the force parameter, the detection
350 * step shall be skipped. A positive kind means that the driver
351 * was loaded with the force parameter and a given kind of chip is
352 * requested, so both the detection and the identification steps
355 config
= i2c_smbus_read_byte_data(new_client
, ADM1025_REG_CONFIG
);
356 if (kind
< 0) { /* detection */
357 if ((config
& 0x80) != 0x00
358 || (i2c_smbus_read_byte_data(new_client
,
359 ADM1025_REG_STATUS1
) & 0xC0) != 0x00
360 || (i2c_smbus_read_byte_data(new_client
,
361 ADM1025_REG_STATUS2
) & 0xBC) != 0x00) {
362 dev_dbg(&adapter
->dev
,
363 "ADM1025 detection failed at 0x%02x.\n",
369 if (kind
<= 0) { /* identification */
372 man_id
= i2c_smbus_read_byte_data(new_client
,
374 chip_id
= i2c_smbus_read_byte_data(new_client
,
375 ADM1025_REG_CHIP_ID
);
377 if (man_id
== 0x41) { /* Analog Devices */
378 if ((chip_id
& 0xF0) == 0x20) { /* ADM1025/ADM1025A */
382 if (man_id
== 0xA1) { /* Philips */
384 && (chip_id
& 0xF0) == 0x20) { /* NE1619 */
389 if (kind
<= 0) { /* identification failed */
390 dev_info(&adapter
->dev
,
391 "Unsupported chip (man_id=0x%02X, "
392 "chip_id=0x%02X).\n", man_id
, chip_id
);
397 if (kind
== adm1025
) {
399 } else if (kind
== ne1619
) {
403 /* We can fill in the remaining client fields */
404 strlcpy(new_client
->name
, name
, I2C_NAME_SIZE
);
406 init_MUTEX(&data
->update_lock
);
408 /* Tell the I2C layer a new client has arrived */
409 if ((err
= i2c_attach_client(new_client
)))
412 /* Initialize the ADM1025 chip */
413 adm1025_init_client(new_client
);
415 /* Register sysfs hooks */
416 data
->class_dev
= hwmon_device_register(&new_client
->dev
);
417 if (IS_ERR(data
->class_dev
)) {
418 err
= PTR_ERR(data
->class_dev
);
422 device_create_file(&new_client
->dev
, &dev_attr_in0_input
);
423 device_create_file(&new_client
->dev
, &dev_attr_in1_input
);
424 device_create_file(&new_client
->dev
, &dev_attr_in2_input
);
425 device_create_file(&new_client
->dev
, &dev_attr_in3_input
);
426 device_create_file(&new_client
->dev
, &dev_attr_in5_input
);
427 device_create_file(&new_client
->dev
, &dev_attr_in0_min
);
428 device_create_file(&new_client
->dev
, &dev_attr_in1_min
);
429 device_create_file(&new_client
->dev
, &dev_attr_in2_min
);
430 device_create_file(&new_client
->dev
, &dev_attr_in3_min
);
431 device_create_file(&new_client
->dev
, &dev_attr_in5_min
);
432 device_create_file(&new_client
->dev
, &dev_attr_in0_max
);
433 device_create_file(&new_client
->dev
, &dev_attr_in1_max
);
434 device_create_file(&new_client
->dev
, &dev_attr_in2_max
);
435 device_create_file(&new_client
->dev
, &dev_attr_in3_max
);
436 device_create_file(&new_client
->dev
, &dev_attr_in5_max
);
437 device_create_file(&new_client
->dev
, &dev_attr_temp1_input
);
438 device_create_file(&new_client
->dev
, &dev_attr_temp2_input
);
439 device_create_file(&new_client
->dev
, &dev_attr_temp1_min
);
440 device_create_file(&new_client
->dev
, &dev_attr_temp2_min
);
441 device_create_file(&new_client
->dev
, &dev_attr_temp1_max
);
442 device_create_file(&new_client
->dev
, &dev_attr_temp2_max
);
443 device_create_file(&new_client
->dev
, &dev_attr_alarms
);
444 device_create_file(&new_client
->dev
, &dev_attr_cpu0_vid
);
445 device_create_file(&new_client
->dev
, &dev_attr_vrm
);
447 /* Pin 11 is either in4 (+12V) or VID4 */
448 if (!(config
& 0x20)) {
449 device_create_file(&new_client
->dev
, &dev_attr_in4_input
);
450 device_create_file(&new_client
->dev
, &dev_attr_in4_min
);
451 device_create_file(&new_client
->dev
, &dev_attr_in4_max
);
457 i2c_detach_client(new_client
);
464 static void adm1025_init_client(struct i2c_client
*client
)
467 struct adm1025_data
*data
= i2c_get_clientdata(client
);
470 data
->vrm
= vid_which_vrm();
474 * Usually we avoid setting limits on driver init, but it happens
475 * that the ADM1025 comes with stupid default limits (all registers
476 * set to 0). In case the chip has not gone through any limit
477 * setting yet, we better set the high limits to the max so that
480 for (i
=0; i
<6; i
++) {
481 reg
= i2c_smbus_read_byte_data(client
,
482 ADM1025_REG_IN_MAX(i
));
484 i2c_smbus_write_byte_data(client
,
485 ADM1025_REG_IN_MAX(i
),
488 for (i
=0; i
<2; i
++) {
489 reg
= i2c_smbus_read_byte_data(client
,
490 ADM1025_REG_TEMP_HIGH(i
));
492 i2c_smbus_write_byte_data(client
,
493 ADM1025_REG_TEMP_HIGH(i
),
498 * Start the conversions
500 reg
= i2c_smbus_read_byte_data(client
, ADM1025_REG_CONFIG
);
502 i2c_smbus_write_byte_data(client
, ADM1025_REG_CONFIG
,
506 static int adm1025_detach_client(struct i2c_client
*client
)
508 struct adm1025_data
*data
= i2c_get_clientdata(client
);
511 hwmon_device_unregister(data
->class_dev
);
513 if ((err
= i2c_detach_client(client
)))
520 static struct adm1025_data
*adm1025_update_device(struct device
*dev
)
522 struct i2c_client
*client
= to_i2c_client(dev
);
523 struct adm1025_data
*data
= i2c_get_clientdata(client
);
525 down(&data
->update_lock
);
527 if (time_after(jiffies
, data
->last_updated
+ HZ
* 2) || !data
->valid
) {
530 dev_dbg(&client
->dev
, "Updating data.\n");
531 for (i
=0; i
<6; i
++) {
532 data
->in
[i
] = i2c_smbus_read_byte_data(client
,
534 data
->in_min
[i
] = i2c_smbus_read_byte_data(client
,
535 ADM1025_REG_IN_MIN(i
));
536 data
->in_max
[i
] = i2c_smbus_read_byte_data(client
,
537 ADM1025_REG_IN_MAX(i
));
539 for (i
=0; i
<2; i
++) {
540 data
->temp
[i
] = i2c_smbus_read_byte_data(client
,
541 ADM1025_REG_TEMP(i
));
542 data
->temp_min
[i
] = i2c_smbus_read_byte_data(client
,
543 ADM1025_REG_TEMP_LOW(i
));
544 data
->temp_max
[i
] = i2c_smbus_read_byte_data(client
,
545 ADM1025_REG_TEMP_HIGH(i
));
547 data
->alarms
= i2c_smbus_read_byte_data(client
,
549 | (i2c_smbus_read_byte_data(client
,
550 ADM1025_REG_STATUS2
) << 8);
551 data
->vid
= (i2c_smbus_read_byte_data(client
,
552 ADM1025_REG_VID
) & 0x0f)
553 | ((i2c_smbus_read_byte_data(client
,
554 ADM1025_REG_VID4
) & 0x01) << 4);
556 data
->last_updated
= jiffies
;
560 up(&data
->update_lock
);
565 static int __init
sensors_adm1025_init(void)
567 return i2c_add_driver(&adm1025_driver
);
570 static void __exit
sensors_adm1025_exit(void)
572 i2c_del_driver(&adm1025_driver
);
575 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
576 MODULE_DESCRIPTION("ADM1025 driver");
577 MODULE_LICENSE("GPL");
579 module_init(sensors_adm1025_init
);
580 module_exit(sensors_adm1025_exit
);