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 		case HFI_RATE_CONTROL_CQ:
644 			break;
645 		default:
646 			ret = -EINVAL;
647 			break;
648 		}
649 
650 		pkt->data[1] = *in;
651 		pkt->shdr.hdr.size += sizeof(u32) * 2;
652 		break;
653 	}
654 	case HFI_PROPERTY_PARAM_VENC_MPEG4_TIME_RESOLUTION: {
655 		struct hfi_mpeg4_time_resolution *in = pdata, *res = prop_data;
656 
657 		res->time_increment_resolution = in->time_increment_resolution;
658 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*res);
659 		break;
660 	}
661 	case HFI_PROPERTY_PARAM_VENC_MPEG4_HEADER_EXTENSION: {
662 		struct hfi_mpeg4_header_extension *in = pdata, *ext = prop_data;
663 
664 		ext->header_extension = in->header_extension;
665 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ext);
666 		break;
667 	}
668 	case HFI_PROPERTY_PARAM_VENC_H264_DEBLOCK_CONTROL: {
669 		struct hfi_h264_db_control *in = pdata, *db = prop_data;
670 
671 		switch (in->mode) {
672 		case HFI_H264_DB_MODE_DISABLE:
673 		case HFI_H264_DB_MODE_SKIP_SLICE_BOUNDARY:
674 		case HFI_H264_DB_MODE_ALL_BOUNDARY:
675 			break;
676 		default:
677 			ret = -EINVAL;
678 			break;
679 		}
680 
681 		db->mode = in->mode;
682 		db->slice_alpha_offset = in->slice_alpha_offset;
683 		db->slice_beta_offset = in->slice_beta_offset;
684 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*db);
685 		break;
686 	}
687 	case HFI_PROPERTY_PARAM_VENC_SESSION_QP: {
688 		struct hfi_quantization *in = pdata, *quant = prop_data;
689 
690 		quant->qp_i = in->qp_i;
691 		quant->qp_p = in->qp_p;
692 		quant->qp_b = in->qp_b;
693 		quant->layer_id = in->layer_id;
694 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*quant);
695 		break;
696 	}
697 	case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE: {
698 		struct hfi_quantization_range *in = pdata, *range = prop_data;
699 		u32 min_qp, max_qp;
700 
701 		min_qp = in->min_qp;
702 		max_qp = in->max_qp;
703 
704 		/* We'll be packing in the qp, so make sure we
705 		 * won't be losing data when masking
706 		 */
707 		if (min_qp > 0xff || max_qp > 0xff) {
708 			ret = -ERANGE;
709 			break;
710 		}
711 
712 		/* When creating the packet, pack the qp value as
713 		 * 0xiippbb, where ii = qp range for I-frames,
714 		 * pp = qp range for P-frames, etc.
715 		 */
716 		range->min_qp = min_qp | min_qp << 8 | min_qp << 16;
717 		range->max_qp = max_qp | max_qp << 8 | max_qp << 16;
718 		range->layer_id = in->layer_id;
719 
720 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*range);
721 		break;
722 	}
723 	case HFI_PROPERTY_PARAM_VENC_VC1_PERF_CFG: {
724 		struct hfi_vc1e_perf_cfg_type *in = pdata, *perf = prop_data;
725 
726 		memcpy(perf->search_range_x_subsampled,
727 		       in->search_range_x_subsampled,
728 		       sizeof(perf->search_range_x_subsampled));
729 		memcpy(perf->search_range_y_subsampled,
730 		       in->search_range_y_subsampled,
731 		       sizeof(perf->search_range_y_subsampled));
732 
733 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*perf);
734 		break;
735 	}
736 	case HFI_PROPERTY_PARAM_VENC_MAX_NUM_B_FRAMES: {
737 		struct hfi_max_num_b_frames *bframes = prop_data;
738 		u32 *in = pdata;
739 
740 		bframes->max_num_b_frames = *in;
741 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*bframes);
742 		break;
743 	}
744 	case HFI_PROPERTY_CONFIG_VENC_INTRA_PERIOD: {
745 		struct hfi_intra_period *in = pdata, *intra = prop_data;
746 
747 		intra->pframes = in->pframes;
748 		intra->bframes = in->bframes;
749 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
750 		break;
751 	}
752 	case HFI_PROPERTY_CONFIG_VENC_IDR_PERIOD: {
753 		struct hfi_idr_period *in = pdata, *idr = prop_data;
754 
755 		idr->idr_period = in->idr_period;
756 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*idr);
757 		break;
758 	}
759 	case HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR: {
760 		struct hfi_conceal_color *color = prop_data;
761 		u32 *in = pdata;
762 
763 		color->conceal_color = *in;
764 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*color);
765 		break;
766 	}
767 	case HFI_PROPERTY_CONFIG_VPE_OPERATIONS: {
768 		struct hfi_operations_type *in = pdata, *ops = prop_data;
769 
770 		switch (in->rotation) {
771 		case HFI_ROTATE_NONE:
772 		case HFI_ROTATE_90:
773 		case HFI_ROTATE_180:
774 		case HFI_ROTATE_270:
775 			break;
776 		default:
777 			ret = -EINVAL;
778 			break;
779 		}
780 
781 		switch (in->flip) {
782 		case HFI_FLIP_NONE:
783 		case HFI_FLIP_HORIZONTAL:
784 		case HFI_FLIP_VERTICAL:
785 			break;
786 		default:
787 			ret = -EINVAL;
788 			break;
789 		}
790 
791 		ops->rotation = in->rotation;
792 		ops->flip = in->flip;
793 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ops);
794 		break;
795 	}
796 	case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {
797 		struct hfi_intra_refresh *in = pdata, *intra = prop_data;
798 
799 		switch (in->mode) {
800 		case HFI_INTRA_REFRESH_NONE:
801 		case HFI_INTRA_REFRESH_ADAPTIVE:
802 		case HFI_INTRA_REFRESH_CYCLIC:
803 		case HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE:
804 		case HFI_INTRA_REFRESH_RANDOM:
805 			break;
806 		default:
807 			ret = -EINVAL;
808 			break;
809 		}
810 
811 		intra->mode = in->mode;
812 		intra->air_mbs = in->air_mbs;
813 		intra->air_ref = in->air_ref;
814 		intra->cir_mbs = in->cir_mbs;
815 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
816 		break;
817 	}
818 	case HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_CONTROL: {
819 		struct hfi_multi_slice_control *in = pdata, *multi = prop_data;
820 
821 		switch (in->multi_slice) {
822 		case HFI_MULTI_SLICE_OFF:
823 		case HFI_MULTI_SLICE_GOB:
824 		case HFI_MULTI_SLICE_BY_MB_COUNT:
825 		case HFI_MULTI_SLICE_BY_BYTE_COUNT:
826 			break;
827 		default:
828 			ret = -EINVAL;
829 			break;
830 		}
831 
832 		multi->multi_slice = in->multi_slice;
833 		multi->slice_size = in->slice_size;
834 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
835 		break;
836 	}
837 	case HFI_PROPERTY_PARAM_VENC_SLICE_DELIVERY_MODE: {
838 		struct hfi_enable *in = pdata, *en = prop_data;
839 
840 		en->enable = in->enable;
841 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
842 		break;
843 	}
844 	case HFI_PROPERTY_PARAM_VENC_H264_VUI_TIMING_INFO: {
845 		struct hfi_h264_vui_timing_info *in = pdata, *vui = prop_data;
846 
847 		vui->enable = in->enable;
848 		vui->fixed_framerate = in->fixed_framerate;
849 		vui->time_scale = in->time_scale;
850 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*vui);
851 		break;
852 	}
853 	case HFI_PROPERTY_CONFIG_VPE_DEINTERLACE: {
854 		struct hfi_enable *in = pdata, *en = prop_data;
855 
856 		en->enable = in->enable;
857 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
858 		break;
859 	}
860 	case HFI_PROPERTY_PARAM_VENC_H264_GENERATE_AUDNAL: {
861 		struct hfi_enable *in = pdata, *en = prop_data;
862 
863 		en->enable = in->enable;
864 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
865 		break;
866 	}
867 	case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE: {
868 		struct hfi_buffer_alloc_mode *in = pdata, *mode = prop_data;
869 
870 		mode->type = in->type;
871 		mode->mode = in->mode;
872 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*mode);
873 		break;
874 	}
875 	case HFI_PROPERTY_PARAM_VDEC_FRAME_ASSEMBLY: {
876 		struct hfi_enable *in = pdata, *en = prop_data;
877 
878 		en->enable = in->enable;
879 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
880 		break;
881 	}
882 	case HFI_PROPERTY_PARAM_VENC_H264_VUI_BITSTREAM_RESTRC: {
883 		struct hfi_enable *in = pdata, *en = prop_data;
884 
885 		en->enable = in->enable;
886 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
887 		break;
888 	}
889 	case HFI_PROPERTY_PARAM_VENC_PRESERVE_TEXT_QUALITY: {
890 		struct hfi_enable *in = pdata, *en = prop_data;
891 
892 		en->enable = in->enable;
893 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
894 		break;
895 	}
896 	case HFI_PROPERTY_PARAM_VDEC_SCS_THRESHOLD: {
897 		struct hfi_scs_threshold *thres = prop_data;
898 		u32 *in = pdata;
899 
900 		thres->threshold_value = *in;
901 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*thres);
902 		break;
903 	}
904 	case HFI_PROPERTY_PARAM_MVC_BUFFER_LAYOUT: {
905 		struct hfi_mvc_buffer_layout_descp_type *in = pdata;
906 		struct hfi_mvc_buffer_layout_descp_type *mvc = prop_data;
907 
908 		switch (in->layout_type) {
909 		case HFI_MVC_BUFFER_LAYOUT_TOP_BOTTOM:
910 		case HFI_MVC_BUFFER_LAYOUT_SEQ:
911 			break;
912 		default:
913 			ret = -EINVAL;
914 			break;
915 		}
916 
917 		mvc->layout_type = in->layout_type;
918 		mvc->bright_view_first = in->bright_view_first;
919 		mvc->ngap = in->ngap;
920 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*mvc);
921 		break;
922 	}
923 	case HFI_PROPERTY_PARAM_VENC_LTRMODE: {
924 		struct hfi_ltr_mode *in = pdata, *ltr = prop_data;
925 
926 		switch (in->ltr_mode) {
927 		case HFI_LTR_MODE_DISABLE:
928 		case HFI_LTR_MODE_MANUAL:
929 		case HFI_LTR_MODE_PERIODIC:
930 			break;
931 		default:
932 			ret = -EINVAL;
933 			break;
934 		}
935 
936 		ltr->ltr_mode = in->ltr_mode;
937 		ltr->ltr_count = in->ltr_count;
938 		ltr->trust_mode = in->trust_mode;
939 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr);
940 		break;
941 	}
942 	case HFI_PROPERTY_CONFIG_VENC_USELTRFRAME: {
943 		struct hfi_ltr_use *in = pdata, *ltr_use = prop_data;
944 
945 		ltr_use->frames = in->frames;
946 		ltr_use->ref_ltr = in->ref_ltr;
947 		ltr_use->use_constrnt = in->use_constrnt;
948 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr_use);
949 		break;
950 	}
951 	case HFI_PROPERTY_CONFIG_VENC_MARKLTRFRAME: {
952 		struct hfi_ltr_mark *in = pdata, *ltr_mark = prop_data;
953 
954 		ltr_mark->mark_frame = in->mark_frame;
955 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr_mark);
956 		break;
957 	}
958 	case HFI_PROPERTY_PARAM_VENC_HIER_P_MAX_NUM_ENH_LAYER: {
959 		u32 *in = pdata;
960 
961 		pkt->data[1] = *in;
962 		pkt->shdr.hdr.size += sizeof(u32) * 2;
963 		break;
964 	}
965 	case HFI_PROPERTY_CONFIG_VENC_HIER_P_ENH_LAYER: {
966 		u32 *in = pdata;
967 
968 		pkt->data[1] = *in;
969 		pkt->shdr.hdr.size += sizeof(u32) * 2;
970 		break;
971 	}
972 	case HFI_PROPERTY_PARAM_VENC_DISABLE_RC_TIMESTAMP: {
973 		struct hfi_enable *in = pdata, *en = prop_data;
974 
975 		en->enable = in->enable;
976 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
977 		break;
978 	}
979 	case HFI_PROPERTY_PARAM_VENC_INITIAL_QP: {
980 		struct hfi_initial_quantization *in = pdata, *quant = prop_data;
981 
982 		quant->init_qp_enable = in->init_qp_enable;
983 		quant->qp_i = in->qp_i;
984 		quant->qp_p = in->qp_p;
985 		quant->qp_b = in->qp_b;
986 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*quant);
987 		break;
988 	}
989 	case HFI_PROPERTY_PARAM_VPE_COLOR_SPACE_CONVERSION: {
990 		struct hfi_vpe_color_space_conversion *in = pdata;
991 		struct hfi_vpe_color_space_conversion *csc = prop_data;
992 
993 		memcpy(csc->csc_matrix, in->csc_matrix,
994 		       sizeof(csc->csc_matrix));
995 		memcpy(csc->csc_bias, in->csc_bias, sizeof(csc->csc_bias));
996 		memcpy(csc->csc_limit, in->csc_limit, sizeof(csc->csc_limit));
997 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*csc);
998 		break;
999 	}
1000 	case HFI_PROPERTY_PARAM_VENC_VPX_ERROR_RESILIENCE_MODE: {
1001 		struct hfi_enable *in = pdata, *en = prop_data;
1002 
1003 		en->enable = in->enable;
1004 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
1005 		break;
1006 	}
1007 	case HFI_PROPERTY_PARAM_VENC_H264_NAL_SVC_EXT: {
1008 		struct hfi_enable *in = pdata, *en = prop_data;
1009 
1010 		en->enable = in->enable;
1011 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
1012 		break;
1013 	}
1014 	case HFI_PROPERTY_CONFIG_VENC_PERF_MODE: {
1015 		u32 *in = pdata;
1016 
1017 		pkt->data[1] = *in;
1018 		pkt->shdr.hdr.size += sizeof(u32) * 2;
1019 		break;
1020 	}
1021 	case HFI_PROPERTY_PARAM_VENC_HIER_B_MAX_NUM_ENH_LAYER: {
1022 		u32 *in = pdata;
1023 
1024 		pkt->data[1] = *in;
1025 		pkt->shdr.hdr.size += sizeof(u32) * 2;
1026 		break;
1027 	}
1028 	case HFI_PROPERTY_PARAM_VDEC_NONCP_OUTPUT2: {
1029 		struct hfi_enable *in = pdata, *en = prop_data;
1030 
1031 		en->enable = in->enable;
1032 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
1033 		break;
1034 	}
1035 	case HFI_PROPERTY_PARAM_VENC_HIER_P_HYBRID_MODE: {
1036 		struct hfi_hybrid_hierp *in = pdata, *hierp = prop_data;
1037 
1038 		hierp->layers = in->layers;
1039 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hierp);
1040 		break;
1041 	}
1042 
1043 	/* FOLLOWING PROPERTIES ARE NOT IMPLEMENTED IN CORE YET */
1044 	case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:
1045 	case HFI_PROPERTY_CONFIG_PRIORITY:
1046 	case HFI_PROPERTY_CONFIG_BATCH_INFO:
1047 	case HFI_PROPERTY_SYS_IDLE_INDICATOR:
1048 	case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:
1049 	case HFI_PROPERTY_PARAM_INTERLACE_FORMAT_SUPPORTED:
1050 	case HFI_PROPERTY_PARAM_CHROMA_SITE:
1051 	case HFI_PROPERTY_PARAM_PROPERTIES_SUPPORTED:
1052 	case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED:
1053 	case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED:
1054 	case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SUPPORTED:
1055 	case HFI_PROPERTY_PARAM_MULTI_VIEW_FORMAT:
1056 	case HFI_PROPERTY_PARAM_MAX_SEQUENCE_HEADER_SIZE:
1057 	case HFI_PROPERTY_PARAM_CODEC_SUPPORTED:
1058 	case HFI_PROPERTY_PARAM_VDEC_MULTI_VIEW_SELECT:
1059 	case HFI_PROPERTY_PARAM_VDEC_MB_QUANTIZATION:
1060 	case HFI_PROPERTY_PARAM_VDEC_NUM_CONCEALED_MB:
1061 	case HFI_PROPERTY_PARAM_VDEC_H264_ENTROPY_SWITCHING:
1062 	case HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_INFO:
1063 	default:
1064 		return -EINVAL;
1065 	}
1066 
1067 	return ret;
1068 }
1069 
1070 static int
1071 pkt_session_get_property_3xx(struct hfi_session_get_property_pkt *pkt,
1072 			     void *cookie, u32 ptype)
1073 {
1074 	int ret = 0;
1075 
1076 	if (!pkt || !cookie)
1077 		return -EINVAL;
1078 
1079 	pkt->shdr.hdr.size = sizeof(struct hfi_session_get_property_pkt);
1080 	pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_GET_PROPERTY;
1081 	pkt->shdr.session_id = hash32_ptr(cookie);
1082 	pkt->num_properties = 1;
1083 
1084 	switch (ptype) {
1085 	case HFI_PROPERTY_CONFIG_VDEC_ENTROPY:
1086 		pkt->data[0] = HFI_PROPERTY_CONFIG_VDEC_ENTROPY;
1087 		break;
1088 	default:
1089 		ret = pkt_session_get_property_1x(pkt, cookie, ptype);
1090 		break;
1091 	}
1092 
1093 	return ret;
1094 }
1095 
1096 static int
1097 pkt_session_set_property_3xx(struct hfi_session_set_property_pkt *pkt,
1098 			     void *cookie, u32 ptype, void *pdata)
1099 {
1100 	void *prop_data;
1101 	int ret = 0;
1102 
1103 	if (!pkt || !cookie || !pdata)
1104 		return -EINVAL;
1105 
1106 	prop_data = &pkt->data[1];
1107 
1108 	pkt->shdr.hdr.size = sizeof(*pkt);
1109 	pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1110 	pkt->shdr.session_id = hash32_ptr(cookie);
1111 	pkt->num_properties = 1;
1112 	pkt->data[0] = ptype;
1113 
1114 	/*
1115 	 * Any session set property which is different in 3XX packetization
1116 	 * should be added as a new case below. All unchanged session set
1117 	 * properties will be handled in the default case.
1118 	 */
1119 	switch (ptype) {
1120 	case HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM: {
1121 		struct hfi_multi_stream *in = pdata;
1122 		struct hfi_multi_stream_3x *multi = prop_data;
1123 
1124 		multi->buffer_type = in->buffer_type;
1125 		multi->enable = in->enable;
1126 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
1127 		break;
1128 	}
1129 	case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {
1130 		struct hfi_intra_refresh *in = pdata;
1131 		struct hfi_intra_refresh_3x *intra = prop_data;
1132 
1133 		switch (in->mode) {
1134 		case HFI_INTRA_REFRESH_NONE:
1135 		case HFI_INTRA_REFRESH_ADAPTIVE:
1136 		case HFI_INTRA_REFRESH_CYCLIC:
1137 		case HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE:
1138 		case HFI_INTRA_REFRESH_RANDOM:
1139 			break;
1140 		default:
1141 			ret = -EINVAL;
1142 			break;
1143 		}
1144 
1145 		intra->mode = in->mode;
1146 		intra->mbs = in->cir_mbs;
1147 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
1148 		break;
1149 	}
1150 	case HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER:
1151 		/* for 3xx fw version session_continue is used */
1152 		break;
1153 	default:
1154 		ret = pkt_session_set_property_1x(pkt, cookie, ptype, pdata);
1155 		break;
1156 	}
1157 
1158 	return ret;
1159 }
1160 
1161 static int
1162 pkt_session_set_property_4xx(struct hfi_session_set_property_pkt *pkt,
1163 			     void *cookie, u32 ptype, void *pdata)
1164 {
1165 	void *prop_data;
1166 
1167 	if (!pkt || !cookie || !pdata)
1168 		return -EINVAL;
1169 
1170 	prop_data = &pkt->data[1];
1171 
1172 	pkt->shdr.hdr.size = sizeof(*pkt);
1173 	pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1174 	pkt->shdr.session_id = hash32_ptr(cookie);
1175 	pkt->num_properties = 1;
1176 	pkt->data[0] = ptype;
1177 
1178 	/*
1179 	 * Any session set property which is different in 3XX packetization
1180 	 * should be added as a new case below. All unchanged session set
1181 	 * properties will be handled in the default case.
1182 	 */
1183 	switch (ptype) {
1184 	case HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL: {
1185 		struct hfi_buffer_count_actual *in = pdata;
1186 		struct hfi_buffer_count_actual_4xx *count = prop_data;
1187 
1188 		count->count_actual = in->count_actual;
1189 		count->type = in->type;
1190 		count->count_min_host = in->count_actual;
1191 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);
1192 		break;
1193 	}
1194 	case HFI_PROPERTY_PARAM_WORK_MODE: {
1195 		struct hfi_video_work_mode *in = pdata, *wm = prop_data;
1196 
1197 		wm->video_work_mode = in->video_work_mode;
1198 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*wm);
1199 		break;
1200 	}
1201 	case HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE: {
1202 		struct hfi_videocores_usage_type *in = pdata, *cu = prop_data;
1203 
1204 		cu->video_core_enable_mask = in->video_core_enable_mask;
1205 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cu);
1206 		break;
1207 	}
1208 	case HFI_PROPERTY_CONFIG_VENC_MAX_BITRATE:
1209 	case HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER:
1210 	case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE:
1211 	case HFI_PROPERTY_PARAM_VENC_SESSION_QP:
1212 	case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE:
1213 		/* not implemented on Venus 4xx */
1214 		return -ENOTSUPP;
1215 	default:
1216 		return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);
1217 	}
1218 
1219 	return 0;
1220 }
1221 
1222 static int
1223 pkt_session_set_property_6xx(struct hfi_session_set_property_pkt *pkt,
1224 			     void *cookie, u32 ptype, void *pdata)
1225 {
1226 	void *prop_data;
1227 
1228 	if (!pkt || !cookie || !pdata)
1229 		return -EINVAL;
1230 
1231 	prop_data = &pkt->data[1];
1232 
1233 	pkt->shdr.hdr.size = sizeof(*pkt);
1234 	pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1235 	pkt->shdr.session_id = hash32_ptr(cookie);
1236 	pkt->num_properties = 1;
1237 	pkt->data[0] = ptype;
1238 
1239 	switch (ptype) {
1240 	case HFI_PROPERTY_CONFIG_HEIC_FRAME_QUALITY: {
1241 		struct hfi_heic_frame_quality *in = pdata, *cq = prop_data;
1242 
1243 		cq->frame_quality = in->frame_quality;
1244 		pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cq);
1245 		break;
1246 	} default:
1247 		return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);
1248 	}
1249 
1250 	return 0;
1251 }
1252 
1253 int pkt_session_get_property(struct hfi_session_get_property_pkt *pkt,
1254 			     void *cookie, u32 ptype)
1255 {
1256 	if (hfi_ver == HFI_VERSION_1XX)
1257 		return pkt_session_get_property_1x(pkt, cookie, ptype);
1258 
1259 	return pkt_session_get_property_3xx(pkt, cookie, ptype);
1260 }
1261 
1262 int pkt_session_set_property(struct hfi_session_set_property_pkt *pkt,
1263 			     void *cookie, u32 ptype, void *pdata)
1264 {
1265 	if (hfi_ver == HFI_VERSION_1XX)
1266 		return pkt_session_set_property_1x(pkt, cookie, ptype, pdata);
1267 
1268 	if (hfi_ver == HFI_VERSION_3XX)
1269 		return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);
1270 
1271 	if (hfi_ver == HFI_VERSION_4XX)
1272 		return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);
1273 
1274 	return pkt_session_set_property_6xx(pkt, cookie, ptype, pdata);
1275 }
1276 
1277 void pkt_set_version(enum hfi_version version)
1278 {
1279 	hfi_ver = version;
1280 }
1281