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