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