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 /* Many GL520 constants specified below
45 One of the inputs can be configured as either temp or voltage.
46 That's why _TEMP2 and _IN4 access the same register
49 /* The GL520 registers */
50 #define GL520_REG_CHIP_ID 0x00
51 #define GL520_REG_REVISION 0x01
52 #define GL520_REG_CONF 0x03
53 #define GL520_REG_MASK 0x11
55 #define GL520_REG_VID_INPUT 0x02
57 static const u8 GL520_REG_IN_INPUT
[] = { 0x15, 0x14, 0x13, 0x0d, 0x0e };
58 static const u8 GL520_REG_IN_LIMIT
[] = { 0x0c, 0x09, 0x0a, 0x0b };
59 static const u8 GL520_REG_IN_MIN
[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x18 };
60 static const u8 GL520_REG_IN_MAX
[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x17 };
62 static const u8 GL520_REG_TEMP_INPUT
[] = { 0x04, 0x0e };
63 static const u8 GL520_REG_TEMP_MAX
[] = { 0x05, 0x17 };
64 static const u8 GL520_REG_TEMP_MAX_HYST
[] = { 0x06, 0x18 };
66 #define GL520_REG_FAN_INPUT 0x07
67 #define GL520_REG_FAN_MIN 0x08
68 #define GL520_REG_FAN_DIV 0x0f
69 #define GL520_REG_FAN_OFF GL520_REG_FAN_DIV
71 #define GL520_REG_ALARMS 0x12
72 #define GL520_REG_BEEP_MASK 0x10
73 #define GL520_REG_BEEP_ENABLE GL520_REG_CONF
76 * Function declarations
79 static int gl520_probe(struct i2c_client
*client
,
80 const struct i2c_device_id
*id
);
81 static int gl520_detect(struct i2c_client
*client
, struct i2c_board_info
*info
);
82 static void gl520_init_client(struct i2c_client
*client
);
83 static int gl520_remove(struct i2c_client
*client
);
84 static int gl520_read_value(struct i2c_client
*client
, u8 reg
);
85 static int gl520_write_value(struct i2c_client
*client
, u8 reg
, u16 value
);
86 static struct gl520_data
*gl520_update_device(struct device
*dev
);
89 static const struct i2c_device_id gl520_id
[] = {
93 MODULE_DEVICE_TABLE(i2c
, gl520_id
);
95 static struct i2c_driver gl520_driver
= {
96 .class = I2C_CLASS_HWMON
,
100 .probe
= gl520_probe
,
101 .remove
= gl520_remove
,
102 .id_table
= gl520_id
,
103 .detect
= gl520_detect
,
104 .address_list
= normal_i2c
,
109 struct device
*hwmon_dev
;
110 struct mutex update_lock
;
111 char valid
; /* zero until the following fields are valid */
112 unsigned long last_updated
; /* in jiffies */
116 u8 in_input
[5]; /* [0] = VVD */
117 u8 in_min
[5]; /* [0] = VDD */
118 u8 in_max
[5]; /* [0] = VDD */
137 static ssize_t
get_cpu_vid(struct device
*dev
, struct device_attribute
*attr
,
140 struct gl520_data
*data
= gl520_update_device(dev
);
141 return sprintf(buf
, "%u\n", vid_from_reg(data
->vid
, data
->vrm
));
143 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, get_cpu_vid
, NULL
);
145 #define VDD_FROM_REG(val) (((val)*95+2)/4)
146 #define VDD_TO_REG(val) (SENSORS_LIMIT((((val)*4+47)/95),0,255))
148 #define IN_FROM_REG(val) ((val)*19)
149 #define IN_TO_REG(val) (SENSORS_LIMIT((((val)+9)/19),0,255))
151 static ssize_t
get_in_input(struct device
*dev
, struct device_attribute
*attr
,
154 int n
= to_sensor_dev_attr(attr
)->index
;
155 struct gl520_data
*data
= gl520_update_device(dev
);
156 u8 r
= data
->in_input
[n
];
159 return sprintf(buf
, "%d\n", VDD_FROM_REG(r
));
161 return sprintf(buf
, "%d\n", IN_FROM_REG(r
));
164 static ssize_t
get_in_min(struct device
*dev
, struct device_attribute
*attr
,
167 int n
= to_sensor_dev_attr(attr
)->index
;
168 struct gl520_data
*data
= gl520_update_device(dev
);
169 u8 r
= data
->in_min
[n
];
172 return sprintf(buf
, "%d\n", VDD_FROM_REG(r
));
174 return sprintf(buf
, "%d\n", IN_FROM_REG(r
));
177 static ssize_t
get_in_max(struct device
*dev
, struct device_attribute
*attr
,
180 int n
= to_sensor_dev_attr(attr
)->index
;
181 struct gl520_data
*data
= gl520_update_device(dev
);
182 u8 r
= data
->in_max
[n
];
185 return sprintf(buf
, "%d\n", VDD_FROM_REG(r
));
187 return sprintf(buf
, "%d\n", IN_FROM_REG(r
));
190 static ssize_t
set_in_min(struct device
*dev
, struct device_attribute
*attr
,
191 const char *buf
, size_t count
)
193 struct i2c_client
*client
= to_i2c_client(dev
);
194 struct gl520_data
*data
= i2c_get_clientdata(client
);
195 int n
= to_sensor_dev_attr(attr
)->index
;
196 long v
= simple_strtol(buf
, NULL
, 10);
199 mutex_lock(&data
->update_lock
);
209 gl520_write_value(client
, GL520_REG_IN_MIN
[n
],
210 (gl520_read_value(client
, GL520_REG_IN_MIN
[n
])
213 gl520_write_value(client
, GL520_REG_IN_MIN
[n
], r
);
215 mutex_unlock(&data
->update_lock
);
219 static ssize_t
set_in_max(struct device
*dev
, struct device_attribute
*attr
,
220 const char *buf
, size_t count
)
222 struct i2c_client
*client
= to_i2c_client(dev
);
223 struct gl520_data
*data
= i2c_get_clientdata(client
);
224 int n
= to_sensor_dev_attr(attr
)->index
;
225 long v
= simple_strtol(buf
, NULL
, 10);
233 mutex_lock(&data
->update_lock
);
238 gl520_write_value(client
, GL520_REG_IN_MAX
[n
],
239 (gl520_read_value(client
, GL520_REG_IN_MAX
[n
])
240 & ~0xff00) | (r
<< 8));
242 gl520_write_value(client
, GL520_REG_IN_MAX
[n
], r
);
244 mutex_unlock(&data
->update_lock
);
248 static SENSOR_DEVICE_ATTR(in0_input
, S_IRUGO
, get_in_input
, NULL
, 0);
249 static SENSOR_DEVICE_ATTR(in1_input
, S_IRUGO
, get_in_input
, NULL
, 1);
250 static SENSOR_DEVICE_ATTR(in2_input
, S_IRUGO
, get_in_input
, NULL
, 2);
251 static SENSOR_DEVICE_ATTR(in3_input
, S_IRUGO
, get_in_input
, NULL
, 3);
252 static SENSOR_DEVICE_ATTR(in4_input
, S_IRUGO
, get_in_input
, NULL
, 4);
253 static SENSOR_DEVICE_ATTR(in0_min
, S_IRUGO
| S_IWUSR
,
254 get_in_min
, set_in_min
, 0);
255 static SENSOR_DEVICE_ATTR(in1_min
, S_IRUGO
| S_IWUSR
,
256 get_in_min
, set_in_min
, 1);
257 static SENSOR_DEVICE_ATTR(in2_min
, S_IRUGO
| S_IWUSR
,
258 get_in_min
, set_in_min
, 2);
259 static SENSOR_DEVICE_ATTR(in3_min
, S_IRUGO
| S_IWUSR
,
260 get_in_min
, set_in_min
, 3);
261 static SENSOR_DEVICE_ATTR(in4_min
, S_IRUGO
| S_IWUSR
,
262 get_in_min
, set_in_min
, 4);
263 static SENSOR_DEVICE_ATTR(in0_max
, S_IRUGO
| S_IWUSR
,
264 get_in_max
, set_in_max
, 0);
265 static SENSOR_DEVICE_ATTR(in1_max
, S_IRUGO
| S_IWUSR
,
266 get_in_max
, set_in_max
, 1);
267 static SENSOR_DEVICE_ATTR(in2_max
, S_IRUGO
| S_IWUSR
,
268 get_in_max
, set_in_max
, 2);
269 static SENSOR_DEVICE_ATTR(in3_max
, S_IRUGO
| S_IWUSR
,
270 get_in_max
, set_in_max
, 3);
271 static SENSOR_DEVICE_ATTR(in4_max
, S_IRUGO
| S_IWUSR
,
272 get_in_max
, set_in_max
, 4);
274 #define DIV_FROM_REG(val) (1 << (val))
275 #define FAN_FROM_REG(val,div) ((val)==0 ? 0 : (480000/((val) << (div))))
276 #define FAN_TO_REG(val,div) ((val)<=0?0:SENSORS_LIMIT((480000 + ((val) << ((div)-1))) / ((val) << (div)), 1, 255))
278 static ssize_t
get_fan_input(struct device
*dev
, struct device_attribute
*attr
,
281 int n
= to_sensor_dev_attr(attr
)->index
;
282 struct gl520_data
*data
= gl520_update_device(dev
);
284 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan_input
[n
],
288 static ssize_t
get_fan_min(struct device
*dev
, struct device_attribute
*attr
,
291 int n
= to_sensor_dev_attr(attr
)->index
;
292 struct gl520_data
*data
= gl520_update_device(dev
);
294 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan_min
[n
],
298 static ssize_t
get_fan_div(struct device
*dev
, struct device_attribute
*attr
,
301 int n
= to_sensor_dev_attr(attr
)->index
;
302 struct gl520_data
*data
= gl520_update_device(dev
);
304 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[n
]));
307 static ssize_t
get_fan_off(struct device
*dev
, struct device_attribute
*attr
,
310 struct gl520_data
*data
= gl520_update_device(dev
);
311 return sprintf(buf
, "%d\n", data
->fan_off
);
314 static ssize_t
set_fan_min(struct device
*dev
, struct device_attribute
*attr
,
315 const char *buf
, size_t count
)
317 struct i2c_client
*client
= to_i2c_client(dev
);
318 struct gl520_data
*data
= i2c_get_clientdata(client
);
319 int n
= to_sensor_dev_attr(attr
)->index
;
320 unsigned long v
= simple_strtoul(buf
, NULL
, 10);
323 mutex_lock(&data
->update_lock
);
324 r
= FAN_TO_REG(v
, data
->fan_div
[n
]);
325 data
->fan_min
[n
] = r
;
328 gl520_write_value(client
, GL520_REG_FAN_MIN
,
329 (gl520_read_value(client
, GL520_REG_FAN_MIN
)
330 & ~0xff00) | (r
<< 8));
332 gl520_write_value(client
, GL520_REG_FAN_MIN
,
333 (gl520_read_value(client
, GL520_REG_FAN_MIN
)
336 data
->beep_mask
= gl520_read_value(client
, GL520_REG_BEEP_MASK
);
337 if (data
->fan_min
[n
] == 0)
338 data
->alarm_mask
&= (n
== 0) ? ~0x20 : ~0x40;
340 data
->alarm_mask
|= (n
== 0) ? 0x20 : 0x40;
341 data
->beep_mask
&= data
->alarm_mask
;
342 gl520_write_value(client
, GL520_REG_BEEP_MASK
, data
->beep_mask
);
344 mutex_unlock(&data
->update_lock
);
348 static ssize_t
set_fan_div(struct device
*dev
, struct device_attribute
*attr
,
349 const char *buf
, size_t count
)
351 struct i2c_client
*client
= to_i2c_client(dev
);
352 struct gl520_data
*data
= i2c_get_clientdata(client
);
353 int n
= to_sensor_dev_attr(attr
)->index
;
354 unsigned long v
= simple_strtoul(buf
, NULL
, 10);
358 case 1: r
= 0; break;
359 case 2: r
= 1; break;
360 case 4: r
= 2; break;
361 case 8: r
= 3; break;
363 dev_err(&client
->dev
, "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", v
);
367 mutex_lock(&data
->update_lock
);
368 data
->fan_div
[n
] = r
;
371 gl520_write_value(client
, GL520_REG_FAN_DIV
,
372 (gl520_read_value(client
, GL520_REG_FAN_DIV
)
373 & ~0xc0) | (r
<< 6));
375 gl520_write_value(client
, GL520_REG_FAN_DIV
,
376 (gl520_read_value(client
, GL520_REG_FAN_DIV
)
377 & ~0x30) | (r
<< 4));
379 mutex_unlock(&data
->update_lock
);
383 static ssize_t
set_fan_off(struct device
*dev
, struct device_attribute
*attr
,
384 const char *buf
, size_t count
)
386 struct i2c_client
*client
= to_i2c_client(dev
);
387 struct gl520_data
*data
= i2c_get_clientdata(client
);
388 u8 r
= simple_strtoul(buf
, NULL
, 10)?1:0;
390 mutex_lock(&data
->update_lock
);
392 gl520_write_value(client
, GL520_REG_FAN_OFF
,
393 (gl520_read_value(client
, GL520_REG_FAN_OFF
)
394 & ~0x0c) | (r
<< 2));
395 mutex_unlock(&data
->update_lock
);
399 static SENSOR_DEVICE_ATTR(fan1_input
, S_IRUGO
, get_fan_input
, NULL
, 0);
400 static SENSOR_DEVICE_ATTR(fan2_input
, S_IRUGO
, get_fan_input
, NULL
, 1);
401 static SENSOR_DEVICE_ATTR(fan1_min
, S_IRUGO
| S_IWUSR
,
402 get_fan_min
, set_fan_min
, 0);
403 static SENSOR_DEVICE_ATTR(fan2_min
, S_IRUGO
| S_IWUSR
,
404 get_fan_min
, set_fan_min
, 1);
405 static SENSOR_DEVICE_ATTR(fan1_div
, S_IRUGO
| S_IWUSR
,
406 get_fan_div
, set_fan_div
, 0);
407 static SENSOR_DEVICE_ATTR(fan2_div
, S_IRUGO
| S_IWUSR
,
408 get_fan_div
, set_fan_div
, 1);
409 static DEVICE_ATTR(fan1_off
, S_IRUGO
| S_IWUSR
,
410 get_fan_off
, set_fan_off
);
412 #define TEMP_FROM_REG(val) (((val) - 130) * 1000)
413 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((((val)<0?(val)-500:(val)+500) / 1000)+130),0,255))
415 static ssize_t
get_temp_input(struct device
*dev
, struct device_attribute
*attr
,
418 int n
= to_sensor_dev_attr(attr
)->index
;
419 struct gl520_data
*data
= gl520_update_device(dev
);
421 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_input
[n
]));
424 static ssize_t
get_temp_max(struct device
*dev
, struct device_attribute
*attr
,
427 int n
= to_sensor_dev_attr(attr
)->index
;
428 struct gl520_data
*data
= gl520_update_device(dev
);
430 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_max
[n
]));
433 static ssize_t
get_temp_max_hyst(struct device
*dev
, struct device_attribute
436 int n
= to_sensor_dev_attr(attr
)->index
;
437 struct gl520_data
*data
= gl520_update_device(dev
);
439 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_max_hyst
[n
]));
442 static ssize_t
set_temp_max(struct device
*dev
, struct device_attribute
*attr
,
443 const char *buf
, size_t count
)
445 struct i2c_client
*client
= to_i2c_client(dev
);
446 struct gl520_data
*data
= i2c_get_clientdata(client
);
447 int n
= to_sensor_dev_attr(attr
)->index
;
448 long v
= simple_strtol(buf
, NULL
, 10);
450 mutex_lock(&data
->update_lock
);
451 data
->temp_max
[n
] = TEMP_TO_REG(v
);
452 gl520_write_value(client
, GL520_REG_TEMP_MAX
[n
], data
->temp_max
[n
]);
453 mutex_unlock(&data
->update_lock
);
457 static ssize_t
set_temp_max_hyst(struct device
*dev
, struct device_attribute
458 *attr
, const char *buf
, size_t count
)
460 struct i2c_client
*client
= to_i2c_client(dev
);
461 struct gl520_data
*data
= i2c_get_clientdata(client
);
462 int n
= to_sensor_dev_attr(attr
)->index
;
463 long v
= simple_strtol(buf
, NULL
, 10);
465 mutex_lock(&data
->update_lock
);
466 data
->temp_max_hyst
[n
] = TEMP_TO_REG(v
);
467 gl520_write_value(client
, GL520_REG_TEMP_MAX_HYST
[n
],
468 data
->temp_max_hyst
[n
]);
469 mutex_unlock(&data
->update_lock
);
473 static SENSOR_DEVICE_ATTR(temp1_input
, S_IRUGO
, get_temp_input
, NULL
, 0);
474 static SENSOR_DEVICE_ATTR(temp2_input
, S_IRUGO
, get_temp_input
, NULL
, 1);
475 static SENSOR_DEVICE_ATTR(temp1_max
, S_IRUGO
| S_IWUSR
,
476 get_temp_max
, set_temp_max
, 0);
477 static SENSOR_DEVICE_ATTR(temp2_max
, S_IRUGO
| S_IWUSR
,
478 get_temp_max
, set_temp_max
, 1);
479 static SENSOR_DEVICE_ATTR(temp1_max_hyst
, S_IRUGO
| S_IWUSR
,
480 get_temp_max_hyst
, set_temp_max_hyst
, 0);
481 static SENSOR_DEVICE_ATTR(temp2_max_hyst
, S_IRUGO
| S_IWUSR
,
482 get_temp_max_hyst
, set_temp_max_hyst
, 1);
484 static ssize_t
get_alarms(struct device
*dev
, struct device_attribute
*attr
,
487 struct gl520_data
*data
= gl520_update_device(dev
);
488 return sprintf(buf
, "%d\n", data
->alarms
);
491 static ssize_t
get_beep_enable(struct device
*dev
, struct device_attribute
494 struct gl520_data
*data
= gl520_update_device(dev
);
495 return sprintf(buf
, "%d\n", data
->beep_enable
);
498 static ssize_t
get_beep_mask(struct device
*dev
, struct device_attribute
*attr
,
501 struct gl520_data
*data
= gl520_update_device(dev
);
502 return sprintf(buf
, "%d\n", data
->beep_mask
);
505 static ssize_t
set_beep_enable(struct device
*dev
, struct device_attribute
506 *attr
, const char *buf
, size_t count
)
508 struct i2c_client
*client
= to_i2c_client(dev
);
509 struct gl520_data
*data
= i2c_get_clientdata(client
);
510 u8 r
= simple_strtoul(buf
, NULL
, 10)?0:1;
512 mutex_lock(&data
->update_lock
);
513 data
->beep_enable
= !r
;
514 gl520_write_value(client
, GL520_REG_BEEP_ENABLE
,
515 (gl520_read_value(client
, GL520_REG_BEEP_ENABLE
)
516 & ~0x04) | (r
<< 2));
517 mutex_unlock(&data
->update_lock
);
521 static ssize_t
set_beep_mask(struct device
*dev
, struct device_attribute
*attr
,
522 const char *buf
, size_t count
)
524 struct i2c_client
*client
= to_i2c_client(dev
);
525 struct gl520_data
*data
= i2c_get_clientdata(client
);
526 u8 r
= simple_strtoul(buf
, NULL
, 10);
528 mutex_lock(&data
->update_lock
);
529 r
&= data
->alarm_mask
;
531 gl520_write_value(client
, GL520_REG_BEEP_MASK
, r
);
532 mutex_unlock(&data
->update_lock
);
536 static DEVICE_ATTR(alarms
, S_IRUGO
, get_alarms
, NULL
);
537 static DEVICE_ATTR(beep_enable
, S_IRUGO
| S_IWUSR
,
538 get_beep_enable
, set_beep_enable
);
539 static DEVICE_ATTR(beep_mask
, S_IRUGO
| S_IWUSR
,
540 get_beep_mask
, set_beep_mask
);
542 static ssize_t
get_alarm(struct device
*dev
, struct device_attribute
*attr
,
545 int bit_nr
= to_sensor_dev_attr(attr
)->index
;
546 struct gl520_data
*data
= gl520_update_device(dev
);
548 return sprintf(buf
, "%d\n", (data
->alarms
>> bit_nr
) & 1);
551 static SENSOR_DEVICE_ATTR(in0_alarm
, S_IRUGO
, get_alarm
, NULL
, 0);
552 static SENSOR_DEVICE_ATTR(in1_alarm
, S_IRUGO
, get_alarm
, NULL
, 1);
553 static SENSOR_DEVICE_ATTR(in2_alarm
, S_IRUGO
, get_alarm
, NULL
, 2);
554 static SENSOR_DEVICE_ATTR(in3_alarm
, S_IRUGO
, get_alarm
, NULL
, 3);
555 static SENSOR_DEVICE_ATTR(temp1_alarm
, S_IRUGO
, get_alarm
, NULL
, 4);
556 static SENSOR_DEVICE_ATTR(fan1_alarm
, S_IRUGO
, get_alarm
, NULL
, 5);
557 static SENSOR_DEVICE_ATTR(fan2_alarm
, S_IRUGO
, get_alarm
, NULL
, 6);
558 static SENSOR_DEVICE_ATTR(temp2_alarm
, S_IRUGO
, get_alarm
, NULL
, 7);
559 static SENSOR_DEVICE_ATTR(in4_alarm
, S_IRUGO
, get_alarm
, NULL
, 7);
561 static ssize_t
get_beep(struct device
*dev
, struct device_attribute
*attr
,
564 int bitnr
= to_sensor_dev_attr(attr
)->index
;
565 struct gl520_data
*data
= gl520_update_device(dev
);
567 return sprintf(buf
, "%d\n", (data
->beep_mask
>> bitnr
) & 1);
570 static ssize_t
set_beep(struct device
*dev
, struct device_attribute
*attr
,
571 const char *buf
, size_t count
)
573 struct i2c_client
*client
= to_i2c_client(dev
);
574 struct gl520_data
*data
= i2c_get_clientdata(client
);
575 int bitnr
= to_sensor_dev_attr(attr
)->index
;
578 bit
= simple_strtoul(buf
, NULL
, 10);
582 mutex_lock(&data
->update_lock
);
583 data
->beep_mask
= gl520_read_value(client
, GL520_REG_BEEP_MASK
);
585 data
->beep_mask
|= (1 << bitnr
);
587 data
->beep_mask
&= ~(1 << bitnr
);
588 gl520_write_value(client
, GL520_REG_BEEP_MASK
, data
->beep_mask
);
589 mutex_unlock(&data
->update_lock
);
593 static SENSOR_DEVICE_ATTR(in0_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 0);
594 static SENSOR_DEVICE_ATTR(in1_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 1);
595 static SENSOR_DEVICE_ATTR(in2_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 2);
596 static SENSOR_DEVICE_ATTR(in3_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 3);
597 static SENSOR_DEVICE_ATTR(temp1_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 4);
598 static SENSOR_DEVICE_ATTR(fan1_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 5);
599 static SENSOR_DEVICE_ATTR(fan2_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 6);
600 static SENSOR_DEVICE_ATTR(temp2_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 7);
601 static SENSOR_DEVICE_ATTR(in4_beep
, S_IRUGO
| S_IWUSR
, get_beep
, set_beep
, 7);
603 static struct attribute
*gl520_attributes
[] = {
604 &dev_attr_cpu0_vid
.attr
,
606 &sensor_dev_attr_in0_input
.dev_attr
.attr
,
607 &sensor_dev_attr_in0_min
.dev_attr
.attr
,
608 &sensor_dev_attr_in0_max
.dev_attr
.attr
,
609 &sensor_dev_attr_in0_alarm
.dev_attr
.attr
,
610 &sensor_dev_attr_in0_beep
.dev_attr
.attr
,
611 &sensor_dev_attr_in1_input
.dev_attr
.attr
,
612 &sensor_dev_attr_in1_min
.dev_attr
.attr
,
613 &sensor_dev_attr_in1_max
.dev_attr
.attr
,
614 &sensor_dev_attr_in1_alarm
.dev_attr
.attr
,
615 &sensor_dev_attr_in1_beep
.dev_attr
.attr
,
616 &sensor_dev_attr_in2_input
.dev_attr
.attr
,
617 &sensor_dev_attr_in2_min
.dev_attr
.attr
,
618 &sensor_dev_attr_in2_max
.dev_attr
.attr
,
619 &sensor_dev_attr_in2_alarm
.dev_attr
.attr
,
620 &sensor_dev_attr_in2_beep
.dev_attr
.attr
,
621 &sensor_dev_attr_in3_input
.dev_attr
.attr
,
622 &sensor_dev_attr_in3_min
.dev_attr
.attr
,
623 &sensor_dev_attr_in3_max
.dev_attr
.attr
,
624 &sensor_dev_attr_in3_alarm
.dev_attr
.attr
,
625 &sensor_dev_attr_in3_beep
.dev_attr
.attr
,
627 &sensor_dev_attr_fan1_input
.dev_attr
.attr
,
628 &sensor_dev_attr_fan1_min
.dev_attr
.attr
,
629 &sensor_dev_attr_fan1_div
.dev_attr
.attr
,
630 &sensor_dev_attr_fan1_alarm
.dev_attr
.attr
,
631 &sensor_dev_attr_fan1_beep
.dev_attr
.attr
,
632 &dev_attr_fan1_off
.attr
,
633 &sensor_dev_attr_fan2_input
.dev_attr
.attr
,
634 &sensor_dev_attr_fan2_min
.dev_attr
.attr
,
635 &sensor_dev_attr_fan2_div
.dev_attr
.attr
,
636 &sensor_dev_attr_fan2_alarm
.dev_attr
.attr
,
637 &sensor_dev_attr_fan2_beep
.dev_attr
.attr
,
639 &sensor_dev_attr_temp1_input
.dev_attr
.attr
,
640 &sensor_dev_attr_temp1_max
.dev_attr
.attr
,
641 &sensor_dev_attr_temp1_max_hyst
.dev_attr
.attr
,
642 &sensor_dev_attr_temp1_alarm
.dev_attr
.attr
,
643 &sensor_dev_attr_temp1_beep
.dev_attr
.attr
,
645 &dev_attr_alarms
.attr
,
646 &dev_attr_beep_enable
.attr
,
647 &dev_attr_beep_mask
.attr
,
651 static const struct attribute_group gl520_group
= {
652 .attrs
= gl520_attributes
,
655 static struct attribute
*gl520_attributes_opt
[] = {
656 &sensor_dev_attr_in4_input
.dev_attr
.attr
,
657 &sensor_dev_attr_in4_min
.dev_attr
.attr
,
658 &sensor_dev_attr_in4_max
.dev_attr
.attr
,
659 &sensor_dev_attr_in4_alarm
.dev_attr
.attr
,
660 &sensor_dev_attr_in4_beep
.dev_attr
.attr
,
662 &sensor_dev_attr_temp2_input
.dev_attr
.attr
,
663 &sensor_dev_attr_temp2_max
.dev_attr
.attr
,
664 &sensor_dev_attr_temp2_max_hyst
.dev_attr
.attr
,
665 &sensor_dev_attr_temp2_alarm
.dev_attr
.attr
,
666 &sensor_dev_attr_temp2_beep
.dev_attr
.attr
,
670 static const struct attribute_group gl520_group_opt
= {
671 .attrs
= gl520_attributes_opt
,
679 /* Return 0 if detection is successful, -ENODEV otherwise */
680 static int gl520_detect(struct i2c_client
*client
, struct i2c_board_info
*info
)
682 struct i2c_adapter
*adapter
= client
->adapter
;
684 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
|
685 I2C_FUNC_SMBUS_WORD_DATA
))
688 /* Determine the chip type. */
689 if ((gl520_read_value(client
, GL520_REG_CHIP_ID
) != 0x20) ||
690 ((gl520_read_value(client
, GL520_REG_REVISION
) & 0x7f) != 0x00) ||
691 ((gl520_read_value(client
, GL520_REG_CONF
) & 0x80) != 0x00)) {
692 dev_dbg(&client
->dev
, "Unknown chip type, skipping\n");
696 strlcpy(info
->type
, "gl520sm", I2C_NAME_SIZE
);
701 static int gl520_probe(struct i2c_client
*client
,
702 const struct i2c_device_id
*id
)
704 struct gl520_data
*data
;
707 data
= kzalloc(sizeof(struct gl520_data
), GFP_KERNEL
);
713 i2c_set_clientdata(client
, data
);
714 mutex_init(&data
->update_lock
);
716 /* Initialize the GL520SM chip */
717 gl520_init_client(client
);
719 /* Register sysfs hooks */
720 if ((err
= sysfs_create_group(&client
->dev
.kobj
, &gl520_group
)))
723 if (data
->two_temps
) {
724 if ((err
= device_create_file(&client
->dev
,
725 &sensor_dev_attr_temp2_input
.dev_attr
))
726 || (err
= device_create_file(&client
->dev
,
727 &sensor_dev_attr_temp2_max
.dev_attr
))
728 || (err
= device_create_file(&client
->dev
,
729 &sensor_dev_attr_temp2_max_hyst
.dev_attr
))
730 || (err
= device_create_file(&client
->dev
,
731 &sensor_dev_attr_temp2_alarm
.dev_attr
))
732 || (err
= device_create_file(&client
->dev
,
733 &sensor_dev_attr_temp2_beep
.dev_attr
)))
734 goto exit_remove_files
;
736 if ((err
= device_create_file(&client
->dev
,
737 &sensor_dev_attr_in4_input
.dev_attr
))
738 || (err
= device_create_file(&client
->dev
,
739 &sensor_dev_attr_in4_min
.dev_attr
))
740 || (err
= device_create_file(&client
->dev
,
741 &sensor_dev_attr_in4_max
.dev_attr
))
742 || (err
= device_create_file(&client
->dev
,
743 &sensor_dev_attr_in4_alarm
.dev_attr
))
744 || (err
= device_create_file(&client
->dev
,
745 &sensor_dev_attr_in4_beep
.dev_attr
)))
746 goto exit_remove_files
;
750 data
->hwmon_dev
= hwmon_device_register(&client
->dev
);
751 if (IS_ERR(data
->hwmon_dev
)) {
752 err
= PTR_ERR(data
->hwmon_dev
);
753 goto exit_remove_files
;
759 sysfs_remove_group(&client
->dev
.kobj
, &gl520_group
);
760 sysfs_remove_group(&client
->dev
.kobj
, &gl520_group_opt
);
768 /* Called when we have found a new GL520SM. */
769 static void gl520_init_client(struct i2c_client
*client
)
771 struct gl520_data
*data
= i2c_get_clientdata(client
);
774 conf
= oldconf
= gl520_read_value(client
, GL520_REG_CONF
);
776 data
->alarm_mask
= 0xff;
777 data
->vrm
= vid_which_vrm();
779 if (extra_sensor_type
== 1)
781 else if (extra_sensor_type
== 2)
783 data
->two_temps
= !(conf
& 0x10);
785 /* If IRQ# is disabled, we can safely force comparator mode */
789 /* Enable monitoring if needed */
793 gl520_write_value(client
, GL520_REG_CONF
, conf
);
795 gl520_update_device(&(client
->dev
));
797 if (data
->fan_min
[0] == 0)
798 data
->alarm_mask
&= ~0x20;
799 if (data
->fan_min
[1] == 0)
800 data
->alarm_mask
&= ~0x40;
802 data
->beep_mask
&= data
->alarm_mask
;
803 gl520_write_value(client
, GL520_REG_BEEP_MASK
, data
->beep_mask
);
806 static int gl520_remove(struct i2c_client
*client
)
808 struct gl520_data
*data
= i2c_get_clientdata(client
);
810 hwmon_device_unregister(data
->hwmon_dev
);
811 sysfs_remove_group(&client
->dev
.kobj
, &gl520_group
);
812 sysfs_remove_group(&client
->dev
.kobj
, &gl520_group_opt
);
819 /* Registers 0x07 to 0x0c are word-sized, others are byte-sized
820 GL520 uses a high-byte first convention */
821 static int gl520_read_value(struct i2c_client
*client
, u8 reg
)
823 if ((reg
>= 0x07) && (reg
<= 0x0c))
824 return i2c_smbus_read_word_swapped(client
, reg
);
826 return i2c_smbus_read_byte_data(client
, reg
);
829 static int gl520_write_value(struct i2c_client
*client
, u8 reg
, u16 value
)
831 if ((reg
>= 0x07) && (reg
<= 0x0c))
832 return i2c_smbus_write_word_swapped(client
, reg
, value
);
834 return i2c_smbus_write_byte_data(client
, reg
, value
);
838 static struct gl520_data
*gl520_update_device(struct device
*dev
)
840 struct i2c_client
*client
= to_i2c_client(dev
);
841 struct gl520_data
*data
= i2c_get_clientdata(client
);
844 mutex_lock(&data
->update_lock
);
846 if (time_after(jiffies
, data
->last_updated
+ 2 * HZ
) || !data
->valid
) {
848 dev_dbg(&client
->dev
, "Starting gl520sm update\n");
850 data
->alarms
= gl520_read_value(client
, GL520_REG_ALARMS
);
851 data
->beep_mask
= gl520_read_value(client
, GL520_REG_BEEP_MASK
);
852 data
->vid
= gl520_read_value(client
, GL520_REG_VID_INPUT
) & 0x1f;
854 for (i
= 0; i
< 4; i
++) {
855 data
->in_input
[i
] = gl520_read_value(client
,
856 GL520_REG_IN_INPUT
[i
]);
857 val
= gl520_read_value(client
, GL520_REG_IN_LIMIT
[i
]);
858 data
->in_min
[i
] = val
& 0xff;
859 data
->in_max
[i
] = (val
>> 8) & 0xff;
862 val
= gl520_read_value(client
, GL520_REG_FAN_INPUT
);
863 data
->fan_input
[0] = (val
>> 8) & 0xff;
864 data
->fan_input
[1] = val
& 0xff;
866 val
= gl520_read_value(client
, GL520_REG_FAN_MIN
);
867 data
->fan_min
[0] = (val
>> 8) & 0xff;
868 data
->fan_min
[1] = val
& 0xff;
870 data
->temp_input
[0] = gl520_read_value(client
,
871 GL520_REG_TEMP_INPUT
[0]);
872 data
->temp_max
[0] = gl520_read_value(client
,
873 GL520_REG_TEMP_MAX
[0]);
874 data
->temp_max_hyst
[0] = gl520_read_value(client
,
875 GL520_REG_TEMP_MAX_HYST
[0]);
877 val
= gl520_read_value(client
, GL520_REG_FAN_DIV
);
878 data
->fan_div
[0] = (val
>> 6) & 0x03;
879 data
->fan_div
[1] = (val
>> 4) & 0x03;
880 data
->fan_off
= (val
>> 2) & 0x01;
882 data
->alarms
&= data
->alarm_mask
;
884 val
= gl520_read_value(client
, GL520_REG_CONF
);
885 data
->beep_enable
= !((val
>> 2) & 1);
887 /* Temp1 and Vin4 are the same input */
888 if (data
->two_temps
) {
889 data
->temp_input
[1] = gl520_read_value(client
,
890 GL520_REG_TEMP_INPUT
[1]);
891 data
->temp_max
[1] = gl520_read_value(client
,
892 GL520_REG_TEMP_MAX
[1]);
893 data
->temp_max_hyst
[1] = gl520_read_value(client
,
894 GL520_REG_TEMP_MAX_HYST
[1]);
896 data
->in_input
[4] = gl520_read_value(client
,
897 GL520_REG_IN_INPUT
[4]);
898 data
->in_min
[4] = gl520_read_value(client
,
899 GL520_REG_IN_MIN
[4]);
900 data
->in_max
[4] = gl520_read_value(client
,
901 GL520_REG_IN_MAX
[4]);
904 data
->last_updated
= jiffies
;
908 mutex_unlock(&data
->update_lock
);
914 static int __init
sensors_gl520sm_init(void)
916 return i2c_add_driver(&gl520_driver
);
919 static void __exit
sensors_gl520sm_exit(void)
921 i2c_del_driver(&gl520_driver
);
925 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
926 "Kyösti Mälkki <kmalkki@cc.hut.fi>, "
927 "Maarten Deprez <maartendeprez@users.sourceforge.net>");
928 MODULE_DESCRIPTION("GL520SM driver");
929 MODULE_LICENSE("GPL");
931 module_init(sensors_gl520sm_init
);
932 module_exit(sensors_gl520sm_exit
);