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