1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved.
4 */
5
6 #include "iris_hfi_gen1.h"
7 #include "iris_hfi_gen1_defines.h"
8 #include "iris_instance.h"
9 #include "iris_vpu_buffer.h"
10
iris_hfi_gen1_buf_type_from_driver(enum iris_buffer_type buffer_type)11 static u32 iris_hfi_gen1_buf_type_from_driver(enum iris_buffer_type buffer_type)
12 {
13 switch (buffer_type) {
14 case BUF_INPUT:
15 return HFI_BUFFER_INPUT;
16 case BUF_OUTPUT:
17 return HFI_BUFFER_OUTPUT;
18 case BUF_PERSIST:
19 return HFI_BUFFER_INTERNAL_PERSIST_1;
20 case BUF_BIN:
21 return HFI_BUFFER_INTERNAL_SCRATCH;
22 case BUF_SCRATCH_1:
23 return HFI_BUFFER_INTERNAL_SCRATCH_1;
24 case BUF_SCRATCH_2:
25 return HFI_BUFFER_INTERNAL_SCRATCH_2;
26 case BUF_ARP:
27 return HFI_BUFFER_INTERNAL_PERSIST;
28 default:
29 return -EINVAL;
30 }
31 }
32
iris_hfi_gen1_sys_init(struct iris_core * core)33 static int iris_hfi_gen1_sys_init(struct iris_core *core)
34 {
35 struct hfi_sys_init_pkt sys_init_pkt;
36
37 sys_init_pkt.hdr.size = sizeof(sys_init_pkt);
38 sys_init_pkt.hdr.pkt_type = HFI_CMD_SYS_INIT;
39 sys_init_pkt.arch_type = HFI_VIDEO_ARCH_OX;
40
41 return iris_hfi_queue_cmd_write_locked(core, &sys_init_pkt, sys_init_pkt.hdr.size);
42 }
43
iris_hfi_gen1_sys_image_version(struct iris_core * core)44 static int iris_hfi_gen1_sys_image_version(struct iris_core *core)
45 {
46 struct hfi_sys_get_property_pkt packet;
47
48 packet.hdr.size = sizeof(packet);
49 packet.hdr.pkt_type = HFI_CMD_SYS_GET_PROPERTY;
50 packet.num_properties = 1;
51 packet.data = HFI_PROPERTY_SYS_IMAGE_VERSION;
52
53 return iris_hfi_queue_cmd_write_locked(core, &packet, packet.hdr.size);
54 }
55
iris_hfi_gen1_sys_interframe_powercollapse(struct iris_core * core)56 static int iris_hfi_gen1_sys_interframe_powercollapse(struct iris_core *core)
57 {
58 struct hfi_sys_set_property_pkt *pkt;
59 struct hfi_enable *hfi;
60 u32 packet_size;
61 int ret;
62
63 packet_size = struct_size(pkt, data, 1) + sizeof(*hfi);
64 pkt = kzalloc(packet_size, GFP_KERNEL);
65 if (!pkt)
66 return -ENOMEM;
67
68 hfi = (struct hfi_enable *)&pkt->data[1];
69
70 pkt->hdr.size = packet_size;
71 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_PROPERTY;
72 pkt->num_properties = 1;
73 pkt->data[0] = HFI_PROPERTY_SYS_CODEC_POWER_PLANE_CTRL;
74 hfi->enable = true;
75
76 ret = iris_hfi_queue_cmd_write_locked(core, pkt, pkt->hdr.size);
77 kfree(pkt);
78
79 return ret;
80 }
81
iris_hfi_gen1_sys_pc_prep(struct iris_core * core)82 static int iris_hfi_gen1_sys_pc_prep(struct iris_core *core)
83 {
84 struct hfi_sys_pc_prep_pkt pkt;
85
86 pkt.hdr.size = sizeof(struct hfi_sys_pc_prep_pkt);
87 pkt.hdr.pkt_type = HFI_CMD_SYS_PC_PREP;
88
89 return iris_hfi_queue_cmd_write_locked(core, &pkt, pkt.hdr.size);
90 }
91
iris_hfi_gen1_session_open(struct iris_inst * inst)92 static int iris_hfi_gen1_session_open(struct iris_inst *inst)
93 {
94 struct hfi_session_open_pkt packet;
95 u32 codec = 0;
96 int ret;
97
98 if (inst->state != IRIS_INST_DEINIT)
99 return -EALREADY;
100
101 switch (inst->codec) {
102 case V4L2_PIX_FMT_H264:
103 codec = HFI_VIDEO_CODEC_H264;
104 break;
105 case V4L2_PIX_FMT_HEVC:
106 codec = HFI_VIDEO_CODEC_HEVC;
107 break;
108 case V4L2_PIX_FMT_VP9:
109 codec = HFI_VIDEO_CODEC_VP9;
110 break;
111 }
112
113 packet.shdr.hdr.size = sizeof(struct hfi_session_open_pkt);
114 packet.shdr.hdr.pkt_type = HFI_CMD_SYS_SESSION_INIT;
115 packet.shdr.session_id = inst->session_id;
116
117 if (inst->domain == DECODER)
118 packet.session_domain = HFI_SESSION_TYPE_DEC;
119 else
120 packet.session_domain = HFI_SESSION_TYPE_ENC;
121
122 packet.session_codec = codec;
123
124 reinit_completion(&inst->completion);
125
126 ret = iris_hfi_queue_cmd_write(inst->core, &packet, packet.shdr.hdr.size);
127 if (ret)
128 return ret;
129
130 return iris_wait_for_session_response(inst, false);
131 }
132
iris_hfi_gen1_packet_session_cmd(struct iris_inst * inst,struct hfi_session_pkt * packet,u32 ptype)133 static void iris_hfi_gen1_packet_session_cmd(struct iris_inst *inst,
134 struct hfi_session_pkt *packet,
135 u32 ptype)
136 {
137 packet->shdr.hdr.size = sizeof(*packet);
138 packet->shdr.hdr.pkt_type = ptype;
139 packet->shdr.session_id = inst->session_id;
140 }
141
iris_hfi_gen1_session_close(struct iris_inst * inst)142 static int iris_hfi_gen1_session_close(struct iris_inst *inst)
143 {
144 struct hfi_session_pkt packet;
145
146 iris_hfi_gen1_packet_session_cmd(inst, &packet, HFI_CMD_SYS_SESSION_END);
147
148 return iris_hfi_queue_cmd_write(inst->core, &packet, packet.shdr.hdr.size);
149 }
150
iris_hfi_gen1_session_start(struct iris_inst * inst,u32 plane)151 static int iris_hfi_gen1_session_start(struct iris_inst *inst, u32 plane)
152 {
153 struct iris_core *core = inst->core;
154 struct hfi_session_pkt packet;
155 int ret;
156
157 if (!V4L2_TYPE_IS_OUTPUT(plane))
158 return 0;
159
160 if (inst->sub_state & IRIS_INST_SUB_LOAD_RESOURCES)
161 return 0;
162
163 reinit_completion(&inst->completion);
164 iris_hfi_gen1_packet_session_cmd(inst, &packet, HFI_CMD_SESSION_LOAD_RESOURCES);
165
166 ret = iris_hfi_queue_cmd_write(core, &packet, packet.shdr.hdr.size);
167 if (ret)
168 return ret;
169
170 ret = iris_wait_for_session_response(inst, false);
171 if (ret)
172 return ret;
173
174 reinit_completion(&inst->completion);
175 iris_hfi_gen1_packet_session_cmd(inst, &packet, HFI_CMD_SESSION_START);
176
177 ret = iris_hfi_queue_cmd_write(core, &packet, packet.shdr.hdr.size);
178 if (ret)
179 return ret;
180
181 ret = iris_wait_for_session_response(inst, false);
182 if (ret)
183 return ret;
184
185 return iris_inst_change_sub_state(inst, 0, IRIS_INST_SUB_LOAD_RESOURCES);
186 }
187
iris_hfi_gen1_session_stop(struct iris_inst * inst,u32 plane)188 static int iris_hfi_gen1_session_stop(struct iris_inst *inst, u32 plane)
189 {
190 struct hfi_session_flush_pkt flush_pkt;
191 struct iris_core *core = inst->core;
192 struct hfi_session_pkt pkt;
193 u32 flush_type = 0;
194 int ret = 0;
195
196 if (inst->domain == DECODER) {
197 if (inst->state == IRIS_INST_STREAMING) {
198 if (V4L2_TYPE_IS_OUTPUT(plane))
199 flush_type = HFI_FLUSH_ALL;
200 else if (V4L2_TYPE_IS_CAPTURE(plane))
201 flush_type = HFI_FLUSH_OUTPUT;
202
203 reinit_completion(&inst->flush_completion);
204
205 flush_pkt.shdr.hdr.size = sizeof(struct hfi_session_flush_pkt);
206 flush_pkt.shdr.hdr.pkt_type = HFI_CMD_SESSION_FLUSH;
207 flush_pkt.shdr.session_id = inst->session_id;
208 flush_pkt.flush_type = flush_type;
209
210 ret = iris_hfi_queue_cmd_write(core, &flush_pkt, flush_pkt.shdr.hdr.size);
211 if (!ret) {
212 inst->flush_responses_pending++;
213 ret = iris_wait_for_session_response(inst, true);
214 }
215 } else if (inst->sub_state & IRIS_INST_SUB_LOAD_RESOURCES) {
216 reinit_completion(&inst->completion);
217 iris_hfi_gen1_packet_session_cmd(inst, &pkt, HFI_CMD_SESSION_STOP);
218 ret = iris_hfi_queue_cmd_write(core, &pkt, pkt.shdr.hdr.size);
219 if (!ret)
220 ret = iris_wait_for_session_response(inst, false);
221
222 reinit_completion(&inst->completion);
223 iris_hfi_gen1_packet_session_cmd(inst, &pkt,
224 HFI_CMD_SESSION_RELEASE_RESOURCES);
225 ret = iris_hfi_queue_cmd_write(core, &pkt, pkt.shdr.hdr.size);
226 if (!ret)
227 ret = iris_wait_for_session_response(inst, false);
228
229 iris_inst_change_sub_state(inst, IRIS_INST_SUB_LOAD_RESOURCES, 0);
230
231 iris_helper_buffers_done(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
232 VB2_BUF_STATE_ERROR);
233 iris_helper_buffers_done(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
234 VB2_BUF_STATE_ERROR);
235 }
236 } else {
237 if (inst->state == IRIS_INST_STREAMING ||
238 inst->state == IRIS_INST_INPUT_STREAMING ||
239 inst->state == IRIS_INST_ERROR) {
240 reinit_completion(&inst->completion);
241 iris_hfi_gen1_packet_session_cmd(inst, &pkt, HFI_CMD_SESSION_STOP);
242 ret = iris_hfi_queue_cmd_write(core, &pkt, pkt.shdr.hdr.size);
243 if (!ret)
244 ret = iris_wait_for_session_response(inst, false);
245
246 reinit_completion(&inst->completion);
247 iris_hfi_gen1_packet_session_cmd(inst, &pkt,
248 HFI_CMD_SESSION_RELEASE_RESOURCES);
249 ret = iris_hfi_queue_cmd_write(core, &pkt, pkt.shdr.hdr.size);
250 if (!ret)
251 ret = iris_wait_for_session_response(inst, false);
252
253 iris_inst_change_sub_state(inst, IRIS_INST_SUB_LOAD_RESOURCES, 0);
254 }
255
256 iris_helper_buffers_done(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
257 VB2_BUF_STATE_ERROR);
258 iris_helper_buffers_done(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
259 VB2_BUF_STATE_ERROR);
260 }
261
262 return ret;
263 }
264
iris_hfi_gen1_session_continue(struct iris_inst * inst,u32 plane)265 static int iris_hfi_gen1_session_continue(struct iris_inst *inst, u32 plane)
266 {
267 struct hfi_session_pkt packet;
268
269 iris_hfi_gen1_packet_session_cmd(inst, &packet, HFI_CMD_SESSION_CONTINUE);
270
271 return iris_hfi_queue_cmd_write(inst->core, &packet, packet.shdr.hdr.size);
272 }
273
iris_hfi_gen1_queue_input_buffer(struct iris_inst * inst,struct iris_buffer * buf)274 static int iris_hfi_gen1_queue_input_buffer(struct iris_inst *inst, struct iris_buffer *buf)
275 {
276 struct hfi_session_empty_buffer_compressed_pkt com_ip_pkt;
277 struct hfi_session_empty_buffer_uncompressed_pkt uncom_ip_pkt;
278
279 if (inst->domain == DECODER) {
280 com_ip_pkt.shdr.hdr.size = sizeof(struct hfi_session_empty_buffer_compressed_pkt);
281 com_ip_pkt.shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
282 com_ip_pkt.shdr.session_id = inst->session_id;
283 com_ip_pkt.time_stamp_hi = upper_32_bits(buf->timestamp);
284 com_ip_pkt.time_stamp_lo = lower_32_bits(buf->timestamp);
285 com_ip_pkt.flags = 0;
286 com_ip_pkt.mark_target = 0;
287 com_ip_pkt.mark_data = 0;
288 com_ip_pkt.offset = buf->data_offset;
289 com_ip_pkt.alloc_len = buf->buffer_size;
290 com_ip_pkt.filled_len = buf->data_size;
291 com_ip_pkt.input_tag = buf->index;
292 com_ip_pkt.packet_buffer = buf->device_addr;
293 return iris_hfi_queue_cmd_write(inst->core, &com_ip_pkt,
294 com_ip_pkt.shdr.hdr.size);
295 } else {
296 uncom_ip_pkt.shdr.hdr.size =
297 sizeof(struct hfi_session_empty_buffer_uncompressed_pkt);
298 uncom_ip_pkt.shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
299 uncom_ip_pkt.shdr.session_id = inst->session_id;
300 uncom_ip_pkt.time_stamp_hi = upper_32_bits(buf->timestamp);
301 uncom_ip_pkt.time_stamp_lo = lower_32_bits(buf->timestamp);
302 uncom_ip_pkt.view_id = 0;
303 uncom_ip_pkt.flags = buf->flags;
304 uncom_ip_pkt.mark_target = 0;
305 uncom_ip_pkt.mark_data = 0;
306 uncom_ip_pkt.offset = buf->data_offset;
307 uncom_ip_pkt.alloc_len = buf->buffer_size;
308 uncom_ip_pkt.filled_len = buf->data_size;
309 uncom_ip_pkt.input_tag = buf->index;
310 uncom_ip_pkt.packet_buffer = buf->device_addr;
311 return iris_hfi_queue_cmd_write(inst->core, &uncom_ip_pkt,
312 uncom_ip_pkt.shdr.hdr.size);
313 }
314 }
315
iris_hfi_gen1_queue_output_buffer(struct iris_inst * inst,struct iris_buffer * buf)316 static int iris_hfi_gen1_queue_output_buffer(struct iris_inst *inst, struct iris_buffer *buf)
317 {
318 struct hfi_session_fill_buffer_pkt op_pkt;
319
320 op_pkt.shdr.hdr.size = sizeof(struct hfi_session_fill_buffer_pkt);
321 op_pkt.shdr.hdr.pkt_type = HFI_CMD_SESSION_FILL_BUFFER;
322 op_pkt.shdr.session_id = inst->session_id;
323 op_pkt.output_tag = buf->index;
324 op_pkt.packet_buffer = buf->device_addr;
325 op_pkt.extradata_buffer = 0;
326 op_pkt.alloc_len = buf->buffer_size;
327 op_pkt.filled_len = buf->data_size;
328 op_pkt.offset = buf->data_offset;
329 op_pkt.data = 0;
330
331 if (buf->type == BUF_OUTPUT && iris_split_mode_enabled(inst))
332 op_pkt.stream_id = 1;
333 else
334 op_pkt.stream_id = 0;
335
336 return iris_hfi_queue_cmd_write(inst->core, &op_pkt, op_pkt.shdr.hdr.size);
337 }
338
iris_hfi_gen1_queue_internal_buffer(struct iris_inst * inst,struct iris_buffer * buf)339 static int iris_hfi_gen1_queue_internal_buffer(struct iris_inst *inst, struct iris_buffer *buf)
340 {
341 struct hfi_session_set_buffers_pkt *int_pkt;
342 u32 buffer_type, i;
343 u32 packet_size;
344 int ret;
345
346 packet_size = struct_size(int_pkt, buffer_info, 1);
347 int_pkt = kzalloc(packet_size, GFP_KERNEL);
348 if (!int_pkt)
349 return -ENOMEM;
350
351 int_pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_BUFFERS;
352 int_pkt->shdr.session_id = inst->session_id;
353 int_pkt->buffer_size = buf->buffer_size;
354 int_pkt->min_buffer_size = buf->buffer_size;
355 int_pkt->num_buffers = 1;
356 int_pkt->extradata_size = 0;
357 int_pkt->shdr.hdr.size = packet_size;
358 for (i = 0; i < int_pkt->num_buffers; i++)
359 int_pkt->buffer_info[i] = buf->device_addr;
360 buffer_type = iris_hfi_gen1_buf_type_from_driver(buf->type);
361 if (buffer_type == -EINVAL) {
362 ret = -EINVAL;
363 goto exit;
364 }
365
366 int_pkt->buffer_type = buffer_type;
367 ret = iris_hfi_queue_cmd_write(inst->core, int_pkt, int_pkt->shdr.hdr.size);
368
369 exit:
370 kfree(int_pkt);
371
372 return ret;
373 }
374
iris_hfi_gen1_session_queue_buffer(struct iris_inst * inst,struct iris_buffer * buf)375 static int iris_hfi_gen1_session_queue_buffer(struct iris_inst *inst, struct iris_buffer *buf)
376 {
377 switch (buf->type) {
378 case BUF_INPUT:
379 return iris_hfi_gen1_queue_input_buffer(inst, buf);
380 case BUF_OUTPUT:
381 case BUF_DPB:
382 return iris_hfi_gen1_queue_output_buffer(inst, buf);
383 case BUF_PERSIST:
384 case BUF_BIN:
385 case BUF_SCRATCH_1:
386 case BUF_SCRATCH_2:
387 case BUF_ARP:
388 return iris_hfi_gen1_queue_internal_buffer(inst, buf);
389 default:
390 return -EINVAL;
391 }
392 }
393
iris_hfi_gen1_session_unset_buffers(struct iris_inst * inst,struct iris_buffer * buf)394 static int iris_hfi_gen1_session_unset_buffers(struct iris_inst *inst, struct iris_buffer *buf)
395 {
396 struct hfi_session_release_buffer_pkt *pkt;
397 u32 packet_size, buffer_type, i;
398 int ret;
399
400 buffer_type = iris_hfi_gen1_buf_type_from_driver(buf->type);
401 if (buffer_type == -EINVAL)
402 return -EINVAL;
403
404 if (buffer_type == HFI_BUFFER_INPUT)
405 return 0;
406
407 packet_size = sizeof(*pkt) + sizeof(struct hfi_buffer_info);
408 pkt = kzalloc(packet_size, GFP_KERNEL);
409 if (!pkt)
410 return -ENOMEM;
411
412 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_RELEASE_BUFFERS;
413 pkt->shdr.session_id = inst->session_id;
414 pkt->buffer_size = buf->buffer_size;
415 pkt->num_buffers = 1;
416
417 if (buffer_type == HFI_BUFFER_OUTPUT ||
418 buffer_type == HFI_BUFFER_OUTPUT2) {
419 struct hfi_buffer_info *bi;
420
421 bi = (struct hfi_buffer_info *)pkt->buffer_info;
422 for (i = 0; i < pkt->num_buffers; i++) {
423 bi->buffer_addr = buf->device_addr;
424 bi->extradata_addr = 0;
425 }
426 pkt->shdr.hdr.size = packet_size;
427 } else {
428 for (i = 0; i < pkt->num_buffers; i++)
429 pkt->buffer_info[i] = buf->device_addr;
430 pkt->extradata_size = 0;
431 pkt->shdr.hdr.size =
432 sizeof(struct hfi_session_set_buffers_pkt) +
433 ((pkt->num_buffers) * sizeof(u32));
434 }
435
436 pkt->response_req = true;
437 pkt->buffer_type = buffer_type;
438
439 ret = iris_hfi_queue_cmd_write(inst->core, pkt, pkt->shdr.hdr.size);
440 if (ret)
441 goto exit;
442
443 ret = iris_wait_for_session_response(inst, false);
444 if (!ret)
445 ret = iris_destroy_internal_buffer(inst, buf);
446
447 exit:
448 kfree(pkt);
449
450 return ret;
451 }
452
iris_hfi_gen1_session_drain(struct iris_inst * inst,u32 plane)453 static int iris_hfi_gen1_session_drain(struct iris_inst *inst, u32 plane)
454 {
455 if (inst->domain == DECODER) {
456 struct hfi_session_empty_buffer_compressed_pkt ip_pkt = {0};
457
458 ip_pkt.shdr.hdr.size = sizeof(struct hfi_session_empty_buffer_compressed_pkt);
459 ip_pkt.shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
460 ip_pkt.shdr.session_id = inst->session_id;
461 ip_pkt.flags = HFI_BUFFERFLAG_EOS;
462 ip_pkt.packet_buffer = 0xdeadb000;
463
464 return iris_hfi_queue_cmd_write(inst->core, &ip_pkt, ip_pkt.shdr.hdr.size);
465 }
466
467 if (inst->domain == ENCODER) {
468 struct hfi_session_empty_buffer_uncompressed_pkt ip_pkt = {0};
469
470 ip_pkt.shdr.hdr.size = sizeof(struct hfi_session_empty_buffer_uncompressed_pkt);
471 ip_pkt.shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
472 ip_pkt.shdr.session_id = inst->session_id;
473 ip_pkt.flags = HFI_BUFFERFLAG_EOS;
474 ip_pkt.packet_buffer = 0xdeadb000;
475
476 return iris_hfi_queue_cmd_write(inst->core, &ip_pkt, ip_pkt.shdr.hdr.size);
477 }
478
479 return -EINVAL;
480 }
481
482 static int
iris_hfi_gen1_packet_session_set_property(struct hfi_session_set_property_pkt * packet,struct iris_inst * inst,u32 ptype,void * pdata)483 iris_hfi_gen1_packet_session_set_property(struct hfi_session_set_property_pkt *packet,
484 struct iris_inst *inst, u32 ptype, void *pdata)
485 {
486 void *prop_data = &packet->data[1];
487
488 packet->shdr.hdr.size = sizeof(*packet);
489 packet->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
490 packet->shdr.session_id = inst->session_id;
491 packet->num_properties = 1;
492 packet->data[0] = ptype;
493
494 switch (ptype) {
495 case HFI_PROPERTY_PARAM_FRAME_SIZE: {
496 struct hfi_framesize *in = pdata, *fsize = prop_data;
497
498 fsize->buffer_type = in->buffer_type;
499 fsize->height = in->height;
500 fsize->width = in->width;
501 packet->shdr.hdr.size += sizeof(u32) + sizeof(*fsize);
502 break;
503 }
504 case HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE: {
505 struct hfi_videocores_usage_type *in = pdata, *cu = prop_data;
506
507 cu->video_core_enable_mask = in->video_core_enable_mask;
508 packet->shdr.hdr.size += sizeof(u32) + sizeof(*cu);
509 break;
510 }
511 case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT: {
512 struct hfi_uncompressed_format_select *in = pdata;
513 struct hfi_uncompressed_format_select *hfi = prop_data;
514
515 hfi->buffer_type = in->buffer_type;
516 hfi->format = in->format;
517 packet->shdr.hdr.size += sizeof(u32) + sizeof(*hfi);
518 break;
519 }
520 case HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO: {
521 struct hfi_uncompressed_plane_actual_constraints_info *info = prop_data;
522
523 info->buffer_type = HFI_BUFFER_OUTPUT2;
524 info->num_planes = 2;
525 info->plane_format[0].stride_multiples = 128;
526 info->plane_format[0].max_stride = 8192;
527 info->plane_format[0].min_plane_buffer_height_multiple = 32;
528 info->plane_format[0].buffer_alignment = 256;
529 if (info->num_planes > 1) {
530 info->plane_format[1].stride_multiples = 128;
531 info->plane_format[1].max_stride = 8192;
532 info->plane_format[1].min_plane_buffer_height_multiple = 16;
533 info->plane_format[1].buffer_alignment = 256;
534 }
535
536 packet->shdr.hdr.size += sizeof(u32) + sizeof(*info);
537 break;
538 }
539 case HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL: {
540 struct hfi_buffer_count_actual *in = pdata;
541 struct hfi_buffer_count_actual *count = prop_data;
542
543 count->type = in->type;
544 count->count_actual = in->count_actual;
545 count->count_min_host = in->count_min_host;
546 packet->shdr.hdr.size += sizeof(u32) + sizeof(*count);
547 break;
548 }
549 case HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM: {
550 struct hfi_multi_stream *in = pdata;
551 struct hfi_multi_stream *multi = prop_data;
552
553 multi->buffer_type = in->buffer_type;
554 multi->enable = in->enable;
555 packet->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
556 break;
557 }
558 case HFI_PROPERTY_PARAM_BUFFER_SIZE_ACTUAL: {
559 struct hfi_buffer_size_actual *in = pdata, *sz = prop_data;
560
561 sz->size = in->size;
562 sz->type = in->type;
563 packet->shdr.hdr.size += sizeof(u32) + sizeof(*sz);
564 break;
565 }
566 case HFI_PROPERTY_PARAM_WORK_ROUTE: {
567 struct hfi_video_work_route *wr = prop_data;
568 u32 *in = pdata;
569
570 wr->video_work_route = *in;
571 packet->shdr.hdr.size += sizeof(u32) + sizeof(*wr);
572 break;
573 }
574 case HFI_PROPERTY_PARAM_WORK_MODE: {
575 struct hfi_video_work_mode *wm = prop_data;
576 u32 *in = pdata;
577
578 wm->video_work_mode = *in;
579 packet->shdr.hdr.size += sizeof(u32) + sizeof(*wm);
580 break;
581 }
582 case HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT: {
583 struct hfi_profile_level *in = pdata, *pl = prop_data;
584
585 pl->level = in->level;
586 pl->profile = in->profile;
587 if (pl->profile <= 0)
588 /* Profile not supported, falling back to high */
589 pl->profile = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH;
590
591 if (!pl->level)
592 /* Level not supported, falling back to 1 */
593 pl->level = 1;
594
595 packet->shdr.hdr.size += sizeof(u32) + sizeof(*pl);
596 break;
597 }
598 case HFI_PROPERTY_CONFIG_VENC_SYNC_FRAME_SEQUENCE_HEADER: {
599 struct hfi_enable *en = prop_data;
600 u32 *in = pdata;
601
602 en->enable = *in;
603 packet->shdr.hdr.size += sizeof(u32) + sizeof(*en);
604 break;
605 }
606 case HFI_PROPERTY_CONFIG_VENC_TARGET_BITRATE: {
607 struct hfi_bitrate *brate = prop_data;
608 u32 *in = pdata;
609
610 brate->bitrate = *in;
611 brate->layer_id = 0;
612 packet->shdr.hdr.size += sizeof(u32) + sizeof(*brate);
613 break;
614 }
615 case HFI_PROPERTY_PARAM_VENC_RATE_CONTROL: {
616 u32 *in = pdata;
617
618 switch (*in) {
619 case HFI_RATE_CONTROL_OFF:
620 case HFI_RATE_CONTROL_CBR_CFR:
621 case HFI_RATE_CONTROL_CBR_VFR:
622 case HFI_RATE_CONTROL_VBR_CFR:
623 case HFI_RATE_CONTROL_VBR_VFR:
624 case HFI_RATE_CONTROL_CQ:
625 break;
626 default:
627 return -EINVAL;
628 }
629
630 packet->data[1] = *in;
631 packet->shdr.hdr.size += sizeof(u32) * 2;
632 break;
633 }
634 case HFI_PROPERTY_PARAM_VENC_H264_ENTROPY_CONTROL: {
635 struct hfi_h264_entropy_control *entropy = prop_data;
636 u32 *in = pdata;
637
638 entropy->entropy_mode = *in;
639 if (entropy->entropy_mode == HFI_H264_ENTROPY_CABAC)
640 entropy->cabac_model = HFI_H264_CABAC_MODEL_0;
641 packet->shdr.hdr.size += sizeof(u32) + sizeof(*entropy);
642 break;
643 }
644 case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE_V2: {
645 struct hfi_quantization_range_v2 *range = prop_data;
646 struct hfi_quantization_range_v2 *in = pdata;
647 u32 min_qp, max_qp;
648
649 min_qp = in->min_qp.qp_packed;
650 max_qp = in->max_qp.qp_packed;
651
652 /* We'll be packing in the qp, so make sure we
653 * won't be losing data when masking
654 */
655 if (min_qp > 0xff || max_qp > 0xff)
656 return -ERANGE;
657
658 range->min_qp.layer_id = 0xFF;
659 range->max_qp.layer_id = 0xFF;
660 range->min_qp.qp_packed = (min_qp & 0xFF) | ((min_qp & 0xFF) << 8) |
661 ((min_qp & 0xFF) << 16);
662 range->max_qp.qp_packed = (max_qp & 0xFF) | ((max_qp & 0xFF) << 8) |
663 ((max_qp & 0xFF) << 16);
664 range->min_qp.enable = 7;
665 range->max_qp.enable = 7;
666 packet->shdr.hdr.size += sizeof(u32) + sizeof(*range);
667 break;
668 }
669 case HFI_PROPERTY_CONFIG_FRAME_RATE: {
670 struct hfi_framerate *frate = prop_data;
671 struct hfi_framerate *in = pdata;
672
673 frate->buffer_type = in->buffer_type;
674 frate->framerate = in->framerate;
675 packet->shdr.hdr.size += sizeof(u32) + sizeof(*frate);
676 break;
677 }
678 case HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_INFO: {
679 struct hfi_uncompressed_plane_actual_info *plane_actual_info = prop_data;
680 struct hfi_uncompressed_plane_actual_info *in = pdata;
681
682 plane_actual_info->buffer_type = in->buffer_type;
683 plane_actual_info->num_planes = in->num_planes;
684 plane_actual_info->plane_format[0] = in->plane_format[0];
685 if (in->num_planes > 1)
686 plane_actual_info->plane_format[1] = in->plane_format[1];
687 packet->shdr.hdr.size += sizeof(u32) + sizeof(*plane_actual_info);
688 break;
689 }
690 default:
691 return -EINVAL;
692 }
693
694 return 0;
695 }
696
hfi_gen1_set_property(struct iris_inst * inst,u32 packet_type,void * payload,u32 payload_size)697 static int hfi_gen1_set_property(struct iris_inst *inst, u32 packet_type,
698 void *payload, u32 payload_size)
699 {
700 struct hfi_session_set_property_pkt *pkt;
701 u32 packet_size;
702 int ret;
703
704 packet_size = sizeof(*pkt) + sizeof(u32) + payload_size;
705 pkt = kzalloc(packet_size, GFP_KERNEL);
706 if (!pkt)
707 return -ENOMEM;
708
709 ret = iris_hfi_gen1_packet_session_set_property(pkt, inst, packet_type, payload);
710 if (ret == -EOPNOTSUPP) {
711 ret = 0;
712 goto exit;
713 }
714 if (ret)
715 goto exit;
716
717 ret = iris_hfi_queue_cmd_write(inst->core, pkt, pkt->shdr.hdr.size);
718
719 exit:
720 kfree(pkt);
721
722 return ret;
723 }
724
iris_hfi_gen1_session_set_property(struct iris_inst * inst,u32 packet_type,u32 flag,u32 plane,u32 payload_type,void * payload,u32 payload_size)725 static int iris_hfi_gen1_session_set_property(struct iris_inst *inst, u32 packet_type,
726 u32 flag, u32 plane, u32 payload_type,
727 void *payload, u32 payload_size)
728 {
729 return hfi_gen1_set_property(inst, packet_type, payload, payload_size);
730 }
731
iris_hfi_gen1_set_resolution(struct iris_inst * inst,u32 plane)732 static int iris_hfi_gen1_set_resolution(struct iris_inst *inst, u32 plane)
733 {
734 u32 ptype = HFI_PROPERTY_PARAM_FRAME_SIZE;
735 struct hfi_framesize fs;
736 int ret;
737
738 if (!iris_drc_pending(inst) && !(inst->sub_state & IRIS_INST_SUB_FIRST_IPSC)) {
739 fs.buffer_type = HFI_BUFFER_INPUT;
740 fs.width = inst->fmt_src->fmt.pix_mp.width;
741 fs.height = inst->fmt_src->fmt.pix_mp.height;
742
743 ret = hfi_gen1_set_property(inst, ptype, &fs, sizeof(fs));
744 if (ret)
745 return ret;
746 }
747 if (inst->domain == DECODER)
748 fs.buffer_type = HFI_BUFFER_OUTPUT2;
749 else
750 fs.buffer_type = HFI_BUFFER_OUTPUT;
751
752 fs.width = inst->fmt_dst->fmt.pix_mp.width;
753 fs.height = inst->fmt_dst->fmt.pix_mp.height;
754
755 return hfi_gen1_set_property(inst, ptype, &fs, sizeof(fs));
756 }
757
iris_hfi_gen1_decide_core(struct iris_inst * inst,u32 plane)758 static int iris_hfi_gen1_decide_core(struct iris_inst *inst, u32 plane)
759 {
760 const u32 ptype = HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE;
761 struct hfi_videocores_usage_type cu;
762
763 cu.video_core_enable_mask = HFI_CORE_ID_1;
764
765 return hfi_gen1_set_property(inst, ptype, &cu, sizeof(cu));
766 }
767
iris_hfi_gen1_set_raw_format(struct iris_inst * inst,u32 plane)768 static int iris_hfi_gen1_set_raw_format(struct iris_inst *inst, u32 plane)
769 {
770 const u32 ptype = HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT;
771 struct hfi_uncompressed_format_select fmt;
772 u32 pixelformat;
773 int ret;
774
775 if (inst->domain == DECODER) {
776 pixelformat = inst->fmt_dst->fmt.pix_mp.pixelformat;
777 if (iris_split_mode_enabled(inst)) {
778 fmt.buffer_type = HFI_BUFFER_OUTPUT;
779 fmt.format = HFI_COLOR_FORMAT_NV12_UBWC;
780
781 ret = hfi_gen1_set_property(inst, ptype, &fmt, sizeof(fmt));
782 if (ret)
783 return ret;
784
785 fmt.buffer_type = HFI_BUFFER_OUTPUT2;
786 fmt.format = pixelformat == V4L2_PIX_FMT_NV12 ?
787 HFI_COLOR_FORMAT_NV12 : HFI_COLOR_FORMAT_NV12_UBWC;
788
789 ret = hfi_gen1_set_property(inst, ptype, &fmt, sizeof(fmt));
790 } else {
791 fmt.buffer_type = HFI_BUFFER_OUTPUT;
792 fmt.format = pixelformat == V4L2_PIX_FMT_NV12 ?
793 HFI_COLOR_FORMAT_NV12 : HFI_COLOR_FORMAT_NV12_UBWC;
794
795 ret = hfi_gen1_set_property(inst, ptype, &fmt, sizeof(fmt));
796 }
797 } else {
798 pixelformat = inst->fmt_src->fmt.pix_mp.pixelformat;
799 fmt.buffer_type = HFI_BUFFER_INPUT;
800 fmt.format = pixelformat == V4L2_PIX_FMT_NV12 ?
801 HFI_COLOR_FORMAT_NV12 : HFI_COLOR_FORMAT_NV12_UBWC;
802 ret = hfi_gen1_set_property(inst, ptype, &fmt, sizeof(fmt));
803 }
804
805 return ret;
806 }
807
iris_hfi_gen1_set_format_constraints(struct iris_inst * inst,u32 plane)808 static int iris_hfi_gen1_set_format_constraints(struct iris_inst *inst, u32 plane)
809 {
810 const u32 ptype = HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO;
811 struct hfi_uncompressed_plane_actual_constraints_info pconstraint;
812
813 if (inst->fmt_dst->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_QC08C)
814 return 0;
815
816 pconstraint.buffer_type = HFI_BUFFER_OUTPUT2;
817 pconstraint.num_planes = 2;
818 pconstraint.plane_format[0].stride_multiples = 128;
819 pconstraint.plane_format[0].max_stride = 8192;
820 pconstraint.plane_format[0].min_plane_buffer_height_multiple = 32;
821 pconstraint.plane_format[0].buffer_alignment = 256;
822
823 pconstraint.plane_format[1].stride_multiples = 128;
824 pconstraint.plane_format[1].max_stride = 8192;
825 pconstraint.plane_format[1].min_plane_buffer_height_multiple = 16;
826 pconstraint.plane_format[1].buffer_alignment = 256;
827
828 return hfi_gen1_set_property(inst, ptype, &pconstraint, sizeof(pconstraint));
829 }
830
iris_hfi_gen1_set_num_bufs(struct iris_inst * inst,u32 plane)831 static int iris_hfi_gen1_set_num_bufs(struct iris_inst *inst, u32 plane)
832 {
833 u32 ptype = HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL;
834 struct hfi_buffer_count_actual buf_count;
835 int ret;
836
837 buf_count.type = HFI_BUFFER_INPUT;
838 buf_count.count_actual = VIDEO_MAX_FRAME;
839 buf_count.count_min_host = VIDEO_MAX_FRAME;
840
841 ret = hfi_gen1_set_property(inst, ptype, &buf_count, sizeof(buf_count));
842 if (ret)
843 return ret;
844
845 if (inst->domain == DECODER) {
846 if (iris_split_mode_enabled(inst)) {
847 buf_count.type = HFI_BUFFER_OUTPUT;
848 buf_count.count_actual = VIDEO_MAX_FRAME;
849 buf_count.count_min_host = VIDEO_MAX_FRAME;
850
851 ret = hfi_gen1_set_property(inst, ptype, &buf_count, sizeof(buf_count));
852 if (ret)
853 return ret;
854
855 buf_count.type = HFI_BUFFER_OUTPUT2;
856 buf_count.count_actual = iris_vpu_buf_count(inst, BUF_DPB);
857 buf_count.count_min_host = iris_vpu_buf_count(inst, BUF_DPB);
858
859 ret = hfi_gen1_set_property(inst, ptype, &buf_count, sizeof(buf_count));
860 } else {
861 buf_count.type = HFI_BUFFER_OUTPUT;
862 buf_count.count_actual = VIDEO_MAX_FRAME;
863 buf_count.count_min_host = VIDEO_MAX_FRAME;
864
865 ret = hfi_gen1_set_property(inst, ptype, &buf_count, sizeof(buf_count));
866 }
867 } else {
868 buf_count.type = HFI_BUFFER_OUTPUT;
869 buf_count.count_actual = VIDEO_MAX_FRAME;
870 buf_count.count_min_host = VIDEO_MAX_FRAME;
871
872 ret = hfi_gen1_set_property(inst, ptype, &buf_count, sizeof(buf_count));
873 }
874
875 return ret;
876 }
877
iris_hfi_gen1_set_multistream(struct iris_inst * inst,u32 plane)878 static int iris_hfi_gen1_set_multistream(struct iris_inst *inst, u32 plane)
879 {
880 u32 ptype = HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM;
881 struct hfi_multi_stream multi = {0};
882 int ret;
883
884 if (iris_split_mode_enabled(inst)) {
885 multi.buffer_type = HFI_BUFFER_OUTPUT;
886 multi.enable = 0;
887
888 ret = hfi_gen1_set_property(inst, ptype, &multi, sizeof(multi));
889 if (ret)
890 return ret;
891
892 multi.buffer_type = HFI_BUFFER_OUTPUT2;
893 multi.enable = 1;
894
895 ret = hfi_gen1_set_property(inst, ptype, &multi, sizeof(multi));
896 } else {
897 multi.buffer_type = HFI_BUFFER_OUTPUT;
898 multi.enable = 1;
899
900 ret = hfi_gen1_set_property(inst, ptype, &multi, sizeof(multi));
901 if (ret)
902 return ret;
903
904 multi.buffer_type = HFI_BUFFER_OUTPUT2;
905 multi.enable = 0;
906
907 ret = hfi_gen1_set_property(inst, ptype, &multi, sizeof(multi));
908 }
909
910 return ret;
911 }
912
iris_hfi_gen1_set_bufsize(struct iris_inst * inst,u32 plane)913 static int iris_hfi_gen1_set_bufsize(struct iris_inst *inst, u32 plane)
914 {
915 const u32 ptype = HFI_PROPERTY_PARAM_BUFFER_SIZE_ACTUAL;
916 struct hfi_buffer_size_actual bufsz;
917 int ret;
918
919 if (iris_split_mode_enabled(inst)) {
920 bufsz.type = HFI_BUFFER_OUTPUT;
921 bufsz.size = inst->core->iris_platform_data->get_vpu_buffer_size(inst, BUF_DPB);
922
923 ret = hfi_gen1_set_property(inst, ptype, &bufsz, sizeof(bufsz));
924 if (ret)
925 return ret;
926
927 bufsz.type = HFI_BUFFER_OUTPUT2;
928 bufsz.size = inst->buffers[BUF_OUTPUT].size;
929
930 ret = hfi_gen1_set_property(inst, ptype, &bufsz, sizeof(bufsz));
931 } else {
932 bufsz.type = HFI_BUFFER_OUTPUT;
933 bufsz.size = inst->buffers[BUF_OUTPUT].size;
934
935 ret = hfi_gen1_set_property(inst, ptype, &bufsz, sizeof(bufsz));
936 if (ret)
937 return ret;
938
939 bufsz.type = HFI_BUFFER_OUTPUT2;
940 bufsz.size = 0;
941
942 ret = hfi_gen1_set_property(inst, ptype, &bufsz, sizeof(bufsz));
943 }
944
945 return ret;
946 }
947
iris_hfi_gen1_set_frame_rate(struct iris_inst * inst,u32 plane)948 static int iris_hfi_gen1_set_frame_rate(struct iris_inst *inst, u32 plane)
949 {
950 const u32 ptype = HFI_PROPERTY_CONFIG_FRAME_RATE;
951 struct hfi_framerate frate;
952
953 if (V4L2_TYPE_IS_OUTPUT(plane))
954 return 0;
955
956 frate.buffer_type = HFI_BUFFER_OUTPUT;
957 frate.framerate = inst->frame_rate << 16;
958
959 return hfi_gen1_set_property(inst, ptype, &frate, sizeof(frate));
960 }
961
iris_hfi_gen1_set_stride(struct iris_inst * inst,u32 plane)962 static int iris_hfi_gen1_set_stride(struct iris_inst *inst, u32 plane)
963 {
964 const u32 ptype = HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_INFO;
965 struct hfi_uncompressed_plane_actual_info plane_actual_info;
966
967 plane_actual_info.buffer_type = HFI_BUFFER_INPUT;
968 plane_actual_info.num_planes = 2;
969 plane_actual_info.plane_format[0].actual_stride =
970 ALIGN(inst->fmt_src->fmt.pix_mp.width, 128);
971 plane_actual_info.plane_format[0].actual_plane_buffer_height =
972 ALIGN(inst->fmt_src->fmt.pix_mp.height, 32);
973 plane_actual_info.plane_format[1].actual_stride =
974 ALIGN(inst->fmt_src->fmt.pix_mp.width, 128);
975 plane_actual_info.plane_format[1].actual_plane_buffer_height =
976 (ALIGN(inst->fmt_src->fmt.pix_mp.height, 32)) / 2;
977
978 return hfi_gen1_set_property(inst, ptype, &plane_actual_info, sizeof(plane_actual_info));
979 }
980
iris_hfi_gen1_session_set_config_params(struct iris_inst * inst,u32 plane)981 static int iris_hfi_gen1_session_set_config_params(struct iris_inst *inst, u32 plane)
982 {
983 struct iris_hfi_prop_type_handle const *handler = NULL;
984 u32 handler_size = 0;
985 struct iris_core *core = inst->core;
986 u32 config_params_size, i, j;
987 const u32 *config_params;
988 int ret;
989
990 static const struct iris_hfi_prop_type_handle vdec_prop_type_handle_inp_arr[] = {
991 {HFI_PROPERTY_PARAM_FRAME_SIZE,
992 iris_hfi_gen1_set_resolution},
993 {HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE,
994 iris_hfi_gen1_decide_core},
995 {HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT,
996 iris_hfi_gen1_set_raw_format},
997 {HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO,
998 iris_hfi_gen1_set_format_constraints},
999 {HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL,
1000 iris_hfi_gen1_set_num_bufs},
1001 {HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM,
1002 iris_hfi_gen1_set_multistream},
1003 {HFI_PROPERTY_PARAM_BUFFER_SIZE_ACTUAL,
1004 iris_hfi_gen1_set_bufsize},
1005 };
1006
1007 static const struct iris_hfi_prop_type_handle vdec_prop_type_handle_out_arr[] = {
1008 {HFI_PROPERTY_PARAM_FRAME_SIZE,
1009 iris_hfi_gen1_set_resolution},
1010 {HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT,
1011 iris_hfi_gen1_set_raw_format},
1012 {HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO,
1013 iris_hfi_gen1_set_format_constraints},
1014 {HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL,
1015 iris_hfi_gen1_set_num_bufs},
1016 {HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM,
1017 iris_hfi_gen1_set_multistream},
1018 {HFI_PROPERTY_PARAM_BUFFER_SIZE_ACTUAL,
1019 iris_hfi_gen1_set_bufsize},
1020 };
1021
1022 static const struct iris_hfi_prop_type_handle venc_prop_type_handle_inp_arr[] = {
1023 {HFI_PROPERTY_CONFIG_FRAME_RATE,
1024 iris_hfi_gen1_set_frame_rate},
1025 {HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_INFO,
1026 iris_hfi_gen1_set_stride},
1027 {HFI_PROPERTY_PARAM_FRAME_SIZE,
1028 iris_hfi_gen1_set_resolution},
1029 {HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT,
1030 iris_hfi_gen1_set_raw_format},
1031 {HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL,
1032 iris_hfi_gen1_set_num_bufs},
1033 };
1034
1035 if (inst->domain == DECODER) {
1036 config_params = core->iris_platform_data->dec_input_config_params_default;
1037 config_params_size = core->iris_platform_data->dec_input_config_params_default_size;
1038 if (V4L2_TYPE_IS_OUTPUT(plane)) {
1039 handler = vdec_prop_type_handle_inp_arr;
1040 handler_size = ARRAY_SIZE(vdec_prop_type_handle_inp_arr);
1041 } else if (V4L2_TYPE_IS_CAPTURE(plane)) {
1042 handler = vdec_prop_type_handle_out_arr;
1043 handler_size = ARRAY_SIZE(vdec_prop_type_handle_out_arr);
1044 }
1045 } else {
1046 config_params = core->iris_platform_data->enc_input_config_params;
1047 config_params_size = core->iris_platform_data->enc_input_config_params_size;
1048 handler = venc_prop_type_handle_inp_arr;
1049 handler_size = ARRAY_SIZE(venc_prop_type_handle_inp_arr);
1050 }
1051
1052 for (i = 0; i < config_params_size; i++) {
1053 for (j = 0; j < handler_size; j++) {
1054 if (handler[j].type == config_params[i]) {
1055 ret = handler[j].handle(inst, plane);
1056 if (ret)
1057 return ret;
1058 break;
1059 }
1060 }
1061 }
1062
1063 return 0;
1064 }
1065
1066 static const struct iris_hfi_command_ops iris_hfi_gen1_command_ops = {
1067 .sys_init = iris_hfi_gen1_sys_init,
1068 .sys_image_version = iris_hfi_gen1_sys_image_version,
1069 .sys_interframe_powercollapse = iris_hfi_gen1_sys_interframe_powercollapse,
1070 .sys_pc_prep = iris_hfi_gen1_sys_pc_prep,
1071 .session_open = iris_hfi_gen1_session_open,
1072 .session_set_config_params = iris_hfi_gen1_session_set_config_params,
1073 .session_set_property = iris_hfi_gen1_session_set_property,
1074 .session_start = iris_hfi_gen1_session_start,
1075 .session_queue_buf = iris_hfi_gen1_session_queue_buffer,
1076 .session_release_buf = iris_hfi_gen1_session_unset_buffers,
1077 .session_resume_drc = iris_hfi_gen1_session_continue,
1078 .session_stop = iris_hfi_gen1_session_stop,
1079 .session_drain = iris_hfi_gen1_session_drain,
1080 .session_close = iris_hfi_gen1_session_close,
1081 };
1082
iris_hfi_gen1_command_ops_init(struct iris_core * core)1083 void iris_hfi_gen1_command_ops_init(struct iris_core *core)
1084 {
1085 core->hfi_ops = &iris_hfi_gen1_command_ops;
1086 }
1087
iris_hfi_gen1_get_instance(void)1088 struct iris_inst *iris_hfi_gen1_get_instance(void)
1089 {
1090 return kzalloc_obj(struct iris_inst);
1091 }
1092