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

/*
 * 1-Wire implementation for the ds2760 chip
 *
 * Copyright © 2004-2005, Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>
 *
 * Use consistent with the GNU GPL is permitted,
 * provided that this copyright notice is
 * preserved in its entirety in all copies and derived works.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/types.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <linux/idr.h>
#include <linux/gfp.h>

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

static int w1_ds2760_io(struct device *dev, char *buf, int addr, size_t count,
			int io)
{
	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);

	if (!dev)
		return 0;

	mutex_lock(&sl->master->bus_mutex);

	if (addr > DS2760_DATA_SIZE || addr < 0) {
		count = 0;
		goto out;
	}
	if (addr + count > DS2760_DATA_SIZE)
		count = DS2760_DATA_SIZE - addr;

	if (!w1_reset_select_slave(sl)) {
		if (!io) {
			w1_write_8(sl->master, W1_DS2760_READ_DATA);
			w1_write_8(sl->master, addr);
			count = w1_read_block(sl->master, buf, count);
		} else {
			w1_write_8(sl->master, W1_DS2760_WRITE_DATA);
			w1_write_8(sl->master, addr);
			w1_write_block(sl->master, buf, count);
			/* XXX w1_write_block returns void, not n_written */
		}
	}

out:
	mutex_unlock(&sl->master->bus_mutex);

	return count;
}

int w1_ds2760_read(struct device *dev, char *buf, int addr, size_t count)
{
	return w1_ds2760_io(dev, buf, addr, count, 0);
}

int w1_ds2760_write(struct device *dev, char *buf, int addr, size_t count)
{
	return w1_ds2760_io(dev, buf, addr, count, 1);
}

static int w1_ds2760_eeprom_cmd(struct device *dev, int addr, int cmd)
{
	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);

	if (!dev)
		return -EINVAL;

	mutex_lock(&sl->master->bus_mutex);

	if (w1_reset_select_slave(sl) == 0) {
		w1_write_8(sl->master, cmd);
		w1_write_8(sl->master, addr);
	}

	mutex_unlock(&sl->master->bus_mutex);
	return 0;
}

int w1_ds2760_store_eeprom(struct device *dev, int addr)
{
	return w1_ds2760_eeprom_cmd(dev, addr, W1_DS2760_COPY_DATA);
}

int w1_ds2760_recall_eeprom(struct device *dev, int addr)
{
	return w1_ds2760_eeprom_cmd(dev, addr, W1_DS2760_RECALL_DATA);
}

static ssize_t w1_slave_read(struct file *filp, struct kobject *kobj,
			     struct bin_attribute *bin_attr, char *buf,
			     loff_t off, size_t count)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	return w1_ds2760_read(dev, buf, off, count);
}

static BIN_ATTR_RO(w1_slave, DS2760_DATA_SIZE);

static struct bin_attribute *w1_ds2760_bin_attrs[] = {
	&bin_attr_w1_slave,
	NULL,
};

static const struct attribute_group w1_ds2760_group = {
	.bin_attrs = w1_ds2760_bin_attrs,
};

static const struct attribute_group *w1_ds2760_groups[] = {
	&w1_ds2760_group,
	NULL,
};

static int w1_ds2760_add_slave(struct w1_slave *sl)
{
	int ret;
	struct platform_device *pdev;

	pdev = platform_device_alloc("ds2760-battery", PLATFORM_DEVID_AUTO);
	if (!pdev)
		return -ENOMEM;
	pdev->dev.parent = &sl->dev;

	ret = platform_device_add(pdev);
	if (ret)
		goto pdev_add_failed;

	dev_set_drvdata(&sl->dev, pdev);

	return 0;

pdev_add_failed:
	platform_device_put(pdev);

	return ret;
}

static void w1_ds2760_remove_slave(struct w1_slave *sl)
{
	struct platform_device *pdev = dev_get_drvdata(&sl->dev);

	platform_device_unregister(pdev);
}

