1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
4 * Copyright (C) 2017 Linaro Ltd.
5 */
6 #include <linux/overflow.h>
7 #include <linux/errno.h>
8 #include <linux/hash.h>
9
10 #include "hfi_cmds.h"
11
12 static enum hfi_version hfi_ver;
13
pkt_sys_init(struct hfi_sys_init_pkt * pkt,u32 arch_type)14 void pkt_sys_init(struct hfi_sys_init_pkt *pkt, u32 arch_type)
15 {
16 pkt->hdr.size = sizeof(*pkt);
17 pkt->hdr.pkt_type = HFI_CMD_SYS_INIT;
18 pkt->arch_type = arch_type;
19 }
20
pkt_sys_pc_prep(struct hfi_sys_pc_prep_pkt * pkt)21 void pkt_sys_pc_prep(struct hfi_sys_pc_prep_pkt *pkt)
22 {
23 pkt->hdr.size = sizeof(*pkt);
24 pkt->hdr.pkt_type = HFI_CMD_SYS_PC_PREP;
25 }
26
pkt_sys_idle_indicator(struct hfi_sys_set_property_pkt * pkt,u32 enable)27 void pkt_sys_idle_indicator(struct hfi_sys_set_property_pkt *pkt, u32 enable)
28 {
29 struct hfi_enable *hfi = (struct hfi_enable *)&pkt->data[1];
30
31 pkt->hdr.size = struct_size(pkt, data, 1) + sizeof(*hfi);
32 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_PROPERTY;
33 pkt->num_properties = 1;
34 pkt->data[0] = HFI_PROPERTY_SYS_IDLE_INDICATOR;
35 hfi->enable = enable;
36 }
37
pkt_sys_debug_config(struct hfi_sys_set_property_pkt * pkt,u32 mode,u32 config)38 void pkt_sys_debug_config(struct hfi_sys_set_property_pkt *pkt, u32 mode,
39 u32 config)
40 {
41 struct hfi_debug_config *hfi;
42
43 pkt->hdr.size = struct_size(pkt, data, 1) + sizeof(*hfi);
44 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_PROPERTY;
45 pkt->num_properties = 1;
46 pkt->data[0] = HFI_PROPERTY_SYS_DEBUG_CONFIG;
47 hfi = (struct hfi_debug_config *)&pkt->data[1];
48 hfi->config = config;
49 hfi->mode = mode;
50 }
51
pkt_sys_coverage_config(struct hfi_sys_set_property_pkt * pkt,u32 mode)52 void pkt_sys_coverage_config(struct hfi_sys_set_property_pkt *pkt, u32 mode)
53 {
54 pkt->hdr.size = struct_size(pkt, data, 2);
55 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_PROPERTY;
56 pkt->num_properties = 1;
57 pkt->data[0] = HFI_PROPERTY_SYS_CONFIG_COVERAGE;
58 pkt->data[1] = mode;
59 }
60
pkt_sys_set_resource(struct hfi_sys_set_resource_pkt * pkt,u32 id,u32 size,u32 addr,void * cookie)61 int pkt_sys_set_resource(struct hfi_sys_set_resource_pkt *pkt, u32 id, u32 size,
62 u32 addr, void *cookie)
63 {
64 pkt->hdr.size = sizeof(*pkt);
65 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_RESOURCE;
66 pkt->resource_handle = hash32_ptr(cookie);
67
68 switch (id) {
69 case VIDC_RESOURCE_OCMEM:
70 case VIDC_RESOURCE_VMEM: {
71 struct hfi_resource_ocmem *res =
72 (struct hfi_resource_ocmem *)&pkt->resource_data[0];
73
74 res->size = size;
75 res->mem = addr;
76 pkt->resource_type = HFI_RESOURCE_OCMEM;
77 pkt->hdr.size += sizeof(*res) - sizeof(u32);
78 break;
79 }
80 case VIDC_RESOURCE_NONE:
81 default:
82 return -ENOTSUPP;
83 }
84
85 return 0;
86 }
87
pkt_sys_unset_resource(struct hfi_sys_release_resource_pkt * pkt,u32 id,u32 size,void * cookie)88 int pkt_sys_unset_resource(struct hfi_sys_release_resource_pkt *pkt, u32 id,
89 u32 size, void *cookie)
90 {
91 pkt->hdr.size = sizeof(*pkt);
92 pkt->hdr.pkt_type = HFI_CMD_SYS_RELEASE_RESOURCE;
93 pkt->resource_handle = hash32_ptr(cookie);
94
95 switch (id) {
96 case VIDC_RESOURCE_OCMEM:
97 case VIDC_RESOURCE_VMEM:
98 pkt->resource_type = HFI_RESOURCE_OCMEM;
99 break;
100 case VIDC_RESOURCE_NONE:
101 break;
102 default:
103 return -ENOTSUPP;
104 }
105
106 return 0;
107 }
108
pkt_sys_ping(struct hfi_sys_ping_pkt * pkt,u32 cookie)109 void pkt_sys_ping(struct hfi_sys_ping_pkt *pkt, u32 cookie)
110 {
111 pkt->hdr.size = sizeof(*pkt);
112 pkt->hdr.pkt_type = HFI_CMD_SYS_PING;
113 pkt->client_data = cookie;
114 }
115
pkt_sys_power_control(struct hfi_sys_set_property_pkt * pkt,u32 enable)116 void pkt_sys_power_control(struct hfi_sys_set_property_pkt *pkt, u32 enable)
117 {
118 struct hfi_enable *hfi = (struct hfi_enable *)&pkt->data[1];
119
120 pkt->hdr.size = struct_size(pkt, data, 1) + sizeof(*hfi);
121 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_PROPERTY;
122 pkt->num_properties = 1;
123 pkt->data[0] = HFI_PROPERTY_SYS_CODEC_POWER_PLANE_CTRL;
124 hfi->enable = enable;
125 }
126
pkt_sys_ssr_cmd(struct hfi_sys_test_ssr_pkt * pkt,u32 trigger_type)127 int pkt_sys_ssr_cmd(struct hfi_sys_test_ssr_pkt *pkt, u32 trigger_type)
128 {
129 switch (trigger_type) {
130 case HFI_TEST_SSR_SW_ERR_FATAL:
131 case HFI_TEST_SSR_SW_DIV_BY_ZERO:
132 case HFI_TEST_SSR_HW_WDOG_IRQ:
133 break;
134 default:
135 return -EINVAL;
136 }
137
138 pkt->hdr.size = sizeof(*pkt);
139 pkt->hdr.pkt_type = HFI_CMD_SYS_TEST_SSR;
140 pkt->trigger_type = trigger_type;
141
142 return 0;
143 }
144
pkt_sys_image_version(struct hfi_sys_get_property_pkt * pkt)145 void pkt_sys_image_version(struct hfi_sys_get_property_pkt *pkt)
146 {
147 pkt->hdr.size = sizeof(*pkt);
148 pkt->hdr.pkt_type = HFI_CMD_SYS_GET_PROPERTY;
149 pkt->num_properties = 1;
150 pkt->data[0] = HFI_PROPERTY_SYS_IMAGE_VERSION;
151 }
152
pkt_session_init(struct hfi_session_init_pkt * pkt,void * cookie,u32 session_type,u32 codec)153 int pkt_session_init(struct hfi_session_init_pkt *pkt, void *cookie,
154 u32 session_type, u32 codec)
155 {
156 if (!pkt || !cookie || !codec)
157 return -EINVAL;
158
159 pkt->shdr.hdr.size = sizeof(*pkt);
160 pkt->shdr.hdr.pkt_type = HFI_CMD_SYS_SESSION_INIT;
161 pkt->shdr.session_id = hash32_ptr(cookie);
162 pkt->session_domain = session_type;
163 pkt->session_codec = codec;
164
165 return 0;
166 }
167
pkt_session_cmd(struct hfi_session_pkt * pkt,u32 pkt_type,void * cookie)168 void pkt_session_cmd(struct hfi_session_pkt *pkt, u32 pkt_type, void *cookie)
169 {
170 pkt->shdr.hdr.size = sizeof(*pkt);
171 pkt->shdr.hdr.pkt_type = pkt_type;
172 pkt->shdr.session_id = hash32_ptr(cookie);
173 }
174
pkt_session_set_buffers(struct hfi_session_set_buffers_pkt * pkt,void * cookie,struct hfi_buffer_desc * bd)175 int pkt_session_set_buffers(struct hfi_session_set_buffers_pkt *pkt,
176 void *cookie, struct hfi_buffer_desc *bd)
177 {
178 unsigned int i;
179
180 if (!cookie || !pkt || !bd)
181 return -EINVAL;
182
183 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_BUFFERS;
184 pkt->shdr.session_id = hash32_ptr(cookie);
185 pkt->buffer_size = bd->buffer_size;
186 pkt->min_buffer_size = bd->buffer_size;
187 pkt->num_buffers = bd->num_buffers;
188
189 if (bd->buffer_type == HFI_BUFFER_OUTPUT ||
190 bd->buffer_type == HFI_BUFFER_OUTPUT2) {
191 struct hfi_buffer_info *bi;
192
193 pkt->extradata_size = bd->extradata_size;
194 pkt->shdr.hdr.size = sizeof(*pkt) - sizeof(u32) +
195 (bd->num_buffers * sizeof(*bi));
196 bi = (struct hfi_buffer_info *)pkt->buffer_info;
197 for (i = 0; i < pkt->num_buffers; i++) {
198 bi->buffer_addr = bd->device_addr;
199 bi->extradata_addr = bd->extradata_addr;
200 }
201 } else {
202 pkt->extradata_size = 0;
203 pkt->shdr.hdr.size = sizeof(*pkt) +
204 ((bd->num_buffers - 1) * sizeof(u32));
205 for (i = 0; i < pkt->num_buffers; i++)
206 pkt->buffer_info[i] = bd->device_addr;
207 }
208
209 pkt->buffer_type = bd->buffer_type;
210
211 return 0;
212 }
213
pkt_session_unset_buffers(struct hfi_session_release_buffer_pkt * pkt,void * cookie,struct hfi_buffer_desc * bd)214 int pkt_session_unset_buffers(struct hfi_session_release_buffer_pkt *pkt,
215 void *cookie, struct hfi_buffer_desc *bd)
216 {
217 unsigned int i;
218
219 if (!cookie || !pkt || !bd)
220 return -EINVAL;
221
222 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_RELEASE_BUFFERS;
223 pkt->shdr.session_id = hash32_ptr(cookie);
224 pkt->buffer_size = bd->buffer_size;
225 pkt->num_buffers = bd->num_buffers;
226
227 if (bd->buffer_type == HFI_BUFFER_OUTPUT ||
228 bd->buffer_type == HFI_BUFFER_OUTPUT2) {
229 struct hfi_buffer_info *bi;
230
231 bi = (struct hfi_buffer_info *)pkt->buffer_info;
232 for (i = 0; i < pkt->num_buffers; i++) {
233 bi->buffer_addr = bd->device_addr;
234 bi->extradata_addr = bd->extradata_addr;
235 }
236 pkt->shdr.hdr.size =
237 sizeof(struct hfi_session_set_buffers_pkt) -
238 sizeof(u32) + (bd->num_buffers * sizeof(*bi));
239 } else {
240 for (i = 0; i < pkt->num_buffers; i++)
241 pkt->buffer_info[i] = bd->device_addr;
242
243 pkt->extradata_size = 0;
244 pkt->shdr.hdr.size =
245 sizeof(struct hfi_session_set_buffers_pkt) +
246 ((bd->num_buffers - 1) * sizeof(u32));
247 }
248
249 pkt->response_req = bd->response_required;
250 pkt->buffer_type = bd->buffer_type;
251
252 return 0;
253 }
254
pkt_session_etb_decoder(struct hfi_session_empty_buffer_compressed_pkt * pkt,void * cookie,struct hfi_frame_data * in_frame)255 int pkt_session_etb_decoder(struct hfi_session_empty_buffer_compressed_pkt *pkt,
256 void *cookie, struct hfi_frame_data *in_frame)
257 {
258 if (!cookie)
259 return -EINVAL;
260
261 pkt->shdr.hdr.size = sizeof(*pkt);
262 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
263 pkt->shdr.session_id = hash32_ptr(cookie);
264 pkt->time_stamp_hi = upper_32_bits(in_frame->timestamp);
265 pkt->time_stamp_lo = lower_32_bits(in_frame->timestamp);
266 pkt->flags = in_frame->flags;
267 pkt->mark_target = in_frame->mark_target;
268 pkt->mark_data = in_frame->mark_data;
269 pkt->offset = in_frame->offset;
270 pkt->alloc_len = in_frame->alloc_len;
271 pkt->filled_len = in_frame->filled_len;
272 pkt->input_tag = in_frame->clnt_data;
273 pkt->packet_buffer = in_frame->device_addr;
274
275 return 0;
276 }
277
pkt_session_etb_encoder(struct hfi_session_empty_buffer_uncompressed_plane0_pkt * pkt,void * cookie,struct hfi_frame_data * in_frame)278 int pkt_session_etb_encoder(
279 struct hfi_session_empty_buffer_uncompressed_plane0_pkt *pkt,
280 void *cookie, struct hfi_frame_data *in_frame)
281 {
282 if (!cookie || !in_frame->device_addr)
283 return -EINVAL;
284
285 pkt->shdr.hdr.size = sizeof(*pkt);
286 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;
287 pkt->shdr.session_id = hash32_ptr(cookie);
288 pkt->view_id = 0;
289 pkt->time_stamp_hi = upper_32_bits(in_frame->timestamp);
290 pkt->time_stamp_lo = lower_32_bits(in_frame->timestamp);
291 pkt->flags = in_frame->flags;
292 pkt->mark_target = in_frame->mark_target;
293 pkt->mark_data = in_frame->mark_data;
294 pkt->offset = in_frame->offset;
295 pkt->alloc_len = in_frame->alloc_len;
296 pkt->filled_len = in_frame->filled_len;
297 pkt->input_tag = in_frame->clnt_data;
298 pkt->packet_buffer = in_frame->device_addr;
299 pkt->extradata_buffer = in_frame->extradata_addr;
300
301 return 0;
302 }
303
pkt_session_ftb(struct hfi_session_fill_buffer_pkt * pkt,void * cookie,struct hfi_frame_data * out_frame)304 int pkt_session_ftb(struct hfi_session_fill_buffer_pkt *pkt, void *cookie,
305 struct hfi_frame_data *out_frame)
306 {
307 if (!cookie || !out_frame || !out_frame->device_addr)
308 return -EINVAL;
309
310 pkt->shdr.hdr.size = sizeof(*pkt);
311 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_FILL_BUFFER;
312 pkt->shdr.session_id = hash32_ptr(cookie);
313
314 if (out_frame->buffer_type == HFI_BUFFER_OUTPUT)
315 pkt->stream_id = 0;
316 else if (out_frame->buffer_type == HFI_BUFFER_OUTPUT2)
317 pkt->stream_id = 1;
318
319 pkt->output_tag = out_frame->clnt_data;
320 pkt->packet_buffer = out_frame->device_addr;
321 pkt->extradata_buffer = out_frame->extradata_addr;
322 pkt->alloc_len = out_frame->alloc_len;
323 pkt->filled_len = out_frame->filled_len;
324 pkt->offset = out_frame->offset;
325 pkt->data[0] = out_frame->extradata_size;
326
327 return 0;
328 }
329
pkt_session_parse_seq_header(struct hfi_session_parse_sequence_header_pkt * pkt,void * cookie,u32 seq_hdr,u32 seq_hdr_len)330 int pkt_session_parse_seq_header(
331 struct hfi_session_parse_sequence_header_pkt *pkt,
332 void *cookie, u32 seq_hdr, u32 seq_hdr_len)
333 {
334 if (!cookie || !seq_hdr || !seq_hdr_len)
335 return -EINVAL;
336
337 pkt->shdr.hdr.size = sizeof(*pkt);
338 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_PARSE_SEQUENCE_HEADER;
339 pkt->shdr.session_id = hash32_ptr(cookie);
340 pkt->header_len = seq_hdr_len;
341 pkt->packet_buffer = seq_hdr;
342
343 return 0;
344 }
345
pkt_session_get_seq_hdr(struct hfi_session_get_sequence_header_pkt * pkt,void * cookie,u32 seq_hdr,u32 seq_hdr_len)346 int pkt_session_get_seq_hdr(struct hfi_session_get_sequence_header_pkt *pkt,
347 void *cookie, u32 seq_hdr, u32 seq_hdr_len)
348 {
349 if (!cookie || !seq_hdr || !seq_hdr_len)
350 return -EINVAL;
351
352 pkt->shdr.hdr.size = sizeof(*pkt);
353 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_GET_SEQUENCE_HEADER;
354 pkt->shdr.session_id = hash32_ptr(cookie);
355 pkt->buffer_len = seq_hdr_len;
356 pkt->packet_buffer = seq_hdr;
357
358 return 0;
359 }
360
pkt_session_flush(struct hfi_session_flush_pkt * pkt,void * cookie,u32 type)361 int pkt_session_flush(struct hfi_session_flush_pkt *pkt, void *cookie, u32 type)
362 {
363 switch (type) {
364 case HFI_FLUSH_INPUT:
365 case HFI_FLUSH_OUTPUT:
366 case HFI_FLUSH_OUTPUT2:
367 case HFI_FLUSH_ALL:
368 break;
369 default:
370 return -EINVAL;
371 }
372
373 pkt->shdr.hdr.size = sizeof(*pkt);
374 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_FLUSH;
375 pkt->shdr.session_id = hash32_ptr(cookie);
376 pkt->flush_type = type;
377
378 return 0;
379 }
380
pkt_session_get_property_1x(struct hfi_session_get_property_pkt * pkt,void * cookie,u32 ptype)381 static int pkt_session_get_property_1x(struct hfi_session_get_property_pkt *pkt,
382 void *cookie, u32 ptype)
383 {
384 switch (ptype) {
385 case HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT:
386 case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:
387 break;
388 default:
389 return -EINVAL;
390 }
391
392 pkt->shdr.hdr.size = sizeof(*pkt);
393 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_GET_PROPERTY;
394 pkt->shdr.session_id = hash32_ptr(cookie);
395 pkt->num_properties = 1;
396 pkt->data[0] = ptype;
397
398 return 0;
399 }
400
pkt_session_set_property_1x(struct hfi_session_set_property_pkt * pkt,void * cookie,u32 ptype,void * pdata)401 static int pkt_session_set_property_1x(struct hfi_session_set_property_pkt *pkt,
402 void *cookie, u32 ptype, void *pdata)
403 {
404 void *prop_data;
405 int ret = 0;
406
407 if (!pkt || !cookie || !pdata)
408 return -EINVAL;
409
410 prop_data = &pkt->data[1];
411
412 pkt->shdr.hdr.size = sizeof(*pkt);
413 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
414 pkt->shdr.session_id = hash32_ptr(cookie);
415 pkt->num_properties = 1;
416 pkt->data[0] = ptype;
417
418 switch (ptype) {
419 case HFI_PROPERTY_CONFIG_FRAME_RATE: {
420 struct hfi_framerate *in = pdata, *frate = prop_data;
421
422 frate->buffer_type = in->buffer_type;
423 frate->framerate = in->framerate;
424 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*frate);
425 break;
426 }
427 case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT: {
428 struct hfi_uncompressed_format_select *in = pdata;
429 struct hfi_uncompressed_format_select *hfi = prop_data;
430
431 hfi->buffer_type = in->buffer_type;
432 hfi->format = in->format;
433 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hfi);
434 break;
435 }
436 case HFI_PROPERTY_PARAM_FRAME_SIZE: {
437 struct hfi_framesize *in = pdata, *fsize = prop_data;
438
439 fsize->buffer_type = in->buffer_type;
440 fsize->height = in->height;
441 fsize->width = in->width;
442 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*fsize);
443 break;
444 }
445 case HFI_PROPERTY_CONFIG_REALTIME: {
446 struct hfi_enable *in = pdata, *en = prop_data;
447
448 en->enable = in->enable;
449 pkt->shdr.hdr.size += sizeof(u32) * 2;
450 break;
451 }
452 case HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL: {
453 struct hfi_buffer_count_actual *in = pdata, *count = prop_data;
454
455 count->count_actual = in->count_actual;
456 count->type = in->type;
457 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);
458 break;
459 }
460 case HFI_PROPERTY_PARAM_BUFFER_SIZE_ACTUAL: {
461 struct hfi_buffer_size_actual *in = pdata, *sz = prop_data;
462
463 sz->size = in->size;
464 sz->type = in->type;
465 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*sz);
466 break;
467 }
468 case HFI_PROPERTY_PARAM_BUFFER_DISPLAY_HOLD_COUNT_ACTUAL: {
469 struct hfi_buffer_display_hold_count_actual *in = pdata;
470 struct hfi_buffer_display_hold_count_actual *count = prop_data;
471
472 count->hold_count = in->hold_count;
473 count->type = in->type;
474 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);
475 break;
476 }
477 case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SELECT: {
478 struct hfi_nal_stream_format_select *in = pdata;
479 struct hfi_nal_stream_format_select *fmt = prop_data;
480
481 fmt->format = in->format;
482 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*fmt);
483 break;
484 }
485 case HFI_PROPERTY_PARAM_VDEC_OUTPUT_ORDER: {
486 u32 *in = pdata;
487
488 switch (*in) {
489 case HFI_OUTPUT_ORDER_DECODE:
490 case HFI_OUTPUT_ORDER_DISPLAY:
491 break;
492 default:
493 ret = -EINVAL;
494 break;
495 }
496
497 pkt->data[1] = *in;
498 pkt->shdr.hdr.size += sizeof(u32) * 2;
499 break;
500 }
501 case HFI_PROPERTY_PARAM_VDEC_PICTURE_TYPE_DECODE: {
502 struct hfi_enable_picture *in = pdata, *en = prop_data;
503
504 en->picture_type = in->picture_type;
505 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
506 break;
507 }
508 case HFI_PROPERTY_PARAM_VDEC_OUTPUT2_KEEP_ASPECT_RATIO: {
509 struct hfi_enable *in = pdata, *en = prop_data;
510
511 en->enable = in->enable;
512 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
513 break;
514 }
515 case HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER: {
516 struct hfi_enable *in = pdata;
517 struct hfi_enable *en = prop_data;
518
519 en->enable = in->enable;
520 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
521 break;
522 }
523 case HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM: {
524 struct hfi_multi_stream *in = pdata, *multi = prop_data;
525
526 multi->buffer_type = in->buffer_type;
527 multi->enable = in->enable;
528 multi->width = in->width;
529 multi->height = in->height;
530 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
531 break;
532 }
533 case HFI_PROPERTY_PARAM_VDEC_DISPLAY_PICTURE_BUFFER_COUNT: {
534 struct hfi_display_picture_buffer_count *in = pdata;
535 struct hfi_display_picture_buffer_count *count = prop_data;
536
537 count->count = in->count;
538 count->enable = in->enable;
539 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);
540 break;
541 }
542 case HFI_PROPERTY_PARAM_DIVX_FORMAT: {
543 u32 *in = pdata;
544
545 switch (*in) {
546 case HFI_DIVX_FORMAT_4:
547 case HFI_DIVX_FORMAT_5:
548 case HFI_DIVX_FORMAT_6:
549 break;
550 default:
551 ret = -EINVAL;
552 break;
553 }
554
555 pkt->data[1] = *in;
556 pkt->shdr.hdr.size += sizeof(u32) * 2;
557 break;
558 }
559 case HFI_PROPERTY_CONFIG_VDEC_MB_ERROR_MAP_REPORTING: {
560 struct hfi_enable *in = pdata, *en = prop_data;
561
562 en->enable = in->enable;
563 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
564 break;
565 }
566 case HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER: {
567 struct hfi_enable *in = pdata, *en = prop_data;
568
569 en->enable = in->enable;
570 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
571 break;
572 }
573 case HFI_PROPERTY_PARAM_VDEC_THUMBNAIL_MODE: {
574 struct hfi_enable *in = pdata, *en = prop_data;
575
576 en->enable = in->enable;
577 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
578 break;
579 }
580 case HFI_PROPERTY_CONFIG_VENC_SYNC_FRAME_SEQUENCE_HEADER: {
581 struct hfi_enable *in = pdata, *en = prop_data;
582
583 en->enable = in->enable;
584 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
585 break;
586 }
587 case HFI_PROPERTY_CONFIG_VENC_REQUEST_SYNC_FRAME:
588 pkt->shdr.hdr.size += sizeof(u32);
589 break;
590 case HFI_PROPERTY_PARAM_VENC_MPEG4_SHORT_HEADER:
591 break;
592 case HFI_PROPERTY_PARAM_VENC_MPEG4_AC_PREDICTION:
593 break;
594 case HFI_PROPERTY_CONFIG_VENC_TARGET_BITRATE: {
595 struct hfi_bitrate *in = pdata, *brate = prop_data;
596
597 brate->bitrate = in->bitrate;
598 brate->layer_id = in->layer_id;
599 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*brate);
600 break;
601 }
602 case HFI_PROPERTY_CONFIG_VENC_MAX_BITRATE: {
603 struct hfi_bitrate *in = pdata, *hfi = prop_data;
604
605 hfi->bitrate = in->bitrate;
606 hfi->layer_id = in->layer_id;
607 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hfi);
608 break;
609 }
610 case HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT: {
611 struct hfi_profile_level *in = pdata, *pl = prop_data;
612
613 pl->level = in->level;
614 pl->profile = in->profile;
615 if (pl->profile <= 0)
616 /* Profile not supported, falling back to high */
617 pl->profile = HFI_H264_PROFILE_HIGH;
618
619 if (!pl->level)
620 /* Level not supported, falling back to 1 */
621 pl->level = 1;
622
623 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*pl);
624 break;
625 }
626 case HFI_PROPERTY_PARAM_VENC_H264_ENTROPY_CONTROL: {
627 struct hfi_h264_entropy_control *in = pdata, *hfi = prop_data;
628
629 hfi->entropy_mode = in->entropy_mode;
630 if (hfi->entropy_mode == HFI_H264_ENTROPY_CABAC)
631 hfi->cabac_model = in->cabac_model;
632 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hfi);
633 break;
634 }
635 case HFI_PROPERTY_PARAM_VENC_RATE_CONTROL: {
636 u32 *in = pdata;
637
638 switch (*in) {
639 case HFI_RATE_CONTROL_OFF:
640 case HFI_RATE_CONTROL_CBR_CFR:
641 case HFI_RATE_CONTROL_CBR_VFR:
642 case HFI_RATE_CONTROL_VBR_CFR:
643 case HFI_RATE_CONTROL_VBR_VFR:
644 case HFI_RATE_CONTROL_CQ:
645 break;
646 default:
647 ret = -EINVAL;
648 break;
649 }
650
651 pkt->data[1] = *in;
652 pkt->shdr.hdr.size += sizeof(u32) * 2;
653 break;
654 }
655 case HFI_PROPERTY_PARAM_VENC_MPEG4_TIME_RESOLUTION: {
656 struct hfi_mpeg4_time_resolution *in = pdata, *res = prop_data;
657
658 res->time_increment_resolution = in->time_increment_resolution;
659 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*res);
660 break;
661 }
662 case HFI_PROPERTY_PARAM_VENC_MPEG4_HEADER_EXTENSION: {
663 struct hfi_mpeg4_header_extension *in = pdata, *ext = prop_data;
664
665 ext->header_extension = in->header_extension;
666 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ext);
667 break;
668 }
669 case HFI_PROPERTY_PARAM_VENC_H264_DEBLOCK_CONTROL: {
670 struct hfi_h264_db_control *in = pdata, *db = prop_data;
671
672 switch (in->mode) {
673 case HFI_H264_DB_MODE_DISABLE:
674 case HFI_H264_DB_MODE_SKIP_SLICE_BOUNDARY:
675 case HFI_H264_DB_MODE_ALL_BOUNDARY:
676 break;
677 default:
678 ret = -EINVAL;
679 break;
680 }
681
682 db->mode = in->mode;
683 db->slice_alpha_offset = in->slice_alpha_offset;
684 db->slice_beta_offset = in->slice_beta_offset;
685 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*db);
686 break;
687 }
688 case HFI_PROPERTY_PARAM_VENC_SESSION_QP: {
689 struct hfi_quantization *in = pdata, *quant = prop_data;
690
691 quant->qp_i = in->qp_i;
692 quant->qp_p = in->qp_p;
693 quant->qp_b = in->qp_b;
694 quant->layer_id = in->layer_id;
695 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*quant);
696 break;
697 }
698 case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE: {
699 struct hfi_quantization_range *in = pdata, *range = prop_data;
700 u32 min_qp, max_qp;
701
702 min_qp = in->min_qp;
703 max_qp = in->max_qp;
704
705 /* We'll be packing in the qp, so make sure we
706 * won't be losing data when masking
707 */
708 if (min_qp > 0xff || max_qp > 0xff) {
709 ret = -ERANGE;
710 break;
711 }
712
713 /* When creating the packet, pack the qp value as
714 * 0xiippbb, where ii = qp range for I-frames,
715 * pp = qp range for P-frames, etc.
716 */
717 range->min_qp = min_qp | min_qp << 8 | min_qp << 16;
718 range->max_qp = max_qp | max_qp << 8 | max_qp << 16;
719 range->layer_id = in->layer_id;
720
721 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*range);
722 break;
723 }
724 case HFI_PROPERTY_PARAM_VENC_VC1_PERF_CFG: {
725 struct hfi_vc1e_perf_cfg_type *in = pdata, *perf = prop_data;
726
727 memcpy(perf->search_range_x_subsampled,
728 in->search_range_x_subsampled,
729 sizeof(perf->search_range_x_subsampled));
730 memcpy(perf->search_range_y_subsampled,
731 in->search_range_y_subsampled,
732 sizeof(perf->search_range_y_subsampled));
733
734 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*perf);
735 break;
736 }
737 case HFI_PROPERTY_PARAM_VENC_MAX_NUM_B_FRAMES: {
738 struct hfi_max_num_b_frames *bframes = prop_data;
739 u32 *in = pdata;
740
741 bframes->max_num_b_frames = *in;
742 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*bframes);
743 break;
744 }
745 case HFI_PROPERTY_CONFIG_VENC_INTRA_PERIOD: {
746 struct hfi_intra_period *in = pdata, *intra = prop_data;
747
748 intra->pframes = in->pframes;
749 intra->bframes = in->bframes;
750 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
751 break;
752 }
753 case HFI_PROPERTY_CONFIG_VENC_IDR_PERIOD: {
754 struct hfi_idr_period *in = pdata, *idr = prop_data;
755
756 idr->idr_period = in->idr_period;
757 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*idr);
758 break;
759 }
760 case HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR: {
761 struct hfi_conceal_color *color = prop_data;
762 u32 *in = pdata;
763
764 color->conceal_color = *in & 0xff;
765 color->conceal_color |= ((*in >> 10) & 0xff) << 8;
766 color->conceal_color |= ((*in >> 20) & 0xff) << 16;
767 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*color);
768 break;
769 }
770 case HFI_PROPERTY_CONFIG_VPE_OPERATIONS: {
771 struct hfi_operations_type *in = pdata, *ops = prop_data;
772
773 switch (in->rotation) {
774 case HFI_ROTATE_NONE:
775 case HFI_ROTATE_90:
776 case HFI_ROTATE_180:
777 case HFI_ROTATE_270:
778 break;
779 default:
780 ret = -EINVAL;
781 break;
782 }
783
784 switch (in->flip) {
785 case HFI_FLIP_NONE:
786 case HFI_FLIP_HORIZONTAL:
787 case HFI_FLIP_VERTICAL:
788 break;
789 default:
790 ret = -EINVAL;
791 break;
792 }
793
794 ops->rotation = in->rotation;
795 ops->flip = in->flip;
796 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ops);
797 break;
798 }
799 case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {
800 struct hfi_intra_refresh *in = pdata, *intra = prop_data;
801
802 switch (in->mode) {
803 case HFI_INTRA_REFRESH_NONE:
804 case HFI_INTRA_REFRESH_ADAPTIVE:
805 case HFI_INTRA_REFRESH_CYCLIC:
806 case HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE:
807 case HFI_INTRA_REFRESH_RANDOM:
808 break;
809 default:
810 ret = -EINVAL;
811 break;
812 }
813
814 intra->mode = in->mode;
815 intra->air_mbs = in->air_mbs;
816 intra->air_ref = in->air_ref;
817 intra->cir_mbs = in->cir_mbs;
818 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
819 break;
820 }
821 case HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_CONTROL: {
822 struct hfi_multi_slice_control *in = pdata, *multi = prop_data;
823
824 switch (in->multi_slice) {
825 case HFI_MULTI_SLICE_OFF:
826 case HFI_MULTI_SLICE_GOB:
827 case HFI_MULTI_SLICE_BY_MB_COUNT:
828 case HFI_MULTI_SLICE_BY_BYTE_COUNT:
829 break;
830 default:
831 ret = -EINVAL;
832 break;
833 }
834
835 multi->multi_slice = in->multi_slice;
836 multi->slice_size = in->slice_size;
837 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
838 break;
839 }
840 case HFI_PROPERTY_PARAM_VENC_SLICE_DELIVERY_MODE: {
841 struct hfi_enable *in = pdata, *en = prop_data;
842
843 en->enable = in->enable;
844 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
845 break;
846 }
847 case HFI_PROPERTY_PARAM_VENC_H264_VUI_TIMING_INFO: {
848 struct hfi_h264_vui_timing_info *in = pdata, *vui = prop_data;
849
850 vui->enable = in->enable;
851 vui->fixed_framerate = in->fixed_framerate;
852 vui->time_scale = in->time_scale;
853 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*vui);
854 break;
855 }
856 case HFI_PROPERTY_CONFIG_VPE_DEINTERLACE: {
857 struct hfi_enable *in = pdata, *en = prop_data;
858
859 en->enable = in->enable;
860 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
861 break;
862 }
863 case HFI_PROPERTY_PARAM_VENC_H264_GENERATE_AUDNAL: {
864 struct hfi_enable *in = pdata, *en = prop_data;
865
866 en->enable = in->enable;
867 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
868 break;
869 }
870 case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE: {
871 struct hfi_buffer_alloc_mode *in = pdata, *mode = prop_data;
872
873 mode->type = in->type;
874 mode->mode = in->mode;
875 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*mode);
876 break;
877 }
878 case HFI_PROPERTY_PARAM_VDEC_FRAME_ASSEMBLY: {
879 struct hfi_enable *in = pdata, *en = prop_data;
880
881 en->enable = in->enable;
882 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
883 break;
884 }
885 case HFI_PROPERTY_PARAM_VENC_H264_VUI_BITSTREAM_RESTRC: {
886 struct hfi_enable *in = pdata, *en = prop_data;
887
888 en->enable = in->enable;
889 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
890 break;
891 }
892 case HFI_PROPERTY_PARAM_VENC_PRESERVE_TEXT_QUALITY: {
893 struct hfi_enable *in = pdata, *en = prop_data;
894
895 en->enable = in->enable;
896 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
897 break;
898 }
899 case HFI_PROPERTY_PARAM_VDEC_SCS_THRESHOLD: {
900 struct hfi_scs_threshold *thres = prop_data;
901 u32 *in = pdata;
902
903 thres->threshold_value = *in;
904 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*thres);
905 break;
906 }
907 case HFI_PROPERTY_PARAM_MVC_BUFFER_LAYOUT: {
908 struct hfi_mvc_buffer_layout_descp_type *in = pdata;
909 struct hfi_mvc_buffer_layout_descp_type *mvc = prop_data;
910
911 switch (in->layout_type) {
912 case HFI_MVC_BUFFER_LAYOUT_TOP_BOTTOM:
913 case HFI_MVC_BUFFER_LAYOUT_SEQ:
914 break;
915 default:
916 ret = -EINVAL;
917 break;
918 }
919
920 mvc->layout_type = in->layout_type;
921 mvc->bright_view_first = in->bright_view_first;
922 mvc->ngap = in->ngap;
923 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*mvc);
924 break;
925 }
926 case HFI_PROPERTY_PARAM_VENC_LTRMODE: {
927 struct hfi_ltr_mode *in = pdata, *ltr = prop_data;
928
929 switch (in->ltr_mode) {
930 case HFI_LTR_MODE_DISABLE:
931 case HFI_LTR_MODE_MANUAL:
932 case HFI_LTR_MODE_PERIODIC:
933 break;
934 default:
935 ret = -EINVAL;
936 break;
937 }
938
939 ltr->ltr_mode = in->ltr_mode;
940 ltr->ltr_count = in->ltr_count;
941 ltr->trust_mode = in->trust_mode;
942 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr);
943 break;
944 }
945 case HFI_PROPERTY_CONFIG_VENC_USELTRFRAME: {
946 struct hfi_ltr_use *in = pdata, *ltr_use = prop_data;
947
948 ltr_use->frames = in->frames;
949 ltr_use->ref_ltr = in->ref_ltr;
950 ltr_use->use_constrnt = in->use_constrnt;
951 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr_use);
952 break;
953 }
954 case HFI_PROPERTY_CONFIG_VENC_MARKLTRFRAME: {
955 struct hfi_ltr_mark *in = pdata, *ltr_mark = prop_data;
956
957 ltr_mark->mark_frame = in->mark_frame;
958 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr_mark);
959 break;
960 }
961 case HFI_PROPERTY_PARAM_VENC_HIER_P_MAX_NUM_ENH_LAYER: {
962 u32 *in = pdata;
963
964 pkt->data[1] = *in;
965 pkt->shdr.hdr.size += sizeof(u32) * 2;
966 break;
967 }
968 case HFI_PROPERTY_CONFIG_VENC_HIER_P_ENH_LAYER: {
969 u32 *in = pdata;
970
971 pkt->data[1] = *in;
972 pkt->shdr.hdr.size += sizeof(u32) * 2;
973 break;
974 }
975 case HFI_PROPERTY_PARAM_VENC_DISABLE_RC_TIMESTAMP: {
976 struct hfi_enable *in = pdata, *en = prop_data;
977
978 en->enable = in->enable;
979 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
980 break;
981 }
982 case HFI_PROPERTY_PARAM_VENC_INITIAL_QP: {
983 struct hfi_initial_quantization *in = pdata, *quant = prop_data;
984
985 quant->init_qp_enable = in->init_qp_enable;
986 quant->qp_i = in->qp_i;
987 quant->qp_p = in->qp_p;
988 quant->qp_b = in->qp_b;
989 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*quant);
990 break;
991 }
992 case HFI_PROPERTY_PARAM_VPE_COLOR_SPACE_CONVERSION: {
993 struct hfi_vpe_color_space_conversion *in = pdata;
994 struct hfi_vpe_color_space_conversion *csc = prop_data;
995
996 memcpy(csc->csc_matrix, in->csc_matrix,
997 sizeof(csc->csc_matrix));
998 memcpy(csc->csc_bias, in->csc_bias, sizeof(csc->csc_bias));
999 memcpy(csc->csc_limit, in->csc_limit, sizeof(csc->csc_limit));
1000 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*csc);
1001 break;
1002 }
1003 case HFI_PROPERTY_PARAM_VENC_VPX_ERROR_RESILIENCE_MODE: {
1004 struct hfi_enable *in = pdata, *en = prop_data;
1005
1006 en->enable = in->enable;
1007 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
1008 break;
1009 }
1010 case HFI_PROPERTY_PARAM_VENC_H264_NAL_SVC_EXT: {
1011 struct hfi_enable *in = pdata, *en = prop_data;
1012
1013 en->enable = in->enable;
1014 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
1015 break;
1016 }
1017 case HFI_PROPERTY_CONFIG_VENC_PERF_MODE: {
1018 u32 *in = pdata;
1019
1020 pkt->data[1] = *in;
1021 pkt->shdr.hdr.size += sizeof(u32) * 2;
1022 break;
1023 }
1024 case HFI_PROPERTY_PARAM_VENC_HIER_B_MAX_NUM_ENH_LAYER: {
1025 u32 *in = pdata;
1026
1027 pkt->data[1] = *in;
1028 pkt->shdr.hdr.size += sizeof(u32) * 2;
1029 break;
1030 }
1031 case HFI_PROPERTY_PARAM_VDEC_NONCP_OUTPUT2: {
1032 struct hfi_enable *in = pdata, *en = prop_data;
1033
1034 en->enable = in->enable;
1035 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
1036 break;
1037 }
1038 case HFI_PROPERTY_PARAM_VENC_HIER_P_HYBRID_MODE: {
1039 struct hfi_hybrid_hierp *in = pdata, *hierp = prop_data;
1040
1041 hierp->layers = in->layers;
1042 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hierp);
1043 break;
1044 }
1045 case HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_INFO: {
1046 struct hfi_uncompressed_plane_actual_info *in = pdata;
1047 struct hfi_uncompressed_plane_actual_info *info = prop_data;
1048
1049 info->buffer_type = in->buffer_type;
1050 info->num_planes = in->num_planes;
1051 info->plane_format[0] = in->plane_format[0];
1052 if (in->num_planes > 1)
1053 info->plane_format[1] = in->plane_format[1];
1054 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*info);
1055 break;
1056 }
1057 case HFI_PROPERTY_PARAM_VENC_HDR10_PQ_SEI:
1058 return -ENOTSUPP;
1059
1060 /* FOLLOWING PROPERTIES ARE NOT IMPLEMENTED IN CORE YET */
1061 case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:
1062 case HFI_PROPERTY_CONFIG_PRIORITY:
1063 case HFI_PROPERTY_CONFIG_BATCH_INFO:
1064 case HFI_PROPERTY_SYS_IDLE_INDICATOR:
1065 case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:
1066 case HFI_PROPERTY_PARAM_INTERLACE_FORMAT_SUPPORTED:
1067 case HFI_PROPERTY_PARAM_CHROMA_SITE:
1068 case HFI_PROPERTY_PARAM_PROPERTIES_SUPPORTED:
1069 case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED:
1070 case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED:
1071 case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SUPPORTED:
1072 case HFI_PROPERTY_PARAM_MULTI_VIEW_FORMAT:
1073 case HFI_PROPERTY_PARAM_MAX_SEQUENCE_HEADER_SIZE:
1074 case HFI_PROPERTY_PARAM_CODEC_SUPPORTED:
1075 case HFI_PROPERTY_PARAM_VDEC_MULTI_VIEW_SELECT:
1076 case HFI_PROPERTY_PARAM_VDEC_MB_QUANTIZATION:
1077 case HFI_PROPERTY_PARAM_VDEC_NUM_CONCEALED_MB:
1078 case HFI_PROPERTY_PARAM_VDEC_H264_ENTROPY_SWITCHING:
1079 case HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_INFO:
1080 default:
1081 return -EINVAL;
1082 }
1083
1084 return ret;
1085 }
1086
1087 static int
pkt_session_get_property_3xx(struct hfi_session_get_property_pkt * pkt,void * cookie,u32 ptype)1088 pkt_session_get_property_3xx(struct hfi_session_get_property_pkt *pkt,
1089 void *cookie, u32 ptype)
1090 {
1091 int ret = 0;
1092
1093 if (!pkt || !cookie)
1094 return -EINVAL;
1095
1096 pkt->shdr.hdr.size = sizeof(struct hfi_session_get_property_pkt);
1097 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_GET_PROPERTY;
1098 pkt->shdr.session_id = hash32_ptr(cookie);
1099 pkt->num_properties = 1;
1100
1101 switch (ptype) {
1102 case HFI_PROPERTY_CONFIG_VDEC_ENTROPY:
1103 pkt->data[0] = HFI_PROPERTY_CONFIG_VDEC_ENTROPY;
1104 break;
1105 default:
1106 ret = pkt_session_get_property_1x(pkt, cookie, ptype);
1107 break;
1108 }
1109
1110 return ret;
1111 }
1112
1113 static int
pkt_session_set_property_3xx(struct hfi_session_set_property_pkt * pkt,void * cookie,u32 ptype,void * pdata)1114 pkt_session_set_property_3xx(struct hfi_session_set_property_pkt *pkt,
1115 void *cookie, u32 ptype, void *pdata)
1116 {
1117 void *prop_data;
1118 int ret = 0;
1119
1120 if (!pkt || !cookie || !pdata)
1121 return -EINVAL;
1122
1123 prop_data = &pkt->data[1];
1124
1125 pkt->shdr.hdr.size = sizeof(*pkt);
1126 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1127 pkt->shdr.session_id = hash32_ptr(cookie);
1128 pkt->num_properties = 1;
1129 pkt->data[0] = ptype;
1130
1131 /*
1132 * Any session set property which is different in 3XX packetization
1133 * should be added as a new case below. All unchanged session set
1134 * properties will be handled in the default case.
1135 */
1136 switch (ptype) {
1137 case HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM: {
1138 struct hfi_multi_stream *in = pdata;
1139 struct hfi_multi_stream_3x *multi = prop_data;
1140
1141 multi->buffer_type = in->buffer_type;
1142 multi->enable = in->enable;
1143 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
1144 break;
1145 }
1146 case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {
1147 struct hfi_intra_refresh *in = pdata;
1148 struct hfi_intra_refresh_3x *intra = prop_data;
1149
1150 switch (in->mode) {
1151 case HFI_INTRA_REFRESH_NONE:
1152 case HFI_INTRA_REFRESH_ADAPTIVE:
1153 case HFI_INTRA_REFRESH_CYCLIC:
1154 case HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE:
1155 case HFI_INTRA_REFRESH_RANDOM:
1156 break;
1157 default:
1158 ret = -EINVAL;
1159 break;
1160 }
1161
1162 intra->mode = in->mode;
1163 intra->mbs = in->cir_mbs;
1164 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
1165 break;
1166 }
1167 case HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER:
1168 /* for 3xx fw version session_continue is used */
1169 break;
1170 default:
1171 ret = pkt_session_set_property_1x(pkt, cookie, ptype, pdata);
1172 break;
1173 }
1174
1175 return ret;
1176 }
1177
1178 static int
pkt_session_set_property_4xx(struct hfi_session_set_property_pkt * pkt,void * cookie,u32 ptype,void * pdata)1179 pkt_session_set_property_4xx(struct hfi_session_set_property_pkt *pkt,
1180 void *cookie, u32 ptype, void *pdata)
1181 {
1182 void *prop_data;
1183
1184 if (!pkt || !cookie || !pdata)
1185 return -EINVAL;
1186
1187 prop_data = &pkt->data[1];
1188
1189 pkt->shdr.hdr.size = sizeof(*pkt);
1190 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1191 pkt->shdr.session_id = hash32_ptr(cookie);
1192 pkt->num_properties = 1;
1193 pkt->data[0] = ptype;
1194
1195 /*
1196 * Any session set property which is different in 3XX packetization
1197 * should be added as a new case below. All unchanged session set
1198 * properties will be handled in the default case.
1199 */
1200 switch (ptype) {
1201 case HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL: {
1202 struct hfi_buffer_count_actual *in = pdata;
1203 struct hfi_buffer_count_actual_4xx *count = prop_data;
1204
1205 count->count_actual = in->count_actual;
1206 count->type = in->type;
1207 count->count_min_host = in->count_actual;
1208 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);
1209 break;
1210 }
1211 case HFI_PROPERTY_PARAM_WORK_MODE: {
1212 struct hfi_video_work_mode *in = pdata, *wm = prop_data;
1213
1214 wm->video_work_mode = in->video_work_mode;
1215 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*wm);
1216 break;
1217 }
1218 case HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE: {
1219 struct hfi_videocores_usage_type *in = pdata, *cu = prop_data;
1220
1221 cu->video_core_enable_mask = in->video_core_enable_mask;
1222 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cu);
1223 break;
1224 }
1225 case HFI_PROPERTY_PARAM_VENC_HDR10_PQ_SEI: {
1226 struct hfi_hdr10_pq_sei *in = pdata, *hdr10 = prop_data;
1227
1228 memcpy(hdr10, in, sizeof(*hdr10));
1229 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hdr10);
1230 break;
1231 }
1232 case HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR: {
1233 struct hfi_conceal_color_v4 *color = prop_data;
1234 u32 *in = pdata;
1235
1236 color->conceal_color_8bit = *in & 0xff;
1237 color->conceal_color_8bit |= ((*in >> 10) & 0xff) << 8;
1238 color->conceal_color_8bit |= ((*in >> 20) & 0xff) << 16;
1239 color->conceal_color_10bit = *in;
1240 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*color);
1241 break;
1242 }
1243
1244 case HFI_PROPERTY_PARAM_VENC_H264_TRANSFORM_8X8: {
1245 struct hfi_h264_8x8_transform *in = pdata, *tm = prop_data;
1246
1247 tm->enable_type = in->enable_type;
1248 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*tm);
1249 break;
1250 }
1251
1252 case HFI_PROPERTY_CONFIG_VENC_MAX_BITRATE:
1253 case HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER:
1254 case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE:
1255 case HFI_PROPERTY_PARAM_VENC_SESSION_QP:
1256 case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE:
1257 /* not implemented on Venus 4xx */
1258 return -ENOTSUPP;
1259 default:
1260 return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);
1261 }
1262
1263 return 0;
1264 }
1265
1266 static int
pkt_session_set_property_6xx(struct hfi_session_set_property_pkt * pkt,void * cookie,u32 ptype,void * pdata)1267 pkt_session_set_property_6xx(struct hfi_session_set_property_pkt *pkt,
1268 void *cookie, u32 ptype, void *pdata)
1269 {
1270 void *prop_data;
1271
1272 if (!pkt || !cookie || !pdata)
1273 return -EINVAL;
1274
1275 prop_data = &pkt->data[1];
1276
1277 pkt->shdr.hdr.size = sizeof(*pkt);
1278 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1279 pkt->shdr.session_id = hash32_ptr(cookie);
1280 pkt->num_properties = 1;
1281 pkt->data[0] = ptype;
1282
1283 switch (ptype) {
1284 case HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO: {
1285 struct hfi_uncompressed_plane_actual_constraints_info *in = pdata;
1286 struct hfi_uncompressed_plane_actual_constraints_info *info = prop_data;
1287
1288 info->buffer_type = in->buffer_type;
1289 info->num_planes = in->num_planes;
1290 info->plane_format[0] = in->plane_format[0];
1291 if (in->num_planes > 1)
1292 info->plane_format[1] = in->plane_format[1];
1293
1294 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*info);
1295 break;
1296 }
1297 case HFI_PROPERTY_CONFIG_HEIC_FRAME_QUALITY: {
1298 struct hfi_heic_frame_quality *in = pdata, *cq = prop_data;
1299
1300 cq->frame_quality = in->frame_quality;
1301 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cq);
1302 break;
1303 }
1304 default:
1305 return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);
1306 }
1307
1308 return 0;
1309 }
1310
pkt_session_get_property(struct hfi_session_get_property_pkt * pkt,void * cookie,u32 ptype)1311 int pkt_session_get_property(struct hfi_session_get_property_pkt *pkt,
1312 void *cookie, u32 ptype)
1313 {
1314 if (hfi_ver == HFI_VERSION_1XX)
1315 return pkt_session_get_property_1x(pkt, cookie, ptype);
1316
1317 return pkt_session_get_property_3xx(pkt, cookie, ptype);
1318 }
1319
pkt_session_set_property(struct hfi_session_set_property_pkt * pkt,void * cookie,u32 ptype,void * pdata)1320 int pkt_session_set_property(struct hfi_session_set_property_pkt *pkt,
1321 void *cookie, u32 ptype, void *pdata)
1322 {
1323 if (hfi_ver == HFI_VERSION_1XX)
1324 return pkt_session_set_property_1x(pkt, cookie, ptype, pdata);
1325
1326 if (hfi_ver == HFI_VERSION_3XX)
1327 return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);
1328
1329 if (hfi_ver == HFI_VERSION_4XX)
1330 return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);
1331
1332 return pkt_session_set_property_6xx(pkt, cookie, ptype, pdata);
1333 }
1334
pkt_set_version(enum hfi_version version)1335 void pkt_set_version(enum hfi_version version)
1336 {
1337 hfi_ver = version;
1338 }
1339