174ba9207SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later 29431996fSJuerg Haefliger /* 3ea694431SJuerg Haefliger * dme1737.c - Driver for the SMSC DME1737, Asus A8000, SMSC SCH311x, SCH5027, 4ea694431SJuerg Haefliger * and SCH5127 Super-I/O chips integrated hardware monitoring 5ea694431SJuerg Haefliger * features. 6ea694431SJuerg Haefliger * Copyright (c) 2007, 2008, 2009, 2010 Juerg Haefliger <juergh@gmail.com> 79431996fSJuerg Haefliger * 8e95c237dSJuerg Haefliger * This driver is an I2C/ISA hybrid, meaning that it uses the I2C bus to access 9549edb83SJuerg Haefliger * the chip registers if a DME1737, A8000, or SCH5027 is found and the ISA bus 10ea694431SJuerg Haefliger * if a SCH311x or SCH5127 chip is found. Both types of chips have very 11ea694431SJuerg Haefliger * similar hardware monitoring capabilities but differ in the way they can be 12ea694431SJuerg Haefliger * accessed. 139431996fSJuerg Haefliger */ 149431996fSJuerg Haefliger 159c6e13b4SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 169c6e13b4SJoe Perches 179431996fSJuerg Haefliger #include <linux/module.h> 189431996fSJuerg Haefliger #include <linux/init.h> 199431996fSJuerg Haefliger #include <linux/slab.h> 209431996fSJuerg Haefliger #include <linux/jiffies.h> 219431996fSJuerg Haefliger #include <linux/i2c.h> 22e95c237dSJuerg Haefliger #include <linux/platform_device.h> 239431996fSJuerg Haefliger #include <linux/hwmon.h> 249431996fSJuerg Haefliger #include <linux/hwmon-sysfs.h> 259431996fSJuerg Haefliger #include <linux/hwmon-vid.h> 269431996fSJuerg Haefliger #include <linux/err.h> 279431996fSJuerg Haefliger #include <linux/mutex.h> 28b9acb64aSJean Delvare #include <linux/acpi.h> 296055fae8SH Hartley Sweeten #include <linux/io.h> 309431996fSJuerg Haefliger 31e95c237dSJuerg Haefliger /* ISA device, if found */ 32e95c237dSJuerg Haefliger static struct platform_device *pdev; 33e95c237dSJuerg Haefliger 349431996fSJuerg Haefliger /* Module load parameters */ 3590ab5ee9SRusty Russell static bool force_start; 369431996fSJuerg Haefliger module_param(force_start, bool, 0); 379431996fSJuerg Haefliger MODULE_PARM_DESC(force_start, "Force the chip to start monitoring inputs"); 389431996fSJuerg Haefliger 3967b671bcSJean Delvare static unsigned short force_id; 4067b671bcSJean Delvare module_param(force_id, ushort, 0); 4167b671bcSJean Delvare MODULE_PARM_DESC(force_id, "Override the detected device ID"); 4267b671bcSJean Delvare 4390ab5ee9SRusty Russell static bool probe_all_addr; 4492430b6fSJuerg Haefliger module_param(probe_all_addr, bool, 0); 45b55f3757SGuenter Roeck MODULE_PARM_DESC(probe_all_addr, 46b55f3757SGuenter Roeck "Include probing of non-standard LPC addresses"); 4792430b6fSJuerg Haefliger 489431996fSJuerg Haefliger /* Addresses to scan */ 4925e9c86dSMark M. Hoffman static const unsigned short normal_i2c[] = {0x2c, 0x2d, 0x2e, I2C_CLIENT_END}; 509431996fSJuerg Haefliger 51ea694431SJuerg Haefliger enum chips { dme1737, sch5027, sch311x, sch5127 }; 529431996fSJuerg Haefliger 53b55f3757SGuenter Roeck #define DO_REPORT "Please report to the driver maintainer." 54b55f3757SGuenter Roeck 559431996fSJuerg Haefliger /* --------------------------------------------------------------------- 569431996fSJuerg Haefliger * Registers 579431996fSJuerg Haefliger * 589431996fSJuerg Haefliger * The sensors are defined as follows: 599431996fSJuerg Haefliger * 609431996fSJuerg Haefliger * Voltages Temperatures 619431996fSJuerg Haefliger * -------- ------------ 629431996fSJuerg Haefliger * in0 +5VTR (+5V stdby) temp1 Remote diode 1 639431996fSJuerg Haefliger * in1 Vccp (proc core) temp2 Internal temp 649431996fSJuerg Haefliger * in2 VCC (internal +3.3V) temp3 Remote diode 2 659431996fSJuerg Haefliger * in3 +5V 669431996fSJuerg Haefliger * in4 +12V 679431996fSJuerg Haefliger * in5 VTR (+3.3V stby) 689431996fSJuerg Haefliger * in6 Vbat 69d4b94e1fSJuerg Haefliger * in7 Vtrip (sch5127 only) 709431996fSJuerg Haefliger * 719431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 729431996fSJuerg Haefliger 73d4b94e1fSJuerg Haefliger /* Voltages (in) numbered 0-7 (ix) */ 74d4b94e1fSJuerg Haefliger #define DME1737_REG_IN(ix) ((ix) < 5 ? 0x20 + (ix) : \ 75d4b94e1fSJuerg Haefliger (ix) < 7 ? 0x94 + (ix) : \ 76d4b94e1fSJuerg Haefliger 0x1f) 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 89c8de8362SGuenter Roeck /* 90c8de8362SGuenter Roeck * Voltage and temperature LSBs 919431996fSJuerg Haefliger * The LSBs (4 bits each) are stored in 5 registers with the following layouts: 929431996fSJuerg Haefliger * IN_TEMP_LSB(0) = [in5, in6] 939431996fSJuerg Haefliger * IN_TEMP_LSB(1) = [temp3, temp1] 949431996fSJuerg Haefliger * IN_TEMP_LSB(2) = [in4, temp2] 959431996fSJuerg Haefliger * IN_TEMP_LSB(3) = [in3, in0] 96d4b94e1fSJuerg Haefliger * IN_TEMP_LSB(4) = [in2, in1] 97c8de8362SGuenter Roeck * IN_TEMP_LSB(5) = [res, in7] 98c8de8362SGuenter Roeck */ 999431996fSJuerg Haefliger #define DME1737_REG_IN_TEMP_LSB(ix) (0x84 + (ix)) 100d4b94e1fSJuerg Haefliger static const u8 DME1737_REG_IN_LSB[] = {3, 4, 4, 3, 2, 0, 0, 5}; 101d4b94e1fSJuerg Haefliger static const u8 DME1737_REG_IN_LSB_SHL[] = {4, 4, 0, 0, 0, 0, 4, 4}; 1029431996fSJuerg Haefliger static const u8 DME1737_REG_TEMP_LSB[] = {1, 2, 1}; 1039431996fSJuerg Haefliger static const u8 DME1737_REG_TEMP_LSB_SHL[] = {4, 4, 0}; 1049431996fSJuerg Haefliger 1059431996fSJuerg Haefliger /* Fans numbered 0-5 (ix) */ 1069431996fSJuerg Haefliger #define DME1737_REG_FAN(ix) ((ix) < 4 ? 0x28 + (ix) * 2 \ 1079431996fSJuerg Haefliger : 0xa1 + (ix) * 2) 1089431996fSJuerg Haefliger #define DME1737_REG_FAN_MIN(ix) ((ix) < 4 ? 0x54 + (ix) * 2 \ 1099431996fSJuerg Haefliger : 0xa5 + (ix) * 2) 1109431996fSJuerg Haefliger #define DME1737_REG_FAN_OPT(ix) ((ix) < 4 ? 0x90 + (ix) \ 1119431996fSJuerg Haefliger : 0xb2 + (ix)) 1129431996fSJuerg Haefliger #define DME1737_REG_FAN_MAX(ix) (0xb4 + (ix)) /* only for fan[4-5] */ 1139431996fSJuerg Haefliger 1149431996fSJuerg Haefliger /* PWMs numbered 0-2, 4-5 (ix) */ 1159431996fSJuerg Haefliger #define DME1737_REG_PWM(ix) ((ix) < 3 ? 0x30 + (ix) \ 1169431996fSJuerg Haefliger : 0xa1 + (ix)) 1179431996fSJuerg Haefliger #define DME1737_REG_PWM_CONFIG(ix) (0x5c + (ix)) /* only for pwm[0-2] */ 1189431996fSJuerg Haefliger #define DME1737_REG_PWM_MIN(ix) (0x64 + (ix)) /* only for pwm[0-2] */ 1199431996fSJuerg Haefliger #define DME1737_REG_PWM_FREQ(ix) ((ix) < 3 ? 0x5f + (ix) \ 1209431996fSJuerg Haefliger : 0xa3 + (ix)) 121c8de8362SGuenter Roeck /* 122c8de8362SGuenter Roeck * The layout of the ramp rate registers is different from the other pwm 1239431996fSJuerg Haefliger * registers. The bits for the 3 PWMs are stored in 2 registers: 1249431996fSJuerg Haefliger * PWM_RR(0) = [OFF3, OFF2, OFF1, RES, RR1E, RR1-2, RR1-1, RR1-0] 125c8de8362SGuenter Roeck * PWM_RR(1) = [RR2E, RR2-2, RR2-1, RR2-0, RR3E, RR3-2, RR3-1, RR3-0] 126c8de8362SGuenter Roeck */ 1279431996fSJuerg Haefliger #define DME1737_REG_PWM_RR(ix) (0x62 + (ix)) /* only for pwm[0-2] */ 1289431996fSJuerg Haefliger 1299431996fSJuerg Haefliger /* Thermal zones 0-2 */ 1309431996fSJuerg Haefliger #define DME1737_REG_ZONE_LOW(ix) (0x67 + (ix)) 1319431996fSJuerg Haefliger #define DME1737_REG_ZONE_ABS(ix) (0x6a + (ix)) 132c8de8362SGuenter Roeck /* 133c8de8362SGuenter Roeck * The layout of the hysteresis registers is different from the other zone 1349431996fSJuerg Haefliger * registers. The bits for the 3 zones are stored in 2 registers: 1359431996fSJuerg Haefliger * ZONE_HYST(0) = [H1-3, H1-2, H1-1, H1-0, H2-3, H2-2, H2-1, H2-0] 136c8de8362SGuenter Roeck * ZONE_HYST(1) = [H3-3, H3-2, H3-1, H3-0, RES, RES, RES, RES] 137c8de8362SGuenter Roeck */ 1389431996fSJuerg Haefliger #define DME1737_REG_ZONE_HYST(ix) (0x6d + (ix)) 1399431996fSJuerg Haefliger 140c8de8362SGuenter Roeck /* 141c8de8362SGuenter Roeck * Alarm registers and bit mapping 1429431996fSJuerg Haefliger * The 3 8-bit alarm registers will be concatenated to a single 32-bit 143c8de8362SGuenter Roeck * alarm value [0, ALARM3, ALARM2, ALARM1]. 144c8de8362SGuenter Roeck */ 1459431996fSJuerg Haefliger #define DME1737_REG_ALARM1 0x41 1469431996fSJuerg Haefliger #define DME1737_REG_ALARM2 0x42 1479431996fSJuerg Haefliger #define DME1737_REG_ALARM3 0x83 148d4b94e1fSJuerg Haefliger static const u8 DME1737_BIT_ALARM_IN[] = {0, 1, 2, 3, 8, 16, 17, 18}; 1499431996fSJuerg Haefliger static const u8 DME1737_BIT_ALARM_TEMP[] = {4, 5, 6}; 1509431996fSJuerg Haefliger static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23}; 1519431996fSJuerg Haefliger 1529431996fSJuerg Haefliger /* Miscellaneous registers */ 153e95c237dSJuerg Haefliger #define DME1737_REG_DEVICE 0x3d 1549431996fSJuerg Haefliger #define DME1737_REG_COMPANY 0x3e 1559431996fSJuerg Haefliger #define DME1737_REG_VERSTEP 0x3f 1569431996fSJuerg Haefliger #define DME1737_REG_CONFIG 0x40 1579431996fSJuerg Haefliger #define DME1737_REG_CONFIG2 0x7f 1589431996fSJuerg Haefliger #define DME1737_REG_VID 0x43 1599431996fSJuerg Haefliger #define DME1737_REG_TACH_PWM 0x81 1609431996fSJuerg Haefliger 1619431996fSJuerg Haefliger /* --------------------------------------------------------------------- 1629431996fSJuerg Haefliger * Misc defines 1639431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 1649431996fSJuerg Haefliger 1659431996fSJuerg Haefliger /* Chip identification */ 1669431996fSJuerg Haefliger #define DME1737_COMPANY_SMSC 0x5c 1679431996fSJuerg Haefliger #define DME1737_VERSTEP 0x88 1689431996fSJuerg Haefliger #define DME1737_VERSTEP_MASK 0xf8 169e95c237dSJuerg Haefliger #define SCH311X_DEVICE 0x8c 170549edb83SJuerg Haefliger #define SCH5027_VERSTEP 0x69 171ea694431SJuerg Haefliger #define SCH5127_DEVICE 0x8e 172ea694431SJuerg Haefliger 173ea694431SJuerg Haefliger /* Device ID values (global configuration register index 0x20) */ 174ea694431SJuerg Haefliger #define DME1737_ID_1 0x77 175ea694431SJuerg Haefliger #define DME1737_ID_2 0x78 176ea694431SJuerg Haefliger #define SCH3112_ID 0x7c 177ea694431SJuerg Haefliger #define SCH3114_ID 0x7d 178ea694431SJuerg Haefliger #define SCH3116_ID 0x7f 179ea694431SJuerg Haefliger #define SCH5027_ID 0x89 180ea694431SJuerg Haefliger #define SCH5127_ID 0x86 181e95c237dSJuerg Haefliger 182e95c237dSJuerg Haefliger /* Length of ISA address segment */ 183e95c237dSJuerg Haefliger #define DME1737_EXTENT 2 1849431996fSJuerg Haefliger 185ea694431SJuerg Haefliger /* chip-dependent features */ 186ea694431SJuerg Haefliger #define HAS_TEMP_OFFSET (1 << 0) /* bit 0 */ 187ea694431SJuerg Haefliger #define HAS_VID (1 << 1) /* bit 1 */ 188ea694431SJuerg Haefliger #define HAS_ZONE3 (1 << 2) /* bit 2 */ 189ea694431SJuerg Haefliger #define HAS_ZONE_HYST (1 << 3) /* bit 3 */ 190ea694431SJuerg Haefliger #define HAS_PWM_MIN (1 << 4) /* bit 4 */ 191ea694431SJuerg Haefliger #define HAS_FAN(ix) (1 << ((ix) + 5)) /* bits 5-10 */ 192ea694431SJuerg Haefliger #define HAS_PWM(ix) (1 << ((ix) + 11)) /* bits 11-16 */ 193d4b94e1fSJuerg Haefliger #define HAS_IN7 (1 << 17) /* bit 17 */ 194ea694431SJuerg Haefliger 1959431996fSJuerg Haefliger /* --------------------------------------------------------------------- 1969431996fSJuerg Haefliger * Data structures and manipulation thereof 1979431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 1989431996fSJuerg Haefliger 1999431996fSJuerg Haefliger struct dme1737_data { 200dbc2bc25SJean Delvare struct i2c_client *client; /* for I2C devices only */ 2011beeffe4STony Jones struct device *hwmon_dev; 202dbc2bc25SJean Delvare const char *name; 203dbc2bc25SJean Delvare unsigned int addr; /* for ISA devices only */ 2049431996fSJuerg Haefliger 2059431996fSJuerg Haefliger struct mutex update_lock; 206952a11caSPaul Fertser bool valid; /* true if following fields are valid */ 2079431996fSJuerg Haefliger unsigned long last_update; /* in jiffies */ 2089431996fSJuerg Haefliger unsigned long last_vbat; /* in jiffies */ 209f994fb23SJuerg Haefliger enum chips type; 210549edb83SJuerg Haefliger const int *in_nominal; /* pointer to IN_NOMINAL array */ 2119431996fSJuerg Haefliger 2129431996fSJuerg Haefliger u8 vid; 2139431996fSJuerg Haefliger u8 pwm_rr_en; 214ea694431SJuerg Haefliger u32 has_features; 2159431996fSJuerg Haefliger 2169431996fSJuerg Haefliger /* Register values */ 217d4b94e1fSJuerg Haefliger u16 in[8]; 218d4b94e1fSJuerg Haefliger u8 in_min[8]; 219d4b94e1fSJuerg Haefliger u8 in_max[8]; 2209431996fSJuerg Haefliger s16 temp[3]; 2219431996fSJuerg Haefliger s8 temp_min[3]; 2229431996fSJuerg Haefliger s8 temp_max[3]; 2239431996fSJuerg Haefliger s8 temp_offset[3]; 2249431996fSJuerg Haefliger u8 config; 2259431996fSJuerg Haefliger u8 config2; 2269431996fSJuerg Haefliger u8 vrm; 2279431996fSJuerg Haefliger u16 fan[6]; 2289431996fSJuerg Haefliger u16 fan_min[6]; 2299431996fSJuerg Haefliger u8 fan_max[2]; 2309431996fSJuerg Haefliger u8 fan_opt[6]; 2319431996fSJuerg Haefliger u8 pwm[6]; 2329431996fSJuerg Haefliger u8 pwm_min[3]; 2339431996fSJuerg Haefliger u8 pwm_config[3]; 2349431996fSJuerg Haefliger u8 pwm_acz[3]; 2359431996fSJuerg Haefliger u8 pwm_freq[6]; 2369431996fSJuerg Haefliger u8 pwm_rr[2]; 237d58e47d7SAxel Lin s8 zone_low[3]; 238d58e47d7SAxel Lin s8 zone_abs[3]; 2399431996fSJuerg Haefliger u8 zone_hyst[2]; 2409431996fSJuerg Haefliger u32 alarms; 2419431996fSJuerg Haefliger }; 2429431996fSJuerg Haefliger 2439431996fSJuerg Haefliger /* Nominal voltage values */ 244f994fb23SJuerg Haefliger static const int IN_NOMINAL_DME1737[] = {5000, 2250, 3300, 5000, 12000, 3300, 245f994fb23SJuerg Haefliger 3300}; 246f994fb23SJuerg Haefliger static const int IN_NOMINAL_SCH311x[] = {2500, 1500, 3300, 5000, 12000, 3300, 247f994fb23SJuerg Haefliger 3300}; 248549edb83SJuerg Haefliger static const int IN_NOMINAL_SCH5027[] = {5000, 2250, 3300, 1125, 1125, 3300, 249549edb83SJuerg Haefliger 3300}; 250ea694431SJuerg Haefliger static const int IN_NOMINAL_SCH5127[] = {2500, 2250, 3300, 1125, 1125, 3300, 251d4b94e1fSJuerg Haefliger 3300, 1500}; 252549edb83SJuerg Haefliger #define IN_NOMINAL(type) ((type) == sch311x ? IN_NOMINAL_SCH311x : \ 253549edb83SJuerg Haefliger (type) == sch5027 ? IN_NOMINAL_SCH5027 : \ 254ea694431SJuerg Haefliger (type) == sch5127 ? IN_NOMINAL_SCH5127 : \ 255549edb83SJuerg Haefliger IN_NOMINAL_DME1737) 2569431996fSJuerg Haefliger 257c8de8362SGuenter Roeck /* 258c8de8362SGuenter Roeck * Voltage input 2599431996fSJuerg Haefliger * Voltage inputs have 16 bits resolution, limit values have 8 bits 260c8de8362SGuenter Roeck * resolution. 261c8de8362SGuenter Roeck */ 262549edb83SJuerg Haefliger static inline int IN_FROM_REG(int reg, int nominal, int res) 2639431996fSJuerg Haefliger { 264549edb83SJuerg Haefliger return (reg * nominal + (3 << (res - 3))) / (3 << (res - 2)); 2659431996fSJuerg Haefliger } 2669431996fSJuerg Haefliger 267d58e47d7SAxel Lin static inline int IN_TO_REG(long val, int nominal) 2689431996fSJuerg Haefliger { 26907cc189dSGuenter Roeck val = clamp_val(val, 0, 255 * nominal / 192); 27007cc189dSGuenter Roeck return DIV_ROUND_CLOSEST(val * 192, nominal); 2719431996fSJuerg Haefliger } 2729431996fSJuerg Haefliger 273c8de8362SGuenter Roeck /* 274c8de8362SGuenter Roeck * Temperature input 2759431996fSJuerg Haefliger * The register values represent temperatures in 2's complement notation from 2769431996fSJuerg Haefliger * -127 degrees C to +127 degrees C. Temp inputs have 16 bits resolution, limit 277c8de8362SGuenter Roeck * values have 8 bits resolution. 278c8de8362SGuenter Roeck */ 2799431996fSJuerg Haefliger static inline int TEMP_FROM_REG(int reg, int res) 2809431996fSJuerg Haefliger { 2819431996fSJuerg Haefliger return (reg * 1000) >> (res - 8); 2829431996fSJuerg Haefliger } 2839431996fSJuerg Haefliger 284d58e47d7SAxel Lin static inline int TEMP_TO_REG(long val) 2859431996fSJuerg Haefliger { 28607cc189dSGuenter Roeck val = clamp_val(val, -128000, 127000); 28707cc189dSGuenter Roeck return DIV_ROUND_CLOSEST(val, 1000); 2889431996fSJuerg Haefliger } 2899431996fSJuerg Haefliger 2909431996fSJuerg Haefliger /* Temperature range */ 2919431996fSJuerg Haefliger static const int TEMP_RANGE[] = {2000, 2500, 3333, 4000, 5000, 6666, 8000, 2929431996fSJuerg Haefliger 10000, 13333, 16000, 20000, 26666, 32000, 2939431996fSJuerg Haefliger 40000, 53333, 80000}; 2949431996fSJuerg Haefliger 2959431996fSJuerg Haefliger static inline int TEMP_RANGE_FROM_REG(int reg) 2969431996fSJuerg Haefliger { 2979431996fSJuerg Haefliger return TEMP_RANGE[(reg >> 4) & 0x0f]; 2989431996fSJuerg Haefliger } 2999431996fSJuerg Haefliger 300d58e47d7SAxel Lin static int TEMP_RANGE_TO_REG(long val, int reg) 3019431996fSJuerg Haefliger { 3029431996fSJuerg Haefliger int i; 3039431996fSJuerg Haefliger 3049431996fSJuerg Haefliger for (i = 15; i > 0; i--) { 305c8de8362SGuenter Roeck if (val > (TEMP_RANGE[i] + TEMP_RANGE[i - 1] + 1) / 2) 3069431996fSJuerg Haefliger break; 3079431996fSJuerg Haefliger } 3089431996fSJuerg Haefliger 3099431996fSJuerg Haefliger return (reg & 0x0f) | (i << 4); 3109431996fSJuerg Haefliger } 3119431996fSJuerg Haefliger 312c8de8362SGuenter Roeck /* 313c8de8362SGuenter Roeck * Temperature hysteresis 3149431996fSJuerg Haefliger * Register layout: 3159431996fSJuerg Haefliger * reg[0] = [H1-3, H1-2, H1-1, H1-0, H2-3, H2-2, H2-1, H2-0] 316c8de8362SGuenter Roeck * reg[1] = [H3-3, H3-2, H3-1, H3-0, xxxx, xxxx, xxxx, xxxx] 317c8de8362SGuenter Roeck */ 3189431996fSJuerg Haefliger static inline int TEMP_HYST_FROM_REG(int reg, int ix) 3199431996fSJuerg Haefliger { 3209431996fSJuerg Haefliger return (((ix == 1) ? reg : reg >> 4) & 0x0f) * 1000; 3219431996fSJuerg Haefliger } 3229431996fSJuerg Haefliger 32307cc189dSGuenter Roeck static inline int TEMP_HYST_TO_REG(int temp, long hyst, int ix, int reg) 3249431996fSJuerg Haefliger { 32507cc189dSGuenter Roeck hyst = clamp_val(hyst, temp - 15000, temp); 32607cc189dSGuenter Roeck hyst = DIV_ROUND_CLOSEST(temp - hyst, 1000); 3279431996fSJuerg Haefliger 3289431996fSJuerg Haefliger return (ix == 1) ? (reg & 0xf0) | hyst : (reg & 0x0f) | (hyst << 4); 3299431996fSJuerg Haefliger } 3309431996fSJuerg Haefliger 3319431996fSJuerg Haefliger /* Fan input RPM */ 3329431996fSJuerg Haefliger static inline int FAN_FROM_REG(int reg, int tpc) 3339431996fSJuerg Haefliger { 334c8de8362SGuenter Roeck if (tpc) 335ff8421f7SJuerg Haefliger return tpc * reg; 336c8de8362SGuenter Roeck else 337ff8421f7SJuerg Haefliger return (reg == 0 || reg == 0xffff) ? 0 : 90000 * 60 / reg; 338ff8421f7SJuerg Haefliger } 3399431996fSJuerg Haefliger 340d58e47d7SAxel Lin static inline int FAN_TO_REG(long val, int tpc) 3419431996fSJuerg Haefliger { 342ff8421f7SJuerg Haefliger if (tpc) { 3432a844c14SGuenter Roeck return clamp_val(val / tpc, 0, 0xffff); 344ff8421f7SJuerg Haefliger } else { 345ff8421f7SJuerg Haefliger return (val <= 0) ? 0xffff : 3462a844c14SGuenter Roeck clamp_val(90000 * 60 / val, 0, 0xfffe); 347ff8421f7SJuerg Haefliger } 3489431996fSJuerg Haefliger } 3499431996fSJuerg Haefliger 350c8de8362SGuenter Roeck /* 351c8de8362SGuenter Roeck * Fan TPC (tach pulse count) 3529431996fSJuerg Haefliger * Converts a register value to a TPC multiplier or returns 0 if the tachometer 353c8de8362SGuenter Roeck * is configured in legacy (non-tpc) mode 354c8de8362SGuenter Roeck */ 3559431996fSJuerg Haefliger static inline int FAN_TPC_FROM_REG(int reg) 3569431996fSJuerg Haefliger { 3579431996fSJuerg Haefliger return (reg & 0x20) ? 0 : 60 >> (reg & 0x03); 3589431996fSJuerg Haefliger } 3599431996fSJuerg Haefliger 360c8de8362SGuenter Roeck /* 361c8de8362SGuenter Roeck * Fan type 3629431996fSJuerg Haefliger * The type of a fan is expressed in number of pulses-per-revolution that it 363c8de8362SGuenter Roeck * emits 364c8de8362SGuenter Roeck */ 3659431996fSJuerg Haefliger static inline int FAN_TYPE_FROM_REG(int reg) 3669431996fSJuerg Haefliger { 3679431996fSJuerg Haefliger int edge = (reg >> 1) & 0x03; 3689431996fSJuerg Haefliger 3699431996fSJuerg Haefliger return (edge > 0) ? 1 << (edge - 1) : 0; 3709431996fSJuerg Haefliger } 3719431996fSJuerg Haefliger 372d58e47d7SAxel Lin static inline int FAN_TYPE_TO_REG(long val, int reg) 3739431996fSJuerg Haefliger { 3749431996fSJuerg Haefliger int edge = (val == 4) ? 3 : val; 3759431996fSJuerg Haefliger 3769431996fSJuerg Haefliger return (reg & 0xf9) | (edge << 1); 3779431996fSJuerg Haefliger } 3789431996fSJuerg Haefliger 3799431996fSJuerg Haefliger /* Fan max RPM */ 3809431996fSJuerg Haefliger static const int FAN_MAX[] = {0x54, 0x38, 0x2a, 0x21, 0x1c, 0x18, 0x15, 0x12, 3819431996fSJuerg Haefliger 0x11, 0x0f, 0x0e}; 3829431996fSJuerg Haefliger 3839431996fSJuerg Haefliger static int FAN_MAX_FROM_REG(int reg) 3849431996fSJuerg Haefliger { 3859431996fSJuerg Haefliger int i; 3869431996fSJuerg Haefliger 3879431996fSJuerg Haefliger for (i = 10; i > 0; i--) { 388c8de8362SGuenter Roeck if (reg == FAN_MAX[i]) 3899431996fSJuerg Haefliger break; 3909431996fSJuerg Haefliger } 3919431996fSJuerg Haefliger 3929431996fSJuerg Haefliger return 1000 + i * 500; 3939431996fSJuerg Haefliger } 3949431996fSJuerg Haefliger 395d58e47d7SAxel Lin static int FAN_MAX_TO_REG(long val) 3969431996fSJuerg Haefliger { 3979431996fSJuerg Haefliger int i; 3989431996fSJuerg Haefliger 3999431996fSJuerg Haefliger for (i = 10; i > 0; i--) { 400c8de8362SGuenter Roeck if (val > (1000 + (i - 1) * 500)) 4019431996fSJuerg Haefliger break; 4029431996fSJuerg Haefliger } 4039431996fSJuerg Haefliger 4049431996fSJuerg Haefliger return FAN_MAX[i]; 4059431996fSJuerg Haefliger } 4069431996fSJuerg Haefliger 407c8de8362SGuenter Roeck /* 408c8de8362SGuenter Roeck * PWM enable 4099431996fSJuerg Haefliger * Register to enable mapping: 4109431996fSJuerg Haefliger * 000: 2 fan on zone 1 auto 4119431996fSJuerg Haefliger * 001: 2 fan on zone 2 auto 4129431996fSJuerg Haefliger * 010: 2 fan on zone 3 auto 4139431996fSJuerg Haefliger * 011: 0 fan full on 4149431996fSJuerg Haefliger * 100: -1 fan disabled 4159431996fSJuerg Haefliger * 101: 2 fan on hottest of zones 2,3 auto 4169431996fSJuerg Haefliger * 110: 2 fan on hottest of zones 1,2,3 auto 417c8de8362SGuenter Roeck * 111: 1 fan in manual mode 418c8de8362SGuenter Roeck */ 4199431996fSJuerg Haefliger static inline int PWM_EN_FROM_REG(int reg) 4209431996fSJuerg Haefliger { 4219431996fSJuerg Haefliger static const int en[] = {2, 2, 2, 0, -1, 2, 2, 1}; 4229431996fSJuerg Haefliger 4239431996fSJuerg Haefliger return en[(reg >> 5) & 0x07]; 4249431996fSJuerg Haefliger } 4259431996fSJuerg Haefliger 4269431996fSJuerg Haefliger static inline int PWM_EN_TO_REG(int val, int reg) 4279431996fSJuerg Haefliger { 4289431996fSJuerg Haefliger int en = (val == 1) ? 7 : 3; 4299431996fSJuerg Haefliger 4309431996fSJuerg Haefliger return (reg & 0x1f) | ((en & 0x07) << 5); 4319431996fSJuerg Haefliger } 4329431996fSJuerg Haefliger 433c8de8362SGuenter Roeck /* 434c8de8362SGuenter Roeck * PWM auto channels zone 4359431996fSJuerg Haefliger * Register to auto channels zone mapping (ACZ is a bitfield with bit x 4369431996fSJuerg Haefliger * corresponding to zone x+1): 4379431996fSJuerg Haefliger * 000: 001 fan on zone 1 auto 4389431996fSJuerg Haefliger * 001: 010 fan on zone 2 auto 4399431996fSJuerg Haefliger * 010: 100 fan on zone 3 auto 4409431996fSJuerg Haefliger * 011: 000 fan full on 4419431996fSJuerg Haefliger * 100: 000 fan disabled 4429431996fSJuerg Haefliger * 101: 110 fan on hottest of zones 2,3 auto 4439431996fSJuerg Haefliger * 110: 111 fan on hottest of zones 1,2,3 auto 444c8de8362SGuenter Roeck * 111: 000 fan in manual mode 445c8de8362SGuenter Roeck */ 4469431996fSJuerg Haefliger static inline int PWM_ACZ_FROM_REG(int reg) 4479431996fSJuerg Haefliger { 4489431996fSJuerg Haefliger static const int acz[] = {1, 2, 4, 0, 0, 6, 7, 0}; 4499431996fSJuerg Haefliger 4509431996fSJuerg Haefliger return acz[(reg >> 5) & 0x07]; 4519431996fSJuerg Haefliger } 4529431996fSJuerg Haefliger 453d58e47d7SAxel Lin static inline int PWM_ACZ_TO_REG(long val, int reg) 4549431996fSJuerg Haefliger { 4559431996fSJuerg Haefliger int acz = (val == 4) ? 2 : val - 1; 4569431996fSJuerg Haefliger 4579431996fSJuerg Haefliger return (reg & 0x1f) | ((acz & 0x07) << 5); 4589431996fSJuerg Haefliger } 4599431996fSJuerg Haefliger 4609431996fSJuerg Haefliger /* PWM frequency */ 4619431996fSJuerg Haefliger static const int PWM_FREQ[] = {11, 15, 22, 29, 35, 44, 59, 88, 4629431996fSJuerg Haefliger 15000, 20000, 30000, 25000, 0, 0, 0, 0}; 4639431996fSJuerg Haefliger 4649431996fSJuerg Haefliger static inline int PWM_FREQ_FROM_REG(int reg) 4659431996fSJuerg Haefliger { 4669431996fSJuerg Haefliger return PWM_FREQ[reg & 0x0f]; 4679431996fSJuerg Haefliger } 4689431996fSJuerg Haefliger 469d58e47d7SAxel Lin static int PWM_FREQ_TO_REG(long val, int reg) 4709431996fSJuerg Haefliger { 4719431996fSJuerg Haefliger int i; 4729431996fSJuerg Haefliger 4739431996fSJuerg Haefliger /* the first two cases are special - stupid chip design! */ 4749431996fSJuerg Haefliger if (val > 27500) { 4759431996fSJuerg Haefliger i = 10; 4769431996fSJuerg Haefliger } else if (val > 22500) { 4779431996fSJuerg Haefliger i = 11; 4789431996fSJuerg Haefliger } else { 4799431996fSJuerg Haefliger for (i = 9; i > 0; i--) { 480c8de8362SGuenter Roeck if (val > (PWM_FREQ[i] + PWM_FREQ[i - 1] + 1) / 2) 4819431996fSJuerg Haefliger break; 4829431996fSJuerg Haefliger } 4839431996fSJuerg Haefliger } 4849431996fSJuerg Haefliger 4859431996fSJuerg Haefliger return (reg & 0xf0) | i; 4869431996fSJuerg Haefliger } 4879431996fSJuerg Haefliger 488c8de8362SGuenter Roeck /* 489c8de8362SGuenter Roeck * PWM ramp rate 4909431996fSJuerg Haefliger * Register layout: 4919431996fSJuerg Haefliger * reg[0] = [OFF3, OFF2, OFF1, RES, RR1-E, RR1-2, RR1-1, RR1-0] 492c8de8362SGuenter Roeck * reg[1] = [RR2-E, RR2-2, RR2-1, RR2-0, RR3-E, RR3-2, RR3-1, RR3-0] 493c8de8362SGuenter Roeck */ 4949431996fSJuerg Haefliger static const u8 PWM_RR[] = {206, 104, 69, 41, 26, 18, 10, 5}; 4959431996fSJuerg Haefliger 4969431996fSJuerg Haefliger static inline int PWM_RR_FROM_REG(int reg, int ix) 4979431996fSJuerg Haefliger { 4989431996fSJuerg Haefliger int rr = (ix == 1) ? reg >> 4 : reg; 4999431996fSJuerg Haefliger 5009431996fSJuerg Haefliger return (rr & 0x08) ? PWM_RR[rr & 0x07] : 0; 5019431996fSJuerg Haefliger } 5029431996fSJuerg Haefliger 503d58e47d7SAxel Lin static int PWM_RR_TO_REG(long val, int ix, int reg) 5049431996fSJuerg Haefliger { 5059431996fSJuerg Haefliger int i; 5069431996fSJuerg Haefliger 5079431996fSJuerg Haefliger for (i = 0; i < 7; i++) { 508c8de8362SGuenter Roeck if (val > (PWM_RR[i] + PWM_RR[i + 1] + 1) / 2) 5099431996fSJuerg Haefliger break; 5109431996fSJuerg Haefliger } 5119431996fSJuerg Haefliger 5129431996fSJuerg Haefliger return (ix == 1) ? (reg & 0x8f) | (i << 4) : (reg & 0xf8) | i; 5139431996fSJuerg Haefliger } 5149431996fSJuerg Haefliger 5159431996fSJuerg Haefliger /* PWM ramp rate enable */ 5169431996fSJuerg Haefliger static inline int PWM_RR_EN_FROM_REG(int reg, int ix) 5179431996fSJuerg Haefliger { 5189431996fSJuerg Haefliger return PWM_RR_FROM_REG(reg, ix) ? 1 : 0; 5199431996fSJuerg Haefliger } 5209431996fSJuerg Haefliger 521d58e47d7SAxel Lin static inline int PWM_RR_EN_TO_REG(long val, int ix, int reg) 5229431996fSJuerg Haefliger { 5239431996fSJuerg Haefliger int en = (ix == 1) ? 0x80 : 0x08; 5249431996fSJuerg Haefliger 5259431996fSJuerg Haefliger return val ? reg | en : reg & ~en; 5269431996fSJuerg Haefliger } 5279431996fSJuerg Haefliger 528c8de8362SGuenter Roeck /* 529c8de8362SGuenter Roeck * PWM min/off 5309431996fSJuerg Haefliger * The PWM min/off bits are part of the PMW ramp rate register 0 (see above for 531c8de8362SGuenter Roeck * the register layout). 532c8de8362SGuenter Roeck */ 5339431996fSJuerg Haefliger static inline int PWM_OFF_FROM_REG(int reg, int ix) 5349431996fSJuerg Haefliger { 5359431996fSJuerg Haefliger return (reg >> (ix + 5)) & 0x01; 5369431996fSJuerg Haefliger } 5379431996fSJuerg Haefliger 5389431996fSJuerg Haefliger static inline int PWM_OFF_TO_REG(int val, int ix, int reg) 5399431996fSJuerg Haefliger { 5409431996fSJuerg Haefliger return (reg & ~(1 << (ix + 5))) | ((val & 0x01) << (ix + 5)); 5419431996fSJuerg Haefliger } 5429431996fSJuerg Haefliger 5439431996fSJuerg Haefliger /* --------------------------------------------------------------------- 5449431996fSJuerg Haefliger * Device I/O access 545e95c237dSJuerg Haefliger * 546e95c237dSJuerg Haefliger * ISA access is performed through an index/data register pair and needs to 547e95c237dSJuerg Haefliger * be protected by a mutex during runtime (not required for initialization). 548e95c237dSJuerg Haefliger * We use data->update_lock for this and need to ensure that we acquire it 549e95c237dSJuerg Haefliger * before calling dme1737_read or dme1737_write. 5509431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 5519431996fSJuerg Haefliger 552dbc2bc25SJean Delvare static u8 dme1737_read(const struct dme1737_data *data, u8 reg) 5539431996fSJuerg Haefliger { 554dbc2bc25SJean Delvare struct i2c_client *client = data->client; 555e95c237dSJuerg Haefliger s32 val; 556e95c237dSJuerg Haefliger 557dbc2bc25SJean Delvare if (client) { /* I2C device */ 558e95c237dSJuerg Haefliger val = i2c_smbus_read_byte_data(client, reg); 5599431996fSJuerg Haefliger 5609431996fSJuerg Haefliger if (val < 0) { 561b55f3757SGuenter Roeck dev_warn(&client->dev, 562b55f3757SGuenter Roeck "Read from register 0x%02x failed! %s\n", 563b55f3757SGuenter Roeck reg, DO_REPORT); 564e95c237dSJuerg Haefliger } 565e95c237dSJuerg Haefliger } else { /* ISA device */ 566dbc2bc25SJean Delvare outb(reg, data->addr); 567dbc2bc25SJean Delvare val = inb(data->addr + 1); 5689431996fSJuerg Haefliger } 5699431996fSJuerg Haefliger 5709431996fSJuerg Haefliger return val; 5719431996fSJuerg Haefliger } 5729431996fSJuerg Haefliger 573dbc2bc25SJean Delvare static s32 dme1737_write(const struct dme1737_data *data, u8 reg, u8 val) 5749431996fSJuerg Haefliger { 575dbc2bc25SJean Delvare struct i2c_client *client = data->client; 576e95c237dSJuerg Haefliger s32 res = 0; 577e95c237dSJuerg Haefliger 578dbc2bc25SJean Delvare if (client) { /* I2C device */ 579e95c237dSJuerg Haefliger res = i2c_smbus_write_byte_data(client, reg, val); 5809431996fSJuerg Haefliger 5819431996fSJuerg Haefliger if (res < 0) { 582b55f3757SGuenter Roeck dev_warn(&client->dev, 583b55f3757SGuenter Roeck "Write to register 0x%02x failed! %s\n", 584b55f3757SGuenter Roeck reg, DO_REPORT); 585e95c237dSJuerg Haefliger } 586e95c237dSJuerg Haefliger } else { /* ISA device */ 587dbc2bc25SJean Delvare outb(reg, data->addr); 588dbc2bc25SJean Delvare outb(val, data->addr + 1); 5899431996fSJuerg Haefliger } 5909431996fSJuerg Haefliger 5919431996fSJuerg Haefliger return res; 5929431996fSJuerg Haefliger } 5939431996fSJuerg Haefliger 5949431996fSJuerg Haefliger static struct dme1737_data *dme1737_update_device(struct device *dev) 5959431996fSJuerg Haefliger { 596b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 5979431996fSJuerg Haefliger int ix; 598d4b94e1fSJuerg Haefliger u8 lsb[6]; 5999431996fSJuerg Haefliger 6009431996fSJuerg Haefliger mutex_lock(&data->update_lock); 6019431996fSJuerg Haefliger 6029431996fSJuerg Haefliger /* Enable a Vbat monitoring cycle every 10 mins */ 6039431996fSJuerg Haefliger if (time_after(jiffies, data->last_vbat + 600 * HZ) || !data->valid) { 604dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_CONFIG, dme1737_read(data, 6059431996fSJuerg Haefliger DME1737_REG_CONFIG) | 0x10); 6069431996fSJuerg Haefliger data->last_vbat = jiffies; 6079431996fSJuerg Haefliger } 6089431996fSJuerg Haefliger 6099431996fSJuerg Haefliger /* Sample register contents every 1 sec */ 6109431996fSJuerg Haefliger if (time_after(jiffies, data->last_update + HZ) || !data->valid) { 611ea694431SJuerg Haefliger if (data->has_features & HAS_VID) { 612dbc2bc25SJean Delvare data->vid = dme1737_read(data, DME1737_REG_VID) & 613549edb83SJuerg Haefliger 0x3f; 614549edb83SJuerg Haefliger } 6159431996fSJuerg Haefliger 6169431996fSJuerg Haefliger /* In (voltage) registers */ 6179431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) { 618c8de8362SGuenter Roeck /* 619c8de8362SGuenter Roeck * Voltage inputs are stored as 16 bit values even 6209431996fSJuerg Haefliger * though they have only 12 bits resolution. This is 621c8de8362SGuenter Roeck * to make it consistent with the temp inputs. 622c8de8362SGuenter Roeck */ 623c8de8362SGuenter Roeck if (ix == 7 && !(data->has_features & HAS_IN7)) 624d4b94e1fSJuerg Haefliger continue; 625dbc2bc25SJean Delvare data->in[ix] = dme1737_read(data, 6269431996fSJuerg Haefliger DME1737_REG_IN(ix)) << 8; 627dbc2bc25SJean Delvare data->in_min[ix] = dme1737_read(data, 6289431996fSJuerg Haefliger DME1737_REG_IN_MIN(ix)); 629dbc2bc25SJean Delvare data->in_max[ix] = dme1737_read(data, 6309431996fSJuerg Haefliger DME1737_REG_IN_MAX(ix)); 6319431996fSJuerg Haefliger } 6329431996fSJuerg Haefliger 6339431996fSJuerg Haefliger /* Temp registers */ 6349431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) { 635c8de8362SGuenter Roeck /* 636c8de8362SGuenter Roeck * Temp inputs are stored as 16 bit values even 6379431996fSJuerg Haefliger * though they have only 12 bits resolution. This is 6389431996fSJuerg Haefliger * to take advantage of implicit conversions between 6399431996fSJuerg Haefliger * register values (2's complement) and temp values 640c8de8362SGuenter Roeck * (signed decimal). 641c8de8362SGuenter Roeck */ 642dbc2bc25SJean Delvare data->temp[ix] = dme1737_read(data, 6439431996fSJuerg Haefliger DME1737_REG_TEMP(ix)) << 8; 644dbc2bc25SJean Delvare data->temp_min[ix] = dme1737_read(data, 6459431996fSJuerg Haefliger DME1737_REG_TEMP_MIN(ix)); 646dbc2bc25SJean Delvare data->temp_max[ix] = dme1737_read(data, 6479431996fSJuerg Haefliger DME1737_REG_TEMP_MAX(ix)); 648ea694431SJuerg Haefliger if (data->has_features & HAS_TEMP_OFFSET) { 649dbc2bc25SJean Delvare data->temp_offset[ix] = dme1737_read(data, 6509431996fSJuerg Haefliger DME1737_REG_TEMP_OFFSET(ix)); 6519431996fSJuerg Haefliger } 652549edb83SJuerg Haefliger } 6539431996fSJuerg Haefliger 654c8de8362SGuenter Roeck /* 655c8de8362SGuenter Roeck * In and temp LSB registers 6569431996fSJuerg Haefliger * The LSBs are latched when the MSBs are read, so the order in 6579431996fSJuerg Haefliger * which the registers are read (MSB first, then LSB) is 658c8de8362SGuenter Roeck * important! 659c8de8362SGuenter Roeck */ 6609431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(lsb); ix++) { 661c8de8362SGuenter Roeck if (ix == 5 && !(data->has_features & HAS_IN7)) 662d4b94e1fSJuerg Haefliger continue; 663dbc2bc25SJean Delvare lsb[ix] = dme1737_read(data, 6649431996fSJuerg Haefliger DME1737_REG_IN_TEMP_LSB(ix)); 6659431996fSJuerg Haefliger } 6669431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) { 667c8de8362SGuenter Roeck if (ix == 7 && !(data->has_features & HAS_IN7)) 668d4b94e1fSJuerg Haefliger continue; 6699431996fSJuerg Haefliger data->in[ix] |= (lsb[DME1737_REG_IN_LSB[ix]] << 6709431996fSJuerg Haefliger DME1737_REG_IN_LSB_SHL[ix]) & 0xf0; 6719431996fSJuerg Haefliger } 6729431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->temp); ix++) { 6739431996fSJuerg Haefliger data->temp[ix] |= (lsb[DME1737_REG_TEMP_LSB[ix]] << 6749431996fSJuerg Haefliger DME1737_REG_TEMP_LSB_SHL[ix]) & 0xf0; 6759431996fSJuerg Haefliger } 6769431996fSJuerg Haefliger 6779431996fSJuerg Haefliger /* Fan registers */ 6789431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->fan); ix++) { 679c8de8362SGuenter Roeck /* 680c8de8362SGuenter Roeck * Skip reading registers if optional fans are not 681c8de8362SGuenter Roeck * present 682c8de8362SGuenter Roeck */ 683c8de8362SGuenter Roeck if (!(data->has_features & HAS_FAN(ix))) 6849431996fSJuerg Haefliger continue; 685dbc2bc25SJean Delvare data->fan[ix] = dme1737_read(data, 6869431996fSJuerg Haefliger DME1737_REG_FAN(ix)); 687dbc2bc25SJean Delvare data->fan[ix] |= dme1737_read(data, 6889431996fSJuerg Haefliger DME1737_REG_FAN(ix) + 1) << 8; 689dbc2bc25SJean Delvare data->fan_min[ix] = dme1737_read(data, 6909431996fSJuerg Haefliger DME1737_REG_FAN_MIN(ix)); 691dbc2bc25SJean Delvare data->fan_min[ix] |= dme1737_read(data, 6929431996fSJuerg Haefliger DME1737_REG_FAN_MIN(ix) + 1) << 8; 693dbc2bc25SJean Delvare data->fan_opt[ix] = dme1737_read(data, 6949431996fSJuerg Haefliger DME1737_REG_FAN_OPT(ix)); 6959431996fSJuerg Haefliger /* fan_max exists only for fan[5-6] */ 6969431996fSJuerg Haefliger if (ix > 3) { 697dbc2bc25SJean Delvare data->fan_max[ix - 4] = dme1737_read(data, 6989431996fSJuerg Haefliger DME1737_REG_FAN_MAX(ix)); 6999431996fSJuerg Haefliger } 7009431996fSJuerg Haefliger } 7019431996fSJuerg Haefliger 7029431996fSJuerg Haefliger /* PWM registers */ 7039431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->pwm); ix++) { 704c8de8362SGuenter Roeck /* 705c8de8362SGuenter Roeck * Skip reading registers if optional PWMs are not 706c8de8362SGuenter Roeck * present 707c8de8362SGuenter Roeck */ 708c8de8362SGuenter Roeck if (!(data->has_features & HAS_PWM(ix))) 7099431996fSJuerg Haefliger continue; 710dbc2bc25SJean Delvare data->pwm[ix] = dme1737_read(data, 7119431996fSJuerg Haefliger DME1737_REG_PWM(ix)); 712dbc2bc25SJean Delvare data->pwm_freq[ix] = dme1737_read(data, 7139431996fSJuerg Haefliger DME1737_REG_PWM_FREQ(ix)); 7149431996fSJuerg Haefliger /* pwm_config and pwm_min exist only for pwm[1-3] */ 7159431996fSJuerg Haefliger if (ix < 3) { 716dbc2bc25SJean Delvare data->pwm_config[ix] = dme1737_read(data, 7179431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 718dbc2bc25SJean Delvare data->pwm_min[ix] = dme1737_read(data, 7199431996fSJuerg Haefliger DME1737_REG_PWM_MIN(ix)); 7209431996fSJuerg Haefliger } 7219431996fSJuerg Haefliger } 7229431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->pwm_rr); ix++) { 723dbc2bc25SJean Delvare data->pwm_rr[ix] = dme1737_read(data, 7249431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix)); 7259431996fSJuerg Haefliger } 7269431996fSJuerg Haefliger 7279431996fSJuerg Haefliger /* Thermal zone registers */ 7289431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->zone_low); ix++) { 729ea694431SJuerg Haefliger /* Skip reading registers if zone3 is not present */ 730c8de8362SGuenter Roeck if ((ix == 2) && !(data->has_features & HAS_ZONE3)) 731ea694431SJuerg Haefliger continue; 732ea694431SJuerg Haefliger /* sch5127 zone2 registers are special */ 733ea694431SJuerg Haefliger if ((ix == 1) && (data->type == sch5127)) { 734ea694431SJuerg Haefliger data->zone_low[1] = dme1737_read(data, 735ea694431SJuerg Haefliger DME1737_REG_ZONE_LOW(2)); 736ea694431SJuerg Haefliger data->zone_abs[1] = dme1737_read(data, 737ea694431SJuerg Haefliger DME1737_REG_ZONE_ABS(2)); 738ea694431SJuerg Haefliger } else { 739dbc2bc25SJean Delvare data->zone_low[ix] = dme1737_read(data, 7409431996fSJuerg Haefliger DME1737_REG_ZONE_LOW(ix)); 741dbc2bc25SJean Delvare data->zone_abs[ix] = dme1737_read(data, 7429431996fSJuerg Haefliger DME1737_REG_ZONE_ABS(ix)); 7439431996fSJuerg Haefliger } 744ea694431SJuerg Haefliger } 745ea694431SJuerg Haefliger if (data->has_features & HAS_ZONE_HYST) { 7469431996fSJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) { 747dbc2bc25SJean Delvare data->zone_hyst[ix] = dme1737_read(data, 7489431996fSJuerg Haefliger DME1737_REG_ZONE_HYST(ix)); 7499431996fSJuerg Haefliger } 750549edb83SJuerg Haefliger } 7519431996fSJuerg Haefliger 7529431996fSJuerg Haefliger /* Alarm registers */ 753dbc2bc25SJean Delvare data->alarms = dme1737_read(data, 7549431996fSJuerg Haefliger DME1737_REG_ALARM1); 755c8de8362SGuenter Roeck /* 756c8de8362SGuenter Roeck * Bit 7 tells us if the other alarm registers are non-zero and 757c8de8362SGuenter Roeck * therefore also need to be read 758c8de8362SGuenter Roeck */ 7599431996fSJuerg Haefliger if (data->alarms & 0x80) { 760dbc2bc25SJean Delvare data->alarms |= dme1737_read(data, 7619431996fSJuerg Haefliger DME1737_REG_ALARM2) << 8; 762dbc2bc25SJean Delvare data->alarms |= dme1737_read(data, 7639431996fSJuerg Haefliger DME1737_REG_ALARM3) << 16; 7649431996fSJuerg Haefliger } 7659431996fSJuerg Haefliger 766c8de8362SGuenter Roeck /* 767c8de8362SGuenter Roeck * The ISA chips require explicit clearing of alarm bits. 768e95c237dSJuerg Haefliger * Don't worry, an alarm will come back if the condition 769c8de8362SGuenter Roeck * that causes it still exists 770c8de8362SGuenter Roeck */ 771dbc2bc25SJean Delvare if (!data->client) { 772c8de8362SGuenter Roeck if (data->alarms & 0xff0000) 773c8de8362SGuenter Roeck dme1737_write(data, DME1737_REG_ALARM3, 0xff); 774c8de8362SGuenter Roeck if (data->alarms & 0xff00) 775c8de8362SGuenter Roeck dme1737_write(data, DME1737_REG_ALARM2, 0xff); 776c8de8362SGuenter Roeck if (data->alarms & 0xff) 777c8de8362SGuenter Roeck dme1737_write(data, DME1737_REG_ALARM1, 0xff); 778e95c237dSJuerg Haefliger } 779e95c237dSJuerg Haefliger 7809431996fSJuerg Haefliger data->last_update = jiffies; 781952a11caSPaul Fertser data->valid = true; 7829431996fSJuerg Haefliger } 7839431996fSJuerg Haefliger 7849431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 7859431996fSJuerg Haefliger 7869431996fSJuerg Haefliger return data; 7879431996fSJuerg Haefliger } 7889431996fSJuerg Haefliger 7899431996fSJuerg Haefliger /* --------------------------------------------------------------------- 7909431996fSJuerg Haefliger * Voltage sysfs attributes 791d4b94e1fSJuerg Haefliger * ix = [0-7] 7929431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 7939431996fSJuerg Haefliger 7949431996fSJuerg Haefliger #define SYS_IN_INPUT 0 7959431996fSJuerg Haefliger #define SYS_IN_MIN 1 7969431996fSJuerg Haefliger #define SYS_IN_MAX 2 7979431996fSJuerg Haefliger #define SYS_IN_ALARM 3 7989431996fSJuerg Haefliger 7999431996fSJuerg Haefliger static ssize_t show_in(struct device *dev, struct device_attribute *attr, 8009431996fSJuerg Haefliger char *buf) 8019431996fSJuerg Haefliger { 8029431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 8039431996fSJuerg Haefliger struct sensor_device_attribute_2 8049431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 8059431996fSJuerg Haefliger int ix = sensor_attr_2->index; 8069431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 8079431996fSJuerg Haefliger int res; 8089431996fSJuerg Haefliger 8099431996fSJuerg Haefliger switch (fn) { 8109431996fSJuerg Haefliger case SYS_IN_INPUT: 811549edb83SJuerg Haefliger res = IN_FROM_REG(data->in[ix], data->in_nominal[ix], 16); 8129431996fSJuerg Haefliger break; 8139431996fSJuerg Haefliger case SYS_IN_MIN: 814549edb83SJuerg Haefliger res = IN_FROM_REG(data->in_min[ix], data->in_nominal[ix], 8); 8159431996fSJuerg Haefliger break; 8169431996fSJuerg Haefliger case SYS_IN_MAX: 817549edb83SJuerg Haefliger res = IN_FROM_REG(data->in_max[ix], data->in_nominal[ix], 8); 8189431996fSJuerg Haefliger break; 8199431996fSJuerg Haefliger case SYS_IN_ALARM: 8209431996fSJuerg Haefliger res = (data->alarms >> DME1737_BIT_ALARM_IN[ix]) & 0x01; 8219431996fSJuerg Haefliger break; 8229431996fSJuerg Haefliger default: 8239431996fSJuerg Haefliger res = 0; 824b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 8259431996fSJuerg Haefliger } 8269431996fSJuerg Haefliger 8279431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 8289431996fSJuerg Haefliger } 8299431996fSJuerg Haefliger 8309431996fSJuerg Haefliger static ssize_t set_in(struct device *dev, struct device_attribute *attr, 8319431996fSJuerg Haefliger const char *buf, size_t count) 8329431996fSJuerg Haefliger { 833b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 8349431996fSJuerg Haefliger struct sensor_device_attribute_2 8359431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 8369431996fSJuerg Haefliger int ix = sensor_attr_2->index; 8379431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 838c8de8362SGuenter Roeck long val; 839c8de8362SGuenter Roeck int err; 840c8de8362SGuenter Roeck 841c8de8362SGuenter Roeck err = kstrtol(buf, 10, &val); 842c8de8362SGuenter Roeck if (err) 843c8de8362SGuenter Roeck return err; 8449431996fSJuerg Haefliger 8459431996fSJuerg Haefliger mutex_lock(&data->update_lock); 8469431996fSJuerg Haefliger switch (fn) { 8479431996fSJuerg Haefliger case SYS_IN_MIN: 848549edb83SJuerg Haefliger data->in_min[ix] = IN_TO_REG(val, data->in_nominal[ix]); 849dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_IN_MIN(ix), 8509431996fSJuerg Haefliger data->in_min[ix]); 8519431996fSJuerg Haefliger break; 8529431996fSJuerg Haefliger case SYS_IN_MAX: 853549edb83SJuerg Haefliger data->in_max[ix] = IN_TO_REG(val, data->in_nominal[ix]); 854dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_IN_MAX(ix), 8559431996fSJuerg Haefliger data->in_max[ix]); 8569431996fSJuerg Haefliger break; 8579431996fSJuerg Haefliger default: 858b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 8599431996fSJuerg Haefliger } 8609431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 8619431996fSJuerg Haefliger 8629431996fSJuerg Haefliger return count; 8639431996fSJuerg Haefliger } 8649431996fSJuerg Haefliger 8659431996fSJuerg Haefliger /* --------------------------------------------------------------------- 8669431996fSJuerg Haefliger * Temperature sysfs attributes 8679431996fSJuerg Haefliger * ix = [0-2] 8689431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 8699431996fSJuerg Haefliger 8709431996fSJuerg Haefliger #define SYS_TEMP_INPUT 0 8719431996fSJuerg Haefliger #define SYS_TEMP_MIN 1 8729431996fSJuerg Haefliger #define SYS_TEMP_MAX 2 8739431996fSJuerg Haefliger #define SYS_TEMP_OFFSET 3 8749431996fSJuerg Haefliger #define SYS_TEMP_ALARM 4 8759431996fSJuerg Haefliger #define SYS_TEMP_FAULT 5 8769431996fSJuerg Haefliger 8779431996fSJuerg Haefliger static ssize_t show_temp(struct device *dev, struct device_attribute *attr, 8789431996fSJuerg Haefliger char *buf) 8799431996fSJuerg Haefliger { 8809431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 8819431996fSJuerg Haefliger struct sensor_device_attribute_2 8829431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 8839431996fSJuerg Haefliger int ix = sensor_attr_2->index; 8849431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 8859431996fSJuerg Haefliger int res; 8869431996fSJuerg Haefliger 8879431996fSJuerg Haefliger switch (fn) { 8889431996fSJuerg Haefliger case SYS_TEMP_INPUT: 8899431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp[ix], 16); 8909431996fSJuerg Haefliger break; 8919431996fSJuerg Haefliger case SYS_TEMP_MIN: 8929431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp_min[ix], 8); 8939431996fSJuerg Haefliger break; 8949431996fSJuerg Haefliger case SYS_TEMP_MAX: 8959431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp_max[ix], 8); 8969431996fSJuerg Haefliger break; 8979431996fSJuerg Haefliger case SYS_TEMP_OFFSET: 8989431996fSJuerg Haefliger res = TEMP_FROM_REG(data->temp_offset[ix], 8); 8999431996fSJuerg Haefliger break; 9009431996fSJuerg Haefliger case SYS_TEMP_ALARM: 9019431996fSJuerg Haefliger res = (data->alarms >> DME1737_BIT_ALARM_TEMP[ix]) & 0x01; 9029431996fSJuerg Haefliger break; 9039431996fSJuerg Haefliger case SYS_TEMP_FAULT: 904c0f31403SJuerg Haefliger res = (((u16)data->temp[ix] & 0xff00) == 0x8000); 9059431996fSJuerg Haefliger break; 9069431996fSJuerg Haefliger default: 9079431996fSJuerg Haefliger res = 0; 908b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 9099431996fSJuerg Haefliger } 9109431996fSJuerg Haefliger 9119431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 9129431996fSJuerg Haefliger } 9139431996fSJuerg Haefliger 9149431996fSJuerg Haefliger static ssize_t set_temp(struct device *dev, struct device_attribute *attr, 9159431996fSJuerg Haefliger const char *buf, size_t count) 9169431996fSJuerg Haefliger { 917b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 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; 922c8de8362SGuenter Roeck long val; 923c8de8362SGuenter Roeck int err; 924c8de8362SGuenter Roeck 925c8de8362SGuenter Roeck err = kstrtol(buf, 10, &val); 926c8de8362SGuenter Roeck if (err) 927c8de8362SGuenter Roeck return err; 9289431996fSJuerg Haefliger 9299431996fSJuerg Haefliger mutex_lock(&data->update_lock); 9309431996fSJuerg Haefliger switch (fn) { 9319431996fSJuerg Haefliger case SYS_TEMP_MIN: 9329431996fSJuerg Haefliger data->temp_min[ix] = TEMP_TO_REG(val); 933dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_TEMP_MIN(ix), 9349431996fSJuerg Haefliger data->temp_min[ix]); 9359431996fSJuerg Haefliger break; 9369431996fSJuerg Haefliger case SYS_TEMP_MAX: 9379431996fSJuerg Haefliger data->temp_max[ix] = TEMP_TO_REG(val); 938dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_TEMP_MAX(ix), 9399431996fSJuerg Haefliger data->temp_max[ix]); 9409431996fSJuerg Haefliger break; 9419431996fSJuerg Haefliger case SYS_TEMP_OFFSET: 9429431996fSJuerg Haefliger data->temp_offset[ix] = TEMP_TO_REG(val); 943dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_TEMP_OFFSET(ix), 9449431996fSJuerg Haefliger data->temp_offset[ix]); 9459431996fSJuerg Haefliger break; 9469431996fSJuerg Haefliger default: 947b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 9489431996fSJuerg Haefliger } 9499431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 9509431996fSJuerg Haefliger 9519431996fSJuerg Haefliger return count; 9529431996fSJuerg Haefliger } 9539431996fSJuerg Haefliger 9549431996fSJuerg Haefliger /* --------------------------------------------------------------------- 9559431996fSJuerg Haefliger * Zone sysfs attributes 9569431996fSJuerg Haefliger * ix = [0-2] 9579431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 9589431996fSJuerg Haefliger 9599431996fSJuerg Haefliger #define SYS_ZONE_AUTO_CHANNELS_TEMP 0 9609431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT1_TEMP_HYST 1 9619431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT1_TEMP 2 9629431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT2_TEMP 3 9639431996fSJuerg Haefliger #define SYS_ZONE_AUTO_POINT3_TEMP 4 9649431996fSJuerg Haefliger 9659431996fSJuerg Haefliger static ssize_t show_zone(struct device *dev, struct device_attribute *attr, 9669431996fSJuerg Haefliger char *buf) 9679431996fSJuerg Haefliger { 9689431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 9699431996fSJuerg Haefliger struct sensor_device_attribute_2 9709431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 9719431996fSJuerg Haefliger int ix = sensor_attr_2->index; 9729431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 9739431996fSJuerg Haefliger int res; 9749431996fSJuerg Haefliger 9759431996fSJuerg Haefliger switch (fn) { 9769431996fSJuerg Haefliger case SYS_ZONE_AUTO_CHANNELS_TEMP: 9779431996fSJuerg Haefliger /* check config2 for non-standard temp-to-zone mapping */ 978c8de8362SGuenter Roeck if ((ix == 1) && (data->config2 & 0x02)) 9799431996fSJuerg Haefliger res = 4; 980c8de8362SGuenter Roeck else 9819431996fSJuerg Haefliger res = 1 << ix; 9829431996fSJuerg Haefliger break; 9839431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP_HYST: 9849431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_low[ix], 8) - 9859431996fSJuerg Haefliger TEMP_HYST_FROM_REG(data->zone_hyst[ix == 2], ix); 9869431996fSJuerg Haefliger break; 9879431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP: 9889431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_low[ix], 8); 9899431996fSJuerg Haefliger break; 9909431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT2_TEMP: 9919431996fSJuerg Haefliger /* pwm_freq holds the temp range bits in the upper nibble */ 9929431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_low[ix], 8) + 9939431996fSJuerg Haefliger TEMP_RANGE_FROM_REG(data->pwm_freq[ix]); 9949431996fSJuerg Haefliger break; 9959431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT3_TEMP: 9969431996fSJuerg Haefliger res = TEMP_FROM_REG(data->zone_abs[ix], 8); 9979431996fSJuerg Haefliger break; 9989431996fSJuerg Haefliger default: 9999431996fSJuerg Haefliger res = 0; 1000b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 10019431996fSJuerg Haefliger } 10029431996fSJuerg Haefliger 10039431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 10049431996fSJuerg Haefliger } 10059431996fSJuerg Haefliger 10069431996fSJuerg Haefliger static ssize_t set_zone(struct device *dev, struct device_attribute *attr, 10079431996fSJuerg Haefliger const char *buf, size_t count) 10089431996fSJuerg Haefliger { 1009b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 10109431996fSJuerg Haefliger struct sensor_device_attribute_2 10119431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 10129431996fSJuerg Haefliger int ix = sensor_attr_2->index; 10139431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 1014c8de8362SGuenter Roeck long val; 101507cc189dSGuenter Roeck int temp; 1016c8de8362SGuenter Roeck int err; 101707cc189dSGuenter Roeck u8 reg; 1018c8de8362SGuenter Roeck 1019c8de8362SGuenter Roeck err = kstrtol(buf, 10, &val); 1020c8de8362SGuenter Roeck if (err) 1021c8de8362SGuenter Roeck return err; 10229431996fSJuerg Haefliger 10239431996fSJuerg Haefliger mutex_lock(&data->update_lock); 10249431996fSJuerg Haefliger switch (fn) { 10259431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP_HYST: 10269431996fSJuerg Haefliger /* Refresh the cache */ 1027dbc2bc25SJean Delvare data->zone_low[ix] = dme1737_read(data, 10289431996fSJuerg Haefliger DME1737_REG_ZONE_LOW(ix)); 10299431996fSJuerg Haefliger /* Modify the temp hyst value */ 103007cc189dSGuenter Roeck temp = TEMP_FROM_REG(data->zone_low[ix], 8); 103107cc189dSGuenter Roeck reg = dme1737_read(data, DME1737_REG_ZONE_HYST(ix == 2)); 103207cc189dSGuenter Roeck data->zone_hyst[ix == 2] = TEMP_HYST_TO_REG(temp, val, ix, reg); 1033dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_ZONE_HYST(ix == 2), 10349431996fSJuerg Haefliger data->zone_hyst[ix == 2]); 10359431996fSJuerg Haefliger break; 10369431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT1_TEMP: 10379431996fSJuerg Haefliger data->zone_low[ix] = TEMP_TO_REG(val); 1038dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_ZONE_LOW(ix), 10399431996fSJuerg Haefliger data->zone_low[ix]); 10409431996fSJuerg Haefliger break; 10419431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT2_TEMP: 10429431996fSJuerg Haefliger /* Refresh the cache */ 1043dbc2bc25SJean Delvare data->zone_low[ix] = dme1737_read(data, 10449431996fSJuerg Haefliger DME1737_REG_ZONE_LOW(ix)); 1045c8de8362SGuenter Roeck /* 1046c8de8362SGuenter Roeck * Modify the temp range value (which is stored in the upper 1047c8de8362SGuenter Roeck * nibble of the pwm_freq register) 1048c8de8362SGuenter Roeck */ 104907cc189dSGuenter Roeck temp = TEMP_FROM_REG(data->zone_low[ix], 8); 105007cc189dSGuenter Roeck val = clamp_val(val, temp, temp + 80000); 105107cc189dSGuenter Roeck reg = dme1737_read(data, DME1737_REG_PWM_FREQ(ix)); 105207cc189dSGuenter Roeck data->pwm_freq[ix] = TEMP_RANGE_TO_REG(val - temp, reg); 1053dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_FREQ(ix), 10549431996fSJuerg Haefliger data->pwm_freq[ix]); 10559431996fSJuerg Haefliger break; 10569431996fSJuerg Haefliger case SYS_ZONE_AUTO_POINT3_TEMP: 10579431996fSJuerg Haefliger data->zone_abs[ix] = TEMP_TO_REG(val); 1058dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_ZONE_ABS(ix), 10599431996fSJuerg Haefliger data->zone_abs[ix]); 10609431996fSJuerg Haefliger break; 10619431996fSJuerg Haefliger default: 1062b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 10639431996fSJuerg Haefliger } 10649431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 10659431996fSJuerg Haefliger 10669431996fSJuerg Haefliger return count; 10679431996fSJuerg Haefliger } 10689431996fSJuerg Haefliger 10699431996fSJuerg Haefliger /* --------------------------------------------------------------------- 10709431996fSJuerg Haefliger * Fan sysfs attributes 10719431996fSJuerg Haefliger * ix = [0-5] 10729431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 10739431996fSJuerg Haefliger 10749431996fSJuerg Haefliger #define SYS_FAN_INPUT 0 10759431996fSJuerg Haefliger #define SYS_FAN_MIN 1 10769431996fSJuerg Haefliger #define SYS_FAN_MAX 2 10779431996fSJuerg Haefliger #define SYS_FAN_ALARM 3 10789431996fSJuerg Haefliger #define SYS_FAN_TYPE 4 10799431996fSJuerg Haefliger 10809431996fSJuerg Haefliger static ssize_t show_fan(struct device *dev, struct device_attribute *attr, 10819431996fSJuerg Haefliger char *buf) 10829431996fSJuerg Haefliger { 10839431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 10849431996fSJuerg Haefliger struct sensor_device_attribute_2 10859431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 10869431996fSJuerg Haefliger int ix = sensor_attr_2->index; 10879431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 10889431996fSJuerg Haefliger int res; 10899431996fSJuerg Haefliger 10909431996fSJuerg Haefliger switch (fn) { 10919431996fSJuerg Haefliger case SYS_FAN_INPUT: 10929431996fSJuerg Haefliger res = FAN_FROM_REG(data->fan[ix], 10939431996fSJuerg Haefliger ix < 4 ? 0 : 10949431996fSJuerg Haefliger FAN_TPC_FROM_REG(data->fan_opt[ix])); 10959431996fSJuerg Haefliger break; 10969431996fSJuerg Haefliger case SYS_FAN_MIN: 10979431996fSJuerg Haefliger res = FAN_FROM_REG(data->fan_min[ix], 10989431996fSJuerg Haefliger ix < 4 ? 0 : 10999431996fSJuerg Haefliger FAN_TPC_FROM_REG(data->fan_opt[ix])); 11009431996fSJuerg Haefliger break; 11019431996fSJuerg Haefliger case SYS_FAN_MAX: 11029431996fSJuerg Haefliger /* only valid for fan[5-6] */ 11039431996fSJuerg Haefliger res = FAN_MAX_FROM_REG(data->fan_max[ix - 4]); 11049431996fSJuerg Haefliger break; 11059431996fSJuerg Haefliger case SYS_FAN_ALARM: 11069431996fSJuerg Haefliger res = (data->alarms >> DME1737_BIT_ALARM_FAN[ix]) & 0x01; 11079431996fSJuerg Haefliger break; 11089431996fSJuerg Haefliger case SYS_FAN_TYPE: 11099431996fSJuerg Haefliger /* only valid for fan[1-4] */ 11109431996fSJuerg Haefliger res = FAN_TYPE_FROM_REG(data->fan_opt[ix]); 11119431996fSJuerg Haefliger break; 11129431996fSJuerg Haefliger default: 11139431996fSJuerg Haefliger res = 0; 1114b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 11159431996fSJuerg Haefliger } 11169431996fSJuerg Haefliger 11179431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 11189431996fSJuerg Haefliger } 11199431996fSJuerg Haefliger 11209431996fSJuerg Haefliger static ssize_t set_fan(struct device *dev, struct device_attribute *attr, 11219431996fSJuerg Haefliger const char *buf, size_t count) 11229431996fSJuerg Haefliger { 1123b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 11249431996fSJuerg Haefliger struct sensor_device_attribute_2 11259431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 11269431996fSJuerg Haefliger int ix = sensor_attr_2->index; 11279431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 1128c8de8362SGuenter Roeck long val; 1129c8de8362SGuenter Roeck int err; 1130c8de8362SGuenter Roeck 1131c8de8362SGuenter Roeck err = kstrtol(buf, 10, &val); 1132c8de8362SGuenter Roeck if (err) 1133c8de8362SGuenter Roeck return err; 11349431996fSJuerg Haefliger 11359431996fSJuerg Haefliger mutex_lock(&data->update_lock); 11369431996fSJuerg Haefliger switch (fn) { 11379431996fSJuerg Haefliger case SYS_FAN_MIN: 11389431996fSJuerg Haefliger if (ix < 4) { 11399431996fSJuerg Haefliger data->fan_min[ix] = FAN_TO_REG(val, 0); 11409431996fSJuerg Haefliger } else { 11419431996fSJuerg Haefliger /* Refresh the cache */ 1142dbc2bc25SJean Delvare data->fan_opt[ix] = dme1737_read(data, 11439431996fSJuerg Haefliger DME1737_REG_FAN_OPT(ix)); 11449431996fSJuerg Haefliger /* Modify the fan min value */ 11459431996fSJuerg Haefliger data->fan_min[ix] = FAN_TO_REG(val, 11469431996fSJuerg Haefliger FAN_TPC_FROM_REG(data->fan_opt[ix])); 11479431996fSJuerg Haefliger } 1148dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_FAN_MIN(ix), 11499431996fSJuerg Haefliger data->fan_min[ix] & 0xff); 1150dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_FAN_MIN(ix) + 1, 11519431996fSJuerg Haefliger data->fan_min[ix] >> 8); 11529431996fSJuerg Haefliger break; 11539431996fSJuerg Haefliger case SYS_FAN_MAX: 11549431996fSJuerg Haefliger /* Only valid for fan[5-6] */ 11559431996fSJuerg Haefliger data->fan_max[ix - 4] = FAN_MAX_TO_REG(val); 1156dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_FAN_MAX(ix), 11579431996fSJuerg Haefliger data->fan_max[ix - 4]); 11589431996fSJuerg Haefliger break; 11599431996fSJuerg Haefliger case SYS_FAN_TYPE: 11609431996fSJuerg Haefliger /* Only valid for fan[1-4] */ 11619431996fSJuerg Haefliger if (!(val == 1 || val == 2 || val == 4)) { 11629431996fSJuerg Haefliger count = -EINVAL; 1163b55f3757SGuenter Roeck dev_warn(dev, 1164b55f3757SGuenter Roeck "Fan type value %ld not supported. Choose one of 1, 2, or 4.\n", 11659431996fSJuerg Haefliger val); 11669431996fSJuerg Haefliger goto exit; 11679431996fSJuerg Haefliger } 1168dbc2bc25SJean Delvare data->fan_opt[ix] = FAN_TYPE_TO_REG(val, dme1737_read(data, 11699431996fSJuerg Haefliger DME1737_REG_FAN_OPT(ix))); 1170dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_FAN_OPT(ix), 11719431996fSJuerg Haefliger data->fan_opt[ix]); 11729431996fSJuerg Haefliger break; 11739431996fSJuerg Haefliger default: 1174b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 11759431996fSJuerg Haefliger } 11769431996fSJuerg Haefliger exit: 11779431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 11789431996fSJuerg Haefliger 11799431996fSJuerg Haefliger return count; 11809431996fSJuerg Haefliger } 11819431996fSJuerg Haefliger 11829431996fSJuerg Haefliger /* --------------------------------------------------------------------- 11839431996fSJuerg Haefliger * PWM sysfs attributes 11849431996fSJuerg Haefliger * ix = [0-4] 11859431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 11869431996fSJuerg Haefliger 11879431996fSJuerg Haefliger #define SYS_PWM 0 11889431996fSJuerg Haefliger #define SYS_PWM_FREQ 1 11899431996fSJuerg Haefliger #define SYS_PWM_ENABLE 2 11909431996fSJuerg Haefliger #define SYS_PWM_RAMP_RATE 3 11919431996fSJuerg Haefliger #define SYS_PWM_AUTO_CHANNELS_ZONE 4 11929431996fSJuerg Haefliger #define SYS_PWM_AUTO_PWM_MIN 5 11939431996fSJuerg Haefliger #define SYS_PWM_AUTO_POINT1_PWM 6 11949431996fSJuerg Haefliger #define SYS_PWM_AUTO_POINT2_PWM 7 11959431996fSJuerg Haefliger 11969431996fSJuerg Haefliger static ssize_t show_pwm(struct device *dev, struct device_attribute *attr, 11979431996fSJuerg Haefliger char *buf) 11989431996fSJuerg Haefliger { 11999431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 12009431996fSJuerg Haefliger struct sensor_device_attribute_2 12019431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 12029431996fSJuerg Haefliger int ix = sensor_attr_2->index; 12039431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 12049431996fSJuerg Haefliger int res; 12059431996fSJuerg Haefliger 12069431996fSJuerg Haefliger switch (fn) { 12079431996fSJuerg Haefliger case SYS_PWM: 1208c8de8362SGuenter Roeck if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 0) 12099431996fSJuerg Haefliger res = 255; 1210c8de8362SGuenter Roeck else 12119431996fSJuerg Haefliger res = data->pwm[ix]; 12129431996fSJuerg Haefliger break; 12139431996fSJuerg Haefliger case SYS_PWM_FREQ: 12149431996fSJuerg Haefliger res = PWM_FREQ_FROM_REG(data->pwm_freq[ix]); 12159431996fSJuerg Haefliger break; 12169431996fSJuerg Haefliger case SYS_PWM_ENABLE: 1217c8de8362SGuenter Roeck if (ix >= 3) 12189431996fSJuerg Haefliger res = 1; /* pwm[5-6] hard-wired to manual mode */ 1219c8de8362SGuenter Roeck else 12209431996fSJuerg Haefliger res = PWM_EN_FROM_REG(data->pwm_config[ix]); 12219431996fSJuerg Haefliger break; 12229431996fSJuerg Haefliger case SYS_PWM_RAMP_RATE: 12239431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 12249431996fSJuerg Haefliger res = PWM_RR_FROM_REG(data->pwm_rr[ix > 0], ix); 12259431996fSJuerg Haefliger break; 12269431996fSJuerg Haefliger case SYS_PWM_AUTO_CHANNELS_ZONE: 12279431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 1228c8de8362SGuenter Roeck if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) 12299431996fSJuerg Haefliger res = PWM_ACZ_FROM_REG(data->pwm_config[ix]); 1230c8de8362SGuenter Roeck else 12319431996fSJuerg Haefliger res = data->pwm_acz[ix]; 12329431996fSJuerg Haefliger break; 12339431996fSJuerg Haefliger case SYS_PWM_AUTO_PWM_MIN: 12349431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 1235c8de8362SGuenter Roeck if (PWM_OFF_FROM_REG(data->pwm_rr[0], ix)) 12369431996fSJuerg Haefliger res = data->pwm_min[ix]; 1237c8de8362SGuenter Roeck else 12389431996fSJuerg Haefliger res = 0; 12399431996fSJuerg Haefliger break; 12409431996fSJuerg Haefliger case SYS_PWM_AUTO_POINT1_PWM: 12419431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 12429431996fSJuerg Haefliger res = data->pwm_min[ix]; 12439431996fSJuerg Haefliger break; 12449431996fSJuerg Haefliger case SYS_PWM_AUTO_POINT2_PWM: 12459431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 12469431996fSJuerg Haefliger res = 255; /* hard-wired */ 12479431996fSJuerg Haefliger break; 12489431996fSJuerg Haefliger default: 12499431996fSJuerg Haefliger res = 0; 1250b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 12519431996fSJuerg Haefliger } 12529431996fSJuerg Haefliger 12539431996fSJuerg Haefliger return sprintf(buf, "%d\n", res); 12549431996fSJuerg Haefliger } 12559431996fSJuerg Haefliger 125673ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm_chmod_attr[]; 125748176a97SAl Viro static void dme1737_chmod_file(struct device*, struct attribute*, umode_t); 12589431996fSJuerg Haefliger 12599431996fSJuerg Haefliger static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 12609431996fSJuerg Haefliger const char *buf, size_t count) 12619431996fSJuerg Haefliger { 1262b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 12639431996fSJuerg Haefliger struct sensor_device_attribute_2 12649431996fSJuerg Haefliger *sensor_attr_2 = to_sensor_dev_attr_2(attr); 12659431996fSJuerg Haefliger int ix = sensor_attr_2->index; 12669431996fSJuerg Haefliger int fn = sensor_attr_2->nr; 1267c8de8362SGuenter Roeck long val; 1268c8de8362SGuenter Roeck int err; 1269c8de8362SGuenter Roeck 1270c8de8362SGuenter Roeck err = kstrtol(buf, 10, &val); 1271c8de8362SGuenter Roeck if (err) 1272c8de8362SGuenter Roeck return err; 12739431996fSJuerg Haefliger 12749431996fSJuerg Haefliger mutex_lock(&data->update_lock); 12759431996fSJuerg Haefliger switch (fn) { 12769431996fSJuerg Haefliger case SYS_PWM: 12772a844c14SGuenter Roeck data->pwm[ix] = clamp_val(val, 0, 255); 1278dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM(ix), data->pwm[ix]); 12799431996fSJuerg Haefliger break; 12809431996fSJuerg Haefliger case SYS_PWM_FREQ: 1281dbc2bc25SJean Delvare data->pwm_freq[ix] = PWM_FREQ_TO_REG(val, dme1737_read(data, 12829431996fSJuerg Haefliger DME1737_REG_PWM_FREQ(ix))); 1283dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_FREQ(ix), 12849431996fSJuerg Haefliger data->pwm_freq[ix]); 12859431996fSJuerg Haefliger break; 12869431996fSJuerg Haefliger case SYS_PWM_ENABLE: 12879431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 12889431996fSJuerg Haefliger if (val < 0 || val > 2) { 12899431996fSJuerg Haefliger count = -EINVAL; 1290b55f3757SGuenter Roeck dev_warn(dev, 1291b55f3757SGuenter Roeck "PWM enable %ld not supported. Choose one of 0, 1, or 2.\n", 12929431996fSJuerg Haefliger val); 12939431996fSJuerg Haefliger goto exit; 12949431996fSJuerg Haefliger } 12959431996fSJuerg Haefliger /* Refresh the cache */ 1296dbc2bc25SJean Delvare data->pwm_config[ix] = dme1737_read(data, 12979431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 12989431996fSJuerg Haefliger if (val == PWM_EN_FROM_REG(data->pwm_config[ix])) { 12999431996fSJuerg Haefliger /* Bail out if no change */ 13009431996fSJuerg Haefliger goto exit; 13019431996fSJuerg Haefliger } 13029431996fSJuerg Haefliger /* Do some housekeeping if we are currently in auto mode */ 13039431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 13049431996fSJuerg Haefliger /* Save the current zone channel assignment */ 13059431996fSJuerg Haefliger data->pwm_acz[ix] = PWM_ACZ_FROM_REG( 13069431996fSJuerg Haefliger data->pwm_config[ix]); 13079431996fSJuerg Haefliger /* Save the current ramp rate state and disable it */ 1308dbc2bc25SJean Delvare data->pwm_rr[ix > 0] = dme1737_read(data, 13099431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0)); 13109431996fSJuerg Haefliger data->pwm_rr_en &= ~(1 << ix); 13119431996fSJuerg Haefliger if (PWM_RR_EN_FROM_REG(data->pwm_rr[ix > 0], ix)) { 13129431996fSJuerg Haefliger data->pwm_rr_en |= (1 << ix); 13139431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(0, ix, 13149431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 1315dbc2bc25SJean Delvare dme1737_write(data, 13169431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0), 13179431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 13189431996fSJuerg Haefliger } 13199431996fSJuerg Haefliger } 13209431996fSJuerg Haefliger /* Set the new PWM mode */ 13219431996fSJuerg Haefliger switch (val) { 13229431996fSJuerg Haefliger case 0: 13239431996fSJuerg Haefliger /* Change permissions of pwm[ix] to read-only */ 132473ce48f6SJuerg Haefliger dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix], 13259431996fSJuerg Haefliger S_IRUGO); 13269431996fSJuerg Haefliger /* Turn fan fully on */ 13279431996fSJuerg Haefliger data->pwm_config[ix] = PWM_EN_TO_REG(0, 13289431996fSJuerg Haefliger data->pwm_config[ix]); 1329dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_CONFIG(ix), 13309431996fSJuerg Haefliger data->pwm_config[ix]); 13319431996fSJuerg Haefliger break; 13329431996fSJuerg Haefliger case 1: 13339431996fSJuerg Haefliger /* Turn on manual mode */ 13349431996fSJuerg Haefliger data->pwm_config[ix] = PWM_EN_TO_REG(1, 13359431996fSJuerg Haefliger data->pwm_config[ix]); 1336dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_CONFIG(ix), 13379431996fSJuerg Haefliger data->pwm_config[ix]); 13389431996fSJuerg Haefliger /* Change permissions of pwm[ix] to read-writeable */ 133973ce48f6SJuerg Haefliger dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix], 13409431996fSJuerg Haefliger S_IRUGO | S_IWUSR); 13419431996fSJuerg Haefliger break; 13429431996fSJuerg Haefliger case 2: 13439431996fSJuerg Haefliger /* Change permissions of pwm[ix] to read-only */ 134473ce48f6SJuerg Haefliger dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix], 13459431996fSJuerg Haefliger S_IRUGO); 1346c8de8362SGuenter Roeck /* 1347c8de8362SGuenter Roeck * Turn on auto mode using the saved zone channel 1348c8de8362SGuenter Roeck * assignment 1349c8de8362SGuenter Roeck */ 13509431996fSJuerg Haefliger data->pwm_config[ix] = PWM_ACZ_TO_REG( 13519431996fSJuerg Haefliger data->pwm_acz[ix], 13529431996fSJuerg Haefliger data->pwm_config[ix]); 1353dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_CONFIG(ix), 13549431996fSJuerg Haefliger data->pwm_config[ix]); 13559431996fSJuerg Haefliger /* Enable PWM ramp rate if previously enabled */ 13569431996fSJuerg Haefliger if (data->pwm_rr_en & (1 << ix)) { 13579431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(1, ix, 1358dbc2bc25SJean Delvare dme1737_read(data, 13599431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0))); 1360dbc2bc25SJean Delvare dme1737_write(data, 13619431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0), 13629431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 13639431996fSJuerg Haefliger } 13649431996fSJuerg Haefliger break; 13659431996fSJuerg Haefliger } 13669431996fSJuerg Haefliger break; 13679431996fSJuerg Haefliger case SYS_PWM_RAMP_RATE: 13689431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 13699431996fSJuerg Haefliger /* Refresh the cache */ 1370dbc2bc25SJean Delvare data->pwm_config[ix] = dme1737_read(data, 13719431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 1372dbc2bc25SJean Delvare data->pwm_rr[ix > 0] = dme1737_read(data, 13739431996fSJuerg Haefliger DME1737_REG_PWM_RR(ix > 0)); 13749431996fSJuerg Haefliger /* Set the ramp rate value */ 13759431996fSJuerg Haefliger if (val > 0) { 13769431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_TO_REG(val, ix, 13779431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 13789431996fSJuerg Haefliger } 1379c8de8362SGuenter Roeck /* 1380c8de8362SGuenter Roeck * Enable/disable the feature only if the associated PWM 1381c8de8362SGuenter Roeck * output is in automatic mode. 1382c8de8362SGuenter Roeck */ 13839431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 13849431996fSJuerg Haefliger data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(val > 0, ix, 13859431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 13869431996fSJuerg Haefliger } 1387dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_RR(ix > 0), 13889431996fSJuerg Haefliger data->pwm_rr[ix > 0]); 13899431996fSJuerg Haefliger break; 13909431996fSJuerg Haefliger case SYS_PWM_AUTO_CHANNELS_ZONE: 13919431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 13929431996fSJuerg Haefliger if (!(val == 1 || val == 2 || val == 4 || 13939431996fSJuerg Haefliger val == 6 || val == 7)) { 13949431996fSJuerg Haefliger count = -EINVAL; 1395b55f3757SGuenter Roeck dev_warn(dev, 1396b55f3757SGuenter Roeck "PWM auto channels zone %ld not supported. Choose one of 1, 2, 4, 6, " 13979431996fSJuerg Haefliger "or 7.\n", val); 13989431996fSJuerg Haefliger goto exit; 13999431996fSJuerg Haefliger } 14009431996fSJuerg Haefliger /* Refresh the cache */ 1401dbc2bc25SJean Delvare data->pwm_config[ix] = dme1737_read(data, 14029431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 14039431996fSJuerg Haefliger if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) { 1404c8de8362SGuenter Roeck /* 1405c8de8362SGuenter Roeck * PWM is already in auto mode so update the temp 1406c8de8362SGuenter Roeck * channel assignment 1407c8de8362SGuenter Roeck */ 14089431996fSJuerg Haefliger data->pwm_config[ix] = PWM_ACZ_TO_REG(val, 14099431996fSJuerg Haefliger data->pwm_config[ix]); 1410dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_CONFIG(ix), 14119431996fSJuerg Haefliger data->pwm_config[ix]); 14129431996fSJuerg Haefliger } else { 1413c8de8362SGuenter Roeck /* 1414c8de8362SGuenter Roeck * PWM is not in auto mode so we save the temp 1415c8de8362SGuenter Roeck * channel assignment for later use 1416c8de8362SGuenter Roeck */ 14179431996fSJuerg Haefliger data->pwm_acz[ix] = val; 14189431996fSJuerg Haefliger } 14199431996fSJuerg Haefliger break; 14209431996fSJuerg Haefliger case SYS_PWM_AUTO_PWM_MIN: 14219431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 14229431996fSJuerg Haefliger /* Refresh the cache */ 1423dbc2bc25SJean Delvare data->pwm_min[ix] = dme1737_read(data, 14249431996fSJuerg Haefliger DME1737_REG_PWM_MIN(ix)); 1425c8de8362SGuenter Roeck /* 1426c8de8362SGuenter Roeck * There are only 2 values supported for the auto_pwm_min 14279431996fSJuerg Haefliger * value: 0 or auto_point1_pwm. So if the temperature drops 14289431996fSJuerg Haefliger * below the auto_point1_temp_hyst value, the fan either turns 1429c8de8362SGuenter Roeck * off or runs at auto_point1_pwm duty-cycle. 1430c8de8362SGuenter Roeck */ 14319431996fSJuerg Haefliger if (val > ((data->pwm_min[ix] + 1) / 2)) { 14329431996fSJuerg Haefliger data->pwm_rr[0] = PWM_OFF_TO_REG(1, ix, 1433dbc2bc25SJean Delvare dme1737_read(data, 14349431996fSJuerg Haefliger DME1737_REG_PWM_RR(0))); 14359431996fSJuerg Haefliger } else { 14369431996fSJuerg Haefliger data->pwm_rr[0] = PWM_OFF_TO_REG(0, ix, 1437dbc2bc25SJean Delvare dme1737_read(data, 14389431996fSJuerg Haefliger DME1737_REG_PWM_RR(0))); 14399431996fSJuerg Haefliger } 1440dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_RR(0), 14419431996fSJuerg Haefliger data->pwm_rr[0]); 14429431996fSJuerg Haefliger break; 14439431996fSJuerg Haefliger case SYS_PWM_AUTO_POINT1_PWM: 14449431996fSJuerg Haefliger /* Only valid for pwm[1-3] */ 14452a844c14SGuenter Roeck data->pwm_min[ix] = clamp_val(val, 0, 255); 1446dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM_MIN(ix), 14479431996fSJuerg Haefliger data->pwm_min[ix]); 14489431996fSJuerg Haefliger break; 14499431996fSJuerg Haefliger default: 1450b237eb25SJuerg Haefliger dev_dbg(dev, "Unknown function %d.\n", fn); 14519431996fSJuerg Haefliger } 14529431996fSJuerg Haefliger exit: 14539431996fSJuerg Haefliger mutex_unlock(&data->update_lock); 14549431996fSJuerg Haefliger 14559431996fSJuerg Haefliger return count; 14569431996fSJuerg Haefliger } 14579431996fSJuerg Haefliger 14589431996fSJuerg Haefliger /* --------------------------------------------------------------------- 14599431996fSJuerg Haefliger * Miscellaneous sysfs attributes 14609431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 14619431996fSJuerg Haefliger 1462fd5ddb81SJulia Lawall static ssize_t vrm_show(struct device *dev, struct device_attribute *attr, 14639431996fSJuerg Haefliger char *buf) 14649431996fSJuerg Haefliger { 14659431996fSJuerg Haefliger struct i2c_client *client = to_i2c_client(dev); 14669431996fSJuerg Haefliger struct dme1737_data *data = i2c_get_clientdata(client); 14679431996fSJuerg Haefliger 14689431996fSJuerg Haefliger return sprintf(buf, "%d\n", data->vrm); 14699431996fSJuerg Haefliger } 14709431996fSJuerg Haefliger 1471fd5ddb81SJulia Lawall static ssize_t vrm_store(struct device *dev, struct device_attribute *attr, 14729431996fSJuerg Haefliger const char *buf, size_t count) 14739431996fSJuerg Haefliger { 1474b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 1475d58e47d7SAxel Lin unsigned long val; 1476c8de8362SGuenter Roeck int err; 1477c8de8362SGuenter Roeck 1478d58e47d7SAxel Lin err = kstrtoul(buf, 10, &val); 1479c8de8362SGuenter Roeck if (err) 1480c8de8362SGuenter Roeck return err; 14819431996fSJuerg Haefliger 1482d58e47d7SAxel Lin if (val > 255) 1483d58e47d7SAxel Lin return -EINVAL; 1484d58e47d7SAxel Lin 14859431996fSJuerg Haefliger data->vrm = val; 14869431996fSJuerg Haefliger return count; 14879431996fSJuerg Haefliger } 14889431996fSJuerg Haefliger 1489fd5ddb81SJulia Lawall static ssize_t cpu0_vid_show(struct device *dev, 1490fd5ddb81SJulia Lawall struct device_attribute *attr, char *buf) 14919431996fSJuerg Haefliger { 14929431996fSJuerg Haefliger struct dme1737_data *data = dme1737_update_device(dev); 14939431996fSJuerg Haefliger 14949431996fSJuerg Haefliger return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm)); 14959431996fSJuerg Haefliger } 14969431996fSJuerg Haefliger 1497fd5ddb81SJulia Lawall static ssize_t name_show(struct device *dev, struct device_attribute *attr, 1498e95c237dSJuerg Haefliger char *buf) 1499e95c237dSJuerg Haefliger { 1500e95c237dSJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 1501e95c237dSJuerg Haefliger 1502dbc2bc25SJean Delvare return sprintf(buf, "%s\n", data->name); 1503e95c237dSJuerg Haefliger } 1504e95c237dSJuerg Haefliger 15059431996fSJuerg Haefliger /* --------------------------------------------------------------------- 15069431996fSJuerg Haefliger * Sysfs device attribute defines and structs 15079431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 15089431996fSJuerg Haefliger 1509d4b94e1fSJuerg Haefliger /* Voltages 0-7 */ 15109431996fSJuerg Haefliger 15119431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_IN(ix) \ 15129431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_input, S_IRUGO, \ 15139431996fSJuerg Haefliger show_in, NULL, SYS_IN_INPUT, ix); \ 15149431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_min, S_IRUGO | S_IWUSR, \ 15159431996fSJuerg Haefliger show_in, set_in, SYS_IN_MIN, ix); \ 15169431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_max, S_IRUGO | S_IWUSR, \ 15179431996fSJuerg Haefliger show_in, set_in, SYS_IN_MAX, ix); \ 15189431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(in##ix##_alarm, S_IRUGO, \ 15199431996fSJuerg Haefliger show_in, NULL, SYS_IN_ALARM, ix) 15209431996fSJuerg Haefliger 15219431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(0); 15229431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(1); 15239431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(2); 15249431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(3); 15259431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(4); 15269431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(5); 15279431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(6); 1528d4b94e1fSJuerg Haefliger SENSOR_DEVICE_ATTR_IN(7); 15299431996fSJuerg Haefliger 15309431996fSJuerg Haefliger /* Temperatures 1-3 */ 15319431996fSJuerg Haefliger 15329431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_TEMP(ix) \ 15339431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_input, S_IRUGO, \ 15349431996fSJuerg Haefliger show_temp, NULL, SYS_TEMP_INPUT, ix-1); \ 15359431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_min, S_IRUGO | S_IWUSR, \ 15369431996fSJuerg Haefliger show_temp, set_temp, SYS_TEMP_MIN, ix-1); \ 15379431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_max, S_IRUGO | S_IWUSR, \ 15389431996fSJuerg Haefliger show_temp, set_temp, SYS_TEMP_MAX, ix-1); \ 15399431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_offset, S_IRUGO, \ 15409431996fSJuerg Haefliger show_temp, set_temp, SYS_TEMP_OFFSET, ix-1); \ 15419431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_alarm, S_IRUGO, \ 15429431996fSJuerg Haefliger show_temp, NULL, SYS_TEMP_ALARM, ix-1); \ 15439431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(temp##ix##_fault, S_IRUGO, \ 15449431996fSJuerg Haefliger show_temp, NULL, SYS_TEMP_FAULT, ix-1) 15459431996fSJuerg Haefliger 15469431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_TEMP(1); 15479431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_TEMP(2); 15489431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_TEMP(3); 15499431996fSJuerg Haefliger 15509431996fSJuerg Haefliger /* Zones 1-3 */ 15519431996fSJuerg Haefliger 15529431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_ZONE(ix) \ 15539431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_channels_temp, S_IRUGO, \ 15549431996fSJuerg Haefliger show_zone, NULL, SYS_ZONE_AUTO_CHANNELS_TEMP, ix-1); \ 15559431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point1_temp_hyst, S_IRUGO, \ 15569431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT1_TEMP_HYST, ix-1); \ 15579431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point1_temp, S_IRUGO, \ 15589431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT1_TEMP, ix-1); \ 15599431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point2_temp, S_IRUGO, \ 15609431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT2_TEMP, ix-1); \ 15619431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(zone##ix##_auto_point3_temp, S_IRUGO, \ 15629431996fSJuerg Haefliger show_zone, set_zone, SYS_ZONE_AUTO_POINT3_TEMP, ix-1) 15639431996fSJuerg Haefliger 15649431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_ZONE(1); 15659431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_ZONE(2); 15669431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_ZONE(3); 15679431996fSJuerg Haefliger 15689431996fSJuerg Haefliger /* Fans 1-4 */ 15699431996fSJuerg Haefliger 15709431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_FAN_1TO4(ix) \ 15719431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_input, S_IRUGO, \ 15729431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_INPUT, ix-1); \ 15739431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \ 15749431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_MIN, ix-1); \ 15759431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_alarm, S_IRUGO, \ 15769431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_ALARM, ix-1); \ 15779431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_type, S_IRUGO | S_IWUSR, \ 15789431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_TYPE, ix-1) 15799431996fSJuerg Haefliger 15809431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(1); 15819431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(2); 15829431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(3); 15839431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_1TO4(4); 15849431996fSJuerg Haefliger 15859431996fSJuerg Haefliger /* Fans 5-6 */ 15869431996fSJuerg Haefliger 15879431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_FAN_5TO6(ix) \ 15889431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_input, S_IRUGO, \ 15899431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_INPUT, ix-1); \ 15909431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_min, S_IRUGO | S_IWUSR, \ 15919431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_MIN, ix-1); \ 15929431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_alarm, S_IRUGO, \ 15939431996fSJuerg Haefliger show_fan, NULL, SYS_FAN_ALARM, ix-1); \ 15949431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(fan##ix##_max, S_IRUGO | S_IWUSR, \ 15959431996fSJuerg Haefliger show_fan, set_fan, SYS_FAN_MAX, ix-1) 15969431996fSJuerg Haefliger 15979431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_5TO6(5); 15989431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_FAN_5TO6(6); 15999431996fSJuerg Haefliger 16009431996fSJuerg Haefliger /* PWMs 1-3 */ 16019431996fSJuerg Haefliger 16029431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_PWM_1TO3(ix) \ 16039431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \ 16049431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM, ix-1); \ 16059431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \ 16069431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \ 16079431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \ 16089431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_ENABLE, ix-1); \ 16099431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_ramp_rate, S_IRUGO, \ 16109431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_RAMP_RATE, ix-1); \ 16119431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_channels_zone, S_IRUGO, \ 16129431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_AUTO_CHANNELS_ZONE, ix-1); \ 16139431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_pwm_min, S_IRUGO, \ 16149431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_AUTO_PWM_MIN, ix-1); \ 16159431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point1_pwm, S_IRUGO, \ 16169431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_AUTO_POINT1_PWM, ix-1); \ 16179431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_auto_point2_pwm, S_IRUGO, \ 16189431996fSJuerg Haefliger show_pwm, NULL, SYS_PWM_AUTO_POINT2_PWM, ix-1) 16199431996fSJuerg Haefliger 16209431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_1TO3(1); 16219431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_1TO3(2); 16229431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_1TO3(3); 16239431996fSJuerg Haefliger 16249431996fSJuerg Haefliger /* PWMs 5-6 */ 16259431996fSJuerg Haefliger 16269431996fSJuerg Haefliger #define SENSOR_DEVICE_ATTR_PWM_5TO6(ix) \ 16279b257714SJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \ 16289431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM, ix-1); \ 16299b257714SJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \ 16309431996fSJuerg Haefliger show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \ 16319431996fSJuerg Haefliger static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \ 16329431996fSJuerg Haefliger show_pwm, NULL, SYS_PWM_ENABLE, ix-1) 16339431996fSJuerg Haefliger 16349431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_5TO6(5); 16359431996fSJuerg Haefliger SENSOR_DEVICE_ATTR_PWM_5TO6(6); 16369431996fSJuerg Haefliger 16379431996fSJuerg Haefliger /* Misc */ 16389431996fSJuerg Haefliger 1639fd5ddb81SJulia Lawall static DEVICE_ATTR_RW(vrm); 1640fd5ddb81SJulia Lawall static DEVICE_ATTR_RO(cpu0_vid); 1641fd5ddb81SJulia Lawall static DEVICE_ATTR_RO(name); /* for ISA devices */ 16429431996fSJuerg Haefliger 1643c8de8362SGuenter Roeck /* 1644c8de8362SGuenter Roeck * This struct holds all the attributes that are always present and need to be 16459431996fSJuerg Haefliger * created unconditionally. The attributes that need modification of their 16469431996fSJuerg Haefliger * permissions are created read-only and write permissions are added or removed 1647c8de8362SGuenter Roeck * on the fly when required 1648c8de8362SGuenter Roeck */ 16499431996fSJuerg Haefliger static struct attribute *dme1737_attr[] = { 16509431996fSJuerg Haefliger /* Voltages */ 16519b257714SJuerg Haefliger &sensor_dev_attr_in0_input.dev_attr.attr, 16529b257714SJuerg Haefliger &sensor_dev_attr_in0_min.dev_attr.attr, 16539b257714SJuerg Haefliger &sensor_dev_attr_in0_max.dev_attr.attr, 16549b257714SJuerg Haefliger &sensor_dev_attr_in0_alarm.dev_attr.attr, 16559b257714SJuerg Haefliger &sensor_dev_attr_in1_input.dev_attr.attr, 16569b257714SJuerg Haefliger &sensor_dev_attr_in1_min.dev_attr.attr, 16579b257714SJuerg Haefliger &sensor_dev_attr_in1_max.dev_attr.attr, 16589b257714SJuerg Haefliger &sensor_dev_attr_in1_alarm.dev_attr.attr, 16599b257714SJuerg Haefliger &sensor_dev_attr_in2_input.dev_attr.attr, 16609b257714SJuerg Haefliger &sensor_dev_attr_in2_min.dev_attr.attr, 16619b257714SJuerg Haefliger &sensor_dev_attr_in2_max.dev_attr.attr, 16629b257714SJuerg Haefliger &sensor_dev_attr_in2_alarm.dev_attr.attr, 16639b257714SJuerg Haefliger &sensor_dev_attr_in3_input.dev_attr.attr, 16649b257714SJuerg Haefliger &sensor_dev_attr_in3_min.dev_attr.attr, 16659b257714SJuerg Haefliger &sensor_dev_attr_in3_max.dev_attr.attr, 16669b257714SJuerg Haefliger &sensor_dev_attr_in3_alarm.dev_attr.attr, 16679b257714SJuerg Haefliger &sensor_dev_attr_in4_input.dev_attr.attr, 16689b257714SJuerg Haefliger &sensor_dev_attr_in4_min.dev_attr.attr, 16699b257714SJuerg Haefliger &sensor_dev_attr_in4_max.dev_attr.attr, 16709b257714SJuerg Haefliger &sensor_dev_attr_in4_alarm.dev_attr.attr, 16719b257714SJuerg Haefliger &sensor_dev_attr_in5_input.dev_attr.attr, 16729b257714SJuerg Haefliger &sensor_dev_attr_in5_min.dev_attr.attr, 16739b257714SJuerg Haefliger &sensor_dev_attr_in5_max.dev_attr.attr, 16749b257714SJuerg Haefliger &sensor_dev_attr_in5_alarm.dev_attr.attr, 16759b257714SJuerg Haefliger &sensor_dev_attr_in6_input.dev_attr.attr, 16769b257714SJuerg Haefliger &sensor_dev_attr_in6_min.dev_attr.attr, 16779b257714SJuerg Haefliger &sensor_dev_attr_in6_max.dev_attr.attr, 16789b257714SJuerg Haefliger &sensor_dev_attr_in6_alarm.dev_attr.attr, 16799431996fSJuerg Haefliger /* Temperatures */ 16809b257714SJuerg Haefliger &sensor_dev_attr_temp1_input.dev_attr.attr, 16819b257714SJuerg Haefliger &sensor_dev_attr_temp1_min.dev_attr.attr, 16829b257714SJuerg Haefliger &sensor_dev_attr_temp1_max.dev_attr.attr, 16839b257714SJuerg Haefliger &sensor_dev_attr_temp1_alarm.dev_attr.attr, 16849b257714SJuerg Haefliger &sensor_dev_attr_temp1_fault.dev_attr.attr, 16859b257714SJuerg Haefliger &sensor_dev_attr_temp2_input.dev_attr.attr, 16869b257714SJuerg Haefliger &sensor_dev_attr_temp2_min.dev_attr.attr, 16879b257714SJuerg Haefliger &sensor_dev_attr_temp2_max.dev_attr.attr, 16889b257714SJuerg Haefliger &sensor_dev_attr_temp2_alarm.dev_attr.attr, 16899b257714SJuerg Haefliger &sensor_dev_attr_temp2_fault.dev_attr.attr, 16909b257714SJuerg Haefliger &sensor_dev_attr_temp3_input.dev_attr.attr, 16919b257714SJuerg Haefliger &sensor_dev_attr_temp3_min.dev_attr.attr, 16929b257714SJuerg Haefliger &sensor_dev_attr_temp3_max.dev_attr.attr, 16939b257714SJuerg Haefliger &sensor_dev_attr_temp3_alarm.dev_attr.attr, 16949b257714SJuerg Haefliger &sensor_dev_attr_temp3_fault.dev_attr.attr, 16959431996fSJuerg Haefliger /* Zones */ 16969b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr, 16979b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr, 16989b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr, 16999b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_channels_temp.dev_attr.attr, 17009b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr, 17019b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr, 17029b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr, 17039b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_channels_temp.dev_attr.attr, 1704549edb83SJuerg Haefliger NULL 1705549edb83SJuerg Haefliger }; 1706549edb83SJuerg Haefliger 1707549edb83SJuerg Haefliger static const struct attribute_group dme1737_group = { 1708549edb83SJuerg Haefliger .attrs = dme1737_attr, 1709549edb83SJuerg Haefliger }; 1710549edb83SJuerg Haefliger 1711c8de8362SGuenter Roeck /* 1712c8de8362SGuenter Roeck * The following struct holds temp offset attributes, which are not available 1713ea694431SJuerg Haefliger * in all chips. The following chips support them: 1714c8de8362SGuenter Roeck * DME1737, SCH311x 1715c8de8362SGuenter Roeck */ 1716ea694431SJuerg Haefliger static struct attribute *dme1737_temp_offset_attr[] = { 1717549edb83SJuerg Haefliger &sensor_dev_attr_temp1_offset.dev_attr.attr, 1718549edb83SJuerg Haefliger &sensor_dev_attr_temp2_offset.dev_attr.attr, 1719549edb83SJuerg Haefliger &sensor_dev_attr_temp3_offset.dev_attr.attr, 17209431996fSJuerg Haefliger NULL 17219431996fSJuerg Haefliger }; 17229431996fSJuerg Haefliger 1723ea694431SJuerg Haefliger static const struct attribute_group dme1737_temp_offset_group = { 1724ea694431SJuerg Haefliger .attrs = dme1737_temp_offset_attr, 17259431996fSJuerg Haefliger }; 17269431996fSJuerg Haefliger 1727c8de8362SGuenter Roeck /* 1728c8de8362SGuenter Roeck * The following struct holds VID related attributes, which are not available 1729ea694431SJuerg Haefliger * in all chips. The following chips support them: 1730c8de8362SGuenter Roeck * DME1737 1731c8de8362SGuenter Roeck */ 17329d091446SJean Delvare static struct attribute *dme1737_vid_attr[] = { 17339d091446SJean Delvare &dev_attr_vrm.attr, 17349d091446SJean Delvare &dev_attr_cpu0_vid.attr, 17359d091446SJean Delvare NULL 17369d091446SJean Delvare }; 17379d091446SJean Delvare 17389d091446SJean Delvare static const struct attribute_group dme1737_vid_group = { 17399d091446SJean Delvare .attrs = dme1737_vid_attr, 17409d091446SJean Delvare }; 17419d091446SJean Delvare 1742c8de8362SGuenter Roeck /* 1743c8de8362SGuenter Roeck * The following struct holds temp zone 3 related attributes, which are not 1744ea694431SJuerg Haefliger * available in all chips. The following chips support them: 1745c8de8362SGuenter Roeck * DME1737, SCH311x, SCH5027 1746c8de8362SGuenter Roeck */ 1747ea694431SJuerg Haefliger static struct attribute *dme1737_zone3_attr[] = { 1748ea694431SJuerg Haefliger &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr, 1749ea694431SJuerg Haefliger &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr, 1750ea694431SJuerg Haefliger &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr, 1751ea694431SJuerg Haefliger &sensor_dev_attr_zone3_auto_channels_temp.dev_attr.attr, 1752ea694431SJuerg Haefliger NULL 1753ea694431SJuerg Haefliger }; 1754ea694431SJuerg Haefliger 1755ea694431SJuerg Haefliger static const struct attribute_group dme1737_zone3_group = { 1756ea694431SJuerg Haefliger .attrs = dme1737_zone3_attr, 1757ea694431SJuerg Haefliger }; 1758ea694431SJuerg Haefliger 1759ea694431SJuerg Haefliger 1760c8de8362SGuenter Roeck /* 1761c8de8362SGuenter Roeck * The following struct holds temp zone hysteresis related attributes, which 1762ea694431SJuerg Haefliger * are not available in all chips. The following chips support them: 1763c8de8362SGuenter Roeck * DME1737, SCH311x 1764c8de8362SGuenter Roeck */ 1765ea694431SJuerg Haefliger static struct attribute *dme1737_zone_hyst_attr[] = { 1766ea694431SJuerg Haefliger &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr, 1767ea694431SJuerg Haefliger &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr, 1768ea694431SJuerg Haefliger &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr, 1769ea694431SJuerg Haefliger NULL 1770ea694431SJuerg Haefliger }; 1771ea694431SJuerg Haefliger 1772ea694431SJuerg Haefliger static const struct attribute_group dme1737_zone_hyst_group = { 1773ea694431SJuerg Haefliger .attrs = dme1737_zone_hyst_attr, 1774ea694431SJuerg Haefliger }; 1775ea694431SJuerg Haefliger 1776c8de8362SGuenter Roeck /* 1777c8de8362SGuenter Roeck * The following struct holds voltage in7 related attributes, which 1778d4b94e1fSJuerg Haefliger * are not available in all chips. The following chips support them: 1779c8de8362SGuenter Roeck * SCH5127 1780c8de8362SGuenter Roeck */ 1781d4b94e1fSJuerg Haefliger static struct attribute *dme1737_in7_attr[] = { 1782d4b94e1fSJuerg Haefliger &sensor_dev_attr_in7_input.dev_attr.attr, 1783d4b94e1fSJuerg Haefliger &sensor_dev_attr_in7_min.dev_attr.attr, 1784d4b94e1fSJuerg Haefliger &sensor_dev_attr_in7_max.dev_attr.attr, 1785d4b94e1fSJuerg Haefliger &sensor_dev_attr_in7_alarm.dev_attr.attr, 1786d4b94e1fSJuerg Haefliger NULL 1787d4b94e1fSJuerg Haefliger }; 1788d4b94e1fSJuerg Haefliger 1789d4b94e1fSJuerg Haefliger static const struct attribute_group dme1737_in7_group = { 1790d4b94e1fSJuerg Haefliger .attrs = dme1737_in7_attr, 1791d4b94e1fSJuerg Haefliger }; 1792d4b94e1fSJuerg Haefliger 1793c8de8362SGuenter Roeck /* 1794c8de8362SGuenter Roeck * The following structs hold the PWM attributes, some of which are optional. 17959431996fSJuerg Haefliger * Their creation depends on the chip configuration which is determined during 1796c8de8362SGuenter Roeck * module load. 1797c8de8362SGuenter Roeck */ 179873ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm1_attr[] = { 17999b257714SJuerg Haefliger &sensor_dev_attr_pwm1.dev_attr.attr, 18009b257714SJuerg Haefliger &sensor_dev_attr_pwm1_freq.dev_attr.attr, 18019b257714SJuerg Haefliger &sensor_dev_attr_pwm1_enable.dev_attr.attr, 18029b257714SJuerg Haefliger &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr, 18039b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr, 18049b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 18059b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 18069431996fSJuerg Haefliger NULL 18079431996fSJuerg Haefliger }; 180873ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm2_attr[] = { 18099b257714SJuerg Haefliger &sensor_dev_attr_pwm2.dev_attr.attr, 18109b257714SJuerg Haefliger &sensor_dev_attr_pwm2_freq.dev_attr.attr, 18119b257714SJuerg Haefliger &sensor_dev_attr_pwm2_enable.dev_attr.attr, 18129b257714SJuerg Haefliger &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr, 18139b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr, 18149b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 18159b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr, 18169431996fSJuerg Haefliger NULL 18179431996fSJuerg Haefliger }; 181873ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm3_attr[] = { 18199b257714SJuerg Haefliger &sensor_dev_attr_pwm3.dev_attr.attr, 18209b257714SJuerg Haefliger &sensor_dev_attr_pwm3_freq.dev_attr.attr, 18219b257714SJuerg Haefliger &sensor_dev_attr_pwm3_enable.dev_attr.attr, 18229b257714SJuerg Haefliger &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr, 18239b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr, 18249b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 18259b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr, 18269431996fSJuerg Haefliger NULL 18279431996fSJuerg Haefliger }; 182873ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm5_attr[] = { 18299b257714SJuerg Haefliger &sensor_dev_attr_pwm5.dev_attr.attr, 18309b257714SJuerg Haefliger &sensor_dev_attr_pwm5_freq.dev_attr.attr, 18319b257714SJuerg Haefliger &sensor_dev_attr_pwm5_enable.dev_attr.attr, 18329431996fSJuerg Haefliger NULL 18339431996fSJuerg Haefliger }; 183473ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm6_attr[] = { 18359b257714SJuerg Haefliger &sensor_dev_attr_pwm6.dev_attr.attr, 18369b257714SJuerg Haefliger &sensor_dev_attr_pwm6_freq.dev_attr.attr, 18379b257714SJuerg Haefliger &sensor_dev_attr_pwm6_enable.dev_attr.attr, 18389431996fSJuerg Haefliger NULL 18399431996fSJuerg Haefliger }; 18409431996fSJuerg Haefliger 18419431996fSJuerg Haefliger static const struct attribute_group dme1737_pwm_group[] = { 184273ce48f6SJuerg Haefliger { .attrs = dme1737_pwm1_attr }, 184373ce48f6SJuerg Haefliger { .attrs = dme1737_pwm2_attr }, 184473ce48f6SJuerg Haefliger { .attrs = dme1737_pwm3_attr }, 18459431996fSJuerg Haefliger { .attrs = NULL }, 184673ce48f6SJuerg Haefliger { .attrs = dme1737_pwm5_attr }, 184773ce48f6SJuerg Haefliger { .attrs = dme1737_pwm6_attr }, 18489431996fSJuerg Haefliger }; 18499431996fSJuerg Haefliger 1850c8de8362SGuenter Roeck /* 1851c8de8362SGuenter Roeck * The following struct holds auto PWM min attributes, which are not available 1852ea694431SJuerg Haefliger * in all chips. Their creation depends on the chip type which is determined 1853c8de8362SGuenter Roeck * during module load. 1854c8de8362SGuenter Roeck */ 1855ea694431SJuerg Haefliger static struct attribute *dme1737_auto_pwm_min_attr[] = { 1856549edb83SJuerg Haefliger &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr, 1857549edb83SJuerg Haefliger &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr, 1858549edb83SJuerg Haefliger &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr, 1859549edb83SJuerg Haefliger }; 1860549edb83SJuerg Haefliger 1861c8de8362SGuenter Roeck /* 1862c8de8362SGuenter Roeck * The following structs hold the fan attributes, some of which are optional. 18639431996fSJuerg Haefliger * Their creation depends on the chip configuration which is determined during 1864c8de8362SGuenter Roeck * module load. 1865c8de8362SGuenter Roeck */ 186673ce48f6SJuerg Haefliger static struct attribute *dme1737_fan1_attr[] = { 18679b257714SJuerg Haefliger &sensor_dev_attr_fan1_input.dev_attr.attr, 18689b257714SJuerg Haefliger &sensor_dev_attr_fan1_min.dev_attr.attr, 18699b257714SJuerg Haefliger &sensor_dev_attr_fan1_alarm.dev_attr.attr, 18709b257714SJuerg Haefliger &sensor_dev_attr_fan1_type.dev_attr.attr, 18719431996fSJuerg Haefliger NULL 18729431996fSJuerg Haefliger }; 187373ce48f6SJuerg Haefliger static struct attribute *dme1737_fan2_attr[] = { 18749b257714SJuerg Haefliger &sensor_dev_attr_fan2_input.dev_attr.attr, 18759b257714SJuerg Haefliger &sensor_dev_attr_fan2_min.dev_attr.attr, 18769b257714SJuerg Haefliger &sensor_dev_attr_fan2_alarm.dev_attr.attr, 18779b257714SJuerg Haefliger &sensor_dev_attr_fan2_type.dev_attr.attr, 18789431996fSJuerg Haefliger NULL 18799431996fSJuerg Haefliger }; 188073ce48f6SJuerg Haefliger static struct attribute *dme1737_fan3_attr[] = { 18819b257714SJuerg Haefliger &sensor_dev_attr_fan3_input.dev_attr.attr, 18829b257714SJuerg Haefliger &sensor_dev_attr_fan3_min.dev_attr.attr, 18839b257714SJuerg Haefliger &sensor_dev_attr_fan3_alarm.dev_attr.attr, 18849b257714SJuerg Haefliger &sensor_dev_attr_fan3_type.dev_attr.attr, 18859431996fSJuerg Haefliger NULL 18869431996fSJuerg Haefliger }; 188773ce48f6SJuerg Haefliger static struct attribute *dme1737_fan4_attr[] = { 18889b257714SJuerg Haefliger &sensor_dev_attr_fan4_input.dev_attr.attr, 18899b257714SJuerg Haefliger &sensor_dev_attr_fan4_min.dev_attr.attr, 18909b257714SJuerg Haefliger &sensor_dev_attr_fan4_alarm.dev_attr.attr, 18919b257714SJuerg Haefliger &sensor_dev_attr_fan4_type.dev_attr.attr, 18929431996fSJuerg Haefliger NULL 18939431996fSJuerg Haefliger }; 189473ce48f6SJuerg Haefliger static struct attribute *dme1737_fan5_attr[] = { 18959b257714SJuerg Haefliger &sensor_dev_attr_fan5_input.dev_attr.attr, 18969b257714SJuerg Haefliger &sensor_dev_attr_fan5_min.dev_attr.attr, 18979b257714SJuerg Haefliger &sensor_dev_attr_fan5_alarm.dev_attr.attr, 18989b257714SJuerg Haefliger &sensor_dev_attr_fan5_max.dev_attr.attr, 18999431996fSJuerg Haefliger NULL 19009431996fSJuerg Haefliger }; 190173ce48f6SJuerg Haefliger static struct attribute *dme1737_fan6_attr[] = { 19029b257714SJuerg Haefliger &sensor_dev_attr_fan6_input.dev_attr.attr, 19039b257714SJuerg Haefliger &sensor_dev_attr_fan6_min.dev_attr.attr, 19049b257714SJuerg Haefliger &sensor_dev_attr_fan6_alarm.dev_attr.attr, 19059b257714SJuerg Haefliger &sensor_dev_attr_fan6_max.dev_attr.attr, 19069431996fSJuerg Haefliger NULL 19079431996fSJuerg Haefliger }; 19089431996fSJuerg Haefliger 19099431996fSJuerg Haefliger static const struct attribute_group dme1737_fan_group[] = { 191073ce48f6SJuerg Haefliger { .attrs = dme1737_fan1_attr }, 191173ce48f6SJuerg Haefliger { .attrs = dme1737_fan2_attr }, 191273ce48f6SJuerg Haefliger { .attrs = dme1737_fan3_attr }, 191373ce48f6SJuerg Haefliger { .attrs = dme1737_fan4_attr }, 191473ce48f6SJuerg Haefliger { .attrs = dme1737_fan5_attr }, 191573ce48f6SJuerg Haefliger { .attrs = dme1737_fan6_attr }, 19169431996fSJuerg Haefliger }; 19179431996fSJuerg Haefliger 1918c8de8362SGuenter Roeck /* 1919c8de8362SGuenter Roeck * The permissions of the following zone attributes are changed to read- 1920c8de8362SGuenter Roeck * writeable if the chip is *not* locked. Otherwise they stay read-only. 1921c8de8362SGuenter Roeck */ 1922549edb83SJuerg Haefliger static struct attribute *dme1737_zone_chmod_attr[] = { 19239b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr, 19249b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr, 19259b257714SJuerg Haefliger &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr, 19269b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr, 19279b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr, 19289b257714SJuerg Haefliger &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr, 1929ea694431SJuerg Haefliger NULL 1930ea694431SJuerg Haefliger }; 1931ea694431SJuerg Haefliger 1932ea694431SJuerg Haefliger static const struct attribute_group dme1737_zone_chmod_group = { 1933ea694431SJuerg Haefliger .attrs = dme1737_zone_chmod_attr, 1934ea694431SJuerg Haefliger }; 1935ea694431SJuerg Haefliger 1936ea694431SJuerg Haefliger 1937c8de8362SGuenter Roeck /* 1938c8de8362SGuenter Roeck * The permissions of the following zone 3 attributes are changed to read- 1939c8de8362SGuenter Roeck * writeable if the chip is *not* locked. Otherwise they stay read-only. 1940c8de8362SGuenter Roeck */ 1941ea694431SJuerg Haefliger static struct attribute *dme1737_zone3_chmod_attr[] = { 19429b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr, 19439b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr, 19449b257714SJuerg Haefliger &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr, 19459431996fSJuerg Haefliger NULL 19469431996fSJuerg Haefliger }; 19479431996fSJuerg Haefliger 1948ea694431SJuerg Haefliger static const struct attribute_group dme1737_zone3_chmod_group = { 1949ea694431SJuerg Haefliger .attrs = dme1737_zone3_chmod_attr, 19509431996fSJuerg Haefliger }; 19519431996fSJuerg Haefliger 1952c8de8362SGuenter Roeck /* 1953c8de8362SGuenter Roeck * The permissions of the following PWM attributes are changed to read- 19549431996fSJuerg Haefliger * writeable if the chip is *not* locked and the respective PWM is available. 1955c8de8362SGuenter Roeck * Otherwise they stay read-only. 1956c8de8362SGuenter Roeck */ 195773ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm1_chmod_attr[] = { 19589b257714SJuerg Haefliger &sensor_dev_attr_pwm1_freq.dev_attr.attr, 19599b257714SJuerg Haefliger &sensor_dev_attr_pwm1_enable.dev_attr.attr, 19609b257714SJuerg Haefliger &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr, 19619b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr, 19629b257714SJuerg Haefliger &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 19639431996fSJuerg Haefliger NULL 19649431996fSJuerg Haefliger }; 196573ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm2_chmod_attr[] = { 19669b257714SJuerg Haefliger &sensor_dev_attr_pwm2_freq.dev_attr.attr, 19679b257714SJuerg Haefliger &sensor_dev_attr_pwm2_enable.dev_attr.attr, 19689b257714SJuerg Haefliger &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr, 19699b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr, 19709b257714SJuerg Haefliger &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr, 19719431996fSJuerg Haefliger NULL 19729431996fSJuerg Haefliger }; 197373ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm3_chmod_attr[] = { 19749b257714SJuerg Haefliger &sensor_dev_attr_pwm3_freq.dev_attr.attr, 19759b257714SJuerg Haefliger &sensor_dev_attr_pwm3_enable.dev_attr.attr, 19769b257714SJuerg Haefliger &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr, 19779b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr, 19789b257714SJuerg Haefliger &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr, 19799431996fSJuerg Haefliger NULL 19809431996fSJuerg Haefliger }; 198173ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm5_chmod_attr[] = { 19829b257714SJuerg Haefliger &sensor_dev_attr_pwm5.dev_attr.attr, 19839b257714SJuerg Haefliger &sensor_dev_attr_pwm5_freq.dev_attr.attr, 19849431996fSJuerg Haefliger NULL 19859431996fSJuerg Haefliger }; 198673ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm6_chmod_attr[] = { 19879b257714SJuerg Haefliger &sensor_dev_attr_pwm6.dev_attr.attr, 19889b257714SJuerg Haefliger &sensor_dev_attr_pwm6_freq.dev_attr.attr, 19899431996fSJuerg Haefliger NULL 19909431996fSJuerg Haefliger }; 19919431996fSJuerg Haefliger 199273ce48f6SJuerg Haefliger static const struct attribute_group dme1737_pwm_chmod_group[] = { 199373ce48f6SJuerg Haefliger { .attrs = dme1737_pwm1_chmod_attr }, 199473ce48f6SJuerg Haefliger { .attrs = dme1737_pwm2_chmod_attr }, 199573ce48f6SJuerg Haefliger { .attrs = dme1737_pwm3_chmod_attr }, 19969431996fSJuerg Haefliger { .attrs = NULL }, 199773ce48f6SJuerg Haefliger { .attrs = dme1737_pwm5_chmod_attr }, 199873ce48f6SJuerg Haefliger { .attrs = dme1737_pwm6_chmod_attr }, 19999431996fSJuerg Haefliger }; 20009431996fSJuerg Haefliger 2001c8de8362SGuenter Roeck /* 2002c8de8362SGuenter Roeck * Pwm[1-3] are read-writeable if the associated pwm is in manual mode and the 2003c8de8362SGuenter Roeck * chip is not locked. Otherwise they are read-only. 2004c8de8362SGuenter Roeck */ 200573ce48f6SJuerg Haefliger static struct attribute *dme1737_pwm_chmod_attr[] = { 20069431996fSJuerg Haefliger &sensor_dev_attr_pwm1.dev_attr.attr, 20079431996fSJuerg Haefliger &sensor_dev_attr_pwm2.dev_attr.attr, 20089431996fSJuerg Haefliger &sensor_dev_attr_pwm3.dev_attr.attr, 20099431996fSJuerg Haefliger }; 20109431996fSJuerg Haefliger 20119431996fSJuerg Haefliger /* --------------------------------------------------------------------- 20129431996fSJuerg Haefliger * Super-IO functions 20139431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 20149431996fSJuerg Haefliger 2015b237eb25SJuerg Haefliger static inline void dme1737_sio_enter(int sio_cip) 2016b237eb25SJuerg Haefliger { 2017b237eb25SJuerg Haefliger outb(0x55, sio_cip); 2018b237eb25SJuerg Haefliger } 2019b237eb25SJuerg Haefliger 2020b237eb25SJuerg Haefliger static inline void dme1737_sio_exit(int sio_cip) 2021b237eb25SJuerg Haefliger { 2022b237eb25SJuerg Haefliger outb(0xaa, sio_cip); 2023b237eb25SJuerg Haefliger } 2024b237eb25SJuerg Haefliger 20259431996fSJuerg Haefliger static inline int dme1737_sio_inb(int sio_cip, int reg) 20269431996fSJuerg Haefliger { 20279431996fSJuerg Haefliger outb(reg, sio_cip); 20289431996fSJuerg Haefliger return inb(sio_cip + 1); 20299431996fSJuerg Haefliger } 20309431996fSJuerg Haefliger 20319431996fSJuerg Haefliger static inline void dme1737_sio_outb(int sio_cip, int reg, int val) 20329431996fSJuerg Haefliger { 20339431996fSJuerg Haefliger outb(reg, sio_cip); 20349431996fSJuerg Haefliger outb(val, sio_cip + 1); 20359431996fSJuerg Haefliger } 20369431996fSJuerg Haefliger 20379431996fSJuerg Haefliger /* --------------------------------------------------------------------- 2038e95c237dSJuerg Haefliger * Device initialization 20399431996fSJuerg Haefliger * --------------------------------------------------------------------- */ 20409431996fSJuerg Haefliger 204167e2f328SJuerg Haefliger static int dme1737_i2c_get_features(int, struct dme1737_data*); 20429431996fSJuerg Haefliger 2043b237eb25SJuerg Haefliger static void dme1737_chmod_file(struct device *dev, 204448176a97SAl Viro struct attribute *attr, umode_t mode) 20459431996fSJuerg Haefliger { 2046b237eb25SJuerg Haefliger if (sysfs_chmod_file(&dev->kobj, attr, mode)) { 2047b237eb25SJuerg Haefliger dev_warn(dev, "Failed to change permissions of %s.\n", 20489431996fSJuerg Haefliger attr->name); 20499431996fSJuerg Haefliger } 20509431996fSJuerg Haefliger } 20519431996fSJuerg Haefliger 2052b237eb25SJuerg Haefliger static void dme1737_chmod_group(struct device *dev, 20539431996fSJuerg Haefliger const struct attribute_group *group, 205448176a97SAl Viro umode_t mode) 20559431996fSJuerg Haefliger { 20569431996fSJuerg Haefliger struct attribute **attr; 20579431996fSJuerg Haefliger 2058c8de8362SGuenter Roeck for (attr = group->attrs; *attr; attr++) 2059b237eb25SJuerg Haefliger dme1737_chmod_file(dev, *attr, mode); 20609431996fSJuerg Haefliger } 20619431996fSJuerg Haefliger 2062b237eb25SJuerg Haefliger static void dme1737_remove_files(struct device *dev) 20639431996fSJuerg Haefliger { 2064b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 2065b237eb25SJuerg Haefliger int ix; 2066b237eb25SJuerg Haefliger 2067b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) { 2068ea694431SJuerg Haefliger if (data->has_features & HAS_FAN(ix)) { 2069b237eb25SJuerg Haefliger sysfs_remove_group(&dev->kobj, 2070b237eb25SJuerg Haefliger &dme1737_fan_group[ix]); 2071b237eb25SJuerg Haefliger } 2072b237eb25SJuerg Haefliger } 2073b237eb25SJuerg Haefliger 2074b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) { 2075ea694431SJuerg Haefliger if (data->has_features & HAS_PWM(ix)) { 2076b237eb25SJuerg Haefliger sysfs_remove_group(&dev->kobj, 2077b237eb25SJuerg Haefliger &dme1737_pwm_group[ix]); 2078ea694431SJuerg Haefliger if ((data->has_features & HAS_PWM_MIN) && ix < 3) { 2079549edb83SJuerg Haefliger sysfs_remove_file(&dev->kobj, 2080ea694431SJuerg Haefliger dme1737_auto_pwm_min_attr[ix]); 2081b237eb25SJuerg Haefliger } 2082b237eb25SJuerg Haefliger } 2083549edb83SJuerg Haefliger } 2084549edb83SJuerg Haefliger 2085c8de8362SGuenter Roeck if (data->has_features & HAS_TEMP_OFFSET) 2086ea694431SJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_temp_offset_group); 2087c8de8362SGuenter Roeck if (data->has_features & HAS_VID) 20889d091446SJean Delvare sysfs_remove_group(&dev->kobj, &dme1737_vid_group); 2089c8de8362SGuenter Roeck if (data->has_features & HAS_ZONE3) 2090ea694431SJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_zone3_group); 2091c8de8362SGuenter Roeck if (data->has_features & HAS_ZONE_HYST) 2092ea694431SJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_zone_hyst_group); 2093c8de8362SGuenter Roeck if (data->has_features & HAS_IN7) 2094d4b94e1fSJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_in7_group); 2095b237eb25SJuerg Haefliger sysfs_remove_group(&dev->kobj, &dme1737_group); 2096e95c237dSJuerg Haefliger 2097c8de8362SGuenter Roeck if (!data->client) 2098e95c237dSJuerg Haefliger sysfs_remove_file(&dev->kobj, &dev_attr_name.attr); 2099e95c237dSJuerg Haefliger } 2100b237eb25SJuerg Haefliger 2101b237eb25SJuerg Haefliger static int dme1737_create_files(struct device *dev) 2102b237eb25SJuerg Haefliger { 2103b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 2104b237eb25SJuerg Haefliger int err, ix; 2105b237eb25SJuerg Haefliger 2106e95c237dSJuerg Haefliger /* Create a name attribute for ISA devices */ 210706f3d9fbSJuerg Haefliger if (!data->client) { 210806f3d9fbSJuerg Haefliger err = sysfs_create_file(&dev->kobj, &dev_attr_name.attr); 2109c8de8362SGuenter Roeck if (err) 2110e95c237dSJuerg Haefliger goto exit; 2111e95c237dSJuerg Haefliger } 2112e95c237dSJuerg Haefliger 2113b237eb25SJuerg Haefliger /* Create standard sysfs attributes */ 211406f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, &dme1737_group); 2115c8de8362SGuenter Roeck if (err) 2116e95c237dSJuerg Haefliger goto exit_remove; 2117b237eb25SJuerg Haefliger 2118ea694431SJuerg Haefliger /* Create chip-dependent sysfs attributes */ 211906f3d9fbSJuerg Haefliger if (data->has_features & HAS_TEMP_OFFSET) { 212006f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, 212106f3d9fbSJuerg Haefliger &dme1737_temp_offset_group); 2122c8de8362SGuenter Roeck if (err) 2123549edb83SJuerg Haefliger goto exit_remove; 2124549edb83SJuerg Haefliger } 212506f3d9fbSJuerg Haefliger if (data->has_features & HAS_VID) { 212606f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, &dme1737_vid_group); 2127c8de8362SGuenter Roeck if (err) 21289d091446SJean Delvare goto exit_remove; 21299d091446SJean Delvare } 213006f3d9fbSJuerg Haefliger if (data->has_features & HAS_ZONE3) { 213106f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, &dme1737_zone3_group); 2132c8de8362SGuenter Roeck if (err) 2133ea694431SJuerg Haefliger goto exit_remove; 2134ea694431SJuerg Haefliger } 213506f3d9fbSJuerg Haefliger if (data->has_features & HAS_ZONE_HYST) { 213606f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, &dme1737_zone_hyst_group); 2137c8de8362SGuenter Roeck if (err) 2138ea694431SJuerg Haefliger goto exit_remove; 2139ea694431SJuerg Haefliger } 2140d4b94e1fSJuerg Haefliger if (data->has_features & HAS_IN7) { 2141d4b94e1fSJuerg Haefliger err = sysfs_create_group(&dev->kobj, &dme1737_in7_group); 2142c8de8362SGuenter Roeck if (err) 2143d4b94e1fSJuerg Haefliger goto exit_remove; 2144d4b94e1fSJuerg Haefliger } 21459d091446SJean Delvare 2146b237eb25SJuerg Haefliger /* Create fan sysfs attributes */ 2147b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) { 2148ea694431SJuerg Haefliger if (data->has_features & HAS_FAN(ix)) { 214906f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, 215006f3d9fbSJuerg Haefliger &dme1737_fan_group[ix]); 2151c8de8362SGuenter Roeck if (err) 2152b237eb25SJuerg Haefliger goto exit_remove; 2153b237eb25SJuerg Haefliger } 2154b237eb25SJuerg Haefliger } 2155b237eb25SJuerg Haefliger 2156b237eb25SJuerg Haefliger /* Create PWM sysfs attributes */ 2157b237eb25SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) { 2158ea694431SJuerg Haefliger if (data->has_features & HAS_PWM(ix)) { 215906f3d9fbSJuerg Haefliger err = sysfs_create_group(&dev->kobj, 216006f3d9fbSJuerg Haefliger &dme1737_pwm_group[ix]); 2161c8de8362SGuenter Roeck if (err) 2162b237eb25SJuerg Haefliger goto exit_remove; 216306f3d9fbSJuerg Haefliger if ((data->has_features & HAS_PWM_MIN) && (ix < 3)) { 216406f3d9fbSJuerg Haefliger err = sysfs_create_file(&dev->kobj, 216506f3d9fbSJuerg Haefliger dme1737_auto_pwm_min_attr[ix]); 2166c8de8362SGuenter Roeck if (err) 2167549edb83SJuerg Haefliger goto exit_remove; 2168549edb83SJuerg Haefliger } 2169b237eb25SJuerg Haefliger } 2170b237eb25SJuerg Haefliger } 2171b237eb25SJuerg Haefliger 2172c8de8362SGuenter Roeck /* 2173c8de8362SGuenter Roeck * Inform if the device is locked. Otherwise change the permissions of 2174c8de8362SGuenter Roeck * selected attributes from read-only to read-writeable. 2175c8de8362SGuenter Roeck */ 2176b237eb25SJuerg Haefliger if (data->config & 0x02) { 2177b55f3757SGuenter Roeck dev_info(dev, 2178b55f3757SGuenter Roeck "Device is locked. Some attributes will be read-only.\n"); 2179b237eb25SJuerg Haefliger } else { 2180549edb83SJuerg Haefliger /* Change permissions of zone sysfs attributes */ 2181549edb83SJuerg Haefliger dme1737_chmod_group(dev, &dme1737_zone_chmod_group, 2182b237eb25SJuerg Haefliger S_IRUGO | S_IWUSR); 2183b237eb25SJuerg Haefliger 2184ea694431SJuerg Haefliger /* Change permissions of chip-dependent sysfs attributes */ 2185ea694431SJuerg Haefliger if (data->has_features & HAS_TEMP_OFFSET) { 2186ea694431SJuerg Haefliger dme1737_chmod_group(dev, &dme1737_temp_offset_group, 2187ea694431SJuerg Haefliger S_IRUGO | S_IWUSR); 2188ea694431SJuerg Haefliger } 2189ea694431SJuerg Haefliger if (data->has_features & HAS_ZONE3) { 2190ea694431SJuerg Haefliger dme1737_chmod_group(dev, &dme1737_zone3_chmod_group, 2191ea694431SJuerg Haefliger S_IRUGO | S_IWUSR); 2192ea694431SJuerg Haefliger } 2193ea694431SJuerg Haefliger if (data->has_features & HAS_ZONE_HYST) { 2194ea694431SJuerg Haefliger dme1737_chmod_group(dev, &dme1737_zone_hyst_group, 2195549edb83SJuerg Haefliger S_IRUGO | S_IWUSR); 2196549edb83SJuerg Haefliger } 2197549edb83SJuerg Haefliger 219873ce48f6SJuerg Haefliger /* Change permissions of PWM sysfs attributes */ 219973ce48f6SJuerg Haefliger for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_chmod_group); ix++) { 2200ea694431SJuerg Haefliger if (data->has_features & HAS_PWM(ix)) { 2201b237eb25SJuerg Haefliger dme1737_chmod_group(dev, 220273ce48f6SJuerg Haefliger &dme1737_pwm_chmod_group[ix], 2203b237eb25SJuerg Haefliger S_IRUGO | S_IWUSR); 2204ea694431SJuerg Haefliger if ((data->has_features & HAS_PWM_MIN) && 2205ea694431SJuerg Haefliger ix < 3) { 2206549edb83SJuerg Haefliger dme1737_chmod_file(dev, 2207ea694431SJuerg Haefliger dme1737_auto_pwm_min_attr[ix], 2208549edb83SJuerg Haefliger S_IRUGO | S_IWUSR); 2209549edb83SJuerg Haefliger } 2210b237eb25SJuerg Haefliger } 2211b237eb25SJuerg Haefliger } 2212b237eb25SJuerg Haefliger 2213b237eb25SJuerg Haefliger /* Change permissions of pwm[1-3] if in manual mode */ 2214b237eb25SJuerg Haefliger for (ix = 0; ix < 3; ix++) { 2215ea694431SJuerg Haefliger if ((data->has_features & HAS_PWM(ix)) && 2216b237eb25SJuerg Haefliger (PWM_EN_FROM_REG(data->pwm_config[ix]) == 1)) { 2217b237eb25SJuerg Haefliger dme1737_chmod_file(dev, 221873ce48f6SJuerg Haefliger dme1737_pwm_chmod_attr[ix], 2219b237eb25SJuerg Haefliger S_IRUGO | S_IWUSR); 2220b237eb25SJuerg Haefliger } 2221b237eb25SJuerg Haefliger } 2222b237eb25SJuerg Haefliger } 2223b237eb25SJuerg Haefliger 2224b237eb25SJuerg Haefliger return 0; 2225b237eb25SJuerg Haefliger 2226b237eb25SJuerg Haefliger exit_remove: 2227b237eb25SJuerg Haefliger dme1737_remove_files(dev); 2228b237eb25SJuerg Haefliger exit: 2229b237eb25SJuerg Haefliger return err; 2230b237eb25SJuerg Haefliger } 2231b237eb25SJuerg Haefliger 2232b237eb25SJuerg Haefliger static int dme1737_init_device(struct device *dev) 2233b237eb25SJuerg Haefliger { 2234b237eb25SJuerg Haefliger struct dme1737_data *data = dev_get_drvdata(dev); 2235dbc2bc25SJean Delvare struct i2c_client *client = data->client; 22369431996fSJuerg Haefliger int ix; 22379431996fSJuerg Haefliger u8 reg; 22389431996fSJuerg Haefliger 2239549edb83SJuerg Haefliger /* Point to the right nominal voltages array */ 2240549edb83SJuerg Haefliger data->in_nominal = IN_NOMINAL(data->type); 2241549edb83SJuerg Haefliger 2242dbc2bc25SJean Delvare data->config = dme1737_read(data, DME1737_REG_CONFIG); 22439431996fSJuerg Haefliger /* Inform if part is not monitoring/started */ 22449431996fSJuerg Haefliger if (!(data->config & 0x01)) { 22459431996fSJuerg Haefliger if (!force_start) { 2246b55f3757SGuenter Roeck dev_err(dev, 2247b55f3757SGuenter Roeck "Device is not monitoring. Use the force_start load parameter to override.\n"); 22489431996fSJuerg Haefliger return -EFAULT; 22499431996fSJuerg Haefliger } 22509431996fSJuerg Haefliger 22519431996fSJuerg Haefliger /* Force monitoring */ 22529431996fSJuerg Haefliger data->config |= 0x01; 2253dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_CONFIG, data->config); 22549431996fSJuerg Haefliger } 22559431996fSJuerg Haefliger /* Inform if part is not ready */ 22569431996fSJuerg Haefliger if (!(data->config & 0x04)) { 2257b237eb25SJuerg Haefliger dev_err(dev, "Device is not ready.\n"); 22589431996fSJuerg Haefliger return -EFAULT; 22599431996fSJuerg Haefliger } 22609431996fSJuerg Haefliger 2261c8de8362SGuenter Roeck /* 2262c8de8362SGuenter Roeck * Determine which optional fan and pwm features are enabled (only 2263c8de8362SGuenter Roeck * valid for I2C devices) 2264c8de8362SGuenter Roeck */ 2265dbc2bc25SJean Delvare if (client) { /* I2C chip */ 2266dbc2bc25SJean Delvare data->config2 = dme1737_read(data, DME1737_REG_CONFIG2); 22679431996fSJuerg Haefliger /* Check if optional fan3 input is enabled */ 2268c8de8362SGuenter Roeck if (data->config2 & 0x04) 2269ea694431SJuerg Haefliger data->has_features |= HAS_FAN(2); 22709431996fSJuerg Haefliger 2271c8de8362SGuenter Roeck /* 2272c8de8362SGuenter Roeck * Fan4 and pwm3 are only available if the client's I2C address 2273e95c237dSJuerg Haefliger * is the default 0x2e. Otherwise the I/Os associated with 2274c8de8362SGuenter Roeck * these functions are used for addr enable/select. 2275c8de8362SGuenter Roeck */ 2276c8de8362SGuenter Roeck if (client->addr == 0x2e) 2277ea694431SJuerg Haefliger data->has_features |= HAS_FAN(3) | HAS_PWM(2); 22789431996fSJuerg Haefliger 2279c8de8362SGuenter Roeck /* 2280c8de8362SGuenter Roeck * Determine which of the optional fan[5-6] and pwm[5-6] 2281e95c237dSJuerg Haefliger * features are enabled. For this, we need to query the runtime 2282e95c237dSJuerg Haefliger * registers through the Super-IO LPC interface. Try both 2283c8de8362SGuenter Roeck * config ports 0x2e and 0x4e. 2284c8de8362SGuenter Roeck */ 2285b237eb25SJuerg Haefliger if (dme1737_i2c_get_features(0x2e, data) && 2286b237eb25SJuerg Haefliger dme1737_i2c_get_features(0x4e, data)) { 2287b55f3757SGuenter Roeck dev_warn(dev, 2288b55f3757SGuenter Roeck "Failed to query Super-IO for optional features.\n"); 22899431996fSJuerg Haefliger } 2290e95c237dSJuerg Haefliger } 22919431996fSJuerg Haefliger 2292ea694431SJuerg Haefliger /* Fan[1-2] and pwm[1-2] are present in all chips */ 2293ea694431SJuerg Haefliger data->has_features |= HAS_FAN(0) | HAS_FAN(1) | HAS_PWM(0) | HAS_PWM(1); 2294ea694431SJuerg Haefliger 2295ea694431SJuerg Haefliger /* Chip-dependent features */ 2296ea694431SJuerg Haefliger switch (data->type) { 2297ea694431SJuerg Haefliger case dme1737: 2298ea694431SJuerg Haefliger data->has_features |= HAS_TEMP_OFFSET | HAS_VID | HAS_ZONE3 | 2299ea694431SJuerg Haefliger HAS_ZONE_HYST | HAS_PWM_MIN; 2300ea694431SJuerg Haefliger break; 2301ea694431SJuerg Haefliger case sch311x: 2302ea694431SJuerg Haefliger data->has_features |= HAS_TEMP_OFFSET | HAS_ZONE3 | 2303ea694431SJuerg Haefliger HAS_ZONE_HYST | HAS_PWM_MIN | HAS_FAN(2) | HAS_PWM(2); 2304ea694431SJuerg Haefliger break; 2305ea694431SJuerg Haefliger case sch5027: 2306ea694431SJuerg Haefliger data->has_features |= HAS_ZONE3; 2307ea694431SJuerg Haefliger break; 2308ea694431SJuerg Haefliger case sch5127: 2309d4b94e1fSJuerg Haefliger data->has_features |= HAS_FAN(2) | HAS_PWM(2) | HAS_IN7; 2310ea694431SJuerg Haefliger break; 2311ea694431SJuerg Haefliger default: 2312ea694431SJuerg Haefliger break; 2313ea694431SJuerg Haefliger } 23149431996fSJuerg Haefliger 2315b55f3757SGuenter Roeck dev_info(dev, 2316b55f3757SGuenter Roeck "Optional features: pwm3=%s, pwm5=%s, pwm6=%s, fan3=%s, fan4=%s, fan5=%s, fan6=%s.\n", 2317ea694431SJuerg Haefliger (data->has_features & HAS_PWM(2)) ? "yes" : "no", 2318ea694431SJuerg Haefliger (data->has_features & HAS_PWM(4)) ? "yes" : "no", 2319ea694431SJuerg Haefliger (data->has_features & HAS_PWM(5)) ? "yes" : "no", 2320ea694431SJuerg Haefliger (data->has_features & HAS_FAN(2)) ? "yes" : "no", 2321ea694431SJuerg Haefliger (data->has_features & HAS_FAN(3)) ? "yes" : "no", 2322ea694431SJuerg Haefliger (data->has_features & HAS_FAN(4)) ? "yes" : "no", 2323ea694431SJuerg Haefliger (data->has_features & HAS_FAN(5)) ? "yes" : "no"); 23249431996fSJuerg Haefliger 2325dbc2bc25SJean Delvare reg = dme1737_read(data, DME1737_REG_TACH_PWM); 23269431996fSJuerg Haefliger /* Inform if fan-to-pwm mapping differs from the default */ 2327dbc2bc25SJean Delvare if (client && reg != 0xa4) { /* I2C chip */ 2328b55f3757SGuenter Roeck dev_warn(dev, 2329b55f3757SGuenter Roeck "Non-standard fan to pwm mapping: fan1->pwm%d, fan2->pwm%d, fan3->pwm%d, fan4->pwm%d. %s\n", 23309431996fSJuerg Haefliger (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1, 2331b55f3757SGuenter Roeck ((reg >> 4) & 0x03) + 1, ((reg >> 6) & 0x03) + 1, 2332b55f3757SGuenter Roeck DO_REPORT); 2333dbc2bc25SJean Delvare } else if (!client && reg != 0x24) { /* ISA chip */ 2334b55f3757SGuenter Roeck dev_warn(dev, 2335b55f3757SGuenter Roeck "Non-standard fan to pwm mapping: fan1->pwm%d, fan2->pwm%d, fan3->pwm%d. %s\n", 2336e95c237dSJuerg Haefliger (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1, 2337b55f3757SGuenter Roeck ((reg >> 4) & 0x03) + 1, DO_REPORT); 23389431996fSJuerg Haefliger } 23399431996fSJuerg Haefliger 2340c8de8362SGuenter Roeck /* 2341c8de8362SGuenter Roeck * Switch pwm[1-3] to manual mode if they are currently disabled and 23429431996fSJuerg Haefliger * set the duty-cycles to 0% (which is identical to the PWMs being 2343c8de8362SGuenter Roeck * disabled). 2344c8de8362SGuenter Roeck */ 23459431996fSJuerg Haefliger if (!(data->config & 0x02)) { 23469431996fSJuerg Haefliger for (ix = 0; ix < 3; ix++) { 2347dbc2bc25SJean Delvare data->pwm_config[ix] = dme1737_read(data, 23489431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix)); 2349ea694431SJuerg Haefliger if ((data->has_features & HAS_PWM(ix)) && 23509431996fSJuerg Haefliger (PWM_EN_FROM_REG(data->pwm_config[ix]) == -1)) { 2351b55f3757SGuenter Roeck dev_info(dev, 2352b55f3757SGuenter Roeck "Switching pwm%d to manual mode.\n", 2353b55f3757SGuenter Roeck ix + 1); 23549431996fSJuerg Haefliger data->pwm_config[ix] = PWM_EN_TO_REG(1, 23559431996fSJuerg Haefliger data->pwm_config[ix]); 2356dbc2bc25SJean Delvare dme1737_write(data, DME1737_REG_PWM(ix), 0); 2357dbc2bc25SJean Delvare dme1737_write(data, 23589431996fSJuerg Haefliger DME1737_REG_PWM_CONFIG(ix), 23599431996fSJuerg Haefliger data->pwm_config[ix]); 23609431996fSJuerg Haefliger } 23619431996fSJuerg Haefliger } 23629431996fSJuerg Haefliger } 23639431996fSJuerg Haefliger 23649431996fSJuerg Haefliger /* Initialize the default PWM auto channels zone (acz) assignments */ 23659431996fSJuerg Haefliger data->pwm_acz[0] = 1; /* pwm1 -> zone1 */ 23669431996fSJuerg Haefliger data->pwm_acz[1] = 2; /* pwm2 -> zone2 */ 23679431996fSJuerg Haefliger data->pwm_acz[2] = 4; /* pwm3 -> zone3 */ 23689431996fSJuerg Haefliger 23699431996fSJuerg Haefliger /* Set VRM */ 2370c8de8362SGuenter Roeck if (data->has_features & HAS_VID) 23719431996fSJuerg Haefliger data->vrm = vid_which_vrm(); 23729431996fSJuerg Haefliger 23739431996fSJuerg Haefliger return 0; 23749431996fSJuerg Haefliger } 23759431996fSJuerg Haefliger 237667e2f328SJuerg Haefliger /* --------------------------------------------------------------------- 237767e2f328SJuerg Haefliger * I2C device detection and registration 237867e2f328SJuerg Haefliger * --------------------------------------------------------------------- */ 237967e2f328SJuerg Haefliger 238067e2f328SJuerg Haefliger static struct i2c_driver dme1737_i2c_driver; 238167e2f328SJuerg Haefliger 238267e2f328SJuerg Haefliger static int dme1737_i2c_get_features(int sio_cip, struct dme1737_data *data) 238367e2f328SJuerg Haefliger { 23849431996fSJuerg Haefliger int err = 0, reg; 23859431996fSJuerg Haefliger u16 addr; 23869431996fSJuerg Haefliger 238767e2f328SJuerg Haefliger dme1737_sio_enter(sio_cip); 23889431996fSJuerg Haefliger 2389c8de8362SGuenter Roeck /* 2390c8de8362SGuenter Roeck * Check device ID 2391c8de8362SGuenter Roeck * We currently know about two kinds of DME1737 and SCH5027. 2392c8de8362SGuenter Roeck */ 2393345a2224SJuerg Haefliger reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20); 2394ea694431SJuerg Haefliger if (!(reg == DME1737_ID_1 || reg == DME1737_ID_2 || 2395ea694431SJuerg Haefliger reg == SCH5027_ID)) { 23969431996fSJuerg Haefliger err = -ENODEV; 23979431996fSJuerg Haefliger goto exit; 23989431996fSJuerg Haefliger } 23999431996fSJuerg Haefliger 24009431996fSJuerg Haefliger /* Select logical device A (runtime registers) */ 24019431996fSJuerg Haefliger dme1737_sio_outb(sio_cip, 0x07, 0x0a); 24029431996fSJuerg Haefliger 24039431996fSJuerg Haefliger /* Get the base address of the runtime registers */ 240406f3d9fbSJuerg Haefliger addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) | 240506f3d9fbSJuerg Haefliger dme1737_sio_inb(sio_cip, 0x61); 240606f3d9fbSJuerg Haefliger if (!addr) { 24079431996fSJuerg Haefliger err = -ENODEV; 24089431996fSJuerg Haefliger goto exit; 24099431996fSJuerg Haefliger } 24109431996fSJuerg Haefliger 2411c8de8362SGuenter Roeck /* 2412c8de8362SGuenter Roeck * Read the runtime registers to determine which optional features 24139431996fSJuerg Haefliger * are enabled and available. Bits [3:2] of registers 0x43-0x46 are set 2414c8de8362SGuenter Roeck * to '10' if the respective feature is enabled. 2415c8de8362SGuenter Roeck */ 2416c8de8362SGuenter Roeck if ((inb(addr + 0x43) & 0x0c) == 0x08) /* fan6 */ 2417ea694431SJuerg Haefliger data->has_features |= HAS_FAN(5); 2418c8de8362SGuenter Roeck if ((inb(addr + 0x44) & 0x0c) == 0x08) /* pwm6 */ 2419ea694431SJuerg Haefliger data->has_features |= HAS_PWM(5); 2420c8de8362SGuenter Roeck if ((inb(addr + 0x45) & 0x0c) == 0x08) /* fan5 */ 2421ea694431SJuerg Haefliger data->has_features |= HAS_FAN(4); 2422c8de8362SGuenter Roeck if ((inb(addr + 0x46) & 0x0c) == 0x08) /* pwm5 */ 2423ea694431SJuerg Haefliger data->has_features |= HAS_PWM(4); 24249431996fSJuerg Haefliger 24259431996fSJuerg Haefliger exit: 242667e2f328SJuerg Haefliger dme1737_sio_exit(sio_cip); 24279431996fSJuerg Haefliger 24289431996fSJuerg Haefliger return err; 24299431996fSJuerg Haefliger } 24309431996fSJuerg Haefliger 243167a37308SJean Delvare /* Return 0 if detection is successful, -ENODEV otherwise */ 2432310ec792SJean Delvare static int dme1737_i2c_detect(struct i2c_client *client, 243367a37308SJean Delvare struct i2c_board_info *info) 24349431996fSJuerg Haefliger { 243567a37308SJean Delvare struct i2c_adapter *adapter = client->adapter; 243667a37308SJean Delvare struct device *dev = &adapter->dev; 24379431996fSJuerg Haefliger u8 company, verstep = 0; 24389431996fSJuerg Haefliger const char *name; 24399431996fSJuerg Haefliger 2440c8de8362SGuenter Roeck if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 244167a37308SJean Delvare return -ENODEV; 24429431996fSJuerg Haefliger 244367a37308SJean Delvare company = i2c_smbus_read_byte_data(client, DME1737_REG_COMPANY); 244467a37308SJean Delvare verstep = i2c_smbus_read_byte_data(client, DME1737_REG_VERSTEP); 24459431996fSJuerg Haefliger 2446549edb83SJuerg Haefliger if (company == DME1737_COMPANY_SMSC && 2447549edb83SJuerg Haefliger verstep == SCH5027_VERSTEP) { 244852df6440SJean Delvare name = "sch5027"; 244952df6440SJean Delvare } else if (company == DME1737_COMPANY_SMSC && 245052df6440SJean Delvare (verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP) { 245152df6440SJean Delvare name = "dme1737"; 2452549edb83SJuerg Haefliger } else { 245367a37308SJean Delvare return -ENODEV; 24549431996fSJuerg Haefliger } 24559431996fSJuerg Haefliger 2456549edb83SJuerg Haefliger dev_info(dev, "Found a %s chip at 0x%02x (rev 0x%02x).\n", 245752df6440SJean Delvare verstep == SCH5027_VERSTEP ? "SCH5027" : "DME1737", 245852df6440SJean Delvare client->addr, verstep); 2459f2f394dbSWolfram Sang strscpy(info->type, name, I2C_NAME_SIZE); 246067a37308SJean Delvare 246167a37308SJean Delvare return 0; 246267a37308SJean Delvare } 246367a37308SJean Delvare 24644e1b4d22SStephen Kitt static int dme1737_i2c_probe(struct i2c_client *client) 246567a37308SJean Delvare { 246667a37308SJean Delvare struct dme1737_data *data; 246767a37308SJean Delvare struct device *dev = &client->dev; 246867a37308SJean Delvare int err; 246967a37308SJean Delvare 2470805fd8c5SGuenter Roeck data = devm_kzalloc(dev, sizeof(struct dme1737_data), GFP_KERNEL); 2471805fd8c5SGuenter Roeck if (!data) 2472805fd8c5SGuenter Roeck return -ENOMEM; 247367a37308SJean Delvare 247467a37308SJean Delvare i2c_set_clientdata(client, data); 2475*9072777dSAndrew Davis data->type = (uintptr_t)i2c_get_match_data(client); 247667a37308SJean Delvare data->client = client; 247767a37308SJean Delvare data->name = client->name; 247867a37308SJean Delvare mutex_init(&data->update_lock); 2479b237eb25SJuerg Haefliger 24809431996fSJuerg Haefliger /* Initialize the DME1737 chip */ 248106f3d9fbSJuerg Haefliger err = dme1737_init_device(dev); 248206f3d9fbSJuerg Haefliger if (err) { 2483b237eb25SJuerg Haefliger dev_err(dev, "Failed to initialize device.\n"); 2484805fd8c5SGuenter Roeck return err; 24859431996fSJuerg Haefliger } 24869431996fSJuerg Haefliger 2487b237eb25SJuerg Haefliger /* Create sysfs files */ 248806f3d9fbSJuerg Haefliger err = dme1737_create_files(dev); 248906f3d9fbSJuerg Haefliger if (err) { 2490b237eb25SJuerg Haefliger dev_err(dev, "Failed to create sysfs files.\n"); 2491805fd8c5SGuenter Roeck return err; 24929431996fSJuerg Haefliger } 24939431996fSJuerg Haefliger 24949431996fSJuerg Haefliger /* Register device */ 249562ee3e10SMark M. Hoffman data->hwmon_dev = hwmon_device_register(dev); 24961beeffe4STony Jones if (IS_ERR(data->hwmon_dev)) { 2497b237eb25SJuerg Haefliger dev_err(dev, "Failed to register device.\n"); 24981beeffe4STony Jones err = PTR_ERR(data->hwmon_dev); 24999431996fSJuerg Haefliger goto exit_remove; 25009431996fSJuerg Haefliger } 25019431996fSJuerg Haefliger 25029431996fSJuerg Haefliger return 0; 25039431996fSJuerg Haefliger 25049431996fSJuerg Haefliger exit_remove: 2505b237eb25SJuerg Haefliger dme1737_remove_files(dev); 25069431996fSJuerg Haefliger return err; 25079431996fSJuerg Haefliger } 25089431996fSJuerg Haefliger 2509ed5c2f5fSUwe Kleine-König static void dme1737_i2c_remove(struct i2c_client *client) 25109431996fSJuerg Haefliger { 25119431996fSJuerg Haefliger struct dme1737_data *data = i2c_get_clientdata(client); 25129431996fSJuerg Haefliger 25131beeffe4STony Jones hwmon_device_unregister(data->hwmon_dev); 2514b237eb25SJuerg Haefliger dme1737_remove_files(&client->dev); 25159431996fSJuerg Haefliger } 25169431996fSJuerg Haefliger 251767a37308SJean Delvare static const struct i2c_device_id dme1737_id[] = { 251867a37308SJean Delvare { "dme1737", dme1737 }, 251967a37308SJean Delvare { "sch5027", sch5027 }, 252067a37308SJean Delvare { } 252167a37308SJean Delvare }; 252267a37308SJean Delvare MODULE_DEVICE_TABLE(i2c, dme1737_id); 252367a37308SJean Delvare 2524b237eb25SJuerg Haefliger static struct i2c_driver dme1737_i2c_driver = { 252567a37308SJean Delvare .class = I2C_CLASS_HWMON, 25269431996fSJuerg Haefliger .driver = { 25279431996fSJuerg Haefliger .name = "dme1737", 25289431996fSJuerg Haefliger }, 25291975d167SUwe Kleine-König .probe = dme1737_i2c_probe, 253067a37308SJean Delvare .remove = dme1737_i2c_remove, 253167a37308SJean Delvare .id_table = dme1737_id, 253267a37308SJean Delvare .detect = dme1737_i2c_detect, 2533c3813d6aSJean Delvare .address_list = normal_i2c, 25349431996fSJuerg Haefliger }; 25359431996fSJuerg Haefliger 253667e2f328SJuerg Haefliger /* --------------------------------------------------------------------- 2537e95c237dSJuerg Haefliger * ISA device detection and registration 2538e95c237dSJuerg Haefliger * --------------------------------------------------------------------- */ 2539e95c237dSJuerg Haefliger 2540e95c237dSJuerg Haefliger static int __init dme1737_isa_detect(int sio_cip, unsigned short *addr) 2541e95c237dSJuerg Haefliger { 2542e95c237dSJuerg Haefliger int err = 0, reg; 2543e95c237dSJuerg Haefliger unsigned short base_addr; 2544e95c237dSJuerg Haefliger 2545e95c237dSJuerg Haefliger dme1737_sio_enter(sio_cip); 2546e95c237dSJuerg Haefliger 2547c8de8362SGuenter Roeck /* 2548c8de8362SGuenter Roeck * Check device ID 2549c8de8362SGuenter Roeck * We currently know about SCH3112, SCH3114, SCH3116, and SCH5127 2550c8de8362SGuenter Roeck */ 255167b671bcSJean Delvare reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20); 2552ea694431SJuerg Haefliger if (!(reg == SCH3112_ID || reg == SCH3114_ID || reg == SCH3116_ID || 2553ea694431SJuerg Haefliger reg == SCH5127_ID)) { 2554e95c237dSJuerg Haefliger err = -ENODEV; 2555e95c237dSJuerg Haefliger goto exit; 2556e95c237dSJuerg Haefliger } 2557e95c237dSJuerg Haefliger 2558e95c237dSJuerg Haefliger /* Select logical device A (runtime registers) */ 2559e95c237dSJuerg Haefliger dme1737_sio_outb(sio_cip, 0x07, 0x0a); 2560e95c237dSJuerg Haefliger 2561e95c237dSJuerg Haefliger /* Get the base address of the runtime registers */ 256206f3d9fbSJuerg Haefliger base_addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) | 256306f3d9fbSJuerg Haefliger dme1737_sio_inb(sio_cip, 0x61); 256406f3d9fbSJuerg Haefliger if (!base_addr) { 25659c6e13b4SJoe Perches pr_err("Base address not set\n"); 2566e95c237dSJuerg Haefliger err = -ENODEV; 2567e95c237dSJuerg Haefliger goto exit; 2568e95c237dSJuerg Haefliger } 2569e95c237dSJuerg Haefliger 2570c8de8362SGuenter Roeck /* 2571c8de8362SGuenter Roeck * Access to the hwmon registers is through an index/data register 2572c8de8362SGuenter Roeck * pair located at offset 0x70/0x71. 2573c8de8362SGuenter Roeck */ 2574e95c237dSJuerg Haefliger *addr = base_addr + 0x70; 2575e95c237dSJuerg Haefliger 2576e95c237dSJuerg Haefliger exit: 2577e95c237dSJuerg Haefliger dme1737_sio_exit(sio_cip); 2578e95c237dSJuerg Haefliger return err; 2579e95c237dSJuerg Haefliger } 2580e95c237dSJuerg Haefliger 2581e95c237dSJuerg Haefliger static int __init dme1737_isa_device_add(unsigned short addr) 2582e95c237dSJuerg Haefliger { 2583e95c237dSJuerg Haefliger struct resource res = { 2584e95c237dSJuerg Haefliger .start = addr, 2585e95c237dSJuerg Haefliger .end = addr + DME1737_EXTENT - 1, 2586e95c237dSJuerg Haefliger .name = "dme1737", 2587e95c237dSJuerg Haefliger .flags = IORESOURCE_IO, 2588e95c237dSJuerg Haefliger }; 2589e95c237dSJuerg Haefliger int err; 2590e95c237dSJuerg Haefliger 2591b9acb64aSJean Delvare err = acpi_check_resource_conflict(&res); 2592b9acb64aSJean Delvare if (err) 2593b9acb64aSJean Delvare goto exit; 2594b9acb64aSJean Delvare 259506f3d9fbSJuerg Haefliger pdev = platform_device_alloc("dme1737", addr); 259606f3d9fbSJuerg Haefliger if (!pdev) { 25979c6e13b4SJoe Perches pr_err("Failed to allocate device\n"); 2598e95c237dSJuerg Haefliger err = -ENOMEM; 2599e95c237dSJuerg Haefliger goto exit; 2600e95c237dSJuerg Haefliger } 2601e95c237dSJuerg Haefliger 260206f3d9fbSJuerg Haefliger err = platform_device_add_resources(pdev, &res, 1); 260306f3d9fbSJuerg Haefliger if (err) { 26049c6e13b4SJoe Perches pr_err("Failed to add device resource (err = %d)\n", err); 2605e95c237dSJuerg Haefliger goto exit_device_put; 2606e95c237dSJuerg Haefliger } 2607e95c237dSJuerg Haefliger 260806f3d9fbSJuerg Haefliger err = platform_device_add(pdev); 260906f3d9fbSJuerg Haefliger if (err) { 26109c6e13b4SJoe Perches pr_err("Failed to add device (err = %d)\n", err); 2611e95c237dSJuerg Haefliger goto exit_device_put; 2612e95c237dSJuerg Haefliger } 2613e95c237dSJuerg Haefliger 2614e95c237dSJuerg Haefliger return 0; 2615e95c237dSJuerg Haefliger 2616e95c237dSJuerg Haefliger exit_device_put: 2617e95c237dSJuerg Haefliger platform_device_put(pdev); 2618e95c237dSJuerg Haefliger pdev = NULL; 2619e95c237dSJuerg Haefliger exit: 2620e95c237dSJuerg Haefliger return err; 2621e95c237dSJuerg Haefliger } 2622e95c237dSJuerg Haefliger 26236c931ae1SBill Pemberton static int dme1737_isa_probe(struct platform_device *pdev) 2624e95c237dSJuerg Haefliger { 2625e95c237dSJuerg Haefliger u8 company, device; 2626e95c237dSJuerg Haefliger struct resource *res; 2627e95c237dSJuerg Haefliger struct dme1737_data *data; 2628e95c237dSJuerg Haefliger struct device *dev = &pdev->dev; 2629e95c237dSJuerg Haefliger int err; 2630e95c237dSJuerg Haefliger 2631e95c237dSJuerg Haefliger res = platform_get_resource(pdev, IORESOURCE_IO, 0); 2632805fd8c5SGuenter Roeck if (!devm_request_region(dev, res->start, DME1737_EXTENT, "dme1737")) { 2633e95c237dSJuerg Haefliger dev_err(dev, "Failed to request region 0x%04x-0x%04x.\n", 2634e95c237dSJuerg Haefliger (unsigned short)res->start, 2635e95c237dSJuerg Haefliger (unsigned short)res->start + DME1737_EXTENT - 1); 2636805fd8c5SGuenter Roeck return -EBUSY; 2637e95c237dSJuerg Haefliger } 2638e95c237dSJuerg Haefliger 2639805fd8c5SGuenter Roeck data = devm_kzalloc(dev, sizeof(struct dme1737_data), GFP_KERNEL); 2640805fd8c5SGuenter Roeck if (!data) 2641805fd8c5SGuenter Roeck return -ENOMEM; 2642e95c237dSJuerg Haefliger 2643dbc2bc25SJean Delvare data->addr = res->start; 2644e95c237dSJuerg Haefliger platform_set_drvdata(pdev, data); 2645e95c237dSJuerg Haefliger 264655d68d75SJuerg Haefliger /* Skip chip detection if module is loaded with force_id parameter */ 2647ea694431SJuerg Haefliger switch (force_id) { 2648ea694431SJuerg Haefliger case SCH3112_ID: 2649ea694431SJuerg Haefliger case SCH3114_ID: 2650ea694431SJuerg Haefliger case SCH3116_ID: 2651ea694431SJuerg Haefliger data->type = sch311x; 2652ea694431SJuerg Haefliger break; 2653ea694431SJuerg Haefliger case SCH5127_ID: 2654ea694431SJuerg Haefliger data->type = sch5127; 2655ea694431SJuerg Haefliger break; 2656ea694431SJuerg Haefliger default: 2657dbc2bc25SJean Delvare company = dme1737_read(data, DME1737_REG_COMPANY); 2658dbc2bc25SJean Delvare device = dme1737_read(data, DME1737_REG_DEVICE); 2659e95c237dSJuerg Haefliger 2660ea694431SJuerg Haefliger if ((company == DME1737_COMPANY_SMSC) && 2661ea694431SJuerg Haefliger (device == SCH311X_DEVICE)) { 2662ea694431SJuerg Haefliger data->type = sch311x; 2663ea694431SJuerg Haefliger } else if ((company == DME1737_COMPANY_SMSC) && 2664ea694431SJuerg Haefliger (device == SCH5127_DEVICE)) { 2665ea694431SJuerg Haefliger data->type = sch5127; 2666ea694431SJuerg Haefliger } else { 2667805fd8c5SGuenter Roeck return -ENODEV; 2668e95c237dSJuerg Haefliger } 266955d68d75SJuerg Haefliger } 2670e95c237dSJuerg Haefliger 2671c8de8362SGuenter Roeck if (data->type == sch5127) 2672ea694431SJuerg Haefliger data->name = "sch5127"; 2673c8de8362SGuenter Roeck else 2674dbc2bc25SJean Delvare data->name = "sch311x"; 2675ea694431SJuerg Haefliger 2676ea694431SJuerg Haefliger /* Initialize the mutex */ 2677e95c237dSJuerg Haefliger mutex_init(&data->update_lock); 2678e95c237dSJuerg Haefliger 2679ea694431SJuerg Haefliger dev_info(dev, "Found a %s chip at 0x%04x\n", 2680ea694431SJuerg Haefliger data->type == sch5127 ? "SCH5127" : "SCH311x", data->addr); 2681e95c237dSJuerg Haefliger 2682e95c237dSJuerg Haefliger /* Initialize the chip */ 268306f3d9fbSJuerg Haefliger err = dme1737_init_device(dev); 268406f3d9fbSJuerg Haefliger if (err) { 2685e95c237dSJuerg Haefliger dev_err(dev, "Failed to initialize device.\n"); 2686805fd8c5SGuenter Roeck return err; 2687e95c237dSJuerg Haefliger } 2688e95c237dSJuerg Haefliger 2689e95c237dSJuerg Haefliger /* Create sysfs files */ 269006f3d9fbSJuerg Haefliger err = dme1737_create_files(dev); 269106f3d9fbSJuerg Haefliger if (err) { 2692e95c237dSJuerg Haefliger dev_err(dev, "Failed to create sysfs files.\n"); 2693805fd8c5SGuenter Roeck return err; 2694e95c237dSJuerg Haefliger } 2695e95c237dSJuerg Haefliger 2696e95c237dSJuerg Haefliger /* Register device */ 2697e95c237dSJuerg Haefliger data->hwmon_dev = hwmon_device_register(dev); 2698e95c237dSJuerg Haefliger if (IS_ERR(data->hwmon_dev)) { 2699e95c237dSJuerg Haefliger dev_err(dev, "Failed to register device.\n"); 2700e95c237dSJuerg Haefliger err = PTR_ERR(data->hwmon_dev); 2701e95c237dSJuerg Haefliger goto exit_remove_files; 2702e95c237dSJuerg Haefliger } 2703e95c237dSJuerg Haefliger 2704e95c237dSJuerg Haefliger return 0; 2705e95c237dSJuerg Haefliger 2706e95c237dSJuerg Haefliger exit_remove_files: 2707e95c237dSJuerg Haefliger dme1737_remove_files(dev); 2708e95c237dSJuerg Haefliger return err; 2709e95c237dSJuerg Haefliger } 2710e95c237dSJuerg Haefliger 271163d35e96SUwe Kleine-König static void dme1737_isa_remove(struct platform_device *pdev) 2712e95c237dSJuerg Haefliger { 2713e95c237dSJuerg Haefliger struct dme1737_data *data = platform_get_drvdata(pdev); 2714e95c237dSJuerg Haefliger 2715e95c237dSJuerg Haefliger hwmon_device_unregister(data->hwmon_dev); 2716e95c237dSJuerg Haefliger dme1737_remove_files(&pdev->dev); 2717e95c237dSJuerg Haefliger } 2718e95c237dSJuerg Haefliger 2719e95c237dSJuerg Haefliger static struct platform_driver dme1737_isa_driver = { 2720e95c237dSJuerg Haefliger .driver = { 2721e95c237dSJuerg Haefliger .name = "dme1737", 2722e95c237dSJuerg Haefliger }, 2723e95c237dSJuerg Haefliger .probe = dme1737_isa_probe, 272463d35e96SUwe Kleine-König .remove_new = dme1737_isa_remove, 2725e95c237dSJuerg Haefliger }; 2726e95c237dSJuerg Haefliger 2727e95c237dSJuerg Haefliger /* --------------------------------------------------------------------- 272867e2f328SJuerg Haefliger * Module initialization and cleanup 272967e2f328SJuerg Haefliger * --------------------------------------------------------------------- */ 273067e2f328SJuerg Haefliger 27319431996fSJuerg Haefliger static int __init dme1737_init(void) 27329431996fSJuerg Haefliger { 2733e95c237dSJuerg Haefliger int err; 2734e95c237dSJuerg Haefliger unsigned short addr; 2735e95c237dSJuerg Haefliger 273606f3d9fbSJuerg Haefliger err = i2c_add_driver(&dme1737_i2c_driver); 2737c8de8362SGuenter Roeck if (err) 2738e95c237dSJuerg Haefliger goto exit; 2739e95c237dSJuerg Haefliger 2740e95c237dSJuerg Haefliger if (dme1737_isa_detect(0x2e, &addr) && 274192430b6fSJuerg Haefliger dme1737_isa_detect(0x4e, &addr) && 274292430b6fSJuerg Haefliger (!probe_all_addr || 274392430b6fSJuerg Haefliger (dme1737_isa_detect(0x162e, &addr) && 274492430b6fSJuerg Haefliger dme1737_isa_detect(0x164e, &addr)))) { 2745e95c237dSJuerg Haefliger /* Return 0 if we didn't find an ISA device */ 2746e95c237dSJuerg Haefliger return 0; 2747e95c237dSJuerg Haefliger } 2748e95c237dSJuerg Haefliger 274906f3d9fbSJuerg Haefliger err = platform_driver_register(&dme1737_isa_driver); 2750c8de8362SGuenter Roeck if (err) 2751e95c237dSJuerg Haefliger goto exit_del_i2c_driver; 2752e95c237dSJuerg Haefliger 2753e95c237dSJuerg Haefliger /* Sets global pdev as a side effect */ 275406f3d9fbSJuerg Haefliger err = dme1737_isa_device_add(addr); 2755c8de8362SGuenter Roeck if (err) 2756e95c237dSJuerg Haefliger goto exit_del_isa_driver; 2757e95c237dSJuerg Haefliger 2758e95c237dSJuerg Haefliger return 0; 2759e95c237dSJuerg Haefliger 2760e95c237dSJuerg Haefliger exit_del_isa_driver: 2761e95c237dSJuerg Haefliger platform_driver_unregister(&dme1737_isa_driver); 2762e95c237dSJuerg Haefliger exit_del_i2c_driver: 2763e95c237dSJuerg Haefliger i2c_del_driver(&dme1737_i2c_driver); 2764e95c237dSJuerg Haefliger exit: 2765e95c237dSJuerg Haefliger return err; 27669431996fSJuerg Haefliger } 27679431996fSJuerg Haefliger 27689431996fSJuerg Haefliger static void __exit dme1737_exit(void) 27699431996fSJuerg Haefliger { 2770e95c237dSJuerg Haefliger if (pdev) { 2771e95c237dSJuerg Haefliger platform_device_unregister(pdev); 2772e95c237dSJuerg Haefliger platform_driver_unregister(&dme1737_isa_driver); 2773e95c237dSJuerg Haefliger } 2774e95c237dSJuerg Haefliger 2775b237eb25SJuerg Haefliger i2c_del_driver(&dme1737_i2c_driver); 27769431996fSJuerg Haefliger } 27779431996fSJuerg Haefliger 27789431996fSJuerg Haefliger MODULE_AUTHOR("Juerg Haefliger <juergh@gmail.com>"); 27799431996fSJuerg Haefliger MODULE_DESCRIPTION("DME1737 sensors"); 27809431996fSJuerg Haefliger MODULE_LICENSE("GPL"); 27819431996fSJuerg Haefliger 27829431996fSJuerg Haefliger module_init(dme1737_init); 27839431996fSJuerg Haefliger module_exit(dme1737_exit); 2784