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 50static u8 devid; 51static struct platform_device *pdev; 52static unsigned short extra_isa[3]; 53static u8 confreg[4]; 54 55static int init = 1; 56module_param(init, int, 0); 57MODULE_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 64static unsigned short force_id; 65module_param(force_id, ushort, 0); 66MODULE_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 81static 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 87static inline void superio_outb(int sioaddr, int reg, int val) 88{ 89 outb(reg, sioaddr); 90 outb(val, sioaddr + 1); 91} 92 93static inline int superio_inb(int sioaddr, int reg) 94{ 95 outb(reg, sioaddr); 96 return inb(sioaddr + 1); 97} 98 99static 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)) 136static 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 188struct 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 */ 229static 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 243static 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 253static 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 292static 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 406static 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 415static 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 429static 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 437static 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 451static 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 460static 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 481static 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 495static 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 504static 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 526static 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 551static 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 560static 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 574static 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 583static 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 605static 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} 611static DEVICE_ATTR_RO(cpu0_vid); 612 613static 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 620static 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} 637static DEVICE_ATTR_RW(vrm); 638 639static 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} 645static DEVICE_ATTR_RO(alarms_in); 646 647static 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}; 664static const struct attribute_group pc8736x_vin_group = { 665 .attrs = pc8736x_vin_attr_array, 666}; 667 668static 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 */ 681static 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 687static 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 695static 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 701static 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 710static 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 731static 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 737static 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 746static 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 767static 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 773static 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 782static 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 803static 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 */ 813static 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 823static 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 829static 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 839static 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 845static 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 855static 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 871static struct attribute *pc8736x_therm_attr_array[] = { 872 THERM_UNIT_ATTRS(0), 873 THERM_UNIT_ATTRS(1), 874 THERM_UNIT_ATTRS(2), 875 NULL 876}; 877static const struct attribute_group pc8736x_therm_group = { 878 .attrs = pc8736x_therm_attr_array, 879}; 880 881static 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 889static 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 895static 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 903static 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 909static 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 917static 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 938static 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 944static 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 952static 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 973static 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 979static 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 988static 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 1009static 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 */ 1020static 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 1030static 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 1036static 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 1046static 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 1052static 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 1062static 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 */ 1069static 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 1078static 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 1097static struct attribute *pc8736x_temp_attr[][10] = { 1098 TEMP_UNIT_ATTRS(0), 1099 TEMP_UNIT_ATTRS(1), 1100 TEMP_UNIT_ATTRS(2) 1101}; 1102 1103static 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 1109static 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 1116static DEVICE_ATTR_RO(alarms_temp); 1117 1118static 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 1127static 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 1133static 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 1142static 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 1148static 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 1157static 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 1163static 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 1172static 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 1210static 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 1224static struct attribute *pc8736x_fan_attr[][5] = { 1225 FAN_UNIT_ATTRS(0), 1226 FAN_UNIT_ATTRS(1), 1227 FAN_UNIT_ATTRS(2) 1228}; 1229 1230static 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 1236static 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 1247static 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 1268static 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 1274static 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 1281static DEVICE_ATTR_RO(name); 1282 1283static 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 1299static 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 = data->innr < 11 ? 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 1439static 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 1588error: 1589 pc87360_remove_files(dev); 1590 return err; 1591} 1592 1593static 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 */ 1604static 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 1616static 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 1703static 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 1746exit_device_put: 1747 platform_device_put(pdev); 1748exit: 1749 return err; 1750} 1751 1752static 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 1793static void __exit pc87360_exit(void) 1794{ 1795 platform_device_unregister(pdev); 1796 platform_driver_unregister(&pc87360_driver); 1797} 1798 1799MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>"); 1800MODULE_DESCRIPTION("PC8736x hardware monitor"); 1801MODULE_LICENSE("GPL"); 1802MODULE_ALIAS("platform:" DRIVER_NAME); 1803 1804module_init(pc87360_init); 1805module_exit(pc87360_exit); 1806