[deliverable/linux.git] / drivers / w1 / slaves / w1_therm.c

/*
 *	w1_therm.c
 *
 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the therms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <asm/types.h>

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/sched.h>
#include <linux/device.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/delay.h>

#include "../w1.h"
#include "../w1_int.h"
#include "../w1_family.h"

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18S20));
MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1822));
MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18B20));
MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1825));
MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00));

/* Allow the strong pullup to be disabled, but default to enabled.
 * If it was disabled a parasite powered device might not get the require
 * current to do a temperature conversion.  If it is enabled parasite powered
 * devices have a better chance of getting the current required.
 * In case the parasite power-detection is not working (seems to be the case
 * for some DS18S20) the strong pullup can also be forced, regardless of the
 * power state of the devices.
 *
 * Summary of options:
 * - strong_pullup = 0	Disable strong pullup completely
 * - strong_pullup = 1	Enable automatic strong pullup detection
 * - strong_pullup = 2	Force strong pullup
 */
static int w1_strong_pullup = 1;
module_param_named(strong_pullup, w1_strong_pullup, int, 0);

struct w1_therm_family_data {
	uint8_t rom[9];
	atomic_t refcnt;
};

/* return the address of the refcnt in the family data */
#define THERM_REFCNT(family_data) \
	(&((struct w1_therm_family_data *)family_data)->refcnt)

static int w1_therm_add_slave(struct w1_slave *sl)
{
	sl->family_data = kzalloc(sizeof(struct w1_therm_family_data),
		GFP_KERNEL);
	if (!sl->family_data)
		return -ENOMEM;
	atomic_set(THERM_REFCNT(sl->family_data), 1);
	return 0;
}

static void w1_therm_remove_slave(struct w1_slave *sl)
{
	int refcnt = atomic_sub_return(1, THERM_REFCNT(sl->family_data));

	while (refcnt) {
		msleep(1000);
		refcnt = atomic_read(THERM_REFCNT(sl->family_data));
	}
	kfree(sl->family_data);
	sl->family_data = NULL;
}

static ssize_t w1_slave_show(struct device *device,
	struct device_attribute *attr, char *buf);

static ssize_t w1_slave_store(struct device *device,
	struct device_attribute *attr, const char *buf, size_t size);

static ssize_t w1_seq_show(struct device *device,
	struct device_attribute *attr, char *buf);

static DEVICE_ATTR_RW(w1_slave);
static DEVICE_ATTR_RO(w1_seq);

static struct attribute *w1_therm_attrs[] = {
	&dev_attr_w1_slave.attr,
	NULL,
};

static struct attribute *w1_ds28ea00_attrs[] = {
	&dev_attr_w1_slave.attr,
	&dev_attr_w1_seq.attr,
	NULL,
};
ATTRIBUTE_GROUPS(w1_therm);
ATTRIBUTE_GROUPS(w1_ds28ea00);

static struct w1_family_ops w1_therm_fops = {
	.add_slave	= w1_therm_add_slave,
	.remove_slave	= w1_therm_remove_slave,
	.groups		= w1_therm_groups,
};

static struct w1_family_ops w1_ds28ea00_fops = {
	.add_slave	= w1_therm_add_slave,
	.remove_slave	= w1_therm_remove_slave,
	.groups		= w1_ds28ea00_groups,
};

static struct w1_family w1_therm_family_DS18S20 = {
	.fid = W1_THERM_DS18S20,
	.fops = &w1_therm_fops,
};

static struct w1_family w1_therm_family_DS18B20 = {
	.fid = W1_THERM_DS18B20,
	.fops = &w1_therm_fops,
};

static struct w1_family w1_therm_family_DS1822 = {
	.fid = W1_THERM_DS1822,
	.fops = &w1_therm_fops,
};

static struct w1_family w1_therm_family_DS28EA00 = {
	.fid = W1_THERM_DS28EA00,
	.fops = &w1_ds28ea00_fops,
};

static struct w1_family w1_therm_family_DS1825 = {
	.fid = W1_THERM_DS1825,
	.fops = &w1_therm_fops,
};

struct w1_therm_family_converter {
	u8			broken;
	u16			reserved;
	struct w1_family	*f;
	int			(*convert)(u8 rom[9]);
	int			(*precision)(struct device *device, int val);
	int			(*eeprom)(struct device *device);
};

/* write configuration to eeprom */
static inline int w1_therm_eeprom(struct device *device);

/* Set precision for conversion */
static inline int w1_DS18B20_precision(struct device *device, int val);
static inline int w1_DS18S20_precision(struct device *device, int val);

/* The return value is millidegrees Centigrade. */
static inline int w1_DS18B20_convert_temp(u8 rom[9]);
static inline int w1_DS18S20_convert_temp(u8 rom[9]);

static struct w1_therm_family_converter w1_therm_families[] = {
	{
		.f		= &w1_therm_family_DS18S20,
		.convert	= w1_DS18S20_convert_temp,
		.precision	= w1_DS18S20_precision,
		.eeprom		= w1_therm_eeprom
	},
	{
		.f		= &w1_therm_family_DS1822,
		.convert	= w1_DS18B20_convert_temp,
		.precision	= w1_DS18S20_precision,
		.eeprom		= w1_therm_eeprom
	},
	{
		.f		= &w1_therm_family_DS18B20,
		.convert	= w1_DS18B20_convert_temp,
		.precision	= w1_DS18B20_precision,
		.eeprom		= w1_therm_eeprom
	},
	{
		.f		= &w1_therm_family_DS28EA00,
		.convert	= w1_DS18B20_convert_temp,
		.precision	= w1_DS18S20_precision,
		.eeprom		= w1_therm_eeprom
	},
	{
		.f		= &w1_therm_family_DS1825,
		.convert	= w1_DS18B20_convert_temp,
		.precision	= w1_DS18S20_precision,
		.eeprom		= w1_therm_eeprom
	}
};

