static int fimg2d_probe(struct platform_device *pdev) { struct resource *res; struct fimg2d_platdata *pdata; int ret; pdata = to_fimg2d_plat(&pdev->dev); if (!pdata) { printk(KERN_ERR "FIMG2D failed to get platform data\n"); ret = -ENOMEM; goto err_plat; } /* global structure */ info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) { printk(KERN_ERR "FIMG2D failed to allocate memory for controller\n"); ret = -ENOMEM; goto err_plat; } /* setup global info */ ret = fimg2d_setup_controller(info); if (ret) { printk(KERN_ERR "FIMG2D failed to setup controller\n"); goto err_setup; } info->dev = &pdev->dev; /* memory region */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { printk(KERN_ERR "FIMG2D failed to get resource\n"); ret = -ENOENT; goto err_res; } info->mem = request_mem_region(res->start, resource_size(res), pdev->name); if (!info->mem) { printk(KERN_ERR "FIMG2D failed to request memory region\n"); ret = -ENOMEM; goto err_region; } /* ioremap */ info->regs = ioremap(res->start, resource_size(res)); if (!info->regs) { printk(KERN_ERR "FIMG2D failed to ioremap for SFR\n"); ret = -ENOENT; goto err_map; } fimg2d_debug("device name: %s base address: 0x%lx\n", pdev->name, (unsigned long)res->start); /* irq */ info->irq = platform_get_irq(pdev, 0); if (!info->irq) { printk(KERN_ERR "FIMG2D failed to get irq resource\n"); ret = -ENOENT; goto err_map; } fimg2d_debug("irq: %d\n", info->irq); ret = request_irq(info->irq, fimg2d_irq, IRQF_DISABLED, pdev->name, info); if (ret) { printk(KERN_ERR "FIMG2D failed to request irq\n"); ret = -ENOENT; goto err_irq; } ret = fimg2d_clk_setup(info); if (ret) { printk(KERN_ERR "FIMG2D failed to setup clk\n"); ret = -ENOENT; goto err_clk; } #ifdef CONFIG_PM_RUNTIME pm_runtime_enable(info->dev); fimg2d_debug("enable runtime pm\n"); #endif exynos_sysmmu_set_fault_handler(info->dev, fimg2d_sysmmu_fault_handler); fimg2d_debug("register sysmmu page fault handler\n"); /* misc register */ ret = misc_register(&fimg2d_dev); if (ret) { printk(KERN_ERR "FIMG2D failed to register misc driver\n"); goto err_reg; } printk(KERN_INFO "Samsung Graphics 2D driver, (c) 2011 Samsung Electronics\n"); return 0; err_reg: fimg2d_clk_release(info); err_clk: free_irq(info->irq, NULL); err_irq: iounmap(info->regs); err_map: kfree(info->mem); err_region: release_resource(info->mem); err_res: destroy_workqueue(info->work_q); err_setup: kfree(info); err_plat: return ret; }
static int fimg2d_probe(struct platform_device *pdev) { int ret = 0; struct resource *res; if (!to_fimg2d_plat(&pdev->dev)) { fimg2d_err("failed to get platform data\n"); return -ENOMEM; } /* global structure */ ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL); if (!ctrl) { fimg2d_err("failed to allocate memory for controller\n"); return -ENOMEM; } /* setup global ctrl */ ret = fimg2d_setup_controller(ctrl); if (ret) { fimg2d_err("failed to setup controller\n"); goto drv_free; } ctrl->dev = &pdev->dev; /* memory region */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { fimg2d_err("failed to get resource\n"); ret = -ENOENT; goto drv_free; } ctrl->mem = request_mem_region(res->start, resource_size(res), pdev->name); if (!ctrl->mem) { fimg2d_err("failed to request memory region\n"); ret = -ENOMEM; goto res_free; } /* ioremap */ ctrl->regs = ioremap(res->start, resource_size(res)); if (!ctrl->regs) { fimg2d_err("failed to ioremap for SFR\n"); ret = -ENOENT; goto mem_free; } fimg2d_info("base address: 0x%lx\n", (unsigned long)res->start); /* irq */ ctrl->irq = platform_get_irq(pdev, 0); if (!ctrl->irq) { fimg2d_err("failed to get irq resource\n"); ret = -ENOENT; goto reg_unmap; } fimg2d_info("irq: %d\n", ctrl->irq); ret = request_irq(ctrl->irq, fimg2d_irq, IRQF_DISABLED, pdev->name, ctrl); if (ret) { fimg2d_err("failed to request irq\n"); ret = -ENOENT; goto reg_unmap; } ret = fimg2d_clk_setup(ctrl); if (ret) { fimg2d_err("failed to setup clk\n"); ret = -ENOENT; goto irq_free; } #ifdef CONFIG_PM_RUNTIME pm_runtime_enable(ctrl->dev); fimg2d_info("enable runtime pm\n"); pm_runtime_get_sync(ctrl->dev); #else fimg2d_clk_on(ctrl); #endif exynos_sysmmu_set_fault_handler(ctrl->dev, fimg2d_sysmmu_fault_handler); fimg2d_info("register sysmmu page fault handler\n"); /* misc register */ ret = misc_register(&fimg2d_dev); if (ret) { fimg2d_err("failed to register misc driver\n"); goto clk_release; } #ifdef CONFIG_ARM_EXYNOS_IKS_CPUFREQ pm_qos_add_request(&exynos5_g2d_cpu_qos, PM_QOS_CPU_FREQ_MIN, 0); pm_qos_add_request(&exynos5_g2d_mif_qos, PM_QOS_BUS_THROUGHPUT, 0); #endif return 0; clk_release: #ifdef CONFIG_PM_RUNTIME pm_runtime_disable(ctrl->dev); #else fimg2d_clk_off(ctrl); #endif fimg2d_clk_release(ctrl); irq_free: free_irq(ctrl->irq, NULL); reg_unmap: iounmap(ctrl->regs); mem_free: kfree(ctrl->mem); res_free: release_resource(ctrl->mem); drv_free: #ifdef BLIT_WORKQUE if (ctrl->work_q) destroy_workqueue(ctrl->work_q); #endif mutex_destroy(&ctrl->drvlock); kfree(ctrl); return ret; }
static int fimc_is_probe(struct platform_device *pdev) { struct exynos_platform_fimc_is *pdata; #if defined (ENABLE_IS_CORE) || defined (USE_MCUCTL) struct resource *mem_res; struct resource *regs_res; #endif struct fimc_is_core *core; int ret = -ENODEV; #ifndef ENABLE_IS_CORE int i; #endif u32 stream; struct pinctrl_state *s; probe_info("%s:start(%ld, %ld)\n", __func__, sizeof(struct fimc_is_core), sizeof(struct fimc_is_video_ctx)); core = kzalloc(sizeof(struct fimc_is_core), GFP_KERNEL); if (!core) { probe_err("core is NULL"); return -ENOMEM; } fimc_is_dev = &pdev->dev; dev_set_drvdata(fimc_is_dev, core); pdata = dev_get_platdata(&pdev->dev); if (!pdata) { #ifdef CONFIG_OF ret = fimc_is_parse_dt(pdev); if (ret) { err("fimc_is_parse_dt is fail(%d)", ret); return ret; } pdata = dev_get_platdata(&pdev->dev); #else BUG(); #endif } #ifdef USE_ION_ALLOC core->fimc_ion_client = ion_client_create(ion_exynos, "fimc-is"); #endif core->pdev = pdev; core->pdata = pdata; core->current_position = SENSOR_POSITION_REAR; device_init_wakeup(&pdev->dev, true); /* for mideaserver force down */ atomic_set(&core->rsccount, 0); #if defined (ENABLE_IS_CORE) || defined (USE_MCUCTL) mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem_res) { probe_err("Failed to get io memory region(%p)", mem_res); goto p_err1; } regs_res = request_mem_region(mem_res->start, resource_size(mem_res), pdev->name); if (!regs_res) { probe_err("Failed to request io memory region(%p)", regs_res); goto p_err1; } core->regs_res = regs_res; core->regs = ioremap_nocache(mem_res->start, resource_size(mem_res)); if (!core->regs) { probe_err("Failed to remap io region(%p)", core->regs); goto p_err2; } #else core->regs_res = NULL; core->regs = NULL; #endif #ifdef ENABLE_IS_CORE core->irq = platform_get_irq(pdev, 0); if (core->irq < 0) { probe_err("Failed to get irq(%d)", core->irq); goto p_err3; } #endif ret = pdata->clk_get(&pdev->dev); if (ret) { probe_err("clk_get is fail(%d)", ret); goto p_err3; } ret = fimc_is_mem_probe(&core->resourcemgr.mem, core->pdev); if (ret) { probe_err("fimc_is_mem_probe is fail(%d)", ret); goto p_err3; } ret = fimc_is_resourcemgr_probe(&core->resourcemgr, core); if (ret) { probe_err("fimc_is_resourcemgr_probe is fail(%d)", ret); goto p_err3; } ret = fimc_is_interface_probe(&core->interface, &core->resourcemgr.minfo, (ulong)core->regs, core->irq, core); if (ret) { probe_err("fimc_is_interface_probe is fail(%d)", ret); goto p_err3; } ret = fimc_is_debug_probe(); if (ret) { probe_err("fimc_is_deubg_probe is fail(%d)", ret); goto p_err3; } ret = fimc_is_vender_probe(&core->vender); if (ret) { probe_err("fimc_is_vender_probe is fail(%d)", ret); goto p_err3; } /* group initialization */ ret = fimc_is_groupmgr_probe(&core->groupmgr); if (ret) { probe_err("fimc_is_groupmgr_probe is fail(%d)", ret); goto p_err3; } for (stream = 0; stream < FIMC_IS_STREAM_COUNT; ++stream) { ret = fimc_is_ischain_probe(&core->ischain[stream], &core->interface, &core->resourcemgr, &core->groupmgr, &core->resourcemgr.mem, core->pdev, stream); if (ret) { probe_err("fimc_is_ischain_probe(%d) is fail(%d)", stream, ret); goto p_err3; } #ifndef ENABLE_IS_CORE core->ischain[stream].hardware = &core->hardware; #endif } ret = v4l2_device_register(&pdev->dev, &core->v4l2_dev); if (ret) { dev_err(&pdev->dev, "failed to register fimc-is v4l2 device\n"); goto p_err3; } #ifdef SOC_30S /* video entity - 3a0 */ fimc_is_30s_video_probe(core); #endif #ifdef SOC_30C /* video entity - 3a0 capture */ fimc_is_30c_video_probe(core); #endif #ifdef SOC_30P /* video entity - 3a0 preview */ fimc_is_30p_video_probe(core); #endif #ifdef SOC_31S /* video entity - 3a1 */ fimc_is_31s_video_probe(core); #endif #ifdef SOC_31C /* video entity - 3a1 capture */ fimc_is_31c_video_probe(core); #endif #ifdef SOC_31P /* video entity - 3a1 preview */ fimc_is_31p_video_probe(core); #endif #ifdef SOC_I0S /* video entity - isp0 */ fimc_is_i0s_video_probe(core); #endif #ifdef SOC_I0C /* video entity - isp0 capture */ fimc_is_i0c_video_probe(core); #endif #ifdef SOC_I0P /* video entity - isp0 preview */ fimc_is_i0p_video_probe(core); #endif #ifdef SOC_I1S /* video entity - isp1 */ fimc_is_i1s_video_probe(core); #endif #ifdef SOC_I1C /* video entity - isp1 capture */ fimc_is_i1c_video_probe(core); #endif #ifdef SOC_I1P /* video entity - isp1 preview */ fimc_is_i1p_video_probe(core); #endif #ifdef SOC_DIS /* video entity - dis */ fimc_is_dis_video_probe(core); #endif #ifdef SOC_SCC /* video entity - scc */ fimc_is_scc_video_probe(core); #endif #ifdef SOC_SCP /* video entity - scp */ fimc_is_scp_video_probe(core); #endif #ifdef SOC_MCS /* video entity - scp */ fimc_is_m0s_video_probe(core); fimc_is_m1s_video_probe(core); fimc_is_m0p_video_probe(core); fimc_is_m1p_video_probe(core); fimc_is_m2p_video_probe(core); fimc_is_m3p_video_probe(core); fimc_is_m4p_video_probe(core); #endif platform_set_drvdata(pdev, core); #ifndef ENABLE_IS_CORE ret = fimc_is_interface_ischain_probe(&core->interface_ischain, &core->hardware, &core->resourcemgr, core->pdev, (ulong)core->regs); if (ret) { dev_err(&pdev->dev, "interface_ischain_probe fail\n"); goto p_err1; } ret = fimc_is_hardware_probe(&core->hardware, &core->interface, &core->interface_ischain); if (ret) { dev_err(&pdev->dev, "hardware_probe fail\n"); goto p_err1; } /* set sysfs for set position to actuator */ sysfs_actuator.init_step = 0; for (i = 0; i < INIT_MAX_SETTING; i++) { sysfs_actuator.init_positions[i] = -1; sysfs_actuator.init_delays[i] = -1; } #endif #if defined(CONFIG_SOC_EXYNOS5430) || defined(CONFIG_SOC_EXYNOS5433) #if defined(CONFIG_VIDEOBUF2_ION) if (core->resourcemgr.mem.alloc_ctx) vb2_ion_attach_iommu(core->resourcemgr.mem.alloc_ctx); #endif #endif EXYNOS_MIF_ADD_NOTIFIER(&exynos_fimc_is_mif_throttling_nb); #if defined(CONFIG_PM_RUNTIME) pm_runtime_enable(&pdev->dev); #endif #ifdef ENABLE_FAULT_HANDLER #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 9, 0)) exynos_sysmmu_set_fault_handler(fimc_is_dev, fimc_is_fault_handler); #else iovmm_set_fault_handler(fimc_is_dev, fimc_is_fault_handler, NULL); #endif #endif /* set sysfs for debuging */ sysfs_debug.en_clk_gate = 0; sysfs_debug.en_dvfs = 1; #ifdef ENABLE_CLOCK_GATE sysfs_debug.en_clk_gate = 1; #ifdef HAS_FW_CLOCK_GATE sysfs_debug.clk_gate_mode = CLOCK_GATE_MODE_FW; #else sysfs_debug.clk_gate_mode = CLOCK_GATE_MODE_HOST; #endif #endif ret = sysfs_create_group(&core->pdev->dev.kobj, &fimc_is_debug_attr_group); s = pinctrl_lookup_state(pdata->pinctrl, "release"); if (pinctrl_select_state(pdata->pinctrl, s) < 0) { probe_err("pinctrl_select_state is fail\n"); goto p_err3; } probe_info("%s:end\n", __func__); return 0; p_err3: iounmap(core->regs); #if defined (ENABLE_IS_CORE) || defined (USE_MCUCTL) p_err2: release_mem_region(regs_res->start, resource_size(regs_res)); #endif p_err1: kfree(core); return ret; }