drivers/media/platform/qcom/iris/iris_hfi_gen1_command.c

Source file repositories/reference/linux-study-clean/drivers/media/platform/qcom/iris/iris_hfi_gen1_command.c

File Facts

System
Linux kernel
Corpus path
drivers/media/platform/qcom/iris/iris_hfi_gen1_command.c
Extension
.c
Size
34389 bytes
Lines
1161
Domain
Driver Families
Bucket
drivers/media
Inferred role
Driver Families: implementation source
Status
source implementation candidate

Why This File Exists

Repeatable hardware-adapter layer. Deep compatibility for every driver is out of scope; this atlas records patterns, probe lifecycles, bus glue, IRQ/DMA usage, and links back to core abstractions.

Dependency Surface

Detected Declarations

Annotated Snippet

if (inst->state == IRIS_INST_STREAMING) {
			if (V4L2_TYPE_IS_OUTPUT(plane))
				flush_type = HFI_FLUSH_ALL;
			else if (V4L2_TYPE_IS_CAPTURE(plane))
				flush_type = HFI_FLUSH_OUTPUT;

			reinit_completion(&inst->flush_completion);

			flush_pkt.shdr.hdr.size = sizeof(struct hfi_session_flush_pkt);
			flush_pkt.shdr.hdr.pkt_type = HFI_CMD_SESSION_FLUSH;
			flush_pkt.shdr.session_id = inst->session_id;
			flush_pkt.flush_type = flush_type;

			ret = iris_hfi_queue_cmd_write(core, &flush_pkt, flush_pkt.shdr.hdr.size);
			if (!ret) {
				inst->flush_responses_pending++;
				ret = iris_wait_for_session_response(inst, true);
			}
		} else if (inst->sub_state & IRIS_INST_SUB_LOAD_RESOURCES) {
			reinit_completion(&inst->completion);
			iris_hfi_gen1_packet_session_cmd(inst, &pkt, HFI_CMD_SESSION_STOP);
			ret = iris_hfi_queue_cmd_write(core, &pkt, pkt.shdr.hdr.size);
			if (!ret)
				ret = iris_wait_for_session_response(inst, false);

			reinit_completion(&inst->completion);
			iris_hfi_gen1_packet_session_cmd(inst, &pkt,
							 HFI_CMD_SESSION_RELEASE_RESOURCES);
			ret = iris_hfi_queue_cmd_write(core, &pkt, pkt.shdr.hdr.size);
			if (!ret)
				ret = iris_wait_for_session_response(inst, false);

			iris_inst_change_sub_state(inst, IRIS_INST_SUB_LOAD_RESOURCES, 0);

			iris_helper_buffers_done(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
						 VB2_BUF_STATE_ERROR);
			iris_helper_buffers_done(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
						 VB2_BUF_STATE_ERROR);
		}
	} else {
		if (inst->state == IRIS_INST_STREAMING ||
		    inst->state == IRIS_INST_INPUT_STREAMING ||
		    inst->state == IRIS_INST_ERROR) {
			reinit_completion(&inst->completion);
			iris_hfi_gen1_packet_session_cmd(inst, &pkt, HFI_CMD_SESSION_STOP);
			ret = iris_hfi_queue_cmd_write(core, &pkt, pkt.shdr.hdr.size);
			if (!ret)
				ret = iris_wait_for_session_response(inst, false);

			reinit_completion(&inst->completion);
			iris_hfi_gen1_packet_session_cmd(inst, &pkt,
							 HFI_CMD_SESSION_RELEASE_RESOURCES);
			ret = iris_hfi_queue_cmd_write(core, &pkt, pkt.shdr.hdr.size);
			if (!ret)
				ret = iris_wait_for_session_response(inst, false);

			iris_inst_change_sub_state(inst, IRIS_INST_SUB_LOAD_RESOURCES, 0);
		}

		iris_helper_buffers_done(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
					 VB2_BUF_STATE_ERROR);
		iris_helper_buffers_done(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
					 VB2_BUF_STATE_ERROR);
	}

	return ret;
}

static int iris_hfi_gen1_session_continue(struct iris_inst *inst, u32 plane)
{
	struct hfi_session_pkt packet;

	iris_hfi_gen1_packet_session_cmd(inst, &packet, HFI_CMD_SESSION_CONTINUE);

	return iris_hfi_queue_cmd_write(inst->core, &packet, packet.shdr.hdr.size);
}

static int iris_hfi_gen1_queue_input_buffer(struct iris_inst *inst, struct iris_buffer *buf)
{
	struct hfi_session_empty_buffer_compressed_pkt com_ip_pkt;
	struct hfi_session_empty_buffer_uncompressed_pkt uncom_ip_pkt;

	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 = 0;
		com_ip_pkt.mark_target = 0;

Annotation

Implementation Notes