samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
포크 0
코드 이슈 풀 리퀘스트 Actions Packages Projects 릴리즈 위키 활동
Files
6bf23cf65c3afdaf51aefbce64ee9307e5301836
android_kernel_samsung_sm86…/driver/vidc/inc/msm_vidc_internal.h
Darshana Patil 1ef323df29 video: driver: buffer flow changes 
When client queued a buffer, v4l2 framework
compares the client Dmabuf with the existing
dmabuf in the bufs array at the same index.
If the dmabuf is different then v4l2 framework
would call unmap_dmabuf, detach_dmabuf callbacks
for the old buffer and then calls attach_dmabuf,
map_dmabuf callbacks for the new buffer before
qbuf callback is made to driver. If the dmabuf
is same then qbuf callback will be made directly.

V4l2 framework expects that clients recycles the
same buffers in the same indices so that when
v4l2 framework compares dmabuf it won't unmap
or map buffers.

If client recycle the buffers in different indices
still usecase works but there will be unnecessary
unmap, map overhead will be incurred.

If client does not recycle the buffers at all,
meaning every time client queues new buffers
then special handling is required for decoder
output buffers which are used for reference by
video hardware.If any buffers are used by video
hardware as reference buffers then firmware returns
those buffers with READ_ONLY flag and they are kept
in read_only list and when read_only grows beyond
some limit then driver would ask firmware to release
those READ_ONLY buffers and when firmware responds
driver would delete these READ_ONLY buffers.

Change-Id: I8a0b11c986dd0b9464895498efd8c1831a754198
Signed-off-by: Darshana Patil <quic_darshana@quicinc.com>
2022-09-26 17:24:30 -07:00

973 lines
26 KiB
C
Raw Blame 히스토리

