2 * Atmel SPI DataFlash support
4 * Copyright (C) 2008 Atmel Corporation
5 * Licensed under the GPL-2 or later.
10 #include <spi_flash.h>
12 #include "spi_flash_internal.h"
14 /* AT45-specific commands */
15 #define CMD_AT45_READ_STATUS 0xd7
16 #define CMD_AT45_ERASE_PAGE 0x81
17 #define CMD_AT45_LOAD_PROG_BUF1 0x82
18 #define CMD_AT45_LOAD_BUF1 0x84
19 #define CMD_AT45_LOAD_PROG_BUF2 0x85
20 #define CMD_AT45_LOAD_BUF2 0x87
21 #define CMD_AT45_PROG_BUF1 0x88
22 #define CMD_AT45_PROG_BUF2 0x89
24 /* AT45 status register bits */
25 #define AT45_STATUS_P2_PAGE_SIZE (1 << 0)
26 #define AT45_STATUS_READY (1 << 7)
28 /* DataFlash family IDs, as obtained from the second idcode byte */
29 #define DF_FAMILY_AT26F 0
30 #define DF_FAMILY_AT45 1
31 #define DF_FAMILY_AT26DF 2 /* AT25DF and AT26DF */
33 struct atmel_spi_flash_params {
35 /* Log2 of page size in power-of-two mode */
43 /* spi_flash needs to be first so upper layers can free() it */
44 struct atmel_spi_flash {
45 struct spi_flash flash;
46 const struct atmel_spi_flash_params *params;
49 static inline struct atmel_spi_flash *
50 to_atmel_spi_flash(struct spi_flash *flash)
52 return container_of(flash, struct atmel_spi_flash, flash);
55 static const struct atmel_spi_flash_params atmel_spi_flash_table[] = {
60 .blocks_per_sector = 16,
68 .blocks_per_sector = 16,
76 .blocks_per_sector = 32,
84 .blocks_per_sector = 32,
92 .blocks_per_sector = 32,
100 .blocks_per_sector = 64,
102 .name = "AT45DB321D",
107 .pages_per_block = 8,
108 .blocks_per_sector = 32,
110 .name = "AT45DB642D",
115 .pages_per_block = 16,
116 .blocks_per_sector = 16,
122 static int at45_wait_ready(struct spi_flash *flash, unsigned long timeout)
124 struct spi_slave *spi = flash->spi;
125 unsigned long timebase;
127 u8 cmd = CMD_AT45_READ_STATUS;
130 timebase = get_timer(0);
132 ret = spi_xfer(spi, 8, &cmd, NULL, SPI_XFER_BEGIN);
137 ret = spi_xfer(spi, 8, NULL, &status, 0);
141 if (status & AT45_STATUS_READY)
143 } while (get_timer(timebase) < timeout);
146 spi_xfer(spi, 0, NULL, NULL, SPI_XFER_END);
148 if (status & AT45_STATUS_READY)
156 * Assemble the address part of a command for AT45 devices in
157 * non-power-of-two page size mode.
159 static void at45_build_address(struct atmel_spi_flash *asf, u8 *cmd, u32 offset)
161 unsigned long page_addr;
162 unsigned long byte_addr;
163 unsigned long page_size;
164 unsigned int page_shift;
167 * The "extra" space per page is the power-of-two page size
170 page_shift = asf->params->l2_page_size;
171 page_size = (1 << page_shift) + (1 << (page_shift - 5));
173 page_addr = offset / page_size;
174 byte_addr = offset % page_size;
176 cmd[0] = page_addr >> (16 - page_shift);
177 cmd[1] = page_addr << (page_shift - 8) | (byte_addr >> 8);
181 static int dataflash_read_fast_at45(struct spi_flash *flash,
182 u32 offset, size_t len, void *buf)
184 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
187 cmd[0] = CMD_READ_ARRAY_FAST;
188 at45_build_address(asf, cmd + 1, offset);
191 return spi_flash_read_common(flash, cmd, sizeof(cmd), buf, len);
195 * TODO: the two write funcs (_p2/_at45) should get unified ...
197 static int dataflash_write_p2(struct spi_flash *flash,
198 u32 offset, size_t len, const void *buf)
200 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
201 unsigned long page_size;
209 * TODO: This function currently uses only page buffer #1. We can
210 * speed this up by using both buffers and loading one buffer while
211 * the other is being programmed into main memory.
214 page_size = (1 << asf->params->l2_page_size);
216 ret = spi_claim_bus(flash->spi);
218 debug("SF: Unable to claim SPI bus\n");
222 for (actual = 0; actual < len; actual += chunk_len) {
223 chunk_len = min(len - actual, page_size - (addr % page_size));
225 /* Use the same address bits for both commands */
226 cmd[0] = CMD_AT45_LOAD_BUF1;
231 ret = spi_flash_cmd_write(flash->spi, cmd, 4,
232 buf + actual, chunk_len);
234 debug("SF: Loading AT45 buffer failed\n");
238 cmd[0] = CMD_AT45_PROG_BUF1;
239 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
241 debug("SF: AT45 page programming failed\n");
245 ret = at45_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
247 debug("SF: AT45 page programming timed out\n");
254 debug("SF: AT45: Successfully programmed %zu bytes @ 0x%x\n",
259 spi_release_bus(flash->spi);
263 static int dataflash_write_at45(struct spi_flash *flash,
264 u32 offset, size_t len, const void *buf)
266 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
267 unsigned long page_addr;
268 unsigned long byte_addr;
269 unsigned long page_size;
270 unsigned int page_shift;
277 * TODO: This function currently uses only page buffer #1. We can
278 * speed this up by using both buffers and loading one buffer while
279 * the other is being programmed into main memory.
282 page_shift = asf->params->l2_page_size;
283 page_size = (1 << page_shift) + (1 << (page_shift - 5));
285 page_addr = offset / page_size;
286 byte_addr = offset % page_size;
288 ret = spi_claim_bus(flash->spi);
290 debug("SF: Unable to claim SPI bus\n");
294 for (actual = 0; actual < len; actual += chunk_len) {
295 chunk_len = min(len - actual, page_size - byte_addr);
297 /* Use the same address bits for both commands */
298 cmd[0] = CMD_AT45_LOAD_BUF1;
299 cmd[1] = page_addr >> (16 - page_shift);
300 cmd[2] = page_addr << (page_shift - 8) | (byte_addr >> 8);
303 ret = spi_flash_cmd_write(flash->spi, cmd, 4,
304 buf + actual, chunk_len);
306 debug("SF: Loading AT45 buffer failed\n");
310 cmd[0] = CMD_AT45_PROG_BUF1;
311 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
313 debug("SF: AT45 page programming failed\n");
317 ret = at45_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
319 debug("SF: AT45 page programming timed out\n");
327 debug("SF: AT45: Successfully programmed %zu bytes @ 0x%x\n",
332 spi_release_bus(flash->spi);
337 * TODO: the two erase funcs (_p2/_at45) should get unified ...
339 static int dataflash_erase_p2(struct spi_flash *flash, u32 offset, size_t len)
341 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
342 unsigned long page_size;
349 * TODO: This function currently uses page erase only. We can
350 * probably speed things up by using block and/or sector erase
354 page_size = (1 << asf->params->l2_page_size);
356 if (offset % page_size || len % page_size) {
357 debug("SF: Erase offset/length not multiple of page size\n");
361 cmd[0] = CMD_AT45_ERASE_PAGE;
364 ret = spi_claim_bus(flash->spi);
366 debug("SF: Unable to claim SPI bus\n");
370 for (actual = 0; actual < len; actual += page_size) {
371 cmd[1] = offset >> 16;
372 cmd[2] = offset >> 8;
374 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
376 debug("SF: AT45 page erase failed\n");
380 ret = at45_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT);
382 debug("SF: AT45 page erase timed out\n");
389 debug("SF: AT45: Successfully erased %zu bytes @ 0x%x\n",
394 spi_release_bus(flash->spi);
398 static int dataflash_erase_at45(struct spi_flash *flash, u32 offset, size_t len)
400 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
401 unsigned long page_addr;
402 unsigned long page_size;
403 unsigned int page_shift;
409 * TODO: This function currently uses page erase only. We can
410 * probably speed things up by using block and/or sector erase
414 page_shift = asf->params->l2_page_size;
415 page_size = (1 << page_shift) + (1 << (page_shift - 5));
417 page_addr = offset / page_size;
419 if (offset % page_size || len % page_size) {
420 debug("SF: Erase offset/length not multiple of page size\n");
424 cmd[0] = CMD_AT45_ERASE_PAGE;
427 ret = spi_claim_bus(flash->spi);
429 debug("SF: Unable to claim SPI bus\n");
433 for (actual = 0; actual < len; actual += page_size) {
434 cmd[1] = page_addr >> (16 - page_shift);
435 cmd[2] = page_addr << (page_shift - 8);
437 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
439 debug("SF: AT45 page erase failed\n");
443 ret = at45_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT);
445 debug("SF: AT45 page erase timed out\n");
452 debug("SF: AT45: Successfully erased %zu bytes @ 0x%x\n",
457 spi_release_bus(flash->spi);
461 struct spi_flash *spi_flash_probe_atmel(struct spi_slave *spi, u8 *idcode)
463 const struct atmel_spi_flash_params *params;
466 struct atmel_spi_flash *asf;
471 for (i = 0; i < ARRAY_SIZE(atmel_spi_flash_table); i++) {
472 params = &atmel_spi_flash_table[i];
473 if (params->idcode1 == idcode[1])
477 if (i == ARRAY_SIZE(atmel_spi_flash_table)) {
478 debug("SF: Unsupported DataFlash ID %02x\n",
483 asf = malloc(sizeof(struct atmel_spi_flash));
485 debug("SF: Failed to allocate memory\n");
489 asf->params = params;
490 asf->flash.spi = spi;
491 asf->flash.name = params->name;
493 /* Assuming power-of-two page size initially. */
494 page_size = 1 << params->l2_page_size;
496 family = idcode[1] >> 5;
501 * AT45 chips have configurable page size. The status
502 * register indicates which configuration is active.
504 ret = spi_flash_cmd(spi, CMD_AT45_READ_STATUS, &status, 1);
508 debug("SF: AT45 status register: %02x\n", status);
510 if (!(status & AT45_STATUS_P2_PAGE_SIZE)) {
511 asf->flash.read = dataflash_read_fast_at45;
512 asf->flash.write = dataflash_write_at45;
513 asf->flash.erase = dataflash_erase_at45;
514 page_size += 1 << (params->l2_page_size - 5);
516 asf->flash.read = spi_flash_cmd_read_fast;
517 asf->flash.write = dataflash_write_p2;
518 asf->flash.erase = dataflash_erase_p2;
523 case DF_FAMILY_AT26F:
524 case DF_FAMILY_AT26DF:
525 asf->flash.read = spi_flash_cmd_read_fast;
526 asf->flash.write = dataflash_write_p2;
527 asf->flash.erase = dataflash_erase_p2;
531 debug("SF: Unsupported DataFlash family %u\n", family);
535 asf->flash.sector_size = page_size;
536 asf->flash.size = page_size * params->pages_per_block
537 * params->blocks_per_sector
538 * params->nr_sectors;