[deliverable/linux.git] / drivers / misc / eeprom / eeprom_93xx46.c

/*
 * Driver for 93xx46 EEPROMs
 *
 * (C) 2011 DENX Software Engineering, Anatolij Gustschin <agust@denx.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/delay.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/slab.h>
#include <linux/spi/spi.h>
#include <linux/sysfs.h>
#include <linux/eeprom_93xx46.h>

#define OP_START	0x4
#define OP_WRITE	(OP_START | 0x1)
#define OP_READ		(OP_START | 0x2)
#define ADDR_EWDS	0x00
#define ADDR_ERAL	0x20
#define ADDR_EWEN	0x30

struct eeprom_93xx46_dev {
	struct spi_device *spi;
	struct eeprom_93xx46_platform_data *pdata;
	struct bin_attribute bin;
	struct mutex lock;
	int addrlen;
};

static ssize_t
eeprom_93xx46_bin_read(struct file *filp, struct kobject *kobj,
		       struct bin_attribute *bin_attr,
		       char *buf, loff_t off, size_t count)
{
	struct eeprom_93xx46_dev *edev;
	struct device *dev;
	struct spi_message m;
	struct spi_transfer t[2];
	int bits, ret;
	u16 cmd_addr;

	dev = kobj_to_dev(kobj);
	edev = dev_get_drvdata(dev);

	cmd_addr = OP_READ << edev->addrlen;

	if (edev->addrlen == 7) {
		cmd_addr |= off & 0x7f;
		bits = 10;
	} else {
		cmd_addr |= (off >> 1) & 0x3f;
		bits = 9;
	}

	dev_dbg(&edev->spi->dev, "read cmd 0x%x, %d Hz\n",
		cmd_addr, edev->spi->max_speed_hz);

	spi_message_init(&m);
	memset(t, 0, sizeof(t));

	t[0].tx_buf = (char *)&cmd_addr;
	t[0].len = 2;
	t[0].bits_per_word = bits;
	spi_message_add_tail(&t[0], &m);

	t[1].rx_buf = buf;
	t[1].len = count;
	t[1].bits_per_word = 8;
	spi_message_add_tail(&t[1], &m);

	mutex_lock(&edev->lock);

	if (edev->pdata->prepare)
		edev->pdata->prepare(edev);

	ret = spi_sync(edev->spi, &m);
	/* have to wait at least Tcsl ns */
	ndelay(250);
	if (ret) {
		dev_err(&edev->spi->dev, "read %zu bytes at %d: err. %d\n",
			count, (int)off, ret);
	}

	if (edev->pdata->finish)
		edev->pdata->finish(edev);

	mutex_unlock(&edev->lock);
	return ret ? : count;
}

static int eeprom_93xx46_ew(struct eeprom_93xx46_dev *edev, int is_on)
{
	struct spi_message m;
	struct spi_transfer t;
	int bits, ret;
	u16 cmd_addr;

	cmd_addr = OP_START << edev->addrlen;
	if (edev->addrlen == 7) {
		cmd_addr |= (is_on ? ADDR_EWEN : ADDR_EWDS) << 1;
		bits = 10;
	} else {
		cmd_addr |= (is_on ? ADDR_EWEN : ADDR_EWDS);
		bits = 9;
	}

	dev_dbg(&edev->spi->dev, "ew cmd 0x%04x\n", cmd_addr);

	spi_message_init(&m);
	memset(&t, 0, sizeof(t));

	t.tx_buf = &cmd_addr;
	t.len = 2;
	t.bits_per_word = bits;
	spi_message_add_tail(&t, &m);

	mutex_lock(&edev->lock);

	if (edev->pdata->prepare)
		edev->pdata->prepare(edev);

	ret = spi_sync(edev->spi, &m);
	/* have to wait at least Tcsl ns */
	ndelay(250);
	if (ret)
		dev_err(&edev->spi->dev, "erase/write %sable error %d\n",
			is_on ? "en" : "dis", ret);

	if (edev->pdata->finish)
		edev->pdata->finish(edev);

	mutex_unlock(&edev->lock);
	return ret;
}

