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

File diff suppressed because it is too large. Load diff
@@ -0,0 +1,762 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef _MT_DPE_H
#define _MT_DPE_H
#include <linux/ioctl.h>
#if IS_ENABLED(CONFIG_COMPAT)
/* 64 bit */
#include <linux/fs.h>
#include <linux/compat.h>
#endif
/*
* enforce kernel log enable
*/
#define KERNEL_LOG /* enable debug log flag if defined */
#define _SUPPORT_MAX_DPE_FRAME_REQUEST_ 12 // 6
#define _SUPPORT_MAX_DPE_REQUEST_RING_SIZE_ 4
#define SIG_ERESTARTSYS 512 /* ERESTARTSYS */
/*
*
*/
#define DPE_DEV_MAJOR_NUMBER 302
#define DPE_MAGIC 'd'
#define DPE_REG_RANGE (0x1000)
#define DPE_BASE_HW 0x15300000
/*This macro is for setting irq status represnted
* by a local variable,DPEInfo.IrqInfo.Status[DPE_IRQ_TYPE_INT_DPE_ST]
*/
#define DPE_INT_ST (1UL<<31)
// MEDV buffer width size should be 64B align
// All other buffer width size should be 128B align
// Assume max width = 640 should meet above requirements
#define DPE_MAX_FRAME_SIZE 307200 //640x480
#define WB_INT_MEDV_SIZE DPE_MAX_FRAME_SIZE
#define WB_DCV_L_SIZE DPE_MAX_FRAME_SIZE
#define WB_ASFRM_SIZE DPE_MAX_FRAME_SIZE
#define WB_ASFRMExt_SIZE DPE_MAX_FRAME_SIZE
#define WB_WMFHF_SIZE DPE_MAX_FRAME_SIZE
#define WB_TOTAL_SIZE \
(WB_INT_MEDV_SIZE+WB_DCV_L_SIZE+ \
WB_ASFRM_SIZE+WB_ASFRMExt_SIZE+WB_WMFHF_SIZE)
// ----------------- DPE_DVS_ME Grouping Definitions -------------------
struct DVS_ME_CFG {
unsigned int DVS_ME_00; //15300300
unsigned int DVS_ME_01; //15300304
unsigned int DVS_ME_02; //15300308
unsigned int DVS_ME_03; //1530030C
unsigned int DVS_ME_04; //15300310
//unsigned int DVS_ME_05; //15300314
unsigned int DVS_ME_06; //15300318
unsigned int DVS_ME_07; //1530031C
unsigned int DVS_ME_08; //15300320
unsigned int DVS_ME_09; //15300324
unsigned int DVS_ME_10; //15300328
unsigned int DVS_ME_11; //1530032C
unsigned int DVS_ME_12; //15300330
unsigned int DVS_ME_13; //15300334
unsigned int DVS_ME_14; //15300338
unsigned int DVS_ME_15; //1530033C
unsigned int DVS_ME_16; //15300340
unsigned int DVS_ME_17; //15300344
unsigned int DVS_ME_18; //15300348
unsigned int DVS_ME_19; //1530034C
unsigned int DVS_ME_20; //15300350
unsigned int DVS_ME_21; //15300354
unsigned int DVS_ME_22; //15300358
unsigned int DVS_ME_23; //1530035C
unsigned int DVS_ME_24; //15300360
unsigned int DVS_ME_25; //15300364
unsigned int DVS_ME_26; //15300368
unsigned int DVS_ME_27; //1530036C
unsigned int DVS_ME_28; //15300370
unsigned int DVS_ME_29; //15300374
unsigned int DVS_ME_30; //15300378
unsigned int DVS_ME_31; //1530037C
unsigned int DVS_ME_32; //15300380
unsigned int DVS_ME_33; //15300384
unsigned int DVS_ME_34; //15300388
unsigned int DVS_ME_35; //1530038C
unsigned int DVS_ME_36; //15300390
unsigned int DVS_ME_37; //15300394
unsigned int DVS_ME_38; //15300398
unsigned int DVS_ME_39; //1530039C
unsigned int DVS_DEBUG; //153003F4
unsigned int DVS_ME_RESERVED; //153003F8
unsigned int DVS_ME_ATPG; //153003FC
unsigned int DVS_ME_40; //15300400
unsigned int DVS_ME_41; //15300404
};
// ----------------- DPE_DVS_OCC Grouping Definitions -------------------
struct DVS_OCC_CFG {
unsigned int DVS_OCC_PQ_0; //153003A0
unsigned int DVS_OCC_PQ_1; //153003A4
unsigned int DVS_OCC_PQ_2; //153003A8
unsigned int DVS_OCC_PQ_3; //153003AC
unsigned int DVS_OCC_PQ_4; //153003B0
unsigned int DVS_OCC_PQ_5; //153003B4
unsigned int DVS_OCC_PQ_6; //153003B8
unsigned int DVS_OCC_PQ_7; //153003BC
unsigned int DVS_OCC_PQ_8; //153003C0
unsigned int DVS_OCC_PQ_9; //153003C4
unsigned int DVS_OCC_PQ_10; //153003C8
unsigned int DVS_OCC_PQ_11; //153003CC
unsigned int DVS_OCC_ATPG; //153003D0
};
// ----------------- DPE_DVP_CTRL Grouping Definitions -------------------
struct DVP_CORE_CFG {
unsigned int DVP_CORE_00; //15300900
unsigned int DVP_CORE_01; //15300904
unsigned int DVP_CORE_02; //15300908
unsigned int DVP_CORE_03; //1530090C
unsigned int DVP_CORE_04; //15300910
unsigned int DVP_CORE_05; //15300914
unsigned int DVP_CORE_06; //15300918
unsigned int DVP_CORE_07; //1530091C
unsigned int DVP_CORE_08; //15300920
unsigned int DVP_CORE_09; //15300924
unsigned int DVP_CORE_10; //15300928
unsigned int DVP_CORE_11; //1530092C
unsigned int DVP_CORE_12; //15300930
unsigned int DVP_CORE_13; //15300934
unsigned int DVP_CORE_14; //15300938
unsigned int DVP_CORE_15; //1530093C
unsigned int DVP_CORE_16; //15300940
};
// -----------------------------------------------------
struct DPE_REG_STRUCT {
unsigned int module;
unsigned int Addr; /* register's addr */
unsigned int Val; /* register's value */
};
struct DPE_REG_IO_STRUCT {
struct DPE_REG_STRUCT *pData; /* pointer to DPE_REG_STRUCT */
unsigned int Count; /* count */
};
/*
* interrupt clear type
*/
enum DPE_IRQ_CLEAR_ENUM {
DPE_IRQ_CLEAR_NONE, /* non-clear wait, clear after wait */
DPE_IRQ_CLEAR_WAIT, /* clear wait, clear before and after wait */
DPE_IRQ_WAIT_CLEAR,
/* wait the signal and clear it, avoid hw executime is too s hort. */
DPE_IRQ_CLEAR_STATUS, /* clear specific status only */
DPE_IRQ_CLEAR_ALL /* clear all status */
};
/*
* module's interrupt , each module should have its own isr.
* note:
* mapping to isr table,ISR_TABLE when using no device tree
*/
enum DPE_IRQ_TYPE_ENUM {
DPE_IRQ_TYPE_INT_DVP_ST, /* DVP */
DPE_IRQ_TYPE_INT_DVS_ST, /* DVS */
DPE_IRQ_TYPE_AMOUNT
};
struct DPE_WAIT_IRQ_STRUCT {
enum DPE_IRQ_CLEAR_ENUM Clear;
enum DPE_IRQ_TYPE_ENUM Type;
unsigned int Status; /*IRQ Status */
unsigned int Timeout;
int UserKey; /* user key for doing interrupt operation */
int ProcessID; /* user ProcessID (will filled in kernel) */
unsigned int bDumpReg; /* check dump register or not */
};
struct DPE_CLEAR_IRQ_STRUCT {
enum DPE_IRQ_TYPE_ENUM Type;
int UserKey; /* user key for doing interrupt operation */
unsigned int Status; /* Input */
};
struct DPE_Kernel_Config {
unsigned int DVS_CTRL00;
unsigned int DVS_CTRL01;
unsigned int DVS_CTRL02;
unsigned int DVS_CTRL03;
// unsigned int DVS_CTRL04;
// unsigned int DVS_CTRL05;
unsigned int DVS_CTRL06;
unsigned int DVS_CTRL07;
unsigned int DVS_IRQ_00;
unsigned int DVS_CTRL_STATUS0;
// unsigned int DVS_CTRL_STATUS1;
unsigned int DVS_CTRL_STATUS2;
unsigned int DVS_IRQ_STATUS;
unsigned int DVS_FRM_STATUS0;
unsigned int DVS_FRM_STATUS1;
// unsigned int DVS_FRM_STATUS2;
// unsigned int DVS_FRM_STATUS3;
unsigned int DVS_CUR_STATUS;
unsigned int DVS_SRC_CTRL;
unsigned int DVS_CRC_CTRL;
unsigned int DVS_CRC_IN;
unsigned int DVS_DRAM_STA0;
unsigned int DVS_DRAM_STA1;
unsigned int DVS_DRAM_ULT;
unsigned int DVS_DRAM_PITCH;
unsigned int DVS_SRC_00;
unsigned int DVS_SRC_01;
unsigned int DVS_SRC_02;
unsigned int DVS_SRC_03;
unsigned int DVS_SRC_04;
unsigned int DVS_SRC_05_L_FRM0;
unsigned int DVS_SRC_06_L_FRM1;
unsigned int DVS_SRC_07_L_FRM2;
unsigned int DVS_SRC_08_L_FRM3;
unsigned int DVS_SRC_09_R_FRM0;
unsigned int DVS_SRC_10_R_FRM1;
unsigned int DVS_SRC_11_R_FRM2;
unsigned int DVS_SRC_12_R_FRM3;
unsigned int DVS_SRC_13_L_VMAP0;
unsigned int DVS_SRC_14_L_VMAP1;
unsigned int DVS_SRC_15_L_VMAP2;
unsigned int DVS_SRC_16_L_VMAP3;
unsigned int DVS_SRC_17_R_VMAP0;
unsigned int DVS_SRC_18_R_VMAP1;
unsigned int DVS_SRC_19_R_VMAP2;
unsigned int DVS_SRC_20_R_VMAP3;
unsigned int DVS_SRC_21_P4_L_DV_ADR;
unsigned int DVS_SRC_26_OCCDV0;
unsigned int DVS_SRC_27_OCCDV1;
unsigned int DVS_SRC_28_OCCDV2;
unsigned int DVS_SRC_29_OCCDV3;
unsigned int DVS_SRC_34_P4_R_DV_ADR;
unsigned int DVS_SRC_42_OCCDV_EXT0;
unsigned int DVS_SRC_43_OCCDV_EXT1;
unsigned int DVS_SRC_44_OCCDV_EXT2;
unsigned int DVS_SRC_45_OCCDV_EXT3;
unsigned int DVS_SRC_46;
unsigned int DVS_CRC_OUT_0;
unsigned int DVS_CRC_OUT_1;
unsigned int DVS_CRC_OUT_2;
unsigned int DVS_CRC_OUT_3;
unsigned int DVS_DRAM_SEC;
unsigned int DVS_PD_SRC_00_L_FRM0;
unsigned int DVS_PD_SRC_01_L_FRM1;
unsigned int DVS_PD_SRC_02_L_FRM2;
unsigned int DVS_PD_SRC_03_L_FRM3;
unsigned int DVS_PD_SRC_04_R_FRM0;
unsigned int DVS_PD_SRC_05_R_FRM1;
unsigned int DVS_PD_SRC_06_R_FRM2;
unsigned int DVS_PD_SRC_07_R_FRM3;
unsigned int DVS_PD_SRC_08_OCCDV0;
unsigned int DVS_PD_SRC_09_OCCDV1;
unsigned int DVS_PD_SRC_10_OCCDV2;
unsigned int DVS_PD_SRC_11_OCCDV3;
unsigned int DVS_PD_SRC_12_OCCDV_EXT0;
unsigned int DVS_PD_SRC_13_OCCDV_EXT1;
unsigned int DVS_PD_SRC_14_OCCDV_EXT2;
unsigned int DVS_PD_SRC_15_OCCDV_EXT3;
unsigned int DVS_PD_SRC_16_DCV_CONF0;
unsigned int DVS_PD_SRC_17_DCV_CONF1;
unsigned int DVS_PD_SRC_18_DCV_CONF2;
unsigned int DVS_PD_SRC_19_DCV_CONF3;
unsigned int DVS_CTRL_RESERVED;
unsigned int DVS_CTRL_ATPG;
unsigned int DVS_ME_00;
unsigned int DVS_ME_01;
unsigned int DVS_ME_02;
unsigned int DVS_ME_03;
unsigned int DVS_ME_04;
unsigned int DVS_ME_06;
unsigned int DVS_ME_07;
unsigned int DVS_ME_08;
unsigned int DVS_ME_09;
unsigned int DVS_ME_10;
unsigned int DVS_ME_11;
unsigned int DVS_ME_12;
unsigned int DVS_ME_13;
unsigned int DVS_ME_14;
unsigned int DVS_ME_15;
unsigned int DVS_ME_16;
unsigned int DVS_ME_17;
unsigned int DVS_ME_18;
unsigned int DVS_ME_19;
unsigned int DVS_ME_20;
unsigned int DVS_ME_21;
unsigned int DVS_ME_22;
unsigned int DVS_ME_23;
unsigned int DVS_ME_24;
unsigned int DVS_ME_25;
unsigned int DVS_ME_26;
unsigned int DVS_ME_27;
unsigned int DVS_ME_28;
unsigned int DVS_ME_29;
unsigned int DVS_ME_30;
unsigned int DVS_ME_31;
unsigned int DVS_ME_32;
unsigned int DVS_ME_33;
unsigned int DVS_ME_34;
unsigned int DVS_ME_35;
unsigned int DVS_ME_36;
unsigned int DVS_ME_37;
unsigned int DVS_ME_38;
unsigned int DVS_ME_39;
unsigned int DVS_DEBUG;
unsigned int DVS_ME_RESERVED;
unsigned int DVS_ME_ATPG;
unsigned int DVS_ME_40;
unsigned int DVS_ME_41;
unsigned int DVS_OCC_PQ_0;
unsigned int DVS_OCC_PQ_1;
unsigned int DVS_OCC_PQ_2;
unsigned int DVS_OCC_PQ_3;
unsigned int DVS_OCC_PQ_4;
unsigned int DVS_OCC_PQ_5;
unsigned int DVS_OCC_PQ_6;
unsigned int DVS_OCC_PQ_7;
unsigned int DVS_OCC_PQ_8;
unsigned int DVS_OCC_PQ_9;
unsigned int DVS_OCC_PQ_10;
unsigned int DVS_OCC_PQ_11;
unsigned int DVS_OCC_ATPG;
unsigned int DVP_CTRL00;
unsigned int DVP_CTRL01;
unsigned int DVP_CTRL02;
unsigned int DVP_CTRL03;
unsigned int DVP_CTRL04;
unsigned int DVP_CTRL07;
unsigned int DVP_IRQ_00;
unsigned int DVP_IRQ_01;
unsigned int DVP_CTRL_STATUS0;
unsigned int DVP_CTRL_STATUS1;
unsigned int DVP_CTRL_STATUS2;
unsigned int DVP_IRQ_STATUS;
unsigned int DVP_FRM_STATUS0;
unsigned int DVP_FRM_STATUS2;
unsigned int DVP_CUR_STATUS;
unsigned int DVP_SRC_00;
unsigned int DVP_SRC_01;
unsigned int DVP_SRC_02;
unsigned int DVP_SRC_03;
unsigned int DVP_SRC_04;
unsigned int DVP_SRC_05_Y_FRM0;
unsigned int DVP_SRC_06_Y_FRM1;
unsigned int DVP_SRC_07_Y_FRM2;
unsigned int DVP_SRC_08_Y_FRM3;
unsigned int DVP_SRC_09_C_FRM0;
unsigned int DVP_SRC_10_C_FRM1;
unsigned int DVP_SRC_11_C_FRM2;
unsigned int DVP_SRC_12_C_FRM3;
unsigned int DVP_SRC_13_OCCDV0;
unsigned int DVP_SRC_14_OCCDV1;
unsigned int DVP_SRC_15_OCCDV2;
unsigned int DVP_SRC_16_OCCDV3;
unsigned int DVP_SRC_17_CRM;
unsigned int DVP_SRC_18_ASF_RMDV;
unsigned int DVP_SRC_19_ASF_RDDV;
unsigned int DVP_SRC_20_ASF_DV0;
unsigned int DVP_SRC_21_ASF_DV1;
unsigned int DVP_SRC_22_ASF_DV2;
unsigned int DVP_SRC_23_ASF_DV3;
unsigned int DVP_SRC_24_WMF_HFDV;
unsigned int DVP_SRC_25_WMF_DV0;
unsigned int DVP_SRC_26_WMF_DV1;
unsigned int DVP_SRC_27_WMF_DV2;
unsigned int DVP_SRC_28_WMF_DV3;
unsigned int DVP_CORE_00;
unsigned int DVP_CORE_01;
unsigned int DVP_CORE_02;
unsigned int DVP_CORE_03;
unsigned int DVP_CORE_04;
unsigned int DVP_CORE_05;
unsigned int DVP_CORE_06;
unsigned int DVP_CORE_07;
unsigned int DVP_CORE_08;
unsigned int DVP_CORE_09;
unsigned int DVP_CORE_10;
unsigned int DVP_CORE_11;
unsigned int DVP_CORE_12;
unsigned int DVP_CORE_13;
unsigned int DVP_CORE_14;
unsigned int DVP_CORE_15;
unsigned int DVP_CORE_16;
unsigned int DVP_SRC_CTRL;
unsigned int DVP_CTRL_RESERVED;
unsigned int DVP_CTRL_ATPG;
unsigned int DVP_CRC_OUT_0;
unsigned int DVP_CRC_OUT_1;
unsigned int DVP_CRC_OUT_2;
unsigned int DVP_CRC_CTRL;
unsigned int DVP_CRC_OUT;
unsigned int DVP_CRC_IN;
unsigned int DVP_DRAM_STA;
unsigned int DVP_DRAM_ULT;
unsigned int DVP_DRAM_PITCH;
unsigned int DVP_CORE_CRC_IN;
unsigned int DVP_EXT_SRC_13_OCCDV0;
unsigned int DVP_EXT_SRC_14_OCCDV1;
unsigned int DVP_EXT_SRC_15_OCCDV2;
unsigned int DVP_EXT_SRC_16_OCCDV3;
unsigned int DVP_EXT_SRC_18_ASF_RMDV;
unsigned int DVP_EXT_SRC_19_ASF_RDDV;
unsigned int DVP_EXT_SRC_20_ASF_DV0;
unsigned int DVP_EXT_SRC_21_ASF_DV1;
unsigned int DVP_EXT_SRC_22_ASF_DV2;
unsigned int DVP_EXT_SRC_23_ASF_DV3;
//unsigned int USERDUMP_EN;
unsigned int DPE_MODE;
};
enum DPEMODE {
MODE_DVS_DVP_BOTH = 0,
MODE_DVS_ONLY,
MODE_DVP_ONLY
};
enum DPE_MAINEYE_SEL {
LEFT = 0,
RIGHT = 1
};
struct DVS_SubModule_EN {
bool sbf_en;
bool conf_en;
bool occ_en;
};
struct DVP_SubModule_EN {
bool asf_crm_en;
bool asf_rm_en;
bool asf_rd_en;
bool asf_hf_en;
bool wmf_hf_en;
bool wmf_filt_en;
unsigned int asf_hf_rounds;
unsigned int asf_nb_rounds;
unsigned int wmf_filt_rounds;
bool asf_recursive_en;
unsigned int asf_conf_en;
unsigned int asf_depth_mode;
};
struct DVS_Iteration {
unsigned int y_IterTimes;
unsigned int y_IterStartDirect_0;
unsigned int y_IterStartDirect_1;
unsigned int x_IterStartDirect_0;
unsigned int x_IterStartDirect_1;
};
struct DPE_feedback {
unsigned int reg1;
unsigned int reg2;
};
struct DVS_Settings {
enum DPE_MAINEYE_SEL mainEyeSel;
struct DVS_ME_CFG TuningBuf_ME;
struct DVS_OCC_CFG TuningBuf_OCC;
struct DVS_SubModule_EN SubModule_EN;
struct DVS_Iteration Iteration;
bool is_pd_mode;
unsigned int pd_frame_num; // set by driver
unsigned int pd_st_x; // set by driver
unsigned int frm_width;
unsigned int frm_height;
unsigned int l_eng_start_x;
unsigned int r_eng_start_x;
unsigned int eng_start_y;
unsigned int eng_width;
unsigned int eng_height;
unsigned int occ_width;
unsigned int dram_out_pitch_en; //!ISP7 tile mode enable
unsigned int dram_out_pitch;
unsigned int occ_start_x;
unsigned int dram_pxl_pitch;
unsigned int input_offset;
unsigned int output_offset;
unsigned int out_adj_en;
unsigned int out_adj_dv_en;
unsigned int out_adj_dv_width;
unsigned int out_adj_dv_high;
};
struct DVP_Settings {
enum DPE_MAINEYE_SEL mainEyeSel;
bool Y_only;
struct DVP_CORE_CFG TuningBuf_CORE;
struct DVP_SubModule_EN SubModule_EN;
//bool disp_guide_en;
unsigned int frm_width;
unsigned int frm_height;
unsigned int eng_start_x;
unsigned int eng_start_y;
unsigned int eng_width;
unsigned int eng_height;
};
struct DPE_Config_map {
unsigned int Dpe_InBuf_SrcImg_Y_L_fd;
unsigned int Dpe_InBuf_SrcImg_Y_L_Pre_fd;
unsigned int Dpe_InBuf_SrcImg_Y_L_Ofs;
unsigned int Dpe_InBuf_SrcImg_Y_L_Pre_Ofs;
unsigned int Dpe_InBuf_SrcImg_Y_R_fd;
unsigned int Dpe_InBuf_SrcImg_Y_R_Pre_fd;
unsigned int Dpe_InBuf_SrcImg_Y_R_Ofs;
unsigned int Dpe_InBuf_SrcImg_Y_R_Pre_Ofs;
unsigned int Dpe_InBuf_SrcImg_Y_fd;
unsigned int Dpe_InBuf_SrcImg_Y_Ofs;
unsigned int Dpe_InBuf_SrcImg_C_fd;
unsigned int Dpe_InBuf_SrcImg_C_Ofs;
unsigned int Dpe_InBuf_ValidMap_L_fd;
unsigned int Dpe_InBuf_ValidMap_L_Ofs;
unsigned int Dpe_InBuf_ValidMap_R_fd;
unsigned int Dpe_InBuf_ValidMap_R_Ofs;
unsigned int Dpe_OutBuf_CONF_fd;
unsigned int Dpe_OutBuf_CONF_Ofs;
unsigned int Dpe_OutBuf_OCC_fd;
unsigned int Dpe_OutBuf_OCC_Ofs;
unsigned int Dpe_OutBuf_OCC_Ext_fd;
unsigned int Dpe_OutBuf_OCC_Ext_Ofs;
unsigned int Dpe_InBuf_OCC_fd;
unsigned int Dpe_InBuf_OCC_Ofs;
unsigned int Dpe_InBuf_OCC_Ext_fd;
unsigned int Dpe_InBuf_OCC_Ext_Ofs;
unsigned int Dpe_OutBuf_CRM_fd;
unsigned int Dpe_OutBuf_CRM_Ofs;
unsigned int Dpe_OutBuf_ASF_RD_fd;
unsigned int Dpe_OutBuf_ASF_RD_Ofs;
unsigned int Dpe_OutBuf_ASF_RD_Ext_fd;
unsigned int Dpe_OutBuf_ASF_RD_Ext_Ofs;
unsigned int Dpe_OutBuf_ASF_HF_fd;
unsigned int Dpe_OutBuf_ASF_HF_Ofs;
unsigned int Dpe_OutBuf_ASF_HF_Ext_fd;
unsigned int Dpe_OutBuf_ASF_HF_Ext_Ofs;
unsigned int Dpe_OutBuf_WMF_FILT_fd;
unsigned int Dpe_OutBuf_WMF_FILT_Ofs;
unsigned int DVS_SRC_21_INTER_MEDV_fd;
unsigned int DVS_SRC_21_INTER_MEDV_Ofs;
unsigned int DVS_SRC_34_DCV_L_FRM0_fd;
unsigned int DVS_SRC_34_DCV_L_FRM0_Ofs;
unsigned int DVP_SRC_18_ASF_RMDV_fd;
unsigned int DVP_SRC_18_ASF_RMDV_Ofs;
unsigned int DVP_SRC_24_WMF_HFDV_fd;
unsigned int DVP_SRC_24_WMF_HFDV_Ofs;
unsigned int DVP_EXT_SRC_18_ASF_RMDV_fd;
unsigned int DVP_EXT_SRC_18_ASF_RMDV_Ofs;
unsigned int Dpe_InBuf_P4_L_DV_fd;
unsigned int Dpe_InBuf_P4_L_DV_Ofs;
unsigned int Dpe_InBuf_P4_R_DV_fd;
unsigned int Dpe_InBuf_P4_R_DV_Ofs;
};
struct DPE_Config {
enum DPEMODE Dpe_engineSelect;
unsigned int Dpe_is16BitMode;
struct DVS_Settings Dpe_DVSSettings;
struct DVP_Settings Dpe_DVPSettings;
struct DPE_Config_map DPE_DMapSettings;
unsigned int Dpe_InBuf_SrcImg_Y_L;
unsigned int Dpe_InBuf_SrcImg_Y_R;
unsigned int Dpe_InBuf_SrcImg_Y;
unsigned int Dpe_InBuf_SrcImg_C;
unsigned int Dpe_InBuf_ValidMap_L;
unsigned int Dpe_InBuf_ValidMap_R;
unsigned int Dpe_OutBuf_CONF;
unsigned int Dpe_OutBuf_OCC;
unsigned int Dpe_OutBuf_OCC_Ext;
unsigned int Dpe_InBuf_OCC;
unsigned int Dpe_InBuf_OCC_Ext;
unsigned int Dpe_OutBuf_CRM;
unsigned int Dpe_OutBuf_ASF_RM;
unsigned int Dpe_OutBuf_ASF_RM_Ext;
unsigned int Dpe_OutBuf_ASF_RD;
unsigned int Dpe_OutBuf_ASF_RD_Ext;
unsigned int Dpe_OutBuf_ASF_HF;
unsigned int Dpe_OutBuf_ASF_HF_Ext;
unsigned int Dpe_OutBuf_WMF_HF;
unsigned int Dpe_OutBuf_WMF_FILT;
unsigned int DVP_SRC_18_ASF_RMDV;
unsigned int DVP_SRC_24_WMF_HFDV;
unsigned int DVP_EXT_SRC_18_ASF_RMDV;
unsigned int Dpe_InBuf_SrcImg_Y_L_Pre;
unsigned int Dpe_InBuf_SrcImg_Y_R_Pre;
unsigned int Dpe_InBuf_P4_L_DV;
unsigned int Dpe_InBuf_P4_R_DV;
struct DPE_feedback Dpe_feedback;
};
/*
*
*/
enum DPE_CMD_ENUM {
DPE_CMD_RESET, /* Reset */
DPE_CMD_DUMP_REG, /* Dump DPE Register */
DPE_CMD_DUMP_ISR_LOG, /* Dump DPE ISR log */
DPE_CMD_READ_REG, /* Read register from driver */
DPE_CMD_WRITE_REG, /* Write register to driver */
DPE_CMD_WAIT_IRQ, /* Wait IRQ */
DPE_CMD_CLEAR_IRQ, /* Clear IRQ */
DPE_CMD_ENQUE_NUM, /* DPE Enque Number */
DPE_CMD_ENQUE, /* DPE Enque */
DPE_CMD_ENQUE_REQ, /* DPE Enque Request */
DPE_CMD_DEQUE_NUM, /* DPE Deque Number */
DPE_CMD_DEQUE, /* DPE Deque */
DPE_CMD_DEQUE_REQ, /* DPE Deque Request */
DPE_CMD_TOTAL,
};
/* */
struct DPE_Request {
unsigned int m_ReqNum;
struct DPE_Config *m_pDpeConfig;
};
#if IS_ENABLED(CONFIG_COMPAT)
struct compat_DPE_REG_IO_STRUCT {
compat_uptr_t pData;
unsigned int Count; /* count */
};
struct compat_DPE_Request {
unsigned int m_ReqNum;
compat_uptr_t m_pDpeConfig;
};
#endif
#define DPE_RESET _IO(DPE_MAGIC, DPE_CMD_RESET)
#define DPE_DUMP_REG _IO(DPE_MAGIC, DPE_CMD_DUMP_REG)
#define DPE_DUMP_ISR_LOG _IO(DPE_MAGIC, DPE_CMD_DUMP_ISR_LOG)
#define DPE_READ_REGISTER \
_IOWR(DPE_MAGIC, DPE_CMD_READ_REG, struct DPE_REG_IO_STRUCT)
#define DPE_WRITE_REGISTER \
_IOWR(DPE_MAGIC, DPE_CMD_WRITE_REG, struct DPE_REG_IO_STRUCT)
#define DPE_WAIT_IRQ \
_IOW(DPE_MAGIC, DPE_CMD_WAIT_IRQ, struct DPE_WAIT_IRQ_STRUCT)
#define DPE_CLEAR_IRQ \
_IOW(DPE_MAGIC, DPE_CMD_CLEAR_IRQ, struct DPE_CLEAR_IRQ_STRUCT)
#define DPE_ENQNUE_NUM _IOW(DPE_MAGIC, DPE_CMD_ENQUE_NUM, int)
#define DPE_ENQUE _IOWR(DPE_MAGIC, DPE_CMD_ENQUE, struct DPE_Config)
#define DPE_ENQUE_REQ _IOWR(DPE_MAGIC, DPE_CMD_ENQUE_REQ, struct DPE_Request)
#define DPE_DEQUE_NUM _IOR(DPE_MAGIC, DPE_CMD_DEQUE_NUM, int)
#define DPE_DEQUE _IOWR(DPE_MAGIC, DPE_CMD_DEQUE, struct DPE_Config)
#define DPE_DEQUE_REQ _IOWR(DPE_MAGIC, DPE_CMD_DEQUE_REQ, struct DPE_Request)
#if IS_ENABLED(CONFIG_COMPAT)
#define COMPAT_DPE_WRITE_REGISTER \
_IOWR(DPE_MAGIC, DPE_CMD_WRITE_REG, struct compat_DPE_REG_IO_STRUCT)
#define COMPAT_DPE_READ_REGISTER \
_IOWR(DPE_MAGIC, DPE_CMD_READ_REG, struct compat_DPE_REG_IO_STRUCT)
#define COMPAT_DPE_ENQUE_REQ \
_IOWR(DPE_MAGIC, DPE_CMD_ENQUE_REQ, struct compat_DPE_Request)
#define COMPAT_DPE_DEQUE_REQ \
_IOWR(DPE_MAGIC, DPE_CMD_DEQUE_REQ, struct compat_DPE_Request)
#endif
/* */
#endif
#define output_WDMA_WRA_num 4
#define fd_loop_num 87
struct aie_static_info {
unsigned int fd_wdma_size[fd_loop_num][output_WDMA_WRA_num];
unsigned int out_xsize_plus_1[fd_loop_num];
unsigned int out_height[fd_loop_num];
unsigned int out_ysize_plus_1_stride2[fd_loop_num];
unsigned int out_stride[fd_loop_num];
unsigned int out_stride_stride2[fd_loop_num];
unsigned int out_width[fd_loop_num];
unsigned int img_width[fd_loop_num];
unsigned int img_height[fd_loop_num];
unsigned int stride2_out_width[fd_loop_num];
unsigned int stride2_out_height[fd_loop_num];
unsigned int out_xsize_plus_1_stride2[fd_loop_num];
unsigned int input_xsize_plus_1[fd_loop_num];
};
struct imem_buf_info {
void *va;
dma_addr_t pa;
unsigned int size;
};
struct mtk_dpe_dev {
struct device *dev;
struct mtk_aie_ctx *ctx;
struct v4l2_device v4l2_dev;
struct v4l2_m2m_dev *m2m_dev;
struct media_device mdev;
struct video_device vfd;
struct clk *fd_clk;
struct device *larb;
// Lock for V4L2 operations
struct mutex vfd_lock;
void __iomem *fd_base;
u32 fd_stream_count;
struct completion fd_job_finished;
struct delayed_work job_timeout_work;
struct aie_enq_info *aie_cfg;
//!struct aie_reg_cfg reg_cfg;
// Input Buffer Pointer
struct imem_buf_info rs_cfg_data;
struct imem_buf_info fd_cfg_data;
struct imem_buf_info pose_cfg_data;
struct imem_buf_info yuv2rgb_cfg_data;
//HW Output Buffer Pointer
struct imem_buf_info rs_output_hw;
struct imem_buf_info fd_dma_hw;
struct imem_buf_info fd_dma_result_hw;
struct imem_buf_info fd_kernel_hw;
struct imem_buf_info fd_attr_dma_hw;
// DRAM Buffer Size
unsigned int fd_rs_cfg_size;
unsigned int fd_fd_cfg_size;
unsigned int fd_yuv2rgb_cfg_size;
unsigned int fd_pose_cfg_size;
unsigned int attr_fd_cfg_size;
unsigned int attr_yuv2rgb_cfg_size;
// HW Output Buffer Size
//!unsigned int rs_pym_out_size[PYM_NUM];
unsigned int fd_dma_max_size;
unsigned int fd_dma_rst_max_size;
unsigned int fd_fd_kernel_size;
unsigned int fd_attr_kernel_size;
unsigned int fd_attr_dma_max_size;
unsigned int fd_attr_dma_rst_max_size;
unsigned int pose_height;
struct aie_para *base_para;
struct aie_attr_para *attr_para;
struct aie_fd_dma_para *dma_para;
struct aie_static_info st_info;
};
@@ -0,0 +1,647 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include <linux/types.h>
#include <linux/stddef.h>
#include <linux/vmalloc.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/seqlock.h>
#include <linux/irqflags.h>
#include "engine_request.h"
/*
* module control
*/
MODULE_DESCRIPTION("Stand Alone Engine Request");
MODULE_AUTHOR("MM3SW5");
MODULE_LICENSE("GPL");
unsigned int dpe_egn_debug;
module_param(dpe_egn_debug, uint, 0644);
MODULE_PARM_DESC(dpe_egn_debug, " activates debug info");
#define MyTag "[STALN]"
#define LOG_VRB(format, args...) \
pr_debug(MyTag "[%s] " format, __func__, ##args)
#define LOG_DBG(format, args...) \
do { \
if (dpe_egn_debug >= 2) \
pr_info(MyTag "[%s] " format, __func__, ##args); \
} while (0)
#define LOG_INF(format, args...) \
do { \
if (dpe_egn_debug >= 1) \
pr_info(MyTag "[%s] " format, __func__, ##args);\
} while (0)
#define LOG_WRN(format, args...) \
do { \
if (dpe_egn_debug >= 0) \
pr_info(MyTag "[%s] " format, __func__, ##args); \
} while (0)
#define LOG_ERR(format, args...) \
do { \
if (dpe_egn_debug >= 0) \
pr_info(MyTag "[%s] " format, __func__, ##args); \
} while (0)
/*
* Single ring ctl init
*/
signed int dpe_init_ring_ctl(struct ring_ctrl *rctl)
{
if (rctl == NULL)
return -1;
rctl->wcnt = 0;
rctl->rcnt = 0;
rctl->icnt = 0;
rctl->gcnt = 0;
rctl->size = 0;
return 0;
}
signed int dpe_set_ring_size(struct ring_ctrl *rctl, unsigned int size)
{
if (rctl == NULL)
return -1;
rctl->size = size;
return 0;
}
signed int dpe_init_frame(struct frame *frame)
{
if (frame == NULL)
return -1;
frame->state = FRAME_STATUS_EMPTY;
return 0;
}
/*
* single request init
*/
signed int dpe_init_request(struct request *req)
{
int f;
if (req == NULL)
return -1;
req->state = REQUEST_STATE_EMPTY;
dpe_init_ring_ctl(&req->fctl);
dpe_set_ring_size(&req->fctl, MAX_FRAMES_PER_REQUEST);
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++)
dpe_init_frame(&req->frames[f]);
req->pending_run = false;
return 0;
}
/*
* per-frame data init
*/
signed int dpe_set_frame_data(struct frame *f, void *engine)
{
if (f == NULL) {
LOG_ERR("NULL frame(%p)", (void *)f);
return -1;
}
f->data = engine;
return 0;
}
/*
* TOP : per-sub-engine
* Size Limitaion: eng_reqs : [MAX_REQUEST_SIZE_PER_ENGINE]
* data : [MAX_REQUEST_SIZE_PER_ENGINE][MAX_FRAMES_PER_REQUEST]
*/
signed int dpe_register_requests(struct engine_requests *eng, size_t size)
{
int f, r, d;
char *_data;
size_t len;
if (eng == NULL)
return -1;
dpe_init_ring_ctl(&eng->req_ctl);
dpe_set_ring_size(&eng->req_ctl, MAX_REQUEST_SIZE_PER_ENGINE);
/* TODO: KE Risk : array out of bound */
len = (size * MAX_FRAMES_PER_REQUEST) * MAX_REQUEST_SIZE_PER_ENGINE;
_data = vmalloc(len);
if (_data == NULL) {
LOG_INF("[%s] vmalloc failed", __func__);
return -1;
}
memset(_data, 0x0, len);
LOG_INF("[%s]Engine struct total size is %zu", __func__, len);
for (r = 0; r < MAX_REQUEST_SIZE_PER_ENGINE; r++) {
dpe_init_request(&eng->reqs[r]);
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++) {
d = (r * MAX_FRAMES_PER_REQUEST + f) * size;
dpe_set_frame_data(&eng->reqs[r].frames[f], &_data[d]);
}
}
/* seqlock_init(&eng->seqlock); */
local_irq_disable();
write_seqlock(&eng->seqlock);
eng->req_running = false;
write_sequnlock(&eng->seqlock);
local_irq_enable();
/* init and inc for 1st request_handler use */
init_completion(&eng->req_handler_done);
complete(&eng->req_handler_done);
return 0;
}
signed int dpe_unregister_requests(struct engine_requests *eng)
{
int f, r;
if (eng == NULL)
return -1;
vfree(eng->reqs[0].frames[0].data);
for (r = 0; r < MAX_REQUEST_SIZE_PER_ENGINE; r++) {
dpe_init_request(&eng->reqs[r]);
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++)
dpe_set_frame_data(&eng->reqs[r].frames[f], NULL);
}
local_irq_disable();
write_seqlock(&eng->seqlock);
eng->req_running = false;
write_sequnlock(&eng->seqlock);
local_irq_enable();
return 0;
}
int dpe_set_engine_ops(struct engine_requests *eng,
const struct engine_ops *ops)
{
if (eng == NULL || ops == NULL)
return -1;
eng->ops = ops;
return 0;
}
bool dpe_request_running(struct engine_requests *eng)
{
unsigned int seq;
seqlock_t *lock;
bool running;
lock = &eng->seqlock;
do {
seq = read_seqbegin(lock);
running = eng->req_running;
} while (read_seqretry(lock, seq));
LOG_DBG("[%s] engine running request(%d)\n", __func__, running);
return running;
}
/*TODO: called in ENQUE_REQ */
signed int dpe_enque_request(struct engine_requests *eng, unsigned int fcnt,
void *req, pid_t pid)
{
unsigned int r;
unsigned int f;
unsigned int enqnum = 0;
if (eng == NULL)
return -1;
r = eng->req_ctl.wcnt;
/* FIFO when wcnt starts from 0 */
f = eng->reqs[r].fctl.wcnt;
if (eng->reqs[r].state != REQUEST_STATE_EMPTY) {
LOG_ERR("No empty requests available.");
goto ERROR;
}
if (eng->ops->req_enque_cb == NULL || req == NULL) {
LOG_ERR("NULL req_enque_cb or req");
goto ERROR;
}
if (eng->ops->req_enque_cb(eng->reqs[r].frames, req)) {
LOG_ERR("Failed to enque request, check cb");
goto ERROR;
}
LOG_DBG("request(%d) enqued with %d frames", r, fcnt);
for (f = 0; f < fcnt; f++)
eng->reqs[r].frames[f].state = FRAME_STATUS_ENQUE;
eng->reqs[r].state = REQUEST_STATE_PENDING;
eng->reqs[r].pid = pid;
eng->reqs[r].fctl.wcnt = fcnt;
eng->reqs[r].fctl.size = fcnt;
eng->req_ctl.wcnt = (r + 1) % MAX_REQUEST_SIZE_PER_ENGINE;
#if REQUEST_REGULATION
/*
* pending request count for request base regulation
*/
for (r = 0; r < MAX_REQUEST_SIZE_PER_ENGINE; r++)
if (eng->reqs[r].state == REQUEST_STATE_PENDING)
enqnum++;
#else
/*
* running frame count for frame base regulation
*/
for (r = 0; r < MAX_REQUEST_SIZE_PER_ENGINE; r++)
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++)
if (eng->reqs[r].frames[f].state ==
FRAME_STATUS_RUNNING)
enqnum++;
#endif
return enqnum;
ERROR:
return -1;
}
/* ConfigWMFERequest / ConfigOCCRequest abstraction
* TODO: locking should be here NOT camera_owe.c
*/
signed int dpe_request_handler(struct engine_requests *eng, spinlock_t *lock)
{
unsigned int f, fn;
unsigned int r;
enum REQUEST_STATE_ENUM rstate;
enum FRAME_STATUS_ENUM fstate;
unsigned long flags;
signed int ret = -1;
if (eng == NULL)
return -1;
LOG_DBG("[%s]waits for completion(%d).\n", __func__,
eng->req_handler_done.done);
wait_for_completion(&eng->req_handler_done);
reinit_completion(&eng->req_handler_done);
LOG_DBG("[%s]previous request completed, reset(%d).\n", __func__,
eng->req_handler_done.done);
spin_lock_irqsave(lock, flags);
/*
* ioctl calls enque_request() request wcnt inc
* if request_handler is NOT called after enque_request() in serial,
* wcnt may inc many times maore than 1
*/
r = eng->req_ctl.gcnt;
LOG_DBG("[%s] processing request(%d)\n", __func__, r);
rstate = eng->reqs[r].state;
#if REQUEST_REGULATION
(void) fn;
if (rstate != REQUEST_STATE_PENDING) {
LOG_DBG("[%s]No pending request(%d), state:%d\n", __func__,
r, rstate);
write_seqlock(&eng->seqlock);
eng->req_running = false;
write_sequnlock(&eng->seqlock);
spin_unlock_irqrestore(lock, flags);
complete_all(&eng->req_handler_done);
LOG_DBG("[%s]complete(%d)\n", __func__,
eng->req_handler_done.done);
return 0;
}
/* running request contains all running frames */
eng->reqs[r].state = REQUEST_STATE_RUNNING;
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++) {
fstate = eng->reqs[r].frames[f].state;
if (fstate == FRAME_STATUS_ENQUE) {
LOG_DBG("[%s]Processing request(%d) of frame(%d)\n",
__func__, r, f);
spin_unlock_irqrestore(lock, flags);
ret = eng->ops->frame_handler(&eng->reqs[r].frames[f]);
spin_lock_irqsave(lock, flags);
if (ret)
LOG_WRN("[%s]failed:frame %d of request %d",
__func__, f, r);
eng->reqs[r].frames[f].state = FRAME_STATUS_RUNNING;
}
}
eng->req_ctl.gcnt = (r + 1) % MAX_REQUEST_SIZE_PER_ENGINE;
#else
/*
* TODO: to prevent IRQ timing issue due to multi-frame requests,
* frame-based reguest handling should be used instead.
*/
if (eng->reqs[r].pending_run == false) {
if (rstate != REQUEST_STATE_PENDING) {
LOG_DBG("[%s]No pending request(%d), state:%d\n",
__func__, r, rstate);
write_seqlock(&eng->seqlock);
eng->req_running = false;
write_sequnlock(&eng->seqlock);
spin_unlock_irqrestore(lock, flags);
complete_all(&eng->req_handler_done);
LOG_DBG("[%s]complete(%d)\n", __func__,
eng->req_handler_done.done);
return 0;
}
eng->reqs[r].pending_run = true;
eng->reqs[r].state = REQUEST_STATE_RUNNING;
} else
if (rstate != REQUEST_STATE_RUNNING) {
LOG_WRN(
"[%s]No pending_run request(%d), state:%d\n", __func__,
r, rstate);
write_seqlock(&eng->seqlock);
eng->req_running = false;
write_sequnlock(&eng->seqlock);
spin_unlock_irqrestore(lock, flags);
complete_all(&eng->req_handler_done);
LOG_DBG(
"[%s]complete(%d)\n", __func__,
eng->req_handler_done.done);
return 0;
}
/* pending requets can have running frames */
f = eng->reqs[r].fctl.gcnt;
LOG_DBG("[%s]Iterating request(%d) of frame(%d)\n",
__func__, r, f);
fstate = eng->reqs[r].frames[f].state;
if (fstate == FRAME_STATUS_ENQUE) {
LOG_DBG("[%s]Processing request(%d) of frame(%d)\n",
__func__, r, f);
write_seqlock(&eng->seqlock);
eng->req_running = true;
write_sequnlock(&eng->seqlock);
eng->reqs[r].frames[f].state = FRAME_STATUS_RUNNING;
spin_unlock_irqrestore(lock, flags);
ret = eng->ops->frame_handler(&eng->reqs[r].frames[f]);
spin_lock_irqsave(lock, flags);
if (ret)
LOG_WRN("[%s]failed:frame %d of request %d",
__func__, f, r);
} else {
spin_unlock_irqrestore(lock, flags);
LOG_WRN("[%s]already running frame %d of request %d",
__func__, f, r);
complete_all(&eng->req_handler_done);
LOG_DBG("[%s]complete(%d)\n", __func__,
eng->req_handler_done.done);
return 1;
}
fn = (f + 1) % MAX_FRAMES_PER_REQUEST;
fstate = eng->reqs[r].frames[fn].state;
if (fstate == FRAME_STATUS_EMPTY || fn == 0) {
eng->reqs[r].pending_run = false;
eng->req_ctl.gcnt = (r + 1) % MAX_REQUEST_SIZE_PER_ENGINE;
} else
eng->reqs[r].fctl.gcnt = fn;
#endif
spin_unlock_irqrestore(lock, flags);
complete_all(&eng->req_handler_done);
LOG_DBG("complete_all done = %d\n", eng->req_handler_done.done);
return 1;
}
int dpe_update_request(struct engine_requests *eng, pid_t *pid)
{
unsigned int i, f, n;
int req_jobs = -1;
if (eng == NULL)
return -1;
/* TODO: request ring */
for (i = eng->req_ctl.icnt; i < MAX_REQUEST_SIZE_PER_ENGINE; i++) {
/* find 1st running request */
if (eng->reqs[i].state != REQUEST_STATE_RUNNING)
continue;
/* find 1st running frame, f. */
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f++) {
if (eng->reqs[i].frames[f].state ==
FRAME_STATUS_RUNNING)
break;
}
/* TODO: no running frame in a running request */
if (f == MAX_FRAMES_PER_REQUEST) {
LOG_ERR(
"[%s]No running frames in a running request(%d).",
__func__, i);
break;
}
eng->reqs[i].frames[f].state = FRAME_STATUS_FINISHED;
LOG_INF("[%s]request %d of frame %d finished.\n",
__func__, i, f);
/*TODO: to obtain statistics */
if (eng->ops->req_feedback_cb == NULL) {
LOG_DBG("NULL req_feedback_cb");
goto NO_FEEDBACK;
}
if (eng->ops->req_feedback_cb(&eng->reqs[i].frames[f])) {
LOG_ERR("Failed to feedback statistics, check cb");
goto NO_FEEDBACK;
}
NO_FEEDBACK:
n = f + 1;
if ((n == MAX_FRAMES_PER_REQUEST) ||
((n < MAX_FRAMES_PER_REQUEST) &&
(eng->reqs[i].frames[n].state == FRAME_STATUS_EMPTY))) {
req_jobs = 0;
(*pid) = eng->reqs[i].pid;
eng->reqs[i].state = REQUEST_STATE_FINISHED;
eng->req_ctl.icnt = (eng->req_ctl.icnt + 1) %
MAX_REQUEST_SIZE_PER_ENGINE;
} else {
LOG_INF(
"[%s]more frames left of request(%d/%d).", __func__,
i, eng->req_ctl.icnt);
}
break;
}
return req_jobs;
}
/*TODO: called in DEQUE_REQ */
signed int dpe_deque_request(
struct engine_requests *eng, unsigned int *fcnt, void *req)
{
unsigned int r;
unsigned int f;
unsigned int m_real_ReqNum;
if (eng == NULL)
return -1;
r = eng->req_ctl.rcnt;
/* FIFO when rcnt starts from 0 */
f = eng->reqs[r].fctl.rcnt;
if (eng->reqs[r].state != REQUEST_STATE_FINISHED) {
LOG_ERR("[%s]Request(%d) NOT finished", __func__, r);
goto ERROR;
}
//for (f = 0; f < fcnt; f++)
//if (eng->reqs[r].frames[f].state != FRAME_STATUS_FINISHED) {
//LOG_ERR("Frame(%d) NOT finised", f);
//goto ERROR;
//}
*fcnt = eng->reqs[r].fctl.size;
m_real_ReqNum = eng->reqs[r].fctl.size;
LOG_DBG("[%s]deque request(%d) has %d frames", __func__, r, *fcnt);
if (eng->ops->req_deque_cb == NULL || req == NULL) {
LOG_ERR("[%s]NULL req_deque_cb/req", __func__);
goto ERROR;
}
if (eng->ops->req_deque_cb(eng->reqs[r].frames, req)) {
LOG_ERR("[%s]Failed to deque, check req_deque_cb", __func__);
goto ERROR;
}
//for (f = 0; f < *fcnt; f++)
for (f = 0; f < m_real_ReqNum; f++)
eng->reqs[r].frames[f].state = FRAME_STATUS_EMPTY;
eng->reqs[r].state = REQUEST_STATE_EMPTY;
eng->reqs[r].pid = 0;
eng->reqs[r].fctl.wcnt = 0;
eng->reqs[r].fctl.rcnt = 0;
eng->reqs[r].fctl.icnt = 0;
eng->reqs[r].fctl.gcnt = 0;
eng->reqs[r].fctl.size = 0;
eng->req_ctl.rcnt = (r + 1) % MAX_REQUEST_SIZE_PER_ENGINE;
return 0;
ERROR:
return -1;
}
signed int dpe_request_dump(struct engine_requests *eng)
{
unsigned int r;
unsigned int f;
LOG_ERR("[%s] +\n", __func__);
if (eng == NULL) {
LOG_ERR("[%s]can't dump NULL engine", __func__);
return -1;
}
LOG_ERR("req_ctl:wc:%d, gc:%d, ic:%d, rc:%d, data:%p\n",
eng->req_ctl.wcnt,
eng->req_ctl.gcnt,
eng->req_ctl.icnt,
eng->req_ctl.rcnt,
eng->reqs[0].frames[0].data);
for (r = 0; r < MAX_REQUEST_SIZE_PER_ENGINE; r++) {
LOG_ERR(
"R[%d].sta:%d, pid:0x%08X, wc:%d, gc:%d, ic:%d, rc:%d\n",
r,
eng->reqs[r].state,
eng->reqs[r].pid,
eng->reqs[r].fctl.wcnt,
eng->reqs[r].fctl.gcnt,
eng->reqs[r].fctl.icnt,
eng->reqs[r].fctl.rcnt);
for (f = 0; f < MAX_FRAMES_PER_REQUEST; f += 2) {
LOG_ERR("F[%d].state:%d, F[%d].state:%d\n",
f, eng->reqs[r].frames[f].state,
f + 1, eng->reqs[r].frames[f + 1].state);
}
}
LOG_ERR("[%s] -\n", __func__);
return 0;
}
static int __init egnreq_init(void)
{
int ret = 0;
LOG_INF("engine_request module loaded");
return ret;
}
static void __exit egnreq_exit(void)
{
LOG_INF("engine_request module unloaded");
}
module_init(egnreq_init);
module_exit(egnreq_exit);
@@ -0,0 +1,92 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include <linux/completion.h>
#ifndef _ENGINE_REQUESTS_H_
#define _ENGINE_REQUESTS_H_
#define MAX_REQUEST_SIZE_PER_ENGINE 4
#define MAX_FRAMES_PER_REQUEST 12 // 6
/* Regulation Options */
#define FRAME_BASE_REGULATION 0
#define REQUEST_BASE_REGULATION 1
#define REQUEST_REGULATION FRAME_BASE_REGULATION
enum FRAME_STATUS_ENUM {
FRAME_STATUS_EMPTY, /* 0 */
FRAME_STATUS_ENQUE, /* 1 */
FRAME_STATUS_RUNNING, /* 2 */
FRAME_STATUS_FINISHED, /* 3 */
FRAME_STATUS_TOTAL
};
enum REQUEST_STATE_ENUM {
REQUEST_STATE_EMPTY, /* 0 */
REQUEST_STATE_PENDING, /* 1 */
REQUEST_STATE_RUNNING, /* 2 */
REQUEST_STATE_FINISHED, /* 3 */
REQUEST_STATE_TOTAL
};
struct ring_ctrl {
unsigned int wcnt; /* enque */
unsigned int rcnt; /* deque */
unsigned int icnt; /* IRQ ringing counter w/o reset */
unsigned int gcnt; /* GCE */
unsigned int size;
/* init MAX_REQUEST_SIZE_PER_ENGINE MAX_FRAMES_PER_REQUEST */
};
struct frame {
enum FRAME_STATUS_ENUM state;
void *data; /* points to engine data */
};
struct request {
enum REQUEST_STATE_ENUM state;
pid_t pid;
struct ring_ctrl fctl;
struct frame frames[MAX_FRAMES_PER_REQUEST];
bool pending_run; /* pending frame in a running request */
};
struct engine_ops {
int (*req_enque_cb)(struct frame *frames, void *req);
int (*req_deque_cb)(struct frame *frames, void *req);
int (*frame_handler)(struct frame *frame);
int (*req_feedback_cb)(struct frame *frame);
};
struct engine_requests {
struct ring_ctrl req_ctl;
struct request reqs[MAX_REQUEST_SIZE_PER_ENGINE];
const struct engine_ops *ops;
struct completion req_handler_done;
bool req_running;
seqlock_t seqlock;
};
signed int dpe_init_ring_ctl(struct ring_ctrl *rctl);
signed int dpe_init_request(struct request *req);
signed int dpe_set_frame_data(struct frame *f, void *engine);
signed int dpe_register_requests(struct engine_requests *eng, size_t size);
signed int dpe_unregister_requests(struct engine_requests *eng);
signed int dpe_request_handler(struct engine_requests *eng, spinlock_t *lock);
/*TODO: APIs to manipulate requests */
int dpe_set_engine_ops(struct engine_requests *eng,
const struct engine_ops *ops);
signed int dpe_enque_request(struct engine_requests *eng, unsigned int fcnt,
void *req, pid_t pid);
signed int dpe_deque_request(struct engine_requests *eng, unsigned int *fcnt,
void *req);
int dpe_update_request(struct engine_requests *eng, pid_t *pid);
bool dpe_request_running(struct engine_requests *eng);
signed int dpe_request_dump(struct engine_requests *eng);
#endif
@@ -0,0 +1,798 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include <linux/dma-buf.h>
#include <linux/module.h>
#include <linux/refcount.h>
#include <linux/scatterlist.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/dma-mapping.h>
#include <media/videobuf2-v4l2.h>
#include <media/videobuf2-dma-contig.h>
#include <media/videobuf2-memops.h>
#include <linux/mm.h>
//!#define vb2_mmap
struct vb2_dc_buf {
struct device *dev;
void *vaddr;
unsigned long size;
void *cookie;
dma_addr_t dma_addr;
unsigned long attrs;
enum dma_data_direction dma_dir;
struct sg_table *dma_sgt;
struct frame_vector *vec;
/* MMAP related */
struct vb2_vmarea_handler handler;
refcount_t refcount;
struct sg_table *sgt_base;
/* DMABUF related */
struct dma_buf_attachment *db_attach;
};
/*********************************************/
/* scatterlist table functions */
/*********************************************/
static unsigned long vb2_dc_get_contiguous_size(struct sg_table *sgt)
{
struct scatterlist *s;
dma_addr_t expected = sg_dma_address(sgt->sgl);
unsigned int i;
unsigned long size = 0;
for_each_sg(sgt->sgl, s, sgt->nents, i) {
if (sg_dma_address(s) != expected)
break;
expected = sg_dma_address(s) + sg_dma_len(s);
size += sg_dma_len(s);
}
return size;
}
/*********************************************/
/* callbacks for all buffers */
/*********************************************/
static void *vb2_dc_cookie(void *buf_priv)
{
struct vb2_dc_buf *buf = buf_priv;
return &buf->dma_addr;
}
static void *vb2_dc_vaddr(void *buf_priv)
{
struct vb2_dc_buf *buf = buf_priv;
if (!buf->vaddr && buf->db_attach)
buf->vaddr = dma_buf_vmap(buf->db_attach->dmabuf);
return buf->vaddr;
}
static unsigned int vb2_dc_num_users(void *buf_priv)
{
struct vb2_dc_buf *buf = buf_priv;
return refcount_read(&buf->refcount);
}
static void vb2_dc_prepare(void *buf_priv)
{
struct vb2_dc_buf *buf = buf_priv;
struct sg_table *sgt = buf->dma_sgt;
/* DMABUF exporter will flush the cache for us */
if (!sgt || buf->db_attach)
return;
dma_sync_sg_for_device(buf->dev, sgt->sgl, sgt->orig_nents,
buf->dma_dir);
}
static void vb2_dc_finish(void *buf_priv)
{
struct vb2_dc_buf *buf = buf_priv;
struct sg_table *sgt = buf->dma_sgt;
/* DMABUF exporter will flush the cache for us */
if (!sgt || buf->db_attach)
return;
dma_sync_sg_for_cpu(buf->dev, sgt->sgl, sgt->orig_nents, buf->dma_dir);
}
/*********************************************/
/* callbacks for MMAP buffers */
/*********************************************/
void vb2_dc_put(void *buf_priv)
{
struct vb2_dc_buf *buf = buf_priv;
pr_debug("kernel_dpebuf refcount before = %d\n", buf->refcount);
if (!refcount_dec_and_test(&buf->refcount))
return;
pr_debug("kernel_dpebuf refcount after = %d\n", buf->refcount);
if (buf->sgt_base) {
sg_free_table(buf->sgt_base);
kfree(buf->sgt_base);
}
dma_free_attrs(buf->dev, buf->size, buf->cookie, buf->dma_addr,
buf->attrs);
put_device(buf->dev);
kfree(buf);
}
void *vb2_dc_alloc(struct device *dev, unsigned long attrs,
unsigned long size, enum dma_data_direction dma_dir,
gfp_t gfp_flags)
{
struct vb2_dc_buf *buf;
if (WARN_ON(!dev))
return ERR_PTR(-EINVAL);
buf = kzalloc(sizeof(*buf), GFP_KERNEL);
if (!buf)
return ERR_PTR(-ENOMEM);
if (attrs)
buf->attrs = attrs;
buf->cookie = dma_alloc_attrs(dev, size, &buf->dma_addr,
GFP_KERNEL | gfp_flags, buf->attrs);
if (!buf->cookie) {
dev_info(dev, "dma_alloc_coherent of size %ld failed\n", size);
kfree(buf);
return ERR_PTR(-ENOMEM);
}
if ((buf->attrs & DMA_ATTR_NO_KERNEL_MAPPING) == 0)
buf->vaddr = buf->cookie;
/* Prevent the device from being released while the buffer is used */
buf->dev = get_device(dev);
buf->size = size;
buf->dma_dir = dma_dir;
buf->handler.refcount = &buf->refcount;
buf->handler.put = vb2_dc_put;
buf->handler.arg = buf;
refcount_set(&buf->refcount, 1);
return buf;
}
#ifdef vb2_mmap
static int vb2_dc_mmap(void *buf_priv, struct vm_area_struct *vma)
{
struct vb2_dc_buf *buf = buf_priv;
int ret;
if (!buf) {
pr_info("No buffer to map\n");
return -EINVAL;
}
/*
* dma_mmap_* uses vm_pgoff as in-buffer offset, but we want to
* map whole buffer
*/
vma->vm_pgoff = 0;
ret = dma_mmap_attrs(buf->dev, vma, buf->cookie,
buf->dma_addr, buf->size, buf->attrs);
if (ret) {
pr_info("Remapping memory failed, error: %d\n", ret);
return ret;
}
vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
vma->vm_private_data = &buf->handler;
vma->vm_ops = &vb2_common_vm_ops;
vma->vm_ops->open(vma);
pr_debug("%s: mapped dma addr 0x%08lx at 0x%08lx, size %ld\n",
__func__, (unsigned long)buf->dma_addr, vma->vm_start,
buf->size);
return 0;
}
#endif
/*********************************************/
/* DMABUF ops for exporters */
/*********************************************/
struct vb2_dc_attachment {
struct sg_table sgt;
enum dma_data_direction dma_dir;
};
static int vb2_dc_dmabuf_ops_attach(struct dma_buf *dbuf,
struct dma_buf_attachment *dbuf_attach)
{
struct vb2_dc_attachment *attach;
unsigned int i;
struct scatterlist *rd, *wr;
struct sg_table *sgt;
struct vb2_dc_buf *buf = dbuf->priv;
int ret;
attach = kzalloc(sizeof(*attach), GFP_KERNEL);
if (!attach)
return -ENOMEM;
sgt = &attach->sgt;
/* Copy the buf->base_sgt scatter list to the attachment, as we can't
* map the same scatter list to multiple attachments at the same time.
*/
ret = sg_alloc_table(sgt, buf->sgt_base->orig_nents, GFP_KERNEL);
if (ret) {
kfree(attach);
return -ENOMEM;
}
rd = buf->sgt_base->sgl;
wr = sgt->sgl;
for (i = 0; i < sgt->orig_nents; ++i) {
sg_set_page(wr, sg_page(rd), rd->length, rd->offset);
rd = sg_next(rd);
wr = sg_next(wr);
}
attach->dma_dir = DMA_NONE;
dbuf_attach->priv = attach;
return 0;
}
static void vb2_dc_dmabuf_ops_detach(struct dma_buf *dbuf,
struct dma_buf_attachment *db_attach)
{
struct vb2_dc_attachment *attach = db_attach->priv;
struct sg_table *sgt;
if (!attach)
return;
sgt = &attach->sgt;
/* release the scatterlist cache */
if (attach->dma_dir != DMA_NONE)
dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
attach->dma_dir);
sg_free_table(sgt);
kfree(attach);
db_attach->priv = NULL;
}
static struct sg_table *vb2_dc_dmabuf_ops_map(
struct dma_buf_attachment *db_attach, enum dma_data_direction dma_dir)
{
struct vb2_dc_attachment *attach = db_attach->priv;
/* stealing dmabuf mutex to serialize map/unmap operations */
struct mutex *lock = &db_attach->dmabuf->lock;
struct sg_table *sgt;
mutex_lock(lock);
sgt = &attach->sgt;
/* return previously mapped sg table */
if (attach->dma_dir == dma_dir) {
mutex_unlock(lock);
return sgt;
}
/* release any previous cache */
if (attach->dma_dir != DMA_NONE) {
dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
attach->dma_dir);
attach->dma_dir = DMA_NONE;
}
/* mapping to the client with new direction */
sgt->nents = dma_map_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
dma_dir);
if (!sgt->nents) {
pr_info("failed to map scatterlist\n");
mutex_unlock(lock);
return ERR_PTR(-EIO);
}
attach->dma_dir = dma_dir;
mutex_unlock(lock);
return sgt;
}
static void vb2_dc_dmabuf_ops_unmap(struct dma_buf_attachment *db_attach,
struct sg_table *sgt, enum dma_data_direction dma_dir)
{
/* nothing to be done here */
}
static void vb2_dc_dmabuf_ops_release(struct dma_buf *dbuf)
{
/* drop reference obtained in vb2_dc_get_dmabuf */
vb2_dc_put(dbuf->priv);
}
static void *vb2_dc_dmabuf_ops_kmap(struct dma_buf *dbuf, unsigned long pgnum)
{
struct vb2_dc_buf *buf = dbuf->priv;
return buf->vaddr ? buf->vaddr + pgnum * PAGE_SIZE : NULL;
}
static void *vb2_dc_dmabuf_ops_vmap(struct dma_buf *dbuf)
{
struct vb2_dc_buf *buf = dbuf->priv;
return buf->vaddr;
}
static int vb2_dc_dmabuf_ops_mmap(struct dma_buf *dbuf,
struct vm_area_struct *vma)
{
//return vb2_dc_mmap(dbuf->priv, vma);
return 0;
}
static const struct dma_buf_ops vb2_dc_dmabuf_ops = {
.attach = vb2_dc_dmabuf_ops_attach,
.detach = vb2_dc_dmabuf_ops_detach,
.map_dma_buf = vb2_dc_dmabuf_ops_map,
.unmap_dma_buf = vb2_dc_dmabuf_ops_unmap,
.map = vb2_dc_dmabuf_ops_kmap,
//!.map_atomic = vb2_dc_dmabuf_ops_kmap,
.vmap = vb2_dc_dmabuf_ops_vmap,
.mmap = vb2_dc_dmabuf_ops_mmap,
.release = vb2_dc_dmabuf_ops_release,
};
static struct sg_table *vb2_dc_get_base_sgt(struct vb2_dc_buf *buf)
{
int ret;
struct sg_table *sgt;
sgt = kmalloc(sizeof(*sgt), GFP_KERNEL);
if (!sgt) {
//dev_info(buf->dev, "failed to alloc sg table\n");
return NULL;
}
ret = dma_get_sgtable_attrs(buf->dev, sgt, buf->cookie, buf->dma_addr,
buf->size, buf->attrs);
if (ret < 0) {
dev_info(buf->dev, "failed to get scatterlist from DMA API\n");
kfree(sgt);
return NULL;
}
return sgt;
}
struct dma_buf *vb2_dc_get_dmabuf(void *buf_priv, unsigned long flags)
{
struct vb2_dc_buf *buf = buf_priv;
struct dma_buf *dbuf;
DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
exp_info.ops = &vb2_dc_dmabuf_ops;
exp_info.size = buf->size;
exp_info.flags = flags;
exp_info.priv = buf;
if (!buf->sgt_base)
buf->sgt_base = vb2_dc_get_base_sgt(buf);
if (WARN_ON(!buf->sgt_base))
return NULL;
dbuf = dma_buf_export(&exp_info);
if (IS_ERR(dbuf))
return NULL;
/* dmabuf keeps reference to vb2 buffer */
refcount_inc(&buf->refcount);
return dbuf;
}
/*********************************************/
/* callbacks for USERPTR buffers */
/*********************************************/
#ifdef vb2_mmap
static void vb2_dc_put_userptr(void *buf_priv)
{
struct vb2_dc_buf *buf = buf_priv;
struct sg_table *sgt = buf->dma_sgt;
int i;
struct page **pages;
if (sgt) {
/*
* No need to sync to CPU, it's already synced to the CPU
* since the finish() memop will have been called before this.
*/
dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
pages = frame_vector_pages(buf->vec);
/* sgt should exist only if vector contains pages... */
//BUG_ON(IS_ERR(pages));
WARN_ON(IS_ERR(pages));
for (i = 0; i < frame_vector_count(buf->vec); i++)
set_page_dirty_lock(pages[i]);
sg_free_table(sgt);
kfree(sgt);
}
vb2_destroy_framevec(buf->vec);
kfree(buf);
}
#endif
/*
* For some kind of reserved memory there might be no struct page available,
* so all that can be done to support such 'pages' is to try to convert
* pfn to dma address or at the last resort just assume that
* dma address == physical address (like it has been assumed in earlier version
* of videobuf2-dma-contig
*/
#ifdef __arch_pfn_to_dma
static inline dma_addr_t vb2_dc_pfn_to_dma(struct device *dev,
unsigned long pfn)
{
return (dma_addr_t)__arch_pfn_to_dma(dev, pfn);
}
#elif defined(__pfn_to_bus)
static inline dma_addr_t vb2_dc_pfn_to_dma(struct device *dev,
unsigned long pfn)
{
return (dma_addr_t)__pfn_to_bus(pfn);
}
#elif defined(__pfn_to_phys)
static inline dma_addr_t vb2_dc_pfn_to_dma(struct device *dev,
unsigned long pfn)
{
return (dma_addr_t)__pfn_to_phys(pfn);
}
#else
static inline dma_addr_t vb2_dc_pfn_to_dma(struct device *dev,
unsigned long pfn)
{
/* really, we cannot do anything better at this point */
return (dma_addr_t)(pfn) << PAGE_SHIFT;
}
#endif
#ifdef vb2_mmap
static void *vb2_dc_get_userptr(struct device *dev, unsigned long vaddr,
unsigned long size, enum dma_data_direction dma_dir)
{
struct vb2_dc_buf *buf;
struct frame_vector *vec;
unsigned long offset;
int n_pages, i;
int ret = 0;
struct sg_table *sgt;
unsigned long contig_size;
unsigned long dma_align = dma_get_cache_alignment();
/* Only cache aligned DMA transfers are reliable */
if (!IS_ALIGNED(vaddr | size, dma_align)) {
pr_debug("user data must be aligned to %lu bytes\n", dma_align);
return ERR_PTR(-EINVAL);
}
if (!size) {
pr_debug("size is zero\n");
return ERR_PTR(-EINVAL);
}
if (WARN_ON(!dev))
return ERR_PTR(-EINVAL);
buf = kzalloc(sizeof(*buf), GFP_KERNEL);
if (!buf)
return ERR_PTR(-ENOMEM);
buf->dev = dev;
buf->dma_dir = dma_dir;
offset = vaddr & ~PAGE_MASK;
vec = vb2_create_framevec(vaddr, size, dma_dir == DMA_FROM_DEVICE ||
dma_dir == DMA_BIDIRECTIONAL);
if (IS_ERR(vec)) {
ret = PTR_ERR(vec);
goto fail_buf;
}
buf->vec = vec;
n_pages = frame_vector_count(vec);
ret = frame_vector_to_pages(vec);
if (ret < 0) {
unsigned long *nums = frame_vector_pfns(vec);
/*
* Failed to convert to pages... Check the memory is physically
* contiguous and use direct mapping
*/
for (i = 1; i < n_pages; i++)
if (nums[i-1] + 1 != nums[i])
goto fail_pfnvec;
buf->dma_addr = vb2_dc_pfn_to_dma(buf->dev, nums[0]);
goto out;
}
sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
if (!sgt) {
//pr_info("failed to allocate sg table\n");
ret = -ENOMEM;
goto fail_pfnvec;
}
ret = sg_alloc_table_from_pages(sgt, frame_vector_pages(vec), n_pages,
offset, size, GFP_KERNEL);
if (ret) {
pr_info("failed to initialize sg table\n");
goto fail_sgt;
}
/*
* No need to sync to the device, this will happen later when the
* prepare() memop is called.
*/
sgt->nents = dma_map_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
if (sgt->nents <= 0) {
pr_info("failed to map scatterlist\n");
ret = -EIO;
goto fail_sgt_init;
}
contig_size = vb2_dc_get_contiguous_size(sgt);
if (contig_size < size) {
pr_info("contiguous mapping is too small %lu/%lu\n",
contig_size, size);
ret = -EFAULT;
goto fail_map_sg;
}
buf->dma_addr = sg_dma_address(sgt->sgl);
buf->dma_sgt = sgt;
out:
buf->size = size;
return buf;
fail_map_sg:
dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
fail_sgt_init:
sg_free_table(sgt);
fail_sgt:
kfree(sgt);
fail_pfnvec:
vb2_destroy_framevec(vec);
fail_buf:
kfree(buf);
return ERR_PTR(ret);
}
#endif
/*********************************************/
/* callbacks for DMABUF buffers */
/*********************************************/
int vb2_dc_map_dmabuf(void *mem_priv)
{
struct vb2_dc_buf *buf = mem_priv;
struct sg_table *sgt;
unsigned long contig_size;
dma_addr_t iommu_pa;
if (WARN_ON(!buf->db_attach)) {
pr_info("trying to pin a non attached buffer\n");
return -EINVAL;
}
if (WARN_ON(buf->dma_sgt)) {
pr_info("dmabuf buffer is already pinned\n");
return 0;
}
/* get the associated scatterlist for this buffer */
sgt = dma_buf_map_attachment(buf->db_attach, buf->dma_dir);
if (IS_ERR(sgt)) {
pr_info("Error getting dmabuf scatterlist\n");
return -EINVAL;
}
/* checking if dmabuf is big enough to store contiguous chunk */
contig_size = vb2_dc_get_contiguous_size(sgt);
if (contig_size < buf->size) {
#ifdef CONFIG_MTK_IOMMU_V2
pr_info("contiguous chunk is too small %lu/%lu b\n",
contig_size, buf->size);
#endif
dma_buf_unmap_attachment(buf->db_attach, sgt, buf->dma_dir);
#ifdef CONFIG_MTK_IOMMU_V2
return -EFAULT;
#endif
}
buf->dma_addr = sg_dma_address(sgt->sgl);
iommu_pa = sg_phys(sgt->sgl); // gasper DBG
buf->dma_sgt = sgt;
buf->vaddr = NULL;
pr_debug("[iommu_iova] [0x%lX]\n", buf->dma_addr);
pr_debug("[iommu_pa] [0x%lX]\n", iommu_pa);
return 0;
}
void vb2_dc_unmap_dmabuf(void *mem_priv)
{
struct vb2_dc_buf *buf = mem_priv;
struct sg_table *sgt = buf->dma_sgt;
if (WARN_ON(!buf->db_attach)) {
pr_info("trying to unpin a not attached buffer\n");
return;
}
if (WARN_ON(!sgt)) {
pr_info("dmabuf buffer is already unpinned\n");
return;
}
if (buf->vaddr) {
dma_buf_vunmap(buf->db_attach->dmabuf, buf->vaddr);
buf->vaddr = NULL;
}
dma_buf_unmap_attachment(buf->db_attach, sgt, buf->dma_dir);
buf->dma_addr = 0;
buf->dma_sgt = NULL;
}
void vb2_dc_detach_dmabuf(void *mem_priv)
{
struct vb2_dc_buf *buf = mem_priv;
/* if vb2 works correctly you should never detach mapped buffer */
if (WARN_ON(buf->dma_addr))
vb2_dc_unmap_dmabuf(buf);
/* detach this attachment */
dma_buf_detach(buf->db_attach->dmabuf, buf->db_attach);
kfree(buf);
}
void *vb2_dc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf,
unsigned long size, enum dma_data_direction dma_dir)
{
struct vb2_dc_buf *buf;
struct dma_buf_attachment *dba;
if (dbuf->size < size)
return ERR_PTR(-EFAULT);
if (WARN_ON(!dev))
return ERR_PTR(-EINVAL);
buf = kzalloc(sizeof(*buf), GFP_KERNEL);
if (!buf)
return ERR_PTR(-ENOMEM);
buf->dev = dev;
/* create attachment for the dmabuf with the user device */
dba = dma_buf_attach(dbuf, buf->dev);
if (IS_ERR(dba)) {
pr_info("failed to attach dmabuf\n");
kfree(buf);
return dba;
}
buf->dma_dir = dma_dir;
buf->size = size;
buf->db_attach = dba;
return buf;
}
/*********************************************/
/* DMA CONTIG exported functions */
/*********************************************/
const struct vb2_mem_ops vb2_dpe_dma_contig_memops = {
.alloc = vb2_dc_alloc,
.put = vb2_dc_put,
.get_dmabuf = vb2_dc_get_dmabuf,
.cookie = vb2_dc_cookie,
.vaddr = vb2_dc_vaddr,
//.mmap = vb2_dc_mmap,
//.get_userptr = vb2_dc_get_userptr,
//.put_userptr = vb2_dc_put_userptr,
.prepare = vb2_dc_prepare,
.finish = vb2_dc_finish,
.map_dmabuf = vb2_dc_map_dmabuf,
.unmap_dmabuf = vb2_dc_unmap_dmabuf,
.attach_dmabuf = vb2_dc_attach_dmabuf,
.detach_dmabuf = vb2_dc_detach_dmabuf,
.num_users = vb2_dc_num_users,
};
EXPORT_SYMBOL_GPL(vb2_dpe_dma_contig_memops);
/**
* vb2_dpe_dma_contig_set_max_seg_size() - configure DMA max segment size
* @dev: device for configuring DMA parameters
* @size: size of DMA max segment size to set
*
* To allow mapping the scatter-list into a single chunk in the DMA
* address space, the device is required to have the DMA max segment
* size parameter set to a value larger than the buffer size. Otherwise,
* the DMA-mapping subsystem will split the mapping into max segment
* size chunks. This function sets the DMA max segment size
* parameter to let DMA-mapping map a buffer as a single chunk in DMA
* address space.
* This code assumes that the DMA-mapping subsystem will merge all
* scatterlist segments if this is really possible (for example when
* an IOMMU is available and enabled).
* Ideally, this parameter should be set by the generic bus code, but it
* is left with the default 64KiB value due to historical litmiations in
* other subsystems (like limited USB host drivers) and there no good
* place to set it to the proper value.
* This function should be called from the drivers, which are known to
* operate on platforms with IOMMU and provide access to shared buffers
* (either USERPTR or DMABUF). This should be done before initializing
* videobuf2 queue.
*/
int vb2_dpe_dma_contig_set_max_seg_size(struct device *dev, unsigned int size)
{
if (!dev->dma_parms) {
dev->dma_parms = kzalloc(sizeof(*dev->dma_parms), GFP_KERNEL);
if (!dev->dma_parms)
return -ENOMEM;
}
if (dma_get_max_seg_size(dev) < size)
return dma_set_max_seg_size(dev, size);
return 0;
}
EXPORT_SYMBOL_GPL(vb2_dpe_dma_contig_set_max_seg_size);
/*
* vb2_dpe_dma_contig_clear_max_seg_size() -
* release resources for DMA parameters
* @dev: device for configuring DMA parameters
*
* This function releases resources allocated to configure DMA parameters
* (see vb2_dpe_dma_contig_set_max_seg_size() function).
* It should be called from device drivers on driver remove.
*/
void vb2_dpe_dma_contig_clear_max_seg_size(struct device *dev)
{
kfree(dev->dma_parms);
dev->dma_parms = NULL;
}
EXPORT_SYMBOL_GPL(vb2_dpe_dma_contig_clear_max_seg_size);
MODULE_DESCRIPTION("DMA-contig memory handling routines for videobuf2");
MODULE_AUTHOR("Pawel Osciak <pawel@osciak.com>");
MODULE_LICENSE("GPL");
@@ -0,0 +1,41 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef _MEDIA_VIDEOBUF2_DMA_CONTIG_H
#define _MEDIA_VIDEOBUF2_DMA_CONTIG_H
#include <media/videobuf2-v4l2.h>
#include <linux/dma-mapping.h>
static inline dma_addr_t
vb2_dma_contig_plane_dma_addr(struct vb2_buffer *vb, unsigned int plane_no)
{
dma_addr_t *addr = vb2_plane_cookie(vb, plane_no);
return *addr;
}
int vb2_dpe_dma_contig_set_max_seg_size(struct device *dev, unsigned int size);
void vb2_dpe_dma_contig_clear_max_seg_size(struct device *dev);
extern const struct vb2_mem_ops vb2_dpe_dma_contig_memops;
void *vb2_dc_alloc(struct device *dev, unsigned long attrs,
unsigned long size, enum dma_data_direction dma_dir,
gfp_t gfp_flags);
struct dma_buf *vb2_dc_get_dmabuf(void *buf_priv, unsigned long flags);
void *vb2_dc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf,
unsigned long size, enum dma_data_direction dma_dir);
int vb2_dc_map_dmabuf(void *mem_priv);
void vb2_dc_unmap_dmabuf(void *mem_priv);
void vb2_dc_detach_dmabuf(void *mem_priv);
void vb2_dc_put(void *buf_priv);
extern struct frame_vector *vb2_create_framevec(unsigned long start,
unsigned long length,
bool write);
#endif