/*******************************************************************************
Name : LAYERVID_UpdateFromMixer
Description : Update parameters from mixer called by STMIXER.
Parameters : ViewportHandle
Params
Assumptions :
Limitations :
Returns :
*******************************************************************************/
void LAYERVID_UpdateFromMixer(const STLAYER_Handle_t LayerHandle, STLAYER_OutputParams_t * const OutputParams_p)
{
HALLAYER_LayerProperties_t * HALLAYER_Data_p;
STLAYER_UpdateParams_t UpdateParams;
STEVT_DeviceSubscribeParams_t SubscribeParams;
ST_ErrorCode_t Error;
/* Find structure */
HALLAYER_Data_p = (HALLAYER_LayerProperties_t *) LayerHandle;
if (HALLAYER_Data_p->ValidityCheck != HALLAYER_VALID_HANDLE)
{
return;
}
/* Initialise event data */
UpdateParams.UpdateReason = 0;
/* The reason of the call is a new connection to a mixer */
if ((OutputParams_p->UpdateReason & STLAYER_CONNECT_REASON) != 0)
{
HALLAYER_Data_p->DisplayParamsForVideo.FrameBufferDisplayLatency = OutputParams_p->FrameBufferDisplayLatency;
HALLAYER_Data_p->DisplayParamsForVideo.FrameBufferHoldTime = OutputParams_p->FrameBufferHoldTime;
UpdateParams.DisplayParamsForVideo.FrameBufferDisplayLatency = OutputParams_p->FrameBufferDisplayLatency;
UpdateParams.DisplayParamsForVideo.FrameBufferHoldTime = OutputParams_p->FrameBufferHoldTime;
UpdateParams.UpdateReason |= STLAYER_CONNECT_REASON;
}
/* The reason of the call is a new VTG. */
if (((OutputParams_p->UpdateReason & STLAYER_VTG_REASON) != 0) || /* VTG name changed */
(((OutputParams_p->UpdateReason & STLAYER_SCREEN_PARAMS_REASON) != 0) && /* or the VTG FrameRate screen param changed */
(HALLAYER_Data_p->VTGSettings.FrameRate != OutputParams_p->FrameRate))
)
{
/* Notify event HALLAYER_UPDATE_PARAMS_EVT_ID with reason VTG for both VTG name and VTG frame rate change.
This is because FrameRate is inside screen params, but video doesn't care about screen params... */
UpdateParams.UpdateReason |= STLAYER_VTG_REASON;
/* Assign a VTG name: either new one if available, or previous one */
if ((OutputParams_p->UpdateReason & STLAYER_VTG_REASON) != 0)
{
/* Top Level HAL must subscribe to this VTG */
if(HALLAYER_Data_p->VTGSettings.IsConnected)
{
/* unsubscribe the previous one */
STEVT_UnsubscribeDeviceEvent(HALLAYER_Data_p->EventsHandle,
HALLAYER_Data_p->VTGSettings.Name,
STVTG_VSYNC_EVT);
}
/* Reason VTG of this event, take new VTG name */
strncpy(UpdateParams.VTG_Name, OutputParams_p->VTGName, sizeof(ST_DeviceName_t)-1); /* old field, kept for backwards compatibility */
strncpy(UpdateParams.VTGParams.VTGName, OutputParams_p->VTGName, sizeof(ST_DeviceName_t)-1);
/* Store the new VTG Name for the future. Could be asked by the video driver with STLAYER_GetVTGName. */
strncpy(HALLAYER_Data_p->VTGSettings.Name, OutputParams_p->VTGName, sizeof(ST_DeviceName_t)-1);
/* Top Level HAL must subscribe to this VTG */
HALLAYER_Data_p->VTGSettings.IsConnected = TRUE;
SubscribeParams.NotifyCallback = (STEVT_DeviceCallbackProc_t)LayerVideo_VSync;
SubscribeParams.SubscriberData_p = (void*)HALLAYER_Data_p;
Error = STEVT_SubscribeDeviceEvent(HALLAYER_Data_p->EventsHandle,
HALLAYER_Data_p->VTGSettings.Name,
STVTG_VSYNC_EVT,
&SubscribeParams);
if (Error != ST_NO_ERROR)
{
STTBX_Print(("STLAYER : Synchro KO: layer not synchro"));
return;
}
}
else
{
/* NOT reason VTG of this event, take previous VTG name */
strncpy(UpdateParams.VTG_Name, HALLAYER_Data_p->VTGSettings.Name, sizeof(ST_DeviceName_t)-1); /* old field, kept for backwards compatibility */
strncpy(UpdateParams.VTGParams.VTGName, HALLAYER_Data_p->VTGSettings.Name, sizeof(ST_DeviceName_t)-1);
}
/* Assign a VTG frame rate: either new one if available, or previous one */
if ((OutputParams_p->UpdateReason & STLAYER_SCREEN_PARAMS_REASON) != 0)
{
/* Reason screen params of this event, take new VTG frame rate */
UpdateParams.VTGParams.VTGFrameRate = OutputParams_p->FrameRate;
/* Store the VTG frame rate for the future. */
HALLAYER_Data_p->VTGSettings.FrameRate = OutputParams_p->FrameRate;
}
else
{
/* NOT reason screen params of this event, take previous VTG frame rate */
UpdateParams.VTGParams.VTGFrameRate = HALLAYER_Data_p->VTGSettings.FrameRate;
}
}
/* Reason of the call is screen params change */
/* if ((OutputParams_p->UpdateReason & STLAYER_SCREEN_PARAMS_REASON) != 0)*/
/* {*/
/* VTG FrameRate treated with VTG reason, nothing to do with other parameters... */
/* }*/
if ((OutputParams_p->UpdateReason & STLAYER_DISCONNECT_REASON) != 0)
{
HALLAYER_Data_p->DisplayParamsForVideo.FrameBufferDisplayLatency = 1;
HALLAYER_Data_p->DisplayParamsForVideo.FrameBufferHoldTime = 1;
UpdateParams.DisplayParamsForVideo.FrameBufferDisplayLatency = 1;
UpdateParams.DisplayParamsForVideo.FrameBufferHoldTime = 1;
/* Inform drivers above */
UpdateParams.UpdateReason |= STLAYER_DISCONNECT_REASON;
}
/* Notify update event if required */
if (UpdateParams.UpdateReason != 0)
{
STEVT_Notify(((HALLAYER_LayerProperties_t *) LayerHandle)->EventsHandle, ((HALLAYER_LayerProperties_t *) LayerHandle)->RegisteredEventsID[HALLAYER_UPDATE_PARAMS_EVT_ID], (const void *) (&UpdateParams));
}
/* Update HAL Layer */
(((HALLAYER_LayerProperties_t*)LayerHandle)->FunctionsTable_p->UpdateFromMixer)(LayerHandle, OutputParams_p);
} /* end of LAYERVID_UpdateFromMixer() */
/*******************************************************************************
Name : STLAYER_VideoTask
Description : Calls the low level HAL on VSync if needed
Parameters :
Assumptions :
Limitations :
Returns :
*******************************************************************************/
static void STLAYER_VideoTask(void * Context_p)
{
HALLAYER_LayerProperties_t * LayerProperties_p;
STOS_TaskEnter(NULL);
/* initialize the context pointer */
LayerProperties_p = (HALLAYER_LayerProperties_t*) Context_p;
LayerProperties_p->HALOrderSemaphore_p = STOS_SemaphoreCreateFifo(NULL,0);
while ( LayerProperties_p->TaskTerminate == FALSE )
{
STOS_SemaphoreWait(LayerProperties_p->HALOrderSemaphore_p);
#ifdef DEBUG_RECORD_TIME
/* STTBX_Print(("h-t:%x\n",tv_head - tv_tail));*/
while (tv_head != tv_tail)
{
unsigned long diff_time;
diff_time = (unsigned long) (get_time_convert((struct timeval *) &(tv_tail->tv_data)))
- (unsigned long) (get_time_convert((struct timeval *) &(old_tv_data)));
switch(tv_tail->where)
{
case 0x00:
/* Top of VTG handler */
STTBX_Print(("---> L:%x T:%06lu\n", tv_tail->where, (unsigned long) (diff_time) % 1000000)); /* in us */
/*
STTBX_Print(("---> T:%lu Time:%03lu.%03lu D:%06lu\n", tv_tail->irq_nb,
(unsigned long) (get_time_convert((struct timeval *) &(tv_tail->tv_data))) / 1000000,
(unsigned long) (get_time_convert((struct timeval *) &(tv_tail->tv_data))) % 1000000,
(unsigned long) (diff_time) % 1000000));
*/
/* Ref time if at this location */
old_tv_data = tv_tail->tv_data;
break;
case 0x0F:
/* End of VTG handler */
/* STTBX_Print((" D:%lu T:%06lu sync:%lu\n", tv_tail->data2,
(unsigned long) (diff_time) % 1000000,
(unsigned long) (tv_tail->data2)));*/
/*
STTBX_Print((" T:%2x Time:%03lu.%03lu D:%06lu\n", tv_tail->irq_nb,
(unsigned long) (get_time_convert((struct timeval *) &(tv_tail->tv_data))) / 1000000,
(unsigned long) (get_time_convert((struct timeval *) &(tv_tail->tv_data))) % 1000000,
(unsigned long) (diff_time) % 1000000));
*/
break;
default:
break;
}
/* old_tv_data = tv_tail->tv_data;*/
layer_incr_tv(&tv_tail);
}
#endif /* DEBUG_RECORD_TIME */
LayerProperties_p->FunctionsTable_p->SynchronizedUpdate((STLAYER_Handle_t)LayerProperties_p);
}
/* if this point is reached , it is the task termination */
/* the callback must be no more called */
if(LayerProperties_p->VTGSettings.IsConnected)
{
LayerProperties_p->VTGSettings.IsConnected = FALSE;
STEVT_UnsubscribeDeviceEvent(LayerProperties_p->EventsHandle,
LayerProperties_p->VTGSettings.Name,
STVTG_VSYNC_EVT);
}
STOS_TaskExit(NULL);
}/* End of STLAYER_VideoTask */
/*******************************************************************************
Name : LAYERVID_Init
Description : Inits The Hal video Layer
Parameters :
Assumptions :
Limitations :
Returns : ST_NO_ERROR if success, ST_ERROR_BAD_PARAMETER, STLAYER_ERROR_EVENT_REGISTRATION
*******************************************************************************/
ST_ErrorCode_t LAYERVID_Init(const ST_DeviceName_t DeviceName, const STLAYER_InitParams_t * const LayerInitParams_p, STLAYER_Handle_t * const LayerHandle_p)
{
HALLAYER_LayerProperties_t * HALLAYER_Data_p;
STEVT_OpenParams_t STEVT_OpenParams;
ST_DeviceName_t LayerName;
ST_ErrorCode_t ErrorCode = ST_NO_ERROR;
#ifdef ST_OSLINUX
STLAYERMod_Param_t VideoLayerModuleParam; /* layer modules parameters */
STLAYERMod_Param_t CompositorModuleParam;
#endif
#ifdef DEBUG_RECORD_TIME
memset(tv_data_tab, 0xFF, sizeof(STLAYER_Record_Time_t) * NR_TIMEVAL);
#endif
/* Memory allocation. */
HALLAYER_Data_p = (HALLAYER_LayerProperties_t *)STOS_MemoryAllocate(LayerInitParams_p->CPUPartition_p, sizeof(HALLAYER_LayerProperties_t));
/* If allocation fails returns an error. */
if (HALLAYER_Data_p == NULL)
{
return (ST_ERROR_NO_MEMORY);
}
/* local LayerName variable to be compliant with STEVT_RegisterDeviceEvent */
strncpy(LayerName, DeviceName, sizeof(ST_DeviceName_t)-1);
/* Open EVT handle. */
ErrorCode = STEVT_Open(LayerInitParams_p->EventHandlerName, &STEVT_OpenParams, &(HALLAYER_Data_p->EventsHandle));
if (ErrorCode != ST_NO_ERROR)
{
/* Error: open failed, undo initialisations done */
/* De-allocate last: data inside cannot be used after ! */
STOS_MemoryDeallocate(HALLAYER_Data_p->CPUPartition_p, (void *) HALLAYER_Data_p);
return(ST_ERROR_BAD_PARAMETER);
}
ErrorCode = STEVT_RegisterDeviceEvent(HALLAYER_Data_p->EventsHandle, LayerName, STLAYER_UPDATE_PARAMS_EVT, &(HALLAYER_Data_p->RegisteredEventsID[HALLAYER_UPDATE_PARAMS_EVT_ID]));
if (ErrorCode != ST_NO_ERROR)
{
/* Close EVT handle. */
ErrorCode = STEVT_Close(HALLAYER_Data_p->EventsHandle);
/* De-allocate last: data inside cannot be used after ! */
STOS_MemoryDeallocate(HALLAYER_Data_p->CPUPartition_p, (void *) HALLAYER_Data_p);
return(STLAYER_ERROR_EVENT_REGISTRATION);
}
ErrorCode = STEVT_RegisterDeviceEvent(HALLAYER_Data_p->EventsHandle, LayerName, STLAYER_UPDATE_DECIMATION_EVT, &(HALLAYER_Data_p->RegisteredEventsID[HALLAYER_UPDATE_DECIMATION_EVT_ID]));
if (ErrorCode != ST_NO_ERROR)
{
/* Close EVT handle. */
ErrorCode = STEVT_Close(HALLAYER_Data_p->EventsHandle);
/* De-allocate last: data inside cannot be used after ! */
STOS_MemoryDeallocate(HALLAYER_Data_p->CPUPartition_p, (void *) HALLAYER_Data_p);
return(STLAYER_ERROR_EVENT_REGISTRATION);
}
#ifdef STLAYER_USE_FMD
ErrorCode = STEVT_RegisterDeviceEvent(HALLAYER_Data_p->EventsHandle, LayerName, STLAYER_NEW_FMD_REPORTED_EVT, &(HALLAYER_Data_p->RegisteredEventsID[HALLAYER_NEW_FMD_REPORTED_EVT_ID]));
if (ErrorCode != ST_NO_ERROR)
{
/* Close EVT handle. */
ErrorCode = STEVT_Close(HALLAYER_Data_p->EventsHandle);
/* De-allocate last: data inside cannot be used after ! */
STOS_MemoryDeallocate(HALLAYER_Data_p->CPUPartition_p, (void *) HALLAYER_Data_p);
return(STLAYER_ERROR_EVENT_REGISTRATION);
}
#endif
/* return LAYER Handle */
*LayerHandle_p = (STLAYER_Handle_t) HALLAYER_Data_p;
HALLAYER_Data_p->ValidityCheck = HALLAYER_VALID_HANDLE;
/* Initialise parameters */
HALLAYER_Data_p->VTGSettings.Name[0] = '\0';
HALLAYER_Data_p->VTGSettings.FrameRate = 0;
HALLAYER_Data_p->VTGSettings.VSyncType = STVTG_TOP;
HALLAYER_Data_p->VTGSettings.IsConnected = FALSE;
#ifdef STLAYER_VIDEO_TASK
HALLAYER_Data_p->TaskTerminate = FALSE;
#endif /* #ifdef STLAYER_VIDEO_TASK */
HALLAYER_Data_p->DisplayParamsForVideo.FrameBufferDisplayLatency = 1;
HALLAYER_Data_p->DisplayParamsForVideo.FrameBufferHoldTime = 1;
/* Store parameters */
HALLAYER_Data_p->LayerType = LayerInitParams_p->LayerType;
HALLAYER_Data_p->CPUPartition_p = LayerInitParams_p->CPUPartition_p;
#ifdef ST_XVP_ENABLE_FLEXVP
HALLAYER_Data_p->NCachePartition_p = LayerInitParams_p->NCachePartition_p;
#endif /* ST_XVP_ENABLE_FLEXVP */
#ifdef ST_XVP_ENABLE_FGT
HALLAYER_Data_p->IsFGTBypassed = TRUE; /* default value : FGT is bypassed */
#endif /* ST_XVP_ENABLE_FGT */
#ifdef ST_OSLINUX
/* Mapping LAYER Registers for Video */
if (ErrorCode == ST_NO_ERROR)
{
HALLAYER_Data_p->MappedVideoDisplayWidth = (unsigned long)0x1000;
/* Determinating length and base address of layer of mapping */
if ((LayerInitParams_p->LayerType == STLAYER_SDDISPO2_VIDEO1)||(LayerInitParams_p->LayerType == STLAYER_HDDISPO2_VIDEO1)
||(LayerInitParams_p->LayerType == STLAYER_DISPLAYPIPE_VIDEO1)
||(LayerInitParams_p->LayerType == STLAYER_DISPLAYPIPE_VIDEO2))
{
VideoLayerModuleParam.LayerBaseAddress = (unsigned long)DISP0BaseAddress;
VideoLayerModuleParam.LayerAddressWidth = (unsigned long)HALLAYER_Data_p->MappedVideoDisplayWidth;
}
else if ((LayerInitParams_p->LayerType == STLAYER_SDDISPO2_VIDEO2)
||(LayerInitParams_p->LayerType == STLAYER_HDDISPO2_VIDEO2)
||(LayerInitParams_p->LayerType == STLAYER_DISPLAYPIPE_VIDEO3))
{
VideoLayerModuleParam.LayerBaseAddress = (unsigned long)DISP1BaseAddress;
VideoLayerModuleParam.LayerAddressWidth = (unsigned long)HALLAYER_Data_p->MappedVideoDisplayWidth;
}
else if (LayerInitParams_p->LayerType == STLAYER_DISPLAYPIPE_VIDEO4)
{
VideoLayerModuleParam.LayerBaseAddress = (unsigned long)DISP2BaseAddress;
VideoLayerModuleParam.LayerAddressWidth = (unsigned long)HALLAYER_Data_p->MappedVideoDisplayWidth;
}
else
{
STTBX_Print(("Layer mapping problem: Unknown display base address!\n"));
return (ST_ERROR_BAD_PARAMETER);
}
HALLAYER_Data_p->MappedVideoDisplayBaseAddress_p = (unsigned long *) STLINUX_MapRegion( (void*)VideoLayerModuleParam.LayerBaseAddress,
VideoLayerModuleParam.LayerAddressWidth, "VIDEO LAYER");
if (HALLAYER_Data_p->MappedVideoDisplayBaseAddress_p == NULL)
{
/*ErrorCode = STLAYER_ERROR_MAP_LAYER;*/
release_mem_region(VideoLayerModuleParam.LayerBaseAddress | REGION2, VideoLayerModuleParam.LayerAddressWidth);
STTBX_Print(("Video Layer: ioremap failed -> STLAYER_ERROR_MAP_LAYER!!!! \n"));
}
STTBX_Print(("Video LAYER virtual io kernel address of phys %lX = %lX\n", (unsigned long)(VideoLayerModuleParam.LayerBaseAddress | REGION2), (unsigned long)(HALLAYER_Data_p->MappedVideoDisplayBaseAddress_p)));
}
/* Mapping LAYER Registers for Compositor */
if (ErrorCode == ST_NO_ERROR)
{
HALLAYER_Data_p->MappedGammaWidth = 0xC00 ;
/* Determinating length of mapping */
CompositorModuleParam.LayerBaseAddress = (unsigned long)LAYER_COMPOSITOR_MAPPING;
CompositorModuleParam.LayerAddressWidth = (unsigned long)HALLAYER_Data_p->MappedGammaWidth;
CompositorModuleParam.LayerMappingIndex = 1; /* Compositor register mapping */
HALLAYER_Data_p->MappedGammaBaseAddress_p = (unsigned long *)STLINUX_MapRegion( (void*)CompositorModuleParam.LayerBaseAddress, CompositorModuleParam.LayerAddressWidth, "COMPOSITOR LAYER");
if (HALLAYER_Data_p->MappedGammaBaseAddress_p == NULL)
{
/*ErrorCode = STLAYER_ERROR_MAP_LAYER;*/
release_mem_region(CompositorModuleParam.LayerBaseAddress | REGION2, CompositorModuleParam.LayerAddressWidth);
STTBX_Print(("STLAYER - VIDEO :Compositor Layer: ioremap failed -> STLAYER_ERROR_MAP_LAYER!!!! \n"));
}
STTBX_Print(("STLAYER - VIDEO :Compositor LAYER virtual io kernel address of phys %lX = %lX\n", (unsigned long)(CompositorModuleParam.LayerBaseAddress | REGION2), (unsigned long)(HALLAYER_Data_p->MappedGammaBaseAddress_p)));
}
#endif /* ST_OSLINUX */
if (ErrorCode == ST_NO_ERROR)
{
if ( (LayerInitParams_p->LayerType == STLAYER_OMEGA2_VIDEO1) || (LayerInitParams_p->LayerType == STLAYER_OMEGA2_VIDEO2)
||(LayerInitParams_p->LayerType == STLAYER_7020_VIDEO1) || (LayerInitParams_p->LayerType == STLAYER_7020_VIDEO2)
||(LayerInitParams_p->LayerType == STLAYER_SDDISPO2_VIDEO1) || (LayerInitParams_p->LayerType == STLAYER_SDDISPO2_VIDEO2)
||(LayerInitParams_p->LayerType == STLAYER_HDDISPO2_VIDEO1) || (LayerInitParams_p->LayerType == STLAYER_HDDISPO2_VIDEO2)
||(LayerInitParams_p->LayerType == STLAYER_DISPLAYPIPE_VIDEO1)||(LayerInitParams_p->LayerType == STLAYER_DISPLAYPIPE_VIDEO2)
||(LayerInitParams_p->LayerType == STLAYER_DISPLAYPIPE_VIDEO3)||(LayerInitParams_p->LayerType == STLAYER_DISPLAYPIPE_VIDEO4)
)
{
/* for Omega2 chips, BaseAddress is the base address of the gamma compositor video registers */
/* and BaseAddress2 is the base address of the video dislay registers (DIS_XX and DIP_XX) */
#ifdef ST_OSLINUX
HALLAYER_Data_p->VideoDisplayBaseAddress_p = (void *)((U32) HALLAYER_Data_p->MappedVideoDisplayBaseAddress_p + (U32) LayerInitParams_p->BaseAddress2_p - (U32) VideoLayerModuleParam.LayerBaseAddress);
HALLAYER_Data_p->GammaBaseAddress_p = (void *)((U32) HALLAYER_Data_p->MappedGammaBaseAddress_p + (U32) LayerInitParams_p->BaseAddress_p - (U32) CompositorModuleParam.LayerBaseAddress);
#else
HALLAYER_Data_p->VideoDisplayBaseAddress_p = (void *) ((U8 *) LayerInitParams_p->DeviceBaseAddress_p + (U32) LayerInitParams_p->BaseAddress2_p);
HALLAYER_Data_p->GammaBaseAddress_p = (void *) ((U8 *) LayerInitParams_p->DeviceBaseAddress_p + (U32) LayerInitParams_p->BaseAddress_p);
#endif /* ST_OSLINUX */
}
else if (LayerInitParams_p->LayerType == STLAYER_OMEGA1_VIDEO)
{
/* for Omega1 chips, BaseAddress is the base address of the video dislay registers (VID_XX) */
HALLAYER_Data_p->VideoDisplayBaseAddress_p = (void *) ((U8 *) LayerInitParams_p->DeviceBaseAddress_p + (U32) LayerInitParams_p->BaseAddress_p);
HALLAYER_Data_p->GammaBaseAddress_p = NULL;
}
else
{
/* Close EVT handle. */
ErrorCode = STEVT_Close(HALLAYER_Data_p->EventsHandle);
/* De-allocate last: data inside cannot be used after ! */
STOS_MemoryDeallocate(HALLAYER_Data_p->CPUPartition_p, (void *) HALLAYER_Data_p);
return (ST_ERROR_BAD_PARAMETER);
}
}
if (ErrorCode == ST_NO_ERROR)
{
switch(LayerInitParams_p->LayerType)
{
case STLAYER_OMEGA1_VIDEO :
#if defined (HW_5508) || \
defined (HW_5518) || \
defined (HW_5510) || \
defined (HW_5512) || \
defined (HW_5514) || \
defined (HW_5516) || \
defined (HW_5517) || \
defined (HW_5578)
/* Functions Table Attribution */
HALLAYER_Data_p->FunctionsTable_p = &HALLAYER_Omega1Functions;
#endif /* defined (HW_5508) ... defined (HW_5578) */
break;
case STLAYER_OMEGA2_VIDEO1 :
case STLAYER_7020_VIDEO1 :
case STLAYER_OMEGA2_VIDEO2 :
case STLAYER_7020_VIDEO2 :
#if defined (HW_7015) || defined (HW_7020)
/* Functions Table Attribution */
HALLAYER_Data_p->FunctionsTable_p = &HALLAYER_Omega2Functions;
#endif /* defined (HW_7015) || defined (HW_7020) */
break;
case STLAYER_SDDISPO2_VIDEO1 :
case STLAYER_SDDISPO2_VIDEO2 :
case STLAYER_HDDISPO2_VIDEO1 :
#if defined (HW_5528) || defined (HW_7710) || defined (HW_7100)
/* Functions Table Attribution */
HALLAYER_Data_p->FunctionsTable_p = &HALLAYER_Xddispo2Functions;
#endif /* HW_5528 || HW_7710 || HW_7100 */
break;
case STLAYER_HDDISPO2_VIDEO2 :
#if defined (HW_5528) || defined (HW_7710) || defined (HW_7100) || defined(HW_7109)
/* Functions Table Attribution */
HALLAYER_Data_p->FunctionsTable_p = &HALLAYER_Xddispo2Functions;
#endif /* HW_5528 || HW_7710 || HW_7100 || HW_7109 */
break;
case STLAYER_DISPLAYPIPE_VIDEO1 :
#if defined (HW_7109)
/* Functions Table Attribution */
HALLAYER_Data_p->FunctionsTable_p = &HALLAYER_DisplayPipeFunctions;
#endif /* defined (HW_7109) */
break;
case STLAYER_DISPLAYPIPE_VIDEO2 :
case STLAYER_DISPLAYPIPE_VIDEO3 :
case STLAYER_DISPLAYPIPE_VIDEO4 :
#if defined (HW_7200)
/* Functions Table Attribution */
HALLAYER_Data_p->FunctionsTable_p = &HALLAYER_DisplayPipeFunctions;
#endif /* defined (HW_7200) */
break;
default :
/* Close EVT handle. */
ErrorCode = STEVT_Close(HALLAYER_Data_p->EventsHandle);
/* De-allocate last: data inside cannot be used after ! */
STOS_MemoryDeallocate(HALLAYER_Data_p->CPUPartition_p, (void *) HALLAYER_Data_p);
return(ST_ERROR_BAD_PARAMETER);
break;
}
}
if (ErrorCode == ST_NO_ERROR)
{
/* Initialise layer */
ErrorCode = (HALLAYER_Data_p->FunctionsTable_p->Init)(*LayerHandle_p, LayerInitParams_p);
}
if (ErrorCode != ST_NO_ERROR)
{
/* Close EVT handle. */
STEVT_Close(HALLAYER_Data_p->EventsHandle);
/* De-allocate last: data inside cannot be used after ! */
STOS_MemoryDeallocate(HALLAYER_Data_p->CPUPartition_p,
(void *) HALLAYER_Data_p);
return(ST_ERROR_BAD_PARAMETER);
}
#ifdef STLAYER_VIDEO_TASK
ErrorCode = STOS_TaskCreate ((void (*) (void*))STLAYER_VideoTask,
(void*)HALLAYER_Data_p,
HALLAYER_Data_p->CPUPartition_p,
HALLAYER_VIDEO_TASK_STACK_SIZE,
&(HALLAYER_Data_p->TaskStack),
HALLAYER_Data_p->CPUPartition_p,
&(HALLAYER_Data_p->Task_p),
&(HALLAYER_Data_p->TaskDesc),
STLAYER_VIDEO_HAL_TASK_PRIORITY,
STLAYER_VIDEO_NAME,
task_flags_no_min_stack_size);
if(ErrorCode != ST_NO_ERROR)
{
STTBX_Print(("Error in call to STOS_TaskCreate() ."));
return(!ST_NO_ERROR);
}
#endif /* #ifdef STLAYER_VIDEO_TASK */
return(ST_NO_ERROR);
}
ST_ErrorCode_t LAYERVID_Term(const STLAYER_Handle_t LayerHandle,
const STLAYER_TermParams_t * TermParams_p)
#endif /* ST_OSLINUX */
{
ST_ErrorCode_t ErrorCode = ST_NO_ERROR;
#ifdef ST_OSLINUX
U32 Index;
#endif
#ifdef STLAYER_VIDEO_TASK
task_t * Task_p;
#endif /* #ifdef STLAYER_VIDEO_TASK */
HALLAYER_LayerProperties_t * HALLAYER_Data_p;
#ifdef ST_OSLINUX
Index = stlayer_HalIndexOfNamedLayer(DeviceName);
/* Find structure */
HALLAYER_Data_p = (HALLAYER_LayerProperties_t *) (stlayer_LayerArray[Index].VideoHandle);
#else
HALLAYER_Data_p = (HALLAYER_LayerProperties_t *) LayerHandle;
#endif /* ST_OSLINUX */
if (HALLAYER_Data_p->ValidityCheck != HALLAYER_VALID_HANDLE)
{
ErrorCode = ST_ERROR_INVALID_HANDLE;
}
else
{
#ifdef ST_OSLINUX
/* releasing LAYER linux memory device device driver */
/* Layer Video Display Unmap*/
STLINUX_UnmapRegion( (void*)HALLAYER_Data_p->MappedVideoDisplayBaseAddress_p, (U32)HALLAYER_Data_p->MappedVideoDisplayWidth);
STLINUX_UnmapRegion( (void*)HALLAYER_Data_p->MappedGammaBaseAddress_p, (U32)HALLAYER_Data_p->MappedGammaWidth);
#endif /* ST_OSLINUX */
#ifdef STLAYER_VIDEO_TASK
/* Termination and deletion of the task: set the flag */
HALLAYER_Data_p->TaskTerminate = TRUE;
/* schedule the task and wait for its term */
STOS_SemaphoreSignal(HALLAYER_Data_p->HALOrderSemaphore_p);
Task_p = HALLAYER_Data_p->Task_p;
#ifndef WA_taskwait_on_os20emu
STOS_TaskWait( &Task_p, TIMEOUT_INFINITY );
#endif
ErrorCode = STOS_TaskDelete ( Task_p,
HALLAYER_Data_p->CPUPartition_p,
HALLAYER_Data_p->TaskStack,
HALLAYER_Data_p->CPUPartition_p );
if( ErrorCode != ST_NO_ERROR)
{
STTBX_Print(("Error in call to STOS_TaskDelete()\n\r"));
return(ErrorCode);
}
STOS_SemaphoreDelete(NULL,HALLAYER_Data_p->HALOrderSemaphore_p);
#endif /* #ifdef STLAYER_VIDEO_TASK */
#ifdef ST_OSLINUX
/* Term Layer */
ErrorCode = (HALLAYER_Data_p->FunctionsTable_p->Term)(stlayer_LayerArray[Index].VideoHandle, TermParams_p);
#else
ErrorCode = (HALLAYER_Data_p->FunctionsTable_p->Term)(LayerHandle, TermParams_p);
#endif /* ST_OSLINUX */
if (ErrorCode == ST_NO_ERROR)
{
/* De-validate structure */
HALLAYER_Data_p->ValidityCheck = 0; /* not HALLAYER_VALID_HANDLE */
ErrorCode = STEVT_Close(HALLAYER_Data_p->EventsHandle);
STOS_MemoryDeallocate(HALLAYER_Data_p->CPUPartition_p, (void *) HALLAYER_Data_p);
}
}
return(ErrorCode);
}
/************************************************************************
Name: ata_ctrl_SoftReset
Description: Pulses the SRST bit in the DeviceCtrl register high for 400 ns and
then low. Delays for mandatory 400ns afterwards
Parameters: Two params:
Ata_p : Pointer to the ATA control block
Device: number identifying the device (0,1)
************************************************************************/
BOOL ata_ctrl_SoftReset(ata_ControlBlock_t *Ata_p)
{
S32 TimeOut=ATA_TIMEOUT;
U8 sc, sn;
if (hal_SoftReset(Ata_p->HalHndl) == TRUE)
{
#if defined(ATAPI_DEBUG)
if (ATAPI_Verbose)
{
STTBX_Print(("ata_ctrl_SoftReset(): hal_SoftReset failed\n"));
}
#endif
return TRUE;
}
/*RESET DONE. This causes device 0 be selected.*/
/* If there is a device 0, wait for device 0 to set BSY=0.*/
if(Ata_p->DevInBus[0] != NONE_DEVICE)
{
if(WaitForBit(Ata_p->HalHndl, ATA_REG_STATUS, BSY_BIT_MASK, 0))
{
Ata_p->LastExtendedErrorCode = 0x01;
return TRUE;
}
}
/* If there is a device 1, wait until device 1 allows
register access.*/
if(Ata_p->DevInBus[1] != NONE_DEVICE)
{
/* Select the device */
hal_RegOutByte(Ata_p->HalHndl, ATA_REG_DEVHEAD, DEVHEAD_DEV1);
WAIT400NS;
while(TimeOut >= 0)
{
sn = hal_RegInByte(Ata_p->HalHndl, ATA_REG_SECNUM);
sc = hal_RegInByte(Ata_p->HalHndl, ATA_REG_SECCOUNT);
if ((sn == 0x01) && (sc == 0x01))
break;
TimeOut--;
}
if(TimeOut<0)
{
Ata_p->LastExtendedErrorCode = 0x02;
return TRUE;
}
/* Now wait for device 1 to set BSY=0 */
if(WaitForBit(Ata_p->HalHndl, ATA_REG_STATUS, BSY_BIT_MASK, 0))
{
Ata_p->LastExtendedErrorCode = 0x03;
return TRUE;
}
}
return FALSE;
}
/************************************************************************
Name: ata_ctrl_Probe
Description:
Probes the ATA bus to determine the number of devices attached and
their type (ATA or ATAPI)
Note: could be re-written more cleanly as a loop.
Parameter:
Ata_p Pointer to the ATA control block
************************************************************************/
BOOL ata_ctrl_Probe(ata_ControlBlock_t *Ata_p)
{
BOOL error = FALSE;
DU8 sc, sn;
#if !defined(BAD_DISK_NO_SIG_CHECK_ATA)
DU8 cl, ch, st, dh;
#endif
Ata_p->DevInBus[0] = NONE_DEVICE;
Ata_p->DevInBus[1] = NONE_DEVICE;
/* Soft reset, so the drives will load signature values (section
* 9.12 of ATA-5 spec).
*/
if (hal_SoftReset(Ata_p->HalHndl) == TRUE)
{
#if defined(ATAPI_DEBUG)
STTBX_Print(("ata_ctrl_Probe(): hal_SoftReset failed!\n"));
#endif
return TRUE;
}
/* RESET DONE. This causes device 0 be selected. */
sc = hal_RegInByte(Ata_p->HalHndl, ATA_REG_SECCOUNT);
sn = hal_RegInByte(Ata_p->HalHndl, ATA_REG_SECNUM);
#if defined(ATAPI_DEBUG)
if (TRUE == ATAPI_Verbose)
{
STTBX_Print(("ata_ctrl_Probe(): sc 0x%02x sn 0x%02x\n", sc, sn));
}
#endif
/* These should be 0x01 0x01 for both ATA and ATAPI, so they're a
* useful sanity check to see if any device is there at all.
*/
if ((sc == 0x01) && (sn == 0x01))
{
#if defined(BAD_DISK_NO_SIG_CHECK_ATA)
Ata_p->DevInBus[0] = ATA_DEVICE;
#else
/* Now we know there's *something* there, but not what */
Ata_p->DevInBus[0] = UNKNOWN_DEVICE;
ch = hal_RegInByte(Ata_p->HalHndl, ATA_REG_CYLHIGH);
cl = hal_RegInByte(Ata_p->HalHndl, ATA_REG_CYLLOW);
dh = hal_RegInByte(Ata_p->HalHndl, ATA_REG_DEVHEAD);
st = hal_RegInByte(Ata_p->HalHndl, ATA_REG_STATUS);
#if defined(ATAPI_DEBUG)
STTBX_Print(("Drive status: 0x%02x\n", st));
STTBX_Print(("Error register: 0x%02x\n",
hal_RegInByte(Ata_p->HalHndl, ATA_REG_ERROR)));
#endif
if ((cl == 0x14) && (ch == 0xeb))
Ata_p->DevInBus[0] = ATAPI_DEVICE;
else if ((cl == 0x00) && (ch == 0x00) && ((dh & 0x5F) == 0x00)) /* Modif for WD drives */
Ata_p->DevInBus[0] = ATA_DEVICE;
#endif
#if !defined(BAD_DISK_NO_SIG_CHECK_ATA) && defined(ATAPI_DEBUG)
if (TRUE == ATAPI_Verbose)
{
STTBX_Print(("ata_ctrl_Probe(): ch 0x%02x cl 0x%02x dh 0x%02x\n",
ch, cl, dh));
}
#endif
}
/*Now for the device 1*/
hal_RegOutByte(Ata_p->HalHndl, ATA_REG_DEVHEAD, DEVHEAD_DEV1);
WAIT400NS;
sc = hal_RegInByte(Ata_p->HalHndl, ATA_REG_SECCOUNT);
sn = hal_RegInByte(Ata_p->HalHndl, ATA_REG_SECNUM);
#if defined(ATAPI_DEBUG)
if (TRUE == ATAPI_Verbose)
{
STTBX_Print(("ata_ctrl_Probe(): sc 0x%02x sn 0x%02x\n", sc, sn));
}
#endif
if ((sc == 0x01) && (sn == 0x01))
{
#if defined(BAD_DISK_NO_SIG_CHECK_ATA)
Ata_p->DevInBus[1] = ATA_DEVICE;
#else
/* Now we know there's *something* there, but not what */
Ata_p->DevInBus[1] = UNKNOWN_DEVICE;
cl = hal_RegInByte(Ata_p->HalHndl, ATA_REG_CYLHIGH);
ch = hal_RegInByte(Ata_p->HalHndl, ATA_REG_CYLLOW);
dh = hal_RegInByte(Ata_p->HalHndl, ATA_REG_DEVHEAD);
st = hal_RegInByte(Ata_p->HalHndl, ATA_REG_STATUS);
#if defined(ATAPI_DEBUG)
STTBX_Print(("Drive status: 0x%02x\n", st));
STTBX_Print(("Error register: 0x%02x\n",
hal_RegInByte(Ata_p->HalHndl, ATA_REG_ERROR)));
#endif
if ((cl == 0x14) && (ch == 0xeb))
Ata_p->DevInBus[1] = ATAPI_DEVICE;
else if ((cl == 0x00) && (ch == 0x00) && ((dh & 0x5F) == 0x10))
{
/* Added to solve the problem of Device 0 repsonding for Device 1 if not present*/
if(st == 0x50)
Ata_p->DevInBus[1] = ATA_DEVICE;
}
#endif
#if !defined(BAD_DISK_NO_SIG_CHECK_ATA) && defined(ATAPI_DEBUG)
if (TRUE == ATAPI_Verbose)
{
STTBX_Print(("ata_ctrl_Probe(): ch 0x%02x cl 0x%02x dh 0x%02x\n",
ch, cl, dh));
}
#endif
}
#if defined(ATAPI_DEBUG)
if (TRUE == ATAPI_Verbose)
{
STTBX_Print(("ata_ctrl_Probe(): returning %i\n", error));
}
#endif
return error;
}
/*******************************************************************************
Name : TSMUX_InitPTI_5517_for_STEM7020
Description : Initialize the STTSMUX driver. Only necessary when using STEM
board (db573) because of injection problem with db499 STEM card.
Parameters : None
Assumptions :
Limitations :
Returns : TRUE if success, FALSE otherwise
*******************************************************************************/
static BOOL TSMUX_InitPTI_5517_for_STEM7020(void)
{
ST_ErrorCode_t ErrorCode;
STTSMUX_InitParams_t TSMUXInitParams;
STTSMUX_OpenParams_t TSMUXOpenParams;
ST_ClockInfo_t SysClockInfo;
BOOL RetOk;
RetOk = TRUE;
TSMUXInitParams.DeviceType = CLTSMUX_DEVICE_TYPE;
TSMUXInitParams.DriverPartition_p = DriverPartition_p;
TSMUXInitParams.BaseAddress_p = (U32*)CLTSMUX_BASE_ADDRESS;
ST_GetClockInfo(&SysClockInfo);
TSMUXInitParams.ClockFrequency = SysClockInfo.STBus;
TSMUXInitParams.MaxHandles = 1;
ErrorCode = STTSMUX_Init(STTSMUX_DEVICE_NAME,&TSMUXInitParams);
if(ErrorCode != ST_NO_ERROR)
{
RetOk = FALSE;
STTBX_Print(("STTSMUX_Init(): Failed. Err = 0x%x\n", ErrorCode));
}
else
{
/* Open tsmux */
ErrorCode = STTSMUX_Open(STTSMUX_DEVICE_NAME,&TSMUXOpenParams,&TSMUXHandle);
if(ErrorCode != ST_NO_ERROR)
{
STTBX_Print(("STTSMUX_Open(): Failed. Err = 0x%x\n", ErrorCode));
}
else
{
/* Setup TSIN1 for stream */
ErrorCode = STTSMUX_SetTSMode(TSMUXHandle, STTSMUX_TSIN_1, STTSMUX_TSMODE_PARALLEL);
if(ErrorCode != ST_NO_ERROR)
{
STTBX_Print(("STTSMUX_SetTSMode(): Failed. Error %x\n", ErrorCode));
}
else
{
/* Setup sync mode */
ErrorCode = STTSMUX_SetSyncMode(TSMUXHandle, STTSMUX_TSIN_1, STTSMUX_SYNCMODE_SYNCHRONOUS);
if(ErrorCode != ST_NO_ERROR)
{
STTBX_Print(("STTSMUX_SetSyncMode(): Failed. Error %x\n", ErrorCode));
}
else
{
/* Connect TSIN to PTI */
ErrorCode = STTSMUX_Connect(TSMUXHandle,STTSMUX_TSIN_1, STTSMUX_PTI_A);
if(ErrorCode != ST_NO_ERROR)
{
STTBX_Print(("STTSMUX_Connect(%d,%d): Failed. Error 0x%x\n",ErrorCode,
STTSMUX_TSIN_1, STTSMUX_PTI_A));
}
}
}
}
if(ErrorCode != ST_NO_ERROR)
{
RetOk = FALSE;
STTBX_Print(("TSMUX_Init() failed !! Error = %d", ErrorCode));
}
else
{
STTBX_Print(("STTSMUX initialized using TSIN1 on PTI A,\trevision=%-21.21s\n", STTSMUX_GetRevision()));
}
}
return (RetOk);
} /* End of TSMUX_InitPTI_5517_for_STEM7020() function. */
/*******************************************************************************
Name : TSMUX_InitPTI_5514
Description : Initialize the TSMUX driver
Parameters : None
Assumptions :
Limitations :
Returns : TRUE if success, FALSE otherwise
*******************************************************************************/
static BOOL TSMUX_InitPTI_5514(void)
{
BOOL RetOk;
ST_ErrorCode_t ErrCode;
STTSMUX_InitParams_t TSMUXInitParams;
STTSMUX_OpenParams_t TSMUXOpenParams;
ST_ClockInfo_t SysClockInfo;
STTSMUX_Object_t Source;
STTSMUX_Object_t Destination;
STTSMUX_SWTSInterface_t Interface;
RetOk=TRUE;
ErrCode = ST_NO_ERROR;
ST_GetClockInfo(&SysClockInfo);
TSMUXInitParams.DeviceType = CLTSMUX_DEVICE_TYPE
TSMUXInitParams.DriverPartition_p = DriverPartition_p;
TSMUXInitParams.BaseAddress_p = (U32*)CLTSMUX_BASE_ADDRESS;
TSMUXInitParams.ClockFrequency = SysClockInfo.STBus;
TSMUXInitParams.MaxHandles = 1;
/* Horrible patch to handle hidden MB314 register setting */
/* This activate the STEM (board DB499) by default */
#if defined(mb290)
/* Setting : 0x1=enabled, 0x0=disabled */
*((volatile unsigned char *) 0x7e0c0000) = 0x1;
#elif defined(mb314)
/* Setting : 0x0=enabled, 0x1=disabled */
*((volatile unsigned char *) 0x7e0c0000) = 0x0;
#else
#error Not defined board for injection
#endif /*mb290 */
ErrCode = STTSMUX_Init(STTSMUX_DEVICE_NAME, &TSMUXInitParams);
if(ErrCode != ST_NO_ERROR)
{
STTBX_Print(("STTSMUX_Init(): Failed. Err = 0x%x\n", ErrCode));
}
else
{
memset((void *)&TSMUXOpenParams, 0, sizeof(STTSMUX_OpenParams_t));
ErrCode = STTSMUX_Open(STTSMUX_DEVICE_NAME, &TSMUXOpenParams, &TSMUXHandle);
if(ErrCode != ST_NO_ERROR)
{
STTBX_Print(("STTSMUX_Open(): Failed. Err = 0x%x\n", ErrCode));
}
else
{
ErrCode = STTSMUX_SetTSMode(TSMUXHandle, STTSMUX_TSIN_0, STTSMUX_TSMODE_SERIAL);
if (ErrCode == ST_NO_ERROR)
ErrCode = STTSMUX_SetTSMode(TSMUXHandle, STTSMUX_TSIN_1, STTSMUX_TSMODE_PARALLEL);
if (ErrCode == ST_NO_ERROR)
ErrCode = STTSMUX_SetTSMode(TSMUXHandle, STTSMUX_TSIN_2, STTSMUX_TSMODE_PARALLEL);
if (ErrCode == ST_NO_ERROR)
ErrCode = STTSMUX_SetSyncMode(TSMUXHandle, STTSMUX_TSIN_0, STTSMUX_SYNCMODE_SYNCHRONOUS);
if (ErrCode == ST_NO_ERROR)
ErrCode = STTSMUX_SetSyncMode(TSMUXHandle, STTSMUX_TSIN_1, STTSMUX_SYNCMODE_SYNCHRONOUS);
if (ErrCode == ST_NO_ERROR)
ErrCode = STTSMUX_SetSyncMode(TSMUXHandle, STTSMUX_TSIN_2, STTSMUX_SYNCMODE_SYNCHRONOUS);
if (ErrCode == ST_NO_ERROR)
ErrCode = STTSMUX_GetSWTSInterface(TSMUXHandle, STTSMUX_SWTS_0, &Interface);
if (ErrCode != ST_NO_ERROR)
{
STTBX_Print(("STTSMUX_SetSyncMode(): Failed. Error 0x%x\n", ErrCode));
}
if (ErrCode == ST_NO_ERROR)
{
ErrCode = STTSMUX_SetStreamRate(TSMUXHandle, STTSMUX_SWTS_0, 150 * 1000000 /* Interface.MaxStreamRate */);
if (ErrCode != ST_NO_ERROR)
{
STTBX_Print(("STTSMUX_SetStreamRate(): Failed. Error %d\n", ErrCode));
}
}
/* TSIN 2 input goes to PTI_A, PTI_B & PTI_C */
if (ErrCode == ST_NO_ERROR)
{
Source = STTSMUX_TSIN_2;
for(Destination=STTSMUX_PTI_A; Destination<STTSMUX_PTI_C; Destination++)
{
ErrCode = STTSMUX_Connect(TSMUXHandle, Source, Destination);
if( ErrCode != ST_NO_ERROR)
{
STTBX_Print(("STTSMUX_Connect(%d,%d): Failed. Error 0x%x\n",ErrCode,
Source, Destination));
}
}
}
}
}
if(ErrCode != ST_NO_ERROR)
{
RetOk = FALSE;
STTBX_Print(("TSMUX_Init() failed !! Error = %d", ErrCode));
}
else
{
STTBX_Print(("STTSMUX initialized,\trevision=%-21.21s\n", STTSMUX_GetRevision()));
}
return (RetOk);
} /* end of TSMUX_InitPTI_5514() */
/*
*********************************************************************************************************
* test1_1
*********************************************************************************************************
*/
unsigned char test1_3(void) {
unsigned char exit_err=0;
STTBX_Print(("\nTEST 1.3 Started...\n"));
STTBX_Print((TEST1_4_STRING));
STTBX_Print(("\n 1.3.1 Creating task T1 Pri=%d...",TASK_T1_PRIORITY));
exit_err = print_debug_task_create(OSTaskCreate(test1_3_T1, (void *)&test1_3_T1Stk, &test1_3_T1Stk[TASK_STK_SIZE - 1], TASK_T1_PRIORITY),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.2 Creating task T2 Pri=%d...",TASK_T1_PRIORITY));
exit_err = print_debug_task_create(OSTaskCreate(test1_3_T1, (void *)&test1_3_T1Stk, &test1_3_T1Stk[TASK_STK_SIZE - 1], TASK_T1_PRIORITY),OS_PRIO_EXIST);
if(exit_err)
return(exit_err);
#if defined(COMPILE_FOR_CORE)
STTBX_Print(("\n 1.3.3 Creating task T2 Pri=%d...",255));
exit_err = print_debug_task_create(OSTaskCreate(test1_3_T1, (void *)&test1_3_T1Stk, &test1_3_T1Stk[TASK_STK_SIZE - 1], 255),OS_PRIO_EXIST);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.4 Creating task T2 Pri=%d...",254));
exit_err = print_debug_task_create(OSTaskCreate(test1_3_T1, (void *)&test1_3_T1Stk, &test1_3_T1Stk[TASK_STK_SIZE - 1], 254),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.5 Deleting task Pri=%d...",254));
exit_err = print_debug_task_delete(OSTaskDel(254),OS_NO_ERR);
if(exit_err)
return(exit_err);
#else
STTBX_Print(("\n 1.3.3 Creating task T2 Pri=%d...",63));
exit_err = print_debug_task_create(OSTaskCreate(test1_3_T1, (void *)&test1_3_T1Stk, &test1_3_T1Stk[TASK_STK_SIZE - 1], 63),OS_PRIO_EXIST/*OS_PRIO_INVALID*/);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.4 Creating task T2 Pri=%d...",62));
exit_err = print_debug_task_create(OSTaskCreate(test1_3_T1, (void *)&test1_3_T1Stk, &test1_3_T1Stk[TASK_STK_SIZE - 1], 62),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.5 Deleting task Pri=%d...",62));
exit_err = print_debug_task_delete(OSTaskDel(62),OS_NO_ERR);
if(exit_err)
return(exit_err);
#endif
STTBX_Print(("\n 1.3.6 Deleting task Pri=%d...",20));
exit_err = print_debug_task_delete(OSTaskDel(20),OS_TASK_DEL_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.7 Deleting task Pri=%d...",62));
exit_err = print_debug_task_delete(OSTaskDel(62),OS_TASK_DEL_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.8 Deleting task T1 Pri=%d...",TASK_T1_PRIORITY));
exit_err = print_debug_task_delete(OSTaskDel(TASK_T1_PRIORITY),OS_NO_ERR);
if(exit_err)
return(exit_err);
return(FALSE);
}
void StartSPDIFPlayerIP(SPDIFPlayerControl_t * SPDIFPlayerControl_p)
{
U32 delay, control, Addr1;
U32 AudioConfigBaseAddr = SPDIFPlayerControl_p->BaseAddress.SPDIFPlayerBaseAddr;
switch(SPDIFPlayerControl_p->spdifPlayerIdentifier)
{
case SPDIF_PLAYER_0:
STSYS_WriteRegDev32LE(AudioConfigBaseAddr+SPDIF_SOFTRESET, 1);
delay = 10;
AUD_TaskDelayMs(delay);
STSYS_WriteRegDev32LE(AudioConfigBaseAddr+SPDIF_SOFTRESET, 0);
// Set the mode in the control register
control = SPDIFPlayerControl_p->SPDIFMode;
control |= (U32)(SPDIFPlayer_ConvertFsMultiplierToClkDivider(SPDIFPlayerControl_p->SPDIFPlayerOutParams.SPDIFPlayerFrequencyMultiplier)<<5);
if (SPDIFPlayerControl_p->CompressedDataAlignment == BE)
{
control |= (U32)((1)<<13);
}
STSYS_WriteSpdifPlayerReg32(SPDIF_CTRL, control);
switch (SPDIFPlayerControl_p->SPDIFMode)
{
case STAUD_DIGITAL_MODE_NONCOMPRESSED:
STSYS_WriteRegDev32LE(AudioConfigBaseAddr+SPDIF_CL1, CalculateSPDIFChannelStatus0(SPDIFPlayerControl_p));
STSYS_WriteRegDev32LE(AudioConfigBaseAddr+SPDIF_CR1, CalculateSPDIFChannelStatus0(SPDIFPlayerControl_p));
// Validity 0
STSYS_WriteRegDev32LE(AudioConfigBaseAddr+SPDIF_CL2_CR2_U_V, (CalculateSPDIFChannelStatus1(SPDIFPlayerControl_p)<<8) | CalculateSPDIFChannelStatus1(SPDIFPlayerControl_p));
Addr1 = SPDIFPlayerControl_p->BaseAddress.SPDIFFDMAAdditionalDataRegionBaseAddr + 0x28;
// Write precision mask register to FDMA additional data region
//STSYS_WriteRegDev32LE(Addr1, 0xFFFFFF00);
STFDMA_SetAddDataRegionParameter(SPDIFPlayerControl_p->FDMABlock, SPDIF_ADDITIONAL_DATA_REGION_3, SPDIF_DATA_PRECISION_MASK, 0xFFFFFF00);
STFDMA_SetAddDataRegionParameter(SPDIFPlayerControl_p->FDMABlock, SPDIF_ADDITIONAL_DATA_REGION_3, SPDIF_FRAMES_TO_GO, 0);
STFDMA_SetAddDataRegionParameter(SPDIFPlayerControl_p->FDMABlock, SPDIF_ADDITIONAL_DATA_REGION_3, SPDIF_FRAME_COUNT, 0);
break;
case STAUD_DIGITAL_MODE_COMPRESSED:
Addr1 = SPDIFPlayerControl_p->BaseAddress.SPDIFFDMAAdditionalDataRegionBaseAddr + 0x24;
// Write compressed mode reset to FDMA additional data region
//STSYS_WriteRegDev32LE(Addr1, 0);
STFDMA_SetAddDataRegionParameter(SPDIFPlayerControl_p->FDMABlock, SPDIF_ADDITIONAL_DATA_REGION_3, SPDIF_FRAMES_TO_GO, 0);
STFDMA_SetAddDataRegionParameter(SPDIFPlayerControl_p->FDMABlock, SPDIF_ADDITIONAL_DATA_REGION_3, SPDIF_FRAME_COUNT, 0);
STSYS_WriteRegDev32LE(AudioConfigBaseAddr + SPDIF_CL1, CalculateSPDIFChannelStatus0(SPDIFPlayerControl_p));
STSYS_WriteRegDev32LE(AudioConfigBaseAddr + SPDIF_CR1, CalculateSPDIFChannelStatus0(SPDIFPlayerControl_p));
// Validity 1
STSYS_WriteRegDev32LE(AudioConfigBaseAddr + SPDIF_CL2_CR2_U_V, 0x000C0000 | (CalculateSPDIFChannelStatus1(SPDIFPlayerControl_p)<<8) | (CalculateSPDIFChannelStatus1(SPDIFPlayerControl_p)));
STSYS_WriteRegDev32LE(AudioConfigBaseAddr + SPDIF_PA_PB, 0xF8724E1F);
STSYS_WriteRegDev32LE(AudioConfigBaseAddr + SPDIF_PC_PD, 0x00013000);
// Generate 1 PAUSE burst of 192 SPDIF frames
STSYS_WriteRegDev32LE(AudioConfigBaseAddr + SPDIF_PAUSE_LAT, 0x00010000);
STSYS_WriteRegDev32LE(AudioConfigBaseAddr + SPDIF_BURST_LEN, 0x06000600);
break;
default:
break;
}
//to be done
STSYS_WriteRegDev32LE(0xB9210200, 0xF);
break;
default:
STTBX_Print(("Unidentified SPDIF player identifier\n"));
break;
}
}
/*-----------------------------------------------------------------------------
* Function : GXOBJ_ConvertPalette
*
* Input : *pars_p, *result_sym_p
* Output :
* Return : TRUE if error, FALSE if success
* --------------------------------------------------------------------------*/
static BOOL GXOBJ_ConvertPalette (parse_t *pars_p, char *result_sym_p)
{
BOOL RetErr;
STGXOBJ_ColorSpaceConversionMode_t ConvMode;
ST_ErrorCode_t ErrCode;
S32 Lvar;
UNUSED_PARAMETER(result_sym_p);
ConvMode = 0;
GXOBJ_Msg[0]='\0';
RetErr = FALSE;
/* get Conversion mode */
if ( RetErr == FALSE )
{
RetErr = STTST_GetInteger( pars_p, 0, &Lvar);
if ( RetErr == TRUE )
{
tag_current_line( pars_p, "expected Conversion mode :" );
tag_current_line( pars_p, "0 : STGXOBJ_ITU_R_BT601");
tag_current_line( pars_p, "1 : STGXOBJ_ITU_R_BT709");
tag_current_line( pars_p, "2 : STGXOBJ_ITU_R_BT470_2_M");
tag_current_line( pars_p, "3 : STGXOBJ_ITU_R_BT470_2_BG");
tag_current_line( pars_p, "4 : STGXOBJ_SMPTE_170M");
tag_current_line( pars_p, "5 : STGXOBJ_SMPTE_240M");
tag_current_line( pars_p, "6 : STGXOBJ_CONVERSION_MODE_UNKNOWN");
}
switch ( Lvar )
{
case 0 :
ConvMode=STGXOBJ_ITU_R_BT601;break;
case 1 :
ConvMode=STGXOBJ_ITU_R_BT709;break;
case 2 :
ConvMode=STGXOBJ_ITU_R_BT470_2_M;break;
case 3 :
ConvMode=STGXOBJ_ITU_R_BT470_2_BG;break;
case 4 :
ConvMode=STGXOBJ_SMPTE_170M;break;
case 5 :
ConvMode=STGXOBJ_SMPTE_240M;break;
case 6 :
ConvMode=STGXOBJ_CONVERSION_MODE_UNKNOWN;break;
}
}
if ( RetErr == FALSE )
{
RetErr = TRUE;
ErrCode=STGXOBJ_ConvertPalette( &PaletteGen1, &PaletteGen2, ConvMode);
switch ( ErrCode )
{
case ST_NO_ERROR :
RetErr = FALSE;
break;
case ST_ERROR_FEATURE_NOT_SUPPORTED :
API_ErrorCount++;
strcat( GXOBJ_Msg, "STGXOBJ_ConvertPalette , Feature not supported !\n" );
break;
case ST_ERROR_BAD_PARAMETER :
API_ErrorCount++;
strcat( GXOBJ_Msg, "STGXOBJ_ConvertPalette Bad parameter !\n" );
break;
default:
API_ErrorCount++;
sprintf( GXOBJ_Msg, "%sSTGXOBJ_ConvertPalette unexpected error [%X] !\n",
GXOBJ_Msg, ErrCode );
break;
}
STTBX_Print(( GXOBJ_Msg ));
}
return ( API_EnableError ? RetErr : FALSE );
}
/*-----------------------------------------------------------------------------
* Function : GXOBJ_GetPaletteColor
*
* Input : *pars_p, *result_sym_p
* Output :
* Return : TRUE if error, FALSE if success
* --------------------------------------------------------------------------*/
static BOOL GXOBJ_GetPaletteColor (parse_t *pars_p, char *result_sym_p)
{
BOOL RetErr;
U8 PaletteIndex;
char ColorType[80];
ST_ErrorCode_t ErrCode;
S32 Lvar,Palette;
UNUSED_PARAMETER(result_sym_p);
ColorType[0]='\0';
GXOBJ_Msg[0]='\0';
RetErr = FALSE;
/* get Index */
if ( RetErr == FALSE )
{
RetErr = STTST_GetInteger( pars_p, 0, &Lvar);
if ( RetErr == TRUE )
{
tag_current_line( pars_p, "expected Index" );
}
PaletteIndex = (U8)Lvar;
}
/* get number of palette */
if ( RetErr == FALSE )
{
RetErr = STTST_GetInteger( pars_p, 1, &Lvar);
if ( RetErr == TRUE )
{
tag_current_line( pars_p, "expected Index" );
}
Palette = Lvar;
}
if ( RetErr == FALSE )
{
RetErr = TRUE;
switch ( Palette )
{
case 2 :
ErrCode=STGXOBJ_GetPaletteColor( &PaletteGen2, PaletteIndex, &ColorGen );
break;
default:
ErrCode=STGXOBJ_GetPaletteColor( &PaletteGen1, PaletteIndex, &ColorGen );
break;
}
switch ( ErrCode )
{
case ST_NO_ERROR :
RetErr = FALSE;
switch ( ColorGen.Type )
{
case STGXOBJ_COLOR_TYPE_ARGB8888:
sprintf( ColorType, "%sARGB8888, Alpha:%d, R:%d, G:%d, B:%d",
ColorType, ColorGen.Value.ARGB8888.Alpha, ColorGen.Value.ARGB8888.R,
ColorGen.Value.ARGB8888.G, ColorGen.Value.ARGB8888.B);
break;
case STGXOBJ_COLOR_TYPE_ARGB4444:
sprintf( ColorType, "%sARGB4444, Alpha:%d, R:%d, G:%d, B:%d",
ColorType, ColorGen.Value.ARGB4444.Alpha, ColorGen.Value.ARGB4444.R,
ColorGen.Value.ARGB4444.G, ColorGen.Value.ARGB4444.B);
break;
case STGXOBJ_COLOR_TYPE_UNSIGNED_AYCBCR6888_444:
sprintf( ColorType, "%sUNSIGNED_AYCBCR6888_444, Alpha: %d, Y:%d, Cb:%d, Cr:%d",
ColorType, ColorGen.Value.UnsignedAYCbCr6888_444.Alpha, ColorGen.Value.UnsignedAYCbCr6888_444.Y,
ColorGen.Value.UnsignedAYCbCr6888_444.Cb, ColorGen.Value.UnsignedAYCbCr6888_444.Cr);
break;
case STGXOBJ_COLOR_TYPE_UNSIGNED_AYCBCR8888:
sprintf( ColorType, "%sUNSIGNED_AYCBCR8888, Alpha: %d, Y:%d, Cb:%d, Cr:%d",
ColorType, ColorGen.Value.UnsignedAYCbCr8888.Alpha, ColorGen.Value.UnsignedAYCbCr8888.Y,
ColorGen.Value.UnsignedAYCbCr8888.Cb, ColorGen.Value.UnsignedAYCbCr8888.Cr);
break;
default:
break;
}
strcat( GXOBJ_Msg, "STGXOBJ_GetPaletteColor \n" );
sprintf( GXOBJ_Msg, "%s%s Index:%d\n", GXOBJ_Msg, ColorType, PaletteIndex);
break;
case ST_ERROR_BAD_PARAMETER :
API_ErrorCount++;
strcat( GXOBJ_Msg, "STGXOBJ_GetPaletteColor Bad parameter !\n" );
break;
default:
API_ErrorCount++;
sprintf( GXOBJ_Msg, "%sSTGXOBJ_GetPaletteColor unexpected error [%X] !\n",
GXOBJ_Msg, ErrCode );
break;
}
STTBX_Print(( GXOBJ_Msg ));
}
return ( API_EnableError ? RetErr : FALSE );
}
/*=============================================================================
stlayer_ioctl_cleanup_module
Realease any resources allocaed to this module before the module is
unloaded.
===========================================================================*/
static void __exit stlayer_ioctl_cleanup_module(void)
{
STTBX_Print((KERN_INFO "stlayer_ioctl_cleanup_module: Exiting STLAYER_IOCTL kernel Module\n"));
STLINUX_DeviceUnregister(1, STLAYER_IOCTL_LINUX_DEVICE_NAME, stlayer_ioctl_major, stlayer_ioctl_cdev, stlayer_ioctl_class);
}
