1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2009 by Michael Sparmann
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
29 #include "nand-target.h"
30 #include <pmu-target.h>
31 #include <mmu-target.h>
36 #define NAND_CMD_READ 0x00
37 #define NAND_CMD_PROGCNFRM 0x10
38 #define NAND_CMD_READ2 0x30
39 #define NAND_CMD_BLOCKERASE 0x60
40 #define NAND_CMD_GET_STATUS 0x70
41 #define NAND_CMD_PROGRAM 0x80
42 #define NAND_CMD_ERASECNFRM 0xD0
43 #define NAND_CMD_RESET 0xFF
45 #define NAND_STATUS_READY 0x40
47 #define NAND_DEVICEINFOTABLE_ENTRIES 33
49 static const struct nand_device_info_type nand_deviceinfotable
[] =
51 {0x1580F1EC, 1024, 968, 0x40, 6, 2, 1, 2, 1},
52 {0x1580DAEC, 2048, 1936, 0x40, 6, 2, 1, 2, 1},
53 {0x15C1DAEC, 2048, 1936, 0x40, 6, 2, 1, 2, 1},
54 {0x1510DCEC, 4096, 3872, 0x40, 6, 2, 1, 2, 1},
55 {0x95C1DCEC, 4096, 3872, 0x40, 6, 2, 1, 2, 1},
56 {0x2514DCEC, 2048, 1936, 0x80, 7, 2, 1, 2, 1},
57 {0x2514D3EC, 4096, 3872, 0x80, 7, 2, 1, 2, 1},
58 {0x2555D3EC, 4096, 3872, 0x80, 7, 2, 1, 2, 1},
59 {0x2555D5EC, 8192, 7744, 0x80, 7, 2, 1, 2, 1},
60 {0x2585D3AD, 4096, 3872, 0x80, 7, 3, 2, 3, 2},
61 {0x9580DCAD, 4096, 3872, 0x40, 6, 3, 2, 3, 2},
62 {0xA514D3AD, 4096, 3872, 0x80, 7, 3, 2, 3, 2},
63 {0xA550D3AD, 4096, 3872, 0x80, 7, 3, 2, 3, 2},
64 {0xA560D5AD, 4096, 3872, 0x80, 7, 3, 2, 3, 2},
65 {0xA555D5AD, 8192, 7744, 0x80, 7, 3, 2, 3, 2},
66 {0xA585D598, 8320, 7744, 0x80, 7, 3, 1, 2, 1},
67 {0xA584D398, 4160, 3872, 0x80, 7, 3, 1, 2, 1},
68 {0x95D1D32C, 8192, 7744, 0x40, 6, 2, 1, 2, 1},
69 {0x1580DC2C, 4096, 3872, 0x40, 6, 2, 1, 2, 1},
70 {0x15C1D32C, 8192, 7744, 0x40, 6, 2, 1, 2, 1},
71 {0x9590DC2C, 4096, 3872, 0x40, 6, 2, 1, 2, 1},
72 {0xA594D32C, 4096, 3872, 0x80, 7, 2, 1, 2, 1},
73 {0x2584DC2C, 2048, 1936, 0x80, 7, 2, 1, 2, 1},
74 {0xA5D5D52C, 8192, 7744, 0x80, 7, 3, 2, 2, 1},
75 {0x95D1D389, 8192, 7744, 0x40, 6, 2, 1, 2, 1},
76 {0x1580DC89, 4096, 3872, 0x40, 6, 2, 1, 2, 1},
77 {0x15C1D389, 8192, 7744, 0x40, 6, 2, 1, 2, 1},
78 {0x9590DC89, 4096, 3872, 0x40, 6, 2, 1, 2, 1},
79 {0xA594D389, 4096, 3872, 0x80, 7, 2, 1, 2, 1},
80 {0x2584DC89, 2048, 1936, 0x80, 7, 2, 1, 2, 1},
81 {0xA5D5D589, 8192, 7744, 0x80, 7, 2, 1, 2, 1},
82 {0xA514D320, 4096, 3872, 0x80, 7, 2, 1, 2, 1},
83 {0xA555D520, 8192, 3872, 0x80, 7, 2, 1, 2, 1}
86 uint8_t nand_tunk1
[4];
88 uint8_t nand_tunk2
[4];
89 uint8_t nand_tunk3
[4];
90 uint32_t nand_type
[4];
92 long nand_last_activity_value
= -1;
93 static long nand_stack
[32];
95 static struct mutex nand_mtx
;
96 static struct wakeup nand_wakeup
;
97 static struct mutex ecc_mtx
;
98 static struct wakeup ecc_wakeup
;
100 static uint8_t nand_data
[0x800] __attribute__((aligned(16)));
101 static uint8_t nand_ctrl
[0x200] __attribute__((aligned(16)));
102 static uint8_t nand_spare
[0x40] __attribute__((aligned(16)));
103 static uint8_t nand_ecc
[0x30] __attribute__((aligned(16)));
106 uint32_t nand_unlock(uint32_t rc
)
109 nand_last_activity_value
= current_tick
;
110 mutex_unlock(&nand_mtx
);
114 uint32_t ecc_unlock(uint32_t rc
)
116 mutex_unlock(&ecc_mtx
);
120 uint32_t nand_timeout(long timeout
)
122 if (TIME_AFTER(current_tick
, timeout
)) return 1;
130 uint32_t nand_wait_rbbdone(void)
132 long timeout
= current_tick
+ HZ
/ 50;
133 while (!(FMCSTAT
& FMCSTAT_RBBDONE
))
134 if (nand_timeout(timeout
)) return 1;
135 FMCSTAT
= FMCSTAT_RBBDONE
;
139 uint32_t nand_wait_cmddone(void)
141 long timeout
= current_tick
+ HZ
/ 50;
142 while (!(FMCSTAT
& FMCSTAT_CMDDONE
))
143 if (nand_timeout(timeout
)) return 1;
144 FMCSTAT
= FMCSTAT_CMDDONE
;
148 uint32_t nand_wait_addrdone(void)
150 long timeout
= current_tick
+ HZ
/ 50;
151 while (!(FMCSTAT
& FMCSTAT_ADDRDONE
))
152 if (nand_timeout(timeout
)) return 1;
153 FMCSTAT
= FMCSTAT_ADDRDONE
;
157 uint32_t nand_wait_chip_ready(uint32_t bank
)
159 long timeout
= current_tick
+ HZ
/ 50;
160 while (!(FMCSTAT
& (FMCSTAT_BANK0READY
<< bank
)))
161 if (nand_timeout(timeout
)) return 1;
162 FMCSTAT
= (FMCSTAT_BANK0READY
<< bank
);
166 void nand_set_fmctrl0(uint32_t bank
, uint32_t flags
)
168 FMCTRL0
= (nand_tunk1
[bank
] << 16) | (nand_twp
[bank
] << 12)
169 | (1 << 11) | 1 | (1 << (bank
+ 1)) | flags
;
172 uint32_t nand_send_cmd(uint32_t cmd
)
175 return nand_wait_rbbdone();
178 uint32_t nand_send_address(uint32_t page
, uint32_t offset
)
181 FMADDR0
= (page
<< 16) | offset
;
182 FMADDR1
= (page
>> 16) & 0xFF;
183 FMCTRL1
= FMCTRL1_DOTRANSADDR
;
184 return nand_wait_cmddone();
187 uint32_t nand_reset(uint32_t bank
)
189 nand_set_fmctrl0(bank
, 0);
190 if (nand_send_cmd(NAND_CMD_RESET
)) return 1;
191 if (nand_wait_chip_ready(bank
)) return 1;
192 FMCTRL1
= FMCTRL1_CLEARRFIFO
| FMCTRL1_CLEARWFIFO
;
197 uint32_t nand_wait_status_ready(uint32_t bank
)
199 long timeout
= current_tick
+ HZ
/ 50;
200 nand_set_fmctrl0(bank
, 0);
201 if ((FMCSTAT
& (FMCSTAT_BANK0READY
<< bank
)))
202 FMCSTAT
= (FMCSTAT_BANK0READY
<< bank
);
203 FMCTRL1
= FMCTRL1_CLEARRFIFO
;
204 if (nand_send_cmd(NAND_CMD_GET_STATUS
)) return 1;
207 if (nand_timeout(timeout
)) return 1;
209 FMCTRL1
= FMCTRL1_DOREADDATA
;
210 if (nand_wait_addrdone()) return 1;
211 if ((FMFIFO
& NAND_STATUS_READY
)) break;
212 FMCTRL1
= FMCTRL1_CLEARRFIFO
;
214 FMCTRL1
= FMCTRL1_CLEARRFIFO
;
215 return nand_send_cmd(NAND_CMD_READ
);
218 void nand_transfer_data_start(uint32_t bank
, uint32_t direction
,
219 void* buffer
, uint32_t size
)
221 nand_set_fmctrl0(bank
, FMCTRL0_ENABLEDMA
);
223 FMCTRL1
= FMCTRL1_DOREADDATA
<< direction
;
224 DMACON3
= (2 << DMACON_DEVICE_SHIFT
)
225 | (direction
<< DMACON_DIRECTION_SHIFT
)
226 | (2 << DMACON_DATA_SIZE_SHIFT
)
227 | (3 << DMACON_BURST_LEN_SHIFT
);
228 while ((DMAALLST
& DMAALLST_CHAN3_MASK
))
229 DMACOM3
= DMACOM_CLEARBOTHDONE
;
230 DMABASE3
= (uint32_t)buffer
;
231 DMATCNT3
= (size
>> 4) - 1;
236 uint32_t nand_transfer_data_collect(uint32_t direction
)
238 long timeout
= current_tick
+ HZ
/ 50;
239 while ((DMAALLST
& DMAALLST_DMABUSY3
))
240 if (nand_timeout(timeout
)) return 1;
241 if (!direction
) invalidate_dcache();
242 if (nand_wait_addrdone()) return 1;
243 if (!direction
) FMCTRL1
= FMCTRL1_CLEARRFIFO
| FMCTRL1_CLEARWFIFO
;
244 else FMCTRL1
= FMCTRL1_CLEARRFIFO
;
248 uint32_t nand_transfer_data(uint32_t bank
, uint32_t direction
,
249 void* buffer
, uint32_t size
)
251 nand_transfer_data_start(bank
, direction
, buffer
, size
);
252 uint32_t rc
= nand_transfer_data_collect(direction
);
256 void ecc_start(uint32_t size
, void* databuffer
, void* sparebuffer
, uint32_t type
)
258 mutex_lock(&ecc_mtx
);
262 ECC_DATA_PTR
= (uint32_t)databuffer
;
263 ECC_SPARE_PTR
= (uint32_t)sparebuffer
;
268 uint32_t ecc_collect(void)
270 long timeout
= current_tick
+ HZ
/ 50;
271 while (!(SRCPND
& INTMSK_ECC
))
272 if (nand_timeout(timeout
)) return ecc_unlock(1);
276 return ecc_unlock(ECC_RESULT
);
279 uint32_t ecc_decode(uint32_t size
, void* databuffer
, void* sparebuffer
)
281 ecc_start(size
, databuffer
, sparebuffer
, ECCCTRL_STARTDECODING
);
282 uint32_t rc
= ecc_collect();
286 uint32_t ecc_encode(uint32_t size
, void* databuffer
, void* sparebuffer
)
288 ecc_start(size
, databuffer
, sparebuffer
, ECCCTRL_STARTENCODING
);
293 uint32_t nand_check_empty(uint8_t* buffer
)
297 for (i
= 0; i
< 0x40; i
++) if (buffer
[i
] != 0xFF) count
++;
298 if (count
< 2) return 1;
302 uint32_t nand_get_chip_type(uint32_t bank
)
304 mutex_lock(&nand_mtx
);
306 if (nand_reset(bank
)) return nand_unlock(0xFFFFFFFF);
307 if (nand_send_cmd(0x90)) return nand_unlock(0xFFFFFFFF);
310 FMCTRL1
= FMCTRL1_DOTRANSADDR
;
311 if (nand_wait_cmddone()) return nand_unlock(0xFFFFFFFF);
313 FMCTRL1
= FMCTRL1_DOREADDATA
;
314 if (nand_wait_addrdone()) return nand_unlock(0xFFFFFFFF);
316 FMCTRL1
= FMCTRL1_CLEARRFIFO
;
317 return nand_unlock(result
);
320 void nand_set_active(void)
322 nand_last_activity_value
= current_tick
;
325 long nand_last_activity(void)
327 return nand_last_activity_value
;
330 void nand_power_up(void)
333 mutex_lock(&nand_mtx
);
334 nand_last_activity_value
= current_tick
;
343 PCON5
= (PCON5
& ~0xF) | 3;
345 pmu_ldo_set_voltage(4, 0x15);
348 nand_last_activity_value
= current_tick
;
349 for (i
= 0; i
< 4; i
++)
351 if(nand_type
[i
] != 0xFFFFFFFF)
354 panicf("nand_power_up: nand_reset(bank=%d) failed.",(unsigned int)i
);
358 nand_last_activity_value
= current_tick
;
359 mutex_unlock(&nand_mtx
);
362 void nand_power_down(void)
364 if (!nand_powered
) return;
365 mutex_lock(&nand_mtx
);
366 pmu_ldo_power_off(4);
373 PCON5
= (PCON5
& ~0xF) | 1;
378 mutex_unlock(&nand_mtx
);
381 uint32_t nand_read_page(uint32_t bank
, uint32_t page
, void* databuffer
,
382 void* sparebuffer
, uint32_t doecc
,
385 uint8_t* data
= nand_data
;
386 uint8_t* spare
= nand_spare
;
387 if (databuffer
&& !((uint32_t)databuffer
& 0xf))
388 data
= (uint8_t*)databuffer
;
389 if (sparebuffer
&& !((uint32_t)sparebuffer
& 0xf))
390 spare
= (uint8_t*)sparebuffer
;
391 mutex_lock(&nand_mtx
);
392 nand_last_activity_value
= current_tick
;
394 if (!nand_powered
) nand_power_up();
395 uint32_t rc
, eccresult
;
396 nand_set_fmctrl0(bank
, FMCTRL0_ENABLEDMA
);
397 if (nand_send_cmd(NAND_CMD_READ
)) return nand_unlock(1);
398 if (nand_send_address(page
, databuffer
? 0 : 0x800))
399 return nand_unlock(1);
400 if (nand_send_cmd(NAND_CMD_READ2
)) return nand_unlock(1);
401 if (nand_wait_status_ready(bank
)) return nand_unlock(1);
403 if (nand_transfer_data(bank
, 0, data
, 0x800))
404 return nand_unlock(1);
408 if (databuffer
&& data
!= databuffer
) memcpy(databuffer
, data
, 0x800);
411 if (nand_transfer_data(bank
, 0, spare
, 0x40))
412 return nand_unlock(1);
413 if (sparebuffer
&& spare
!= sparebuffer
)
414 memcpy(sparebuffer
, spare
, 0x800);
416 rc
= nand_check_empty((uint8_t*)sparebuffer
) << 1;
418 return nand_unlock(rc
);
420 if (nand_transfer_data(bank
, 0, spare
, 0x40)) return nand_unlock(1);
423 memcpy(nand_ecc
, &spare
[0xC], 0x28);
424 rc
|= (ecc_decode(3, data
, nand_ecc
) & 0xF) << 4;
425 if (data
!= databuffer
) memcpy(databuffer
, data
, 0x800);
427 memset(nand_ctrl
, 0xFF, 0x200);
428 memcpy(nand_ctrl
, spare
, 0xC);
429 memcpy(nand_ecc
, &spare
[0x34], 0xC);
430 eccresult
= ecc_decode(0, nand_ctrl
, nand_ecc
);
431 rc
|= (eccresult
& 0xF) << 8;
434 if (spare
!= sparebuffer
) memcpy(sparebuffer
, spare
, 0x40);
435 if (eccresult
& 1) memset(sparebuffer
, 0xFF, 0xC);
436 else memcpy(sparebuffer
, nand_ctrl
, 0xC);
438 if (checkempty
) rc
|= nand_check_empty(spare
) << 1;
440 return nand_unlock(rc
);
443 uint32_t nand_write_page_int(uint32_t bank
, uint32_t page
, void* databuffer
,
444 void* sparebuffer
, uint32_t doecc
, uint32_t wait
)
446 uint8_t* data
= nand_data
;
447 uint8_t* spare
= nand_spare
;
448 if (databuffer
&& !((uint32_t)databuffer
& 0xf))
449 data
= (uint8_t*)databuffer
;
450 if (sparebuffer
&& !((uint32_t)sparebuffer
& 0xf))
451 spare
= (uint8_t*)sparebuffer
;
452 mutex_lock(&nand_mtx
);
453 nand_last_activity_value
= current_tick
;
455 if (!nand_powered
) nand_power_up();
458 if (spare
!= sparebuffer
) memcpy(spare
, sparebuffer
, 0x40);
460 else memset(spare
, 0xFF, 0x40);
461 nand_set_fmctrl0(bank
, FMCTRL0_ENABLEDMA
);
462 if (nand_send_cmd(NAND_CMD_PROGRAM
)) return nand_unlock(1);
463 if (nand_send_address(page
, databuffer
? 0 : 0x800))
464 return nand_unlock(1);
465 if (databuffer
&& data
!= databuffer
) memcpy(data
, databuffer
, 0x800);
466 if (databuffer
) nand_transfer_data_start(bank
, 1, data
, 0x800);
469 if (ecc_encode(3, data
, nand_ecc
)) return nand_unlock(1);
470 memcpy(&spare
[0xC], nand_ecc
, 0x28);
471 memset(nand_ctrl
, 0xFF, 0x200);
472 memcpy(nand_ctrl
, spare
, 0xC);
473 if (ecc_encode(0, nand_ctrl
, nand_ecc
)) return nand_unlock(1);
474 memcpy(&spare
[0x34], nand_ecc
, 0xC);
477 if (nand_transfer_data_collect(1))
478 return nand_unlock(1);
479 if (sparebuffer
|| doecc
)
480 if (nand_transfer_data(bank
, 1, spare
, 0x40))
481 return nand_unlock(1);
482 if (nand_send_cmd(NAND_CMD_PROGCNFRM
)) return nand_unlock(1);
483 if (wait
) if (nand_wait_status_ready(bank
)) return nand_unlock(1);
484 return nand_unlock(0);
487 uint32_t nand_block_erase(uint32_t bank
, uint32_t page
)
489 mutex_lock(&nand_mtx
);
490 nand_last_activity_value
= current_tick
;
492 if (!nand_powered
) nand_power_up();
493 nand_set_fmctrl0(bank
, 0);
494 if (nand_send_cmd(NAND_CMD_BLOCKERASE
)) return nand_unlock(1);
497 FMCTRL1
= FMCTRL1_DOTRANSADDR
;
498 if (nand_wait_cmddone()) return nand_unlock(1);
499 if (nand_send_cmd(NAND_CMD_ERASECNFRM
)) return nand_unlock(1);
500 if (nand_wait_status_ready(bank
)) return nand_unlock(1);
501 return nand_unlock(0);
504 uint32_t nand_read_page_fast(uint32_t page
, void* databuffer
,
505 void* sparebuffer
, uint32_t doecc
,
509 if (((uint32_t)databuffer
& 0xf) || ((uint32_t)sparebuffer
& 0xf)
510 || !databuffer
|| !sparebuffer
|| !doecc
)
512 for (i
= 0; i
< 4; i
++)
514 if (nand_type
[i
] == 0xFFFFFFFF) continue;
515 void* databuf
= (void*)0;
516 void* sparebuf
= (void*)0;
517 if (databuffer
) databuf
= (void*)((uint32_t)databuffer
+ 0x800 * i
);
518 if (sparebuffer
) sparebuf
= (void*)((uint32_t)sparebuffer
+ 0x40 * i
);
519 uint32_t ret
= nand_read_page(i
, page
, databuf
, sparebuf
, doecc
, checkempty
);
520 if (ret
& 1) rc
|= 1 << (i
<< 2);
521 if (ret
& 2) rc
|= 2 << (i
<< 2);
522 if (ret
& 0x10) rc
|= 4 << (i
<< 2);
523 if (ret
& 0x100) rc
|= 8 << (i
<< 2);
527 mutex_lock(&nand_mtx
);
528 nand_last_activity_value
= current_tick
;
530 if (!nand_powered
) nand_power_up();
531 for (i
= 0; i
< 4; i
++)
533 if (nand_type
[i
] == 0xFFFFFFFF) continue;
534 nand_set_fmctrl0(i
, FMCTRL0_ENABLEDMA
);
535 if (nand_send_cmd(NAND_CMD_READ
))
540 if (nand_send_address(page
, databuffer
? 0 : 0x800))
545 if (nand_send_cmd(NAND_CMD_READ2
))
552 for (i
= 0; i
< 4; i
++) status
[i
] = (nand_type
[i
] == 0xFFFFFFFF);
554 if (nand_wait_status_ready(0))
557 if (nand_transfer_data(0, 0, databuffer
, 0x800))
560 if (nand_transfer_data(0, 0, sparebuffer
, 0x40))
562 for (i
= 1; i
< 4; i
++)
565 if (nand_wait_status_ready(i
))
568 nand_transfer_data_start(i
, 0, (void*)((uint32_t)databuffer
569 + 0x800 * i
), 0x800);
572 memcpy(nand_ecc
, (void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1) + 0xC), 0x28);
573 ecc_start(3, (void*)((uint32_t)databuffer
574 + 0x800 * (i
- 1)), nand_ecc
, ECCCTRL_STARTDECODING
);
577 if (nand_transfer_data_collect(0))
580 nand_transfer_data_start(i
, 0, (void*)((uint32_t)sparebuffer
583 if (ecc_collect() & 1)
587 memset(nand_ctrl
, 0xFF, 0x200);
588 memcpy(nand_ctrl
, (void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), 0xC);
589 memcpy(nand_ecc
, (void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1) + 0x34), 0xC);
590 ecc_start(0, nand_ctrl
, nand_ecc
, ECCCTRL_STARTDECODING
);
593 if (nand_transfer_data_collect(0))
597 if (ecc_collect() & 1)
600 memset((void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), 0xFF, 0xC);
602 else memcpy((void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), nand_ctrl
, 0xC);
604 status
[i
- 1] |= nand_check_empty((void*)((uint32_t)sparebuffer
605 + 0x40 * (i
- 1))) << 1;
610 memcpy(nand_ecc
,(void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1) + 0xC), 0x28);
611 if (ecc_decode(3, (void*)((uint32_t)databuffer
612 + 0x800 * (i
- 1)), nand_ecc
) & 1)
617 memset(nand_ctrl
, 0xFF, 0x200);
618 memcpy(nand_ctrl
, (void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), 0xC);
619 memcpy(nand_ecc
, (void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1) + 0x34), 0xC);
620 if (ecc_decode(0, nand_ctrl
, nand_ecc
) & 1)
623 memset((void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), 0xFF, 0xC);
625 else memcpy((void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), nand_ctrl
, 0xC);
627 status
[i
- 1] |= nand_check_empty((void*)((uint32_t)sparebuffer
628 + 0x40 * (i
- 1))) << 1;
630 for (i
= 0; i
< 4; i
++)
631 if (nand_type
[i
] != 0xFFFFFFFF)
632 rc
|= status
[i
] << (i
<< 2);
633 return nand_unlock(rc
);
636 uint32_t nand_write_page(uint32_t bank
, uint32_t page
, void* databuffer
,
637 void* sparebuffer
, uint32_t doecc
)
639 return nand_write_page_int(bank
, page
, databuffer
, sparebuffer
, doecc
, 1);
642 uint32_t nand_write_page_start(uint32_t bank
, uint32_t page
, void* databuffer
,
643 void* sparebuffer
, uint32_t doecc
)
645 if (((uint32_t)databuffer
& 0xf) || ((uint32_t)sparebuffer
& 0xf)
646 || !databuffer
|| !sparebuffer
|| !doecc
)
647 return nand_write_page_int(bank
, page
, databuffer
, sparebuffer
, doecc
, 0);
649 mutex_lock(&nand_mtx
);
650 nand_last_activity_value
= current_tick
;
652 if (!nand_powered
) nand_power_up();
653 nand_set_fmctrl0(bank
, FMCTRL0_ENABLEDMA
);
654 if (nand_send_cmd(NAND_CMD_PROGRAM
))
655 return nand_unlock(1);
656 if (nand_send_address(page
, 0))
657 return nand_unlock(1);
658 nand_transfer_data_start(bank
, 1, databuffer
, 0x800);
659 if (ecc_encode(3, databuffer
, nand_ecc
))
660 return nand_unlock(1);
661 memcpy((void*)((uint32_t)sparebuffer
+ 0xC), nand_ecc
, 0x28);
662 memset(nand_ctrl
, 0xFF, 0x200);
663 memcpy(nand_ctrl
, sparebuffer
, 0xC);
664 if (ecc_encode(0, nand_ctrl
, nand_ecc
))
665 return nand_unlock(1);
666 memcpy((void*)((uint32_t)sparebuffer
+ 0x34), nand_ecc
, 0xC);
667 if (nand_transfer_data_collect(0))
668 return nand_unlock(1);
669 if (nand_transfer_data(bank
, 1, sparebuffer
, 0x40))
670 return nand_unlock(1);
671 return nand_unlock(nand_send_cmd(NAND_CMD_PROGCNFRM
));
674 uint32_t nand_write_page_collect(uint32_t bank
)
676 return nand_wait_status_ready(bank
);
679 uint32_t nand_block_erase_fast(uint32_t page
)
682 mutex_lock(&nand_mtx
);
683 nand_last_activity_value
= current_tick
;
685 if (!nand_powered
) nand_power_up();
686 for (i
= 0; i
< 4; i
++)
688 if (nand_type
[i
] == 0xFFFFFFFF) continue;
689 nand_set_fmctrl0(i
, 0);
690 if (nand_send_cmd(NAND_CMD_BLOCKERASE
))
697 FMCTRL1
= FMCTRL1_DOTRANSADDR
;
698 if (nand_wait_cmddone())
703 if (nand_send_cmd(NAND_CMD_ERASECNFRM
)) rc
|= 1 << i
;
705 for (i
= 0; i
< 4; i
++)
707 if (nand_type
[i
] == 0xFFFFFFFF) continue;
708 if (rc
& (1 << i
)) continue;
709 if (nand_wait_status_ready(i
)) rc
|= 1 << i
;
711 return nand_unlock(rc
);
714 const struct nand_device_info_type
* nand_get_device_type(uint32_t bank
)
716 if (nand_type
[bank
] == 0xFFFFFFFF)
717 return (struct nand_device_info_type
*)0;
718 return &nand_deviceinfotable
[nand_type
[bank
]];
721 static void nand_thread(void)
725 if (TIME_AFTER(current_tick
, nand_last_activity_value
+ HZ
/ 5)
732 uint32_t nand_device_init(void)
734 mutex_init(&nand_mtx
);
735 wakeup_init(&nand_wakeup
);
736 mutex_init(&ecc_mtx
);
737 wakeup_init(&ecc_wakeup
);
742 /* Assume there are 0 banks, to prevent
743 nand_power_up from talking with them yet. */
744 for(i
= 0; i
< 4; i
++) nand_type
[i
] = 0xFFFFFFFF;
747 /* Now that the flash is powered on, detect how
748 many banks we really have and initialize them. */
749 for (i
= 0; i
< 4; i
++)
755 type
= nand_get_chip_type(i
);
756 if (type
== 0xFFFFFFFF) continue;
759 if (j
== ARRAYLEN(nand_deviceinfotable
)) break;
760 else if (nand_deviceinfotable
[j
].id
== type
)
766 nand_tunk1
[i
] = nand_deviceinfotable
[nand_type
[i
]].tunk1
;
767 nand_twp
[i
] = nand_deviceinfotable
[nand_type
[i
]].twp
;
768 nand_tunk2
[i
] = nand_deviceinfotable
[nand_type
[i
]].tunk2
;
769 nand_tunk3
[i
] = nand_deviceinfotable
[nand_type
[i
]].tunk3
;
771 if (nand_type
[0] == 0xFFFFFFFF) return 1;
773 nand_last_activity_value
= current_tick
;
774 create_thread(nand_thread
, nand_stack
,
775 sizeof(nand_stack
), 0, "nand"
776 IF_PRIO(, PRIORITY_USER_INTERFACE
)