1 /* 2 * pc87360.c - Part of lm_sensors, Linux kernel modules 3 * for hardware monitoring 4 * Copyright (C) 2004, 2007 Jean Delvare <khali@linux-fr.org> 5 * 6 * Copied from smsc47m1.c: 7 * Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 * 23 * Supports the following chips: 24 * 25 * Chip #vin #fan #pwm #temp devid 26 * PC87360 - 2 2 - 0xE1 27 * PC87363 - 2 2 - 0xE8 28 * PC87364 - 3 3 - 0xE4 29 * PC87365 11 3 3 2 0xE5 30 * PC87366 11 3 3 3-4 0xE9 31 * 32 * This driver assumes that no more than one chip is present, and one of 33 * the standard Super-I/O addresses is used (0x2E/0x2F or 0x4E/0x4F). 34 */ 35 36 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 37 38 #include <linux/module.h> 39 #include <linux/init.h> 40 #include <linux/slab.h> 41 #include <linux/jiffies.h> 42 #include <linux/platform_device.h> 43 #include <linux/hwmon.h> 44 #include <linux/hwmon-sysfs.h> 45 #include <linux/hwmon-vid.h> 46 #include <linux/err.h> 47 #include <linux/mutex.h> 48 #include <linux/acpi.h> 49 #include <linux/io.h> 50 51 static u8 devid; 52 static struct platform_device *pdev; 53 static unsigned short extra_isa[3]; 54 static u8 confreg[4]; 55 56 static int init = 1; 57 module_param(init, int, 0); 58 MODULE_PARM_DESC(init, 59 "Chip initialization level:\n" 60 " 0: None\n" 61 "*1: Forcibly enable internal voltage and temperature channels, except in9\n" 62 " 2: Forcibly enable all voltage and temperature channels, except in9\n" 63 " 3: Forcibly enable all voltage and temperature channels, including in9"); 64 65 static unsigned short force_id; 66 module_param(force_id, ushort, 0); 67 MODULE_PARM_DESC(force_id, "Override the detected device ID"); 68 69 /* 70 * Super-I/O registers and operations 71 */ 72 73 #define DEV 0x07 /* Register: Logical device select */ 74 #define DEVID 0x20 /* Register: Device ID */ 75 #define ACT 0x30 /* Register: Device activation */ 76 #define BASE 0x60 /* Register: Base address */ 77 78 #define FSCM 0x09 /* Logical device: fans */ 79 #define VLM 0x0d /* Logical device: voltages */ 80 #define TMS 0x0e /* Logical device: temperatures */ 81 #define LDNI_MAX 3 82 static const u8 logdev[LDNI_MAX] = { FSCM, VLM, TMS }; 83 84 #define LD_FAN 0 85 #define LD_IN 1 86 #define LD_TEMP 2 87 88 static inline void superio_outb(int sioaddr, int reg, int val) 89 { 90 outb(reg, sioaddr); 91 outb(val, sioaddr+1); 92 } 93 94 static inline int superio_inb(int sioaddr, int reg) 95 { 96 outb(reg, sioaddr); 97 return inb(sioaddr+1); 98 } 99 100 static inline void superio_exit(int sioaddr) 101 { 102 outb(0x02, sioaddr); 103 outb(0x02, sioaddr+1); 104 } 105 106 /* 107 * Logical devices 108 */ 109 110 #define PC87360_EXTENT 0x10 111 #define PC87365_REG_BANK 0x09 112 #define NO_BANK 0xff 113 114 /* 115 * Fan registers and conversions 116 */ 117 118 /* nr has to be 0 or 1 (PC87360/87363) or 2 (PC87364/87365/87366) */ 119 #define PC87360_REG_PRESCALE(nr) (0x00 + 2 * (nr)) 120 #define PC87360_REG_PWM(nr) (0x01 + 2 * (nr)) 121 #define PC87360_REG_FAN_MIN(nr) (0x06 + 3 * (nr)) 122 #define PC87360_REG_FAN(nr) (0x07 + 3 * (nr)) 123 #define PC87360_REG_FAN_STATUS(nr) (0x08 + 3 * (nr)) 124 125 #define FAN_FROM_REG(val,div) ((val) == 0 ? 0: \ 126 480000 / ((val)*(div))) 127 #define FAN_TO_REG(val,div) ((val) <= 100 ? 0 : \ 128 480000 / ((val)*(div))) 129 #define FAN_DIV_FROM_REG(val) (1 << ((val >> 5) & 0x03)) 130 #define FAN_STATUS_FROM_REG(val) ((val) & 0x07) 131 132 #define FAN_CONFIG_MONITOR(val,nr) (((val) >> (2 + nr * 3)) & 1) 133 #define FAN_CONFIG_CONTROL(val,nr) (((val) >> (3 + nr * 3)) & 1) 134 #define FAN_CONFIG_INVERT(val,nr) (((val) >> (4 + nr * 3)) & 1) 135 136 #define PWM_FROM_REG(val,inv) ((inv) ? 255 - (val) : (val)) 137 static inline u8 PWM_TO_REG(int val, int inv) 138 { 139 if (inv) 140 val = 255 - val; 141 if (val < 0) 142 return 0; 143 if (val > 255) 144 return 255; 145 return val; 146 } 147 148 /* 149 * Voltage registers and conversions 150 */ 151 152 #define PC87365_REG_IN_CONVRATE 0x07 153 #define PC87365_REG_IN_CONFIG 0x08 154 #define PC87365_REG_IN 0x0B 155 #define PC87365_REG_IN_MIN 0x0D 156 #define PC87365_REG_IN_MAX 0x0C 157 #define PC87365_REG_IN_STATUS 0x0A 158 #define PC87365_REG_IN_ALARMS1 0x00 159 #define PC87365_REG_IN_ALARMS2 0x01 160 #define PC87365_REG_VID 0x06 161 162 #define IN_FROM_REG(val,ref) (((val) * (ref) + 128) / 256) 163 #define IN_TO_REG(val,ref) ((val) < 0 ? 0 : \ 164 (val)*256 >= (ref)*255 ? 255: \ 165 ((val) * 256 + (ref)/2) / (ref)) 166 167 /* 168 * Temperature registers and conversions 169 */ 170 171 #define PC87365_REG_TEMP_CONFIG 0x08 172 #define PC87365_REG_TEMP 0x0B 173 #define PC87365_REG_TEMP_MIN 0x0D 174 #define PC87365_REG_TEMP_MAX 0x0C 175 #define PC87365_REG_TEMP_CRIT 0x0E 176 #define PC87365_REG_TEMP_STATUS 0x0A 177 #define PC87365_REG_TEMP_ALARMS 0x00 178 179 #define TEMP_FROM_REG(val) ((val) * 1000) 180 #define TEMP_TO_REG(val) ((val) < -55000 ? -55 : \ 181 (val) > 127000 ? 127 : \ 182 (val) < 0 ? ((val) - 500) / 1000 : \ 183 ((val) + 500) / 1000) 184 185 /* 186 * Device data 187 */ 188 189 struct pc87360_data { 190 const char *name; 191 struct device *hwmon_dev; 192 struct mutex lock; 193 struct mutex update_lock; 194 char valid; /* !=0 if following fields are valid */ 195 unsigned long last_updated; /* In jiffies */ 196 197 int address[3]; 198 199 u8 fannr, innr, tempnr; 200 201 u8 fan[3]; /* Register value */ 202 u8 fan_min[3]; /* Register value */ 203 u8 fan_status[3]; /* Register value */ 204 u8 pwm[3]; /* Register value */ 205 u16 fan_conf; /* Configuration register values, combined */ 206 207 u16 in_vref; /* 1 mV/bit */ 208 u8 in[14]; /* Register value */ 209 u8 in_min[14]; /* Register value */ 210 u8 in_max[14]; /* Register value */ 211 u8 in_crit[3]; /* Register value */ 212 u8 in_status[14]; /* Register value */ 213 u16 in_alarms; /* Register values, combined, masked */ 214 u8 vid_conf; /* Configuration register value */ 215 u8 vrm; 216 u8 vid; /* Register value */ 217 218 s8 temp[3]; /* Register value */ 219 s8 temp_min[3]; /* Register value */ 220 s8 temp_max[3]; /* Register value */ 221 s8 temp_crit[3]; /* Register value */ 222 u8 temp_status[3]; /* Register value */ 223 u8 temp_alarms; /* Register value, masked */ 224 }; 225 226 /* 227 * Functions declaration 228 */ 229 230 static int pc87360_probe(struct platform_device *pdev); 231 static int __devexit pc87360_remove(struct platform_device *pdev); 232 233 static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank, 234 u8 reg); 235 static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank, 236 u8 reg, u8 value); 237 static void pc87360_init_device(struct platform_device *pdev, 238 int use_thermistors); 239 static struct pc87360_data *pc87360_update_device(struct device *dev); 240 241 /* 242 * Driver data 243 */ 244 245 static struct platform_driver pc87360_driver = { 246 .driver = { 247 .owner = THIS_MODULE, 248 .name = "pc87360", 249 }, 250 .probe = pc87360_probe, 251 .remove = __devexit_p(pc87360_remove), 252 }; 253 254 /* 255 * Sysfs stuff 256 */ 257 258 static ssize_t show_fan_input(struct device *dev, struct device_attribute *devattr, char *buf) 259 { 260 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 261 struct pc87360_data *data = pc87360_update_device(dev); 262 return sprintf(buf, "%u\n", FAN_FROM_REG(data->fan[attr->index], 263 FAN_DIV_FROM_REG(data->fan_status[attr->index]))); 264 } 265 static ssize_t show_fan_min(struct device *dev, struct device_attribute *devattr, char *buf) 266 { 267 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 268 struct pc87360_data *data = pc87360_update_device(dev); 269 return sprintf(buf, "%u\n", FAN_FROM_REG(data->fan_min[attr->index], 270 FAN_DIV_FROM_REG(data->fan_status[attr->index]))); 271 } 272 static ssize_t show_fan_div(struct device *dev, struct device_attribute *devattr, char *buf) 273 { 274 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 275 struct pc87360_data *data = pc87360_update_device(dev); 276 return sprintf(buf, "%u\n", 277 FAN_DIV_FROM_REG(data->fan_status[attr->index])); 278 } 279 static ssize_t show_fan_status(struct device *dev, struct device_attribute *devattr, char *buf) 280 { 281 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 282 struct pc87360_data *data = pc87360_update_device(dev); 283 return sprintf(buf, "%u\n", 284 FAN_STATUS_FROM_REG(data->fan_status[attr->index])); 285 } 286 static ssize_t set_fan_min(struct device *dev, struct device_attribute *devattr, const char *buf, 287 size_t count) 288 { 289 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 290 struct pc87360_data *data = dev_get_drvdata(dev); 291 long fan_min = simple_strtol(buf, NULL, 10); 292 293 mutex_lock(&data->update_lock); 294 fan_min = FAN_TO_REG(fan_min, FAN_DIV_FROM_REG(data->fan_status[attr->index])); 295 296 /* If it wouldn't fit, change clock divisor */ 297 while (fan_min > 255 298 && (data->fan_status[attr->index] & 0x60) != 0x60) { 299 fan_min >>= 1; 300 data->fan[attr->index] >>= 1; 301 data->fan_status[attr->index] += 0x20; 302 } 303 data->fan_min[attr->index] = fan_min > 255 ? 255 : fan_min; 304 pc87360_write_value(data, LD_FAN, NO_BANK, PC87360_REG_FAN_MIN(attr->index), 305 data->fan_min[attr->index]); 306 307 /* Write new divider, preserve alarm bits */ 308 pc87360_write_value(data, LD_FAN, NO_BANK, PC87360_REG_FAN_STATUS(attr->index), 309 data->fan_status[attr->index] & 0xF9); 310 mutex_unlock(&data->update_lock); 311 312 return count; 313 } 314 315 static struct sensor_device_attribute fan_input[] = { 316 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0), 317 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1), 318 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan_input, NULL, 2), 319 }; 320 static struct sensor_device_attribute fan_status[] = { 321 SENSOR_ATTR(fan1_status, S_IRUGO, show_fan_status, NULL, 0), 322 SENSOR_ATTR(fan2_status, S_IRUGO, show_fan_status, NULL, 1), 323 SENSOR_ATTR(fan3_status, S_IRUGO, show_fan_status, NULL, 2), 324 }; 325 static struct sensor_device_attribute fan_div[] = { 326 SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0), 327 SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1), 328 SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2), 329 }; 330 static struct sensor_device_attribute fan_min[] = { 331 SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min, set_fan_min, 0), 332 SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min, set_fan_min, 1), 333 SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min, set_fan_min, 2), 334 }; 335 336 #define FAN_UNIT_ATTRS(X) \ 337 &fan_input[X].dev_attr.attr, \ 338 &fan_status[X].dev_attr.attr, \ 339 &fan_div[X].dev_attr.attr, \ 340 &fan_min[X].dev_attr.attr 341 342 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr, char *buf) 343 { 344 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 345 struct pc87360_data *data = pc87360_update_device(dev); 346 return sprintf(buf, "%u\n", 347 PWM_FROM_REG(data->pwm[attr->index], 348 FAN_CONFIG_INVERT(data->fan_conf, 349 attr->index))); 350 } 351 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, const char *buf, 352 size_t count) 353 { 354 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 355 struct pc87360_data *data = dev_get_drvdata(dev); 356 long val = simple_strtol(buf, NULL, 10); 357 358 mutex_lock(&data->update_lock); 359 data->pwm[attr->index] = PWM_TO_REG(val, 360 FAN_CONFIG_INVERT(data->fan_conf, attr->index)); 361 pc87360_write_value(data, LD_FAN, NO_BANK, PC87360_REG_PWM(attr->index), 362 data->pwm[attr->index]); 363 mutex_unlock(&data->update_lock); 364 return count; 365 } 366 367 static struct sensor_device_attribute pwm[] = { 368 SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0), 369 SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1), 370 SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2), 371 }; 372 373 static struct attribute * pc8736x_fan_attr_array[] = { 374 FAN_UNIT_ATTRS(0), 375 FAN_UNIT_ATTRS(1), 376 FAN_UNIT_ATTRS(2), 377 &pwm[0].dev_attr.attr, 378 &pwm[1].dev_attr.attr, 379 &pwm[2].dev_attr.attr, 380 NULL 381 }; 382 static const struct attribute_group pc8736x_fan_group = { 383 .attrs = pc8736x_fan_attr_array, 384 }; 385 386 static ssize_t show_in_input(struct device *dev, struct device_attribute *devattr, char *buf) 387 { 388 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 389 struct pc87360_data *data = pc87360_update_device(dev); 390 return sprintf(buf, "%u\n", IN_FROM_REG(data->in[attr->index], 391 data->in_vref)); 392 } 393 static ssize_t show_in_min(struct device *dev, struct device_attribute *devattr, char *buf) 394 { 395 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 396 struct pc87360_data *data = pc87360_update_device(dev); 397 return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[attr->index], 398 data->in_vref)); 399 } 400 static ssize_t show_in_max(struct device *dev, struct device_attribute *devattr, char *buf) 401 { 402 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 403 struct pc87360_data *data = pc87360_update_device(dev); 404 return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[attr->index], 405 data->in_vref)); 406 } 407 static ssize_t show_in_status(struct device *dev, struct device_attribute *devattr, char *buf) 408 { 409 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 410 struct pc87360_data *data = pc87360_update_device(dev); 411 return sprintf(buf, "%u\n", data->in_status[attr->index]); 412 } 413 static ssize_t set_in_min(struct device *dev, struct device_attribute *devattr, const char *buf, 414 size_t count) 415 { 416 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 417 struct pc87360_data *data = dev_get_drvdata(dev); 418 long val = simple_strtol(buf, NULL, 10); 419 420 mutex_lock(&data->update_lock); 421 data->in_min[attr->index] = IN_TO_REG(val, data->in_vref); 422 pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_IN_MIN, 423 data->in_min[attr->index]); 424 mutex_unlock(&data->update_lock); 425 return count; 426 } 427 static ssize_t set_in_max(struct device *dev, struct device_attribute *devattr, const char *buf, 428 size_t count) 429 { 430 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 431 struct pc87360_data *data = dev_get_drvdata(dev); 432 long val = simple_strtol(buf, NULL, 10); 433 434 mutex_lock(&data->update_lock); 435 data->in_max[attr->index] = IN_TO_REG(val, 436 data->in_vref); 437 pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_IN_MAX, 438 data->in_max[attr->index]); 439 mutex_unlock(&data->update_lock); 440 return count; 441 } 442 443 static struct sensor_device_attribute in_input[] = { 444 SENSOR_ATTR(in0_input, S_IRUGO, show_in_input, NULL, 0), 445 SENSOR_ATTR(in1_input, S_IRUGO, show_in_input, NULL, 1), 446 SENSOR_ATTR(in2_input, S_IRUGO, show_in_input, NULL, 2), 447 SENSOR_ATTR(in3_input, S_IRUGO, show_in_input, NULL, 3), 448 SENSOR_ATTR(in4_input, S_IRUGO, show_in_input, NULL, 4), 449 SENSOR_ATTR(in5_input, S_IRUGO, show_in_input, NULL, 5), 450 SENSOR_ATTR(in6_input, S_IRUGO, show_in_input, NULL, 6), 451 SENSOR_ATTR(in7_input, S_IRUGO, show_in_input, NULL, 7), 452 SENSOR_ATTR(in8_input, S_IRUGO, show_in_input, NULL, 8), 453 SENSOR_ATTR(in9_input, S_IRUGO, show_in_input, NULL, 9), 454 SENSOR_ATTR(in10_input, S_IRUGO, show_in_input, NULL, 10), 455 }; 456 static struct sensor_device_attribute in_status[] = { 457 SENSOR_ATTR(in0_status, S_IRUGO, show_in_status, NULL, 0), 458 SENSOR_ATTR(in1_status, S_IRUGO, show_in_status, NULL, 1), 459 SENSOR_ATTR(in2_status, S_IRUGO, show_in_status, NULL, 2), 460 SENSOR_ATTR(in3_status, S_IRUGO, show_in_status, NULL, 3), 461 SENSOR_ATTR(in4_status, S_IRUGO, show_in_status, NULL, 4), 462 SENSOR_ATTR(in5_status, S_IRUGO, show_in_status, NULL, 5), 463 SENSOR_ATTR(in6_status, S_IRUGO, show_in_status, NULL, 6), 464 SENSOR_ATTR(in7_status, S_IRUGO, show_in_status, NULL, 7), 465 SENSOR_ATTR(in8_status, S_IRUGO, show_in_status, NULL, 8), 466 SENSOR_ATTR(in9_status, S_IRUGO, show_in_status, NULL, 9), 467 SENSOR_ATTR(in10_status, S_IRUGO, show_in_status, NULL, 10), 468 }; 469 static struct sensor_device_attribute in_min[] = { 470 SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 0), 471 SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 1), 472 SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 2), 473 SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 3), 474 SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 4), 475 SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 5), 476 SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 6), 477 SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 7), 478 SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 8), 479 SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 9), 480 SENSOR_ATTR(in10_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 10), 481 }; 482 static struct sensor_device_attribute in_max[] = { 483 SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 0), 484 SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 1), 485 SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 2), 486 SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 3), 487 SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 4), 488 SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 5), 489 SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 6), 490 SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 7), 491 SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 8), 492 SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 9), 493 SENSOR_ATTR(in10_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 10), 494 }; 495 496 /* (temp & vin) channel status register alarm bits (pdf sec.11.5.12) */ 497 #define CHAN_ALM_MIN 0x02 /* min limit crossed */ 498 #define CHAN_ALM_MAX 0x04 /* max limit exceeded */ 499 #define TEMP_ALM_CRIT 0x08 /* temp crit exceeded (temp only) */ 500 501 /* show_in_min/max_alarm() reads data from the per-channel status 502 register (sec 11.5.12), not the vin event status registers (sec 503 11.5.2) that (legacy) show_in_alarm() resds (via data->in_alarms) */ 504 505 static ssize_t show_in_min_alarm(struct device *dev, 506 struct device_attribute *devattr, char *buf) 507 { 508 struct pc87360_data *data = pc87360_update_device(dev); 509 unsigned nr = to_sensor_dev_attr(devattr)->index; 510 511 return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MIN)); 512 } 513 static ssize_t show_in_max_alarm(struct device *dev, 514 struct device_attribute *devattr, char *buf) 515 { 516 struct pc87360_data *data = pc87360_update_device(dev); 517 unsigned nr = to_sensor_dev_attr(devattr)->index; 518 519 return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MAX)); 520 } 521 522 static struct sensor_device_attribute in_min_alarm[] = { 523 SENSOR_ATTR(in0_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 0), 524 SENSOR_ATTR(in1_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 1), 525 SENSOR_ATTR(in2_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 2), 526 SENSOR_ATTR(in3_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 3), 527 SENSOR_ATTR(in4_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 4), 528 SENSOR_ATTR(in5_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 5), 529 SENSOR_ATTR(in6_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 6), 530 SENSOR_ATTR(in7_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 7), 531 SENSOR_ATTR(in8_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 8), 532 SENSOR_ATTR(in9_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 9), 533 SENSOR_ATTR(in10_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 10), 534 }; 535 static struct sensor_device_attribute in_max_alarm[] = { 536 SENSOR_ATTR(in0_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 0), 537 SENSOR_ATTR(in1_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 1), 538 SENSOR_ATTR(in2_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 2), 539 SENSOR_ATTR(in3_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 3), 540 SENSOR_ATTR(in4_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 4), 541 SENSOR_ATTR(in5_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 5), 542 SENSOR_ATTR(in6_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 6), 543 SENSOR_ATTR(in7_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 7), 544 SENSOR_ATTR(in8_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 8), 545 SENSOR_ATTR(in9_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 9), 546 SENSOR_ATTR(in10_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 10), 547 }; 548 549 #define VIN_UNIT_ATTRS(X) \ 550 &in_input[X].dev_attr.attr, \ 551 &in_status[X].dev_attr.attr, \ 552 &in_min[X].dev_attr.attr, \ 553 &in_max[X].dev_attr.attr, \ 554 &in_min_alarm[X].dev_attr.attr, \ 555 &in_max_alarm[X].dev_attr.attr 556 557 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf) 558 { 559 struct pc87360_data *data = pc87360_update_device(dev); 560 return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm)); 561 } 562 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL); 563 564 static ssize_t show_vrm(struct device *dev, struct device_attribute *attr, char *buf) 565 { 566 struct pc87360_data *data = dev_get_drvdata(dev); 567 return sprintf(buf, "%u\n", data->vrm); 568 } 569 static ssize_t set_vrm(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 570 { 571 struct pc87360_data *data = dev_get_drvdata(dev); 572 data->vrm = simple_strtoul(buf, NULL, 10); 573 return count; 574 } 575 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm); 576 577 static ssize_t show_in_alarms(struct device *dev, struct device_attribute *attr, char *buf) 578 { 579 struct pc87360_data *data = pc87360_update_device(dev); 580 return sprintf(buf, "%u\n", data->in_alarms); 581 } 582 static DEVICE_ATTR(alarms_in, S_IRUGO, show_in_alarms, NULL); 583 584 static struct attribute *pc8736x_vin_attr_array[] = { 585 VIN_UNIT_ATTRS(0), 586 VIN_UNIT_ATTRS(1), 587 VIN_UNIT_ATTRS(2), 588 VIN_UNIT_ATTRS(3), 589 VIN_UNIT_ATTRS(4), 590 VIN_UNIT_ATTRS(5), 591 VIN_UNIT_ATTRS(6), 592 VIN_UNIT_ATTRS(7), 593 VIN_UNIT_ATTRS(8), 594 VIN_UNIT_ATTRS(9), 595 VIN_UNIT_ATTRS(10), 596 &dev_attr_cpu0_vid.attr, 597 &dev_attr_vrm.attr, 598 &dev_attr_alarms_in.attr, 599 NULL 600 }; 601 static const struct attribute_group pc8736x_vin_group = { 602 .attrs = pc8736x_vin_attr_array, 603 }; 604 605 static ssize_t show_therm_input(struct device *dev, struct device_attribute *devattr, char *buf) 606 { 607 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 608 struct pc87360_data *data = pc87360_update_device(dev); 609 return sprintf(buf, "%u\n", IN_FROM_REG(data->in[attr->index], 610 data->in_vref)); 611 } 612 static ssize_t show_therm_min(struct device *dev, struct device_attribute *devattr, char *buf) 613 { 614 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 615 struct pc87360_data *data = pc87360_update_device(dev); 616 return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[attr->index], 617 data->in_vref)); 618 } 619 static ssize_t show_therm_max(struct device *dev, struct device_attribute *devattr, char *buf) 620 { 621 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 622 struct pc87360_data *data = pc87360_update_device(dev); 623 return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[attr->index], 624 data->in_vref)); 625 } 626 static ssize_t show_therm_crit(struct device *dev, struct device_attribute *devattr, char *buf) 627 { 628 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 629 struct pc87360_data *data = pc87360_update_device(dev); 630 return sprintf(buf, "%u\n", IN_FROM_REG(data->in_crit[attr->index-11], 631 data->in_vref)); 632 } 633 static ssize_t show_therm_status(struct device *dev, struct device_attribute *devattr, char *buf) 634 { 635 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 636 struct pc87360_data *data = pc87360_update_device(dev); 637 return sprintf(buf, "%u\n", data->in_status[attr->index]); 638 } 639 static ssize_t set_therm_min(struct device *dev, struct device_attribute *devattr, const char *buf, 640 size_t count) 641 { 642 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 643 struct pc87360_data *data = dev_get_drvdata(dev); 644 long val = simple_strtol(buf, NULL, 10); 645 646 mutex_lock(&data->update_lock); 647 data->in_min[attr->index] = IN_TO_REG(val, data->in_vref); 648 pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_MIN, 649 data->in_min[attr->index]); 650 mutex_unlock(&data->update_lock); 651 return count; 652 } 653 static ssize_t set_therm_max(struct device *dev, struct device_attribute *devattr, const char *buf, 654 size_t count) 655 { 656 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 657 struct pc87360_data *data = dev_get_drvdata(dev); 658 long val = simple_strtol(buf, NULL, 10); 659 660 mutex_lock(&data->update_lock); 661 data->in_max[attr->index] = IN_TO_REG(val, data->in_vref); 662 pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_MAX, 663 data->in_max[attr->index]); 664 mutex_unlock(&data->update_lock); 665 return count; 666 } 667 static ssize_t set_therm_crit(struct device *dev, struct device_attribute *devattr, const char *buf, 668 size_t count) 669 { 670 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 671 struct pc87360_data *data = dev_get_drvdata(dev); 672 long val = simple_strtol(buf, NULL, 10); 673 674 mutex_lock(&data->update_lock); 675 data->in_crit[attr->index-11] = IN_TO_REG(val, data->in_vref); 676 pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_CRIT, 677 data->in_crit[attr->index-11]); 678 mutex_unlock(&data->update_lock); 679 return count; 680 } 681 682 /* the +11 term below reflects the fact that VLM units 11,12,13 are 683 used in the chip to measure voltage across the thermistors 684 */ 685 static struct sensor_device_attribute therm_input[] = { 686 SENSOR_ATTR(temp4_input, S_IRUGO, show_therm_input, NULL, 0+11), 687 SENSOR_ATTR(temp5_input, S_IRUGO, show_therm_input, NULL, 1+11), 688 SENSOR_ATTR(temp6_input, S_IRUGO, show_therm_input, NULL, 2+11), 689 }; 690 static struct sensor_device_attribute therm_status[] = { 691 SENSOR_ATTR(temp4_status, S_IRUGO, show_therm_status, NULL, 0+11), 692 SENSOR_ATTR(temp5_status, S_IRUGO, show_therm_status, NULL, 1+11), 693 SENSOR_ATTR(temp6_status, S_IRUGO, show_therm_status, NULL, 2+11), 694 }; 695 static struct sensor_device_attribute therm_min[] = { 696 SENSOR_ATTR(temp4_min, S_IRUGO | S_IWUSR, 697 show_therm_min, set_therm_min, 0+11), 698 SENSOR_ATTR(temp5_min, S_IRUGO | S_IWUSR, 699 show_therm_min, set_therm_min, 1+11), 700 SENSOR_ATTR(temp6_min, S_IRUGO | S_IWUSR, 701 show_therm_min, set_therm_min, 2+11), 702 }; 703 static struct sensor_device_attribute therm_max[] = { 704 SENSOR_ATTR(temp4_max, S_IRUGO | S_IWUSR, 705 show_therm_max, set_therm_max, 0+11), 706 SENSOR_ATTR(temp5_max, S_IRUGO | S_IWUSR, 707 show_therm_max, set_therm_max, 1+11), 708 SENSOR_ATTR(temp6_max, S_IRUGO | S_IWUSR, 709 show_therm_max, set_therm_max, 2+11), 710 }; 711 static struct sensor_device_attribute therm_crit[] = { 712 SENSOR_ATTR(temp4_crit, S_IRUGO | S_IWUSR, 713 show_therm_crit, set_therm_crit, 0+11), 714 SENSOR_ATTR(temp5_crit, S_IRUGO | S_IWUSR, 715 show_therm_crit, set_therm_crit, 1+11), 716 SENSOR_ATTR(temp6_crit, S_IRUGO | S_IWUSR, 717 show_therm_crit, set_therm_crit, 2+11), 718 }; 719 720 /* show_therm_min/max_alarm() reads data from the per-channel voltage 721 status register (sec 11.5.12) */ 722 723 static ssize_t show_therm_min_alarm(struct device *dev, 724 struct device_attribute *devattr, char *buf) 725 { 726 struct pc87360_data *data = pc87360_update_device(dev); 727 unsigned nr = to_sensor_dev_attr(devattr)->index; 728 729 return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MIN)); 730 } 731 static ssize_t show_therm_max_alarm(struct device *dev, 732 struct device_attribute *devattr, char *buf) 733 { 734 struct pc87360_data *data = pc87360_update_device(dev); 735 unsigned nr = to_sensor_dev_attr(devattr)->index; 736 737 return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MAX)); 738 } 739 static ssize_t show_therm_crit_alarm(struct device *dev, 740 struct device_attribute *devattr, char *buf) 741 { 742 struct pc87360_data *data = pc87360_update_device(dev); 743 unsigned nr = to_sensor_dev_attr(devattr)->index; 744 745 return sprintf(buf, "%u\n", !!(data->in_status[nr] & TEMP_ALM_CRIT)); 746 } 747 748 static struct sensor_device_attribute therm_min_alarm[] = { 749 SENSOR_ATTR(temp4_min_alarm, S_IRUGO, 750 show_therm_min_alarm, NULL, 0+11), 751 SENSOR_ATTR(temp5_min_alarm, S_IRUGO, 752 show_therm_min_alarm, NULL, 1+11), 753 SENSOR_ATTR(temp6_min_alarm, S_IRUGO, 754 show_therm_min_alarm, NULL, 2+11), 755 }; 756 static struct sensor_device_attribute therm_max_alarm[] = { 757 SENSOR_ATTR(temp4_max_alarm, S_IRUGO, 758 show_therm_max_alarm, NULL, 0+11), 759 SENSOR_ATTR(temp5_max_alarm, S_IRUGO, 760 show_therm_max_alarm, NULL, 1+11), 761 SENSOR_ATTR(temp6_max_alarm, S_IRUGO, 762 show_therm_max_alarm, NULL, 2+11), 763 }; 764 static struct sensor_device_attribute therm_crit_alarm[] = { 765 SENSOR_ATTR(temp4_crit_alarm, S_IRUGO, 766 show_therm_crit_alarm, NULL, 0+11), 767 SENSOR_ATTR(temp5_crit_alarm, S_IRUGO, 768 show_therm_crit_alarm, NULL, 1+11), 769 SENSOR_ATTR(temp6_crit_alarm, S_IRUGO, 770 show_therm_crit_alarm, NULL, 2+11), 771 }; 772 773 #define THERM_UNIT_ATTRS(X) \ 774 &therm_input[X].dev_attr.attr, \ 775 &therm_status[X].dev_attr.attr, \ 776 &therm_min[X].dev_attr.attr, \ 777 &therm_max[X].dev_attr.attr, \ 778 &therm_crit[X].dev_attr.attr, \ 779 &therm_min_alarm[X].dev_attr.attr, \ 780 &therm_max_alarm[X].dev_attr.attr, \ 781 &therm_crit_alarm[X].dev_attr.attr 782 783 static struct attribute * pc8736x_therm_attr_array[] = { 784 THERM_UNIT_ATTRS(0), 785 THERM_UNIT_ATTRS(1), 786 THERM_UNIT_ATTRS(2), 787 NULL 788 }; 789 static const struct attribute_group pc8736x_therm_group = { 790 .attrs = pc8736x_therm_attr_array, 791 }; 792 793 static ssize_t show_temp_input(struct device *dev, struct device_attribute *devattr, char *buf) 794 { 795 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 796 struct pc87360_data *data = pc87360_update_device(dev); 797 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[attr->index])); 798 } 799 static ssize_t show_temp_min(struct device *dev, struct device_attribute *devattr, char *buf) 800 { 801 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 802 struct pc87360_data *data = pc87360_update_device(dev); 803 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[attr->index])); 804 } 805 static ssize_t show_temp_max(struct device *dev, struct device_attribute *devattr, char *buf) 806 { 807 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 808 struct pc87360_data *data = pc87360_update_device(dev); 809 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[attr->index])); 810 } 811 static ssize_t show_temp_crit(struct device *dev, struct device_attribute *devattr, char *buf) 812 { 813 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 814 struct pc87360_data *data = pc87360_update_device(dev); 815 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[attr->index])); 816 } 817 static ssize_t show_temp_status(struct device *dev, struct device_attribute *devattr, char *buf) 818 { 819 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 820 struct pc87360_data *data = pc87360_update_device(dev); 821 return sprintf(buf, "%d\n", data->temp_status[attr->index]); 822 } 823 static ssize_t set_temp_min(struct device *dev, struct device_attribute *devattr, const char *buf, 824 size_t count) 825 { 826 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 827 struct pc87360_data *data = dev_get_drvdata(dev); 828 long val = simple_strtol(buf, NULL, 10); 829 830 mutex_lock(&data->update_lock); 831 data->temp_min[attr->index] = TEMP_TO_REG(val); 832 pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_MIN, 833 data->temp_min[attr->index]); 834 mutex_unlock(&data->update_lock); 835 return count; 836 } 837 static ssize_t set_temp_max(struct device *dev, struct device_attribute *devattr, const char *buf, 838 size_t count) 839 { 840 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 841 struct pc87360_data *data = dev_get_drvdata(dev); 842 long val = simple_strtol(buf, NULL, 10); 843 844 mutex_lock(&data->update_lock); 845 data->temp_max[attr->index] = TEMP_TO_REG(val); 846 pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_MAX, 847 data->temp_max[attr->index]); 848 mutex_unlock(&data->update_lock); 849 return count; 850 } 851 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *devattr, const char *buf, 852 size_t count) 853 { 854 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 855 struct pc87360_data *data = dev_get_drvdata(dev); 856 long val = simple_strtol(buf, NULL, 10); 857 858 mutex_lock(&data->update_lock); 859 data->temp_crit[attr->index] = TEMP_TO_REG(val); 860 pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_CRIT, 861 data->temp_crit[attr->index]); 862 mutex_unlock(&data->update_lock); 863 return count; 864 } 865 866 static struct sensor_device_attribute temp_input[] = { 867 SENSOR_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0), 868 SENSOR_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1), 869 SENSOR_ATTR(temp3_input, S_IRUGO, show_temp_input, NULL, 2), 870 }; 871 static struct sensor_device_attribute temp_status[] = { 872 SENSOR_ATTR(temp1_status, S_IRUGO, show_temp_status, NULL, 0), 873 SENSOR_ATTR(temp2_status, S_IRUGO, show_temp_status, NULL, 1), 874 SENSOR_ATTR(temp3_status, S_IRUGO, show_temp_status, NULL, 2), 875 }; 876 static struct sensor_device_attribute temp_min[] = { 877 SENSOR_ATTR(temp1_min, S_IRUGO | S_IWUSR, 878 show_temp_min, set_temp_min, 0), 879 SENSOR_ATTR(temp2_min, S_IRUGO | S_IWUSR, 880 show_temp_min, set_temp_min, 1), 881 SENSOR_ATTR(temp3_min, S_IRUGO | S_IWUSR, 882 show_temp_min, set_temp_min, 2), 883 }; 884 static struct sensor_device_attribute temp_max[] = { 885 SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, 886 show_temp_max, set_temp_max, 0), 887 SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, 888 show_temp_max, set_temp_max, 1), 889 SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, 890 show_temp_max, set_temp_max, 2), 891 }; 892 static struct sensor_device_attribute temp_crit[] = { 893 SENSOR_ATTR(temp1_crit, S_IRUGO | S_IWUSR, 894 show_temp_crit, set_temp_crit, 0), 895 SENSOR_ATTR(temp2_crit, S_IRUGO | S_IWUSR, 896 show_temp_crit, set_temp_crit, 1), 897 SENSOR_ATTR(temp3_crit, S_IRUGO | S_IWUSR, 898 show_temp_crit, set_temp_crit, 2), 899 }; 900 901 static ssize_t show_temp_alarms(struct device *dev, struct device_attribute *attr, char *buf) 902 { 903 struct pc87360_data *data = pc87360_update_device(dev); 904 return sprintf(buf, "%u\n", data->temp_alarms); 905 } 906 static DEVICE_ATTR(alarms_temp, S_IRUGO, show_temp_alarms, NULL); 907 908 /* show_temp_min/max_alarm() reads data from the per-channel status 909 register (sec 12.3.7), not the temp event status registers (sec 910 12.3.2) that show_temp_alarm() reads (via data->temp_alarms) */ 911 912 static ssize_t show_temp_min_alarm(struct device *dev, 913 struct device_attribute *devattr, char *buf) 914 { 915 struct pc87360_data *data = pc87360_update_device(dev); 916 unsigned nr = to_sensor_dev_attr(devattr)->index; 917 918 return sprintf(buf, "%u\n", !!(data->temp_status[nr] & CHAN_ALM_MIN)); 919 } 920 static ssize_t show_temp_max_alarm(struct device *dev, 921 struct device_attribute *devattr, char *buf) 922 { 923 struct pc87360_data *data = pc87360_update_device(dev); 924 unsigned nr = to_sensor_dev_attr(devattr)->index; 925 926 return sprintf(buf, "%u\n", !!(data->temp_status[nr] & CHAN_ALM_MAX)); 927 } 928 static ssize_t show_temp_crit_alarm(struct device *dev, 929 struct device_attribute *devattr, char *buf) 930 { 931 struct pc87360_data *data = pc87360_update_device(dev); 932 unsigned nr = to_sensor_dev_attr(devattr)->index; 933 934 return sprintf(buf, "%u\n", !!(data->temp_status[nr] & TEMP_ALM_CRIT)); 935 } 936 937 static struct sensor_device_attribute temp_min_alarm[] = { 938 SENSOR_ATTR(temp1_min_alarm, S_IRUGO, show_temp_min_alarm, NULL, 0), 939 SENSOR_ATTR(temp2_min_alarm, S_IRUGO, show_temp_min_alarm, NULL, 1), 940 SENSOR_ATTR(temp3_min_alarm, S_IRUGO, show_temp_min_alarm, NULL, 2), 941 }; 942 static struct sensor_device_attribute temp_max_alarm[] = { 943 SENSOR_ATTR(temp1_max_alarm, S_IRUGO, show_temp_max_alarm, NULL, 0), 944 SENSOR_ATTR(temp2_max_alarm, S_IRUGO, show_temp_max_alarm, NULL, 1), 945 SENSOR_ATTR(temp3_max_alarm, S_IRUGO, show_temp_max_alarm, NULL, 2), 946 }; 947 static struct sensor_device_attribute temp_crit_alarm[] = { 948 SENSOR_ATTR(temp1_crit_alarm, S_IRUGO, show_temp_crit_alarm, NULL, 0), 949 SENSOR_ATTR(temp2_crit_alarm, S_IRUGO, show_temp_crit_alarm, NULL, 1), 950 SENSOR_ATTR(temp3_crit_alarm, S_IRUGO, show_temp_crit_alarm, NULL, 2), 951 }; 952 953 #define TEMP_FAULT 0x40 /* open diode */ 954 static ssize_t show_temp_fault(struct device *dev, 955 struct device_attribute *devattr, char *buf) 956 { 957 struct pc87360_data *data = pc87360_update_device(dev); 958 unsigned nr = to_sensor_dev_attr(devattr)->index; 959 960 return sprintf(buf, "%u\n", !!(data->temp_status[nr] & TEMP_FAULT)); 961 } 962 static struct sensor_device_attribute temp_fault[] = { 963 SENSOR_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0), 964 SENSOR_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1), 965 SENSOR_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2), 966 }; 967 968 #define TEMP_UNIT_ATTRS(X) \ 969 &temp_input[X].dev_attr.attr, \ 970 &temp_status[X].dev_attr.attr, \ 971 &temp_min[X].dev_attr.attr, \ 972 &temp_max[X].dev_attr.attr, \ 973 &temp_crit[X].dev_attr.attr, \ 974 &temp_min_alarm[X].dev_attr.attr, \ 975 &temp_max_alarm[X].dev_attr.attr, \ 976 &temp_crit_alarm[X].dev_attr.attr, \ 977 &temp_fault[X].dev_attr.attr 978 979 static struct attribute * pc8736x_temp_attr_array[] = { 980 TEMP_UNIT_ATTRS(0), 981 TEMP_UNIT_ATTRS(1), 982 TEMP_UNIT_ATTRS(2), 983 /* include the few miscellaneous atts here */ 984 &dev_attr_alarms_temp.attr, 985 NULL 986 }; 987 static const struct attribute_group pc8736x_temp_group = { 988 .attrs = pc8736x_temp_attr_array, 989 }; 990 991 static ssize_t show_name(struct device *dev, 992 struct device_attribute *devattr, char *buf) 993 { 994 struct pc87360_data *data = dev_get_drvdata(dev); 995 return sprintf(buf, "%s\n", data->name); 996 } 997 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 998 999 /* 1000 * Device detection, registration and update 1001 */ 1002 1003 static int __init pc87360_find(int sioaddr, u8 *devid, unsigned short *addresses) 1004 { 1005 u16 val; 1006 int i; 1007 int nrdev; /* logical device count */ 1008 1009 /* No superio_enter */ 1010 1011 /* Identify device */ 1012 val = force_id ? force_id : superio_inb(sioaddr, DEVID); 1013 switch (val) { 1014 case 0xE1: /* PC87360 */ 1015 case 0xE8: /* PC87363 */ 1016 case 0xE4: /* PC87364 */ 1017 nrdev = 1; 1018 break; 1019 case 0xE5: /* PC87365 */ 1020 case 0xE9: /* PC87366 */ 1021 nrdev = 3; 1022 break; 1023 default: 1024 superio_exit(sioaddr); 1025 return -ENODEV; 1026 } 1027 /* Remember the device id */ 1028 *devid = val; 1029 1030 for (i = 0; i < nrdev; i++) { 1031 /* select logical device */ 1032 superio_outb(sioaddr, DEV, logdev[i]); 1033 1034 val = superio_inb(sioaddr, ACT); 1035 if (!(val & 0x01)) { 1036 pr_info("Device 0x%02x not activated\n", logdev[i]); 1037 continue; 1038 } 1039 1040 val = (superio_inb(sioaddr, BASE) << 8) 1041 | superio_inb(sioaddr, BASE + 1); 1042 if (!val) { 1043 pr_info("Base address not set for device 0x%02x\n", 1044 logdev[i]); 1045 continue; 1046 } 1047 1048 addresses[i] = val; 1049 1050 if (i==0) { /* Fans */ 1051 confreg[0] = superio_inb(sioaddr, 0xF0); 1052 confreg[1] = superio_inb(sioaddr, 0xF1); 1053 1054 pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 1, 1055 (confreg[0] >> 2) & 1, (confreg[0] >> 3) & 1, 1056 (confreg[0] >> 4) & 1); 1057 pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 2, 1058 (confreg[0] >> 5) & 1, (confreg[0] >> 6) & 1, 1059 (confreg[0] >> 7) & 1); 1060 pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 3, 1061 confreg[1] & 1, (confreg[1] >> 1) & 1, 1062 (confreg[1] >> 2) & 1); 1063 } else if (i==1) { /* Voltages */ 1064 /* Are we using thermistors? */ 1065 if (*devid == 0xE9) { /* PC87366 */ 1066 /* These registers are not logical-device 1067 specific, just that we won't need them if 1068 we don't use the VLM device */ 1069 confreg[2] = superio_inb(sioaddr, 0x2B); 1070 confreg[3] = superio_inb(sioaddr, 0x25); 1071 1072 if (confreg[2] & 0x40) { 1073 pr_info("Using thermistors for " 1074 "temperature monitoring\n"); 1075 } 1076 if (confreg[3] & 0xE0) { 1077 pr_info("VID inputs routed (mode %u)\n", 1078 confreg[3] >> 5); 1079 } 1080 } 1081 } 1082 } 1083 1084 superio_exit(sioaddr); 1085 return 0; 1086 } 1087 1088 static int __devinit pc87360_probe(struct platform_device *pdev) 1089 { 1090 int i; 1091 struct pc87360_data *data; 1092 int err = 0; 1093 const char *name = "pc87360"; 1094 int use_thermistors = 0; 1095 struct device *dev = &pdev->dev; 1096 1097 if (!(data = kzalloc(sizeof(struct pc87360_data), GFP_KERNEL))) 1098 return -ENOMEM; 1099 1100 data->fannr = 2; 1101 data->innr = 0; 1102 data->tempnr = 0; 1103 1104 switch (devid) { 1105 case 0xe8: 1106 name = "pc87363"; 1107 break; 1108 case 0xe4: 1109 name = "pc87364"; 1110 data->fannr = 3; 1111 break; 1112 case 0xe5: 1113 name = "pc87365"; 1114 data->fannr = extra_isa[0] ? 3 : 0; 1115 data->innr = extra_isa[1] ? 11 : 0; 1116 data->tempnr = extra_isa[2] ? 2 : 0; 1117 break; 1118 case 0xe9: 1119 name = "pc87366"; 1120 data->fannr = extra_isa[0] ? 3 : 0; 1121 data->innr = extra_isa[1] ? 14 : 0; 1122 data->tempnr = extra_isa[2] ? 3 : 0; 1123 break; 1124 } 1125 1126 data->name = name; 1127 data->valid = 0; 1128 mutex_init(&data->lock); 1129 mutex_init(&data->update_lock); 1130 platform_set_drvdata(pdev, data); 1131 1132 for (i = 0; i < LDNI_MAX; i++) { 1133 if (((data->address[i] = extra_isa[i])) 1134 && !request_region(extra_isa[i], PC87360_EXTENT, 1135 pc87360_driver.driver.name)) { 1136 dev_err(dev, "Region 0x%x-0x%x already " 1137 "in use!\n", extra_isa[i], 1138 extra_isa[i]+PC87360_EXTENT-1); 1139 for (i--; i >= 0; i--) 1140 release_region(extra_isa[i], PC87360_EXTENT); 1141 err = -EBUSY; 1142 goto ERROR1; 1143 } 1144 } 1145 1146 /* Retrieve the fans configuration from Super-I/O space */ 1147 if (data->fannr) 1148 data->fan_conf = confreg[0] | (confreg[1] << 8); 1149 1150 /* Use the correct reference voltage 1151 Unless both the VLM and the TMS logical devices agree to 1152 use an external Vref, the internal one is used. */ 1153 if (data->innr) { 1154 i = pc87360_read_value(data, LD_IN, NO_BANK, 1155 PC87365_REG_IN_CONFIG); 1156 if (data->tempnr) { 1157 i &= pc87360_read_value(data, LD_TEMP, NO_BANK, 1158 PC87365_REG_TEMP_CONFIG); 1159 } 1160 data->in_vref = (i&0x02) ? 3025 : 2966; 1161 dev_dbg(dev, "Using %s reference voltage\n", 1162 (i&0x02) ? "external" : "internal"); 1163 1164 data->vid_conf = confreg[3]; 1165 data->vrm = vid_which_vrm(); 1166 } 1167 1168 /* Fan clock dividers may be needed before any data is read */ 1169 for (i = 0; i < data->fannr; i++) { 1170 if (FAN_CONFIG_MONITOR(data->fan_conf, i)) 1171 data->fan_status[i] = pc87360_read_value(data, 1172 LD_FAN, NO_BANK, 1173 PC87360_REG_FAN_STATUS(i)); 1174 } 1175 1176 if (init > 0) { 1177 if (devid == 0xe9 && data->address[1]) /* PC87366 */ 1178 use_thermistors = confreg[2] & 0x40; 1179 1180 pc87360_init_device(pdev, use_thermistors); 1181 } 1182 1183 /* Register all-or-nothing sysfs groups */ 1184 1185 if (data->innr && 1186 (err = sysfs_create_group(&dev->kobj, 1187 &pc8736x_vin_group))) 1188 goto ERROR3; 1189 1190 if (data->innr == 14 && 1191 (err = sysfs_create_group(&dev->kobj, 1192 &pc8736x_therm_group))) 1193 goto ERROR3; 1194 1195 /* create device attr-files for varying sysfs groups */ 1196 1197 if (data->tempnr) { 1198 for (i = 0; i < data->tempnr; i++) { 1199 if ((err = device_create_file(dev, 1200 &temp_input[i].dev_attr)) 1201 || (err = device_create_file(dev, 1202 &temp_min[i].dev_attr)) 1203 || (err = device_create_file(dev, 1204 &temp_max[i].dev_attr)) 1205 || (err = device_create_file(dev, 1206 &temp_crit[i].dev_attr)) 1207 || (err = device_create_file(dev, 1208 &temp_status[i].dev_attr)) 1209 || (err = device_create_file(dev, 1210 &temp_min_alarm[i].dev_attr)) 1211 || (err = device_create_file(dev, 1212 &temp_max_alarm[i].dev_attr)) 1213 || (err = device_create_file(dev, 1214 &temp_crit_alarm[i].dev_attr)) 1215 || (err = device_create_file(dev, 1216 &temp_fault[i].dev_attr))) 1217 goto ERROR3; 1218 } 1219 if ((err = device_create_file(dev, &dev_attr_alarms_temp))) 1220 goto ERROR3; 1221 } 1222 1223 for (i = 0; i < data->fannr; i++) { 1224 if (FAN_CONFIG_MONITOR(data->fan_conf, i) 1225 && ((err = device_create_file(dev, 1226 &fan_input[i].dev_attr)) 1227 || (err = device_create_file(dev, 1228 &fan_min[i].dev_attr)) 1229 || (err = device_create_file(dev, 1230 &fan_div[i].dev_attr)) 1231 || (err = device_create_file(dev, 1232 &fan_status[i].dev_attr)))) 1233 goto ERROR3; 1234 1235 if (FAN_CONFIG_CONTROL(data->fan_conf, i) 1236 && (err = device_create_file(dev, &pwm[i].dev_attr))) 1237 goto ERROR3; 1238 } 1239 1240 if ((err = device_create_file(dev, &dev_attr_name))) 1241 goto ERROR3; 1242 1243 data->hwmon_dev = hwmon_device_register(dev); 1244 if (IS_ERR(data->hwmon_dev)) { 1245 err = PTR_ERR(data->hwmon_dev); 1246 goto ERROR3; 1247 } 1248 return 0; 1249 1250 ERROR3: 1251 device_remove_file(dev, &dev_attr_name); 1252 /* can still remove groups whose members were added individually */ 1253 sysfs_remove_group(&dev->kobj, &pc8736x_temp_group); 1254 sysfs_remove_group(&dev->kobj, &pc8736x_fan_group); 1255 sysfs_remove_group(&dev->kobj, &pc8736x_therm_group); 1256 sysfs_remove_group(&dev->kobj, &pc8736x_vin_group); 1257 for (i = 0; i < 3; i++) { 1258 if (data->address[i]) { 1259 release_region(data->address[i], PC87360_EXTENT); 1260 } 1261 } 1262 ERROR1: 1263 kfree(data); 1264 return err; 1265 } 1266 1267 static int __devexit pc87360_remove(struct platform_device *pdev) 1268 { 1269 struct pc87360_data *data = platform_get_drvdata(pdev); 1270 int i; 1271 1272 hwmon_device_unregister(data->hwmon_dev); 1273 1274 device_remove_file(&pdev->dev, &dev_attr_name); 1275 sysfs_remove_group(&pdev->dev.kobj, &pc8736x_temp_group); 1276 sysfs_remove_group(&pdev->dev.kobj, &pc8736x_fan_group); 1277 sysfs_remove_group(&pdev->dev.kobj, &pc8736x_therm_group); 1278 sysfs_remove_group(&pdev->dev.kobj, &pc8736x_vin_group); 1279 1280 for (i = 0; i < 3; i++) { 1281 if (data->address[i]) { 1282 release_region(data->address[i], PC87360_EXTENT); 1283 } 1284 } 1285 kfree(data); 1286 1287 return 0; 1288 } 1289 1290 /* ldi is the logical device index 1291 bank is for voltages and temperatures only */ 1292 static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank, 1293 u8 reg) 1294 { 1295 int res; 1296 1297 mutex_lock(&(data->lock)); 1298 if (bank != NO_BANK) 1299 outb_p(bank, data->address[ldi] + PC87365_REG_BANK); 1300 res = inb_p(data->address[ldi] + reg); 1301 mutex_unlock(&(data->lock)); 1302 1303 return res; 1304 } 1305 1306 static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank, 1307 u8 reg, u8 value) 1308 { 1309 mutex_lock(&(data->lock)); 1310 if (bank != NO_BANK) 1311 outb_p(bank, data->address[ldi] + PC87365_REG_BANK); 1312 outb_p(value, data->address[ldi] + reg); 1313 mutex_unlock(&(data->lock)); 1314 } 1315 1316 /* (temp & vin) channel conversion status register flags (pdf sec.11.5.12) */ 1317 #define CHAN_CNVRTD 0x80 /* new data ready */ 1318 #define CHAN_ENA 0x01 /* enabled channel (temp or vin) */ 1319 #define CHAN_ALM_ENA 0x10 /* propagate to alarms-reg ?? (chk val!) */ 1320 #define CHAN_READY (CHAN_ENA|CHAN_CNVRTD) /* sample ready mask */ 1321 1322 #define TEMP_OTS_OE 0x20 /* OTS Output Enable */ 1323 #define VIN_RW1C_MASK (CHAN_READY|CHAN_ALM_MAX|CHAN_ALM_MIN) /* 0x87 */ 1324 #define TEMP_RW1C_MASK (VIN_RW1C_MASK|TEMP_ALM_CRIT|TEMP_FAULT) /* 0xCF */ 1325 1326 static void pc87360_init_device(struct platform_device *pdev, 1327 int use_thermistors) 1328 { 1329 struct pc87360_data *data = platform_get_drvdata(pdev); 1330 int i, nr; 1331 const u8 init_in[14] = { 2, 2, 2, 2, 2, 2, 2, 1, 1, 3, 1, 2, 2, 2 }; 1332 const u8 init_temp[3] = { 2, 2, 1 }; 1333 u8 reg; 1334 1335 if (init >= 2 && data->innr) { 1336 reg = pc87360_read_value(data, LD_IN, NO_BANK, 1337 PC87365_REG_IN_CONVRATE); 1338 dev_info(&pdev->dev, "VLM conversion set to " 1339 "1s period, 160us delay\n"); 1340 pc87360_write_value(data, LD_IN, NO_BANK, 1341 PC87365_REG_IN_CONVRATE, 1342 (reg & 0xC0) | 0x11); 1343 } 1344 1345 nr = data->innr < 11 ? data->innr : 11; 1346 for (i = 0; i < nr; i++) { 1347 reg = pc87360_read_value(data, LD_IN, i, 1348 PC87365_REG_IN_STATUS); 1349 dev_dbg(&pdev->dev, "bios in%d status:0x%02x\n", i, reg); 1350 if (init >= init_in[i]) { 1351 /* Forcibly enable voltage channel */ 1352 if (!(reg & CHAN_ENA)) { 1353 dev_dbg(&pdev->dev, "Forcibly " 1354 "enabling in%d\n", i); 1355 pc87360_write_value(data, LD_IN, i, 1356 PC87365_REG_IN_STATUS, 1357 (reg & 0x68) | 0x87); 1358 } 1359 } 1360 } 1361 1362 /* We can't blindly trust the Super-I/O space configuration bit, 1363 most BIOS won't set it properly */ 1364 dev_dbg(&pdev->dev, "bios thermistors:%d\n", use_thermistors); 1365 for (i = 11; i < data->innr; i++) { 1366 reg = pc87360_read_value(data, LD_IN, i, 1367 PC87365_REG_TEMP_STATUS); 1368 use_thermistors = use_thermistors || (reg & CHAN_ENA); 1369 /* thermistors are temp[4-6], measured on vin[11-14] */ 1370 dev_dbg(&pdev->dev, "bios temp%d_status:0x%02x\n", i-7, reg); 1371 } 1372 dev_dbg(&pdev->dev, "using thermistors:%d\n", use_thermistors); 1373 1374 i = use_thermistors ? 2 : 0; 1375 for (; i < data->tempnr; i++) { 1376 reg = pc87360_read_value(data, LD_TEMP, i, 1377 PC87365_REG_TEMP_STATUS); 1378 dev_dbg(&pdev->dev, "bios temp%d_status:0x%02x\n", i+1, reg); 1379 if (init >= init_temp[i]) { 1380 /* Forcibly enable temperature channel */ 1381 if (!(reg & CHAN_ENA)) { 1382 dev_dbg(&pdev->dev, "Forcibly " 1383 "enabling temp%d\n", i+1); 1384 pc87360_write_value(data, LD_TEMP, i, 1385 PC87365_REG_TEMP_STATUS, 1386 0xCF); 1387 } 1388 } 1389 } 1390 1391 if (use_thermistors) { 1392 for (i = 11; i < data->innr; i++) { 1393 if (init >= init_in[i]) { 1394 /* The pin may already be used by thermal 1395 diodes */ 1396 reg = pc87360_read_value(data, LD_TEMP, 1397 (i-11)/2, PC87365_REG_TEMP_STATUS); 1398 if (reg & CHAN_ENA) { 1399 dev_dbg(&pdev->dev, "Skipping " 1400 "temp%d, pin already in use " 1401 "by temp%d\n", i-7, (i-11)/2); 1402 continue; 1403 } 1404 1405 /* Forcibly enable thermistor channel */ 1406 reg = pc87360_read_value(data, LD_IN, i, 1407 PC87365_REG_IN_STATUS); 1408 if (!(reg & CHAN_ENA)) { 1409 dev_dbg(&pdev->dev, "Forcibly " 1410 "enabling temp%d\n", i-7); 1411 pc87360_write_value(data, LD_IN, i, 1412 PC87365_REG_TEMP_STATUS, 1413 (reg & 0x60) | 0x8F); 1414 } 1415 } 1416 } 1417 } 1418 1419 if (data->innr) { 1420 reg = pc87360_read_value(data, LD_IN, NO_BANK, 1421 PC87365_REG_IN_CONFIG); 1422 dev_dbg(&pdev->dev, "bios vin-cfg:0x%02x\n", reg); 1423 if (reg & CHAN_ENA) { 1424 dev_dbg(&pdev->dev, "Forcibly " 1425 "enabling monitoring (VLM)\n"); 1426 pc87360_write_value(data, LD_IN, NO_BANK, 1427 PC87365_REG_IN_CONFIG, 1428 reg & 0xFE); 1429 } 1430 } 1431 1432 if (data->tempnr) { 1433 reg = pc87360_read_value(data, LD_TEMP, NO_BANK, 1434 PC87365_REG_TEMP_CONFIG); 1435 dev_dbg(&pdev->dev, "bios temp-cfg:0x%02x\n", reg); 1436 if (reg & CHAN_ENA) { 1437 dev_dbg(&pdev->dev, "Forcibly enabling " 1438 "monitoring (TMS)\n"); 1439 pc87360_write_value(data, LD_TEMP, NO_BANK, 1440 PC87365_REG_TEMP_CONFIG, 1441 reg & 0xFE); 1442 } 1443 1444 if (init >= 2) { 1445 /* Chip config as documented by National Semi. */ 1446 pc87360_write_value(data, LD_TEMP, 0xF, 0xA, 0x08); 1447 /* We voluntarily omit the bank here, in case the 1448 sequence itself matters. It shouldn't be a problem, 1449 since nobody else is supposed to access the 1450 device at that point. */ 1451 pc87360_write_value(data, LD_TEMP, NO_BANK, 0xB, 0x04); 1452 pc87360_write_value(data, LD_TEMP, NO_BANK, 0xC, 0x35); 1453 pc87360_write_value(data, LD_TEMP, NO_BANK, 0xD, 0x05); 1454 pc87360_write_value(data, LD_TEMP, NO_BANK, 0xE, 0x05); 1455 } 1456 } 1457 } 1458 1459 static void pc87360_autodiv(struct device *dev, int nr) 1460 { 1461 struct pc87360_data *data = dev_get_drvdata(dev); 1462 u8 old_min = data->fan_min[nr]; 1463 1464 /* Increase clock divider if needed and possible */ 1465 if ((data->fan_status[nr] & 0x04) /* overflow flag */ 1466 || (data->fan[nr] >= 224)) { /* next to overflow */ 1467 if ((data->fan_status[nr] & 0x60) != 0x60) { 1468 data->fan_status[nr] += 0x20; 1469 data->fan_min[nr] >>= 1; 1470 data->fan[nr] >>= 1; 1471 dev_dbg(dev, "Increasing " 1472 "clock divider to %d for fan %d\n", 1473 FAN_DIV_FROM_REG(data->fan_status[nr]), nr+1); 1474 } 1475 } else { 1476 /* Decrease clock divider if possible */ 1477 while (!(data->fan_min[nr] & 0x80) /* min "nails" divider */ 1478 && data->fan[nr] < 85 /* bad accuracy */ 1479 && (data->fan_status[nr] & 0x60) != 0x00) { 1480 data->fan_status[nr] -= 0x20; 1481 data->fan_min[nr] <<= 1; 1482 data->fan[nr] <<= 1; 1483 dev_dbg(dev, "Decreasing " 1484 "clock divider to %d for fan %d\n", 1485 FAN_DIV_FROM_REG(data->fan_status[nr]), 1486 nr+1); 1487 } 1488 } 1489 1490 /* Write new fan min if it changed */ 1491 if (old_min != data->fan_min[nr]) { 1492 pc87360_write_value(data, LD_FAN, NO_BANK, 1493 PC87360_REG_FAN_MIN(nr), 1494 data->fan_min[nr]); 1495 } 1496 } 1497 1498 static struct pc87360_data *pc87360_update_device(struct device *dev) 1499 { 1500 struct pc87360_data *data = dev_get_drvdata(dev); 1501 u8 i; 1502 1503 mutex_lock(&data->update_lock); 1504 1505 if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) { 1506 dev_dbg(dev, "Data update\n"); 1507 1508 /* Fans */ 1509 for (i = 0; i < data->fannr; i++) { 1510 if (FAN_CONFIG_MONITOR(data->fan_conf, i)) { 1511 data->fan_status[i] = 1512 pc87360_read_value(data, LD_FAN, 1513 NO_BANK, PC87360_REG_FAN_STATUS(i)); 1514 data->fan[i] = pc87360_read_value(data, LD_FAN, 1515 NO_BANK, PC87360_REG_FAN(i)); 1516 data->fan_min[i] = pc87360_read_value(data, 1517 LD_FAN, NO_BANK, 1518 PC87360_REG_FAN_MIN(i)); 1519 /* Change clock divider if needed */ 1520 pc87360_autodiv(dev, i); 1521 /* Clear bits and write new divider */ 1522 pc87360_write_value(data, LD_FAN, NO_BANK, 1523 PC87360_REG_FAN_STATUS(i), 1524 data->fan_status[i]); 1525 } 1526 if (FAN_CONFIG_CONTROL(data->fan_conf, i)) 1527 data->pwm[i] = pc87360_read_value(data, LD_FAN, 1528 NO_BANK, PC87360_REG_PWM(i)); 1529 } 1530 1531 /* Voltages */ 1532 for (i = 0; i < data->innr; i++) { 1533 data->in_status[i] = pc87360_read_value(data, LD_IN, i, 1534 PC87365_REG_IN_STATUS); 1535 /* Clear bits */ 1536 pc87360_write_value(data, LD_IN, i, 1537 PC87365_REG_IN_STATUS, 1538 data->in_status[i]); 1539 if ((data->in_status[i] & CHAN_READY) == CHAN_READY) { 1540 data->in[i] = pc87360_read_value(data, LD_IN, 1541 i, PC87365_REG_IN); 1542 } 1543 if (data->in_status[i] & CHAN_ENA) { 1544 data->in_min[i] = pc87360_read_value(data, 1545 LD_IN, i, 1546 PC87365_REG_IN_MIN); 1547 data->in_max[i] = pc87360_read_value(data, 1548 LD_IN, i, 1549 PC87365_REG_IN_MAX); 1550 if (i >= 11) 1551 data->in_crit[i-11] = 1552 pc87360_read_value(data, LD_IN, 1553 i, PC87365_REG_TEMP_CRIT); 1554 } 1555 } 1556 if (data->innr) { 1557 data->in_alarms = pc87360_read_value(data, LD_IN, 1558 NO_BANK, PC87365_REG_IN_ALARMS1) 1559 | ((pc87360_read_value(data, LD_IN, 1560 NO_BANK, PC87365_REG_IN_ALARMS2) 1561 & 0x07) << 8); 1562 data->vid = (data->vid_conf & 0xE0) ? 1563 pc87360_read_value(data, LD_IN, 1564 NO_BANK, PC87365_REG_VID) : 0x1F; 1565 } 1566 1567 /* Temperatures */ 1568 for (i = 0; i < data->tempnr; i++) { 1569 data->temp_status[i] = pc87360_read_value(data, 1570 LD_TEMP, i, 1571 PC87365_REG_TEMP_STATUS); 1572 /* Clear bits */ 1573 pc87360_write_value(data, LD_TEMP, i, 1574 PC87365_REG_TEMP_STATUS, 1575 data->temp_status[i]); 1576 if ((data->temp_status[i] & CHAN_READY) == CHAN_READY) { 1577 data->temp[i] = pc87360_read_value(data, 1578 LD_TEMP, i, 1579 PC87365_REG_TEMP); 1580 } 1581 if (data->temp_status[i] & CHAN_ENA) { 1582 data->temp_min[i] = pc87360_read_value(data, 1583 LD_TEMP, i, 1584 PC87365_REG_TEMP_MIN); 1585 data->temp_max[i] = pc87360_read_value(data, 1586 LD_TEMP, i, 1587 PC87365_REG_TEMP_MAX); 1588 data->temp_crit[i] = pc87360_read_value(data, 1589 LD_TEMP, i, 1590 PC87365_REG_TEMP_CRIT); 1591 } 1592 } 1593 if (data->tempnr) { 1594 data->temp_alarms = pc87360_read_value(data, LD_TEMP, 1595 NO_BANK, PC87365_REG_TEMP_ALARMS) 1596 & 0x3F; 1597 } 1598 1599 data->last_updated = jiffies; 1600 data->valid = 1; 1601 } 1602 1603 mutex_unlock(&data->update_lock); 1604 1605 return data; 1606 } 1607 1608 static int __init pc87360_device_add(unsigned short address) 1609 { 1610 struct resource res[3]; 1611 int err, i, res_count; 1612 1613 pdev = platform_device_alloc("pc87360", address); 1614 if (!pdev) { 1615 err = -ENOMEM; 1616 pr_err("Device allocation failed\n"); 1617 goto exit; 1618 } 1619 1620 memset(res, 0, 3 * sizeof(struct resource)); 1621 res_count = 0; 1622 for (i = 0; i < 3; i++) { 1623 if (!extra_isa[i]) 1624 continue; 1625 res[res_count].start = extra_isa[i]; 1626 res[res_count].end = extra_isa[i] + PC87360_EXTENT - 1; 1627 res[res_count].name = "pc87360", 1628 res[res_count].flags = IORESOURCE_IO, 1629 1630 err = acpi_check_resource_conflict(&res[res_count]); 1631 if (err) 1632 goto exit_device_put; 1633 1634 res_count++; 1635 } 1636 1637 err = platform_device_add_resources(pdev, res, res_count); 1638 if (err) { 1639 pr_err("Device resources addition failed (%d)\n", err); 1640 goto exit_device_put; 1641 } 1642 1643 err = platform_device_add(pdev); 1644 if (err) { 1645 pr_err("Device addition failed (%d)\n", err); 1646 goto exit_device_put; 1647 } 1648 1649 return 0; 1650 1651 exit_device_put: 1652 platform_device_put(pdev); 1653 exit: 1654 return err; 1655 } 1656 1657 static int __init pc87360_init(void) 1658 { 1659 int err, i; 1660 unsigned short address = 0; 1661 1662 if (pc87360_find(0x2e, &devid, extra_isa) 1663 && pc87360_find(0x4e, &devid, extra_isa)) { 1664 pr_warn("PC8736x not detected, module not inserted\n"); 1665 return -ENODEV; 1666 } 1667 1668 /* Arbitrarily pick one of the addresses */ 1669 for (i = 0; i < 3; i++) { 1670 if (extra_isa[i] != 0x0000) { 1671 address = extra_isa[i]; 1672 break; 1673 } 1674 } 1675 1676 if (address == 0x0000) { 1677 pr_warn("No active logical device, module not inserted\n"); 1678 return -ENODEV; 1679 } 1680 1681 err = platform_driver_register(&pc87360_driver); 1682 if (err) 1683 goto exit; 1684 1685 /* Sets global pdev as a side effect */ 1686 err = pc87360_device_add(address); 1687 if (err) 1688 goto exit_driver; 1689 1690 return 0; 1691 1692 exit_driver: 1693 platform_driver_unregister(&pc87360_driver); 1694 exit: 1695 return err; 1696 } 1697 1698 static void __exit pc87360_exit(void) 1699 { 1700 platform_device_unregister(pdev); 1701 platform_driver_unregister(&pc87360_driver); 1702 } 1703 1704 1705 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>"); 1706 MODULE_DESCRIPTION("PC8736x hardware monitor"); 1707 MODULE_LICENSE("GPL"); 1708 1709 module_init(pc87360_init); 1710 module_exit(pc87360_exit); 1711