projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'stable/fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/konrad...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / spectra / flash.c
1 /*
2 * NAND Flash Controller Device Driver
3 * Copyright (c) 2009, Intel Corporation and its suppliers.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 */
19
20 #include <linux/fs.h>
21 #include <linux/slab.h>
22
23 #include "flash.h"
24 #include "ffsdefs.h"
25 #include "lld.h"
26 #include "lld_nand.h"
27 #if CMD_DMA
28 #include "lld_cdma.h"
29 #endif
30
31 #define BLK_FROM_ADDR(addr) ((u32)(addr >> DeviceInfo.nBitsInBlockDataSize))
32 #define PAGE_FROM_ADDR(addr, Block) ((u16)((addr - (u64)Block * \
33 DeviceInfo.wBlockDataSize) >> DeviceInfo.nBitsInPageDataSize))
34
35 #define IS_SPARE_BLOCK(blk) (BAD_BLOCK != (pbt[blk] &\
36 BAD_BLOCK) && SPARE_BLOCK == (pbt[blk] & SPARE_BLOCK))
37
38 #define IS_DATA_BLOCK(blk) (0 == (pbt[blk] & BAD_BLOCK))
39
40 #define IS_DISCARDED_BLOCK(blk) (BAD_BLOCK != (pbt[blk] &\
41 BAD_BLOCK) && DISCARD_BLOCK == (pbt[blk] & DISCARD_BLOCK))
42
43 #define IS_BAD_BLOCK(blk) (BAD_BLOCK == (pbt[blk] & BAD_BLOCK))
44
45 #if DEBUG_BNDRY
46 void debug_boundary_lineno_error(int chnl, int limit, int no,
47 int lineno, char *filename)
48 {
49 if (chnl >= limit)
50 printk(KERN_ERR "Boundary Check Fail value %d >= limit %d, "
51 "at %s:%d. Other info:%d. Aborting...\n",
52 chnl, limit, filename, lineno, no);
53 }
54 /* static int globalmemsize; */
55 #endif
56
57 static u16 FTL_Cache_If_Hit(u64 dwPageAddr);
58 static int FTL_Cache_Read(u64 dwPageAddr);
59 static void FTL_Cache_Read_Page(u8 *pData, u64 dwPageAddr,
60 u16 cache_blk);
61 static void FTL_Cache_Write_Page(u8 *pData, u64 dwPageAddr,
62 u8 cache_blk, u16 flag);
63 static int FTL_Cache_Write(void);
64 static int FTL_Cache_Write_Back(u8 *pData, u64 blk_addr);
65 static void FTL_Calculate_LRU(void);
66 static u32 FTL_Get_Block_Index(u32 wBlockNum);
67
68 static int FTL_Search_Block_Table_IN_Block(u32 BT_Block,
69 u8 BT_Tag, u16 *Page);
70 static int FTL_Read_Block_Table(void);
71 static int FTL_Write_Block_Table(int wForce);
72 static int FTL_Write_Block_Table_Data(void);
73 static int FTL_Check_Block_Table(int wOldTable);
74 static int FTL_Static_Wear_Leveling(void);
75 static u32 FTL_Replace_Block_Table(void);
76 static int FTL_Write_IN_Progress_Block_Table_Page(void);
77
78 static u32 FTL_Get_Page_Num(u64 length);
79 static u64 FTL_Get_Physical_Block_Addr(u64 blk_addr);
80
81 static u32 FTL_Replace_OneBlock(u32 wBlockNum,
82 u32 wReplaceNum);
83 static u32 FTL_Replace_LWBlock(u32 wBlockNum,
84 int *pGarbageCollect);
85 static u32 FTL_Replace_MWBlock(void);
86 static int FTL_Replace_Block(u64 blk_addr);
87 static int FTL_Adjust_Relative_Erase_Count(u32 Index_of_MAX);
88
89 static int FTL_Flash_Error_Handle(u8 *pData, u64 old_page_addr, u64 blk_addr);
90
91 struct device_info_tag DeviceInfo;
92 struct flash_cache_tag Cache;
93 static struct spectra_l2_cache_info cache_l2;
94
95 static u8 *cache_l2_page_buf;
96 static u8 *cache_l2_blk_buf;
97
98 u8 *g_pBlockTable;
99 u8 *g_pWearCounter;
100 u16 *g_pReadCounter;
101 u32 *g_pBTBlocks;
102 static u16 g_wBlockTableOffset;
103 static u32 g_wBlockTableIndex;
104 static u8 g_cBlockTableStatus;
105
106 static u8 *g_pTempBuf;
107 static u8 *flag_check_blk_table;
108 static u8 *tmp_buf_search_bt_in_block;
109 static u8 *spare_buf_search_bt_in_block;
110 static u8 *spare_buf_bt_search_bt_in_block;
111 static u8 *tmp_buf1_read_blk_table;
112 static u8 *tmp_buf2_read_blk_table;
113 static u8 *flags_static_wear_leveling;
114 static u8 *tmp_buf_write_blk_table_data;
115 static u8 *tmp_buf_read_disturbance;
116
117 u8 *buf_read_page_main_spare;
118 u8 *buf_write_page_main_spare;
119 u8 *buf_read_page_spare;
120 u8 *buf_get_bad_block;
121
122 #if (RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE && CMD_DMA)
123 struct flash_cache_delta_list_tag int_cache[MAX_CHANS + MAX_DESCS];
124 struct flash_cache_tag cache_start_copy;
125 #endif
126
127 int g_wNumFreeBlocks;
128 u8 g_SBDCmdIndex;
129
130 static u8 *g_pIPF;
131 static u8 bt_flag = FIRST_BT_ID;
132 static u8 bt_block_changed;
133
134 static u16 cache_block_to_write;
135 static u8 last_erased = FIRST_BT_ID;
136
137 static u8 GC_Called;
138 static u8 BT_GC_Called;
139
140 #if CMD_DMA
141 #define COPY_BACK_BUF_NUM 10
142
143 static u8 ftl_cmd_cnt; /* Init value is 0 */
144 u8 *g_pBTDelta;
145 u8 *g_pBTDelta_Free;
146 u8 *g_pBTStartingCopy;
147 u8 *g_pWearCounterCopy;
148 u16 *g_pReadCounterCopy;
149 u8 *g_pBlockTableCopies;
150 u8 *g_pNextBlockTable;
151 static u8 *cp_back_buf_copies[COPY_BACK_BUF_NUM];
152 static int cp_back_buf_idx;
153
154 static u8 *g_temp_buf;
155
156 #pragma pack(push, 1)
157 #pragma pack(1)
158 struct BTableChangesDelta {
159 u8 ftl_cmd_cnt;
160 u8 ValidFields;
161 u16 g_wBlockTableOffset;
162 u32 g_wBlockTableIndex;
163 u32 BT_Index;
164 u32 BT_Entry_Value;
165 u32 WC_Index;
166 u8 WC_Entry_Value;
167 u32 RC_Index;
168 u16 RC_Entry_Value;
169 };
170
171 #pragma pack(pop)
172
173 struct BTableChangesDelta *p_BTableChangesDelta;
174 #endif
175
176
177 #define MARK_BLOCK_AS_BAD(blocknode) (blocknode |= BAD_BLOCK)
178 #define MARK_BLK_AS_DISCARD(blk) (blk = (blk & ~SPARE_BLOCK) | DISCARD_BLOCK)
179
180 #define FTL_Get_LBAPBA_Table_Mem_Size_Bytes() (DeviceInfo.wDataBlockNum *\
181 sizeof(u32))
182 #define FTL_Get_WearCounter_Table_Mem_Size_Bytes() (DeviceInfo.wDataBlockNum *\
183 sizeof(u8))
184 #define FTL_Get_ReadCounter_Table_Mem_Size_Bytes() (DeviceInfo.wDataBlockNum *\
185 sizeof(u16))
186 #if SUPPORT_LARGE_BLOCKNUM
187 #define FTL_Get_LBAPBA_Table_Flash_Size_Bytes() (DeviceInfo.wDataBlockNum *\
188 sizeof(u8) * 3)
189 #else
190 #define FTL_Get_LBAPBA_Table_Flash_Size_Bytes() (DeviceInfo.wDataBlockNum *\
191 sizeof(u16))
192 #endif
193 #define FTL_Get_WearCounter_Table_Flash_Size_Bytes \
194 FTL_Get_WearCounter_Table_Mem_Size_Bytes
195 #define FTL_Get_ReadCounter_Table_Flash_Size_Bytes \
196 FTL_Get_ReadCounter_Table_Mem_Size_Bytes
197
198 static u32 FTL_Get_Block_Table_Flash_Size_Bytes(void)
199 {
200 u32 byte_num;
201
202 if (DeviceInfo.MLCDevice) {
203 byte_num = FTL_Get_LBAPBA_Table_Flash_Size_Bytes() +
204 DeviceInfo.wDataBlockNum * sizeof(u8) +
205 DeviceInfo.wDataBlockNum * sizeof(u16);
206 } else {
207 byte_num = FTL_Get_LBAPBA_Table_Flash_Size_Bytes() +
208 DeviceInfo.wDataBlockNum * sizeof(u8);
209 }
210
211 byte_num += 4 * sizeof(u8);
212
213 return byte_num;
214 }
215
216 static u16 FTL_Get_Block_Table_Flash_Size_Pages(void)
217 {
218 return (u16)FTL_Get_Page_Num(FTL_Get_Block_Table_Flash_Size_Bytes());
219 }
220
221 static int FTL_Copy_Block_Table_To_Flash(u8 *flashBuf, u32 sizeToTx,
222 u32 sizeTxed)
223 {
224 u32 wBytesCopied, blk_tbl_size, wBytes;
225 u32 *pbt = (u32 *)g_pBlockTable;
226
227 blk_tbl_size = FTL_Get_LBAPBA_Table_Flash_Size_Bytes();
228 for (wBytes = 0;
229 (wBytes < sizeToTx) && ((wBytes + sizeTxed) < blk_tbl_size);
230 wBytes++) {
231 #if SUPPORT_LARGE_BLOCKNUM
232 flashBuf[wBytes] = (u8)(pbt[(wBytes + sizeTxed) / 3]
233 >> (((wBytes + sizeTxed) % 3) ?
234 ((((wBytes + sizeTxed) % 3) == 2) ? 0 : 8) : 16)) & 0xFF;
235 #else
236 flashBuf[wBytes] = (u8)(pbt[(wBytes + sizeTxed) / 2]
237 >> (((wBytes + sizeTxed) % 2) ? 0 : 8)) & 0xFF;
238 #endif
239 }
240
241 sizeTxed = (sizeTxed > blk_tbl_size) ? (sizeTxed - blk_tbl_size) : 0;
242 blk_tbl_size = FTL_Get_WearCounter_Table_Flash_Size_Bytes();
243 wBytesCopied = wBytes;
244 wBytes = ((blk_tbl_size - sizeTxed) > (sizeToTx - wBytesCopied)) ?
245 (sizeToTx - wBytesCopied) : (blk_tbl_size - sizeTxed);
246 memcpy(flashBuf + wBytesCopied, g_pWearCounter + sizeTxed, wBytes);
247
248 sizeTxed = (sizeTxed > blk_tbl_size) ? (sizeTxed - blk_tbl_size) : 0;
249
250 if (DeviceInfo.MLCDevice) {
251 blk_tbl_size = FTL_Get_ReadCounter_Table_Flash_Size_Bytes();
252 wBytesCopied += wBytes;
253 for (wBytes = 0; ((wBytes + wBytesCopied) < sizeToTx) &&
254 ((wBytes + sizeTxed) < blk_tbl_size); wBytes++)
255 flashBuf[wBytes + wBytesCopied] =
256 (g_pReadCounter[(wBytes + sizeTxed) / 2] >>
257 (((wBytes + sizeTxed) % 2) ? 0 : 8)) & 0xFF;
258 }
259
260 return wBytesCopied + wBytes;
261 }
262
263 static int FTL_Copy_Block_Table_From_Flash(u8 *flashBuf,
264 u32 sizeToTx, u32 sizeTxed)
265 {
266 u32 wBytesCopied, blk_tbl_size, wBytes;
267 u32 *pbt = (u32 *)g_pBlockTable;
268
269 blk_tbl_size = FTL_Get_LBAPBA_Table_Flash_Size_Bytes();
270 for (wBytes = 0; (wBytes < sizeToTx) &&
271 ((wBytes + sizeTxed) < blk_tbl_size); wBytes++) {
272 #if SUPPORT_LARGE_BLOCKNUM
273 if (!((wBytes + sizeTxed) % 3))
274 pbt[(wBytes + sizeTxed) / 3] = 0;
275 pbt[(wBytes + sizeTxed) / 3] |=
276 (flashBuf[wBytes] << (((wBytes + sizeTxed) % 3) ?
277 ((((wBytes + sizeTxed) % 3) == 2) ? 0 : 8) : 16));
278 #else
279 if (!((wBytes + sizeTxed) % 2))
280 pbt[(wBytes + sizeTxed) / 2] = 0;
281 pbt[(wBytes + sizeTxed) / 2] |=
282 (flashBuf[wBytes] << (((wBytes + sizeTxed) % 2) ?
283 0 : 8));
284 #endif
285 }
286
287 sizeTxed = (sizeTxed > blk_tbl_size) ? (sizeTxed - blk_tbl_size) : 0;
288 blk_tbl_size = FTL_Get_WearCounter_Table_Flash_Size_Bytes();
289 wBytesCopied = wBytes;
290 wBytes = ((blk_tbl_size - sizeTxed) > (sizeToTx - wBytesCopied)) ?
291 (sizeToTx - wBytesCopied) : (blk_tbl_size - sizeTxed);
292 memcpy(g_pWearCounter + sizeTxed, flashBuf + wBytesCopied, wBytes);
293 sizeTxed = (sizeTxed > blk_tbl_size) ? (sizeTxed - blk_tbl_size) : 0;
294
295 if (DeviceInfo.MLCDevice) {
296 wBytesCopied += wBytes;
297 blk_tbl_size = FTL_Get_ReadCounter_Table_Flash_Size_Bytes();
298 for (wBytes = 0; ((wBytes + wBytesCopied) < sizeToTx) &&
299 ((wBytes + sizeTxed) < blk_tbl_size); wBytes++) {
300 if (((wBytes + sizeTxed) % 2))
301 g_pReadCounter[(wBytes + sizeTxed) / 2] = 0;
302 g_pReadCounter[(wBytes + sizeTxed) / 2] |=
303 (flashBuf[wBytes] <<
304 (((wBytes + sizeTxed) % 2) ? 0 : 8));
305 }
306 }
307
308 return wBytesCopied+wBytes;
309 }
310
311 static int FTL_Insert_Block_Table_Signature(u8 *buf, u8 tag)
312 {
313 int i;
314
315 for (i = 0; i < BTSIG_BYTES; i++)
316 buf[BTSIG_OFFSET + i] =
317 ((tag + (i * BTSIG_DELTA) - FIRST_BT_ID) %
318 (1 + LAST_BT_ID-FIRST_BT_ID)) + FIRST_BT_ID;
319
320 return PASS;
321 }
322
323 static int FTL_Extract_Block_Table_Tag(u8 *buf, u8 **tagarray)
324 {
325 static u8 tag[BTSIG_BYTES >> 1];
326 int i, j, k, tagi, tagtemp, status;
327
328 *tagarray = (u8 *)tag;
329 tagi = 0;
330
331 for (i = 0; i < (BTSIG_BYTES - 1); i++) {
332 for (j = i + 1; (j < BTSIG_BYTES) &&
333 (tagi < (BTSIG_BYTES >> 1)); j++) {
334 tagtemp = buf[BTSIG_OFFSET + j] -
335 buf[BTSIG_OFFSET + i];
336 if (tagtemp && !(tagtemp % BTSIG_DELTA)) {
337 tagtemp = (buf[BTSIG_OFFSET + i] +
338 (1 + LAST_BT_ID - FIRST_BT_ID) -
339 (i * BTSIG_DELTA)) %
340 (1 + LAST_BT_ID - FIRST_BT_ID);
341 status = FAIL;
342 for (k = 0; k < tagi; k++) {
343 if (tagtemp == tag[k])
344 status = PASS;
345 }
346
347 if (status == FAIL) {
348 tag[tagi++] = tagtemp;
349 i = (j == (i + 1)) ? i + 1 : i;
350 j = (j == (i + 1)) ? i + 1 : i;
351 }
352 }
353 }
354 }
355
356 return tagi;
357 }
358
359
360 static int FTL_Execute_SPL_Recovery(void)
361 {
362 u32 j, block, blks;
363 u32 *pbt = (u32 *)g_pBlockTable;
364 int ret;
365
366 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
367 __FILE__, __LINE__, __func__);
368
369 blks = DeviceInfo.wSpectraEndBlock - DeviceInfo.wSpectraStartBlock;
370 for (j = 0; j <= blks; j++) {
371 block = (pbt[j]);
372 if (((block & BAD_BLOCK) != BAD_BLOCK) &&
373 ((block & SPARE_BLOCK) == SPARE_BLOCK)) {
374 ret = GLOB_LLD_Erase_Block(block & ~BAD_BLOCK);
375 if (FAIL == ret) {
376 nand_dbg_print(NAND_DBG_WARN,
377 "NAND Program fail in %s, Line %d, "
378 "Function: %s, new Bad Block %d "
379 "generated!\n",
380 __FILE__, __LINE__, __func__,
381 (int)(block & ~BAD_BLOCK));
382 MARK_BLOCK_AS_BAD(pbt[j]);
383 }
384 }
385 }
386
387 return PASS;
388 }
389
390 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
391 * Function: GLOB_FTL_IdentifyDevice
392 * Inputs: pointer to identify data structure
393 * Outputs: PASS / FAIL
394 * Description: the identify data structure is filled in with
395 * information for the block driver.
396 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
397 int GLOB_FTL_IdentifyDevice(struct spectra_indentfy_dev_tag *dev_data)
398 {
399 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
400 __FILE__, __LINE__, __func__);
401
402 dev_data->NumBlocks = DeviceInfo.wTotalBlocks;
403 dev_data->PagesPerBlock = DeviceInfo.wPagesPerBlock;
404 dev_data->PageDataSize = DeviceInfo.wPageDataSize;
405 dev_data->wECCBytesPerSector = DeviceInfo.wECCBytesPerSector;
406 dev_data->wDataBlockNum = DeviceInfo.wDataBlockNum;
407
408 return PASS;
409 }
410
411 /* ..... */
412 static int allocate_memory(void)
413 {
414 u32 block_table_size, page_size, block_size, mem_size;
415 u32 total_bytes = 0;
416 int i;
417 #if CMD_DMA
418 int j;
419 #endif
420
421 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
422 __FILE__, __LINE__, __func__);
423
424 page_size = DeviceInfo.wPageSize;
425 block_size = DeviceInfo.wPagesPerBlock * DeviceInfo.wPageDataSize;
426
427 block_table_size = DeviceInfo.wDataBlockNum *
428 (sizeof(u32) + sizeof(u8) + sizeof(u16));
429 block_table_size += (DeviceInfo.wPageDataSize -
430 (block_table_size % DeviceInfo.wPageDataSize)) %
431 DeviceInfo.wPageDataSize;
432
433 /* Malloc memory for block tables */
434 g_pBlockTable = kmalloc(block_table_size, GFP_ATOMIC);
435 if (!g_pBlockTable)
436 goto block_table_fail;
437 memset(g_pBlockTable, 0, block_table_size);
438 total_bytes += block_table_size;
439
440 g_pWearCounter = (u8 *)(g_pBlockTable +
441 DeviceInfo.wDataBlockNum * sizeof(u32));
442
443 if (DeviceInfo.MLCDevice)
444 g_pReadCounter = (u16 *)(g_pBlockTable +
445 DeviceInfo.wDataBlockNum *
446 (sizeof(u32) + sizeof(u8)));
447
448 /* Malloc memory and init for cache items */
449 for (i = 0; i < CACHE_ITEM_NUM; i++) {
450 Cache.array[i].address = NAND_CACHE_INIT_ADDR;
451 Cache.array[i].use_cnt = 0;
452 Cache.array[i].changed = CLEAR;
453 Cache.array[i].buf = kmalloc(Cache.cache_item_size,
454 GFP_ATOMIC);
455 if (!Cache.array[i].buf)
456 goto cache_item_fail;
457 memset(Cache.array[i].buf, 0, Cache.cache_item_size);
458 total_bytes += Cache.cache_item_size;
459 }
460
461 /* Malloc memory for IPF */
462 g_pIPF = kmalloc(page_size, GFP_ATOMIC);
463 if (!g_pIPF)
464 goto ipf_fail;
465 memset(g_pIPF, 0, page_size);
466 total_bytes += page_size;
467
468 /* Malloc memory for data merging during Level2 Cache flush */
469 cache_l2_page_buf = kmalloc(page_size, GFP_ATOMIC);
470 if (!cache_l2_page_buf)
471 goto cache_l2_page_buf_fail;
472 memset(cache_l2_page_buf, 0xff, page_size);
473 total_bytes += page_size;
474
475 cache_l2_blk_buf = kmalloc(block_size, GFP_ATOMIC);
476 if (!cache_l2_blk_buf)
477 goto cache_l2_blk_buf_fail;
478 memset(cache_l2_blk_buf, 0xff, block_size);
479 total_bytes += block_size;
480
481 /* Malloc memory for temp buffer */
482 g_pTempBuf = kmalloc(Cache.cache_item_size, GFP_ATOMIC);
483 if (!g_pTempBuf)
484 goto Temp_buf_fail;
485 memset(g_pTempBuf, 0, Cache.cache_item_size);
486 total_bytes += Cache.cache_item_size;
487
488 /* Malloc memory for block table blocks */
489 mem_size = (1 + LAST_BT_ID - FIRST_BT_ID) * sizeof(u32);
490 g_pBTBlocks = kmalloc(mem_size, GFP_ATOMIC);
491 if (!g_pBTBlocks)
492 goto bt_blocks_fail;
493 memset(g_pBTBlocks, 0xff, mem_size);
494 total_bytes += mem_size;
495
496 /* Malloc memory for function FTL_Check_Block_Table */
497 flag_check_blk_table = kmalloc(DeviceInfo.wDataBlockNum, GFP_ATOMIC);
498 if (!flag_check_blk_table)
499 goto flag_check_blk_table_fail;
500 total_bytes += DeviceInfo.wDataBlockNum;
501
502 /* Malloc memory for function FTL_Search_Block_Table_IN_Block */
503 tmp_buf_search_bt_in_block = kmalloc(page_size, GFP_ATOMIC);
504 if (!tmp_buf_search_bt_in_block)
505 goto tmp_buf_search_bt_in_block_fail;
506 memset(tmp_buf_search_bt_in_block, 0xff, page_size);
507 total_bytes += page_size;
508
509 mem_size = DeviceInfo.wPageSize - DeviceInfo.wPageDataSize;
510 spare_buf_search_bt_in_block = kmalloc(mem_size, GFP_ATOMIC);
511 if (!spare_buf_search_bt_in_block)
512 goto spare_buf_search_bt_in_block_fail;
513 memset(spare_buf_search_bt_in_block, 0xff, mem_size);
514 total_bytes += mem_size;
515
516 spare_buf_bt_search_bt_in_block = kmalloc(mem_size, GFP_ATOMIC);
517 if (!spare_buf_bt_search_bt_in_block)
518 goto spare_buf_bt_search_bt_in_block_fail;
519 memset(spare_buf_bt_search_bt_in_block, 0xff, mem_size);
520 total_bytes += mem_size;
521
522 /* Malloc memory for function FTL_Read_Block_Table */
523 tmp_buf1_read_blk_table = kmalloc(page_size, GFP_ATOMIC);
524 if (!tmp_buf1_read_blk_table)
525 goto tmp_buf1_read_blk_table_fail;
526 memset(tmp_buf1_read_blk_table, 0xff, page_size);
527 total_bytes += page_size;
528
529 tmp_buf2_read_blk_table = kmalloc(page_size, GFP_ATOMIC);
530 if (!tmp_buf2_read_blk_table)
531 goto tmp_buf2_read_blk_table_fail;
532 memset(tmp_buf2_read_blk_table, 0xff, page_size);
533 total_bytes += page_size;
534
535 /* Malloc memory for function FTL_Static_Wear_Leveling */
536 flags_static_wear_leveling = kmalloc(DeviceInfo.wDataBlockNum,
537 GFP_ATOMIC);
538 if (!flags_static_wear_leveling)
539 goto flags_static_wear_leveling_fail;
540 total_bytes += DeviceInfo.wDataBlockNum;
541
542 /* Malloc memory for function FTL_Write_Block_Table_Data */
543 if (FTL_Get_Block_Table_Flash_Size_Pages() > 3)
544 mem_size = FTL_Get_Block_Table_Flash_Size_Bytes() -
545 2 * DeviceInfo.wPageSize;
546 else
547 mem_size = DeviceInfo.wPageSize;
548 tmp_buf_write_blk_table_data = kmalloc(mem_size, GFP_ATOMIC);
549 if (!tmp_buf_write_blk_table_data)
550 goto tmp_buf_write_blk_table_data_fail;
551 memset(tmp_buf_write_blk_table_data, 0xff, mem_size);
552 total_bytes += mem_size;
553
554 /* Malloc memory for function FTL_Read_Disturbance */
555 tmp_buf_read_disturbance = kmalloc(block_size, GFP_ATOMIC);
556 if (!tmp_buf_read_disturbance)
557 goto tmp_buf_read_disturbance_fail;
558 memset(tmp_buf_read_disturbance, 0xff, block_size);
559 total_bytes += block_size;
560
561 /* Alloc mem for function NAND_Read_Page_Main_Spare of lld_nand.c */
562 buf_read_page_main_spare = kmalloc(DeviceInfo.wPageSize, GFP_ATOMIC);
563 if (!buf_read_page_main_spare)
564 goto buf_read_page_main_spare_fail;
565 total_bytes += DeviceInfo.wPageSize;
566
567 /* Alloc mem for function NAND_Write_Page_Main_Spare of lld_nand.c */
568 buf_write_page_main_spare = kmalloc(DeviceInfo.wPageSize, GFP_ATOMIC);
569 if (!buf_write_page_main_spare)
570 goto buf_write_page_main_spare_fail;
571 total_bytes += DeviceInfo.wPageSize;
572
573 /* Alloc mem for function NAND_Read_Page_Spare of lld_nand.c */
574 buf_read_page_spare = kmalloc(DeviceInfo.wPageSpareSize, GFP_ATOMIC);
575 if (!buf_read_page_spare)
576 goto buf_read_page_spare_fail;
577 memset(buf_read_page_spare, 0xff, DeviceInfo.wPageSpareSize);
578 total_bytes += DeviceInfo.wPageSpareSize;
579
580 /* Alloc mem for function NAND_Get_Bad_Block of lld_nand.c */
581 buf_get_bad_block = kmalloc(DeviceInfo.wPageSpareSize, GFP_ATOMIC);
582 if (!buf_get_bad_block)
583 goto buf_get_bad_block_fail;
584 memset(buf_get_bad_block, 0xff, DeviceInfo.wPageSpareSize);
585 total_bytes += DeviceInfo.wPageSpareSize;
586
587 #if CMD_DMA
588 g_temp_buf = kmalloc(block_size, GFP_ATOMIC);
589 if (!g_temp_buf)
590 goto temp_buf_fail;
591 memset(g_temp_buf, 0xff, block_size);
592 total_bytes += block_size;
593
594 /* Malloc memory for copy of block table used in CDMA mode */
595 g_pBTStartingCopy = kmalloc(block_table_size, GFP_ATOMIC);
596 if (!g_pBTStartingCopy)
597 goto bt_starting_copy;
598 memset(g_pBTStartingCopy, 0, block_table_size);
599 total_bytes += block_table_size;
600
601 g_pWearCounterCopy = (u8 *)(g_pBTStartingCopy +
602 DeviceInfo.wDataBlockNum * sizeof(u32));
603
604 if (DeviceInfo.MLCDevice)
605 g_pReadCounterCopy = (u16 *)(g_pBTStartingCopy +
606 DeviceInfo.wDataBlockNum *
607 (sizeof(u32) + sizeof(u8)));
608
609 /* Malloc memory for block table copies */
610 mem_size = 5 * DeviceInfo.wDataBlockNum * sizeof(u32) +
611 5 * DeviceInfo.wDataBlockNum * sizeof(u8);
612 if (DeviceInfo.MLCDevice)
613 mem_size += 5 * DeviceInfo.wDataBlockNum * sizeof(u16);
614 g_pBlockTableCopies = kmalloc(mem_size, GFP_ATOMIC);
615 if (!g_pBlockTableCopies)
616 goto blk_table_copies_fail;
617 memset(g_pBlockTableCopies, 0, mem_size);
618 total_bytes += mem_size;
619 g_pNextBlockTable = g_pBlockTableCopies;
620
621 /* Malloc memory for Block Table Delta */
622 mem_size = MAX_DESCS * sizeof(struct BTableChangesDelta);
623 g_pBTDelta = kmalloc(mem_size, GFP_ATOMIC);
624 if (!g_pBTDelta)
625 goto bt_delta_fail;
626 memset(g_pBTDelta, 0, mem_size);
627 total_bytes += mem_size;
628 g_pBTDelta_Free = g_pBTDelta;
629
630 /* Malloc memory for Copy Back Buffers */
631 for (j = 0; j < COPY_BACK_BUF_NUM; j++) {
632 cp_back_buf_copies[j] = kmalloc(block_size, GFP_ATOMIC);
633 if (!cp_back_buf_copies[j])
634 goto cp_back_buf_copies_fail;
635 memset(cp_back_buf_copies[j], 0, block_size);
636 total_bytes += block_size;
637 }
638 cp_back_buf_idx = 0;
639
640 /* Malloc memory for pending commands list */
641 mem_size = sizeof(struct pending_cmd) * MAX_DESCS;
642 info.pcmds = kzalloc(mem_size, GFP_KERNEL);
643 if (!info.pcmds)
644 goto pending_cmds_buf_fail;
645 total_bytes += mem_size;
646
647 /* Malloc memory for CDMA descripter table */
648 mem_size = sizeof(struct cdma_descriptor) * MAX_DESCS;
649 info.cdma_desc_buf = kzalloc(mem_size, GFP_KERNEL);
650 if (!info.cdma_desc_buf)
651 goto cdma_desc_buf_fail;
652 total_bytes += mem_size;
653
654 /* Malloc memory for Memcpy descripter table */
655 mem_size = sizeof(struct memcpy_descriptor) * MAX_DESCS;
656 info.memcp_desc_buf = kzalloc(mem_size, GFP_KERNEL);
657 if (!info.memcp_desc_buf)
658 goto memcp_desc_buf_fail;
659 total_bytes += mem_size;
660 #endif
661
662 nand_dbg_print(NAND_DBG_WARN,
663 "Total memory allocated in FTL layer: %d\n", total_bytes);
664
665 return PASS;
666
667 #if CMD_DMA
668 memcp_desc_buf_fail:
669 kfree(info.cdma_desc_buf);
670 cdma_desc_buf_fail:
671 kfree(info.pcmds);
672 pending_cmds_buf_fail:
673 cp_back_buf_copies_fail:
674 j--;
675 for (; j >= 0; j--)
676 kfree(cp_back_buf_copies[j]);
677 kfree(g_pBTDelta);
678 bt_delta_fail:
679 kfree(g_pBlockTableCopies);
680 blk_table_copies_fail:
681 kfree(g_pBTStartingCopy);
682 bt_starting_copy:
683 kfree(g_temp_buf);
684 temp_buf_fail:
685 kfree(buf_get_bad_block);
686 #endif
687
688 buf_get_bad_block_fail:
689 kfree(buf_read_page_spare);
690 buf_read_page_spare_fail:
691 kfree(buf_write_page_main_spare);
692 buf_write_page_main_spare_fail:
693 kfree(buf_read_page_main_spare);
694 buf_read_page_main_spare_fail:
695 kfree(tmp_buf_read_disturbance);
696 tmp_buf_read_disturbance_fail:
697 kfree(tmp_buf_write_blk_table_data);
698 tmp_buf_write_blk_table_data_fail:
699 kfree(flags_static_wear_leveling);
700 flags_static_wear_leveling_fail:
701 kfree(tmp_buf2_read_blk_table);
702 tmp_buf2_read_blk_table_fail:
703 kfree(tmp_buf1_read_blk_table);
704 tmp_buf1_read_blk_table_fail:
705 kfree(spare_buf_bt_search_bt_in_block);
706 spare_buf_bt_search_bt_in_block_fail:
707 kfree(spare_buf_search_bt_in_block);
708 spare_buf_search_bt_in_block_fail:
709 kfree(tmp_buf_search_bt_in_block);
710 tmp_buf_search_bt_in_block_fail:
711 kfree(flag_check_blk_table);
712 flag_check_blk_table_fail:
713 kfree(g_pBTBlocks);
714 bt_blocks_fail:
715 kfree(g_pTempBuf);
716 Temp_buf_fail:
717 kfree(cache_l2_blk_buf);
718 cache_l2_blk_buf_fail:
719 kfree(cache_l2_page_buf);
720 cache_l2_page_buf_fail:
721 kfree(g_pIPF);
722 ipf_fail:
723 cache_item_fail:
724 i--;
725 for (; i >= 0; i--)
726 kfree(Cache.array[i].buf);
727 kfree(g_pBlockTable);
728 block_table_fail:
729 printk(KERN_ERR "Failed to kmalloc memory in %s Line %d.\n",
730 __FILE__, __LINE__);
731
732 return -ENOMEM;
733 }
734
735 /* .... */
736 static int free_memory(void)
737 {
738 int i;
739
740 #if CMD_DMA
741 kfree(info.memcp_desc_buf);
742 kfree(info.cdma_desc_buf);
743 kfree(info.pcmds);
744 for (i = COPY_BACK_BUF_NUM - 1; i >= 0; i--)
745 kfree(cp_back_buf_copies[i]);
746 kfree(g_pBTDelta);
747 kfree(g_pBlockTableCopies);
748 kfree(g_pBTStartingCopy);
749 kfree(g_temp_buf);
750 kfree(buf_get_bad_block);
751 #endif
752 kfree(buf_read_page_spare);
753 kfree(buf_write_page_main_spare);
754 kfree(buf_read_page_main_spare);
755 kfree(tmp_buf_read_disturbance);
756 kfree(tmp_buf_write_blk_table_data);
757 kfree(flags_static_wear_leveling);
758 kfree(tmp_buf2_read_blk_table);
759 kfree(tmp_buf1_read_blk_table);
760 kfree(spare_buf_bt_search_bt_in_block);
761 kfree(spare_buf_search_bt_in_block);
762 kfree(tmp_buf_search_bt_in_block);
763 kfree(flag_check_blk_table);
764 kfree(g_pBTBlocks);
765 kfree(g_pTempBuf);
766 kfree(g_pIPF);
767 for (i = CACHE_ITEM_NUM - 1; i >= 0; i--)
768 kfree(Cache.array[i].buf);
769 kfree(g_pBlockTable);
770
771 return 0;
772 }
773
774 static void dump_cache_l2_table(void)
775 {
776 struct list_head *p;
777 struct spectra_l2_cache_list *pnd;
778 int n, i;
779
780 n = 0;
781 list_for_each(p, &cache_l2.table.list) {
782 pnd = list_entry(p, struct spectra_l2_cache_list, list);
783 nand_dbg_print(NAND_DBG_WARN, "dump_cache_l2_table node: %d, logical_blk_num: %d\n", n, pnd->logical_blk_num);
784 /*
785 for (i = 0; i < DeviceInfo.wPagesPerBlock; i++) {
786 if (pnd->pages_array[i] != MAX_U32_VALUE)
787 nand_dbg_print(NAND_DBG_WARN, " pages_array[%d]: 0x%x\n", i, pnd->pages_array[i]);
788 }
789 */
790 n++;
791 }
792 }
793
794 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
795 * Function: GLOB_FTL_Init
796 * Inputs: none
797 * Outputs: PASS=0 / FAIL=1
798 * Description: allocates the memory for cache array,
799 * important data structures
800 * clears the cache array
801 * reads the block table from flash into array
802 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
803 int GLOB_FTL_Init(void)
804 {
805 int i;
806
807 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
808 __FILE__, __LINE__, __func__);
809
810 Cache.pages_per_item = 1;
811 Cache.cache_item_size = 1 * DeviceInfo.wPageDataSize;
812
813 if (allocate_memory() != PASS)
814 return FAIL;
815
816 #if CMD_DMA
817 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
818 memcpy((void *)&cache_start_copy, (void *)&Cache,
819 sizeof(struct flash_cache_tag));
820 memset((void *)&int_cache, -1,
821 sizeof(struct flash_cache_delta_list_tag) *
822 (MAX_CHANS + MAX_DESCS));
823 #endif
824 ftl_cmd_cnt = 0;
825 #endif
826
827 if (FTL_Read_Block_Table() != PASS)
828 return FAIL;
829
830 /* Init the Level2 Cache data structure */
831 for (i = 0; i < BLK_NUM_FOR_L2_CACHE; i++)
832 cache_l2.blk_array[i] = MAX_U32_VALUE;
833 cache_l2.cur_blk_idx = 0;
834 cache_l2.cur_page_num = 0;
835 INIT_LIST_HEAD(&cache_l2.table.list);
836 cache_l2.table.logical_blk_num = MAX_U32_VALUE;
837
838 dump_cache_l2_table();
839
840 return 0;
841 }
842
843
844 #if CMD_DMA
845 #if 0
846 static void save_blk_table_changes(u16 idx)
847 {
848 u8 ftl_cmd;
849 u32 *pbt = (u32 *)g_pBTStartingCopy;
850
851 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
852 u16 id;
853 u8 cache_blks;
854
855 id = idx - MAX_CHANS;
856 if (int_cache[id].item != -1) {
857 cache_blks = int_cache[id].item;
858 cache_start_copy.array[cache_blks].address =
859 int_cache[id].cache.address;
860 cache_start_copy.array[cache_blks].changed =
861 int_cache[id].cache.changed;
862 }
863 #endif
864
865 ftl_cmd = p_BTableChangesDelta->ftl_cmd_cnt;
866
867 while (ftl_cmd <= PendingCMD[idx].Tag) {
868 if (p_BTableChangesDelta->ValidFields == 0x01) {
869 g_wBlockTableOffset =
870 p_BTableChangesDelta->g_wBlockTableOffset;
871 } else if (p_BTableChangesDelta->ValidFields == 0x0C) {
872 pbt[p_BTableChangesDelta->BT_Index] =
873 p_BTableChangesDelta->BT_Entry_Value;
874 debug_boundary_error(((
875 p_BTableChangesDelta->BT_Index)),
876 DeviceInfo.wDataBlockNum, 0);
877 } else if (p_BTableChangesDelta->ValidFields == 0x03) {
878 g_wBlockTableOffset =
879 p_BTableChangesDelta->g_wBlockTableOffset;
880 g_wBlockTableIndex =
881 p_BTableChangesDelta->g_wBlockTableIndex;
882 } else if (p_BTableChangesDelta->ValidFields == 0x30) {
883 g_pWearCounterCopy[p_BTableChangesDelta->WC_Index] =
884 p_BTableChangesDelta->WC_Entry_Value;
885 } else if ((DeviceInfo.MLCDevice) &&
886 (p_BTableChangesDelta->ValidFields == 0xC0)) {
887 g_pReadCounterCopy[p_BTableChangesDelta->RC_Index] =
888 p_BTableChangesDelta->RC_Entry_Value;
889 nand_dbg_print(NAND_DBG_DEBUG,
890 "In event status setting read counter "
891 "GLOB_ftl_cmd_cnt %u Count %u Index %u\n",
892 ftl_cmd,
893 p_BTableChangesDelta->RC_Entry_Value,
894 (unsigned int)p_BTableChangesDelta->RC_Index);
895 } else {
896 nand_dbg_print(NAND_DBG_DEBUG,
897 "This should never occur \n");
898 }
899 p_BTableChangesDelta += 1;
900 ftl_cmd = p_BTableChangesDelta->ftl_cmd_cnt;
901 }
902 }
903
904 static void discard_cmds(u16 n)
905 {
906 u32 *pbt = (u32 *)g_pBTStartingCopy;
907 u8 ftl_cmd;
908 unsigned long k;
909 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
910 u8 cache_blks;
911 u16 id;
912 #endif
913
914 if ((PendingCMD[n].CMD == WRITE_MAIN_CMD) ||
915 (PendingCMD[n].CMD == WRITE_MAIN_SPARE_CMD)) {
916 for (k = 0; k < DeviceInfo.wDataBlockNum; k++) {
917 if (PendingCMD[n].Block == (pbt[k] & (~BAD_BLOCK)))
918 MARK_BLK_AS_DISCARD(pbt[k]);
919 }
920 }
921
922 ftl_cmd = p_BTableChangesDelta->ftl_cmd_cnt;
923 while (ftl_cmd <= PendingCMD[n].Tag) {
924 p_BTableChangesDelta += 1;
925 ftl_cmd = p_BTableChangesDelta->ftl_cmd_cnt;
926 }
927
928 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
929 id = n - MAX_CHANS;
930
931 if (int_cache[id].item != -1) {
932 cache_blks = int_cache[id].item;
933 if (PendingCMD[n].CMD == MEMCOPY_CMD) {
934 if ((cache_start_copy.array[cache_blks].buf <=
935 PendingCMD[n].DataDestAddr) &&
936 ((cache_start_copy.array[cache_blks].buf +
937 Cache.cache_item_size) >
938 PendingCMD[n].DataDestAddr)) {
939 cache_start_copy.array[cache_blks].address =
940 NAND_CACHE_INIT_ADDR;
941 cache_start_copy.array[cache_blks].use_cnt =
942 0;
943 cache_start_copy.array[cache_blks].changed =
944 CLEAR;
945 }
946 } else {
947 cache_start_copy.array[cache_blks].address =
948 int_cache[id].cache.address;
949 cache_start_copy.array[cache_blks].changed =
950 int_cache[id].cache.changed;
951 }
952 }
953 #endif
954 }
955
956 static void process_cmd_pass(int *first_failed_cmd, u16 idx)
957 {
958 if (0 == *first_failed_cmd)
959 save_blk_table_changes(idx);
960 else
961 discard_cmds(idx);
962 }
963
964 static void process_cmd_fail_abort(int *first_failed_cmd,
965 u16 idx, int event)
966 {
967 u32 *pbt = (u32 *)g_pBTStartingCopy;
968 u8 ftl_cmd;
969 unsigned long i;
970 int erase_fail, program_fail;
971 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
972 u8 cache_blks;
973 u16 id;
974 #endif
975
976 if (0 == *first_failed_cmd)
977 *first_failed_cmd = PendingCMD[idx].SBDCmdIndex;
978
979 nand_dbg_print(NAND_DBG_DEBUG, "Uncorrectable error has occured "
980 "while executing %u Command %u accesing Block %u\n",
981 (unsigned int)p_BTableChangesDelta->ftl_cmd_cnt,
982 PendingCMD[idx].CMD,
983 (unsigned int)PendingCMD[idx].Block);
984
985 ftl_cmd = p_BTableChangesDelta->ftl_cmd_cnt;
986 while (ftl_cmd <= PendingCMD[idx].Tag) {
987 p_BTableChangesDelta += 1;
988 ftl_cmd = p_BTableChangesDelta->ftl_cmd_cnt;
989 }
990
991 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
992 id = idx - MAX_CHANS;
993
994 if (int_cache[id].item != -1) {
995 cache_blks = int_cache[id].item;
996 if ((PendingCMD[idx].CMD == WRITE_MAIN_CMD)) {
997 cache_start_copy.array[cache_blks].address =
998 int_cache[id].cache.address;
999 cache_start_copy.array[cache_blks].changed = SET;
1000 } else if ((PendingCMD[idx].CMD == READ_MAIN_CMD)) {
1001 cache_start_copy.array[cache_blks].address =
1002 NAND_CACHE_INIT_ADDR;
1003 cache_start_copy.array[cache_blks].use_cnt = 0;
1004 cache_start_copy.array[cache_blks].changed =
1005 CLEAR;
1006 } else if (PendingCMD[idx].CMD == ERASE_CMD) {
1007 /* ? */
1008 } else if (PendingCMD[idx].CMD == MEMCOPY_CMD) {
1009 /* ? */
1010 }
1011 }
1012 #endif
1013
1014 erase_fail = (event == EVENT_ERASE_FAILURE) &&
1015 (PendingCMD[idx].CMD == ERASE_CMD);
1016
1017 program_fail = (event == EVENT_PROGRAM_FAILURE) &&
1018 ((PendingCMD[idx].CMD == WRITE_MAIN_CMD) ||
1019 (PendingCMD[idx].CMD == WRITE_MAIN_SPARE_CMD));
1020
1021 if (erase_fail || program_fail) {
1022 for (i = 0; i < DeviceInfo.wDataBlockNum; i++) {
1023 if (PendingCMD[idx].Block ==
1024 (pbt[i] & (~BAD_BLOCK)))
1025 MARK_BLOCK_AS_BAD(pbt[i]);
1026 }
1027 }
1028 }
1029
1030 static void process_cmd(int *first_failed_cmd, u16 idx, int event)
1031 {
1032 u8 ftl_cmd;
1033 int cmd_match = 0;
1034
1035 if (p_BTableChangesDelta->ftl_cmd_cnt == PendingCMD[idx].Tag)
1036 cmd_match = 1;
1037
1038 if (PendingCMD[idx].Status == CMD_PASS) {
1039 process_cmd_pass(first_failed_cmd, idx);
1040 } else if ((PendingCMD[idx].Status == CMD_FAIL) ||
1041 (PendingCMD[idx].Status == CMD_ABORT)) {
1042 process_cmd_fail_abort(first_failed_cmd, idx, event);
1043 } else if ((PendingCMD[idx].Status == CMD_NOT_DONE) &&
1044 PendingCMD[idx].Tag) {
1045 nand_dbg_print(NAND_DBG_DEBUG,
1046 " Command no. %hu is not executed\n",
1047 (unsigned int)PendingCMD[idx].Tag);
1048 ftl_cmd = p_BTableChangesDelta->ftl_cmd_cnt;
1049 while (ftl_cmd <= PendingCMD[idx].Tag) {
1050 p_BTableChangesDelta += 1;
1051 ftl_cmd = p_BTableChangesDelta->ftl_cmd_cnt;
1052 }
1053 }
1054 }
1055 #endif
1056
1057 static void process_cmd(int *first_failed_cmd, u16 idx, int event)
1058 {
1059 printk(KERN_ERR "temporary workaround function. "
1060 "Should not be called! \n");
1061 }
1062
1063 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1064 * Function: GLOB_FTL_Event_Status
1065 * Inputs: none
1066 * Outputs: Event Code
1067 * Description: It is called by SBD after hardware interrupt signalling
1068 * completion of commands chain
1069 * It does following things
1070 * get event status from LLD
1071 * analyze command chain status
1072 * determine last command executed
1073 * analyze results
1074 * rebuild the block table in case of uncorrectable error
1075 * return event code
1076 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1077 int GLOB_FTL_Event_Status(int *first_failed_cmd)
1078 {
1079 int event_code = PASS;
1080 u16 i_P;
1081
1082 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1083 __FILE__, __LINE__, __func__);
1084
1085 *first_failed_cmd = 0;
1086
1087 event_code = GLOB_LLD_Event_Status();
1088
1089 switch (event_code) {
1090 case EVENT_PASS:
1091 nand_dbg_print(NAND_DBG_DEBUG, "Handling EVENT_PASS\n");
1092 break;
1093 case EVENT_UNCORRECTABLE_DATA_ERROR:
1094 nand_dbg_print(NAND_DBG_DEBUG, "Handling Uncorrectable ECC!\n");
1095 break;
1096 case EVENT_PROGRAM_FAILURE:
1097 case EVENT_ERASE_FAILURE:
1098 nand_dbg_print(NAND_DBG_WARN, "Handling Ugly case. "
1099 "Event code: 0x%x\n", event_code);
1100 p_BTableChangesDelta =
1101 (struct BTableChangesDelta *)g_pBTDelta;
1102 for (i_P = MAX_CHANS; i_P < (ftl_cmd_cnt + MAX_CHANS);
1103 i_P++)
1104 process_cmd(first_failed_cmd, i_P, event_code);
1105 memcpy(g_pBlockTable, g_pBTStartingCopy,
1106 DeviceInfo.wDataBlockNum * sizeof(u32));
1107 memcpy(g_pWearCounter, g_pWearCounterCopy,
1108 DeviceInfo.wDataBlockNum * sizeof(u8));
1109 if (DeviceInfo.MLCDevice)
1110 memcpy(g_pReadCounter, g_pReadCounterCopy,
1111 DeviceInfo.wDataBlockNum * sizeof(u16));
1112
1113 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
1114 memcpy((void *)&Cache, (void *)&cache_start_copy,
1115 sizeof(struct flash_cache_tag));
1116 memset((void *)&int_cache, -1,
1117 sizeof(struct flash_cache_delta_list_tag) *
1118 (MAX_DESCS + MAX_CHANS));
1119 #endif
1120 break;
1121 default:
1122 nand_dbg_print(NAND_DBG_WARN,
1123 "Handling unexpected event code - 0x%x\n",
1124 event_code);
1125 event_code = ERR;
1126 break;
1127 }
1128
1129 memcpy(g_pBTStartingCopy, g_pBlockTable,
1130 DeviceInfo.wDataBlockNum * sizeof(u32));
1131 memcpy(g_pWearCounterCopy, g_pWearCounter,
1132 DeviceInfo.wDataBlockNum * sizeof(u8));
1133 if (DeviceInfo.MLCDevice)
1134 memcpy(g_pReadCounterCopy, g_pReadCounter,
1135 DeviceInfo.wDataBlockNum * sizeof(u16));
1136
1137 g_pBTDelta_Free = g_pBTDelta;
1138 ftl_cmd_cnt = 0;
1139 g_pNextBlockTable = g_pBlockTableCopies;
1140 cp_back_buf_idx = 0;
1141
1142 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
1143 memcpy((void *)&cache_start_copy, (void *)&Cache,
1144 sizeof(struct flash_cache_tag));
1145 memset((void *)&int_cache, -1,
1146 sizeof(struct flash_cache_delta_list_tag) *
1147 (MAX_DESCS + MAX_CHANS));
1148 #endif
1149
1150 return event_code;
1151 }
1152
1153 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1154 * Function: glob_ftl_execute_cmds
1155 * Inputs: none
1156 * Outputs: none
1157 * Description: pass thru to LLD
1158 ***************************************************************/
1159 u16 glob_ftl_execute_cmds(void)
1160 {
1161 nand_dbg_print(NAND_DBG_TRACE,
1162 "glob_ftl_execute_cmds: ftl_cmd_cnt %u\n",
1163 (unsigned int)ftl_cmd_cnt);
1164 g_SBDCmdIndex = 0;
1165 return glob_lld_execute_cmds();
1166 }
1167
1168 #endif
1169
1170 #if !CMD_DMA
1171 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1172 * Function: GLOB_FTL_Read Immediate
1173 * Inputs: pointer to data
1174 * address of data
1175 * Outputs: PASS / FAIL
1176 * Description: Reads one page of data into RAM directly from flash without
1177 * using or disturbing cache.It is assumed this function is called
1178 * with CMD-DMA disabled.
1179 *****************************************************************/
1180 int GLOB_FTL_Read_Immediate(u8 *read_data, u64 addr)
1181 {
1182 int wResult = FAIL;
1183 u32 Block;
1184 u16 Page;
1185 u32 phy_blk;
1186 u32 *pbt = (u32 *)g_pBlockTable;
1187
1188 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1189 __FILE__, __LINE__, __func__);
1190
1191 Block = BLK_FROM_ADDR(addr);
1192 Page = PAGE_FROM_ADDR(addr, Block);
1193
1194 if (!IS_SPARE_BLOCK(Block))
1195 return FAIL;
1196
1197 phy_blk = pbt[Block];
1198 wResult = GLOB_LLD_Read_Page_Main(read_data, phy_blk, Page, 1);
1199
1200 if (DeviceInfo.MLCDevice) {
1201 g_pReadCounter[phy_blk - DeviceInfo.wSpectraStartBlock]++;
1202 if (g_pReadCounter[phy_blk - DeviceInfo.wSpectraStartBlock]
1203 >= MAX_READ_COUNTER)
1204 FTL_Read_Disturbance(phy_blk);
1205 if (g_cBlockTableStatus != IN_PROGRESS_BLOCK_TABLE) {
1206 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
1207 FTL_Write_IN_Progress_Block_Table_Page();
1208 }
1209 }
1210
1211 return wResult;
1212 }
1213 #endif
1214
1215 #ifdef SUPPORT_BIG_ENDIAN
1216 /*********************************************************************
1217 * Function: FTL_Invert_Block_Table
1218 * Inputs: none
1219 * Outputs: none
1220 * Description: Re-format the block table in ram based on BIG_ENDIAN and
1221 * LARGE_BLOCKNUM if necessary
1222 **********************************************************************/
1223 static void FTL_Invert_Block_Table(void)
1224 {
1225 u32 i;
1226 u32 *pbt = (u32 *)g_pBlockTable;
1227
1228 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1229 __FILE__, __LINE__, __func__);
1230
1231 #ifdef SUPPORT_LARGE_BLOCKNUM
1232 for (i = 0; i < DeviceInfo.wDataBlockNum; i++) {
1233 pbt[i] = INVERTUINT32(pbt[i]);
1234 g_pWearCounter[i] = INVERTUINT32(g_pWearCounter[i]);
1235 }
1236 #else
1237 for (i = 0; i < DeviceInfo.wDataBlockNum; i++) {
1238 pbt[i] = INVERTUINT16(pbt[i]);
1239 g_pWearCounter[i] = INVERTUINT16(g_pWearCounter[i]);
1240 }
1241 #endif
1242 }
1243 #endif
1244
1245 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1246 * Function: GLOB_FTL_Flash_Init
1247 * Inputs: none
1248 * Outputs: PASS=0 / FAIL=0x01 (based on read ID)
1249 * Description: The flash controller is initialized
1250 * The flash device is reset
1251 * Perform a flash READ ID command to confirm that a
1252 * valid device is attached and active.
1253 * The DeviceInfo structure gets filled in
1254 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1255 int GLOB_FTL_Flash_Init(void)
1256 {
1257 int status = FAIL;
1258
1259 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1260 __FILE__, __LINE__, __func__);
1261
1262 g_SBDCmdIndex = 0;
1263
1264 GLOB_LLD_Flash_Init();
1265
1266 status = GLOB_LLD_Read_Device_ID();
1267
1268 return status;
1269 }
1270
1271 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1272 * Inputs: none
1273 * Outputs: PASS=0 / FAIL=0x01 (based on read ID)
1274 * Description: The flash controller is released
1275 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1276 int GLOB_FTL_Flash_Release(void)
1277 {
1278 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1279 __FILE__, __LINE__, __func__);
1280
1281 return GLOB_LLD_Flash_Release();
1282 }
1283
1284
1285 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1286 * Function: GLOB_FTL_Cache_Release
1287 * Inputs: none
1288 * Outputs: none
1289 * Description: release all allocated memory in GLOB_FTL_Init
1290 * (allocated in GLOB_FTL_Init)
1291 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1292 void GLOB_FTL_Cache_Release(void)
1293 {
1294 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1295 __FILE__, __LINE__, __func__);
1296
1297 free_memory();
1298 }
1299
1300 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1301 * Function: FTL_Cache_If_Hit
1302 * Inputs: Page Address
1303 * Outputs: Block number/UNHIT BLOCK
1304 * Description: Determines if the addressed page is in cache
1305 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1306 static u16 FTL_Cache_If_Hit(u64 page_addr)
1307 {
1308 u16 item;
1309 u64 addr;
1310 int i;
1311
1312 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1313 __FILE__, __LINE__, __func__);
1314
1315 item = UNHIT_CACHE_ITEM;
1316 for (i = 0; i < CACHE_ITEM_NUM; i++) {
1317 addr = Cache.array[i].address;
1318 if ((page_addr >= addr) &&
1319 (page_addr < (addr + Cache.cache_item_size))) {
1320 item = i;
1321 break;
1322 }
1323 }
1324
1325 return item;
1326 }
1327
1328 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1329 * Function: FTL_Calculate_LRU
1330 * Inputs: None
1331 * Outputs: None
1332 * Description: Calculate the least recently block in a cache and record its
1333 * index in LRU field.
1334 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1335 static void FTL_Calculate_LRU(void)
1336 {
1337 u16 i, bCurrentLRU, bTempCount;
1338
1339 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1340 __FILE__, __LINE__, __func__);
1341
1342 bCurrentLRU = 0;
1343 bTempCount = MAX_WORD_VALUE;
1344
1345 for (i = 0; i < CACHE_ITEM_NUM; i++) {
1346 if (Cache.array[i].use_cnt < bTempCount) {
1347 bCurrentLRU = i;
1348 bTempCount = Cache.array[i].use_cnt;
1349 }
1350 }
1351
1352 Cache.LRU = bCurrentLRU;
1353 }
1354
1355 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1356 * Function: FTL_Cache_Read_Page
1357 * Inputs: pointer to read buffer, logical address and cache item number
1358 * Outputs: None
1359 * Description: Read the page from the cached block addressed by blocknumber
1360 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1361 static void FTL_Cache_Read_Page(u8 *data_buf, u64 logic_addr, u16 cache_item)
1362 {
1363 u8 *start_addr;
1364
1365 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1366 __FILE__, __LINE__, __func__);
1367
1368 start_addr = Cache.array[cache_item].buf;
1369 start_addr += (u32)(((logic_addr - Cache.array[cache_item].address) >>
1370 DeviceInfo.nBitsInPageDataSize) * DeviceInfo.wPageDataSize);
1371
1372 #if CMD_DMA
1373 GLOB_LLD_MemCopy_CMD(data_buf, start_addr,
1374 DeviceInfo.wPageDataSize, 0);
1375 ftl_cmd_cnt++;
1376 #else
1377 memcpy(data_buf, start_addr, DeviceInfo.wPageDataSize);
1378 #endif
1379
1380 if (Cache.array[cache_item].use_cnt < MAX_WORD_VALUE)
1381 Cache.array[cache_item].use_cnt++;
1382 }
1383
1384 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1385 * Function: FTL_Cache_Read_All
1386 * Inputs: pointer to read buffer,block address
1387 * Outputs: PASS=0 / FAIL =1
1388 * Description: It reads pages in cache
1389 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1390 static int FTL_Cache_Read_All(u8 *pData, u64 phy_addr)
1391 {
1392 int wResult = PASS;
1393 u32 Block;
1394 u32 lba;
1395 u16 Page;
1396 u16 PageCount;
1397 u32 *pbt = (u32 *)g_pBlockTable;
1398 u32 i;
1399
1400 Block = BLK_FROM_ADDR(phy_addr);
1401 Page = PAGE_FROM_ADDR(phy_addr, Block);
1402 PageCount = Cache.pages_per_item;
1403
1404 nand_dbg_print(NAND_DBG_DEBUG,
1405 "%s, Line %d, Function: %s, Block: 0x%x\n",
1406 __FILE__, __LINE__, __func__, Block);
1407
1408 lba = 0xffffffff;
1409 for (i = 0; i < DeviceInfo.wDataBlockNum; i++) {
1410 if ((pbt[i] & (~BAD_BLOCK)) == Block) {
1411 lba = i;
1412 if (IS_SPARE_BLOCK(i) || IS_BAD_BLOCK(i) ||
1413 IS_DISCARDED_BLOCK(i)) {
1414 /* Add by yunpeng -2008.12.3 */
1415 #if CMD_DMA
1416 GLOB_LLD_MemCopy_CMD(pData, g_temp_buf,
1417 PageCount * DeviceInfo.wPageDataSize, 0);
1418 ftl_cmd_cnt++;
1419 #else
1420 memset(pData, 0xFF,
1421 PageCount * DeviceInfo.wPageDataSize);
1422 #endif
1423 return wResult;
1424 } else {
1425 continue; /* break ?? */
1426 }
1427 }
1428 }
1429
1430 if (0xffffffff == lba)
1431 printk(KERN_ERR "FTL_Cache_Read_All: Block is not found in BT\n");
1432
1433 #if CMD_DMA
1434 wResult = GLOB_LLD_Read_Page_Main_cdma(pData, Block, Page,
1435 PageCount, LLD_CMD_FLAG_MODE_CDMA);
1436 if (DeviceInfo.MLCDevice) {
1437 g_pReadCounter[Block - DeviceInfo.wSpectraStartBlock]++;
1438 nand_dbg_print(NAND_DBG_DEBUG,
1439 "Read Counter modified in ftl_cmd_cnt %u"
1440 " Block %u Counter%u\n",
1441 ftl_cmd_cnt, (unsigned int)Block,
1442 g_pReadCounter[Block -
1443 DeviceInfo.wSpectraStartBlock]);
1444
1445 p_BTableChangesDelta =
1446 (struct BTableChangesDelta *)g_pBTDelta_Free;
1447 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
1448 p_BTableChangesDelta->ftl_cmd_cnt = ftl_cmd_cnt;
1449 p_BTableChangesDelta->RC_Index =
1450 Block - DeviceInfo.wSpectraStartBlock;
1451 p_BTableChangesDelta->RC_Entry_Value =
1452 g_pReadCounter[Block - DeviceInfo.wSpectraStartBlock];
1453 p_BTableChangesDelta->ValidFields = 0xC0;
1454
1455 ftl_cmd_cnt++;
1456
1457 if (g_pReadCounter[Block - DeviceInfo.wSpectraStartBlock] >=
1458 MAX_READ_COUNTER)
1459 FTL_Read_Disturbance(Block);
1460 if (g_cBlockTableStatus != IN_PROGRESS_BLOCK_TABLE) {
1461 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
1462 FTL_Write_IN_Progress_Block_Table_Page();
1463 }
1464 } else {
1465 ftl_cmd_cnt++;
1466 }
1467 #else
1468 wResult = GLOB_LLD_Read_Page_Main(pData, Block, Page, PageCount);
1469 if (wResult == FAIL)
1470 return wResult;
1471
1472 if (DeviceInfo.MLCDevice) {
1473 g_pReadCounter[Block - DeviceInfo.wSpectraStartBlock]++;
1474 if (g_pReadCounter[Block - DeviceInfo.wSpectraStartBlock] >=
1475 MAX_READ_COUNTER)
1476 FTL_Read_Disturbance(Block);
1477 if (g_cBlockTableStatus != IN_PROGRESS_BLOCK_TABLE) {
1478 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
1479 FTL_Write_IN_Progress_Block_Table_Page();
1480 }
1481 }
1482 #endif
1483 return wResult;
1484 }
1485
1486 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1487 * Function: FTL_Cache_Write_All
1488 * Inputs: pointer to cache in sys memory
1489 * address of free block in flash
1490 * Outputs: PASS=0 / FAIL=1
1491 * Description: writes all the pages of the block in cache to flash
1492 *
1493 * NOTE:need to make sure this works ok when cache is limited
1494 * to a partial block. This is where copy-back would be
1495 * activated. This would require knowing which pages in the
1496 * cached block are clean/dirty.Right now we only know if
1497 * the whole block is clean/dirty.
1498 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1499 static int FTL_Cache_Write_All(u8 *pData, u64 blk_addr)
1500 {
1501 u16 wResult = PASS;
1502 u32 Block;
1503 u16 Page;
1504 u16 PageCount;
1505
1506 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1507 __FILE__, __LINE__, __func__);
1508
1509 nand_dbg_print(NAND_DBG_DEBUG, "This block %d going to be written "
1510 "on %d\n", cache_block_to_write,
1511 (u32)(blk_addr >> DeviceInfo.nBitsInBlockDataSize));
1512
1513 Block = BLK_FROM_ADDR(blk_addr);
1514 Page = PAGE_FROM_ADDR(blk_addr, Block);
1515 PageCount = Cache.pages_per_item;
1516
1517 #if CMD_DMA
1518 if (FAIL == GLOB_LLD_Write_Page_Main_cdma(pData,
1519 Block, Page, PageCount)) {
1520 nand_dbg_print(NAND_DBG_WARN,
1521 "NAND Program fail in %s, Line %d, "
1522 "Function: %s, new Bad Block %d generated! "
1523 "Need Bad Block replacing.\n",
1524 __FILE__, __LINE__, __func__, Block);
1525 wResult = FAIL;
1526 }
1527 ftl_cmd_cnt++;
1528 #else
1529 if (FAIL == GLOB_LLD_Write_Page_Main(pData, Block, Page, PageCount)) {
1530 nand_dbg_print(NAND_DBG_WARN, "NAND Program fail in %s,"
1531 " Line %d, Function %s, new Bad Block %d generated!"
1532 "Need Bad Block replacing.\n",
1533 __FILE__, __LINE__, __func__, Block);
1534 wResult = FAIL;
1535 }
1536 #endif
1537 return wResult;
1538 }
1539
1540 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1541 * Function: FTL_Cache_Update_Block
1542 * Inputs: pointer to buffer,page address,block address
1543 * Outputs: PASS=0 / FAIL=1
1544 * Description: It updates the cache
1545 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1546 static int FTL_Cache_Update_Block(u8 *pData,
1547 u64 old_page_addr, u64 blk_addr)
1548 {
1549 int i, j;
1550 u8 *buf = pData;
1551 int wResult = PASS;
1552 int wFoundInCache;
1553 u64 page_addr;
1554 u64 addr;
1555 u64 old_blk_addr;
1556 u16 page_offset;
1557
1558 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1559 __FILE__, __LINE__, __func__);
1560
1561 old_blk_addr = (u64)(old_page_addr >>
1562 DeviceInfo.nBitsInBlockDataSize) * DeviceInfo.wBlockDataSize;
1563 page_offset = (u16)(GLOB_u64_Remainder(old_page_addr, 2) >>
1564 DeviceInfo.nBitsInPageDataSize);
1565
1566 for (i = 0; i < DeviceInfo.wPagesPerBlock; i += Cache.pages_per_item) {
1567 page_addr = old_blk_addr + i * DeviceInfo.wPageDataSize;
1568 if (i != page_offset) {
1569 wFoundInCache = FAIL;
1570 for (j = 0; j < CACHE_ITEM_NUM; j++) {
1571 addr = Cache.array[j].address;
1572 addr = FTL_Get_Physical_Block_Addr(addr) +
1573 GLOB_u64_Remainder(addr, 2);
1574 if ((addr >= page_addr) && addr <
1575 (page_addr + Cache.cache_item_size)) {
1576 wFoundInCache = PASS;
1577 buf = Cache.array[j].buf;
1578 Cache.array[j].changed = SET;
1579 #if CMD_DMA
1580 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
1581 int_cache[ftl_cmd_cnt].item = j;
1582 int_cache[ftl_cmd_cnt].cache.address =
1583 Cache.array[j].address;
1584 int_cache[ftl_cmd_cnt].cache.changed =
1585 Cache.array[j].changed;
1586 #endif
1587 #endif
1588 break;
1589 }
1590 }
1591 if (FAIL == wFoundInCache) {
1592 if (ERR == FTL_Cache_Read_All(g_pTempBuf,
1593 page_addr)) {
1594 wResult = FAIL;
1595 break;
1596 }
1597 buf = g_pTempBuf;
1598 }
1599 } else {
1600 buf = pData;
1601 }
1602
1603 if (FAIL == FTL_Cache_Write_All(buf,
1604 blk_addr + (page_addr - old_blk_addr))) {
1605 wResult = FAIL;
1606 break;
1607 }
1608 }
1609
1610 return wResult;
1611 }
1612
1613 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1614 * Function: FTL_Copy_Block
1615 * Inputs: source block address
1616 * Destination block address
1617 * Outputs: PASS=0 / FAIL=1
1618 * Description: used only for static wear leveling to move the block
1619 * containing static data to new blocks(more worn)
1620 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
1621 int FTL_Copy_Block(u64 old_blk_addr, u64 blk_addr)
1622 {
1623 int i, r1, r2, wResult = PASS;
1624
1625 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
1626 __FILE__, __LINE__, __func__);
1627
1628 for (i = 0; i < DeviceInfo.wPagesPerBlock; i += Cache.pages_per_item) {
1629 r1 = FTL_Cache_Read_All(g_pTempBuf, old_blk_addr +
1630 i * DeviceInfo.wPageDataSize);
1631 r2 = FTL_Cache_Write_All(g_pTempBuf, blk_addr +
1632 i * DeviceInfo.wPageDataSize);
1633 if ((ERR == r1) || (FAIL == r2)) {
1634 wResult = FAIL;
1635 break;
1636 }
1637 }
1638
1639 return wResult;
1640 }
1641
1642 /* Search the block table to find out the least wear block and then return it */
1643 static u32 find_least_worn_blk_for_l2_cache(void)
1644 {
1645 int i;
1646 u32 *pbt = (u32 *)g_pBlockTable;
1647 u8 least_wear_cnt = MAX_BYTE_VALUE;
1648 u32 least_wear_blk_idx = MAX_U32_VALUE;
1649 u32 phy_idx;
1650
1651 for (i = 0; i < DeviceInfo.wDataBlockNum; i++) {
1652 if (IS_SPARE_BLOCK(i)) {
1653 phy_idx = (u32)((~BAD_BLOCK) & pbt[i]);
1654 if (phy_idx > DeviceInfo.wSpectraEndBlock)
1655 printk(KERN_ERR "find_least_worn_blk_for_l2_cache: "
1656 "Too big phy block num (%d)\n", phy_idx);
1657 if (g_pWearCounter[phy_idx -DeviceInfo.wSpectraStartBlock] < least_wear_cnt) {
1658 least_wear_cnt = g_pWearCounter[phy_idx - DeviceInfo.wSpectraStartBlock];
1659 least_wear_blk_idx = i;
1660 }
1661 }
1662 }
1663
1664 nand_dbg_print(NAND_DBG_WARN,
1665 "find_least_worn_blk_for_l2_cache: "
1666 "find block %d with least worn counter (%d)\n",
1667 least_wear_blk_idx, least_wear_cnt);
1668
1669 return least_wear_blk_idx;
1670 }
1671
1672
1673
1674 /* Get blocks for Level2 Cache */
1675 static int get_l2_cache_blks(void)
1676 {
1677 int n;
1678 u32 blk;
1679 u32 *pbt = (u32 *)g_pBlockTable;
1680
1681 for (n = 0; n < BLK_NUM_FOR_L2_CACHE; n++) {
1682 blk = find_least_worn_blk_for_l2_cache();
1683 if (blk > DeviceInfo.wDataBlockNum) {
1684 nand_dbg_print(NAND_DBG_WARN,
1685 "find_least_worn_blk_for_l2_cache: "
1686 "No enough free NAND blocks (n: %d) for L2 Cache!\n", n);
1687 return FAIL;
1688 }
1689 /* Tag the free block as discard in block table */
1690 pbt[blk] = (pbt[blk] & (~BAD_BLOCK)) | DISCARD_BLOCK;
1691 /* Add the free block to the L2 Cache block array */
1692 cache_l2.blk_array[n] = pbt[blk] & (~BAD_BLOCK);
1693 }
1694
1695 return PASS;
1696 }
1697
1698 static int erase_l2_cache_blocks(void)
1699 {
1700 int i, ret = PASS;
1701 u32 pblk, lblk;
1702 u64 addr;
1703 u32 *pbt = (u32 *)g_pBlockTable;
1704
1705 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d, Function: %s\n",
1706 __FILE__, __LINE__, __func__);
1707
1708 for (i = 0; i < BLK_NUM_FOR_L2_CACHE; i++) {
1709 pblk = cache_l2.blk_array[i];
1710
1711 /* If the L2 cache block is invalid, then just skip it */
1712 if (MAX_U32_VALUE == pblk)
1713 continue;
1714
1715 BUG_ON(pblk > DeviceInfo.wSpectraEndBlock);
1716
1717 addr = (u64)pblk << DeviceInfo.nBitsInBlockDataSize;
1718 if (PASS == GLOB_FTL_Block_Erase(addr)) {
1719 /* Get logical block number of the erased block */
1720 lblk = FTL_Get_Block_Index(pblk);
1721 BUG_ON(BAD_BLOCK == lblk);
1722 /* Tag it as free in the block table */
1723 pbt[lblk] &= (u32)(~DISCARD_BLOCK);
1724 pbt[lblk] |= (u32)(SPARE_BLOCK);
1725 } else {
1726 MARK_BLOCK_AS_BAD(pbt[lblk]);
1727 ret = ERR;
1728 }
1729 }
1730
1731 return ret;
1732 }
1733
1734 /*
1735 * Merge the valid data page in the L2 cache blocks into NAND.
1736 */
1737 static int flush_l2_cache(void)
1738 {
1739 struct list_head *p;
1740 struct spectra_l2_cache_list *pnd, *tmp_pnd;
1741 u32 *pbt = (u32 *)g_pBlockTable;
1742 u32 phy_blk, l2_blk;
1743 u64 addr;
1744 u16 l2_page;
1745 int i, ret = PASS;
1746
1747 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d, Function: %s\n",
1748 __FILE__, __LINE__, __func__);
1749
1750 if (list_empty(&cache_l2.table.list)) /* No data to flush */
1751 return ret;
1752
1753 //dump_cache_l2_table();
1754
1755 if (IN_PROGRESS_BLOCK_TABLE != g_cBlockTableStatus) {
1756 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
1757 FTL_Write_IN_Progress_Block_Table_Page();
1758 }
1759
1760 list_for_each(p, &cache_l2.table.list) {
1761 pnd = list_entry(p, struct spectra_l2_cache_list, list);
1762 if (IS_SPARE_BLOCK(pnd->logical_blk_num) ||
1763 IS_BAD_BLOCK(pnd->logical_blk_num) ||
1764 IS_DISCARDED_BLOCK(pnd->logical_blk_num)) {
1765 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d\n", __FILE__, __LINE__);
1766 memset(cache_l2_blk_buf, 0xff, DeviceInfo.wPagesPerBlock * DeviceInfo.wPageDataSize);
1767 } else {
1768 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d\n", __FILE__, __LINE__);
1769 phy_blk = pbt[pnd->logical_blk_num] & (~BAD_BLOCK);
1770 ret = GLOB_LLD_Read_Page_Main(cache_l2_blk_buf,
1771 phy_blk, 0, DeviceInfo.wPagesPerBlock);
1772 if (ret == FAIL) {
1773 printk(KERN_ERR "Read NAND page fail in %s, Line %d\n", __FILE__, __LINE__);
1774 }
1775 }
1776
1777 for (i = 0; i < DeviceInfo.wPagesPerBlock; i++) {
1778 if (pnd->pages_array[i] != MAX_U32_VALUE) {
1779 l2_blk = cache_l2.blk_array[(pnd->pages_array[i] >> 16) & 0xffff];
1780 l2_page = pnd->pages_array[i] & 0xffff;
1781 ret = GLOB_LLD_Read_Page_Main(cache_l2_page_buf, l2_blk, l2_page, 1);
1782 if (ret == FAIL) {
1783 printk(KERN_ERR "Read NAND page fail in %s, Line %d\n", __FILE__, __LINE__);
1784 }
1785 memcpy(cache_l2_blk_buf + i * DeviceInfo.wPageDataSize, cache_l2_page_buf, DeviceInfo.wPageDataSize);
1786 }
1787 }
1788
1789 /* Find a free block and tag the original block as discarded */
1790 addr = (u64)pnd->logical_blk_num << DeviceInfo.nBitsInBlockDataSize;
1791 ret = FTL_Replace_Block(addr);
1792 if (ret == FAIL) {
1793 printk(KERN_ERR "FTL_Replace_Block fail in %s, Line %d\n", __FILE__, __LINE__);
1794 }
1795
1796 /* Write back the updated data into NAND */
1797 phy_blk = pbt[pnd->logical_blk_num] & (~BAD_BLOCK);
1798 if (FAIL == GLOB_LLD_Write_Page_Main(cache_l2_blk_buf, phy_blk, 0, DeviceInfo.wPagesPerBlock)) {
1799 nand_dbg_print(NAND_DBG_WARN,
1800 "Program NAND block %d fail in %s, Line %d\n",
1801 phy_blk, __FILE__, __LINE__);
1802 /* This may not be really a bad block. So just tag it as discarded. */
1803 /* Then it has a chance to be erased when garbage collection. */
1804 /* If it is really bad, then the erase will fail and it will be marked */
1805 /* as bad then. Otherwise it will be marked as free and can be used again */
1806 MARK_BLK_AS_DISCARD(pbt[pnd->logical_blk_num]);
1807 /* Find another free block and write it again */
1808 FTL_Replace_Block(addr);
1809 phy_blk = pbt[pnd->logical_blk_num] & (~BAD_BLOCK);
1810 if (FAIL == GLOB_LLD_Write_Page_Main(cache_l2_blk_buf, phy_blk, 0, DeviceInfo.wPagesPerBlock)) {
1811 printk(KERN_ERR "Failed to write back block %d when flush L2 cache."
1812 "Some data will be lost!\n", phy_blk);
1813 MARK_BLOCK_AS_BAD(pbt[pnd->logical_blk_num]);
1814 }
1815 } else {
1816 /* tag the new free block as used block */
1817 pbt[pnd->logical_blk_num] &= (~SPARE_BLOCK);
1818 }
1819 }
1820
1821 /* Destroy the L2 Cache table and free the memory of all nodes */
1822 list_for_each_entry_safe(pnd, tmp_pnd, &cache_l2.table.list, list) {
1823 list_del(&pnd->list);
1824 kfree(pnd);
1825 }
1826
1827 /* Erase discard L2 cache blocks */
1828 if (erase_l2_cache_blocks() != PASS)
1829 nand_dbg_print(NAND_DBG_WARN,
1830 " Erase L2 cache blocks error in %s, Line %d\n",
1831 __FILE__, __LINE__);
1832
1833 /* Init the Level2 Cache data structure */
1834 for (i = 0; i < BLK_NUM_FOR_L2_CACHE; i++)
1835 cache_l2.blk_array[i] = MAX_U32_VALUE;
1836 cache_l2.cur_blk_idx = 0;
1837 cache_l2.cur_page_num = 0;
1838 INIT_LIST_HEAD(&cache_l2.table.list);
1839 cache_l2.table.logical_blk_num = MAX_U32_VALUE;
1840
1841 return ret;
1842 }
1843
1844 /*
1845 * Write back a changed victim cache item to the Level2 Cache
1846 * and update the L2 Cache table to map the change.
1847 * If the L2 Cache is full, then start to do the L2 Cache flush.
1848 */
1849 static int write_back_to_l2_cache(u8 *buf, u64 logical_addr)
1850 {
1851 u32 logical_blk_num;
1852 u16 logical_page_num;
1853 struct list_head *p;
1854 struct spectra_l2_cache_list *pnd, *pnd_new;
1855 u32 node_size;
1856 int i, found;
1857
1858 nand_dbg_print(NAND_DBG_DEBUG, "%s, Line %d, Function: %s\n",
1859 __FILE__, __LINE__, __func__);
1860
1861 /*
1862 * If Level2 Cache table is empty, then it means either:
1863 * 1. This is the first time that the function called after FTL_init
1864 * or
1865 * 2. The Level2 Cache has just been flushed
1866 *
1867 * So, 'steal' some free blocks from NAND for L2 Cache using
1868 * by just mask them as discard in the block table
1869 */
1870 if (list_empty(&cache_l2.table.list)) {
1871 BUG_ON(cache_l2.cur_blk_idx != 0);
1872 BUG_ON(cache_l2.cur_page_num!= 0);
1873 BUG_ON(cache_l2.table.logical_blk_num != MAX_U32_VALUE);
1874 if (FAIL == get_l2_cache_blks()) {
1875 GLOB_FTL_Garbage_Collection();
1876 if (FAIL == get_l2_cache_blks()) {
1877 printk(KERN_ALERT "Fail to get L2 cache blks!\n");
1878 return FAIL;
1879 }
1880 }
1881 }
1882
1883 logical_blk_num = BLK_FROM_ADDR(logical_addr);
1884 logical_page_num = PAGE_FROM_ADDR(logical_addr, logical_blk_num);
1885 BUG_ON(logical_blk_num == MAX_U32_VALUE);
1886
1887 /* Write the cache item data into the current position of L2 Cache */
1888 #if CMD_DMA
1889 /*
1890 * TODO
1891 */
1892 #else
1893 if (FAIL == GLOB_LLD_Write_Page_Main(buf,
1894 cache_l2.blk_array[cache_l2.cur_blk_idx],
1895 cache_l2.cur_page_num, 1)) {
1896 nand_dbg_print(NAND_DBG_WARN, "NAND Program fail in "
1897 "%s, Line %d, new Bad Block %d generated!\n",
1898 __FILE__, __LINE__,
1899 cache_l2.blk_array[cache_l2.cur_blk_idx]);
1900
1901 /* TODO: tag the current block as bad and try again */
1902
1903 return FAIL;
1904 }
1905 #endif
1906
1907 /*
1908 * Update the L2 Cache table.
1909 *
1910 * First seaching in the table to see whether the logical block
1911 * has been mapped. If not, then kmalloc a new node for the
1912 * logical block, fill data, and then insert it to the list.
1913 * Otherwise, just update the mapped node directly.
1914 */
1915 found = 0;
1916 list_for_each(p, &cache_l2.table.list) {
1917 pnd = list_entry(p, struct spectra_l2_cache_list, list);
1918 if (pnd->logical_blk_num == logical_blk_num) {
1919 pnd->pages_array[logical_page_num] =
1920 (cache_l2.cur_blk_idx << 16) |
1921 cache_l2.cur_page_num;
1922 found = 1;
1923 break;
1924 }
1925 }
1926 if (!found) { /* Create new node for the logical block here */
1927
1928 /* The logical pages to physical pages map array is
1929 * located at the end of struct spectra_l2_cache_list.
1930 */
1931 node_size = sizeof(struct spectra_l2_cache_list) +
1932 sizeof(u32) * DeviceInfo.wPagesPerBlock;
1933 pnd_new = kmalloc(node_size, GFP_ATOMIC);
1934 if (!pnd_new) {
1935 printk(KERN_ERR "Failed to kmalloc in %s Line %d\n",
1936 __FILE__, __LINE__);
1937 /*
1938 * TODO: Need to flush all the L2 cache into NAND ASAP
1939 * since no memory available here
1940 */
1941 }
1942 pnd_new->logical_blk_num = logical_blk_num;
1943 for (i = 0; i < DeviceInfo.wPagesPerBlock; i++)
1944 pnd_new->pages_array[i] = MAX_U32_VALUE;
1945 pnd_new->pages_array[logical_page_num] =
1946 (cache_l2.cur_blk_idx << 16) | cache_l2.cur_page_num;
1947 list_add(&pnd_new->list, &cache_l2.table.list);
1948 }
1949
1950 /* Increasing the current position pointer of the L2 Cache */
1951 cache_l2.cur_page_num++;
1952 if (cache_l2.cur_page_num >= DeviceInfo.wPagesPerBlock) {
1953 cache_l2.cur_blk_idx++;
1954 if (cache_l2.cur_blk_idx >= BLK_NUM_FOR_L2_CACHE) {
1955 /* The L2 Cache is full. Need to flush it now */
1956 nand_dbg_print(NAND_DBG_WARN,
1957 "L2 Cache is full, will start to flush it\n");
1958 flush_l2_cache();
1959 } else {
1960 cache_l2.cur_page_num = 0;
1961 }
1962 }
1963
1964 return PASS;
1965 }
1966
1967 /*
1968 * Seach in the Level2 Cache table to find the cache item.
1969 * If find, read the data from the NAND page of L2 Cache,
1970 * Otherwise, return FAIL.
1971 */
1972 static int search_l2_cache(u8 *buf, u64 logical_addr)
1973 {
1974 u32 logical_blk_num;
1975 u16 logical_page_num;
1976 struct list_head *p;
1977 struct spectra_l2_cache_list *pnd;
1978 u32 tmp = MAX_U32_VALUE;
1979 u32 phy_blk;
1980 u16 phy_page;
1981 int ret = FAIL;
1982
1983 logical_blk_num = BLK_FROM_ADDR(logical_addr);
1984 logical_page_num = PAGE_FROM_ADDR(logical_addr, logical_blk_num);
1985
1986 list_for_each(p, &cache_l2.table.list) {
1987 pnd = list_entry(p, struct spectra_l2_cache_list, list);
1988 if (pnd->logical_blk_num == logical_blk_num) {
1989 tmp = pnd->pages_array[logical_page_num];
1990 break;
1991 }
1992 }
1993
1994 if (tmp != MAX_U32_VALUE) { /* Found valid map */
1995 phy_blk = cache_l2.blk_array[(tmp >> 16) & 0xFFFF];
1996 phy_page = tmp & 0xFFFF;
1997 #if CMD_DMA
1998 /* TODO */
1999 #else
2000 ret = GLOB_LLD_Read_Page_Main(buf, phy_blk, phy_page, 1);
2001 #endif
2002 }
2003
2004 return ret;
2005 }
2006
2007 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
2008 * Function: FTL_Cache_Write_Back
2009 * Inputs: pointer to data cached in sys memory
2010 * address of free block in flash
2011 * Outputs: PASS=0 / FAIL=1
2012 * Description: writes all the pages of Cache Block to flash
2013 *
2014 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
2015 static int FTL_Cache_Write_Back(u8 *pData, u64 blk_addr)
2016 {
2017 int i, j, iErase;
2018 u64 old_page_addr, addr, phy_addr;
2019 u32 *pbt = (u32 *)g_pBlockTable;
2020 u32 lba;
2021
2022 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
2023 __FILE__, __LINE__, __func__);
2024
2025 old_page_addr = FTL_Get_Physical_Block_Addr(blk_addr) +
2026 GLOB_u64_Remainder(blk_addr, 2);
2027
2028 iErase = (FAIL == FTL_Replace_Block(blk_addr)) ? PASS : FAIL;
2029
2030 pbt[BLK_FROM_ADDR(blk_addr)] &= (~SPARE_BLOCK);
2031
2032 #if CMD_DMA
2033 p_BTableChangesDelta = (struct BTableChangesDelta *)g_pBTDelta_Free;
2034 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
2035
2036 p_BTableChangesDelta->ftl_cmd_cnt = ftl_cmd_cnt;
2037 p_BTableChangesDelta->BT_Index = (u32)(blk_addr >>
2038 DeviceInfo.nBitsInBlockDataSize);
2039 p_BTableChangesDelta->BT_Entry_Value =
2040 pbt[(u32)(blk_addr >> DeviceInfo.nBitsInBlockDataSize)];
2041 p_BTableChangesDelta->ValidFields = 0x0C;
2042 #endif
2043
2044 if (IN_PROGRESS_BLOCK_TABLE != g_cBlockTableStatus) {
2045 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
2046 FTL_Write_IN_Progress_Block_Table_Page();
2047 }
2048
2049 for (i = 0; i < RETRY_TIMES; i++) {
2050 if (PASS == iErase) {
2051 phy_addr = FTL_Get_Physical_Block_Addr(blk_addr);
2052 if (FAIL == GLOB_FTL_Block_Erase(phy_addr)) {
2053 lba = BLK_FROM_ADDR(blk_addr);
2054 MARK_BLOCK_AS_BAD(pbt[lba]);
2055 i = RETRY_TIMES;
2056 break;
2057 }
2058 }
2059
2060 for (j = 0; j < CACHE_ITEM_NUM; j++) {
2061 addr = Cache.array[j].address;
2062 if ((addr <= blk_addr) &&
2063 ((addr + Cache.cache_item_size) > blk_addr))
2064 cache_block_to_write = j;
2065 }
2066
2067 phy_addr = FTL_Get_Physical_Block_Addr(blk_addr);
2068 if (PASS == FTL_Cache_Update_Block(pData,
2069 old_page_addr, phy_addr)) {
2070 cache_block_to_write = UNHIT_CACHE_ITEM;
2071 break;
2072 } else {
2073 iErase = PASS;
2074 }
2075 }
2076
2077 if (i >= RETRY_TIMES) {
2078 if (ERR == FTL_Flash_Error_Handle(pData,
2079 old_page_addr, blk_addr))
2080 return ERR;
2081 else
2082 return FAIL;
2083 }
2084
2085 return PASS;
2086 }
2087
2088 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
2089 * Function: FTL_Cache_Write_Page
2090 * Inputs: Pointer to buffer, page address, cache block number
2091 * Outputs: PASS=0 / FAIL=1
2092 * Description: It writes the data in Cache Block
2093 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
2094 static void FTL_Cache_Write_Page(u8 *pData, u64 page_addr,
2095 u8 cache_blk, u16 flag)
2096 {
2097 u8 *pDest;
2098 u64 addr;
2099
2100 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
2101 __FILE__, __LINE__, __func__);
2102
2103 addr = Cache.array[cache_blk].address;
2104 pDest = Cache.array[cache_blk].buf;
2105
2106 pDest += (unsigned long)(page_addr - addr);
2107 Cache.array[cache_blk].changed = SET;
2108 #if CMD_DMA
2109 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
2110 int_cache[ftl_cmd_cnt].item = cache_blk;
2111 int_cache[ftl_cmd_cnt].cache.address =
2112 Cache.array[cache_blk].address;
2113 int_cache[ftl_cmd_cnt].cache.changed =
2114 Cache.array[cache_blk].changed;
2115 #endif
2116 GLOB_LLD_MemCopy_CMD(pDest, pData, DeviceInfo.wPageDataSize, flag);
2117 ftl_cmd_cnt++;
2118 #else
2119 memcpy(pDest, pData, DeviceInfo.wPageDataSize);
2120 #endif
2121 if (Cache.array[cache_blk].use_cnt < MAX_WORD_VALUE)
2122 Cache.array[cache_blk].use_cnt++;
2123 }
2124
2125 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
2126 * Function: FTL_Cache_Write
2127 * Inputs: none
2128 * Outputs: PASS=0 / FAIL=1
2129 * Description: It writes least frequently used Cache block to flash if it
2130 * has been changed
2131 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
2132 static int FTL_Cache_Write(void)
2133 {
2134 int i, bResult = PASS;
2135 u16 bNO, least_count = 0xFFFF;
2136
2137 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
2138 __FILE__, __LINE__, __func__);
2139
2140 FTL_Calculate_LRU();
2141
2142 bNO = Cache.LRU;
2143 nand_dbg_print(NAND_DBG_DEBUG, "FTL_Cache_Write: "
2144 "Least used cache block is %d\n", bNO);
2145
2146 if (Cache.array[bNO].changed != SET)
2147 return bResult;
2148
2149 nand_dbg_print(NAND_DBG_DEBUG, "FTL_Cache_Write: Cache"
2150 " Block %d containing logical block %d is dirty\n",
2151 bNO,
2152 (u32)(Cache.array[bNO].address >>
2153 DeviceInfo.nBitsInBlockDataSize));
2154 #if CMD_DMA
2155 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
2156 int_cache[ftl_cmd_cnt].item = bNO;
2157 int_cache[ftl_cmd_cnt].cache.address =
2158 Cache.array[bNO].address;
2159 int_cache[ftl_cmd_cnt].cache.changed = CLEAR;
2160 #endif
2161 #endif
2162 bResult = write_back_to_l2_cache(Cache.array[bNO].buf,
2163 Cache.array[bNO].address);
2164 if (bResult != ERR)
2165 Cache.array[bNO].changed = CLEAR;
2166
2167 least_count = Cache.array[bNO].use_cnt;
2168
2169 for (i = 0; i < CACHE_ITEM_NUM; i++) {
2170 if (i == bNO)
2171 continue;
2172 if (Cache.array[i].use_cnt > 0)
2173 Cache.array[i].use_cnt -= least_count;
2174 }
2175
2176 return bResult;
2177 }
2178
2179 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
2180 * Function: FTL_Cache_Read
2181 * Inputs: Page address
2182 * Outputs: PASS=0 / FAIL=1
2183 * Description: It reads the block from device in Cache Block
2184 * Set the LRU count to 1
2185 * Mark the Cache Block as clean
2186 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
2187 static int FTL_Cache_Read(u64 logical_addr)
2188 {
2189 u64 item_addr, phy_addr;
2190 u16 num;
2191 int ret;
2192
2193 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
2194 __FILE__, __LINE__, __func__);
2195
2196 num = Cache.LRU; /* The LRU cache item will be overwritten */
2197
2198 item_addr = (u64)GLOB_u64_Div(logical_addr, Cache.cache_item_size) *
2199 Cache.cache_item_size;
2200 Cache.array[num].address = item_addr;
2201 Cache.array[num].use_cnt = 1;
2202 Cache.array[num].changed = CLEAR;
2203
2204 #if CMD_DMA
2205 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
2206 int_cache[ftl_cmd_cnt].item = num;
2207 int_cache[ftl_cmd_cnt].cache.address =
2208 Cache.array[num].address;
2209 int_cache[ftl_cmd_cnt].cache.changed =
2210 Cache.array[num].changed;
2211 #endif
2212 #endif
2213 /*
2214 * Search in L2 Cache. If hit, fill data into L1 Cache item buffer,
2215 * Otherwise, read it from NAND
2216 */
2217 ret = search_l2_cache(Cache.array[num].buf, logical_addr);
2218 if (PASS == ret) /* Hit in L2 Cache */
2219 return ret;
2220
2221 /* Compute the physical start address of NAND device according to */
2222 /* the logical start address of the cache item (LRU cache item) */
2223 phy_addr = FTL_Get_Physical_Block_Addr(item_addr) +
2224 GLOB_u64_Remainder(item_addr, 2);
2225
2226 return FTL_Cache_Read_All(Cache.array[num].buf, phy_addr);
2227 }
2228
2229 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
2230 * Function: FTL_Check_Block_Table
2231 * Inputs: ?
2232 * Outputs: PASS=0 / FAIL=1
2233 * Description: It checks the correctness of each block table entry
2234 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
2235 static int FTL_Check_Block_Table(int wOldTable)
2236 {
2237 u32 i;
2238 int wResult = PASS;
2239 u32 blk_idx;
2240 u32 *pbt = (u32 *)g_pBlockTable;
2241 u8 *pFlag = flag_check_blk_table;
2242
2243 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
2244 __FILE__, __LINE__, __func__);
2245
2246 if (NULL != pFlag) {
2247 memset(pFlag, FAIL, DeviceInfo.wDataBlockNum);
2248 for (i = 0; i < DeviceInfo.wDataBlockNum; i++) {
2249 blk_idx = (u32)(pbt[i] & (~BAD_BLOCK));
2250
2251 /*
2252 * 20081006/KBV - Changed to pFlag[i] reference
2253 * to avoid buffer overflow
2254 */
2255
2256 /*
2257 * 2008-10-20 Yunpeng Note: This change avoid
2258 * buffer overflow, but changed function of
2259 * the code, so it should be re-write later
2260 */
2261 if ((blk_idx > DeviceInfo.wSpectraEndBlock) ||
2262 PASS == pFlag[i]) {
2263 wResult = FAIL;
2264 break;
2265 } else {
2266 pFlag[i] = PASS;
2267 }
2268 }
2269 }
2270
2271 return wResult;
2272 }
2273
2274
2275 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
2276 * Function: FTL_Write_Block_Table
2277 * Inputs: flasg
2278 * Outputs: 0=Block Table was updated. No write done. 1=Block write needs to
2279 * happen. -1 Error
2280 * Description: It writes the block table
2281 * Block table always mapped to LBA 0 which inturn mapped
2282 * to any physical block
2283 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
2284 static int FTL_Write_Block_Table(int wForce)
2285 {
2286 u32 *pbt = (u32 *)g_pBlockTable;
2287 int wSuccess = PASS;
2288 u32 wTempBlockTableIndex;
2289 u16 bt_pages, new_bt_offset;
2290 u8 blockchangeoccured = 0;
2291
2292 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
2293 __FILE__, __LINE__, __func__);
2294
2295 bt_pages = FTL_Get_Block_Table_Flash_Size_Pages();
2296
2297 if (IN_PROGRESS_BLOCK_TABLE != g_cBlockTableStatus)
2298 return 0;
2299
2300 if (PASS == wForce) {
2301 g_wBlockTableOffset =
2302 (u16)(DeviceInfo.wPagesPerBlock - bt_pages);
2303 #if CMD_DMA
2304 p_BTableChangesDelta =
2305 (struct BTableChangesDelta *)g_pBTDelta_Free;
2306 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
2307
2308 p_BTableChangesDelta->ftl_cmd_cnt = ftl_cmd_cnt;
2309 p_BTableChangesDelta->g_wBlockTableOffset =
2310 g_wBlockTableOffset;
2311 p_BTableChangesDelta->ValidFields = 0x01;
2312 #endif
2313 }
2314
2315 nand_dbg_print(NAND_DBG_DEBUG,
2316 "Inside FTL_Write_Block_Table: block %d Page:%d\n",
2317 g_wBlockTableIndex, g_wBlockTableOffset);
2318
2319 do {
2320 new_bt_offset = g_wBlockTableOffset + bt_pages + 1;
2321 if ((0 == (new_bt_offset % DeviceInfo.wPagesPerBlock)) ||
2322 (new_bt_offset > DeviceInfo.wPagesPerBlock) ||
2323 (FAIL == wSuccess)) {
2324 wTempBlockTableIndex = FTL_Replace_Block_Table();
2325 if (BAD_BLOCK == wTempBlockTableIndex)
2326 return ERR;
2327 if (!blockchangeoccured) {
2328 bt_block_changed = 1;
2329 blockchangeoccured = 1;
2330 }
2331
2332 g_wBlockTableIndex = wTempBlockTableIndex;
2333 g_wBlockTableOffset = 0;
2334 pbt[BLOCK_TABLE_INDEX] = g_wBlockTableIndex;
2335 #if CMD_DMA
2336 p_BTableChangesDelta =
2337 (struct BTableChangesDelta *)g_pBTDelta_Free;
2338 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
2339
2340 p_BTableChangesDelta->ftl_cmd_cnt =
2341 ftl_cmd_cnt;
2342 p_BTableChangesDelta->g_wBlockTableOffset =
2343 g_wBlockTableOffset;
2344 p_BTableChangesDelta->g_wBlockTableIndex =
2345 g_wBlockTableIndex;
2346 p_BTableChangesDelta->ValidFields = 0x03;
2347
2348 p_BTableChangesDelta =
2349 (struct BTableChangesDelta *)g_pBTDelta_Free;
2350 g_pBTDelta_Free +=
2351 sizeof(struct BTableChangesDelta);
2352
2353 p_BTableChangesDelta->ftl_cmd_cnt =
2354 ftl_cmd_cnt;
2355 p_BTableChangesDelta->BT_Index =
2356 BLOCK_TABLE_INDEX;
2357 p_BTableChangesDelta->BT_Entry_Value =
2358 pbt[BLOCK_TABLE_INDEX];
2359 p_BTableChangesDelta->ValidFields = 0x0C;
2360 #endif
2361 }
2362
2363 wSuccess = FTL_Write_Block_Table_Data();
2364 if (FAIL == wSuccess)
2365 MARK_BLOCK_AS_BAD(pbt[BLOCK_TABLE_INDEX]);
2366 } while (FAIL == wSuccess);
2367
2368 g_cBlockTableStatus = CURRENT_BLOCK_TABLE;
2369
2370 return 1;
2371 }
2372
2373 /******************************************************************
2374 * Function: GLOB_FTL_Flash_Format
2375 * Inputs: none
2376 * Outputs: PASS
2377 * Description: The block table stores bad block info, including MDF+
2378 * blocks gone bad over the ages. Therefore, if we have a
2379 * block table in place, then use it to scan for bad blocks
2380 * If not, then scan for MDF.
2381 * Now, a block table will only be found if spectra was already
2382 * being used. For a fresh flash, we'll go thru scanning for
2383 * MDF. If spectra was being used, then there is a chance that
2384 * the MDF has been corrupted. Spectra avoids writing to the
2385 * first 2 bytes of the spare area to all pages in a block. This
2386 * covers all known flash devices. However, since flash
2387 * manufacturers have no standard of where the MDF is stored,
2388 * this cannot guarantee that the MDF is protected for future
2389 * devices too. The initial scanning for the block table assures
2390 * this. It is ok even if the block table is outdated, as all
2391 * we're looking for are bad block markers.
2392 * Use this when mounting a file system or starting a
2393 * new flash.
2394 *
2395 *********************************************************************/
2396 static int FTL_Format_Flash(u8 valid_block_table)
2397 {
2398 u32 i, j;
2399 u32 *pbt = (u32 *)g_pBlockTable;
2400 u32 tempNode;
2401 int ret;
2402
2403 #if CMD_DMA
2404 u32 *pbtStartingCopy = (u32 *)g_pBTStartingCopy;
2405 if (ftl_cmd_cnt)
2406 return FAIL;
2407 #endif
2408
2409 if (FAIL == FTL_Check_Block_Table(FAIL))
2410 valid_block_table = 0;
2411
2412 if (valid_block_table) {
2413 u8 switched = 1;
2414 u32 block, k;
2415
2416 k = DeviceInfo.wSpectraStartBlock;
2417 while (switched && (k < DeviceInfo.wSpectraEndBlock)) {
2418 switched = 0;
2419 k++;
2420 for (j = DeviceInfo.wSpectraStartBlock, i = 0;
2421 j <= DeviceInfo.wSpectraEndBlock;
2422 j++, i++) {
2423 block = (pbt[i] & ~BAD_BLOCK) -
2424 DeviceInfo.wSpectraStartBlock;
2425 if (block != i) {
2426 switched = 1;
2427 tempNode = pbt[i];
2428 pbt[i] = pbt[block];
2429 pbt[block] = tempNode;
2430 }
2431 }
2432 }
2433 if ((k == DeviceInfo.wSpectraEndBlock) && switched)
2434 valid_block_table = 0;
2435 }
2436
2437 if (!valid_block_table) {
2438 memset(g_pBlockTable, 0,
2439 DeviceInfo.wDataBlockNum * sizeof(u32));
2440 memset(g_pWearCounter, 0,
2441 DeviceInfo.wDataBlockNum * sizeof(u8));
2442 if (DeviceInfo.MLCDevice)
2443 memset(g_pReadCounter, 0,
2444 DeviceInfo.wDataBlockNum * sizeof(u16));
2445 #if CMD_DMA
2446 memset(g_pBTStartingCopy, 0,
2447 DeviceInfo.wDataBlockNum * sizeof(u32));
2448 memset(g_pWearCounterCopy, 0,
2449 DeviceInfo.wDataBlockNum * sizeof(u8));
2450 if (DeviceInfo.MLCDevice)
2451 memset(g_pReadCounterCopy, 0,
2452 DeviceInfo.wDataBlockNum * sizeof(u16));
2453 #endif
2454 for (j = DeviceInfo.wSpectraStartBlock, i = 0;
2455 j <= DeviceInfo.wSpectraEndBlock;
2456 j++, i++) {
2457 if (GLOB_LLD_Get_Bad_Block((u32)j))
2458 pbt[i] = (u32)(BAD_BLOCK | j);
2459 }
2460 }
2461
2462 nand_dbg_print(NAND_DBG_WARN, "Erasing all blocks in the NAND\n");
2463
2464 for (j = DeviceInfo.wSpectraStartBlock, i = 0;
2465 j <= DeviceInfo.wSpectraEndBlock;
2466 j++, i++) {
2467 if ((pbt[i] & BAD_BLOCK) != BAD_BLOCK) {
2468 ret = GLOB_LLD_Erase_Block(j);
2469 if (FAIL == ret) {
2470 pbt[i] = (u32)(j);
2471 MARK_BLOCK_AS_BAD(pbt[i]);
2472 nand_dbg_print(NAND_DBG_WARN,
2473 "NAND Program fail in %s, Line %d, "
2474 "Function: %s, new Bad Block %d generated!\n",
2475 __FILE__, __LINE__, __func__, (int)j);
2476 } else {
2477 pbt[i] = (u32)(SPARE_BLOCK | j);
2478 }
2479 }
2480 #if CMD_DMA
2481 pbtStartingCopy[i] = pbt[i];
2482 #endif
2483 }
2484
2485 g_wBlockTableOffset = 0;
2486 for (i = 0; (i <= (DeviceInfo.wSpectraEndBlock -
2487 DeviceInfo.wSpectraStartBlock))
2488 && ((pbt[i] & BAD_BLOCK) == BAD_BLOCK); i++)
2489 ;
2490 if (i > (DeviceInfo.wSpectraEndBlock - DeviceInfo.wSpectraStartBlock)) {
2491 printk(KERN_ERR "All blocks bad!\n");
2492 return FAIL;
2493 } else {
2494 g_wBlockTableIndex = pbt[i] & ~BAD_BLOCK;
2495 if (i != BLOCK_TABLE_INDEX) {
2496 tempNode = pbt[i];
2497 pbt[i] = pbt[BLOCK_TABLE_INDEX];
2498 pbt[BLOCK_TABLE_INDEX] = tempNode;
2499 }
2500 }
2501 pbt[BLOCK_TABLE_INDEX] &= (~SPARE_BLOCK);
2502
2503 #if CMD_DMA
2504 pbtStartingCopy[BLOCK_TABLE_INDEX] &= (~SPARE_BLOCK);
2505 #endif
2506
2507 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
2508 memset(g_pBTBlocks, 0xFF,
2509 (1 + LAST_BT_ID - FIRST_BT_ID) * sizeof(u32));
2510 g_pBTBlocks[FIRST_BT_ID-FIRST_BT_ID] = g_wBlockTableIndex;
2511 FTL_Write_Block_Table(FAIL);
2512
2513 for (i = 0; i < CACHE_ITEM_NUM; i++) {
2514 Cache.array[i].address = NAND_CACHE_INIT_ADDR;
2515 Cache.array[i].use_cnt = 0;
2516 Cache.array[i].changed = CLEAR;
2517 }
2518
2519 #if (RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE && CMD_DMA)
2520 memcpy((void *)&cache_start_copy, (void *)&Cache,
2521 sizeof(struct flash_cache_tag));
2522 #endif
2523 return PASS;
2524 }
2525
2526 static int force_format_nand(void)
2527 {
2528 u32 i;
2529
2530 /* Force erase the whole unprotected physical partiton of NAND */
2531 printk(KERN_ALERT "Start to force erase whole NAND device ...\n");
2532 printk(KERN_ALERT "From phyical block %d to %d\n",
2533 DeviceInfo.wSpectraStartBlock, DeviceInfo.wSpectraEndBlock);
2534 for (i = DeviceInfo.wSpectraStartBlock; i <= DeviceInfo.wSpectraEndBlock; i++) {
2535 if (GLOB_LLD_Erase_Block(i))
2536 printk(KERN_ERR "Failed to force erase NAND block %d\n", i);
2537 }
2538 printk(KERN_ALERT "Force Erase ends. Please reboot the system ...\n");
2539 while(1);
2540
2541 return PASS;
2542 }
2543
2544 int GLOB_FTL_Flash_Format(void)
2545 {
2546 //return FTL_Format_Flash(1);
2547 return force_format_nand();
2548
2549 }
2550
2551 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
2552 * Function: FTL_Search_Block_Table_IN_Block
2553 * Inputs: Block Number
2554 * Pointer to page
2555 * Outputs: PASS / FAIL
2556 * Page contatining the block table
2557 * Description: It searches the block table in the block
2558 * passed as an argument.
2559 *
2560 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
2561 static int FTL_Search_Block_Table_IN_Block(u32 BT_Block,
2562 u8 BT_Tag, u16 *Page)
2563 {
2564 u16 i, j, k;
2565 u16 Result = PASS;
2566 u16 Last_IPF = 0;
2567 u8 BT_Found = 0;
2568 u8 *tagarray;
2569 u8 *tempbuf = tmp_buf_search_bt_in_block;
2570 u8 *pSpareBuf = spare_buf_search_bt_in_block;
2571 u8 *pSpareBufBTLastPage = spare_buf_bt_search_bt_in_block;
2572 u8 bt_flag_last_page = 0xFF;
2573 u8 search_in_previous_pages = 0;
2574 u16 bt_pages;
2575
2576 nand_dbg_print(NAND_DBG_DEBUG, "%s, Line %d, Function: %s\n",
2577 __FILE__, __LINE__, __func__);
2578
2579 nand_dbg_print(NAND_DBG_DEBUG,
2580 "Searching block table in %u block\n",
2581 (unsigned int)BT_Block);
2582
2583 bt_pages = FTL_Get_Block_Table_Flash_Size_Pages();
2584
2585 for (i = bt_pages; i < DeviceInfo.wPagesPerBlock;
2586 i += (bt_pages + 1)) {
2587 nand_dbg_print(NAND_DBG_DEBUG,
2588 "Searching last IPF: %d\n", i);
2589 Result = GLOB_LLD_Read_Page_Main_Polling(tempbuf,
2590 BT_Block, i, 1);
2591
2592 if (0 == memcmp(tempbuf, g_pIPF, DeviceInfo.wPageDataSize)) {
2593 if ((i + bt_pages + 1) < DeviceInfo.wPagesPerBlock) {
2594 continue;
2595 } else {
2596 search_in_previous_pages = 1;
2597 Last_IPF = i;
2598 }
2599 }
2600
2601 if (!search_in_previous_pages) {
2602 if (i != bt_pages) {
2603 i -= (bt_pages + 1);
2604 Last_IPF = i;
2605 }
2606 }
2607
2608 if (0 == Last_IPF)
2609 break;
2610
2611 if (!search_in_previous_pages) {
2612 i = i + 1;
2613 nand_dbg_print(NAND_DBG_DEBUG,
2614 "Reading the spare area of Block %u Page %u",
2615 (unsigned int)BT_Block, i);
2616 Result = GLOB_LLD_Read_Page_Spare(pSpareBuf,
2617 BT_Block, i, 1);
2618 nand_dbg_print(NAND_DBG_DEBUG,
2619 "Reading the spare area of Block %u Page %u",
2620 (unsigned int)BT_Block, i + bt_pages - 1);
2621 Result = GLOB_LLD_Read_Page_Spare(pSpareBufBTLastPage,
2622 BT_Block, i + bt_pages - 1, 1);
2623
2624 k = 0;
2625 j = FTL_Extract_Block_Table_Tag(pSpareBuf, &tagarray);
2626 if (j) {
2627 for (; k < j; k++) {
2628 if (tagarray[k] == BT_Tag)
2629 break;
2630 }
2631 }
2632
2633 if (k < j)
2634 bt_flag = tagarray[k];
2635 else
2636 Result = FAIL;
2637
2638 if (Result == PASS) {
2639 k = 0;
2640 j = FTL_Extract_Block_Table_Tag(
2641 pSpareBufBTLastPage, &tagarray);
2642 if (j) {
2643 for (; k < j; k++) {
2644 if (tagarray[k] == BT_Tag)
2645 break;
2646 }
2647 }
2648
2649 if (k < j)
2650 bt_flag_last_page = tagarray[k];
2651 else
2652 Result = FAIL;
2653
2654 if (Result == PASS) {
2655 if (bt_flag == bt_flag_last_page) {
2656 nand_dbg_print(NAND_DBG_DEBUG,
2657 "Block table is found"
2658 " in page after IPF "
2659 "at block %d "
2660 "page %d\n",
2661 (int)BT_Block, i);
2662 BT_Found = 1;
2663 *Page = i;
2664 g_cBlockTableStatus =
2665 CURRENT_BLOCK_TABLE;
2666 break;
2667 } else {
2668 Result = FAIL;
2669 }
2670 }
2671 }
2672 }
2673
2674 if (search_in_previous_pages)
2675 i = i - bt_pages;
2676 else
2677 i = i - (bt_pages + 1);
2678
2679 Result = PASS;
2680
2681 nand_dbg_print(NAND_DBG_DEBUG,
2682 "Reading the spare area of Block %d Page %d",
2683 (int)BT_Block, i);
2684
2685 Result = GLOB_LLD_Read_Page_Spare(pSpareBuf, BT_Block, i, 1);
2686 nand_dbg_print(NAND_DBG_DEBUG,
2687 "Reading the spare area of Block %u Page %u",
2688 (unsigned int)BT_Block, i + bt_pages - 1);
2689
2690 Result = GLOB_LLD_Read_Page_Spare(pSpareBufBTLastPage,
2691 BT_Block, i + bt_pages - 1, 1);
2692
2693 k = 0;
2694 j = FTL_Extract_Block_Table_Tag(pSpareBuf, &tagarray);
2695 if (j) {
2696 for (; k < j; k++) {
2697 if (tagarray[k] == BT_Tag)
2698 break;
2699 }
2700 }
2701
2702 if (k < j)
2703 bt_flag = tagarray[k];
2704 else
2705 Result = FAIL;
2706
2707 if (Result == PASS) {
2708 k = 0;
2709 j = FTL_Extract_Block_Table_Tag(pSpareBufBTLastPage,
2710 &tagarray);
2711 if (j) {
2712 for (; k < j; k++) {
2713 if (tagarray[k] == BT_Tag)
2714 break;
2715 }
2716 }
2717
2718 if (k < j) {
2719 bt_flag_last_page = tagarray[k];
2720 } else {
2721 Result = FAIL;
2722 break;
2723 }
2724
2725 if (Result == PASS) {
2726 if (bt_flag == bt_flag_last_page) {
2727 nand_dbg_print(NAND_DBG_DEBUG,
2728 "Block table is found "
2729 "in page prior to IPF "
2730 "at block %u page %d\n",
2731 (unsigned int)BT_Block, i);
2732 BT_Found = 1;
2733 *Page = i;
2734 g_cBlockTableStatus =
2735 IN_PROGRESS_BLOCK_TABLE;
2736 break;
2737 } else {
2738 Result = FAIL;
2739 break;
2740 }
2741 }
2742 }
2743 }
2744
2745 if (Result == FAIL) {
2746 if ((Last_IPF > bt_pages) && (i < Last_IPF) && (!BT_Found)) {
2747 BT_Found = 1;
2748 *Page = i - (bt_pages + 1);
2749 }
2750 if ((Last_IPF == bt_pages) && (i < Last_IPF) && (!BT_Found))
2751 goto func_return;
2752 }
2753
2754 if (Last_IPF == 0) {
2755 i = 0;
2756 Result = PASS;
2757 nand_dbg_print(NAND_DBG_DEBUG, "Reading the spare area of "
2758 "Block %u Page %u", (unsigned int)BT_Block, i);
2759
2760 Result = GLOB_LLD_Read_Page_Spare(pSpareBuf, BT_Block, i, 1);
2761 nand_dbg_print(NAND_DBG_DEBUG,
2762 "Reading the spare area of Block %u Page %u",
2763 (unsigned int)BT_Block, i + bt_pages - 1);
2764 Result = GLOB_LLD_Read_Page_Spare(pSpareBufBTLastPage,
2765 BT_Block, i + bt_pages - 1, 1);
2766
2767 k = 0;
2768 j = FTL_Extract_Block_Table_Tag(pSpareBuf, &tagarray);
2769 if (j) {
2770 for (; k < j; k++) {
2771 if (tagarray[k] == BT_Tag)
2772 break;
2773 }
2774 }
2775
2776 if (k < j)
2777 bt_flag = tagarray[k];
2778 else
2779 Result = FAIL;
2780
2781 if (Result == PASS) {
2782 k = 0;
2783 j = FTL_Extract_Block_Table_Tag(pSpareBufBTLastPage,
2784 &tagarray);
2785 if (j) {
2786 for (; k < j; k++) {
2787 if (tagarray[k] == BT_Tag)
2788 break;
2789 }
2790 }
2791
2792 if (k < j)
2793 bt_flag_last_page = tagarray[k];
2794 else
2795 Result = FAIL;
2796
2797 if (Result == PASS) {
2798 if (bt_flag == bt_flag_last_page) {
2799 nand_dbg_print(NAND_DBG_DEBUG,
2800 "Block table is found "
2801 "in page after IPF at "
2802 "block %u page %u\n",
2803 (unsigned int)BT_Block,
2804 (unsigned int)i);
2805 BT_Found = 1;
2806 *Page = i;
2807 g_cBlockTableStatus =
2808 CURRENT_BLOCK_TABLE;
2809 goto func_return;
2810 } else {
2811 Result = FAIL;
2812 }
2813 }
2814 }
2815
2816 if (Result == FAIL)
2817 goto func_return;
2818 }
2819 func_return:
2820 return Result;
2821 }
2822
2823 u8 *get_blk_table_start_addr(void)
2824 {
2825 return g_pBlockTable;
2826 }
2827
2828 unsigned long get_blk_table_len(void)
2829 {
2830 return DeviceInfo.wDataBlockNum * sizeof(u32);
2831 }
2832
2833 u8 *get_wear_leveling_table_start_addr(void)
2834 {
2835 return g_pWearCounter;
2836 }
2837
2838 unsigned long get_wear_leveling_table_len(void)
2839 {
2840 return DeviceInfo.wDataBlockNum * sizeof(u8);
2841 }
2842
2843 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
2844 * Function: FTL_Read_Block_Table
2845 * Inputs: none
2846 * Outputs: PASS / FAIL
2847 * Description: read the flash spare area and find a block containing the
2848 * most recent block table(having largest block_table_counter).
2849 * Find the last written Block table in this block.
2850 * Check the correctness of Block Table
2851 * If CDMA is enabled, this function is called in
2852 * polling mode.
2853 * We don't need to store changes in Block table in this
2854 * function as it is called only at initialization
2855 *
2856 * Note: Currently this function is called at initialization
2857 * before any read/erase/write command issued to flash so,
2858 * there is no need to wait for CDMA list to complete as of now
2859 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
2860 static int FTL_Read_Block_Table(void)
2861 {
2862 u16 i = 0;
2863 int k, j;
2864 u8 *tempBuf, *tagarray;
2865 int wResult = FAIL;
2866 int status = FAIL;
2867 u8 block_table_found = 0;
2868 int search_result;
2869 u32 Block;
2870 u16 Page = 0;
2871 u16 PageCount;
2872 u16 bt_pages;
2873 int wBytesCopied = 0, tempvar;
2874
2875 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
2876 __FILE__, __LINE__, __func__);
2877
2878 tempBuf = tmp_buf1_read_blk_table;
2879 bt_pages = FTL_Get_Block_Table_Flash_Size_Pages();
2880
2881 for (j = DeviceInfo.wSpectraStartBlock;
2882 j <= (int)DeviceInfo.wSpectraEndBlock;
2883 j++) {
2884 status = GLOB_LLD_Read_Page_Spare(tempBuf, j, 0, 1);
2885 k = 0;
2886 i = FTL_Extract_Block_Table_Tag(tempBuf, &tagarray);
2887 if (i) {
2888 status = GLOB_LLD_Read_Page_Main_Polling(tempBuf,
2889 j, 0, 1);
2890 for (; k < i; k++) {
2891 if (tagarray[k] == tempBuf[3])
2892 break;
2893 }
2894 }
2895
2896 if (k < i)
2897 k = tagarray[k];
2898 else
2899 continue;
2900
2901 nand_dbg_print(NAND_DBG_DEBUG,
2902 "Block table is contained in Block %d %d\n",
2903 (unsigned int)j, (unsigned int)k);
2904
2905 if (g_pBTBlocks[k-FIRST_BT_ID] == BTBLOCK_INVAL) {
2906 g_pBTBlocks[k-FIRST_BT_ID] = j;
2907 block_table_found = 1;
2908 } else {
2909 printk(KERN_ERR "FTL_Read_Block_Table -"
2910 "This should never happens. "
2911 "Two block table have same counter %u!\n", k);
2912 }
2913 }
2914
2915 if (block_table_found) {
2916 if (g_pBTBlocks[FIRST_BT_ID - FIRST_BT_ID] != BTBLOCK_INVAL &&
2917 g_pBTBlocks[LAST_BT_ID - FIRST_BT_ID] != BTBLOCK_INVAL) {
2918 j = LAST_BT_ID;
2919 while ((j > FIRST_BT_ID) &&
2920 (g_pBTBlocks[j - FIRST_BT_ID] != BTBLOCK_INVAL))
2921 j--;
2922 if (j == FIRST_BT_ID) {
2923 j = LAST_BT_ID;
2924 last_erased = LAST_BT_ID;
2925 } else {
2926 last_erased = (u8)j + 1;
2927 while ((j > FIRST_BT_ID) && (BTBLOCK_INVAL ==
2928 g_pBTBlocks[j - FIRST_BT_ID]))
2929 j--;
2930 }
2931 } else {
2932 j = FIRST_BT_ID;
2933 while (g_pBTBlocks[j - FIRST_BT_ID] == BTBLOCK_INVAL)
2934 j++;
2935 last_erased = (u8)j;
2936 while ((j < LAST_BT_ID) && (BTBLOCK_INVAL !=
2937 g_pBTBlocks[j - FIRST_BT_ID]))
2938 j++;
2939 if (g_pBTBlocks[j-FIRST_BT_ID] == BTBLOCK_INVAL)
2940 j--;
2941 }
2942
2943 if (last_erased > j)
2944 j += (1 + LAST_BT_ID - FIRST_BT_ID);
2945
2946 for (; (j >= last_erased) && (FAIL == wResult); j--) {
2947 i = (j - FIRST_BT_ID) %
2948 (1 + LAST_BT_ID - FIRST_BT_ID);
2949 search_result =
2950 FTL_Search_Block_Table_IN_Block(g_pBTBlocks[i],
2951 i + FIRST_BT_ID, &Page);
2952 if (g_cBlockTableStatus == IN_PROGRESS_BLOCK_TABLE)
2953 block_table_found = 0;
2954
2955 while ((search_result == PASS) && (FAIL == wResult)) {
2956 nand_dbg_print(NAND_DBG_DEBUG,
2957 "FTL_Read_Block_Table:"
2958 "Block: %u Page: %u "
2959 "contains block table\n",
2960 (unsigned int)g_pBTBlocks[i],
2961 (unsigned int)Page);
2962
2963 tempBuf = tmp_buf2_read_blk_table;
2964
2965 for (k = 0; k < bt_pages; k++) {
2966 Block = g_pBTBlocks[i];
2967 PageCount = 1;
2968
2969 status =
2970 GLOB_LLD_Read_Page_Main_Polling(
2971 tempBuf, Block, Page, PageCount);
2972
2973 tempvar = k ? 0 : 4;
2974
2975 wBytesCopied +=
2976 FTL_Copy_Block_Table_From_Flash(
2977 tempBuf + tempvar,
2978 DeviceInfo.wPageDataSize - tempvar,
2979 wBytesCopied);
2980
2981 Page++;
2982 }
2983
2984 wResult = FTL_Check_Block_Table(FAIL);
2985 if (FAIL == wResult) {
2986 block_table_found = 0;
2987 if (Page > bt_pages)
2988 Page -= ((bt_pages<<1) + 1);
2989 else
2990 search_result = FAIL;
2991 }
2992 }
2993 }
2994 }
2995
2996 if (PASS == wResult) {
2997 if (!block_table_found)
2998 FTL_Execute_SPL_Recovery();
2999
3000 if (g_cBlockTableStatus == IN_PROGRESS_BLOCK_TABLE)
3001 g_wBlockTableOffset = (u16)Page + 1;
3002 else
3003 g_wBlockTableOffset = (u16)Page - bt_pages;
3004
3005 g_wBlockTableIndex = (u32)g_pBTBlocks[i];
3006
3007 #if CMD_DMA
3008 if (DeviceInfo.MLCDevice)
3009 memcpy(g_pBTStartingCopy, g_pBlockTable,
3010 DeviceInfo.wDataBlockNum * sizeof(u32)
3011 + DeviceInfo.wDataBlockNum * sizeof(u8)
3012 + DeviceInfo.wDataBlockNum * sizeof(u16));
3013 else
3014 memcpy(g_pBTStartingCopy, g_pBlockTable,
3015 DeviceInfo.wDataBlockNum * sizeof(u32)
3016 + DeviceInfo.wDataBlockNum * sizeof(u8));
3017 #endif
3018 }
3019
3020 if (FAIL == wResult)
3021 printk(KERN_ERR "Yunpeng - "
3022 "Can not find valid spectra block table!\n");
3023
3024 #if AUTO_FORMAT_FLASH
3025 if (FAIL == wResult) {
3026 nand_dbg_print(NAND_DBG_DEBUG, "doing auto-format\n");
3027 wResult = FTL_Format_Flash(0);
3028 }
3029 #endif
3030
3031 return wResult;
3032 }
3033
3034
3035 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3036 * Function: FTL_Flash_Error_Handle
3037 * Inputs: Pointer to data
3038 * Page address
3039 * Block address
3040 * Outputs: PASS=0 / FAIL=1
3041 * Description: It handles any error occured during Spectra operation
3042 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
3043 static int FTL_Flash_Error_Handle(u8 *pData, u64 old_page_addr,
3044 u64 blk_addr)
3045 {
3046 u32 i;
3047 int j;
3048 u32 tmp_node, blk_node = BLK_FROM_ADDR(blk_addr);
3049 u64 phy_addr;
3050 int wErase = FAIL;
3051 int wResult = FAIL;
3052 u32 *pbt = (u32 *)g_pBlockTable;
3053
3054 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
3055 __FILE__, __LINE__, __func__);
3056
3057 if (ERR == GLOB_FTL_Garbage_Collection())
3058 return ERR;
3059
3060 do {
3061 for (i = DeviceInfo.wSpectraEndBlock -
3062 DeviceInfo.wSpectraStartBlock;
3063 i > 0; i--) {
3064 if (IS_SPARE_BLOCK(i)) {
3065 tmp_node = (u32)(BAD_BLOCK |
3066 pbt[blk_node]);
3067 pbt[blk_node] = (u32)(pbt[i] &
3068 (~SPARE_BLOCK));
3069 pbt[i] = tmp_node;
3070 #if CMD_DMA
3071 p_BTableChangesDelta =
3072 (struct BTableChangesDelta *)
3073 g_pBTDelta_Free;
3074 g_pBTDelta_Free +=
3075 sizeof(struct BTableChangesDelta);
3076
3077 p_BTableChangesDelta->ftl_cmd_cnt =
3078 ftl_cmd_cnt;
3079 p_BTableChangesDelta->BT_Index =
3080 blk_node;
3081 p_BTableChangesDelta->BT_Entry_Value =
3082 pbt[blk_node];
3083 p_BTableChangesDelta->ValidFields = 0x0C;
3084
3085 p_BTableChangesDelta =
3086 (struct BTableChangesDelta *)
3087 g_pBTDelta_Free;
3088 g_pBTDelta_Free +=
3089 sizeof(struct BTableChangesDelta);
3090
3091 p_BTableChangesDelta->ftl_cmd_cnt =
3092 ftl_cmd_cnt;
3093 p_BTableChangesDelta->BT_Index = i;
3094 p_BTableChangesDelta->BT_Entry_Value = pbt[i];
3095 p_BTableChangesDelta->ValidFields = 0x0C;
3096 #endif
3097 wResult = PASS;
3098 break;
3099 }
3100 }
3101
3102 if (FAIL == wResult) {
3103 if (FAIL == GLOB_FTL_Garbage_Collection())
3104 break;
3105 else
3106 continue;
3107 }
3108
3109 if (IN_PROGRESS_BLOCK_TABLE != g_cBlockTableStatus) {
3110 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
3111 FTL_Write_IN_Progress_Block_Table_Page();
3112 }
3113
3114 phy_addr = FTL_Get_Physical_Block_Addr(blk_addr);
3115
3116 for (j = 0; j < RETRY_TIMES; j++) {
3117 if (PASS == wErase) {
3118 if (FAIL == GLOB_FTL_Block_Erase(phy_addr)) {
3119 MARK_BLOCK_AS_BAD(pbt[blk_node]);
3120 break;
3121 }
3122 }
3123 if (PASS == FTL_Cache_Update_Block(pData,
3124 old_page_addr,
3125 phy_addr)) {
3126 wResult = PASS;
3127 break;
3128 } else {
3129 wResult = FAIL;
3130 wErase = PASS;
3131 }
3132 }
3133 } while (FAIL == wResult);
3134
3135 FTL_Write_Block_Table(FAIL);
3136
3137 return wResult;
3138 }
3139
3140 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3141 * Function: FTL_Get_Page_Num
3142 * Inputs: Size in bytes
3143 * Outputs: Size in pages
3144 * Description: It calculates the pages required for the length passed
3145 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
3146 static u32 FTL_Get_Page_Num(u64 length)
3147 {
3148 return (u32)((length >> DeviceInfo.nBitsInPageDataSize) +
3149 (GLOB_u64_Remainder(length , 1) > 0 ? 1 : 0));
3150 }
3151
3152 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3153 * Function: FTL_Get_Physical_Block_Addr
3154 * Inputs: Block Address (byte format)
3155 * Outputs: Physical address of the block.
3156 * Description: It translates LBA to PBA by returning address stored
3157 * at the LBA location in the block table
3158 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
3159 static u64 FTL_Get_Physical_Block_Addr(u64 logical_addr)
3160 {
3161 u32 *pbt;
3162 u64 physical_addr;
3163
3164 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
3165 __FILE__, __LINE__, __func__);
3166
3167 pbt = (u32 *)g_pBlockTable;
3168 physical_addr = (u64) DeviceInfo.wBlockDataSize *
3169 (pbt[BLK_FROM_ADDR(logical_addr)] & (~BAD_BLOCK));
3170
3171 return physical_addr;
3172 }
3173
3174 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3175 * Function: FTL_Get_Block_Index
3176 * Inputs: Physical Block no.
3177 * Outputs: Logical block no. /BAD_BLOCK
3178 * Description: It returns the logical block no. for the PBA passed
3179 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
3180 static u32 FTL_Get_Block_Index(u32 wBlockNum)
3181 {
3182 u32 *pbt = (u32 *)g_pBlockTable;
3183 u32 i;
3184
3185 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
3186 __FILE__, __LINE__, __func__);
3187
3188 for (i = 0; i < DeviceInfo.wDataBlockNum; i++)
3189 if (wBlockNum == (pbt[i] & (~BAD_BLOCK)))
3190 return i;
3191
3192 return BAD_BLOCK;
3193 }
3194
3195 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3196 * Function: GLOB_FTL_Wear_Leveling
3197 * Inputs: none
3198 * Outputs: PASS=0
3199 * Description: This is static wear leveling (done by explicit call)
3200 * do complete static wear leveling
3201 * do complete garbage collection
3202 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
3203 int GLOB_FTL_Wear_Leveling(void)
3204 {
3205 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d, Function: %s\n",
3206 __FILE__, __LINE__, __func__);
3207
3208 FTL_Static_Wear_Leveling();
3209 GLOB_FTL_Garbage_Collection();
3210
3211 return PASS;
3212 }
3213
3214 static void find_least_most_worn(u8 *chg,
3215 u32 *least_idx, u8 *least_cnt,
3216 u32 *most_idx, u8 *most_cnt)
3217 {
3218 u32 *pbt = (u32 *)g_pBlockTable;
3219 u32 idx;
3220 u8 cnt;
3221 int i;
3222
3223 for (i = BLOCK_TABLE_INDEX + 1; i < DeviceInfo.wDataBlockNum; i++) {
3224 if (IS_BAD_BLOCK(i) || PASS == chg[i])
3225 continue;
3226
3227 idx = (u32) ((~BAD_BLOCK) & pbt[i]);
3228 cnt = g_pWearCounter[idx - DeviceInfo.wSpectraStartBlock];
3229
3230 if (IS_SPARE_BLOCK(i)) {
3231 if (cnt > *most_cnt) {
3232 *most_cnt = cnt;
3233 *most_idx = idx;
3234 }
3235 }
3236
3237 if (IS_DATA_BLOCK(i)) {
3238 if (cnt < *least_cnt) {
3239 *least_cnt = cnt;
3240 *least_idx = idx;
3241 }
3242 }
3243
3244 if (PASS == chg[*most_idx] || PASS == chg[*least_idx]) {
3245 debug_boundary_error(*most_idx,
3246 DeviceInfo.wDataBlockNum, 0);
3247 debug_boundary_error(*least_idx,
3248 DeviceInfo.wDataBlockNum, 0);
3249 continue;
3250 }
3251 }
3252 }
3253
3254 static int move_blks_for_wear_leveling(u8 *chg,
3255 u32 *least_idx, u32 *rep_blk_num, int *result)
3256 {
3257 u32 *pbt = (u32 *)g_pBlockTable;
3258 u32 rep_blk;
3259 int j, ret_cp_blk, ret_erase;
3260 int ret = PASS;
3261
3262 chg[*least_idx] = PASS;
3263 debug_boundary_error(*least_idx, DeviceInfo.wDataBlockNum, 0);
3264
3265 rep_blk = FTL_Replace_MWBlock();
3266 if (rep_blk != BAD_BLOCK) {
3267 nand_dbg_print(NAND_DBG_DEBUG,
3268 "More than two spare blocks exist so do it\n");
3269 nand_dbg_print(NAND_DBG_DEBUG, "Block Replaced is %d\n",
3270 rep_blk);
3271
3272 chg[rep_blk] = PASS;
3273
3274 if (IN_PROGRESS_BLOCK_TABLE != g_cBlockTableStatus) {
3275 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
3276 FTL_Write_IN_Progress_Block_Table_Page();
3277 }
3278
3279 for (j = 0; j < RETRY_TIMES; j++) {
3280 ret_cp_blk = FTL_Copy_Block((u64)(*least_idx) *
3281 DeviceInfo.wBlockDataSize,
3282 (u64)rep_blk * DeviceInfo.wBlockDataSize);
3283 if (FAIL == ret_cp_blk) {
3284 ret_erase = GLOB_FTL_Block_Erase((u64)rep_blk
3285 * DeviceInfo.wBlockDataSize);
3286 if (FAIL == ret_erase)
3287 MARK_BLOCK_AS_BAD(pbt[rep_blk]);
3288 } else {
3289 nand_dbg_print(NAND_DBG_DEBUG,
3290 "FTL_Copy_Block == OK\n");
3291 break;
3292 }
3293 }
3294
3295 if (j < RETRY_TIMES) {
3296 u32 tmp;
3297 u32 old_idx = FTL_Get_Block_Index(*least_idx);
3298 u32 rep_idx = FTL_Get_Block_Index(rep_blk);
3299 tmp = (u32)(DISCARD_BLOCK | pbt[old_idx]);
3300 pbt[old_idx] = (u32)((~SPARE_BLOCK) &
3301 pbt[rep_idx]);
3302 pbt[rep_idx] = tmp;
3303 #if CMD_DMA
3304 p_BTableChangesDelta = (struct BTableChangesDelta *)
3305 g_pBTDelta_Free;
3306 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
3307 p_BTableChangesDelta->ftl_cmd_cnt =
3308 ftl_cmd_cnt;
3309 p_BTableChangesDelta->BT_Index = old_idx;
3310 p_BTableChangesDelta->BT_Entry_Value = pbt[old_idx];
3311 p_BTableChangesDelta->ValidFields = 0x0C;
3312
3313 p_BTableChangesDelta = (struct BTableChangesDelta *)
3314 g_pBTDelta_Free;
3315 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
3316
3317 p_BTableChangesDelta->ftl_cmd_cnt =
3318 ftl_cmd_cnt;
3319 p_BTableChangesDelta->BT_Index = rep_idx;
3320 p_BTableChangesDelta->BT_Entry_Value = pbt[rep_idx];
3321 p_BTableChangesDelta->ValidFields = 0x0C;
3322 #endif
3323 } else {
3324 pbt[FTL_Get_Block_Index(rep_blk)] |= BAD_BLOCK;
3325 #if CMD_DMA
3326 p_BTableChangesDelta = (struct BTableChangesDelta *)
3327 g_pBTDelta_Free;
3328 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
3329
3330 p_BTableChangesDelta->ftl_cmd_cnt =
3331 ftl_cmd_cnt;
3332 p_BTableChangesDelta->BT_Index =
3333 FTL_Get_Block_Index(rep_blk);
3334 p_BTableChangesDelta->BT_Entry_Value =
3335 pbt[FTL_Get_Block_Index(rep_blk)];
3336 p_BTableChangesDelta->ValidFields = 0x0C;
3337 #endif
3338 *result = FAIL;
3339 ret = FAIL;
3340 }
3341
3342 if (((*rep_blk_num)++) > WEAR_LEVELING_BLOCK_NUM)
3343 ret = FAIL;
3344 } else {
3345 printk(KERN_ERR "Less than 3 spare blocks exist so quit\n");
3346 ret = FAIL;
3347 }
3348
3349 return ret;
3350 }
3351
3352 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3353 * Function: FTL_Static_Wear_Leveling
3354 * Inputs: none
3355 * Outputs: PASS=0 / FAIL=1
3356 * Description: This is static wear leveling (done by explicit call)
3357 * search for most&least used
3358 * if difference < GATE:
3359 * update the block table with exhange
3360 * mark block table in flash as IN_PROGRESS
3361 * copy flash block
3362 * the caller should handle GC clean up after calling this function
3363 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
3364 int FTL_Static_Wear_Leveling(void)
3365 {
3366 u8 most_worn_cnt;
3367 u8 least_worn_cnt;
3368 u32 most_worn_idx;
3369 u32 least_worn_idx;
3370 int result = PASS;
3371 int go_on = PASS;
3372 u32 replaced_blks = 0;
3373 u8 *chang_flag = flags_static_wear_leveling;
3374
3375 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d, Function: %s\n",
3376 __FILE__, __LINE__, __func__);
3377
3378 if (!chang_flag)
3379 return FAIL;
3380
3381 memset(chang_flag, FAIL, DeviceInfo.wDataBlockNum);
3382 while (go_on == PASS) {
3383 nand_dbg_print(NAND_DBG_DEBUG,
3384 "starting static wear leveling\n");
3385 most_worn_cnt = 0;
3386 least_worn_cnt = 0xFF;
3387 least_worn_idx = BLOCK_TABLE_INDEX;
3388 most_worn_idx = BLOCK_TABLE_INDEX;
3389
3390 find_least_most_worn(chang_flag, &least_worn_idx,
3391 &least_worn_cnt, &most_worn_idx, &most_worn_cnt);
3392
3393 nand_dbg_print(NAND_DBG_DEBUG,
3394 "Used and least worn is block %u, whos count is %u\n",
3395 (unsigned int)least_worn_idx,
3396 (unsigned int)least_worn_cnt);
3397
3398 nand_dbg_print(NAND_DBG_DEBUG,
3399 "Free and most worn is block %u, whos count is %u\n",
3400 (unsigned int)most_worn_idx,
3401 (unsigned int)most_worn_cnt);
3402
3403 if ((most_worn_cnt > least_worn_cnt) &&
3404 (most_worn_cnt - least_worn_cnt > WEAR_LEVELING_GATE))
3405 go_on = move_blks_for_wear_leveling(chang_flag,
3406 &least_worn_idx, &replaced_blks, &result);
3407 else
3408 go_on = FAIL;
3409 }
3410
3411 return result;
3412 }
3413
3414 #if CMD_DMA
3415 static int do_garbage_collection(u32 discard_cnt)
3416 {
3417 u32 *pbt = (u32 *)g_pBlockTable;
3418 u32 pba;
3419 u8 bt_block_erased = 0;
3420 int i, cnt, ret = FAIL;
3421 u64 addr;
3422
3423 i = 0;
3424 while ((i < DeviceInfo.wDataBlockNum) && (discard_cnt > 0) &&
3425 ((ftl_cmd_cnt + 28) < 256)) {
3426 if (((pbt[i] & BAD_BLOCK) != BAD_BLOCK) &&
3427 (pbt[i] & DISCARD_BLOCK)) {
3428 if (IN_PROGRESS_BLOCK_TABLE != g_cBlockTableStatus) {
3429 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
3430 FTL_Write_IN_Progress_Block_Table_Page();
3431 }
3432
3433 addr = FTL_Get_Physical_Block_Addr((u64)i *
3434 DeviceInfo.wBlockDataSize);
3435 pba = BLK_FROM_ADDR(addr);
3436
3437 for (cnt = FIRST_BT_ID; cnt <= LAST_BT_ID; cnt++) {
3438 if (pba == g_pBTBlocks[cnt - FIRST_BT_ID]) {
3439 nand_dbg_print(NAND_DBG_DEBUG,
3440 "GC will erase BT block %u\n",
3441 (unsigned int)pba);
3442 discard_cnt--;
3443 i++;
3444 bt_block_erased = 1;
3445 break;
3446 }
3447 }
3448
3449 if (bt_block_erased) {
3450 bt_block_erased = 0;
3451 continue;
3452 }
3453
3454 addr = FTL_Get_Physical_Block_Addr((u64)i *
3455 DeviceInfo.wBlockDataSize);
3456
3457 if (PASS == GLOB_FTL_Block_Erase(addr)) {
3458 pbt[i] &= (u32)(~DISCARD_BLOCK);
3459 pbt[i] |= (u32)(SPARE_BLOCK);
3460 p_BTableChangesDelta =
3461 (struct BTableChangesDelta *)
3462 g_pBTDelta_Free;
3463 g_pBTDelta_Free +=
3464 sizeof(struct BTableChangesDelta);
3465 p_BTableChangesDelta->ftl_cmd_cnt =
3466 ftl_cmd_cnt - 1;
3467 p_BTableChangesDelta->BT_Index = i;
3468 p_BTableChangesDelta->BT_Entry_Value = pbt[i];
3469 p_BTableChangesDelta->ValidFields = 0x0C;
3470 discard_cnt--;
3471 ret = PASS;
3472 } else {
3473 MARK_BLOCK_AS_BAD(pbt[i]);
3474 }
3475 }
3476
3477 i++;
3478 }
3479
3480 return ret;
3481 }
3482
3483 #else
3484 static int do_garbage_collection(u32 discard_cnt)
3485 {
3486 u32 *pbt = (u32 *)g_pBlockTable;
3487 u32 pba;
3488 u8 bt_block_erased = 0;
3489 int i, cnt, ret = FAIL;
3490 u64 addr;
3491
3492 i = 0;
3493 while ((i < DeviceInfo.wDataBlockNum) && (discard_cnt > 0)) {
3494 if (((pbt[i] & BAD_BLOCK) != BAD_BLOCK) &&
3495 (pbt[i] & DISCARD_BLOCK)) {
3496 if (IN_PROGRESS_BLOCK_TABLE != g_cBlockTableStatus) {
3497 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
3498 FTL_Write_IN_Progress_Block_Table_Page();
3499 }
3500
3501 addr = FTL_Get_Physical_Block_Addr((u64)i *
3502 DeviceInfo.wBlockDataSize);
3503 pba = BLK_FROM_ADDR(addr);
3504
3505 for (cnt = FIRST_BT_ID; cnt <= LAST_BT_ID; cnt++) {
3506 if (pba == g_pBTBlocks[cnt - FIRST_BT_ID]) {
3507 nand_dbg_print(NAND_DBG_DEBUG,
3508 "GC will erase BT block %d\n",
3509 pba);
3510 discard_cnt--;
3511 i++;
3512 bt_block_erased = 1;
3513 break;
3514 }
3515 }
3516
3517 if (bt_block_erased) {
3518 bt_block_erased = 0;
3519 continue;
3520 }
3521
3522 /* If the discard block is L2 cache block, then just skip it */
3523 for (cnt = 0; cnt < BLK_NUM_FOR_L2_CACHE; cnt++) {
3524 if (cache_l2.blk_array[cnt] == pba) {
3525 nand_dbg_print(NAND_DBG_DEBUG,
3526 "GC will erase L2 cache blk %d\n",
3527 pba);
3528 break;
3529 }
3530 }
3531 if (cnt < BLK_NUM_FOR_L2_CACHE) { /* Skip it */
3532 discard_cnt--;
3533 i++;
3534 continue;
3535 }
3536
3537 addr = FTL_Get_Physical_Block_Addr((u64)i *
3538 DeviceInfo.wBlockDataSize);
3539
3540 if (PASS == GLOB_FTL_Block_Erase(addr)) {
3541 pbt[i] &= (u32)(~DISCARD_BLOCK);
3542 pbt[i] |= (u32)(SPARE_BLOCK);
3543 discard_cnt--;
3544 ret = PASS;
3545 } else {
3546 MARK_BLOCK_AS_BAD(pbt[i]);
3547 }
3548 }
3549
3550 i++;
3551 }
3552
3553 return ret;
3554 }
3555 #endif
3556
3557 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3558 * Function: GLOB_FTL_Garbage_Collection
3559 * Inputs: none
3560 * Outputs: PASS / FAIL (returns the number of un-erased blocks
3561 * Description: search the block table for all discarded blocks to erase
3562 * for each discarded block:
3563 * set the flash block to IN_PROGRESS
3564 * erase the block
3565 * update the block table
3566 * write the block table to flash
3567 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
3568 int GLOB_FTL_Garbage_Collection(void)
3569 {
3570 u32 i;
3571 u32 wDiscard = 0;
3572 int wResult = FAIL;
3573 u32 *pbt = (u32 *)g_pBlockTable;
3574
3575 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d, Function: %s\n",
3576 __FILE__, __LINE__, __func__);
3577
3578 if (GC_Called) {
3579 printk(KERN_ALERT "GLOB_FTL_Garbage_Collection() "
3580 "has been re-entered! Exit.\n");
3581 return PASS;
3582 }
3583
3584 GC_Called = 1;
3585
3586 GLOB_FTL_BT_Garbage_Collection();
3587
3588 for (i = 0; i < DeviceInfo.wDataBlockNum; i++) {
3589 if (IS_DISCARDED_BLOCK(i))
3590 wDiscard++;
3591 }
3592
3593 if (wDiscard <= 0) {
3594 GC_Called = 0;
3595 return wResult;
3596 }
3597
3598 nand_dbg_print(NAND_DBG_DEBUG,
3599 "Found %d discarded blocks\n", wDiscard);
3600
3601 FTL_Write_Block_Table(FAIL);
3602
3603 wResult = do_garbage_collection(wDiscard);
3604
3605 FTL_Write_Block_Table(FAIL);
3606
3607 GC_Called = 0;
3608
3609 return wResult;
3610 }
3611
3612
3613 #if CMD_DMA
3614 static int do_bt_garbage_collection(void)
3615 {
3616 u32 pba, lba;
3617 u32 *pbt = (u32 *)g_pBlockTable;
3618 u32 *pBTBlocksNode = (u32 *)g_pBTBlocks;
3619 u64 addr;
3620 int i, ret = FAIL;
3621
3622 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
3623 __FILE__, __LINE__, __func__);
3624
3625 if (BT_GC_Called)
3626 return PASS;
3627
3628 BT_GC_Called = 1;
3629
3630 for (i = last_erased; (i <= LAST_BT_ID) &&
3631 (g_pBTBlocks[((i + 2) % (1 + LAST_BT_ID - FIRST_BT_ID)) +
3632 FIRST_BT_ID - FIRST_BT_ID] != BTBLOCK_INVAL) &&
3633 ((ftl_cmd_cnt + 28)) < 256; i++) {
3634 pba = pBTBlocksNode[i - FIRST_BT_ID];
3635 lba = FTL_Get_Block_Index(pba);
3636 nand_dbg_print(NAND_DBG_DEBUG,
3637 "do_bt_garbage_collection: pba %d, lba %d\n",
3638 pba, lba);
3639 nand_dbg_print(NAND_DBG_DEBUG,
3640 "Block Table Entry: %d", pbt[lba]);
3641
3642 if (((pbt[lba] & BAD_BLOCK) != BAD_BLOCK) &&
3643 (pbt[lba] & DISCARD_BLOCK)) {
3644 nand_dbg_print(NAND_DBG_DEBUG,
3645 "do_bt_garbage_collection_cdma: "
3646 "Erasing Block tables present in block %d\n",
3647 pba);
3648 addr = FTL_Get_Physical_Block_Addr((u64)lba *
3649 DeviceInfo.wBlockDataSize);
3650 if (PASS == GLOB_FTL_Block_Erase(addr)) {
3651 pbt[lba] &= (u32)(~DISCARD_BLOCK);
3652 pbt[lba] |= (u32)(SPARE_BLOCK);
3653
3654 p_BTableChangesDelta =
3655 (struct BTableChangesDelta *)
3656 g_pBTDelta_Free;
3657 g_pBTDelta_Free +=
3658 sizeof(struct BTableChangesDelta);
3659
3660 p_BTableChangesDelta->ftl_cmd_cnt =
3661 ftl_cmd_cnt - 1;
3662 p_BTableChangesDelta->BT_Index = lba;
3663 p_BTableChangesDelta->BT_Entry_Value =
3664 pbt[lba];
3665
3666 p_BTableChangesDelta->ValidFields = 0x0C;
3667
3668 ret = PASS;
3669 pBTBlocksNode[last_erased - FIRST_BT_ID] =
3670 BTBLOCK_INVAL;
3671 nand_dbg_print(NAND_DBG_DEBUG,
3672 "resetting bt entry at index %d "
3673 "value %d\n", i,
3674 pBTBlocksNode[i - FIRST_BT_ID]);
3675 if (last_erased == LAST_BT_ID)
3676 last_erased = FIRST_BT_ID;
3677 else
3678 last_erased++;
3679 } else {
3680 MARK_BLOCK_AS_BAD(pbt[lba]);
3681 }
3682 }
3683 }
3684
3685 BT_GC_Called = 0;
3686
3687 return ret;
3688 }
3689
3690 #else
3691 static int do_bt_garbage_collection(void)
3692 {
3693 u32 pba, lba;
3694 u32 *pbt = (u32 *)g_pBlockTable;
3695 u32 *pBTBlocksNode = (u32 *)g_pBTBlocks;
3696 u64 addr;
3697 int i, ret = FAIL;
3698
3699 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
3700 __FILE__, __LINE__, __func__);
3701
3702 if (BT_GC_Called)
3703 return PASS;
3704
3705 BT_GC_Called = 1;
3706
3707 for (i = last_erased; (i <= LAST_BT_ID) &&
3708 (g_pBTBlocks[((i + 2) % (1 + LAST_BT_ID - FIRST_BT_ID)) +
3709 FIRST_BT_ID - FIRST_BT_ID] != BTBLOCK_INVAL); i++) {
3710 pba = pBTBlocksNode[i - FIRST_BT_ID];
3711 lba = FTL_Get_Block_Index(pba);
3712 nand_dbg_print(NAND_DBG_DEBUG,
3713 "do_bt_garbage_collection_cdma: pba %d, lba %d\n",
3714 pba, lba);
3715 nand_dbg_print(NAND_DBG_DEBUG,
3716 "Block Table Entry: %d", pbt[lba]);
3717
3718 if (((pbt[lba] & BAD_BLOCK) != BAD_BLOCK) &&
3719 (pbt[lba] & DISCARD_BLOCK)) {
3720 nand_dbg_print(NAND_DBG_DEBUG,
3721 "do_bt_garbage_collection: "
3722 "Erasing Block tables present in block %d\n",
3723 pba);
3724 addr = FTL_Get_Physical_Block_Addr((u64)lba *
3725 DeviceInfo.wBlockDataSize);
3726 if (PASS == GLOB_FTL_Block_Erase(addr)) {
3727 pbt[lba] &= (u32)(~DISCARD_BLOCK);
3728 pbt[lba] |= (u32)(SPARE_BLOCK);
3729 ret = PASS;
3730 pBTBlocksNode[last_erased - FIRST_BT_ID] =
3731 BTBLOCK_INVAL;
3732 nand_dbg_print(NAND_DBG_DEBUG,
3733 "resetting bt entry at index %d "
3734 "value %d\n", i,
3735 pBTBlocksNode[i - FIRST_BT_ID]);
3736 if (last_erased == LAST_BT_ID)
3737 last_erased = FIRST_BT_ID;
3738 else
3739 last_erased++;
3740 } else {
3741 MARK_BLOCK_AS_BAD(pbt[lba]);
3742 }
3743 }
3744 }
3745
3746 BT_GC_Called = 0;
3747
3748 return ret;
3749 }
3750
3751 #endif
3752
3753 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3754 * Function: GLOB_FTL_BT_Garbage_Collection
3755 * Inputs: none
3756 * Outputs: PASS / FAIL (returns the number of un-erased blocks
3757 * Description: Erases discarded blocks containing Block table
3758 *
3759 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
3760 int GLOB_FTL_BT_Garbage_Collection(void)
3761 {
3762 return do_bt_garbage_collection();
3763 }
3764
3765 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3766 * Function: FTL_Replace_OneBlock
3767 * Inputs: Block number 1
3768 * Block number 2
3769 * Outputs: Replaced Block Number
3770 * Description: Interchange block table entries at wBlockNum and wReplaceNum
3771 *
3772 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
3773 static u32 FTL_Replace_OneBlock(u32 blk, u32 rep_blk)
3774 {
3775 u32 tmp_blk;
3776 u32 replace_node = BAD_BLOCK;
3777 u32 *pbt = (u32 *)g_pBlockTable;
3778
3779 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
3780 __FILE__, __LINE__, __func__);
3781
3782 if (rep_blk != BAD_BLOCK) {
3783 if (IS_BAD_BLOCK(blk))
3784 tmp_blk = pbt[blk];
3785 else
3786 tmp_blk = DISCARD_BLOCK | (~SPARE_BLOCK & pbt[blk]);
3787
3788 replace_node = (u32) ((~SPARE_BLOCK) & pbt[rep_blk]);
3789 pbt[blk] = replace_node;
3790 pbt[rep_blk] = tmp_blk;
3791
3792 #if CMD_DMA
3793 p_BTableChangesDelta =
3794 (struct BTableChangesDelta *)g_pBTDelta_Free;
3795 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
3796
3797 p_BTableChangesDelta->ftl_cmd_cnt = ftl_cmd_cnt;
3798 p_BTableChangesDelta->BT_Index = blk;
3799 p_BTableChangesDelta->BT_Entry_Value = pbt[blk];
3800
3801 p_BTableChangesDelta->ValidFields = 0x0C;
3802
3803 p_BTableChangesDelta =
3804 (struct BTableChangesDelta *)g_pBTDelta_Free;
3805 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
3806
3807 p_BTableChangesDelta->ftl_cmd_cnt = ftl_cmd_cnt;
3808 p_BTableChangesDelta->BT_Index = rep_blk;
3809 p_BTableChangesDelta->BT_Entry_Value = pbt[rep_blk];
3810 p_BTableChangesDelta->ValidFields = 0x0C;
3811 #endif
3812 }
3813
3814 return replace_node;
3815 }
3816
3817 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3818 * Function: FTL_Write_Block_Table_Data
3819 * Inputs: Block table size in pages
3820 * Outputs: PASS=0 / FAIL=1
3821 * Description: Write block table data in flash
3822 * If first page and last page
3823 * Write data+BT flag
3824 * else
3825 * Write data
3826 * BT flag is a counter. Its value is incremented for block table
3827 * write in a new Block
3828 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
3829 static int FTL_Write_Block_Table_Data(void)
3830 {
3831 u64 dwBlockTableAddr, pTempAddr;
3832 u32 Block;
3833 u16 Page, PageCount;
3834 u8 *tempBuf = tmp_buf_write_blk_table_data;
3835 int wBytesCopied;
3836 u16 bt_pages;
3837
3838 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
3839 __FILE__, __LINE__, __func__);
3840
3841 dwBlockTableAddr =
3842 (u64)((u64)g_wBlockTableIndex * DeviceInfo.wBlockDataSize +
3843 (u64)g_wBlockTableOffset * DeviceInfo.wPageDataSize);
3844 pTempAddr = dwBlockTableAddr;
3845
3846 bt_pages = FTL_Get_Block_Table_Flash_Size_Pages();
3847
3848 nand_dbg_print(NAND_DBG_DEBUG, "FTL_Write_Block_Table_Data: "
3849 "page= %d BlockTableIndex= %d "
3850 "BlockTableOffset=%d\n", bt_pages,
3851 g_wBlockTableIndex, g_wBlockTableOffset);
3852
3853 Block = BLK_FROM_ADDR(pTempAddr);
3854 Page = PAGE_FROM_ADDR(pTempAddr, Block);
3855 PageCount = 1;
3856
3857 if (bt_block_changed) {
3858 if (bt_flag == LAST_BT_ID) {
3859 bt_flag = FIRST_BT_ID;
3860 g_pBTBlocks[bt_flag - FIRST_BT_ID] = Block;
3861 } else if (bt_flag < LAST_BT_ID) {
3862 bt_flag++;
3863 g_pBTBlocks[bt_flag - FIRST_BT_ID] = Block;
3864 }
3865
3866 if ((bt_flag > (LAST_BT_ID-4)) &&
3867 g_pBTBlocks[FIRST_BT_ID - FIRST_BT_ID] !=
3868 BTBLOCK_INVAL) {
3869 bt_block_changed = 0;
3870 GLOB_FTL_BT_Garbage_Collection();
3871 }
3872
3873 bt_block_changed = 0;
3874 nand_dbg_print(NAND_DBG_DEBUG,
3875 "Block Table Counter is %u Block %u\n",
3876 bt_flag, (unsigned int)Block);
3877 }
3878
3879 memset(tempBuf, 0, 3);
3880 tempBuf[3] = bt_flag;
3881 wBytesCopied = FTL_Copy_Block_Table_To_Flash(tempBuf + 4,
3882 DeviceInfo.wPageDataSize - 4, 0);
3883 memset(&tempBuf[wBytesCopied + 4], 0xff,
3884 DeviceInfo.wPageSize - (wBytesCopied + 4));
3885 FTL_Insert_Block_Table_Signature(&tempBuf[DeviceInfo.wPageDataSize],
3886 bt_flag);
3887
3888 #if CMD_DMA
3889 memcpy(g_pNextBlockTable, tempBuf,
3890 DeviceInfo.wPageSize * sizeof(u8));
3891 nand_dbg_print(NAND_DBG_DEBUG, "Writing First Page of Block Table "
3892 "Block %u Page %u\n", (unsigned int)Block, Page);
3893 if (FAIL == GLOB_LLD_Write_Page_Main_Spare_cdma(g_pNextBlockTable,
3894 Block, Page, 1,
3895 LLD_CMD_FLAG_MODE_CDMA | LLD_CMD_FLAG_ORDER_BEFORE_REST)) {
3896 nand_dbg_print(NAND_DBG_WARN, "NAND Program fail in "
3897 "%s, Line %d, Function: %s, "
3898 "new Bad Block %d generated!\n",
3899 __FILE__, __LINE__, __func__, Block);
3900 goto func_return;
3901 }
3902
3903 ftl_cmd_cnt++;
3904 g_pNextBlockTable += ((DeviceInfo.wPageSize * sizeof(u8)));
3905 #else
3906 if (FAIL == GLOB_LLD_Write_Page_Main_Spare(tempBuf, Block, Page, 1)) {
3907 nand_dbg_print(NAND_DBG_WARN,
3908 "NAND Program fail in %s, Line %d, Function: %s, "
3909 "new Bad Block %d generated!\n",
3910 __FILE__, __LINE__, __func__, Block);
3911 goto func_return;
3912 }
3913 #endif
3914
3915 if (bt_pages > 1) {
3916 PageCount = bt_pages - 1;
3917 if (PageCount > 1) {
3918 wBytesCopied += FTL_Copy_Block_Table_To_Flash(tempBuf,
3919 DeviceInfo.wPageDataSize * (PageCount - 1),
3920 wBytesCopied);
3921
3922 #if CMD_DMA
3923 memcpy(g_pNextBlockTable, tempBuf,
3924 (PageCount - 1) * DeviceInfo.wPageDataSize);
3925 if (FAIL == GLOB_LLD_Write_Page_Main_cdma(
3926 g_pNextBlockTable, Block, Page + 1,
3927 PageCount - 1)) {
3928 nand_dbg_print(NAND_DBG_WARN,
3929 "NAND Program fail in %s, Line %d, "
3930 "Function: %s, "
3931 "new Bad Block %d generated!\n",
3932 __FILE__, __LINE__, __func__,
3933 (int)Block);
3934 goto func_return;
3935 }
3936
3937 ftl_cmd_cnt++;
3938 g_pNextBlockTable += (PageCount - 1) *
3939 DeviceInfo.wPageDataSize * sizeof(u8);
3940 #else
3941 if (FAIL == GLOB_LLD_Write_Page_Main(tempBuf,
3942 Block, Page + 1, PageCount - 1)) {
3943 nand_dbg_print(NAND_DBG_WARN,
3944 "NAND Program fail in %s, Line %d, "
3945 "Function: %s, "
3946 "new Bad Block %d generated!\n",
3947 __FILE__, __LINE__, __func__,
3948 (int)Block);
3949 goto func_return;
3950 }
3951 #endif
3952 }
3953
3954 wBytesCopied = FTL_Copy_Block_Table_To_Flash(tempBuf,
3955 DeviceInfo.wPageDataSize, wBytesCopied);
3956 memset(&tempBuf[wBytesCopied], 0xff,
3957 DeviceInfo.wPageSize-wBytesCopied);
3958 FTL_Insert_Block_Table_Signature(
3959 &tempBuf[DeviceInfo.wPageDataSize], bt_flag);
3960 #if CMD_DMA
3961 memcpy(g_pNextBlockTable, tempBuf,
3962 DeviceInfo.wPageSize * sizeof(u8));
3963 nand_dbg_print(NAND_DBG_DEBUG,
3964 "Writing the last Page of Block Table "
3965 "Block %u Page %u\n",
3966 (unsigned int)Block, Page + bt_pages - 1);
3967 if (FAIL == GLOB_LLD_Write_Page_Main_Spare_cdma(
3968 g_pNextBlockTable, Block, Page + bt_pages - 1, 1,
3969 LLD_CMD_FLAG_MODE_CDMA |
3970 LLD_CMD_FLAG_ORDER_BEFORE_REST)) {
3971 nand_dbg_print(NAND_DBG_WARN,
3972 "NAND Program fail in %s, Line %d, "
3973 "Function: %s, new Bad Block %d generated!\n",
3974 __FILE__, __LINE__, __func__, Block);
3975 goto func_return;
3976 }
3977 ftl_cmd_cnt++;
3978 #else
3979 if (FAIL == GLOB_LLD_Write_Page_Main_Spare(tempBuf,
3980 Block, Page+bt_pages - 1, 1)) {
3981 nand_dbg_print(NAND_DBG_WARN,
3982 "NAND Program fail in %s, Line %d, "
3983 "Function: %s, "
3984 "new Bad Block %d generated!\n",
3985 __FILE__, __LINE__, __func__, Block);
3986 goto func_return;
3987 }
3988 #endif
3989 }
3990
3991 nand_dbg_print(NAND_DBG_DEBUG, "FTL_Write_Block_Table_Data: done\n");
3992
3993 func_return:
3994 return PASS;
3995 }
3996
3997 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
3998 * Function: FTL_Replace_Block_Table
3999 * Inputs: None
4000 * Outputs: PASS=0 / FAIL=1
4001 * Description: Get a new block to write block table
4002 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4003 static u32 FTL_Replace_Block_Table(void)
4004 {
4005 u32 blk;
4006 int gc;
4007
4008 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
4009 __FILE__, __LINE__, __func__);
4010
4011 blk = FTL_Replace_LWBlock(BLOCK_TABLE_INDEX, &gc);
4012
4013 if ((BAD_BLOCK == blk) && (PASS == gc)) {
4014 GLOB_FTL_Garbage_Collection();
4015 blk = FTL_Replace_LWBlock(BLOCK_TABLE_INDEX, &gc);
4016 }
4017 if (BAD_BLOCK == blk)
4018 printk(KERN_ERR "%s, %s: There is no spare block. "
4019 "It should never happen\n",
4020 __FILE__, __func__);
4021
4022 nand_dbg_print(NAND_DBG_DEBUG, "New Block table Block is %d\n", blk);
4023
4024 return blk;
4025 }
4026
4027 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4028 * Function: FTL_Replace_LWBlock
4029 * Inputs: Block number
4030 * Pointer to Garbage Collect flag
4031 * Outputs:
4032 * Description: Determine the least weared block by traversing
4033 * block table
4034 * Set Garbage collection to be called if number of spare
4035 * block is less than Free Block Gate count
4036 * Change Block table entry to map least worn block for current
4037 * operation
4038 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4039 static u32 FTL_Replace_LWBlock(u32 wBlockNum, int *pGarbageCollect)
4040 {
4041 u32 i;
4042 u32 *pbt = (u32 *)g_pBlockTable;
4043 u8 wLeastWornCounter = 0xFF;
4044 u32 wLeastWornIndex = BAD_BLOCK;
4045 u32 wSpareBlockNum = 0;
4046 u32 wDiscardBlockNum = 0;
4047
4048 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
4049 __FILE__, __LINE__, __func__);
4050
4051 if (IS_SPARE_BLOCK(wBlockNum)) {
4052 *pGarbageCollect = FAIL;
4053 pbt[wBlockNum] = (u32)(pbt[wBlockNum] & (~SPARE_BLOCK));
4054 #if CMD_DMA
4055 p_BTableChangesDelta =
4056 (struct BTableChangesDelta *)g_pBTDelta_Free;
4057 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
4058 p_BTableChangesDelta->ftl_cmd_cnt =
4059 ftl_cmd_cnt;
4060 p_BTableChangesDelta->BT_Index = (u32)(wBlockNum);
4061 p_BTableChangesDelta->BT_Entry_Value = pbt[wBlockNum];
4062 p_BTableChangesDelta->ValidFields = 0x0C;
4063 #endif
4064 return pbt[wBlockNum];
4065 }
4066
4067 for (i = 0; i < DeviceInfo.wDataBlockNum; i++) {
4068 if (IS_DISCARDED_BLOCK(i))
4069 wDiscardBlockNum++;
4070
4071 if (IS_SPARE_BLOCK(i)) {
4072 u32 wPhysicalIndex = (u32)((~BAD_BLOCK) & pbt[i]);
4073 if (wPhysicalIndex > DeviceInfo.wSpectraEndBlock)
4074 printk(KERN_ERR "FTL_Replace_LWBlock: "
4075 "This should never occur!\n");
4076 if (g_pWearCounter[wPhysicalIndex -
4077 DeviceInfo.wSpectraStartBlock] <
4078 wLeastWornCounter) {
4079 wLeastWornCounter =
4080 g_pWearCounter[wPhysicalIndex -
4081 DeviceInfo.wSpectraStartBlock];
4082 wLeastWornIndex = i;
4083 }
4084 wSpareBlockNum++;
4085 }
4086 }
4087
4088 nand_dbg_print(NAND_DBG_WARN,
4089 "FTL_Replace_LWBlock: Least Worn Counter %d\n",
4090 (int)wLeastWornCounter);
4091
4092 if ((wDiscardBlockNum >= NUM_FREE_BLOCKS_GATE) ||
4093 (wSpareBlockNum <= NUM_FREE_BLOCKS_GATE))
4094 *pGarbageCollect = PASS;
4095 else
4096 *pGarbageCollect = FAIL;
4097
4098 nand_dbg_print(NAND_DBG_DEBUG,
4099 "FTL_Replace_LWBlock: Discarded Blocks %u Spare"
4100 " Blocks %u\n",
4101 (unsigned int)wDiscardBlockNum,
4102 (unsigned int)wSpareBlockNum);
4103
4104 return FTL_Replace_OneBlock(wBlockNum, wLeastWornIndex);
4105 }
4106
4107 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4108 * Function: FTL_Replace_MWBlock
4109 * Inputs: None
4110 * Outputs: most worn spare block no./BAD_BLOCK
4111 * Description: It finds most worn spare block.
4112 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4113 static u32 FTL_Replace_MWBlock(void)
4114 {
4115 u32 i;
4116 u32 *pbt = (u32 *)g_pBlockTable;
4117 u8 wMostWornCounter = 0;
4118 u32 wMostWornIndex = BAD_BLOCK;
4119 u32 wSpareBlockNum = 0;
4120
4121 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
4122 __FILE__, __LINE__, __func__);
4123
4124 for (i = 0; i < DeviceInfo.wDataBlockNum; i++) {
4125 if (IS_SPARE_BLOCK(i)) {
4126 u32 wPhysicalIndex = (u32)((~SPARE_BLOCK) & pbt[i]);
4127 if (g_pWearCounter[wPhysicalIndex -
4128 DeviceInfo.wSpectraStartBlock] >
4129 wMostWornCounter) {
4130 wMostWornCounter =
4131 g_pWearCounter[wPhysicalIndex -
4132 DeviceInfo.wSpectraStartBlock];
4133 wMostWornIndex = wPhysicalIndex;
4134 }
4135 wSpareBlockNum++;
4136 }
4137 }
4138
4139 if (wSpareBlockNum <= 2)
4140 return BAD_BLOCK;
4141
4142 return wMostWornIndex;
4143 }
4144
4145 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4146 * Function: FTL_Replace_Block
4147 * Inputs: Block Address
4148 * Outputs: PASS=0 / FAIL=1
4149 * Description: If block specified by blk_addr parameter is not free,
4150 * replace it with the least worn block.
4151 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4152 static int FTL_Replace_Block(u64 blk_addr)
4153 {
4154 u32 current_blk = BLK_FROM_ADDR(blk_addr);
4155 u32 *pbt = (u32 *)g_pBlockTable;
4156 int wResult = PASS;
4157 int GarbageCollect = FAIL;
4158
4159 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
4160 __FILE__, __LINE__, __func__);
4161
4162 if (IS_SPARE_BLOCK(current_blk)) {
4163 pbt[current_blk] = (~SPARE_BLOCK) & pbt[current_blk];
4164 #if CMD_DMA
4165 p_BTableChangesDelta =
4166 (struct BTableChangesDelta *)g_pBTDelta_Free;
4167 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
4168 p_BTableChangesDelta->ftl_cmd_cnt =
4169 ftl_cmd_cnt;
4170 p_BTableChangesDelta->BT_Index = current_blk;
4171 p_BTableChangesDelta->BT_Entry_Value = pbt[current_blk];
4172 p_BTableChangesDelta->ValidFields = 0x0C ;
4173 #endif
4174 return wResult;
4175 }
4176
4177 FTL_Replace_LWBlock(current_blk, &GarbageCollect);
4178
4179 if (PASS == GarbageCollect)
4180 wResult = GLOB_FTL_Garbage_Collection();
4181
4182 return wResult;
4183 }
4184
4185 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4186 * Function: GLOB_FTL_Is_BadBlock
4187 * Inputs: block number to test
4188 * Outputs: PASS (block is BAD) / FAIL (block is not bad)
4189 * Description: test if this block number is flagged as bad
4190 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4191 int GLOB_FTL_Is_BadBlock(u32 wBlockNum)
4192 {
4193 u32 *pbt = (u32 *)g_pBlockTable;
4194
4195 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
4196 __FILE__, __LINE__, __func__);
4197
4198 if (wBlockNum >= DeviceInfo.wSpectraStartBlock
4199 && BAD_BLOCK == (pbt[wBlockNum] & BAD_BLOCK))
4200 return PASS;
4201 else
4202 return FAIL;
4203 }
4204
4205 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4206 * Function: GLOB_FTL_Flush_Cache
4207 * Inputs: none
4208 * Outputs: PASS=0 / FAIL=1
4209 * Description: flush all the cache blocks to flash
4210 * if a cache block is not dirty, don't do anything with it
4211 * else, write the block and update the block table
4212 * Note: This function should be called at shutdown/power down.
4213 * to write important data into device
4214 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4215 int GLOB_FTL_Flush_Cache(void)
4216 {
4217 int i, ret;
4218
4219 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d, Function: %s\n",
4220 __FILE__, __LINE__, __func__);
4221
4222 for (i = 0; i < CACHE_ITEM_NUM; i++) {
4223 if (SET == Cache.array[i].changed) {
4224 #if CMD_DMA
4225 #if RESTORE_CACHE_ON_CDMA_CHAIN_FAILURE
4226 int_cache[ftl_cmd_cnt].item = i;
4227 int_cache[ftl_cmd_cnt].cache.address =
4228 Cache.array[i].address;
4229 int_cache[ftl_cmd_cnt].cache.changed = CLEAR;
4230 #endif
4231 #endif
4232 ret = write_back_to_l2_cache(Cache.array[i].buf, Cache.array[i].address);
4233 if (PASS == ret) {
4234 Cache.array[i].changed = CLEAR;
4235 } else {
4236 printk(KERN_ALERT "Failed when write back to L2 cache!\n");
4237 /* TODO - How to handle this? */
4238 }
4239 }
4240 }
4241
4242 flush_l2_cache();
4243
4244 return FTL_Write_Block_Table(FAIL);
4245 }
4246
4247 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4248 * Function: GLOB_FTL_Page_Read
4249 * Inputs: pointer to data
4250 * logical address of data (u64 is LBA * Bytes/Page)
4251 * Outputs: PASS=0 / FAIL=1
4252 * Description: reads a page of data into RAM from the cache
4253 * if the data is not already in cache, read from flash to cache
4254 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4255 int GLOB_FTL_Page_Read(u8 *data, u64 logical_addr)
4256 {
4257 u16 cache_item;
4258 int res = PASS;
4259
4260 nand_dbg_print(NAND_DBG_DEBUG, "GLOB_FTL_Page_Read - "
4261 "page_addr: %llu\n", logical_addr);
4262
4263 cache_item = FTL_Cache_If_Hit(logical_addr);
4264
4265 if (UNHIT_CACHE_ITEM == cache_item) {
4266 nand_dbg_print(NAND_DBG_DEBUG,
4267 "GLOB_FTL_Page_Read: Cache not hit\n");
4268 res = FTL_Cache_Write();
4269 if (ERR == FTL_Cache_Read(logical_addr))
4270 res = ERR;
4271 cache_item = Cache.LRU;
4272 }
4273
4274 FTL_Cache_Read_Page(data, logical_addr, cache_item);
4275
4276 return res;
4277 }
4278
4279 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4280 * Function: GLOB_FTL_Page_Write
4281 * Inputs: pointer to data
4282 * address of data (ADDRESSTYPE is LBA * Bytes/Page)
4283 * Outputs: PASS=0 / FAIL=1
4284 * Description: writes a page of data from RAM to the cache
4285 * if the data is not already in cache, write back the
4286 * least recently used block and read the addressed block
4287 * from flash to cache
4288 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4289 int GLOB_FTL_Page_Write(u8 *pData, u64 dwPageAddr)
4290 {
4291 u16 cache_blk;
4292 u32 *pbt = (u32 *)g_pBlockTable;
4293 int wResult = PASS;
4294
4295 nand_dbg_print(NAND_DBG_TRACE, "GLOB_FTL_Page_Write - "
4296 "dwPageAddr: %llu\n", dwPageAddr);
4297
4298 cache_blk = FTL_Cache_If_Hit(dwPageAddr);
4299
4300 if (UNHIT_CACHE_ITEM == cache_blk) {
4301 wResult = FTL_Cache_Write();
4302 if (IS_BAD_BLOCK(BLK_FROM_ADDR(dwPageAddr))) {
4303 wResult = FTL_Replace_Block(dwPageAddr);
4304 pbt[BLK_FROM_ADDR(dwPageAddr)] |= SPARE_BLOCK;
4305 if (wResult == FAIL)
4306 return FAIL;
4307 }
4308 if (ERR == FTL_Cache_Read(dwPageAddr))
4309 wResult = ERR;
4310 cache_blk = Cache.LRU;
4311 FTL_Cache_Write_Page(pData, dwPageAddr, cache_blk, 0);
4312 } else {
4313 #if CMD_DMA
4314 FTL_Cache_Write_Page(pData, dwPageAddr, cache_blk,
4315 LLD_CMD_FLAG_ORDER_BEFORE_REST);
4316 #else
4317 FTL_Cache_Write_Page(pData, dwPageAddr, cache_blk, 0);
4318 #endif
4319 }
4320
4321 return wResult;
4322 }
4323
4324 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4325 * Function: GLOB_FTL_Block_Erase
4326 * Inputs: address of block to erase (now in byte format, should change to
4327 * block format)
4328 * Outputs: PASS=0 / FAIL=1
4329 * Description: erases the specified block
4330 * increments the erase count
4331 * If erase count reaches its upper limit,call function to
4332 * do the ajustment as per the relative erase count values
4333 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4334 int GLOB_FTL_Block_Erase(u64 blk_addr)
4335 {
4336 int status;
4337 u32 BlkIdx;
4338
4339 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
4340 __FILE__, __LINE__, __func__);
4341
4342 BlkIdx = (u32)(blk_addr >> DeviceInfo.nBitsInBlockDataSize);
4343
4344 if (BlkIdx < DeviceInfo.wSpectraStartBlock) {
4345 printk(KERN_ERR "GLOB_FTL_Block_Erase: "
4346 "This should never occur\n");
4347 return FAIL;
4348 }
4349
4350 #if CMD_DMA
4351 status = GLOB_LLD_Erase_Block_cdma(BlkIdx, LLD_CMD_FLAG_MODE_CDMA);
4352 if (status == FAIL)
4353 nand_dbg_print(NAND_DBG_WARN,
4354 "NAND Program fail in %s, Line %d, "
4355 "Function: %s, new Bad Block %d generated!\n",
4356 __FILE__, __LINE__, __func__, BlkIdx);
4357 #else
4358 status = GLOB_LLD_Erase_Block(BlkIdx);
4359 if (status == FAIL) {
4360 nand_dbg_print(NAND_DBG_WARN,
4361 "NAND Program fail in %s, Line %d, "
4362 "Function: %s, new Bad Block %d generated!\n",
4363 __FILE__, __LINE__, __func__, BlkIdx);
4364 return status;
4365 }
4366 #endif
4367
4368 if (DeviceInfo.MLCDevice) {
4369 g_pReadCounter[BlkIdx - DeviceInfo.wSpectraStartBlock] = 0;
4370 if (g_cBlockTableStatus != IN_PROGRESS_BLOCK_TABLE) {
4371 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
4372 FTL_Write_IN_Progress_Block_Table_Page();
4373 }
4374 }
4375
4376 g_pWearCounter[BlkIdx - DeviceInfo.wSpectraStartBlock]++;
4377
4378 #if CMD_DMA
4379 p_BTableChangesDelta =
4380 (struct BTableChangesDelta *)g_pBTDelta_Free;
4381 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
4382 p_BTableChangesDelta->ftl_cmd_cnt = ftl_cmd_cnt;
4383 p_BTableChangesDelta->WC_Index =
4384 BlkIdx - DeviceInfo.wSpectraStartBlock;
4385 p_BTableChangesDelta->WC_Entry_Value =
4386 g_pWearCounter[BlkIdx - DeviceInfo.wSpectraStartBlock];
4387 p_BTableChangesDelta->ValidFields = 0x30;
4388
4389 if (DeviceInfo.MLCDevice) {
4390 p_BTableChangesDelta =
4391 (struct BTableChangesDelta *)g_pBTDelta_Free;
4392 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
4393 p_BTableChangesDelta->ftl_cmd_cnt =
4394 ftl_cmd_cnt;
4395 p_BTableChangesDelta->RC_Index =
4396 BlkIdx - DeviceInfo.wSpectraStartBlock;
4397 p_BTableChangesDelta->RC_Entry_Value =
4398 g_pReadCounter[BlkIdx -
4399 DeviceInfo.wSpectraStartBlock];
4400 p_BTableChangesDelta->ValidFields = 0xC0;
4401 }
4402
4403 ftl_cmd_cnt++;
4404 #endif
4405
4406 if (g_pWearCounter[BlkIdx - DeviceInfo.wSpectraStartBlock] == 0xFE)
4407 FTL_Adjust_Relative_Erase_Count(BlkIdx);
4408
4409 return status;
4410 }
4411
4412
4413 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4414 * Function: FTL_Adjust_Relative_Erase_Count
4415 * Inputs: index to block that was just incremented and is at the max
4416 * Outputs: PASS=0 / FAIL=1
4417 * Description: If any erase counts at MAX, adjusts erase count of every
4418 * block by substracting least worn
4419 * counter from counter value of every entry in wear table
4420 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4421 static int FTL_Adjust_Relative_Erase_Count(u32 Index_of_MAX)
4422 {
4423 u8 wLeastWornCounter = MAX_BYTE_VALUE;
4424 u8 wWearCounter;
4425 u32 i, wWearIndex;
4426 u32 *pbt = (u32 *)g_pBlockTable;
4427 int wResult = PASS;
4428
4429 nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
4430 __FILE__, __LINE__, __func__);
4431
4432 for (i = 0; i < DeviceInfo.wDataBlockNum; i++) {
4433 if (IS_BAD_BLOCK(i))
4434 continue;
4435 wWearIndex = (u32)(pbt[i] & (~BAD_BLOCK));
4436
4437 if ((wWearIndex - DeviceInfo.wSpectraStartBlock) < 0)
4438 printk(KERN_ERR "FTL_Adjust_Relative_Erase_Count:"
4439 "This should never occur\n");
4440 wWearCounter = g_pWearCounter[wWearIndex -
4441 DeviceInfo.wSpectraStartBlock];
4442 if (wWearCounter < wLeastWornCounter)
4443 wLeastWornCounter = wWearCounter;
4444 }
4445
4446 if (wLeastWornCounter == 0) {
4447 nand_dbg_print(NAND_DBG_WARN,
4448 "Adjusting Wear Levelling Counters: Special Case\n");
4449 g_pWearCounter[Index_of_MAX -
4450 DeviceInfo.wSpectraStartBlock]--;
4451 #if CMD_DMA
4452 p_BTableChangesDelta =
4453 (struct BTableChangesDelta *)g_pBTDelta_Free;
4454 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
4455 p_BTableChangesDelta->ftl_cmd_cnt = ftl_cmd_cnt;
4456 p_BTableChangesDelta->WC_Index =
4457 Index_of_MAX - DeviceInfo.wSpectraStartBlock;
4458 p_BTableChangesDelta->WC_Entry_Value =
4459 g_pWearCounter[Index_of_MAX -
4460 DeviceInfo.wSpectraStartBlock];
4461 p_BTableChangesDelta->ValidFields = 0x30;
4462 #endif
4463 FTL_Static_Wear_Leveling();
4464 } else {
4465 for (i = 0; i < DeviceInfo.wDataBlockNum; i++)
4466 if (!IS_BAD_BLOCK(i)) {
4467 wWearIndex = (u32)(pbt[i] & (~BAD_BLOCK));
4468 g_pWearCounter[wWearIndex -
4469 DeviceInfo.wSpectraStartBlock] =
4470 (u8)(g_pWearCounter
4471 [wWearIndex -
4472 DeviceInfo.wSpectraStartBlock] -
4473 wLeastWornCounter);
4474 #if CMD_DMA
4475 p_BTableChangesDelta =
4476 (struct BTableChangesDelta *)g_pBTDelta_Free;
4477 g_pBTDelta_Free +=
4478 sizeof(struct BTableChangesDelta);
4479
4480 p_BTableChangesDelta->ftl_cmd_cnt =
4481 ftl_cmd_cnt;
4482 p_BTableChangesDelta->WC_Index = wWearIndex -
4483 DeviceInfo.wSpectraStartBlock;
4484 p_BTableChangesDelta->WC_Entry_Value =
4485 g_pWearCounter[wWearIndex -
4486 DeviceInfo.wSpectraStartBlock];
4487 p_BTableChangesDelta->ValidFields = 0x30;
4488 #endif
4489 }
4490 }
4491
4492 return wResult;
4493 }
4494
4495 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4496 * Function: FTL_Write_IN_Progress_Block_Table_Page
4497 * Inputs: None
4498 * Outputs: None
4499 * Description: It writes in-progress flag page to the page next to
4500 * block table
4501 ***********************************************************************/
4502 static int FTL_Write_IN_Progress_Block_Table_Page(void)
4503 {
4504 int wResult = PASS;
4505 u16 bt_pages;
4506 u16 dwIPFPageAddr;
4507 #if CMD_DMA
4508 #else
4509 u32 *pbt = (u32 *)g_pBlockTable;
4510 u32 wTempBlockTableIndex;
4511 #endif
4512
4513 nand_dbg_print(NAND_DBG_WARN, "%s, Line %d, Function: %s\n",
4514 __FILE__, __LINE__, __func__);
4515
4516 bt_pages = FTL_Get_Block_Table_Flash_Size_Pages();
4517
4518 dwIPFPageAddr = g_wBlockTableOffset + bt_pages;
4519
4520 nand_dbg_print(NAND_DBG_DEBUG, "Writing IPF at "
4521 "Block %d Page %d\n",
4522 g_wBlockTableIndex, dwIPFPageAddr);
4523
4524 #if CMD_DMA
4525 wResult = GLOB_LLD_Write_Page_Main_Spare_cdma(g_pIPF,
4526 g_wBlockTableIndex, dwIPFPageAddr, 1,
4527 LLD_CMD_FLAG_MODE_CDMA | LLD_CMD_FLAG_ORDER_BEFORE_REST);
4528 if (wResult == FAIL) {
4529 nand_dbg_print(NAND_DBG_WARN,
4530 "NAND Program fail in %s, Line %d, "
4531 "Function: %s, new Bad Block %d generated!\n",
4532 __FILE__, __LINE__, __func__,
4533 g_wBlockTableIndex);
4534 }
4535 g_wBlockTableOffset = dwIPFPageAddr + 1;
4536 p_BTableChangesDelta = (struct BTableChangesDelta *)g_pBTDelta_Free;
4537 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
4538 p_BTableChangesDelta->ftl_cmd_cnt = ftl_cmd_cnt;
4539 p_BTableChangesDelta->g_wBlockTableOffset = g_wBlockTableOffset;
4540 p_BTableChangesDelta->ValidFields = 0x01;
4541 ftl_cmd_cnt++;
4542 #else
4543 wResult = GLOB_LLD_Write_Page_Main_Spare(g_pIPF,
4544 g_wBlockTableIndex, dwIPFPageAddr, 1);
4545 if (wResult == FAIL) {
4546 nand_dbg_print(NAND_DBG_WARN,
4547 "NAND Program fail in %s, Line %d, "
4548 "Function: %s, new Bad Block %d generated!\n",
4549 __FILE__, __LINE__, __func__,
4550 (int)g_wBlockTableIndex);
4551 MARK_BLOCK_AS_BAD(pbt[BLOCK_TABLE_INDEX]);
4552 wTempBlockTableIndex = FTL_Replace_Block_Table();
4553 bt_block_changed = 1;
4554 if (BAD_BLOCK == wTempBlockTableIndex)
4555 return ERR;
4556 g_wBlockTableIndex = wTempBlockTableIndex;
4557 g_wBlockTableOffset = 0;
4558 /* Block table tag is '00'. Means it's used one */
4559 pbt[BLOCK_TABLE_INDEX] = g_wBlockTableIndex;
4560 return FAIL;
4561 }
4562 g_wBlockTableOffset = dwIPFPageAddr + 1;
4563 #endif
4564 return wResult;
4565 }
4566
4567 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4568 * Function: FTL_Read_Disturbance
4569 * Inputs: block address
4570 * Outputs: PASS=0 / FAIL=1
4571 * Description: used to handle read disturbance. Data in block that
4572 * reaches its read limit is moved to new block
4573 *&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
4574 int FTL_Read_Disturbance(u32 blk_addr)
4575 {
4576 int wResult = FAIL;
4577 u32 *pbt = (u32 *) g_pBlockTable;
4578 u32 dwOldBlockAddr = blk_addr;
4579 u32 wBlockNum;
4580 u32 i;
4581 u32 wLeastReadCounter = 0xFFFF;
4582 u32 wLeastReadIndex = BAD_BLOCK;
4583 u32 wSpareBlockNum = 0;
4584 u32 wTempNode;
4585 u32 wReplacedNode;
4586 u8 *g_pTempBuf;
4587
4588 nand_dbg_print(NAND_DBG_DEBUG, "%s, Line %d, Function: %s\n",
4589 __FILE__, __LINE__, __func__);
4590
4591 #if CMD_DMA
4592 g_pTempBuf = cp_back_buf_copies[cp_back_buf_idx];
4593 cp_back_buf_idx++;
4594 if (cp_back_buf_idx > COPY_BACK_BUF_NUM) {
4595 printk(KERN_ERR "cp_back_buf_copies overflow! Exit."
4596 "Maybe too many pending commands in your CDMA chain.\n");
4597 return FAIL;
4598 }
4599 #else
4600 g_pTempBuf = tmp_buf_read_disturbance;
4601 #endif
4602
4603 wBlockNum = FTL_Get_Block_Index(blk_addr);
4604
4605 do {
4606 /* This is a bug.Here 'i' should be logical block number
4607 * and start from 1 (0 is reserved for block table).
4608 * Have fixed it. - Yunpeng 2008. 12. 19
4609 */
4610 for (i = 1; i < DeviceInfo.wDataBlockNum; i++) {
4611 if (IS_SPARE_BLOCK(i)) {
4612 u32 wPhysicalIndex =
4613 (u32)((~SPARE_BLOCK) & pbt[i]);
4614 if (g_pReadCounter[wPhysicalIndex -
4615 DeviceInfo.wSpectraStartBlock] <
4616 wLeastReadCounter) {
4617 wLeastReadCounter =
4618 g_pReadCounter[wPhysicalIndex -
4619 DeviceInfo.wSpectraStartBlock];
4620 wLeastReadIndex = i;
4621 }
4622 wSpareBlockNum++;
4623 }
4624 }
4625
4626 if (wSpareBlockNum <= NUM_FREE_BLOCKS_GATE) {
4627 wResult = GLOB_FTL_Garbage_Collection();
4628 if (PASS == wResult)
4629 continue;
4630 else
4631 break;
4632 } else {
4633 wTempNode = (u32)(DISCARD_BLOCK | pbt[wBlockNum]);
4634 wReplacedNode = (u32)((~SPARE_BLOCK) &
4635 pbt[wLeastReadIndex]);
4636 #if CMD_DMA
4637 pbt[wBlockNum] = wReplacedNode;
4638 pbt[wLeastReadIndex] = wTempNode;
4639 p_BTableChangesDelta =
4640 (struct BTableChangesDelta *)g_pBTDelta_Free;
4641 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
4642
4643 p_BTableChangesDelta->ftl_cmd_cnt =
4644 ftl_cmd_cnt;
4645 p_BTableChangesDelta->BT_Index = wBlockNum;
4646 p_BTableChangesDelta->BT_Entry_Value = pbt[wBlockNum];
4647 p_BTableChangesDelta->ValidFields = 0x0C;
4648
4649 p_BTableChangesDelta =
4650 (struct BTableChangesDelta *)g_pBTDelta_Free;
4651 g_pBTDelta_Free += sizeof(struct BTableChangesDelta);
4652
4653 p_BTableChangesDelta->ftl_cmd_cnt =
4654 ftl_cmd_cnt;
4655 p_BTableChangesDelta->BT_Index = wLeastReadIndex;
4656 p_BTableChangesDelta->BT_Entry_Value =
4657 pbt[wLeastReadIndex];
4658 p_BTableChangesDelta->ValidFields = 0x0C;
4659
4660 wResult = GLOB_LLD_Read_Page_Main_cdma(g_pTempBuf,
4661 dwOldBlockAddr, 0, DeviceInfo.wPagesPerBlock,
4662 LLD_CMD_FLAG_MODE_CDMA);
4663 if (wResult == FAIL)
4664 return wResult;
4665
4666 ftl_cmd_cnt++;
4667
4668 if (wResult != FAIL) {
4669 if (FAIL == GLOB_LLD_Write_Page_Main_cdma(
4670 g_pTempBuf, pbt[wBlockNum], 0,
4671 DeviceInfo.wPagesPerBlock)) {
4672 nand_dbg_print(NAND_DBG_WARN,
4673 "NAND Program fail in "
4674 "%s, Line %d, Function: %s, "
4675 "new Bad Block %d "
4676 "generated!\n",
4677 __FILE__, __LINE__, __func__,
4678 (int)pbt[wBlockNum]);
4679 wResult = FAIL;
4680 MARK_BLOCK_AS_BAD(pbt[wBlockNum]);
4681 }
4682 ftl_cmd_cnt++;
4683 }
4684 #else
4685 wResult = GLOB_LLD_Read_Page_Main(g_pTempBuf,
4686 dwOldBlockAddr, 0, DeviceInfo.wPagesPerBlock);
4687 if (wResult == FAIL)
4688 return wResult;
4689
4690 if (wResult != FAIL) {
4691 /* This is a bug. At this time, pbt[wBlockNum]
4692 is still the physical address of
4693 discard block, and should not be write.
4694 Have fixed it as below.
4695 -- Yunpeng 2008.12.19
4696 */
4697 wResult = GLOB_LLD_Write_Page_Main(g_pTempBuf,
4698 wReplacedNode, 0,
4699 DeviceInfo.wPagesPerBlock);
4700 if (wResult == FAIL) {
4701 nand_dbg_print(NAND_DBG_WARN,
4702 "NAND Program fail in "
4703 "%s, Line %d, Function: %s, "
4704 "new Bad Block %d "
4705 "generated!\n",
4706 __FILE__, __LINE__, __func__,
4707 (int)wReplacedNode);
4708 MARK_BLOCK_AS_BAD(wReplacedNode);
4709 } else {
4710 pbt[wBlockNum] = wReplacedNode;
4711 pbt[wLeastReadIndex] = wTempNode;
4712 }
4713 }
4714
4715 if ((wResult == PASS) && (g_cBlockTableStatus !=
4716 IN_PROGRESS_BLOCK_TABLE)) {
4717 g_cBlockTableStatus = IN_PROGRESS_BLOCK_TABLE;
4718 FTL_Write_IN_Progress_Block_Table_Page();
4719 }
4720 #endif
4721 }
4722 } while (wResult != PASS)
4723 ;
4724
4725 #if CMD_DMA
4726 /* ... */
4727 #endif
4728
4729 return wResult;
4730 }
4731
kernel source for telekom puls (alcatel/mediatek)