Esempio n. 1
0
// main program - initialize, then send to proper function
int main (int argc, char **argv)
{
  CubitStatus status = InitCGMA::initialize_cgma("OCC");
  if (CUBIT_SUCCESS != status) return 1;

  //Do make point.
  status = make_Point();
  if (status == CUBIT_FAILURE) 
     PRINT_INFO("Operation Failed");

  int ret_val = ( CubitMessage::instance()->error_count() );
  if ( ret_val > 0 )
  {
    PRINT_ERROR("Errors found during Mergechk session.\n");
  }
  return ret_val;
  
}
Esempio n. 2
0
File: arm.cpp Progetto: webjb/bbb
int s_arm_t::kick(int speed)
{
	PRINT_INFO("KICK %d\n", speed);
	add_command(1, 0000, 50, 100);
	add_command(2, 0000, 90, 100);
	add_command(0, 1000, 45, 100);

	add_command(0, 3000, 45, speed);
//	add_command(2, 4100, 80, speed);
	add_command(1, 3100, 85, speed);
	
	add_command(2, 5000, 40, 100);

	add_command(2, 7000, 90, 100);
	add_command(1, 7000, 50, 100);
	add_command(0, 8000, 45, 100);
	
	return 0;
}
Esempio n. 3
0
static int put_mod(mod_record_t* mod_record)
{
    int ret = 0;
    unsigned long flags;
    PRINT_INFO("put mod  %s\n", mod_record->name);
    spin_lock_irqsave(&mod_lock, flags);
    if (mod_record->no_share) 
    	ret = _switch_gate(mod_record->type, 0); 
    else {
        mod_record->ref--;
        if(mod_record->ref <= 0) {
            ret = _switch_gate(mod_record->type, 0); 
            mod_record->ref = 0;
            mod_record->flag = 0;
        }
    }
    spin_unlock_irqrestore(&mod_lock, flags);
    return ret;
}
Esempio n. 4
0
long bmd_set_ctx_fileInMem(	GenBuf_t *file_buf,
					char *pass,
					long passlen,
					bmd_crypt_ctx_t **ctx)
{
	PRINT_INFO("LIBBMDPKIINF Setting ctx file from mem\n");

	if( file_buf == NULL )			{	BMD_FOK(BMD_ERR_PARAM1);	}
	if( file_buf->buf == NULL )		{	BMD_FOK(BMD_ERR_PARAM1);	}
	if( ( passlen != 0 ) && ( pass == NULL ) )	{	BMD_FOK(BMD_ERR_PARAM2);	}
	if( (passlen == 0 ) && ( pass != NULL ) )		{	BMD_FOK(BMD_ERR_PARAM3);	}
	if( ctx == NULL )				{	BMD_FOK(BMD_ERR_PARAM4);	}
	if( (*ctx) != NULL )			{	BMD_FOK(BMD_ERR_PARAM4);	}

	BMD_FOK(bmd_create_ctx(ctx,BMD_CTX_SOURCE_FILE,BMD_CTX_TYPE_ASYM));
	BMD_FOK(bmd_parse_p12_fileInMem(file_buf,pass,passlen,&((*ctx)->file->publicKey),&((*ctx)->file->privateKey),&((*ctx)->file->cert)));

	return BMD_OK;
}
Esempio n. 5
0
/* ustawia kontekst z PKCS#11 - laduje biblioteke, inicjalizuje,
   pobiera wszystkie certyfikaty z kart jesli opcja auto_load jest ustawiona (BMD_PKCS11_AUTO_LOAD_CERT)
*/
long bmd_set_ctx_pkcs11	(bmd_crypt_ctx_t **ctx,
				char *pkcs11_library,
				long ctx_type,
				long auto_load,
				BmdCtxPkcs11Option_e ctx_option)
{
	PRINT_INFO("LIBBMDPKIINF Setting ctx pkcs11\n");

	if(ctx==NULL)		{	BMD_FOK(BMD_ERR_PARAM1);	}
	if((*ctx)!=NULL)		{	BMD_FOK(BMD_ERR_PARAM1);	}
	if(pkcs11_library==NULL){	BMD_FOK(BMD_ERR_PARAM2);	}
	if( (auto_load!=BMD_PKCS11_AUTO_LOAD_CERT) && (auto_load!=0) )
	{
		BMD_FOK(BMD_ERR_PARAM4);
	}

	BMD_FOK(bmd_create_ctx(ctx,BMD_CTX_SOURCE_PKCS11,ctx_type));
	BMD_FOK(bmd_pkcs11_init(pkcs11_library,(*ctx)->pkcs11));

	if(auto_load==BMD_PKCS11_AUTO_LOAD_CERT)
	{
		BMD_FOK(bmd_pkcs11_get_all_certs((*ctx)->pkcs11,&((*ctx)->pkcs11->all_certs)));
	}

	// sprawdzenie poprawnosci podanej opji
	// BMD_CTX_PKCS11_OPTION_DEFAULT i BMD_CTX_PKCS11_OPTION_DEDBS wzajemnie sie wykluczaja
	if(ctx_option != BMD_CTX_PKCS11_OPTION_DEFAULT && ctx_option != BMD_CTX_PKCS11_OPTION_DEDBS)
	{
		BMD_FOK(BMD_ERR_PARAM5);
	}
	
	if(ctx_option & BMD_CTX_PKCS11_OPTION_DEFAULT)
	{
		(*ctx)->pkcs11->dontEstimateDecryptBufferSize = 0;
	}
	if(ctx_option & BMD_CTX_PKCS11_OPTION_DEDBS)
	{
		(*ctx)->pkcs11->dontEstimateDecryptBufferSize = 1;
	}
	

	return BMD_OK;
}
Esempio n. 6
0
 double GetXPDF(const kf_code& kf, bool anti) {
   if (m_x>m_xmax) return 0.;
   if (!(m_x>=0.0 && m_x<=1.0)) {
     PRINT_INFO("PDF called with x="<<m_x);
     return 0.;
   }
   int cteqindex;
   switch (kf) {
   case kf_gluon: cteqindex=0;                    break;
   case kf_d:     cteqindex=m_anti*(anti?-2:2);   break;
   case kf_u:     cteqindex=m_anti*(anti?-1:1);   break;
   default:       cteqindex=m_anti*(anti?-kf:kf); break;
   }
   if (!m_calculated[5-cteqindex]) {
     m_f[5-cteqindex]=ct10pdf_(cteqindex,m_x,m_Q)*m_x;
     m_calculated[5-cteqindex]=true;
   }
   return m_rescale*m_f[5-cteqindex];
 }
