19431996fSJuerg Haefliger /* 2e95c237dSJuerg Haefliger * dme1737.c - Driver for the SMSC DME1737, Asus A8000, and SMSC SCH311x 3e95c237dSJuerg Haefliger * Super-I/O chips integrated hardware monitoring features. 49431996fSJuerg Haefliger * Copyright (c) 2007 Juerg Haefliger <juergh@gmail.com> 59431996fSJuerg Haefliger * 6e95c237dSJuerg Haefliger * This driver is an I2C/ISA hybrid, meaning that it uses the I2C bus to access 7e95c237dSJuerg Haefliger * the chip registers if a DME1737 (or A8000) is found and the ISA bus if a 8e95c237dSJuerg Haefliger * SCH311x chip is found. Both types of chips have very similar hardware 9e95c237dSJuerg Haefliger * monitoring capabilities but differ in the way they can be accessed. 109431996fSJuerg Haefliger * 119431996fSJuerg Haefliger * This program is free software; you can redistribute it and/or modify 129431996fSJuerg Haefliger * it under the terms of the GNU General Public License as published by 139431996fSJuerg Haefliger * the Free Software Foundation; either version 2 of the License, or 149431996fSJuerg Haefliger * (at your option) any later version. 159431996fSJuerg Haefliger * 169431996fSJuerg Haefliger * This program is distributed in the hope that it will be useful, 179431996fSJuerg Haefliger * but WITHOUT ANY WARRANTY; without even the implied warranty of 189431996fSJuerg Haefliger * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 199431996fSJuerg Haefliger * GNU General Public License for more details. 209431996fSJuerg Haefliger * 219431996fSJuerg Haefliger * You should have received a copy of the GNU General Public License 229431996fSJuerg Haefliger * along with this program; if not, write to the Free Software 239431996fSJuerg Haefliger * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 249431996fSJuerg Haefliger */ 259431996fSJuerg Haefliger 269431996fSJuerg Haefliger #include <linux/module.h> 279431996fSJuerg Haefliger #include <linux/init.h> 289431996fSJuerg Haefliger #include <linux/slab.h> 299431996fSJuerg Haefliger #include <linux/jiffies.h> 309431996fSJuerg Haefliger #include <linux/i2c.h> 31e95c237dSJuerg Haefliger #include <linux/platform_device.h> 329431996fSJuerg Haefliger #include <linux/hwmon.h> 339431996fSJuerg Haefliger #include <linux/hwmon-sysfs.h> 349431996fSJuerg Haefliger #include <linux/hwmon-vid.h> 359431996fSJuerg Haefliger #include <linux/err.h> 369431996fSJuerg Haefliger #include <linux/mutex.h> 379431996fSJuerg Haefliger #include <asm/io.h> 389431996fSJuerg Haefliger 39e95c237dSJuerg Haefliger /* ISA device, if found */ 40e95c237dSJuerg Haefliger static struct platform_device *pdev; 41e95c237dSJuerg Haefliger 429431996fSJuerg Haefliger /* Module load parameters */ 439431996fSJuerg Haefliger static int force_start; 449431996fSJuerg Haefliger module_param(force_start, bool, 0); 459431996fSJuerg Haefliger MODULE_PARM_DESC(force_start, "Force the chip to start monitoring inputs"); 469431996fSJuerg Haefliger 4767b671bcSJean Delvare static unsigned short force_id; 4867b671bcSJean Delvare module_param(force_id, ushort, 0); 4967b671bcSJean Delvare MODULE_PARM_DESC(force_id, "Override the detected device ID"); 5067b671bcSJean Delvare 519431996fSJuerg Haefliger /* Addresses to scan */ 5225e9c86dSMark M. Hoffman static const unsigned short normal_i2c[] = {0x2c, 0x2d, 0x2e, I2C_CLIENT_END}; 539431996fSJuerg Haefliger 549431996fSJuerg Haefliger /* Insmod parameters */ 559431996fSJuerg Haefliger I2C_CLIENT_INSMOD_1(dme1737); 569431996fSJuerg Haefliger 579431996fSJuerg Haefliger /* --------------------------------------------------------------------- 589431996fSJuerg Haefliger * Registers 599431996fSJuerg Haefliger * 609431996fSJuerg Haefliger * The sensors are defined as follows: 619431996fSJuerg Haefliger * 629431996fSJuerg Haefliger * Voltages Temperatures 639431996fSJuerg Haefliger * -------- ------------ 649431996fSJuerg Haefliger * in0 +5VTR (+5V stdby) temp1 Remote diode 1 659431996fSJuerg Haefliger * in1 Vccp (proc core) temp2 Internal temp 669431996fSJuerg Haefliger * in2 VCC (internal +3.3V) temp3 Remote diode 2 679431996fSJuerg Haefliger * in3 +5V 689431996fSJuerg Haefliger * in4 +12V 699431996fSJuerg Haefliger * in5 VTR (+3.3V stby) 709431996fSJuerg Haefliger * in6 Vbat 719431996fSJuerg Haefliger * 729431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 739431996fSJuerg Haefliger 749431996fSJuerg Haefliger /* Voltages (in) numbered 0-6 (ix) */ 759431996fSJuerg Haefliger #define DME1737_REG_IN(ix) ((ix) < 5 ? 0x20 + (ix) \ 769431996fSJuerg Haefliger : 0x94 + (ix)) 779431996fSJuerg Haefliger #define DME1737_REG_IN_MIN(ix) ((ix) < 5 ? 0x44 + (ix) * 2 \ 789431996fSJuerg Haefliger : 0x91 + (ix) * 2) 799431996fSJuerg Haefliger #define DME1737_REG_IN_MAX(ix) ((ix) < 5 ? 0x45 + (ix) * 2 \ 809431996fSJuerg Haefliger : 0x92 + (ix) * 2) 819431996fSJuerg Haefliger 829431996fSJuerg Haefliger /* Temperatures (temp) numbered 0-2 (ix) */ 839431996fSJuerg Haefliger #define DME1737_REG_TEMP(ix) (0x25 + (ix)) 849431996fSJuerg Haefliger #define DME1737_REG_TEMP_MIN(ix) (0x4e + (ix) * 2) 859431996fSJuerg Haefliger #define DME1737_REG_TEMP_MAX(ix) (0x4f + (ix) * 2) 869431996fSJuerg Haefliger #define DME1737_REG_TEMP_OFFSET(ix) ((ix) == 0 ? 0x1f \ 879431996fSJuerg Haefliger : 0x1c + (ix)) 889431996fSJuerg Haefliger 899431996fSJuerg Haefliger /* Voltage and temperature LSBs 909431996fSJuerg Haefliger * The LSBs (4 bits each) are stored in 5 registers with the following layouts: 919431996fSJuerg Haefliger * IN_TEMP_LSB(0) = [in5, in6] 929431996fSJuerg Haefliger * IN_TEMP_LSB(1) = [temp3, temp1] 939431996fSJuerg Haefliger * IN_TEMP_LSB(2) = [in4, temp2] 949431996fSJuerg Haefliger * IN_TEMP_LSB(3) = [in3, in0] 959431996fSJuerg Haefliger * IN_TEMP_LSB(4) = [in2, in1] */ 969431996fSJuerg Haefliger #define DME1737_REG_IN_TEMP_LSB(ix) (0x84 + (ix)) 979431996fSJuerg Haefliger static const u8 DME1737_REG_IN_LSB[] = {3, 4, 4, 3, 2, 0, 0}; 989431996fSJuerg Haefliger static const u8 DME1737_REG_IN_LSB_SHL[] = {4, 4, 0, 0, 0, 0, 4}; 999431996fSJuerg Haefliger static const u8 DME1737_REG_TEMP_LSB[] = {1, 2, 1}; 1009431996fSJuerg Haefliger static const u8 DME1737_REG_TEMP_LSB_SHL[] = {4, 4, 0}; 1019431996fSJuerg Haefliger 1029431996fSJuerg Haefliger /* Fans numbered 0-5 (ix) */ 1039431996fSJuerg Haefliger #define DME1737_REG_FAN(ix) ((ix) < 4 ? 0x28 + (ix) * 2 \ 1049431996fSJuerg Haefliger : 0xa1 + (ix) * 2) 1059431996fSJuerg Haefliger #define DME1737_REG_FAN_MIN(ix) ((ix) < 4 ? 0x54 + (ix) * 2 \ 1069431996fSJuerg Haefliger : 0xa5 + (ix) * 2) 1079431996fSJuerg Haefliger #define DME1737_REG_FAN_OPT(ix) ((ix) < 4 ? 0x90 + (ix) \ 1089431996fSJuerg Haefliger : 0xb2 + (ix)) 1099431996fSJuerg Haefliger #define DME1737_REG_FAN_MAX(ix) (0xb4 + (ix)) /* only for fan[4-5] */ 1109431996fSJuerg Haefliger 1119431996fSJuerg Haefliger /* PWMs numbered 0-2, 4-5 (ix) */ 1129431996fSJuerg Haefliger #define DME1737_REG_PWM(ix) ((ix) < 3 ? 0x30 + (ix) \ 1139431996fSJuerg Haefliger : 0xa1 + (ix)) 1149431996fSJuerg Haefliger #define DME1737_REG_PWM_CONFIG(ix) (0x5c + (ix)) /* only for pwm[0-2] */ 1159431996fSJuerg Haefliger #define DME1737_REG_PWM_MIN(ix) (0x64 + (ix)) /* only for pwm[0-2] */ 1169431996fSJuerg Haefliger #define DME1737_REG_PWM_FREQ(ix) ((ix) < 3 ? 0x5f + (ix) \ 1179431996fSJuerg Haefliger : 0xa3 + (ix)) 1189431996fSJuerg Haefliger /* The layout of the ramp rate registers is different from the other pwm 1199431996fSJuerg Haefliger * registers. The bits for the 3 PWMs are stored in 2 registers: 1209431996fSJuerg Haefliger * PWM_RR(0) = [OFF3, OFF2, OFF1, RES, RR1E, RR1-2, RR1-1, RR1-0] 1219431996fSJuerg Haefliger * PWM_RR(1) = [RR2E, RR2-2, RR2-1, RR2-0, RR3E, RR3-2, RR3-1, RR3-0] */ 1229431996fSJuerg Haefliger #define DME1737_REG_PWM_RR(ix) (0x62 + (ix)) /* only for pwm[0-2] */ 1239431996fSJuerg Haefliger 1249431996fSJuerg Haefliger /* Thermal zones 0-2 */ 1259431996fSJuerg Haefliger #define DME1737_REG_ZONE_LOW(ix) (0x67 + (ix)) 1269431996fSJuerg Haefliger #define DME1737_REG_ZONE_ABS(ix) (0x6a + (ix)) 1279431996fSJuerg Haefliger /* The layout of the hysteresis registers is different from the other zone 1289431996fSJuerg Haefliger * registers. The bits for the 3 zones are stored in 2 registers: 1299431996fSJuerg Haefliger * ZONE_HYST(0) = [H1-3, H1-2, H1-1, H1-0, H2-3, H2-2, H2-1, H2-0] 1309431996fSJuerg Haefliger * ZONE_HYST(1) = [H3-3, H3-2, H3-1, H3-0, RES, RES, RES, RES] */ 1319431996fSJuerg Haefliger #define DME1737_REG_ZONE_HYST(ix) (0x6d + (ix)) 1329431996fSJuerg Haefliger 1339431996fSJuerg Haefliger /* Alarm registers and bit mapping 1349431996fSJuerg Haefliger * The 3 8-bit alarm registers will be concatenated to a single 32-bit 1359431996fSJuerg Haefliger * alarm value [0, ALARM3, ALARM2, ALARM1]. */ 1369431996fSJuerg Haefliger #define DME1737_REG_ALARM1 0x41 1379431996fSJuerg Haefliger #define DME1737_REG_ALARM2 0x42 1389431996fSJuerg Haefliger #define DME1737_REG_ALARM3 0x83 1399431996fSJuerg Haefliger static const u8 DME1737_BIT_ALARM_IN[] = {0, 1, 2, 3, 8, 16, 17}; 1409431996fSJuerg Haefliger static const u8 DME1737_BIT_ALARM_TEMP[] = {4, 5, 6}; 1419431996fSJuerg Haefliger static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23}; 1429431996fSJuerg Haefliger 1439431996fSJuerg Haefliger /* Miscellaneous registers */ 144e95c237dSJuerg Haefliger #define DME1737_REG_DEVICE 0x3d 1459431996fSJuerg Haefliger #define DME1737_REG_COMPANY 0x3e 1469431996fSJuerg Haefliger #define DME1737_REG_VERSTEP 0x3f 1479431996fSJuerg Haefliger #define DME1737_REG_CONFIG 0x40 1489431996fSJuerg Haefliger #define DME1737_REG_CONFIG2 0x7f 1499431996fSJuerg Haefliger #define DME1737_REG_VID 0x43 1509431996fSJuerg Haefliger #define DME1737_REG_TACH_PWM 0x81 1519431996fSJuerg Haefliger 1529431996fSJuerg Haefliger /* --------------------------------------------------------------------- 1539431996fSJuerg Haefliger * Misc defines 1549431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 1559431996fSJuerg Haefliger 1569431996fSJuerg Haefliger /* Chip identification */ 1579431996fSJuerg Haefliger #define DME1737_COMPANY_SMSC 0x5c 1589431996fSJuerg Haefliger #define DME1737_VERSTEP 0x88 1599431996fSJuerg Haefliger #define DME1737_VERSTEP_MASK 0xf8 160e95c237dSJuerg Haefliger #define SCH311X_DEVICE 0x8c 161e95c237dSJuerg Haefliger 162e95c237dSJuerg Haefliger /* Length of ISA address segment */ 163e95c237dSJuerg Haefliger #define DME1737_EXTENT 2 1649431996fSJuerg Haefliger 1659431996fSJuerg Haefliger /* --------------------------------------------------------------------- 1669431996fSJuerg Haefliger * Data structures and manipulation thereof 1679431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 1689431996fSJuerg Haefliger 169e95c237dSJuerg Haefliger /* For ISA chips, we abuse the i2c_client addr and name fields. We also use 170e95c237dSJuerg Haefliger the driver field to differentiate between I2C and ISA chips. */ 1719431996fSJuerg Haefliger struct dme1737_data { 1729431996fSJuerg Haefliger struct i2c_client client; 1731beeffe4STony Jones struct device *hwmon_dev; 1749431996fSJuerg Haefliger 1759431996fSJuerg Haefliger struct mutex update_lock; 1769431996fSJuerg Haefliger int valid; /* !=0 if following fields are valid */ 1779431996fSJuerg Haefliger unsigned long last_update; /* in jiffies */ 1789431996fSJuerg Haefliger unsigned long last_vbat; /* in jiffies */ 1799431996fSJuerg Haefliger 1809431996fSJuerg Haefliger u8 vid; 1819431996fSJuerg Haefliger u8 pwm_rr_en; 1829431996fSJuerg Haefliger u8 has_pwm; 1839431996fSJuerg Haefliger u8 has_fan; 1849431996fSJuerg Haefliger 1859431996fSJuerg Haefliger /* Register values */ 1869431996fSJuerg Haefliger u16 in[7]; 1879431996fSJuerg Haefliger u8 in_min[7]; 1889431996fSJuerg Haefliger u8 in_max[7]; 1899431996fSJuerg Haefliger s16 temp[3]; 1909431996fSJuerg Haefliger s8 temp_min[3]; 1919431996fSJuerg Haefliger s8 temp_max[3]; 1929431996fSJuerg Haefliger s8 temp_offset[3]; 1939431996fSJuerg Haefliger u8 config; 1949431996fSJuerg Haefliger u8 config2; 1959431996fSJuerg Haefliger u8 vrm; 1969431996fSJuerg Haefliger u16 fan[6]; 1979431996fSJuerg Haefliger u16 fan_min[6]; 1989431996fSJuerg Haefliger u8 fan_max[2]; 1999431996fSJuerg Haefliger u8 fan_opt[6]; 2009431996fSJuerg Haefliger u8 pwm[6]; 2019431996fSJuerg Haefliger u8 pwm_min[3]; 2029431996fSJuerg Haefliger u8 pwm_config[3]; 2039431996fSJuerg Haefliger u8 pwm_acz[3]; 2049431996fSJuerg Haefliger u8 pwm_freq[6]; 2059431996fSJuerg Haefliger u8 pwm_rr[2]; 2069431996fSJuerg Haefliger u8 zone_low[3]; 2079431996fSJuerg Haefliger u8 zone_abs[3]; 2089431996fSJuerg Haefliger u8 zone_hyst[2]; 2099431996fSJuerg Haefliger u32 alarms; 2109431996fSJuerg Haefliger }; 2119431996fSJuerg Haefliger 2129431996fSJuerg Haefliger /* Nominal voltage values */ 2139431996fSJuerg Haefliger static const int IN_NOMINAL[] = {5000, 2250, 3300, 5000, 12000, 3300, 3300}; 2149431996fSJuerg Haefliger 2159431996fSJuerg Haefliger /* Voltage input 2169431996fSJuerg Haefliger * Voltage inputs have 16 bits resolution, limit values have 8 bits 2179431996fSJuerg Haefliger * resolution. */ 2189431996fSJuerg Haefliger static inline int IN_FROM_REG(int reg, int ix, int res) 2199431996fSJuerg Haefliger { 2209431996fSJuerg Haefliger return (reg * IN_NOMINAL[ix] + (3 << (res - 3))) / (3 << (res - 2)); 2219431996fSJuerg Haefliger } 2229431996fSJuerg Haefliger 2239431996fSJuerg Haefliger static inline int IN_TO_REG(int val, int ix) 2249431996fSJuerg Haefliger { 2259431996fSJuerg Haefliger return SENSORS_LIMIT((val * 192 + IN_NOMINAL[ix] / 2) / 2269431996fSJuerg Haefliger IN_NOMINAL[ix], 0, 255); 2279431996fSJuerg Haefliger } 2289431996fSJuerg Haefliger 2299431996fSJuerg Haefliger /* Temperature input 2309431996fSJuerg Haefliger * The register values represent temperatures in 2's complement notation from 2319431996fSJuerg Haefliger * -127 degrees C to +127 degrees C. Temp inputs have 16 bits resolution, limit 2329431996fSJuerg Haefliger * values have 8 bits resolution. */ 2339431996fSJuerg Haefliger static inline int TEMP_FROM_REG(int reg, int res) 2349431996fSJuerg Haefliger { 2359431996fSJuerg Haefliger return (reg * 1000) >> (res - 8); 2369431996fSJuerg Haefliger } 2379431996fSJuerg Haefliger 2389431996fSJuerg Haefliger static inline int TEMP_TO_REG(int val) 2399431996fSJuerg Haefliger { 2409431996fSJuerg Haefliger return SENSORS_LIMIT((val < 0 ? val - 500 : val + 500) / 1000, 2419431996fSJuerg Haefliger -128, 127); 2429431996fSJuerg Haefliger } 2439431996fSJuerg Haefliger 2449431996fSJuerg Haefliger /* Temperature range */ 2459431996fSJuerg Haefliger static const int TEMP_RANGE[] = {2000, 2500, 3333, 4000, 5000, 6666, 8000, 2469431996fSJuerg Haefliger 10000, 13333, 16000, 20000, 26666, 32000, 2479431996fSJuerg Haefliger 40000, 53333, 80000}; 2489431996fSJuerg Haefliger 2499431996fSJuerg Haefliger static inline int TEMP_RANGE_FROM_REG(int reg) 2509431996fSJuerg Haefliger { 2519431996fSJuerg Haefliger return TEMP_RANGE[(reg >> 4) & 0x0f]; 2529431996fSJuerg Haefliger } 2539431996fSJuerg Haefliger 2549431996fSJuerg Haefliger static int TEMP_RANGE_TO_REG(int val, int reg) 2559431996fSJuerg Haefliger { 2569431996fSJuerg Haefliger int i; 2579431996fSJuerg Haefliger 2589431996fSJuerg Haefliger for (i = 15; i > 0; i--) { 2599431996fSJuerg Haefliger if (val > (TEMP_RANGE[i] + TEMP_RANGE[i - 1] + 1) / 2) { 2609431996fSJuerg Haefliger break; 2619431996fSJuerg Haefliger } 2629431996fSJuerg Haefliger } 2639431996fSJuerg Haefliger 2649431996fSJuerg Haefliger return (reg & 0x0f) | (i << 4); 2659431996fSJuerg Haefliger } 2669431996fSJuerg Haefliger 2679431996fSJuerg Haefliger /* Temperature hysteresis 2689431996fSJuerg Haefliger * Register layout: 2699431996fSJuerg Haefliger * reg[0] = [H1-3, H1-2, H1-1, H1-0, H2-3, H2-2, H2-1, H2-0] 2709431996fSJuerg Haefliger * reg[1] = [H3-3, H3-2, H3-1, H3-0, xxxx, xxxx, xxxx, xxxx] */ 2719431996fSJuerg Haefliger static inline int TEMP_HYST_FROM_REG(int reg, int ix) 2729431996fSJuerg Haefliger { 2739431996fSJuerg Haefliger return (((ix == 1) ? reg : reg >> 4) & 0x0f) * 1000; 2749431996fSJuerg Haefliger } 2759431996fSJuerg Haefliger 2769431996fSJuerg Haefliger static inline int TEMP_HYST_TO_REG(int val, int ix, int reg) 2779431996fSJuerg Haefliger { 2789431996fSJuerg Haefliger int hyst = SENSORS_LIMIT((val + 500) / 1000, 0, 15); 2799431996fSJuerg Haefliger 2809431996fSJuerg Haefliger return (ix == 1) ? (reg & 0xf0) | hyst : (reg & 0x0f) | (hyst << 4); 2819431996fSJuerg Haefliger } 2829431996fSJuerg Haefliger 2839431996fSJuerg Haefliger /* Fan input RPM */ 2849431996fSJuerg Haefliger static inline int FAN_FROM_REG(int reg, int tpc) 2859431996fSJuerg Haefliger { 286ff8421f7SJuerg Haefliger if (tpc) { 287ff8421f7SJuerg Haefliger return tpc * reg; 288ff8421f7SJuerg Haefliger } else { 289ff8421f7SJuerg Haefliger return (reg == 0 || reg == 0xffff) ? 0 : 90000 * 60 / reg; 290ff8421f7SJuerg Haefliger } 2919431996fSJuerg Haefliger } 2929431996fSJuerg Haefliger 2939431996fSJuerg Haefliger static inline int FAN_TO_REG(int val, int tpc) 2949431996fSJuerg Haefliger { 295ff8421f7SJuerg Haefliger if (tpc) { 296ff8421f7SJuerg Haefliger return SENSORS_LIMIT(val / tpc, 0, 0xffff); 297ff8421f7SJuerg Haefliger } else { 298ff8421f7SJuerg Haefliger return (val <= 0) ? 0xffff : 299ff8421f7SJuerg Haefliger SENSORS_LIMIT(90000 * 60 / val, 0, 0xfffe); 300ff8421f7SJuerg Haefliger } 3019431996fSJuerg Haefliger } 3029431996fSJuerg Haefliger 3039431996fSJuerg Haefliger /* Fan TPC (tach pulse count) 3049431996fSJuerg Haefliger * Converts a register value to a TPC multiplier or returns 0 if the tachometer 3059431996fSJuerg Haefliger * is configured in legacy (non-tpc) mode */ 3069431996fSJuerg Haefliger static inline int FAN_TPC_FROM_REG(int reg) 3079431996fSJuerg Haefliger { 3089431996fSJuerg Haefliger return (reg & 0x20) ? 0 : 60 >> (reg & 0x03); 3099431996fSJuerg Haefliger } 3109431996fSJuerg Haefliger 3119431996fSJuerg Haefliger /* Fan type 3129431996fSJuerg Haefliger * The type of a fan is expressed in number of pulses-per-revolution that it 3139431996fSJuerg Haefliger * emits */ 3149431996fSJuerg Haefliger static inline int FAN_TYPE_FROM_REG(int reg) 3159431996fSJuerg Haefliger { 3169431996fSJuerg Haefliger int edge = (reg >> 1) & 0x03; 3179431996fSJuerg Haefliger 3189431996fSJuerg Haefliger return (edge > 0) ? 1 << (edge - 1) : 0; 3199431996fSJuerg Haefliger } 3209431996fSJuerg Haefliger 3219431996fSJuerg Haefliger static inline int FAN_TYPE_TO_REG(int val, int reg) 3229431996fSJuerg Haefliger { 3239431996fSJuerg Haefliger int edge = (val == 4) ? 3 : val; 3249431996fSJuerg Haefliger 3259431996fSJuerg Haefliger return (reg & 0xf9) | (edge << 1); 3269431996fSJuerg Haefliger } 3279431996fSJuerg Haefliger 3289431996fSJuerg Haefliger /* Fan max RPM */ 3299431996fSJuerg Haefliger static const int FAN_MAX[] = {0x54, 0x38, 0x2a, 0x21, 0x1c, 0x18, 0x15, 0x12, 3309431996fSJuerg Haefliger 0x11, 0x0f, 0x0e}; 3319431996fSJuerg Haefliger 3329431996fSJuerg Haefliger static int FAN_MAX_FROM_REG(int reg) 3339431996fSJuerg Haefliger { 3349431996fSJuerg Haefliger int i; 3359431996fSJuerg Haefliger 3369431996fSJuerg Haefliger for (i = 10; i > 0; i--) { 3379431996fSJuerg Haefliger if (reg == FAN_MAX[i]) { 3389431996fSJuerg Haefliger break; 3399431996fSJuerg Haefliger } 3409431996fSJuerg Haefliger } 3419431996fSJuerg Haefliger 3429431996fSJuerg Haefliger return 1000 + i * 500; 3439431996fSJuerg Haefliger } 3449431996fSJuerg Haefliger 3459431996fSJuerg Haefliger static int FAN_MAX_TO_REG(int val) 3469431996fSJuerg Haefliger { 3479431996fSJuerg Haefliger int i; 3489431996fSJuerg Haefliger 3499431996fSJuerg Haefliger for (i = 10; i > 0; i--) { 3509431996fSJuerg Haefliger if (val > (1000 + (i - 1) * 500)) { 3519431996fSJuerg Haefliger break; 3529431996fSJuerg Haefliger } 3539431996fSJuerg Haefliger } 3549431996fSJuerg Haefliger 3559431996fSJuerg Haefliger return FAN_MAX[i]; 3569431996fSJuerg Haefliger } 3579431996fSJuerg Haefliger 3589431996fSJuerg Haefliger /* PWM enable 3599431996fSJuerg Haefliger * Register to enable mapping: 3609431996fSJuerg Haefliger * 000: 2 fan on zone 1 auto 3619431996fSJuerg Haefliger * 001: 2 fan on zone 2 auto 3629431996fSJuerg Haefliger * 010: 2 fan on zone 3 auto 3639431996fSJuerg Haefliger * 011: 0 fan full on 3649431996fSJuerg Haefliger * 100: -1 fan disabled 3659431996fSJuerg Haefliger * 101: 2 fan on hottest of zones 2,3 auto 3669431996fSJuerg Haefliger * 110: 2 fan on hottest of zones 1,2,3 auto 3679431996fSJuerg Haefliger * 111: 1 fan in manual mode */ 3689431996fSJuerg Haefliger static inline int PWM_EN_FROM_REG(int reg) 3699431996fSJuerg Haefliger { 3709431996fSJuerg Haefliger static const int en[] = {2, 2, 2, 0, -1, 2, 2, 1}; 3719431996fSJuerg Haefliger 3729431996fSJuerg Haefliger return en[(reg >> 5) & 0x07]; 3739431996fSJuerg Haefliger } 3749431996fSJuerg Haefliger 3759431996fSJuerg Haefliger static inline int PWM_EN_TO_REG(int val, int reg) 3769431996fSJuerg Haefliger { 3779431996fSJuerg Haefliger int en = (val == 1) ? 7 : 3; 3789431996fSJuerg Haefliger 3799431996fSJuerg Haefliger return (reg & 0x1f) | ((en & 0x07) << 5); 3809431996fSJuerg Haefliger } 3819431996fSJuerg Haefliger 3829431996fSJuerg Haefliger /* PWM auto channels zone 3839431996fSJuerg Haefliger * Register to auto channels zone mapping (ACZ is a bitfield with bit x 3849431996fSJuerg Haefliger * corresponding to zone x+1): 3859431996fSJuerg Haefliger * 000: 001 fan on zone 1 auto 3869431996fSJuerg Haefliger * 001: 010 fan on zone 2 auto 3879431996fSJuerg Haefliger * 010: 100 fan on zone 3 auto 3889431996fSJuerg Haefliger * 011: 000 fan full on 3899431996fSJuerg Haefliger * 100: 000 fan disabled 3909431996fSJuerg Haefliger * 101: 110 fan on hottest of zones 2,3 auto 3919431996fSJuerg Haefliger * 110: 111 fan on hottest of zones 1,2,3 auto 3929431996fSJuerg Haefliger * 111: 000 fan in manual mode */ 3939431996fSJuerg Haefliger static inline int PWM_ACZ_FROM_REG(int reg) 3949431996fSJuerg Haefliger { 3959431996fSJuerg Haefliger static const int acz[] = {1, 2, 4, 0, 0, 6, 7, 0}; 3969431996fSJuerg Haefliger 3979431996fSJuerg Haefliger return acz[(reg >> 5) & 0x07]; 3989431996fSJuerg Haefliger } 3999431996fSJuerg Haefliger 4009431996fSJuerg Haefliger static inline int PWM_ACZ_TO_REG(int val, int reg) 4019431996fSJuerg Haefliger { 4029431996fSJuerg Haefliger int acz = (val == 4) ? 2 : val - 1; 4039431996fSJuerg Haefliger 4049431996fSJuerg Haefliger return (reg & 0x1f) | ((acz & 0x07) << 5); 4059431996fSJuerg Haefliger } 4069431996fSJuerg Haefliger 4079431996fSJuerg Haefliger /* PWM frequency */ 4089431996fSJuerg Haefliger static const int PWM_FREQ[] = {11, 15, 22, 29, 35, 44, 59, 88, 4099431996fSJuerg Haefliger 15000, 20000, 30000, 25000, 0, 0, 0, 0}; 4109431996fSJuerg Haefliger 4119431996fSJuerg Haefliger static inline int PWM_FREQ_FROM_REG(int reg) 4129431996fSJuerg Haefliger { 4139431996fSJuerg Haefliger return PWM_FREQ[reg & 0x0f]; 4149431996fSJuerg Haefliger } 4159431996fSJuerg Haefliger 4169431996fSJuerg Haefliger static int PWM_FREQ_TO_REG(int val, int reg) 4179431996fSJuerg Haefliger { 4189431996fSJuerg Haefliger int i; 4199431996fSJuerg Haefliger 4209431996fSJuerg Haefliger /* the first two cases are special - stupid chip design! */ 4219431996fSJuerg Haefliger if (val > 27500) { 4229431996fSJuerg Haefliger i = 10; 4239431996fSJuerg Haefliger } else if (val > 22500) { 4249431996fSJuerg Haefliger i = 11; 4259431996fSJuerg Haefliger } else { 4269431996fSJuerg Haefliger for (i = 9; i > 0; i--) { 4279431996fSJuerg Haefliger if (val > (PWM_FREQ[i] + PWM_FREQ[i - 1] + 1) / 2) { 4289431996fSJuerg Haefliger break; 4299431996fSJuerg Haefliger } 4309431996fSJuerg Haefliger } 4319431996fSJuerg Haefliger } 4329431996fSJuerg Haefliger 4339431996fSJuerg Haefliger return (reg & 0xf0) | i; 4349431996fSJuerg Haefliger } 4359431996fSJuerg Haefliger 4369431996fSJuerg Haefliger /* PWM ramp rate 4379431996fSJuerg Haefliger * Register layout: 4389431996fSJuerg Haefliger * reg[0] = [OFF3, OFF2, OFF1, RES, RR1-E, RR1-2, RR1-1, RR1-0] 4399431996fSJuerg Haefliger * reg[1] = [RR2-E, RR2-2, RR2-1, RR2-0, RR3-E, RR3-2, RR3-1, RR3-0] */ 4409431996fSJuerg Haefliger static const u8 PWM_RR[] = {206, 104, 69, 41, 26, 18, 10, 5}; 4419431996fSJuerg Haefliger 4429431996fSJuerg Haefliger static inline int PWM_RR_FROM_REG(int reg, int ix) 4439431996fSJuerg Haefliger { 4449431996fSJuerg Haefliger int rr = (ix == 1) ? reg >> 4 : reg; 4459431996fSJuerg Haefliger 4469431996fSJuerg Haefliger return (rr & 0x08) ? PWM_RR[rr & 0x07] : 0; 4479431996fSJuerg Haefliger } 4489431996fSJuerg Haefliger 4499431996fSJuerg Haefliger static int PWM_RR_TO_REG(int val, int ix, int reg) 4509431996fSJuerg Haefliger { 4519431996fSJuerg Haefliger int i; 4529431996fSJuerg Haefliger 4539431996fSJuerg Haefliger for (i = 0; i < 7; i++) { 4549431996fSJuerg Haefliger if (val > (PWM_RR[i] + PWM_RR[i + 1] + 1) / 2) { 4559431996fSJuerg Haefliger break; 4569431996fSJuerg Haefliger } 4579431996fSJuerg Haefliger } 4589431996fSJuerg Haefliger 4599431996fSJuerg Haefliger return (ix == 1) ? (reg & 0x8f) | (i << 4) : (reg & 0xf8) | i; 4609431996fSJuerg Haefliger } 4619431996fSJuerg Haefliger 4629431996fSJuerg Haefliger /* PWM ramp rate enable */ 4639431996fSJuerg Haefliger static inline int PWM_RR_EN_FROM_REG(int reg, int ix) 4649431996fSJuerg Haefliger { 4659431996fSJuerg Haefliger return PWM_RR_FROM_REG(reg, ix) ? 1 : 0; 4669431996fSJuerg Haefliger } 4679431996fSJuerg Haefliger 4689431996fSJuerg Haefliger static inline int PWM_RR_EN_TO_REG(int val, int ix, int reg) 4699431996fSJuerg Haefliger { 4709431996fSJuerg Haefliger int en = (ix == 1) ? 0x80 : 0x08; 4719431996fSJuerg Haefliger 4729431996fSJuerg Haefliger return val ? reg | en : reg & ~en; 4739431996fSJuerg Haefliger } 4749431996fSJuerg Haefliger 4759431996fSJuerg Haefliger /* PWM min/off 4769431996fSJuerg Haefliger * The PWM min/off bits are part of the PMW ramp rate register 0 (see above for 4779431996fSJuerg Haefliger * the register layout). */ 4789431996fSJuerg Haefliger static inline int PWM_OFF_FROM_REG(int reg, int ix) 4799431996fSJuerg Haefliger { 4809431996fSJuerg Haefliger return (reg >> (ix + 5)) & 0x01; 4819431996fSJuerg Haefliger } 4829431996fSJuerg Haefliger 4839431996fSJuerg Haefliger static inline int PWM_OFF_TO_REG(int val, int ix, int reg) 4849431996fSJuerg Haefliger { 4859431996fSJuerg Haefliger return (reg & ~(1 << (ix + 5))) | ((val & 0x01) << (ix + 5)); 4869431996fSJuerg Haefliger } 4879431996fSJuerg Haefliger 4889431996fSJuerg Haefliger /* --------------------------------------------------------------------- 4899431996fSJuerg Haefliger * Device I/O access 490e95c237dSJuerg Haefliger * 491e95c237dSJuerg Haefliger * ISA access is performed through an index/data register pair and needs to 492e95c237dSJuerg Haefliger * be protected by a mutex during runtime (not required for initialization). 493e95c237dSJuerg Haefliger * We use data->update_lock for this and need to ensure that we acquire it 494e95c237dSJuerg Haefliger * before calling dme1737_read or dme1737_write. 4959431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 4969431996fSJuerg Haefliger 4979431996fSJuerg Haefliger static u8 dme1737_read(struct i2c_client *client, u8 reg) 4989431996fSJuerg Haefliger { 499e95c237dSJuerg Haefliger s32 val; 500e95c237dSJuerg Haefliger 501e95c237dSJuerg Haefliger if (client->driver) { /* I2C device */ 502e95c237dSJuerg Haefliger val = i2c_smbus_read_byte_data(client, reg); 5039431996fSJuerg Haefliger 5049431996fSJuerg Haefliger if (val < 0) { 505e95c237dSJuerg Haefliger dev_warn(&client->dev, "Read from register " 506e95c237dSJuerg Haefliger "0x%02x failed! Please report to the driver " 507e95c237dSJuerg Haefliger "maintainer.\n", reg); 508e95c237dSJuerg Haefliger } 509e95c237dSJuerg Haefliger } else { /* ISA device */ 510e95c237dSJuerg Haefliger outb(reg, client->addr); 511e95c237dSJuerg Haefliger val = inb(client->addr + 1); 5129431996fSJuerg Haefliger } 5139431996fSJuerg Haefliger 5149431996fSJuerg Haefliger return val; 5159431996fSJuerg Haefliger } 5169431996fSJuerg Haefliger 517e95c237dSJuerg Haefliger static s32 dme1737_write(struct i2c_client *client, u8 reg, u8 val) 5189431996fSJuerg Haefliger { 519e95c237dSJuerg Haefliger s32 res = 0; 520e95c237dSJuerg Haefliger 521e95c237dSJuerg Haefliger if (client->driver) { /* I2C device */ 522e95c237dSJuerg Haefliger res = i2c_smbus_write_byte_data(client, reg, val); 5239431996fSJuerg Haefliger 5249431996fSJuerg Haefliger if (res < 0) { 525e95c237dSJuerg Haefliger dev_warn(&client->dev, "Write to register " 526e95c237dSJuerg Haefliger "0x%02x failed! Please report to the driver " 527e95c237dSJuerg Haefliger "maintainer.\n", reg); 528e95c237dSJuerg Haefliger } 529e95c237dSJuerg Haefliger } else { /* ISA device */ 530e95c237dSJuerg Haefliger outb(reg, client->addr); 531e95c237dSJuerg Haefliger outb(val, client->addr + 1); 5329431996fSJuerg Haefliger } 5339431996fSJuerg Haefliger 5349431996fSJuerg Haefliger return res; 5359431996fSJuerg Haefliger } 5369431996fSJuerg Haefliger 5379431996fSJuerg Haefliger static struct dme1737_data *dme1737_update_device(struct device *dev) 5389431996fSJuerg Haefliger { 539b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 540b237eb25SJuerg Haefliger struct i2c_client *client = &data->client; 5419431996fSJuerg Haefliger int ix; 5429431996fSJuerg Haefliger u8 lsb[5]; 5439431996fSJuerg Haefliger 5449431996fSJuerg Haefliger mutex_lock(&data->update_lock); 5459431996fSJuerg Haefliger 5469431996fSJuerg Haefliger /* Enable a Vbat monitoring cycle every 10 mins */ 5479431996fSJuerg Haefliger if (time_after(jiffies, data->last_vbat + 600 * HZ) || !data->valid) { 5489431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_CONFIG, dme1737_read(client, 5499431996fSJuerg Haefliger DME1737_REG_CONFIG) | 0x10); 5509431996fSJuerg Haefliger data->last_vbat = jiffies; 5519431996fSJuerg Haefliger } 5529431996fSJuerg Haefliger 5539431996fSJuerg Haefliger /* Sample register contents every 1 sec */ 5549431996fSJuerg Haefliger if (time_after(jiffies, data->last_update + HZ) || !data->valid) { 5559431996fSJuerg Haefliger data->vid = dme1737_read(client, DME1737_REG_VID) & 0x3f; 5569431996fSJuerg Haefliger 5579431996fSJuerg Haefliger /* In (voltage) registers */ 5589431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) { 5599431996fSJuerg Haefliger /* Voltage inputs are stored as 16 bit values even 5609431996fSJuerg Haefliger * though they have only 12 bits resolution. This is 5619431996fSJuerg Haefliger * to make it consistent with the temp inputs. */ 5629431996fSJuerg Haefliger data->in[ix] = dme1737_read(client, 5639431996fSJuerg Haefliger DME1737_REG_IN(ix)) << 8; 5649431996fSJuerg Haefliger data->in_min[ix] = dme1737_read(client, 5659431996fSJuerg Haefliger DME1737_REG_IN_MIN(ix)); 5669431996fSJuerg Haefliger data->in_max[ix] = dme1737_read(client, 5679431996fSJuerg Haefliger DME1737_REG_IN_MAX(ix)); 5689431996fSJuerg Haefliger } 5699431996fSJuerg Haefliger 5709431996fSJuerg Haefliger /* Temp registers */ 5719431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) { 5729431996fSJuerg Haefliger /* Temp inputs are stored as 16 bit values even 5739431996fSJuerg Haefliger * though they have only 12 bits resolution. This is 5749431996fSJuerg Haefliger * to take advantage of implicit conversions between 5759431996fSJuerg Haefliger * register values (2's complement) and temp values 5769431996fSJuerg Haefliger * (signed decimal). */ 5779431996fSJuerg Haefliger data->temp[ix] = dme1737_read(client, 5789431996fSJuerg Haefliger DME1737_REG_TEMP(ix)) << 8; 5799431996fSJuerg Haefliger data->temp_min[ix] = dme1737_read(client, 5809431996fSJuerg Haefliger DME1737_REG_TEMP_MIN(ix)); 5819431996fSJuerg Haefliger data->temp_max[ix] = dme1737_read(client, 5829431996fSJuerg Haefliger DME1737_REG_TEMP_MAX(ix)); 5839431996fSJuerg Haefliger data->temp_offset[ix] = dme1737_read(client, 5849431996fSJuerg Haefliger DME1737_REG_TEMP_OFFSET(ix)); 5859431996fSJuerg Haefliger } 5869431996fSJuerg Haefliger 5879431996fSJuerg Haefliger /* In and temp LSB registers 5889431996fSJuerg Haefliger * The LSBs are latched when the MSBs are read, so the order in 5899431996fSJuerg Haefliger * which the registers are read (MSB first, then LSB) is 5909431996fSJuerg Haefliger * important! */ 5919431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(lsb); ix++) { 5929431996fSJuerg Haefliger lsb[ix] = dme1737_read(client, 5939431996fSJuerg Haefliger DME1737_REG_IN_TEMP_LSB(ix)); 5949431996fSJuerg Haefliger } 5959431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) { 5969431996fSJuerg Haefliger data->in[ix] |= (lsb[DME1737_REG_IN_LSB[ix]] << 5979431996fSJuerg Haefliger DME1737_REG_IN_LSB_SHL[ix]) & 0xf0; 5989431996fSJuerg Haefliger } 5999431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) { 6009431996fSJuerg Haefliger data->temp[ix] |= (lsb[DME1737_REG_TEMP_LSB[ix]] << 6019431996fSJuerg Haefliger DME1737_REG_TEMP_LSB_SHL[ix]) & 0xf0; 6029431996fSJuerg Haefliger } 6039431996fSJuerg Haefliger 6049431996fSJuerg Haefliger /* Fan registers */ 6059431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->fan); ix++) { 6069431996fSJuerg Haefliger /* Skip reading registers if optional fans are not 6079431996fSJuerg Haefliger * present */ 6089431996fSJuerg Haefliger if (!(data->has_fan & (1 << ix))) { 6099431996fSJuerg Haefliger continue; 6109431996fSJuerg Haefliger } 6119431996fSJuerg Haefliger data->fan[ix] = dme1737_read(client, 6129431996fSJuerg Haefliger DME1737_REG_FAN(ix)); 6139431996fSJuerg Haefliger data->fan[ix] |= dme1737_read(client, 6149431996fSJuerg Haefliger DME1737_REG_FAN(ix) + 1) << 8; 6159431996fSJuerg Haefliger data->fan_min[ix] = dme1737_read(client, 6169431996fSJuerg Haefliger DME1737_REG_FAN_MIN(ix)); 6179431996fSJuerg Haefliger data->fan_min[ix] |= dme1737_read(client, 6189431996fSJuerg Haefliger DME1737_REG_FAN_MIN(ix) + 1) << 8; 6199431996fSJuerg Haefliger data->fan_opt[ix] = dme1737_read(client, 6209431996fSJuerg Haefliger DME1737_REG_FAN_OPT(ix)); 6219431996fSJuerg Haefliger /* fan_max exists only for fan[5-6] */ 6229431996fSJuerg Haefliger if (ix > 3) { 6239431996fSJuerg Haefliger data->fan_max[ix - 4] = dme1737_read(client, 6249431996fSJuerg Haefliger DME1737_REG_FAN_MAX(ix)); 6259431996fSJuerg Haefliger } 6269431996fSJuerg Haefliger } 6279431996fSJuerg Haefliger 6289431996fSJuerg Haefliger /* PWM registers */ 6299431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->pwm); ix++) { 6309431996fSJuerg Haefliger /* Skip reading registers if optional PWMs are not 6319431996fSJuerg Haefliger * present */ 6329431996fSJuerg Haefliger if (!(data->has_pwm & (1 << ix))) { 6339431996fSJuerg Haefliger continue; 6349431996fSJuerg Haefliger } 6359431996fSJuerg Haefliger data->pwm[ix] = dme1737_read(client, 6369431996fSJuerg Haefliger DME1737_REG_PWM(ix)); 6379431996fSJuerg Haefliger data->pwm_freq[ix] = dme1737_read(client, 6389431996fSJuerg Haefliger DME1737_REG_PWM_FREQ(ix)); 6399431996fSJuerg Haefliger /* pwm_config and pwm_min exist only for pwm[1-3] */ 6409431996fSJuerg Haefliger if (ix < 3) { 6419431996fSJuerg Haefliger data->pwm_config[ix] = dme1737_read(client, 6429431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 6439431996fSJuerg Haefliger data->pwm_min[ix] = dme1737_read(client, 6449431996fSJuerg Haefliger DME1737_REG_PWM_MIN(ix)); 6459431996fSJuerg Haefliger } 6469431996fSJuerg Haefliger } 6479431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->pwm_rr); ix++) { 6489431996fSJuerg Haefliger data->pwm_rr[ix] = dme1737_read(client, 6499431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix)); 6509431996fSJuerg Haefliger } 6519431996fSJuerg Haefliger 6529431996fSJuerg Haefliger /* Thermal zone registers */ 6539431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->zone_low); ix++) { 6549431996fSJuerg Haefliger data->zone_low[ix] = dme1737_read(client, 6559431996fSJuerg Haefliger DME1737_REG_ZONE_LOW(ix)); 6569431996fSJuerg Haefliger data->zone_abs[ix] = dme1737_read(client, 6579431996fSJuerg Haefliger DME1737_REG_ZONE_ABS(ix)); 6589431996fSJuerg Haefliger } 6599431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) { 6609431996fSJuerg Haefliger data->zone_hyst[ix] = dme1737_read(client, 6619431996fSJuerg Haefliger DME1737_REG_ZONE_HYST(ix)); 6629431996fSJuerg Haefliger } 6639431996fSJuerg Haefliger 6649431996fSJuerg Haefliger /* Alarm registers */ 6659431996fSJuerg Haefliger data->alarms = dme1737_read(client, 6669431996fSJuerg Haefliger DME1737_REG_ALARM1); 6679431996fSJuerg Haefliger /* Bit 7 tells us if the other alarm registers are non-zero and 6689431996fSJuerg Haefliger * therefore also need to be read */ 6699431996fSJuerg Haefliger if (data->alarms & 0x80) { 6709431996fSJuerg Haefliger data->alarms |= dme1737_read(client, 6719431996fSJuerg Haefliger DME1737_REG_ALARM2) << 8; 6729431996fSJuerg Haefliger data->alarms |= dme1737_read(client, 6739431996fSJuerg Haefliger DME1737_REG_ALARM3) << 16; 6749431996fSJuerg Haefliger } 6759431996fSJuerg Haefliger 676e95c237dSJuerg Haefliger /* The ISA chips require explicit clearing of alarm bits. 677e95c237dSJuerg Haefliger * Don't worry, an alarm will come back if the condition 678e95c237dSJuerg Haefliger * that causes it still exists */ 679e95c237dSJuerg Haefliger if (!client->driver) { 680e95c237dSJuerg Haefliger if (data->alarms & 0xff0000) { 681e95c237dSJuerg Haefliger dme1737_write(client, DME1737_REG_ALARM3, 682e95c237dSJuerg Haefliger 0xff); 683e95c237dSJuerg Haefliger } 684e95c237dSJuerg Haefliger if (data->alarms & 0xff00) { 685e95c237dSJuerg Haefliger dme1737_write(client, DME1737_REG_ALARM2, 686e95c237dSJuerg Haefliger 0xff); 687e95c237dSJuerg Haefliger } 688e95c237dSJuerg Haefliger if (data->alarms & 0xff) { 689e95c237dSJuerg Haefliger dme1737_write(client, DME1737_REG_ALARM1, 690e95c237dSJuerg Haefliger 0xff); 691e95c237dSJuerg Haefliger } 692e95c237dSJuerg Haefliger } 693e95c237dSJuerg Haefliger 6949431996fSJuerg Haefliger data->last_update = jiffies; 6959431996fSJuerg Haefliger data->valid = 1; 6969431996fSJuerg Haefliger } 6979431996fSJuerg Haefliger 6989431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 6999431996fSJuerg Haefliger 7009431996fSJuerg Haefliger return data; 7019431996fSJuerg Haefliger } 7029431996fSJuerg Haefliger 7039431996fSJuerg Haefliger /* --------------------------------------------------------------------- 7049431996fSJuerg Haefliger * Voltage sysfs attributes 7059431996fSJuerg Haefliger * ix = [0-5] 7069431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 7079431996fSJuerg Haefliger 7089431996fSJuerg Haefliger #define SYS_IN_INPUT 0 7099431996fSJuerg Haefliger #define SYS_IN_MIN 1 7109431996fSJuerg Haefliger #define SYS_IN_MAX 2 7119431996fSJuerg Haefliger #define SYS_IN_ALARM 3 7129431996fSJuerg Haefliger 7139431996fSJuerg Haefliger static ssize_t show_in(struct device *dev, struct device_attribute *attr, 7149431996fSJuerg Haefliger char *buf) 7159431996fSJuerg Haefliger { 7169431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 7179431996fSJuerg Haefliger struct sensor_device_attribute_2 7189431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 7199431996fSJuerg Haefliger int ix = sensor_attr_2->index; 7209431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 7219431996fSJuerg Haefliger int res; 7229431996fSJuerg Haefliger 7239431996fSJuerg Haefliger switch (fn) { 7249431996fSJuerg Haefliger case SYS_IN_INPUT: 7259431996fSJuerg Haefliger res = IN_FROM_REG(data->in[ix], ix, 16); 7269431996fSJuerg Haefliger break; 7279431996fSJuerg Haefliger case SYS_IN_MIN: 7289431996fSJuerg Haefliger res = IN_FROM_REG(data->in_min[ix], ix, 8); 7299431996fSJuerg Haefliger break; 7309431996fSJuerg Haefliger case SYS_IN_MAX: 7319431996fSJuerg Haefliger res = IN_FROM_REG(data->in_max[ix], ix, 8); 7329431996fSJuerg Haefliger break; 7339431996fSJuerg Haefliger case SYS_IN_ALARM: 7349431996fSJuerg Haefliger res = (data->alarms >> DME1737_BIT_ALARM_IN[ix]) & 0x01; 7359431996fSJuerg Haefliger break; 7369431996fSJuerg Haefliger default: 7379431996fSJuerg Haefliger res = 0; 738b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 7399431996fSJuerg Haefliger } 7409431996fSJuerg Haefliger 7419431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 7429431996fSJuerg Haefliger } 7439431996fSJuerg Haefliger 7449431996fSJuerg Haefliger static ssize_t set_in(struct device *dev, struct device_attribute *attr, 7459431996fSJuerg Haefliger const char *buf, size_t count) 7469431996fSJuerg Haefliger { 747b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 748b237eb25SJuerg Haefliger struct i2c_client *client = &data->client; 7499431996fSJuerg Haefliger struct sensor_device_attribute_2 7509431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 7519431996fSJuerg Haefliger int ix = sensor_attr_2->index; 7529431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 7539431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 7549431996fSJuerg Haefliger 7559431996fSJuerg Haefliger mutex_lock(&data->update_lock); 7569431996fSJuerg Haefliger switch (fn) { 7579431996fSJuerg Haefliger case SYS_IN_MIN: 7589431996fSJuerg Haefliger data->in_min[ix] = IN_TO_REG(val, ix); 7599431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_IN_MIN(ix), 7609431996fSJuerg Haefliger data->in_min[ix]); 7619431996fSJuerg Haefliger break; 7629431996fSJuerg Haefliger case SYS_IN_MAX: 7639431996fSJuerg Haefliger data->in_max[ix] = IN_TO_REG(val, ix); 7649431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_IN_MAX(ix), 7659431996fSJuerg Haefliger data->in_max[ix]); 7669431996fSJuerg Haefliger break; 7679431996fSJuerg Haefliger default: 768b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 7699431996fSJuerg Haefliger } 7709431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 7719431996fSJuerg Haefliger 7729431996fSJuerg Haefliger return count; 7739431996fSJuerg Haefliger } 7749431996fSJuerg Haefliger 7759431996fSJuerg Haefliger /* --------------------------------------------------------------------- 7769431996fSJuerg Haefliger * Temperature sysfs attributes 7779431996fSJuerg Haefliger * ix = [0-2] 7789431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 7799431996fSJuerg Haefliger 7809431996fSJuerg Haefliger #define SYS_TEMP_INPUT 0 7819431996fSJuerg Haefliger #define SYS_TEMP_MIN 1 7829431996fSJuerg Haefliger #define SYS_TEMP_MAX 2 7839431996fSJuerg Haefliger #define SYS_TEMP_OFFSET 3 7849431996fSJuerg Haefliger #define SYS_TEMP_ALARM 4 7859431996fSJuerg Haefliger #define SYS_TEMP_FAULT 5 7869431996fSJuerg Haefliger 7879431996fSJuerg Haefliger static ssize_t show_temp(struct device *dev, struct device_attribute *attr, 7889431996fSJuerg Haefliger char *buf) 7899431996fSJuerg Haefliger { 7909431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 7919431996fSJuerg Haefliger struct sensor_device_attribute_2 7929431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 7939431996fSJuerg Haefliger int ix = sensor_attr_2->index; 7949431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 7959431996fSJuerg Haefliger int res; 7969431996fSJuerg Haefliger 7979431996fSJuerg Haefliger switch (fn) { 7989431996fSJuerg Haefliger case SYS_TEMP_INPUT: 7999431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp[ix], 16); 8009431996fSJuerg Haefliger break; 8019431996fSJuerg Haefliger case SYS_TEMP_MIN: 8029431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp_min[ix], 8); 8039431996fSJuerg Haefliger break; 8049431996fSJuerg Haefliger case SYS_TEMP_MAX: 8059431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp_max[ix], 8); 8069431996fSJuerg Haefliger break; 8079431996fSJuerg Haefliger case SYS_TEMP_OFFSET: 8089431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp_offset[ix], 8); 8099431996fSJuerg Haefliger break; 8109431996fSJuerg Haefliger case SYS_TEMP_ALARM: 8119431996fSJuerg Haefliger res = (data->alarms >> DME1737_BIT_ALARM_TEMP[ix]) & 0x01; 8129431996fSJuerg Haefliger break; 8139431996fSJuerg Haefliger case SYS_TEMP_FAULT: 814c0f31403SJuerg Haefliger res = (((u16)data->temp[ix] & 0xff00) == 0x8000); 8159431996fSJuerg Haefliger break; 8169431996fSJuerg Haefliger default: 8179431996fSJuerg Haefliger res = 0; 818b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 8199431996fSJuerg Haefliger } 8209431996fSJuerg Haefliger 8219431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 8229431996fSJuerg Haefliger } 8239431996fSJuerg Haefliger 8249431996fSJuerg Haefliger static ssize_t set_temp(struct device *dev, struct device_attribute *attr, 8259431996fSJuerg Haefliger const char *buf, size_t count) 8269431996fSJuerg Haefliger { 827b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 828b237eb25SJuerg Haefliger struct i2c_client *client = &data->client; 8299431996fSJuerg Haefliger struct sensor_device_attribute_2 8309431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 8319431996fSJuerg Haefliger int ix = sensor_attr_2->index; 8329431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 8339431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 8349431996fSJuerg Haefliger 8359431996fSJuerg Haefliger mutex_lock(&data->update_lock); 8369431996fSJuerg Haefliger switch (fn) { 8379431996fSJuerg Haefliger case SYS_TEMP_MIN: 8389431996fSJuerg Haefliger data->temp_min[ix] = TEMP_TO_REG(val); 8399431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_TEMP_MIN(ix), 8409431996fSJuerg Haefliger data->temp_min[ix]); 8419431996fSJuerg Haefliger break; 8429431996fSJuerg Haefliger case SYS_TEMP_MAX: 8439431996fSJuerg Haefliger data->temp_max[ix] = TEMP_TO_REG(val); 8449431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_TEMP_MAX(ix), 8459431996fSJuerg Haefliger data->temp_max[ix]); 8469431996fSJuerg Haefliger break; 8479431996fSJuerg Haefliger case SYS_TEMP_OFFSET: 8489431996fSJuerg Haefliger data->temp_offset[ix] = TEMP_TO_REG(val); 8499431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_TEMP_OFFSET(ix), 8509431996fSJuerg Haefliger data->temp_offset[ix]); 8519431996fSJuerg Haefliger break; 8529431996fSJuerg Haefliger default: 853b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 8549431996fSJuerg Haefliger } 8559431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 8569431996fSJuerg Haefliger 8579431996fSJuerg Haefliger return count; 8589431996fSJuerg Haefliger } 8599431996fSJuerg Haefliger 8609431996fSJuerg Haefliger /* --------------------------------------------------------------------- 8619431996fSJuerg Haefliger * Zone sysfs attributes 8629431996fSJuerg Haefliger * ix = [0-2] 8639431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 8649431996fSJuerg Haefliger 8659431996fSJuerg Haefliger #define SYS_ZONE_AUTO_CHANNELS_TEMP 0 8669431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT1_TEMP_HYST 1 8679431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT1_TEMP 2 8689431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT2_TEMP 3 8699431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT3_TEMP 4 8709431996fSJuerg Haefliger 8719431996fSJuerg Haefliger static ssize_t show_zone(struct device *dev, struct device_attribute *attr, 8729431996fSJuerg Haefliger char *buf) 8739431996fSJuerg Haefliger { 8749431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 8759431996fSJuerg Haefliger struct sensor_device_attribute_2 8769431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 8779431996fSJuerg Haefliger int ix = sensor_attr_2->index; 8789431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 8799431996fSJuerg Haefliger int res; 8809431996fSJuerg Haefliger 8819431996fSJuerg Haefliger switch (fn) { 8829431996fSJuerg Haefliger case SYS_ZONE_AUTO_CHANNELS_TEMP: 8839431996fSJuerg Haefliger /* check config2 for non-standard temp-to-zone mapping */ 8849431996fSJuerg Haefliger if ((ix == 1) && (data->config2 & 0x02)) { 8859431996fSJuerg Haefliger res = 4; 8869431996fSJuerg Haefliger } else { 8879431996fSJuerg Haefliger res = 1 << ix; 8889431996fSJuerg Haefliger } 8899431996fSJuerg Haefliger break; 8909431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP_HYST: 8919431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_low[ix], 8) - 8929431996fSJuerg Haefliger TEMP_HYST_FROM_REG(data->zone_hyst[ix == 2], ix); 8939431996fSJuerg Haefliger break; 8949431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP: 8959431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_low[ix], 8); 8969431996fSJuerg Haefliger break; 8979431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT2_TEMP: 8989431996fSJuerg Haefliger /* pwm_freq holds the temp range bits in the upper nibble */ 8999431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_low[ix], 8) + 9009431996fSJuerg Haefliger TEMP_RANGE_FROM_REG(data->pwm_freq[ix]); 9019431996fSJuerg Haefliger break; 9029431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT3_TEMP: 9039431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_abs[ix], 8); 9049431996fSJuerg Haefliger break; 9059431996fSJuerg Haefliger default: 9069431996fSJuerg Haefliger res = 0; 907b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 9089431996fSJuerg Haefliger } 9099431996fSJuerg Haefliger 9109431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 9119431996fSJuerg Haefliger } 9129431996fSJuerg Haefliger 9139431996fSJuerg Haefliger static ssize_t set_zone(struct device *dev, struct device_attribute *attr, 9149431996fSJuerg Haefliger const char *buf, size_t count) 9159431996fSJuerg Haefliger { 916b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 917b237eb25SJuerg Haefliger struct i2c_client *client = &data->client; 9189431996fSJuerg Haefliger struct sensor_device_attribute_2 9199431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 9209431996fSJuerg Haefliger int ix = sensor_attr_2->index; 9219431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 9229431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 9239431996fSJuerg Haefliger 9249431996fSJuerg Haefliger mutex_lock(&data->update_lock); 9259431996fSJuerg Haefliger switch (fn) { 9269431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP_HYST: 9279431996fSJuerg Haefliger /* Refresh the cache */ 9289431996fSJuerg Haefliger data->zone_low[ix] = dme1737_read(client, 9299431996fSJuerg Haefliger DME1737_REG_ZONE_LOW(ix)); 9309431996fSJuerg Haefliger /* Modify the temp hyst value */ 9319431996fSJuerg Haefliger data->zone_hyst[ix == 2] = TEMP_HYST_TO_REG( 9329431996fSJuerg Haefliger TEMP_FROM_REG(data->zone_low[ix], 8) - 9339431996fSJuerg Haefliger val, ix, dme1737_read(client, 9349431996fSJuerg Haefliger DME1737_REG_ZONE_HYST(ix == 2))); 9359431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_ZONE_HYST(ix == 2), 9369431996fSJuerg Haefliger data->zone_hyst[ix == 2]); 9379431996fSJuerg Haefliger break; 9389431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP: 9399431996fSJuerg Haefliger data->zone_low[ix] = TEMP_TO_REG(val); 9409431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_ZONE_LOW(ix), 9419431996fSJuerg Haefliger data->zone_low[ix]); 9429431996fSJuerg Haefliger break; 9439431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT2_TEMP: 9449431996fSJuerg Haefliger /* Refresh the cache */ 9459431996fSJuerg Haefliger data->zone_low[ix] = dme1737_read(client, 9469431996fSJuerg Haefliger DME1737_REG_ZONE_LOW(ix)); 9479431996fSJuerg Haefliger /* Modify the temp range value (which is stored in the upper 9489431996fSJuerg Haefliger * nibble of the pwm_freq register) */ 9499431996fSJuerg Haefliger data->pwm_freq[ix] = TEMP_RANGE_TO_REG(val - 9509431996fSJuerg Haefliger TEMP_FROM_REG(data->zone_low[ix], 8), 9519431996fSJuerg Haefliger dme1737_read(client, 9529431996fSJuerg Haefliger DME1737_REG_PWM_FREQ(ix))); 9539431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM_FREQ(ix), 9549431996fSJuerg Haefliger data->pwm_freq[ix]); 9559431996fSJuerg Haefliger break; 9569431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT3_TEMP: 9579431996fSJuerg Haefliger data->zone_abs[ix] = TEMP_TO_REG(val); 9589431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_ZONE_ABS(ix), 9599431996fSJuerg Haefliger data->zone_abs[ix]); 9609431996fSJuerg Haefliger break; 9619431996fSJuerg Haefliger default: 962b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 9639431996fSJuerg Haefliger } 9649431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 9659431996fSJuerg Haefliger 9669431996fSJuerg Haefliger return count; 9679431996fSJuerg Haefliger } 9689431996fSJuerg Haefliger 9699431996fSJuerg Haefliger /* --------------------------------------------------------------------- 9709431996fSJuerg Haefliger * Fan sysfs attributes 9719431996fSJuerg Haefliger * ix = [0-5] 9729431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 9739431996fSJuerg Haefliger 9749431996fSJuerg Haefliger #define SYS_FAN_INPUT 0 9759431996fSJuerg Haefliger #define SYS_FAN_MIN 1 9769431996fSJuerg Haefliger #define SYS_FAN_MAX 2 9779431996fSJuerg Haefliger #define SYS_FAN_ALARM 3 9789431996fSJuerg Haefliger #define SYS_FAN_TYPE 4 9799431996fSJuerg Haefliger 9809431996fSJuerg Haefliger static ssize_t show_fan(struct device *dev, struct device_attribute *attr, 9819431996fSJuerg Haefliger char *buf) 9829431996fSJuerg Haefliger { 9839431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 9849431996fSJuerg Haefliger struct sensor_device_attribute_2 9859431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 9869431996fSJuerg Haefliger int ix = sensor_attr_2->index; 9879431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 9889431996fSJuerg Haefliger int res; 9899431996fSJuerg Haefliger 9909431996fSJuerg Haefliger switch (fn) { 9919431996fSJuerg Haefliger case SYS_FAN_INPUT: 9929431996fSJuerg Haefliger res = FAN_FROM_REG(data->fan[ix], 9939431996fSJuerg Haefliger ix < 4 ? 0 : 9949431996fSJuerg Haefliger FAN_TPC_FROM_REG(data->fan_opt[ix])); 9959431996fSJuerg Haefliger break; 9969431996fSJuerg Haefliger case SYS_FAN_MIN: 9979431996fSJuerg Haefliger res = FAN_FROM_REG(data->fan_min[ix], 9989431996fSJuerg Haefliger ix < 4 ? 0 : 9999431996fSJuerg Haefliger FAN_TPC_FROM_REG(data->fan_opt[ix])); 10009431996fSJuerg Haefliger break; 10019431996fSJuerg Haefliger case SYS_FAN_MAX: 10029431996fSJuerg Haefliger /* only valid for fan[5-6] */ 10039431996fSJuerg Haefliger res = FAN_MAX_FROM_REG(data->fan_max[ix - 4]); 10049431996fSJuerg Haefliger break; 10059431996fSJuerg Haefliger case SYS_FAN_ALARM: 10069431996fSJuerg Haefliger res = (data->alarms >> DME1737_BIT_ALARM_FAN[ix]) & 0x01; 10079431996fSJuerg Haefliger break; 10089431996fSJuerg Haefliger case SYS_FAN_TYPE: 10099431996fSJuerg Haefliger /* only valid for fan[1-4] */ 10109431996fSJuerg Haefliger res = FAN_TYPE_FROM_REG(data->fan_opt[ix]); 10119431996fSJuerg Haefliger break; 10129431996fSJuerg Haefliger default: 10139431996fSJuerg Haefliger res = 0; 1014b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 10159431996fSJuerg Haefliger } 10169431996fSJuerg Haefliger 10179431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 10189431996fSJuerg Haefliger } 10199431996fSJuerg Haefliger 10209431996fSJuerg Haefliger static ssize_t set_fan(struct device *dev, struct device_attribute *attr, 10219431996fSJuerg Haefliger const char *buf, size_t count) 10229431996fSJuerg Haefliger { 1023b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 1024b237eb25SJuerg Haefliger struct i2c_client *client = &data->client; 10259431996fSJuerg Haefliger struct sensor_device_attribute_2 10269431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 10279431996fSJuerg Haefliger int ix = sensor_attr_2->index; 10289431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 10299431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 10309431996fSJuerg Haefliger 10319431996fSJuerg Haefliger mutex_lock(&data->update_lock); 10329431996fSJuerg Haefliger switch (fn) { 10339431996fSJuerg Haefliger case SYS_FAN_MIN: 10349431996fSJuerg Haefliger if (ix < 4) { 10359431996fSJuerg Haefliger data->fan_min[ix] = FAN_TO_REG(val, 0); 10369431996fSJuerg Haefliger } else { 10379431996fSJuerg Haefliger /* Refresh the cache */ 10389431996fSJuerg Haefliger data->fan_opt[ix] = dme1737_read(client, 10399431996fSJuerg Haefliger DME1737_REG_FAN_OPT(ix)); 10409431996fSJuerg Haefliger /* Modify the fan min value */ 10419431996fSJuerg Haefliger data->fan_min[ix] = FAN_TO_REG(val, 10429431996fSJuerg Haefliger FAN_TPC_FROM_REG(data->fan_opt[ix])); 10439431996fSJuerg Haefliger } 10449431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_FAN_MIN(ix), 10459431996fSJuerg Haefliger data->fan_min[ix] & 0xff); 10469431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_FAN_MIN(ix) + 1, 10479431996fSJuerg Haefliger data->fan_min[ix] >> 8); 10489431996fSJuerg Haefliger break; 10499431996fSJuerg Haefliger case SYS_FAN_MAX: 10509431996fSJuerg Haefliger /* Only valid for fan[5-6] */ 10519431996fSJuerg Haefliger data->fan_max[ix - 4] = FAN_MAX_TO_REG(val); 10529431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_FAN_MAX(ix), 10539431996fSJuerg Haefliger data->fan_max[ix - 4]); 10549431996fSJuerg Haefliger break; 10559431996fSJuerg Haefliger case SYS_FAN_TYPE: 10569431996fSJuerg Haefliger /* Only valid for fan[1-4] */ 10579431996fSJuerg Haefliger if (!(val == 1 || val == 2 || val == 4)) { 10589431996fSJuerg Haefliger count = -EINVAL; 1059e95c237dSJuerg Haefliger dev_warn(dev, "Fan type value %ld not " 10609431996fSJuerg Haefliger "supported. Choose one of 1, 2, or 4.\n", 10619431996fSJuerg Haefliger val); 10629431996fSJuerg Haefliger goto exit; 10639431996fSJuerg Haefliger } 10649431996fSJuerg Haefliger data->fan_opt[ix] = FAN_TYPE_TO_REG(val, dme1737_read(client, 10659431996fSJuerg Haefliger DME1737_REG_FAN_OPT(ix))); 10669431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_FAN_OPT(ix), 10679431996fSJuerg Haefliger data->fan_opt[ix]); 10689431996fSJuerg Haefliger break; 10699431996fSJuerg Haefliger default: 1070b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 10719431996fSJuerg Haefliger } 10729431996fSJuerg Haefliger exit: 10739431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 10749431996fSJuerg Haefliger 10759431996fSJuerg Haefliger return count; 10769431996fSJuerg Haefliger } 10779431996fSJuerg Haefliger 10789431996fSJuerg Haefliger /* --------------------------------------------------------------------- 10799431996fSJuerg Haefliger * PWM sysfs attributes 10809431996fSJuerg Haefliger * ix = [0-4] 10819431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 10829431996fSJuerg Haefliger 10839431996fSJuerg Haefliger #define SYS_PWM 0 10849431996fSJuerg Haefliger #define SYS_PWM_FREQ 1 10859431996fSJuerg Haefliger #define SYS_PWM_ENABLE 2 10869431996fSJuerg Haefliger #define SYS_PWM_RAMP_RATE 3 10879431996fSJuerg Haefliger #define SYS_PWM_AUTO_CHANNELS_ZONE 4 10889431996fSJuerg Haefliger #define SYS_PWM_AUTO_PWM_MIN 5 10899431996fSJuerg Haefliger #define SYS_PWM_AUTO_POINT1_PWM 6 10909431996fSJuerg Haefliger #define SYS_PWM_AUTO_POINT2_PWM 7 10919431996fSJuerg Haefliger 10929431996fSJuerg Haefliger static ssize_t show_pwm(struct device *dev, struct device_attribute *attr, 10939431996fSJuerg Haefliger char *buf) 10949431996fSJuerg Haefliger { 10959431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 10969431996fSJuerg Haefliger struct sensor_device_attribute_2 10979431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 10989431996fSJuerg Haefliger int ix = sensor_attr_2->index; 10999431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 11009431996fSJuerg Haefliger int res; 11019431996fSJuerg Haefliger 11029431996fSJuerg Haefliger switch (fn) { 11039431996fSJuerg Haefliger case SYS_PWM: 11049431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 0) { 11059431996fSJuerg Haefliger res = 255; 11069431996fSJuerg Haefliger } else { 11079431996fSJuerg Haefliger res = data->pwm[ix]; 11089431996fSJuerg Haefliger } 11099431996fSJuerg Haefliger break; 11109431996fSJuerg Haefliger case SYS_PWM_FREQ: 11119431996fSJuerg Haefliger res = PWM_FREQ_FROM_REG(data->pwm_freq[ix]); 11129431996fSJuerg Haefliger break; 11139431996fSJuerg Haefliger case SYS_PWM_ENABLE: 11149431996fSJuerg Haefliger if (ix > 3) { 11159431996fSJuerg Haefliger res = 1; /* pwm[5-6] hard-wired to manual mode */ 11169431996fSJuerg Haefliger } else { 11179431996fSJuerg Haefliger res = PWM_EN_FROM_REG(data->pwm_config[ix]); 11189431996fSJuerg Haefliger } 11199431996fSJuerg Haefliger break; 11209431996fSJuerg Haefliger case SYS_PWM_RAMP_RATE: 11219431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 11229431996fSJuerg Haefliger res = PWM_RR_FROM_REG(data->pwm_rr[ix > 0], ix); 11239431996fSJuerg Haefliger break; 11249431996fSJuerg Haefliger case SYS_PWM_AUTO_CHANNELS_ZONE: 11259431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 11269431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 11279431996fSJuerg Haefliger res = PWM_ACZ_FROM_REG(data->pwm_config[ix]); 11289431996fSJuerg Haefliger } else { 11299431996fSJuerg Haefliger res = data->pwm_acz[ix]; 11309431996fSJuerg Haefliger } 11319431996fSJuerg Haefliger break; 11329431996fSJuerg Haefliger case SYS_PWM_AUTO_PWM_MIN: 11339431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 11349431996fSJuerg Haefliger if (PWM_OFF_FROM_REG(data->pwm_rr[0], ix)) { 11359431996fSJuerg Haefliger res = data->pwm_min[ix]; 11369431996fSJuerg Haefliger } else { 11379431996fSJuerg Haefliger res = 0; 11389431996fSJuerg Haefliger } 11399431996fSJuerg Haefliger break; 11409431996fSJuerg Haefliger case SYS_PWM_AUTO_POINT1_PWM: 11419431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 11429431996fSJuerg Haefliger res = data->pwm_min[ix]; 11439431996fSJuerg Haefliger break; 11449431996fSJuerg Haefliger case SYS_PWM_AUTO_POINT2_PWM: 11459431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 11469431996fSJuerg Haefliger res = 255; /* hard-wired */ 11479431996fSJuerg Haefliger break; 11489431996fSJuerg Haefliger default: 11499431996fSJuerg Haefliger res = 0; 1150b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 11519431996fSJuerg Haefliger } 11529431996fSJuerg Haefliger 11539431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 11549431996fSJuerg Haefliger } 11559431996fSJuerg Haefliger 11569431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm[]; 1157b237eb25SJuerg Haefliger static void dme1737_chmod_file(struct device*, struct attribute*, mode_t); 11589431996fSJuerg Haefliger 11599431996fSJuerg Haefliger static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 11609431996fSJuerg Haefliger const char *buf, size_t count) 11619431996fSJuerg Haefliger { 1162b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 1163b237eb25SJuerg Haefliger struct i2c_client *client = &data->client; 11649431996fSJuerg Haefliger struct sensor_device_attribute_2 11659431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 11669431996fSJuerg Haefliger int ix = sensor_attr_2->index; 11679431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 11689431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 11699431996fSJuerg Haefliger 11709431996fSJuerg Haefliger mutex_lock(&data->update_lock); 11719431996fSJuerg Haefliger switch (fn) { 11729431996fSJuerg Haefliger case SYS_PWM: 11739431996fSJuerg Haefliger data->pwm[ix] = SENSORS_LIMIT(val, 0, 255); 11749431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM(ix), data->pwm[ix]); 11759431996fSJuerg Haefliger break; 11769431996fSJuerg Haefliger case SYS_PWM_FREQ: 11779431996fSJuerg Haefliger data->pwm_freq[ix] = PWM_FREQ_TO_REG(val, dme1737_read(client, 11789431996fSJuerg Haefliger DME1737_REG_PWM_FREQ(ix))); 11799431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM_FREQ(ix), 11809431996fSJuerg Haefliger data->pwm_freq[ix]); 11819431996fSJuerg Haefliger break; 11829431996fSJuerg Haefliger case SYS_PWM_ENABLE: 11839431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 11849431996fSJuerg Haefliger if (val < 0 || val > 2) { 11859431996fSJuerg Haefliger count = -EINVAL; 1186e95c237dSJuerg Haefliger dev_warn(dev, "PWM enable %ld not " 11879431996fSJuerg Haefliger "supported. Choose one of 0, 1, or 2.\n", 11889431996fSJuerg Haefliger val); 11899431996fSJuerg Haefliger goto exit; 11909431996fSJuerg Haefliger } 11919431996fSJuerg Haefliger /* Refresh the cache */ 11929431996fSJuerg Haefliger data->pwm_config[ix] = dme1737_read(client, 11939431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 11949431996fSJuerg Haefliger if (val == PWM_EN_FROM_REG(data->pwm_config[ix])) { 11959431996fSJuerg Haefliger /* Bail out if no change */ 11969431996fSJuerg Haefliger goto exit; 11979431996fSJuerg Haefliger } 11989431996fSJuerg Haefliger /* Do some housekeeping if we are currently in auto mode */ 11999431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 12009431996fSJuerg Haefliger /* Save the current zone channel assignment */ 12019431996fSJuerg Haefliger data->pwm_acz[ix] = PWM_ACZ_FROM_REG( 12029431996fSJuerg Haefliger data->pwm_config[ix]); 12039431996fSJuerg Haefliger /* Save the current ramp rate state and disable it */ 12049431996fSJuerg Haefliger data->pwm_rr[ix > 0] = dme1737_read(client, 12059431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0)); 12069431996fSJuerg Haefliger data->pwm_rr_en &= ~(1 << ix); 12079431996fSJuerg Haefliger if (PWM_RR_EN_FROM_REG(data->pwm_rr[ix > 0], ix)) { 12089431996fSJuerg Haefliger data->pwm_rr_en |= (1 << ix); 12099431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(0, ix, 12109431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 12119431996fSJuerg Haefliger dme1737_write(client, 12129431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0), 12139431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 12149431996fSJuerg Haefliger } 12159431996fSJuerg Haefliger } 12169431996fSJuerg Haefliger /* Set the new PWM mode */ 12179431996fSJuerg Haefliger switch (val) { 12189431996fSJuerg Haefliger case 0: 12199431996fSJuerg Haefliger /* Change permissions of pwm[ix] to read-only */ 1220b237eb25SJuerg Haefliger dme1737_chmod_file(dev, dme1737_attr_pwm[ix], 12219431996fSJuerg Haefliger S_IRUGO); 12229431996fSJuerg Haefliger /* Turn fan fully on */ 12239431996fSJuerg Haefliger data->pwm_config[ix] = PWM_EN_TO_REG(0, 12249431996fSJuerg Haefliger data->pwm_config[ix]); 12259431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM_CONFIG(ix), 12269431996fSJuerg Haefliger data->pwm_config[ix]); 12279431996fSJuerg Haefliger break; 12289431996fSJuerg Haefliger case 1: 12299431996fSJuerg Haefliger /* Turn on manual mode */ 12309431996fSJuerg Haefliger data->pwm_config[ix] = PWM_EN_TO_REG(1, 12319431996fSJuerg Haefliger data->pwm_config[ix]); 12329431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM_CONFIG(ix), 12339431996fSJuerg Haefliger data->pwm_config[ix]); 12349431996fSJuerg Haefliger /* Change permissions of pwm[ix] to read-writeable */ 1235b237eb25SJuerg Haefliger dme1737_chmod_file(dev, dme1737_attr_pwm[ix], 12369431996fSJuerg Haefliger S_IRUGO | S_IWUSR); 12379431996fSJuerg Haefliger break; 12389431996fSJuerg Haefliger case 2: 12399431996fSJuerg Haefliger /* Change permissions of pwm[ix] to read-only */ 1240b237eb25SJuerg Haefliger dme1737_chmod_file(dev, dme1737_attr_pwm[ix], 12419431996fSJuerg Haefliger S_IRUGO); 12429431996fSJuerg Haefliger /* Turn on auto mode using the saved zone channel 12439431996fSJuerg Haefliger * assignment */ 12449431996fSJuerg Haefliger data->pwm_config[ix] = PWM_ACZ_TO_REG( 12459431996fSJuerg Haefliger data->pwm_acz[ix], 12469431996fSJuerg Haefliger data->pwm_config[ix]); 12479431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM_CONFIG(ix), 12489431996fSJuerg Haefliger data->pwm_config[ix]); 12499431996fSJuerg Haefliger /* Enable PWM ramp rate if previously enabled */ 12509431996fSJuerg Haefliger if (data->pwm_rr_en & (1 << ix)) { 12519431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(1, ix, 12529431996fSJuerg Haefliger dme1737_read(client, 12539431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0))); 12549431996fSJuerg Haefliger dme1737_write(client, 12559431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0), 12569431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 12579431996fSJuerg Haefliger } 12589431996fSJuerg Haefliger break; 12599431996fSJuerg Haefliger } 12609431996fSJuerg Haefliger break; 12619431996fSJuerg Haefliger case SYS_PWM_RAMP_RATE: 12629431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 12639431996fSJuerg Haefliger /* Refresh the cache */ 12649431996fSJuerg Haefliger data->pwm_config[ix] = dme1737_read(client, 12659431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 12669431996fSJuerg Haefliger data->pwm_rr[ix > 0] = dme1737_read(client, 12679431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0)); 12689431996fSJuerg Haefliger /* Set the ramp rate value */ 12699431996fSJuerg Haefliger if (val > 0) { 12709431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_TO_REG(val, ix, 12719431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 12729431996fSJuerg Haefliger } 12739431996fSJuerg Haefliger /* Enable/disable the feature only if the associated PWM 12749431996fSJuerg Haefliger * output is in automatic mode. */ 12759431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 12769431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(val > 0, ix, 12779431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 12789431996fSJuerg Haefliger } 12799431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM_RR(ix > 0), 12809431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 12819431996fSJuerg Haefliger break; 12829431996fSJuerg Haefliger case SYS_PWM_AUTO_CHANNELS_ZONE: 12839431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 12849431996fSJuerg Haefliger if (!(val == 1 || val == 2 || val == 4 || 12859431996fSJuerg Haefliger val == 6 || val == 7)) { 12869431996fSJuerg Haefliger count = -EINVAL; 1287e95c237dSJuerg Haefliger dev_warn(dev, "PWM auto channels zone %ld " 12889431996fSJuerg Haefliger "not supported. Choose one of 1, 2, 4, 6, " 12899431996fSJuerg Haefliger "or 7.\n", val); 12909431996fSJuerg Haefliger goto exit; 12919431996fSJuerg Haefliger } 12929431996fSJuerg Haefliger /* Refresh the cache */ 12939431996fSJuerg Haefliger data->pwm_config[ix] = dme1737_read(client, 12949431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 12959431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 12969431996fSJuerg Haefliger /* PWM is already in auto mode so update the temp 12979431996fSJuerg Haefliger * channel assignment */ 12989431996fSJuerg Haefliger data->pwm_config[ix] = PWM_ACZ_TO_REG(val, 12999431996fSJuerg Haefliger data->pwm_config[ix]); 13009431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM_CONFIG(ix), 13019431996fSJuerg Haefliger data->pwm_config[ix]); 13029431996fSJuerg Haefliger } else { 13039431996fSJuerg Haefliger /* PWM is not in auto mode so we save the temp 13049431996fSJuerg Haefliger * channel assignment for later use */ 13059431996fSJuerg Haefliger data->pwm_acz[ix] = val; 13069431996fSJuerg Haefliger } 13079431996fSJuerg Haefliger break; 13089431996fSJuerg Haefliger case SYS_PWM_AUTO_PWM_MIN: 13099431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 13109431996fSJuerg Haefliger /* Refresh the cache */ 13119431996fSJuerg Haefliger data->pwm_min[ix] = dme1737_read(client, 13129431996fSJuerg Haefliger DME1737_REG_PWM_MIN(ix)); 13139431996fSJuerg Haefliger /* There are only 2 values supported for the auto_pwm_min 13149431996fSJuerg Haefliger * value: 0 or auto_point1_pwm. So if the temperature drops 13159431996fSJuerg Haefliger * below the auto_point1_temp_hyst value, the fan either turns 13169431996fSJuerg Haefliger * off or runs at auto_point1_pwm duty-cycle. */ 13179431996fSJuerg Haefliger if (val > ((data->pwm_min[ix] + 1) / 2)) { 13189431996fSJuerg Haefliger data->pwm_rr[0] = PWM_OFF_TO_REG(1, ix, 13199431996fSJuerg Haefliger dme1737_read(client, 13209431996fSJuerg Haefliger DME1737_REG_PWM_RR(0))); 13219431996fSJuerg Haefliger } else { 13229431996fSJuerg Haefliger data->pwm_rr[0] = PWM_OFF_TO_REG(0, ix, 13239431996fSJuerg Haefliger dme1737_read(client, 13249431996fSJuerg Haefliger DME1737_REG_PWM_RR(0))); 13259431996fSJuerg Haefliger } 13269431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM_RR(0), 13279431996fSJuerg Haefliger data->pwm_rr[0]); 13289431996fSJuerg Haefliger break; 13299431996fSJuerg Haefliger case SYS_PWM_AUTO_POINT1_PWM: 13309431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 13319431996fSJuerg Haefliger data->pwm_min[ix] = SENSORS_LIMIT(val, 0, 255); 13329431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM_MIN(ix), 13339431996fSJuerg Haefliger data->pwm_min[ix]); 13349431996fSJuerg Haefliger break; 13359431996fSJuerg Haefliger default: 1336b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 13379431996fSJuerg Haefliger } 13389431996fSJuerg Haefliger exit: 13399431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 13409431996fSJuerg Haefliger 13419431996fSJuerg Haefliger return count; 13429431996fSJuerg Haefliger } 13439431996fSJuerg Haefliger 13449431996fSJuerg Haefliger /* --------------------------------------------------------------------- 13459431996fSJuerg Haefliger * Miscellaneous sysfs attributes 13469431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 13479431996fSJuerg Haefliger 13489431996fSJuerg Haefliger static ssize_t show_vrm(struct device *dev, struct device_attribute *attr, 13499431996fSJuerg Haefliger char *buf) 13509431996fSJuerg Haefliger { 13519431996fSJuerg Haefliger struct i2c_client *client = to_i2c_client(dev); 13529431996fSJuerg Haefliger struct dme1737_data *data = i2c_get_clientdata(client); 13539431996fSJuerg Haefliger 13549431996fSJuerg Haefliger return sprintf(buf, "%d\n", data->vrm); 13559431996fSJuerg Haefliger } 13569431996fSJuerg Haefliger 13579431996fSJuerg Haefliger static ssize_t set_vrm(struct device *dev, struct device_attribute *attr, 13589431996fSJuerg Haefliger const char *buf, size_t count) 13599431996fSJuerg Haefliger { 1360b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 13619431996fSJuerg Haefliger long val = simple_strtol(buf, NULL, 10); 13629431996fSJuerg Haefliger 13639431996fSJuerg Haefliger data->vrm = val; 13649431996fSJuerg Haefliger return count; 13659431996fSJuerg Haefliger } 13669431996fSJuerg Haefliger 13679431996fSJuerg Haefliger static ssize_t show_vid(struct device *dev, struct device_attribute *attr, 13689431996fSJuerg Haefliger char *buf) 13699431996fSJuerg Haefliger { 13709431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 13719431996fSJuerg Haefliger 13729431996fSJuerg Haefliger return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm)); 13739431996fSJuerg Haefliger } 13749431996fSJuerg Haefliger 1375e95c237dSJuerg Haefliger static ssize_t show_name(struct device *dev, struct device_attribute *attr, 1376e95c237dSJuerg Haefliger char *buf) 1377e95c237dSJuerg Haefliger { 1378e95c237dSJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 1379e95c237dSJuerg Haefliger 1380e95c237dSJuerg Haefliger return sprintf(buf, "%s\n", data->client.name); 1381e95c237dSJuerg Haefliger } 1382e95c237dSJuerg Haefliger 13839431996fSJuerg Haefliger /* --------------------------------------------------------------------- 13849431996fSJuerg Haefliger * Sysfs device attribute defines and structs 13859431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 13869431996fSJuerg Haefliger 13879431996fSJuerg Haefliger /* Voltages 0-6 */ 13889431996fSJuerg Haefliger 13899431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_IN(ix) \ 13909431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_input, S_IRUGO, \ 13919431996fSJuerg Haefliger show_in, NULL, SYS_IN_INPUT, ix); \ 13929431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_min, S_IRUGO | S_IWUSR, \ 13939431996fSJuerg Haefliger show_in, set_in, SYS_IN_MIN, ix); \ 13949431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_max, S_IRUGO | S_IWUSR, \ 13959431996fSJuerg Haefliger show_in, set_in, SYS_IN_MAX, ix); \ 13969431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_alarm, S_IRUGO, \ 13979431996fSJuerg Haefliger show_in, NULL, SYS_IN_ALARM, ix) 13989431996fSJuerg Haefliger 13999431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(0); 14009431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(1); 14019431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(2); 14029431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(3); 14039431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(4); 14049431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(5); 14059431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(6); 14069431996fSJuerg Haefliger 14079431996fSJuerg Haefliger /* Temperatures 1-3 */ 14089431996fSJuerg Haefliger 14099431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_TEMP(ix) \ 14109431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_input, S_IRUGO, \ 14119431996fSJuerg Haefliger show_temp, NULL, SYS_TEMP_INPUT, ix-1); \ 14129431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_min, S_IRUGO | S_IWUSR, \ 14139431996fSJuerg Haefliger show_temp, set_temp, SYS_TEMP_MIN, ix-1); \ 14149431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_max, S_IRUGO | S_IWUSR, \ 14159431996fSJuerg Haefliger show_temp, set_temp, SYS_TEMP_MAX, ix-1); \ 14169431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_offset, S_IRUGO, \ 14179431996fSJuerg Haefliger show_temp, set_temp, SYS_TEMP_OFFSET, ix-1); \ 14189431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_alarm, S_IRUGO, \ 14199431996fSJuerg Haefliger show_temp, NULL, SYS_TEMP_ALARM, ix-1); \ 14209431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_fault, S_IRUGO, \ 14219431996fSJuerg Haefliger show_temp, NULL, SYS_TEMP_FAULT, ix-1) 14229431996fSJuerg Haefliger 14239431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_TEMP(1); 14249431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_TEMP(2); 14259431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_TEMP(3); 14269431996fSJuerg Haefliger 14279431996fSJuerg Haefliger /* Zones 1-3 */ 14289431996fSJuerg Haefliger 14299431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_ZONE(ix) \ 14309431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_channels_temp, S_IRUGO, \ 14319431996fSJuerg Haefliger show_zone, NULL, SYS_ZONE_AUTO_CHANNELS_TEMP, ix-1); \ 14329431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point1_temp_hyst, S_IRUGO, \ 14339431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT1_TEMP_HYST, ix-1); \ 14349431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point1_temp, S_IRUGO, \ 14359431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT1_TEMP, ix-1); \ 14369431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point2_temp, S_IRUGO, \ 14379431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT2_TEMP, ix-1); \ 14389431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point3_temp, S_IRUGO, \ 14399431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT3_TEMP, ix-1) 14409431996fSJuerg Haefliger 14419431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_ZONE(1); 14429431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_ZONE(2); 14439431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_ZONE(3); 14449431996fSJuerg Haefliger 14459431996fSJuerg Haefliger /* Fans 1-4 */ 14469431996fSJuerg Haefliger 14479431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_FAN_1TO4(ix) \ 14489431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_input, S_IRUGO, \ 14499431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_INPUT, ix-1); \ 14509431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \ 14519431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_MIN, ix-1); \ 14529431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_alarm, S_IRUGO, \ 14539431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_ALARM, ix-1); \ 14549431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_type, S_IRUGO | S_IWUSR, \ 14559431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_TYPE, ix-1) 14569431996fSJuerg Haefliger 14579431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(1); 14589431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(2); 14599431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(3); 14609431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(4); 14619431996fSJuerg Haefliger 14629431996fSJuerg Haefliger /* Fans 5-6 */ 14639431996fSJuerg Haefliger 14649431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_FAN_5TO6(ix) \ 14659431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_input, S_IRUGO, \ 14669431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_INPUT, ix-1); \ 14679431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \ 14689431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_MIN, ix-1); \ 14699431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_alarm, S_IRUGO, \ 14709431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_ALARM, ix-1); \ 14719431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_max, S_IRUGO | S_IWUSR, \ 14729431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_MAX, ix-1) 14739431996fSJuerg Haefliger 14749431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_5TO6(5); 14759431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_5TO6(6); 14769431996fSJuerg Haefliger 14779431996fSJuerg Haefliger /* PWMs 1-3 */ 14789431996fSJuerg Haefliger 14799431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_PWM_1TO3(ix) \ 14809431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \ 14819431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM, ix-1); \ 14829431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \ 14839431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \ 14849431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \ 14859431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_ENABLE, ix-1); \ 14869431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_ramp_rate, S_IRUGO, \ 14879431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_RAMP_RATE, ix-1); \ 14889431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_channels_zone, S_IRUGO, \ 14899431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_AUTO_CHANNELS_ZONE, ix-1); \ 14909431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_pwm_min, S_IRUGO, \ 14919431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_AUTO_PWM_MIN, ix-1); \ 14929431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point1_pwm, S_IRUGO, \ 14939431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_AUTO_POINT1_PWM, ix-1); \ 14949431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point2_pwm, S_IRUGO, \ 14959431996fSJuerg Haefliger show_pwm, NULL, SYS_PWM_AUTO_POINT2_PWM, ix-1) 14969431996fSJuerg Haefliger 14979431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_1TO3(1); 14989431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_1TO3(2); 14999431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_1TO3(3); 15009431996fSJuerg Haefliger 15019431996fSJuerg Haefliger /* PWMs 5-6 */ 15029431996fSJuerg Haefliger 15039431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_PWM_5TO6(ix) \ 1504*9b257714SJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \ 15059431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM, ix-1); \ 1506*9b257714SJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \ 15079431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \ 15089431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \ 15099431996fSJuerg Haefliger show_pwm, NULL, SYS_PWM_ENABLE, ix-1) 15109431996fSJuerg Haefliger 15119431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_5TO6(5); 15129431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_5TO6(6); 15139431996fSJuerg Haefliger 15149431996fSJuerg Haefliger /* Misc */ 15159431996fSJuerg Haefliger 15169431996fSJuerg Haefliger static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm); 15179431996fSJuerg Haefliger static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL); 1518e95c237dSJuerg Haefliger static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); /* for ISA devices */ 15199431996fSJuerg Haefliger 15209431996fSJuerg Haefliger /* This struct holds all the attributes that are always present and need to be 15219431996fSJuerg Haefliger * created unconditionally. The attributes that need modification of their 15229431996fSJuerg Haefliger * permissions are created read-only and write permissions are added or removed 15239431996fSJuerg Haefliger * on the fly when required */ 15249431996fSJuerg Haefliger static struct attribute *dme1737_attr[] ={ 15259431996fSJuerg Haefliger /* Voltages */ 1526*9b257714SJuerg Haefliger &sensor_dev_attr_in0_input.dev_attr.attr, 1527*9b257714SJuerg Haefliger &sensor_dev_attr_in0_min.dev_attr.attr, 1528*9b257714SJuerg Haefliger &sensor_dev_attr_in0_max.dev_attr.attr, 1529*9b257714SJuerg Haefliger &sensor_dev_attr_in0_alarm.dev_attr.attr, 1530*9b257714SJuerg Haefliger &sensor_dev_attr_in1_input.dev_attr.attr, 1531*9b257714SJuerg Haefliger &sensor_dev_attr_in1_min.dev_attr.attr, 1532*9b257714SJuerg Haefliger &sensor_dev_attr_in1_max.dev_attr.attr, 1533*9b257714SJuerg Haefliger &sensor_dev_attr_in1_alarm.dev_attr.attr, 1534*9b257714SJuerg Haefliger &sensor_dev_attr_in2_input.dev_attr.attr, 1535*9b257714SJuerg Haefliger &sensor_dev_attr_in2_min.dev_attr.attr, 1536*9b257714SJuerg Haefliger &sensor_dev_attr_in2_max.dev_attr.attr, 1537*9b257714SJuerg Haefliger &sensor_dev_attr_in2_alarm.dev_attr.attr, 1538*9b257714SJuerg Haefliger &sensor_dev_attr_in3_input.dev_attr.attr, 1539*9b257714SJuerg Haefliger &sensor_dev_attr_in3_min.dev_attr.attr, 1540*9b257714SJuerg Haefliger &sensor_dev_attr_in3_max.dev_attr.attr, 1541*9b257714SJuerg Haefliger &sensor_dev_attr_in3_alarm.dev_attr.attr, 1542*9b257714SJuerg Haefliger &sensor_dev_attr_in4_input.dev_attr.attr, 1543*9b257714SJuerg Haefliger &sensor_dev_attr_in4_min.dev_attr.attr, 1544*9b257714SJuerg Haefliger &sensor_dev_attr_in4_max.dev_attr.attr, 1545*9b257714SJuerg Haefliger &sensor_dev_attr_in4_alarm.dev_attr.attr, 1546*9b257714SJuerg Haefliger &sensor_dev_attr_in5_input.dev_attr.attr, 1547*9b257714SJuerg Haefliger &sensor_dev_attr_in5_min.dev_attr.attr, 1548*9b257714SJuerg Haefliger &sensor_dev_attr_in5_max.dev_attr.attr, 1549*9b257714SJuerg Haefliger &sensor_dev_attr_in5_alarm.dev_attr.attr, 1550*9b257714SJuerg Haefliger &sensor_dev_attr_in6_input.dev_attr.attr, 1551*9b257714SJuerg Haefliger &sensor_dev_attr_in6_min.dev_attr.attr, 1552*9b257714SJuerg Haefliger &sensor_dev_attr_in6_max.dev_attr.attr, 1553*9b257714SJuerg Haefliger &sensor_dev_attr_in6_alarm.dev_attr.attr, 15549431996fSJuerg Haefliger /* Temperatures */ 1555*9b257714SJuerg Haefliger &sensor_dev_attr_temp1_input.dev_attr.attr, 1556*9b257714SJuerg Haefliger &sensor_dev_attr_temp1_min.dev_attr.attr, 1557*9b257714SJuerg Haefliger &sensor_dev_attr_temp1_max.dev_attr.attr, 1558*9b257714SJuerg Haefliger &sensor_dev_attr_temp1_alarm.dev_attr.attr, 1559*9b257714SJuerg Haefliger &sensor_dev_attr_temp1_fault.dev_attr.attr, 1560*9b257714SJuerg Haefliger &sensor_dev_attr_temp1_offset.dev_attr.attr, 1561*9b257714SJuerg Haefliger &sensor_dev_attr_temp2_input.dev_attr.attr, 1562*9b257714SJuerg Haefliger &sensor_dev_attr_temp2_min.dev_attr.attr, 1563*9b257714SJuerg Haefliger &sensor_dev_attr_temp2_max.dev_attr.attr, 1564*9b257714SJuerg Haefliger &sensor_dev_attr_temp2_alarm.dev_attr.attr, 1565*9b257714SJuerg Haefliger &sensor_dev_attr_temp2_fault.dev_attr.attr, 1566*9b257714SJuerg Haefliger &sensor_dev_attr_temp2_offset.dev_attr.attr, 1567*9b257714SJuerg Haefliger &sensor_dev_attr_temp3_input.dev_attr.attr, 1568*9b257714SJuerg Haefliger &sensor_dev_attr_temp3_min.dev_attr.attr, 1569*9b257714SJuerg Haefliger &sensor_dev_attr_temp3_max.dev_attr.attr, 1570*9b257714SJuerg Haefliger &sensor_dev_attr_temp3_alarm.dev_attr.attr, 1571*9b257714SJuerg Haefliger &sensor_dev_attr_temp3_fault.dev_attr.attr, 1572*9b257714SJuerg Haefliger &sensor_dev_attr_temp3_offset.dev_attr.attr, 15739431996fSJuerg Haefliger /* Zones */ 1574*9b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr, 1575*9b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr, 1576*9b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr, 1577*9b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr, 1578*9b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_channels_temp.dev_attr.attr, 1579*9b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr, 1580*9b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr, 1581*9b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr, 1582*9b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr, 1583*9b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_channels_temp.dev_attr.attr, 1584*9b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr, 1585*9b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr, 1586*9b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr, 1587*9b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr, 1588*9b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_channels_temp.dev_attr.attr, 15899431996fSJuerg Haefliger /* Misc */ 15909431996fSJuerg Haefliger &dev_attr_vrm.attr, 15919431996fSJuerg Haefliger &dev_attr_cpu0_vid.attr, 15929431996fSJuerg Haefliger NULL 15939431996fSJuerg Haefliger }; 15949431996fSJuerg Haefliger 15959431996fSJuerg Haefliger static const struct attribute_group dme1737_group = { 15969431996fSJuerg Haefliger .attrs = dme1737_attr, 15979431996fSJuerg Haefliger }; 15989431996fSJuerg Haefliger 15999431996fSJuerg Haefliger /* The following structs hold the PWM attributes, some of which are optional. 16009431996fSJuerg Haefliger * Their creation depends on the chip configuration which is determined during 16019431996fSJuerg Haefliger * module load. */ 16029431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm1[] = { 1603*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1.dev_attr.attr, 1604*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_freq.dev_attr.attr, 1605*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_enable.dev_attr.attr, 1606*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr, 1607*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr, 1608*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr, 1609*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 1610*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 16119431996fSJuerg Haefliger NULL 16129431996fSJuerg Haefliger }; 16139431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm2[] = { 1614*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2.dev_attr.attr, 1615*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_freq.dev_attr.attr, 1616*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_enable.dev_attr.attr, 1617*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr, 1618*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr, 1619*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr, 1620*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 1621*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, 16229431996fSJuerg Haefliger NULL 16239431996fSJuerg Haefliger }; 16249431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm3[] = { 1625*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3.dev_attr.attr, 1626*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_freq.dev_attr.attr, 1627*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_enable.dev_attr.attr, 1628*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr, 1629*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr, 1630*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr, 1631*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 1632*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr, 16339431996fSJuerg Haefliger NULL 16349431996fSJuerg Haefliger }; 16359431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm5[] = { 1636*9b257714SJuerg Haefliger &sensor_dev_attr_pwm5.dev_attr.attr, 1637*9b257714SJuerg Haefliger &sensor_dev_attr_pwm5_freq.dev_attr.attr, 1638*9b257714SJuerg Haefliger &sensor_dev_attr_pwm5_enable.dev_attr.attr, 16399431996fSJuerg Haefliger NULL 16409431996fSJuerg Haefliger }; 16419431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm6[] = { 1642*9b257714SJuerg Haefliger &sensor_dev_attr_pwm6.dev_attr.attr, 1643*9b257714SJuerg Haefliger &sensor_dev_attr_pwm6_freq.dev_attr.attr, 1644*9b257714SJuerg Haefliger &sensor_dev_attr_pwm6_enable.dev_attr.attr, 16459431996fSJuerg Haefliger NULL 16469431996fSJuerg Haefliger }; 16479431996fSJuerg Haefliger 16489431996fSJuerg Haefliger static const struct attribute_group dme1737_pwm_group[] = { 16499431996fSJuerg Haefliger { .attrs = dme1737_attr_pwm1 }, 16509431996fSJuerg Haefliger { .attrs = dme1737_attr_pwm2 }, 16519431996fSJuerg Haefliger { .attrs = dme1737_attr_pwm3 }, 16529431996fSJuerg Haefliger { .attrs = NULL }, 16539431996fSJuerg Haefliger { .attrs = dme1737_attr_pwm5 }, 16549431996fSJuerg Haefliger { .attrs = dme1737_attr_pwm6 }, 16559431996fSJuerg Haefliger }; 16569431996fSJuerg Haefliger 16579431996fSJuerg Haefliger /* The following structs hold the fan attributes, some of which are optional. 16589431996fSJuerg Haefliger * Their creation depends on the chip configuration which is determined during 16599431996fSJuerg Haefliger * module load. */ 16609431996fSJuerg Haefliger static struct attribute *dme1737_attr_fan1[] = { 1661*9b257714SJuerg Haefliger &sensor_dev_attr_fan1_input.dev_attr.attr, 1662*9b257714SJuerg Haefliger &sensor_dev_attr_fan1_min.dev_attr.attr, 1663*9b257714SJuerg Haefliger &sensor_dev_attr_fan1_alarm.dev_attr.attr, 1664*9b257714SJuerg Haefliger &sensor_dev_attr_fan1_type.dev_attr.attr, 16659431996fSJuerg Haefliger NULL 16669431996fSJuerg Haefliger }; 16679431996fSJuerg Haefliger static struct attribute *dme1737_attr_fan2[] = { 1668*9b257714SJuerg Haefliger &sensor_dev_attr_fan2_input.dev_attr.attr, 1669*9b257714SJuerg Haefliger &sensor_dev_attr_fan2_min.dev_attr.attr, 1670*9b257714SJuerg Haefliger &sensor_dev_attr_fan2_alarm.dev_attr.attr, 1671*9b257714SJuerg Haefliger &sensor_dev_attr_fan2_type.dev_attr.attr, 16729431996fSJuerg Haefliger NULL 16739431996fSJuerg Haefliger }; 16749431996fSJuerg Haefliger static struct attribute *dme1737_attr_fan3[] = { 1675*9b257714SJuerg Haefliger &sensor_dev_attr_fan3_input.dev_attr.attr, 1676*9b257714SJuerg Haefliger &sensor_dev_attr_fan3_min.dev_attr.attr, 1677*9b257714SJuerg Haefliger &sensor_dev_attr_fan3_alarm.dev_attr.attr, 1678*9b257714SJuerg Haefliger &sensor_dev_attr_fan3_type.dev_attr.attr, 16799431996fSJuerg Haefliger NULL 16809431996fSJuerg Haefliger }; 16819431996fSJuerg Haefliger static struct attribute *dme1737_attr_fan4[] = { 1682*9b257714SJuerg Haefliger &sensor_dev_attr_fan4_input.dev_attr.attr, 1683*9b257714SJuerg Haefliger &sensor_dev_attr_fan4_min.dev_attr.attr, 1684*9b257714SJuerg Haefliger &sensor_dev_attr_fan4_alarm.dev_attr.attr, 1685*9b257714SJuerg Haefliger &sensor_dev_attr_fan4_type.dev_attr.attr, 16869431996fSJuerg Haefliger NULL 16879431996fSJuerg Haefliger }; 16889431996fSJuerg Haefliger static struct attribute *dme1737_attr_fan5[] = { 1689*9b257714SJuerg Haefliger &sensor_dev_attr_fan5_input.dev_attr.attr, 1690*9b257714SJuerg Haefliger &sensor_dev_attr_fan5_min.dev_attr.attr, 1691*9b257714SJuerg Haefliger &sensor_dev_attr_fan5_alarm.dev_attr.attr, 1692*9b257714SJuerg Haefliger &sensor_dev_attr_fan5_max.dev_attr.attr, 16939431996fSJuerg Haefliger NULL 16949431996fSJuerg Haefliger }; 16959431996fSJuerg Haefliger static struct attribute *dme1737_attr_fan6[] = { 1696*9b257714SJuerg Haefliger &sensor_dev_attr_fan6_input.dev_attr.attr, 1697*9b257714SJuerg Haefliger &sensor_dev_attr_fan6_min.dev_attr.attr, 1698*9b257714SJuerg Haefliger &sensor_dev_attr_fan6_alarm.dev_attr.attr, 1699*9b257714SJuerg Haefliger &sensor_dev_attr_fan6_max.dev_attr.attr, 17009431996fSJuerg Haefliger NULL 17019431996fSJuerg Haefliger }; 17029431996fSJuerg Haefliger 17039431996fSJuerg Haefliger static const struct attribute_group dme1737_fan_group[] = { 17049431996fSJuerg Haefliger { .attrs = dme1737_attr_fan1 }, 17059431996fSJuerg Haefliger { .attrs = dme1737_attr_fan2 }, 17069431996fSJuerg Haefliger { .attrs = dme1737_attr_fan3 }, 17079431996fSJuerg Haefliger { .attrs = dme1737_attr_fan4 }, 17089431996fSJuerg Haefliger { .attrs = dme1737_attr_fan5 }, 17099431996fSJuerg Haefliger { .attrs = dme1737_attr_fan6 }, 17109431996fSJuerg Haefliger }; 17119431996fSJuerg Haefliger 17129431996fSJuerg Haefliger /* The permissions of all of the following attributes are changed to read- 17139431996fSJuerg Haefliger * writeable if the chip is *not* locked. Otherwise they stay read-only. */ 17149431996fSJuerg Haefliger static struct attribute *dme1737_attr_lock[] = { 17159431996fSJuerg Haefliger /* Temperatures */ 1716*9b257714SJuerg Haefliger &sensor_dev_attr_temp1_offset.dev_attr.attr, 1717*9b257714SJuerg Haefliger &sensor_dev_attr_temp2_offset.dev_attr.attr, 1718*9b257714SJuerg Haefliger &sensor_dev_attr_temp3_offset.dev_attr.attr, 17199431996fSJuerg Haefliger /* Zones */ 1720*9b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr, 1721*9b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr, 1722*9b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr, 1723*9b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr, 1724*9b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr, 1725*9b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr, 1726*9b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr, 1727*9b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr, 1728*9b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr, 1729*9b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr, 1730*9b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr, 1731*9b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr, 17329431996fSJuerg Haefliger NULL 17339431996fSJuerg Haefliger }; 17349431996fSJuerg Haefliger 17359431996fSJuerg Haefliger static const struct attribute_group dme1737_lock_group = { 17369431996fSJuerg Haefliger .attrs = dme1737_attr_lock, 17379431996fSJuerg Haefliger }; 17389431996fSJuerg Haefliger 17399431996fSJuerg Haefliger /* The permissions of the following PWM attributes are changed to read- 17409431996fSJuerg Haefliger * writeable if the chip is *not* locked and the respective PWM is available. 17419431996fSJuerg Haefliger * Otherwise they stay read-only. */ 17429431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm1_lock[] = { 1743*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_freq.dev_attr.attr, 1744*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_enable.dev_attr.attr, 1745*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr, 1746*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr, 1747*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr, 1748*9b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 17499431996fSJuerg Haefliger NULL 17509431996fSJuerg Haefliger }; 17519431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm2_lock[] = { 1752*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_freq.dev_attr.attr, 1753*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_enable.dev_attr.attr, 1754*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr, 1755*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr, 1756*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr, 1757*9b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 17589431996fSJuerg Haefliger NULL 17599431996fSJuerg Haefliger }; 17609431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm3_lock[] = { 1761*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_freq.dev_attr.attr, 1762*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_enable.dev_attr.attr, 1763*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr, 1764*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr, 1765*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr, 1766*9b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 17679431996fSJuerg Haefliger NULL 17689431996fSJuerg Haefliger }; 17699431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm5_lock[] = { 1770*9b257714SJuerg Haefliger &sensor_dev_attr_pwm5.dev_attr.attr, 1771*9b257714SJuerg Haefliger &sensor_dev_attr_pwm5_freq.dev_attr.attr, 17729431996fSJuerg Haefliger NULL 17739431996fSJuerg Haefliger }; 17749431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm6_lock[] = { 1775*9b257714SJuerg Haefliger &sensor_dev_attr_pwm6.dev_attr.attr, 1776*9b257714SJuerg Haefliger &sensor_dev_attr_pwm6_freq.dev_attr.attr, 17779431996fSJuerg Haefliger NULL 17789431996fSJuerg Haefliger }; 17799431996fSJuerg Haefliger 17809431996fSJuerg Haefliger static const struct attribute_group dme1737_pwm_lock_group[] = { 17819431996fSJuerg Haefliger { .attrs = dme1737_attr_pwm1_lock }, 17829431996fSJuerg Haefliger { .attrs = dme1737_attr_pwm2_lock }, 17839431996fSJuerg Haefliger { .attrs = dme1737_attr_pwm3_lock }, 17849431996fSJuerg Haefliger { .attrs = NULL }, 17859431996fSJuerg Haefliger { .attrs = dme1737_attr_pwm5_lock }, 17869431996fSJuerg Haefliger { .attrs = dme1737_attr_pwm6_lock }, 17879431996fSJuerg Haefliger }; 17889431996fSJuerg Haefliger 17899431996fSJuerg Haefliger /* Pwm[1-3] are read-writeable if the associated pwm is in manual mode and the 17909431996fSJuerg Haefliger * chip is not locked. Otherwise they are read-only. */ 17919431996fSJuerg Haefliger static struct attribute *dme1737_attr_pwm[] = { 17929431996fSJuerg Haefliger &sensor_dev_attr_pwm1.dev_attr.attr, 17939431996fSJuerg Haefliger &sensor_dev_attr_pwm2.dev_attr.attr, 17949431996fSJuerg Haefliger &sensor_dev_attr_pwm3.dev_attr.attr, 17959431996fSJuerg Haefliger }; 17969431996fSJuerg Haefliger 17979431996fSJuerg Haefliger /* --------------------------------------------------------------------- 17989431996fSJuerg Haefliger * Super-IO functions 17999431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 18009431996fSJuerg Haefliger 1801b237eb25SJuerg Haefliger static inline void dme1737_sio_enter(int sio_cip) 1802b237eb25SJuerg Haefliger { 1803b237eb25SJuerg Haefliger outb(0x55, sio_cip); 1804b237eb25SJuerg Haefliger } 1805b237eb25SJuerg Haefliger 1806b237eb25SJuerg Haefliger static inline void dme1737_sio_exit(int sio_cip) 1807b237eb25SJuerg Haefliger { 1808b237eb25SJuerg Haefliger outb(0xaa, sio_cip); 1809b237eb25SJuerg Haefliger } 1810b237eb25SJuerg Haefliger 18119431996fSJuerg Haefliger static inline int dme1737_sio_inb(int sio_cip, int reg) 18129431996fSJuerg Haefliger { 18139431996fSJuerg Haefliger outb(reg, sio_cip); 18149431996fSJuerg Haefliger return inb(sio_cip + 1); 18159431996fSJuerg Haefliger } 18169431996fSJuerg Haefliger 18179431996fSJuerg Haefliger static inline void dme1737_sio_outb(int sio_cip, int reg, int val) 18189431996fSJuerg Haefliger { 18199431996fSJuerg Haefliger outb(reg, sio_cip); 18209431996fSJuerg Haefliger outb(val, sio_cip + 1); 18219431996fSJuerg Haefliger } 18229431996fSJuerg Haefliger 18239431996fSJuerg Haefliger /* --------------------------------------------------------------------- 1824e95c237dSJuerg Haefliger * Device initialization 18259431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 18269431996fSJuerg Haefliger 182767e2f328SJuerg Haefliger static int dme1737_i2c_get_features(int, struct dme1737_data*); 18289431996fSJuerg Haefliger 1829b237eb25SJuerg Haefliger static void dme1737_chmod_file(struct device *dev, 18309431996fSJuerg Haefliger struct attribute *attr, mode_t mode) 18319431996fSJuerg Haefliger { 1832b237eb25SJuerg Haefliger if (sysfs_chmod_file(&dev->kobj, attr, mode)) { 1833b237eb25SJuerg Haefliger dev_warn(dev, "Failed to change permissions of %s.\n", 18349431996fSJuerg Haefliger attr->name); 18359431996fSJuerg Haefliger } 18369431996fSJuerg Haefliger } 18379431996fSJuerg Haefliger 1838b237eb25SJuerg Haefliger static void dme1737_chmod_group(struct device *dev, 18399431996fSJuerg Haefliger const struct attribute_group *group, 18409431996fSJuerg Haefliger mode_t mode) 18419431996fSJuerg Haefliger { 18429431996fSJuerg Haefliger struct attribute **attr; 18439431996fSJuerg Haefliger 18449431996fSJuerg Haefliger for (attr = group->attrs; *attr; attr++) { 1845b237eb25SJuerg Haefliger dme1737_chmod_file(dev, *attr, mode); 18469431996fSJuerg Haefliger } 18479431996fSJuerg Haefliger } 18489431996fSJuerg Haefliger 1849b237eb25SJuerg Haefliger static void dme1737_remove_files(struct device *dev) 18509431996fSJuerg Haefliger { 1851b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 1852b237eb25SJuerg Haefliger int ix; 1853b237eb25SJuerg Haefliger 1854b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) { 1855b237eb25SJuerg Haefliger if (data->has_fan & (1 << ix)) { 1856b237eb25SJuerg Haefliger sysfs_remove_group(&dev->kobj, 1857b237eb25SJuerg Haefliger &dme1737_fan_group[ix]); 1858b237eb25SJuerg Haefliger } 1859b237eb25SJuerg Haefliger } 1860b237eb25SJuerg Haefliger 1861b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) { 1862b237eb25SJuerg Haefliger if (data->has_pwm & (1 << ix)) { 1863b237eb25SJuerg Haefliger sysfs_remove_group(&dev->kobj, 1864b237eb25SJuerg Haefliger &dme1737_pwm_group[ix]); 1865b237eb25SJuerg Haefliger } 1866b237eb25SJuerg Haefliger } 1867b237eb25SJuerg Haefliger 1868b237eb25SJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_group); 1869e95c237dSJuerg Haefliger 1870e95c237dSJuerg Haefliger if (!data->client.driver) { 1871e95c237dSJuerg Haefliger sysfs_remove_file(&dev->kobj, &dev_attr_name.attr); 1872e95c237dSJuerg Haefliger } 1873b237eb25SJuerg Haefliger } 1874b237eb25SJuerg Haefliger 1875b237eb25SJuerg Haefliger static int dme1737_create_files(struct device *dev) 1876b237eb25SJuerg Haefliger { 1877b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 1878b237eb25SJuerg Haefliger int err, ix; 1879b237eb25SJuerg Haefliger 1880e95c237dSJuerg Haefliger /* Create a name attribute for ISA devices */ 1881e95c237dSJuerg Haefliger if (!data->client.driver && 1882e95c237dSJuerg Haefliger (err = sysfs_create_file(&dev->kobj, &dev_attr_name.attr))) { 1883e95c237dSJuerg Haefliger goto exit; 1884e95c237dSJuerg Haefliger } 1885e95c237dSJuerg Haefliger 1886b237eb25SJuerg Haefliger /* Create standard sysfs attributes */ 1887b237eb25SJuerg Haefliger if ((err = sysfs_create_group(&dev->kobj, &dme1737_group))) { 1888e95c237dSJuerg Haefliger goto exit_remove; 1889b237eb25SJuerg Haefliger } 1890b237eb25SJuerg Haefliger 1891b237eb25SJuerg Haefliger /* Create fan sysfs attributes */ 1892b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) { 1893b237eb25SJuerg Haefliger if (data->has_fan & (1 << ix)) { 1894b237eb25SJuerg Haefliger if ((err = sysfs_create_group(&dev->kobj, 1895b237eb25SJuerg Haefliger &dme1737_fan_group[ix]))) { 1896b237eb25SJuerg Haefliger goto exit_remove; 1897b237eb25SJuerg Haefliger } 1898b237eb25SJuerg Haefliger } 1899b237eb25SJuerg Haefliger } 1900b237eb25SJuerg Haefliger 1901b237eb25SJuerg Haefliger /* Create PWM sysfs attributes */ 1902b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) { 1903b237eb25SJuerg Haefliger if (data->has_pwm & (1 << ix)) { 1904b237eb25SJuerg Haefliger if ((err = sysfs_create_group(&dev->kobj, 1905b237eb25SJuerg Haefliger &dme1737_pwm_group[ix]))) { 1906b237eb25SJuerg Haefliger goto exit_remove; 1907b237eb25SJuerg Haefliger } 1908b237eb25SJuerg Haefliger } 1909b237eb25SJuerg Haefliger } 1910b237eb25SJuerg Haefliger 1911b237eb25SJuerg Haefliger /* Inform if the device is locked. Otherwise change the permissions of 1912b237eb25SJuerg Haefliger * selected attributes from read-only to read-writeable. */ 1913b237eb25SJuerg Haefliger if (data->config & 0x02) { 1914b237eb25SJuerg Haefliger dev_info(dev, "Device is locked. Some attributes " 1915b237eb25SJuerg Haefliger "will be read-only.\n"); 1916b237eb25SJuerg Haefliger } else { 1917b237eb25SJuerg Haefliger /* Change permissions of standard attributes */ 1918b237eb25SJuerg Haefliger dme1737_chmod_group(dev, &dme1737_lock_group, 1919b237eb25SJuerg Haefliger S_IRUGO | S_IWUSR); 1920b237eb25SJuerg Haefliger 1921b237eb25SJuerg Haefliger /* Change permissions of PWM attributes */ 1922b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_lock_group); ix++) { 1923b237eb25SJuerg Haefliger if (data->has_pwm & (1 << ix)) { 1924b237eb25SJuerg Haefliger dme1737_chmod_group(dev, 1925b237eb25SJuerg Haefliger &dme1737_pwm_lock_group[ix], 1926b237eb25SJuerg Haefliger S_IRUGO | S_IWUSR); 1927b237eb25SJuerg Haefliger } 1928b237eb25SJuerg Haefliger } 1929b237eb25SJuerg Haefliger 1930b237eb25SJuerg Haefliger /* Change permissions of pwm[1-3] if in manual mode */ 1931b237eb25SJuerg Haefliger for (ix = 0; ix < 3; ix++) { 1932b237eb25SJuerg Haefliger if ((data->has_pwm & (1 << ix)) && 1933b237eb25SJuerg Haefliger (PWM_EN_FROM_REG(data->pwm_config[ix]) == 1)) { 1934b237eb25SJuerg Haefliger dme1737_chmod_file(dev, 1935b237eb25SJuerg Haefliger dme1737_attr_pwm[ix], 1936b237eb25SJuerg Haefliger S_IRUGO | S_IWUSR); 1937b237eb25SJuerg Haefliger } 1938b237eb25SJuerg Haefliger } 1939b237eb25SJuerg Haefliger } 1940b237eb25SJuerg Haefliger 1941b237eb25SJuerg Haefliger return 0; 1942b237eb25SJuerg Haefliger 1943b237eb25SJuerg Haefliger exit_remove: 1944b237eb25SJuerg Haefliger dme1737_remove_files(dev); 1945b237eb25SJuerg Haefliger exit: 1946b237eb25SJuerg Haefliger return err; 1947b237eb25SJuerg Haefliger } 1948b237eb25SJuerg Haefliger 1949b237eb25SJuerg Haefliger static int dme1737_init_device(struct device *dev) 1950b237eb25SJuerg Haefliger { 1951b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 1952b237eb25SJuerg Haefliger struct i2c_client *client = &data->client; 19539431996fSJuerg Haefliger int ix; 19549431996fSJuerg Haefliger u8 reg; 19559431996fSJuerg Haefliger 19569431996fSJuerg Haefliger data->config = dme1737_read(client, DME1737_REG_CONFIG); 19579431996fSJuerg Haefliger /* Inform if part is not monitoring/started */ 19589431996fSJuerg Haefliger if (!(data->config & 0x01)) { 19599431996fSJuerg Haefliger if (!force_start) { 1960b237eb25SJuerg Haefliger dev_err(dev, "Device is not monitoring. " 19619431996fSJuerg Haefliger "Use the force_start load parameter to " 19629431996fSJuerg Haefliger "override.\n"); 19639431996fSJuerg Haefliger return -EFAULT; 19649431996fSJuerg Haefliger } 19659431996fSJuerg Haefliger 19669431996fSJuerg Haefliger /* Force monitoring */ 19679431996fSJuerg Haefliger data->config |= 0x01; 19689431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_CONFIG, data->config); 19699431996fSJuerg Haefliger } 19709431996fSJuerg Haefliger /* Inform if part is not ready */ 19719431996fSJuerg Haefliger if (!(data->config & 0x04)) { 1972b237eb25SJuerg Haefliger dev_err(dev, "Device is not ready.\n"); 19739431996fSJuerg Haefliger return -EFAULT; 19749431996fSJuerg Haefliger } 19759431996fSJuerg Haefliger 1976e95c237dSJuerg Haefliger /* Determine which optional fan and pwm features are enabled/present */ 1977e95c237dSJuerg Haefliger if (client->driver) { /* I2C chip */ 19789431996fSJuerg Haefliger data->config2 = dme1737_read(client, DME1737_REG_CONFIG2); 19799431996fSJuerg Haefliger /* Check if optional fan3 input is enabled */ 19809431996fSJuerg Haefliger if (data->config2 & 0x04) { 19819431996fSJuerg Haefliger data->has_fan |= (1 << 2); 19829431996fSJuerg Haefliger } 19839431996fSJuerg Haefliger 19849431996fSJuerg Haefliger /* Fan4 and pwm3 are only available if the client's I2C address 1985e95c237dSJuerg Haefliger * is the default 0x2e. Otherwise the I/Os associated with 1986e95c237dSJuerg Haefliger * these functions are used for addr enable/select. */ 1987e95c237dSJuerg Haefliger if (data->client.addr == 0x2e) { 19889431996fSJuerg Haefliger data->has_fan |= (1 << 3); 19899431996fSJuerg Haefliger data->has_pwm |= (1 << 2); 19909431996fSJuerg Haefliger } 19919431996fSJuerg Haefliger 1992e95c237dSJuerg Haefliger /* Determine which of the optional fan[5-6] and pwm[5-6] 1993e95c237dSJuerg Haefliger * features are enabled. For this, we need to query the runtime 1994e95c237dSJuerg Haefliger * registers through the Super-IO LPC interface. Try both 1995e95c237dSJuerg Haefliger * config ports 0x2e and 0x4e. */ 1996b237eb25SJuerg Haefliger if (dme1737_i2c_get_features(0x2e, data) && 1997b237eb25SJuerg Haefliger dme1737_i2c_get_features(0x4e, data)) { 1998b237eb25SJuerg Haefliger dev_warn(dev, "Failed to query Super-IO for optional " 19999431996fSJuerg Haefliger "features.\n"); 20009431996fSJuerg Haefliger } 2001e95c237dSJuerg Haefliger } else { /* ISA chip */ 2002e95c237dSJuerg Haefliger /* Fan3 and pwm3 are always available. Fan[4-5] and pwm[5-6] 2003e95c237dSJuerg Haefliger * don't exist in the ISA chip. */ 2004e95c237dSJuerg Haefliger data->has_fan |= (1 << 2); 2005e95c237dSJuerg Haefliger data->has_pwm |= (1 << 2); 2006e95c237dSJuerg Haefliger } 20079431996fSJuerg Haefliger 20089431996fSJuerg Haefliger /* Fan1, fan2, pwm1, and pwm2 are always present */ 20099431996fSJuerg Haefliger data->has_fan |= 0x03; 20109431996fSJuerg Haefliger data->has_pwm |= 0x03; 20119431996fSJuerg Haefliger 2012b237eb25SJuerg Haefliger dev_info(dev, "Optional features: pwm3=%s, pwm5=%s, pwm6=%s, " 20139431996fSJuerg Haefliger "fan3=%s, fan4=%s, fan5=%s, fan6=%s.\n", 20149431996fSJuerg Haefliger (data->has_pwm & (1 << 2)) ? "yes" : "no", 20159431996fSJuerg Haefliger (data->has_pwm & (1 << 4)) ? "yes" : "no", 20169431996fSJuerg Haefliger (data->has_pwm & (1 << 5)) ? "yes" : "no", 20179431996fSJuerg Haefliger (data->has_fan & (1 << 2)) ? "yes" : "no", 20189431996fSJuerg Haefliger (data->has_fan & (1 << 3)) ? "yes" : "no", 20199431996fSJuerg Haefliger (data->has_fan & (1 << 4)) ? "yes" : "no", 20209431996fSJuerg Haefliger (data->has_fan & (1 << 5)) ? "yes" : "no"); 20219431996fSJuerg Haefliger 20229431996fSJuerg Haefliger reg = dme1737_read(client, DME1737_REG_TACH_PWM); 20239431996fSJuerg Haefliger /* Inform if fan-to-pwm mapping differs from the default */ 2024e95c237dSJuerg Haefliger if (client->driver && reg != 0xa4) { /* I2C chip */ 2025b237eb25SJuerg Haefliger dev_warn(dev, "Non-standard fan to pwm mapping: " 20269431996fSJuerg Haefliger "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d, " 20279431996fSJuerg Haefliger "fan4->pwm%d. Please report to the driver " 20289431996fSJuerg Haefliger "maintainer.\n", 20299431996fSJuerg Haefliger (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1, 20309431996fSJuerg Haefliger ((reg >> 4) & 0x03) + 1, ((reg >> 6) & 0x03) + 1); 2031e95c237dSJuerg Haefliger } else if (!client->driver && reg != 0x24) { /* ISA chip */ 2032e95c237dSJuerg Haefliger dev_warn(dev, "Non-standard fan to pwm mapping: " 2033e95c237dSJuerg Haefliger "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d. " 2034e95c237dSJuerg Haefliger "Please report to the driver maintainer.\n", 2035e95c237dSJuerg Haefliger (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1, 2036e95c237dSJuerg Haefliger ((reg >> 4) & 0x03) + 1); 20379431996fSJuerg Haefliger } 20389431996fSJuerg Haefliger 20399431996fSJuerg Haefliger /* Switch pwm[1-3] to manual mode if they are currently disabled and 20409431996fSJuerg Haefliger * set the duty-cycles to 0% (which is identical to the PWMs being 20419431996fSJuerg Haefliger * disabled). */ 20429431996fSJuerg Haefliger if (!(data->config & 0x02)) { 20439431996fSJuerg Haefliger for (ix = 0; ix < 3; ix++) { 20449431996fSJuerg Haefliger data->pwm_config[ix] = dme1737_read(client, 20459431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 20469431996fSJuerg Haefliger if ((data->has_pwm & (1 << ix)) && 20479431996fSJuerg Haefliger (PWM_EN_FROM_REG(data->pwm_config[ix]) == -1)) { 2048b237eb25SJuerg Haefliger dev_info(dev, "Switching pwm%d to " 20499431996fSJuerg Haefliger "manual mode.\n", ix + 1); 20509431996fSJuerg Haefliger data->pwm_config[ix] = PWM_EN_TO_REG(1, 20519431996fSJuerg Haefliger data->pwm_config[ix]); 20529431996fSJuerg Haefliger dme1737_write(client, DME1737_REG_PWM(ix), 0); 20539431996fSJuerg Haefliger dme1737_write(client, 20549431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix), 20559431996fSJuerg Haefliger data->pwm_config[ix]); 20569431996fSJuerg Haefliger } 20579431996fSJuerg Haefliger } 20589431996fSJuerg Haefliger } 20599431996fSJuerg Haefliger 20609431996fSJuerg Haefliger /* Initialize the default PWM auto channels zone (acz) assignments */ 20619431996fSJuerg Haefliger data->pwm_acz[0] = 1; /* pwm1 -> zone1 */ 20629431996fSJuerg Haefliger data->pwm_acz[1] = 2; /* pwm2 -> zone2 */ 20639431996fSJuerg Haefliger data->pwm_acz[2] = 4; /* pwm3 -> zone3 */ 20649431996fSJuerg Haefliger 20659431996fSJuerg Haefliger /* Set VRM */ 20669431996fSJuerg Haefliger data->vrm = vid_which_vrm(); 20679431996fSJuerg Haefliger 20689431996fSJuerg Haefliger return 0; 20699431996fSJuerg Haefliger } 20709431996fSJuerg Haefliger 207167e2f328SJuerg Haefliger /* --------------------------------------------------------------------- 207267e2f328SJuerg Haefliger * I2C device detection and registration 207367e2f328SJuerg Haefliger * --------------------------------------------------------------------- */ 207467e2f328SJuerg Haefliger 207567e2f328SJuerg Haefliger static struct i2c_driver dme1737_i2c_driver; 207667e2f328SJuerg Haefliger 207767e2f328SJuerg Haefliger static int dme1737_i2c_get_features(int sio_cip, struct dme1737_data *data) 207867e2f328SJuerg Haefliger { 20799431996fSJuerg Haefliger int err = 0, reg; 20809431996fSJuerg Haefliger u16 addr; 20819431996fSJuerg Haefliger 208267e2f328SJuerg Haefliger dme1737_sio_enter(sio_cip); 20839431996fSJuerg Haefliger 20849431996fSJuerg Haefliger /* Check device ID 20859431996fSJuerg Haefliger * The DME1737 can return either 0x78 or 0x77 as its device ID. */ 2086345a2224SJuerg Haefliger reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20); 20879431996fSJuerg Haefliger if (!(reg == 0x77 || reg == 0x78)) { 20889431996fSJuerg Haefliger err = -ENODEV; 20899431996fSJuerg Haefliger goto exit; 20909431996fSJuerg Haefliger } 20919431996fSJuerg Haefliger 20929431996fSJuerg Haefliger /* Select logical device A (runtime registers) */ 20939431996fSJuerg Haefliger dme1737_sio_outb(sio_cip, 0x07, 0x0a); 20949431996fSJuerg Haefliger 20959431996fSJuerg Haefliger /* Get the base address of the runtime registers */ 20969431996fSJuerg Haefliger if (!(addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) | 20979431996fSJuerg Haefliger dme1737_sio_inb(sio_cip, 0x61))) { 20989431996fSJuerg Haefliger err = -ENODEV; 20999431996fSJuerg Haefliger goto exit; 21009431996fSJuerg Haefliger } 21019431996fSJuerg Haefliger 21029431996fSJuerg Haefliger /* Read the runtime registers to determine which optional features 21039431996fSJuerg Haefliger * are enabled and available. Bits [3:2] of registers 0x43-0x46 are set 21049431996fSJuerg Haefliger * to '10' if the respective feature is enabled. */ 21059431996fSJuerg Haefliger if ((inb(addr + 0x43) & 0x0c) == 0x08) { /* fan6 */ 21069431996fSJuerg Haefliger data->has_fan |= (1 << 5); 21079431996fSJuerg Haefliger } 21089431996fSJuerg Haefliger if ((inb(addr + 0x44) & 0x0c) == 0x08) { /* pwm6 */ 21099431996fSJuerg Haefliger data->has_pwm |= (1 << 5); 21109431996fSJuerg Haefliger } 21119431996fSJuerg Haefliger if ((inb(addr + 0x45) & 0x0c) == 0x08) { /* fan5 */ 21129431996fSJuerg Haefliger data->has_fan |= (1 << 4); 21139431996fSJuerg Haefliger } 21149431996fSJuerg Haefliger if ((inb(addr + 0x46) & 0x0c) == 0x08) { /* pwm5 */ 21159431996fSJuerg Haefliger data->has_pwm |= (1 << 4); 21169431996fSJuerg Haefliger } 21179431996fSJuerg Haefliger 21189431996fSJuerg Haefliger exit: 211967e2f328SJuerg Haefliger dme1737_sio_exit(sio_cip); 21209431996fSJuerg Haefliger 21219431996fSJuerg Haefliger return err; 21229431996fSJuerg Haefliger } 21239431996fSJuerg Haefliger 2124b237eb25SJuerg Haefliger static int dme1737_i2c_detect(struct i2c_adapter *adapter, int address, 21259431996fSJuerg Haefliger int kind) 21269431996fSJuerg Haefliger { 21279431996fSJuerg Haefliger u8 company, verstep = 0; 21289431996fSJuerg Haefliger struct i2c_client *client; 21299431996fSJuerg Haefliger struct dme1737_data *data; 2130b237eb25SJuerg Haefliger struct device *dev; 2131b237eb25SJuerg Haefliger int err = 0; 21329431996fSJuerg Haefliger const char *name; 21339431996fSJuerg Haefliger 21349431996fSJuerg Haefliger if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 21359431996fSJuerg Haefliger goto exit; 21369431996fSJuerg Haefliger } 21379431996fSJuerg Haefliger 21389431996fSJuerg Haefliger if (!(data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL))) { 21399431996fSJuerg Haefliger err = -ENOMEM; 21409431996fSJuerg Haefliger goto exit; 21419431996fSJuerg Haefliger } 21429431996fSJuerg Haefliger 21439431996fSJuerg Haefliger client = &data->client; 21449431996fSJuerg Haefliger i2c_set_clientdata(client, data); 21459431996fSJuerg Haefliger client->addr = address; 21469431996fSJuerg Haefliger client->adapter = adapter; 2147b237eb25SJuerg Haefliger client->driver = &dme1737_i2c_driver; 2148b237eb25SJuerg Haefliger dev = &client->dev; 21499431996fSJuerg Haefliger 21509431996fSJuerg Haefliger /* A negative kind means that the driver was loaded with no force 21519431996fSJuerg Haefliger * parameter (default), so we must identify the chip. */ 21529431996fSJuerg Haefliger if (kind < 0) { 21539431996fSJuerg Haefliger company = dme1737_read(client, DME1737_REG_COMPANY); 21549431996fSJuerg Haefliger verstep = dme1737_read(client, DME1737_REG_VERSTEP); 21559431996fSJuerg Haefliger 21569431996fSJuerg Haefliger if (!((company == DME1737_COMPANY_SMSC) && 21579431996fSJuerg Haefliger ((verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP))) { 21589431996fSJuerg Haefliger err = -ENODEV; 21599431996fSJuerg Haefliger goto exit_kfree; 21609431996fSJuerg Haefliger } 21619431996fSJuerg Haefliger } 21629431996fSJuerg Haefliger 21639431996fSJuerg Haefliger kind = dme1737; 21649431996fSJuerg Haefliger name = "dme1737"; 21659431996fSJuerg Haefliger 21669431996fSJuerg Haefliger /* Fill in the remaining client fields and put it into the global 21679431996fSJuerg Haefliger * list */ 21689431996fSJuerg Haefliger strlcpy(client->name, name, I2C_NAME_SIZE); 21699431996fSJuerg Haefliger mutex_init(&data->update_lock); 21709431996fSJuerg Haefliger 21719431996fSJuerg Haefliger /* Tell the I2C layer a new client has arrived */ 21729431996fSJuerg Haefliger if ((err = i2c_attach_client(client))) { 21739431996fSJuerg Haefliger goto exit_kfree; 21749431996fSJuerg Haefliger } 21759431996fSJuerg Haefliger 2176b237eb25SJuerg Haefliger dev_info(dev, "Found a DME1737 chip at 0x%02x (rev 0x%02x).\n", 2177b237eb25SJuerg Haefliger client->addr, verstep); 2178b237eb25SJuerg Haefliger 21799431996fSJuerg Haefliger /* Initialize the DME1737 chip */ 2180b237eb25SJuerg Haefliger if ((err = dme1737_init_device(dev))) { 2181b237eb25SJuerg Haefliger dev_err(dev, "Failed to initialize device.\n"); 21829431996fSJuerg Haefliger goto exit_detach; 21839431996fSJuerg Haefliger } 21849431996fSJuerg Haefliger 2185b237eb25SJuerg Haefliger /* Create sysfs files */ 2186b237eb25SJuerg Haefliger if ((err = dme1737_create_files(dev))) { 2187b237eb25SJuerg Haefliger dev_err(dev, "Failed to create sysfs files.\n"); 21889431996fSJuerg Haefliger goto exit_detach; 21899431996fSJuerg Haefliger } 21909431996fSJuerg Haefliger 21919431996fSJuerg Haefliger /* Register device */ 219262ee3e10SMark M. Hoffman data->hwmon_dev = hwmon_device_register(dev); 21931beeffe4STony Jones if (IS_ERR(data->hwmon_dev)) { 2194b237eb25SJuerg Haefliger dev_err(dev, "Failed to register device.\n"); 21951beeffe4STony Jones err = PTR_ERR(data->hwmon_dev); 21969431996fSJuerg Haefliger goto exit_remove; 21979431996fSJuerg Haefliger } 21989431996fSJuerg Haefliger 21999431996fSJuerg Haefliger return 0; 22009431996fSJuerg Haefliger 22019431996fSJuerg Haefliger exit_remove: 2202b237eb25SJuerg Haefliger dme1737_remove_files(dev); 22039431996fSJuerg Haefliger exit_detach: 22049431996fSJuerg Haefliger i2c_detach_client(client); 22059431996fSJuerg Haefliger exit_kfree: 22069431996fSJuerg Haefliger kfree(data); 22079431996fSJuerg Haefliger exit: 22089431996fSJuerg Haefliger return err; 22099431996fSJuerg Haefliger } 22109431996fSJuerg Haefliger 2211b237eb25SJuerg Haefliger static int dme1737_i2c_attach_adapter(struct i2c_adapter *adapter) 22129431996fSJuerg Haefliger { 22139431996fSJuerg Haefliger if (!(adapter->class & I2C_CLASS_HWMON)) { 22149431996fSJuerg Haefliger return 0; 22159431996fSJuerg Haefliger } 22169431996fSJuerg Haefliger 2217b237eb25SJuerg Haefliger return i2c_probe(adapter, &addr_data, dme1737_i2c_detect); 22189431996fSJuerg Haefliger } 22199431996fSJuerg Haefliger 2220b237eb25SJuerg Haefliger static int dme1737_i2c_detach_client(struct i2c_client *client) 22219431996fSJuerg Haefliger { 22229431996fSJuerg Haefliger struct dme1737_data *data = i2c_get_clientdata(client); 2223b237eb25SJuerg Haefliger int err; 22249431996fSJuerg Haefliger 22251beeffe4STony Jones hwmon_device_unregister(data->hwmon_dev); 2226b237eb25SJuerg Haefliger dme1737_remove_files(&client->dev); 22279431996fSJuerg Haefliger 22289431996fSJuerg Haefliger if ((err = i2c_detach_client(client))) { 22299431996fSJuerg Haefliger return err; 22309431996fSJuerg Haefliger } 22319431996fSJuerg Haefliger 22329431996fSJuerg Haefliger kfree(data); 22339431996fSJuerg Haefliger return 0; 22349431996fSJuerg Haefliger } 22359431996fSJuerg Haefliger 2236b237eb25SJuerg Haefliger static struct i2c_driver dme1737_i2c_driver = { 22379431996fSJuerg Haefliger .driver = { 22389431996fSJuerg Haefliger .name = "dme1737", 22399431996fSJuerg Haefliger }, 2240b237eb25SJuerg Haefliger .attach_adapter = dme1737_i2c_attach_adapter, 2241b237eb25SJuerg Haefliger .detach_client = dme1737_i2c_detach_client, 22429431996fSJuerg Haefliger }; 22439431996fSJuerg Haefliger 224467e2f328SJuerg Haefliger /* --------------------------------------------------------------------- 2245e95c237dSJuerg Haefliger * ISA device detection and registration 2246e95c237dSJuerg Haefliger * --------------------------------------------------------------------- */ 2247e95c237dSJuerg Haefliger 2248e95c237dSJuerg Haefliger static int __init dme1737_isa_detect(int sio_cip, unsigned short *addr) 2249e95c237dSJuerg Haefliger { 2250e95c237dSJuerg Haefliger int err = 0, reg; 2251e95c237dSJuerg Haefliger unsigned short base_addr; 2252e95c237dSJuerg Haefliger 2253e95c237dSJuerg Haefliger dme1737_sio_enter(sio_cip); 2254e95c237dSJuerg Haefliger 2255e95c237dSJuerg Haefliger /* Check device ID 2256e95c237dSJuerg Haefliger * We currently know about SCH3112 (0x7c), SCH3114 (0x7d), and 2257e95c237dSJuerg Haefliger * SCH3116 (0x7f). */ 225867b671bcSJean Delvare reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20); 2259e95c237dSJuerg Haefliger if (!(reg == 0x7c || reg == 0x7d || reg == 0x7f)) { 2260e95c237dSJuerg Haefliger err = -ENODEV; 2261e95c237dSJuerg Haefliger goto exit; 2262e95c237dSJuerg Haefliger } 2263e95c237dSJuerg Haefliger 2264e95c237dSJuerg Haefliger /* Select logical device A (runtime registers) */ 2265e95c237dSJuerg Haefliger dme1737_sio_outb(sio_cip, 0x07, 0x0a); 2266e95c237dSJuerg Haefliger 2267e95c237dSJuerg Haefliger /* Get the base address of the runtime registers */ 2268e95c237dSJuerg Haefliger if (!(base_addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) | 2269e95c237dSJuerg Haefliger dme1737_sio_inb(sio_cip, 0x61))) { 2270e95c237dSJuerg Haefliger printk(KERN_ERR "dme1737: Base address not set.\n"); 2271e95c237dSJuerg Haefliger err = -ENODEV; 2272e95c237dSJuerg Haefliger goto exit; 2273e95c237dSJuerg Haefliger } 2274e95c237dSJuerg Haefliger 2275e95c237dSJuerg Haefliger /* Access to the hwmon registers is through an index/data register 2276e95c237dSJuerg Haefliger * pair located at offset 0x70/0x71. */ 2277e95c237dSJuerg Haefliger *addr = base_addr + 0x70; 2278e95c237dSJuerg Haefliger 2279e95c237dSJuerg Haefliger exit: 2280e95c237dSJuerg Haefliger dme1737_sio_exit(sio_cip); 2281e95c237dSJuerg Haefliger return err; 2282e95c237dSJuerg Haefliger } 2283e95c237dSJuerg Haefliger 2284e95c237dSJuerg Haefliger static int __init dme1737_isa_device_add(unsigned short addr) 2285e95c237dSJuerg Haefliger { 2286e95c237dSJuerg Haefliger struct resource res = { 2287e95c237dSJuerg Haefliger .start = addr, 2288e95c237dSJuerg Haefliger .end = addr + DME1737_EXTENT - 1, 2289e95c237dSJuerg Haefliger .name = "dme1737", 2290e95c237dSJuerg Haefliger .flags = IORESOURCE_IO, 2291e95c237dSJuerg Haefliger }; 2292e95c237dSJuerg Haefliger int err; 2293e95c237dSJuerg Haefliger 2294e95c237dSJuerg Haefliger if (!(pdev = platform_device_alloc("dme1737", addr))) { 2295e95c237dSJuerg Haefliger printk(KERN_ERR "dme1737: Failed to allocate device.\n"); 2296e95c237dSJuerg Haefliger err = -ENOMEM; 2297e95c237dSJuerg Haefliger goto exit; 2298e95c237dSJuerg Haefliger } 2299e95c237dSJuerg Haefliger 2300e95c237dSJuerg Haefliger if ((err = platform_device_add_resources(pdev, &res, 1))) { 2301e95c237dSJuerg Haefliger printk(KERN_ERR "dme1737: Failed to add device resource " 2302e95c237dSJuerg Haefliger "(err = %d).\n", err); 2303e95c237dSJuerg Haefliger goto exit_device_put; 2304e95c237dSJuerg Haefliger } 2305e95c237dSJuerg Haefliger 2306e95c237dSJuerg Haefliger if ((err = platform_device_add(pdev))) { 2307e95c237dSJuerg Haefliger printk(KERN_ERR "dme1737: Failed to add device (err = %d).\n", 2308e95c237dSJuerg Haefliger err); 2309e95c237dSJuerg Haefliger goto exit_device_put; 2310e95c237dSJuerg Haefliger } 2311e95c237dSJuerg Haefliger 2312e95c237dSJuerg Haefliger return 0; 2313e95c237dSJuerg Haefliger 2314e95c237dSJuerg Haefliger exit_device_put: 2315e95c237dSJuerg Haefliger platform_device_put(pdev); 2316e95c237dSJuerg Haefliger pdev = NULL; 2317e95c237dSJuerg Haefliger exit: 2318e95c237dSJuerg Haefliger return err; 2319e95c237dSJuerg Haefliger } 2320e95c237dSJuerg Haefliger 2321e95c237dSJuerg Haefliger static int __devinit dme1737_isa_probe(struct platform_device *pdev) 2322e95c237dSJuerg Haefliger { 2323e95c237dSJuerg Haefliger u8 company, device; 2324e95c237dSJuerg Haefliger struct resource *res; 2325e95c237dSJuerg Haefliger struct i2c_client *client; 2326e95c237dSJuerg Haefliger struct dme1737_data *data; 2327e95c237dSJuerg Haefliger struct device *dev = &pdev->dev; 2328e95c237dSJuerg Haefliger int err; 2329e95c237dSJuerg Haefliger 2330e95c237dSJuerg Haefliger res = platform_get_resource(pdev, IORESOURCE_IO, 0); 2331e95c237dSJuerg Haefliger if (!request_region(res->start, DME1737_EXTENT, "dme1737")) { 2332e95c237dSJuerg Haefliger dev_err(dev, "Failed to request region 0x%04x-0x%04x.\n", 2333e95c237dSJuerg Haefliger (unsigned short)res->start, 2334e95c237dSJuerg Haefliger (unsigned short)res->start + DME1737_EXTENT - 1); 2335e95c237dSJuerg Haefliger err = -EBUSY; 2336e95c237dSJuerg Haefliger goto exit; 2337e95c237dSJuerg Haefliger } 2338e95c237dSJuerg Haefliger 2339e95c237dSJuerg Haefliger if (!(data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL))) { 2340e95c237dSJuerg Haefliger err = -ENOMEM; 2341e95c237dSJuerg Haefliger goto exit_release_region; 2342e95c237dSJuerg Haefliger } 2343e95c237dSJuerg Haefliger 2344e95c237dSJuerg Haefliger client = &data->client; 2345e95c237dSJuerg Haefliger i2c_set_clientdata(client, data); 2346e95c237dSJuerg Haefliger client->addr = res->start; 2347e95c237dSJuerg Haefliger platform_set_drvdata(pdev, data); 2348e95c237dSJuerg Haefliger 2349e95c237dSJuerg Haefliger company = dme1737_read(client, DME1737_REG_COMPANY); 2350e95c237dSJuerg Haefliger device = dme1737_read(client, DME1737_REG_DEVICE); 2351e95c237dSJuerg Haefliger 2352e95c237dSJuerg Haefliger if (!((company == DME1737_COMPANY_SMSC) && 2353e95c237dSJuerg Haefliger (device == SCH311X_DEVICE))) { 2354e95c237dSJuerg Haefliger err = -ENODEV; 2355e95c237dSJuerg Haefliger goto exit_kfree; 2356e95c237dSJuerg Haefliger } 2357e95c237dSJuerg Haefliger 2358e95c237dSJuerg Haefliger /* Fill in the remaining client fields and initialize the mutex */ 2359e95c237dSJuerg Haefliger strlcpy(client->name, "sch311x", I2C_NAME_SIZE); 2360e95c237dSJuerg Haefliger mutex_init(&data->update_lock); 2361e95c237dSJuerg Haefliger 2362e95c237dSJuerg Haefliger dev_info(dev, "Found a SCH311x chip at 0x%04x\n", client->addr); 2363e95c237dSJuerg Haefliger 2364e95c237dSJuerg Haefliger /* Initialize the chip */ 2365e95c237dSJuerg Haefliger if ((err = dme1737_init_device(dev))) { 2366e95c237dSJuerg Haefliger dev_err(dev, "Failed to initialize device.\n"); 2367e95c237dSJuerg Haefliger goto exit_kfree; 2368e95c237dSJuerg Haefliger } 2369e95c237dSJuerg Haefliger 2370e95c237dSJuerg Haefliger /* Create sysfs files */ 2371e95c237dSJuerg Haefliger if ((err = dme1737_create_files(dev))) { 2372e95c237dSJuerg Haefliger dev_err(dev, "Failed to create sysfs files.\n"); 2373e95c237dSJuerg Haefliger goto exit_kfree; 2374e95c237dSJuerg Haefliger } 2375e95c237dSJuerg Haefliger 2376e95c237dSJuerg Haefliger /* Register device */ 2377e95c237dSJuerg Haefliger data->hwmon_dev = hwmon_device_register(dev); 2378e95c237dSJuerg Haefliger if (IS_ERR(data->hwmon_dev)) { 2379e95c237dSJuerg Haefliger dev_err(dev, "Failed to register device.\n"); 2380e95c237dSJuerg Haefliger err = PTR_ERR(data->hwmon_dev); 2381e95c237dSJuerg Haefliger goto exit_remove_files; 2382e95c237dSJuerg Haefliger } 2383e95c237dSJuerg Haefliger 2384e95c237dSJuerg Haefliger return 0; 2385e95c237dSJuerg Haefliger 2386e95c237dSJuerg Haefliger exit_remove_files: 2387e95c237dSJuerg Haefliger dme1737_remove_files(dev); 2388e95c237dSJuerg Haefliger exit_kfree: 2389e95c237dSJuerg Haefliger platform_set_drvdata(pdev, NULL); 2390e95c237dSJuerg Haefliger kfree(data); 2391e95c237dSJuerg Haefliger exit_release_region: 2392e95c237dSJuerg Haefliger release_region(res->start, DME1737_EXTENT); 2393e95c237dSJuerg Haefliger exit: 2394e95c237dSJuerg Haefliger return err; 2395e95c237dSJuerg Haefliger } 2396e95c237dSJuerg Haefliger 2397e95c237dSJuerg Haefliger static int __devexit dme1737_isa_remove(struct platform_device *pdev) 2398e95c237dSJuerg Haefliger { 2399e95c237dSJuerg Haefliger struct dme1737_data *data = platform_get_drvdata(pdev); 2400e95c237dSJuerg Haefliger 2401e95c237dSJuerg Haefliger hwmon_device_unregister(data->hwmon_dev); 2402e95c237dSJuerg Haefliger dme1737_remove_files(&pdev->dev); 2403e95c237dSJuerg Haefliger release_region(data->client.addr, DME1737_EXTENT); 2404e95c237dSJuerg Haefliger platform_set_drvdata(pdev, NULL); 2405e95c237dSJuerg Haefliger kfree(data); 2406e95c237dSJuerg Haefliger 2407e95c237dSJuerg Haefliger return 0; 2408e95c237dSJuerg Haefliger } 2409e95c237dSJuerg Haefliger 2410e95c237dSJuerg Haefliger static struct platform_driver dme1737_isa_driver = { 2411e95c237dSJuerg Haefliger .driver = { 2412e95c237dSJuerg Haefliger .owner = THIS_MODULE, 2413e95c237dSJuerg Haefliger .name = "dme1737", 2414e95c237dSJuerg Haefliger }, 2415e95c237dSJuerg Haefliger .probe = dme1737_isa_probe, 2416e95c237dSJuerg Haefliger .remove = __devexit_p(dme1737_isa_remove), 2417e95c237dSJuerg Haefliger }; 2418e95c237dSJuerg Haefliger 2419e95c237dSJuerg Haefliger /* --------------------------------------------------------------------- 242067e2f328SJuerg Haefliger * Module initialization and cleanup 242167e2f328SJuerg Haefliger * --------------------------------------------------------------------- */ 242267e2f328SJuerg Haefliger 24239431996fSJuerg Haefliger static int __init dme1737_init(void) 24249431996fSJuerg Haefliger { 2425e95c237dSJuerg Haefliger int err; 2426e95c237dSJuerg Haefliger unsigned short addr; 2427e95c237dSJuerg Haefliger 2428e95c237dSJuerg Haefliger if ((err = i2c_add_driver(&dme1737_i2c_driver))) { 2429e95c237dSJuerg Haefliger goto exit; 2430e95c237dSJuerg Haefliger } 2431e95c237dSJuerg Haefliger 2432e95c237dSJuerg Haefliger if (dme1737_isa_detect(0x2e, &addr) && 2433e95c237dSJuerg Haefliger dme1737_isa_detect(0x4e, &addr)) { 2434e95c237dSJuerg Haefliger /* Return 0 if we didn't find an ISA device */ 2435e95c237dSJuerg Haefliger return 0; 2436e95c237dSJuerg Haefliger } 2437e95c237dSJuerg Haefliger 2438e95c237dSJuerg Haefliger if ((err = platform_driver_register(&dme1737_isa_driver))) { 2439e95c237dSJuerg Haefliger goto exit_del_i2c_driver; 2440e95c237dSJuerg Haefliger } 2441e95c237dSJuerg Haefliger 2442e95c237dSJuerg Haefliger /* Sets global pdev as a side effect */ 2443e95c237dSJuerg Haefliger if ((err = dme1737_isa_device_add(addr))) { 2444e95c237dSJuerg Haefliger goto exit_del_isa_driver; 2445e95c237dSJuerg Haefliger } 2446e95c237dSJuerg Haefliger 2447e95c237dSJuerg Haefliger return 0; 2448e95c237dSJuerg Haefliger 2449e95c237dSJuerg Haefliger exit_del_isa_driver: 2450e95c237dSJuerg Haefliger platform_driver_unregister(&dme1737_isa_driver); 2451e95c237dSJuerg Haefliger exit_del_i2c_driver: 2452e95c237dSJuerg Haefliger i2c_del_driver(&dme1737_i2c_driver); 2453e95c237dSJuerg Haefliger exit: 2454e95c237dSJuerg Haefliger return err; 24559431996fSJuerg Haefliger } 24569431996fSJuerg Haefliger 24579431996fSJuerg Haefliger static void __exit dme1737_exit(void) 24589431996fSJuerg Haefliger { 2459e95c237dSJuerg Haefliger if (pdev) { 2460e95c237dSJuerg Haefliger platform_device_unregister(pdev); 2461e95c237dSJuerg Haefliger platform_driver_unregister(&dme1737_isa_driver); 2462e95c237dSJuerg Haefliger } 2463e95c237dSJuerg Haefliger 2464b237eb25SJuerg Haefliger i2c_del_driver(&dme1737_i2c_driver); 24659431996fSJuerg Haefliger } 24669431996fSJuerg Haefliger 24679431996fSJuerg Haefliger MODULE_AUTHOR("Juerg Haefliger <juergh@gmail.com>"); 24689431996fSJuerg Haefliger MODULE_DESCRIPTION("DME1737 sensors"); 24699431996fSJuerg Haefliger MODULE_LICENSE("GPL"); 24709431996fSJuerg Haefliger 24719431996fSJuerg Haefliger module_init(dme1737_init); 24729431996fSJuerg Haefliger module_exit(dme1737_exit); 2473