static inline int w1_therm_eeprom(struct device *device)
{
	struct w1_slave *sl = dev_to_w1_slave(device);
	struct w1_master *dev = sl->master;
	u8 rom[9], external_power;
	int ret, max_trying = 10;
	u8 *family_data = sl->family_data;

	ret = mutex_lock_interruptible(&dev->bus_mutex);
	if (ret != 0)
		goto post_unlock;

	if (!sl->family_data) {
		ret = -ENODEV;
		goto pre_unlock;
	}

	/* prevent the slave from going away in sleep */
	atomic_inc(THERM_REFCNT(family_data));
	memset(rom, 0, sizeof(rom));

	while (max_trying--) {
		if (!w1_reset_select_slave(sl)) {
			unsigned int tm = 10;
			unsigned long sleep_rem;

			/* check if in parasite mode */
			w1_write_8(dev, W1_READ_PSUPPLY);
			external_power = w1_read_8(dev);

			if (w1_reset_select_slave(sl))
				continue;

			/* 10ms strong pullup/delay after the copy command */
			if (w1_strong_pullup == 2 ||
			    (!external_power && w1_strong_pullup))
				w1_next_pullup(dev, tm);

			w1_write_8(dev, W1_COPY_SCRATCHPAD);

			if (external_power) {
				mutex_unlock(&dev->bus_mutex);

				sleep_rem = msleep_interruptible(tm);
				if (sleep_rem != 0) {
					ret = -EINTR;
					goto post_unlock;
				}

				ret = mutex_lock_interruptible(&dev->bus_mutex);
				if (ret != 0)
					goto post_unlock;
			} else if (!w1_strong_pullup) {
				sleep_rem = msleep_interruptible(tm);
				if (sleep_rem != 0) {
					ret = -EINTR;
					goto pre_unlock;
				}
			}

			break;
		}
	}

pre_unlock:
	mutex_unlock(&dev->bus_mutex);

post_unlock:
	atomic_dec(THERM_REFCNT(family_data));
	return ret;
}

/* DS18S20 does not feature configuration register */
static inline int w1_DS18S20_precision(struct device *device, int val)
{
	return 0;
}

static inline int w1_DS18B20_precision(struct device *device, int val)
{
	struct w1_slave *sl = dev_to_w1_slave(device);
	struct w1_master *dev = sl->master;
	u8 rom[9], crc;
	int ret, max_trying = 10;
	u8 *family_data = sl->family_data;
	uint8_t precision_bits;
	uint8_t mask = 0x60;

	if (val > 12 || val < 9) {
		pr_warn("Unsupported precision\n");
		return -1;
	}

	ret = mutex_lock_interruptible(&dev->bus_mutex);
	if (ret != 0)
		goto post_unlock;

	if (!sl->family_data) {
		ret = -ENODEV;
		goto pre_unlock;
	}

	/* prevent the slave from going away in sleep */
	atomic_inc(THERM_REFCNT(family_data));
	memset(rom, 0, sizeof(rom));

	/* translate precision to bitmask (see datasheet page 9) */
	switch (val) {
	case 9:
		precision_bits = 0x00;
		break;
	case 10:
		precision_bits = 0x20;
		break;
	case 11:
		precision_bits = 0x40;
		break;
	case 12:
	default:
		precision_bits = 0x60;
		break;
	}

	while (max_trying--) {
		crc = 0;

		if (!w1_reset_select_slave(sl)) {
			int count = 0;

			/* read values to only alter precision bits */
			w1_write_8(dev, W1_READ_SCRATCHPAD);
			count = w1_read_block(dev, rom, 9);
			if (count != 9)
				dev_warn(device, "w1_read_block() returned %u instead of 9.\n",	count);

			crc = w1_calc_crc8(rom, 8);
			if (rom[8] == crc) {
				rom[4] = (rom[4] & ~mask) | (precision_bits & mask);

				if (!w1_reset_select_slave(sl)) {
					w1_write_8(dev, W1_WRITE_SCRATCHPAD);
					w1_write_8(dev, rom[2]);
					w1_write_8(dev, rom[3]);
					w1_write_8(dev, rom[4]);

					break;
				}
			}
		}
	}

pre_unlock:
	mutex_unlock(&dev->bus_mutex);

post_unlock:
	atomic_dec(THERM_REFCNT(family_data));
	return ret;
}

static inline int w1_DS18B20_convert_temp(u8 rom[9])
{
	s16 t = le16_to_cpup((__le16 *)rom);

	return t*1000/16;
}

static inline int w1_DS18S20_convert_temp(u8 rom[9])
{
	int t, h;

	if (!rom[7])
		return 0;

	if (rom[1] == 0)
		t = ((s32)rom[0] >> 1)*1000;
	else
		t = 1000*(-1*(s32)(0x100-rom[0]) >> 1);

	t -= 250;
	h = 1000*((s32)rom[7] - (s32)rom[6]);
	h /= (s32)rom[7];
	t += h;

	return t;
}

static inline int w1_convert_temp(u8 rom[9], u8 fid)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
		if (w1_therm_families[i].f->fid == fid)
			return w1_therm_families[i].convert(rom);

	return 0;
}