Esempio n. 7
0
 double GetXPDF(const ATOOLS::Flavour& infl) {
   if (m_x>m_xmax || m_rescale<0.) return 0.;
   if (!(m_x>=0.0 && m_x<=1.0)) {
     PRINT_INFO("PDF called with x="<<m_x);
     return 0.;
   }
   int cteqindex;
   switch (infl.Kfcode()) {
   case kf_gluon: cteqindex=0;                  break;
   case kf_d:     cteqindex=m_anti*int(infl)*2; break;
   case kf_u:     cteqindex=m_anti*int(infl)/2; break;
   default:                cteqindex=m_anti*int(infl);   break;
   }
   if (!m_calculated[5-cteqindex]) {
     m_f[5-cteqindex]=ct10pdf_(cteqindex,m_x,m_Q)*m_x; 
     m_calculated[5-cteqindex]=true;
   }
   return m_rescale*m_f[5-cteqindex];     
 }
Esempio n. 8
0
static void modisk_set_block_shift(struct scst_cmd *cmd, int block_shift)
{
	struct scst_device *dev = cmd->dev;
	int new_block_shift;

	/*
	 * No need for locks here, since *_detach() can not be
	 * called, when there are existing commands.
	 */
	new_block_shift = block_shift ? : MODISK_DEF_BLOCK_SHIFT;
	if (dev->block_shift != new_block_shift) {
		PRINT_INFO("%s: Changed block shift from %d into %d / %d",
			   dev->virt_name, dev->block_shift, block_shift,
			   new_block_shift);
		dev->block_shift = new_block_shift;
		dev->block_size = 1 << dev->block_shift;
	}
	return;
}
Esempio n. 9
0
/**
 *  @brief              sends certain Configuration Packet based on the input WIDs pstrWIDs
 *  using driver config layer
 *
 *  @details
 *  @param[in]  pstrWIDs WIDs to be sent in the configuration packet
 *  @param[in]  u32WIDsCount number of WIDs to be sent in the configuration packet
 *  @param[out]         pu8RxResp The received Packet Response
 *  @param[out]         ps32RxRespLen Length of the received Packet Response
 *  @return     Error code indicating success/failure
 *  @note
 *  @author	mabubakr
 *  @date		1 Mar 2012
 *  @version	1.0
 */
s32 send_config_pkt(u8 mode, struct wid *wids, u32 count, u32 drv)
{
	s32 counter = 0, ret = 0;

	if (mode == GET_CFG) {
		for (counter = 0; counter < count; counter++) {
			PRINT_INFO(CORECONFIG_DBG, "Sending CFG packet [%d][%d]\n", !counter,
				   (counter == count - 1));
			if (!wilc_wlan_cfg_get(!counter,
					       wids[counter].id,
					       (counter == count - 1),
					       drv)) {
				ret = -1;
				printk("[Sendconfigpkt]Get Timed out\n");
				break;
			}
		}
		counter = 0;
		for (counter = 0; counter < count; counter++) {
			wids[counter].size = wilc_wlan_cfg_get_val(
					wids[counter].id,
					wids[counter].val,
					wids[counter].size);

		}
	} else if (mode == SET_CFG) {
		for (counter = 0; counter < count; counter++) {
			PRINT_D(CORECONFIG_DBG, "Sending config SET PACKET WID:%x\n", wids[counter].id);
			if (!wilc_wlan_cfg_set(!counter,
					       wids[counter].id,
					       wids[counter].val,
					       wids[counter].size,
					       (counter == count - 1),
					       drv)) {
				ret = -1;
				printk("[Sendconfigpkt]Set Timed out\n");
				break;
			}
		}
	}

	return ret;
}
Esempio n. 10
0
// main program - initialize, then send to proper function
int main (int argc, char **argv)
{
    // Start up CGM
  CubitStatus status = InitCGMA::initialize_cgma("ACIS");
  if (CUBIT_SUCCESS != status) return 1;

  //Do hollow operation to make thick body.
  status = hollow();
  if (status == CUBIT_FAILURE) 
     PRINT_INFO("Operation Failed");

  int ret_val = ( CubitMessage::instance()->error_count() );
  if ( ret_val > 0 )
  {
    PRINT_ERROR("Errors found during Mergechk session.\n");
  }
  return ret_val;
  
}
Esempio n. 11
0
/*
 * Resume execution after an external function call
 */
