Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 1c720093f635af490e103c79c056e7408aee6618

Authored by Guenter Roeck
Committed by Jean Delvare
1 parent 16b5dda22e
Exists in master and in 6 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

hwmon: (adm1031) Fix coding style issues 

Fix almost all coding style issues except for the multi-line macro errors,
which do not really apply since the macros are not multi-line statements
but declarations.

Based on merged patch series from Zac Storer; fixed remaining checkpatch
errors and warnings.

Cc: Zac Storer <zac.3.14159@gmail.com>
Signed-off-by: Guenter Roeck <guenter.roeck@ericsson.com>
Signed-off-by: Jean Delvare <khali@linux-fr.org>

Showing 1 changed file with 103 additions and 50 deletions Inline Diff

drivers/hwmon/adm1031.c
Diff comments   View file @ 1c72009
1 /* 1 /*
2 adm1031.c - Part of lm_sensors, Linux kernel modules for hardware 2 adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring 3 monitoring
4 Based on lm75.c and lm85.c 4 Based on lm75.c and lm85.c
5 Supports adm1030 / adm1031 5 Supports adm1030 / adm1031
6 Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org> 6 Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org>
7 Reworked by Jean Delvare <khali@linux-fr.org> 7 Reworked by Jean Delvare <khali@linux-fr.org>
8 8
9 This program is free software; you can redistribute it and/or modify 9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by 10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or 11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version. 12 (at your option) any later version.
13 13
14 This program is distributed in the hope that it will be useful, 14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details. 17 GNU General Public License for more details.
18 18
19 You should have received a copy of the GNU General Public License 19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software 20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */ 22 */
23 23
24 #include <linux/module.h> 24 #include <linux/module.h>
25 #include <linux/init.h> 25 #include <linux/init.h>
26 #include <linux/slab.h> 26 #include <linux/slab.h>
27 #include <linux/jiffies.h> 27 #include <linux/jiffies.h>
28 #include <linux/i2c.h> 28 #include <linux/i2c.h>
29 #include <linux/hwmon.h> 29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h> 30 #include <linux/hwmon-sysfs.h>
31 #include <linux/err.h> 31 #include <linux/err.h>
32 #include <linux/mutex.h> 32 #include <linux/mutex.h>
33 33
34 /* Following macros takes channel parameter starting from 0 to 2 */ 34 /* Following macros takes channel parameter starting from 0 to 2 */
35 #define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr)) 35 #define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr))
36 #define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr)) 36 #define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr))
37 #define ADM1031_REG_PWM (0x22) 37 #define ADM1031_REG_PWM (0x22)
38 #define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr)) 38 #define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr))
39 #define ADM1031_REG_FAN_FILTER (0x23) 39 #define ADM1031_REG_FAN_FILTER (0x23)
40 40
41 #define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr)) 41 #define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr))
42 #define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr)) 42 #define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr))
43 #define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr)) 43 #define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr))
44 #define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr)) 44 #define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr))
45 45
46 #define ADM1031_REG_TEMP(nr) (0x0a + (nr)) 46 #define ADM1031_REG_TEMP(nr) (0x0a + (nr))
47 #define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr)) 47 #define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr))
48 48
49 #define ADM1031_REG_STATUS(nr) (0x2 + (nr)) 49 #define ADM1031_REG_STATUS(nr) (0x2 + (nr))
50 50
51 #define ADM1031_REG_CONF1 0x00 51 #define ADM1031_REG_CONF1 0x00
52 #define ADM1031_REG_CONF2 0x01 52 #define ADM1031_REG_CONF2 0x01
53 #define ADM1031_REG_EXT_TEMP 0x06 53 #define ADM1031_REG_EXT_TEMP 0x06
54 54
55 #define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */ 55 #define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */
56 #define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */ 56 #define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */
57 #define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */ 57 #define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */
58 58
59 #define ADM1031_CONF2_PWM1_ENABLE 0x01 59 #define ADM1031_CONF2_PWM1_ENABLE 0x01
60 #define ADM1031_CONF2_PWM2_ENABLE 0x02 60 #define ADM1031_CONF2_PWM2_ENABLE 0x02
61 #define ADM1031_CONF2_TACH1_ENABLE 0x04 61 #define ADM1031_CONF2_TACH1_ENABLE 0x04
62 #define ADM1031_CONF2_TACH2_ENABLE 0x08 62 #define ADM1031_CONF2_TACH2_ENABLE 0x08
63 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan)) 63 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
64 64
65 #define ADM1031_UPDATE_RATE_MASK 0x1c 65 #define ADM1031_UPDATE_RATE_MASK 0x1c
66 #define ADM1031_UPDATE_RATE_SHIFT 2 66 #define ADM1031_UPDATE_RATE_SHIFT 2
67 67
68 /* Addresses to scan */ 68 /* Addresses to scan */
69 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END }; 69 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
70 70
71 enum chips { adm1030, adm1031 }; 71 enum chips { adm1030, adm1031 };
72 72
73 typedef u8 auto_chan_table_t[8][2]; 73 typedef u8 auto_chan_table_t[8][2];
74 74
75 /* Each client has this additional data */ 75 /* Each client has this additional data */
76 struct adm1031_data { 76 struct adm1031_data {
77 struct device *hwmon_dev; 77 struct device *hwmon_dev;
78 struct mutex update_lock; 78 struct mutex update_lock;
79 int chip_type; 79 int chip_type;
80 char valid; /* !=0 if following fields are valid */ 80 char valid; /* !=0 if following fields are valid */
81 unsigned long last_updated; /* In jiffies */ 81 unsigned long last_updated; /* In jiffies */
82 unsigned int update_interval; /* In milliseconds */ 82 unsigned int update_interval; /* In milliseconds */
83 /* The chan_select_table contains the possible configurations for 83 /* The chan_select_table contains the possible configurations for
84 * auto fan control. 84 * auto fan control.
85 */ 85 */
86 const auto_chan_table_t *chan_select_table; 86 const auto_chan_table_t *chan_select_table;
87 u16 alarm; 87 u16 alarm;
88 u8 conf1; 88 u8 conf1;
89 u8 conf2; 89 u8 conf2;
90 u8 fan[2]; 90 u8 fan[2];
91 u8 fan_div[2]; 91 u8 fan_div[2];
92 u8 fan_min[2]; 92 u8 fan_min[2];
93 u8 pwm[2]; 93 u8 pwm[2];
94 u8 old_pwm[2]; 94 u8 old_pwm[2];
95 s8 temp[3]; 95 s8 temp[3];
96 u8 ext_temp[3]; 96 u8 ext_temp[3];
97 u8 auto_temp[3]; 97 u8 auto_temp[3];
98 u8 auto_temp_min[3]; 98 u8 auto_temp_min[3];
99 u8 auto_temp_off[3]; 99 u8 auto_temp_off[3];
100 u8 auto_temp_max[3]; 100 u8 auto_temp_max[3];
101 s8 temp_offset[3]; 101 s8 temp_offset[3];
102 s8 temp_min[3]; 102 s8 temp_min[3];
103 s8 temp_max[3]; 103 s8 temp_max[3];
104 s8 temp_crit[3]; 104 s8 temp_crit[3];
105 }; 105 };
106 106
107 static int adm1031_probe(struct i2c_client *client, 107 static int adm1031_probe(struct i2c_client *client,
108 const struct i2c_device_id *id); 108 const struct i2c_device_id *id);
109 static int adm1031_detect(struct i2c_client *client, 109 static int adm1031_detect(struct i2c_client *client,
110 struct i2c_board_info *info); 110 struct i2c_board_info *info);
111 static void adm1031_init_client(struct i2c_client *client); 111 static void adm1031_init_client(struct i2c_client *client);
112 static int adm1031_remove(struct i2c_client *client); 112 static int adm1031_remove(struct i2c_client *client);
113 static struct adm1031_data *adm1031_update_device(struct device *dev); 113 static struct adm1031_data *adm1031_update_device(struct device *dev);
114 114
115 static const struct i2c_device_id adm1031_id[] = { 115 static const struct i2c_device_id adm1031_id[] = {
116 { "adm1030", adm1030 }, 116 { "adm1030", adm1030 },
117 { "adm1031", adm1031 }, 117 { "adm1031", adm1031 },
118 { } 118 { }
119 }; 119 };
120 MODULE_DEVICE_TABLE(i2c, adm1031_id); 120 MODULE_DEVICE_TABLE(i2c, adm1031_id);
121 121
122 /* This is the driver that will be inserted */ 122 /* This is the driver that will be inserted */
123 static struct i2c_driver adm1031_driver = { 123 static struct i2c_driver adm1031_driver = {
124 .class = I2C_CLASS_HWMON, 124 .class = I2C_CLASS_HWMON,
125 .driver = { 125 .driver = {
126 .name = "adm1031", 126 .name = "adm1031",
127 }, 127 },
128 .probe = adm1031_probe, 128 .probe = adm1031_probe,
129 .remove = adm1031_remove, 129 .remove = adm1031_remove,
130 .id_table = adm1031_id, 130 .id_table = adm1031_id,
131 .detect = adm1031_detect, 131 .detect = adm1031_detect,
132 .address_list = normal_i2c, 132 .address_list = normal_i2c,
133 }; 133 };
134 134
135 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg) 135 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
136 { 136 {
137 return i2c_smbus_read_byte_data(client, reg); 137 return i2c_smbus_read_byte_data(client, reg);
138 } 138 }
139 139
140 static inline int 140 static inline int
141 adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value) 141 adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
142 { 142 {
143 return i2c_smbus_write_byte_data(client, reg, value); 143 return i2c_smbus_write_byte_data(client, reg, value);
144 } 144 }
145 145
146 146
147 #define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \ 147 #define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
148 ((val + 500) / 1000))) 148 ((val + 500) / 1000)))
149 149
150 #define TEMP_FROM_REG(val) ((val) * 1000) 150 #define TEMP_FROM_REG(val) ((val) * 1000)
151 151
152 #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125) 152 #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
153 153
154 #define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f) 154 #define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f)
155 #define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \ 155 #define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \
156 (val) | 0x70 : (val)) 156 (val) | 0x70 : (val))
157 157
158 #define FAN_FROM_REG(reg, div) ((reg) ? (11250 * 60) / ((reg) * (div)) : 0) 158 #define FAN_FROM_REG(reg, div) ((reg) ? \
159 (11250 * 60) / ((reg) * (div)) : 0)
159 160
160 static int FAN_TO_REG(int reg, int div) 161 static int FAN_TO_REG(int reg, int div)
161 { 162 {
162 int tmp; 163 int tmp;
163 tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div); 164 tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div);
164 return tmp > 255 ? 255 : tmp; 165 return tmp > 255 ? 255 : tmp;
165 } 166 }
166 167
167 #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6)) 168 #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6))
168 169
169 #define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4) 170 #define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4)
170 #define PWM_FROM_REG(val) ((val) << 4) 171 #define PWM_FROM_REG(val) ((val) << 4)
171 172
172 #define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7) 173 #define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7)
173 #define FAN_CHAN_TO_REG(val, reg) \ 174 #define FAN_CHAN_TO_REG(val, reg) \
174 (((reg) & 0x1F) | (((val) << 5) & 0xe0)) 175 (((reg) & 0x1F) | (((val) << 5) & 0xe0))
175 176
176 #define AUTO_TEMP_MIN_TO_REG(val, reg) \ 177 #define AUTO_TEMP_MIN_TO_REG(val, reg) \
177 ((((val)/500) & 0xf8)|((reg) & 0x7)) 178 ((((val) / 500) & 0xf8) | ((reg) & 0x7))
178 #define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1<< ((reg)&0x7))) 179 #define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1 << ((reg) & 0x7)))
179 #define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2)) 180 #define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2))
180 181
181 #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2) 182 #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
182 183
183 #define AUTO_TEMP_OFF_FROM_REG(reg) \ 184 #define AUTO_TEMP_OFF_FROM_REG(reg) \
184 (AUTO_TEMP_MIN_FROM_REG(reg) - 5000) 185 (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
185 186
186 #define AUTO_TEMP_MAX_FROM_REG(reg) \ 187 #define AUTO_TEMP_MAX_FROM_REG(reg) \
187 (AUTO_TEMP_RANGE_FROM_REG(reg) + \ 188 (AUTO_TEMP_RANGE_FROM_REG(reg) + \
188 AUTO_TEMP_MIN_FROM_REG(reg)) 189 AUTO_TEMP_MIN_FROM_REG(reg))
189 190
190 static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm) 191 static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
191 { 192 {
192 int ret; 193 int ret;
193 int range = val - AUTO_TEMP_MIN_FROM_REG(reg); 194 int range = val - AUTO_TEMP_MIN_FROM_REG(reg);
194 195
195 range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm); 196 range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm);
196 ret = ((reg & 0xf8) | 197 ret = ((reg & 0xf8) |
197 (range < 10000 ? 0 : 198 (range < 10000 ? 0 :
198 range < 20000 ? 1 : 199 range < 20000 ? 1 :
199 range < 40000 ? 2 : range < 80000 ? 3 : 4)); 200 range < 40000 ? 2 : range < 80000 ? 3 : 4));
200 return ret; 201 return ret;
201 } 202 }
202 203
203 /* FAN auto control */ 204 /* FAN auto control */
204 #define GET_FAN_AUTO_BITFIELD(data, idx) \ 205 #define GET_FAN_AUTO_BITFIELD(data, idx) \
205 (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx%2] 206 (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx % 2]
206 207
207 /* The tables below contains the possible values for the auto fan 208 /* The tables below contains the possible values for the auto fan
208 * control bitfields. the index in the table is the register value. 209 * control bitfields. the index in the table is the register value.
209 * MSb is the auto fan control enable bit, so the four first entries 210 * MSb is the auto fan control enable bit, so the four first entries
210 * in the table disables auto fan control when both bitfields are zero. 211 * in the table disables auto fan control when both bitfields are zero.
211 */ 212 */
212 static const auto_chan_table_t auto_channel_select_table_adm1031 = { 213 static const auto_chan_table_t auto_channel_select_table_adm1031 = {
213 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, 214 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
214 { 2 /* 0b010 */ , 4 /* 0b100 */ }, 215 { 2 /* 0b010 */ , 4 /* 0b100 */ },
215 { 2 /* 0b010 */ , 2 /* 0b010 */ }, 216 { 2 /* 0b010 */ , 2 /* 0b010 */ },
216 { 4 /* 0b100 */ , 4 /* 0b100 */ }, 217 { 4 /* 0b100 */ , 4 /* 0b100 */ },
217 { 7 /* 0b111 */ , 7 /* 0b111 */ }, 218 { 7 /* 0b111 */ , 7 /* 0b111 */ },
218 }; 219 };
219 220
220 static const auto_chan_table_t auto_channel_select_table_adm1030 = { 221 static const auto_chan_table_t auto_channel_select_table_adm1030 = {
221 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, 222 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
222 { 2 /* 0b10 */ , 0 }, 223 { 2 /* 0b10 */ , 0 },
223 { 0xff /* invalid */ , 0 }, 224 { 0xff /* invalid */ , 0 },
224 { 0xff /* invalid */ , 0 }, 225 { 0xff /* invalid */ , 0 },
225 { 3 /* 0b11 */ , 0 }, 226 { 3 /* 0b11 */ , 0 },
226 }; 227 };
227 228
228 /* That function checks if a bitfield is valid and returns the other bitfield 229 /* That function checks if a bitfield is valid and returns the other bitfield
229 * nearest match if no exact match where found. 230 * nearest match if no exact match where found.
230 */ 231 */
231 static int 232 static int
232 get_fan_auto_nearest(struct adm1031_data *data, 233 get_fan_auto_nearest(struct adm1031_data *data,
233 int chan, u8 val, u8 reg, u8 * new_reg) 234 int chan, u8 val, u8 reg, u8 *new_reg)
234 { 235 {
235 int i; 236 int i;
236 int first_match = -1, exact_match = -1; 237 int first_match = -1, exact_match = -1;
237 u8 other_reg_val = 238 u8 other_reg_val =
238 (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1]; 239 (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
239 240
240 if (val == 0) { 241 if (val == 0) {
241 *new_reg = 0; 242 *new_reg = 0;
242 return 0; 243 return 0;
243 } 244 }
244 245
245 for (i = 0; i < 8; i++) { 246 for (i = 0; i < 8; i++) {
246 if ((val == (*data->chan_select_table)[i][chan]) && 247 if ((val == (*data->chan_select_table)[i][chan]) &&
247 ((*data->chan_select_table)[i][chan ? 0 : 1] == 248 ((*data->chan_select_table)[i][chan ? 0 : 1] ==
248 other_reg_val)) { 249 other_reg_val)) {
249 /* We found an exact match */ 250 /* We found an exact match */
250 exact_match = i; 251 exact_match = i;
251 break; 252 break;
252 } else if (val == (*data->chan_select_table)[i][chan] && 253 } else if (val == (*data->chan_select_table)[i][chan] &&
253 first_match == -1) { 254 first_match == -1) {
254 /* Save the first match in case of an exact match has 255 /* Save the first match in case of an exact match has
255 * not been found 256 * not been found
256 */ 257 */
257 first_match = i; 258 first_match = i;
258 } 259 }
259 } 260 }
260 261
261 if (exact_match >= 0) { 262 if (exact_match >= 0)
262 *new_reg = exact_match; 263 *new_reg = exact_match;
263 } else if (first_match >= 0) { 264 else if (first_match >= 0)
264 *new_reg = first_match; 265 *new_reg = first_match;
265 } else { 266 else
266 return -EINVAL; 267 return -EINVAL;
267 } 268
268 return 0; 269 return 0;
269 } 270 }
270 271
271 static ssize_t show_fan_auto_channel(struct device *dev, 272 static ssize_t show_fan_auto_channel(struct device *dev,
272 struct device_attribute *attr, char *buf) 273 struct device_attribute *attr, char *buf)
273 { 274 {
274 int nr = to_sensor_dev_attr(attr)->index; 275 int nr = to_sensor_dev_attr(attr)->index;
275 struct adm1031_data *data = adm1031_update_device(dev); 276 struct adm1031_data *data = adm1031_update_device(dev);
276 return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr)); 277 return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
277 } 278 }
278 279
279 static ssize_t 280 static ssize_t
280 set_fan_auto_channel(struct device *dev, struct device_attribute *attr, 281 set_fan_auto_channel(struct device *dev, struct device_attribute *attr,
281 const char *buf, size_t count) 282 const char *buf, size_t count)
282 { 283 {
283 struct i2c_client *client = to_i2c_client(dev); 284 struct i2c_client *client = to_i2c_client(dev);
284 struct adm1031_data *data = i2c_get_clientdata(client); 285 struct adm1031_data *data = i2c_get_clientdata(client);
285 int nr = to_sensor_dev_attr(attr)->index; 286 int nr = to_sensor_dev_attr(attr)->index;
286 int val = simple_strtol(buf, NULL, 10); 287 long val;
287 u8 reg; 288 u8 reg;
288 int ret; 289 int ret;
289 u8 old_fan_mode; 290 u8 old_fan_mode;
290 291
292 ret = kstrtol(buf, 10, &val);
293 if (ret)
294 return ret;
295
291 old_fan_mode = data->conf1; 296 old_fan_mode = data->conf1;
292 297
293 mutex_lock(&data->update_lock); 298 mutex_lock(&data->update_lock);
294 299
295 if ((ret = get_fan_auto_nearest(data, nr, val, data->conf1, &reg))) { 300 ret = get_fan_auto_nearest(data, nr, val, data->conf1, &reg);
301 if (ret) {
296 mutex_unlock(&data->update_lock); 302 mutex_unlock(&data->update_lock);
297 return ret; 303 return ret;
298 } 304 }
299 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1); 305 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
300 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^ 306 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
301 (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) { 307 (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
302 if (data->conf1 & ADM1031_CONF1_AUTO_MODE){ 308 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
303 /* Switch to Auto Fan Mode 309 /* Switch to Auto Fan Mode
304 * Save PWM registers 310 * Save PWM registers
305 * Set PWM registers to 33% Both */ 311 * Set PWM registers to 33% Both */
306 data->old_pwm[0] = data->pwm[0]; 312 data->old_pwm[0] = data->pwm[0];
307 data->old_pwm[1] = data->pwm[1]; 313 data->old_pwm[1] = data->pwm[1];
308 adm1031_write_value(client, ADM1031_REG_PWM, 0x55); 314 adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
309 } else { 315 } else {
310 /* Switch to Manual Mode */ 316 /* Switch to Manual Mode */
311 data->pwm[0] = data->old_pwm[0]; 317 data->pwm[0] = data->old_pwm[0];
312 data->pwm[1] = data->old_pwm[1]; 318 data->pwm[1] = data->old_pwm[1];
313 /* Restore PWM registers */ 319 /* Restore PWM registers */
314 adm1031_write_value(client, ADM1031_REG_PWM, 320 adm1031_write_value(client, ADM1031_REG_PWM,
315 data->pwm[0] | (data->pwm[1] << 4)); 321 data->pwm[0] | (data->pwm[1] << 4));
316 } 322 }
317 } 323 }
318 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1); 324 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
319 adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1); 325 adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
320 mutex_unlock(&data->update_lock); 326 mutex_unlock(&data->update_lock);
321 return count; 327 return count;
322 } 328 }
323 329
324 static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR, 330 static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR,
325 show_fan_auto_channel, set_fan_auto_channel, 0); 331 show_fan_auto_channel, set_fan_auto_channel, 0);
326 static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR, 332 static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR,
327 show_fan_auto_channel, set_fan_auto_channel, 1); 333 show_fan_auto_channel, set_fan_auto_channel, 1);
328 334
329 /* Auto Temps */ 335 /* Auto Temps */
330 static ssize_t show_auto_temp_off(struct device *dev, 336 static ssize_t show_auto_temp_off(struct device *dev,
331 struct device_attribute *attr, char *buf) 337 struct device_attribute *attr, char *buf)
332 { 338 {
333 int nr = to_sensor_dev_attr(attr)->index; 339 int nr = to_sensor_dev_attr(attr)->index;
334 struct adm1031_data *data = adm1031_update_device(dev); 340 struct adm1031_data *data = adm1031_update_device(dev);
335 return sprintf(buf, "%d\n", 341 return sprintf(buf, "%d\n",
336 AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr])); 342 AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
337 } 343 }
338 static ssize_t show_auto_temp_min(struct device *dev, 344 static ssize_t show_auto_temp_min(struct device *dev,
339 struct device_attribute *attr, char *buf) 345 struct device_attribute *attr, char *buf)
340 { 346 {
341 int nr = to_sensor_dev_attr(attr)->index; 347 int nr = to_sensor_dev_attr(attr)->index;
342 struct adm1031_data *data = adm1031_update_device(dev); 348 struct adm1031_data *data = adm1031_update_device(dev);
343 return sprintf(buf, "%d\n", 349 return sprintf(buf, "%d\n",
344 AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr])); 350 AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
345 } 351 }
346 static ssize_t 352 static ssize_t
347 set_auto_temp_min(struct device *dev, struct device_attribute *attr, 353 set_auto_temp_min(struct device *dev, struct device_attribute *attr,
348 const char *buf, size_t count) 354 const char *buf, size_t count)
349 { 355 {
350 struct i2c_client *client = to_i2c_client(dev); 356 struct i2c_client *client = to_i2c_client(dev);
351 struct adm1031_data *data = i2c_get_clientdata(client); 357 struct adm1031_data *data = i2c_get_clientdata(client);
352 int nr = to_sensor_dev_attr(attr)->index; 358 int nr = to_sensor_dev_attr(attr)->index;
353 int val = simple_strtol(buf, NULL, 10); 359 long val;
360 int ret;
354 361
362 ret = kstrtol(buf, 10, &val);
363 if (ret)
364 return ret;
365
355 mutex_lock(&data->update_lock); 366 mutex_lock(&data->update_lock);
356 data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]); 367 data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
357 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr), 368 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
358 data->auto_temp[nr]); 369 data->auto_temp[nr]);
359 mutex_unlock(&data->update_lock); 370 mutex_unlock(&data->update_lock);
360 return count; 371 return count;
361 } 372 }
362 static ssize_t show_auto_temp_max(struct device *dev, 373 static ssize_t show_auto_temp_max(struct device *dev,
363 struct device_attribute *attr, char *buf) 374 struct device_attribute *attr, char *buf)
364 { 375 {
365 int nr = to_sensor_dev_attr(attr)->index; 376 int nr = to_sensor_dev_attr(attr)->index;
366 struct adm1031_data *data = adm1031_update_device(dev); 377 struct adm1031_data *data = adm1031_update_device(dev);
367 return sprintf(buf, "%d\n", 378 return sprintf(buf, "%d\n",
368 AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr])); 379 AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
369 } 380 }
370 static ssize_t 381 static ssize_t
371 set_auto_temp_max(struct device *dev, struct device_attribute *attr, 382 set_auto_temp_max(struct device *dev, struct device_attribute *attr,
372 const char *buf, size_t count) 383 const char *buf, size_t count)
373 { 384 {
374 struct i2c_client *client = to_i2c_client(dev); 385 struct i2c_client *client = to_i2c_client(dev);
375 struct adm1031_data *data = i2c_get_clientdata(client); 386 struct adm1031_data *data = i2c_get_clientdata(client);
376 int nr = to_sensor_dev_attr(attr)->index; 387 int nr = to_sensor_dev_attr(attr)->index;
377 int val = simple_strtol(buf, NULL, 10); 388 long val;
389 int ret;
378 390
391 ret = kstrtol(buf, 10, &val);
392 if (ret)
393 return ret;
394
379 mutex_lock(&data->update_lock); 395 mutex_lock(&data->update_lock);
380 data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr], data->pwm[nr]); 396 data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr],
397 data->pwm[nr]);
381 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr), 398 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
382 data->temp_max[nr]); 399 data->temp_max[nr]);
383 mutex_unlock(&data->update_lock); 400 mutex_unlock(&data->update_lock);
384 return count; 401 return count;
385 } 402 }
386 403
387 #define auto_temp_reg(offset) \ 404 #define auto_temp_reg(offset) \
388 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \ 405 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \
389 show_auto_temp_off, NULL, offset - 1); \ 406 show_auto_temp_off, NULL, offset - 1); \
390 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \ 407 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \
391 show_auto_temp_min, set_auto_temp_min, offset - 1); \ 408 show_auto_temp_min, set_auto_temp_min, offset - 1); \
392 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \ 409 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \
393 show_auto_temp_max, set_auto_temp_max, offset - 1) 410 show_auto_temp_max, set_auto_temp_max, offset - 1)
394 411
395 auto_temp_reg(1); 412 auto_temp_reg(1);
396 auto_temp_reg(2); 413 auto_temp_reg(2);
397 auto_temp_reg(3); 414 auto_temp_reg(3);
398 415
399 /* pwm */ 416 /* pwm */
400 static ssize_t show_pwm(struct device *dev, 417 static ssize_t show_pwm(struct device *dev,
401 struct device_attribute *attr, char *buf) 418 struct device_attribute *attr, char *buf)
402 { 419 {
403 int nr = to_sensor_dev_attr(attr)->index; 420 int nr = to_sensor_dev_attr(attr)->index;
404 struct adm1031_data *data = adm1031_update_device(dev); 421 struct adm1031_data *data = adm1031_update_device(dev);
405 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr])); 422 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
406 } 423 }
407 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 424 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
408 const char *buf, size_t count) 425 const char *buf, size_t count)
409 { 426 {
410 struct i2c_client *client = to_i2c_client(dev); 427 struct i2c_client *client = to_i2c_client(dev);
411 struct adm1031_data *data = i2c_get_clientdata(client); 428 struct adm1031_data *data = i2c_get_clientdata(client);
412 int nr = to_sensor_dev_attr(attr)->index; 429 int nr = to_sensor_dev_attr(attr)->index;
413 int val = simple_strtol(buf, NULL, 10); 430 long val;
414 int reg; 431 int ret, reg;
415 432
433 ret = kstrtol(buf, 10, &val);
434 if (ret)
435 return ret;
436
416 mutex_lock(&data->update_lock); 437 mutex_lock(&data->update_lock);
417 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) && 438 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
418 (((val>>4) & 0xf) != 5)) { 439 (((val>>4) & 0xf) != 5)) {
419 /* In automatic mode, the only PWM accepted is 33% */ 440 /* In automatic mode, the only PWM accepted is 33% */
420 mutex_unlock(&data->update_lock); 441 mutex_unlock(&data->update_lock);
421 return -EINVAL; 442 return -EINVAL;
422 } 443 }
423 data->pwm[nr] = PWM_TO_REG(val); 444 data->pwm[nr] = PWM_TO_REG(val);
424 reg = adm1031_read_value(client, ADM1031_REG_PWM); 445 reg = adm1031_read_value(client, ADM1031_REG_PWM);
425 adm1031_write_value(client, ADM1031_REG_PWM, 446 adm1031_write_value(client, ADM1031_REG_PWM,
426 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf) 447 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
427 : (data->pwm[nr] & 0xf) | (reg & 0xf0)); 448 : (data->pwm[nr] & 0xf) | (reg & 0xf0));
428 mutex_unlock(&data->update_lock); 449 mutex_unlock(&data->update_lock);
429 return count; 450 return count;
430 } 451 }
431 452
432 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0); 453 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);
433 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1); 454 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1);
434 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR, 455 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR,
435 show_pwm, set_pwm, 0); 456 show_pwm, set_pwm, 0);
436 static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR, 457 static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR,
437 show_pwm, set_pwm, 1); 458 show_pwm, set_pwm, 1);
438 459
439 /* Fans */ 460 /* Fans */
440 461
441 /* 462 /*
442 * That function checks the cases where the fan reading is not 463 * That function checks the cases where the fan reading is not
443 * relevant. It is used to provide 0 as fan reading when the fan is 464 * relevant. It is used to provide 0 as fan reading when the fan is
444 * not supposed to run 465 * not supposed to run
445 */ 466 */
446 static int trust_fan_readings(struct adm1031_data *data, int chan) 467 static int trust_fan_readings(struct adm1031_data *data, int chan)
447 { 468 {
448 int res = 0; 469 int res = 0;
449 470
450 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) { 471 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
451 switch (data->conf1 & 0x60) { 472 switch (data->conf1 & 0x60) {
452 case 0x00: /* remote temp1 controls fan1 remote temp2 controls fan2 */ 473 case 0x00:
474 /*
475 * remote temp1 controls fan1,
476 * remote temp2 controls fan2
477 */
453 res = data->temp[chan+1] >= 478 res = data->temp[chan+1] >=
454 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]); 479 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
455 break; 480 break;
456 case 0x20: /* remote temp1 controls both fans */ 481 case 0x20: /* remote temp1 controls both fans */
457 res = 482 res =
458 data->temp[1] >= 483 data->temp[1] >=
459 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]); 484 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
460 break; 485 break;
461 case 0x40: /* remote temp2 controls both fans */ 486 case 0x40: /* remote temp2 controls both fans */
462 res = 487 res =
463 data->temp[2] >= 488 data->temp[2] >=
464 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]); 489 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
465 break; 490 break;
466 case 0x60: /* max controls both fans */ 491 case 0x60: /* max controls both fans */
467 res = 492 res =
468 data->temp[0] >= 493 data->temp[0] >=
469 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0]) 494 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
470 || data->temp[1] >= 495 || data->temp[1] >=
471 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]) 496 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
472 || (data->chip_type == adm1031 497 || (data->chip_type == adm1031
473 && data->temp[2] >= 498 && data->temp[2] >=
474 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2])); 499 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
475 break; 500 break;
476 } 501 }
477 } else { 502 } else {
478 res = data->pwm[chan] > 0; 503 res = data->pwm[chan] > 0;
479 } 504 }
480 return res; 505 return res;
481 } 506 }
482 507
483 508
484 static ssize_t show_fan(struct device *dev, 509 static ssize_t show_fan(struct device *dev,
485 struct device_attribute *attr, char *buf) 510 struct device_attribute *attr, char *buf)
486 { 511 {
487 int nr = to_sensor_dev_attr(attr)->index; 512 int nr = to_sensor_dev_attr(attr)->index;
488 struct adm1031_data *data = adm1031_update_device(dev); 513 struct adm1031_data *data = adm1031_update_device(dev);
489 int value; 514 int value;
490 515
491 value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr], 516 value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
492 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0; 517 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
493 return sprintf(buf, "%d\n", value); 518 return sprintf(buf, "%d\n", value);
494 } 519 }
495 520
496 static ssize_t show_fan_div(struct device *dev, 521 static ssize_t show_fan_div(struct device *dev,
497 struct device_attribute *attr, char *buf) 522 struct device_attribute *attr, char *buf)
498 { 523 {
499 int nr = to_sensor_dev_attr(attr)->index; 524 int nr = to_sensor_dev_attr(attr)->index;
500 struct adm1031_data *data = adm1031_update_device(dev); 525 struct adm1031_data *data = adm1031_update_device(dev);
501 return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr])); 526 return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
502 } 527 }
503 static ssize_t show_fan_min(struct device *dev, 528 static ssize_t show_fan_min(struct device *dev,
504 struct device_attribute *attr, char *buf) 529 struct device_attribute *attr, char *buf)
505 { 530 {
506 int nr = to_sensor_dev_attr(attr)->index; 531 int nr = to_sensor_dev_attr(attr)->index;
507 struct adm1031_data *data = adm1031_update_device(dev); 532 struct adm1031_data *data = adm1031_update_device(dev);
508 return sprintf(buf, "%d\n", 533 return sprintf(buf, "%d\n",
509 FAN_FROM_REG(data->fan_min[nr], 534 FAN_FROM_REG(data->fan_min[nr],
510 FAN_DIV_FROM_REG(data->fan_div[nr]))); 535 FAN_DIV_FROM_REG(data->fan_div[nr])));
511 } 536 }
512 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 537 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
513 const char *buf, size_t count) 538 const char *buf, size_t count)
514 { 539 {
515 struct i2c_client *client = to_i2c_client(dev); 540 struct i2c_client *client = to_i2c_client(dev);
516 struct adm1031_data *data = i2c_get_clientdata(client); 541 struct adm1031_data *data = i2c_get_clientdata(client);
517 int nr = to_sensor_dev_attr(attr)->index; 542 int nr = to_sensor_dev_attr(attr)->index;
518 int val = simple_strtol(buf, NULL, 10); 543 long val;
544 int ret;
519 545
546 ret = kstrtol(buf, 10, &val);
547 if (ret)
548 return ret;
549
520 mutex_lock(&data->update_lock); 550 mutex_lock(&data->update_lock);
521 if (val) { 551 if (val) {
522 data->fan_min[nr] = 552 data->fan_min[nr] =
523 FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr])); 553 FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
524 } else { 554 } else {
525 data->fan_min[nr] = 0xff; 555 data->fan_min[nr] = 0xff;
526 } 556 }
527 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]); 557 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
528 mutex_unlock(&data->update_lock); 558 mutex_unlock(&data->update_lock);
529 return count; 559 return count;
530 } 560 }
531 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 561 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
532 const char *buf, size_t count) 562 const char *buf, size_t count)
533 { 563 {
534 struct i2c_client *client = to_i2c_client(dev); 564 struct i2c_client *client = to_i2c_client(dev);
535 struct adm1031_data *data = i2c_get_clientdata(client); 565 struct adm1031_data *data = i2c_get_clientdata(client);
536 int nr = to_sensor_dev_attr(attr)->index; 566 int nr = to_sensor_dev_attr(attr)->index;
537 int val = simple_strtol(buf, NULL, 10); 567 long val;
538 u8 tmp; 568 u8 tmp;
539 int old_div; 569 int old_div;
540 int new_min; 570 int new_min;
571 int ret;
541 572
573 ret = kstrtol(buf, 10, &val);
574 if (ret)
575 return ret;
576
542 tmp = val == 8 ? 0xc0 : 577 tmp = val == 8 ? 0xc0 :
543 val == 4 ? 0x80 : 578 val == 4 ? 0x80 :
544 val == 2 ? 0x40 : 579 val == 2 ? 0x40 :
545 val == 1 ? 0x00 : 580 val == 1 ? 0x00 :
546 0xff; 581 0xff;
547 if (tmp == 0xff) 582 if (tmp == 0xff)
548 return -EINVAL; 583 return -EINVAL;
549 584
550 mutex_lock(&data->update_lock); 585 mutex_lock(&data->update_lock);
551 /* Get fresh readings */ 586 /* Get fresh readings */
552 data->fan_div[nr] = adm1031_read_value(client, 587 data->fan_div[nr] = adm1031_read_value(client,
553 ADM1031_REG_FAN_DIV(nr)); 588 ADM1031_REG_FAN_DIV(nr));
554 data->fan_min[nr] = adm1031_read_value(client, 589 data->fan_min[nr] = adm1031_read_value(client,
555 ADM1031_REG_FAN_MIN(nr)); 590 ADM1031_REG_FAN_MIN(nr));
556 591
557 /* Write the new clock divider and fan min */ 592 /* Write the new clock divider and fan min */
558 old_div = FAN_DIV_FROM_REG(data->fan_div[nr]); 593 old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
559 data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]); 594 data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
560 new_min = data->fan_min[nr] * old_div / val; 595 new_min = data->fan_min[nr] * old_div / val;
561 data->fan_min[nr] = new_min > 0xff ? 0xff : new_min; 596 data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
562 597
563 adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr), 598 adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
564 data->fan_div[nr]); 599 data->fan_div[nr]);
565 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), 600 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
566 data->fan_min[nr]); 601 data->fan_min[nr]);
567 602
568 /* Invalidate the cache: fan speed is no longer valid */ 603 /* Invalidate the cache: fan speed is no longer valid */
569 data->valid = 0; 604 data->valid = 0;
570 mutex_unlock(&data->update_lock); 605 mutex_unlock(&data->update_lock);
571 return count; 606 return count;
572 } 607 }
573 608
574 #define fan_offset(offset) \ 609 #define fan_offset(offset) \
575 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \ 610 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
576 show_fan, NULL, offset - 1); \ 611 show_fan, NULL, offset - 1); \
577 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 612 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
578 show_fan_min, set_fan_min, offset - 1); \ 613 show_fan_min, set_fan_min, offset - 1); \
579 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 614 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
580 show_fan_div, set_fan_div, offset - 1) 615 show_fan_div, set_fan_div, offset - 1)
581 616
582 fan_offset(1); 617 fan_offset(1);
583 fan_offset(2); 618 fan_offset(2);
584 619
585 620
586 /* Temps */ 621 /* Temps */
587 static ssize_t show_temp(struct device *dev, 622 static ssize_t show_temp(struct device *dev,
588 struct device_attribute *attr, char *buf) 623 struct device_attribute *attr, char *buf)
589 { 624 {
590 int nr = to_sensor_dev_attr(attr)->index; 625 int nr = to_sensor_dev_attr(attr)->index;
591 struct adm1031_data *data = adm1031_update_device(dev); 626 struct adm1031_data *data = adm1031_update_device(dev);
592 int ext; 627 int ext;
593 ext = nr == 0 ? 628 ext = nr == 0 ?
594 ((data->ext_temp[nr] >> 6) & 0x3) * 2 : 629 ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
595 (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7)); 630 (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
596 return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext)); 631 return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
597 } 632 }
598 static ssize_t show_temp_offset(struct device *dev, 633 static ssize_t show_temp_offset(struct device *dev,
599 struct device_attribute *attr, char *buf) 634 struct device_attribute *attr, char *buf)
600 { 635 {
601 int nr = to_sensor_dev_attr(attr)->index; 636 int nr = to_sensor_dev_attr(attr)->index;
602 struct adm1031_data *data = adm1031_update_device(dev); 637 struct adm1031_data *data = adm1031_update_device(dev);
603 return sprintf(buf, "%d\n", 638 return sprintf(buf, "%d\n",
604 TEMP_OFFSET_FROM_REG(data->temp_offset[nr])); 639 TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
605 } 640 }
606 static ssize_t show_temp_min(struct device *dev, 641 static ssize_t show_temp_min(struct device *dev,
607 struct device_attribute *attr, char *buf) 642 struct device_attribute *attr, char *buf)
608 { 643 {
609 int nr = to_sensor_dev_attr(attr)->index; 644 int nr = to_sensor_dev_attr(attr)->index;
610 struct adm1031_data *data = adm1031_update_device(dev); 645 struct adm1031_data *data = adm1031_update_device(dev);
611 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr])); 646 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
612 } 647 }
613 static ssize_t show_temp_max(struct device *dev, 648 static ssize_t show_temp_max(struct device *dev,
614 struct device_attribute *attr, char *buf) 649 struct device_attribute *attr, char *buf)
615 { 650 {
616 int nr = to_sensor_dev_attr(attr)->index; 651 int nr = to_sensor_dev_attr(attr)->index;
617 struct adm1031_data *data = adm1031_update_device(dev); 652 struct adm1031_data *data = adm1031_update_device(dev);
618 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr])); 653 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
619 } 654 }
620 static ssize_t show_temp_crit(struct device *dev, 655 static ssize_t show_temp_crit(struct device *dev,
621 struct device_attribute *attr, char *buf) 656 struct device_attribute *attr, char *buf)
622 { 657 {
623 int nr = to_sensor_dev_attr(attr)->index; 658 int nr = to_sensor_dev_attr(attr)->index;
624 struct adm1031_data *data = adm1031_update_device(dev); 659 struct adm1031_data *data = adm1031_update_device(dev);
625 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr])); 660 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
626 } 661 }
627 static ssize_t set_temp_offset(struct device *dev, 662 static ssize_t set_temp_offset(struct device *dev,
628 struct device_attribute *attr, const char *buf, 663 struct device_attribute *attr, const char *buf,
629 size_t count) 664 size_t count)
630 { 665 {
631 struct i2c_client *client = to_i2c_client(dev); 666 struct i2c_client *client = to_i2c_client(dev);
632 struct adm1031_data *data = i2c_get_clientdata(client); 667 struct adm1031_data *data = i2c_get_clientdata(client);
633 int nr = to_sensor_dev_attr(attr)->index; 668 int nr = to_sensor_dev_attr(attr)->index;
634 int val; 669 long val;
670 int ret;
635 671
636 val = simple_strtol(buf, NULL, 10); 672 ret = kstrtol(buf, 10, &val);
673 if (ret)
674 return ret;
675
637 val = SENSORS_LIMIT(val, -15000, 15000); 676 val = SENSORS_LIMIT(val, -15000, 15000);
638 mutex_lock(&data->update_lock); 677 mutex_lock(&data->update_lock);
639 data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val); 678 data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
640 adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr), 679 adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
641 data->temp_offset[nr]); 680 data->temp_offset[nr]);
642 mutex_unlock(&data->update_lock); 681 mutex_unlock(&data->update_lock);
643 return count; 682 return count;
644 } 683 }
645 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr, 684 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
646 const char *buf, size_t count) 685 const char *buf, size_t count)
647 { 686 {
648 struct i2c_client *client = to_i2c_client(dev); 687 struct i2c_client *client = to_i2c_client(dev);
649 struct adm1031_data *data = i2c_get_clientdata(client); 688 struct adm1031_data *data = i2c_get_clientdata(client);
650 int nr = to_sensor_dev_attr(attr)->index; 689 int nr = to_sensor_dev_attr(attr)->index;
651 int val; 690 long val;
691 int ret;
652 692
653 val = simple_strtol(buf, NULL, 10); 693 ret = kstrtol(buf, 10, &val);
694 if (ret)
695 return ret;
696
654 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); 697 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
655 mutex_lock(&data->update_lock); 698 mutex_lock(&data->update_lock);
656 data->temp_min[nr] = TEMP_TO_REG(val); 699 data->temp_min[nr] = TEMP_TO_REG(val);
657 adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr), 700 adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
658 data->temp_min[nr]); 701 data->temp_min[nr]);
659 mutex_unlock(&data->update_lock); 702 mutex_unlock(&data->update_lock);
660 return count; 703 return count;
661 } 704 }
662 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, 705 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
663 const char *buf, size_t count) 706 const char *buf, size_t count)
664 { 707 {
665 struct i2c_client *client = to_i2c_client(dev); 708 struct i2c_client *client = to_i2c_client(dev);
666 struct adm1031_data *data = i2c_get_clientdata(client); 709 struct adm1031_data *data = i2c_get_clientdata(client);
667 int nr = to_sensor_dev_attr(attr)->index; 710 int nr = to_sensor_dev_attr(attr)->index;
668 int val; 711 long val;
712 int ret;
669 713
670 val = simple_strtol(buf, NULL, 10); 714 ret = kstrtol(buf, 10, &val);
715 if (ret)
716 return ret;
717
671 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); 718 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
672 mutex_lock(&data->update_lock); 719 mutex_lock(&data->update_lock);
673 data->temp_max[nr] = TEMP_TO_REG(val); 720 data->temp_max[nr] = TEMP_TO_REG(val);
674 adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr), 721 adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
675 data->temp_max[nr]); 722 data->temp_max[nr]);
676 mutex_unlock(&data->update_lock); 723 mutex_unlock(&data->update_lock);
677 return count; 724 return count;
678 } 725 }
679 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr, 726 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
680 const char *buf, size_t count) 727 const char *buf, size_t count)
681 { 728 {
682 struct i2c_client *client = to_i2c_client(dev); 729 struct i2c_client *client = to_i2c_client(dev);
683 struct adm1031_data *data = i2c_get_clientdata(client); 730 struct adm1031_data *data = i2c_get_clientdata(client);
684 int nr = to_sensor_dev_attr(attr)->index; 731 int nr = to_sensor_dev_attr(attr)->index;
685 int val; 732 long val;
733 int ret;
686 734
687 val = simple_strtol(buf, NULL, 10); 735 ret = kstrtol(buf, 10, &val);
736 if (ret)
737 return ret;
738
688 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875); 739 val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
689 mutex_lock(&data->update_lock); 740 mutex_lock(&data->update_lock);
690 data->temp_crit[nr] = TEMP_TO_REG(val); 741 data->temp_crit[nr] = TEMP_TO_REG(val);
691 adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr), 742 adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
692 data->temp_crit[nr]); 743 data->temp_crit[nr]);
693 mutex_unlock(&data->update_lock); 744 mutex_unlock(&data->update_lock);
694 return count; 745 return count;
695 } 746 }
696 747
697 #define temp_reg(offset) \ 748 #define temp_reg(offset) \
698 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \ 749 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
699 show_temp, NULL, offset - 1); \ 750 show_temp, NULL, offset - 1); \
700 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \ 751 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \
701 show_temp_offset, set_temp_offset, offset - 1); \ 752 show_temp_offset, set_temp_offset, offset - 1); \
702 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \ 753 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
703 show_temp_min, set_temp_min, offset - 1); \ 754 show_temp_min, set_temp_min, offset - 1); \
704 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ 755 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
705 show_temp_max, set_temp_max, offset - 1); \ 756 show_temp_max, set_temp_max, offset - 1); \
706 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \ 757 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \
707 show_temp_crit, set_temp_crit, offset - 1) 758 show_temp_crit, set_temp_crit, offset - 1)
708 759
709 temp_reg(1); 760 temp_reg(1);
710 temp_reg(2); 761 temp_reg(2);
711 temp_reg(3); 762 temp_reg(3);
712 763
713 /* Alarms */ 764 /* Alarms */
714 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) 765 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
766 char *buf)
715 { 767 {
716 struct adm1031_data *data = adm1031_update_device(dev); 768 struct adm1031_data *data = adm1031_update_device(dev);
717 return sprintf(buf, "%d\n", data->alarm); 769 return sprintf(buf, "%d\n", data->alarm);
718 } 770 }
719 771
720 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 772 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
721 773
722 static ssize_t show_alarm(struct device *dev, 774 static ssize_t show_alarm(struct device *dev,
723 struct device_attribute *attr, char *buf) 775 struct device_attribute *attr, char *buf)
724 { 776 {
725 int bitnr = to_sensor_dev_attr(attr)->index; 777 int bitnr = to_sensor_dev_attr(attr)->index;
726 struct adm1031_data *data = adm1031_update_device(dev); 778 struct adm1031_data *data = adm1031_update_device(dev);
727 return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1); 779 return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
728 } 780 }
729 781
730 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0); 782 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
731 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1); 783 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
732 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2); 784 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
733 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3); 785 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
734 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4); 786 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4);
735 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5); 787 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5);
736 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6); 788 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
737 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7); 789 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7);
738 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8); 790 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8);
739 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9); 791 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9);
740 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10); 792 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10);
741 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11); 793 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
742 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12); 794 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
743 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13); 795 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
744 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14); 796 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
745 797
746 /* Update Interval */ 798 /* Update Interval */
747 static const unsigned int update_intervals[] = { 799 static const unsigned int update_intervals[] = {
748 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 800 16000, 8000, 4000, 2000, 1000, 500, 250, 125,
749 }; 801 };
750 802
751 static ssize_t show_update_interval(struct device *dev, 803 static ssize_t show_update_interval(struct device *dev,
752 struct device_attribute *attr, char *buf) 804 struct device_attribute *attr, char *buf)
753 { 805 {
754 struct i2c_client *client = to_i2c_client(dev); 806 struct i2c_client *client = to_i2c_client(dev);
755 struct adm1031_data *data = i2c_get_clientdata(client); 807 struct adm1031_data *data = i2c_get_clientdata(client);
756 808
757 return sprintf(buf, "%u\n", data->update_interval); 809 return sprintf(buf, "%u\n", data->update_interval);
758 } 810 }
759 811
760 static ssize_t set_update_interval(struct device *dev, 812 static ssize_t set_update_interval(struct device *dev,
761 struct device_attribute *attr, 813 struct device_attribute *attr,
762 const char *buf, size_t count) 814 const char *buf, size_t count)
763 { 815 {
764 struct i2c_client *client = to_i2c_client(dev); 816 struct i2c_client *client = to_i2c_client(dev);
765 struct adm1031_data *data = i2c_get_clientdata(client); 817 struct adm1031_data *data = i2c_get_clientdata(client);
766 unsigned long val; 818 unsigned long val;
767 int i, err; 819 int i, err;
768 u8 reg; 820 u8 reg;
769 821
770 err = kstrtoul(buf, 10, &val); 822 err = kstrtoul(buf, 10, &val);
771 if (err) 823 if (err)
772 return err; 824 return err;
773 825
774 /* 826 /*
775 * Find the nearest update interval from the table. 827 * Find the nearest update interval from the table.
776 * Use it to determine the matching update rate. 828 * Use it to determine the matching update rate.
777 */ 829 */
778 for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) { 830 for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
779 if (val >= update_intervals[i]) 831 if (val >= update_intervals[i])
780 break; 832 break;
781 } 833 }
782 /* if not found, we point to the last entry (lowest update interval) */ 834 /* if not found, we point to the last entry (lowest update interval) */
783 835
784 /* set the new update rate while preserving other settings */ 836 /* set the new update rate while preserving other settings */
785 reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER); 837 reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
786 reg &= ~ADM1031_UPDATE_RATE_MASK; 838 reg &= ~ADM1031_UPDATE_RATE_MASK;
787 reg |= i << ADM1031_UPDATE_RATE_SHIFT; 839 reg |= i << ADM1031_UPDATE_RATE_SHIFT;
788 adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg); 840 adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
789 841
790 mutex_lock(&data->update_lock); 842 mutex_lock(&data->update_lock);
791 data->update_interval = update_intervals[i]; 843 data->update_interval = update_intervals[i];
792 mutex_unlock(&data->update_lock); 844 mutex_unlock(&data->update_lock);
793 845
794 return count; 846 return count;
795 } 847 }
796 848
797 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval, 849 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
798 set_update_interval); 850 set_update_interval);
799 851
800 static struct attribute *adm1031_attributes[] = { 852 static struct attribute *adm1031_attributes[] = {
801 &sensor_dev_attr_fan1_input.dev_attr.attr, 853 &sensor_dev_attr_fan1_input.dev_attr.attr,
802 &sensor_dev_attr_fan1_div.dev_attr.attr, 854 &sensor_dev_attr_fan1_div.dev_attr.attr,
803 &sensor_dev_attr_fan1_min.dev_attr.attr, 855 &sensor_dev_attr_fan1_min.dev_attr.attr,
804 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 856 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
805 &sensor_dev_attr_fan1_fault.dev_attr.attr, 857 &sensor_dev_attr_fan1_fault.dev_attr.attr,
806 &sensor_dev_attr_pwm1.dev_attr.attr, 858 &sensor_dev_attr_pwm1.dev_attr.attr,
807 &sensor_dev_attr_auto_fan1_channel.dev_attr.attr, 859 &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
808 &sensor_dev_attr_temp1_input.dev_attr.attr, 860 &sensor_dev_attr_temp1_input.dev_attr.attr,
809 &sensor_dev_attr_temp1_offset.dev_attr.attr, 861 &sensor_dev_attr_temp1_offset.dev_attr.attr,
810 &sensor_dev_attr_temp1_min.dev_attr.attr, 862 &sensor_dev_attr_temp1_min.dev_attr.attr,
811 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 863 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
812 &sensor_dev_attr_temp1_max.dev_attr.attr, 864 &sensor_dev_attr_temp1_max.dev_attr.attr,
813 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 865 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
814 &sensor_dev_attr_temp1_crit.dev_attr.attr, 866 &sensor_dev_attr_temp1_crit.dev_attr.attr,
815 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 867 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
816 &sensor_dev_attr_temp2_input.dev_attr.attr, 868 &sensor_dev_attr_temp2_input.dev_attr.attr,
817 &sensor_dev_attr_temp2_offset.dev_attr.attr, 869 &sensor_dev_attr_temp2_offset.dev_attr.attr,
818 &sensor_dev_attr_temp2_min.dev_attr.attr, 870 &sensor_dev_attr_temp2_min.dev_attr.attr,
819 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 871 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
820 &sensor_dev_attr_temp2_max.dev_attr.attr, 872 &sensor_dev_attr_temp2_max.dev_attr.attr,
821 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 873 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
822 &sensor_dev_attr_temp2_crit.dev_attr.attr, 874 &sensor_dev_attr_temp2_crit.dev_attr.attr,
823 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 875 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
824 &sensor_dev_attr_temp2_fault.dev_attr.attr, 876 &sensor_dev_attr_temp2_fault.dev_attr.attr,
825 877
826 &sensor_dev_attr_auto_temp1_off.dev_attr.attr, 878 &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
827 &sensor_dev_attr_auto_temp1_min.dev_attr.attr, 879 &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
828 &sensor_dev_attr_auto_temp1_max.dev_attr.attr, 880 &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
829 881
830 &sensor_dev_attr_auto_temp2_off.dev_attr.attr, 882 &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
831 &sensor_dev_attr_auto_temp2_min.dev_attr.attr, 883 &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
832 &sensor_dev_attr_auto_temp2_max.dev_attr.attr, 884 &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
833 885
834 &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr, 886 &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
835 887
836 &dev_attr_update_interval.attr, 888 &dev_attr_update_interval.attr,
837 &dev_attr_alarms.attr, 889 &dev_attr_alarms.attr,
838 890
839 NULL 891 NULL
840 }; 892 };
841 893
842 static const struct attribute_group adm1031_group = { 894 static const struct attribute_group adm1031_group = {
843 .attrs = adm1031_attributes, 895 .attrs = adm1031_attributes,
844 }; 896 };
845 897
846 static struct attribute *adm1031_attributes_opt[] = { 898 static struct attribute *adm1031_attributes_opt[] = {
847 &sensor_dev_attr_fan2_input.dev_attr.attr, 899 &sensor_dev_attr_fan2_input.dev_attr.attr,
848 &sensor_dev_attr_fan2_div.dev_attr.attr, 900 &sensor_dev_attr_fan2_div.dev_attr.attr,
849 &sensor_dev_attr_fan2_min.dev_attr.attr, 901 &sensor_dev_attr_fan2_min.dev_attr.attr,
850 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 902 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
851 &sensor_dev_attr_fan2_fault.dev_attr.attr, 903 &sensor_dev_attr_fan2_fault.dev_attr.attr,
852 &sensor_dev_attr_pwm2.dev_attr.attr, 904 &sensor_dev_attr_pwm2.dev_attr.attr,
853 &sensor_dev_attr_auto_fan2_channel.dev_attr.attr, 905 &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
854 &sensor_dev_attr_temp3_input.dev_attr.attr, 906 &sensor_dev_attr_temp3_input.dev_attr.attr,
855 &sensor_dev_attr_temp3_offset.dev_attr.attr, 907 &sensor_dev_attr_temp3_offset.dev_attr.attr,
856 &sensor_dev_attr_temp3_min.dev_attr.attr, 908 &sensor_dev_attr_temp3_min.dev_attr.attr,
857 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, 909 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
858 &sensor_dev_attr_temp3_max.dev_attr.attr, 910 &sensor_dev_attr_temp3_max.dev_attr.attr,
859 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 911 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
860 &sensor_dev_attr_temp3_crit.dev_attr.attr, 912 &sensor_dev_attr_temp3_crit.dev_attr.attr,
861 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 913 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
862 &sensor_dev_attr_temp3_fault.dev_attr.attr, 914 &sensor_dev_attr_temp3_fault.dev_attr.attr,
863 &sensor_dev_attr_auto_temp3_off.dev_attr.attr, 915 &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
864 &sensor_dev_attr_auto_temp3_min.dev_attr.attr, 916 &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
865 &sensor_dev_attr_auto_temp3_max.dev_attr.attr, 917 &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
866 &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr, 918 &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
867 NULL 919 NULL
868 }; 920 };
869 921
870 static const struct attribute_group adm1031_group_opt = { 922 static const struct attribute_group adm1031_group_opt = {
871 .attrs = adm1031_attributes_opt, 923 .attrs = adm1031_attributes_opt,
872 }; 924 };
873 925
874 /* Return 0 if detection is successful, -ENODEV otherwise */ 926 /* Return 0 if detection is successful, -ENODEV otherwise */
875 static int adm1031_detect(struct i2c_client *client, 927 static int adm1031_detect(struct i2c_client *client,
876 struct i2c_board_info *info) 928 struct i2c_board_info *info)
877 { 929 {
878 struct i2c_adapter *adapter = client->adapter; 930 struct i2c_adapter *adapter = client->adapter;
879 const char *name; 931 const char *name;
880 int id, co; 932 int id, co;
881 933
882 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 934 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
883 return -ENODEV; 935 return -ENODEV;
884 936
885 id = i2c_smbus_read_byte_data(client, 0x3d); 937 id = i2c_smbus_read_byte_data(client, 0x3d);
886 co = i2c_smbus_read_byte_data(client, 0x3e); 938 co = i2c_smbus_read_byte_data(client, 0x3e);
887 939
888 if (!((id == 0x31 || id == 0x30) && co == 0x41)) 940 if (!((id == 0x31 || id == 0x30) && co == 0x41))
889 return -ENODEV; 941 return -ENODEV;
890 name = (id == 0x30) ? "adm1030" : "adm1031"; 942 name = (id == 0x30) ? "adm1030" : "adm1031";
891 943
892 strlcpy(info->type, name, I2C_NAME_SIZE); 944 strlcpy(info->type, name, I2C_NAME_SIZE);
893 945
894 return 0; 946 return 0;
895 } 947 }
896 948
897 static int adm1031_probe(struct i2c_client *client, 949 static int adm1031_probe(struct i2c_client *client,
898 const struct i2c_device_id *id) 950 const struct i2c_device_id *id)
899 { 951 {
900 struct adm1031_data *data; 952 struct adm1031_data *data;
901 int err; 953 int err;
902 954
903 data = kzalloc(sizeof(struct adm1031_data), GFP_KERNEL); 955 data = kzalloc(sizeof(struct adm1031_data), GFP_KERNEL);
904 if (!data) { 956 if (!data) {
905 err = -ENOMEM; 957 err = -ENOMEM;
906 goto exit; 958 goto exit;
907 } 959 }
908 960
909 i2c_set_clientdata(client, data); 961 i2c_set_clientdata(client, data);
910 data->chip_type = id->driver_data; 962 data->chip_type = id->driver_data;
911 mutex_init(&data->update_lock); 963 mutex_init(&data->update_lock);
912 964
913 if (data->chip_type == adm1030) 965 if (data->chip_type == adm1030)
914 data->chan_select_table = &auto_channel_select_table_adm1030; 966 data->chan_select_table = &auto_channel_select_table_adm1030;
915 else 967 else
916 data->chan_select_table = &auto_channel_select_table_adm1031; 968 data->chan_select_table = &auto_channel_select_table_adm1031;
917 969
918 /* Initialize the ADM1031 chip */ 970 /* Initialize the ADM1031 chip */
919 adm1031_init_client(client); 971 adm1031_init_client(client);
920 972
921 /* Register sysfs hooks */ 973 /* Register sysfs hooks */
922 if ((err = sysfs_create_group(&client->dev.kobj, &adm1031_group))) 974 err = sysfs_create_group(&client->dev.kobj, &adm1031_group);
975 if (err)
923 goto exit_free; 976 goto exit_free;
924 977
925 if (data->chip_type == adm1031) { 978 if (data->chip_type == adm1031) {
926 if ((err = sysfs_create_group(&client->dev.kobj, 979 err = sysfs_create_group(&client->dev.kobj, &adm1031_group_opt);
927 &adm1031_group_opt))) 980 if (err)
928 goto exit_remove; 981 goto exit_remove;
929 } 982 }
930 983
931 data->hwmon_dev = hwmon_device_register(&client->dev); 984 data->hwmon_dev = hwmon_device_register(&client->dev);
932 if (IS_ERR(data->hwmon_dev)) { 985 if (IS_ERR(data->hwmon_dev)) {
933 err = PTR_ERR(data->hwmon_dev); 986 err = PTR_ERR(data->hwmon_dev);
934 goto exit_remove; 987 goto exit_remove;
935 } 988 }
936 989
937 return 0; 990 return 0;
938 991
939 exit_remove: 992 exit_remove:
940 sysfs_remove_group(&client->dev.kobj, &adm1031_group); 993 sysfs_remove_group(&client->dev.kobj, &adm1031_group);
941 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt); 994 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
942 exit_free: 995 exit_free:
943 kfree(data); 996 kfree(data);
944 exit: 997 exit:
945 return err; 998 return err;
946 } 999 }
947 1000
948 static int adm1031_remove(struct i2c_client *client) 1001 static int adm1031_remove(struct i2c_client *client)
949 { 1002 {
950 struct adm1031_data *data = i2c_get_clientdata(client); 1003 struct adm1031_data *data = i2c_get_clientdata(client);
951 1004
952 hwmon_device_unregister(data->hwmon_dev); 1005 hwmon_device_unregister(data->hwmon_dev);
953 sysfs_remove_group(&client->dev.kobj, &adm1031_group); 1006 sysfs_remove_group(&client->dev.kobj, &adm1031_group);
954 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt); 1007 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
955 kfree(data); 1008 kfree(data);
956 return 0; 1009 return 0;
957 } 1010 }
958 1011
959 static void adm1031_init_client(struct i2c_client *client) 1012 static void adm1031_init_client(struct i2c_client *client)
960 { 1013 {
961 unsigned int read_val; 1014 unsigned int read_val;
962 unsigned int mask; 1015 unsigned int mask;
963 int i; 1016 int i;
964 struct adm1031_data *data = i2c_get_clientdata(client); 1017 struct adm1031_data *data = i2c_get_clientdata(client);
965 1018
966 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE); 1019 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
967 if (data->chip_type == adm1031) { 1020 if (data->chip_type == adm1031) {
968 mask |= (ADM1031_CONF2_PWM2_ENABLE | 1021 mask |= (ADM1031_CONF2_PWM2_ENABLE |
969 ADM1031_CONF2_TACH2_ENABLE); 1022 ADM1031_CONF2_TACH2_ENABLE);
970 } 1023 }
971 /* Initialize the ADM1031 chip (enables fan speed reading ) */ 1024 /* Initialize the ADM1031 chip (enables fan speed reading ) */
972 read_val = adm1031_read_value(client, ADM1031_REG_CONF2); 1025 read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
973 if ((read_val | mask) != read_val) { 1026 if ((read_val | mask) != read_val)
974 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask); 1027 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
975 }
976 1028
977 read_val = adm1031_read_value(client, ADM1031_REG_CONF1); 1029 read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
978 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) { 1030 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
979 adm1031_write_value(client, ADM1031_REG_CONF1, read_val | 1031 adm1031_write_value(client, ADM1031_REG_CONF1,
980 ADM1031_CONF1_MONITOR_ENABLE); 1032 read_val | ADM1031_CONF1_MONITOR_ENABLE);
981 } 1033 }
982 1034
983 /* Read the chip's update rate */ 1035 /* Read the chip's update rate */
984 mask = ADM1031_UPDATE_RATE_MASK; 1036 mask = ADM1031_UPDATE_RATE_MASK;
985 read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER); 1037 read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
986 i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT; 1038 i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
987 /* Save it as update interval */ 1039 /* Save it as update interval */
988 data->update_interval = update_intervals[i]; 1040 data->update_interval = update_intervals[i];
989 } 1041 }
990 1042
991 static struct adm1031_data *adm1031_update_device(struct device *dev) 1043 static struct adm1031_data *adm1031_update_device(struct device *dev)
992 { 1044 {
993 struct i2c_client *client = to_i2c_client(dev); 1045 struct i2c_client *client = to_i2c_client(dev);
994 struct adm1031_data *data = i2c_get_clientdata(client); 1046 struct adm1031_data *data = i2c_get_clientdata(client);
995 unsigned long next_update; 1047 unsigned long next_update;
996 int chan; 1048 int chan;
997 1049
998 mutex_lock(&data->update_lock); 1050 mutex_lock(&data->update_lock);
999 1051
1000 next_update = data->last_updated 1052 next_update = data->last_updated
1001 + msecs_to_jiffies(data->update_interval); 1053 + msecs_to_jiffies(data->update_interval);
1002 if (time_after(jiffies, next_update) || !data->valid) { 1054 if (time_after(jiffies, next_update) || !data->valid) {
1003 1055
1004 dev_dbg(&client->dev, "Starting adm1031 update\n"); 1056 dev_dbg(&client->dev, "Starting adm1031 update\n");
1005 for (chan = 0; 1057 for (chan = 0;
1006 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) { 1058 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
1007 u8 oldh, newh; 1059 u8 oldh, newh;
1008 1060
1009 oldh = 1061 oldh =
1010 adm1031_read_value(client, ADM1031_REG_TEMP(chan)); 1062 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1011 data->ext_temp[chan] = 1063 data->ext_temp[chan] =
1012 adm1031_read_value(client, ADM1031_REG_EXT_TEMP); 1064 adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
1013 newh = 1065 newh =
1014 adm1031_read_value(client, ADM1031_REG_TEMP(chan)); 1066 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1015 if (newh != oldh) { 1067 if (newh != oldh) {
1016 data->ext_temp[chan] = 1068 data->ext_temp[chan] =
1017 adm1031_read_value(client, 1069 adm1031_read_value(client,
1018 ADM1031_REG_EXT_TEMP); 1070 ADM1031_REG_EXT_TEMP);
1019 #ifdef DEBUG 1071 #ifdef DEBUG
1020 oldh = 1072 oldh =
1021 adm1031_read_value(client, 1073 adm1031_read_value(client,
1022 ADM1031_REG_TEMP(chan)); 1074 ADM1031_REG_TEMP(chan));
1023 1075
1024 /* oldh is actually newer */ 1076 /* oldh is actually newer */
1025 if (newh != oldh) 1077 if (newh != oldh)
1026 dev_warn(&client->dev, 1078 dev_warn(&client->dev,
1027 "Remote temperature may be " 1079 "Remote temperature may be wrong.\n");
1028 "wrong.\n");
1029 #endif 1080 #endif
1030 } 1081 }
1031 data->temp[chan] = newh; 1082 data->temp[chan] = newh;
1032 1083
1033 data->temp_offset[chan] = 1084 data->temp_offset[chan] =
1034 adm1031_read_value(client, 1085 adm1031_read_value(client,
1035 ADM1031_REG_TEMP_OFFSET(chan)); 1086 ADM1031_REG_TEMP_OFFSET(chan));
1036 data->temp_min[chan] = 1087 data->temp_min[chan] =
1037 adm1031_read_value(client, 1088 adm1031_read_value(client,
1038 ADM1031_REG_TEMP_MIN(chan)); 1089 ADM1031_REG_TEMP_MIN(chan));
1039 data->temp_max[chan] = 1090 data->temp_max[chan] =
1040 adm1031_read_value(client, 1091 adm1031_read_value(client,
1041 ADM1031_REG_TEMP_MAX(chan)); 1092 ADM1031_REG_TEMP_MAX(chan));
1042 data->temp_crit[chan] = 1093 data->temp_crit[chan] =
1043 adm1031_read_value(client, 1094 adm1031_read_value(client,
1044 ADM1031_REG_TEMP_CRIT(chan)); 1095 ADM1031_REG_TEMP_CRIT(chan));
1045 data->auto_temp[chan] = 1096 data->auto_temp[chan] =
1046 adm1031_read_value(client, 1097 adm1031_read_value(client,
1047 ADM1031_REG_AUTO_TEMP(chan)); 1098 ADM1031_REG_AUTO_TEMP(chan));
1048 1099
1049 } 1100 }
1050 1101
1051 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1); 1102 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
1052 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2); 1103 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
1053 1104
1054 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0)) 1105 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
1055 | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) 1106 | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8);
1056 << 8); 1107 if (data->chip_type == adm1030)
1057 if (data->chip_type == adm1030) {
1058 data->alarm &= 0xc0ff; 1108 data->alarm &= 0xc0ff;
1059 }
1060 1109
1061 for (chan=0; chan<(data->chip_type == adm1030 ? 1 : 2); chan++) { 1110 for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2);
1111 chan++) {
1062 data->fan_div[chan] = 1112 data->fan_div[chan] =
1063 adm1031_read_value(client, ADM1031_REG_FAN_DIV(chan)); 1113 adm1031_read_value(client,
1114 ADM1031_REG_FAN_DIV(chan));
1064 data->fan_min[chan] = 1115 data->fan_min[chan] =
1065 adm1031_read_value(client, ADM1031_REG_FAN_MIN(chan)); 1116 adm1031_read_value(client,
1117 ADM1031_REG_FAN_MIN(chan));
1066 data->fan[chan] = 1118 data->fan[chan] =
1067 adm1031_read_value(client, ADM1031_REG_FAN_SPEED(chan)); 1119 adm1031_read_value(client,
1120 ADM1031_REG_FAN_SPEED(chan));
1068 data->pwm[chan] = 1121 data->pwm[chan] =
1069 0xf & (adm1031_read_value(client, ADM1031_REG_PWM) >> 1122 (adm1031_read_value(client,
1070 (4*chan)); 1123 ADM1031_REG_PWM) >> (4 * chan)) & 0x0f;
1071 } 1124 }
1072 data->last_updated = jiffies; 1125 data->last_updated = jiffies;
1073 data->valid = 1; 1126 data->valid = 1;
1074 } 1127 }
1075 1128
1076 mutex_unlock(&data->update_lock); 1129 mutex_unlock(&data->update_lock);
1077 1130
1078 return data; 1131 return data;
1079 } 1132 }
1080 1133
1081 static int __init sensors_adm1031_init(void) 1134 static int __init sensors_adm1031_init(void)
1082 { 1135 {
1083 return i2c_add_driver(&adm1031_driver); 1136 return i2c_add_driver(&adm1031_driver);
1084 } 1137 }
1085 1138
1086 static void __exit sensors_adm1031_exit(void) 1139 static void __exit sensors_adm1031_exit(void)
1087 { 1140 {
1088 i2c_del_driver(&adm1031_driver); 1141 i2c_del_driver(&adm1031_driver);
1089 } 1142 }
1090 1143
1091 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>"); 1144 MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1092 MODULE_DESCRIPTION("ADM1031/ADM1030 driver"); 1145 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1093 MODULE_LICENSE("GPL"); 1146 MODULE_LICENSE("GPL");