static INT32 as_select_nim(S_NODE *snode) { INT32 res = SUCCESS; UINT8 nim_id = 0; //0 or 1 if(snode->tuner1_valid == 1) { nim_id = 0; tsi_select(TSI_DMX_0, ts_route_get_nim_tsiid(nim_id)); as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id); } else if(snode->tuner2_valid == 1) { nim_id = 1; tsi_select(TSI_DMX_0, ts_route_get_nim_tsiid(nim_id)); as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id); } else { nim_id = 0; as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id); return res; } return res; }
static void pcm_play_demo(void) { struct deca_feature_config deca_config; struct snd_feature_config snd_config; UINT32 i, j; struct pcm_output pcm; INT32 *p_pcm_sp; g_decv_dev = dev_get_by_id(HLD_DEV_TYPE_DECV, 0); g_deca_dev = dev_get_by_id(HLD_DEV_TYPE_DECA, 0); if (RET_SUCCESS != deca_open(g_deca_dev, 0, 0, 0, 0, 0)) { PRINTF("deca_open failed!!\n"); ASSERT(0); } if (RET_SUCCESS != snd_open(g_snd_dev)) { PRINTF("snd_open failed!!\n"); ASSERT(0); } MEMSET(&pcm, 0, sizeof(struct pcm_output)); pcm.ch_num = 2; pcm.ch_mod = DUAL_CHANNEL; pcm.ch_left = pcm_left_ch; pcm.ch_right = pcm_right_ch; pcm.samp_num = 1152; snd_set_spdif_type(g_snd_dev, SND_OUT_SPDIF_PCM); snd_set_volume(g_snd_dev, SND_SUB_OUT, 100); snd_set_duplicate(g_snd_dev, SND_DUP_NONE); /*assumes PCM data is in address __MM_AUDIO_PATTERN_ADDR, 400*4608 samples, Preset PCM sample rate is 48000, each sample occupy 1 double word (32 bits)*/ while (1) { p_pcm_sp = (INT32 *)__MM_AUDIO_PATTERN_ADDR; for (i = 0;i < PCM_FRM_NUM;i++) { for (j = 0;j < pcm.samp_num;j++) { /*for dual channel mode, 2 channels should have different samples, herel fills the same samples to 2 channels for demo. If only have 1 channel PCM, you can only fill 1 channel (left or right), but you should call snd_set_duplicate(g_snd_dev, SND_DUP_L); or snd_set_duplicate(g_snd_dev, SND_DUP_R); before play.*/ pcm_left_ch[j] = (*p_pcm_sp) << 5; pcm_right_ch[j] = (*p_pcm_sp) << 5; p_pcm_sp++; } libc_demo_pcm_output(&pcm); } } }
struct osd_device* lib_subt_atsc_get_osd_handle(void) { #ifdef SHOW_BY_CPU struct osd_device* ret = (struct osd_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, 1); #else struct osd_device* ret = (struct osd_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, g_subt_config_par.osd_layer_id); #endif //struct osd_device* ret = (struct osd_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, 0); return ret; }
static INT32 pic_gif_draw(gif_file fh, struct OSDRect *rect, BOOL animation) { struct gif_dec_par par; struct ge_device* ge_dev; ge_dev = (struct ge_device *)dev_get_by_id(HLD_DEV_TYPE_GE, 0); if (ge_dev == NULL) { AD_GIF_PRINTF("%s() ge device find failed!\n", __FUNCTION__); return !SUCCESS; } #ifdef DUAL_ENABLE struct osd_device* osd_dev; osd_dev = (struct ge_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, 0); if (osd_dev == NULL) { AD_GIF_PRINTF("%s() osd device find failed!\n", __FUNCTION__); return !SUCCESS; } #endif //if (SUCCESS != ad_gif_file_add(fh)) // return !SUCCESS; //gif_file_init(fh, file, file_len); if (animation) gif_io_ctrl(gif, GIF_IO_CMD_DEC_FIRST_PIC, GIF_FALSE); else gif_io_ctrl(gif, GIF_IO_CMD_DEC_FIRST_PIC, GIF_TRUE); MEMSET((void *)&par, 0, sizeof(struct gif_dec_par)); par.in_par.file = fh; par.in_par.fread_callback = gif_read_data; par.in_par.fseek_callback = gif_seek_data; par.in_par.ftell_callback = gif_tell_pos; par.out_par.dev = (gif_ge_dev)ge_dev; #ifdef DUAL_ENABLE par.out_par.dev = (gif_ge_dev)osd_dev; #endif par.out_par.handle = 0;//(gif_surface_handle)ad_get_ge_surface(AD_DST_SURFACE); par.out_par.region = 0; par.out_par.pos.x = rect->uLeft; par.out_par.pos.y = rect->uTop; par.out_par.area.x = par.out_par.area.y = 0; par.out_par.area.w = rect->uWidth; par.out_par.area.h = rect->uHeight; gif_dec(gif, &par); return SUCCESS; }
void sys_data_set_display_mode(AV_Set *av_set) { enum TVMode eTVAspect; enum DisplayMode e169DisplayMode; if (av_set->tv_ratio == TV_ASPECT_RATIO_169) eTVAspect = TV_16_9; else // if(av_set->tv_ratio==TV_ASPECT_RATIO_43) eTVAspect = TV_4_3; if (av_set->tv_ratio == TV_ASPECT_RATIO_AUTO) e169DisplayMode = NORMAL_SCALE; else if (av_set->display_mode == DISPLAY_MODE_LETTERBOX) e169DisplayMode = LETTERBOX; else if (av_set->display_mode == DISPLAY_MODE_PANSCAN) e169DisplayMode = PANSCAN; else e169DisplayMode = NORMAL_SCALE; //if(eTVAspect == TV_16_9) if (av_set->tv_ratio == TV_ASPECT_RATIO_169) e169DisplayMode = PILLBOX; vpo_aspect_mode((struct vpo_device*)dev_get_by_id(HLD_DEV_TYPE_DIS, 0), \ eTVAspect, e169DisplayMode); }
/********************************************** * enter usb logo test from here by ui * *********************************************/ RET_CODE usb_test_enter() { struct usb_hc_device *hc_dev = (struct usb_hc_device *)dev_get_by_type(NULL,HLD_DEV_TYPE_USB_HOST); if (hc_dev->usbd_flg_id != NULL) { usbd_notify_dynamic_removerd(hc_dev); enable_usb_intf_int(hc_dev->base_addr,0); en_host_int_flag1(hc_dev->base_addr,0); en_host_int_flag2(hc_dev->base_addr,0); en_host_int_flag3(hc_dev->base_addr,0); // hc_dev->bdev_callback(0); // hc_dev->usb_dev->release(hc_dev->usb_dev); // hc_dev->usb_dev = NULL; } if(sys_ic_get_chip_id() == ALI_S3602F) { if(0!=(hc_dev= (pUSBD_BUS)dev_get_by_id(HLD_DEV_TYPE_USB_HOST, 1))) { usbd_notify_dynamic_removerd(hc_dev); enable_usb_intf_int(hc_dev->base_addr,0); en_host_int_flag1(hc_dev->base_addr,0); en_host_int_flag2(hc_dev->base_addr,0); en_host_int_flag3(hc_dev->base_addr,0); } } osal_task_sleep(1); usb_if_test_flag = IF_TEST_ENTER; return RET_SUCCESS ; }
void win_otaset_turn_frntend(void) { UINT8 back_saved; S_NODE s_node; T_NODE t_node; struct nim_device *nim; union ft_xpond xpond; nim = dev_get_by_id(HLD_DEV_TYPE_NIM, 0); t_node.frq = ota_freq; t_node.sym = ota_symb; t_node.pol = ota_pol; t_node.FEC_inner = ota_modulation; MEMCPY(&m_ota_cfg.t_node, &t_node, sizeof(t_node)); m_ota_cfg.pid = ota_pid; win_otaset_get_FreqSymbPid_display(); if(NULL != nim) { MEMSET(&xpond, 0, sizeof(xpond)); xpond.c_info.type = FRONTEND_TYPE_C; xpond.c_info.frq = ota_freq; xpond.c_info.sym = ota_symb; xpond.c_info.modulation = ota_modulation; //frontend_set_nim(nim, NULL, &xpond, 1); frontend_tuning(nim, NULL, &xpond, 1); }
RET_CODE sys_get_host_key(UINT8 *key, UINT32 *len, UINT32 type) { unsigned long addr; CIPLUS_KEY_HDR hdr; UINT8 aes_key[16]; UINT8 *encryped_data; struct sto_device *dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0); libc_printf("%s - type %d\n",__FUNCTION__,type); if(RET_SUCCESS != find_key(CIPLUS_KEY_AES_KEY, &addr, &hdr)) return RET_FAILURE; sto_get_data(dev, aes_key, addr, 16); if(RET_SUCCESS != find_key(type, &addr, &hdr)) return RET_FAILURE; encryped_data = (UINT8 *)MALLOC(hdr.size); //encryped_data = g_ci_tmp_buff; sto_get_data(dev, encryped_data, addr, hdr.size); decrypt_key(encryped_data, key, aes_key, hdr.size); if(len) *len = hdr.size; FREE(encryped_data); return RET_SUCCESS; }
static void pic_gif_init(void) { struct osd_device *osd_layer2_dev; struct gif_cfg init; osd_layer2_dev =(struct osd_device*)dev_get_by_id(HLD_DEV_TYPE_OSD, 0); if (osd_layer2_dev == NULL) { AD_GIF_PRINTF("%s() OSD_layer2 is not be opened!\n", __FUNCTION__); } else { OSDDrv_Close((HANDLE)osd_layer2_dev); AD_GIF_PRINTF("%s() OSD_layer2 is closed!\n", __FUNCTION__); } #ifdef DUAL_ENABLE osd_output_init(); #endif MEMSET((void *)&init,0,sizeof(struct gif_cfg)); init.bit_buf_start = (UINT8 *)((__MM_MP_BUFFER_ADDR +0x800000)& ~(7<<28));//(UINT8 *)(GIF_BIT_BUF& ~(7<<28));// init.bit_buf_size = 0x200000;//GIF_BIT_SIZE;// init.dec_buf_start = (UINT8 *)((__MM_MP_BUFFER_ADDR +0xa00000)& ~(7<<28));//(UINT8 *)(GIF_DEC_BUF& ~(7<<28));// init.dec_buf_size = (__MM_PVR_VOB_BUFFER_LEN -0xa00000 );//GIF_DEC_SIZE;//__MM_PVR_VOB_BUFFER_ADDR init.fread_callback = gif_read_data; init.fseek_callback = gif_seek_data; init.ftell_callback = gif_tell_pos; init.max_width = 800; //400; init.max_height = 600; //300; gif_init(&init); //gif_list_init(); gif = gif_open(); }
static void ca_info_displayinfo(unsigned char CardSlot) { UINT8 i=0; //mcas_card_t stcard_info; #if 1 McasDisplayStrByCardSlot(CardSlot);/*---added by vachel--*/ #else mcas_card_get_info((struct smc_device *)dev_get_by_id(HLD_DEV_TYPE_SMC, 0),&stcard_info); switch(stcard_info.ca_system_id) { case CAS_SYS_CONAX: { Conax_Info_t *pstConax_info; pstConax_info = &conax; ca_info_text_display("Conax card",pstConax_info->iCardNumber,pstConax_info->stParam.MatRat,\ NULL,NULL); } break; case CAS_SYS_SECA: case CAS_SYS_VIACCESS: case CAS_SYS_IRDETO: case CAS_SYS_BISS: break; default://Unknown card break; } #endif }
static INT8 stb_hwinfo_load(STB_HWINFO *hwinfo) { INT8 ret = 0, i; UINT32 check_data; UINT8 data[STB_HWINFO_LEN]; BOOL old2new = FALSE; struct sto_device *sto = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0); if(NULL == sto) { ret = -1; goto RETURN; } MEMSET(data,0,STB_HWINFO_LEN); sto_get_data(sto, data, STB_HWINFO_BASE_ADDR, sizeof(STB_HWINFO)); #if 0 check_data = ((data[0]<<24) |(data[1]<<16) |(data[2]<<8) |(data[3])); if(check_data == 0xffffffff) { ret = -1; goto RETURN; } #endif MEMCPY(hwinfo, data, sizeof(STB_HWINFO)); //libc_printf("load oui = %d, hwmode = %d, hwversion = %d\n", hwinfo->stb_oui, hwinfo->stb_hw_model, hwinfo->stb_hw_version); RETURN: return ret; }
static UINT8 gyca_writemaill_all_to_flash(UINT32 addr, UINT32 mail_head_size) { struct sto_device *flash_dev = NULL; UINT32 mailaddr; mailaddr=addr + mail_head_size; //flash_dev = (struct sto_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_STO); flash_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0); if(NULL == flash_dev) { GYCAS_PRINTF("gyca_writemaill_all_to_flash: dev_get_by_name failed!\n"); return 1; } if(gyca_delmail_all_from_flash(addr)!= 0) return 2; gyca_write_flash_mail_head(addr); gyca_mutex_lock(); if(sizeof(gycamail)*GYCA_EMAIL_MAX_CNT != sto_put_data(flash_dev, mailaddr, flashbuf, sizeof(gycamail)*GYCA_EMAIL_MAX_CNT)) { gyca_mutex_unlock(); GYCAS_PRINTF("%s: sto_put_data failed!\n", __FUNCTION__); return 3; } gyca_mutex_unlock(); return 0; }
static void config_deo_frm_buf(void) { struct vpo_device *gpvpo_sd; Imagedec_frm deo_frm_buf[4]; gpvpo_sd = gpvpo_sd = (struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS, 1); if(NULL != gpvpo_sd) { deo_frm_buf[0].frm_y_addr = (UINT8 *)__MM_FB3_Y_START_ADDR; deo_frm_buf[0].frm_y_len = __MM_FB3_Y_LEN; deo_frm_buf[0].frm_c_addr = (UINT8 *)__MM_FB3_C_START_ADDR; deo_frm_buf[0].frm_c_len = __MM_FB3_C_LEN; deo_frm_buf[0].busy = 0; deo_frm_buf[1].frm_y_addr = (UINT8 *)__MM_FB4_Y_START_ADDR; deo_frm_buf[1].frm_y_len = __MM_FB4_Y_LEN; deo_frm_buf[1].frm_c_addr = (UINT8 *)__MM_FB4_C_START_ADDR; deo_frm_buf[1].frm_c_len = __MM_FB4_C_LEN; deo_frm_buf[1].busy = 0; deo_frm_buf[2].frm_y_addr = (UINT8 *)__MM_FB5_Y_START_ADDR; deo_frm_buf[2].frm_y_len = __MM_FB5_Y_LEN; deo_frm_buf[2].frm_c_addr = (UINT8 *)__MM_FB5_C_START_ADDR; deo_frm_buf[2].frm_c_len = __MM_FB5_C_LEN; deo_frm_buf[2].busy = 0; deo_frm_buf[3].frm_y_addr = (UINT8 *)__MM_FB6_Y_START_ADDR; deo_frm_buf[3].frm_y_len = __MM_FB6_Y_LEN; deo_frm_buf[3].frm_c_addr = (UINT8 *)__MM_FB6_C_START_ADDR; deo_frm_buf[3].frm_c_len = __MM_FB6_C_LEN; deo_frm_buf[3].busy = 0; imagedec_ioctl(1, IMAGEDEC_IO_CMD_CFG_DEO_FRM, (UINT32)(&deo_frm_buf)); } }
static UINT8 gyca_check_flash_mail_head(UINT32 addr) { struct sto_device *flash_dev = NULL; UINT32 mailaddr = addr; UINT8 mail_head[GYCA_MAIL_HEAD_SIZE]; //flash_dev = (struct sto_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_STO); flash_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0); if(NULL == flash_dev) { GYCAS_PRINTF("%s: dev_get_by_name failed!\n", __FUNCTION__); return 1; } //if (SUCCESS != flash_dev->get_data(flash_dev, mail_head, mailaddr, GYCA_MAIL_HEAD_SIZE)) if (GYCA_MAIL_HEAD_SIZE != sto_get_data(flash_dev, mail_head, mailaddr, GYCA_MAIL_HEAD_SIZE)) { GYCAS_PRINTF("%s: sto_get_data failed!\n", __FUNCTION__); return 2; } gyca_mutex_lock(); if(MEMCMP(mail_head,gyca_mail_head, GYCA_MAIL_HEAD_SIZE)) { gyca_mutex_unlock(); return 3; } gyca_mutex_unlock(); return 0; }
static int GetLock(unsigned int argc, unsigned char *argv[]) { INT32 ret; UINT8 lock; if (argc != 1) { SH_PRINTF("Usage: GetLock\n"); return -1; } struct nim_device *nim_dev = dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id); if ((ret = nim_get_lock(nim_dev, &lock)) != SUCCESS) { SH_PRINTF("api_nim_get_lock: operation error! %d\n", ret); return -1; } //LIB_ASH_OC('\r'); //LIB_ASH_OC('\n'); if(!lock) { LIB_ASH_OC('U'); LIB_ASH_OC('N'); } LIB_ASH_OC('L'); LIB_ASH_OC('O'); LIB_ASH_OC('C'); LIB_ASH_OC('K'); LIB_ASH_OC('\r'); LIB_ASH_OC('\n'); }
static void osd_output_init(void) { struct osd_device *osd_dev; UINT32 region_id =0; UINT32 trans_color; struct OSDRect region_rect; struct OSDPara OpenPara; UINT8 *p_pallette; region_rect.uLeft = 0; region_rect.uTop = 0; region_rect.uWidth = 800;//OSD_MAX_WIDTH;//608; region_rect.uHeight = 500;//OSD_MAX_HEIGHT;//430; OpenPara.eMode = OSD_256_COLOR; OpenPara.uGAlpha = 0x0f; OpenPara.uGAlphaEnable = 0; OpenPara.uPalletteSel = 0; osd_dev = (struct osd_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, 0); OSDDrv_Open((HANDLE)osd_dev, &OpenPara); osal_task_sleep(20); //trans_color = OSD_GetTransColor(OpenPara.eMode,FALSE); OSDDrv_IoCtl((HANDLE)osd_dev, OSD_IO_SET_TRANS_COLOR, 0x00); OSDDrv_CreateRegion((HANDLE)osd_dev, region_id, ®ion_rect, NULL); //p_pallette = OSD_GetRscPallette(0x4080 | 0); //OSD_SetPallette(p_pallette,256); //OSDDrv_RegionFill((HANDLE)osd_dev,region_id,®ion_rect,0xff); //OSDDrv_ShowOnOff((HANDLE)osd_dev, TRUE); }
/* * Class: com_dvb_DvbSystemSetting * Method: setAspect * Signature: (I)Z */ JNIEXPORT jboolean JNICALL Java_DvbSystemSetting_setAspect (JNIEnv *env, jclass cls, jint value) { LOGD("%s,%d value = %d ",__FUNCTION__,__LINE__, value); enum TVMode eTVAspect; enum DisplayMode e169DisplayMode; if (value == 2) { eTVAspect = TV_16_9; e169DisplayMode = NORMAL_SCALE; } else if( value == 1 ) { e169DisplayMode = VERTICALCUT; eTVAspect = TV_4_3; } else { e169DisplayMode = PILLBOX; eTVAspect = TV_4_3; } if(vpo_aspect_mode( (struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS, 0), eTVAspect, e169DisplayMode) == 0) return 1; else return 0; }
static int GetPER(unsigned int argc, unsigned char *argv[]) { INT32 ret; UINT32 per; if (argc != 1) { SH_PRINTF("Usage: GetPER\n"); return -1; } struct nim_device *nim_dev = dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id); if ((ret = nim_io_control(nim_dev, NIM_DRIVER_READ_RSUB, &per)) != SUCCESS) { if(ret != ERR_TIME_OUT) { SH_PRINTF("api_nim_get_PER: operation error! %d\n", ret); return -1; } else { per = 0; } } //LIB_ASH_OC('\r'); //LIB_ASH_OC('\n'); IntPrintf(per); LIB_ASH_OC('\r'); LIB_ASH_OC('\n'); }
static int GetBER(unsigned int argc, unsigned char *argv[]) { INT32 ret; UINT32 ber; if (argc != 1) { SH_PRINTF("Usage: GetBER\n"); return -1; } struct nim_device *nim_dev = dev_get_by_id(HLD_DEV_TYPE_NIM, nim_id); if ((ret = nim_get_BER(nim_dev, &ber)) != SUCCESS) { SH_PRINTF("api_nim_get_BER: operation error! %d\n", ret); return -1; } //LIB_ASH_OC('\r'); //LIB_ASH_OC('\n'); IntPrintf(ber); LIB_ASH_OC('\r'); LIB_ASH_OC('\n'); }
void ap_osd_layer2_init() { UINT8 *p_pallette; struct OSDPara tOpenPara; struct OSDRect region1, region2, rc1, rc2; cas_osd_dev = (struct osd_device*)dev_get_by_id(HLD_DEV_TYPE_OSD, 0); tOpenPara.eMode = OSD_256_COLOR; tOpenPara.uGAlphaEnable = 0; tOpenPara.uGAlpha = 0x0F; tOpenPara.uPalletteSel = 0; OSDDrv_Open((HANDLE)cas_osd_dev, &tOpenPara); osal_task_sleep(20); OSDDrv_IoCtl((HANDLE)cas_osd_dev, OSD_IO_SET_TRANS_COLOR, OSD_TRANSPARENT_COLOR); //create region for bottom osd msg region2.uLeft = 0; region2.uTop = 530; region2.uWidth = 720; region2.uHeight = 28; rc2.uLeft = 0; rc2.uTop = 0; rc2.uWidth = region2.uWidth; rc2.uHeight = region2.uHeight; OSDDrv_CreateRegion((HANDLE)cas_osd_dev, OSDMSG_REGION_BTM, ®ion2, NULL); p_pallette = OSD_GetRscPallette(0x4080 | 0); OSDDrv_SetPallette((HANDLE)cas_osd_dev, p_pallette, COLOR_N, OSDDRV_YCBCR); OSDDrv_RegionFill((HANDLE)cas_osd_dev,OSDMSG_REGION_BTM,&rc2,OSD_TRANSPARENT_COLOR); OSDDrv_ShowOnOff((HANDLE)cas_osd_dev,OSDDRV_ON); }
/* * Class: com_dvb_DvbSystemSetting * Method: setBrightness * Signature: (I)Z */ JNIEXPORT jboolean JNICALL Java_DvbSystemSetting_setBrightness (JNIEnv *env, jclass cls, jint value) { LOGD("%s,%d value = %d ",__FUNCTION__,__LINE__, value); struct vpo_io_video_enhance vp_ve_par; struct vpo_device * vp_dev; vp_dev= (struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS, 0); if(value > 100) value = 100; else if(value < 0) value =50; vp_ve_par.grade=value ;//42+2*value; vp_ve_par.changed_flag=VPO_IO_SET_ENHANCE_BRIGHTNESS; if(NULL==vp_dev) { return 0; } else if( vpo_ioctl(vp_dev,VPO_IO_VIDEO_ENHANCE, (UINT32)&vp_ve_par) == 0) { return 1; } else return 0; }
BOOL keyupg_burnflash(UINT32 chunk_id, char *buffer_adr,UINT32 buffer_size) { UINT32 chunk_len,chunk_addr; UINT32 param; struct sto_device *f_dev; UINT32 sector_count=0; api_get_chuck_addlen(chunk_id, &chunk_addr, &chunk_len);//chunk_addr is the real data addr not include header if ((f_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0)) == NULL) { libc_printf("ERROR: Not found Flash device!\n"); return FALSE; } if(chunk_id==HDCPKEY_CHUNK_ID) { //hdcp key,need rewrite bootloader UINT8 *bootloader_sector = NULL; CHUNK_HEADER bloader_chuck_hdr; sto_get_chunk_header(BLOADER_CHUNK_ID,&bloader_chuck_hdr); bootloader_sector = (UINT8 *)MALLOC(sizeof(UINT8)*(bloader_chuck_hdr.offset)); sto_lseek(f_dev, 0x00, STO_LSEEK_SET); sto_read(f_dev, bootloader_sector, bloader_chuck_hdr.offset); /* param = 0x00; param = param << 10; param +=( (SECTOR_SIZE*(bloader_chuck_hdr.offset/SECTOR_SIZE+1)) >> 10); sto_io_control(f_dev, STO_DRIVER_SECTOR_ERASE, param); */ for(sector_count=0;sector_count< ((bloader_chuck_hdr.offset-1)/SECTOR_SIZE+1);sector_count++) { param = 0x00+sector_count*SECTOR_SIZE; param = param << 10; /* Lower 10 bits of LSB is length in K bytes*/ param += SECTOR_SIZE >> 10; sto_io_control(f_dev, STO_DRIVER_SECTOR_ERASE_EXT, param); } sto_lseek(f_dev, 0x00, STO_LSEEK_SET); sto_write(f_dev, bootloader_sector, bloader_chuck_hdr.offset); CHUNK_HEADER hdcp_chuck_hdr; //sto_get_chunk_header(chunk_id,&hdcp_chuck_hdr); hdcp_chuck_hdr.id = data_change_for_sto(chunk_id); hdcp_chuck_hdr.len = data_change_for_sto(buffer_size); hdcp_chuck_hdr.offset = data_change_for_sto(0x200); hdcp_chuck_hdr.crc = data_change_for_sto(0x4e435243); strcpy(hdcp_chuck_hdr.name,"HDCPKey"); strcpy(hdcp_chuck_hdr.version,"Encrypted"); strcpy(hdcp_chuck_hdr.time,"2010.09.01"); sto_write(f_dev,&hdcp_chuck_hdr,sizeof(CHUNK_HEADER)); sto_write(f_dev,buffer_adr, buffer_size); FREE(bootloader_sector); }
//for tuner to select the nim device static INT32 as_select_nim(S_NODE *snode) { INT32 res = SUCCESS; if(2 > lib_nimng_get_lnb_ns()) { #ifdef SYS_TS_INPUT_INTERFACE tsi_select(TSI_DMX_0, SYS_TS_INPUT_INTERFACE); #else tsi_select(TSI_DMX_0, TSI_SPI_0); #endif as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, 0); return res; } if(snode->tuner1_valid == 1) { #ifdef SYS_TS_INPUT_INTERFACE tsi_select(TSI_DMX_0, SYS_TS_INPUT_INTERFACE); #else tsi_select(TSI_DMX_0, TSI_SPI_0); #endif as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, 0); } else if(snode->tuner2_valid == 1) { //modified for 29e tuner2 ts select #if (SYS_CHIP_MODULE == ALI_M3329E) tsi_select(TSI_DMX_0, TSI_SSI_0); #else #ifdef SYS_TS_INPUT_INTERFACE tsi_select(TSI_DMX_0, SYS_TS_INPUT_INTERFACE); #else tsi_select(TSI_DMX_0, TSI_SPI_1); #endif #endif as_info->nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, 1); } else { res = ERR_FAILUE; } return res; }
void lib_subt_atsc_stop_filter(UINT16 dmx_id) { if(SI_SUCCESS != sie_abort_ext((struct dmx_device *)dev_get_by_id(HLD_DEV_TYPE_DMX, dmx_id),NULL, lib_subt_atac_pid,NULL)) { ASSERT(FALSE); } lib_subt_atac_pid = 0x1fff; return; }
INT32 ali_ipanel_exit_mw() { INT32 ret = SUCCESS; UINT32 flag_value = 0; struct dmx_device *dmx = (struct dmx_device*)dev_get_by_id(HLD_DEV_TYPE_DMX, 0); struct vpo_device *vpo_dev = (struct vpo_device*)dev_get_by_id(HLD_DEV_TYPE_DIS, 0); if (ali_ipanel_flag_id == OSAL_INVALID_ID) { IPANEL_PRINTF("%s() ali_ipanel_flag_id invalid! \n", __FUNCTION__); return - 1; } //start dmx, ipanel porting stopped dmx and changed buff mode dmx_io_control(dmx, DMX_SWITCH_TO_UNI_BUF, 0); dmx_io_control(dmx, DMX_CHANGE_THLD, (0 << 16) | (16)); dmx_start(dmx); //open vpo vpo_win_onoff(vpo_dev, TRUE); //open sie /* if (SUCCESS != sie_open(dmx, PSI_MODULE_CONCURRENT_FILTER, NULL, 0)) { IPANEL_PRINTF("%s() sie_open failed! \n", __FUNCTION__); return - 1; }*/ //resum key task key_task_resume(); //suspend ota task ota_task_resume(); //start tdt start_tdt(); sdt_monitor_on(0); //set flag to enable ali application ALI_IPANEL_LEAVE_MUTEX(ALI_IPANEL_FLAG_EXIT_MW); return ret; }
/* * request the NIT from stream * and find given tp's information */ static INT32 find_tp_in_nit(UINT16 network_id, UINT16 ts_id, T_NODE *t_node) { INT32 ret; UINT8 section_num = 0; UINT8 last_section_num; struct dmx_device * dmx_dev; if((dmx_dev = (struct dmx_device *)dev_get_by_id(HLD_DEV_TYPE_DMX, 0)) == NULL) { return MULTIFEED_FAILURE; } struct get_section_param sr_request; struct restrict sr_restrict; MEMSET(&sr_request, 0, sizeof(struct get_section_param)); MEMSET(&sr_restrict, 0, sizeof(struct restrict)); sr_request.buff = multifeed_table_buff; sr_request.buff_len = 1024; sr_request.crc_flag = 1; sr_request.pid = PSI_NIT_PID; sr_request.mask_value = &sr_restrict; sr_request.wai_flg_dly = 6000; sr_restrict.mask_len = 7; sr_restrict.value_num = 1; sr_restrict.mask[0] = 0xff; sr_restrict.mask[1] = 0x80; sr_restrict.mask[6] = 0xff; sr_restrict.value[0][0] = PSI_NIT_TABLE_ID; sr_restrict.value[0][1] = 0x80; section_num =0; do{ sr_restrict.value[0][6] = section_num; if(dmx_req_section(dmx_dev, &sr_request)!= SUCCESS) { return MULTIFEED_FAILURE; } last_section_num = multifeed_table_buff[7]; ret = search_node(multifeed_table_buff, 1024, network_id, ts_id, t_node); if(ret == MULTIFEED_SUCCESS) break; section_num++; }while(section_num<=last_section_num); return ret; }
static void win_tplist_set_capture(S_NODE *s_node, T_NODE *t_node) { INT32 tuning_frq = 0; UINT8 pol; struct nim_device *nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, (s_node->tuner1_valid ? 0 : (s_node->tuner2_valid ? 1 : 0))); SYSTEM_DATA* sys_data = sys_data_get(); switch(s_node->lnb_type) { case LNB_CTRL_22K: if(t_node->frq > KU_LNB_22K_EDGE_FREQUENCY) { api_diseqc_set_22k(nim, 1); tuning_frq = t_node->frq - ((s_node->lnb_high > s_node->lnb_low) ? s_node->lnb_high : s_node->lnb_low); } else { api_diseqc_set_22k(nim, 0); tuning_frq = t_node->frq - ((s_node->lnb_high > s_node->lnb_low) ? s_node->lnb_low : s_node->lnb_high); } break; case LNB_CTRL_POL: pol = ((s_node->pol == 0) || (s_node->pol == 3)) ? (s_node->pol + 1) : (s_node->pol); if(pol == 1) { tuning_frq = s_node->lnb_low - t_node->frq; } else { tuning_frq = s_node->lnb_high - t_node->frq; } break; case LNB_CTRL_UNICABLE: // frontend_set_unicable(nim,antenna,xpond); tuning_frq = sys_data->tuner_lnb_antenna[cur_tuner_idx].unicable_freq;; break; case LNB_CTRL_STD: default: tuning_frq = (((s_node->lnb_low != 0) ? s_node->lnb_low : s_node->lnb_high)) - t_node->frq; break; } if(tuning_frq < 0) { tuning_frq = -tuning_frq; } UINT32 cap_param[3]; cap_param[0] = tuning_frq; cap_param[1] = (UINT32)NULL; cap_param[2] = t_node->sym; libc_printf("win start capture freq = %d\n", tuning_frq); //nim_ioctl_ext(nim, NIM_DRIVER_START_CAPTURE, &cap_param); set_capture_freq(nim, tuning_frq); }
static void init_upgrade_param() { #if (SYS_SDRAM_SIZE != 2) || defined(_MHEG5_ENABLE_) struct sto_device* sto_local_flash_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0); m_UpgradeParam.binary_len = (UINT32)(sto_local_flash_dev->totol_size); #endif if(UPGRADE_MULTI == upgrade_mode) m_UpgradeParam.upgrade_mode = UPGRADE_MODE_MUL_NORMAL; else m_UpgradeParam.upgrade_mode = UPGRADE_MODE_One2One | (UART_DOWNLOAD_SPEED<<8); }
/* Set Background Color of VPO for Single Color Background */ void hde_back_color(UINT8 bY, UINT8 bCb, UINT8 bCr) { struct YCbCrColor color; color.uY = bY; color.uCb = bCb; color.uCr = bCr; vpo_ioctl((struct vpo_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_DIS), VPO_IO_SET_BG_COLOR, (UINT32)(&color)); #ifdef DUAL_VIDEO_OUTPUT vpo_ioctl((struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS, 1), VPO_IO_SET_BG_COLOR, (UINT32)&color); #endif }
static void osdmsg_updatevscr(VSCR* pVscr,UINT8 regionID) { if(pVscr->lpbScr!=NULL) { if(pVscr->updatePending) { cas_osd_dev = (struct osd_device*)dev_get_by_id(HLD_DEV_TYPE_OSD, 0); OSDDrv_RegionWrite((HANDLE)cas_osd_dev, regionID, pVscr,&pVscr->vR); pVscr->updatePending = 0; } } }