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

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;
}

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;
}

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;
}

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

 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];
 }

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;
}

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

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

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

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;
}

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();
}

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

//=============================================================================
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;
  }
}

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;
}

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;
}

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

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