static ssize_t w1_slave_store(struct device *device,
			      struct device_attribute *attr, const char *buf,
			      size_t size)
{
	int val, ret;
	struct w1_slave *sl = dev_to_w1_slave(device);
	int i;

	ret = kstrtoint(buf, 0, &val);
	if (ret)
		return ret;

	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
		if (w1_therm_families[i].f->fid == sl->family->fid) {
			/* zero value indicates to write current configuration to eeprom */
			if (val == 0)
				ret = w1_therm_families[i].eeprom(device);
			else
				ret = w1_therm_families[i].precision(device, val);
			break;
		}
	}
	return ret ? : size;
}

static ssize_t w1_slave_show(struct device *device,
	struct device_attribute *attr, char *buf)
{
	struct w1_slave *sl = dev_to_w1_slave(device);
	struct w1_master *dev = sl->master;
	u8 rom[9], crc, verdict, external_power;
	int i, ret, max_trying = 10;
	ssize_t c = PAGE_SIZE;
	u8 *family_data = sl->family_data;

	ret = mutex_lock_interruptible(&dev->bus_mutex);
	if (ret != 0)
		goto post_unlock;

	if (!sl->family_data) {
		ret = -ENODEV;
		goto pre_unlock;
	}

	/* prevent the slave from going away in sleep */
	atomic_inc(THERM_REFCNT(family_data));
	memset(rom, 0, sizeof(rom));

	while (max_trying--) {

		verdict = 0;
		crc = 0;

		if (!w1_reset_select_slave(sl)) {
			int count = 0;
			unsigned int tm = 750;
			unsigned long sleep_rem;

			w1_write_8(dev, W1_READ_PSUPPLY);
			external_power = w1_read_8(dev);

			if (w1_reset_select_slave(sl))
				continue;

			/* 750ms strong pullup (or delay) after the convert */
			if (w1_strong_pullup == 2 ||
					(!external_power && w1_strong_pullup))
				w1_next_pullup(dev, tm);

			w1_write_8(dev, W1_CONVERT_TEMP);

			if (external_power) {
				mutex_unlock(&dev->bus_mutex);

				sleep_rem = msleep_interruptible(tm);
				if (sleep_rem != 0) {
					ret = -EINTR;
					goto post_unlock;
				}

				ret = mutex_lock_interruptible(&dev->bus_mutex);
				if (ret != 0)
					goto post_unlock;
			} else if (!w1_strong_pullup) {
				sleep_rem = msleep_interruptible(tm);
				if (sleep_rem != 0) {
					ret = -EINTR;
					goto pre_unlock;
				}
			}

			if (!w1_reset_select_slave(sl)) {

				w1_write_8(dev, W1_READ_SCRATCHPAD);
				count = w1_read_block(dev, rom, 9);
				if (count != 9) {
					dev_warn(device, "w1_read_block() "
						"returned %u instead of 9.\n",
						count);
				}

				crc = w1_calc_crc8(rom, 8);

				if (rom[8] == crc)
					verdict = 1;
			}
		}

		if (verdict)
			break;
	}

	for (i = 0; i < 9; ++i)
		c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", rom[i]);
	c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
		      crc, (verdict) ? "YES" : "NO");
	if (verdict)
		memcpy(family_data, rom, sizeof(rom));
	else
		dev_warn(device, "Read failed CRC check\n");

	for (i = 0; i < 9; ++i)
		c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ",
			      ((u8 *)family_data)[i]);

	c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
		w1_convert_temp(rom, sl->family->fid));
	ret = PAGE_SIZE - c;

pre_unlock:
	mutex_unlock(&dev->bus_mutex);

post_unlock:
	atomic_dec(THERM_REFCNT(family_data));
	return ret;
}

#define W1_42_CHAIN	0x99
#define W1_42_CHAIN_OFF	0x3C
#define W1_42_CHAIN_OFF_INV	0xC3
#define W1_42_CHAIN_ON	0x5A
#define W1_42_CHAIN_ON_INV	0xA5
#define W1_42_CHAIN_DONE 0x96
#define W1_42_CHAIN_DONE_INV 0x69
#define W1_42_COND_READ	0x0F
#define W1_42_SUCCESS_CONFIRM_BYTE 0xAA
#define W1_42_FINISHED_BYTE 0xFF
static ssize_t w1_seq_show(struct device *device,
	struct device_attribute *attr, char *buf)
{
	struct w1_slave *sl = dev_to_w1_slave(device);
	ssize_t c = PAGE_SIZE;
	int rv;
	int i;
	u8 ack;
	u64 rn;
	struct w1_reg_num *reg_num;
	int seq = 0;

	mutex_lock(&sl->master->bus_mutex);
	/* Place all devices in CHAIN state */
	if (w1_reset_bus(sl->master))
		goto error;
	w1_write_8(sl->master, W1_SKIP_ROM);
	w1_write_8(sl->master, W1_42_CHAIN);
	w1_write_8(sl->master, W1_42_CHAIN_ON);
	w1_write_8(sl->master, W1_42_CHAIN_ON_INV);
	msleep(sl->master->pullup_duration);

	/* check for acknowledgment */
	ack = w1_read_8(sl->master);
	if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
		goto error;

