1 /*
2  * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
3  * Copyright (C) 2017 Linaro Ltd.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 and
7  * only version 2 as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  */
15 #include <linux/hash.h>
16 #include <linux/list.h>
17 #include <linux/slab.h>
18 #include <media/videobuf2-v4l2.h>
19 
20 #include "core.h"
21 #include "hfi.h"
22 #include "hfi_helper.h"
23 #include "hfi_msgs.h"
24 
25 static void event_seq_changed(struct venus_core *core, struct venus_inst *inst,
26 			      struct hfi_msg_event_notify_pkt *pkt)
27 {
28 	struct hfi_event_data event = {0};
29 	int num_properties_changed;
30 	struct hfi_framesize *frame_sz;
31 	struct hfi_profile_level *profile_level;
32 	u8 *data_ptr;
33 	u32 ptype;
34 
35 	inst->error = HFI_ERR_NONE;
36 
37 	switch (pkt->event_data1) {
38 	case HFI_EVENT_DATA_SEQUENCE_CHANGED_SUFFICIENT_BUF_RESOURCES:
39 	case HFI_EVENT_DATA_SEQUENCE_CHANGED_INSUFFICIENT_BUF_RESOURCES:
40 		break;
41 	default:
42 		inst->error = HFI_ERR_SESSION_INVALID_PARAMETER;
43 		goto done;
44 	}
45 
46 	event.event_type = pkt->event_data1;
47 
48 	num_properties_changed = pkt->event_data2;
49 	if (!num_properties_changed) {
50 		inst->error = HFI_ERR_SESSION_INSUFFICIENT_RESOURCES;
51 		goto done;
52 	}
53 
54 	data_ptr = (u8 *)&pkt->ext_event_data[0];
55 	do {
56 		ptype = *((u32 *)data_ptr);
57 		switch (ptype) {
58 		case HFI_PROPERTY_PARAM_FRAME_SIZE:
59 			data_ptr += sizeof(u32);
60 			frame_sz = (struct hfi_framesize *)data_ptr;
61 			event.width = frame_sz->width;
62 			event.height = frame_sz->height;
63 			data_ptr += sizeof(frame_sz);
64 			break;
65 		case HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT:
66 			data_ptr += sizeof(u32);
67 			profile_level = (struct hfi_profile_level *)data_ptr;
68 			event.profile = profile_level->profile;
69 			event.level = profile_level->level;
70 			data_ptr += sizeof(profile_level);
71 			break;
72 		default:
73 			break;
74 		}
75 		num_properties_changed--;
76 	} while (num_properties_changed > 0);
77 
78 done:
79 	inst->ops->event_notify(inst, EVT_SYS_EVENT_CHANGE, &event);
80 }
81 
82 static void event_release_buffer_ref(struct venus_core *core,
83 				     struct venus_inst *inst,
84 				     struct hfi_msg_event_notify_pkt *pkt)
85 {
86 	struct hfi_event_data event = {0};
87 	struct hfi_msg_event_release_buffer_ref_pkt *data;
88 
89 	data = (struct hfi_msg_event_release_buffer_ref_pkt *)
90 		pkt->ext_event_data;
91 
92 	event.event_type = HFI_EVENT_RELEASE_BUFFER_REFERENCE;
93 	event.packet_buffer = data->packet_buffer;
94 	event.extradata_buffer = data->extradata_buffer;
95 	event.tag = data->output_tag;
96 
97 	inst->error = HFI_ERR_NONE;
98 	inst->ops->event_notify(inst, EVT_SYS_EVENT_CHANGE, &event);
99 }
100 
101 static void event_sys_error(struct venus_core *core, u32 event,
102 			    struct hfi_msg_event_notify_pkt *pkt)
103 {
104 	if (pkt)
105 		dev_dbg(core->dev,
106 			"sys error (session id:%x, data1:%x, data2:%x)\n",
107 			pkt->shdr.session_id, pkt->event_data1,
108 			pkt->event_data2);
109 
110 	core->core_ops->event_notify(core, event);
111 }
112 
113 static void
114 event_session_error(struct venus_core *core, struct venus_inst *inst,
115 		    struct hfi_msg_event_notify_pkt *pkt)
116 {
117 	struct device *dev = core->dev;
118 
119 	dev_dbg(dev, "session error: event id:%x, session id:%x\n",
120 		pkt->event_data1, pkt->shdr.session_id);
121 
122 	if (!inst)
123 		return;
124 
125 	switch (pkt->event_data1) {
126 	/* non fatal session errors */
127 	case HFI_ERR_SESSION_INVALID_SCALE_FACTOR:
128 	case HFI_ERR_SESSION_UNSUPPORT_BUFFERTYPE:
129 	case HFI_ERR_SESSION_UNSUPPORTED_SETTING:
130 	case HFI_ERR_SESSION_UPSCALE_NOT_SUPPORTED:
131 		inst->error = HFI_ERR_NONE;
132 		break;
133 	default:
134 		dev_err(dev, "session error: event id:%x (%x), session id:%x\n",
135 			pkt->event_data1, pkt->event_data2,
136 			pkt->shdr.session_id);
137 
138 		inst->error = pkt->event_data1;
139 		inst->ops->event_notify(inst, EVT_SESSION_ERROR, NULL);
140 		break;
141 	}
142 }
143 
144 static void hfi_event_notify(struct venus_core *core, struct venus_inst *inst,
145 			     void *packet)
146 {
147 	struct hfi_msg_event_notify_pkt *pkt = packet;
148 
149 	if (!packet)
150 		return;
151 
152 	switch (pkt->event_id) {
153 	case HFI_EVENT_SYS_ERROR:
154 		event_sys_error(core, EVT_SYS_ERROR, pkt);
155 		break;
156 	case HFI_EVENT_SESSION_ERROR:
157 		event_session_error(core, inst, pkt);
158 		break;
159 	case HFI_EVENT_SESSION_SEQUENCE_CHANGED:
160 		event_seq_changed(core, inst, pkt);
161 		break;
162 	case HFI_EVENT_RELEASE_BUFFER_REFERENCE:
163 		event_release_buffer_ref(core, inst, pkt);
164 		break;
165 	case HFI_EVENT_SESSION_PROPERTY_CHANGED:
166 		break;
167 	default:
168 		break;
169 	}
170 }
171 
172 static void hfi_sys_init_done(struct venus_core *core, struct venus_inst *inst,
173 			      void *packet)
174 {
175 	struct hfi_msg_sys_init_done_pkt *pkt = packet;
176 	u32 rem_bytes, read_bytes = 0, num_properties;
177 	u32 error, ptype;
178 	u8 *data;
179 
180 	error = pkt->error_type;
181 	if (error != HFI_ERR_NONE)
182 		goto err_no_prop;
183 
184 	num_properties = pkt->num_properties;
185 
186 	if (!num_properties) {
187 		error = HFI_ERR_SYS_INVALID_PARAMETER;
188 		goto err_no_prop;
189 	}
190 
191 	rem_bytes = pkt->hdr.size - sizeof(*pkt) + sizeof(u32);
192 
193 	if (!rem_bytes) {
194 		/* missing property data */
195 		error = HFI_ERR_SYS_INSUFFICIENT_RESOURCES;
196 		goto err_no_prop;
197 	}
198 
199 	data = (u8 *)&pkt->data[0];
200 
201 	if (core->res->hfi_version == HFI_VERSION_3XX)
202 		goto err_no_prop;
203 
204 	while (num_properties && rem_bytes >= sizeof(u32)) {
205 		ptype = *((u32 *)data);
206 		data += sizeof(u32);
207 
208 		switch (ptype) {
209 		case HFI_PROPERTY_PARAM_CODEC_SUPPORTED: {
210 			struct hfi_codec_supported *prop;
211 
212 			prop = (struct hfi_codec_supported *)data;
213 
214 			if (rem_bytes < sizeof(*prop)) {
215 				error = HFI_ERR_SYS_INSUFFICIENT_RESOURCES;
216 				break;
217 			}
218 
219 			read_bytes += sizeof(*prop) + sizeof(u32);
220 			core->dec_codecs = prop->dec_codecs;
221 			core->enc_codecs = prop->enc_codecs;
222 			break;
223 		}
224 		case HFI_PROPERTY_PARAM_MAX_SESSIONS_SUPPORTED: {
225 			struct hfi_max_sessions_supported *prop;
226 
227 			if (rem_bytes < sizeof(*prop)) {
228 				error = HFI_ERR_SYS_INSUFFICIENT_RESOURCES;
229 				break;
230 			}
231 
232 			prop = (struct hfi_max_sessions_supported *)data;
233 			read_bytes += sizeof(*prop) + sizeof(u32);
234 			core->max_sessions_supported = prop->max_sessions;
235 			break;
236 		}
237 		default:
238 			error = HFI_ERR_SYS_INVALID_PARAMETER;
239 			break;
240 		}
241 
242 		if (error)
243 			break;
244 
245 		rem_bytes -= read_bytes;
246 		data += read_bytes;
247 		num_properties--;
248 	}
249 
250 err_no_prop:
251 	core->error = error;
252 	complete(&core->done);
253 }
254 
255 static void
256 sys_get_prop_image_version(struct device *dev,
257 			   struct hfi_msg_sys_property_info_pkt *pkt)
258 {
259 	int req_bytes;
260 
261 	req_bytes = pkt->hdr.size - sizeof(*pkt);
262 
263 	if (req_bytes < 128 || !pkt->data[1] || pkt->num_properties > 1)
264 		/* bad packet */
265 		return;
266 
267 	dev_dbg(dev, "F/W version: %s\n", (u8 *)&pkt->data[1]);
268 }
269 
270 static void hfi_sys_property_info(struct venus_core *core,
271 				  struct venus_inst *inst, void *packet)
272 {
273 	struct hfi_msg_sys_property_info_pkt *pkt = packet;
274 	struct device *dev = core->dev;
275 
276 	if (!pkt->num_properties) {
277 		dev_dbg(dev, "%s: no properties\n", __func__);
278 		return;
279 	}
280 
281 	switch (pkt->data[0]) {
282 	case HFI_PROPERTY_SYS_IMAGE_VERSION:
283 		sys_get_prop_image_version(dev, pkt);
284 		break;
285 	default:
286 		dev_dbg(dev, "%s: unknown property data\n", __func__);
287 		break;
288 	}
289 }
290 
291 static void hfi_sys_rel_resource_done(struct venus_core *core,
292 				      struct venus_inst *inst,
293 				      void *packet)
294 {
295 	struct hfi_msg_sys_release_resource_done_pkt *pkt = packet;
296 
297 	core->error = pkt->error_type;
298 	complete(&core->done);
299 }
300 
301 static void hfi_sys_ping_done(struct venus_core *core, struct venus_inst *inst,
302 			      void *packet)
303 {
304 	struct hfi_msg_sys_ping_ack_pkt *pkt = packet;
305 
306 	core->error = HFI_ERR_NONE;
307 
308 	if (pkt->client_data != 0xbeef)
309 		core->error = HFI_ERR_SYS_FATAL;
310 
311 	complete(&core->done);
312 }
313 
314 static void hfi_sys_idle_done(struct venus_core *core, struct venus_inst *inst,
315 			      void *packet)
316 {
317 	dev_dbg(core->dev, "sys idle\n");
318 }
319 
320 static void hfi_sys_pc_prepare_done(struct venus_core *core,
321 				    struct venus_inst *inst, void *packet)
322 {
323 	struct hfi_msg_sys_pc_prep_done_pkt *pkt = packet;
324 
325 	dev_dbg(core->dev, "pc prepare done (error %x)\n", pkt->error_type);
326 }
327 
328 static void
329 hfi_copy_cap_prop(struct hfi_capability *in, struct venus_inst *inst)
330 {
331 	if (!in || !inst)
332 		return;
333 
334 	switch (in->capability_type) {
335 	case HFI_CAPABILITY_FRAME_WIDTH:
336 		inst->cap_width = *in;
337 		break;
338 	case HFI_CAPABILITY_FRAME_HEIGHT:
339 		inst->cap_height = *in;
340 		break;
341 	case HFI_CAPABILITY_MBS_PER_FRAME:
342 		inst->cap_mbs_per_frame = *in;
343 		break;
344 	case HFI_CAPABILITY_MBS_PER_SECOND:
345 		inst->cap_mbs_per_sec = *in;
346 		break;
347 	case HFI_CAPABILITY_FRAMERATE:
348 		inst->cap_framerate = *in;
349 		break;
350 	case HFI_CAPABILITY_SCALE_X:
351 		inst->cap_scale_x = *in;
352 		break;
353 	case HFI_CAPABILITY_SCALE_Y:
354 		inst->cap_scale_y = *in;
355 		break;
356 	case HFI_CAPABILITY_BITRATE:
357 		inst->cap_bitrate = *in;
358 		break;
359 	case HFI_CAPABILITY_HIER_P_NUM_ENH_LAYERS:
360 		inst->cap_hier_p = *in;
361 		break;
362 	case HFI_CAPABILITY_ENC_LTR_COUNT:
363 		inst->cap_ltr_count = *in;
364 		break;
365 	case HFI_CAPABILITY_CP_OUTPUT2_THRESH:
366 		inst->cap_secure_output2_threshold = *in;
367 		break;
368 	default:
369 		break;
370 	}
371 }
372 
373 static unsigned int
374 session_get_prop_profile_level(struct hfi_msg_session_property_info_pkt *pkt,
375 			       struct hfi_profile_level *profile_level)
376 {
377 	struct hfi_profile_level *hfi;
378 	u32 req_bytes;
379 
380 	req_bytes = pkt->shdr.hdr.size - sizeof(*pkt);
381 
382 	if (!req_bytes || req_bytes % sizeof(struct hfi_profile_level))
383 		/* bad packet */
384 		return HFI_ERR_SESSION_INVALID_PARAMETER;
385 
386 	hfi = (struct hfi_profile_level *)&pkt->data[1];
387 	profile_level->profile = hfi->profile;
388 	profile_level->level = hfi->level;
389 
390 	return HFI_ERR_NONE;
391 }
392 
393 static unsigned int
394 session_get_prop_buf_req(struct hfi_msg_session_property_info_pkt *pkt,
395 			 struct hfi_buffer_requirements *bufreq)
396 {
397 	struct hfi_buffer_requirements *buf_req;
398 	u32 req_bytes;
399 	unsigned int idx = 0;
400 
401 	req_bytes = pkt->shdr.hdr.size - sizeof(*pkt);
402 
403 	if (!req_bytes || req_bytes % sizeof(*buf_req) || !pkt->data[1])
404 		/* bad packet */
405 		return HFI_ERR_SESSION_INVALID_PARAMETER;
406 
407 	buf_req = (struct hfi_buffer_requirements *)&pkt->data[1];
408 	if (!buf_req)
409 		return HFI_ERR_SESSION_INVALID_PARAMETER;
410 
411 	while (req_bytes) {
412 		memcpy(&bufreq[idx], buf_req, sizeof(*bufreq));
413 		idx++;
414 
415 		if (idx > HFI_BUFFER_TYPE_MAX)
416 			return HFI_ERR_SESSION_INVALID_PARAMETER;
417 
418 		req_bytes -= sizeof(struct hfi_buffer_requirements);
419 		buf_req++;
420 	}
421 
422 	return HFI_ERR_NONE;
423 }
424 
425 static void hfi_session_prop_info(struct venus_core *core,
426 				  struct venus_inst *inst, void *packet)
427 {
428 	struct hfi_msg_session_property_info_pkt *pkt = packet;
429 	struct device *dev = core->dev;
430 	union hfi_get_property *hprop = &inst->hprop;
431 	unsigned int error = HFI_ERR_NONE;
432 
433 	if (!pkt->num_properties) {
434 		error = HFI_ERR_SESSION_INVALID_PARAMETER;
435 		dev_err(dev, "%s: no properties\n", __func__);
436 		goto done;
437 	}
438 
439 	switch (pkt->data[0]) {
440 	case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:
441 		memset(hprop->bufreq, 0, sizeof(hprop->bufreq));
442 		error = session_get_prop_buf_req(pkt, hprop->bufreq);
443 		break;
444 	case HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT:
445 		memset(&hprop->profile_level, 0, sizeof(hprop->profile_level));
446 		error = session_get_prop_profile_level(pkt,
447 						       &hprop->profile_level);
448 		break;
449 	case HFI_PROPERTY_CONFIG_VDEC_ENTROPY:
450 		break;
451 	default:
452 		dev_dbg(dev, "%s: unknown property id:%x\n", __func__,
453 			pkt->data[0]);
454 		return;
455 	}
456 
457 done:
458 	inst->error = error;
459 	complete(&inst->done);
460 }
461 
462 static u32 init_done_read_prop(struct venus_core *core, struct venus_inst *inst,
463 			       struct hfi_msg_session_init_done_pkt *pkt)
464 {
465 	struct device *dev = core->dev;
466 	u32 rem_bytes, num_props;
467 	u32 ptype, next_offset = 0;
468 	u32 err;
469 	u8 *data;
470 
471 	rem_bytes = pkt->shdr.hdr.size - sizeof(*pkt) + sizeof(u32);
472 	if (!rem_bytes) {
473 		dev_err(dev, "%s: missing property info\n", __func__);
474 		return HFI_ERR_SESSION_INSUFFICIENT_RESOURCES;
475 	}
476 
477 	err = pkt->error_type;
478 	if (err)
479 		return err;
480 
481 	data = (u8 *)&pkt->data[0];
482 	num_props = pkt->num_properties;
483 
484 	while (err == HFI_ERR_NONE && num_props && rem_bytes >= sizeof(u32)) {
485 		ptype = *((u32 *)data);
486 		next_offset = sizeof(u32);
487 
488 		switch (ptype) {
489 		case HFI_PROPERTY_PARAM_CODEC_MASK_SUPPORTED: {
490 			struct hfi_codec_mask_supported *masks =
491 				(struct hfi_codec_mask_supported *)
492 				(data + next_offset);
493 
494 			next_offset += sizeof(*masks);
495 			num_props--;
496 			break;
497 		}
498 		case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED: {
499 			struct hfi_capabilities *caps;
500 			struct hfi_capability *cap;
501 			u32 num_caps;
502 
503 			if ((rem_bytes - next_offset) < sizeof(*cap)) {
504 				err = HFI_ERR_SESSION_INVALID_PARAMETER;
505 				break;
506 			}
507 
508 			caps = (struct hfi_capabilities *)(data + next_offset);
509 
510 			num_caps = caps->num_capabilities;
511 			cap = &caps->data[0];
512 			next_offset += sizeof(u32);
513 
514 			while (num_caps &&
515 			       (rem_bytes - next_offset) >= sizeof(u32)) {
516 				hfi_copy_cap_prop(cap, inst);
517 				cap++;
518 				next_offset += sizeof(*cap);
519 				num_caps--;
520 			}
521 			num_props--;
522 			break;
523 		}
524 		case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED: {
525 			struct hfi_uncompressed_format_supported *prop =
526 				(struct hfi_uncompressed_format_supported *)
527 				(data + next_offset);
528 			u32 num_fmt_entries;
529 			u8 *fmt;
530 			struct hfi_uncompressed_plane_info *inf;
531 
532 			if ((rem_bytes - next_offset) < sizeof(*prop)) {
533 				err = HFI_ERR_SESSION_INVALID_PARAMETER;
534 				break;
535 			}
536 
537 			num_fmt_entries = prop->format_entries;
538 			next_offset = sizeof(*prop) - sizeof(u32);
539 			fmt = (u8 *)&prop->format_info[0];
540 
541 			dev_dbg(dev, "uncomm format support num entries:%u\n",
542 				num_fmt_entries);
543 
544 			while (num_fmt_entries) {
545 				struct hfi_uncompressed_plane_constraints *cnts;
546 				u32 bytes_to_skip;
547 
548 				inf = (struct hfi_uncompressed_plane_info *)fmt;
549 
550 				if ((rem_bytes - next_offset) < sizeof(*inf)) {
551 					err = HFI_ERR_SESSION_INVALID_PARAMETER;
552 					break;
553 				}
554 
555 				dev_dbg(dev, "plane info: fmt:%x, planes:%x\n",
556 					inf->format, inf->num_planes);
557 
558 				cnts = &inf->plane_format[0];
559 				dev_dbg(dev, "%u %u %u %u\n",
560 					cnts->stride_multiples,
561 					cnts->max_stride,
562 					cnts->min_plane_buffer_height_multiple,
563 					cnts->buffer_alignment);
564 
565 				bytes_to_skip = sizeof(*inf) - sizeof(*cnts) +
566 						inf->num_planes * sizeof(*cnts);
567 
568 				fmt += bytes_to_skip;
569 				next_offset += bytes_to_skip;
570 				num_fmt_entries--;
571 			}
572 			num_props--;
573 			break;
574 		}
575 		case HFI_PROPERTY_PARAM_PROPERTIES_SUPPORTED: {
576 			struct hfi_properties_supported *prop =
577 				(struct hfi_properties_supported *)
578 				(data + next_offset);
579 
580 			next_offset += sizeof(*prop) - sizeof(u32)
581 					+ prop->num_properties * sizeof(u32);
582 			num_props--;
583 			break;
584 		}
585 		case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED: {
586 			struct hfi_profile_level_supported *prop =
587 				(struct hfi_profile_level_supported *)
588 				(data + next_offset);
589 			struct hfi_profile_level *pl;
590 			unsigned int prop_count = 0;
591 			unsigned int count = 0;
592 			u8 *ptr;
593 
594 			ptr = (u8 *)&prop->profile_level[0];
595 			prop_count = prop->profile_count;
596 
597 			if (prop_count > HFI_MAX_PROFILE_COUNT)
598 				prop_count = HFI_MAX_PROFILE_COUNT;
599 
600 			while (prop_count) {
601 				ptr++;
602 				pl = (struct hfi_profile_level *)ptr;
603 
604 				inst->pl[count].profile = pl->profile;
605 				inst->pl[count].level = pl->level;
606 				prop_count--;
607 				count++;
608 				ptr += sizeof(*pl) / sizeof(u32);
609 			}
610 
611 			inst->pl_count = count;
612 			next_offset += sizeof(*prop) - sizeof(*pl) +
613 				       prop->profile_count * sizeof(*pl);
614 
615 			num_props--;
616 			break;
617 		}
618 		case HFI_PROPERTY_PARAM_INTERLACE_FORMAT_SUPPORTED: {
619 			next_offset +=
620 				sizeof(struct hfi_interlace_format_supported);
621 			num_props--;
622 			break;
623 		}
624 		case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SUPPORTED: {
625 			struct hfi_nal_stream_format *nal =
626 				(struct hfi_nal_stream_format *)
627 				(data + next_offset);
628 			dev_dbg(dev, "NAL format: %x\n", nal->format);
629 			next_offset += sizeof(*nal);
630 			num_props--;
631 			break;
632 		}
633 		case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SELECT: {
634 			next_offset += sizeof(u32);
635 			num_props--;
636 			break;
637 		}
638 		case HFI_PROPERTY_PARAM_MAX_SEQUENCE_HEADER_SIZE: {
639 			u32 *max_seq_sz = (u32 *)(data + next_offset);
640 
641 			dev_dbg(dev, "max seq header sz: %x\n", *max_seq_sz);
642 			next_offset += sizeof(u32);
643 			num_props--;
644 			break;
645 		}
646 		case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {
647 			next_offset += sizeof(struct hfi_intra_refresh);
648 			num_props--;
649 			break;
650 		}
651 		case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE_SUPPORTED: {
652 			struct hfi_buffer_alloc_mode_supported *prop =
653 				(struct hfi_buffer_alloc_mode_supported *)
654 				(data + next_offset);
655 			unsigned int i;
656 
657 			for (i = 0; i < prop->num_entries; i++) {
658 				if (prop->buffer_type == HFI_BUFFER_OUTPUT ||
659 				    prop->buffer_type == HFI_BUFFER_OUTPUT2) {
660 					switch (prop->data[i]) {
661 					case HFI_BUFFER_MODE_STATIC:
662 						inst->cap_bufs_mode_static = true;
663 						break;
664 					case HFI_BUFFER_MODE_DYNAMIC:
665 						inst->cap_bufs_mode_dynamic = true;
666 						break;
667 					default:
668 						break;
669 					}
670 				}
671 			}
672 			next_offset += sizeof(*prop) -
673 				sizeof(u32) + prop->num_entries * sizeof(u32);
674 			num_props--;
675 			break;
676 		}
677 		default:
678 			dev_dbg(dev, "%s: default case %#x\n", __func__, ptype);
679 			break;
680 		}
681 
682 		rem_bytes -= next_offset;
683 		data += next_offset;
684 	}
685 
686 	return err;
687 }
688 
689 static void hfi_session_init_done(struct venus_core *core,
690 				  struct venus_inst *inst, void *packet)
691 {
692 	struct hfi_msg_session_init_done_pkt *pkt = packet;
693 	unsigned int error;
694 
695 	error = pkt->error_type;
696 	if (error != HFI_ERR_NONE)
697 		goto done;
698 
699 	if (core->res->hfi_version != HFI_VERSION_1XX)
700 		goto done;
701 
702 	error = init_done_read_prop(core, inst, pkt);
703 
704 done:
705 	inst->error = error;
706 	complete(&inst->done);
707 }
708 
709 static void hfi_session_load_res_done(struct venus_core *core,
710 				      struct venus_inst *inst, void *packet)
711 {
712 	struct hfi_msg_session_load_resources_done_pkt *pkt = packet;
713 
714 	inst->error = pkt->error_type;
715 	complete(&inst->done);
716 }
717 
718 static void hfi_session_flush_done(struct venus_core *core,
719 				   struct venus_inst *inst, void *packet)
720 {
721 	struct hfi_msg_session_flush_done_pkt *pkt = packet;
722 
723 	inst->error = pkt->error_type;
724 	complete(&inst->done);
725 }
726 
727 static void hfi_session_etb_done(struct venus_core *core,
728 				 struct venus_inst *inst, void *packet)
729 {
730 	struct hfi_msg_session_empty_buffer_done_pkt *pkt = packet;
731 
732 	inst->error = pkt->error_type;
733 	inst->ops->buf_done(inst, HFI_BUFFER_INPUT, pkt->input_tag,
734 			    pkt->filled_len, pkt->offset, 0, 0, 0);
735 }
736 
737 static void hfi_session_ftb_done(struct venus_core *core,
738 				 struct venus_inst *inst, void *packet)
739 {
740 	u32 session_type = inst->session_type;
741 	u64 timestamp_us = 0;
742 	u32 timestamp_hi = 0, timestamp_lo = 0;
743 	unsigned int error;
744 	u32 flags = 0, hfi_flags = 0, offset = 0, filled_len = 0;
745 	u32 pic_type = 0, buffer_type = 0, output_tag = -1;
746 
747 	if (session_type == VIDC_SESSION_TYPE_ENC) {
748 		struct hfi_msg_session_fbd_compressed_pkt *pkt = packet;
749 
750 		timestamp_hi = pkt->time_stamp_hi;
751 		timestamp_lo = pkt->time_stamp_lo;
752 		hfi_flags = pkt->flags;
753 		offset = pkt->offset;
754 		filled_len = pkt->filled_len;
755 		pic_type = pkt->picture_type;
756 		output_tag = pkt->output_tag;
757 		buffer_type = HFI_BUFFER_OUTPUT;
758 
759 		error = pkt->error_type;
760 	} else if (session_type == VIDC_SESSION_TYPE_DEC) {
761 		struct hfi_msg_session_fbd_uncompressed_plane0_pkt *pkt =
762 			packet;
763 
764 		timestamp_hi = pkt->time_stamp_hi;
765 		timestamp_lo = pkt->time_stamp_lo;
766 		hfi_flags = pkt->flags;
767 		offset = pkt->offset;
768 		filled_len = pkt->filled_len;
769 		pic_type = pkt->picture_type;
770 		output_tag = pkt->output_tag;
771 
772 		if (pkt->stream_id == 0)
773 			buffer_type = HFI_BUFFER_OUTPUT;
774 		else if (pkt->stream_id == 1)
775 			buffer_type = HFI_BUFFER_OUTPUT2;
776 
777 		error = pkt->error_type;
778 	} else {
779 		error = HFI_ERR_SESSION_INVALID_PARAMETER;
780 	}
781 
782 	if (buffer_type != HFI_BUFFER_OUTPUT)
783 		goto done;
784 
785 	if (hfi_flags & HFI_BUFFERFLAG_EOS)
786 		flags |= V4L2_BUF_FLAG_LAST;
787 
788 	switch (pic_type) {
789 	case HFI_PICTURE_IDR:
790 	case HFI_PICTURE_I:
791 		flags |= V4L2_BUF_FLAG_KEYFRAME;
792 		break;
793 	case HFI_PICTURE_P:
794 		flags |= V4L2_BUF_FLAG_PFRAME;
795 		break;
796 	case HFI_PICTURE_B:
797 		flags |= V4L2_BUF_FLAG_BFRAME;
798 		break;
799 	case HFI_FRAME_NOTCODED:
800 	case HFI_UNUSED_PICT:
801 	case HFI_FRAME_YUV:
802 	default:
803 		break;
804 	}
805 
806 	if (!(hfi_flags & HFI_BUFFERFLAG_TIMESTAMPINVALID) && filled_len) {
807 		timestamp_us = timestamp_hi;
808 		timestamp_us = (timestamp_us << 32) | timestamp_lo;
809 	}
810 
811 done:
812 	inst->error = error;
813 	inst->ops->buf_done(inst, buffer_type, output_tag, filled_len,
814 			    offset, flags, hfi_flags, timestamp_us);
815 }
816 
817 static void hfi_session_start_done(struct venus_core *core,
818 				   struct venus_inst *inst, void *packet)
819 {
820 	struct hfi_msg_session_start_done_pkt *pkt = packet;
821 
822 	inst->error = pkt->error_type;
823 	complete(&inst->done);
824 }
825 
826 static void hfi_session_stop_done(struct venus_core *core,
827 				  struct venus_inst *inst, void *packet)
828 {
829 	struct hfi_msg_session_stop_done_pkt *pkt = packet;
830 
831 	inst->error = pkt->error_type;
832 	complete(&inst->done);
833 }
834 
835 static void hfi_session_rel_res_done(struct venus_core *core,
836 				     struct venus_inst *inst, void *packet)
837 {
838 	struct hfi_msg_session_release_resources_done_pkt *pkt = packet;
839 
840 	inst->error = pkt->error_type;
841 	complete(&inst->done);
842 }
843 
844 static void hfi_session_rel_buf_done(struct venus_core *core,
845 				     struct venus_inst *inst, void *packet)
846 {
847 	struct hfi_msg_session_release_buffers_done_pkt *pkt = packet;
848 
849 	inst->error = pkt->error_type;
850 	complete(&inst->done);
851 }
852 
853 static void hfi_session_end_done(struct venus_core *core,
854 				 struct venus_inst *inst, void *packet)
855 {
856 	struct hfi_msg_session_end_done_pkt *pkt = packet;
857 
858 	inst->error = pkt->error_type;
859 	complete(&inst->done);
860 }
861 
862 static void hfi_session_abort_done(struct venus_core *core,
863 				   struct venus_inst *inst, void *packet)
864 {
865 	struct hfi_msg_sys_session_abort_done_pkt *pkt = packet;
866 
867 	inst->error = pkt->error_type;
868 	complete(&inst->done);
869 }
870 
871 static void hfi_session_get_seq_hdr_done(struct venus_core *core,
872 					 struct venus_inst *inst, void *packet)
873 {
874 	struct hfi_msg_session_get_sequence_hdr_done_pkt *pkt = packet;
875 
876 	inst->error = pkt->error_type;
877 	complete(&inst->done);
878 }
879 
880 struct hfi_done_handler {
881 	u32 pkt;
882 	u32 pkt_sz;
883 	u32 pkt_sz2;
884 	void (*done)(struct venus_core *, struct venus_inst *, void *);
885 	bool is_sys_pkt;
886 };
887 
888 static const struct hfi_done_handler handlers[] = {
889 	{.pkt = HFI_MSG_EVENT_NOTIFY,
890 	 .pkt_sz = sizeof(struct hfi_msg_event_notify_pkt),
891 	 .done = hfi_event_notify,
892 	},
893 	{.pkt = HFI_MSG_SYS_INIT,
894 	 .pkt_sz = sizeof(struct hfi_msg_sys_init_done_pkt),
895 	 .done = hfi_sys_init_done,
896 	 .is_sys_pkt = true,
897 	},
898 	{.pkt = HFI_MSG_SYS_PROPERTY_INFO,
899 	 .pkt_sz = sizeof(struct hfi_msg_sys_property_info_pkt),
900 	 .done = hfi_sys_property_info,
901 	 .is_sys_pkt = true,
902 	},
903 	{.pkt = HFI_MSG_SYS_RELEASE_RESOURCE,
904 	 .pkt_sz = sizeof(struct hfi_msg_sys_release_resource_done_pkt),
905 	 .done = hfi_sys_rel_resource_done,
906 	 .is_sys_pkt = true,
907 	},
908 	{.pkt = HFI_MSG_SYS_PING_ACK,
909 	 .pkt_sz = sizeof(struct hfi_msg_sys_ping_ack_pkt),
910 	 .done = hfi_sys_ping_done,
911 	 .is_sys_pkt = true,
912 	},
913 	{.pkt = HFI_MSG_SYS_IDLE,
914 	 .pkt_sz = sizeof(struct hfi_msg_sys_idle_pkt),
915 	 .done = hfi_sys_idle_done,
916 	 .is_sys_pkt = true,
917 	},
918 	{.pkt = HFI_MSG_SYS_PC_PREP,
919 	 .pkt_sz = sizeof(struct hfi_msg_sys_pc_prep_done_pkt),
920 	 .done = hfi_sys_pc_prepare_done,
921 	 .is_sys_pkt = true,
922 	},
923 	{.pkt = HFI_MSG_SYS_SESSION_INIT,
924 	 .pkt_sz = sizeof(struct hfi_msg_session_init_done_pkt),
925 	 .done = hfi_session_init_done,
926 	},
927 	{.pkt = HFI_MSG_SYS_SESSION_END,
928 	 .pkt_sz = sizeof(struct hfi_msg_session_end_done_pkt),
929 	 .done = hfi_session_end_done,
930 	},
931 	{.pkt = HFI_MSG_SESSION_LOAD_RESOURCES,
932 	 .pkt_sz = sizeof(struct hfi_msg_session_load_resources_done_pkt),
933 	 .done = hfi_session_load_res_done,
934 	},
935 	{.pkt = HFI_MSG_SESSION_START,
936 	 .pkt_sz = sizeof(struct hfi_msg_session_start_done_pkt),
937 	 .done = hfi_session_start_done,
938 	},
939 	{.pkt = HFI_MSG_SESSION_STOP,
940 	 .pkt_sz = sizeof(struct hfi_msg_session_stop_done_pkt),
941 	 .done = hfi_session_stop_done,
942 	},
943 	{.pkt = HFI_MSG_SYS_SESSION_ABORT,
944 	 .pkt_sz = sizeof(struct hfi_msg_sys_session_abort_done_pkt),
945 	 .done = hfi_session_abort_done,
946 	},
947 	{.pkt = HFI_MSG_SESSION_EMPTY_BUFFER,
948 	 .pkt_sz = sizeof(struct hfi_msg_session_empty_buffer_done_pkt),
949 	 .done = hfi_session_etb_done,
950 	},
951 	{.pkt = HFI_MSG_SESSION_FILL_BUFFER,
952 	 .pkt_sz = sizeof(struct hfi_msg_session_fbd_uncompressed_plane0_pkt),
953 	 .pkt_sz2 = sizeof(struct hfi_msg_session_fbd_compressed_pkt),
954 	 .done = hfi_session_ftb_done,
955 	},
956 	{.pkt = HFI_MSG_SESSION_FLUSH,
957 	 .pkt_sz = sizeof(struct hfi_msg_session_flush_done_pkt),
958 	 .done = hfi_session_flush_done,
959 	},
960 	{.pkt = HFI_MSG_SESSION_PROPERTY_INFO,
961 	 .pkt_sz = sizeof(struct hfi_msg_session_property_info_pkt),
962 	 .done = hfi_session_prop_info,
963 	},
964 	{.pkt = HFI_MSG_SESSION_RELEASE_RESOURCES,
965 	 .pkt_sz = sizeof(struct hfi_msg_session_release_resources_done_pkt),
966 	 .done = hfi_session_rel_res_done,
967 	},
968 	{.pkt = HFI_MSG_SESSION_GET_SEQUENCE_HEADER,
969 	 .pkt_sz = sizeof(struct hfi_msg_session_get_sequence_hdr_done_pkt),
970 	 .done = hfi_session_get_seq_hdr_done,
971 	},
972 	{.pkt = HFI_MSG_SESSION_RELEASE_BUFFERS,
973 	 .pkt_sz = sizeof(struct hfi_msg_session_release_buffers_done_pkt),
974 	 .done = hfi_session_rel_buf_done,
975 	},
976 };
977 
978 void hfi_process_watchdog_timeout(struct venus_core *core)
979 {
980 	event_sys_error(core, EVT_SYS_WATCHDOG_TIMEOUT, NULL);
981 }
982 
983 static struct venus_inst *to_instance(struct venus_core *core, u32 session_id)
984 {
985 	struct venus_inst *inst;
986 
987 	mutex_lock(&core->lock);
988 	list_for_each_entry(inst, &core->instances, list)
989 		if (hash32_ptr(inst) == session_id) {
990 			mutex_unlock(&core->lock);
991 			return inst;
992 		}
993 	mutex_unlock(&core->lock);
994 
995 	return NULL;
996 }
997 
998 u32 hfi_process_msg_packet(struct venus_core *core, struct hfi_pkt_hdr *hdr)
999 {
1000 	const struct hfi_done_handler *handler;
1001 	struct device *dev = core->dev;
1002 	struct venus_inst *inst;
1003 	bool found = false;
1004 	unsigned int i;
1005 
1006 	for (i = 0; i < ARRAY_SIZE(handlers); i++) {
1007 		handler = &handlers[i];
1008 		if (handler->pkt != hdr->pkt_type)
1009 			continue;
1010 		found = true;
1011 		break;
1012 	}
1013 
1014 	if (!found)
1015 		return hdr->pkt_type;
1016 
1017 	if (hdr->size && hdr->size < handler->pkt_sz &&
1018 	    hdr->size < handler->pkt_sz2) {
1019 		dev_err(dev, "bad packet size (%d should be %d, pkt type:%x)\n",
1020 			hdr->size, handler->pkt_sz, hdr->pkt_type);
1021 
1022 		return hdr->pkt_type;
1023 	}
1024 
1025 	if (handler->is_sys_pkt) {
1026 		inst = NULL;
1027 	} else {
1028 		struct hfi_session_pkt *pkt;
1029 
1030 		pkt = (struct hfi_session_pkt *)hdr;
1031 		inst = to_instance(core, pkt->shdr.session_id);
1032 
1033 		if (!inst)
1034 			dev_warn(dev, "no valid instance(pkt session_id:%x, pkt:%x)\n",
1035 				 pkt->shdr.session_id,
1036 				 handler ? handler->pkt : 0);
1037 
1038 		/*
1039 		 * Event of type HFI_EVENT_SYS_ERROR will not have any session
1040 		 * associated with it
1041 		 */
1042 		if (!inst && hdr->pkt_type != HFI_MSG_EVENT_NOTIFY) {
1043 			dev_err(dev, "got invalid session id:%x\n",
1044 				pkt->shdr.session_id);
1045 			goto invalid_session;
1046 		}
1047 	}
1048 
1049 	handler->done(core, inst, hdr);
1050 
1051 invalid_session:
1052 	return hdr->pkt_type;
1053 }
1054