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 struct spi_slave *spi = flash->spi;
117 unsigned long timebase;
119 u8 cmd = CMD_AT45_READ_STATUS;
122 timebase = get_timer(0);
124 ret = spi_xfer(spi, 8, &cmd, NULL, SPI_XFER_BEGIN);
129 ret = spi_xfer(spi, 8, NULL, &status, 0);
133 if (status & AT45_STATUS_READY)
135 } while (get_timer(timebase) < timeout);
138 spi_xfer(spi, 0, NULL, NULL, SPI_XFER_END);
140 if (status & AT45_STATUS_READY)
148 * Assemble the address part of a command for AT45 devices in
149 * non-power-of-two page size mode.
151 static void at45_build_address(struct atmel_spi_flash *asf, u8 *cmd, u32 offset)
153 unsigned long page_addr;
154 unsigned long byte_addr;
155 unsigned long page_size;
156 unsigned int page_shift;
159 * The "extra" space per page is the power-of-two page size
162 page_shift = asf->params->l2_page_size;
163 page_size = (1 << page_shift) + (1 << (page_shift - 5));
165 page_addr = offset / page_size;
166 byte_addr = offset % page_size;
168 cmd[0] = page_addr >> (16 - page_shift);
169 cmd[1] = page_addr << (page_shift - 8) | (byte_addr >> 8);
173 static int dataflash_read_fast_at45(struct spi_flash *flash,
174 u32 offset, size_t len, void *buf)
176 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
179 cmd[0] = CMD_READ_ARRAY_FAST;
180 at45_build_address(asf, cmd + 1, offset);
183 return spi_flash_read_common(flash, cmd, sizeof(cmd), buf, len);
187 * TODO: the two write funcs (_p2/_at45) should get unified ...
189 static int dataflash_write_p2(struct spi_flash *flash,
190 u32 offset, size_t len, const void *buf)
192 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
193 unsigned long page_size;
201 * TODO: This function currently uses only page buffer #1. We can
202 * speed this up by using both buffers and loading one buffer while
203 * the other is being programmed into main memory.
206 page_size = (1 << asf->params->l2_page_size);
208 ret = spi_claim_bus(flash->spi);
210 debug("SF: Unable to claim SPI bus\n");
214 for (actual = 0; actual < len; actual += chunk_len) {
215 chunk_len = min(len - actual, page_size - (addr % page_size));
217 /* Use the same address bits for both commands */
218 cmd[0] = CMD_AT45_LOAD_BUF1;
223 ret = spi_flash_cmd_write(flash->spi, cmd, 4,
224 buf + actual, chunk_len);
226 debug("SF: Loading AT45 buffer failed\n");
230 cmd[0] = CMD_AT45_PROG_BUF1;
231 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
233 debug("SF: AT45 page programming failed\n");
237 ret = at45_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
239 debug("SF: AT45 page programming timed out\n");
246 debug("SF: AT45: Successfully programmed %zu bytes @ 0x%x\n",
251 spi_release_bus(flash->spi);
255 static int dataflash_write_at45(struct spi_flash *flash,
256 u32 offset, size_t len, const void *buf)
258 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
259 unsigned long page_addr;
260 unsigned long byte_addr;
261 unsigned long page_size;
262 unsigned int page_shift;
269 * TODO: This function currently uses only page buffer #1. We can
270 * speed this up by using both buffers and loading one buffer while
271 * the other is being programmed into main memory.
274 page_shift = asf->params->l2_page_size;
275 page_size = (1 << page_shift) + (1 << (page_shift - 5));
277 page_addr = offset / page_size;
278 byte_addr = offset % page_size;
280 ret = spi_claim_bus(flash->spi);
282 debug("SF: Unable to claim SPI bus\n");
286 for (actual = 0; actual < len; actual += chunk_len) {
287 chunk_len = min(len - actual, page_size - byte_addr);
289 /* Use the same address bits for both commands */
290 cmd[0] = CMD_AT45_LOAD_BUF1;
291 cmd[1] = page_addr >> (16 - page_shift);
292 cmd[2] = page_addr << (page_shift - 8) | (byte_addr >> 8);
295 ret = spi_flash_cmd_write(flash->spi, cmd, 4,
296 buf + actual, chunk_len);
298 debug("SF: Loading AT45 buffer failed\n");
302 cmd[0] = CMD_AT45_PROG_BUF1;
303 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
305 debug("SF: AT45 page programming failed\n");
309 ret = at45_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
311 debug("SF: AT45 page programming timed out\n");
319 debug("SF: AT45: Successfully programmed %zu bytes @ 0x%x\n",
324 spi_release_bus(flash->spi);
329 * TODO: the two erase funcs (_p2/_at45) should get unified ...
331 static int dataflash_erase_p2(struct spi_flash *flash, u32 offset, size_t len)
333 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
334 unsigned long page_size;
341 * TODO: This function currently uses page erase only. We can
342 * probably speed things up by using block and/or sector erase
346 page_size = (1 << asf->params->l2_page_size);
348 if (offset % page_size || len % page_size) {
349 debug("SF: Erase offset/length not multiple of page size\n");
353 cmd[0] = CMD_AT45_ERASE_PAGE;
356 ret = spi_claim_bus(flash->spi);
358 debug("SF: Unable to claim SPI bus\n");
362 for (actual = 0; actual < len; actual += page_size) {
363 cmd[1] = offset >> 16;
364 cmd[2] = offset >> 8;
366 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
368 debug("SF: AT45 page erase failed\n");
372 ret = at45_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT);
374 debug("SF: AT45 page erase timed out\n");
381 debug("SF: AT45: Successfully erased %zu bytes @ 0x%x\n",
386 spi_release_bus(flash->spi);
390 static int dataflash_erase_at45(struct spi_flash *flash, u32 offset, size_t len)
392 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
393 unsigned long page_addr;
394 unsigned long page_size;
395 unsigned int page_shift;
401 * TODO: This function currently uses page erase only. We can
402 * probably speed things up by using block and/or sector erase
406 page_shift = asf->params->l2_page_size;
407 page_size = (1 << page_shift) + (1 << (page_shift - 5));
409 page_addr = offset / page_size;
411 if (offset % page_size || len % page_size) {
412 debug("SF: Erase offset/length not multiple of page size\n");
416 cmd[0] = CMD_AT45_ERASE_PAGE;
419 ret = spi_claim_bus(flash->spi);
421 debug("SF: Unable to claim SPI bus\n");
425 for (actual = 0; actual < len; actual += page_size) {
426 cmd[1] = page_addr >> (16 - page_shift);
427 cmd[2] = page_addr << (page_shift - 8);
429 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
431 debug("SF: AT45 page erase failed\n");
435 ret = at45_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT);
437 debug("SF: AT45 page erase timed out\n");
444 debug("SF: AT45: Successfully erased %zu bytes @ 0x%x\n",
449 spi_release_bus(flash->spi);
453 struct spi_flash *spi_flash_probe_atmel(struct spi_slave *spi, u8 *idcode)
455 const struct atmel_spi_flash_params *params;
458 struct atmel_spi_flash *asf;
463 for (i = 0; i < ARRAY_SIZE(atmel_spi_flash_table); i++) {
464 params = &atmel_spi_flash_table[i];
465 if (params->idcode1 == idcode[1])
469 if (i == ARRAY_SIZE(atmel_spi_flash_table)) {
470 debug("SF: Unsupported DataFlash ID %02x\n",
475 asf = malloc(sizeof(struct atmel_spi_flash));
477 debug("SF: Failed to allocate memory\n");
481 asf->params = params;
482 asf->flash.spi = spi;
483 asf->flash.name = params->name;
485 /* Assuming power-of-two page size initially. */
486 page_size = 1 << params->l2_page_size;
488 family = idcode[1] >> 5;
493 * AT45 chips have configurable page size. The status
494 * register indicates which configuration is active.
496 ret = spi_flash_cmd(spi, CMD_AT45_READ_STATUS, &status, 1);
500 debug("SF: AT45 status register: %02x\n", status);
502 if (!(status & AT45_STATUS_P2_PAGE_SIZE)) {
503 asf->flash.read = dataflash_read_fast_at45;
504 asf->flash.write = dataflash_write_at45;
505 asf->flash.erase = dataflash_erase_at45;
506 page_size += 1 << (params->l2_page_size - 5);
508 asf->flash.read = spi_flash_cmd_read_fast;
509 asf->flash.write = dataflash_write_p2;
510 asf->flash.erase = dataflash_erase_p2;
515 case DF_FAMILY_AT26F:
516 case DF_FAMILY_AT26DF:
517 asf->flash.read = spi_flash_cmd_read_fast;
521 debug("SF: Unsupported DataFlash family %u\n", family);
525 asf->flash.sector_size = page_size;
526 asf->flash.size = page_size * params->pages_per_block
527 * params->blocks_per_sector
528 * params->nr_sectors;