Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code ยป

Commit c0b4e3ab0c769913438aeb078535ff117eeba5fb

Authored by Darrick J. Wong
Committed by Linus Torvalds
1 parent 455fbdd376
Exists in master and in 20 other branches dlt-processor-sdk-linux-03.00.00.04, newt-ti-linux-3.12.y, processor-sdk-linux-01.00.00, processor-sdk-linux-02.00.01, smarc-ti-linux-3.12.10, smarc-ti-linux-3.12.y, smarc-ti-linux-3.14.y, smarc-ti-linux-3.15.y, smarc-ti-lsk-linux-4.1.y, smarct3x-processor-sdk-04.01.00.06, smarct3x-processor-sdk-linux-02.00.01, smarct3x-processor-sdk-linux-03.00.00.04, smarct4x-800-processor-sdk-linux-02.00.01, smarct4x-processor-sdk-04.01.00.06, smarct4x-processor-sdk-linux-02.00.01, smarct4x-processor-sdk-linux-03.00.00.04, ti-linux-3.12.y, ti-linux-3.14.y, ti-linux-3.15.y, ti-lsk-linux-4.1.y

adt7462: new hwmon driver 

New driver to play with.  As Jean mentioned a couple of years ago, this
chip is a beast with odd combinations of 8 fans, 4 temperatures, and 13
voltage sensors.  This driver has been tested on an IntelliStation Z30.

Signed-off-by: Darrick J. Wong <djwong@us.ibm.com>
Cc: Jean Delvare <khali@linux-fr.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 4 changed files with 2080 additions and 0 deletions Side-by-side Diff

Documentation/hwmon/adt7462
Diff comments   View file @ c0b4e3a
  1 +Kernel driver adt7462
  2 +======================
  3 +
  4 +Supported chips:
  5 + * Analog Devices ADT7462
  6 + Prefix: 'adt7462'
  7 + Addresses scanned: I2C 0x58, 0x5C
  8 + Datasheet: Publicly available at the Analog Devices website
  9 +
  10 +Author: Darrick J. Wong
  11 +
  12 +Description
  13 +-----------
  14 +
  15 +This driver implements support for the Analog Devices ADT7462 chip family.
  16 +
  17 +This chip is a bit of a beast. It has 8 counters for measuring fan speed. It
  18 +can also measure 13 voltages or 4 temperatures, or various combinations of the
  19 +two. See the chip documentation for more details about the exact set of
  20 +configurations. This driver does not allow one to configure the chip; that is
  21 +left to the system designer.
  22 +
  23 +A sophisticated control system for the PWM outputs is designed into the ADT7462
  24 +that allows fan speed to be adjusted automatically based on any of the three
  25 +temperature sensors. Each PWM output is individually adjustable and
  26 +programmable. Once configured, the ADT7462 will adjust the PWM outputs in
  27 +response to the measured temperatures without further host intervention. This
  28 +feature can also be disabled for manual control of the PWM's.
  29 +
  30 +Each of the measured inputs (voltage, temperature, fan speed) has
  31 +corresponding high/low limit values. The ADT7462 will signal an ALARM if
  32 +any measured value exceeds either limit.
  33 +
  34 +The ADT7462 samples all inputs continuously. The driver will not read
  35 +the registers more often than once every other second. Further,
  36 +configuration data is only read once per minute.
  37 +
  38 +Special Features
  39 +----------------
  40 +
  41 +The ADT7462 have a 10-bit ADC and can therefore measure temperatures
  42 +with 0.25 degC resolution.
  43 +
  44 +The Analog Devices datasheet is very detailed and describes a procedure for
  45 +determining an optimal configuration for the automatic PWM control.
  46 +
  47 +The driver will report sensor labels when it is able to determine that
  48 +information from the configuration registers.
  49 +
  50 +Configuration Notes
  51 +-------------------
  52 +
  53 +Besides standard interfaces driver adds the following:
  54 +
  55 +* PWM Control
  56 +
  57 +* pwm#_auto_point1_pwm and temp#_auto_point1_temp and
  58 +* pwm#_auto_point2_pwm and temp#_auto_point2_temp -
  59 +
  60 +point1: Set the pwm speed at a lower temperature bound.
  61 +point2: Set the pwm speed at a higher temperature bound.
  62 +
  63 +The ADT7462 will scale the pwm between the lower and higher pwm speed when
  64 +the temperature is between the two temperature boundaries. PWM values range
  65 +from 0 (off) to 255 (full speed). Fan speed will be set to maximum when the
  66 +temperature sensor associated with the PWM control exceeds temp#_max.
drivers/hwmon/Kconfig
Diff comments   View file @ c0b4e3a
... ... @@ -159,6 +159,16 @@
159 159 This driver can also be built as a module. If so, the module
160 160 will be called adm9240.
161 161  
  162 +config SENSORS_ADT7462
  163 + tristate "Analog Devices ADT7462"
  164 + depends on I2C && EXPERIMENTAL
  165 + help
  166 + If you say yes here you get support for the Analog Devices
  167 + ADT7462 temperature monitoring chips.
  168 +
  169 + This driver can also be built as a module. If so, the module
  170 + will be called adt7462.
  171 +
162 172 config SENSORS_ADT7470
163 173 tristate "Analog Devices ADT7470"
164 174 depends on I2C && EXPERIMENTAL
drivers/hwmon/Makefile
Diff comments   View file @ c0b4e3a
... ... @@ -25,6 +25,7 @@
25 25 obj-$(CONFIG_SENSORS_ADM1031) += adm1031.o
26 26 obj-$(CONFIG_SENSORS_ADM9240) += adm9240.o
27 27 obj-$(CONFIG_SENSORS_ADS7828) += ads7828.o
  28 +obj-$(CONFIG_SENSORS_ADT7462) += adt7462.o
