/*
 * drivers/amlogic/amports/jpegenc.c
 *
 * Copyright (C) 2015 Amlogic, Inc. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
*/
#define LOG_LINE()
//pr_err("[%s:%d]\n", __FUNCTION__, __LINE__);
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/timer.h>
#include <linux/compat.h>
#include <linux/ktime.h>
#include <linux/timekeeping.h>

#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/dma-mapping.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>
#include <linux/ctype.h>
#include <linux/amlogic/media/frame_sync/ptsserv.h>
#include <linux/amlogic/media/utils/amstream.h>
#include <linux/amlogic/media/canvas/canvas.h>
#include <linux/amlogic/media/canvas/canvas_mgr.h>
#include <linux/amlogic/media/utils/vdec_reg.h>
#include "../../../frame_provider/decoder/utils/vdec_canvas_utils.h"
#include <linux/delay.h>
#include <linux/poll.h>
#include <linux/of.h>
#include <linux/of_fdt.h>
#include <linux/dma-contiguous.h>
#include "../../../common/chips/decoder_cpu_ver_info.h"
#include "../../../frame_provider/decoder/utils/amvdec.h"
#include "../../../stream_input/amports/amports_priv.h"
#include "../../../frame_provider/decoder/utils/firmware.h"
#include "../../../frame_provider/decoder/utils/vdec.h"
#include "../../../frame_provider/decoder/utils/vdec_power_ctrl.h"
#include <linux/amlogic/media/codec_mm/codec_mm.h>
#include "jpegenc.h"
#include <linux/of_reserved_mem.h>

#include <linux/amlogic/power_ctrl.h>
#include <dt-bindings/power/t7-pd.h>
#include <linux/amlogic/power_domain.h>

#include <linux/clk.h>
#define HCODEC_MFDIN_REG17                       0x101f
#define HCODEC_MFDIN_REG18                       0x1020
#define HCODEC_MFDIN_REG19                       0x1021

#ifdef CONFIG_AM_ENCODER
#include "encoder.h"
#endif

#define JPEGENC_CANVAS_INDEX 0x64
#define JPEGENC_CANVAS_MAX_INDEX 0x67

#define ENC_CANVAS_OFFSET  JPEGENC_CANVAS_INDEX

#define LOG_ALL 0
#define LOG_INFO 1
#define LOG_DEBUG 2
#define LOG_ERROR 3

#define jenc_pr(level, x...) \
    do { \
        if (level >= jpegenc_print_level) \
            printk(x); \
    } while (0)

#define DRIVER_NAME "jpegenc"
#define CLASS_NAME "jpegenc"
#define DEVICE_NAME "jpegenc"

/* #define EXTEAN_QUANT_TABLE */

/*######### DEBUG-BRINGUP#########*/
static u32 manual_clock;
static u32 manual_irq_num = 2;
static u32 manual_interrupt = 0;
/*################################*/

static s32 jpegenc_device_major;
static struct device *jpegenc_dev;
static u32 jpegenc_print_level = LOG_ERROR;

static s32 reg_offset;

static u32 use_dma_io = 1;

static u32 use_quality=1;
static u32 legacy_load=0;

static u32 dumpmem_line = 0;
static u32 pointer = 0;

static u32 clock_level = 1;
static u16 gQuantTable[2][DCTSIZE2];
#ifdef EXTEAN_QUANT_TABLE
static u16 *gExternalQuantTablePtr;
static bool external_quant_table_available;
#endif

static u32 simulation_enable;
static u32 g_block_mode;
static u32 g_canv0_stride;
static u32 g_canv1_stride;
static u32 g_canv2_stride;
static u32 g_canvas_height;

static u32 jpeg_in_full_hcodec;
static u32 mfdin_ambus_canv_conv;

#define MHz (1000000)

//static DEFINE_SPINLOCK(lock);

#define JPEGENC_BUFFER_LEVEL_VGA   0
#define JPEGENC_BUFFER_LEVEL_2M     1
#define JPEGENC_BUFFER_LEVEL_3M     2
#define JPEGENC_BUFFER_LEVEL_5M     3
#define JPEGENC_BUFFER_LEVEL_8M     4
#define JPEGENC_BUFFER_LEVEL_13M   5
#define JPEGENC_BUFFER_LEVEL_HD     6

const s8 *glevel_str[] = {
    "VGA",
    "2M",
    "3M",
    "5M",
    "8M",
    "13M",
    "HD",
};

const struct Jpegenc_BuffInfo_s jpegenc_buffspec[] = {
    {
        .lev_id = JPEGENC_BUFFER_LEVEL_VGA,
        .max_width = 640,
        .max_height = 640,
        .min_buffsize = 0x330000,
        .input = {
            .buf_start = 0,
            .buf_size = 0x12c000,
        },
        .assit = {
            .buf_start = 0x12d000,
            .buf_size = 0x2000,
        },
        .bitstream = {
            .buf_start = 0x130000,
            .buf_size = 0x200000,
        }
    }, {
        .lev_id = JPEGENC_BUFFER_LEVEL_2M,
        .max_width = 1600,
        .max_height = 1600,
        .min_buffsize = 0x960000,
        .input = {
            .buf_start = 0,
            .buf_size = 0x753000,
        },
        .assit = {
            .buf_start = 0x754000,
            .buf_size = 0x2000,
        },
        .bitstream = {
            .buf_start = 0x760000,
            .buf_size = 0x200000,
        }
    }, {
        .lev_id = JPEGENC_BUFFER_LEVEL_3M,
        .max_width = 2048,
        .max_height = 2048,
        .min_buffsize = 0xe10000,
        .input = {
            .buf_start = 0,
            .buf_size = 0xc00000,
        },
        .assit = {
            .buf_start = 0xc01000,
            .buf_size = 0x2000,
        },
        .bitstream = {
            .buf_start = 0xc10000,
            .buf_size = 0x200000,
        }
    }, {
        .lev_id = JPEGENC_BUFFER_LEVEL_5M,
        .max_width = 2624,
        .max_height = 2624,
        .min_buffsize = 0x1800000,
        .input = {
            .buf_start = 0,
            .buf_size = 0x13B3000,
        },
        .assit = {
            .buf_start = 0x13B4000,
            .buf_size = 0x2000,
        },
        .bitstream = {
            .buf_start = 0x1400000,
            .buf_size = 0x400000,
        }
    }, {
        .lev_id = JPEGENC_BUFFER_LEVEL_8M,
        .max_width = 3264,
        .max_height = 3264,
        .min_buffsize = 0x2300000,
        .input = {
            .buf_start = 0,
            .buf_size = 0x1e7b000,
        },
        .assit = {
            .buf_start = 0x1e7c000,
            .buf_size = 0x2000,
        },
        .bitstream = {
            .buf_start = 0x1f00000,
            .buf_size = 0x400000,
        }
    }, {
        .lev_id = JPEGENC_BUFFER_LEVEL_13M,
        .max_width = 8192,
        .max_height = 8192,
        .min_buffsize = 0xc400000,
        .input = {
            .buf_start = 0,
            .buf_size = 0xc000000,
        },
        .assit = {
            .buf_start = 0xc001000,
            .buf_size = 0x2000,
        },
        .bitstream = {
            .buf_start = 0xc010000,
            .buf_size = 0x3f0000,
        }
    }, {
        .lev_id = JPEGENC_BUFFER_LEVEL_HD,
        .max_width = 8192,
        .max_height = 8192,
        .min_buffsize = 0xc400000,
        .input = {
            .buf_start = 0,
            .buf_size = 0xc000000,
        },
        .assit = {
            .buf_start = 0xc001000,
            .buf_size = 0x2000,
        },
        .bitstream = {
            .buf_start = 0xc010000,
            .buf_size = 0x3f0000,
        }
    }
};

const char *jpegenc_ucode[] = {
    "jpegenc_mc",
};

static struct jpegenc_manager_s gJpegenc;

static const u16 jpeg_quant[7][DCTSIZE2] = {
    { /* jpeg_quant[0][] : Luma, Canon */
        0x06, 0x06, 0x08, 0x0A, 0x0A, 0x10, 0x15, 0x19,
        0x06, 0x0A, 0x0A, 0x0E, 0x12, 0x1F, 0x29, 0x29,
        0x08, 0x0A, 0x0E, 0x12, 0x21, 0x29, 0x29, 0x29,
        0x0A, 0x0E, 0x12, 0x14, 0x23, 0x29, 0x29, 0x29,
        0x0A, 0x12, 0x21, 0x23, 0x27, 0x29, 0x29, 0x29,
        0x10, 0x1F, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
        0x15, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
        0x19, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29
    },
    { /* jpeg_quant[1][] : Chroma, Canon */
        0x0A, 0x0E, 0x10, 0x14, 0x15, 0x1D, 0x2B, 0x35,
        0x0E, 0x12, 0x14, 0x1D, 0x25, 0x3E, 0x54, 0x54,
        0x10, 0x14, 0x19, 0x25, 0x40, 0x54, 0x54, 0x54,
        0x14, 0x1D, 0x25, 0x27, 0x48, 0x54, 0x54, 0x54,
        0x15, 0x25, 0x40, 0x48, 0x4E, 0x54, 0x54, 0x54,
        0x1D, 0x3E, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
        0x2B, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
        0x35, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54
    },
    { /* jpeg_quant[2][] : Luma, spec example Table K.1 */
        16, 11, 10, 16, 24, 40, 51, 61,
        12, 12, 14, 19, 26, 58, 60, 55,
        14, 13, 16, 24, 40, 57, 69, 56,
        14, 17, 22, 29, 51, 87, 80, 62,
        18, 22, 37, 56, 68, 109, 103, 77,
        24, 35, 55, 64, 81, 104, 113, 92,
        49, 64, 78, 87, 103, 121, 120, 101,
        72, 92, 95, 98, 112, 100, 103, 99
    },
    { /* jpeg_quant[3][] : Chroma, spec example Table K.2 */
        17, 18, 24, 47, 99, 99, 99, 99,
        18, 21, 26, 66, 99, 99, 99, 99,
        24, 26, 56, 99, 99, 99, 99, 99,
        47, 66, 99, 99, 99, 99, 99, 99,
        99, 99, 99, 99, 99, 99, 99, 99,
        99, 99, 99, 99, 99, 99, 99, 99,
        99, 99, 99, 99, 99, 99, 99, 99,
        99, 99, 99, 99, 99, 99, 99, 99
    },
    { /* jpeg_quant[4][] : Luma, spec example Table K.1,
        modified to create long ZRL */
        16, 11, 10, 16, 24, 40, 51, 61,
        12, 12, 14, 19, 26, 58, 60, 55,
        14, 13, 16, 24, 40, 57, 69, 56,
        14, 17, 22, 29, 51, 87, 80, 62,
        18, 22, 37, 56, 68, 109, 103, 77,
        24, 35, 55, 64, 81, 104, 113, 92,
        49, 64, 78, 87, 103, 121, 120, 101,
        72, 92, 95, 98, 112, 100, 103, 16
    },
    { /* jpeg_quant[5][] : Chroma, spec example Table K.2,
        modified to create long ZRL */
        17, 18, 24, 47, 99, 99, 99, 99,
        18, 21, 26, 66, 99, 99, 99, 99,
        24, 26, 56, 99, 99, 99, 99, 99,
        47, 66, 99, 99, 99, 99, 99, 99,
        99, 99, 99, 99, 99, 99, 99, 99,
        99, 99, 99, 99, 99, 99, 99, 99,
        99, 99, 99, 99, 99, 99, 99, 99,
        99, 99, 99, 99, 99, 99, 99, 17
    },
    { /* jpeg_quant[6][] : no compression */
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1
    }
}; /* jpeg_quant */

static const u8 jpeg_huffman_dc[2][16 + 12] = {
    { /* jpeg_huffman_dc[0][] */
        0x00, /* number of code length=1 */
        0x01,
        0x05,
        0x01,
        0x01,
        0x01,
        0x01,
        0x01,
        0x01,
        0x00,
        0x00,
        0x00,
        0x00,
        0x00,
        0x00,
        0x00, /* number of code length=16 */

        /* Entry index for code with
            minimum code length (=2 in this case) */
        0x00,
        0x01, 0x02, 0x03, 0x04, 0x05,
        0x06,
        0x07,
        0x08,
        0x09,
        0x0A,
        0x0B
    },
    { /* jpeg_huffman_dc[1][] */
        0x00, /* number of code length=1 */
        0x03,
        0x01,
        0x01,
        0x01,
        0x01,
        0x01,
        0x01,
        0x01,
        0x01,
        0x01,
        0x00,
        0x00,
        0x00,
        0x00,
        0x00, /* number of code length=16 */

        /* Entry index for code with
            minimum code length (=2 in this case) */
        0x00, 0x01, 0x02,
        0x03,
        0x04,
        0x05,
        0x06,
        0x07,
        0x08,
        0x09,
        0x0A,
        0x0B
    }
}; /* jpeg_huffman_dc */

static const u8 jpeg_huffman_ac[2][16 + 162] = {
    { /* jpeg_huffman_ac[0][] */
        0x00, /* number of code length=1 */
        0x02,
        0x01,
        0x03,
        0x03,
        0x02,
        0x04,
        0x03,
        0x05,
        0x05,
        0x04,
        0x04,
        0x00,
        0x00,
        0x01,
        0x7D, /* number of code length=16 */

        /* Entry index for code with
            minimum code length (=2 in this case) */
        0x01, 0x02,
        0x03,
        0x00, 0x04, 0x11,
        0x05, 0x12, 0x21,
        0x31, 0x41,
        0x06, 0x13, 0x51, 0x61,
        0x07, 0x22, 0x71,
        0x14, 0x32, 0x81, 0x91, 0xA1,
        0x08, 0x23, 0x42, 0xB1, 0xC1,
        0x15, 0x52, 0xD1, 0xF0,
        0x24, 0x33, 0x62, 0x72,
        0x82,
        0x09, 0x0A, 0x16, 0x17, 0x18, 0x19,
        0x1A, 0x25, 0x26, 0x27, 0x28, 0x29,
        0x2A, 0x34, 0x35, 0x36,
        0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
        0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
        0x53, 0x54, 0x55, 0x56,
        0x57, 0x58, 0x59, 0x5A, 0x63, 0x64,
        0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
        0x73, 0x74, 0x75, 0x76,
        0x77, 0x78, 0x79, 0x7A, 0x83, 0x84,
        0x85, 0x86, 0x87, 0x88, 0x89, 0x8A,
        0x92, 0x93, 0x94, 0x95,
        0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2,
        0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
        0xA9, 0xAA, 0xB2, 0xB3,
        0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9,
        0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6,
        0xC7, 0xC8, 0xC9, 0xCA,
        0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
        0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3,
        0xE4, 0xE5, 0xE6, 0xE7,
        0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
        0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
        0xFA
    },
    { /* jpeg_huffman_ac[1][] */
        0x00, /* number of code length=1 */
        0x02,
        0x01,
        0x02,
        0x04,
        0x04,
        0x03,
        0x04,
        0x07,
        0x05,
        0x04,
        0x04,
        0x00,
        0x01,
        0x02,
        0x77, /* number of code length=16 */

        /* Entry index for code with
            minimum code length (=2 in this case) */
        0x00, 0x01,
        0x02,
        0x03, 0x11,
        0x04, 0x05, 0x21, 0x31,
        0x06, 0x12, 0x41, 0x51,
        0x07, 0x61, 0x71,
        0x13, 0x22, 0x32, 0x81,
        0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
        0x09, 0x23, 0x33, 0x52, 0xF0,
        0x15, 0x62, 0x72, 0xD1,
        0x0A, 0x16, 0x24, 0x34,

        0xE1,
        0x25, 0xF1,
        0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
        0x28, 0x29, 0x2A, 0x35, 0x36, 0x37,
        0x38, 0x39, 0x3A, 0x43,
        0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
        0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
        0x58, 0x59, 0x5A, 0x63,
        0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
        0x6A, 0x73, 0x74, 0x75, 0x76, 0x77,
        0x78, 0x79, 0x7A, 0x82,
        0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
        0x89, 0x8A, 0x92, 0x93, 0x94, 0x95,
        0x96, 0x97, 0x98, 0x99,
        0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
        0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3,
        0xB4, 0xB5, 0xB6, 0xB7,
        0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4,
        0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
        0xD2, 0xD3, 0xD4, 0xD5,
        0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2,
        0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8,
        0xE9, 0xEA, 0xF2, 0xF3,
        0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA
    }
}; /* jpeg_huffman_ac */

static u64 time_cnt = 0;

static int enc_dma_buf_get_phys(struct enc_dma_cfg *cfg, unsigned long *addr);
static void enc_dma_buf_unmap(struct enc_dma_cfg *cfg);

static void dump_requst(struct jpegenc_request_s *request) {
    jenc_pr(LOG_DEBUG, "jpegenc: dump request start\n");
    jenc_pr(LOG_DEBUG, "src=%u\n", request->src);
    jenc_pr(LOG_DEBUG, "encoder_width=%u\n", request->encoder_width);
    jenc_pr(LOG_DEBUG, "encoder_height=%u\n", request->encoder_height);
    jenc_pr(LOG_DEBUG, "framesize=%u\n", request->framesize);
    jenc_pr(LOG_DEBUG, "jpeg_quality=%u\n", request->jpeg_quality);
    jenc_pr(LOG_DEBUG, "QuantTable_id=%u\n", request->QuantTable_id);
    jenc_pr(LOG_DEBUG, "flush_flag=%u\n", request->flush_flag);
    jenc_pr(LOG_DEBUG, "block_mode=%u\n", request->block_mode);
    jenc_pr(LOG_DEBUG, "type=%d\n", request->type);
    jenc_pr(LOG_DEBUG, "input_fmt=%d\n", request->input_fmt);
    jenc_pr(LOG_DEBUG, "output_fmt=%d\n", request->output_fmt);

    jenc_pr(LOG_DEBUG, "y_off=%u\n", request->y_off);
    jenc_pr(LOG_DEBUG, "u_off=%u\n", request->u_off);
    jenc_pr(LOG_DEBUG, "v_off=%u\n", request->v_off);
    jenc_pr(LOG_DEBUG, "y_stride=%u\n", request->y_stride);
    jenc_pr(LOG_DEBUG, "u_stride=%u\n", request->u_stride);
    jenc_pr(LOG_DEBUG, "v_stride=%u\n", request->v_stride);
    jenc_pr(LOG_DEBUG, "h_stride=%u\n", request->h_stride);
    jenc_pr(LOG_DEBUG, "jpegenc: dump request end\n");
}

static void canvas_config_proxy(u32 index, ulong addr, u32 width, u32 height,
		   u32 wrap, u32 blkmode) {
	unsigned long datah_temp, datal_temp;

	if (!is_support_vdec_canvas()) {
		canvas_config(index, addr, width, height, wrap, blkmode);
	} else {
#if 1
		ulong start_addr = addr >> 3;
		u32 cav_width = (((width + 31)>>5)<<2);
		u32 cav_height = height;
		u32 x_wrap_en = 0;
		u32 y_wrap_en = 0;
		u32 blk_mode = 0;//blkmode;
		u32 cav_endian = 0;

		datal_temp = (start_addr & 0x1fffffff) |
					((cav_width & 0x7 ) << 29 );

		datah_temp = ((cav_width  >> 3) & 0x1ff) |
					((cav_height & 0x1fff) <<9 ) |
					((x_wrap_en & 1) << 22 ) |
					((y_wrap_en & 1) << 23) |
					((blk_mode & 0x3) << 24) |
					( cav_endian << 26);

#else
		u32 endian = 0;
		u32 addr_bits_l = ((((addr + 7) >> 3) & CANVAS_ADDR_LMASK) << CAV_WADDR_LBIT);
		u32 width_l     = ((((width    + 7) >> 3) & CANVAS_WIDTH_LMASK) << CAV_WIDTH_LBIT);
		u32 width_h     = ((((width    + 7) >> 3) >> CANVAS_WIDTH_LWID) << CAV_WIDTH_HBIT);
		u32 height_h    = (height & CANVAS_HEIGHT_MASK) << CAV_HEIGHT_HBIT;
		u32 blkmod_h    = (blkmode & CANVAS_BLKMODE_MASK) << CAV_BLKMODE_HBIT;
		u32 switch_bits_ctl = (endian & 0xf) << CAV_ENDIAN_HBIT;
		u32 wrap_h      = (0 << 23);
		datal_temp = addr_bits_l | width_l;
		datah_temp = width_h | height_h | wrap_h | blkmod_h | switch_bits_ctl;
#endif
		/*
		if (core == VDEC_1) {
			WRITE_VREG(MDEC_CAV_CFG0, 0);	//[0]canv_mode, by default is non-canv-mode
			WRITE_VREG(MDEC_CAV_LUT_DATAL, datal_temp);
			WRITE_VREG(MDEC_CAV_LUT_DATAH, datah_temp);
			WRITE_VREG(MDEC_CAV_LUT_ADDR,  index);
		} else if (core == VDEC_HCODEC) */ {
			WRITE_HREG(HCODEC_MDEC_CAV_CFG0, 0);	//[0]canv_mode, by default is non-canv-mode
			WRITE_HREG(HCODEC_MDEC_CAV_LUT_DATAL, datal_temp);
			WRITE_HREG(HCODEC_MDEC_CAV_LUT_DATAH, datah_temp);
			WRITE_HREG(HCODEC_MDEC_CAV_LUT_ADDR,  index);
		}

		/*
		cav_lut_info_store(index, addr, width, height, wrap, blkmode, 0);

		if (vdec_get_debug() & 0x40000000) {
			pr_info("(%s %2d) addr: %lx, width: %d, height: %d, blkm: %d, endian: %d\n",
				__func__, index, addr, width, height, blkmode, 0);
			pr_info("data(h,l): 0x%8lx, 0x%8lx\n", datah_temp, datal_temp);
	    }
	    */
	}
}

