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