int XTIER_inject_resume_module_execution(struct kvm_vcpu *vcpu)
{
	struct timespec begin;

	// Did the function return?
	if(kvm_rip_read(vcpu) == _XTIER_inject.external_function_return_rip)
	{
		// Take time
		// Since the execution is still running we do not use starttime!
		XTIER_inject_begin_time_measurement(&begin);

		PRINT_INFO("External function returned. Execution of the injected module will be resumed!\n");
		PRINT_DEBUG("EIP: 0x%lx, RSP: 0x%lx, CR3: 0x%lx\n", kvm_rip_read(vcpu), kvm_register_read(vcpu, VCPU_REGS_RSP), kvm_read_cr3(vcpu));


		// Make the module accessible again
		XTIER_memory_reallow_access(vcpu);

		// Restore RIP
		kvm_rip_write(vcpu, _XTIER_inject.external_function_return_rip);
		_XTIER_inject.external_function_return_rip = 0;

		// Set HALT Exiting
		XTIER_enable_hlt_exiting();

		// Set Exception Exiting
		XTIER_enable_interrupt_exiting(vcpu);

		// Take time
		XTIER_inject_end_time_measurement(&begin, &_XTIER_performance.total_module_temp_resume_time);

		// Return but do not update RIP
		return 2;
	}
	else
	{
		PRINT_WARNING("External function tried to access the protected memory area @ 0x%lx!\n Malware?\n", kvm_rip_read(vcpu));
		return 0;
	}

	return 0;
}
Esempio n. 12
0
static int get_mod(mod_record_t* mod_record)
{
    int ret = 0;
    unsigned long flags;
    PRINT_INFO("get mod  %s\n", mod_record->name);
    spin_lock_irqsave(&mod_lock, flags);
    if (mod_record->no_share)
    	ret = _switch_gate(mod_record->type, 1);
    else {
        if(mod_record->ref > 0)
            mod_record->ref++;
        else {
            mod_record->ref = 1;
            mod_record->flag = 1;
            ret = _switch_gate(mod_record->type, 1);
        }  
    }
    spin_unlock_irqrestore(&mod_lock, flags);
    return ret;
}
Esempio n. 13
0
static void backlight_power_ctrl(Bool_t status)
{ 
	PRINT_INFO("%s(): bl_status=%s, data_status=%s, bl_level=%u\n", __FUNCTION__, (bl_status ? "ON" : "OFF"), (data_status ? "ON" : "OFF"), bl_level);
	if( status == ON ){
		if ((data_status == OFF) || (bl_status == ON))
			return;
		if (bl_level == 0) {
			bl_status = status;
			return;
		}
		_power_on_backlight();
	}
	else{
		if (bl_status == OFF) 
			return;
		_power_off_backlight();
	}
	bl_status = status;
	printk(KERN_INFO "%s() Power %s\n", __FUNCTION__, (status ? "ON" : "OFF"));
}
void msw_exit(void)
{

	unsigned long 	l_RetCode = C_AMSW_REJ;
	amu_go = FALSE;

        PRINT_INFO("msw_exit\n");

	if (!GlobalRemove)
        {
            board_disable_intrs();		// disable interrupts before disabling the driver

            l_RetCode = AMSW_ANT_requestModemStateChange(C_AMSW_IDLE);
            PRINT_ERROR("Modem going to IDLE\n");
            if	(l_RetCode != C_AMSW_ACK)
                PRINT_ERROR("AMSW_ANT_requestModemStateChange(C_AMSW_IDLE) error!\n", l_RetCode);
        } else {
            g_ModemState = C_AMSW_IDLE;
        }
        AMSW_Modem_SW_Exit();
}
Esempio n. 15
0
// main program - initialize, then send to proper function
int main (int argc, char **argv)
{
  CubitStatus s = InitCGMA::initialize_cgma( ENGINE );
  if (CUBIT_SUCCESS != s) return 1;

  //Do tests.
  int rsl = CreateGeometry();
  if (rsl == 1) 
     PRINT_INFO("Operation Failed");

  int ret_val = ( CubitMessage::instance()->error_count() );
  if ( ret_val != 0 )
  {
    PRINT_ERROR("Errors found during Mergechk session.\n");
  }
  else
    ret_val = 0;

  return ret_val;
  
}
static void sprd_kpled_set_brightness( unsigned long  brightness)
{
	unsigned long brightness_level;
	brightness_level = brightness;

	if(brightness_level > 255)
		brightness_level = 255;
	
#ifdef CONFIG_ARCH_SCX35
	/*brightness steps = 16*/
	brightness_level = brightness_level/16;
	brightness_level = 0;//set brightness_level = 0 for reducing power consumption
#else
	/*brightness steps = 8*/
	brightness_level = brightness_level/32;
#endif
	
	// Set Output Current
	sci_adi_write(KPLED_CTL, ((brightness_level << KPLED_V_SHIFT) & KPLED_V_MSK), KPLED_V_MSK);
	PRINT_INFO("reg:0x%08X set_val:0x%08X  brightness:%ld  brightness_level:%ld(0~15)\n", \
		KPLED_CTL, kpled_read(KPLED_CTL), brightness, brightness_level);
}
Esempio n. 17
0
//=============================================================================
bool CubitInstrumentation::check_token_log()
{
  const char* token_file = getenv("_CUBIT_USAGE_TOKEN_FILE");
  if (token_file)
  {
    if (!tokenUsageStream)
    {
      //const char* token_file = getenv("_CUBIT_USAGE_TOKEN_FILE");
      //if(!token_file)
      //  token_file = "usage_tokens.log";
      tokenUsageStream = new std::ofstream(token_file, std::ofstream::out);
      if (!tokenUsageStream)
      {
        std::string file_name = getenv("_CUBIT_USAGE_TOKEN_DIR");
        file_name += std::tmpnam(NULL);
        file_name += "log";
        tokenUsageStream = new std::ofstream(file_name.c_str(), std::ofstream::out);
        if (!tokenUsageStream)
        {
          PRINT_ERROR("Failed to open token usage file!\n");
          PRINT_INFO("\tNo usage token will be recorded.\n");
          return false;
        }
      }
    }

      // write keywords if valid and write flags set
    if (validKeywords && writeKeywords)
    {
      write_all_words();
      writeKeywords = false;
    }
    return true; 
  }
  else
  {
    return false;
  }
}
Esempio n. 18
0
static int nmi_wlan_parse_info_frame(uint8_t *info, int size)
{
	nmi_mac_cfg_t *pd = (nmi_mac_cfg_t *)&g_mac;
	uint32_t wid, len;
	int type = NMI_CFG_RSP_STATUS;

	wid = info[0] | (info[1] << 8);
#if 0
#ifdef BIG_ENDIAN
	wid = BYTE_SWAP(wid);
#endif
#endif

	len = info[2];
	PRINT_INFO(GENERIC_DBG,"Status Len = %d Id= %d\n",len,wid);
	if ((len == 1) && (wid == WID_STATUS)) {
		pd->mac_status = info[3];
		type = NMI_CFG_RSP_STATUS;
	}

	return type;
}
Esempio n. 19
0
File: app.cpp Progetto: webjb/bbb
int s_app_t::run()
{
//	int64 time_ms;
	while(!this->m_quit)
	{
		if( m_exit == 1)
			break;
	 	switch( m_run_state )
		{
	 	}
		usleep(1000*50);
	}
	m_quit = 1;
	PRINT_INFO("s_app_t::run EXIT quit:%d\n", this->m_quit);
	if( m_exit == 1 )
	{
		m_eye->stop();
		stop();
		m_exit = 2;
	}

	return 0;
}
/**
    @function: static int srecorder_get_other_symbols(void)
    @brief: 给s_kernel_symbols_table表中的内核符号找到对应的地址

    @param: none
    
    @return: 0 - 成功;<0-失败

    @note: 
*/
static int srecorder_get_other_symbols(void)
{
    int i = 0;
    int symbols_table_size = sizeof(s_kernel_symbols_table) / sizeof(s_kernel_symbols_table[0]);  

    for (i = 0; i < symbols_table_size; i++)
    {
        /*调用kallsyms_lookup_name查找符号对应的地址*/
        if (unlikely(NULL == s_kernel_symbols_table[i].symbol_name || NULL == s_kernel_symbols_table[i].symbol_address))
        {
            continue;
        }
        
        *(s_kernel_symbols_table[i].symbol_address) = s_kallsyms_lookup_name(s_kernel_symbols_table[i].symbol_name);
        if (INVALID_KSYM_ADDR == *(s_kernel_symbols_table[i].symbol_address))
        {
            PRINT_INFO(("Get %s failed.\n", s_kernel_symbols_table[i].symbol_name), DEBUG_KERNEL_SYMBOLS);
            continue; /*return -EFAULT; */ /* 不要因为一个符号的失败影响到其他符号的读取 */
        }
    }
    
    return 0;
}
Esempio n. 21
0
/*
 * 3480/3490 interrupt handler
 */
static int
tape_34xx_irq(struct tape_device *device, struct tape_request *request,
	      struct irb *irb)
{
	if (request == NULL)
		return tape_34xx_unsolicited_irq(device, irb);

	if ((irb->scsw.dstat & DEV_STAT_UNIT_EXCEP) &&
	    (irb->scsw.dstat & DEV_STAT_DEV_END) &&
	    (request->op == TO_WRI)) {
		/* Write at end of volume */
		PRINT_INFO("End of volume\n"); /* XXX */
		return tape_34xx_erp_failed(request, -ENOSPC);
	}