	/* In case the bus fails to send 0xFF, limit*/
	for (i = 0; i <= 64; i++) {
		if (w1_reset_bus(sl->master))
			goto error;

		w1_write_8(sl->master, W1_42_COND_READ);
		rv = w1_read_block(sl->master, (u8 *)&rn, 8);
		reg_num = (struct w1_reg_num *) &rn;
		if (reg_num->family == W1_42_FINISHED_BYTE)
			break;
		if (sl->reg_num.id == reg_num->id)
			seq = i;

		w1_write_8(sl->master, W1_42_CHAIN);
		w1_write_8(sl->master, W1_42_CHAIN_DONE);
		w1_write_8(sl->master, W1_42_CHAIN_DONE_INV);
		w1_read_block(sl->master, &ack, sizeof(ack));

		/* check for acknowledgment */
		ack = w1_read_8(sl->master);
		if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
			goto error;

	}

	/* Exit from CHAIN state */
	if (w1_reset_bus(sl->master))
		goto error;
	w1_write_8(sl->master, W1_SKIP_ROM);
	w1_write_8(sl->master, W1_42_CHAIN);
	w1_write_8(sl->master, W1_42_CHAIN_OFF);
	w1_write_8(sl->master, W1_42_CHAIN_OFF_INV);

	/* check for acknowledgment */
	ack = w1_read_8(sl->master);
	if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
		goto error;
	mutex_unlock(&sl->master->bus_mutex);

	c -= snprintf(buf + PAGE_SIZE - c, c, "%d\n", seq);
	return PAGE_SIZE - c;
error:
	mutex_unlock(&sl->master->bus_mutex);
	return -EIO;
}

static int __init w1_therm_init(void)
{
	int err, i;

	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
		err = w1_register_family(w1_therm_families[i].f);
		if (err)
			w1_therm_families[i].broken = 1;
	}

	return 0;
}

static void __exit w1_therm_fini(void)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
		if (!w1_therm_families[i].broken)
			w1_unregister_family(w1_therm_families[i].f);
}

module_init(w1_therm_init);
module_exit(w1_therm_fini);
Commit	Line	Data
1da177e4	1	/*
7785925d	2	* w1_therm.c
1da177e4	3	*
a8018766	4	* Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
7785925d	5	*
1da177e4 LT	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the therms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*/
	21
	22	#include <asm/types.h>
	23
	24	#include <linux/kernel.h>
	25	#include <linux/module.h>
	26	#include <linux/moduleparam.h>
f6a57033	27	#include <linux/sched.h>
1da177e4 LT	28	#include <linux/device.h>
1da177e4 LT	29	#include <linux/types.h>
eb2c0da4	30	#include <linux/slab.h>
1da177e4 LT	31	#include <linux/delay.h>
1da177e4 LT	32
bd529cfb	33	#include "../w1.h"
bd529cfb EP	34	#include "../w1_int.h"
bd529cfb EP	35	#include "../w1_family.h"
1da177e4 LT	36
1da177e4 LT	37	MODULE_LICENSE("GPL");
a8018766	38	MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
1da177e4	39	MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
8d7bda51 AS	40	MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18S20));
	41	MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1822));
	42	MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18B20));
	43	MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1825));
	44	MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00));
1da177e4	45
6cd15974 DF	46	/* Allow the strong pullup to be disabled, but default to enabled.
	47	* If it was disabled a parasite powered device might not get the require
	48	* current to do a temperature conversion. If it is enabled parasite powered
	49	* devices have a better chance of getting the current required.
29e5507a MA	50	* In case the parasite power-detection is not working (seems to be the case
	51	* for some DS18S20) the strong pullup can also be forced, regardless of the
	52	* power state of the devices.
	53	*
	54	* Summary of options:
	55	* - strong_pullup = 0 Disable strong pullup completely
	56	* - strong_pullup = 1 Enable automatic strong pullup detection
	57	* - strong_pullup = 2 Force strong pullup
6cd15974 DF	58	*/
	59	static int w1_strong_pullup = 1;
	60	module_param_named(strong_pullup, w1_strong_pullup, int, 0);
	61
f7134eea DF	62	struct w1_therm_family_data {
	63	uint8_t rom[9];
	64	atomic_t refcnt;
	65	};
	66
	67	/* return the address of the refcnt in the family data */
	68	#define THERM_REFCNT(family_data) \
368451ea	69	(&((struct w1_therm_family_data *)family_data)->refcnt)
f7134eea	70
eb2c0da4 DF	71	static int w1_therm_add_slave(struct w1_slave *sl)
eb2c0da4 DF	72	{
f7134eea DF	73	sl->family_data = kzalloc(sizeof(struct w1_therm_family_data),
f7134eea DF	74	GFP_KERNEL);
eb2c0da4 DF	75	if (!sl->family_data)
eb2c0da4 DF	76	return -ENOMEM;
f7134eea	77	atomic_set(THERM_REFCNT(sl->family_data), 1);
eb2c0da4 DF	78	return 0;
	79	}
	80
	81	static void w1_therm_remove_slave(struct w1_slave *sl)
	82	{
f7134eea	83	int refcnt = atomic_sub_return(1, THERM_REFCNT(sl->family_data));
368451ea	84
d4c3f97a	85	while (refcnt) {
f7134eea DF	86	msleep(1000);
	87	refcnt = atomic_read(THERM_REFCNT(sl->family_data));
	88	}
eb2c0da4 DF	89	kfree(sl->family_data);
	90	sl->family_data = NULL;
	91	}
1da177e4	92
b8a9f44f	93	static ssize_t w1_slave_show(struct device *device,
347ba8a5	94	struct device_attribute attr, char buf);
1da177e4	95
0a19f129 BS	96	static ssize_t w1_slave_store(struct device *device,
	97	struct device_attribute attr, const char buf, size_t size);
	98
