2 gl520sm.c - Part of lm_sensors, Linux kernel modules for hardware
4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>,
5 Kyösti Mälkki <kmalkki@cc.hut.fi>
6 Copyright (c) 2005 Maarten Deprez <maartendeprez@users.sourceforge.net>
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/slab.h>
27 #include <linux/jiffies.h>
28 #include <linux/i2c.h>
29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h>
31 #include <linux/hwmon-vid.h>
32 #include <linux/err.h>
33 #include <linux/mutex.h>
34 #include <linux/sysfs.h>
36 /* Type of the extra sensor */
37 static unsigned short extra_sensor_type
;
38 module_param(extra_sensor_type
, ushort
, 0);
39 MODULE_PARM_DESC(extra_sensor_type
, "Type of extra sensor (0=autodetect, 1=temperature, 2=voltage)");
41 /* Addresses to scan */
42 static const unsigned short normal_i2c
[] = { 0x2c, 0x2d, I2C_CLIENT_END
};
44 /* Insmod parameters */
45 I2C_CLIENT_INSMOD_1(gl520sm
);
47 /* Many GL520 constants specified below
48 One of the inputs can be configured as either temp or voltage.
49 That's why _TEMP2 and _IN4 access the same register
52 /* The GL520 registers */
53 #define GL520_REG_CHIP_ID 0x00
54 #define GL520_REG_REVISION 0x01
55 #define GL520_REG_CONF 0x03
56 #define GL520_REG_MASK 0x11
58 #define GL520_REG_VID_INPUT 0x02
60 static const u8 GL520_REG_IN_INPUT
[] = { 0x15, 0x14, 0x13, 0x0d, 0x0e };
61 static const u8 GL520_REG_IN_LIMIT
[] = { 0x0c, 0x09, 0x0a, 0x0b };
62 static const u8 GL520_REG_IN_MIN
[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x18 };
63 static const u8 GL520_REG_IN_MAX
[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x17 };
65 static const u8 GL520_REG_TEMP_INPUT
[] = { 0x04, 0x0e };
66 static const u8 GL520_REG_TEMP_MAX
[] = { 0x05, 0x17 };
67 static const u8 GL520_REG_TEMP_MAX_HYST
[] = { 0x06, 0x18 };
69 #define GL520_REG_FAN_INPUT 0x07
70 #define GL520_REG_FAN_MIN 0x08
71 #define GL520_REG_FAN_DIV 0x0f
72 #define GL520_REG_FAN_OFF GL520_REG_FAN_DIV
74 #define GL520_REG_ALARMS 0x12
75 #define GL520_REG_BEEP_MASK 0x10
76 #define GL520_REG_BEEP_ENABLE GL520_REG_CONF
79 * Function declarations
82 static int gl520_probe(struct i2c_client
*client
,
83 const struct i2c_device_id
*id
);
84 static int gl520_detect(struct i2c_client
*client
, struct i2c_board_info
*info
);
85 static void gl520_init_client(struct i2c_client
*client
);
86 static int gl520_remove(struct i2c_client
*client
);
87 static int gl520_read_value(struct i2c_client
*client
, u8 reg
);
88 static int gl520_write_value(struct i2c_client
*client
, u8 reg
, u16 value
);
89 static struct gl520_data
*gl520_update_device(struct device
*dev
);
92 static const struct i2c_device_id gl520_id
[] = {
93 { "gl520sm", gl520sm
},
96 MODULE_DEVICE_TABLE(i2c
, gl520_id
);
98 static struct i2c_driver gl520_driver
= {
99 .class = I2C_CLASS_HWMON
,
103 .probe
= gl520_probe
,
104 .remove
= gl520_remove
,
105 .id_table
= gl520_id
,
106 .detect
= gl520_detect
,
107 .address_list
= normal_i2c
,
112 struct device
*hwmon_dev
;
113 struct mutex update_lock
;
114 char valid
; /* zero until the following fields are valid */
115 unsigned long last_updated
; /* in jiffies */
119 u8 in_input
[5]; /* [0] = VVD */
120 u8 in_min
[5]; /* [0] = VDD */
121 u8 in_max
[5]; /* [0] = VDD */
140 static ssize_t
get_cpu_vid(struct device
*dev
, struct device_attribute
*attr
,
143 struct gl520_data
*data
= gl520_update_device(dev
);
144 return sprintf(buf
, "%u\n", vid_from_reg(data
->vid
, data
->vrm
));
146 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, get_cpu_vid
, NULL
);
148 #define VDD_FROM_REG(val) (((val)*95+2)/4)
149 #define VDD_TO_REG(val) (SENSORS_LIMIT((((val)*4+47)/95),0,255))
151 #define IN_FROM_REG(val) ((val)*19)
152 #define IN_TO_REG(val) (SENSORS_LIMIT((((val)+9)/19),0,255))
154 static ssize_t
get_in_input(struct device
*dev
, struct device_attribute
*attr
,
157 int n
= to_sensor_dev_attr(attr
)->index
;
158 struct gl520_data
*data
= gl520_update_device(dev
);
159 u8 r
= data
->in_input
[n
];
162 return sprintf(buf
, "%d\n", VDD_FROM_REG(r
));
164 return sprintf(buf
, "%d\n", IN_FROM_REG(r
));
167 static ssize_t
get_in_min(struct device
*dev
, struct device_attribute
*attr
,
170 int n
= to_sensor_dev_attr(attr
)->index
;
171 struct gl520_data
*data
= gl520_update_device(dev
);
172 u8 r
= data
->in_min
[n
];
175 return sprintf(buf
, "%d\n", VDD_FROM_REG(r
));
177 return sprintf(buf
, "%d\n", IN_FROM_REG(r
));
180 static ssize_t
get_in_max(struct device
*dev
, struct device_attribute
*attr
,
183 int n
= to_sensor_dev_attr(attr
)->index
;
184 struct gl520_data
*data
= gl520_update_device(dev
);
185 u8 r
= data
->in_max
[n
];
188 return sprintf(buf
, "%d\n", VDD_FROM_REG(r
));
190 return sprintf(buf
, "%d\n", IN_FROM_REG(r
));
193 static ssize_t
set_in_min(struct device
*dev
, struct device_attribute
*attr
,
194 const char *buf
, size_t count
)
196 struct i2c_client
*client
= to_i2c_client(dev
);
197 struct gl520_data
*data
= i2c_get_clientdata(client
);
198 int n
= to_sensor_dev_attr(attr
)->index
;
199 long v
= simple_strtol(buf
, NULL
, 10);
202 mutex_lock(&data
->update_lock
);
212 gl520_write_value(client
, GL520_REG_IN_MIN
[n
],
213 (gl520_read_value(client
, GL520_REG_IN_MIN
[n
])
216 gl520_write_value(client
, GL520_REG_IN_MIN
[n
], r
);
218 mutex_unlock(&data
->update_lock
);
222 static ssize_t
set_in_max(struct device
*dev
, struct device_attribute
*attr
,
223 const char *buf
, size_t count
)
225 struct i2c_client
*client
= to_i2c_client(dev
);
226 struct gl520_data
*data
= i2c_get_clientdata(client
);
227 int n
= to_sensor_dev_attr(attr
)->index
;
228 long v
= simple_strtol(buf
, NULL
, 10);
236 mutex_lock(&data
->update_lock
);
241 gl520_write_value(client
, GL520_REG_IN_MAX
[n
],
242 (gl520_read_value(client
, GL520_REG_IN_MAX
[n
])
243 & ~0xff00) | (r
<< 8));
245 gl520_write_value(client
, GL520_REG_IN_MAX
[n
], r
);
247 mutex_unlock(&data
->update_lock
);
251 static SENSOR_DEVICE_ATTR(in0_input
, S_IRUGO
, get_in_input
, NULL
, 0);
252 static SENSOR_DEVICE_ATTR(in1_input
, S_IRUGO
, get_in_input
, NULL
, 1);
253 static SENSOR_DEVICE_ATTR(in2_input
, S_IRUGO
, get_in_input
, NULL
, 2);
254 static SENSOR_DEVICE_ATTR(in3_input
, S_IRUGO
, get_in_input
, NULL
, 3);
255 static SENSOR_DEVICE_ATTR(in4_input
, S_IRUGO
, get_in_input
, NULL
, 4);
256 static SENSOR_DEVICE_ATTR(in0_min
, S_IRUGO
| S_IWUSR
,
257 get_in_min
, set_in_min
, 0);
258 static SENSOR_DEVICE_ATTR(in1_min
, S_IRUGO
| S_IWUSR
,
259 get_in_min
, set_in_min
, 1);
260 static SENSOR_DEVICE_ATTR(in2_min
, S_IRUGO
| S_IWUSR
,
261 get_in_min
, set_in_min
, 2);
262 static SENSOR_DEVICE_ATTR(in3_min
, S_IRUGO
| S_IWUSR
,
263 get_in_min
, set_in_min
, 3);
264 static SENSOR_DEVICE_ATTR(in4_min
, S_IRUGO
| S_IWUSR
,
265 get_in_min
, set_in_min
, 4);
266 static SENSOR_DEVICE_ATTR(in0_max
, S_IRUGO
| S_IWUSR
,
267 get_in_max
, set_in_max
, 0);
268 static SENSOR_DEVICE_ATTR(in1_max
, S_IRUGO
| S_IWUSR
,
269 get_in_max
, set_in_max
, 1);
270 static SENSOR_DEVICE_ATTR(in2_max
, S_IRUGO
| S_IWUSR
,
271 get_in_max
, set_in_max
, 2);
272 static SENSOR_DEVICE_ATTR(in3_max
, S_IRUGO
| S_IWUSR
,
273 get_in_max
, set_in_max
, 3);
274 static SENSOR_DEVICE_ATTR(in4_max
, S_IRUGO
| S_IWUSR
,
275 get_in_max
, set_in_max
, 4);
277 #define DIV_FROM_REG(val) (1 << (val))
278 #define FAN_FROM_REG(val,div) ((val)==0 ? 0 : (480000/((val) << (div))))
279 #define FAN_TO_REG(val,div) ((val)<=0?0:SENSORS_LIMIT((480000 + ((val) << ((div)-1))) / ((val) << (div)), 1, 255));
281 static ssize_t
get_fan_input(struct device
*dev
, struct device_attribute
*attr
,
284 int n
= to_sensor_dev_attr(attr
)->index
;
285 struct gl520_data
*data
= gl520_update_device(dev
);
287 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan_input
[n
],
291 static ssize_t
get_fan_min(struct device
*dev
, struct device_attribute
*attr
,
294 int n
= to_sensor_dev_attr(attr
)->index
;
295 struct gl520_data
*data
= gl520_update_device(dev
);
297 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan_min
[n
],
301 static ssize_t
get_fan_div(struct device
*dev
, struct device_attribute
*attr
,
304 int n
= to_sensor_dev_attr(attr
)->index
;
305 struct gl520_data
*data
= gl520_update_device(dev
);
307 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[n
]));
310 static ssize_t
get_fan_off(struct device
*dev
, struct device_attribute
*attr
,
313 struct gl520_data
*data
= gl520_update_device(dev
);
314 return sprintf(buf
, "%d\n", data
->fan_off
);
317 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
*attr
,
318 const char *buf
, size_t count
)
320 struct i2c_client
*client
= to_i2c_client(dev
);
321 struct gl520_data
*data
= i2c_get_clientdata(client
);
322 int n
= to_sensor_dev_attr(attr
)->index
;
323 unsigned long v
= simple_strtoul(buf
, NULL
, 10);
326 mutex_lock(&data
->update_lock
);
327 r
= FAN_TO_REG(v
, data
->fan_div
[n
]);
328 data
->fan_min
[n
] = r
;
331 gl520_write_value(client
, GL520_REG_FAN_MIN
,
332 (gl520_read_value(client
, GL520_REG_FAN_MIN
)
333 & ~0xff00) | (r
<< 8));
335 gl520_write_value(client
, GL520_REG_FAN_MIN
,
336 (gl520_read_value(client
, GL520_REG_FAN_MIN
)
339 data
->beep_mask
= gl520_read_value(client
, GL520_REG_BEEP_MASK
);
340 if (data
->fan_min
[n
] == 0)
341 data
->alarm_mask
&= (n
== 0) ? ~0x20 : ~0x40;
343 data
->alarm_mask
|= (n
== 0) ? 0x20 : 0x40;
344 data
->beep_mask
&= data
->alarm_mask
;
345 gl520_write_value(client
, GL520_REG_BEEP_MASK
, data
->beep_mask
);
347 mutex_unlock(&data
->update_lock
);
351 static ssize_t
set_fan_div(struct device
*dev
, struct device_attribute
*attr
,
352 const char *buf
, size_t count
)
354 struct i2c_client
*client
= to_i2c_client(dev
);
355 struct gl520_data
*data
= i2c_get_clientdata(client
);
356 int n
= to_sensor_dev_attr(attr
)->index
;
357 unsigned long v
= simple_strtoul(buf
, NULL
, 10);
361 case 1: r
= 0; break;
362 case 2: r
= 1; break;
363 case 4: r
= 2; break;
364 case 8: r
= 3; break;
366 dev_err(&client
->dev
, "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", v
);
370 mutex_lock(&data
->update_lock
);
371 data
->fan_div
[n
] = r
;
374 gl520_write_value(client
, GL520_REG_FAN_DIV
,
375 (gl520_read_value(client
, GL520_REG_FAN_DIV
)
376 & ~0xc0) | (r
<< 6));
378 gl520_write_value(client
, GL520_REG_FAN_DIV
,
379 (gl520_read_value(client
, GL520_REG_FAN_DIV
)
380 & ~0x30) | (r
<< 4));
382 mutex_unlock(&data
->update_lock
);
386 static ssize_t
set_fan_off(struct device
*dev
, struct device_attribute
*attr
,
387 const char *buf
, size_t count
)
389 struct i2c_client
*client
= to_i2c_client(dev
);
390 struct gl520_data
*data
= i2c_get_clientdata(client
);
391 u8 r
= simple_strtoul(buf
, NULL
, 10)?1:0;
393 mutex_lock(&data
->update_lock
);
395 gl520_write_value(client
, GL520_REG_FAN_OFF
,
396 (gl520_read_value(client
, GL520_REG_FAN_OFF
)
397 & ~0x0c) | (r
<< 2));
398 mutex_unlock(&data
->update_lock
);
402 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, get_fan_input
, NULL
, 0);
403 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, get_fan_input
, NULL
, 1);
404 static SENSOR_DEVICE_ATTR(fan1_min
, S_IRUGO
| S_IWUSR
,
405 get_fan_min
, set_fan_min
, 0);
406 static SENSOR_DEVICE_ATTR(fan2_min
, S_IRUGO
| S_IWUSR
,
407 get_fan_min
, set_fan_min
, 1);
408 static SENSOR_DEVICE_ATTR(fan1_div
, S_IRUGO
| S_IWUSR
,
409 get_fan_div
, set_fan_div
, 0);
410 static SENSOR_DEVICE_ATTR(fan2_div
, S_IRUGO
| S_IWUSR
,
411 get_fan_div
, set_fan_div
, 1);
412 static DEVICE_ATTR(fan1_off
, S_IRUGO
| S_IWUSR
,
413 get_fan_off
, set_fan_off
);
415 #define TEMP_FROM_REG(val) (((val) - 130) * 1000)
416 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((((val)<0?(val)-500:(val)+500) / 1000)+130),0,255))
418 static ssize_t
get_temp_input(struct device
*dev
, struct device_attribute
*attr
,
421 int n
= to_sensor_dev_attr(attr
)->index
;
422 struct gl520_data
*data
= gl520_update_device(dev
);
424 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_input
[n
]));
427 static ssize_t
get_temp_max(struct device
*dev
, struct device_attribute
*attr
,
430 int n
= to_sensor_dev_attr(attr
)->index
;
431 struct gl520_data
*data
= gl520_update_device(dev
);
433 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_max
[n
]));
436 static ssize_t
get_temp_max_hyst(struct device
*dev
, struct device_attribute
439 int n
= to_sensor_dev_attr(attr
)->index
;
440 struct gl520_data
*data
= gl520_update_device(dev
);
442 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_max_hyst
[n
]));
445 static ssize_t
set_temp_max(struct device
*dev
, struct device_attribute
*attr
,
446 const char *buf
, size_t count
)
448 struct i2c_client
*client
= to_i2c_client(dev
);
449 struct gl520_data
*data
= i2c_get_clientdata(client
);
450 int n
= to_sensor_dev_attr(attr
)->index
;
451 long v
= simple_strtol(buf
, NULL
, 10);
453 mutex_lock(&data
->update_lock
);
454 data
->temp_max
[n
] = TEMP_TO_REG(v
);
455 gl520_write_value(client
, GL520_REG_TEMP_MAX
[n
], data
->temp_max
[n
]);
456 mutex_unlock(&data
->update_lock
);
460 static ssize_t
set_temp_max_hyst(struct device
*dev
, struct device_attribute
461 *attr
, const char *buf
, size_t count
)
463 struct i2c_client
*client
= to_i2c_client(dev
);
464 struct gl520_data
*data
= i2c_get_clientdata(client
);
465 int n
= to_sensor_dev_attr(attr
)->index
;
466 long v
= simple_strtol(buf
, NULL
, 10);
468 mutex_lock(&data
->update_lock
);
469 data
->temp_max_hyst
[n
] = TEMP_TO_REG(v
);
470 gl520_write_value(client
, GL520_REG_TEMP_MAX_HYST
[n
],
471 data
->temp_max_hyst
[n
]);
472 mutex_unlock(&data
->update_lock
);
476 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, get_temp_input
, NULL
, 0);
477 static SENSOR_DEVICE_ATTR(temp2_input
, S_IRUGO
, get_temp_input
, NULL
, 1);
478 static SENSOR_DEVICE_ATTR(temp1_max
, S_IRUGO
| S_IWUSR
,
479 get_temp_max
, set_temp_max
, 0);
480 static SENSOR_DEVICE_ATTR(temp2_max
, S_IRUGO
| S_IWUSR
,
481 get_temp_max
, set_temp_max
, 1);
482 static SENSOR_DEVICE_ATTR(temp1_max_hyst
, S_IRUGO
| S_IWUSR
,
483 get_temp_max_hyst
, set_temp_max_hyst
, 0);
484 static SENSOR_DEVICE_ATTR(temp2_max_hyst
, S_IRUGO
| S_IWUSR
,
485 get_temp_max_hyst
, set_temp_max_hyst
, 1);
487 static ssize_t
get_alarms(struct device
*dev
, struct device_attribute
*attr
,
490 struct gl520_data
*data
= gl520_update_device(dev
);
491 return sprintf(buf
, "%d\n", data
->alarms
);
494 static ssize_t
get_beep_enable(struct device
*dev
, struct device_attribute
497 struct gl520_data
*data
= gl520_update_device(dev
);
498 return sprintf(buf
, "%d\n", data
->beep_enable
);
501 static ssize_t
get_beep_mask(struct device
*dev
, struct device_attribute
*attr
,
504 struct gl520_data
*data
= gl520_update_device(dev
);
505 return sprintf(buf
, "%d\n", data
->beep_mask
);
508 static ssize_t
set_beep_enable(struct device
*dev
, struct device_attribute
509 *attr
, const char *buf
, size_t count
)
511 struct i2c_client
*client
= to_i2c_client(dev
);
512 struct gl520_data
*data
= i2c_get_clientdata(client
);
513 u8 r
= simple_strtoul(buf
, NULL
, 10)?0:1;
515 mutex_lock(&data
->update_lock
);
516 data
->beep_enable
= !r
;
517 gl520_write_value(client
, GL520_REG_BEEP_ENABLE
,
518 (gl520_read_value(client
, GL520_REG_BEEP_ENABLE
)
519 & ~0x04) | (r
<< 2));
520 mutex_unlock(&data
->update_lock
);
524 static ssize_t
set_beep_mask(struct device
*dev
, struct device_attribute
*attr
,
525 const char *buf
, size_t count
)
527 struct i2c_client
*client
= to_i2c_client(dev
);
528 struct gl520_data
*data
= i2c_get_clientdata(client
);
529 u8 r
= simple_strtoul(buf
, NULL
, 10);
531 mutex_lock(&data
->update_lock
);
532 r
&= data
->alarm_mask
;
534 gl520_write_value(client
, GL520_REG_BEEP_MASK
, r
);
535 mutex_unlock(&data
->update_lock
);
539 static DEVICE_ATTR(alarms
, S_IRUGO
, get_alarms
, NULL
);
540 static DEVICE_ATTR(beep_enable
, S_IRUGO
| S_IWUSR
,
541 get_beep_enable
, set_beep_enable
);
542 static DEVICE_ATTR(beep_mask
, S_IRUGO
| S_IWUSR
,
543 get_beep_mask
, set_beep_mask
);
545 static ssize_t
get_alarm(struct device
*dev
, struct device_attribute
*attr
,
548 int bit_nr
= to_sensor_dev_attr(attr
)->index
;
549 struct gl520_data
*data
= gl520_update_device(dev
);
551 return sprintf(buf
, "%d\n", (data
->alarms
>> bit_nr
) & 1);
554 static SENSOR_DEVICE_ATTR(in0_alarm
, S_IRUGO
, get_alarm
, NULL
, 0);
555 static SENSOR_DEVICE_ATTR(in1_alarm
, S_IRUGO
, get_alarm
, NULL
, 1);
556 static SENSOR_DEVICE_ATTR(in2_alarm
, S_IRUGO
, get_alarm
, NULL
, 2);
557 static SENSOR_DEVICE_ATTR(in3_alarm
, S_IRUGO
, get_alarm
, NULL
, 3);
558 static SENSOR_DEVICE_ATTR(temp1_alarm
, S_IRUGO
, get_alarm
, NULL
, 4);
559 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, get_alarm
, NULL
, 5);
560 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, get_alarm
, NULL
, 6);
561 static SENSOR_DEVICE_ATTR(temp2_alarm
, S_IRUGO
, get_alarm
, NULL
, 7);
562 static SENSOR_DEVICE_ATTR(in4_alarm
, S_IRUGO
, get_alarm
, NULL
, 7);
564 static ssize_t
get_beep(struct device
*dev
, struct device_attribute
*attr
,
567 int bitnr
= to_sensor_dev_attr(attr
)->index
;
568 struct gl520_data
*data
= gl520_update_device(dev
);
570 return sprintf(buf
, "%d\n", (data
->beep_mask
>> bitnr
) & 1);
573 static ssize_t
set_beep(struct device
*dev
, struct device_attribute
*attr
,
574 const char *buf
, size_t count
)
576 struct i2c_client
*client
= to_i2c_client(dev
);
577 struct gl520_data
*data
= i2c_get_clientdata(client
);
578 int bitnr
= to_sensor_dev_attr(attr
)->index
;
581 bit
= simple_strtoul(buf
, NULL
, 10);
585 mutex_lock(&data
->update_lock
);
586 data
->beep_mask
= gl520_read_value(client
, GL520_REG_BEEP_MASK
);
588 data
->beep_mask
|= (1 << bitnr
);
590 data
->beep_mask
&= ~(1 << bitnr
);
591 gl520_write_value(client
, GL520_REG_BEEP_MASK
, data
->beep_mask
);
592 mutex_unlock(&data
->update_lock
);
596 static SENSOR_DEVICE_ATTR(in0_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 0);
597 static SENSOR_DEVICE_ATTR(in1_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 1);
598 static SENSOR_DEVICE_ATTR(in2_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 2);
599 static SENSOR_DEVICE_ATTR(in3_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 3);
600 static SENSOR_DEVICE_ATTR(temp1_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 4);
601 static SENSOR_DEVICE_ATTR(fan1_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 5);
602 static SENSOR_DEVICE_ATTR(fan2_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 6);
603 static SENSOR_DEVICE_ATTR(temp2_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 7);
604 static SENSOR_DEVICE_ATTR(in4_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 7);
606 static struct attribute
*gl520_attributes
[] = {
607 &dev_attr_cpu0_vid
.attr
,
609 &sensor_dev_attr_in0_input
.dev_attr
.attr
,
610 &sensor_dev_attr_in0_min
.dev_attr
.attr
,
611 &sensor_dev_attr_in0_max
.dev_attr
.attr
,
612 &sensor_dev_attr_in0_alarm
.dev_attr
.attr
,
613 &sensor_dev_attr_in0_beep
.dev_attr
.attr
,
614 &sensor_dev_attr_in1_input
.dev_attr
.attr
,
615 &sensor_dev_attr_in1_min
.dev_attr
.attr
,
616 &sensor_dev_attr_in1_max
.dev_attr
.attr
,
617 &sensor_dev_attr_in1_alarm
.dev_attr
.attr
,
618 &sensor_dev_attr_in1_beep
.dev_attr
.attr
,
619 &sensor_dev_attr_in2_input
.dev_attr
.attr
,
620 &sensor_dev_attr_in2_min
.dev_attr
.attr
,
621 &sensor_dev_attr_in2_max
.dev_attr
.attr
,
622 &sensor_dev_attr_in2_alarm
.dev_attr
.attr
,
623 &sensor_dev_attr_in2_beep
.dev_attr
.attr
,
624 &sensor_dev_attr_in3_input
.dev_attr
.attr
,
625 &sensor_dev_attr_in3_min
.dev_attr
.attr
,
626 &sensor_dev_attr_in3_max
.dev_attr
.attr
,
627 &sensor_dev_attr_in3_alarm
.dev_attr
.attr
,
628 &sensor_dev_attr_in3_beep
.dev_attr
.attr
,
630 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
631 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
632 &sensor_dev_attr_fan1_div
.dev_attr
.attr
,
633 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
634 &sensor_dev_attr_fan1_beep
.dev_attr
.attr
,
635 &dev_attr_fan1_off
.attr
,
636 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
637 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
638 &sensor_dev_attr_fan2_div
.dev_attr
.attr
,
639 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
640 &sensor_dev_attr_fan2_beep
.dev_attr
.attr
,
642 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
643 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
644 &sensor_dev_attr_temp1_max_hyst
.dev_attr
.attr
,
645 &sensor_dev_attr_temp1_alarm
.dev_attr
.attr
,
646 &sensor_dev_attr_temp1_beep
.dev_attr
.attr
,
648 &dev_attr_alarms
.attr
,
649 &dev_attr_beep_enable
.attr
,
650 &dev_attr_beep_mask
.attr
,
654 static const struct attribute_group gl520_group
= {
655 .attrs
= gl520_attributes
,
658 static struct attribute
*gl520_attributes_opt
[] = {
659 &sensor_dev_attr_in4_input
.dev_attr
.attr
,
660 &sensor_dev_attr_in4_min
.dev_attr
.attr
,
661 &sensor_dev_attr_in4_max
.dev_attr
.attr
,
662 &sensor_dev_attr_in4_alarm
.dev_attr
.attr
,
663 &sensor_dev_attr_in4_beep
.dev_attr
.attr
,
665 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
666 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
667 &sensor_dev_attr_temp2_max_hyst
.dev_attr
.attr
,
668 &sensor_dev_attr_temp2_alarm
.dev_attr
.attr
,
669 &sensor_dev_attr_temp2_beep
.dev_attr
.attr
,
673 static const struct attribute_group gl520_group_opt
= {
674 .attrs
= gl520_attributes_opt
,
682 /* Return 0 if detection is successful, -ENODEV otherwise */
683 static int gl520_detect(struct i2c_client
*client
, struct i2c_board_info
*info
)
685 struct i2c_adapter
*adapter
= client
->adapter
;
687 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
|
688 I2C_FUNC_SMBUS_WORD_DATA
))
691 /* Determine the chip type. */
692 if ((gl520_read_value(client
, GL520_REG_CHIP_ID
) != 0x20) ||
693 ((gl520_read_value(client
, GL520_REG_REVISION
) & 0x7f) != 0x00) ||
694 ((gl520_read_value(client
, GL520_REG_CONF
) & 0x80) != 0x00)) {
695 dev_dbg(&client
->dev
, "Unknown chip type, skipping\n");
699 strlcpy(info
->type
, "gl520sm", I2C_NAME_SIZE
);
704 static int gl520_probe(struct i2c_client
*client
,
705 const struct i2c_device_id
*id
)
707 struct gl520_data
*data
;
710 data
= kzalloc(sizeof(struct gl520_data
), GFP_KERNEL
);
716 i2c_set_clientdata(client
, data
);
717 mutex_init(&data
->update_lock
);
719 /* Initialize the GL520SM chip */
720 gl520_init_client(client
);
722 /* Register sysfs hooks */
723 if ((err
= sysfs_create_group(&client
->dev
.kobj
, &gl520_group
)))
726 if (data
->two_temps
) {
727 if ((err
= device_create_file(&client
->dev
,
728 &sensor_dev_attr_temp2_input
.dev_attr
))
729 || (err
= device_create_file(&client
->dev
,
730 &sensor_dev_attr_temp2_max
.dev_attr
))
731 || (err
= device_create_file(&client
->dev
,
732 &sensor_dev_attr_temp2_max_hyst
.dev_attr
))
733 || (err
= device_create_file(&client
->dev
,
734 &sensor_dev_attr_temp2_alarm
.dev_attr
))
735 || (err
= device_create_file(&client
->dev
,
736 &sensor_dev_attr_temp2_beep
.dev_attr
)))
737 goto exit_remove_files
;
739 if ((err
= device_create_file(&client
->dev
,
740 &sensor_dev_attr_in4_input
.dev_attr
))
741 || (err
= device_create_file(&client
->dev
,
742 &sensor_dev_attr_in4_min
.dev_attr
))
743 || (err
= device_create_file(&client
->dev
,
744 &sensor_dev_attr_in4_max
.dev_attr
))
745 || (err
= device_create_file(&client
->dev
,
746 &sensor_dev_attr_in4_alarm
.dev_attr
))
747 || (err
= device_create_file(&client
->dev
,
748 &sensor_dev_attr_in4_beep
.dev_attr
)))
749 goto exit_remove_files
;
753 data
->hwmon_dev
= hwmon_device_register(&client
->dev
);
754 if (IS_ERR(data
->hwmon_dev
)) {
755 err
= PTR_ERR(data
->hwmon_dev
);
756 goto exit_remove_files
;
762 sysfs_remove_group(&client
->dev
.kobj
, &gl520_group
);
763 sysfs_remove_group(&client
->dev
.kobj
, &gl520_group_opt
);
771 /* Called when we have found a new GL520SM. */
772 static void gl520_init_client(struct i2c_client
*client
)
774 struct gl520_data
*data
= i2c_get_clientdata(client
);
777 conf
= oldconf
= gl520_read_value(client
, GL520_REG_CONF
);
779 data
->alarm_mask
= 0xff;
780 data
->vrm
= vid_which_vrm();
782 if (extra_sensor_type
== 1)
784 else if (extra_sensor_type
== 2)
786 data
->two_temps
= !(conf
& 0x10);
788 /* If IRQ# is disabled, we can safely force comparator mode */
792 /* Enable monitoring if needed */
796 gl520_write_value(client
, GL520_REG_CONF
, conf
);
798 gl520_update_device(&(client
->dev
));
800 if (data
->fan_min
[0] == 0)
801 data
->alarm_mask
&= ~0x20;
802 if (data
->fan_min
[1] == 0)
803 data
->alarm_mask
&= ~0x40;
805 data
->beep_mask
&= data
->alarm_mask
;
806 gl520_write_value(client
, GL520_REG_BEEP_MASK
, data
->beep_mask
);
809 static int gl520_remove(struct i2c_client
*client
)
811 struct gl520_data
*data
= i2c_get_clientdata(client
);
813 hwmon_device_unregister(data
->hwmon_dev
);
814 sysfs_remove_group(&client
->dev
.kobj
, &gl520_group
);
815 sysfs_remove_group(&client
->dev
.kobj
, &gl520_group_opt
);
822 /* Registers 0x07 to 0x0c are word-sized, others are byte-sized
823 GL520 uses a high-byte first convention */
824 static int gl520_read_value(struct i2c_client
*client
, u8 reg
)
826 if ((reg
>= 0x07) && (reg
<= 0x0c))
827 return swab16(i2c_smbus_read_word_data(client
, reg
));
829 return i2c_smbus_read_byte_data(client
, reg
);
832 static int gl520_write_value(struct i2c_client
*client
, u8 reg
, u16 value
)
834 if ((reg
>= 0x07) && (reg
<= 0x0c))
835 return i2c_smbus_write_word_data(client
, reg
, swab16(value
));
837 return i2c_smbus_write_byte_data(client
, reg
, value
);
841 static struct gl520_data
*gl520_update_device(struct device
*dev
)
843 struct i2c_client
*client
= to_i2c_client(dev
);
844 struct gl520_data
*data
= i2c_get_clientdata(client
);
847 mutex_lock(&data
->update_lock
);
849 if (time_after(jiffies
, data
->last_updated
+ 2 * HZ
) || !data
->valid
) {
851 dev_dbg(&client
->dev
, "Starting gl520sm update\n");
853 data
->alarms
= gl520_read_value(client
, GL520_REG_ALARMS
);
854 data
->beep_mask
= gl520_read_value(client
, GL520_REG_BEEP_MASK
);
855 data
->vid
= gl520_read_value(client
, GL520_REG_VID_INPUT
) & 0x1f;
857 for (i
= 0; i
< 4; i
++) {
858 data
->in_input
[i
] = gl520_read_value(client
,
859 GL520_REG_IN_INPUT
[i
]);
860 val
= gl520_read_value(client
, GL520_REG_IN_LIMIT
[i
]);
861 data
->in_min
[i
] = val
& 0xff;
862 data
->in_max
[i
] = (val
>> 8) & 0xff;
865 val
= gl520_read_value(client
, GL520_REG_FAN_INPUT
);
866 data
->fan_input
[0] = (val
>> 8) & 0xff;
867 data
->fan_input
[1] = val
& 0xff;
869 val
= gl520_read_value(client
, GL520_REG_FAN_MIN
);
870 data
->fan_min
[0] = (val
>> 8) & 0xff;
871 data
->fan_min
[1] = val
& 0xff;
873 data
->temp_input
[0] = gl520_read_value(client
,
874 GL520_REG_TEMP_INPUT
[0]);
875 data
->temp_max
[0] = gl520_read_value(client
,
876 GL520_REG_TEMP_MAX
[0]);
877 data
->temp_max_hyst
[0] = gl520_read_value(client
,
878 GL520_REG_TEMP_MAX_HYST
[0]);
880 val
= gl520_read_value(client
, GL520_REG_FAN_DIV
);
881 data
->fan_div
[0] = (val
>> 6) & 0x03;
882 data
->fan_div
[1] = (val
>> 4) & 0x03;
883 data
->fan_off
= (val
>> 2) & 0x01;
885 data
->alarms
&= data
->alarm_mask
;
887 val
= gl520_read_value(client
, GL520_REG_CONF
);
888 data
->beep_enable
= !((val
>> 2) & 1);
890 /* Temp1 and Vin4 are the same input */
891 if (data
->two_temps
) {
892 data
->temp_input
[1] = gl520_read_value(client
,
893 GL520_REG_TEMP_INPUT
[1]);
894 data
->temp_max
[1] = gl520_read_value(client
,
895 GL520_REG_TEMP_MAX
[1]);
896 data
->temp_max_hyst
[1] = gl520_read_value(client
,
897 GL520_REG_TEMP_MAX_HYST
[1]);
899 data
->in_input
[4] = gl520_read_value(client
,
900 GL520_REG_IN_INPUT
[4]);
901 data
->in_min
[4] = gl520_read_value(client
,
902 GL520_REG_IN_MIN
[4]);
903 data
->in_max
[4] = gl520_read_value(client
,
904 GL520_REG_IN_MAX
[4]);
907 data
->last_updated
= jiffies
;
911 mutex_unlock(&data
->update_lock
);
917 static int __init
sensors_gl520sm_init(void)
919 return i2c_add_driver(&gl520_driver
);
922 static void __exit
sensors_gl520sm_exit(void)
924 i2c_del_driver(&gl520_driver
);
928 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
929 "Kyösti Mälkki <kmalkki@cc.hut.fi>, "
930 "Maarten Deprez <maartendeprez@users.sourceforge.net>");
931 MODULE_DESCRIPTION("GL520SM driver");
932 MODULE_LICENSE("GPL");
934 module_init(sensors_gl520sm_init
);
935 module_exit(sensors_gl520sm_exit
);