static ssize_t
eeprom_93xx46_write_word(struct eeprom_93xx46_dev *edev,
			 const char *buf, unsigned off)
{
	struct spi_message m;
	struct spi_transfer t[2];
	int bits, data_len, ret;
	u16 cmd_addr;

	cmd_addr = OP_WRITE << edev->addrlen;

	if (edev->addrlen == 7) {
		cmd_addr |= off & 0x7f;
		bits = 10;
		data_len = 1;
	} else {
		cmd_addr |= (off >> 1) & 0x3f;
		bits = 9;
		data_len = 2;
	}

	dev_dbg(&edev->spi->dev, "write cmd 0x%x\n", cmd_addr);

	spi_message_init(&m);
	memset(t, 0, sizeof(t));

	t[0].tx_buf = (char *)&cmd_addr;
	t[0].len = 2;
	t[0].bits_per_word = bits;
	spi_message_add_tail(&t[0], &m);

	t[1].tx_buf = buf;
	t[1].len = data_len;
	t[1].bits_per_word = 8;
	spi_message_add_tail(&t[1], &m);

	ret = spi_sync(edev->spi, &m);
	/* have to wait program cycle time Twc ms */
	mdelay(6);
	return ret;
}

static ssize_t
eeprom_93xx46_bin_write(struct file *filp, struct kobject *kobj,
			struct bin_attribute *bin_attr,
			char *buf, loff_t off, size_t count)
{
	struct eeprom_93xx46_dev *edev;
	struct device *dev;
	int i, ret, step = 1;

	dev = kobj_to_dev(kobj);
	edev = dev_get_drvdata(dev);

	/* only write even number of bytes on 16-bit devices */
	if (edev->addrlen == 6) {
		step = 2;
		count &= ~1;
	}

	/* erase/write enable */
	ret = eeprom_93xx46_ew(edev, 1);
	if (ret)
		return ret;

	mutex_lock(&edev->lock);

	if (edev->pdata->prepare)
		edev->pdata->prepare(edev);

	for (i = 0; i < count; i += step) {
		ret = eeprom_93xx46_write_word(edev, &buf[i], off + i);
		if (ret) {
			dev_err(&edev->spi->dev, "write failed at %d: %d\n",
				(int)off + i, ret);
			break;
		}
	}

	if (edev->pdata->finish)
		edev->pdata->finish(edev);

	mutex_unlock(&edev->lock);

	/* erase/write disable */
	eeprom_93xx46_ew(edev, 0);
	return ret ? : count;
}

static int eeprom_93xx46_eral(struct eeprom_93xx46_dev *edev)
{
	struct eeprom_93xx46_platform_data *pd = edev->pdata;
	struct spi_message m;
	struct spi_transfer t;
	int bits, ret;
	u16 cmd_addr;

	cmd_addr = OP_START << edev->addrlen;
	if (edev->addrlen == 7) {
		cmd_addr |= ADDR_ERAL << 1;
		bits = 10;
	} else {
		cmd_addr |= ADDR_ERAL;
		bits = 9;
	}

	spi_message_init(&m);
	memset(&t, 0, sizeof(t));

	t.tx_buf = &cmd_addr;
	t.len = 2;
	t.bits_per_word = bits;
	spi_message_add_tail(&t, &m);

	mutex_lock(&edev->lock);

	if (edev->pdata->prepare)
		edev->pdata->prepare(edev);

	ret = spi_sync(edev->spi, &m);
	if (ret)
		dev_err(&edev->spi->dev, "erase error %d\n", ret);
	/* have to wait erase cycle time Tec ms */
	mdelay(6);

	if (pd->finish)
		pd->finish(edev);

	mutex_unlock(&edev->lock);
	return ret;
}

