RET_CODE lib_subt_atsc_get_region_pos(struct osd_device *subt_atsc_osd_dev)
{
RET_CODE ret = SUCCESS;
struct OSDRect rect;
ret = OSDDrv_GetRegionPos((HANDLE)subt_atsc_osd_dev,0,&rect);
if(SUCCESS != ret)
{
SDBBP();
}
#ifdef tnntc_debug
libc_printf("Character rect region got: uLeft:%d, uTop:%d, uWidth:%d, uHeight:%d\n",rect.uLeft,rect.uTop,\
rect.uWidth,rect.uHeight);
#endif
return ret;
}
RET_CODE ce_ioctl(pCE_DEVICE pCeDev,UINT32 cmd,UINT32 param)
{
UINT32 i;
UINT32 common_desc[sizeof(ce_io_control)];
UINT32 *desc = (UINT32 *)common_desc;
UINT32 *b = (UINT32 *)ce_io_control;
for(i = 0; i < sizeof(ce_io_control)/sizeof(UINT32); i++)
{
desc[i] = b[i];
}
switch (cmd)
{
case IO_OTP_ROOT_KEY_GET:
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(OTP_PARAM));
break;
case IO_CRYPT_DATA_INPUT:
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(DATA_PARAM));
break;
case IO_CRYPT_PARAM_SET:
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(DES_PARAM));
break;
case IO_CRYPT_SECOND_KEY_CONFIG:
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(CE_KEY_PARAM));
break;
case IO_SECOND_KEY_GENERATE:
desc = NULL ;
break;
case IO_CRYPT_DEBUG_GET_KEY:
DESC_OUTPUT_STRU_SET_SIZE(common_desc, 0, sizeof(CE_DEBUG_KEY_INFO));
break;
case IO_CRYPT_POS_IS_OCCUPY:
{
DESC_OUTPUT_STRU_SET_SIZE(common_desc, 0, sizeof(CE_POS_STS_PARAM));
}
break;
case IO_CRYPT_POS_SET_USED:
{
desc=NULL;
}
break;
case IO_CRYPT_POS_SET_IDLE:
{
desc=NULL;
}
break;
case IO_CRYPT_FOUND_FREE_POS:
{
DESC_OUTPUT_STRU_SET_SIZE(common_desc, 0, sizeof(CE_FOUND_FREE_POS_PARAM));
}
break;
case IO_DECRYPT_PVR_USER_KEY:
{
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(CE_PVR_KEY_PARAM));
}
break;
default:
SDBBP();
break;
}
jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(3)|FUNC_CE_IOCTL, desc);
}
RET_CODE OSDDrv_RegionWrite2(HANDLE hDev,UINT8 uRegionId,UINT8* pSrcData,UINT16 uSrcWidth,UINT16 uSrcHeight,struct OSDRect* pSrcRect,struct OSDRect* pDestRect)
{
struct osd_device *dev = (struct osd_device *)hDev;
#ifdef GE_SIMULATE_OSD
RET_CODE ret;
ge_gma_region_t region_param;
UINT32 vscr_width = 1920, vscr_height = 1080; // get from subtitle
UINT32 reg_width, reg_height;
GE_SIMU_MUTEX_LOCK();
ret = ge_gma_get_region_info(m_osddrv_ge_dev, GMA_SW_LAYER_ID, uRegionId, ®ion_param);
if (ret != RET_SUCCESS)
{
GE_SIMU_MUTEX_UNLOCK();
return ret;
}
if (uSrcWidth > 1280)
{
vscr_width = 1920;
vscr_height = 1080;
}
else if (uSrcWidth > 720)
{
vscr_width = 1280;
vscr_height = 720;
}
else
{
vscr_width = 720;
vscr_height = 576;
}
reg_width = region_param.region_w;
reg_height = region_param.region_h;
if (vscr_width > reg_width || vscr_height > reg_height)
{
region_param.region_x = 0;
region_param.region_y = 0;
region_param.region_w = vscr_width;
region_param.region_h = vscr_height;
region_param.bitmap_x = 0;
region_param.bitmap_y = 0;
region_param.bitmap_w = vscr_width;
region_param.bitmap_h = vscr_height;
region_param.pixel_pitch = vscr_width;
region_param.bitmap_addr = 0;
ret = ge_gma_delete_region(m_osddrv_ge_dev, GMA_SW_LAYER_ID, uRegionId);
if (ret != RET_SUCCESS)
{
SDBBP();
}
ret = ge_gma_create_region(m_osddrv_ge_dev, GMA_SW_LAYER_ID, uRegionId, ®ion_param);
if (ret != RET_SUCCESS)
{
SDBBP();
return ret;
}
ret = ge_gma_scale(m_osddrv_ge_dev, GMA_SW_LAYER_ID, GE_VSCALE_TTX_SUBT, PAL);
if (ret != RET_SUCCESS)
{
SDBBP();
}
}
ge_cmd_list_new(m_osddrv_ge_dev, m_cmd_list, GE_COMPILE_AND_EXECUTE);
ret = ge_gma_set_region_to_cmd_list(m_osddrv_ge_dev, GMA_SW_LAYER_ID, uRegionId, m_cmd_list);
if (ret != RET_SUCCESS)
{
GE_SIMU_MUTEX_UNLOCK();
return ret;
}
UINT32 byte_pitch = osddrv_get_pitch(OSD_256_COLOR, uSrcWidth);
osal_cache_flush(pSrcData + byte_pitch * pSrcRect->uTop, byte_pitch * pSrcRect->uHeight);
ge_cmd_list_hdl cmd_list = m_cmd_list;
ge_base_addr_t base_addr;
base_addr.color_format = (enum GE_PIXEL_FORMAT)osddrv_color_mode_to_ge(OSD_256_COLOR);
base_addr.base_address = (UINT32)pSrcData;
base_addr.data_decoder = GE_DECODER_DISABLE;
base_addr.pixel_pitch = uSrcWidth;
base_addr.modify_flags = GE_BA_FLAG_ADDR|GE_BA_FLAG_FORMAT|GE_BA_FLAG_PITCH;
UINT32 cmd_hdl = ge_cmd_begin(m_osddrv_ge_dev, cmd_list, GE_DRAW_BITMAP);
ge_set_base_addr(m_osddrv_ge_dev, cmd_hdl, GE_PTN, &base_addr);
ge_set_wh(m_osddrv_ge_dev, cmd_hdl, GE_DST_PTN, pSrcRect->uWidth, pSrcRect->uHeight);
ge_set_xy(m_osddrv_ge_dev, cmd_hdl, GE_DST, pDestRect->uLeft, pDestRect->uTop);
ge_set_xy(m_osddrv_ge_dev, cmd_hdl, GE_PTN, pSrcRect->uLeft, pSrcRect->uTop);
ge_cmd_end(m_osddrv_ge_dev, cmd_hdl);
ge_cmd_list_end(m_osddrv_ge_dev, cmd_list);
GE_SIMU_MUTEX_UNLOCK();
return RET_SUCCESS;
#endif
if (dev == NULL)
return RET_SUCCESS;
/* If device not running, exit */
if ((dev->flags & HLD_DEV_STATS_UP) == 0)
{
return RET_FAILURE;
}
if (dev->region_write2)
{
return dev->region_write2(dev, uRegionId,pSrcData,uSrcWidth,uSrcHeight,pSrcRect,pDestRect);
}
return !RET_SUCCESS;
}
UINT32 cmd_stbid(unsigned int argc, unsigned char *argv[])
{
UINT8 i = 0, j = 0, ch = 0xff;
UINT8 *_stbid_flag = "SRI";
INT32 _stbid_flag_len = 3;
UINT8 _serial_data[1024]; // max receive 1KB data
UINT32 timeout = 1000, stbid_offset = STB_HWINFO_SERIAL_OFF, _stbid_crc = 0, _stbid_len = 0, _serial_len = 0, _crc = 0, _crc_pos = 0;
UINT8 *buffer = NULL;
UINT32 nReturn = SUCCESS;
UINT32 nPacketNum = 0;
PACKET packet;
UINT32 tick = osal_get_tick();
UINT8 retry_num = 5, _tr_num = 5;
ID _task_id = g_com_ash_id;
osal_task_dispatch_off();
SendStatusPacket(COMMAND_STATUS_OK, 0);
pan_display(g_pan_dev, "Stb-", 4);
RETRY:
_tr_num = 5;
//transfer data
MEMSET(&packet, 0, sizeof(PACKET));
nReturn = packet_receive(&packet, 5 * 1000);
if(SUCCESS != nReturn)
{
SERIAL_DEBUG("receive packet fail!\n");
retry_num--;
goto RETURN;
}
if(packet.packet_type == PACKET_DATA)
{
_serial_len = packet.packet_length-4;
MEMCPY(_serial_data, packet.data_buffer+4, packet.packet_length-4);
}
else
{
SERIAL_DEBUG("receive %d packet, ignore!\n", packet.packet_type);
retry_num--;
goto RETURN;
}
SERIAL_DEBUG("stbid get data total len %d finish, data: \n", _serial_len);
for(i=0; i<_serial_len; i++)
{
SERIAL_DEBUG("%c", _serial_data[i]);
}
SERIAL_DEBUG("\n");
pan_display(g_pan_dev, "GET", 4);
if((_serial_data[0] != _stbid_flag[0]) || (_serial_data[1] != _stbid_flag[1]) || (_serial_data[2] != _stbid_flag[2])) // received flag tag
{
SERIAL_DEBUG("Error: SRI flag missing!\n");
retry_num--;
goto RETURN;
}
pan_display(g_pan_dev, "FLAG", 4);
_stbid_len = _serial_len-4-8;
if(_stbid_len > STB_HWINFO_MAC_OFF)
{
SERIAL_DEBUG("Error: stbid len %d != [%d], please resend cmd!\n", _stbid_len, STB_HWINFO_MAC_OFF);
retry_num--;
goto RETURN;
}
pan_display(g_pan_dev, "LENG", 4);
// do crc check
_crc_pos = _stbid_flag_len+1+_stbid_len;
_stbid_crc = 0;
for(i=0; i<8; i++)
{
_stbid_crc |= (((_serial_data[_crc_pos+i]>'9') ? (_serial_data[_crc_pos+i]-'A'+10) : (_serial_data[_crc_pos+i]-'0'))<<((7-i)*4));
}
_crc = MG_Table_Driven_CRC(0xFFFFFFFF, _serial_data, _crc_pos);
if(_stbid_crc != _crc)
{
// fail, need re-trans
SERIAL_DEBUG("stbid crc fail, calcu = 0x%x!\n", _crc);
retry_num--;
goto RETURN;
}
pan_display(g_pan_dev, "CRC", 4);
// burn code, enable drive auto-erase
for(i=0; i<(STB_HWINFO_OUI_OFF-STB_HWINFO_MAC_OFF); i++) // init mac
{
ch = _serial_data[STB_HWINFO_MAC_OFF+4-12+i*2];
_serial_data[i+STB_HWINFO_MAC_OFF+4] = (((ch>'9') ? ((ch>='a') ? (ch-'a'+10) : (ch-'A'+10)) : (ch-'0'))<<4);
ch = _serial_data[STB_HWINFO_MAC_OFF+4-12+i*2+1];
_serial_data[i+STB_HWINFO_MAC_OFF+4] |= ((ch>'9') ? ((ch>='a') ? (ch-'a'+10) : (ch-'A'+10)) : (ch-'0'));
}
buffer = MALLOC(64*1024);
if(buffer == NULL)
{
SDBBP();
}
sto_io_control(g_sto_dev, STO_DRIVER_SECTOR_BUFFER, (UINT32)buffer);
sto_io_control(g_sto_dev, STO_DRIVER_SET_FLAG, STO_FLAG_AUTO_ERASE|STO_FLAG_SAVE_REST);
SERIAL_DEBUG("Now burn stbid: ");
for(i=0; i<STB_HWINFO_OUI_OFF; i++)
{
SERIAL_DEBUG("%c", _serial_data[i+_stbid_flag_len+1]);
}
SERIAL_DEBUG("\n");
sto_put_data(g_sto_dev, STB_HWINFO_BASE_ADDR, &_serial_data[_stbid_flag_len+1], STB_HWINFO_OUI_OFF);
if(buffer)
{
FREE(buffer);
buffer = NULL;
sto_io_control(g_sto_dev, STO_DRIVER_SECTOR_BUFFER, 0);
sto_io_control(g_sto_dev, STO_DRIVER_SET_FLAG, 0);
}
if(g_stb_hwinfo != NULL)
{
FREE(g_stb_hwinfo);
g_stb_hwinfo = NULL;
}
pan_display(g_pan_dev, "-tr-", 4);
SERIAL_DEBUG("stbid finish, task %d deleted!\n", g_com_ash_id);
SERIAL_DEBUG("cmd_stbid takes %dms\n", osal_get_tick()-tick);
retry_num = 0;
RESEND:
SendStatusPacket(COMMAND_STATUS_DONE, 0);
MEMSET(&packet, 0, sizeof(PACKET));
osal_task_sleep(100);
nReturn = packet_receive(&packet, 5 * 1000);
if((SUCCESS != nReturn) || (packet.packet_type != PACKET_STATUS))
{
if(_tr_num-- > 0)
{
SERIAL_DEBUG("stbid finish, but signal send fail, now re-send!\n");
goto RESEND;
}
else
{
pan_display(g_pan_dev, "dStb", 4); // done, but notice fail!
}
}
else
{
pan_display(g_pan_dev, "-Stb", 4); // done, all ok!
}
RETURN:
if(retry_num >0)
{
SendStatusPacket(COMMAND_STATUS_ERROR, 0);
goto RETRY;
}
else
{
SERIAL_DEBUG("error, please redo!\n");
api_set_com_check_flag(COM_MONITOR_CHECK_STBID);
}
g_com_ash_id = INVALID_ID;
osal_task_dispatch_on();
osal_task_delete(_task_id);
}
