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",
114 static int at45_wait_ready(struct spi_flash *flash, unsigned long timeout)
116 return spi_flash_cmd_poll_bit(flash, timeout,
117 CMD_AT45_READ_STATUS, AT45_STATUS_READY);
121 * Assemble the address part of a command for AT45 devices in
122 * non-power-of-two page size mode.
124 static void at45_build_address(struct atmel_spi_flash *asf, u8 *cmd, u32 offset)
126 unsigned long page_addr;
127 unsigned long byte_addr;
128 unsigned long page_size;
129 unsigned int page_shift;
132 * The "extra" space per page is the power-of-two page size
135 page_shift = asf->params->l2_page_size;
136 page_size = (1 << page_shift) + (1 << (page_shift - 5));
138 page_addr = offset / page_size;
139 byte_addr = offset % page_size;
141 cmd[0] = page_addr >> (16 - page_shift);
142 cmd[1] = page_addr << (page_shift - 8) | (byte_addr >> 8);
146 static int dataflash_read_fast_p2(struct spi_flash *flash,
147 u32 offset, size_t len, void *buf)
151 cmd[0] = CMD_READ_ARRAY_FAST;
152 cmd[1] = offset >> 16;
153 cmd[2] = offset >> 8;
157 return spi_flash_read_common(flash, cmd, sizeof(cmd), buf, len);
160 static int dataflash_read_fast_at45(struct spi_flash *flash,
161 u32 offset, size_t len, void *buf)
163 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
166 cmd[0] = CMD_READ_ARRAY_FAST;
167 at45_build_address(asf, cmd + 1, offset);
170 return spi_flash_read_common(flash, cmd, sizeof(cmd), buf, len);
174 * TODO: the two write funcs (_p2/_at45) should get unified ...
176 static int dataflash_write_p2(struct spi_flash *flash,
177 u32 offset, size_t len, const void *buf)
179 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
180 unsigned long page_size;
188 * TODO: This function currently uses only page buffer #1. We can
189 * speed this up by using both buffers and loading one buffer while
190 * the other is being programmed into main memory.
193 page_size = (1 << asf->params->l2_page_size);
195 ret = spi_claim_bus(flash->spi);
197 debug("SF: Unable to claim SPI bus\n");
201 for (actual = 0; actual < len; actual += chunk_len) {
202 chunk_len = min(len - actual, page_size - (addr % page_size));
204 /* Use the same address bits for both commands */
205 cmd[0] = CMD_AT45_LOAD_BUF1;
210 ret = spi_flash_cmd_write(flash->spi, cmd, 4,
211 buf + actual, chunk_len);
213 debug("SF: Loading AT45 buffer failed\n");
217 cmd[0] = CMD_AT45_PROG_BUF1;
218 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
220 debug("SF: AT45 page programming failed\n");
224 ret = at45_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
226 debug("SF: AT45 page programming timed out\n");
233 debug("SF: AT45: Successfully programmed %zu bytes @ 0x%x\n",
238 spi_release_bus(flash->spi);
242 static int dataflash_write_at45(struct spi_flash *flash,
243 u32 offset, size_t len, const void *buf)
245 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
246 unsigned long page_addr;
247 unsigned long byte_addr;
248 unsigned long page_size;
249 unsigned int page_shift;
256 * TODO: This function currently uses only page buffer #1. We can
257 * speed this up by using both buffers and loading one buffer while
258 * the other is being programmed into main memory.
261 page_shift = asf->params->l2_page_size;
262 page_size = (1 << page_shift) + (1 << (page_shift - 5));
264 page_addr = offset / page_size;
265 byte_addr = offset % page_size;
267 ret = spi_claim_bus(flash->spi);
269 debug("SF: Unable to claim SPI bus\n");
273 for (actual = 0; actual < len; actual += chunk_len) {
274 chunk_len = min(len - actual, page_size - byte_addr);
276 /* Use the same address bits for both commands */
277 cmd[0] = CMD_AT45_LOAD_BUF1;
278 cmd[1] = page_addr >> (16 - page_shift);
279 cmd[2] = page_addr << (page_shift - 8) | (byte_addr >> 8);
282 ret = spi_flash_cmd_write(flash->spi, cmd, 4,
283 buf + actual, chunk_len);
285 debug("SF: Loading AT45 buffer failed\n");
289 cmd[0] = CMD_AT45_PROG_BUF1;
290 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
292 debug("SF: AT45 page programming failed\n");
296 ret = at45_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
298 debug("SF: AT45 page programming timed out\n");
306 debug("SF: AT45: Successfully programmed %zu bytes @ 0x%x\n",
311 spi_release_bus(flash->spi);
316 * TODO: the two erase funcs (_p2/_at45) should get unified ...
318 int dataflash_erase_p2(struct spi_flash *flash, u32 offset, size_t len)
320 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
321 unsigned long page_size;
328 * TODO: This function currently uses page erase only. We can
329 * probably speed things up by using block and/or sector erase
333 page_size = (1 << asf->params->l2_page_size);
335 if (offset % page_size || len % page_size) {
336 debug("SF: Erase offset/length not multiple of page size\n");
340 cmd[0] = CMD_AT45_ERASE_PAGE;
343 ret = spi_claim_bus(flash->spi);
345 debug("SF: Unable to claim SPI bus\n");
349 for (actual = 0; actual < len; actual += page_size) {
350 cmd[1] = offset >> 16;
351 cmd[2] = offset >> 8;
353 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
355 debug("SF: AT45 page erase failed\n");
359 ret = at45_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT);
361 debug("SF: AT45 page erase timed out\n");
368 debug("SF: AT45: Successfully erased %zu bytes @ 0x%x\n",
373 spi_release_bus(flash->spi);
377 int dataflash_erase_at45(struct spi_flash *flash, u32 offset, size_t len)
379 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
380 unsigned long page_addr;
381 unsigned long page_size;
382 unsigned int page_shift;
388 * TODO: This function currently uses page erase only. We can
389 * probably speed things up by using block and/or sector erase
393 page_shift = asf->params->l2_page_size;
394 page_size = (1 << page_shift) + (1 << (page_shift - 5));
396 page_addr = offset / page_size;
398 if (offset % page_size || len % page_size) {
399 debug("SF: Erase offset/length not multiple of page size\n");
403 cmd[0] = CMD_AT45_ERASE_PAGE;
406 ret = spi_claim_bus(flash->spi);
408 debug("SF: Unable to claim SPI bus\n");
412 for (actual = 0; actual < len; actual += page_size) {
413 cmd[1] = page_addr >> (16 - page_shift);
414 cmd[2] = page_addr << (page_shift - 8);
416 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
418 debug("SF: AT45 page erase failed\n");
422 ret = at45_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT);
424 debug("SF: AT45 page erase timed out\n");
431 debug("SF: AT45: Successfully erased %zu bytes @ 0x%x\n",
436 spi_release_bus(flash->spi);
440 struct spi_flash *spi_flash_probe_atmel(struct spi_slave *spi, u8 *idcode)
442 const struct atmel_spi_flash_params *params;
445 struct atmel_spi_flash *asf;
450 for (i = 0; i < ARRAY_SIZE(atmel_spi_flash_table); i++) {
451 params = &atmel_spi_flash_table[i];
452 if (params->idcode1 == idcode[1])
456 if (i == ARRAY_SIZE(atmel_spi_flash_table)) {
457 debug("SF: Unsupported DataFlash ID %02x\n",
462 asf = malloc(sizeof(struct atmel_spi_flash));
464 debug("SF: Failed to allocate memory\n");
468 asf->params = params;
469 asf->flash.spi = spi;
470 asf->flash.name = params->name;
472 /* Assuming power-of-two page size initially. */
473 page_size = 1 << params->l2_page_size;
475 family = idcode[1] >> 5;
480 * AT45 chips have configurable page size. The status
481 * register indicates which configuration is active.
483 ret = spi_flash_cmd(spi, CMD_AT45_READ_STATUS, &status, 1);
487 debug("SF: AT45 status register: %02x\n", status);
489 if (!(status & AT45_STATUS_P2_PAGE_SIZE)) {
490 asf->flash.read = dataflash_read_fast_at45;
491 asf->flash.write = dataflash_write_at45;
492 asf->flash.erase = dataflash_erase_at45;
493 page_size += 1 << (params->l2_page_size - 5);
495 asf->flash.read = dataflash_read_fast_p2;
496 asf->flash.write = dataflash_write_p2;
497 asf->flash.erase = dataflash_erase_p2;
502 case DF_FAMILY_AT26F:
503 case DF_FAMILY_AT26DF:
504 asf->flash.read = dataflash_read_fast_p2;
508 debug("SF: Unsupported DataFlash family %u\n", family);
512 asf->flash.size = page_size * params->pages_per_block
513 * params->blocks_per_sector
514 * params->nr_sectors;
516 printf("SF: Detected %s with page size %u, total ",
517 params->name, page_size);
518 print_size(asf->flash.size, "\n");