int __init mm_isp2_init(void)
{
int ret = 0;
MM_CORE_HW_IFC core_param;
MM_DVFS_HW_IFC dvfs_param;
MM_PROF_HW_IFC prof_param;
isp_device = kmalloc(sizeof(struct isp_device_t), GFP_KERNEL);
isp_device->vaddr = NULL;
pr_debug("ISP driver Module Init");
core_param.mm_base_addr = ISP2_BASE_ADDR;
core_param.mm_hw_size = ISP2_HW_SIZE;
core_param.mm_irq = IRQ_ISP2;
core_param.mm_timer = DEFAULT_MM_DEV_TIMER_MS;
core_param.mm_timeout = DEFAULT_MM_DEV_TIMEOUT_MS;
core_param.mm_get_status = get_isp_status;
core_param.mm_start_job = isp_start_job;
core_param.mm_process_irq = process_isp_irq;
core_param.mm_init = isp_reset;
core_param.mm_deinit = isp_reset;
core_param.mm_abort = isp_abort;
core_param.mm_get_regs = NULL;
core_param.mm_update_virt_addr = mm_isp_update_virt_addr;
core_param.mm_version_init = NULL;
core_param.mm_device_id = (void *)isp_device;
core_param.mm_virt_addr = NULL;
core_param.core_name = "ISP2";
dvfs_param.ON = 1;
dvfs_param.MODE = PI_OPP_TURBO;
dvfs_param.T0 = 200;
dvfs_param.P0 = 0;
dvfs_param.T1 = 300;
dvfs_param.P1 = 0;
dvfs_param.P1L = 0;
dvfs_param.T2 = 300;
dvfs_param.P2 = 120;
dvfs_param.P2L = 0;
dvfs_param.T3 = 1000;
dvfs_param.P3L = 120;
dvfs_param.dvfs_bulk_job_cnt = 0;
isp_device->fmwk_handle = mm_fmwk_register(ISP2_DEV_NAME,
ISP2_AXI_BUS_CLK_NAME_STR, 1,
&core_param, &dvfs_param, &prof_param);
if ((isp_device->fmwk_handle == NULL) ||
(isp_device->vaddr == NULL)) {
ret = -ENOMEM;
goto err;
}
pr_debug("ISP driver Module Init over");
return ret;
err:
pr_err("ISP driver Module Init Error");
return ret;
}
int __init interlock_init(void)
{
int ret = 0;
MM_CORE_HW_IFC core_param;
MM_DVFS_HW_IFC dvfs_param;
MM_PROF_HW_IFC prof_param;
interlock_device = kmalloc(sizeof(struct interlock_device_t),
GFP_KERNEL);
pr_debug("INTERLOCK driver Module Init");
core_param.mm_base_addr = 0;
core_param.mm_hw_size = 0;
core_param.mm_irq = 0;
core_param.mm_timer = 0;
core_param.mm_timeout = 0;
core_param.mm_get_status = get_interlock_status;
core_param.mm_start_job = interlock_start_job;
core_param.mm_process_irq = process_interlock_irq;
core_param.mm_init = interlock_reset;
core_param.mm_deinit = interlock_reset;
core_param.mm_abort = interlock_abort;
core_param.mm_get_regs = interlock_get_regs;
core_param.mm_update_virt_addr = interlock_virt_addr_update;
core_param.mm_version_init = NULL;
core_param.mm_device_id = (void *)interlock_device;
core_param.mm_virt_addr = NULL;
dvfs_param.ON = 0;
dvfs_param.MODE = ECONOMY;
dvfs_param.T0 = 0;
dvfs_param.P0 = 0;
dvfs_param.T1 = 300;
dvfs_param.P1 = 80;
dvfs_param.P1L = 0;
dvfs_param.T2 = 500;
dvfs_param.P2 = 80;
dvfs_param.P2L = 45;
dvfs_param.T3 = 1000;
dvfs_param.P3L = 45;
dvfs_param.dvfs_bulk_job_cnt = 0;
interlock_device->fmwk_handle = mm_fmwk_register(INTERLOCK_DEV_NAME,
NULL, 1, &core_param,
&dvfs_param, &prof_param);
if (interlock_device->fmwk_handle == NULL) {
ret = -ENOMEM;
goto err;
}
pr_debug("INTERLOCK driver Module Init over");
return ret;
err:
pr_err("INTERLOCK driver Module Init Error");
return ret;
}
int __init mm_h264_init(void)
{
int ret = 0;
MM_CORE_HW_IFC core_param[H264_SUBDEV_COUNT];
MM_DVFS_HW_IFC dvfs_param;
MM_PROF_HW_IFC prof_param;
int i = 0;
pr_debug("h264_init: -->\n");
h264_device = kmalloc(sizeof(struct h264_device_t), GFP_KERNEL);
if (h264_device == NULL) {
pr_err("h264_init: kmalloc failed\n");
ret = -ENOMEM;
goto err;
}
h264_device->subdev_init[0] = &cme_init;
h264_device->subdev_deinit[0] = &cme_deinit;
h264_device->subdev_init[1] = &mcin_init;
h264_device->subdev_deinit[1] = &mcin_deinit;
h264_device->subdev_init[2] = &cabac_init;
h264_device->subdev_deinit[2] = &cabac_deinit;
h264_device->subdev_init[3] = &h264_vce_init;
h264_device->subdev_deinit[3] = &h264_vce_deinit;
/*Calling init on sub devices*/
for (i = 0; i < H264_SUBDEV_COUNT; i++) {
ret = h264_device->subdev_init[i](&core_param[i]);
if (ret != 0) {
pr_err("mm_h264_init: subdev init for " \
"%d returned error\n", i);
goto err1;
}
}
/*Initialize generice params*/
dvfs_param.is_dvfs_on = 0;
dvfs_param.user_requested_mode = TURBO;
dvfs_param.enable_suspend_resume = 0;
dvfs_param.T1 = 300;
dvfs_param.P1 = 80;
dvfs_param.T2 = 3000;
dvfs_param.P2 = 30;
dvfs_param.dvfs_bulk_job_cnt = 0;
h264_device->fmwk_handle = mm_fmwk_register(H264_DEV_NAME,
H264_AXI_BUS_CLK_NAME_STR,
H264_SUBDEV_COUNT,
&core_param[0],
&dvfs_param,
&prof_param);
if ((h264_device->fmwk_handle == NULL)) {
ret = -ENOMEM;
goto err1;
}
pr_debug("h264_init: H264 driver Module Init over");
return ret;
err1:
kfree(h264_device);
err:
pr_err("h264_init: H264 driver Module Init Error");
return ret;
}
int __init mm_h264_init(void)
{
int ret = 0;
MM_CORE_HW_IFC *core_param;
MM_DVFS_HW_IFC dvfs_param;
MM_PROF_HW_IFC prof_param;
int i = 0;
pr_debug("h264_init: -->\n");
h264_device = kzalloc(sizeof(struct h264_device_t), GFP_KERNEL);
if (h264_device == NULL) {
pr_err("h264_init: kzalloc failed\n");
ret = -ENOMEM;
goto err;
}
core_param = kzalloc(sizeof(MM_CORE_HW_IFC) * H264_SUBDEV_COUNT,
GFP_KERNEL);
if (core_param == NULL) {
pr_err("h264_init: kzalloc failed\n");
kfree(h264_device);
ret = -ENOMEM;
goto err;
}
h264_device->subdev_init[0] = &cme_init;
h264_device->subdev_deinit[0] = &cme_deinit;
h264_device->subdev_init[1] = &mcin_init;
h264_device->subdev_deinit[1] = &mcin_deinit;
h264_device->subdev_init[2] = &cabac_init;
h264_device->subdev_deinit[2] = &cabac_deinit;
h264_device->subdev_init[3] = &h264_vce_init;
h264_device->subdev_deinit[3] = &h264_vce_deinit;
core_param[0].core_name = "CME";
core_param[1].core_name = "MCIN";
core_param[2].core_name = "CABAC";
core_param[3].core_name = "H264_VCE";
#if defined(CONFIG_MM_SECURE_DRIVER)
h264_device->subdev_init[9] = &mcin_secure_init;
h264_device->subdev_deinit[9] = &mcin_secure_deinit;
h264_device->subdev_init[10] = &cabac_secure_init;
h264_device->subdev_deinit[10] = &cabac_secure_deinit;
h264_device->subdev_init[11] = &h264_vce_secure_init;
h264_device->subdev_deinit[11] = &h264_vce_secure_deinit;
h264_device->subdev_init[12] = &h264_ol_secure_init;
h264_device->subdev_deinit[12] = &h264_ol_secure_deinit;
core_param[9].core_name = "MCIN_SECURE";
core_param[10].core_name = "CABAC_SECURE";
core_param[11].core_name = "H264_VCE_SECURE";
core_param[12].core_name = "H264_OL_SECURE";
#endif /* CONFIG_MM_SECURE_DRIVER */
/*Calling init on sub devices*/
for (i = 0; i < H264_SUBDEV_COUNT; i++) {
if (h264_device->subdev_init[i]) {
ret = h264_device->subdev_init[i](&core_param[i]);
if (ret != 0)
goto err1;
}
}
/*Initialize params*/
dvfs_param.ON = 1;
dvfs_param.MODE = TURBO;
#ifdef CONFIG_MM_312M_SOURCE_CLK
dvfs_param.T0 = 100;
dvfs_param.P0 = 90;
dvfs_param.T1 = 200;
dvfs_param.P1 = 90;
dvfs_param.P1L = 60;
dvfs_param.T2 = 500;
dvfs_param.P2 = 97;
dvfs_param.P2L = 60;
dvfs_param.T3 = 750;
dvfs_param.P3L = 63;
#else
dvfs_param.T0 = 0;
dvfs_param.P0 = 0;
dvfs_param.T1 = 300;
dvfs_param.P1 = 80;
dvfs_param.P1L = 0;
dvfs_param.T2 = 500;
dvfs_param.P2 = 85;
dvfs_param.P2L = 50;
dvfs_param.T3 = 750;
dvfs_param.P3L = 65;
#endif
dvfs_param.dvfs_bulk_job_cnt = 0;
h264_device->fmwk_handle = mm_fmwk_register(H264_DEV_NAME,
H264_AXI_BUS_CLK_NAME_STR,
H264_SUBDEV_COUNT,
&core_param[0],
&dvfs_param,
&prof_param);
if ((h264_device->fmwk_handle == NULL)) {
ret = -ENOMEM;
goto err1;
}
kfree(core_param);
pr_debug("h264_init: H264 driver Module Init over");
return ret;
err1:
pr_err("h264_init: Error subdev init (%d)\n", i);
kfree(core_param);
kfree(h264_device);
err:
return ret;
}
int __init mm_v3d_init(void)
{
int ret = 0;
MM_CORE_HW_IFC core_param[V3D_SUBDEV_COUNT];
MM_DVFS_HW_IFC dvfs_param;
MM_PROF_HW_IFC prof_param;
int i = 0;
pr_debug("v3d_init: -->\n");
v3d_device = kmalloc(sizeof(v3d_device_t), GFP_KERNEL);
if (v3d_device == NULL) {
pr_err("v3d_init: kmalloc failed\n");
ret = -ENOMEM;
goto err;
}
v3d_device->subdev_init[0] = &v3d_bin_render_init;
v3d_device->subdev_deinit[0] = &v3d_bin_render_deinit;
v3d_device->subdev_init[1] = &v3d_user_init;
v3d_device->subdev_deinit[1] = &v3d_user_deinit;
/*Calling init on sub devices*/
for (i = 0; i < V3D_SUBDEV_COUNT; i++) {
ret = v3d_device->subdev_init[i](&core_param[i]);
if (ret != 0) {
pr_err("mm_v3d_init:"
"subdev init for %d returned error\n", i);
goto err1;
}
}
/*Initialize generice params*/
dvfs_param.is_dvfs_on = 0;
dvfs_param.user_requested_mode = TURBO;
dvfs_param.enable_suspend_resume = 0;
dvfs_param.T1 = 300;
dvfs_param.P1 = 80;
dvfs_param.T2 = 3000;
dvfs_param.P2 = 30;
dvfs_param.dvfs_bulk_job_cnt = 0;
v3d_device->fmwk_handle =
mm_fmwk_register(V3D_DEV_NAME,
V3D_AXI_BUS_CLK_NAME_STR,
V3D_SUBDEV_COUNT,
&core_param[0],
&dvfs_param,
&prof_param);
if ((v3d_device->fmwk_handle == NULL)) {
ret = -ENOMEM;
goto err1;
}
pr_debug("v3d_init: H264 driver Module Init over");
return ret;
err1:
kfree(v3d_device);
err:
pr_err("v3d_init: V3D driver Module Init Error");
return ret;
}