static struct w1_family_ops w1_ds2760_fops = {
	.add_slave    = w1_ds2760_add_slave,
	.remove_slave = w1_ds2760_remove_slave,
	.groups       = w1_ds2760_groups,
};

static struct w1_family w1_ds2760_family = {
	.fid = W1_FAMILY_DS2760,
	.fops = &w1_ds2760_fops,
};
module_w1_family(w1_ds2760_family);

EXPORT_SYMBOL(w1_ds2760_read);
EXPORT_SYMBOL(w1_ds2760_write);
EXPORT_SYMBOL(w1_ds2760_store_eeprom);
EXPORT_SYMBOL(w1_ds2760_recall_eeprom);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>");
MODULE_DESCRIPTION("1-wire Driver Dallas 2760 battery monitor chip");
MODULE_ALIAS("w1-family-" __stringify(W1_FAMILY_DS2760));
Commit	Line	Data
d7ce6d1d AV	1	/*
	2	* 1-Wire implementation for the ds2760 chip
	3	*
	4	* Copyright © 2004-2005, Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>
	5	*
	6	* Use consistent with the GNU GPL is permitted,
	7	* provided that this copyright notice is
	8	* preserved in its entirety in all copies and derived works.
	9	*
	10	*/
	11
	12	#include <linux/kernel.h>
	13	#include <linux/module.h>
	14	#include <linux/device.h>
	15	#include <linux/types.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/mutex.h>
	18	#include <linux/idr.h>
5a0e3ad6	19	#include <linux/gfp.h>
d7ce6d1d AV	20
	21	#include "../w1.h"
	22	#include "../w1_int.h"
	23	#include "../w1_family.h"
	24	#include "w1_ds2760.h"
	25
	26	static int w1_ds2760_io(struct device dev, char buf, int addr, size_t count,
	27	int io)
	28	{
	29	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	30
	31	if (!dev)
	32	return 0;
	33
b02f8bed	34	mutex_lock(&sl->master->bus_mutex);
d7ce6d1d AV	35
	36	if (addr > DS2760_DATA_SIZE \|\| addr < 0) {
	37	count = 0;
	38	goto out;
	39	}
	40	if (addr + count > DS2760_DATA_SIZE)
	41	count = DS2760_DATA_SIZE - addr;
	42
	43	if (!w1_reset_select_slave(sl)) {
	44	if (!io) {
	45	w1_write_8(sl->master, W1_DS2760_READ_DATA);
	46	w1_write_8(sl->master, addr);
	47	count = w1_read_block(sl->master, buf, count);
	48	} else {
	49	w1_write_8(sl->master, W1_DS2760_WRITE_DATA);
	50	w1_write_8(sl->master, addr);
	51	w1_write_block(sl->master, buf, count);
	52	/* XXX w1_write_block returns void, not n_written */
	53	}
	54	}
	55
	56	out:
b02f8bed	57	mutex_unlock(&sl->master->bus_mutex);
d7ce6d1d AV	58
	59	return count;
	60	}
	61
	62	int w1_ds2760_read(struct device dev, char buf, int addr, size_t count)
	63	{
	64	return w1_ds2760_io(dev, buf, addr, count, 0);
	65	}
	66
	67	int w1_ds2760_write(struct device dev, char buf, int addr, size_t count)
	68	{
	69	return w1_ds2760_io(dev, buf, addr, count, 1);
	70	}
	71
0b47b570 DM	72	static int w1_ds2760_eeprom_cmd(struct device *dev, int addr, int cmd)
	73	{
	74	struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
	75
	76	if (!dev)
	77	return -EINVAL;
	78
b02f8bed	79	mutex_lock(&sl->master->bus_mutex);
0b47b570 DM	80
	81	if (w1_reset_select_slave(sl) == 0) {
	82	w1_write_8(sl->master, cmd);
	83	w1_write_8(sl->master, addr);
	84	}
	85
b02f8bed	86	mutex_unlock(&sl->master->bus_mutex);
0b47b570 DM	87	return 0;
	88	}
	89
	90	int w1_ds2760_store_eeprom(struct device *dev, int addr)
	91	{
	92	return w1_ds2760_eeprom_cmd(dev, addr, W1_DS2760_COPY_DATA);
	93	}
	94
	95	int w1_ds2760_recall_eeprom(struct device *dev, int addr)
	96	{
	97	return w1_ds2760_eeprom_cmd(dev, addr, W1_DS2760_RECALL_DATA);
	98	}
	99
