Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

+8
View File
@@ -0,0 +1,8 @@
config MTK_JPEG
bool "MTK_JPEG"
default n
help
Control the jpeg encode driver, which is used to enable jpeg encode
Its default value is no, would
be set to yes by RD when needed. It's scenario
is image capture
+21
View File
@@ -0,0 +1,21 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# 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.
#
# drivers/image/jpeg/Makefile
# use common driver
ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6757" "mt6799" "kiboplus" "mt6759" "mt6763" "mt6758" "mt6739" "mt6765" "mt6761" "mt8163" "mt8173" "mt6779" "mt6768" "mt6767" "mt6771" "mt6785" "mt8168" "mt6885" "mt6893"))
# new chip use v2 driver
obj-y += v2/
endif
# EOF
+102
View File
@@ -0,0 +1,102 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# 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.
#
# drivers/image/jpeg/Makefile
ccflags-y = -DSDEBUG_T
ifeq ($(CONFIG_MACH_MT6757),y)
ccflags-y += -DJPEG_DEC_DRIVER
endif
ifeq ($(CONFIG_MACH_MT6799),y)
ccflags-y += -DJPEG_DEC_DRIVER
endif
ifeq ($(CONFIG_MACH_MT6765),y)
ccflags-y += -DSMI_CG_SUPPORT
ccflags-y += -DQOS_MT6765_SUPPORT
ccflags-y += -DPLATFORM_MT6765
endif
ifeq ($(CONFIG_MACH_MT6761),y)
ccflags-y += -DSMI_CG_SUPPORT
ccflags-y += -DQOS_MT6761_SUPPORT
ccflags-y += -DPLATFORM_MT6761
endif
ifeq ($(CONFIG_MACH_MT6779),y)
ccflags-y += -DSMI_CG_SUPPORT
ccflags-y += -DQOS_MT6779_SUPPORT
ccflags-y += -DPLATFORM_MT6779
endif
ifeq ($(CONFIG_MACH_MT6785),y)
ccflags-y += -DSMI_CG_SUPPORT
ccflags-y += -DQOS_MT6785_SUPPORT
ccflags-y += -DPLATFORM_MT6785
endif
ifeq ($(CONFIG_MACH_MT6768),y)
ccflags-y += -DSMI_CG_SUPPORT
ccflags-y += -DPLATFORM_MT6767
endif
ifeq ($(CONFIG_MACH_MT6739),y)
ccflags-y += -DPLATFORM_MT6739
endif
ifeq ($(CONFIG_MACH_MT6771),y)
ccflags-y += -DPLATFORM_MT6771
endif
ifeq ($(CONFIG_MACH_MT6767),y)
ccflags-y += -DSMI_CG_SUPPORT
ccflags-y += -DPLATFORM_MT6768
endif
ifeq (y, $(filter y,$(CONFIG_MACH_MT6885) $(CONFIG_MACH_MT6893)))
ccflags-y += -DJPEG_HYBRID_DEC_DRIVER
endif
ifeq (,$(filter y,$(CONFIG_MACH_MT6885) $(CONFIG_MACH_MT6893)))
ccflags-y += -DJPEG_ENC_DRIVER
endif
ifeq ($(CONFIG_MACH_MT8163),y)
ccflags-y += -DJPEG_PM_DOMAIN_ENABLE
endif
ifeq ($(CONFIG_MACH_MT8173),y)
ccflags-y += -DJPEG_DEC_DRIVER
ccflags-y += -DJPEG_PM_DOMAIN_ENABLE
endif
ccflags-y += -I$(srctree)/drivers/misc/mediatek/smi/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmdvfs
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion/mtk
#obj-$(CONFIG_MTK_JPEG) += jpeg_driver.o
obj-y += jpeg_driver.o
ifdef CONFIG_MTK_PSEUDO_M4U
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_PLATFORM)/include
ccflags-y += -I$(srctree)/drivers/iommu/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)
endif
#jpeg_driver-objs := jpeg_cmdq.o jpeg_drv_enc.o jpeg_drv_dec.o jpeg_drv.o
jpeg_driver-objs := jpeg_drv_enc.o jpeg_drv_dec.o jpeg_drv.o jpeg_ion.o
# EOF
File diff suppressed because it is too large. Load diff
+734
View File
@@ -0,0 +1,734 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#include <linux/ioctl.h>
#include <linux/notifier.h>
#include "jpeg_ion.h"
#ifdef CONFIG_COMPAT
/* 32-64 bit conversion */
#include <linux/fs.h>
#include <linux/compat.h>
#endif
#ifndef CONFIG_MTK_CLKMGR
#include <linux/clk.h>
#endif /* !defined(CONFIG_MTK_LEGACY) */
#ifndef __JPEG_DRV_H__
#define __JPEG_DRV_H__
#define TO_CEIL(x, a) (((x) + ((a)-1)) & ~((a)-1))
#define TO_FLOOR(x, a) ((x) & ~((a)-1))
#define TO_MASK(x, a) ((x) & (a))
#define DUNUM_MAPPING(value) (((value)-1)&0x3)
/* ============================ */
#define MAX_JPEG_COMPONENT 4
#define MAX_NUM_SCAN 32
#define D_MAX_JPEG_HW_COMP 3
/* #define D_MAX_JPEG_HUFF_TBL 4 */
#define D_MAX_JPEG_QTBL 4
#define D_MAX_JPEG_HW_QTBL 2
#define D_MAX_JPEG_BLOCK_NUM 10
#define D_HUFF_LOOKAHEAD_BITS 6 /* # of bits of lookahead */
#define D_DCTSIZE 8
#define D_JPEG_DRAM_ALIGN_MASK 0xf
#define D_JPEG_DRAM_ALIGN_SIZE (D_JPEG_DRAM_ALIGN_MASK + 1)
#define D_JPEG_BASELINE 0
#define D_JPEG_DC_REFINE 1
#define D_JPEG_AC_FIRST 2
#define D_JPEG_AC_REFINE 3
#define D_JPEG_DC_FIRST 4
/* global data check flags */
#define D_FLAG_NONE (0)
#define D_GLOB_PROGRESSIVE (1 << 0)
#define D_GLOB_NCOMP (1 << 1)
#define D_GLOB_BLK_W (1 << 2)
#define D_GLOB_BLK_H (1 << 3)
#define D_GLOB_PIC_W (1 << 4)
#define D_GLOB_PIC_H (1 << 5)
#define D_GLOB_DCHUFF (1 << 6) /* no need */
#define D_GLOB_ACHUFF (1 << 7) /* no need */
#define D_GLOB_NZBUFF (1 << 8) /* no need */
#define D_GLOB_QTBL (1 << 9) /* no need */
#define D_GLOB_RESTART (1 << 10)
/* scan data check flags */
#define D_SCAN_DATASTART (1 << 0)
#define D_SCAN_NCOMP (1 << 1)
#define D_SCAN_COMPIN (1 << 2)
#define D_SCAN_COMPQ (1 << 3)
#define D_SCAN_BLKDC (1 << 4)
#define D_SCAN_BLKAC (1 << 5)
#define D_SCAN_ALAH (1 << 6)
#define D_SCAN_SESS (1 << 7)
#define D_SCAN_LAST (1 << 8)
#define D_SCAN_ROWSTART (1 << 9)
#define D_SCAN_ROWEND (1 << 10)
#define D_SCAN_DCHUFF (1 << 11)
#define D_SCAN_ACHUFF (1 << 12)
#define D_SCAN_QTBL (1 << 13)
#define D_SCAN_NZBUFF (1 << 14)
/* mcu row check flags */
#define D_ROW_CURR (1 << 0)
#define D_ROW_OUTBUF (1 << 1)
#define D_ROW_OUTBUFSIZE (1 << 2)
/* mcu check flags */
#define D_MCU_OUTADDR (1 << 0)
#define D_MCU_COEFADDR (1 << 1)
/* misc check flags */
#define D_MISC_ADDR_X (1 << 0)
#define D_MISC_ADDR_Y (1 << 1)
#define HORI 0
#define VERT 1
#define JPEG_ENC_DST_ADDR_OFFSET_MASK (0x0f)
#define HW_CORE_NUMBER 3
#if defined(PLATFORM_MT6785)
#define ENABLE_MMQOS 1
#else
#define ENABLE_MMQOS 0
#endif
/* #ifdef CONFIG_OF */
struct JpegDeviceStruct {
struct device *pDev;
long encRegBaseVA; /* considering 64 bit kernel, use long */
long decRegBaseVA;
long hybriddecRegBaseVA[HW_CORE_NUMBER];
uint32_t encIrqId;
uint32_t decIrqId;
uint32_t hybriddecIrqId[HW_CORE_NUMBER];
struct device *larbjpeg;
struct notifier_block pm_notifier;
bool is_suspending;
bool is_dec_started[HW_CORE_NUMBER];
};
const long jpeg_dev_get_encoder_base_VA(void);
const long jpeg_dev_get_decoder_base_VA(void);
const long jpeg_dev_get_hybrid_decoder_base_VA(int id);
const int jpeg_dev_get_hybrid_decoder_id(unsigned int pa);
/* #endif */
#ifndef CONFIG_MTK_CLKMGR
struct JpegClk {
struct clk *clk_smi_common;
#ifdef JPEG_DRV_MT6799
struct clk *clk_mm_larb7;
struct clk *clk_gals_m0_2x;
struct clk *clk_gals_m1_2x;
struct clk *clk_upsz0;
struct clk *clk_upsz1;
struct clk *clk_fifo0;
struct clk *clk_fifo1;
struct clk *clk_smi_common_2x;
#endif
struct clk *clk_scp_sys_mm0;
struct clk *clk_scp_sys_ven;
struct clk *clk_venc_larb;
struct clk *clk_venc_jpgEnc;
struct clk *clk_venc_jpgDec;
struct clk *clk_venc_jpgDec_c1;
struct clk *clk_venc_c1_jpgDec;
};
#endif /* !defined(CONFIG_MTK_LEGACY) */
enum JpegDecRetCode {
E_JPG_OK,
E_JPG_ERR_NONFATAL,
E_JPG_ERR_FATAL,
E_JPG_ERR_PARAM,
E_JPG_ERR_NOT_INITED,
E_JPG_ERR_ALREADY, /* 5 */
/* markers */
E_JPG_ERR_NOT_JPEG_IMAGE,
E_JPG_ERR_NOT_A_MARKER,
E_JPG_ERR_PASS_END,
E_JPG_ERR_MULTI_SOI,
E_JPG_ERR_UNSUPPORT_SOF, /* 10 */
E_JPG_ERR_MULTI_SOF,
E_JPG_ERR_INVALID_SOF,
E_JPG_ERR_SOS_BEFORE_SOF,
E_JPG_ERR_INVALID_SOS,
E_JPG_ERR_INVALID_DHT, /* 15 */
E_JPG_ERR_INVALID_DRI,
E_JPG_ERR_MULTI_APP1,
E_JPG_ERR_INVALID_APP0,
E_JPG_ERR_INVALID_APP1,
E_JPG_ERR_PARSE_FAILED, /* 20 */
E_JPG_ERR_NOT_PARSED,
E_JPG_ERR_MULTI_EOI,
/* instances */
E_JPG_ERR_ALLOC_PARSER,
E_JPG_ERR_ALLOC_DECODER,
E_JPG_ERR_ALLOC_MEM, /* 25 */
E_JPG_ERR_ALLOC_FLOW,
/* general */
E_JPG_ERR_UNSUPPORT,
E_JPG_ERR_GENERAL,
E_JPG_ERR_LAST,
E_JPG_ERR_DISPLAY_ADDR, /* 30 */
E_JPG_ERR_INVALID_COMPONENT /* code sync */
};
enum JpegDrvDecRetCode {
E_HWJPG_OK = 0,
E_HWJPG_BUSY,
E_HWJPG_ERR_FETCH_TIMEOIT = E_JPG_ERR_LAST + 1,
E_HWJPG_ERR_SET_BS,
E_HWJPG_ERR_LOAD_Q,
E_HWJPG_ERR_QTBL_INDEX,
E_HWJPG_ERR_QTBL_NUM,
E_HWJPG_ERR_PARAM,
E_HWJPG_ERR_TIMEOUT,
E_HWJPG_ERR_COMP_RANGE,
E_HWJPG_ERR_TBL_RANGE,
E_HWJPG_ERR_BLOCK,
E_HWJPG_ERR_SIZE,
E_HWJPG_ERR_OUTBUF,
E_HWJPG_ERR_NULL_SCAN,
E_HWJPG_ERR_GLOB_NOT_READY,
E_HWJPG_ERR_SCAN_NOT_READY,
E_HWJPG_ERR_ROW_NOT_READY,
E_HWJPG_ERR_MCU_NOT_READY,
E_HWJPG_ERR_MISC_NOT_READY,
E_HWJPG_ERR_HUFF_ADDR,
/* last */
E_HWJPG_ERR_GENERAL
};
enum JpegDrvDecMode {
JDEC_HAL_DEC_MODE_NONE,
/* /< Jpeg baseline picture, decode whole picture */
JDEC_HAL_DEC_MODE_BASELINE_PIC,
/* /< Jpeg baseline picture, decode MCU row */
JDEC_HAL_DEC_MODE_BASELINE_MCU,
/* /< Jpeg baseline picture, decode MCU */
JDEC_HAL_DEC_MODE_BASELINE_MCU_ROW,
JDEC_HAL_DEC_MODE_BASELINE_VIDEO_OUTPUT,
/* /< Jpeg progressive picture, decode MCU milti-collect */
JDEC_HAL_DEC_MODE_PROGRESSIVE_MCU_MULTI_COLLECT,
/* /< Jpeg progressive picture, decode MCU enhance decoding */
JDEC_HAL_DEC_MODE_PROGRESSIVE_MCU_ENHANCE,
/* /Jpeg progressive MCU-Row Mode */
JDEC_HAL_DEC_MODE_PROGRESSIVE_MCU_ROW_MULTI_COLLECT,
JDEC_HAL_DEC_MODE_PROGRESSIVE_MCU_ROW_ENHANCE,
JDEC_HAL_DEC_MODE_PROGRESSIVE_SCAN_MULTI_COLLECT,
JDEC_HAL_DEC_MODE_PROGRESSIVE_SCAN_ENHANCE
};
/* jpeg format */
enum JpegDecFormat {
E_JPG_UNKNOWN_FORMAT,
E_JPG_BASELINE,
E_JPG_EX_SEQ_HUFFMAN,
E_JPG_PROGRESSIVE_HUFFMAN,
E_JPG_EX_SEQ_ARITHMETIC,
E_JPG_PROGRESSIVE_ARITHMETIC,
E_JPG_LOSSLESS_HUFFMAN,
E_JPG_DIFFERENTIAL_SEQ_HUFFMAN,
E_JPG_DIFF_PROG_HUFFMAN,
E_JPG_DIFF_LLESS_HUFFMAN,
E_JPG_RESERVED_FOR_EXTENSIONS,
E_JPG_LOSSLESS_ARITHMETIC,
E_JPG_DIFF_SEQ_ARITHMETIC,
E_JPG_DIFF_PROG_ARITHMETIC,
E_JPG_UNSUPPORT_FORMAT
};
/* // jpeg decode mode */
enum JpegDecMode {
JPEG_DEC_MODE_NONE,
/* /< Jpeg baseline picture, decode whole picture */
JPEG_DEC_MODE_FRAME,
/* /< Jpeg baseline picture, decode whole picture */
JPEG_DEC_MODE_DC_LINK,
/* /< Jpeg baseline picture, decode MCU row */
JPEG_DEC_MODE_MCU_ROW
};
/* component info in SOF marker */
struct JpegDecSOFComp {
unsigned char u1CompId;
unsigned char u1HSampFactor;
unsigned char u1VSampFactor;
unsigned char u1QuantTblNo;
};
struct JpegDecSOS {
unsigned int u4ScanPass; /* scan pass */
unsigned char u1CompInScan;
unsigned char au1CompNoList[MAX_JPEG_COMPONENT];
unsigned char au1DcId[MAX_JPEG_COMPONENT];
unsigned char au1AcId[MAX_JPEG_COMPONENT];
unsigned char u1Ss, u1Se, u1Ah, u1Al, u1AhAl; /* OT: NO USE */
unsigned char *pu1ScanTableStart;
unsigned char *pu1ScanDataStart;
};
/* raw de-huffman table */
struct JpegDecDhtHuffTbl {
unsigned char au1Bits[17];
unsigned char au1HuffVal[256];
};
/* SOF data */
struct JpegDecSOF {
int fgSOF; /* indicate that already have an SOF marker */
enum JpegDecFormat eJpegFormat;
unsigned char u1DataPrecision;
unsigned short u2ImageHeight;
unsigned short u2ImageWidth;
unsigned char u1NumComponents;
unsigned char au1MapId2Index[256];
struct JpegDecSOFComp arSofComp[MAX_JPEG_COMPONENT];
};
/* DHT data */
struct JpegDecDHT {
unsigned int u4NumDcTbl;
unsigned int u4NumAcTbl;
unsigned int fgDcTblLoaded; /* bit mask for loaded dc table */
unsigned int fgAcTblLoaded; /* bit mask for loaded ac table */
struct JpegDecDhtHuffTbl arDcTbl[4];
struct JpegDecDhtHuffTbl arAcTbl[4];
};
/* DQT data */
struct JpegDecDQT {
/* although we leave 2bytes mul 64 space here, */
/* if q table precision is 8bits, we use only */
/* first half (1x64) of this table */
unsigned char aau1Qtbl[4][128];
unsigned int afgPrec[4];
unsigned char u1NumQ;
unsigned int fgDQT;
};
/* new types for flw2 (wired) */
struct JpegDrvDecFlow {
void *pvFreePoint; /* OT: NO USE */
unsigned int u4Width; /* OT: NO USE */
unsigned int u4Height; /* OT: NO USE */
unsigned int u4McuNumInRow; /* OT: NO USE */
unsigned int u4McuRows; /* OT: NO USE */
unsigned int u4TotalMcuNum; /* OT: NO USE */
unsigned int aau4SampleFactor[3][2]; /* OT: NO USE */
unsigned int au4CompBlock[3]; /* OT: NO USE */
unsigned int au4MaxFactor[2]; /* OT: NO USE */
unsigned int outputBuffer0[3];
/* nouse in full frame mode, only use */
/* in PauseResume/DirectCouple mode */
unsigned int outputBuffer1[3];
unsigned int au1CoffBuffer[3]; /* OT: NO USE */
int fgProgScan; /* OT: NO USE */
/* temp buffers */
unsigned int apvNzBuffer[3]; /* OT: NO USE */
};
/* // JPEG Decoder Structure */
struct JPEG_DEC_DRV_IN {
/* common */
unsigned int decodeMode; /* OK */
unsigned int reg_OpMode; /* OK */
unsigned int regDecDumpEn;
unsigned int totalMCU; /* OK */
unsigned int comp0_DU;
/* OK { GRAY, gmcEn, DU9, DU8,..., DU1, DU0} */
unsigned int membershipList;
/* for BRZ (0): 1, (1): 1/2, (2): 1/4, (3): 1/8 */
unsigned char lumaHorDecimate; /* OK */
unsigned char lumaVerDecimate; /* OK */
unsigned char cbcrHorDecimate; /* OK */
unsigned char cbcrVerDecimate; /* OK */
unsigned int srcStreamAddrBase; /* OK */
unsigned int srcStreamSize; /* OK */
unsigned int srcStreamAddrWritePtr; /* OK */
unsigned int outputBuffer0[3]; /* OK */
/*OK only use in PauseResume/DirectCouple mode */
unsigned int outputBuffer1[3];
/* JPEG component information */
unsigned int componentNum; /* OK */
unsigned int componentID[3]; /* OK ///< Ci */
unsigned int hSamplingFactor[3]; /* OK ///< Hi */
unsigned int vSamplingFactor[3]; /* OK ///< Vi */
/* OK ///< Tqi (OT: need this field?) */
unsigned int qTableSelector[3];
unsigned int dma_McuInGroup; /* OK */
unsigned int dma_GroupNum; /* OK */
unsigned int dma_LastMcuNum; /* OK */
unsigned int gmcEn; /* OK */
/*OK ///< number of MCU column in the JPEG file */
/* unsigned int totalMcuRows; */
/* hSamplingFactor[n] * 8 * mcuPerRow */
unsigned int compImgStride[D_MAX_JPEG_HW_COMP];
unsigned int compMemStride[D_MAX_JPEG_HW_COMP]; /* OK */
/* hSamplingFactor[n] * 8 * mcuPerRow */
unsigned int compTileBufStride[D_MAX_JPEG_HW_COMP];
/* OK //move to HAL ///< number of MCU row in the JPEG file */
unsigned int mcuPerRow;
unsigned int pauseRow_en; /* OK */
unsigned int pauseRowCnt; /* move to HAL */
unsigned int pauseMCU; /* OK */
unsigned int tileBufRowNum; /* move to HAL */
unsigned int buffer_Y_PA; /* move to HAL */
unsigned int buffer_Cb_PA; /* move to HAL */
unsigned int buffer_Cr_PA; /* move to HAL */
unsigned int buffer_Y_row_size; /* move to HAL */
unsigned int buffer_C_row_size; /* move to HAL */
/*OK (required by HW decoder) number of DU for each component */
/* unsigned int compDU[3]; */
/*OK (required by HW decoder) DU per MCU row for each component */
/* unsigned int duPerMCURow[3]; */
/*OK (required by HW decoder) number of dummy DU for each component */
/* unsigned int dummyDU[3]; */
/*OK /// how many format? */
/* unsigned int samplingFormat; */
};
struct JPEG_DEC_DRV_OUT {
long timeout;
unsigned int *result;
};
struct JPEG_DEC_DRV_HYBRID_TASK {
long timeout;
int *hwid;
int *index_buf_fd;
unsigned int data[21];
};
struct JPEG_DEC_DRV_HYBRID_P_N_S {
int hwid;
int *progress_n_status;
};
struct JPEG_DEC_CONFIG_ROW {
unsigned int decRowBuf[3]; /* OK */
unsigned int pauseMCU; /* OK */
};
struct JPEG_DEC_CONFIG_CMDQ {
unsigned int goNum;
unsigned int pauseMCUidx[64];
unsigned int decRowBuf0[64];
unsigned int decRowBuf1[64];
unsigned int decRowBuf2[64];
};
struct JpegDrvDecConfig {
/* from mt6575 */
unsigned int srcStreamAddrBase;
unsigned int srcStreamSize;
unsigned int srcStreamAddrWritePtr;
unsigned int outputBuffer0[3];
/* nouse in full frame mode, only use */
/*in PauseResume/DirectCouple mode */
unsigned int outputBuffer1[3];
/* /< number of MCU row in the JPEG file */
unsigned int mcuPerRow;
/* /< number of MCU column in the JPEG file */
unsigned int totalMcuRows;
/* /< (required by HW decoder) number of DU for each component */
unsigned int compDU[3];
/* /< (required by HW decoder) DU per MCU row for each component */
unsigned int duPerMCURow[3];
/* /< (required by HW decoder) number of dummy DU for each component */
unsigned int dummyDU[3];
unsigned int samplingFormat; /* / how many format? */
/* JPEG component information */
unsigned int componentNum;
unsigned int componentID[3]; /* /< Ci */
unsigned int hSamplingFactor[3]; /* /< Hi */
unsigned int vSamplingFactor[3]; /* /< Vi */
unsigned int qTableSelector[3]; /* /< Tqi (OT: need this field?) */
/******************************/
/* common */
unsigned int totalMCU;
unsigned char blkNumInMCU; /* total drv no use */
/* widest, highest */
unsigned char u1MaxHorSample, u1MaxVerSample;
/* picture width and height */
unsigned int u4PicWidth, u4PicHeight;
/* hSamplingFactor[n] * 8 * mcuPerRow */
unsigned int compImgStride[D_MAX_JPEG_HW_COMP];
/* hSamplingFactor[n] * 8 * mcuPerRow */
unsigned int compTileBufStride[D_MAX_JPEG_HW_COMP];
unsigned int au4PicWidthInBuf[D_MAX_JPEG_HW_COMP];
/* use only in look ahead table */
/* DU mapping to components */
unsigned char au1MemberShip[D_MAX_JPEG_BLOCK_NUM];
/* q tables in stream */
unsigned char aau1Qtbl[D_MAX_JPEG_QTBL][128];
unsigned int u4RestartInterval;
/* current scan */
/* number of components in current scan */
unsigned char u1NumCompsInCurrScan;
int afgCompInScan[D_MAX_JPEG_HW_COMP + 1];
/* unsigned char qTableSelector[D_MAX_JPEG_HW_COMP]; */
unsigned char au1BlkDc[D_MAX_JPEG_BLOCK_NUM];
unsigned char au1BlkAc[D_MAX_JPEG_BLOCK_NUM];
unsigned char u1Se; /* OT: NO USE */
unsigned char u1Ss; /* OT: NO USE */
/* current mcu row */
unsigned int u4CurrMcuRow;
unsigned int u4ModTotalRows;
/* for single component in p scan */
unsigned char u1FirstCompInScan;
/* for BRZ */
/* (0): 1, (1): 1/2, (2): 1/4, (3): 1/8 */
unsigned char lumaHorDecimate;
unsigned char lumaVerDecimate;
unsigned char cbcrHorDecimate;
unsigned char cbcrVerDecimate;
unsigned int srcColorFormat;
unsigned int dstColorFormat;
unsigned int u4isColorConv;
unsigned int u4ds_width[3];
unsigned int u4ds_height[3];
unsigned int decodeMode;
unsigned int gdmaBypassEn;
unsigned int regDecDumpEn;
unsigned int pauseRow_en;
unsigned int pauseRowCnt;
unsigned int tileBufRowNum;
unsigned int buffer_Y_PA;
unsigned int buffer_Cb_PA;
unsigned int buffer_Cr_PA;
unsigned int buffer_Y_row_size;
unsigned int buffer_C_row_size;
};
struct JpegDrvDecResult {
unsigned int *pChksum;
};
/* ========================== */
/* JPEG Encoder Structure */
struct JPEG_ENC_DRV_IN {
unsigned int dstBufferAddr;
unsigned int dstBufferSize;
unsigned int encWidth; /* HW directly fill to header */
unsigned int encHeight; /* HW directly fill to header */
unsigned char enableEXIF;
unsigned char allocBuffer;
/* unsigned char enableSyncReset; */
unsigned int encQuality;
unsigned int encFormat;
/* extend in mt6589 */
unsigned int disableGMC; /* TBD: not support */
unsigned int restartInterval;
unsigned int srcBufferAddr; /* YUV420: Luma */
unsigned int srcChromaAddr;
unsigned int imgStride;
unsigned int memStride;
unsigned int totalEncDU;
unsigned int dstBufAddrOffset;
unsigned int dstBufAddrOffsetMask;
int srcFd;
int srcFd2;
int dstFd;
unsigned int memHeight;
};
struct JPEG_ENC_DRV_OUT {
long timeout;
unsigned int *fileSize;
unsigned int *result;
unsigned int *cycleCount;
};
struct JPEG_PMEM_RANGE {
unsigned long startAddr; /* In : */
unsigned long size;
unsigned long result;
};
#ifdef CONFIG_COMPAT
struct compat_JPEG_DEC_DRV_OUT {
compat_long_t timeout;
compat_uptr_t result;
};
struct compat_JpegDrvDecResult {
compat_uptr_t pChksum;
};
struct compat_JPEG_ENC_DRV_OUT {
compat_long_t timeout;
compat_uptr_t fileSize;
compat_uptr_t result;
compat_uptr_t cycleCount;
};
struct compat_JPEG_DEC_DRV_HYBRID_TASK {
compat_long_t timeout;
compat_uptr_t hwid;
compat_uptr_t index_buf_fd;
unsigned int data[21];
};
struct compat_JPEG_DEC_DRV_HYBRID_P_N_S {
int hwid;
compat_uptr_t progress_n_status;
};
#endif
/* ============================= */
#define JPEG_IOCTL_MAGIC 'x'
/* /////////////////// JPEG DEC IOCTL ///////////////////////////////////// */
#define JPEG_DEC_IOCTL_INIT \
_IO(JPEG_IOCTL_MAGIC, 1)
#define JPEG_DEC_IOCTL_CONFIG \
_IOW(JPEG_IOCTL_MAGIC, 2, struct JPEG_DEC_DRV_IN)
#define JPEG_DEC_IOCTL_FLOW \
_IOW(JPEG_IOCTL_MAGIC, 3, struct JpegDrvDecFlow)
#define JPEG_DEC_IOCTL_START \
_IO(JPEG_IOCTL_MAGIC, 4)
#define JPEG_DEC_IOCTL_WAIT \
_IOWR(JPEG_IOCTL_MAGIC, 5, struct JPEG_DEC_DRV_OUT)
#define JPEG_DEC_IOCTL_DEINIT \
_IO(JPEG_IOCTL_MAGIC, 6)
#define JPEG_DEC_IOCTL_RESET \
_IO(JPEG_IOCTL_MAGIC, 7)
#define JPEG_DEC_IOCTL_CHKSUM \
_IOWR(JPEG_IOCTL_MAGIC, 8, struct JpegDrvDecResult)
#define JPEG_DEC_IOCTL_BREAK \
_IO(JPEG_IOCTL_MAGIC, 9)
#define JPEG_DEC_IOCTL_RW_REG \
_IO(JPEG_IOCTL_MAGIC, 10)
#define JPEG_DEC_IOCTL_RESUME \
_IOW(JPEG_IOCTL_MAGIC, 11, struct JPEG_DEC_CONFIG_ROW)
#define JPEG_DEC_IOCTL_FLUSH_CMDQ \
_IOW(JPEG_IOCTL_MAGIC, 17, struct JPEG_DEC_CONFIG_CMDQ)
#define JPEG_DEC_IOCTL_DUMP_REG \
_IO(JPEG_IOCTL_MAGIC, 30)
#define JPEG_DEC_IOCTL_HYBRID_START \
_IOWR(JPEG_IOCTL_MAGIC, 18, struct JPEG_DEC_DRV_HYBRID_TASK)
#define JPEG_DEC_IOCTL_HYBRID_WAIT \
_IOWR(JPEG_IOCTL_MAGIC, 19, struct JPEG_DEC_DRV_HYBRID_P_N_S)
#define JPEG_DEC_IOCTL_HYBRID_GET_PROGRESS_STATUS \
_IOWR(JPEG_IOCTL_MAGIC, 20, struct JPEG_DEC_DRV_HYBRID_P_N_S)
/* /////////////////// JPEG ENC IOCTL ///////////////////////////////////// */
#define JPEG_ENC_IOCTL_INIT \
_IO(JPEG_IOCTL_MAGIC, 11)
#define JPEG_ENC_IOCTL_CONFIG \
_IOW(JPEG_IOCTL_MAGIC, 12, struct JPEG_ENC_DRV_IN)
#define JPEG_ENC_IOCTL_WAIT \
_IOWR(JPEG_IOCTL_MAGIC, 13, struct JPEG_ENC_DRV_OUT)
#define JPEG_ENC_IOCTL_DEINIT \
_IO(JPEG_IOCTL_MAGIC, 14)
#define JPEG_ENC_IOCTL_START \
_IO(JPEG_IOCTL_MAGIC, 15)
#define JPEG_ENC_IOCTL_WARM_RESET \
_IO(JPEG_IOCTL_MAGIC, 20)
#define JPEG_ENC_IOCTL_DUMP_REG \
_IO(JPEG_IOCTL_MAGIC, 21)
#define JPEG_ENC_IOCTL_RW_REG \
_IO(JPEG_IOCTL_MAGIC, 22)
#ifdef CONFIG_COMPAT
#define COMPAT_JPEG_DEC_IOCTL_WAIT \
_IOWR(JPEG_IOCTL_MAGIC, 5, struct compat_JPEG_DEC_DRV_OUT)
#define COMPAT_JPEG_DEC_IOCTL_CHKSUM \
_IOWR(JPEG_IOCTL_MAGIC, 8, struct compat_JpegDrvDecResult)
#define COMPAT_JPEG_ENC_IOCTL_WAIT \
_IOWR(JPEG_IOCTL_MAGIC, 13, struct compat_JPEG_ENC_DRV_OUT)
#define COMPAT_JPEG_DEC_IOCTL_HYBRID_START \
_IOWR(JPEG_IOCTL_MAGIC, 18, struct compat_JPEG_DEC_DRV_HYBRID_TASK)
#define COMPAT_JPEG_DEC_IOCTL_HYBRID_WAIT \
_IOWR(JPEG_IOCTL_MAGIC, 19, struct compat_JPEG_DEC_DRV_HYBRID_P_N_S)
#define COMPAT_JPEG_DEC_IOCTL_HYBRID_GET_PROGRESS_STATUS \
_IOWR(JPEG_IOCTL_MAGIC, 20, struct compat_JPEG_DEC_DRV_HYBRID_P_N_S)
#endif
#endif
@@ -0,0 +1,198 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __JPEG_DRV_COMMON_H__
#define __JPEG_DRV_COMMON_H__
/* #include <mach/mt_typedefs.h> */
/* #include <mach/typedefs.h> */
#include "jpeg_drv.h"
#include <ion_drv.h>
extern unsigned int _jpeg_enc_int_status;
extern unsigned int _jpeg_dec_int_status;
extern unsigned int _jpeg_hybrid_dec_int_status[HW_CORE_NUMBER];
extern unsigned int _jpeg_dec_mode;
enum JpegDrvEncYUVFormat {
YUYV,
YVYU,
NV12,
NV21
};
enum JpegDrvEncQuality {
Q60 = 0x0,
Q80 = 0x1,
Q90 = 0x2,
Q95 = 0x3,
Q39 = 0x4,
Q68 = 0x5,
Q84 = 0x6,
Q92 = 0x7,
Q48 = 0x9,
Q74 = 0xA,
Q87 = 0xB,
Q34 = 0xD,
Q64 = 0xE,
Q82 = 0xF,
Q_ALL = 0x10
};
struct JpegDrvEncSrcCfg {
unsigned int width;
unsigned int height;
unsigned int yuv_format;
unsigned int luma_addr;
unsigned int chroma_addr;
};
struct JpegDrvEncDstCfg {
unsigned int exif_en; /* 0:JPG mode, 1:JFIF/EXIF mode */
unsigned int dst_addr;
unsigned int dst_size;
unsigned int offset_addr;
unsigned int byte_offset_mask;
};
struct JpegDrvEncCtrlCfg {
unsigned int quality;
unsigned int restart_interval;
unsigned int gmc_disable; /* HW not support */
};
#define JPEG_DRV_ENC_YUYV (0x00 << 3)
#define JPEG_DRV_ENC_YVYU (0x01 << 3)
#define JPEG_DRV_ENC_NV12 (0x02 << 3)
#define JPEG_DRV_ENC_NV21 (0x03 << 3)
#define JPEG_MSG pr_info
#define JPEG_WRN pr_info
#define JPEG_ERR pr_info
#define JPEG_VEB pr_info
#define JPEG_LOG(level, format, args...) \
do { \
if ((jpg_dbg_level & level) == level) \
pr_info("[JPEG] level=%d %s(),%d: " format "\n",\
level, __func__, __LINE__, ##args); \
} while (0)
/* /////// JPEG Driver Decoder /////// */
/* */
/* */
void jpeg_drv_dec_power_on(void);
void jpeg_drv_dec_power_off(void);
unsigned int jpeg_drv_dec_set_config_data(struct JPEG_DEC_DRV_IN *config);
unsigned int jpeg_drv_dec_set_dst_bank0(
unsigned int addr_Y,
unsigned int addr_U,
unsigned int addr_V);
void jpeg_drv_dec_verify_state_and_reset(void);
void jpeg_drv_dec_reset(void);
void jpeg_drv_dec_warm_reset(void);
void jpeg_drv_dec_start(void);
int jpeg_drv_dec_wait(struct JPEG_DEC_DRV_IN *config);
void jpeg_drv_dec_dump_key_reg(void);
void jpeg_drv_dec_dump_reg(void);
int jpeg_drv_dec_break(void);
unsigned int jpeg_drv_dec_set_pause_mcu_idx(unsigned int McuIdx);
void jpeg_drv_dec_resume(unsigned int resume);
unsigned int jpeg_drv_dec_get_result(void);
/* ///// JPEG Driver Encoder /////// */
void jpeg_drv_enc_power_on(void);
void jpeg_drv_enc_power_off(void);
unsigned int jpeg_drv_enc_src_cfg(struct JpegDrvEncSrcCfg srcCfg);
unsigned int jpeg_drv_enc_dst_buff(struct JpegDrvEncDstCfg dstCfg);
unsigned int jpeg_drv_enc_ctrl_cfg(unsigned int exif_en, unsigned int quality,
unsigned int restart_interval);
void jpeg_drv_enc_verify_state_and_reset(void);
void jpeg_drv_enc_reset(void);
unsigned int jpeg_drv_enc_warm_reset(void);
void jpeg_drv_enc_start(void);
unsigned int jpeg_drv_enc_set_quality(unsigned int quality);
unsigned int jpeg_drv_enc_set_img_size(unsigned int width, unsigned int height);
unsigned int jpeg_drv_enc_set_blk_num(unsigned int blk_num);
unsigned int jpeg_drv_enc_set_luma_addr(dma_addr_t src_luma_addr);
unsigned int jpeg_drv_enc_set_chroma_addr(dma_addr_t src_luma_addr);
unsigned int jpeg_drv_enc_set_memory_stride(unsigned int mem_stride);
unsigned int jpeg_drv_enc_set_image_stride(unsigned int img_stride);
void jpeg_drv_enc_set_restart_interval(unsigned int restart_interval);
unsigned int jpeg_drv_enc_set_offset_addr(unsigned int offset);
/* 0:JPG mode, 1:JFIF/EXIF mode */
void jpeg_drv_enc_set_EncodeMode(unsigned int exif_en);
void jpeg_drv_enc_set_burst_type(unsigned int burst_type);
unsigned int jpeg_drv_enc_set_dst_buff(
struct ion_client *pIonClient,
int dstFd,
unsigned int stall_size,
unsigned int init_offset,
unsigned int offset_mask);
unsigned int jpeg_drv_enc_set_sample_format_related(
unsigned int width,
unsigned int height,
unsigned int yuv_format);
unsigned int jpeg_drv_enc_get_file_size(void);
unsigned int jpeg_drv_enc_get_result(unsigned int *fileSize);
unsigned int jpeg_drv_enc_get_cycle_count(void);
void jpeg_drv_enc_dump_reg(void);
unsigned int jpeg_drv_enc_rw_reg(void);
void jpegenc_drv_enc_remove_bw_request(void);
void jpeg_drv_enc_prepare_bw_request(void);
void jpegenc_drv_enc_update_bw_request(struct JPEG_ENC_DRV_IN cfgEnc);
int jpeg_isr_enc_lisr(void);
int jpeg_isr_dec_lisr(void);
int jpeg_isr_hybrid_dec_lisr(int id);
int jpeg_drv_hybrid_dec_start(unsigned int data[],
unsigned int id,
int *index_buf_fd);
void jpeg_drv_hybrid_dec_get_p_n_s(unsigned int id,
int *progress_n_status);
unsigned int jpeg_drv_enc_set_src_image(
unsigned int width,
unsigned int height,
unsigned int yuv_format,
unsigned int totalEncDU);
unsigned int jpeg_drv_enc_set_src_buf(
struct ion_client *pIonClient,
unsigned int yuv_format,
unsigned int img_stride,
unsigned int mem_stride,
unsigned int mem_height,
int srcFd,
int srcFd2);
unsigned int jpeg_drv_enc_set_encFormat(unsigned int encFormat);
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,644 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifdef JPEG_ENC_DRIVER
#include <linux/kernel.h>
/* #include <linux/xlog.h> */
#include "jpeg_drv_reg.h"
#include "jpeg_drv_common.h"
#define JPEG_ENC_RST_BIT 0x1
#define JPEG_ENC_CTRL_ENABLE_BIT 0x01
#define JPEG_ENC_CTRL_DIS_GMC_BIT 0x02
#define JPEG_ENC_CTRL_INT_EN_BIT 0x04
#define JPEG_ENC_CTRL_YUV_BIT 0x18
#define JPEG_ENC_CTRL_FILE_FORMAT_BIT 0x20
#define JPEG_ENC_CTRL_GRAY_EN_BIT 0x80
#define JPEG_ENC_CTRL_ULTRA_HIGH_EN_BIT 0x200
#define JPEG_ENC_CTRL_RESTART_EN_BIT 0x400
#define JPEG_ENC_CTRL_BURST_TYPE_MASK 0x00007000
#define JPEG_ENC_CTRL_BURST_TYPE_SHIFT_COUNT 12
#define JPEG_ENC_EN_DIS_GMC (1 << 2)
#define JPEG_ENC_EN_JFIF_EXIF (1 << 5)
#define JPEG_ENC_EN_SELF_INIT (1 << 16)
#define JPEG_ENC_DEBUG_INFO0_GMC_IDLE_MASK (1 << 13)
unsigned int _jpeg_enc_int_status;
static struct ion_handle *jpeg_ion_import_handle(struct ion_client *client, int fd)
{
struct ion_handle *handle = NULL;
struct ion_mm_data mm_data;
/* If no need Ion support, do nothing! */
if (fd < 0) {
JPEG_MSG("NO NEED ion support, fd %d\n", fd);
return handle;
}
if (!client) {
JPEG_MSG("invalid ion client!\n");
return handle;
}
handle = ion_import_dma_buf_fd(client, fd);
if (IS_ERR(handle)) {
JPEG_MSG("import ion handle failed!\n");
return NULL;
}
mm_data.mm_cmd = ION_MM_CONFIG_BUFFER;
mm_data.config_buffer_param.kernel_handle = handle;
mm_data.config_buffer_param.module_id = 0;
mm_data.config_buffer_param.security = 0;
mm_data.config_buffer_param.coherent = 0;
if (ion_kernel_ioctl(client, ION_CMD_MULTIMEDIA,
(unsigned long)&mm_data))
JPEG_MSG("configure ion buffer failed!\n");
JPEG_MSG("import ion handle fd=%d,hnd=0x%p\n", fd, handle);
return handle;
}
static int jpeg_ion_get_mva(struct ion_client *client, struct ion_handle *handle,
dma_addr_t *mva, unsigned int *size, int port)
{
struct ion_mm_data mm_data;
size_t mva_size = 0;
ion_phys_addr_t phy_addr = 0;
memset((void *)&mm_data, 0, sizeof(struct ion_mm_data));
mm_data.config_buffer_param.module_id = port;
mm_data.config_buffer_param.kernel_handle = handle;
mm_data.mm_cmd = ION_MM_CONFIG_BUFFER;
if (ion_kernel_ioctl(client, ION_CMD_MULTIMEDIA,
(unsigned long)&mm_data) < 0) {
JPEG_MSG("config buffer failed.%p -%p\n",
client, handle);
ion_free(client, handle);
return -1;
}
ion_phys(client, handle, &phy_addr, &mva_size);
*mva = phy_addr;
*size = mva_size;
JPEG_MSG("alloc mmu addr hnd=0x%p,mva=0x%p size %d\n",
handle, *mva, *size);
return 0;
}
static void jpeg_ion_free_handle(struct ion_client *client, struct ion_handle *handle)
{
if (!client) {
JPEG_MSG("invalid ion client!\n");
return;
}
if (!handle)
return;
ion_free(client, handle);
JPEG_MSG("free ion handle 0x%p\n", handle);
}
int jpeg_isr_enc_lisr(void)
{
unsigned int tmp, tmp1;
/* _jpeg_enc_int_status = REG_JPEG_ENC_INTERRUPT_STATUS; */
tmp1 = IMG_REG_READ(REG_ADDR_JPEG_ENC_INTERRUPT_STATUS);
tmp = tmp1 & (JPEG_DRV_ENC_INT_STATUS_MASK_ALLIRQ);
if (tmp) {
_jpeg_enc_int_status = tmp;
/* / clear the interrupt status register */
/* if(_jpeg_enc_int_status) */
/* { */
IMG_REG_WRITE(0, REG_ADDR_JPEG_ENC_INTERRUPT_STATUS);
return 0;
/* } */
} else if (_jpeg_enc_int_status) {
IMG_REG_WRITE(0, REG_ADDR_JPEG_ENC_INTERRUPT_STATUS);
return 0;
}
return -1;
}
unsigned int jpeg_drv_enc_set_src_image(
unsigned int width,
unsigned int height,
unsigned int yuv_format,
unsigned int totalEncDU)
{
unsigned int ret = 1;
ret &= jpeg_drv_enc_set_img_size(width, height);
ret &= jpeg_drv_enc_set_encFormat(yuv_format);
ret &= jpeg_drv_enc_set_blk_num(totalEncDU);
return ret;
}
unsigned int jpeg_drv_enc_set_src_buf(struct ion_client *pIonClient,
unsigned int yuv_format, unsigned int img_stride,
unsigned int mem_stride, unsigned int mem_height,
int srcFd, int srcFd2)
{
unsigned int ret = 1;
dma_addr_t srcAddr = 0;
dma_addr_t srcAddr_C = 0;
unsigned int bufSize = 0;
struct ion_handle *handle = NULL;
if (yuv_format == 0x00 || yuv_format == 0x01) {
if ((mem_stride & 0x1f) || (img_stride & 0x1f)) {
JPEG_MSG
("JPGENC:imag/mem stride not align fmt %x(%x/%x)\n",
yuv_format, mem_stride, img_stride);
ret = 0;
}
}
if (yuv_format == YUYV || yuv_format == YVYU) {
handle = jpeg_ion_import_handle(pIonClient, srcFd);
if (handle == NULL) {
JPEG_MSG("import handle fail line %d\n", __LINE__);
return 0;
}
if (jpeg_ion_get_mva(pIonClient, handle, &srcAddr, &bufSize, 0) != 0)
return 0;
jpeg_ion_free_handle(pIonClient, handle);
srcAddr_C = 0;
JPEG_MSG("srcAddr 0x%p srcAddr_C 0x%p line %d\n", srcAddr, srcAddr_C, __LINE__);
} else if (srcFd == srcFd2) {
handle = jpeg_ion_import_handle(pIonClient, srcFd);
if (handle == NULL) {
JPEG_MSG("import handle fail line %d\n", __LINE__);
return 0;
}
if (jpeg_ion_get_mva(pIonClient, handle, &srcAddr, &bufSize, 0) != 0)
return 0;
jpeg_ion_free_handle(pIonClient, handle);
srcAddr_C = (dma_addr_t)mem_stride*mem_height + srcAddr;
JPEG_MSG("srcAddr 0x%p srcAddr_C 0x%p line %d\n", srcAddr, srcAddr_C, __LINE__);
} else {
handle = jpeg_ion_import_handle(pIonClient, srcFd);
if (handle == NULL) {
JPEG_MSG("import handle fail line %d\n", __LINE__);
return 0;
}
if (jpeg_ion_get_mva(pIonClient, handle, &srcAddr, &bufSize, 0) != 0)
return 0;
jpeg_ion_free_handle(pIonClient, handle);
handle = jpeg_ion_import_handle(pIonClient, srcFd2);
if (handle == NULL) {
JPEG_MSG("import handle fail line %d\n", __LINE__);
return 0;
}
if (jpeg_ion_get_mva(pIonClient, handle, &srcAddr_C, &bufSize, 0) != 0)
return 0;
jpeg_ion_free_handle(pIonClient, handle);
JPEG_MSG("srcAddr 0x%p srcAddr_C 0x%p line %d\n", srcAddr, srcAddr_C, __LINE__);
}
ret &= jpeg_drv_enc_set_image_stride(img_stride);
ret &= jpeg_drv_enc_set_memory_stride(mem_stride);
ret &= jpeg_drv_enc_set_luma_addr(srcAddr);
ret &= jpeg_drv_enc_set_chroma_addr(srcAddr_C);
return ret;
}
unsigned int jpeg_drv_enc_ctrl_cfg(unsigned int exif_en, unsigned int quality,
unsigned int restart_interval)
{
jpeg_drv_enc_set_quality(quality);
jpeg_drv_enc_set_restart_interval(restart_interval);
jpeg_drv_enc_set_EncodeMode(exif_en);
return 1;
}
void jpeg_drv_enc_dump_reg(void)
{
unsigned int reg_value = 0;
unsigned int index = 0;
JPEG_MSG("===== JPEG ENC DUMP =====\n");
for (index = 0x100; index < JPEG_ENC_REG_COUNT; index += 4) {
/* reg_value = ioread32(JPEG_ENC_BASE + index); */
reg_value = IMG_REG_READ(JPEG_ENC_BASE + index);
JPEG_MSG("+0x%x 0x%08x\n", index, reg_value);
}
}
void jpeg_drv_enc_start(void)
{
unsigned int u4Value;
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
u4Value |= (JPEG_ENC_CTRL_INT_EN_BIT | JPEG_ENC_CTRL_ENABLE_BIT);
/* REG_JPEG_ENC_CTRL |= */
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
/*(JPEG_ENC_CTRL_INT_EN_BIT | JPEG_ENC_CTRL_ENABLE_BIT); */
}
/* workaround for jpeg odd read operation at cg gating state */
void jpeg_drv_enc_verify_state_and_reset(void)
{
unsigned int temp, value;
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_RSTB);
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_RSTB);
IMG_REG_WRITE((1), REG_ADDR_JPEG_ENC_RSTB);
IMG_REG_WRITE((1), REG_ADDR_JPEG_ENC_RSTB);
temp = IMG_REG_READ(REG_ADDR_JPEG_ENC_ULTRA_THRES);
value = IMG_REG_READ(REG_ADDR_JPEG_ENC_DMA_ADDR0);
/* issue happen, need to do 1 read at cg gating state */
if (value == 0xFFFFFFFF) {
JPEG_MSG("JPGENC APB R/W issue found, start to do recovery!\n");
jpeg_drv_enc_power_off();
value = IMG_REG_READ(REG_ADDR_JPEG_ENC_ULTRA_THRES);
jpeg_drv_enc_power_on();
}
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_CODEC_SEL);
_jpeg_enc_int_status = 0;
}
void jpeg_drv_enc_reset(void)
{
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_RSTB);
IMG_REG_WRITE((1), REG_ADDR_JPEG_ENC_RSTB);
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_CODEC_SEL);
_jpeg_enc_int_status = 0;
}
unsigned int jpeg_drv_enc_warm_reset(void)
{
unsigned int timeout = 0xFFFFF;
unsigned int u4Value;
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
u4Value &= ~JPEG_ENC_CTRL_ENABLE_BIT;
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
u4Value |= JPEG_ENC_CTRL_ENABLE_BIT;
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
while (0 ==
(IMG_REG_READ(REG_ADDR_JPEG_ENC_DEBUG_INFO0) &
JPEG_ENC_DEBUG_INFO0_GMC_IDLE_MASK)) {
timeout--;
if (timeout == 0) {
JPEG_MSG("Wait for GMC IDLE timeout\n");
return 0;
}
}
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_RSTB);
u4Value &= ~(JPEG_ENC_RST_BIT);
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_RSTB);
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_RSTB);
u4Value |= JPEG_ENC_RST_BIT;
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_RSTB);
IMG_REG_WRITE((0), REG_ADDR_JPEG_ENC_CODEC_SEL);
_jpeg_enc_int_status = 0;
return 1;
}
unsigned int jpeg_drv_enc_set_encFormat(unsigned int encFormat)
{
unsigned int val;
unsigned int u4Value;
if (encFormat & (~3)) {
JPEG_ERR("JPEG_DRV_ENC: set encFormat Err %d!!\n", encFormat);
return 0;
}
val = (encFormat & 3) << 3;
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
u4Value &= ~JPEG_ENC_CTRL_YUV_BIT;
u4Value |= val;
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
return 1;
}
unsigned int jpeg_drv_enc_set_quality(unsigned int quality)
{
unsigned int u4Value;
if (quality == 0x8 || quality == 0xC) {
JPEG_MSG("JPEGENC: set quality failed\n");
return 0;
}
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_QUALITY);
u4Value = (u4Value & 0xFFFF0000) | quality;
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_QUALITY);
return 1;
}
unsigned int jpeg_drv_enc_set_img_size(unsigned int width, unsigned int height)
{
unsigned int u4Value;
if ((width & 0xffff0000) || (height & 0xffff0000)) {
JPEG_MSG("JPGENC: img size exceed 65535, (%x, %x)\n",
width,
height);
return 0;
}
u4Value = (width << 16) | height;
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_IMG_SIZE);
return 1;
}
unsigned int jpeg_drv_enc_set_blk_num(unsigned int blk_num) /* NO_USE */
{
if (blk_num < 4)
return 0;
IMG_REG_WRITE((blk_num), REG_ADDR_JPEG_ENC_BLK_NUM);
return 1;
}
unsigned int jpeg_drv_enc_set_luma_addr(dma_addr_t src_luma_addr)
{
if (src_luma_addr & 0x0F)
JPEG_MSG("JPGENC: set LUMA addr not align (%x)\n",
src_luma_addr);
IMG_REG_WRITE((src_luma_addr), REG_ADDR_JPEG_ENC_SRC_LUMA_ADDR);
return 1;
}
unsigned int jpeg_drv_enc_set_chroma_addr(dma_addr_t src_chroma_addr)
{
if (src_chroma_addr & 0x0F)
JPEG_MSG("JPGENC: set CHROMA addr not align (%x)\n",
src_chroma_addr);
IMG_REG_WRITE((src_chroma_addr), REG_ADDR_JPEG_ENC_SRC_CHROMA_ADDR);
return 1;
}
unsigned int jpeg_drv_enc_set_memory_stride(unsigned int mem_stride)
{
if (mem_stride & 0x0F) {
JPEG_MSG("JPGENC:memory stride not align to 0x1f (%x)\n",
mem_stride);
return 0;
}
IMG_REG_WRITE((mem_stride), REG_ADDR_JPEG_ENC_STRIDE);
return 1;
}
unsigned int jpeg_drv_enc_set_image_stride(unsigned int img_stride)
{
if (img_stride & 0x0F) {
JPEG_MSG("JPGENC: image stride not align to 0x0f (%x)\n",
img_stride);
return 0;
}
IMG_REG_WRITE((img_stride), REG_ADDR_JPEG_ENC_IMG_STRIDE);
return 1;
}
void jpeg_drv_enc_set_restart_interval(unsigned int restart_interval)
{
unsigned int u4Value;
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
if (restart_interval != 0) {
u4Value |= JPEG_ENC_CTRL_RESTART_EN_BIT;
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
} else {
u4Value &= ~JPEG_ENC_CTRL_RESTART_EN_BIT;
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
}
IMG_REG_WRITE((restart_interval), REG_ADDR_JPEG_ENC_RST_MCU_NUM);
}
unsigned int jpeg_drv_enc_set_offset_addr(unsigned int offset)
{
if (offset & 0x0F) {
JPEG_MSG("JPEGENC:WARN set offset addr %x\n", offset);
/* return 0; */
}
IMG_REG_WRITE((offset), REG_ADDR_JPEG_ENC_OFFSET_ADDR);
return 1;
}
unsigned int jpeg_drv_enc_set_dst_buff(struct ion_client *pIonClient,
int dstFd, unsigned int stall_size,
unsigned int init_offset, unsigned int offset_mask)
{
struct ion_handle *handle = NULL;
dma_addr_t dst_addr = 0;
unsigned int bufSize = 0;
if (stall_size < 624) {
JPEG_MSG("JPGENC:stall size less than 624 to write %d\n",
stall_size);
return 0;
}
if (offset_mask & 0x0F) {
JPEG_MSG("JPEGENC: set offset addr %x\n", offset_mask);
/* return 0; */
}
handle = jpeg_ion_import_handle(pIonClient, dstFd);
if (handle == NULL) {
JPEG_MSG("import handle fail line %d\n", __LINE__);
return 0;
}
if (jpeg_ion_get_mva(pIonClient, handle, &dst_addr, &bufSize, 0) != 0)
return 0;
jpeg_ion_free_handle(pIonClient, handle);
if (init_offset >= bufSize) {
JPEG_MSG("invalid offset %d bufsize %d line %d\n", init_offset, bufSize, __LINE__);
return 0;
}
dst_addr += init_offset;
JPEG_MSG("dst_addr 0x%p offset 0x%x line %d\n", dst_addr, init_offset, __LINE__);
IMG_REG_WRITE((0 & (~0xF)), REG_ADDR_JPEG_ENC_OFFSET_ADDR);
IMG_REG_WRITE((offset_mask & 0xF), REG_ADDR_JPEG_ENC_BYTE_OFFSET_MASK);
IMG_REG_WRITE((dst_addr & (~0xF)), REG_ADDR_JPEG_ENC_DST_ADDR0);
IMG_REG_WRITE(((dst_addr + stall_size) & (~0xF)),
REG_ADDR_JPEG_ENC_STALL_ADDR0);
return 1;
}
/* 0:JPG mode, 1:JFIF/EXIF mode */
void jpeg_drv_enc_set_EncodeMode(unsigned int exif_en)
{
unsigned int u4Value;
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
u4Value &= ~(JPEG_ENC_CTRL_FILE_FORMAT_BIT);
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
if (exif_en) {
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
u4Value |= JPEG_ENC_EN_JFIF_EXIF;
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
}
}
void jpeg_drv_enc_set_gmc_disable_bit(void)
{
unsigned int u4Value;
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
u4Value |= JPEG_ENC_EN_DIS_GMC;
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
}
void jpeg_drv_enc_set_burst_type(unsigned int burst_type)
{
unsigned int u4Value;
u4Value = IMG_REG_READ(REG_ADDR_JPEG_ENC_CTRL);
u4Value &= ~JPEG_ENC_CTRL_BURST_TYPE_MASK;
u4Value |= (burst_type << JPEG_ENC_CTRL_BURST_TYPE_SHIFT_COUNT);
IMG_REG_WRITE((u4Value), REG_ADDR_JPEG_ENC_CTRL);
}
unsigned int jpeg_drv_enc_get_cycle_count(void)
{
return IMG_REG_READ(REG_ADDR_JPEG_ENC_TOTAL_CYCLE);
}
unsigned int jpeg_drv_enc_get_file_size(void)
{
unsigned int u4DMA_Addr0;
unsigned int u4DST_Addr0;
u4DMA_Addr0 = IMG_REG_READ(REG_ADDR_JPEG_ENC_DMA_ADDR0);
u4DST_Addr0 = IMG_REG_READ(REG_ADDR_JPEG_ENC_DST_ADDR0);
return (u4DMA_Addr0 - u4DST_Addr0);
/* return REG_JPEG_ENC_CURR_DMA_ADDR - REG_JPEG_ENC_DST_ADDR0; */
}
#ifdef FPGA_VERSION
unsigned int jpeg_drv_enc_get_result(void)
{
unsigned int file_size;
file_size = jpeg_drv_enc_get_file_size();
return file_size;
}
#else
unsigned int jpeg_drv_enc_get_result(unsigned int *fileSize)
{
*fileSize = jpeg_drv_enc_get_file_size();
if (_jpeg_enc_int_status & JPEG_DRV_ENC_INT_STATUS_DONE)
return 0;
else if (_jpeg_enc_int_status & JPEG_DRV_ENC_INT_STATUS_STALL)
return 1;
else if (_jpeg_enc_int_status & JPEG_DRV_ENC_INT_STATUS_VCODEC_IRQ)
return 2;
JPEG_MSG("JPEGENC: int_st %x!!\n", _jpeg_enc_int_status);
return 3;
}
#endif
#endif
@@ -0,0 +1,183 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __JPEG_DRV_REG_H__
#define __JPEG_DRV_REG_H__
/* #include <mach/mt_reg_base.h> */
/* #include <mach/sync_write.h> */
#include <mt-plat/sync_write.h>
#include <linux/io.h>
#include "jpeg_drv.h"
#define JPEG_ENC_BASE jpeg_dev_get_encoder_base_VA()
#define JPEG_DEC_BASE jpeg_dev_get_decoder_base_VA()
#define JPEG_HYBRID_DEC_BASE(i) jpeg_dev_get_hybrid_decoder_base_VA(i)
#define IMG_REG_WRITE(v, a) writel(v, (void __iomem *)a)
#define IMG_REG_READ(a) readl((void __iomem *)a)
#define JPEG_ENC_REG_COUNT 0x31C
/********************************************************************/
/* define JPEG Encoder Registers register field*/
/********************************************************************/
#define JPEG_DRV_ENC_INT_STATUS_DONE 0x01
#define JPEG_DRV_ENC_INT_STATUS_STALL 0x02
#define JPEG_DRV_ENC_INT_STATUS_VCODEC_IRQ 0x10
#define JPEG_DRV_ENC_INT_STATUS_MASK_ALLIRQ 0x13
#define JPEG_DRV_DEC_INT_STATUS_DEC_ERR 0x04
/********************************************************************/
/* The following registers are for JPEG Encoder Registers on MT6589 */
/********************************************************************/
#define REG_ADDR_JPEG_ENC_RSTB (JPEG_ENC_BASE + 0x100)
#define REG_ADDR_JPEG_ENC_CTRL (JPEG_ENC_BASE + 0x104)
#define REG_ADDR_JPEG_ENC_QUALITY (JPEG_ENC_BASE + 0x108)
#define REG_ADDR_JPEG_ENC_BLK_NUM (JPEG_ENC_BASE + 0x10C)
#define REG_ADDR_JPEG_ENC_BLK_CNT (JPEG_ENC_BASE + 0x110)
#define REG_ADDR_JPEG_ENC_INTERRUPT_STATUS (JPEG_ENC_BASE + 0x11C)
#define REG_ADDR_JPEG_ENC_DST_ADDR0 (JPEG_ENC_BASE + 0x120)
#define REG_ADDR_JPEG_ENC_DMA_ADDR0 (JPEG_ENC_BASE + 0x124)
#define REG_ADDR_JPEG_ENC_STALL_ADDR0 (JPEG_ENC_BASE + 0x128)
#define REG_ADDR_JPEG_ENC_OFFSET_ADDR (JPEG_ENC_BASE + 0x138)
#define REG_ADDR_JPEG_ENC_CURR_DMA_ADDR (JPEG_ENC_BASE + 0x13C)
#define REG_ADDR_JPEG_ENC_RST_MCU_NUM (JPEG_ENC_BASE + 0x150)
#define REG_ADDR_JPEG_ENC_IMG_SIZE (JPEG_ENC_BASE + 0x154)
#define REG_ADDR_JPEG_ENC_GULTRA_TRESH (JPEG_ENC_BASE + 0x158)
#define REG_ADDR_JPEG_ENC_DEBUG_INFO0 (JPEG_ENC_BASE + 0x160)
#define REG_ADDR_JPEG_ENC_DEBUG_INFO1 (JPEG_ENC_BASE + 0x164)
#define REG_ADDR_JPEG_ENC_TOTAL_CYCLE (JPEG_ENC_BASE + 0x168)
#define REG_ADDR_JPEG_ENC_BYTE_OFFSET_MASK (JPEG_ENC_BASE + 0x16C)
#define REG_ADDR_JPEG_ENC_SRC_LUMA_ADDR (JPEG_ENC_BASE + 0x170)
#define REG_ADDR_JPEG_ENC_SRC_CHROMA_ADDR (JPEG_ENC_BASE + 0x174)
#define REG_ADDR_JPEG_ENC_STRIDE (JPEG_ENC_BASE + 0x178)
#define REG_ADDR_JPEG_ENC_IMG_STRIDE (JPEG_ENC_BASE + 0x17C)
#define REG_ADDR_JPEG_ENC_MEM_CYCLE (JPEG_ENC_BASE + 0x208)
#define REG_ADDR_JPEG_ENC_SMI_DEBUG0 (JPEG_ENC_BASE + 0x304)
#define REG_ADDR_JPEG_ENC_SMI_DEBUG1 (JPEG_ENC_BASE + 0x308)
#define REG_ADDR_JPEG_ENC_SMI_DEBUG2 (JPEG_ENC_BASE + 0x30C)
#define REG_ADDR_JPEG_ENC_SMI_DEBUG3 (JPEG_ENC_BASE + 0x310)
#define REG_ADDR_JPEG_ENC_CODEC_SEL (JPEG_ENC_BASE + 0x314)
#define REG_ADDR_JPEG_ENC_ULTRA_THRES (JPEG_ENC_BASE + 0x318)
#define REG_ADDR_JPEG_ENC_PASS2_RSTB (JPEG_ENC_BASE + 0x800)
/********************************************************************/
/* define JPEG Decoder Registers register field*/
/********************************************************************/
/* REG_JPGDEC_RESET ( JPEG_DEC_BASE + 0x0090 ) */
#define BIT_SOFT_RST_SHIFT 0
#define BIT_HARD_RST_SHIFT 4
/* REG_JPGDEC_BRZ_FACTOR ( JPEG_DEC_BASE + 0x00F8 ) */
#define BIT_BRZ_YH_SHIFT 0
#define BIT_BRZ_YV_SHIFT 4
#define BIT_BRZ_CH_SHIFT 8
#define BIT_BRZ_CV_SHIFT 12
/* REG_JPGDEC_DU_SAMPLE ( JPEG_DEC_BASE + 0x00FC ) */
/* REG_JPGDEC_DEST_ADDR0_Y ( JPEG_DEC_BASE + 0x0140 ) */
/* REG_JPGDEC_DEST_ADDR0_U ( JPEG_DEC_BASE + 0x0144 ) */
/* REG_JPGDEC_DEST_ADDR0_V ( JPEG_DEC_BASE + 0x0148 ) */
/* REG_JPGDEC_DEST_ADDR1_Y ( JPEG_DEC_BASE + 0x014C ) */
/* REG_JPGDEC_DEST_ADDR1_U ( JPEG_DEC_BASE + 0x0150 ) */
/* REG_JPGDEC_DEST_ADDR1_V ( JPEG_DEC_BASE + 0x0154 ) */
/* REG_JPGDEC_STRIDE_Y ( JPEG_DEC_BASE + 0x0158 ) */
/* REG_JPGDEC_STRIDE_UV ( JPEG_DEC_BASE + 0x015C ) */
/* REG_JPGDEC_IMG_STRIDE_Y ( JPEG_DEC_BASE + 0x0160 ) */
/* REG_JPGDEC_IMG_STRIDE_UV ( JPEG_DEC_BASE + 0x0164 ) */
/* REG_JPGDEC_WDMA_CTRL ( JPEG_DEC_BASE + 0x016C ) */
/* REG_JPGDEC_PAUSE_MCU_NUM ( JPEG_DEC_BASE + 0x0170 ) */
/* REG_JPGDEC_OPERATION_MODE ( JPEG_DEC_BASE + 0x017C ) */
/* REG_JPGDEC_DEBUG0 ( JPEG_DEC_BASE + 0x0180 ) */
/* REG_JPGDEC_FILE_ADDR ( JPEG_DEC_BASE + 0x0200 ) */
/* REG_JPGDEC_COMP_ID ( JPEG_DEC_BASE + 0x020C ) */
/* REG_JPGDEC_TOTAL_MCU_NUM ( JPEG_DEC_BASE + 0x0210 ) */
/* REG_JPGDEC_COMP0_DATA_UNIT_NUM ( JPEG_DEC_BASE + 0x0224 ) */
/* REG_JPGDEC_DU_CTRL ( JPEG_DEC_BASE + 0x023C ) */
#define BIT_DU_CTRL_COMP_Y 4
#define BIT_DU_CTRL_COMP_U 5
#define BIT_DU_CTRL_COMP_V 6
#define BIT_DU_CTRL_NOUSE 7
/* REG_JPGDEC_TRIG ( JPEG_DEC_BASE + 0x0240 ) */
/* REG_JPGDEC_FILE_BRP ( JPEG_DEC_BASE + 0x0248 ) */
/* REG_JPGDEC_FILE_TOTAL_SIZE ( JPEG_DEC_BASE + 0x024C ) */
/* REG_JPGDEC_QT_ID ( JPEG_DEC_BASE + 0x0270 ) */
/* REG_JPGDEC_INTERRUPT_STATUS ( JPEG_DEC_BASE + 0x0274 ) */
#define BIT_INQST_MASK_TYPE 0x80000000
#define BIT_INQST_MASK_ERROR_BS 0x20
#define BIT_INQST_MASK_PAUSE 0x10
#define BIT_INQST_MASK_OVERFLOW 0x04
#define BIT_INQST_MASK_UNDERFLOW 0x02
#define BIT_INQST_MASK_EOF 0x01
#define BIT_INQST_MASK_END 0x27
#define BIT_INQST_MASK_ALLIRQ 0x37
#define BIT_DEC_IRQ_EN_DEBUG_BRP_FLAG 0x80
/* REG_JPGDEC_STATUS ( JPEG_DEC_BASE + 0x0278 ) */
#define BIT_DEC_ST_STATE_MASK 0x07000000
#define BIT_DEC_ST_STATE_IDLE 0x00000000
#define BIT_DEC_ST_STATE_DMA 0x01000000
#define BIT_DEC_ST_STATE_HEADER 0x02000000
#define BIT_DEC_ST_STATE_VLD 0x03000000
#define BIT_DEC_ST_STATE_RST 0x04000000
#define BIT_DEC_ST_STATE_PROG 0x05000000
#define BIT_DEC_ST_STATE_IDCT 0x06000000
#define REG_JPGDEC_HYBRID_090(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0090)
#define REG_JPGDEC_HYBRID_0FC(X) (JPEG_HYBRID_DEC_BASE(X) + 0x00FC)
#define REG_JPGDEC_HYBRID_14C(X) (JPEG_HYBRID_DEC_BASE(X) + 0x014C)
#define REG_JPGDEC_HYBRID_150(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0150)
#define REG_JPGDEC_HYBRID_154(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0154)
#define REG_JPGDEC_HYBRID_17C(X) (JPEG_HYBRID_DEC_BASE(X) + 0x017C)
#define REG_JPGDEC_HYBRID_200(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0200)
#define REG_JPGDEC_HYBRID_20C(X) (JPEG_HYBRID_DEC_BASE(X) + 0x020C)
#define REG_JPGDEC_HYBRID_210(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0210)
#define REG_JPGDEC_HYBRID_224(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0224)
#define REG_JPGDEC_HYBRID_23C(X) (JPEG_HYBRID_DEC_BASE(X) + 0x023C)
#define REG_JPGDEC_HYBRID_240(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0240)
#define REG_JPGDEC_HYBRID_24C(X) (JPEG_HYBRID_DEC_BASE(X) + 0x024C)
#define REG_JPGDEC_HYBRID_270(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0270)
#define REG_JPGDEC_HYBRID_274(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0274)
#define REG_JPGDEC_HYBRID_31C(X) (JPEG_HYBRID_DEC_BASE(X) + 0x031C)
#define REG_JPGDEC_HYBRID_330(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0330)
#define REG_JPGDEC_HYBRID_334(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0334)
#define REG_JPGDEC_HYBRID_338(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0338)
#define REG_JPGDEC_HYBRID_33C(X) (JPEG_HYBRID_DEC_BASE(X) + 0x033C)
#define REG_JPGDEC_HYBRID_340(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0340)
#define REG_JPGDEC_HYBRID_344(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0344)
#define REG_JPGDEC_HYBRID_348(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0348)
#define REG_JPGDEC_HYBRID_36C(X) (JPEG_HYBRID_DEC_BASE(X) + 0x036C)
#define REG_JPGDEC_HYBRID_370(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0370)
#define REG_JPGDEC_HYBRID_374(X) (JPEG_HYBRID_DEC_BASE(X) + 0x0374)
#endif /* / __MT6589_JPEG_REG_H__ */
+240
View File
@@ -0,0 +1,240 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#include "jpeg_ion.h"
#include "jpeg_drv_common.h"
#include <ion_drv.h>
#ifdef CONFIG_MTK_IOMMU_V2
#include "mach/mt_iommu.h"
#include "mach/pseudo_m4u.h"
#include <soc/mediatek/smi.h>
#include "mtk_iommu_ext.h"
#include "mtk_ion.h"
#endif
#if defined(CONFIG_MTK_IOMMU_V2)
static struct ion_client *g_jpg_ion_client;
#endif
extern int jpg_dbg_level;
int jpg_ion_get_iova(struct ion_handle *handle,
u64 *iova, int port)
{
#if defined(CONFIG_MTK_IOMMU_V2)
struct ion_mm_data mm_data;
size_t iova_size;
memset((void *)&mm_data, 0, sizeof(struct ion_mm_data));
mm_data.mm_cmd = ION_MM_GET_IOVA;
mm_data.get_phys_param.module_id = port;
mm_data.get_phys_param.kernel_handle = handle;
if (ion_kernel_ioctl(g_jpg_ion_client, ION_CMD_MULTIMEDIA,
(unsigned long)&mm_data) < 0) {
JPEG_LOG(0, "get iova failed.%p -%p\n",
g_jpg_ion_client, handle);
ion_free(g_jpg_ion_client, handle);
return -1;
}
*iova = mm_data.get_phys_param.phy_addr;
iova_size = mm_data.get_phys_param.len;
if (*iova == 0)
JPEG_LOG(0, "alloc mmu addr hnd=0x%p,iova=0x%08lx\n",
handle, *iova);
JPEG_LOG(1, "iova: %llu", *iova);
#endif
return 0;
}
struct ion_handle *jpg_ion_import_handle(int fd)
{
struct ion_handle *handle = NULL;
#if defined(CONFIG_MTK_IOMMU_V2)
/* If no need Ion support, do nothing! */
if (fd <= 0) {
JPEG_LOG(0, "NO NEED ion support, fd %d\n", fd);
return handle;
}
if (!g_jpg_ion_client) {
JPEG_LOG(0, "invalid ion client!");
return handle;
}
handle = ion_import_dma_buf_fd(g_jpg_ion_client, fd);
if (IS_ERR(handle)) {
JPEG_LOG(0, "import ion handle failed!");
return NULL;
}
JPEG_LOG(1, "import ion handle fd=%d, hnd=0x%p", fd, handle);
#endif
return handle;
}
struct ion_handle *jpg_ion_alloc_handle(size_t size, size_t align, unsigned int flags)
{
struct ion_handle *handle = NULL;
#if defined(CONFIG_MTK_IOMMU_V2)
if (!g_jpg_ion_client) {
JPEG_LOG(0, "invalid ion client!");
return handle;
}
handle = ion_alloc(g_jpg_ion_client, size, align, ION_HEAP_MULTIMEDIA_MASK, flags);
if (IS_ERR(handle)) {
JPEG_LOG(0, "alloc ion handle failed!");
return NULL;
}
JPEG_LOG(1, "alloc ion handle hnd=0x%p", handle);
#endif
return handle;
}
int jpg_ion_share_handle(struct ion_handle *handle)
{
int fd = -1;
#if defined(CONFIG_MTK_IOMMU_V2)
if (!g_jpg_ion_client) {
JPEG_LOG(0, "invalid ion client!");
return -1;
}
fd = ion_share_dma_buf_fd(g_jpg_ion_client, handle);
if (fd < 0) {
JPEG_LOG(0, "share ion handle failed!");
return -1;
}
JPEG_LOG(1, "share ion handle hnd=0x%p fd:%d", handle, fd);
#endif
return fd;
}
void *jpg_ion_map_handle(struct ion_handle *handle)
{
void *ptr = NULL;
#if defined(CONFIG_MTK_IOMMU_V2)
if (!g_jpg_ion_client) {
JPEG_LOG(0, "invalid ion client!");
return NULL;
}
ptr = ion_map_kernel(g_jpg_ion_client, handle);
if (ptr == NULL) {
JPEG_LOG(0, "map ion handle failed!");
return NULL;
}
JPEG_LOG(1, "map ion handle hnd=0x%p ptr:%p", handle, ptr);
#endif
return ptr;
}
void jpg_ion_unmap_handle(struct ion_handle *handle)
{
#if defined(CONFIG_MTK_IOMMU_V2)
if (!g_jpg_ion_client) {
JPEG_LOG(0, "invalid ion client!");
return;
}
ion_unmap_kernel(g_jpg_ion_client, handle);
JPEG_LOG(1, "unmap ion handle hnd=0x%p", handle);
#endif
}
void jpg_ion_free_handle(struct ion_handle *handle)
{
#if defined(CONFIG_MTK_IOMMU_V2)
if (!g_jpg_ion_client) {
JPEG_LOG(0, "invalid ion client!");
return;
}
if (!handle)
return;
ion_free(g_jpg_ion_client, handle);
JPEG_LOG(1, "handle 0x%p", handle);
#endif
}
void jpg_ion_cache_flush(struct ion_handle *handle)
{
#if defined(CONFIG_MTK_IOMMU_V2)
struct ion_sys_data sys_data;
void *buffer_va;
if (!g_jpg_ion_client || !handle)
return;
sys_data.sys_cmd = ION_SYS_CACHE_SYNC;
sys_data.cache_sync_param.kernel_handle = handle;
sys_data.cache_sync_param.sync_type = ION_CACHE_INVALID_BY_RANGE;
buffer_va = ion_map_kernel(g_jpg_ion_client, handle);
sys_data.cache_sync_param.va = buffer_va;
sys_data.cache_sync_param.size = handle->buffer->size;
if (ion_kernel_ioctl(g_jpg_ion_client, ION_CMD_SYSTEM,
(unsigned long)&sys_data))
JPEG_LOG(0, "ion cache flush failed!");
ion_unmap_kernel(g_jpg_ion_client, handle);
#endif
}
void jpg_ion_create(const char *name)
{
#if defined(CONFIG_MTK_IOMMU_V2)
if (g_ion_device)
g_jpg_ion_client = ion_client_create(g_ion_device, name);
else
JPEG_LOG(0, "invalid g_ion_device");
if (!g_jpg_ion_client)
JPEG_LOG(0, "create ion client failed!");
#endif
}
void jpg_ion_destroy(void)
{
#if defined(CONFIG_MTK_IOMMU_V2)
if (g_jpg_ion_client && g_ion_device)
ion_client_destroy(g_jpg_ion_client);
#endif
}
u64 jpg_translate_fd(u64 fd, u32 offset, u32 port)
{
struct ion_handle *ion_h;
u64 iova = 0;
/* need to map ion handle and iova */
ion_h = jpg_ion_import_handle(fd);
if (!ion_h)
return 0;
jpg_ion_get_iova(ion_h, &iova, port);
iova += offset;
jpg_ion_free_handle(ion_h);
JPEG_LOG(1, "iova 0x%llx", iova);
return iova;
}
+28
View File
@@ -0,0 +1,28 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __JPEG_ION_H__
#define __JPEG_ION_H__
#ifdef CONFIG_MTK_IOMMU_V2
#include "mach/mt_iommu.h"
#include <soc/mediatek/smi.h>
#endif
#include <ion_priv.h>
void jpg_ion_create(const char *name);
void jpg_ion_destroy(void);
int jpg_ion_get_iova(struct ion_handle *handle,
u64 *iova, int port);
struct ion_handle *jpg_ion_import_handle(int fd);
struct ion_handle *jpg_ion_alloc_handle(size_t size, size_t align, unsigned int flags);
int jpg_ion_share_handle(struct ion_handle *handle);
void *jpg_ion_map_handle(struct ion_handle *handle);
void jpg_ion_unmap_handle(struct ion_handle *handle);
void jpg_ion_free_handle(struct ion_handle *handle);
void jpg_ion_cache_flush(struct ion_handle *handle);
u64 jpg_translate_fd(u64 fd, u32 offset, u32 port);
#endif /*__JPEG_ION_H__*/