Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
adt7462.c
Go to the documentation of this file.
1 /*
2  * A hwmon driver for the Analog Devices ADT7462
3  * Copyright (C) 2008 IBM
4  *
5  * Author: Darrick J. Wong <[email protected]>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  */
21 
22 #include <linux/module.h>
23 #include <linux/jiffies.h>
24 #include <linux/i2c.h>
25 #include <linux/hwmon.h>
26 #include <linux/hwmon-sysfs.h>
27 #include <linux/err.h>
28 #include <linux/mutex.h>
29 #include <linux/log2.h>
30 #include <linux/slab.h>
31 
32 /* Addresses to scan */
33 static const unsigned short normal_i2c[] = { 0x58, 0x5C, I2C_CLIENT_END };
34 
35 /* ADT7462 registers */
36 #define ADT7462_REG_DEVICE 0x3D
37 #define ADT7462_REG_VENDOR 0x3E
38 #define ADT7462_REG_REVISION 0x3F
39 
40 #define ADT7462_REG_MIN_TEMP_BASE_ADDR 0x44
41 #define ADT7462_REG_MIN_TEMP_MAX_ADDR 0x47
42 #define ADT7462_REG_MAX_TEMP_BASE_ADDR 0x48
43 #define ADT7462_REG_MAX_TEMP_MAX_ADDR 0x4B
44 #define ADT7462_REG_TEMP_BASE_ADDR 0x88
45 #define ADT7462_REG_TEMP_MAX_ADDR 0x8F
46 
47 #define ADT7462_REG_FAN_BASE_ADDR 0x98
48 #define ADT7462_REG_FAN_MAX_ADDR 0x9F
49 #define ADT7462_REG_FAN2_BASE_ADDR 0xA2
50 #define ADT7462_REG_FAN2_MAX_ADDR 0xA9
51 #define ADT7462_REG_FAN_ENABLE 0x07
52 #define ADT7462_REG_FAN_MIN_BASE_ADDR 0x78
53 #define ADT7462_REG_FAN_MIN_MAX_ADDR 0x7F
54 
55 #define ADT7462_REG_CFG2 0x02
56 #define ADT7462_FSPD_MASK 0x20
57 
58 #define ADT7462_REG_PWM_BASE_ADDR 0xAA
59 #define ADT7462_REG_PWM_MAX_ADDR 0xAD
60 #define ADT7462_REG_PWM_MIN_BASE_ADDR 0x28
61 #define ADT7462_REG_PWM_MIN_MAX_ADDR 0x2B
62 #define ADT7462_REG_PWM_MAX 0x2C
63 #define ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR 0x5C
64 #define ADT7462_REG_PWM_TEMP_MIN_MAX_ADDR 0x5F
65 #define ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR 0x60
66 #define ADT7462_REG_PWM_TEMP_RANGE_MAX_ADDR 0x63
67 #define ADT7462_PWM_HYST_MASK 0x0F
68 #define ADT7462_PWM_RANGE_MASK 0xF0
69 #define ADT7462_PWM_RANGE_SHIFT 4
70 #define ADT7462_REG_PWM_CFG_BASE_ADDR 0x21
71 #define ADT7462_REG_PWM_CFG_MAX_ADDR 0x24
72 #define ADT7462_PWM_CHANNEL_MASK 0xE0
73 #define ADT7462_PWM_CHANNEL_SHIFT 5
74 
75 #define ADT7462_REG_PIN_CFG_BASE_ADDR 0x10
76 #define ADT7462_REG_PIN_CFG_MAX_ADDR 0x13
77 #define ADT7462_PIN7_INPUT 0x01 /* cfg0 */
78 #define ADT7462_DIODE3_INPUT 0x20
79 #define ADT7462_DIODE1_INPUT 0x40
80 #define ADT7462_VID_INPUT 0x80
81 #define ADT7462_PIN22_INPUT 0x04 /* cfg1 */
82 #define ADT7462_PIN21_INPUT 0x08
83 #define ADT7462_PIN19_INPUT 0x10
84 #define ADT7462_PIN15_INPUT 0x20
85 #define ADT7462_PIN13_INPUT 0x40
86 #define ADT7462_PIN8_INPUT 0x80
87 #define ADT7462_PIN23_MASK 0x03
88 #define ADT7462_PIN23_SHIFT 0
89 #define ADT7462_PIN26_MASK 0x0C /* cfg2 */
90 #define ADT7462_PIN26_SHIFT 2
91 #define ADT7462_PIN25_MASK 0x30
92 #define ADT7462_PIN25_SHIFT 4
93 #define ADT7462_PIN24_MASK 0xC0
94 #define ADT7462_PIN24_SHIFT 6
95 #define ADT7462_PIN26_VOLT_INPUT 0x08
96 #define ADT7462_PIN25_VOLT_INPUT 0x20
97 #define ADT7462_PIN28_SHIFT 4 /* cfg3 */
98 #define ADT7462_PIN28_VOLT 0x5
99 
100 #define ADT7462_REG_ALARM1 0xB8
101 #define ADT7462_LT_ALARM 0x02
102 #define ADT7462_R1T_ALARM 0x04
103 #define ADT7462_R2T_ALARM 0x08
104 #define ADT7462_R3T_ALARM 0x10
105 #define ADT7462_REG_ALARM2 0xBB
106 #define ADT7462_V0_ALARM 0x01
107 #define ADT7462_V1_ALARM 0x02
108 #define ADT7462_V2_ALARM 0x04
109 #define ADT7462_V3_ALARM 0x08
110 #define ADT7462_V4_ALARM 0x10
111 #define ADT7462_V5_ALARM 0x20
112 #define ADT7462_V6_ALARM 0x40
113 #define ADT7462_V7_ALARM 0x80
114 #define ADT7462_REG_ALARM3 0xBC
115 #define ADT7462_V8_ALARM 0x08
116 #define ADT7462_V9_ALARM 0x10
117 #define ADT7462_V10_ALARM 0x20
118 #define ADT7462_V11_ALARM 0x40
119 #define ADT7462_V12_ALARM 0x80
120 #define ADT7462_REG_ALARM4 0xBD
121 #define ADT7462_F0_ALARM 0x01
122 #define ADT7462_F1_ALARM 0x02
123 #define ADT7462_F2_ALARM 0x04
124 #define ADT7462_F3_ALARM 0x08
125 #define ADT7462_F4_ALARM 0x10
126 #define ADT7462_F5_ALARM 0x20
127 #define ADT7462_F6_ALARM 0x40
128 #define ADT7462_F7_ALARM 0x80
129 #define ADT7462_ALARM1 0x0000
130 #define ADT7462_ALARM2 0x0100
131 #define ADT7462_ALARM3 0x0200
132 #define ADT7462_ALARM4 0x0300
133 #define ADT7462_ALARM_REG_SHIFT 8
134 #define ADT7462_ALARM_FLAG_MASK 0x0F
135 
136 #define ADT7462_TEMP_COUNT 4
137 #define ADT7462_TEMP_REG(x) (ADT7462_REG_TEMP_BASE_ADDR + ((x) * 2))
138 #define ADT7462_TEMP_MIN_REG(x) (ADT7462_REG_MIN_TEMP_BASE_ADDR + (x))
139 #define ADT7462_TEMP_MAX_REG(x) (ADT7462_REG_MAX_TEMP_BASE_ADDR + (x))
140 #define TEMP_FRAC_OFFSET 6
141 
142 #define ADT7462_FAN_COUNT 8
143 #define ADT7462_REG_FAN_MIN(x) (ADT7462_REG_FAN_MIN_BASE_ADDR + (x))
144 
145 #define ADT7462_PWM_COUNT 4
146 #define ADT7462_REG_PWM(x) (ADT7462_REG_PWM_BASE_ADDR + (x))
147 #define ADT7462_REG_PWM_MIN(x) (ADT7462_REG_PWM_MIN_BASE_ADDR + (x))
148 #define ADT7462_REG_PWM_TMIN(x) \
149  (ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
150 #define ADT7462_REG_PWM_TRANGE(x) \
151  (ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR + (x))
152 
153 #define ADT7462_PIN_CFG_REG_COUNT 4
154 #define ADT7462_REG_PIN_CFG(x) (ADT7462_REG_PIN_CFG_BASE_ADDR + (x))
155 #define ADT7462_REG_PWM_CFG(x) (ADT7462_REG_PWM_CFG_BASE_ADDR + (x))
156 
157 #define ADT7462_ALARM_REG_COUNT 4
158 
159 /*
160  * The chip can measure 13 different voltage sources:
161  *
162  * 1. +12V1 (pin 7)
163  * 2. Vccp1/+2.5V/+1.8V/+1.5V (pin 23)
164  * 3. +12V3 (pin 22)
165  * 4. +5V (pin 21)
166  * 5. +1.25V/+0.9V (pin 19)
167  * 6. +2.5V/+1.8V (pin 15)
168  * 7. +3.3v (pin 13)
169  * 8. +12V2 (pin 8)
170  * 9. Vbatt/FSB_Vtt (pin 26)
171  * A. +3.3V/+1.2V1 (pin 25)
172  * B. Vccp2/+2.5V/+1.8V/+1.5V (pin 24)
173  * C. +1.5V ICH (only if BOTH pin 28/29 are set to +1.5V)
174  * D. +1.5V 3GPIO (only if BOTH pin 28/29 are set to +1.5V)
175  *
176  * Each of these 13 has a factor to convert raw to voltage. Even better,
177  * the pins can be connected to other sensors (tach/gpio/hot/etc), which
178  * makes the bookkeeping tricky.
179  *
180  * Some, but not all, of these voltages have low/high limits.
181  */
182 #define ADT7462_VOLT_COUNT 13
183 
184 #define ADT7462_VENDOR 0x41
185 #define ADT7462_DEVICE 0x62
186 /* datasheet only mentions a revision 4 */
187 #define ADT7462_REVISION 0x04
188 
189 /* How often do we reread sensors values? (In jiffies) */
190 #define SENSOR_REFRESH_INTERVAL (2 * HZ)
191 
192 /* How often do we reread sensor limit values? (In jiffies) */
193 #define LIMIT_REFRESH_INTERVAL (60 * HZ)
194 
195 /* datasheet says to divide this number by the fan reading to get fan rpm */
196 #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
197 #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
198 #define FAN_PERIOD_INVALID 65535
199 #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
200 
201 #define MASK_AND_SHIFT(value, prefix) \
202  (((value) & prefix##_MASK) >> prefix##_SHIFT)
203 
204 struct adt7462_data {
205  struct device *hwmon_dev;
206  struct attribute_group attrs;
207  struct mutex lock;
208  char sensors_valid;
209  char limits_valid;
210  unsigned long sensors_last_updated; /* In jiffies */
211  unsigned long limits_last_updated; /* In jiffies */
212 
213  u8 temp[ADT7462_TEMP_COUNT];
214  /* bits 6-7 are quarter pieces of temp */
215  u8 temp_frac[ADT7462_TEMP_COUNT];
216  u8 temp_min[ADT7462_TEMP_COUNT];
217  u8 temp_max[ADT7462_TEMP_COUNT];
218  u16 fan[ADT7462_FAN_COUNT];
219  u8 fan_enabled;
220  u8 fan_min[ADT7462_FAN_COUNT];
221  u8 cfg2;
222  u8 pwm[ADT7462_PWM_COUNT];
223  u8 pin_cfg[ADT7462_PIN_CFG_REG_COUNT];
224  u8 voltages[ADT7462_VOLT_COUNT];
225  u8 volt_max[ADT7462_VOLT_COUNT];
226  u8 volt_min[ADT7462_VOLT_COUNT];
227  u8 pwm_min[ADT7462_PWM_COUNT];
228  u8 pwm_tmin[ADT7462_PWM_COUNT];
229  u8 pwm_trange[ADT7462_PWM_COUNT];
230  u8 pwm_max; /* only one per chip */
231  u8 pwm_cfg[ADT7462_PWM_COUNT];
232  u8 alarms[ADT7462_ALARM_REG_COUNT];
233 };
234 
235 static int adt7462_probe(struct i2c_client *client,
236  const struct i2c_device_id *id);
237 static int adt7462_detect(struct i2c_client *client,
238  struct i2c_board_info *info);
239 static int adt7462_remove(struct i2c_client *client);
240 
241 static const struct i2c_device_id adt7462_id[] = {
242  { "adt7462", 0 },
243  { }
244 };
245 MODULE_DEVICE_TABLE(i2c, adt7462_id);
246 
247 static struct i2c_driver adt7462_driver = {
248  .class = I2C_CLASS_HWMON,
249  .driver = {
250  .name = "adt7462",
251  },
252  .probe = adt7462_probe,
253  .remove = adt7462_remove,
254  .id_table = adt7462_id,
255  .detect = adt7462_detect,
256  .address_list = normal_i2c,
257 };
258 
259 /*
260  * 16-bit registers on the ADT7462 are low-byte first. The data sheet says
261  * that the low byte must be read before the high byte.
262  */
263 static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg)
264 {
265  u16 foo;
266  foo = i2c_smbus_read_byte_data(client, reg);
267  foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
268  return foo;
269 }
270 
271 /* For some reason these registers are not contiguous. */
272 static int ADT7462_REG_FAN(int fan)
273 {
274  if (fan < 4)
275  return ADT7462_REG_FAN_BASE_ADDR + (2 * fan);
276  return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4));
277 }
278 
279 /* Voltage registers are scattered everywhere */
280 static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which)
281 {
282  switch (which) {
283  case 0:
284  if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
285  return 0x7C;
286  break;
287  case 1:
288  return 0x69;
289  case 2:
290  if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
291  return 0x7F;
292  break;
293  case 3:
294  if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
295  return 0x7E;
296  break;
297  case 4:
298  if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
299  return 0x4B;
300  break;
301  case 5:
302  if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
303  return 0x49;
304  break;
305  case 6:
306  if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
307  return 0x68;
308  break;
309  case 7:
310  if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
311  return 0x7D;
312  break;
313  case 8:
314  if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
315  return 0x6C;
316  break;
317  case 9:
318  if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
319  return 0x6B;
320  break;
321  case 10:
322  return 0x6A;
323  case 11:
324  if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
325  ADT7462_PIN28_VOLT &&
326  !(data->pin_cfg[0] & ADT7462_VID_INPUT))
327  return 0x50;
328  break;
329  case 12:
330  if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
331  ADT7462_PIN28_VOLT &&
332  !(data->pin_cfg[0] & ADT7462_VID_INPUT))
333  return 0x4C;
334  break;
335  }
336  return -ENODEV;
337 }
338 
339 static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which)
340 {
341  switch (which) {
342  case 0:
343  if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
344  return 0x6D;
345  break;
346  case 1:
347  return 0x72;
348  case 2:
349  if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
350  return 0x6F;
351  break;
352  case 3:
353  if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
354  return 0x71;
355  break;
356  case 4:
357  if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
358  return 0x47;
359  break;
360  case 5:
361  if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
362  return 0x45;
363  break;
364  case 6:
365  if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
366  return 0x70;
367  break;
368  case 7:
369  if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
370  return 0x6E;
371  break;
372  case 8:
373  if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
374  return 0x75;
375  break;
376  case 9:
377  if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
378  return 0x74;
379  break;
380  case 10:
381  return 0x73;
382  case 11:
383  if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
384  ADT7462_PIN28_VOLT &&
385  !(data->pin_cfg[0] & ADT7462_VID_INPUT))
386  return 0x76;
387  break;
388  case 12:
389  if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
390  ADT7462_PIN28_VOLT &&
391  !(data->pin_cfg[0] & ADT7462_VID_INPUT))
392  return 0x77;
393  break;
394  }
395  return -ENODEV;
396 }
397 
398 static int ADT7462_REG_VOLT(struct adt7462_data *data, int which)
399 {
400  switch (which) {
401  case 0:
402  if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
403  return 0xA3;
404  break;
405  case 1:
406  return 0x90;
407  case 2:
408  if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
409  return 0xA9;
410  break;
411  case 3:
412  if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
413  return 0xA7;
414  break;
415  case 4:
416  if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
417  return 0x8F;
418  break;
419  case 5:
420  if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
421  return 0x8B;
422  break;
423  case 6:
424  if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
425  return 0x96;
426  break;
427  case 7:
428  if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
429  return 0xA5;
430  break;
431  case 8:
432  if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
433  return 0x93;
434  break;
435  case 9:
436  if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
437  return 0x92;
438  break;
439  case 10:
440  return 0x91;
441  case 11:
442  if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
443  ADT7462_PIN28_VOLT &&
444  !(data->pin_cfg[0] & ADT7462_VID_INPUT))
445  return 0x94;
446  break;
447  case 12:
448  if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
449  ADT7462_PIN28_VOLT &&
450  !(data->pin_cfg[0] & ADT7462_VID_INPUT))
451  return 0x95;
452  break;
453  }
454  return -ENODEV;
455 }
456 
457 /* Provide labels for sysfs */
458 static const char *voltage_label(struct adt7462_data *data, int which)
459 {
460  switch (which) {
461  case 0:
462  if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
463  return "+12V1";
464  break;
465  case 1:
466  switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
467  case 0:
468  return "Vccp1";
469  case 1:
470  return "+2.5V";
471  case 2:
472  return "+1.8V";
473  case 3:
474  return "+1.5V";
475  }
476  case 2:
477  if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
478  return "+12V3";
479  break;
480  case 3:
481  if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
482  return "+5V";
483  break;
484  case 4:
485  if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
486  if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
487  return "+0.9V";
488  return "+1.25V";
489  }
490  break;
491  case 5:
492  if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
493  if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
494  return "+1.8V";
495  return "+2.5V";
496  }
497  break;
498  case 6:
499  if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
500  return "+3.3V";
501  break;
502  case 7:
503  if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
504  return "+12V2";
505  break;
506  case 8:
507  switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
508  case 0:
509  return "Vbatt";
510  case 1:
511  return "FSB_Vtt";
512  }
513  break;
514  case 9:
515  switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
516  case 0:
517  return "+3.3V";
518  case 1:
519  return "+1.2V1";
520  }
521  break;
522  case 10:
523  switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
524  case 0:
525  return "Vccp2";
526  case 1:
527  return "+2.5V";
528  case 2:
529  return "+1.8V";
530  case 3:
531  return "+1.5";
532  }
533  case 11:
534  if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
535  ADT7462_PIN28_VOLT &&
536  !(data->pin_cfg[0] & ADT7462_VID_INPUT))
537  return "+1.5V ICH";
538  break;
539  case 12:
540  if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
541  ADT7462_PIN28_VOLT &&
542  !(data->pin_cfg[0] & ADT7462_VID_INPUT))
543  return "+1.5V 3GPIO";
544  break;
545  }
546  return "N/A";
547 }
548 
549 /* Multipliers are actually in uV, not mV. */
550 static int voltage_multiplier(struct adt7462_data *data, int which)
551 {
552  switch (which) {
553  case 0:
554  if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
555  return 62500;
556  break;
557  case 1:
558  switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
559  case 0:
560  if (data->pin_cfg[0] & ADT7462_VID_INPUT)
561  return 12500;
562  return 6250;
563  case 1:
564  return 13000;
565  case 2:
566  return 9400;
567  case 3:
568  return 7800;
569  }
570  case 2:
571  if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
572  return 62500;
573  break;
574  case 3:
575  if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
576  return 26000;
577  break;
578  case 4:
579  if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
580  if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
581  return 4690;
582  return 6500;
583  }
584  break;
585  case 5:
586  if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
587  if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
588  return 9400;
589  return 13000;
590  }
591  break;
592  case 6:
593  if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
594  return 17200;
595  break;
596  case 7:
597  if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
598  return 62500;
599  break;
600  case 8:
601  switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
602  case 0:
603  return 15600;
604  case 1:
605  return 6250;
606  }
607  break;
608  case 9:
609  switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
610  case 0:
611  return 17200;
612  case 1:
613  return 6250;
614  }
615  break;
616  case 10:
617  switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
618  case 0:
619  return 6250;
620  case 1:
621  return 13000;
622  case 2:
623  return 9400;
624  case 3:
625  return 7800;
626  }
627  case 11:
628  case 12:
629  if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
630  ADT7462_PIN28_VOLT &&
631  !(data->pin_cfg[0] & ADT7462_VID_INPUT))
632  return 7800;
633  }
634  return 0;
635 }
636 
637 static int temp_enabled(struct adt7462_data *data, int which)
638 {
639  switch (which) {
640  case 0:
641  case 2:
642  return 1;
643  case 1:
644  if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
645  return 1;
646  break;
647  case 3:
648  if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
649  return 1;
650  break;
651  }
652  return 0;
653 }
654 
655 static const char *temp_label(struct adt7462_data *data, int which)
656 {
657  switch (which) {
658  case 0:
659  return "local";
660  case 1:
661  if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
662  return "remote1";
663  break;
664  case 2:
665  return "remote2";
666  case 3:
667  if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
668  return "remote3";
669  break;
670  }
671  return "N/A";
672 }
673 
674 /* Map Trange register values to mC */
675 #define NUM_TRANGE_VALUES 16
676 static const int trange_values[NUM_TRANGE_VALUES] = {
677  2000,
678  2500,
679  3300,
680  4000,
681  5000,
682  6700,
683  8000,
684  10000,
685  13300,
686  16000,
687  20000,
688  26700,
689  32000,
690  40000,
691  53300,
692  80000
693 };
694 
695 static int find_trange_value(int trange)
696 {
697  int i;
698 
699  for (i = 0; i < NUM_TRANGE_VALUES; i++)
700  if (trange_values[i] == trange)
701  return i;
702 
703  return -ENODEV;
704 }
705 
706 static struct adt7462_data *adt7462_update_device(struct device *dev)
707 {
708  struct i2c_client *client = to_i2c_client(dev);
709  struct adt7462_data *data = i2c_get_clientdata(client);
710  unsigned long local_jiffies = jiffies;
711  int i;
712 
713  mutex_lock(&data->lock);
714  if (time_before(local_jiffies, data->sensors_last_updated +
715  SENSOR_REFRESH_INTERVAL)
716  && data->sensors_valid)
717  goto no_sensor_update;
718 
719  for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
720  /*
721  * Reading the fractional register locks the integral
722  * register until both have been read.
723  */
724  data->temp_frac[i] = i2c_smbus_read_byte_data(client,
725  ADT7462_TEMP_REG(i));
726  data->temp[i] = i2c_smbus_read_byte_data(client,
727  ADT7462_TEMP_REG(i) + 1);
728  }
729 
730  for (i = 0; i < ADT7462_FAN_COUNT; i++)
731  data->fan[i] = adt7462_read_word_data(client,
732  ADT7462_REG_FAN(i));
733 
734  data->fan_enabled = i2c_smbus_read_byte_data(client,
735  ADT7462_REG_FAN_ENABLE);
736 
737  for (i = 0; i < ADT7462_PWM_COUNT; i++)
738  data->pwm[i] = i2c_smbus_read_byte_data(client,
739  ADT7462_REG_PWM(i));
740 
741  for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
742  data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
743  ADT7462_REG_PIN_CFG(i));
744 
745  for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
746  int reg = ADT7462_REG_VOLT(data, i);
747  if (!reg)
748  data->voltages[i] = 0;
749  else
750  data->voltages[i] = i2c_smbus_read_byte_data(client,
751  reg);
752  }
753 
754  data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
755  data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
756  data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
757  data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
758 
759  data->sensors_last_updated = local_jiffies;
760  data->sensors_valid = 1;
761 
762 no_sensor_update:
763  if (time_before(local_jiffies, data->limits_last_updated +
764  LIMIT_REFRESH_INTERVAL)
765  && data->limits_valid)
766  goto out;
767 
768  for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
769  data->temp_min[i] = i2c_smbus_read_byte_data(client,
770  ADT7462_TEMP_MIN_REG(i));
771  data->temp_max[i] = i2c_smbus_read_byte_data(client,
772  ADT7462_TEMP_MAX_REG(i));
773  }
774 
775  for (i = 0; i < ADT7462_FAN_COUNT; i++)
776  data->fan_min[i] = i2c_smbus_read_byte_data(client,
777  ADT7462_REG_FAN_MIN(i));
778 
779  for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
780  int reg = ADT7462_REG_VOLT_MAX(data, i);
781  data->volt_max[i] =
782  (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
783 
784  reg = ADT7462_REG_VOLT_MIN(data, i);
785  data->volt_min[i] =
786  (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
787  }
788 
789  for (i = 0; i < ADT7462_PWM_COUNT; i++) {
790  data->pwm_min[i] = i2c_smbus_read_byte_data(client,
791  ADT7462_REG_PWM_MIN(i));
792  data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
793  ADT7462_REG_PWM_TMIN(i));
794  data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
795  ADT7462_REG_PWM_TRANGE(i));
796  data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
797  ADT7462_REG_PWM_CFG(i));
798  }
799 
800  data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
801 
802  data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
803 
804  data->limits_last_updated = local_jiffies;
805  data->limits_valid = 1;
806 
807 out:
808  mutex_unlock(&data->lock);
809  return data;
810 }
811 
812 static ssize_t show_temp_min(struct device *dev,
813  struct device_attribute *devattr,
814  char *buf)
815 {
816  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
817  struct adt7462_data *data = adt7462_update_device(dev);
818 
819  if (!temp_enabled(data, attr->index))
820  return sprintf(buf, "0\n");
821 
822  return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
823 }
824 
825 static ssize_t set_temp_min(struct device *dev,
826  struct device_attribute *devattr,
827  const char *buf,
828  size_t count)
829 {
830  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
831  struct i2c_client *client = to_i2c_client(dev);
832  struct adt7462_data *data = i2c_get_clientdata(client);
833  long temp;
834 
835  if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
836  return -EINVAL;
837 
838  temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
839  temp = SENSORS_LIMIT(temp, 0, 255);
840 
841  mutex_lock(&data->lock);
842  data->temp_min[attr->index] = temp;
843  i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
844  temp);
845  mutex_unlock(&data->lock);
846 
847  return count;
848 }
849 
850 static ssize_t show_temp_max(struct device *dev,
851  struct device_attribute *devattr,
852  char *buf)
853 {
854  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
855  struct adt7462_data *data = adt7462_update_device(dev);
856 
857  if (!temp_enabled(data, attr->index))
858  return sprintf(buf, "0\n");
859 
860  return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
861 }
862 
863 static ssize_t set_temp_max(struct device *dev,
864  struct device_attribute *devattr,
865  const char *buf,
866  size_t count)
867 {
868  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
869  struct i2c_client *client = to_i2c_client(dev);
870  struct adt7462_data *data = i2c_get_clientdata(client);
871  long temp;
872 
873  if (kstrtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
874  return -EINVAL;
875 
876  temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
877  temp = SENSORS_LIMIT(temp, 0, 255);
878 
879  mutex_lock(&data->lock);
880  data->temp_max[attr->index] = temp;
881  i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
882  temp);
883  mutex_unlock(&data->lock);
884 
885  return count;
886 }
887 
888 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
889  char *buf)
890 {
891  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
892  struct adt7462_data *data = adt7462_update_device(dev);
893  u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
894 
895  if (!temp_enabled(data, attr->index))
896  return sprintf(buf, "0\n");
897 
898  return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
899  250 * frac);
900 }
901 
902 static ssize_t show_temp_label(struct device *dev,
903  struct device_attribute *devattr,
904  char *buf)
905 {
906  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
907  struct adt7462_data *data = adt7462_update_device(dev);
908 
909  return sprintf(buf, "%s\n", temp_label(data, attr->index));
910 }
911 
912 static ssize_t show_volt_max(struct device *dev,
913  struct device_attribute *devattr,
914  char *buf)
915 {
916  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
917  struct adt7462_data *data = adt7462_update_device(dev);
918  int x = voltage_multiplier(data, attr->index);
919 
920  x *= data->volt_max[attr->index];
921  x /= 1000; /* convert from uV to mV */
922 
923  return sprintf(buf, "%d\n", x);
924 }
925 
926 static ssize_t set_volt_max(struct device *dev,
927  struct device_attribute *devattr,
928  const char *buf,
929  size_t count)
930 {
931  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
932  struct i2c_client *client = to_i2c_client(dev);
933  struct adt7462_data *data = i2c_get_clientdata(client);
934  int x = voltage_multiplier(data, attr->index);
935  long temp;
936 
937  if (kstrtol(buf, 10, &temp) || !x)
938  return -EINVAL;
939 
940  temp *= 1000; /* convert mV to uV */
941  temp = DIV_ROUND_CLOSEST(temp, x);
942  temp = SENSORS_LIMIT(temp, 0, 255);
943 
944  mutex_lock(&data->lock);
945  data->volt_max[attr->index] = temp;
946  i2c_smbus_write_byte_data(client,
947  ADT7462_REG_VOLT_MAX(data, attr->index),
948  temp);
949  mutex_unlock(&data->lock);
950 
951  return count;
952 }
953 
954 static ssize_t show_volt_min(struct device *dev,
955  struct device_attribute *devattr,
956  char *buf)
957 {
958  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
959  struct adt7462_data *data = adt7462_update_device(dev);
960  int x = voltage_multiplier(data, attr->index);
961 
962  x *= data->volt_min[attr->index];
963  x /= 1000; /* convert from uV to mV */
964 
965  return sprintf(buf, "%d\n", x);
966 }
967 
968 static ssize_t set_volt_min(struct device *dev,
969  struct device_attribute *devattr,
970  const char *buf,
971  size_t count)
972 {
973  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
974  struct i2c_client *client = to_i2c_client(dev);
975  struct adt7462_data *data = i2c_get_clientdata(client);
976  int x = voltage_multiplier(data, attr->index);
977  long temp;
978 
979  if (kstrtol(buf, 10, &temp) || !x)
980  return -EINVAL;
981 
982  temp *= 1000; /* convert mV to uV */
983  temp = DIV_ROUND_CLOSEST(temp, x);
984  temp = SENSORS_LIMIT(temp, 0, 255);
985 
986  mutex_lock(&data->lock);
987  data->volt_min[attr->index] = temp;
988  i2c_smbus_write_byte_data(client,
989  ADT7462_REG_VOLT_MIN(data, attr->index),
990  temp);
991  mutex_unlock(&data->lock);
992 
993  return count;
994 }
995 
996 static ssize_t show_voltage(struct device *dev,
997  struct device_attribute *devattr,
998  char *buf)
999 {
1000  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1001  struct adt7462_data *data = adt7462_update_device(dev);
1002  int x = voltage_multiplier(data, attr->index);
1003 
1004  x *= data->voltages[attr->index];
1005  x /= 1000; /* convert from uV to mV */
1006 
1007  return sprintf(buf, "%d\n", x);
1008 }
1009 
1010 static ssize_t show_voltage_label(struct device *dev,
1011  struct device_attribute *devattr,
1012  char *buf)
1013 {
1014  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1015  struct adt7462_data *data = adt7462_update_device(dev);
1016 
1017  return sprintf(buf, "%s\n", voltage_label(data, attr->index));
1018 }
1019 
1020 static ssize_t show_alarm(struct device *dev,
1021  struct device_attribute *devattr,
1022  char *buf)
1023 {
1024  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1025  struct adt7462_data *data = adt7462_update_device(dev);
1026  int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
1027  int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
1028 
1029  if (data->alarms[reg] & mask)
1030  return sprintf(buf, "1\n");
1031  else
1032  return sprintf(buf, "0\n");
1033 }
1034 
1035 static int fan_enabled(struct adt7462_data *data, int fan)
1036 {
1037  return data->fan_enabled & (1 << fan);
1038 }
1039 
1040 static ssize_t show_fan_min(struct device *dev,
1041  struct device_attribute *devattr,
1042  char *buf)
1043 {
1044  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1045  struct adt7462_data *data = adt7462_update_device(dev);
1046  u16 temp;
1047 
1048  /* Only the MSB of the min fan period is stored... */
1049  temp = data->fan_min[attr->index];
1050  temp <<= 8;
1051 
1052  if (!fan_enabled(data, attr->index) ||
1053  !FAN_DATA_VALID(temp))
1054  return sprintf(buf, "0\n");
1055 
1056  return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
1057 }
1058 
1059 static ssize_t set_fan_min(struct device *dev,
1060  struct device_attribute *devattr,
1061  const char *buf, size_t count)
1062 {
1063  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1064  struct i2c_client *client = to_i2c_client(dev);
1065  struct adt7462_data *data = i2c_get_clientdata(client);
1066  long temp;
1067 
1068  if (kstrtol(buf, 10, &temp) || !temp ||
1069  !fan_enabled(data, attr->index))
1070  return -EINVAL;
1071 
1072  temp = FAN_RPM_TO_PERIOD(temp);
1073  temp >>= 8;
1074  temp = SENSORS_LIMIT(temp, 1, 255);
1075 
1076  mutex_lock(&data->lock);
1077  data->fan_min[attr->index] = temp;
1078  i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
1079  temp);
1080  mutex_unlock(&data->lock);
1081 
1082  return count;
1083 }
1084 
1085 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
1086  char *buf)
1087 {
1088  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1089  struct adt7462_data *data = adt7462_update_device(dev);
1090 
1091  if (!fan_enabled(data, attr->index) ||
1092  !FAN_DATA_VALID(data->fan[attr->index]))
1093  return sprintf(buf, "0\n");
1094 
1095  return sprintf(buf, "%d\n",
1096  FAN_PERIOD_TO_RPM(data->fan[attr->index]));
1097 }
1098 
1099 static ssize_t show_force_pwm_max(struct device *dev,
1100  struct device_attribute *devattr,
1101  char *buf)
1102 {
1103  struct adt7462_data *data = adt7462_update_device(dev);
1104  return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
1105 }
1106 
1107 static ssize_t set_force_pwm_max(struct device *dev,
1108  struct device_attribute *devattr,
1109  const char *buf,
1110  size_t count)
1111 {
1112  struct i2c_client *client = to_i2c_client(dev);
1113  struct adt7462_data *data = i2c_get_clientdata(client);
1114  long temp;
1115  u8 reg;
1116 
1117  if (kstrtol(buf, 10, &temp))
1118  return -EINVAL;
1119 
1120  mutex_lock(&data->lock);
1121  reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
1122  if (temp)
1123  reg |= ADT7462_FSPD_MASK;
1124  else
1125  reg &= ~ADT7462_FSPD_MASK;
1126  data->cfg2 = reg;
1127  i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
1128  mutex_unlock(&data->lock);
1129 
1130  return count;
1131 }
1132 
1133 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
1134  char *buf)
1135 {
1136  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1137  struct adt7462_data *data = adt7462_update_device(dev);
1138  return sprintf(buf, "%d\n", data->pwm[attr->index]);
1139 }
1140 
1141 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
1142  const char *buf, size_t count)
1143 {
1144  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1145  struct i2c_client *client = to_i2c_client(dev);
1146  struct adt7462_data *data = i2c_get_clientdata(client);
1147  long temp;
1148 
1149  if (kstrtol(buf, 10, &temp))
1150  return -EINVAL;
1151 
1152  temp = SENSORS_LIMIT(temp, 0, 255);
1153 
1154  mutex_lock(&data->lock);
1155  data->pwm[attr->index] = temp;
1156  i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
1157  mutex_unlock(&data->lock);
1158 
1159  return count;
1160 }
1161 
1162 static ssize_t show_pwm_max(struct device *dev,
1163  struct device_attribute *devattr,
1164  char *buf)
1165 {
1166  struct adt7462_data *data = adt7462_update_device(dev);
1167  return sprintf(buf, "%d\n", data->pwm_max);
1168 }
1169 
1170 static ssize_t set_pwm_max(struct device *dev,
1171  struct device_attribute *devattr,
1172  const char *buf,
1173  size_t count)
1174 {
1175  struct i2c_client *client = to_i2c_client(dev);
1176  struct adt7462_data *data = i2c_get_clientdata(client);
1177  long temp;
1178 
1179  if (kstrtol(buf, 10, &temp))
1180  return -EINVAL;
1181 
1182  temp = SENSORS_LIMIT(temp, 0, 255);
1183 
1184  mutex_lock(&data->lock);
1185  data->pwm_max = temp;
1186  i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
1187  mutex_unlock(&data->lock);
1188 
1189  return count;
1190 }
1191 
1192 static ssize_t show_pwm_min(struct device *dev,
1193  struct device_attribute *devattr,
1194  char *buf)
1195 {
1196  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1197  struct adt7462_data *data = adt7462_update_device(dev);
1198  return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
1199 }
1200 
1201 static ssize_t set_pwm_min(struct device *dev,
1202  struct device_attribute *devattr,
1203  const char *buf,
1204  size_t count)
1205 {
1206  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1207  struct i2c_client *client = to_i2c_client(dev);
1208  struct adt7462_data *data = i2c_get_clientdata(client);
1209  long temp;
1210 
1211  if (kstrtol(buf, 10, &temp))
1212  return -EINVAL;
1213 
1214  temp = SENSORS_LIMIT(temp, 0, 255);
1215 
1216  mutex_lock(&data->lock);
1217  data->pwm_min[attr->index] = temp;
1218  i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
1219  temp);
1220  mutex_unlock(&data->lock);
1221 
1222  return count;
1223 }
1224 
1225 static ssize_t show_pwm_hyst(struct device *dev,
1226  struct device_attribute *devattr,
1227  char *buf)
1228 {
1229  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1230  struct adt7462_data *data = adt7462_update_device(dev);
1231  return sprintf(buf, "%d\n", 1000 *
1232  (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
1233 }
1234 
1235 static ssize_t set_pwm_hyst(struct device *dev,
1236  struct device_attribute *devattr,
1237  const char *buf,
1238  size_t count)
1239 {
1240  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1241  struct i2c_client *client = to_i2c_client(dev);
1242  struct adt7462_data *data = i2c_get_clientdata(client);
1243  long temp;
1244 
1245  if (kstrtol(buf, 10, &temp))
1246  return -EINVAL;
1247 
1248  temp = DIV_ROUND_CLOSEST(temp, 1000);
1249  temp = SENSORS_LIMIT(temp, 0, 15);
1250 
1251  /* package things up */
1252  temp &= ADT7462_PWM_HYST_MASK;
1253  temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
1254 
1255  mutex_lock(&data->lock);
1256  data->pwm_trange[attr->index] = temp;
1257  i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1258  temp);
1259  mutex_unlock(&data->lock);
1260 
1261  return count;
1262 }
1263 
1264 static ssize_t show_pwm_tmax(struct device *dev,
1265  struct device_attribute *devattr,
1266  char *buf)
1267 {
1268  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1269  struct adt7462_data *data = adt7462_update_device(dev);
1270 
1271  /* tmax = tmin + trange */
1272  int trange = trange_values[data->pwm_trange[attr->index] >>
1273  ADT7462_PWM_RANGE_SHIFT];
1274  int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1275 
1276  return sprintf(buf, "%d\n", tmin + trange);
1277 }
1278 
1279 static ssize_t set_pwm_tmax(struct device *dev,
1280  struct device_attribute *devattr,
1281  const char *buf,
1282  size_t count)
1283 {
1284  int temp;
1285  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1286  struct i2c_client *client = to_i2c_client(dev);
1287  struct adt7462_data *data = i2c_get_clientdata(client);
1288  int tmin, trange_value;
1289  long trange;
1290 
1291  if (kstrtol(buf, 10, &trange))
1292  return -EINVAL;
1293 
1294  /* trange = tmax - tmin */
1295  tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
1296  trange_value = find_trange_value(trange - tmin);
1297 
1298  if (trange_value < 0)
1299  return -EINVAL;
1300 
1301  temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
1302  temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
1303 
1304  mutex_lock(&data->lock);
1305  data->pwm_trange[attr->index] = temp;
1306  i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
1307  temp);
1308  mutex_unlock(&data->lock);
1309 
1310  return count;
1311 }
1312 
1313 static ssize_t show_pwm_tmin(struct device *dev,
1314  struct device_attribute *devattr,
1315  char *buf)
1316 {
1317  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1318  struct adt7462_data *data = adt7462_update_device(dev);
1319  return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
1320 }
1321 
1322 static ssize_t set_pwm_tmin(struct device *dev,
1323  struct device_attribute *devattr,
1324  const char *buf,
1325  size_t count)
1326 {
1327  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1328  struct i2c_client *client = to_i2c_client(dev);
1329  struct adt7462_data *data = i2c_get_clientdata(client);
1330  long temp;
1331 
1332  if (kstrtol(buf, 10, &temp))
1333  return -EINVAL;
1334 
1335  temp = DIV_ROUND_CLOSEST(temp, 1000) + 64;
1336  temp = SENSORS_LIMIT(temp, 0, 255);
1337 
1338  mutex_lock(&data->lock);
1339  data->pwm_tmin[attr->index] = temp;
1340  i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
1341  temp);
1342  mutex_unlock(&data->lock);
1343 
1344  return count;
1345 }
1346 
1347 static ssize_t show_pwm_auto(struct device *dev,
1348  struct device_attribute *devattr,
1349  char *buf)
1350 {
1351  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1352  struct adt7462_data *data = adt7462_update_device(dev);
1353  int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1354 
1355  switch (cfg) {
1356  case 4: /* off */
1357  return sprintf(buf, "0\n");
1358  case 7: /* manual */
1359  return sprintf(buf, "1\n");
1360  default: /* automatic */
1361  return sprintf(buf, "2\n");
1362  }
1363 }
1364 
1365 static void set_pwm_channel(struct i2c_client *client,
1366  struct adt7462_data *data,
1367  int which,
1368  int value)
1369 {
1370  int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
1371  temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
1372 
1373  mutex_lock(&data->lock);
1374  data->pwm_cfg[which] = temp;
1375  i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
1376  mutex_unlock(&data->lock);
1377 }
1378 
1379 static ssize_t set_pwm_auto(struct device *dev,
1380  struct device_attribute *devattr,
1381  const char *buf,
1382  size_t count)
1383 {
1384  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1385  struct i2c_client *client = to_i2c_client(dev);
1386  struct adt7462_data *data = i2c_get_clientdata(client);
1387  long temp;
1388 
1389  if (kstrtol(buf, 10, &temp))
1390  return -EINVAL;
1391 
1392  switch (temp) {
1393  case 0: /* off */
1394  set_pwm_channel(client, data, attr->index, 4);
1395  return count;
1396  case 1: /* manual */
1397  set_pwm_channel(client, data, attr->index, 7);
1398  return count;
1399  default:
1400  return -EINVAL;
1401  }
1402 }
1403 
1404 static ssize_t show_pwm_auto_temp(struct device *dev,
1405  struct device_attribute *devattr,
1406  char *buf)
1407 {
1408  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1409  struct adt7462_data *data = adt7462_update_device(dev);
1410  int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
1411 
1412  switch (channel) {
1413  case 0: /* temp[1234] only */
1414  case 1:
1415  case 2:
1416  case 3:
1417  return sprintf(buf, "%d\n", (1 << channel));
1418  case 5: /* temp1 & temp4 */
1419  return sprintf(buf, "9\n");
1420  case 6:
1421  return sprintf(buf, "15\n");
1422  default:
1423  return sprintf(buf, "0\n");
1424  }
1425 }
1426 
1427 static int cvt_auto_temp(int input)
1428 {
1429  if (input == 0xF)
1430  return 6;
1431  if (input == 0x9)
1432  return 5;
1433  if (input < 1 || !is_power_of_2(input))
1434  return -EINVAL;
1435  return ilog2(input);
1436 }
1437 
1438 static ssize_t set_pwm_auto_temp(struct device *dev,
1439  struct device_attribute *devattr,
1440  const char *buf,
1441  size_t count)
1442 {
1443  struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1444  struct i2c_client *client = to_i2c_client(dev);
1445  struct adt7462_data *data = i2c_get_clientdata(client);
1446  long temp;
1447 
1448  if (kstrtol(buf, 10, &temp))
1449  return -EINVAL;
1450 
1451  temp = cvt_auto_temp(temp);
1452  if (temp < 0)
1453  return temp;
1454 
1455  set_pwm_channel(client, data, attr->index, temp);
1456 
1457  return count;
1458 }
1459 
1460 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
1461  set_temp_max, 0);
1462 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
1463  set_temp_max, 1);
1464 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
1465  set_temp_max, 2);
1466 static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max,
1467  set_temp_max, 3);
1468 
1469 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
1470  set_temp_min, 0);
1471 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
1472  set_temp_min, 1);
1473 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
1474  set_temp_min, 2);
1475 static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min,
1476  set_temp_min, 3);
1477 
1478 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1479 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
1480 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
1481 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
1482 
1483 static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0);
1484 static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1);
1485 static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2);
1486 static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3);
1487 
1488 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
1489  ADT7462_ALARM1 | ADT7462_LT_ALARM);
1490 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
1491  ADT7462_ALARM1 | ADT7462_R1T_ALARM);
1492 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
1493  ADT7462_ALARM1 | ADT7462_R2T_ALARM);
1494 static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL,
1495  ADT7462_ALARM1 | ADT7462_R3T_ALARM);
1496 
1497 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, show_volt_max,
1498  set_volt_max, 0);
1499 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, show_volt_max,
1500  set_volt_max, 1);
1501 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, show_volt_max,
1502  set_volt_max, 2);
1503 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, show_volt_max,
1504  set_volt_max, 3);
1505 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, show_volt_max,
1506  set_volt_max, 4);
1507 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, show_volt_max,
1508  set_volt_max, 5);
1509 static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO, show_volt_max,
1510  set_volt_max, 6);
1511 static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO, show_volt_max,
1512  set_volt_max, 7);
1513 static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO, show_volt_max,
1514  set_volt_max, 8);
1515 static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO, show_volt_max,
1516  set_volt_max, 9);
1517 static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO, show_volt_max,
1518  set_volt_max, 10);
1519 static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO, show_volt_max,
1520  set_volt_max, 11);
1521 static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO, show_volt_max,
1522  set_volt_max, 12);
1523 
1524 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, show_volt_min,
1525  set_volt_min, 0);
1526 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, show_volt_min,
1527  set_volt_min, 1);
1528 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, show_volt_min,
1529  set_volt_min, 2);
1530 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, show_volt_min,
1531  set_volt_min, 3);
1532 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, show_volt_min,
1533  set_volt_min, 4);
1534 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, show_volt_min,
1535  set_volt_min, 5);
1536 static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO, show_volt_min,
1537  set_volt_min, 6);
1538 static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO, show_volt_min,
1539  set_volt_min, 7);
1540 static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO, show_volt_min,
1541  set_volt_min, 8);
1542 static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO, show_volt_min,
1543  set_volt_min, 9);
1544 static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO, show_volt_min,
1545  set_volt_min, 10);
1546 static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO, show_volt_min,
1547  set_volt_min, 11);
1548 static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO, show_volt_min,
1549  set_volt_min, 12);
1550 
1551 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_voltage, NULL, 0);
1552 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_voltage, NULL, 1);
1553 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_voltage, NULL, 2);
1554 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_voltage, NULL, 3);
1555 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_voltage, NULL, 4);
1556 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_voltage, NULL, 5);
1557 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_voltage, NULL, 6);
1558 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_voltage, NULL, 7);
1559 static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_voltage, NULL, 8);
1560 static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_voltage, NULL, 9);
1561 static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_voltage, NULL, 10);
1562 static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_voltage, NULL, 11);
1563 static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_voltage, NULL, 12);
1564 
1565 static SENSOR_DEVICE_ATTR(in1_label, S_IRUGO, show_voltage_label, NULL, 0);
1566 static SENSOR_DEVICE_ATTR(in2_label, S_IRUGO, show_voltage_label, NULL, 1);
1567 static SENSOR_DEVICE_ATTR(in3_label, S_IRUGO, show_voltage_label, NULL, 2);
1568 static SENSOR_DEVICE_ATTR(in4_label, S_IRUGO, show_voltage_label, NULL, 3);
1569 static SENSOR_DEVICE_ATTR(in5_label, S_IRUGO, show_voltage_label, NULL, 4);
1570 static SENSOR_DEVICE_ATTR(in6_label, S_IRUGO, show_voltage_label, NULL, 5);
1571 static SENSOR_DEVICE_ATTR(in7_label, S_IRUGO, show_voltage_label, NULL, 6);
1572 static SENSOR_DEVICE_ATTR(in8_label, S_IRUGO, show_voltage_label, NULL, 7);
1573 static SENSOR_DEVICE_ATTR(in9_label, S_IRUGO, show_voltage_label, NULL, 8);
1574 static SENSOR_DEVICE_ATTR(in10_label, S_IRUGO, show_voltage_label, NULL, 9);
1575 static SENSOR_DEVICE_ATTR(in11_label, S_IRUGO, show_voltage_label, NULL, 10);
1576 static SENSOR_DEVICE_ATTR(in12_label, S_IRUGO, show_voltage_label, NULL, 11);
1577 static SENSOR_DEVICE_ATTR(in13_label, S_IRUGO, show_voltage_label, NULL, 12);
1578 
1579 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL,
1580  ADT7462_ALARM2 | ADT7462_V0_ALARM);
1581 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL,
1582  ADT7462_ALARM2 | ADT7462_V7_ALARM);
1583 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL,
1584  ADT7462_ALARM2 | ADT7462_V2_ALARM);
1585 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL,
1586  ADT7462_ALARM2 | ADT7462_V6_ALARM);
1587 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL,
1588  ADT7462_ALARM2 | ADT7462_V5_ALARM);
1589 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL,
1590  ADT7462_ALARM2 | ADT7462_V4_ALARM);
1591 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL,
1592  ADT7462_ALARM2 | ADT7462_V3_ALARM);
1593 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL,
1594  ADT7462_ALARM2 | ADT7462_V1_ALARM);
1595 static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL,
1596  ADT7462_ALARM3 | ADT7462_V10_ALARM);
1597 static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL,
1598  ADT7462_ALARM3 | ADT7462_V9_ALARM);
1599 static SENSOR_DEVICE_ATTR(in11_alarm, S_IRUGO, show_alarm, NULL,
1600  ADT7462_ALARM3 | ADT7462_V8_ALARM);
1601 static SENSOR_DEVICE_ATTR(in12_alarm, S_IRUGO, show_alarm, NULL,
1602  ADT7462_ALARM3 | ADT7462_V11_ALARM);
1603 static SENSOR_DEVICE_ATTR(in13_alarm, S_IRUGO, show_alarm, NULL,
1604  ADT7462_ALARM3 | ADT7462_V12_ALARM);
1605 
1606 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
1607  set_fan_min, 0);
1608 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
1609  set_fan_min, 1);
1610 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
1611  set_fan_min, 2);
1612 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
1613  set_fan_min, 3);
1614 static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
1615  set_fan_min, 4);
1616 static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO, show_fan_min,
1617  set_fan_min, 5);
1618 static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO, show_fan_min,
1619  set_fan_min, 6);
1620 static SENSOR_DEVICE_ATTR(fan8_min, S_IWUSR | S_IRUGO, show_fan_min,
1621  set_fan_min, 7);
1622 
1623 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
1624 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
1625 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
1626 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
1627 static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4);
1628 static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan, NULL, 5);
1629 static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan, NULL, 6);
1630 static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan, NULL, 7);
1631 
1632 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
1633  ADT7462_ALARM4 | ADT7462_F0_ALARM);
1634 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
1635  ADT7462_ALARM4 | ADT7462_F1_ALARM);
1636 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
1637  ADT7462_ALARM4 | ADT7462_F2_ALARM);
1638 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
1639  ADT7462_ALARM4 | ADT7462_F3_ALARM);
1640 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL,
1641  ADT7462_ALARM4 | ADT7462_F4_ALARM);
1642 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL,
1643  ADT7462_ALARM4 | ADT7462_F5_ALARM);
1644 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_alarm, NULL,
1645  ADT7462_ALARM4 | ADT7462_F6_ALARM);
1646 static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_alarm, NULL,
1647  ADT7462_ALARM4 | ADT7462_F7_ALARM);
1648 
1649 static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO,
1650  show_force_pwm_max, set_force_pwm_max, 0);
1651 
1652 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
1653 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
1654 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
1655 static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
1656 
1657 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
1658  show_pwm_min, set_pwm_min, 0);
1659 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
1660  show_pwm_min, set_pwm_min, 1);
1661 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
1662  show_pwm_min, set_pwm_min, 2);
1663 static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
1664  show_pwm_min, set_pwm_min, 3);
1665 
1666 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
1667  show_pwm_max, set_pwm_max, 0);
1668 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
1669  show_pwm_max, set_pwm_max, 1);
1670 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
1671  show_pwm_max, set_pwm_max, 2);
1672 static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
1673  show_pwm_max, set_pwm_max, 3);
1674 
1675 static SENSOR_DEVICE_ATTR(temp1_auto_point1_hyst, S_IWUSR | S_IRUGO,
1676  show_pwm_hyst, set_pwm_hyst, 0);
1677 static SENSOR_DEVICE_ATTR(temp2_auto_point1_hyst, S_IWUSR | S_IRUGO,
1678  show_pwm_hyst, set_pwm_hyst, 1);
1679 static SENSOR_DEVICE_ATTR(temp3_auto_point1_hyst, S_IWUSR | S_IRUGO,
1680  show_pwm_hyst, set_pwm_hyst, 2);
1681 static SENSOR_DEVICE_ATTR(temp4_auto_point1_hyst, S_IWUSR | S_IRUGO,
1682  show_pwm_hyst, set_pwm_hyst, 3);
1683 
1684 static SENSOR_DEVICE_ATTR(temp1_auto_point2_hyst, S_IWUSR | S_IRUGO,
1685  show_pwm_hyst, set_pwm_hyst, 0);
1686 static SENSOR_DEVICE_ATTR(temp2_auto_point2_hyst, S_IWUSR | S_IRUGO,
1687  show_pwm_hyst, set_pwm_hyst, 1);
1688 static SENSOR_DEVICE_ATTR(temp3_auto_point2_hyst, S_IWUSR | S_IRUGO,
1689  show_pwm_hyst, set_pwm_hyst, 2);
1690 static SENSOR_DEVICE_ATTR(temp4_auto_point2_hyst, S_IWUSR | S_IRUGO,
1691  show_pwm_hyst, set_pwm_hyst, 3);
1692 
1693 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IWUSR | S_IRUGO,
1694  show_pwm_tmin, set_pwm_tmin, 0);
1695 static SENSOR_DEVICE_ATTR(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
1696  show_pwm_tmin, set_pwm_tmin, 1);
1697 static SENSOR_DEVICE_ATTR(temp3_auto_point1_temp, S_IWUSR | S_IRUGO,
1698  show_pwm_tmin, set_pwm_tmin, 2);
1699 static SENSOR_DEVICE_ATTR(temp4_auto_point1_temp, S_IWUSR | S_IRUGO,
1700  show_pwm_tmin, set_pwm_tmin, 3);
1701 
1702 static SENSOR_DEVICE_ATTR(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
1703  show_pwm_tmax, set_pwm_tmax, 0);
1704 static SENSOR_DEVICE_ATTR(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
1705  show_pwm_tmax, set_pwm_tmax, 1);
1706 static SENSOR_DEVICE_ATTR(temp3_auto_point2_temp, S_IWUSR | S_IRUGO,
1707  show_pwm_tmax, set_pwm_tmax, 2);
1708 static SENSOR_DEVICE_ATTR(temp4_auto_point2_temp, S_IWUSR | S_IRUGO,
1709  show_pwm_tmax, set_pwm_tmax, 3);
1710 
1711 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1712  set_pwm_auto, 0);
1713 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1714  set_pwm_auto, 1);
1715 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1716  set_pwm_auto, 2);
1717 static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
1718  set_pwm_auto, 3);
1719 
1720 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
1721  show_pwm_auto_temp, set_pwm_auto_temp, 0);
1722 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
1723  show_pwm_auto_temp, set_pwm_auto_temp, 1);
1724 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
1725  show_pwm_auto_temp, set_pwm_auto_temp, 2);
1726 static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO,
1727  show_pwm_auto_temp, set_pwm_auto_temp, 3);
1728 
1729 static struct attribute *adt7462_attr[] = {
1730  &sensor_dev_attr_temp1_max.dev_attr.attr,
1731  &sensor_dev_attr_temp2_max.dev_attr.attr,
1732  &sensor_dev_attr_temp3_max.dev_attr.attr,
1733  &sensor_dev_attr_temp4_max.dev_attr.attr,
1734 
1735  &sensor_dev_attr_temp1_min.dev_attr.attr,
1736  &sensor_dev_attr_temp2_min.dev_attr.attr,
1737  &sensor_dev_attr_temp3_min.dev_attr.attr,
1738  &sensor_dev_attr_temp4_min.dev_attr.attr,
1739 
1740  &sensor_dev_attr_temp1_input.dev_attr.attr,
1741  &sensor_dev_attr_temp2_input.dev_attr.attr,
1742  &sensor_dev_attr_temp3_input.dev_attr.attr,
1743  &sensor_dev_attr_temp4_input.dev_attr.attr,
1744 
1745  &sensor_dev_attr_temp1_label.dev_attr.attr,
1746  &sensor_dev_attr_temp2_label.dev_attr.attr,
1747  &sensor_dev_attr_temp3_label.dev_attr.attr,
1748  &sensor_dev_attr_temp4_label.dev_attr.attr,
1749 
1750  &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1751  &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1752  &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1753  &sensor_dev_attr_temp4_alarm.dev_attr.attr,
1754 
1755  &sensor_dev_attr_in1_max.dev_attr.attr,
1756  &sensor_dev_attr_in2_max.dev_attr.attr,
1757  &sensor_dev_attr_in3_max.dev_attr.attr,
1758  &sensor_dev_attr_in4_max.dev_attr.attr,
1759  &sensor_dev_attr_in5_max.dev_attr.attr,
1760  &sensor_dev_attr_in6_max.dev_attr.attr,
1761  &sensor_dev_attr_in7_max.dev_attr.attr,
1762  &sensor_dev_attr_in8_max.dev_attr.attr,
1763  &sensor_dev_attr_in9_max.dev_attr.attr,
1764  &sensor_dev_attr_in10_max.dev_attr.attr,
1765  &sensor_dev_attr_in11_max.dev_attr.attr,
1766  &sensor_dev_attr_in12_max.dev_attr.attr,
1767  &sensor_dev_attr_in13_max.dev_attr.attr,
1768 
1769  &sensor_dev_attr_in1_min.dev_attr.attr,
1770  &sensor_dev_attr_in2_min.dev_attr.attr,
1771  &sensor_dev_attr_in3_min.dev_attr.attr,
1772  &sensor_dev_attr_in4_min.dev_attr.attr,
1773  &sensor_dev_attr_in5_min.dev_attr.attr,
1774  &sensor_dev_attr_in6_min.dev_attr.attr,
1775  &sensor_dev_attr_in7_min.dev_attr.attr,
1776  &sensor_dev_attr_in8_min.dev_attr.attr,
1777  &sensor_dev_attr_in9_min.dev_attr.attr,
1778  &sensor_dev_attr_in10_min.dev_attr.attr,
1779  &sensor_dev_attr_in11_min.dev_attr.attr,
1780  &sensor_dev_attr_in12_min.dev_attr.attr,
1781  &sensor_dev_attr_in13_min.dev_attr.attr,
1782 
1783  &sensor_dev_attr_in1_input.dev_attr.attr,
1784  &sensor_dev_attr_in2_input.dev_attr.attr,
1785  &sensor_dev_attr_in3_input.dev_attr.attr,
1786  &sensor_dev_attr_in4_input.dev_attr.attr,
1787  &sensor_dev_attr_in5_input.dev_attr.attr,
1788  &sensor_dev_attr_in6_input.dev_attr.attr,
1789  &sensor_dev_attr_in7_input.dev_attr.attr,
1790  &sensor_dev_attr_in8_input.dev_attr.attr,
1791  &sensor_dev_attr_in9_input.dev_attr.attr,
1792  &sensor_dev_attr_in10_input.dev_attr.attr,
1793  &sensor_dev_attr_in11_input.dev_attr.attr,
1794  &sensor_dev_attr_in12_input.dev_attr.attr,
1795  &sensor_dev_attr_in13_input.dev_attr.attr,
1796 
1797  &sensor_dev_attr_in1_label.dev_attr.attr,
1798  &sensor_dev_attr_in2_label.dev_attr.attr,
1799  &sensor_dev_attr_in3_label.dev_attr.attr,
1800  &sensor_dev_attr_in4_label.dev_attr.attr,
1801  &sensor_dev_attr_in5_label.dev_attr.attr,
1802  &sensor_dev_attr_in6_label.dev_attr.attr,
1803  &sensor_dev_attr_in7_label.dev_attr.attr,
1804  &sensor_dev_attr_in8_label.dev_attr.attr,
1805  &sensor_dev_attr_in9_label.dev_attr.attr,
1806  &sensor_dev_attr_in10_label.dev_attr.attr,
1807  &sensor_dev_attr_in11_label.dev_attr.attr,
1808  &sensor_dev_attr_in12_label.dev_attr.attr,
1809  &sensor_dev_attr_in13_label.dev_attr.attr,
1810 
1811  &sensor_dev_attr_in1_alarm.dev_attr.attr,
1812  &sensor_dev_attr_in2_alarm.dev_attr.attr,
1813  &sensor_dev_attr_in3_alarm.dev_attr.attr,
1814  &sensor_dev_attr_in4_alarm.dev_attr.attr,
1815  &sensor_dev_attr_in5_alarm.dev_attr.attr,
1816  &sensor_dev_attr_in6_alarm.dev_attr.attr,
1817  &sensor_dev_attr_in7_alarm.dev_attr.attr,
1818  &sensor_dev_attr_in8_alarm.dev_attr.attr,
1819  &sensor_dev_attr_in9_alarm.dev_attr.attr,
1820  &sensor_dev_attr_in10_alarm.dev_attr.attr,
1821  &sensor_dev_attr_in11_alarm.dev_attr.attr,
1822  &sensor_dev_attr_in12_alarm.dev_attr.attr,
1823  &sensor_dev_attr_in13_alarm.dev_attr.attr,
1824 
1825  &sensor_dev_attr_fan1_min.dev_attr.attr,
1826  &sensor_dev_attr_fan2_min.dev_attr.attr,
1827  &sensor_dev_attr_fan3_min.dev_attr.attr,
1828  &sensor_dev_attr_fan4_min.dev_attr.attr,
1829  &sensor_dev_attr_fan5_min.dev_attr.attr,
1830  &sensor_dev_attr_fan6_min.dev_attr.attr,
1831  &sensor_dev_attr_fan7_min.dev_attr.attr,
1832  &sensor_dev_attr_fan8_min.dev_attr.attr,
1833 
1834  &sensor_dev_attr_fan1_input.dev_attr.attr,
1835  &sensor_dev_attr_fan2_input.dev_attr.attr,
1836  &sensor_dev_attr_fan3_input.dev_attr.attr,
1837  &sensor_dev_attr_fan4_input.dev_attr.attr,
1838  &sensor_dev_attr_fan5_input.dev_attr.attr,
1839  &sensor_dev_attr_fan6_input.dev_attr.attr,
1840  &sensor_dev_attr_fan7_input.dev_attr.attr,
1841  &sensor_dev_attr_fan8_input.dev_attr.attr,
1842 
1843  &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1844  &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1845  &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1846  &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1847  &sensor_dev_attr_fan5_alarm.dev_attr.attr,
1848  &sensor_dev_attr_fan6_alarm.dev_attr.attr,
1849  &sensor_dev_attr_fan7_alarm.dev_attr.attr,
1850  &sensor_dev_attr_fan8_alarm.dev_attr.attr,
1851 
1852  &sensor_dev_attr_force_pwm_max.dev_attr.attr,
1853  &sensor_dev_attr_pwm1.dev_attr.attr,
1854  &sensor_dev_attr_pwm2.dev_attr.attr,
1855  &sensor_dev_attr_pwm3.dev_attr.attr,
1856  &sensor_dev_attr_pwm4.dev_attr.attr,
1857 
1858  &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1859  &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1860  &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1861  &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
1862 
1863  &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1864  &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1865  &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1866  &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
1867 
1868  &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
1869  &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
1870  &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
1871  &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
1872 
1873  &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
1874  &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
1875  &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
1876  &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
1877 
1878  &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1879  &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1880  &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1881  &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
1882 
1883  &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1884  &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1885  &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1886  &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
1887 
1888  &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1889  &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1890  &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1891  &sensor_dev_attr_pwm4_enable.dev_attr.attr,
1892 
1893  &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1894  &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1895  &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1896  &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
1897  NULL
1898 };
1899 
1900 /* Return 0 if detection is successful, -ENODEV otherwise */
1901 static int adt7462_detect(struct i2c_client *client,
1902  struct i2c_board_info *info)
1903 {
1904  struct i2c_adapter *adapter = client->adapter;
1905  int vendor, device, revision;
1906 
1907  if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1908  return -ENODEV;
1909 
1910  vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
1911  if (vendor != ADT7462_VENDOR)
1912  return -ENODEV;
1913 
1914  device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
1915  if (device != ADT7462_DEVICE)
1916  return -ENODEV;
1917 
1918  revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION);
1919  if (revision != ADT7462_REVISION)
1920  return -ENODEV;
1921 
1922  strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
1923 
1924  return 0;
1925 }
1926 
1927 static int adt7462_probe(struct i2c_client *client,
1928  const struct i2c_device_id *id)
1929 {
1930  struct adt7462_data *data;
1931  int err;
1932 
1933  data = devm_kzalloc(&client->dev, sizeof(struct adt7462_data),
1934  GFP_KERNEL);
1935  if (!data)
1936  return -ENOMEM;
1937 
1938  i2c_set_clientdata(client, data);
1939  mutex_init(&data->lock);
1940 
1941  dev_info(&client->dev, "%s chip found\n", client->name);
1942 
1943  /* Register sysfs hooks */
1944  data->attrs.attrs = adt7462_attr;
1945  err = sysfs_create_group(&client->dev.kobj, &data->attrs);
1946  if (err)
1947  return err;
1948 
1949  data->hwmon_dev = hwmon_device_register(&client->dev);
1950  if (IS_ERR(data->hwmon_dev)) {
1951  err = PTR_ERR(data->hwmon_dev);
1952  goto exit_remove;
1953  }
1954 
1955  return 0;
1956 
1957 exit_remove:
1958  sysfs_remove_group(&client->dev.kobj, &data->attrs);
1959  return err;
1960 }
1961 
1962 static int adt7462_remove(struct i2c_client *client)
1963 {
1964  struct adt7462_data *data = i2c_get_clientdata(client);
1965 
1966  hwmon_device_unregister(data->hwmon_dev);
1967  sysfs_remove_group(&client->dev.kobj, &data->attrs);
1968  return 0;
1969 }
1970 
1971 module_i2c_driver(adt7462_driver);
1972 
1973 MODULE_AUTHOR("Darrick J. Wong <[email protected]>");
1974 MODULE_DESCRIPTION("ADT7462 driver");
1975 MODULE_LICENSE("GPL");
Generated on Thu Jan 10 2013 13:34:36 for Linux Kernel by   doxygen 1.8.2