s3c_pp_6400.c

s3c6400 post processor decoder

int s3c_pp_open(struct inode *inode, struct file *file) 
{ 	
	pp_params	*pParams;

	// allocating the post processor instance
	pParams	= (pp_params *)kmalloc(sizeof(pp_params), GFP_KERNEL);
	if (pParams == NULL) {
		printk(KERN_ERR "Instance memory allocation was failed\n");
	}

	file->private_data	= (pp_params *)pParams;
	
	return 0;
}

int s3c_pp_read(struct file *file, char *buf, size_t count,
		loff_t *f_pos)
{
	return 0;
}

int s3c_pp_write(struct file *file, const char *buf, size_t 
		count, loff_t *f_pos)
{
	return 0;
}

int s3c_pp_mmap(struct file *file, struct vm_area_struct *vma)
{
	u32 size = vma->vm_end - vma->vm_start;
	u32 max_size;
	u32 page_frame_no;

	page_frame_no = __phys_to_pfn(POST_BUFF_BASE_ADDR);

	max_size = RESERVE_POST_MEM + PAGE_SIZE - (RESERVE_POST_MEM % PAGE_SIZE);

	if(size > max_size) {
		return -EINVAL;
	}

	vma->vm_flags |= VM_RESERVED;

	if( remap_pfn_range(vma, vma->vm_start, page_frame_no, size, vma->vm_page_prot)) {
		printk(KERN_ERR "%s: mmap_error\n", __FUNCTION__);
		return -EAGAIN;

	}

	return 0;
}


int s3c_pp_release(struct inode *inode, struct file *file) 
{
	pp_params	*pParams;

	pParams	= (pp_params *)file->private_data;
	if (pParams == NULL) {
		return -1;
	}

	kfree(pParams);
	
	return 0;
}

void pp_for_mfc(unsigned int uSrcFrmSt,     unsigned int uDstFrmSt,
		unsigned int srcFrmFormat,  unsigned int dstFrmFormat,
		unsigned int srcFrmWidth,   unsigned int srcFrmHeight,
		unsigned int dstFrmWidth,   unsigned int dstFrmHeight,
		unsigned int srcXOffset,    unsigned int srcYOffset,
		unsigned int dstXOffset,    unsigned int dstYOffset,
		unsigned int srcCropWidth,  unsigned int srcCropHeight,
		unsigned int dstCropWidth,  unsigned int dstCropHeight
		)
{
	pp_params	*pParams;

	pParams	= (pp_params *)kmalloc(sizeof(pp_params), GFP_KERNEL);
	if (pParams == NULL) {
		printk(KERN_ERR "Instance memory allocation was failed\n");
	}
	
	pParams->SrcFullWidth	= srcFrmWidth;
	pParams->SrcFullHeight	= srcFrmHeight;
	pParams->SrcStartX		= srcXOffset;
	pParams->SrcStartY		= srcYOffset;
	pParams->SrcWidth		= srcCropWidth;
	pParams->SrcHeight		= srcCropHeight;
	pParams->SrcFrmSt		= uSrcFrmSt;
	pParams->SrcCSpace		= srcFrmFormat;

	pParams->DstFullWidth	= dstFrmWidth;
	pParams->DstFullHeight	= dstFrmHeight;
	pParams->DstStartX		= dstXOffset;
	pParams->DstStartY		= dstYOffset;
	pParams->DstWidth		= dstCropWidth;
	pParams->DstHeight		= dstCropHeight;
	pParams->DstFrmSt		= uDstFrmSt;
	pParams->DstCSpace		= dstFrmFormat;

	pParams->Mode			= ONE_SHOT;
	pParams->OutPath		= POST_DMA;

	config_pp(pParams);

	post_int_enable(1);
	start_processing();		
	if (interruptible_sleep_on_timeout(&waitq, 500) == 0) {
		printk(KERN_ERR "\n%s: Waiting for interrupt is timeout\n", __FUNCTION__);					
	}
	post_int_disable();
}

EXPORT_SYMBOL(pp_for_mfc);

