?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libata: fix Seagate NCQ+FLUSH blacklist
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hwmon / fschmd.c
blob96717036893376dd47ae06134af682e439640b0d
1 /* fschmd.c
2 *
3 * Copyright (C) 2007 Hans de Goede <j.w.r.degoede@hhs.nl>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20 /*
21 * Merged Fujitsu Siemens hwmon driver, supporting the Poseidon, Hermes,
22 * Scylla, Heracles and Heimdall chips
23 *
24 * Based on the original 2.4 fscscy, 2.6 fscpos, 2.6 fscher and 2.6
25 * (candidate) fschmd drivers:
26 * Copyright (C) 2006 Thilo Cestonaro
27 * <thilo.cestonaro.external@fujitsu-siemens.com>
28 * Copyright (C) 2004, 2005 Stefan Ott <stefan@desire.ch>
29 * Copyright (C) 2003, 2004 Reinhard Nissl <rnissl@gmx.de>
30 * Copyright (c) 2001 Martin Knoblauch <mkn@teraport.de, knobi@knobisoft.de>
31 * Copyright (C) 2000 Hermann Jung <hej@odn.de>
32 */
33
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/slab.h>
37 #include <linux/jiffies.h>
38 #include <linux/i2c.h>
39 #include <linux/hwmon.h>
40 #include <linux/hwmon-sysfs.h>
41 #include <linux/err.h>
42 #include <linux/mutex.h>
43 #include <linux/sysfs.h>
44 #include <linux/dmi.h>
45
46 /* Addresses to scan */
47 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
48
49 /* Insmod parameters */
50 I2C_CLIENT_INSMOD_5(fscpos, fscher, fscscy, fschrc, fschmd);
51
52 /*
53 * The FSCHMD registers and other defines
54 */
55
56 /* chip identification */
57 #define FSCHMD_REG_IDENT_0 0x00
58 #define FSCHMD_REG_IDENT_1 0x01
59 #define FSCHMD_REG_IDENT_2 0x02
60 #define FSCHMD_REG_REVISION 0x03
61
62 /* global control and status */
63 #define FSCHMD_REG_EVENT_STATE 0x04
64 #define FSCHMD_REG_CONTROL 0x05
65
66 #define FSCHMD_CONTROL_ALERT_LED_MASK 0x01
67
68 /* watchdog (support to be implemented) */
69 #define FSCHMD_REG_WDOG_PRESET 0x28
70 #define FSCHMD_REG_WDOG_STATE 0x23
71 #define FSCHMD_REG_WDOG_CONTROL 0x21
72
73 /* voltages, weird order is to keep the same order as the old drivers */
74 static const u8 FSCHMD_REG_VOLT[3] = { 0x45, 0x42, 0x48 };
75
76 /* minimum pwm at which the fan is driven (pwm can by increased depending on
77 the temp. Notice that for the scy some fans share there minimum speed.
78 Also notice that with the scy the sensor order is different then with the
79 other chips, this order was in the 2.4 driver and kept for consistency. */
80 static const u8 FSCHMD_REG_FAN_MIN[5][6] = {
81 { 0x55, 0x65 }, /* pos */
82 { 0x55, 0x65, 0xb5 }, /* her */
83 { 0x65, 0x65, 0x55, 0xa5, 0x55, 0xa5 }, /* scy */
84 { 0x55, 0x65, 0xa5, 0xb5 }, /* hrc */
85 { 0x55, 0x65, 0xa5, 0xb5, 0xc5 }, /* hmd */
86 };
87
88 /* actual fan speed */
89 static const u8 FSCHMD_REG_FAN_ACT[5][6] = {
90 { 0x0e, 0x6b, 0xab }, /* pos */
91 { 0x0e, 0x6b, 0xbb }, /* her */
92 { 0x6b, 0x6c, 0x0e, 0xab, 0x5c, 0xbb }, /* scy */
93 { 0x0e, 0x6b, 0xab, 0xbb }, /* hrc */
94 { 0x5b, 0x6b, 0xab, 0xbb, 0xcb }, /* hmd */
95 };
96
97 /* fan status registers */
98 static const u8 FSCHMD_REG_FAN_STATE[5][6] = {
99 { 0x0d, 0x62, 0xa2 }, /* pos */
100 { 0x0d, 0x62, 0xb2 }, /* her */
101 { 0x62, 0x61, 0x0d, 0xa2, 0x52, 0xb2 }, /* scy */
102 { 0x0d, 0x62, 0xa2, 0xb2 }, /* hrc */
103 { 0x52, 0x62, 0xa2, 0xb2, 0xc2 }, /* hmd */
104 };
105
106 /* fan ripple / divider registers */
107 static const u8 FSCHMD_REG_FAN_RIPPLE[5][6] = {
108 { 0x0f, 0x6f, 0xaf }, /* pos */
109 { 0x0f, 0x6f, 0xbf }, /* her */
110 { 0x6f, 0x6f, 0x0f, 0xaf, 0x0f, 0xbf }, /* scy */
111 { 0x0f, 0x6f, 0xaf, 0xbf }, /* hrc */
112 { 0x5f, 0x6f, 0xaf, 0xbf, 0xcf }, /* hmd */
113 };
114
115 static const int FSCHMD_NO_FAN_SENSORS[5] = { 3, 3, 6, 4, 5 };
116
117 /* Fan status register bitmasks */
118 #define FSCHMD_FAN_ALARM_MASK 0x04 /* called fault by FSC! */
119 #define FSCHMD_FAN_NOT_PRESENT_MASK 0x08 /* not documented */
120
121
122 /* actual temperature registers */
123 static const u8 FSCHMD_REG_TEMP_ACT[5][5] = {
124 { 0x64, 0x32, 0x35 }, /* pos */
125 { 0x64, 0x32, 0x35 }, /* her */
126 { 0x64, 0xD0, 0x32, 0x35 }, /* scy */
127 { 0x64, 0x32, 0x35 }, /* hrc */
128 { 0x70, 0x80, 0x90, 0xd0, 0xe0 }, /* hmd */
129 };
130
131 /* temperature state registers */
132 static const u8 FSCHMD_REG_TEMP_STATE[5][5] = {
133 { 0x71, 0x81, 0x91 }, /* pos */
134 { 0x71, 0x81, 0x91 }, /* her */
135 { 0x71, 0xd1, 0x81, 0x91 }, /* scy */
136 { 0x71, 0x81, 0x91 }, /* hrc */
137 { 0x71, 0x81, 0x91, 0xd1, 0xe1 }, /* hmd */
138 };
139
140 /* temperature high limit registers, FSC does not document these. Proven to be
141 there with field testing on the fscher and fschrc, already supported / used
142 in the fscscy 2.4 driver. FSC has confirmed that the fschmd has registers
143 at these addresses, but doesn't want to confirm they are the same as with
144 the fscher?? */
145 static const u8 FSCHMD_REG_TEMP_LIMIT[5][5] = {
146 { 0, 0, 0 }, /* pos */
147 { 0x76, 0x86, 0x96 }, /* her */
148 { 0x76, 0xd6, 0x86, 0x96 }, /* scy */
149 { 0x76, 0x86, 0x96 }, /* hrc */
150 { 0x76, 0x86, 0x96, 0xd6, 0xe6 }, /* hmd */
151 };
152
153 /* These were found through experimenting with an fscher, currently they are
154 not used, but we keep them around for future reference.
155 static const u8 FSCHER_REG_TEMP_AUTOP1[] = { 0x73, 0x83, 0x93 };
156 static const u8 FSCHER_REG_TEMP_AUTOP2[] = { 0x75, 0x85, 0x95 }; */
157
158 static const int FSCHMD_NO_TEMP_SENSORS[5] = { 3, 3, 4, 3, 5 };
159
160 /* temp status register bitmasks */
161 #define FSCHMD_TEMP_WORKING_MASK 0x01
162 #define FSCHMD_TEMP_ALERT_MASK 0x02
163 /* there only really is an alarm if the sensor is working and alert == 1 */
164 #define FSCHMD_TEMP_ALARM_MASK \
165 (FSCHMD_TEMP_WORKING_MASK | FSCHMD_TEMP_ALERT_MASK)
166
167 /* our driver name */
168 #define FSCHMD_NAME "fschmd"
169
170 /*
171 * Functions declarations
172 */
173
174 static int fschmd_probe(struct i2c_client *client,
175 const struct i2c_device_id *id);
176 static int fschmd_detect(struct i2c_client *client, int kind,
177 struct i2c_board_info *info);
178 static int fschmd_remove(struct i2c_client *client);
179 static struct fschmd_data *fschmd_update_device(struct device *dev);
180
181 /*
182 * Driver data (common to all clients)
183 */
184
185 static const struct i2c_device_id fschmd_id[] = {
186 { "fscpos", fscpos },
187 { "fscher", fscher },
188 { "fscscy", fscscy },
189 { "fschrc", fschrc },
190 { "fschmd", fschmd },
191 { }
192 };
193 MODULE_DEVICE_TABLE(i2c, fschmd_id);
194
195 static struct i2c_driver fschmd_driver = {
196 .class = I2C_CLASS_HWMON,
197 .driver = {
198 .name = FSCHMD_NAME,
199 },
200 .probe = fschmd_probe,
201 .remove = fschmd_remove,
202 .id_table = fschmd_id,
203 .detect = fschmd_detect,
204 .address_data = &addr_data,
205 };
206
207 /*
208 * Client data (each client gets its own)
209 */
210
211 struct fschmd_data {
212 struct device *hwmon_dev;
213 struct mutex update_lock;
214 int kind;
215 char valid; /* zero until following fields are valid */
216 unsigned long last_updated; /* in jiffies */
217
218 /* register values */
219 u8 global_control; /* global control register */
220 u8 volt[3]; /* 12, 5, battery voltage */
221 u8 temp_act[5]; /* temperature */
222 u8 temp_status[5]; /* status of sensor */
223 u8 temp_max[5]; /* high temp limit, notice: undocumented! */
224 u8 fan_act[6]; /* fans revolutions per second */
225 u8 fan_status[6]; /* fan status */
226 u8 fan_min[6]; /* fan min value for rps */
227 u8 fan_ripple[6]; /* divider for rps */
228 };
229
230 /* Global variables to hold information read from special DMI tables, which are
231 available on FSC machines with an fscher or later chip. */
232 static int dmi_mult[3] = { 490, 200, 100 };
233 static int dmi_offset[3] = { 0, 0, 0 };
234 static int dmi_vref = -1;
235
236
237 /*
238 * Sysfs attr show / store functions
239 */
240
241 static ssize_t show_in_value(struct device *dev,
242 struct device_attribute *devattr, char *buf)
243 {
244 const int max_reading[3] = { 14200, 6600, 3300 };
245 int index = to_sensor_dev_attr(devattr)->index;
246 struct fschmd_data *data = fschmd_update_device(dev);
247
248 /* fscher / fschrc - 1 as data->kind is an array index, not a chips */
249 if (data->kind == (fscher - 1) || data->kind >= (fschrc - 1))
250 return sprintf(buf, "%d\n", (data->volt[index] * dmi_vref *
251 dmi_mult[index]) / 255 + dmi_offset[index]);
252 else
253 return sprintf(buf, "%d\n", (data->volt[index] *
254 max_reading[index] + 128) / 255);
255 }
256
257
258 #define TEMP_FROM_REG(val) (((val) - 128) * 1000)
259
260 static ssize_t show_temp_value(struct device *dev,
261 struct device_attribute *devattr, char *buf)
262 {
263 int index = to_sensor_dev_attr(devattr)->index;
264 struct fschmd_data *data = fschmd_update_device(dev);
265
266 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_act[index]));
267 }
268
269 static ssize_t show_temp_max(struct device *dev,
270 struct device_attribute *devattr, char *buf)
271 {
272 int index = to_sensor_dev_attr(devattr)->index;
273 struct fschmd_data *data = fschmd_update_device(dev);
274
275 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[index]));
276 }
277
278 static ssize_t store_temp_max(struct device *dev, struct device_attribute
279 *devattr, const char *buf, size_t count)
280 {
281 int index = to_sensor_dev_attr(devattr)->index;
282 struct fschmd_data *data = dev_get_drvdata(dev);
283 long v = simple_strtol(buf, NULL, 10) / 1000;
284
285 v = SENSORS_LIMIT(v, -128, 127) + 128;
286
287 mutex_lock(&data->update_lock);
288 i2c_smbus_write_byte_data(to_i2c_client(dev),
289 FSCHMD_REG_TEMP_LIMIT[data->kind][index], v);
290 data->temp_max[index] = v;
291 mutex_unlock(&data->update_lock);
292
293 return count;
294 }
295
296 static ssize_t show_temp_fault(struct device *dev,
297 struct device_attribute *devattr, char *buf)
298 {
299 int index = to_sensor_dev_attr(devattr)->index;
300 struct fschmd_data *data = fschmd_update_device(dev);
301
302 /* bit 0 set means sensor working ok, so no fault! */
303 if (data->temp_status[index] & FSCHMD_TEMP_WORKING_MASK)
304 return sprintf(buf, "0\n");
305 else
306 return sprintf(buf, "1\n");
307 }
308
309 static ssize_t show_temp_alarm(struct device *dev,
310 struct device_attribute *devattr, char *buf)
311 {
312 int index = to_sensor_dev_attr(devattr)->index;
313 struct fschmd_data *data = fschmd_update_device(dev);
314
315 if ((data->temp_status[index] & FSCHMD_TEMP_ALARM_MASK) ==
316 FSCHMD_TEMP_ALARM_MASK)
317 return sprintf(buf, "1\n");
318 else
319 return sprintf(buf, "0\n");
320 }
321
322
323 #define RPM_FROM_REG(val) ((val) * 60)
324
325 static ssize_t show_fan_value(struct device *dev,
326 struct device_attribute *devattr, char *buf)
327 {
328 int index = to_sensor_dev_attr(devattr)->index;
329 struct fschmd_data *data = fschmd_update_device(dev);
330
331 return sprintf(buf, "%u\n", RPM_FROM_REG(data->fan_act[index]));
332 }
333
334 static ssize_t show_fan_div(struct device *dev,
335 struct device_attribute *devattr, char *buf)
336 {
337 int index = to_sensor_dev_attr(devattr)->index;
338 struct fschmd_data *data = fschmd_update_device(dev);
339
340 /* bits 2..7 reserved => mask with 3 */
341 return sprintf(buf, "%d\n", 1 << (data->fan_ripple[index] & 3));
342 }
343
344 static ssize_t store_fan_div(struct device *dev, struct device_attribute
345 *devattr, const char *buf, size_t count)
346 {
347 u8 reg;
348 int index = to_sensor_dev_attr(devattr)->index;
349 struct fschmd_data *data = dev_get_drvdata(dev);
350 /* supported values: 2, 4, 8 */
351 unsigned long v = simple_strtoul(buf, NULL, 10);
352
353 switch (v) {
354 case 2: v = 1; break;
355 case 4: v = 2; break;
356 case 8: v = 3; break;
357 default:
358 dev_err(dev, "fan_div value %lu not supported. "
359 "Choose one of 2, 4 or 8!\n", v);
360 return -EINVAL;
361 }
362
363 mutex_lock(&data->update_lock);
364
365 reg = i2c_smbus_read_byte_data(to_i2c_client(dev),
366 FSCHMD_REG_FAN_RIPPLE[data->kind][index]);
367
368 /* bits 2..7 reserved => mask with 0x03 */
369 reg &= ~0x03;
370 reg |= v;
371
372 i2c_smbus_write_byte_data(to_i2c_client(dev),
373 FSCHMD_REG_FAN_RIPPLE[data->kind][index], reg);
374
375 data->fan_ripple[index] = reg;
376
377 mutex_unlock(&data->update_lock);
378
379 return count;
380 }
381
382 static ssize_t show_fan_alarm(struct device *dev,
383 struct device_attribute *devattr, char *buf)
384 {
385 int index = to_sensor_dev_attr(devattr)->index;
386 struct fschmd_data *data = fschmd_update_device(dev);
387
388 if (data->fan_status[index] & FSCHMD_FAN_ALARM_MASK)
389 return sprintf(buf, "1\n");
390 else
391 return sprintf(buf, "0\n");
392 }
393
394 static ssize_t show_fan_fault(struct device *dev,
395 struct device_attribute *devattr, char *buf)
396 {
397 int index = to_sensor_dev_attr(devattr)->index;
398 struct fschmd_data *data = fschmd_update_device(dev);
399
400 if (data->fan_status[index] & FSCHMD_FAN_NOT_PRESENT_MASK)
401 return sprintf(buf, "1\n");
402 else
403 return sprintf(buf, "0\n");
404 }
405
406
407 static ssize_t show_pwm_auto_point1_pwm(struct device *dev,
408 struct device_attribute *devattr, char *buf)
409 {
410 int index = to_sensor_dev_attr(devattr)->index;
411 int val = fschmd_update_device(dev)->fan_min[index];
412
413 /* 0 = allow turning off, 1-255 = 50-100% */
414 if (val)
415 val = val / 2 + 128;
416
417 return sprintf(buf, "%d\n", val);
418 }
419
420 static ssize_t store_pwm_auto_point1_pwm(struct device *dev,
421 struct device_attribute *devattr, const char *buf, size_t count)
422 {
423 int index = to_sensor_dev_attr(devattr)->index;
424 struct fschmd_data *data = dev_get_drvdata(dev);
425 unsigned long v = simple_strtoul(buf, NULL, 10);
426
427 /* register: 0 = allow turning off, 1-255 = 50-100% */
428 if (v) {
429 v = SENSORS_LIMIT(v, 128, 255);
430 v = (v - 128) * 2 + 1;
431 }
432
433 mutex_lock(&data->update_lock);
434
435 i2c_smbus_write_byte_data(to_i2c_client(dev),
436 FSCHMD_REG_FAN_MIN[data->kind][index], v);
437 data->fan_min[index] = v;
438
439 mutex_unlock(&data->update_lock);
440
441 return count;
442 }
443
444
445 /* The FSC hwmon family has the ability to force an attached alert led to flash
446 from software, we export this as an alert_led sysfs attr */
447 static ssize_t show_alert_led(struct device *dev,
448 struct device_attribute *devattr, char *buf)
449 {
450 struct fschmd_data *data = fschmd_update_device(dev);
451
452 if (data->global_control & FSCHMD_CONTROL_ALERT_LED_MASK)
453 return sprintf(buf, "1\n");
454 else
455 return sprintf(buf, "0\n");
456 }
457
458 static ssize_t store_alert_led(struct device *dev,
459 struct device_attribute *devattr, const char *buf, size_t count)
460 {
461 u8 reg;
462 struct fschmd_data *data = dev_get_drvdata(dev);
463 unsigned long v = simple_strtoul(buf, NULL, 10);
464
465 mutex_lock(&data->update_lock);
466
467 reg = i2c_smbus_read_byte_data(to_i2c_client(dev), FSCHMD_REG_CONTROL);
468
469 if (v)
470 reg |= FSCHMD_CONTROL_ALERT_LED_MASK;
471 else
472 reg &= ~FSCHMD_CONTROL_ALERT_LED_MASK;
473
474 i2c_smbus_write_byte_data(to_i2c_client(dev), FSCHMD_REG_CONTROL, reg);
475
476 data->global_control = reg;
477
478 mutex_unlock(&data->update_lock);
479
480 return count;
481 }
482
483 static struct sensor_device_attribute fschmd_attr[] = {
484 SENSOR_ATTR(in0_input, 0444, show_in_value, NULL, 0),
485 SENSOR_ATTR(in1_input, 0444, show_in_value, NULL, 1),
486 SENSOR_ATTR(in2_input, 0444, show_in_value, NULL, 2),
487 SENSOR_ATTR(alert_led, 0644, show_alert_led, store_alert_led, 0),
488 };
489
490 static struct sensor_device_attribute fschmd_temp_attr[] = {
491 SENSOR_ATTR(temp1_input, 0444, show_temp_value, NULL, 0),
492 SENSOR_ATTR(temp1_max, 0644, show_temp_max, store_temp_max, 0),
493 SENSOR_ATTR(temp1_fault, 0444, show_temp_fault, NULL, 0),
494 SENSOR_ATTR(temp1_alarm, 0444, show_temp_alarm, NULL, 0),
495 SENSOR_ATTR(temp2_input, 0444, show_temp_value, NULL, 1),
496 SENSOR_ATTR(temp2_max, 0644, show_temp_max, store_temp_max, 1),
497 SENSOR_ATTR(temp2_fault, 0444, show_temp_fault, NULL, 1),
498 SENSOR_ATTR(temp2_alarm, 0444, show_temp_alarm, NULL, 1),
499 SENSOR_ATTR(temp3_input, 0444, show_temp_value, NULL, 2),
500 SENSOR_ATTR(temp3_max, 0644, show_temp_max, store_temp_max, 2),
501 SENSOR_ATTR(temp3_fault, 0444, show_temp_fault, NULL, 2),
502 SENSOR_ATTR(temp3_alarm, 0444, show_temp_alarm, NULL, 2),
503 SENSOR_ATTR(temp4_input, 0444, show_temp_value, NULL, 3),
504 SENSOR_ATTR(temp4_max, 0644, show_temp_max, store_temp_max, 3),
505 SENSOR_ATTR(temp4_fault, 0444, show_temp_fault, NULL, 3),
506 SENSOR_ATTR(temp4_alarm, 0444, show_temp_alarm, NULL, 3),
507 SENSOR_ATTR(temp5_input, 0444, show_temp_value, NULL, 4),
508 SENSOR_ATTR(temp5_max, 0644, show_temp_max, store_temp_max, 4),
509 SENSOR_ATTR(temp5_fault, 0444, show_temp_fault, NULL, 4),
510 SENSOR_ATTR(temp5_alarm, 0444, show_temp_alarm, NULL, 4),
511 };
512
513 static struct sensor_device_attribute fschmd_fan_attr[] = {
514 SENSOR_ATTR(fan1_input, 0444, show_fan_value, NULL, 0),
515 SENSOR_ATTR(fan1_div, 0644, show_fan_div, store_fan_div, 0),
516 SENSOR_ATTR(fan1_alarm, 0444, show_fan_alarm, NULL, 0),
517 SENSOR_ATTR(fan1_fault, 0444, show_fan_fault, NULL, 0),
518 SENSOR_ATTR(pwm1_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
519 store_pwm_auto_point1_pwm, 0),
520 SENSOR_ATTR(fan2_input, 0444, show_fan_value, NULL, 1),
521 SENSOR_ATTR(fan2_div, 0644, show_fan_div, store_fan_div, 1),
522 SENSOR_ATTR(fan2_alarm, 0444, show_fan_alarm, NULL, 1),
523 SENSOR_ATTR(fan2_fault, 0444, show_fan_fault, NULL, 1),
524 SENSOR_ATTR(pwm2_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
525 store_pwm_auto_point1_pwm, 1),
526 SENSOR_ATTR(fan3_input, 0444, show_fan_value, NULL, 2),
527 SENSOR_ATTR(fan3_div, 0644, show_fan_div, store_fan_div, 2),
528 SENSOR_ATTR(fan3_alarm, 0444, show_fan_alarm, NULL, 2),
529 SENSOR_ATTR(fan3_fault, 0444, show_fan_fault, NULL, 2),
530 SENSOR_ATTR(pwm3_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
531 store_pwm_auto_point1_pwm, 2),
532 SENSOR_ATTR(fan4_input, 0444, show_fan_value, NULL, 3),
533 SENSOR_ATTR(fan4_div, 0644, show_fan_div, store_fan_div, 3),
534 SENSOR_ATTR(fan4_alarm, 0444, show_fan_alarm, NULL, 3),
535 SENSOR_ATTR(fan4_fault, 0444, show_fan_fault, NULL, 3),
536 SENSOR_ATTR(pwm4_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
537 store_pwm_auto_point1_pwm, 3),
538 SENSOR_ATTR(fan5_input, 0444, show_fan_value, NULL, 4),
539 SENSOR_ATTR(fan5_div, 0644, show_fan_div, store_fan_div, 4),
540 SENSOR_ATTR(fan5_alarm, 0444, show_fan_alarm, NULL, 4),
541 SENSOR_ATTR(fan5_fault, 0444, show_fan_fault, NULL, 4),
542 SENSOR_ATTR(pwm5_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
543 store_pwm_auto_point1_pwm, 4),
544 SENSOR_ATTR(fan6_input, 0444, show_fan_value, NULL, 5),
545 SENSOR_ATTR(fan6_div, 0644, show_fan_div, store_fan_div, 5),
546 SENSOR_ATTR(fan6_alarm, 0444, show_fan_alarm, NULL, 5),
547 SENSOR_ATTR(fan6_fault, 0444, show_fan_fault, NULL, 5),
548 SENSOR_ATTR(pwm6_auto_point1_pwm, 0644, show_pwm_auto_point1_pwm,
549 store_pwm_auto_point1_pwm, 5),
550 };
551
552
553 /*
554 * Real code
555 */
556
557 /* DMI decode routine to read voltage scaling factors from special DMI tables,
558 which are available on FSC machines with an fscher or later chip. */
559 static void fschmd_dmi_decode(const struct dmi_header *header)
560 {
561 int i, mult[3] = { 0 }, offset[3] = { 0 }, vref = 0, found = 0;
562
563 /* dmi code ugliness, we get passed the address of the contents of
564 a complete DMI record, but in the form of a dmi_header pointer, in
565 reality this address holds header->length bytes of which the header
566 are the first 4 bytes */
567 u8 *dmi_data = (u8 *)header;
568
569 /* We are looking for OEM-specific type 185 */
570 if (header->type != 185)
571 return;
572
573 /* we are looking for what Siemens calls "subtype" 19, the subtype
574 is stored in byte 5 of the dmi block */
575 if (header->length < 5 || dmi_data[4] != 19)
576 return;
577
578 /* After the subtype comes 1 unknown byte and then blocks of 5 bytes,
579 consisting of what Siemens calls an "Entity" number, followed by
580 2 16-bit words in LSB first order */
581 for (i = 6; (i + 4) < header->length; i += 5) {
582 /* entity 1 - 3: voltage multiplier and offset */
583 if (dmi_data[i] >= 1 && dmi_data[i] <= 3) {
584 /* Our in sensors order and the DMI order differ */
585 const int shuffle[3] = { 1, 0, 2 };
586 int in = shuffle[dmi_data[i] - 1];
587
588 /* Check for twice the same entity */
589 if (found & (1 << in))
590 return;
591
592 mult[in] = dmi_data[i + 1] | (dmi_data[i + 2] << 8);
593 offset[in] = dmi_data[i + 3] | (dmi_data[i + 4] << 8);
594
595 found |= 1 << in;
596 }
597
598 /* entity 7: reference voltage */
599 if (dmi_data[i] == 7) {
600 /* Check for twice the same entity */
601 if (found & 0x08)
602 return;
603
604 vref = dmi_data[i + 1] | (dmi_data[i + 2] << 8);
605
606 found |= 0x08;
607 }
608 }
609
610 if (found == 0x0F) {
611 for (i = 0; i < 3; i++) {
612 dmi_mult[i] = mult[i] * 10;
613 dmi_offset[i] = offset[i] * 10;
614 }
615 dmi_vref = vref;
616 }
617 }
618
619 static int fschmd_detect(struct i2c_client *client, int kind,
620 struct i2c_board_info *info)
621 {
622 struct i2c_adapter *adapter = client->adapter;
623 const char * const client_names[5] = { "fscpos", "fscher", "fscscy",
624 "fschrc", "fschmd" };
625
626 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
627 return -ENODEV;
628
629 /* Detect & Identify the chip */
630 if (kind <= 0) {
631 char id[4];
632
633 id[0] = i2c_smbus_read_byte_data(client,
634 FSCHMD_REG_IDENT_0);
635 id[1] = i2c_smbus_read_byte_data(client,
636 FSCHMD_REG_IDENT_1);
637 id[2] = i2c_smbus_read_byte_data(client,
638 FSCHMD_REG_IDENT_2);
639 id[3] = '\0';
640
641 if (!strcmp(id, "PEG"))
642 kind = fscpos;
643 else if (!strcmp(id, "HER"))
644 kind = fscher;
645 else if (!strcmp(id, "SCY"))
646 kind = fscscy;
647 else if (!strcmp(id, "HRC"))
648 kind = fschrc;
649 else if (!strcmp(id, "HMD"))
650 kind = fschmd;
651 else
652 return -ENODEV;
653 }
654
655 strlcpy(info->type, client_names[kind - 1], I2C_NAME_SIZE);
656
657 return 0;
658 }
659
660 static int fschmd_probe(struct i2c_client *client,
661 const struct i2c_device_id *id)
662 {
663 struct fschmd_data *data;
664 u8 revision;
665 const char * const names[5] = { "Poseidon", "Hermes", "Scylla",
666 "Heracles", "Heimdall" };
667 int i, err;
668 enum chips kind = id->driver_data;
669
670 data = kzalloc(sizeof(struct fschmd_data), GFP_KERNEL);
671 if (!data)
672 return -ENOMEM;
673
674 i2c_set_clientdata(client, data);
675 mutex_init(&data->update_lock);
676
677 if (kind == fscpos) {
678 /* The Poseidon has hardwired temp limits, fill these
679 in for the alarm resetting code */
680 data->temp_max[0] = 70 + 128;
681 data->temp_max[1] = 50 + 128;
682 data->temp_max[2] = 50 + 128;
683 }
684
685 /* Read the special DMI table for fscher and newer chips */
686 if (kind == fscher || kind >= fschrc) {
687 dmi_walk(fschmd_dmi_decode);
688 if (dmi_vref == -1) {
689 printk(KERN_WARNING FSCHMD_NAME
690 ": Couldn't get voltage scaling factors from "
691 "BIOS DMI table, using builtin defaults\n");
692 dmi_vref = 33;
693 }
694 }
695
696 /* i2c kind goes from 1-5, we want from 0-4 to address arrays */
697 data->kind = kind - 1;
698
699 for (i = 0; i < ARRAY_SIZE(fschmd_attr); i++) {
700 err = device_create_file(&client->dev,
701 &fschmd_attr[i].dev_attr);
702 if (err)
703 goto exit_detach;
704 }
705
706 for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++) {
707 /* Poseidon doesn't have TEMP_LIMIT registers */
708 if (kind == fscpos && fschmd_temp_attr[i].dev_attr.show ==
709 show_temp_max)
710 continue;
711
712 err = device_create_file(&client->dev,
713 &fschmd_temp_attr[i].dev_attr);
714 if (err)
715 goto exit_detach;
716 }
717
718 for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++) {
719 /* Poseidon doesn't have a FAN_MIN register for its 3rd fan */
720 if (kind == fscpos &&
721 !strcmp(fschmd_fan_attr[i].dev_attr.attr.name,
722 "pwm3_auto_point1_pwm"))
723 continue;
724
725 err = device_create_file(&client->dev,
726 &fschmd_fan_attr[i].dev_attr);
727 if (err)
728 goto exit_detach;
729 }
730
731 data->hwmon_dev = hwmon_device_register(&client->dev);
732 if (IS_ERR(data->hwmon_dev)) {
733 err = PTR_ERR(data->hwmon_dev);
734 data->hwmon_dev = NULL;
735 goto exit_detach;
736 }
737
738 revision = i2c_smbus_read_byte_data(client, FSCHMD_REG_REVISION);
739 printk(KERN_INFO FSCHMD_NAME ": Detected FSC %s chip, revision: %d\n",
740 names[data->kind], (int) revision);
741
742 return 0;
743
744 exit_detach:
745 fschmd_remove(client); /* will also free data for us */
746 return err;
747 }
748
749 static int fschmd_remove(struct i2c_client *client)
750 {
751 struct fschmd_data *data = i2c_get_clientdata(client);
752 int i;
753
754 /* Check if registered in case we're called from fschmd_detect
755 to cleanup after an error */
756 if (data->hwmon_dev)
757 hwmon_device_unregister(data->hwmon_dev);
758
759 for (i = 0; i < ARRAY_SIZE(fschmd_attr); i++)
760 device_remove_file(&client->dev, &fschmd_attr[i].dev_attr);
761 for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++)
762 device_remove_file(&client->dev,
763 &fschmd_temp_attr[i].dev_attr);
764 for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++)
765 device_remove_file(&client->dev,
766 &fschmd_fan_attr[i].dev_attr);
767
768 kfree(data);
769 return 0;
770 }
771
772 static struct fschmd_data *fschmd_update_device(struct device *dev)
773 {
774 struct i2c_client *client = to_i2c_client(dev);
775 struct fschmd_data *data = i2c_get_clientdata(client);
776 int i;
777
778 mutex_lock(&data->update_lock);
779
780 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
781
782 for (i = 0; i < FSCHMD_NO_TEMP_SENSORS[data->kind]; i++) {
783 data->temp_act[i] = i2c_smbus_read_byte_data(client,
784 FSCHMD_REG_TEMP_ACT[data->kind][i]);
785 data->temp_status[i] = i2c_smbus_read_byte_data(client,
786 FSCHMD_REG_TEMP_STATE[data->kind][i]);
787
788 /* The fscpos doesn't have TEMP_LIMIT registers */
789 if (FSCHMD_REG_TEMP_LIMIT[data->kind][i])
790 data->temp_max[i] = i2c_smbus_read_byte_data(
791 client,
792 FSCHMD_REG_TEMP_LIMIT[data->kind][i]);
793
794 /* reset alarm if the alarm condition is gone,
795 the chip doesn't do this itself */
796 if ((data->temp_status[i] & FSCHMD_TEMP_ALARM_MASK) ==
797 FSCHMD_TEMP_ALARM_MASK &&
798 data->temp_act[i] < data->temp_max[i])
799 i2c_smbus_write_byte_data(client,
800 FSCHMD_REG_TEMP_STATE[data->kind][i],
801 FSCHMD_TEMP_ALERT_MASK);
802 }
803
804 for (i = 0; i < FSCHMD_NO_FAN_SENSORS[data->kind]; i++) {
805 data->fan_act[i] = i2c_smbus_read_byte_data(client,
806 FSCHMD_REG_FAN_ACT[data->kind][i]);
807 data->fan_status[i] = i2c_smbus_read_byte_data(client,
808 FSCHMD_REG_FAN_STATE[data->kind][i]);
809 data->fan_ripple[i] = i2c_smbus_read_byte_data(client,
810 FSCHMD_REG_FAN_RIPPLE[data->kind][i]);
811
812 /* The fscpos third fan doesn't have a fan_min */
813 if (FSCHMD_REG_FAN_MIN[data->kind][i])
814 data->fan_min[i] = i2c_smbus_read_byte_data(
815 client,
816 FSCHMD_REG_FAN_MIN[data->kind][i]);
817
818 /* reset fan status if speed is back to > 0 */
819 if ((data->fan_status[i] & FSCHMD_FAN_ALARM_MASK) &&
820 data->fan_act[i])
821 i2c_smbus_write_byte_data(client,
822 FSCHMD_REG_FAN_STATE[data->kind][i],
823 FSCHMD_FAN_ALARM_MASK);
824 }
825
826 for (i = 0; i < 3; i++)
827 data->volt[i] = i2c_smbus_read_byte_data(client,
828 FSCHMD_REG_VOLT[i]);
829
830 data->global_control = i2c_smbus_read_byte_data(client,
831 FSCHMD_REG_CONTROL);
832
833 /* To be implemented in the future
834 data->watchdog[0] = i2c_smbus_read_byte_data(client,
835 FSCHMD_REG_WDOG_PRESET);
836 data->watchdog[1] = i2c_smbus_read_byte_data(client,
837 FSCHMD_REG_WDOG_STATE);
838 data->watchdog[2] = i2c_smbus_read_byte_data(client,
839 FSCHMD_REG_WDOG_CONTROL); */
840
841 data->last_updated = jiffies;
842 data->valid = 1;
843 }
844
845 mutex_unlock(&data->update_lock);
846
847 return data;
848 }
849
850 static int __init fschmd_init(void)
851 {
852 return i2c_add_driver(&fschmd_driver);
853 }
854
855 static void __exit fschmd_exit(void)
856 {
857 i2c_del_driver(&fschmd_driver);
858 }
859
860 MODULE_AUTHOR("Hans de Goede <j.w.r.degoede@hhs.nl>");
861 MODULE_DESCRIPTION("FSC Poseidon, Hermes, Scylla, Heracles and "
862 "Heimdall driver");
863 MODULE_LICENSE("GPL");
864
865 module_init(fschmd_init);
866 module_exit(fschmd_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree