A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-24 21:54:34 -04:00
Code Issues Projects Releases Packages Wiki Activity

Merge 5a5d1b2859 on remote branch

Browse source 
Change-Id: I412d33d6d333016ec81aea39746a79fe6deeb702
This commit is contained in:
Linux Build Service Account 2020-08-19 19:25:20 -07:00
commit 5644ed06fc
15 changed files with 230 additions and 129 deletions
Download patch file Download diff file Expand all files Collapse all files

4
msm/vidc/hfi_iris2.c
View file

@ -243,10 +243,6 @@ skip_aon_mvp_noc:
/* HPG 6.1.2 Step 6 */
__disable_unprepare_clks(device);
/* HPG 6.1.2 Step 7 & 8 */
if (call_venus_op(device, reset_ahb2axi_bridge, device, sid))
d_vpr_e("%s: Failed to reset ahb2axi\n", __func__);
/* HPG 6.1.2 Step 5 */
if (__disable_regulators(device))
d_vpr_e("%s: Failed to disable regulators\n", __func__);

73
msm/vidc/hfi_response_handler.c
View file

@ -496,11 +496,21 @@ static int hfi_process_sys_rel_resource_done(u32 device_id,
return 0;
}
static void copy_hfi_to_hal_buf_req(struct hal_buffer_requirements *dst,
struct hfi_buffer_requirements *src) {
dst->buffer_size = src->buffer_size;
dst->buffer_count_min = (u16)src->buffer_count_min;
dst->buffer_count_min_host = (u16)src->buffer_count_min_host;
dst->buffer_count_actual = (u16)src->buffer_count_actual;
dst->buffer_alignment = (u16)src->buffer_alignment;
}
static void hfi_process_sess_get_prop_buf_req(
struct hfi_msg_session_property_info_packet *prop,
struct buffer_requirements *buffreq, u32 sid)
{
struct hfi_buffer_requirements *hfi_buf_req;
struct hal_buffer_requirements *hal_buf_req;
u32 req_bytes;
if (!prop) {
@ -529,79 +539,70 @@ static void hfi_process_sess_get_prop_buf_req(
hfi_buf_req->buffer_type);
switch (hfi_buf_req->buffer_type) {
case HFI_BUFFER_INPUT:
memcpy(&buffreq->buffer[0], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[0].buffer_type = HAL_BUFFER_INPUT;
hal_buf_req = &buffreq->buffer[0];
hal_buf_req->buffer_type = HAL_BUFFER_INPUT;
break;
case HFI_BUFFER_OUTPUT:
memcpy(&buffreq->buffer[1], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[1].buffer_type = HAL_BUFFER_OUTPUT;
hal_buf_req = &buffreq->buffer[1];
hal_buf_req->buffer_type = HAL_BUFFER_OUTPUT;
break;
case HFI_BUFFER_OUTPUT2:
memcpy(&buffreq->buffer[2], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[2].buffer_type = HAL_BUFFER_OUTPUT2;
hal_buf_req = &buffreq->buffer[2];
hal_buf_req->buffer_type = HAL_BUFFER_OUTPUT2;
break;
case HFI_BUFFER_EXTRADATA_INPUT:
memcpy(&buffreq->buffer[3], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[3].buffer_type =
hal_buf_req = &buffreq->buffer[3];
hal_buf_req->buffer_type =
HAL_BUFFER_EXTRADATA_INPUT;
break;
case HFI_BUFFER_EXTRADATA_OUTPUT:
memcpy(&buffreq->buffer[4], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[4].buffer_type =
hal_buf_req = &buffreq->buffer[4];
hal_buf_req->buffer_type =
HAL_BUFFER_EXTRADATA_OUTPUT;
break;
case HFI_BUFFER_EXTRADATA_OUTPUT2:
memcpy(&buffreq->buffer[5], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[5].buffer_type =
hal_buf_req = &buffreq->buffer[5];
hal_buf_req->buffer_type =
HAL_BUFFER_EXTRADATA_OUTPUT2;
break;
case HFI_BUFFER_COMMON_INTERNAL_SCRATCH:
memcpy(&buffreq->buffer[6], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[6].buffer_type =
hal_buf_req = &buffreq->buffer[6];
hal_buf_req->buffer_type =
HAL_BUFFER_INTERNAL_SCRATCH;
break;
case HFI_BUFFER_COMMON_INTERNAL_SCRATCH_1:
memcpy(&buffreq->buffer[7], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[7].buffer_type =
hal_buf_req = &buffreq->buffer[7];
hal_buf_req->buffer_type =
HAL_BUFFER_INTERNAL_SCRATCH_1;
break;
case HFI_BUFFER_COMMON_INTERNAL_SCRATCH_2:
memcpy(&buffreq->buffer[8], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[8].buffer_type =
hal_buf_req = &buffreq->buffer[8];
hal_buf_req->buffer_type =
HAL_BUFFER_INTERNAL_SCRATCH_2;
break;
case HFI_BUFFER_INTERNAL_PERSIST:
memcpy(&buffreq->buffer[9], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[9].buffer_type =
hal_buf_req = &buffreq->buffer[9];
hal_buf_req->buffer_type =
HAL_BUFFER_INTERNAL_PERSIST;
break;
case HFI_BUFFER_INTERNAL_PERSIST_1:
memcpy(&buffreq->buffer[10], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[10].buffer_type =
hal_buf_req = &buffreq->buffer[10];
hal_buf_req->buffer_type =
HAL_BUFFER_INTERNAL_PERSIST_1;
break;
case HFI_BUFFER_COMMON_INTERNAL_RECON:
memcpy(&buffreq->buffer[11], hfi_buf_req,
sizeof(struct hfi_buffer_requirements));
buffreq->buffer[11].buffer_type =
hal_buf_req = &buffreq->buffer[11];
hal_buf_req->buffer_type =
HAL_BUFFER_INTERNAL_RECON;
break;
default:
hal_buf_req = NULL;
s_vpr_e(sid, "%s: bad_buffer_type: %d\n",
__func__, hfi_buf_req->buffer_type);
break;
}
if (hal_buf_req)
copy_hfi_to_hal_buf_req(hal_buf_req, hfi_buf_req);
req_bytes -= sizeof(struct hfi_buffer_requirements);
hfi_buf_req++;
}

7
msm/vidc/msm_vdec.c
View file

@ -17,7 +17,7 @@
#define MIN_NUM_DEC_CAPTURE_BUFFERS 4
/* Y=16(0-9bits), Cb(10-19bits)=Cr(20-29bits)=128, black by default */
#define DEFAULT_VIDEO_CONCEAL_COLOR_BLACK 0x8020010
#define MAX_VP9D_INST_COUNT 6
#define MAX_VP9D_INST_COUNT 3
static const char *const mpeg_video_h264_profile[] = {
"Baseline",
@ -1195,10 +1195,9 @@ int msm_vdec_set_secure_mode(struct msm_vidc_inst *inst)
if (ctrl->val) {
if (!(codec == V4L2_PIX_FMT_HEVC ||
codec == V4L2_PIX_FMT_H264 ||
codec == V4L2_PIX_FMT_VP9 ||
codec == V4L2_PIX_FMT_MPEG2)) {
codec == V4L2_PIX_FMT_VP9)) {
s_vpr_e(inst->sid,
"%s: Secure allowed for HEVC/H264/VP9/MPEG2\n",
"%s: Secure allowed for HEVC/H264/VP9\n",
__func__);
return -EINVAL;
}

30
msm/vidc/msm_venc.c
View file

@ -32,8 +32,6 @@
#define DEFAULT_QP 0xA
#define DEFAULT_QP_PACKED 0xA0A0A
#define MIN_CHROMA_QP_OFFSET -12
#define MAX_CHROMA_QP_OFFSET 0
#define DEFAULT_CHROMA_QP_OFFSET 0
#define MAX_INTRA_REFRESH_MBS ((7680 * 4320) >> 8)
#define MAX_LTR_FRAME_COUNT 10
#define MAX_NUM_B_FRAMES 1
@ -927,8 +925,8 @@ static struct msm_vidc_ctrl msm_venc_ctrls[] = {
.name = "Chroma QP Index Offset",
.type = V4L2_CTRL_TYPE_INTEGER,
.minimum = MIN_CHROMA_QP_OFFSET,
.maximum = MAX_CHROMA_QP_OFFSET,
.default_value = DEFAULT_CHROMA_QP_OFFSET,
.maximum = INT_MAX,
.default_value = INT_MAX,
.step = 1,
},
{
@ -2120,6 +2118,7 @@ int msm_venc_store_timestamp(struct msm_vidc_inst *inst, u64 timestamp_us)
struct msm_vidc_timestamps *entry, *node, *prev = NULL;
int count = 0;
int rc = 0;
struct v4l2_ctrl *superframe_ctrl = NULL;
if (!inst || !inst->core) {
d_vpr_e("%s: invalid parameters\n", __func__);
@ -2172,7 +2171,13 @@ int msm_venc_store_timestamp(struct msm_vidc_inst *inst, u64 timestamp_us)
/* if framerate changed and stable for 2 frames, set to firmware */
if (entry->framerate == prev->framerate &&
entry->framerate != inst->clk_data.frame_rate) {
inst->clk_data.frame_rate = entry->framerate;
superframe_ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_SUPERFRAME);
if (superframe_ctrl->val > 1)
inst->clk_data.frame_rate = entry->framerate * superframe_ctrl->val;
else
inst->clk_data.frame_rate = entry->framerate;
s_vpr_l(inst->sid, "%s: updated fps to %u\n",
__func__, (inst->clk_data.frame_rate >> 16));
msm_venc_set_frame_rate(inst);
}
@ -2478,8 +2483,9 @@ int msm_venc_set_intra_period(struct msm_vidc_inst *inst)
V4L2_CID_MPEG_VIDC_VIDEO_HEVC_MAX_HIER_CODING_LAYER);
codec = get_v4l2_codec(inst);
intra_period.pframes = gop_size->val;
if (!max_layer->val && codec == V4L2_PIX_FMT_H264) {
intra_period.pframes = gop_size->val;
/*
* At this point we've already made decision on bframe.
* Control value gives updated bframe value.
@ -3373,7 +3379,7 @@ int msm_venc_set_chroma_qp_offset(struct msm_vidc_inst *inst)
hdev = inst->core->device;
chr = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET);
if (chr->val != MIN_CHROMA_QP_OFFSET)
if (chr->val == INT_MAX || (chr->val != 0 && chr->val != -12))
return 0;
f = &inst->fmts[INPUT_PORT].v4l2_fmt;
@ -3406,10 +3412,6 @@ int msm_venc_set_chroma_qp_offset(struct msm_vidc_inst *inst)
chroma_qp.chroma_offset = (chr->val + 12) << 16 | (chr->val + 12);
s_vpr_h(inst->sid, "%s: %x\n", __func__, chroma_qp.chroma_offset);
/* TODO: Remove this check after firmware support added for 8-bit */
if (inst->bit_depth == MSM_VIDC_BIT_DEPTH_8)
return 0;
rc = call_hfi_op(hdev, session_set_property, inst->session,
HFI_PROPERTY_PARAM_HEVC_PPS_CB_CR_OFFSET, &chroma_qp,
sizeof(chroma_qp));
@ -4603,6 +4605,12 @@ int msm_venc_set_cvp_skipratio(struct msm_vidc_inst *inst)
d_vpr_e("%s: invalid params %pK\n", __func__, inst);
return -EINVAL;
}
if (!is_cvp_supported(inst)) {
s_vpr_h(inst->sid, "%s cvp is not supported", __func__);
return rc;
}
if (!msm_vidc_cvp_usage)
return 0;

26
msm/vidc/msm_vidc.c
View file

@ -366,7 +366,7 @@ int msm_vidc_qbuf(void *instance, struct media_device *mdev,
int rc = 0;
unsigned int i = 0;
struct buf_queue *q = NULL;
u64 timestamp_us = 0;
s64 timestamp_us = 0;
u32 cr = 0;
if (!inst || !inst->core || !b || !valid_v4l2_buffer(b, inst)) {
@ -430,14 +430,17 @@ int msm_vidc_qbuf(void *instance, struct media_device *mdev,
&& b->type == INPUT_MPLANE)
b->flags |= V4L2_BUF_FLAG_PERF_MODE;
timestamp_us = (u64)((b->timestamp.tv_sec * 1000000ULL) +
timestamp_us = (s64)((b->timestamp.tv_sec * 1000000) +
b->timestamp.tv_usec);
if (is_decode_session(inst) && b->type == INPUT_MPLANE) {
if (inst->flush_timestamps)
msm_comm_release_timestamps(inst);
inst->flush_timestamps = false;
rc = msm_comm_store_timestamp(inst, timestamp_us);
if (!(b->flags & V4L2_BUF_FLAG_CODECCONFIG))
rc = msm_comm_store_timestamp(inst, timestamp_us,
b->flags & V4L2_BUF_FLAG_EOS);
if (rc)
goto unlock;
inst->clk_data.frame_rate = msm_comm_get_max_framerate(inst);
@ -508,7 +511,9 @@ int msm_vidc_dqbuf(void *instance, struct v4l2_buffer *b)
return -EINVAL;
}
}
if (is_decode_session(inst) && b->type == OUTPUT_MPLANE)
if (is_decode_session(inst) &&
b->type == OUTPUT_MPLANE &&
!(b->flags & V4L2_BUF_FLAG_CODECCONFIG))
msm_comm_fetch_ts_framerate(inst, b);
return rc;
@ -794,6 +799,11 @@ static bool msm_vidc_set_cvp_metadata(struct msm_vidc_inst *inst) {
return false;
}
if (!is_cvp_supported(inst)) {
s_vpr_h(inst->sid, "%s cvp is not supported", __func__);
return true;
}
if (inst->prop.extradata_ctrls & EXTRADATA_ENC_INPUT_CVP)
value = 0x1;
@ -1403,13 +1413,13 @@ static int try_get_ctrl_for_instance(struct msm_vidc_inst *inst,
break;
case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
ctrl->val = inst->fmts[OUTPUT_PORT].count_min_host;
s_vpr_h(inst->sid, "g_min: hal_buffer %d min buffers %d\n",
HAL_BUFFER_OUTPUT, ctrl->val);
s_vpr_h(inst->sid, "g_min: OUTPUT_PORT count_min_host %d\n",
ctrl->val);
break;
case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
ctrl->val = inst->fmts[INPUT_PORT].count_min_host;
s_vpr_h(inst->sid, "g_min: hal_buffer %d min buffers %d\n",
HAL_BUFFER_INPUT, ctrl->val);
s_vpr_h(inst->sid, "g_min: INPUT_PORT count_min_host %d\n",
ctrl->val);
break;
case V4L2_CID_MPEG_VIDC_VIDEO_EXTRADATA:
ctrl->val = inst->prop.extradata_ctrls;

9
msm/vidc/msm_vidc_buffer_calculations.c
View file

@ -790,11 +790,10 @@ static int msm_vidc_get_extra_input_buff_count(struct msm_vidc_inst *inst)
core = inst->core;
/*
* For a non-realtime session, extra buffers are not required.
* For thumbnail session, extra buffers are not required as
* neither dcvs nor batching will be enabled.
*/
if (!is_realtime_session(inst) || is_thumbnail_session(inst))
if (is_thumbnail_session(inst))
return extra_input_count;
if (is_decode_session(inst)) {
@ -1350,13 +1349,15 @@ static inline u32 calculate_vpxd_scratch_size(struct msm_vidc_inst *inst,
((BIN_BUFFER_THRESHOLD * 3) >> 1)) *
VPX_DECODER_FRAME_CONCURENCY_LVL *
VPX_DECODER_FRAME_BIN_HDR_BUDGET_RATIO_NUM /
VPX_DECODER_FRAME_BIN_HDR_BUDGET_RATIO_DEN,
VPX_DECODER_FRAME_BIN_HDR_BUDGET_RATIO_DEN /
num_vpp_pipes,
VENUS_DMA_ALIGNMENT);
binbuffer2_size = ALIGN(max_t(u32, size_yuv,
((BIN_BUFFER_THRESHOLD * 3) >> 1)) *
VPX_DECODER_FRAME_CONCURENCY_LVL *
VPX_DECODER_FRAME_BIN_RES_BUDGET_RATIO_NUM /
VPX_DECODER_FRAME_BIN_RES_BUDGET_RATIO_DEN,
VPX_DECODER_FRAME_BIN_RES_BUDGET_RATIO_DEN /
num_vpp_pipes,
VENUS_DMA_ALIGNMENT);
size = binbuffer1_size + binbuffer2_size;
size = size * num_vpp_pipes;

4
msm/vidc/msm_vidc_buffer_calculations.h
View file

@ -6,9 +6,9 @@
#ifndef __H_MSM_VIDC_BUFFER_MEM_DEFS_H__
#define __H_MSM_VIDC_BUFFER_MEM_DEFS_H__
/* extra o/p buffers in case of dcvs */
/* extra buffers in case of dcvs */
#define DCVS_DEC_EXTRA_OUTPUT_BUFFERS 4
#define DCVS_ENC_EXTRA_INPUT_BUFFERS DCVS_DEC_EXTRA_OUTPUT_BUFFERS
#define DCVS_ENC_EXTRA_INPUT_BUFFERS 4
struct msm_vidc_dec_buff_size_calculators {
u32 (*calculate_scratch_size)(struct msm_vidc_inst *inst, u32 width,

85
msm/vidc/msm_vidc_clocks.c
View file

@ -120,8 +120,8 @@ bool res_is_less_than_or_equal_to(u32 width, u32 height,
u32 num_mbs = NUM_MBS_PER_FRAME(height, width);
u32 max_side = max(ref_width, ref_height);
if (num_mbs <= NUM_MBS_PER_FRAME(ref_height, ref_width) ||
width <= max_side ||
if (num_mbs <= NUM_MBS_PER_FRAME(ref_height, ref_width) &&
width <= max_side &&
height <= max_side)
return true;
else
@ -999,7 +999,8 @@ int msm_dcvs_try_enable(struct msm_vidc_inst *inst)
inst->clk_data.low_latency_mode ||
inst->batch.enable ||
is_turbo_session(inst) ||
inst->rc_type == V4L2_MPEG_VIDEO_BITRATE_MODE_CQ);
inst->rc_type == V4L2_MPEG_VIDEO_BITRATE_MODE_CQ ||
is_encode_batching(inst));
s_vpr_hp(inst->sid, "DCVS %s: %pK\n",
inst->clk_data.dcvs_mode ? "enabled" : "disabled", inst);
@ -1007,6 +1008,53 @@ int msm_dcvs_try_enable(struct msm_vidc_inst *inst)
return 0;
}
void msm_dcvs_reset(struct msm_vidc_inst *inst)
{
struct msm_vidc_format *fmt;
struct clock_data *dcvs;
if (!inst) {
d_vpr_e("%s: Invalid params\n", __func__);
return;
}
dcvs = &inst->clk_data;
if (inst->session_type == MSM_VIDC_ENCODER) {
fmt = &inst->fmts[INPUT_PORT];
} else if (inst->session_type == MSM_VIDC_DECODER) {
fmt = &inst->fmts[OUTPUT_PORT];
} else {
s_vpr_e(inst->sid, "%s: invalid session type %#x\n",
__func__, inst->session_type);
return;
}
dcvs->min_threshold = fmt->count_min;
if (inst->session_type == MSM_VIDC_ENCODER)
dcvs->max_threshold =
min((fmt->count_min + DCVS_ENC_EXTRA_INPUT_BUFFERS),
fmt->count_actual);
else
dcvs->max_threshold =
min((fmt->count_min + DCVS_DEC_EXTRA_OUTPUT_BUFFERS),
fmt->count_actual);
dcvs->dcvs_window =
dcvs->max_threshold < dcvs->min_threshold ? 0 :
dcvs->max_threshold - dcvs->min_threshold;
dcvs->nom_threshold = dcvs->min_threshold +
(dcvs->dcvs_window ?
(dcvs->dcvs_window / 2) : 0);
dcvs->dcvs_flags = 0;
s_vpr_p(inst->sid, "DCVS: Th[%d %d %d] Flag %#x\n",
dcvs->min_threshold,
dcvs->nom_threshold, dcvs->max_threshold,
dcvs->dcvs_flags);
}
int msm_comm_init_clocks_and_bus_data(struct msm_vidc_inst *inst)
{
int rc = 0, j = 0;
@ -1047,8 +1095,6 @@ void msm_clock_data_reset(struct msm_vidc_inst *inst)
struct allowed_clock_rates_table *allowed_clks_tbl = NULL;
u64 total_freq = 0, rate = 0, load;
int cycles;
struct clock_data *dcvs;
struct msm_vidc_format *fmt;
if (!inst || !inst->core || !inst->clk_data.entry) {
d_vpr_e("%s: Invalid args: Inst = %pK\n",
@ -1058,35 +1104,14 @@ void msm_clock_data_reset(struct msm_vidc_inst *inst)
s_vpr_h(inst->sid, "Init DCVS Load\n");
core = inst->core;
dcvs = &inst->clk_data;
load = msm_comm_get_inst_load_per_core(inst, LOAD_POWER);
cycles = inst->clk_data.entry->vpp_cycles;
allowed_clks_tbl = core->resources.allowed_clks_tbl;
if (inst->session_type == MSM_VIDC_ENCODER) {
cycles = inst->flags & VIDC_LOW_POWER ?
inst->clk_data.entry->low_power_cycles :
cycles;
if (inst->session_type == MSM_VIDC_ENCODER &&
inst->flags & VIDC_LOW_POWER)
cycles = inst->clk_data.entry->low_power_cycles;
fmt = &inst->fmts[INPUT_PORT];
} else if (inst->session_type == MSM_VIDC_DECODER) {
fmt = &inst->fmts[OUTPUT_PORT];
} else {
s_vpr_e(inst->sid, "%s: invalid session type %#x\n",
__func__, inst->session_type);
return;
}
dcvs->min_threshold = fmt->count_min;
dcvs->max_threshold =
min((fmt->count_min + DCVS_DEC_EXTRA_OUTPUT_BUFFERS),
fmt->count_actual);
dcvs->dcvs_window =
dcvs->max_threshold < dcvs->min_threshold ? 0 :
dcvs->max_threshold - dcvs->min_threshold;
dcvs->nom_threshold = dcvs->min_threshold +
(dcvs->dcvs_window ?
(dcvs->dcvs_window / 2) : 0);
msm_dcvs_reset(inst);
total_freq = cycles * load;

1
msm/vidc/msm_vidc_clocks.h
View file

@ -8,6 +8,7 @@
#include "msm_vidc_internal.h"
void msm_clock_data_reset(struct msm_vidc_inst *inst);
void msm_dcvs_reset(struct msm_vidc_inst *inst);
int msm_vidc_set_clocks(struct msm_vidc_core *core, u32 sid);
int msm_comm_vote_bus(struct msm_vidc_inst *inst);
int msm_dcvs_try_enable(struct msm_vidc_inst *inst);

61
msm/vidc/msm_vidc_common.c
View file

@ -1598,7 +1598,6 @@ static void handle_event_change(enum hal_command_response cmd, void *data)
struct hfi_device *hdev;
u32 *ptr = NULL;
struct msm_vidc_format *fmt;
struct v4l2_format *f;
u32 codec;
if (!event_notify) {
@ -1650,11 +1649,12 @@ static void handle_event_change(enum hal_command_response cmd, void *data)
inst->pic_struct == MSM_VIDC_PIC_STRUCT_MAYBE_INTERLACED))
event_fields_changed = true;
f = &inst->fmts[OUTPUT_PORT].v4l2_fmt;
fmt = &inst->fmts[OUTPUT_PORT];
event_fields_changed |=
(f->fmt.pix_mp.height != event_notify->height);
(fmt->v4l2_fmt.fmt.pix_mp.height !=
event_notify->height);
event_fields_changed |=
(f->fmt.pix_mp.width != event_notify->width);
(fmt->v4l2_fmt.fmt.pix_mp.width != event_notify->width);
if (event_fields_changed) {
event = V4L2_EVENT_SEQ_CHANGED_INSUFFICIENT;
@ -1670,6 +1670,10 @@ static void handle_event_change(enum hal_command_response cmd, void *data)
"%s: Failed to decide work mode\n",
__func__);
}
fmt->count_min = event_notify->fw_min_cnt;
msm_dcvs_reset(inst);
s_vpr_h(inst->sid,
"seq: No parameter change continue session\n");
rc = call_hfi_op(hdev, session_continue,
@ -2809,6 +2813,7 @@ bool is_batching_allowed(struct msm_vidc_inst *inst)
{
u32 op_pixelformat, fps, maxmbs, maxfps;
u32 ignore_flags = VIDC_THUMBNAIL;
u32 enable = 0;
if (!inst || !inst->core)
return false;
@ -2827,17 +2832,23 @@ bool is_batching_allowed(struct msm_vidc_inst *inst)
* as sufficient extra buffers (required for batch mode
* on both ports) may not have been updated to client.
*/
return (inst->batch.enable &&
enable = (inst->batch.enable &&
inst->core->resources.decode_batching &&
!is_low_latency_hint(inst) &&
is_single_session(inst, ignore_flags) &&
is_decode_session(inst) &&
!is_thumbnail_session(inst) &&
is_realtime_session(inst) &&
!inst->clk_data.low_latency_mode &&
(op_pixelformat == V4L2_PIX_FMT_NV12_UBWC ||
op_pixelformat == V4L2_PIX_FMT_NV12_TP10_UBWC) &&
fps <= maxfps &&
msm_vidc_get_mbs_per_frame(inst) <= maxmbs);
s_vpr_hp(inst->sid, "%s: batching %s\n",
__func__, enable ? "enabled" : "disabled");
return enable;
}
static int msm_comm_session_abort(struct msm_vidc_inst *inst)
@ -4941,7 +4952,10 @@ int msm_comm_try_get_bufreqs(struct msm_vidc_inst *inst)
for (i = 0; i < HAL_BUFFER_MAX; i++) {
struct hal_buffer_requirements req = inst->buff_req.buffer[i];
if (req.buffer_type != HAL_BUFFER_NONE) {
if (req.buffer_type != HAL_BUFFER_NONE &&
req.buffer_type != HAL_BUFFER_INPUT &&
req.buffer_type != HAL_BUFFER_OUTPUT &&
req.buffer_type != HAL_BUFFER_OUTPUT2) {
s_vpr_h(inst->sid, "%15s %8d %8d %8d %8d %8d\n",
get_buffer_name(req.buffer_type),
req.buffer_count_actual,
@ -5319,7 +5333,7 @@ int msm_comm_release_persist_buffers(struct msm_vidc_inst *inst)
}
int msm_comm_set_buffer_count(struct msm_vidc_inst *inst,
int host_count, int act_count, enum hal_buffer type)
int min_count, int act_count, enum hal_buffer type)
{
int rc = 0;
struct v4l2_ctrl *ctrl;
@ -5334,20 +5348,22 @@ int msm_comm_set_buffer_count(struct msm_vidc_inst *inst,
buf_count.buffer_type = get_hfi_buffer(type, inst->sid);
buf_count.buffer_count_actual = act_count;
buf_count.buffer_count_min_host = host_count;
buf_count.buffer_count_min_host = min_count;
/* set total superframe buffers count */
ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_SUPERFRAME);
if (ctrl->val)
buf_count.buffer_count_actual = act_count * ctrl->val;
s_vpr_h(inst->sid, "%s: hal_buffer %d min_host %d actual %d\n",
__func__, type, host_count, act_count);
s_vpr_h(inst->sid,
"%s: hal_buffer %d min %d actual %d superframe %d\n",
__func__, type, min_count,
buf_count.buffer_count_actual, ctrl->val);
rc = call_hfi_op(hdev, session_set_property,
inst->session, HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL,
&buf_count, sizeof(buf_count));
if (rc)
s_vpr_e(inst->sid,
"Failed to set actual buffer count %d for buffer type %d\n",
act_count, type);
buf_count.buffer_count_actual, type);
return rc;
}
@ -7584,7 +7600,8 @@ void msm_comm_release_timestamps(struct msm_vidc_inst *inst)
mutex_unlock(&inst->timestamps.lock);
}
int msm_comm_store_timestamp(struct msm_vidc_inst *inst, u64 timestamp_us)
int msm_comm_store_timestamp(struct msm_vidc_inst *inst, s64 timestamp_us,
bool is_eos)
{
struct msm_vidc_timestamps *entry, *node, *prev = NULL;
struct msm_vidc_timestamps *duplicate;
@ -7602,7 +7619,8 @@ int msm_comm_store_timestamp(struct msm_vidc_inst *inst, u64 timestamp_us)
duplicate = NULL;
list_for_each_entry(node, &inst->timestamps.list, list) {
count++;
if (node->timestamp_us == timestamp_us)
if (node->is_valid && node->timestamp_us == timestamp_us &&
!node->is_eos)
duplicate = node;
}
@ -7633,6 +7651,7 @@ int msm_comm_store_timestamp(struct msm_vidc_inst *inst, u64 timestamp_us)
entry->timestamp_us = duplicate->timestamp_us;
entry->framerate = duplicate->framerate;
entry->is_valid = true;
entry->is_eos = is_eos;
/* add entry next to duplicate */
list_add(&entry->list, &duplicate->list);
goto unlock;
@ -7645,7 +7664,8 @@ int msm_comm_store_timestamp(struct msm_vidc_inst *inst, u64 timestamp_us)
prev = NULL;
inserted = false;
list_for_each_entry(node, &inst->timestamps.list, list) {
if (entry->timestamp_us < node->timestamp_us) {
if (entry->timestamp_us < node->timestamp_us &&
!node->is_eos) {
/*
* if prev available add entry next to prev else
* entry is first so add it at head.
@ -7672,7 +7692,8 @@ int msm_comm_store_timestamp(struct msm_vidc_inst *inst, u64 timestamp_us)
node->timestamp_us, prev->timestamp_us);
break;
}
if (node->timestamp_us == entry->timestamp_us) {
if (node->timestamp_us == entry->timestamp_us &&
!node->is_eos) {
if (prev)
node->framerate = msm_comm_calc_framerate(inst,
node->timestamp_us, prev->timestamp_us);
@ -7681,6 +7702,12 @@ int msm_comm_store_timestamp(struct msm_vidc_inst *inst, u64 timestamp_us)
prev = node;
}
/* mark all entries as eos if is_eos is queued */
if (is_eos)
list_for_each_entry(node, &inst->timestamps.list, list) {
node->is_eos = true;
}
unlock:
mutex_unlock(&inst->timestamps.lock);
return rc;
@ -7767,8 +7794,8 @@ int msm_comm_fetch_ts_framerate(struct msm_vidc_inst *inst,
if (!(b->flags & V4L2_BUF_FLAG_END_OF_SUBFRAME))
node->is_valid = false;
b->timestamp.tv_sec = node->timestamp_us / 1000000ull;
b->timestamp.tv_usec = node->timestamp_us % 1000000ull;
b->timestamp.tv_sec = node->timestamp_us / 1000000;
b->timestamp.tv_usec = node->timestamp_us % 1000000;
b->m.planes[0].reserved[MSM_VIDC_FRAMERATE] = node->framerate;
break;
}

19
msm/vidc/msm_vidc_common.h
View file

@ -59,6 +59,11 @@ static inline bool is_low_power_session(struct msm_vidc_inst *inst)
return !!(inst->flags & VIDC_LOW_POWER);
}
static inline bool is_cvp_supported(struct msm_vidc_inst *inst)
{
return inst->core && !inst->core->resources.no_cvp;
}
static inline struct v4l2_ctrl *get_ctrl(struct msm_vidc_inst *inst,
u32 id)
{
@ -153,6 +158,17 @@ static inline bool is_encode_session(struct msm_vidc_inst *inst)
return inst->session_type == MSM_VIDC_ENCODER;
}
static inline bool is_encode_batching(struct msm_vidc_inst *inst)
{
struct v4l2_ctrl *ctrl;
if (inst->session_type != MSM_VIDC_ENCODER)
return false;
ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_SUPERFRAME);
return !!ctrl->val;
}
static inline bool is_primary_output_mode(struct msm_vidc_inst *inst)
{
return inst->stream_output_mode == HAL_VIDEO_DECODER_PRIMARY;
@ -384,7 +400,8 @@ int msm_comm_set_cvp_skip_ratio(struct msm_vidc_inst *inst,
uint32_t capture_rate, uint32_t cvp_rate);
int msm_comm_fetch_ts_framerate(struct msm_vidc_inst *inst,
struct v4l2_buffer *b);
int msm_comm_store_timestamp(struct msm_vidc_inst *inst, u64 timestamp_us);
int msm_comm_store_timestamp(struct msm_vidc_inst *inst, s64 timestamp_us,
bool is_eos);
void msm_comm_release_timestamps(struct msm_vidc_inst *inst);
u32 msm_comm_get_max_framerate(struct msm_vidc_inst *inst);
u32 msm_comm_calc_framerate(struct msm_vidc_inst *inst, u64 timestamp_us,

3
msm/vidc/msm_vidc_internal.h
View file

@ -236,9 +236,10 @@ struct msm_vidc_codec {
struct msm_vidc_timestamps {
struct list_head list;
u64 timestamp_us;
s64 timestamp_us;
u32 framerate;
bool is_valid;
bool is_eos;
};
enum efuse_purpose {

34
msm/vidc/msm_vidc_platform.c
View file

@ -72,12 +72,12 @@ static struct msm_vidc_codec_data bengal_codec_data[] = {
};
static struct msm_vidc_codec_data shima_codec_data[] = {
CODEC_ENTRY(V4L2_PIX_FMT_H264, MSM_VIDC_ENCODER, 0, 675, 320),
CODEC_ENTRY(V4L2_PIX_FMT_HEVC, MSM_VIDC_ENCODER, 0, 675, 320),
CODEC_ENTRY(V4L2_PIX_FMT_MPEG2, MSM_VIDC_DECODER, 0, 200, 200),
CODEC_ENTRY(V4L2_PIX_FMT_H264, MSM_VIDC_DECODER, 0, 200, 200),
CODEC_ENTRY(V4L2_PIX_FMT_HEVC, MSM_VIDC_DECODER, 0, 200, 200),
CODEC_ENTRY(V4L2_PIX_FMT_VP9, MSM_VIDC_DECODER, 0, 200, 200),
CODEC_ENTRY(V4L2_PIX_FMT_H264, MSM_VIDC_ENCODER, 25, 675, 320),
CODEC_ENTRY(V4L2_PIX_FMT_HEVC, MSM_VIDC_ENCODER, 25, 675, 320),
CODEC_ENTRY(V4L2_PIX_FMT_MPEG2, MSM_VIDC_DECODER, 25, 200, 200),
CODEC_ENTRY(V4L2_PIX_FMT_H264, MSM_VIDC_DECODER, 25, 200, 200),
CODEC_ENTRY(V4L2_PIX_FMT_HEVC, MSM_VIDC_DECODER, 25, 200, 200),
CODEC_ENTRY(V4L2_PIX_FMT_VP9, MSM_VIDC_DECODER, 60, 200, 200),
};
static struct msm_vidc_codec_data holi_codec_data[] = {
@ -358,6 +358,16 @@ static struct msm_vidc_codec_capability lahaina_capabilities[] = {
{CAP_FRAMERATE, DEC, MPEG2, 1, 30, 1, 30},
{CAP_BITRATE, DEC, MPEG2, 1, 40000000, 1, 20000000},
/* VP9 decoder-specific */
{CAP_FRAME_WIDTH, DEC, VP9, 96, 4096, 1, 1920},
{CAP_FRAME_HEIGHT, DEC, VP9, 96, 4096, 1, 1080},
/* (4096 * 2304) / 256 */
{CAP_MBS_PER_FRAME, DEC, VP9, 36, 36864, 1, 36864},
/* ((4096 * 2304) / 256) * 60*/
{CAP_MBS_PER_SECOND, DEC, VP9, 36, 2211840, 1, 2211840},
{CAP_FRAMERATE, DEC, VP9, 1, 60, 1, 60},
{CAP_BITRATE, DEC, VP9, 1, 100000000, 1, 20000000},
/* Secure usecase specific */
{CAP_SECURE_FRAME_WIDTH, DEC, CODECS_ALL, 96, 4096, 1, 1920},
{CAP_SECURE_FRAME_HEIGHT, DEC, CODECS_ALL, 96, 4096, 1, 1080},
@ -1398,6 +1408,10 @@ static struct msm_vidc_common_data holi_common_data[] = {
.key = "qcom,fw-vpp-cycles",
.value = 225975,
},
{
.key = "qcom,no-cvp",
.value = 1,
},
};
static struct msm_vidc_efuse_data shima_efuse_data[] = {
@ -1621,11 +1635,9 @@ void *vidc_get_drv_data(struct device *dev)
goto exit;
/* Check for sku version */
if (of_find_property(dev->of_node, "sku-index", NULL)) {
rc = msm_vidc_read_efuse(driver_data, dev);
if (rc)
goto exit;
}
rc = msm_vidc_read_efuse(driver_data, dev);
if (rc)
goto exit;
if (!strcmp(match->compatible, "qcom,lahaina-vidc")) {
ddr_type = of_fdt_get_ddrtype();

2
msm/vidc/msm_vidc_res_parse.c
View file

@ -813,6 +813,8 @@ int read_platform_resources_from_drv_data(
"qcom,vpp_delay_supported");
res->enc_auto_dynamic_fps = find_key_value(platform_data,
"qcom,enc_auto_dynamic_fps");
res->no_cvp = find_key_value(platform_data,
"qcom,no-cvp");
res->csc_coeff_data = &platform_data->csc_data;

1
msm/vidc/msm_vidc_resources.h
View file

@ -206,6 +206,7 @@ struct msm_vidc_platform_resources {
uint32_t ubwc_stats_in_fbd;
uint32_t has_vpp_delay;
bool enc_auto_dynamic_fps;
bool no_cvp;
};
static inline bool is_iommu_present(struct msm_vidc_platform_resources *res)