/**************************************************************************** /* F i l e D a t a /* /* Module : FileManager /* C.I. No. : /* $Revision: 1.31 $ /* $Date: 2005/03/20 18:17:24 $ /* Belonging to : /* : /* $RCSfile: FT_MMSUManager_int.c,v $ /* Program Type : /* Sub-modules : /* /**************************************************************************** /* S W D e v e l o p m e n t E n v i r o n m e n t /* /* Host system : /* SW Compiler : /* $Author: sebastiani $ /* : /**************************************************************************** /* U p d a t i n g /* /* $Log: FT_MMSUManager_int.c,v $ /* Revision 1.31 2005/03/20 18:17:24 sebastiani /* rawFlag old code cancelled under if 0 /* /* Revision 1.30 2005/03/06 14:54:16 sebastiani /* fix log /* /* Revision 1.29 2005/02/21 08:58:28 sebastiani /* all log comments completed /* /* Revision 1.28 2004/11/19 15:14:35 sebastiani /* PRH_EXTERN_{VAR,ARR,TABLE} removed and put them on the autogenerated parameter heeader file /* /* Revision 1.27 2004/09/17 15:01:00 faber /* LU_INFN_LOG flags fixing /* /* Revision 1.26 2004/09/10 15:27:05 sebastiani /* fixed TM CC /* /* Revision 1.25 2004/08/26 16:54:07 sebastiani /* fix some bug /* /* Revision 1.24 2004/08/02 12:15:21 sebastiani /* using hk_manager to access to tmtc /* /* Revision 1.23 2004/07/28 09:03:01 sebastiani /* *** empty log message *** /* /* Revision 1.22 2004/07/27 17:30:17 faber /* OBT can be now in second or milliseconds, depending of the situazion. /* OBT_s is used for FM compatibility, OBT_ms basically for MM infos /* /* Revision 1.21 2004/04/23 14:37:26 tassa /* ops fix compilation! /* /* Revision 1.20 2004/04/23 14:16:02 tassa /* change for donwloading procedures vrl handling /* /* Revision 1.19 2004/03/08 15:49:09 alfarano /* improved handling functions for FE /* /* Revision 1.18 2004/03/05 14:07:14 sebastiani /* TM_piSendTC (TM_VRL_START,1) moved in StartDownlink in the right place,after starting of DMA in order to avoid delay time at starting /* /* Revision 1.17 2004/03/03 11:23:43 tassa /* Start downlink manager by timer+message /* /* Revision 1.16 2003/12/15 10:57:16 sebastiani /* last changes for the acceptance of TM tests in Rome of 9-12/Dec/2003 /* /* Revision 1.15 2003/11/28 14:49:46 sebastiani /* in MMSU delete comment lines /* in KHB fix HW bug /* in TS_PamManager add test /* /* Revision 1.14 2003/11/18 09:01:14 alfarano /* laben patch fixes some problems /* /* Revision 1.13 2003/11/13 16:05:18 sebastiani /* main_spare managerment /* /* Revision 1.12 2003/11/11 15:13:39 faber /* commands for VRL/TMTC use now the INFN style wrapped identifiers /* /* Revision 1.11 2003/11/05 08:17:19 sebastiani /* History Entry6 substituted with INFN style log /* /* Revision 1.10 2003/10/31 17:21:29 sebastiani /* bug fix on read and write function in TM_TMTCManager: added busy flag control on each read & write /* CRC functions updated in the SRAMPageManager /* /* Revision 1.9 2003/10/27 18:50:24 sebastiani /* *** empty log message *** /* /* Revision 1.8 2003/10/21 16:09:12 alfarano /* LU_LOG_INFN replacement for all remaining original log functions /* /* Revision 1.7 2003/10/17 08:25:48 sebastiani /* FILE1 bugfixes, /* downlink various bugfixes, VRL switch on/off introduced, /* FT_ifStopDownLink_CallBack function introduced, /* "case" FT_STOP_DOWNLINK introduced for the MSSUManager task /* /* Revision 1.6 2003/09/10 14:10:58 laben /* Fix Timer to ticks. /* /* Revision 1.5 2003/09/10 13:44:00 laben /* New File System model: just one file used like a circular buffer. /* NEw donwlink procedure: downlink next sector until the timer expires. /* /* Revision 1.4 2003/08/27 09:49:17 wizard /* Fix last sector in donwload. /* Set Sector size to 1024*1015 /* Fix Donwload procedure... ( set size set lastsector flag.....) /* bye /* /* Revision 1.3 2003/08/07 08:44:14 wizard /* SIMULATOR bugs ifdef/ifndef corrected /* laben bug "GetFileInfo" for FS_ERC32 id accepted in order to fix SM_pi_GetPacket /* /* Revision 1.1.1.1 2003/08/04 09:40:21 sebastiani /* Imported sources laben rel. 19.06.2003 integrated with pam2 /* /* Revision 1.20 2003/06/09 10:23:22 aurora /* improved the management of data acquisition /* /* Revision 1.19 2003/06/06 09:41:50 aurora /* fixed the latchup recovery function /* /* Revision 1.18 2003/05/20 07:48:17 aurora /* correct the downlink mcmd when some parameter is wrong. /* The acquisition mode is restored only when the mcmd is executed. /* /* Revision 1.17 2003/04/29 13:22:40 aurora /* cleared the last field of entry 6 for memory test /* /* Revision 1.16 2003/04/11 08:24:55 aurora /* Fixed Memory Module TEST /* /* Revision 1.15 2003/01/22 13:55:10 aurora /* typo /* /* Revision 1.14 2002/11/20 13:56:48 zulia /* The ABORT S2M now run always /* /* Revision 1.13 2002/11/14 09:48:31 zulia /* removed unsed code /* /* Revision 1.12 2002/10/17 10:05:18 zulia /* fixed ON/OFF memory module /* optimised PIFReset /* /* Revision 1.11 2002/07/31 14:27:00 zulia /* Correct EXE_MEM_CONF and init memory module /* /* Revision 1.10 2002/07/29 09:03:53 zulia /* new downlink format /* /* Revision 1.9 2002/05/09 13:43:49 aurora /* Modified for column latchup recovery /* Latchup retry added during column switch /* /* Revision 1.8 2002/05/09 08:16:34 zulia /* * acceptance release /* /* /*****************************************************************************/ /*============================= Include File ================================*/ #include #define __FILEID__ _FT_MMSUManager_int__c #include #include #include LU_DECL_MASK(); #include #include #include #include #include #include #include #include #include /*============================== Local Variables ============================*/ // FROM BRANCH_TM_SAMARA UINT32 FT_main_spare = FT_VRL_MAIN; /*****************************************************************************/ /*======= M M S U M a n a g e r I N T E R N A L F U N C T I O N S =======*/ /*****************************************************************************/ /*****************************************************************************/ /* @Function: FT_ifSndMsgMMSUManager */ /* @Purpose : */ /* The function formats a message, then sends it to the MMSUManager task in */ /* order to execute a specific operation. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* Code IN Task operation code */ /* Info IN Task operation parameter */ /* status_code OUT Return code */ /* @@ */ /*****************************************************************************/ status_code FT_ifSndMsgMMSUManager(unsigned int Code, unsigned int Info) { status_code status; MsgTsk sndMsg; /* Message code */ sndMsg.Code =Code; /* Operation parameter */ *(unsigned int* )&sndMsg.Info =Info; /* Size of parameter */ sndMsg.LlInfo =sizeof(unsigned int); /* Send message to MMSUManager */ status =FT_piSndMsgMMSUManager(&sndMsg); return (status); } /*****************************************************************************/ /* @Function: FT_ifMCMDExeMemConf */ /* @Purpose : */ /* The function menages the EXE MEM CONF execution. The MCMD information */ /* are extracted from the buffer and inserted in the EXE MEM CONF MCMD */ /* structure. */ /* The buffer is deleted from the partition. The Memory Module is switched */ /* ON or OFF in accordance with the MCMD switched flag parameter. */ /* To switch ON the module are performed the following actions: */ /* - Check if all two Module are OFF. */ /* - Check if Memory Module to switch ON is OK. */ /* - Sending a log to the History area to notify the EXE MEM CONF MCND */ /* execution. */ /* To switch OFF the module are performed the following actions: */ /* - Sending a log to the History area to notify the EXE MEM CONF MCND */ /* execution. */ /* Any error detected during EXE MEM CONF initialization causes the MCMD */ /* rejection. A specific log sent to the HistoryArea object, defines the */ /* reason of the failure. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrMcmd IN Pointer to MCMD header */ /* (MA_HEADER_MCMD type) */ /* MMSUStatus IN Pointer to all MMSU status structure */ /* (FT_ALL_MMSU_STATUS type) */ /* @@ */ /*****************************************************************************/ void FT_ifMCMDExeMemConf (MA_HEADER_MCMD* PtrMcmd, FT_MMSU_STATUS* MMSUStatus, FT_RW_CH* ptrRWChannel) { status_code status; unsigned short* pMcmdInfo; unsigned int timetagFlag; unsigned int param; unsigned int module; unsigned int memModSw; unsigned int memModOn; unsigned int i; /* Extract MCMD parameters and delete it from partition */ pMcmdInfo =(unsigned short* )PtrMcmd->PtrMCMD; param =*(pMcmdInfo+OFFSET_HEADER); module =(param & FT_MM_SEL) ? FT_MEM_MOD_2 : FT_MEM_MOD_1; memModSw =param & FT_MM_SW; timetagFlag =(*(pMcmdInfo+1)&TIMETAG_MASK) ? TIMETAG_MCMD : IMMEDIATE_MCMD; MA_piDelBufferMCMD(PtrMcmd->PtrMCMD,timetagFlag); /* Check if Memory Module must be switched ON or OFF */ if (memModSw) { /* Check if possible switch ON the Memory Module */ /* Switch ON the Memory Module if Nominal and */ /* Redounded is OFF and Module to switch is OK */ if (MMSUStatus->Module[FT_MEM_MOD_1].Mode==FT_MODE_MEM_MOD_OFF && MMSUStatus->Module[FT_MEM_MOD_2].Mode==FT_MODE_MEM_MOD_OFF ) { status =SUCCESSFUL; MMSUStatus->Module[module].State = FT_STATE_MOD_OK; } else { /* Define error type */ status = HA_E2_ONE_MEM_MODULE_ON; } } else { /* It's always possible switch OFF the Module */ status =SUCCESSFUL; } /*=============== Entry 2 Log in History Area ============*/ // LO G_INFN HA_piLogHistoryEntry2 (PtrMcmd->Type,status); /*@LOG MCMD MemExeConf - status */ LU_INFN_LOG(LU_NORMAL_TRACE|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); if (status == SUCCESSFUL) { if (memModSw) { /*=========== Memory Module is switched ON =======*/ /* Memory Module ON */ if ( FT_opMemModuleON(module) == SUCCESSFUL ) FT_ifRWChannelInit(ptrRWChannel, module, &MMSUStatus->Module[module]); } else { /*========== Memory Module is switched OFF =======*/ /* Delete all file that using the Module into FAT */ /* and mark as unused the sectors in the Free List*/ /* Memory Module OFF */ FT_opMemModuleOFF(module); } } } /*****************************************************************************/ /* @Function: FT_ifMCMDBiteExec */ /* @Purpose : */ /* The function menages the Bite MCMD execution. The MCMD Bite information */ /* are extracted from the buffer and inserted in the Bite MCMD structure. */ /* The buffer is deleted from the partition. To begin the Bite operations */ /* are performed the followings actions: */ /* - Checking of the MCMD Bite parameters. */ /* - Program Dramma REINIT and SCRUBBING and REFRESH registers. */ /* - Interrupt SFT_OVL and HW_OR,HW_AND masked. */ /* - Interrupt SA_OVL and LATCHUP_MONITOR enabled. */ /* - Starting of the Memory Module fill. */ /* - Sending a log to the History area to notify the Bite starting */ /* operations. */ /* Any error detected during Biteinitialization causes the MCMD rejection. */ /* A specific log sent to the HistoryArea object, defines the reason of the */ /* failure. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrMcmd IN Pointer to MCMD header */ /* (MA_HEADER_MCMD type) */ /* MMSUStatus IN Pointer to all MMSU status structure */ /* (FT_MMSU_STATUS type) */ /* TestStatus IN Pointer to test statuts structure */ /* (FT_TEST_MOD_STATUS type) */ /* status_code OUT Return code */ //* @@ */ /*****************************************************************************/ status_code FT_ifMCMDBiteExec (MA_HEADER_MCMD* PtrMcmd, FT_MMSU_STATUS* MMSUStatus, FT_TEST_MOD_STATUS* TestStatus, FT_RW_CH* PtrRWChannel) { status_code status = HA_E2_MCMD_OK; unsigned short* pMcmdInfo; unsigned int initPattern; unsigned int boardId; unsigned int timetagFlag; unsigned int i; FT_MEM_MOD* pMemMod; /* Extract parameters and delete MCMD from partition */ pMcmdInfo =(unsigned short* )PtrMcmd->PtrMCMD; initPattern = (UINT32)(*(pMcmdInfo+OFFSET_HEADER)); /* Delete MCMD from partition */ timetagFlag =(*(pMcmdInfo+1)&TIMETAG_MASK) ? TIMETAG_MCMD : IMMEDIATE_MCMD; MA_piDelBufferMCMD(PtrMcmd->PtrMCMD,timetagFlag); /* Perform a BITE only if the memory module is ON */ /* and no BITE is in progress */ if(PtrRWChannel->PtrModuleStatus->Mode != FT_MODE_MEM_MOD_ON) { if(PtrRWChannel->PtrModuleStatus->Mode == FT_MODE_MEM_MOD_BITE) { status = HA_E2_BT_RUNNING; } else { status = HA_E2_MOD_NOT_AVAILABLE; } } if (status == HA_E2_MCMD_OK) { boardId = PtrRWChannel->ActiveModule; /* Start the timeout timer for the BITE operation */ status = OS_piStartTimer(FT_TIM, FT_BITETO, FT_ifBiteTORecovery, (void*)PtrRWChannel); if (status != SUCCESSFUL) { /* Timer not started correctly */ // LOG_INFN HA_piLogHistoryEntry10(HA_E10_SW_FS,HA_E10_TIMER_ERR,status); /*@LOG error starting timer for bite operation - status */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); status =HA_E2_INTERNAL_ERR; } } if (status == HA_E2_MCMD_OK) { /* Program Dramma REINT register */ FD_piDrammaWrWPBUSReg (boardId,FD_REINIT,0); /* Program Dramma SCRUBBING and REFRESH register */ FD_piDrammaWrWPBUSReg (boardId,FD_SCRUBBER_REFRESH,FD_SCRABBER_REFRESH_VALUE); /* Interrupt masked: SFT_OVL,HW_OR,HW_AND */ /* Interrupt unmask: SA_OVL,LATCHUP_MONITOR */ FD_piDrammaWrWPBUSReg(boardId,FD_INTMSK,FD_MM_INT_ABIL_SA); /* Clear all memory module interrupts */ status =FD_piDrammaWrWPBUSReg(boardId,FD_INTCLR,FD_MM_INT_ALL); /* Start Memory module fix pattern filling */ initPattern |= FD_INITREG_START | FD_INITREG_INIT_MEM; status =FD_piDrammaWrWPBUSReg(boardId,FD_INITREG,initPattern); /* Set in MMSU status Module in BITE mode */ MMSUStatus->Module[boardId].Mode =FT_MODE_MEM_MOD_BITE; /* Set variable in Module Test Status */ TestStatus->State =FT_TEST_START; TestStatus->Module =boardId; TestStatus->TestIdx =0; /*============= Entry 2 Log in History Area ==========*/ // LOG_INFN HA_piLogHistoryEntry2 (PtrMcmd->Type,status); /*@LOG BITE: trace - status */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); /*========= Entry 0 Log in History Area ==========*/ // LOG_INFN HA_piLogHistoryEntry0(HA_E0_STARTING,HA_E0_BITE,HA_E0_BITE_BIT); /*@LOG BITE: trace */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,HA_E0_BITE_BIT); } else { /*============= Entry 2 Log in History Area ==========*/ // LOG_INFN HA_piLogHistoryEntry2 (PtrMcmd->Type,status); /*@LOG BITE: trace - status */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); } return(status); } /*****************************************************************************/ /* @Function: FT_ifColLatchUpInter */ /* @Purpose : */ /* The function sends a message to the MMSUManager task to menage the */ /* latchup recovery procedure. */ /* The lactchup recovery information are compacted in an unsigned int type */ /* as follows : */ /* 32 16 7 0 */ /* Latchup columns | Memory Module */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* MemModule IN Memory Module (FT_MEMORY_MODULE type) */ /* LatchUpCol IN Latchup recovery information */ /* @@ */ /*****************************************************************************/ void FT_ifColLatchUpInter (unsigned int MemModule, unsigned int LatchUpCol) { /* Send message to the MMSUManager to start Latchup rocovery procedure */ FT_ifSndMsgMMSUManager(FT_LATCHUP_RECOVERY,FT_LATCHUP_INFO(MemModule,LatchUpCol)); } /*****************************************************************************/ /* @Function: FT_ifLatchUpRecovery */ /* @Purpose : */ /* The function performs the latchup recovery procedure. */ /* The actions executed to recovery the columns in latchup are the */ /* following: */ /* - The memory module, and columns in error are extracted from */ /* the recovery information parameter. */ /* - Abort all the operational modes that using the Memory Module in */ /* fail. */ /* - Calling the columns latchup recovery procedure. */ /* - If there is 1 column in error, calling the procedure to switch the */ /* fail column with the spare column if available. If the column */ /* switch is ended correctly, the column in error is marked as FAIL */ /* and the spare column is marked as USED into the MMSU status */ /* structure. */ /* If the columns latchup procedure is missed the Memory Module is marked */ /* as fail, all the files that using the module is marked as corrupt, and */ /* the sectors of the module located into the free list is marked as */ /* unused. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* RecoveryInfo IN Recovery information */ /* MMSUStatus IN Pointer to all MMSU status structure */ /* (FT_ALL_MMSU_STATUS type) */ /* PtrRWChannel IN Pointer to the Read/Write channels structure*/ /* @@ */ /*****************************************************************************/ void FT_ifLatchUpRecovery (unsigned int RecoveryInfo, FT_MMSU_STATUS* MMSUStatus, FT_RW_CH* PtrRWChannel) { status_code status; unsigned int memModule; unsigned int latchupBit; unsigned int colError; unsigned int pendingVal; FT_MEM_MOD* pM; unsigned int maskCol; unsigned int i; SM_ACQMODE acqMode; FT_STR_MODE currentStore; /* Get LatchUp recovery information */ memModule = FT_LATCHUP_MEM_MOD(RecoveryInfo); latchupBit =FT_LATCHUP_BIT(RecoveryInfo); pM =&MMSUStatus->Module[memModule]; /* Call column Latchup recovery procedure */ status =FT_ifColumnLatchUp(memModule,FD_CONFIG_REG_27_11_B, latchupBit,TRUE,&colError,&pendingVal); /* Abort a running Downlink */ if(PtrRWChannel->ReadMode != FT_CLOSED) { FT_ifDownlinkAbort(PtrRWChannel); } /* Disable data acquisition nad storage in the mass memory */ acqMode = PM_pi_GetAcqMode(); PM_pi_SetAcqMode(SM_IDLE); currentStore = PtrRWChannel->StoreEnable; FT_ifDisableStore(PtrRWChannel, TRUE); if (status==SUCCESSFUL && colError) { /* There is 1 column in error, try to use the spare column */ if ((status=FT_ifColumnSwitch(memModule,colError))==SUCCESSFUL) { /* Update column information */ for (i=0,maskCol=1; iColumn[i] =FT_COLUMN_FAIL; break; /* Column set fail, exit from the loop */ } } pM->Column[FT_SPARE_COL] =FT_COLUMN_ON; } } /* Check if latchup procedure is OK */ if (status!=SUCCESSFUL) { /* Latchup procedure is NOT OK */ /* Memory Module is marked fail */ pM->State =FT_STATE_MOD_FAIL; /*============= Entry 11 Log in History Area ==============*/ // LOG_INFN HA_piLogHistoryEntry11(HA_E11_MEMORY_MODULE,HA_E11_MOD_LATCHUP_REC_ERR,memModule, colError); /*@LOG LatchUpRecovery - status */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,colError); } /* Disable the storage in the mass memory */ if(currentStore != FT_STR_NONE) { FT_ifEnableStore(PtrRWChannel); PM_pi_SetAcqMode(acqMode); } } /*****************************************************************************/ /* @Function: FT_ifHwErrorInter */ /* @Purpose : */ /* The function sends a message to MMSUManager task to menage the hardware */ /* error recovery procedure. */ /* The hardware error information are compacted in an unsigned int type */ /* as follows : */ /* 32 16 7 0 */ /* | Memory Module */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* MemModule IN Memory Module (FT_MEMORY_MODULE type) */ /* @@ */ /*****************************************************************************/ void FT_ifHwErrorInter (unsigned int MemModule) { /* Send message to MMSUManager to start HW error rocovery menagement */ FT_ifSndMsgMMSUManager(FT_HW_ERROR_RECOVERY,MemModule); } /*****************************************************************************/ /* @Function: FT_ifHwErrorRecovery */ /* @Purpose : */ /* The function performs the Memory Module hardware error (HW) recovery */ /* procedure. */ /* The actions executed to recovery the Memory Module HW error are the */ /* following: */ /* - Extract the memory module information from the */ /* -RecoveryInfo- parameter. */ /* - Masking of the Memory Module interrupts. */ /* - Abort all the operational modes that using the Memory Module in */ /* fail. */ /* - The memory module is marked as fail, all the files that using the */ /* module are marked as corrupt, the sectors of the module located */ /* into the free list are marked as unused. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* RecoveryInfo IN Recovery information */ /* MMSUStatus IN Pointer to all MMSU status structure */ /* (FT_ALL_MMSU_STATUS type) */ /* PtrRWChannel IN Pointer to the Read/Write channels structure*/ /* @@ */ /*****************************************************************************/ void FT_ifHwErrorRecovery (unsigned int RecoveryInfo, FT_MMSU_STATUS* MMSUStatus, FT_RW_CH* PtrRWChannel) { status_code status; unsigned int MemModule; FT_MEM_MOD* pM; unsigned int hwErr; unsigned int failed_col_num; unsigned int failed_col_bit; unsigned int pendingVal; unsigned int colEnable; unsigned int configRegVal; /* Get LatchUp recovery information */ MemModule = RecoveryInfo; pM =&MMSUStatus->Module[MemModule]; /* Mask all memory module interrupts */ FD_piDrammaWrWPBUSReg(MemModule,FD_INTMSK,FD_MM_INT_ALL); /* Abort a running Downlink */ if(PtrRWChannel->ReadMode != FT_CLOSED) { FT_ifDownlinkAbort(PtrRWChannel); } /* Disable the storage in the mass memory */ if(PtrRWChannel->StoreEnable == FT_STR_ALL) { FT_ifStoreAbort(PtrRWChannel); } /* Find the failed column reading the Hard Error Register */ FD_piDrammaRdRPBUSReg(MemModule,FD_HARD_ERROR_REG,&hwErr); /* retrieve the bits from 13 to 15 */ failed_col_num = ((hwErr & 0x0000E000)>>13); failed_col_bit = ( 0x01 << failed_col_num); /* If spare column is available switch */ if (pM->Column[FT_SPARE_COL] == FT_COLUMN_OFF) { /* Switch off failed column */ FD_piDrammaWrWPBUSReg (MemModule, FD_REINIT,0); /* Program Dramma SCRUBBING and REFRESH register */ FD_piDrammaWrWPBUSReg (MemModule, FD_SCRUBBER_REFRESH, FD_SCRABBER_REFRESH_VALUE); /* Get columns enable */ FD_piDrammaRdRPBUSReg (MemModule, FD_PENDING_INT, &pendingVal); colEnable = FD_COLUMN_ENABLE(pendingVal); configRegVal = FD_CONFIG_REG_27_11_B | ((MemModule&0x07) << 22) | colEnable; /* Fail column OFF */ configRegVal &=~failed_col_bit; FD_piDrammaWrWPBUSReg (MemModule,FD_CONFIGURATION,configRegVal); /* Wait 1 ms before to put ON the spare column */ OS_piTaskSuspend (1); /* Spare column ON */ configRegVal |= FD_CONFIG_REG_COL_11; FD_piDrammaWrWPBUSReg (MemModule, FD_CONFIGURATION,configRegVal); /* Program Latchup Retry counter 3 ms */ FD_piDrammaWrWPBUSReg (MemModule, FD_LATCH_UP_RETRY, FD_LATCHUP_RETRY_VAL); /* Wait 2 ms */ OS_piTaskSuspend (2); /* Update columns status */ pM->Column[failed_col_num] = FT_COLUMN_FAIL; pM->Column[FT_SPARE_COL] = FT_COLUMN_ON; /* Start up memory module operations */ FD_piDrammaWrWPBUSReg (MemModule, FD_INITREG, FD_INITREG_START); /* Wait 2 ms, to complete start operations */ OS_piTaskSuspend (2); /* Unmask all memory module interrupts */ FD_piDrammaWrWPBUSReg (MemModule, FD_INTMSK, FD_MM_INT_ABIL_ALL); } else /* spare column is not available */ { /* Memory Module is marked fail */ pM->State = FT_STATE_MOD_FAIL; } } /*****************************************************************************/ /* @Function: FT_ifColumnLatchUp */ /* @Purpose : */ /* The function menages the colummns latchup recovery procedure. */ /* The actions executed in the procedure are the following: */ /* - If the flag parameter is TRUE the Memory Module device is carried */ /* in idle state. */ /* - Activation of the columns in latchup. Each column in latchup is */ /* forced OFF, the Latchup Retry Counter register is writed, and */ /* then the column is forced ON again. Before to continue in the */ /* latchup procedure esecution the task wait 2 ms. */ /* - Reading of the pending interrupt register to check if there are */ /* again columns in latchup condition: */ /* Zero column error the Memory Module is OK. */ /* One column error the Memory Module is not considered in fail */ /* because the spare column could be used. */ /* More than one column in error the Memory Module is in fail. */ /* If column latchup procedure is ended correctly and the flag parameter is */ /* TRUE, the INITREG register is programmed to carry out from idle state the */ /* Memory Module. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* MemModule IN Memory Module (FT_MEMORY_MODULE type) */ /* ConfigVal IN Value to write in Configuration register */ /* Columns IN Columns in error */ /* ActivationColFlag IN Flag to carry in or to carry out from the */ /* idle state the Memory Module device */ /* ColumnsError OUT Returned column status */ /* (bit 0 to 10 columns, bit to 1 specifies */ /* the column error) */ /* PendingVal OUT Returned Pending Interrupt register */ /* @@ */ /*****************************************************************************/ status_code FT_ifColumnLatchUp (unsigned int MemModule, unsigned int ConfigVal, unsigned int Columns, unsigned int ActivationColFlag, unsigned int* ColumnsError, unsigned int* PendingVal) { status_code status; unsigned int configRegVal; unsigned int pendingVal; unsigned int maskCol; unsigned int colError; unsigned int colLatchUp; unsigned int i; configRegVal =ConfigVal; /* If column at the end of procedure must be */ /* activated first set REINIT and SCRUBB register */ if (ActivationColFlag) { /* Program Dramma REINT register */ FD_piDrammaWrWPBUSReg(MemModule,FD_REINIT,0); /* Program Dramma SCRUBBING and REFRESH register */ FD_piDrammaWrWPBUSReg(MemModule,FD_SCRUBBER_REFRESH,FD_SCRABBER_REFRESH_VALUE); /* Clear all memory module interrupts */ FD_piDrammaWrWPBUSReg(MemModule,FD_INTCLR,FD_MM_INT_ALL); /* Mask all memory module interrupts */ FD_piDrammaWrWPBUSReg(MemModule,FD_INTMSK,FD_MM_INT_ALL); } /* Try to activate the columns in Latch Up */ for (i=0,maskCol =FD_CONFIG_REG_COL_01; iModule [i].State =FT_STATE_MOD_OK; Mmsu->Module [i].Mode =FT_MODE_MEM_MOD_OFF; /* Columns status initalization */ for (c=0; cModule [i].Column[c] =FT_COLUMN_OFF; } /* Bite status initalization */ Mmsu->Module[i].Bite.Abil =FT_TEST_PATTERN_EN; Mmsu->Module[i].Bite.Type =FT_TEST_PATTERN_FIX; Mmsu->Module[i].Bite.Pattern =0x00; Mmsu->Module[i].Bite.Result =FT_TEST_MOD_NOT_PERFORMED; Mmsu->Module[i].Bite.HWError =0x00; memModTestDef = (FT_MOD_TEST*)MemModTestDef; /* Test status initalization */ for (c=0; cModule[i].Test[c] =*memModTestDef; } } } /*****************************************************************************/ /* @Function: FT_ifMemModuleTestExec */ /* @Purpose : */ /* The function menages the Memory Module Test execution. The Test */ /* initilizes again the MMSU status information and the File System */ /* structures than causes all the stored data to be lost. */ /* No information must be extracted from the MCMD that is deleted from */ /* the partition. */ /* The Test execution is started during this step, the following actions */ /* are performed: */ /* - Initialization of the MMSU status structure. */ /* - Searching of the Memory Module if is in off condition and */ /* initializes the test correctly. */ /* - Sending a log to the History area to notify the test starting */ /* operations. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* MemModule IN Memory Module identifier. */ /* MemModTestDef IN Memory Module test pattern (default value) */ /* MMSUStatus OUT Pointer to all MMSU status structure */ /* (FT_ALL_MMSU_STATUS type) */ /* TestStatus OUT Pointer to test statuts structure */ /* (FT_TEST_MOD_STATUS type) */ /* @@ */ /*****************************************************************************/ void FT_ifMemModuleTestExec (FT_MMSU_STATUS* MMSUStatus, FT_TEST_MOD_STATUS* TestStatus, void* MemModTestDef) { status_code status; unsigned int timetagFlag; unsigned int module; unsigned int testStartFlag; FT_MEM_MOD* pM; if(MMSUStatus->Module[FT_MEM_MOD_1].Mode == FT_MODE_MEM_MOD_ON) { FT_opMemModuleOFF(FT_MEM_MOD_1); } if(MMSUStatus->Module[FT_MEM_MOD_2].Mode == FT_MODE_MEM_MOD_ON) { FT_opMemModuleOFF(FT_MEM_MOD_2); } /* MMSU status initialization */ FT_ifMMSUStatusInit(MMSUStatus,MemModTestDef); testStartFlag =FALSE; for (module=FT_MEM_MOD_1; moduleState != FT_TEST_NO_RUNNING) { /* Initialize local variable */ state =TestStatus->State; module =TestStatus->Module; testIdx =TestStatus->TestIdx; mode =MMSUStatus->Module[module].Mode; testEndFlag =FALSE; /* Next state */ state++; TestStatus->State =state; if (mode==FT_MODE_MEM_MOD_BITE) { /* Memmory Module in BITE mode */ pT =&MMSUStatus->Module[module].Bite; testEndFlag =TRUE; /* Set testIdx to Max test pattern because */ /* in BITE mode no other memory fill need */ testIdx =FT_MAX_TEST_PATTERN; } else { /* Memmory Module in TEST mode */ pT =&MMSUStatus->Module[module].Test[testIdx]; testEndFlag =(state==FT_TEST_CHECK_PATTERN) ? TRUE : FALSE; } if (testEndFlag) { /* Check HW_OR, interrupt */ FD_piDrammaRdRPBUSReg (module,FD_PENDING_INT,&pendingVal); pendingVal =FD_MM_INTER_BIT(pendingVal); if (pendingVal & FD_MM_INT_HW_OR) { /* Read Hard Error register */ FD_piDrammaRdRPBUSReg(module,FD_HARD_ERROR_REG,&hwErr); pT->Result =FT_TEST_MOD_NOT_OK; pT->HWError =hwErr; MMSUStatus->Module[module].State =FT_STATE_MOD_FAIL; /*================ Module error, stop Test ===================*/ TestStatus->State =FT_TEST_END; if (mode==FT_MODE_MEM_MOD_TEST) { /*== Send message to MMSUManager to menage the Test end ==*/ FT_ifSndMsgMMSUManager(FT_TEST_MODULE_END,FT_TEST_MOD_NOT_OK); } /*================ Entry 11 Log in History Area ===============*/ // LOG_INFN HA_piLogHistoryEntry11(HA_E11_MEMORY_MODULE, HA_E11_MOD_TEST_HW_ERR,module, hwErr); /*@LOG Test Module interrupt - hwErr */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,hwErr); } else { /* Module test is OK */ pT->Result =FT_TEST_MOD_OK; pT->HWError =0; /* Search next pattern */ testStartFlag =FALSE; testIdx++; while (!testStartFlag && testIdxAbil==FT_TEST_PATTERN_EN) { /* Start the Memory Module test */ FT_ifStartMemModuleTest(module,pT->Type,pT->Pattern); TestStatus->State =FT_TEST_START; testStartFlag =TRUE; } else { testIdx++; } } TestStatus->TestIdx =testIdx; if (!testStartFlag) { /*========== Memmory Module OK, test is finished =========*/ TestStatus->State =FT_TEST_END; if (mode==FT_MODE_MEM_MOD_TEST) { /* Send message to MMSUManager to menage the Test end */ FT_ifSndMsgMMSUManager(FT_TEST_MODULE_END,FT_TEST_MOD_OK); } } } } } } /*****************************************************************************/ /* @Function: FT_ifMemModuleTest */ /* @Purpose : */ /* The function initializes and starts the Memory Module test with a */ /* specific pattern. */ /* MMSU and Memory Module are specified in the function parameters. */ /* The Test Status structure is initialized and a new test pattern is */ /* searched into the test pattern table. If new pattern is found the Memory */ /* Module start procedure is executed. Return code identifier is SUCCESSFUL */ /* when memory test is started correctly, otherwise is UNSATISFIED. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* MemModule IN Memory Module (FT_MEMORY_MODULE type) */ /* MMSUStatus OUT Pointer to all MMSU status structure */ /* (FT_ALL_MMSU_STATUS type) */ /* TestStatus OUT Pointer to test statuts structure */ /* (FT_TEST_MOD_STATUS type) */ /* status_code OUT Return code */ /* @@ */ /*****************************************************************************/ status_code FT_ifMemModuleTest (unsigned int MemModule, FT_MMSU_STATUS* MMSUStatus, FT_TEST_MOD_STATUS* TestStatus) { status_code status; FT_MEM_MOD* pM; FT_MOD_TEST* pT; unsigned int i; /* Set MMSU type */ /* Initialize the running test structure */ TestStatus->State =FT_TEST_START; TestStatus->Module =MemModule; TestStatus->TestIdx =FT_START_TEST_PATTERN; /* Pointer to Module structure */ pM =&MMSUStatus->Module[MemModule]; /* Pointer to Test Module structure */ pT =&pM->Test[FT_START_TEST_PATTERN]; /* Search first pattern */ status =UNSATISFIED; for (i=FT_START_TEST_PATTERN; iAbil==FT_TEST_PATTERN_EN) { /* Start the Memory Module Test */ FT_ifStartMemModuleTest(MemModule,pT->Type,pT->Pattern); pM->Mode =FT_MODE_MEM_MOD_TEST; status =SUCCESSFUL; break; /* First pattern found, exit from the loop */ } } return (status); } /*****************************************************************************/ /* @Function: FT_ifStartMemModuleTest */ /* @Purpose : */ /* The function programs the Dramma registers to perform the test of a */ /* specific Memory Module using a defined pattern. */ /* The function parameters specify the MMSU, the Memory Module, the type of */ /* the test, and the pattern. */ /* To start the Memory Module test are performed the following actions: */ /* - Clearing of all Memory Module interrupts. */ /* - Masking of the SOFTERROR OVL, HARDERROR AND OR interrupts */ /* - Unmasking of the SCRUB ADDRESS OVL interrupts. */ /* - Programming of the Dramma REINT register to reset whole device. */ /* - Programming of the Dramma SCRUBBING and REFRESH register. */ /* - Programming of the Dramma INITREG to start memory fill with a FIX */ /* or VARIABLE pattern depending of the test type parameter. */ /* @@ */ /* @Parameter Name @Mode @Description */ /* MemModule IN Memory Module (FT_MEMORY_MODULE type) */ /* StartType IN Type of the memory test */ /* (FT_TEST_PATTERN_VAR,FT_TEST_PATTERN_FIX) */ /* Pattern IN Pattern used to fill the memory */ /* @@ */ /*****************************************************************************/ void FT_ifStartMemModuleTest(unsigned int MemModule, unsigned int StartType, unsigned int Pattern) { unsigned int initReg; /* Program Dramma REINT register */ FD_piDrammaWrWPBUSReg(MemModule,FD_REINIT,0); /* Program Dramma SCRUBBING and REFRESH register */ FD_piDrammaWrWPBUSReg(MemModule,FD_SCRUBBER_REFRESH,FD_SCRABBER_REFRESH_VALUE); /* Clear all memory module interrupts */ FD_piDrammaWrWPBUSReg(MemModule,FD_INTCLR,FD_MM_INT_ALL); /* Mask SFT_OVL,HW_OR,HW_AND memory module interrupts and */ /* unmask SA_OVL */ FD_piDrammaWrWPBUSReg(MemModule,FD_INTMSK,FD_MM_INT_ABIL_SA); /* Check test type */ if (StartType==FT_TEST_PATTERN_VAR) { /* Start Memory Module filling with a VARIABLE pattern */ initReg =FD_INITREG_PATTERN_VAR; FD_piDrammaWrWPBUSReg(MemModule,FD_INITREG,initReg); } else { /* Start Memory Module filling with a FIX pattern */ initReg =FD_INITREG_PATTERN_FIX | Pattern; FD_piDrammaWrWPBUSReg(MemModule,FD_INITREG,initReg); } } /*****************************************************************************/ /* @Function: FT_ifTestModuleEnd */ /* @Purpose : */ /* The function menages the Memory Module test end condition, and the */ /* starting of the next Memeory Module test. */ /* The actions performed are the following: */ /* - The MMSU Test Running Status structure is reseted. */ /* - The Memory Module is forced to OFF condition. */ /* - Searching of the next Memory Module to test and calling the */ /* function to perform the test starting. */ /* - The MMSU is forced to OFF condition if all Memory Module have */ /* executed the test procedure. */ /* - If both MMSU local and remote have completed the Memory Module. */ /* test is sent a log to History area with the results of the tests. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* MMSUStatus OUT Pointer to all MMSU status structure */ /* (FT_ALL_MMSU_STATUS type) */ /* TestStatus OUT Pointer to test statuts structure */ /* (FT_TEST_MOD_STATUS type) */ /* TestStatus OUT Pointer to test statuts structure */ /* (FT_TEST_MOD_STATUS type) */ /* @@ */ /*****************************************************************************/ void FT_ifTestModuleEnd (unsigned int TestResult, FT_MMSU_STATUS* MMSUStatus, FT_TEST_MOD_STATUS* TestStatus) { status_code status; FT_MEM_MOD* pM; unsigned int module; unsigned int endTestFlag; unsigned int testStartFlag; module =TestStatus->Module; /* Reset of the MMSU Test Running Status structure */ TestStatus->State =FT_TEST_NO_RUNNING; TestStatus->Module =0xffffffff; /* No Module index */ TestStatus->TestIdx =0xffffffff; /* No Pattern index */ /* Memory Module Test is ended, switch OFF the Module */ status =FT_piMemModuleOFF(module); /* Test the next Memory Module */ module++; testStartFlag =FALSE; endTestFlag =FALSE; while (!testStartFlag && !endTestFlag && (TestResult!=FT_TEST_MOD_ABORT)) { /* Check if all MMSU Memory Module are tested */ if (module>16); *((unsigned short* )&sndMsg.Info[4]) =(obtime & 0xffff); *((unsigned short* )&sndMsg.Info[6]) =(testReport & 0xffff); *((unsigned short* )&sndMsg.Info[8]) = 0x0000; sndMsg.Code = HA_TRACEVENT; sndMsg.LlInfo = HA_SIZEW_E0; */ /* Send message to the Histrory area */ // HA_piSndMsgHistoryArea(&sndMsg); /*@LOG LOG History Entry 6 - testreport */ LU_INFN_LOG(LU_CRITICAL|LU_HA|LU_NORMAL_TRACE,LU_MASK(__FILEID__),__FILEID__,line,testReport); } /*****************************************************************************/ /* @Function: FT_ifGetReportTest */ /* @Purpose : */ /* The function formats the MMSUs (Local and Remote) test results in */ /* according to the bits structure defined in the Entry Type 6 layout. */ /* The test informations are obtained from the content of the MMSU status */ /* structure. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* MMSUStatus IN Pointer to all MMSU status structure */ /* (FT_ALL_MMSU_STATUS type) */ /* Report OUT Returned test report */ /* @@ */ /*****************************************************************************/ void FT_ifGetReportTest(FT_MMSU_STATUS* MMSUStatus, unsigned int* Report) { FT_MEM_MOD* pM; unsigned int mask; unsigned int report; unsigned int i; /* Report structure : */ /* 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 */ /* M2 M1 */ /*=========== Get MMSU Local test result =========*/ pM =&MMSUStatus->Module[0]; for (i=0,mask =1,report =0; iState != FT_STATE_MOD_OK) { report |=mask; } } *Report = report; } /*****************************************************************************/ /* @Function: FT_ifGetModeDetails */ /* @Purpose : */ /* The function formats the current Mission Modes status in according to */ /* to the bits structure defined in the Entry Type 0 layout. */ /* The Mission Modes informations are obtained from the content of the Open */ /* Channel structure. From each open channel are extracted the current */ /* information about the status of the active operational mode. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* ChOpen IN Pointer to the channels structure */ /* (FT_CHANNELS_OPEN type) */ /* Report OUT Returned test report */ /* @@ */ /*****************************************************************************/ void FT_ifGetModeDetails (unsigned int* ModeReport) { unsigned int modeRep; modeRep =0; *ModeReport =modeRep; } /*****************************************************************************/ /* @Function: FT_ifMCMDDownLinkExec */ /* @Purpose : */ /* The function menages the Downlink MCMD execution by opening the RWChannel*/ /* in downlink mode, switching onthe TAM IF and starting the StartPlayback */ /* trigger Timer */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrMcmd IN Pointer to MCMD header */ /* (MA_HEADER_MCMD type) */ /* status_code OUT Return code */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* @@ */ /*****************************************************************************/ status_code FT_ifMCMDDownLinkExec(MA_HEADER_MCMD* PtrMcmd, FT_RW_CH* PtrRWChannel) { status_code status = HA_E2_MCMD_OK; UINT16* pMcmdInfo; UINT32 timetagFlag; UINT32 fileId; UINT32 rawFlag; UINT32 dlSectors; UINT32 tamId; UINT32 totalSize; UINT32 sectors; FS_FILE_DESCR fileInfo; MsgTsk Msg; SM_ACQMODE acqMode; FS_EXITCODE imageStat; BOOL newImage; /* word to send to INFN */ UINT16 word_06; UINT16 word_07; UINT16 word_08; TI_TIME WaitForStartDownlink; TI_TIME DownlinkStartTime; TI_TIME DownlinkIntervalTime; TI_TIME CurrentMoscowTime; /* Extract parameters and delete MCMD from partition */ pMcmdInfo =(UINT16* )PtrMcmd->PtrMCMD; // Bit 0 fileId =(UINT32)((*(pMcmdInfo+OFFSET_HEADER)) & 0x0001); // Bit 1-2 tamId =(UINT32)((*(pMcmdInfo+OFFSET_HEADER)) & 0x0006) >> 1; // Bit 3 rawFlag =(UINT32)((*(pMcmdInfo+OFFSET_HEADER)) & 0x0008) >> 3; // Bit 4-15 dlSectors =(UINT32)((*(pMcmdInfo+OFFSET_HEADER)) & 0xfff0) >> 4; word_06 = *(pMcmdInfo + OFFSET_HEADER + 1); word_07 = *(pMcmdInfo + OFFSET_HEADER + 2); word_08 = *(pMcmdInfo + OFFSET_HEADER + 3); /* get the 6th bit for the main/spare selector: */ // Changed since TM in Rome: main_spare = (word_08 & 0x0020) >> 5; FT_main_spare = (word_07 & 0x0020) >> 5; /* Delete MCMD from partition */ timetagFlag =(*(pMcmdInfo+1)&TIMETAG_MASK) ? TIMETAG_MCMD : IMMEDIATE_MCMD; MA_piDelBufferMCMD(PtrMcmd->PtrMCMD,timetagFlag); /* here call INFN provided interface for copy word_0x */ /* Check that the active memory module is ON */ if(PtrRWChannel->PtrModuleStatus->Mode != FT_MODE_MEM_MOD_ON) { status = HA_E2_MOD_NOT_AVAILABLE; } /* Check that the read channel is not already in use */ if(PtrRWChannel->ReadMode != FT_CLOSED) { status = HA_E2_DL_RUNNING; } if(status == SUCCESSFUL) { PtrRWChannel->ReadSectors = 0; /* Init the playback automa status */ PtrRWChannel->PlayBackStatus = FT_READY; /* * Possibile Ottimizzazione spostare il cambio di stato e * il setting di PtrRWChannel->ReadMod dopo il timer!! */ #warning "Possibile Ottimizzazione spostare il cambio di stato e il setting di PtrRWChannel->ReadMod dopo il timer" /* Stop the acquisition and the SRAM page storage */ #if 0 #warning "e' necessario mettere in SM_IDLE lo stato?????" acqMode = PM_pi_GetAcqMode(); PM_pi_SetAcqMode(SM_IDLE); FT_ifDisableStore(PtrRWChannel, TRUE); #endif if(rawFlag == TRUE) { /* Prepare a sector chain that starts from the sector number 0 and */ /* has the selected number of sectors */ // FS_piMakeFileImage(0, (dlSectors * FT_SECTSIZE) / FT_SAMPLESIZE, §ors, TRUE); /* Lock the read channel in raw downlink mode */ PtrRWChannel->ReadMode = FT_BITEDNLK; } else { /* Prepare a sector chain that covers all the sectors used by the */ /* selected file and the HK file */ /* we have deleted FILE2*/ // PtrRWChannel->FileId = (fileId == FT_FILE1) ? FS_FILE1 : FS_FILE2; PtrRWChannel->FileId = FS_FILE1; /* Lock the read channel in downlink mode */ PtrRWChannel->ReadMode = FT_DOWNLINK; } /* Switch on the selected TAM I/F */ /* FROM BRANCH_TM_SAMARA*/ // TM_piSendTC (TM_VRL_MAIN_OFF,1); // TM_piSendTC (TM_VRL_SPARE_OFF,1); HK_SendTC (TM_VRL_OFF,1); // HK_SendTC (TM_VRL_SPARE_OFF,1); OS_piTaskSuspend (PRH_VAR_TM_VRL_SUSPEND_HCL); // old.. to remove // HK_SendTC (TM_VRL_STOP,1); // OS_piTaskSuspend (PRH_VAR_TM_VRL_SUSPEND_HCL); if(FT_main_spare == FT_VRL_MAIN) HK_SendTC (TM_VRL_MAIN_ON_START,1); else HK_SendTC (TM_VRL_SPARE_ON_START,1); PtrRWChannel->TamId=tamId; /* Start the timer that will trigger the palyback start as soon as the */ /* selected TAM I/F has completed the warm up */ /* Set Timer to Downlink Start */ status = TI_piGetCurrentMoscowTime_s(&CurrentMoscowTime); if (status != SUCCESSFUL) { /*@LOG Downlink: error getting current moscow time - status */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); status = HA_E2_INTERNAL_ERR; FT_ifStopDownLink(PtrRWChannel); // oppure FT_ifDownLinkClose(PtrRWChannel); ?? } else { status = MH_GetDownlinkInfo(&DownlinkStartTime,&DownlinkIntervalTime); if (status != SUCCESSFUL) { /*@LOG Downlink: error getting downlink info - status */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); status =HA_E2_INTERNAL_ERR; FT_ifStopDownLink(PtrRWChannel); // oppure FT_ifDownLinkClose(PtrRWChannel); ?? } else { PtrRWChannel->DownlinkStartTime = DownlinkStartTime; PtrRWChannel->DownlinkIntervalTime = DownlinkIntervalTime; WaitForStartDownlink = 0; if (DownlinkStartTime > CurrentMoscowTime){ WaitForStartDownlink = DownlinkStartTime - CurrentMoscowTime; } if(WaitForStartDownlink < FT_TAM_WARMUP) WaitForStartDownlink = FT_TAM_WARMUP; //WaitForStartDownlink=20; status = OS_piStartTimer(FT_TIM, TI_SECOND_TO_TICK(WaitForStartDownlink), FT_ifStartDownLink_CallBack, (void*)PtrRWChannel); /*@LOG Downlink: wait for start downlink*/ LU_INFN_LOG(LU_NORMAL_TRACE|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,WaitForStartDownlink); /*@LOG Downlink: duration of downlink */ LU_INFN_LOG(LU_NORMAL_TRACE|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,DownlinkIntervalTime); if (status != SUCCESSFUL) { // LOG_INFN HA_piLogHistoryEntry10(HA_E10_SW_FS,HA_E10_TIMER_ERR,status); /*@LOG Timer not started correctly - status */ LU_INFN_LOG(LU_FATAL|LU_HA ,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); status =HA_E2_INTERNAL_ERR; FT_ifStopDownLink(PtrRWChannel); // oppure FT_ifDownLinkClose(PtrRWChannel); ?? } /* Re-enable the store channel */ /* and the perviously interrupted acquisition activity */ #if 0 FT_ifEnableStore(PtrRWChannel); PM_pi_SetAcqMode(acqMode); #endif } } } if (status != SUCCESSFUL) { /*@LOG Downlink Error */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); /*============= Entry 2 Log in History Area ==========*/ } return (status); } /*****************************************************************************/ /* @Function: FT_ifMCMDAbordExec */ /* @Purpose : */ /* The function menages the Abort MCMD execution by calling the proper */ /* function to abort the Downlink, Mass Memory storage or Test operation. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrMcmd IN Pointer to MCMD header */ /* (MA_HEADER_MCMD type) */ /* status_code OUT Return code */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* @@ */ /*****************************************************************************/ status_code FT_ifMCMDAbordExec(MA_HEADER_MCMD* PtrMcmd, FT_RW_CH* PtrRWChannel, FT_TEST_MOD_STATUS* PtrTestModuleStatus) { status_code status = HA_E2_MCMD_OK; UINT16* pMcmdInfo; UINT32 timetagFlag; UINT32 abortType; /* Extract parameters and delete MCMD from partition */ pMcmdInfo =(UINT16* )PtrMcmd->PtrMCMD; // Abort Type parameter abortType =(UINT32)((*(pMcmdInfo+OFFSET_HEADER)) & 0x0007); /* Delete MCMD from partition */ timetagFlag =(*(pMcmdInfo+1)&TIMETAG_MASK) ? TIMETAG_MCMD : IMMEDIATE_MCMD; MA_piDelBufferMCMD(PtrMcmd->PtrMCMD,timetagFlag); if(abortType & FT_ABORT_DLK) { if(PtrRWChannel->ReadMode == FT_CLOSED) { /* Downlink not running */ /*============= Entry 2 Log in History Area ==========*/ // LOG_INFN HA_piLogHistoryEntry2(PtrMcmd->Type,HA_E2_INVALID_DL_ABORT); LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,HA_E2_INVALID_DL_ABORT); status = HA_E2_INVALID_ABORT; } else { /* Downlink running, abort it */ FT_ifDownlinkAbort(PtrRWChannel); } } if(abortType & FT_ABORT_S2M) { /* SRAM to MMSU running, abort it */ FT_ifStoreAbort(PtrRWChannel); } if(abortType & FT_ABORT_TST) { if(PtrTestModuleStatus->State == FT_TEST_NO_RUNNING) { /* Test not running */ /*============= Entry 2 Log in History Area ==========*/ // LOG_INFN HA_piLogHistoryEntry2(PtrMcmd->Type,HA_E2_INVALID_TEST_ABORT); LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,HA_E2_INVALID_TEST_ABORT); status = HA_E2_INVALID_ABORT; } else { /* Test running, abort it */ PtrTestModuleStatus->State = FT_TEST_NO_RUNNING; FT_ifSndMsgMMSUManager(FT_TEST_MODULE_END,FT_TEST_MOD_ABORT); } } /*============= Entry 2 Log in History Area ==========*/ // LOG_INFN HA_piLogHistoryEntry2 (PtrMcmd->Type,status); LU_INFN_LOG(LU_NORMAL_TRACE|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); } /*****************************************************************************/ /* @Function: FT_ifStartDownLink */ /* @Purpose : */ /* This function is used to start the Playback operation. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* TimerId IN Timer identification */ /* @@ */ /*****************************************************************************/ void FT_ifStartDownLink(FT_RW_CH* PtrRWChannel) { unsigned int intLevel; FS_SECT_DESCR sectorInfo; status_code status; TI_TIME DownlinkTime; SM_ACQMODE acqMode; /* Check if the read channel is locked in any kind of downlink mode */ if(PtrRWChannel->ReadMode == FT_DOWNLINK || PtrRWChannel->ReadMode == FT_BITEDNLK) { #if 1 #warning "e' necessario mettere in SM_IDLE lo stato?????" acqMode = PM_pi_GetAcqMode(); PM_pi_SetAcqMode(SM_IDLE); FT_ifDisableStore(PtrRWChannel, TRUE); #endif /*========= Entry 0 Log in History Area ==========*/ // LOG_INFN HA_piLogHistoryEntry0(HA_E0_STARTING,HA_E0_DOWN_LINK,HA_E0_DL_BIT); /*@LOG Start downlink */ LU_INFN_LOG(LU_NORMAL_TRACE|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,HA_E0_DL_BIT); /* Enable the playback related interrupt */ OS_piInterDisable(&intLevel); SD_piClearInt(SD_RPB_EOT); SD_piUnMaskInt(SD_RPB_EOT); OS_piInterEnable(intLevel); /* Program the DRAMMA and WPBUS with the info about the first two sectors */ /* and start the data transfer */ FS_piGetCurrentSector(§orInfo); FD_piDrammaWrWPBUSReg(PtrRWChannel->ActiveModule, FD_RADDR1_WPBUS, sectorInfo.SectAddr); // per consentire il download di settori da 1024*1015 byte, abbiamo aggiunto la seguente istruzione e cambiato quella successiva FD_piSetBlockLength(FT_SECTSIZE / FT_SAMPLESIZE); // Start Timer di finestra temporale downlink. DownlinkTime = PtrRWChannel->DownlinkIntervalTime; status = OS_piStartTimer_INFN(DNLK_TIM, TI_SECOND_TO_TICK(DownlinkTime), FT_ifStopDownLink_CallBack, (void*)PtrRWChannel); /*@LOG Downlink: StartTimer_INFN - status */ LU_INFN_LOG(LU_NORMAL_TRACE|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); if (status != SUCCESSFUL) { /* Timer not started correctly */ // LOG_INFN HA_piLogHistoryEntry10(HA_E10_SW_FS,HA_E10_TIMER_ERR,status); /*@LOG Downlink - status */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); status =HA_E2_INTERNAL_ERR; FT_ifStopDownLink(PtrRWChannel); // oppure FT_ifDownLinkClose(PtrRWChannel); ?? } else { /*============= Entry 2 Log in History Area ==========*/ // HA_piLogHistoryEntry2 (PtrMcmd->Type,status); FD_piStartTransferFromMemory(PtrRWChannel->ActiveModule, TRUE); OS_piTaskSuspend (PRH_VAR_TM_VRL_SUSPEND_BEFORE_START); // FROM BRANCH_TM_SAMARA if(FT_main_spare == FT_VRL_MAIN) HK_SendTC (TM_VRL_MAIN_ON_START,1); else HK_SendTC (TM_VRL_SPARE_ON_START,1); // HK_SendTC // TM_piSendTC (TM_VRL_START,1); OS_piTaskSuspend (PRH_VAR_TM_VRL_SUSPEND_HCL); // FD_piStartTransferFromMemory(PtrRWChannel->ActiveModule, FALSE); } /* This 3-line comment had indroduced from zulianello@laben in his visit in Roma, 28.07.2003 in order to fix the "End of 1-MB gap problem" FS_piGetNextSector(§orInfo); FD_piDrammaWrWPBUSReg(PtrRWChannel->ActiveModule, FD_RADDR1_WPBUS, sectorInfo.SectAddr); FD_piStartTransferFromMemory(PtrRWChannel->ActiveModule, FALSE); */ PtrRWChannel->PlayBackStatus = FT_RUN; #if 1 FT_ifEnableStore(PtrRWChannel); PM_pi_SetAcqMode(acqMode); #endif } } /*****************************************************************************/ /* @Function: FT_ifDownLinkClose */ /* @Purpose : */ /* This function is used to close the Downlink operation and RWChannel */ /* via the MMSU Manager */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* @@ */ /*****************************************************************************/ rtems_timer_service_routine FT_ifStopDownLink_CallBack(rtems_id timer_id,void *PtrRWChannel) { MsgTsk SndMsg; status_code s; SndMsg.Code = FT_STOP_DOWNLINK; s=FT_opSndMsgMMSUManager(&SndMsg); } rtems_timer_service_routine FT_ifStartDownLink_CallBack(rtems_id timer_id,void *PtrRWChannel) { MsgTsk SndMsg; status_code s; SndMsg.Code = FT_START_DOWNLINK; s=FT_opSndMsgMMSUManager(&SndMsg); } /*****************************************************************************/ /* @Function: FT_ifDownLinkClose */ /* @Purpose : */ /* This function is used to close the Downlink operation and RWChannel */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* @@ */ /*****************************************************************************/ void FT_ifStopDownLink(FT_RW_CH* PtrRWChannel) { unsigned int intLevel; status_code status; // Disable ReadEOT OS_piInterDisable(&intLevel); SD_piClearInt(SD_RPB_EOT); SD_piMaskInt(SD_RPB_EOT); OS_piInterEnable(intLevel); // SET START to 0 : START HLC 4 // FROM BRANCH_TM_SAMARA // if(FT_main_spare == FT_VRL_MAIN) HK_SendTC (TM_VRL_OFF,1); // else // HK_SendTC (TM_VRL_SPARE_OFF,1); /* HK_SendTC (TM_VRL_STOP, 0x1); OS_piTaskSuspend (PRH_VAR_TM_VRL_SUSPEND_HCL); HK_SendTC (TM_VRL_OFF, 0x1); */ OS_piTaskSuspend (PRH_VAR_TM_VRL_SUSPEND_HCL); // Reset DMA forse non necessario!!! FD_piAbortTransfer(FD_ABT_READ); OS_piCancelTimer_INFN(DNLK_TIM); status = FS_piUpdateSectorPointer(); /* Close the read channel */ PtrRWChannel->ReadMode = FT_CLOSED; /* Update the store channel status enabling again the storage */ /* into mass memory */ FT_ifEnableStore(PtrRWChannel); /*@LOG Stop Download - status */ LU_INFN_LOG(LU_NORMAL_TRACE|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,status); PM_SendCommand(PM_INFN_END_OF_DOWNLINK); } /*****************************************************************************/ /* @Function: FT_ifDownLinkClose */ /* @Purpose : */ /* This function is used to close the Downlink operation and RWChannel */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* @@ */ /*****************************************************************************/ void FT_ifDownLinkClose(FT_RW_CH* PtrRWChannel) { unsigned int intLevel; if(PtrRWChannel->ReadMode == FT_DOWNLINK) { /* If a playback operation of a regular file was ended then */ if(PtrRWChannel->PlayBackStatus == FT_END) { /* Reset the files that has just been downloaded */ FS_piResetFile(PtrRWChannel->FileId); FS_piResetFile(FS_HK); /*========= Entry 0 Log in History Area ==========*/ // LOG_INFN HA_piLogHistoryEntry0(HA_E0_EXITING,HA_E0_DOWN_LINK,0); /*@LOG DownLinkClose: reset file */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,0); } } /* End of a raw downlink */ if(PtrRWChannel->ReadMode == FT_BITEDNLK) { if(PtrRWChannel->PlayBackStatus == FT_END) { /*========= Entry 0 Log in History Area ==========*/ // LOG_INFN HA_piLogHistoryEntry0(HA_E0_EXITING,HA_E0_DOWN_LINK,0); /*@LOG DownLinkClose: BITE in progress */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,0); } } /* Close the read channel */ PtrRWChannel->ReadMode = FT_CLOSED; /* Update the store channel status enabling again the storage */ /* into mass memory */ FT_ifEnableStore(PtrRWChannel); } /*****************************************************************************/ /* @Function: FT_ifDownlinkAbort */ /* @Purpose : */ /* This function is used to close the Downlink operation and RWChannel */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* @@ */ /*****************************************************************************/ void FT_ifDownlinkAbort(FT_RW_CH* PtrRWChannel) { status_code status; unsigned int intLevel; /* Stop the trigger timer for the downlink */ OS_piCancelTimer(FT_TIM); /* Disable all the store related interrupts */ OS_piInterDisable(&intLevel); SD_piMaskInt(SD_RPB_EOT); OS_piInterEnable(intLevel); /* If a playback is running then */ if(PtrRWChannel->PlayBackStatus != FT_READY && PtrRWChannel->PlayBackStatus != FT_END) { /* Abort the RPBUS transfer */ FD_piAbortTransfer(FD_ABT_READ); } /* Close the downlink operation */ FT_ifDownLinkClose(PtrRWChannel); } /*****************************************************************************/ /* @Function: FT_ifRWChannelInit */ /* @Purpose : */ /* This function initializes the RWChannel structure used to supervise the */ /* data flow to or from the memory module */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* status_code OUT Return code */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* PtrModInfo IN Pointer to the active module info structure */ /* Module IN Active Module */ /* @@ */ /*****************************************************************************/ status_code FT_ifRWChannelInit(FT_RW_CH* PtrRWChannel, FT_MEMORY_MODULE Module, FT_MEM_MOD* PtrModInfo) { status_code status = SUCCESSFUL; unsigned int intLevel; /* program the WPBUS/RPBUS wait state counters */ FD_piSetWPBUSWaitState(FT_WPBUS_WCS); FD_piSetRPBUSWaitState(FT_RPBUS_WSC); // By default the Active module is the Primary module PtrRWChannel->ActiveModule = Module; PtrRWChannel->PtrModuleStatus = PtrModInfo; PtrRWChannel->ReadMode = FT_CLOSED; PtrRWChannel->ReadSectors = 0; PtrRWChannel->PlayBackStatus = FT_END; PtrRWChannel->FileId = FS_MAXID; PtrRWChannel->SaveInProgress = FALSE; PtrRWChannel->CurrentPageId = SM_SKETCHBOARD; PtrRWChannel->StoreEnable = FT_STR_NONE; OS_piInterDisable(&intLevel); /* disable any read/store related interrupts */ SD_piMaskInt(SD_WPB_EOT | SD_RPB_EOT); OS_piInterEnable(intLevel); /* release the semaphore on save queue*/ // OS_piResourceRelease ( FT_RES ); // console_outbyte_polled( 0, 'R' ); // console_outbyte_polled( 0, '\n' ); return (status); } /*****************************************************************************/ /* @Function: FT_ifDisableStore */ /* @Purpose : */ /* This function is used to stop the SRAM page storage operations. */ /* The current store operation is stopped, the save queue reset and no more */ /* save request are accepted. */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* AllStr IN Flag to force the reinit of store automa */ /* @@ */ /*****************************************************************************/ void FT_ifDisableStore(FT_RW_CH* PtrRWChannel, BOOL AllStr) { unsigned int intLevel; FT_SAVEREQUEST saveReq; UINT32 reqSize; if(AllStr) { /* Disable the store chanel */ PtrRWChannel->StoreEnable = FT_STR_NONE; /* If a store operation was in progress then */ if(PtrRWChannel->SaveInProgress == TRUE) { /* Abort the WPBUS transfer */ FD_piAbortTransfer(FD_ABT_WRITE); } /* Notify the SRAMPageManager that any save request */ /* about the skatchboard has been cancelled */ OS_piInterDisable(&intLevel); PM_piPageWasSaved(FS_HK); OS_piInterEnable(intLevel); /* release the semaphore on save queue*/ // OS_piResourceRelease ( FT_RES ); // console_outbyte_polled( 0, 'R' ); // console_outbyte_polled( 0, '\n' ); } else { PtrRWChannel->StoreEnable = FT_STR_CMD; } } /*****************************************************************************/ /* @Function: FT_ifEnableStore */ /* @Purpose : */ /* This function is used to start the SRAM page storage operations. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* status_code OUT Return code */ /* @@ */ /*****************************************************************************/ status_code FT_ifEnableStore(FT_RW_CH* PtrRWChannel) { status_code status = FT_STR_DONE; unsigned int intLevel; FT_SAVEREQUEST saveReq; UINT32 reqSize; /* If the store channel was closed */ if(PtrRWChannel->StoreEnable == FT_STR_NONE) { /* Init the store flag */ PtrRWChannel->SaveInProgress = FALSE; PtrRWChannel->CurrentPageId = SM_SKETCHBOARD; } /* If the read channel is closed and the current memory module */ /* is up and running */ if(PtrRWChannel->ReadMode == FT_CLOSED && PtrRWChannel->PtrModuleStatus->State == FT_STATE_MOD_OK && PtrRWChannel->PtrModuleStatus->Mode == FT_MODE_MEM_MOD_ON) { /* Enable the storage both in the mass memory and towards */ /* the CMD I/F */ PtrRWChannel->StoreEnable = FT_STR_ALL; OS_piInterDisable(&intLevel); /* enable eny store related interrupts */ SD_piUnMaskInt(SD_WPB_EOT); OS_piInterEnable(intLevel); /* release the semaphore on save queue*/ // OS_piResourceRelease ( FT_RES ); // console_outbyte_polled( 0, 'R' ); // console_outbyte_polled( 0, '\n' ); } else { /* Enable only the data transfer towards the CMD I/F */ PtrRWChannel->StoreEnable = FT_STR_CMD; } } /*****************************************************************************/ /* @Function: FT_ifBiteTORecovery */ /* @Purpose : */ /* This function handles the timeout event during a BITE operation */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* TimerId IN Timer identification */ /* @@ */ /*****************************************************************************/ void FT_ifBiteTORecovery(unsigned int TimerId, FT_RW_CH* PtrRWChannel) { /* If the BITE operation dosen't end then close it and mark the module bad */ FD_piDrammaWrWPBUSReg(PtrRWChannel->ActiveModule,FD_INTMSK,FD_MM_INT_DISABIL); PtrRWChannel->PtrModuleStatus->State = FT_STATE_MOD_FAIL; PtrRWChannel->PtrModuleStatus->Mode = FT_MODE_MEM_MOD_ON; } /*****************************************************************************/ /* @Function: FT_ifStoreAbort */ /* @Purpose : */ /* This function is used to close the Downlink operation and RWChannel */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* PtrRWChannel IN Pointer to the RWchannel manage structure */ /* @@ */ /*****************************************************************************/ void FT_ifStoreAbort(FT_RW_CH* PtrRWChannel) { SM_ACQMODE acqMode; /* Reinit the data acquisition and SRAM page store operations */ acqMode = PM_pi_GetAcqMode(); /* HW reset of PIF */ SD_piPIFReset(); /* Init the timeout timers */ SD_piSetEventTimeout(SM_ETO_TICS); SD_piSetDataTimeout(SM_DTO_TICS); /* Init the Header length registers */ SD_piSetDataHeaderLength(SM_PKTHEADER_LEN); SD_piSetCalibrationHeaderLength(SM_PKTHEADER_LEN); PM_pi_SetAcqMode(SM_IDLE); FT_ifDisableStore(PtrRWChannel, TRUE); FT_ifEnableStore(PtrRWChannel); PM_pi_SetAcqMode(acqMode); }