1 /*
2 * Atmel SPI DataFlash support
3 *
4 * Copyright (C) 2008 Atmel Corporation
5 * Licensed under the GPL-2 or later.
6 */
7
8 #include <common.h>
9 #include <malloc.h>
10 #include <spi_flash.h>
11
12 #include "spi_flash_internal.h"
13
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
23
24 /* AT45 status register bits */
25 #define AT45_STATUS_P2_PAGE_SIZE (1 << 0)
26 #define AT45_STATUS_READY (1 << 7)
27
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 */
32
33 struct atmel_spi_flash_params {
34 u8 idcode1;
35 /* Log2 of page size in power-of-two mode */
36 u8 l2_page_size;
37 u8 pages_per_block;
38 u8 blocks_per_sector;
39 u8 nr_sectors;
40 const char *name;
41 };
42
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;
47 };
48
49 static inline struct atmel_spi_flash *
to_atmel_spi_flash(struct spi_flash * flash)50 to_atmel_spi_flash(struct spi_flash *flash)
51 {
52 return container_of(flash, struct atmel_spi_flash, flash);
53 }
54
55 static const struct atmel_spi_flash_params atmel_spi_flash_table[] = {
56 {
57 .idcode1 = 0x22,
58 .l2_page_size = 8,
59 .pages_per_block = 8,
60 .blocks_per_sector = 16,
61 .nr_sectors = 4,
62 .name = "AT45DB011D",
63 },
64 {
65 .idcode1 = 0x23,
66 .l2_page_size = 8,
67 .pages_per_block = 8,
68 .blocks_per_sector = 16,
69 .nr_sectors = 8,
70 .name = "AT45DB021D",
71 },
72 {
73 .idcode1 = 0x24,
74 .l2_page_size = 8,
75 .pages_per_block = 8,
76 .blocks_per_sector = 32,
77 .nr_sectors = 8,
78 .name = "AT45DB041D",
79 },
80 {
81 .idcode1 = 0x25,
82 .l2_page_size = 8,
83 .pages_per_block = 8,
84 .blocks_per_sector = 32,
85 .nr_sectors = 16,
86 .name = "AT45DB081D",
87 },
88 {
89 .idcode1 = 0x26,
90 .l2_page_size = 9,
91 .pages_per_block = 8,
92 .blocks_per_sector = 32,
93 .nr_sectors = 16,
94 .name = "AT45DB161D",
95 },
96 {
97 .idcode1 = 0x27,
98 .l2_page_size = 9,
99 .pages_per_block = 8,
100 .blocks_per_sector = 64,
101 .nr_sectors = 64,
102 .name = "AT45DB321D",
103 },
104 {
105 .idcode1 = 0x28,
106 .l2_page_size = 10,
107 .pages_per_block = 8,
108 .blocks_per_sector = 32,
109 .nr_sectors = 32,
110 .name = "AT45DB642D",
111 },
112 };
113
at45_wait_ready(struct spi_flash * flash,unsigned long timeout)114 static int at45_wait_ready(struct spi_flash *flash, unsigned long timeout)
115 {
116 struct spi_slave *spi = flash->spi;
117 unsigned long timebase;
118 int ret;
119 u8 cmd = CMD_AT45_READ_STATUS;
120 u8 status;
121
122 timebase = get_timer(0);
123
124 ret = spi_xfer(spi, 8, &cmd, NULL, SPI_XFER_BEGIN);
125 if (ret)
126 return -1;
127
128 do {
129 ret = spi_xfer(spi, 8, NULL, &status, 0);
130 if (ret)
131 return -1;
132
133 if (status & AT45_STATUS_READY)
134 break;
135 } while (get_timer(timebase) < timeout);
136
137 /* Deactivate CS */
138 spi_xfer(spi, 0, NULL, NULL, SPI_XFER_END);
139
140 if (status & AT45_STATUS_READY)
141 return 0;
142
143 /* Timed out */
144 return -1;
145 }
146
147 /*
148 * Assemble the address part of a command for AT45 devices in
149 * non-power-of-two page size mode.
150 */
at45_build_address(struct atmel_spi_flash * asf,u8 * cmd,u32 offset)151 static void at45_build_address(struct atmel_spi_flash *asf, u8 *cmd, u32 offset)
152 {
153 unsigned long page_addr;
154 unsigned long byte_addr;
155 unsigned long page_size;
156 unsigned int page_shift;
157
158 /*
159 * The "extra" space per page is the power-of-two page size
160 * divided by 32.
161 */
162 page_shift = asf->params->l2_page_size;
163 page_size = (1 << page_shift) + (1 << (page_shift - 5));
164 page_shift++;
165 page_addr = offset / page_size;
166 byte_addr = offset % page_size;
167
168 cmd[0] = page_addr >> (16 - page_shift);
169 cmd[1] = page_addr << (page_shift - 8) | (byte_addr >> 8);
170 cmd[2] = byte_addr;
171 }
172
dataflash_read_fast_p2(struct spi_flash * flash,u32 offset,size_t len,void * buf)173 static int dataflash_read_fast_p2(struct spi_flash *flash,
174 u32 offset, size_t len, void *buf)
175 {
176 u8 cmd[5];
177
178 cmd[0] = CMD_READ_ARRAY_FAST;
179 cmd[1] = offset >> 16;
180 cmd[2] = offset >> 8;
181 cmd[3] = offset;
182 cmd[4] = 0x00;
183
184 return spi_flash_read_common(flash, cmd, sizeof(cmd), buf, len);
185 }
186
dataflash_read_fast_at45(struct spi_flash * flash,u32 offset,size_t len,void * buf)187 static int dataflash_read_fast_at45(struct spi_flash *flash,
188 u32 offset, size_t len, void *buf)
189 {
190 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
191 u8 cmd[5];
192
193 cmd[0] = CMD_READ_ARRAY_FAST;
194 at45_build_address(asf, cmd + 1, offset);
195 cmd[4] = 0x00;
196
197 return spi_flash_read_common(flash, cmd, sizeof(cmd), buf, len);
198 }
199
200 /*
201 * TODO: the two write funcs (_p2/_at45) should get unified ...
202 */
dataflash_write_p2(struct spi_flash * flash,u32 offset,size_t len,const void * buf)203 static int dataflash_write_p2(struct spi_flash *flash,
204 u32 offset, size_t len, const void *buf)
205 {
206 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
207 unsigned long page_size;
208 u32 addr = offset;
209 size_t chunk_len;
210 size_t actual;
211 int ret;
212 u8 cmd[4];
213
214 /*
215 * TODO: This function currently uses only page buffer #1. We can
216 * speed this up by using both buffers and loading one buffer while
217 * the other is being programmed into main memory.
218 */
219
220 page_size = (1 << asf->params->l2_page_size);
221
222 ret = spi_claim_bus(flash->spi);
223 if (ret) {
224 debug("SF: Unable to claim SPI bus\n");
225 return ret;
226 }
227
228 for (actual = 0; actual < len; actual += chunk_len) {
229 chunk_len = min(len - actual, page_size - (addr % page_size));
230
231 /* Use the same address bits for both commands */
232 cmd[0] = CMD_AT45_LOAD_BUF1;
233 cmd[1] = addr >> 16;
234 cmd[2] = addr >> 8;
235 cmd[3] = addr;
236
237 ret = spi_flash_cmd_write(flash->spi, cmd, 4,
238 buf + actual, chunk_len);
239 if (ret < 0) {
240 debug("SF: Loading AT45 buffer failed\n");
241 goto out;
242 }
243
244 cmd[0] = CMD_AT45_PROG_BUF1;
245 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
246 if (ret < 0) {
247 debug("SF: AT45 page programming failed\n");
248 goto out;
249 }
250
251 ret = at45_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
252 if (ret < 0) {
253 debug("SF: AT45 page programming timed out\n");
254 goto out;
255 }
256
257 addr += chunk_len;
258 }
259
260 debug("SF: AT45: Successfully programmed %zu bytes @ 0x%x\n",
261 len, offset);
262 ret = 0;
263
264 out:
265 spi_release_bus(flash->spi);
266 return ret;
267 }
268
dataflash_write_at45(struct spi_flash * flash,u32 offset,size_t len,const void * buf)269 static int dataflash_write_at45(struct spi_flash *flash,
270 u32 offset, size_t len, const void *buf)
271 {
272 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
273 unsigned long page_addr;
274 unsigned long byte_addr;
275 unsigned long page_size;
276 unsigned int page_shift;
277 size_t chunk_len;
278 size_t actual;
279 int ret;
280 u8 cmd[4];
281
282 /*
283 * TODO: This function currently uses only page buffer #1. We can
284 * speed this up by using both buffers and loading one buffer while
285 * the other is being programmed into main memory.
286 */
287
288 page_shift = asf->params->l2_page_size;
289 page_size = (1 << page_shift) + (1 << (page_shift - 5));
290 page_shift++;
291 page_addr = offset / page_size;
292 byte_addr = offset % page_size;
293
294 ret = spi_claim_bus(flash->spi);
295 if (ret) {
296 debug("SF: Unable to claim SPI bus\n");
297 return ret;
298 }
299
300 for (actual = 0; actual < len; actual += chunk_len) {
301 chunk_len = min(len - actual, page_size - byte_addr);
302
303 /* Use the same address bits for both commands */
304 cmd[0] = CMD_AT45_LOAD_BUF1;
305 cmd[1] = page_addr >> (16 - page_shift);
306 cmd[2] = page_addr << (page_shift - 8) | (byte_addr >> 8);
307 cmd[3] = byte_addr;
308
309 ret = spi_flash_cmd_write(flash->spi, cmd, 4,
310 buf + actual, chunk_len);
311 if (ret < 0) {
312 debug("SF: Loading AT45 buffer failed\n");
313 goto out;
314 }
315
316 cmd[0] = CMD_AT45_PROG_BUF1;
317 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
318 if (ret < 0) {
319 debug("SF: AT45 page programming failed\n");
320 goto out;
321 }
322
323 ret = at45_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT);
324 if (ret < 0) {
325 debug("SF: AT45 page programming timed out\n");
326 goto out;
327 }
328
329 page_addr++;
330 byte_addr = 0;
331 }
332
333 debug("SF: AT45: Successfully programmed %zu bytes @ 0x%x\n",
334 len, offset);
335 ret = 0;
336
337 out:
338 spi_release_bus(flash->spi);
339 return ret;
340 }
341
342 /*
343 * TODO: the two erase funcs (_p2/_at45) should get unified ...
344 */
dataflash_erase_p2(struct spi_flash * flash,u32 offset,size_t len)345 int dataflash_erase_p2(struct spi_flash *flash, u32 offset, size_t len)
346 {
347 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
348 unsigned long page_size;
349
350 size_t actual;
351 int ret;
352 u8 cmd[4];
353
354 /*
355 * TODO: This function currently uses page erase only. We can
356 * probably speed things up by using block and/or sector erase
357 * when possible.
358 */
359
360 page_size = (1 << asf->params->l2_page_size);
361
362 if (offset % page_size || len % page_size) {
363 debug("SF: Erase offset/length not multiple of page size\n");
364 return -1;
365 }
366
367 cmd[0] = CMD_AT45_ERASE_PAGE;
368 cmd[3] = 0x00;
369
370 ret = spi_claim_bus(flash->spi);
371 if (ret) {
372 debug("SF: Unable to claim SPI bus\n");
373 return ret;
374 }
375
376 for (actual = 0; actual < len; actual += page_size) {
377 cmd[1] = offset >> 16;
378 cmd[2] = offset >> 8;
379
380 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
381 if (ret < 0) {
382 debug("SF: AT45 page erase failed\n");
383 goto out;
384 }
385
386 ret = at45_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT);
387 if (ret < 0) {
388 debug("SF: AT45 page erase timed out\n");
389 goto out;
390 }
391
392 offset += page_size;
393 }
394
395 debug("SF: AT45: Successfully erased %zu bytes @ 0x%x\n",
396 len, offset);
397 ret = 0;
398
399 out:
400 spi_release_bus(flash->spi);
401 return ret;
402 }
403
dataflash_erase_at45(struct spi_flash * flash,u32 offset,size_t len)404 int dataflash_erase_at45(struct spi_flash *flash, u32 offset, size_t len)
405 {
406 struct atmel_spi_flash *asf = to_atmel_spi_flash(flash);
407 unsigned long page_addr;
408 unsigned long page_size;
409 unsigned int page_shift;
410 size_t actual;
411 int ret;
412 u8 cmd[4];
413
414 /*
415 * TODO: This function currently uses page erase only. We can
416 * probably speed things up by using block and/or sector erase
417 * when possible.
418 */
419
420 page_shift = asf->params->l2_page_size;
421 page_size = (1 << page_shift) + (1 << (page_shift - 5));
422 page_shift++;
423 page_addr = offset / page_size;
424
425 if (offset % page_size || len % page_size) {
426 debug("SF: Erase offset/length not multiple of page size\n");
427 return -1;
428 }
429
430 cmd[0] = CMD_AT45_ERASE_PAGE;
431 cmd[3] = 0x00;
432
433 ret = spi_claim_bus(flash->spi);
434 if (ret) {
435 debug("SF: Unable to claim SPI bus\n");
436 return ret;
437 }
438
439 for (actual = 0; actual < len; actual += page_size) {
440 cmd[1] = page_addr >> (16 - page_shift);
441 cmd[2] = page_addr << (page_shift - 8);
442
443 ret = spi_flash_cmd_write(flash->spi, cmd, 4, NULL, 0);
444 if (ret < 0) {
445 debug("SF: AT45 page erase failed\n");
446 goto out;
447 }
448
449 ret = at45_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT);
450 if (ret < 0) {
451 debug("SF: AT45 page erase timed out\n");
452 goto out;
453 }
454
455 page_addr++;
456 }
457
458 debug("SF: AT45: Successfully erased %zu bytes @ 0x%x\n",
459 len, offset);
460 ret = 0;
461
462 out:
463 spi_release_bus(flash->spi);
464 return ret;
465 }
466
spi_flash_probe_atmel(struct spi_slave * spi,u8 * idcode)467 struct spi_flash *spi_flash_probe_atmel(struct spi_slave *spi, u8 *idcode)
468 {
469 const struct atmel_spi_flash_params *params;
470 unsigned long page_size;
471 unsigned int family;
472 struct atmel_spi_flash *asf;
473 unsigned int i;
474 int ret;
475 u8 status;
476
477 for (i = 0; i < ARRAY_SIZE(atmel_spi_flash_table); i++) {
478 params = &atmel_spi_flash_table[i];
479 if (params->idcode1 == idcode[1])
480 break;
481 }
482
483 if (i == ARRAY_SIZE(atmel_spi_flash_table)) {
484 debug("SF: Unsupported DataFlash ID %02x\n",
485 idcode[1]);
486 return NULL;
487 }
488
489 asf = malloc(sizeof(struct atmel_spi_flash));
490 if (!asf) {
491 debug("SF: Failed to allocate memory\n");
492 return NULL;
493 }
494
495 asf->params = params;
496 asf->flash.spi = spi;
497 asf->flash.name = params->name;
498
499 /* Assuming power-of-two page size initially. */
500 page_size = 1 << params->l2_page_size;
501
502 family = idcode[1] >> 5;
503
504 switch (family) {
505 case DF_FAMILY_AT45:
506 /*
507 * AT45 chips have configurable page size. The status
508 * register indicates which configuration is active.
509 */
510 ret = spi_flash_cmd(spi, CMD_AT45_READ_STATUS, &status, 1);
511 if (ret)
512 goto err;
513
514 debug("SF: AT45 status register: %02x\n", status);
515
516 if (!(status & AT45_STATUS_P2_PAGE_SIZE)) {
517 asf->flash.read = dataflash_read_fast_at45;
518 asf->flash.write = dataflash_write_at45;
519 asf->flash.erase = dataflash_erase_at45;
520 page_size += 1 << (params->l2_page_size - 5);
521 } else {
522 asf->flash.read = dataflash_read_fast_p2;
523 asf->flash.write = dataflash_write_p2;
524 asf->flash.erase = dataflash_erase_p2;
525 }
526
527 break;
528
529 case DF_FAMILY_AT26F:
530 case DF_FAMILY_AT26DF:
531 asf->flash.read = dataflash_read_fast_p2;
532 break;
533
534 default:
535 debug("SF: Unsupported DataFlash family %u\n", family);
536 goto err;
537 }
538
539 asf->flash.size = page_size * params->pages_per_block
540 * params->blocks_per_sector
541 * params->nr_sectors;
542
543 debug("SF: Detected %s with page size %lu, total %u bytes\n",
544 params->name, page_size, asf->flash.size);
545
546 return &asf->flash;
547
548 err:
549 free(asf);
550 return NULL;
551 }
552