int lc823450_sdc_trimsector(uint32_t ch, unsigned long addr, unsigned short cnt)
{
int ret;
_sdc_semtake(&_sdc_sem[ch]);
#ifdef CONFIG_LC823450_SDC_LOG
mcinfo("++++ start ch=%d, addr=%ld, cnt=%d \n", ch, addr, cnt);
#endif
lc823450_sdc_access_led(ch, addr);
#ifdef CONFIG_SCHED_INSTRUMENTATION_IO
sched_add_bt((uint64_t)cnt);
#endif
ret = SdDrEraseSeq(0x00000001, addr, cnt, _cfg[ch]);
if (0 > ret)
{
mcinfo("ret=%d ch=%d add=%ld cnt=%d \n", ret, ch, addr, cnt);
}
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
int lc823450_sdc_changespeedmode(uint32_t ch, int mode)
{
int ret;
mcinfo("++++ ch=%d, mode=%d \n", ch, mode);
_sdc_semtake(&_sdc_sem[ch]);
ret = SdDrChangeSpeedMode(mode, _cfg[ch]);
if (0 == ret)
{
switch (mode)
{
case 1: /* High Speed */
modifyreg32(SDCTL,
SDCTL_ACSMODE0_MASK << (ch * 8),
SDCTL_ACSMODE0_HS << (ch * 8));
break;
case 4: /* DDR */
modifyreg32(SDCTL,
SDCTL_ACSMODE0_MASK << (ch * 8),
SDCTL_ACSMODE0_MMCDDR << (ch * 8));
break;
}
}
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
static void fmuk66_mediachange(struct fmuk66_sdhc_state_s *sdhc)
{
bool inserted;
/* Get the current value of the card detect pin. This pin is pulled up on
* board. So low means that a card is present.
*/
inserted = !kinetis_gpioread(GPIO_SD_CARDDETECT);
mcinfo("inserted: %s\n", inserted ? "Yes" : "No");
/* Has the pin changed state? */
if (inserted != sdhc->inserted) {
mcinfo("Media change: %d->%d\n", sdhc->inserted, inserted);
/* Yes.. perform the appropriate action (this might need some debounce). */
sdhc->inserted = inserted;
sdhc_mediachange(sdhc->sdhc, inserted);
#ifdef CONFIG_FMUK66_SDHC_AUTOMOUNT
/* Let the automounter know about the insertion event */
fmuk66_automount_event(fmuk66_cardinserted());
#endif
}
}
int lc823450_sdc_getcid(uint32_t ch, char *cidstr, int length)
{
uint8_t cid[16];
int ret;
mcinfo("++++ ch=%d \n", ch);
_sdc_semtake(&_sdc_sem[ch]);
ret = SdDrGetCid((UI_32 *)cid, _cfg[ch]);
if (0 == ret && length >= (2 * sizeof(cid) + 1))
{
int i;
for (i = 15; i >= 0; i--)
{
snprintf(cidstr, 3, "%02x", cid[i]);
cidstr += 2;
}
*cidstr = '\0';
}
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
int lc823450_sdc_initialize(uint32_t ch)
{
int ret;
/* Only ES2 is supported */
ASSERT(1 == cpu_ver);
struct SdDrCfg_s *psd = _cfg[ch];
psd->sysclk = lc823450_get_systemfreq();
psd->detecttime = DET_TIME;
#ifdef CONFIG_LC823450_SDC_UHS1
psd->setting = SDDR_SD_SWITCH_18V;
#endif
psd->deposinit = sddep_os_init;
psd->deposexit = sddep_os_exit;
psd->depsetclk = sddep_set_clk;
psd->depwait = sddep_wait;
psd->depwaitstatus = sddep_wait_status;
psd->depreaddata = sddep_read;
psd->depwritedata = sddep_write;
psd->depvoltageswitch = sddep_voltage_switch;
switch (ch)
{
case 0:
psd->dephwinit = sddep0_hw_init;
psd->dephwexit = sddep0_hw_exit;
psd->regbase = SDIF0_BASE;
psd->workbuf = _work0;
break;
#ifdef CONFIG_LC823450_SDIF_SDC
case 1:
psd->dephwinit = sddep1_hw_init;
psd->dephwexit = sddep1_hw_exit;
psd->regbase = SDIF1_BASE;
psd->workbuf = _work1;
break;
#endif
default:
ASSERT(false);
}
mcinfo("++++ start \n");
_sdc_semtake(&_sdc_sem[ch]);
ret = SdDrInitialize(_cfg[ch]);
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
int lc823450_sdc_finalize(uint32_t ch)
{
int ret;
mcinfo("++++ start ch=%ld \n", ch);
_sdc_semtake(&_sdc_sem[ch]);
ret = SdDrFinalize(_cfg[ch]);
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
int lc823450_sdc_setclock(uint32_t ch, uint32_t limitclk, uint32_t sysclk)
{
int ret;
mcinfo("++++ start ch=%ld limitClk=%ld sysClk=%ld\n", ch, limitClk, sysClk);
_sdc_semtake(&_sdc_sem[ch]);
ret = SdDrSetClock(limitclk, sysclk, _cfg[ch]);
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
int lc823450_sdc_refmediatype(uint32_t ch)
{
int ret;
mcinfo("++++ start \n");
_sdc_semtake(&_sdc_sem[ch]);
ret = SdDrRefMediaType(_cfg[ch]);
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
int lc823450_sdc_cachectl(uint32_t ch, int ctrl)
{
int ret;
mcinfo("++++ ch=%d, ctrl=%d \n", ch, ctrl);
_sdc_semtake(&_sdc_sem[ch]);
ret = SdDrCacheCtrl(ctrl, _cfg[ch]);
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
int lc823450_sdc_getcardsize(uint32_t ch,
unsigned long *psecnum, unsigned long *psecsize)
{
int ret;
mcinfo("++++ start \n");
_sdc_semtake(&_sdc_sem[ch]);
ret = SdDrGetCardSize(psecnum, psecsize, _cfg[ch]);
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
int k64_sdhc_initialize(void)
{
int ret;
/* Configure GPIO pins */
kinetis_pinconfig(GPIO_SD_CARDDETECT);
/* Attached the card detect interrupt (but don't enable it yet) */
kinetis_pinirqattach(GPIO_SD_CARDDETECT, k64_cdinterrupt);
/* Configure the write protect GPIO -- None */
/* Mount the SDHC-based MMC/SD block driver */
/* First, get an instance of the SDHC interface */
mcinfo("Initializing SDHC slot %d\n", MMCSD_SLOTNO);
g_sdhc.sdhc = sdhc_initialize(MMCSD_SLOTNO);
if (!g_sdhc.sdhc)
{
mcerr("ERROR: Failed to initialize SDHC slot %d\n", MMCSD_SLOTNO);
return -ENODEV;
}
/* Now bind the SDHC interface to the MMC/SD driver */
mcinfo("Bind SDHC to the MMC/SD driver, minor=%d\n", MMSCD_MINOR);
ret = mmcsd_slotinitialize(MMSCD_MINOR, g_sdhc.sdhc);
if (ret != OK)
{
syslog(LOG_ERR, "ERROR: Failed to bind SDHC to the MMC/SD driver: %d\n", ret);
return ret;
}
syslog(LOG_INFO, "Successfully bound SDHC to the MMC/SD driver\n");
/* Handle the initial card state */
k64_mediachange();
/* Enable CD interrupts to handle subsequent media changes */
kinetis_pinirqenable(GPIO_SD_CARDDETECT);
return OK;
}
bool fmuk66_cardinserted(void)
{
bool inserted;
/* Get the current value of the card detect pin. This pin is pulled up on
* board. So low means that a card is present.
*/
inserted = !kinetis_gpioread(GPIO_SD_CARDDETECT);
mcinfo("inserted: %s\n", inserted ? "Yes" : "No");
return inserted;
}
int lc823450_sdc_identifycard(uint32_t ch)
{
int ret;
mcinfo("++++ start \n");
_sdc_semtake(&_sdc_sem[ch]);
ret = SdDrIdentifyCard(_cfg[ch]);
#ifdef CONFIG_LC823450_SDC_CACHE
if (ch)
{
_sec_cache_enabled = 0;
_sec_cache_add = 0xffffffff; /* invalid */
}
#endif
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
int lc823450_sdc_writesector(uint32_t ch,
unsigned long addr, unsigned short cnt,
void *pbuf, unsigned long type)
{
int ret;
_sdc_semtake(&_sdc_sem[ch]);
#ifdef CONFIG_LC823450_SDC_LOG
mcinfo("++++ start ch=%d, addr=%ld, cnt=%d \n", ch, addr, cnt);
#endif
#ifdef CONFIG_LC823450_SDC_CACHE
if (1 == ch && _sec_cache_enabled)
{
_sec_cache_add = 0xffffffff; /* invalid */
}
#endif
lc823450_sdc_access_led(ch, addr);
#ifdef CONFIG_SCHED_INSTRUMENTATION_IO
sched_add_bo((uint64_t)cnt);
#endif
ret = SdDrWriteSector(addr, cnt, pbuf, type, _cfg[ch]);
if (0 > ret)
{
mcinfo("ret=%d ch=%d add=%ld cnt=%d \n", ret, ch, addr, cnt);
}
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
/*
* @file sim-hlt-tpc.C
* @brief HLT Conformal mapping tracker embedded into AliRoot simulation.
*
* Example macro to run the HLT Conformal mapping tracker embedded into
* AliRoot simulation. The reconstruction is done from the TPC digits.
*
* Usage: aliroot -b -q sim-hlt-tpc.C | tee sim-hlt-tpc.log
*
* The chain to be run is defined within the macro. The input data is
* read from the TPC.Digits.
*
* The following options can be specified comma separated in a string:
* <pre>
* aliroot -b -q sim-hlt-tpc.C'("options")'
* CA use the cellular automaton tracker and track merger
* CM use the conformal mapping tracker and track merger
* SORTED use CF pre-sorting and corresponding sequential CF
* algorithm, by default the algorithm capable of reading
* unsorted data is used
* RAW write raw data for all detectors
* RAWHLT write raw data only for HLT
* MC propagate the MC information
* </pre>
*
* The macro asumes the data to be already simulated. If it should run
* within the initial simulation, comment the corresponding functions
* below (SetRunGeneration etc.)
*
* @author [email protected]
* @ingroup alihlt_tpc
*/
sim_hlt_tpc(const char* options="CA")
{
// this is just a tool to switch the logging systems
AliHLTLogging log;
//log.SwitchAliLog(0);
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// scanning the options
//
bool bUseCA=true; // use the CA tracker and merger
bool bCFSort=false; // CF pre-sorting and sequential CF algorithm
bool bRawData=false;// raw data for all detectors
bool bRawHLTData=false; // raw data only for HLT
bool bPropagateMC=false;
TString tsOptions=options;
TObjArray* pTokens=tsOptions.Tokenize(",");
if (pTokens) {
for (int n=0; n<pTokens->GetEntries(); n++) {
TString arg=((TObjString*)pTokens->At(n))->GetString();
if (arg.CompareTo("ca", TString::kIgnoreCase)==0) {
bUseCA=true;
} else if (arg.CompareTo("cm", TString::kIgnoreCase)==0) {
bUseCA=false;
} else if (arg.CompareTo("sorted", TString::kIgnoreCase)==0) {
bCFSort=true;
} else if (arg.CompareTo("unsorted", TString::kIgnoreCase)==0) {
bCFSort=false;
} else if (arg.CompareTo("raw", TString::kIgnoreCase)==0) {
bRawData=true;
} else if (arg.CompareTo("rawhlt", TString::kIgnoreCase)==0) {
bRawHLTData=true;
} else if (arg.CompareTo("mc", TString::kIgnoreCase)==0) {
bPropagateMC=true;
} else {
cout << "unknown argument: " << arg << endl;
return 0;
}
}
delete pTokens;
}
// summary
cout << "using " << bUseCA?"CA":"CM" << " tracker" << endl;
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// init the HLT system in order to define the analysis chain below
//
AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// define the analysis chain
//
// load TPCParam from OCDB
const char* cdbEntry="TPC/Calib/Parameters";
AliCDBManager* pMan=AliCDBManager::Instance();
AliTPCParam* pTPCParam=NULL;
if (pMan) {
if (!pMan->IsDefaultStorageSet()) {
pMan->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
pMan->SetRun(0);
}
AliCDBEntry *pEntry = pMan->Get(cdbEntry);
if (pEntry &&
pEntry->GetObject() &&
(pTPCParam=dynamic_cast<AliTPCParam*>(pEntry->GetObject()))) {
} else {
HLTWarning("can not load AliTPCParam from CDB entry %s", cdbEntry);
}
}
int iMinSlice=0;
int iMaxSlice=35;
int iMinPart=0;
int iMaxPart=5;
TString mergerInput;
TString writerInput;
TString sinkClusterInput;
for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
TString trackerInput;
for (int part=iMinPart; part<=iMaxPart; part++) {
TString arg, publisher, cf;
// digit publisher components
arg.Form("-slice %d -partition %d", slice, part);
publisher.Form("DP_%02d_%d", slice, part);
AliHLTConfiguration pubconf(publisher.Data(), "TPCDigitPublisher", NULL , arg.Data());
// cluster finder components
arg="-timebins ";
if (pTPCParam) arg+=pTPCParam->GetMaxTBin()+1;
else arg+=446; // old simulated data
if (bCFSort) arg+=" -sorted ";
if (bPropagateMC) arg+=" -do-mc ";
cf.Form("CF_%02d_%d", slice, part);
AliHLTConfiguration cfconf(cf.Data(), "TPCClusterFinderUnpacked", publisher.Data(), arg.Data());
if (trackerInput.Length()>0) trackerInput+=" ";
trackerInput+=cf;
if (sinkClusterInput.Length()>0) sinkClusterInput+=" ";
sinkClusterInput+=cf;
}
TString tracker;
// tracker finder components
tracker.Form("TR_%02d", slice);
if (bUseCA) {
AliHLTConfiguration trackerconf(tracker.Data(), "TPCCATracker", trackerInput.Data(), "");
} else {
AliHLTConfiguration trackerconf(tracker.Data(), "TPCSliceTracker", trackerInput.Data(), "-pp-run");
}
//add all trackers to writer input. Include if you would like all slice tracks written.
//if (writerInput.Length()>0) writerInput+=" ";
//writerInput+=tracker;
// add all clusterfinders to the writer input
if (writerInput.Length()>0) writerInput+=" ";
writerInput+=trackerInput;
if (mergerInput.Length()>0) mergerInput+=" ";
mergerInput+=tracker;
}
// GlobalMerger component
if (bUseCA) {
AliHLTConfiguration mergerconf("globalmerger","TPCCAGlobalMerger",mergerInput.Data(),"");
} else {
AliHLTConfiguration mergerconf("globalmerger","TPCGlobalMerger",mergerInput.Data(),"");
}
TString converterInput="globalmerger";
// collector for the MC information to be propagated from CFs to ESDConverter
if (bPropagateMC){
AliHLTConfiguration mcinfo("mcinfo", "BlockFilter" , sinkClusterInput.Data(), "-datatype 'CLMCINFO' 'TPC '");
AliHLTConfiguration mcTrackMarker("mcTrackMarker","TPCTrackMCMarker","globalmerger mcinfo","" );
converterInput+=" mcTrackMarker";
}
if (writerInput.Length()>0) writerInput+=" ";
writerInput+="globalmerger";
//////////////////////////////////////////////////////////////////////////////////////////
//
// output section
//
//////////////////////////////////////////////////////////////////////////////////////////
// sink1: id=sink-writeall write all blocks
AliHLTConfiguration sink1("sink-writeall", "FileWriter" , writerInput.Data(), "-specfmt -subdir=event_%d -blcknofmt=_0x%x -idfmt=_0x%08x");
//////////////////////////////////////////////////////////////////////////////////////////
// sink2: id=sink-esd-file write ESD using the TPCEsdWriter
AliHLTConfiguration sink2("sink-esd-file", "TPCEsdWriter" , converterInput.Data(), "-datafile AliHLTESDs.root");
//////////////////////////////////////////////////////////////////////////////////////////
// sink3: id=sink-esd add ESD to HLTOUT using the TPCEsdConverter
// the esd converter configuration
AliHLTConfiguration sink3("sink-esd", "TPCEsdConverter" , converterInput.Data(), "");
//////////////////////////////////////////////////////////////////////////////////////////
// sink4: id=sink-clusters add cluster data blocks to HLTOUT
AliHLTConfiguration sink4("sink-clusters", "BlockFilter" , sinkClusterInput.Data(), "-datatype 'CLUSTERS' 'TPC '");
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// Init and run the HLT simulation
// All but HLT simulation is switched off
//
AliSimulation sim;
// switch of simulation and data generation
// comment all that stuff to also simulate the events and data
sim.SetRunGeneration(kFALSE);
sim.SetMakeDigits("");
sim.SetMakeSDigits("");
sim.SetMakeDigitsFromHits("");
//sim.SetMakeTrigger("");
sim.SetRunQA(":");
// the normal simulation sets the specific storage for the GRP entry
if (gSystem->AccessPathName("GRP/GRP/Data")) {
cerr << "*********************************************************" << endl;
cerr << "error: no GRP entry found in the currect directory, simulation might be incomplete. Skip setting specific storage for GRP entry" << endl;
cerr << "*********************************************************" << endl << endl;
} else {
sim.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
}
TString rawDataSelection="HLT";
if (bRawData) rawDataSelection="ALL";
if (bRawHLTData || bRawData) sim.SetWriteRawData(rawDataSelection, "raw.root", kTRUE);
// set the options for the HLT simulation
sim.SetRunHLT("libAliHLTUtil.so libAliHLTTPC.so loglevel=0x7c "
"chains=sink-esd,sink-clusters");
sim.Run();
}
int fmuk66_sdhc_initialize(void)
{
int ret;
struct fmuk66_sdhc_state_s *sdhc = &g_sdhc;
/* Configure GPIO pins */
VDD_3V3_SD_CARD_EN(true);
kinetis_pinconfig(GPIO_SD_CARDDETECT);
/* Attached the card detect interrupt (but don't enable it yet) */
kinetis_pinirqattach(GPIO_SD_CARDDETECT, fmuk66_cdinterrupt, sdhc);
/* Configure the write protect GPIO -- None */
/* Mount the SDHC-based MMC/SD block driver */
/* First, get an instance of the SDHC interface */
mcinfo("Initializing SDHC slot %d\n", CONFIG_NSH_MMCSDSLOTNO);
sdhc->sdhc = sdhc_initialize(CONFIG_NSH_MMCSDSLOTNO);
if (!sdhc->sdhc) {
mcerr("ERROR: Failed to initialize SDHC slot %d\n", CONFIG_NSH_MMCSDSLOTNO);
return -ENODEV;
}
// Testing done on SanDISK HC all failed sd_bench with Drive/Slew other than default and _PIN_OUTPUT_FAST|_PIN_OUTPUT_HIGHDRIVE
// _PIN_OUTPUT_FAST|_PIN_OUTPUT_HIGHDRIVE Square noisy, pass SanDISK HC
// _PIN_OUTPUT_FAST|_PIN_OUTPUT_LOWDRIVE Square noisy, pass SanDISK HC
// _PIN_OUTPUT_HIGHDRIVE|_PIN_OUTPUT_SLOW sinusoidal fail SanDISK HC pass SanDISK HC1
// _PIN_OUTPUT_LOWDRIVE|_PIN_OUTPUT_SLOW sinusoidal fail SanDISK HC pass SanDISK HC1
// _PIN_OUTPUT_SLOW sinusoidal fail SanDISK HC pass SanDISK HC1
// This up dating of the driver setting is for EMI issue with GPS and FCC
// With this setting the clock is sinusoidal N.B. sd_bench fails on SanDISK HC, but
// Passes SanDISK **HC1** - use HC1 or Kingston cards!
kinetis_pinconfig(PIN_SDHC0_DCLK | _PIN_OUTPUT_HIGHDRIVE | _PIN_OUTPUT_SLOW);
/* Now bind the SDHC interface to the MMC/SD driver */
mcinfo("Bind SDHC to the MMC/SD driver, minor=%d\n", CONFIG_NSH_MMCSDMINOR);
ret = mmcsd_slotinitialize(CONFIG_NSH_MMCSDMINOR, sdhc->sdhc);
if (ret != OK) {
syslog(LOG_ERR, "ERROR: Failed to bind SDHC to the MMC/SD driver: %d\n", ret);
return ret;
}
syslog(LOG_ERR, "Successfully bound SDHC to the MMC/SD driver\n");
/* Handle the initial card state */
fmuk66_mediachange(sdhc);
/* Enable CD interrupts to handle subsequent media changes */
kinetis_pinirqenable(GPIO_SD_CARDDETECT);
return OK;
}
int lc823450_sdc_readsector(uint32_t ch,
unsigned long addr, unsigned short cnt,
void *pbuf, unsigned long type)
{
int ret = 0;
int i = 0;
_sdc_semtake(&_sdc_sem[ch]);
#ifdef CONFIG_LC823450_SDC_LOG
mcinfo("++++ start ch=%d, addr=%ld, cnt=%d \n", ch, addr, cnt);
#endif
#ifdef CONFIG_LC823450_SDC_CACHE
if (ch && _sec_cache_enabled && 1 == cnt && addr == _sec_cache_add)
{
memcpy(pbuf, _sec_cache, sizeof(_sec_cache));
goto errout_with_semaphore;
}
#endif
lc823450_sdc_access_led(ch, addr);
#ifdef CONFIG_SCHED_INSTRUMENTATION_IO
sched_add_bi((uint64_t)cnt);
#endif
for (i = 0; i < 5; i++)
{
#ifdef CONFIG_LC823450_SDIF_PATCH
ret = fixedSdDrReadSector(addr, cnt, pbuf, type, _cfg[ch]);
#else
ret = SdDrReadSector(addr, cnt, pbuf, type, _cfg[ch]);
#endif
if (0 == ret)
{
break;
}
mcinfo("ret=%d ch=%d add=%ld cnt=%d i=%d \n",
ret, ch, addr, cnt, i);
}
#ifdef CONFIG_LC823450_SDC_CACHE
if (ch)
{
if (0 == addr)
{
uint8_t *p = (pbuf + 0x1c2); /* partition id */
if (0x7 == *p)
{
mcinfo("exFAT (NTFS) detected \n");
_sec_cache_enabled = 1;
}
}
if (_sec_cache_enabled)
{
if (1 == cnt && 0 == ret)
{
memcpy(_sec_cache, pbuf, sizeof(_sec_cache));
_sec_cache_add = addr;
}
else
{
_sec_cache_add = 0xffffffff; /* invalid */
}
}
}
errout_with_semaphore:
#endif
_sdc_semgive(&_sdc_sem[ch]);
mcinfo("---- end ret=%d \n", ret);
return ret;
}
