github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-31 02:24:24 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

media: iris: Add support for buffer management ioctls for encoder device

Browse Source 
Implement support for queuing and dequeuing input and output buffers
for the encoder video device using the appropriate V4L2 buffer
management ioctls.

This enables userspace applications to manage streaming buffers
required for encoding operations.

Tested-by: Vikash Garodia <quic_vgarodia@quicinc.com> # X1E80100
Reviewed-by: Vikash Garodia <quic_vgarodia@quicinc.com>
Tested-by: Neil Armstrong <neil.armstrong@linaro.org> # on SM8550-HDK
Tested-by: Neil Armstrong <neil.armstrong@linaro.org> # on SM8650-HDK
Signed-off-by: Dikshita Agarwal <quic_dikshita@quicinc.com>
Tested-by: Bryan O'Donoghue <bryan.odonoghue@linaro.org> # x1e80100-crd
[bod: drop dead code size_enc_single_pipe()]
Signed-off-by: Bryan O'Donoghue <bod@kernel.org>
Signed-off-by: Hans Verkuil <hverkuil+cisco@kernel.org>
This commit is contained in:
Dikshita Agarwal 2025-08-25 12:30:49 +05:30 committed by Hans Verkuil
parent 61528e8668
commit 8cefa0ac93
13 changed files with 215 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
drivers/media/platform/qcom/iris/iris_common.c
View File