static u64 jpegenc_time_count_start(void)
{
    //struct timeval    tv;

    //do_gettimeofday(&tv);
    //efi_gettimeofday(&tv);
    //return div64_u64(timeval_to_ns(&tv), 1000);
    return 0;
}

static void jpegenc_time_count_end(u64 *time)
{
    jenc_pr(LOG_INFO, "the encoder takes time %lld us.\n",
        jpegenc_time_count_start() - *time);
    *time = 0;
}

static int is_oversize(int w, int h, int max)
{
    if (w < 0 || h < 0)
        return true;

    if (h != 0 && (w > max / h))
        return true;

    return false;
}

struct jpeg_enc_clks {
    struct clk *dos_clk;
    struct clk *dos_apb_clk;
    struct clk *jpeg_enc_clk;

};

static struct jpeg_enc_clks g_jpeg_enc_clks;

static void jpeg_enc_clk_put(struct device *dev, struct jpeg_enc_clks *clks)
{
    if (!(clks->jpeg_enc_clk == NULL || IS_ERR(clks->jpeg_enc_clk)))
        devm_clk_put(dev, clks->jpeg_enc_clk);

    if (!(clks->dos_apb_clk == NULL || IS_ERR(clks->dos_apb_clk)))
        devm_clk_put(dev, clks->dos_apb_clk);

    if (!(clks->dos_clk == NULL || IS_ERR(clks->dos_clk)))
        devm_clk_put(dev, clks->dos_clk);
}

static int jpeg_enc_clk_get(struct device *dev, struct jpeg_enc_clks *clks)
{
    //int ret = 0;

    clks->dos_clk = devm_clk_get(dev, "clk_dos");
    if (IS_ERR(clks->dos_clk)) {
        jenc_pr(LOG_ERROR, "cannot get clk_dos clock\n");
        clks->dos_clk = NULL;
        //ret = -ENOENT;
        //goto err;
    } else
        pr_err("jpeg_enc_clk_get: get clk_dos OK\n");

    clks->dos_apb_clk = devm_clk_get(dev, "clk_apb_dos");
    if (IS_ERR(clks->dos_apb_clk)) {
        jenc_pr(LOG_ERROR, "cannot get clk_apb_dos clock\n");
        clks->dos_apb_clk = NULL;
        //ret = -ENOENT;
        //goto err;
    } else
        pr_err("jpeg_enc_clk_get: get clk_apb_dos OK\n");

    clks->jpeg_enc_clk = devm_clk_get(dev, "clk_jpeg_enc");
    if (IS_ERR(clks->jpeg_enc_clk)) {
        jenc_pr(LOG_ERROR, "cannot get clk_jpeg_enc clock\n");
        clks->jpeg_enc_clk = NULL;
        //ret = -ENOENT;
        //goto err;
    } else
        pr_err("jpeg_enc_clk_get: get clk_jpeg_enc OK\n");

    return 0;
//err:
//    jpeg_enc_clk_put(dev, clks);

//    return ret;
}

static void jpeg_enc_clk_enable(struct jpeg_enc_clks *clks, u32 frq)
{
    if (clks->dos_clk != NULL) {
        clk_set_rate(clks->dos_clk, 400 * MHz);
        clk_prepare_enable(clks->dos_clk);
        pr_err("dos clk: %ld\n", clk_get_rate(clks->dos_clk));
    }

    if (clks->dos_apb_clk != NULL) {
        clk_set_rate(clks->dos_apb_clk, 400 * MHz);
        clk_prepare_enable(clks->dos_apb_clk);
        pr_err("apb clk: %ld\n", clk_get_rate(clks->dos_apb_clk));
    }

    if (clks->jpeg_enc_clk != NULL) {
        clk_set_rate(clks->jpeg_enc_clk, 666666666);
        clk_prepare_enable(clks->jpeg_enc_clk);
        pr_err("jpegenc clk: %ld\n", clk_get_rate(clks->jpeg_enc_clk));
    }

    /*
    clk_prepare_enable(clks->dos_clk);
    clk_prepare_enable(clks->dos_apb_clk);
    clk_prepare_enable(clks->jpeg_enc_clk);
    */
    pr_err("dos: %ld, dos_apb: %ld, jpeg clk: %ld\n",
        clk_get_rate(clks->dos_clk),
        clk_get_rate(clks->dos_apb_clk),
        clk_get_rate(clks->jpeg_enc_clk));

}

static void jpeg_enc_clk_disable(struct jpeg_enc_clks *clks)
{
    pr_err("set jpeg_enc_clk rate to 0\n");
    clk_set_rate(clks->jpeg_enc_clk, 0);
    clk_disable_unprepare(clks->jpeg_enc_clk);

    //clk_disable_unprepare(clks->dos_apb_clk);
    //clk_disable_unprepare(clks->dos_clk);
}

static void dma_flush(u32 buf_start, u32 buf_size);

static s32 zigzag(s32 i)
{
    s32 zigzag_i;
    switch (i) {
    case 0:
        zigzag_i = 0;
        break;
    case 1:
        zigzag_i = 1;
        break;
    case 2:
        zigzag_i = 8;
        break;
    case 3:
        zigzag_i = 16;
        break;
    case 4:
        zigzag_i = 9;
        break;
    case 5:
        zigzag_i = 2;
        break;
    case 6:
        zigzag_i = 3;
        break;
    case 7:
        zigzag_i = 10;
        break;
    case 8:
        zigzag_i = 17;
        break;
    case 9:
        zigzag_i = 24;
        break;
    case 10:
        zigzag_i = 32;
        break;
    case 11:
        zigzag_i = 25;
        break;
    case 12:
        zigzag_i = 18;
        break;
    case 13:
        zigzag_i = 11;
        break;
    case 14:
        zigzag_i = 4;
        break;
    case 15:
        zigzag_i = 5;
        break;
    case 16:
        zigzag_i = 12;
        break;
    case 17:
        zigzag_i = 19;
        break;
    case 18:
        zigzag_i = 26;
        break;
    case 19:
        zigzag_i = 33;
        break;
    case 20:
        zigzag_i = 40;
        break;
    case 21:
        zigzag_i = 48;
        break;
    case 22:
        zigzag_i = 41;
        break;
    case 23:
        zigzag_i = 34;
        break;
    case 24:
        zigzag_i = 27;
        break;
    case 25:
        zigzag_i = 20;
        break;
    case 26:
        zigzag_i = 13;
        break;
    case 27:
        zigzag_i = 6;
        break;
    case 28:
        zigzag_i = 7;
        break;
    case 29:
        zigzag_i = 14;
        break;
    case 30:
        zigzag_i = 21;
        break;
    case 31:
        zigzag_i = 28;
        break;
    case 32:
        zigzag_i = 35;
        break;
    case 33:
        zigzag_i = 42;
        break;
    case 34:
        zigzag_i = 49;
        break;
    case 35:
        zigzag_i = 56;
        break;
    case 36:
        zigzag_i = 57;
        break;
    case 37:
        zigzag_i = 50;
        break;
    case 38:
        zigzag_i = 43;
        break;
    case 39:
        zigzag_i = 36;
        break;
    case 40:
        zigzag_i = 29;
        break;
    case 41:
        zigzag_i = 22;
        break;
    case 42:
        zigzag_i = 15;
        break;
    case 43:
        zigzag_i = 23;
        break;
    case 44:
        zigzag_i = 30;
        break;
    case 45:
        zigzag_i = 37;
        break;
    case 46:
        zigzag_i = 44;
        break;
    case 47:
        zigzag_i = 51;
        break;
    case 48:
        zigzag_i = 58;
        break;
    case 49:
        zigzag_i = 59;
        break;
    case 50:
        zigzag_i = 52;
        break;
    case 51:
        zigzag_i = 45;
        break;
    case 52:
        zigzag_i = 38;
        break;
    case 53:
        zigzag_i = 31;
        break;
    case 54:
        zigzag_i = 39;
        break;
    case 55:
        zigzag_i = 46;
        break;
    case 56:
        zigzag_i = 53;
        break;
    case 57:
        zigzag_i = 60;
        break;
    case 58:
        zigzag_i = 61;
        break;
    case 59:
        zigzag_i = 54;
        break;
    case 60:
        zigzag_i = 47;
        break;
    case 61:
        zigzag_i = 55;
        break;
    case 62:
        zigzag_i = 62;
        break;
    default:
        zigzag_i = 63;
        break;
    }
    return zigzag_i;
}

/* Perform convertion from Q to 1/Q */
u32 reciprocal(u32 q)
{
    u32 q_recip;

    /* 65535 * (1/q) */
    switch (q) {
    case 0:
        q_recip = 0;
        break;
    case 1:
        q_recip = 65535;
        break;
    case 2:
        q_recip = 32768;
        break;
    case 3:
        q_recip = 21845;
        break;
    case 4:
        q_recip = 16384;
        break;
    case 5:
        q_recip = 13107;
        break;
    case 6:
        q_recip = 10923;
        break;
    case 7:
        q_recip = 9362;
        break;
    case 8:
        q_recip = 8192;
        break;
    case 9:
        q_recip = 7282;
        break;
    case 10:
        q_recip = 6554;
        break;
    case 11:
        q_recip = 5958;
        break;
    case 12:
        q_recip = 5461;
        break;
    case 13:
        q_recip = 5041;
        break;
    case 14:
        q_recip = 4681;
        break;
    case 15:
        q_recip = 4369;
        break;
    case 16:
        q_recip = 4096;
        break;
    case 17:
        q_recip = 3855;
        break;
    case 18:
        q_recip = 3641;
        break;
    case 19:
        q_recip = 3449;
        break;
    case 20:
        q_recip = 3277;
        break;
    case 21:
        q_recip = 3121;
        break;
    case 22:
        q_recip = 2979;
        break;
    case 23:
        q_recip = 2849;
        break;
    case 24:
        q_recip = 2731;
        break;
    case 25:
        q_recip = 2621;
        break;
    case 26:
        q_recip = 2521;
        break;
    case 27:
        q_recip = 2427;
        break;
    case 28:
        q_recip = 2341;
        break;
    case 29:
        q_recip = 2260;
        break;
    case 30:
        q_recip = 2185;
        break;
    case 31:
        q_recip = 2114;
        break;
    case 32:
        q_recip = 2048;
        break;
    case 33:
        q_recip = 1986;
        break;
    case 34:
        q_recip = 1928;
        break;
    case 35:
        q_recip = 1872;
        break;
    case 36:
        q_recip = 1820;
        break;
    case 37:
        q_recip = 1771;
        break;
    case 38:
        q_recip = 1725;
        break;
    case 39:
        q_recip = 1680;
        break;
    case 40:
        q_recip = 1638;
        break;
    case 41:
        q_recip = 1598;
        break;
    case 42:
        q_recip = 1560;
        break;
    case 43:
        q_recip = 1524;
        break;
    case 44:
        q_recip = 1489;
        break;
    case 45:
        q_recip = 1456;
        break;
    case 46:
        q_recip = 1425;
        break;
    case 47:
        q_recip = 1394;
        break;
    case 48:
        q_recip = 1365;
        break;
    case 49:
        q_recip = 1337;
        break;
    case 50:
        q_recip = 1311;
        break;
    case 51:
        q_recip = 1285;
        break;
    case 52:
        q_recip = 1260;
        break;
    case 53:
        q_recip = 1237;
        break;
    case 54:
        q_recip = 1214;
        break;
    case 55:
        q_recip = 1192;
        break;
    case 56:
        q_recip = 1170;
        break;
    case 57:
        q_recip = 1150;
        break;
    case 58:
        q_recip = 1130;
        break;
    case 59:
        q_recip = 1111;
        break;
    case 60:
        q_recip = 1092;
        break;
    case 61:
        q_recip = 1074;
        break;
    case 62:
        q_recip = 1057;
        break;
    case 63:
        q_recip = 1040;
        break;
    case 64:
        q_recip = 1024;
        break;
    case 65:
        q_recip = 1008;
        break;
    case 66:
        q_recip = 993;
        break;
    case 67:
        q_recip = 978;
        break;
    case 68:
        q_recip = 964;
        break;
    case 69:
        q_recip = 950;
        break;
    case 70:
        q_recip = 936;
        break;
    case 71:
        q_recip = 923;
        break;
    case 72:
        q_recip = 910;
        break;
    case 73:
        q_recip = 898;
        break;
    case 74:
        q_recip = 886;
        break;
    case 75:
        q_recip = 874;
        break;
    case 76:
        q_recip = 862;
        break;
    case 77:
        q_recip = 851;
        break;
    case 78:
        q_recip = 840;
        break;
    case 79:
        q_recip = 830;
        break;
    case 80:
        q_recip = 819;
        break;
    case 81:
        q_recip = 809;
        break;
    case 82:
        q_recip = 799;
        break;
    case 83:
        q_recip = 790;
        break;
    case 84:
        q_recip = 780;
        break;
    case 85:
        q_recip = 771;
        break;
    case 86:
        q_recip = 762;
        break;
    case 87:
        q_recip = 753;
        break;
    case 88:
        q_recip = 745;
        break;
    case 89:
        q_recip = 736;
        break;
    case 90:
        q_recip = 728;
        break;
    case 91:
        q_recip = 720;
        break;
    case 92:
        q_recip = 712;
        break;
    case 93:
        q_recip = 705;
        break;
    case 94:
        q_recip = 697;
        break;
    case 95:
        q_recip = 690;
        break;
    case 96:
        q_recip = 683;
        break;
    case 97:
        q_recip = 676;
        break;
    case 98:
        q_recip = 669;
        break;
    case 99:
        q_recip = 662;
        break;
    case 100:
        q_recip = 655;
        break;
    case 101:
        q_recip = 649;
        break;
    case 102:
        q_recip = 643;
        break;
    case 103:
        q_recip = 636;
        break;
    case 104:
        q_recip = 630;
        break;
    case 105:
        q_recip = 624;
        break;
    case 106:
        q_recip = 618;
        break;
    case 107:
        q_recip = 612;
        break;
    case 108:
        q_recip = 607;
        break;
    case 109:
        q_recip = 601;
        break;
    case 110:
        q_recip = 596;
        break;
    case 111:
        q_recip = 590;
        break;
    case 112:
        q_recip = 585;
        break;
    case 113:
        q_recip = 580;
        break;
    case 114:
        q_recip = 575;
        break;
    case 115:
        q_recip = 570;
        break;
    case 116:
        q_recip = 565;
        break;
    case 117:
        q_recip = 560;
        break;
    case 118:
        q_recip = 555;
        break;
    case 119:
        q_recip = 551;
        break;
    case 120:
        q_recip = 546;
        break;
    case 121:
        q_recip = 542;
        break;
    case 122:
        q_recip = 537;
        break;
    case 123:
        q_recip = 533;
        break;
    case 124:
        q_recip = 529;
        break;
    case 125:
        q_recip = 524;
        break;
    case 126:
        q_recip = 520;
        break;
    case 127:
        q_recip = 516;
        break;
    case 128:
        q_recip = 512;
        break;
    case 129:
        q_recip = 508;
        break;
    case 130:
        q_recip = 504;
        break;
    case 131:
        q_recip = 500;
        break;
    case 132:
        q_recip = 496;
        break;
    case 133:
        q_recip = 493;
        break;
    case 134:
        q_recip = 489;
        break;
    case 135:
        q_recip = 485;
        break;
    case 136:
        q_recip = 482;
        break;
    case 137:
        q_recip = 478;
        break;
    case 138:
        q_recip = 475;
        break;
    case 139:
        q_recip = 471;
        break;
    case 140:
        q_recip = 468;
        break;
    case 141:
        q_recip = 465;
        break;
    case 142:
        q_recip = 462;
        break;
    case 143:
        q_recip = 458;
        break;
    case 144:
        q_recip = 455;
        break;
    case 145:
        q_recip = 452;
        break;
    case 146:
        q_recip = 449;
        break;
    case 147:
        q_recip = 446;
        break;
    case 148:
        q_recip = 443;
        break;
    case 149:
        q_recip = 440;
        break;
    case 150:
        q_recip = 437;
        break;
    case 151:
        q_recip = 434;
        break;
    case 152:
        q_recip = 431;
        break;
    case 153:
        q_recip = 428;
        break;
    case 154:
        q_recip = 426;
        break;
    case 155:
        q_recip = 423;
        break;
    case 156:
        q_recip = 420;
        break;
    case 157:
        q_recip = 417;
        break;
    case 158:
        q_recip = 415;
        break;
    case 159:
        q_recip = 412;
        break;
    case 160:
        q_recip = 410;
        break;
    case 161:
        q_recip = 407;
        break;
    case 162:
        q_recip = 405;
        break;
    case 163:
        q_recip = 402;
        break;
    case 164:
        q_recip = 400;
        break;
    case 165:
        q_recip = 397;
        break;
    case 166:
        q_recip = 395;
        break;
    case 167:
        q_recip = 392;
        break;
    case 168:
        q_recip = 390;
        break;
    case 169:
        q_recip = 388;
        break;
    case 170:
        q_recip = 386;
        break;
    case 171:
        q_recip = 383;
        break;
    case 172:
        q_recip = 381;
        break;
    case 173:
        q_recip = 379;
        break;
    case 174:
        q_recip = 377;
        break;
    case 175:
        q_recip = 374;
        break;
    case 176:
        q_recip = 372;
        break;
    case 177:
        q_recip = 370;
        break;
    case 178:
        q_recip = 368;
        break;
    case 179:
        q_recip = 366;
        break;
    case 180:
        q_recip = 364;
        break;
    case 181:
        q_recip = 362;
        break;
    case 182:
        q_recip = 360;
        break;
    case 183:
        q_recip = 358;
        break;
    case 184:
        q_recip = 356;
        break;
    case 185:
        q_recip = 354;
        break;
    case 186:
        q_recip = 352;
        break;
    case 187:
        q_recip = 350;
        break;
    case 188:
        q_recip = 349;
        break;
    case 189:
        q_recip = 347;
        break;
    case 190:
        q_recip = 345;
        break;
    case 191:
        q_recip = 343;
        break;
    case 192:
        q_recip = 341;
        break;
    case 193:
        q_recip = 340;
        break;
    case 194:
        q_recip = 338;
        break;
    case 195:
        q_recip = 336;
        break;
    case 196:
        q_recip = 334;
        break;
    case 197:
        q_recip = 333;
        break;
    case 198:
        q_recip = 331;
        break;
    case 199:
        q_recip = 329;
        break;
    case 200:
        q_recip = 328;
        break;
    case 201:
        q_recip = 326;
        break;
    case 202:
        q_recip = 324;
        break;
    case 203:
        q_recip = 323;
        break;
    case 204:
        q_recip = 321;
        break;
    case 205:
        q_recip = 320;
        break;
    case 206:
        q_recip = 318;
        break;
    case 207:
        q_recip = 317;
        break;
    case 208:
        q_recip = 315;
        break;
    case 209:
        q_recip = 314;
        break;
    case 210:
        q_recip = 312;
        break;
    case 211:
        q_recip = 311;
        break;
    case 212:
        q_recip = 309;
        break;
    case 213:
        q_recip = 308;
        break;
    case 214:
        q_recip = 306;
        break;
    case 215:
        q_recip = 305;
        break;
    case 216:
        q_recip = 303;
        break;
    case 217:
        q_recip = 302;
        break;
    case 218:
        q_recip = 301;
        break;
    case 219:
        q_recip = 299;
        break;
    case 220:
        q_recip = 298;
        break;
    case 221:
        q_recip = 297;
        break;
    case 222:
        q_recip = 295;
        break;
    case 223:
        q_recip = 294;
        break;
    case 224:
        q_recip = 293;
        break;
    case 225:
        q_recip = 291;
        break;
    case 226:
        q_recip = 290;
        break;
    case 227:
        q_recip = 289;
        break;
    case 228:
        q_recip = 287;
        break;
    case 229:
        q_recip = 286;
        break;
    case 230:
        q_recip = 285;
        break;
    case 231:
        q_recip = 284;
        break;
    case 232:
        q_recip = 282;
        break;
    case 233:
        q_recip = 281;
        break;
    case 234:
        q_recip = 280;
        break;
    case 235:
        q_recip = 279;
        break;
    case 236:
        q_recip = 278;
        break;
    case 237:
        q_recip = 277;
        break;
    case 238:
        q_recip = 275;
        break;
    case 239:
        q_recip = 274;
        break;
    case 240:
        q_recip = 273;
        break;
    case 241:
        q_recip = 272;
        break;
    case 242:
        q_recip = 271;
        break;
    case 243:
        q_recip = 270;
        break;
    case 244:
        q_recip = 269;
        break;
    case 245:
        q_recip = 267;
        break;
    case 246:
        q_recip = 266;
        break;
    case 247:
        q_recip = 265;
        break;
    case 248:
        q_recip = 264;
        break;
    case 249:
        q_recip = 263;
        break;
    case 250:
        q_recip = 262;
        break;
    case 251:
        q_recip = 261;
        break;
    case 252:
        q_recip = 260;
        break;
    case 253:
        q_recip = 259;
        break;
    case 254:
        q_recip = 258;
        break;
    default:
        q_recip = 257;
        break;
    }
    return q_recip;
} /* reciprocal */

static void push_word(u8 *base, s32 *offset, u32 word)
{
    u8 *ptr;
    s32 i;
    s32 bytes = (word >> 24) & 0xff;
    for (i = bytes - 1; i >= 0; i--) {
        ptr = base + *offset;
        (*offset)++;
        if (i == 0)
            *ptr = word & 0xff;
        else if (i == 1)
            *ptr = (word >> 8) & 0xff;
        else if (i == 2)
            *ptr = (word >> 16) & 0xff;
    }
}

