Beispiel #1
0
RET_CODE ce_aes_key_generate_two_level(pCE_DEVICE pCeDev,pCE_DATA_INFO pCe_data_info_one,
            pCE_DATA_INFO pCe_data_info_two)
{
    UINT32 desc[] = 
    { //desc of pointer para
      2, DESC_STATIC_STRU(0, sizeof(CE_DATA_INFO)),DESC_STATIC_STRU(0, sizeof(CE_DATA_INFO)),
      2, DESC_P_PARA(0, 1, 0),DESC_P_PARA(0, 2, 1),
      //desc of pointer ret
      0,                          
      0,
    };
    jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(3)|FUNC_CE_KEY_GENERATE_TWO_AES, desc);
}
Beispiel #2
0
int ali_ce_generate_single_level_key(pCE_DEVICE pCeDev, pCE_DATA_INFO pCe_data_info)
{
#if !defined(CONFIG_ALI_RPCNG)
	__u32 desc[] = 
	{ //desc of pointer para
		1, DESC_STATIC_STRU(0, sizeof(CE_DATA_INFO)),
		1, DESC_P_PARA(0, 1, 0),
		//desc of pointer ret
		0,                          
		0,
	};
	jump_to_func(NULL, ali_rpc_call, pCeDev, CE_NPARA(2)|FUNC_CE_GENERATE_SINGLE_LEVEL_KEY, desc);
#else
	Param dev;
	Param ce_info;
	CE_DATA_INFO ce_data;

	ali_ce_umemcpy(&ce_data, pCe_data_info, sizeof(ce_data));
	
	RPC_PARAM_UPDATE(dev, PARAM_IN, PARAM_UINT32, sizeof(__u32), &pCeDev);
	RPC_PARAM_UPDATE(ce_info, PARAM_IN, PARAM_Ce_data_info_rpc, sizeof(Ce_data_info_rpc), &ce_data);

	return RpcCallCompletion(RPC_ce_generate_single_level_key,&dev,&ce_info,NULL);
#endif
}
Beispiel #3
0
int ali_ce_key_load(pCE_DEVICE pCeDev, pOTP_PARAM pCe_opt_info)
{
#if !defined(CONFIG_ALI_RPCNG)
	__u32 desc[] = 
	{ //desc of pointer para
		1, DESC_STATIC_STRU(0, sizeof(OTP_PARAM)),
		1, DESC_P_PARA(0, 1, 0),
		//desc of pointer ret
		0,                          
		0,
	};
	jump_to_func(NULL, ali_rpc_call, pCeDev, CE_NPARA(2)|FUNC_CE_LOAD, desc);
#else
	Param dev;
	Param otp_info;
	OTP_PARAM otp_data;
	
	ali_ce_umemcpy(&otp_data, pCe_opt_info, sizeof(otp_data));
	
	RPC_PARAM_UPDATE(dev, PARAM_IN, PARAM_UINT32, sizeof(__u32), &pCeDev);
	RPC_PARAM_UPDATE(otp_info, PARAM_IN, PARAM_Otp_param_rpc, sizeof(Otp_param_rpc), &otp_data);

	return RpcCallCompletion(RPC_ce_key_load,&dev,&otp_info,NULL);
#endif
}
Beispiel #4
0
void snd_output_config(struct snd_device * dev, struct snd_output_cfg * cfg_param)
{
#if 0
    UINT32 desc[] = 
    { //desc of pointer para
      1, DESC_STATIC_STRU(0, sizeof(struct snd_output_cfg)),
      1, DESC_P_PARA(0, 1, 0), 
      //desc of pointer ret
      0,                          
      0,
    };
    jump_to_func(NULL, ali_rpc_call, dev, (HLD_SND_MODULE<<24)|(2<<16)|FUNC_SND_OUTPUT_CONFIG, desc);
#endif

    struct snd_output_cfg_rpc snd_output_cfg_struct;
    struct snd_output_cfg_rpc *temp1 = &snd_output_cfg_struct;

    temp1->mute_num = cfg_param->mute_num;
    temp1->mute_polar = cfg_param->mute_polar;
    temp1->dac_precision = cfg_param->dac_precision;
    temp1->dac_format = cfg_param->dac_format;
    temp1->is_ext_dac = cfg_param->is_ext_dac;
    temp1->reserved8 = cfg_param->reserved8;
    temp1->gpio_mute_circuit = cfg_param->gpio_mute_circuit;
    temp1->ext_mute_mode = cfg_param->ext_mute_mode;
    temp1->enable_hw_accelerator = cfg_param->enable_hw_accelerator;
    temp1->chip_type_config = cfg_param->chip_type_config;
    temp1->reserved = cfg_param->reserved;

    RPC_PARAM_CREATE(p1, PARAM_IN, PARAM_UINT32, 4, &dev);
    RPC_PARAM_CREATE(p2, PARAM_IN, PARAM_Snd_output_cfg_rpc, sizeof(Snd_output_cfg_rpc), temp1);
    
    RpcCallCompletion(RPC_snd_output_config, &p1, &p2, NULL);
}
Beispiel #5
0
int ali_ce_generate_cw_key(__u8 *in_cw_data,__u8 mode,
						__u8 first_pos,__u8 second_pos)
{
#if !defined(CONFIG_ALI_RPCNG)
	__u32 desc[] = 
	{ //desc of pointer para
		1, DESC_STATIC_STRU(0, 16),
		1, DESC_P_PARA(0, 0, 0),
		//desc of pointer ret
		0,
		0,
	};
	jump_to_func(NULL, ali_rpc_call, in_cw_data, CE_NPARA(4)|FUNC_CE_GENERATE_CW_KEY, desc);
#else
	Data_param_rpc data_param;
	Param p1;
	Param p2;
	Param p3;
	Param p4;
	
	ali_ce_umemcpy(&data_param.crypt_data[0], in_cw_data, sizeof(data_param.crypt_data));
	RPC_PARAM_UPDATE(p1, PARAM_IN, PARAM_Data_param_rpc, sizeof(Data_param_rpc), &data_param);
	RPC_PARAM_UPDATE(p2, PARAM_IN, PARAM_UCHAR, sizeof(__u8), &mode);
	RPC_PARAM_UPDATE(p3, PARAM_IN, PARAM_UCHAR, sizeof(__u8), &first_pos);
	RPC_PARAM_UPDATE(p4, PARAM_IN, PARAM_UCHAR, sizeof(__u8), &second_pos);

	return RpcCallCompletion(RPC_ce_generate_cw_key,&p1,&p2,&p3,&p4,NULL);
#endif
}
Beispiel #6
0
RET_CODE ce_key_generate(pCE_DEVICE pCeDev,pCE_DATA_INFO pCe_data_info)
{
    UINT32 desc[] = 
    { //desc of pointer para
      1, DESC_STATIC_STRU(0, sizeof(CE_DATA_INFO)),
      1, DESC_P_PARA(0, 1, 0),
      //desc of pointer ret
      0,                          
      0,
    };
    jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(2)|FUNC_CE_GENERATE, desc);
}
Beispiel #7
0
RET_CODE ce_generate_cw_key(const UINT8 *in_cw_data,UINT8 mode,UINT8 first_pos,UINT8 second_pos)
{
     UINT32 desc[] = 
    { //desc of pointer para
      1, DESC_STATIC_STRU(0, 16),
      1, DESC_P_PARA(0, 0, 0),
      //desc of pointer ret
      0,                          
      0,
    }; 
    jump_to_func(NULL, OS_hld_caller, in_cw_data, CE_NPARA(4)|FUNC_CE_GENERATE_CW_KEY, desc);
}
Beispiel #8
0
RET_CODE ce_key_load(pCE_DEVICE pCeDev,pOTP_PARAM pCe_opt_info)
{
    UINT32 desc[] = 
    { //desc of pointer para
      1, DESC_STATIC_STRU(0, sizeof(OTP_PARAM)),
      1, DESC_P_PARA(0, 1, 0),
      //desc of pointer ret
      0,                          
      0,
    };
    jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(2)|FUNC_CE_LOAD, desc);
}
Beispiel #9
0

