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