	if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK)
		return tape_34xx_unit_check(device, request, irb);

	if (irb->scsw.dstat & DEV_STAT_DEV_END) {
		/*
		 * A unit exception occurs on skipping over a tapemark block.
		 */
		if (irb->scsw.dstat & DEV_STAT_UNIT_EXCEP) {
			if (request->op == TO_BSB || request->op == TO_FSB)
				request->rescnt++;
			else
				DBF_EVENT(5, "Unit Exception!\n");
		}
		return tape_34xx_done(request);
	}

	DBF_EVENT(6, "xunknownirq\n");
	PRINT_ERR("Unexpected interrupt.\n");
	PRINT_ERR("Current op is: %s", tape_op_verbose[request->op]);
	tape_dump_sense(device, request, irb);
	return TAPE_IO_STOP;
}
Esempio n. 22
0
static void venc_set_lvds(Lcd_Config_t *pConf)
{
	PRINT_INFO("%s.\n",__FUNCTION__);
#if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6TV
	aml_write_reg32(P_VPU_VIU_VENC_MUX_CTRL, (0<<0) |    // viu1 select encl
											(0<<2) );    // viu2 select encl
#endif
	aml_write_reg32(P_ENCL_VIDEO_EN, 0);
	//int havon_begin = 80;
	aml_write_reg32(P_VPU_VIU_VENC_MUX_CTRL, (0<<0) |    // viu1 select encl
											(0<<2) );     // viu2 select encl
	aml_write_reg32(P_ENCL_VIDEO_MODE, 0); // Enable Hsync and equalization pulse switch in center; bit[14] cfg_de_v = 1
	aml_write_reg32(P_ENCL_VIDEO_MODE_ADV,     0x0418); // Sampling rate: 1

	// bypass filter
	aml_write_reg32(P_ENCL_VIDEO_FILT_CTRL, 0x1000);
	aml_write_reg32(P_ENCL_VIDEO_MAX_PXCNT, pConf->lcd_basic.h_period - 1);
	if (pDev->lcd_info.mode == VMODE_1080P_50HZ)
		aml_write_reg32(P_ENCL_VIDEO_MAX_LNCNT, 1350 - 1);
	else
		aml_write_reg32(P_ENCL_VIDEO_MAX_LNCNT, pConf->lcd_basic.v_period - 1);
	aml_write_reg32(P_ENCL_VIDEO_HAVON_BEGIN, pConf->lcd_timing.video_on_pixel);
	aml_write_reg32(P_ENCL_VIDEO_HAVON_END, pConf->lcd_basic.h_active - 1 + pConf->lcd_timing.video_on_pixel);
	aml_write_reg32(P_ENCL_VIDEO_VAVON_BLINE,	pConf->lcd_timing.video_on_line);
	aml_write_reg32(P_ENCL_VIDEO_VAVON_ELINE,	pConf->lcd_basic.v_active - 1  + pConf->lcd_timing.video_on_line);

	aml_write_reg32(P_ENCL_VIDEO_HSO_BEGIN,	pConf->lcd_timing.sth1_hs_addr);//10);
	aml_write_reg32(P_ENCL_VIDEO_HSO_END,	pConf->lcd_timing.sth1_he_addr);//20);
	aml_write_reg32(P_ENCL_VIDEO_VSO_BEGIN,	pConf->lcd_timing.stv1_hs_addr);//10);
	aml_write_reg32(P_ENCL_VIDEO_VSO_END,	pConf->lcd_timing.stv1_he_addr);//20);
	aml_write_reg32(P_ENCL_VIDEO_VSO_BLINE,	pConf->lcd_timing.stv1_vs_addr);//2);
	aml_write_reg32(P_ENCL_VIDEO_VSO_ELINE,	pConf->lcd_timing.stv1_ve_addr);//4);
		aml_write_reg32(P_ENCL_VIDEO_RGBIN_CTRL, 0);

		// enable encl
		aml_write_reg32(P_ENCL_VIDEO_EN, 1);
	}
static void backlight_power_ctrl(Bool_t status)
{ 
	mutex_lock(&bl_power_mutex);
	PRINT_INFO("%s(): bl_status=%s, data_status=%s, bl_level=%u\n", __FUNCTION__, (bl_status ? "ON" : "OFF"), (data_status ? "ON" : "OFF"), bl_level);
    if( status == ON ){
		if ((bl_status == ON) || (data_status == OFF) || (bl_level == 0)) {
			mutex_unlock(&bl_power_mutex);
			return;
		}	
        aml_set_reg32_bits(P_LED_PWM_REG0, 1, 12, 2);
        lcd_mdelay(20); 
		
#if (BL_CTL==BL_CTL_GPIO)	
		//BL_EN -> GPIOD_1: 1
		gpio_out(PAD_GPIOD_1, 1);		
#elif (BL_CTL==BL_CTL_PWM)		 		
		aml_set_reg32_bits(P_PWM_MISC_REG_CD, PWM_PRE_DIV, 16, 7);
		aml_set_reg32_bits(P_PWM_MISC_REG_CD, 1, 23, 1);
		aml_set_reg32_bits(P_PWM_MISC_REG_CD, 1, 1, 1);  //enable pwm_d		
		aml_write_reg32(P_PERIPHS_PIN_MUX_2, aml_read_reg32(P_PERIPHS_PIN_MUX_2) | (1<<3));  //enable pwm pinmux
#endif
    }
    else{
		if (bl_status == OFF) {
			mutex_unlock(&bl_power_mutex);
			return;
		}
#if (BL_CTL==BL_CTL_GPIO)		
		gpio_out(PAD_GPIOD_1, 0);		
#elif (BL_CTL==BL_CTL_PWM)		
		aml_set_reg32_bits(P_PWM_MISC_REG_CD, 0, 1, 1);	//disable pwm_d		
#endif		
    }
	bl_status = status;
	printk(KERN_INFO "%s() Power %s\n", __FUNCTION__, (status ? "ON" : "OFF"));
	mutex_unlock(&bl_power_mutex);
}
Esempio n. 24
0
int init_x86rom_cbfs_media(struct cbfs_media *media) {
	// On X86, we always keep a reference of pointer to CBFS header in
	// 0xfffffffc, and the pointer is still a memory-mapped address.
	// Since the CBFS core always use ROM offset, we need to figure out
	// header->romsize even before media is initialized.
	struct cbfs_header *header = (struct cbfs_header*)
		phys_to_virt( *(uint32_t*) phys_to_virt(0xfffffffc));

	PRINT_DEBUG( "header %p contains 0x%x\n\n\n", (unsigned int *) header, header->magic );

	if (CBFS_HEADER_MAGIC != ntohl(header->magic)) {
#if defined(CONFIG_LP_ROM_SIZE)
		PRINT_ERROR("\nBIOS_ERR : Invalid CBFS master header at %p\n", header);
		media->context = (void*)CONFIG_LP_ROM_SIZE;
#else
		return -1;
#endif
	} else {
		uint32_t romsize = ntohl(header->romsize);

		media->context = phys_to_virt(0 - romsize);

		PRINT_DEBUG( "context set to %p\n", (char *) media->context );

#if defined(CONFIG_LP_ROM_SIZE)
		if (CONFIG_LP_ROM_SIZE != romsize)
			PRINT_INFO("BIOS_INFO: Warning: rom size unmatch (%d/%d)\n",
			       CONFIG_LP_ROM_SIZE, romsize);
#endif
	}
	media->open = x86_rom_open;
	media->close = x86_rom_close;
	media->map = x86_rom_map;
	media->unmap = x86_rom_unmap;
	media->read = x86_rom_read;
	return 0;
}
Esempio n. 25
0
File: delete.c Progetto: unizeto/bmd
long DeleteOtherData(		void *hDB,
				char *CryptoObjectNr,
				char *location_id,
				char *tableName,
				server_request_data_t *req)
{
char *SQLQuery		= NULL;
void *database_result	= NULL;

	PRINT_INFO("LIBBMDSQLINF Deleting file's aditional metadata\n");
	/************************/
	/* walidacja parametrow */
	/************************/
	if (hDB==NULL)			{	BMD_FOK(BMD_ERR_PARAM1);	}
	if (CryptoObjectNr==NULL)	{	BMD_FOK(BMD_ERR_PARAM2);	}

	asprintf(&SQLQuery, "DELETE FROM %s WHERE fk_crypto_objects=%s%s%s;",
				tableName,
				CryptoObjectNr,
				location_id==NULL?"":" AND location_id=",
				location_id==NULL?"":location_id);
	if (SQLQuery==NULL)	{	BMD_FOK(NO_MEMORY);	}

	/****************************************/
	/* wykonanie polecenia usuwania w bazie */
	/****************************************/
	BMD_FOK(bmd_db_execute_sql(hDB, SQLQuery,NULL,NULL, &database_result));

	/************/
	/* porzadki */
	/************/
	bmd_db_result_free(&database_result);
	free0(SQLQuery);

	return BMD_OK;
}
Esempio n. 26
0
/*
 * Callback function for SSL/TLS NPN. Since this program only supports
 * SPDY protocol, if server does not offer SPDY protocol the Spdylay
 * library supports, we terminate program.
 */
