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