1
2
3
4
5
6#include <linux/overflow.h>
7#include <linux/errno.h>
8#include <linux/hash.h>
9
10#include "hfi_cmds.h"
11
12static enum hfi_version hfi_ver;
13
14void 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
21void 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
27void 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
38void 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
52void 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
61int 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
88int 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
109void 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
116void 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
127int 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
145void 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
153int 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
168void 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
175int 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
214int 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
255int 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
278int 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
304int 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
330int 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
346int 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
361int 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
381static 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
401static 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
617 pl->profile = HFI_H264_PROFILE_HIGH;
618
619 if (!pl->level)
620
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
706
707
708 if (min_qp > 0xff || max_qp > 0xff) {
709 ret = -ERANGE;
710 break;
711 }
712
713
714
715
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
1058
1059 case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:
1060 case HFI_PROPERTY_CONFIG_PRIORITY:
1061 case HFI_PROPERTY_CONFIG_BATCH_INFO:
1062 case HFI_PROPERTY_SYS_IDLE_INDICATOR:
1063 case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:
1064 case HFI_PROPERTY_PARAM_INTERLACE_FORMAT_SUPPORTED:
1065 case HFI_PROPERTY_PARAM_CHROMA_SITE:
1066 case HFI_PROPERTY_PARAM_PROPERTIES_SUPPORTED:
1067 case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED:
1068 case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED:
1069 case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SUPPORTED:
1070 case HFI_PROPERTY_PARAM_MULTI_VIEW_FORMAT:
1071 case HFI_PROPERTY_PARAM_MAX_SEQUENCE_HEADER_SIZE:
1072 case HFI_PROPERTY_PARAM_CODEC_SUPPORTED:
1073 case HFI_PROPERTY_PARAM_VDEC_MULTI_VIEW_SELECT:
1074 case HFI_PROPERTY_PARAM_VDEC_MB_QUANTIZATION:
1075 case HFI_PROPERTY_PARAM_VDEC_NUM_CONCEALED_MB:
1076 case HFI_PROPERTY_PARAM_VDEC_H264_ENTROPY_SWITCHING:
1077 case HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_INFO:
1078 default:
1079 return -EINVAL;
1080 }
1081
1082 return ret;
1083}
1084
1085static int
1086pkt_session_get_property_3xx(struct hfi_session_get_property_pkt *pkt,
1087 void *cookie, u32 ptype)
1088{
1089 int ret = 0;
1090
1091 if (!pkt || !cookie)
1092 return -EINVAL;
1093
1094 pkt->shdr.hdr.size = sizeof(struct hfi_session_get_property_pkt);
1095 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_GET_PROPERTY;
1096 pkt->shdr.session_id = hash32_ptr(cookie);
1097 pkt->num_properties = 1;
1098
1099 switch (ptype) {
1100 case HFI_PROPERTY_CONFIG_VDEC_ENTROPY:
1101 pkt->data[0] = HFI_PROPERTY_CONFIG_VDEC_ENTROPY;
1102 break;
1103 default:
1104 ret = pkt_session_get_property_1x(pkt, cookie, ptype);
1105 break;
1106 }
1107
1108 return ret;
1109}
1110
1111static int
1112pkt_session_set_property_3xx(struct hfi_session_set_property_pkt *pkt,
1113 void *cookie, u32 ptype, void *pdata)
1114{
1115 void *prop_data;
1116 int ret = 0;
1117
1118 if (!pkt || !cookie || !pdata)
1119 return -EINVAL;
1120
1121 prop_data = &pkt->data[1];
1122
1123 pkt->shdr.hdr.size = sizeof(*pkt);
1124 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1125 pkt->shdr.session_id = hash32_ptr(cookie);
1126 pkt->num_properties = 1;
1127 pkt->data[0] = ptype;
1128
1129
1130
1131
1132
1133
1134 switch (ptype) {
1135 case HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM: {
1136 struct hfi_multi_stream *in = pdata;
1137 struct hfi_multi_stream_3x *multi = prop_data;
1138
1139 multi->buffer_type = in->buffer_type;
1140 multi->enable = in->enable;
1141 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
1142 break;
1143 }
1144 case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {
1145 struct hfi_intra_refresh *in = pdata;
1146 struct hfi_intra_refresh_3x *intra = prop_data;
1147
1148 switch (in->mode) {
1149 case HFI_INTRA_REFRESH_NONE:
1150 case HFI_INTRA_REFRESH_ADAPTIVE:
1151 case HFI_INTRA_REFRESH_CYCLIC:
1152 case HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE:
1153 case HFI_INTRA_REFRESH_RANDOM:
1154 break;
1155 default:
1156 ret = -EINVAL;
1157 break;
1158 }
1159
1160 intra->mode = in->mode;
1161 intra->mbs = in->cir_mbs;
1162 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
1163 break;
1164 }
1165 case HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER:
1166
1167 break;
1168 default:
1169 ret = pkt_session_set_property_1x(pkt, cookie, ptype, pdata);
1170 break;
1171 }
1172
1173 return ret;
1174}
1175
1176static int
1177pkt_session_set_property_4xx(struct hfi_session_set_property_pkt *pkt,
1178 void *cookie, u32 ptype, void *pdata)
1179{
1180 void *prop_data;
1181
1182 if (!pkt || !cookie || !pdata)
1183 return -EINVAL;
1184
1185 prop_data = &pkt->data[1];
1186
1187 pkt->shdr.hdr.size = sizeof(*pkt);
1188 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1189 pkt->shdr.session_id = hash32_ptr(cookie);
1190 pkt->num_properties = 1;
1191 pkt->data[0] = ptype;
1192
1193
1194
1195
1196
1197
1198 switch (ptype) {
1199 case HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL: {
1200 struct hfi_buffer_count_actual *in = pdata;
1201 struct hfi_buffer_count_actual_4xx *count = prop_data;
1202
1203 count->count_actual = in->count_actual;
1204 count->type = in->type;
1205 count->count_min_host = in->count_actual;
1206 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);
1207 break;
1208 }
1209 case HFI_PROPERTY_PARAM_WORK_MODE: {
1210 struct hfi_video_work_mode *in = pdata, *wm = prop_data;
1211
1212 wm->video_work_mode = in->video_work_mode;
1213 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*wm);
1214 break;
1215 }
1216 case HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE: {
1217 struct hfi_videocores_usage_type *in = pdata, *cu = prop_data;
1218
1219 cu->video_core_enable_mask = in->video_core_enable_mask;
1220 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cu);
1221 break;
1222 }
1223 case HFI_PROPERTY_PARAM_VENC_HDR10_PQ_SEI: {
1224 struct hfi_hdr10_pq_sei *in = pdata, *hdr10 = prop_data;
1225
1226 memcpy(hdr10, in, sizeof(*hdr10));
1227 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hdr10);
1228 break;
1229 }
1230 case HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR: {
1231 struct hfi_conceal_color_v4 *color = prop_data;
1232 u32 *in = pdata;
1233
1234 color->conceal_color_8bit = *in & 0xff;
1235 color->conceal_color_8bit |= ((*in >> 10) & 0xff) << 8;
1236 color->conceal_color_8bit |= ((*in >> 20) & 0xff) << 16;
1237 color->conceal_color_10bit = *in;
1238 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*color);
1239 break;
1240 }
1241
1242 case HFI_PROPERTY_CONFIG_VENC_MAX_BITRATE:
1243 case HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER:
1244 case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE:
1245 case HFI_PROPERTY_PARAM_VENC_SESSION_QP:
1246 case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE:
1247
1248 return -ENOTSUPP;
1249 default:
1250 return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);
1251 }
1252
1253 return 0;
1254}
1255
1256static int
1257pkt_session_set_property_6xx(struct hfi_session_set_property_pkt *pkt,
1258 void *cookie, u32 ptype, void *pdata)
1259{
1260 void *prop_data;
1261
1262 if (!pkt || !cookie || !pdata)
1263 return -EINVAL;
1264
1265 prop_data = &pkt->data[1];
1266
1267 pkt->shdr.hdr.size = sizeof(*pkt);
1268 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1269 pkt->shdr.session_id = hash32_ptr(cookie);
1270 pkt->num_properties = 1;
1271 pkt->data[0] = ptype;
1272
1273 switch (ptype) {
1274 case HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO: {
1275 struct hfi_uncompressed_plane_actual_constraints_info *in = pdata;
1276 struct hfi_uncompressed_plane_actual_constraints_info *info = prop_data;
1277
1278 info->buffer_type = in->buffer_type;
1279 info->num_planes = in->num_planes;
1280 info->plane_format[0] = in->plane_format[0];
1281 if (in->num_planes > 1)
1282 info->plane_format[1] = in->plane_format[1];
1283
1284 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*info);
1285 break;
1286 }
1287 case HFI_PROPERTY_CONFIG_HEIC_FRAME_QUALITY: {
1288 struct hfi_heic_frame_quality *in = pdata, *cq = prop_data;
1289
1290 cq->frame_quality = in->frame_quality;
1291 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cq);
1292 break;
1293 }
1294 default:
1295 return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);
1296 }
1297
1298 return 0;
1299}
1300
1301int pkt_session_get_property(struct hfi_session_get_property_pkt *pkt,
1302 void *cookie, u32 ptype)
1303{
1304 if (hfi_ver == HFI_VERSION_1XX)
1305 return pkt_session_get_property_1x(pkt, cookie, ptype);
1306
1307 return pkt_session_get_property_3xx(pkt, cookie, ptype);
1308}
1309
1310int pkt_session_set_property(struct hfi_session_set_property_pkt *pkt,
1311 void *cookie, u32 ptype, void *pdata)
1312{
1313 if (hfi_ver == HFI_VERSION_1XX)
1314 return pkt_session_set_property_1x(pkt, cookie, ptype, pdata);
1315
1316 if (hfi_ver == HFI_VERSION_3XX)
1317 return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);
1318
1319 if (hfi_ver == HFI_VERSION_4XX)
1320 return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);
1321
1322 return pkt_session_set_property_6xx(pkt, cookie, ptype, pdata);
1323}
1324
1325void pkt_set_version(enum hfi_version version)
1326{
1327 hfi_ver = version;
1328}
1329