static int
spdy_cb_ssl_select_next_proto(SSL* ssl,
                                unsigned char **out,
                                unsigned char *outlen,
                                const unsigned char *in,
                                unsigned int inlen,
                                void *arg)
{
  (void)ssl;

  int rv;
  uint16_t *spdy_proto_version;

  /* spdylay_select_next_protocol() selects SPDY protocol version the
     Spdylay library supports. */
  rv = spdylay_select_next_protocol(out, outlen, in, inlen);
  if(rv <= 0) {
    PRINT_INFO("Server did not advertise spdy/2 or spdy/3 protocol.");
    return rv;
  }
  spdy_proto_version = (uint16_t*)arg;
  *spdy_proto_version = rv;
  return SSL_TLSEXT_ERR_OK;
}
Esempio n. 27
0
int invoke_stpg(const uint8_t *device_name,
                const struct scst_event_stpg_descr *descr, pid_t *out_pid)
{
    char *args[7], *env[7];
    int res = 0, ret, i;
    pid_t c_pid;

    args[0] = stpg_path;
    args[1] = (char *)device_name;
    args[2] = (char *)descr->prev_state;
    args[3] = (char *)descr->new_state;
    args[4] = (char *)descr->dg_name;
    args[5] = (char *)descr->tg_name;
    args[6] = NULL;

    env[0] = "PATH=/bin:/usr/bin:/sbin:/usr/sbin";
    ret = asprintf(&env[1], "SCST_DEVICE_NAME=%s", device_name);
    if (ret < 0) {
        res = -errno;
        PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res));
        goto out;
    }
    ret = asprintf(&env[2], "SCST_PREV_ALUA_STATE=%s", descr->prev_state);
    if (ret < 0) {
        res = -errno;
        PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res));
        goto out;
    }
    ret = asprintf(&env[3], "SCST_ALUA_STATE=%s", descr->new_state);
    if (ret < 0) {
        res = -errno;
        PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res));
        goto out;
    }
    ret = asprintf(&env[4], "SCST_DEVICE_GROUP=%s", descr->dg_name);
    if (ret < 0) {
        res = -errno;
        PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res));
        goto out;
    }
    ret = asprintf(&env[5], "SCST_TARGET_GROUP=%s", descr->tg_name);
    if (ret < 0) {
        res = -errno;
        PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res));
        goto out;
    }
    env[6] = NULL;

    PRINT_INFO("Invoking script %s with parameters: %s %s %s %s %s and environment: "
               "%s %s %s %s %s", stpg_path, args[1], args[2], args[3],
               args[4], args[5], env[1], env[2], env[3], env[4], env[5]);

    c_pid = fork();
    if (c_pid == 0) {
        ret = setpgid(getpid(), getpid());
        if (ret < 0) {
            res = -errno;
            PRINT_ERROR("setgid failed %d (%s)", ret, strerror(-ret));
        }
        TRACE_DBG("pgid %d (pid %d)", getpgid(getpid()), getpid());
        ret = execve(stpg_path, args, env);
        if (ret < 0) {
            res = -errno;
            PRINT_ERROR("EXEC failed %d (%s)", ret, strerror(-ret));
        }
        exit(0);
    } else if (c_pid < 0) {
        res = -errno;
        PRINT_ERROR("fork() failed: %d (%s)", res, strerror(-res));
    }

    *out_pid = c_pid;

    for (i = 1; i < (signed)ARRAY_SIZE(env); i++)
        free(env[i]);

