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_at45(struct spi_flash *flash,
147 u32 offset, size_t len, void *buf)
149 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
152 cmd[0] = CMD_READ_ARRAY_FAST;
153 at45_build_address(asf, cmd + 1, offset);
156 return spi_flash_read_common(flash, cmd, sizeof(cmd), buf, len);
160 * TODO: the two write funcs (_p2/_at45) should get unified ...
162 static int dataflash_write_p2(struct spi_flash *flash,
163 u32 offset, size_t len, const void *buf)
165 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
166 unsigned long page_size;
174 * TODO: This function currently uses only page buffer #1. We can
175 * speed this up by using both buffers and loading one buffer while
176 * the other is being programmed into main memory.
179 page_size = (1 << asf->params->l2_page_size);
181 ret = spi_claim_bus(flash->spi);
183 debug("SF: Unable to claim SPI bus\n");
187 for (actual = 0; actual < len; actual += chunk_len) {
188 chunk_len = min(len - actual, page_size - (addr % page_size));
190 /* Use the same address bits for both commands */
191 cmd[0] = CMD_AT45_LOAD_BUF1;
196 ret = spi_flash_cmd_write(flash->spi, cmd, 4,
197 buf + actual, chunk_len);
199 debug("SF: Loading AT45 buffer failed\n");
203 cmd[0] = CMD_AT45_PROG_BUF1;
204 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
206 debug("SF: AT45 page programming failed\n");
210 ret = at45_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
212 debug("SF: AT45 page programming timed out\n");
219 debug("SF: AT45: Successfully programmed %zu bytes @ 0x%x\n",
224 spi_release_bus(flash->spi);
228 static int dataflash_write_at45(struct spi_flash *flash,
229 u32 offset, size_t len, const void *buf)
231 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
232 unsigned long page_addr;
233 unsigned long byte_addr;
234 unsigned long page_size;
235 unsigned int page_shift;
242 * TODO: This function currently uses only page buffer #1. We can
243 * speed this up by using both buffers and loading one buffer while
244 * the other is being programmed into main memory.
247 page_shift = asf->params->l2_page_size;
248 page_size = (1 << page_shift) + (1 << (page_shift - 5));
250 page_addr = offset / page_size;
251 byte_addr = offset % page_size;
253 ret = spi_claim_bus(flash->spi);
255 debug("SF: Unable to claim SPI bus\n");
259 for (actual = 0; actual < len; actual += chunk_len) {
260 chunk_len = min(len - actual, page_size - byte_addr);
262 /* Use the same address bits for both commands */
263 cmd[0] = CMD_AT45_LOAD_BUF1;
264 cmd[1] = page_addr >> (16 - page_shift);
265 cmd[2] = page_addr << (page_shift - 8) | (byte_addr >> 8);
268 ret = spi_flash_cmd_write(flash->spi, cmd, 4,
269 buf + actual, chunk_len);
271 debug("SF: Loading AT45 buffer failed\n");
275 cmd[0] = CMD_AT45_PROG_BUF1;
276 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
278 debug("SF: AT45 page programming failed\n");
282 ret = at45_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
284 debug("SF: AT45 page programming timed out\n");
292 debug("SF: AT45: Successfully programmed %zu bytes @ 0x%x\n",
297 spi_release_bus(flash->spi);
302 * TODO: the two erase funcs (_p2/_at45) should get unified ...
304 int dataflash_erase_p2(struct spi_flash *flash, u32 offset, size_t len)
306 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
307 unsigned long page_size;
314 * TODO: This function currently uses page erase only. We can
315 * probably speed things up by using block and/or sector erase
319 page_size = (1 << asf->params->l2_page_size);
321 if (offset % page_size || len % page_size) {
322 debug("SF: Erase offset/length not multiple of page size\n");
326 cmd[0] = CMD_AT45_ERASE_PAGE;
329 ret = spi_claim_bus(flash->spi);
331 debug("SF: Unable to claim SPI bus\n");
335 for (actual = 0; actual < len; actual += page_size) {
336 cmd[1] = offset >> 16;
337 cmd[2] = offset >> 8;
339 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
341 debug("SF: AT45 page erase failed\n");
345 ret = at45_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT);
347 debug("SF: AT45 page erase timed out\n");
354 debug("SF: AT45: Successfully erased %zu bytes @ 0x%x\n",
359 spi_release_bus(flash->spi);
363 int dataflash_erase_at45(struct spi_flash *flash, u32 offset, size_t len)
365 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
366 unsigned long page_addr;
367 unsigned long page_size;
368 unsigned int page_shift;
374 * TODO: This function currently uses page erase only. We can
375 * probably speed things up by using block and/or sector erase
379 page_shift = asf->params->l2_page_size;
380 page_size = (1 << page_shift) + (1 << (page_shift - 5));
382 page_addr = offset / page_size;
384 if (offset % page_size || len % page_size) {
385 debug("SF: Erase offset/length not multiple of page size\n");
389 cmd[0] = CMD_AT45_ERASE_PAGE;
392 ret = spi_claim_bus(flash->spi);
394 debug("SF: Unable to claim SPI bus\n");
398 for (actual = 0; actual < len; actual += page_size) {
399 cmd[1] = page_addr >> (16 - page_shift);
400 cmd[2] = page_addr << (page_shift - 8);
402 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
404 debug("SF: AT45 page erase failed\n");
408 ret = at45_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT);
410 debug("SF: AT45 page erase timed out\n");
417 debug("SF: AT45: Successfully erased %zu bytes @ 0x%x\n",
422 spi_release_bus(flash->spi);
426 struct spi_flash *spi_flash_probe_atmel(struct spi_slave *spi, u8 *idcode)
428 const struct atmel_spi_flash_params *params;
431 struct atmel_spi_flash *asf;
436 for (i = 0; i < ARRAY_SIZE(atmel_spi_flash_table); i++) {
437 params = &atmel_spi_flash_table[i];
438 if (params->idcode1 == idcode[1])
442 if (i == ARRAY_SIZE(atmel_spi_flash_table)) {
443 debug("SF: Unsupported DataFlash ID %02x\n",
448 asf = malloc(sizeof(struct atmel_spi_flash));
450 debug("SF: Failed to allocate memory\n");
454 asf->params = params;
455 asf->flash.spi = spi;
456 asf->flash.name = params->name;
458 /* Assuming power-of-two page size initially. */
459 page_size = 1 << params->l2_page_size;
461 family = idcode[1] >> 5;
466 * AT45 chips have configurable page size. The status
467 * register indicates which configuration is active.
469 ret = spi_flash_cmd(spi, CMD_AT45_READ_STATUS, &status, 1);
473 debug("SF: AT45 status register: %02x\n", status);
475 if (!(status & AT45_STATUS_P2_PAGE_SIZE)) {
476 asf->flash.read = dataflash_read_fast_at45;
477 asf->flash.write = dataflash_write_at45;
478 asf->flash.erase = dataflash_erase_at45;
479 page_size += 1 << (params->l2_page_size - 5);
481 asf->flash.read = spi_flash_cmd_read_fast;
482 asf->flash.write = dataflash_write_p2;
483 asf->flash.erase = dataflash_erase_p2;
488 case DF_FAMILY_AT26F:
489 case DF_FAMILY_AT26DF:
490 asf->flash.read = spi_flash_cmd_read_fast;
494 debug("SF: Unsupported DataFlash family %u\n", family);
498 asf->flash.size = page_size * params->pages_per_block
499 * params->blocks_per_sector
500 * params->nr_sectors;
502 printf("SF: Detected %s with page size %u, total ",
503 params->name, page_size);
504 print_size(asf->flash.size, "\n");