int s3c_jpeg_direct_encode(JPG_ENC_PROC_PARAM *EncParam)
{
BOOL result = TRUE;
DWORD ret;
clk_enable(jpeg_hclk);
clk_enable(jpeg_sclk);
log_msg(LOG_TRACE, "s3c_jpeg_open", "JPG_open \r\n");
g_JPGRegCtx = (s3c6400_jpg_ctx *)mem_alloc(sizeof(s3c6400_jpg_ctx));
memset(g_JPGRegCtx, 0x00, sizeof(s3c6400_jpg_ctx));
ret = lock_jpg_mutex();
if(!ret){
log_msg(LOG_ERROR, "s3c_jpeg_open", "DD::JPG Mutex Lock Fail\r\n");
unlock_jpg_mutex();
return FALSE;
}
g_JPGRegCtx->v_pJPG_REG = JPGMem.v_pJPG_REG;
g_JPGRegCtx->v_pJPGData_Buff = JPGMem.v_pJPGData_Buff;
if (instanceNo > MAX_INSTANCE_NUM){
log_msg(LOG_ERROR, "s3c_jpeg_open", "DD::Instance Number error-JPEG is running, instance number is %d\n", instanceNo);
unlock_jpg_mutex();
return FALSE;
}
instanceNo++;
unlock_jpg_mutex();
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "width : %d hegiht : %d\n",
EncParam->width, EncParam->height);
result = encode_jpg(g_JPGRegCtx, EncParam);
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "encoded file size : %d\n", EncParam->fileSize);
ret = lock_jpg_mutex();
if(!ret){
log_msg(LOG_ERROR, "s3c_jpeg_release", "DD::JPG Mutex Lock Fail\r\n");
return FALSE;
}
instanceNo = 0;
unlock_jpg_mutex();
kfree(g_JPGRegCtx);
clk_disable(jpeg_hclk);
clk_disable(jpeg_sclk);
return 0;
}
static int s3c_jpeg_release(struct inode *inode, struct file *file)
{
DWORD ret;
s3c6400_jpg_ctx *JPGRegCtx;
log_msg(LOG_TRACE, "s3c_jpeg_release", "JPG_Close\n");
JPGRegCtx = (s3c6400_jpg_ctx *)file->private_data;
if(!JPGRegCtx){
log_msg(LOG_ERROR, "s3c_jpeg_release", "DD::JPG Invalid Input Handle\r\n");
return FALSE;
}
ret = lock_jpg_mutex();
if(!ret){
log_msg(LOG_ERROR, "s3c_jpeg_release", "DD::JPG Mutex Lock Fail\r\n");
return FALSE;
}
//if((--instanceNo) < 0)
instanceNo = 0;
kfree(JPGRegCtx);
unlock_jpg_mutex();
clk_disable(jpeg_hclk);
clk_disable(jpeg_sclk);
return 0;
}
static int s3c_jpeg_open(struct inode *inode, struct file *file)
{
sspc100_jpg_ctx *jpg_reg_ctx;
DWORD ret;
ret = s5pv210_pd_enable("jpeg_pd");
if (ret < 0) {
jpg_err("failed to enable jpeg power domain\n");
return FALSE;
}
/* clock enable */
clk_enable(s3c_jpeg_clk);
jpg_dbg("JPG_open \r\n");
jpg_reg_ctx = (sspc100_jpg_ctx *)mem_alloc(sizeof(sspc100_jpg_ctx));
memset(jpg_reg_ctx, 0x00, sizeof(sspc100_jpg_ctx));
ret = lock_jpg_mutex();
if (!ret) {
jpg_err("JPG Mutex Lock Fail\r\n");
unlock_jpg_mutex();
kfree(jpg_reg_ctx);
return FALSE;
}
if (instanceNo > MAX_INSTANCE_NUM) {
jpg_err("Instance Number error-JPEG is running, \
instance number is %d\n", instanceNo);
unlock_jpg_mutex();
kfree(jpg_reg_ctx);
return FALSE;
}
static int s3c_jpeg_open(struct inode *inode, struct file *file)
{
struct s5pc110_jpg_ctx *jpg_reg_ctx;
unsigned long ret;
jpg_dbg("JPG_open \r\n");
jpg_reg_ctx = (struct s5pc110_jpg_ctx *)
mem_alloc(sizeof(struct s5pc110_jpg_ctx));
memset(jpg_reg_ctx, 0x00, sizeof(struct s5pc110_jpg_ctx));
ret = lock_jpg_mutex();
if (!ret) {
jpg_err("JPG Mutex Lock Fail\r\n");
unlock_jpg_mutex();
kfree(jpg_reg_ctx);
return FALSE;
}
if (instanceNo > MAX_INSTANCE_NUM) {
jpg_err("Instance Number error-JPEG is running, \
instance number is %d\n", instanceNo);
unlock_jpg_mutex();
kfree(jpg_reg_ctx);
return FALSE;
}
static int s3c_jpeg_open(struct inode *inode, struct file *file)
{
s3c6400_jpg_ctx *JPGRegCtx;
DWORD ret;
clk_enable(jpeg_hclk);
clk_enable(jpeg_sclk);
log_msg(LOG_TRACE, "s3c_jpeg_open", "JPG_open \r\n");
JPGRegCtx = (s3c6400_jpg_ctx *)mem_alloc(sizeof(s3c6400_jpg_ctx));
if (JPGRegCtx == NULL) {
log_msg(LOG_ERROR, "s3c_jpeg_open", "DD::JPG mem alloc Fail\r\n");
return FALSE;
}
memset(JPGRegCtx, 0x00, sizeof(s3c6400_jpg_ctx));
ret = lock_jpg_mutex();
if(!ret){
log_msg(LOG_ERROR, "s3c_jpeg_open", "DD::JPG Mutex Lock Fail\r\n");
unlock_jpg_mutex();
kfree(JPGRegCtx);
return FALSE;
}
JPGRegCtx->v_pJPG_REG = JPGMem.v_pJPG_REG;
JPGRegCtx->v_pJPGData_Buff = JPGMem.v_pJPGData_Buff;
if (instanceNo > MAX_INSTANCE_NUM){
log_msg(LOG_ERROR, "s3c_jpeg_open", "DD::Instance Number error-JPEG is running, instance number is %d\n", instanceNo);
unlock_jpg_mutex();
kfree(JPGRegCtx);
return FALSE;
}
instanceNo++;
unlock_jpg_mutex();
file->private_data = (s3c6400_jpg_ctx *)JPGRegCtx;
return 0;
}
static void __exit s3c_jpeg_exit(void)
{
DWORD ret;
log_msg(LOG_TRACE, "s3c_jpeg_exit", "JPG_Deinit\n");
ret = lock_jpg_mutex();
if(!ret){
log_msg(LOG_ERROR, "s3c_jpeg_exit", "DD::JPG Mutex Lock Fail\r\n");
}
jpg_buff_free(&JPGMem);
jpg_mem_free(&JPGMem);
unlock_jpg_mutex();
delete_jpg_mutex();
platform_driver_unregister(&s3c_jpeg_driver);
printk("S3C JPEG driver module exit\n");
}
static int s3c_jpeg_probe(struct platform_device *pdev)
{
struct resource *res;
static int size;
static int ret;
HANDLE h_Mutex;
// JPEG clock enable
jpeg_hclk = clk_get(&pdev->dev, "hclk_jpeg");
if (!jpeg_hclk || IS_ERR(jpeg_hclk)) {
printk(KERN_ERR "failed to get jpeg hclk source\n");
return -ENOENT;
}
clk_enable(jpeg_hclk);
jpeg_sclk = clk_get(&pdev->dev, "sclk_jpeg");
if (!jpeg_sclk || IS_ERR(jpeg_sclk)) {
printk(KERN_ERR "failed to get jpeg scllk source\n");
return -ENOENT;
}
clk_enable(jpeg_sclk);
/*
post = clk_get(NULL, "post");
if (!post) {
printk(KERN_ERR "failed to get post clock source\n");
return -ENOENT;
}
clk_enable(post);
*/
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
printk(KERN_INFO "failed to get memory region resouce\n");
return -ENOENT;
}
size = (res->end-res->start)+1;
jpeg_mem = request_mem_region(res->start, size, pdev->name);
if (jpeg_mem == NULL) {
printk(KERN_INFO "failed to get memory region\n");
return -ENOENT;
}
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (res == NULL) {
printk(KERN_INFO "failed to get irq resource\n");
return -ENOENT;
}
irq_no = res->start;
ret = request_irq(res->start, s3c_jpeg_irq, 0, pdev->name, pdev);
if (ret != 0) {
printk(KERN_INFO "failed to install irq (%d)\n", ret);
return ret;
}
jpeg_base = ioremap(res->start, size);
if (jpeg_base == 0) {
printk(KERN_INFO "failed to ioremap() region\n");
return -EINVAL;
}
// JPEG clock was set as 66 MHz
if (s3c_jpeg_clock_setup() == FALSE)
return -ENODEV;
log_msg(LOG_TRACE, "s3c_jpeg_probe", "JPG_Init\n");
// Mutex initialization
h_Mutex = create_jpg_mutex();
if (h_Mutex == NULL)
{
log_msg(LOG_ERROR, "s3c_jpeg_probe", "DD::JPG Mutex Initialize error\r\n");
return FALSE;
}
ret = lock_jpg_mutex();
if (!ret){
log_msg(LOG_ERROR, "s3c_jpeg_probe", "DD::JPG Mutex Lock Fail\n");
return FALSE;
}
// Memory initialization
if( !jpeg_mem_mapping(&JPGMem) ){
log_msg(LOG_ERROR, "s3c_jpeg_probe", "DD::JPEG-HOST-MEMORY Initialize error\r\n");
unlock_jpg_mutex();
return FALSE;
}
else {
if (!jpg_buff_mapping(&JPGMem)){
log_msg(LOG_ERROR, "s3c_jpeg_probe", "DD::JPEG-DATA-MEMORY Initialize error : %d\n");
unlock_jpg_mutex();
return FALSE;
}
}
instanceNo = 0;
unlock_jpg_mutex();
ret = misc_register(&s3c_jpeg_miscdev);
clk_disable(jpeg_hclk);
clk_disable(jpeg_sclk);
return 0;
}
static int s3c_jpeg_ioctl(struct inode *inode, struct file *file, unsigned
int cmd, unsigned long arg)
{
static s3c6400_jpg_ctx *JPGRegCtx;
JPG_DEC_PROC_PARAM DecReturn;
JPG_ENC_PROC_PARAM EncParam;
BOOL result = TRUE;
DWORD ret;
int out;
JPGRegCtx = (s3c6400_jpg_ctx *)file->private_data;
if(!JPGRegCtx){
log_msg(LOG_ERROR, "s3c_jpeg_ioctl", "DD::JPG Invalid Input Handle\r\n");
return FALSE;
}
ret = lock_jpg_mutex();
if(!ret){
log_msg(LOG_ERROR, "s3c_jpeg_ioctl", "DD::JPG Mutex Lock Fail\r\n");
return FALSE;
}
switch (cmd)
{
case IOCTL_JPG_DECODE:
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "IOCTL_JPEG_DECODE\n");
out = copy_from_user(&DecReturn, (JPG_DEC_PROC_PARAM *)arg, sizeof(JPG_DEC_PROC_PARAM));
result = decode_jpg(JPGRegCtx, &DecReturn);
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "width : %d hegiht : %d size : %d\n",
DecReturn.width, DecReturn.height, DecReturn.dataSize);
out = copy_to_user((void *)arg, (void *)&DecReturn, sizeof(JPG_DEC_PROC_PARAM));
break;
case IOCTL_JPG_ENCODE:
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "IOCTL_JPEG_ENCODE\n");
out = copy_from_user(&EncParam, (JPG_ENC_PROC_PARAM *)arg, sizeof(JPG_ENC_PROC_PARAM));
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "width : %d hegiht : %d\n",
EncParam.width, EncParam.height);
result = encode_jpg(JPGRegCtx, &EncParam);
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "encoded file size : %d\n", EncParam.fileSize);
out = copy_to_user((void *)arg, (void *)&EncParam, sizeof(JPG_ENC_PROC_PARAM));
break;
case IOCTL_JPG_GET_STRBUF:
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "IOCTL_JPG_GET_STRBUF\n");
unlock_jpg_mutex();
return arg;
case IOCTL_JPG_GET_THUMB_STRBUF:
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "IOCTL_JPG_GET_THUMB_STRBUF\n");
unlock_jpg_mutex();
return arg + JPG_STREAM_BUF_SIZE;
case IOCTL_JPG_GET_FRMBUF:
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "IOCTL_JPG_GET_FRMBUF\n");
unlock_jpg_mutex();
return arg + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE;
case IOCTL_JPG_GET_THUMB_FRMBUF:
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "IOCTL_JPG_GET_THUMB_FRMBUF\n");
unlock_jpg_mutex();
return arg + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE + JPG_FRAME_BUF_SIZE;
case IOCTL_JPG_GET_PHY_FRMBUF:
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "IOCTL_JPG_GET_PHY_FRMBUF\n");
unlock_jpg_mutex();
return jpg_data_base_addr + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE;
case IOCTL_JPG_GET_PHY_THUMB_FRMBUF:
log_msg(LOG_TRACE, "s3c_jpeg_ioctl", "IOCTL_JPG_GET_PHY_THUMB_FRMBUF\n");
unlock_jpg_mutex();
return jpg_data_base_addr + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE + JPG_FRAME_BUF_SIZE;
default :
log_msg(LOG_ERROR, "s3c_jpeg_ioctl", "DD::JPG Invalid ioctl : 0x%X\r\n", cmd);
}
unlock_jpg_mutex();
return result;
}