static int s3c_pp_ioctl(struct inode *inode, struct file *file,
		unsigned int cmd, unsigned long arg)
{
	pp_params	*pParams;
	pp_params	*parg;

	pParams	= (pp_params *)file->private_data;
	parg	= (pp_params *)arg;

	mutex_lock(h_mutex);
	
	switch(cmd) {
		case PPROC_SET_PARAMS:		
			get_user(pParams->SrcFullWidth, &parg->SrcFullWidth);
			get_user(pParams->SrcFullHeight, &parg->SrcFullHeight);
			get_user(pParams->SrcStartX, &parg->SrcStartX);
			get_user(pParams->SrcStartY, &parg->SrcStartY);
			get_user(pParams->SrcWidth, &parg->SrcWidth);
			get_user(pParams->SrcHeight, &parg->SrcHeight);
			get_user(pParams->SrcFrmSt, &parg->SrcFrmSt);
			get_user(pParams->SrcCSpace, &parg->SrcCSpace);
			get_user(pParams->DstFullWidth, &parg->DstFullWidth);
			get_user(pParams->DstFullHeight, &parg->DstFullHeight);
			get_user(pParams->DstStartX, &parg->DstStartX);
			get_user(pParams->DstStartY, &parg->DstStartY);
			get_user(pParams->DstWidth, &parg->DstWidth);
			get_user(pParams->DstHeight, &parg->DstHeight);
			get_user(pParams->DstFrmSt, &parg->DstFrmSt);
			get_user(pParams->DstCSpace, &parg->DstCSpace);
			get_user(pParams->SrcFrmBufNum, &parg->SrcFrmBufNum);
			get_user(pParams->DstFrmSt, &parg->DstFrmSt);
			get_user(pParams->Mode, &parg->Mode);	
			get_user(pParams->OutPath, &parg->OutPath);
			if( (pParams->DstFullWidth > 2048) || (pParams->DstFullHeight > 2048) )
			{
				printk(KERN_ERR "\n%s: maximum width and height size are 2048\n", __FUNCTION__);
				mutex_unlock(h_mutex);
				return -EINVAL;
			}

			config_pp(pParams);
			break;
		case PPROC_START:
			if(pParams->Mode == ONE_SHOT) {
				post_int_enable(1);
				start_processing();		
				if (interruptible_sleep_on_timeout(&waitq, 500) == 0) {
					printk(KERN_ERR "\n%s: Waiting for interrupt is timeout\n", __FUNCTION__);					
				}
				post_int_disable();
			} else if(pParams->Mode == FREE_RUN) {
				post_int_disable();
				start_processing();
			}		
			break;
		case PPROC_STOP:
			if(pParams->Mode == FREE_RUN) {
				stop_processing_free_run();
			}
			break;
		case PPROC_INTERLACE_MODE:
			set_interlace_mode(1);	//interlace mode
			break;
		case PPROC_PROGRESSIVE_MODE:
			set_interlace_mode(0);
			break;
		case PPROC_GET_PHY_INBUF_ADDR:
			mutex_unlock(h_mutex);
			return POST_BUFF_BASE_ADDR;
			break;
		case PPROC_GET_INBUF_SIZE:
			mutex_unlock(h_mutex);
			return PRE_BUFF_SIZE;
			break;
		case PPROC_GET_BUF_SIZE:
			mutex_unlock(h_mutex);
			return RESERVE_POST_MEM;
			break;
		case PPROC_START_ONLY:
			if(pParams->Mode == ONE_SHOT) {
				post_int_enable(1);
				start_processing();		
			}
			break;
		case PPROC_GET_OUT_DATA_SIZE:
			mutex_unlock(h_mutex);
			return get_out_data_size(pParams);
			break;
		default:
			mutex_unlock(h_mutex);
			return -EINVAL;
	}

	mutex_unlock(h_mutex);
	
	return 0;
}

static unsigned int s3c_pp_poll(struct file *file, poll_table *wait)
{
	unsigned int	mask = 0;

	poll_wait(file, &waitq, wait);
	post_int_disable();
	mask |= POLLIN | POLLRDNORM;

	return mask;
}

static struct file_operations s3c_pp_fops = {
	.owner 	= THIS_MODULE,
	.ioctl 	= s3c_pp_ioctl,
	.open 	= s3c_pp_open,
	.read 	= s3c_pp_read,
	.write 	= s3c_pp_write,
	.mmap	= s3c_pp_mmap,
	.poll	= s3c_pp_poll,
	.release 	= s3c_pp_release
};


static struct miscdevice s3c_pp_dev = {
	.minor		= PP_MINOR,
	.name		= "s3c-pp",
	.fops		= &s3c_pp_fops,
};

