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; }
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) { 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; }