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