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