Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 4109a7160849604395eda57d6f011c8db3866482

Authored by Fengguang Wu
Committed by Guenter Roeck
1 parent e5840c78f3
Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch imx_3.14.28_1.0.0_ga

hwmon: (max6697) fix coccinelle warnings 

drivers/hwmon/max6697.c:649:1-3: WARNING: PTR_RET can be used

 Use PTR_ERR_OR_ZERO rather than if(IS_ERR(...)) + PTR_ERR

Generated by: coccinelle/api/ptr_ret.cocci

CC: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Fengguang Wu <fengguang.wu@intel.com>
Signed-off-by: Guenter Roeck <linux@roeck-us.net>

Showing 1 changed file with 1 additions and 4 deletions Inline Diff

drivers/hwmon/max6697.c
Diff comments   View file @ 4109a71
1 /* 1 /*
2 * Copyright (c) 2012 Guenter Roeck <linux@roeck-us.net> 2 * Copyright (c) 2012 Guenter Roeck <linux@roeck-us.net>
3 * 3 *
4 * based on max1668.c 4 * based on max1668.c
5 * Copyright (c) 2011 David George <david.george@ska.ac.za> 5 * Copyright (c) 2011 David George <david.george@ska.ac.za>
6 * 6 *
7 * This program is free software; you can redistribute it and/or modify 7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by 8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or 9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version. 10 * (at your option) any later version.
11 * 11 *
12 * This program is distributed in the hope that it will be useful, 12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details. 15 * GNU General Public License for more details.
16 */ 16 */
17 17
18 #include <linux/module.h> 18 #include <linux/module.h>
19 #include <linux/init.h> 19 #include <linux/init.h>
20 #include <linux/slab.h> 20 #include <linux/slab.h>
21 #include <linux/jiffies.h> 21 #include <linux/jiffies.h>
22 #include <linux/i2c.h> 22 #include <linux/i2c.h>
23 #include <linux/hwmon.h> 23 #include <linux/hwmon.h>
24 #include <linux/hwmon-sysfs.h> 24 #include <linux/hwmon-sysfs.h>
25 #include <linux/err.h> 25 #include <linux/err.h>
26 #include <linux/mutex.h> 26 #include <linux/mutex.h>
27 #include <linux/of.h> 27 #include <linux/of.h>
28 28
29 #include <linux/platform_data/max6697.h> 29 #include <linux/platform_data/max6697.h>
30 30
31 enum chips { max6581, max6602, max6622, max6636, max6689, max6693, max6694, 31 enum chips { max6581, max6602, max6622, max6636, max6689, max6693, max6694,
32 max6697, max6698, max6699 }; 32 max6697, max6698, max6699 };
33 33
34 /* Report local sensor as temp1 */ 34 /* Report local sensor as temp1 */
35 35
36 static const u8 MAX6697_REG_TEMP[] = { 36 static const u8 MAX6697_REG_TEMP[] = {
37 0x07, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08 }; 37 0x07, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08 };
38 static const u8 MAX6697_REG_TEMP_EXT[] = { 38 static const u8 MAX6697_REG_TEMP_EXT[] = {
39 0x57, 0x09, 0x52, 0x53, 0x54, 0x55, 0x56, 0 }; 39 0x57, 0x09, 0x52, 0x53, 0x54, 0x55, 0x56, 0 };
40 static const u8 MAX6697_REG_MAX[] = { 40 static const u8 MAX6697_REG_MAX[] = {
41 0x17, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x18 }; 41 0x17, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x18 };
42 static const u8 MAX6697_REG_CRIT[] = { 42 static const u8 MAX6697_REG_CRIT[] = {
43 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27 }; 43 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27 };
44 44
45 /* 45 /*
46 * Map device tree / platform data register bit map to chip bit map. 46 * Map device tree / platform data register bit map to chip bit map.
47 * Applies to alert register and over-temperature register. 47 * Applies to alert register and over-temperature register.
48 */ 48 */
49 #define MAX6697_MAP_BITS(reg) ((((reg) & 0x7e) >> 1) | \ 49 #define MAX6697_MAP_BITS(reg) ((((reg) & 0x7e) >> 1) | \
50 (((reg) & 0x01) << 6) | ((reg) & 0x80)) 50 (((reg) & 0x01) << 6) | ((reg) & 0x80))
51 51
52 #define MAX6697_REG_STAT(n) (0x44 + (n)) 52 #define MAX6697_REG_STAT(n) (0x44 + (n))
53 53
54 #define MAX6697_REG_CONFIG 0x41 54 #define MAX6697_REG_CONFIG 0x41
55 #define MAX6581_CONF_EXTENDED (1 << 1) 55 #define MAX6581_CONF_EXTENDED (1 << 1)
56 #define MAX6693_CONF_BETA (1 << 2) 56 #define MAX6693_CONF_BETA (1 << 2)
57 #define MAX6697_CONF_RESISTANCE (1 << 3) 57 #define MAX6697_CONF_RESISTANCE (1 << 3)
58 #define MAX6697_CONF_TIMEOUT (1 << 5) 58 #define MAX6697_CONF_TIMEOUT (1 << 5)
59 #define MAX6697_REG_ALERT_MASK 0x42 59 #define MAX6697_REG_ALERT_MASK 0x42
60 #define MAX6697_REG_OVERT_MASK 0x43 60 #define MAX6697_REG_OVERT_MASK 0x43
61 61
62 #define MAX6581_REG_RESISTANCE 0x4a 62 #define MAX6581_REG_RESISTANCE 0x4a
63 #define MAX6581_REG_IDEALITY 0x4b 63 #define MAX6581_REG_IDEALITY 0x4b
64 #define MAX6581_REG_IDEALITY_SELECT 0x4c 64 #define MAX6581_REG_IDEALITY_SELECT 0x4c
65 #define MAX6581_REG_OFFSET 0x4d 65 #define MAX6581_REG_OFFSET 0x4d
66 #define MAX6581_REG_OFFSET_SELECT 0x4e 66 #define MAX6581_REG_OFFSET_SELECT 0x4e
67 67
68 #define MAX6697_CONV_TIME 156 /* ms per channel, worst case */ 68 #define MAX6697_CONV_TIME 156 /* ms per channel, worst case */
69 69
70 struct max6697_chip_data { 70 struct max6697_chip_data {
71 int channels; 71 int channels;
72 u32 have_ext; 72 u32 have_ext;
73 u32 have_crit; 73 u32 have_crit;
74 u32 have_fault; 74 u32 have_fault;
75 u8 valid_conf; 75 u8 valid_conf;
76 const u8 *alarm_map; 76 const u8 *alarm_map;
77 }; 77 };
78 78
79 struct max6697_data { 79 struct max6697_data {
80 struct i2c_client *client; 80 struct i2c_client *client;
81 81
82 enum chips type; 82 enum chips type;
83 const struct max6697_chip_data *chip; 83 const struct max6697_chip_data *chip;
84 84
85 int update_interval; /* in milli-seconds */ 85 int update_interval; /* in milli-seconds */
86 int temp_offset; /* in degrees C */ 86 int temp_offset; /* in degrees C */
87 87
88 struct mutex update_lock; 88 struct mutex update_lock;
89 unsigned long last_updated; /* In jiffies */ 89 unsigned long last_updated; /* In jiffies */
90 bool valid; /* true if following fields are valid */ 90 bool valid; /* true if following fields are valid */
91 91
92 /* 1x local and up to 7x remote */ 92 /* 1x local and up to 7x remote */
93 u8 temp[8][4]; /* [nr][0]=temp [1]=ext [2]=max [3]=crit */ 93 u8 temp[8][4]; /* [nr][0]=temp [1]=ext [2]=max [3]=crit */
94 #define MAX6697_TEMP_INPUT 0 94 #define MAX6697_TEMP_INPUT 0
95 #define MAX6697_TEMP_EXT 1 95 #define MAX6697_TEMP_EXT 1
96 #define MAX6697_TEMP_MAX 2 96 #define MAX6697_TEMP_MAX 2
97 #define MAX6697_TEMP_CRIT 3 97 #define MAX6697_TEMP_CRIT 3
98 u32 alarms; 98 u32 alarms;
99 }; 99 };
100 100
101 /* Diode fault status bits on MAX6581 are right shifted by one bit */ 101 /* Diode fault status bits on MAX6581 are right shifted by one bit */
102 static const u8 max6581_alarm_map[] = { 102 static const u8 max6581_alarm_map[] = {
103 0, 0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 103 0, 0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15,
104 16, 17, 18, 19, 20, 21, 22, 23 }; 104 16, 17, 18, 19, 20, 21, 22, 23 };
105 105
106 static const struct max6697_chip_data max6697_chip_data[] = { 106 static const struct max6697_chip_data max6697_chip_data[] = {
107 [max6581] = { 107 [max6581] = {
108 .channels = 8, 108 .channels = 8,
109 .have_crit = 0xff, 109 .have_crit = 0xff,
110 .have_ext = 0x7f, 110 .have_ext = 0x7f,
111 .have_fault = 0xfe, 111 .have_fault = 0xfe,
112 .valid_conf = MAX6581_CONF_EXTENDED | MAX6697_CONF_TIMEOUT, 112 .valid_conf = MAX6581_CONF_EXTENDED | MAX6697_CONF_TIMEOUT,
113 .alarm_map = max6581_alarm_map, 113 .alarm_map = max6581_alarm_map,
114 }, 114 },
115 [max6602] = { 115 [max6602] = {
116 .channels = 5, 116 .channels = 5,
117 .have_crit = 0x12, 117 .have_crit = 0x12,
118 .have_ext = 0x02, 118 .have_ext = 0x02,
119 .have_fault = 0x1e, 119 .have_fault = 0x1e,
120 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT, 120 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT,
121 }, 121 },
122 [max6622] = { 122 [max6622] = {
123 .channels = 5, 123 .channels = 5,
124 .have_crit = 0x12, 124 .have_crit = 0x12,
125 .have_ext = 0x02, 125 .have_ext = 0x02,
126 .have_fault = 0x1e, 126 .have_fault = 0x1e,
127 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT, 127 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT,
128 }, 128 },
129 [max6636] = { 129 [max6636] = {
130 .channels = 7, 130 .channels = 7,
131 .have_crit = 0x72, 131 .have_crit = 0x72,
132 .have_ext = 0x02, 132 .have_ext = 0x02,
133 .have_fault = 0x7e, 133 .have_fault = 0x7e,
134 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT, 134 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT,
135 }, 135 },
136 [max6689] = { 136 [max6689] = {
137 .channels = 7, 137 .channels = 7,
138 .have_crit = 0x72, 138 .have_crit = 0x72,
139 .have_ext = 0x02, 139 .have_ext = 0x02,
140 .have_fault = 0x7e, 140 .have_fault = 0x7e,
141 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT, 141 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT,
142 }, 142 },
143 [max6693] = { 143 [max6693] = {
144 .channels = 7, 144 .channels = 7,
145 .have_crit = 0x72, 145 .have_crit = 0x72,
146 .have_ext = 0x02, 146 .have_ext = 0x02,
147 .have_fault = 0x7e, 147 .have_fault = 0x7e,
148 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6693_CONF_BETA | 148 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6693_CONF_BETA |
149 MAX6697_CONF_TIMEOUT, 149 MAX6697_CONF_TIMEOUT,
150 }, 150 },
151 [max6694] = { 151 [max6694] = {
152 .channels = 5, 152 .channels = 5,
153 .have_crit = 0x12, 153 .have_crit = 0x12,
154 .have_ext = 0x02, 154 .have_ext = 0x02,
155 .have_fault = 0x1e, 155 .have_fault = 0x1e,
156 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6693_CONF_BETA | 156 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6693_CONF_BETA |
157 MAX6697_CONF_TIMEOUT, 157 MAX6697_CONF_TIMEOUT,
158 }, 158 },
159 [max6697] = { 159 [max6697] = {
160 .channels = 7, 160 .channels = 7,
161 .have_crit = 0x72, 161 .have_crit = 0x72,
162 .have_ext = 0x02, 162 .have_ext = 0x02,
163 .have_fault = 0x7e, 163 .have_fault = 0x7e,
164 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT, 164 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT,
165 }, 165 },
166 [max6698] = { 166 [max6698] = {
167 .channels = 7, 167 .channels = 7,
168 .have_crit = 0x72, 168 .have_crit = 0x72,
169 .have_ext = 0x02, 169 .have_ext = 0x02,
170 .have_fault = 0x0e, 170 .have_fault = 0x0e,
171 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT, 171 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT,
172 }, 172 },
173 [max6699] = { 173 [max6699] = {
174 .channels = 5, 174 .channels = 5,
175 .have_crit = 0x12, 175 .have_crit = 0x12,
176 .have_ext = 0x02, 176 .have_ext = 0x02,
177 .have_fault = 0x1e, 177 .have_fault = 0x1e,
178 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT, 178 .valid_conf = MAX6697_CONF_RESISTANCE | MAX6697_CONF_TIMEOUT,
179 }, 179 },
180 }; 180 };
181 181
182 static struct max6697_data *max6697_update_device(struct device *dev) 182 static struct max6697_data *max6697_update_device(struct device *dev)
183 { 183 {
184 struct max6697_data *data = dev_get_drvdata(dev); 184 struct max6697_data *data = dev_get_drvdata(dev);
185 struct i2c_client *client = data->client; 185 struct i2c_client *client = data->client;
186 struct max6697_data *ret = data; 186 struct max6697_data *ret = data;
187 int val; 187 int val;
188 int i; 188 int i;
189 u32 alarms; 189 u32 alarms;
190 190
191 mutex_lock(&data->update_lock); 191 mutex_lock(&data->update_lock);
192 192
193 if (data->valid && 193 if (data->valid &&
194 !time_after(jiffies, data->last_updated 194 !time_after(jiffies, data->last_updated
195 + msecs_to_jiffies(data->update_interval))) 195 + msecs_to_jiffies(data->update_interval)))
196 goto abort; 196 goto abort;
197 197
198 for (i = 0; i < data->chip->channels; i++) { 198 for (i = 0; i < data->chip->channels; i++) {
199 if (data->chip->have_ext & (1 << i)) { 199 if (data->chip->have_ext & (1 << i)) {
200 val = i2c_smbus_read_byte_data(client, 200 val = i2c_smbus_read_byte_data(client,
201 MAX6697_REG_TEMP_EXT[i]); 201 MAX6697_REG_TEMP_EXT[i]);
202 if (unlikely(val < 0)) { 202 if (unlikely(val < 0)) {
203 ret = ERR_PTR(val); 203 ret = ERR_PTR(val);
204 goto abort; 204 goto abort;
205 } 205 }
206 data->temp[i][MAX6697_TEMP_EXT] = val; 206 data->temp[i][MAX6697_TEMP_EXT] = val;
207 } 207 }
208 208
209 val = i2c_smbus_read_byte_data(client, MAX6697_REG_TEMP[i]); 209 val = i2c_smbus_read_byte_data(client, MAX6697_REG_TEMP[i]);
210 if (unlikely(val < 0)) { 210 if (unlikely(val < 0)) {
211 ret = ERR_PTR(val); 211 ret = ERR_PTR(val);
212 goto abort; 212 goto abort;
213 } 213 }
214 data->temp[i][MAX6697_TEMP_INPUT] = val; 214 data->temp[i][MAX6697_TEMP_INPUT] = val;
215 215
216 val = i2c_smbus_read_byte_data(client, MAX6697_REG_MAX[i]); 216 val = i2c_smbus_read_byte_data(client, MAX6697_REG_MAX[i]);
217 if (unlikely(val < 0)) { 217 if (unlikely(val < 0)) {
218 ret = ERR_PTR(val); 218 ret = ERR_PTR(val);
219 goto abort; 219 goto abort;
220 } 220 }
221 data->temp[i][MAX6697_TEMP_MAX] = val; 221 data->temp[i][MAX6697_TEMP_MAX] = val;
222 222
223 if (data->chip->have_crit & (1 << i)) { 223 if (data->chip->have_crit & (1 << i)) {
224 val = i2c_smbus_read_byte_data(client, 224 val = i2c_smbus_read_byte_data(client,
225 MAX6697_REG_CRIT[i]); 225 MAX6697_REG_CRIT[i]);
226 if (unlikely(val < 0)) { 226 if (unlikely(val < 0)) {
227 ret = ERR_PTR(val); 227 ret = ERR_PTR(val);
228 goto abort; 228 goto abort;
229 } 229 }
230 data->temp[i][MAX6697_TEMP_CRIT] = val; 230 data->temp[i][MAX6697_TEMP_CRIT] = val;
231 } 231 }
232 } 232 }
233 233
234 alarms = 0; 234 alarms = 0;
235 for (i = 0; i < 3; i++) { 235 for (i = 0; i < 3; i++) {
236 val = i2c_smbus_read_byte_data(client, MAX6697_REG_STAT(i)); 236 val = i2c_smbus_read_byte_data(client, MAX6697_REG_STAT(i));
237 if (unlikely(val < 0)) { 237 if (unlikely(val < 0)) {
238 ret = ERR_PTR(val); 238 ret = ERR_PTR(val);
239 goto abort; 239 goto abort;
240 } 240 }
241 alarms = (alarms << 8) | val; 241 alarms = (alarms << 8) | val;
242 } 242 }
243 data->alarms = alarms; 243 data->alarms = alarms;
244 data->last_updated = jiffies; 244 data->last_updated = jiffies;
245 data->valid = true; 245 data->valid = true;
246 abort: 246 abort:
247 mutex_unlock(&data->update_lock); 247 mutex_unlock(&data->update_lock);
248 248
249 return ret; 249 return ret;
250 } 250 }
251 251
252 static ssize_t show_temp_input(struct device *dev, 252 static ssize_t show_temp_input(struct device *dev,
253 struct device_attribute *devattr, char *buf) 253 struct device_attribute *devattr, char *buf)
254 { 254 {
255 int index = to_sensor_dev_attr(devattr)->index; 255 int index = to_sensor_dev_attr(devattr)->index;
256 struct max6697_data *data = max6697_update_device(dev); 256 struct max6697_data *data = max6697_update_device(dev);
257 int temp; 257 int temp;
258 258
259 if (IS_ERR(data)) 259 if (IS_ERR(data))
260 return PTR_ERR(data); 260 return PTR_ERR(data);
261 261
262 temp = (data->temp[index][MAX6697_TEMP_INPUT] - data->temp_offset) << 3; 262 temp = (data->temp[index][MAX6697_TEMP_INPUT] - data->temp_offset) << 3;
263 temp |= data->temp[index][MAX6697_TEMP_EXT] >> 5; 263 temp |= data->temp[index][MAX6697_TEMP_EXT] >> 5;
264 264
265 return sprintf(buf, "%d\n", temp * 125); 265 return sprintf(buf, "%d\n", temp * 125);
266 } 266 }
267 267
268 static ssize_t show_temp(struct device *dev, 268 static ssize_t show_temp(struct device *dev,
269 struct device_attribute *devattr, char *buf) 269 struct device_attribute *devattr, char *buf)
270 { 270 {
271 int nr = to_sensor_dev_attr_2(devattr)->nr; 271 int nr = to_sensor_dev_attr_2(devattr)->nr;
272 int index = to_sensor_dev_attr_2(devattr)->index; 272 int index = to_sensor_dev_attr_2(devattr)->index;
273 struct max6697_data *data = max6697_update_device(dev); 273 struct max6697_data *data = max6697_update_device(dev);
274 int temp; 274 int temp;
275 275
276 if (IS_ERR(data)) 276 if (IS_ERR(data))
277 return PTR_ERR(data); 277 return PTR_ERR(data);
278 278
279 temp = data->temp[nr][index]; 279 temp = data->temp[nr][index];
280 temp -= data->temp_offset; 280 temp -= data->temp_offset;
281 281
282 return sprintf(buf, "%d\n", temp * 1000); 282 return sprintf(buf, "%d\n", temp * 1000);
283 } 283 }
284 284
285 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 285 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
286 char *buf) 286 char *buf)
287 { 287 {
288 int index = to_sensor_dev_attr(attr)->index; 288 int index = to_sensor_dev_attr(attr)->index;
289 struct max6697_data *data = max6697_update_device(dev); 289 struct max6697_data *data = max6697_update_device(dev);
290 290
291 if (IS_ERR(data)) 291 if (IS_ERR(data))
292 return PTR_ERR(data); 292 return PTR_ERR(data);
293 293
294 if (data->chip->alarm_map) 294 if (data->chip->alarm_map)
295 index = data->chip->alarm_map[index]; 295 index = data->chip->alarm_map[index];
296 296
297 return sprintf(buf, "%u\n", (data->alarms >> index) & 0x1); 297 return sprintf(buf, "%u\n", (data->alarms >> index) & 0x1);
298 } 298 }
299 299
300 static ssize_t set_temp(struct device *dev, 300 static ssize_t set_temp(struct device *dev,
301 struct device_attribute *devattr, 301 struct device_attribute *devattr,
302 const char *buf, size_t count) 302 const char *buf, size_t count)
303 { 303 {
304 int nr = to_sensor_dev_attr_2(devattr)->nr; 304 int nr = to_sensor_dev_attr_2(devattr)->nr;
305 int index = to_sensor_dev_attr_2(devattr)->index; 305 int index = to_sensor_dev_attr_2(devattr)->index;
306 struct max6697_data *data = dev_get_drvdata(dev); 306 struct max6697_data *data = dev_get_drvdata(dev);
307 long temp; 307 long temp;
308 int ret; 308 int ret;
309 309
310 ret = kstrtol(buf, 10, &temp); 310 ret = kstrtol(buf, 10, &temp);
311 if (ret < 0) 311 if (ret < 0)
312 return ret; 312 return ret;
313 313
314 mutex_lock(&data->update_lock); 314 mutex_lock(&data->update_lock);
315 temp = DIV_ROUND_CLOSEST(temp, 1000) + data->temp_offset; 315 temp = DIV_ROUND_CLOSEST(temp, 1000) + data->temp_offset;
316 temp = clamp_val(temp, 0, data->type == max6581 ? 255 : 127); 316 temp = clamp_val(temp, 0, data->type == max6581 ? 255 : 127);
317 data->temp[nr][index] = temp; 317 data->temp[nr][index] = temp;
318 ret = i2c_smbus_write_byte_data(data->client, 318 ret = i2c_smbus_write_byte_data(data->client,
319 index == 2 ? MAX6697_REG_MAX[nr] 319 index == 2 ? MAX6697_REG_MAX[nr]
320 : MAX6697_REG_CRIT[nr], 320 : MAX6697_REG_CRIT[nr],
321 temp); 321 temp);
322 mutex_unlock(&data->update_lock); 322 mutex_unlock(&data->update_lock);
323 323
324 return ret < 0 ? ret : count; 324 return ret < 0 ? ret : count;
325 } 325 }
326 326
327 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0); 327 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
328 static SENSOR_DEVICE_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, show_temp, set_temp, 328 static SENSOR_DEVICE_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
329 0, MAX6697_TEMP_MAX); 329 0, MAX6697_TEMP_MAX);
330 static SENSOR_DEVICE_ATTR_2(temp1_crit, S_IRUGO | S_IWUSR, show_temp, set_temp, 330 static SENSOR_DEVICE_ATTR_2(temp1_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
331 0, MAX6697_TEMP_CRIT); 331 0, MAX6697_TEMP_CRIT);
332 332
333 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1); 333 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1);
334 static SENSOR_DEVICE_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp, set_temp, 334 static SENSOR_DEVICE_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
335 1, MAX6697_TEMP_MAX); 335 1, MAX6697_TEMP_MAX);
336 static SENSOR_DEVICE_ATTR_2(temp2_crit, S_IRUGO | S_IWUSR, show_temp, set_temp, 336 static SENSOR_DEVICE_ATTR_2(temp2_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
337 1, MAX6697_TEMP_CRIT); 337 1, MAX6697_TEMP_CRIT);
338 338
339 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp_input, NULL, 2); 339 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp_input, NULL, 2);
340 static SENSOR_DEVICE_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp, set_temp, 340 static SENSOR_DEVICE_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
341 2, MAX6697_TEMP_MAX); 341 2, MAX6697_TEMP_MAX);
342 static SENSOR_DEVICE_ATTR_2(temp3_crit, S_IRUGO | S_IWUSR, show_temp, set_temp, 342 static SENSOR_DEVICE_ATTR_2(temp3_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
343 2, MAX6697_TEMP_CRIT); 343 2, MAX6697_TEMP_CRIT);
344 344
345 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp_input, NULL, 3); 345 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp_input, NULL, 3);
346 static SENSOR_DEVICE_ATTR_2(temp4_max, S_IRUGO | S_IWUSR, show_temp, set_temp, 346 static SENSOR_DEVICE_ATTR_2(temp4_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
347 3, MAX6697_TEMP_MAX); 347 3, MAX6697_TEMP_MAX);
348 static SENSOR_DEVICE_ATTR_2(temp4_crit, S_IRUGO | S_IWUSR, show_temp, set_temp, 348 static SENSOR_DEVICE_ATTR_2(temp4_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
349 3, MAX6697_TEMP_CRIT); 349 3, MAX6697_TEMP_CRIT);
350 350
351 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp_input, NULL, 4); 351 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp_input, NULL, 4);
352 static SENSOR_DEVICE_ATTR_2(temp5_max, S_IRUGO | S_IWUSR, show_temp, set_temp, 352 static SENSOR_DEVICE_ATTR_2(temp5_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
353 4, MAX6697_TEMP_MAX); 353 4, MAX6697_TEMP_MAX);
354 static SENSOR_DEVICE_ATTR_2(temp5_crit, S_IRUGO | S_IWUSR, show_temp, set_temp, 354 static SENSOR_DEVICE_ATTR_2(temp5_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
355 4, MAX6697_TEMP_CRIT); 355 4, MAX6697_TEMP_CRIT);
356 356
357 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp_input, NULL, 5); 357 static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp_input, NULL, 5);
358 static SENSOR_DEVICE_ATTR_2(temp6_max, S_IRUGO | S_IWUSR, show_temp, set_temp, 358 static SENSOR_DEVICE_ATTR_2(temp6_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
359 5, MAX6697_TEMP_MAX); 359 5, MAX6697_TEMP_MAX);
360 static SENSOR_DEVICE_ATTR_2(temp6_crit, S_IRUGO | S_IWUSR, show_temp, set_temp, 360 static SENSOR_DEVICE_ATTR_2(temp6_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
361 5, MAX6697_TEMP_CRIT); 361 5, MAX6697_TEMP_CRIT);
362 362
363 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO, show_temp_input, NULL, 6); 363 static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO, show_temp_input, NULL, 6);
364 static SENSOR_DEVICE_ATTR_2(temp7_max, S_IRUGO | S_IWUSR, show_temp, set_temp, 364 static SENSOR_DEVICE_ATTR_2(temp7_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
365 6, MAX6697_TEMP_MAX); 365 6, MAX6697_TEMP_MAX);
366 static SENSOR_DEVICE_ATTR_2(temp7_crit, S_IRUGO | S_IWUSR, show_temp, set_temp, 366 static SENSOR_DEVICE_ATTR_2(temp7_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
367 6, MAX6697_TEMP_CRIT); 367 6, MAX6697_TEMP_CRIT);
368 368
369 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO, show_temp_input, NULL, 7); 369 static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO, show_temp_input, NULL, 7);
370 static SENSOR_DEVICE_ATTR_2(temp8_max, S_IRUGO | S_IWUSR, show_temp, set_temp, 370 static SENSOR_DEVICE_ATTR_2(temp8_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
371 7, MAX6697_TEMP_MAX); 371 7, MAX6697_TEMP_MAX);
372 static SENSOR_DEVICE_ATTR_2(temp8_crit, S_IRUGO | S_IWUSR, show_temp, set_temp, 372 static SENSOR_DEVICE_ATTR_2(temp8_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
373 7, MAX6697_TEMP_CRIT); 373 7, MAX6697_TEMP_CRIT);
374 374
375 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 22); 375 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 22);
376 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 16); 376 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 16);
377 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 17); 377 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 17);
378 static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 18); 378 static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 18);
379 static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO, show_alarm, NULL, 19); 379 static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO, show_alarm, NULL, 19);
380 static SENSOR_DEVICE_ATTR(temp6_max_alarm, S_IRUGO, show_alarm, NULL, 20); 380 static SENSOR_DEVICE_ATTR(temp6_max_alarm, S_IRUGO, show_alarm, NULL, 20);
381 static SENSOR_DEVICE_ATTR(temp7_max_alarm, S_IRUGO, show_alarm, NULL, 21); 381 static SENSOR_DEVICE_ATTR(temp7_max_alarm, S_IRUGO, show_alarm, NULL, 21);
382 static SENSOR_DEVICE_ATTR(temp8_max_alarm, S_IRUGO, show_alarm, NULL, 23); 382 static SENSOR_DEVICE_ATTR(temp8_max_alarm, S_IRUGO, show_alarm, NULL, 23);
383 383
384 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14); 384 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
385 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 8); 385 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 8);
386 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 9); 386 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 9);
387 static SENSOR_DEVICE_ATTR(temp4_crit_alarm, S_IRUGO, show_alarm, NULL, 10); 387 static SENSOR_DEVICE_ATTR(temp4_crit_alarm, S_IRUGO, show_alarm, NULL, 10);
388 static SENSOR_DEVICE_ATTR(temp5_crit_alarm, S_IRUGO, show_alarm, NULL, 11); 388 static SENSOR_DEVICE_ATTR(temp5_crit_alarm, S_IRUGO, show_alarm, NULL, 11);
389 static SENSOR_DEVICE_ATTR(temp6_crit_alarm, S_IRUGO, show_alarm, NULL, 12); 389 static SENSOR_DEVICE_ATTR(temp6_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
390 static SENSOR_DEVICE_ATTR(temp7_crit_alarm, S_IRUGO, show_alarm, NULL, 13); 390 static SENSOR_DEVICE_ATTR(temp7_crit_alarm, S_IRUGO, show_alarm, NULL, 13);
391 static SENSOR_DEVICE_ATTR(temp8_crit_alarm, S_IRUGO, show_alarm, NULL, 15); 391 static SENSOR_DEVICE_ATTR(temp8_crit_alarm, S_IRUGO, show_alarm, NULL, 15);
392 392
393 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 1); 393 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 1);
394 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 2); 394 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 2);
395 static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_alarm, NULL, 3); 395 static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_alarm, NULL, 3);
396 static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_alarm, NULL, 4); 396 static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_alarm, NULL, 4);
397 static SENSOR_DEVICE_ATTR(temp6_fault, S_IRUGO, show_alarm, NULL, 5); 397 static SENSOR_DEVICE_ATTR(temp6_fault, S_IRUGO, show_alarm, NULL, 5);
398 static SENSOR_DEVICE_ATTR(temp7_fault, S_IRUGO, show_alarm, NULL, 6); 398 static SENSOR_DEVICE_ATTR(temp7_fault, S_IRUGO, show_alarm, NULL, 6);
399 static SENSOR_DEVICE_ATTR(temp8_fault, S_IRUGO, show_alarm, NULL, 7); 399 static SENSOR_DEVICE_ATTR(temp8_fault, S_IRUGO, show_alarm, NULL, 7);
400 400
401 static DEVICE_ATTR(dummy, 0, NULL, NULL); 401 static DEVICE_ATTR(dummy, 0, NULL, NULL);
402 402
403 static umode_t max6697_is_visible(struct kobject *kobj, struct attribute *attr, 403 static umode_t max6697_is_visible(struct kobject *kobj, struct attribute *attr,
404 int index) 404 int index)
405 { 405 {
406 struct device *dev = container_of(kobj, struct device, kobj); 406 struct device *dev = container_of(kobj, struct device, kobj);
407 struct max6697_data *data = dev_get_drvdata(dev); 407 struct max6697_data *data = dev_get_drvdata(dev);
408 const struct max6697_chip_data *chip = data->chip; 408 const struct max6697_chip_data *chip = data->chip;
409 int channel = index / 6; /* channel number */ 409 int channel = index / 6; /* channel number */
410 int nr = index % 6; /* attribute index within channel */ 410 int nr = index % 6; /* attribute index within channel */
411 411
412 if (channel >= chip->channels) 412 if (channel >= chip->channels)
413 return 0; 413 return 0;
414 414
415 if ((nr == 3 || nr == 4) && !(chip->have_crit & (1 << channel))) 415 if ((nr == 3 || nr == 4) && !(chip->have_crit & (1 << channel)))
416 return 0; 416 return 0;
417 if (nr == 5 && !(chip->have_fault & (1 << channel))) 417 if (nr == 5 && !(chip->have_fault & (1 << channel)))
418 return 0; 418 return 0;
419 419
420 return attr->mode; 420 return attr->mode;
421 } 421 }
422 422
423 /* 423 /*
424 * max6697_is_visible uses the index into the following array to determine 424 * max6697_is_visible uses the index into the following array to determine
425 * if attributes should be created or not. Any change in order or content 425 * if attributes should be created or not. Any change in order or content
426 * must be matched in max6697_is_visible. 426 * must be matched in max6697_is_visible.
427 */ 427 */
428 static struct attribute *max6697_attributes[] = { 428 static struct attribute *max6697_attributes[] = {
429 &sensor_dev_attr_temp1_input.dev_attr.attr, 429 &sensor_dev_attr_temp1_input.dev_attr.attr,
430 &sensor_dev_attr_temp1_max.dev_attr.attr, 430 &sensor_dev_attr_temp1_max.dev_attr.attr,
431 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 431 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
432 &sensor_dev_attr_temp1_crit.dev_attr.attr, 432 &sensor_dev_attr_temp1_crit.dev_attr.attr,
433 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 433 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
434 &dev_attr_dummy.attr, 434 &dev_attr_dummy.attr,
435 435
436 &sensor_dev_attr_temp2_input.dev_attr.attr, 436 &sensor_dev_attr_temp2_input.dev_attr.attr,
437 &sensor_dev_attr_temp2_max.dev_attr.attr, 437 &sensor_dev_attr_temp2_max.dev_attr.attr,
438 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 438 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
439 &sensor_dev_attr_temp2_crit.dev_attr.attr, 439 &sensor_dev_attr_temp2_crit.dev_attr.attr,
440 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 440 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
441 &sensor_dev_attr_temp2_fault.dev_attr.attr, 441 &sensor_dev_attr_temp2_fault.dev_attr.attr,
442 442
443 &sensor_dev_attr_temp3_input.dev_attr.attr, 443 &sensor_dev_attr_temp3_input.dev_attr.attr,
444 &sensor_dev_attr_temp3_max.dev_attr.attr, 444 &sensor_dev_attr_temp3_max.dev_attr.attr,
445 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 445 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
446 &sensor_dev_attr_temp3_crit.dev_attr.attr, 446 &sensor_dev_attr_temp3_crit.dev_attr.attr,
447 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 447 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
448 &sensor_dev_attr_temp3_fault.dev_attr.attr, 448 &sensor_dev_attr_temp3_fault.dev_attr.attr,
449 449
450 &sensor_dev_attr_temp4_input.dev_attr.attr, 450 &sensor_dev_attr_temp4_input.dev_attr.attr,
451 &sensor_dev_attr_temp4_max.dev_attr.attr, 451 &sensor_dev_attr_temp4_max.dev_attr.attr,
452 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr, 452 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
453 &sensor_dev_attr_temp4_crit.dev_attr.attr, 453 &sensor_dev_attr_temp4_crit.dev_attr.attr,
454 &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr, 454 &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr,
455 &sensor_dev_attr_temp4_fault.dev_attr.attr, 455 &sensor_dev_attr_temp4_fault.dev_attr.attr,
456 456
457 &sensor_dev_attr_temp5_input.dev_attr.attr, 457 &sensor_dev_attr_temp5_input.dev_attr.attr,
458 &sensor_dev_attr_temp5_max.dev_attr.attr, 458 &sensor_dev_attr_temp5_max.dev_attr.attr,
459 &sensor_dev_attr_temp5_max_alarm.dev_attr.attr, 459 &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
460 &sensor_dev_attr_temp5_crit.dev_attr.attr, 460 &sensor_dev_attr_temp5_crit.dev_attr.attr,
461 &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr, 461 &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr,
462 &sensor_dev_attr_temp5_fault.dev_attr.attr, 462 &sensor_dev_attr_temp5_fault.dev_attr.attr,
463 463
464 &sensor_dev_attr_temp6_input.dev_attr.attr, 464 &sensor_dev_attr_temp6_input.dev_attr.attr,
465 &sensor_dev_attr_temp6_max.dev_attr.attr, 465 &sensor_dev_attr_temp6_max.dev_attr.attr,
466 &sensor_dev_attr_temp6_max_alarm.dev_attr.attr, 466 &sensor_dev_attr_temp6_max_alarm.dev_attr.attr,
467 &sensor_dev_attr_temp6_crit.dev_attr.attr, 467 &sensor_dev_attr_temp6_crit.dev_attr.attr,
468 &sensor_dev_attr_temp6_crit_alarm.dev_attr.attr, 468 &sensor_dev_attr_temp6_crit_alarm.dev_attr.attr,
469 &sensor_dev_attr_temp6_fault.dev_attr.attr, 469 &sensor_dev_attr_temp6_fault.dev_attr.attr,
470 470
471 &sensor_dev_attr_temp7_input.dev_attr.attr, 471 &sensor_dev_attr_temp7_input.dev_attr.attr,
472 &sensor_dev_attr_temp7_max.dev_attr.attr, 472 &sensor_dev_attr_temp7_max.dev_attr.attr,
473 &sensor_dev_attr_temp7_max_alarm.dev_attr.attr, 473 &sensor_dev_attr_temp7_max_alarm.dev_attr.attr,
474 &sensor_dev_attr_temp7_crit.dev_attr.attr, 474 &sensor_dev_attr_temp7_crit.dev_attr.attr,
475 &sensor_dev_attr_temp7_crit_alarm.dev_attr.attr, 475 &sensor_dev_attr_temp7_crit_alarm.dev_attr.attr,
476 &sensor_dev_attr_temp7_fault.dev_attr.attr, 476 &sensor_dev_attr_temp7_fault.dev_attr.attr,
477 477
478 &sensor_dev_attr_temp8_input.dev_attr.attr, 478 &sensor_dev_attr_temp8_input.dev_attr.attr,
479 &sensor_dev_attr_temp8_max.dev_attr.attr, 479 &sensor_dev_attr_temp8_max.dev_attr.attr,
480 &sensor_dev_attr_temp8_max_alarm.dev_attr.attr, 480 &sensor_dev_attr_temp8_max_alarm.dev_attr.attr,
481 &sensor_dev_attr_temp8_crit.dev_attr.attr, 481 &sensor_dev_attr_temp8_crit.dev_attr.attr,
482 &sensor_dev_attr_temp8_crit_alarm.dev_attr.attr, 482 &sensor_dev_attr_temp8_crit_alarm.dev_attr.attr,
483 &sensor_dev_attr_temp8_fault.dev_attr.attr, 483 &sensor_dev_attr_temp8_fault.dev_attr.attr,
484 NULL 484 NULL
485 }; 485 };
486 486
487 static const struct attribute_group max6697_group = { 487 static const struct attribute_group max6697_group = {
488 .attrs = max6697_attributes, .is_visible = max6697_is_visible, 488 .attrs = max6697_attributes, .is_visible = max6697_is_visible,
489 }; 489 };
490 __ATTRIBUTE_GROUPS(max6697); 490 __ATTRIBUTE_GROUPS(max6697);
491 491
492 static void max6697_get_config_of(struct device_node *node, 492 static void max6697_get_config_of(struct device_node *node,
493 struct max6697_platform_data *pdata) 493 struct max6697_platform_data *pdata)
494 { 494 {
495 int len; 495 int len;
496 const __be32 *prop; 496 const __be32 *prop;
497 497
498 prop = of_get_property(node, "smbus-timeout-disable", &len); 498 prop = of_get_property(node, "smbus-timeout-disable", &len);
499 if (prop) 499 if (prop)
500 pdata->smbus_timeout_disable = true; 500 pdata->smbus_timeout_disable = true;
501 prop = of_get_property(node, "extended-range-enable", &len); 501 prop = of_get_property(node, "extended-range-enable", &len);
502 if (prop) 502 if (prop)
503 pdata->extended_range_enable = true; 503 pdata->extended_range_enable = true;
504 prop = of_get_property(node, "beta-compensation-enable", &len); 504 prop = of_get_property(node, "beta-compensation-enable", &len);
505 if (prop) 505 if (prop)
506 pdata->beta_compensation = true; 506 pdata->beta_compensation = true;
507 prop = of_get_property(node, "alert-mask", &len); 507 prop = of_get_property(node, "alert-mask", &len);
508 if (prop && len == sizeof(u32)) 508 if (prop && len == sizeof(u32))
509 pdata->alert_mask = be32_to_cpu(prop[0]); 509 pdata->alert_mask = be32_to_cpu(prop[0]);
510 prop = of_get_property(node, "over-temperature-mask", &len); 510 prop = of_get_property(node, "over-temperature-mask", &len);
511 if (prop && len == sizeof(u32)) 511 if (prop && len == sizeof(u32))
512 pdata->over_temperature_mask = be32_to_cpu(prop[0]); 512 pdata->over_temperature_mask = be32_to_cpu(prop[0]);
513 prop = of_get_property(node, "resistance-cancellation", &len); 513 prop = of_get_property(node, "resistance-cancellation", &len);
514 if (prop) { 514 if (prop) {
515 if (len == sizeof(u32)) 515 if (len == sizeof(u32))
516 pdata->resistance_cancellation = be32_to_cpu(prop[0]); 516 pdata->resistance_cancellation = be32_to_cpu(prop[0]);
517 else 517 else
518 pdata->resistance_cancellation = 0xfe; 518 pdata->resistance_cancellation = 0xfe;
519 } 519 }
520 prop = of_get_property(node, "transistor-ideality", &len); 520 prop = of_get_property(node, "transistor-ideality", &len);
521 if (prop && len == 2 * sizeof(u32)) { 521 if (prop && len == 2 * sizeof(u32)) {
522 pdata->ideality_mask = be32_to_cpu(prop[0]); 522 pdata->ideality_mask = be32_to_cpu(prop[0]);
523 pdata->ideality_value = be32_to_cpu(prop[1]); 523 pdata->ideality_value = be32_to_cpu(prop[1]);
524 } 524 }
525 } 525 }
526 526
527 static int max6697_init_chip(struct max6697_data *data, 527 static int max6697_init_chip(struct max6697_data *data,
528 struct i2c_client *client) 528 struct i2c_client *client)
529 { 529 {
530 struct max6697_platform_data *pdata = dev_get_platdata(&client->dev); 530 struct max6697_platform_data *pdata = dev_get_platdata(&client->dev);
531 struct max6697_platform_data p; 531 struct max6697_platform_data p;
532 const struct max6697_chip_data *chip = data->chip; 532 const struct max6697_chip_data *chip = data->chip;
533 int factor = chip->channels; 533 int factor = chip->channels;
534 int ret, reg; 534 int ret, reg;
535 535
536 /* 536 /*
537 * Don't touch configuration if neither platform data nor OF 537 * Don't touch configuration if neither platform data nor OF
538 * configuration was specified. If that is the case, use the 538 * configuration was specified. If that is the case, use the
539 * current chip configuration. 539 * current chip configuration.
540 */ 540 */
541 if (!pdata && !client->dev.of_node) { 541 if (!pdata && !client->dev.of_node) {
542 reg = i2c_smbus_read_byte_data(client, MAX6697_REG_CONFIG); 542 reg = i2c_smbus_read_byte_data(client, MAX6697_REG_CONFIG);
543 if (reg < 0) 543 if (reg < 0)
544 return reg; 544 return reg;
545 if (data->type == max6581) { 545 if (data->type == max6581) {
546 if (reg & MAX6581_CONF_EXTENDED) 546 if (reg & MAX6581_CONF_EXTENDED)
547 data->temp_offset = 64; 547 data->temp_offset = 64;
548 reg = i2c_smbus_read_byte_data(client, 548 reg = i2c_smbus_read_byte_data(client,
549 MAX6581_REG_RESISTANCE); 549 MAX6581_REG_RESISTANCE);
550 if (reg < 0) 550 if (reg < 0)
551 return reg; 551 return reg;
552 factor += hweight8(reg); 552 factor += hweight8(reg);
553 } else { 553 } else {
554 if (reg & MAX6697_CONF_RESISTANCE) 554 if (reg & MAX6697_CONF_RESISTANCE)
555 factor++; 555 factor++;
556 } 556 }
557 goto done; 557 goto done;
558 } 558 }
559 559
560 if (client->dev.of_node) { 560 if (client->dev.of_node) {
561 memset(&p, 0, sizeof(p)); 561 memset(&p, 0, sizeof(p));
562 max6697_get_config_of(client->dev.of_node, &p); 562 max6697_get_config_of(client->dev.of_node, &p);
563 pdata = &p; 563 pdata = &p;
564 } 564 }
565 565
566 reg = 0; 566 reg = 0;
567 if (pdata->smbus_timeout_disable && 567 if (pdata->smbus_timeout_disable &&
568 (chip->valid_conf & MAX6697_CONF_TIMEOUT)) { 568 (chip->valid_conf & MAX6697_CONF_TIMEOUT)) {
569 reg |= MAX6697_CONF_TIMEOUT; 569 reg |= MAX6697_CONF_TIMEOUT;
570 } 570 }
571 if (pdata->extended_range_enable && 571 if (pdata->extended_range_enable &&
572 (chip->valid_conf & MAX6581_CONF_EXTENDED)) { 572 (chip->valid_conf & MAX6581_CONF_EXTENDED)) {
573 reg |= MAX6581_CONF_EXTENDED; 573 reg |= MAX6581_CONF_EXTENDED;
574 data->temp_offset = 64; 574 data->temp_offset = 64;
575 } 575 }
576 if (pdata->resistance_cancellation && 576 if (pdata->resistance_cancellation &&
577 (chip->valid_conf & MAX6697_CONF_RESISTANCE)) { 577 (chip->valid_conf & MAX6697_CONF_RESISTANCE)) {
578 reg |= MAX6697_CONF_RESISTANCE; 578 reg |= MAX6697_CONF_RESISTANCE;
579 factor++; 579 factor++;
580 } 580 }
581 if (pdata->beta_compensation && 581 if (pdata->beta_compensation &&
582 (chip->valid_conf & MAX6693_CONF_BETA)) { 582 (chip->valid_conf & MAX6693_CONF_BETA)) {
583 reg |= MAX6693_CONF_BETA; 583 reg |= MAX6693_CONF_BETA;
584 } 584 }
585 585
586 ret = i2c_smbus_write_byte_data(client, MAX6697_REG_CONFIG, reg); 586 ret = i2c_smbus_write_byte_data(client, MAX6697_REG_CONFIG, reg);
587 if (ret < 0) 587 if (ret < 0)
588 return ret; 588 return ret;
589 589
590 ret = i2c_smbus_write_byte_data(client, MAX6697_REG_ALERT_MASK, 590 ret = i2c_smbus_write_byte_data(client, MAX6697_REG_ALERT_MASK,
591 MAX6697_MAP_BITS(pdata->alert_mask)); 591 MAX6697_MAP_BITS(pdata->alert_mask));
592 if (ret < 0) 592 if (ret < 0)
593 return ret; 593 return ret;
594 594
595 ret = i2c_smbus_write_byte_data(client, MAX6697_REG_OVERT_MASK, 595 ret = i2c_smbus_write_byte_data(client, MAX6697_REG_OVERT_MASK,
596 MAX6697_MAP_BITS(pdata->over_temperature_mask)); 596 MAX6697_MAP_BITS(pdata->over_temperature_mask));
597 if (ret < 0) 597 if (ret < 0)
598 return ret; 598 return ret;
599 599
600 if (data->type == max6581) { 600 if (data->type == max6581) {
601 factor += hweight8(pdata->resistance_cancellation >> 1); 601 factor += hweight8(pdata->resistance_cancellation >> 1);
602 ret = i2c_smbus_write_byte_data(client, MAX6581_REG_RESISTANCE, 602 ret = i2c_smbus_write_byte_data(client, MAX6581_REG_RESISTANCE,
603 pdata->resistance_cancellation >> 1); 603 pdata->resistance_cancellation >> 1);
604 if (ret < 0) 604 if (ret < 0)
605 return ret; 605 return ret;
606 ret = i2c_smbus_write_byte_data(client, MAX6581_REG_IDEALITY, 606 ret = i2c_smbus_write_byte_data(client, MAX6581_REG_IDEALITY,
607 pdata->ideality_value); 607 pdata->ideality_value);
608 if (ret < 0) 608 if (ret < 0)
609 return ret; 609 return ret;
610 ret = i2c_smbus_write_byte_data(client, 610 ret = i2c_smbus_write_byte_data(client,
611 MAX6581_REG_IDEALITY_SELECT, 611 MAX6581_REG_IDEALITY_SELECT,
612 pdata->ideality_mask >> 1); 612 pdata->ideality_mask >> 1);
613 if (ret < 0) 613 if (ret < 0)
614 return ret; 614 return ret;
615 } 615 }
616 done: 616 done:
617 data->update_interval = factor * MAX6697_CONV_TIME; 617 data->update_interval = factor * MAX6697_CONV_TIME;
618 return 0; 618 return 0;
619 } 619 }
620 620
621 static int max6697_probe(struct i2c_client *client, 621 static int max6697_probe(struct i2c_client *client,
622 const struct i2c_device_id *id) 622 const struct i2c_device_id *id)
623 { 623 {
624 struct i2c_adapter *adapter = client->adapter; 624 struct i2c_adapter *adapter = client->adapter;
625 struct device *dev = &client->dev; 625 struct device *dev = &client->dev;
626 struct max6697_data *data; 626 struct max6697_data *data;
627 struct device *hwmon_dev; 627 struct device *hwmon_dev;
628 int err; 628 int err;
629 629
630 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 630 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
631 return -ENODEV; 631 return -ENODEV;
632 632
633 data = devm_kzalloc(dev, sizeof(struct max6697_data), GFP_KERNEL); 633 data = devm_kzalloc(dev, sizeof(struct max6697_data), GFP_KERNEL);
634 if (!data) 634 if (!data)
635 return -ENOMEM; 635 return -ENOMEM;
636 636
637 data->type = id->driver_data; 637 data->type = id->driver_data;
638 data->chip = &max6697_chip_data[data->type]; 638 data->chip = &max6697_chip_data[data->type];
639 data->client = client; 639 data->client = client;
640 mutex_init(&data->update_lock); 640 mutex_init(&data->update_lock);
641 641
642 err = max6697_init_chip(data, client); 642 err = max6697_init_chip(data, client);
643 if (err) 643 if (err)
644 return err; 644 return err;
645 645
646 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 646 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
647 data, 647 data,
648 max6697_groups); 648 max6697_groups);
649 if (IS_ERR(hwmon_dev)) 649 return PTR_ERR_OR_ZERO(hwmon_dev);
650 return PTR_ERR(hwmon_dev);
651
652 return 0;
653 } 650 }
654 651
655 static const struct i2c_device_id max6697_id[] = { 652 static const struct i2c_device_id max6697_id[] = {
656 { "max6581", max6581 }, 653 { "max6581", max6581 },
657 { "max6602", max6602 }, 654 { "max6602", max6602 },
658 { "max6622", max6622 }, 655 { "max6622", max6622 },
659 { "max6636", max6636 }, 656 { "max6636", max6636 },
660 { "max6689", max6689 }, 657 { "max6689", max6689 },
661 { "max6693", max6693 }, 658 { "max6693", max6693 },
662 { "max6694", max6694 }, 659 { "max6694", max6694 },
663 { "max6697", max6697 }, 660 { "max6697", max6697 },
664 { "max6698", max6698 }, 661 { "max6698", max6698 },
665 { "max6699", max6699 }, 662 { "max6699", max6699 },
666 { } 663 { }
667 }; 664 };
668 MODULE_DEVICE_TABLE(i2c, max6697_id); 665 MODULE_DEVICE_TABLE(i2c, max6697_id);
669 666
670 static struct i2c_driver max6697_driver = { 667 static struct i2c_driver max6697_driver = {
671 .class = I2C_CLASS_HWMON, 668 .class = I2C_CLASS_HWMON,
672 .driver = { 669 .driver = {
673 .name = "max6697", 670 .name = "max6697",
674 }, 671 },
675 .probe = max6697_probe, 672 .probe = max6697_probe,
676 .id_table = max6697_id, 673 .id_table = max6697_id,
677 }; 674 };
678 675
679 module_i2c_driver(max6697_driver); 676 module_i2c_driver(max6697_driver);
680 677
681 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>"); 678 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
682 MODULE_DESCRIPTION("MAX6697 temperature sensor driver"); 679 MODULE_DESCRIPTION("MAX6697 temperature sensor driver");
683 MODULE_LICENSE("GPL"); 680 MODULE_LICENSE("GPL");
684 681