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