自学教程：C++ CCCI_MSG_INF函数代码示例

int reset_md(void){    CCCI_BUFF_T sys_msg;	char buf = 1;	    CCCI_MSG_INF("ctl", "send reset modem request message/n");    /* prevent another reset modem action from wdt timeout IRQ during modem reset */	atomic_inc(&md_reset_on_going);	if(atomic_read(&md_reset_on_going)>1){		CCCI_MSG_INF("ctl", "One reset flow is on-going /n");		return CCCI_MD_IN_RESET;	}	if(md_boot_stage == MD_BOOT_STAGE_2){		lock_md_sleep(&buf, sizeof(char));	}		/* v1.3 20120601: mask CCIF IRQ to prevent md_boot_stage from updating by CCIF ISR */    md_boot_stage = MD_BOOT_STAGE_0;    //ccci_disable();    ccci_mask();    //CCCI_INIT_MAILBOX(&sys_msg, CCCI_SYS_MSG_RESET_MD);    wake_lock_timeout(&trm_wake_lock, 10*HZ);    CCCI_INIT_MAILBOX(&sys_msg, CCCI_MD_MSG_RESET);    ccci_system_message(&sys_msg);  //  CCCI_DEBUG("wait...../n"); //   schedule_timeout_interruptible(5*HZ); //  boot_md();    return CCCI_SUCCESS;}

static int ready2boot(void){    int addr, len;    ccci_uart_base_req(0, &addr, &len);    if (addr == 0 || len == 0) {        CCCI_MSG_INF("ctl", "UART base address is not setup/n");        return 0;    }    ccci_fs_base_req(&addr, &len);    if (addr == 0 || len == 0) {        CCCI_MSG_INF("ctl", "CCCI_FS base address is not setup/n");        return 0;    }    ccci_pmic_base_req(&addr, &len);    if (addr == 0 || len == 0) {        CCCI_MSG_INF("ctl", "PMIC base address is not setup/n");        return 0;    }	    ccci_ipc_base_req(&addr, &len);    if (addr == 0 || len == 0) {        CCCI_MSG_INF("ctl", "CCCI_IPC base address is not setup/n");        return 0;    }   if (platform_ready2boot())   	return 0;    return 1;}

int get_logic_ch_data(logic_channel_info_t *ch_info, ccci_msg_t *msg){	if (unlikely(ch_info == NULL)){		CCCI_MSG("%s fail: get invalid ch info/n", __FUNCTION__);		return -CCCI_ERR_GET_NULL_POINTER;	}	if (unlikely(ch_info->m_attrs&L_CH_ATTR_TX)){		CCCI_MSG_INF(ch_info->m_md_id, "cci", "%s fail: %s(ch%d) is tx /n", /						__FUNCTION__, ch_info->m_ch_name, msg->channel);		return -CCCI_ERR_GET_RX_DATA_FROM_TX_CHANNEL;	}	// check whether fifo is ready	if (unlikely(!ch_info->m_kfifo_ready)){		CCCI_MSG_INF(ch_info->m_md_id, "cci", "%s fail: %s(ch%d) kfifo not ready/n", /						__FUNCTION__, ch_info->m_ch_name, msg->channel);		return -CCCI_ERR_KFIFO_IS_NOT_READY;	}	// Check fifo if has data	if (kfifo_is_empty(&ch_info->m_kfifo))	{		return 0;	}	// Pop data	return kfifo_out(&ch_info->m_kfifo, msg, sizeof(ccif_msg_t));}

int ccci_send_run_time_data(void){	int ret=0;	CCCI_BUFF_T buff;	/* Set runtime data and echo start-boot command */	CCCI_MSG_INF("ctl", "set modem runtime/n");	ret = set_md_runtime();	if (ret != 0) {		CCCI_MSG_INF("ctl", "fail to set MODEM runtime data/n");		return ret;	}	//printk("echo MD_INIT_START_BOOT/n");	CCCI_INIT_MAILBOX(&buff, MD_INIT_START_BOOT);	buff.reserved = MD_INIT_CHK_ID;	ccci_before_modem_start_boot();	ret = ccci_write(CCCI_CONTROL_TX, &buff);	if (ret != 0) {		CCCI_MSG_INF("ctl", "fail to write CCCI_CONTROL_TX/n");		return ret;	}	CCCI_MSG_INF("ctl", "wait for NORMAL_BOOT_ID/n");	//if (end)   end();	//Notes:after load dsp_rom, dsp will write data back to dsp region, so set protect region at last	//start_emi_mpu_protect();	enable_emi_mpu_protection(ccci_smem_phy, ccci_smem_size);	//mod_timer(&md_boot_up_check_timer, jiffies+5*HZ);	mod_timer(&md_boot_up_check_timer, jiffies+10*HZ);	return ret;}

int send_stop_md_request(void){	CCCI_BUFF_T sys_msg;    char buf = 1;	CCCI_MSG_INF("ctl", "send stop modem request message/n");	/* prevent another reset modem action from wdt timeout IRQ during modem reset */	atomic_inc(&md_reset_on_going);	if(atomic_read(&md_reset_on_going)>1){		CCCI_MSG_INF("ctl", "One stop flow is on-going /n");		return CCCI_MD_IN_RESET;	}	if(md_boot_stage == MD_BOOT_STAGE_2){		lock_md_sleep(&buf, sizeof(char));	}		/* mask CCIF IRQ to prevent md_boot_stage from updating by CCIF LISR */	md_boot_stage = MD_BOOT_STAGE_0;	/* v1.4 20120618: mask CCIF IRQ to prevent md_boot_stage from updating by CCIF ISR */	//CCCI_MSG_INF("ctl", "stop request: mask ccci irq/n");	ccci_mask();	CCCI_INIT_MAILBOX(&sys_msg, CCCI_MD_MSG_STOP_MD_REQUEST);	ccci_system_message(&sys_msg);	return CCCI_SUCCESS;}

static int ccmni_v2_check_info(int md_id, int ch, const unsigned char *ccmni_ptr, int ccmni_len){	int ret = 0;	if ((ccmni_ptr == NULL) || (ccmni_len <= 0))	{		CCCI_MSG_INF(md_id, "net", "CCMNI%d_check_info() ptr_n or len_n error!/n", ch);		ret = -CCCI_ERR_INVALID_PARAM;		goto check_info_error;	}	//Check Header and Footer	if ((*(int*)(ccmni_ptr - CCMNI_BUFF_HEADER_SIZE) != CCMNI_BUFF_HEADER) || /		(*(int*)(ccmni_ptr + CCMNI_BUFF_DATA_FIELD_SIZE) != CCMNI_BUFF_FOOTER)) 	{		CCCI_MSG_INF(md_id, "net", "CCMNI%d_check_info() check header and footer error/n", ch);		ret = -CCCI_ERR_MEM_CHECK_FAIL;		goto check_info_error;	}	//Check End Byte	if (*(unsigned char *)((unsigned int)(ccmni_ptr + ccmni_len + 3)&0xfffffffc) != CCMNI_DATA_END)	{		CCCI_MSG_INF(md_id, "net", "CCMNI%d_check_info() check end byte error/n", ch);		ret = -CCCI_ERR_MEM_CHECK_FAIL;		goto check_info_error;	}	ret = 0;check_info_error:	return ret;}

static int __logic_dispatch_push(ccif_msg_t *msg, void *ctl_b){	logic_channel_info_t *ch_info;	int ret = 0;	logic_dispatch_ctl_block_t *ctl_block = (logic_dispatch_ctl_block_t*)ctl_b;	int md_id = ctl_block->m_md_id;	int drop = 1;	if (unlikely(msg->channel >= CCCI_MAX_CH_NUM)){		CCCI_MSG_INF(md_id, "cci", "%s get invalid logic ch id:%d/n", /							__FUNCTION__, msg->channel);		ret = -CCCI_ERR_INVALID_LOGIC_CHANNEL_ID;		goto _out;	}	ch_info = &(ctl_block->m_logic_ch_table[msg->channel]);	if (unlikely(ch_info->m_attrs&L_CH_ATTR_TX)){		CCCI_MSG_INF(md_id, "cci", "%s CH:%d %s is tx channel/n", __FUNCTION__, /							msg->channel, ch_info->m_ch_name);		ret = -CCCI_ERR_PUSH_RX_DATA_TO_TX_CHANNEL;		goto _out;	}	// check whether fifo is ready	if (!ch_info->m_kfifo_ready){		CCCI_MSG_INF(md_id, "cci", "%s CH:%d %s's kfifo is not ready/n", /							__FUNCTION__, msg->channel, ch_info->m_ch_name);		ret = -CCCI_ERR_KFIFO_IS_NOT_READY;		goto _out;	}	// Check fifo free space	if (kfifo_is_full(&ch_info->m_kfifo))	{		if (ch_info->m_attrs&L_CH_DROP_TOLERATED){			CCCI_CTL_MSG(md_id, "Drop (%08X %08X %02d %08X) is tolerated/n", /							msg->data[0], msg->data[1], msg->channel, msg->reserved);			ret = sizeof(ccif_msg_t);		} else {			// message should NOT be droped			CCCI_DBG_MSG(md_id, "cci", "kfifo full: ch:%s size:%d (%08X %08X %02d %08X)/n",							ch_info->m_ch_name, kfifo_size(&ch_info->m_kfifo),msg->data[0], 							msg->data[1], msg->channel, msg->reserved);			// disalbe CCIF interrupt here????			ret = 0; // Fix this!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!		}		goto _out;	}	// Push data	ret = kfifo_in(&ch_info->m_kfifo,msg,sizeof(ccif_msg_t));	WARN_ON(ret!=sizeof(ccif_msg_t));	ctl_block->m_has_pending_data = 1;	drop = 0;_out:	add_logic_layer_record(md_id, (ccci_msg_t*)msg, drop);	return ret;}

int __init ccci_md_init_mod_init(void){    int ret;    CCCI_MSG("Ver. %s, @ %s %s/n",ccci_version, __DATE__, __TIME__);        ret = ccci_alloc_smem();    if (ret)	return ret;	    /*     * IOREMAP the physical address where the modem firmware is stored.     * We will need to dump this, when there's an exception.     */    //md_img_vir = (int *)ioremap_nocache(MODEM_REGION_BASE, MD_IMG_DUMP_SIZE);//	 printk(KERN_ERR "----------->CCCI_MD: md_img_vir=%p./n",md_img_vir);    //if (!md_img_vir)    //{        //printk(KERN_ERR "[CCCI]:CCCI_MD[Exception] Mem dump ioremap failed/n");        //return -ENOMEM;    //}    ret=platform_init();    if (ret)    {	CCCI_MSG_INF("ctl", "platform_init failed./n");	//iounmap(md_img_vir);	return ret;    }	    ret=ccci_rpc_init();    if (ret)    {	CCCI_MSG_INF("ctl", "rpc_init failed./n");	ccci_rpc_exit();	//iounmap(md_img_vir);	return ret;    }	    // MUST register callbacks after memory is allocated	boot_register_md_func(boot_md_show, boot_md_store);	//slp_set_ccci_callback(ccci_dormancy);	ccci_md_wdt_notify_register(reset_md);	ccci_aed_cb_register(ccci_aed);	register_resume_notify(RSM_ID_MD_LOCK_DORMANT, lock_md_dormant);	register_suspend_notify(SLP_ID_MD_UNLOCK_DORMANT, unlock_md_dormant);	register_ccci_kern_func(ID_CCCI_DORMANCY, ccci_dormancy);    register_ccci_kern_func(ID_LOCK_MD_SLEEP, lock_md_sleep);	register_ccci_kern_func(ID_ACK_MD_SLEEP, ack_md_sleep);        register_filter_func("-l", ccci_msg_filter_store, ccci_msg_filter_show);    register_filter_func("-c", ccci_ch_filter_store, ccci_ch_filter_show);    wake_lock_init(&trm_wake_lock, WAKE_LOCK_SUSPEND, "ccci_trm");    spin_lock_init(&md_slp_lock);        return 0;}

static int ccmni_v2_receive(ccmni_v2_instance_t *ccmni, const unsigned char *ccmni_ptr, int ccmni_len){	int						packet_type, ret = 0;	struct sk_buff			*skb;	ccmni_v2_ctl_block_t	*ctl_b = (ccmni_v2_ctl_block_t*)ccmni->owner;	int						md_id = ctl_b->m_md_id;	if ((ccmni == NULL) || (ccmni_ptr == NULL) || (ccmni_len <= 0))	{		CCCI_MSG_INF(md_id, "net", "CCMNI%d_receive: invalid private data/n", ccmni->channel);		ret = -1;	}	skb = dev_alloc_skb(ccmni_len);	if (skb)	{		packet_type = ccmni_ptr[0] & 0xF0;		memcpy(skb_put(skb, ccmni_len), ccmni_ptr, ccmni_len);		ccmni_make_etherframe(skb->data - ETH_HLEN, ccmni->dev->dev_addr, packet_type);		skb_set_mac_header(skb, -ETH_HLEN);		skb->dev = ccmni->dev;		if(packet_type == IPV6_VERSION)		{			skb->protocol  = htons(ETH_P_IPV6);		}		else		{			skb->protocol  = htons(ETH_P_IP);		}		//skb->ip_summed = CHECKSUM_UNNECESSARY;		skb->ip_summed = CHECKSUM_NONE;		ret = netif_rx(skb);		CCCI_CCMNI_MSG(md_id, "CCMNI%d invoke netif_rx()=%d/n", ccmni->channel, ret);		ccmni->dev->stats.rx_packets++;		ccmni->dev->stats.rx_bytes	+= ccmni_len;		CCCI_CCMNI_MSG(md_id, "CCMNI%d rx_pkts=%d, stats_rx_bytes=%d/n",ccmni->channel, /			ccmni->dev->stats.rx_packets,ccmni->dev->stats.rx_bytes);		ret = 0;	}	else	{		CCCI_MSG_INF(md_id, "net", "CCMNI%d Socket buffer allocate fail/n", ccmni->channel);		ret = -CCCI_ERR_MEM_CHECK_FAIL;	}	return ret;}

void ccmni_v2_dump(int md_id){	int i=0,port=0;	ccmni_v2_ctl_block_t *ctl_b = (ccmni_v2_ctl_block_t *)ccmni_ctl_block[md_id];		CCCI_MSG_INF(md_id, "ctl", "ccmni v2 dump start/n");	for(port=0;port<CCMNI_V2_PORT_NUM;port++){		ccmni_v2_instance_t *ccmni= ctl_b->ccmni_v2_instance[port];		CCCI_MSG_INF(md_id, "ctl", "Port%d RX CONTROL: read_out=%d, avai_out=%d, avai_in=%d,q_len=%d/n",port,			ccmni->shared_mem->rx_control.read_out,			ccmni->shared_mem->rx_control.avai_out,			ccmni->shared_mem->rx_control.avai_in,			ccmni->shared_mem->rx_control.q_length);		CCCI_MSG_INF(md_id, "ctl", "Port%d RX ringbuff:/n",port);		for(i=0; i<CCMNI_CTRL_Q_RX_SIZE; i++)		{			if(ccmni->shared_mem->q_rx_ringbuff[i].ptr!=NULL && ccmni->shared_mem->q_rx_ringbuff[i].len!=0)				CCCI_MSG_INF(md_id,"ctl","[%d]: ptr=%08X len=%d/n",i,(int)(ccmni->shared_mem->q_rx_ringbuff[i].ptr), ccmni->shared_mem->q_rx_ringbuff[i].len);		}		CCCI_MSG_INF(md_id, "ctl", "Port%d TX CONTROL: read_out=%d, avai_out=%d, avai_in=%d,q_len=%d/n",port,			ccmni->shared_mem->tx_control.read_out,			ccmni->shared_mem->tx_control.avai_out,			ccmni->shared_mem->tx_control.avai_in,			ccmni->shared_mem->tx_control.q_length);		CCCI_MSG_INF(md_id, "ctl", "Port%d TX ringbuff:/n",port);				for(i=0; i < CCMNI_CTRL_Q_TX_SIZE; i++)		{			if(ccmni->shared_mem->q_tx_ringbuff[i].ptr!=NULL&&ccmni->shared_mem->q_tx_ringbuff[i].len!=0)				CCCI_MSG_INF(md_id,"ctl","[%d]: ptr=%08X len=%d/n",i,(int)(ccmni->shared_mem->q_tx_ringbuff[i].ptr),ccmni->shared_mem->q_tx_ringbuff[i].len);		}	}	CCCI_MSG_INF(md_id, "ctl", "ccmni v2 dump end/n");}

int ccmni_v2_init(int md_id){	int						count, ret, curr;	ccmni_v2_ctl_block_t	*ctl_b;	char					ccmni_lock_name[32];	// Create control block structure	ctl_b = (ccmni_v2_ctl_block_t *)kmalloc(sizeof(ccmni_v2_ctl_block_t), GFP_KERNEL);	if(ctl_b == NULL)		return -CCCI_ERR_GET_MEM_FAIL;	memset(ctl_b, 0, sizeof(ccmni_v2_ctl_block_t));	ccmni_ctl_block[md_id] = ctl_b;	// Init ctl_b	ctl_b->m_md_id = md_id;	ctl_b->ccmni_notifier.call = ccmni_v2_notifier_call;	ctl_b->ccmni_notifier.next = NULL;	for(count = 0; count < CCMNI_CHANNEL_CNT; count++)	{		ret = ccmni_v2_create_instance(md_id, count);		if (ret != 0) {			CCCI_MSG_INF(md_id, "net", "CCMNI%d create instance fail: %d/n", count, ret);			goto _CCMNI_INSTANCE_CREATE_FAIL;		} else {			CCCI_DBG_MSG(md_id, "net", "CCMNI%d create instance ok!/n", count);		}	}	ret = md_register_call_chain(md_id, &ctl_b->ccmni_notifier);	if(ret) {		CCCI_MSG_INF(md_id, "net", "md_register_call_chain fail: %d/n", ret);		goto _CCMNI_INSTANCE_CREATE_FAIL;	}	snprintf(ccmni_lock_name, 32, "cc%dmni wake lock", md_id);    	wake_lock_init(&ctl_b->ccmni_wake_lock, WAKE_LOCK_SUSPEND, ccmni_lock_name);	return ret;_CCMNI_INSTANCE_CREATE_FAIL:	for(curr=0; curr<count-1; curr++) {		ccmni_v2_destroy_instance(md_id, curr);	}	kfree(ctl_b);	ccmni_ctl_block[md_id] = NULL;	return ret;}

void ccci_aed(unsigned int dump_flag, char *aed_str){	#define AED_STR_LEN		(512)	int *ex_log_addr = NULL;	int ex_log_len = 0;	int *md_img_addr = NULL;	int md_img_len = 0;	int info_str_len = 0;	char buff[AED_STR_LEN];	info_str_len = strlen(aed_str);	info_str_len += strlen(image_buf);	if(info_str_len > AED_STR_LEN){		CCCI_MSG_INF("ctl", "Info string is too long, num:%d/n", info_str_len);		buff[AED_STR_LEN-1] = '/0'; // Cut string length to AED_STR_LEN	}	snprintf(buff, AED_STR_LEN, "%s%s", aed_str, image_buf);	if(dump_flag & CCCI_AED_DUMP_EX_MEM){		ex_log_addr = md_ex_log;		ex_log_len = MD_EX_LOG_SIZE;	}	if(dump_flag & CCCI_AED_DUMP_MD_IMG_MEM){		md_img_addr = md_img_vir;		md_img_len = MD_IMG_DUMP_SIZE;	}	#ifdef CONFIG_MTK_AEE_FEATURE	aed_md_exception2(ex_log_addr, ex_log_len, md_img_addr, md_img_len, buff);	#endif}

static void md_boot_up_timeout_func(unsigned long data  __always_unused){	CCCI_BUFF_T sys_msg;	CCCI_MSG_INF("ctl", "Time out! Notify Deamon/n");	CCCI_INIT_MAILBOX(&sys_msg, CCCI_MD_MSG_BOOT_TIMEOUT);	ccci_system_message(&sys_msg);}

int register_to_logic_ch(int md_id, int ch, void (*func)(void*), void *owner){	logic_channel_info_t *ch_info;	int ret = 0;	unsigned long flags;	logic_dispatch_ctl_block_t *ctl_b;	ctl_b = logic_dispatch_ctlb[md_id];	ch_info = &(ctl_b->m_logic_ch_table[ch]);		if ((ch_info->m_attrs&L_CH_ATTR_TX) && (func != NULL)) {		return 0;	}	spin_lock_irqsave(&ch_info->m_lock, flags);	// Check whether call back function has been registered	if (!ch_info->m_register) {		ch_info->m_register = 1;		ch_info->m_call_back = func;		ch_info->m_owner = owner;	} else {		CCCI_MSG_INF(md_id, "cci", "%s fail: %s(ch%d) cb func has registered/n", /					__FUNCTION__, ch_info->m_ch_name, ch_info->m_ch_id);		ret = -CCCI_ERR_LOGIC_CH_HAS_REGISTERED;	}	spin_unlock_irqrestore(&ch_info->m_lock, flags);	return ret;}

static int ccci_tty_writeable(tty_instance_t	*tty_instance){	int 	read, write, size,length;	read   = tty_instance->shared_mem->tx_control.read;	write  = tty_instance->shared_mem->tx_control.write;	length = tty_instance->shared_mem->tx_control.length;	if (read == write)	{		size = length - 1;	}	else if (read < write)	{		size =  length - write;		size += read;	}	else	{		size = read - write - 1;	}	if ((size <= 0) || (length <= 0)) {		CCCI_MSG_INF(tty_instance->m_md_id, "tty", "writeable: read=%d,write=%d,length=%d,size=%d/n",			read, write, length, size);	}	return size;}

int logic_layer_reset(int md_id){	logic_dispatch_ctl_block_t	*ctl_b;	ccif_t						*ccif;	unsigned int				ref_jiffies = jiffies;	int							i;	ctl_b = logic_dispatch_ctlb[md_id];	ccif = ctl_b->m_ccif;	// Check whether there is on-going isr/tasklet	while ((CCIF_TOP_HALF_RUNNING&ccif->m_status)||ctl_b->m_running||ctl_b->m_has_pending_data){		yield();		if ((jiffies-ref_jiffies)>2*HZ){			CCCI_MSG_INF(ctl_b->m_md_id, "cci", "%s wait isr/tasklet more than 2 seconds/n", __FUNCTION__);			break;		}	}	// isr/tasklet done, then reset ccif and logic channel	ccif->ccif_reset_to_default(ccif);	for(i=0; i<CCCI_MAX_CH_NUM; i++)	{		if (ctl_b->m_logic_ch_table[i].m_kfifo_ready)			kfifo_reset(&(ctl_b->m_logic_ch_table[i].m_kfifo));	}	ctl_b->m_has_pending_data = 0;	ctl_b->m_freezed = 0;	ctl_b->m_running = 0;	//ctl_b->m_privilege = MD_BOOT_STAGE_0;	ctl_b->m_status_flag = 0;	return 0;}

static void ex_monitor_func(unsigned long data  __always_unused){	int md_ex_get, md_ex_ok_get; 	int trusted = 0;	volatile int reentrant_times;	atomic_inc(&md_ex_dump_reentrant);		do {		reentrant_times = atomic_read(&md_ex_dump_reentrant);	}while(reentrant_times != atomic_read(&md_ex_dump_reentrant));	if(reentrant_times > 1)		return;	while(1){		md_ex_get=atomic_read(&md_ex);		md_ex_ok_get=atomic_read(&md_ex_ok);		if (md_ex_get==1 && md_ex_ok_get==0) {			atomic_set(&md_ex,0);			CCCI_MSG_INF("ctl", "Only recv MD_EX, timeout trigger dump. Dump data may be not correct./n");		}else if (md_ex_get==1 && md_ex_ok_get==1) {			atomic_set(&md_ex,0);			atomic_set(&md_ex_ok,0);			CCCI_MSG_INF("ctl", "Receive MD_EX_REC_OK/n");			trusted = 1;		}else  if (md_ex_get==0 && md_ex_ok_get==1){			atomic_set(&md_ex_ok,0);			CCCI_MSG_INF("ctl", "Only Receive MD_EX_REC_OK, this may be appear after time out/n");		}		else 			CCCI_MSG_INF("ctl", "Invalid EX_Num/n");//		md_boot_stage = MD_BOOT_STAGE_0;//		atomic_set(&md_ex,0);//		ccci_disable_nosync();		ccci_md_exception(trusted);		atomic_dec(&md_ex_dump_reentrant);		do {			reentrant_times = atomic_read(&md_ex_dump_reentrant);		}while(reentrant_times != atomic_read(&md_ex_dump_reentrant));		if(reentrant_times == 0)			break;	}}

int send_start_md_request(void){	CCCI_BUFF_T sys_msg;	CCCI_MSG_INF("ctl", "send start modem request message/n");	CCCI_INIT_MAILBOX(&sys_msg, CCCI_MD_MSG_START_MD_REQUEST);	ccci_system_message(&sys_msg);	return CCCI_SUCCESS;}

static int  __ccif_v1_write_phy_ch_data(ccif_t* ccif, unsigned int buf[], int retry_en){    int             ret = 0;    unsigned int    busy;    unsigned long    flag;    unsigned int    retry_count = 200;    unsigned int    ch;    ccif_msg_t        *tx_msg;    int md_id = ccif->m_md_id;    CCCI_FUNC_ENTRY(md_id);    if(retry_en == 0)        retry_count = 1;    do{        spin_lock_irqsave(&ccif->m_lock, flag);        busy=ccci_read32(CCIF_BUSY(ccif->m_reg_base));        ch = ccif->m_tx_idx;        if (busy&(1<<ch)) {                            ret = -CCCI_ERR_CCIF_NO_PHYSICAL_CHANNEL;            if (busy != 0xff) {                CCCI_DBG_MSG(md_id, "cci", "Wrong Busy value: 0x%X/n", busy);            }            spin_unlock_irqrestore(&ccif->m_lock,flag);                        udelay(1);            retry_count--;        } else {            ccci_write32(CCIF_BUSY(ccif->m_reg_base), 1<<ch);            ccif->m_tx_idx++;            ccif->m_tx_idx &= (CCIF_STD_V1_MAX_CH_NUM-1);            //spin_unlock_irqrestore(&ccif->m_lock,flag);                        //mb(); // Note here, make sure data has write to memory be really send            tx_msg = (ccif_msg_t*)(CCIF_TXCHDATA(ccif->m_reg_base));            ccci_write32(&(tx_msg[ch].data[0]), buf[0]);            ccci_write32(&(tx_msg[ch].data[1]), buf[1]);            ccci_write32(&(tx_msg[ch].channel), buf[2]);            ccci_write32(&(tx_msg[ch].reserved), buf[3]);            //mb();            ccci_write32(CCIF_TCHNUM(ccif->m_reg_base), ch);                        spin_unlock_irqrestore(&ccif->m_lock,flag);            ret = sizeof(ccif_msg_t);            break;        }    }while(retry_count>0);    if(lg_ch_tx_debug_enable[md_id] & (1<< buf[2]))         CCCI_MSG_INF(md_id, "cci", "[TX]: %08X, %08X, %02d, %08X (%02d)/n",             buf[0], buf[1], buf[2], buf[3], ch);    return ret;}

int lock_md_sleep(char *buf, unsigned int len){	unsigned long flag;	int ret = 0;	spin_lock_irqsave(&md_slp_lock, flag);	if (buf[0]) {		//if (++md_slp_cnt == 1)		//	md_slp_lock_ack = 0;		++md_slp_cnt;	}	else {		if (md_slp_cnt == 0) {			CCCI_MSG_INF("ctl", "unlock md slp mis-match lock(%s, 0)/n", current->comm);			spin_unlock_irqrestore(&md_slp_lock, flag);			return ret;		}				//if (--md_slp_cnt == 0)		//	md_slp_unlock_ack = 0;		--md_slp_cnt;	}	spin_unlock_irqrestore(&md_slp_lock, flag);		if (md_slp_cnt == 1)		ret = ccci_write_mailbox_with_resv(CCCI_SYSTEM_TX, MD_SLP_REQUEST, LOCK_MD_SLP);	else if (md_slp_cnt == 0)		ret = ccci_write_mailbox_with_resv(CCCI_SYSTEM_TX, MD_SLP_REQUEST, UNLOCK_MD_SLP);		if (ret == 0) {		spin_lock_irqsave(&md_slp_lock, flag);		if (buf[0])			--md_slp_lock_ack;		else			--md_slp_unlock_ack;		spin_unlock_irqrestore(&md_slp_lock, flag);			}		CCCI_MSG_INF("ctl", "%s request md sleep %d (%d, %d, %d): %d/n", 		current->comm, buf[0], md_slp_cnt, md_slp_lock_ack, md_slp_unlock_ack, ret);	return ret;}

int ccci_stop_modem(void){	int i, ret;	/*ALPS00302837: md reset happens again during reset process, this judge will cause the first reset fail*/	#if 0	//atomic_inc(&md_reset_on_going);	if(atomic_read(&md_reset_on_going)>1){		CCCI_MSG_INF("ctl", "One reset flow is on-going /n");		return -1;	}	#endif	//md_call_chain(&md_notifier,CCCI_MD_RESET);	ccci_disable();	md_call_chain(&md_notifier,CCCI_MD_RESET);	gate_md();	ccci_reset();	for (i = 0; i < NR_CCCI_RESET_USER; i++) {		reset_sta[i].is_reset = 0;	}	if(md_ex_flag) {		if((ret = ccci_load_firmware(LOAD_MD_ONLY)) <0) {	    	CCCI_MSG_INF("ctl", "load firmware fail, so modem boot fail:%d!/n", ret);	    	return -1;        }        else {	   	 	//when load firmware successfully, no need to load it again when reset modem	   	 	CCCI_MSG_INF("ctl", "load firmware successful!/n");        }		md_ex_flag = 0;	}		md_slp_cnt = 0;	md_slp_lock_ack = 0;	md_slp_unlock_ack = 0;	md_boot_stage = MD_BOOT_STAGE_0;	return CCCI_SUCCESS;}

int ccci_reset_register(char *name){    int handle, i;    CCCI_MSG_INF("ctl", "Register a reset handle/n");	    if (name == NULL) {		CCCI_MSG_INF("ctl", "Invalid reset handle name registered /n");        return CCCI_INVALID_PARAM;    }    if (down_interruptible(&ccci_reset_mutex)) {		CCCI_MSG_INF("ctl", "down_interruptible fail /n");        return -1;    }    		    for (handle = 0; handle < NR_CCCI_RESET_USER; handle++) {        if (reset_sta[handle].is_allocate == 0) {            reset_sta[handle].is_allocate = 1;            break;        }    }    if (handle < NR_CCCI_RESET_USER) {		reset_sta[handle].is_reset = 0;	up(&ccci_reset_mutex);        for (i = 0; i < NR_CCCI_RESET_USER_NAME; i++) {            if (name[i] == '/0') {                break;            } else {                reset_sta[handle].name[i] = name[i];            }        }		CCCI_MSG_INF("ctl", "Register a reset handle by %s(%d)/n", current->comm, handle);        return handle;    } 	else {	up(&ccci_reset_mutex);        ASSERT(0);        return CCCI_FAIL;    }}

int ccci_do_modem_reset(void){	CCCI_MSG_INF("ctl", "Begin to reset MD/n");	if(ccci_stop_modem() != CCCI_SUCCESS)		return -1;	ccci_start_modem();	return CCCI_SUCCESS;}

void ccmni_exit(int md_id){	int ccmni_version = 0;		if(ccci_get_sub_module_cfg(md_id, "net", (char*)&ccmni_version, sizeof(int)) != sizeof(int)) {		CCCI_MSG_INF(md_id, "net", "get ccmni version fail/n");		return;	}		switch(ccmni_version)	{		case 1:			return ccmni_v1_exit(md_id);		case 2:			return ccmni_v2_exit(md_id);		default:			CCCI_MSG_INF(md_id, "net", "[Error]invalid CCMNI version: %d/n", ccmni_version);			return;	}}

static ssize_t boot_md_store(const char *buf, size_t count){    if (down_interruptible(&ccci_mb_mutex)) {        return count;    }    if (md_boot_stage == MD_BOOT_STAGE_0) {        if (!ready2boot()) {            CCCI_MSG_INF("ctl", "systme is not ready/n");        } else {            boot_md();        }    } else {        CCCI_MSG_INF("ctl", "MD already in boot stage %d/n", md_boot_stage);    }    up(&ccci_mb_mutex);    return count;}

// Note: This is a common functionstatic irqreturn_t __ccif_irq_handler(int irq, void *data){    int ret;    ccif_t *ccif = (ccif_t*)data;    ret = ccif->ccif_intr_handler(ccif);    if(ret){        CCCI_MSG_INF(ccif->m_md_id, "cci", "ccif_irq_handler fail: %d!/n", ret);    }        return IRQ_HANDLED;}

int scan_image_list(int md_id, char fmt[], int out_img_list[],		    int img_list_size){	int i;	int img_num = 0;	char full_path[64] = { 0 };	char img_name[32] = { 0 };	struct file *filp = NULL;	for (i = 0; i < (sizeof(type_str) / sizeof(char *)); i++) {		snprintf(img_name, 32, fmt, md_id + 1, type_str[i]);		/*  Find at CIP first */		snprintf(full_path, 64, "%s%s", CONFIG_MODEM_FIRMWARE_CIP_PATH,			 img_name);		CCCI_MSG_INF(md_id, "chr", "Find:%s/n", full_path);		filp = filp_open(full_path, O_RDONLY, 0644);		if (IS_ERR(filp)) {			/*  Find at default */			snprintf(full_path, 64, "%s%s",				 CONFIG_MODEM_FIRMWARE_PATH, img_name);			CCCI_MSG_INF(md_id, "chr", "Find:%s/n", full_path);			filp = filp_open(full_path, O_RDONLY, 0644);			if (IS_ERR(filp)) {				CCCI_MSG_INF(md_id, "chr",					     "%s not found(%d,%d)/n", full_path,					     img_num, i);				continue;			}		}		/*  Run here means open image success */		filp_close(filp, NULL);		CCCI_MSG_INF(md_id, "chr", "Image:%s found/n", full_path);		if (img_num < img_list_size)			out_img_list[img_num] = i;		img_num++;	}	if (img_num < 1)		CCCI_ERR_INF(md_id, "chr", "Error! - No Image found/n");	return img_num;}

logic_channel_info_t* get_logic_ch_info(int md_id, int ch_id){	logic_channel_info_t *ch_info;	logic_dispatch_ctl_block_t *ctl_block;	if (unlikely(ch_id >= CCCI_MAX_CH_NUM)){		CCCI_MSG_INF(md_id, "cci", "%s fail: invalid logic ch%d/n", __FUNCTION__, ch_id);		return NULL;	}	ctl_block = logic_dispatch_ctlb[md_id];	ch_info = &(ctl_block->m_logic_ch_table[ch_id]);	return ch_info;}

int get_logic_ch_data_len(logic_channel_info_t *ch_info){	if (unlikely(ch_info == NULL)){		CCCI_MSG("%s get invalid ch info/n", __FUNCTION__);		return 0;	}	if (unlikely(ch_info->m_attrs&L_CH_ATTR_TX)){		CCCI_MSG_INF(ch_info->m_md_id, "cci", "%s fail: %s(ch%d) is tx /n", /						__FUNCTION__, ch_info->m_ch_name, ch_info->m_ch_id);		return 0;	}	// check whether fifo is ready	if (unlikely(!ch_info->m_kfifo_ready)){		CCCI_MSG_INF(ch_info->m_md_id, "cci", "%s fail: %s(ch%d) kfifo not ready/n", /						__FUNCTION__, ch_info->m_ch_name, ch_info->m_ch_id);		return 0;	}	// Check fifo data length	return kfifo_len(&ch_info->m_kfifo);}

void set_curr_md_state(int md_id, int state){	logic_dispatch_ctl_block_t *ctl_b;	//CCCI_MSG("%s update md sys id:%d to state:%d/n", __FUNCTION__, md_id+1, state);	if(unlikely(!md_enabled[md_id])) {		CCCI_MSG_INF(md_id, "md sys%d is not enable/n", md_id+1);		return;	}	ctl_b = logic_dispatch_ctlb[md_id];	ctl_b->m_privilege = state;}