forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/drivers/hwmon/adm9240.c
....@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /*
23  * adm9240.c	Part of lm_sensors, Linux kernel modules for hardware
34  *		monitoring
....@@ -25,20 +26,6 @@
2526  * Test hardware: Intel SE440BX-2 desktop motherboard --Grant
2627  *
2728  * LM81 extended temp reading not implemented
28
- *
29
- * This program is free software; you can redistribute it and/or modify
30
- * it under the terms of the GNU General Public License as published by
31
- * the Free Software Foundation; either version 2 of the License, or
32
- * (at your option) any later version.
33
- *
34
- * This program is distributed in the hope that it will be useful,
35
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
36
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
37
- * GNU General Public License for more details.
38
- *
39
- * You should have received a copy of the GNU General Public License
40
- * along with this program; if not, write to the Free Software
41
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
4229  */
4330 
4431 #include <linux/init.h>
....@@ -51,6 +38,7 @@
5138 #include <linux/err.h>
5239 #include <linux/mutex.h>
5340 #include <linux/jiffies.h>
41
+#include <linux/regmap.h>
5442 
5543 /* Addresses to scan */
5644 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
....@@ -136,6 +124,7 @@
136124 /* per client data */
137125 struct adm9240_data {
138126 	struct i2c_client *client;
127
+	struct regmap *regmap;
139128 	struct mutex update_lock;
140129 	char valid;
141130 	unsigned long last_updated_measure;
....@@ -156,68 +145,141 @@
156145 };
157146 
158147 /* write new fan div, callers must hold data->update_lock */
159
-static void adm9240_write_fan_div(struct i2c_client *client, int nr,
148
+static int adm9240_write_fan_div(struct adm9240_data *data, int nr,
160149 		u8 fan_div)
161150 {
162
-	u8 reg, old, shift = (nr + 2) * 2;
151
+	unsigned int reg, old, shift = (nr + 2) * 2;
152
+	int err;
163153 
164
-	reg = i2c_smbus_read_byte_data(client, ADM9240_REG_VID_FAN_DIV);
154
+	err = regmap_read(data->regmap, ADM9240_REG_VID_FAN_DIV, &reg);
155
+	if (err < 0)
156
+		return err;
165157 	old = (reg >> shift) & 3;
166158 	reg &= ~(3 << shift);
167159 	reg |= (fan_div << shift);
168
-	i2c_smbus_write_byte_data(client, ADM9240_REG_VID_FAN_DIV, reg);
169
-	dev_dbg(&client->dev,
160
+	err = regmap_write(data->regmap, ADM9240_REG_VID_FAN_DIV, reg);
161
+	if (err < 0)
162
+		return err;
163
+	dev_dbg(&data->client->dev,
170164 		"fan%d clock divider changed from %u to %u\n",
171165 		nr + 1, 1 << old, 1 << fan_div);
166
+
167
+	return 0;
168
+}
169
+
170
+static int adm9240_update_measure(struct adm9240_data *data)
171
+{
172
+	unsigned int val;
173
+	u8 regs[2];
174
+	int err;
175
+	int i;
176
+
177
+	err = regmap_bulk_read(data->regmap, ADM9240_REG_IN(0), &data->in[0], 6);
178
+	if (err < 0)
179
+		return err;
180
+	err = regmap_bulk_read(data->regmap, ADM9240_REG_INT(0), &regs, 2);
181
+	if (err < 0)
182
+		return err;
183
+
184
+	data->alarms = regs[0] | regs[1] << 8;
185
+
186
+	/*
187
+	 * read temperature: assume temperature changes less than
188
+	 * 0.5'C per two measurement cycles thus ignore possible
189
+	 * but unlikely aliasing error on lsb reading. --Grant
190
+	 */
191
+	err = regmap_read(data->regmap, ADM9240_REG_TEMP, &val);
192
+	if (err < 0)
193
+		return err;
194
+	data->temp = val << 8;
195
+	err = regmap_read(data->regmap, ADM9240_REG_TEMP_CONF, &val);
196
+	if (err < 0)
197
+		return err;
198
+	data->temp |= val;
199
+
200
+	err = regmap_bulk_read(data->regmap, ADM9240_REG_FAN(0),
201
+			       &data->fan[0], 2);
202
+	if (err < 0)
203
+		return err;
204
+
205
+	for (i = 0; i < 2; i++) { /* read fans */
206
+		/* adjust fan clock divider on overflow */
207
+		if (data->valid && data->fan[i] == 255 &&
208
+				data->fan_div[i] < 3) {
209
+
210
+			err = adm9240_write_fan_div(data, i,
211
+					++data->fan_div[i]);
212
+			if (err < 0)
213
+				return err;
214
+
215
+			/* adjust fan_min if active, but not to 0 */
216
+			if (data->fan_min[i] < 255 &&
217
+					data->fan_min[i] >= 2)
218
+				data->fan_min[i] /= 2;
219
+		}
220
+	}
221
+
222
+	return 0;
223
+}
224
+
225
+static int adm9240_update_config(struct adm9240_data *data)
226
+{
227
+	unsigned int val;
228
+	int i;
229
+	int err;
230
+
231
+	for (i = 0; i < 6; i++) {
232
+		err = regmap_raw_read(data->regmap, ADM9240_REG_IN_MIN(i),
233
+				      &data->in_min[i], 1);
234
+		if (err < 0)
235
+			return err;
236
+		err = regmap_raw_read(data->regmap, ADM9240_REG_IN_MAX(i),
237
+				      &data->in_max[i], 1);
238
+		if (err < 0)
239
+			return err;
240
+	}
241
+	err = regmap_bulk_read(data->regmap, ADM9240_REG_FAN_MIN(0),
242
+				      &data->fan_min[0], 2);
243
+	if (err < 0)
244
+		return err;
245
+	err = regmap_bulk_read(data->regmap, ADM9240_REG_TEMP_MAX(0),
246
+				      &data->temp_max[0], 2);
247
+	if (err < 0)
248
+		return err;
249
+
250
+	/* read fan divs and 5-bit VID */
251
+	err = regmap_read(data->regmap, ADM9240_REG_VID_FAN_DIV, &val);
252
+	if (err < 0)
253
+		return err;
254
+	data->fan_div[0] = (val >> 4) & 3;
255
+	data->fan_div[1] = (val >> 6) & 3;
256
+	data->vid = val & 0x0f;
257
+	err = regmap_read(data->regmap, ADM9240_REG_VID4, &val);
258
+	if (err < 0)
259
+		return err;
260
+	data->vid |= (val & 1) << 4;
261
+	/* read analog out */
262
+	err = regmap_raw_read(data->regmap, ADM9240_REG_ANALOG_OUT,
263
+			      &data->aout, 1);
264
+
265
+	return err;
172266 }
173267 
174268 static struct adm9240_data *adm9240_update_device(struct device *dev)
175269 {
176270 	struct adm9240_data *data = dev_get_drvdata(dev);
177
-	struct i2c_client *client = data->client;
178
-	int i;
271
+	int err;
179272 
180273 	mutex_lock(&data->update_lock);
181274 
182275 	/* minimum measurement cycle: 1.75 seconds */
183276 	if (time_after(jiffies, data->last_updated_measure + (HZ * 7 / 4))
184277 			|| !data->valid) {
185
-
186
-		for (i = 0; i < 6; i++) { /* read voltages */
187
-			data->in[i] = i2c_smbus_read_byte_data(client,
188
-					ADM9240_REG_IN(i));
189
-		}
190
-		data->alarms = i2c_smbus_read_byte_data(client,
191
-					ADM9240_REG_INT(0)) |
192
-					i2c_smbus_read_byte_data(client,
193
-					ADM9240_REG_INT(1)) << 8;
194
-
195
-		/*
196
-		 * read temperature: assume temperature changes less than
197
-		 * 0.5'C per two measurement cycles thus ignore possible
198
-		 * but unlikely aliasing error on lsb reading. --Grant
199
-		 */
200
-		data->temp = (i2c_smbus_read_byte_data(client,
201
-					ADM9240_REG_TEMP) << 8) |
202
-					i2c_smbus_read_byte_data(client,
203
-					ADM9240_REG_TEMP_CONF);
204
-
205
-		for (i = 0; i < 2; i++) { /* read fans */
206
-			data->fan[i] = i2c_smbus_read_byte_data(client,
207
-					ADM9240_REG_FAN(i));
208
-
209
-			/* adjust fan clock divider on overflow */
210
-			if (data->valid && data->fan[i] == 255 &&
211
-					data->fan_div[i] < 3) {
212
-
213
-				adm9240_write_fan_div(client, i,
214
-						++data->fan_div[i]);
215
-
216
-				/* adjust fan_min if active, but not to 0 */
217
-				if (data->fan_min[i] < 255 &&
218
-						data->fan_min[i] >= 2)
219
-					data->fan_min[i] /= 2;
220
-			}
278
+		err = adm9240_update_measure(data);
279
+		if (err < 0) {
280
+			data->valid = 0;
281
+			mutex_unlock(&data->update_lock);
282
+			return ERR_PTR(err);
221283 		}
222284 		data->last_updated_measure = jiffies;
223285 	}
....@@ -225,33 +287,12 @@
225287 	/* minimum config reading cycle: 300 seconds */
226288 	if (time_after(jiffies, data->last_updated_config + (HZ * 300))
227289 			|| !data->valid) {
228
-
229
-		for (i = 0; i < 6; i++) {
230
-			data->in_min[i] = i2c_smbus_read_byte_data(client,
231
-					ADM9240_REG_IN_MIN(i));
232
-			data->in_max[i] = i2c_smbus_read_byte_data(client,
233
-					ADM9240_REG_IN_MAX(i));
290
+		err = adm9240_update_config(data);
291
+		if (err < 0) {
292
+			data->valid = 0;
293
+			mutex_unlock(&data->update_lock);
294
+			return ERR_PTR(err);
234295 		}
235
-		for (i = 0; i < 2; i++) {
236
-			data->fan_min[i] = i2c_smbus_read_byte_data(client,
237
-					ADM9240_REG_FAN_MIN(i));
238
-		}
239
-		data->temp_max[0] = i2c_smbus_read_byte_data(client,
240
-				ADM9240_REG_TEMP_MAX(0));
241
-		data->temp_max[1] = i2c_smbus_read_byte_data(client,
242
-				ADM9240_REG_TEMP_MAX(1));
243
-
244
-		/* read fan divs and 5-bit VID */
245
-		i = i2c_smbus_read_byte_data(client, ADM9240_REG_VID_FAN_DIV);
246
-		data->fan_div[0] = (i >> 4) & 3;
247
-		data->fan_div[1] = (i >> 6) & 3;
248
-		data->vid = i & 0x0f;
249
-		data->vid |= (i2c_smbus_read_byte_data(client,
250
-					ADM9240_REG_VID4) & 1) << 4;
251
-		/* read analog out */
252
-		data->aout = i2c_smbus_read_byte_data(client,
253
-				ADM9240_REG_ANALOG_OUT);
254
-
255296 		data->last_updated_config = jiffies;
256297 		data->valid = 1;
257298 	}
....@@ -266,23 +307,30 @@
266307 				struct device_attribute *dummy, char *buf)
267308 {
268309 	struct adm9240_data *data = adm9240_update_device(dev);
310
+
311
+	if (IS_ERR(data))
312
+		return PTR_ERR(data);
313
+
269314 	return sprintf(buf, "%d\n", data->temp / 128 * 500); /* 9-bit value */
270315 }
271316 
272
-static ssize_t show_max(struct device *dev, struct device_attribute *devattr,
273
-		char *buf)
317
+static ssize_t max_show(struct device *dev, struct device_attribute *devattr,
318
+			char *buf)
274319 {
275320 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
276321 	struct adm9240_data *data = adm9240_update_device(dev);
322
+
323
+	if (IS_ERR(data))
324
+		return PTR_ERR(data);
325
+
277326 	return sprintf(buf, "%d\n", data->temp_max[attr->index] * 1000);
278327 }
279328 
280
-static ssize_t set_max(struct device *dev, struct device_attribute *devattr,
281
-		const char *buf, size_t count)
329
+static ssize_t max_store(struct device *dev, struct device_attribute *devattr,
330
+			 const char *buf, size_t count)
282331 {
283332 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
284333 	struct adm9240_data *data = dev_get_drvdata(dev);
285
-	struct i2c_client *client = data->client;
286334 	long val;
287335 	int err;
288336 
....@@ -292,53 +340,62 @@
292340 
293341 	mutex_lock(&data->update_lock);
294342 	data->temp_max[attr->index] = TEMP_TO_REG(val);
295
-	i2c_smbus_write_byte_data(client, ADM9240_REG_TEMP_MAX(attr->index),
296
-			data->temp_max[attr->index]);
343
+	err = regmap_write(data->regmap, ADM9240_REG_TEMP_MAX(attr->index),
344
+			   data->temp_max[attr->index]);
297345 	mutex_unlock(&data->update_lock);
298
-	return count;
346
+	return err < 0 ? err : count;
299347 }
300348 
301349 static DEVICE_ATTR_RO(temp1_input);
302
-static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
303
-		show_max, set_max, 0);
304
-static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
305
-		show_max, set_max, 1);
350
+static SENSOR_DEVICE_ATTR_RW(temp1_max, max, 0);
351
+static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, max, 1);
306352 
307353 /* voltage */
308
-static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
309
-		char *buf)
354
+static ssize_t in_show(struct device *dev, struct device_attribute *devattr,
355
+		       char *buf)
310356 {
311357 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
312358 	struct adm9240_data *data = adm9240_update_device(dev);
359
+
360
+	if (IS_ERR(data))
361
+		return PTR_ERR(data);
362
+
313363 	return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index],
314364 				attr->index));
315365 }
316366 
317
-static ssize_t show_in_min(struct device *dev,
318
-		struct device_attribute *devattr, char *buf)
367
+static ssize_t in_min_show(struct device *dev,
368
+			   struct device_attribute *devattr, char *buf)
319369 {
320370 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
321371 	struct adm9240_data *data = adm9240_update_device(dev);
372
+
373
+	if (IS_ERR(data))
374
+		return PTR_ERR(data);
375
+
322376 	return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index],
323377 				attr->index));
324378 }
325379 
326
-static ssize_t show_in_max(struct device *dev,
327
-		struct device_attribute *devattr, char *buf)
380
+static ssize_t in_max_show(struct device *dev,
381
+			   struct device_attribute *devattr, char *buf)
328382 {
329383 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
330384 	struct adm9240_data *data = adm9240_update_device(dev);
385
+
386
+	if (IS_ERR(data))
387
+		return PTR_ERR(data);
388
+
331389 	return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index],
332390 				attr->index));
333391 }
334392 
335
-static ssize_t set_in_min(struct device *dev,
336
-		struct device_attribute *devattr,
337
-		const char *buf, size_t count)
393
+static ssize_t in_min_store(struct device *dev,
394
+			    struct device_attribute *devattr, const char *buf,
395
+			    size_t count)
338396 {
339397 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
340398 	struct adm9240_data *data = dev_get_drvdata(dev);
341
-	struct i2c_client *client = data->client;
342399 	unsigned long val;
343400 	int err;
344401 
....@@ -348,19 +405,18 @@
348405 
349406 	mutex_lock(&data->update_lock);
350407 	data->in_min[attr->index] = IN_TO_REG(val, attr->index);
351
-	i2c_smbus_write_byte_data(client, ADM9240_REG_IN_MIN(attr->index),
352
-			data->in_min[attr->index]);
408
+	err = regmap_write(data->regmap, ADM9240_REG_IN_MIN(attr->index),
409
+			   data->in_min[attr->index]);
353410 	mutex_unlock(&data->update_lock);
354
-	return count;
411
+	return err < 0 ? err : count;
355412 }
356413 
357
-static ssize_t set_in_max(struct device *dev,
358
-		struct device_attribute *devattr,
359
-		const char *buf, size_t count)
414
+static ssize_t in_max_store(struct device *dev,
415
+			    struct device_attribute *devattr, const char *buf,
416
+			    size_t count)
360417 {
361418 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
362419 	struct adm9240_data *data = dev_get_drvdata(dev);
363
-	struct i2c_client *client = data->client;
364420 	unsigned long val;
365421 	int err;
366422 
....@@ -370,51 +426,67 @@
370426 
371427 	mutex_lock(&data->update_lock);
372428 	data->in_max[attr->index] = IN_TO_REG(val, attr->index);
373
-	i2c_smbus_write_byte_data(client, ADM9240_REG_IN_MAX(attr->index),
374
-			data->in_max[attr->index]);
429
+	err = regmap_write(data->regmap, ADM9240_REG_IN_MAX(attr->index),
430
+			   data->in_max[attr->index]);
375431 	mutex_unlock(&data->update_lock);
376
-	return count;
432
+	return err < 0 ? err : count;
377433 }
378434 
379
-#define vin(nr)							\
380
-static SENSOR_DEVICE_ATTR(in##nr##_input, S_IRUGO,		\
381
-		show_in, NULL, nr);				\
382
-static SENSOR_DEVICE_ATTR(in##nr##_min, S_IRUGO | S_IWUSR,	\
383
-		show_in_min, set_in_min, nr);			\
384
-static SENSOR_DEVICE_ATTR(in##nr##_max, S_IRUGO | S_IWUSR,	\
385
-		show_in_max, set_in_max, nr);
386
-
387
-vin(0);
388
-vin(1);
389
-vin(2);
390
-vin(3);
391
-vin(4);
392
-vin(5);
435
+static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
436
+static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
437
+static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
438
+static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
439
+static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
440
+static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
441
+static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
442
+static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
443
+static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
444
+static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
445
+static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
446
+static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
447
+static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
448
+static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
449
+static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
450
+static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);
451
+static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
452
+static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
393453 
394454 /* fans */
395
-static ssize_t show_fan(struct device *dev,
396
-		struct device_attribute *devattr, char *buf)
455
+static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
456
+			char *buf)
397457 {
398458 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
399459 	struct adm9240_data *data = adm9240_update_device(dev);
460
+
461
+	if (IS_ERR(data))
462
+		return PTR_ERR(data);
463
+
400464 	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index],
401465 				1 << data->fan_div[attr->index]));
402466 }
403467 
404
-static ssize_t show_fan_min(struct device *dev,
405
-		struct device_attribute *devattr, char *buf)
468
+static ssize_t fan_min_show(struct device *dev,
469
+			    struct device_attribute *devattr, char *buf)
406470 {
407471 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
408472 	struct adm9240_data *data = adm9240_update_device(dev);
473
+
474
+	if (IS_ERR(data))
475
+		return PTR_ERR(data);
476
+
409477 	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[attr->index],
410478 				1 << data->fan_div[attr->index]));
411479 }
412480 
413
-static ssize_t show_fan_div(struct device *dev,
414
-		struct device_attribute *devattr, char *buf)
481
+static ssize_t fan_div_show(struct device *dev,
482
+			    struct device_attribute *devattr, char *buf)
415483 {
416484 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
417485 	struct adm9240_data *data = adm9240_update_device(dev);
486
+
487
+	if (IS_ERR(data))
488
+		return PTR_ERR(data);
489
+
418490 	return sprintf(buf, "%d\n", 1 << data->fan_div[attr->index]);
419491 }
420492 
....@@ -429,9 +501,9 @@
429501  * - otherwise: select fan clock divider to suit fan speed low limit,
430502  *   measurement code may adjust registers to ensure fan speed reading
431503  */
432
-static ssize_t set_fan_min(struct device *dev,
433
-		struct device_attribute *devattr,
434
-		const char *buf, size_t count)
504
+static ssize_t fan_min_store(struct device *dev,
505
+			     struct device_attribute *devattr,
506
+			     const char *buf, size_t count)
435507 {
436508 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
437509 	struct adm9240_data *data = dev_get_drvdata(dev);
....@@ -480,57 +552,65 @@
480552 
481553 	if (new_div != data->fan_div[nr]) {
482554 		data->fan_div[nr] = new_div;
483
-		adm9240_write_fan_div(client, nr, new_div);
555
+		adm9240_write_fan_div(data, nr, new_div);
484556 	}
485
-	i2c_smbus_write_byte_data(client, ADM9240_REG_FAN_MIN(nr),
486
-			data->fan_min[nr]);
557
+	err = regmap_write(data->regmap, ADM9240_REG_FAN_MIN(nr),
558
+			   data->fan_min[nr]);
487559 
488560 	mutex_unlock(&data->update_lock);
489
-	return count;
561
+	return err < 0 ? err : count;
490562 }
491563 
492
-#define fan(nr)							\
493
-static SENSOR_DEVICE_ATTR(fan##nr##_input, S_IRUGO,		\
494
-		show_fan, NULL, nr - 1);			\
495
-static SENSOR_DEVICE_ATTR(fan##nr##_div, S_IRUGO,		\
496
-		show_fan_div, NULL, nr - 1);			\
497
-static SENSOR_DEVICE_ATTR(fan##nr##_min, S_IRUGO | S_IWUSR,	\
498
-		show_fan_min, set_fan_min, nr - 1);
499
-
500
-fan(1);
501
-fan(2);
564
+static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
565
+static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
566
+static SENSOR_DEVICE_ATTR_RO(fan1_div, fan_div, 0);
567
+static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
568
+static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
569
+static SENSOR_DEVICE_ATTR_RO(fan2_div, fan_div, 1);
502570 
503571 /* alarms */
504572 static ssize_t alarms_show(struct device *dev,
505573 		struct device_attribute *attr, char *buf)
506574 {
507575 	struct adm9240_data *data = adm9240_update_device(dev);
576
+
577
+	if (IS_ERR(data))
578
+		return PTR_ERR(data);
579
+
508580 	return sprintf(buf, "%u\n", data->alarms);
509581 }
510582 static DEVICE_ATTR_RO(alarms);
511583 
512
-static ssize_t show_alarm(struct device *dev,
513
-		struct device_attribute *attr, char *buf)
584
+static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
585
+			  char *buf)
514586 {
515587 	int bitnr = to_sensor_dev_attr(attr)->index;
516588 	struct adm9240_data *data = adm9240_update_device(dev);
589
+
590
+	if (IS_ERR(data))
591
+		return PTR_ERR(data);
592
+
517593 	return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
518594 }
519
-static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
520
-static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
521
-static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
522
-static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
523
-static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
524
-static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
525
-static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
526
-static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
527
-static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
595
+static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
596
+static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
597
+static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
598
+static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
599
+static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8);
600
+static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 9);
601
+static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
602
+static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6);
603
+static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7);
528604 
529605 /* vid */
530606 static ssize_t cpu0_vid_show(struct device *dev,
531607 			     struct device_attribute *attr, char *buf)
532608 {
533609 	struct adm9240_data *data = adm9240_update_device(dev);
610
+
611
+	if (IS_ERR(data))
612
+		return PTR_ERR(data);
613
+
534614 	return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
535615 }
536616 static DEVICE_ATTR_RO(cpu0_vid);
....@@ -540,6 +620,10 @@
540620 				struct device_attribute *attr, char *buf)
541621 {
542622 	struct adm9240_data *data = adm9240_update_device(dev);
623
+
624
+	if (IS_ERR(data))
625
+		return PTR_ERR(data);
626
+
543627 	return sprintf(buf, "%d\n", AOUT_FROM_REG(data->aout));
544628 }
545629 
....@@ -548,7 +632,6 @@
548632 				 const char *buf, size_t count)
549633 {
550634 	struct adm9240_data *data = dev_get_drvdata(dev);
551
-	struct i2c_client *client = data->client;
552635 	long val;
553636 	int err;
554637 
....@@ -558,33 +641,33 @@
558641 
559642 	mutex_lock(&data->update_lock);
560643 	data->aout = AOUT_TO_REG(val);
561
-	i2c_smbus_write_byte_data(client, ADM9240_REG_ANALOG_OUT, data->aout);
644
+	err = regmap_write(data->regmap, ADM9240_REG_ANALOG_OUT, data->aout);
562645 	mutex_unlock(&data->update_lock);
563
-	return count;
646
+	return err < 0 ? err : count;
564647 }
565648 static DEVICE_ATTR_RW(aout_output);
566649 
567
-static ssize_t chassis_clear(struct device *dev,
568
-		struct device_attribute *attr,
569
-		const char *buf, size_t count)
650
+static ssize_t alarm_store(struct device *dev, struct device_attribute *attr,
651
+			   const char *buf, size_t count)
570652 {
571653 	struct adm9240_data *data = dev_get_drvdata(dev);
572
-	struct i2c_client *client = data->client;
573654 	unsigned long val;
655
+	int err;
574656 
575657 	if (kstrtoul(buf, 10, &val) || val != 0)
576658 		return -EINVAL;
577659 
578660 	mutex_lock(&data->update_lock);
579
-	i2c_smbus_write_byte_data(client, ADM9240_REG_CHASSIS_CLEAR, 0x80);
661
+	err = regmap_write(data->regmap, ADM9240_REG_CHASSIS_CLEAR, 0x80);
580662 	data->valid = 0;		/* Force cache refresh */
581663 	mutex_unlock(&data->update_lock);
582
-	dev_dbg(&client->dev, "chassis intrusion latch cleared\n");
664
+	if (err < 0)
665
+		return err;
666
+	dev_dbg(&data->client->dev, "chassis intrusion latch cleared\n");
583667 
584668 	return count;
585669 }
586
-static SENSOR_DEVICE_ATTR(intrusion0_alarm, S_IRUGO | S_IWUSR, show_alarm,
587
-		chassis_clear, 12);
670
+static SENSOR_DEVICE_ATTR_RW(intrusion0_alarm, alarm, 12);
588671 
589672 static struct attribute *adm9240_attrs[] = {
590673 	&sensor_dev_attr_in0_input.dev_attr.attr,
....@@ -631,7 +714,6 @@
631714 };
632715 
633716 ATTRIBUTE_GROUPS(adm9240);
634
-
635717 
636718 /*** sensor chip detect and driver install ***/
637719 
....@@ -680,11 +762,18 @@
680762 	return 0;
681763 }
682764 
683
-static void adm9240_init_client(struct i2c_client *client)
765
+static int adm9240_init_client(struct i2c_client *client, struct adm9240_data *data)
684766 {
685
-	struct adm9240_data *data = i2c_get_clientdata(client);
686
-	u8 conf = i2c_smbus_read_byte_data(client, ADM9240_REG_CONFIG);
687
-	u8 mode = i2c_smbus_read_byte_data(client, ADM9240_REG_TEMP_CONF) & 3;
767
+	u8 conf, mode;
768
+	int err;
769
+
770
+	err = regmap_raw_read(data->regmap, ADM9240_REG_CONFIG, &conf, 1);
771
+	if (err < 0)
772
+		return err;
773
+	err = regmap_raw_read(data->regmap, ADM9240_REG_TEMP_CONF, &mode, 1);
774
+	if (err < 0)
775
+		return err;
776
+	mode &= 3;
688777 
689778 	data->vrm = vid_which_vrm(); /* need this to report vid as mV */
690779 
....@@ -700,44 +789,67 @@
700789 		int i;
701790 
702791 		for (i = 0; i < 6; i++) {
703
-			i2c_smbus_write_byte_data(client,
704
-					ADM9240_REG_IN_MIN(i), 0);
705
-			i2c_smbus_write_byte_data(client,
706
-					ADM9240_REG_IN_MAX(i), 255);
792
+			err = regmap_write(data->regmap,
793
+					   ADM9240_REG_IN_MIN(i), 0);
794
+			if (err < 0)
795
+				return err;
796
+			err = regmap_write(data->regmap,
797
+					   ADM9240_REG_IN_MAX(i), 255);
798
+			if (err < 0)
799
+				return err;
707800 		}
708
-		i2c_smbus_write_byte_data(client,
709
-				ADM9240_REG_FAN_MIN(0), 255);
710
-		i2c_smbus_write_byte_data(client,
711
-				ADM9240_REG_FAN_MIN(1), 255);
712
-		i2c_smbus_write_byte_data(client,
713
-				ADM9240_REG_TEMP_MAX(0), 127);
714
-		i2c_smbus_write_byte_data(client,
715
-				ADM9240_REG_TEMP_MAX(1), 127);
801
+		for (i = 0; i < 2; i++) {
802
+			err = regmap_write(data->regmap,
803
+					ADM9240_REG_FAN_MIN(i), 255);
804
+			if (err < 0)
805
+				return err;
806
+		}
807
+		for (i = 0; i < 2; i++) {
808
+			err = regmap_write(data->regmap,
809
+					ADM9240_REG_TEMP_MAX(i), 127);
810
+			if (err < 0)
811
+				return err;
812
+		}
716813 
717814 		/* start measurement cycle */
718
-		i2c_smbus_write_byte_data(client, ADM9240_REG_CONFIG, 1);
815
+		err = regmap_write(data->regmap, ADM9240_REG_CONFIG, 1);
816
+		if (err < 0)
817
+			return err;
719818 
720819 		dev_info(&client->dev,
721820 			 "cold start: config was 0x%02x mode %u\n", conf, mode);
722821 	}
822
+
823
+	return 0;
723824 }
724825 
725
-static int adm9240_probe(struct i2c_client *new_client,
726
-			 const struct i2c_device_id *id)
826
+static const struct regmap_config adm9240_regmap_config = {
827
+	.reg_bits = 8,
828
+	.val_bits = 8,
829
+	.use_single_read = true,
830
+	.use_single_write = true,
831
+};
832
+
833
+static int adm9240_probe(struct i2c_client *new_client)
727834 {
728835 	struct device *dev = &new_client->dev;
729836 	struct device *hwmon_dev;
730837 	struct adm9240_data *data;
838
+	int err;
731839 
732840 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
733841 	if (!data)
734842 		return -ENOMEM;
735843 
736
-	i2c_set_clientdata(new_client, data);
737844 	data->client = new_client;
738845 	mutex_init(&data->update_lock);
846
+	data->regmap = devm_regmap_init_i2c(new_client, &adm9240_regmap_config);
847
+	if (IS_ERR(data->regmap))
848
+		return PTR_ERR(data->regmap);
739849 
740
-	adm9240_init_client(new_client);
850
+	err = adm9240_init_client(new_client, data);
851
+	if (err < 0)
852
+		return err;
741853 
742854 	hwmon_dev = devm_hwmon_device_register_with_groups(dev,
743855 							   new_client->name,
....@@ -759,7 +871,7 @@
759871 	.driver = {
760872 		.name	= "adm9240",
761873 	},
762
-	.probe		= adm9240_probe,
874
+	.probe_new	= adm9240_probe,
763875 	.id_table	= adm9240_id,
764876 	.detect		= adm9240_detect,
765877 	.address_list	= normal_i2c,