← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/hwmon/gl520sm.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/hwmon/gl520sm.c
 
1
/*
 
2
    gl520sm.c - Part of lm_sensors, Linux kernel modules for hardware
 
3
                monitoring
 
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>
 
7
 
 
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.
 
12
 
 
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.
 
17
 
 
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.
 
21
 
 
22
*/
 
23
 
 
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>
 
35
 
 
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)");
 
40
 
 
41
/* Addresses to scan */
 
42
static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
 
43
 
 
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
 
47
*/
 
48
 
 
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
 
54
 
 
55
#define GL520_REG_VID_INPUT             0x02
 
56
 
 
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 };
 
61
 
 
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 };
 
65
 
 
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
 
70
 
 
71
#define GL520_REG_ALARMS                0x12
 
72
#define GL520_REG_BEEP_MASK             0x10
 
73
#define GL520_REG_BEEP_ENABLE           GL520_REG_CONF
 
74
 
 
75
/*
 
76
 * Function declarations
 
77
 */
 
78
 
 
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);
 
87
 
 
88
/* Driver data */
 
89
static const struct i2c_device_id gl520_id[] = {
 
90
        { "gl520sm", 0 },
 
91
        { }
 
92
};
 
93
MODULE_DEVICE_TABLE(i2c, gl520_id);
 
94
 
 
95
static struct i2c_driver gl520_driver = {
 
96
        .class          = I2C_CLASS_HWMON,
 
97
        .driver = {
 
98
                .name   = "gl520sm",
 
99
        },
 
100
        .probe          = gl520_probe,
 
101
        .remove         = gl520_remove,
 
102
        .id_table       = gl520_id,
 
103
        .detect         = gl520_detect,
 
104
        .address_list   = normal_i2c,
 
105
};
 
106
 
 
107
/* Client data */
 
108
struct gl520_data {
 
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 */
 
113
 
 
114
        u8 vid;
 
115
        u8 vrm;
 
116
        u8 in_input[5];         /* [0] = VVD */
 
117
        u8 in_min[5];           /* [0] = VDD */
 
118
        u8 in_max[5];           /* [0] = VDD */
 
119
        u8 fan_input[2];
 
120
        u8 fan_min[2];
 
121
        u8 fan_div[2];
 
122
        u8 fan_off;
 
123
        u8 temp_input[2];
 
124
        u8 temp_max[2];
 
125
        u8 temp_max_hyst[2];
 
126
        u8 alarms;
 
127
        u8 beep_enable;
 
128
        u8 beep_mask;
 
129
        u8 alarm_mask;
 
130
        u8 two_temps;
 
131
};
 
132
 
 
133
/*
 
134
 * Sysfs stuff
 
135
 */
 
136
 
 
137
static ssize_t get_cpu_vid(struct device *dev, struct device_attribute *attr,
 
138
                           char *buf)
 
139
{
 
140
        struct gl520_data *data = gl520_update_device(dev);
 
141
        return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
 
142
}
 
143
static DEVICE_ATTR(cpu0_vid, S_IRUGO, get_cpu_vid, NULL);
 
144
 
 
145
#define VDD_FROM_REG(val) (((val)*95+2)/4)
 
146
#define VDD_TO_REG(val) (SENSORS_LIMIT((((val)*4+47)/95),0,255))
 
147
 
 
148
#define IN_FROM_REG(val) ((val)*19)
 
149
#define IN_TO_REG(val) (SENSORS_LIMIT((((val)+9)/19),0,255))
 
150
 
 
151
static ssize_t get_in_input(struct device *dev, struct device_attribute *attr,
 
152
                            char *buf)
 
153
{
 
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];
 
157
 
 
158
        if (n == 0)
 
159
                return sprintf(buf, "%d\n", VDD_FROM_REG(r));
 
160
        else
 
161
                return sprintf(buf, "%d\n", IN_FROM_REG(r));
 
162
}
 
163
 
 
164
static ssize_t get_in_min(struct device *dev, struct device_attribute *attr,
 
165
                          char *buf)
 
166
{
 
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];
 
170
 
 
171
        if (n == 0)
 
172
                return sprintf(buf, "%d\n", VDD_FROM_REG(r));
 
173
        else
 
174
                return sprintf(buf, "%d\n", IN_FROM_REG(r));
 
175
}
 
176
 
 
177
static ssize_t get_in_max(struct device *dev, struct device_attribute *attr,
 
178
                          char *buf)
 
179
{
 
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];
 