out:
    return res;
}
Esempio n. 28
0
static int stpg_event_loop(void)
{
    int res = 0, status;
    int event_fd;
    uint8_t event_user_buf[1024*1024];
    pid_t c_pid = 0;
    struct pollfd pl;
    struct scst_event_user *event_user =
        (struct scst_event_user *)event_user_buf;
    struct scst_event e1;
    bool first_error = true;

    event_fd = open(SCST_EVENT_DEV, O_RDWR);
    if (event_fd < 0) {
        res = -errno;
        PRINT_ERROR("Unable to open SCST event device %s (%s)",
                    SCST_EVENT_DEV, strerror(-res));
        goto out;
    }

    close(stpg_init_report_pipe[0]);

    if (log_daemon)
        res = write(stpg_init_report_pipe[1], &res, sizeof(res));

    close(stpg_init_report_pipe[1]);

    memset(&pl, 0, sizeof(pl));
    pl.fd = event_fd;
    pl.events = POLLIN;

    memset(&e1, 0, sizeof(e1));
    e1.event_code = SCST_EVENT_STPG_USER_INVOKE;
    strncpy(e1.issuer_name, SCST_EVENT_SCST_CORE_ISSUER,
            sizeof(e1.issuer_name));
    e1.issuer_name[sizeof(e1.issuer_name)-1] = '\0';
    PRINT_INFO("Setting allowed event code %d, issuer_name %s",
               e1.event_code, e1.issuer_name);

    res = ioctl(event_fd, SCST_EVENT_ALLOW_EVENT, &e1);
    if (res != 0) {
        res = -errno;
        PRINT_ERROR("SCST_EVENT_ALLOW_EVENT failed: %d (%s)",
                    res, strerror(-res));
        goto out;
    }

    e1.event_code = SCST_EVENT_TM_FN_RECEIVED;
    strncpy(e1.issuer_name, SCST_EVENT_SCST_CORE_ISSUER,
            sizeof(e1.issuer_name));
    e1.issuer_name[sizeof(e1.issuer_name)-1] = '\0';
    PRINT_INFO("Setting allowed event code %d, issuer_name %s",
               e1.event_code, e1.issuer_name);
    res = ioctl(event_fd, SCST_EVENT_ALLOW_EVENT, &e1);
    if (res != 0) {
        res = -errno;
        PRINT_ERROR("SCST_EVENT_ALLOW_EVENT failed: %d (%s)",
                    res, strerror(-res));
        goto out;
    }

    while (1) {
        memset(event_user_buf, 0, sizeof(event_user_buf));
        event_user->max_event_size = sizeof(event_user_buf);
        res = ioctl(event_fd, SCST_EVENT_GET_NEXT_EVENT, event_user);
        if (res != 0) {
            res = -errno;
            switch (-res) {
            case ESRCH:
            case EBUSY:
                TRACE_MGMT_DBG("SCST_EVENT_GET_NEXT_EVENT "
                               "returned %d (%s)", res, strerror(res));
            /* go through */
            case EINTR:
                continue;
            case EAGAIN:
                TRACE_DBG("SCST_EVENT_GET_NEXT_EVENT, "
                          "returned EAGAIN (%d)", -res);
                continue;
            default:
                PRINT_ERROR("SCST_EVENT_GET_NEXT_EVENT "
                            "failed: %d (%s)", res, strerror(-res));
                if (!first_error)
                    goto out;
                first_error = false;
                continue;
            }
            first_error = true;
again_poll:
            res = poll(&pl, 1, c_pid > 0 ? 1 : 0);
            if (res > 0)
                continue;
            else if (res == 0)
                goto again_poll;
            else {
                res = -errno;
                switch (res) {
                case ESRCH:
                case EBUSY:
                case EAGAIN:
                    TRACE_MGMT_DBG("poll() returned %d "
                                   "(%s)", res, strerror(-res));
                case EINTR:
                    goto again_poll;
                default:
                    PRINT_ERROR("poll() failed: %d (%s)",
                                res, strerror(-res));
                    goto again_poll;
                }
            }
        }
        first_error = true;
#ifdef DEBUG
        PRINT_INFO("event_code %d, issuer_name %s",
                   event_user->out_event.event_code,
                   event_user->out_event.issuer_name);
#endif
        if (event_user->out_event.payload_len != 0)
            TRACE_BUFFER("payload", event_user->out_event.payload,
                         event_user->out_event.payload_len);

        if (event_user->out_event.event_code == SCST_EVENT_STPG_USER_INVOKE) {
            c_pid = fork();
            if (c_pid == -1)
                PRINT_ERROR("Failed to fork: %d", c_pid);
            else if (c_pid == 0) {
                struct scst_event_notify_done d;

                signal(SIGCHLD, SIG_DFL);

                status = handle_stpg_received(event_user);

                memset(&d, 0, sizeof(d));
                d.event_id = event_user->out_event.event_id;
                d.status = status;
                res = ioctl(event_fd, SCST_EVENT_NOTIFY_DONE, &d);
                if (res != 0) {
                    res = -errno;
                    PRINT_ERROR("SCST_EVENT_NOTIFY_DONE "
                                "failed: %s (res %d)",
                                strerror(-res), res);
                } else
                    PRINT_INFO("STPG event completed with status %d", status);
                exit(res);
            }
        } else if (event_user->out_event.event_code == SCST_EVENT_TM_FN_RECEIVED)
            stpg_handle_tm_received(event_user);
        else
            PRINT_ERROR("Unknown event %d received", event_user->out_event.event_code);
    }
out:
    return res;
}
Esempio n. 29
0
int main(int argc, char **argv)
{
    int res = 0, ch, longindex;
    pid_t pid;
    struct sigaction sa;

    setlinebuf(stdout);

    openlog(argv[0], LOG_PID, LOG_USER);

    res = pipe(stpg_init_report_pipe);
    if (res == -1) {
        res = -errno;
        PRINT_ERROR("Pipe failed: %d (%s)", res, strerror(-res));
        goto out;
    }

    sa.sa_handler = &sig_chld;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
    if (sigaction(SIGCHLD, &sa, 0) == -1) {
        PRINT_ERROR("sigaction() failed: %d/%s", errno, strerror(errno));
        exit(1);
    }

    /*
     * Otherwise we could die in some later write() during the event_loop()
     * instead of getting EPIPE!
     */
    signal(SIGPIPE, SIG_IGN);

    res = debug_init();
    if (res != 0)
        goto out;

    app_name = argv[0];

    while ((ch = getopt_long(argc, argv, "+d:fp:t:hv",
                             long_options, &longindex)) >= 0) {
        switch (ch) {
        case 'p':
            stpg_path = optarg;
            break;
#if defined(DEBUG) || defined(TRACING)
        case 'd':
            trace_flag = strtol(optarg, (char **)NULL, 0);
            break;
#endif
        case 'v':
            printf("%s version %s\n", app_name, VERSION_STR);
            goto out_done;
        case 'f':
            log_daemon = false;
            break;
        case 't':
            transition_timeout = strtol(optarg, (char **)NULL, 0);
            if (transition_timeout < 0) {
                printf("Invalid timeout %d\n", transition_timeout);
                res = -EINVAL;
                goto out_done;
            }
            break;
        case 'h':
            usage(0);
            goto out_done;
        default:
            goto out_usage;
        }
    }

    if (!stpg_path)
        stpg_path = "/usr/local/bin/scst/scst_on_stpg";

    if (access(stpg_path, X_OK) == -1) {
        PRINT_ERROR("Script file \" %s \"does not exist or not "
                    "executable", stpg_path);
        res = -1;
        goto out_done;
    }

#ifdef DEBUG
    PRINT_INFO("trace_flag %lx", trace_flag);
#endif
    if (log_daemon) {
        trace_flag &= ~TRACE_TIME;
        trace_flag &= ~TRACE_PID;

        pid = fork();
        if (pid < 0) {
            PRINT_ERROR("starting daemon failed(%d)", pid);
            res = pid;
            goto out_done;
        } else if (pid) {
            int res1 = -1;

            close(stpg_init_report_pipe[1]);
            if ((unsigned)read(stpg_init_report_pipe[0], &res1, sizeof(res1)) < sizeof(res1)) {
                res = -1;
                goto out_done;
            } else {
                res = res1;
                goto out_done;
            }
        }

        close(0);
        open("/dev/null", O_RDWR);
        dup2(0, 1);
        dup2(0, 2);
        setsid();
    }

    res = stpg_event_loop();

out_done:
    debug_done();

out:
    closelog();
    return res;

out_usage:
    usage(1);
    goto out_done;
}
Esempio n. 30
0
static int _switch_gate(mod_type_t type, int flag)
{
    int ret = 0;
    switch(type) {
        case MOD_VDEC:
            PRINT_INFO("turn %s vdec module\n", flag?"on":"off");
            if (flag) {               
                GATE_ON(DOS);
            } else {
                GATE_OFF(DOS);
            }
            break;
        case MOD_AUDIO:
            PRINT_INFO("turn %s audio module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(AIU_AMCLK_MEASURE);
                GATE_ON(AIU_AIFIFO2);
                GATE_ON(AIU_AUD_MIXER);
                GATE_ON(AIU_MIXER_REG);
                
                GATE_ON(AIU_IEC958);
                GATE_ON(AIU_AI_TOP_GLUE);
                GATE_ON(AUD_BUF);
                GATE_ON(AIU_I2S_OUT);
                GATE_ON(AIU_AMCLK); //this gate should not be turned off
                GATE_ON(AIU_ICE958_AMCLK);
                GATE_ON(AIU_AOCLK);   
                //GATE_ON(AUD_IN);
                GATE_ON(AIU_ADC);
                GATE_ON(AIU_AUDIN_SCLK);
            } else {   
            	  GATE_OFF(AIU_AMCLK_MEASURE);
                GATE_OFF(AIU_AIFIFO2);
                GATE_OFF(AIU_AUD_MIXER);
                GATE_OFF(AIU_MIXER_REG);
                
                GATE_OFF(AIU_IEC958);
                GATE_OFF(AIU_AI_TOP_GLUE);
                GATE_OFF(AUD_BUF);
                GATE_OFF(AIU_I2S_OUT);         
                GATE_OFF(AIU_AMCLK); //this gate should not be turned off
                GATE_OFF(AIU_ICE958_AMCLK);
                GATE_OFF(AIU_AOCLK);
                //GATE_OFF(AUD_IN);
                GATE_OFF(AIU_ADC);
                GATE_OFF(AIU_AUDIN_SCLK);
            }
            break;
        case MOD_HDMI:
            PRINT_INFO("turn %s hdmi module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(HDMI_INTR_SYNC);
                GATE_ON(HDMI_PCLK);
                GATE_ON(VCLK1_HDMI);
            } else {
                GATE_OFF(HDMI_INTR_SYNC);
                GATE_OFF(HDMI_PCLK);
                GATE_OFF(VCLK1_HDMI);
            }            
            break;
        case MOD_VENC:
            PRINT_INFO("turn %s venc module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(VCLK2_VENCI);
                GATE_ON(VCLK2_VENCI1);
                GATE_ON(VCLK2_VENCP);
                GATE_ON(VCLK2_VENCP1);
                GATE_ON(VENC_P_TOP);
                GATE_ON(VENC_I_TOP);
                GATE_ON(VENCI_INT);
                GATE_ON(VENCP_INT);
                GATE_ON(VCLK2_ENCI);
                GATE_ON(VCLK2_ENCP);
                GATE_ON(VCLK2_VENCT);
                GATE_ON(VCLK2_VENCT1);
                GATE_ON(VCLK2_OTHER);
                GATE_ON(VCLK2_OTHER1);
                GATE_ON(ENC480P);
                GATE_ON(VENC_DAC);
                GATE_ON(DAC_CLK);
            } else {
                GATE_OFF(VCLK2_VENCI);
                GATE_OFF(VCLK2_VENCI1);
                GATE_OFF(VCLK2_VENCP);
                GATE_OFF(VCLK2_VENCP1);
                GATE_OFF(VENC_P_TOP);
                GATE_OFF(VENC_I_TOP);
                GATE_OFF(VENCI_INT);
                GATE_OFF(VENCP_INT);
                GATE_OFF(VCLK2_ENCI);
                GATE_OFF(VCLK2_ENCP);
                GATE_OFF(VCLK2_VENCT);
                GATE_OFF(VCLK2_VENCT1);
                GATE_OFF(VCLK2_OTHER);
                GATE_OFF(VCLK2_OTHER1);
                GATE_OFF(ENC480P);
                GATE_OFF(VENC_DAC);
                GATE_OFF(DAC_CLK);
            }
            break;
        case MOD_TCON:
            PRINT_INFO("turn %s tcon module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(VENC_T_TOP);
                GATE_ON(VENCT_INT);
                GATE_ON(VCLK2_ENCT);
            } else {
                GATE_OFF(VENC_T_TOP);
                GATE_OFF(VENCT_INT);
                GATE_OFF(VCLK2_ENCT);
            }
            break;
        case MOD_LVDS:
            PRINT_INFO("turn %s lvds module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(VENC_L_TOP);
                GATE_ON(VENCL_INT);
                GATE_ON(VCLK2_ENCL);
            } else {
                GATE_OFF(VENC_L_TOP);
                GATE_OFF(VENCL_INT);
                GATE_OFF(VCLK2_ENCL);
            }
            break;
        case MOD_MIPI:
            PRINT_INFO("turn %s mipi module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(MIPI_APB_CLK);
                GATE_ON(MIPI_SYS_CLK);
                GATE_ON(MIPI_PHY);
            } else {
                GATE_OFF(MIPI_APB_CLK);
                GATE_OFF(MIPI_SYS_CLK);
                GATE_OFF(MIPI_PHY);
            }
            break;
        case MOD_BT656:
            PRINT_INFO("turn %s bt656 module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(BT656_IN);
            } else {
                GATE_OFF(BT656_IN);
            }
            break;
        case MOD_SPI:
            PRINT_INFO("turn %s spi module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(SPICC);
                GATE_ON(SPI1);
                GATE_ON(SPI2);
            } else {
                GATE_OFF(SPICC);
                GATE_OFF(SPI1);
                GATE_OFF(SPI2);
            }
            break;
        case MOD_UART0:
            PRINT_INFO("turn %s uart0 module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(UART0);
            } else {
                GATE_OFF(UART0);
            }
            break;
        case MOD_UART1:
            PRINT_INFO("turn %s uart1 module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(UART1);
            } else {
                GATE_OFF(UART1);
            }
            break;
        case MOD_UART2:
            PRINT_INFO("turn %s uart2 module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(UART2);
            } else {
                GATE_OFF(UART2);
            }
            break;
        case MOD_UART3:
            PRINT_INFO("turn %s uart3 module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(UART3);
            } else {
                GATE_OFF(UART3);
            }
            break;
        case MOD_ROM:
            PRINT_INFO("turn %s rom module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(ROM_CLK);
            } else {
                GATE_OFF(ROM_CLK);
            }
            break;
        case MOD_EFUSE:
            PRINT_INFO("turn %s efuse module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(EFUSE);
            } else {
                GATE_OFF(EFUSE);
            }
            break;
        case MOD_RANDOM_NUM_GEN:
            PRINT_INFO("turn %s random_num_gen module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(RANDOM_NUM_GEN);
            } else {
                GATE_OFF(RANDOM_NUM_GEN);
            }
            break;
        case MOD_ETHERNET:
            PRINT_INFO("turn %s ethernet module\n", flag?"on":"off");
            if (flag) {
                GATE_ON(ETHERNET);
            } else {
                GATE_OFF(ETHERNET);
            }
            break;
        case MOD_MEDIA_CPU:
            PRINT_INFO("trun %s Audio DSP\n", flag? " on" : "off");
            if(flag){
                GATE_ON(MEDIA_CPU);
            }else{
                 GATE_OFF(MEDIA_CPU);
            }
            break;
        case MOD_GE2D:
            PRINT_INFO("trun %s GE2D\n", flag? " on" : "off");
            if(flag){
                GATE_ON(GE2D);
            }else{
                GATE_OFF(GE2D);
            }
            break;
        case MOD_VIDEO_IN:
            PRINT_INFO("trun %s video_in\n", flag? " on" : "off");
            if(flag){
                GATE_ON(VIDEO_IN);
            }else{
                GATE_OFF(VIDEO_IN);
            }
            break;
        case MOD_VIU2:
            PRINT_INFO("trun %s viu2\n", flag? " on" : "off");
            if(flag){
                GATE_ON(VIU2);
            }else{
                GATE_OFF(VIU2);
            }
            break;
        case MOD_AUD_IN:
            PRINT_INFO("trun %s audio_in\n", flag? " on" : "off");
            #if 0
            if(flag){
                GATE_ON(AIU_ADC);
                GATE_ON(AIU_AUDIN_SCLK);
            }else{
                GATE_OFF(AIU_ADC);
                GATE_OFF(AIU_AUDIN_SCLK);
            }
            #endif
            break;
        case MOD_AUD_OUT:
            PRINT_INFO("trun %s audio_out\n", flag? " on" : "off");
            if(flag){

            }else{

            }
            break;
        case MOD_AHB:
            PRINT_INFO("trun %s ahb\n", flag? " on" : "off");
            if(flag){
                GATE_ON(AHB_ARB0);
                GATE_ON(AHB_BRIDGE);
                GATE_ON(AHB_DATA_BUS);
                GATE_ON(AHB_CONTROL_BUS);
            }else{
                GATE_OFF(AHB_ARB0);
                GATE_OFF(AHB_BRIDGE);
                GATE_OFF(AHB_DATA_BUS);
                GATE_OFF(AHB_CONTROL_BUS);
            }
            break;
        case MOD_DEMUX:
            PRINT_INFO("trun %s demux\n", flag? " on" : "off");
            if(flag){
                GATE_ON(DEMUX);
            }else{
                GATE_OFF(DEMUX);
            }
            break;
        case MOD_SMART_CARD:
            PRINT_INFO("trun %s smart card\n", flag? " on" : "off");
            if(flag){
                GATE_ON(SMART_CARD_MPEG_DOMAIN);
            }else{
                GATE_OFF(SMART_CARD_MPEG_DOMAIN);
            }
            break;
        case MOD_SDHC:
            PRINT_INFO("trun %s sdhc\n", flag? " on" : "off");
            if(flag){
                GATE_ON(SDHC);
            }else{
                GATE_OFF(SDHC);
            }
            break;
        case MOD_STREAM:
            PRINT_INFO("trun %s stream\n", flag? " on" : "off");
            if(flag){
                GATE_ON(STREAM);
            }else{
                GATE_OFF(STREAM);
            }
            break;
        case MOD_BLK_MOV:
            PRINT_INFO("trun %s blk_mov\n", flag? " on" : "off");
            if(flag){
                GATE_ON(BLK_MOV);
            }else{
                GATE_OFF(BLK_MOV);
            }
            break;
        case MOD_MISC_DVIN:
            PRINT_INFO("trun %s dvin\n", flag? " on" : "off");
            if(flag){
                GATE_ON(MISC_DVIN);
            }else{
                GATE_OFF(MISC_DVIN);
            }
            break;
        case MOD_MISC_RDMA:
            PRINT_INFO("trun %s rdma\n", flag? " on" : "off");
            if(flag){
                GATE_ON(MISC_RDMA);
            }else{
                GATE_OFF(MISC_RDMA);
            }
            break;
        case MOD_USB0:
            PRINT_INFO("trun %s rdma\n", flag? " on" : "off");
            if(flag){
                GATE_ON(USB0);
                GATE_ON(MISC_USB0_TO_DDR);
            }else{
                GATE_OFF(USB0);
                GATE_ON(MISC_USB0_TO_DDR);
            }
            break;
        case MOD_USB1:
            PRINT_INFO("trun %s rdma\n", flag? " on" : "off");
            if(flag){
                GATE_ON(USB1);
                GATE_ON(MISC_USB1_TO_DDR);
            }else{
                GATE_OFF(USB1);
                GATE_ON(MISC_USB1_TO_DDR);
            }
            break;
        case MOD_SDIO:
            PRINT_INFO("trun %s rdma\n", flag? " on" : "off");
            if(flag){
                GATE_ON(SDIO);
            }else{
                GATE_OFF(SDIO);
            }
            break;
        case MOD_VI_CORE:
            PRINT_INFO("trun %s vi core\n", flag? " on" : "off");
            if(flag){
                GATE_ON(VI_CORE);
            }else{
                GATE_OFF(VI_CORE);
            }
            break;
        case MOD_LED_PWM:
            PRINT_INFO("trun %s led pwm\n", flag? " on" : "off");
            if(flag){
                GATE_ON(LED_PWM);
            }else{
                GATE_OFF(LED_PWM);
            }
            break;
        default:
            PRINT_INFO("mod type not support\n");
            ret = -1;
            break;
    }
    return ret;
}