d9411e57 MC	99	static ssize_t w1_seq_show(struct device *device,
	100	struct device_attribute attr, char buf);
	101
0a19f129	102	static DEVICE_ATTR_RW(w1_slave);
d9411e57	103	static DEVICE_ATTR_RO(w1_seq);
d2a4ef6a	104
b8a9f44f GKH	105	static struct attribute *w1_therm_attrs[] = {
	106	&dev_attr_w1_slave.attr,
	107	NULL,
	108	};
d9411e57 MC	109
	110	static struct attribute *w1_ds28ea00_attrs[] = {
	111	&dev_attr_w1_slave.attr,
	112	&dev_attr_w1_seq.attr,
	113	NULL,
	114	};
b8a9f44f	115	ATTRIBUTE_GROUPS(w1_therm);
d9411e57	116	ATTRIBUTE_GROUPS(w1_ds28ea00);
d2a4ef6a	117
1da177e4	118	static struct w1_family_ops w1_therm_fops = {
eb2c0da4 DF	119	.add_slave = w1_therm_add_slave,
eb2c0da4 DF	120	.remove_slave = w1_therm_remove_slave,
b8a9f44f	121	.groups = w1_therm_groups,
1da177e4 LT	122	};
1da177e4 LT	123
d9411e57 MC	124	static struct w1_family_ops w1_ds28ea00_fops = {
	125	.add_slave = w1_therm_add_slave,
	126	.remove_slave = w1_therm_remove_slave,
	127	.groups = w1_ds28ea00_groups,
	128	};
	129
718a538f EP	130	static struct w1_family w1_therm_family_DS18S20 = {
	131	.fid = W1_THERM_DS18S20,
	132	.fops = &w1_therm_fops,
	133	};
	134
	135	static struct w1_family w1_therm_family_DS18B20 = {
	136	.fid = W1_THERM_DS18B20,
	137	.fops = &w1_therm_fops,
	138	};
d2a4ef6a	139
718a538f EP	140	static struct w1_family w1_therm_family_DS1822 = {
	141	.fid = W1_THERM_DS1822,
	142	.fops = &w1_therm_fops,
	143	};
	144
f7b1371e CG	145	static struct w1_family w1_therm_family_DS28EA00 = {
f7b1371e CG	146	.fid = W1_THERM_DS28EA00,
d9411e57	147	.fops = &w1_ds28ea00_fops,
f7b1371e CG	148	};
f7b1371e CG	149
f3261dfb RA	150	static struct w1_family w1_therm_family_DS1825 = {
	151	.fid = W1_THERM_DS1825,
	152	.fops = &w1_therm_fops,
	153	};
	154
d4c3f97a	155	struct w1_therm_family_converter {
718a538f EP	156	u8 broken;
	157	u16 reserved;
	158	struct w1_family *f;
	159	int (*convert)(u8 rom[9]);
0a19f129 BS	160	int (precision)(struct device device, int val);
0a19f129 BS	161	int (eeprom)(struct device device);
718a538f EP	162	};
718a538f EP	163
0a19f129 BS	164	/* write configuration to eeprom */
	165	static inline int w1_therm_eeprom(struct device *device);
	166
	167	/* Set precision for conversion */
	168	static inline int w1_DS18B20_precision(struct device *device, int val);
	169	static inline int w1_DS18S20_precision(struct device *device, int val);
	170
