// pmem
static void __init android_pmem_set_platdata(void)
{
	pmem_pdata.start = (u32)s3c_get_media_memory(S3C_MDEV_PMEM);
	pmem_pdata.size = (u32)s3c_get_media_memsize(S3C_MDEV_PMEM);

	pmem_gpu1_pdata.start = (u32)s3c_get_media_memory(S3C_MDEV_PMEM_GPU1);
	pmem_gpu1_pdata.size = (u32)s3c_get_media_memsize(S3C_MDEV_PMEM_GPU1);	

	pmem_adsp_pdata.start = (u32)s3c_get_media_memory(S3C_MDEV_PMEM_ADSP);
	pmem_adsp_pdata.size = (u32)s3c_get_media_memsize(S3C_MDEV_PMEM_ADSP);	
}
int s3c_mfc_init_buffer_manager(void)
{
	s3c_mfc_free_mem_t	*free_node;
	s3c_mfc_alloc_mem_t	*alloc_node;

	/* init alloc list, if(s3c_mfc_alloc_mem_head == s3c_mfc_alloc_mem_tail) then, the list is NULL */
	alloc_node = (s3c_mfc_alloc_mem_t *)kmalloc(sizeof(s3c_mfc_alloc_mem_t), GFP_KERNEL);
	memset(alloc_node, 0x00, sizeof(s3c_mfc_alloc_mem_t));
	alloc_node->next = alloc_node;
	alloc_node->prev = alloc_node;
	s3c_mfc_alloc_mem_head = alloc_node;
	s3c_mfc_alloc_mem_tail = s3c_mfc_alloc_mem_head;

	/* init free list, if(s3c_mfc_free_mem_head == s3c_mfc_free_mem_tail) then, the list is NULL */
	free_node = (s3c_mfc_free_mem_t *)kmalloc(sizeof(s3c_mfc_free_mem_t), GFP_KERNEL);
	memset(free_node, 0x00, sizeof(s3c_mfc_free_mem_t));
	free_node->next = free_node;
	free_node->prev = free_node;
	s3c_mfc_free_mem_head = free_node;
	s3c_mfc_free_mem_tail = s3c_mfc_free_mem_head;

	/* init free head node */
	free_node = (s3c_mfc_free_mem_t *)kmalloc(sizeof(s3c_mfc_free_mem_t), GFP_KERNEL);
	memset(free_node, 0x00, sizeof(s3c_mfc_free_mem_t));
	free_node->start_addr = s3c_mfc_phys_data_buf;
	free_node->cache_flag = 0;
	free_node->size = s3c_get_media_memsize(S3C_MDEV_MFC);
	s3c_mfc_insert_first_node_to_free_list(free_node, -1);

	return 0;
}
Beispiel #3
0
static int s3c_fimc_init_global(struct platform_device *pdev)
{
	/* camera clock */
	s3c_fimc.cam_clock = clk_get(&pdev->dev, "sclk_cam");
	if (IS_ERR(s3c_fimc.cam_clock)) {
		err("failed to get camera clock source\n");
		return -EINVAL;
	}

	s3c_fimc.dma_start = s3c_get_media_memory(S3C_MDEV_FIMC);
	s3c_fimc.dma_total = s3c_get_media_memsize(S3C_MDEV_FIMC);
	s3c_fimc.dma_current = s3c_fimc.dma_start;

	/* test pattern */
	s3c_fimc.camera[test_pattern.id] = &test_pattern;

	return 0;
}
MFC_ERROR_CODE s3c_mfc_get_virt_addr(s3c_mfc_inst_ctx  *MfcCtx,  s3c_mfc_args *args)
{
	int ret;
	int inst_no = MfcCtx->InstNo;
	unsigned int p_startAddr;
	s3c_mfc_mem_alloc_arg_t *in_param;	
	s3c_mfc_alloc_mem_t *p_allocMem;
	

	in_param = (s3c_mfc_mem_alloc_arg_t *)args;

	/* if user request cachable area, allocate from reserved area */
	/* if user request uncachable area, allocate dynamically */
	p_startAddr = s3c_mfc_get_mem_area((int)in_param->buff_size, inst_no, in_param->cache_flag);
	mfc_debug("p_startAddr = 0x%X\n\r", p_startAddr);

	if (!p_startAddr) {
		mfc_debug("There is no more memory\n\r");
		in_param->out_addr = -1;
		ret = MFCINST_MEMORY_ALLOC_FAIL;
		goto out_getcodecviraddr;
	}

	p_allocMem = (s3c_mfc_alloc_mem_t *)kmalloc(sizeof(s3c_mfc_alloc_mem_t), GFP_KERNEL);
	memset(p_allocMem, 0x00, sizeof(s3c_mfc_alloc_mem_t));

	if (in_param->cache_flag == MFC_MEM_CACHED) {
		p_allocMem->cached_p_addr = p_startAddr;
		p_allocMem->v_addr = s3c_mfc_virt_data_buf + (p_allocMem->cached_p_addr - s3c_mfc_phys_data_buf);
		p_allocMem->u_addr = (unsigned char *)(in_param->cached_mapped_addr + 
				(p_allocMem->cached_p_addr - s3c_mfc_phys_data_buf));

		if (p_allocMem->v_addr == NULL) {
			mfc_debug("Mapping Failed [PA:0x%08x]\n\r", p_allocMem->cached_p_addr);
			ret = MFCINST_MEMORY_MAPPING_FAIL;
			goto out_getcodecviraddr;
		}
	} else {
		p_allocMem->uncached_p_addr = p_startAddr;
		p_allocMem->v_addr = s3c_mfc_virt_data_buf + (p_allocMem->uncached_p_addr - s3c_mfc_phys_data_buf);
		p_allocMem->u_addr = (unsigned char *)(in_param->non_cached_mapped_addr + 
				(p_allocMem->uncached_p_addr - s3c_mfc_phys_data_buf));
		mfc_debug("in_param->non_cached_mapped_addr = 0x%X, s3c_mfc_phys_data_buf = 0x%X, data buffer size = 0x%X\n", 
				in_param->non_cached_mapped_addr, s3c_mfc_phys_data_buf, s3c_get_media_memsize(S3C_MDEV_MFC));
		if (p_allocMem->v_addr == NULL) {
			mfc_debug("Mapping Failed [PA:0x%08x]\n\r", p_allocMem->uncached_p_addr);
			ret = MFCINST_MEMORY_MAPPING_FAIL;
			goto out_getcodecviraddr;
		}
	}

	in_param->out_addr = (unsigned int)p_allocMem->u_addr;
	mfc_debug("u_addr : 0x%x v_addr : 0x%x cached_p_addr : 0x%x, uncached_p_addr : 0x%x\n",
		p_allocMem->u_addr, p_allocMem->v_addr, p_allocMem->cached_p_addr, p_allocMem->uncached_p_addr);

	p_allocMem->size = (int)in_param->buff_size;
	p_allocMem->inst_no = inst_no;
	p_allocMem->cache_flag = in_param->cache_flag;

	s3c_mfc_insert_node_to_alloc_list(p_allocMem, inst_no);
	ret = MFCINST_RET_OK;

out_getcodecviraddr:	
	return ret;
}
Beispiel #5
0
size_t s3c_get_media_memsize_node(int dev_id, int node)
{
	return s3c_get_media_memsize(dev_id);
}