PageRenderTime 84ms CodeModel.GetById 6ms app.highlight 72ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/hwmon/amc6821.c

http://github.com/mirrors/linux
C | 953 lines | 811 code | 112 blank | 30 comment | 60 complexity | a9c9858d0e052c824d9d069e7dd403a2 MD5 | raw file
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * amc6821.c - Part of lm_sensors, Linux kernel modules for hardware
  4 *	       monitoring
  5 * Copyright (C) 2009 T. Mertelj <tomaz.mertelj@guest.arnes.si>
  6 *
  7 * Based on max6650.c:
  8 * Copyright (C) 2007 Hans J. Koch <hjk@hansjkoch.de>
  9 */
 10
 11#include <linux/kernel.h>	/* Needed for KERN_INFO */
 12#include <linux/module.h>
 13#include <linux/init.h>
 14#include <linux/slab.h>
 15#include <linux/jiffies.h>
 16#include <linux/i2c.h>
 17#include <linux/hwmon.h>
 18#include <linux/hwmon-sysfs.h>
 19#include <linux/err.h>
 20#include <linux/mutex.h>
 21
 22/*
 23 * Addresses to scan.
 24 */
 25
 26static const unsigned short normal_i2c[] = {0x18, 0x19, 0x1a, 0x2c, 0x2d, 0x2e,
 27	0x4c, 0x4d, 0x4e, I2C_CLIENT_END};
 28
 29/*
 30 * Insmod parameters
 31 */
 32
 33static int pwminv;	/*Inverted PWM output. */
 34module_param(pwminv, int, 0444);
 35
 36static int init = 1; /*Power-on initialization.*/
 37module_param(init, int, 0444);
 38
 39enum chips { amc6821 };
 40
 41#define AMC6821_REG_DEV_ID 0x3D
 42#define AMC6821_REG_COMP_ID 0x3E
 43#define AMC6821_REG_CONF1 0x00
 44#define AMC6821_REG_CONF2 0x01
 45#define AMC6821_REG_CONF3 0x3F
 46#define AMC6821_REG_CONF4 0x04
 47#define AMC6821_REG_STAT1 0x02
 48#define AMC6821_REG_STAT2 0x03
 49#define AMC6821_REG_TDATA_LOW 0x08
 50#define AMC6821_REG_TDATA_HI 0x09
 51#define AMC6821_REG_LTEMP_HI 0x0A
 52#define AMC6821_REG_RTEMP_HI 0x0B
 53#define AMC6821_REG_LTEMP_LIMIT_MIN 0x15
 54#define AMC6821_REG_LTEMP_LIMIT_MAX 0x14
 55#define AMC6821_REG_RTEMP_LIMIT_MIN 0x19
 56#define AMC6821_REG_RTEMP_LIMIT_MAX 0x18
 57#define AMC6821_REG_LTEMP_CRIT 0x1B
 58#define AMC6821_REG_RTEMP_CRIT 0x1D
 59#define AMC6821_REG_PSV_TEMP 0x1C
 60#define AMC6821_REG_DCY 0x22
 61#define AMC6821_REG_LTEMP_FAN_CTRL 0x24
 62#define AMC6821_REG_RTEMP_FAN_CTRL 0x25
 63#define AMC6821_REG_DCY_LOW_TEMP 0x21
 64
 65#define AMC6821_REG_TACH_LLIMITL 0x10
 66#define AMC6821_REG_TACH_LLIMITH 0x11
 67#define AMC6821_REG_TACH_HLIMITL 0x12
 68#define AMC6821_REG_TACH_HLIMITH 0x13
 69
 70#define AMC6821_CONF1_START 0x01
 71#define AMC6821_CONF1_FAN_INT_EN 0x02
 72#define AMC6821_CONF1_FANIE 0x04
 73#define AMC6821_CONF1_PWMINV 0x08
 74#define AMC6821_CONF1_FAN_FAULT_EN 0x10
 75#define AMC6821_CONF1_FDRC0 0x20
 76#define AMC6821_CONF1_FDRC1 0x40
 77#define AMC6821_CONF1_THERMOVIE 0x80
 78
 79#define AMC6821_CONF2_PWM_EN 0x01
 80#define AMC6821_CONF2_TACH_MODE 0x02
 81#define AMC6821_CONF2_TACH_EN 0x04
 82#define AMC6821_CONF2_RTFIE 0x08
 83#define AMC6821_CONF2_LTOIE 0x10
 84#define AMC6821_CONF2_RTOIE 0x20
 85#define AMC6821_CONF2_PSVIE 0x40
 86#define AMC6821_CONF2_RST 0x80
 87
 88#define AMC6821_CONF3_THERM_FAN_EN 0x80
 89#define AMC6821_CONF3_REV_MASK 0x0F
 90
 91#define AMC6821_CONF4_OVREN 0x10
 92#define AMC6821_CONF4_TACH_FAST 0x20
 93#define AMC6821_CONF4_PSPR 0x40
 94#define AMC6821_CONF4_MODE 0x80
 95
 96#define AMC6821_STAT1_RPM_ALARM 0x01
 97#define AMC6821_STAT1_FANS 0x02
 98#define AMC6821_STAT1_RTH 0x04
 99#define AMC6821_STAT1_RTL 0x08