/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2020-2021,, The Linux Foundation. All rights reserved.
*/
#ifndef _MSM_VIDC_INTERNAL_H_
#define _MSM_VIDC_INTERNAL_H_
#include <linux/version.h>
#include <linux/bits.h>
#include <linux/workqueue.h>
#include <linux/spinlock.h>
#include <linux/sync_file.h>
#include <linux/dma-fence.h>
#include <media/v4l2-dev.h>
#include <media/v4l2-device.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-event.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-mem2mem.h>
#include <media/videobuf2-core.h>
#include <media/videobuf2-v4l2.h>
struct msm_vidc_inst;
/* TODO : remove once available in mainline kernel */
#ifndef V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10_STILL_PICTURE
#define V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10_STILL_PICTURE (3)
#endif
enum msm_vidc_blur_types {
MSM_VIDC_BLUR_NONE = 0x0,
MSM_VIDC_BLUR_EXTERNAL = 0x1,
MSM_VIDC_BLUR_ADAPTIVE = 0x2,
};
/* various Metadata - encoder & decoder */
enum msm_vidc_metadata_bits {
MSM_VIDC_META_DISABLE = 0x0,
MSM_VIDC_META_ENABLE = 0x1,
MSM_VIDC_META_TX_INPUT = 0x2,
MSM_VIDC_META_TX_OUTPUT = 0x4,
MSM_VIDC_META_RX_INPUT = 0x8,
MSM_VIDC_META_RX_OUTPUT = 0x10,
MSM_VIDC_META_MAX = 0x20,
};
#define MSM_VIDC_METADATA_SIZE (4 * 4096) /* 16 KB */
#define ENCODE_INPUT_METADATA_SIZE (512 * 4096) /* 2 MB */
#define DECODE_INPUT_METADATA_SIZE MSM_VIDC_METADATA_SIZE
#define MSM_VIDC_METADATA_DOLBY_RPU_SIZE (41 * 1024) /* 41 KB */
#define MAX_NAME_LENGTH 128
#define VENUS_VERSION_LENGTH 128
#define MAX_MATRIX_COEFFS 9
#define MAX_BIAS_COEFFS 3
#define MAX_LIMIT_COEFFS 6
#define MAX_DEBUGFS_NAME 50
#define DEFAULT_HEIGHT 240
#define DEFAULT_WIDTH 320
#define DEFAULT_FPS 30
#define MAXIMUM_VP9_FPS 60
#define NRT_PRIORITY_OFFSET 2
#define RT_DEC_DOWN_PRORITY_OFFSET 1
#define MAX_SUPPORTED_INSTANCES 16
#define DEFAULT_BSE_VPP_DELAY 2
#define MAX_CAP_PARENTS 20
#define MAX_CAP_CHILDREN 20
#define DEFAULT_MAX_HOST_BUF_COUNT 64
#define DEFAULT_MAX_HOST_BURST_BUF_COUNT 256
#define BIT_DEPTH_8 (8 << 16 | 8)
#define BIT_DEPTH_10 (10 << 16 | 10)
#define CODED_FRAMES_PROGRESSIVE 0x0
#define CODED_FRAMES_INTERLACE 0x1
#define MAX_VP9D_INST_COUNT 6
/* TODO: move below macros to waipio.c */
#define MAX_ENH_LAYER_HB 3
#define MAX_HEVC_VBR_ENH_LAYER_SLIDING_WINDOW 5
#define MAX_HEVC_NON_VBR_ENH_LAYER_SLIDING_WINDOW 3
#define MAX_AVC_ENH_LAYER_SLIDING_WINDOW 3
#define MAX_AVC_ENH_LAYER_HYBRID_HP 5
#define INVALID_DEFAULT_MARK_OR_USE_LTR -1
#define MAX_SLICES_PER_FRAME 10
#define MAX_SLICES_FRAME_RATE 60
#define MAX_MB_SLICE_WIDTH 4096
#define MAX_MB_SLICE_HEIGHT 2160
#define MAX_BYTES_SLICE_WIDTH 1920
#define MAX_BYTES_SLICE_HEIGHT 1088
#define MIN_HEVC_SLICE_WIDTH 384
#define MIN_AVC_SLICE_WIDTH 192
#define MIN_SLICE_HEIGHT 128
#define MAX_BITRATE_BOOST 25
#define MAX_SUPPORTED_MIN_QUALITY 70
#define MIN_CHROMA_QP_OFFSET -12
#define MAX_CHROMA_QP_OFFSET 0
#define MIN_QP_10BIT -11
#define MIN_QP_8BIT 1
#define INVALID_FD -1
#define INVALID_CLIENT_ID -1
#define DCVS_WINDOW 16
#define ENC_FPS_WINDOW 3
#define DEC_FPS_WINDOW 10
#define INPUT_TIMER_LIST_SIZE 30
#define DEFAULT_COMPLEXITY 50
#define INPUT_MPLANE V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
#define OUTPUT_MPLANE V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
#define INPUT_META_PLANE V4L2_BUF_TYPE_META_OUTPUT
#define OUTPUT_META_PLANE V4L2_BUF_TYPE_META_CAPTURE
#define VIDC_IFACEQ_MAX_PKT_SIZE 1024
#define VIDC_IFACEQ_MED_PKT_SIZE 768
#define VIDC_IFACEQ_MIN_PKT_SIZE 8
#define VIDC_IFACEQ_VAR_SMALL_PKT_SIZE 100
#define VIDC_IFACEQ_VAR_LARGE_PKT_SIZE 512
#define VIDC_IFACEQ_VAR_HUGE_PKT_SIZE (1024*4)
#define NUM_MBS_PER_SEC(__height, __width, __fps) \
(NUM_MBS_PER_FRAME(__height, __width) * __fps)
#define NUM_MBS_PER_FRAME(__height, __width) \
((ALIGN(__height, 16) / 16) * (ALIGN(__width, 16) / 16))
#ifdef V4L2_CTRL_CLASS_CODEC
#define IS_PRIV_CTRL(idx) ( \
(V4L2_CTRL_ID2WHICH(idx) == V4L2_CTRL_CLASS_CODEC) && \
V4L2_CTRL_DRIVER_PRIV(idx))
#else
#define IS_PRIV_CTRL(idx) ( \
(V4L2_CTRL_ID2WHICH(idx) == V4L2_CTRL_CLASS_MPEG) && \
V4L2_CTRL_DRIVER_PRIV(idx))
#endif
#define BUFFER_ALIGNMENT_SIZE(x) x
#define NUM_MBS_360P (((480 + 15) >> 4) * ((360 + 15) >> 4))
#define NUM_MBS_720P (((1280 + 15) >> 4) * ((720 + 15) >> 4))
#define NUM_MBS_4k (((4096 + 15) >> 4) * ((2304 + 15) >> 4))
#define MB_SIZE_IN_PIXEL (16 * 16)
#define DB_H264_DISABLE_SLICE_BOUNDARY \
V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY
#define DB_HEVC_DISABLE_SLICE_BOUNDARY \
V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY
/*
* Convert Q16 number into Integer and Fractional part upto 2 places.
* Ex : 105752 / 65536 = 1.61; 1.61 in Q16 = 105752;
* Integer part = 105752 / 65536 = 1;
* Reminder = 105752 * 0xFFFF = 40216; Last 16 bits.
* Fractional part = 40216 * 100 / 65536 = 61;
* Now convert to FP(1, 61, 100).
*/
#define Q16_INT(q) ((q) >> 16)
#define Q16_FRAC(q) ((((q) & 0xFFFF) * 100) >> 16)
/* define timeout values */
#define HW_RESPONSE_TIMEOUT_VALUE (1000)
#define SW_PC_DELAY_VALUE (HW_RESPONSE_TIMEOUT_VALUE + 500)
#define FW_UNLOAD_DELAY_VALUE (SW_PC_DELAY_VALUE + 1500)
#define MAX_MAP_OUTPUT_COUNT 64
#define MAX_DPB_COUNT 32
/*
* max dpb count in firmware = 16
* each dpb: 4 words - <base_address, addr_offset, data_offset>
* dpb list array size = 16 * 4
* dpb payload size = 16 * 4 * 4
*/
#define MAX_DPB_LIST_ARRAY_SIZE (16 * 4)
#define MAX_DPB_LIST_PAYLOAD_SIZE (16 * 4 * 4)
enum msm_vidc_domain_type {
MSM_VIDC_ENCODER = BIT(0),
MSM_VIDC_DECODER = BIT(1),
};
enum msm_vidc_codec_type {
MSM_VIDC_H264 = BIT(0),
MSM_VIDC_HEVC = BIT(1),
MSM_VIDC_VP9 = BIT(2),
MSM_VIDC_HEIC = BIT(3),
MSM_VIDC_AV1 = BIT(4),
};
enum msm_vidc_colorformat_type {
MSM_VIDC_FMT_NONE = 0,
MSM_VIDC_FMT_NV12C = BIT(0),
MSM_VIDC_FMT_NV12 = BIT(1),
MSM_VIDC_FMT_NV21 = BIT(2),
MSM_VIDC_FMT_TP10C = BIT(3),
MSM_VIDC_FMT_P010 = BIT(4),
MSM_VIDC_FMT_RGBA8888C = BIT(5),
MSM_VIDC_FMT_RGBA8888 = BIT(6),
MSM_VIDC_FMT_META = BIT(31),
};
enum msm_vidc_buffer_type {
MSM_VIDC_BUF_INPUT = 1,
MSM_VIDC_BUF_OUTPUT = 2,
MSM_VIDC_BUF_INPUT_META = 3,
MSM_VIDC_BUF_OUTPUT_META = 4,
MSM_VIDC_BUF_READ_ONLY = 5,
MSM_VIDC_BUF_QUEUE = 6,
MSM_VIDC_BUF_BIN = 7,
MSM_VIDC_BUF_ARP = 8,
MSM_VIDC_BUF_COMV = 9,
MSM_VIDC_BUF_NON_COMV = 10,
MSM_VIDC_BUF_LINE = 11,
MSM_VIDC_BUF_DPB = 12,
MSM_VIDC_BUF_PERSIST = 13,
MSM_VIDC_BUF_VPSS = 14,
MSM_VIDC_BUF_PARTIAL_DATA = 15,
};
/* always match with v4l2 flags V4L2_BUF_FLAG_* */
enum msm_vidc_buffer_flags {
MSM_VIDC_BUF_FLAG_KEYFRAME = 0x00000008,
MSM_VIDC_BUF_FLAG_PFRAME = 0x00000010,
MSM_VIDC_BUF_FLAG_BFRAME = 0x00000020,
MSM_VIDC_BUF_FLAG_ERROR = 0x00000040,
MSM_VIDC_BUF_FLAG_LAST = 0x00100000,
/* codec config is a vendor specific flag */
MSM_VIDC_BUF_FLAG_CODECCONFIG = 0x01000000,
/* sub frame is a vendor specific flag */
MSM_VIDC_BUF_FLAG_SUBFRAME = 0x02000000,
};
enum msm_vidc_buffer_attributes {
MSM_VIDC_ATTR_DEFERRED = BIT(0),
MSM_VIDC_ATTR_READ_ONLY = BIT(1),
MSM_VIDC_ATTR_PENDING_RELEASE = BIT(2),
MSM_VIDC_ATTR_QUEUED = BIT(3),
MSM_VIDC_ATTR_DEQUEUED = BIT(4),
MSM_VIDC_ATTR_BUFFER_DONE = BIT(5),
};
enum msm_vidc_buffer_region {
MSM_VIDC_REGION_NONE = 0,
MSM_VIDC_NON_SECURE,
MSM_VIDC_NON_SECURE_PIXEL,
MSM_VIDC_SECURE_PIXEL,
MSM_VIDC_SECURE_NONPIXEL,
MSM_VIDC_SECURE_BITSTREAM,
};
enum msm_vidc_port_type {
INPUT_PORT = 0,
OUTPUT_PORT,
INPUT_META_PORT,
OUTPUT_META_PORT,
PORT_NONE,
MAX_PORT,
};
enum msm_vidc_stage_type {
MSM_VIDC_STAGE_NONE = 0,
MSM_VIDC_STAGE_1 = 1,
MSM_VIDC_STAGE_2 = 2,
};
enum msm_vidc_pipe_type {
MSM_VIDC_PIPE_NONE = 0,
MSM_VIDC_PIPE_1 = 1,
MSM_VIDC_PIPE_2 = 2,
MSM_VIDC_PIPE_4 = 4,
};
enum msm_vidc_quality_mode {
MSM_VIDC_MAX_QUALITY_MODE = 0x1,
MSM_VIDC_POWER_SAVE_MODE = 0x2,
};
enum msm_vidc_color_primaries {
MSM_VIDC_PRIMARIES_RESERVED = 0,
MSM_VIDC_PRIMARIES_BT709 = 1,
MSM_VIDC_PRIMARIES_UNSPECIFIED = 2,
MSM_VIDC_PRIMARIES_BT470_SYSTEM_M = 4,
MSM_VIDC_PRIMARIES_BT470_SYSTEM_BG = 5,
MSM_VIDC_PRIMARIES_BT601_525 = 6,
MSM_VIDC_PRIMARIES_SMPTE_ST240M = 7,
MSM_VIDC_PRIMARIES_GENERIC_FILM = 8,
MSM_VIDC_PRIMARIES_BT2020 = 9,
MSM_VIDC_PRIMARIES_SMPTE_ST428_1 = 10,
MSM_VIDC_PRIMARIES_SMPTE_RP431_2 = 11,
MSM_VIDC_PRIMARIES_SMPTE_EG431_1 = 12,
MSM_VIDC_PRIMARIES_SMPTE_EBU_TECH = 22,
};
enum msm_vidc_transfer_characteristics {
MSM_VIDC_TRANSFER_RESERVED = 0,
MSM_VIDC_TRANSFER_BT709 = 1,
MSM_VIDC_TRANSFER_UNSPECIFIED = 2,
MSM_VIDC_TRANSFER_BT470_SYSTEM_M = 4,
MSM_VIDC_TRANSFER_BT470_SYSTEM_BG = 5,
MSM_VIDC_TRANSFER_BT601_525_OR_625 = 6,
MSM_VIDC_TRANSFER_SMPTE_ST240M = 7,
MSM_VIDC_TRANSFER_LINEAR = 8,
MSM_VIDC_TRANSFER_LOG_100_1 = 9,
MSM_VIDC_TRANSFER_LOG_SQRT = 10,
MSM_VIDC_TRANSFER_XVYCC = 11,
MSM_VIDC_TRANSFER_BT1361_0 = 12,
MSM_VIDC_TRANSFER_SRGB_SYCC = 13,
MSM_VIDC_TRANSFER_BT2020_14 = 14,
MSM_VIDC_TRANSFER_BT2020_15 = 15,
MSM_VIDC_TRANSFER_SMPTE_ST2084_PQ = 16,
MSM_VIDC_TRANSFER_SMPTE_ST428_1 = 17,
MSM_VIDC_TRANSFER_BT2100_2_HLG = 18,
};
enum msm_vidc_matrix_coefficients {
MSM_VIDC_MATRIX_COEFF_SRGB_SMPTE_ST428_1 = 0,
MSM_VIDC_MATRIX_COEFF_BT709 = 1,
MSM_VIDC_MATRIX_COEFF_UNSPECIFIED = 2,
MSM_VIDC_MATRIX_COEFF_RESERVED = 3,
MSM_VIDC_MATRIX_COEFF_FCC_TITLE_47 = 4,
MSM_VIDC_MATRIX_COEFF_BT470_SYS_BG_OR_BT601_625 = 5,
MSM_VIDC_MATRIX_COEFF_BT601_525_BT1358_525_OR_625 = 6,
MSM_VIDC_MATRIX_COEFF_SMPTE_ST240 = 7,
MSM_VIDC_MATRIX_COEFF_YCGCO = 8,
MSM_VIDC_MATRIX_COEFF_BT2020_NON_CONSTANT = 9,
MSM_VIDC_MATRIX_COEFF_BT2020_CONSTANT = 10,
MSM_VIDC_MATRIX_COEFF_SMPTE_ST2085 = 11,
MSM_VIDC_MATRIX_COEFF_SMPTE_CHROM_DERV_NON_CONSTANT = 12,
MSM_VIDC_MATRIX_COEFF_SMPTE_CHROM_DERV_CONSTANT = 13,
MSM_VIDC_MATRIX_COEFF_BT2100 = 14,
};
enum msm_vidc_preprocess_type {
MSM_VIDC_PREPROCESS_NONE = BIT(0),
MSM_VIDC_PREPROCESS_TYPE0 = BIT(1),
};
enum msm_vidc_core_capability_type {
CORE_CAP_NONE = 0,
ENC_CODECS,
DEC_CODECS,
MAX_SESSION_COUNT,
MAX_NUM_720P_SESSIONS,
MAX_NUM_1080P_SESSIONS,
MAX_NUM_4K_SESSIONS,
MAX_NUM_8K_SESSIONS,
MAX_SECURE_SESSION_COUNT,
MAX_LOAD,
MAX_RT_MBPF,
MAX_MBPF,
MAX_MBPS,
MAX_IMAGE_MBPF,
MAX_MBPF_HQ,
MAX_MBPS_HQ,
MAX_MBPF_B_FRAME,
MAX_MBPS_B_FRAME,
MAX_MBPS_ALL_INTRA,
MAX_ENH_LAYER_COUNT,
NUM_VPP_PIPE,
SW_PC,
SW_PC_DELAY,
FW_UNLOAD,
FW_UNLOAD_DELAY,
HW_RESPONSE_TIMEOUT,
PREFIX_BUF_COUNT_PIX,
PREFIX_BUF_SIZE_PIX,
PREFIX_BUF_COUNT_NON_PIX,
PREFIX_BUF_SIZE_NON_PIX,
PAGEFAULT_NON_FATAL,
PAGETABLE_CACHING,
DCVS,
DECODE_BATCH,
DECODE_BATCH_TIMEOUT,
STATS_TIMEOUT_MS,
AV_SYNC_WINDOW_SIZE,
CLK_FREQ_THRESHOLD,
NON_FATAL_FAULTS,
ENC_AUTO_FRAMERATE,
MMRM,
DEVICE_CAPS,
SUPPORTS_REQUESTS,
CORE_CAP_MAX,
};
/**
* msm_vidc_prepare_dependency_list() api will prepare caps_list by looping over
* enums(msm_vidc_inst_capability_type) from 0 to INST_CAP_MAX and arranges the
* node in such a way that parents willbe at the front and dependent children
* in the back.
*
* caps_list preparation may become CPU intensive task, so to save CPU cycles,
* organize enum in proper order(root caps at the beginning and dependent caps
* at back), so that during caps_list preparation num CPU cycles spent will reduce.
*
* Note: It will work, if enum kept at different places, but not efficient.
*/
enum msm_vidc_inst_capability_type {
INST_CAP_NONE = 0,
/* place all metadata after this line
*/
META_SEQ_HDR_NAL,
META_BITSTREAM_RESOLUTION,
META_CROP_OFFSETS,
META_DPB_MISR,
META_OPB_MISR,
META_INTERLACE,
META_OUTBUF_FENCE,
META_LTR_MARK_USE,
META_TIMESTAMP,
META_CONCEALED_MB_CNT,
META_HIST_INFO,
META_PICTURE_TYPE,
META_SEI_MASTERING_DISP,
META_SEI_CLL,
META_HDR10PLUS,
META_BUF_TAG,
META_DPB_TAG_LIST,
META_SUBFRAME_OUTPUT,
META_ENC_QP_METADATA,
META_DEC_QP_METADATA,
META_MAX_NUM_REORDER_FRAMES,
META_EVA_STATS,
META_ROI_INFO,
META_SALIENCY_INFO,
META_TRANSCODING_STAT_INFO,
META_DOLBY_RPU,
/* end of metadata caps */
FRAME_WIDTH,
LOSSLESS_FRAME_WIDTH,
SECURE_FRAME_WIDTH,
FRAME_HEIGHT,
LOSSLESS_FRAME_HEIGHT,
SECURE_FRAME_HEIGHT,
PIX_FMTS,
MIN_BUFFERS_INPUT,
MIN_BUFFERS_OUTPUT,
MBPF,
BATCH_MBPF,
BATCH_FPS,
LOSSLESS_MBPF,
SECURE_MBPF,
MBPS,
POWER_SAVE_MBPS,
CHECK_MBPS,
FRAME_RATE,
OPERATING_RATE,
INPUT_RATE,
TIMESTAMP_RATE,
SCALE_FACTOR,
MB_CYCLES_VSP,
MB_CYCLES_VPP,
MB_CYCLES_LP,
MB_CYCLES_FW,
MB_CYCLES_FW_VPP,
CLIENT_ID,
SECURE_MODE,
FENCE_ID,
FENCE_FD,
TS_REORDER,
HFLIP,
VFLIP,
ROTATION,
SUPER_FRAME,
HEADER_MODE,
PREPEND_SPSPPS_TO_IDR,
WITHOUT_STARTCODE,
NAL_LENGTH_FIELD,
REQUEST_I_FRAME,
BITRATE_MODE,
LOSSLESS,
FRAME_SKIP_MODE,
FRAME_RC_ENABLE,
GOP_CLOSURE,
CSC,
CSC_CUSTOM_MATRIX,
USE_LTR,
MARK_LTR,
BASELAYER_PRIORITY,
IR_TYPE,
AU_DELIMITER,
GRID,
I_FRAME_MIN_QP,
P_FRAME_MIN_QP,
B_FRAME_MIN_QP,
I_FRAME_MAX_QP,
P_FRAME_MAX_QP,
B_FRAME_MAX_QP,
LAYER_TYPE,
LAYER_ENABLE,
L0_BR,
L1_BR,
L2_BR,
L3_BR,
L4_BR,
L5_BR,
LEVEL,
HEVC_TIER,
AV1_TIER,
DISPLAY_DELAY_ENABLE,
DISPLAY_DELAY,
CONCEAL_COLOR_8BIT,
CONCEAL_COLOR_10BIT,
LF_MODE,
LF_ALPHA,
LF_BETA,
SLICE_MAX_BYTES,
SLICE_MAX_MB,
MB_RC,
CHROMA_QP_INDEX_OFFSET,
PIPE,
POC,
CODED_FRAMES,
BIT_DEPTH,
CODEC_CONFIG,
BITSTREAM_SIZE_OVERWRITE,
THUMBNAIL_MODE,
DEFAULT_HEADER,
RAP_FRAME,
SEQ_CHANGE_AT_SYNC_FRAME,
QUALITY_MODE,
PRIORITY,
FIRMWARE_PRIORITY_OFFSET,
CRITICAL_PRIORITY,
RESERVE_DURATION,
DPB_LIST,
FILM_GRAIN,
SUPER_BLOCK,
DRAP,
ENC_IP_CR,
COMPLEXITY,
CABAC_MAX_BITRATE,
CAVLC_MAX_BITRATE,
ALLINTRA_MAX_BITRATE,
LOWLATENCY_MAX_BITRATE,
LAST_FLAG_EVENT_ENABLE,
NUM_COMV,
/* place all root(no parent) enums before this line */
PROFILE,
ENH_LAYER_COUNT,
BIT_RATE,
LOWLATENCY_MODE,
GOP_SIZE,
B_FRAME,
ALL_INTRA,
MIN_QUALITY,
CONTENT_ADAPTIVE_CODING,
BLUR_TYPES,
REQUEST_PREPROCESS,
SLICE_MODE,
/* place all intermittent(having both parent and child) enums before this line */
MIN_FRAME_QP,
MAX_FRAME_QP,
I_FRAME_QP,
P_FRAME_QP,
B_FRAME_QP,
TIME_DELTA_BASED_RC,
CONSTANT_QUALITY,
VBV_DELAY,
PEAK_BITRATE,
ENTROPY_MODE,
TRANSFORM_8X8,
STAGE,
LTR_COUNT,
IR_PERIOD,
BITRATE_BOOST,
BLUR_RESOLUTION,
OUTPUT_ORDER,
INPUT_BUF_HOST_MAX_COUNT,
OUTPUT_BUF_HOST_MAX_COUNT,
DELIVERY_MODE,
VUI_TIMING_INFO,
SLICE_DECODE,
/* place all leaf(no child) enums before this line */
INST_CAP_MAX,
};
enum msm_vidc_inst_capability_flags {
CAP_FLAG_NONE = 0,
CAP_FLAG_DYNAMIC_ALLOWED = BIT(0),
CAP_FLAG_MENU = BIT(1),
CAP_FLAG_INPUT_PORT = BIT(2),
CAP_FLAG_OUTPUT_PORT = BIT(3),
CAP_FLAG_CLIENT_SET = BIT(4),
CAP_FLAG_BITMASK = BIT(5),
CAP_FLAG_VOLATILE = BIT(6),
CAP_FLAG_META = BIT(7),
};
struct msm_vidc_inst_cap {
enum msm_vidc_inst_capability_type cap_id;
s32 min;
s32 max;
u32 step_or_mask;
s32 value;
u32 v4l2_id;
u32 hfi_id;
enum msm_vidc_inst_capability_flags flags;
enum msm_vidc_inst_capability_type parents[MAX_CAP_PARENTS];
enum msm_vidc_inst_capability_type children[MAX_CAP_CHILDREN];
int (*adjust)(void *inst,
struct v4l2_ctrl *ctrl);
int (*set)(void *inst,
enum msm_vidc_inst_capability_type cap_id);
};
struct msm_vidc_inst_capability {
enum msm_vidc_domain_type domain;
enum msm_vidc_codec_type codec;
struct msm_vidc_inst_cap cap[INST_CAP_MAX+1];
};
struct msm_vidc_core_capability {
enum msm_vidc_core_capability_type type;
u32 value;
};
struct msm_vidc_inst_cap_entry {
/* list of struct msm_vidc_inst_cap_entry */
struct list_head list;
enum msm_vidc_inst_capability_type cap_id;
};
struct debug_buf_count {
u64 etb;
u64 ftb;
u64 fbd;
u64 ebd;
};
struct msm_vidc_statistics {
struct debug_buf_count count;
u64 data_size;
u64 time_ms;
};
enum efuse_purpose {
SKU_VERSION = 0,
};
enum sku_version {
SKU_VERSION_0 = 0,
SKU_VERSION_1,
SKU_VERSION_2,
};
enum msm_vidc_ssr_trigger_type {
SSR_ERR_FATAL = 1,
SSR_SW_DIV_BY_ZERO,
SSR_HW_WDOG_IRQ,
};
enum msm_vidc_stability_trigger_type {
STABILITY_VCODEC_HUNG = 1,
STABILITY_ENC_BUFFER_FULL,
};
enum msm_vidc_cache_op {
MSM_VIDC_CACHE_CLEAN,
MSM_VIDC_CACHE_INVALIDATE,
MSM_VIDC_CACHE_CLEAN_INVALIDATE,
};
enum msm_vidc_dcvs_flags {
MSM_VIDC_DCVS_INCR = BIT(0),
MSM_VIDC_DCVS_DECR = BIT(1),
};
enum msm_vidc_clock_properties {
CLOCK_PROP_HAS_SCALING = BIT(0),
CLOCK_PROP_HAS_MEM_RETENTION = BIT(1),
};
enum profiling_points {
FRAME_PROCESSING = 0,
MAX_PROFILING_POINTS,
};
enum signal_session_response {
SIGNAL_CMD_STOP_INPUT = 0,
SIGNAL_CMD_STOP_OUTPUT,
SIGNAL_CMD_CLOSE,
MAX_SIGNAL,
};
struct profile_data {
u64 start;
u64 stop;
u64 cumulative;
char name[64];
u32 sampling;
u64 average;
};
struct msm_vidc_debug {
struct profile_data pdata[MAX_PROFILING_POINTS];
u32 profile;
u32 samples;
};
struct msm_vidc_input_cr_data {
struct list_head list;
u32 index;
u32 input_cr;
};
struct msm_vidc_session_idle {
bool idle;
u64 last_activity_time_ns;
};
struct msm_vidc_color_info {
u32 colorspace;
u32 ycbcr_enc;
u32 xfer_func;
u32 quantization;
};
struct msm_vidc_rectangle {
u32 left;
u32 top;
u32 width;
u32 height;
};
struct msm_vidc_subscription_params {
u32 bitstream_resolution;
u32 crop_offsets[2];
u32 bit_depth;
u32 coded_frames;
u32 fw_min_count;
u32 pic_order_cnt;
u32 color_info;
u32 profile;
u32 level;
u32 tier;
u32 av1_film_grain_present;
u32 av1_super_block_enabled;
};
struct msm_vidc_hfi_frame_info {
u32 picture_type;
u32 no_output;
u32 subframe_input;
u32 cr;
u32 cf;
u32 data_corrupt;
u32 overflow;
u32 fence_id;
};
struct msm_vidc_decode_vpp_delay {
bool enable;
u32 size;
};
struct msm_vidc_decode_batch {
bool enable;
u32 size;
struct delayed_work work;
};
enum msm_vidc_power_mode {
VIDC_POWER_NORMAL = 0,
VIDC_POWER_LOW,
VIDC_POWER_TURBO,
};
struct vidc_bus_vote_data {
enum msm_vidc_domain_type domain;
enum msm_vidc_codec_type codec;
enum msm_vidc_power_mode power_mode;
u32 color_formats[2];
int num_formats; /* 1 = DPB-OPB unified; 2 = split */
int input_height, input_width, bitrate;
int output_height, output_width;
int rotation;
int compression_ratio;
int complexity_factor;
int input_cr;
u32 lcu_size;
u32 fps;
u32 work_mode;
bool use_sys_cache;
bool b_frames_enabled;
u64 calc_bw_ddr;
u64 calc_bw_llcc;
u32 num_vpp_pipes;
bool vpss_preprocessing_enabled;
};
struct msm_vidc_power {
enum msm_vidc_power_mode power_mode;
u32 buffer_counter;
u32 min_threshold;
u32 nom_threshold;
u32 max_threshold;
bool dcvs_mode;
u32 dcvs_window;
u64 min_freq;
u64 curr_freq;
u32 ddr_bw;
u32 sys_cache_bw;
u32 dcvs_flags;
u32 fw_cr;
u32 fw_cf;
};
struct msm_vidc_fence_context {
char name[MAX_NAME_LENGTH];
u64 ctx_num;
u64 seq_num;
};
struct msm_vidc_fence {
struct list_head list;
struct dma_fence dma_fence;
char name[MAX_NAME_LENGTH];
spinlock_t lock;
struct sync_file *sync_file;
int fd;
};
struct msm_vidc_alloc {
struct list_head list;
enum msm_vidc_buffer_type type;
enum msm_vidc_buffer_region region;
u32 size;
u8 secure:1;
u8 map_kernel:1;
struct dma_buf *dmabuf;
/*
* Kalama uses Kernel Version 5.15.x,
* Pineapple uses Kernel version 5.18.x
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5,16,0))
struct iosys_map dmabuf_map;
#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(5,15,0))
struct dma_buf_map dmabuf_map;
#endif
void *kvaddr;
};
struct msm_vidc_allocations {
struct list_head list; // list of "struct msm_vidc_alloc"
};
struct msm_vidc_map {
struct list_head list;
enum msm_vidc_buffer_type type;
enum msm_vidc_buffer_region region;
struct dma_buf *dmabuf;
u32 refcount;
u64 device_addr;
struct sg_table *table;
struct dma_buf_attachment *attach;
u32 skip_delayed_unmap:1;
};
struct msm_vidc_mappings {
struct list_head list; // list of "struct msm_vidc_map"
};
struct msm_vidc_buffer {
struct list_head list;
struct msm_vidc_inst *inst;
enum msm_vidc_buffer_type type;
u32 index;
int fd;
u32 buffer_size;
u32 data_offset;
u32 data_size;
u64 device_addr;
u32 flags;
u64 timestamp;
enum msm_vidc_buffer_attributes attr;
void *dmabuf;
struct sg_table *sg_table;
struct dma_buf_attachment *attach;
u32 dbuf_get:1;
u64 fence_id;
u32 start_time_ms;
u32 end_time_ms;
};
struct msm_vidc_buffers {
struct list_head list; // list of "struct msm_vidc_buffer"
u32 min_count;
u32 extra_count;
u32 actual_count;
u32 size;
bool reuse;
};
struct msm_vidc_buffer_stats {
struct list_head list;
u32 frame_num;
u64 timestamp;
u32 etb_time_ms;
u32 ebd_time_ms;
u32 ftb_time_ms;
u32 fbd_time_ms;
u32 data_size;
u32 flags;
};
enum msm_vidc_buffer_stats_flag {
MSM_VIDC_STATS_FLAG_CORRUPT = BIT(0),
MSM_VIDC_STATS_FLAG_OVERFLOW = BIT(1),
MSM_VIDC_STATS_FLAG_NO_OUTPUT = BIT(2),
};
struct msm_vidc_sort {
struct list_head list;
s64 val;
};
struct msm_vidc_timestamp {
struct msm_vidc_sort sort;
u64 rank;
};
struct msm_vidc_timestamps {
struct list_head list;
u32 count;
u64 rank;
};
struct msm_vidc_input_timer {
struct list_head list;
u64 time_us;
};
enum msm_vidc_allow {
MSM_VIDC_DISALLOW = 0,
MSM_VIDC_ALLOW,
MSM_VIDC_DEFER,
MSM_VIDC_DISCARD,
MSM_VIDC_IGNORE,
};
struct msm_vidc_ssr {
bool trigger;
enum msm_vidc_ssr_trigger_type ssr_type;
u32 sub_client_id;
u32 test_addr;
};
struct msm_vidc_stability {
enum msm_vidc_stability_trigger_type stability_type;
u32 sub_client_id;
u32 value;
};
struct msm_vidc_sfr {
u32 bufSize;
u8 rg_data[1];
};
#define call_mem_op(c, op, ...) \
(((c) && (c)->mem_ops && (c)->mem_ops->op) ? \
((c)->mem_ops->op(__VA_ARGS__)) : 0)
struct msm_vidc_memory_ops {
int (*allocate)(void *inst, struct msm_vidc_buffer *mbuf);
int (*dma_map)(void *inst, struct msm_vidc_buffer *mbuf);
int (*dma_unmap)(void *inst, struct msm_vidc_buffer *mbuf);
int (*free)(void *inst, struct msm_vidc_buffer *mbuf);
int (*cache_op)(void *inst, struct msm_vidc_buffer *mbuf,
enum msm_vidc_cache_op cache_op);
};
#endif // _MSM_VIDC_INTERNAL_H_
Reference in New Issue View Git Blame Copy Permalink