7129b126	171	/* The return value is millidegrees Centigrade. */
718a538f EP	172	static inline int w1_DS18B20_convert_temp(u8 rom[9]);
	173	static inline int w1_DS18S20_convert_temp(u8 rom[9]);
	174
	175	static struct w1_therm_family_converter w1_therm_families[] = {
	176	{
718a538f	177	.f = &w1_therm_family_DS18S20,
0a19f129 BS	178	.convert = w1_DS18S20_convert_temp,
	179	.precision = w1_DS18S20_precision,
	180	.eeprom = w1_therm_eeprom
718a538f EP	181	},
718a538f EP	182	{
718a538f	183	.f = &w1_therm_family_DS1822,
0a19f129 BS	184	.convert = w1_DS18B20_convert_temp,
	185	.precision = w1_DS18S20_precision,
	186	.eeprom = w1_therm_eeprom
718a538f EP	187	},
718a538f EP	188	{
718a538f	189	.f = &w1_therm_family_DS18B20,
0a19f129 BS	190	.convert = w1_DS18B20_convert_temp,
	191	.precision = w1_DS18B20_precision,
	192	.eeprom = w1_therm_eeprom
718a538f	193	},
f7b1371e CG	194	{
f7b1371e CG	195	.f = &w1_therm_family_DS28EA00,
0a19f129 BS	196	.convert = w1_DS18B20_convert_temp,
	197	.precision = w1_DS18S20_precision,
	198	.eeprom = w1_therm_eeprom
f7b1371e	199	},
f3261dfb RA	200	{
f3261dfb RA	201	.f = &w1_therm_family_DS1825,
0a19f129 BS	202	.convert = w1_DS18B20_convert_temp,
	203	.precision = w1_DS18S20_precision,
	204	.eeprom = w1_therm_eeprom
f3261dfb	205	}
718a538f EP	206	};
718a538f EP	207
0a19f129 BS	208	static inline int w1_therm_eeprom(struct device *device)
	209	{
	210	struct w1_slave *sl = dev_to_w1_slave(device);
	211	struct w1_master *dev = sl->master;
	212	u8 rom[9], external_power;
	213	int ret, max_trying = 10;
	214	u8 *family_data = sl->family_data;
	215
	216	ret = mutex_lock_interruptible(&dev->bus_mutex);
	217	if (ret != 0)
	218	goto post_unlock;
	219
	220	if (!sl->family_data) {
	221	ret = -ENODEV;
	222	goto pre_unlock;
	223	}
	224
	225	/* prevent the slave from going away in sleep */
	226	atomic_inc(THERM_REFCNT(family_data));
	227	memset(rom, 0, sizeof(rom));
	228
	229	while (max_trying--) {
	230	if (!w1_reset_select_slave(sl)) {
	231	unsigned int tm = 10;
	232	unsigned long sleep_rem;
	233
	234	/* check if in parasite mode */
	235	w1_write_8(dev, W1_READ_PSUPPLY);
	236	external_power = w1_read_8(dev);
	237
	238	if (w1_reset_select_slave(sl))
	239	continue;
	240
	241	/* 10ms strong pullup/delay after the copy command */
	242	if (w1_strong_pullup == 2 \|\|
	243	(!external_power && w1_strong_pullup))
	244	w1_next_pullup(dev, tm);
	245
	246	w1_write_8(dev, W1_COPY_SCRATCHPAD);
	247
	248	if (external_power) {
	249	mutex_unlock(&dev->bus_mutex);
	250
	251	sleep_rem = msleep_interruptible(tm);
	252	if (sleep_rem != 0) {
	253	ret = -EINTR;
	254	goto post_unlock;
	255	}
	256
	257	ret = mutex_lock_interruptible(&dev->bus_mutex);
	258	if (ret != 0)
	259	goto post_unlock;
	260	} else if (!w1_strong_pullup) {
	261	sleep_rem = msleep_interruptible(tm);
	262	if (sleep_rem != 0) {
	263	ret = -EINTR;
	264	goto pre_unlock;
	265	}
	266	}
	267
	268	break;
	269	}
	270	}
	271
272	pre_unlock:
273	mutex_unlock(&dev->bus_mutex);
274
275	post_unlock:
276	atomic_dec(THERM_REFCNT(family_data));
277	return ret;
278	}
279
280	/* DS18S20 does not feature configuration register */
281	static inline int w1_DS18S20_precision(struct device *device, int val)
282	{
283	return 0;
284	}
285
286	static inline int w1_DS18B20_precision(struct device *device, int val)
287	{
288	struct w1_slave *sl = dev_to_w1_slave(device);
289	struct w1_master *dev = sl->master;
290	u8 rom[9], crc;
291	int ret, max_trying = 10;
292	u8 *family_data = sl->family_data;
293	uint8_t precision_bits;
294	uint8_t mask = 0x60;
295
d4c3f97a	296	if (val > 12 \|\| val < 9) {
0a19f129 BS	297	pr_warn("Unsupported precision\n");
	298	return -1;
	299	}
	300
	301	ret = mutex_lock_interruptible(&dev->bus_mutex);
	302	if (ret != 0)
	303	goto post_unlock;
	304
	305	if (!sl->family_data) {
	306	ret = -ENODEV;
	307	goto pre_unlock;
	308	}
	309
	310	/* prevent the slave from going away in sleep */
	311	atomic_inc(THERM_REFCNT(family_data));
	312	memset(rom, 0, sizeof(rom));
	313
	314	/* translate precision to bitmask (see datasheet page 9) */
	315	switch (val) {
	316	case 9:
	317	precision_bits = 0x00;
	318	break;
	319	case 10:
	320	precision_bits = 0x20;
	321	break;
	322	case 11:
	323	precision_bits = 0x40;
	324	break;
	325	case 12:
	326	default:
	327	precision_bits = 0x60;
	328	break;
	329	}
	330
	331	while (max_trying--) {
	332	crc = 0;
	333
	334	if (!w1_reset_select_slave(sl)) {
	335	int count = 0;
	336
	337	/* read values to only alter precision bits */
	338	w1_write_8(dev, W1_READ_SCRATCHPAD);
aaf16f7d BW	339	count = w1_read_block(dev, rom, 9);
aaf16f7d BW	340	if (count != 9)
0a19f129 BS	341	dev_warn(device, "w1_read_block() returned %u instead of 9.\n", count);
	342
	343	crc = w1_calc_crc8(rom, 8);
	344	if (rom[8] == crc) {
	345	rom[4] = (rom[4] & ~mask) \| (precision_bits & mask);
	346
	347	if (!w1_reset_select_slave(sl)) {
	348	w1_write_8(dev, W1_WRITE_SCRATCHPAD);
	349	w1_write_8(dev, rom[2]);
	350	w1_write_8(dev, rom[3]);
	351	w1_write_8(dev, rom[4]);
	352
	353	break;
	354	}
	355	}
	356	}
	357	}
	358
	359	pre_unlock:
	360	mutex_unlock(&dev->bus_mutex);
	361
	362	post_unlock:
	363	atomic_dec(THERM_REFCNT(family_data));
	364	return ret;
	365	}
	366
718a538f EP	367	static inline int w1_DS18B20_convert_temp(u8 rom[9])
718a538f EP	368	{
9a6a1ecd	369	s16 t = le16_to_cpup((__le16 *)rom);
368451ea	370
9a6a1ecd	371	return t*1000/16;
718a538f EP	372	}
	373
	374	static inline int w1_DS18S20_convert_temp(u8 rom[9])
