2 * at25.c -- support most SPI EEPROMs, such as Atmel AT25 models
4 * Copyright (C) 2006 David Brownell
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <linux/delay.h>
16 #include <linux/device.h>
17 #include <linux/sched.h>
19 #include <linux/spi/spi.h>
20 #include <linux/spi/eeprom.h>
21 #include <linux/property.h>
24 * NOTE: this is an *EEPROM* driver. The vagaries of product naming
25 * mean that some AT25 products are EEPROMs, and others are FLASH.
26 * Handle FLASH chips with the drivers/mtd/devices/m25p80.c driver,
31 struct spi_device
*spi
;
33 struct spi_eeprom chip
;
34 struct bin_attribute bin
;
38 #define AT25_WREN 0x06 /* latch the write enable */
39 #define AT25_WRDI 0x04 /* reset the write enable */
40 #define AT25_RDSR 0x05 /* read status register */
41 #define AT25_WRSR 0x01 /* write status register */
42 #define AT25_READ 0x03 /* read byte(s) */
43 #define AT25_WRITE 0x02 /* write byte(s)/sector */
45 #define AT25_SR_nRDY 0x01 /* nRDY = write-in-progress */
46 #define AT25_SR_WEN 0x02 /* write enable (latched) */
47 #define AT25_SR_BP0 0x04 /* BP for software writeprotect */
48 #define AT25_SR_BP1 0x08
49 #define AT25_SR_WPEN 0x80 /* writeprotect enable */
51 #define AT25_INSTR_BIT3 0x08 /* Additional address bit in instr */
53 #define EE_MAXADDRLEN 3 /* 24 bit addresses, up to 2 MBytes */
55 /* Specs often allow 5 msec for a page write, sometimes 20 msec;
56 * it's important to recover from write timeouts.
60 /*-------------------------------------------------------------------------*/
62 #define io_limit PAGE_SIZE /* bytes */
66 struct at25_data
*at25
,
72 u8 command
[EE_MAXADDRLEN
+ 1];
75 struct spi_transfer t
[2];
79 if (unlikely(offset
>= at25
->bin
.size
))
81 if ((offset
+ count
) > at25
->bin
.size
)
82 count
= at25
->bin
.size
- offset
;
89 if (at25
->chip
.flags
& EE_INSTR_BIT3_IS_ADDR
)
90 if (offset
>= (1U << (at25
->addrlen
* 8)))
91 instr
|= AT25_INSTR_BIT3
;
94 /* 8/16/24-bit address is written MSB first */
95 switch (at25
->addrlen
) {
101 case 0: /* can't happen: for better codegen */
105 spi_message_init(&m
);
106 memset(t
, 0, sizeof t
);
108 t
[0].tx_buf
= command
;
109 t
[0].len
= at25
->addrlen
+ 1;
110 spi_message_add_tail(&t
[0], &m
);
114 spi_message_add_tail(&t
[1], &m
);
116 mutex_lock(&at25
->lock
);
118 /* Read it all at once.
120 * REVISIT that's potentially a problem with large chips, if
121 * other devices on the bus need to be accessed regularly or
122 * this chip is clocked very slowly
124 status
= spi_sync(at25
->spi
, &m
);
125 dev_dbg(&at25
->spi
->dev
,
126 "read %Zd bytes at %d --> %d\n",
127 count
, offset
, (int) status
);
129 mutex_unlock(&at25
->lock
);
130 return status
? status
: count
;
134 at25_bin_read(struct file
*filp
, struct kobject
*kobj
,
135 struct bin_attribute
*bin_attr
,
136 char *buf
, loff_t off
, size_t count
)
139 struct at25_data
*at25
;
141 dev
= kobj_to_dev(kobj
);
142 at25
= dev_get_drvdata(dev
);
144 return at25_ee_read(at25
, buf
, off
, count
);
149 at25_ee_write(struct at25_data
*at25
, const char *buf
, loff_t off
,
153 unsigned written
= 0;
157 if (unlikely(off
>= at25
->bin
.size
))
159 if ((off
+ count
) > at25
->bin
.size
)
160 count
= at25
->bin
.size
- off
;
161 if (unlikely(!count
))
164 /* Temp buffer starts with command and address */
165 buf_size
= at25
->chip
.page_size
;
166 if (buf_size
> io_limit
)
168 bounce
= kmalloc(buf_size
+ at25
->addrlen
+ 1, GFP_KERNEL
);
172 /* For write, rollover is within the page ... so we write at
173 * most one page, then manually roll over to the next page.
175 mutex_lock(&at25
->lock
);
177 unsigned long timeout
, retries
;
179 unsigned offset
= (unsigned) off
;
185 status
= spi_write(at25
->spi
, cp
, 1);
187 dev_dbg(&at25
->spi
->dev
, "WREN --> %d\n",
193 if (at25
->chip
.flags
& EE_INSTR_BIT3_IS_ADDR
)
194 if (offset
>= (1U << (at25
->addrlen
* 8)))
195 instr
|= AT25_INSTR_BIT3
;
198 /* 8/16/24-bit address is written MSB first */
199 switch (at25
->addrlen
) {
200 default: /* case 3 */
201 *cp
++ = offset
>> 16;
205 case 0: /* can't happen: for better codegen */
209 /* Write as much of a page as we can */
210 segment
= buf_size
- (offset
% buf_size
);
213 memcpy(cp
, buf
, segment
);
214 status
= spi_write(at25
->spi
, bounce
,
215 segment
+ at25
->addrlen
+ 1);
216 dev_dbg(&at25
->spi
->dev
,
217 "write %u bytes at %u --> %d\n",
218 segment
, offset
, (int) status
);
222 /* REVISIT this should detect (or prevent) failed writes
223 * to readonly sections of the EEPROM...
226 /* Wait for non-busy status */
227 timeout
= jiffies
+ msecs_to_jiffies(EE_TIMEOUT
);
231 sr
= spi_w8r8(at25
->spi
, AT25_RDSR
);
232 if (sr
< 0 || (sr
& AT25_SR_nRDY
)) {
233 dev_dbg(&at25
->spi
->dev
,
234 "rdsr --> %d (%02x)\n", sr
, sr
);
235 /* at HZ=100, this is sloooow */
239 if (!(sr
& AT25_SR_nRDY
))
241 } while (retries
++ < 3 || time_before_eq(jiffies
, timeout
));
243 if ((sr
< 0) || (sr
& AT25_SR_nRDY
)) {
244 dev_err(&at25
->spi
->dev
,
245 "write %d bytes offset %d, "
246 "timeout after %u msecs\n",
248 jiffies_to_msecs(jiffies
-
249 (timeout
- EE_TIMEOUT
)));
261 mutex_unlock(&at25
->lock
);
264 return written
? written
: status
;
268 at25_bin_write(struct file
*filp
, struct kobject
*kobj
,
269 struct bin_attribute
*bin_attr
,
270 char *buf
, loff_t off
, size_t count
)
273 struct at25_data
*at25
;
275 dev
= kobj_to_dev(kobj
);
276 at25
= dev_get_drvdata(dev
);
278 return at25_ee_write(at25
, buf
, off
, count
);
281 /*-------------------------------------------------------------------------*/
283 static int at25_fw_to_chip(struct device
*dev
, struct spi_eeprom
*chip
)
287 memset(chip
, 0, sizeof(*chip
));
288 strncpy(chip
->name
, "at25", sizeof(chip
->name
));
290 if (device_property_read_u32(dev
, "size", &val
) == 0 ||
291 device_property_read_u32(dev
, "at25,byte-len", &val
) == 0) {
292 chip
->byte_len
= val
;
294 dev_err(dev
, "Error: missing \"size\" property\n");
298 if (device_property_read_u32(dev
, "pagesize", &val
) == 0 ||
299 device_property_read_u32(dev
, "at25,page-size", &val
) == 0) {
300 chip
->page_size
= (u16
)val
;
302 dev_err(dev
, "Error: missing \"pagesize\" property\n");
306 if (device_property_read_u32(dev
, "at25,addr-mode", &val
) == 0) {
307 chip
->flags
= (u16
)val
;
309 if (device_property_read_u32(dev
, "address-width", &val
)) {
311 "Error: missing \"address-width\" property\n");
316 chip
->flags
|= EE_ADDR1
;
319 chip
->flags
|= EE_ADDR2
;
322 chip
->flags
|= EE_ADDR3
;
326 "Error: bad \"address-width\" property: %u\n",
330 if (device_property_present(dev
, "read-only"))
331 chip
->flags
|= EE_READONLY
;
336 static int at25_probe(struct spi_device
*spi
)
338 struct at25_data
*at25
= NULL
;
339 struct spi_eeprom chip
;
344 /* Chip description */
345 if (!spi
->dev
.platform_data
) {
346 err
= at25_fw_to_chip(&spi
->dev
, &chip
);
350 chip
= *(struct spi_eeprom
*)spi
->dev
.platform_data
;
352 /* For now we only support 8/16/24 bit addressing */
353 if (chip
.flags
& EE_ADDR1
)
355 else if (chip
.flags
& EE_ADDR2
)
357 else if (chip
.flags
& EE_ADDR3
)
360 dev_dbg(&spi
->dev
, "unsupported address type\n");
364 /* Ping the chip ... the status register is pretty portable,
365 * unlike probing manufacturer IDs. We do expect that system
366 * firmware didn't write it in the past few milliseconds!
368 sr
= spi_w8r8(spi
, AT25_RDSR
);
369 if (sr
< 0 || sr
& AT25_SR_nRDY
) {
370 dev_dbg(&spi
->dev
, "rdsr --> %d (%02x)\n", sr
, sr
);
374 at25
= devm_kzalloc(&spi
->dev
, sizeof(struct at25_data
), GFP_KERNEL
);
378 mutex_init(&at25
->lock
);
380 at25
->spi
= spi_dev_get(spi
);
381 spi_set_drvdata(spi
, at25
);
382 at25
->addrlen
= addrlen
;
384 /* Export the EEPROM bytes through sysfs, since that's convenient.
385 * And maybe to other kernel code; it might hold a board's Ethernet
386 * address, or board-specific calibration data generated on the
387 * manufacturing floor.
389 * Default to root-only access to the data; EEPROMs often hold data
390 * that's sensitive for read and/or write, like ethernet addresses,
391 * security codes, board-specific manufacturing calibrations, etc.
393 sysfs_bin_attr_init(&at25
->bin
);
394 at25
->bin
.attr
.name
= "eeprom";
395 at25
->bin
.attr
.mode
= S_IRUSR
;
396 at25
->bin
.read
= at25_bin_read
;
398 at25
->bin
.size
= at25
->chip
.byte_len
;
399 if (!(chip
.flags
& EE_READONLY
)) {
400 at25
->bin
.write
= at25_bin_write
;
401 at25
->bin
.attr
.mode
|= S_IWUSR
;
404 err
= sysfs_create_bin_file(&spi
->dev
.kobj
, &at25
->bin
);
408 dev_info(&spi
->dev
, "%Zd %s %s eeprom%s, pagesize %u\n",
409 (at25
->bin
.size
< 1024)
411 : (at25
->bin
.size
/ 1024),
412 (at25
->bin
.size
< 1024) ? "Byte" : "KByte",
414 (chip
.flags
& EE_READONLY
) ? " (readonly)" : "",
415 at25
->chip
.page_size
);
419 static int at25_remove(struct spi_device
*spi
)
421 struct at25_data
*at25
;
423 at25
= spi_get_drvdata(spi
);
424 sysfs_remove_bin_file(&spi
->dev
.kobj
, &at25
->bin
);
428 /*-------------------------------------------------------------------------*/
430 static const struct of_device_id at25_of_match
[] = {
431 { .compatible
= "atmel,at25", },
434 MODULE_DEVICE_TABLE(of
, at25_of_match
);
436 static struct spi_driver at25_driver
= {
439 .of_match_table
= at25_of_match
,
442 .remove
= at25_remove
,
445 module_spi_driver(at25_driver
);
447 MODULE_DESCRIPTION("Driver for most SPI EEPROMs");
448 MODULE_AUTHOR("David Brownell");
449 MODULE_LICENSE("GPL");
450 MODULE_ALIAS("spi:at25");