static int mfc_mmap(struct file *filp, struct vm_area_struct *vma)
{
unsigned long vir_size = vma->vm_end - vma->vm_start;
unsigned long phy_size, firmware_size;
unsigned long page_frame_no = 0;
mfc_inst_ctx *mfc_ctx;
mfc_debug("vma->vm_start = 0x%08x, vma->vm_end = 0x%08x\n",
(unsigned int)vma->vm_start,
(unsigned int)vma->vm_end);
mfc_debug("vma->vm_end - vma->vm_start = %ld\n", vir_size);
mfc_ctx = (mfc_inst_ctx *)filp->private_data;
firmware_size = mfc_get_port0_buff_paddr() - mfc_get_fw_buff_paddr();
phy_size = (unsigned long)(s3c_get_media_memsize_bank(S3C_MDEV_MFC, 0) - firmware_size
+ s3c_get_media_memsize_bank(S3C_MDEV_MFC, 1));
/* if memory size required from appl. mmap() is bigger than max data memory
* size allocated in the driver */
if (vir_size > phy_size)
{
mfc_err("virtual requested mem(%ld) is bigger than physical mem(%ld)\n",
vir_size, phy_size);
return -EINVAL;
}
mfc_ctx->port0_mmap_size = (vir_size / 2);
vma->vm_flags |= VM_RESERVED | VM_IO;
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
/*
* port0 mapping for stream buf & frame buf (chroma + MV)
*/
page_frame_no = __phys_to_pfn(mfc_get_port0_buff_paddr());
if (remap_pfn_range(vma, vma->vm_start, page_frame_no,
mfc_ctx->port0_mmap_size, vma->vm_page_prot))
{
mfc_err("mfc remap port0 error\n");
return -EAGAIN;
}
vma->vm_flags |= VM_RESERVED | VM_IO;
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
/*
* port1 mapping for frame buf (luma)
*/
page_frame_no = __phys_to_pfn(mfc_get_port1_buff_paddr());
if (remap_pfn_range(vma, vma->vm_start + mfc_ctx->port0_mmap_size,
page_frame_no, vir_size - mfc_ctx->port0_mmap_size, vma->vm_page_prot))
{
mfc_err("mfc remap port1 error\n");
return -EAGAIN;
}
mfc_debug("virtual requested mem = %ld, physical reserved data mem = %ld\n", vir_size, phy_size);
return 0;
}
static void __init android_pmem_set_platdata(void)
{
pmem_pdata.start = (u32)s3c_get_media_memory_bank(S3C_MDEV_PMEM, 2);
pmem_pdata.size = (u32)s3c_get_media_memsize_bank(S3C_MDEV_PMEM, 2);
pmem_gpu1_pdata.start = (u32)s3c_get_media_memory_bank(S3C_MDEV_PMEM_GPU1, 2);
pmem_gpu1_pdata.size = (u32)s3c_get_media_memsize_bank(S3C_MDEV_PMEM_GPU1, 2);
pmem_adsp_pdata.start = (u32)s3c_get_media_memory_bank(S3C_MDEV_PMEM_ADSP, 2);
pmem_adsp_pdata.size = (u32)s3c_get_media_memsize_bank(S3C_MDEV_PMEM_ADSP, 2);
}
static int s3cfb_map_default_video_memory(struct fb_info *fb)
{
struct fb_fix_screeninfo *fix = &fb->fix;
struct s3cfb_window *win = fb->par;
int reserved_size = 0;
if (win->owner == DMA_MEM_OTHER)
return 0;
fix->smem_start = s3c_get_media_memory_bank(S3C_MDEV_FIMD, 1);
reserved_size = s3c_get_media_memsize_bank(S3C_MDEV_FIMD, 1);
fb->screen_base = ioremap_wc(fix->smem_start, reserved_size);
if (!fb->screen_base)
return -ENOMEM;
else
dev_info(fbdev->dev, "[fb%d] dma: 0x%08x, cpu: 0x%08x, "
"size: 0x%08x\n", win->id,
(unsigned int)fix->smem_start,
(unsigned int)fb->screen_base, fix->smem_len);
memset(fb->screen_base, 0, fix->smem_len);
win->owner = DMA_MEM_FIMD;
return 0;
}
void __init s3c_mfc_set_platdata(struct s3c_platform_mfc *pd)
{
struct s3c_platform_mfc *npd;
if (!pd)
pd = &default_mfc_data;
npd = kmemdup(pd, sizeof(struct s3c_platform_mfc), GFP_KERNEL);
if (!npd) {
printk(KERN_ERR "%s: no memory for platform data\n", __func__);
npd->buf_phy_base[0] = s3c_get_media_memory_bank(S3C_MDEV_MFC, 0);
} else {
#if (defined(CONFIG_VIDEO_SAMSUNG_MEMSIZE_MFC) || defined(CONFIG_VIDEO_SAMSUNG_MEMSIZE_MFC0))
npd->buf_phy_base[0] = s3c_get_media_memory_bank(S3C_MDEV_MFC, 0);
npd->buf_phy_size[0] = s3c_get_media_memsize_bank(S3C_MDEV_MFC, 0);
#endif
#ifdef CONFIG_VIDEO_SAMSUNG_MEMSIZE_MFC1
npd->buf_phy_base[1] = s3c_get_media_memory_bank(S3C_MDEV_MFC, 1);
npd->buf_phy_size[1] = s3c_get_media_memsize_bank(S3C_MDEV_MFC, 1);
#endif
s3c_device_mfc.dev.platform_data = npd;
}
}
static
struct fimc_control *fimc_register_controller(struct platform_device *pdev)
{
struct s3c_platform_fimc *pdata;
struct fimc_control *ctrl;
struct resource *res;
int id, mdev_id;
id = pdev->id;
mdev_id = S3C_MDEV_FIMC0 + id;
pdata = to_fimc_plat(&pdev->dev);
ctrl = get_fimc_ctrl(id);
ctrl->id = id;
ctrl->dev = &pdev->dev;
ctrl->vd = &fimc_video_device[id];
ctrl->vd->minor = id;
/* alloc from bank1 as default */
ctrl->mem.base = s3c_get_media_memory_bank(mdev_id, 1);
ctrl->mem.size = s3c_get_media_memsize_bank(mdev_id, 1);
ctrl->mem.curr = ctrl->mem.base;
ctrl->status = FIMC_STREAMOFF;
ctrl->limit = &fimc_limits[id];
ctrl->log = FIMC_LOG_DEFAULT;
sprintf(ctrl->name, "%s%d", FIMC_NAME, id);
strcpy(ctrl->vd->name, ctrl->name);
atomic_set(&ctrl->in_use, 0);
mutex_init(&ctrl->lock);
mutex_init(&ctrl->v4l2_lock);
spin_lock_init(&ctrl->lock_in);
spin_lock_init(&ctrl->lock_out);
init_waitqueue_head(&ctrl->wq);
/* get resource for io memory */
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
fimc_err("%s: failed to get io memory region\n", __func__);
return NULL;
}
/* request mem region */
res = request_mem_region(res->start, res->end - res->start + 1,
pdev->name);
if (!res) {
fimc_err("%s: failed to request io memory region\n", __func__);
return NULL;
}
/* ioremap for register block */
ctrl->regs = ioremap(res->start, res->end - res->start + 1);
if (!ctrl->regs) {
fimc_err("%s: failed to remap io region\n", __func__);
return NULL;
}
/* irq */
ctrl->irq = platform_get_irq(pdev, 0);
if (request_irq(ctrl->irq, fimc_irq, IRQF_DISABLED, ctrl->name, ctrl))
fimc_err("%s: request_irq failed\n", __func__);
fimc_hwset_reset(ctrl);
return ctrl;
}
static void __init s3c_pmem_set_platdata(void)
{
pmem_pdata.start = s3c_get_media_memory_bank(S3C_MDEV_PMEM, 2);
pmem_pdata.size = s3c_get_media_memsize_bank(S3C_MDEV_PMEM, 2);
}
