]> Git Repo - linux.git/blame - drivers/hwmon/pc87427.c
projects / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branches 'sh-fixes-for-linus' and 'rmobile-fixes-for-linus' of git://git.kernel...
[linux.git] / drivers / hwmon / pc87427.c
CommitLineData
ba224e2c
JD		 1/*
2 * pc87427.c - hardware monitoring driver for the
3 * National Semiconductor PC87427 Super-I/O chip
008e5f33 4 * Copyright (C) 2006, 2008, 2010 Jean Delvare <[email protected]>
ba224e2c
JD		 5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
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 * Supports the following chips:
16 *
17 * Chip #vin #fan #pwm #temp devid
008e5f33 18 * PC87427 - 8 4 6 0xF2
ba224e2c
JD		 19 *
20 * This driver assumes that no more than one chip is present.
008e5f33
JD		 21 * Only fans are fully supported so far. Temperatures are in read-only
22 * mode, and voltages aren't supported at all.
ba224e2c
JD		 23 */
24
25#include <linux/module.h>
26#include <linux/init.h>
27#include <linux/slab.h>
28#include <linux/jiffies.h>
29#include <linux/platform_device.h>
30#include <linux/hwmon.h>
31#include <linux/hwmon-sysfs.h>
32#include <linux/err.h>
33#include <linux/mutex.h>
34#include <linux/sysfs.h>
ce7ee4e8 35#include <linux/ioport.h>
b9acb64a 36#include <linux/acpi.h>
6055fae8 37#include <linux/io.h>
ba224e2c 38
67b671bc
JD		 39static unsigned short force_id;
40module_param(force_id, ushort, 0);
41MODULE_PARM_DESC(force_id, "Override the detected device ID");
42
ba224e2c
JD		 43static struct platform_device *pdev;
44
45#define DRVNAME "pc87427"
46
47/* The lock mutex protects both the I/O accesses (needed because the
48 device is using banked registers) and the register cache (needed to keep
49 the data in the registers and the cache in sync at any time). */
50struct pc87427_data {
1beeffe4 51 struct device *hwmon_dev;
ba224e2c
JD		 52 struct mutex lock;
53 int address[2];
54 const char *name;
55
56 unsigned long last_updated; /* in jiffies */
57 u8 fan_enabled; /* bit vector */
58 u16 fan[8]; /* register values */
59 u16 fan_min[8]; /* register values */
60 u8 fan_status[8]; /* register values */
328716bc
JD		 61
62 u8 pwm_enabled; /* bit vector */
63 u8 pwm_auto_ok; /* bit vector */
64 u8 pwm_enable[4]; /* register values */
65 u8 pwm[4]; /* register values */
008e5f33
JD		 66
67 u8 temp_enabled; /* bit vector */
68 s16 temp[6]; /* register values */
69 s8 temp_min[6]; /* register values */
70 s8 temp_max[6]; /* register values */
71 s8 temp_crit[6]; /* register values */
72 u8 temp_status[6]; /* register values */
73 u8 temp_type[6]; /* register values */
ba224e2c
JD		 74};
75
4e7d99e1 76struct pc87427_sio_data {
9d32df19 77 unsigned short address[2];
4e7d99e1 78 u8 has_fanin;
328716bc 79 u8 has_fanout;
4e7d99e1
JD		 80};
81
ba224e2c
JD		 82/*
83 * Super-I/O registers and operations
84 */
85
86#define SIOREG_LDSEL 0x07 /* Logical device select */
87#define SIOREG_DEVID 0x20 /* Device ID */
4e7d99e1
JD		 88#define SIOREG_CF2 0x22 /* Configuration 2 */
89#define SIOREG_CF3 0x23 /* Configuration 3 */
90#define SIOREG_CF4 0x24 /* Configuration 4 */
328716bc 91#define SIOREG_CF5 0x25 /* Configuration 5 */
4e7d99e1 92#define SIOREG_CFB 0x2B /* Configuration B */
328716bc 93#define SIOREG_CFC 0x2C /* Configuration C */
4e7d99e1 94#define SIOREG_CFD 0x2D /* Configuration D */
ba224e2c
JD		 95#define SIOREG_ACT 0x30 /* Device activation */
96#define SIOREG_MAP 0x50 /* I/O or memory mapping */
97#define SIOREG_IOBASE 0x60 /* I/O base address */
98
99static const u8 logdev[2] = { 0x09, 0x14 };
100static const char *logdev_str[2] = { DRVNAME " FMC", DRVNAME " HMC" };
101#define LD_FAN 0
102#define LD_IN 1
103#define LD_TEMP 1
104
105static inline void superio_outb(int sioaddr, int reg, int val)
106{
107 outb(reg, sioaddr);
108 outb(val, sioaddr + 1);
109}
110
111static inline int superio_inb(int sioaddr, int reg)
112{
113 outb(reg, sioaddr);
114 return inb(sioaddr + 1);
115}
116
117static inline void superio_exit(int sioaddr)
118{
119 outb(0x02, sioaddr);
120 outb(0x02, sioaddr + 1);
121}
122
123/*
124 * Logical devices
125 */
126
127#define REGION_LENGTH 32
128#define PC87427_REG_BANK 0x0f
129#define BANK_FM(nr) (nr)
130#define BANK_FT(nr) (0x08 + (nr))
131#define BANK_FC(nr) (0x10 + (nr) * 2)
008e5f33
JD		 132#define BANK_TM(nr) (nr)
133#define BANK_VM(nr) (0x08 + (nr))
ba224e2c
JD		 134
135/*
136 * I/O access functions
137 */
138
139/* ldi is the logical device index */
140static inline int pc87427_read8(struct pc87427_data *data, u8 ldi, u8 reg)
141{
142 return inb(data->address[ldi] + reg);
143}
144
145/* Must be called with data->lock held, except during init */
146static inline int pc87427_read8_bank(struct pc87427_data *data, u8 ldi,
147 u8 bank, u8 reg)
148{
149 outb(bank, data->address[ldi] + PC87427_REG_BANK);
150 return inb(data->address[ldi] + reg);
151}
152
153/* Must be called with data->lock held, except during init */
154static inline void pc87427_write8_bank(struct pc87427_data *data, u8 ldi,
155 u8 bank, u8 reg, u8 value)
156{
157 outb(bank, data->address[ldi] + PC87427_REG_BANK);
158 outb(value, data->address[ldi] + reg);
159}
160
161/*
162 * Fan registers and conversions
163 */
164
165/* fan data registers are 16-bit wide */
166#define PC87427_REG_FAN 0x12
167#define PC87427_REG_FAN_MIN 0x14
168#define PC87427_REG_FAN_STATUS 0x10
169
170#define FAN_STATUS_STALL (1 << 3)
171#define FAN_STATUS_LOSPD (1 << 1)
172#define FAN_STATUS_MONEN (1 << 0)
173
174/* Dedicated function to read all registers related to a given fan input.
175 This saves us quite a few locks and bank selections.
176 Must be called with data->lock held.
177 nr is from 0 to 7 */
178static void pc87427_readall_fan(struct pc87427_data *data, u8 nr)
179{
180 int iobase = data->address[LD_FAN];
181
182 outb(BANK_FM(nr), iobase + PC87427_REG_BANK);
183 data->fan[nr] = inw(iobase + PC87427_REG_FAN);
184 data->fan_min[nr] = inw(iobase + PC87427_REG_FAN_MIN);
185 data->fan_status[nr] = inb(iobase + PC87427_REG_FAN_STATUS);
186 /* Clear fan alarm bits */
187 outb(data->fan_status[nr], iobase + PC87427_REG_FAN_STATUS);
188}
189
190/* The 2 LSB of fan speed registers are used for something different.
191 The actual 2 LSB of the measurements are not available. */
192static inline unsigned long fan_from_reg(u16 reg)
193{
194 reg &= 0xfffc;
195 if (reg == 0x0000 || reg == 0xfffc)
196 return 0;
197 return 5400000UL / reg;
198}
199
200/* The 2 LSB of the fan speed limit registers are not significant. */
201static inline u16 fan_to_reg(unsigned long val)
202{
203 if (val < 83UL)
204 return 0xffff;
205 if (val >= 1350000UL)
206 return 0x0004;
207 return ((1350000UL + val / 2) / val) << 2;
208}
209
328716bc
JD		 210/*
211 * PWM registers and conversions
212 */
213
214#define PC87427_REG_PWM_ENABLE 0x10
215#define PC87427_REG_PWM_DUTY 0x12
216
217#define PWM_ENABLE_MODE_MASK (7 << 4)
218#define PWM_ENABLE_CTLEN (1 << 0)
219
220#define PWM_MODE_MANUAL (0 << 4)
221#define PWM_MODE_AUTO (1 << 4)
222#define PWM_MODE_OFF (2 << 4)
223#define PWM_MODE_ON (7 << 4)
224
225/* Dedicated function to read all registers related to a given PWM output.
226 This saves us quite a few locks and bank selections.
227 Must be called with data->lock held.
228 nr is from 0 to 3 */
229static void pc87427_readall_pwm(struct pc87427_data *data, u8 nr)
230{
231 int iobase = data->address[LD_FAN];
232
233 outb(BANK_FC(nr), iobase + PC87427_REG_BANK);
234 data->pwm_enable[nr] = inb(iobase + PC87427_REG_PWM_ENABLE);
235 data->pwm[nr] = inb(iobase + PC87427_REG_PWM_DUTY);
236}
237
238static inline int pwm_enable_from_reg(u8 reg)
239{
240 switch (reg & PWM_ENABLE_MODE_MASK) {
241 case PWM_MODE_ON:
242 return 0;
243 case PWM_MODE_MANUAL:
244 case PWM_MODE_OFF:
245 return 1;
246 case PWM_MODE_AUTO:
247 return 2;
248 default:
249 return -EPROTO;
250 }
251}
252
253static inline u8 pwm_enable_to_reg(unsigned long val, u8 pwmval)
254{
255 switch (val) {
256 default:
257 return PWM_MODE_ON;
258 case 1:
259 return pwmval ? PWM_MODE_MANUAL : PWM_MODE_OFF;
260 case 2:
261 return PWM_MODE_AUTO;
262 }
263}
264
008e5f33
JD		 265/*
266 * Temperature registers and conversions
267 */
268
269#define PC87427_REG_TEMP_STATUS 0x10
270#define PC87427_REG_TEMP 0x14
271#define PC87427_REG_TEMP_MAX 0x18
272#define PC87427_REG_TEMP_MIN 0x19
273#define PC87427_REG_TEMP_CRIT 0x1a
274#define PC87427_REG_TEMP_TYPE 0x1d
275
276#define TEMP_STATUS_CHANEN (1 << 0)
277#define TEMP_STATUS_LOWFLG (1 << 1)
278#define TEMP_STATUS_HIGHFLG (1 << 2)
279#define TEMP_STATUS_CRITFLG (1 << 3)
280#define TEMP_STATUS_SENSERR (1 << 5)
281#define TEMP_TYPE_MASK (3 << 5)
282
283#define TEMP_TYPE_THERMISTOR (1 << 5)
284#define TEMP_TYPE_REMOTE_DIODE (2 << 5)
285#define TEMP_TYPE_LOCAL_DIODE (3 << 5)
286
287/* Dedicated function to read all registers related to a given temperature
288 input. This saves us quite a few locks and bank selections.
289 Must be called with data->lock held.
290 nr is from 0 to 5 */
291static void pc87427_readall_temp(struct pc87427_data *data, u8 nr)
292{
293 int iobase = data->address[LD_TEMP];
294
295 outb(BANK_TM(nr), iobase + PC87427_REG_BANK);
296 data->temp[nr] = le16_to_cpu(inw(iobase + PC87427_REG_TEMP));
297 data->temp_max[nr] = inb(iobase + PC87427_REG_TEMP_MAX);
298 data->temp_min[nr] = inb(iobase + PC87427_REG_TEMP_MIN);
299 data->temp_crit[nr] = inb(iobase + PC87427_REG_TEMP_CRIT);
300 data->temp_type[nr] = inb(iobase + PC87427_REG_TEMP_TYPE);
301 data->temp_status[nr] = inb(iobase + PC87427_REG_TEMP_STATUS);
302 /* Clear fan alarm bits */
303 outb(data->temp_status[nr], iobase + PC87427_REG_TEMP_STATUS);
304}
305
306static inline unsigned int temp_type_from_reg(u8 reg)
307{
308 switch (reg & TEMP_TYPE_MASK) {
309 case TEMP_TYPE_THERMISTOR:
310 return 4;
311 case TEMP_TYPE_REMOTE_DIODE:
312 case TEMP_TYPE_LOCAL_DIODE:
313 return 3;
314 default:
315 return 0;
316 }
317}
318
319/* We assume 8-bit thermal sensors; 9-bit thermal sensors are possible
320 too, but I have no idea how to figure out when they are used. */
321static inline long temp_from_reg(s16 reg)
322{
323 return reg * 1000 / 256;
324}
325
326static inline long temp_from_reg8(s8 reg)
327{
328 return reg * 1000;
329}
330
ba224e2c
JD		 331/*
332 * Data interface
333 */
334
335static struct pc87427_data *pc87427_update_device(struct device *dev)
336{
337 struct pc87427_data *data = dev_get_drvdata(dev);
338 int i;
339
340 mutex_lock(&data->lock);
341 if (!time_after(jiffies, data->last_updated + HZ)
342 && data->last_updated)
343 goto done;
344
345 /* Fans */
346 for (i = 0; i < 8; i++) {
347 if (!(data->fan_enabled & (1 << i)))
348 continue;
349 pc87427_readall_fan(data, i);
350 }
328716bc
JD		 351
352 /* PWM outputs */
353 for (i = 0; i < 4; i++) {
354 if (!(data->pwm_enabled & (1 << i)))
355 continue;
356 pc87427_readall_pwm(data, i);
357 }
358
008e5f33
JD		 359 /* Temperature channels */
360 for (i = 0; i < 6; i++) {
361 if (!(data->temp_enabled & (1 << i)))
362 continue;
363 pc87427_readall_temp(data, i);
364 }
365
ba224e2c
JD		 366 data->last_updated = jiffies;
367
368done:
369 mutex_unlock(&data->lock);
370 return data;
371}
372
373static ssize_t show_fan_input(struct device *dev, struct device_attribute
374 *devattr, char *buf)
375{
ba224e2c 376 struct pc87427_data *data = pc87427_update_device(dev);
0d22d583 377 int nr = to_sensor_dev_attr(devattr)->index;
ba224e2c
JD		 378
379 return sprintf(buf, "%lu\n", fan_from_reg(data->fan[nr]));
380}
381
382static ssize_t show_fan_min(struct device *dev, struct device_attribute
383 *devattr, char *buf)
384{
ba224e2c 385 struct pc87427_data *data = pc87427_update_device(dev);
0d22d583 386 int nr = to_sensor_dev_attr(devattr)->index;
ba224e2c
JD		 387
388 return sprintf(buf, "%lu\n", fan_from_reg(data->fan_min[nr]));
389}
390
391static ssize_t show_fan_alarm(struct device *dev, struct device_attribute
392 *devattr, char *buf)
393{
ba224e2c 394 struct pc87427_data *data = pc87427_update_device(dev);
0d22d583 395 int nr = to_sensor_dev_attr(devattr)->index;
ba224e2c
JD		 396
397 return sprintf(buf, "%d\n", !!(data->fan_status[nr]
398 & FAN_STATUS_LOSPD));
399}
400
401static ssize_t show_fan_fault(struct device *dev, struct device_attribute
402 *devattr, char *buf)
403{
ba224e2c 404 struct pc87427_data *data = pc87427_update_device(dev);
0d22d583 405 int nr = to_sensor_dev_attr(devattr)->index;
ba224e2c
JD		 406
407 return sprintf(buf, "%d\n", !!(data->fan_status[nr]
408 & FAN_STATUS_STALL));
409}
410
411static ssize_t set_fan_min(struct device *dev, struct device_attribute
412 *devattr, const char *buf, size_t count)
413{
414 struct pc87427_data *data = dev_get_drvdata(dev);
0d22d583
JD		 415 int nr = to_sensor_dev_attr(devattr)->index;
416 unsigned long val;
ba224e2c
JD		 417 int iobase = data->address[LD_FAN];
418
0d22d583
JD		 419 if (strict_strtoul(buf, 10, &val) < 0)
420 return -EINVAL;
421
ba224e2c
JD		 422 mutex_lock(&data->lock);
423 outb(BANK_FM(nr), iobase + PC87427_REG_BANK);
424 /* The low speed limit registers are read-only while monitoring
425 is enabled, so we have to disable monitoring, then change the
426 limit, and finally enable monitoring again. */
427 outb(0, iobase + PC87427_REG_FAN_STATUS);
428 data->fan_min[nr] = fan_to_reg(val);
429 outw(data->fan_min[nr], iobase + PC87427_REG_FAN_MIN);
430 outb(FAN_STATUS_MONEN, iobase + PC87427_REG_FAN_STATUS);
431 mutex_unlock(&data->lock);
432
433 return count;
434}
435
436static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
437static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
438static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_input, NULL, 2);
439static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_input, NULL, 3);
440static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan_input, NULL, 4);
441static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan_input, NULL, 5);
442static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan_input, NULL, 6);
443static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan_input, NULL, 7);
444
445static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO,
446 show_fan_min, set_fan_min, 0);
447static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO,
448 show_fan_min, set_fan_min, 1);
449static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO,
450 show_fan_min, set_fan_min, 2);
451static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO,
452 show_fan_min, set_fan_min, 3);
453static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO,
454 show_fan_min, set_fan_min, 4);
455static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO,
456 show_fan_min, set_fan_min, 5);
457static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO,
458 show_fan_min, set_fan_min, 6);
459static SENSOR_DEVICE_ATTR(fan8_min, S_IWUSR | S_IRUGO,
460 show_fan_min, set_fan_min, 7);
461
462static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_fan_alarm, NULL, 0);
463static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_fan_alarm, NULL, 1);
464static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_fan_alarm, NULL, 2);
465static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_fan_alarm, NULL, 3);
466static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_fan_alarm, NULL, 4);
467static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_fan_alarm, NULL, 5);
468static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_fan_alarm, NULL, 6);
469static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_fan_alarm, NULL, 7);
470
471static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault, NULL, 0);
472static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_fan_fault, NULL, 1);
473static SENSOR_DEVICE_ATTR(fan3_fault, S_IRUGO, show_fan_fault, NULL, 2);
474static SENSOR_DEVICE_ATTR(fan4_fault, S_IRUGO, show_fan_fault, NULL, 3);
475static SENSOR_DEVICE_ATTR(fan5_fault, S_IRUGO, show_fan_fault, NULL, 4);
476static SENSOR_DEVICE_ATTR(fan6_fault, S_IRUGO, show_fan_fault, NULL, 5);
477static SENSOR_DEVICE_ATTR(fan7_fault, S_IRUGO, show_fan_fault, NULL, 6);
478static SENSOR_DEVICE_ATTR(fan8_fault, S_IRUGO, show_fan_fault, NULL, 7);
479
480static struct attribute *pc87427_attributes_fan[8][5] = {
481 {
482 &sensor_dev_attr_fan1_input.dev_attr.attr,
483 &sensor_dev_attr_fan1_min.dev_attr.attr,
484 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
485 &sensor_dev_attr_fan1_fault.dev_attr.attr,
486 NULL
487 }, {
488 &sensor_dev_attr_fan2_input.dev_attr.attr,
489 &sensor_dev_attr_fan2_min.dev_attr.attr,
490 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
491 &sensor_dev_attr_fan2_fault.dev_attr.attr,
492 NULL
493 }, {
494 &sensor_dev_attr_fan3_input.dev_attr.attr,
495 &sensor_dev_attr_fan3_min.dev_attr.attr,
496 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
497 &sensor_dev_attr_fan3_fault.dev_attr.attr,
498 NULL
499 }, {
500 &sensor_dev_attr_fan4_input.dev_attr.attr,
501 &sensor_dev_attr_fan4_min.dev_attr.attr,
502 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
503 &sensor_dev_attr_fan4_fault.dev_attr.attr,
504 NULL
505 }, {
506 &sensor_dev_attr_fan5_input.dev_attr.attr,
507 &sensor_dev_attr_fan5_min.dev_attr.attr,
508 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
509 &sensor_dev_attr_fan5_fault.dev_attr.attr,
510 NULL
511 }, {
512 &sensor_dev_attr_fan6_input.dev_attr.attr,
513 &sensor_dev_attr_fan6_min.dev_attr.attr,
514 &sensor_dev_attr_fan6_alarm.dev_attr.attr,
515 &sensor_dev_attr_fan6_fault.dev_attr.attr,
516 NULL
517 }, {
518 &sensor_dev_attr_fan7_input.dev_attr.attr,
519 &sensor_dev_attr_fan7_min.dev_attr.attr,
520 &sensor_dev_attr_fan7_alarm.dev_attr.attr,
521 &sensor_dev_attr_fan7_fault.dev_attr.attr,
522 NULL
523 }, {
524 &sensor_dev_attr_fan8_input.dev_attr.attr,
525 &sensor_dev_attr_fan8_min.dev_attr.attr,
526 &sensor_dev_attr_fan8_alarm.dev_attr.attr,
527 &sensor_dev_attr_fan8_fault.dev_attr.attr,
528 NULL
529 }
530};
531
532static const struct attribute_group pc87427_group_fan[8] = {
533 { .attrs = pc87427_attributes_fan[0] },
534 { .attrs = pc87427_attributes_fan[1] },
535 { .attrs = pc87427_attributes_fan[2] },
536 { .attrs = pc87427_attributes_fan[3] },
537 { .attrs = pc87427_attributes_fan[4] },
538 { .attrs = pc87427_attributes_fan[5] },
539 { .attrs = pc87427_attributes_fan[6] },
540 { .attrs = pc87427_attributes_fan[7] },
541};
542
328716bc
JD		 543/* Must be called with data->lock held and pc87427_readall_pwm() freshly
544 called */
545static void update_pwm_enable(struct pc87427_data *data, int nr, u8 mode)
546{
547 int iobase = data->address[LD_FAN];
548 data->pwm_enable[nr] &= ~PWM_ENABLE_MODE_MASK;
549 data->pwm_enable[nr] |= mode;
550 outb(data->pwm_enable[nr], iobase + PC87427_REG_PWM_ENABLE);
551}
552
553static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
554 *devattr, char *buf)
555{
556 struct pc87427_data *data = pc87427_update_device(dev);
557 int nr = to_sensor_dev_attr(devattr)->index;
558 int pwm_enable;
559
560 pwm_enable = pwm_enable_from_reg(data->pwm_enable[nr]);
561 if (pwm_enable < 0)
562 return pwm_enable;
563 return sprintf(buf, "%d\n", pwm_enable);
564}
565
566static ssize_t set_pwm_enable(struct device *dev, struct device_attribute
567 *devattr, const char *buf, size_t count)
568{
569 struct pc87427_data *data = dev_get_drvdata(dev);
570 int nr = to_sensor_dev_attr(devattr)->index;
571 unsigned long val;
572
573 if (strict_strtoul(buf, 10, &val) < 0 || val > 2)
574 return -EINVAL;
575 /* Can't go to automatic mode if it isn't configured */
576 if (val == 2 && !(data->pwm_auto_ok & (1 << nr)))
577 return -EINVAL;
578
579 mutex_lock(&data->lock);
580 pc87427_readall_pwm(data, nr);
581 update_pwm_enable(data, nr, pwm_enable_to_reg(val, data->pwm[nr]));
582 mutex_unlock(&data->lock);
583
584 return count;
585}
586
587static ssize_t show_pwm(struct device *dev, struct device_attribute
588 *devattr, char *buf)
589{
590 struct pc87427_data *data = pc87427_update_device(dev);
591 int nr = to_sensor_dev_attr(devattr)->index;
592
593 return sprintf(buf, "%d\n", (int)data->pwm[nr]);
594}
595
596static ssize_t set_pwm(struct device *dev, struct device_attribute
597 *devattr, const char *buf, size_t count)
598{
599 struct pc87427_data *data = dev_get_drvdata(dev);
600 int nr = to_sensor_dev_attr(devattr)->index;
601 unsigned long val;
602 int iobase = data->address[LD_FAN];
603 u8 mode;
604
605 if (strict_strtoul(buf, 10, &val) < 0 || val > 0xff)
606 return -EINVAL;
607
608 mutex_lock(&data->lock);
609 pc87427_readall_pwm(data, nr);
610 mode = data->pwm_enable[nr] & PWM_ENABLE_MODE_MASK;
611 if (mode != PWM_MODE_MANUAL && mode != PWM_MODE_OFF) {
612 dev_notice(dev, "Can't set PWM%d duty cycle while not in "
613 "manual mode\n", nr + 1);
614 mutex_unlock(&data->lock);
615 return -EPERM;
616 }
617
618 /* We may have to change the mode */
619 if (mode == PWM_MODE_MANUAL && val == 0) {
620 /* Transition from Manual to Off */
621 update_pwm_enable(data, nr, PWM_MODE_OFF);
622 mode = PWM_MODE_OFF;
623 dev_dbg(dev, "Switching PWM%d from %s to %s\n", nr + 1,
624 "manual", "off");
625 } else if (mode == PWM_MODE_OFF && val != 0) {
626 /* Transition from Off to Manual */
627 update_pwm_enable(data, nr, PWM_MODE_MANUAL);
628 mode = PWM_MODE_MANUAL;
629 dev_dbg(dev, "Switching PWM%d from %s to %s\n", nr + 1,
630 "off", "manual");
631 }
632
633 data->pwm[nr] = val;
634 if (mode == PWM_MODE_MANUAL)
635 outb(val, iobase + PC87427_REG_PWM_DUTY);
636 mutex_unlock(&data->lock);
637
638 return count;
639}
640
641static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
642 show_pwm_enable, set_pwm_enable, 0);
643static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
644 show_pwm_enable, set_pwm_enable, 1);
645static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO,
646 show_pwm_enable, set_pwm_enable, 2);
647static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO,
648 show_pwm_enable, set_pwm_enable, 3);
649
650static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
651static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
652static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
653static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
654
655static struct attribute *pc87427_attributes_pwm[4][3] = {
656 {
657 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
658 &sensor_dev_attr_pwm1.dev_attr.attr,
659 NULL
660 }, {
661 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
662 &sensor_dev_attr_pwm2.dev_attr.attr,
663 NULL
664 }, {
665 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
666 &sensor_dev_attr_pwm3.dev_attr.attr,
667 NULL
668 }, {
669 &sensor_dev_attr_pwm4_enable.dev_attr.attr,
670 &sensor_dev_attr_pwm4.dev_attr.attr,
671 NULL
672 }
673};
674
675static const struct attribute_group pc87427_group_pwm[4] = {
676 { .attrs = pc87427_attributes_pwm[0] },
677 { .attrs = pc87427_attributes_pwm[1] },
678 { .attrs = pc87427_attributes_pwm[2] },
679 { .attrs = pc87427_attributes_pwm[3] },
680};
681
008e5f33
JD		 682static ssize_t show_temp_input(struct device *dev, struct device_attribute
683 *devattr, char *buf)
684{
685 struct pc87427_data *data = pc87427_update_device(dev);
686 int nr = to_sensor_dev_attr(devattr)->index;
687
688 return sprintf(buf, "%ld\n", temp_from_reg(data->temp[nr]));
689}
690
691static ssize_t show_temp_min(struct device *dev, struct device_attribute
692 *devattr, char *buf)
693{
694 struct pc87427_data *data = pc87427_update_device(dev);
695 int nr = to_sensor_dev_attr(devattr)->index;
696
697 return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_min[nr]));
698}
699
700static ssize_t show_temp_max(struct device *dev, struct device_attribute
701 *devattr, char *buf)
702{
703 struct pc87427_data *data = pc87427_update_device(dev);
704 int nr = to_sensor_dev_attr(devattr)->index;
705
706 return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_max[nr]));
707}
708
709static ssize_t show_temp_crit(struct device *dev, struct device_attribute
710 *devattr, char *buf)
711{
712 struct pc87427_data *data = pc87427_update_device(dev);
713 int nr = to_sensor_dev_attr(devattr)->index;
714
715 return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_crit[nr]));
716}
717
718static ssize_t show_temp_type(struct device *dev, struct device_attribute
719 *devattr, char *buf)
720{
721 struct pc87427_data *data = pc87427_update_device(dev);
722 int nr = to_sensor_dev_attr(devattr)->index;
723
724 return sprintf(buf, "%u\n", temp_type_from_reg(data->temp_type[nr]));
725}
726
727static ssize_t show_temp_min_alarm(struct device *dev, struct device_attribute
728 *devattr, char *buf)
729{
730 struct pc87427_data *data = pc87427_update_device(dev);
731 int nr = to_sensor_dev_attr(devattr)->index;
732
733 return sprintf(buf, "%d\n", !!(data->temp_status[nr]
734 & TEMP_STATUS_LOWFLG));
735}
736
737static ssize_t show_temp_max_alarm(struct device *dev, struct device_attribute
738 *devattr, char *buf)
739{
740 struct pc87427_data *data = pc87427_update_device(dev);
741 int nr = to_sensor_dev_attr(devattr)->index;
742
743 return sprintf(buf, "%d\n", !!(data->temp_status[nr]
744 & TEMP_STATUS_HIGHFLG));
745}
746
747static ssize_t show_temp_crit_alarm(struct device *dev, struct device_attribute
748 *devattr, char *buf)
749{
750 struct pc87427_data *data = pc87427_update_device(dev);
751 int nr = to_sensor_dev_attr(devattr)->index;
752
753 return sprintf(buf, "%d\n", !!(data->temp_status[nr]
754 & TEMP_STATUS_CRITFLG));
755}
756
757static ssize_t show_temp_fault(struct device *dev, struct device_attribute
758 *devattr, char *buf)
759{
760 struct pc87427_data *data = pc87427_update_device(dev);
761 int nr = to_sensor_dev_attr(devattr)->index;
762
763 return sprintf(buf, "%d\n", !!(data->temp_status[nr]
764 & TEMP_STATUS_SENSERR));
765}
766
767static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
768static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1);
769static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp_input, NULL, 2);
770static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp_input, NULL, 3);
771static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp_input, NULL, 4);
772static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp_input, NULL, 5);
773
774static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO, show_temp_min, NULL, 0);
775static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO, show_temp_min, NULL, 1);
776static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO, show_temp_min, NULL, 2);
777static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO, show_temp_min, NULL, 3);
778static SENSOR_DEVICE_ATTR(temp5_min, S_IRUGO, show_temp_min, NULL, 4);
779static SENSOR_DEVICE_ATTR(temp6_min, S_IRUGO, show_temp_min, NULL, 5);
780
781static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp_max, NULL, 0);
782static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO, show_temp_max, NULL, 1);
783static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO, show_temp_max, NULL, 2);
784static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO, show_temp_max, NULL, 3);
785static SENSOR_DEVICE_ATTR(temp5_max, S_IRUGO, show_temp_max, NULL, 4);
786static SENSOR_DEVICE_ATTR(temp6_max, S_IRUGO, show_temp_max, NULL, 5);
787
788static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, show_temp_crit, NULL, 0);
789static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO, show_temp_crit, NULL, 1);
790static SENSOR_DEVICE_ATTR(temp3_crit, S_IRUGO, show_temp_crit, NULL, 2);
791static SENSOR_DEVICE_ATTR(temp4_crit, S_IRUGO, show_temp_crit, NULL, 3);
792static SENSOR_DEVICE_ATTR(temp5_crit, S_IRUGO, show_temp_crit, NULL, 4);
793static SENSOR_DEVICE_ATTR(temp6_crit, S_IRUGO, show_temp_crit, NULL, 5);
794
795static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0);
796static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1);
797static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2);
798static SENSOR_DEVICE_ATTR(temp4_type, S_IRUGO, show_temp_type, NULL, 3);
799static SENSOR_DEVICE_ATTR(temp5_type, S_IRUGO, show_temp_type, NULL, 4);
800static SENSOR_DEVICE_ATTR(temp6_type, S_IRUGO, show_temp_type, NULL, 5);
801
802static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO,
803 show_temp_min_alarm, NULL, 0);
804static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO,
805 show_temp_min_alarm, NULL, 1);
806static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO,
807 show_temp_min_alarm, NULL, 2);
808static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO,
809 show_temp_min_alarm, NULL, 3);
810static SENSOR_DEVICE_ATTR(temp5_min_alarm, S_IRUGO,
811 show_temp_min_alarm, NULL, 4);
812static SENSOR_DEVICE_ATTR(temp6_min_alarm, S_IRUGO,
813 show_temp_min_alarm, NULL, 5);
814
815static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO,
816 show_temp_max_alarm, NULL, 0);
817static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO,
818 show_temp_max_alarm, NULL, 1);
819static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO,
820 show_temp_max_alarm, NULL, 2);
821static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO,
822 show_temp_max_alarm, NULL, 3);
823static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO,
824 show_temp_max_alarm, NULL, 4);
825static SENSOR_DEVICE_ATTR(temp6_max_alarm, S_IRUGO,
826 show_temp_max_alarm, NULL, 5);
827
828static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO,
829 show_temp_crit_alarm, NULL, 0);
830static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO,
831 show_temp_crit_alarm, NULL, 1);
832static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO,
833 show_temp_crit_alarm, NULL, 2);
834static SENSOR_DEVICE_ATTR(temp4_crit_alarm, S_IRUGO,
835 show_temp_crit_alarm, NULL, 3);
836static SENSOR_DEVICE_ATTR(temp5_crit_alarm, S_IRUGO,
837 show_temp_crit_alarm, NULL, 4);
838static SENSOR_DEVICE_ATTR(temp6_crit_alarm, S_IRUGO,
839 show_temp_crit_alarm, NULL, 5);
840
841static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
842static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
843static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2);
844static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_temp_fault, NULL, 3);
845static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_temp_fault, NULL, 4);
846static SENSOR_DEVICE_ATTR(temp6_fault, S_IRUGO, show_temp_fault, NULL, 5);
847
848static struct attribute *pc87427_attributes_temp[6][10] = {
849 {
850 &sensor_dev_attr_temp1_input.dev_attr.attr,
851 &sensor_dev_attr_temp1_min.dev_attr.attr,
852 &sensor_dev_attr_temp1_max.dev_attr.attr,
853 &sensor_dev_attr_temp1_crit.dev_attr.attr,
854 &sensor_dev_attr_temp1_type.dev_attr.attr,
855 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
856 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
857 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
858 &sensor_dev_attr_temp1_fault.dev_attr.attr,
859 NULL
860 }, {
861 &sensor_dev_attr_temp2_input.dev_attr.attr,
862 &sensor_dev_attr_temp2_min.dev_attr.attr,
863 &sensor_dev_attr_temp2_max.dev_attr.attr,
864 &sensor_dev_attr_temp2_crit.dev_attr.attr,
865 &sensor_dev_attr_temp2_type.dev_attr.attr,
866 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
867 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
868 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
869 &sensor_dev_attr_temp2_fault.dev_attr.attr,
870 NULL
871 }, {
872 &sensor_dev_attr_temp3_input.dev_attr.attr,
873 &sensor_dev_attr_temp3_min.dev_attr.attr,
874 &sensor_dev_attr_temp3_max.dev_attr.attr,
875 &sensor_dev_attr_temp3_crit.dev_attr.attr,
876 &sensor_dev_attr_temp3_type.dev_attr.attr,
877 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
878 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
879 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
880 &sensor_dev_attr_temp3_fault.dev_attr.attr,
881 NULL
882 }, {
883 &sensor_dev_attr_temp4_input.dev_attr.attr,
884 &sensor_dev_attr_temp4_min.dev_attr.attr,
885 &sensor_dev_attr_temp4_max.dev_attr.attr,
886 &sensor_dev_attr_temp4_crit.dev_attr.attr,
887 &sensor_dev_attr_temp4_type.dev_attr.attr,
888 &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
889 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
890 &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr,
891 &sensor_dev_attr_temp4_fault.dev_attr.attr,
892 NULL
893 }, {
894 &sensor_dev_attr_temp5_input.dev_attr.attr,
895 &sensor_dev_attr_temp5_min.dev_attr.attr,
896 &sensor_dev_attr_temp5_max.dev_attr.attr,
897 &sensor_dev_attr_temp5_crit.dev_attr.attr,
898 &sensor_dev_attr_temp5_type.dev_attr.attr,
899 &sensor_dev_attr_temp5_min_alarm.dev_attr.attr,
900 &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
901 &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr,
902 &sensor_dev_attr_temp5_fault.dev_attr.attr,
903 NULL
904 }, {
905 &sensor_dev_attr_temp6_input.dev_attr.attr,
906 &sensor_dev_attr_temp6_min.dev_attr.attr,
907 &sensor_dev_attr_temp6_max.dev_attr.attr,
908 &sensor_dev_attr_temp6_crit.dev_attr.attr,
909 &sensor_dev_attr_temp6_type.dev_attr.attr,
910 &sensor_dev_attr_temp6_min_alarm.dev_attr.attr,
911 &sensor_dev_attr_temp6_max_alarm.dev_attr.attr,
912 &sensor_dev_attr_temp6_crit_alarm.dev_attr.attr,
913 &sensor_dev_attr_temp6_fault.dev_attr.attr,
914 NULL
915 }
916};
917
918static const struct attribute_group pc87427_group_temp[6] = {
919 { .attrs = pc87427_attributes_temp[0] },
920 { .attrs = pc87427_attributes_temp[1] },
921 { .attrs = pc87427_attributes_temp[2] },
922 { .attrs = pc87427_attributes_temp[3] },
923 { .attrs = pc87427_attributes_temp[4] },
924 { .attrs = pc87427_attributes_temp[5] },
925};
926
ba224e2c
JD		 927static ssize_t show_name(struct device *dev, struct device_attribute
928 *devattr, char *buf)
929{
930 struct pc87427_data *data = dev_get_drvdata(dev);
931
932 return sprintf(buf, "%s\n", data->name);
933}
934static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
935
936
937/*
938 * Device detection, attach and detach
939 */
940
9d32df19
JD		 941static void pc87427_release_regions(struct platform_device *pdev, int count)
942{
943 struct resource *res;
944 int i;
945
946 for (i = 0; i < count; i++) {
947 res = platform_get_resource(pdev, IORESOURCE_IO, i);
948 release_region(res->start, resource_size(res));
949 }
950}
951
952static int __devinit pc87427_request_regions(struct platform_device *pdev,
953 int count)
954{
955 struct resource *res;
956 int i, err = 0;
957
958 for (i = 0; i < count; i++) {
959 res = platform_get_resource(pdev, IORESOURCE_IO, i);
960 if (!res) {
961 err = -ENOENT;
962 dev_err(&pdev->dev, "Missing resource #%d\n", i);
963 break;
964 }
965 if (!request_region(res->start, resource_size(res), DRVNAME)) {
966 err = -EBUSY;
967 dev_err(&pdev->dev,
968 "Failed to request region 0x%lx-0x%lx\n",
969 (unsigned long)res->start,
970 (unsigned long)res->end);
971 break;
972 }
973 }
974
975 if (err && i)
976 pc87427_release_regions(pdev, i);
977
978 return err;
979}
980
ba224e2c
JD		 981static void __devinit pc87427_init_device(struct device *dev)
982{
4e7d99e1 983 struct pc87427_sio_data *sio_data = dev->platform_data;
ba224e2c
JD		 984 struct pc87427_data *data = dev_get_drvdata(dev);
985 int i;
986 u8 reg;
987
988 /* The FMC module should be ready */
989 reg = pc87427_read8(data, LD_FAN, PC87427_REG_BANK);
990 if (!(reg & 0x80))
008e5f33 991 dev_warn(dev, "%s module not ready!\n", "FMC");
ba224e2c
JD		 992
993 /* Check which fans are enabled */
994 for (i = 0; i < 8; i++) {
4e7d99e1
JD		 995 if (!(sio_data->has_fanin & (1 << i))) /* Not wired */
996 continue;
ba224e2c
JD		 997 reg = pc87427_read8_bank(data, LD_FAN, BANK_FM(i),
998 PC87427_REG_FAN_STATUS);
999 if (reg & FAN_STATUS_MONEN)
1000 data->fan_enabled |= (1 << i);
1001 }
1002
1003 if (!data->fan_enabled) {
4e7d99e1
JD		 1004 dev_dbg(dev, "Enabling monitoring of all fans\n");
1005 for (i = 0; i < 8; i++) {
1006 if (!(sio_data->has_fanin & (1 << i))) /* Not wired */
1007 continue;
ba224e2c
JD		 1008 pc87427_write8_bank(data, LD_FAN, BANK_FM(i),
1009 PC87427_REG_FAN_STATUS,
1010 FAN_STATUS_MONEN);
4e7d99e1
JD		 1011 }
1012 data->fan_enabled = sio_data->has_fanin;
ba224e2c 1013 }
328716bc
JD		 1014
1015 /* Check which PWM outputs are enabled */
1016 for (i = 0; i < 4; i++) {
1017 if (!(sio_data->has_fanout & (1 << i))) /* Not wired */
1018 continue;
1019 reg = pc87427_read8_bank(data, LD_FAN, BANK_FC(i),
1020 PC87427_REG_PWM_ENABLE);
1021 if (reg & PWM_ENABLE_CTLEN)
1022 data->pwm_enabled |= (1 << i);
1023
1024 /* We don't expose an interface to reconfigure the automatic
1025 fan control mode, so only allow to return to this mode if
1026 it was originally set. */
1027 if ((reg & PWM_ENABLE_MODE_MASK) == PWM_MODE_AUTO) {
1028 dev_dbg(dev, "PWM%d is in automatic control mode\n",
1029 i + 1);
1030 data->pwm_auto_ok |= (1 << i);
1031 }
1032 }
008e5f33
JD		 1033
1034 /* The HMC module should be ready */
1035 reg = pc87427_read8(data, LD_TEMP, PC87427_REG_BANK);
1036 if (!(reg & 0x80))
1037 dev_warn(dev, "%s module not ready!\n", "HMC");
1038
1039 /* Check which temperature channels are enabled */
1040 for (i = 0; i < 6; i++) {
1041 reg = pc87427_read8_bank(data, LD_TEMP, BANK_TM(i),
1042 PC87427_REG_TEMP_STATUS);
1043 if (reg & TEMP_STATUS_CHANEN)
1044 data->temp_enabled |= (1 << i);
1045 }
ba224e2c
JD		 1046}
1047
c6b87246
JD		 1048static void pc87427_remove_files(struct device *dev)
1049{
1050 struct pc87427_data *data = dev_get_drvdata(dev);
1051 int i;
1052
1053 device_remove_file(dev, &dev_attr_name);
1054 for (i = 0; i < 8; i++) {
1055 if (!(data->fan_enabled & (1 << i)))
1056 continue;
1057 sysfs_remove_group(&dev->kobj, &pc87427_group_fan[i]);
1058 }
1059 for (i = 0; i < 4; i++) {
1060 if (!(data->pwm_enabled & (1 << i)))
1061 continue;
1062 sysfs_remove_group(&dev->kobj, &pc87427_group_pwm[i]);
1063 }
1064 for (i = 0; i < 6; i++) {
1065 if (!(data->temp_enabled & (1 << i)))
1066 continue;
1067 sysfs_remove_group(&dev->kobj, &pc87427_group_temp[i]);
1068 }
1069}
1070
ba224e2c
JD		 1071static int __devinit pc87427_probe(struct platform_device *pdev)
1072{
9d32df19 1073 struct pc87427_sio_data *sio_data = pdev->dev.platform_data;
ba224e2c 1074 struct pc87427_data *data;
9d32df19 1075 int i, err, res_count;
ba224e2c 1076
0d22d583
JD		 1077 data = kzalloc(sizeof(struct pc87427_data), GFP_KERNEL);
1078 if (!data) {
ba224e2c
JD		 1079 err = -ENOMEM;
1080 printk(KERN_ERR DRVNAME ": Out of memory\n");
1081 goto exit;
1082 }
1083
9d32df19
JD		 1084 data->address[0] = sio_data->address[0];
1085 data->address[1] = sio_data->address[1];
1086 res_count = (data->address[0] != 0) + (data->address[1] != 0);
1087
1088 err = pc87427_request_regions(pdev, res_count);
1089 if (err)
ce7ee4e8 1090 goto exit_kfree;
ba224e2c
JD		 1091
1092 mutex_init(&data->lock);
1093 data->name = "pc87427";
1094 platform_set_drvdata(pdev, data);
1095 pc87427_init_device(&pdev->dev);
1096
1097 /* Register sysfs hooks */
0d22d583
JD		 1098 err = device_create_file(&pdev->dev, &dev_attr_name);
1099 if (err)
ce7ee4e8 1100 goto exit_release_region;
ba224e2c
JD		 1101 for (i = 0; i < 8; i++) {
1102 if (!(data->fan_enabled & (1 << i)))
1103 continue;
0d22d583
JD		 1104 err = sysfs_create_group(&pdev->dev.kobj,
1105 &pc87427_group_fan[i]);
1106 if (err)
ba224e2c
JD		 1107 goto exit_remove_files;
1108 }
328716bc
JD		 1109 for (i = 0; i < 4; i++) {
1110 if (!(data->pwm_enabled & (1 << i)))
1111 continue;
1112 err = sysfs_create_group(&pdev->dev.kobj,
1113 &pc87427_group_pwm[i]);
1114 if (err)
1115 goto exit_remove_files;
1116 }
008e5f33
JD		 1117 for (i = 0; i < 6; i++) {
1118 if (!(data->temp_enabled & (1 << i)))
1119 continue;
1120 err = sysfs_create_group(&pdev->dev.kobj,
1121 &pc87427_group_temp[i]);
1122 if (err)
1123 goto exit_remove_files;
1124 }
ba224e2c 1125
1beeffe4
TJ		 1126 data->hwmon_dev = hwmon_device_register(&pdev->dev);
1127 if (IS_ERR(data->hwmon_dev)) {
1128 err = PTR_ERR(data->hwmon_dev);
ba224e2c
JD		 1129 dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
1130 goto exit_remove_files;
1131 }
1132
1133 return 0;
1134
1135exit_remove_files:
c6b87246 1136 pc87427_remove_files(&pdev->dev);
ce7ee4e8 1137exit_release_region:
9d32df19 1138 pc87427_release_regions(pdev, res_count);
ba224e2c
JD		 1139exit_kfree:
1140 platform_set_drvdata(pdev, NULL);
1141 kfree(data);
1142exit:
1143 return err;
1144}
1145
1146static int __devexit pc87427_remove(struct platform_device *pdev)
1147{
1148 struct pc87427_data *data = platform_get_drvdata(pdev);
c6b87246 1149 int res_count;
9d32df19
JD		 1150
1151 res_count = (data->address[0] != 0) + (data->address[1] != 0);
ba224e2c 1152
1beeffe4 1153 hwmon_device_unregister(data->hwmon_dev);
c6b87246 1154 pc87427_remove_files(&pdev->dev);
04a6217d 1155 platform_set_drvdata(pdev, NULL);
ba224e2c
JD		 1156 kfree(data);
1157
9d32df19 1158 pc87427_release_regions(pdev, res_count);
ce7ee4e8 1159
ba224e2c
JD		 1160 return 0;
1161}
1162
1163
1164static struct platform_driver pc87427_driver = {
1165 .driver = {
1166 .owner = THIS_MODULE,
1167 .name = DRVNAME,
1168 },
1169 .probe = pc87427_probe,
1170 .remove = __devexit_p(pc87427_remove),
1171};
1172
9d32df19 1173static int __init pc87427_device_add(const struct pc87427_sio_data *sio_data)
ba224e2c 1174{
9d32df19
JD		 1175 struct resource res[2] = {
1176 { .flags = IORESOURCE_IO },
1177 { .flags = IORESOURCE_IO },
ba224e2c 1178 };
9d32df19 1179 int err, i, res_count;
ba224e2c 1180
9d32df19
JD		 1181 res_count = 0;
1182 for (i = 0; i < 2; i++) {
1183 if (!sio_data->address[i])
1184 continue;
1185 res[res_count].start = sio_data->address[i];
1186 res[res_count].end = sio_data->address[i] + REGION_LENGTH - 1;
1187 res[res_count].name = logdev_str[i];
b9acb64a 1188
9d32df19
JD		 1189 err = acpi_check_resource_conflict(&res[res_count]);
1190 if (err)
1191 goto exit;
1192
1193 res_count++;
1194 }
1195
1196 pdev = platform_device_alloc(DRVNAME, res[0].start);
ba224e2c
JD		 1197 if (!pdev) {
1198 err = -ENOMEM;
1199 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
1200 goto exit;
1201 }
1202
9d32df19 1203 err = platform_device_add_resources(pdev, res, res_count);
ba224e2c
JD		 1204 if (err) {
1205 printk(KERN_ERR DRVNAME ": Device resource addition failed "
1206 "(%d)\n", err);
1207 goto exit_device_put;
1208 }
1209
4e7d99e1
JD		 1210 err = platform_device_add_data(pdev, sio_data,
1211 sizeof(struct pc87427_sio_data));
1212 if (err) {
1213 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
1214 goto exit_device_put;
1215 }
1216
ba224e2c
JD		 1217 err = platform_device_add(pdev);
1218 if (err) {
1219 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
1220 err);
1221 goto exit_device_put;
1222 }
1223
1224 return 0;
1225
1226exit_device_put:
1227 platform_device_put(pdev);
1228exit:
1229 return err;
1230}
1231
9d32df19 1232static int __init pc87427_find(int sioaddr, struct pc87427_sio_data *sio_data)
ba224e2c
JD		 1233{
1234 u16 val;
4e7d99e1 1235 u8 cfg, cfg_b;
ba224e2c
JD		 1236 int i, err = 0;
1237
1238 /* Identify device */
67b671bc 1239 val = force_id ? force_id : superio_inb(sioaddr, SIOREG_DEVID);
ba224e2c
JD		 1240 if (val != 0xf2) { /* PC87427 */
1241 err = -ENODEV;
1242 goto exit;
1243 }
1244
1245 for (i = 0; i < 2; i++) {
9d32df19 1246 sio_data->address[i] = 0;
ba224e2c
JD		 1247 /* Select logical device */
1248 superio_outb(sioaddr, SIOREG_LDSEL, logdev[i]);
1249
1250 val = superio_inb(sioaddr, SIOREG_ACT);
1251 if (!(val & 0x01)) {
1252 printk(KERN_INFO DRVNAME ": Logical device 0x%02x "
1253 "not activated\n", logdev[i]);
1254 continue;
1255 }
1256
1257 val = superio_inb(sioaddr, SIOREG_MAP);
1258 if (val & 0x01) {
1259 printk(KERN_WARNING DRVNAME ": Logical device 0x%02x "
1260 "is memory-mapped, can't use\n", logdev[i]);
1261 continue;
1262 }
1263
1264 val = (superio_inb(sioaddr, SIOREG_IOBASE) << 8)
1265 | superio_inb(sioaddr, SIOREG_IOBASE + 1);
1266 if (!val) {
1267 printk(KERN_INFO DRVNAME ": I/O base address not set "
1268 "for logical device 0x%02x\n", logdev[i]);
1269 continue;
1270 }
9d32df19
JD		 1271 sio_data->address[i] = val;
1272 }
1273
1274 /* No point in loading the driver if everything is disabled */
1275 if (!sio_data->address[0] && !sio_data->address[1]) {
1276 err = -ENODEV;
1277 goto exit;
ba224e2c
JD		 1278 }
1279
4e7d99e1
JD		 1280 /* Check which fan inputs are wired */
1281 sio_data->has_fanin = (1 << 2) | (1 << 3); /* FANIN2, FANIN3 */
1282
1283 cfg = superio_inb(sioaddr, SIOREG_CF2);
1284 if (!(cfg & (1 << 3)))
1285 sio_data->has_fanin |= (1 << 0); /* FANIN0 */
1286 if (!(cfg & (1 << 2)))
1287 sio_data->has_fanin |= (1 << 4); /* FANIN4 */
1288
1289 cfg = superio_inb(sioaddr, SIOREG_CFD);
1290 if (!(cfg & (1 << 0)))
1291 sio_data->has_fanin |= (1 << 1); /* FANIN1 */
1292
1293 cfg = superio_inb(sioaddr, SIOREG_CF4);
1294 if (!(cfg & (1 << 0)))
1295 sio_data->has_fanin |= (1 << 7); /* FANIN7 */
1296 cfg_b = superio_inb(sioaddr, SIOREG_CFB);
1297 if (!(cfg & (1 << 1)) && (cfg_b & (1 << 3)))
1298 sio_data->has_fanin |= (1 << 5); /* FANIN5 */
1299 cfg = superio_inb(sioaddr, SIOREG_CF3);
1300 if ((cfg & (1 << 3)) && !(cfg_b & (1 << 5)))
1301 sio_data->has_fanin |= (1 << 6); /* FANIN6 */
1302
328716bc
JD		 1303 /* Check which fan outputs are wired */
1304 sio_data->has_fanout = (1 << 0); /* FANOUT0 */
1305 if (cfg_b & (1 << 0))
1306 sio_data->has_fanout |= (1 << 3); /* FANOUT3 */
1307
1308 cfg = superio_inb(sioaddr, SIOREG_CFC);
1309 if (!(cfg & (1 << 4))) {
1310 if (cfg_b & (1 << 1))
1311 sio_data->has_fanout |= (1 << 1); /* FANOUT1 */
1312 if (cfg_b & (1 << 2))
1313 sio_data->has_fanout |= (1 << 2); /* FANOUT2 */
1314 }
1315
1316 /* FANOUT1 and FANOUT2 can each be routed to 2 different pins */
1317 cfg = superio_inb(sioaddr, SIOREG_CF5);
1318 if (cfg & (1 << 6))
1319 sio_data->has_fanout |= (1 << 1); /* FANOUT1 */
1320 if (cfg & (1 << 5))
1321 sio_data->has_fanout |= (1 << 2); /* FANOUT2 */
1322
ba224e2c
JD		 1323exit:
1324 superio_exit(sioaddr);
1325 return err;
1326}
1327
1328static int __init pc87427_init(void)
1329{
1330 int err;
4e7d99e1 1331 struct pc87427_sio_data sio_data;
ba224e2c 1332
9d32df19
JD		 1333 if (pc87427_find(0x2e, &sio_data)
1334 && pc87427_find(0x4e, &sio_data))
ba224e2c
JD		 1335 return -ENODEV;
1336
1337 err = platform_driver_register(&pc87427_driver);
1338 if (err)
1339 goto exit;
1340
1341 /* Sets global pdev as a side effect */
9d32df19 1342 err = pc87427_device_add(&sio_data);
ba224e2c
JD		 1343 if (err)
1344 goto exit_driver;
1345
1346 return 0;
1347
1348exit_driver:
1349 platform_driver_unregister(&pc87427_driver);
1350exit:
1351 return err;
1352}
1353
1354static void __exit pc87427_exit(void)
1355{
1356 platform_device_unregister(pdev);
1357 platform_driver_unregister(&pc87427_driver);
1358}
1359
1360MODULE_AUTHOR("Jean Delvare <[email protected]>");
1361MODULE_DESCRIPTION("PC87427 hardware monitoring driver");
1362MODULE_LICENSE("GPL");
1363
1364module_init(pc87427_init);
1365module_exit(pc87427_exit);
Empty description
This page took 0.617405 seconds and 4 git commands to generate.