?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PNP: stop using the subsystem rwsem
[linux/fpc-iii.git] / drivers / hwmon / w83793.c
blob253ffaf1568a7baefdeb86468b3467ae23d5466c
1 /*
2 w83793.c - Linux kernel driver for hardware monitoring
3 Copyright (C) 2006 Winbond Electronics Corp.
4 Yuan Mu
5 Rudolf Marek <r.marek@assembler.cz>
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 - version 2.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-1301 USA.
20 */
21
22 /*
23 Supports following chips:
24
25 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
26 w83793 10 12 8 6 0x7b 0x5ca3 yes no
27 */
28
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/i2c.h>
33 #include <linux/hwmon.h>
34 #include <linux/hwmon-vid.h>
35 #include <linux/hwmon-sysfs.h>
36 #include <linux/err.h>
37 #include <linux/mutex.h>
38
39 /* Addresses to scan */
40 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
41
42 /* Insmod parameters */
43 I2C_CLIENT_INSMOD_1(w83793);
44 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
45 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
46
47 static int reset;
48 module_param(reset, bool, 0);
49 MODULE_PARM_DESC(reset, "Set to 1 to reset chip, not recommended");
50
51 /*
52 Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved
53 as ID, Bank Select registers
54 */
55 #define W83793_REG_BANKSEL 0x00
56 #define W83793_REG_VENDORID 0x0d
57 #define W83793_REG_CHIPID 0x0e
58 #define W83793_REG_DEVICEID 0x0f
59
60 #define W83793_REG_CONFIG 0x40
61 #define W83793_REG_MFC 0x58
62 #define W83793_REG_FANIN_CTRL 0x5c
63 #define W83793_REG_FANIN_SEL 0x5d
64 #define W83793_REG_I2C_ADDR 0x0b
65 #define W83793_REG_I2C_SUBADDR 0x0c
66 #define W83793_REG_VID_INA 0x05
67 #define W83793_REG_VID_INB 0x06
68 #define W83793_REG_VID_LATCHA 0x07
69 #define W83793_REG_VID_LATCHB 0x08
70 #define W83793_REG_VID_CTRL 0x59
71
72 static u16 W83793_REG_TEMP_MODE[2] = { 0x5e, 0x5f };
73
74 #define TEMP_READ 0
75 #define TEMP_CRIT 1
76 #define TEMP_CRIT_HYST 2
77 #define TEMP_WARN 3
78 #define TEMP_WARN_HYST 4
79 /* only crit and crit_hyst affect real-time alarm status
80 current crit crit_hyst warn warn_hyst */
81 static u16 W83793_REG_TEMP[][5] = {
82 {0x1c, 0x78, 0x79, 0x7a, 0x7b},
83 {0x1d, 0x7c, 0x7d, 0x7e, 0x7f},
84 {0x1e, 0x80, 0x81, 0x82, 0x83},
85 {0x1f, 0x84, 0x85, 0x86, 0x87},
86 {0x20, 0x88, 0x89, 0x8a, 0x8b},
87 {0x21, 0x8c, 0x8d, 0x8e, 0x8f},
88 };
89
90 #define W83793_REG_TEMP_LOW_BITS 0x22
91
92 #define W83793_REG_BEEP(index) (0x53 + (index))
93 #define W83793_REG_ALARM(index) (0x4b + (index))
94
95 #define W83793_REG_CLR_CHASSIS 0x4a /* SMI MASK4 */
96 #define W83793_REG_IRQ_CTRL 0x50
97 #define W83793_REG_OVT_CTRL 0x51
98 #define W83793_REG_OVT_BEEP 0x52
99
100 #define IN_READ 0
101 #define IN_MAX 1
102 #define IN_LOW 2
103 static const u16 W83793_REG_IN[][3] = {
104 /* Current, High, Low */
105 {0x10, 0x60, 0x61}, /* Vcore A */
106 {0x11, 0x62, 0x63}, /* Vcore B */
107 {0x12, 0x64, 0x65}, /* Vtt */
108 {0x14, 0x6a, 0x6b}, /* VSEN1 */
109 {0x15, 0x6c, 0x6d}, /* VSEN2 */
110 {0x16, 0x6e, 0x6f}, /* +3VSEN */
111 {0x17, 0x70, 0x71}, /* +12VSEN */
112 {0x18, 0x72, 0x73}, /* 5VDD */
113 {0x19, 0x74, 0x75}, /* 5VSB */
114 {0x1a, 0x76, 0x77}, /* VBAT */
115 };
116
117 /* Low Bits of Vcore A/B Vtt Read/High/Low */
118 static const u16 W83793_REG_IN_LOW_BITS[] = { 0x1b, 0x68, 0x69 };
119 static u8 scale_in[] = { 2, 2, 2, 16, 16, 16, 8, 24, 24, 16 };
120 static u8 scale_in_add[] = { 0, 0, 0, 0, 0, 0, 0, 150, 150, 0 };
121
122 #define W83793_REG_FAN(index) (0x23 + 2 * (index)) /* High byte */
123 #define W83793_REG_FAN_MIN(index) (0x90 + 2 * (index)) /* High byte */
124
125 #define W83793_REG_PWM_DEFAULT 0xb2
126 #define W83793_REG_PWM_ENABLE 0x207
127 #define W83793_REG_PWM_UPTIME 0xc3 /* Unit in 0.1 second */
128 #define W83793_REG_PWM_DOWNTIME 0xc4 /* Unit in 0.1 second */
129 #define W83793_REG_TEMP_CRITICAL 0xc5
130
131 #define PWM_DUTY 0
132 #define PWM_START 1
133 #define PWM_NONSTOP 2
134 #define W83793_REG_PWM(index, nr) (((nr) == 0 ? 0xb3 : \
135 (nr) == 1 ? 0x220 : 0x218) + (index))
136
137 /* bit field, fan1 is bit0, fan2 is bit1 ... */
138 #define W83793_REG_TEMP_FAN_MAP(index) (0x201 + (index))
139 #define W83793_REG_TEMP_TOL(index) (0x208 + (index))
140 #define W83793_REG_TEMP_CRUISE(index) (0x210 + (index))
141 #define W83793_REG_PWM_STOP_TIME(index) (0x228 + (index))
142 #define W83793_REG_SF2_TEMP(index, nr) (0x230 + ((index) << 4) + (nr))
143 #define W83793_REG_SF2_PWM(index, nr) (0x238 + ((index) << 4) + (nr))
144
145 static inline unsigned long FAN_FROM_REG(u16 val)
146 {
147 if ((val >= 0xfff) || (val == 0))
148 return 0;
149 return (1350000UL / val);
150 }
151
152 static inline u16 FAN_TO_REG(long rpm)
153 {
154 if (rpm <= 0)
155 return 0x0fff;
156 return SENSORS_LIMIT((1350000 + (rpm >> 1)) / rpm, 1, 0xffe);
157 }
158
159 static inline unsigned long TIME_FROM_REG(u8 reg)
160 {
161 return (reg * 100);
162 }
163
164 static inline u8 TIME_TO_REG(unsigned long val)
165 {
166 return SENSORS_LIMIT((val + 50) / 100, 0, 0xff);
167 }
168
169 static inline long TEMP_FROM_REG(s8 reg)
170 {
171 return (reg * 1000);
172 }
173
174 static inline s8 TEMP_TO_REG(long val, s8 min, s8 max)
175 {
176 return SENSORS_LIMIT((val + (val < 0 ? -500 : 500)) / 1000, min, max);
177 }
178
179 struct w83793_data {
180 struct i2c_client client;
181 struct i2c_client *lm75[2];
182 struct class_device *class_dev;
183 struct mutex update_lock;
184 char valid; /* !=0 if following fields are valid */
185 unsigned long last_updated; /* In jiffies */
186 unsigned long last_nonvolatile; /* In jiffies, last time we update the
187 nonvolatile registers */
188
189 u8 bank;
190 u8 vrm;
191 u8 vid[2];
192 u8 in[10][3]; /* Register value, read/high/low */
193 u8 in_low_bits[3]; /* Additional resolution for VCore A/B Vtt */
194
195 u16 has_fan; /* Only fan1- fan5 has own pins */
196 u16 fan[12]; /* Register value combine */
197 u16 fan_min[12]; /* Register value combine */
198
199 s8 temp[6][5]; /* current, crit, crit_hyst,warn, warn_hyst */
200 u8 temp_low_bits; /* Additional resolution TD1-TD4 */
201 u8 temp_mode[2]; /* byte 0: Temp D1-D4 mode each has 2 bits
202 byte 1: Temp R1,R2 mode, each has 1 bit */
203 u8 temp_critical; /* If reached all fan will be at full speed */
204 u8 temp_fan_map[6]; /* Temp controls which pwm fan, bit field */
205
206 u8 has_pwm;
207 u8 has_temp;
208 u8 has_vid;
209 u8 pwm_enable; /* Register value, each Temp has 1 bit */
210 u8 pwm_uptime; /* Register value */
211 u8 pwm_downtime; /* Register value */
212 u8 pwm_default; /* All fan default pwm, next poweron valid */
213 u8 pwm[8][3]; /* Register value */
214 u8 pwm_stop_time[8];
215 u8 temp_cruise[6];
216
217 u8 alarms[5]; /* realtime status registers */
218 u8 beeps[5];
219 u8 beep_enable;
220 u8 tolerance[3]; /* Temp tolerance(Smart Fan I/II) */
221 u8 sf2_pwm[6][7]; /* Smart FanII: Fan duty cycle */
222 u8 sf2_temp[6][7]; /* Smart FanII: Temp level point */
223 };
224
225 static u8 w83793_read_value(struct i2c_client *client, u16 reg);
226 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value);
227 static int w83793_attach_adapter(struct i2c_adapter *adapter);
228 static int w83793_detect(struct i2c_adapter *adapter, int address, int kind);
229 static int w83793_detach_client(struct i2c_client *client);
230 static void w83793_init_client(struct i2c_client *client);
231 static void w83793_update_nonvolatile(struct device *dev);
232 static struct w83793_data *w83793_update_device(struct device *dev);
233
234 static struct i2c_driver w83793_driver = {
235 .driver = {
236 .name = "w83793",
237 },
238 .attach_adapter = w83793_attach_adapter,
239 .detach_client = w83793_detach_client,
240 };
241
242 static ssize_t
243 show_vrm(struct device *dev, struct device_attribute *attr, char *buf)
244 {
245 struct i2c_client *client = to_i2c_client(dev);
246 struct w83793_data *data = i2c_get_clientdata(client);
247
248 return sprintf(buf, "%d\n", data->vrm);
249 }
250
251 static ssize_t
252 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
253 {
254 struct w83793_data *data = w83793_update_device(dev);
255 struct sensor_device_attribute_2 *sensor_attr =
256 to_sensor_dev_attr_2(attr);
257 int index = sensor_attr->index;
258
259 return sprintf(buf, "%d\n", vid_from_reg(data->vid[index], data->vrm));
260 }
261
262 static ssize_t
263 store_vrm(struct device *dev, struct device_attribute *attr,
264 const char *buf, size_t count)
265 {
266 struct i2c_client *client = to_i2c_client(dev);
267 struct w83793_data *data = i2c_get_clientdata(client);
268
269 data->vrm = simple_strtoul(buf, NULL, 10);
270 return count;
271 }
272
273 #define ALARM_STATUS 0
274 #define BEEP_ENABLE 1
275 static ssize_t
276 show_alarm_beep(struct device *dev, struct device_attribute *attr, char *buf)
277 {
278 struct w83793_data *data = w83793_update_device(dev);
279 struct sensor_device_attribute_2 *sensor_attr =
280 to_sensor_dev_attr_2(attr);
281 int nr = sensor_attr->nr;
282 int index = sensor_attr->index >> 3;
283 int bit = sensor_attr->index & 0x07;
284 u8 val;
285
286 if (ALARM_STATUS == nr) {
287 val = (data->alarms[index] >> (bit)) & 1;
288 } else { /* BEEP_ENABLE */
289 val = (data->beeps[index] >> (bit)) & 1;
290 }
291
292 return sprintf(buf, "%u\n", val);
293 }
294
295 static ssize_t
296 store_beep(struct device *dev, struct device_attribute *attr,
297 const char *buf, size_t count)
298 {
299 struct i2c_client *client = to_i2c_client(dev);
300 struct w83793_data *data = i2c_get_clientdata(client);
301 struct sensor_device_attribute_2 *sensor_attr =
302 to_sensor_dev_attr_2(attr);
303 int index = sensor_attr->index >> 3;
304 int shift = sensor_attr->index & 0x07;
305 u8 beep_bit = 1 << shift;
306 u8 val;
307
308 val = simple_strtoul(buf, NULL, 10);
309 if (val != 0 && val != 1)
310 return -EINVAL;
311
312 mutex_lock(&data->update_lock);
313 data->beeps[index] = w83793_read_value(client, W83793_REG_BEEP(index));
314 data->beeps[index] &= ~beep_bit;
315 data->beeps[index] |= val << shift;
316 w83793_write_value(client, W83793_REG_BEEP(index), data->beeps[index]);
317 mutex_unlock(&data->update_lock);
318
319 return count;
320 }
321
322 static ssize_t
323 show_beep_enable(struct device *dev, struct device_attribute *attr, char *buf)
324 {
325 struct w83793_data *data = w83793_update_device(dev);
326 return sprintf(buf, "%u\n", (data->beep_enable >> 1) & 0x01);
327 }
328
329 static ssize_t
330 store_beep_enable(struct device *dev, struct device_attribute *attr,
331 const char *buf, size_t count)
332 {
333 struct i2c_client *client = to_i2c_client(dev);
334 struct w83793_data *data = i2c_get_clientdata(client);
335 u8 val = simple_strtoul(buf, NULL, 10);
336
337 if (val != 0 && val != 1)
338 return -EINVAL;
339
340 mutex_lock(&data->update_lock);
341 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP)
342 & 0xfd;
343 data->beep_enable |= val << 1;
344 w83793_write_value(client, W83793_REG_OVT_BEEP, data->beep_enable);
345 mutex_unlock(&data->update_lock);
346
347 return count;
348 }
349
350 /* Write any value to clear chassis alarm */
351 static ssize_t
352 store_chassis_clear(struct device *dev,
353 struct device_attribute *attr, const char *buf,
354 size_t count)
355 {
356 struct i2c_client *client = to_i2c_client(dev);
357 struct w83793_data *data = i2c_get_clientdata(client);
358 u8 val;
359
360 mutex_lock(&data->update_lock);
361 val = w83793_read_value(client, W83793_REG_CLR_CHASSIS);
362 val |= 0x80;
363 w83793_write_value(client, W83793_REG_CLR_CHASSIS, val);
364 mutex_unlock(&data->update_lock);
365 return count;
366 }
367
368 #define FAN_INPUT 0
369 #define FAN_MIN 1
370 static ssize_t
371 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
372 {
373 struct sensor_device_attribute_2 *sensor_attr =
374 to_sensor_dev_attr_2(attr);
375 int nr = sensor_attr->nr;
376 int index = sensor_attr->index;
377 struct w83793_data *data = w83793_update_device(dev);
378 u16 val;
379
380 if (FAN_INPUT == nr) {
381 val = data->fan[index] & 0x0fff;
382 } else {
383 val = data->fan_min[index] & 0x0fff;
384 }
385
386 return sprintf(buf, "%lu\n", FAN_FROM_REG(val));
387 }
388
389 static ssize_t
390 store_fan_min(struct device *dev, struct device_attribute *attr,
391 const char *buf, size_t count)
392 {
393 struct sensor_device_attribute_2 *sensor_attr =
394 to_sensor_dev_attr_2(attr);
395 int index = sensor_attr->index;
396 struct i2c_client *client = to_i2c_client(dev);
397 struct w83793_data *data = i2c_get_clientdata(client);
398 u16 val = FAN_TO_REG(simple_strtoul(buf, NULL, 10));
399
400 mutex_lock(&data->update_lock);
401 data->fan_min[index] = val;
402 w83793_write_value(client, W83793_REG_FAN_MIN(index),
403 (val >> 8) & 0xff);
404 w83793_write_value(client, W83793_REG_FAN_MIN(index) + 1, val & 0xff);
405 mutex_unlock(&data->update_lock);
406
407 return count;
408 }
409
410 #define PWM_DUTY 0
411 #define PWM_START 1
412 #define PWM_NONSTOP 2
413 #define PWM_STOP_TIME 3
414 static ssize_t
415 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
416 {
417 struct sensor_device_attribute_2 *sensor_attr =
418 to_sensor_dev_attr_2(attr);
419 struct w83793_data *data = w83793_update_device(dev);
420 u16 val;
421 int nr = sensor_attr->nr;
422 int index = sensor_attr->index;
423
424 if (PWM_STOP_TIME == nr)
425 val = TIME_FROM_REG(data->pwm_stop_time[index]);
426 else
427 val = (data->pwm[index][nr] & 0x3f) << 2;
428
429 return sprintf(buf, "%d\n", val);
430 }
431
432 static ssize_t
433 store_pwm(struct device *dev, struct device_attribute *attr,
434 const char *buf, size_t count)
435 {
436 struct i2c_client *client = to_i2c_client(dev);
437 struct w83793_data *data = i2c_get_clientdata(client);
438 struct sensor_device_attribute_2 *sensor_attr =
439 to_sensor_dev_attr_2(attr);
440 int nr = sensor_attr->nr;
441 int index = sensor_attr->index;
442 u8 val;
443
444 mutex_lock(&data->update_lock);
445 if (PWM_STOP_TIME == nr) {
446 val = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
447 data->pwm_stop_time[index] = val;
448 w83793_write_value(client, W83793_REG_PWM_STOP_TIME(index),
449 val);
450 } else {
451 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff)
452 >> 2;
453 data->pwm[index][nr] =
454 w83793_read_value(client, W83793_REG_PWM(index, nr)) & 0xc0;
455 data->pwm[index][nr] |= val;
456 w83793_write_value(client, W83793_REG_PWM(index, nr),
457 data->pwm[index][nr]);
458 }
459
460 mutex_unlock(&data->update_lock);
461 return count;
462 }
463
464 static ssize_t
465 show_temp(struct device *dev, struct device_attribute *attr, char *buf)
466 {
467 struct sensor_device_attribute_2 *sensor_attr =
468 to_sensor_dev_attr_2(attr);
469 int nr = sensor_attr->nr;
470 int index = sensor_attr->index;
471 struct w83793_data *data = w83793_update_device(dev);
472 long temp = TEMP_FROM_REG(data->temp[index][nr]);
473
474 if (TEMP_READ == nr && index < 4) { /* Only TD1-TD4 have low bits */
475 int low = ((data->temp_low_bits >> (index * 2)) & 0x03) * 250;
476 temp += temp > 0 ? low : -low;
477 }
478 return sprintf(buf, "%ld\n", temp);
479 }
480
481 static ssize_t
482 store_temp(struct device *dev, struct device_attribute *attr,
483 const char *buf, size_t count)
484 {
485 struct sensor_device_attribute_2 *sensor_attr =
486 to_sensor_dev_attr_2(attr);
487 int nr = sensor_attr->nr;
488 int index = sensor_attr->index;
489 struct i2c_client *client = to_i2c_client(dev);
490 struct w83793_data *data = i2c_get_clientdata(client);
491 long tmp = simple_strtol(buf, NULL, 10);
492
493 mutex_lock(&data->update_lock);
494 data->temp[index][nr] = TEMP_TO_REG(tmp, -128, 127);
495 w83793_write_value(client, W83793_REG_TEMP[index][nr],
496 data->temp[index][nr]);
497 mutex_unlock(&data->update_lock);
498 return count;
499 }
500
501 /*
502 TD1-TD4
503 each has 4 mode:(2 bits)
504 0: Stop monitor
505 1: Use internal temp sensor(default)
506 2: Reserved
507 3: Use sensor in Intel CPU and get result by PECI
508
509 TR1-TR2
510 each has 2 mode:(1 bit)
511 0: Disable temp sensor monitor
512 1: To enable temp sensors monitor
513 */
514
515 /* 0 disable, 6 PECI */
516 static u8 TO_TEMP_MODE[] = { 0, 0, 0, 6 };
517
518 static ssize_t
519 show_temp_mode(struct device *dev, struct device_attribute *attr, char *buf)
520 {
521 struct w83793_data *data = w83793_update_device(dev);
522 struct sensor_device_attribute_2 *sensor_attr =
523 to_sensor_dev_attr_2(attr);
524 int index = sensor_attr->index;
525 u8 mask = (index < 4) ? 0x03 : 0x01;
526 u8 shift = (index < 4) ? (2 * index) : (index - 4);
527 u8 tmp;
528 index = (index < 4) ? 0 : 1;
529
530 tmp = (data->temp_mode[index] >> shift) & mask;
531
532 /* for the internal sensor, found out if diode or thermistor */
533 if (tmp == 1) {
534 tmp = index == 0 ? 3 : 4;
535 } else {
536 tmp = TO_TEMP_MODE[tmp];
537 }
538
539 return sprintf(buf, "%d\n", tmp);
540 }
541
542 static ssize_t
543 store_temp_mode(struct device *dev, struct device_attribute *attr,
544 const char *buf, size_t count)
545 {
546 struct i2c_client *client = to_i2c_client(dev);
547 struct w83793_data *data = i2c_get_clientdata(client);
548 struct sensor_device_attribute_2 *sensor_attr =
549 to_sensor_dev_attr_2(attr);
550 int index = sensor_attr->index;
551 u8 mask = (index < 4) ? 0x03 : 0x01;
552 u8 shift = (index < 4) ? (2 * index) : (index - 4);
553 u8 val = simple_strtoul(buf, NULL, 10);
554
555 /* transform the sysfs interface values into table above */
556 if ((val == 6) && (index < 4)) {
557 val -= 3;
558 } else if ((val == 3 && index < 4)
559 || (val == 4 && index >= 4)) {
560 /* transform diode or thermistor into internal enable */
561 val = !!val;
562 } else {
563 return -EINVAL;
564 }
565
566 index = (index < 4) ? 0 : 1;
567 mutex_lock(&data->update_lock);
568 data->temp_mode[index] =
569 w83793_read_value(client, W83793_REG_TEMP_MODE[index]);
570 data->temp_mode[index] &= ~(mask << shift);
571 data->temp_mode[index] |= val << shift;
572 w83793_write_value(client, W83793_REG_TEMP_MODE[index],
573 data->temp_mode[index]);
574 mutex_unlock(&data->update_lock);
575
576 return count;
577 }
578
579 #define SETUP_PWM_DEFAULT 0
580 #define SETUP_PWM_UPTIME 1 /* Unit in 0.1s */
581 #define SETUP_PWM_DOWNTIME 2 /* Unit in 0.1s */
582 #define SETUP_TEMP_CRITICAL 3
583 static ssize_t
584 show_sf_setup(struct device *dev, struct device_attribute *attr, char *buf)
585 {
586 struct sensor_device_attribute_2 *sensor_attr =
587 to_sensor_dev_attr_2(attr);
588 int nr = sensor_attr->nr;
589 struct w83793_data *data = w83793_update_device(dev);
590 u32 val = 0;
591
592 if (SETUP_PWM_DEFAULT == nr) {
593 val = (data->pwm_default & 0x3f) << 2;
594 } else if (SETUP_PWM_UPTIME == nr) {
595 val = TIME_FROM_REG(data->pwm_uptime);
596 } else if (SETUP_PWM_DOWNTIME == nr) {
597 val = TIME_FROM_REG(data->pwm_downtime);
598 } else if (SETUP_TEMP_CRITICAL == nr) {
599 val = TEMP_FROM_REG(data->temp_critical & 0x7f);
600 }
601
602 return sprintf(buf, "%d\n", val);
603 }
604
605 static ssize_t
606 store_sf_setup(struct device *dev, struct device_attribute *attr,
607 const char *buf, size_t count)
608 {
609 struct sensor_device_attribute_2 *sensor_attr =
610 to_sensor_dev_attr_2(attr);
611 int nr = sensor_attr->nr;
612 struct i2c_client *client = to_i2c_client(dev);
613 struct w83793_data *data = i2c_get_clientdata(client);
614
615 mutex_lock(&data->update_lock);
616 if (SETUP_PWM_DEFAULT == nr) {
617 data->pwm_default =
618 w83793_read_value(client, W83793_REG_PWM_DEFAULT) & 0xc0;
619 data->pwm_default |= SENSORS_LIMIT(simple_strtoul(buf, NULL,
620 10),
621 0, 0xff) >> 2;
622 w83793_write_value(client, W83793_REG_PWM_DEFAULT,
623 data->pwm_default);
624 } else if (SETUP_PWM_UPTIME == nr) {
625 data->pwm_uptime = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
626 data->pwm_uptime += data->pwm_uptime == 0 ? 1 : 0;
627 w83793_write_value(client, W83793_REG_PWM_UPTIME,
628 data->pwm_uptime);
629 } else if (SETUP_PWM_DOWNTIME == nr) {
630 data->pwm_downtime = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
631 data->pwm_downtime += data->pwm_downtime == 0 ? 1 : 0;
632 w83793_write_value(client, W83793_REG_PWM_DOWNTIME,
633 data->pwm_downtime);
634 } else { /* SETUP_TEMP_CRITICAL */
635 data->temp_critical =
636 w83793_read_value(client, W83793_REG_TEMP_CRITICAL) & 0x80;
637 data->temp_critical |= TEMP_TO_REG(simple_strtol(buf, NULL, 10),
638 0, 0x7f);
639 w83793_write_value(client, W83793_REG_TEMP_CRITICAL,
640 data->temp_critical);
641 }
642
643 mutex_unlock(&data->update_lock);
644 return count;
645 }
646
647 /*
648 Temp SmartFan control
649 TEMP_FAN_MAP
650 Temp channel control which pwm fan, bitfield, bit 0 indicate pwm1...
651 It's possible two or more temp channels control the same fan, w83793
652 always prefers to pick the most critical request and applies it to
653 the related Fan.
654 It's possible one fan is not in any mapping of 6 temp channels, this
655 means the fan is manual mode
656
657 TEMP_PWM_ENABLE
658 Each temp channel has its own SmartFan mode, and temp channel
659 control fans that are set by TEMP_FAN_MAP
660 0: SmartFanII mode
661 1: Thermal Cruise Mode
662
663 TEMP_CRUISE
664 Target temperature in thermal cruise mode, w83793 will try to turn
665 fan speed to keep the temperature of target device around this
666 temperature.
667
668 TEMP_TOLERANCE
669 If Temp higher or lower than target with this tolerance, w83793
670 will take actions to speed up or slow down the fan to keep the
671 temperature within the tolerance range.
672 */
673
674 #define TEMP_FAN_MAP 0
675 #define TEMP_PWM_ENABLE 1
676 #define TEMP_CRUISE 2
677 #define TEMP_TOLERANCE 3
678 static ssize_t
679 show_sf_ctrl(struct device *dev, struct device_attribute *attr, char *buf)
680 {
681 struct sensor_device_attribute_2 *sensor_attr =
682 to_sensor_dev_attr_2(attr);
683 int nr = sensor_attr->nr;
684 int index = sensor_attr->index;
685 struct w83793_data *data = w83793_update_device(dev);
686 u32 val;
687
688 if (TEMP_FAN_MAP == nr) {
689 val = data->temp_fan_map[index];
690 } else if (TEMP_PWM_ENABLE == nr) {
691 /* +2 to transfrom into 2 and 3 to conform with sysfs intf */
692 val = ((data->pwm_enable >> index) & 0x01) + 2;
693 } else if (TEMP_CRUISE == nr) {
694 val = TEMP_FROM_REG(data->temp_cruise[index] & 0x7f);
695 } else { /* TEMP_TOLERANCE */
696 val = data->tolerance[index >> 1] >> ((index & 0x01) ? 4 : 0);
697 val = TEMP_FROM_REG(val & 0x0f);
698 }
699 return sprintf(buf, "%d\n", val);
700 }
701
702 static ssize_t
703 store_sf_ctrl(struct device *dev, struct device_attribute *attr,
704 const char *buf, size_t count)
705 {
706 struct sensor_device_attribute_2 *sensor_attr =
707 to_sensor_dev_attr_2(attr);
708 int nr = sensor_attr->nr;
709 int index = sensor_attr->index;
710 struct i2c_client *client = to_i2c_client(dev);
711 struct w83793_data *data = i2c_get_clientdata(client);
712 u32 val;
713
714 mutex_lock(&data->update_lock);
715 if (TEMP_FAN_MAP == nr) {
716 val = simple_strtoul(buf, NULL, 10) & 0xff;
717 w83793_write_value(client, W83793_REG_TEMP_FAN_MAP(index), val);
718 data->temp_fan_map[index] = val;
719 } else if (TEMP_PWM_ENABLE == nr) {
720 val = simple_strtoul(buf, NULL, 10);
721 if (2 == val || 3 == val) {
722 data->pwm_enable =
723 w83793_read_value(client, W83793_REG_PWM_ENABLE);
724 if (val - 2)
725 data->pwm_enable |= 1 << index;
726 else
727 data->pwm_enable &= ~(1 << index);
728 w83793_write_value(client, W83793_REG_PWM_ENABLE,
729 data->pwm_enable);
730 } else {
731 mutex_unlock(&data->update_lock);
732 return -EINVAL;
733 }
734 } else if (TEMP_CRUISE == nr) {
735 data->temp_cruise[index] =
736 w83793_read_value(client, W83793_REG_TEMP_CRUISE(index));
737 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f);
738 data->temp_cruise[index] &= 0x80;
739 data->temp_cruise[index] |= val;
740
741 w83793_write_value(client, W83793_REG_TEMP_CRUISE(index),
742 data->temp_cruise[index]);
743 } else { /* TEMP_TOLERANCE */
744 int i = index >> 1;
745 u8 shift = (index & 0x01) ? 4 : 0;
746 data->tolerance[i] =
747 w83793_read_value(client, W83793_REG_TEMP_TOL(i));
748
749 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x0f);
750 data->tolerance[i] &= ~(0x0f << shift);
751 data->tolerance[i] |= val << shift;
752 w83793_write_value(client, W83793_REG_TEMP_TOL(i),
753 data->tolerance[i]);
754 }
755
756 mutex_unlock(&data->update_lock);
757 return count;
758 }
759
760 static ssize_t
761 show_sf2_pwm(struct device *dev, struct device_attribute *attr, char *buf)
762 {
763 struct sensor_device_attribute_2 *sensor_attr =
764 to_sensor_dev_attr_2(attr);
765 int nr = sensor_attr->nr;
766 int index = sensor_attr->index;
767 struct w83793_data *data = w83793_update_device(dev);
768
769 return sprintf(buf, "%d\n", (data->sf2_pwm[index][nr] & 0x3f) << 2);
770 }
771
772 static ssize_t
773 store_sf2_pwm(struct device *dev, struct device_attribute *attr,
774 const char *buf, size_t count)
775 {
776 struct i2c_client *client = to_i2c_client(dev);
777 struct w83793_data *data = i2c_get_clientdata(client);
778 struct sensor_device_attribute_2 *sensor_attr =
779 to_sensor_dev_attr_2(attr);
780 int nr = sensor_attr->nr;
781 int index = sensor_attr->index;
782 u8 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff) >> 2;
783
784 mutex_lock(&data->update_lock);
785 data->sf2_pwm[index][nr] =
786 w83793_read_value(client, W83793_REG_SF2_PWM(index, nr)) & 0xc0;
787 data->sf2_pwm[index][nr] |= val;
788 w83793_write_value(client, W83793_REG_SF2_PWM(index, nr),
789 data->sf2_pwm[index][nr]);
790 mutex_unlock(&data->update_lock);
791 return count;
792 }
793
794 static ssize_t
795 show_sf2_temp(struct device *dev, struct device_attribute *attr, char *buf)
796 {
797 struct sensor_device_attribute_2 *sensor_attr =
798 to_sensor_dev_attr_2(attr);
799 int nr = sensor_attr->nr;
800 int index = sensor_attr->index;
801 struct w83793_data *data = w83793_update_device(dev);
802
803 return sprintf(buf, "%ld\n",
804 TEMP_FROM_REG(data->sf2_temp[index][nr] & 0x7f));
805 }
806
807 static ssize_t
808 store_sf2_temp(struct device *dev, struct device_attribute *attr,
809 const char *buf, size_t count)
810 {
811 struct i2c_client *client = to_i2c_client(dev);
812 struct w83793_data *data = i2c_get_clientdata(client);
813 struct sensor_device_attribute_2 *sensor_attr =
814 to_sensor_dev_attr_2(attr);
815 int nr = sensor_attr->nr;
816 int index = sensor_attr->index;
817 u8 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f);
818
819 mutex_lock(&data->update_lock);
820 data->sf2_temp[index][nr] =
821 w83793_read_value(client, W83793_REG_SF2_TEMP(index, nr)) & 0x80;
822 data->sf2_temp[index][nr] |= val;
823 w83793_write_value(client, W83793_REG_SF2_TEMP(index, nr),
824 data->sf2_temp[index][nr]);
825 mutex_unlock(&data->update_lock);
826 return count;
827 }
828
829 /* only Vcore A/B and Vtt have additional 2 bits precision */
830 static ssize_t
831 show_in(struct device *dev, struct device_attribute *attr, char *buf)
832 {
833 struct sensor_device_attribute_2 *sensor_attr =
834 to_sensor_dev_attr_2(attr);
835 int nr = sensor_attr->nr;
836 int index = sensor_attr->index;
837 struct w83793_data *data = w83793_update_device(dev);
838 u16 val = data->in[index][nr];
839
840 if (index < 3) {
841 val <<= 2;
842 val += (data->in_low_bits[nr] >> (index * 2)) & 0x3;
843 }
844 /* voltage inputs 5VDD and 5VSB needs 150mV offset */
845 val = val * scale_in[index] + scale_in_add[index];
846 return sprintf(buf, "%d\n", val);
847 }
848
849 static ssize_t
850 store_in(struct device *dev, struct device_attribute *attr,
851 const char *buf, size_t count)
852 {
853 struct sensor_device_attribute_2 *sensor_attr =
854 to_sensor_dev_attr_2(attr);
855 int nr = sensor_attr->nr;
856 int index = sensor_attr->index;
857 struct i2c_client *client = to_i2c_client(dev);
858 struct w83793_data *data = i2c_get_clientdata(client);
859 u32 val;
860
861 val =
862 (simple_strtoul(buf, NULL, 10) +
863 scale_in[index] / 2) / scale_in[index];
864 mutex_lock(&data->update_lock);
865 if (index > 2) {
866 /* fix the limit values of 5VDD and 5VSB to ALARM mechanism */
867 if (1 == nr || 2 == nr) {
868 val -= scale_in_add[index] / scale_in[index];
869 }
870 val = SENSORS_LIMIT(val, 0, 255);
871 } else {
872 val = SENSORS_LIMIT(val, 0, 0x3FF);
873 data->in_low_bits[nr] =
874 w83793_read_value(client, W83793_REG_IN_LOW_BITS[nr]);
875 data->in_low_bits[nr] &= ~(0x03 << (2 * index));
876 data->in_low_bits[nr] |= (val & 0x03) << (2 * index);
877 w83793_write_value(client, W83793_REG_IN_LOW_BITS[nr],
878 data->in_low_bits[nr]);
879 val >>= 2;
880 }
881 data->in[index][nr] = val;
882 w83793_write_value(client, W83793_REG_IN[index][nr],
883 data->in[index][nr]);
884 mutex_unlock(&data->update_lock);
885 return count;
886 }
887
888 #define NOT_USED -1
889
890 #define SENSOR_ATTR_IN(index) \
891 SENSOR_ATTR_2(in##index##_input, S_IRUGO, show_in, NULL, \
892 IN_READ, index), \
893 SENSOR_ATTR_2(in##index##_max, S_IRUGO | S_IWUSR, show_in, \
894 store_in, IN_MAX, index), \
895 SENSOR_ATTR_2(in##index##_min, S_IRUGO | S_IWUSR, show_in, \
896 store_in, IN_LOW, index), \
897 SENSOR_ATTR_2(in##index##_alarm, S_IRUGO, show_alarm_beep, \
898 NULL, ALARM_STATUS, index + ((index > 2) ? 1 : 0)), \
899 SENSOR_ATTR_2(in##index##_beep, S_IWUSR | S_IRUGO, \
900 show_alarm_beep, store_beep, BEEP_ENABLE, \
901 index + ((index > 2) ? 1 : 0))
902
903 #define SENSOR_ATTR_FAN(index) \
904 SENSOR_ATTR_2(fan##index##_alarm, S_IRUGO, show_alarm_beep, \
905 NULL, ALARM_STATUS, index + 17), \
906 SENSOR_ATTR_2(fan##index##_beep, S_IWUSR | S_IRUGO, \
907 show_alarm_beep, store_beep, BEEP_ENABLE, index + 17), \
908 SENSOR_ATTR_2(fan##index##_input, S_IRUGO, show_fan, \
909 NULL, FAN_INPUT, index - 1), \
910 SENSOR_ATTR_2(fan##index##_min, S_IWUSR | S_IRUGO, \
911 show_fan, store_fan_min, FAN_MIN, index - 1)
912
913 #define SENSOR_ATTR_PWM(index) \
914 SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm, \
915 store_pwm, PWM_DUTY, index - 1), \
916 SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO, \
917 show_pwm, store_pwm, PWM_NONSTOP, index - 1), \
918 SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO, \
919 show_pwm, store_pwm, PWM_START, index - 1), \
920 SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO, \
921 show_pwm, store_pwm, PWM_STOP_TIME, index - 1)
922
923 #define SENSOR_ATTR_TEMP(index) \
924 SENSOR_ATTR_2(temp##index##_type, S_IRUGO | S_IWUSR, \
925 show_temp_mode, store_temp_mode, NOT_USED, index - 1), \
926 SENSOR_ATTR_2(temp##index##_input, S_IRUGO, show_temp, \
927 NULL, TEMP_READ, index - 1), \
928 SENSOR_ATTR_2(temp##index##_max, S_IRUGO | S_IWUSR, show_temp, \
929 store_temp, TEMP_CRIT, index - 1), \
930 SENSOR_ATTR_2(temp##index##_max_hyst, S_IRUGO | S_IWUSR, \
931 show_temp, store_temp, TEMP_CRIT_HYST, index - 1), \
932 SENSOR_ATTR_2(temp##index##_warn, S_IRUGO | S_IWUSR, show_temp, \
933 store_temp, TEMP_WARN, index - 1), \
934 SENSOR_ATTR_2(temp##index##_warn_hyst, S_IRUGO | S_IWUSR, \
935 show_temp, store_temp, TEMP_WARN_HYST, index - 1), \
936 SENSOR_ATTR_2(temp##index##_alarm, S_IRUGO, \
937 show_alarm_beep, NULL, ALARM_STATUS, index + 11), \
938 SENSOR_ATTR_2(temp##index##_beep, S_IWUSR | S_IRUGO, \
939 show_alarm_beep, store_beep, BEEP_ENABLE, index + 11), \
940 SENSOR_ATTR_2(temp##index##_auto_channels_pwm, \
941 S_IRUGO | S_IWUSR, show_sf_ctrl, store_sf_ctrl, \
942 TEMP_FAN_MAP, index - 1), \
943 SENSOR_ATTR_2(temp##index##_pwm_enable, S_IWUSR | S_IRUGO, \
944 show_sf_ctrl, store_sf_ctrl, TEMP_PWM_ENABLE, \
945 index - 1), \
946 SENSOR_ATTR_2(thermal_cruise##index, S_IRUGO | S_IWUSR, \
947 show_sf_ctrl, store_sf_ctrl, TEMP_CRUISE, index - 1), \
948 SENSOR_ATTR_2(tolerance##index, S_IRUGO | S_IWUSR, show_sf_ctrl,\
949 store_sf_ctrl, TEMP_TOLERANCE, index - 1), \
950 SENSOR_ATTR_2(temp##index##_auto_point1_pwm, S_IRUGO | S_IWUSR, \
951 show_sf2_pwm, store_sf2_pwm, 0, index - 1), \
952 SENSOR_ATTR_2(temp##index##_auto_point2_pwm, S_IRUGO | S_IWUSR, \
953 show_sf2_pwm, store_sf2_pwm, 1, index - 1), \
954 SENSOR_ATTR_2(temp##index##_auto_point3_pwm, S_IRUGO | S_IWUSR, \
955 show_sf2_pwm, store_sf2_pwm, 2, index - 1), \
956 SENSOR_ATTR_2(temp##index##_auto_point4_pwm, S_IRUGO | S_IWUSR, \
957 show_sf2_pwm, store_sf2_pwm, 3, index - 1), \
958 SENSOR_ATTR_2(temp##index##_auto_point5_pwm, S_IRUGO | S_IWUSR, \
959 show_sf2_pwm, store_sf2_pwm, 4, index - 1), \
960 SENSOR_ATTR_2(temp##index##_auto_point6_pwm, S_IRUGO | S_IWUSR, \
961 show_sf2_pwm, store_sf2_pwm, 5, index - 1), \
962 SENSOR_ATTR_2(temp##index##_auto_point7_pwm, S_IRUGO | S_IWUSR, \
963 show_sf2_pwm, store_sf2_pwm, 6, index - 1), \
964 SENSOR_ATTR_2(temp##index##_auto_point1_temp, S_IRUGO | S_IWUSR,\
965 show_sf2_temp, store_sf2_temp, 0, index - 1), \
966 SENSOR_ATTR_2(temp##index##_auto_point2_temp, S_IRUGO | S_IWUSR,\
967 show_sf2_temp, store_sf2_temp, 1, index - 1), \
968 SENSOR_ATTR_2(temp##index##_auto_point3_temp, S_IRUGO | S_IWUSR,\
969 show_sf2_temp, store_sf2_temp, 2, index - 1), \
970 SENSOR_ATTR_2(temp##index##_auto_point4_temp, S_IRUGO | S_IWUSR,\
971 show_sf2_temp, store_sf2_temp, 3, index - 1), \
972 SENSOR_ATTR_2(temp##index##_auto_point5_temp, S_IRUGO | S_IWUSR,\
973 show_sf2_temp, store_sf2_temp, 4, index - 1), \
974 SENSOR_ATTR_2(temp##index##_auto_point6_temp, S_IRUGO | S_IWUSR,\
975 show_sf2_temp, store_sf2_temp, 5, index - 1), \
976 SENSOR_ATTR_2(temp##index##_auto_point7_temp, S_IRUGO | S_IWUSR,\
977 show_sf2_temp, store_sf2_temp, 6, index - 1)
978
979 static struct sensor_device_attribute_2 w83793_sensor_attr_2[] = {
980 SENSOR_ATTR_IN(0),
981 SENSOR_ATTR_IN(1),
982 SENSOR_ATTR_IN(2),
983 SENSOR_ATTR_IN(3),
984 SENSOR_ATTR_IN(4),
985 SENSOR_ATTR_IN(5),
986 SENSOR_ATTR_IN(6),
987 SENSOR_ATTR_IN(7),
988 SENSOR_ATTR_IN(8),
989 SENSOR_ATTR_IN(9),
990 SENSOR_ATTR_FAN(1),
991 SENSOR_ATTR_FAN(2),
992 SENSOR_ATTR_FAN(3),
993 SENSOR_ATTR_FAN(4),
994 SENSOR_ATTR_FAN(5),
995 SENSOR_ATTR_PWM(1),
996 SENSOR_ATTR_PWM(2),
997 SENSOR_ATTR_PWM(3),
998 };
999
1000 static struct sensor_device_attribute_2 w83793_temp[] = {
1001 SENSOR_ATTR_TEMP(1),
1002 SENSOR_ATTR_TEMP(2),
1003 SENSOR_ATTR_TEMP(3),
1004 SENSOR_ATTR_TEMP(4),
1005 SENSOR_ATTR_TEMP(5),
1006 SENSOR_ATTR_TEMP(6),
1007 };
1008
1009 /* Fan6-Fan12 */
1010 static struct sensor_device_attribute_2 w83793_left_fan[] = {
1011 SENSOR_ATTR_FAN(6),
1012 SENSOR_ATTR_FAN(7),
1013 SENSOR_ATTR_FAN(8),
1014 SENSOR_ATTR_FAN(9),
1015 SENSOR_ATTR_FAN(10),
1016 SENSOR_ATTR_FAN(11),
1017 SENSOR_ATTR_FAN(12),
1018 };
1019
1020 /* Pwm4-Pwm8 */
1021 static struct sensor_device_attribute_2 w83793_left_pwm[] = {
1022 SENSOR_ATTR_PWM(4),
1023 SENSOR_ATTR_PWM(5),
1024 SENSOR_ATTR_PWM(6),
1025 SENSOR_ATTR_PWM(7),
1026 SENSOR_ATTR_PWM(8),
1027 };
1028
1029 static struct sensor_device_attribute_2 w83793_vid[] = {
1030 SENSOR_ATTR_2(cpu0_vid, S_IRUGO, show_vid, NULL, NOT_USED, 0),
1031 SENSOR_ATTR_2(cpu1_vid, S_IRUGO, show_vid, NULL, NOT_USED, 1),
1032 };
1033
1034 static struct sensor_device_attribute_2 sda_single_files[] = {
1035 SENSOR_ATTR_2(vrm, S_IWUSR | S_IRUGO, show_vrm, store_vrm,
1036 NOT_USED, NOT_USED),
1037 SENSOR_ATTR_2(chassis, S_IWUSR | S_IRUGO, show_alarm_beep,
1038 store_chassis_clear, ALARM_STATUS, 30),
1039 SENSOR_ATTR_2(beep_enable, S_IWUSR | S_IRUGO, show_beep_enable,
1040 store_beep_enable, NOT_USED, NOT_USED),
1041 SENSOR_ATTR_2(pwm_default, S_IWUSR | S_IRUGO, show_sf_setup,
1042 store_sf_setup, SETUP_PWM_DEFAULT, NOT_USED),
1043 SENSOR_ATTR_2(pwm_uptime, S_IWUSR | S_IRUGO, show_sf_setup,
1044 store_sf_setup, SETUP_PWM_UPTIME, NOT_USED),
1045 SENSOR_ATTR_2(pwm_downtime, S_IWUSR | S_IRUGO, show_sf_setup,
1046 store_sf_setup, SETUP_PWM_DOWNTIME, NOT_USED),
1047 SENSOR_ATTR_2(temp_critical, S_IWUSR | S_IRUGO, show_sf_setup,
1048 store_sf_setup, SETUP_TEMP_CRITICAL, NOT_USED),
1049 };
1050
1051 static void w83793_init_client(struct i2c_client *client)
1052 {
1053 if (reset) {
1054 w83793_write_value(client, W83793_REG_CONFIG, 0x80);
1055 }
1056
1057 /* Start monitoring */
1058 w83793_write_value(client, W83793_REG_CONFIG,
1059 w83793_read_value(client, W83793_REG_CONFIG) | 0x01);
1060
1061 }
1062
1063 static int w83793_attach_adapter(struct i2c_adapter *adapter)
1064 {
1065 if (!(adapter->class & I2C_CLASS_HWMON))
1066 return 0;
1067 return i2c_probe(adapter, &addr_data, w83793_detect);
1068 }
1069
1070 static int w83793_detach_client(struct i2c_client *client)
1071 {
1072 struct w83793_data *data = i2c_get_clientdata(client);
1073 struct device *dev = &client->dev;
1074 int err, i;
1075
1076 /* main client */
1077 if (data) {
1078 hwmon_device_unregister(data->class_dev);
1079
1080 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1081 device_remove_file(dev,
1082 &w83793_sensor_attr_2[i].dev_attr);
1083
1084 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1085 device_remove_file(dev, &sda_single_files[i].dev_attr);
1086
1087 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1088 device_remove_file(dev, &w83793_vid[i].dev_attr);
1089
1090 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1091 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1092
1093 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1094 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1095
1096 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1097 device_remove_file(dev, &w83793_temp[i].dev_attr);
1098 }
1099
1100 if ((err = i2c_detach_client(client)))
1101 return err;
1102
1103 /* main client */
1104 if (data)
1105 kfree(data);
1106 /* subclient */
1107 else
1108 kfree(client);
1109
1110 return 0;
1111 }
1112
1113 static int
1114 w83793_create_subclient(struct i2c_adapter *adapter,
1115 struct i2c_client *client, int addr,
1116 struct i2c_client **sub_cli)
1117 {
1118 int err = 0;
1119 struct i2c_client *sub_client;
1120
1121 (*sub_cli) = sub_client =
1122 kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1123 if (!(sub_client)) {
1124 return -ENOMEM;
1125 }
1126 sub_client->addr = 0x48 + addr;
1127 i2c_set_clientdata(sub_client, NULL);
1128 sub_client->adapter = adapter;
1129 sub_client->driver = &w83793_driver;
1130 strlcpy(sub_client->name, "w83793 subclient", I2C_NAME_SIZE);
1131 if ((err = i2c_attach_client(sub_client))) {
1132 dev_err(&client->dev, "subclient registration "
1133 "at address 0x%x failed\n", sub_client->addr);
1134 kfree(sub_client);
1135 }
1136 return err;
1137 }
1138
1139 static int
1140 w83793_detect_subclients(struct i2c_adapter *adapter, int address,
1141 int kind, struct i2c_client *client)
1142 {
1143 int i, id, err;
1144 u8 tmp;
1145 struct w83793_data *data = i2c_get_clientdata(client);
1146
1147 id = i2c_adapter_id(adapter);
1148 if (force_subclients[0] == id && force_subclients[1] == address) {
1149 for (i = 2; i <= 3; i++) {
1150 if (force_subclients[i] < 0x48
1151 || force_subclients[i] > 0x4f) {
1152 dev_err(&client->dev,
1153 "invalid subclient "
1154 "address %d; must be 0x48-0x4f\n",
1155 force_subclients[i]);
1156 err = -EINVAL;
1157 goto ERROR_SC_0;
1158 }
1159 }
1160 w83793_write_value(client, W83793_REG_I2C_SUBADDR,
1161 (force_subclients[2] & 0x07) |
1162 ((force_subclients[3] & 0x07) << 4));
1163 }
1164
1165 tmp = w83793_read_value(client, W83793_REG_I2C_SUBADDR);
1166 if (!(tmp & 0x08)) {
1167 err =
1168 w83793_create_subclient(adapter, client, tmp & 0x7,
1169 &data->lm75[0]);
1170 if (err < 0)
1171 goto ERROR_SC_0;
1172 }
1173 if (!(tmp & 0x80)) {
1174 if ((data->lm75[0] != NULL)
1175 && ((tmp & 0x7) == ((tmp >> 4) & 0x7))) {
1176 dev_err(&client->dev,
1177 "duplicate addresses 0x%x, "
1178 "use force_subclients\n", data->lm75[0]->addr);
1179 err = -ENODEV;
1180 goto ERROR_SC_1;
1181 }
1182 err = w83793_create_subclient(adapter, client,
1183 (tmp >> 4) & 0x7, &data->lm75[1]);
1184 if (err < 0)
1185 goto ERROR_SC_1;
1186 }
1187
1188 return 0;
1189
1190 /* Undo inits in case of errors */
1191
1192 ERROR_SC_1:
1193 if (data->lm75[0] != NULL) {
1194 i2c_detach_client(data->lm75[0]);
1195 kfree(data->lm75[0]);
1196 }
1197 ERROR_SC_0:
1198 return err;
1199 }
1200
1201 static int w83793_detect(struct i2c_adapter *adapter, int address, int kind)
1202 {
1203 int i;
1204 u8 tmp, val;
1205 struct i2c_client *client;
1206 struct device *dev;
1207 struct w83793_data *data;
1208 int files_fan = ARRAY_SIZE(w83793_left_fan) / 7;
1209 int files_pwm = ARRAY_SIZE(w83793_left_pwm) / 5;
1210 int files_temp = ARRAY_SIZE(w83793_temp) / 6;
1211 int err = 0;
1212
1213 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1214 goto exit;
1215 }
1216
1217 /* OK. For now, we presume we have a valid client. We now create the
1218 client structure, even though we cannot fill it completely yet.
1219 But it allows us to access w83793_{read,write}_value. */
1220
1221 if (!(data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL))) {
1222 err = -ENOMEM;
1223 goto exit;
1224 }
1225
1226 client = &data->client;
1227 dev = &client->dev;
1228 i2c_set_clientdata(client, data);
1229 client->addr = address;
1230 client->adapter = adapter;
1231 client->driver = &w83793_driver;
1232
1233 data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1234
1235 /* Now, we do the remaining detection. */
1236 if (kind < 0) {
1237 tmp = data->bank & 0x80 ? 0x5c : 0xa3;
1238 /* Check Winbond vendor ID */
1239 if (tmp != i2c_smbus_read_byte_data(client,
1240 W83793_REG_VENDORID)) {
1241 pr_debug("w83793: Detection failed at check "
1242 "vendor id\n");
1243 err = -ENODEV;
1244 goto free_mem;
1245 }
1246
1247 /* If Winbond chip, address of chip and W83793_REG_I2C_ADDR
1248 should match */
1249 if ((data->bank & 0x07) == 0
1250 && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) !=
1251 (address << 1)) {
1252 pr_debug("w83793: Detection failed at check "
1253 "i2c addr\n");
1254 err = -ENODEV;
1255 goto free_mem;
1256 }
1257
1258 }
1259
1260 /* We have either had a force parameter, or we have already detected the
1261 Winbond. Determine the chip type now */
1262
1263 if (kind <= 0) {
1264 if (0x7b == w83793_read_value(client, W83793_REG_CHIPID)) {
1265 kind = w83793;
1266 } else {
1267 if (kind == 0)
1268 dev_warn(&adapter->dev, "w83793: Ignoring "
1269 "'force' parameter for unknown chip "
1270 "at address 0x%02x\n", address);
1271 err = -ENODEV;
1272 goto free_mem;
1273 }
1274 }
1275
1276 /* Fill in the remaining client fields and put into the global list */
1277 strlcpy(client->name, "w83793", I2C_NAME_SIZE);
1278
1279 mutex_init(&data->update_lock);
1280
1281 /* Tell the I2C layer a new client has arrived */
1282 if ((err = i2c_attach_client(client)))
1283 goto free_mem;
1284
1285 if ((err = w83793_detect_subclients(adapter, address, kind, client)))
1286 goto detach_client;
1287
1288 /* Initialize the chip */
1289 w83793_init_client(client);
1290
1291 data->vrm = vid_which_vrm();
1292 /*
1293 Only fan 1-5 has their own input pins,
1294 Pwm 1-3 has their own pins
1295 */
1296 data->has_fan = 0x1f;
1297 data->has_pwm = 0x07;
1298 tmp = w83793_read_value(client, W83793_REG_MFC);
1299 val = w83793_read_value(client, W83793_REG_FANIN_CTRL);
1300
1301 /* check the function of pins 49-56 */
1302 if (!(tmp & 0x80)) {
1303 data->has_pwm |= 0x18; /* pwm 4,5 */
1304 if (val & 0x01) { /* fan 6 */
1305 data->has_fan |= 0x20;
1306 data->has_pwm |= 0x20;
1307 }
1308 if (val & 0x02) { /* fan 7 */
1309 data->has_fan |= 0x40;
1310 data->has_pwm |= 0x40;
1311 }
1312 if (!(tmp & 0x40) && (val & 0x04)) { /* fan 8 */
1313 data->has_fan |= 0x80;
1314 data->has_pwm |= 0x80;
1315 }
1316 }
1317
1318 if (0x08 == (tmp & 0x0c)) {
1319 if (val & 0x08) /* fan 9 */
1320 data->has_fan |= 0x100;
1321 if (val & 0x10) /* fan 10 */
1322 data->has_fan |= 0x200;
1323 }
1324
1325 if (0x20 == (tmp & 0x30)) {
1326 if (val & 0x20) /* fan 11 */
1327 data->has_fan |= 0x400;
1328 if (val & 0x40) /* fan 12 */
1329 data->has_fan |= 0x800;
1330 }
1331
1332 if ((tmp & 0x01) && (val & 0x04)) { /* fan 8, second location */
1333 data->has_fan |= 0x80;
1334 data->has_pwm |= 0x80;
1335 }
1336
1337 tmp = w83793_read_value(client, W83793_REG_FANIN_SEL);
1338 if ((tmp & 0x01) && (val & 0x08)) { /* fan 9, second location */
1339 data->has_fan |= 0x100;
1340 }
1341 if ((tmp & 0x02) && (val & 0x10)) { /* fan 10, second location */
1342 data->has_fan |= 0x200;
1343 }
1344 if ((tmp & 0x04) && (val & 0x20)) { /* fan 11, second location */
1345 data->has_fan |= 0x400;
1346 }
1347 if ((tmp & 0x08) && (val & 0x40)) { /* fan 12, second location */
1348 data->has_fan |= 0x800;
1349 }
1350
1351 /* check the temp1-6 mode, ignore former AMDSI selected inputs */
1352 tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[0]);
1353 if (tmp & 0x01)
1354 data->has_temp |= 0x01;
1355 if (tmp & 0x04)
1356 data->has_temp |= 0x02;
1357 if (tmp & 0x10)
1358 data->has_temp |= 0x04;
1359 if (tmp & 0x40)
1360 data->has_temp |= 0x08;
1361
1362 tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[1]);
1363 if (tmp & 0x01)
1364 data->has_temp |= 0x10;
1365 if (tmp & 0x02)
1366 data->has_temp |= 0x20;
1367
1368 /* Detect the VID usage and ignore unused input */
1369 tmp = w83793_read_value(client, W83793_REG_MFC);
1370 if (!(tmp & 0x29))
1371 data->has_vid |= 0x1; /* has VIDA */
1372 if (tmp & 0x80)
1373 data->has_vid |= 0x2; /* has VIDB */
1374
1375 /* Register sysfs hooks */
1376 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) {
1377 err = device_create_file(dev,
1378 &w83793_sensor_attr_2[i].dev_attr);
1379 if (err)
1380 goto exit_remove;
1381 }
1382
1383 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) {
1384 if (!(data->has_vid & (1 << i)))
1385 continue;
1386 err = device_create_file(dev, &w83793_vid[i].dev_attr);
1387 if (err)
1388 goto exit_remove;
1389 }
1390
1391 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) {
1392 err = device_create_file(dev, &sda_single_files[i].dev_attr);
1393 if (err)
1394 goto exit_remove;
1395
1396 }
1397
1398 for (i = 0; i < 6; i++) {
1399 int j;
1400 if (!(data->has_temp & (1 << i)))
1401 continue;
1402 for (j = 0; j < files_temp; j++) {
1403 err = device_create_file(dev,
1404 &w83793_temp[(i) * files_temp
1405 + j].dev_attr);
1406 if (err)
1407 goto exit_remove;
1408 }
1409 }
1410
1411 for (i = 5; i < 12; i++) {
1412 int j;
1413 if (!(data->has_fan & (1 << i)))
1414 continue;
1415 for (j = 0; j < files_fan; j++) {
1416 err = device_create_file(dev,
1417 &w83793_left_fan[(i - 5) * files_fan
1418 + j].dev_attr);
1419 if (err)
1420 goto exit_remove;
1421 }
1422 }
1423
1424 for (i = 3; i < 8; i++) {
1425 int j;
1426 if (!(data->has_pwm & (1 << i)))
1427 continue;
1428 for (j = 0; j < files_pwm; j++) {
1429 err = device_create_file(dev,
1430 &w83793_left_pwm[(i - 3) * files_pwm
1431 + j].dev_attr);
1432 if (err)
1433 goto exit_remove;
1434 }
1435 }
1436
1437 data->class_dev = hwmon_device_register(dev);
1438 if (IS_ERR(data->class_dev)) {
1439 err = PTR_ERR(data->class_dev);
1440 goto exit_remove;
1441 }
1442
1443 return 0;
1444
1445 /* Unregister sysfs hooks */
1446
1447 exit_remove:
1448 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1449 device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr);
1450
1451 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1452 device_remove_file(dev, &sda_single_files[i].dev_attr);
1453
1454 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1455 device_remove_file(dev, &w83793_vid[i].dev_attr);
1456
1457 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1458 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1459
1460 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1461 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1462
1463 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1464 device_remove_file(dev, &w83793_temp[i].dev_attr);
1465
1466 if (data->lm75[0] != NULL) {
1467 i2c_detach_client(data->lm75[0]);
1468 kfree(data->lm75[0]);
1469 }
1470 if (data->lm75[1] != NULL) {
1471 i2c_detach_client(data->lm75[1]);
1472 kfree(data->lm75[1]);
1473 }
1474 detach_client:
1475 i2c_detach_client(client);
1476 free_mem:
1477 kfree(data);
1478 exit:
1479 return err;
1480 }
1481
1482 static void w83793_update_nonvolatile(struct device *dev)
1483 {
1484 struct i2c_client *client = to_i2c_client(dev);
1485 struct w83793_data *data = i2c_get_clientdata(client);
1486 int i, j;
1487 /*
1488 They are somewhat "stable" registers, and to update them everytime
1489 takes so much time, it's just not worthy. Update them in a long
1490 interval to avoid exception.
1491 */
1492 if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1493 || !data->valid))
1494 return;
1495 /* update voltage limits */
1496 for (i = 1; i < 3; i++) {
1497 for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1498 data->in[j][i] =
1499 w83793_read_value(client, W83793_REG_IN[j][i]);
1500 }
1501 data->in_low_bits[i] =
1502 w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]);
1503 }
1504
1505 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1506 /* Update the Fan measured value and limits */
1507 if (!(data->has_fan & (1 << i))) {
1508 continue;
1509 }
1510 data->fan_min[i] =
1511 w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8;
1512 data->fan_min[i] |=
1513 w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1);
1514 }
1515
1516 for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1517 if (!(data->has_temp & (1 << i)))
1518 continue;
1519 data->temp_fan_map[i] =
1520 w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i));
1521 for (j = 1; j < 5; j++) {
1522 data->temp[i][j] =
1523 w83793_read_value(client, W83793_REG_TEMP[i][j]);
1524 }
1525 data->temp_cruise[i] =
1526 w83793_read_value(client, W83793_REG_TEMP_CRUISE(i));
1527 for (j = 0; j < 7; j++) {
1528 data->sf2_pwm[i][j] =
1529 w83793_read_value(client, W83793_REG_SF2_PWM(i, j));
1530 data->sf2_temp[i][j] =
1531 w83793_read_value(client,
1532 W83793_REG_SF2_TEMP(i, j));
1533 }
1534 }
1535
1536 for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1537 data->temp_mode[i] =
1538 w83793_read_value(client, W83793_REG_TEMP_MODE[i]);
1539
1540 for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1541 data->tolerance[i] =
1542 w83793_read_value(client, W83793_REG_TEMP_TOL(i));
1543 }
1544
1545 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1546 if (!(data->has_pwm & (1 << i)))
1547 continue;
1548 data->pwm[i][PWM_NONSTOP] =
1549 w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP));
1550 data->pwm[i][PWM_START] =
1551 w83793_read_value(client, W83793_REG_PWM(i, PWM_START));
1552 data->pwm_stop_time[i] =
1553 w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i));
1554 }
1555
1556 data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
1557 data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
1558 data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
1559 data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
1560 data->temp_critical =
1561 w83793_read_value(client, W83793_REG_TEMP_CRITICAL);
1562 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
1563
1564 for (i = 0; i < ARRAY_SIZE(data->beeps); i++) {
1565 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
1566 }
1567
1568 data->last_nonvolatile = jiffies;
1569 }
1570
1571 static struct w83793_data *w83793_update_device(struct device *dev)
1572 {
1573 struct i2c_client *client = to_i2c_client(dev);
1574 struct w83793_data *data = i2c_get_clientdata(client);
1575 int i;
1576
1577 mutex_lock(&data->update_lock);
1578
1579 if (!(time_after(jiffies, data->last_updated + HZ * 2)
1580 || !data->valid))
1581 goto END;
1582
1583 /* Update the voltages measured value and limits */
1584 for (i = 0; i < ARRAY_SIZE(data->in); i++)
1585 data->in[i][IN_READ] =
1586 w83793_read_value(client, W83793_REG_IN[i][IN_READ]);
1587
1588 data->in_low_bits[IN_READ] =
1589 w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]);
1590
1591 for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
1592 if (!(data->has_fan & (1 << i))) {
1593 continue;
1594 }
1595 data->fan[i] =
1596 w83793_read_value(client, W83793_REG_FAN(i)) << 8;
1597 data->fan[i] |=
1598 w83793_read_value(client, W83793_REG_FAN(i) + 1);
1599 }
1600
1601 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
1602 if (!(data->has_temp & (1 << i)))
1603 continue;
1604 data->temp[i][TEMP_READ] =
1605 w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]);
1606 }
1607
1608 data->temp_low_bits =
1609 w83793_read_value(client, W83793_REG_TEMP_LOW_BITS);
1610
1611 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1612 if (data->has_pwm & (1 << i))
1613 data->pwm[i][PWM_DUTY] =
1614 w83793_read_value(client,
1615 W83793_REG_PWM(i, PWM_DUTY));
1616 }
1617
1618 for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
1619 data->alarms[i] =
1620 w83793_read_value(client, W83793_REG_ALARM(i));
1621 if (data->has_vid & 0x01)
1622 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
1623 if (data->has_vid & 0x02)
1624 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
1625 w83793_update_nonvolatile(dev);
1626 data->last_updated = jiffies;
1627 data->valid = 1;
1628
1629 END:
1630 mutex_unlock(&data->update_lock);
1631 return data;
1632 }
1633
1634 /* Ignore the possibility that somebody change bank outside the driver
1635 Must be called with data->update_lock held, except during initialization */
1636 static u8 w83793_read_value(struct i2c_client *client, u16 reg)
1637 {
1638 struct w83793_data *data = i2c_get_clientdata(client);
1639 u8 res = 0xff;
1640 u8 new_bank = reg >> 8;
1641
1642 new_bank |= data->bank & 0xfc;
1643 if (data->bank != new_bank) {
1644 if (i2c_smbus_write_byte_data
1645 (client, W83793_REG_BANKSEL, new_bank) >= 0)
1646 data->bank = new_bank;
1647 else {
1648 dev_err(&client->dev,
1649 "set bank to %d failed, fall back "
1650 "to bank %d, read reg 0x%x error\n",
1651 new_bank, data->bank, reg);
1652 res = 0x0; /* read 0x0 from the chip */
1653 goto END;
1654 }
1655 }
1656 res = i2c_smbus_read_byte_data(client, reg & 0xff);
1657 END:
1658 return res;
1659 }
1660
1661 /* Must be called with data->update_lock held, except during initialization */
1662 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value)
1663 {
1664 struct w83793_data *data = i2c_get_clientdata(client);
1665 int res;
1666 u8 new_bank = reg >> 8;
1667
1668 new_bank |= data->bank & 0xfc;
1669 if (data->bank != new_bank) {
1670 if ((res = i2c_smbus_write_byte_data
1671 (client, W83793_REG_BANKSEL, new_bank)) >= 0)
1672 data->bank = new_bank;
1673 else {
1674 dev_err(&client->dev,
1675 "set bank to %d failed, fall back "
1676 "to bank %d, write reg 0x%x error\n",
1677 new_bank, data->bank, reg);
1678 goto END;
1679 }
1680 }
1681
1682 res = i2c_smbus_write_byte_data(client, reg & 0xff, value);
1683 END:
1684 return res;
1685 }
1686
1687 static int __init sensors_w83793_init(void)
1688 {
1689 return i2c_add_driver(&w83793_driver);
1690 }
1691
1692 static void __exit sensors_w83793_exit(void)
1693 {
1694 i2c_del_driver(&w83793_driver);
1695 }
1696
1697 MODULE_AUTHOR("Yuan Mu");
1698 MODULE_DESCRIPTION("w83793 driver");
1699 MODULE_LICENSE("GPL");
1700
1701 module_init(sensors_w83793_init);
1702 module_exit(sensors_w83793_exit);
Linux with added FPC-III support