28 29 obj-$(CONFIG_SENSORS_ADT7470) += adt7470.o
29 30 obj-$(CONFIG_SENSORS_ADT7473) += adt7473.o
30 31 obj-$(CONFIG_SENSORS_APPLESMC) += applesmc.o
drivers/hwmon/adt7462.c
Diff comments   View file @ c0b4e3a
Changes suppressed. Click to show
  1 +/*
  2 + * A hwmon driver for the Analog Devices ADT7462
  3 + * Copyright (C) 2008 IBM
  4 + *
  5 + * Author: Darrick J. Wong <djwong@us.ibm.com>
  6 + *
  7 + * This program is free software; you can redistribute it and/or modify
  8 + * it under the terms of the GNU General Public License as published by
  9 + * the Free Software Foundation; either version 2 of the License, or
  10 + * (at your option) any later version.
  11 + *
  12 + * This program is distributed in the hope that it will be useful,
  13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 + * GNU General Public License for more details.
  16 + *
  17 + * You should have received a copy of the GNU General Public License
  18 + * along with this program; if not, write to the Free Software
  19 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20 + */
  21 +
  22 +#include <linux/module.h>
  23 +#include <linux/jiffies.h>
  24 +#include <linux/i2c.h>
  25 +#include <linux/hwmon.h>
  26 +#include <linux/hwmon-sysfs.h>
  27 +#include <linux/err.h>
  28 +#include <linux/mutex.h>
  29 +#include <linux/delay.h>
  30 +#include <linux/log2.h>
  31 +
  32 +/* Addresses to scan */
  33 +static const unsigned short normal_i2c[] = { 0x58, 0x5C, I2C_CLIENT_END };
  34 +
  35 +/* Insmod parameters */
  36 +I2C_CLIENT_INSMOD_1(adt7462);
  37 +
  38 +/* ADT7462 registers */
  39 +#define ADT7462_REG_DEVICE 0x3D
  40 +#define ADT7462_REG_VENDOR 0x3E
  41 +#define ADT7462_REG_REVISION 0x3F
  42 +
  43 +#define ADT7462_REG_MIN_TEMP_BASE_ADDR 0x44
  44 +#define ADT7462_REG_MIN_TEMP_MAX_ADDR 0x47
  45 +#define ADT7462_REG_MAX_TEMP_BASE_ADDR 0x48
  46 +#define ADT7462_REG_MAX_TEMP_MAX_ADDR 0x4B
  47 +#define ADT7462_REG_TEMP_BASE_ADDR 0x88
  48 +#define ADT7462_REG_TEMP_MAX_ADDR 0x8F
  49 +
  50 +#define ADT7462_REG_FAN_BASE_ADDR 0x98
  51 +#define ADT7462_REG_FAN_MAX_ADDR 0x9F
  52 +#define ADT7462_REG_FAN2_BASE_ADDR 0xA2
  53 +#define ADT7462_REG_FAN2_MAX_ADDR 0xA9
  54 +#define ADT7462_REG_FAN_ENABLE 0x07
  55 +#define ADT7462_REG_FAN_MIN_BASE_ADDR 0x78
  56 +#define ADT7462_REG_FAN_MIN_MAX_ADDR 0x7F
  57 +
  58 +#define ADT7462_REG_CFG2 0x02
  59 +#define ADT7462_FSPD_MASK 0x20
  60 +
  61 +#define ADT7462_REG_PWM_BASE_ADDR 0xAA
  62 +#define ADT7462_REG_PWM_MAX_ADDR 0xAD
  63 +#define ADT7462_REG_PWM_MIN_BASE_ADDR 0x28
  64 +#define ADT7462_REG_PWM_MIN_MAX_ADDR 0x2B
  65 +#define ADT7462_REG_PWM_MAX 0x2C
  66 +#define ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR 0x5C
  67 +#define ADT7462_REG_PWM_TEMP_MIN_MAX_ADDR 0x5F
  68 +#define ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR 0x60
  69 +#define ADT7462_REG_PWM_TEMP_RANGE_MAX_ADDR 0x63
  70 +#define ADT7462_PWM_HYST_MASK 0x0F
  71 +#define ADT7462_PWM_RANGE_MASK 0xF0
  72 +#define ADT7462_PWM_RANGE_SHIFT 4
  73 +#define ADT7462_REG_PWM_CFG_BASE_ADDR 0x21
  74 +#define ADT7462_REG_PWM_CFG_MAX_ADDR 0x24
  75 +#define ADT7462_PWM_CHANNEL_MASK 0xE0
  76 +#define ADT7462_PWM_CHANNEL_SHIFT 5
  77 +
  78 +#define ADT7462_REG_PIN_CFG_BASE_ADDR 0x10
  79 +#define ADT7462_REG_PIN_CFG_MAX_ADDR 0x13
  80 +#define ADT7462_PIN7_INPUT 0x01 /* cfg0 */
  81 +#define ADT7462_DIODE3_INPUT 0x20
  82 +#define ADT7462_DIODE1_INPUT 0x40
  83 +#define ADT7462_VID_INPUT 0x80
  84 +#define ADT7462_PIN22_INPUT 0x04 /* cfg1 */
  85 +#define ADT7462_PIN21_INPUT 0x08
  86 +#define ADT7462_PIN19_INPUT 0x10
  87 +#define ADT7462_PIN15_INPUT 0x20
  88 +#define ADT7462_PIN13_INPUT 0x40
  89 +#define ADT7462_PIN8_INPUT 0x80
  90 +#define ADT7462_PIN23_MASK 0x03
  91 +#define ADT7462_PIN23_SHIFT 0
  92 +#define ADT7462_PIN26_MASK 0x0C /* cfg2 */
  93 +#define ADT7462_PIN26_SHIFT 2
  94 +#define ADT7462_PIN25_MASK 0x30
  95 +#define ADT7462_PIN25_SHIFT 4
  96 +#define ADT7462_PIN24_MASK 0xC0
  97 +#define ADT7462_PIN24_SHIFT 6
  98 +#define ADT7462_PIN26_VOLT_INPUT 0x08
  99 +#define ADT7462_PIN25_VOLT_INPUT 0x20
  100 +#define ADT7462_PIN28_SHIFT 6 /* cfg3 */
  101 +#define ADT7462_PIN28_VOLT 0x5
  102 +
  103 +#define ADT7462_REG_ALARM1 0xB8
  104 +#define ADT7462_LT_ALARM 0x02
  105 +#define ADT7462_R1T_ALARM 0x04
  106 +#define ADT7462_R2T_ALARM 0x08
  107 +#define ADT7462_R3T_ALARM 0x10
  108 +#define ADT7462_REG_ALARM2 0xBB
  109 +#define ADT7462_V0_ALARM 0x01
  110 +#define ADT7462_V1_ALARM 0x02
  111 +#define ADT7462_V2_ALARM 0x04
  112 +#define ADT7462_V3_ALARM 0x08
  113 +#define ADT7462_V4_ALARM 0x10
  114 +#define ADT7462_V5_ALARM 0x20
  115 +#define ADT7462_V6_ALARM 0x40
  116 +#define ADT7462_V7_ALARM 0x80
  117 +#define ADT7462_REG_ALARM3 0xBC
  118 +#define ADT7462_V8_ALARM 0x08
  119 +#define ADT7462_V9_ALARM 0x10
  120 +#define ADT7462_V10_ALARM 0x20
  121 +#define ADT7462_V11_ALARM 0x40
  122 +#define ADT7462_V12_ALARM 0x80
  123 +#define ADT7462_REG_ALARM4 0xBD
  124 +#define ADT7462_F0_ALARM 0x01
  125 +#define ADT7462_F1_ALARM 0x02
  126 +#define ADT7462_F2_ALARM 0x04
  127 +#define ADT7462_F3_ALARM 0x08
  128 +#define ADT7462_F4_ALARM 0x10
  129 +#define ADT7462_F5_ALARM 0x20
  130 +#define ADT7462_F6_ALARM 0x40
  131 +#define ADT7462_F7_ALARM 0x80
  132 +#define ADT7462_ALARM1 0x0000
  133 +#define ADT7462_ALARM2 0x0100
  134 +#define ADT7462_ALARM3 0x0200
  135 +#define ADT7462_ALARM4 0x0300
  136 +#define ADT7462_ALARM_REG_SHIFT 8
  137 +#define ADT7462_ALARM_FLAG_MASK 0x0F
  138 +
  139 +#define ADT7462_TEMP_COUNT 4
  140 +#define ADT7462_TEMP_REG(x) (ADT7462_REG_TEMP_BASE_ADDR + (x * 2))
  141 +#define ADT7462_TEMP_MIN_REG(x) (ADT7462_REG_MIN_TEMP_BASE_ADDR + (x))
  142 +#define ADT7462_TEMP_MAX_REG(x) (ADT7462_REG_MAX_TEMP_BASE_ADDR + (x))
  143 +#define TEMP_FRAC_OFFSET 6
  144 +
  145 +#define ADT7462_FAN_COUNT 8
  146 +#define ADT7462_REG_FAN_MIN(x) (ADT7462_REG_FAN_MIN_BASE_ADDR + (x))
  147 +
  148 +#define ADT7462_PWM_COUNT 4
  149 +#define ADT7462_REG_PWM(x) (ADT7462_REG_PWM_BASE_ADDR + (x))
  150 +#define ADT7462_REG_PWM_MIN(x) (ADT7462_REG_PWM_MIN_BASE_ADDR + (x))
  151 +#define ADT7462_REG_PWM_TMIN(x) \
  152 + (ADT7462_REG_PWM_TEMP_MIN_BASE_ADDR + (x))
  153 +#define ADT7462_REG_PWM_TRANGE(x) \
  154 + (ADT7462_REG_PWM_TEMP_RANGE_BASE_ADDR + (x))
  155 +
  156 +#define ADT7462_PIN_CFG_REG_COUNT 4
  157 +#define ADT7462_REG_PIN_CFG(x) (ADT7462_REG_PIN_CFG_BASE_ADDR + (x))
  158 +#define ADT7462_REG_PWM_CFG(x) (ADT7462_REG_PWM_CFG_BASE_ADDR + (x))
  159 +
  160 +#define ADT7462_ALARM_REG_COUNT 4
  161 +
  162 +/*
  163 + * The chip can measure 13 different voltage sources:
  164 + *
  165 + * 1. +12V1 (pin 7)
  166 + * 2. Vccp1/+2.5V/+1.8V/+1.5V (pin 23)
  167 + * 3. +12V3 (pin 22)
  168 + * 4. +5V (pin 21)
  169 + * 5. +1.25V/+0.9V (pin 19)
  170 + * 6. +2.5V/+1.8V (pin 15)
  171 + * 7. +3.3v (pin 13)
  172 + * 8. +12V2 (pin 8)
  173 + * 9. Vbatt/FSB_Vtt (pin 26)
  174 + * A. +3.3V/+1.2V1 (pin 25)
  175 + * B. Vccp2/+2.5V/+1.8V/+1.5V (pin 24)
  176 + * C. +1.5V ICH (only if BOTH pin 28/29 are set to +1.5V)
  177 + * D. +1.5V 3GPIO (only if BOTH pin 28/29 are set to +1.5V)
  178 + *
  179 + * Each of these 13 has a factor to convert raw to voltage. Even better,
  180 + * the pins can be connected to other sensors (tach/gpio/hot/etc), which
  181 + * makes the bookkeeping tricky.
  182 + *
  183 + * Some, but not all, of these voltages have low/high limits.
  184 + */
  185 +#define ADT7462_VOLT_COUNT 12
  186 +
  187 +#define ADT7462_VENDOR 0x41
  188 +#define ADT7462_DEVICE 0x62
  189 +/* datasheet only mentions a revision 4 */
  190 +#define ADT7462_REVISION 0x04
  191 +
  192 +/* How often do we reread sensors values? (In jiffies) */
  193 +#define SENSOR_REFRESH_INTERVAL (2 * HZ)
  194 +
  195 +/* How often do we reread sensor limit values? (In jiffies) */
  196 +#define LIMIT_REFRESH_INTERVAL (60 * HZ)
  197 +
  198 +/* datasheet says to divide this number by the fan reading to get fan rpm */
  199 +#define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
  200 +#define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
  201 +#define FAN_PERIOD_INVALID 65535
  202 +#define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
  203 +
  204 +#define MASK_AND_SHIFT(value, prefix) \
  205 + (((value) & prefix##_MASK) >> prefix##_SHIFT)
  206 +
  207 +#define ROUND_DIV(x, divisor) (((x) + ((divisor) / 2)) / (divisor))
  208 +
  209 +struct adt7462_data {
  210 + struct device *hwmon_dev;
  211 + struct attribute_group attrs;
  212 + struct mutex lock;
  213 + char sensors_valid;
  214 + char limits_valid;
  215 + unsigned long sensors_last_updated; /* In jiffies */
  216 + unsigned long limits_last_updated; /* In jiffies */
  217 +
  218 + u8 temp[ADT7462_TEMP_COUNT];
  219 + /* bits 6-7 are quarter pieces of temp */
  220 + u8 temp_frac[ADT7462_TEMP_COUNT];
  221 + u8 temp_min[ADT7462_TEMP_COUNT];
  222 + u8 temp_max[ADT7462_TEMP_COUNT];
  223 + u16 fan[ADT7462_FAN_COUNT];
  224 + u8 fan_enabled;
  225 + u8 fan_min[ADT7462_FAN_COUNT];
  226 + u8 cfg2;
  227 + u8 pwm[ADT7462_PWM_COUNT];
  228 + u8 pin_cfg[ADT7462_PIN_CFG_REG_COUNT];
  229 + u8 voltages[ADT7462_VOLT_COUNT];
  230 + u8 volt_max[ADT7462_VOLT_COUNT];
  231 + u8 volt_min[ADT7462_VOLT_COUNT];
  232 + u8 pwm_min[ADT7462_PWM_COUNT];
  233 + u8 pwm_tmin[ADT7462_PWM_COUNT];
  234 + u8 pwm_trange[ADT7462_PWM_COUNT];
  235 + u8 pwm_max; /* only one per chip */
  236 + u8 pwm_cfg[ADT7462_PWM_COUNT];
  237 + u8 alarms[ADT7462_ALARM_REG_COUNT];
  238 +};
  239 +
  240 +static int adt7462_probe(struct i2c_client *client,
  241 + const struct i2c_device_id *id);
  242 +static int adt7462_detect(struct i2c_client *client, int kind,
  243 + struct i2c_board_info *info);
  244 +static int adt7462_remove(struct i2c_client *client);
  245 +
  246 +static const struct i2c_device_id adt7462_id[] = {
  247 + { "adt7462", adt7462 },
  248 + { }
  249 +};
  250 +MODULE_DEVICE_TABLE(i2c, adt7462_id);
  251 +
  252 +static struct i2c_driver adt7462_driver = {
  253 + .class = I2C_CLASS_HWMON,
  254 + .driver = {
  255 + .name = "adt7462",
  256 + },
  257 + .probe = adt7462_probe,
  258 + .remove = adt7462_remove,
  259 + .id_table = adt7462_id,
  260 + .detect = adt7462_detect,
  261 + .address_data = &addr_data,
  262 +};
  263 +
  264 +/*
  265 + * 16-bit registers on the ADT7462 are low-byte first. The data sheet says
  266 + * that the low byte must be read before the high byte.
  267 + */
  268 +static inline int adt7462_read_word_data(struct i2c_client *client, u8 reg)
  269 +{
  270 + u16 foo;
  271 + foo = i2c_smbus_read_byte_data(client, reg);
  272 + foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
  273 + return foo;
  274 +}
  275 +
  276 +/* For some reason these registers are not contiguous. */
  277 +static int ADT7462_REG_FAN(int fan)
  278 +{
  279 + if (fan < 4)
  280 + return ADT7462_REG_FAN_BASE_ADDR + (2 * fan);
  281 + return ADT7462_REG_FAN2_BASE_ADDR + (2 * (fan - 4));
  282 +}
  283 +
  284 +/* Voltage registers are scattered everywhere */
  285 +static int ADT7462_REG_VOLT_MAX(struct adt7462_data *data, int which)
  286 +{
  287 + switch (which) {
  288 + case 0:
  289 + if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
  290 + return 0x7C;
  291 + break;
  292 + case 1:
  293 + return 0x69;
  294 + case 2:
  295 + if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
  296 + return 0x7F;
  297 + break;
  298 + case 3:
  299 + if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
  300 + return 0x7E;
  301 + break;
  302 + case 4:
  303 + if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
  304 + return 0x4B;
  305 + break;
  306 + case 5:
  307 + if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
  308 + return 0x49;
  309 + break;
  310 + case 6:
  311 + if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
  312 + return 0x68;
  313 + break;
  314 + case 7:
  315 + if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
  316 + return 0x7D;
  317 + break;
  318 + case 8:
  319 + if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
  320 + return 0x6C;
  321 + break;
  322 + case 9:
  323 + if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
  324 + return 0x6B;
  325 + break;
  326 + case 10:
  327 + return 0x6A;
  328 + case 11:
  329 + if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  330 + ADT7462_PIN28_VOLT &&
  331 + !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  332 + return 0x50;
  333 + break;
  334 + case 12:
  335 + if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  336 + ADT7462_PIN28_VOLT &&
  337 + !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  338 + return 0x4C;
  339 + break;
  340 + }
  341 + return -ENODEV;
  342 +}
  343 +
  344 +static int ADT7462_REG_VOLT_MIN(struct adt7462_data *data, int which)
  345 +{
  346 + switch (which) {
  347 + case 0:
  348 + if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
  349 + return 0x6D;
  350 + break;
  351 + case 1:
  352 + return 0x72;
  353 + case 2:
  354 + if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
  355 + return 0x6F;
  356 + break;
  357 + case 3:
  358 + if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
  359 + return 0x71;
  360 + break;
  361 + case 4:
  362 + if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
  363 + return 0x47;
  364 + break;
  365 + case 5:
  366 + if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
  367 + return 0x45;
  368 + break;
  369 + case 6:
  370 + if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
  371 + return 0x70;
  372 + break;
  373 + case 7:
  374 + if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
  375 + return 0x6E;
  376 + break;
  377 + case 8:
  378 + if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
  379 + return 0x75;
  380 + break;
  381 + case 9:
  382 + if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
  383 + return 0x74;
  384 + break;
  385 + case 10:
  386 + return 0x73;
  387 + case 11:
  388 + if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  389 + ADT7462_PIN28_VOLT &&
  390 + !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  391 + return 0x76;
  392 + break;
  393 + case 12:
  394 + if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  395 + ADT7462_PIN28_VOLT &&
  396 + !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  397 + return 0x77;
  398 + break;
  399 + }
  400 + return -ENODEV;
  401 +}
  402 +
  403 +static int ADT7462_REG_VOLT(struct adt7462_data *data, int which)
  404 +{
  405 + switch (which) {
  406 + case 0:
  407 + if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
  408 + return 0xA3;
  409 + break;
  410 + case 1:
  411 + return 0x90;
  412 + case 2:
  413 + if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
  414 + return 0xA9;
  415 + break;
  416 + case 3:
  417 + if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
  418 + return 0xA7;
  419 + break;
  420 + case 4:
  421 + if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT))
  422 + return 0x8F;
  423 + break;
  424 + case 5:
  425 + if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT))
  426 + return 0x8B;
  427 + break;
  428 + case 6:
  429 + if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
  430 + return 0x96;
  431 + break;
  432 + case 7:
  433 + if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
  434 + return 0xA5;
  435 + break;
  436 + case 8:
  437 + if (!(data->pin_cfg[2] & ADT7462_PIN26_VOLT_INPUT))
  438 + return 0x93;
  439 + break;
  440 + case 9:
  441 + if (!(data->pin_cfg[2] & ADT7462_PIN25_VOLT_INPUT))
  442 + return 0x92;
  443 + break;
  444 + case 10:
  445 + return 0x91;
  446 + case 11:
  447 + if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  448 + ADT7462_PIN28_VOLT &&
  449 + !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  450 + return 0x94;
  451 + break;
  452 + case 12:
  453 + if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  454 + ADT7462_PIN28_VOLT &&
  455 + !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  456 + return 0x95;
  457 + break;
  458 + }
  459 + return -ENODEV;
  460 +}
  461 +
  462 +/* Provide labels for sysfs */
  463 +static const char *voltage_label(struct adt7462_data *data, int which)
  464 +{
  465 + switch (which) {
  466 + case 0:
  467 + if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
  468 + return "+12V1";
  469 + break;
  470 + case 1:
  471 + switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
  472 + case 0:
  473 + return "Vccp1";
  474 + case 1:
  475 + return "+2.5V";
  476 + case 2:
  477 + return "+1.8V";
  478 + case 3:
  479 + return "+1.5V";
  480 + }
  481 + case 2:
  482 + if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
  483 + return "+12V3";
  484 + break;
  485 + case 3:
  486 + if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
  487 + return "+5V";
  488 + break;
  489 + case 4:
  490 + if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
  491 + if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
  492 + return "+0.9V";
  493 + return "+1.25V";
  494 + }
  495 + break;
  496 + case 5:
  497 + if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
  498 + if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
  499 + return "+1.8V";
  500 + return "+2.5V";
  501 + }
  502 + break;
  503 + case 6:
  504 + if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
  505 + return "+3.3V";
  506 + break;
  507 + case 7:
  508 + if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
  509 + return "+12V2";
  510 + break;
  511 + case 8:
  512 + switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
  513 + case 0:
  514 + return "Vbatt";
  515 + case 1:
  516 + return "FSB_Vtt";
  517 + }
  518 + break;
  519 + case 9:
  520 + switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
  521 + case 0:
  522 + return "+3.3V";
  523 + case 1:
  524 + return "+1.2V1";
  525 + }
  526 + break;
  527 + case 10:
  528 + switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
  529 + case 0:
  530 + return "Vccp2";
  531 + case 1:
  532 + return "+2.5V";
  533 + case 2:
  534 + return "+1.8V";
  535 + case 3:
  536 + return "+1.5";
  537 + }
  538 + case 11:
  539 + if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  540 + ADT7462_PIN28_VOLT &&
  541 + !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  542 + return "+1.5V ICH";
  543 + break;
  544 + case 12:
  545 + if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  546 + ADT7462_PIN28_VOLT &&
  547 + !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  548 + return "+1.5V 3GPIO";
  549 + break;
  550 + }
  551 + return "N/A";
  552 +}
  553 +
  554 +/* Multipliers are actually in uV, not mV. */
  555 +static int voltage_multiplier(struct adt7462_data *data, int which)
  556 +{
  557 + switch (which) {
  558 + case 0:
  559 + if (!(data->pin_cfg[0] & ADT7462_PIN7_INPUT))
  560 + return 62500;
  561 + break;
  562 + case 1:
  563 + switch (MASK_AND_SHIFT(data->pin_cfg[1], ADT7462_PIN23)) {
  564 + case 0:
  565 + if (data->pin_cfg[0] & ADT7462_VID_INPUT)
  566 + return 12500;
  567 + return 6250;
  568 + case 1:
  569 + return 13000;
  570 + case 2:
  571 + return 9400;
  572 + case 3:
  573 + return 7800;
  574 + }
  575 + case 2:
  576 + if (!(data->pin_cfg[1] & ADT7462_PIN22_INPUT))
  577 + return 62500;
  578 + break;
  579 + case 3:
  580 + if (!(data->pin_cfg[1] & ADT7462_PIN21_INPUT))
  581 + return 26000;
  582 + break;
  583 + case 4:
  584 + if (!(data->pin_cfg[0] & ADT7462_DIODE3_INPUT)) {
  585 + if (data->pin_cfg[1] & ADT7462_PIN19_INPUT)
  586 + return 4690;
  587 + return 6500;
  588 + }
  589 + break;
  590 + case 5:
  591 + if (!(data->pin_cfg[0] & ADT7462_DIODE1_INPUT)) {
  592 + if (data->pin_cfg[1] & ADT7462_PIN15_INPUT)
  593 + return 9400;
  594 + return 13000;
  595 + }
  596 + break;
  597 + case 6:
  598 + if (!(data->pin_cfg[1] & ADT7462_PIN13_INPUT))
  599 + return 17200;
  600 + break;
  601 + case 7:
  602 + if (!(data->pin_cfg[1] & ADT7462_PIN8_INPUT))
  603 + return 62500;
  604 + break;
  605 + case 8:
  606 + switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN26)) {
  607 + case 0:
  608 + return 15600;
  609 + case 1:
  610 + return 6250;
  611 + }
  612 + break;
  613 + case 9:
  614 + switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN25)) {
  615 + case 0:
  616 + return 17200;
  617 + case 1:
  618 + return 6250;
  619 + }
  620 + break;
  621 + case 10:
  622 + switch (MASK_AND_SHIFT(data->pin_cfg[2], ADT7462_PIN24)) {
  623 + case 0:
  624 + return 6250;
  625 + case 1:
  626 + return 13000;
  627 + case 2:
  628 + return 9400;
  629 + case 3:
  630 + return 7800;
  631 + }
  632 + case 11:
  633 + case 12:
  634 + if (data->pin_cfg[3] >> ADT7462_PIN28_SHIFT ==
  635 + ADT7462_PIN28_VOLT &&
  636 + !(data->pin_cfg[0] & ADT7462_VID_INPUT))
  637 + return 7800;
  638 + }
  639 + return 0;
  640 +}
  641 +
  642 +static int temp_enabled(struct adt7462_data *data, int which)
  643 +{
  644 + switch (which) {
  645 + case 0:
  646 + case 2:
  647 + return 1;
  648 + case 1:
  649 + if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
  650 + return 1;
  651 + break;
  652 + case 3:
  653 + if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
  654 + return 1;
  655 + break;
  656 + }
  657 + return 0;
  658 +}
  659 +
  660 +static const char *temp_label(struct adt7462_data *data, int which)
  661 +{
  662 + switch (which) {
  663 + case 0:
  664 + return "local";
  665 + case 1:
  666 + if (data->pin_cfg[0] & ADT7462_DIODE1_INPUT)
  667 + return "remote1";
  668 + break;
  669 + case 2:
  670 + return "remote2";
  671 + case 3:
  672 + if (data->pin_cfg[0] & ADT7462_DIODE3_INPUT)
  673 + return "remote3";
  674 + break;
  675 + }
  676 + return "N/A";
  677 +}
  678 +
  679 +/* Map Trange register values to mC */
  680 +#define NUM_TRANGE_VALUES 16
  681 +static const int trange_values[NUM_TRANGE_VALUES] = {
  682 + 2000,
  683 + 2500,
  684 + 3300,
  685 + 4000,
  686 + 5000,
  687 + 6700,
  688 + 8000,
  689 + 10000,
  690 + 13300,
  691 + 16000,
  692 + 20000,
  693 + 26700,
  694 + 32000,
  695 + 40000,
  696 + 53300,
  697 + 80000
  698 +};
  699 +
  700 +static int find_trange_value(int trange)
  701 +{
  702 + int i;
  703 +
  704 + for (i = 0; i < NUM_TRANGE_VALUES; i++)
  705 + if (trange_values[i] == trange)
  706 + return i;
  707 +
  708 + return -ENODEV;
  709 +}
  710 +
  711 +static struct adt7462_data *adt7462_update_device(struct device *dev)
  712 +{
  713 + struct i2c_client *client = to_i2c_client(dev);
  714 + struct adt7462_data *data = i2c_get_clientdata(client);
  715 + unsigned long local_jiffies = jiffies;
  716 + int i;
  717 +
  718 + mutex_lock(&data->lock);
  719 + if (time_before(local_jiffies, data->sensors_last_updated +
  720 + SENSOR_REFRESH_INTERVAL)
  721 + && data->sensors_valid)
  722 + goto no_sensor_update;
  723 +
  724 + for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
  725 + /*
  726 + * Reading the fractional register locks the integral
  727 + * register until both have been read.
  728 + */
  729 + data->temp_frac[i] = i2c_smbus_read_byte_data(client,
  730 + ADT7462_TEMP_REG(i));
  731 + data->temp[i] = i2c_smbus_read_byte_data(client,
  732 + ADT7462_TEMP_REG(i) + 1);
  733 + }
  734 +
  735 + for (i = 0; i < ADT7462_FAN_COUNT; i++)
  736 + data->fan[i] = adt7462_read_word_data(client,
  737 + ADT7462_REG_FAN(i));
  738 +
  739 + data->fan_enabled = i2c_smbus_read_byte_data(client,
  740 + ADT7462_REG_FAN_ENABLE);
  741 +
  742 + for (i = 0; i < ADT7462_PWM_COUNT; i++)
  743 + data->pwm[i] = i2c_smbus_read_byte_data(client,
  744 + ADT7462_REG_PWM(i));
  745 +
  746 + for (i = 0; i < ADT7462_PIN_CFG_REG_COUNT; i++)
  747 + data->pin_cfg[i] = i2c_smbus_read_byte_data(client,
  748 + ADT7462_REG_PIN_CFG(i));
  749 +
  750 + for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
  751 + int reg = ADT7462_REG_VOLT(data, i);
  752 + if (!reg)
  753 + data->voltages[i] = 0;
  754 + else
  755 + data->voltages[i] = i2c_smbus_read_byte_data(client,
  756 + reg);
  757 + }
  758 +
  759 + data->alarms[0] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM1);
  760 + data->alarms[1] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM2);
  761 + data->alarms[2] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM3);
  762 + data->alarms[3] = i2c_smbus_read_byte_data(client, ADT7462_REG_ALARM4);
  763 +
  764 + data->sensors_last_updated = local_jiffies;
  765 + data->sensors_valid = 1;
  766 +
  767 +no_sensor_update:
  768 + if (time_before(local_jiffies, data->limits_last_updated +
  769 + LIMIT_REFRESH_INTERVAL)
  770 + && data->limits_valid)
  771 + goto out;
  772 +
  773 + for (i = 0; i < ADT7462_TEMP_COUNT; i++) {
  774 + data->temp_min[i] = i2c_smbus_read_byte_data(client,
  775 + ADT7462_TEMP_MIN_REG(i));
  776 + data->temp_max[i] = i2c_smbus_read_byte_data(client,
  777 + ADT7462_TEMP_MAX_REG(i));
  778 + }
  779 +
  780 + for (i = 0; i < ADT7462_FAN_COUNT; i++)
  781 + data->fan_min[i] = i2c_smbus_read_byte_data(client,
  782 + ADT7462_REG_FAN_MIN(i));
  783 +
  784 + for (i = 0; i < ADT7462_VOLT_COUNT; i++) {
  785 + int reg = ADT7462_REG_VOLT_MAX(data, i);
  786 + data->volt_max[i] =
  787 + (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
  788 +
  789 + reg = ADT7462_REG_VOLT_MIN(data, i);
  790 + data->volt_min[i] =
  791 + (reg ? i2c_smbus_read_byte_data(client, reg) : 0);
  792 + }
  793 +
  794 + for (i = 0; i < ADT7462_PWM_COUNT; i++) {
  795 + data->pwm_min[i] = i2c_smbus_read_byte_data(client,
  796 + ADT7462_REG_PWM_MIN(i));
  797 + data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
  798 + ADT7462_REG_PWM_TMIN(i));
  799 + data->pwm_trange[i] = i2c_smbus_read_byte_data(client,
  800 + ADT7462_REG_PWM_TRANGE(i));
  801 + data->pwm_cfg[i] = i2c_smbus_read_byte_data(client,
  802 + ADT7462_REG_PWM_CFG(i));
  803 + }
  804 +
  805 + data->pwm_max = i2c_smbus_read_byte_data(client, ADT7462_REG_PWM_MAX);
  806 +
  807 + data->cfg2 = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
  808 +
  809 + data->limits_last_updated = local_jiffies;
  810 + data->limits_valid = 1;
  811 +
  812 +out:
  813 + mutex_unlock(&data->lock);
  814 + return data;
  815 +}
  816 +
  817 +static ssize_t show_temp_min(struct device *dev,
  818 + struct device_attribute *devattr,
  819 + char *buf)
  820 +{
  821 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  822 + struct adt7462_data *data = adt7462_update_device(dev);
  823 +
  824 + if (!temp_enabled(data, attr->index))
  825 + return sprintf(buf, "0\n");
  826 +
  827 + return sprintf(buf, "%d\n", 1000 * (data->temp_min[attr->index] - 64));
  828 +}
  829 +
  830 +static ssize_t set_temp_min(struct device *dev,
  831 + struct device_attribute *devattr,
  832 + const char *buf,
  833 + size_t count)
  834 +{
  835 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  836 + struct i2c_client *client = to_i2c_client(dev);
  837 + struct adt7462_data *data = i2c_get_clientdata(client);
  838 + long temp;
  839 +
  840 + if (strict_strtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
  841 + return -EINVAL;
  842 +
  843 + temp = ROUND_DIV(temp, 1000) + 64;
  844 + temp = SENSORS_LIMIT(temp, 0, 255);
  845 +
  846 + mutex_lock(&data->lock);
  847 + data->temp_min[attr->index] = temp;
  848 + i2c_smbus_write_byte_data(client, ADT7462_TEMP_MIN_REG(attr->index),
  849 + temp);
  850 + mutex_unlock(&data->lock);
  851 +
  852 + return count;
  853 +}
  854 +
  855 +static ssize_t show_temp_max(struct device *dev,
  856 + struct device_attribute *devattr,
  857 + char *buf)
  858 +{
  859 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  860 + struct adt7462_data *data = adt7462_update_device(dev);
  861 +
  862 + if (!temp_enabled(data, attr->index))
  863 + return sprintf(buf, "0\n");
  864 +
  865 + return sprintf(buf, "%d\n", 1000 * (data->temp_max[attr->index] - 64));
  866 +}
  867 +
  868 +static ssize_t set_temp_max(struct device *dev,
  869 + struct device_attribute *devattr,
  870 + const char *buf,
  871 + size_t count)
  872 +{
  873 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  874 + struct i2c_client *client = to_i2c_client(dev);
  875 + struct adt7462_data *data = i2c_get_clientdata(client);
  876 + long temp;
  877 +
  878 + if (strict_strtol(buf, 10, &temp) || !temp_enabled(data, attr->index))
  879 + return -EINVAL;
  880 +
  881 + temp = ROUND_DIV(temp, 1000) + 64;
  882 + temp = SENSORS_LIMIT(temp, 0, 255);
  883 +
  884 + mutex_lock(&data->lock);
  885 + data->temp_max[attr->index] = temp;
  886 + i2c_smbus_write_byte_data(client, ADT7462_TEMP_MAX_REG(attr->index),
  887 + temp);
  888 + mutex_unlock(&data->lock);
  889 +
  890 + return count;
  891 +}
  892 +
  893 +static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
  894 + char *buf)
  895 +{
  896 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  897 + struct adt7462_data *data = adt7462_update_device(dev);
  898 + u8 frac = data->temp_frac[attr->index] >> TEMP_FRAC_OFFSET;
  899 +
  900 + if (!temp_enabled(data, attr->index))
  901 + return sprintf(buf, "0\n");
  902 +
  903 + return sprintf(buf, "%d\n", 1000 * (data->temp[attr->index] - 64) +
  904 + 250 * frac);
  905 +}
  906 +
  907 +static ssize_t show_temp_label(struct device *dev,
  908 + struct device_attribute *devattr,
  909 + char *buf)
  910 +{
  911 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  912 + struct adt7462_data *data = adt7462_update_device(dev);
  913 +
  914 + return sprintf(buf, "%s\n", temp_label(data, attr->index));
  915 +}
  916 +
  917 +static ssize_t show_volt_max(struct device *dev,
  918 + struct device_attribute *devattr,
  919 + char *buf)
  920 +{
  921 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  922 + struct adt7462_data *data = adt7462_update_device(dev);
  923 + int x = voltage_multiplier(data, attr->index);
  924 +
  925 + x *= data->volt_max[attr->index];
  926 + x /= 1000; /* convert from uV to mV */
  927 +
  928 + return sprintf(buf, "%d\n", x);
  929 +}
  930 +
  931 +static ssize_t set_volt_max(struct device *dev,
  932 + struct device_attribute *devattr,
  933 + const char *buf,
  934 + size_t count)
  935 +{
  936 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  937 + struct i2c_client *client = to_i2c_client(dev);
  938 + struct adt7462_data *data = i2c_get_clientdata(client);
  939 + int x = voltage_multiplier(data, attr->index);
  940 + long temp;
  941 +
  942 + if (strict_strtol(buf, 10, &temp) || !x)
  943 + return -EINVAL;
  944 +
  945 + temp *= 1000; /* convert mV to uV */
  946 + temp = ROUND_DIV(temp, x);
  947 + temp = SENSORS_LIMIT(temp, 0, 255);
  948 +
  949 + mutex_lock(&data->lock);
  950 + data->volt_max[attr->index] = temp;
  951 + i2c_smbus_write_byte_data(client,
  952 + ADT7462_REG_VOLT_MAX(data, attr->index),
  953 + temp);
  954 + mutex_unlock(&data->lock);
  955 +
  956 + return count;
  957 +}
  958 +
  959 +static ssize_t show_volt_min(struct device *dev,
  960 + struct device_attribute *devattr,
  961 + char *buf)
  962 +{
  963 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  964 + struct adt7462_data *data = adt7462_update_device(dev);
  965 + int x = voltage_multiplier(data, attr->index);
  966 +
  967 + x *= data->volt_min[attr->index];
  968 + x /= 1000; /* convert from uV to mV */
  969 +
  970 + return sprintf(buf, "%d\n", x);
  971 +}
  972 +
  973 +static ssize_t set_volt_min(struct device *dev,
  974 + struct device_attribute *devattr,
  975 + const char *buf,
  976 + size_t count)
  977 +{
  978 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  979 + struct i2c_client *client = to_i2c_client(dev);
  980 + struct adt7462_data *data = i2c_get_clientdata(client);
  981 + int x = voltage_multiplier(data, attr->index);
  982 + long temp;
  983 +
  984 + if (strict_strtol(buf, 10, &temp) || !x)
  985 + return -EINVAL;
  986 +
  987 + temp *= 1000; /* convert mV to uV */
  988 + temp = ROUND_DIV(temp, x);
  989 + temp = SENSORS_LIMIT(temp, 0, 255);
  990 +
  991 + mutex_lock(&data->lock);
  992 + data->volt_min[attr->index] = temp;
  993 + i2c_smbus_write_byte_data(client,
  994 + ADT7462_REG_VOLT_MIN(data, attr->index),
  995 + temp);
  996 + mutex_unlock(&data->lock);
  997 +
  998 + return count;
  999 +}
  1000 +
  1001 +static ssize_t show_voltage(struct device *dev,
  1002 + struct device_attribute *devattr,
  1003 + char *buf)
  1004 +{
  1005 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1006 + struct adt7462_data *data = adt7462_update_device(dev);
  1007 + int x = voltage_multiplier(data, attr->index);
  1008 +
  1009 + x *= data->voltages[attr->index];
  1010 + x /= 1000; /* convert from uV to mV */
  1011 +
  1012 + return sprintf(buf, "%d\n", x);
  1013 +}
  1014 +
  1015 +static ssize_t show_voltage_label(struct device *dev,
  1016 + struct device_attribute *devattr,
  1017 + char *buf)
  1018 +{
  1019 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1020 + struct adt7462_data *data = adt7462_update_device(dev);
  1021 +
  1022 + return sprintf(buf, "%s\n", voltage_label(data, attr->index));
  1023 +}
  1024 +
  1025 +static ssize_t show_alarm(struct device *dev,
  1026 + struct device_attribute *devattr,
  1027 + char *buf)
  1028 +{
  1029 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1030 + struct adt7462_data *data = adt7462_update_device(dev);
  1031 + int reg = attr->index >> ADT7462_ALARM_REG_SHIFT;
  1032 + int mask = attr->index & ADT7462_ALARM_FLAG_MASK;
  1033 +
  1034 + if (data->alarms[reg] & mask)
  1035 + return sprintf(buf, "1\n");
  1036 + else
  1037 + return sprintf(buf, "0\n");
  1038 +}
  1039 +
  1040 +static int fan_enabled(struct adt7462_data *data, int fan)
  1041 +{
  1042 + return data->fan_enabled & (1 << fan);
  1043 +}
  1044 +
  1045 +static ssize_t show_fan_min(struct device *dev,
  1046 + struct device_attribute *devattr,
  1047 + char *buf)
  1048 +{
  1049 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1050 + struct adt7462_data *data = adt7462_update_device(dev);
  1051 + u16 temp;
  1052 +
  1053 + /* Only the MSB of the min fan period is stored... */
  1054 + temp = data->fan_min[attr->index];
  1055 + temp <<= 8;
  1056 +
  1057 + if (!fan_enabled(data, attr->index) ||
  1058 + !FAN_DATA_VALID(temp))
  1059 + return sprintf(buf, "0\n");
  1060 +
  1061 + return sprintf(buf, "%d\n", FAN_PERIOD_TO_RPM(temp));
  1062 +}
  1063 +
  1064 +static ssize_t set_fan_min(struct device *dev,
  1065 + struct device_attribute *devattr,
  1066 + const char *buf, size_t count)
  1067 +{
  1068 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1069 + struct i2c_client *client = to_i2c_client(dev);
  1070 + struct adt7462_data *data = i2c_get_clientdata(client);
  1071 + long temp;
  1072 +
  1073 + if (strict_strtol(buf, 10, &temp) || !temp ||
  1074 + !fan_enabled(data, attr->index))
  1075 + return -EINVAL;
  1076 +
  1077 + temp = FAN_RPM_TO_PERIOD(temp);
  1078 + temp >>= 8;
  1079 + temp = SENSORS_LIMIT(temp, 1, 255);
  1080 +
  1081 + mutex_lock(&data->lock);
  1082 + data->fan_min[attr->index] = temp;
  1083 + i2c_smbus_write_byte_data(client, ADT7462_REG_FAN_MIN(attr->index),
  1084 + temp);
  1085 + mutex_unlock(&data->lock);
  1086 +
  1087 + return count;
  1088 +}
  1089 +
  1090 +static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
  1091 + char *buf)
  1092 +{
  1093 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1094 + struct adt7462_data *data = adt7462_update_device(dev);
  1095 +
  1096 + if (!fan_enabled(data, attr->index) ||
  1097 + !FAN_DATA_VALID(data->fan[attr->index]))
  1098 + return sprintf(buf, "0\n");
  1099 +
  1100 + return sprintf(buf, "%d\n",
  1101 + FAN_PERIOD_TO_RPM(data->fan[attr->index]));
  1102 +}
  1103 +
  1104 +static ssize_t show_force_pwm_max(struct device *dev,
  1105 + struct device_attribute *devattr,
  1106 + char *buf)
  1107 +{
  1108 + struct adt7462_data *data = adt7462_update_device(dev);
  1109 + return sprintf(buf, "%d\n", (data->cfg2 & ADT7462_FSPD_MASK ? 1 : 0));
  1110 +}
  1111 +
  1112 +static ssize_t set_force_pwm_max(struct device *dev,
  1113 + struct device_attribute *devattr,
  1114 + const char *buf,
  1115 + size_t count)
  1116 +{
  1117 + struct i2c_client *client = to_i2c_client(dev);
  1118 + struct adt7462_data *data = i2c_get_clientdata(client);
  1119 + long temp;
  1120 + u8 reg;
  1121 +
  1122 + if (strict_strtol(buf, 10, &temp))
  1123 + return -EINVAL;
  1124 +
  1125 + mutex_lock(&data->lock);
  1126 + reg = i2c_smbus_read_byte_data(client, ADT7462_REG_CFG2);
  1127 + if (temp)
  1128 + reg |= ADT7462_FSPD_MASK;
  1129 + else
  1130 + reg &= ~ADT7462_FSPD_MASK;
  1131 + data->cfg2 = reg;
  1132 + i2c_smbus_write_byte_data(client, ADT7462_REG_CFG2, reg);
  1133 + mutex_unlock(&data->lock);
  1134 +
  1135 + return count;
  1136 +}
  1137 +
  1138 +static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
  1139 + char *buf)
  1140 +{
  1141 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1142 + struct adt7462_data *data = adt7462_update_device(dev);
  1143 + return sprintf(buf, "%d\n", data->pwm[attr->index]);
  1144 +}
  1145 +
  1146 +static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
  1147 + const char *buf, size_t count)
  1148 +{
  1149 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1150 + struct i2c_client *client = to_i2c_client(dev);
  1151 + struct adt7462_data *data = i2c_get_clientdata(client);
  1152 + long temp;
  1153 +
  1154 + if (strict_strtol(buf, 10, &temp))
  1155 + return -EINVAL;
  1156 +
  1157 + temp = SENSORS_LIMIT(temp, 0, 255);
  1158 +
  1159 + mutex_lock(&data->lock);
  1160 + data->pwm[attr->index] = temp;
  1161 + i2c_smbus_write_byte_data(client, ADT7462_REG_PWM(attr->index), temp);
  1162 + mutex_unlock(&data->lock);
  1163 +
  1164 + return count;
  1165 +}
  1166 +
  1167 +static ssize_t show_pwm_max(struct device *dev,
  1168 + struct device_attribute *devattr,
  1169 + char *buf)
  1170 +{
  1171 + struct adt7462_data *data = adt7462_update_device(dev);
  1172 + return sprintf(buf, "%d\n", data->pwm_max);
  1173 +}
  1174 +
  1175 +static ssize_t set_pwm_max(struct device *dev,
  1176 + struct device_attribute *devattr,
  1177 + const char *buf,
  1178 + size_t count)
  1179 +{
  1180 + struct i2c_client *client = to_i2c_client(dev);
  1181 + struct adt7462_data *data = i2c_get_clientdata(client);
  1182 + long temp;
  1183 +
  1184 + if (strict_strtol(buf, 10, &temp))
  1185 + return -EINVAL;
  1186 +
  1187 + temp = SENSORS_LIMIT(temp, 0, 255);
  1188 +
  1189 + mutex_lock(&data->lock);
  1190 + data->pwm_max = temp;
  1191 + i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MAX, temp);
  1192 + mutex_unlock(&data->lock);
  1193 +
  1194 + return count;
  1195 +}
  1196 +
  1197 +static ssize_t show_pwm_min(struct device *dev,
  1198 + struct device_attribute *devattr,
  1199 + char *buf)
  1200 +{
  1201 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1202 + struct adt7462_data *data = adt7462_update_device(dev);
  1203 + return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
  1204 +}
  1205 +
  1206 +static ssize_t set_pwm_min(struct device *dev,
  1207 + struct device_attribute *devattr,
  1208 + const char *buf,
  1209 + size_t count)
  1210 +{
  1211 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1212 + struct i2c_client *client = to_i2c_client(dev);
  1213 + struct adt7462_data *data = i2c_get_clientdata(client);
  1214 + long temp;
  1215 +
  1216 + if (strict_strtol(buf, 10, &temp))
  1217 + return -EINVAL;
  1218 +
  1219 + temp = SENSORS_LIMIT(temp, 0, 255);
  1220 +
  1221 + mutex_lock(&data->lock);
  1222 + data->pwm_min[attr->index] = temp;
  1223 + i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_MIN(attr->index),
  1224 + temp);
  1225 + mutex_unlock(&data->lock);
  1226 +
  1227 + return count;
  1228 +}
  1229 +
  1230 +static ssize_t show_pwm_hyst(struct device *dev,
  1231 + struct device_attribute *devattr,
  1232 + char *buf)
  1233 +{
  1234 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1235 + struct adt7462_data *data = adt7462_update_device(dev);
  1236 + return sprintf(buf, "%d\n", 1000 *
  1237 + (data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK));
  1238 +}
  1239 +
  1240 +static ssize_t set_pwm_hyst(struct device *dev,
  1241 + struct device_attribute *devattr,
  1242 + const char *buf,
  1243 + size_t count)
  1244 +{
  1245 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1246 + struct i2c_client *client = to_i2c_client(dev);
  1247 + struct adt7462_data *data = i2c_get_clientdata(client);
  1248 + long temp;
  1249 +
  1250 + if (strict_strtol(buf, 10, &temp))
  1251 + return -EINVAL;
  1252 +
  1253 + temp = ROUND_DIV(temp, 1000);
  1254 + temp = SENSORS_LIMIT(temp, 0, 15);
  1255 +
  1256 + /* package things up */
  1257 + temp &= ADT7462_PWM_HYST_MASK;
  1258 + temp |= data->pwm_trange[attr->index] & ADT7462_PWM_RANGE_MASK;
  1259 +
  1260 + mutex_lock(&data->lock);
  1261 + data->pwm_trange[attr->index] = temp;
  1262 + i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
  1263 + temp);
  1264 + mutex_unlock(&data->lock);
  1265 +
  1266 + return count;
  1267 +}
  1268 +
  1269 +static ssize_t show_pwm_tmax(struct device *dev,
  1270 + struct device_attribute *devattr,
  1271 + char *buf)
  1272 +{
  1273 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1274 + struct adt7462_data *data = adt7462_update_device(dev);
  1275 +
  1276 + /* tmax = tmin + trange */
  1277 + int trange = trange_values[data->pwm_trange[attr->index] >>
  1278 + ADT7462_PWM_RANGE_SHIFT];
  1279 + int tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
  1280 +
  1281 + return sprintf(buf, "%d\n", tmin + trange);
  1282 +}
  1283 +
  1284 +static ssize_t set_pwm_tmax(struct device *dev,
  1285 + struct device_attribute *devattr,
  1286 + const char *buf,
  1287 + size_t count)
  1288 +{
  1289 + int temp;
  1290 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1291 + struct i2c_client *client = to_i2c_client(dev);
  1292 + struct adt7462_data *data = i2c_get_clientdata(client);
  1293 + int tmin, trange_value;
  1294 + long trange;
  1295 +
  1296 + if (strict_strtol(buf, 10, &trange))
  1297 + return -EINVAL;
  1298 +
  1299 + /* trange = tmax - tmin */
  1300 + tmin = (data->pwm_tmin[attr->index] - 64) * 1000;
  1301 + trange_value = find_trange_value(trange - tmin);
  1302 +
  1303 + if (trange_value < 0)
  1304 + return -EINVAL;
  1305 +
  1306 + temp = trange_value << ADT7462_PWM_RANGE_SHIFT;
  1307 + temp |= data->pwm_trange[attr->index] & ADT7462_PWM_HYST_MASK;
  1308 +
  1309 + mutex_lock(&data->lock);
  1310 + data->pwm_trange[attr->index] = temp;
  1311 + i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TRANGE(attr->index),
  1312 + temp);
  1313 + mutex_unlock(&data->lock);
  1314 +
  1315 + return count;
  1316 +}
  1317 +
  1318 +static ssize_t show_pwm_tmin(struct device *dev,
  1319 + struct device_attribute *devattr,
  1320 + char *buf)
  1321 +{
  1322 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1323 + struct adt7462_data *data = adt7462_update_device(dev);
  1324 + return sprintf(buf, "%d\n", 1000 * (data->pwm_tmin[attr->index] - 64));
  1325 +}
  1326 +
  1327 +static ssize_t set_pwm_tmin(struct device *dev,
  1328 + struct device_attribute *devattr,
  1329 + const char *buf,
  1330 + size_t count)
  1331 +{
  1332 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1333 + struct i2c_client *client = to_i2c_client(dev);
  1334 + struct adt7462_data *data = i2c_get_clientdata(client);
  1335 + long temp;
  1336 +
  1337 + if (strict_strtol(buf, 10, &temp))
  1338 + return -EINVAL;
  1339 +
  1340 + temp = ROUND_DIV(temp, 1000) + 64;
  1341 + temp = SENSORS_LIMIT(temp, 0, 255);
  1342 +
  1343 + mutex_lock(&data->lock);
  1344 + data->pwm_tmin[attr->index] = temp;
  1345 + i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_TMIN(attr->index),
  1346 + temp);
  1347 + mutex_unlock(&data->lock);
  1348 +
  1349 + return count;
  1350 +}
  1351 +
  1352 +static ssize_t show_pwm_auto(struct device *dev,
  1353 + struct device_attribute *devattr,
  1354 + char *buf)
  1355 +{
  1356 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1357 + struct adt7462_data *data = adt7462_update_device(dev);
  1358 + int cfg = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
  1359 +
  1360 + switch (cfg) {
  1361 + case 4: /* off */
  1362 + return sprintf(buf, "0\n");
  1363 + case 7: /* manual */
  1364 + return sprintf(buf, "1\n");
  1365 + default: /* automatic */
  1366 + return sprintf(buf, "2\n");
  1367 + }
  1368 +}
  1369 +
  1370 +static void set_pwm_channel(struct i2c_client *client,
  1371 + struct adt7462_data *data,
  1372 + int which,
  1373 + int value)
  1374 +{
  1375 + int temp = data->pwm_cfg[which] & ~ADT7462_PWM_CHANNEL_MASK;
  1376 + temp |= value << ADT7462_PWM_CHANNEL_SHIFT;
  1377 +
  1378 + mutex_lock(&data->lock);
  1379 + data->pwm_cfg[which] = temp;
  1380 + i2c_smbus_write_byte_data(client, ADT7462_REG_PWM_CFG(which), temp);
  1381 + mutex_unlock(&data->lock);
  1382 +}
  1383 +
  1384 +static ssize_t set_pwm_auto(struct device *dev,
  1385 + struct device_attribute *devattr,
  1386 + const char *buf,
  1387 + size_t count)
  1388 +{
  1389 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1390 + struct i2c_client *client = to_i2c_client(dev);
  1391 + struct adt7462_data *data = i2c_get_clientdata(client);
  1392 + long temp;
  1393 +
  1394 + if (strict_strtol(buf, 10, &temp))
  1395 + return -EINVAL;
  1396 +
  1397 + switch (temp) {
  1398 + case 0: /* off */
  1399 + set_pwm_channel(client, data, attr->index, 4);
  1400 + return count;
  1401 + case 1: /* manual */
  1402 + set_pwm_channel(client, data, attr->index, 7);
  1403 + return count;
  1404 + default:
  1405 + return -EINVAL;
  1406 + }
  1407 +}
  1408 +
  1409 +static ssize_t show_pwm_auto_temp(struct device *dev,
  1410 + struct device_attribute *devattr,
  1411 + char *buf)
  1412 +{
  1413 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1414 + struct adt7462_data *data = adt7462_update_device(dev);
  1415 + int channel = data->pwm_cfg[attr->index] >> ADT7462_PWM_CHANNEL_SHIFT;
  1416 +
  1417 + switch (channel) {
  1418 + case 0: /* temp[1234] only */
  1419 + case 1:
  1420 + case 2:
  1421 + case 3:
  1422 + return sprintf(buf, "%d\n", (1 << channel));
  1423 + case 5: /* temp1 & temp4 */
  1424 + return sprintf(buf, "9\n");
  1425 + case 6:
  1426 + return sprintf(buf, "15\n");
  1427 + default:
  1428 + return sprintf(buf, "0\n");
  1429 + }
  1430 +}
  1431 +
  1432 +static int cvt_auto_temp(int input)
  1433 +{
  1434 + if (input == 0xF)
  1435 + return 6;
  1436 + if (input == 0x9)
  1437 + return 5;
  1438 + if (input < 1 || !is_power_of_2(input))
  1439 + return -EINVAL;
  1440 + return ilog2(input);
  1441 +}
  1442 +
  1443 +static ssize_t set_pwm_auto_temp(struct device *dev,
  1444 + struct device_attribute *devattr,
  1445 + const char *buf,
  1446 + size_t count)
  1447 +{
  1448 + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
  1449 + struct i2c_client *client = to_i2c_client(dev);
  1450 + struct adt7462_data *data = i2c_get_clientdata(client);
  1451 + long temp;
  1452 +
  1453 + if (strict_strtol(buf, 10, &temp))
  1454 + return -EINVAL;
  1455 +
  1456 + temp = cvt_auto_temp(temp);
  1457 + if (temp < 0)
  1458 + return temp;
  1459 +
  1460 + set_pwm_channel(client, data, attr->index, temp);
  1461 +
  1462 + return count;
  1463 +}
  1464 +
  1465 +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
  1466 + set_temp_max, 0);
  1467 +static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
  1468 + set_temp_max, 1);
  1469 +static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
  1470 + set_temp_max, 2);
  1471 +static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_temp_max,
  1472 + set_temp_max, 3);
  1473 +
  1474 +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
  1475 + set_temp_min, 0);
  1476 +static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
  1477 + set_temp_min, 1);
  1478 +static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
  1479 + set_temp_min, 2);
  1480 +static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_temp_min,
  1481 + set_temp_min, 3);
  1482 +
  1483 +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
  1484 +static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
  1485 +static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
  1486 +static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
  1487 +
  1488 +static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_temp_label, NULL, 0);
  1489 +static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, show_temp_label, NULL, 1);
  1490 +static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, show_temp_label, NULL, 2);
  1491 +static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, show_temp_label, NULL, 3);
  1492 +
  1493 +static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
  1494 + ADT7462_ALARM1 | ADT7462_LT_ALARM);
  1495 +static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
  1496 + ADT7462_ALARM1 | ADT7462_R1T_ALARM);
  1497 +static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
  1498 + ADT7462_ALARM1 | ADT7462_R2T_ALARM);
  1499 +static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO, show_alarm, NULL,
  1500 + ADT7462_ALARM1 | ADT7462_R3T_ALARM);
  1501 +
  1502 +static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, show_volt_max,
  1503 + set_volt_max, 0);
  1504 +static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, show_volt_max,
  1505 + set_volt_max, 1);
  1506 +static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, show_volt_max,
  1507 + set_volt_max, 2);
  1508 +static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, show_volt_max,
  1509 + set_volt_max, 3);
  1510 +static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, show_volt_max,
  1511 + set_volt_max, 4);
  1512 +static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, show_volt_max,
  1513 + set_volt_max, 5);
  1514 +static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO, show_volt_max,
  1515 + set_volt_max, 6);
  1516 +static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO, show_volt_max,
  1517 + set_volt_max, 7);
  1518 +static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO, show_volt_max,
  1519 + set_volt_max, 8);
  1520 +static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO, show_volt_max,
  1521 + set_volt_max, 9);
  1522 +static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO, show_volt_max,
  1523 + set_volt_max, 10);
  1524 +static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO, show_volt_max,
  1525 + set_volt_max, 11);
  1526 +static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO, show_volt_max,
  1527 + set_volt_max, 12);
  1528 +
  1529 +static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, show_volt_min,
  1530 + set_volt_min, 0);
  1531 +static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, show_volt_min,
  1532 + set_volt_min, 1);
  1533 +static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, show_volt_min,
  1534 + set_volt_min, 2);
  1535 +static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, show_volt_min,
  1536 + set_volt_min, 3);
  1537 +static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, show_volt_min,
  1538 + set_volt_min, 4);
  1539 +static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, show_volt_min,
  1540 + set_volt_min, 5);
  1541 +static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO, show_volt_min,
  1542 + set_volt_min, 6);
  1543 +static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO, show_volt_min,
  1544 + set_volt_min, 7);
  1545 +static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO, show_volt_min,
  1546 + set_volt_min, 8);
  1547 +static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO, show_volt_min,
  1548 + set_volt_min, 9);
  1549 +static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO, show_volt_min,
  1550 + set_volt_min, 10);
  1551 +static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO, show_volt_min,
  1552 + set_volt_min, 11);
  1553 +static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO, show_volt_min,
  1554 + set_volt_min, 12);
  1555 +
  1556 +static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_voltage, NULL, 0);
  1557 +static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_voltage, NULL, 1);
  1558 +static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_voltage, NULL, 2);
  1559 +static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_voltage, NULL, 3);
  1560 +static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_voltage, NULL, 4);
  1561 +static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_voltage, NULL, 5);
  1562 +static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_voltage, NULL, 6);
  1563 +static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_voltage, NULL, 7);
  1564 +static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_voltage, NULL, 8);
  1565 +static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_voltage, NULL, 9);
  1566 +static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_voltage, NULL, 10);
  1567 +static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_voltage, NULL, 11);
  1568 +static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_voltage, NULL, 12);
  1569 +
  1570 +static SENSOR_DEVICE_ATTR(in1_label, S_IRUGO, show_voltage_label, NULL, 0);
  1571 +static SENSOR_DEVICE_ATTR(in2_label, S_IRUGO, show_voltage_label, NULL, 1);
  1572 +static SENSOR_DEVICE_ATTR(in3_label, S_IRUGO, show_voltage_label, NULL, 2);
  1573 +static SENSOR_DEVICE_ATTR(in4_label, S_IRUGO, show_voltage_label, NULL, 3);
  1574 +static SENSOR_DEVICE_ATTR(in5_label, S_IRUGO, show_voltage_label, NULL, 4);
  1575 +static SENSOR_DEVICE_ATTR(in6_label, S_IRUGO, show_voltage_label, NULL, 5);
  1576 +static SENSOR_DEVICE_ATTR(in7_label, S_IRUGO, show_voltage_label, NULL, 6);
  1577 +static SENSOR_DEVICE_ATTR(in8_label, S_IRUGO, show_voltage_label, NULL, 7);
  1578 +static SENSOR_DEVICE_ATTR(in9_label, S_IRUGO, show_voltage_label, NULL, 8);
  1579 +static SENSOR_DEVICE_ATTR(in10_label, S_IRUGO, show_voltage_label, NULL, 9);
  1580 +static SENSOR_DEVICE_ATTR(in11_label, S_IRUGO, show_voltage_label, NULL, 10);
  1581 +static SENSOR_DEVICE_ATTR(in12_label, S_IRUGO, show_voltage_label, NULL, 11);
  1582 +static SENSOR_DEVICE_ATTR(in13_label, S_IRUGO, show_voltage_label, NULL, 12);
  1583 +
  1584 +static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL,
  1585 + ADT7462_ALARM2 | ADT7462_V0_ALARM);
  1586 +static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL,
  1587 + ADT7462_ALARM2 | ADT7462_V7_ALARM);
  1588 +static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL,
  1589 + ADT7462_ALARM2 | ADT7462_V2_ALARM);
  1590 +static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL,
  1591 + ADT7462_ALARM2 | ADT7462_V6_ALARM);
  1592 +static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL,
  1593 + ADT7462_ALARM2 | ADT7462_V5_ALARM);
  1594 +static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL,
  1595 + ADT7462_ALARM2 | ADT7462_V4_ALARM);
  1596 +static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL,
  1597 + ADT7462_ALARM2 | ADT7462_V3_ALARM);
  1598 +static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL,
  1599 + ADT7462_ALARM2 | ADT7462_V1_ALARM);
  1600 +static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL,
  1601 + ADT7462_ALARM3 | ADT7462_V10_ALARM);
  1602 +static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL,
  1603 + ADT7462_ALARM3 | ADT7462_V9_ALARM);
  1604 +static SENSOR_DEVICE_ATTR(in11_alarm, S_IRUGO, show_alarm, NULL,
  1605 + ADT7462_ALARM3 | ADT7462_V8_ALARM);
  1606 +static SENSOR_DEVICE_ATTR(in12_alarm, S_IRUGO, show_alarm, NULL,
  1607 + ADT7462_ALARM3 | ADT7462_V11_ALARM);
  1608 +static SENSOR_DEVICE_ATTR(in13_alarm, S_IRUGO, show_alarm, NULL,
  1609 + ADT7462_ALARM3 | ADT7462_V12_ALARM);
  1610 +
  1611 +static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
  1612 + set_fan_min, 0);
  1613 +static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
  1614 + set_fan_min, 1);
  1615 +static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
  1616 + set_fan_min, 2);
  1617 +static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
  1618 + set_fan_min, 3);
  1619 +static SENSOR_DEVICE_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
  1620 + set_fan_min, 4);
  1621 +static SENSOR_DEVICE_ATTR(fan6_min, S_IWUSR | S_IRUGO, show_fan_min,
  1622 + set_fan_min, 5);
  1623 +static SENSOR_DEVICE_ATTR(fan7_min, S_IWUSR | S_IRUGO, show_fan_min,
  1624 + set_fan_min, 6);
  1625 +static SENSOR_DEVICE_ATTR(fan8_min, S_IWUSR | S_IRUGO, show_fan_min,
  1626 + set_fan_min, 7);
  1627 +
  1628 +static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
  1629 +static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
  1630 +static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
  1631 +static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
  1632 +static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4);
  1633 +static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan, NULL, 5);
  1634 +static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan, NULL, 6);
  1635 +static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan, NULL, 7);
  1636 +
  1637 +static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
  1638 + ADT7462_ALARM4 | ADT7462_F0_ALARM);
  1639 +static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
  1640 + ADT7462_ALARM4 | ADT7462_F1_ALARM);
  1641 +static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
  1642 + ADT7462_ALARM4 | ADT7462_F2_ALARM);
  1643 +static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
  1644 + ADT7462_ALARM4 | ADT7462_F3_ALARM);
  1645 +static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL,
  1646 + ADT7462_ALARM4 | ADT7462_F4_ALARM);
  1647 +static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL,
  1648 + ADT7462_ALARM4 | ADT7462_F5_ALARM);
  1649 +static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_alarm, NULL,
  1650 + ADT7462_ALARM4 | ADT7462_F6_ALARM);
  1651 +static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_alarm, NULL,
  1652 + ADT7462_ALARM4 | ADT7462_F7_ALARM);
  1653 +
  1654 +static SENSOR_DEVICE_ATTR(force_pwm_max, S_IWUSR | S_IRUGO,
  1655 + show_force_pwm_max, set_force_pwm_max, 0);
  1656 +
  1657 +static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
  1658 +static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
  1659 +static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
  1660 +static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
  1661 +
  1662 +static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
  1663 + show_pwm_min, set_pwm_min, 0);
  1664 +static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
  1665 + show_pwm_min, set_pwm_min, 1);
  1666 +static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
  1667 + show_pwm_min, set_pwm_min, 2);
  1668 +static SENSOR_DEVICE_ATTR(pwm4_auto_point1_pwm, S_IWUSR | S_IRUGO,
  1669 + show_pwm_min, set_pwm_min, 3);
  1670 +
  1671 +static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
  1672 + show_pwm_max, set_pwm_max, 0);
  1673 +static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
  1674 + show_pwm_max, set_pwm_max, 1);
  1675 +static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
  1676 + show_pwm_max, set_pwm_max, 2);
  1677 +static SENSOR_DEVICE_ATTR(pwm4_auto_point2_pwm, S_IWUSR | S_IRUGO,
  1678 + show_pwm_max, set_pwm_max, 3);
  1679 +
  1680 +static SENSOR_DEVICE_ATTR(temp1_auto_point1_hyst, S_IWUSR | S_IRUGO,
  1681 + show_pwm_hyst, set_pwm_hyst, 0);
  1682 +static SENSOR_DEVICE_ATTR(temp2_auto_point1_hyst, S_IWUSR | S_IRUGO,
  1683 + show_pwm_hyst, set_pwm_hyst, 1);
  1684 +static SENSOR_DEVICE_ATTR(temp3_auto_point1_hyst, S_IWUSR | S_IRUGO,
  1685 + show_pwm_hyst, set_pwm_hyst, 2);
  1686 +static SENSOR_DEVICE_ATTR(temp4_auto_point1_hyst, S_IWUSR | S_IRUGO,
  1687 + show_pwm_hyst, set_pwm_hyst, 3);
  1688 +
  1689 +static SENSOR_DEVICE_ATTR(temp1_auto_point2_hyst, S_IWUSR | S_IRUGO,
  1690 + show_pwm_hyst, set_pwm_hyst, 0);
  1691 +static SENSOR_DEVICE_ATTR(temp2_auto_point2_hyst, S_IWUSR | S_IRUGO,
  1692 + show_pwm_hyst, set_pwm_hyst, 1);
  1693 +static SENSOR_DEVICE_ATTR(temp3_auto_point2_hyst, S_IWUSR | S_IRUGO,
  1694 + show_pwm_hyst, set_pwm_hyst, 2);
  1695 +static SENSOR_DEVICE_ATTR(temp4_auto_point2_hyst, S_IWUSR | S_IRUGO,
  1696 + show_pwm_hyst, set_pwm_hyst, 3);
  1697 +
  1698 +static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IWUSR | S_IRUGO,
  1699 + show_pwm_tmin, set_pwm_tmin, 0);
  1700 +static SENSOR_DEVICE_ATTR(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
  1701 + show_pwm_tmin, set_pwm_tmin, 1);
  1702 +static SENSOR_DEVICE_ATTR(temp3_auto_point1_temp, S_IWUSR | S_IRUGO,
  1703 + show_pwm_tmin, set_pwm_tmin, 2);
  1704 +static SENSOR_DEVICE_ATTR(temp4_auto_point1_temp, S_IWUSR | S_IRUGO,
  1705 + show_pwm_tmin, set_pwm_tmin, 3);
  1706 +
  1707 +static SENSOR_DEVICE_ATTR(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
  1708 + show_pwm_tmax, set_pwm_tmax, 0);
  1709 +static SENSOR_DEVICE_ATTR(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
  1710 + show_pwm_tmax, set_pwm_tmax, 1);
  1711 +static SENSOR_DEVICE_ATTR(temp3_auto_point2_temp, S_IWUSR | S_IRUGO,
  1712 + show_pwm_tmax, set_pwm_tmax, 2);
  1713 +static SENSOR_DEVICE_ATTR(temp4_auto_point2_temp, S_IWUSR | S_IRUGO,
  1714 + show_pwm_tmax, set_pwm_tmax, 3);
  1715 +
  1716 +static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
  1717 + set_pwm_auto, 0);
  1718 +static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
  1719 + set_pwm_auto, 1);
  1720 +static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
  1721 + set_pwm_auto, 2);
  1722 +static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO, show_pwm_auto,
  1723 + set_pwm_auto, 3);
  1724 +
  1725 +static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
  1726 + show_pwm_auto_temp, set_pwm_auto_temp, 0);
  1727 +static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
  1728 + show_pwm_auto_temp, set_pwm_auto_temp, 1);
  1729 +static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
  1730 + show_pwm_auto_temp, set_pwm_auto_temp, 2);
  1731 +static SENSOR_DEVICE_ATTR(pwm4_auto_channels_temp, S_IWUSR | S_IRUGO,
  1732 + show_pwm_auto_temp, set_pwm_auto_temp, 3);
  1733 +
  1734 +static struct attribute *adt7462_attr[] =
  1735 +{
  1736 + &sensor_dev_attr_temp1_max.dev_attr.attr,
  1737 + &sensor_dev_attr_temp2_max.dev_attr.attr,
  1738 + &sensor_dev_attr_temp3_max.dev_attr.attr,
  1739 + &sensor_dev_attr_temp4_max.dev_attr.attr,
  1740 +
  1741 + &sensor_dev_attr_temp1_min.dev_attr.attr,
  1742 + &sensor_dev_attr_temp2_min.dev_attr.attr,
  1743 + &sensor_dev_attr_temp3_min.dev_attr.attr,
  1744 + &sensor_dev_attr_temp4_min.dev_attr.attr,
  1745 +
  1746 + &sensor_dev_attr_temp1_input.dev_attr.attr,
  1747 + &sensor_dev_attr_temp2_input.dev_attr.attr,
  1748 + &sensor_dev_attr_temp3_input.dev_attr.attr,
  1749 + &sensor_dev_attr_temp4_input.dev_attr.attr,
  1750 +
  1751 + &sensor_dev_attr_temp1_label.dev_attr.attr,
  1752 + &sensor_dev_attr_temp2_label.dev_attr.attr,
  1753 + &sensor_dev_attr_temp3_label.dev_attr.attr,
  1754 + &sensor_dev_attr_temp4_label.dev_attr.attr,
  1755 +
  1756 + &sensor_dev_attr_temp1_alarm.dev_attr.attr,
  1757 + &sensor_dev_attr_temp2_alarm.dev_attr.attr,
  1758 + &sensor_dev_attr_temp3_alarm.dev_attr.attr,
  1759 + &sensor_dev_attr_temp4_alarm.dev_attr.attr,
  1760 +
  1761 + &sensor_dev_attr_in1_max.dev_attr.attr,
  1762 + &sensor_dev_attr_in2_max.dev_attr.attr,
  1763 + &sensor_dev_attr_in3_max.dev_attr.attr,
  1764 + &sensor_dev_attr_in4_max.dev_attr.attr,
  1765 + &sensor_dev_attr_in5_max.dev_attr.attr,
  1766 + &sensor_dev_attr_in6_max.dev_attr.attr,
  1767 + &sensor_dev_attr_in7_max.dev_attr.attr,
  1768 + &sensor_dev_attr_in8_max.dev_attr.attr,
  1769 + &sensor_dev_attr_in9_max.dev_attr.attr,
  1770 + &sensor_dev_attr_in10_max.dev_attr.attr,
  1771 + &sensor_dev_attr_in11_max.dev_attr.attr,
  1772 + &sensor_dev_attr_in12_max.dev_attr.attr,
  1773 + &sensor_dev_attr_in13_max.dev_attr.attr,
  1774 +
  1775 + &sensor_dev_attr_in1_min.dev_attr.attr,
  1776 + &sensor_dev_attr_in2_min.dev_attr.attr,
  1777 + &sensor_dev_attr_in3_min.dev_attr.attr,
  1778 + &sensor_dev_attr_in4_min.dev_attr.attr,
  1779 + &sensor_dev_attr_in5_min.dev_attr.attr,
  1780 + &sensor_dev_attr_in6_min.dev_attr.attr,
  1781 + &sensor_dev_attr_in7_min.dev_attr.attr,
  1782 + &sensor_dev_attr_in8_min.dev_attr.attr,
  1783 + &sensor_dev_attr_in9_min.dev_attr.attr,
  1784 + &sensor_dev_attr_in10_min.dev_attr.attr,
  1785 + &sensor_dev_attr_in11_min.dev_attr.attr,
  1786 + &sensor_dev_attr_in12_min.dev_attr.attr,
  1787 + &sensor_dev_attr_in13_min.dev_attr.attr,
  1788 +
  1789 + &sensor_dev_attr_in1_input.dev_attr.attr,
  1790 + &sensor_dev_attr_in2_input.dev_attr.attr,
  1791 + &sensor_dev_attr_in3_input.dev_attr.attr,
  1792 + &sensor_dev_attr_in4_input.dev_attr.attr,
  1793 + &sensor_dev_attr_in5_input.dev_attr.attr,
  1794 + &sensor_dev_attr_in6_input.dev_attr.attr,
  1795 + &sensor_dev_attr_in7_input.dev_attr.attr,
  1796 + &sensor_dev_attr_in8_input.dev_attr.attr,
  1797 + &sensor_dev_attr_in9_input.dev_attr.attr,
  1798 + &sensor_dev_attr_in10_input.dev_attr.attr,
  1799 + &sensor_dev_attr_in11_input.dev_attr.attr,
  1800 + &sensor_dev_attr_in12_input.dev_attr.attr,
  1801 + &sensor_dev_attr_in13_input.dev_attr.attr,
  1802 +
  1803 + &sensor_dev_attr_in1_label.dev_attr.attr,
  1804 + &sensor_dev_attr_in2_label.dev_attr.attr,
  1805 + &sensor_dev_attr_in3_label.dev_attr.attr,
  1806 + &sensor_dev_attr_in4_label.dev_attr.attr,
  1807 + &sensor_dev_attr_in5_label.dev_attr.attr,
  1808 + &sensor_dev_attr_in6_label.dev_attr.attr,
  1809 + &sensor_dev_attr_in7_label.dev_attr.attr,
  1810 + &sensor_dev_attr_in8_label.dev_attr.attr,
  1811 + &sensor_dev_attr_in9_label.dev_attr.attr,
  1812 + &sensor_dev_attr_in10_label.dev_attr.attr,
  1813 + &sensor_dev_attr_in11_label.dev_attr.attr,
  1814 + &sensor_dev_attr_in12_label.dev_attr.attr,
  1815 + &sensor_dev_attr_in13_label.dev_attr.attr,
  1816 +
  1817 + &sensor_dev_attr_in1_alarm.dev_attr.attr,
  1818 + &sensor_dev_attr_in2_alarm.dev_attr.attr,
  1819 + &sensor_dev_attr_in3_alarm.dev_attr.attr,
  1820 + &sensor_dev_attr_in4_alarm.dev_attr.attr,
  1821 + &sensor_dev_attr_in5_alarm.dev_attr.attr,
  1822 + &sensor_dev_attr_in6_alarm.dev_attr.attr,
  1823 + &sensor_dev_attr_in7_alarm.dev_attr.attr,
  1824 + &sensor_dev_attr_in8_alarm.dev_attr.attr,
  1825 + &sensor_dev_attr_in9_alarm.dev_attr.attr,
  1826 + &sensor_dev_attr_in10_alarm.dev_attr.attr,
  1827 + &sensor_dev_attr_in11_alarm.dev_attr.attr,
  1828 + &sensor_dev_attr_in12_alarm.dev_attr.attr,
  1829 + &sensor_dev_attr_in13_alarm.dev_attr.attr,
  1830 +
  1831 + &sensor_dev_attr_fan1_min.dev_attr.attr,
  1832 + &sensor_dev_attr_fan2_min.dev_attr.attr,
  1833 + &sensor_dev_attr_fan3_min.dev_attr.attr,
  1834 + &sensor_dev_attr_fan4_min.dev_attr.attr,
  1835 + &sensor_dev_attr_fan5_min.dev_attr.attr,
  1836 + &sensor_dev_attr_fan6_min.dev_attr.attr,
  1837 + &sensor_dev_attr_fan7_min.dev_attr.attr,
  1838 + &sensor_dev_attr_fan8_min.dev_attr.attr,
  1839 +
  1840 + &sensor_dev_attr_fan1_input.dev_attr.attr,
  1841 + &sensor_dev_attr_fan2_input.dev_attr.attr,
  1842 + &sensor_dev_attr_fan3_input.dev_attr.attr,
  1843 + &sensor_dev_attr_fan4_input.dev_attr.attr,
  1844 + &sensor_dev_attr_fan5_input.dev_attr.attr,
  1845 + &sensor_dev_attr_fan6_input.dev_attr.attr,
  1846 + &sensor_dev_attr_fan7_input.dev_attr.attr,
  1847 + &sensor_dev_attr_fan8_input.dev_attr.attr,
  1848 +
  1849 + &sensor_dev_attr_fan1_alarm.dev_attr.attr,
  1850 + &sensor_dev_attr_fan2_alarm.dev_attr.attr,
  1851 + &sensor_dev_attr_fan3_alarm.dev_attr.attr,
  1852 + &sensor_dev_attr_fan4_alarm.dev_attr.attr,
  1853 + &sensor_dev_attr_fan5_alarm.dev_attr.attr,
  1854 + &sensor_dev_attr_fan6_alarm.dev_attr.attr,
  1855 + &sensor_dev_attr_fan7_alarm.dev_attr.attr,
  1856 + &sensor_dev_attr_fan8_alarm.dev_attr.attr,
  1857 +
  1858 + &sensor_dev_attr_force_pwm_max.dev_attr.attr,
  1859 + &sensor_dev_attr_pwm1.dev_attr.attr,
  1860 + &sensor_dev_attr_pwm2.dev_attr.attr,
  1861 + &sensor_dev_attr_pwm3.dev_attr.attr,
  1862 + &sensor_dev_attr_pwm4.dev_attr.attr,
  1863 +
  1864 + &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
  1865 + &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
  1866 + &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
  1867 + &sensor_dev_attr_pwm4_auto_point1_pwm.dev_attr.attr,
  1868 +
  1869 + &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
  1870 + &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
  1871 + &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
  1872 + &sensor_dev_attr_pwm4_auto_point2_pwm.dev_attr.attr,
  1873 +
  1874 + &sensor_dev_attr_temp1_auto_point1_hyst.dev_attr.attr,
  1875 + &sensor_dev_attr_temp2_auto_point1_hyst.dev_attr.attr,
  1876 + &sensor_dev_attr_temp3_auto_point1_hyst.dev_attr.attr,
  1877 + &sensor_dev_attr_temp4_auto_point1_hyst.dev_attr.attr,
  1878 +
  1879 + &sensor_dev_attr_temp1_auto_point2_hyst.dev_attr.attr,
  1880 + &sensor_dev_attr_temp2_auto_point2_hyst.dev_attr.attr,
  1881 + &sensor_dev_attr_temp3_auto_point2_hyst.dev_attr.attr,
  1882 + &sensor_dev_attr_temp4_auto_point2_hyst.dev_attr.attr,
  1883 +
  1884 + &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
  1885 + &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
  1886 + &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
  1887 + &sensor_dev_attr_temp4_auto_point1_temp.dev_attr.attr,
  1888 +
  1889 + &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
  1890 + &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
  1891 + &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
  1892 + &sensor_dev_attr_temp4_auto_point2_temp.dev_attr.attr,
  1893 +
  1894 + &sensor_dev_attr_pwm1_enable.dev_attr.attr,
  1895 + &sensor_dev_attr_pwm2_enable.dev_attr.attr,
  1896 + &sensor_dev_attr_pwm3_enable.dev_attr.attr,
  1897 + &sensor_dev_attr_pwm4_enable.dev_attr.attr,
  1898 +
  1899 + &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
  1900 + &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
  1901 + &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
  1902 + &sensor_dev_attr_pwm4_auto_channels_temp.dev_attr.attr,
  1903 + NULL
  1904 +};
  1905 +
  1906 +/* Return 0 if detection is successful, -ENODEV otherwise */
  1907 +static int adt7462_detect(struct i2c_client *client, int kind,
  1908 + struct i2c_board_info *info)
  1909 +{
  1910 + struct i2c_adapter *adapter = client->adapter;
  1911 +
  1912 + if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
  1913 + return -ENODEV;
  1914 +
  1915 + if (kind <= 0) {
  1916 + int vendor, device, revision;
  1917 +
  1918 + vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
  1919 + if (vendor != ADT7462_VENDOR)
  1920 + return -ENODEV;
  1921 +
  1922 + device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
  1923 + if (device != ADT7462_DEVICE)
  1924 + return -ENODEV;
  1925 +
  1926 + revision = i2c_smbus_read_byte_data(client,
  1927 + ADT7462_REG_REVISION);
  1928 + if (revision != ADT7462_REVISION)
  1929 + return -ENODEV;
  1930 + } else
  1931 + dev_dbg(&adapter->dev, "detection forced\n");
  1932 +
  1933 + strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
  1934 +
  1935 + return 0;
  1936 +}
  1937 +
  1938 +static int adt7462_probe(struct i2c_client *client,
  1939 + const struct i2c_device_id *id)
  1940 +{
  1941 + struct adt7462_data *data;
  1942 + int err;
  1943 +
  1944 + data = kzalloc(sizeof(struct adt7462_data), GFP_KERNEL);
  1945 + if (!data) {
  1946 + err = -ENOMEM;
  1947 + goto exit;
  1948 + }
  1949 +
  1950 + i2c_set_clientdata(client, data);
  1951 + mutex_init(&data->lock);
  1952 +
  1953 + dev_info(&client->dev, "%s chip found\n", client->name);
  1954 +
  1955 + /* Register sysfs hooks */
  1956 + data->attrs.attrs = adt7462_attr;
  1957 + err = sysfs_create_group(&client->dev.kobj, &data->attrs);
  1958 + if (err)
  1959 + goto exit_free;
  1960 +
  1961 + data->hwmon_dev = hwmon_device_register(&client->dev);
  1962 + if (IS_ERR(data->hwmon_dev)) {
  1963 + err = PTR_ERR(data->hwmon_dev);
  1964 + goto exit_remove;
  1965 + }
  1966 +
  1967 + return 0;
  1968 +
  1969 +exit_remove:
  1970 + sysfs_remove_group(&client->dev.kobj, &data->attrs);
  1971 +exit_free:
  1972 + kfree(data);
  1973 +exit:
  1974 + return err;
  1975 +}
  1976 +
  1977 +static int adt7462_remove(struct i2c_client *client)
  1978 +{
  1979 + struct adt7462_data *data = i2c_get_clientdata(client);
  1980 +
  1981 + hwmon_device_unregister(data->hwmon_dev);
  1982 + sysfs_remove_group(&client->dev.kobj, &data->attrs);
  1983 + kfree(data);
  1984 + return 0;
  1985 +}
  1986 +
  1987 +static int __init adt7462_init(void)
  1988 +{
  1989 + return i2c_add_driver(&adt7462_driver);
  1990 +}
  1991 +
  1992 +static void __exit adt7462_exit(void)
  1993 +{
  1994 + i2c_del_driver(&adt7462_driver);
  1995 +}
  1996 +
  1997 +MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
  1998 +MODULE_DESCRIPTION("ADT7462 driver");
  1999 +MODULE_LICENSE("GPL");
  2000 +
  2001 +module_init(adt7462_init);
  2002 +module_exit(adt7462_exit);