static ssize_t eeprom_93xx46_store_erase(struct device *dev,
					 struct device_attribute *attr,
					 const char *buf, size_t count)
{
	struct eeprom_93xx46_dev *edev = dev_get_drvdata(dev);
	int erase = 0, ret;

	sscanf(buf, "%d", &erase);
	if (erase) {
		ret = eeprom_93xx46_ew(edev, 1);
		if (ret)
			return ret;
		ret = eeprom_93xx46_eral(edev);
		if (ret)
			return ret;
		ret = eeprom_93xx46_ew(edev, 0);
		if (ret)
			return ret;
	}
	return count;
}
static DEVICE_ATTR(erase, S_IWUSR, NULL, eeprom_93xx46_store_erase);

static const struct of_device_id eeprom_93xx46_of_table[] = {
	{ .compatible = "eeprom-93xx46", },
	{}
};
MODULE_DEVICE_TABLE(of, eeprom_93xx46_of_table);

static int eeprom_93xx46_probe_dt(struct spi_device *spi)
{
	struct device_node *np = spi->dev.of_node;
	struct eeprom_93xx46_platform_data *pd;
	u32 tmp;
	int ret;

	pd = devm_kzalloc(&spi->dev, sizeof(*pd), GFP_KERNEL);
	if (!pd)
		return -ENOMEM;

	ret = of_property_read_u32(np, "data-size", &tmp);
	if (ret < 0) {
		dev_err(&spi->dev, "data-size property not found\n");
		return ret;
	}

	if (tmp == 8) {
		pd->flags |= EE_ADDR8;
	} else if (tmp == 16) {
		pd->flags |= EE_ADDR16;
	} else {
		dev_err(&spi->dev, "invalid data-size (%d)\n", tmp);
		return -EINVAL;
	}

	if (of_property_read_bool(np, "read-only"))
		pd->flags |= EE_READONLY;

	spi->dev.platform_data = pd;

	return 0;
}

static int eeprom_93xx46_probe(struct spi_device *spi)
{
	struct eeprom_93xx46_platform_data *pd;
	struct eeprom_93xx46_dev *edev;
	int err;

	if (spi->dev.of_node) {
		err = eeprom_93xx46_probe_dt(spi);
		if (err < 0)
			return err;
	}

	pd = spi->dev.platform_data;
	if (!pd) {
		dev_err(&spi->dev, "missing platform data\n");
		return -ENODEV;
	}

	edev = kzalloc(sizeof(*edev), GFP_KERNEL);
	if (!edev)
		return -ENOMEM;

	if (pd->flags & EE_ADDR8)
		edev->addrlen = 7;
	else if (pd->flags & EE_ADDR16)
		edev->addrlen = 6;
	else {
		dev_err(&spi->dev, "unspecified address type\n");
		err = -EINVAL;
		goto fail;
	}

	mutex_init(&edev->lock);

	edev->spi = spi_dev_get(spi);
	edev->pdata = pd;

	sysfs_bin_attr_init(&edev->bin);
	edev->bin.attr.name = "eeprom";
	edev->bin.attr.mode = S_IRUSR;
	edev->bin.read = eeprom_93xx46_bin_read;
	edev->bin.size = 128;
	if (!(pd->flags & EE_READONLY)) {
		edev->bin.write = eeprom_93xx46_bin_write;
		edev->bin.attr.mode |= S_IWUSR;
	}

	err = sysfs_create_bin_file(&spi->dev.kobj, &edev->bin);
	if (err)
		goto fail;

	dev_info(&spi->dev, "%d-bit eeprom %s\n",
		(pd->flags & EE_ADDR8) ? 8 : 16,
		(pd->flags & EE_READONLY) ? "(readonly)" : "");

	if (!(pd->flags & EE_READONLY)) {
		if (device_create_file(&spi->dev, &dev_attr_erase))
			dev_err(&spi->dev, "can't create erase interface\n");
	}

	spi_set_drvdata(spi, edev);
	return 0;
fail:
	kfree(edev);
	return err;
}

static int eeprom_93xx46_remove(struct spi_device *spi)
{
	struct eeprom_93xx46_dev *edev = spi_get_drvdata(spi);

	if (!(edev->pdata->flags & EE_READONLY))
		device_remove_file(&spi->dev, &dev_attr_erase);

	sysfs_remove_bin_file(&spi->dev.kobj, &edev->bin);
	kfree(edev);
	return 0;
}

