645 lines
15 KiB
C
645 lines
15 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (c) 2020 MediaTek Inc.
|
|
*/
|
|
#ifdef JPEG_ENC_DRIVER
|
|
#include <linux/kernel.h>
|
|
/* #include <linux/xlog.h> */
|
|
|
|
#include "jpeg_drv_reg.h"
|
|
#include "jpeg_drv_common.h"
|
|
|
|
#define JPEG_ENC_RST_BIT 0x1
|
|
|
|
#define JPEG_ENC_CTRL_ENABLE_BIT 0x01
|
|
#define JPEG_ENC_CTRL_DIS_GMC_BIT 0x02
|
|
#define JPEG_ENC_CTRL_INT_EN_BIT 0x04
|
|
#define JPEG_ENC_CTRL_YUV_BIT 0x18
|
|
#define JPEG_ENC_CTRL_FILE_FORMAT_BIT 0x20
|
|
#define JPEG_ENC_CTRL_GRAY_EN_BIT 0x80
|
|
#define JPEG_ENC_CTRL_ULTRA_HIGH_EN_BIT 0x200
|
|
#define JPEG_ENC_CTRL_RESTART_EN_BIT 0x400
|
|
#define JPEG_ENC_CTRL_BURST_TYPE_MASK 0x00007000
|
|
#define JPEG_ENC_CTRL_BURST_TYPE_SHIFT_COUNT 12
|
|
|
|
#define JPEG_ENC_EN_DIS_GMC (1 << 2)
|
|
#define JPEG_ENC_EN_JFIF_EXIF (1 << 5)
|
|
#define JPEG_ENC_EN_SELF_INIT (1 << 16)
|
|
|
|
#define JPEG_ENC_DEBUG_INFO0_GMC_IDLE_MASK (1 << 13)
|
|
|
|
|
|
|
|
unsigned int _jpeg_enc_int_status;
|
|
|
|
static struct ion_handle *jpeg_ion_import_handle(struct ion_client *client, int fd)
|
|
{
|
|
struct ion_handle *handle = NULL;
|
|
struct ion_mm_data mm_data;
|
|
|
|
/* If no need Ion support, do nothing! */
|
|
if (fd < 0) {
|
|
JPEG_MSG("NO NEED ion support, fd %d\n", fd);
|
|
return handle;
|
|
}
|
|
|
|
if (!client) {
|
|
JPEG_MSG("invalid ion client!\n");
|
|
return handle;
|
|
}
|
|
|
|
handle = ion_import_dma_buf_fd(client, fd);
|
|
if (IS_ERR(handle)) {
|
|
JPEG_MSG("import ion handle failed!\n");
|
|
return NULL;
|
|
}
|
|
mm_data.mm_cmd = ION_MM_CONFIG_BUFFER;
|
|
mm_data.config_buffer_param.kernel_handle = handle;
|
|
mm_data.config_buffer_param.module_id = 0;
|
|
mm_data.config_buffer_param.security = 0;
|
|
mm_data.config_buffer_param.coherent = 0;
|
|
|
|
if (ion_kernel_ioctl(client, ION_CMD_MULTIMEDIA,
|
|
(unsigned long)&mm_data))
|
|
JPEG_MSG("configure ion buffer failed!\n");
|
|
|
|
JPEG_MSG("import ion handle fd=%d,hnd=0x%p\n", fd, handle);
|
|
|
|
return handle;
|
|
}
|
|
|
|
static int jpeg_ion_get_mva(struct ion_client *client, struct ion_handle *handle,
|
|
dma_addr_t *mva, unsigned int *size, int port)
|
|
{
|
|
struct ion_mm_data mm_data;
|
|
size_t mva_size = 0;
|
|
ion_phys_addr_t phy_addr = 0;
|
|
|
|
memset((void *)&mm_data, 0, sizeof(struct ion_mm_data));
|
|
mm_data.config_buffer_param.module_id = port;
|
|
mm_data.config_buffer_param.kernel_handle = handle;
|
|
mm_data.mm_cmd = ION_MM_CONFIG_BUFFER;
|
|
if (ion_kernel_ioctl(client, ION_CMD_MULTIMEDIA,
|
|
(unsigned long)&mm_data) < 0) {
|
|
|
|
JPEG_MSG("config buffer failed.%p -%p\n",
|
|
client, handle);
|
|
ion_free(client, handle);
|
|
return -1;
|
|
}
|
|
|
|
ion_phys(client, handle, &phy_addr, &mva_size);
|
|
*mva = phy_addr;
|
|
*size = mva_size;
|
|
JPEG_MSG("alloc mmu addr hnd=0x%p,mva=0x%p size %d\n",
|
|
handle, *mva, *size);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void jpeg_ion_free_handle(struct ion_client *client, struct ion_handle *handle)
|
|
{
|
|
if (!client) {
|
|
JPEG_MSG("invalid ion client!\n");
|
|
return;
|
|
}
|
|
if (!handle)
|
|
return;
|
|
|
|
ion_free(client, handle);
|
|
|
|
JPEG_MSG("free ion handle 0x%p\n", handle);
|
|
}
|
|
int jpeg_isr_enc_lisr(void)
|
|
{
|
|
unsigned int tmp, tmp1;
|
|
/* _jpeg_enc_int_status = REG_JPEG_ENC_INTERRUPT_STATUS; */
|
|
tmp1 = IMG_REG_READ(REG_ADDR_JPEG_ENC_INTERRUPT_STATUS);
|
|
tmp = tmp1 & (JPEG_DRV_ENC_INT_STATUS_MASK_ALLIRQ);
|
|
if (tmp) {
|
|
_jpeg_enc_int_status = tmp;
|
|
|
|
/* / clear the interrupt status register */
|
|
/* if(_jpeg_enc_int_status) */
|
|
/* { */
|
|
IMG_REG_WRITE(0, REG_ADDR_JPEG_ENC_INTERRUPT_STATUS);
|
|
return 0;
|
|
/* } */
|
|
} else if (_jpeg_enc_int_status) {
|
|
IMG_REG_WRITE(0, REG_ADDR_JPEG_ENC_INTERRUPT_STATUS);
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_src_image(
|
|
unsigned int width,
|
|
unsigned int height,
|
|
unsigned int yuv_format,
|
|
unsigned int totalEncDU)
|
|
{
|
|
unsigned int ret = 1;
|
|
|
|
ret &= jpeg_drv_enc_set_img_size(width, height);
|
|
|
|
ret &= jpeg_drv_enc_set_encFormat(yuv_format);
|
|
|
|
ret &= jpeg_drv_enc_set_blk_num(totalEncDU);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_src_buf(struct ion_client *pIonClient,
|
|
unsigned int yuv_format, unsigned int img_stride,
|
|
unsigned int mem_stride, unsigned int mem_height,
|
|
int srcFd, int srcFd2)
|
|
{
|
|
unsigned int ret = 1;
|
|
dma_addr_t srcAddr = 0;
|
|
dma_addr_t srcAddr_C = 0;
|
|
unsigned int bufSize = 0;
|
|
struct ion_handle *handle = NULL;
|
|
|
|
if (yuv_format == 0x00 || yuv_format == 0x01) {
|
|
if ((mem_stride & 0x1f) || (img_stride & 0x1f)) {
|
|
JPEG_MSG
|
|
("JPGENC:imag/mem stride not align fmt %x(%x/%x)\n",
|
|
yuv_format, mem_stride, img_stride);
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
if (yuv_format == YUYV || yuv_format == YVYU) {
|
|
handle = jpeg_ion_import_handle(pIonClient, srcFd);
|
|
if (handle == NULL) {
|
|
JPEG_MSG("import handle fail line %d\n", __LINE__);
|
|
return 0;
|
|
}
|
|
if (jpeg_ion_get_mva(pIonClient, handle, &srcAddr, &bufSize, 0) != 0)
|
|
return 0;
|
|
|
|
jpeg_ion_free_handle(pIonClient, handle);
|
|
srcAddr_C = 0;
|
|
|
|
JPEG_MSG("srcAddr 0x%p srcAddr_C 0x%p line %d\n", srcAddr, srcAddr_C, __LINE__);
|
|
} else if (srcFd == srcFd2) {
|
|
handle = jpeg_ion_import_handle(pIonClient, srcFd);
|
|
if (handle == NULL) {
|
|
JPEG_MSG("import handle fail line %d\n", __LINE__);
|
|
return 0;
|
|
}
|
|
if (jpeg_ion_get_mva(pIonClient, handle, &srcAddr, &bufSize, 0) != 0)
|
|
return 0;
|
|
|
|
jpeg_ion_free_handle(pIonClient, handle);
|
|
srcAddr_C = (dma_addr_t)mem_stride*mem_height + srcAddr;
|
|
JPEG_MSG("srcAddr 0x%p srcAddr_C 0x%p line %d\n", srcAddr, srcAddr_C, __LINE__);
|
|
} else {
|
|
handle = jpeg_ion_import_handle(pIonClient, srcFd);
|
|
if (handle == NULL) {
|
|
JPEG_MSG("import handle fail line %d\n", __LINE__);
|
|
return 0;
|
|
}
|
|
if (jpeg_ion_get_mva(pIonClient, handle, &srcAddr, &bufSize, 0) != 0)
|
|
return 0;
|
|
|
|
jpeg_ion_free_handle(pIonClient, handle);
|
|
|
|
handle = jpeg_ion_import_handle(pIonClient, srcFd2);
|
|
if (handle == NULL) {
|
|
JPEG_MSG("import handle fail line %d\n", __LINE__);
|
|
return 0;
|
|
}
|
|
if (jpeg_ion_get_mva(pIonClient, handle, &srcAddr_C, &bufSize, 0) != 0)
|
|
return 0;
|
|
|
|
jpeg_ion_free_handle(pIonClient, handle);
|
|
|
|
JPEG_MSG("srcAddr 0x%p srcAddr_C 0x%p line %d\n", srcAddr, srcAddr_C, __LINE__);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_ctrl_cfg(unsigned int exif_en, unsigned int quality,
|
|
unsigned int restart_interval)
|
|
{
|
|
jpeg_drv_enc_set_quality(quality);
|
|
|
|
jpeg_drv_enc_set_restart_interval(restart_interval);
|
|
|
|
jpeg_drv_enc_set_EncodeMode(exif_en);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
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) {
|
|
/* reg_value = ioread32(JPEG_ENC_BASE + index); */
|
|
reg_value = IMG_REG_READ(JPEG_ENC_BASE + index);
|
|
JPEG_MSG("+0x%x 0x%08x\n", index, reg_value);
|
|
}
|
|
}
|
|
|
|
|
|
void jpeg_drv_enc_start(void)
|
|
{
|
|
unsigned int u4Value;
|
|
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
|
|
u4Value |= (JPEG_ENC_CTRL_INT_EN_BIT | JPEG_ENC_CTRL_ENABLE_BIT);
|
|
/* REG_JPEG_ENC_CTRL |= */
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
|
|
/*(JPEG_ENC_CTRL_INT_EN_BIT | JPEG_ENC_CTRL_ENABLE_BIT); */
|
|
}
|
|
|
|
|
|
/* workaround for jpeg odd read operation at cg gating state */
|
|
void jpeg_drv_enc_verify_state_and_reset(void)
|
|
{
|
|
unsigned int temp, value;
|
|
|
|
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_RSTB);
|
|
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_RSTB);
|
|
IMG_REG_WRITE((1), REG_ADDR_JPEG_ENC_RSTB);
|
|
IMG_REG_WRITE((1), REG_ADDR_JPEG_ENC_RSTB);
|
|
|
|
temp = IMG_REG_READ(REG_ADDR_JPEG_ENC_ULTRA_THRES);
|
|
value = IMG_REG_READ(REG_ADDR_JPEG_ENC_DMA_ADDR0);
|
|
|
|
/* issue happen, need to do 1 read at cg gating state */
|
|
if (value == 0xFFFFFFFF) {
|
|
JPEG_MSG("JPGENC APB R/W issue found, start to do recovery!\n");
|
|
jpeg_drv_enc_power_off();
|
|
value = IMG_REG_READ(REG_ADDR_JPEG_ENC_ULTRA_THRES);
|
|
jpeg_drv_enc_power_on();
|
|
}
|
|
|
|
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_CODEC_SEL);
|
|
|
|
_jpeg_enc_int_status = 0;
|
|
}
|
|
|
|
|
|
void jpeg_drv_enc_reset(void)
|
|
{
|
|
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_RSTB);
|
|
IMG_REG_WRITE((1), REG_ADDR_JPEG_ENC_RSTB);
|
|
|
|
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_CODEC_SEL);
|
|
|
|
_jpeg_enc_int_status = 0;
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_warm_reset(void)
|
|
{
|
|
unsigned int timeout = 0xFFFFF;
|
|
unsigned int u4Value;
|
|
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
|
|
u4Value &= ~JPEG_ENC_CTRL_ENABLE_BIT;
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
|
|
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
|
|
u4Value |= JPEG_ENC_CTRL_ENABLE_BIT;
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
|
|
|
|
|
|
while (0 ==
|
|
(IMG_REG_READ(REG_ADDR_JPEG_ENC_DEBUG_INFO0) &
|
|
JPEG_ENC_DEBUG_INFO0_GMC_IDLE_MASK)) {
|
|
timeout--;
|
|
if (timeout == 0) {
|
|
JPEG_MSG("Wait for GMC IDLE timeout\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_RSTB);
|
|
u4Value &= ~(JPEG_ENC_RST_BIT);
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_RSTB);
|
|
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_RSTB);
|
|
u4Value |= JPEG_ENC_RST_BIT;
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_RSTB);
|
|
|
|
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_CODEC_SEL);
|
|
|
|
_jpeg_enc_int_status = 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_encFormat(unsigned int encFormat)
|
|
{
|
|
unsigned int val;
|
|
unsigned int u4Value;
|
|
|
|
if (encFormat & (~3)) {
|
|
JPEG_ERR("JPEG_DRV_ENC: set encFormat Err %d!!\n", encFormat);
|
|
return 0;
|
|
}
|
|
|
|
val = (encFormat & 3) << 3;
|
|
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
|
|
|
|
u4Value &= ~JPEG_ENC_CTRL_YUV_BIT;
|
|
|
|
u4Value |= val;
|
|
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_quality(unsigned int quality)
|
|
{
|
|
unsigned int u4Value;
|
|
|
|
if (quality == 0x8 || quality == 0xC) {
|
|
JPEG_MSG("JPEGENC: set quality failed\n");
|
|
return 0;
|
|
}
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_QUALITY);
|
|
|
|
u4Value = (u4Value & 0xFFFF0000) | quality;
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_QUALITY);
|
|
return 1;
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_img_size(unsigned int width, unsigned int height)
|
|
{
|
|
unsigned int u4Value;
|
|
|
|
if ((width & 0xffff0000) || (height & 0xffff0000)) {
|
|
JPEG_MSG("JPGENC: 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);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_blk_num(unsigned int blk_num) /* NO_USE */
|
|
{
|
|
if (blk_num < 4)
|
|
return 0;
|
|
|
|
IMG_REG_WRITE((blk_num), REG_ADDR_JPEG_ENC_BLK_NUM);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_luma_addr(dma_addr_t src_luma_addr)
|
|
{
|
|
if (src_luma_addr & 0x0F)
|
|
JPEG_MSG("JPGENC: set LUMA addr not align (%x)\n",
|
|
src_luma_addr);
|
|
|
|
IMG_REG_WRITE((src_luma_addr), REG_ADDR_JPEG_ENC_SRC_LUMA_ADDR);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_chroma_addr(dma_addr_t src_chroma_addr)
|
|
{
|
|
if (src_chroma_addr & 0x0F)
|
|
JPEG_MSG("JPGENC: set CHROMA addr not align (%x)\n",
|
|
src_chroma_addr);
|
|
|
|
IMG_REG_WRITE((src_chroma_addr), REG_ADDR_JPEG_ENC_SRC_CHROMA_ADDR);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_memory_stride(unsigned int mem_stride)
|
|
{
|
|
if (mem_stride & 0x0F) {
|
|
JPEG_MSG("JPGENC:memory stride not align to 0x1f (%x)\n",
|
|
mem_stride);
|
|
return 0;
|
|
}
|
|
|
|
IMG_REG_WRITE((mem_stride), REG_ADDR_JPEG_ENC_STRIDE);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_image_stride(unsigned int img_stride)
|
|
{
|
|
if (img_stride & 0x0F) {
|
|
JPEG_MSG("JPGENC: image stride not align to 0x0f (%x)\n",
|
|
img_stride);
|
|
return 0;
|
|
}
|
|
|
|
IMG_REG_WRITE((img_stride), REG_ADDR_JPEG_ENC_IMG_STRIDE);
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
void jpeg_drv_enc_set_restart_interval(unsigned int restart_interval)
|
|
{
|
|
unsigned int u4Value;
|
|
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
|
|
|
|
if (restart_interval != 0) {
|
|
u4Value |= JPEG_ENC_CTRL_RESTART_EN_BIT;
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
|
|
} else {
|
|
u4Value &= ~JPEG_ENC_CTRL_RESTART_EN_BIT;
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
|
|
}
|
|
IMG_REG_WRITE((restart_interval), REG_ADDR_JPEG_ENC_RST_MCU_NUM);
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_set_offset_addr(unsigned int 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);
|
|
|
|
return 1;
|
|
}
|
|
|
|
unsigned int jpeg_drv_enc_set_dst_buff(struct ion_client *pIonClient,
|
|
int dstFd, unsigned int stall_size,
|
|
unsigned int init_offset, unsigned int offset_mask)
|
|
{
|
|
struct ion_handle *handle = NULL;
|
|
dma_addr_t dst_addr = 0;
|
|
unsigned int bufSize = 0;
|
|
|
|
if (stall_size < 624) {
|
|
JPEG_MSG("JPGENC:stall size less than 624 to write %d\n",
|
|
stall_size);
|
|
return 0;
|
|
}
|
|
|
|
if (offset_mask & 0x0F) {
|
|
JPEG_MSG("JPEGENC: set offset addr %x\n", offset_mask);
|
|
/* return 0; */
|
|
}
|
|
|
|
handle = jpeg_ion_import_handle(pIonClient, dstFd);
|
|
if (handle == NULL) {
|
|
JPEG_MSG("import handle fail line %d\n", __LINE__);
|
|
return 0;
|
|
}
|
|
if (jpeg_ion_get_mva(pIonClient, handle, &dst_addr, &bufSize, 0) != 0)
|
|
return 0;
|
|
|
|
jpeg_ion_free_handle(pIonClient, handle);
|
|
|
|
if (init_offset >= bufSize) {
|
|
JPEG_MSG("invalid offset %d bufsize %d line %d\n", init_offset, bufSize, __LINE__);
|
|
return 0;
|
|
}
|
|
|
|
dst_addr += init_offset;
|
|
JPEG_MSG("dst_addr 0x%p offset 0x%x line %d\n", dst_addr, init_offset, __LINE__);
|
|
|
|
|
|
|
|
IMG_REG_WRITE((0 & (~0xF)), REG_ADDR_JPEG_ENC_OFFSET_ADDR);
|
|
|
|
IMG_REG_WRITE((offset_mask & 0xF), REG_ADDR_JPEG_ENC_BYTE_OFFSET_MASK);
|
|
|
|
IMG_REG_WRITE((dst_addr & (~0xF)), REG_ADDR_JPEG_ENC_DST_ADDR0);
|
|
|
|
IMG_REG_WRITE(((dst_addr + stall_size) & (~0xF)),
|
|
REG_ADDR_JPEG_ENC_STALL_ADDR0);
|
|
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* 0:JPG mode, 1:JFIF/EXIF mode */
|
|
void jpeg_drv_enc_set_EncodeMode(unsigned int exif_en)
|
|
{
|
|
unsigned int u4Value;
|
|
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
|
|
u4Value &= ~(JPEG_ENC_CTRL_FILE_FORMAT_BIT);
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
|
|
|
|
if (exif_en) {
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
|
|
u4Value |= JPEG_ENC_EN_JFIF_EXIF;
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
|
|
}
|
|
}
|
|
|
|
|
|
void jpeg_drv_enc_set_gmc_disable_bit(void)
|
|
{
|
|
unsigned int u4Value;
|
|
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
|
|
u4Value |= JPEG_ENC_EN_DIS_GMC;
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
|
|
}
|
|
|
|
|
|
void jpeg_drv_enc_set_burst_type(unsigned int burst_type)
|
|
{
|
|
unsigned int u4Value;
|
|
|
|
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
|
|
u4Value &= ~JPEG_ENC_CTRL_BURST_TYPE_MASK;
|
|
u4Value |= (burst_type << JPEG_ENC_CTRL_BURST_TYPE_SHIFT_COUNT);
|
|
|
|
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
|
|
}
|
|
|
|
unsigned int jpeg_drv_enc_get_cycle_count(void)
|
|
{
|
|
return IMG_REG_READ(REG_ADDR_JPEG_ENC_TOTAL_CYCLE);
|
|
}
|
|
|
|
|
|
unsigned int jpeg_drv_enc_get_file_size(void)
|
|
{
|
|
unsigned int u4DMA_Addr0;
|
|
unsigned int u4DST_Addr0;
|
|
|
|
u4DMA_Addr0 = IMG_REG_READ(REG_ADDR_JPEG_ENC_DMA_ADDR0);
|
|
u4DST_Addr0 = IMG_REG_READ(REG_ADDR_JPEG_ENC_DST_ADDR0);
|
|
|
|
return (u4DMA_Addr0 - u4DST_Addr0);
|
|
/* return REG_JPEG_ENC_CURR_DMA_ADDR - REG_JPEG_ENC_DST_ADDR0; */
|
|
}
|
|
|
|
|
|
#ifdef FPGA_VERSION
|
|
|
|
unsigned int jpeg_drv_enc_get_result(void)
|
|
{
|
|
unsigned int file_size;
|
|
|
|
file_size = jpeg_drv_enc_get_file_size();
|
|
return file_size;
|
|
}
|
|
|
|
#else
|
|
|
|
unsigned int jpeg_drv_enc_get_result(unsigned int *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;
|
|
}
|
|
|
|
#endif
|
|
#endif
|