void hld_crypto_callee(UINT8 *msg)
{
    
    OS_hld_callee(hld_ce_entry, msg);
}
#endif  /*_HLD_CE_REMOTE*/

#ifdef _HLD_CRYPTO_REMOTE

#define CE_NPARA(x) ((HLD_CRYPTO_MODULE<<24)|(x<<16))

UINT32 ce_io_control[] = 
{ //desc of pointer para
  1, DESC_STATIC_STRU(0, 0),
  1, DESC_P_PARA(0, 2, 0), 
  //desc of pointer ret
  0,                          
  0,
};
RET_CODE ce_open(pCE_DEVICE pCeDev)
{
    jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(1)|FUNC_CE_OPEN, NULL);
}

RET_CODE ce_close(pCE_DEVICE pCeDev)
{
    jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(1)|FUNC_CE_CLOSE, NULL);
}
RET_CODE ce_key_generate(pCE_DEVICE pCeDev,pCE_DATA_INFO pCe_data_info)
Beispiel #10
0
  0,                          
  0,
};

UINT32 desc_vbi_io_ctrl_p_uint32[] = 
{ //desc of pointer para
  1, DESC_OUTPUT_STRU(0, 4),  
  1, DESC_P_PARA(0, 2, 0),
  //desc of pointer ret
  0,                          
  0,
};

