davrcvpr.c

Flash file system

      /* Haven't started copying the FROM object yet.      */
      from_addr_method = UseCurrObject;
      to_addr_method = UseNextObject;
   }      
      
   /*************************************************/
   /*** (5) RIP/CIP                               ***/
   /*************************************************/
   if ((RecoverState.FROMInput | RecoverState.TOInput) ==
              (FROM_ObjectReclaimInProgress | TO_ObjectCopyInProgress))
   {      
      #ifdef PRINT_ON   
         printf("(5) RIP/CIP");
      #endif
      EVT_CountOccurance(EVT_RECRCVR_State5);
      
      /* We were copying the from object to the to object. */
      from_addr_method = UseCurrObject;
      to_addr_method = UseCurrObject;
   }
   
   #ifdef PRINT_ON
      printf(", ");
   #endif
   
   /*************************************************/
   /*** Calculate actual TO & FROM address        ***/
   /*************************************************/
   /*************************************************/
   /*** (A) Previous From/Current To              ***/
   /*************************************************/
   if (from_addr_method == UsePrevHeader)
   {
      #ifdef PRINT_ON   
         printf("PrevFrom/CurrTO (A)");
      #endif
      EVT_CountOccurance(EVT_RECRCVR_StateA);
      
      if (to_addr_method != UseCurrObject)
      {
         return ERR_SYSTEM;
      }
      
      ReclaimState.HeaderCopied = TRUE;
      ReclaimState.MarkHeaderCopyComplete = TRUE;
      
      /* The FROMObject header has been erased, use the    */
      /*  header information from the TO object.           */
      FLASH_ReadBuffer(RecoverState.TOObject.HeaderAddress,
                   (MemBufferPtr)&SearchHeader, HDR_FixedSize);

      status = UINT16_HeaderFixISF_PLR( &(SearchHeader.Attr16), 
        (RecoverState.TOObject.HeaderAddress + HDR_OffsetToAttr16), restart);
      if(status)
      {
         return status;
      }    
      /*fix header ID*/
      status = UINT16_FixISF_PLR( &(SearchHeader.HeaderId), 
        (RecoverState.TOObject.HeaderAddress + HDR_OffsetToHeaderId), restart);             
      if(status)
      {
         return status;
      }  

      
      /* Adjust the FROM header address to point to the    */
      /*  location where the previous FROM object resided. */
      RecoverState.FROMObject.HeaderAddress += 
                        HDR_CalcHdrSize(SearchHeader.NameSize);

      if (HDR_GetAlignmentAttr(SearchHeader.Attr16) == 
                                             HDR_HA_AlignPara)
      {
         RecoverState.FROMObject.HeaderAddress += 
                              RecoverState.TOObject.ObjectSize;
      }
       
      MemMap.FreeBlk.BaseAddr = 
              RecoverState.TOObject.HeaderAddress - 1;
                                          
      ReclaimState.ObjectHiAddr = 
              RecoverState.FROMObject.HeaderAddress - 1;
       
      /* Adjust the free flash base by the amount of the object */
      /*  that is known to be copied in FROM space, also adjust */
      /*  the copy from pointer.                                */
      if (top_of_from_block < ReclaimState.ObjectHiAddr)
      {
         pre_block_bytes = ReclaimState.ObjectHiAddr - 
                                             top_of_from_block;

         ReclaimState.ObjectHiAddr -= pre_block_bytes;
         MemMap.FreeBlk.BaseAddr -= pre_block_bytes;
      }
   }
   else  /* end UsePrevHeader */
   {
      if (from_addr_method == UseCurrObject)
      {
         #ifdef PRINT_ON
            printf("CurrFROM/");
         #endif              
         
         ReclaimState.HeaderCopied = FALSE;
         switch (to_addr_method)
         {
            /**************************************************/
            /*** (B) Current From/Curr To                   ***/
            /**************************************************/
            case UseCurrObject:
               EVT_CountOccurance(EVT_RECRCVR_StateB);
            
               #ifdef PRINT_ON
                  printf("CurrTO (B)");
               #endif              
            
               /* Assumes SearchHeader already contains FROM object */
               /*  information.                                     */
               /* If not: the uncomment the following:              */
               /*
               FLASH_ReadBuffer(RecoverState.FROMObject.HeaderAddress,
                           (MemBufferPtr)&SearchHeader, HDR_FixedSize);
               */
         
            break;
            
            /**************************************************/
            /*** (C) Current From/Next To                   ***/
            /**************************************************/
            case UseNextObject:
               #ifdef PRINT_ON
                  printf("NextTO (C)");
               #endif              
               
               EVT_CountOccurance(EVT_RECRCVR_StateC);
               
               FLASH_ReadBuffer(RecoverState.TOObject.HeaderAddress,
                               (MemBufferPtr)&TempHeader, HDR_FixedSize);

              status = UINT16_HeaderFixISF_PLR( &(TempHeader.Attr16), 
                (RecoverState.TOObject.HeaderAddress + HDR_OffsetToAttr16), restart);
              if(status)
              {
                  return status;
              }  
                
              /*fix header ID*/
              status = UINT16_FixISF_PLR( &(TempHeader.HeaderId), 
                (RecoverState.TOObject.HeaderAddress + HDR_OffsetToHeaderId), restart);       
              if(status)
              {
                  return status;
              }  
                    
              /* Set our FreeBlk.BaseAddr to the first byte following */
              /*  the current TO Object.                              */
              RecoverState.TOObject.HeaderAddress = 
                  HDR_CalcNextHdrAddr(
                       RecoverState.TOObject.HeaderAddress,
                           (UINT16)HDR_GetAlignmentAttr((TempHeader.Attr16)), 
                                 TempHeader.NameSize, 
                                       RecoverState.TOObject.ObjectSize);
         
            break;
            
            /**************************************************/
            /*** (D) Current From/No To                     ***/
            /**************************************************/
            case UseNoObject:
               
               EVT_CountOccurance(EVT_RECRCVR_StateD);
               
               #ifdef PRINT_ON
                  printf("NoTO (D)");
               #endif              
               
               RecoverState.TOObject.HeaderAddress = 
                      Block2Handle((RecoverState.TOBlock + 1)) - 
                                                          HDR_FixedSizeP;
            break;

            case UsePrevHeader:
            case UseDummyObject:       
            default:
               #ifdef PRINT_ON
                  printf("ERR");
               #endif              
               
               return ERR_SYSTEM;
         } /* end switch */
         
         MemMap.FreeBlk.BaseAddr = 
              RecoverState.TOObject.HeaderAddress + (HDR_FixedSizeP - 1);
      }
      else /* end UseCurrObject */
      {
         /**************************************************/
         /*** (E) Dummy From/Next To                     ***/
         /**************************************************/
         #ifdef PRINT_ON
            printf("DummyFROM/NextTO (E)");
         #endif   
         
         EVT_CountOccurance(EVT_RECRCVR_StateE);
         
         if (to_addr_method != UseNextObject)
         {
            return ERR_SYSTEM;
         }
                    
         ReclaimState.HeaderCopied = TRUE;
         
         /* Create a dummy Invalid header. */
         HDR_InitHeaderAttr16(SearchInfo.HeaderPtr->Attr16);
         HDR_InitHeaderAttr8(SearchInfo.HeaderPtr->Attr8);
         
         SearchInfo.HeaderPtr->NameSize = 0;
         
         RecoverState.FROMObject.HeaderAddress = 
             (Block2Handle((RecoverState.FROMBlock + 1)) + 
                                   HDR_FixedSizeP) - FDI_ParagraphLength;

         SearchInfo.CurrObj.ObjectSize = 
                 RecoverState.FROMObject.HeaderAddress -
                     (SearchInfo.CurrObj.HeaderAddress + HDR_FixedSizeP);
         
         SearchInfo.HeaderPtr->Attr16 = 
             HDR_SetAlignmentAttr((SearchInfo.HeaderPtr->Attr16), 
                                                       HDR_HA_AlignPara);
         
         HDR_SetObjectSize(SearchInfo.HeaderPtr, 
                  (SearchInfo.CurrObj.ObjectSize / FDI_ParagraphLength));
         
         SearchInfo.HeaderPtr->Attr16 = 
             HDR_SetStatusAttr((SearchInfo.HeaderPtr->Attr16), 
                                                         HDR_HA_Invalid);
         
         /* from_addr_method == UseDummyObject */
         ReclaimState.MarkHeaderCopyComplete = FALSE;
         
         FLASH_ReadBuffer(RecoverState.TOObject.HeaderAddress,
                         (MemBufferPtr)&TempHeader, HDR_FixedSize);
         status = UINT16_HeaderFixISF_PLR( &(TempHeader.Attr16), 
           (RecoverState.TOObject.HeaderAddress+HDR_OffsetToAttr16), restart);
         if(status)
         {
            return status;
         }  
      
           /*fix header ID*/
         status = UINT16_FixISF_PLR( &(TempHeader.HeaderId), 
           (RecoverState.TOObject.HeaderAddress + HDR_OffsetToHeaderId), restart);                                
         if(status)
         {
            return status;
         }  
          
                      
         /* Set our FreeBlk.BaseAddr to the first byte following */
         /*  the current TO Object.                              */
         RecoverState.TOObject.HeaderAddress = 
             HDR_CalcNextHdrAddr(
                   RecoverState.TOObject.HeaderAddress,
                        (UINT16)HDR_GetAlignmentAttr((TempHeader.Attr16)), 
                              TempHeader.NameSize, 
                                       RecoverState.TOObject.ObjectSize);

         MemMap.FreeBlk.BaseAddr = 
              RecoverState.TOObject.HeaderAddress + (HDR_FixedSizeP - 1);
      } /* end UseDummyObject */
   } 

   #ifdef PRINT_ON   
      printf("\n");
   #endif   
   
   if (Handle2Block(RecoverState.TOObject.HeaderAddress) ==
                                  Handle2Block(FDI_ReclaimBlockAddress))
   {
      ReclaimState.HeaderInRecBlk = TRUE;
   }
         
   /* Make adjustments to the FreeBlk and RecBlk vars depending       */
   /*  on whether the FreeBlk.BaseAddr points into the reclaim block. */
   MemMap.RecBlk.BaseAddr = FDI_ReclaimBlockAddress + 
                                                  FDI_BlockSize - 1;
   
   if (Handle2Block(MemMap.FreeBlk.BaseAddr) ==
                                           RecoverState.FROMBlock)
   {
      if (RecoverState.TOBlock != RecoverState.FROMBlock)
      {
         return ERR_SYSTEM;
      }
      
      MemMap.RecBlk.BaseAddr = 
         FDI_ReclaimBlockAddress + (MemMap.FreeBlk.BaseAddr - 
                              BlockAlign(MemMap.FreeBlk.BaseAddr));
      MemMap.FreeBlk.BaseAddr = 
                    Block2Handle((RecoverState.TOBlock + 1)) - 1;
   }
   
   if (Handle2Block(MemMap.FreeBlk.BaseAddr) ==
                         Handle2Block(FDI_ReclaimBlockAddress))
   {
      if (RecoverState.TOBlock != RecoverState.FROMBlock)
      {
         return ERR_SYSTEM;
      }
      
      /* Beginning of object (header) is in reclaim block.    */
      /*  Must move FreeBlk.BaseAddr back to the TOBlock and  */
      /*  set the reclaim block base to whatever the free blk */
      /*  base is.                                            */
      MemMap.RecBlk.BaseAddr = MemMap.FreeBlk.BaseAddr;
      MemMap.FreeBlk.BaseAddr = 
                    Block2Handle((RecoverState.TOBlock + 1)) - 1;
   }

   MemMap.FreeBlk.BytesFree = MemMap.FreeBlk.BaseAddr - 
                                                 top_of_from_block;
   
   MemMap.RecBlk.BytesUsed = (FDI_ReclaimBlockAddress + 
                     FDI_BlockSize - 1) - MemMap.RecBlk.BaseAddr;

   HDR_GetObjectSize(SearchInfo.HeaderPtr, 
                                   &SearchInfo.CurrObj.ObjectSize);
                               
   SearchInfo.CurrObj.HeaderAddress = 
                             RecoverState.FROMObject.HeaderAddress;

   SearchInfo.CurrObj.ObjectAddress = 
      HDR_CalcNextHdrAddr(SearchInfo.CurrObj.HeaderAddress, 
          (UINT16)HDR_GetAlignmentAttr((SearchInfo.HeaderPtr->Attr16)), 
                                SearchInfo.HeaderPtr->NameSize, 
                                 SearchInfo.CurrObj.ObjectSize) +
                                                      HDR_FixedSizeP;
                             
   ReclaimState.TargetHeaderAddress = RecoverState.TOObject.HeaderAddress;
   ReclaimState.NextState = (UINT16)RECLAIM_ST_ReadNextObj;
   
   return status;
}

#endif /* DIRECT_ACCESS_VOLUME */