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