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/init.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/delay.h>
17 #include <linux/device.h>
18 #include <linux/sched.h>
20 #include <linux/spi/spi.h>
21 #include <linux/spi/eeprom.h>
25 * NOTE: this is an *EEPROM* driver. The vagaries of product naming
26 * mean that some AT25 products are EEPROMs, and others are FLASH.
27 * Handle FLASH chips with the drivers/mtd/devices/m25p80.c driver,
32 struct spi_device
*spi
;
33 struct memory_accessor mem
;
35 struct spi_eeprom chip
;
36 struct bin_attribute bin
;
40 #define AT25_WREN 0x06 /* latch the write enable */
41 #define AT25_WRDI 0x04 /* reset the write enable */
42 #define AT25_RDSR 0x05 /* read status register */
43 #define AT25_WRSR 0x01 /* write status register */
44 #define AT25_READ 0x03 /* read byte(s) */
45 #define AT25_WRITE 0x02 /* write byte(s)/sector */
47 #define AT25_SR_nRDY 0x01 /* nRDY = write-in-progress */
48 #define AT25_SR_WEN 0x02 /* write enable (latched) */
49 #define AT25_SR_BP0 0x04 /* BP for software writeprotect */
50 #define AT25_SR_BP1 0x08
51 #define AT25_SR_WPEN 0x80 /* writeprotect enable */
54 #define EE_MAXADDRLEN 3 /* 24 bit addresses, up to 2 MBytes */
56 /* Specs often allow 5 msec for a page write, sometimes 20 msec;
57 * it's important to recover from write timeouts.
61 /*-------------------------------------------------------------------------*/
63 #define io_limit PAGE_SIZE /* bytes */
67 struct at25_data
*at25
,
73 u8 command
[EE_MAXADDRLEN
+ 1];
76 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 /* 8/16/24-bit address is written MSB first */
90 switch (at25
->addrlen
) {
96 case 0: /* can't happen: for better codegen */
100 spi_message_init(&m
);
101 memset(t
, 0, sizeof t
);
103 t
[0].tx_buf
= command
;
104 t
[0].len
= at25
->addrlen
+ 1;
105 spi_message_add_tail(&t
[0], &m
);
109 spi_message_add_tail(&t
[1], &m
);
111 mutex_lock(&at25
->lock
);
113 /* Read it all at once.
115 * REVISIT that's potentially a problem with large chips, if
116 * other devices on the bus need to be accessed regularly or
117 * this chip is clocked very slowly
119 status
= spi_sync(at25
->spi
, &m
);
120 dev_dbg(&at25
->spi
->dev
,
121 "read %Zd bytes at %d --> %d\n",
122 count
, offset
, (int) status
);
124 mutex_unlock(&at25
->lock
);
125 return status
? status
: count
;
129 at25_bin_read(struct kobject
*kobj
, struct bin_attribute
*bin_attr
,
130 char *buf
, loff_t off
, size_t count
)
133 struct at25_data
*at25
;
135 dev
= container_of(kobj
, struct device
, kobj
);
136 at25
= dev_get_drvdata(dev
);
138 return at25_ee_read(at25
, buf
, off
, count
);
143 at25_ee_write(struct at25_data
*at25
, char *buf
, loff_t off
, size_t count
)
146 unsigned written
= 0;
150 if (unlikely(off
>= at25
->bin
.size
))
152 if ((off
+ count
) > at25
->bin
.size
)
153 count
= at25
->bin
.size
- off
;
154 if (unlikely(!count
))
157 /* Temp buffer starts with command and address */
158 buf_size
= at25
->chip
.page_size
;
159 if (buf_size
> io_limit
)
161 bounce
= kmalloc(buf_size
+ at25
->addrlen
+ 1, GFP_KERNEL
);
165 /* For write, rollover is within the page ... so we write at
166 * most one page, then manually roll over to the next page.
168 bounce
[0] = AT25_WRITE
;
169 mutex_lock(&at25
->lock
);
171 unsigned long timeout
, retries
;
173 unsigned offset
= (unsigned) off
;
177 status
= spi_write(at25
->spi
, cp
, 1);
179 dev_dbg(&at25
->spi
->dev
, "WREN --> %d\n",
184 /* 8/16/24-bit address is written MSB first */
185 switch (at25
->addrlen
) {
186 default: /* case 3 */
187 *cp
++ = offset
>> 16;
191 case 0: /* can't happen: for better codegen */
195 /* Write as much of a page as we can */
196 segment
= buf_size
- (offset
% buf_size
);
199 memcpy(cp
, buf
, segment
);
200 status
= spi_write(at25
->spi
, bounce
,
201 segment
+ at25
->addrlen
+ 1);
202 dev_dbg(&at25
->spi
->dev
,
203 "write %u bytes at %u --> %d\n",
204 segment
, offset
, (int) status
);
208 /* REVISIT this should detect (or prevent) failed writes
209 * to readonly sections of the EEPROM...
212 /* Wait for non-busy status */
213 timeout
= jiffies
+ msecs_to_jiffies(EE_TIMEOUT
);
218 sr
= spi_w8r8(at25
->spi
, AT25_RDSR
);
219 if (sr
< 0 || (sr
& AT25_SR_nRDY
)) {
220 dev_dbg(&at25
->spi
->dev
,
221 "rdsr --> %d (%02x)\n", sr
, sr
);
222 /* at HZ=100, this is sloooow */
226 if (!(sr
& AT25_SR_nRDY
))
228 } while (retries
++ < 3 || time_before_eq(jiffies
, timeout
));
230 if (time_after(jiffies
, timeout
)) {
231 dev_err(&at25
->spi
->dev
,
232 "write %d bytes offset %d, "
233 "timeout after %u msecs\n",
235 jiffies_to_msecs(jiffies
-
236 (timeout
- EE_TIMEOUT
)));
248 mutex_unlock(&at25
->lock
);
251 return written
? written
: status
;
255 at25_bin_write(struct kobject
*kobj
, struct bin_attribute
*bin_attr
,
256 char *buf
, loff_t off
, size_t count
)
259 struct at25_data
*at25
;
261 dev
= container_of(kobj
, struct device
, kobj
);
262 at25
= dev_get_drvdata(dev
);
264 return at25_ee_write(at25
, buf
, off
, count
);
267 /*-------------------------------------------------------------------------*/
269 /* Let in-kernel code access the eeprom data. */
271 static ssize_t
at25_mem_read(struct memory_accessor
*mem
, char *buf
,
272 off_t offset
, size_t count
)
274 struct at25_data
*at25
= container_of(mem
, struct at25_data
, mem
);
276 return at25_ee_read(at25
, buf
, offset
, count
);
279 static ssize_t
at25_mem_write(struct memory_accessor
*mem
, char *buf
,
280 off_t offset
, size_t count
)
282 struct at25_data
*at25
= container_of(mem
, struct at25_data
, mem
);
284 return at25_ee_write(at25
, buf
, offset
, count
);
287 /*-------------------------------------------------------------------------*/
289 static int at25_probe(struct spi_device
*spi
)
291 struct at25_data
*at25
= NULL
;
292 const struct spi_eeprom
*chip
;
297 /* Chip description */
298 chip
= spi
->dev
.platform_data
;
300 dev_dbg(&spi
->dev
, "no chip description\n");
305 /* For now we only support 8/16/24 bit addressing */
306 if (chip
->flags
& EE_ADDR1
)
308 else if (chip
->flags
& EE_ADDR2
)
310 else if (chip
->flags
& EE_ADDR3
)
313 dev_dbg(&spi
->dev
, "unsupported address type\n");
318 /* Ping the chip ... the status register is pretty portable,
319 * unlike probing manufacturer IDs. We do expect that system
320 * firmware didn't write it in the past few milliseconds!
322 sr
= spi_w8r8(spi
, AT25_RDSR
);
323 if (sr
< 0 || sr
& AT25_SR_nRDY
) {
324 dev_dbg(&spi
->dev
, "rdsr --> %d (%02x)\n", sr
, sr
);
329 if (!(at25
= kzalloc(sizeof *at25
, GFP_KERNEL
))) {
334 mutex_init(&at25
->lock
);
336 at25
->spi
= spi_dev_get(spi
);
337 dev_set_drvdata(&spi
->dev
, at25
);
338 at25
->addrlen
= addrlen
;
340 /* Export the EEPROM bytes through sysfs, since that's convenient.
341 * And maybe to other kernel code; it might hold a board's Ethernet
342 * address, or board-specific calibration data generated on the
343 * manufacturing floor.
345 * Default to root-only access to the data; EEPROMs often hold data
346 * that's sensitive for read and/or write, like ethernet addresses,
347 * security codes, board-specific manufacturing calibrations, etc.
349 at25
->bin
.attr
.name
= "eeprom";
350 at25
->bin
.attr
.mode
= S_IRUSR
;
351 at25
->bin
.read
= at25_bin_read
;
352 at25
->mem
.read
= at25_mem_read
;
354 at25
->bin
.size
= at25
->chip
.byte_len
;
355 if (!(chip
->flags
& EE_READONLY
)) {
356 at25
->bin
.write
= at25_bin_write
;
357 at25
->bin
.attr
.mode
|= S_IWUSR
;
358 at25
->mem
.write
= at25_mem_write
;
361 err
= sysfs_create_bin_file(&spi
->dev
.kobj
, &at25
->bin
);
366 chip
->setup(&at25
->mem
, chip
->context
);
368 dev_info(&spi
->dev
, "%Zd %s %s eeprom%s, pagesize %u\n",
369 (at25
->bin
.size
< 1024)
371 : (at25
->bin
.size
/ 1024),
372 (at25
->bin
.size
< 1024) ? "Byte" : "KByte",
374 (chip
->flags
& EE_READONLY
) ? " (readonly)" : "",
375 at25
->chip
.page_size
);
378 dev_dbg(&spi
->dev
, "probe err %d\n", err
);
383 static int __devexit
at25_remove(struct spi_device
*spi
)
385 struct at25_data
*at25
;
387 at25
= dev_get_drvdata(&spi
->dev
);
388 sysfs_remove_bin_file(&spi
->dev
.kobj
, &at25
->bin
);
393 /*-------------------------------------------------------------------------*/
395 static struct spi_driver at25_driver
= {
398 .owner
= THIS_MODULE
,
401 .remove
= __devexit_p(at25_remove
),
404 static int __init
at25_init(void)
406 return spi_register_driver(&at25_driver
);
408 module_init(at25_init
);
410 static void __exit
at25_exit(void)
412 spi_unregister_driver(&at25_driver
);
414 module_exit(at25_exit
);
416 MODULE_DESCRIPTION("Driver for most SPI EEPROMs");
417 MODULE_AUTHOR("David Brownell");
418 MODULE_LICENSE("GPL");
This page took 0.104048 seconds and 5 git commands to generate.