static s32 jpeg_quality_scaling(s32 quality)
{
    if (quality <= 0)
        quality = 1;
    if (quality > 100)
        quality = 100;

    if (quality < 50)
        quality = 5000 / quality;
    else
        quality = 200 - quality * 2;
    return quality;
}

static void _convert_quant_table(u16 *qtable, u16 *basic_table,
    s32 scale_factor, bool force_baseline)
{
    s32 i = 0;
    s32 temp;
    for (i = 0; i < DCTSIZE2; i++) {
        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1) {
            if (use_quality) {
                //jenc_pr(LOG_ALL, "c1 using quality factor %d\n", scale_factor);
                temp = ((s32)basic_table[i] * scale_factor + 50) / 100;
            } else {
                //jenc_pr(LOG_INFO, "c1 ignore quality factor\n");
                temp = (s32)basic_table[i];
            }
        }else
            temp = ((s32)basic_table[i] * scale_factor + 50) / 100;
        /* limit the values to the valid range */
        if (temp <= 0)
            temp = 1;
        /* max quantizer needed for 12 bits */
        if (temp > 32767)
            temp = 32767;
        /* limit to baseline range if requested */
        if (force_baseline && temp > 255)
            temp = 255;
        qtable[i] = (u16)temp;
    }
}

static void convert_quant_table(u16 *qtable, u16 *basic_table,
    s32 scale_factor)
{
    _convert_quant_table(qtable, basic_table, scale_factor, true);
}

static void write_jpeg_quant_lut(s32 table_num)
{
    s32 i;
    u32 data32;

    for (i = 0; i < DCTSIZE2; i += 2) {
        data32 = reciprocal(gQuantTable[table_num][i]);
        data32 |= reciprocal(gQuantTable[table_num][i + 1]) << 16;
        WRITE_HREG(HCODEC_QDCT_JPEG_QUANT_DATA, data32);
    }
}

static void write_jpeg_huffman_lut_dc(s32 table_num)
{
    u32 code_len, code_word, pos, addr;
    u32 num_code_len;
    u32 lut[12];
    u32 i, j;

    code_len = 1;
    code_word = 1;
    pos = 16;

    /* Construct DC Huffman table */
    for (i = 0; i < 16; i++) {
        num_code_len = jpeg_huffman_dc[table_num][i];
        for (j = 0; j < num_code_len; j++) {
            code_word = (code_word + 1) & ((1 << code_len) - 1);
            if (code_len < i + 1) {
                code_word <<= (i + 1 - code_len);
                code_len = i + 1;
            }
            addr = jpeg_huffman_dc[table_num][pos];
            lut[addr] = ((code_len - 1) << 16) | (code_word);
            pos++;
        }
    }

    /* Write DC Huffman table to HW */
    for (i = 0; i < 12; i++)
        WRITE_HREG(HCODEC_VLC_HUFFMAN_DATA, lut[i]);
}

static void write_jpeg_huffman_lut_ac(s32 table_num)
{
    u32 code_len, code_word, pos;
    u32 num_code_len;
    u32 run, size;
    u32 data, addr = 0;
    u32 *lut = NULL;
    u32 i, j;
    code_len = 1;
    code_word = 1;
    pos = 16;

    lut = (u32 *)vmalloc(162 * sizeof(u32));
    if (!lut) {
        pr_err("alloc lut failed.\n");
        return;
    }

    /* Construct AC Huffman table */
    for (i = 0; i < 16; i++) {
        num_code_len = jpeg_huffman_ac[table_num][i];
        for (j = 0; j < num_code_len; j++) {
            code_word = (code_word + 1) & ((1 << code_len) - 1);
            if (code_len < i + 1) {
                code_word <<= (i + 1 - code_len);
                code_len = i + 1;
            }
            run = jpeg_huffman_ac[table_num][pos] >> 4;
            size = jpeg_huffman_ac[table_num][pos] & 0xf;
            data = ((code_len - 1) << 16) | (code_word);
            if (size == 0) {
                if (run == 0)
                    addr = 0;     /* EOB */
                else if (run == 0xf)
                    addr = 161; /* ZRL */
                else
                    jenc_pr(LOG_ERROR,
                        "Error: Illegal AC Huffman table format!\n");
            } else if (size <= 0xa)
                addr = 1 + 16 * (size - 1) + run;
            else
                jenc_pr(LOG_ERROR,
                    "Error: Illegal AC Huffman table format!\n");
            lut[addr] = data;
            pos++;
        }
    }

    /* Write AC Huffman table to HW */
    for (i = 0; i < 162; i++)
        WRITE_HREG(HCODEC_VLC_HUFFMAN_DATA, lut[i]);

    vfree(lut);
}

static void prepare_jpeg_header(struct jpegenc_wq_s *wq)
{
    s32 pic_format;
    s32 pic_width, pic_height;
    s32 q_sel_comp0, q_sel_comp1, q_sel_comp2;
    s32 dc_huff_sel_comp0, dc_huff_sel_comp1, dc_huff_sel_comp2;
    s32 ac_huff_sel_comp0, ac_huff_sel_comp1, ac_huff_sel_comp2;
    s32 lastcoeff_sel;
    s32 jdct_intr_sel;
    s32 h_factor_comp0, v_factor_comp0;
    s32 h_factor_comp1, v_factor_comp1;
    s32 h_factor_comp2, v_factor_comp2;
    s32 q_num;
    s32 tq[2];
    s32 dc_huff_num, ac_huff_num;
    s32 dc_th[2], ac_th[2];
    u32 header_bytes = 0;
    u32 bak_header_bytes = 0;
    s32 i, j;
    u8 *assitbuf = (u8 *)wq->AssitstreamStartVirtAddr;

    if (wq->cmd.output_fmt >= JPEGENC_MAX_FRAME_FMT)
        jenc_pr(LOG_ERROR, "Input format is wrong!\n");
    switch (wq->cmd.output_fmt) {
    case JPEGENC_FMT_NV21:
    case JPEGENC_FMT_NV12:
    case JPEGENC_FMT_YUV420:
        pic_format = 3;
        break;
    case JPEGENC_FMT_YUV422_SINGLE:
        pic_format = 2;
        break;
    case JPEGENC_FMT_YUV444_SINGLE:
    case JPEGENC_FMT_YUV444_PLANE:
        pic_format = 1;
        break;
    default:
        pic_format = 0;
        break;
    }

    pic_width = wq->cmd.encoder_width;
    pic_height = wq->cmd.encoder_height;

    q_sel_comp0 = QUANT_SEL_COMP0;
    q_sel_comp1 = QUANT_SEL_COMP1;
    q_sel_comp2 = QUANT_SEL_COMP2;

    dc_huff_sel_comp0 = DC_HUFF_SEL_COMP0;
    dc_huff_sel_comp1 = DC_HUFF_SEL_COMP1;
    dc_huff_sel_comp2 = DC_HUFF_SEL_COMP2;
    ac_huff_sel_comp0 = AC_HUFF_SEL_COMP0;
    ac_huff_sel_comp1 = AC_HUFF_SEL_COMP1;
    ac_huff_sel_comp2 = AC_HUFF_SEL_COMP2;
    lastcoeff_sel = JDCT_LASTCOEFF_SEL;
    jdct_intr_sel = JDCT_INTR_SEL;

    if (pic_format == 2) {
        /* YUV422 */
        h_factor_comp0 = 1;
        v_factor_comp0 = 0;
        h_factor_comp1 = 0;
        v_factor_comp1 = 0;
        h_factor_comp2 = 0;
        v_factor_comp2 = 0;
    } else if (pic_format == 3) {
        /* YUV420 */
        h_factor_comp0 = 1;
        v_factor_comp0 = 1;
        h_factor_comp1 = 0;
        v_factor_comp1 = 0;
        h_factor_comp2 = 0;
        v_factor_comp2 = 0;
    } else {
        /* RGB or YUV */
        h_factor_comp0 = 0;
        v_factor_comp0 = 0;
        h_factor_comp1 = 0;
        v_factor_comp1 = 0;
        h_factor_comp2 = 0;
        v_factor_comp2 = 0;
    }

    /* SOI marke */
    push_word(assitbuf, &header_bytes,
        (2 << 24) | /* Number of bytes */
        (0xffd8 << 0)); /* data: SOI marker */

    /* Define quantization tables */
    q_num = 1;
#if 0
    if ((q_sel_comp0 != q_sel_comp1) ||
        (q_sel_comp0 != q_sel_comp2) ||
        (q_sel_comp1 != q_sel_comp2))
#endif
        q_num++;
#if 0
    tq[0] = q_sel_comp0;
    tq[1] = (q_sel_comp0 != q_sel_comp1) ? q_sel_comp1 :
        (q_sel_comp0 != q_sel_comp2) ? q_sel_comp2 :
        q_sel_comp0;
#endif
    tq[0] = 0;
    tq[1] = q_num - 1;

    /* data: DQT marker */
    push_word(assitbuf, &header_bytes,
        (2 << 24) | (0xffdb << 0));
    /* data: Lq */
    push_word(assitbuf, &header_bytes,
        (2 << 24) | ((2 + 65 * q_num) << 0));

    /* Add Quantization table bytes */
    /* header_bytes += (2 + (2 + 65 * q_num)); */
    for (i = 0; i < q_num; i++) {
        /* data: {Pq,Tq} */
        push_word(assitbuf, &header_bytes,
            (1 << 24) | (i << 0));
        for (j = 0; j < DCTSIZE2; j++) {
            /* data: Qk */
            push_word(assitbuf, &header_bytes,
                (1 << 24) |
                ((gQuantTable[tq[i]][zigzag(j)]) << 0));
        }
    }

    /* Define Huffman tables */
    dc_huff_num = 1;
    if ((dc_huff_sel_comp0 != dc_huff_sel_comp1) ||
        (dc_huff_sel_comp0 != dc_huff_sel_comp2) ||
        (dc_huff_sel_comp1 != dc_huff_sel_comp2))
        dc_huff_num++;

    ac_huff_num = 1;
    if ((ac_huff_sel_comp0 != ac_huff_sel_comp1) ||
        (ac_huff_sel_comp0 != ac_huff_sel_comp2) ||
        (ac_huff_sel_comp1 != ac_huff_sel_comp2))
        ac_huff_num++;

    dc_th[0] = dc_huff_sel_comp0;
    dc_th[1] = (dc_huff_sel_comp0 != dc_huff_sel_comp1) ?
        dc_huff_sel_comp1 : (dc_huff_sel_comp0 != dc_huff_sel_comp2) ?
        dc_huff_sel_comp2 : dc_huff_sel_comp0;

    ac_th[0] = ac_huff_sel_comp0;
    ac_th[1] = (ac_huff_sel_comp0 != ac_huff_sel_comp1) ?
        ac_huff_sel_comp1 : (ac_huff_sel_comp0 != ac_huff_sel_comp2) ?
        ac_huff_sel_comp2 : ac_huff_sel_comp0;

    /* data: DHT marker */
    push_word(assitbuf, &header_bytes,
        (2 << 24) | (0xffc4 << 0));
    /* data: Lh */
    push_word(assitbuf, &header_bytes,
        (2 << 24) |
        ((2 + (1 + 16 + 12) * dc_huff_num +
        (1 + 16 + 162) * ac_huff_num) << 0));

    /* Add Huffman table bytes */
    /* data: {Tc,Th} */
    for (i = 0; i < dc_huff_num; i++) {
        push_word(assitbuf, &header_bytes,
            (1 << 24) | (i << 0));
        for (j = 0; j < 16 + 12; j++) {
            /* data: Li then Vi,j */
            push_word(assitbuf, &header_bytes,
                (1 << 24) |
                ((jpeg_huffman_dc[dc_th[i]][j]) << 0));
        }
    }
    for (i = 0; i < ac_huff_num; i++) {
        push_word(assitbuf, &header_bytes,
            (1 << 24) |
            (1 << 4) | /* data: Tc */
            (i << 0)); /* data: Th */
        for (j = 0; j < 16 + 162; j++) {
            /* data: Li then Vi,j */
            push_word(assitbuf, &header_bytes,
                (1 << 24) |
                ((jpeg_huffman_ac[ac_th[i]][j]) << 0));
        }
    }

    /* Frame header */
    /* Add Frame header bytes */
    /* header_bytes += (2 + (8 + 3 * 3)); */
    push_word(assitbuf, &header_bytes,
        (2 << 24) | /* Number of bytes */
        (0xffc0 << 0)); /* data: SOF_0 marker */
    /* data: Lf */
    push_word(assitbuf, &header_bytes,
        (2 << 24) | ((8 + 3 * 3) << 0));
    /* data: P -- Sample precision */
    push_word(assitbuf,
        &header_bytes, (1 << 24) | (8 << 0));
    /* data: Y -- Number of lines */
    push_word(assitbuf,
        &header_bytes, (2 << 24) | (pic_height << 0));
    /* data: X -- Number of samples per line */
    push_word(assitbuf,
        &header_bytes, (2 << 24) | (pic_width << 0));
    /* data: Nf -- Number of components in a frame */
    push_word(assitbuf,
        &header_bytes, (1 << 24) | (3 << 0));
    /* data: C0 -- Comp0 identifier */
    push_word(assitbuf,
        &header_bytes, (1 << 24) | (0 << 0));
    push_word(assitbuf,
        &header_bytes, (1 << 24) |
        /* data: H0 -- Comp0 horizontal sampling factor */
        ((h_factor_comp0 + 1) << 4) |
        /* data: V0 -- Comp0 vertical sampling factor */
        ((v_factor_comp0 + 1) << 0));

    /* data: Tq0 -- Comp0 quantization table seletor */
    push_word(assitbuf,
        &header_bytes, (1 << 24) | (0 << 0));
    /* data: C1 -- Comp1 identifier */
    push_word(assitbuf,
        &header_bytes, (1 << 24) | (1 << 0));
    push_word(assitbuf,
        &header_bytes, (1 << 24) |
        /* data: H1 -- Comp1 horizontal sampling factor */
        ((h_factor_comp1 + 1) << 4) |
        /* data: V1 -- Comp1 vertical sampling factor */
        ((v_factor_comp1 + 1) << 0));
    /* data: Tq1 -- Comp1 quantization table seletor */
    push_word(assitbuf,
        &header_bytes, (1 << 24) |
        (((q_sel_comp0 != q_sel_comp1) ? 1 : 0) << 0));
    /* data: C2 -- Comp2 identifier */
    push_word(assitbuf,
        &header_bytes, (1 << 24) | (2 << 0));
    push_word(assitbuf,
        &header_bytes, (1 << 24) |
        /* data: H2 -- Comp2 horizontal sampling factor */
        ((h_factor_comp2 + 1) << 4) |
        /* data: V2 -- Comp2 vertical sampling factor */
        ((v_factor_comp2 + 1) << 0));
    /* data: Tq2 -- Comp2 quantization table seletor */
    push_word(assitbuf,
        &header_bytes, (1 << 24) |
        (((q_sel_comp0 != q_sel_comp2) ? 1 : 0) << 0));

    /* Scan header */
    bak_header_bytes = header_bytes + (2 + (6 + 2 * 3));

    /* Add Scan header bytes */
    /* header_bytes += (2 + (6+2*3)); */
    /* If total header bytes is not multiple of 8,
         then fill 0xff byte between Frame header segment
         and the Scan header segment. */
    /* header_bytes = ((header_bytes + 7)/8)*8; */
    bak_header_bytes = ((bak_header_bytes + 7) / 8) * 8 - bak_header_bytes;
    for (i = 0; i < bak_header_bytes; i++)
        push_word(assitbuf,
            &header_bytes,
            (1 << 24) | (0xff << 0)); /* 0xff filler */

    push_word(assitbuf,
        &header_bytes,
        (2 << 24) | /* Number of bytes */
        (0xffda << 0)); /* data: SOS marker */

    /* data: Ls */
    push_word(assitbuf,
        &header_bytes, (2 << 24) | ((6 + 2 * 3) << 0));
    /* data: Ns -- Number of components in a scan */
    push_word(assitbuf,
        &header_bytes, (1 << 24) | (3 << 0));
    /* data: Cs0 -- Comp0 identifier */
    push_word(assitbuf,
        &header_bytes, (1 << 24) | (0 << 0));
    push_word(assitbuf,
        &header_bytes, (1 << 24) |
        (0 << 4) | /* data: Td0 -- Comp0 DC Huffman table selector */
        (0 << 0)); /* data: Ta0 -- Comp0 AC Huffman table selector */
    /* data: Cs1 -- Comp1 identifier */
    push_word(assitbuf,
        &header_bytes, (1 << 24) | (1 << 0));
    push_word(assitbuf,
        &header_bytes, (1 << 24) |
        /* data: Td1 -- Comp1 DC Huffman table selector */
        (((dc_huff_sel_comp0 != dc_huff_sel_comp1) ? 1 : 0) << 4) |
        /* data: Ta1 -- Comp1 AC Huffman table selector */
        (((ac_huff_sel_comp0 != ac_huff_sel_comp1) ? 1 : 0) << 0));
    /* data: Cs2 -- Comp2 identifier */
    push_word(assitbuf,
        &header_bytes, (1 << 24) | (2 << 0));
    push_word(assitbuf,
        &header_bytes, (1 << 24) |
        /* data: Td2 -- Comp2 DC Huffman table selector */
        (((dc_huff_sel_comp0 != dc_huff_sel_comp2) ? 1 : 0) << 4) |
        /* data: Ta2 -- Comp2 AC Huffman table selector */
        (((ac_huff_sel_comp0 != ac_huff_sel_comp2) ? 1 : 0) << 0));
    push_word(assitbuf, &header_bytes,
        (3 << 24) |
        (0 << 16) | /* data: Ss = 0 */
        (63 << 8) | /* data: Se = 63 */
        (0 << 4) | /* data: Ah = 0 */
        (0 << 0)); /* data: Al = 0 */
    jenc_pr(LOG_INFO, "jpeg header bytes is %d\n", header_bytes);
    wq->headbytes = header_bytes;
}

static void init_jpeg_encoder(struct jpegenc_wq_s *wq)
{
    u32 data32;
    s32 pic_format; /* 0=RGB; 1=YUV; 2=YUV422; 3=YUV420 */
    s32 pic_x_start, pic_x_end, pic_y_start, pic_y_end;
    s32 pic_width, pic_height;
    u32 q_sel_comp0, q_sel_comp1, q_sel_comp2;
    s32 dc_huff_sel_comp0, dc_huff_sel_comp1, dc_huff_sel_comp2;
    s32 ac_huff_sel_comp0, ac_huff_sel_comp1, ac_huff_sel_comp2;
    s32 lastcoeff_sel;
    s32 jdct_intr_sel;
    s32 h_factor_comp0, v_factor_comp0;
    s32 h_factor_comp1, v_factor_comp1;
    s32 h_factor_comp2, v_factor_comp2;

    jenc_pr(LOG_INFO, "Initialize JPEG Encoder ....\n");
    if (wq->cmd.output_fmt >= JPEGENC_MAX_FRAME_FMT)
        jenc_pr(LOG_ERROR, "Input format is wrong!\n");
    switch (wq->cmd.output_fmt) {
    case JPEGENC_FMT_NV21:
    case JPEGENC_FMT_NV12:
    case JPEGENC_FMT_YUV420:
        pic_format = 3;
        break;
    case JPEGENC_FMT_YUV422_SINGLE:
        pic_format = 2;
        break;
    case JPEGENC_FMT_YUV444_SINGLE:
    case JPEGENC_FMT_YUV444_PLANE:
        pic_format = 1;
        break;
    default:
        pic_format = 0;
        break;
    }

    pic_x_start = 0;
    pic_x_end = wq->cmd.encoder_width - 1;

    pic_y_start = 0;
    pic_y_end = wq->cmd.encoder_height - 1;

    pic_width = wq->cmd.encoder_width;
    pic_height = wq->cmd.encoder_height;

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1) {
        q_sel_comp0 = QUANT_SEL_COMP0 & 0xff;
        q_sel_comp1 = QUANT_SEL_COMP1 & 0xff;
        q_sel_comp2 = QUANT_SEL_COMP2 & 0xff;
    } else {
        q_sel_comp0 = wq->cmd.QuantTable_id * 2;
        q_sel_comp1 = q_sel_comp0 + 1;
        q_sel_comp2 = q_sel_comp1;
    }
    if (q_sel_comp0 >= 6 || q_sel_comp1 >= 6)
    {
        jenc_pr(LOG_ERROR, "error, q_sel_comp0, q_sel_comp1 is invalid %d,%d\n",
            q_sel_comp0, q_sel_comp1);
        return;
    }
    dc_huff_sel_comp0 = DC_HUFF_SEL_COMP0;
    dc_huff_sel_comp1 = DC_HUFF_SEL_COMP1;
    dc_huff_sel_comp2 = DC_HUFF_SEL_COMP2;
    ac_huff_sel_comp0 = AC_HUFF_SEL_COMP0;
    ac_huff_sel_comp1 = AC_HUFF_SEL_COMP1;
    ac_huff_sel_comp2 = AC_HUFF_SEL_COMP2;
    lastcoeff_sel = JDCT_LASTCOEFF_SEL;
    jdct_intr_sel = JDCT_INTR_SEL;

    if (pic_format == 2) {
        /* YUV422 */
        h_factor_comp0 = 1;
        v_factor_comp0 = 0;
        h_factor_comp1 = 0;
        v_factor_comp1 = 0;
        h_factor_comp2 = 0;
        v_factor_comp2 = 0;
    } else if (pic_format == 3) {
        /* YUV420 */
        h_factor_comp0 = 1;
        v_factor_comp0 = 1;
        h_factor_comp1 = 0;
        v_factor_comp1 = 0;
        h_factor_comp2 = 0;
        v_factor_comp2 = 0;
    } else {
        /* RGB or YUV */
        h_factor_comp0 = 0;
        v_factor_comp0 = 0;
        h_factor_comp1 = 0;
        v_factor_comp1 = 0;
        h_factor_comp2 = 0;
        v_factor_comp2 = 0;
    }

    /* Configure picture size and format */
    WRITE_HREG(HCODEC_VLC_PIC_SIZE, pic_width | (pic_height << 16));
    WRITE_HREG(HCODEC_VLC_PIC_POSITION, pic_format | (lastcoeff_sel << 4));
    WRITE_HREG(HCODEC_QDCT_JPEG_X_START_END,
           ((pic_x_end << 16) | (pic_x_start << 0)));
    WRITE_HREG(HCODEC_QDCT_JPEG_Y_START_END,
           ((pic_y_end << 16) | (pic_y_start << 0)));

    /* Configure quantization tables */