UINT32 desc_vbi_io_ctrl_ttx_page_info[] = 
{ //desc of pointer para
  1, DESC_STATIC_STRU(0, sizeof(struct ttx_page_info)),
  1, DESC_P_PARA(0, 2, 0), 
  //desc of pointer ret
  0,                          
  0,
};

/*
 * 	Name		:   vbi_open()   	
 *	Description	:   Open a vbi device
 *	Parameter	:	struct vbi_device *dev		: Device to be openned
 *	Return		:	INT32 						: Return value
 *
 */
INT32 vbi_open(struct vbi_device *dev)
{
Beispiel #11
0
		
    jump_to_func(NULL, ali_rpc_call, dev, (HLD_AVSYNC_MODULE<<24)|(2<<16)|FUNC_AVSYNC_DBG_SET_POLL_OPTION, NULL);
		
}

RET_CODE avsync_dbg_set_polling_interval(struct avsync_device *dev, UINT32 interval_ms)
{
		
    jump_to_func(NULL, ali_rpc_call, dev, (HLD_AVSYNC_MODULE<<24)|(2<<16)|FUNC_AVSYNC_DBG_SET_POLL_INTERVAL, NULL);
		
}


#if 0
UINT32 desc_avsync_attach[] = 
{ //desc of pointer para
  1, DESC_STATIC_STRU(0, sizeof(avsync_cfg_param_t)),
  1, DESC_P_PARA(0, 0, 0), 
  //desc of pointer ret
  0,                          
  0,
};
#endif

RET_CODE avsync_attach(void)
{
    jump_to_func(NULL, ali_rpc_call, null, (LLD_AVSYNC_MODULE<<24)|(1<<16)|FUNC_AVSYNC_ATTACH, NULL/*desc_avsync_attach*/);
}


Beispiel #12
0
#include <rpc_hld/ali_rpc_hld_sdec.h>

//#include "../ali_rpc.h"

#include <ali_rpcng.h>
/*****************************************************************************
*	LLD_SDEC															  		  *
*****************************************************************************/
enum LLD_SDEC_SW_FUNC{
    FUNC_SDEC_M33_ATTACH = 0,   
    FUNC_SDEC_SBUT_DISPLAY_BL_INIT,
};

static UINT32 desc_cfg_param[] = 
{ //desc of pointer para
  1, DESC_STATIC_STRU(0, sizeof(struct sdec_feature_config)), 
  1, DESC_P_PARA(0, 0, 0), 
  //desc of pointer ret
  0,                          
  0,
};

