#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <mach/irqs.h>
#include <ccif.h>
#include <ccif.h>
#include <ccci.h>

unsigned long long lg_ch_rx_debug_enable[MAX_MD_NUM];
unsigned long long lg_ch_tx_debug_enable[MAX_MD_NUM];

static int __init ccci_init(void)
{
    int ret = CCCI_ERR_MODULE_INIT_OK;
    unsigned int md_num = 1;    
    int i = 0;
    int md_en[MAX_MD_NUM] = {0};
    
    //1. Get and set Support MD nmmber
    md_num = get_md_sys_max_num();
    set_md_sys_max_num(md_num);

    //2. Get and set MD enable table
    for(i = 0; i < md_num; i++) {
        if(get_modem_is_enabled(i)){
            md_en[i] = 1;
            set_md_enable(i, 1);
        } else {
            md_en[i] = 0;
            set_md_enable(i, 0);
        }
    }

#ifdef ENABLE_CCCI_DRV_BUILDIN
CCCI_MSG("ccci_init: device_initcall_sync\n");
#else  // MODULE
CCCI_MSG("ccci_init: module_init\n");
#endif

    //3. Init ccci device table    
    ret = init_ccci_dev_node();
    if(ret) {
        CCCI_MSG("init_ccci_dev_node fail: %d\n", ret);
        ret = -CCCI_ERR_INIT_DEV_NODE_FAIL;
        goto out;
    }

    //4. Init ccci driver for each modem
    for(i = 0; i < md_num; i++)
    {
        if(md_en[i] == 0) {
            CCCI_MSG_INF(i, "cci", "md initial fail: md%d is not enabled\n", i+1);
            continue;
        }
        
        // 4.0 Init platform support function
        ret = platform_init(i, !md_en[i]);
        if (ret) {
            CCCI_MSG_INF(i, "cci", "platform_init fail: %d\n", ret);
            ret = -CCCI_ERR_INIT_PLATFORM_FAIL;
            goto platform_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "platform_init OK!\n");
        }

        // Make ccci device node
        ret = mk_ccci_dev_node(i);
        if (ret) {
            CCCI_MSG_INF(i, "cci", "mk_ccci_dev_node fail: %d\n", ret);
            ret = -CCCI_ERR_MK_DEV_NODE_FAIL;
            goto mk_node_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "mk_ccci_dev_node OK!\n");
        }

        // Statistics init
        statistics_init(i);

        // 4.1 Init ccci logical layer
        ret = ccci_logic_layer_init(i);
        if(ret) {
            CCCI_MSG_INF(i, "cci", "ccci logical layer init fail: %d\n", ret);
            ret = -CCCI_ERR_INIT_LOGIC_LAYER_FAIL;
            goto logic_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "ccci_logic_layer_init OK!\n");
        }
        
        // 4.2 Init md ctrl
        ret = ccci_md_ctrl_init(i);
        if(ret) {
            CCCI_MSG_INF(i, "cci", "ccci md ctrl init fail: %d\n", ret);
            ret = -CCCI_ERR_INIT_MD_CTRL_FAIL;
            goto mdctl_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "ccci_md_ctrl_init OK!\n");
        }
        
        // 4.3 Init char dev
        ret = ccci_chrdev_init(i);
        if (ret) {
            CCCI_MSG_INF(i, "cci", "ccci_chrdev_init fail: %d\n", ret);
            ret = -CCCI_ERR_INIT_CHAR_DEV_FAIL;
            goto char_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "ccci_chrdev_init OK!\n");
        }
        
        // 4.4 Init tty dev
        ret = ccci_tty_init(i);
        if (ret) {
            CCCI_MSG_INF(i, "cci", "ccci_tty_init fail: %d\n", ret);
            ret = -CCCI_ERR_INIT_TTY_FAIL;
            goto tty_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "ccci_tty_init OK!\n");
        }
        
        // 4.5 Init ipc dev
        ret = ccci_ipc_init(i);
        if (ret) {
            CCCI_MSG_INF(i, "cci", "ccci_ipc_init fail: %d\n", ret);
            ret = -CCCI_ERR_INIT_IPC_FAIL;
            goto ipc_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "ccci_ipc_init OK!\n");
        }
        
        // 4.6 Init rpc dev
        ret = ccci_rpc_init(i);
        if (ret) {
            CCCI_MSG_INF(i, "cci", "ccci_rpc_init fail: %d\n", ret);
            ret = -CCCI_ERR_INIT_RPC_FAIL;
            goto rpc_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "ccci_rpc_init OK!\n");
        }
        
        // 4.7 Init fs dev
        ret = ccci_fs_init(i);
        if (ret) {
            CCCI_MSG_INF(i, "cci", "ccci_fs_init fail: %d\n", ret);
            ret = -CCCI_ERR_INIT_FS_FAIL;
            goto fs_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "ccci_fs_init OK!\n");
        }
        
        // 4.8 Init ccmni dev
        ret = ccmni_init(i);
        if (ret) {
            CCCI_MSG_INF(i, "cci", "ccmni_init fail: %d\n", ret);
            ret = -CCCI_ERR_INIT_CCMNI_FAIL;
            goto ccmni_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "ccmni_init OK!\n");
        }
        
        // 4.9 Init pmic dev
        // ....
        
        // 4.10 Init vir char dev
        ret = ccci_vir_chrdev_init(i);
        if (ret) {
            CCCI_MSG_INF(i, "cci", "ccci_vir_chrdev_init fail: %d\n", ret);        
            ret = -CCCI_ERR_INIT_VIR_CHAR_FAIL;
            goto virchar_out;
        } else {
            CCCI_DBG_MSG(i, "cci", "ccci_vir_chrdev_init OK!\n");
        }
        
        CCCI_MSG_INF(i, "cci", "md initial OK!\n");
    }

    // 5. Init common section
    ret = ccci_md_ctrl_common_init();
    if (ret == 0)
        goto out;
    else {
        i = md_num-1;
        CCCI_MSG_INF(i, "cci", "ccci_md_ctrl_common_init fail: %d\n", ret);
    }