#ifdef EXTEAN_QUANT_TABLE
    if (external_quant_table_available) {
        convert_quant_table(&gQuantTable[0][0],
            &gExternalQuantTablePtr[0],
            wq->cmd.jpeg_quality);
        convert_quant_table(&gQuantTable[1][0],
            &gExternalQuantTablePtr[DCTSIZE2],
            wq->cmd.jpeg_quality);
        q_sel_comp0 = 0;
        q_sel_comp1 = 1;
        q_sel_comp2 = 1;
    } else
#endif
    {
        s32 tq[2];
        tq[0] = q_sel_comp0;
        tq[1] = (q_sel_comp0 != q_sel_comp1) ?
            q_sel_comp1 : (q_sel_comp0 != q_sel_comp2) ?
            q_sel_comp2 : q_sel_comp0;
        convert_quant_table(&gQuantTable[0][0],
            (u16 *)&jpeg_quant[tq[0]],
            wq->cmd.jpeg_quality);
        if (tq[0] != tq[1])
            convert_quant_table(&gQuantTable[1][0],
                (u16 *)&jpeg_quant[tq[1]],
                wq->cmd.jpeg_quality);
        q_sel_comp0 = tq[0];
        q_sel_comp1 = tq[1];
        q_sel_comp2 = tq[1];
    }

    /* Set Quantization LUT start address */
    data32 = 0;
    data32 |= 0 << 8; /* [8] 0=Write LUT, 1=Read */
    data32 |= 0 << 0; /* [5:0] Start addr = 0 */

    WRITE_HREG(HCODEC_QDCT_JPEG_QUANT_ADDR, data32);

    /* Burst-write Quantization LUT data */
    if (get_cpu_major_id() < AM_MESON_CPU_MAJOR_ID_C1) {
        write_jpeg_quant_lut(0);
        if (q_sel_comp0 != q_sel_comp1)
            write_jpeg_quant_lut(1);
    } else {
        write_jpeg_quant_lut(q_sel_comp0);
        if (q_sel_comp1 != q_sel_comp0)
            write_jpeg_quant_lut(q_sel_comp1);
        if ((q_sel_comp2 != q_sel_comp0) && (q_sel_comp2 != q_sel_comp1))
            write_jpeg_quant_lut(q_sel_comp2);
    }

    /* Configure Huffman tables */

    /* Set DC Huffman LUT start address */
    data32 = 0;
    data32 |= 0 << 16; /* [16] 0=Write LUT, 1=Read */
    data32 |= 0 << 0; /* [8:0] Start addr = 0 */
    WRITE_HREG(HCODEC_VLC_HUFFMAN_ADDR, data32);

    /* Burst-write DC Huffman LUT data */
    write_jpeg_huffman_lut_dc(dc_huff_sel_comp0);
    if (dc_huff_sel_comp1 != dc_huff_sel_comp0)
        write_jpeg_huffman_lut_dc(dc_huff_sel_comp1);

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1) {
        if ((dc_huff_sel_comp2 != dc_huff_sel_comp0)
            && (dc_huff_sel_comp2 != dc_huff_sel_comp1))
            write_jpeg_huffman_lut_dc(dc_huff_sel_comp2);
    }

    /* Set AC Huffman LUT start address */
    data32 = 0;
    data32 |= 0 << 16; /* [16] 0=Write LUT, 1=Read */
    data32 |= 24 << 0; /* [8:0] Start addr = 0 */
    WRITE_HREG(HCODEC_VLC_HUFFMAN_ADDR, data32);

    /* Burst-write AC Huffman LUT data */
    write_jpeg_huffman_lut_ac(ac_huff_sel_comp0);
    if (ac_huff_sel_comp1 != ac_huff_sel_comp0)
        write_jpeg_huffman_lut_ac(ac_huff_sel_comp1);

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1) {
        if ((ac_huff_sel_comp2 != ac_huff_sel_comp0)
            && (ac_huff_sel_comp2 != ac_huff_sel_comp1))
            write_jpeg_huffman_lut_ac(ac_huff_sel_comp2);
    }

    /* Configure general control registers */
    data32 = 0;
    /* [19:18] dct_inflow_ctrl: 0=No halt; */
    /* 1=DCT halts request at end of each 8x8 block; */
    /* 2=DCT halts request at end of each MCU. */
    data32 |= 0 << 18;
    /* [17:16] jpeg_coeff_last_sel: */
    /* 0=Mark last coeff at the end of an 8x8 block, */
    /* 1=Mark last coeff at the end of an MCU */
    /* 2=Mark last coeff at the end of a scan */
    data32 |= lastcoeff_sel << 16;
    /* [15] jpeg_quant_sel_comp2 */
    data32 |= ((q_sel_comp2 == q_sel_comp0) ? 0 : 1) << 15;
    /* [14] jpeg_v_factor_comp2 */
    data32 |= v_factor_comp2 << 14;
    /* [13] jpeg_h_factor_comp2 */
    data32 |= h_factor_comp2 << 13;
    /* [12] jpeg_comp2_en */
    data32 |= 1 << 12;
    /* [11] jpeg_quant_sel_comp1 */
    data32 |= ((q_sel_comp1 == q_sel_comp0) ? 0 : 1) << 11;
    /* [10] jpeg_v_factor_comp1 */
    data32 |= v_factor_comp1 << 10;
    /* [9] jpeg_h_factor_comp1 */
    data32 |= h_factor_comp1 << 9;
    /* [8] jpeg_comp1_en */
    data32 |= 1 << 8;
    /* [7] jpeg_quant_sel_comp0 */
    data32 |= 0 << 7;
    /* [6] jpeg_v_factor_comp0 */
    data32 |= v_factor_comp0 << 6;
    /* [5] jpeg_h_factor_comp0 */
    data32 |= h_factor_comp0 << 5;
    /* [4] jpeg_comp0_en */
    data32 |= 1 << 4;
    /* [3:1] jdct_intr_sel:0=Disable intr; */
    /* 1=Intr at end of each 8x8 block of DCT input; */
    /* 2=Intr at end of each MCU of DCT input; */
    /* 3=Intr at end of a scan of DCT input; */
    /* 4=Intr at end of each 8x8 block of DCT output; */
    /* 5=Intr at end of each MCU of DCT output; */
    /* 6=Intr at end of a scan of DCT output. */
    data32 |= jdct_intr_sel << 1;
    /* [0] jpeg_en */
    data32 |= 1 << 0;
    WRITE_HREG(HCODEC_QDCT_JPEG_CTRL, data32);

    data32 = 0;
    data32 |= ((ac_huff_sel_comp2 == ac_huff_sel_comp0)? 0 : 1) << 29;  // [   29] jpeg_comp2_ac_table_sel
    data32 |= ((dc_huff_sel_comp2 == dc_huff_sel_comp0)? 0 : 1) << 28;  // [   28] jpeg_comp2_dc_table_sel
    /* [26:25] jpeg_comp2_cnt_max */
    data32 |= ((h_factor_comp2 + 1) * (v_factor_comp2 + 1) - 1) << 25;
    /* [24] jpeg_comp2_en */
    data32 |= 1 << 24;
    data32 |= ((ac_huff_sel_comp1 == ac_huff_sel_comp0)? 0 : 1) << 21;  // [   21] jpeg_comp1_ac_table_sel
    data32 |= ((dc_huff_sel_comp1 == dc_huff_sel_comp0)? 0 : 1) << 20;  // [   20] jpeg_comp1_dc_table_sel
    /* [18:17] jpeg_comp1_cnt_max */
    data32 |= ((h_factor_comp1 + 1) * (v_factor_comp1 + 1) - 1) << 17;
    /* [16] jpeg_comp1_en */
    data32 |= 1 << 16;
    /* [13] jpeg_comp0_ac_table_sel */
    data32 |= 0 << 13;
    /* [12] jpeg_comp0_dc_table_sel */
    data32 |= 0 << 12;
    /* [10:9] jpeg_comp0_cnt_max */
    data32 |= ((h_factor_comp0 + 1) * (v_factor_comp0 + 1) - 1) << 9;
    /* [8] jpeg_comp0_en */
    data32 |= 1 << 8;
    /* [0] jpeg_en, will be enbled by amrisc */
    data32 |= 0 << 0;
    WRITE_HREG(HCODEC_VLC_JPEG_CTRL, data32);

    WRITE_HREG(HCODEC_QDCT_MB_CONTROL,
        (1 << 9) | /* mb_info_soft_reset */
        (1 << 0)); /* mb read buffer soft reset */

    WRITE_HREG(HCODEC_QDCT_MB_CONTROL,
        (0 << 28) | /* ignore_t_p8x8 */
        (0 << 27) | /* zero_mc_out_null_non_skipped_mb */
        (0 << 26) | /* no_mc_out_null_non_skipped_mb */
        (0 << 25) | /* mc_out_even_skipped_mb */
        (0 << 24) | /* mc_out_wait_cbp_ready */
        (0 << 23) | /* mc_out_wait_mb_type_ready */
        (0 << 29) | /* ie_start_int_enable */
        (0 << 19) | /* i_pred_enable */
        (0 << 20) | /* ie_sub_enable */
        (0 << 18) | /* iq_enable */
        (0 << 17) | /* idct_enable */
        (0 << 14) | /* mb_pause_enable */
        (1 << 13) | /* q_enable */
        (1 << 12) | /* dct_enable */
        (0 << 10) | /* mb_info_en */
        (0 << 3) | /* endian */
        (0 << 1) | /* mb_read_en */
        (0 << 0)); /* soft reset */

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1) {
        // INIT_ENCODER
        WRITE_HREG(HCODEC_VLC_TOTAL_BYTES, 0);
        WRITE_HREG(HCODEC_VLC_INT_CONTROL, 0);// disable vlc interrupt

        WRITE_HREG(HCODEC_HENC_SCRATCH_0, 0);// mtspi   ENCODER_IDLE = ( ENCODER_STATUS
        WRITE_HREG(HCODEC_HENC_SCRATCH_1, 0xffffffff);// reset MCU_XY_REG

        WRITE_HREG(HCODEC_ASSIST_AMR1_INT0, 0x15);// vb_full_isr
        WRITE_HREG(HCODEC_ASSIST_AMR1_INT1, 8);// vlc_isr
        WRITE_HREG(HCODEC_ASSIST_AMR1_INT3, 0x14);// qdct_isr
    }

    /* Assember JPEG file header */
    prepare_jpeg_header(wq);
}

static void jpegenc_init_output_buffer(struct jpegenc_wq_s *wq)
{
    WRITE_HREG(HCODEC_VLC_VB_MEM_CTL,
        ((1 << 31) | (0x3f << 24) |
        (0x20 << 16) | (2 << 0)));

    WRITE_HREG(HCODEC_VLC_VB_START_PTR, wq->BitstreamStart);
    WRITE_HREG(HCODEC_VLC_VB_WR_PTR,    wq->BitstreamStart);
    WRITE_HREG(HCODEC_VLC_VB_SW_RD_PTR, wq->BitstreamStart);
    WRITE_HREG(HCODEC_VLC_VB_END_PTR,   wq->BitstreamEnd);
    WRITE_HREG(HCODEC_VLC_VB_CONTROL,   1);
    WRITE_HREG(HCODEC_VLC_VB_CONTROL,
        ((0 << 14) | (7 << 3) |
        (1 << 1) | (0 << 0)));
}

static void jpegenc_buffspec_init(struct jpegenc_wq_s *wq)
{
    /* input dct buffer config */
    wq->InputBuffStart = wq->buf_start + gJpegenc.mem.bufspec->input.buf_start;
    wq->InputBuffEnd = wq->InputBuffStart + gJpegenc.mem.bufspec->input.buf_size - 1;
    jenc_pr(LOG_INFO, "InputBuffStart is 0x%x\n", wq->InputBuffStart);

    /* assit stream buffer config */
    wq->AssitStart =  wq->buf_start + gJpegenc.mem.bufspec->assit.buf_start;
    wq->AssitEnd = wq->AssitStart + gJpegenc.mem.bufspec->assit.buf_size - 1;
    /* output stream buffer config */
    wq->BitstreamStart =  wq->buf_start + gJpegenc.mem.bufspec->bitstream.buf_start;
    wq->BitstreamEnd = wq->BitstreamStart + gJpegenc.mem.bufspec->bitstream.buf_size - 1;
    jenc_pr(LOG_INFO, "BitstreamStart is 0x%x\n", wq->BitstreamStart);

    wq->AssitstreamStartVirtAddr = phys_to_virt(wq->AssitStart);
    jenc_pr(LOG_INFO, "AssitstreamStartVirtAddr is %p\n", wq->AssitstreamStartVirtAddr);
}

/* for temp */
#define HCODEC_MFDIN_REGC_MBLP        (HCODEC_MFDIN_REGB_AMPC + 0x1)
#define HCODEC_MFDIN_REG0D            (HCODEC_MFDIN_REGB_AMPC + 0x2)
#define HCODEC_MFDIN_REG0E            (HCODEC_MFDIN_REGB_AMPC + 0x3)
#define HCODEC_MFDIN_REG0F            (HCODEC_MFDIN_REGB_AMPC + 0x4)
#define HCODEC_MFDIN_REG10            (HCODEC_MFDIN_REGB_AMPC + 0x5)
#define HCODEC_MFDIN_REG11            (HCODEC_MFDIN_REGB_AMPC + 0x6)
#define HCODEC_MFDIN_REG12            (HCODEC_MFDIN_REGB_AMPC + 0x7)
#define HCODEC_MFDIN_REG13            (HCODEC_MFDIN_REGB_AMPC + 0x8)
#define HCODEC_MFDIN_REG14            (HCODEC_MFDIN_REGB_AMPC + 0x9)
#define HCODEC_MFDIN_REG15            (HCODEC_MFDIN_REGB_AMPC + 0xa)
#define HCODEC_MFDIN_REG16            (HCODEC_MFDIN_REGB_AMPC + 0xb)

static void mfdin_basic_jpeg(
    u32 input, u8 iformat, u8 oformat, u32 picsize_x,
    u32 picsize_y, u8 r2y_en, u8 ifmt_extra,
    int mfdin_canvas0_stride,
    int mfdin_canvas1_stride,
    int mfdin_canvas2_stride,
    int mfdin_canvas0_blkmode,
    int mfdin_canvas1_blkmode,
    int mfdin_canvas2_blkmode,
    int mfdin_canvas0_addr,
    int mfdin_canvas1_addr,
    int mfdin_canvas2_addr,
    int mfdin_canvas_bias,
    bool mfdin_big_endian)
{
    u8 dsample_en; /* Downsample Enable */
    u8 interp_en; /* Interpolation Enable */
    u8 y_size; /* 0:16 Pixels for y direction pickup; 1:8 pixels */
    u8 r2y_mode; /* RGB2YUV Mode, range(0~3) */
    /* mfdin_reg3_canv[25:24]; */
    /* bytes per pixel in x direction for index0, 0:half 1:1 2:2 3:3 */
    u8 canv_idx0_bppx;
    /* mfdin_reg3_canv[27:26]; */
    /* bytes per pixel in x direction for index1-2, 0:half 1:1 2:2 3:3 */
    u8 canv_idx1_bppx;
    /* mfdin_reg3_canv[29:28]; */
    /* bytes per pixel in y direction for index0, 0:half 1:1 2:2 3:3 */
    u8 canv_idx0_bppy;
    /* mfdin_reg3_canv[31:30]; */
    /* bytes per pixel in y direction for index1-2, 0:half 1:1 2:2 3:3 */
    u8 canv_idx1_bppy;
    u8 ifmt444, ifmt422, ifmt420, linear_bytes4p;
    u32 linear_bytesperline;
    int mfdin_input_mode = 0;
    //s32 reg_offset;
    bool format_err = false;
    u32 data32;

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_TXL) {
        if ((iformat == 7) && (ifmt_extra > 2))
            format_err = true;
    } else if (iformat == 7)
        format_err = true;

    if (format_err) {
        jenc_pr(LOG_ERROR,
            "mfdin format err, iformat:%d, ifmt_extra:%d\n",
            iformat, ifmt_extra);
        return;
    }
    if (iformat != 7)
        ifmt_extra = 0;

    ifmt444 = ((iformat == 1) || (iformat == 5) || (iformat == 8)
        || (iformat == 9) || (iformat == 12)) ? 1 : 0;
    if (iformat == 7 && ifmt_extra == 1)
        ifmt444 = 1;
    ifmt422 = ((iformat == 0) || (iformat == 10)) ? 1 : 0;
    if (iformat == 7 && ifmt_extra != 1)
        ifmt422 = 1;
    ifmt420 = ((iformat == 2) || (iformat == 3) || (iformat == 4)
        || (iformat == 11)) ? 1 : 0;
    dsample_en = ((ifmt444 && (oformat != 2))
        || (ifmt422 && (oformat == 0))) ? 1 : 0;
    interp_en = ((ifmt422 && (oformat == 2))
             || (ifmt420 && (oformat != 0))) ? 1 : 0;
    y_size = (oformat != 0) ? 1 : 0;
    /* r2y_mode = (r2y_en == 1) ? 1 : 0; */
    r2y_mode = 1;
    canv_idx0_bppx = (iformat == 1) ? 3 : (iformat == 0) ? 2 : 1;
    canv_idx1_bppx = (iformat == 4) ? 0 : 1;
    canv_idx0_bppy = 1;
    canv_idx1_bppy = (iformat == 5) ? 1 : 0;

    if ((iformat == 8) || (iformat == 9) || (iformat == 12))
        linear_bytes4p = 3;
    else if (iformat == 10)
        linear_bytes4p = 2;
    else if (iformat == 11)
        linear_bytes4p = 1;
    else
        linear_bytes4p = 0;
    linear_bytesperline = picsize_x * linear_bytes4p;

    if (iformat < 8)
        mfdin_input_mode = 0;
    else
        mfdin_input_mode = 1;

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1)
        mfdin_input_mode = 2;

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXBB) {
        reg_offset = -8;
        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1)
            WRITE_HREG((HCODEC_MFDIN_REG8_DMBL + reg_offset),
                (picsize_x << 16) | (picsize_y << 0));
        else
            WRITE_HREG((HCODEC_MFDIN_REG8_DMBL + reg_offset),
                (picsize_x << 14) | (picsize_y << 0));
    } else {
        reg_offset = 0;
        WRITE_HREG((HCODEC_MFDIN_REG8_DMBL + reg_offset),
            (picsize_x << 12) | (picsize_y << 0));
    }

    WRITE_HREG((HCODEC_MFDIN_REG1_CTRL + reg_offset),
        (iformat << 0) |
        (oformat << 4) |
        (dsample_en << 6) |
        (y_size << 8) |
        (interp_en << 9) |
        (r2y_en << 12) |
        (r2y_mode << 13) |
        (ifmt_extra << 16) |
        (0 <<19) | // 0:NR Not Enabled
        (2 <<29) | // 0:H264_I_PIC_ALL_4x4, 1:H264_P_PIC_Y_16x16_C_8x8, 2:JPEG_ALL_8x8, 3:Reserved
        (0 <<31));  // 0:YC interleaved 1:YC non-interleaved(for JPEG)

    if (mfdin_input_mode == 0) {
        WRITE_HREG((HCODEC_MFDIN_REG3_CANV + reg_offset),
            (input & 0xffffff) |
            (canv_idx1_bppy << 30) |
            (canv_idx0_bppy << 28) |
            (canv_idx1_bppx << 26) |
            (canv_idx0_bppx << 24));
        WRITE_HREG((HCODEC_MFDIN_REG4_LNR0 + reg_offset),
            (0 << 16) | (0 << 0));
        WRITE_HREG((HCODEC_MFDIN_REG5_LNR1 + reg_offset), 0);
    } else if (mfdin_input_mode == 1) {
        WRITE_HREG((HCODEC_MFDIN_REG3_CANV + reg_offset),
            (canv_idx1_bppy << 30) |
            (canv_idx0_bppy << 28) |
            (canv_idx1_bppx << 26) |
            (canv_idx0_bppx << 24));
        WRITE_HREG((HCODEC_MFDIN_REG4_LNR0 + reg_offset),
            (linear_bytes4p << 16) | (linear_bytesperline << 0));
        WRITE_HREG((HCODEC_MFDIN_REG5_LNR1 + reg_offset), input);
    } else if (mfdin_input_mode == 2) {
        WRITE_HREG((HCODEC_MFDIN_REG3_CANV + reg_offset),
            (canv_idx1_bppy << 30) |
            (canv_idx0_bppy << 28) |
            (canv_idx1_bppx << 26) |
            (canv_idx0_bppx << 24));
        WRITE_HREG((HCODEC_MFDIN_REG4_LNR0 + reg_offset),
            mfdin_canvas0_stride << 0);
        WRITE_HREG((HCODEC_MFDIN_REG5_LNR1 + reg_offset), mfdin_canvas0_addr);

        WRITE_HREG(HCODEC_MFDIN_REG17, mfdin_canvas1_addr);        // U canvas initial address
        WRITE_HREG(HCODEC_MFDIN_REG18, mfdin_canvas2_addr);        // V canvas initial address
        WRITE_HREG(HCODEC_MFDIN_REG19, (mfdin_canvas1_stride << 16) |    // U canvas stride
                                   (mfdin_canvas2_stride << 0));

        data32 = READ_HREG(HCODEC_MFDIN_REG6_DCFG + reg_offset);
        data32 = data32 & 0x3ff;

        if (jpeg_in_full_hcodec) {
            pr_err("JPEG_IN_FULL_HCODEC\n");
            data32 |= (0<<16);

            if(mfdin_ambus_canv_conv) {
                data32 |= (1<<17); // AMBUS
            }
        } else {
            data32 |= (1 << 16); // AXI Enable
        }

        data32 |= (mfdin_canvas0_blkmode << 14) |        // V canvas block mode
                  (mfdin_canvas1_blkmode << 12) |        // U canvas block mode
                  (mfdin_canvas2_blkmode << 10);         // Y canvas block mode

        WRITE_HREG(HCODEC_MFDIN_REG6_DCFG + reg_offset, data32);

        if (mfdin_canvas_bias)
            WRITE_HREG(HCODEC_MFDIN_REGA_CAV1 + reg_offset, mfdin_canvas_bias);
    }

    if (!mfdin_big_endian) {
        WRITE_HREG((HCODEC_MFDIN_REG9_ENDN + reg_offset),
            (7 << 0) | (6 << 3) | (5 << 6) |
            (4 << 9) | (3 << 12) | (2 << 15) |
            (1 << 18) | (0 << 21));
    }

    if (jpeg_in_full_hcodec) {//#ifdef JPEG_IN_FULL_HCODEC
        data32 = READ_HREG(HCODEC_MFDIN_REG3_CANV + reg_offset);
        WRITE_HREG(HCODEC_MFDIN_REG3_CANV + reg_offset, data32|(0x1 << 8)|(0x2 << 16));
    }

    data32 = READ_HREG(HCODEC_MFDIN_REG7_SCMD + reg_offset);
    WRITE_HREG(HCODEC_MFDIN_REG7_SCMD + reg_offset, data32 | (0x1 << 28)); // MFDIN Enabled

    jenc_pr(LOG_INFO, "MFDIN Enabled\n");

    return;
}

