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