?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwlwifi: introduce host commands callbacks
[linux/fpc-iii.git] / drivers / hwmon / w83793.c
blobee35af93b574d37879acf53d813bd24f12c8dc29
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
1028 static struct sensor_device_attribute_2 sda_single_files[] = {
1029 SENSOR_ATTR_2(vrm, S_IWUSR | S_IRUGO, show_vrm, store_vrm,
1030 NOT_USED, NOT_USED),
1031 SENSOR_ATTR_2(chassis, S_IWUSR | S_IRUGO, show_alarm_beep,
1032 store_chassis_clear, ALARM_STATUS, 30),
1033 SENSOR_ATTR_2(beep_enable, S_IWUSR | S_IRUGO, show_beep_enable,
1034 store_beep_enable, NOT_USED, NOT_USED),
1035 SENSOR_ATTR_2(pwm_default, S_IWUSR | S_IRUGO, show_sf_setup,
1036 store_sf_setup, SETUP_PWM_DEFAULT, NOT_USED),
1037 SENSOR_ATTR_2(pwm_uptime, S_IWUSR | S_IRUGO, show_sf_setup,
1038 store_sf_setup, SETUP_PWM_UPTIME, NOT_USED),
1039 SENSOR_ATTR_2(pwm_downtime, S_IWUSR | S_IRUGO, show_sf_setup,
1040 store_sf_setup, SETUP_PWM_DOWNTIME, NOT_USED),
1041 SENSOR_ATTR_2(temp_critical, S_IWUSR | S_IRUGO, show_sf_setup,
1042 store_sf_setup, SETUP_TEMP_CRITICAL, NOT_USED),
1043 };
1044
1045 static void w83793_init_client(struct i2c_client *client)
1046 {
1047 if (reset) {
1048 w83793_write_value(client, W83793_REG_CONFIG, 0x80);
1049 }
1050
1051 /* Start monitoring */
1052 w83793_write_value(client, W83793_REG_CONFIG,
1053 w83793_read_value(client, W83793_REG_CONFIG) | 0x01);
1054
1055 }
1056
1057 static int w83793_attach_adapter(struct i2c_adapter *adapter)
1058 {
1059 if (!(adapter->class & I2C_CLASS_HWMON))
1060 return 0;
1061 return i2c_probe(adapter, &addr_data, w83793_detect);
1062 }
1063
1064 static int w83793_detach_client(struct i2c_client *client)
1065 {
1066 struct w83793_data *data = i2c_get_clientdata(client);
1067 struct device *dev = &client->dev;
1068 int err, i;
1069
1070 /* main client */
1071 if (data) {
1072 hwmon_device_unregister(data->hwmon_dev);
1073
1074 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1075 device_remove_file(dev,
1076 &w83793_sensor_attr_2[i].dev_attr);
1077
1078 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1079 device_remove_file(dev, &sda_single_files[i].dev_attr);
1080
1081 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1082 device_remove_file(dev, &w83793_vid[i].dev_attr);
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 data->vrm = vid_which_vrm();
1286 /*
1287 Only fan 1-5 has their own input pins,
1288 Pwm 1-3 has their own pins
1289 */
1290 data->has_fan = 0x1f;
1291 data->has_pwm = 0x07;
1292 tmp = w83793_read_value(client, W83793_REG_MFC);
1293 val = w83793_read_value(client, W83793_REG_FANIN_CTRL);
1294
1295 /* check the function of pins 49-56 */
1296 if (!(tmp & 0x80)) {
1297 data->has_pwm |= 0x18; /* pwm 4,5 */
1298 if (val & 0x01) { /* fan 6 */
1299 data->has_fan |= 0x20;
1300 data->has_pwm |= 0x20;
1301 }
1302 if (val & 0x02) { /* fan 7 */
1303 data->has_fan |= 0x40;
1304 data->has_pwm |= 0x40;
1305 }
1306 if (!(tmp & 0x40) && (val & 0x04)) { /* fan 8 */
1307 data->has_fan |= 0x80;
1308 data->has_pwm |= 0x80;
1309 }
1310 }
1311
1312 if (0x08 == (tmp & 0x0c)) {
1313 if (val & 0x08) /* fan 9 */
1314 data->has_fan |= 0x100;
1315 if (val & 0x10) /* fan 10 */
1316 data->has_fan |= 0x200;
1317 }
1318
1319 if (0x20 == (tmp & 0x30)) {
1320 if (val & 0x20) /* fan 11 */
1321 data->has_fan |= 0x400;
1322 if (val & 0x40) /* fan 12 */
1323 data->has_fan |= 0x800;
1324 }
1325
1326 if ((tmp & 0x01) && (val & 0x04)) { /* fan 8, second location */
1327 data->has_fan |= 0x80;
1328 data->has_pwm |= 0x80;
1329 }
1330
1331 tmp = w83793_read_value(client, W83793_REG_FANIN_SEL);
1332 if ((tmp & 0x01) && (val & 0x08)) { /* fan 9, second location */
1333 data->has_fan |= 0x100;
1334 }
1335 if ((tmp & 0x02) && (val & 0x10)) { /* fan 10, second location */
1336 data->has_fan |= 0x200;
1337 }
1338 if ((tmp & 0x04) && (val & 0x20)) { /* fan 11, second location */
1339 data->has_fan |= 0x400;
1340 }
1341 if ((tmp & 0x08) && (val & 0x40)) { /* fan 12, second location */
1342 data->has_fan |= 0x800;
1343 }
1344
1345 /* check the temp1-6 mode, ignore former AMDSI selected inputs */
1346 tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[0]);
1347 if (tmp & 0x01)
1348 data->has_temp |= 0x01;
1349 if (tmp & 0x04)
1350 data->has_temp |= 0x02;
1351 if (tmp & 0x10)
1352 data->has_temp |= 0x04;
1353 if (tmp & 0x40)
1354 data->has_temp |= 0x08;
1355
1356 tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[1]);
1357 if (tmp & 0x01)
1358 data->has_temp |= 0x10;
1359 if (tmp & 0x02)
1360 data->has_temp |= 0x20;
1361
1362 /* Detect the VID usage and ignore unused input */
1363 tmp = w83793_read_value(client, W83793_REG_MFC);
1364 if (!(tmp & 0x29))
1365 data->has_vid |= 0x1; /* has VIDA */
1366 if (tmp & 0x80)
1367 data->has_vid |= 0x2; /* has VIDB */
1368
1369 /* Register sysfs hooks */
1370 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) {
1371 err = device_create_file(dev,
1372 &w83793_sensor_attr_2[i].dev_attr);
1373 if (err)
1374 goto exit_remove;
1375 }
1376
1377 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) {
1378 if (!(data->has_vid & (1 << i)))
1379 continue;
1380 err = device_create_file(dev, &w83793_vid[i].dev_attr);
1381 if (err)
1382 goto exit_remove;
1383 }
1384
1385 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) {
1386 err = device_create_file(dev, &sda_single_files[i].dev_attr);
1387 if (err)
1388 goto exit_remove;
1389
1390 }
1391
1392 for (i = 0; i < 6; i++) {
1393 int j;
1394 if (!(data->has_temp & (1 << i)))
1395 continue;
1396 for (j = 0; j < files_temp; j++) {
1397 err = device_create_file(dev,
1398 &w83793_temp[(i) * files_temp
1399 + j].dev_attr);
1400 if (err)
1401 goto exit_remove;
1402 }
1403 }
1404
1405 for (i = 5; i < 12; i++) {
1406 int j;
1407 if (!(data->has_fan & (1 << i)))
1408 continue;
1409 for (j = 0; j < files_fan; j++) {
1410 err = device_create_file(dev,
1411 &w83793_left_fan[(i - 5) * files_fan
1412 + j].dev_attr);
1413 if (err)
1414 goto exit_remove;
1415 }
1416 }
1417
1418 for (i = 3; i < 8; i++) {
1419 int j;
1420 if (!(data->has_pwm & (1 << i)))
1421 continue;
1422 for (j = 0; j < files_pwm; j++) {
1423 err = device_create_file(dev,
1424 &w83793_left_pwm[(i - 3) * files_pwm
1425 + j].dev_attr);
1426 if (err)
1427 goto exit_remove;
1428 }
1429 }
1430
1431 data->hwmon_dev = hwmon_device_register(dev);
1432 if (IS_ERR(data->hwmon_dev)) {
1433 err = PTR_ERR(data->hwmon_dev);
1434 goto exit_remove;
1435 }
1436
1437 return 0;
1438
1439 /* Unregister sysfs hooks */
1440
1441 exit_remove:
1442 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1443 device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr);
1444
1445 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1446 device_remove_file(dev, &sda_single_files[i].dev_attr);
1447
1448 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1449 device_remove_file(dev, &w83793_vid[i].dev_attr);
1450
1451 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1452 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1453
1454 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1455 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1456
1457 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1458 device_remove_file(dev, &w83793_temp[i].dev_attr);
1459
1460 if (data->lm75[0] != NULL) {
1461 i2c_detach_client(data->lm75[0]);
1462 kfree(data->lm75[0]);
1463 }
1464 if (data->lm75[1] != NULL) {
1465 i2c_detach_client(data->lm75[1]);
1466 kfree(data->lm75[1]);
1467 }
1468 detach_client:
1469 i2c_detach_client(client);
1470 free_mem:
1471 kfree(data);
1472 exit:
1473 return err;
1474 }
1475
1476 static void w83793_update_nonvolatile(struct device *dev)
1477 {
1478 struct i2c_client *client = to_i2c_client(dev);
1479 struct w83793_data *data = i2c_get_clientdata(client);
1480 int i, j;
1481 /*
1482 They are somewhat "stable" registers, and to update them everytime
1483 takes so much time, it's just not worthy. Update them in a long
1484 interval to avoid exception.
1485 */
1486 if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1487 || !data->valid))
1488 return;
1489 /* update voltage limits */
1490 for (i = 1; i < 3; i++) {
1491 for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1492 data->in[j][i] =
1493 w83793_read_value(client, W83793_REG_IN[j][i]);
1494 }
1495 data->in_low_bits[i] =
1496 w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]);
1497 }
1498
1499 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1500 /* Update the Fan measured value and limits */
1501 if (!(data->has_fan & (1 << i))) {
1502 continue;
1503 }
1504 data->fan_min[i] =
1505 w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8;
1506 data->fan_min[i] |=
1507 w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1);
1508 }
1509
1510 for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1511 if (!(data->has_temp & (1 << i)))
1512 continue;
1513 data->temp_fan_map[i] =
1514 w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i));
1515 for (j = 1; j < 5; j++) {
1516 data->temp[i][j] =
1517 w83793_read_value(client, W83793_REG_TEMP[i][j]);
1518 }
1519 data->temp_cruise[i] =
1520 w83793_read_value(client, W83793_REG_TEMP_CRUISE(i));
1521 for (j = 0; j < 7; j++) {
1522 data->sf2_pwm[i][j] =
1523 w83793_read_value(client, W83793_REG_SF2_PWM(i, j));
1524 data->sf2_temp[i][j] =
1525 w83793_read_value(client,
1526 W83793_REG_SF2_TEMP(i, j));
1527 }
1528 }
1529
1530 for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1531 data->temp_mode[i] =
1532 w83793_read_value(client, W83793_REG_TEMP_MODE[i]);
1533
1534 for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1535 data->tolerance[i] =
1536 w83793_read_value(client, W83793_REG_TEMP_TOL(i));
1537 }
1538
1539 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1540 if (!(data->has_pwm & (1 << i)))
1541 continue;
1542 data->pwm[i][PWM_NONSTOP] =
1543 w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP));
1544 data->pwm[i][PWM_START] =
1545 w83793_read_value(client, W83793_REG_PWM(i, PWM_START));
1546 data->pwm_stop_time[i] =
1547 w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i));
1548 }
1549
1550 data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
1551 data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
1552 data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
1553 data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
1554 data->temp_critical =
1555 w83793_read_value(client, W83793_REG_TEMP_CRITICAL);
1556 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
1557
1558 for (i = 0; i < ARRAY_SIZE(data->beeps); i++) {
1559 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
1560 }
1561
1562 data->last_nonvolatile = jiffies;
1563 }
1564
1565 static struct w83793_data *w83793_update_device(struct device *dev)
1566 {
1567 struct i2c_client *client = to_i2c_client(dev);
1568 struct w83793_data *data = i2c_get_clientdata(client);
1569 int i;
1570
1571 mutex_lock(&data->update_lock);
1572
1573 if (!(time_after(jiffies, data->last_updated + HZ * 2)
1574 || !data->valid))
1575 goto END;
1576
1577 /* Update the voltages measured value and limits */
1578 for (i = 0; i < ARRAY_SIZE(data->in); i++)
1579 data->in[i][IN_READ] =
1580 w83793_read_value(client, W83793_REG_IN[i][IN_READ]);
1581
1582 data->in_low_bits[IN_READ] =
1583 w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]);
1584
1585 for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
1586 if (!(data->has_fan & (1 << i))) {
1587 continue;
1588 }
1589 data->fan[i] =
1590 w83793_read_value(client, W83793_REG_FAN(i)) << 8;
1591 data->fan[i] |=
1592 w83793_read_value(client, W83793_REG_FAN(i) + 1);
1593 }
1594
1595 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
1596 if (!(data->has_temp & (1 << i)))
1597 continue;
1598 data->temp[i][TEMP_READ] =
1599 w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]);
1600 }
1601
1602 data->temp_low_bits =
1603 w83793_read_value(client, W83793_REG_TEMP_LOW_BITS);
1604
1605 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1606 if (data->has_pwm & (1 << i))
1607 data->pwm[i][PWM_DUTY] =
1608 w83793_read_value(client,
1609 W83793_REG_PWM(i, PWM_DUTY));
1610 }
1611
1612 for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
1613 data->alarms[i] =
1614 w83793_read_value(client, W83793_REG_ALARM(i));
1615 if (data->has_vid & 0x01)
1616 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
1617 if (data->has_vid & 0x02)
1618 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
1619 w83793_update_nonvolatile(dev);
1620 data->last_updated = jiffies;
1621 data->valid = 1;
1622
1623 END:
1624 mutex_unlock(&data->update_lock);
1625 return data;
1626 }
1627
1628 /* Ignore the possibility that somebody change bank outside the driver
1629 Must be called with data->update_lock held, except during initialization */
1630 static u8 w83793_read_value(struct i2c_client *client, u16 reg)
1631 {
1632 struct w83793_data *data = i2c_get_clientdata(client);
1633 u8 res = 0xff;
1634 u8 new_bank = reg >> 8;
1635
1636 new_bank |= data->bank & 0xfc;
1637 if (data->bank != new_bank) {
1638 if (i2c_smbus_write_byte_data
1639 (client, W83793_REG_BANKSEL, new_bank) >= 0)
1640 data->bank = new_bank;
1641 else {
1642 dev_err(&client->dev,
1643 "set bank to %d failed, fall back "
1644 "to bank %d, read reg 0x%x error\n",
1645 new_bank, data->bank, reg);
1646 res = 0x0; /* read 0x0 from the chip */
1647 goto END;
1648 }
1649 }
1650 res = i2c_smbus_read_byte_data(client, reg & 0xff);
1651 END:
1652 return res;
1653 }
1654
1655 /* Must be called with data->update_lock held, except during initialization */
1656 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value)
1657 {
1658 struct w83793_data *data = i2c_get_clientdata(client);
1659 int res;
1660 u8 new_bank = reg >> 8;
1661
1662 new_bank |= data->bank & 0xfc;
1663 if (data->bank != new_bank) {
1664 if ((res = i2c_smbus_write_byte_data
1665 (client, W83793_REG_BANKSEL, new_bank)) >= 0)
1666 data->bank = new_bank;
1667 else {
1668 dev_err(&client->dev,
1669 "set bank to %d failed, fall back "
1670 "to bank %d, write reg 0x%x error\n",
1671 new_bank, data->bank, reg);
1672 goto END;
1673 }
1674 }
1675
1676 res = i2c_smbus_write_byte_data(client, reg & 0xff, value);
1677 END:
1678 return res;
1679 }
1680
1681 static int __init sensors_w83793_init(void)
1682 {
1683 return i2c_add_driver(&w83793_driver);
1684 }
1685
1686 static void __exit sensors_w83793_exit(void)
1687 {
1688 i2c_del_driver(&w83793_driver);
1689 }
1690
1691 MODULE_AUTHOR("Yuan Mu");
1692 MODULE_DESCRIPTION("w83793 driver");
1693 MODULE_LICENSE("GPL");
1694
1695 module_init(sensors_w83793_init);
1696 module_exit(sensors_w83793_exit);
Linux with added FPC-III support