//#define CONFIG_AMLOGIC_MEDIA_CANVAS

static s32 set_jpeg_input_format(struct jpegenc_wq_s *wq,
    struct jpegenc_request_s *cmd)
{
    s32 ret = 0;
    u8 iformat = JPEGENC_MAX_FRAME_FMT;
    u8 oformat = JPEGENC_MAX_FRAME_FMT;
    u8 r2y_en = 0;
    u32 picsize_x = 0, picsize_y = 0;
    u32 input = cmd->src;
    u8 ifmt_extra = 0;
    int mfdin_canvas0_stride = 0, mfdin_canvas1_stride = 0, mfdin_canvas2_stride = 0;
    int mfdin_canvas0_blkmode = 0, mfdin_canvas1_blkmode = 0, mfdin_canvas2_blkmode = 0;
    int mfdin_canvas0_addr = 0, mfdin_canvas1_addr = 0, mfdin_canvas2_addr = 0;
    int mfdin_canvas_height = 0;
    int mfdin_canvas_bias = 0;
    bool mfdin_big_endian = false;
    u32 block_mode = 0;

#ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
    u32 canvas_w = 0;
#endif

    jenc_pr(LOG_INFO, "************begin set input format**************\n");
    jenc_pr(LOG_INFO, "type is %d\n", cmd->type);
    jenc_pr(LOG_INFO, "input_fmt is %d\n", cmd->input_fmt);
    jenc_pr(LOG_INFO, "output_fmt is %d\n", cmd->output_fmt);
    jenc_pr(LOG_INFO, "input is 0x%x\n", cmd->src);
    jenc_pr(LOG_INFO, "size is %d\n", cmd->framesize);
    jenc_pr(LOG_INFO, "quality is %d\n", cmd->jpeg_quality);
    jenc_pr(LOG_INFO, "quant tbl_id is %d\n", cmd->QuantTable_id);
    jenc_pr(LOG_INFO, "flush flag is %d\n", cmd->flush_flag);
    jenc_pr(LOG_INFO, "block mode is %d\n", cmd->block_mode);
    jenc_pr(LOG_INFO, "************end set input format**************\n");

