1 // SPDX-License-Identifier: GPL-2.0-only
3 * Driver for 93xx46 EEPROMs
5 * (C) 2011 DENX Software Engineering, Anatolij Gustschin <agust@denx.de>
8 #include <linux/delay.h>
9 #include <linux/device.h>
10 #include <linux/gpio/consumer.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/mutex.h>
15 #include <linux/of_device.h>
16 #include <linux/of_gpio.h>
17 #include <linux/slab.h>
18 #include <linux/spi/spi.h>
19 #include <linux/nvmem-provider.h>
20 #include <linux/eeprom_93xx46.h>
23 #define OP_WRITE (OP_START | 0x1)
24 #define OP_READ (OP_START | 0x2)
25 #define ADDR_EWDS 0x00
26 #define ADDR_ERAL 0x20
27 #define ADDR_EWEN 0x30
29 struct eeprom_93xx46_devtype_data {
33 static const struct eeprom_93xx46_devtype_data atmel_at93c46d_data = {
34 .quirks = EEPROM_93XX46_QUIRK_SINGLE_WORD_READ |
35 EEPROM_93XX46_QUIRK_INSTRUCTION_LENGTH,
38 static const struct eeprom_93xx46_devtype_data microchip_93lc46b_data = {
39 .quirks = EEPROM_93XX46_QUIRK_EXTRA_READ_CYCLE,
42 struct eeprom_93xx46_dev {
43 struct spi_device *spi;
44 struct eeprom_93xx46_platform_data *pdata;
46 struct nvmem_config nvmem_config;
47 struct nvmem_device *nvmem;
52 static inline bool has_quirk_single_word_read(struct eeprom_93xx46_dev *edev)
54 return edev->pdata->quirks & EEPROM_93XX46_QUIRK_SINGLE_WORD_READ;
57 static inline bool has_quirk_instruction_length(struct eeprom_93xx46_dev *edev)
59 return edev->pdata->quirks & EEPROM_93XX46_QUIRK_INSTRUCTION_LENGTH;
62 static inline bool has_quirk_extra_read_cycle(struct eeprom_93xx46_dev *edev)
64 return edev->pdata->quirks & EEPROM_93XX46_QUIRK_EXTRA_READ_CYCLE;
67 static int eeprom_93xx46_read(void *priv, unsigned int off,
68 void *val, size_t count)
70 struct eeprom_93xx46_dev *edev = priv;
74 if (unlikely(off >= edev->size))
76 if ((off + count) > edev->size)
77 count = edev->size - off;
81 mutex_lock(&edev->lock);
83 if (edev->pdata->prepare)
84 edev->pdata->prepare(edev);
88 struct spi_transfer t[2] = { { 0 } };
89 u16 cmd_addr = OP_READ << edev->addrlen;
90 size_t nbytes = count;
93 if (edev->addrlen == 7) {
94 cmd_addr |= off & 0x7f;
96 if (has_quirk_single_word_read(edev))
99 cmd_addr |= (off >> 1) & 0x3f;
101 if (has_quirk_single_word_read(edev))
105 dev_dbg(&edev->spi->dev, "read cmd 0x%x, %d Hz\n",
106 cmd_addr, edev->spi->max_speed_hz);
108 if (has_quirk_extra_read_cycle(edev)) {
113 spi_message_init(&m);
115 t[0].tx_buf = (char *)&cmd_addr;
117 t[0].bits_per_word = bits;
118 spi_message_add_tail(&t[0], &m);
122 t[1].bits_per_word = 8;
123 spi_message_add_tail(&t[1], &m);
125 err = spi_sync(edev->spi, &m);
126 /* have to wait at least Tcsl ns */
130 dev_err(&edev->spi->dev, "read %zu bytes at %d: err. %d\n",
131 nbytes, (int)off, err);
140 if (edev->pdata->finish)
141 edev->pdata->finish(edev);
143 mutex_unlock(&edev->lock);
148 static int eeprom_93xx46_ew(struct eeprom_93xx46_dev *edev, int is_on)
150 struct spi_message m;
151 struct spi_transfer t;
155 cmd_addr = OP_START << edev->addrlen;
156 if (edev->addrlen == 7) {
157 cmd_addr |= (is_on ? ADDR_EWEN : ADDR_EWDS) << 1;
160 cmd_addr |= (is_on ? ADDR_EWEN : ADDR_EWDS);
164 if (has_quirk_instruction_length(edev)) {
169 dev_dbg(&edev->spi->dev, "ew%s cmd 0x%04x, %d bits\n",
170 is_on ? "en" : "ds", cmd_addr, bits);
172 spi_message_init(&m);
173 memset(&t, 0, sizeof(t));
175 t.tx_buf = &cmd_addr;
177 t.bits_per_word = bits;
178 spi_message_add_tail(&t, &m);
180 mutex_lock(&edev->lock);
182 if (edev->pdata->prepare)
183 edev->pdata->prepare(edev);
185 ret = spi_sync(edev->spi, &m);
186 /* have to wait at least Tcsl ns */
189 dev_err(&edev->spi->dev, "erase/write %sable error %d\n",
190 is_on ? "en" : "dis", ret);
192 if (edev->pdata->finish)
193 edev->pdata->finish(edev);
195 mutex_unlock(&edev->lock);
200 eeprom_93xx46_write_word(struct eeprom_93xx46_dev *edev,
201 const char *buf, unsigned off)
203 struct spi_message m;
204 struct spi_transfer t[2];
205 int bits, data_len, ret;
208 cmd_addr = OP_WRITE << edev->addrlen;
210 if (edev->addrlen == 7) {
211 cmd_addr |= off & 0x7f;
215 cmd_addr |= (off >> 1) & 0x3f;
220 dev_dbg(&edev->spi->dev, "write cmd 0x%x\n", cmd_addr);
222 spi_message_init(&m);
223 memset(t, 0, sizeof(t));
225 t[0].tx_buf = (char *)&cmd_addr;
227 t[0].bits_per_word = bits;
228 spi_message_add_tail(&t[0], &m);
232 t[1].bits_per_word = 8;
233 spi_message_add_tail(&t[1], &m);
235 ret = spi_sync(edev->spi, &m);
236 /* have to wait program cycle time Twc ms */
241 static int eeprom_93xx46_write(void *priv, unsigned int off,
242 void *val, size_t count)
244 struct eeprom_93xx46_dev *edev = priv;
246 int i, ret, step = 1;
248 if (unlikely(off >= edev->size))
250 if ((off + count) > edev->size)
251 count = edev->size - off;
252 if (unlikely(!count))
255 /* only write even number of bytes on 16-bit devices */
256 if (edev->addrlen == 6) {
261 /* erase/write enable */
262 ret = eeprom_93xx46_ew(edev, 1);
266 mutex_lock(&edev->lock);
268 if (edev->pdata->prepare)
269 edev->pdata->prepare(edev);
271 for (i = 0; i < count; i += step) {
272 ret = eeprom_93xx46_write_word(edev, &buf[i], off + i);
274 dev_err(&edev->spi->dev, "write failed at %d: %d\n",
280 if (edev->pdata->finish)
281 edev->pdata->finish(edev);
283 mutex_unlock(&edev->lock);
285 /* erase/write disable */
286 eeprom_93xx46_ew(edev, 0);
290 static int eeprom_93xx46_eral(struct eeprom_93xx46_dev *edev)
292 struct eeprom_93xx46_platform_data *pd = edev->pdata;
293 struct spi_message m;
294 struct spi_transfer t;
298 cmd_addr = OP_START << edev->addrlen;
299 if (edev->addrlen == 7) {
300 cmd_addr |= ADDR_ERAL << 1;
303 cmd_addr |= ADDR_ERAL;
307 if (has_quirk_instruction_length(edev)) {
312 dev_dbg(&edev->spi->dev, "eral cmd 0x%04x, %d bits\n", cmd_addr, bits);
314 spi_message_init(&m);
315 memset(&t, 0, sizeof(t));
317 t.tx_buf = &cmd_addr;
319 t.bits_per_word = bits;
320 spi_message_add_tail(&t, &m);
322 mutex_lock(&edev->lock);
324 if (edev->pdata->prepare)
325 edev->pdata->prepare(edev);
327 ret = spi_sync(edev->spi, &m);
329 dev_err(&edev->spi->dev, "erase error %d\n", ret);
330 /* have to wait erase cycle time Tec ms */
336 mutex_unlock(&edev->lock);
340 static ssize_t eeprom_93xx46_store_erase(struct device *dev,
341 struct device_attribute *attr,
342 const char *buf, size_t count)
344 struct eeprom_93xx46_dev *edev = dev_get_drvdata(dev);
347 sscanf(buf, "%d", &erase);
349 ret = eeprom_93xx46_ew(edev, 1);
352 ret = eeprom_93xx46_eral(edev);
355 ret = eeprom_93xx46_ew(edev, 0);
361 static DEVICE_ATTR(erase, S_IWUSR, NULL, eeprom_93xx46_store_erase);
363 static void select_assert(void *context)
365 struct eeprom_93xx46_dev *edev = context;
367 gpiod_set_value_cansleep(edev->pdata->select, 1);
370 static void select_deassert(void *context)
372 struct eeprom_93xx46_dev *edev = context;
374 gpiod_set_value_cansleep(edev->pdata->select, 0);
377 static const struct of_device_id eeprom_93xx46_of_table[] = {
378 { .compatible = "eeprom-93xx46", },
379 { .compatible = "atmel,at93c46d", .data = &atmel_at93c46d_data, },
380 { .compatible = "microchip,93lc46b", .data = µchip_93lc46b_data, },
383 MODULE_DEVICE_TABLE(of, eeprom_93xx46_of_table);
385 static int eeprom_93xx46_probe_dt(struct spi_device *spi)
387 const struct of_device_id *of_id =
388 of_match_device(eeprom_93xx46_of_table, &spi->dev);
389 struct device_node *np = spi->dev.of_node;
390 struct eeprom_93xx46_platform_data *pd;
394 pd = devm_kzalloc(&spi->dev, sizeof(*pd), GFP_KERNEL);
398 ret = of_property_read_u32(np, "data-size", &tmp);
400 dev_err(&spi->dev, "data-size property not found\n");
405 pd->flags |= EE_ADDR8;
406 } else if (tmp == 16) {
407 pd->flags |= EE_ADDR16;
409 dev_err(&spi->dev, "invalid data-size (%d)\n", tmp);
413 if (of_property_read_bool(np, "read-only"))
414 pd->flags |= EE_READONLY;
416 pd->select = devm_gpiod_get_optional(&spi->dev, "select",
418 if (IS_ERR(pd->select))
419 return PTR_ERR(pd->select);
421 pd->prepare = select_assert;
422 pd->finish = select_deassert;
423 gpiod_direction_output(pd->select, 0);
426 const struct eeprom_93xx46_devtype_data *data = of_id->data;
428 pd->quirks = data->quirks;
431 spi->dev.platform_data = pd;
436 static int eeprom_93xx46_probe(struct spi_device *spi)
438 struct eeprom_93xx46_platform_data *pd;
439 struct eeprom_93xx46_dev *edev;
442 if (spi->dev.of_node) {
443 err = eeprom_93xx46_probe_dt(spi);
448 pd = spi->dev.platform_data;
450 dev_err(&spi->dev, "missing platform data\n");
454 edev = devm_kzalloc(&spi->dev, sizeof(*edev), GFP_KERNEL);
458 if (pd->flags & EE_ADDR8)
460 else if (pd->flags & EE_ADDR16)
463 dev_err(&spi->dev, "unspecified address type\n");
467 mutex_init(&edev->lock);
473 edev->nvmem_config.type = NVMEM_TYPE_EEPROM;
474 edev->nvmem_config.name = dev_name(&spi->dev);
475 edev->nvmem_config.dev = &spi->dev;
476 edev->nvmem_config.read_only = pd->flags & EE_READONLY;
477 edev->nvmem_config.root_only = true;
478 edev->nvmem_config.owner = THIS_MODULE;
479 edev->nvmem_config.compat = true;
480 edev->nvmem_config.base_dev = &spi->dev;
481 edev->nvmem_config.reg_read = eeprom_93xx46_read;
482 edev->nvmem_config.reg_write = eeprom_93xx46_write;
483 edev->nvmem_config.priv = edev;
484 edev->nvmem_config.stride = 4;
485 edev->nvmem_config.word_size = 1;
486 edev->nvmem_config.size = edev->size;
488 edev->nvmem = devm_nvmem_register(&spi->dev, &edev->nvmem_config);
489 if (IS_ERR(edev->nvmem))
490 return PTR_ERR(edev->nvmem);
492 dev_info(&spi->dev, "%d-bit eeprom %s\n",
493 (pd->flags & EE_ADDR8) ? 8 : 16,
494 (pd->flags & EE_READONLY) ? "(readonly)" : "");
496 if (!(pd->flags & EE_READONLY)) {
497 if (device_create_file(&spi->dev, &dev_attr_erase))
498 dev_err(&spi->dev, "can't create erase interface\n");
501 spi_set_drvdata(spi, edev);
505 static int eeprom_93xx46_remove(struct spi_device *spi)
507 struct eeprom_93xx46_dev *edev = spi_get_drvdata(spi);
509 if (!(edev->pdata->flags & EE_READONLY))
510 device_remove_file(&spi->dev, &dev_attr_erase);
515 static struct spi_driver eeprom_93xx46_driver = {
518 .of_match_table = of_match_ptr(eeprom_93xx46_of_table),
520 .probe = eeprom_93xx46_probe,
521 .remove = eeprom_93xx46_remove,
524 module_spi_driver(eeprom_93xx46_driver);
526 MODULE_LICENSE("GPL");
527 MODULE_DESCRIPTION("Driver for 93xx46 EEPROMs");
528 MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>");
529 MODULE_ALIAS("spi:93xx46");
530 MODULE_ALIAS("spi:eeprom-93xx46");