183
 
 
184
        if (n == 0)
 
185
                return sprintf(buf, "%d\n", VDD_FROM_REG(r));
 
186
        else
 
187
                return sprintf(buf, "%d\n", IN_FROM_REG(r));
 
188
}
 
189
 
 
190
static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
 
191
                          const char *buf, size_t count)
 
192
{
 
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);
 
197
        u8 r;
 
198
 
 
199
        mutex_lock(&data->update_lock);
 
200
 
 
201
        if (n == 0)
 
202
                r = VDD_TO_REG(v);
 
203
        else
 
204
                r = IN_TO_REG(v);
 
205
 
 
206
        data->in_min[n] = r;
 
207
 
 
208
        if (n < 4)
 
209
                gl520_write_value(client, GL520_REG_IN_MIN[n],
 
210
                                  (gl520_read_value(client, GL520_REG_IN_MIN[n])
 
211
                                   & ~0xff) | r);
 
212
        else
 
213
                gl520_write_value(client, GL520_REG_IN_MIN[n], r);
 
214
 
 
215
        mutex_unlock(&data->update_lock);
 
216
        return count;
 
217
}
 
218
 
 
219
static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
 
220
                          const char *buf, size_t count)
 
221
{
 
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);
 
226
        u8 r;
 
227
 
 
228
        if (n == 0)
 
229
                r = VDD_TO_REG(v);
 
230
        else
 
231
                r = IN_TO_REG(v);
 
232
 
 
233
        mutex_lock(&data->update_lock);
 
234
 
 
235
        data->in_max[n] = r;
 
236
 
 
237
        if (n < 4)
 
238
                gl520_write_value(client, GL520_REG_IN_MAX[n],
 
239
                                  (gl520_read_value(client, GL520_REG_IN_MAX[n])
 
240
                                   & ~0xff00) | (r << 8));
 
241
        else
 
242
                gl520_write_value(client, GL520_REG_IN_MAX[n], r);
 
243
 
 
244
        mutex_unlock(&data->update_lock);
 
245
        return count;
 
246
}
 
247
 
 
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);
 
273
 
 
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))
 
277
 
 
278
static ssize_t get_fan_input(struct device *dev, struct device_attribute *attr,
 
279
                             char *buf)
 
280
{
 
281
        int n = to_sensor_dev_attr(attr)->index;
 
282
        struct gl520_data *data = gl520_update_device(dev);
 
283
 
 
284
        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_input[n],
 
285
                                                 data->fan_div[n]));
 
286
}
 
287
 
 
288
static ssize_t get_fan_min(struct device *dev, struct device_attribute *attr,
 
289
                           char *buf)
 
290
{
 
291
        int n = to_sensor_dev_attr(attr)->index;
 
292
        struct gl520_data *data = gl520_update_device(dev);
 
293
 
 
294
        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[n],
 
295
                                                 data->fan_div[n]));
 
296
}
 
297
 
 
298
static ssize_t get_fan_div(struct device *dev, struct device_attribute *attr,
 
299
                           char *buf)
 
300
{
 
301
        int n = to_sensor_dev_attr(attr)->index;
 
302
        struct gl520_data *data = gl520_update_device(dev);
 
303
 
 
304
        return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[n]));
 
305
}
 
306
 
 
307
static ssize_t get_fan_off(struct device *dev, struct device_attribute *attr,
 
308
                           char *buf)
 
309
{
 
310
        struct gl520_data *data = gl520_update_device(dev);
 
311
        return sprintf(buf, "%d\n", data->fan_off);
 
312
}
 
313
 
 
314
static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
 
315
                           const char *buf, size_t count)
 
316
{
 
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);
 
321
        u8 r;
 
322
 
 
323
        mutex_lock(&data->update_lock);
 
324
        r = FAN_TO_REG(v, data->fan_div[n]);
 
325
        data->fan_min[n] = r;
 
326
 
 
327
        if (n == 0)
 
328
                gl520_write_value(client, GL520_REG_FAN_MIN,
 
329
                                  (gl520_read_value(client, GL520_REG_FAN_MIN)
 
330
                                   & ~0xff00) | (r << 8));
 
331
        else
 
332
                gl520_write_value(client, GL520_REG_FAN_MIN,
 
333
                                  (gl520_read_value(client, GL520_REG_FAN_MIN)
 
334
                                   & ~0xff) | r);
 
335
 
 
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;
 
339
        else
 
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);
 
343
 
 
344
        mutex_unlock(&data->update_lock);
 