    if ((cmd->type == JPEGENC_LOCAL_BUFF) ||
        (cmd->type == JPEGENC_DMA_BUFF) ||
        (cmd->type == JPEGENC_PHYSICAL_BUFF)) {

        if (cmd->type == JPEGENC_LOCAL_BUFF) {
            if (cmd->flush_flag & JPEGENC_FLUSH_FLAG_INPUT)
                dma_flush(wq->InputBuffStart, cmd->framesize);
        }

        if (cmd->type == JPEGENC_LOCAL_BUFF || cmd->type == JPEGENC_DMA_BUFF)
            input = wq->InputBuffStart;

        picsize_x = ((cmd->encoder_width + 15) >> 4) << 4;
        picsize_y = ((cmd->encoder_height + 15) >> 4) << 4;

        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1) {
            /*
             * mfdin in  fmt:  0:422 single, 1:444 single, 2:NV21, 3:NV12, 4:420 plane, 5:444 plane
             * mfdin out fmt:  0:420, 1:422, 2:444
             * picture   fmt:  0:RGB, 1:444, 2:422, 3:420
             * (out, pic)   :  (0,3), (1,2), (2,1)
             */
            if (cmd->input_fmt     == JPEGENC_FMT_YUV422_SINGLE)
                iformat = 0;

            else if (cmd->input_fmt == JPEGENC_FMT_YUV444_SINGLE)
                iformat = 1;

            else if (cmd->input_fmt == JPEGENC_FMT_NV21)
                iformat = 2;

            else if (cmd->input_fmt == JPEGENC_FMT_NV12)
                iformat = 3;

            else if (cmd->input_fmt == JPEGENC_FMT_YUV420)
                iformat = 4;

            else if (cmd->input_fmt == JPEGENC_FMT_YUV444_PLANE)
                iformat = 5;

            if (cmd->output_fmt     == JPEGENC_FMT_YUV420)
                oformat = 0;
            else if (cmd->output_fmt == JPEGENC_FMT_YUV422_SINGLE)
                oformat = 1;
            else if (cmd->output_fmt == JPEGENC_FMT_YUV444_SINGLE)
                oformat = 2;

            block_mode = cmd->block_mode;
            mfdin_canvas0_stride = cmd->y_stride;
            mfdin_canvas1_stride = cmd->u_stride;
            mfdin_canvas2_stride = cmd->v_stride;
            mfdin_canvas_height = cmd->h_stride;

            if (simulation_enable) {
                if (g_block_mode)
                    block_mode = g_block_mode;
                if (g_canv0_stride)
                    mfdin_canvas0_stride = g_canv0_stride;
                if (g_canv1_stride)
                    mfdin_canvas1_stride = g_canv1_stride;
                if (g_canv2_stride)
                    mfdin_canvas2_stride = g_canv2_stride;
                if (g_canvas_height)
                    mfdin_canvas_height = g_canvas_height;
            }

            if (block_mode) {
                mfdin_canvas0_blkmode = 1;
                mfdin_canvas1_blkmode = 1;
                mfdin_canvas2_blkmode = 1;
            } else {
                mfdin_canvas0_blkmode = 0;
                mfdin_canvas1_blkmode = 0;
                mfdin_canvas2_blkmode = 0;
            }

            if ((iformat == 0 && oformat == 0) ||    /*case1013, 422 single -> 420*/
                (iformat == 0 && oformat == 1) ||    /*case1002, 422 single -> 422*/
                (iformat == 0 && oformat == 2) ||    /*case1004, 422 single -> 444*/
                (iformat == 1 && oformat == 1) ||    /*case1003, 444 single -> 444*/
                (iformat == 1 && oformat == 0) ||
                (iformat == 1 && oformat == 2)) {    /*case1005, 444 single -> 444*/
                mfdin_canvas0_addr = input;
                mfdin_canvas1_addr = input;
                mfdin_canvas2_addr = input;

                if (iformat == 0) {
                    mfdin_canvas0_stride = cmd->y_stride * 2;
                    mfdin_canvas1_stride = cmd->u_stride * 2;
                    mfdin_canvas2_stride = cmd->v_stride * 3;
                } else if (iformat == 1) {
                    mfdin_canvas0_stride = cmd->y_stride * 3;
                    mfdin_canvas1_stride = cmd->u_stride * 3;
                    mfdin_canvas2_stride = cmd->v_stride * 3;
                }
            } else if ((iformat == 2 && oformat == 0) ||
                (iformat == 3 && oformat == 0) ||    /*case1001, NV21 -> 420*/
                (iformat == 3 && oformat == 1) ||    /*case1000, NV21 -> 422*/
                (iformat == 3 && oformat == 2) ||    /*case1006, NV21 -> 444*/
                (iformat == 2 && oformat == 2) ||
                (iformat == 2 && oformat == 1)) {    /*case1006, NV12 -> 444, linear*/
                mfdin_canvas0_addr = input;
                mfdin_canvas1_addr = input + mfdin_canvas0_stride * mfdin_canvas_height;
                mfdin_canvas2_addr = mfdin_canvas1_addr;
            } else if ((iformat == 4 && oformat == 0) ||    /*case1010, 420 plane -> 420*/
                (iformat == 4 && oformat == 2) ||
                (iformat == 4 && oformat == 1)) {            /*case1008, case1011, case1012, 420 plane -> 444*/
                if (!simulation_enable) {
                    mfdin_canvas1_stride = mfdin_canvas0_stride / 2;
                    mfdin_canvas2_stride = mfdin_canvas0_stride / 2;
                }
                mfdin_canvas0_addr = input;
                mfdin_canvas1_addr = input + mfdin_canvas0_stride * mfdin_canvas_height;

                mfdin_canvas2_addr = input + mfdin_canvas0_stride * mfdin_canvas_height +
                        mfdin_canvas0_stride * mfdin_canvas_height / 4;

                jenc_pr(LOG_INFO, "%x:%x:%x, mfdin_canvas0_stride=%d, mfdin_canvas1_stride=%d, mfdin_canvas2_stride=%d, mfdin_canvas_height=%d\n",
                    mfdin_canvas0_addr, mfdin_canvas1_addr, mfdin_canvas2_addr,
                    mfdin_canvas0_stride,
                    mfdin_canvas1_stride,
                    mfdin_canvas2_stride,
                    mfdin_canvas_height);

                jenc_pr(LOG_INFO, "process yuv420p input, uoff=%d, voff=%d\n",
                        mfdin_canvas0_stride * mfdin_canvas_height,
                        mfdin_canvas0_stride * mfdin_canvas_height +
                        mfdin_canvas0_stride * mfdin_canvas_height / 4);
            } else if (iformat == 4 && oformat == 1) {    /*case1009, 420 plane -> 422*/
                if (!simulation_enable) {
                    mfdin_canvas1_stride = mfdin_canvas0_stride / 2;
                    mfdin_canvas2_stride = mfdin_canvas0_stride / 2;
                }
                mfdin_canvas0_addr = input;
                mfdin_canvas1_addr = input + mfdin_canvas0_stride * mfdin_canvas_height;
                mfdin_canvas2_addr = input + mfdin_canvas0_stride * mfdin_canvas_height +
                        mfdin_canvas0_stride * mfdin_canvas_height / 4;

                //mfdin_canvas_bias = mfdin_canvas1_stride << 16;
            } else if (iformat == 5 /*&& oformat == 0*/) {    /*case1007, 444 plane -> 420*/
                mfdin_canvas1_stride = mfdin_canvas0_stride;
                mfdin_canvas2_stride = mfdin_canvas0_stride;
                mfdin_canvas0_addr = input;
                mfdin_canvas1_addr = input              + mfdin_canvas0_stride * mfdin_canvas_height;
                mfdin_canvas2_addr = mfdin_canvas1_addr + mfdin_canvas1_stride * mfdin_canvas_height;
                //mfdin_big_endian = true;
            } else {
                pr_err("config input or output format err!\n");
                return -1;
            }

            if (get_cpu_major_id() == AM_MESON_CPU_MAJOR_ID_T3) {
                if ((cmd->input_fmt == JPEGENC_FMT_RGB565)
                    || (cmd->input_fmt >= JPEGENC_MAX_FRAME_FMT))
                    return -1;

                if (cmd->output_fmt     == JPEGENC_FMT_YUV420) {
                    oformat = 0;
                } else if (cmd->output_fmt == JPEGENC_FMT_YUV422_SINGLE) {
                    oformat = 1;
                } else if (cmd->output_fmt == JPEGENC_FMT_YUV444_SINGLE) {
                    oformat = 2;
                }

                if ((cmd->input_fmt <= JPEGENC_FMT_YUV444_PLANE) ||
                    (cmd->input_fmt >= JPEGENC_FMT_YUV422_12BIT))
                    r2y_en = 0;
                else
                    r2y_en = 1;

                if (cmd->input_fmt >= JPEGENC_FMT_YUV422_12BIT) {
                    iformat = 7;
                    ifmt_extra =
                        cmd->input_fmt - JPEGENC_FMT_YUV422_12BIT;

    #ifdef CONFIG_AMLOGIC_MEDIA_CANVAS

                    if (cmd->input_fmt == JPEGENC_FMT_YUV422_12BIT)
                        canvas_w = picsize_x * 24 / 8;
                    else if (cmd->input_fmt == JPEGENC_FMT_YUV444_10BIT)
                        canvas_w = picsize_x * 32 / 8;
                    else
                        canvas_w = (picsize_x * 20 + 7) / 8;
                    canvas_w = ((canvas_w + 31) >> 5) << 5;
                    canvas_config_proxy(ENC_CANVAS_OFFSET,
                        input,
                        canvas_w, picsize_y,
                        CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    input = ENC_CANVAS_OFFSET;
                    input = input & 0xff;
    #endif
                } else if (cmd->input_fmt == JPEGENC_FMT_YUV422_SINGLE) {
                    iformat = 0;

    #ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                    canvas_w = picsize_x * 2;
                    canvas_w = ((canvas_w + 31) >> 5) << 5;
                    canvas_config_proxy(ENC_CANVAS_OFFSET,
                        input,
                        canvas_w, picsize_y,
                        CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    input = ENC_CANVAS_OFFSET;
    #endif
                } else if ((cmd->input_fmt == JPEGENC_FMT_YUV444_SINGLE)
                    || (cmd->input_fmt == JPEGENC_FMT_RGB888)) {
                    iformat = 1;
                    if (cmd->input_fmt == JPEGENC_FMT_RGB888)
                        r2y_en = 1;

    #ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                    canvas_w = picsize_x * 3;
                    canvas_w = ((canvas_w + 31) >> 5) << 5;
                    canvas_config_proxy(ENC_CANVAS_OFFSET,
                        input,
                        canvas_w, picsize_y,
                        CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    input = ENC_CANVAS_OFFSET;
    #endif
                } else if ((cmd->input_fmt == JPEGENC_FMT_NV21)
                    || (cmd->input_fmt == JPEGENC_FMT_NV12)) {
                    iformat = (cmd->input_fmt == JPEGENC_FMT_NV21) ? 2 : 3;
    #ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                    canvas_w = ((cmd->encoder_width + 31) >> 5) << 5;
                    canvas_config_proxy(ENC_CANVAS_OFFSET,
                        input,
                        canvas_w, picsize_y,
                        CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    canvas_config_proxy(ENC_CANVAS_OFFSET + 1,
                        input + canvas_w * picsize_y, canvas_w,
                        picsize_y / 2, CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    input = ((ENC_CANVAS_OFFSET + 1) << 8) |
                        ENC_CANVAS_OFFSET;
    #endif
                } else if (cmd->input_fmt == JPEGENC_FMT_YUV420) {
                    iformat = 4;

    #ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                    canvas_w = ((cmd->encoder_width + 63) >> 6) << 6;
                    canvas_config_proxy(ENC_CANVAS_OFFSET,
                        input,
                        canvas_w, picsize_y,
                        CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    canvas_config_proxy(ENC_CANVAS_OFFSET + 2,
                        input + canvas_w * picsize_y,
                        canvas_w / 2, picsize_y / 2,
                        CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    canvas_config_proxy(ENC_CANVAS_OFFSET + 2,
                        input + canvas_w * picsize_y * 5 / 4,
                        canvas_w / 2, picsize_y / 2,
                        CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    input = ((ENC_CANVAS_OFFSET + 2) << 16) |
                        ((ENC_CANVAS_OFFSET + 1) << 8) |
                        ENC_CANVAS_OFFSET;
    #endif
                } else if ((cmd->input_fmt == JPEGENC_FMT_YUV444_PLANE)
                    || (cmd->input_fmt == JPEGENC_FMT_RGB888_PLANE)) {
                    iformat = 5;
                    if (cmd->input_fmt == JPEGENC_FMT_RGB888_PLANE)
                        r2y_en = 1;

    #ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                    canvas_w = ((cmd->encoder_width + 31) >> 5) << 5;
                    canvas_config_proxy(ENC_CANVAS_OFFSET,
                        input,
                        canvas_w, picsize_y,
                        CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    canvas_config_proxy(ENC_CANVAS_OFFSET + 1,
                        input + canvas_w * picsize_y, canvas_w,
                        picsize_y, CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    canvas_config_proxy(ENC_CANVAS_OFFSET + 2,
                        input + canvas_w * picsize_y * 2,
                        canvas_w, picsize_y, CANVAS_ADDR_NOWRAP,
                        CANVAS_BLKMODE_LINEAR);
                    input = ((ENC_CANVAS_OFFSET + 2) << 16) |
                        ((ENC_CANVAS_OFFSET + 1) << 8) |
                        ENC_CANVAS_OFFSET;
    #endif
                } else if (cmd->input_fmt == JPEGENC_FMT_RGBA8888) {
                    iformat = 12;
                    r2y_en = 1;
                }
                ret = 0;
            }

        } else {
            if ((cmd->input_fmt == JPEGENC_FMT_RGB565)
                || (cmd->input_fmt >= JPEGENC_MAX_FRAME_FMT))
                return -1;

            if (cmd->output_fmt == JPEGENC_FMT_YUV422_SINGLE)
                oformat = 1;
            else
                oformat = 0;

            if ((cmd->input_fmt <= JPEGENC_FMT_YUV444_PLANE) ||
                (cmd->input_fmt >= JPEGENC_FMT_YUV422_12BIT))
                r2y_en = 0;
            else
                r2y_en = 1;

            if (cmd->input_fmt >= JPEGENC_FMT_YUV422_12BIT) {
                iformat = 7;
                ifmt_extra =
                    cmd->input_fmt - JPEGENC_FMT_YUV422_12BIT;

#ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                if (cmd->input_fmt == JPEGENC_FMT_YUV422_12BIT)
                    canvas_w = picsize_x * 24 / 8;
                else if (cmd->input_fmt == JPEGENC_FMT_YUV444_10BIT)
                    canvas_w = picsize_x * 32 / 8;
                else
                    canvas_w = (picsize_x * 20 + 7) / 8;
                canvas_w = ((canvas_w + 31) >> 5) << 5;
                canvas_config_proxy(ENC_CANVAS_OFFSET,
                    input,
                    canvas_w, picsize_y,
                    CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                input = ENC_CANVAS_OFFSET;
                input = input & 0xff;
#endif
            } else if (cmd->input_fmt == JPEGENC_FMT_YUV422_SINGLE) {
                iformat = 0;

#ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                canvas_w = picsize_x * 2;
                canvas_w = ((canvas_w + 31) >> 5) << 5;
                canvas_config_proxy(ENC_CANVAS_OFFSET,
                    input,
                    canvas_w, picsize_y,
                    CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                input = ENC_CANVAS_OFFSET;
#endif
            } else if ((cmd->input_fmt == JPEGENC_FMT_YUV444_SINGLE)
                || (cmd->input_fmt == JPEGENC_FMT_RGB888)) {
                iformat = 1;
                if (cmd->input_fmt == JPEGENC_FMT_RGB888)
                    r2y_en = 1;

#ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                canvas_w = picsize_x * 3;
                canvas_w = ((canvas_w + 31) >> 5) << 5;
                canvas_config_proxy(ENC_CANVAS_OFFSET,
                    input,
                    canvas_w, picsize_y,
                    CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                input = ENC_CANVAS_OFFSET;
#endif
            } else if ((cmd->input_fmt == JPEGENC_FMT_NV21)
                || (cmd->input_fmt == JPEGENC_FMT_NV12)) {
                iformat = (cmd->input_fmt == JPEGENC_FMT_NV21) ? 2 : 3;

#ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                canvas_w = ((cmd->encoder_width + 31) >> 5) << 5;
                canvas_config_proxy(ENC_CANVAS_OFFSET,
                    input,
                    canvas_w, picsize_y,
                    CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                canvas_config_proxy(ENC_CANVAS_OFFSET + 1,
                    input + canvas_w * picsize_y, canvas_w,
                    picsize_y / 2, CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                input = ((ENC_CANVAS_OFFSET + 1) << 8) |
                    ENC_CANVAS_OFFSET;
#endif
            } else if (cmd->input_fmt == JPEGENC_FMT_YUV420) {
                iformat = 4;

#ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                canvas_w = ((cmd->encoder_width + 63) >> 6) << 6;
                canvas_config_proxy(ENC_CANVAS_OFFSET,
                    input,
                    canvas_w, picsize_y,
                    CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                canvas_config_proxy(ENC_CANVAS_OFFSET + 2,
                    input + canvas_w * picsize_y,
                    canvas_w / 2, picsize_y / 2,
                    CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                canvas_config_proxy(ENC_CANVAS_OFFSET + 2,
                    input + canvas_w * picsize_y * 5 / 4,
                    canvas_w / 2, picsize_y / 2,
                    CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                input = ((ENC_CANVAS_OFFSET + 2) << 16) |
                    ((ENC_CANVAS_OFFSET + 1) << 8) |
                    ENC_CANVAS_OFFSET;
#endif
            } else if ((cmd->input_fmt == JPEGENC_FMT_YUV444_PLANE)
                || (cmd->input_fmt == JPEGENC_FMT_RGB888_PLANE)) {
                iformat = 5;
                if (cmd->input_fmt == JPEGENC_FMT_RGB888_PLANE)
                    r2y_en = 1;

#ifdef CONFIG_AMLOGIC_MEDIA_CANVAS
                canvas_w = ((cmd->encoder_width + 31) >> 5) << 5;
                canvas_config_proxy(ENC_CANVAS_OFFSET,
                    input,
                    canvas_w, picsize_y,
                    CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                canvas_config_proxy(ENC_CANVAS_OFFSET + 1,
                    input + canvas_w * picsize_y, canvas_w,
                    picsize_y, CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                canvas_config_proxy(ENC_CANVAS_OFFSET + 2,
                    input + canvas_w * picsize_y * 2,
                    canvas_w, picsize_y, CANVAS_ADDR_NOWRAP,
                    CANVAS_BLKMODE_LINEAR);
                input = ((ENC_CANVAS_OFFSET + 2) << 16) |
                    ((ENC_CANVAS_OFFSET + 1) << 8) |
                    ENC_CANVAS_OFFSET;
#endif
            } else if (cmd->input_fmt == JPEGENC_FMT_RGBA8888) {
                iformat = 12;
                r2y_en = 1;
            }
        }
        ret = 0;
    } else if (cmd->type == JPEGENC_CANVAS_BUFF) {
        r2y_en = 0;
        if (cmd->input_fmt == JPEGENC_FMT_YUV422_SINGLE) {
            iformat = 0;
            input = input & 0xff;
        } else if (cmd->input_fmt == JPEGENC_FMT_YUV444_SINGLE) {
            iformat = 1;
            input = input & 0xff;
        } else if ((cmd->input_fmt == JPEGENC_FMT_NV21)
            || (cmd->input_fmt == JPEGENC_FMT_NV12)) {
            iformat = (cmd->input_fmt == JPEGENC_FMT_NV21) ? 2 : 3;
            input = input & 0xffff;
        } else if (cmd->input_fmt == JPEGENC_FMT_YUV420) {
            iformat = 4;
            input = input & 0xffffff;
        } else if ((cmd->input_fmt == JPEGENC_FMT_YUV444_PLANE)
            || (cmd->input_fmt == JPEGENC_FMT_RGB888_PLANE)) {
            if (cmd->input_fmt == JPEGENC_FMT_RGB888_PLANE)
                r2y_en = 1;
            iformat = 5;
            input = input & 0xffffff;
        } else if ((cmd->input_fmt == JPEGENC_FMT_YUV422_12BIT)
            || (cmd->input_fmt == JPEGENC_FMT_YUV444_10BIT)
            || (cmd->input_fmt == JPEGENC_FMT_YUV422_10BIT)) {
            iformat = 7;
            ifmt_extra = cmd->input_fmt - JPEGENC_FMT_YUV422_12BIT;
            input = input & 0xff;
        } else
            ret = -1;
    }

    if (ret == 0)
        mfdin_basic_jpeg(input, iformat, oformat,
            picsize_x, picsize_y, r2y_en, ifmt_extra,
            mfdin_canvas0_stride,
            mfdin_canvas1_stride,
            mfdin_canvas2_stride,
            mfdin_canvas0_blkmode,
            mfdin_canvas1_blkmode,
            mfdin_canvas2_blkmode,
            mfdin_canvas0_addr,
            mfdin_canvas1_addr,
            mfdin_canvas2_addr,
            mfdin_canvas_bias,
            mfdin_big_endian);
    return ret;
}

static void jpegenc_isr_tasklet(ulong data)
{
    struct jpegenc_manager_s *manager = (struct jpegenc_manager_s *)data;

    jenc_pr(LOG_INFO, "encoder is done %d\n", manager->encode_hw_status);

    if ((manager->encode_hw_status == JPEGENC_ENCODER_DONE)
        && (manager->process_irq)) {
        manager->wq.hw_status = manager->encode_hw_status;
        manager->wq.output_size = READ_HREG(HCODEC_VLC_TOTAL_BYTES);
        jenc_pr(LOG_INFO, "encoder size %d\n", manager->wq.output_size);
        atomic_inc(&manager->wq.ready);
        wake_up_interruptible(&manager->wq.complete);
    }
}

static irqreturn_t jpegenc_isr(s32 irq_number, void *para)
{
    struct jpegenc_manager_s *manager = (struct jpegenc_manager_s *)para;
    jenc_pr(LOG_ALL, "jpegenc intr is fired\n");

    if (manager->irq_requested == false)
        return IRQ_NONE;

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1) {
        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_T7)
            WRITE_HREG(HCODEC_ASSIST_MBOX2_CLR_REG, 1);
        else
            WRITE_HREG(HCODEC_ASSIST_MBOX0_CLR_REG, 1);
    } else
        WRITE_HREG(HCODEC_ASSIST_MBOX2_CLR_REG, 1);

    manager->encode_hw_status  = READ_HREG(JPEGENC_ENCODER_STATUS);

    if (manager->encode_hw_status == JPEGENC_ENCODER_DONE) {
        jpegenc_time_count_end(&time_cnt);
        manager->process_irq = true;
        tasklet_schedule(&manager->tasklet);
    }

    return IRQ_HANDLED;
}

static void jpegenc_start(void)
{
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
    WRITE_VREG(DOS_SW_RESET1, (1 << 12) | (1 << 11));
    WRITE_VREG(DOS_SW_RESET1, 0);
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
    WRITE_HREG(HCODEC_MPSR, 0x0001);
}

static void _jpegenc_stop(void)
{
    ulong timeout = jiffies + HZ;

    WRITE_HREG(HCODEC_MPSR, 0);
    WRITE_HREG(HCODEC_CPSR, 0);

    while (READ_HREG(HCODEC_IMEM_DMA_CTRL) & 0x8000) {
        if (time_after(jiffies, timeout))
            break;
    }
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXBB)
        WRITE_VREG(DOS_SW_RESET1,
               (1 << 12) | (1 << 11) |
               (1 << 2) | (1 << 6) |
               (1 << 7) | (1 << 8) |
               (1 << 14) | (1 << 16) |
               (1 << 17));
    else
        WRITE_VREG(DOS_SW_RESET1,
               (1 << 12) | (1 << 11) |
               (1 << 2) | (1 << 6) |
               (1 << 7) | (1 << 8) |
               (1 << 16) | (1 << 17));

    WRITE_VREG(DOS_SW_RESET1, 0);

    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
}

static void dump_mem(u8 *addr) {
    int i;
    u8 *offset = addr;

    for (i=0;i<dumpmem_line;i++) {
        offset += i * 8;
        pr_err("%#x\t%#x\t%#x\t%#x\t%#x\t%#x\t%#x\t%#x\n",
            *(offset+0), *(offset+1), *(offset+2), *(offset+3),
            *(offset+4), *(offset+5), *(offset+6), *(offset+7));
    }
}

static void __iomem *mc_addr;
static u32 mc_addr_map;
#define MC_SIZE (4096 * 4)
s32 jpegenc_loadmc(const char *p)
{
    ulong timeout;
    s32 ret = 0;
    //int i=0;

    /* use static mempry*/
    if (mc_addr == NULL) {
        mc_addr = kmalloc(MC_SIZE, GFP_KERNEL);

        if (!mc_addr) {
            jenc_pr(LOG_ERROR, "jpegenc loadmc iomap mc addr error.\n");
            return -ENOMEM;
        }
        memset(mc_addr, 0, MC_SIZE);
    }

    //ret = get_data_from_name("c1_jpeg_enc", (u8 *)mc_addr);
    ret = get_firmware_data(VIDEO_ENC_JPEG, (u8 *)mc_addr);

    dump_mem(mc_addr);

    if (ret < 0)
        jenc_pr(LOG_ERROR, "jpegenc microcode fail ret=%d, name: %s.\n", ret, p);

    mc_addr_map = dma_map_single(&gJpegenc.this_pdev->dev, mc_addr, MC_SIZE, DMA_TO_DEVICE);

    WRITE_HREG(HCODEC_MPSR, 0);
    WRITE_HREG(HCODEC_CPSR, 0);

    /* Read CBUS register for timing */
    //timeout = READ_HREG(HCODEC_MPSR);
    //timeout = READ_HREG(HCODEC_MPSR);
    timeout = jiffies + HZ;
    WRITE_HREG(HCODEC_IMEM_DMA_ADR, mc_addr_map);
    WRITE_HREG(HCODEC_IMEM_DMA_COUNT, 0x1000);

    if (get_cpu_major_id() == AM_MESON_CPU_MAJOR_ID_T7)
        WRITE_HREG(HCODEC_IMEM_DMA_CTRL, (0x8000 | (0xf << 16))); // ucode test c is 0x8000 | (0xf << 16)
    else if (get_cpu_major_id() == AM_MESON_CPU_MAJOR_ID_T3) {
        pr_err("t3 HCODEC_IMEM_DMA_CTRL (0x8000 | (0 & 0xffff))\n");
        WRITE_HREG(HCODEC_IMEM_DMA_CTRL, (0x8000 | (0 & 0xffff))); // Endian : 4'b1000);
    } else
        WRITE_HREG(HCODEC_IMEM_DMA_CTRL, (0x8000 | (0 & 0xffff))); // Endian : 4'b1000);

    while (READ_HREG(HCODEC_IMEM_DMA_CTRL) & 0x8000) {
        if (time_before(jiffies, timeout)) {
            schedule();
        } else {
            jenc_pr(LOG_ERROR, "hcodec load mc error\n");
            ret = -EBUSY;
            break;
        }
    }

    dma_unmap_single(&gJpegenc.this_pdev->dev, mc_addr_map, MC_SIZE, DMA_TO_DEVICE);
    return ret;
}

static s32 jpegenc_poweron_ex(u32 clock)
{
    u32 frq;

    if (clock == 1)
        frq = 200;
    else if (clock == 3)
        frq = 300;
    else
        frq = 400;

    jpeg_enc_clk_enable(&g_jpeg_enc_clks, frq);

    /* Powerup HCODEC memories */
    WRITE_VREG(DOS_MEM_PD_HCODEC, 0x0);

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_T7) {
        pr_err("powering on hcodec\n");
        vdec_poweron(VDEC_HCODEC);
        pr_err("hcodec power status after poweron:%d\n", vdec_on(VDEC_HCODEC));
    } else {
        pwr_ctrl_psci_smc(PDID_T7_DOS_HCODEC, true);
    }

    /*
     * [21] hcodec clk_en for henc qdct
     * [20] hcodec clk_en for henc vlc
     * [19] hcodec clk_en for assist and cbus
     * [18] hcodec clk_en for ddr
     * [17] hcodec clk_en for vcpu
     * [16] hcodec clk_en for hdec assist
     * [15] hcodec clk_en for hdec dblk
     * [14] reserved
     * [13] hcodec clk_en for hdec mc
     * [12] hcodec clk_en for hdec pic_dc
     */
    WRITE_VREG_BITS(DOS_GCLK_EN0, 0x7fff, 12, 15);

    return 0;
}

static s32 jpegenc_poweroff_ex(void)
{
    WRITE_VREG_BITS(DOS_GCLK_EN0, 0, 12, 15);

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_T7) {
        pr_err("powering off hcodec for t7\n");
        vdec_poweroff(VDEC_HCODEC);
        pr_err("hcodec power status after poweroff:%d\n", vdec_on(VDEC_HCODEC));
    } else
        pwr_ctrl_psci_smc(PDID_T7_DOS_HCODEC, false);

    /* power off HCODEC memories */
    WRITE_VREG(DOS_MEM_PD_HCODEC, 0xffffffffUL);

    jpeg_enc_clk_disable(&g_jpeg_enc_clks);

    return 0;
}

#if 0
bool jpegenc_on(void)
{
    bool hcodec_on;
    ulong flags;

    spin_lock_irqsave(&lock, flags);

    hcodec_on = vdec_on(VDEC_HCODEC);
    hcodec_on &= (gJpegenc.opened > 0);

    spin_unlock_irqrestore(&lock, flags);
    return hcodec_on;
}
#endif

static s32 jpegenc_poweron(u32 clock)
{
    //ulong flags;
    u32 data32;

    //spin_lock_irqsave(&lock, flags);

    if (get_cpu_major_id() < AM_MESON_CPU_MAJOR_ID_C1) {
        data32 = 0;
        amports_switch_gate("vdec", 1);

        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_M8) {
            WRITE_AOREG(AO_RTI_PWR_CNTL_REG0,
                (READ_AOREG(AO_RTI_PWR_CNTL_REG0) & (~0x18)));
            udelay(10);
            /* Powerup HCODEC */
            /* [1:0] HCODEC */
            WRITE_AOREG(AO_RTI_GEN_PWR_SLEEP0,
                (READ_AOREG(AO_RTI_GEN_PWR_SLEEP0) & (~0x3)));
            udelay(10);
        }

        WRITE_VREG(DOS_SW_RESET1, 0xffffffff);
        WRITE_VREG(DOS_SW_RESET1, 0);

        /* Enable Dos internal clock gating */
        jpegenc_clock_enable(clock);

        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_M8) {
            /* Powerup HCODEC memories */
            WRITE_VREG(DOS_MEM_PD_HCODEC, 0x0);

            /* Remove HCODEC ISO */
            WRITE_AOREG(AO_RTI_GEN_PWR_ISO0,
                (READ_AOREG(AO_RTI_GEN_PWR_ISO0) & (~0x30)));
            udelay(10);
        }
        /* Disable auto-clock gate */
        WRITE_VREG(DOS_GEN_CTRL0, (READ_VREG(DOS_GEN_CTRL0) | 0x1));
        WRITE_VREG(DOS_GEN_CTRL0, (READ_VREG(DOS_GEN_CTRL0) & 0xFFFFFFFE));
    } else {
        jpegenc_poweron_ex(clock);
    }
    //spin_unlock_irqrestore(&lock, flags);

    mdelay(10);
    return 0;
}

static s32 jpegenc_poweroff(void)
{
    //ulong flags;
    //spin_lock_irqsave(&lock, flags);

    if (get_cpu_major_id() < AM_MESON_CPU_MAJOR_ID_C1) {
        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_M8) {
            /* enable HCODEC isolation */
            WRITE_AOREG(AO_RTI_GEN_PWR_ISO0,
                READ_AOREG(AO_RTI_GEN_PWR_ISO0) | 0x30);
            /* power off HCODEC memories */
            WRITE_VREG(DOS_MEM_PD_HCODEC, 0xffffffffUL);
        }
        /* disable HCODEC clock */
        jpegenc_clock_disable();

        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_M8) {
            /* HCODEC power off */
            WRITE_AOREG(AO_RTI_GEN_PWR_SLEEP0,
                READ_AOREG(AO_RTI_GEN_PWR_SLEEP0) | 0x3);
        }

        /* release DOS clk81 clock gating */
        amports_switch_gate("vdec", 0);
    } else {
        jpegenc_poweroff_ex();
    }
    //spin_unlock_irqrestore(&lock, flags);

    return 0;
}

void jpegenc_reset(void)
{
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXBB)
        WRITE_VREG(DOS_SW_RESET1,
               (1 << 2) | (1 << 6) |
               (1 << 7) | (1 << 8) |
               (1 << 14) | (1 << 16) |
               (1 << 17));
    else
        WRITE_VREG(DOS_SW_RESET1,
               (1 << 2) | (1 << 6) | (1 << 7) |
               (1 << 8) | (1 << 16) | (1 << 17));
    WRITE_VREG(DOS_SW_RESET1, 0);
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
    READ_VREG(DOS_SW_RESET1);
}

static s32 jpegenc_init(void)
{
    jpegenc_poweron(clock_level);

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_MG9TV)
        WRITE_HREG(HCODEC_ASSIST_MMC_CTRL1, 0x32);
    else
        WRITE_HREG(HCODEC_ASSIST_MMC_CTRL1, 0x2);

    jenc_pr(LOG_ALL, "start to load microcode\n");

    if (!legacy_load && (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_T7 )) {
        char *buf = vmalloc(0x1000 * 16);
        int ret = -1;
        pr_err("load ucode\n");
        if (get_firmware_data(VIDEO_ENC_JPEG, buf) < 0) {
            //amvdec_disable();
            pr_err("get firmware for jpeg enc fail!\n");
            vfree(buf);
            return -1;
        }
        WRITE_HREG(HCODEC_MPSR, 0);
        WRITE_HREG(HCODEC_CPSR, 0);
        ret = amvdec_loadmc_ex(VFORMAT_JPEG_ENC, NULL, buf);

        if (ret < 0) {
            //amvdec_disable();
            vfree(buf);
            pr_err("jpegenc: the %s fw loading failed, err: %x\n",
                tee_enabled() ? "TEE" : "local", ret);
            return -EBUSY;
        }
        vfree(buf);
    } else {
        if (jpegenc_loadmc(jpegenc_ucode[0]) < 0)
            return -EBUSY;
    }

    jenc_pr(LOG_ALL, "jpegenc load microcode success.\n");
    gJpegenc.process_irq = false;

    if (request_irq(gJpegenc.irq_num, jpegenc_isr, IRQF_SHARED,
        "jpegenc-irq", (void *)&gJpegenc) == 0)
        gJpegenc.irq_requested = true;
    else
        gJpegenc.irq_requested = false;

    WRITE_HREG(JPEGENC_ENCODER_STATUS, JPEGENC_ENCODER_IDLE);
    gJpegenc.inited = true;
    return 0;
}

static s32 convert_cmd(struct jpegenc_wq_s *wq, u32 *cmd_info)
{
    if (!wq) {
        jenc_pr(LOG_ERROR, "jpegenc convert_cmd error\n");
        return -1;
    }

    memset(&wq->cmd, 0, sizeof(struct jpegenc_request_s));
    wq->cmd.type = cmd_info[0];
    wq->cmd.input_fmt = cmd_info[1];
    wq->cmd.output_fmt = cmd_info[2];
    wq->cmd.encoder_width = cmd_info[3];
    wq->cmd.encoder_height = cmd_info[4];
    wq->cmd.framesize = cmd_info[5];
    wq->cmd.src = cmd_info[6];
    wq->cmd.jpeg_quality = cmd_info[7];
    wq->cmd.QuantTable_id = cmd_info[8];
    wq->cmd.flush_flag = cmd_info[9];
    wq->cmd.block_mode = cmd_info[10];

    wq->cmd.y_stride = cmd_info[11];
    wq->cmd.u_stride = cmd_info[12];
    wq->cmd.v_stride = cmd_info[13];
    wq->cmd.h_stride = cmd_info[14];
    jenc_pr(LOG_DEBUG, "convert_cmd: ystride:%d, h_stride:%d\n",
            cmd_info[11], cmd_info[14]);

    if (is_oversize(wq->cmd.encoder_width,
        wq->cmd.encoder_height,
        wq->max_width * wq->max_height)) {
        jenc_pr(LOG_ERROR,
            "set encode size %dx%d is larger than supported (%dx%d).\n",
            wq->cmd.encoder_width,
            wq->cmd.encoder_height,
            wq->max_width,
            wq->max_height);
        return -1;
    }

    wq->cmd.jpeg_quality = jpeg_quality_scaling(wq->cmd.jpeg_quality);
    if (wq->cmd.QuantTable_id < 4) {
        jenc_pr(LOG_INFO,
            "JPEGENC_SEL_QUANT_TABLE : %d.\n",
            wq->cmd.QuantTable_id);
    } else {
        wq->cmd.QuantTable_id = 0;
        jenc_pr(LOG_ERROR,
            "JPEGENC_SEL_QUANT_TABLE invaild. target value: %d.\n",
            cmd_info[8]);
    }
    jenc_pr(LOG_INFO,
        "target quality : %d,  jpeg_quality value: %d.\n",
        cmd_info[7], wq->cmd.jpeg_quality);
    return 0;
}

static void jpegenc_start_cmd(struct jpegenc_wq_s *wq)
{
    gJpegenc.process_irq = false;
    gJpegenc.encode_hw_status = JPEGENC_ENCODER_IDLE;

    jpegenc_reset();

    set_jpeg_input_format(wq, &wq->cmd);

    init_jpeg_encoder(wq);

    jpegenc_init_output_buffer(wq);

    /* clear mailbox interrupt */
    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1) {
        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_T7)
            WRITE_HREG(HCODEC_ASSIST_MBOX2_CLR_REG, 1);
        else
            WRITE_HREG(HCODEC_ASSIST_MBOX0_CLR_REG, 1);
    } else
        WRITE_HREG(HCODEC_ASSIST_MBOX2_CLR_REG, 1);

    /* enable mailbox interrupt */
    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1) {
        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_T7)
            WRITE_HREG(HCODEC_ASSIST_MBOX2_MASK, 0xffffffff);
        else
            WRITE_HREG(HCODEC_ASSIST_MBOX0_MASK, 0xffffffff);
    } else
        WRITE_HREG(HCODEC_ASSIST_MBOX2_MASK, 1);

    gJpegenc.encode_hw_status = JPEGENC_ENCODER_IDLE;
    WRITE_HREG(JPEGENC_ENCODER_STATUS, JPEGENC_ENCODER_IDLE);
    gJpegenc.process_irq = false;

    time_cnt = jpegenc_time_count_start();

    jpegenc_start();
    jenc_pr(LOG_INFO, "jpegenc_start\n");
}

static void jpegenc_stop(void)
{
    if ((gJpegenc.irq_num >= 0) &&
        (gJpegenc.irq_requested == true)) {
        gJpegenc.irq_requested = false;
        free_irq(gJpegenc.irq_num, &gJpegenc);
    }
    _jpegenc_stop();
    jpegenc_poweroff();
    jenc_pr(LOG_INFO, "jpegenc_stop\n");
}

static void dma_flush(u32 buf_start, u32 buf_size)
{
    dma_sync_single_for_device(&gJpegenc.this_pdev->dev,
        buf_start, buf_size, DMA_TO_DEVICE);
}

static void cache_flush(u32 buf_start, u32 buf_size)
{
    dma_sync_single_for_cpu(&gJpegenc.this_pdev->dev,
        buf_start, buf_size, DMA_FROM_DEVICE);
}

static s32 jpegenc_open(struct inode *inode, struct file *file)
{
    struct jpegenc_wq_s *wq;
    s32 r;
    pr_err("jpegenc open, filp=%lu\n", (unsigned long)file);
#ifdef CONFIG_AM_ENCODER
    if (amvenc_avc_on() == true) {
        jenc_pr(LOG_ERROR, "hcodec in use for AVC Encode now.\n");
        return -EBUSY;
    }
#endif
    file->private_data = NULL;

    spin_lock(&gJpegenc.sem_lock);
    if (gJpegenc.opened > 0) {
        spin_unlock(&gJpegenc.sem_lock);
        jenc_pr(LOG_ERROR, "jpegenc open busy.\n");
        return -EBUSY;
    }
    wq = &gJpegenc.wq;
    wq->buf_start = gJpegenc.mem.buf_start;
    wq->buf_size = gJpegenc.mem.buf_size;
    gJpegenc.opened++;
    spin_unlock(&gJpegenc.sem_lock);

#ifdef CONFIG_CMA
    if (gJpegenc.use_reserve == false) {
        if (gJpegenc.use_cma) {
            struct page *cma_pages;
            cma_pages = dma_alloc_from_contiguous(&gJpegenc.this_pdev->dev,
                                  gJpegenc.mem.buf_size >> PAGE_SHIFT, 0, true);
            if (cma_pages) {
                wq->buf_start = page_to_phys(cma_pages);
                wq->buf_size = gJpegenc.mem.buf_size;
            } else {
                jenc_pr(LOG_ERROR, "jpegenc - cma allocation failed\n");
            }
        }

        if (!wq->buf_start) {
            gJpegenc.use_cma = false;
            wq->buf_start = codec_mm_alloc_for_dma(DRIVER_NAME,
                gJpegenc.mem.buf_size >> PAGE_SHIFT, 0, 0);
            if (wq->buf_start) {
                wq->buf_size = gJpegenc.mem.buf_size;
            } else {
                jenc_pr(LOG_ERROR,
                    "jpegenc - codec_mm allocation failed\n");
                spin_lock(&gJpegenc.sem_lock);
                gJpegenc.opened--;
                spin_unlock(&gJpegenc.sem_lock);
                return -ENOMEM;
            }
        }
    }
#endif

    jenc_pr(LOG_DEBUG,
        "jpegenc - allocated from %s: start:0x%x, %d MB.\n",
        gJpegenc.use_reserve ? "reserved" :
            gJpegenc.use_cma ? "cma" : "codec_mm",
        wq->buf_start, gJpegenc.mem.buf_size / SZ_1M);

    spin_lock(&gJpegenc.sem_lock);
    init_waitqueue_head(&wq->complete);
    atomic_set(&wq->ready, 0);
    wq->AssitstreamStartVirtAddr = NULL;
    memset(gQuantTable, 0, sizeof(gQuantTable));
    wq->cmd.QuantTable_id = 0;
    wq->cmd.jpeg_quality = 90;
    wq->max_width = gJpegenc.mem.bufspec->max_width;
    wq->max_height = gJpegenc.mem.bufspec->max_height;
    wq->headbytes = 0;
    file->private_data = (void *)wq;
#ifdef EXTEAN_QUANT_TABLE
    gExternalQuantTablePtr = NULL;
    external_quant_table_available = false;
#endif
    spin_unlock(&gJpegenc.sem_lock);
    r = 0;

    return r;
}

static s32 jpegenc_release(struct inode *inode, struct file *file)
{
    struct jpegenc_wq_s *wq = (struct jpegenc_wq_s *)file->private_data;

    if (wq != &gJpegenc.wq) {
        jenc_pr(LOG_ERROR, "jpegenc release error\n");
        return -1;
    }
    if (gJpegenc.inited) {
        jpegenc_stop();
        gJpegenc.inited = false;
    }
    if (wq->dma_input != NULL) {
        enc_dma_buf_unmap(wq->dma_input);
        kfree(wq->dma_input);
        wq->dma_input = NULL;
    }
    memset(gQuantTable, 0, sizeof(gQuantTable));

    if (wq->AssitstreamStartVirtAddr)
        wq->AssitstreamStartVirtAddr = NULL;

#ifdef CONFIG_CMA
    if (wq->buf_start) {
        if (gJpegenc.use_cma) {
            struct page *cma_pages;
            cma_pages = phys_to_page(wq->buf_start);
            if (!dma_release_from_contiguous(&gJpegenc.this_pdev->dev, cma_pages,
                             wq->buf_size >> PAGE_SHIFT)) {
                jenc_pr(LOG_ERROR, "[%s] failed to release cma buffer\n", __FUNCTION__);
            }
        } else {
            codec_mm_free_for_dma(DRIVER_NAME, wq->buf_start);
        }
    }
#endif
    wq->buf_start = 0;
    wq->buf_size = 0;
#ifdef EXTEAN_QUANT_TABLE
    kfree(gExternalQuantTablePtr);
    gExternalQuantTablePtr = NULL;
    external_quant_table_available = false;
#endif
    spin_lock(&gJpegenc.sem_lock);
    if (gJpegenc.opened > 0)
        gJpegenc.opened--;
    spin_unlock(&gJpegenc.sem_lock);
    jenc_pr(LOG_DEBUG, "jpegenc release\n");
    return 0;
}

static void jpegenc_reconfig_input(struct jpegenc_wq_s *wq, u32 new_addr, u32 new_size) {
    wq->InputBuffStart = new_addr;
    wq->InputBuffEnd = wq->InputBuffStart + new_size - 1;
}

static void jpegenc_restore_input(struct jpegenc_wq_s *wq) {
    wq->InputBuffStart = wq->buf_start + gJpegenc.mem.bufspec->input.buf_start;
    wq->InputBuffEnd = wq->InputBuffStart + gJpegenc.mem.bufspec->input.buf_size - 1;
}
static long jpegenc_ioctl(struct file *file, u32 cmd, ulong arg)
{
    long r = 0;
    struct jpegenc_wq_s *wq = (struct jpegenc_wq_s *)file->private_data;
#define MAX_ADDR_INFO_SIZE 30
    u32 addr_info[MAX_ADDR_INFO_SIZE + 4];
    int shared_fd = -1;
    //struct jpegenc_frame_params *frm_params;

    struct platform_device *pdev;
    unsigned long paddr = 0;

    switch (cmd) {
    case JPEGENC_IOC_QUERY_DMA_SUPPORT:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_QUERY_DMA_SUPPORT\n");
        jenc_pr(LOG_INFO, "use_dma_io=%u\n", use_dma_io);
        put_user(use_dma_io, (u32 *)arg);
        break;
    case JPEGENC_IOC_CONFIG_DMA_INPUT:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_CONFIG_DMA_INPUT\n");
        if (copy_from_user(&shared_fd, (void *)arg, sizeof(s32))) {
            jenc_pr(LOG_ERROR,
                "jpegenc JPEGENC_IOC_CONFIG_DMA_INPUT error.\n");
            return -1;
        }

        jenc_pr(LOG_INFO, "JPEGENC_IOC_CONFIG_DMA_INPUT, shared_fd:%d\n",
            shared_fd);

        if (wq->dma_input != NULL) {
            jenc_pr(LOG_INFO, "[%d] release old stale dma buffer\n", __LINE__);
            enc_dma_buf_unmap(wq->dma_input);
            wq->dma_input->fd = -1;
        }

        if (wq->dma_input == NULL)
            wq->dma_input = kmalloc(sizeof(struct enc_dma_cfg), GFP_KERNEL);

        if (wq->dma_input != NULL) {
            wq->dma_input->dir = DMA_TO_DEVICE;
            wq->dma_input->fd = shared_fd;
            pdev = gJpegenc.this_pdev;
            wq->dma_input->dev = &(pdev->dev);

            r = enc_dma_buf_get_phys(wq->dma_input, &paddr);

            if (r < 0) {
                jenc_pr(LOG_ERROR,
                    "import fd %d failed\n",
                    wq->dma_input->fd);
                wq->dma_input->paddr = NULL;
                wq->dma_input->vaddr = NULL;
                enc_dma_buf_unmap(wq->dma_input);
                kfree(wq->dma_input);
                return -1;
            }

            wq->dma_input->paddr = (void *)paddr;
            jenc_pr(LOG_INFO, "paddr %p\n",
                    wq->dma_input->paddr);
        } else {
            jenc_pr(LOG_ERROR, "kmalloc struct enc_dma_cfg failed\n");
            return -1;
        }

        jpegenc_reconfig_input(wq, paddr, wq->dma_input->size);
        break;
    case JPEGENC_IOC_RELEASE_DMA_INPUT:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_RELEASE_DMA_INPUT\n");
        if (wq->dma_input != NULL) {
            jenc_pr(LOG_INFO, "[%d] release dma buffer\n", __LINE__);
            enc_dma_buf_unmap(wq->dma_input);
            wq->dma_input->fd = -1;
            // restore to original input buffer config if dma buffer is revoked
            jpegenc_restore_input(wq);
        }
        break;
    case JPEGENC_IOC_NEW_CMD:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_NEW_CMD\n");
        if (copy_from_user(addr_info, (void *)arg,
            MAX_ADDR_INFO_SIZE * sizeof(u32))) {
            jenc_pr(LOG_ERROR,
                "jpegenc get new cmd error.\n");
            return -1;
        }
        if (!convert_cmd(wq, addr_info))
            jpegenc_start_cmd(wq);
        break;
    case JPEGENC_IOC_NEW_CMD2:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_NEW_CMD2\n");
        if (copy_from_user(&(wq->cmd), (void *)arg, (unsigned long) sizeof(struct jpegenc_request_s))) {
            jenc_pr(LOG_ERROR,
                "jpegenc get new cmd2 error.\n");
            return -1;
        }

        dump_requst(&(wq->cmd));

        if (is_oversize(wq->cmd.encoder_width,
            wq->cmd.encoder_height,
            wq->max_width * wq->max_height)) {
            jenc_pr(LOG_ERROR,
                "set encode size %dx%d is larger than supported (%dx%d).\n",
                wq->cmd.encoder_width,
                wq->cmd.encoder_height,
                wq->max_width,
                wq->max_height);
            return -1;
        }

        wq->cmd.jpeg_quality = jpeg_quality_scaling(wq->cmd.jpeg_quality);

        if (wq->cmd.QuantTable_id < 4) {
            jenc_pr(LOG_INFO, "JPEGENC_SEL_QUANT_TABLE: %d\n", wq->cmd.QuantTable_id);
        } else {
            wq->cmd.QuantTable_id = 0;
            jenc_pr(LOG_ERROR, "JPEGENC_SEL_QUANT_TABLE invaild, use 0 instead\n");
        }

        jenc_pr(LOG_INFO, "scaled jpeg_quality: %d\n", wq->cmd.jpeg_quality);

        //if (!convert_cmd(wq, addr_info))
        jpegenc_start_cmd(wq);

        break;
    case JPEGENC_IOC_GET_STAGE:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_GET_STAGE\n");
        put_user(wq->hw_status, (u32 *)arg);
        break;
    case JPEGENC_IOC_GET_OUTPUT_SIZE:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_GET_OUTPUT_SIZE\n");
        cache_flush(wq->BitstreamStart, wq->output_size);
        addr_info[0] = wq->headbytes;
        addr_info[1] = wq->output_size;
        r = copy_to_user((u32 *)arg, addr_info , 2 * sizeof(u32));
        break;
    case JPEGENC_IOC_CONFIG_INIT:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_CONFIG_INIT\n");
        jpegenc_init();
        jpegenc_buffspec_init(wq);
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_CONFIG_INIT end\n");
        break;
    case JPEGENC_IOC_GET_BUFFINFO:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_GET_BUFFINFO\n");
        addr_info[0] = gJpegenc.mem.buf_size;
        addr_info[1] = gJpegenc.mem.bufspec->input.buf_start;
        addr_info[2] = gJpegenc.mem.bufspec->input.buf_size;
        addr_info[3] = gJpegenc.mem.bufspec->assit.buf_start;
        addr_info[4] = gJpegenc.mem.bufspec->assit.buf_size;
        addr_info[5] = gJpegenc.mem.bufspec->bitstream.buf_start;
        addr_info[6] = gJpegenc.mem.bufspec->bitstream.buf_size;
        r = copy_to_user((u32 *)arg, addr_info , 7 * sizeof(u32));
        break;
    case JPEGENC_IOC_GET_DEVINFO:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_GET_DEVINFO\n");
        if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXL) {
            /* GXL send same id of GXTVBB to upper*/
            r = copy_to_user((s8 *)arg, JPEGENC_DEVINFO_GXTVBB,
                strlen(JPEGENC_DEVINFO_GXTVBB));
        } else if (get_cpu_major_id() == AM_MESON_CPU_MAJOR_ID_GXTVBB) {
            r = copy_to_user((s8 *)arg, JPEGENC_DEVINFO_GXTVBB,
                strlen(JPEGENC_DEVINFO_GXTVBB));
        } else if (get_cpu_major_id() == AM_MESON_CPU_MAJOR_ID_GXBB) {
            r = copy_to_user((s8 *)arg, JPEGENC_DEVINFO_GXBB,
                strlen(JPEGENC_DEVINFO_GXBB));
        } else if (get_cpu_major_id() == AM_MESON_CPU_MAJOR_ID_MG9TV) {
            r = copy_to_user((s8 *)arg, JPEGENC_DEVINFO_G9,
                strlen(JPEGENC_DEVINFO_G9));
        } else {
            r = copy_to_user((s8 *)arg, JPEGENC_DEVINFO_M8,
                strlen(JPEGENC_DEVINFO_M8));
        }
        break;
    case JPEGENC_IOC_SET_EXT_QUANT_TABLE:
        jenc_pr(LOG_DEBUG, "ioctl JPEGENC_IOC_SET_EXT_QUANT_TABLE\n");
#ifdef EXTEAN_QUANT_TABLE
        if (arg == 0) {
            kfree(gExternalQuantTablePtr);
            gExternalQuantTablePtr = NULL;
            external_quant_table_available = false;
        } else {
            void __user *argp = (void __user *)arg;
            gExternalQuantTablePtr =
                kmalloc(sizeof(u16) * DCTSIZE2 * 2,
                GFP_KERNEL);
            if (gExternalQuantTablePtr) {
                if (copy_from_user
                    (gExternalQuantTablePtr, argp,
                    sizeof(u16) * DCTSIZE2 * 2)) {
                    r = -1;
                    break;
                }
                external_quant_table_available = true;
                r = 0;
            } else {
                jenc_pr(LOG_ERROR,
                    "gExternalQuantTablePtr malloc fail\n");
                r = -1;
            }
        }
#else
        r = 0;
#endif
        break;
    default:
        jenc_pr(LOG_DEBUG, "ioctl BAD cmd\n");
        r = -1;
        break;
    }
    return r;
}

#ifdef CONFIG_COMPAT
static long jpegenc_compat_ioctl(struct file *filp,
    unsigned int cmd, unsigned long args)
{
    unsigned long ret;

    args = (unsigned long)compat_ptr(args);
    ret = jpegenc_ioctl(filp, cmd, args);
    return ret;
}
#endif

static s32 jpegenc_mmap(struct file *filp, struct vm_area_struct *vma)
{
    struct jpegenc_wq_s *wq = (struct jpegenc_wq_s *)filp->private_data;
    ulong off = vma->vm_pgoff << PAGE_SHIFT;
    ulong vma_size = vma->vm_end - vma->vm_start;

    if (vma_size == 0) {
        jenc_pr(LOG_ERROR, "vma_size is 0\n");
        return -EAGAIN;
    }
    off += wq->buf_start;
    jenc_pr(LOG_INFO, "vma_size is %ld, off is %ld\n", vma_size, off);
    vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP | VM_IO;
    /* vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); */
    if (remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
        vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
        jenc_pr(LOG_ERROR, "set_cached: failed remap_pfn_range\n");
        return -EAGAIN;
    }
    return 0;
}

static u32 jpegenc_poll(struct file *file, poll_table *wait_table)
{
    struct jpegenc_wq_s *wq = (struct jpegenc_wq_s *)file->private_data;
    poll_wait(file, &wq->complete, wait_table);

    if (atomic_read(&wq->ready)) {
        atomic_dec(&wq->ready);
        return POLLIN | POLLRDNORM;
    }
    return 0;
}

static const struct file_operations jpegenc_fops = {
    .owner = THIS_MODULE,
    .open = jpegenc_open,
    .mmap = jpegenc_mmap,
    .release = jpegenc_release,
    .unlocked_ioctl = jpegenc_ioctl,
#ifdef CONFIG_COMPAT
    .compat_ioctl = jpegenc_compat_ioctl,
#endif
    .poll = jpegenc_poll,
};

static s32 jpegenc_wq_init(void)
{
    jenc_pr(LOG_DEBUG, "jpegenc_wq_init.\n");
    spin_lock_init(&gJpegenc.sem_lock);
    spin_lock(&gJpegenc.sem_lock);
    gJpegenc.irq_requested = false;
    gJpegenc.process_irq = false;
    gJpegenc.inited = false;
    gJpegenc.opened = 0;
    gJpegenc.encode_hw_status = JPEGENC_ENCODER_IDLE;

    tasklet_init(&gJpegenc.tasklet,
             jpegenc_isr_tasklet,
             (ulong)&gJpegenc);
    spin_unlock(&gJpegenc.sem_lock);
    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_GXBB)
        clock_level = 5;
    else if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_M8M2)
        clock_level = 3;
    else
        clock_level = 1;
    return 0;
}

static s32 jpegenc_wq_uninit(void)
{
    s32 r = -1;
    jenc_pr(LOG_DEBUG, "uninit encode wq.\n");
    if (gJpegenc.encode_hw_status == JPEGENC_ENCODER_IDLE) {
        if ((gJpegenc.irq_num >= 0) &&
            (gJpegenc.irq_requested == true)) {
            free_irq(gJpegenc.irq_num, &gJpegenc);
            gJpegenc.irq_requested = false;
        }
        r = 0;
    }
    return  r;
}

static ssize_t encode_status_show(struct class *cla,
    struct class_attribute *attr, char *buf)
{
    s32 irq_num;
    u32 hw_status, width, height;
    bool process_irq;
    bool inited;
    bool use_reserve;
    u32 cma_size, max_w, max_h;
    u32 buffer_start, buffer_size;
    u8 lev, opened;
    struct Jpegenc_Buff_s res;