static int s3c_pp_remove(struct platform_device *dev)
{
	clk_disable(pp_clock);

	free_irq(s3c_pp_irq, NULL);
	if (s3c_pp_mem != NULL) {
		pr_debug("s3c_post: releasing s3c_post_mem\n");
		iounmap(s3c_pp_base);
		release_resource(s3c_pp_mem);
		kfree(s3c_pp_mem);
	}
	misc_deregister(&s3c_pp_dev);
	return 0;
}



int s3c_pp_probe(struct platform_device *pdev)
{

	struct resource *res;

	int ret;

	int tmp;

	// Use DOUTmpll source clock as a scaler clock
	tmp = __raw_readl(S3C_CLK_SRC);

	tmp &=~(0x3<<28);
	tmp |= (0x1<<28);
	__raw_writel(tmp, S3C_CLK_SRC);

	/* find the IRQs */
	s3c_pp_irq = platform_get_irq(pdev, 0);


	if(s3c_pp_irq <= 0) {
		printk(KERN_ERR PFX "failed to get irq resouce\n");
		return -ENOENT;
	}

	/* get the memory region for the post processor driver */
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if(res == NULL) {
		printk(KERN_ERR PFX "failed to get memory region resouce\n");
		return -ENOENT;
	}

	s3c_pp_mem = request_mem_region(res->start, res->end-res->start+1, pdev->name);
	if(s3c_pp_mem == NULL) {
		printk(KERN_ERR PFX "failed to reserve memory region\n");
		return -ENOENT;
	}


	s3c_pp_base = ioremap(s3c_pp_mem->start, s3c_pp_mem->end - res->start + 1);
	if(s3c_pp_base == NULL) {
		printk(KERN_ERR PFX "failed ioremap\n");
		return -ENOENT;
	}

	pp_clock = clk_get(&pdev->dev, "post");
	if(pp_clock == NULL) {
		printk(KERN_ERR PFX "failed to find post clock source\n");
		return -ENOENT;
	}

	clk_enable(pp_clock);

	h_clk = clk_get(&pdev->dev, "hclk");
	if(h_clk == NULL) {
		printk(KERN_ERR PFX "failed to find h_clk clock source\n");
		return -ENOENT;
	}

	init_waitqueue_head(&waitq);

	ret = misc_register(&s3c_pp_dev);
	if (ret) {
		printk (KERN_ERR "cannot register miscdev on minor=%d (%d)\n",
				PP_MINOR, ret);
		return ret;
	}
	ret = request_irq(s3c_pp_irq, s3c_pp_isr, SA_INTERRUPT,
			pdev->name, NULL);
	if (ret) {
		printk("request_irq(PP) failed.\n");
		return ret;
	}

	h_mutex = (struct mutex *)kmalloc(sizeof(struct mutex), GFP_KERNEL);
	if (h_mutex == NULL)
		return -1;
	
	mutex_init(h_mutex);

	/* check to see if everything is setup correctly */	
	return 0;
}

static int s3c_pp_suspend(struct platform_device *dev, pm_message_t state)
{
	int	post_state;


	post_state = post_get_processing_state();
	while (post_state == POST_BUSY)
		msleep(1);

	clk_disable(pp_clock);
	return 0;
}
static int s3c_pp_resume(struct platform_device *pdev)
{
	clk_enable(pp_clock);
	return 0;
}
static struct platform_driver s3c_pp_driver = {
	.probe          = s3c_pp_probe,
	.remove         = s3c_pp_remove,
	.suspend        = s3c_pp_suspend,
	.resume         = s3c_pp_resume,
	.driver		= {
		.owner	= THIS_MODULE,
		.name	= "s3c-vpp",
	},
};

static char banner[] __initdata = KERN_INFO "S3C PostProcessor Driver, (c) 2007 Samsung Electronics\n";

int __init  s3c_pp_init(void)
{

	printk(banner);
	if(platform_driver_register(&s3c_pp_driver)!=0)
	{
		printk("platform device register Failed \n");
		return -1;
	}

	return 0;
}

void  s3c_pp_exit(void)
{
	platform_driver_unregister(&s3c_pp_driver);
	mutex_destroy(h_mutex);
	printk("S3C PostProcessor module exit\n");
}
module_init(s3c_pp_init);
module_exit(s3c_pp_exit);


MODULE_AUTHOR("[e-mail]");
MODULE_DESCRIPTION("S3C PostProcessor Device Driver");
MODULE_LICENSE("GPL");