345
        return count;
 
346
}
 
347
 
 
348
static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
 
349
                           const char *buf, size_t count)
 
350
{
 
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);
 
355
        u8 r;
 
356
 
 
357
        switch (v) {
 
358
        case 1: r = 0; break;
 
359
        case 2: r = 1; break;
 
360
        case 4: r = 2; break;
 
361
        case 8: r = 3; break;
 
362
        default:
 
363
                dev_err(&client->dev, "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", v);
 
364
                return -EINVAL;
 
365
        }
 
366
 
 
367
        mutex_lock(&data->update_lock);
 
368
        data->fan_div[n] = r;
 
369
 
 
370
        if (n == 0)
 
371
                gl520_write_value(client, GL520_REG_FAN_DIV,
 
372
                                  (gl520_read_value(client, GL520_REG_FAN_DIV)
 
373
                                   & ~0xc0) | (r << 6));
 
374
        else
 
375
                gl520_write_value(client, GL520_REG_FAN_DIV,
 
376
                                  (gl520_read_value(client, GL520_REG_FAN_DIV)
 
377
                                   & ~0x30) | (r << 4));
 
378
 
 
379
        mutex_unlock(&data->update_lock);
 
380
        return count;
 
381
}
 
382
 
 
383
static ssize_t set_fan_off(struct device *dev, struct device_attribute *attr,
 
384
                           const char *buf, size_t count)
 
385
{
 
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;
 
389
 
 
390
        mutex_lock(&data->update_lock);
 
391
        data->fan_off = r;
 
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);
 
396
        return count;
 
397
}
 
398
 
 
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);
 
411
 
 
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))
 
414
 
 
415
static ssize_t get_temp_input(struct device *dev, struct device_attribute *attr,
 
416
                              char *buf)
 
417
{
 
418
        int n = to_sensor_dev_attr(attr)->index;
 
419
        struct gl520_data *data = gl520_update_device(dev);
 
420
 
 
421
        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_input[n]));
 
422
}
 
423
 
 
424
static ssize_t get_temp_max(struct device *dev, struct device_attribute *attr,
 
425
                            char *buf)
 
426
{
 
427
        int n = to_sensor_dev_attr(attr)->index;
 
428
        struct gl520_data *data = gl520_update_device(dev);
 
429
 
 
430
        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[n]));
 
431
}
 
432
 
 
433
static ssize_t get_temp_max_hyst(struct device *dev, struct device_attribute
 
434
                                 *attr, char *buf)
 
435
{
 
436
        int n = to_sensor_dev_attr(attr)->index;
 
437
        struct gl520_data *data = gl520_update_device(dev);
 
438
 
 
439
        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[n]));
 
440
}
 
441
 
 
442
static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
 
443
                            const char *buf, size_t count)
 
444
{
 
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);
 
449
 
 
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);
 
454
        return count;
 
455
}
 
456
 
 
457
static ssize_t set_temp_max_hyst(struct device *dev, struct device_attribute
 
458
                                 *attr, const char *buf, size_t count)
 
459
{
 
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);
 
464
 
 
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);
 
470
        return count;
 
471
}
 
472
 
 
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);
 
483
 
 
484
static ssize_t get_alarms(struct device *dev, struct device_attribute *attr,
 
485
                          char *buf)
 
486
{
 
487
        struct gl520_data *data = gl520_update_device(dev);
 
488
        return sprintf(buf, "%d\n", data->alarms);
 
489
}
 
490
 
 
491
static ssize_t get_beep_enable(struct device *dev, struct device_attribute
 
492
                               *attr, char *buf)
 
493
{
 
494
        struct gl520_data *data = gl520_update_device(dev);
 
495
        return sprintf(buf, "%d\n", data->beep_enable);
 
496
}
 
497
 
 
498
static ssize_t get_beep_mask(struct device *dev, struct device_attribute *attr,
 
499
                             char *buf)
 
500
{
 
501
        struct gl520_data *data = gl520_update_device(dev);
 
502
        return sprintf(buf, "%d\n", data->beep_mask);
 
503
}
 
504
 
 
505
static ssize_t set_beep_enable(struct device *dev, struct device_attribute
 
506
                               *attr, const char *buf, size_t count)
 
507
{
 
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;
 
511
 
 
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);
 
518
        return count;
 
519
}
 
520
 
 
521
static ssize_t set_beep_mask(struct device *dev, struct device_attribute *attr,
 
522
                             const char *buf, size_t count)
 