0597129c GKH	100	static ssize_t w1_slave_read(struct file filp, struct kobject kobj,
	101	struct bin_attribute bin_attr, char buf,
	102	loff_t off, size_t count)
d7ce6d1d AV	103	{
	104	struct device *dev = container_of(kobj, struct device, kobj);
	105	return w1_ds2760_read(dev, buf, off, count);
	106	}
	107
0597129c GKH	108	static BIN_ATTR_RO(w1_slave, DS2760_DATA_SIZE);
	109
	110	static struct bin_attribute *w1_ds2760_bin_attrs[] = {
	111	&bin_attr_w1_slave,
	112	NULL,
	113	};
	114
	115	static const struct attribute_group w1_ds2760_group = {
	116	.bin_attrs = w1_ds2760_bin_attrs,
	117	};
	118
	119	static const struct attribute_group *w1_ds2760_groups[] = {
	120	&w1_ds2760_group,
	121	NULL,
d7ce6d1d AV	122	};
d7ce6d1d AV	123
d7ce6d1d AV	124	static int w1_ds2760_add_slave(struct w1_slave *sl)
	125	{
	126	int ret;
d7ce6d1d AV	127	struct platform_device *pdev;
d7ce6d1d AV	128
098f9fb0 AD	129	pdev = platform_device_alloc("ds2760-battery", PLATFORM_DEVID_AUTO);
	130	if (!pdev)
	131	return -ENOMEM;
d7ce6d1d AV	132	pdev->dev.parent = &sl->dev;
	133
	134	ret = platform_device_add(pdev);
	135	if (ret)
	136	goto pdev_add_failed;
	137
d7ce6d1d AV	138	dev_set_drvdata(&sl->dev, pdev);
d7ce6d1d AV	139
098f9fb0	140	return 0;
d7ce6d1d	141
d7ce6d1d	142	pdev_add_failed:
4d10e0f2	143	platform_device_put(pdev);
098f9fb0	144
d7ce6d1d AV	145	return ret;
	146	}
	147
	148	static void w1_ds2760_remove_slave(struct w1_slave *sl)
	149	{
	150	struct platform_device *pdev = dev_get_drvdata(&sl->dev);
d7ce6d1d AV	151
d7ce6d1d AV	152	platform_device_unregister(pdev);
d7ce6d1d AV	153	}
	154
	155	static struct w1_family_ops w1_ds2760_fops = {
	156	.add_slave = w1_ds2760_add_slave,
	157	.remove_slave = w1_ds2760_remove_slave,
0597129c	158	.groups = w1_ds2760_groups,
d7ce6d1d AV	159	};
	160
	161	static struct w1_family w1_ds2760_family = {
	162	.fid = W1_FAMILY_DS2760,
	163	.fops = &w1_ds2760_fops,
	164	};
939fc832	165	module_w1_family(w1_ds2760_family);
d7ce6d1d AV	166
	167	EXPORT_SYMBOL(w1_ds2760_read);
	168	EXPORT_SYMBOL(w1_ds2760_write);
0b47b570 DM	169	EXPORT_SYMBOL(w1_ds2760_store_eeprom);
0b47b570 DM	170	EXPORT_SYMBOL(w1_ds2760_recall_eeprom);
d7ce6d1d	171
d7ce6d1d AV	172	MODULE_LICENSE("GPL");
	173	MODULE_AUTHOR("Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>");
	174	MODULE_DESCRIPTION("1-wire Driver Dallas 2760 battery monitor chip");
8d7bda51	175	MODULE_ALIAS("w1-family-" __stringify(W1_FAMILY_DS2760));