1360 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * vt1211.c - driver for the VIA VT1211 Super-I/O chip integrated hardware4 * monitoring features5 * Copyright (C) 2006 Juerg Haefliger <juergh@gmail.com>6 *7 * This driver is based on the driver for kernel 2.4 by Mark D. Studebaker8 * and its port to kernel 2.6 by Lars Ekman.9 */10 11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt12 13#include <linux/module.h>14#include <linux/init.h>15#include <linux/slab.h>16#include <linux/jiffies.h>17#include <linux/platform_device.h>18#include <linux/hwmon.h>19#include <linux/hwmon-sysfs.h>20#include <linux/hwmon-vid.h>21#include <linux/err.h>22#include <linux/mutex.h>23#include <linux/ioport.h>24#include <linux/acpi.h>25#include <linux/io.h>26 27static int uch_config = -1;28module_param(uch_config, int, 0);29MODULE_PARM_DESC(uch_config, "Initialize the universal channel configuration");30 31static int int_mode = -1;32module_param(int_mode, int, 0);33MODULE_PARM_DESC(int_mode, "Force the temperature interrupt mode");34 35static unsigned short force_id;36module_param(force_id, ushort, 0);37MODULE_PARM_DESC(force_id, "Override the detected device ID");38 39static struct platform_device *pdev;40 41#define DRVNAME "vt1211"42 43/* ---------------------------------------------------------------------44 * Registers45 *46 * The sensors are defined as follows.47 *48 * Sensor Voltage Mode Temp Mode Notes (from the datasheet)49 * -------- ------------ --------- --------------------------50 * Reading 1 temp1 Intel thermal diode51 * Reading 3 temp2 Internal thermal diode52 * UCH1/Reading2 in0 temp3 NTC type thermistor53 * UCH2 in1 temp4 +2.5V54 * UCH3 in2 temp5 VccP55 * UCH4 in3 temp6 +5V56 * UCH5 in4 temp7 +12V57 * 3.3V in5 Internal VDD (+3.3V)58 *59 * --------------------------------------------------------------------- */60 61/* Voltages (in) numbered 0-5 (ix) */62#define VT1211_REG_IN(ix) (0x21 + (ix))63#define VT1211_REG_IN_MIN(ix) ((ix) == 0 ? 0x3e : 0x2a + 2 * (ix))64#define VT1211_REG_IN_MAX(ix) ((ix) == 0 ? 0x3d : 0x29 + 2 * (ix))65 66/* Temperatures (temp) numbered 0-6 (ix) */67static u8 regtemp[] = {0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25};68static u8 regtempmax[] = {0x39, 0x1d, 0x3d, 0x2b, 0x2d, 0x2f, 0x31};69static u8 regtemphyst[] = {0x3a, 0x1e, 0x3e, 0x2c, 0x2e, 0x30, 0x32};70 71/* Fans numbered 0-1 (ix) */72#define VT1211_REG_FAN(ix) (0x29 + (ix))73#define VT1211_REG_FAN_MIN(ix) (0x3b + (ix))74#define VT1211_REG_FAN_DIV 0x4775 76/* PWMs numbered 0-1 (ix) */77/* Auto points numbered 0-3 (ap) */78#define VT1211_REG_PWM(ix) (0x60 + (ix))79#define VT1211_REG_PWM_CLK 0x5080#define VT1211_REG_PWM_CTL 0x5181#define VT1211_REG_PWM_AUTO_TEMP(ap) (0x55 - (ap))82#define VT1211_REG_PWM_AUTO_PWM(ix, ap) (0x58 + 2 * (ix) - (ap))83 84/* Miscellaneous registers */85#define VT1211_REG_CONFIG 0x4086#define VT1211_REG_ALARM1 0x4187#define VT1211_REG_ALARM2 0x4288#define VT1211_REG_VID 0x4589#define VT1211_REG_UCH_CONFIG 0x4a90#define VT1211_REG_TEMP1_CONFIG 0x4b91#define VT1211_REG_TEMP2_CONFIG 0x4c92 93/* In, temp & fan alarm bits */94static const u8 bitalarmin[] = {11, 0, 1, 3, 8, 2, 9};95static const u8 bitalarmtemp[] = {4, 15, 11, 0, 1, 3, 8};96static const u8 bitalarmfan[] = {6, 7};97 98/* ---------------------------------------------------------------------99 * Data structures and manipulation thereof100 * --------------------------------------------------------------------- */101 102struct vt1211_data {103 unsigned short addr;104 const char *name;105 struct device *hwmon_dev;106 107 struct mutex update_lock;108 bool valid; /* true if following fields are valid */109 unsigned long last_updated; /* In jiffies */110 111 /* Register values */112 u8 in[6];113 u8 in_max[6];114 u8 in_min[6];115 u8 temp[7];116 u8 temp_max[7];117 u8 temp_hyst[7];118 u8 fan[2];119 u8 fan_min[2];120 u8 fan_div[2];121 u8 fan_ctl;122 u8 pwm[2];123 u8 pwm_ctl[2];124 u8 pwm_clk;125 u8 pwm_auto_temp[4];126 u8 pwm_auto_pwm[2][4];127 u8 vid; /* Read once at init time */128 u8 vrm;129 u8 uch_config; /* Read once at init time */130 u16 alarms;131};132 133/* ix = [0-5] */134#define ISVOLT(ix, uch_config) ((ix) > 4 ? 1 : \135 !(((uch_config) >> ((ix) + 2)) & 1))136 137/* ix = [0-6] */138#define ISTEMP(ix, uch_config) ((ix) < 2 ? 1 : \139 ((uch_config) >> (ix)) & 1)140 141/*142 * in5 (ix = 5) is special. It's the internal 3.3V so it's scaled in the143 * driver according to the VT1211 BIOS porting guide144 */145#define IN_FROM_REG(ix, reg) ((reg) < 3 ? 0 : (ix) == 5 ? \146 (((reg) - 3) * 15882 + 479) / 958 : \147 (((reg) - 3) * 10000 + 479) / 958)148#define IN_TO_REG(ix, val) (clamp_val((ix) == 5 ? \149 ((val) * 958 + 7941) / 15882 + 3 : \150 ((val) * 958 + 5000) / 10000 + 3, 0, 255))151 152/*153 * temp1 (ix = 0) is an intel thermal diode which is scaled in user space.154 * temp2 (ix = 1) is the internal temp diode so it's scaled in the driver155 * according to some measurements that I took on an EPIA M10000.156 * temp3-7 are thermistor based so the driver returns the voltage measured at157 * the pin (range 0V - 2.2V).158 */159#define TEMP_FROM_REG(ix, reg) ((ix) == 0 ? (reg) * 1000 : \160 (ix) == 1 ? (reg) < 51 ? 0 : \161 ((reg) - 51) * 1000 : \162 ((253 - (reg)) * 2200 + 105) / 210)163#define TEMP_TO_REG(ix, val) clamp_val( \164 ((ix) == 0 ? ((val) + 500) / 1000 : \165 (ix) == 1 ? ((val) + 500) / 1000 + 51 : \166 253 - ((val) * 210 + 1100) / 2200), 0, 255)167 168#define DIV_FROM_REG(reg) (1 << (reg))169 170#define RPM_FROM_REG(reg, div) (((reg) == 0) || ((reg) == 255) ? 0 : \171 1310720 / (reg) / DIV_FROM_REG(div))172#define RPM_TO_REG(val, div) ((val) == 0 ? 255 : \173 clamp_val((1310720 / (val) / \174 DIV_FROM_REG(div)), 1, 254))175 176/* ---------------------------------------------------------------------177 * Super-I/O constants and functions178 * --------------------------------------------------------------------- */179 180/*181 * Configuration index port registers182 * The vt1211 can live at 2 different addresses so we need to probe both183 */184#define SIO_REG_CIP1 0x2e185#define SIO_REG_CIP2 0x4e186 187/* Configuration registers */188#define SIO_VT1211_LDN 0x07 /* logical device number */189#define SIO_VT1211_DEVID 0x20 /* device ID */190#define SIO_VT1211_DEVREV 0x21 /* device revision */191#define SIO_VT1211_ACTIVE 0x30 /* HW monitor active */192#define SIO_VT1211_BADDR 0x60 /* base I/O address */193#define SIO_VT1211_ID 0x3c /* VT1211 device ID */194 195/* VT1211 logical device numbers */196#define SIO_VT1211_LDN_HWMON 0x0b /* HW monitor */197 198static inline int superio_inb(int sio_cip, int reg)199{200 outb(reg, sio_cip);201 return inb(sio_cip + 1);202}203 204static inline void superio_select(int sio_cip, int ldn)205{206 outb(SIO_VT1211_LDN, sio_cip);207 outb(ldn, sio_cip + 1);208}209 210static inline int superio_enter(int sio_cip)211{212 if (!request_muxed_region(sio_cip, 2, DRVNAME))213 return -EBUSY;214 215 outb(0x87, sio_cip);216 outb(0x87, sio_cip);217 218 return 0;219}220 221static inline void superio_exit(int sio_cip)222{223 outb(0xaa, sio_cip);224 release_region(sio_cip, 2);225}226 227/* ---------------------------------------------------------------------228 * Device I/O access229 * --------------------------------------------------------------------- */230 231static inline u8 vt1211_read8(struct vt1211_data *data, u8 reg)232{233 return inb(data->addr + reg);234}235 236static inline void vt1211_write8(struct vt1211_data *data, u8 reg, u8 val)237{238 outb(val, data->addr + reg);239}240 241static struct vt1211_data *vt1211_update_device(struct device *dev)242{243 struct vt1211_data *data = dev_get_drvdata(dev);244 int ix, val;245 246 mutex_lock(&data->update_lock);247 248 /* registers cache is refreshed after 1 second */249 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {250 /* read VID */251 data->vid = vt1211_read8(data, VT1211_REG_VID) & 0x1f;252 253 /* voltage (in) registers */254 for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) {255 if (ISVOLT(ix, data->uch_config)) {256 data->in[ix] = vt1211_read8(data,257 VT1211_REG_IN(ix));258 data->in_min[ix] = vt1211_read8(data,259 VT1211_REG_IN_MIN(ix));260 data->in_max[ix] = vt1211_read8(data,261 VT1211_REG_IN_MAX(ix));262 }263 }264 265 /* temp registers */266 for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) {267 if (ISTEMP(ix, data->uch_config)) {268 data->temp[ix] = vt1211_read8(data,269 regtemp[ix]);270 data->temp_max[ix] = vt1211_read8(data,271 regtempmax[ix]);272 data->temp_hyst[ix] = vt1211_read8(data,273 regtemphyst[ix]);274 }275 }276 277 /* fan & pwm registers */278 for (ix = 0; ix < ARRAY_SIZE(data->fan); ix++) {279 data->fan[ix] = vt1211_read8(data,280 VT1211_REG_FAN(ix));281 data->fan_min[ix] = vt1211_read8(data,282 VT1211_REG_FAN_MIN(ix));283 data->pwm[ix] = vt1211_read8(data,284 VT1211_REG_PWM(ix));285 }286 val = vt1211_read8(data, VT1211_REG_FAN_DIV);287 data->fan_div[0] = (val >> 4) & 3;288 data->fan_div[1] = (val >> 6) & 3;289 data->fan_ctl = val & 0xf;290 291 val = vt1211_read8(data, VT1211_REG_PWM_CTL);292 data->pwm_ctl[0] = val & 0xf;293 data->pwm_ctl[1] = (val >> 4) & 0xf;294 295 data->pwm_clk = vt1211_read8(data, VT1211_REG_PWM_CLK);296 297 /* pwm & temp auto point registers */298 data->pwm_auto_pwm[0][1] = vt1211_read8(data,299 VT1211_REG_PWM_AUTO_PWM(0, 1));300 data->pwm_auto_pwm[0][2] = vt1211_read8(data,301 VT1211_REG_PWM_AUTO_PWM(0, 2));302 data->pwm_auto_pwm[1][1] = vt1211_read8(data,303 VT1211_REG_PWM_AUTO_PWM(1, 1));304 data->pwm_auto_pwm[1][2] = vt1211_read8(data,305 VT1211_REG_PWM_AUTO_PWM(1, 2));306 for (ix = 0; ix < ARRAY_SIZE(data->pwm_auto_temp); ix++) {307 data->pwm_auto_temp[ix] = vt1211_read8(data,308 VT1211_REG_PWM_AUTO_TEMP(ix));309 }310 311 /* alarm registers */312 data->alarms = (vt1211_read8(data, VT1211_REG_ALARM2) << 8) |313 vt1211_read8(data, VT1211_REG_ALARM1);314 315 data->last_updated = jiffies;316 data->valid = true;317 }318 319 mutex_unlock(&data->update_lock);320 321 return data;322}323 324/* ---------------------------------------------------------------------325 * Voltage sysfs interfaces326 * ix = [0-5]327 * --------------------------------------------------------------------- */328 329#define SHOW_IN_INPUT 0330#define SHOW_SET_IN_MIN 1331#define SHOW_SET_IN_MAX 2332#define SHOW_IN_ALARM 3333 334static ssize_t show_in(struct device *dev, struct device_attribute *attr,335 char *buf)336{337 struct vt1211_data *data = vt1211_update_device(dev);338 struct sensor_device_attribute_2 *sensor_attr_2 =339 to_sensor_dev_attr_2(attr);340 int ix = sensor_attr_2->index;341 int fn = sensor_attr_2->nr;342 int res;343 344 switch (fn) {345 case SHOW_IN_INPUT:346 res = IN_FROM_REG(ix, data->in[ix]);347 break;348 case SHOW_SET_IN_MIN:349 res = IN_FROM_REG(ix, data->in_min[ix]);350 break;351 case SHOW_SET_IN_MAX:352 res = IN_FROM_REG(ix, data->in_max[ix]);353 break;354 case SHOW_IN_ALARM:355 res = (data->alarms >> bitalarmin[ix]) & 1;356 break;357 default:358 res = 0;359 dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);360 }361 362 return sprintf(buf, "%d\n", res);363}364 365static ssize_t set_in(struct device *dev, struct device_attribute *attr,366 const char *buf, size_t count)367{368 struct vt1211_data *data = dev_get_drvdata(dev);369 struct sensor_device_attribute_2 *sensor_attr_2 =370 to_sensor_dev_attr_2(attr);371 int ix = sensor_attr_2->index;372 int fn = sensor_attr_2->nr;373 long val;374 int err;375 376 err = kstrtol(buf, 10, &val);377 if (err)378 return err;379 380 mutex_lock(&data->update_lock);381 switch (fn) {382 case SHOW_SET_IN_MIN:383 data->in_min[ix] = IN_TO_REG(ix, val);384 vt1211_write8(data, VT1211_REG_IN_MIN(ix), data->in_min[ix]);385 break;386 case SHOW_SET_IN_MAX:387 data->in_max[ix] = IN_TO_REG(ix, val);388 vt1211_write8(data, VT1211_REG_IN_MAX(ix), data->in_max[ix]);389 break;390 default:391 dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);392 }393 mutex_unlock(&data->update_lock);394 395 return count;396}397 398/* ---------------------------------------------------------------------399 * Temperature sysfs interfaces400 * ix = [0-6]401 * --------------------------------------------------------------------- */402 403#define SHOW_TEMP_INPUT 0404#define SHOW_SET_TEMP_MAX 1405#define SHOW_SET_TEMP_MAX_HYST 2406#define SHOW_TEMP_ALARM 3407 408static ssize_t show_temp(struct device *dev, struct device_attribute *attr,409 char *buf)410{411 struct vt1211_data *data = vt1211_update_device(dev);412 struct sensor_device_attribute_2 *sensor_attr_2 =413 to_sensor_dev_attr_2(attr);414 int ix = sensor_attr_2->index;415 int fn = sensor_attr_2->nr;416 int res;417 418 switch (fn) {419 case SHOW_TEMP_INPUT:420 res = TEMP_FROM_REG(ix, data->temp[ix]);421 break;422 case SHOW_SET_TEMP_MAX:423 res = TEMP_FROM_REG(ix, data->temp_max[ix]);424 break;425 case SHOW_SET_TEMP_MAX_HYST:426 res = TEMP_FROM_REG(ix, data->temp_hyst[ix]);427 break;428 case SHOW_TEMP_ALARM:429 res = (data->alarms >> bitalarmtemp[ix]) & 1;430 break;431 default:432 res = 0;433 dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);434 }435 436 return sprintf(buf, "%d\n", res);437}438 439static ssize_t set_temp(struct device *dev, struct device_attribute *attr,440 const char *buf, size_t count)441{442 struct vt1211_data *data = dev_get_drvdata(dev);443 struct sensor_device_attribute_2 *sensor_attr_2 =444 to_sensor_dev_attr_2(attr);445 int ix = sensor_attr_2->index;446 int fn = sensor_attr_2->nr;447 long val;448 int err;449 450 err = kstrtol(buf, 10, &val);451 if (err)452 return err;453 454 mutex_lock(&data->update_lock);455 switch (fn) {456 case SHOW_SET_TEMP_MAX:457 data->temp_max[ix] = TEMP_TO_REG(ix, val);458 vt1211_write8(data, regtempmax[ix],459 data->temp_max[ix]);460 break;461 case SHOW_SET_TEMP_MAX_HYST:462 data->temp_hyst[ix] = TEMP_TO_REG(ix, val);463 vt1211_write8(data, regtemphyst[ix],464 data->temp_hyst[ix]);465 break;466 default:467 dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);468 }469 mutex_unlock(&data->update_lock);470 471 return count;472}473 474/* ---------------------------------------------------------------------475 * Fan sysfs interfaces476 * ix = [0-1]477 * --------------------------------------------------------------------- */478 479#define SHOW_FAN_INPUT 0480#define SHOW_SET_FAN_MIN 1481#define SHOW_SET_FAN_DIV 2482#define SHOW_FAN_ALARM 3483 484static ssize_t show_fan(struct device *dev, struct device_attribute *attr,485 char *buf)486{487 struct vt1211_data *data = vt1211_update_device(dev);488 struct sensor_device_attribute_2 *sensor_attr_2 =489 to_sensor_dev_attr_2(attr);490 int ix = sensor_attr_2->index;491 int fn = sensor_attr_2->nr;492 int res;493 494 switch (fn) {495 case SHOW_FAN_INPUT:496 res = RPM_FROM_REG(data->fan[ix], data->fan_div[ix]);497 break;498 case SHOW_SET_FAN_MIN:499 res = RPM_FROM_REG(data->fan_min[ix], data->fan_div[ix]);500 break;501 case SHOW_SET_FAN_DIV:502 res = DIV_FROM_REG(data->fan_div[ix]);503 break;504 case SHOW_FAN_ALARM:505 res = (data->alarms >> bitalarmfan[ix]) & 1;506 break;507 default:508 res = 0;509 dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);510 }511 512 return sprintf(buf, "%d\n", res);513}514 515static ssize_t set_fan(struct device *dev, struct device_attribute *attr,516 const char *buf, size_t count)517{518 struct vt1211_data *data = dev_get_drvdata(dev);519 struct sensor_device_attribute_2 *sensor_attr_2 =520 to_sensor_dev_attr_2(attr);521 int ix = sensor_attr_2->index;522 int fn = sensor_attr_2->nr;523 int reg;524 unsigned long val;525 int err;526 527 err = kstrtoul(buf, 10, &val);528 if (err)529 return err;530 531 mutex_lock(&data->update_lock);532 533 /* sync the data cache */534 reg = vt1211_read8(data, VT1211_REG_FAN_DIV);535 data->fan_div[0] = (reg >> 4) & 3;536 data->fan_div[1] = (reg >> 6) & 3;537 data->fan_ctl = reg & 0xf;538 539 switch (fn) {540 case SHOW_SET_FAN_MIN:541 data->fan_min[ix] = RPM_TO_REG(val, data->fan_div[ix]);542 vt1211_write8(data, VT1211_REG_FAN_MIN(ix),543 data->fan_min[ix]);544 break;545 case SHOW_SET_FAN_DIV:546 switch (val) {547 case 1:548 data->fan_div[ix] = 0;549 break;550 case 2:551 data->fan_div[ix] = 1;552 break;553 case 4:554 data->fan_div[ix] = 2;555 break;556 case 8:557 data->fan_div[ix] = 3;558 break;559 default:560 count = -EINVAL;561 dev_warn(dev,562 "fan div value %ld not supported. Choose one of 1, 2, 4, or 8.\n",563 val);564 goto EXIT;565 }566 vt1211_write8(data, VT1211_REG_FAN_DIV,567 ((data->fan_div[1] << 6) |568 (data->fan_div[0] << 4) |569 data->fan_ctl));570 break;571 default:572 dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);573 }574 575EXIT:576 mutex_unlock(&data->update_lock);577 return count;578}579 580/* ---------------------------------------------------------------------581 * PWM sysfs interfaces582 * ix = [0-1]583 * --------------------------------------------------------------------- */584 585#define SHOW_PWM 0586#define SHOW_SET_PWM_ENABLE 1587#define SHOW_SET_PWM_FREQ 2588#define SHOW_SET_PWM_AUTO_CHANNELS_TEMP 3589 590static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,591 char *buf)592{593 struct vt1211_data *data = vt1211_update_device(dev);594 struct sensor_device_attribute_2 *sensor_attr_2 =595 to_sensor_dev_attr_2(attr);596 int ix = sensor_attr_2->index;597 int fn = sensor_attr_2->nr;598 int res;599 600 switch (fn) {601 case SHOW_PWM:602 res = data->pwm[ix];603 break;604 case SHOW_SET_PWM_ENABLE:605 res = ((data->pwm_ctl[ix] >> 3) & 1) ? 2 : 0;606 break;607 case SHOW_SET_PWM_FREQ:608 res = 90000 >> (data->pwm_clk & 7);609 break;610 case SHOW_SET_PWM_AUTO_CHANNELS_TEMP:611 res = (data->pwm_ctl[ix] & 7) + 1;612 break;613 default:614 res = 0;615 dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);616 }617 618 return sprintf(buf, "%d\n", res);619}620 621static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,622 const char *buf, size_t count)623{624 struct vt1211_data *data = dev_get_drvdata(dev);625 struct sensor_device_attribute_2 *sensor_attr_2 =626 to_sensor_dev_attr_2(attr);627 int ix = sensor_attr_2->index;628 int fn = sensor_attr_2->nr;629 int tmp, reg;630 unsigned long val;631 int err;632 633 err = kstrtoul(buf, 10, &val);634 if (err)635 return err;636 637 mutex_lock(&data->update_lock);638 639 switch (fn) {640 case SHOW_SET_PWM_ENABLE:641 /* sync the data cache */642 reg = vt1211_read8(data, VT1211_REG_FAN_DIV);643 data->fan_div[0] = (reg >> 4) & 3;644 data->fan_div[1] = (reg >> 6) & 3;645 data->fan_ctl = reg & 0xf;646 reg = vt1211_read8(data, VT1211_REG_PWM_CTL);647 data->pwm_ctl[0] = reg & 0xf;648 data->pwm_ctl[1] = (reg >> 4) & 0xf;649 switch (val) {650 case 0:651 data->pwm_ctl[ix] &= 7;652 /*653 * disable SmartGuardian if both PWM outputs are654 * disabled655 */656 if ((data->pwm_ctl[ix ^ 1] & 1) == 0)657 data->fan_ctl &= 0xe;658 break;659 case 2:660 data->pwm_ctl[ix] |= 8;661 data->fan_ctl |= 1;662 break;663 default:664 count = -EINVAL;665 dev_warn(dev,666 "pwm mode %ld not supported. Choose one of 0 or 2.\n",667 val);668 goto EXIT;669 }670 vt1211_write8(data, VT1211_REG_PWM_CTL,671 ((data->pwm_ctl[1] << 4) |672 data->pwm_ctl[0]));673 vt1211_write8(data, VT1211_REG_FAN_DIV,674 ((data->fan_div[1] << 6) |675 (data->fan_div[0] << 4) |676 data->fan_ctl));677 break;678 case SHOW_SET_PWM_FREQ:679 val = 135000 / clamp_val(val, 135000 >> 7, 135000);680 /* calculate tmp = log2(val) */681 tmp = 0;682 for (val >>= 1; val > 0; val >>= 1)683 tmp++;684 /* sync the data cache */685 reg = vt1211_read8(data, VT1211_REG_PWM_CLK);686 data->pwm_clk = (reg & 0xf8) | tmp;687 vt1211_write8(data, VT1211_REG_PWM_CLK, data->pwm_clk);688 break;689 case SHOW_SET_PWM_AUTO_CHANNELS_TEMP:690 if (val < 1 || val > 7) {691 count = -EINVAL;692 dev_warn(dev,693 "temp channel %ld not supported. Choose a value between 1 and 7.\n",694 val);695 goto EXIT;696 }697 if (!ISTEMP(val - 1, data->uch_config)) {698 count = -EINVAL;699 dev_warn(dev, "temp channel %ld is not available.\n",700 val);701 goto EXIT;702 }703 /* sync the data cache */704 reg = vt1211_read8(data, VT1211_REG_PWM_CTL);705 data->pwm_ctl[0] = reg & 0xf;706 data->pwm_ctl[1] = (reg >> 4) & 0xf;707 data->pwm_ctl[ix] = (data->pwm_ctl[ix] & 8) | (val - 1);708 vt1211_write8(data, VT1211_REG_PWM_CTL,709 ((data->pwm_ctl[1] << 4) | data->pwm_ctl[0]));710 break;711 default:712 dev_dbg(dev, "Unknown attr fetch (%d)\n", fn);713 }714 715EXIT:716 mutex_unlock(&data->update_lock);717 return count;718}719 720/* ---------------------------------------------------------------------721 * PWM auto point definitions722 * ix = [0-1]723 * ap = [0-3]724 * --------------------------------------------------------------------- */725 726/*727 * pwm[ix+1]_auto_point[ap+1]_temp mapping table:728 * Note that there is only a single set of temp auto points that controls both729 * PWM controllers. We still create 2 sets of sysfs files to make it look730 * more consistent even though they map to the same registers.731 *732 * ix ap : description733 * -------------------734 * 0 0 : pwm1/2 off temperature (pwm_auto_temp[0])735 * 0 1 : pwm1/2 low speed temperature (pwm_auto_temp[1])736 * 0 2 : pwm1/2 high speed temperature (pwm_auto_temp[2])737 * 0 3 : pwm1/2 full speed temperature (pwm_auto_temp[3])738 * 1 0 : pwm1/2 off temperature (pwm_auto_temp[0])739 * 1 1 : pwm1/2 low speed temperature (pwm_auto_temp[1])740 * 1 2 : pwm1/2 high speed temperature (pwm_auto_temp[2])741 * 1 3 : pwm1/2 full speed temperature (pwm_auto_temp[3])742 */743 744static ssize_t show_pwm_auto_point_temp(struct device *dev,745 struct device_attribute *attr,746 char *buf)747{748 struct vt1211_data *data = vt1211_update_device(dev);749 struct sensor_device_attribute_2 *sensor_attr_2 =750 to_sensor_dev_attr_2(attr);751 int ix = sensor_attr_2->index;752 int ap = sensor_attr_2->nr;753 754 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->pwm_ctl[ix] & 7,755 data->pwm_auto_temp[ap]));756}757 758static ssize_t set_pwm_auto_point_temp(struct device *dev,759 struct device_attribute *attr,760 const char *buf, size_t count)761{762 struct vt1211_data *data = dev_get_drvdata(dev);763 struct sensor_device_attribute_2 *sensor_attr_2 =764 to_sensor_dev_attr_2(attr);765 int ix = sensor_attr_2->index;766 int ap = sensor_attr_2->nr;767 int reg;768 long val;769 int err;770 771 err = kstrtol(buf, 10, &val);772 if (err)773 return err;774 775 776 mutex_lock(&data->update_lock);777 778 /* sync the data cache */779 reg = vt1211_read8(data, VT1211_REG_PWM_CTL);780 data->pwm_ctl[0] = reg & 0xf;781 data->pwm_ctl[1] = (reg >> 4) & 0xf;782 783 data->pwm_auto_temp[ap] = TEMP_TO_REG(data->pwm_ctl[ix] & 7, val);784 vt1211_write8(data, VT1211_REG_PWM_AUTO_TEMP(ap),785 data->pwm_auto_temp[ap]);786 mutex_unlock(&data->update_lock);787 788 return count;789}790 791/*792 * pwm[ix+1]_auto_point[ap+1]_pwm mapping table:793 * Note that the PWM auto points 0 & 3 are hard-wired in the VT1211 and can't794 * be changed.795 *796 * ix ap : description797 * -------------------798 * 0 0 : pwm1 off (pwm_auto_pwm[0][0], hard-wired to 0)799 * 0 1 : pwm1 low speed duty cycle (pwm_auto_pwm[0][1])800 * 0 2 : pwm1 high speed duty cycle (pwm_auto_pwm[0][2])801 * 0 3 : pwm1 full speed (pwm_auto_pwm[0][3], hard-wired to 255)802 * 1 0 : pwm2 off (pwm_auto_pwm[1][0], hard-wired to 0)803 * 1 1 : pwm2 low speed duty cycle (pwm_auto_pwm[1][1])804 * 1 2 : pwm2 high speed duty cycle (pwm_auto_pwm[1][2])805 * 1 3 : pwm2 full speed (pwm_auto_pwm[1][3], hard-wired to 255)806 */807 808static ssize_t show_pwm_auto_point_pwm(struct device *dev,809 struct device_attribute *attr,810 char *buf)811{812 struct vt1211_data *data = vt1211_update_device(dev);813 struct sensor_device_attribute_2 *sensor_attr_2 =814 to_sensor_dev_attr_2(attr);815 int ix = sensor_attr_2->index;816 int ap = sensor_attr_2->nr;817 818 return sprintf(buf, "%d\n", data->pwm_auto_pwm[ix][ap]);819}820 821static ssize_t set_pwm_auto_point_pwm(struct device *dev,822 struct device_attribute *attr,823 const char *buf, size_t count)824{825 struct vt1211_data *data = dev_get_drvdata(dev);826 struct sensor_device_attribute_2 *sensor_attr_2 =827 to_sensor_dev_attr_2(attr);828 int ix = sensor_attr_2->index;829 int ap = sensor_attr_2->nr;830 unsigned long val;831 int err;832 833 err = kstrtoul(buf, 10, &val);834 if (err)835 return err;836 837 mutex_lock(&data->update_lock);838 data->pwm_auto_pwm[ix][ap] = clamp_val(val, 0, 255);839 vt1211_write8(data, VT1211_REG_PWM_AUTO_PWM(ix, ap),840 data->pwm_auto_pwm[ix][ap]);841 mutex_unlock(&data->update_lock);842 843 return count;844}845 846/* ---------------------------------------------------------------------847 * Miscellaneous sysfs interfaces (VRM, VID, name, and (legacy) alarms)848 * --------------------------------------------------------------------- */849 850static ssize_t show_vrm(struct device *dev, struct device_attribute *attr,851 char *buf)852{853 struct vt1211_data *data = dev_get_drvdata(dev);854 855 return sprintf(buf, "%d\n", data->vrm);856}857 858static ssize_t set_vrm(struct device *dev, struct device_attribute *attr,859 const char *buf, size_t count)860{861 struct vt1211_data *data = dev_get_drvdata(dev);862 unsigned long val;863 int err;864 865 err = kstrtoul(buf, 10, &val);866 if (err)867 return err;868 869 if (val > 255)870 return -EINVAL;871 872 data->vrm = val;873 874 return count;875}876 877static ssize_t show_vid(struct device *dev, struct device_attribute *attr,878 char *buf)879{880 struct vt1211_data *data = dev_get_drvdata(dev);881 882 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));883}884 885static ssize_t show_name(struct device *dev,886 struct device_attribute *attr, char *buf)887{888 struct vt1211_data *data = dev_get_drvdata(dev);889 890 return sprintf(buf, "%s\n", data->name);891}892 893static ssize_t show_alarms(struct device *dev,894 struct device_attribute *attr, char *buf)895{896 struct vt1211_data *data = vt1211_update_device(dev);897 898 return sprintf(buf, "%d\n", data->alarms);899}900 901/* ---------------------------------------------------------------------902 * Device attribute structs903 * --------------------------------------------------------------------- */904 905#define SENSOR_ATTR_IN(ix) \906{ SENSOR_ATTR_2(in##ix##_input, S_IRUGO, \907 show_in, NULL, SHOW_IN_INPUT, ix), \908 SENSOR_ATTR_2(in##ix##_min, S_IRUGO | S_IWUSR, \909 show_in, set_in, SHOW_SET_IN_MIN, ix), \910 SENSOR_ATTR_2(in##ix##_max, S_IRUGO | S_IWUSR, \911 show_in, set_in, SHOW_SET_IN_MAX, ix), \912 SENSOR_ATTR_2(in##ix##_alarm, S_IRUGO, \913 show_in, NULL, SHOW_IN_ALARM, ix) \914}915 916static struct sensor_device_attribute_2 vt1211_sysfs_in[][4] = {917 SENSOR_ATTR_IN(0),918 SENSOR_ATTR_IN(1),919 SENSOR_ATTR_IN(2),920 SENSOR_ATTR_IN(3),921 SENSOR_ATTR_IN(4),922 SENSOR_ATTR_IN(5)923};924 925#define IN_UNIT_ATTRS(X) \926{ &vt1211_sysfs_in[X][0].dev_attr.attr, \927 &vt1211_sysfs_in[X][1].dev_attr.attr, \928 &vt1211_sysfs_in[X][2].dev_attr.attr, \929 &vt1211_sysfs_in[X][3].dev_attr.attr, \930 NULL \931}932 933static struct attribute *vt1211_in_attr[][5] = {934 IN_UNIT_ATTRS(0),935 IN_UNIT_ATTRS(1),936 IN_UNIT_ATTRS(2),937 IN_UNIT_ATTRS(3),938 IN_UNIT_ATTRS(4),939 IN_UNIT_ATTRS(5)940};941 942static const struct attribute_group vt1211_in_attr_group[] = {943 { .attrs = vt1211_in_attr[0] },944 { .attrs = vt1211_in_attr[1] },945 { .attrs = vt1211_in_attr[2] },946 { .attrs = vt1211_in_attr[3] },947 { .attrs = vt1211_in_attr[4] },948 { .attrs = vt1211_in_attr[5] }949};950 951#define SENSOR_ATTR_TEMP(ix) \952{ SENSOR_ATTR_2(temp##ix##_input, S_IRUGO, \953 show_temp, NULL, SHOW_TEMP_INPUT, ix-1), \954 SENSOR_ATTR_2(temp##ix##_max, S_IRUGO | S_IWUSR, \955 show_temp, set_temp, SHOW_SET_TEMP_MAX, ix-1), \956 SENSOR_ATTR_2(temp##ix##_max_hyst, S_IRUGO | S_IWUSR, \957 show_temp, set_temp, SHOW_SET_TEMP_MAX_HYST, ix-1), \958 SENSOR_ATTR_2(temp##ix##_alarm, S_IRUGO, \959 show_temp, NULL, SHOW_TEMP_ALARM, ix-1) \960}961 962static struct sensor_device_attribute_2 vt1211_sysfs_temp[][4] = {963 SENSOR_ATTR_TEMP(1),964 SENSOR_ATTR_TEMP(2),965 SENSOR_ATTR_TEMP(3),966 SENSOR_ATTR_TEMP(4),967 SENSOR_ATTR_TEMP(5),968 SENSOR_ATTR_TEMP(6),969 SENSOR_ATTR_TEMP(7),970};971 972#define TEMP_UNIT_ATTRS(X) \973{ &vt1211_sysfs_temp[X][0].dev_attr.attr, \974 &vt1211_sysfs_temp[X][1].dev_attr.attr, \975 &vt1211_sysfs_temp[X][2].dev_attr.attr, \976 &vt1211_sysfs_temp[X][3].dev_attr.attr, \977 NULL \978}979 980static struct attribute *vt1211_temp_attr[][5] = {981 TEMP_UNIT_ATTRS(0),982 TEMP_UNIT_ATTRS(1),983 TEMP_UNIT_ATTRS(2),984 TEMP_UNIT_ATTRS(3),985 TEMP_UNIT_ATTRS(4),986 TEMP_UNIT_ATTRS(5),987 TEMP_UNIT_ATTRS(6)988};989 990static const struct attribute_group vt1211_temp_attr_group[] = {991 { .attrs = vt1211_temp_attr[0] },992 { .attrs = vt1211_temp_attr[1] },993 { .attrs = vt1211_temp_attr[2] },994 { .attrs = vt1211_temp_attr[3] },995 { .attrs = vt1211_temp_attr[4] },996 { .attrs = vt1211_temp_attr[5] },997 { .attrs = vt1211_temp_attr[6] }998};999 1000#define SENSOR_ATTR_FAN(ix) \1001 SENSOR_ATTR_2(fan##ix##_input, S_IRUGO, \1002 show_fan, NULL, SHOW_FAN_INPUT, ix-1), \1003 SENSOR_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \1004 show_fan, set_fan, SHOW_SET_FAN_MIN, ix-1), \1005 SENSOR_ATTR_2(fan##ix##_div, S_IRUGO | S_IWUSR, \1006 show_fan, set_fan, SHOW_SET_FAN_DIV, ix-1), \1007 SENSOR_ATTR_2(fan##ix##_alarm, S_IRUGO, \1008 show_fan, NULL, SHOW_FAN_ALARM, ix-1)1009 1010#define SENSOR_ATTR_PWM(ix) \1011 SENSOR_ATTR_2(pwm##ix, S_IRUGO, \1012 show_pwm, NULL, SHOW_PWM, ix-1), \1013 SENSOR_ATTR_2(pwm##ix##_enable, S_IRUGO | S_IWUSR, \1014 show_pwm, set_pwm, SHOW_SET_PWM_ENABLE, ix-1), \1015 SENSOR_ATTR_2(pwm##ix##_auto_channels_temp, S_IRUGO | S_IWUSR, \1016 show_pwm, set_pwm, SHOW_SET_PWM_AUTO_CHANNELS_TEMP, ix-1)1017 1018#define SENSOR_ATTR_PWM_FREQ(ix) \1019 SENSOR_ATTR_2(pwm##ix##_freq, S_IRUGO | S_IWUSR, \1020 show_pwm, set_pwm, SHOW_SET_PWM_FREQ, ix-1)1021 1022#define SENSOR_ATTR_PWM_FREQ_RO(ix) \1023 SENSOR_ATTR_2(pwm##ix##_freq, S_IRUGO, \1024 show_pwm, NULL, SHOW_SET_PWM_FREQ, ix-1)1025 1026#define SENSOR_ATTR_PWM_AUTO_POINT_TEMP(ix, ap) \1027 SENSOR_ATTR_2(pwm##ix##_auto_point##ap##_temp, S_IRUGO | S_IWUSR, \1028 show_pwm_auto_point_temp, set_pwm_auto_point_temp, \1029 ap-1, ix-1)1030 1031#define SENSOR_ATTR_PWM_AUTO_POINT_TEMP_RO(ix, ap) \1032 SENSOR_ATTR_2(pwm##ix##_auto_point##ap##_temp, S_IRUGO, \1033 show_pwm_auto_point_temp, NULL, \1034 ap-1, ix-1)1035 1036#define SENSOR_ATTR_PWM_AUTO_POINT_PWM(ix, ap) \1037 SENSOR_ATTR_2(pwm##ix##_auto_point##ap##_pwm, S_IRUGO | S_IWUSR, \1038 show_pwm_auto_point_pwm, set_pwm_auto_point_pwm, \1039 ap-1, ix-1)1040 1041#define SENSOR_ATTR_PWM_AUTO_POINT_PWM_RO(ix, ap) \1042 SENSOR_ATTR_2(pwm##ix##_auto_point##ap##_pwm, S_IRUGO, \1043 show_pwm_auto_point_pwm, NULL, \1044 ap-1, ix-1)1045 1046static struct sensor_device_attribute_2 vt1211_sysfs_fan_pwm[] = {1047 SENSOR_ATTR_FAN(1),1048 SENSOR_ATTR_FAN(2),1049 SENSOR_ATTR_PWM(1),1050 SENSOR_ATTR_PWM(2),1051 SENSOR_ATTR_PWM_FREQ(1),1052 SENSOR_ATTR_PWM_FREQ_RO(2),1053 SENSOR_ATTR_PWM_AUTO_POINT_TEMP(1, 1),1054 SENSOR_ATTR_PWM_AUTO_POINT_TEMP(1, 2),1055 SENSOR_ATTR_PWM_AUTO_POINT_TEMP(1, 3),1056 SENSOR_ATTR_PWM_AUTO_POINT_TEMP(1, 4),1057 SENSOR_ATTR_PWM_AUTO_POINT_TEMP_RO(2, 1),1058 SENSOR_ATTR_PWM_AUTO_POINT_TEMP_RO(2, 2),1059 SENSOR_ATTR_PWM_AUTO_POINT_TEMP_RO(2, 3),1060 SENSOR_ATTR_PWM_AUTO_POINT_TEMP_RO(2, 4),1061 SENSOR_ATTR_PWM_AUTO_POINT_PWM_RO(1, 1),1062 SENSOR_ATTR_PWM_AUTO_POINT_PWM(1, 2),1063 SENSOR_ATTR_PWM_AUTO_POINT_PWM(1, 3),1064 SENSOR_ATTR_PWM_AUTO_POINT_PWM_RO(1, 4),1065 SENSOR_ATTR_PWM_AUTO_POINT_PWM_RO(2, 1),1066 SENSOR_ATTR_PWM_AUTO_POINT_PWM(2, 2),1067 SENSOR_ATTR_PWM_AUTO_POINT_PWM(2, 3),1068 SENSOR_ATTR_PWM_AUTO_POINT_PWM_RO(2, 4),1069};1070 1071static struct device_attribute vt1211_sysfs_misc[] = {1072 __ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm),1073 __ATTR(cpu0_vid, S_IRUGO, show_vid, NULL),1074 __ATTR(name, S_IRUGO, show_name, NULL),1075 __ATTR(alarms, S_IRUGO, show_alarms, NULL),1076};1077 1078/* ---------------------------------------------------------------------1079 * Device registration and initialization1080 * --------------------------------------------------------------------- */1081 1082static void vt1211_init_device(struct vt1211_data *data)1083{1084 /* set VRM */1085 data->vrm = vid_which_vrm();1086 1087 /* Read (and initialize) UCH config */1088 data->uch_config = vt1211_read8(data, VT1211_REG_UCH_CONFIG);1089 if (uch_config > -1) {1090 data->uch_config = (data->uch_config & 0x83) |1091 (uch_config << 2);1092 vt1211_write8(data, VT1211_REG_UCH_CONFIG, data->uch_config);1093 }1094 1095 /*1096 * Initialize the interrupt mode (if request at module load time).1097 * The VT1211 implements 3 different modes for clearing interrupts:1098 * 0: Clear INT when status register is read. Regenerate INT as long1099 * as temp stays above hysteresis limit.1100 * 1: Clear INT when status register is read. DON'T regenerate INT1101 * until temp falls below hysteresis limit and exceeds hot limit1102 * again.1103 * 2: Clear INT when temp falls below max limit.1104 *1105 * The driver only allows to force mode 0 since that's the only one1106 * that makes sense for 'sensors'1107 */1108 if (int_mode == 0) {1109 vt1211_write8(data, VT1211_REG_TEMP1_CONFIG, 0);1110 vt1211_write8(data, VT1211_REG_TEMP2_CONFIG, 0);1111 }1112 1113 /* Fill in some hard wired values into our data struct */1114 data->pwm_auto_pwm[0][3] = 255;1115 data->pwm_auto_pwm[1][3] = 255;1116}1117 1118static void vt1211_remove_sysfs(struct platform_device *pdev)1119{1120 struct device *dev = &pdev->dev;1121 int i;1122 1123 for (i = 0; i < ARRAY_SIZE(vt1211_in_attr_group); i++)1124 sysfs_remove_group(&dev->kobj, &vt1211_in_attr_group[i]);1125 1126 for (i = 0; i < ARRAY_SIZE(vt1211_temp_attr_group); i++)1127 sysfs_remove_group(&dev->kobj, &vt1211_temp_attr_group[i]);1128 1129 for (i = 0; i < ARRAY_SIZE(vt1211_sysfs_fan_pwm); i++) {1130 device_remove_file(dev,1131 &vt1211_sysfs_fan_pwm[i].dev_attr);1132 }1133 for (i = 0; i < ARRAY_SIZE(vt1211_sysfs_misc); i++)1134 device_remove_file(dev, &vt1211_sysfs_misc[i]);1135}1136 1137static int vt1211_probe(struct platform_device *pdev)1138{1139 struct device *dev = &pdev->dev;1140 struct vt1211_data *data;1141 struct resource *res;1142 int i, err;1143 1144 data = devm_kzalloc(dev, sizeof(struct vt1211_data), GFP_KERNEL);1145 if (!data)1146 return -ENOMEM;1147 1148 res = platform_get_resource(pdev, IORESOURCE_IO, 0);1149 if (!devm_request_region(dev, res->start, resource_size(res),1150 DRVNAME)) {1151 dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",1152 (unsigned long)res->start, (unsigned long)res->end);1153 return -EBUSY;1154 }1155 data->addr = res->start;1156 data->name = DRVNAME;1157 mutex_init(&data->update_lock);1158 1159 platform_set_drvdata(pdev, data);1160 1161 /* Initialize the VT1211 chip */1162 vt1211_init_device(data);1163 1164 /* Create sysfs interface files */1165 for (i = 0; i < ARRAY_SIZE(vt1211_in_attr_group); i++) {1166 if (ISVOLT(i, data->uch_config)) {1167 err = sysfs_create_group(&dev->kobj,1168 &vt1211_in_attr_group[i]);1169 if (err)1170 goto EXIT_DEV_REMOVE;1171 }1172 }1173 for (i = 0; i < ARRAY_SIZE(vt1211_temp_attr_group); i++) {1174 if (ISTEMP(i, data->uch_config)) {1175 err = sysfs_create_group(&dev->kobj,1176 &vt1211_temp_attr_group[i]);1177 if (err)1178 goto EXIT_DEV_REMOVE;1179 }1180 }1181 for (i = 0; i < ARRAY_SIZE(vt1211_sysfs_fan_pwm); i++) {1182 err = device_create_file(dev,1183 &vt1211_sysfs_fan_pwm[i].dev_attr);1184 if (err)1185 goto EXIT_DEV_REMOVE;1186 }1187 for (i = 0; i < ARRAY_SIZE(vt1211_sysfs_misc); i++) {1188 err = device_create_file(dev,1189 &vt1211_sysfs_misc[i]);1190 if (err)1191 goto EXIT_DEV_REMOVE;1192 }1193 1194 /* Register device */1195 data->hwmon_dev = hwmon_device_register(dev);1196 if (IS_ERR(data->hwmon_dev)) {1197 err = PTR_ERR(data->hwmon_dev);1198 dev_err(dev, "Class registration failed (%d)\n", err);1199 goto EXIT_DEV_REMOVE_SILENT;1200 }1201 1202 return 0;1203 1204EXIT_DEV_REMOVE:1205 dev_err(dev, "Sysfs interface creation failed (%d)\n", err);1206EXIT_DEV_REMOVE_SILENT:1207 vt1211_remove_sysfs(pdev);1208 return err;1209}1210 1211static void vt1211_remove(struct platform_device *pdev)1212{1213 struct vt1211_data *data = platform_get_drvdata(pdev);1214 1215 hwmon_device_unregister(data->hwmon_dev);1216 vt1211_remove_sysfs(pdev);1217}1218 1219static struct platform_driver vt1211_driver = {1220 .driver = {1221 .name = DRVNAME,1222 },1223 .probe = vt1211_probe,1224 .remove_new = vt1211_remove,1225};1226 1227static int __init vt1211_device_add(unsigned short address)1228{1229 struct resource res = {1230 .start = address,1231 .end = address + 0x7f,1232 .flags = IORESOURCE_IO,1233 };1234 int err;1235 1236 pdev = platform_device_alloc(DRVNAME, address);1237 if (!pdev) {1238 err = -ENOMEM;1239 pr_err("Device allocation failed (%d)\n", err);1240 goto EXIT;1241 }1242 1243 res.name = pdev->name;1244 err = acpi_check_resource_conflict(&res);1245 if (err)1246 goto EXIT_DEV_PUT;1247 1248 err = platform_device_add_resources(pdev, &res, 1);1249 if (err) {1250 pr_err("Device resource addition failed (%d)\n", err);1251 goto EXIT_DEV_PUT;1252 }1253 1254 err = platform_device_add(pdev);1255 if (err) {1256 pr_err("Device addition failed (%d)\n", err);1257 goto EXIT_DEV_PUT;1258 }1259 1260 return 0;1261 1262EXIT_DEV_PUT:1263 platform_device_put(pdev);1264EXIT:1265 return err;1266}1267 1268static int __init vt1211_find(int sio_cip, unsigned short *address)1269{1270 int err;1271 int devid;1272 1273 err = superio_enter(sio_cip);1274 if (err)1275 return err;1276 1277 err = -ENODEV;1278 devid = force_id ? force_id : superio_inb(sio_cip, SIO_VT1211_DEVID);1279 if (devid != SIO_VT1211_ID)1280 goto EXIT;1281 1282 superio_select(sio_cip, SIO_VT1211_LDN_HWMON);1283 1284 if ((superio_inb(sio_cip, SIO_VT1211_ACTIVE) & 1) == 0) {1285 pr_warn("HW monitor is disabled, skipping\n");1286 goto EXIT;1287 }1288 1289 *address = ((superio_inb(sio_cip, SIO_VT1211_BADDR) << 8) |1290 (superio_inb(sio_cip, SIO_VT1211_BADDR + 1))) & 0xff00;1291 if (*address == 0) {1292 pr_warn("Base address is not set, skipping\n");1293 goto EXIT;1294 }1295 1296 err = 0;1297 pr_info("Found VT1211 chip at 0x%04x, revision %u\n",1298 *address, superio_inb(sio_cip, SIO_VT1211_DEVREV));1299 1300EXIT:1301 superio_exit(sio_cip);1302 return err;1303}1304 1305static int __init vt1211_init(void)1306{1307 int err;1308 unsigned short address = 0;1309 1310 err = vt1211_find(SIO_REG_CIP1, &address);1311 if (err) {1312 err = vt1211_find(SIO_REG_CIP2, &address);1313 if (err)1314 goto EXIT;1315 }1316 1317 if ((uch_config < -1) || (uch_config > 31)) {1318 err = -EINVAL;1319 pr_warn("Invalid UCH configuration %d. Choose a value between 0 and 31.\n",1320 uch_config);1321 goto EXIT;1322 }1323 1324 if ((int_mode < -1) || (int_mode > 0)) {1325 err = -EINVAL;1326 pr_warn("Invalid interrupt mode %d. Only mode 0 is supported.\n",1327 int_mode);1328 goto EXIT;1329 }1330 1331 err = platform_driver_register(&vt1211_driver);1332 if (err)1333 goto EXIT;1334 1335 /* Sets global pdev as a side effect */1336 err = vt1211_device_add(address);1337 if (err)1338 goto EXIT_DRV_UNREGISTER;1339 1340 return 0;1341 1342EXIT_DRV_UNREGISTER:1343 platform_driver_unregister(&vt1211_driver);1344EXIT:1345 return err;1346}1347 1348static void __exit vt1211_exit(void)1349{1350 platform_device_unregister(pdev);1351 platform_driver_unregister(&vt1211_driver);1352}1353 1354MODULE_AUTHOR("Juerg Haefliger <juergh@gmail.com>");1355MODULE_DESCRIPTION("VT1211 sensors");1356MODULE_LICENSE("GPL");1357 1358module_init(vt1211_init);1359module_exit(vt1211_exit);1360