19431996fSJuerg Haefliger /* 2ea694431SJuerg Haefliger * dme1737.c - Driver for the SMSC DME1737, Asus A8000, SMSC SCH311x, SCH5027, 3ea694431SJuerg Haefliger * and SCH5127 Super-I/O chips integrated hardware monitoring 4ea694431SJuerg Haefliger * features. 5ea694431SJuerg Haefliger * Copyright (c) 2007, 2008, 2009, 2010 Juerg Haefliger <juergh@gmail.com> 69431996fSJuerg Haefliger * 7e95c237dSJuerg Haefliger * This driver is an I2C/ISA hybrid, meaning that it uses the I2C bus to access 8549edb83SJuerg Haefliger * the chip registers if a DME1737, A8000, or SCH5027 is found and the ISA bus 9ea694431SJuerg Haefliger * if a SCH311x or SCH5127 chip is found. Both types of chips have very 10ea694431SJuerg Haefliger * similar hardware monitoring capabilities but differ in the way they can be 11ea694431SJuerg Haefliger * accessed. 129431996fSJuerg Haefliger * 139431996fSJuerg Haefliger * This program is free software; you can redistribute it and/or modify 149431996fSJuerg Haefliger * it under the terms of the GNU General Public License as published by 159431996fSJuerg Haefliger * the Free Software Foundation; either version 2 of the License, or 169431996fSJuerg Haefliger * (at your option) any later version. 179431996fSJuerg Haefliger * 189431996fSJuerg Haefliger * This program is distributed in the hope that it will be useful, 199431996fSJuerg Haefliger * but WITHOUT ANY WARRANTY; without even the implied warranty of 209431996fSJuerg Haefliger * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 219431996fSJuerg Haefliger * GNU General Public License for more details. 229431996fSJuerg Haefliger * 239431996fSJuerg Haefliger * You should have received a copy of the GNU General Public License 249431996fSJuerg Haefliger * along with this program; if not, write to the Free Software 259431996fSJuerg Haefliger * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 269431996fSJuerg Haefliger */ 279431996fSJuerg Haefliger 289c6e13b4SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 299c6e13b4SJoe Perches 309431996fSJuerg Haefliger #include <linux/module.h> 319431996fSJuerg Haefliger #include <linux/init.h> 329431996fSJuerg Haefliger #include <linux/slab.h> 339431996fSJuerg Haefliger #include <linux/jiffies.h> 349431996fSJuerg Haefliger #include <linux/i2c.h> 35e95c237dSJuerg Haefliger #include <linux/platform_device.h> 369431996fSJuerg Haefliger #include <linux/hwmon.h> 379431996fSJuerg Haefliger #include <linux/hwmon-sysfs.h> 389431996fSJuerg Haefliger #include <linux/hwmon-vid.h> 399431996fSJuerg Haefliger #include <linux/err.h> 409431996fSJuerg Haefliger #include <linux/mutex.h> 41b9acb64aSJean Delvare #include <linux/acpi.h> 426055fae8SH Hartley Sweeten #include <linux/io.h> 439431996fSJuerg Haefliger 44e95c237dSJuerg Haefliger /* ISA device, if found */ 45e95c237dSJuerg Haefliger static struct platform_device *pdev; 46e95c237dSJuerg Haefliger 479431996fSJuerg Haefliger /* Module load parameters */ 489431996fSJuerg Haefliger static int force_start; 499431996fSJuerg Haefliger module_param(force_start, bool, 0); 509431996fSJuerg Haefliger MODULE_PARM_DESC(force_start, "Force the chip to start monitoring inputs"); 519431996fSJuerg Haefliger 5267b671bcSJean Delvare static unsigned short force_id; 5367b671bcSJean Delvare module_param(force_id, ushort, 0); 5467b671bcSJean Delvare MODULE_PARM_DESC(force_id, "Override the detected device ID"); 5567b671bcSJean Delvare 5692430b6fSJuerg Haefliger static int probe_all_addr; 5792430b6fSJuerg Haefliger module_param(probe_all_addr, bool, 0); 5892430b6fSJuerg Haefliger MODULE_PARM_DESC(probe_all_addr, "Include probing of non-standard LPC " 5992430b6fSJuerg Haefliger "addresses"); 6092430b6fSJuerg Haefliger 619431996fSJuerg Haefliger /* Addresses to scan */ 6225e9c86dSMark M. Hoffman static const unsigned short normal_i2c[] = {0x2c, 0x2d, 0x2e, I2C_CLIENT_END}; 639431996fSJuerg Haefliger 64ea694431SJuerg Haefliger enum chips { dme1737, sch5027, sch311x, sch5127 }; 659431996fSJuerg Haefliger 669431996fSJuerg Haefliger /* --------------------------------------------------------------------- 679431996fSJuerg Haefliger * Registers 689431996fSJuerg Haefliger * 699431996fSJuerg Haefliger * The sensors are defined as follows: 709431996fSJuerg Haefliger * 719431996fSJuerg Haefliger * Voltages Temperatures 729431996fSJuerg Haefliger * -------- ------------ 739431996fSJuerg Haefliger * in0 +5VTR (+5V stdby) temp1 Remote diode 1 749431996fSJuerg Haefliger * in1 Vccp (proc core) temp2 Internal temp 759431996fSJuerg Haefliger * in2 VCC (internal +3.3V) temp3 Remote diode 2 769431996fSJuerg Haefliger * in3 +5V 779431996fSJuerg Haefliger * in4 +12V 789431996fSJuerg Haefliger * in5 VTR (+3.3V stby) 799431996fSJuerg Haefliger * in6 Vbat 80d4b94e1fSJuerg Haefliger * in7 Vtrip (sch5127 only) 819431996fSJuerg Haefliger * 829431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 839431996fSJuerg Haefliger 84d4b94e1fSJuerg Haefliger /* Voltages (in) numbered 0-7 (ix) */ 85d4b94e1fSJuerg Haefliger #define DME1737_REG_IN(ix) ((ix) < 5 ? 0x20 + (ix) : \ 86d4b94e1fSJuerg Haefliger (ix) < 7 ? 0x94 + (ix) : \ 87d4b94e1fSJuerg Haefliger 0x1f) 889431996fSJuerg Haefliger #define DME1737_REG_IN_MIN(ix) ((ix) < 5 ? 0x44 + (ix) * 2 \ 899431996fSJuerg Haefliger : 0x91 + (ix) * 2) 909431996fSJuerg Haefliger #define DME1737_REG_IN_MAX(ix) ((ix) < 5 ? 0x45 + (ix) * 2 \ 919431996fSJuerg Haefliger : 0x92 + (ix) * 2) 929431996fSJuerg Haefliger 939431996fSJuerg Haefliger /* Temperatures (temp) numbered 0-2 (ix) */ 949431996fSJuerg Haefliger #define DME1737_REG_TEMP(ix) (0x25 + (ix)) 959431996fSJuerg Haefliger #define DME1737_REG_TEMP_MIN(ix) (0x4e + (ix) * 2) 969431996fSJuerg Haefliger #define DME1737_REG_TEMP_MAX(ix) (0x4f + (ix) * 2) 979431996fSJuerg Haefliger #define DME1737_REG_TEMP_OFFSET(ix) ((ix) == 0 ? 0x1f \ 989431996fSJuerg Haefliger : 0x1c + (ix)) 999431996fSJuerg Haefliger 1009431996fSJuerg Haefliger /* Voltage and temperature LSBs 1019431996fSJuerg Haefliger * The LSBs (4 bits each) are stored in 5 registers with the following layouts: 1029431996fSJuerg Haefliger * IN_TEMP_LSB(0) = [in5, in6] 1039431996fSJuerg Haefliger * IN_TEMP_LSB(1) = [temp3, temp1] 1049431996fSJuerg Haefliger * IN_TEMP_LSB(2) = [in4, temp2] 1059431996fSJuerg Haefliger * IN_TEMP_LSB(3) = [in3, in0] 106d4b94e1fSJuerg Haefliger * IN_TEMP_LSB(4) = [in2, in1] 107d4b94e1fSJuerg Haefliger * IN_TEMP_LSB(5) = [res, in7] */ 1089431996fSJuerg Haefliger #define DME1737_REG_IN_TEMP_LSB(ix) (0x84 + (ix)) 109d4b94e1fSJuerg Haefliger static const u8 DME1737_REG_IN_LSB[] = {3, 4, 4, 3, 2, 0, 0, 5}; 110d4b94e1fSJuerg Haefliger static const u8 DME1737_REG_IN_LSB_SHL[] = {4, 4, 0, 0, 0, 0, 4, 4}; 1119431996fSJuerg Haefliger static const u8 DME1737_REG_TEMP_LSB[] = {1, 2, 1}; 1129431996fSJuerg Haefliger static const u8 DME1737_REG_TEMP_LSB_SHL[] = {4, 4, 0}; 1139431996fSJuerg Haefliger 1149431996fSJuerg Haefliger /* Fans numbered 0-5 (ix) */ 1159431996fSJuerg Haefliger #define DME1737_REG_FAN(ix) ((ix) < 4 ? 0x28 + (ix) * 2 \ 1169431996fSJuerg Haefliger : 0xa1 + (ix) * 2) 1179431996fSJuerg Haefliger #define DME1737_REG_FAN_MIN(ix) ((ix) < 4 ? 0x54 + (ix) * 2 \ 1189431996fSJuerg Haefliger : 0xa5 + (ix) * 2) 1199431996fSJuerg Haefliger #define DME1737_REG_FAN_OPT(ix) ((ix) < 4 ? 0x90 + (ix) \ 1209431996fSJuerg Haefliger : 0xb2 + (ix)) 1219431996fSJuerg Haefliger #define DME1737_REG_FAN_MAX(ix) (0xb4 + (ix)) /* only for fan[4-5] */ 1229431996fSJuerg Haefliger 1239431996fSJuerg Haefliger /* PWMs numbered 0-2, 4-5 (ix) */ 1249431996fSJuerg Haefliger #define DME1737_REG_PWM(ix) ((ix) < 3 ? 0x30 + (ix) \ 1259431996fSJuerg Haefliger : 0xa1 + (ix)) 1269431996fSJuerg Haefliger #define DME1737_REG_PWM_CONFIG(ix) (0x5c + (ix)) /* only for pwm[0-2] */ 1279431996fSJuerg Haefliger #define DME1737_REG_PWM_MIN(ix) (0x64 + (ix)) /* only for pwm[0-2] */ 1289431996fSJuerg Haefliger #define DME1737_REG_PWM_FREQ(ix) ((ix) < 3 ? 0x5f + (ix) \ 1299431996fSJuerg Haefliger : 0xa3 + (ix)) 1309431996fSJuerg Haefliger /* The layout of the ramp rate registers is different from the other pwm 1319431996fSJuerg Haefliger * registers. The bits for the 3 PWMs are stored in 2 registers: 1329431996fSJuerg Haefliger * PWM_RR(0) = [OFF3, OFF2, OFF1, RES, RR1E, RR1-2, RR1-1, RR1-0] 1339431996fSJuerg Haefliger * PWM_RR(1) = [RR2E, RR2-2, RR2-1, RR2-0, RR3E, RR3-2, RR3-1, RR3-0] */ 1349431996fSJuerg Haefliger #define DME1737_REG_PWM_RR(ix) (0x62 + (ix)) /* only for pwm[0-2] */ 1359431996fSJuerg Haefliger 1369431996fSJuerg Haefliger /* Thermal zones 0-2 */ 1379431996fSJuerg Haefliger #define DME1737_REG_ZONE_LOW(ix) (0x67 + (ix)) 1389431996fSJuerg Haefliger #define DME1737_REG_ZONE_ABS(ix) (0x6a + (ix)) 1399431996fSJuerg Haefliger /* The layout of the hysteresis registers is different from the other zone 1409431996fSJuerg Haefliger * registers. The bits for the 3 zones are stored in 2 registers: 1419431996fSJuerg Haefliger * ZONE_HYST(0) = [H1-3, H1-2, H1-1, H1-0, H2-3, H2-2, H2-1, H2-0] 1429431996fSJuerg Haefliger * ZONE_HYST(1) = [H3-3, H3-2, H3-1, H3-0, RES, RES, RES, RES] */ 1439431996fSJuerg Haefliger #define DME1737_REG_ZONE_HYST(ix) (0x6d + (ix)) 1449431996fSJuerg Haefliger 1459431996fSJuerg Haefliger /* Alarm registers and bit mapping 1469431996fSJuerg Haefliger * The 3 8-bit alarm registers will be concatenated to a single 32-bit 1479431996fSJuerg Haefliger * alarm value [0, ALARM3, ALARM2, ALARM1]. */ 1489431996fSJuerg Haefliger #define DME1737_REG_ALARM1 0x41 1499431996fSJuerg Haefliger #define DME1737_REG_ALARM2 0x42 1509431996fSJuerg Haefliger #define DME1737_REG_ALARM3 0x83 151d4b94e1fSJuerg Haefliger static const u8 DME1737_BIT_ALARM_IN[] = {0, 1, 2, 3, 8, 16, 17, 18}; 1529431996fSJuerg Haefliger static const u8 DME1737_BIT_ALARM_TEMP[] = {4, 5, 6}; 1539431996fSJuerg Haefliger static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23}; 1549431996fSJuerg Haefliger 1559431996fSJuerg Haefliger /* Miscellaneous registers */ 156e95c237dSJuerg Haefliger #define DME1737_REG_DEVICE 0x3d 1579431996fSJuerg Haefliger #define DME1737_REG_COMPANY 0x3e 1589431996fSJuerg Haefliger #define DME1737_REG_VERSTEP 0x3f 1599431996fSJuerg Haefliger #define DME1737_REG_CONFIG 0x40 1609431996fSJuerg Haefliger #define DME1737_REG_CONFIG2 0x7f 1619431996fSJuerg Haefliger #define DME1737_REG_VID 0x43 1629431996fSJuerg Haefliger #define DME1737_REG_TACH_PWM 0x81 1639431996fSJuerg Haefliger 1649431996fSJuerg Haefliger /* --------------------------------------------------------------------- 1659431996fSJuerg Haefliger * Misc defines 1669431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 1679431996fSJuerg Haefliger 1689431996fSJuerg Haefliger /* Chip identification */ 1699431996fSJuerg Haefliger #define DME1737_COMPANY_SMSC 0x5c 1709431996fSJuerg Haefliger #define DME1737_VERSTEP 0x88 1719431996fSJuerg Haefliger #define DME1737_VERSTEP_MASK 0xf8 172e95c237dSJuerg Haefliger #define SCH311X_DEVICE 0x8c 173549edb83SJuerg Haefliger #define SCH5027_VERSTEP 0x69 174ea694431SJuerg Haefliger #define SCH5127_DEVICE 0x8e 175ea694431SJuerg Haefliger 176ea694431SJuerg Haefliger /* Device ID values (global configuration register index 0x20) */ 177ea694431SJuerg Haefliger #define DME1737_ID_1 0x77 178ea694431SJuerg Haefliger #define DME1737_ID_2 0x78 179ea694431SJuerg Haefliger #define SCH3112_ID 0x7c 180ea694431SJuerg Haefliger #define SCH3114_ID 0x7d 181ea694431SJuerg Haefliger #define SCH3116_ID 0x7f 182ea694431SJuerg Haefliger #define SCH5027_ID 0x89 183ea694431SJuerg Haefliger #define SCH5127_ID 0x86 184e95c237dSJuerg Haefliger 185e95c237dSJuerg Haefliger /* Length of ISA address segment */ 186e95c237dSJuerg Haefliger #define DME1737_EXTENT 2 1879431996fSJuerg Haefliger 188ea694431SJuerg Haefliger /* chip-dependent features */ 189ea694431SJuerg Haefliger #define HAS_TEMP_OFFSET (1 << 0) /* bit 0 */ 190ea694431SJuerg Haefliger #define HAS_VID (1 << 1) /* bit 1 */ 191ea694431SJuerg Haefliger #define HAS_ZONE3 (1 << 2) /* bit 2 */ 192ea694431SJuerg Haefliger #define HAS_ZONE_HYST (1 << 3) /* bit 3 */ 193ea694431SJuerg Haefliger #define HAS_PWM_MIN (1 << 4) /* bit 4 */ 194ea694431SJuerg Haefliger #define HAS_FAN(ix) (1 << ((ix) + 5)) /* bits 5-10 */ 195ea694431SJuerg Haefliger #define HAS_PWM(ix) (1 << ((ix) + 11)) /* bits 11-16 */ 196d4b94e1fSJuerg Haefliger #define HAS_IN7 (1 << 17) /* bit 17 */ 197ea694431SJuerg Haefliger 1989431996fSJuerg Haefliger /* --------------------------------------------------------------------- 1999431996fSJuerg Haefliger * Data structures and manipulation thereof 2009431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 2019431996fSJuerg Haefliger 2029431996fSJuerg Haefliger struct dme1737_data { 203dbc2bc25SJean Delvare struct i2c_client *client; /* for I2C devices only */ 2041beeffe4STony Jones struct device *hwmon_dev; 205dbc2bc25SJean Delvare const char *name; 206dbc2bc25SJean Delvare unsigned int addr; /* for ISA devices only */ 2079431996fSJuerg Haefliger 2089431996fSJuerg Haefliger struct mutex update_lock; 2099431996fSJuerg Haefliger int valid; /* !=0 if following fields are valid */ 2109431996fSJuerg Haefliger unsigned long last_update; /* in jiffies */ 2119431996fSJuerg Haefliger unsigned long last_vbat; /* in jiffies */ 212f994fb23SJuerg Haefliger enum chips type; 213549edb83SJuerg Haefliger const int *in_nominal; /* pointer to IN_NOMINAL array */ 2149431996fSJuerg Haefliger 2159431996fSJuerg Haefliger u8 vid; 2169431996fSJuerg Haefliger u8 pwm_rr_en; 217ea694431SJuerg Haefliger u32 has_features; 2189431996fSJuerg Haefliger 2199431996fSJuerg Haefliger /* Register values */ 220d4b94e1fSJuerg Haefliger u16 in[8]; 221d4b94e1fSJuerg Haefliger u8 in_min[8]; 222d4b94e1fSJuerg Haefliger u8 in_max[8]; 2239431996fSJuerg Haefliger s16 temp[3]; 2249431996fSJuerg Haefliger s8 temp_min[3]; 2259431996fSJuerg Haefliger s8 temp_max[3]; 2269431996fSJuerg Haefliger s8 temp_offset[3]; 2279431996fSJuerg Haefliger u8 config; 2289431996fSJuerg Haefliger u8 config2; 2299431996fSJuerg Haefliger u8 vrm; 2309431996fSJuerg Haefliger u16 fan[6]; 2319431996fSJuerg Haefliger u16 fan_min[6]; 2329431996fSJuerg Haefliger u8 fan_max[2]; 2339431996fSJuerg Haefliger u8 fan_opt[6]; 2349431996fSJuerg Haefliger u8 pwm[6]; 2359431996fSJuerg Haefliger u8 pwm_min[3]; 2369431996fSJuerg Haefliger u8 pwm_config[3]; 2379431996fSJuerg Haefliger u8 pwm_acz[3]; 2389431996fSJuerg Haefliger u8 pwm_freq[6]; 2399431996fSJuerg Haefliger u8 pwm_rr[2]; 2409431996fSJuerg Haefliger u8 zone_low[3]; 2419431996fSJuerg Haefliger u8 zone_abs[3]; 2429431996fSJuerg Haefliger u8 zone_hyst[2]; 2439431996fSJuerg Haefliger u32 alarms; 2449431996fSJuerg Haefliger }; 2459431996fSJuerg Haefliger 2469431996fSJuerg Haefliger /* Nominal voltage values */ 247f994fb23SJuerg Haefliger static const int IN_NOMINAL_DME1737[] = {5000, 2250, 3300, 5000, 12000, 3300, 248f994fb23SJuerg Haefliger 3300}; 249f994fb23SJuerg Haefliger static const int IN_NOMINAL_SCH311x[] = {2500, 1500, 3300, 5000, 12000, 3300, 250f994fb23SJuerg Haefliger 3300}; 251549edb83SJuerg Haefliger static const int IN_NOMINAL_SCH5027[] = {5000, 2250, 3300, 1125, 1125, 3300, 252549edb83SJuerg Haefliger 3300}; 253ea694431SJuerg Haefliger static const int IN_NOMINAL_SCH5127[] = {2500, 2250, 3300, 1125, 1125, 3300, 254d4b94e1fSJuerg Haefliger 3300, 1500}; 255549edb83SJuerg Haefliger #define IN_NOMINAL(type) ((type) == sch311x ? IN_NOMINAL_SCH311x : \ 256549edb83SJuerg Haefliger (type) == sch5027 ? IN_NOMINAL_SCH5027 : \ 257ea694431SJuerg Haefliger (type) == sch5127 ? IN_NOMINAL_SCH5127 : \ 258549edb83SJuerg Haefliger IN_NOMINAL_DME1737) 2599431996fSJuerg Haefliger 2609431996fSJuerg Haefliger /* Voltage input 2619431996fSJuerg Haefliger * Voltage inputs have 16 bits resolution, limit values have 8 bits 2629431996fSJuerg Haefliger * resolution. */ 263549edb83SJuerg Haefliger static inline int IN_FROM_REG(int reg, int nominal, int res) 2649431996fSJuerg Haefliger { 265549edb83SJuerg Haefliger return (reg * nominal + (3 << (res - 3))) / (3 << (res - 2)); 2669431996fSJuerg Haefliger } 2679431996fSJuerg Haefliger 268549edb83SJuerg Haefliger static inline int IN_TO_REG(int val, int nominal) 2699431996fSJuerg Haefliger { 270549edb83SJuerg Haefliger return SENSORS_LIMIT((val * 192 + nominal / 2) / nominal, 0, 255); 2719431996fSJuerg Haefliger } 2729431996fSJuerg Haefliger 2739431996fSJuerg Haefliger /* Temperature input 2749431996fSJuerg Haefliger * The register values represent temperatures in 2's complement notation from 2759431996fSJuerg Haefliger * -127 degrees C to +127 degrees C. Temp inputs have 16 bits resolution, limit 2769431996fSJuerg Haefliger * values have 8 bits resolution. */ 2779431996fSJuerg Haefliger static inline int TEMP_FROM_REG(int reg, int res) 2789431996fSJuerg Haefliger { 2799431996fSJuerg Haefliger return (reg * 1000) >> (res - 8); 2809431996fSJuerg Haefliger } 2819431996fSJuerg Haefliger 2829431996fSJuerg Haefliger static inline int TEMP_TO_REG(int val) 2839431996fSJuerg Haefliger { 2849431996fSJuerg Haefliger return SENSORS_LIMIT((val < 0 ? val - 500 : val + 500) / 1000, 2859431996fSJuerg Haefliger -128, 127); 2869431996fSJuerg Haefliger } 2879431996fSJuerg Haefliger 2889431996fSJuerg Haefliger /* Temperature range */ 2899431996fSJuerg Haefliger static const int TEMP_RANGE[] = {2000, 2500, 3333, 4000, 5000, 6666, 8000, 2909431996fSJuerg Haefliger 10000, 13333, 16000, 20000, 26666, 32000, 2919431996fSJuerg Haefliger 40000, 53333, 80000}; 2929431996fSJuerg Haefliger 2939431996fSJuerg Haefliger static inline int TEMP_RANGE_FROM_REG(int reg) 2949431996fSJuerg Haefliger { 2959431996fSJuerg Haefliger return TEMP_RANGE[(reg >> 4) & 0x0f]; 2969431996fSJuerg Haefliger } 2979431996fSJuerg Haefliger 2989431996fSJuerg Haefliger static int TEMP_RANGE_TO_REG(int val, int reg) 2999431996fSJuerg Haefliger { 3009431996fSJuerg Haefliger int i; 3019431996fSJuerg Haefliger 3029431996fSJuerg Haefliger for (i = 15; i > 0; i--) { 3039431996fSJuerg Haefliger if (val > (TEMP_RANGE[i] + TEMP_RANGE[i - 1] + 1) / 2) { 3049431996fSJuerg Haefliger break; 3059431996fSJuerg Haefliger } 3069431996fSJuerg Haefliger } 3079431996fSJuerg Haefliger 3089431996fSJuerg Haefliger return (reg & 0x0f) | (i << 4); 3099431996fSJuerg Haefliger } 3109431996fSJuerg Haefliger 3119431996fSJuerg Haefliger /* Temperature hysteresis 3129431996fSJuerg Haefliger * Register layout: 3139431996fSJuerg Haefliger * reg[0] = [H1-3, H1-2, H1-1, H1-0, H2-3, H2-2, H2-1, H2-0] 3149431996fSJuerg Haefliger * reg[1] = [H3-3, H3-2, H3-1, H3-0, xxxx, xxxx, xxxx, xxxx] */ 3159431996fSJuerg Haefliger static inline int TEMP_HYST_FROM_REG(int reg, int ix) 3169431996fSJuerg Haefliger { 3179431996fSJuerg Haefliger return (((ix == 1) ? reg : reg >> 4) & 0x0f) * 1000; 3189431996fSJuerg Haefliger } 3199431996fSJuerg Haefliger 3209431996fSJuerg Haefliger static inline int TEMP_HYST_TO_REG(int val, int ix, int reg) 3219431996fSJuerg Haefliger { 3229431996fSJuerg Haefliger int hyst = SENSORS_LIMIT((val + 500) / 1000, 0, 15); 3239431996fSJuerg Haefliger 3249431996fSJuerg Haefliger return (ix == 1) ? (reg & 0xf0) | hyst : (reg & 0x0f) | (hyst << 4); 3259431996fSJuerg Haefliger } 3269431996fSJuerg Haefliger 3279431996fSJuerg Haefliger /* Fan input RPM */ 3289431996fSJuerg Haefliger static inline int FAN_FROM_REG(int reg, int tpc) 3299431996fSJuerg Haefliger { 330ff8421f7SJuerg Haefliger if (tpc) { 331ff8421f7SJuerg Haefliger return tpc * reg; 332ff8421f7SJuerg Haefliger } else { 333ff8421f7SJuerg Haefliger return (reg == 0 || reg == 0xffff) ? 0 : 90000 * 60 / reg; 334ff8421f7SJuerg Haefliger } 3359431996fSJuerg Haefliger } 3369431996fSJuerg Haefliger 3379431996fSJuerg Haefliger static inline int FAN_TO_REG(int val, int tpc) 3389431996fSJuerg Haefliger { 339ff8421f7SJuerg Haefliger if (tpc) { 340ff8421f7SJuerg Haefliger return SENSORS_LIMIT(val / tpc, 0, 0xffff); 341ff8421f7SJuerg Haefliger } else { 342ff8421f7SJuerg Haefliger return (val <= 0) ? 0xffff : 343ff8421f7SJuerg Haefliger SENSORS_LIMIT(90000 * 60 / val, 0, 0xfffe); 344ff8421f7SJuerg Haefliger } 3459431996fSJuerg Haefliger } 3469431996fSJuerg Haefliger 3479431996fSJuerg Haefliger /* Fan TPC (tach pulse count) 3489431996fSJuerg Haefliger * Converts a register value to a TPC multiplier or returns 0 if the tachometer 3499431996fSJuerg Haefliger * is configured in legacy (non-tpc) mode */ 3509431996fSJuerg Haefliger static inline int FAN_TPC_FROM_REG(int reg) 3519431996fSJuerg Haefliger { 3529431996fSJuerg Haefliger return (reg & 0x20) ? 0 : 60 >> (reg & 0x03); 3539431996fSJuerg Haefliger } 3549431996fSJuerg Haefliger 3559431996fSJuerg Haefliger /* Fan type 3569431996fSJuerg Haefliger * The type of a fan is expressed in number of pulses-per-revolution that it 3579431996fSJuerg Haefliger * emits */ 3589431996fSJuerg Haefliger static inline int FAN_TYPE_FROM_REG(int reg) 3599431996fSJuerg Haefliger { 3609431996fSJuerg Haefliger int edge = (reg >> 1) & 0x03; 3619431996fSJuerg Haefliger 3629431996fSJuerg Haefliger return (edge > 0) ? 1 << (edge - 1) : 0; 3639431996fSJuerg Haefliger } 3649431996fSJuerg Haefliger 3659431996fSJuerg Haefliger static inline int FAN_TYPE_TO_REG(int val, int reg) 3669431996fSJuerg Haefliger { 3679431996fSJuerg Haefliger int edge = (val == 4) ? 3 : val; 3689431996fSJuerg Haefliger 3699431996fSJuerg Haefliger return (reg & 0xf9) | (edge << 1); 3709431996fSJuerg Haefliger } 3719431996fSJuerg Haefliger 3729431996fSJuerg Haefliger /* Fan max RPM */ 3739431996fSJuerg Haefliger static const int FAN_MAX[] = {0x54, 0x38, 0x2a, 0x21, 0x1c, 0x18, 0x15, 0x12, 3749431996fSJuerg Haefliger 0x11, 0x0f, 0x0e}; 3759431996fSJuerg Haefliger 3769431996fSJuerg Haefliger static int FAN_MAX_FROM_REG(int reg) 3779431996fSJuerg Haefliger { 3789431996fSJuerg Haefliger int i; 3799431996fSJuerg Haefliger 3809431996fSJuerg Haefliger for (i = 10; i > 0; i--) { 3819431996fSJuerg Haefliger if (reg == FAN_MAX[i]) { 3829431996fSJuerg Haefliger break; 3839431996fSJuerg Haefliger } 3849431996fSJuerg Haefliger } 3859431996fSJuerg Haefliger 3869431996fSJuerg Haefliger return 1000 + i * 500; 3879431996fSJuerg Haefliger } 3889431996fSJuerg Haefliger 3899431996fSJuerg Haefliger static int FAN_MAX_TO_REG(int val) 3909431996fSJuerg Haefliger { 3919431996fSJuerg Haefliger int i; 3929431996fSJuerg Haefliger 3939431996fSJuerg Haefliger for (i = 10; i > 0; i--) { 3949431996fSJuerg Haefliger if (val > (1000 + (i - 1) * 500)) { 3959431996fSJuerg Haefliger break; 3969431996fSJuerg Haefliger } 3979431996fSJuerg Haefliger } 3989431996fSJuerg Haefliger 3999431996fSJuerg Haefliger return FAN_MAX[i]; 4009431996fSJuerg Haefliger } 4019431996fSJuerg Haefliger 4029431996fSJuerg Haefliger /* PWM enable 4039431996fSJuerg Haefliger * Register to enable mapping: 4049431996fSJuerg Haefliger * 000: 2 fan on zone 1 auto 4059431996fSJuerg Haefliger * 001: 2 fan on zone 2 auto 4069431996fSJuerg Haefliger * 010: 2 fan on zone 3 auto 4079431996fSJuerg Haefliger * 011: 0 fan full on 4089431996fSJuerg Haefliger * 100: -1 fan disabled 4099431996fSJuerg Haefliger * 101: 2 fan on hottest of zones 2,3 auto 4109431996fSJuerg Haefliger * 110: 2 fan on hottest of zones 1,2,3 auto 4119431996fSJuerg Haefliger * 111: 1 fan in manual mode */ 4129431996fSJuerg Haefliger static inline int PWM_EN_FROM_REG(int reg) 4139431996fSJuerg Haefliger { 4149431996fSJuerg Haefliger static const int en[] = {2, 2, 2, 0, -1, 2, 2, 1}; 4159431996fSJuerg Haefliger 4169431996fSJuerg Haefliger return en[(reg >> 5) & 0x07]; 4179431996fSJuerg Haefliger } 4189431996fSJuerg Haefliger 4199431996fSJuerg Haefliger static inline int PWM_EN_TO_REG(int val, int reg) 4209431996fSJuerg Haefliger { 4219431996fSJuerg Haefliger int en = (val == 1) ? 7 : 3; 4229431996fSJuerg Haefliger 4239431996fSJuerg Haefliger return (reg & 0x1f) | ((en & 0x07) << 5); 4249431996fSJuerg Haefliger } 4259431996fSJuerg Haefliger 4269431996fSJuerg Haefliger /* PWM auto channels zone 4279431996fSJuerg Haefliger * Register to auto channels zone mapping (ACZ is a bitfield with bit x 4289431996fSJuerg Haefliger * corresponding to zone x+1): 4299431996fSJuerg Haefliger * 000: 001 fan on zone 1 auto 4309431996fSJuerg Haefliger * 001: 010 fan on zone 2 auto 4319431996fSJuerg Haefliger * 010: 100 fan on zone 3 auto 4329431996fSJuerg Haefliger * 011: 000 fan full on 4339431996fSJuerg Haefliger * 100: 000 fan disabled 4349431996fSJuerg Haefliger * 101: 110 fan on hottest of zones 2,3 auto 4359431996fSJuerg Haefliger * 110: 111 fan on hottest of zones 1,2,3 auto 4369431996fSJuerg Haefliger * 111: 000 fan in manual mode */ 4379431996fSJuerg Haefliger static inline int PWM_ACZ_FROM_REG(int reg) 4389431996fSJuerg Haefliger { 4399431996fSJuerg Haefliger static const int acz[] = {1, 2, 4, 0, 0, 6, 7, 0}; 4409431996fSJuerg Haefliger 4419431996fSJuerg Haefliger return acz[(reg >> 5) & 0x07]; 4429431996fSJuerg Haefliger } 4439431996fSJuerg Haefliger 4449431996fSJuerg Haefliger static inline int PWM_ACZ_TO_REG(int val, int reg) 4459431996fSJuerg Haefliger { 4469431996fSJuerg Haefliger int acz = (val == 4) ? 2 : val - 1; 4479431996fSJuerg Haefliger 4489431996fSJuerg Haefliger return (reg & 0x1f) | ((acz & 0x07) << 5); 4499431996fSJuerg Haefliger } 4509431996fSJuerg Haefliger 4519431996fSJuerg Haefliger /* PWM frequency */ 4529431996fSJuerg Haefliger static const int PWM_FREQ[] = {11, 15, 22, 29, 35, 44, 59, 88, 4539431996fSJuerg Haefliger 15000, 20000, 30000, 25000, 0, 0, 0, 0}; 4549431996fSJuerg Haefliger 4559431996fSJuerg Haefliger static inline int PWM_FREQ_FROM_REG(int reg) 4569431996fSJuerg Haefliger { 4579431996fSJuerg Haefliger return PWM_FREQ[reg & 0x0f]; 4589431996fSJuerg Haefliger } 4599431996fSJuerg Haefliger 4609431996fSJuerg Haefliger static int PWM_FREQ_TO_REG(int val, int reg) 4619431996fSJuerg Haefliger { 4629431996fSJuerg Haefliger int i; 4639431996fSJuerg Haefliger 4649431996fSJuerg Haefliger /* the first two cases are special - stupid chip design! */ 4659431996fSJuerg Haefliger if (val > 27500) { 4669431996fSJuerg Haefliger i = 10; 4679431996fSJuerg Haefliger } else if (val > 22500) { 4689431996fSJuerg Haefliger i = 11; 4699431996fSJuerg Haefliger } else { 4709431996fSJuerg Haefliger for (i = 9; i > 0; i--) { 4719431996fSJuerg Haefliger if (val > (PWM_FREQ[i] + PWM_FREQ[i - 1] + 1) / 2) { 4729431996fSJuerg Haefliger break; 4739431996fSJuerg Haefliger } 4749431996fSJuerg Haefliger } 4759431996fSJuerg Haefliger } 4769431996fSJuerg Haefliger 4779431996fSJuerg Haefliger return (reg & 0xf0) | i; 4789431996fSJuerg Haefliger } 4799431996fSJuerg Haefliger 4809431996fSJuerg Haefliger /* PWM ramp rate 4819431996fSJuerg Haefliger * Register layout: 4829431996fSJuerg Haefliger * reg[0] = [OFF3, OFF2, OFF1, RES, RR1-E, RR1-2, RR1-1, RR1-0] 4839431996fSJuerg Haefliger * reg[1] = [RR2-E, RR2-2, RR2-1, RR2-0, RR3-E, RR3-2, RR3-1, RR3-0] */ 4849431996fSJuerg Haefliger static const u8 PWM_RR[] = {206, 104, 69, 41, 26, 18, 10, 5}; 4859431996fSJuerg Haefliger 4869431996fSJuerg Haefliger static inline int PWM_RR_FROM_REG(int reg, int ix) 4879431996fSJuerg Haefliger { 4889431996fSJuerg Haefliger int rr = (ix == 1) ? reg >> 4 : reg; 4899431996fSJuerg Haefliger 4909431996fSJuerg Haefliger return (rr & 0x08) ? PWM_RR[rr & 0x07] : 0; 4919431996fSJuerg Haefliger } 4929431996fSJuerg Haefliger 4939431996fSJuerg Haefliger static int PWM_RR_TO_REG(int val, int ix, int reg) 4949431996fSJuerg Haefliger { 4959431996fSJuerg Haefliger int i; 4969431996fSJuerg Haefliger 4979431996fSJuerg Haefliger for (i = 0; i < 7; i++) { 4989431996fSJuerg Haefliger if (val > (PWM_RR[i] + PWM_RR[i + 1] + 1) / 2) { 4999431996fSJuerg Haefliger break; 5009431996fSJuerg Haefliger } 5019431996fSJuerg Haefliger } 5029431996fSJuerg Haefliger 5039431996fSJuerg Haefliger return (ix == 1) ? (reg & 0x8f) | (i << 4) : (reg & 0xf8) | i; 5049431996fSJuerg Haefliger } 5059431996fSJuerg Haefliger 5069431996fSJuerg Haefliger /* PWM ramp rate enable */ 5079431996fSJuerg Haefliger static inline int PWM_RR_EN_FROM_REG(int reg, int ix) 5089431996fSJuerg Haefliger { 5099431996fSJuerg Haefliger return PWM_RR_FROM_REG(reg, ix) ? 1 : 0; 5109431996fSJuerg Haefliger } 5119431996fSJuerg Haefliger 5129431996fSJuerg Haefliger static inline int PWM_RR_EN_TO_REG(int val, int ix, int reg) 5139431996fSJuerg Haefliger { 5149431996fSJuerg Haefliger int en = (ix == 1) ? 0x80 : 0x08; 5159431996fSJuerg Haefliger 5169431996fSJuerg Haefliger return val ? reg | en : reg & ~en; 5179431996fSJuerg Haefliger } 5189431996fSJuerg Haefliger 5199431996fSJuerg Haefliger /* PWM min/off 5209431996fSJuerg Haefliger * The PWM min/off bits are part of the PMW ramp rate register 0 (see above for 5219431996fSJuerg Haefliger * the register layout). */ 5229431996fSJuerg Haefliger static inline int PWM_OFF_FROM_REG(int reg, int ix) 5239431996fSJuerg Haefliger { 5249431996fSJuerg Haefliger return (reg >> (ix + 5)) & 0x01; 5259431996fSJuerg Haefliger } 5269431996fSJuerg Haefliger 5279431996fSJuerg Haefliger static inline int PWM_OFF_TO_REG(int val, int ix, int reg) 5289431996fSJuerg Haefliger { 5299431996fSJuerg Haefliger return (reg & ~(1 << (ix + 5))) | ((val & 0x01) << (ix + 5)); 5309431996fSJuerg Haefliger } 5319431996fSJuerg Haefliger 5329431996fSJuerg Haefliger /* --------------------------------------------------------------------- 5339431996fSJuerg Haefliger * Device I/O access 534e95c237dSJuerg Haefliger * 535e95c237dSJuerg Haefliger * ISA access is performed through an index/data register pair and needs to 536e95c237dSJuerg Haefliger * be protected by a mutex during runtime (not required for initialization). 537e95c237dSJuerg Haefliger * We use data->update_lock for this and need to ensure that we acquire it 538e95c237dSJuerg Haefliger * before calling dme1737_read or dme1737_write. 5399431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 5409431996fSJuerg Haefliger 541dbc2bc25SJean Delvare static u8 dme1737_read(const struct dme1737_data *data, u8 reg) 5429431996fSJuerg Haefliger { 543dbc2bc25SJean Delvare struct i2c_client *client = data->client; 544e95c237dSJuerg Haefliger s32 val; 545e95c237dSJuerg Haefliger 546dbc2bc25SJean Delvare if (client) { /* I2C device */ 547e95c237dSJuerg Haefliger val = i2c_smbus_read_byte_data(client, reg); 5489431996fSJuerg Haefliger 5499431996fSJuerg Haefliger if (val < 0) { 550e95c237dSJuerg Haefliger dev_warn(&client->dev, "Read from register " 551e95c237dSJuerg Haefliger "0x%02x failed! Please report to the driver " 552e95c237dSJuerg Haefliger "maintainer.\n", reg); 553e95c237dSJuerg Haefliger } 554e95c237dSJuerg Haefliger } else { /* ISA device */ 555dbc2bc25SJean Delvare outb(reg, data->addr); 556dbc2bc25SJean Delvare val = inb(data->addr + 1); 5579431996fSJuerg Haefliger } 5589431996fSJuerg Haefliger 5599431996fSJuerg Haefliger return val; 5609431996fSJuerg Haefliger } 5619431996fSJuerg Haefliger 562dbc2bc25SJean Delvare static s32 dme1737_write(const struct dme1737_data *data, u8 reg, u8 val) 5639431996fSJuerg Haefliger { 564dbc2bc25SJean Delvare struct i2c_client *client = data->client; 565e95c237dSJuerg Haefliger s32 res = 0; 566e95c237dSJuerg Haefliger 567dbc2bc25SJean Delvare if (client) { /* I2C device */ 568e95c237dSJuerg Haefliger res = i2c_smbus_write_byte_data(client, reg, val); 5699431996fSJuerg Haefliger 5709431996fSJuerg Haefliger if (res < 0) { 571e95c237dSJuerg Haefliger dev_warn(&client->dev, "Write to register " 572e95c237dSJuerg Haefliger "0x%02x failed! Please report to the driver " 573e95c237dSJuerg Haefliger "maintainer.\n", reg); 574e95c237dSJuerg Haefliger } 575e95c237dSJuerg Haefliger } else { /* ISA device */ 576dbc2bc25SJean Delvare outb(reg, data->addr); 577dbc2bc25SJean Delvare outb(val, data->addr + 1); 5789431996fSJuerg Haefliger } 5799431996fSJuerg Haefliger 5809431996fSJuerg Haefliger return res; 5819431996fSJuerg Haefliger } 5829431996fSJuerg Haefliger 5839431996fSJuerg Haefliger static struct dme1737_data *dme1737_update_device(struct device *dev) 5849431996fSJuerg Haefliger { 585b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 5869431996fSJuerg Haefliger int ix; 587d4b94e1fSJuerg Haefliger u8 lsb[6]; 5889431996fSJuerg Haefliger 5899431996fSJuerg Haefliger mutex_lock(&data->update_lock); 5909431996fSJuerg Haefliger 5919431996fSJuerg Haefliger /* Enable a Vbat monitoring cycle every 10 mins */ 5929431996fSJuerg Haefliger if (time_after(jiffies, data->last_vbat + 600 * HZ) || !data->valid) { 593dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_CONFIG, dme1737_read(data, 5949431996fSJuerg Haefliger DME1737_REG_CONFIG) | 0x10); 5959431996fSJuerg Haefliger data->last_vbat = jiffies; 5969431996fSJuerg Haefliger } 5979431996fSJuerg Haefliger 5989431996fSJuerg Haefliger /* Sample register contents every 1 sec */ 5999431996fSJuerg Haefliger if (time_after(jiffies, data->last_update + HZ) || !data->valid) { 600ea694431SJuerg Haefliger if (data->has_features & HAS_VID) { 601dbc2bc25SJean Delvare data->vid = dme1737_read(data, DME1737_REG_VID) & 602549edb83SJuerg Haefliger 0x3f; 603549edb83SJuerg Haefliger } 6049431996fSJuerg Haefliger 6059431996fSJuerg Haefliger /* In (voltage) registers */ 6069431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) { 6079431996fSJuerg Haefliger /* Voltage inputs are stored as 16 bit values even 6089431996fSJuerg Haefliger * though they have only 12 bits resolution. This is 6099431996fSJuerg Haefliger * to make it consistent with the temp inputs. */ 610d4b94e1fSJuerg Haefliger if (ix == 7 && !(data->has_features & HAS_IN7)) { 611d4b94e1fSJuerg Haefliger continue; 612d4b94e1fSJuerg Haefliger } 613dbc2bc25SJean Delvare data->in[ix] = dme1737_read(data, 6149431996fSJuerg Haefliger DME1737_REG_IN(ix)) << 8; 615dbc2bc25SJean Delvare data->in_min[ix] = dme1737_read(data, 6169431996fSJuerg Haefliger DME1737_REG_IN_MIN(ix)); 617dbc2bc25SJean Delvare data->in_max[ix] = dme1737_read(data, 6189431996fSJuerg Haefliger DME1737_REG_IN_MAX(ix)); 6199431996fSJuerg Haefliger } 6209431996fSJuerg Haefliger 6219431996fSJuerg Haefliger /* Temp registers */ 6229431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) { 6239431996fSJuerg Haefliger /* Temp inputs are stored as 16 bit values even 6249431996fSJuerg Haefliger * though they have only 12 bits resolution. This is 6259431996fSJuerg Haefliger * to take advantage of implicit conversions between 6269431996fSJuerg Haefliger * register values (2's complement) and temp values 6279431996fSJuerg Haefliger * (signed decimal). */ 628dbc2bc25SJean Delvare data->temp[ix] = dme1737_read(data, 6299431996fSJuerg Haefliger DME1737_REG_TEMP(ix)) << 8; 630dbc2bc25SJean Delvare data->temp_min[ix] = dme1737_read(data, 6319431996fSJuerg Haefliger DME1737_REG_TEMP_MIN(ix)); 632dbc2bc25SJean Delvare data->temp_max[ix] = dme1737_read(data, 6339431996fSJuerg Haefliger DME1737_REG_TEMP_MAX(ix)); 634ea694431SJuerg Haefliger if (data->has_features & HAS_TEMP_OFFSET) { 635dbc2bc25SJean Delvare data->temp_offset[ix] = dme1737_read(data, 6369431996fSJuerg Haefliger DME1737_REG_TEMP_OFFSET(ix)); 6379431996fSJuerg Haefliger } 638549edb83SJuerg Haefliger } 6399431996fSJuerg Haefliger 6409431996fSJuerg Haefliger /* In and temp LSB registers 6419431996fSJuerg Haefliger * The LSBs are latched when the MSBs are read, so the order in 6429431996fSJuerg Haefliger * which the registers are read (MSB first, then LSB) is 6439431996fSJuerg Haefliger * important! */ 6449431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(lsb); ix++) { 645d4b94e1fSJuerg Haefliger if (ix == 5 && !(data->has_features & HAS_IN7)) { 646d4b94e1fSJuerg Haefliger continue; 647d4b94e1fSJuerg Haefliger } 648dbc2bc25SJean Delvare lsb[ix] = dme1737_read(data, 6499431996fSJuerg Haefliger DME1737_REG_IN_TEMP_LSB(ix)); 6509431996fSJuerg Haefliger } 6519431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) { 652d4b94e1fSJuerg Haefliger if (ix == 7 && !(data->has_features & HAS_IN7)) { 653d4b94e1fSJuerg Haefliger continue; 654d4b94e1fSJuerg Haefliger } 6559431996fSJuerg Haefliger data->in[ix] |= (lsb[DME1737_REG_IN_LSB[ix]] << 6569431996fSJuerg Haefliger DME1737_REG_IN_LSB_SHL[ix]) & 0xf0; 6579431996fSJuerg Haefliger } 6589431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) { 6599431996fSJuerg Haefliger data->temp[ix] |= (lsb[DME1737_REG_TEMP_LSB[ix]] << 6609431996fSJuerg Haefliger DME1737_REG_TEMP_LSB_SHL[ix]) & 0xf0; 6619431996fSJuerg Haefliger } 6629431996fSJuerg Haefliger 6639431996fSJuerg Haefliger /* Fan registers */ 6649431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->fan); ix++) { 6659431996fSJuerg Haefliger /* Skip reading registers if optional fans are not 6669431996fSJuerg Haefliger * present */ 667ea694431SJuerg Haefliger if (!(data->has_features & HAS_FAN(ix))) { 6689431996fSJuerg Haefliger continue; 6699431996fSJuerg Haefliger } 670dbc2bc25SJean Delvare data->fan[ix] = dme1737_read(data, 6719431996fSJuerg Haefliger DME1737_REG_FAN(ix)); 672dbc2bc25SJean Delvare data->fan[ix] |= dme1737_read(data, 6739431996fSJuerg Haefliger DME1737_REG_FAN(ix) + 1) << 8; 674dbc2bc25SJean Delvare data->fan_min[ix] = dme1737_read(data, 6759431996fSJuerg Haefliger DME1737_REG_FAN_MIN(ix)); 676dbc2bc25SJean Delvare data->fan_min[ix] |= dme1737_read(data, 6779431996fSJuerg Haefliger DME1737_REG_FAN_MIN(ix) + 1) << 8; 678dbc2bc25SJean Delvare data->fan_opt[ix] = dme1737_read(data, 6799431996fSJuerg Haefliger DME1737_REG_FAN_OPT(ix)); 6809431996fSJuerg Haefliger /* fan_max exists only for fan[5-6] */ 6819431996fSJuerg Haefliger if (ix > 3) { 682dbc2bc25SJean Delvare data->fan_max[ix - 4] = dme1737_read(data, 6839431996fSJuerg Haefliger DME1737_REG_FAN_MAX(ix)); 6849431996fSJuerg Haefliger } 6859431996fSJuerg Haefliger } 6869431996fSJuerg Haefliger 6879431996fSJuerg Haefliger /* PWM registers */ 6889431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->pwm); ix++) { 6899431996fSJuerg Haefliger /* Skip reading registers if optional PWMs are not 6909431996fSJuerg Haefliger * present */ 691ea694431SJuerg Haefliger if (!(data->has_features & HAS_PWM(ix))) { 6929431996fSJuerg Haefliger continue; 6939431996fSJuerg Haefliger } 694dbc2bc25SJean Delvare data->pwm[ix] = dme1737_read(data, 6959431996fSJuerg Haefliger DME1737_REG_PWM(ix)); 696dbc2bc25SJean Delvare data->pwm_freq[ix] = dme1737_read(data, 6979431996fSJuerg Haefliger DME1737_REG_PWM_FREQ(ix)); 6989431996fSJuerg Haefliger /* pwm_config and pwm_min exist only for pwm[1-3] */ 6999431996fSJuerg Haefliger if (ix < 3) { 700dbc2bc25SJean Delvare data->pwm_config[ix] = dme1737_read(data, 7019431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 702dbc2bc25SJean Delvare data->pwm_min[ix] = dme1737_read(data, 7039431996fSJuerg Haefliger DME1737_REG_PWM_MIN(ix)); 7049431996fSJuerg Haefliger } 7059431996fSJuerg Haefliger } 7069431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->pwm_rr); ix++) { 707dbc2bc25SJean Delvare data->pwm_rr[ix] = dme1737_read(data, 7089431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix)); 7099431996fSJuerg Haefliger } 7109431996fSJuerg Haefliger 7119431996fSJuerg Haefliger /* Thermal zone registers */ 7129431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->zone_low); ix++) { 713ea694431SJuerg Haefliger /* Skip reading registers if zone3 is not present */ 714ea694431SJuerg Haefliger if ((ix == 2) && !(data->has_features & HAS_ZONE3)) { 715ea694431SJuerg Haefliger continue; 716ea694431SJuerg Haefliger } 717ea694431SJuerg Haefliger /* sch5127 zone2 registers are special */ 718ea694431SJuerg Haefliger if ((ix == 1) && (data->type == sch5127)) { 719ea694431SJuerg Haefliger data->zone_low[1] = dme1737_read(data, 720ea694431SJuerg Haefliger DME1737_REG_ZONE_LOW(2)); 721ea694431SJuerg Haefliger data->zone_abs[1] = dme1737_read(data, 722ea694431SJuerg Haefliger DME1737_REG_ZONE_ABS(2)); 723ea694431SJuerg Haefliger } else { 724dbc2bc25SJean Delvare data->zone_low[ix] = dme1737_read(data, 7259431996fSJuerg Haefliger DME1737_REG_ZONE_LOW(ix)); 726dbc2bc25SJean Delvare data->zone_abs[ix] = dme1737_read(data, 7279431996fSJuerg Haefliger DME1737_REG_ZONE_ABS(ix)); 7289431996fSJuerg Haefliger } 729ea694431SJuerg Haefliger } 730ea694431SJuerg Haefliger if (data->has_features & HAS_ZONE_HYST) { 7319431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) { 732dbc2bc25SJean Delvare data->zone_hyst[ix] = dme1737_read(data, 7339431996fSJuerg Haefliger DME1737_REG_ZONE_HYST(ix)); 7349431996fSJuerg Haefliger } 735549edb83SJuerg Haefliger } 7369431996fSJuerg Haefliger 7379431996fSJuerg Haefliger /* Alarm registers */ 738dbc2bc25SJean Delvare data->alarms = dme1737_read(data, 7399431996fSJuerg Haefliger DME1737_REG_ALARM1); 7409431996fSJuerg Haefliger /* Bit 7 tells us if the other alarm registers are non-zero and 7419431996fSJuerg Haefliger * therefore also need to be read */ 7429431996fSJuerg Haefliger if (data->alarms & 0x80) { 743dbc2bc25SJean Delvare data->alarms |= dme1737_read(data, 7449431996fSJuerg Haefliger DME1737_REG_ALARM2) << 8; 745dbc2bc25SJean Delvare data->alarms |= dme1737_read(data, 7469431996fSJuerg Haefliger DME1737_REG_ALARM3) << 16; 7479431996fSJuerg Haefliger } 7489431996fSJuerg Haefliger 749e95c237dSJuerg Haefliger /* The ISA chips require explicit clearing of alarm bits. 750e95c237dSJuerg Haefliger * Don't worry, an alarm will come back if the condition 751e95c237dSJuerg Haefliger * that causes it still exists */ 752dbc2bc25SJean Delvare if (!data->client) { 753e95c237dSJuerg Haefliger if (data->alarms & 0xff0000) { 754dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_ALARM3, 755e95c237dSJuerg Haefliger 0xff); 756e95c237dSJuerg Haefliger } 757e95c237dSJuerg Haefliger if (data->alarms & 0xff00) { 758dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_ALARM2, 759e95c237dSJuerg Haefliger 0xff); 760e95c237dSJuerg Haefliger } 761e95c237dSJuerg Haefliger if (data->alarms & 0xff) { 762dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_ALARM1, 763e95c237dSJuerg Haefliger 0xff); 764e95c237dSJuerg Haefliger } 765e95c237dSJuerg Haefliger } 766e95c237dSJuerg Haefliger 7679431996fSJuerg Haefliger data->last_update = jiffies; 7689431996fSJuerg Haefliger data->valid = 1; 7699431996fSJuerg Haefliger } 7709431996fSJuerg Haefliger 7719431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 7729431996fSJuerg Haefliger 7739431996fSJuerg Haefliger return data; 7749431996fSJuerg Haefliger } 7759431996fSJuerg Haefliger 7769431996fSJuerg Haefliger /* --------------------------------------------------------------------- 7779431996fSJuerg Haefliger * Voltage sysfs attributes 778d4b94e1fSJuerg Haefliger * ix = [0-7] 7799431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 7809431996fSJuerg Haefliger 7819431996fSJuerg Haefliger #define SYS_IN_INPUT 0 7829431996fSJuerg Haefliger #define SYS_IN_MIN 1 7839431996fSJuerg Haefliger #define SYS_IN_MAX 2 7849431996fSJuerg Haefliger #define SYS_IN_ALARM 3 7859431996fSJuerg Haefliger 7869431996fSJuerg Haefliger static ssize_t show_in(struct device *dev, struct device_attribute *attr, 7879431996fSJuerg Haefliger char *buf) 7889431996fSJuerg Haefliger { 7899431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 7909431996fSJuerg Haefliger struct sensor_device_attribute_2 7919431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 7929431996fSJuerg Haefliger int ix = sensor_attr_2->index; 7939431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 7949431996fSJuerg Haefliger int res; 7959431996fSJuerg Haefliger 7969431996fSJuerg Haefliger switch (fn) { 7979431996fSJuerg Haefliger case SYS_IN_INPUT: 798549edb83SJuerg Haefliger res = IN_FROM_REG(data->in[ix], data->in_nominal[ix], 16); 7999431996fSJuerg Haefliger break; 8009431996fSJuerg Haefliger case SYS_IN_MIN: 801549edb83SJuerg Haefliger res = IN_FROM_REG(data->in_min[ix], data->in_nominal[ix], 8); 8029431996fSJuerg Haefliger break; 8039431996fSJuerg Haefliger case SYS_IN_MAX: 804549edb83SJuerg Haefliger res = IN_FROM_REG(data->in_max[ix], data->in_nominal[ix], 8); 8059431996fSJuerg Haefliger break; 8069431996fSJuerg Haefliger case SYS_IN_ALARM: 8079431996fSJuerg Haefliger res = (data->alarms >> DME1737_BIT_ALARM_IN[ix]) & 0x01; 8089431996fSJuerg Haefliger break; 8099431996fSJuerg Haefliger default: 8109431996fSJuerg Haefliger res = 0; 811b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 8129431996fSJuerg Haefliger } 8139431996fSJuerg Haefliger 8149431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 8159431996fSJuerg Haefliger } 8169431996fSJuerg Haefliger 8179431996fSJuerg Haefliger static ssize_t set_in(struct device *dev, struct device_attribute *attr, 8189431996fSJuerg Haefliger const char *buf, size_t count) 8199431996fSJuerg Haefliger { 820b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 8219431996fSJuerg Haefliger struct sensor_device_attribute_2 8229431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 8239431996fSJuerg Haefliger int ix = sensor_attr_2->index; 8249431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 8259431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 8269431996fSJuerg Haefliger 8279431996fSJuerg Haefliger mutex_lock(&data->update_lock); 8289431996fSJuerg Haefliger switch (fn) { 8299431996fSJuerg Haefliger case SYS_IN_MIN: 830549edb83SJuerg Haefliger data->in_min[ix] = IN_TO_REG(val, data->in_nominal[ix]); 831dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_IN_MIN(ix), 8329431996fSJuerg Haefliger data->in_min[ix]); 8339431996fSJuerg Haefliger break; 8349431996fSJuerg Haefliger case SYS_IN_MAX: 835549edb83SJuerg Haefliger data->in_max[ix] = IN_TO_REG(val, data->in_nominal[ix]); 836dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_IN_MAX(ix), 8379431996fSJuerg Haefliger data->in_max[ix]); 8389431996fSJuerg Haefliger break; 8399431996fSJuerg Haefliger default: 840b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 8419431996fSJuerg Haefliger } 8429431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 8439431996fSJuerg Haefliger 8449431996fSJuerg Haefliger return count; 8459431996fSJuerg Haefliger } 8469431996fSJuerg Haefliger 8479431996fSJuerg Haefliger /* --------------------------------------------------------------------- 8489431996fSJuerg Haefliger * Temperature sysfs attributes 8499431996fSJuerg Haefliger * ix = [0-2] 8509431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 8519431996fSJuerg Haefliger 8529431996fSJuerg Haefliger #define SYS_TEMP_INPUT 0 8539431996fSJuerg Haefliger #define SYS_TEMP_MIN 1 8549431996fSJuerg Haefliger #define SYS_TEMP_MAX 2 8559431996fSJuerg Haefliger #define SYS_TEMP_OFFSET 3 8569431996fSJuerg Haefliger #define SYS_TEMP_ALARM 4 8579431996fSJuerg Haefliger #define SYS_TEMP_FAULT 5 8589431996fSJuerg Haefliger 8599431996fSJuerg Haefliger static ssize_t show_temp(struct device *dev, struct device_attribute *attr, 8609431996fSJuerg Haefliger char *buf) 8619431996fSJuerg Haefliger { 8629431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 8639431996fSJuerg Haefliger struct sensor_device_attribute_2 8649431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 8659431996fSJuerg Haefliger int ix = sensor_attr_2->index; 8669431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 8679431996fSJuerg Haefliger int res; 8689431996fSJuerg Haefliger 8699431996fSJuerg Haefliger switch (fn) { 8709431996fSJuerg Haefliger case SYS_TEMP_INPUT: 8719431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp[ix], 16); 8729431996fSJuerg Haefliger break; 8739431996fSJuerg Haefliger case SYS_TEMP_MIN: 8749431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp_min[ix], 8); 8759431996fSJuerg Haefliger break; 8769431996fSJuerg Haefliger case SYS_TEMP_MAX: 8779431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp_max[ix], 8); 8789431996fSJuerg Haefliger break; 8799431996fSJuerg Haefliger case SYS_TEMP_OFFSET: 8809431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp_offset[ix], 8); 8819431996fSJuerg Haefliger break; 8829431996fSJuerg Haefliger case SYS_TEMP_ALARM: 8839431996fSJuerg Haefliger res = (data->alarms >> DME1737_BIT_ALARM_TEMP[ix]) & 0x01; 8849431996fSJuerg Haefliger break; 8859431996fSJuerg Haefliger case SYS_TEMP_FAULT: 886c0f31403SJuerg Haefliger res = (((u16)data->temp[ix] & 0xff00) == 0x8000); 8879431996fSJuerg Haefliger break; 8889431996fSJuerg Haefliger default: 8899431996fSJuerg Haefliger res = 0; 890b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 8919431996fSJuerg Haefliger } 8929431996fSJuerg Haefliger 8939431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 8949431996fSJuerg Haefliger } 8959431996fSJuerg Haefliger 8969431996fSJuerg Haefliger static ssize_t set_temp(struct device *dev, struct device_attribute *attr, 8979431996fSJuerg Haefliger const char *buf, size_t count) 8989431996fSJuerg Haefliger { 899b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 9009431996fSJuerg Haefliger struct sensor_device_attribute_2 9019431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 9029431996fSJuerg Haefliger int ix = sensor_attr_2->index; 9039431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 9049431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 9059431996fSJuerg Haefliger 9069431996fSJuerg Haefliger mutex_lock(&data->update_lock); 9079431996fSJuerg Haefliger switch (fn) { 9089431996fSJuerg Haefliger case SYS_TEMP_MIN: 9099431996fSJuerg Haefliger data->temp_min[ix] = TEMP_TO_REG(val); 910dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_TEMP_MIN(ix), 9119431996fSJuerg Haefliger data->temp_min[ix]); 9129431996fSJuerg Haefliger break; 9139431996fSJuerg Haefliger case SYS_TEMP_MAX: 9149431996fSJuerg Haefliger data->temp_max[ix] = TEMP_TO_REG(val); 915dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_TEMP_MAX(ix), 9169431996fSJuerg Haefliger data->temp_max[ix]); 9179431996fSJuerg Haefliger break; 9189431996fSJuerg Haefliger case SYS_TEMP_OFFSET: 9199431996fSJuerg Haefliger data->temp_offset[ix] = TEMP_TO_REG(val); 920dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_TEMP_OFFSET(ix), 9219431996fSJuerg Haefliger data->temp_offset[ix]); 9229431996fSJuerg Haefliger break; 9239431996fSJuerg Haefliger default: 924b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 9259431996fSJuerg Haefliger } 9269431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 9279431996fSJuerg Haefliger 9289431996fSJuerg Haefliger return count; 9299431996fSJuerg Haefliger } 9309431996fSJuerg Haefliger 9319431996fSJuerg Haefliger /* --------------------------------------------------------------------- 9329431996fSJuerg Haefliger * Zone sysfs attributes 9339431996fSJuerg Haefliger * ix = [0-2] 9349431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 9359431996fSJuerg Haefliger 9369431996fSJuerg Haefliger #define SYS_ZONE_AUTO_CHANNELS_TEMP 0 9379431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT1_TEMP_HYST 1 9389431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT1_TEMP 2 9399431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT2_TEMP 3 9409431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT3_TEMP 4 9419431996fSJuerg Haefliger 9429431996fSJuerg Haefliger static ssize_t show_zone(struct device *dev, struct device_attribute *attr, 9439431996fSJuerg Haefliger char *buf) 9449431996fSJuerg Haefliger { 9459431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 9469431996fSJuerg Haefliger struct sensor_device_attribute_2 9479431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 9489431996fSJuerg Haefliger int ix = sensor_attr_2->index; 9499431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 9509431996fSJuerg Haefliger int res; 9519431996fSJuerg Haefliger 9529431996fSJuerg Haefliger switch (fn) { 9539431996fSJuerg Haefliger case SYS_ZONE_AUTO_CHANNELS_TEMP: 9549431996fSJuerg Haefliger /* check config2 for non-standard temp-to-zone mapping */ 9559431996fSJuerg Haefliger if ((ix == 1) && (data->config2 & 0x02)) { 9569431996fSJuerg Haefliger res = 4; 9579431996fSJuerg Haefliger } else { 9589431996fSJuerg Haefliger res = 1 << ix; 9599431996fSJuerg Haefliger } 9609431996fSJuerg Haefliger break; 9619431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP_HYST: 9629431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_low[ix], 8) - 9639431996fSJuerg Haefliger TEMP_HYST_FROM_REG(data->zone_hyst[ix == 2], ix); 9649431996fSJuerg Haefliger break; 9659431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP: 9669431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_low[ix], 8); 9679431996fSJuerg Haefliger break; 9689431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT2_TEMP: 9699431996fSJuerg Haefliger /* pwm_freq holds the temp range bits in the upper nibble */ 9709431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_low[ix], 8) + 9719431996fSJuerg Haefliger TEMP_RANGE_FROM_REG(data->pwm_freq[ix]); 9729431996fSJuerg Haefliger break; 9739431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT3_TEMP: 9749431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_abs[ix], 8); 9759431996fSJuerg Haefliger break; 9769431996fSJuerg Haefliger default: 9779431996fSJuerg Haefliger res = 0; 978b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 9799431996fSJuerg Haefliger } 9809431996fSJuerg Haefliger 9819431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 9829431996fSJuerg Haefliger } 9839431996fSJuerg Haefliger 9849431996fSJuerg Haefliger static ssize_t set_zone(struct device *dev, struct device_attribute *attr, 9859431996fSJuerg Haefliger const char *buf, size_t count) 9869431996fSJuerg Haefliger { 987b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 9889431996fSJuerg Haefliger struct sensor_device_attribute_2 9899431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 9909431996fSJuerg Haefliger int ix = sensor_attr_2->index; 9919431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 9929431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 9939431996fSJuerg Haefliger 9949431996fSJuerg Haefliger mutex_lock(&data->update_lock); 9959431996fSJuerg Haefliger switch (fn) { 9969431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP_HYST: 9979431996fSJuerg Haefliger /* Refresh the cache */ 998dbc2bc25SJean Delvare data->zone_low[ix] = dme1737_read(data, 9999431996fSJuerg Haefliger DME1737_REG_ZONE_LOW(ix)); 10009431996fSJuerg Haefliger /* Modify the temp hyst value */ 10019431996fSJuerg Haefliger data->zone_hyst[ix == 2] = TEMP_HYST_TO_REG( 10029431996fSJuerg Haefliger TEMP_FROM_REG(data->zone_low[ix], 8) - 1003dbc2bc25SJean Delvare val, ix, dme1737_read(data, 10049431996fSJuerg Haefliger DME1737_REG_ZONE_HYST(ix == 2))); 1005dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_ZONE_HYST(ix == 2), 10069431996fSJuerg Haefliger data->zone_hyst[ix == 2]); 10079431996fSJuerg Haefliger break; 10089431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP: 10099431996fSJuerg Haefliger data->zone_low[ix] = TEMP_TO_REG(val); 1010dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_ZONE_LOW(ix), 10119431996fSJuerg Haefliger data->zone_low[ix]); 10129431996fSJuerg Haefliger break; 10139431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT2_TEMP: 10149431996fSJuerg Haefliger /* Refresh the cache */ 1015dbc2bc25SJean Delvare data->zone_low[ix] = dme1737_read(data, 10169431996fSJuerg Haefliger DME1737_REG_ZONE_LOW(ix)); 10179431996fSJuerg Haefliger /* Modify the temp range value (which is stored in the upper 10189431996fSJuerg Haefliger * nibble of the pwm_freq register) */ 10199431996fSJuerg Haefliger data->pwm_freq[ix] = TEMP_RANGE_TO_REG(val - 10209431996fSJuerg Haefliger TEMP_FROM_REG(data->zone_low[ix], 8), 1021dbc2bc25SJean Delvare dme1737_read(data, 10229431996fSJuerg Haefliger DME1737_REG_PWM_FREQ(ix))); 1023dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_FREQ(ix), 10249431996fSJuerg Haefliger data->pwm_freq[ix]); 10259431996fSJuerg Haefliger break; 10269431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT3_TEMP: 10279431996fSJuerg Haefliger data->zone_abs[ix] = TEMP_TO_REG(val); 1028dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_ZONE_ABS(ix), 10299431996fSJuerg Haefliger data->zone_abs[ix]); 10309431996fSJuerg Haefliger break; 10319431996fSJuerg Haefliger default: 1032b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 10339431996fSJuerg Haefliger } 10349431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 10359431996fSJuerg Haefliger 10369431996fSJuerg Haefliger return count; 10379431996fSJuerg Haefliger } 10389431996fSJuerg Haefliger 10399431996fSJuerg Haefliger /* --------------------------------------------------------------------- 10409431996fSJuerg Haefliger * Fan sysfs attributes 10419431996fSJuerg Haefliger * ix = [0-5] 10429431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 10439431996fSJuerg Haefliger 10449431996fSJuerg Haefliger #define SYS_FAN_INPUT 0 10459431996fSJuerg Haefliger #define SYS_FAN_MIN 1 10469431996fSJuerg Haefliger #define SYS_FAN_MAX 2 10479431996fSJuerg Haefliger #define SYS_FAN_ALARM 3 10489431996fSJuerg Haefliger #define SYS_FAN_TYPE 4 10499431996fSJuerg Haefliger 10509431996fSJuerg Haefliger static ssize_t show_fan(struct device *dev, struct device_attribute *attr, 10519431996fSJuerg Haefliger char *buf) 10529431996fSJuerg Haefliger { 10539431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 10549431996fSJuerg Haefliger struct sensor_device_attribute_2 10559431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 10569431996fSJuerg Haefliger int ix = sensor_attr_2->index; 10579431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 10589431996fSJuerg Haefliger int res; 10599431996fSJuerg Haefliger 10609431996fSJuerg Haefliger switch (fn) { 10619431996fSJuerg Haefliger case SYS_FAN_INPUT: 10629431996fSJuerg Haefliger res = FAN_FROM_REG(data->fan[ix], 10639431996fSJuerg Haefliger ix < 4 ? 0 : 10649431996fSJuerg Haefliger FAN_TPC_FROM_REG(data->fan_opt[ix])); 10659431996fSJuerg Haefliger break; 10669431996fSJuerg Haefliger case SYS_FAN_MIN: 10679431996fSJuerg Haefliger res = FAN_FROM_REG(data->fan_min[ix], 10689431996fSJuerg Haefliger ix < 4 ? 0 : 10699431996fSJuerg Haefliger FAN_TPC_FROM_REG(data->fan_opt[ix])); 10709431996fSJuerg Haefliger break; 10719431996fSJuerg Haefliger case SYS_FAN_MAX: 10729431996fSJuerg Haefliger /* only valid for fan[5-6] */ 10739431996fSJuerg Haefliger res = FAN_MAX_FROM_REG(data->fan_max[ix - 4]); 10749431996fSJuerg Haefliger break; 10759431996fSJuerg Haefliger case SYS_FAN_ALARM: 10769431996fSJuerg Haefliger res = (data->alarms >> DME1737_BIT_ALARM_FAN[ix]) & 0x01; 10779431996fSJuerg Haefliger break; 10789431996fSJuerg Haefliger case SYS_FAN_TYPE: 10799431996fSJuerg Haefliger /* only valid for fan[1-4] */ 10809431996fSJuerg Haefliger res = FAN_TYPE_FROM_REG(data->fan_opt[ix]); 10819431996fSJuerg Haefliger break; 10829431996fSJuerg Haefliger default: 10839431996fSJuerg Haefliger res = 0; 1084b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 10859431996fSJuerg Haefliger } 10869431996fSJuerg Haefliger 10879431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 10889431996fSJuerg Haefliger } 10899431996fSJuerg Haefliger 10909431996fSJuerg Haefliger static ssize_t set_fan(struct device *dev, struct device_attribute *attr, 10919431996fSJuerg Haefliger const char *buf, size_t count) 10929431996fSJuerg Haefliger { 1093b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 10949431996fSJuerg Haefliger struct sensor_device_attribute_2 10959431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 10969431996fSJuerg Haefliger int ix = sensor_attr_2->index; 10979431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 10989431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 10999431996fSJuerg Haefliger 11009431996fSJuerg Haefliger mutex_lock(&data->update_lock); 11019431996fSJuerg Haefliger switch (fn) { 11029431996fSJuerg Haefliger case SYS_FAN_MIN: 11039431996fSJuerg Haefliger if (ix < 4) { 11049431996fSJuerg Haefliger data->fan_min[ix] = FAN_TO_REG(val, 0); 11059431996fSJuerg Haefliger } else { 11069431996fSJuerg Haefliger /* Refresh the cache */ 1107dbc2bc25SJean Delvare data->fan_opt[ix] = dme1737_read(data, 11089431996fSJuerg Haefliger DME1737_REG_FAN_OPT(ix)); 11099431996fSJuerg Haefliger /* Modify the fan min value */ 11109431996fSJuerg Haefliger data->fan_min[ix] = FAN_TO_REG(val, 11119431996fSJuerg Haefliger FAN_TPC_FROM_REG(data->fan_opt[ix])); 11129431996fSJuerg Haefliger } 1113dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_FAN_MIN(ix), 11149431996fSJuerg Haefliger data->fan_min[ix] & 0xff); 1115dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_FAN_MIN(ix) + 1, 11169431996fSJuerg Haefliger data->fan_min[ix] >> 8); 11179431996fSJuerg Haefliger break; 11189431996fSJuerg Haefliger case SYS_FAN_MAX: 11199431996fSJuerg Haefliger /* Only valid for fan[5-6] */ 11209431996fSJuerg Haefliger data->fan_max[ix - 4] = FAN_MAX_TO_REG(val); 1121dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_FAN_MAX(ix), 11229431996fSJuerg Haefliger data->fan_max[ix - 4]); 11239431996fSJuerg Haefliger break; 11249431996fSJuerg Haefliger case SYS_FAN_TYPE: 11259431996fSJuerg Haefliger /* Only valid for fan[1-4] */ 11269431996fSJuerg Haefliger if (!(val == 1 || val == 2 || val == 4)) { 11279431996fSJuerg Haefliger count = -EINVAL; 1128e95c237dSJuerg Haefliger dev_warn(dev, "Fan type value %ld not " 11299431996fSJuerg Haefliger "supported. Choose one of 1, 2, or 4.\n", 11309431996fSJuerg Haefliger val); 11319431996fSJuerg Haefliger goto exit; 11329431996fSJuerg Haefliger } 1133dbc2bc25SJean Delvare data->fan_opt[ix] = FAN_TYPE_TO_REG(val, dme1737_read(data, 11349431996fSJuerg Haefliger DME1737_REG_FAN_OPT(ix))); 1135dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_FAN_OPT(ix), 11369431996fSJuerg Haefliger data->fan_opt[ix]); 11379431996fSJuerg Haefliger break; 11389431996fSJuerg Haefliger default: 1139b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 11409431996fSJuerg Haefliger } 11419431996fSJuerg Haefliger exit: 11429431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 11439431996fSJuerg Haefliger 11449431996fSJuerg Haefliger return count; 11459431996fSJuerg Haefliger } 11469431996fSJuerg Haefliger 11479431996fSJuerg Haefliger /* --------------------------------------------------------------------- 11489431996fSJuerg Haefliger * PWM sysfs attributes 11499431996fSJuerg Haefliger * ix = [0-4] 11509431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 11519431996fSJuerg Haefliger 11529431996fSJuerg Haefliger #define SYS_PWM 0 11539431996fSJuerg Haefliger #define SYS_PWM_FREQ 1 11549431996fSJuerg Haefliger #define SYS_PWM_ENABLE 2 11559431996fSJuerg Haefliger #define SYS_PWM_RAMP_RATE 3 11569431996fSJuerg Haefliger #define SYS_PWM_AUTO_CHANNELS_ZONE 4 11579431996fSJuerg Haefliger #define SYS_PWM_AUTO_PWM_MIN 5 11589431996fSJuerg Haefliger #define SYS_PWM_AUTO_POINT1_PWM 6 11599431996fSJuerg Haefliger #define SYS_PWM_AUTO_POINT2_PWM 7 11609431996fSJuerg Haefliger 11619431996fSJuerg Haefliger static ssize_t show_pwm(struct device *dev, struct device_attribute *attr, 11629431996fSJuerg Haefliger char *buf) 11639431996fSJuerg Haefliger { 11649431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 11659431996fSJuerg Haefliger struct sensor_device_attribute_2 11669431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 11679431996fSJuerg Haefliger int ix = sensor_attr_2->index; 11689431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 11699431996fSJuerg Haefliger int res; 11709431996fSJuerg Haefliger 11719431996fSJuerg Haefliger switch (fn) { 11729431996fSJuerg Haefliger case SYS_PWM: 11739431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 0) { 11749431996fSJuerg Haefliger res = 255; 11759431996fSJuerg Haefliger } else { 11769431996fSJuerg Haefliger res = data->pwm[ix]; 11779431996fSJuerg Haefliger } 11789431996fSJuerg Haefliger break; 11799431996fSJuerg Haefliger case SYS_PWM_FREQ: 11809431996fSJuerg Haefliger res = PWM_FREQ_FROM_REG(data->pwm_freq[ix]); 11819431996fSJuerg Haefliger break; 11829431996fSJuerg Haefliger case SYS_PWM_ENABLE: 1183912e837aSRoel Kluin if (ix >= 3) { 11849431996fSJuerg Haefliger res = 1; /* pwm[5-6] hard-wired to manual mode */ 11859431996fSJuerg Haefliger } else { 11869431996fSJuerg Haefliger res = PWM_EN_FROM_REG(data->pwm_config[ix]); 11879431996fSJuerg Haefliger } 11889431996fSJuerg Haefliger break; 11899431996fSJuerg Haefliger case SYS_PWM_RAMP_RATE: 11909431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 11919431996fSJuerg Haefliger res = PWM_RR_FROM_REG(data->pwm_rr[ix > 0], ix); 11929431996fSJuerg Haefliger break; 11939431996fSJuerg Haefliger case SYS_PWM_AUTO_CHANNELS_ZONE: 11949431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 11959431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 11969431996fSJuerg Haefliger res = PWM_ACZ_FROM_REG(data->pwm_config[ix]); 11979431996fSJuerg Haefliger } else { 11989431996fSJuerg Haefliger res = data->pwm_acz[ix]; 11999431996fSJuerg Haefliger } 12009431996fSJuerg Haefliger break; 12019431996fSJuerg Haefliger case SYS_PWM_AUTO_PWM_MIN: 12029431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 12039431996fSJuerg Haefliger if (PWM_OFF_FROM_REG(data->pwm_rr[0], ix)) { 12049431996fSJuerg Haefliger res = data->pwm_min[ix]; 12059431996fSJuerg Haefliger } else { 12069431996fSJuerg Haefliger res = 0; 12079431996fSJuerg Haefliger } 12089431996fSJuerg Haefliger break; 12099431996fSJuerg Haefliger case SYS_PWM_AUTO_POINT1_PWM: 12109431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 12119431996fSJuerg Haefliger res = data->pwm_min[ix]; 12129431996fSJuerg Haefliger break; 12139431996fSJuerg Haefliger case SYS_PWM_AUTO_POINT2_PWM: 12149431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 12159431996fSJuerg Haefliger res = 255; /* hard-wired */ 12169431996fSJuerg Haefliger break; 12179431996fSJuerg Haefliger default: 12189431996fSJuerg Haefliger res = 0; 1219b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 12209431996fSJuerg Haefliger } 12219431996fSJuerg Haefliger 12229431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 12239431996fSJuerg Haefliger } 12249431996fSJuerg Haefliger 122573ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm_chmod_attr[]; 1226b237eb25SJuerg Haefliger static void dme1737_chmod_file(struct device*, struct attribute*, mode_t); 12279431996fSJuerg Haefliger 12289431996fSJuerg Haefliger static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 12299431996fSJuerg Haefliger const char *buf, size_t count) 12309431996fSJuerg Haefliger { 1231b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 12329431996fSJuerg Haefliger struct sensor_device_attribute_2 12339431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 12349431996fSJuerg Haefliger int ix = sensor_attr_2->index; 12359431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 12369431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 12379431996fSJuerg Haefliger 12389431996fSJuerg Haefliger mutex_lock(&data->update_lock); 12399431996fSJuerg Haefliger switch (fn) { 12409431996fSJuerg Haefliger case SYS_PWM: 12419431996fSJuerg Haefliger data->pwm[ix] = SENSORS_LIMIT(val, 0, 255); 1242dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM(ix), data->pwm[ix]); 12439431996fSJuerg Haefliger break; 12449431996fSJuerg Haefliger case SYS_PWM_FREQ: 1245dbc2bc25SJean Delvare data->pwm_freq[ix] = PWM_FREQ_TO_REG(val, dme1737_read(data, 12469431996fSJuerg Haefliger DME1737_REG_PWM_FREQ(ix))); 1247dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_FREQ(ix), 12489431996fSJuerg Haefliger data->pwm_freq[ix]); 12499431996fSJuerg Haefliger break; 12509431996fSJuerg Haefliger case SYS_PWM_ENABLE: 12519431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 12529431996fSJuerg Haefliger if (val < 0 || val > 2) { 12539431996fSJuerg Haefliger count = -EINVAL; 1254e95c237dSJuerg Haefliger dev_warn(dev, "PWM enable %ld not " 12559431996fSJuerg Haefliger "supported. Choose one of 0, 1, or 2.\n", 12569431996fSJuerg Haefliger val); 12579431996fSJuerg Haefliger goto exit; 12589431996fSJuerg Haefliger } 12599431996fSJuerg Haefliger /* Refresh the cache */ 1260dbc2bc25SJean Delvare data->pwm_config[ix] = dme1737_read(data, 12619431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 12629431996fSJuerg Haefliger if (val == PWM_EN_FROM_REG(data->pwm_config[ix])) { 12639431996fSJuerg Haefliger /* Bail out if no change */ 12649431996fSJuerg Haefliger goto exit; 12659431996fSJuerg Haefliger } 12669431996fSJuerg Haefliger /* Do some housekeeping if we are currently in auto mode */ 12679431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 12689431996fSJuerg Haefliger /* Save the current zone channel assignment */ 12699431996fSJuerg Haefliger data->pwm_acz[ix] = PWM_ACZ_FROM_REG( 12709431996fSJuerg Haefliger data->pwm_config[ix]); 12719431996fSJuerg Haefliger /* Save the current ramp rate state and disable it */ 1272dbc2bc25SJean Delvare data->pwm_rr[ix > 0] = dme1737_read(data, 12739431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0)); 12749431996fSJuerg Haefliger data->pwm_rr_en &= ~(1 << ix); 12759431996fSJuerg Haefliger if (PWM_RR_EN_FROM_REG(data->pwm_rr[ix > 0], ix)) { 12769431996fSJuerg Haefliger data->pwm_rr_en |= (1 << ix); 12779431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(0, ix, 12789431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 1279dbc2bc25SJean Delvare dme1737_write(data, 12809431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0), 12819431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 12829431996fSJuerg Haefliger } 12839431996fSJuerg Haefliger } 12849431996fSJuerg Haefliger /* Set the new PWM mode */ 12859431996fSJuerg Haefliger switch (val) { 12869431996fSJuerg Haefliger case 0: 12879431996fSJuerg Haefliger /* Change permissions of pwm[ix] to read-only */ 128873ce48f6SJuerg Haefliger dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix], 12899431996fSJuerg Haefliger S_IRUGO); 12909431996fSJuerg Haefliger /* Turn fan fully on */ 12919431996fSJuerg Haefliger data->pwm_config[ix] = PWM_EN_TO_REG(0, 12929431996fSJuerg Haefliger data->pwm_config[ix]); 1293dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_CONFIG(ix), 12949431996fSJuerg Haefliger data->pwm_config[ix]); 12959431996fSJuerg Haefliger break; 12969431996fSJuerg Haefliger case 1: 12979431996fSJuerg Haefliger /* Turn on manual mode */ 12989431996fSJuerg Haefliger data->pwm_config[ix] = PWM_EN_TO_REG(1, 12999431996fSJuerg Haefliger data->pwm_config[ix]); 1300dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_CONFIG(ix), 13019431996fSJuerg Haefliger data->pwm_config[ix]); 13029431996fSJuerg Haefliger /* Change permissions of pwm[ix] to read-writeable */ 130373ce48f6SJuerg Haefliger dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix], 13049431996fSJuerg Haefliger S_IRUGO | S_IWUSR); 13059431996fSJuerg Haefliger break; 13069431996fSJuerg Haefliger case 2: 13079431996fSJuerg Haefliger /* Change permissions of pwm[ix] to read-only */ 130873ce48f6SJuerg Haefliger dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix], 13099431996fSJuerg Haefliger S_IRUGO); 13109431996fSJuerg Haefliger /* Turn on auto mode using the saved zone channel 13119431996fSJuerg Haefliger * assignment */ 13129431996fSJuerg Haefliger data->pwm_config[ix] = PWM_ACZ_TO_REG( 13139431996fSJuerg Haefliger data->pwm_acz[ix], 13149431996fSJuerg Haefliger data->pwm_config[ix]); 1315dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_CONFIG(ix), 13169431996fSJuerg Haefliger data->pwm_config[ix]); 13179431996fSJuerg Haefliger /* Enable PWM ramp rate if previously enabled */ 13189431996fSJuerg Haefliger if (data->pwm_rr_en & (1 << ix)) { 13199431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(1, ix, 1320dbc2bc25SJean Delvare dme1737_read(data, 13219431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0))); 1322dbc2bc25SJean Delvare dme1737_write(data, 13239431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0), 13249431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 13259431996fSJuerg Haefliger } 13269431996fSJuerg Haefliger break; 13279431996fSJuerg Haefliger } 13289431996fSJuerg Haefliger break; 13299431996fSJuerg Haefliger case SYS_PWM_RAMP_RATE: 13309431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 13319431996fSJuerg Haefliger /* Refresh the cache */ 1332dbc2bc25SJean Delvare data->pwm_config[ix] = dme1737_read(data, 13339431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 1334dbc2bc25SJean Delvare data->pwm_rr[ix > 0] = dme1737_read(data, 13359431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0)); 13369431996fSJuerg Haefliger /* Set the ramp rate value */ 13379431996fSJuerg Haefliger if (val > 0) { 13389431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_TO_REG(val, ix, 13399431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 13409431996fSJuerg Haefliger } 13419431996fSJuerg Haefliger /* Enable/disable the feature only if the associated PWM 13429431996fSJuerg Haefliger * output is in automatic mode. */ 13439431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 13449431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(val > 0, ix, 13459431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 13469431996fSJuerg Haefliger } 1347dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_RR(ix > 0), 13489431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 13499431996fSJuerg Haefliger break; 13509431996fSJuerg Haefliger case SYS_PWM_AUTO_CHANNELS_ZONE: 13519431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 13529431996fSJuerg Haefliger if (!(val == 1 || val == 2 || val == 4 || 13539431996fSJuerg Haefliger val == 6 || val == 7)) { 13549431996fSJuerg Haefliger count = -EINVAL; 1355e95c237dSJuerg Haefliger dev_warn(dev, "PWM auto channels zone %ld " 13569431996fSJuerg Haefliger "not supported. Choose one of 1, 2, 4, 6, " 13579431996fSJuerg Haefliger "or 7.\n", val); 13589431996fSJuerg Haefliger goto exit; 13599431996fSJuerg Haefliger } 13609431996fSJuerg Haefliger /* Refresh the cache */ 1361dbc2bc25SJean Delvare data->pwm_config[ix] = dme1737_read(data, 13629431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 13639431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 13649431996fSJuerg Haefliger /* PWM is already in auto mode so update the temp 13659431996fSJuerg Haefliger * channel assignment */ 13669431996fSJuerg Haefliger data->pwm_config[ix] = PWM_ACZ_TO_REG(val, 13679431996fSJuerg Haefliger data->pwm_config[ix]); 1368dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_CONFIG(ix), 13699431996fSJuerg Haefliger data->pwm_config[ix]); 13709431996fSJuerg Haefliger } else { 13719431996fSJuerg Haefliger /* PWM is not in auto mode so we save the temp 13729431996fSJuerg Haefliger * channel assignment for later use */ 13739431996fSJuerg Haefliger data->pwm_acz[ix] = val; 13749431996fSJuerg Haefliger } 13759431996fSJuerg Haefliger break; 13769431996fSJuerg Haefliger case SYS_PWM_AUTO_PWM_MIN: 13779431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 13789431996fSJuerg Haefliger /* Refresh the cache */ 1379dbc2bc25SJean Delvare data->pwm_min[ix] = dme1737_read(data, 13809431996fSJuerg Haefliger DME1737_REG_PWM_MIN(ix)); 13819431996fSJuerg Haefliger /* There are only 2 values supported for the auto_pwm_min 13829431996fSJuerg Haefliger * value: 0 or auto_point1_pwm. So if the temperature drops 13839431996fSJuerg Haefliger * below the auto_point1_temp_hyst value, the fan either turns 13849431996fSJuerg Haefliger * off or runs at auto_point1_pwm duty-cycle. */ 13859431996fSJuerg Haefliger if (val > ((data->pwm_min[ix] + 1) / 2)) { 13869431996fSJuerg Haefliger data->pwm_rr[0] = PWM_OFF_TO_REG(1, ix, 1387dbc2bc25SJean Delvare dme1737_read(data, 13889431996fSJuerg Haefliger DME1737_REG_PWM_RR(0))); 13899431996fSJuerg Haefliger } else { 13909431996fSJuerg Haefliger data->pwm_rr[0] = PWM_OFF_TO_REG(0, ix, 1391dbc2bc25SJean Delvare dme1737_read(data, 13929431996fSJuerg Haefliger DME1737_REG_PWM_RR(0))); 13939431996fSJuerg Haefliger } 1394dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_RR(0), 13959431996fSJuerg Haefliger data->pwm_rr[0]); 13969431996fSJuerg Haefliger break; 13979431996fSJuerg Haefliger case SYS_PWM_AUTO_POINT1_PWM: 13989431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 13999431996fSJuerg Haefliger data->pwm_min[ix] = SENSORS_LIMIT(val, 0, 255); 1400dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_MIN(ix), 14019431996fSJuerg Haefliger data->pwm_min[ix]); 14029431996fSJuerg Haefliger break; 14039431996fSJuerg Haefliger default: 1404b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 14059431996fSJuerg Haefliger } 14069431996fSJuerg Haefliger exit: 14079431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 14089431996fSJuerg Haefliger 14099431996fSJuerg Haefliger return count; 14109431996fSJuerg Haefliger } 14119431996fSJuerg Haefliger 14129431996fSJuerg Haefliger /* --------------------------------------------------------------------- 14139431996fSJuerg Haefliger * Miscellaneous sysfs attributes 14149431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 14159431996fSJuerg Haefliger 14169431996fSJuerg Haefliger static ssize_t show_vrm(struct device *dev, struct device_attribute *attr, 14179431996fSJuerg Haefliger char *buf) 14189431996fSJuerg Haefliger { 14199431996fSJuerg Haefliger struct i2c_client *client = to_i2c_client(dev); 14209431996fSJuerg Haefliger struct dme1737_data *data = i2c_get_clientdata(client); 14219431996fSJuerg Haefliger 14229431996fSJuerg Haefliger return sprintf(buf, "%d\n", data->vrm); 14239431996fSJuerg Haefliger } 14249431996fSJuerg Haefliger 14259431996fSJuerg Haefliger static ssize_t set_vrm(struct device *dev, struct device_attribute *attr, 14269431996fSJuerg Haefliger const char *buf, size_t count) 14279431996fSJuerg Haefliger { 1428b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 14299431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 14309431996fSJuerg Haefliger 14319431996fSJuerg Haefliger data->vrm = val; 14329431996fSJuerg Haefliger return count; 14339431996fSJuerg Haefliger } 14349431996fSJuerg Haefliger 14359431996fSJuerg Haefliger static ssize_t show_vid(struct device *dev, struct device_attribute *attr, 14369431996fSJuerg Haefliger char *buf) 14379431996fSJuerg Haefliger { 14389431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 14399431996fSJuerg Haefliger 14409431996fSJuerg Haefliger return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm)); 14419431996fSJuerg Haefliger } 14429431996fSJuerg Haefliger 1443e95c237dSJuerg Haefliger static ssize_t show_name(struct device *dev, struct device_attribute *attr, 1444e95c237dSJuerg Haefliger char *buf) 1445e95c237dSJuerg Haefliger { 1446e95c237dSJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 1447e95c237dSJuerg Haefliger 1448dbc2bc25SJean Delvare return sprintf(buf, "%s\n", data->name); 1449e95c237dSJuerg Haefliger } 1450e95c237dSJuerg Haefliger 14519431996fSJuerg Haefliger /* --------------------------------------------------------------------- 14529431996fSJuerg Haefliger * Sysfs device attribute defines and structs 14539431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 14549431996fSJuerg Haefliger 1455d4b94e1fSJuerg Haefliger /* Voltages 0-7 */ 14569431996fSJuerg Haefliger 14579431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_IN(ix) \ 14589431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_input, S_IRUGO, \ 14599431996fSJuerg Haefliger show_in, NULL, SYS_IN_INPUT, ix); \ 14609431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_min, S_IRUGO | S_IWUSR, \ 14619431996fSJuerg Haefliger show_in, set_in, SYS_IN_MIN, ix); \ 14629431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_max, S_IRUGO | S_IWUSR, \ 14639431996fSJuerg Haefliger show_in, set_in, SYS_IN_MAX, ix); \ 14649431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_alarm, S_IRUGO, \ 14659431996fSJuerg Haefliger show_in, NULL, SYS_IN_ALARM, ix) 14669431996fSJuerg Haefliger 14679431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(0); 14689431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(1); 14699431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(2); 14709431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(3); 14719431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(4); 14729431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(5); 14739431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(6); 1474d4b94e1fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(7); 14759431996fSJuerg Haefliger 14769431996fSJuerg Haefliger /* Temperatures 1-3 */ 14779431996fSJuerg Haefliger 14789431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_TEMP(ix) \ 14799431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_input, S_IRUGO, \ 14809431996fSJuerg Haefliger show_temp, NULL, SYS_TEMP_INPUT, ix-1); \ 14819431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_min, S_IRUGO | S_IWUSR, \ 14829431996fSJuerg Haefliger show_temp, set_temp, SYS_TEMP_MIN, ix-1); \ 14839431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_max, S_IRUGO | S_IWUSR, \ 14849431996fSJuerg Haefliger show_temp, set_temp, SYS_TEMP_MAX, ix-1); \ 14859431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_offset, S_IRUGO, \ 14869431996fSJuerg Haefliger show_temp, set_temp, SYS_TEMP_OFFSET, ix-1); \ 14879431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_alarm, S_IRUGO, \ 14889431996fSJuerg Haefliger show_temp, NULL, SYS_TEMP_ALARM, ix-1); \ 14899431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_fault, S_IRUGO, \ 14909431996fSJuerg Haefliger show_temp, NULL, SYS_TEMP_FAULT, ix-1) 14919431996fSJuerg Haefliger 14929431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_TEMP(1); 14939431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_TEMP(2); 14949431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_TEMP(3); 14959431996fSJuerg Haefliger 14969431996fSJuerg Haefliger /* Zones 1-3 */ 14979431996fSJuerg Haefliger 14989431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_ZONE(ix) \ 14999431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_channels_temp, S_IRUGO, \ 15009431996fSJuerg Haefliger show_zone, NULL, SYS_ZONE_AUTO_CHANNELS_TEMP, ix-1); \ 15019431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point1_temp_hyst, S_IRUGO, \ 15029431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT1_TEMP_HYST, ix-1); \ 15039431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point1_temp, S_IRUGO, \ 15049431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT1_TEMP, ix-1); \ 15059431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point2_temp, S_IRUGO, \ 15069431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT2_TEMP, ix-1); \ 15079431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point3_temp, S_IRUGO, \ 15089431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT3_TEMP, ix-1) 15099431996fSJuerg Haefliger 15109431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_ZONE(1); 15119431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_ZONE(2); 15129431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_ZONE(3); 15139431996fSJuerg Haefliger 15149431996fSJuerg Haefliger /* Fans 1-4 */ 15159431996fSJuerg Haefliger 15169431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_FAN_1TO4(ix) \ 15179431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_input, S_IRUGO, \ 15189431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_INPUT, ix-1); \ 15199431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \ 15209431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_MIN, ix-1); \ 15219431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_alarm, S_IRUGO, \ 15229431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_ALARM, ix-1); \ 15239431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_type, S_IRUGO | S_IWUSR, \ 15249431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_TYPE, ix-1) 15259431996fSJuerg Haefliger 15269431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(1); 15279431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(2); 15289431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(3); 15299431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(4); 15309431996fSJuerg Haefliger 15319431996fSJuerg Haefliger /* Fans 5-6 */ 15329431996fSJuerg Haefliger 15339431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_FAN_5TO6(ix) \ 15349431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_input, S_IRUGO, \ 15359431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_INPUT, ix-1); \ 15369431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \ 15379431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_MIN, ix-1); \ 15389431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_alarm, S_IRUGO, \ 15399431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_ALARM, ix-1); \ 15409431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_max, S_IRUGO | S_IWUSR, \ 15419431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_MAX, ix-1) 15429431996fSJuerg Haefliger 15439431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_5TO6(5); 15449431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_5TO6(6); 15459431996fSJuerg Haefliger 15469431996fSJuerg Haefliger /* PWMs 1-3 */ 15479431996fSJuerg Haefliger 15489431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_PWM_1TO3(ix) \ 15499431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \ 15509431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM, ix-1); \ 15519431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \ 15529431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \ 15539431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \ 15549431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_ENABLE, ix-1); \ 15559431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_ramp_rate, S_IRUGO, \ 15569431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_RAMP_RATE, ix-1); \ 15579431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_channels_zone, S_IRUGO, \ 15589431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_AUTO_CHANNELS_ZONE, ix-1); \ 15599431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_pwm_min, S_IRUGO, \ 15609431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_AUTO_PWM_MIN, ix-1); \ 15619431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point1_pwm, S_IRUGO, \ 15629431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_AUTO_POINT1_PWM, ix-1); \ 15639431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point2_pwm, S_IRUGO, \ 15649431996fSJuerg Haefliger show_pwm, NULL, SYS_PWM_AUTO_POINT2_PWM, ix-1) 15659431996fSJuerg Haefliger 15669431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_1TO3(1); 15679431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_1TO3(2); 15689431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_1TO3(3); 15699431996fSJuerg Haefliger 15709431996fSJuerg Haefliger /* PWMs 5-6 */ 15719431996fSJuerg Haefliger 15729431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_PWM_5TO6(ix) \ 15739b257714SJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \ 15749431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM, ix-1); \ 15759b257714SJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \ 15769431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \ 15779431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \ 15789431996fSJuerg Haefliger show_pwm, NULL, SYS_PWM_ENABLE, ix-1) 15799431996fSJuerg Haefliger 15809431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_5TO6(5); 15819431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_5TO6(6); 15829431996fSJuerg Haefliger 15839431996fSJuerg Haefliger /* Misc */ 15849431996fSJuerg Haefliger 15859431996fSJuerg Haefliger static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm); 15869431996fSJuerg Haefliger static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL); 1587e95c237dSJuerg Haefliger static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); /* for ISA devices */ 15889431996fSJuerg Haefliger 15899431996fSJuerg Haefliger /* This struct holds all the attributes that are always present and need to be 15909431996fSJuerg Haefliger * created unconditionally. The attributes that need modification of their 15919431996fSJuerg Haefliger * permissions are created read-only and write permissions are added or removed 15929431996fSJuerg Haefliger * on the fly when required */ 15939431996fSJuerg Haefliger static struct attribute *dme1737_attr[] = { 15949431996fSJuerg Haefliger /* Voltages */ 15959b257714SJuerg Haefliger &sensor_dev_attr_in0_input.dev_attr.attr, 15969b257714SJuerg Haefliger &sensor_dev_attr_in0_min.dev_attr.attr, 15979b257714SJuerg Haefliger &sensor_dev_attr_in0_max.dev_attr.attr, 15989b257714SJuerg Haefliger &sensor_dev_attr_in0_alarm.dev_attr.attr, 15999b257714SJuerg Haefliger &sensor_dev_attr_in1_input.dev_attr.attr, 16009b257714SJuerg Haefliger &sensor_dev_attr_in1_min.dev_attr.attr, 16019b257714SJuerg Haefliger &sensor_dev_attr_in1_max.dev_attr.attr, 16029b257714SJuerg Haefliger &sensor_dev_attr_in1_alarm.dev_attr.attr, 16039b257714SJuerg Haefliger &sensor_dev_attr_in2_input.dev_attr.attr, 16049b257714SJuerg Haefliger &sensor_dev_attr_in2_min.dev_attr.attr, 16059b257714SJuerg Haefliger &sensor_dev_attr_in2_max.dev_attr.attr, 16069b257714SJuerg Haefliger &sensor_dev_attr_in2_alarm.dev_attr.attr, 16079b257714SJuerg Haefliger &sensor_dev_attr_in3_input.dev_attr.attr, 16089b257714SJuerg Haefliger &sensor_dev_attr_in3_min.dev_attr.attr, 16099b257714SJuerg Haefliger &sensor_dev_attr_in3_max.dev_attr.attr, 16109b257714SJuerg Haefliger &sensor_dev_attr_in3_alarm.dev_attr.attr, 16119b257714SJuerg Haefliger &sensor_dev_attr_in4_input.dev_attr.attr, 16129b257714SJuerg Haefliger &sensor_dev_attr_in4_min.dev_attr.attr, 16139b257714SJuerg Haefliger &sensor_dev_attr_in4_max.dev_attr.attr, 16149b257714SJuerg Haefliger &sensor_dev_attr_in4_alarm.dev_attr.attr, 16159b257714SJuerg Haefliger &sensor_dev_attr_in5_input.dev_attr.attr, 16169b257714SJuerg Haefliger &sensor_dev_attr_in5_min.dev_attr.attr, 16179b257714SJuerg Haefliger &sensor_dev_attr_in5_max.dev_attr.attr, 16189b257714SJuerg Haefliger &sensor_dev_attr_in5_alarm.dev_attr.attr, 16199b257714SJuerg Haefliger &sensor_dev_attr_in6_input.dev_attr.attr, 16209b257714SJuerg Haefliger &sensor_dev_attr_in6_min.dev_attr.attr, 16219b257714SJuerg Haefliger &sensor_dev_attr_in6_max.dev_attr.attr, 16229b257714SJuerg Haefliger &sensor_dev_attr_in6_alarm.dev_attr.attr, 16239431996fSJuerg Haefliger /* Temperatures */ 16249b257714SJuerg Haefliger &sensor_dev_attr_temp1_input.dev_attr.attr, 16259b257714SJuerg Haefliger &sensor_dev_attr_temp1_min.dev_attr.attr, 16269b257714SJuerg Haefliger &sensor_dev_attr_temp1_max.dev_attr.attr, 16279b257714SJuerg Haefliger &sensor_dev_attr_temp1_alarm.dev_attr.attr, 16289b257714SJuerg Haefliger &sensor_dev_attr_temp1_fault.dev_attr.attr, 16299b257714SJuerg Haefliger &sensor_dev_attr_temp2_input.dev_attr.attr, 16309b257714SJuerg Haefliger &sensor_dev_attr_temp2_min.dev_attr.attr, 16319b257714SJuerg Haefliger &sensor_dev_attr_temp2_max.dev_attr.attr, 16329b257714SJuerg Haefliger &sensor_dev_attr_temp2_alarm.dev_attr.attr, 16339b257714SJuerg Haefliger &sensor_dev_attr_temp2_fault.dev_attr.attr, 16349b257714SJuerg Haefliger &sensor_dev_attr_temp3_input.dev_attr.attr, 16359b257714SJuerg Haefliger &sensor_dev_attr_temp3_min.dev_attr.attr, 16369b257714SJuerg Haefliger &sensor_dev_attr_temp3_max.dev_attr.attr, 16379b257714SJuerg Haefliger &sensor_dev_attr_temp3_alarm.dev_attr.attr, 16389b257714SJuerg Haefliger &sensor_dev_attr_temp3_fault.dev_attr.attr, 16399431996fSJuerg Haefliger /* Zones */ 16409b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr, 16419b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr, 16429b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr, 16439b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_channels_temp.dev_attr.attr, 16449b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr, 16459b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr, 16469b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr, 16479b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_channels_temp.dev_attr.attr, 1648549edb83SJuerg Haefliger NULL 1649549edb83SJuerg Haefliger }; 1650549edb83SJuerg Haefliger 1651549edb83SJuerg Haefliger static const struct attribute_group dme1737_group = { 1652549edb83SJuerg Haefliger .attrs = dme1737_attr, 1653549edb83SJuerg Haefliger }; 1654549edb83SJuerg Haefliger 1655ea694431SJuerg Haefliger /* The following struct holds temp offset attributes, which are not available 1656ea694431SJuerg Haefliger * in all chips. The following chips support them: 1657ea694431SJuerg Haefliger * DME1737, SCH311x */ 1658ea694431SJuerg Haefliger static struct attribute *dme1737_temp_offset_attr[] = { 1659549edb83SJuerg Haefliger &sensor_dev_attr_temp1_offset.dev_attr.attr, 1660549edb83SJuerg Haefliger &sensor_dev_attr_temp2_offset.dev_attr.attr, 1661549edb83SJuerg Haefliger &sensor_dev_attr_temp3_offset.dev_attr.attr, 16629431996fSJuerg Haefliger NULL 16639431996fSJuerg Haefliger }; 16649431996fSJuerg Haefliger 1665ea694431SJuerg Haefliger static const struct attribute_group dme1737_temp_offset_group = { 1666ea694431SJuerg Haefliger .attrs = dme1737_temp_offset_attr, 16679431996fSJuerg Haefliger }; 16689431996fSJuerg Haefliger 1669ea694431SJuerg Haefliger /* The following struct holds VID related attributes, which are not available 1670ea694431SJuerg Haefliger * in all chips. The following chips support them: 1671ea694431SJuerg Haefliger * DME1737 */ 16729d091446SJean Delvare static struct attribute *dme1737_vid_attr[] = { 16739d091446SJean Delvare &dev_attr_vrm.attr, 16749d091446SJean Delvare &dev_attr_cpu0_vid.attr, 16759d091446SJean Delvare NULL 16769d091446SJean Delvare }; 16779d091446SJean Delvare 16789d091446SJean Delvare static const struct attribute_group dme1737_vid_group = { 16799d091446SJean Delvare .attrs = dme1737_vid_attr, 16809d091446SJean Delvare }; 16819d091446SJean Delvare 1682ea694431SJuerg Haefliger /* The following struct holds temp zone 3 related attributes, which are not 1683ea694431SJuerg Haefliger * available in all chips. The following chips support them: 1684ea694431SJuerg Haefliger * DME1737, SCH311x, SCH5027 */ 1685ea694431SJuerg Haefliger static struct attribute *dme1737_zone3_attr[] = { 1686ea694431SJuerg Haefliger &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr, 1687ea694431SJuerg Haefliger &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr, 1688ea694431SJuerg Haefliger &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr, 1689ea694431SJuerg Haefliger &sensor_dev_attr_zone3_auto_channels_temp.dev_attr.attr, 1690ea694431SJuerg Haefliger NULL 1691ea694431SJuerg Haefliger }; 1692ea694431SJuerg Haefliger 1693ea694431SJuerg Haefliger static const struct attribute_group dme1737_zone3_group = { 1694ea694431SJuerg Haefliger .attrs = dme1737_zone3_attr, 1695ea694431SJuerg Haefliger }; 1696ea694431SJuerg Haefliger 1697ea694431SJuerg Haefliger 1698ea694431SJuerg Haefliger /* The following struct holds temp zone hysteresis related attributes, which 1699ea694431SJuerg Haefliger * are not available in all chips. The following chips support them: 1700ea694431SJuerg Haefliger * DME1737, SCH311x */ 1701ea694431SJuerg Haefliger static struct attribute *dme1737_zone_hyst_attr[] = { 1702ea694431SJuerg Haefliger &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr, 1703ea694431SJuerg Haefliger &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr, 1704ea694431SJuerg Haefliger &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr, 1705ea694431SJuerg Haefliger NULL 1706ea694431SJuerg Haefliger }; 1707ea694431SJuerg Haefliger 1708ea694431SJuerg Haefliger static const struct attribute_group dme1737_zone_hyst_group = { 1709ea694431SJuerg Haefliger .attrs = dme1737_zone_hyst_attr, 1710ea694431SJuerg Haefliger }; 1711ea694431SJuerg Haefliger 1712d4b94e1fSJuerg Haefliger /* The following struct holds voltage in7 related attributes, which 1713d4b94e1fSJuerg Haefliger * are not available in all chips. The following chips support them: 1714d4b94e1fSJuerg Haefliger * SCH5127 */ 1715d4b94e1fSJuerg Haefliger static struct attribute *dme1737_in7_attr[] = { 1716d4b94e1fSJuerg Haefliger &sensor_dev_attr_in7_input.dev_attr.attr, 1717d4b94e1fSJuerg Haefliger &sensor_dev_attr_in7_min.dev_attr.attr, 1718d4b94e1fSJuerg Haefliger &sensor_dev_attr_in7_max.dev_attr.attr, 1719d4b94e1fSJuerg Haefliger &sensor_dev_attr_in7_alarm.dev_attr.attr, 1720d4b94e1fSJuerg Haefliger NULL 1721d4b94e1fSJuerg Haefliger }; 1722d4b94e1fSJuerg Haefliger 1723d4b94e1fSJuerg Haefliger static const struct attribute_group dme1737_in7_group = { 1724d4b94e1fSJuerg Haefliger .attrs = dme1737_in7_attr, 1725d4b94e1fSJuerg Haefliger }; 1726d4b94e1fSJuerg Haefliger 17279431996fSJuerg Haefliger /* The following structs hold the PWM attributes, some of which are optional. 17289431996fSJuerg Haefliger * Their creation depends on the chip configuration which is determined during 17299431996fSJuerg Haefliger * module load. */ 173073ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm1_attr[] = { 17319b257714SJuerg Haefliger &sensor_dev_attr_pwm1.dev_attr.attr, 17329b257714SJuerg Haefliger &sensor_dev_attr_pwm1_freq.dev_attr.attr, 17339b257714SJuerg Haefliger &sensor_dev_attr_pwm1_enable.dev_attr.attr, 17349b257714SJuerg Haefliger &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr, 17359b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr, 17369b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 17379b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 17389431996fSJuerg Haefliger NULL 17399431996fSJuerg Haefliger }; 174073ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm2_attr[] = { 17419b257714SJuerg Haefliger &sensor_dev_attr_pwm2.dev_attr.attr, 17429b257714SJuerg Haefliger &sensor_dev_attr_pwm2_freq.dev_attr.attr, 17439b257714SJuerg Haefliger &sensor_dev_attr_pwm2_enable.dev_attr.attr, 17449b257714SJuerg Haefliger &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr, 17459b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr, 17469b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 17479b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, 17489431996fSJuerg Haefliger NULL 17499431996fSJuerg Haefliger }; 175073ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm3_attr[] = { 17519b257714SJuerg Haefliger &sensor_dev_attr_pwm3.dev_attr.attr, 17529b257714SJuerg Haefliger &sensor_dev_attr_pwm3_freq.dev_attr.attr, 17539b257714SJuerg Haefliger &sensor_dev_attr_pwm3_enable.dev_attr.attr, 17549b257714SJuerg Haefliger &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr, 17559b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr, 17569b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 17579b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr, 17589431996fSJuerg Haefliger NULL 17599431996fSJuerg Haefliger }; 176073ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm5_attr[] = { 17619b257714SJuerg Haefliger &sensor_dev_attr_pwm5.dev_attr.attr, 17629b257714SJuerg Haefliger &sensor_dev_attr_pwm5_freq.dev_attr.attr, 17639b257714SJuerg Haefliger &sensor_dev_attr_pwm5_enable.dev_attr.attr, 17649431996fSJuerg Haefliger NULL 17659431996fSJuerg Haefliger }; 176673ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm6_attr[] = { 17679b257714SJuerg Haefliger &sensor_dev_attr_pwm6.dev_attr.attr, 17689b257714SJuerg Haefliger &sensor_dev_attr_pwm6_freq.dev_attr.attr, 17699b257714SJuerg Haefliger &sensor_dev_attr_pwm6_enable.dev_attr.attr, 17709431996fSJuerg Haefliger NULL 17719431996fSJuerg Haefliger }; 17729431996fSJuerg Haefliger 17739431996fSJuerg Haefliger static const struct attribute_group dme1737_pwm_group[] = { 177473ce48f6SJuerg Haefliger { .attrs = dme1737_pwm1_attr }, 177573ce48f6SJuerg Haefliger { .attrs = dme1737_pwm2_attr }, 177673ce48f6SJuerg Haefliger { .attrs = dme1737_pwm3_attr }, 17779431996fSJuerg Haefliger { .attrs = NULL }, 177873ce48f6SJuerg Haefliger { .attrs = dme1737_pwm5_attr }, 177973ce48f6SJuerg Haefliger { .attrs = dme1737_pwm6_attr }, 17809431996fSJuerg Haefliger }; 17819431996fSJuerg Haefliger 1782ea694431SJuerg Haefliger /* The following struct holds auto PWM min attributes, which are not available 1783ea694431SJuerg Haefliger * in all chips. Their creation depends on the chip type which is determined 1784549edb83SJuerg Haefliger * during module load. */ 1785ea694431SJuerg Haefliger static struct attribute *dme1737_auto_pwm_min_attr[] = { 1786549edb83SJuerg Haefliger &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr, 1787549edb83SJuerg Haefliger &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr, 1788549edb83SJuerg Haefliger &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr, 1789549edb83SJuerg Haefliger }; 1790549edb83SJuerg Haefliger 17919431996fSJuerg Haefliger /* The following structs hold the fan attributes, some of which are optional. 17929431996fSJuerg Haefliger * Their creation depends on the chip configuration which is determined during 17939431996fSJuerg Haefliger * module load. */ 179473ce48f6SJuerg Haefliger static struct attribute *dme1737_fan1_attr[] = { 17959b257714SJuerg Haefliger &sensor_dev_attr_fan1_input.dev_attr.attr, 17969b257714SJuerg Haefliger &sensor_dev_attr_fan1_min.dev_attr.attr, 17979b257714SJuerg Haefliger &sensor_dev_attr_fan1_alarm.dev_attr.attr, 17989b257714SJuerg Haefliger &sensor_dev_attr_fan1_type.dev_attr.attr, 17999431996fSJuerg Haefliger NULL 18009431996fSJuerg Haefliger }; 180173ce48f6SJuerg Haefliger static struct attribute *dme1737_fan2_attr[] = { 18029b257714SJuerg Haefliger &sensor_dev_attr_fan2_input.dev_attr.attr, 18039b257714SJuerg Haefliger &sensor_dev_attr_fan2_min.dev_attr.attr, 18049b257714SJuerg Haefliger &sensor_dev_attr_fan2_alarm.dev_attr.attr, 18059b257714SJuerg Haefliger &sensor_dev_attr_fan2_type.dev_attr.attr, 18069431996fSJuerg Haefliger NULL 18079431996fSJuerg Haefliger }; 180873ce48f6SJuerg Haefliger static struct attribute *dme1737_fan3_attr[] = { 18099b257714SJuerg Haefliger &sensor_dev_attr_fan3_input.dev_attr.attr, 18109b257714SJuerg Haefliger &sensor_dev_attr_fan3_min.dev_attr.attr, 18119b257714SJuerg Haefliger &sensor_dev_attr_fan3_alarm.dev_attr.attr, 18129b257714SJuerg Haefliger &sensor_dev_attr_fan3_type.dev_attr.attr, 18139431996fSJuerg Haefliger NULL 18149431996fSJuerg Haefliger }; 181573ce48f6SJuerg Haefliger static struct attribute *dme1737_fan4_attr[] = { 18169b257714SJuerg Haefliger &sensor_dev_attr_fan4_input.dev_attr.attr, 18179b257714SJuerg Haefliger &sensor_dev_attr_fan4_min.dev_attr.attr, 18189b257714SJuerg Haefliger &sensor_dev_attr_fan4_alarm.dev_attr.attr, 18199b257714SJuerg Haefliger &sensor_dev_attr_fan4_type.dev_attr.attr, 18209431996fSJuerg Haefliger NULL 18219431996fSJuerg Haefliger }; 182273ce48f6SJuerg Haefliger static struct attribute *dme1737_fan5_attr[] = { 18239b257714SJuerg Haefliger &sensor_dev_attr_fan5_input.dev_attr.attr, 18249b257714SJuerg Haefliger &sensor_dev_attr_fan5_min.dev_attr.attr, 18259b257714SJuerg Haefliger &sensor_dev_attr_fan5_alarm.dev_attr.attr, 18269b257714SJuerg Haefliger &sensor_dev_attr_fan5_max.dev_attr.attr, 18279431996fSJuerg Haefliger NULL 18289431996fSJuerg Haefliger }; 182973ce48f6SJuerg Haefliger static struct attribute *dme1737_fan6_attr[] = { 18309b257714SJuerg Haefliger &sensor_dev_attr_fan6_input.dev_attr.attr, 18319b257714SJuerg Haefliger &sensor_dev_attr_fan6_min.dev_attr.attr, 18329b257714SJuerg Haefliger &sensor_dev_attr_fan6_alarm.dev_attr.attr, 18339b257714SJuerg Haefliger &sensor_dev_attr_fan6_max.dev_attr.attr, 18349431996fSJuerg Haefliger NULL 18359431996fSJuerg Haefliger }; 18369431996fSJuerg Haefliger 18379431996fSJuerg Haefliger static const struct attribute_group dme1737_fan_group[] = { 183873ce48f6SJuerg Haefliger { .attrs = dme1737_fan1_attr }, 183973ce48f6SJuerg Haefliger { .attrs = dme1737_fan2_attr }, 184073ce48f6SJuerg Haefliger { .attrs = dme1737_fan3_attr }, 184173ce48f6SJuerg Haefliger { .attrs = dme1737_fan4_attr }, 184273ce48f6SJuerg Haefliger { .attrs = dme1737_fan5_attr }, 184373ce48f6SJuerg Haefliger { .attrs = dme1737_fan6_attr }, 18449431996fSJuerg Haefliger }; 18459431996fSJuerg Haefliger 1846549edb83SJuerg Haefliger /* The permissions of the following zone attributes are changed to read- 18479431996fSJuerg Haefliger * writeable if the chip is *not* locked. Otherwise they stay read-only. */ 1848549edb83SJuerg Haefliger static struct attribute *dme1737_zone_chmod_attr[] = { 18499b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr, 18509b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr, 18519b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr, 18529b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr, 18539b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr, 18549b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr, 1855ea694431SJuerg Haefliger NULL 1856ea694431SJuerg Haefliger }; 1857ea694431SJuerg Haefliger 1858ea694431SJuerg Haefliger static const struct attribute_group dme1737_zone_chmod_group = { 1859ea694431SJuerg Haefliger .attrs = dme1737_zone_chmod_attr, 1860ea694431SJuerg Haefliger }; 1861ea694431SJuerg Haefliger 1862ea694431SJuerg Haefliger 1863ea694431SJuerg Haefliger /* The permissions of the following zone 3 attributes are changed to read- 1864ea694431SJuerg Haefliger * writeable if the chip is *not* locked. Otherwise they stay read-only. */ 1865ea694431SJuerg Haefliger static struct attribute *dme1737_zone3_chmod_attr[] = { 18669b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr, 18679b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr, 18689b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr, 18699431996fSJuerg Haefliger NULL 18709431996fSJuerg Haefliger }; 18719431996fSJuerg Haefliger 1872ea694431SJuerg Haefliger static const struct attribute_group dme1737_zone3_chmod_group = { 1873ea694431SJuerg Haefliger .attrs = dme1737_zone3_chmod_attr, 18749431996fSJuerg Haefliger }; 18759431996fSJuerg Haefliger 18769431996fSJuerg Haefliger /* The permissions of the following PWM attributes are changed to read- 18779431996fSJuerg Haefliger * writeable if the chip is *not* locked and the respective PWM is available. 18789431996fSJuerg Haefliger * Otherwise they stay read-only. */ 187973ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm1_chmod_attr[] = { 18809b257714SJuerg Haefliger &sensor_dev_attr_pwm1_freq.dev_attr.attr, 18819b257714SJuerg Haefliger &sensor_dev_attr_pwm1_enable.dev_attr.attr, 18829b257714SJuerg Haefliger &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr, 18839b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr, 18849b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 18859431996fSJuerg Haefliger NULL 18869431996fSJuerg Haefliger }; 188773ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm2_chmod_attr[] = { 18889b257714SJuerg Haefliger &sensor_dev_attr_pwm2_freq.dev_attr.attr, 18899b257714SJuerg Haefliger &sensor_dev_attr_pwm2_enable.dev_attr.attr, 18909b257714SJuerg Haefliger &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr, 18919b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr, 18929b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 18939431996fSJuerg Haefliger NULL 18949431996fSJuerg Haefliger }; 189573ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm3_chmod_attr[] = { 18969b257714SJuerg Haefliger &sensor_dev_attr_pwm3_freq.dev_attr.attr, 18979b257714SJuerg Haefliger &sensor_dev_attr_pwm3_enable.dev_attr.attr, 18989b257714SJuerg Haefliger &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr, 18999b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr, 19009b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 19019431996fSJuerg Haefliger NULL 19029431996fSJuerg Haefliger }; 190373ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm5_chmod_attr[] = { 19049b257714SJuerg Haefliger &sensor_dev_attr_pwm5.dev_attr.attr, 19059b257714SJuerg Haefliger &sensor_dev_attr_pwm5_freq.dev_attr.attr, 19069431996fSJuerg Haefliger NULL 19079431996fSJuerg Haefliger }; 190873ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm6_chmod_attr[] = { 19099b257714SJuerg Haefliger &sensor_dev_attr_pwm6.dev_attr.attr, 19109b257714SJuerg Haefliger &sensor_dev_attr_pwm6_freq.dev_attr.attr, 19119431996fSJuerg Haefliger NULL 19129431996fSJuerg Haefliger }; 19139431996fSJuerg Haefliger 191473ce48f6SJuerg Haefliger static const struct attribute_group dme1737_pwm_chmod_group[] = { 191573ce48f6SJuerg Haefliger { .attrs = dme1737_pwm1_chmod_attr }, 191673ce48f6SJuerg Haefliger { .attrs = dme1737_pwm2_chmod_attr }, 191773ce48f6SJuerg Haefliger { .attrs = dme1737_pwm3_chmod_attr }, 19189431996fSJuerg Haefliger { .attrs = NULL }, 191973ce48f6SJuerg Haefliger { .attrs = dme1737_pwm5_chmod_attr }, 192073ce48f6SJuerg Haefliger { .attrs = dme1737_pwm6_chmod_attr }, 19219431996fSJuerg Haefliger }; 19229431996fSJuerg Haefliger 19239431996fSJuerg Haefliger /* Pwm[1-3] are read-writeable if the associated pwm is in manual mode and the 19249431996fSJuerg Haefliger * chip is not locked. Otherwise they are read-only. */ 192573ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm_chmod_attr[] = { 19269431996fSJuerg Haefliger &sensor_dev_attr_pwm1.dev_attr.attr, 19279431996fSJuerg Haefliger &sensor_dev_attr_pwm2.dev_attr.attr, 19289431996fSJuerg Haefliger &sensor_dev_attr_pwm3.dev_attr.attr, 19299431996fSJuerg Haefliger }; 19309431996fSJuerg Haefliger 19319431996fSJuerg Haefliger /* --------------------------------------------------------------------- 19329431996fSJuerg Haefliger * Super-IO functions 19339431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 19349431996fSJuerg Haefliger 1935b237eb25SJuerg Haefliger static inline void dme1737_sio_enter(int sio_cip) 1936b237eb25SJuerg Haefliger { 1937b237eb25SJuerg Haefliger outb(0x55, sio_cip); 1938b237eb25SJuerg Haefliger } 1939b237eb25SJuerg Haefliger 1940b237eb25SJuerg Haefliger static inline void dme1737_sio_exit(int sio_cip) 1941b237eb25SJuerg Haefliger { 1942b237eb25SJuerg Haefliger outb(0xaa, sio_cip); 1943b237eb25SJuerg Haefliger } 1944b237eb25SJuerg Haefliger 19459431996fSJuerg Haefliger static inline int dme1737_sio_inb(int sio_cip, int reg) 19469431996fSJuerg Haefliger { 19479431996fSJuerg Haefliger outb(reg, sio_cip); 19489431996fSJuerg Haefliger return inb(sio_cip + 1); 19499431996fSJuerg Haefliger } 19509431996fSJuerg Haefliger 19519431996fSJuerg Haefliger static inline void dme1737_sio_outb(int sio_cip, int reg, int val) 19529431996fSJuerg Haefliger { 19539431996fSJuerg Haefliger outb(reg, sio_cip); 19549431996fSJuerg Haefliger outb(val, sio_cip + 1); 19559431996fSJuerg Haefliger } 19569431996fSJuerg Haefliger 19579431996fSJuerg Haefliger /* --------------------------------------------------------------------- 1958e95c237dSJuerg Haefliger * Device initialization 19599431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 19609431996fSJuerg Haefliger 196167e2f328SJuerg Haefliger static int dme1737_i2c_get_features(int, struct dme1737_data*); 19629431996fSJuerg Haefliger 1963b237eb25SJuerg Haefliger static void dme1737_chmod_file(struct device *dev, 19649431996fSJuerg Haefliger struct attribute *attr, mode_t mode) 19659431996fSJuerg Haefliger { 1966b237eb25SJuerg Haefliger if (sysfs_chmod_file(&dev->kobj, attr, mode)) { 1967b237eb25SJuerg Haefliger dev_warn(dev, "Failed to change permissions of %s.\n", 19689431996fSJuerg Haefliger attr->name); 19699431996fSJuerg Haefliger } 19709431996fSJuerg Haefliger } 19719431996fSJuerg Haefliger 1972b237eb25SJuerg Haefliger static void dme1737_chmod_group(struct device *dev, 19739431996fSJuerg Haefliger const struct attribute_group *group, 19749431996fSJuerg Haefliger mode_t mode) 19759431996fSJuerg Haefliger { 19769431996fSJuerg Haefliger struct attribute **attr; 19779431996fSJuerg Haefliger 19789431996fSJuerg Haefliger for (attr = group->attrs; *attr; attr++) { 1979b237eb25SJuerg Haefliger dme1737_chmod_file(dev, *attr, mode); 19809431996fSJuerg Haefliger } 19819431996fSJuerg Haefliger } 19829431996fSJuerg Haefliger 1983b237eb25SJuerg Haefliger static void dme1737_remove_files(struct device *dev) 19849431996fSJuerg Haefliger { 1985b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 1986b237eb25SJuerg Haefliger int ix; 1987b237eb25SJuerg Haefliger 1988b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) { 1989ea694431SJuerg Haefliger if (data->has_features & HAS_FAN(ix)) { 1990b237eb25SJuerg Haefliger sysfs_remove_group(&dev->kobj, 1991b237eb25SJuerg Haefliger &dme1737_fan_group[ix]); 1992b237eb25SJuerg Haefliger } 1993b237eb25SJuerg Haefliger } 1994b237eb25SJuerg Haefliger 1995b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) { 1996ea694431SJuerg Haefliger if (data->has_features & HAS_PWM(ix)) { 1997b237eb25SJuerg Haefliger sysfs_remove_group(&dev->kobj, 1998b237eb25SJuerg Haefliger &dme1737_pwm_group[ix]); 1999ea694431SJuerg Haefliger if ((data->has_features & HAS_PWM_MIN) && ix < 3) { 2000549edb83SJuerg Haefliger sysfs_remove_file(&dev->kobj, 2001ea694431SJuerg Haefliger dme1737_auto_pwm_min_attr[ix]); 2002b237eb25SJuerg Haefliger } 2003b237eb25SJuerg Haefliger } 2004549edb83SJuerg Haefliger } 2005549edb83SJuerg Haefliger 2006ea694431SJuerg Haefliger if (data->has_features & HAS_TEMP_OFFSET) { 2007ea694431SJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_temp_offset_group); 2008549edb83SJuerg Haefliger } 2009ea694431SJuerg Haefliger if (data->has_features & HAS_VID) { 20109d091446SJean Delvare sysfs_remove_group(&dev->kobj, &dme1737_vid_group); 20119d091446SJean Delvare } 2012ea694431SJuerg Haefliger if (data->has_features & HAS_ZONE3) { 2013ea694431SJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_zone3_group); 2014ea694431SJuerg Haefliger } 2015ea694431SJuerg Haefliger if (data->has_features & HAS_ZONE_HYST) { 2016ea694431SJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_zone_hyst_group); 2017ea694431SJuerg Haefliger } 2018d4b94e1fSJuerg Haefliger if (data->has_features & HAS_IN7) { 2019d4b94e1fSJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_in7_group); 2020d4b94e1fSJuerg Haefliger } 2021b237eb25SJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_group); 2022e95c237dSJuerg Haefliger 2023dbc2bc25SJean Delvare if (!data->client) { 2024e95c237dSJuerg Haefliger sysfs_remove_file(&dev->kobj, &dev_attr_name.attr); 2025e95c237dSJuerg Haefliger } 2026b237eb25SJuerg Haefliger } 2027b237eb25SJuerg Haefliger 2028b237eb25SJuerg Haefliger static int dme1737_create_files(struct device *dev) 2029b237eb25SJuerg Haefliger { 2030b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 2031b237eb25SJuerg Haefliger int err, ix; 2032b237eb25SJuerg Haefliger 2033e95c237dSJuerg Haefliger /* Create a name attribute for ISA devices */ 2034*06f3d9fbSJuerg Haefliger if (!data->client) { 2035*06f3d9fbSJuerg Haefliger err = sysfs_create_file(&dev->kobj, &dev_attr_name.attr); 2036*06f3d9fbSJuerg Haefliger if (err) { 2037e95c237dSJuerg Haefliger goto exit; 2038e95c237dSJuerg Haefliger } 2039*06f3d9fbSJuerg Haefliger } 2040e95c237dSJuerg Haefliger 2041b237eb25SJuerg Haefliger /* Create standard sysfs attributes */ 2042*06f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, &dme1737_group); 2043*06f3d9fbSJuerg Haefliger if (err) { 2044e95c237dSJuerg Haefliger goto exit_remove; 2045b237eb25SJuerg Haefliger } 2046b237eb25SJuerg Haefliger 2047ea694431SJuerg Haefliger /* Create chip-dependent sysfs attributes */ 2048*06f3d9fbSJuerg Haefliger if (data->has_features & HAS_TEMP_OFFSET) { 2049*06f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, 2050*06f3d9fbSJuerg Haefliger &dme1737_temp_offset_group); 2051*06f3d9fbSJuerg Haefliger if (err) { 2052549edb83SJuerg Haefliger goto exit_remove; 2053549edb83SJuerg Haefliger } 2054*06f3d9fbSJuerg Haefliger } 2055*06f3d9fbSJuerg Haefliger if (data->has_features & HAS_VID) { 2056*06f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, &dme1737_vid_group); 2057*06f3d9fbSJuerg Haefliger if (err) { 20589d091446SJean Delvare goto exit_remove; 20599d091446SJean Delvare } 2060*06f3d9fbSJuerg Haefliger } 2061*06f3d9fbSJuerg Haefliger if (data->has_features & HAS_ZONE3) { 2062*06f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, &dme1737_zone3_group); 2063*06f3d9fbSJuerg Haefliger if (err) { 2064ea694431SJuerg Haefliger goto exit_remove; 2065ea694431SJuerg Haefliger } 2066*06f3d9fbSJuerg Haefliger } 2067*06f3d9fbSJuerg Haefliger if (data->has_features & HAS_ZONE_HYST) { 2068*06f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, &dme1737_zone_hyst_group); 2069*06f3d9fbSJuerg Haefliger if (err) { 2070ea694431SJuerg Haefliger goto exit_remove; 2071ea694431SJuerg Haefliger } 2072*06f3d9fbSJuerg Haefliger } 2073d4b94e1fSJuerg Haefliger if (data->has_features & HAS_IN7) { 2074d4b94e1fSJuerg Haefliger err = sysfs_create_group(&dev->kobj, &dme1737_in7_group); 2075d4b94e1fSJuerg Haefliger if (err) { 2076d4b94e1fSJuerg Haefliger goto exit_remove; 2077d4b94e1fSJuerg Haefliger } 2078d4b94e1fSJuerg Haefliger } 20799d091446SJean Delvare 2080b237eb25SJuerg Haefliger /* Create fan sysfs attributes */ 2081b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) { 2082ea694431SJuerg Haefliger if (data->has_features & HAS_FAN(ix)) { 2083*06f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, 2084*06f3d9fbSJuerg Haefliger &dme1737_fan_group[ix]); 2085*06f3d9fbSJuerg Haefliger if (err) { 2086b237eb25SJuerg Haefliger goto exit_remove; 2087b237eb25SJuerg Haefliger } 2088b237eb25SJuerg Haefliger } 2089b237eb25SJuerg Haefliger } 2090b237eb25SJuerg Haefliger 2091b237eb25SJuerg Haefliger /* Create PWM sysfs attributes */ 2092b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) { 2093ea694431SJuerg Haefliger if (data->has_features & HAS_PWM(ix)) { 2094*06f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, 2095*06f3d9fbSJuerg Haefliger &dme1737_pwm_group[ix]); 2096*06f3d9fbSJuerg Haefliger if (err) { 2097b237eb25SJuerg Haefliger goto exit_remove; 2098b237eb25SJuerg Haefliger } 2099*06f3d9fbSJuerg Haefliger if ((data->has_features & HAS_PWM_MIN) && (ix < 3)) { 2100*06f3d9fbSJuerg Haefliger err = sysfs_create_file(&dev->kobj, 2101*06f3d9fbSJuerg Haefliger dme1737_auto_pwm_min_attr[ix]); 2102*06f3d9fbSJuerg Haefliger if (err) { 2103549edb83SJuerg Haefliger goto exit_remove; 2104549edb83SJuerg Haefliger } 2105b237eb25SJuerg Haefliger } 2106b237eb25SJuerg Haefliger } 2107*06f3d9fbSJuerg Haefliger } 2108b237eb25SJuerg Haefliger 2109b237eb25SJuerg Haefliger /* Inform if the device is locked. Otherwise change the permissions of 2110b237eb25SJuerg Haefliger * selected attributes from read-only to read-writeable. */ 2111b237eb25SJuerg Haefliger if (data->config & 0x02) { 2112b237eb25SJuerg Haefliger dev_info(dev, "Device is locked. Some attributes " 2113b237eb25SJuerg Haefliger "will be read-only.\n"); 2114b237eb25SJuerg Haefliger } else { 2115549edb83SJuerg Haefliger /* Change permissions of zone sysfs attributes */ 2116549edb83SJuerg Haefliger dme1737_chmod_group(dev, &dme1737_zone_chmod_group, 2117b237eb25SJuerg Haefliger S_IRUGO | S_IWUSR); 2118b237eb25SJuerg Haefliger 2119ea694431SJuerg Haefliger /* Change permissions of chip-dependent sysfs attributes */ 2120ea694431SJuerg Haefliger if (data->has_features & HAS_TEMP_OFFSET) { 2121ea694431SJuerg Haefliger dme1737_chmod_group(dev, &dme1737_temp_offset_group, 2122ea694431SJuerg Haefliger S_IRUGO | S_IWUSR); 2123ea694431SJuerg Haefliger } 2124ea694431SJuerg Haefliger if (data->has_features & HAS_ZONE3) { 2125ea694431SJuerg Haefliger dme1737_chmod_group(dev, &dme1737_zone3_chmod_group, 2126ea694431SJuerg Haefliger S_IRUGO | S_IWUSR); 2127ea694431SJuerg Haefliger } 2128ea694431SJuerg Haefliger if (data->has_features & HAS_ZONE_HYST) { 2129ea694431SJuerg Haefliger dme1737_chmod_group(dev, &dme1737_zone_hyst_group, 2130549edb83SJuerg Haefliger S_IRUGO | S_IWUSR); 2131549edb83SJuerg Haefliger } 2132549edb83SJuerg Haefliger 213373ce48f6SJuerg Haefliger /* Change permissions of PWM sysfs attributes */ 213473ce48f6SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_chmod_group); ix++) { 2135ea694431SJuerg Haefliger if (data->has_features & HAS_PWM(ix)) { 2136b237eb25SJuerg Haefliger dme1737_chmod_group(dev, 213773ce48f6SJuerg Haefliger &dme1737_pwm_chmod_group[ix], 2138b237eb25SJuerg Haefliger S_IRUGO | S_IWUSR); 2139ea694431SJuerg Haefliger if ((data->has_features & HAS_PWM_MIN) && 2140ea694431SJuerg Haefliger ix < 3) { 2141549edb83SJuerg Haefliger dme1737_chmod_file(dev, 2142ea694431SJuerg Haefliger dme1737_auto_pwm_min_attr[ix], 2143549edb83SJuerg Haefliger S_IRUGO | S_IWUSR); 2144549edb83SJuerg Haefliger } 2145b237eb25SJuerg Haefliger } 2146b237eb25SJuerg Haefliger } 2147b237eb25SJuerg Haefliger 2148b237eb25SJuerg Haefliger /* Change permissions of pwm[1-3] if in manual mode */ 2149b237eb25SJuerg Haefliger for (ix = 0; ix < 3; ix++) { 2150ea694431SJuerg Haefliger if ((data->has_features & HAS_PWM(ix)) && 2151b237eb25SJuerg Haefliger (PWM_EN_FROM_REG(data->pwm_config[ix]) == 1)) { 2152b237eb25SJuerg Haefliger dme1737_chmod_file(dev, 215373ce48f6SJuerg Haefliger dme1737_pwm_chmod_attr[ix], 2154b237eb25SJuerg Haefliger S_IRUGO | S_IWUSR); 2155b237eb25SJuerg Haefliger } 2156b237eb25SJuerg Haefliger } 2157b237eb25SJuerg Haefliger } 2158b237eb25SJuerg Haefliger 2159b237eb25SJuerg Haefliger return 0; 2160b237eb25SJuerg Haefliger 2161b237eb25SJuerg Haefliger exit_remove: 2162b237eb25SJuerg Haefliger dme1737_remove_files(dev); 2163b237eb25SJuerg Haefliger exit: 2164b237eb25SJuerg Haefliger return err; 2165b237eb25SJuerg Haefliger } 2166b237eb25SJuerg Haefliger 2167b237eb25SJuerg Haefliger static int dme1737_init_device(struct device *dev) 2168b237eb25SJuerg Haefliger { 2169b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 2170dbc2bc25SJean Delvare struct i2c_client *client = data->client; 21719431996fSJuerg Haefliger int ix; 21729431996fSJuerg Haefliger u8 reg; 21739431996fSJuerg Haefliger 2174549edb83SJuerg Haefliger /* Point to the right nominal voltages array */ 2175549edb83SJuerg Haefliger data->in_nominal = IN_NOMINAL(data->type); 2176549edb83SJuerg Haefliger 2177dbc2bc25SJean Delvare data->config = dme1737_read(data, DME1737_REG_CONFIG); 21789431996fSJuerg Haefliger /* Inform if part is not monitoring/started */ 21799431996fSJuerg Haefliger if (!(data->config & 0x01)) { 21809431996fSJuerg Haefliger if (!force_start) { 2181b237eb25SJuerg Haefliger dev_err(dev, "Device is not monitoring. " 21829431996fSJuerg Haefliger "Use the force_start load parameter to " 21839431996fSJuerg Haefliger "override.\n"); 21849431996fSJuerg Haefliger return -EFAULT; 21859431996fSJuerg Haefliger } 21869431996fSJuerg Haefliger 21879431996fSJuerg Haefliger /* Force monitoring */ 21889431996fSJuerg Haefliger data->config |= 0x01; 2189dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_CONFIG, data->config); 21909431996fSJuerg Haefliger } 21919431996fSJuerg Haefliger /* Inform if part is not ready */ 21929431996fSJuerg Haefliger if (!(data->config & 0x04)) { 2193b237eb25SJuerg Haefliger dev_err(dev, "Device is not ready.\n"); 21949431996fSJuerg Haefliger return -EFAULT; 21959431996fSJuerg Haefliger } 21969431996fSJuerg Haefliger 2197ea694431SJuerg Haefliger /* Determine which optional fan and pwm features are enabled (only 2198ea694431SJuerg Haefliger * valid for I2C devices) */ 2199dbc2bc25SJean Delvare if (client) { /* I2C chip */ 2200dbc2bc25SJean Delvare data->config2 = dme1737_read(data, DME1737_REG_CONFIG2); 22019431996fSJuerg Haefliger /* Check if optional fan3 input is enabled */ 22029431996fSJuerg Haefliger if (data->config2 & 0x04) { 2203ea694431SJuerg Haefliger data->has_features |= HAS_FAN(2); 22049431996fSJuerg Haefliger } 22059431996fSJuerg Haefliger 22069431996fSJuerg Haefliger /* Fan4 and pwm3 are only available if the client's I2C address 2207e95c237dSJuerg Haefliger * is the default 0x2e. Otherwise the I/Os associated with 2208e95c237dSJuerg Haefliger * these functions are used for addr enable/select. */ 2209dbc2bc25SJean Delvare if (client->addr == 0x2e) { 2210ea694431SJuerg Haefliger data->has_features |= HAS_FAN(3) | HAS_PWM(2); 22119431996fSJuerg Haefliger } 22129431996fSJuerg Haefliger 2213e95c237dSJuerg Haefliger /* Determine which of the optional fan[5-6] and pwm[5-6] 2214e95c237dSJuerg Haefliger * features are enabled. For this, we need to query the runtime 2215e95c237dSJuerg Haefliger * registers through the Super-IO LPC interface. Try both 2216e95c237dSJuerg Haefliger * config ports 0x2e and 0x4e. */ 2217b237eb25SJuerg Haefliger if (dme1737_i2c_get_features(0x2e, data) && 2218b237eb25SJuerg Haefliger dme1737_i2c_get_features(0x4e, data)) { 2219b237eb25SJuerg Haefliger dev_warn(dev, "Failed to query Super-IO for optional " 22209431996fSJuerg Haefliger "features.\n"); 22219431996fSJuerg Haefliger } 2222e95c237dSJuerg Haefliger } 22239431996fSJuerg Haefliger 2224ea694431SJuerg Haefliger /* Fan[1-2] and pwm[1-2] are present in all chips */ 2225ea694431SJuerg Haefliger data->has_features |= HAS_FAN(0) | HAS_FAN(1) | HAS_PWM(0) | HAS_PWM(1); 2226ea694431SJuerg Haefliger 2227ea694431SJuerg Haefliger /* Chip-dependent features */ 2228ea694431SJuerg Haefliger switch (data->type) { 2229ea694431SJuerg Haefliger case dme1737: 2230ea694431SJuerg Haefliger data->has_features |= HAS_TEMP_OFFSET | HAS_VID | HAS_ZONE3 | 2231ea694431SJuerg Haefliger HAS_ZONE_HYST | HAS_PWM_MIN; 2232ea694431SJuerg Haefliger break; 2233ea694431SJuerg Haefliger case sch311x: 2234ea694431SJuerg Haefliger data->has_features |= HAS_TEMP_OFFSET | HAS_ZONE3 | 2235ea694431SJuerg Haefliger HAS_ZONE_HYST | HAS_PWM_MIN | HAS_FAN(2) | HAS_PWM(2); 2236ea694431SJuerg Haefliger break; 2237ea694431SJuerg Haefliger case sch5027: 2238ea694431SJuerg Haefliger data->has_features |= HAS_ZONE3; 2239ea694431SJuerg Haefliger break; 2240ea694431SJuerg Haefliger case sch5127: 2241d4b94e1fSJuerg Haefliger data->has_features |= HAS_FAN(2) | HAS_PWM(2) | HAS_IN7; 2242ea694431SJuerg Haefliger break; 2243ea694431SJuerg Haefliger default: 2244ea694431SJuerg Haefliger break; 2245ea694431SJuerg Haefliger } 22469431996fSJuerg Haefliger 2247b237eb25SJuerg Haefliger dev_info(dev, "Optional features: pwm3=%s, pwm5=%s, pwm6=%s, " 22489431996fSJuerg Haefliger "fan3=%s, fan4=%s, fan5=%s, fan6=%s.\n", 2249ea694431SJuerg Haefliger (data->has_features & HAS_PWM(2)) ? "yes" : "no", 2250ea694431SJuerg Haefliger (data->has_features & HAS_PWM(4)) ? "yes" : "no", 2251ea694431SJuerg Haefliger (data->has_features & HAS_PWM(5)) ? "yes" : "no", 2252ea694431SJuerg Haefliger (data->has_features & HAS_FAN(2)) ? "yes" : "no", 2253ea694431SJuerg Haefliger (data->has_features & HAS_FAN(3)) ? "yes" : "no", 2254ea694431SJuerg Haefliger (data->has_features & HAS_FAN(4)) ? "yes" : "no", 2255ea694431SJuerg Haefliger (data->has_features & HAS_FAN(5)) ? "yes" : "no"); 22569431996fSJuerg Haefliger 2257dbc2bc25SJean Delvare reg = dme1737_read(data, DME1737_REG_TACH_PWM); 22589431996fSJuerg Haefliger /* Inform if fan-to-pwm mapping differs from the default */ 2259dbc2bc25SJean Delvare if (client && reg != 0xa4) { /* I2C chip */ 2260b237eb25SJuerg Haefliger dev_warn(dev, "Non-standard fan to pwm mapping: " 22619431996fSJuerg Haefliger "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d, " 22629431996fSJuerg Haefliger "fan4->pwm%d. Please report to the driver " 22639431996fSJuerg Haefliger "maintainer.\n", 22649431996fSJuerg Haefliger (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1, 22659431996fSJuerg Haefliger ((reg >> 4) & 0x03) + 1, ((reg >> 6) & 0x03) + 1); 2266dbc2bc25SJean Delvare } else if (!client && reg != 0x24) { /* ISA chip */ 2267e95c237dSJuerg Haefliger dev_warn(dev, "Non-standard fan to pwm mapping: " 2268e95c237dSJuerg Haefliger "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d. " 2269e95c237dSJuerg Haefliger "Please report to the driver maintainer.\n", 2270e95c237dSJuerg Haefliger (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1, 2271e95c237dSJuerg Haefliger ((reg >> 4) & 0x03) + 1); 22729431996fSJuerg Haefliger } 22739431996fSJuerg Haefliger 22749431996fSJuerg Haefliger /* Switch pwm[1-3] to manual mode if they are currently disabled and 22759431996fSJuerg Haefliger * set the duty-cycles to 0% (which is identical to the PWMs being 22769431996fSJuerg Haefliger * disabled). */ 22779431996fSJuerg Haefliger if (!(data->config & 0x02)) { 22789431996fSJuerg Haefliger for (ix = 0; ix < 3; ix++) { 2279dbc2bc25SJean Delvare data->pwm_config[ix] = dme1737_read(data, 22809431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 2281ea694431SJuerg Haefliger if ((data->has_features & HAS_PWM(ix)) && 22829431996fSJuerg Haefliger (PWM_EN_FROM_REG(data->pwm_config[ix]) == -1)) { 2283b237eb25SJuerg Haefliger dev_info(dev, "Switching pwm%d to " 22849431996fSJuerg Haefliger "manual mode.\n", ix + 1); 22859431996fSJuerg Haefliger data->pwm_config[ix] = PWM_EN_TO_REG(1, 22869431996fSJuerg Haefliger data->pwm_config[ix]); 2287dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM(ix), 0); 2288dbc2bc25SJean Delvare dme1737_write(data, 22899431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix), 22909431996fSJuerg Haefliger data->pwm_config[ix]); 22919431996fSJuerg Haefliger } 22929431996fSJuerg Haefliger } 22939431996fSJuerg Haefliger } 22949431996fSJuerg Haefliger 22959431996fSJuerg Haefliger /* Initialize the default PWM auto channels zone (acz) assignments */ 22969431996fSJuerg Haefliger data->pwm_acz[0] = 1; /* pwm1 -> zone1 */ 22979431996fSJuerg Haefliger data->pwm_acz[1] = 2; /* pwm2 -> zone2 */ 22989431996fSJuerg Haefliger data->pwm_acz[2] = 4; /* pwm3 -> zone3 */ 22999431996fSJuerg Haefliger 23009431996fSJuerg Haefliger /* Set VRM */ 2301ea694431SJuerg Haefliger if (data->has_features & HAS_VID) { 23029431996fSJuerg Haefliger data->vrm = vid_which_vrm(); 2303549edb83SJuerg Haefliger } 23049431996fSJuerg Haefliger 23059431996fSJuerg Haefliger return 0; 23069431996fSJuerg Haefliger } 23079431996fSJuerg Haefliger 230867e2f328SJuerg Haefliger /* --------------------------------------------------------------------- 230967e2f328SJuerg Haefliger * I2C device detection and registration 231067e2f328SJuerg Haefliger * --------------------------------------------------------------------- */ 231167e2f328SJuerg Haefliger 231267e2f328SJuerg Haefliger static struct i2c_driver dme1737_i2c_driver; 231367e2f328SJuerg Haefliger 231467e2f328SJuerg Haefliger static int dme1737_i2c_get_features(int sio_cip, struct dme1737_data *data) 231567e2f328SJuerg Haefliger { 23169431996fSJuerg Haefliger int err = 0, reg; 23179431996fSJuerg Haefliger u16 addr; 23189431996fSJuerg Haefliger 231967e2f328SJuerg Haefliger dme1737_sio_enter(sio_cip); 23209431996fSJuerg Haefliger 23219431996fSJuerg Haefliger /* Check device ID 2322ea694431SJuerg Haefliger * We currently know about two kinds of DME1737 and SCH5027. */ 2323345a2224SJuerg Haefliger reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20); 2324ea694431SJuerg Haefliger if (!(reg == DME1737_ID_1 || reg == DME1737_ID_2 || 2325ea694431SJuerg Haefliger reg == SCH5027_ID)) { 23269431996fSJuerg Haefliger err = -ENODEV; 23279431996fSJuerg Haefliger goto exit; 23289431996fSJuerg Haefliger } 23299431996fSJuerg Haefliger 23309431996fSJuerg Haefliger /* Select logical device A (runtime registers) */ 23319431996fSJuerg Haefliger dme1737_sio_outb(sio_cip, 0x07, 0x0a); 23329431996fSJuerg Haefliger 23339431996fSJuerg Haefliger /* Get the base address of the runtime registers */ 2334*06f3d9fbSJuerg Haefliger addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) | 2335*06f3d9fbSJuerg Haefliger dme1737_sio_inb(sio_cip, 0x61); 2336*06f3d9fbSJuerg Haefliger if (!addr) { 23379431996fSJuerg Haefliger err = -ENODEV; 23389431996fSJuerg Haefliger goto exit; 23399431996fSJuerg Haefliger } 23409431996fSJuerg Haefliger 23419431996fSJuerg Haefliger /* Read the runtime registers to determine which optional features 23429431996fSJuerg Haefliger * are enabled and available. Bits [3:2] of registers 0x43-0x46 are set 23439431996fSJuerg Haefliger * to '10' if the respective feature is enabled. */ 23449431996fSJuerg Haefliger if ((inb(addr + 0x43) & 0x0c) == 0x08) { /* fan6 */ 2345ea694431SJuerg Haefliger data->has_features |= HAS_FAN(5); 23469431996fSJuerg Haefliger } 23479431996fSJuerg Haefliger if ((inb(addr + 0x44) & 0x0c) == 0x08) { /* pwm6 */ 2348ea694431SJuerg Haefliger data->has_features |= HAS_PWM(5); 23499431996fSJuerg Haefliger } 23509431996fSJuerg Haefliger if ((inb(addr + 0x45) & 0x0c) == 0x08) { /* fan5 */ 2351ea694431SJuerg Haefliger data->has_features |= HAS_FAN(4); 23529431996fSJuerg Haefliger } 23539431996fSJuerg Haefliger if ((inb(addr + 0x46) & 0x0c) == 0x08) { /* pwm5 */ 2354ea694431SJuerg Haefliger data->has_features |= HAS_PWM(4); 23559431996fSJuerg Haefliger } 23569431996fSJuerg Haefliger 23579431996fSJuerg Haefliger exit: 235867e2f328SJuerg Haefliger dme1737_sio_exit(sio_cip); 23599431996fSJuerg Haefliger 23609431996fSJuerg Haefliger return err; 23619431996fSJuerg Haefliger } 23629431996fSJuerg Haefliger 236367a37308SJean Delvare /* Return 0 if detection is successful, -ENODEV otherwise */ 2364310ec792SJean Delvare static int dme1737_i2c_detect(struct i2c_client *client, 236567a37308SJean Delvare struct i2c_board_info *info) 23669431996fSJuerg Haefliger { 236767a37308SJean Delvare struct i2c_adapter *adapter = client->adapter; 236867a37308SJean Delvare struct device *dev = &adapter->dev; 23699431996fSJuerg Haefliger u8 company, verstep = 0; 23709431996fSJuerg Haefliger const char *name; 23719431996fSJuerg Haefliger 23729431996fSJuerg Haefliger if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 237367a37308SJean Delvare return -ENODEV; 23749431996fSJuerg Haefliger } 23759431996fSJuerg Haefliger 237667a37308SJean Delvare company = i2c_smbus_read_byte_data(client, DME1737_REG_COMPANY); 237767a37308SJean Delvare verstep = i2c_smbus_read_byte_data(client, DME1737_REG_VERSTEP); 23789431996fSJuerg Haefliger 2379549edb83SJuerg Haefliger if (company == DME1737_COMPANY_SMSC && 2380549edb83SJuerg Haefliger verstep == SCH5027_VERSTEP) { 238152df6440SJean Delvare name = "sch5027"; 238252df6440SJean Delvare } else if (company == DME1737_COMPANY_SMSC && 238352df6440SJean Delvare (verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP) { 238452df6440SJean Delvare name = "dme1737"; 2385549edb83SJuerg Haefliger } else { 238667a37308SJean Delvare return -ENODEV; 23879431996fSJuerg Haefliger } 23889431996fSJuerg Haefliger 2389549edb83SJuerg Haefliger dev_info(dev, "Found a %s chip at 0x%02x (rev 0x%02x).\n", 239052df6440SJean Delvare verstep == SCH5027_VERSTEP ? "SCH5027" : "DME1737", 239152df6440SJean Delvare client->addr, verstep); 239267a37308SJean Delvare strlcpy(info->type, name, I2C_NAME_SIZE); 239367a37308SJean Delvare 239467a37308SJean Delvare return 0; 239567a37308SJean Delvare } 239667a37308SJean Delvare 239767a37308SJean Delvare static int dme1737_i2c_probe(struct i2c_client *client, 239867a37308SJean Delvare const struct i2c_device_id *id) 239967a37308SJean Delvare { 240067a37308SJean Delvare struct dme1737_data *data; 240167a37308SJean Delvare struct device *dev = &client->dev; 240267a37308SJean Delvare int err; 240367a37308SJean Delvare 240467a37308SJean Delvare data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL); 240567a37308SJean Delvare if (!data) { 240667a37308SJean Delvare err = -ENOMEM; 240767a37308SJean Delvare goto exit; 240867a37308SJean Delvare } 240967a37308SJean Delvare 241067a37308SJean Delvare i2c_set_clientdata(client, data); 241167a37308SJean Delvare data->type = id->driver_data; 241267a37308SJean Delvare data->client = client; 241367a37308SJean Delvare data->name = client->name; 241467a37308SJean Delvare mutex_init(&data->update_lock); 2415b237eb25SJuerg Haefliger 24169431996fSJuerg Haefliger /* Initialize the DME1737 chip */ 2417*06f3d9fbSJuerg Haefliger err = dme1737_init_device(dev); 2418*06f3d9fbSJuerg Haefliger if (err) { 2419b237eb25SJuerg Haefliger dev_err(dev, "Failed to initialize device.\n"); 242067a37308SJean Delvare goto exit_kfree; 24219431996fSJuerg Haefliger } 24229431996fSJuerg Haefliger 2423b237eb25SJuerg Haefliger /* Create sysfs files */ 2424*06f3d9fbSJuerg Haefliger err = dme1737_create_files(dev); 2425*06f3d9fbSJuerg Haefliger if (err) { 2426b237eb25SJuerg Haefliger dev_err(dev, "Failed to create sysfs files.\n"); 242767a37308SJean Delvare goto exit_kfree; 24289431996fSJuerg Haefliger } 24299431996fSJuerg Haefliger 24309431996fSJuerg Haefliger /* Register device */ 243162ee3e10SMark M. Hoffman data->hwmon_dev = hwmon_device_register(dev); 24321beeffe4STony Jones if (IS_ERR(data->hwmon_dev)) { 2433b237eb25SJuerg Haefliger dev_err(dev, "Failed to register device.\n"); 24341beeffe4STony Jones err = PTR_ERR(data->hwmon_dev); 24359431996fSJuerg Haefliger goto exit_remove; 24369431996fSJuerg Haefliger } 24379431996fSJuerg Haefliger 24389431996fSJuerg Haefliger return 0; 24399431996fSJuerg Haefliger 24409431996fSJuerg Haefliger exit_remove: 2441b237eb25SJuerg Haefliger dme1737_remove_files(dev); 24429431996fSJuerg Haefliger exit_kfree: 24439431996fSJuerg Haefliger kfree(data); 24449431996fSJuerg Haefliger exit: 24459431996fSJuerg Haefliger return err; 24469431996fSJuerg Haefliger } 24479431996fSJuerg Haefliger 244867a37308SJean Delvare static int dme1737_i2c_remove(struct i2c_client *client) 24499431996fSJuerg Haefliger { 24509431996fSJuerg Haefliger struct dme1737_data *data = i2c_get_clientdata(client); 24519431996fSJuerg Haefliger 24521beeffe4STony Jones hwmon_device_unregister(data->hwmon_dev); 2453b237eb25SJuerg Haefliger dme1737_remove_files(&client->dev); 24549431996fSJuerg Haefliger 24559431996fSJuerg Haefliger kfree(data); 24569431996fSJuerg Haefliger return 0; 24579431996fSJuerg Haefliger } 24589431996fSJuerg Haefliger 245967a37308SJean Delvare static const struct i2c_device_id dme1737_id[] = { 246067a37308SJean Delvare { "dme1737", dme1737 }, 246167a37308SJean Delvare { "sch5027", sch5027 }, 246267a37308SJean Delvare { } 246367a37308SJean Delvare }; 246467a37308SJean Delvare MODULE_DEVICE_TABLE(i2c, dme1737_id); 246567a37308SJean Delvare 2466b237eb25SJuerg Haefliger static struct i2c_driver dme1737_i2c_driver = { 246767a37308SJean Delvare .class = I2C_CLASS_HWMON, 24689431996fSJuerg Haefliger .driver = { 24699431996fSJuerg Haefliger .name = "dme1737", 24709431996fSJuerg Haefliger }, 247167a37308SJean Delvare .probe = dme1737_i2c_probe, 247267a37308SJean Delvare .remove = dme1737_i2c_remove, 247367a37308SJean Delvare .id_table = dme1737_id, 247467a37308SJean Delvare .detect = dme1737_i2c_detect, 2475c3813d6aSJean Delvare .address_list = normal_i2c, 24769431996fSJuerg Haefliger }; 24779431996fSJuerg Haefliger 247867e2f328SJuerg Haefliger /* --------------------------------------------------------------------- 2479e95c237dSJuerg Haefliger * ISA device detection and registration 2480e95c237dSJuerg Haefliger * --------------------------------------------------------------------- */ 2481e95c237dSJuerg Haefliger 2482e95c237dSJuerg Haefliger static int __init dme1737_isa_detect(int sio_cip, unsigned short *addr) 2483e95c237dSJuerg Haefliger { 2484e95c237dSJuerg Haefliger int err = 0, reg; 2485e95c237dSJuerg Haefliger unsigned short base_addr; 2486e95c237dSJuerg Haefliger 2487e95c237dSJuerg Haefliger dme1737_sio_enter(sio_cip); 2488e95c237dSJuerg Haefliger 2489e95c237dSJuerg Haefliger /* Check device ID 2490ea694431SJuerg Haefliger * We currently know about SCH3112, SCH3114, SCH3116, and SCH5127 */ 249167b671bcSJean Delvare reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20); 2492ea694431SJuerg Haefliger if (!(reg == SCH3112_ID || reg == SCH3114_ID || reg == SCH3116_ID || 2493ea694431SJuerg Haefliger reg == SCH5127_ID)) { 2494e95c237dSJuerg Haefliger err = -ENODEV; 2495e95c237dSJuerg Haefliger goto exit; 2496e95c237dSJuerg Haefliger } 2497e95c237dSJuerg Haefliger 2498e95c237dSJuerg Haefliger /* Select logical device A (runtime registers) */ 2499e95c237dSJuerg Haefliger dme1737_sio_outb(sio_cip, 0x07, 0x0a); 2500e95c237dSJuerg Haefliger 2501e95c237dSJuerg Haefliger /* Get the base address of the runtime registers */ 2502*06f3d9fbSJuerg Haefliger base_addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) | 2503*06f3d9fbSJuerg Haefliger dme1737_sio_inb(sio_cip, 0x61); 2504*06f3d9fbSJuerg Haefliger if (!base_addr) { 25059c6e13b4SJoe Perches pr_err("Base address not set\n"); 2506e95c237dSJuerg Haefliger err = -ENODEV; 2507e95c237dSJuerg Haefliger goto exit; 2508e95c237dSJuerg Haefliger } 2509e95c237dSJuerg Haefliger 2510e95c237dSJuerg Haefliger /* Access to the hwmon registers is through an index/data register 2511e95c237dSJuerg Haefliger * pair located at offset 0x70/0x71. */ 2512e95c237dSJuerg Haefliger *addr = base_addr + 0x70; 2513e95c237dSJuerg Haefliger 2514e95c237dSJuerg Haefliger exit: 2515e95c237dSJuerg Haefliger dme1737_sio_exit(sio_cip); 2516e95c237dSJuerg Haefliger return err; 2517e95c237dSJuerg Haefliger } 2518e95c237dSJuerg Haefliger 2519e95c237dSJuerg Haefliger static int __init dme1737_isa_device_add(unsigned short addr) 2520e95c237dSJuerg Haefliger { 2521e95c237dSJuerg Haefliger struct resource res = { 2522e95c237dSJuerg Haefliger .start = addr, 2523e95c237dSJuerg Haefliger .end = addr + DME1737_EXTENT - 1, 2524e95c237dSJuerg Haefliger .name = "dme1737", 2525e95c237dSJuerg Haefliger .flags = IORESOURCE_IO, 2526e95c237dSJuerg Haefliger }; 2527e95c237dSJuerg Haefliger int err; 2528e95c237dSJuerg Haefliger 2529b9acb64aSJean Delvare err = acpi_check_resource_conflict(&res); 2530b9acb64aSJean Delvare if (err) 2531b9acb64aSJean Delvare goto exit; 2532b9acb64aSJean Delvare 2533*06f3d9fbSJuerg Haefliger pdev = platform_device_alloc("dme1737", addr); 2534*06f3d9fbSJuerg Haefliger if (!pdev) { 25359c6e13b4SJoe Perches pr_err("Failed to allocate device\n"); 2536e95c237dSJuerg Haefliger err = -ENOMEM; 2537e95c237dSJuerg Haefliger goto exit; 2538e95c237dSJuerg Haefliger } 2539e95c237dSJuerg Haefliger 2540*06f3d9fbSJuerg Haefliger err = platform_device_add_resources(pdev, &res, 1); 2541*06f3d9fbSJuerg Haefliger if (err) { 25429c6e13b4SJoe Perches pr_err("Failed to add device resource (err = %d)\n", err); 2543e95c237dSJuerg Haefliger goto exit_device_put; 2544e95c237dSJuerg Haefliger } 2545e95c237dSJuerg Haefliger 2546*06f3d9fbSJuerg Haefliger err = platform_device_add(pdev); 2547*06f3d9fbSJuerg Haefliger if (err) { 25489c6e13b4SJoe Perches pr_err("Failed to add device (err = %d)\n", err); 2549e95c237dSJuerg Haefliger goto exit_device_put; 2550e95c237dSJuerg Haefliger } 2551e95c237dSJuerg Haefliger 2552e95c237dSJuerg Haefliger return 0; 2553e95c237dSJuerg Haefliger 2554e95c237dSJuerg Haefliger exit_device_put: 2555e95c237dSJuerg Haefliger platform_device_put(pdev); 2556e95c237dSJuerg Haefliger pdev = NULL; 2557e95c237dSJuerg Haefliger exit: 2558e95c237dSJuerg Haefliger return err; 2559e95c237dSJuerg Haefliger } 2560e95c237dSJuerg Haefliger 2561e95c237dSJuerg Haefliger static int __devinit dme1737_isa_probe(struct platform_device *pdev) 2562e95c237dSJuerg Haefliger { 2563e95c237dSJuerg Haefliger u8 company, device; 2564e95c237dSJuerg Haefliger struct resource *res; 2565e95c237dSJuerg Haefliger struct dme1737_data *data; 2566e95c237dSJuerg Haefliger struct device *dev = &pdev->dev; 2567e95c237dSJuerg Haefliger int err; 2568e95c237dSJuerg Haefliger 2569e95c237dSJuerg Haefliger res = platform_get_resource(pdev, IORESOURCE_IO, 0); 2570e95c237dSJuerg Haefliger if (!request_region(res->start, DME1737_EXTENT, "dme1737")) { 2571e95c237dSJuerg Haefliger dev_err(dev, "Failed to request region 0x%04x-0x%04x.\n", 2572e95c237dSJuerg Haefliger (unsigned short)res->start, 2573e95c237dSJuerg Haefliger (unsigned short)res->start + DME1737_EXTENT - 1); 2574e95c237dSJuerg Haefliger err = -EBUSY; 2575e95c237dSJuerg Haefliger goto exit; 2576e95c237dSJuerg Haefliger } 2577e95c237dSJuerg Haefliger 2578*06f3d9fbSJuerg Haefliger data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL); 2579*06f3d9fbSJuerg Haefliger if (!data) { 2580e95c237dSJuerg Haefliger err = -ENOMEM; 2581e95c237dSJuerg Haefliger goto exit_release_region; 2582e95c237dSJuerg Haefliger } 2583e95c237dSJuerg Haefliger 2584dbc2bc25SJean Delvare data->addr = res->start; 2585e95c237dSJuerg Haefliger platform_set_drvdata(pdev, data); 2586e95c237dSJuerg Haefliger 258755d68d75SJuerg Haefliger /* Skip chip detection if module is loaded with force_id parameter */ 2588ea694431SJuerg Haefliger switch (force_id) { 2589ea694431SJuerg Haefliger case SCH3112_ID: 2590ea694431SJuerg Haefliger case SCH3114_ID: 2591ea694431SJuerg Haefliger case SCH3116_ID: 2592ea694431SJuerg Haefliger data->type = sch311x; 2593ea694431SJuerg Haefliger break; 2594ea694431SJuerg Haefliger case SCH5127_ID: 2595ea694431SJuerg Haefliger data->type = sch5127; 2596ea694431SJuerg Haefliger break; 2597ea694431SJuerg Haefliger default: 2598dbc2bc25SJean Delvare company = dme1737_read(data, DME1737_REG_COMPANY); 2599dbc2bc25SJean Delvare device = dme1737_read(data, DME1737_REG_DEVICE); 2600e95c237dSJuerg Haefliger 2601ea694431SJuerg Haefliger if ((company == DME1737_COMPANY_SMSC) && 2602ea694431SJuerg Haefliger (device == SCH311X_DEVICE)) { 2603ea694431SJuerg Haefliger data->type = sch311x; 2604ea694431SJuerg Haefliger } else if ((company == DME1737_COMPANY_SMSC) && 2605ea694431SJuerg Haefliger (device == SCH5127_DEVICE)) { 2606ea694431SJuerg Haefliger data->type = sch5127; 2607ea694431SJuerg Haefliger } else { 2608e95c237dSJuerg Haefliger err = -ENODEV; 2609e95c237dSJuerg Haefliger goto exit_kfree; 2610e95c237dSJuerg Haefliger } 261155d68d75SJuerg Haefliger } 2612e95c237dSJuerg Haefliger 2613ea694431SJuerg Haefliger if (data->type == sch5127) { 2614ea694431SJuerg Haefliger data->name = "sch5127"; 2615ea694431SJuerg Haefliger } else { 2616dbc2bc25SJean Delvare data->name = "sch311x"; 2617ea694431SJuerg Haefliger } 2618ea694431SJuerg Haefliger 2619ea694431SJuerg Haefliger /* Initialize the mutex */ 2620e95c237dSJuerg Haefliger mutex_init(&data->update_lock); 2621e95c237dSJuerg Haefliger 2622ea694431SJuerg Haefliger dev_info(dev, "Found a %s chip at 0x%04x\n", 2623ea694431SJuerg Haefliger data->type == sch5127 ? "SCH5127" : "SCH311x", data->addr); 2624e95c237dSJuerg Haefliger 2625e95c237dSJuerg Haefliger /* Initialize the chip */ 2626*06f3d9fbSJuerg Haefliger err = dme1737_init_device(dev); 2627*06f3d9fbSJuerg Haefliger if (err) { 2628e95c237dSJuerg Haefliger dev_err(dev, "Failed to initialize device.\n"); 2629e95c237dSJuerg Haefliger goto exit_kfree; 2630e95c237dSJuerg Haefliger } 2631e95c237dSJuerg Haefliger 2632e95c237dSJuerg Haefliger /* Create sysfs files */ 2633*06f3d9fbSJuerg Haefliger err = dme1737_create_files(dev); 2634*06f3d9fbSJuerg Haefliger if (err) { 2635e95c237dSJuerg Haefliger dev_err(dev, "Failed to create sysfs files.\n"); 2636e95c237dSJuerg Haefliger goto exit_kfree; 2637e95c237dSJuerg Haefliger } 2638e95c237dSJuerg Haefliger 2639e95c237dSJuerg Haefliger /* Register device */ 2640e95c237dSJuerg Haefliger data->hwmon_dev = hwmon_device_register(dev); 2641e95c237dSJuerg Haefliger if (IS_ERR(data->hwmon_dev)) { 2642e95c237dSJuerg Haefliger dev_err(dev, "Failed to register device.\n"); 2643e95c237dSJuerg Haefliger err = PTR_ERR(data->hwmon_dev); 2644e95c237dSJuerg Haefliger goto exit_remove_files; 2645e95c237dSJuerg Haefliger } 2646e95c237dSJuerg Haefliger 2647e95c237dSJuerg Haefliger return 0; 2648e95c237dSJuerg Haefliger 2649e95c237dSJuerg Haefliger exit_remove_files: 2650e95c237dSJuerg Haefliger dme1737_remove_files(dev); 2651e95c237dSJuerg Haefliger exit_kfree: 2652e95c237dSJuerg Haefliger platform_set_drvdata(pdev, NULL); 2653e95c237dSJuerg Haefliger kfree(data); 2654e95c237dSJuerg Haefliger exit_release_region: 2655e95c237dSJuerg Haefliger release_region(res->start, DME1737_EXTENT); 2656e95c237dSJuerg Haefliger exit: 2657e95c237dSJuerg Haefliger return err; 2658e95c237dSJuerg Haefliger } 2659e95c237dSJuerg Haefliger 2660e95c237dSJuerg Haefliger static int __devexit dme1737_isa_remove(struct platform_device *pdev) 2661e95c237dSJuerg Haefliger { 2662e95c237dSJuerg Haefliger struct dme1737_data *data = platform_get_drvdata(pdev); 2663e95c237dSJuerg Haefliger 2664e95c237dSJuerg Haefliger hwmon_device_unregister(data->hwmon_dev); 2665e95c237dSJuerg Haefliger dme1737_remove_files(&pdev->dev); 2666dbc2bc25SJean Delvare release_region(data->addr, DME1737_EXTENT); 2667e95c237dSJuerg Haefliger platform_set_drvdata(pdev, NULL); 2668e95c237dSJuerg Haefliger kfree(data); 2669e95c237dSJuerg Haefliger 2670e95c237dSJuerg Haefliger return 0; 2671e95c237dSJuerg Haefliger } 2672e95c237dSJuerg Haefliger 2673e95c237dSJuerg Haefliger static struct platform_driver dme1737_isa_driver = { 2674e95c237dSJuerg Haefliger .driver = { 2675e95c237dSJuerg Haefliger .owner = THIS_MODULE, 2676e95c237dSJuerg Haefliger .name = "dme1737", 2677e95c237dSJuerg Haefliger }, 2678e95c237dSJuerg Haefliger .probe = dme1737_isa_probe, 2679e95c237dSJuerg Haefliger .remove = __devexit_p(dme1737_isa_remove), 2680e95c237dSJuerg Haefliger }; 2681e95c237dSJuerg Haefliger 2682e95c237dSJuerg Haefliger /* --------------------------------------------------------------------- 268367e2f328SJuerg Haefliger * Module initialization and cleanup 268467e2f328SJuerg Haefliger * --------------------------------------------------------------------- */ 268567e2f328SJuerg Haefliger 26869431996fSJuerg Haefliger static int __init dme1737_init(void) 26879431996fSJuerg Haefliger { 2688e95c237dSJuerg Haefliger int err; 2689e95c237dSJuerg Haefliger unsigned short addr; 2690e95c237dSJuerg Haefliger 2691*06f3d9fbSJuerg Haefliger err = i2c_add_driver(&dme1737_i2c_driver); 2692*06f3d9fbSJuerg Haefliger if (err) { 2693e95c237dSJuerg Haefliger goto exit; 2694e95c237dSJuerg Haefliger } 2695e95c237dSJuerg Haefliger 2696e95c237dSJuerg Haefliger if (dme1737_isa_detect(0x2e, &addr) && 269792430b6fSJuerg Haefliger dme1737_isa_detect(0x4e, &addr) && 269892430b6fSJuerg Haefliger (!probe_all_addr || 269992430b6fSJuerg Haefliger (dme1737_isa_detect(0x162e, &addr) && 270092430b6fSJuerg Haefliger dme1737_isa_detect(0x164e, &addr)))) { 2701e95c237dSJuerg Haefliger /* Return 0 if we didn't find an ISA device */ 2702e95c237dSJuerg Haefliger return 0; 2703e95c237dSJuerg Haefliger } 2704e95c237dSJuerg Haefliger 2705*06f3d9fbSJuerg Haefliger err = platform_driver_register(&dme1737_isa_driver); 2706*06f3d9fbSJuerg Haefliger if (err) { 2707e95c237dSJuerg Haefliger goto exit_del_i2c_driver; 2708e95c237dSJuerg Haefliger } 2709e95c237dSJuerg Haefliger 2710e95c237dSJuerg Haefliger /* Sets global pdev as a side effect */ 2711*06f3d9fbSJuerg Haefliger err = dme1737_isa_device_add(addr); 2712*06f3d9fbSJuerg Haefliger if (err) { 2713e95c237dSJuerg Haefliger goto exit_del_isa_driver; 2714e95c237dSJuerg Haefliger } 2715e95c237dSJuerg Haefliger 2716e95c237dSJuerg Haefliger return 0; 2717e95c237dSJuerg Haefliger 2718e95c237dSJuerg Haefliger exit_del_isa_driver: 2719e95c237dSJuerg Haefliger platform_driver_unregister(&dme1737_isa_driver); 2720e95c237dSJuerg Haefliger exit_del_i2c_driver: 2721e95c237dSJuerg Haefliger i2c_del_driver(&dme1737_i2c_driver); 2722e95c237dSJuerg Haefliger exit: 2723e95c237dSJuerg Haefliger return err; 27249431996fSJuerg Haefliger } 27259431996fSJuerg Haefliger 27269431996fSJuerg Haefliger static void __exit dme1737_exit(void) 27279431996fSJuerg Haefliger { 2728e95c237dSJuerg Haefliger if (pdev) { 2729e95c237dSJuerg Haefliger platform_device_unregister(pdev); 2730e95c237dSJuerg Haefliger platform_driver_unregister(&dme1737_isa_driver); 2731e95c237dSJuerg Haefliger } 2732e95c237dSJuerg Haefliger 2733b237eb25SJuerg Haefliger i2c_del_driver(&dme1737_i2c_driver); 27349431996fSJuerg Haefliger } 27359431996fSJuerg Haefliger 27369431996fSJuerg Haefliger MODULE_AUTHOR("Juerg Haefliger <juergh@gmail.com>"); 27379431996fSJuerg Haefliger MODULE_DESCRIPTION("DME1737 sensors"); 27389431996fSJuerg Haefliger MODULE_LICENSE("GPL"); 27399431996fSJuerg Haefliger 27409431996fSJuerg Haefliger module_init(dme1737_init); 27419431996fSJuerg Haefliger module_exit(dme1737_exit); 2742