static int __init jpeg_init(void)
{
int ret;
JPEG_MSG("JPEG Codec initialize\n");
JPEG_MSG("Register the JPEG Codec device\n");
if(platform_device_register(&jpeg_device))
{
JPEG_ERR("failed to register jpeg codec device\n");
ret = -ENODEV;
return ret;
}
JPEG_MSG("Register the JPEG Codec driver\n");
if(platform_driver_register(&jpeg_driver))
{
JPEG_ERR("failed to register jpeg codec driver\n");
platform_device_unregister(&jpeg_device);
ret = -ENODEV;
return ret;
}
return 0;
}
kal_uint32 jpeg_drv_enc_set_dst_buff(kal_uint32 dst_addr, kal_uint32 stall_size, kal_uint32 init_offset, kal_uint32 offset_mask)
{
if (stall_size < 624)
{
JPEG_MSG("JPEGENC:stall offset less than 624 to write header %d!!\n",stall_size);
return 0;
}
if (offset_mask & 0x0F)
{
JPEG_MSG("JPEGENC: set offset addr %x\n", offset_mask);
//return 0;
}
IMG_REG_WRITE( (init_offset & (~0xF)), REG_ADDR_JPEG_ENC_OFFSET_ADDR); //REG_JPEG_ENC_OFFSET_ADDR = init_offset & (~0xF);
IMG_REG_WRITE( (offset_mask & 0xF), REG_ADDR_JPEG_ENC_BYTE_OFFSET_MASK); //REG_JPEG_ENC_BYTE_OFFSET_MASK = (offset_mask & 0xF);
IMG_REG_WRITE( (dst_addr & (~0xF)), REG_ADDR_JPEG_ENC_DST_ADDR0); //REG_JPEG_ENC_DST_ADDR0 = dst_addr & (~0xF);
IMG_REG_WRITE( ((dst_addr + stall_size) & (~0xF)), REG_ADDR_JPEG_ENC_STALL_ADDR0); //REG_JPEG_ENC_STALL_ADDR0 = (dst_addr + stall_size) & (~0xF);
return 1;
}
static int __init jpeg_init(void)
{
int ret;
JPEG_MSG("JPEG Codec initialize\n");
#if 0
JPEG_MSG("Register the JPEG Codec device\n");
if(platform_device_register(&jpeg_device))
{
JPEG_ERR("failed to register jpeg codec device\n");
ret = -ENODEV;
return ret;
}
#endif
JPEG_MSG("Register the JPEG Codec driver\n");
if(platform_driver_register(&jpeg_driver))
{
JPEG_ERR("failed to register jpeg codec driver\n");
platform_device_unregister(&jpeg_device);
ret = -ENODEV;
return ret;
}
cmdqCoreRegisterCB(CMDQ_GROUP_JPEG,
cmdqJpegClockOn,
cmdqJpegDumpInfo,
cmdqJpegResetEng,
cmdqJpegClockOff);
return 0;
}
void jpeg_drv_enc_power_on(void)
{
#ifdef FPGA_VERSION
IMG_REG_WRITE( (0), JPEG_EARLY_MM_BASE);
JPEG_MSG("JPEG Encoder RESET_MM_BASE!!\n");
#endif
JPEG_MSG("JPEG Encoder Power On\n");
}
static int jpeg_remove(struct platform_device *pdev)
{
JPEG_MSG("JPEG Codec remove\n");
//unregister_chrdev(JPEGDEC_MAJOR, JPEGDEC_DEVNAME);
#ifndef FPGA_VERSION
free_irq(MT_JPEG_CODEC_IRQ_ID, NULL);
#endif
JPEG_MSG("Done\n");
return 0;
}
static int jpeg_probe(struct platform_device *pdev)
{
struct class_device;
int ret;
struct class_device *class_dev = NULL;
JPEG_MSG("-------------jpeg driver probe-------\n");
ret = alloc_chrdev_region(&jpeg_devno, 0, 1, JPEG_DEVNAME);
if(ret)
{
JPEG_ERR("Error: Can't Get Major number for JPEG Device\n");
}
else
{
JPEG_MSG("Get JPEG Device Major number (%d)\n", jpeg_devno);
}
jpeg_cdev = cdev_alloc();
jpeg_cdev->owner = THIS_MODULE;
jpeg_cdev->ops = &jpeg_fops;
ret = cdev_add(jpeg_cdev, jpeg_devno, 1);
jpeg_class = class_create(THIS_MODULE, JPEG_DEVNAME);
class_dev = (struct class_device *)device_create(jpeg_class, NULL, jpeg_devno, NULL, JPEG_DEVNAME);
spin_lock_init(&jpeg_dec_lock);
spin_lock_init(&jpeg_enc_lock);
// initial codec, register codec ISR
dec_status = 0;
enc_status = 0;
_jpeg_dec_int_status = 0;
_jpeg_enc_int_status = 0;
#ifndef FPGA_VERSION
init_waitqueue_head(&dec_wait_queue);
init_waitqueue_head(&enc_wait_queue);
enable_irq(MT_JPEG_CODEC_IRQ_ID);
if(request_irq(MT_JPEG_CODEC_IRQ_ID, jpeg_drv_isr, IRQF_TRIGGER_LOW, "jpeg_driver" , NULL))
{
JPEG_ERR("JPEG Codec Driver request irq failed\n");
}
#endif
JPEG_MSG("JPEG Probe Done\n");
NOT_REFERENCED(class_dev);
return 0;
}
void jpeg_drv_enc_dump_reg(void)
{
unsigned int reg_value = 0;
unsigned int index = 0;
JPEG_MSG("===== JPEG ENC DUMP =====\n");
for(index = 0x100 ; index < JPEG_ENC_REG_COUNT ; index += 4){
#ifdef FPGA_VERSION
reg_value = *(volatile kal_uint32 *)(JPEG_ENC_BASE + index);
#else
reg_value = ioread32(JPEG_ENC_BASE + index);
#endif
JPEG_MSG("+0x%x 0x%08x\n", index, reg_value);
}
}
int jpeg_drv_dec_wait_one_row(JPEG_DEC_DRV_IN *config)
{
unsigned int timeout = 0x2FFFFF;
unsigned int irq_status;
unsigned int tri_cnt = ++config->pauseRowCnt; /* 1; */
unsigned int MCU_cnt = 0;
unsigned int base_Y = config->buffer_Y_PA; /* 0x89080000; */
unsigned int base_CB = config->buffer_Cb_PA; /* 0x89040000; */
unsigned int base_CR = config->buffer_Cr_PA; /* 0x89100000; */
unsigned int ring_row_index = tri_cnt % config->tileBufRowNum;
/* for( tri_cnt = 1 ; tri_cnt <= 60 ; tri_cnt++) */
{
/* wait done */
if (config->decodeMode == JPEG_DEC_MODE_MCU_ROW) {
while ((REG_JPGDEC_INTERRUPT_STATUS & BIT_INQST_MASK_ALLIRQ) == 0) {
timeout--;
if (timeout == 0)
break;
}
} else {
while ((REG_JPGDEC_INTERRUPT_STATUS & BIT_INQST_MASK_ALLIRQ) == 0) {
timeout--;
if (timeout == 0)
break;
}
}
irq_status = REG_JPGDEC_INTERRUPT_STATUS;
MCU_cnt = config->mcuPerRow * (tri_cnt + 1);
/* MCU_cnt = config->u4McuNumInRow * (tri_cnt+1) ; */
JPEG_MSG
("JPEG_DEC_WAIT_DONE: tri_cnt %d, irq %x, MCUinRow %d, p_idx %d, %x %x %x!!\n",
tri_cnt, irq_status, config->mcuPerRow, MCU_cnt,
base_Y + ring_row_index * (config->buffer_Y_row_size),
base_CB + ring_row_index * (config->buffer_C_row_size),
base_CR + ring_row_index * (config->buffer_C_row_size));
jpeg_drv_dec_set_dst_bank0(base_Y + ring_row_index * (config->buffer_Y_row_size),
base_CB + ring_row_index * (config->buffer_C_row_size),
base_CR + ring_row_index * (config->buffer_C_row_size));
jpeg_drv_dec_set_pause_mcu_idx(MCU_cnt - 1);
IMG_REG_WRITE((irq_status), REG_ADDR_JPGDEC_INTERRUPT_STATUS);
/* Debug: jpeg_drv_dec_dump_reg(); */
if (timeout == 0) {
JPEG_ERR("Error! Decode Timeout.\n");
jpeg_drv_dec_dump_reg();
return 0;
}
JPEG_ERR("JPEG Decode Success, st %x!!\n", irq_status);
}
return 1;
}
kal_uint32 jpeg_drv_enc_warm_reset(void)
{
kal_uint32 timeout = 0xFFFFF;
REG_JPEG_ENC_CTRL &= ~JPEG_ENC_CTRL_ENABLE_BIT;
//REG_JPEG_ENC_CTRL |= JPEG_ENC_CTRL_ENABLE_BIT;
while (0 == (REG_JPEG_ENC_DEBUG_INFO0 & JPEG_ENC_DEBUG_INFO0_GMC_IDLE_MASK))
{
timeout--;
if (0 == timeout)
{
JPEG_MSG("Wait for GMC IDLE timeout\n");
return 0;
}
}
REG_JPEG_ENC_RSTB &= ~(JPEG_ENC_RST_BIT);
REG_JPEG_ENC_RSTB |= JPEG_ENC_RST_BIT;
IMG_REG_WRITE( (0), REG_ADDR_JPEG_ENC_CODEC_SEL); //REG_JPEG_ENC_CODEC_SEL = 0;
_jpeg_enc_int_status = 0;
return 1;
}
unsigned int jpeg_drv_dec_get_decMCU(void)
{
unsigned int u4Value;
u4Value = REG_JPGDEC_MCU_CNT ;
JPEG_MSG("JPED_DEC_DRV: MCU_CNT %x!!\n", u4Value);
return u4Value;
}
unsigned int jpeg_drv_dec_get_decState(void)
{
unsigned int u4Value;
u4Value = REG_JPGDEC_STATUS ;
JPEG_MSG("JPED_DEC_DRV: STATUS %x!!\n", u4Value);
return u4Value;
}
void jpeg_drv_dec_start(void)
{
#ifndef JPEG_DEC_IRQ_ENHANCE
JPEG_MSG("JPGDC jpeg_drv_dec_start: unmask jpeg irq!\n");
/* unmask jpeg irq */
IMG_REG_WRITE(0x37, REG_ADDR_JPGDEC_IRQ_EN);
#else
unsigned int reg_value;
JPEG_MSG("JPGDC jpeg_drv_dec_start: JPEG_DEC_IRQ_ENHANCE!\n");
IMG_REG_READ(reg_value, REG_ADDR_JPGDEC_IRQ_EN);
reg_value |= BIT_DEC_IRQ_EN_DEBUG_BRP_FLAG;
IMG_REG_WRITE(reg_value, REG_ADDR_JPGDEC_IRQ_EN);
#endif
IMG_REG_WRITE(0, REG_ADDR_JPGDEC_TRIG); /* REG_JPGDEC_TRIG = 0; */
}
kal_uint32 jpeg_drv_enc_set_chroma_addr(kal_uint32 src_chroma_addr)
{
if (src_chroma_addr & 0x0F) {
JPEG_MSG("JPEGENC: set CHROMA addr not align (%x)!!\n", src_chroma_addr);
/* return 0; */
}
IMG_REG_WRITE((src_chroma_addr), REG_ADDR_JPEG_ENC_SRC_CHROMA_ADDR);
return 1;
}
kal_uint32 jpeg_drv_enc_set_offset_addr(kal_uint32 offset)
{
if (offset & 0x0F) {
JPEG_MSG("JPEGENC:WARN set offset addr %x\n", offset);
/* return 0; */
}
IMG_REG_WRITE((offset), REG_ADDR_JPEG_ENC_OFFSET_ADDR); /* REG_JPEG_ENC_OFFSET_ADDR = offset; */
return 1;
}
kal_uint32 jpeg_drv_enc_set_memory_stride(kal_uint32 mem_stride)
{
if ( mem_stride & 0x0F )
{
JPEG_MSG("JPEGENC: set memory stride failed, not align to 0x1f (%x)!!\n", mem_stride);
return 0;
}
IMG_REG_WRITE( (mem_stride), REG_ADDR_JPEG_ENC_STRIDE); //REG_JPEG_ENC_STRIDE = (mem_stride);
return 1;
}
kal_uint32 jpeg_drv_enc_set_luma_addr(kal_uint32 src_luma_addr)
{
if (src_luma_addr & 0x0F)
{
JPEG_MSG("JPEGENC: set LUMA addr not align (%x)!!\n", src_luma_addr);
//return 0;
}
IMG_REG_WRITE( (src_luma_addr), REG_ADDR_JPEG_ENC_SRC_LUMA_ADDR); //REG_JPEG_ENC_SRC_LUMA_ADDR = src_luma_addr;
return 1;
}
static void __exit jpeg_exit(void)
{
cdev_del(jpeg_cdev);
unregister_chrdev_region(jpeg_devno, 1);
//JPEG_MSG("Unregistering driver\n");
platform_driver_unregister(&jpeg_driver);
platform_device_unregister(&jpeg_device);
device_destroy(jpeg_class, jpeg_devno);
class_destroy(jpeg_class);
JPEG_MSG("Done\n");
}
kal_uint32 jpeg_drv_enc_set_image_stride(kal_uint32 img_stride)
{
if (img_stride & 0x0F)
{
JPEG_MSG("JPEGENC: set image stride failed, not align to 0x0f (%x)!!\n", img_stride);
return 0;
}
IMG_REG_WRITE( (img_stride), REG_ADDR_JPEG_ENC_IMG_STRIDE); //REG_JPEG_ENC_IMG_STRIDE = (img_stride);
return 1;
}
kal_uint32 jpeg_drv_enc_set_quality(kal_uint32 quality)
{
unsigned int u4Value ;
if (quality == 0x8 || quality == 0xC)
{
JPEG_MSG("JPEGENC: set quality failed\n");
return 0;
}
u4Value = REG_JPEG_ENC_QUALITY;
u4Value = (u4Value & 0xFFFF0000) | quality ;
IMG_REG_WRITE( (u4Value), REG_ADDR_JPEG_ENC_QUALITY); //REG_JPEG_ENC_QUALITY = (REG_JPEG_ENC_QUALITY & 0xFFFF0000) | quality;
return 1;
}
kal_uint32 jpeg_drv_enc_set_img_size(kal_uint32 width, kal_uint32 height)
{
unsigned int u4Value ;
if ((width & 0xffff0000) || (height & 0xffff0000))
{
JPEG_MSG("JPEGENC: img size exceed 65535, (%x, %x)!!\n", width, height);
return 0;
}
u4Value = (width << 16) | height ;
IMG_REG_WRITE( (u4Value), REG_ADDR_JPEG_ENC_IMG_SIZE); //REG_JPEG_ENC_IMG_SIZE = (width << 16) | height;
return 1;
}
kal_uint32 jpeg_drv_enc_get_result(kal_uint32 *fileSize)
{
*fileSize = jpeg_drv_enc_get_file_size();
if (_jpeg_enc_int_status & JPEG_DRV_ENC_INT_STATUS_DONE)
return 0;
else if (_jpeg_enc_int_status & JPEG_DRV_ENC_INT_STATUS_STALL)
return 1;
else if (_jpeg_enc_int_status & JPEG_DRV_ENC_INT_STATUS_VCODEC_IRQ)
return 2;
JPEG_MSG("JPEGENC: int_st %x!!\n", _jpeg_enc_int_status);
return 3;
}
kal_uint32 jpeg_drv_enc_get_result(kal_uint32 *fileSize)
{
*fileSize = jpeg_drv_enc_get_file_size();
if(_jpeg_enc_int_status & JPEG_DRV_ENC_INT_STATUS_DONE)
{
return 0;
}
else if(_jpeg_enc_int_status & JPEG_DRV_ENC_INT_STATUS_STALL)
{
return 1;
}
JPEG_MSG("JPEGENC: int_st %x\n", _jpeg_enc_int_status);
return 2;
}
kal_uint32 jpeg_drv_enc_set_src_buf(kal_uint32 yuv_format, kal_uint32 img_stride, kal_uint32 mem_stride, kal_uint32 srcAddr, kal_uint32 srcAddr_C)
{
kal_uint32 ret = 1;
if( yuv_format == 0x00 || yuv_format == 0x01 ){
if( (mem_stride & 0x1f) || (img_stride & 0x1f) ){
JPEG_MSG("JPEGENC: set image/memory stride not align 0x1f in fmt %x(%x/%x)!!\n", yuv_format, mem_stride, img_stride);
ret = 0;
}
}
ret &= jpeg_drv_enc_set_image_stride(img_stride);
ret &= jpeg_drv_enc_set_memory_stride(mem_stride);
ret &= jpeg_drv_enc_set_luma_addr(srcAddr);
ret &= jpeg_drv_enc_set_chroma_addr(srcAddr_C);
return ret;
}
static irqreturn_t jpeg_drv_isr(int irq, void *dev_id)
{
JPEG_MSG("JPEG Codec Interrupt\n");
//jpeg_reg_dump();
if(irq == MT_JPEG_CODEC_IRQ_ID)
{
if(jpeg_isr_dec_lisr() == 0)
{
wake_up_interruptible(&dec_wait_queue);
}
if(jpeg_isr_enc_lisr() == 0)
{
wake_up_interruptible(&enc_wait_queue);
}
}
return IRQ_HANDLED;
}
/* workaround for jpeg odd read operation at cg gating state */
void jpeg_drv_dec_verify_state_and_reset(void)
{
unsigned int temp, value;
IMG_REG_WRITE(0x00, REG_ADDR_JPGDEC_RESET);
IMG_REG_WRITE(0x00, REG_ADDR_JPGDEC_RESET);
IMG_REG_WRITE(0x10, REG_ADDR_JPGDEC_RESET);
IMG_REG_WRITE(0x10, REG_ADDR_JPGDEC_RESET);
IMG_REG_READ(temp, REG_ADDR_JPGDEC_ULTRA_THRES);
IMG_REG_READ(value, REG_ADDR_JPGDEC_FILE_ADDR);
/* issue happen, need to do 1 read at cg gating state */
if (value == 0xFFFFFFFF) {
JPEG_MSG("JPGDEC APB R/W issue found, start to do recovery!\n");
jpeg_drv_dec_power_off();
IMG_REG_READ(value, REG_ADDR_JPGDEC_ULTRA_THRES);
jpeg_drv_dec_power_on();
}
_jpeg_dec_int_status = 0;
_jpeg_dec_mode = 0;
}
static void __exit jpeg_exit(void)
{
#ifdef JPEG_DEV
cdev_del(jpeg_cdev);
unregister_chrdev_region(jpeg_devno, 1);
device_destroy(jpeg_class, jpeg_devno);
class_destroy(jpeg_class);
#else
remove_proc_entry("mtk_jpeg", NULL);
#endif
cmdqCoreRegisterCB(CMDQ_GROUP_JPEG,
NULL,
NULL,
NULL,
NULL);
//JPEG_MSG("Unregistering driver\n");
platform_driver_unregister(&jpeg_driver);
platform_device_unregister(&jpeg_device);
JPEG_MSG("Done\n");
}
kal_uint32 jpeg_drv_dec_get_result(void)
{
JPEG_MSG("[JPEGDRV] get_result mode %x, irq_sts %x!!\n", _jpeg_dec_mode,
_jpeg_dec_int_status);
/* if(_jpeg_dec_mode == 1){ */
/* if(_jpeg_dec_int_status & BIT_INQST_MASK_END ) */
/* REG_JPGDEC_INTERRUPT_STATUS = _jpeg_dec_int_status ; */
/* } */
if (_jpeg_dec_int_status & BIT_INQST_MASK_EOF)
return 0;
else if (_jpeg_dec_int_status & BIT_INQST_MASK_PAUSE)
return 1;
else if (_jpeg_dec_int_status & BIT_INQST_MASK_UNDERFLOW)
return 2;
else if (_jpeg_dec_int_status & BIT_INQST_MASK_OVERFLOW)
return 3;
else if (_jpeg_dec_int_status & BIT_INQST_MASK_ERROR_BS)
return 4;
return 5;
}
//static irqreturn_t jpeg_drv_isr(int irq, void *dev_id)
static __tcmfunc irqreturn_t jpeg_drv_isr(int irq, void *dev_id)
{
JPEG_MSG("JPEG Codec Interrupt\n");
//jpeg_reg_dump();
if(irq == MT6573_JPG_CODEC_IRQ_LINE)
{
mt6573_irq_mask(MT6573_JPG_CODEC_IRQ_LINE);
if(jpeg_isr_dec_lisr() == 0)
{
wake_up_interruptible(&dec_wait_queue);
}
if(jpeg_isr_enc_lisr() == 0)
{
wake_up_interruptible(&enc_wait_queue);
}
mt6573_irq_unmask(MT6573_JPG_CODEC_IRQ_LINE);
}
return IRQ_HANDLED;
}
static ssize_t jpeg_read(struct file *file, char __user *data, size_t len, loff_t *ppos)
{
JPEG_MSG("jpeg driver read\n");
return 0;
}
static int jpeg_enc_ioctl(unsigned int cmd, unsigned long arg, struct file *file)
{
int retValue;
//unsigned int decResult;
long timeout_jiff;
unsigned int file_size, enc_result_code;
//unsigned int _jpeg_enc_int_status;
unsigned int jpeg_enc_wait_timeout = 0;
unsigned int cycle_count;
unsigned int ret ;
unsigned int *pStatus;
//JpegDrvEncParam cfgEnc;
JPEG_ENC_DRV_IN cfgEnc;
JpegDrvEncResult enc_result;
//JpegDrvEncSrcCfg src_cfg;
//JpegDrvEncDstCfg dst_cfg;
//JpegDrvEncCtrlCfg ctrl_cfg;
pStatus = (unsigned int*)file->private_data;
if(NULL == pStatus)
{
JPEG_WRN("Private data is null in flush operation. HOW COULD THIS HAPPEN ??\n");
return -EFAULT;
}
switch(cmd)
{
case JPEG_ENC_IOCTL_RW_REG:
//jpeg_drv_enc_rw_reg();
break;
// initial and reset JPEG encoder
case JPEG_ENC_IOCTL_INIT:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Encoder Init!!\n");
retValue = jpeg_drv_enc_init();
if(retValue == 0)
{
*pStatus = JPEG_ENC_PROCESS;
}
return retValue;
break;
case JPEG_ENC_IOCTL_WARM_RESET:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Encoder Warm Reset\n");
enc_result_code = jpeg_drv_enc_warm_reset();
if (0 == enc_result_code)
{
return -EFAULT;
}
break;
// configure the register
case JPEG_ENC_IOCTL_CONFIG:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Encoder Configure Hardware\n");
if(*pStatus != JPEG_ENC_PROCESS)
{
JPEG_WRN("Permission Denied! This process can not access encoder");
return -EFAULT;
}
if(enc_status == 0)
{
JPEG_WRN("Encoder status is available, HOW COULD THIS HAPPEN ??");
*pStatus = 0;
return -EFAULT;
}
// copy input parameters
if(copy_from_user(&cfgEnc, (void *)arg, sizeof(JPEG_ENC_DRV_IN)))
{
JPEG_MSG("[JPEGDRV]JPEG Encoder : Copy from user error\n");
return -EFAULT;
}
// 0. reset
jpeg_drv_enc_reset();
// 1. set src config
//memset(&src_cfg, 0, sizeof(JpegDrvEncSrcCfg));
//src_cfg.luma_addr = cfgEnc.srcBufferAddr;
//if (cfgEnc.encFormat == NV12 || cfgEnc.encFormat == NV21)
//{
// unsigned int srcChromaAddr = cfgEnc.srcChromaAddr;
// srcChromaAddr = TO_CEIL(srcChromaAddr, 128); //((srcChromaAddr+127)&~127);
// src_cfg.chroma_addr = srcChromaAddr;
//}
//
//src_cfg.width = cfgEnc.encWidth;
//src_cfg.height = cfgEnc.encHeight;
//src_cfg.yuv_format = cfgEnc.encFormat;
// 1. set src config
JPEG_MSG("[JPEGDRV]SRC_IMG: %x %x, DU:%x, fmt:%x!!\n", cfgEnc.encWidth, cfgEnc.encHeight, cfgEnc.totalEncDU, cfgEnc.encFormat);
ret = jpeg_drv_enc_set_src_image(cfgEnc.encWidth, cfgEnc.encHeight, cfgEnc.encFormat, cfgEnc.totalEncDU) ;
if(ret == 0) {
JPEG_MSG("[JPEGDRV]JPEG Encoder set srouce image failed\n");
return -EFAULT;
}
// 2. set src buffer info
JPEG_MSG("[JPEGDRV]SRC_BUF: addr %x, %x, stride %x, %x!!\n", cfgEnc.srcBufferAddr, cfgEnc.srcChromaAddr ,cfgEnc.imgStride, cfgEnc.memStride);
ret = jpeg_drv_enc_set_src_buf(cfgEnc.encFormat, cfgEnc.imgStride, cfgEnc.memStride, cfgEnc.srcBufferAddr, cfgEnc.srcChromaAddr);
if(ret == 0) {
JPEG_MSG("[JPEGDRV]JPEG Encoder set srouce buffer failed\n");
return -EFAULT;
}
//if (0 == jpeg_drv_enc_src_cfg(src_cfg))
//{
// JPEG_MSG("JPEG Encoder src cfg failed\n");
// return -EFAULT;
//}
// 3. set dst buffer info
JPEG_MSG("[JPEGDRV]DST_BUF: addr:%x, size:%x, ofs:%x, mask:%x!!\n",cfgEnc.dstBufferAddr, cfgEnc.dstBufferSize, cfgEnc.dstBufAddrOffset, cfgEnc.dstBufAddrOffsetMask);
ret = jpeg_drv_enc_set_dst_buff(cfgEnc.dstBufferAddr, cfgEnc.dstBufferSize, cfgEnc.dstBufAddrOffset, cfgEnc.dstBufAddrOffsetMask);
if (ret == 0 ) {
JPEG_MSG("[JPEGDRV]JPEG Encoder set dst buffer failed\n");
return -EFAULT;
}
//memset(&dst_cfg, 0, sizeof(JpegDrvEncDstCfg));
//
//dst_cfg.dst_addr = cfgEnc.dstBufferAddr;
//dst_cfg.dst_size = cfgEnc.dstBufferSize;
//dst_cfg.exif_en = cfgEnc.enableEXIF;
//
//JPEG_MSG("go L:%d, %x, %d, %d !!", __LINE__, dst_cfg.dst_addr, dst_cfg.dst_size, dst_cfg.file_format);
//
//if (0 == jpeg_drv_enc_dst_buff(dst_cfg))
// return -EFAULT;
// 4 .set ctrl config
JPEG_MSG("[JPEGDRV]ENC_CFG: exif:%d, q:%d, DRI:%d !!\n", cfgEnc.enableEXIF, cfgEnc.encQuality, cfgEnc.restartInterval);
jpeg_drv_enc_ctrl_cfg(cfgEnc.enableEXIF, cfgEnc.encQuality, cfgEnc.restartInterval);
//memset(&ctrl_cfg, 0, sizeof(JpegDrvEncCtrlCfg));
//
//ctrl_cfg.quality = cfgEnc.encQuality;
//ctrl_cfg.gmc_disable = cfgEnc.disableGMC;
//ctrl_cfg.restart_interval = cfgEnc.restartInterval;
//
break;
case JPEG_ENC_IOCTL_START:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Encoder Start!!\n");
if(*pStatus != JPEG_ENC_PROCESS)
{
JPEG_WRN("Permission Denied! This process can not access encoder");
return -EFAULT;
}
if(enc_status == 0)
{
JPEG_WRN("Encoder status is available, HOW COULD THIS HAPPEN ??");
*pStatus = 0;
return -EFAULT;
}
jpeg_drv_enc_start();
break;
case JPEG_ENC_IOCTL_WAIT:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Encoder Wait!!\n");
if(*pStatus != JPEG_ENC_PROCESS)
{
JPEG_WRN("Permission Denied! This process can not access encoder");
return -EFAULT;
}
if(enc_status == 0)
{
JPEG_WRN("Encoder status is available, HOW COULD THIS HAPPEN ??");
*pStatus = 0;
return -EFAULT;
}
if(copy_from_user(&enc_result, (void *)arg, sizeof(JpegDrvEncResult)))
{
JPEG_WRN("JPEG Encoder : Copy from user error\n");
return -EFAULT;
}
//#ifdef FPGA_VERSION
//TODO: ENC_DONE in REG_JPEG_ENC_INTERRUPT_STATUS need to set to 0 after read.
jpeg_enc_wait_timeout = 0xFFFFFF;
#if 0
do {
_jpeg_enc_int_status = REG_JPEG_ENC_INTERRUPT_STATUS;
jpeg_enc_wait_timeout--;
} while(_jpeg_enc_int_status == 0 && jpeg_enc_wait_timeout > 0);
if (jpeg_enc_wait_timeout == 0)
JPEG_MSG("JPEG Encoder timeout\n");
ret = jpeg_drv_enc_get_result(&file_size);
JPEG_MSG("Result : %d, Size : %u, addres : 0x%x\n", ret, file_size, ioread32(JPG_CODEC_BASE + 0x120));
if(_jpeg_enc_int_status != 1)
{
jpeg_drv_enc_dump_reg();
}
#else
//set timeout
timeout_jiff = enc_result.timeout* HZ / 1000;
JPEG_MSG("[JPEGDRV]JPEG Encoder Time Jiffies : %ld\n", timeout_jiff);
if(jpeg_isr_enc_lisr()<0) {
wait_event_interruptible_timeout(enc_wait_queue, _jpeg_enc_int_status, timeout_jiff);
JPEG_MSG("[JPEGDRV]JPEG Encoder Wait done !!\n");
} else {
JPEG_MSG("[JPEGDRV]JPEG Encoder already done !!\n");
}
ret = jpeg_drv_enc_get_result(&file_size);
JPEG_MSG("[JPEGDRV]Result : %d, Size : %u!!\n", ret, file_size);
if(ret != 0)
{
jpeg_drv_enc_dump_reg();
}
#endif
cycle_count = jpeg_drv_enc_get_cycle_count();
if(copy_to_user(enc_result.pFileSize, &file_size, sizeof(unsigned int)))
{
JPEG_MSG("[JPEGDRV]JPEG Encoder : Copy to user error (file size)\n");
return -EFAULT;
}
if(copy_to_user(enc_result.pResult, &ret, sizeof(unsigned int)))
{
JPEG_MSG("[JPEGDRV]JPEG Encoder : Copy to user error (status)\n");
return -EFAULT;
}
if(copy_to_user(enc_result.pCycleCount, &cycle_count, sizeof(unsigned int)))
{
JPEG_MSG("[JPEGDRV]JPEG Encoder : Copy to user error (cycle)\n");
return -EFAULT;
}
break;
case JPEG_ENC_IOCTL_DEINIT:
JPEG_MSG("[JPEGDRV][IOCTL] JPEG Encoder Deinit!!\n");
// copy input parameters
if(*pStatus != JPEG_ENC_PROCESS)
{
JPEG_WRN("Permission Denied! This process can not access encoder");
return -EFAULT;
}
if(enc_status == 0)
{
JPEG_WRN("Encoder status is available, HOW COULD THIS HAPPEN ??");
*pStatus = 0;
return -EFAULT;
}
jpeg_drv_enc_deinit();
*pStatus = 0;
break;
case JPEG_ENC_IOCTL_DUMP_REG:
jpeg_drv_enc_dump_reg();
break;
default:
JPEG_MSG("[JPEGDRV]JPEG ENC IOCTL NO THIS COMMAND\n");
}
return 0;
}