523
{
 
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);
 
527
 
 
528
        mutex_lock(&data->update_lock);
 
529
        r &= data->alarm_mask;
 
530
        data->beep_mask = r;
 
531
        gl520_write_value(client, GL520_REG_BEEP_MASK, r);
 
532
        mutex_unlock(&data->update_lock);
 
533
        return count;
 
534
}
 
535
 
 
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);
 
541
 
 
542
static ssize_t get_alarm(struct device *dev, struct device_attribute *attr,
 
543
                         char *buf)
 
544
{
 
545
        int bit_nr = to_sensor_dev_attr(attr)->index;
 
546
        struct gl520_data *data = gl520_update_device(dev);
 
547
 
 
548
        return sprintf(buf, "%d\n", (data->alarms >> bit_nr) & 1);
 
549
}
 
550
 
 
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);
 
560
 
 
561
static ssize_t get_beep(struct device *dev, struct device_attribute *attr,
 
562
                        char *buf)
 
563
{
 
564
        int bitnr = to_sensor_dev_attr(attr)->index;
 
565
        struct gl520_data *data = gl520_update_device(dev);
 
566
 
 
567
        return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
 
568
}
 
569
 
 
570
static ssize_t set_beep(struct device *dev, struct device_attribute *attr,
 
571
                        const char *buf, size_t count)
 
572
{
 
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;
 
576
        unsigned long bit;
 
577
 
 
578
        bit = simple_strtoul(buf, NULL, 10);
 
579
        if (bit & ~1)
 
580
                return -EINVAL;
 
581
 
 
582
        mutex_lock(&data->update_lock);
 
583
        data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
 
584
        if (bit)
 
585
                data->beep_mask |= (1 << bitnr);
 
586
        else
 
587
                data->beep_mask &= ~(1 << bitnr);
 
588
        gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
 
589
        mutex_unlock(&data->update_lock);
 
590
        return count;
 
591
}
 
592
 
 
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);
 
602
 
 
603
static struct attribute *gl520_attributes[] = {
 
604
        &dev_attr_cpu0_vid.attr,
 
605
 
 
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,
 
626
 
 
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,
 
638
 
 
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,
 
644
 
 
645
        &dev_attr_alarms.attr,
 
646
        &dev_attr_beep_enable.attr,
 
647
        &dev_attr_beep_mask.attr,
 
648
        NULL
 
649
};
 
650
 
 
651
static const struct attribute_group gl520_group = {
 
652
        .attrs = gl520_attributes,
 
653
};
 
654
 
 
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,
 
661
 
 
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,
 
667
        NULL
 
668
};
 
669
 
 
670
static const struct attribute_group gl520_group_opt = {
 
671
        .attrs = gl520_attributes_opt,
 
672
};
 
673
 
 
674
 
 
675
/*
 
676
 * Real code
 
677
 */
 
678
 
 
679
/* Return 0 if detection is successful, -ENODEV otherwise */
 
680
static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info)
 
681
{
 
682
        struct i2c_adapter *adapter = client->adapter;
 
683
 
 
684
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
 
685
                                     I2C_FUNC_SMBUS_WORD_DATA))
 
686
                return -ENODEV;
 
687
 
 
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");
 
693
                return -ENODEV;
 
694
        }
 
695
 
 
696
        strlcpy(info->type, "gl520sm", I2C_NAME_SIZE);
 
697
 
 
698
        return 0;
 
699
}
 
700
 
 
701
static int gl520_probe(struct i2c_client *client,
 
702
                       const struct i2c_device_id *id)
 
703
{
 
704
        struct gl520_data *data;
 
705
        int err;
 
706
 
 
707
        data = kzalloc(sizeof(struct gl520_data), GFP_KERNEL);
 
708
        if (!data) {
 
709
                err = -ENOMEM;
 
710
                goto exit;
 
711
        }
 
712
 
 
713
        i2c_set_clientdata(client, data);
 
714
        mutex_init(&data->update_lock);
 
715
 
 
716
        /* Initialize the GL520SM chip */
 
717
        gl520_init_client(client);
 
718
 
 
719
        /* Register sysfs hooks */
 
720
        if ((err = sysfs_create_group(&client->dev.kobj, &gl520_group)))
 
721
                goto exit_free;
 
722
 
 
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;
 
735
        } else {
 
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;
 
747
        }
 
748
 
 
749
 
 
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;
 
754
        }
 
755
 
 
756
        return 0;
 
757
 
 
758
exit_remove_files:
 
