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