void apps_init(void)
{
// init command system.
commandSystemInit();
// init ipc objects.
ipcs_init();
// init socket_conn array.
socket_conn_init();
// init settings stored in flash.
settings_powerup_init();
// init lwip, modified by me.
_lwip_sys_init();
// init serial devices.
usart_dev_init();
// check and start all threads.
threads_init();
// init idle hook functions.
rt_thread_idle_sethook(idle_hook_function);
}
static int __init ipcs_module_init(void)
{
int rc = 0;
int readyChkCnt = 0;
struct timespec startTime, endTime;
IPC_DEBUG(DBG_INFO,"[ipc]: ipcs_module_init start..\n");
init_MUTEX_LOCKED(&g_ipc_info.ipc_sem);
g_ipc_info.ipc_state = 0;
g_ipc_info.devnum = MKDEV(IPC_MAJOR, 0);
rc = register_chrdev_region(g_ipc_info.devnum, 1, "bcm_fuse_ipc");
if (rc < 0)
{
IPC_DEBUG(DBG_ERROR,"Error registering the IPC device\n");
goto out;
}
cdev_init(&g_ipc_info.cdev, &ipc_ops);
g_ipc_info.cdev.owner = THIS_MODULE;
rc = cdev_add(&g_ipc_info.cdev, g_ipc_info.devnum, 1);
if (rc)
{
IPC_DEBUG(DBG_ERROR,"[ipc]: cdev_add errpr\n");
goto out_unregister;
}
IPC_DEBUG(DBG_INFO, "[ipc]: create_workqueue\n");
INIT_WORK(&g_ipc_info.cp_crash_dump_wq, ProcessCPCrashedDump);
INIT_WORK(&g_ipc_info.intr_work, ipcs_intr_workqueue_process);
g_ipc_info.intr_workqueue = create_workqueue("ipc-wq");
if (!g_ipc_info.intr_workqueue)
{
IPC_DEBUG(DBG_ERROR,"[ipc]: cannot create workqueue\n");
goto out_unregister;
}
IPC_DEBUG(DBG_INFO, "[ipc]: request_irq\n");
rc = request_irq(IRQ_IPC_C2A, ipcs_interrupt, IRQF_NO_SUSPEND, "ipc-intr", &g_ipc_info);
if (rc)
{
IPC_DEBUG(DBG_ERROR,"[ipc]: request_irq error\n");
goto out_del;
}
/**
Make sure this is not cache'd because CP has to know about any changes
we write to this memory immediately.
*/
IPC_DEBUG(DBG_INFO, "[ipc]: ioremap_nocache IPC_BASE\n");
g_ipc_info.apcp_shmem = ioremap_nocache(IPC_BASE, IPC_SIZE);
if (!g_ipc_info.apcp_shmem)
{
rc = -ENOMEM;
IPC_DEBUG(DBG_ERROR,"[ipc]: Could not map shmem\n");
goto out_del;
}
#ifdef CONFIG_HAS_WAKELOCK
wake_lock_init(&ipc_wake_lock, WAKE_LOCK_SUSPEND, "ipc_wake_lock");
#endif
IPC_DEBUG(DBG_INFO, "[ipc]: ipcs_init\n");
if (ipcs_init((void *)g_ipc_info.apcp_shmem, IPC_SIZE))
{
rc = -1;
IPC_DEBUG(DBG_ERROR,"[ipc]: ipcs_init() failed\n");
goto out_del;
}
if ( sEarlyCPInterrupt )
{
IPC_DEBUG(DBG_INFO,"[ipc]: early CP interrupt - doing crash dump...\n");
#ifdef CONFIG_HAS_WAKELOCK
wake_lock(&ipc_wake_lock);
#endif
schedule_work(&g_ipc_info.cp_crash_dump_wq);
}
// check for AP only boot mode
if ( AP_ONLY_BOOT == get_ap_boot_mode() )
{
IPC_DEBUG(DBG_INFO,"[ipc]: AP only boot - not waiting for CP\n");
}
else
{
// wait for CP to have IPC setup as well; if we exit module init
// before IPC is ready, RPC module will likely crash during its
// own init
startTime = current_kernel_time();
while ( !g_ipc_info.ipc_state )
{
IPC_DEBUG(DBG_INFO, "[ipc]: CP IPC not ready, sleeping...\n");
msleep(20);
readyChkCnt++;
if ( readyChkCnt > 100 )
{
IPC_DEBUG(DBG_ERROR, "[ipc]: IPC init timeout - no response from CP\n");
rc = -1;
goto out_del;
}
}
endTime = current_kernel_time();
IPC_DEBUG(DBG_INFO,"readyChkCnt=%d time=%ldus\n", readyChkCnt,
((endTime.tv_sec - startTime.tv_sec)*1000000L+(endTime.tv_nsec - startTime.tv_nsec)/1000L));
IPC_DEBUG(DBG_INFO,"[ipc]: ipcs_module_init ok\n");
}
return 0;
out_del:
cdev_del(&g_ipc_info.cdev);
out_unregister:
unregister_chrdev_region(g_ipc_info.devnum, 1);
out:
IPC_DEBUG(DBG_ERROR,"IPC Driver Failed to initialise!\n");
return rc;
}
static int __init ipcs_module_init(void)
{
int rc = -1;
struct proc_dir_entry *dir;
dir =
create_proc_read_entry("driver/bcmipc", 0, NULL, ipcs_read_proc,
NULL);
if (dir == NULL) {
IPC_DEBUG(DBG_ERROR,
"ipcs_module_init: can't create /proc/driver/bcmipc\n");
//return -1;
}
IPC_DEBUG(DBG_TRACE, "start ...\n");
g_ipc_info.ipc_state = 0;
g_ipc_info.mDriverClass = class_create(THIS_MODULE,
BCM_KERNEL_IPC_NAME);
if (IS_ERR(g_ipc_info.mDriverClass)) {
IPC_DEBUG(DBG_ERROR, "driver class_create failed\n");
goto out;
}
g_ipc_info.drvdata = device_create(g_ipc_info.mDriverClass, NULL,
MKDEV(IPC_MAJOR, 0), NULL, BCM_KERNEL_IPC_NAME);
if (IS_ERR(g_ipc_info.drvdata)) {
IPC_DEBUG(DBG_ERROR, "device_create drvdata failed\n");
goto out;
}
IPC_DEBUG(DBG_TRACE, "Allocate CP crash dump workqueue\n");
g_ipc_info.crash_dump_workqueue = alloc_workqueue("dump-wq",
WQ_FREEZABLE |
WQ_MEM_RECLAIM, 0);
if (!g_ipc_info.crash_dump_workqueue) {
IPC_DEBUG(DBG_ERROR,
"Cannot allocate CP crash dump workqueue\n");
goto out;
}
INIT_WORK(&g_ipc_info.cp_crash_dump_wq, ProcessCPCrashedDump);
tasklet_init(&g_ipc_info.intr_tasklet, ipcs_intr_tasklet_handler, 0);
/**
Make sure this is not cache'd because CP has to know about any changes
we write to this memory immediately.
*/
IPC_DEBUG(DBG_TRACE, "ioremap_nocache IPC_BASE\n");
g_ipc_info.apcp_shmem = ioremap_nocache(IPC_BASE, IPC_SIZE);
if (!g_ipc_info.apcp_shmem) {
rc = -ENOMEM;
IPC_DEBUG(DBG_ERROR, "Could not map shmem\n");
goto out_shared_mem_fail;
}
IPC_DEBUG(DBG_TRACE, "ipcs_init\n");
if (ipcs_init((void *)g_ipc_info.apcp_shmem, IPC_SIZE, 0)) {
rc = -1;
IPC_DEBUG(DBG_ERROR, "ipcs_init() failed\n");
goto out_ipc_init_fail;
}
IPC_DEBUG(DBG_TRACE, "ok\n");
#ifdef CONFIG_HAS_WAKELOCK
wake_lock_init(&ipc_wake_lock, WAKE_LOCK_SUSPEND, "ipc_wake_lock");
#endif
IPC_DEBUG(DBG_TRACE, "request_irq\n");
rc = request_irq(IRQ_IPC_C2A, ipcs_interrupt, IRQF_NO_SUSPEND,
"ipc-intr", &g_ipc_info);
if (rc) {
IPC_DEBUG(DBG_ERROR, "request_irq error\n");
goto out_irq_req_fail;
}
IPC_DEBUG(DBG_TRACE, "IRQ Clear and Enable\n");
return 0;
out_irq_req_fail:
wake_lock_destroy(&ipc_wake_lock);
out_ipc_init_fail:
iounmap(g_ipc_info.apcp_shmem);
out_shared_mem_fail:
flush_workqueue(g_ipc_info.crash_dump_workqueue);
destroy_workqueue(g_ipc_info.crash_dump_workqueue);
out:
IPC_DEBUG(DBG_ERROR, "IPC Driver Failed to initialise!\n");
return rc;
}
int ipcs_reinitialize_ipc(void)
{
IPC_DEBUG(DBG_INFO, "calling ipcs_init\n");
return ipcs_init((void *)g_ipc_info.apcp_shmem, IPC_SIZE, 1);
}