@ -10,6 +10,42 @@
#include "iris_instance.h"
#include "iris_power.h"
int iris_vb2_buffer_to_driver(struct vb2_buffer *vb2, struct iris_buffer *buf)
{
struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb2);
buf->type = iris_v4l2_type_to_driver(vb2->type);
buf->index = vb2->index;
buf->fd = vb2->planes[0].m.fd;
buf->buffer_size = vb2->planes[0].length;
buf->data_offset = vb2->planes[0].data_offset;
buf->data_size = vb2->planes[0].bytesused - vb2->planes[0].data_offset;
buf->flags = vbuf->flags;
buf->timestamp = vb2->timestamp;
buf->attr = 0;
return 0;
}
void iris_set_ts_metadata(struct iris_inst *inst, struct vb2_v4l2_buffer *vbuf)
{
u32 mask = V4L2_BUF_FLAG_TIMECODE | V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
struct vb2_buffer *vb = &vbuf->vb2_buf;
u64 ts_us = vb->timestamp;
if (inst->metadata_idx >= ARRAY_SIZE(inst->tss))
inst->metadata_idx = 0;
do_div(ts_us, NSEC_PER_USEC);
inst->tss[inst->metadata_idx].flags = vbuf->flags & mask;
inst->tss[inst->metadata_idx].tc = vbuf->timecode;
inst->tss[inst->metadata_idx].ts_us = ts_us;
inst->tss[inst->metadata_idx].ts_ns = vb->timestamp;
inst->metadata_idx++;
}
int iris_process_streamon_input(struct iris_inst *inst)
{
const struct iris_hfi_command_ops *hfi_ops = inst->core->hfi_ops;

2
drivers/media/platform/qcom/iris/iris_common.h
View File

@ -9,6 +9,8 @@
struct iris_inst;
struct iris_buffer;
int iris_vb2_buffer_to_driver(struct vb2_buffer *vb2, struct iris_buffer *buf);
void iris_set_ts_metadata(struct iris_inst *inst, struct vb2_v4l2_buffer *vbuf);
int iris_process_streamon_input(struct iris_inst *inst);
int iris_process_streamon_output(struct iris_inst *inst);
int iris_session_streamoff(struct iris_inst *inst, u32 plane);

53
drivers/media/platform/qcom/iris/iris_hfi_gen1_command.c
View File

@ -273,23 +273,44 @@ static int iris_hfi_gen1_session_continue(struct iris_inst *inst, u32 plane)
static int iris_hfi_gen1_queue_input_buffer(struct iris_inst *inst, struct iris_buffer *buf)
{
struct hfi_session_empty_buffer_compressed_pkt ip_pkt;
struct hfi_session_empty_buffer_compressed_pkt com_ip_pkt;
struct hfi_session_empty_buffer_uncompressed_pkt uncom_ip_pkt;
ip_pkt.shdr.hdr.size = sizeof(struct hfi_session_empty_buffer_compressed_pkt);
ip_pkt.shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
ip_pkt.shdr.session_id = inst->session_id;
ip_pkt.time_stamp_hi = upper_32_bits(buf->timestamp);
ip_pkt.time_stamp_lo = lower_32_bits(buf->timestamp);
ip_pkt.flags = buf->flags;
ip_pkt.mark_target = 0;
ip_pkt.mark_data = 0;
ip_pkt.offset = buf->data_offset;
ip_pkt.alloc_len = buf->buffer_size;
ip_pkt.filled_len = buf->data_size;
ip_pkt.input_tag = buf->index;
ip_pkt.packet_buffer = buf->device_addr;
return iris_hfi_queue_cmd_write(inst->core, &ip_pkt, ip_pkt.shdr.hdr.size);
if (inst->domain == DECODER) {
com_ip_pkt.shdr.hdr.size = sizeof(struct hfi_session_empty_buffer_compressed_pkt);
com_ip_pkt.shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
com_ip_pkt.shdr.session_id = inst->session_id;
com_ip_pkt.time_stamp_hi = upper_32_bits(buf->timestamp);
com_ip_pkt.time_stamp_lo = lower_32_bits(buf->timestamp);
com_ip_pkt.flags = buf->flags;
com_ip_pkt.mark_target = 0;
com_ip_pkt.mark_data = 0;
com_ip_pkt.offset = buf->data_offset;
com_ip_pkt.alloc_len = buf->buffer_size;
com_ip_pkt.filled_len = buf->data_size;
com_ip_pkt.input_tag = buf->index;
com_ip_pkt.packet_buffer = buf->device_addr;
return iris_hfi_queue_cmd_write(inst->core, &com_ip_pkt,
com_ip_pkt.shdr.hdr.size);
} else {
uncom_ip_pkt.shdr.hdr.size =
sizeof(struct hfi_session_empty_buffer_uncompressed_pkt);
uncom_ip_pkt.shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
uncom_ip_pkt.shdr.session_id = inst->session_id;
uncom_ip_pkt.time_stamp_hi = upper_32_bits(buf->timestamp);
uncom_ip_pkt.time_stamp_lo = lower_32_bits(buf->timestamp);
uncom_ip_pkt.view_id = 0;
uncom_ip_pkt.flags = buf->flags;
uncom_ip_pkt.mark_target = 0;
uncom_ip_pkt.mark_data = 0;
uncom_ip_pkt.offset = buf->data_offset;
uncom_ip_pkt.alloc_len = buf->buffer_size;
uncom_ip_pkt.filled_len = buf->data_size;
uncom_ip_pkt.input_tag = buf->index;
uncom_ip_pkt.packet_buffer = buf->device_addr;
return iris_hfi_queue_cmd_write(inst->core, &uncom_ip_pkt,
uncom_ip_pkt.shdr.hdr.size);
}
}
static int iris_hfi_gen1_queue_output_buffer(struct iris_inst *inst, struct iris_buffer *buf)

37
drivers/media/platform/qcom/iris/iris_hfi_gen1_defines.h
View File

@ -216,6 +216,23 @@ struct hfi_session_empty_buffer_compressed_pkt {
u32 data;
};
struct hfi_session_empty_buffer_uncompressed_pkt {
struct hfi_session_hdr_pkt shdr;
u32 view_id;
u32 time_stamp_hi;
u32 time_stamp_lo;
u32 flags;
u32 mark_target;
u32 mark_data;
u32 alloc_len;
u32 filled_len;
u32 offset;
u32 input_tag;
u32 packet_buffer;
u32 extradata_buffer;
u32 data;
};
struct hfi_session_fill_buffer_pkt {
struct hfi_session_hdr_pkt shdr;
u32 stream_id;
@ -461,6 +478,26 @@ struct hfi_msg_session_empty_buffer_done_pkt {
u32 data[];
};
struct hfi_msg_session_fbd_compressed_pkt {
struct hfi_session_hdr_pkt shdr;
u32 time_stamp_hi;
u32 time_stamp_lo;
u32 error_type;
u32 flags;
u32 mark_target;
u32 mark_data;
u32 stats;
u32 offset;
u32 alloc_len;
u32 filled_len;
u32 input_tag;
u32 output_tag;
u32 picture_type;
u32 packet_buffer;
u32 extradata_buffer;
u32 data[];
};
struct hfi_msg_session_fbd_uncompressed_plane0_pkt {
struct hfi_session_hdr_pkt shdr;
u32 stream_id;

43
drivers/media/platform/qcom/iris/iris_hfi_gen1_response.c
View File

@ -387,24 +387,43 @@ static void iris_hfi_gen1_session_etb_done(struct iris_inst *inst, void *packet)
static void iris_hfi_gen1_session_ftb_done(struct iris_inst *inst, void *packet)
{
struct hfi_msg_session_fbd_uncompressed_plane0_pkt *pkt = packet;
struct hfi_msg_session_fbd_uncompressed_plane0_pkt *uncom_pkt = packet;
struct hfi_msg_session_fbd_compressed_pkt *com_pkt = packet;
struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
struct v4l2_m2m_buffer *m2m_buffer, *n;
struct hfi_session_flush_pkt flush_pkt;
u32 timestamp_hi = pkt->time_stamp_hi;
u32 timestamp_lo = pkt->time_stamp_lo;
u32 timestamp_hi;
u32 timestamp_lo;
struct iris_core *core = inst->core;
u32 filled_len = pkt->filled_len;
u32 pic_type = pkt->picture_type;
u32 output_tag = pkt->output_tag;
u32 filled_len;
u32 pic_type;
u32 output_tag;
struct iris_buffer *buf, *iter;
struct iris_buffers *buffers;
u32 hfi_flags = pkt->flags;
u32 offset = pkt->offset;
u32 hfi_flags;
u32 offset;
u64 timestamp_us = 0;
bool found = false;
u32 flags = 0;
if (inst->domain == DECODER) {
timestamp_hi = uncom_pkt->time_stamp_hi;
timestamp_lo = uncom_pkt->time_stamp_lo;
filled_len = uncom_pkt->filled_len;
pic_type = uncom_pkt->picture_type;
output_tag = uncom_pkt->output_tag;
hfi_flags = uncom_pkt->flags;
offset = uncom_pkt->offset;
} else {
timestamp_hi = com_pkt->time_stamp_hi;
timestamp_lo = com_pkt->time_stamp_lo;
filled_len = com_pkt->filled_len;
pic_type = com_pkt->picture_type;
output_tag = com_pkt->output_tag;
hfi_flags = com_pkt->flags;
offset = com_pkt->offset;
}
if ((hfi_flags & HFI_BUFFERFLAG_EOS) && !filled_len) {
reinit_completion(&inst->flush_completion);
@ -418,7 +437,8 @@ static void iris_hfi_gen1_session_ftb_done(struct iris_inst *inst, void *packet)
iris_inst_sub_state_change_drain_last(inst);
}
if (iris_split_mode_enabled(inst) && pkt->stream_id == 0) {
if (iris_split_mode_enabled(inst) && inst->domain == DECODER &&
uncom_pkt->stream_id == 0) {
buffers = &inst->buffers[BUF_DPB];
if (!buffers)
goto error;
@ -459,7 +479,8 @@ static void iris_hfi_gen1_session_ftb_done(struct iris_inst *inst, void *packet)
timestamp_us = timestamp_hi;
timestamp_us = (timestamp_us << 32) | timestamp_lo;
} else {
if (pkt->stream_id == 1 && !inst->last_buffer_dequeued) {
if (inst->domain == DECODER && uncom_pkt->stream_id == 1 &&
!inst->last_buffer_dequeued) {
if (iris_drc_pending(inst) || iris_drain_pending(inst)) {
flags |= V4L2_BUF_FLAG_LAST;
inst->last_buffer_dequeued = true;
@ -551,7 +572,7 @@ static const struct iris_hfi_gen1_response_pkt_info pkt_infos[] = {
},
{
.pkt = HFI_MSG_SESSION_FILL_BUFFER,
.pkt_sz = sizeof(struct hfi_msg_session_fbd_uncompressed_plane0_pkt),
.pkt_sz = sizeof(struct hfi_msg_session_fbd_compressed_pkt),
},
{
.pkt = HFI_MSG_SESSION_FLUSH,

23
drivers/media/platform/qcom/iris/iris_hfi_gen2_command.c
View File

@ -1045,13 +1045,19 @@ static int iris_hfi_gen2_session_drain(struct iris_inst *inst, u32 plane)
inst_hfi_gen2->packet->size);
}
static u32 iris_hfi_gen2_buf_type_from_driver(enum iris_buffer_type buffer_type)
static u32 iris_hfi_gen2_buf_type_from_driver(u32 domain, enum iris_buffer_type buffer_type)
{
switch (buffer_type) {
case BUF_INPUT:
return HFI_BUFFER_BITSTREAM;
if (domain == DECODER)
return HFI_BUFFER_BITSTREAM;
else
return HFI_BUFFER_RAW;
case BUF_OUTPUT:
return HFI_BUFFER_RAW;
if (domain == DECODER)
return HFI_BUFFER_RAW;
else
return HFI_BUFFER_BITSTREAM;
case BUF_BIN:
return HFI_BUFFER_BIN;
case BUF_COMV:
@ -1091,16 +1097,17 @@ static int iris_set_num_comv(struct iris_inst *inst)
&num_comv, sizeof(u32));
}
static void iris_hfi_gen2_get_buffer(struct iris_buffer *buffer, struct iris_hfi_buffer *buf)
static void iris_hfi_gen2_get_buffer(u32 domain, struct iris_buffer *buffer,
struct iris_hfi_buffer *buf)
{
memset(buf, 0, sizeof(*buf));
buf->type = iris_hfi_gen2_buf_type_from_driver(buffer->type);
buf->type = iris_hfi_gen2_buf_type_from_driver(domain, buffer->type);
buf->index = buffer->index;
buf->base_address = buffer->device_addr;
buf->addr_offset = 0;
buf->buffer_size = buffer->buffer_size;
if (buffer->type == BUF_INPUT)
if (domain == DECODER && buffer->type == BUF_INPUT)
buf->buffer_size = ALIGN(buffer->buffer_size, 256);
buf->data_offset = buffer->data_offset;
buf->data_size = buffer->data_size;
@ -1117,7 +1124,7 @@ static int iris_hfi_gen2_session_queue_buffer(struct iris_inst *inst, struct iri
u32 port;
int ret;
iris_hfi_gen2_get_buffer(buffer, &hfi_buffer);
iris_hfi_gen2_get_buffer(inst->domain, buffer, &hfi_buffer);
if (buffer->type == BUF_COMV) {
ret = iris_set_num_comv(inst);
if (ret)
@ -1144,7 +1151,7 @@ static int iris_hfi_gen2_session_release_buffer(struct iris_inst *inst, struct i
struct iris_hfi_buffer hfi_buffer;
u32 port;
iris_hfi_gen2_get_buffer(buffer, &hfi_buffer);
iris_hfi_gen2_get_buffer(inst->domain, buffer, &hfi_buffer);
hfi_buffer.flags |= HFI_BUF_HOST_FLAG_RELEASE;
port = iris_hfi_gen2_get_port_from_buf_type(inst, buffer->type);

22
drivers/media/platform/qcom/iris/iris_hfi_gen2_response.c
View File

@ -480,12 +480,22 @@ static int iris_hfi_gen2_handle_session_buffer(struct iris_inst *inst,
if (!iris_hfi_gen2_is_valid_hfi_port(pkt->port, buffer->type))
return 0;
if (buffer->type == HFI_BUFFER_BITSTREAM)
return iris_hfi_gen2_handle_input_buffer(inst, buffer);
else if (buffer->type == HFI_BUFFER_RAW)
return iris_hfi_gen2_handle_output_buffer(inst, buffer);
else
return iris_hfi_gen2_handle_release_internal_buffer(inst, buffer);
if (inst->domain == DECODER) {
if (buffer->type == HFI_BUFFER_BITSTREAM)
return iris_hfi_gen2_handle_input_buffer(inst, buffer);
else if (buffer->type == HFI_BUFFER_RAW)
return iris_hfi_gen2_handle_output_buffer(inst, buffer);
else
return iris_hfi_gen2_handle_release_internal_buffer(inst, buffer);
} else {
if (buffer->type == HFI_BUFFER_RAW)
return iris_hfi_gen2_handle_input_buffer(inst, buffer);
else if (buffer->type == HFI_BUFFER_BITSTREAM)
return iris_hfi_gen2_handle_output_buffer(inst, buffer);
else
return iris_hfi_gen2_handle_release_internal_buffer(inst, buffer);
}
return 0;
}
static int iris_hfi_gen2_handle_session_drain(struct iris_inst *inst,

5
drivers/media/platform/qcom/iris/iris_vb2.c
View File

@ -327,7 +327,10 @@ void iris_vb2_buf_queue(struct vb2_buffer *vb2)
v4l2_m2m_buf_queue(m2m_ctx, vbuf);
ret = iris_vdec_qbuf(inst, vbuf);
if (inst->domain == DECODER)
ret = iris_vdec_qbuf(inst, vbuf);
else
ret = iris_venc_qbuf(inst, vbuf);
exit:
if (ret) {

40
drivers/media/platform/qcom/iris/iris_vdec.c
View File

@ -377,44 +377,6 @@ int iris_vdec_streamon_output(struct iris_inst *inst)
return ret;
}
static int
iris_vdec_vb2_buffer_to_driver(struct vb2_buffer *vb2, struct iris_buffer *buf)
{
struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb2);
buf->type = iris_v4l2_type_to_driver(vb2->type);
buf->index = vb2->index;
buf->fd = vb2->planes[0].m.fd;
buf->buffer_size = vb2->planes[0].length;
buf->data_offset = vb2->planes[0].data_offset;
buf->data_size = vb2->planes[0].bytesused - vb2->planes[0].data_offset;
buf->flags = vbuf->flags;
buf->timestamp = vb2->timestamp;
buf->attr = 0;
return 0;
}
static void
iris_set_ts_metadata(struct iris_inst *inst, struct vb2_v4l2_buffer *vbuf)
{
u32 mask = V4L2_BUF_FLAG_TIMECODE | V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
struct vb2_buffer *vb = &vbuf->vb2_buf;
u64 ts_us = vb->timestamp;
if (inst->metadata_idx >= ARRAY_SIZE(inst->tss))
inst->metadata_idx = 0;
do_div(ts_us, NSEC_PER_USEC);
inst->tss[inst->metadata_idx].flags = vbuf->flags & mask;
inst->tss[inst->metadata_idx].tc = vbuf->timecode;
inst->tss[inst->metadata_idx].ts_us = ts_us;
inst->tss[inst->metadata_idx].ts_ns = vb->timestamp;
inst->metadata_idx++;
}
int iris_vdec_qbuf(struct iris_inst *inst, struct vb2_v4l2_buffer *vbuf)
{
struct iris_buffer *buf = to_iris_buffer(vbuf);
@ -422,7 +384,7 @@ int iris_vdec_qbuf(struct iris_inst *inst, struct vb2_v4l2_buffer *vbuf)
struct vb2_queue *q;
int ret;
ret = iris_vdec_vb2_buffer_to_driver(vb2, buf);
ret = iris_vb2_buffer_to_driver(vb2, buf);
if (ret)
return ret;

26
drivers/media/platform/qcom/iris/iris_venc.c
View File

@ -10,6 +10,7 @@
#include "iris_common.h"
#include "iris_ctrls.h"
#include "iris_instance.h"
#include "iris_power.h"
#include "iris_venc.h"
#include "iris_vpu_buffer.h"
@ -493,3 +494,28 @@ int iris_venc_streamon_output(struct iris_inst *inst)
return ret;
}
int iris_venc_qbuf(struct iris_inst *inst, struct vb2_v4l2_buffer *vbuf)
{
struct iris_buffer *buf = to_iris_buffer(vbuf);
struct vb2_buffer *vb2 = &vbuf->vb2_buf;
struct vb2_queue *q;
int ret;
ret = iris_vb2_buffer_to_driver(vb2, buf);
if (ret)
return ret;
if (buf->type == BUF_INPUT)
iris_set_ts_metadata(inst, vbuf);
q = v4l2_m2m_get_vq(inst->m2m_ctx, vb2->type);
if (!vb2_is_streaming(q)) {
buf->attr |= BUF_ATTR_DEFERRED;
return 0;
}
iris_scale_power(inst);
return iris_queue_buffer(inst, buf);
}

1
drivers/media/platform/qcom/iris/iris_venc.h
View File

@ -20,5 +20,6 @@ int iris_venc_g_param(struct iris_inst *inst, struct v4l2_streamparm *s_parm);
int iris_venc_s_param(struct iris_inst *inst, struct v4l2_streamparm *s_parm);
int iris_venc_streamon_input(struct iris_inst *inst);
int iris_venc_streamon_output(struct iris_inst *inst);
int iris_venc_qbuf(struct iris_inst *inst, struct vb2_v4l2_buffer *vbuf);
#endif

8
drivers/media/platform/qcom/iris/iris_vidc.c
View File

@ -664,6 +664,14 @@ static const struct v4l2_ioctl_ops iris_v4l2_ioctl_ops_enc = {
.vidioc_g_parm = iris_g_parm,
.vidioc_streamon = v4l2_m2m_ioctl_streamon,
.vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
.vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
.vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
.vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
.vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,
.vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
.vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
.vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
.vidioc_remove_bufs = v4l2_m2m_ioctl_remove_bufs,
};
void iris_init_ops(struct iris_core *core)

23
drivers/media/platform/qcom/iris/iris_vpu_buffer.c
View File

@ -556,29 +556,6 @@ static u32 iris_vpu_dec_scratch1_size(struct iris_inst *inst)
iris_vpu_dec_line_size(inst);
}
static inline
u32 size_enc_single_pipe(u32 rc_type, u32 bitbin_size, u32 num_vpp_pipes,
u32 frame_width, u32 frame_height, u32 lcu_size)
{
u32 size_aligned_height = ALIGN((frame_height), lcu_size);
u32 size_aligned_width = ALIGN((frame_width), lcu_size);
u32 size_single_pipe_eval = 0, sao_bin_buffer_size = 0;
u32 padded_bin_sz;
if ((size_aligned_width * size_aligned_height) > (3840 * 2160))
size_single_pipe_eval = (bitbin_size / num_vpp_pipes);
else if (num_vpp_pipes > 2)
size_single_pipe_eval = bitbin_size / 2;
else
size_single_pipe_eval = bitbin_size;
sao_bin_buffer_size = (64 * ((((frame_width) + 32) * ((frame_height) + 32)) >> 10)) + 384;
padded_bin_sz = ALIGN(size_single_pipe_eval, 256);
size_single_pipe_eval = sao_bin_buffer_size + padded_bin_sz;
return ALIGN(size_single_pipe_eval, 256);
}
static inline u32 size_bin_bitstream_enc(u32 width, u32 height,
u32 rc_type)
{