759
        sysfs_remove_group(&client->dev.kobj, &gl520_group);
 
760
        sysfs_remove_group(&client->dev.kobj, &gl520_group_opt);
 
761
exit_free:
 
762
        kfree(data);
 
763
exit:
 
764
        return err;
 
765
}
 
766
 
 
767
 
 
768
/* Called when we have found a new GL520SM. */
 
769
static void gl520_init_client(struct i2c_client *client)
 
770
{
 
771
        struct gl520_data *data = i2c_get_clientdata(client);
 
772
        u8 oldconf, conf;
 
773
 
 
774
        conf = oldconf = gl520_read_value(client, GL520_REG_CONF);
 
775
 
 
776
        data->alarm_mask = 0xff;
 
777
        data->vrm = vid_which_vrm();
 
778
 
 
779
        if (extra_sensor_type == 1)
 
780
                conf &= ~0x10;
 
781
        else if (extra_sensor_type == 2)
 
782
                conf |= 0x10;
 
783
        data->two_temps = !(conf & 0x10);
 
784
 
 
785
        /* If IRQ# is disabled, we can safely force comparator mode */
 
786
        if (!(conf & 0x20))
 
787
                conf &= 0xf7;
 
788
 
 
789
        /* Enable monitoring if needed */
 
790
        conf |= 0x40;
 
791
 
 
792
        if (conf != oldconf)
 
793
                gl520_write_value(client, GL520_REG_CONF, conf);
 
794
 
 
795
        gl520_update_device(&(client->dev));
 
796
 
 
797
        if (data->fan_min[0] == 0)
 
798
                data->alarm_mask &= ~0x20;
 
799
        if (data->fan_min[1] == 0)
 
800
                data->alarm_mask &= ~0x40;
 
801
 
 
802
        data->beep_mask &= data->alarm_mask;
 
803
        gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
 
804
}
 
805
 
 
806
static int gl520_remove(struct i2c_client *client)
 
807
{
 
808
        struct gl520_data *data = i2c_get_clientdata(client);
 
809
 
 
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);
 
813
 
 
814
        kfree(data);
 
815
        return 0;
 
816
}
 
817
 
 
818
 
 
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)
 
822
{
 
823
        if ((reg >= 0x07) && (reg <= 0x0c))
 
824
                return i2c_smbus_read_word_swapped(client, reg);
 
825
        else
 
826
                return i2c_smbus_read_byte_data(client, reg);
 
827
}
 
828
 
 
829
static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value)
 
830
{
 
831
        if ((reg >= 0x07) && (reg <= 0x0c))
 
832
                return i2c_smbus_write_word_swapped(client, reg, value);
 
833
        else
 
834
                return i2c_smbus_write_byte_data(client, reg, value);
 
835
}
 
836
 
 
837
 
 
838
static struct gl520_data *gl520_update_device(struct device *dev)
 
839
{
 
840
        struct i2c_client *client = to_i2c_client(dev);
 
841
        struct gl520_data *data = i2c_get_clientdata(client);
 
842
        int val, i;
 
843
 
 
844
        mutex_lock(&data->update_lock);
 
845
 
 
846
        if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
 
847
 
 
848
                dev_dbg(&client->dev, "Starting gl520sm update\n");
 
849
 
 
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;
 
853
 
 
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;
 
860
                }
 
861
 
 
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;
 
865
 
 
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;
 
869
 
 
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]);
 
876
 
 
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;
 
881
 
 
882
                data->alarms &= data->alarm_mask;
 
883
 
 
884
                val = gl520_read_value(client, GL520_REG_CONF);
 
885
                data->beep_enable = !((val >> 2) & 1);
 
886
 
 
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]);
 
895
                } else {
 
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]);
 
902
                }
 
903
 
 
904
                data->last_updated = jiffies;
 
905
                data->valid = 1;
 
906
        }
 
907
 
 
908
        mutex_unlock(&data->update_lock);
 
909
 
 
910
        return data;
 
911
}
 
912
 
 
913
 
 
914
static int __init sensors_gl520sm_init(void)
 
915
{
 
916
        return i2c_add_driver(&gl520_driver);
 
917
}
 
918
 
 
919
static void __exit sensors_gl520sm_exit(void)
 
920
{
 
921
        i2c_del_driver(&gl520_driver);
 
922
}
 
923
 
 
924
 
 
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");
 
930
 
 
931
module_init(sensors_gl520sm_init);
 
932
module_exit(sensors_gl520sm_exit);