static struct spi_driver eeprom_93xx46_driver = {
	.driver = {
		.name	= "93xx46",
		.of_match_table = of_match_ptr(eeprom_93xx46_of_table),
	},
	.probe		= eeprom_93xx46_probe,
	.remove		= eeprom_93xx46_remove,
};

module_spi_driver(eeprom_93xx46_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Driver for 93xx46 EEPROMs");
MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>");
MODULE_ALIAS("spi:93xx46");
Commit	Line	Data
06b4501e AG	1	/*
	2	* Driver for 93xx46 EEPROMs
	3	*
	4	* (C) 2011 DENX Software Engineering, Anatolij Gustschin <agust@denx.de>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
	10
	11	#include <linux/delay.h>
	12	#include <linux/device.h>
	13	#include <linux/kernel.h>
06b4501e AG	14	#include <linux/module.h>
06b4501e AG	15	#include <linux/mutex.h>
c074abe0 CT	16	#include <linux/of.h>
c074abe0 CT	17	#include <linux/of_device.h>
06b4501e AG	18	#include <linux/slab.h>
	19	#include <linux/spi/spi.h>
	20	#include <linux/sysfs.h>
	21	#include <linux/eeprom_93xx46.h>
	22
	23	#define OP_START 0x4
	24	#define OP_WRITE (OP_START \| 0x1)
	25	#define OP_READ (OP_START \| 0x2)
	26	#define ADDR_EWDS 0x00
	27	#define ADDR_ERAL 0x20
	28	#define ADDR_EWEN 0x30
	29
	30	struct eeprom_93xx46_dev {
	31	struct spi_device *spi;
	32	struct eeprom_93xx46_platform_data *pdata;
	33	struct bin_attribute bin;
	34	struct mutex lock;
	35	int addrlen;
	36	};
	37
	38	static ssize_t
	39	eeprom_93xx46_bin_read(struct file filp, struct kobject kobj,
	40	struct bin_attribute *bin_attr,
	41	char *buf, loff_t off, size_t count)
	42	{
	43	struct eeprom_93xx46_dev *edev;
	44	struct device *dev;
	45	struct spi_message m;
	46	struct spi_transfer t[2];
	47	int bits, ret;
	48	u16 cmd_addr;
	49
092462c2	50	dev = kobj_to_dev(kobj);
06b4501e AG	51	edev = dev_get_drvdata(dev);
06b4501e AG	52
06b4501e AG	53	cmd_addr = OP_READ << edev->addrlen;
	54
	55	if (edev->addrlen == 7) {
	56	cmd_addr \|= off & 0x7f;
	57	bits = 10;
	58	} else {
cb54ad6c	59	cmd_addr \|= (off >> 1) & 0x3f;
06b4501e AG	60	bits = 9;
	61	}
	62
	63	dev_dbg(&edev->spi->dev, "read cmd 0x%x, %d Hz\n",
	64	cmd_addr, edev->spi->max_speed_hz);
	65
	66	spi_message_init(&m);
	67	memset(t, 0, sizeof(t));
	68
	69	t[0].tx_buf = (char *)&cmd_addr;
	70	t[0].len = 2;
	71	t[0].bits_per_word = bits;
	72	spi_message_add_tail(&t[0], &m);
	73
	74	t[1].rx_buf = buf;
	75	t[1].len = count;
	76	t[1].bits_per_word = 8;
	77	spi_message_add_tail(&t[1], &m);
	78
	79	mutex_lock(&edev->lock);
	80
	81	if (edev->pdata->prepare)
	82	edev->pdata->prepare(edev);
	83
	84	ret = spi_sync(edev->spi, &m);
	85	/* have to wait at least Tcsl ns */
	86	ndelay(250);
	87	if (ret) {
	88	dev_err(&edev->spi->dev, "read %zu bytes at %d: err. %d\n",
	89	count, (int)off, ret);
	90	}
	91
	92	if (edev->pdata->finish)
	93	edev->pdata->finish(edev);
	94
	95	mutex_unlock(&edev->lock);
	96	return ret ? : count;
	97	}
	98
	99	static int eeprom_93xx46_ew(struct eeprom_93xx46_dev *edev, int is_on)
	100	{
	101	struct spi_message m;
	102	struct spi_transfer t;
	103	int bits, ret;
	104	u16 cmd_addr;
	105
	106	cmd_addr = OP_START << edev->addrlen;
	107	if (edev->addrlen == 7) {
	108	cmd_addr \|= (is_on ? ADDR_EWEN : ADDR_EWDS) << 1;
	109	bits = 10;
	110	} else {
	111	cmd_addr \|= (is_on ? ADDR_EWEN : ADDR_EWDS);
	112	bits = 9;
	113	}
	114
	115	dev_dbg(&edev->spi->dev, "ew cmd 0x%04x\n", cmd_addr);
	116
	117	spi_message_init(&m);
	118	memset(&t, 0, sizeof(t));
	119
	120	t.tx_buf = &cmd_addr;
	121	t.len = 2;
	122	t.bits_per_word = bits;
	123	spi_message_add_tail(&t, &m);
124
125	mutex_lock(&edev->lock);
126
127	if (edev->pdata->prepare)
128	edev->pdata->prepare(edev);
129
130	ret = spi_sync(edev->spi, &m);
131	/* have to wait at least Tcsl ns */
132	ndelay(250);
133	if (ret)
134	dev_err(&edev->spi->dev, "erase/write %sable error %d\n",
135	is_on ? "en" : "dis", ret);
136
137	if (edev->pdata->finish)
138	edev->pdata->finish(edev);
139
140	mutex_unlock(&edev->lock);
141	return ret;
142	}
143
144	static ssize_t
145	eeprom_93xx46_write_word(struct eeprom_93xx46_dev *edev,
146	const char *buf, unsigned off)
147	{
148	struct spi_message m;
149	struct spi_transfer t[2];
150	int bits, data_len, ret;
151	u16 cmd_addr;
152
153	cmd_addr = OP_WRITE << edev->addrlen;
154
155	if (edev->addrlen == 7) {
156	cmd_addr \|= off & 0x7f;
157	bits = 10;
158	data_len = 1;
159	} else {
cb54ad6c	160	cmd_addr \|= (off >> 1) & 0x3f;
06b4501e AG	161	bits = 9;
	162	data_len = 2;
	163	}
	164
	165	dev_dbg(&edev->spi->dev, "write cmd 0x%x\n", cmd_addr);
	166
	167	spi_message_init(&m);
	168	memset(t, 0, sizeof(t));
	169
	170	t[0].tx_buf = (char *)&cmd_addr;
	171	t[0].len = 2;
	172	t[0].bits_per_word = bits;
	173	spi_message_add_tail(&t[0], &m);
	174
	175	t[1].tx_buf = buf;
	176	t[1].len = data_len;
	177	t[1].bits_per_word = 8;
	178	spi_message_add_tail(&t[1], &m);
	179
	180	ret = spi_sync(edev->spi, &m);
	181	/* have to wait program cycle time Twc ms */
	182	mdelay(6);
	183	return ret;
	184	}
	185
	186	static ssize_t
	187	eeprom_93xx46_bin_write(struct file filp, struct kobject kobj,
	188	struct bin_attribute *bin_attr,
	189	char *buf, loff_t off, size_t count)
	190	{
	191	struct eeprom_93xx46_dev *edev;
	192	struct device *dev;
	193	int i, ret, step = 1;
	194
092462c2	195	dev = kobj_to_dev(kobj);
06b4501e AG	196	edev = dev_get_drvdata(dev);
06b4501e AG	197
06b4501e AG	198	/* only write even number of bytes on 16-bit devices */
	199	if (edev->addrlen == 6) {
	200	step = 2;
	201	count &= ~1;
	202	}
	203
	204	/* erase/write enable */
	205	ret = eeprom_93xx46_ew(edev, 1);
	206	if (ret)
	207	return ret;
	208
	209	mutex_lock(&edev->lock);
	210
	211	if (edev->pdata->prepare)
	212	edev->pdata->prepare(edev);
	213
	214	for (i = 0; i < count; i += step) {
	215	ret = eeprom_93xx46_write_word(edev, &buf[i], off + i);
	216	if (ret) {
	217	dev_err(&edev->spi->dev, "write failed at %d: %d\n",
	218	(int)off + i, ret);
	219	break;
	220	}
	221	}
	222
	223	if (edev->pdata->finish)
	224	edev->pdata->finish(edev);
	225
	226	mutex_unlock(&edev->lock);
	227
	228	/* erase/write disable */
	229	eeprom_93xx46_ew(edev, 0);
	230	return ret ? : count;
	231	}
	232
	233	static int eeprom_93xx46_eral(struct eeprom_93xx46_dev *edev)
	234	{
	235	struct eeprom_93xx46_platform_data *pd = edev->pdata;
	236	struct spi_message m;
	237	struct spi_transfer t;
	238	int bits, ret;
	239	u16 cmd_addr;
	240
	241	cmd_addr = OP_START << edev->addrlen;
	242	if (edev->addrlen == 7) {
	243	cmd_addr \|= ADDR_ERAL << 1;
	244	bits = 10;
	245	} else {
	246	cmd_addr \|= ADDR_ERAL;
	247	bits = 9;
	248	}
	249
	250	spi_message_init(&m);
	251	memset(&t, 0, sizeof(t));
	252
	253	t.tx_buf = &cmd_addr;
	254	t.len = 2;
	255	t.bits_per_word = bits;
	256	spi_message_add_tail(&t, &m);
	257
	258	mutex_lock(&edev->lock);
	259
	260	if (edev->pdata->prepare)
	261	edev->pdata->prepare(edev);
262
263	ret = spi_sync(edev->spi, &m);
264	if (ret)
265	dev_err(&edev->spi->dev, "erase error %d\n", ret);
266	/* have to wait erase cycle time Tec ms */
267	mdelay(6);
268
269	if (pd->finish)
270	pd->finish(edev);
271
272	mutex_unlock(&edev->lock);
273	return ret;
274	}
275
276	static ssize_t eeprom_93xx46_store_erase(struct device *dev,
277	struct device_attribute *attr,
278	const char *buf, size_t count)
279	{
280	struct eeprom_93xx46_dev *edev = dev_get_drvdata(dev);
281	int erase = 0, ret;
282
283	sscanf(buf, "%d", &erase);
284	if (erase) {
285	ret = eeprom_93xx46_ew(edev, 1);
286	if (ret)
287	return ret;
288	ret = eeprom_93xx46_eral(edev);
289	if (ret)
290	return ret;
291	ret = eeprom_93xx46_ew(edev, 0);
292	if (ret)
293	return ret;
294	}
295	return count;
296	}
297	static DEVICE_ATTR(erase, S_IWUSR, NULL, eeprom_93xx46_store_erase);
298
c074abe0 CT	299	static const struct of_device_id eeprom_93xx46_of_table[] = {
	300	{ .compatible = "eeprom-93xx46", },
	301	{}
	302	};
	303	MODULE_DEVICE_TABLE(of, eeprom_93xx46_of_table);
	304
	305	static int eeprom_93xx46_probe_dt(struct spi_device *spi)
	306	{
	307	struct device_node *np = spi->dev.of_node;
	308	struct eeprom_93xx46_platform_data *pd;
	309	u32 tmp;
	310	int ret;
	311
	312	pd = devm_kzalloc(&spi->dev, sizeof(*pd), GFP_KERNEL);
	313	if (!pd)
	314	return -ENOMEM;
	315
	316	ret = of_property_read_u32(np, "data-size", &tmp);
	317	if (ret < 0) {
	318	dev_err(&spi->dev, "data-size property not found\n");
	319	return ret;
	320	}
	321
	322	if (tmp == 8) {
	323	pd->flags \|= EE_ADDR8;
	324	} else if (tmp == 16) {
	325	pd->flags \|= EE_ADDR16;
	326	} else {
	327	dev_err(&spi->dev, "invalid data-size (%d)\n", tmp);
	328	return -EINVAL;
	329	}
	330
	331	if (of_property_read_bool(np, "read-only"))
	332	pd->flags \|= EE_READONLY;
	333
	334	spi->dev.platform_data = pd;
	335
	336	return 0;
	337	}
	338