virchar_out:
    ccci_vir_chrdev_exit(i);
    
ccmni_out:
    ccmni_exit(i);

fs_out:
    ccci_fs_exit(i);
    
rpc_out:
    ccci_rpc_exit(i);

ipc_out:
    ccci_ipc_exit(i);
    
tty_out:
    ccci_tty_exit(i);
    
char_out:
    ccci_chrdev_exit(i);

mdctl_out:
    ccci_md_ctrl_exit(i);
    
logic_out:
    ccci_logic_layer_exit(i);
    
platform_out:
    platform_deinit(i);
    
mk_node_out:
    ccci_dev_node_exit(i);
    
out:
    if ((i == MD_SYS2) && (md_num > MD_SYS2)) {
        ccci_vir_chrdev_exit(MD_SYS1);
        ccmni_exit(MD_SYS1);
        ccci_fs_exit(MD_SYS1);
        ccci_rpc_exit(MD_SYS1);
        ccci_ipc_exit(MD_SYS1);
        ccci_tty_exit(MD_SYS1);
        ccci_chrdev_exit(MD_SYS1);
        ccci_md_ctrl_exit(MD_SYS1);
        ccci_logic_layer_exit(MD_SYS1);
        platform_deinit(MD_SYS1);
        ccci_dev_node_exit(MD_SYS1);
    }
    
    if (ret == CCCI_ERR_MODULE_INIT_OK)
        CCCI_MSG("ccci module init OK\n");
    else {        
        release_ccci_dev_node();
        ccci_helper_exit();
        CCCI_MSG("ccci module init fail: %d\n", ret);
    }
    
    return ret;
}

static void __exit ccci_exit(void)
{
    unsigned int md_num = 1, i;

    //1. Get Support MD nmmber
    md_num = get_md_sys_max_num();

    //2. Init ccci driver for each modem
    for(i=0; i<md_num; i++)
    {
        // 3.1 de-Init virtual char dev
        ccci_vir_chrdev_exit(i);
        // 3.2 de-Init ccmni dev
        ccmni_exit(i);
        // 3.3 de-Init fs dev
        ccci_fs_exit(i);
        // 3.4 de-Init rpc dev
        ccci_rpc_exit(i);
        // 3.5 de-Init ipc dev
        ccci_ipc_exit(i);
        // 3.6 de-Init tty dev
        ccci_tty_exit(i);
        // 3.7 de-Init char dev
        ccci_chrdev_exit(i);
        // 3.8 De-Init md ctrl
        ccci_md_ctrl_exit(i);
        // 3.9 de-Init ccci logical layer
        ccci_logic_layer_exit(i);
        // 3.10 de-Init ccci platform layer
        platform_deinit(i);
        // 3.11 de-Init ccci device node
        ccci_dev_node_exit(i);
    }
    // 3.12 release ccci class
    release_ccci_dev_node();
    // 3.13 de-Init ccci helper grobal data
    ccci_helper_exit();
}

//  Build-in Modified - S
#ifdef ENABLE_CCCI_DRV_BUILDIN
device_initcall_sync(ccci_init);
#else  // MODULE
module_init(ccci_init);
#endif
//  Build-in Modified - E
module_exit(ccci_exit);

MODULE_DESCRIPTION("CCIF Driver");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("MTK");