    spin_lock(&gJpegenc.sem_lock);

    irq_num = gJpegenc.irq_num;
    hw_status = gJpegenc.encode_hw_status;
    process_irq = gJpegenc.process_irq;
    inited = gJpegenc.inited;
    opened = gJpegenc.opened;
    use_reserve = gJpegenc.use_reserve;
    res.buf_start = gJpegenc.mem.reserve_mem.buf_start;
    res.buf_size = gJpegenc.mem.reserve_mem.buf_size;
    buffer_start = gJpegenc.mem.buf_start;
    buffer_size = gJpegenc.mem.buf_size;
    lev = gJpegenc.mem.cur_buf_lev;
    max_w = gJpegenc.mem.bufspec->max_width;
    max_h = gJpegenc.mem.bufspec->max_height;
    width = gJpegenc.wq.cmd.encoder_width;
    height = gJpegenc.wq.cmd.encoder_height;
#ifdef CONFIG_CMA
    cma_size = gJpegenc.mem.cma_pool_size / SZ_1M;
#endif
    spin_unlock(&gJpegenc.sem_lock);

    jenc_pr(LOG_DEBUG,
        "jpegenc width: %d, encode height: %d.\n",
        width, height);
    jenc_pr(LOG_DEBUG,
        "jpegenc hw_status: %d, process_irq: %s.\n",
        hw_status, process_irq ? "true" : "false");
    jenc_pr(LOG_DEBUG,
        "jpegenc irq num: %d,  inited: %s, opened: %d\n",
        irq_num, inited ? "true" : "false", opened);
    if (use_reserve) {
        jenc_pr(LOG_DEBUG,
            "jpegenc reserve memory, buffer start: 0x%x, size: %d MB.\n",
            res.buf_start, res.buf_size / SZ_1M);
    } else {
#ifdef CONFIG_CMA
        jenc_pr(LOG_DEBUG, "jpegenc cma pool size: %d.\n", cma_size);
#endif
    }
    jenc_pr(LOG_DEBUG, "jpegenc buffer start: 0x%x, size: 0x%x\n",
        buffer_start, buffer_size);
    jenc_pr(LOG_DEBUG, "buffer level: %s\n", glevel_str[lev]);
    return snprintf(buf, 40, "max size: %dx%d\n", max_w, max_h);
}

static int enc_dma_buf_map(struct enc_dma_cfg *cfg)
{
    long ret = -1;
    int fd = -1;
    struct dma_buf *dbuf = NULL;
    struct dma_buf_attachment *d_att = NULL;
    struct sg_table *sg = NULL;
    void *vaddr = NULL;
    struct device *dev = NULL;
    enum dma_data_direction dir;

    if (cfg == NULL || (cfg->fd < 0) || cfg->dev == NULL) {
        jenc_pr(LOG_ERROR, "error input param\n");
        return -EINVAL;
    }

    jenc_pr(LOG_INFO, "enc_dma_buf_map, fd %d\n", cfg->fd);

    fd = cfg->fd;
    dev = cfg->dev;
    dir = cfg->dir;
    jenc_pr(LOG_INFO, "enc_dma_buffer_map fd %d\n", fd);

    dbuf = dma_buf_get(fd);

    if (dbuf == NULL) {
        jenc_pr(LOG_ERROR, "failed to get dma buffer,fd %d\n",fd);
        return -EINVAL;
    }

    d_att = dma_buf_attach(dbuf, dev);

    if (d_att == NULL) {
        jenc_pr(LOG_ERROR, "failed to set dma attach\n");
        goto attach_err;
    }

    sg = dma_buf_map_attachment(d_att, dir);

    if (sg == NULL) {
        jenc_pr(LOG_ERROR, "failed to get dma sg\n");
        goto map_attach_err;
    }

    ret = dma_buf_begin_cpu_access(dbuf, dir);

    if (ret != 0) {
        jenc_pr(LOG_ERROR, "failed to access dma buff\n");
        goto access_err;
    }

    vaddr = dma_buf_vmap(dbuf);

    if (vaddr == NULL) {
        jenc_pr(LOG_ERROR, "failed to vmap dma buf\n");
        goto vmap_err;
    }

    cfg->dbuf = dbuf;
    cfg->attach = d_att;
    cfg->vaddr = vaddr;
    cfg->sg = sg;
    cfg->size = dbuf->size;
    jenc_pr(LOG_INFO, "dmabuf size is %zu\n", cfg->size);

    return ret;

vmap_err:
    dma_buf_end_cpu_access(dbuf, dir);

access_err:
    dma_buf_unmap_attachment(d_att, sg, dir);

map_attach_err:
    dma_buf_detach(dbuf, d_att);

attach_err:
    dma_buf_put(dbuf);

    return ret;
}

static int enc_dma_buf_get_phys(struct enc_dma_cfg *cfg, unsigned long *addr)
{
    struct sg_table *sg_table;
    struct page *page;
    int ret;
    jenc_pr(LOG_INFO, "jpegenc_dma_buf_get_phys in\n");

    ret = enc_dma_buf_map(cfg);

    if (ret < 0) {
        jenc_pr(LOG_ERROR, "jpegenc_dma_buf_get_phys failed\n");
        return ret;
    }

    if (cfg->sg) {
        sg_table = cfg->sg;
        page = sg_page(sg_table->sgl);
        *addr = PFN_PHYS(page_to_pfn(page));
        ret = 0;
    }

    jenc_pr(LOG_INFO, "jpegenc_dma_buf_get_phys 0x%lx\n", *addr);
    return ret;
}

static void enc_dma_buf_unmap(struct enc_dma_cfg *cfg)
{
    int fd = -1;
    struct dma_buf *dbuf = NULL;
    struct dma_buf_attachment *d_att = NULL;
    struct sg_table *sg = NULL;
    void *vaddr = NULL;
    struct device *dev = NULL;
    enum dma_data_direction dir;

    if (cfg == NULL || (cfg->fd < 0) || cfg->dev == NULL
       || cfg->dbuf == NULL || cfg->vaddr == NULL
       || cfg->attach == NULL || cfg->sg == NULL) {
        jenc_pr(LOG_ERROR, "Error input param\n");
        return;
    }

    fd = cfg->fd;
    dev = cfg->dev;
    dir = cfg->dir;
    dbuf = cfg->dbuf;
    vaddr = cfg->vaddr;
    d_att = cfg->attach;
    sg = cfg->sg;

    dma_buf_vunmap(dbuf, vaddr);

    dma_buf_end_cpu_access(dbuf, dir);

    dma_buf_unmap_attachment(d_att, sg, dir);

    dma_buf_detach(dbuf, d_att);

    dma_buf_put(dbuf);
    jenc_pr(LOG_DEBUG, "enc_dma_buffer_unmap vaddr %p\n",(unsigned *)vaddr);
}

static ssize_t power_ctrl_show(struct class *cla, struct class_attribute *attr, char *buf) {
    pr_err("power status: %lu\n", pwr_ctrl_status_psci_smc(PDID_T7_DOS_HCODEC));
    pr_err("jpeg clk: %ld\n", clk_get_rate(g_jpeg_enc_clks.jpeg_enc_clk));
    return 1;//snprintf(buf, PAGE_SIZE, "power control show done\n");
}

static ssize_t power_ctrl_store(struct class *class,struct class_attribute *attr,
        const char *buf, size_t count) {
    if (strncmp(buf, "poweron", 7) == 0) {
        pr_err("now powering on:\n");
        //pwr_ctrl_psci_smc(PM_HCODEC, true);
        //jpegenc_poweron_ex(6);
        jpegenc_init();
    } else if (strncmp(buf, "poweroff", 8) == 0) {
        pr_err("now powering off:\n");
        //pwr_ctrl_psci_smc(PM_HCODEC, false);
        jpegenc_poweroff_ex();
    } else if (strncmp(buf, "mbox0", 5) == 0) {
        pr_err("trigger mbox0:\n");

        WRITE_HREG(HCODEC_ASSIST_MBOX0_MASK, 1);   //enable irq
        WRITE_VREG(HCODEC_ASSIST_MBOX0_IRQ_REG, 0x1);  // set irq
    } else if (strncmp(buf, "mbox1", 5) == 0) {
        pr_err("trigger mbox1:\n");

        WRITE_HREG(HCODEC_ASSIST_MBOX1_MASK, 1);   //enable irq
        WRITE_VREG(HCODEC_ASSIST_MBOX1_IRQ_REG, 0x1);  // set irq
    } else if (strncmp(buf, "mbox2", 5) == 0) {
        pr_err("trigger mbox2:\n");

        WRITE_HREG(HCODEC_ASSIST_MBOX2_MASK, 1);   //enable irq
        WRITE_VREG(HCODEC_ASSIST_MBOX2_IRQ_REG, 0x1);  // set irq
    }

    return 1;//snprintf(buf, PAGE_SIZE, "policy read,just for test\n");
}

static CLASS_ATTR_RO(encode_status);
static CLASS_ATTR_RW(power_ctrl);
//static CLASS_ATTR(clock_ctrl, 0664, clock_ctrl_show, clock_ctrl_store);

static struct attribute *jpegenc_class_attrs[] = {
    &class_attr_encode_status.attr,
    &class_attr_power_ctrl.attr,
    //&class_attr_clock_ctrl.attr,
    NULL
};

ATTRIBUTE_GROUPS(jpegenc_class);

static struct class jpegenc_class = {
    .name = CLASS_NAME,
    .class_groups = jpegenc_class_groups,
};

s32 init_jpegenc_device(void)
{
    s32 r = 0;
    r = register_chrdev(0, DEVICE_NAME, &jpegenc_fops);
    if (r <= 0) {
        jenc_pr(LOG_ERROR, "register jpegenc device error\n");
        return r;
    }
    jpegenc_device_major = r;

    r = class_register(&jpegenc_class);
    if (r < 0) {
        jenc_pr(LOG_ERROR, "error create jpegenc class.\n");
        return r;
    }

    jpegenc_dev = device_create(&jpegenc_class, NULL,
        MKDEV(jpegenc_device_major, 0), NULL,
        DEVICE_NAME);

    if (IS_ERR(jpegenc_dev)) {
        jenc_pr(LOG_ERROR, "create jpegenc device error.\n");
        class_unregister(&jpegenc_class);
        return -1;
    }
    return r;
}

s32 uninit_jpegenc_device(void)
{
    if (jpegenc_dev)
        device_destroy(&jpegenc_class, MKDEV(jpegenc_device_major, 0));

    class_destroy(&jpegenc_class);

    unregister_chrdev(jpegenc_device_major, DEVICE_NAME);
    return 0;
}

static s32 jpegenc_mem_device_init(struct reserved_mem *rmem,
        struct device *dev)
{
    s32 r = 0;
    struct resource res;
    if (!rmem) {
        jenc_pr(LOG_ERROR,
            "Can't obtain I/O memory, will allocate jpegenc buffer!\n");
        r = -EFAULT;
        return r;
    }
    res.start = (phys_addr_t) rmem->base;
    res.end = res.start + (phys_addr_t) rmem->size - 1;
    gJpegenc.mem.reserve_mem.buf_start = res.start;
    gJpegenc.mem.reserve_mem.buf_size = res.end - res.start + 1;
    jenc_pr(LOG_DEBUG, "found reserved memory device(start:0x%llux, size:0x%llux)\n",
        rmem->base, rmem->size);
    if (gJpegenc.mem.reserve_mem.buf_size >=
        jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_VGA].min_buffsize)
        gJpegenc.use_reserve = true;
    else {
        jenc_pr(LOG_ERROR,
            "jpegenc reserve_mem too small, size is %d.\n",
            gJpegenc.mem.reserve_mem.buf_size);
        gJpegenc.mem.reserve_mem.buf_start = 0;
        gJpegenc.mem.reserve_mem.buf_size = 0;
        return -EFAULT;
    }
    return r;
}