1da177e4 LT	375	{
1da177e4 LT	376	int t, h;
718a538f EP	377
	378	if (!rom[7])
	379	return 0;
bd529cfb	380
1da177e4 LT	381	if (rom[1] == 0)
	382	t = ((s32)rom[0] >> 1)*1000;
	383	else
	384	t = 1000(-1(s32)(0x100-rom[0]) >> 1);
bd529cfb	385
1da177e4 LT	386	t -= 250;
	387	h = 1000*((s32)rom[7] - (s32)rom[6]);
	388	h /= (s32)rom[7];
	389	t += h;
	390
	391	return t;
	392	}
	393
718a538f EP	394	static inline int w1_convert_temp(u8 rom[9], u8 fid)
	395	{
	396	int i;
	397
9d0094de	398	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
4e470aa9	399	if (w1_therm_families[i].f->fid == fid)
718a538f EP	400	return w1_therm_families[i].convert(rom);
	401
	402	return 0;
	403	}
	404
0a19f129 BS	405	static ssize_t w1_slave_store(struct device *device,
	406	struct device_attribute attr, const char buf,
	407	size_t size)
	408	{
	409	int val, ret;
	410	struct w1_slave *sl = dev_to_w1_slave(device);
	411	int i;
	412
	413	ret = kstrtoint(buf, 0, &val);
	414	if (ret)
	415	return ret;
	416
	417	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
	418	if (w1_therm_families[i].f->fid == sl->family->fid) {
	419	/* zero value indicates to write current configuration to eeprom */
368451ea	420	if (val == 0)
0a19f129 BS	421	ret = w1_therm_families[i].eeprom(device);
	422	else
	423	ret = w1_therm_families[i].precision(device, val);
	424	break;
	425	}
	426	}
	427	return ret ? : size;
	428	}
1da177e4	429
b8a9f44f	430	static ssize_t w1_slave_show(struct device *device,
347ba8a5	431	struct device_attribute attr, char buf)
1da177e4	432	{
347ba8a5	433	struct w1_slave *sl = dev_to_w1_slave(device);
1da177e4	434	struct w1_master *dev = sl->master;
377195c4	435	u8 rom[9], crc, verdict, external_power;
f7134eea	436	int i, ret, max_trying = 10;
347ba8a5	437	ssize_t c = PAGE_SIZE;
f7134eea DF	438	u8 *family_data = sl->family_data;
	439
	440	ret = mutex_lock_interruptible(&dev->bus_mutex);
	441	if (ret != 0)
	442	goto post_unlock;
1da177e4	443
d4c3f97a	444	if (!sl->family_data) {
f7134eea DF	445	ret = -ENODEV;
	446	goto pre_unlock;
	447	}
1da177e4	448
f7134eea DF	449	/* prevent the slave from going away in sleep */
f7134eea DF	450	atomic_inc(THERM_REFCNT(family_data));
1da177e4 LT	451	memset(rom, 0, sizeof(rom));
1da177e4 LT	452
1da177e4	453	while (max_trying--) {
867ff988 DS	454
	455	verdict = 0;
	456	crc = 0;
	457
ea7d8f65	458	if (!w1_reset_select_slave(sl)) {
1da177e4	459	int count = 0;
1da177e4	460	unsigned int tm = 750;
377195c4 MS	461	unsigned long sleep_rem;
	462
	463	w1_write_8(dev, W1_READ_PSUPPLY);
	464	external_power = w1_read_8(dev);
	465
	466	if (w1_reset_select_slave(sl))
	467	continue;
1da177e4	468
6cd15974	469	/* 750ms strong pullup (or delay) after the convert */
29e5507a MA	470	if (w1_strong_pullup == 2 \|\|
29e5507a MA	471	(!external_power && w1_strong_pullup))
6cd15974	472	w1_next_pullup(dev, tm);
377195c4	473
1da177e4	474	w1_write_8(dev, W1_CONVERT_TEMP);
377195c4 MS	475
377195c4 MS	476	if (external_power) {
b02f8bed	477	mutex_unlock(&dev->bus_mutex);
377195c4 MS	478
377195c4 MS	479	sleep_rem = msleep_interruptible(tm);
f7134eea DF	480	if (sleep_rem != 0) {
	481	ret = -EINTR;
	482	goto post_unlock;
	483	}
377195c4	484
f7134eea DF	485	ret = mutex_lock_interruptible(&dev->bus_mutex);
	486	if (ret != 0)
	487	goto post_unlock;
377195c4 MS	488	} else if (!w1_strong_pullup) {
	489	sleep_rem = msleep_interruptible(tm);
	490	if (sleep_rem != 0) {
f7134eea DF	491	ret = -EINTR;
f7134eea DF	492	goto pre_unlock;
377195c4 MS	493	}
377195c4 MS	494	}
1da177e4	495
ea7d8f65	496	if (!w1_reset_select_slave(sl)) {
7785925d	497
1da177e4	498	w1_write_8(dev, W1_READ_SCRATCHPAD);
aaf16f7d BW	499	count = w1_read_block(dev, rom, 9);
aaf16f7d BW	500	if (count != 9) {
347ba8a5 DF	501	dev_warn(device, "w1_read_block() "
	502	"returned %u instead of 9.\n",
	503	count);
1da177e4 LT	504	}
	505
	506	crc = w1_calc_crc8(rom, 8);
	507
80c002dd	508	if (rom[8] == crc)
1da177e4	509	verdict = 1;
1da177e4 LT	510	}
	511	}
	512
867ff988	513	if (verdict)
1da177e4 LT	514	break;
	515	}
	516
	517	for (i = 0; i < 9; ++i)
347ba8a5 DF	518	c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", rom[i]);
347ba8a5 DF	519	c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
0a19f129	520	crc, (verdict) ? "YES" : "NO");
1da177e4	521	if (verdict)
f7134eea	522	memcpy(family_data, rom, sizeof(rom));
1da177e4	523	else
867ff988	524	dev_warn(device, "Read failed CRC check\n");
1da177e4 LT	525
1da177e4 LT	526	for (i = 0; i < 9; ++i)
eb2c0da4	527	c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ",
f7134eea	528	((u8 *)family_data)[i]);
bd529cfb	529
347ba8a5 DF	530	c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
347ba8a5 DF	531	w1_convert_temp(rom, sl->family->fid));
f7134eea DF	532	ret = PAGE_SIZE - c;
	533
	534	pre_unlock:
b02f8bed	535	mutex_unlock(&dev->bus_mutex);
1da177e4	536
f7134eea DF	537	post_unlock:
	538	atomic_dec(THERM_REFCNT(family_data));
	539	return ret;
1da177e4 LT	540	}
1da177e4 LT	541
d9411e57 MC	542	#define W1_42_CHAIN 0x99
	543	#define W1_42_CHAIN_OFF 0x3C
	544	#define W1_42_CHAIN_OFF_INV 0xC3
	545	#define W1_42_CHAIN_ON 0x5A
	546	#define W1_42_CHAIN_ON_INV 0xA5
	547	#define W1_42_CHAIN_DONE 0x96
	548	#define W1_42_CHAIN_DONE_INV 0x69
	549	#define W1_42_COND_READ 0x0F
	550	#define W1_42_SUCCESS_CONFIRM_BYTE 0xAA
	551	#define W1_42_FINISHED_BYTE 0xFF
	552	static ssize_t w1_seq_show(struct device *device,
	553	struct device_attribute attr, char buf)
	554	{
	555	struct w1_slave *sl = dev_to_w1_slave(device);
	556	ssize_t c = PAGE_SIZE;
	557	int rv;
	558	int i;
	559	u8 ack;
	560	u64 rn;
	561	struct w1_reg_num *reg_num;
	562	int seq = 0;
	563
0c6d5c89	564	mutex_lock(&sl->master->bus_mutex);
d9411e57 MC	565	/* Place all devices in CHAIN state */
	566	if (w1_reset_bus(sl->master))
	567	goto error;
	568	w1_write_8(sl->master, W1_SKIP_ROM);
	569	w1_write_8(sl->master, W1_42_CHAIN);
	570	w1_write_8(sl->master, W1_42_CHAIN_ON);
	571	w1_write_8(sl->master, W1_42_CHAIN_ON_INV);
	572	msleep(sl->master->pullup_duration);
	573
	574	/* check for acknowledgment */
	575	ack = w1_read_8(sl->master);
	576	if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
	577	goto error;
	578
	579	/* In case the bus fails to send 0xFF, limit*/
	580	for (i = 0; i <= 64; i++) {
	581	if (w1_reset_bus(sl->master))
	582	goto error;
	583
	584	w1_write_8(sl->master, W1_42_COND_READ);
	585	rv = w1_read_block(sl->master, (u8 *)&rn, 8);
	586	reg_num = (struct w1_reg_num *) &rn;
a14ef24b	587	if (reg_num->family == W1_42_FINISHED_BYTE)
d9411e57 MC	588	break;
	589	if (sl->reg_num.id == reg_num->id)
	590	seq = i;
	591
	592	w1_write_8(sl->master, W1_42_CHAIN);
	593	w1_write_8(sl->master, W1_42_CHAIN_DONE);
	594	w1_write_8(sl->master, W1_42_CHAIN_DONE_INV);
	595	w1_read_block(sl->master, &ack, sizeof(ack));
	596
	597	/* check for acknowledgment */
	598	ack = w1_read_8(sl->master);
	599	if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
	600	goto error;
	601
	602	}
	603
	604	/* Exit from CHAIN state */
	605	if (w1_reset_bus(sl->master))
	606	goto error;
	607	w1_write_8(sl->master, W1_SKIP_ROM);
	608	w1_write_8(sl->master, W1_42_CHAIN);
	609	w1_write_8(sl->master, W1_42_CHAIN_OFF);
	610	w1_write_8(sl->master, W1_42_CHAIN_OFF_INV);
	611
	612	/* check for acknowledgment */
	613	ack = w1_read_8(sl->master);
	614	if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
	615	goto error;
0c6d5c89	616	mutex_unlock(&sl->master->bus_mutex);
d9411e57 MC	617
	618	c -= snprintf(buf + PAGE_SIZE - c, c, "%d\n", seq);
	619	return PAGE_SIZE - c;
	620	error:
	621	mutex_unlock(&sl->master->bus_mutex);
	622	return -EIO;
	623	}
	624
1da177e4 LT	625	static int __init w1_therm_init(void)
1da177e4 LT	626	{
718a538f EP	627	int err, i;
718a538f EP	628
9d0094de	629	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
718a538f EP	630	err = w1_register_family(w1_therm_families[i].f);
	631	if (err)
	632	w1_therm_families[i].broken = 1;
	633	}
	634
	635	return 0;
1da177e4 LT	636	}
	637
	638	static void __exit w1_therm_fini(void)
	639	{
718a538f EP	640	int i;
718a538f EP	641
9d0094de	642	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
718a538f EP	643	if (!w1_therm_families[i].broken)
718a538f EP	644	w1_unregister_family(w1_therm_families[i].f);
1da177e4 LT	645	}
	646
	647	module_init(w1_therm_init);
	648	module_exit(w1_therm_fini);