INT32 sdec_m33_attach(struct sdec_feature_config * cfg_param)
{
#if 0
	register RET_CODE ret asm("$2");
	jump_to_func(NULL, ali_rpc_call, cfg_param, (LLD_SDEC_SW_MODULE<<24)|(1<<16)|FUNC_SDEC_M33_ATTACH, desc_cfg_param);
	return ret;
#endif
    Int32 ret;
    RPC_PARAM_CREATE(p1, PARAM_IN, PARAM_Sdec_feature_config_rpc, sizeof(Sdec_feature_config_rpc), cfg_param);
Beispiel #13
0
#include <rpc_hld/ali_rpc_hld_snd.h>

//#include "../ali_rpc.h"

#include <ali_rpcng.h>
static struct snd_callback g_snd_cb;

static void snd_hdmi_cb(UINT32 type, UINT32 uParam)
{
	if(g_snd_cb.phdmi_snd_cb)
		g_snd_cb.phdmi_snd_cb(uParam);
}
#if !defined(CONFIG_ALI_RPCNG)
UINT32 desc_snd_m36_attach[] = 
{ //desc of pointer para
  1, DESC_STATIC_STRU(0, sizeof(struct snd_feature_config)),
  1, DESC_P_PARA(0, 0, 0), 
  //desc of pointer ret
  0,                          
  0,
};
#endif
void snd_m36_attach(struct snd_feature_config * config)
{
    #if 0
    jump_to_func(NULL, ali_rpc_call, config, (LLD_SND_M36_MODULE<<24)|(1<<16)|FUNC_SND_M36_ATTACH, desc_snd_m36_attach);
    #endif
    struct snd_feature_config_rpc snd_feature;
    struct snd_feature_config_rpc *tmp1 = &snd_feature;

    struct snd_output_cfg_rpc snd_output;
Beispiel #14
0
{
    (UINT32)TTXEng_Init,
    (UINT32)TTXEng_Attach,
};

void lib_ttx_callee(UINT8 *msg)
{
    OS_hld_callee(lib_ttx_entry, msg);
}

#endif

#ifdef _LIB_TTX_REMOTE
UINT32 desc_ttx_eng_attach[] = 
{ //desc of pointer para
  1, DESC_STATIC_STRU(0, sizeof(struct ttx_config_par)),
  1, DESC_P_PARA(0, 0, 0), 
  //desc of pointer ret
  0,                          
  0,
};

void TTXEng_Init(void)
{
    jump_to_func(NULL, OS_hld_caller, null, (LIB_TTX_MODULE<<24)|(0<<16)|FUNC_LIB_TTX_INIT, NULL);
}

void  TTXEng_Attach(struct ttx_config_par *pconfig_par)
{
    jump_to_func(NULL, OS_hld_caller, pconfig_par, (LIB_TTX_MODULE<<24)|(1<<16)|FUNC_LIB_TTX_Attach, desc_ttx_eng_attach);
}
Beispiel #15
0
#include <linux/delay.h>
#include <linux/ali_rpc.h>
//#include <linux/ali_video.h>
#include <rpc_hld/ali_rpc_hld_decv.h>

#include "../ali_rpc.h"
static unsigned int m_vdec_XD = 0;//add by phil for XD311
//add by phil for boot-media
void boot_media_start(UINT32 addr, UINT32 len)
{
	 jump_to_func(NULL, ali_rpc_call, addr, (BOOT_MEDIA_MODULE<<24)|(2<<16)|FUNC_BOOT_MEDIA_START, NULL);
}

static UINT32 desc_vdec_m36_attach[] = 
{ //desc of pointer para
	1, DESC_STATIC_STRU(0, sizeof(struct vdec_config_par)),
	1, DESC_P_PARA(0, 0, 0), 
	//desc of pointer ret
	0,                          
	0,
};

void vdec_m36_attach(struct vdec_config_par *pconfig_par)
{
    	jump_to_func(NULL, ali_rpc_call, pconfig_par, (LLD_DECV_M36_MODULE<<24)|(1<<16)|FUNC_VDEC_M36_ATTACH, desc_vdec_m36_attach);
}

RET_CODE vdec_enable_advance_play(struct vdec_device *dev)
{
	
    	jump_to_func(NULL, ali_rpc_call, dev, (LLD_DECV_M36_MODULE<<24)|(1<<16)|FUNC_VDEC_ENABLE_ADVANCE_PLAY, NULL);
Beispiel #16
0
    (UINT32)music_engine_set_eq,
    (UINT32)music_engine_get_song_info,
    (UINT32)music_engine_get_decoder_info,
};

void lib_pe_music_engine_callee(UINT8 *msg)
{
    OS_hld_callee(music_engine_entry, msg);
}

#endif

#ifdef _LIB_PE_MUSIC_ENGINE_REMOTE
static UINT32 desc_me_init[] = 
{ //desc of pointer para
  1, DESC_STATIC_STRU(0, sizeof(struct pe_music_cfg)), 
  1, DESC_P_PARA(0, 0, 0),
  //desc of pointer ret
  0,                          
  0,
};

static UINT32 desc_me_set_eq[] = 
{ //desc of pointer para
  1, DESC_OUTPUT_STRU(0, sizeof(float)),  
  1, DESC_P_PARA(0, 2, 0),
  //desc of pointer ret
  0,                          
  0,
};
Beispiel #17
0
#include <linux/err.h>
#include <linux/device.h>
#include <linux/efi.h>
#include <linux/fb.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/ali_rpc.h>

#include <rpc_hld/ali_rpc_pe.h>

#include "../ali_rpc.h"

static UINT32 desc_ve_init[] = 
{ //desc of pointer para
  1, DESC_STATIC_STRU(0, sizeof(struct pe_video_cfg)), 
  1, DESC_P_PARA(0, 0, 0),
  //desc of pointer ret
  0,                          
  0,
};

static UINT32 desc_ve_set_output[] = 
{ //desc of pointer para
  1, DESC_STATIC_STRU(0, sizeof(struct VDecPIPInfo)), 
  1, DESC_P_PARA(0, 1, 0),
  //desc of pointer ret
  0,                          
  0,
};