static s32 jpegenc_probe(struct platform_device *pdev)
{
    s32 res_irq;
    s32 idx;

    jenc_pr(LOG_DEBUG, "jpegenc probe start.\n");

    gJpegenc.this_pdev = pdev;
    gJpegenc.use_reserve = false;
    gJpegenc.use_cma = false;

    jpeg_in_full_hcodec = 0;
    mfdin_ambus_canv_conv = 0;

    if (get_cpu_major_id() == AM_MESON_CPU_MAJOR_ID_T3) {
        pr_err("jpegenc_probe: jpeg_in_full_hcodec\n");
        jpeg_in_full_hcodec = 1;
        mfdin_ambus_canv_conv = 1;
    }

    memset(&gJpegenc.mem, 0, sizeof(struct jpegenc_meminfo_s));

    idx = of_reserved_mem_device_init(&pdev->dev);
    if (idx != 0) {
        jenc_pr(LOG_DEBUG,
            "jpegenc memory resource undefined. err=%d\n", idx);
    }

    if (gJpegenc.use_reserve == false) {
#ifndef CONFIG_CMA
        jenc_pr(LOG_ERROR,
            "jpegenc memory is invaild, probe fail!\n");
        return -EFAULT;
#else
        struct device_node *mem_node;
        struct reserved_mem *rmem = NULL;

        mem_node = of_parse_phandle(pdev->dev.of_node, "memory-region", 0);
        if (mem_node)
            rmem = of_reserved_mem_lookup(mem_node);
        of_node_put(mem_node);

        if (rmem) {
            jenc_pr(LOG_DEBUG,
                "jpegenc - reserved cma node found: %s.\n", rmem->name);
            gJpegenc.mem.cma_pool_size = rmem->size;
            gJpegenc.use_cma = true;
            jenc_pr(LOG_DEBUG,
                "jpegenc - codec mm pool size: %d MB.\n", codec_mm_get_free_size() / SZ_1M);

        } else {
            jenc_pr(LOG_DEBUG,
                "jpegenc - reserved cma node not found, using codec mm pool size.\n");
            gJpegenc.mem.cma_pool_size = codec_mm_get_free_size();
        }

        jenc_pr(LOG_DEBUG,
            "jpegenc - cma memory pool size: %d MB\n",
            (u32)gJpegenc.mem.cma_pool_size / SZ_1M);
        gJpegenc.mem.buf_size = gJpegenc.mem.cma_pool_size;
#endif
    } else {

        jenc_pr(LOG_DEBUG, "using reserved memory(start:0x%x, size:%d MB)\n",
            gJpegenc.mem.reserve_mem.buf_start,
            (u32)gJpegenc.mem.reserve_mem.buf_size / SZ_1M);
        gJpegenc.mem.buf_start = gJpegenc.mem.reserve_mem.buf_start;
        gJpegenc.mem.buf_size = gJpegenc.mem.reserve_mem.buf_size;
    }

    // when use_cma is false, choose JPEGENC_BUFFER_LEVEL_8M as default
    if (gJpegenc.use_cma == false) {
        jenc_pr(LOG_ERROR, "set mem spec to JPEGENC_BUFFER_LEVEL_8M\n");
        gJpegenc.mem.buf_size = jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_8M].min_buffsize;
    }

    if (gJpegenc.mem.buf_size >=
        jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_HD].min_buffsize) {
        gJpegenc.mem.cur_buf_lev = JPEGENC_BUFFER_LEVEL_HD;
        gJpegenc.mem.bufspec = (struct Jpegenc_BuffInfo_s *)
            &jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_HD];
    } else if (gJpegenc.mem.buf_size >=
        jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_13M].min_buffsize) {
        gJpegenc.mem.cur_buf_lev = JPEGENC_BUFFER_LEVEL_13M;
        gJpegenc.mem.bufspec = (struct Jpegenc_BuffInfo_s *)
            &jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_13M];
    } else if (gJpegenc.mem.buf_size >=
        jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_8M].min_buffsize) {
        gJpegenc.mem.cur_buf_lev = JPEGENC_BUFFER_LEVEL_8M;
        gJpegenc.mem.bufspec = (struct Jpegenc_BuffInfo_s *)
            &jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_8M];
    } else if (gJpegenc.mem.buf_size >=
        jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_5M].min_buffsize) {
        gJpegenc.mem.cur_buf_lev = JPEGENC_BUFFER_LEVEL_5M;
        gJpegenc.mem.bufspec = (struct Jpegenc_BuffInfo_s *)
            &jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_5M];
    } else if (gJpegenc.mem.buf_size >=
        jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_3M].min_buffsize) {
        gJpegenc.mem.cur_buf_lev = JPEGENC_BUFFER_LEVEL_3M;
        gJpegenc.mem.bufspec = (struct Jpegenc_BuffInfo_s *)
            &jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_3M];
    } else if (gJpegenc.mem.buf_size >=
        jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_2M].min_buffsize) {
        gJpegenc.mem.cur_buf_lev = JPEGENC_BUFFER_LEVEL_2M;
        gJpegenc.mem.bufspec = (struct Jpegenc_BuffInfo_s *)
            &jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_2M];
    } else if (gJpegenc.mem.buf_size >=
        jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_VGA].min_buffsize) {
        gJpegenc.mem.cur_buf_lev = JPEGENC_BUFFER_LEVEL_VGA;
        gJpegenc.mem.bufspec = (struct Jpegenc_BuffInfo_s *)
            &jpegenc_buffspec[JPEGENC_BUFFER_LEVEL_VGA];
    } else {
        jenc_pr(LOG_ERROR,
            "jpegenc probe memory too small, size is %d.\n",
            gJpegenc.mem.buf_size);
        gJpegenc.mem.buf_start = 0;
        gJpegenc.mem.buf_size = 0;
        return -EFAULT;
    }
#if 1
    res_irq = platform_get_irq(pdev, 0);
#else
    switch (manual_irq_num) {
        case 0:
            res_irq = platform_get_irq_byname(pdev, "dos_mbox_slow_irq0");
            pr_err("[%s:%d] get irq dos_mbox_slow_irq0, res_irq=%d\n", __FUNCTION__, __LINE__, res_irq);
            break;
        case 1:
            res_irq = platform_get_irq_byname(pdev, "dos_mbox_slow_irq1");
            pr_err("[%s:%d] get irq dos_mbox_slow_irq1, res_irq=%d\n", __FUNCTION__, __LINE__, res_irq);
            break;
        case 2:
            res_irq = platform_get_irq_byname(pdev, "dos_mbox_slow_irq2");
            pr_err("[%s:%d] get irq dos_mbox_slow_irq2, res_irq=%d\n", __FUNCTION__, __LINE__, res_irq);
            break;
        default:

            res_irq = platform_get_irq_byname(pdev, "dos_mbox_slow_irq0");
            pr_err("[%s:%d] get irq dos_mbox_slow_irq0, res_irq=%d\n", __FUNCTION__, __LINE__, res_irq);
            break;
    }
#endif

    if (res_irq < 0) {
        jenc_pr(LOG_ERROR, "[%s] get irq error!", __func__);
        return -EINVAL;
    } else
        jenc_pr(LOG_ERROR, "[%s] get irq success: %d!, manual_irq_num=%d\n", __func__, res_irq, manual_irq_num);

    gJpegenc.irq_num = res_irq;

    jenc_pr(LOG_DEBUG,
        "jpegenc memory config sucess, buff size is 0x%x, level: %s\n",
        gJpegenc.mem.buf_size,
        glevel_str[gJpegenc.mem.cur_buf_lev]);

    jpegenc_wq_init();
    init_jpegenc_device();

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1) {
        if (jpeg_enc_clk_get(&pdev->dev, &g_jpeg_enc_clks) != 0) {
            pr_err("jpeg_enc_clk_get failed\n");
            return -1;
        }
    }

    jenc_pr(LOG_DEBUG, "jpegenc probe end.\n");
    return 0;
}

static s32 jpegenc_remove(struct platform_device *pdev)
{
    if (jpegenc_wq_uninit())
        jenc_pr(LOG_ERROR, "jpegenc_wq_uninit error.\n");

    of_reserved_mem_device_release(&pdev->dev);

    if (get_cpu_major_id() >= AM_MESON_CPU_MAJOR_ID_C1)
        jpeg_enc_clk_put(&pdev->dev, &g_jpeg_enc_clks);

    uninit_jpegenc_device();
    jenc_pr(LOG_DEBUG, "jpegenc remove.\n");
    return 0;
}

static const struct of_device_id amlogic_jpegenc_dt_match[] = {
    {
        .compatible = "amlogic, jpegenc",
    },
    {},
};

static struct platform_driver jpegenc_driver = {
    .probe = jpegenc_probe,
    .remove = jpegenc_remove,
    .driver = {
        .name = DRIVER_NAME,
        .of_match_table = amlogic_jpegenc_dt_match,
    }
};

#if 0
static struct codec_profile_t jpegenc_profile = {
    .name = "jpegenc",
    .profile = ""
};
#endif

static s32 __init jpegenc_driver_init_module(void)
{
    jenc_pr(LOG_DEBUG, "jpegenc module init\n");

    if (platform_driver_register(&jpegenc_driver)) {
        jenc_pr(LOG_ERROR, "failed to register jpegenc driver\n");
        return -ENODEV;
    }

#if 0
    vcodec_profile_register(&jpegenc_profile);
#endif
    return 0;
}

static void __exit jpegenc_driver_remove_module(void)
{
    jenc_pr(LOG_DEBUG, "jpegenc module remove.\n");
    platform_driver_unregister(&jpegenc_driver);
}

static const struct reserved_mem_ops rmem_jpegenc_ops = {
    .device_init = jpegenc_mem_device_init,
};

static s32 __init jpegenc_mem_setup(struct reserved_mem *rmem)
{
    rmem->ops = &rmem_jpegenc_ops;
    jenc_pr(LOG_DEBUG, "jpegenc reserved mem setup.\n");
    return 0;
}

module_param(simulation_enable, uint, 0664);
MODULE_PARM_DESC(simulation_enable, "\n simulation_enable\n");

module_param(g_block_mode, uint, 0664);
MODULE_PARM_DESC(g_block_mode, "\n g_block_mode\n");

module_param(g_canv0_stride, uint, 0664);
MODULE_PARM_DESC(g_canv0_stride, "\n g_canv0_stride\n");

module_param(g_canv1_stride, uint, 0664);
MODULE_PARM_DESC(g_canv1_stride, "\n g_canv1_stride\n");

module_param(g_canv2_stride, uint, 0664);
MODULE_PARM_DESC(g_canv2_stride, "\n g_canv2_stride\n");

module_param(g_canvas_height, uint, 0664);
MODULE_PARM_DESC(g_canvas_height, "\n g_canvas_height\n");

module_param(clock_level, uint, 0664);
MODULE_PARM_DESC(clock_level, "\n clock_level\n");

module_param(jpegenc_print_level, uint, 0664);
MODULE_PARM_DESC(jpegenc_print_level, "\n jpegenc_print_level\n");

module_param(reg_offset, int, 0664);
MODULE_PARM_DESC(reg_offset, "\n reg_offset\n");

module_param(use_dma_io, uint, 0664);
MODULE_PARM_DESC(use_dma_io, "\n use dma io or not\n");

module_param(use_quality, uint, 0664);
MODULE_PARM_DESC(use_quality, "\n use_quality\n");

module_param(legacy_load, uint, 0664);
MODULE_PARM_DESC(legacy_load, "\n legacy_load\n");

module_param(dumpmem_line, uint, 0664);
MODULE_PARM_DESC(dumpmem_line, "\n dumpmem_line\n");

module_param(pointer, uint, 0664);
MODULE_PARM_DESC(pointer, "\n pointer\n");

/*######### DEBUG-BRINGUP#########*/
module_param(manual_clock, uint, 0664);
MODULE_PARM_DESC(manual_clock, "\n manual_clock\n");

module_param(manual_irq_num, uint, 0664);
MODULE_PARM_DESC(manual_irq_num, "\n manual_irq_num\n");

module_param(manual_interrupt, uint, 0664);
MODULE_PARM_DESC(manual_interrupt, "\n manual_interrupt\n");
/*################################*/

module_init(jpegenc_driver_init_module);
module_exit(jpegenc_driver_remove_module);
RESERVEDMEM_OF_DECLARE(jpegenc, "amlogic, jpegenc-memory", jpegenc_mem_setup);

MODULE_DESCRIPTION("AMLOGIC JPEG Encoder Driver");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("simon.zheng <simon.zheng@amlogic.com>");