80c8ae28	339	static int eeprom_93xx46_probe(struct spi_device *spi)
06b4501e AG	340	{
	341	struct eeprom_93xx46_platform_data *pd;
	342	struct eeprom_93xx46_dev *edev;
	343	int err;
	344
c074abe0 CT	345	if (spi->dev.of_node) {
	346	err = eeprom_93xx46_probe_dt(spi);
	347	if (err < 0)
	348	return err;
	349	}
	350
06b4501e AG	351	pd = spi->dev.platform_data;
	352	if (!pd) {
	353	dev_err(&spi->dev, "missing platform data\n");
	354	return -ENODEV;
	355	}
	356
	357	edev = kzalloc(sizeof(*edev), GFP_KERNEL);
	358	if (!edev)
	359	return -ENOMEM;
	360
	361	if (pd->flags & EE_ADDR8)
	362	edev->addrlen = 7;
	363	else if (pd->flags & EE_ADDR16)
	364	edev->addrlen = 6;
	365	else {
	366	dev_err(&spi->dev, "unspecified address type\n");
	367	err = -EINVAL;
	368	goto fail;
	369	}
	370
	371	mutex_init(&edev->lock);
	372
	373	edev->spi = spi_dev_get(spi);
	374	edev->pdata = pd;
	375
	376	sysfs_bin_attr_init(&edev->bin);
	377	edev->bin.attr.name = "eeprom";
	378	edev->bin.attr.mode = S_IRUSR;
	379	edev->bin.read = eeprom_93xx46_bin_read;
	380	edev->bin.size = 128;
	381	if (!(pd->flags & EE_READONLY)) {
	382	edev->bin.write = eeprom_93xx46_bin_write;
	383	edev->bin.attr.mode \|= S_IWUSR;
	384	}
	385
	386	err = sysfs_create_bin_file(&spi->dev.kobj, &edev->bin);
	387	if (err)
	388	goto fail;
	389
	390	dev_info(&spi->dev, "%d-bit eeprom %s\n",
	391	(pd->flags & EE_ADDR8) ? 8 : 16,
	392	(pd->flags & EE_READONLY) ? "(readonly)" : "");
	393
	394	if (!(pd->flags & EE_READONLY)) {
	395	if (device_create_file(&spi->dev, &dev_attr_erase))
	396	dev_err(&spi->dev, "can't create erase interface\n");
	397	}
	398
5ba75b55	399	spi_set_drvdata(spi, edev);
06b4501e AG	400	return 0;
	401	fail:
	402	kfree(edev);
	403	return err;
	404	}
	405
