/******************************************************************************* 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); }