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