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