100#define AMC6821_STAT1_R_THERM 0x10
101#define AMC6821_STAT1_RTF 0x20
102#define AMC6821_STAT1_LTH 0x40
103#define AMC6821_STAT1_LTL 0x80
104
105#define AMC6821_STAT2_RTC 0x08
106#define AMC6821_STAT2_LTC 0x10
107#define AMC6821_STAT2_LPSV 0x20
108#define AMC6821_STAT2_L_THERM 0x40
109#define AMC6821_STAT2_THERM_IN 0x80
110
111enum {IDX_TEMP1_INPUT = 0, IDX_TEMP1_MIN, IDX_TEMP1_MAX,
112	IDX_TEMP1_CRIT, IDX_TEMP2_INPUT, IDX_TEMP2_MIN,
113	IDX_TEMP2_MAX, IDX_TEMP2_CRIT,
114	TEMP_IDX_LEN, };
115
116static const u8 temp_reg[] = {AMC6821_REG_LTEMP_HI,
117			AMC6821_REG_LTEMP_LIMIT_MIN,
118			AMC6821_REG_LTEMP_LIMIT_MAX,
119			AMC6821_REG_LTEMP_CRIT,
120			AMC6821_REG_RTEMP_HI,
121			AMC6821_REG_RTEMP_LIMIT_MIN,
122			AMC6821_REG_RTEMP_LIMIT_MAX,
123			AMC6821_REG_RTEMP_CRIT, };
124
125enum {IDX_FAN1_INPUT = 0, IDX_FAN1_MIN, IDX_FAN1_MAX,
126	FAN1_IDX_LEN, };
127
128static const u8 fan_reg_low[] = {AMC6821_REG_TDATA_LOW,
129			AMC6821_REG_TACH_LLIMITL,
130			AMC6821_REG_TACH_HLIMITL, };
131
132
133static const u8 fan_reg_hi[] = {AMC6821_REG_TDATA_HI,
134			AMC6821_REG_TACH_LLIMITH,
135			AMC6821_REG_TACH_HLIMITH, };
136
137/*
138 * Client data (each client gets its own)
139 */
140
141struct amc6821_data {
142	struct i2c_client *client;
143	struct mutex update_lock;
144	char valid; /* zero until following fields are valid */
145	unsigned long last_updated; /* in jiffies */
146
147	/* register values */
148	int temp[TEMP_IDX_LEN];
149
150	u16 fan[FAN1_IDX_LEN];
151	u8 fan1_div;
152
153	u8 pwm1;
154	u8 temp1_auto_point_temp[3];
155	u8 temp2_auto_point_temp[3];
156	u8 pwm1_auto_point_pwm[3];
157	u8 pwm1_enable;
158	u8 pwm1_auto_channels_temp;
159
160	u8 stat1;
161	u8 stat2;
162};
163
164static struct amc6821_data *amc6821_update_device(struct device *dev)
165{
166	struct amc6821_data *data = dev_get_drvdata(dev);
167	struct i2c_client *client = data->client;
168	int timeout = HZ;
169	u8 reg;
170	int i;
171
172	mutex_lock(&data->update_lock);
173
174	if (time_after(jiffies, data->last_updated + timeout) ||
175			!data->valid) {
176
177		for (i = 0; i < TEMP_IDX_LEN; i++)
178			data->temp[i] = (int8_t)i2c_smbus_read_byte_data(
179				client, temp_reg[i]);
180
181		data->stat1 = i2c_smbus_read_byte_data(client,
182			AMC6821_REG_STAT1);
183		data->stat2 = i2c_smbus_read_byte_data(client,
184			AMC6821_REG_STAT2);
185
186		data->pwm1 = i2c_smbus_read_byte_data(client,
187			AMC6821_REG_DCY);
188		for (i = 0; i < FAN1_IDX_LEN; i++) {
189			data->fan[i] = i2c_smbus_read_byte_data(
190					client,
191					fan_reg_low[i]);
192			data->fan[i] += i2c_smbus_read_byte_data(
193					client,
194					fan_reg_hi[i]) << 8;
195		}
196		data->fan1_div = i2c_smbus_read_byte_data(client,
197			AMC6821_REG_CONF4);
198		data->fan1_div = data->fan1_div & AMC6821_CONF4_PSPR ? 4 : 2;
199
200		data->pwm1_auto_point_pwm[0] = 0;
201		data->pwm1_auto_point_pwm[2] = 255;
202		data->pwm1_auto_point_pwm[1] = i2c_smbus_read_byte_data(client,
203			AMC6821_REG_DCY_LOW_TEMP);
204
205		data->temp1_auto_point_temp[0] =
206			i2c_smbus_read_byte_data(client,
207					AMC6821_REG_PSV_TEMP);
208		data->temp2_auto_point_temp[0] =
209				data->temp1_auto_point_temp[0];
210		reg = i2c_smbus_read_byte_data(client,
211			AMC6821_REG_LTEMP_FAN_CTRL);
212		data->temp1_auto_point_temp[1] = (reg & 0xF8) >> 1;
213		reg &= 0x07;
214		reg = 0x20 >> reg;
215		if (reg > 0)
216			data->temp1_auto_point_temp[2] =
217				data->temp1_auto_point_temp[1] +
218				(data->pwm1_auto_point_pwm[2] -
219				data->pwm1_auto_point_pwm[1]) / reg;
220		else
221			data->temp1_auto_point_temp[2] = 255;
222
223		reg = i2c_smbus_read_byte_data(client,
224			AMC6821_REG_RTEMP_FAN_CTRL);
225		data->temp2_auto_point_temp[1] = (reg & 0xF8) >> 1;
226		reg &= 0x07;
227		reg = 0x20 >> reg;
228		if (reg > 0)
229			data->temp2_auto_point_temp[2] =
230				data->temp2_auto_point_temp[1] +
231				(data->pwm1_auto_point_pwm[2] -
232				data->pwm1_auto_point_pwm[1]) / reg;
233		else
234			data->temp2_auto_point_temp[2] = 255;
235
236		reg = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
237		reg = (reg >> 5) & 0x3;
238		switch (reg) {
239		case 0: /*open loop: software sets pwm1*/
240			data->pwm1_auto_channels_temp = 0;
241			data->pwm1_enable = 1;
242			break;
243		case 2: /*closed loop: remote T (temp2)*/
244			data->pwm1_auto_channels_temp = 2;
245			data->pwm1_enable = 2;
246			break;
247		case 3: /*closed loop: local and remote T (temp2)*/
248			data->pwm1_auto_channels_temp = 3;
249			data->pwm1_enable = 3;
250			break;
251		case 1: /*
252			 * semi-open loop: software sets rpm, chip controls
253			 * pwm1, currently not implemented
254			 */
255			data->pwm1_auto_channels_temp = 0;
256			data->pwm1_enable = 0;
257			break;
258		}
259
260		data->last_updated = jiffies;
261		data->valid = 1;
262	}
263	mutex_unlock(&data->update_lock);
264	return data;
265}
266
267static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
268			 char *buf)
269{
270	struct amc6821_data *data = amc6821_update_device(dev);
271	int ix = to_sensor_dev_attr(devattr)->index;
272
273	return sprintf(buf, "%d\n", data->temp[ix] * 1000);
274}
275
276static ssize_t temp_store(struct device *dev, struct device_attribute *attr,
277			  const char *buf, size_t count)
278{
279	struct amc6821_data *data = dev_get_drvdata(dev);
280	struct i2c_client *client = data->client;
281	int ix = to_sensor_dev_attr(attr)->index;
282	long val;
283
284	int ret = kstrtol(buf, 10, &val);
285	if (ret)
286		return ret;
287	val = clamp_val(val / 1000, -128, 127);
288
289	mutex_lock(&data->update_lock);
290	data->temp[ix] = val;
291	if (i2c_smbus_write_byte_data(client, temp_reg[ix], data->temp[ix])) {
292		dev_err(&client->dev, "Register write error, aborting.\n");
293		count = -EIO;
294	}
295	mutex_unlock(&data->update_lock);
296	return count;
297}
298
299static ssize_t temp_alarm_show(struct device *dev,
300			       struct device_attribute *devattr, char *buf)
301{
302	struct amc6821_data *data = amc6821_update_device(dev);
303	int ix = to_sensor_dev_attr(devattr)->index;
304	u8 flag;
305
306	switch (ix) {
307	case IDX_TEMP1_MIN:
308		flag = data->stat1 & AMC6821_STAT1_LTL;
309		break;
310	case IDX_TEMP1_MAX:
311		flag = data->stat1 & AMC6821_STAT1_LTH;
312		break;
313	case IDX_TEMP1_CRIT:
314		flag = data->stat2 & AMC6821_STAT2_LTC;
315		break;
316	case IDX_TEMP2_MIN:
317		flag = data->stat1 & AMC6821_STAT1_RTL;
318		break;
319	case IDX_TEMP2_MAX:
320		flag = data->stat1 & AMC6821_STAT1_RTH;
321		break;
322	case IDX_TEMP2_CRIT:
323		flag = data->stat2 & AMC6821_STAT2_RTC;
324		break;
325	default:
326		dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
327		return -EINVAL;
328	}
329	if (flag)
330		return sprintf(buf, "1");
331	else
332		return sprintf(buf, "0");
333}
334
335static ssize_t temp2_fault_show(struct device *dev,
336				struct device_attribute *devattr, char *buf)
337{
338	struct amc6821_data *data = amc6821_update_device(dev);
339	if (data->stat1 & AMC6821_STAT1_RTF)
340		return sprintf(buf, "1");
341	else
342		return sprintf(buf, "0");
343}
344
345static ssize_t pwm1_show(struct device *dev, struct device_attribute *devattr,
346			 char *buf)
347{
348	struct amc6821_data *data = amc6821_update_device(dev);
349	return sprintf(buf, "%d\n", data->pwm1);
350}
351
352static ssize_t pwm1_store(struct device *dev,
353			  struct device_attribute *devattr, const char *buf,
354			  size_t count)
355{
356	struct amc6821_data *data = dev_get_drvdata(dev);
357	struct i2c_client *client = data->client;
358	long val;
359	int ret = kstrtol(buf, 10, &val);
360	if (ret)
361		return ret;
362
363	mutex_lock(&data->update_lock);
364	data->pwm1 = clamp_val(val , 0, 255);
365	i2c_smbus_write_byte_data(client, AMC6821_REG_DCY, data->pwm1);
366	mutex_unlock(&data->update_lock);
367	return count;
368}
369
370static ssize_t pwm1_enable_show(struct device *dev,
371				struct device_attribute *devattr, char *buf)
372{
373	struct amc6821_data *data = amc6821_update_device(dev);
374	return sprintf(buf, "%d\n", data->pwm1_enable);
375}
376
377static ssize_t pwm1_enable_store(struct device *dev,
378				 struct device_attribute *attr,
379				 const char *buf, size_t count)
380{
381	struct amc6821_data *data = dev_get_drvdata(dev);
382	struct i2c_client *client = data->client;
383	long val;
384	int config = kstrtol(buf, 10, &val);
385	if (config)
386		return config;
387
388	mutex_lock(&data->update_lock);
389	config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
390	if (config < 0) {
391			dev_err(&client->dev,
392			"Error reading configuration register, aborting.\n");
393			count = config;
394			goto unlock;
395	}
396
397	switch (val) {
398	case 1:
399		config &= ~AMC6821_CONF1_FDRC0;
400		config &= ~AMC6821_CONF1_FDRC1;
401		break;
402	case 2:
403		config &= ~AMC6821_CONF1_FDRC0;
404		config |= AMC6821_CONF1_FDRC1;
405		break;
406	case 3:
407		config |= AMC6821_CONF1_FDRC0;
408		config |= AMC6821_CONF1_FDRC1;
409		break;
410	default:
411		count = -EINVAL;
412		goto unlock;
413	}
414	if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF1, config)) {
415			dev_err(&client->dev,
416			"Configuration register write error, aborting.\n");
417			count = -EIO;
418	}
419unlock:
420	mutex_unlock(&data->update_lock);
421	return count;
422}
423
424static ssize_t pwm1_auto_channels_temp_show(struct device *dev,
425					    struct device_attribute *devattr,
426					    char *buf)
427{
428	struct amc6821_data *data = amc6821_update_device(dev);
429	return sprintf(buf, "%d\n", data->pwm1_auto_channels_temp);
430}
431
432static ssize_t temp_auto_point_temp_show(struct device *dev,
433					 struct device_attribute *devattr,
434					 char *buf)
435{
436	int ix = to_sensor_dev_attr_2(devattr)->index;
437	int nr = to_sensor_dev_attr_2(devattr)->nr;
438	struct amc6821_data *data = amc6821_update_device(dev);
439	switch (nr) {
440	case 1:
441		return sprintf(buf, "%d\n",
442			data->temp1_auto_point_temp[ix] * 1000);
443	case 2:
444		return sprintf(buf, "%d\n",
445			data->temp2_auto_point_temp[ix] * 1000);
446	default:
447		dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
448		return -EINVAL;
449	}
450}
451
452static ssize_t pwm1_auto_point_pwm_show(struct device *dev,
453					struct device_attribute *devattr,
454					char *buf)
455{
456	int ix = to_sensor_dev_attr(devattr)->index;
457	struct amc6821_data *data = amc6821_update_device(dev);
458	return sprintf(buf, "%d\n", data->pwm1_auto_point_pwm[ix]);
459}
460
461static inline ssize_t set_slope_register(struct i2c_client *client,
462		u8 reg,
463		u8 dpwm,
464		u8 *ptemp)
465{
466	int dt;
467	u8 tmp;
468
469	dt = ptemp[2]-ptemp[1];
470	for (tmp = 4; tmp > 0; tmp--) {
471		if (dt * (0x20 >> tmp) >= dpwm)
472			break;
473	}
474	tmp |= (ptemp[1] & 0x7C) << 1;
475	if (i2c_smbus_write_byte_data(client,
476			reg, tmp)) {
477		dev_err(&client->dev, "Register write error, aborting.\n");
478		return -EIO;
479	}
480	return 0;
481}
482
483static ssize_t temp_auto_point_temp_store(struct device *dev,
484					  struct device_attribute *attr,
485					  const char *buf, size_t count)
486{
487	struct amc6821_data *data = amc6821_update_device(dev);
488	struct i2c_client *client = data->client;
489	int ix = to_sensor_dev_attr_2(attr)->index;
490	int nr = to_sensor_dev_attr_2(attr)->nr;
491	u8 *ptemp;
492	u8 reg;
493	int dpwm;
494	long val;
495	int ret = kstrtol(buf, 10, &val);
496	if (ret)
497		return ret;
498
499	switch (nr) {
500	case 1:
501		ptemp = data->temp1_auto_point_temp;
502		reg = AMC6821_REG_LTEMP_FAN_CTRL;
503		break;
504	case 2:
505		ptemp = data->temp2_auto_point_temp;
506		reg = AMC6821_REG_RTEMP_FAN_CTRL;
507		break;
508	default:
509		dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
510		return -EINVAL;
511	}
512
513	mutex_lock(&data->update_lock);
514	data->valid = 0;
515
516	switch (ix) {
517	case 0:
518		ptemp[0] = clamp_val(val / 1000, 0,
519				     data->temp1_auto_point_temp[1]);
520		ptemp[0] = clamp_val(ptemp[0], 0,
521				     data->temp2_auto_point_temp[1]);
522		ptemp[0] = clamp_val(ptemp[0], 0, 63);
523		if (i2c_smbus_write_byte_data(
524					client,
525					AMC6821_REG_PSV_TEMP,
526					ptemp[0])) {
527				dev_err(&client->dev,
528					"Register write error, aborting.\n");
529				count = -EIO;
530		}
531		goto EXIT;
532	case 1:
533		ptemp[1] = clamp_val(val / 1000, (ptemp[0] & 0x7C) + 4, 124);
534		ptemp[1] &= 0x7C;
535		ptemp[2] = clamp_val(ptemp[2], ptemp[1] + 1, 255);
536		break;
537	case 2:
538		ptemp[2] = clamp_val(val / 1000, ptemp[1]+1, 255);
539		break;
540	default:
541		dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
542		count = -EINVAL;
543		goto EXIT;
544	}
545	dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
546	if (set_slope_register(client, reg, dpwm, ptemp))
547		count = -EIO;
548
549EXIT:
550	mutex_unlock(&data->update_lock);
551	return count;
552}
553
554static ssize_t pwm1_auto_point_pwm_store(struct device *dev,
555					 struct device_attribute *attr,
556					 const char *buf, size_t count)
557{
558	struct amc6821_data *data = dev_get_drvdata(dev);
559	struct i2c_client *client = data->client;
560	int dpwm;
561	long val;
562	int ret = kstrtol(buf, 10, &val);
563	if (ret)
564		return ret;
565
566	mutex_lock(&data->update_lock);
567	data->pwm1_auto_point_pwm[1] = clamp_val(val, 0, 254);
568	if (i2c_smbus_write_byte_data(client, AMC6821_REG_DCY_LOW_TEMP,
569			data->pwm1_auto_point_pwm[1])) {
570		dev_err(&client->dev, "Register write error, aborting.\n");
571		count = -EIO;
572		goto EXIT;
573	}
574	dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
575	if (set_slope_register(client, AMC6821_REG_LTEMP_FAN_CTRL, dpwm,
576			data->temp1_auto_point_temp)) {
577		count = -EIO;
578		goto EXIT;
579	}
580	if (set_slope_register(client, AMC6821_REG_RTEMP_FAN_CTRL, dpwm,
581			data->temp2_auto_point_temp)) {
582		count = -EIO;
583		goto EXIT;
584	}
585
586EXIT:
587	data->valid = 0;
588	mutex_unlock(&data->update_lock);
589	return count;
590}
591
592static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
593			char *buf)
594{
595	struct amc6821_data *data = amc6821_update_device(dev);
596	int ix = to_sensor_dev_attr(devattr)->index;
597	if (0 == data->fan[ix])
598		return sprintf(buf, "0");
599	return sprintf(buf, "%d\n", (int)(6000000 / data->fan[ix]));
600}
601
602static ssize_t fan1_fault_show(struct device *dev,
603			       struct device_attribute *devattr, char *buf)
604{
605	struct amc6821_data *data = amc6821_update_device(dev);
606	if (data->stat1 & AMC6821_STAT1_FANS)
607		return sprintf(buf, "1");
608	else
609		return sprintf(buf, "0");
610}
611
612static ssize_t fan_store(struct device *dev, struct device_attribute *attr,
613			 const char *buf, size_t count)
614{
615	struct amc6821_data *data = dev_get_drvdata(dev);
616	struct i2c_client *client = data->client;
617	long val;
618	int ix = to_sensor_dev_attr(attr)->index;
619	int ret = kstrtol(buf, 10, &val);
620	if (ret)
621		return ret;
622	val = 1 > val ? 0xFFFF : 6000000/val;
623
624	mutex_lock(&data->update_lock);
625	data->fan[ix] = (u16) clamp_val(val, 1, 0xFFFF);
626	if (i2c_smbus_write_byte_data(client, fan_reg_low[ix],
627			data->fan[ix] & 0xFF)) {
628		dev_err(&client->dev, "Register write error, aborting.\n");
629		count = -EIO;
630		goto EXIT;
631	}
632	if (i2c_smbus_write_byte_data(client,
633			fan_reg_hi[ix], data->fan[ix] >> 8)) {
634		dev_err(&client->dev, "Register write error, aborting.\n");
635		count = -EIO;
636	}
637EXIT:
638	mutex_unlock(&data->update_lock);
639	return count;
640}
641
642static ssize_t fan1_div_show(struct device *dev,
643			     struct device_attribute *devattr, char *buf)
644{
645	struct amc6821_data *data = amc6821_update_device(dev);
646	return sprintf(buf, "%d\n", data->fan1_div);
647}
648
649static ssize_t fan1_div_store(struct device *dev,
650			      struct device_attribute *attr, const char *buf,
651			      size_t count)
652{
653	struct amc6821_data *data = dev_get_drvdata(dev);
654	struct i2c_client *client = data->client;
655	long val;
656	int config = kstrtol(buf, 10, &val);
657	if (config)
658		return config;
659
660	mutex_lock(&data->update_lock);
661	config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
662	if (config < 0) {
663		dev_err(&client->dev,
664			"Error reading configuration register, aborting.\n");
665		count = config;
666		goto EXIT;
667	}
668	switch (val) {
669	case 2:
670		config &= ~AMC6821_CONF4_PSPR;
671		data->fan1_div = 2;
672		break;
673	case 4:
674		config |= AMC6821_CONF4_PSPR;
675		data->fan1_div = 4;
676		break;
677	default:
678		count = -EINVAL;
679		goto EXIT;
680	}
681	if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4, config)) {
682		dev_err(&client->dev,
683			"Configuration register write error, aborting.\n");
684		count = -EIO;
685	}
686EXIT:
687	mutex_unlock(&data->update_lock);
688	return count;
689}
690
691static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, IDX_TEMP1_INPUT);
692static SENSOR_DEVICE_ATTR_RW(temp1_min, temp, IDX_TEMP1_MIN);
693static SENSOR_DEVICE_ATTR_RW(temp1_max, temp, IDX_TEMP1_MAX);
694static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp, IDX_TEMP1_CRIT);
695static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, temp_alarm, IDX_TEMP1_MIN);
696static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, temp_alarm, IDX_TEMP1_MAX);
697static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, temp_alarm, IDX_TEMP1_CRIT);
698static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, IDX_TEMP2_INPUT);
699static SENSOR_DEVICE_ATTR_RW(temp2_min, temp, IDX_TEMP2_MIN);
700static SENSOR_DEVICE_ATTR_RW(temp2_max, temp, IDX_TEMP2_MAX);
701static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp, IDX_TEMP2_CRIT);
702static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp2_fault, 0);
703static SENSOR_DEVICE_ATTR_RO(temp2_min_alarm, temp_alarm, IDX_TEMP2_MIN);
704static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, temp_alarm, IDX_TEMP2_MAX);
705static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, temp_alarm, IDX_TEMP2_CRIT);
706static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, IDX_FAN1_INPUT);
707static SENSOR_DEVICE_ATTR_RW(fan1_min, fan, IDX_FAN1_MIN);
708static SENSOR_DEVICE_ATTR_RW(fan1_max, fan, IDX_FAN1_MAX);
709static SENSOR_DEVICE_ATTR_RO(fan1_fault, fan1_fault, 0);
710static SENSOR_DEVICE_ATTR_RW(fan1_div, fan1_div, 0);
711
712static SENSOR_DEVICE_ATTR_RW(pwm1, pwm1, 0);
713static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm1_enable, 0);
714static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point1_pwm, pwm1_auto_point_pwm, 0);
715static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm1_auto_point_pwm, 1);
716static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point3_pwm, pwm1_auto_point_pwm, 2);
717static SENSOR_DEVICE_ATTR_RO(pwm1_auto_channels_temp, pwm1_auto_channels_temp,
718			     0);
719static SENSOR_DEVICE_ATTR_2_RO(temp1_auto_point1_temp, temp_auto_point_temp,
720			       1, 0);
721static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point2_temp, temp_auto_point_temp,
722			       1, 1);
723static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point3_temp, temp_auto_point_temp,
724			       1, 2);
725
726static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point1_temp, temp_auto_point_temp,
727			       2, 0);
728static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point2_temp, temp_auto_point_temp,
729			       2, 1);
730static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point3_temp, temp_auto_point_temp,
731			       2, 2);
732
733static struct attribute *amc6821_attrs[] = {
734	&sensor_dev_attr_temp1_input.dev_attr.attr,
735	&sensor_dev_attr_temp1_min.dev_attr.attr,
736	&sensor_dev_attr_temp1_max.dev_attr.attr,
737	&sensor_dev_attr_temp1_crit.dev_attr.attr,
738	&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
739	&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
740	&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
741	&sensor_dev_attr_temp2_input.dev_attr.attr,
742	&sensor_dev_attr_temp2_min.dev_attr.attr,
743	&sensor_dev_attr_temp2_max.dev_attr.attr,
744	&sensor_dev_attr_temp2_crit.dev_attr.attr,
745	&sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
746	&sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
747	&sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
748	&sensor_dev_attr_temp2_fault.dev_attr.attr,
749	&sensor_dev_attr_fan1_input.dev_attr.attr,
750	&sensor_dev_attr_fan1_min.dev_attr.attr,
751	&sensor_dev_attr_fan1_max.dev_attr.attr,
752	&sensor_dev_attr_fan1_fault.dev_attr.attr,
753	&sensor_dev_attr_fan1_div.dev_attr.attr,
754	&sensor_dev_attr_pwm1.dev_attr.attr,
755	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
756	&sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
757	&sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
758	&sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
759	&sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
760	&sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
761	&sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
762	&sensor_dev_attr_temp1_auto_point3_temp.dev_attr.attr,
763	&sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
764	&sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
765	&sensor_dev_attr_temp2_auto_point3_temp.dev_attr.attr,
766	NULL
767};
768
769ATTRIBUTE_GROUPS(amc6821);
770
771/* Return 0 if detection is successful, -ENODEV otherwise */
772static int amc6821_detect(
773		struct i2c_client *client,
774		struct i2c_board_info *info)
775{
776	struct i2c_adapter *adapter = client->adapter;
777	int address = client->addr;
778	int dev_id, comp_id;
779
780	dev_dbg(&adapter->dev, "amc6821_detect called.\n");
781
782	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
783		dev_dbg(&adapter->dev,
784			"amc6821: I2C bus doesn't support byte mode, "
785			"skipping.\n");
786		return -ENODEV;
787	}
788
789	dev_id = i2c_smbus_read_byte_data(client, AMC6821_REG_DEV_ID);
790	comp_id = i2c_smbus_read_byte_data(client, AMC6821_REG_COMP_ID);
791	if (dev_id != 0x21 || comp_id != 0x49) {
792		dev_dbg(&adapter->dev,
793			"amc6821: detection failed at 0x%02x.\n",
794			address);
795		return -ENODEV;
796	}
797
798	/*
799	 * Bit 7 of the address register is ignored, so we can check the
800	 * ID registers again
801	 */
802	dev_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_DEV_ID);
803	comp_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_COMP_ID);
804	if (dev_id != 0x21 || comp_id != 0x49) {
805		dev_dbg(&adapter->dev,
806			"amc6821: detection failed at 0x%02x.\n",
807			address);
808		return -ENODEV;
809	}
810
811	dev_info(&adapter->dev, "amc6821: chip found at 0x%02x.\n", address);
812	strlcpy(info->type, "amc6821", I2C_NAME_SIZE);
813
814	return 0;
815}
816
817static int amc6821_init_client(struct i2c_client *client)
818{
819	int config;
820	int err = -EIO;
821
822	if (init) {
823		config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
824
825		if (config < 0) {
826				dev_err(&client->dev,
827			"Error reading configuration register, aborting.\n");
828				return err;
829		}
830
831		config |= AMC6821_CONF4_MODE;
832
833		if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4,
834				config)) {
835			dev_err(&client->dev,
836			"Configuration register write error, aborting.\n");
837			return err;
838		}
839
840		config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF3);
841
842		if (config < 0) {
843			dev_err(&client->dev,
844			"Error reading configuration register, aborting.\n");
845			return err;
846		}
847
848		dev_info(&client->dev, "Revision %d\n", config & 0x0f);
849
850		config &= ~AMC6821_CONF3_THERM_FAN_EN;
851
852		if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF3,
853				config)) {
854			dev_err(&client->dev,
855			"Configuration register write error, aborting.\n");
856			return err;
857		}
858
859		config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF2);
860
861		if (config < 0) {
862			dev_err(&client->dev,
863			"Error reading configuration register, aborting.\n");
864			return err;
865		}
866
867		config &= ~AMC6821_CONF2_RTFIE;
868		config &= ~AMC6821_CONF2_LTOIE;
869		config &= ~AMC6821_CONF2_RTOIE;
870		if (i2c_smbus_write_byte_data(client,
871				AMC6821_REG_CONF2, config)) {
872			dev_err(&client->dev,
873			"Configuration register write error, aborting.\n");
874			return err;
875		}
876
877		config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
878
879		if (config < 0) {
880			dev_err(&client->dev,
881			"Error reading configuration register, aborting.\n");
882			return err;
883		}
884
885		config &= ~AMC6821_CONF1_THERMOVIE;
886		config &= ~AMC6821_CONF1_FANIE;
887		config |= AMC6821_CONF1_START;
888		if (pwminv)
889			config |= AMC6821_CONF1_PWMINV;
890		else
891			config &= ~AMC6821_CONF1_PWMINV;
892
893		if (i2c_smbus_write_byte_data(
894				client, AMC6821_REG_CONF1, config)) {
895			dev_err(&client->dev,
896			"Configuration register write error, aborting.\n");
897			return err;
898		}
899	}
900	return 0;
901}
902
903static int amc6821_probe(struct i2c_client *client,
904			 const struct i2c_device_id *id)
905{
906	struct device *dev = &client->dev;
907	struct amc6821_data *data;
908	struct device *hwmon_dev;
909	int err;
910
911	data = devm_kzalloc(dev, sizeof(struct amc6821_data), GFP_KERNEL);
912	if (!data)
913		return -ENOMEM;
914
915	data->client = client;
916	mutex_init(&data->update_lock);
917
918	/*
919	 * Initialize the amc6821 chip
920	 */
921	err = amc6821_init_client(client);
922	if (err)
923		return err;
924
925	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
926							   data,
927							   amc6821_groups);
928	return PTR_ERR_OR_ZERO(hwmon_dev);
929}
930
931static const struct i2c_device_id amc6821_id[] = {
932	{ "amc6821", amc6821 },
933	{ }
934};
935
936MODULE_DEVICE_TABLE(i2c, amc6821_id);
937
938static struct i2c_driver amc6821_driver = {
939	.class = I2C_CLASS_HWMON,
940	.driver = {
941		.name	= "amc6821",
942	},
943	.probe = amc6821_probe,
944	.id_table = amc6821_id,
945	.detect = amc6821_detect,
946	.address_list = normal_i2c,
947};
948
949module_i2c_driver(amc6821_driver);
950
951MODULE_LICENSE("GPL");
952MODULE_AUTHOR("T. Mertelj <tomaz.mertelj@guest.arnes.si>");
953MODULE_DESCRIPTION("Texas Instruments amc6821 hwmon driver");