Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6-microblaze.git] / 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 /*
45  * Many GL520 constants specified below
46  * One of the inputs can be configured as either temp or voltage.
47  * That's why _TEMP2 and _IN4 access the same register
48  */
49
50 /* The GL520 registers */
51 #define GL520_REG_CHIP_ID               0x00
52 #define GL520_REG_REVISION              0x01
53 #define GL520_REG_CONF                  0x03
54 #define GL520_REG_MASK                  0x11
55
56 #define GL520_REG_VID_INPUT             0x02
57
58 static const u8 GL520_REG_IN_INPUT[]    = { 0x15, 0x14, 0x13, 0x0d, 0x0e };
59 static const u8 GL520_REG_IN_LIMIT[]    = { 0x0c, 0x09, 0x0a, 0x0b };
60 static const u8 GL520_REG_IN_MIN[]      = { 0x0c, 0x09, 0x0a, 0x0b, 0x18 };
61 static const u8 GL520_REG_IN_MAX[]      = { 0x0c, 0x09, 0x0a, 0x0b, 0x17 };
62
63 static const u8 GL520_REG_TEMP_INPUT[]          = { 0x04, 0x0e };
64 static const u8 GL520_REG_TEMP_MAX[]            = { 0x05, 0x17 };
65 static const u8 GL520_REG_TEMP_MAX_HYST[]       = { 0x06, 0x18 };
66
67 #define GL520_REG_FAN_INPUT             0x07
68 #define GL520_REG_FAN_MIN               0x08
69 #define GL520_REG_FAN_DIV               0x0f
70 #define GL520_REG_FAN_OFF               GL520_REG_FAN_DIV
71
72 #define GL520_REG_ALARMS                0x12
73 #define GL520_REG_BEEP_MASK             0x10
74 #define GL520_REG_BEEP_ENABLE           GL520_REG_CONF
75
76 /*
77  * Function declarations
78  */
79
80 static int gl520_probe(struct i2c_client *client,
81                        const struct i2c_device_id *id);
82 static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info);
83 static void gl520_init_client(struct i2c_client *client);
84 static int gl520_remove(struct i2c_client *client);
85 static int gl520_read_value(struct i2c_client *client, u8 reg);
86 static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value);
87 static struct gl520_data *gl520_update_device(struct device *dev);
88
89 /* Driver data */
90 static const struct i2c_device_id gl520_id[] = {
91         { "gl520sm", 0 },
92         { }
93 };
94 MODULE_DEVICE_TABLE(i2c, gl520_id);
95
96 static struct i2c_driver gl520_driver = {
97         .class          = I2C_CLASS_HWMON,
98         .driver = {
99                 .name   = "gl520sm",
100         },
101         .probe          = gl520_probe,
102         .remove         = gl520_remove,
103         .id_table       = gl520_id,
104         .detect         = gl520_detect,
105         .address_list   = normal_i2c,
106 };
107
108 /* Client data */
109 struct gl520_data {
110         struct device *hwmon_dev;
111         struct mutex update_lock;
112         char valid;             /* zero until the following fields are valid */
113         unsigned long last_updated;     /* in jiffies */
114
115         u8 vid;
116         u8 vrm;
117         u8 in_input[5];         /* [0] = VVD */
118         u8 in_min[5];           /* [0] = VDD */
119         u8 in_max[5];           /* [0] = VDD */
120         u8 fan_input[2];
121         u8 fan_min[2];
122         u8 fan_div[2];
123         u8 fan_off;
124         u8 temp_input[2];
125         u8 temp_max[2];
126         u8 temp_max_hyst[2];
127         u8 alarms;
128         u8 beep_enable;
129         u8 beep_mask;
130         u8 alarm_mask;
131         u8 two_temps;
132 };
133
134 /*
135  * Sysfs stuff
136  */
137
138 static ssize_t get_cpu_vid(struct device *dev, struct device_attribute *attr,
139                            char *buf)
140 {
141         struct gl520_data *data = gl520_update_device(dev);
142         return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
143 }
144 static DEVICE_ATTR(cpu0_vid, S_IRUGO, get_cpu_vid, NULL);
145
146 #define VDD_FROM_REG(val) (((val) * 95 + 2) / 4)
147 #define VDD_TO_REG(val) clamp_val((((val) * 4 + 47) / 95), 0, 255)
148
149 #define IN_FROM_REG(val) ((val) * 19)
150 #define IN_TO_REG(val) clamp_val((((val) + 9) / 19), 0, 255)
151
152 static ssize_t get_in_input(struct device *dev, struct device_attribute *attr,
153                             char *buf)
154 {
155         int n = to_sensor_dev_attr(attr)->index;
156         struct gl520_data *data = gl520_update_device(dev);
157         u8 r = data->in_input[n];
158
159         if (n == 0)
160                 return sprintf(buf, "%d\n", VDD_FROM_REG(r));
161         else
162                 return sprintf(buf, "%d\n", IN_FROM_REG(r));
163 }
164
165 static ssize_t get_in_min(struct device *dev, struct device_attribute *attr,
166                           char *buf)
167 {
168         int n = to_sensor_dev_attr(attr)->index;
169         struct gl520_data *data = gl520_update_device(dev);
170         u8 r = data->in_min[n];
171
172         if (n == 0)
173                 return sprintf(buf, "%d\n", VDD_FROM_REG(r));
174         else
175                 return sprintf(buf, "%d\n", IN_FROM_REG(r));
176 }
177
178 static ssize_t get_in_max(struct device *dev, struct device_attribute *attr,
179                           char *buf)
180 {
181         int n = to_sensor_dev_attr(attr)->index;
182         struct gl520_data *data = gl520_update_device(dev);
183         u8 r = data->in_max[n];
184
185         if (n == 0)
186                 return sprintf(buf, "%d\n", VDD_FROM_REG(r));
187         else
188                 return sprintf(buf, "%d\n", IN_FROM_REG(r));
189 }
190
191 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
192                           const char *buf, size_t count)
193 {
194         struct i2c_client *client = to_i2c_client(dev);
195         struct gl520_data *data = i2c_get_clientdata(client);
196         int n = to_sensor_dev_attr(attr)->index;
197         u8 r;
198         long v;
199         int err;
200
201         err = kstrtol(buf, 10, &v);
202         if (err)
203                 return err;
204
205         mutex_lock(&data->update_lock);
206
207         if (n == 0)
208                 r = VDD_TO_REG(v);
209         else
210                 r = IN_TO_REG(v);
211
212         data->in_min[n] = r;
213
214         if (n < 4)
215                 gl520_write_value(client, GL520_REG_IN_MIN[n],
216                                   (gl520_read_value(client, GL520_REG_IN_MIN[n])
217                                    & ~0xff) | r);
218         else
219                 gl520_write_value(client, GL520_REG_IN_MIN[n], r);
220
221         mutex_unlock(&data->update_lock);
222         return count;
223 }
224
225 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
226                           const char *buf, size_t count)
227 {
228         struct i2c_client *client = to_i2c_client(dev);
229         struct gl520_data *data = i2c_get_clientdata(client);
230         int n = to_sensor_dev_attr(attr)->index;
231         u8 r;
232         long v;
233         int err;
234
235         err = kstrtol(buf, 10, &v);
236         if (err)
237                 return err;
238
239         if (n == 0)
240                 r = VDD_TO_REG(v);
241         else
242                 r = IN_TO_REG(v);
243
244         mutex_lock(&data->update_lock);
245
246         data->in_max[n] = r;
247
248         if (n < 4)
249                 gl520_write_value(client, GL520_REG_IN_MAX[n],
250                                   (gl520_read_value(client, GL520_REG_IN_MAX[n])
251                                    & ~0xff00) | (r << 8));
252         else
253                 gl520_write_value(client, GL520_REG_IN_MAX[n], r);
254
255         mutex_unlock(&data->update_lock);
256         return count;
257 }
258
259 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, get_in_input, NULL, 0);
260 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, get_in_input, NULL, 1);
261 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, get_in_input, NULL, 2);
262 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, get_in_input, NULL, 3);
263 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, get_in_input, NULL, 4);
264 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
265                 get_in_min, set_in_min, 0);
266 static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR,
267                 get_in_min, set_in_min, 1);
268 static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR,
269                 get_in_min, set_in_min, 2);
270 static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S_IWUSR,
271                 get_in_min, set_in_min, 3);
272 static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S_IWUSR,
273                 get_in_min, set_in_min, 4);
274 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
275                 get_in_max, set_in_max, 0);
276 static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR,
277                 get_in_max, set_in_max, 1);
278 static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR,
279                 get_in_max, set_in_max, 2);
280 static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S_IWUSR,
281                 get_in_max, set_in_max, 3);
282 static SENSOR_DEVICE_ATTR(in4_max, S_IRUGO | S_IWUSR,
283                 get_in_max, set_in_max, 4);
284
285 #define DIV_FROM_REG(val) (1 << (val))
286 #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : (480000 / ((val) << (div))))
287 #define FAN_TO_REG(val, div) ((val) <= 0 ? 0 : \
288         clamp_val((480000 + ((val) << ((div)-1))) / ((val) << (div)), 1, 255))
289
290 static ssize_t get_fan_input(struct device *dev, struct device_attribute *attr,
291                              char *buf)
292 {
293         int n = to_sensor_dev_attr(attr)->index;
294         struct gl520_data *data = gl520_update_device(dev);
295
296         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_input[n],
297                                                  data->fan_div[n]));
298 }
299
300 static ssize_t get_fan_min(struct device *dev, struct device_attribute *attr,
301                            char *buf)
302 {
303         int n = to_sensor_dev_attr(attr)->index;
304         struct gl520_data *data = gl520_update_device(dev);
305
306         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[n],
307                                                  data->fan_div[n]));
308 }
309
310 static ssize_t get_fan_div(struct device *dev, struct device_attribute *attr,
311                            char *buf)
312 {
313         int n = to_sensor_dev_attr(attr)->index;
314         struct gl520_data *data = gl520_update_device(dev);
315
316         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[n]));
317 }
318
319 static ssize_t get_fan_off(struct device *dev, struct device_attribute *attr,
320                            char *buf)
321 {
322         struct gl520_data *data = gl520_update_device(dev);
323         return sprintf(buf, "%d\n", data->fan_off);
324 }
325
326 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
327                            const char *buf, size_t count)
328 {
329         struct i2c_client *client = to_i2c_client(dev);
330         struct gl520_data *data = i2c_get_clientdata(client);
331         int n = to_sensor_dev_attr(attr)->index;
332         u8 r;
333         unsigned long v;
334         int err;
335
336         err = kstrtoul(buf, 10, &v);
337         if (err)
338                 return err;
339
340         mutex_lock(&data->update_lock);
341         r = FAN_TO_REG(v, data->fan_div[n]);
342         data->fan_min[n] = r;
343
344         if (n == 0)
345                 gl520_write_value(client, GL520_REG_FAN_MIN,
346                                   (gl520_read_value(client, GL520_REG_FAN_MIN)
347                                    & ~0xff00) | (r << 8));
348         else
349                 gl520_write_value(client, GL520_REG_FAN_MIN,
350                                   (gl520_read_value(client, GL520_REG_FAN_MIN)
351                                    & ~0xff) | r);
352
353         data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
354         if (data->fan_min[n] == 0)
355                 data->alarm_mask &= (n == 0) ? ~0x20 : ~0x40;
356         else
357                 data->alarm_mask |= (n == 0) ? 0x20 : 0x40;
358         data->beep_mask &= data->alarm_mask;
359         gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
360
361         mutex_unlock(&data->update_lock);
362         return count;
363 }
364
365 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
366                            const char *buf, size_t count)
367 {
368         struct i2c_client *client = to_i2c_client(dev);
369         struct gl520_data *data = i2c_get_clientdata(client);
370         int n = to_sensor_dev_attr(attr)->index;
371         u8 r;
372         unsigned long v;
373         int err;
374
375         err = kstrtoul(buf, 10, &v);
376         if (err)
377                 return err;
378
379         switch (v) {
380         case 1:
381                 r = 0;
382                 break;
383         case 2:
384                 r = 1;
385                 break;
386         case 4:
387                 r = 2;
388                 break;
389         case 8:
390                 r = 3;
391                 break;
392         default:
393                 dev_err(&client->dev,
394         "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", v);
395                 return -EINVAL;
396         }
397
398         mutex_lock(&data->update_lock);
399         data->fan_div[n] = r;
400
401         if (n == 0)
402                 gl520_write_value(client, GL520_REG_FAN_DIV,
403                                   (gl520_read_value(client, GL520_REG_FAN_DIV)
404                                    & ~0xc0) | (r << 6));
405         else
406                 gl520_write_value(client, GL520_REG_FAN_DIV,
407                                   (gl520_read_value(client, GL520_REG_FAN_DIV)
408                                    & ~0x30) | (r << 4));
409
410         mutex_unlock(&data->update_lock);
411         return count;
412 }
413
414 static ssize_t set_fan_off(struct device *dev, struct device_attribute *attr,
415                            const char *buf, size_t count)
416 {
417         struct i2c_client *client = to_i2c_client(dev);
418         struct gl520_data *data = i2c_get_clientdata(client);
419         u8 r;
420         unsigned long v;
421         int err;
422
423         err = kstrtoul(buf, 10, &v);
424         if (err)
425                 return err;
426
427         r = (v ? 1 : 0);
428
429         mutex_lock(&data->update_lock);
430         data->fan_off = r;
431         gl520_write_value(client, GL520_REG_FAN_OFF,
432                           (gl520_read_value(client, GL520_REG_FAN_OFF)
433                            & ~0x0c) | (r << 2));
434         mutex_unlock(&data->update_lock);
435         return count;
436 }
437
438 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan_input, NULL, 0);
439 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan_input, NULL, 1);
440 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
441                 get_fan_min, set_fan_min, 0);
442 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
443                 get_fan_min, set_fan_min, 1);
444 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
445                 get_fan_div, set_fan_div, 0);
446 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
447                 get_fan_div, set_fan_div, 1);
448 static DEVICE_ATTR(fan1_off, S_IRUGO | S_IWUSR,
449                 get_fan_off, set_fan_off);
450
451 #define TEMP_FROM_REG(val) (((val) - 130) * 1000)
452 #define TEMP_TO_REG(val) clamp_val(((((val) < 0 ? \
453                         (val) - 500 : (val) + 500) / 1000) + 130), 0, 255)
454
455 static ssize_t get_temp_input(struct device *dev, struct device_attribute *attr,
456                               char *buf)
457 {
458         int n = to_sensor_dev_attr(attr)->index;
459         struct gl520_data *data = gl520_update_device(dev);
460
461         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_input[n]));
462 }
463
464 static ssize_t get_temp_max(struct device *dev, struct device_attribute *attr,
465                             char *buf)
466 {
467         int n = to_sensor_dev_attr(attr)->index;
468         struct gl520_data *data = gl520_update_device(dev);
469
470         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[n]));
471 }
472
473 static ssize_t get_temp_max_hyst(struct device *dev,
474                                  struct device_attribute *attr, char *buf)
475 {
476         int n = to_sensor_dev_attr(attr)->index;
477         struct gl520_data *data = gl520_update_device(dev);
478
479         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[n]));
480 }
481
482 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
483                             const char *buf, size_t count)
484 {
485         struct i2c_client *client = to_i2c_client(dev);
486         struct gl520_data *data = i2c_get_clientdata(client);
487         int n = to_sensor_dev_attr(attr)->index;
488         long v;
489         int err;
490
491         err = kstrtol(buf, 10, &v);
492         if (err)
493                 return err;
494
495         mutex_lock(&data->update_lock);
496         data->temp_max[n] = TEMP_TO_REG(v);
497         gl520_write_value(client, GL520_REG_TEMP_MAX[n], data->temp_max[n]);
498         mutex_unlock(&data->update_lock);
499         return count;
500 }
501
502 static ssize_t set_temp_max_hyst(struct device *dev, struct device_attribute
503                                  *attr, const char *buf, size_t count)
504 {
505         struct i2c_client *client = to_i2c_client(dev);
506         struct gl520_data *data = i2c_get_clientdata(client);
507         int n = to_sensor_dev_attr(attr)->index;
508         long v;
509         int err;
510
511         err = kstrtol(buf, 10, &v);
512         if (err)
513                 return err;
514
515         mutex_lock(&data->update_lock);
516         data->temp_max_hyst[n] = TEMP_TO_REG(v);
517         gl520_write_value(client, GL520_REG_TEMP_MAX_HYST[n],
518                           data->temp_max_hyst[n]);
519         mutex_unlock(&data->update_lock);
520         return count;
521 }
522
523 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, get_temp_input, NULL, 0);
524 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, get_temp_input, NULL, 1);
525 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
526                 get_temp_max, set_temp_max, 0);
527 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR,
528                 get_temp_max, set_temp_max, 1);
529 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
530                 get_temp_max_hyst, set_temp_max_hyst, 0);
531 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR,
532                 get_temp_max_hyst, set_temp_max_hyst, 1);
533
534 static ssize_t get_alarms(struct device *dev, struct device_attribute *attr,
535                           char *buf)
536 {
537         struct gl520_data *data = gl520_update_device(dev);
538         return sprintf(buf, "%d\n", data->alarms);
539 }
540
541 static ssize_t get_beep_enable(struct device *dev, struct device_attribute
542                                *attr, char *buf)
543 {
544         struct gl520_data *data = gl520_update_device(dev);
545         return sprintf(buf, "%d\n", data->beep_enable);
546 }
547
548 static ssize_t get_beep_mask(struct device *dev, struct device_attribute *attr,
549                              char *buf)
550 {
551         struct gl520_data *data = gl520_update_device(dev);
552         return sprintf(buf, "%d\n", data->beep_mask);
553 }
554
555 static ssize_t set_beep_enable(struct device *dev, struct device_attribute
556                                *attr, const char *buf, size_t count)
557 {
558         struct i2c_client *client = to_i2c_client(dev);
559         struct gl520_data *data = i2c_get_clientdata(client);
560         u8 r;
561         unsigned long v;
562         int err;
563
564         err = kstrtoul(buf, 10, &v);
565         if (err)
566                 return err;
567
568         r = (v ? 0 : 1);
569
570         mutex_lock(&data->update_lock);
571         data->beep_enable = !r;
572         gl520_write_value(client, GL520_REG_BEEP_ENABLE,
573                           (gl520_read_value(client, GL520_REG_BEEP_ENABLE)
574                            & ~0x04) | (r << 2));
575         mutex_unlock(&data->update_lock);
576         return count;
577 }
578
579 static ssize_t set_beep_mask(struct device *dev, struct device_attribute *attr,
580                              const char *buf, size_t count)
581 {
582         struct i2c_client *client = to_i2c_client(dev);
583         struct gl520_data *data = i2c_get_clientdata(client);
584         unsigned long r;
585         int err;
586
587         err = kstrtoul(buf, 10, &r);
588         if (err)
589                 return err;
590
591         mutex_lock(&data->update_lock);
592         r &= data->alarm_mask;
593         data->beep_mask = r;
594         gl520_write_value(client, GL520_REG_BEEP_MASK, r);
595         mutex_unlock(&data->update_lock);
596         return count;
597 }
598
599 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
600 static DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
601                 get_beep_enable, set_beep_enable);
602 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR,
603                 get_beep_mask, set_beep_mask);
604
605 static ssize_t get_alarm(struct device *dev, struct device_attribute *attr,
606                          char *buf)
607 {
608         int bit_nr = to_sensor_dev_attr(attr)->index;
609         struct gl520_data *data = gl520_update_device(dev);
610
611         return sprintf(buf, "%d\n", (data->alarms >> bit_nr) & 1);
612 }
613
614 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, get_alarm, NULL, 0);
615 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, get_alarm, NULL, 1);
616 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, get_alarm, NULL, 2);
617 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, get_alarm, NULL, 3);
618 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, get_alarm, NULL, 4);
619 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, get_alarm, NULL, 5);
620 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, get_alarm, NULL, 6);
621 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, get_alarm, NULL, 7);
622 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, get_alarm, NULL, 7);
623
624 static ssize_t get_beep(struct device *dev, struct device_attribute *attr,
625                         char *buf)
626 {
627         int bitnr = to_sensor_dev_attr(attr)->index;
628         struct gl520_data *data = gl520_update_device(dev);
629
630         return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
631 }
632
633 static ssize_t set_beep(struct device *dev, struct device_attribute *attr,
634                         const char *buf, size_t count)
635 {
636         struct i2c_client *client = to_i2c_client(dev);
637         struct gl520_data *data = i2c_get_clientdata(client);
638         int bitnr = to_sensor_dev_attr(attr)->index;
639         unsigned long bit;
640
641         int err;
642
643         err = kstrtoul(buf, 10, &bit);
644         if (err)
645                 return err;
646         if (bit & ~1)
647                 return -EINVAL;
648
649         mutex_lock(&data->update_lock);
650         data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
651         if (bit)
652                 data->beep_mask |= (1 << bitnr);
653         else
654                 data->beep_mask &= ~(1 << bitnr);
655         gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
656         mutex_unlock(&data->update_lock);
657         return count;
658 }
659
660 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 0);
661 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 1);
662 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 2);
663 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 3);
664 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 4);
665 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 5);
666 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 6);
667 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
668 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
669
670 static struct attribute *gl520_attributes[] = {
671         &dev_attr_cpu0_vid.attr,
672
673         &sensor_dev_attr_in0_input.dev_attr.attr,
674         &sensor_dev_attr_in0_min.dev_attr.attr,
675         &sensor_dev_attr_in0_max.dev_attr.attr,
676         &sensor_dev_attr_in0_alarm.dev_attr.attr,
677         &sensor_dev_attr_in0_beep.dev_attr.attr,
678         &sensor_dev_attr_in1_input.dev_attr.attr,
679         &sensor_dev_attr_in1_min.dev_attr.attr,
680         &sensor_dev_attr_in1_max.dev_attr.attr,
681         &sensor_dev_attr_in1_alarm.dev_attr.attr,
682         &sensor_dev_attr_in1_beep.dev_attr.attr,
683         &sensor_dev_attr_in2_input.dev_attr.attr,
684         &sensor_dev_attr_in2_min.dev_attr.attr,
685         &sensor_dev_attr_in2_max.dev_attr.attr,
686         &sensor_dev_attr_in2_alarm.dev_attr.attr,
687         &sensor_dev_attr_in2_beep.dev_attr.attr,
688         &sensor_dev_attr_in3_input.dev_attr.attr,
689         &sensor_dev_attr_in3_min.dev_attr.attr,
690         &sensor_dev_attr_in3_max.dev_attr.attr,
691         &sensor_dev_attr_in3_alarm.dev_attr.attr,
692         &sensor_dev_attr_in3_beep.dev_attr.attr,
693
694         &sensor_dev_attr_fan1_input.dev_attr.attr,
695         &sensor_dev_attr_fan1_min.dev_attr.attr,
696         &sensor_dev_attr_fan1_div.dev_attr.attr,
697         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
698         &sensor_dev_attr_fan1_beep.dev_attr.attr,
699         &dev_attr_fan1_off.attr,
700         &sensor_dev_attr_fan2_input.dev_attr.attr,
701         &sensor_dev_attr_fan2_min.dev_attr.attr,
702         &sensor_dev_attr_fan2_div.dev_attr.attr,
703         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
704         &sensor_dev_attr_fan2_beep.dev_attr.attr,
705
706         &sensor_dev_attr_temp1_input.dev_attr.attr,
707         &sensor_dev_attr_temp1_max.dev_attr.attr,
708         &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
709         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
710         &sensor_dev_attr_temp1_beep.dev_attr.attr,
711
712         &dev_attr_alarms.attr,
713         &dev_attr_beep_enable.attr,
714         &dev_attr_beep_mask.attr,
715         NULL
716 };
717
718 static const struct attribute_group gl520_group = {
719         .attrs = gl520_attributes,
720 };
721
722 static struct attribute *gl520_attributes_in4[] = {
723         &sensor_dev_attr_in4_input.dev_attr.attr,
724         &sensor_dev_attr_in4_min.dev_attr.attr,
725         &sensor_dev_attr_in4_max.dev_attr.attr,
726         &sensor_dev_attr_in4_alarm.dev_attr.attr,
727         &sensor_dev_attr_in4_beep.dev_attr.attr,
728         NULL
729 };
730
731 static struct attribute *gl520_attributes_temp2[] = {
732         &sensor_dev_attr_temp2_input.dev_attr.attr,
733         &sensor_dev_attr_temp2_max.dev_attr.attr,
734         &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
735         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
736         &sensor_dev_attr_temp2_beep.dev_attr.attr,
737         NULL
738 };
739
740 static const struct attribute_group gl520_group_in4 = {
741         .attrs = gl520_attributes_in4,
742 };
743
744 static const struct attribute_group gl520_group_temp2 = {
745         .attrs = gl520_attributes_temp2,
746 };
747
748
749 /*
750  * Real code
751  */
752
753 /* Return 0 if detection is successful, -ENODEV otherwise */
754 static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info)
755 {
756         struct i2c_adapter *adapter = client->adapter;
757
758         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
759                                      I2C_FUNC_SMBUS_WORD_DATA))
760                 return -ENODEV;
761
762         /* Determine the chip type. */
763         if ((gl520_read_value(client, GL520_REG_CHIP_ID) != 0x20) ||
764             ((gl520_read_value(client, GL520_REG_REVISION) & 0x7f) != 0x00) ||
765             ((gl520_read_value(client, GL520_REG_CONF) & 0x80) != 0x00)) {
766                 dev_dbg(&client->dev, "Unknown chip type, skipping\n");
767                 return -ENODEV;
768         }
769
770         strlcpy(info->type, "gl520sm", I2C_NAME_SIZE);
771
772         return 0;
773 }
774
775 static int gl520_probe(struct i2c_client *client,
776                        const struct i2c_device_id *id)
777 {
778         struct gl520_data *data;
779         int err;
780
781         data = devm_kzalloc(&client->dev, sizeof(struct gl520_data),
782                             GFP_KERNEL);
783         if (!data)
784                 return -ENOMEM;
785
786         i2c_set_clientdata(client, data);
787         mutex_init(&data->update_lock);
788
789         /* Initialize the GL520SM chip */
790         gl520_init_client(client);
791
792         /* Register sysfs hooks */
793         err = sysfs_create_group(&client->dev.kobj, &gl520_group);
794         if (err)
795                 return err;
796
797         if (data->two_temps)
798                 err = sysfs_create_group(&client->dev.kobj, &gl520_group_temp2);
799         else
800                 err = sysfs_create_group(&client->dev.kobj, &gl520_group_in4);
801
802         if (err)
803                 goto exit_remove_files;
804
805         data->hwmon_dev = hwmon_device_register(&client->dev);
806         if (IS_ERR(data->hwmon_dev)) {
807                 err = PTR_ERR(data->hwmon_dev);
808                 goto exit_remove_files;
809         }
810
811         return 0;
812
813 exit_remove_files:
814         sysfs_remove_group(&client->dev.kobj, &gl520_group);
815         sysfs_remove_group(&client->dev.kobj, &gl520_group_in4);
816         sysfs_remove_group(&client->dev.kobj, &gl520_group_temp2);
817         return err;
818 }
819
820
821 /* Called when we have found a new GL520SM. */
822 static void gl520_init_client(struct i2c_client *client)
823 {
824         struct gl520_data *data = i2c_get_clientdata(client);
825         u8 oldconf, conf;
826
827         conf = oldconf = gl520_read_value(client, GL520_REG_CONF);
828
829         data->alarm_mask = 0xff;
830         data->vrm = vid_which_vrm();
831
832         if (extra_sensor_type == 1)
833                 conf &= ~0x10;
834         else if (extra_sensor_type == 2)
835                 conf |= 0x10;
836         data->two_temps = !(conf & 0x10);
837
838         /* If IRQ# is disabled, we can safely force comparator mode */
839         if (!(conf & 0x20))
840                 conf &= 0xf7;
841
842         /* Enable monitoring if needed */
843         conf |= 0x40;
844
845         if (conf != oldconf)
846                 gl520_write_value(client, GL520_REG_CONF, conf);
847
848         gl520_update_device(&(client->dev));
849
850         if (data->fan_min[0] == 0)
851                 data->alarm_mask &= ~0x20;
852         if (data->fan_min[1] == 0)
853                 data->alarm_mask &= ~0x40;
854
855         data->beep_mask &= data->alarm_mask;
856         gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
857 }
858
859 static int gl520_remove(struct i2c_client *client)
860 {
861         struct gl520_data *data = i2c_get_clientdata(client);
862
863         hwmon_device_unregister(data->hwmon_dev);
864         sysfs_remove_group(&client->dev.kobj, &gl520_group);
865         sysfs_remove_group(&client->dev.kobj, &gl520_group_in4);
866         sysfs_remove_group(&client->dev.kobj, &gl520_group_temp2);
867
868         return 0;
869 }
870
871
872 /*
873  * Registers 0x07 to 0x0c are word-sized, others are byte-sized
874  * GL520 uses a high-byte first convention
875  */
876 static int gl520_read_value(struct i2c_client *client, u8 reg)
877 {
878         if ((reg >= 0x07) && (reg <= 0x0c))
879                 return i2c_smbus_read_word_swapped(client, reg);
880         else
881                 return i2c_smbus_read_byte_data(client, reg);
882 }
883
884 static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value)
885 {
886         if ((reg >= 0x07) && (reg <= 0x0c))
887                 return i2c_smbus_write_word_swapped(client, reg, value);
888         else
889                 return i2c_smbus_write_byte_data(client, reg, value);
890 }
891
892
893 static struct gl520_data *gl520_update_device(struct device *dev)
894 {
895         struct i2c_client *client = to_i2c_client(dev);
896         struct gl520_data *data = i2c_get_clientdata(client);
897         int val, i;
898
899         mutex_lock(&data->update_lock);
900
901         if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
902
903                 dev_dbg(&client->dev, "Starting gl520sm update\n");
904
905                 data->alarms = gl520_read_value(client, GL520_REG_ALARMS);
906                 data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
907                 data->vid = gl520_read_value(client,
908                                              GL520_REG_VID_INPUT) & 0x1f;
909
910                 for (i = 0; i < 4; i++) {
911                         data->in_input[i] = gl520_read_value(client,
912                                                         GL520_REG_IN_INPUT[i]);
913                         val = gl520_read_value(client, GL520_REG_IN_LIMIT[i]);
914                         data->in_min[i] = val & 0xff;
915                         data->in_max[i] = (val >> 8) & 0xff;
916                 }
917
918                 val = gl520_read_value(client, GL520_REG_FAN_INPUT);
919                 data->fan_input[0] = (val >> 8) & 0xff;
920                 data->fan_input[1] = val & 0xff;
921
922                 val = gl520_read_value(client, GL520_REG_FAN_MIN);
923                 data->fan_min[0] = (val >> 8) & 0xff;
924                 data->fan_min[1] = val & 0xff;
925
926                 data->temp_input[0] = gl520_read_value(client,
927                                                 GL520_REG_TEMP_INPUT[0]);
928                 data->temp_max[0] = gl520_read_value(client,
929                                                 GL520_REG_TEMP_MAX[0]);
930                 data->temp_max_hyst[0] = gl520_read_value(client,
931                                                 GL520_REG_TEMP_MAX_HYST[0]);
932
933                 val = gl520_read_value(client, GL520_REG_FAN_DIV);
934                 data->fan_div[0] = (val >> 6) & 0x03;
935                 data->fan_div[1] = (val >> 4) & 0x03;
936                 data->fan_off = (val >> 2) & 0x01;
937
938                 data->alarms &= data->alarm_mask;
939
940                 val = gl520_read_value(client, GL520_REG_CONF);
941                 data->beep_enable = !((val >> 2) & 1);
942
943                 /* Temp1 and Vin4 are the same input */
944                 if (data->two_temps) {
945                         data->temp_input[1] = gl520_read_value(client,
946                                                 GL520_REG_TEMP_INPUT[1]);
947                         data->temp_max[1] = gl520_read_value(client,
948                                                 GL520_REG_TEMP_MAX[1]);
949                         data->temp_max_hyst[1] = gl520_read_value(client,
950                                                 GL520_REG_TEMP_MAX_HYST[1]);
951                 } else {
952                         data->in_input[4] = gl520_read_value(client,
953                                                 GL520_REG_IN_INPUT[4]);
954                         data->in_min[4] = gl520_read_value(client,
955                                                 GL520_REG_IN_MIN[4]);
956                         data->in_max[4] = gl520_read_value(client,
957                                                 GL520_REG_IN_MAX[4]);
958                 }
959
960                 data->last_updated = jiffies;
961                 data->valid = 1;
962         }
963
964         mutex_unlock(&data->update_lock);
965
966         return data;
967 }
968
969 module_i2c_driver(gl520_driver);
970
971 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
972         "Kyösti Mälkki <kmalkki@cc.hut.fi>, "
973         "Maarten Deprez <maartendeprez@users.sourceforge.net>");
974 MODULE_DESCRIPTION("GL520SM driver");
975 MODULE_LICENSE("GPL");