Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
gl520sm.c
Go to the documentation of this file.
1 /*
2  * gl520sm.c - Part of lm_sensors, Linux kernel modules for hardware
3  * monitoring
4  * Copyright (c) 1998, 1999 Frodo Looijaard <[email protected]>,
5  * Kyösti Mälkki <[email protected]>
6  * Copyright (c) 2005 Maarten Deprez <[email protected]>
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) SENSORS_LIMIT((((val) * 4 + 47) / 95), 0, 255)
148 
149 #define IN_FROM_REG(val) ((val) * 19)
150 #define IN_TO_REG(val) SENSORS_LIMIT((((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  SENSORS_LIMIT((480000 + ((val) << ((div)-1))) / ((val) << (div)), 1, \
289  255))
290 
291 static ssize_t get_fan_input(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_input[n],
298  data->fan_div[n]));
299 }
300 
301 static ssize_t get_fan_min(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", FAN_FROM_REG(data->fan_min[n],
308  data->fan_div[n]));
309 }
310 
311 static ssize_t get_fan_div(struct device *dev, struct device_attribute *attr,
312  char *buf)
313 {
314  int n = to_sensor_dev_attr(attr)->index;
315  struct gl520_data *data = gl520_update_device(dev);
316 
317  return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[n]));
318 }
319 
320 static ssize_t get_fan_off(struct device *dev, struct device_attribute *attr,
321  char *buf)
322 {
323  struct gl520_data *data = gl520_update_device(dev);
324  return sprintf(buf, "%d\n", data->fan_off);
325 }
326 
327 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
328  const char *buf, size_t count)
329 {
330  struct i2c_client *client = to_i2c_client(dev);
331  struct gl520_data *data = i2c_get_clientdata(client);
332  int n = to_sensor_dev_attr(attr)->index;
333  u8 r;
334  unsigned long v;
335  int err;
336 
337  err = kstrtoul(buf, 10, &v);
338  if (err)
339  return err;
340 
341  mutex_lock(&data->update_lock);
342  r = FAN_TO_REG(v, data->fan_div[n]);
343  data->fan_min[n] = r;
344 
345  if (n == 0)
346  gl520_write_value(client, GL520_REG_FAN_MIN,
347  (gl520_read_value(client, GL520_REG_FAN_MIN)
348  & ~0xff00) | (r << 8));
349  else
350  gl520_write_value(client, GL520_REG_FAN_MIN,
351  (gl520_read_value(client, GL520_REG_FAN_MIN)
352  & ~0xff) | r);
353 
354  data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
355  if (data->fan_min[n] == 0)
356  data->alarm_mask &= (n == 0) ? ~0x20 : ~0x40;
357  else
358  data->alarm_mask |= (n == 0) ? 0x20 : 0x40;
359  data->beep_mask &= data->alarm_mask;
360  gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
361 
362  mutex_unlock(&data->update_lock);
363  return count;
364 }
365 
366 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
367  const char *buf, size_t count)
368 {
369  struct i2c_client *client = to_i2c_client(dev);
370  struct gl520_data *data = i2c_get_clientdata(client);
371  int n = to_sensor_dev_attr(attr)->index;
372  u8 r;
373  unsigned long v;
374  int err;
375 
376  err = kstrtoul(buf, 10, &v);
377  if (err)
378  return err;
379 
380  switch (v) {
381  case 1:
382  r = 0;
383  break;
384  case 2:
385  r = 1;
386  break;
387  case 4:
388  r = 2;
389  break;
390  case 8:
391  r = 3;
392  break;
393  default:
394  dev_err(&client->dev,
395  "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", v);
396  return -EINVAL;
397  }
398 
399  mutex_lock(&data->update_lock);
400  data->fan_div[n] = r;
401 
402  if (n == 0)
403  gl520_write_value(client, GL520_REG_FAN_DIV,
404  (gl520_read_value(client, GL520_REG_FAN_DIV)
405  & ~0xc0) | (r << 6));
406  else
407  gl520_write_value(client, GL520_REG_FAN_DIV,
408  (gl520_read_value(client, GL520_REG_FAN_DIV)
409  & ~0x30) | (r << 4));
410 
411  mutex_unlock(&data->update_lock);
412  return count;
413 }
414 
415 static ssize_t set_fan_off(struct device *dev, struct device_attribute *attr,
416  const char *buf, size_t count)
417 {
418  struct i2c_client *client = to_i2c_client(dev);
419  struct gl520_data *data = i2c_get_clientdata(client);
420  u8 r;
421  unsigned long v;
422  int err;
423 
424  err = kstrtoul(buf, 10, &v);
425  if (err)
426  return err;
427 
428  r = (v ? 1 : 0);
429 
430  mutex_lock(&data->update_lock);
431  data->fan_off = r;
432  gl520_write_value(client, GL520_REG_FAN_OFF,
433  (gl520_read_value(client, GL520_REG_FAN_OFF)
434  & ~0x0c) | (r << 2));
435  mutex_unlock(&data->update_lock);
436  return count;
437 }
438 
439 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan_input, NULL, 0);
440 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan_input, NULL, 1);
441 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
442  get_fan_min, set_fan_min, 0);
443 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
444  get_fan_min, set_fan_min, 1);
445 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
446  get_fan_div, set_fan_div, 0);
447 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
448  get_fan_div, set_fan_div, 1);
449 static DEVICE_ATTR(fan1_off, S_IRUGO | S_IWUSR,
450  get_fan_off, set_fan_off);
451 
452 #define TEMP_FROM_REG(val) (((val) - 130) * 1000)
453 #define TEMP_TO_REG(val) SENSORS_LIMIT(((((val) < 0 ? \
454  (val) - 500 : (val) + 500) / 1000) + 130), 0, 255)
455 
456 static ssize_t get_temp_input(struct device *dev, struct device_attribute *attr,
457  char *buf)
458 {
459  int n = to_sensor_dev_attr(attr)->index;
460  struct gl520_data *data = gl520_update_device(dev);
461 
462  return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_input[n]));
463 }
464 
465 static ssize_t get_temp_max(struct device *dev, struct device_attribute *attr,
466  char *buf)
467 {
468  int n = to_sensor_dev_attr(attr)->index;
469  struct gl520_data *data = gl520_update_device(dev);
470 
471  return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[n]));
472 }
473 
474 static ssize_t get_temp_max_hyst(struct device *dev,
475  struct device_attribute *attr, char *buf)
476 {
477  int n = to_sensor_dev_attr(attr)->index;
478  struct gl520_data *data = gl520_update_device(dev);
479 
480  return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[n]));
481 }
482 
483 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
484  const char *buf, size_t count)
485 {
486  struct i2c_client *client = to_i2c_client(dev);
487  struct gl520_data *data = i2c_get_clientdata(client);
488  int n = to_sensor_dev_attr(attr)->index;
489  long v;
490  int err;
491 
492  err = kstrtol(buf, 10, &v);
493  if (err)
494  return err;
495 
496  mutex_lock(&data->update_lock);
497  data->temp_max[n] = TEMP_TO_REG(v);
498  gl520_write_value(client, GL520_REG_TEMP_MAX[n], data->temp_max[n]);
499  mutex_unlock(&data->update_lock);
500  return count;
501 }
502 
503 static ssize_t set_temp_max_hyst(struct device *dev, struct device_attribute
504  *attr, const char *buf, size_t count)
505 {
506  struct i2c_client *client = to_i2c_client(dev);
507  struct gl520_data *data = i2c_get_clientdata(client);
508  int n = to_sensor_dev_attr(attr)->index;
509  long v;
510  int err;
511 
512  err = kstrtol(buf, 10, &v);
513  if (err)
514  return err;
515 
516  mutex_lock(&data->update_lock);
517  data->temp_max_hyst[n] = TEMP_TO_REG(v);
518  gl520_write_value(client, GL520_REG_TEMP_MAX_HYST[n],
519  data->temp_max_hyst[n]);
520  mutex_unlock(&data->update_lock);
521  return count;
522 }
523 
524 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, get_temp_input, NULL, 0);
525 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, get_temp_input, NULL, 1);
526 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
527  get_temp_max, set_temp_max, 0);
528 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR,
529  get_temp_max, set_temp_max, 1);
530 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
531  get_temp_max_hyst, set_temp_max_hyst, 0);
532 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR,
533  get_temp_max_hyst, set_temp_max_hyst, 1);
534 
535 static ssize_t get_alarms(struct device *dev, struct device_attribute *attr,
536  char *buf)
537 {
538  struct gl520_data *data = gl520_update_device(dev);
539  return sprintf(buf, "%d\n", data->alarms);
540 }
541 
542 static ssize_t get_beep_enable(struct device *dev, struct device_attribute
543  *attr, char *buf)
544 {
545  struct gl520_data *data = gl520_update_device(dev);
546  return sprintf(buf, "%d\n", data->beep_enable);
547 }
548 
549 static ssize_t get_beep_mask(struct device *dev, struct device_attribute *attr,
550  char *buf)
551 {
552  struct gl520_data *data = gl520_update_device(dev);
553  return sprintf(buf, "%d\n", data->beep_mask);
554 }
555 
556 static ssize_t set_beep_enable(struct device *dev, struct device_attribute
557  *attr, const char *buf, size_t count)
558 {
559  struct i2c_client *client = to_i2c_client(dev);
560  struct gl520_data *data = i2c_get_clientdata(client);
561  u8 r;
562  unsigned long v;
563  int err;
564 
565  err = kstrtoul(buf, 10, &v);
566  if (err)
567  return err;
568 
569  r = (v ? 0 : 1);
570 
571  mutex_lock(&data->update_lock);
572  data->beep_enable = !r;
573  gl520_write_value(client, GL520_REG_BEEP_ENABLE,
574  (gl520_read_value(client, GL520_REG_BEEP_ENABLE)
575  & ~0x04) | (r << 2));
576  mutex_unlock(&data->update_lock);
577  return count;
578 }
579 
580 static ssize_t set_beep_mask(struct device *dev, struct device_attribute *attr,
581  const char *buf, size_t count)
582 {
583  struct i2c_client *client = to_i2c_client(dev);
584  struct gl520_data *data = i2c_get_clientdata(client);
585  unsigned long r;
586  int err;
587 
588  err = kstrtoul(buf, 10, &r);
589  if (err)
590  return err;
591 
592  mutex_lock(&data->update_lock);
593  r &= data->alarm_mask;
594  data->beep_mask = r;
595  gl520_write_value(client, GL520_REG_BEEP_MASK, r);
596  mutex_unlock(&data->update_lock);
597  return count;
598 }
599 
600 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
601 static DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
602  get_beep_enable, set_beep_enable);
603 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR,
604  get_beep_mask, set_beep_mask);
605 
606 static ssize_t get_alarm(struct device *dev, struct device_attribute *attr,
607  char *buf)
608 {
609  int bit_nr = to_sensor_dev_attr(attr)->index;
610  struct gl520_data *data = gl520_update_device(dev);
611 
612  return sprintf(buf, "%d\n", (data->alarms >> bit_nr) & 1);
613 }
614 
615 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, get_alarm, NULL, 0);
616 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, get_alarm, NULL, 1);
617 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, get_alarm, NULL, 2);
618 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, get_alarm, NULL, 3);
619 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, get_alarm, NULL, 4);
620 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, get_alarm, NULL, 5);
621 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, get_alarm, NULL, 6);
622 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, get_alarm, NULL, 7);
623 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, get_alarm, NULL, 7);
624 
625 static ssize_t get_beep(struct device *dev, struct device_attribute *attr,
626  char *buf)
627 {
628  int bitnr = to_sensor_dev_attr(attr)->index;
629  struct gl520_data *data = gl520_update_device(dev);
630 
631  return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
632 }
633 
634 static ssize_t set_beep(struct device *dev, struct device_attribute *attr,
635  const char *buf, size_t count)
636 {
637  struct i2c_client *client = to_i2c_client(dev);
638  struct gl520_data *data = i2c_get_clientdata(client);
639  int bitnr = to_sensor_dev_attr(attr)->index;
640  unsigned long bit;
641 
642  int err;
643 
644  err = kstrtoul(buf, 10, &bit);
645  if (err)
646  return err;
647  if (bit & ~1)
648  return -EINVAL;
649 
650  mutex_lock(&data->update_lock);
651  data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
652  if (bit)
653  data->beep_mask |= (1 << bitnr);
654  else
655  data->beep_mask &= ~(1 << bitnr);
656  gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
657  mutex_unlock(&data->update_lock);
658  return count;
659 }
660 
661 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 0);
662 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 1);
663 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 2);
664 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 3);
665 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 4);
666 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 5);
667 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 6);
668 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
669 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
670 
671 static struct attribute *gl520_attributes[] = {
672  &dev_attr_cpu0_vid.attr,
673 
674  &sensor_dev_attr_in0_input.dev_attr.attr,
675  &sensor_dev_attr_in0_min.dev_attr.attr,
676  &sensor_dev_attr_in0_max.dev_attr.attr,
677  &sensor_dev_attr_in0_alarm.dev_attr.attr,
678  &sensor_dev_attr_in0_beep.dev_attr.attr,
679  &sensor_dev_attr_in1_input.dev_attr.attr,
680  &sensor_dev_attr_in1_min.dev_attr.attr,
681  &sensor_dev_attr_in1_max.dev_attr.attr,
682  &sensor_dev_attr_in1_alarm.dev_attr.attr,
683  &sensor_dev_attr_in1_beep.dev_attr.attr,
684  &sensor_dev_attr_in2_input.dev_attr.attr,
685  &sensor_dev_attr_in2_min.dev_attr.attr,
686  &sensor_dev_attr_in2_max.dev_attr.attr,
687  &sensor_dev_attr_in2_alarm.dev_attr.attr,
688  &sensor_dev_attr_in2_beep.dev_attr.attr,
689  &sensor_dev_attr_in3_input.dev_attr.attr,
690  &sensor_dev_attr_in3_min.dev_attr.attr,
691  &sensor_dev_attr_in3_max.dev_attr.attr,
692  &sensor_dev_attr_in3_alarm.dev_attr.attr,
693  &sensor_dev_attr_in3_beep.dev_attr.attr,
694 
695  &sensor_dev_attr_fan1_input.dev_attr.attr,
696  &sensor_dev_attr_fan1_min.dev_attr.attr,
697  &sensor_dev_attr_fan1_div.dev_attr.attr,
698  &sensor_dev_attr_fan1_alarm.dev_attr.attr,
699  &sensor_dev_attr_fan1_beep.dev_attr.attr,
700  &dev_attr_fan1_off.attr,
701  &sensor_dev_attr_fan2_input.dev_attr.attr,
702  &sensor_dev_attr_fan2_min.dev_attr.attr,
703  &sensor_dev_attr_fan2_div.dev_attr.attr,
704  &sensor_dev_attr_fan2_alarm.dev_attr.attr,
705  &sensor_dev_attr_fan2_beep.dev_attr.attr,
706 
707  &sensor_dev_attr_temp1_input.dev_attr.attr,
708  &sensor_dev_attr_temp1_max.dev_attr.attr,
709  &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
710  &sensor_dev_attr_temp1_alarm.dev_attr.attr,
711  &sensor_dev_attr_temp1_beep.dev_attr.attr,
712 
713  &dev_attr_alarms.attr,
714  &dev_attr_beep_enable.attr,
715  &dev_attr_beep_mask.attr,
716  NULL
717 };
718 
719 static const struct attribute_group gl520_group = {
720  .attrs = gl520_attributes,
721 };
722 
723 static struct attribute *gl520_attributes_in4[] = {
724  &sensor_dev_attr_in4_input.dev_attr.attr,
725  &sensor_dev_attr_in4_min.dev_attr.attr,
726  &sensor_dev_attr_in4_max.dev_attr.attr,
727  &sensor_dev_attr_in4_alarm.dev_attr.attr,
728  &sensor_dev_attr_in4_beep.dev_attr.attr,
729  NULL
730 };
731 
732 static struct attribute *gl520_attributes_temp2[] = {
733  &sensor_dev_attr_temp2_input.dev_attr.attr,
734  &sensor_dev_attr_temp2_max.dev_attr.attr,
735  &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
736  &sensor_dev_attr_temp2_alarm.dev_attr.attr,
737  &sensor_dev_attr_temp2_beep.dev_attr.attr,
738  NULL
739 };
740 
741 static const struct attribute_group gl520_group_in4 = {
742  .attrs = gl520_attributes_in4,
743 };
744 
745 static const struct attribute_group gl520_group_temp2 = {
746  .attrs = gl520_attributes_temp2,
747 };
748 
749 
750 /*
751  * Real code
752  */
753 
754 /* Return 0 if detection is successful, -ENODEV otherwise */
755 static int gl520_detect(struct i2c_client *client, struct i2c_board_info *info)
756 {
757  struct i2c_adapter *adapter = client->adapter;
758 
759  if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
760  I2C_FUNC_SMBUS_WORD_DATA))
761  return -ENODEV;
762 
763  /* Determine the chip type. */
764  if ((gl520_read_value(client, GL520_REG_CHIP_ID) != 0x20) ||
765  ((gl520_read_value(client, GL520_REG_REVISION) & 0x7f) != 0x00) ||
766  ((gl520_read_value(client, GL520_REG_CONF) & 0x80) != 0x00)) {
767  dev_dbg(&client->dev, "Unknown chip type, skipping\n");
768  return -ENODEV;
769  }
770 
771  strlcpy(info->type, "gl520sm", I2C_NAME_SIZE);
772 
773  return 0;
774 }
775 
776 static int gl520_probe(struct i2c_client *client,
777  const struct i2c_device_id *id)
778 {
779  struct gl520_data *data;
780  int err;
781 
782  data = devm_kzalloc(&client->dev, sizeof(struct gl520_data),
783  GFP_KERNEL);
784  if (!data)
785  return -ENOMEM;
786 
787  i2c_set_clientdata(client, data);
788  mutex_init(&data->update_lock);
789 
790  /* Initialize the GL520SM chip */
791  gl520_init_client(client);
792 
793  /* Register sysfs hooks */
794  err = sysfs_create_group(&client->dev.kobj, &gl520_group);
795  if (err)
796  return err;
797 
798  if (data->two_temps)
799  err = sysfs_create_group(&client->dev.kobj, &gl520_group_temp2);
800  else
801  err = sysfs_create_group(&client->dev.kobj, &gl520_group_in4);
802 
803  if (err)
804  goto exit_remove_files;
805 
806  data->hwmon_dev = hwmon_device_register(&client->dev);
807  if (IS_ERR(data->hwmon_dev)) {
808  err = PTR_ERR(data->hwmon_dev);
809  goto exit_remove_files;
810  }
811 
812  return 0;
813 
814 exit_remove_files:
815  sysfs_remove_group(&client->dev.kobj, &gl520_group);
816  sysfs_remove_group(&client->dev.kobj, &gl520_group_in4);
817  sysfs_remove_group(&client->dev.kobj, &gl520_group_temp2);
818  return err;
819 }
820 
821 
822 /* Called when we have found a new GL520SM. */
823 static void gl520_init_client(struct i2c_client *client)
824 {
825  struct gl520_data *data = i2c_get_clientdata(client);
826  u8 oldconf, conf;
827 
828  conf = oldconf = gl520_read_value(client, GL520_REG_CONF);
829 
830  data->alarm_mask = 0xff;
831  data->vrm = vid_which_vrm();
832 
833  if (extra_sensor_type == 1)
834  conf &= ~0x10;
835  else if (extra_sensor_type == 2)
836  conf |= 0x10;
837  data->two_temps = !(conf & 0x10);
838 
839  /* If IRQ# is disabled, we can safely force comparator mode */
840  if (!(conf & 0x20))
841  conf &= 0xf7;
842 
843  /* Enable monitoring if needed */
844  conf |= 0x40;
845 
846  if (conf != oldconf)
847  gl520_write_value(client, GL520_REG_CONF, conf);
848 
849  gl520_update_device(&(client->dev));
850 
851  if (data->fan_min[0] == 0)
852  data->alarm_mask &= ~0x20;
853  if (data->fan_min[1] == 0)
854  data->alarm_mask &= ~0x40;
855 
856  data->beep_mask &= data->alarm_mask;
857  gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
858 }
859 
860 static int gl520_remove(struct i2c_client *client)
861 {
862  struct gl520_data *data = i2c_get_clientdata(client);
863 
864  hwmon_device_unregister(data->hwmon_dev);
865  sysfs_remove_group(&client->dev.kobj, &gl520_group);
866  sysfs_remove_group(&client->dev.kobj, &gl520_group_in4);
867  sysfs_remove_group(&client->dev.kobj, &gl520_group_temp2);
868 
869  return 0;
870 }
871 
872 
873 /*
874  * Registers 0x07 to 0x0c are word-sized, others are byte-sized
875  * GL520 uses a high-byte first convention
876  */
877 static int gl520_read_value(struct i2c_client *client, u8 reg)
878 {
879  if ((reg >= 0x07) && (reg <= 0x0c))
880  return i2c_smbus_read_word_swapped(client, reg);
881  else
882  return i2c_smbus_read_byte_data(client, reg);
883 }
884 
885 static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value)
886 {
887  if ((reg >= 0x07) && (reg <= 0x0c))
888  return i2c_smbus_write_word_swapped(client, reg, value);
889  else
890  return i2c_smbus_write_byte_data(client, reg, value);
891 }
892 
893 
894 static struct gl520_data *gl520_update_device(struct device *dev)
895 {
896  struct i2c_client *client = to_i2c_client(dev);
897  struct gl520_data *data = i2c_get_clientdata(client);
898  int val, i;
899 
900  mutex_lock(&data->update_lock);
901 
902  if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
903 
904  dev_dbg(&client->dev, "Starting gl520sm update\n");
905 
906  data->alarms = gl520_read_value(client, GL520_REG_ALARMS);
907  data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
908  data->vid = gl520_read_value(client,
909  GL520_REG_VID_INPUT) & 0x1f;
910 
911  for (i = 0; i < 4; i++) {
912  data->in_input[i] = gl520_read_value(client,
913  GL520_REG_IN_INPUT[i]);
914  val = gl520_read_value(client, GL520_REG_IN_LIMIT[i]);
915  data->in_min[i] = val & 0xff;
916  data->in_max[i] = (val >> 8) & 0xff;
917  }
918 
919  val = gl520_read_value(client, GL520_REG_FAN_INPUT);
920  data->fan_input[0] = (val >> 8) & 0xff;
921  data->fan_input[1] = val & 0xff;
922 
923  val = gl520_read_value(client, GL520_REG_FAN_MIN);
924  data->fan_min[0] = (val >> 8) & 0xff;
925  data->fan_min[1] = val & 0xff;
926 
927  data->temp_input[0] = gl520_read_value(client,
928  GL520_REG_TEMP_INPUT[0]);
929  data->temp_max[0] = gl520_read_value(client,
930  GL520_REG_TEMP_MAX[0]);
931  data->temp_max_hyst[0] = gl520_read_value(client,
932  GL520_REG_TEMP_MAX_HYST[0]);
933 
934  val = gl520_read_value(client, GL520_REG_FAN_DIV);
935  data->fan_div[0] = (val >> 6) & 0x03;
936  data->fan_div[1] = (val >> 4) & 0x03;
937  data->fan_off = (val >> 2) & 0x01;
938 
939  data->alarms &= data->alarm_mask;
940 
941  val = gl520_read_value(client, GL520_REG_CONF);
942  data->beep_enable = !((val >> 2) & 1);
943 
944  /* Temp1 and Vin4 are the same input */
945  if (data->two_temps) {
946  data->temp_input[1] = gl520_read_value(client,
947  GL520_REG_TEMP_INPUT[1]);
948  data->temp_max[1] = gl520_read_value(client,
949  GL520_REG_TEMP_MAX[1]);
950  data->temp_max_hyst[1] = gl520_read_value(client,
951  GL520_REG_TEMP_MAX_HYST[1]);
952  } else {
953  data->in_input[4] = gl520_read_value(client,
954  GL520_REG_IN_INPUT[4]);
955  data->in_min[4] = gl520_read_value(client,
956  GL520_REG_IN_MIN[4]);
957  data->in_max[4] = gl520_read_value(client,
958  GL520_REG_IN_MAX[4]);
959  }
960 
961  data->last_updated = jiffies;
962  data->valid = 1;
963  }
964 
965  mutex_unlock(&data->update_lock);
966 
967  return data;
968 }
969 
970 module_i2c_driver(gl520_driver);
971 
972 MODULE_AUTHOR("Frodo Looijaard <[email protected]>, "
973  "Kyösti Mälkki <[email protected]>, "
974  "Maarten Deprez <[email protected]>");
975 MODULE_DESCRIPTION("GL520SM driver");
976 MODULE_LICENSE("GPL");
Generated on Thu Jan 10 2013 13:34:50 for Linux Kernel by   doxygen 1.8.2