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>
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 int nand_interleaved
= 0;
94 long nand_last_activity_value
= -1;
95 static long nand_stack
[32];
97 static struct mutex nand_mtx
;
98 static struct wakeup nand_wakeup
;
99 static struct mutex ecc_mtx
;
100 static struct wakeup ecc_wakeup
;
102 static uint8_t nand_data
[0x800] __attribute__((aligned(16)));
103 static uint8_t nand_ctrl
[0x200] __attribute__((aligned(16)));
104 static uint8_t nand_spare
[0x40] __attribute__((aligned(16)));
105 static uint8_t nand_ecc
[0x30] __attribute__((aligned(16)));
108 uint32_t nand_unlock(uint32_t rc
)
111 nand_last_activity_value
= current_tick
;
112 mutex_unlock(&nand_mtx
);
116 uint32_t ecc_unlock(uint32_t rc
)
118 mutex_unlock(&ecc_mtx
);
122 uint32_t nand_timeout(long timeout
)
124 if (TIME_AFTER(current_tick
, timeout
)) return 1;
132 uint32_t nand_wait_rbbdone(void)
134 long timeout
= current_tick
+ HZ
/ 50;
135 while (!(FMCSTAT
& FMCSTAT_RBBDONE
))
136 if (nand_timeout(timeout
)) return 1;
137 FMCSTAT
= FMCSTAT_RBBDONE
;
141 uint32_t nand_wait_cmddone(void)
143 long timeout
= current_tick
+ HZ
/ 50;
144 while (!(FMCSTAT
& FMCSTAT_CMDDONE
))
145 if (nand_timeout(timeout
)) return 1;
146 FMCSTAT
= FMCSTAT_CMDDONE
;
150 uint32_t nand_wait_addrdone(void)
152 long timeout
= current_tick
+ HZ
/ 50;
153 while (!(FMCSTAT
& FMCSTAT_ADDRDONE
))
154 if (nand_timeout(timeout
)) return 1;
155 FMCSTAT
= FMCSTAT_ADDRDONE
;
159 uint32_t nand_wait_chip_ready(uint32_t bank
)
161 long timeout
= current_tick
+ HZ
/ 50;
162 while (!(FMCSTAT
& (FMCSTAT_BANK0READY
<< bank
)))
163 if (nand_timeout(timeout
)) return 1;
164 FMCSTAT
= (FMCSTAT_BANK0READY
<< bank
);
168 void nand_set_fmctrl0(uint32_t bank
, uint32_t flags
)
170 FMCTRL0
= (nand_tunk1
[bank
] << 16) | (nand_twp
[bank
] << 12)
171 | (1 << 11) | 1 | (1 << (bank
+ 1)) | flags
;
174 uint32_t nand_send_cmd(uint32_t cmd
)
177 return nand_wait_rbbdone();
180 uint32_t nand_send_address(uint32_t page
, uint32_t offset
)
183 FMADDR0
= (page
<< 16) | offset
;
184 FMADDR1
= (page
>> 16) & 0xFF;
185 FMCTRL1
= FMCTRL1_DOTRANSADDR
;
186 return nand_wait_cmddone();
189 uint32_t nand_reset(uint32_t bank
)
191 nand_set_fmctrl0(bank
, 0);
192 if (nand_send_cmd(NAND_CMD_RESET
)) return 1;
193 if (nand_wait_chip_ready(bank
)) return 1;
194 FMCTRL1
= FMCTRL1_CLEARRFIFO
| FMCTRL1_CLEARWFIFO
;
199 uint32_t nand_wait_status_ready(uint32_t bank
)
201 long timeout
= current_tick
+ HZ
/ 50;
202 nand_set_fmctrl0(bank
, 0);
203 if ((FMCSTAT
& (FMCSTAT_BANK0READY
<< bank
)))
204 FMCSTAT
= (FMCSTAT_BANK0READY
<< bank
);
205 FMCTRL1
= FMCTRL1_CLEARRFIFO
;
206 if (nand_send_cmd(NAND_CMD_GET_STATUS
)) return 1;
209 if (nand_timeout(timeout
)) return 1;
211 FMCTRL1
= FMCTRL1_DOREADDATA
;
212 if (nand_wait_addrdone()) return 1;
213 if ((FMFIFO
& NAND_STATUS_READY
)) break;
214 FMCTRL1
= FMCTRL1_CLEARRFIFO
;
216 FMCTRL1
= FMCTRL1_CLEARRFIFO
;
217 return nand_send_cmd(NAND_CMD_READ
);
220 void nand_transfer_data_start(uint32_t bank
, uint32_t direction
,
221 void* buffer
, uint32_t size
)
223 nand_set_fmctrl0(bank
, FMCTRL0_ENABLEDMA
);
225 FMCTRL1
= FMCTRL1_DOREADDATA
<< direction
;
226 DMACON3
= (2 << DMACON_DEVICE_SHIFT
)
227 | (direction
<< DMACON_DIRECTION_SHIFT
)
228 | (2 << DMACON_DATA_SIZE_SHIFT
)
229 | (3 << DMACON_BURST_LEN_SHIFT
);
230 while ((DMAALLST
& DMAALLST_CHAN3_MASK
))
231 DMACOM3
= DMACOM_CLEARBOTHDONE
;
232 DMABASE3
= (uint32_t)buffer
;
233 DMATCNT3
= (size
>> 4) - 1;
238 uint32_t nand_transfer_data_collect(uint32_t direction
)
240 long timeout
= current_tick
+ HZ
/ 50;
241 while ((DMAALLST
& DMAALLST_DMABUSY3
))
242 if (nand_timeout(timeout
)) return 1;
243 if (!direction
) invalidate_dcache();
244 if (nand_wait_addrdone()) return 1;
245 if (!direction
) FMCTRL1
= FMCTRL1_CLEARRFIFO
| FMCTRL1_CLEARWFIFO
;
246 else FMCTRL1
= FMCTRL1_CLEARRFIFO
;
250 uint32_t nand_transfer_data(uint32_t bank
, uint32_t direction
,
251 void* buffer
, uint32_t size
)
253 nand_transfer_data_start(bank
, direction
, buffer
, size
);
254 uint32_t rc
= nand_transfer_data_collect(direction
);
258 void ecc_start(uint32_t size
, void* databuffer
, void* sparebuffer
, uint32_t type
)
260 mutex_lock(&ecc_mtx
);
264 ECC_DATA_PTR
= (uint32_t)databuffer
;
265 ECC_SPARE_PTR
= (uint32_t)sparebuffer
;
270 uint32_t ecc_collect(void)
272 long timeout
= current_tick
+ HZ
/ 50;
273 while (!(SRCPND
& INTMSK_ECC
))
274 if (nand_timeout(timeout
)) return ecc_unlock(1);
278 return ecc_unlock(ECC_RESULT
);
281 uint32_t ecc_decode(uint32_t size
, void* databuffer
, void* sparebuffer
)
283 ecc_start(size
, databuffer
, sparebuffer
, ECCCTRL_STARTDECODING
);
284 uint32_t rc
= ecc_collect();
288 uint32_t ecc_encode(uint32_t size
, void* databuffer
, void* sparebuffer
)
290 ecc_start(size
, databuffer
, sparebuffer
, ECCCTRL_STARTENCODING
);
295 uint32_t nand_check_empty(uint8_t* buffer
)
299 for (i
= 0; i
< 0x40; i
++) if (buffer
[i
] != 0xFF) count
++;
300 if (count
< 2) return 1;
304 uint32_t nand_get_chip_type(uint32_t bank
)
306 mutex_lock(&nand_mtx
);
308 if (nand_reset(bank
)) return nand_unlock(0xFFFFFFFF);
309 if (nand_send_cmd(0x90)) return nand_unlock(0xFFFFFFFF);
312 FMCTRL1
= FMCTRL1_DOTRANSADDR
;
313 if (nand_wait_cmddone()) return nand_unlock(0xFFFFFFFF);
315 FMCTRL1
= FMCTRL1_DOREADDATA
;
316 if (nand_wait_addrdone()) return nand_unlock(0xFFFFFFFF);
318 FMCTRL1
= FMCTRL1_CLEARRFIFO
;
319 return nand_unlock(result
);
322 void nand_set_active(void)
324 nand_last_activity_value
= current_tick
;
327 long nand_last_activity(void)
329 return nand_last_activity_value
;
332 void nand_power_up(void)
335 mutex_lock(&nand_mtx
);
336 nand_last_activity_value
= current_tick
;
345 PCON5
= (PCON5
& ~0xF) | 3;
347 pmu_ldo_set_voltage(4, 0x15);
350 nand_last_activity_value
= current_tick
;
351 for (i
= 0; i
< 4; i
++)
353 if(nand_type
[i
] != 0xFFFFFFFF)
356 panicf("nand_power_up: nand_reset(bank=%d) failed.",(unsigned int)i
);
360 nand_last_activity_value
= current_tick
;
361 mutex_unlock(&nand_mtx
);
364 void nand_power_down(void)
366 if (!nand_powered
) return;
367 mutex_lock(&nand_mtx
);
368 pmu_ldo_power_off(4);
375 PCON5
= (PCON5
& ~0xF) | 1;
380 mutex_unlock(&nand_mtx
);
383 uint32_t nand_read_page(uint32_t bank
, uint32_t page
, void* databuffer
,
384 void* sparebuffer
, uint32_t doecc
,
387 uint8_t* data
= nand_data
;
388 uint8_t* spare
= nand_spare
;
389 if (databuffer
&& !((uint32_t)databuffer
& 0xf))
390 data
= (uint8_t*)databuffer
;
391 if (sparebuffer
&& !((uint32_t)sparebuffer
& 0xf))
392 spare
= (uint8_t*)sparebuffer
;
393 mutex_lock(&nand_mtx
);
394 nand_last_activity_value
= current_tick
;
396 if (!nand_powered
) nand_power_up();
397 uint32_t rc
, eccresult
;
398 nand_set_fmctrl0(bank
, FMCTRL0_ENABLEDMA
);
399 if (nand_send_cmd(NAND_CMD_READ
)) return nand_unlock(1);
400 if (nand_send_address(page
, databuffer
? 0 : 0x800))
401 return nand_unlock(1);
402 if (nand_send_cmd(NAND_CMD_READ2
)) return nand_unlock(1);
403 if (nand_wait_status_ready(bank
)) return nand_unlock(1);
405 if (nand_transfer_data(bank
, 0, data
, 0x800))
406 return nand_unlock(1);
410 if (databuffer
&& data
!= databuffer
) memcpy(databuffer
, data
, 0x800);
413 if (nand_transfer_data(bank
, 0, spare
, 0x40))
414 return nand_unlock(1);
415 if (sparebuffer
&& spare
!= sparebuffer
)
416 memcpy(sparebuffer
, spare
, 0x800);
418 rc
= nand_check_empty((uint8_t*)sparebuffer
) << 1;
420 return nand_unlock(rc
);
422 if (nand_transfer_data(bank
, 0, spare
, 0x40)) return nand_unlock(1);
425 memcpy(nand_ecc
, &spare
[0xC], 0x28);
426 rc
|= (ecc_decode(3, data
, nand_ecc
) & 0xF) << 4;
427 if (data
!= databuffer
) memcpy(databuffer
, data
, 0x800);
429 memset(nand_ctrl
, 0xFF, 0x200);
430 memcpy(nand_ctrl
, spare
, 0xC);
431 memcpy(nand_ecc
, &spare
[0x34], 0xC);
432 eccresult
= ecc_decode(0, nand_ctrl
, nand_ecc
);
433 rc
|= (eccresult
& 0xF) << 8;
436 if (spare
!= sparebuffer
) memcpy(sparebuffer
, spare
, 0x40);
437 if (eccresult
& 1) memset(sparebuffer
, 0xFF, 0xC);
438 else memcpy(sparebuffer
, nand_ctrl
, 0xC);
440 if (checkempty
) rc
|= nand_check_empty(spare
) << 1;
442 return nand_unlock(rc
);
445 uint32_t nand_write_page_int(uint32_t bank
, uint32_t page
, void* databuffer
,
446 void* sparebuffer
, uint32_t doecc
, uint32_t wait
)
448 uint8_t* data
= nand_data
;
449 uint8_t* spare
= nand_spare
;
450 if (databuffer
&& !((uint32_t)databuffer
& 0xf))
451 data
= (uint8_t*)databuffer
;
452 if (sparebuffer
&& !((uint32_t)sparebuffer
& 0xf))
453 spare
= (uint8_t*)sparebuffer
;
454 mutex_lock(&nand_mtx
);
455 nand_last_activity_value
= current_tick
;
457 if (!nand_powered
) nand_power_up();
460 if (spare
!= sparebuffer
) memcpy(spare
, sparebuffer
, 0x40);
462 else memset(spare
, 0xFF, 0x40);
463 nand_set_fmctrl0(bank
, FMCTRL0_ENABLEDMA
);
464 if (nand_send_cmd(NAND_CMD_PROGRAM
)) return nand_unlock(1);
465 if (nand_send_address(page
, databuffer
? 0 : 0x800))
466 return nand_unlock(1);
467 if (databuffer
&& data
!= databuffer
) memcpy(data
, databuffer
, 0x800);
468 if (databuffer
) nand_transfer_data_start(bank
, 1, data
, 0x800);
471 if (ecc_encode(3, data
, nand_ecc
)) return nand_unlock(1);
472 memcpy(&spare
[0xC], nand_ecc
, 0x28);
473 memset(nand_ctrl
, 0xFF, 0x200);
474 memcpy(nand_ctrl
, spare
, 0xC);
475 if (ecc_encode(0, nand_ctrl
, nand_ecc
)) return nand_unlock(1);
476 memcpy(&spare
[0x34], nand_ecc
, 0xC);
479 if (nand_transfer_data_collect(1))
480 return nand_unlock(1);
481 if (sparebuffer
|| doecc
)
482 if (nand_transfer_data(bank
, 1, spare
, 0x40))
483 return nand_unlock(1);
484 if (nand_send_cmd(NAND_CMD_PROGCNFRM
)) return nand_unlock(1);
485 if (wait
) if (nand_wait_status_ready(bank
)) return nand_unlock(1);
486 return nand_unlock(0);
489 uint32_t nand_block_erase(uint32_t bank
, uint32_t page
)
491 mutex_lock(&nand_mtx
);
492 nand_last_activity_value
= current_tick
;
494 if (!nand_powered
) nand_power_up();
495 nand_set_fmctrl0(bank
, 0);
496 if (nand_send_cmd(NAND_CMD_BLOCKERASE
)) return nand_unlock(1);
499 FMCTRL1
= FMCTRL1_DOTRANSADDR
;
500 if (nand_wait_cmddone()) return nand_unlock(1);
501 if (nand_send_cmd(NAND_CMD_ERASECNFRM
)) return nand_unlock(1);
502 if (nand_wait_status_ready(bank
)) return nand_unlock(1);
503 return nand_unlock(0);
506 uint32_t nand_read_page_fast(uint32_t page
, void* databuffer
,
507 void* sparebuffer
, uint32_t doecc
,
511 if (((uint32_t)databuffer
& 0xf) || ((uint32_t)sparebuffer
& 0xf)
512 || !databuffer
|| !sparebuffer
|| !doecc
)
514 for (i
= 0; i
< 4; i
++)
516 if (nand_type
[i
] == 0xFFFFFFFF) continue;
517 void* databuf
= (void*)0;
518 void* sparebuf
= (void*)0;
519 if (databuffer
) databuf
= (void*)((uint32_t)databuffer
+ 0x800 * i
);
520 if (sparebuffer
) sparebuf
= (void*)((uint32_t)sparebuffer
+ 0x40 * i
);
521 uint32_t ret
= nand_read_page(i
, page
, databuf
, sparebuf
, doecc
, checkempty
);
522 if (ret
& 1) rc
|= 1 << (i
<< 2);
523 if (ret
& 2) rc
|= 2 << (i
<< 2);
524 if (ret
& 0x10) rc
|= 4 << (i
<< 2);
525 if (ret
& 0x100) rc
|= 8 << (i
<< 2);
529 mutex_lock(&nand_mtx
);
530 nand_last_activity_value
= current_tick
;
532 if (!nand_powered
) nand_power_up();
534 for (i
= 0; i
< 4; i
++) status
[i
] = (nand_type
[i
] == 0xFFFFFFFF);
535 for (i
= 0; i
< 4; i
++)
539 nand_set_fmctrl0(i
, FMCTRL0_ENABLEDMA
);
540 if (nand_send_cmd(NAND_CMD_READ
))
544 if (nand_send_address(page
, 0))
547 if (nand_send_cmd(NAND_CMD_READ2
))
551 if (nand_wait_status_ready(0))
554 if (nand_transfer_data(0, 0, databuffer
, 0x800))
557 if (nand_transfer_data(0, 0, sparebuffer
, 0x40))
559 for (i
= 1; i
< 4; i
++)
562 if (nand_wait_status_ready(i
))
565 nand_transfer_data_start(i
, 0, (void*)((uint32_t)databuffer
566 + 0x800 * i
), 0x800);
569 memcpy(nand_ecc
, (void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1) + 0xC), 0x28);
570 ecc_start(3, (void*)((uint32_t)databuffer
571 + 0x800 * (i
- 1)), nand_ecc
, ECCCTRL_STARTDECODING
);
574 if (nand_transfer_data_collect(0))
577 nand_transfer_data_start(i
, 0, (void*)((uint32_t)sparebuffer
580 if (ecc_collect() & 1)
584 memset(nand_ctrl
, 0xFF, 0x200);
585 memcpy(nand_ctrl
, (void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), 0xC);
586 memcpy(nand_ecc
, (void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1) + 0x34), 0xC);
587 ecc_start(0, nand_ctrl
, nand_ecc
, ECCCTRL_STARTDECODING
);
590 if (nand_transfer_data_collect(0))
594 if (ecc_collect() & 1)
597 memset((void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), 0xFF, 0xC);
599 else memcpy((void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), nand_ctrl
, 0xC);
601 status
[i
- 1] |= nand_check_empty((void*)((uint32_t)sparebuffer
602 + 0x40 * (i
- 1))) << 1;
607 memcpy(nand_ecc
,(void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1) + 0xC), 0x28);
608 if (ecc_decode(3, (void*)((uint32_t)databuffer
609 + 0x800 * (i
- 1)), nand_ecc
) & 1)
614 memset(nand_ctrl
, 0xFF, 0x200);
615 memcpy(nand_ctrl
, (void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), 0xC);
616 memcpy(nand_ecc
, (void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1) + 0x34), 0xC);
617 if (ecc_decode(0, nand_ctrl
, nand_ecc
) & 1)
620 memset((void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), 0xFF, 0xC);
622 else memcpy((void*)((uint32_t)sparebuffer
+ 0x40 * (i
- 1)), nand_ctrl
, 0xC);
624 status
[i
- 1] |= nand_check_empty((void*)((uint32_t)sparebuffer
625 + 0x40 * (i
- 1))) << 1;
627 for (i
= 0; i
< 4; i
++)
628 if (nand_type
[i
] != 0xFFFFFFFF)
629 rc
|= status
[i
] << (i
<< 2);
630 return nand_unlock(rc
);
633 uint32_t nand_write_page(uint32_t bank
, uint32_t page
, void* databuffer
,
634 void* sparebuffer
, uint32_t doecc
)
636 return nand_write_page_int(bank
, page
, databuffer
, sparebuffer
, doecc
, 1);
639 uint32_t nand_write_page_start(uint32_t bank
, uint32_t page
, void* databuffer
,
640 void* sparebuffer
, uint32_t doecc
)
642 if (((uint32_t)databuffer
& 0xf) || ((uint32_t)sparebuffer
& 0xf)
643 || !databuffer
|| !sparebuffer
|| !doecc
|| !nand_interleaved
)
644 return nand_write_page_int(bank
, page
, databuffer
, sparebuffer
, doecc
, !nand_interleaved
);
646 mutex_lock(&nand_mtx
);
647 nand_last_activity_value
= current_tick
;
649 if (!nand_powered
) nand_power_up();
650 nand_set_fmctrl0(bank
, FMCTRL0_ENABLEDMA
);
651 if (nand_send_cmd(NAND_CMD_PROGRAM
))
652 return nand_unlock(1);
653 if (nand_send_address(page
, 0))
654 return nand_unlock(1);
655 nand_transfer_data_start(bank
, 1, databuffer
, 0x800);
656 if (ecc_encode(3, databuffer
, nand_ecc
))
657 return nand_unlock(1);
658 memcpy((void*)((uint32_t)sparebuffer
+ 0xC), nand_ecc
, 0x28);
659 memset(nand_ctrl
, 0xFF, 0x200);
660 memcpy(nand_ctrl
, sparebuffer
, 0xC);
661 if (ecc_encode(0, nand_ctrl
, nand_ecc
))
662 return nand_unlock(1);
663 memcpy((void*)((uint32_t)sparebuffer
+ 0x34), nand_ecc
, 0xC);
664 if (nand_transfer_data_collect(0))
665 return nand_unlock(1);
666 if (nand_transfer_data(bank
, 1, sparebuffer
, 0x40))
667 return nand_unlock(1);
668 return nand_unlock(nand_send_cmd(NAND_CMD_PROGCNFRM
));
671 uint32_t nand_write_page_collect(uint32_t bank
)
673 return nand_wait_status_ready(bank
);
676 uint32_t nand_block_erase_fast(uint32_t page
)
679 mutex_lock(&nand_mtx
);
680 nand_last_activity_value
= current_tick
;
682 if (!nand_powered
) nand_power_up();
683 for (i
= 0; i
< 4; i
++)
685 if (nand_type
[i
] == 0xFFFFFFFF) continue;
686 nand_set_fmctrl0(i
, 0);
687 if (nand_send_cmd(NAND_CMD_BLOCKERASE
))
694 FMCTRL1
= FMCTRL1_DOTRANSADDR
;
695 if (nand_wait_cmddone())
700 if (nand_send_cmd(NAND_CMD_ERASECNFRM
)) rc
|= 1 << i
;
702 for (i
= 0; i
< 4; i
++)
704 if (nand_type
[i
] == 0xFFFFFFFF) continue;
705 if (rc
& (1 << i
)) continue;
706 if (nand_wait_status_ready(i
)) rc
|= 1 << i
;
708 return nand_unlock(rc
);
711 const struct nand_device_info_type
* nand_get_device_type(uint32_t bank
)
713 if (nand_type
[bank
] == 0xFFFFFFFF)
714 return (struct nand_device_info_type
*)0;
715 return &nand_deviceinfotable
[nand_type
[bank
]];
718 static void nand_thread(void)
722 if (TIME_AFTER(current_tick
, nand_last_activity_value
+ HZ
/ 5)
729 uint32_t nand_device_init(void)
731 mutex_init(&nand_mtx
);
732 wakeup_init(&nand_wakeup
);
733 mutex_init(&ecc_mtx
);
734 wakeup_init(&ecc_wakeup
);
739 /* Assume there are 0 banks, to prevent
740 nand_power_up from talking with them yet. */
741 for(i
= 0; i
< 4; i
++) nand_type
[i
] = 0xFFFFFFFF;
744 /* Now that the flash is powered on, detect how
745 many banks we really have and initialize them. */
746 for (i
= 0; i
< 4; i
++)
752 type
= nand_get_chip_type(i
);
753 if (type
== 0xFFFFFFFF) continue;
756 if (j
== ARRAYLEN(nand_deviceinfotable
)) break;
757 else if (nand_deviceinfotable
[j
].id
== type
)
763 nand_tunk1
[i
] = nand_deviceinfotable
[nand_type
[i
]].tunk1
;
764 nand_twp
[i
] = nand_deviceinfotable
[nand_type
[i
]].twp
;
765 nand_tunk2
[i
] = nand_deviceinfotable
[nand_type
[i
]].tunk2
;
766 nand_tunk3
[i
] = nand_deviceinfotable
[nand_type
[i
]].tunk3
;
768 if (nand_type
[0] == 0xFFFFFFFF) return 1;
769 nand_interleaved
= ((nand_type
[0] >> 22) & 1);
770 nand_cached
= ((nand_type
[0] >> 23) & 1);
772 nand_last_activity_value
= current_tick
;
773 create_thread(nand_thread
, nand_stack
,
774 sizeof(nand_stack
), 0, "nand"
775 IF_PRIO(, PRIORITY_USER_INTERFACE
)