486a5c28	406	static int eeprom_93xx46_remove(struct spi_device *spi)
06b4501e	407	{
5ba75b55	408	struct eeprom_93xx46_dev *edev = spi_get_drvdata(spi);
06b4501e AG	409
	410	if (!(edev->pdata->flags & EE_READONLY))
	411	device_remove_file(&spi->dev, &dev_attr_erase);
	412
	413	sysfs_remove_bin_file(&spi->dev.kobj, &edev->bin);
06b4501e AG	414	kfree(edev);
	415	return 0;
	416	}
	417
	418	static struct spi_driver eeprom_93xx46_driver = {
	419	.driver = {
	420	.name = "93xx46",
c074abe0	421	.of_match_table = of_match_ptr(eeprom_93xx46_of_table),
06b4501e AG	422	},
06b4501e AG	423	.probe = eeprom_93xx46_probe,
2d6bed9c	424	.remove = eeprom_93xx46_remove,
06b4501e AG	425	};
06b4501e AG	426
a3dc3c9e	427	module_spi_driver(eeprom_93xx46_driver);
06b4501e AG	428
	429	MODULE_LICENSE("GPL");
	430	MODULE_DESCRIPTION("Driver for 93xx46 EEPROMs");
	431	MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>");
	432	MODULE_ALIAS("spi:93xx46");