PageRenderTime 80ms CodeModel.GetById 36ms app.highlight 29ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/hwmon/f75375s.c

https://bitbucket.org/ndreys/linux-sunxi
C | 718 lines | 594 code | 86 blank | 38 comment | 46 complexity | be6d8a6f420cff8c69eda49ebe7256a1 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  1/*
  2 * f75375s.c - driver for the Fintek F75375/SP and F75373
  3 *             hardware monitoring features
  4 * Copyright (C) 2006-2007  Riku Voipio
  5 *
  6 * Datasheets available at:
  7 *
  8 * f75375:
  9 * http://www.fintek.com.tw/files/productfiles/F75375_V026P.pdf 
 10 *
 11 * f75373:
 12 * http://www.fintek.com.tw/files/productfiles/F75373_V025P.pdf
 13 *
 14 * This program is free software; you can redistribute it and/or modify
 15 * it under the terms of the GNU General Public License as published by
 16 * the Free Software Foundation; either version 2 of the License, or
 17 * (at your option) any later version.
 18 *
 19 * This program is distributed in the hope that it will be useful,
 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 22 * GNU General Public License for more details.
 23 *
 24 * You should have received a copy of the GNU General Public License
 25 * along with this program; if not, write to the Free Software
 26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 27 *
 28 */
 29
 30#include <linux/module.h>
 31#include <linux/jiffies.h>
 32#include <linux/hwmon.h>
 33#include <linux/hwmon-sysfs.h>
 34#include <linux/i2c.h>
 35#include <linux/err.h>
 36#include <linux/mutex.h>
 37#include <linux/f75375s.h>
 38#include <linux/slab.h>
 39
 40/* Addresses to scan */
 41static const unsigned short normal_i2c[] = { 0x2d, 0x2e, I2C_CLIENT_END };
 42
 43enum chips { f75373, f75375 };
 44
 45/* Fintek F75375 registers  */
 46#define F75375_REG_CONFIG0		0x0
 47#define F75375_REG_CONFIG1		0x1
 48#define F75375_REG_CONFIG2		0x2
 49#define F75375_REG_CONFIG3		0x3
 50#define F75375_REG_ADDR			0x4
 51#define F75375_REG_INTR			0x31
 52#define F75375_CHIP_ID			0x5A
 53#define F75375_REG_VERSION		0x5C
 54#define F75375_REG_VENDOR		0x5D
 55#define F75375_REG_FAN_TIMER		0x60
 56
 57#define F75375_REG_VOLT(nr)		(0x10 + (nr))
 58#define F75375_REG_VOLT_HIGH(nr)	(0x20 + (nr) * 2)
 59#define F75375_REG_VOLT_LOW(nr)		(0x21 + (nr) * 2)
 60
 61#define F75375_REG_TEMP(nr)		(0x14 + (nr))
 62#define F75375_REG_TEMP_HIGH(nr)	(0x28 + (nr) * 2)
 63#define F75375_REG_TEMP_HYST(nr)	(0x29 + (nr) * 2)
 64
 65#define F75375_REG_FAN(nr)		(0x16 + (nr) * 2)
 66#define F75375_REG_FAN_MIN(nr)		(0x2C + (nr) * 2)
 67#define F75375_REG_FAN_FULL(nr)		(0x70 + (nr) * 0x10)
 68#define F75375_REG_FAN_PWM_DUTY(nr)	(0x76 + (nr) * 0x10)
 69#define F75375_REG_FAN_PWM_CLOCK(nr)	(0x7D + (nr) * 0x10)
 70
 71#define F75375_REG_FAN_EXP(nr)		(0x74 + (nr) * 0x10)
 72#define F75375_REG_FAN_B_TEMP(nr, step)	((0xA0 + (nr) * 0x10) + (step))
 73#define F75375_REG_FAN_B_SPEED(nr, step) \
 74	((0xA5 + (nr) * 0x10) + (step) * 2)
 75
 76#define F75375_REG_PWM1_RAISE_DUTY	0x69
 77#define F75375_REG_PWM2_RAISE_DUTY	0x6A
 78#define F75375_REG_PWM1_DROP_DUTY	0x6B
 79#define F75375_REG_PWM2_DROP_DUTY	0x6C
 80
 81#define FAN_CTRL_LINEAR(nr)		(4 + nr)
 82#define FAN_CTRL_MODE(nr)		(4 + ((nr) * 2))
 83
 84/*
 85 * Data structures and manipulation thereof
 86 */
 87
 88struct f75375_data {
 89	unsigned short addr;
 90	struct device *hwmon_dev;
 91
 92	const char *name;
 93	int kind;
 94	struct mutex update_lock; /* protect register access */
 95	char valid;
 96	unsigned long last_updated;	/* In jiffies */
 97	unsigned long last_limits;	/* In jiffies */
 98
 99	/* Register values */
100	u8 in[4];
101	u8 in_max[4];
102	u8 in_min[4];
103	u16 fan[2];
104	u16 fan_min[2];
105	u16 fan_full[2];
106	u16 fan_exp[2];
107	u8 fan_timer;
108	u8 pwm[2];
109	u8 pwm_mode[2];
110	u8 pwm_enable[2];
111	s8 temp[2];
112	s8 temp_high[2];
113	s8 temp_max_hyst[2];
114};
115
116static int f75375_detect(struct i2c_client *client,
117			 struct i2c_board_info *info);
118static int f75375_probe(struct i2c_client *client,
119			const struct i2c_device_id *id);
120static int f75375_remove(struct i2c_client *client);
121
122static const struct i2c_device_id f75375_id[] = {
123	{ "f75373", f75373 },
124	{ "f75375", f75375 },
125	{ }
126};
127MODULE_DEVICE_TABLE(i2c, f75375_id);
128
129static struct i2c_driver f75375_driver = {
130	.class = I2C_CLASS_HWMON,
131	.driver = {
132		.name = "f75375",
133	},
134	.probe = f75375_probe,
135	.remove = f75375_remove,
136	.id_table = f75375_id,
137	.detect = f75375_detect,
138	.address_list = normal_i2c,
139};
140
141static inline int f75375_read8(struct i2c_client *client, u8 reg)
142{
143	return i2c_smbus_read_byte_data(client, reg);
144}
145
146/* in most cases, should be called while holding update_lock */
147static inline u16 f75375_read16(struct i2c_client *client, u8 reg)
148{
149	return ((i2c_smbus_read_byte_data(client, reg) << 8)
150		| i2c_smbus_read_byte_data(client, reg + 1));
151}
152
153static inline void f75375_write8(struct i2c_client *client, u8 reg,
154		u8 value)
155{
156	i2c_smbus_write_byte_data(client, reg, value);
157}
158
159static inline void f75375_write16(struct i2c_client *client, u8 reg,
160		u16 value)
161{
162	int err = i2c_smbus_write_byte_data(client, reg, (value >> 8));
163	if (err)
164		return;
165	i2c_smbus_write_byte_data(client, reg + 1, (value & 0xFF));
166}
167
168static struct f75375_data *f75375_update_device(struct device *dev)
169{
170	struct i2c_client *client = to_i2c_client(dev);
171	struct f75375_data *data = i2c_get_clientdata(client);
172	int nr;
173
174	mutex_lock(&data->update_lock);
175
176	/* Limit registers cache is refreshed after 60 seconds */
177	if (time_after(jiffies, data->last_limits + 60 * HZ)
178		|| !data->valid) {
179		for (nr = 0; nr < 2; nr++) {
180			data->temp_high[nr] =
181				f75375_read8(client, F75375_REG_TEMP_HIGH(nr));
182			data->temp_max_hyst[nr] =
183				f75375_read8(client, F75375_REG_TEMP_HYST(nr));
184			data->fan_full[nr] =
185				f75375_read16(client, F75375_REG_FAN_FULL(nr));
186			data->fan_min[nr] =
187				f75375_read16(client, F75375_REG_FAN_MIN(nr));
188			data->fan_exp[nr] =
189				f75375_read16(client, F75375_REG_FAN_EXP(nr));
190			data->pwm[nr] =	f75375_read8(client,
191				F75375_REG_FAN_PWM_DUTY(nr));
192
193		}
194		for (nr = 0; nr < 4; nr++) {
195			data->in_max[nr] =
196				f75375_read8(client, F75375_REG_VOLT_HIGH(nr));
197			data->in_min[nr] =
198				f75375_read8(client, F75375_REG_VOLT_LOW(nr));
199		}
200		data->fan_timer = f75375_read8(client, F75375_REG_FAN_TIMER);
201		data->last_limits = jiffies;
202	}
203
204	/* Measurement registers cache is refreshed after 2 second */
205	if (time_after(jiffies, data->last_updated + 2 * HZ)
206		|| !data->valid) {
207		for (nr = 0; nr < 2; nr++) {
208			data->temp[nr] =
209				f75375_read8(client, F75375_REG_TEMP(nr));
210			data->fan[nr] =
211				f75375_read16(client, F75375_REG_FAN(nr));
212		}
213		for (nr = 0; nr < 4; nr++)
214			data->in[nr] =
215				f75375_read8(client, F75375_REG_VOLT(nr));
216
217		data->last_updated = jiffies;
218		data->valid = 1;
219	}
220
221	mutex_unlock(&data->update_lock);
222	return data;
223}
224
225static inline u16 rpm_from_reg(u16 reg)
226{
227	if (reg == 0 || reg == 0xffff)
228		return 0;
229	return (1500000 / reg);
230}
231
232static inline u16 rpm_to_reg(int rpm)
233{
234	if (rpm < 367 || rpm > 0xffff)
235		return 0xffff;
236	return (1500000 / rpm);
237}
238
239static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
240		const char *buf, size_t count)
241{
242	int nr = to_sensor_dev_attr(attr)->index;
243	struct i2c_client *client = to_i2c_client(dev);
244	struct f75375_data *data = i2c_get_clientdata(client);
245	int val = simple_strtoul(buf, NULL, 10);
246
247	mutex_lock(&data->update_lock);
248	data->fan_min[nr] = rpm_to_reg(val);
249	f75375_write16(client, F75375_REG_FAN_MIN(nr), data->fan_min[nr]);
250	mutex_unlock(&data->update_lock);
251	return count;
252}
253
254static ssize_t set_fan_exp(struct device *dev, struct device_attribute *attr,
255		const char *buf, size_t count)
256{
257	int nr = to_sensor_dev_attr(attr)->index;
258	struct i2c_client *client = to_i2c_client(dev);
259	struct f75375_data *data = i2c_get_clientdata(client);
260	int val = simple_strtoul(buf, NULL, 10);
261
262	mutex_lock(&data->update_lock);
263	data->fan_exp[nr] = rpm_to_reg(val);
264	f75375_write16(client, F75375_REG_FAN_EXP(nr), data->fan_exp[nr]);
265	mutex_unlock(&data->update_lock);
266	return count;
267}
268
269static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
270		const char *buf, size_t count)
271{
272	int nr = to_sensor_dev_attr(attr)->index;
273	struct i2c_client *client = to_i2c_client(dev);
274	struct f75375_data *data = i2c_get_clientdata(client);
275	int val = simple_strtoul(buf, NULL, 10);
276
277	mutex_lock(&data->update_lock);
278	data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
279	f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr), data->pwm[nr]);
280	mutex_unlock(&data->update_lock);
281	return count;
282}
283
284static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
285		*attr, char *buf)
286{
287	int nr = to_sensor_dev_attr(attr)->index;
288	struct f75375_data *data = f75375_update_device(dev);
289	return sprintf(buf, "%d\n", data->pwm_enable[nr]);
290}
291
292static int set_pwm_enable_direct(struct i2c_client *client, int nr, int val)
293{
294	struct f75375_data *data = i2c_get_clientdata(client);
295	u8 fanmode;
296
297	if (val < 0 || val > 4)
298		return -EINVAL;
299
300	fanmode = f75375_read8(client, F75375_REG_FAN_TIMER);
301	fanmode &= ~(3 << FAN_CTRL_MODE(nr));
302
303	switch (val) {
304	case 0: /* Full speed */
305		fanmode  |= (3 << FAN_CTRL_MODE(nr));
306		data->pwm[nr] = 255;
307		break;
308	case 1: /* PWM */
309		fanmode  |= (3 << FAN_CTRL_MODE(nr));
310		break;
311	case 2: /* AUTOMATIC*/
312		fanmode  |= (1 << FAN_CTRL_MODE(nr));
313		break;
314	case 3: /* fan speed */
315		break;
316	}
317	f75375_write8(client, F75375_REG_FAN_TIMER, fanmode);
318	data->pwm_enable[nr] = val;
319	if (val == 0)
320		f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr),
321				data->pwm[nr]);
322	return 0;
323}
324
325static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr,
326		const char *buf, size_t count)
327{
328	int nr = to_sensor_dev_attr(attr)->index;
329	struct i2c_client *client = to_i2c_client(dev);
330	struct f75375_data *data = i2c_get_clientdata(client);
331	int val = simple_strtoul(buf, NULL, 10);
332	int err = 0;
333
334	mutex_lock(&data->update_lock);
335	err = set_pwm_enable_direct(client, nr, val);
336	mutex_unlock(&data->update_lock);
337	return err ? err : count;
338}
339
340static ssize_t set_pwm_mode(struct device *dev, struct device_attribute *attr,
341		const char *buf, size_t count)
342{
343	int nr = to_sensor_dev_attr(attr)->index;
344	struct i2c_client *client = to_i2c_client(dev);
345	struct f75375_data *data = i2c_get_clientdata(client);
346	int val = simple_strtoul(buf, NULL, 10);
347	u8 conf = 0;
348
349	if (!(val == 0 || val == 1))
350		return -EINVAL;
351
352	mutex_lock(&data->update_lock);
353	conf = f75375_read8(client, F75375_REG_CONFIG1);
354	conf &= ~(1 << FAN_CTRL_LINEAR(nr));
355
356	if (val == 0)
357		conf |= (1 << FAN_CTRL_LINEAR(nr)) ;
358
359	f75375_write8(client, F75375_REG_CONFIG1, conf);
360	data->pwm_mode[nr] = val;
361	mutex_unlock(&data->update_lock);
362	return count;
363}
364
365static ssize_t show_pwm(struct device *dev, struct device_attribute
366		*attr, char *buf)
367{
368	int nr = to_sensor_dev_attr(attr)->index;
369	struct f75375_data *data = f75375_update_device(dev);
370	return sprintf(buf, "%d\n", data->pwm[nr]);
371}
372
373static ssize_t show_pwm_mode(struct device *dev, struct device_attribute
374		*attr, char *buf)
375{
376	int nr = to_sensor_dev_attr(attr)->index;
377	struct f75375_data *data = f75375_update_device(dev);
378	return sprintf(buf, "%d\n", data->pwm_mode[nr]);
379}
380
381#define VOLT_FROM_REG(val) ((val) * 8)
382#define VOLT_TO_REG(val) ((val) / 8)
383
384static ssize_t show_in(struct device *dev, struct device_attribute *attr,
385		char *buf)
386{
387	int nr = to_sensor_dev_attr(attr)->index;
388	struct f75375_data *data = f75375_update_device(dev);
389	return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in[nr]));
390}
391
392static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
393		char *buf)
394{
395	int nr = to_sensor_dev_attr(attr)->index;
396	struct f75375_data *data = f75375_update_device(dev);
397	return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_max[nr]));
398}
399
400static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
401		char *buf)
402{
403	int nr = to_sensor_dev_attr(attr)->index;
404	struct f75375_data *data = f75375_update_device(dev);
405	return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_min[nr]));
406}
407
408static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
409		const char *buf, size_t count)
410{
411	int nr = to_sensor_dev_attr(attr)->index;
412	struct i2c_client *client = to_i2c_client(dev);
413	struct f75375_data *data = i2c_get_clientdata(client);
414	int val = simple_strtoul(buf, NULL, 10);
415	val = SENSORS_LIMIT(VOLT_TO_REG(val), 0, 0xff);
416	mutex_lock(&data->update_lock);
417	data->in_max[nr] = val;
418	f75375_write8(client, F75375_REG_VOLT_HIGH(nr), data->in_max[nr]);
419	mutex_unlock(&data->update_lock);
420	return count;
421}
422
423static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
424		const char *buf, size_t count)
425{
426	int nr = to_sensor_dev_attr(attr)->index;
427	struct i2c_client *client = to_i2c_client(dev);
428	struct f75375_data *data = i2c_get_clientdata(client);
429	int val = simple_strtoul(buf, NULL, 10);
430	val = SENSORS_LIMIT(VOLT_TO_REG(val), 0, 0xff);
431	mutex_lock(&data->update_lock);
432	data->in_min[nr] = val;
433	f75375_write8(client, F75375_REG_VOLT_LOW(nr), data->in_min[nr]);
434	mutex_unlock(&data->update_lock);
435	return count;
436}
437#define TEMP_FROM_REG(val) ((val) * 1000)
438#define TEMP_TO_REG(val) ((val) / 1000)
439
440static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
441		char *buf)
442{
443	int nr = to_sensor_dev_attr(attr)->index;
444	struct f75375_data *data = f75375_update_device(dev);
445	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
446}
447
448static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
449		char *buf)
450{
451	int nr = to_sensor_dev_attr(attr)->index;
452	struct f75375_data *data = f75375_update_device(dev);
453	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
454}
455
456static ssize_t show_temp_max_hyst(struct device *dev,
457		struct device_attribute *attr, char *buf)
458{
459	int nr = to_sensor_dev_attr(attr)->index;
460	struct f75375_data *data = f75375_update_device(dev);
461	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[nr]));
462}
463
464static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
465		const char *buf, size_t count)
466{
467	int nr = to_sensor_dev_attr(attr)->index;
468	struct i2c_client *client = to_i2c_client(dev);
469	struct f75375_data *data = i2c_get_clientdata(client);
470	int val = simple_strtol(buf, NULL, 10);
471	val = SENSORS_LIMIT(TEMP_TO_REG(val), 0, 127);
472	mutex_lock(&data->update_lock);
473	data->temp_high[nr] = val;
474	f75375_write8(client, F75375_REG_TEMP_HIGH(nr), data->temp_high[nr]);
475	mutex_unlock(&data->update_lock);
476	return count;
477}
478
479static ssize_t set_temp_max_hyst(struct device *dev,
480	struct device_attribute *attr, const char *buf, size_t count)
481{
482	int nr = to_sensor_dev_attr(attr)->index;
483	struct i2c_client *client = to_i2c_client(dev);
484	struct f75375_data *data = i2c_get_clientdata(client);
485	int val = simple_strtol(buf, NULL, 10);
486	val = SENSORS_LIMIT(TEMP_TO_REG(val), 0, 127);
487	mutex_lock(&data->update_lock);
488	data->temp_max_hyst[nr] = val;
489	f75375_write8(client, F75375_REG_TEMP_HYST(nr),
490		data->temp_max_hyst[nr]);
491	mutex_unlock(&data->update_lock);
492	return count;
493}
494
495#define show_fan(thing) \
496static ssize_t show_##thing(struct device *dev, struct device_attribute *attr, \
497			char *buf)\
498{\
499	int nr = to_sensor_dev_attr(attr)->index;\
500	struct f75375_data *data = f75375_update_device(dev); \
501	return sprintf(buf, "%d\n", rpm_from_reg(data->thing[nr])); \
502}
503
504show_fan(fan);
505show_fan(fan_min);
506show_fan(fan_full);
507show_fan(fan_exp);
508
509static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in, NULL, 0);
510static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO|S_IWUSR,
511	show_in_max, set_in_max, 0);
512static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO|S_IWUSR,
513	show_in_min, set_in_min, 0);
514static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1);
515static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO|S_IWUSR,
516	show_in_max, set_in_max, 1);
517static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO|S_IWUSR,
518	show_in_min, set_in_min, 1);
519static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2);
520static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO|S_IWUSR,
521	show_in_max, set_in_max, 2);
522static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO|S_IWUSR,
523	show_in_min, set_in_min, 2);
524static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3);
525static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO|S_IWUSR,
526	show_in_max, set_in_max, 3);
527static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO|S_IWUSR,
528	show_in_min, set_in_min, 3);
529static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
530static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO|S_IWUSR,
531	show_temp_max_hyst, set_temp_max_hyst, 0);
532static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO|S_IWUSR,
533	show_temp_max, set_temp_max, 0);
534static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
535static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO|S_IWUSR,
536	show_temp_max_hyst, set_temp_max_hyst, 1);
537static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO|S_IWUSR,
538	show_temp_max, set_temp_max, 1);
539static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
540static SENSOR_DEVICE_ATTR(fan1_full, S_IRUGO, show_fan_full, NULL, 0);
541static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO|S_IWUSR,
542	show_fan_min, set_fan_min, 0);
543static SENSOR_DEVICE_ATTR(fan1_exp, S_IRUGO|S_IWUSR,
544	show_fan_exp, set_fan_exp, 0);
545static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
546static SENSOR_DEVICE_ATTR(fan2_full, S_IRUGO, show_fan_full, NULL, 1);
547static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO|S_IWUSR,
548	show_fan_min, set_fan_min, 1);
549static SENSOR_DEVICE_ATTR(fan2_exp, S_IRUGO|S_IWUSR,
550	show_fan_exp, set_fan_exp, 1);
551static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO|S_IWUSR,
552	show_pwm, set_pwm, 0);
553static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO|S_IWUSR,
554	show_pwm_enable, set_pwm_enable, 0);
555static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO,
556	show_pwm_mode, set_pwm_mode, 0);
557static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR,
558	show_pwm, set_pwm, 1);
559static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO|S_IWUSR,
560	show_pwm_enable, set_pwm_enable, 1);
561static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO,
562	show_pwm_mode, set_pwm_mode, 1);
563
564static struct attribute *f75375_attributes[] = {
565	&sensor_dev_attr_temp1_input.dev_attr.attr,
566	&sensor_dev_attr_temp1_max.dev_attr.attr,
567	&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
568	&sensor_dev_attr_temp2_input.dev_attr.attr,
569	&sensor_dev_attr_temp2_max.dev_attr.attr,
570	&sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
571	&sensor_dev_attr_fan1_input.dev_attr.attr,
572	&sensor_dev_attr_fan1_full.dev_attr.attr,
573	&sensor_dev_attr_fan1_min.dev_attr.attr,
574	&sensor_dev_attr_fan1_exp.dev_attr.attr,
575	&sensor_dev_attr_fan2_input.dev_attr.attr,
576	&sensor_dev_attr_fan2_full.dev_attr.attr,
577	&sensor_dev_attr_fan2_min.dev_attr.attr,
578	&sensor_dev_attr_fan2_exp.dev_attr.attr,
579	&sensor_dev_attr_pwm1.dev_attr.attr,
580	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
581	&sensor_dev_attr_pwm1_mode.dev_attr.attr,
582	&sensor_dev_attr_pwm2.dev_attr.attr,
583	&sensor_dev_attr_pwm2_enable.dev_attr.attr,
584	&sensor_dev_attr_pwm2_mode.dev_attr.attr,
585	&sensor_dev_attr_in0_input.dev_attr.attr,
586	&sensor_dev_attr_in0_max.dev_attr.attr,
587	&sensor_dev_attr_in0_min.dev_attr.attr,
588	&sensor_dev_attr_in1_input.dev_attr.attr,
589	&sensor_dev_attr_in1_max.dev_attr.attr,
590	&sensor_dev_attr_in1_min.dev_attr.attr,
591	&sensor_dev_attr_in2_input.dev_attr.attr,
592	&sensor_dev_attr_in2_max.dev_attr.attr,
593	&sensor_dev_attr_in2_min.dev_attr.attr,
594	&sensor_dev_attr_in3_input.dev_attr.attr,
595	&sensor_dev_attr_in3_max.dev_attr.attr,
596	&sensor_dev_attr_in3_min.dev_attr.attr,
597	NULL
598};
599
600static const struct attribute_group f75375_group = {
601	.attrs = f75375_attributes,
602};
603
604static void f75375_init(struct i2c_client *client, struct f75375_data *data,
605		struct f75375s_platform_data *f75375s_pdata)
606{
607	int nr;
608	set_pwm_enable_direct(client, 0, f75375s_pdata->pwm_enable[0]);
609	set_pwm_enable_direct(client, 1, f75375s_pdata->pwm_enable[1]);
610	for (nr = 0; nr < 2; nr++) {
611		data->pwm[nr] = SENSORS_LIMIT(f75375s_pdata->pwm[nr], 0, 255);
612		f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr),
613			data->pwm[nr]);
614	}
615
616}
617
618static int f75375_probe(struct i2c_client *client,
619		const struct i2c_device_id *id)
620{
621	struct f75375_data *data;
622	struct f75375s_platform_data *f75375s_pdata = client->dev.platform_data;
623	int err;
624
625	if (!i2c_check_functionality(client->adapter,
626				I2C_FUNC_SMBUS_BYTE_DATA))
627		return -EIO;
628	if (!(data = kzalloc(sizeof(struct f75375_data), GFP_KERNEL)))
629		return -ENOMEM;
630
631	i2c_set_clientdata(client, data);
632	mutex_init(&data->update_lock);
633	data->kind = id->driver_data;
634
635	if ((err = sysfs_create_group(&client->dev.kobj, &f75375_group)))
636		goto exit_free;
637
638	if (data->kind == f75375) {
639		err = sysfs_chmod_file(&client->dev.kobj,
640			&sensor_dev_attr_pwm1_mode.dev_attr.attr,
641			S_IRUGO | S_IWUSR);
642		if (err)
643			goto exit_remove;
644		err = sysfs_chmod_file(&client->dev.kobj,
645			&sensor_dev_attr_pwm2_mode.dev_attr.attr,
646			S_IRUGO | S_IWUSR);
647		if (err)
648			goto exit_remove;
649	}
650
651	data->hwmon_dev = hwmon_device_register(&client->dev);
652	if (IS_ERR(data->hwmon_dev)) {
653		err = PTR_ERR(data->hwmon_dev);
654		goto exit_remove;
655	}
656
657	if (f75375s_pdata != NULL)
658		f75375_init(client, data, f75375s_pdata);
659
660	return 0;
661
662exit_remove:
663	sysfs_remove_group(&client->dev.kobj, &f75375_group);
664exit_free:
665	kfree(data);
666	return err;
667}
668
669static int f75375_remove(struct i2c_client *client)
670{
671	struct f75375_data *data = i2c_get_clientdata(client);
672	hwmon_device_unregister(data->hwmon_dev);
673	sysfs_remove_group(&client->dev.kobj, &f75375_group);
674	kfree(data);
675	return 0;
676}
677
678/* Return 0 if detection is successful, -ENODEV otherwise */
679static int f75375_detect(struct i2c_client *client,
680			 struct i2c_board_info *info)
681{
682	struct i2c_adapter *adapter = client->adapter;
683	u16 vendid, chipid;
684	u8 version;
685	const char *name;
686
687	vendid = f75375_read16(client, F75375_REG_VENDOR);
688	chipid = f75375_read16(client, F75375_CHIP_ID);
689	if (chipid == 0x0306 && vendid == 0x1934)
690		name = "f75375";
691	else if (chipid == 0x0204 && vendid == 0x1934)
692		name = "f75373";
693	else
694		return -ENODEV;
695
696	version = f75375_read8(client, F75375_REG_VERSION);
697	dev_info(&adapter->dev, "found %s version: %02X\n", name, version);
698	strlcpy(info->type, name, I2C_NAME_SIZE);
699
700	return 0;
701}
702
703static int __init sensors_f75375_init(void)
704{
705	return i2c_add_driver(&f75375_driver);
706}
707
708static void __exit sensors_f75375_exit(void)
709{
710	i2c_del_driver(&f75375_driver);
711}
712
713MODULE_AUTHOR("Riku Voipio");
714MODULE_LICENSE("GPL");
715MODULE_DESCRIPTION("F75373/F75375 hardware monitoring driver");
716
717module_init(sensors_f75375_init);
718module_exit(sensors_f75375_exit);