static void autok_module_exit(void) { //int ret; remove_proc_entry(LTE_AUTOK_PROC_NAME, NULL); KAL_RAWPRINT(("/proc/%s removed\n", LTE_AUTOK_PROC_NAME)); }
//static //void __exit mtlte_sys_sdio_driver_exit(void) void mtlte_sys_sdio_driver_exit(void) { KAL_RAWPRINT(("[EXIT] =======> lte_sdio_driver_exit\n")); sdio_onoff_module_exit(); KAL_DESTROYMUTEX(<e_dev.thread_kick_lock) ; sdio_unregister_driver(&mtlte_driver); KAL_RAWPRINT(("[EXIT] sdio_unregister_driver OK. \n")); #if EMCS_SDIO_DRVTST mtlte_dev_test_drvdeinit() ; KAL_RAWPRINT(("[EXIT] mtlte_dev_test_drvdeinit OK. \n")); #endif /* denit the expt layer */ mtlte_expt_deinit() ; KAL_RAWPRINT(("[EXIT] mtlte_expt_deinit OK. \n")); /* denit the data flow layer */ mtlte_df_deinit() ; KAL_RAWPRINT(("[EXIT] mtlte_df_deinit OK. \n")); /* denit the hif layer */ mtlte_hif_sdio_deinit() ; KAL_RAWPRINT(("[EXIT] mtlte_hif_sdio_deinit OK. \n")); #ifdef MT_LTE_AUTO_CALIBRATION autok_module_exit(); #endif KAL_RAWPRINT(("[EXIT] <======= lte_sdio_driver_exit\n")); }
int mtlte_df_probe(void) { unsigned int i ; #if USE_MULTI_QUE_DISPATCH char rxq_work_name[RXQ_NUM][50]; #endif KAL_DBGPRINT(KAL, DBG_INFO,("====> %s\n",KAL_FUNC_NAME)) ; for (i=0; i<TXQ_NUM ; i++){ skb_queue_head_init(<e_df_core.ul_xmit_wait_queue[i]); } skb_queue_head_init(<e_df_core.ul_xmit_free_queue); for (i=0; i<RXQ_NUM ; i++){ lte_df_core.dl_pkt_in_use[i] = 0 ; skb_queue_head_init(<e_df_core.dl_recv_wait_queue[i]); } #if BUFFER_POOL_FOR_EACH_QUE for (i=0; i<RXQ_NUM ; i++){ skb_queue_head_init(<e_df_core.dl_buffer_pool_queue[i]); mtlte_df_DL_prepare_skb_for_swq(i) ; KAL_RAWPRINT(("The DL Buffer Pool packet of RXQ%d is %d\r\n", i, lte_df_core.dl_buffer_pool_queue[i].qlen)) ; KAL_RAWPRINT(("The skb size of RXQ%d is %d\r\n", i, lte_df_core.df_skb_alloc_size[i])) ; } #else skb_queue_head_init(<e_df_core.dl_buffer_pool_queue); mtlte_df_DL_prepare_skb_for_swq() ; KAL_RAWPRINT(("The DL Buffer Pool packet is %d\r\n", lte_df_core.dl_buffer_pool_queue.qlen)) ; #endif #if FORMAL_DL_FLOW_CONTROL for (i=0; i<RXQ_NUM ; i++){ lte_df_core.fl_ctrl_full[i] = false; atomic_set(<e_df_core.fl_ctrl_counter[i], 0); } #endif KAL_DBGPRINT(KAL, DBG_INFO,("<==== %s\n",KAL_FUNC_NAME)) ; return KAL_SUCCESS ; }
static int mtlte_sys_check_sdio_thread_stop(void) { unsigned int cnt = 500 ; // wait 5 seconds while (cnt--) { if (lte_dev.sdio_thread_state == SDIO_THREAD_IDLE) { KAL_RAWPRINT(("[REMOVE] mtlte_sys_check_sdio_thread_stop OK !!\r\n")); return 0 ; } KAL_SLEEP_MSEC(10) ; } KAL_RAWPRINT(("[REMOVE ERR] mtlte_sys_check_sdio_thread_stop FAIL !!\r\n")); return -1 ; }
static int autok_module_init(void) { //s_proc = create_proc_entry(LTE_AUTOK_PROC_NAME, 0660, NULL); s_proc = proc_create(LTE_AUTOK_PROC_NAME, 0660, NULL, <e_autok_proc_ops); if (s_proc == NULL) { remove_proc_entry(LTE_AUTOK_PROC_NAME, NULL); KAL_RAWPRINT(("Error: Could not initialize /proc/%s\n", LTE_AUTOK_PROC_NAME)); return -ENOMEM; } //s_proc->write_proc = lte_autok_writeproc; //s_proc->read_proc = lte_autok_readproc; s_proc->gid = 1000; KAL_RAWPRINT(("/proc/%s created\n", LTE_AUTOK_PROC_NAME)); return 0; /* everything is ok */ }
static int mtlte_sys_sdio_remove_irq(struct sdio_func *sdiofunc) { int ret = 0 ; KAL_RAWPRINT(("[REMOVE] =======> mtlte_sys_sdio_remove_irq\n")); lte_sdio_disable_eirq(); sdio_claim_host(sdiofunc); ret = sdio_release_irq(sdiofunc); sdio_release_host(sdiofunc); if (ret){ KAL_RAWPRINT(("[REMOVE] XXXXXX mtlte_sys_sdio_remove_irq fail, %d \n", ret )); return (ret); } KAL_RAWPRINT(("[REMOVE] <======= mtlte_sys_sdio_remove_irq\n")); return 0 ; }
static int mtlte_sys_sdio_setup_irq(struct sdio_func *sdiofunc) { int ret = 0 ; KAL_RAWPRINT(("[PROBE] =======> mtlte_sys_sdio_setup_irq\n")); sdio_claim_host(sdiofunc); ret = sdio_claim_irq(sdiofunc, mtlte_sys_lte_sdio_isr); sdio_release_host(sdiofunc); if (ret){ KAL_RAWPRINT(("[PROBE] XXXXXX mtlte_sys_sdio_setup_irq fail, %d \n", ret )); return (ret); } mtlte_hif_enable_interrupt_at_probe(); lte_sdio_enable_eirq(); KAL_RAWPRINT(("[PROBE] <======= mtlte_sys_sdio_setup_irq\n")); return 0 ; }
inline void mtlte_sys_disable_int_isr(struct sdio_func *func) { int err_ret ; unsigned int value ; KAL_DBGPRINT(KAL, DBG_LOUD,("[INT] mtlte_sys_disable_int_isr <==========>\r\n")) ; value = W_INT_EN_CLR ; sdio_claim_host(func); err_ret = sdio_writesb(func,SDIO_IP_WHLPCR, &value, 4); sdio_release_host(func); if (err_ret){ KAL_RAWPRINT(("[ISR] XXXXXX mtlte_sys_disable_int_isr fail, %d \n", err_ret )); return ; } }
int mtlte_df_remove_phase1(void) { #if USE_MULTI_QUE_DISPATCH int i ; #endif KAL_DBGPRINT(KAL, DBG_INFO,("====> %s\n",KAL_FUNC_NAME)) ; #if USE_MULTI_QUE_DISPATCH for (i=0; i<RXQ_NUM ; i++){ flush_workqueue(lte_df_core.rxq_dispatch_work_queue[i]); } #else flush_workqueue(lte_df_core.dl_dispatch_work_queue); #endif flush_workqueue(lte_df_core.dl_reload_work_queue); KAL_RAWPRINT(("[REMOVE] All queue work is flushed ~~ \r\n")) ; KAL_DBGPRINT(KAL, DBG_INFO,("<==== %s\n",KAL_FUNC_NAME)) ; return 0 ; }
static void mtlte_sys_sdio_remove(struct sdio_func *func) { KAL_RAWPRINT(("[REMOVE] =======> mtlte_sys_sdio_remove\n")); #ifdef MT_LTE_AUTO_CALIBRATION mtlte_sdio_probe_done = 0; #endif #ifdef MT_LTE_ONLINE_TUNE_SUPPORT ot_set_dev_sleep_sts((void*)lte_dev.sdio_func->card->host, 1); #endif lte_dev.card_exist = 0 ; mtlte_sys_sdio_remove_irq(func) ; KAL_RAWPRINT(("[REMOVE] sdio_release_irq Done. \n")); mtlte_hif_sdio_txrx_proc_enable(0) ; KAL_RAWPRINT(("[REMOVE] mtlte_hif_sdio_txrx_proc_enable disalbe it. \n")); if (!IS_ERR(lte_dev.sdio_thread)){ kthread_stop(lte_dev.sdio_thread); } KAL_RAWPRINT(("[REMOVE] kthread_stop OK. \n")); /* check all the hif jobs are stopped */ mtlte_sys_check_sdio_thread_stop() ; KAL_RAWPRINT(("[REMOVE] mtlte_sys_check_sdio_thread_stop Done. \n")); #if EMCS_SDIO_DRVTST mtlte_dev_test_detach(LTE_TEST_DEVICE_MINOR) ; #endif mtlte_expt_remove(); /* do phase 1 removing */ mtlte_hif_sdio_remove_phase1() ; KAL_RAWPRINT(("[REMOVE] mtlte_hif_sdio_remove_phase1 Done. \n")); mtlte_df_remove_phase1() ; KAL_RAWPRINT(("[REMOVE] mtlte_df_remove_phase1 Done. \n")); /* do phase 2 removing */ mtlte_hif_sdio_remove_phase2() ; KAL_RAWPRINT(("[REMOVE] mtlte_hif_sdio_remove_phase2 Done. \n")); mtlte_df_remove_phase2(); KAL_RAWPRINT(("[REMOVE] mtlte_df_remove_phase2 Done. \n")); /* disable the SDIO interrupt and */ sdio_close_device(func) ; KAL_RAWPRINT(("[REMOVE] sdio_close_device Done. \n")); KAL_RAWPRINT(("[REMOVE] <======= mtlte_sys_sdio_remove\n")); LTE_WD_timeout_indicator = 0; return ; }
static int mtlte_sys_sdio_probe( struct sdio_func *func, const struct sdio_device_id *id) { int ret ; //char net_mac[6] ; #ifdef MT_LTE_AUTO_CALIBRATION #ifndef NATIVE_AUTOK int lte_autok_finish_next; #endif BOOTMODE btmod; #endif unsigned int orig_WHCR = 0; unsigned int changed_WHCR = 0; unsigned int orig_WPLRCR = 0; unsigned int changed_WPLRCR = 0; KAL_RAWPRINT(("[PROBE] =======> mt_lte_sdio_probe\n")); #ifdef MT_LTE_AUTO_CALIBRATION mtlte_sdio_probe_done = 0; #endif LTE_WD_timeout_indicator = 0; lte_dev.card_exist = 1 ; lte_dev.sdio_thread_kick = 0 ; lte_dev.sdio_thread_kick_isr = 0 ; lte_dev.sdio_thread_kick_own_timer = 0 ; lte_dev.sdio_thread_state = SDIO_THREAD_IDLE ; lte_dev.sdio_func = func ; /* Because MT7208 SDIO device add the r/w busy function, We only can use block read at Tx/Rx port. This quirk is force host to use block access if the transfer byte is equal to n*block size */ // func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE; /* Because MT7208 SDIO device not support read 512 byte in data block This quirk is set byte mode size to max 511 byte */ func->card->quirks |= MMC_QUIRK_BROKEN_BYTE_MODE_512; /* enable the sdio device function */ if ((ret = sdio_open_device(func)) != KAL_SUCCESS){ KAL_RAWPRINT(("[PROBE] XXXXXX mt_lte_sdio_probe -sdio_open_device fail \n")); goto OPEN_FAIL ; } #ifdef MT_LTE_AUTO_CALIBRATION btmod = get_boot_mode(); printk("btmod = %d\n", btmod); if ((btmod!=META_BOOT) && (btmod!=FACTORY_BOOT) && (btmod!=ATE_FACTORY_BOOT)) { #ifndef NATIVE_AUTOK lte_autok_finish = 0; lte_autok_finish_next = lte_autok_finish + 1; // KAL_RAWPRINT(("[AUTOK] =======> mtlte_sys_trigger_auto_calibration\n")); mtlte_sys_trigger_auto_calibration(NULL); // KAL_RAWPRINT(("lte_autok_finish = %d\n", lte_autok_finish)); while (lte_autok_finish_next != lte_autok_finish){ KAL_SLEEP_MSEC(50); } #else //wait_sdio_autok_ready((void*)lte_dev.sdio_func->card->host); wait_sdio_autok_ready((void*)lte_dev.sdio_func->card->host, force_autok); force_autok = 0; #endif // KAL_RAWPRINT(("lte_autok_finish = %d\n", lte_autok_finish)); } #endif #ifdef MT_LTE_ONLINE_TUNE_SUPPORT ot_set_dev_sleep_sts((void*)lte_dev.sdio_func->card->host, 0); ot_dev_wakeup( (void*)lte_dev.sdio_func->card->host ); #endif mtlte_hif_register_hif_to_sys_wake_callback(mtlte_sys_sdio_kick_thread, 0) ; mtlte_hif_register_hif_to_sys_sleep_callback(mtlte_sys_sdio_sleep_thread, 0) ; if ((ret = mtlte_hif_sdio_probe()) != KAL_SUCCESS){ KAL_RAWPRINT(("[PROBE] XXXXXX mt_lte_sdio_probe -mtlte_hif_sdio_probe fail \n")); goto HIF_PROBE_FAIL ; } /* sync with the Device FW */ #if 1 if ((ret = mtlte_hif_sdio_wait_FW_ready()) != KAL_SUCCESS){ KAL_RAWPRINT(("[PROBE] XXXXXX mt_lte_sdio_probe -mtlte_hif_sdio_wait_FW_ready fail \n")); goto HIF_PROBE_FAIL ; } #endif /* do the data flow layer probing */ if ((ret = mtlte_df_probe()) != KAL_SUCCESS){ KAL_RAWPRINT(("[PROBE] XXXXXX mt_lte_sdio_probe -mtlte_df_probe fail \n")); goto DF_PROBE_FAIL ; } if ((ret = mtlte_expt_probe()) != KAL_SUCCESS){ KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -sdio_register_driver fail \n")); goto DF_PROBE_FAIL ; } KAL_DBGPRINT(KAL, DBG_ERROR,("[%s] set the WPLRCR for NEW FPGA... \n",KAL_FUNC_NAME)) ; /* Set the Default value of RX MAX Report Num due MT6290 SDIO HW's flexibility */ sdio_func1_rd(SDIO_IP_WHCR, &orig_WHCR, 4); changed_WHCR = orig_WHCR | RPT_OWN_RX_PACKET_LEN; sdio_func1_wr(SDIO_IP_WHCR, &changed_WHCR, 4); sdio_func1_rd(SDIO_IP_WPLRCR, &orig_WPLRCR, 4); changed_WPLRCR = orig_WPLRCR; changed_WPLRCR &= (~(RX_RPT_PKT_LEN(0))); changed_WPLRCR |= MT_LTE_RXQ0_MAX_PKT_REPORT_NUM<<(8*0); changed_WPLRCR &= (~(RX_RPT_PKT_LEN(1))); changed_WPLRCR |= MT_LTE_RXQ1_MAX_PKT_REPORT_NUM<<(8*1); changed_WPLRCR &= (~(RX_RPT_PKT_LEN(2))); changed_WPLRCR |= MT_LTE_RXQ2_MAX_PKT_REPORT_NUM<<(8*2); changed_WPLRCR &= (~(RX_RPT_PKT_LEN(3))); changed_WPLRCR |= MT_LTE_RXQ3_MAX_PKT_REPORT_NUM<<(8*3); sdio_func1_wr(SDIO_IP_WPLRCR, &changed_WPLRCR, 4); #if EMCS_SDIO_DRVTST if ((ret = mtlte_dev_test_probe(LTE_TEST_DEVICE_MINOR, &func->dev)) != KAL_SUCCESS){ KAL_RAWPRINT(("[PROBE] XXXXXX mt_lte_sdio_probe -mtlte_dev_test_probe %d fail \n", LTE_TEST_DEVICE_MINOR)); goto PROBE_TEST_DRV_FAIL ; } #endif /* Sync with FW */ //TODO5: /* start the kthread */ lte_dev.sdio_thread = kthread_run(mtlte_sys_sdio_thread, <e_dev, "mt_sdio_kthread"); if (IS_ERR(lte_dev.sdio_thread)) { ret = -EBUSY ; KAL_RAWPRINT(("[PROBE] XXXXXX mt_lte_sdio_probe -kthread_run fail \n")); goto CREATE_THREAD_FAIL; } /* Enable the SDIO TXRX handle process */ mtlte_hif_sdio_txrx_proc_enable(1) ; KAL_RAWPRINT(("[PROBE] mtlte_hif_sdio_txrx_proc_enable enalbe it. \n")); // Test the WHISR read before enable interrupt for 6575 debug //mtlte_hif_sdio_get_driver_own(); //sdio_func1_rd(SDIO_IP_WHISR, hif_sdio_handler.enh_whisr_cache,sizeof(sdio_whisr_enhance)); /* enable the sdio interrupt service */ if ((ret = mtlte_sys_sdio_setup_irq(func)) != KAL_SUCCESS){ KAL_RAWPRINT(("[PROBE] XXXXXX mt_lte_sdio_probe -mtlte_sys_sdio_setup_irq fail \n")); goto SETUP_IRQ_FAIL; } #ifdef MT_LTE_AUTO_CALIBRATION mtlte_sdio_probe_done = 1; #endif KAL_RAWPRINT(("[PROBE] <======= mt_lte_sdio_probe\n")); return ret ; SETUP_IRQ_FAIL: kthread_stop(lte_dev.sdio_thread); CREATE_THREAD_FAIL: #if EMCS_SDIO_DRVTST mtlte_dev_test_detach(LTE_TEST_DEVICE_MINOR) ; PROBE_TEST_DRV_FAIL: #endif mtlte_df_remove_phase1() ; mtlte_df_remove_phase2() ; DF_PROBE_FAIL: mtlte_hif_sdio_remove_phase1() ; mtlte_hif_sdio_remove_phase2() ; HIF_PROBE_FAIL: sdio_close_device(func) ; OPEN_FAIL: KAL_RAWPRINT(("[PROBE FAIL] <======= mt_lte_sdio_probe\n")); return -ENODEV ; }
static int mtlte_sys_sdio_thread(void *_ltedev) { struct mtlte_dev *ltedev = (struct mtlte_dev *)_ltedev; struct timer_list give_own_timer; unsigned long give_own_deley_t; /* set same task priority with original EMCS */ struct sched_param param = { .sched_priority = RTPM_PRIO_MTLTE_SYS_SDIO_THREAD }; sched_setscheduler(current, SCHED_FIFO, ¶m); init_timer(&give_own_timer); give_own_timer.function = give_own_timer_callback; give_own_timer.data = 0; lte_dev.sdio_thread_state = SDIO_THREAD_RUNNING ; while (1) { wait_event_interruptible( ltedev->sdio_thread_wq, (kthread_should_stop() /* check this first! */ || ltedev->sdio_thread_kick || ltedev->sdio_thread_kick_isr )); if (kthread_should_stop()){ break ; } if (!ltedev->card_exist){ ltedev->sdio_thread_kick =0 ; ltedev->sdio_thread_kick_isr =0 ; continue ; } #if USING_WAKE_MD_EINT if(1 == mtlte_hif_sdio_check_fw_own()) { if(ltedev->sdio_thread_kick_isr){ mtlte_hif_sdio_get_driver_own_in_main(); } else{ mtlte_hif_sdio_wake_MD_up_EINT(); wait_event_interruptible( ltedev->sdio_thread_wq, (kthread_should_stop() || ltedev->sdio_thread_kick_isr)); if (kthread_should_stop()) { lte_sdio_turnoff_wakedevice(); break; } KAL_RAWPRINT((" [SDIO][Sleep] MD acked wake_up_EINT with isr.\n")); mtlte_hif_sdio_get_driver_own_in_main(); } } #endif ltedev->sdio_thread_kick =0; ltedev->sdio_thread_kick_isr =0; mtlte_hif_sdio_process() ; #if USING_WAKE_MD_EINT if(0 == ltedev->sdio_thread_kick && 0 == ltedev->sdio_thread_kick_isr){ if(ownback_delay_ratio){ ltedev->sdio_thread_kick_own_timer = 0; //give_own_deley_t = HZ / ownback_delay_ratio; /* direct use ownback_delay_ratio as jiffies; */ give_own_deley_t = ownback_delay_ratio; give_own_timer.expires = jiffies + give_own_deley_t; add_timer(&give_own_timer); //KAL_RAWPRINT((" [SDIO][Sleep] set up timer \n")); wait_event_interruptible( ltedev->sdio_thread_wq, (kthread_should_stop()|| ltedev->sdio_thread_kick || ltedev->sdio_thread_kick_isr || ltedev->sdio_thread_kick_own_timer)); if (kthread_should_stop()) { del_timer_sync(&give_own_timer); ltedev->sdio_thread_kick_own_timer = 0; break; } /* KAL_RAWPRINT((" [SDIO][Sleep] Thread wake up, sdio_thread_kick=%d, sdio_thread_kick_isr=%d, sdio_thread_kick_own_timer=%d \n", \ ltedev->sdio_thread_kick, ltedev->sdio_thread_kick_isr, ltedev->sdio_thread_kick_own_timer)); */ if(0 == ltedev->sdio_thread_kick && 0 == ltedev->sdio_thread_kick_isr && 1 ==ltedev->sdio_thread_kick_own_timer ){ KAL_RAWPRINT((" [SDIO][Sleep] wake up by timer \n")); #ifdef MT_LTE_ONLINE_TUNE_SUPPORT ot_set_dev_sleep_sts((void*)lte_dev.sdio_func->card->host, 1); #endif mtlte_hif_sdio_give_fw_own_in_main() ; give_own_counter++; }else{ del_timer_sync(&give_own_timer); ltedev->sdio_thread_kick_own_timer = 0; } } else{ KAL_RAWPRINT((" [SDIO][Sleep] ownback_delay_ratio == 0, give own back directly \n")); #ifdef MT_LTE_ONLINE_TUNE_SUPPORT ot_set_dev_sleep_sts((void*)lte_dev.sdio_func->card->host, 1); #endif mtlte_hif_sdio_give_fw_own_in_main() ; } } #endif } lte_dev.sdio_thread_state = SDIO_THREAD_IDLE ; KAL_RAWPRINT(("[REMOVE] =======> mtlte_sys_sdio_thread\n")); return 0 ; }
static ssize_t device_write(struct file *filp, const char __user *buff, size_t len, loff_t *off) { char *msg_ptr; char *cmd_ptr; char *level_num_str; unsigned int level_num; if (len > 199) return -EINVAL; if(copy_from_user(msg, buff, len)) { return -EINVAL; } msg[len] = '\0'; //msg_ptr = msg; //msg_ptr2 = msg2; //msg_ptr = strsep(&msg_ptr2, " "); if(0 == strcmp(msg, "lte_sdio_on")) { KAL_RAWPRINT (("Perform: %s\n", msg)); lte_sdio_on(); } else if(0 == strcmp(msg, "lte_sdio_off")) { KAL_RAWPRINT (("Perform: %s\n", msg)); lte_sdio_off(); } else if(0 == strcmp(msg, "device_pow_on")) { KAL_RAWPRINT (("Perform: %s\n", msg)); lte_sdio_device_power_on(); } else if(0 == strcmp(msg, "device_pow_off")) { KAL_RAWPRINT (("Perform: %s\n", msg)); lte_sdio_device_power_off(); } else if(0 == strcmp(msg, "card_identify")) { KAL_RAWPRINT (("Perform: %s\n", msg)); lte_sdio_card_identify(); } else if(0 == strcmp(msg, "card_remove")) { KAL_RAWPRINT (("Perform: %s\n", msg)); lte_sdio_card_remove(); } else if(0 == strcmp(msg, "eirq_mask")) { KAL_RAWPRINT (("Perform: %s\n", msg)); lte_sdio_disable_eirq(); } else if(0 == strcmp(msg, "eirq_unmask")) { KAL_RAWPRINT (("Perform: %s\n", msg)); lte_sdio_enable_eirq(); } else if(0 == strcmp(msg, "manual_enable_sleep")) { KAL_RAWPRINT (("Perform: %s\n", msg)); mtlte_hif_sdio_enable_fw_own_back(1); mtlte_sys_sdio_kick_thread(0); //temp_sdio_enable_sleep = 1; } else if(0 == strcmp(msg, "manual_disable_sleep")) { KAL_RAWPRINT (("Perform: %s\n", msg)); mtlte_hif_sdio_enable_fw_own_back(0); mtlte_sys_sdio_kick_thread(0); //temp_sdio_enable_sleep = 0; } #if USING_WAKE_MD_EINT else if(0 == strcmp(msg, "Read_fw_own")) { KAL_RAWPRINT (("Perform: %s\n", msg)); KAL_RAWPRINT (("SDIO fw_own = %d \n", mtlte_hif_sdio_check_fw_own())); } else if(0 == strcmp(msg, "Read_give_own_time")) { KAL_RAWPRINT (("Perform: %s\n", msg)); KAL_RAWPRINT (("SDIO give_own_counter = %d \n", give_own_counter)); } #endif #if FORMAL_DL_FLOW_CONTROL else if(0 == strcmp(msg, "show_flow_control_record")) { KAL_RAWPRINT (("Perform: %s\n", msg)); for(level_num=0; level_num<RXQ_NUM; level_num++){ KAL_RAWPRINT (("Biggest num of sk_buff of RXQ%d = %d \n", level_num, mtlte_df_DL_read_fl_ctrl_record(level_num))); } } #endif #if FORMAL_DL_FLOW_CONTROL_TEST else if(0 == strcmp(msg, "flow_control_status")) { KAL_RAWPRINT (("Perform: %s\n", msg)); for(level_num=0; level_num<RXQ_NUM; level_num++){ mtlte_df_DL_fl_ctrl_print_status(level_num); } mtlte_hif_print_fl_ctrl(); } #endif else { msg_ptr = msg; cmd_ptr = strsep(&msg_ptr, " "); if(0 == strcmp(cmd_ptr, "set_dbg_msg_level")){ level_num_str = strsep(&msg_ptr, " "); level_num = level_num_str[0] - 0x30; mtlte_kal_set_dbglevel(level_num); KAL_RAWPRINT (("dbg_msg_level : change to %s\n", level_num_str)); } #if USING_WAKE_MD_EINT else if(0 == strcmp(cmd_ptr, "set_ownback_delay_ratio")){ level_num_str = strsep(&msg_ptr, " "); level_num = str_to_int_main(level_num_str); ownback_delay_ratio = level_num; if(level_num){ KAL_RAWPRINT (("set_ownback_delay_ratio : change to %d/%d = 1/%d second. \n", ownback_delay_ratio, HZ, ownback_delay_ratio)); }else{ KAL_RAWPRINT (("set_ownback_delay_ratio : Turn off delay ownback!! \n")); } } #endif #if INTEGRATION_DEBUG else if(0 == strcmp(cmd_ptr, "switch_throughput_log")) { level_num_str = strsep(&msg_ptr, " "); level_num = level_num_str[0] - 0x30; KAL_RAWPRINT (("Perform: %s %d \n", msg, level_num)); if(level_num == 0) { eemcs_sdio_throughput_log = 0; log_sdio_ul_now = 0; log_sdio_dl_now = 0; log_sdio_ul_history = 0; log_sdio_dl_history = 0; log_sdio_buf_pool = 0; log_sdio_ul_txqcnt = 0; } else{eemcs_sdio_throughput_log = 1;} if(level_num == 1){log_sdio_ul_now = 1;} if(level_num == 2){log_sdio_dl_now = 1;} if(level_num == 3){log_sdio_ul_history = 1;} if(level_num == 4){log_sdio_dl_history = 1;} if(level_num == 5){log_sdio_buf_pool = 1;} if(level_num == 6){log_sdio_ul_txqcnt = 1;} } #endif #if FORMAL_DL_FLOW_CONTROL_TEST if(0 == strcmp(cmd_ptr, "manual_release_DL_buff")){ level_num_str = strsep(&msg_ptr, " "); level_num = level_num_str[0] - 0x30; level_num_str = strsep(&msg_ptr, " "); mtlte_df_DL_release_buff(level_num, str_to_int_main(level_num_str), NULL); KAL_RAWPRINT (("manual_release_DL_buff : DLQ%d - %d\n", level_num, str_to_int_main(level_num_str))); } #endif else{ KAL_RAWPRINT (("Unknown cmd : %s\n", msg)); } } return len; }
//static //KAL_INT32 __init mtlte_sys_sdio_driver_init(void) int mtlte_sys_sdio_driver_init(void) { int ret = KAL_SUCCESS ; KAL_RAWPRINT(("[INIT] =======> lte_sdio_driver_init\n")); lte_dev.card_exist = 0 ; lte_dev.sdio_func = NULL; /* init thread related parameters */ init_waitqueue_head(<e_dev.sdio_thread_wq); #ifdef MT_LTE_AUTO_CALIBRATION autok_module_init(); #endif /* init the hif layer */ if ((ret = mtlte_hif_sdio_init()) != KAL_SUCCESS){ KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -mtlte_hif_sdio_init fail \n")); goto HIF_INITFAIL ; } /* init the data flow layer */ if ((ret = mtlte_df_init()) != KAL_SUCCESS){ KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -mtlte_df_init fail \n")); goto DF_INITFAIL ; } if ((ret = mtlte_expt_init()) != KAL_SUCCESS){ KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -mtlte_expt_init fail \n")); goto DF_INITFAIL ; } #if EMCS_SDIO_DRVTST if ((ret = mtlte_dev_test_drvinit()) != KAL_SUCCESS){ KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -mtlte_dev_test_drvinit fail \n")); goto TEST_DRV_INITFAIL ; } #endif if ((ret = sdio_register_driver(&mtlte_driver)) != KAL_SUCCESS){ KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init -sdio_register_driver fail \n")); goto SDIO_REG_FAIL ; } KAL_AQUIREMUTEX(<e_dev.thread_kick_lock) ; if ((ret = sdio_onoff_module_init()) != KAL_SUCCESS){ KAL_RAWPRINT(("[INIT] XXXXXX lte_sdio_driver_init - onoff_char_dev register fail \n")); goto ONOFF_DEV_FAIL ; } KAL_RAWPRINT(("[INIT] <======= lte_sdio_driver_init\n")); return ret ; ONOFF_DEV_FAIL: sdio_unregister_driver(&mtlte_driver); SDIO_REG_FAIL : #if EMCS_SDIO_DRVTST mtlte_dev_test_drvdeinit() ; TEST_DRV_INITFAIL : #endif mtlte_df_deinit() ; DF_INITFAIL : mtlte_hif_sdio_deinit() ; HIF_INITFAIL : KAL_RAWPRINT(("[INIT FAIL] <======= lte_sdio_driver_init\n")); return ret ; }