Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Untitled

By: a guest on Jul 14th, 2012  |  syntax: None  |  size: 12.59 KB  |  hits: 13  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1.  
  2. static uint16_t isGoodBlock()
  3. {      
  4.         int blockNum;
  5.         int badblock = 0xFFFF; // or valid block or free block?
  6.        
  7.         for (blockNum = 0; i < yaftl_info.unkn184_0xA; blockNum++)
  8.         {
  9.                 if (yaftl_info.unknStructArray[i].field_8 == 0xFFFF) // need to identify this structure
  10.                 {  
  11.                         return blockNum;
  12.                 }
  13.         }
  14.        
  15.         return (badblock);
  16. }
  17.  
  18. static void ConvertP2C (unsigned int a1, unsigned int a2, unsigned int* blockArray)
  19. {
  20.         uint32_t _outPageNum, nand_geometry_vfl.total_ce;
  21.         uint32_t v1, v2;
  22.        
  23.         v1 = a2 * nand_geometry_vfl.pages_per_block;
  24.         v2 = _pagesPerBlock;
  25.        
  26.         if (!((a1 / nand_geometry_vfl.total_ce) && 0x1))
  27.                 v2 = a1 / nand_geometry_vfl.total_ce;
  28.                
  29.         _outPageNum = v2 | (v1 % nand_geometry_vfl.pages_per_block) | ((v1 - (v1 % nand_geometry_vfl.pages_per_block))*2);
  30.         _outCE = a1 % nand_geometry_vfl.total_ce;
  31.        
  32.         *blockArray = _outPageNum / nand_geometry_vfl.pages_per_block; 
  33. }
  34.  
  35.  
  36.  
  37. static void update_blockmap(uint32_t blocks)
  38. {
  39.         int i = 0;
  40.        
  41.         memset(freeVFLctxpage, 0xFFFFFFFF, 0x48); // find out where is freeVFLctxpage, this could also be a misnomer
  42.        
  43.         freeVFLctxpage[0].unkn0 = 1;
  44.        
  45.         while ((i <= 15) && (nand_geometry_vfl.total_banks >= i))
  46.         {
  47.                 freeVFLctxpage[i].unkn1 = i % nand_geometry_vfl.total_ce;      
  48.                 // &block_number_array[i] <-  another global var needs to be identified
  49.                 ConvertP2C(i, blocks, &block_number_array[i]);
  50.                 i ++;
  51.         }
  52. }
  53.  
  54. unsigned int ConvertC2P(unsigned int _phyBlock, unsigned int* out2, unsigned int* out3) { // just a place holder
  55.         *out2 = 1;
  56.         *out3 = 1;
  57.         return 1;
  58. }
  59.  
  60. unsigned int getBBT (unsigned int _block) // place holder
  61. {
  62.         return 1;
  63. }
  64.  
  65. unsigned int remapBlock (unsigned int _CE, unsigned int _phyBlock, unsigned int flag1, unsigned int* status)
  66. {
  67.         uint32_t good_block;
  68.         uint32_t BBT_bit;
  69.         uint32_t v1, v2, out, out2, out3, ret;
  70.         int i;
  71.  
  72.         good_block = getBBT(_phyBlock); // need to implement this function properly
  73.        
  74.         if (good_block) {
  75.                        
  76.                 if (flag1)
  77.                    BBT_bit = good_block;
  78.                
  79.                  //vflcxt[0x698] = 0xf40 for a typical 32GB device  
  80.                 for(i=0; i < nand_geometry_vfl.blocks_per_ce - (*((uint32_t*)(vflcxt + 0x698)) * nand_geometry_vfl.banks_per_ce); i++ )
  81.                 {
  82.                         if (_phyBlock == *(uint16_t*(vflcxt + 0x26 + i)))
  83.                                 break;
  84.             }
  85.            
  86.             if (i == nand_geometry_vfl.blocks_per_ce - (*((uint32_t*)(vflcxt + 0x698)) * nand_geometry_vfl.banks_per_ce))
  87.             {
  88.                     bufferPrintf("Error! \n");
  89.                     return 0xE;
  90.             }
  91.  
  92.             v1 = i / (nand_geometry_vfl.blocks_per_bank - *((uint32_t*)(vflcxt + 0x698)));
  93.             v2 = i % (nand_geometry_vfl.blocks_per_bank - *((uint32_t*)(vflcxt + 0x698)));
  94.  
  95.             ret = ConvertP2C(_CE + nand_geometry_vfl.total_ce * v1, vflcxt[0x698] + v2, &out);
  96.  
  97.             if(status != NULL)
  98.             {
  99.                     ret = ConvertC2P(_phyBlock, &out2, &out3); // need to implement this function properly
  100.                     if (_CE / nand_geometry_vfl.total_ce != out2)
  101.                         status = NULL;
  102.             }
  103.            
  104.             return (out);          
  105.     }
  106.    
  107.     else
  108.         return _phyBlock;
  109. }
  110.  
  111. static void vfl_Phy2C(int ftl_pageNum, int* phyCE, int* phyPageNum)
  112. {
  113.   uint32_t v1, v2, v3, v4;
  114.   uint32_t phyBlock, ret;
  115.  
  116.  
  117.   v1 = ftl_pageNum % nand_geometry_vfl.total_bank;
  118.   v2 = ftl_pageNum / nand_geometry_vfl.pages_per_block_total_bank;
  119.  
  120.   ret = ConvertP2C(v1, v2, &phyBlock);
  121.  
  122.   //printf("sub_5FF2A4EC: v1=%d, v2=%d, phyBlock=0x%04X\n",v1,v2,phyBlock);
  123.  
  124.   *phyCE = v1 % nand_geometry_vfl.total_ce;
  125.  
  126.   ret = remapBlock(*phyCE, phyBlock, 0, NULL);
  127.  
  128.   // printf("sub_5FF2A4EC: v1=%d, v2=%d, phyBlock=0x%04X, ret=%d\n",v1,v2,phyBlock,ret);
  129.    
  130.   v3 = pagesPerBlock * (nand_geometry_vfl.bytes_per_page * (ret / nand_geometry_vfl.blocks_per_bank) + (ret % nand_geometry_vfl.blocks_per_bank));
  131.  
  132.   v4 = (ftl_pageNum % nand_geometry_vfl.pages_per_block_total_bank) / nand_geometry_vfl.total_bank;
  133.  
  134.   *phyPageNum = v3 + v4;
  135.  
  136. }
  137.  
  138.  
  139. static int VFL_ReadScatteredPagesInVb(uint32_t* buf, uint16_t num_pages, uint8_t* data, UNKNBUFFERSTRUCT* meta, uint32_t* unkn, uint32_t flag1, uint32_t flag2, uint32_t* status)
  140. {      
  141.         int pages;
  142.         uint8_t vstatus = 0;
  143.  
  144.         if (unkn != NULL)
  145.                 *unkn = 0;
  146.        
  147.         for (pages = 0; pages <= num_pages; pages++)
  148.         {
  149.                 vfl_Phy2C(*(buf + i), &awScatteredReadCS[pages], &awScatteredReadPages[pages]); // have seen these but forgot where they are initialized
  150.         }
  151.        
  152.         int ret = h2fmi_Read_Scattered_Pages(&awScatteredReadCS[0], &awScatteredReadPages[0], data, meta, num_pages, &vstatus, unkn, flag1);
  153.        
  154.         if ((ret != 0) && (nand_geometry_vfl.status <= vstatus))
  155.         {
  156.                 bufferPrintf("VFL_ReadScatteredPagesInVb: mark page for refresh! \r\n");
  157.                 *unkn = 1;
  158.         }
  159.        
  160.         if (status != NULL)
  161.                 *status = ret;
  162.        
  163.         if (ret > 1)   
  164.         {
  165.                 update_blockmap(*buf / nand_geometry_ftl.pages_per_block_total_banks);
  166.                 return 0;
  167.         }
  168.        
  169.         return 1;
  170. }
  171.                
  172. static int YAFTL_readMultiPages(uint32_t* buf, uint32_t num_pages, a1, uint8_t* databuffer, UNKNBUFFERSTRUCT* unknBuf_array, a4, a5)
  173. {
  174.         UNKNBUFFERSTRUCT* metabuf_array = unknBuf_array;
  175.         int unkn = 0;
  176.         int status;
  177.         int ret_multi;
  178.         int ret_read;
  179.  
  180.         if (unknBuf_array == NULL)     
  181.                 metabuf_array = buffer20;
  182.        
  183.         for (i = 0; i < (num_pages / nand_geometry_ftl.pages_per_block_total_banks); i++)
  184.         {
  185.                 ret_multi = VFL_ReadScatteredPagesInVb(&buf[(i * nand_geometry_ftl.pages_per_block_total_banks)],nand_geometry_ftl.pages_per_block_total_banks, databuffer + i * nand_geometry_ftl.pages_per_block_total_banks * nand_geometry_ftl.bytes_per_page_ftl, metabuf_array, &unkn, 0, a4, &status);
  186.        
  187.                 if(!ret_multi)
  188.                 {
  189.                         bufferPrintf("yaftl:_readMultiPages: We got read failure!!\r\n");
  190.                         int flag = 1;
  191.                        
  192.                         int j;
  193.                         for (j = 0; j < nand_geometry_ftl.pages_per_block_total_banks; j++)
  194.                         {
  195.                                 ret_read = YAFTL_readPage(buf[(i * nand_geometry_ftl.pages_per_block_total_banks) + j], databuffer + (i * nand_geometry_ftl.pages_per_block_total_banks + j) * nand_geometry_ftl.bytes_per_page_ftl, metabuf_array[i * nand_geometry_ftl.pages_per_block_total_banks + j], a4, 1, a5)
  196.                                
  197.                                 if (ret_read)
  198.                                    flag = 0;
  199.                                
  200.                                 status = ret_read;
  201.                         }
  202.                        
  203.                         if (flag)
  204.                         bufferPrintf("yaftl:_readMultiPages: We were able to overcome read failure!!\r\n");
  205.                 }
  206.                 else
  207.                 {
  208.                         if (status)                              
  209.                                 return 0;
  210.                 }
  211.                
  212.             int blk;
  213.             blk = databuffer[(i + 1) * nand_geometry_ftl.pages_per_block_total_banks] / nand_geometry_ftl.pages_per_block_total_banks;
  214.                
  215.                 yaftl_info.block_array[blk].unkn3 ++;
  216.         }
  217.        
  218.         if (num_pages == (i * nand_geometry_ftl.pages_per_block_total_banks))
  219.                 return 1;
  220.                
  221.         int yaBlk = buf[(i - 1) * nand_geometry_ftl.pages_per_block_total_banks] / nand_geometry_ftl.pages_per_block_total_banks;
  222.         yaftl_info.block_array[blk].unkn3 ++;
  223.        
  224.         unkn = 0;
  225.         ret_multi = VFL_ReadScatteredPagesInVb(&buf[(i - 1) * nand_geometry_ftl.pages_per_block_total_banks], num_pages % nand_geometry_ftl.pages_per_block_total_banks, databuffer + (i - 1) * nand_geometry_ftl.pages_per_block_total_banks * nand_geometry_ftl.bytes_per_page_ftl, metabuf_array, &unkn, 0, a4, &status);
  226.        
  227.         if(!ret_multi)
  228.         {
  229.                 bufferPrintf("yaftl:_readMultiPages: We got read failure!!\r\n");
  230.                 flag = 1;
  231.  
  232.                 for (j = 0; j < nand_geometry_ftl.pages_per_block_total_banks; j++)
  233.                 {
  234.                         ret_read = YAFTL_readPage(buf[(i-1) * nand_geometry_ftl.pages_per_block_total_banks + j], databuffer + ((i-1) * nand_geometry_ftl.pages_per_block_total_banks + j) * nand_geometry_ftl.bytes_per_page_ftl, metabuf_array[(i-1) * nand_geometry_ftl.pages_per_block_total_banks + j], a4, 1, a5);
  235.                        
  236.                         if (ret_read)
  237.                            flag = 0;
  238.                        
  239.                         status = ret_read;
  240.                 }
  241.                
  242.                 if (flag)
  243.                 {
  244.                         bufferPrintf("yaftl:_readMultiPages: We were able to overcome read failure!!\r\n");
  245.                         return 1;
  246.                 }
  247.                 else
  248.                         return 0;
  249.         }
  250.        
  251.         else
  252.         {
  253.                 if (status >= 1)
  254.                         return 0;
  255.                        
  256.                 return (1 - status);
  257.         }
  258.        
  259. }
  260.  
  261. static int yaftl_verifyMetaData(uint32_t page_num, spareData* meta, uint32_t pages)
  262. {
  263.         int i;
  264.         for (i = 0; i != pages; i++)
  265.         {
  266.                 if (meta[i]->lpn != (page_num + i))
  267.                 {
  268.                         bufferPrintf("YAFTL_Read: mismatch between lpn and metadata! \r\n");
  269.                         return 0;
  270.                 }
  271.                
  272.                 if (meta[i]->pagetype & 0x40)
  273.                         return 0;
  274.         }
  275.        
  276.         return 1;
  277. }
  278.                        
  279.        
  280. static int YAFTL_Read (uint32_t page_num, uint32_t page_count, uint32_t* buf)
  281. {
  282.         int noBuf;
  283.         int temp;
  284.         int unkBlock;
  285.        
  286.         noBuf = (buf > 1) ? 0 : (1 - buf);
  287.        
  288.         if (noBuf && (page_count != 1))
  289.                 return (0x80000001);
  290.                
  291.         if ((page_num + page_count) >= yaftl_info.total_pages_ftl)
  292.                 return (0x80000001);
  293.                
  294.         set_ftl_region(page_num, 0, page_count, buf);
  295.        
  296.         yaftl_info.unk140_n1 = 0xFFFFFFFF;
  297.         yaftl_info.unk33C = 0;
  298.        
  299.         if ((page_count == 1) && noBuf)
  300.                 yaftl_info.unknBuffer3_ftl = 0xFFFFFFFF;
  301.        
  302.         uint32_t nothingToDo = (page_count == 1) ? (noBuf & 1) : 0;
  303.                
  304.         int ret = 0;
  305.         uint32_t pagesRead = 0;
  306.         uint16_t v30 = 0;
  307.         uint32_t v2c = 0;
  308.         uint32_t readbuf = buf;
  309.        
  310.         while (pagesRead != page_count)
  311.         {
  312.                 uint32_t ftl_block = (page_num + pagesRead) / yaftl_info.unkn3A_0x800;
  313.                 if ((yaftl_info.tocArray[ftl_block].TOCUnkMember1 == 0xFFFF) && (yaftl_info.tocArray[ftl_block].indexPage == 0xFFFFFFFF))
  314.                 {
  315.                         if (nothingToDo)
  316.                                 return 0;
  317.                                        
  318.                         if (yaftl_readMultiPages(yaftl_info.unknBuffer3_ftl, var30, var2C, nothingToDo, 0, 1)
  319.                                 {
  320.                                         if (!(yaftl_verifyMetaData(page_num + (var2C - buf) / nand_geometry_ftl.bytes_per_page_ftl, yaftl_info.buffer20, var30)))
  321.                                                 ret = 0x80000002;
  322.                                 }
  323.                                
  324.                                 else
  325.                                 {
  326.                                         ret = 0x80000002;
  327.                                 }
  328.                                                
  329.                         var30 = 0;                                     
  330.                        
  331.                                
  332.                         pagesRead ++;
  333.                         readbuf += nand_geometry_ftl.bytes_per_page_ftl;
  334.                 }
  335.                
  336.                 else
  337.                 {
  338.                         if (yaftl_info.tocArray[ftl_block].TOCUnkMember1 != 0xFFFF)
  339.                         {
  340.                                 yaftl_info.unknStructArray[yaftl_info.tocArray[ftl_block].TOCUnkMember1].field_8 ++ // need to id the structure
  341.                                 temp = *(uint32_t*)(&yaftl_info.unknStructArray[yaftl_info.tocArray[ftl_block].TOCUnkMember1].buffer[(page_num + pagesRead) % yaftl_info.unkn3A_0x800]);
  342.                         }
  343.                        
  344.                         else
  345.                         {
  346.                                 if ((unkBlock = isGoodBlock()) == 0xFFFF)
  347.                                 {
  348.                                         if (yaftl_info.unk140_n1 != ftl_block)
  349.                                         {
  350.                                        
  351.                                                 if ((ret = YAFTL_readPage(yaftl_info.tocArray[ftl_block].indexPage, yaftl_info.pageBuffer1, 0, 0, 1,1)) == 0)
  352.                                                 {
  353.                                                         yaftl_info.unk140_n1 = ftl_block;
  354.                                                 }
  355.                                                 else
  356.                                                 {
  357.                                                         set_ftl_region(0, 0, 0, 0);
  358.                                                         return ret;
  359.                                                 }
  360.                                         }
  361.                                
  362.                                         temp = yaftl_info.pageBuffer1[(page_num + pagesRead) % yaftl_info.unkn3A_0x800];
  363.                                 }
  364.                                
  365.                                 else
  366.                                 {
  367.                                         if (ret = (YAFTL_readPage(yaftl_info.tocArray[ftl_block].indexPage, &yaftl_info.unknStructArray[unkBlock].buffer[0], 0, 0, 1, 1)) == 0)
  368.                                                 yaftl_info.unkn4C --; // initiated in _readcxtinfo
  369.                                                 unknStructArray[unkBlock].field_A = 2; // need structure figured out of size 12 bytes
  370.                                                 unknStructArray[unkBlock].field_8 = 1;
  371.                                                 unknStructArray[unkBlock].field_4 = ftl_block;
  372.                                                 yaftl_info.tocArray[ftl_block].TOCUnkMember1 = unkBlock;
  373.                                                
  374.                                                 temp = *(uint32_t*)(&unknStructArray[yaftl_info.tocArray[ftl_block].TOCUnkMember1].buffer[(page_num + pagesRead) % yaftl_info.unkn3A_0x800]);
  375.                                                
  376.                                         else
  377.                                         {
  378.                                                 set_ftl_region(0, 0, 0, 0);
  379.                                                 return ret;
  380.                                         }
  381.                                 }
  382.                                
  383.                                 if (temp == 0xFFFFFFFF)
  384.                                 {
  385.                                         if (nothingToDo)
  386.                                                 return 0;
  387.                                        
  388.                                         if (yaftl_readMultiPages(yaftl_info.unknBuffer3_ftl, var30, var2C, nothingToDo, 0, 1)
  389.                                         {
  390.                                                 if (!(yaftl_verifyMetaData(page_num + (var2C - buf) / nand_geometry_ftl.bytes_per_page_ftl, yaftl_info.buffer20, var30)))
  391.                                                         ret = 0x80000002;
  392.                                         }
  393.                                        
  394.                                         else
  395.                                         {
  396.                                                 ret = 0x80000002;
  397.                                         }
  398.                                 }
  399.                                
  400.                                 else
  401.                                 {
  402.                                         yaftl_info.unknBuffer3_ftl[var30] = yaftl_info.pageBuffer1[(page_num + pagesRead) % yaftl_info.unkn3A_0x800];
  403.                                         var30 ++;
  404.                                        
  405.                                         if (var2C == 0)
  406.                                                 var2C = readBuf;
  407.                                                
  408.                                         if (var30 == nand_geometry_ftl.pages_per_block_total_banks)
  409.                                         {
  410.                                                 if (nothingToDo)
  411.                                                         return 0;
  412.                                        
  413.                                                 if (yaftl_readMultiPages(yaftl_info.unknBuffer3_ftl, var30, var2C, nothingToDo, 0, 1)
  414.                                                 {
  415.                                                         if (!(yaftl_verifyMetaData(page_num + (var2C - buf) / nand_geometry_ftl.bytes_per_page_ftl, yaftl_info.buffer20, var30)))
  416.                                                                 ret = 0x80000002;
  417.                                                 }
  418.                                                
  419.                                                 else
  420.                                                 {
  421.                                                         ret = 0x80000002;
  422.                                                 }      
  423.                                         }
  424.                                 }
  425.                                
  426.                                 var30 = 0;
  427.                                 var2C = 0;
  428.                                 pagesRead ++;
  429.                                 readbuf += nand_geometry_ftl.bytes_per_page_ftl;
  430.                 }
  431.                 }
  432.         }
  433.        
  434.         if (var30 == 0)
  435.         {
  436.                 if (nothingToDo)
  437.                         return (0x80000002);
  438.                
  439.                 set_ftl_region(0, 0, 0, 0);
  440.                 return ret;
  441.         }
  442.        
  443.         if (nothingToDo)
  444.                 return 0;
  445.        
  446.         if (yaftl_readMultiPages(yaftl_info.unknBuffer3_ftl, var30, var2C, nothingToDo, 0, 1)
  447.         {
  448.                 if (!(yaftl_verifyMetaData(page_num + (var2C - buf) / nand_geometry_ftl.bytes_per_page_ftl, yaftl_info.buffer20, var30)))
  449.                         ret = 0x80000002;
  450.         }
  451.        
  452.         else
  453.         {
  454.                 ret = 0x80000002;
  455.         }      
  456.        
  457.         set_ftl_region(0, 0, 0, 0);
  458.         return ret;                    
  459.        
  460. }
create a new version of this paste RAW Paste Data