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/clk.h>
16 #include <linux/list.h>
17 #include <linux/mutex.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/slab.h>
20 #include <media/videobuf2-dma-sg.h>
21 #include <media/v4l2-mem2mem.h>
22 #include <asm/div64.h>
23 
24 #include "core.h"
25 #include "helpers.h"
26 #include "hfi_helper.h"
27 
28 struct intbuf {
29 	struct list_head list;
30 	u32 type;
31 	size_t size;
32 	void *va;
33 	dma_addr_t da;
34 	unsigned long attrs;
35 };
36 
37 bool venus_helper_check_codec(struct venus_inst *inst, u32 v4l2_pixfmt)
38 {
39 	struct venus_core *core = inst->core;
40 	u32 session_type = inst->session_type;
41 	u32 codec;
42 
43 	switch (v4l2_pixfmt) {
44 	case V4L2_PIX_FMT_H264:
45 		codec = HFI_VIDEO_CODEC_H264;
46 		break;
47 	case V4L2_PIX_FMT_H263:
48 		codec = HFI_VIDEO_CODEC_H263;
49 		break;
50 	case V4L2_PIX_FMT_MPEG1:
51 		codec = HFI_VIDEO_CODEC_MPEG1;
52 		break;
53 	case V4L2_PIX_FMT_MPEG2:
54 		codec = HFI_VIDEO_CODEC_MPEG2;
55 		break;
56 	case V4L2_PIX_FMT_MPEG4:
57 		codec = HFI_VIDEO_CODEC_MPEG4;
58 		break;
59 	case V4L2_PIX_FMT_VC1_ANNEX_G:
60 	case V4L2_PIX_FMT_VC1_ANNEX_L:
61 		codec = HFI_VIDEO_CODEC_VC1;
62 		break;
63 	case V4L2_PIX_FMT_VP8:
64 		codec = HFI_VIDEO_CODEC_VP8;
65 		break;
66 	case V4L2_PIX_FMT_VP9:
67 		codec = HFI_VIDEO_CODEC_VP9;
68 		break;
69 	case V4L2_PIX_FMT_XVID:
70 		codec = HFI_VIDEO_CODEC_DIVX;
71 		break;
72 	default:
73 		return false;
74 	}
75 
76 	if (session_type == VIDC_SESSION_TYPE_ENC && core->enc_codecs & codec)
77 		return true;
78 
79 	if (session_type == VIDC_SESSION_TYPE_DEC && core->dec_codecs & codec)
80 		return true;
81 
82 	return false;
83 }
84 EXPORT_SYMBOL_GPL(venus_helper_check_codec);
85 
86 static int intbufs_set_buffer(struct venus_inst *inst, u32 type)
87 {
88 	struct venus_core *core = inst->core;
89 	struct device *dev = core->dev;
90 	struct hfi_buffer_requirements bufreq;
91 	struct hfi_buffer_desc bd;
92 	struct intbuf *buf;
93 	unsigned int i;
94 	int ret;
95 
96 	ret = venus_helper_get_bufreq(inst, type, &bufreq);
97 	if (ret)
98 		return 0;
99 
100 	if (!bufreq.size)
101 		return 0;
102 
103 	for (i = 0; i < bufreq.count_actual; i++) {
104 		buf = kzalloc(sizeof(*buf), GFP_KERNEL);
105 		if (!buf) {
106 			ret = -ENOMEM;
107 			goto fail;
108 		}
109 
110 		buf->type = bufreq.type;
111 		buf->size = bufreq.size;
112 		buf->attrs = DMA_ATTR_WRITE_COMBINE |
113 			     DMA_ATTR_NO_KERNEL_MAPPING;
114 		buf->va = dma_alloc_attrs(dev, buf->size, &buf->da, GFP_KERNEL,
115 					  buf->attrs);
116 		if (!buf->va) {
117 			ret = -ENOMEM;
118 			goto fail;
119 		}
120 
121 		memset(&bd, 0, sizeof(bd));
122 		bd.buffer_size = buf->size;
123 		bd.buffer_type = buf->type;
124 		bd.num_buffers = 1;
125 		bd.device_addr = buf->da;
126 
127 		ret = hfi_session_set_buffers(inst, &bd);
128 		if (ret) {
129 			dev_err(dev, "set session buffers failed\n");
130 			goto dma_free;
131 		}
132 
133 		list_add_tail(&buf->list, &inst->internalbufs);
134 	}
135 
136 	return 0;
137 
138 dma_free:
139 	dma_free_attrs(dev, buf->size, buf->va, buf->da, buf->attrs);
140 fail:
141 	kfree(buf);
142 	return ret;
143 }
144 
145 static int intbufs_unset_buffers(struct venus_inst *inst)
146 {
147 	struct hfi_buffer_desc bd = {0};
148 	struct intbuf *buf, *n;
149 	int ret = 0;
150 
151 	list_for_each_entry_safe(buf, n, &inst->internalbufs, list) {
152 		bd.buffer_size = buf->size;
153 		bd.buffer_type = buf->type;
154 		bd.num_buffers = 1;
155 		bd.device_addr = buf->da;
156 		bd.response_required = true;
157 
158 		ret = hfi_session_unset_buffers(inst, &bd);
159 
160 		list_del_init(&buf->list);
161 		dma_free_attrs(inst->core->dev, buf->size, buf->va, buf->da,
162 			       buf->attrs);
163 		kfree(buf);
164 	}
165 
166 	return ret;
167 }
168 
169 static const unsigned int intbuf_types[] = {
170 	HFI_BUFFER_INTERNAL_SCRATCH,
171 	HFI_BUFFER_INTERNAL_SCRATCH_1,
172 	HFI_BUFFER_INTERNAL_SCRATCH_2,
173 	HFI_BUFFER_INTERNAL_PERSIST,
174 	HFI_BUFFER_INTERNAL_PERSIST_1,
175 };
176 
177 static int intbufs_alloc(struct venus_inst *inst)
178 {
179 	unsigned int i;
180 	int ret;
181 
182 	for (i = 0; i < ARRAY_SIZE(intbuf_types); i++) {
183 		ret = intbufs_set_buffer(inst, intbuf_types[i]);
184 		if (ret)
185 			goto error;
186 	}
187 
188 	return 0;
189 
190 error:
191 	intbufs_unset_buffers(inst);
192 	return ret;
193 }
194 
195 static int intbufs_free(struct venus_inst *inst)
196 {
197 	return intbufs_unset_buffers(inst);
198 }
199 
200 static u32 load_per_instance(struct venus_inst *inst)
201 {
202 	u32 mbs;
203 
204 	if (!inst || !(inst->state >= INST_INIT && inst->state < INST_STOP))
205 		return 0;
206 
207 	mbs = (ALIGN(inst->width, 16) / 16) * (ALIGN(inst->height, 16) / 16);
208 
209 	return mbs * inst->fps;
210 }
211 
212 static u32 load_per_type(struct venus_core *core, u32 session_type)
213 {
214 	struct venus_inst *inst = NULL;
215 	u32 mbs_per_sec = 0;
216 
217 	mutex_lock(&core->lock);
218 	list_for_each_entry(inst, &core->instances, list) {
219 		if (inst->session_type != session_type)
220 			continue;
221 
222 		mbs_per_sec += load_per_instance(inst);
223 	}
224 	mutex_unlock(&core->lock);
225 
226 	return mbs_per_sec;
227 }
228 
229 static int load_scale_clocks(struct venus_core *core)
230 {
231 	const struct freq_tbl *table = core->res->freq_tbl;
232 	unsigned int num_rows = core->res->freq_tbl_size;
233 	unsigned long freq = table[0].freq;
234 	struct clk *clk = core->clks[0];
235 	struct device *dev = core->dev;
236 	u32 mbs_per_sec;
237 	unsigned int i;
238 	int ret;
239 
240 	mbs_per_sec = load_per_type(core, VIDC_SESSION_TYPE_ENC) +
241 		      load_per_type(core, VIDC_SESSION_TYPE_DEC);
242 
243 	if (mbs_per_sec > core->res->max_load)
244 		dev_warn(dev, "HW is overloaded, needed: %d max: %d\n",
245 			 mbs_per_sec, core->res->max_load);
246 
247 	if (!mbs_per_sec && num_rows > 1) {
248 		freq = table[num_rows - 1].freq;
249 		goto set_freq;
250 	}
251 
252 	for (i = 0; i < num_rows; i++) {
253 		if (mbs_per_sec > table[i].load)
254 			break;
255 		freq = table[i].freq;
256 	}
257 
258 set_freq:
259 
260 	if (core->res->hfi_version == HFI_VERSION_3XX) {
261 		ret = clk_set_rate(clk, freq);
262 		ret |= clk_set_rate(core->core0_clk, freq);
263 		ret |= clk_set_rate(core->core1_clk, freq);
264 	} else {
265 		ret = clk_set_rate(clk, freq);
266 	}
267 
268 	if (ret) {
269 		dev_err(dev, "failed to set clock rate %lu (%d)\n", freq, ret);
270 		return ret;
271 	}
272 
273 	return 0;
274 }
275 
276 static void fill_buffer_desc(const struct venus_buffer *buf,
277 			     struct hfi_buffer_desc *bd, bool response)
278 {
279 	memset(bd, 0, sizeof(*bd));
280 	bd->buffer_type = HFI_BUFFER_OUTPUT;
281 	bd->buffer_size = buf->size;
282 	bd->num_buffers = 1;
283 	bd->device_addr = buf->dma_addr;
284 	bd->response_required = response;
285 }
286 
287 static void return_buf_error(struct venus_inst *inst,
288 			     struct vb2_v4l2_buffer *vbuf)
289 {
290 	struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
291 
292 	if (vbuf->vb2_buf.type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
293 		v4l2_m2m_src_buf_remove_by_buf(m2m_ctx, vbuf);
294 	else
295 		v4l2_m2m_dst_buf_remove_by_buf(m2m_ctx, vbuf);
296 
297 	v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
298 }
299 
300 static int
301 session_process_buf(struct venus_inst *inst, struct vb2_v4l2_buffer *vbuf)
302 {
303 	struct venus_buffer *buf = to_venus_buffer(vbuf);
304 	struct vb2_buffer *vb = &vbuf->vb2_buf;
305 	unsigned int type = vb->type;
306 	struct hfi_frame_data fdata;
307 	int ret;
308 
309 	memset(&fdata, 0, sizeof(fdata));
310 	fdata.alloc_len = buf->size;
311 	fdata.device_addr = buf->dma_addr;
312 	fdata.timestamp = vb->timestamp;
313 	do_div(fdata.timestamp, NSEC_PER_USEC);
314 	fdata.flags = 0;
315 	fdata.clnt_data = vbuf->vb2_buf.index;
316 
317 	if (!fdata.timestamp)
318 		fdata.flags |= HFI_BUFFERFLAG_TIMESTAMPINVALID;
319 
320 	if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
321 		fdata.buffer_type = HFI_BUFFER_INPUT;
322 		fdata.filled_len = vb2_get_plane_payload(vb, 0);
323 		fdata.offset = vb->planes[0].data_offset;
324 
325 		if (vbuf->flags & V4L2_BUF_FLAG_LAST || !fdata.filled_len)
326 			fdata.flags |= HFI_BUFFERFLAG_EOS;
327 	} else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
328 		fdata.buffer_type = HFI_BUFFER_OUTPUT;
329 		fdata.filled_len = 0;
330 		fdata.offset = 0;
331 	}
332 
333 	ret = hfi_session_process_buf(inst, &fdata);
334 	if (ret)
335 		return ret;
336 
337 	return 0;
338 }
339 
340 static inline int is_reg_unreg_needed(struct venus_inst *inst)
341 {
342 	if (inst->session_type == VIDC_SESSION_TYPE_DEC &&
343 	    inst->core->res->hfi_version == HFI_VERSION_3XX)
344 		return 0;
345 
346 	if (inst->session_type == VIDC_SESSION_TYPE_DEC &&
347 	    inst->cap_bufs_mode_dynamic &&
348 	    inst->core->res->hfi_version == HFI_VERSION_1XX)
349 		return 0;
350 
351 	return 1;
352 }
353 
354 static int session_unregister_bufs(struct venus_inst *inst)
355 {
356 	struct venus_buffer *buf, *n;
357 	struct hfi_buffer_desc bd;
358 	int ret = 0;
359 
360 	if (!is_reg_unreg_needed(inst))
361 		return 0;
362 
363 	list_for_each_entry_safe(buf, n, &inst->registeredbufs, reg_list) {
364 		fill_buffer_desc(buf, &bd, true);
365 		ret = hfi_session_unset_buffers(inst, &bd);
366 		list_del_init(&buf->reg_list);
367 	}
368 
369 	return ret;
370 }
371 
372 static int session_register_bufs(struct venus_inst *inst)
373 {
374 	struct venus_core *core = inst->core;
375 	struct device *dev = core->dev;
376 	struct hfi_buffer_desc bd;
377 	struct venus_buffer *buf;
378 	int ret = 0;
379 
380 	if (!is_reg_unreg_needed(inst))
381 		return 0;
382 
383 	list_for_each_entry(buf, &inst->registeredbufs, reg_list) {
384 		fill_buffer_desc(buf, &bd, false);
385 		ret = hfi_session_set_buffers(inst, &bd);
386 		if (ret) {
387 			dev_err(dev, "%s: set buffer failed\n", __func__);
388 			break;
389 		}
390 	}
391 
392 	return ret;
393 }
394 
395 int venus_helper_get_bufreq(struct venus_inst *inst, u32 type,
396 			    struct hfi_buffer_requirements *req)
397 {
398 	u32 ptype = HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS;
399 	union hfi_get_property hprop;
400 	unsigned int i;
401 	int ret;
402 
403 	if (req)
404 		memset(req, 0, sizeof(*req));
405 
406 	ret = hfi_session_get_property(inst, ptype, &hprop);
407 	if (ret)
408 		return ret;
409 
410 	ret = -EINVAL;
411 
412 	for (i = 0; i < HFI_BUFFER_TYPE_MAX; i++) {
413 		if (hprop.bufreq[i].type != type)
414 			continue;
415 
416 		if (req)
417 			memcpy(req, &hprop.bufreq[i], sizeof(*req));
418 		ret = 0;
419 		break;
420 	}
421 
422 	return ret;
423 }
424 EXPORT_SYMBOL_GPL(venus_helper_get_bufreq);
425 
426 int venus_helper_set_input_resolution(struct venus_inst *inst,
427 				      unsigned int width, unsigned int height)
428 {
429 	u32 ptype = HFI_PROPERTY_PARAM_FRAME_SIZE;
430 	struct hfi_framesize fs;
431 
432 	fs.buffer_type = HFI_BUFFER_INPUT;
433 	fs.width = width;
434 	fs.height = height;
435 
436 	return hfi_session_set_property(inst, ptype, &fs);
437 }
438 EXPORT_SYMBOL_GPL(venus_helper_set_input_resolution);
439 
440 int venus_helper_set_output_resolution(struct venus_inst *inst,
441 				       unsigned int width, unsigned int height)
442 {
443 	u32 ptype = HFI_PROPERTY_PARAM_FRAME_SIZE;
444 	struct hfi_framesize fs;
445 
446 	fs.buffer_type = HFI_BUFFER_OUTPUT;
447 	fs.width = width;
448 	fs.height = height;
449 
450 	return hfi_session_set_property(inst, ptype, &fs);
451 }
452 EXPORT_SYMBOL_GPL(venus_helper_set_output_resolution);
453 
454 int venus_helper_set_num_bufs(struct venus_inst *inst, unsigned int input_bufs,
455 			      unsigned int output_bufs)
456 {
457 	u32 ptype = HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL;
458 	struct hfi_buffer_count_actual buf_count;
459 	int ret;
460 
461 	buf_count.type = HFI_BUFFER_INPUT;
462 	buf_count.count_actual = input_bufs;
463 
464 	ret = hfi_session_set_property(inst, ptype, &buf_count);
465 	if (ret)
466 		return ret;
467 
468 	buf_count.type = HFI_BUFFER_OUTPUT;
469 	buf_count.count_actual = output_bufs;
470 
471 	return hfi_session_set_property(inst, ptype, &buf_count);
472 }
473 EXPORT_SYMBOL_GPL(venus_helper_set_num_bufs);
474 
475 int venus_helper_set_color_format(struct venus_inst *inst, u32 pixfmt)
476 {
477 	struct hfi_uncompressed_format_select fmt;
478 	u32 ptype = HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT;
479 	int ret;
480 
481 	if (inst->session_type == VIDC_SESSION_TYPE_DEC)
482 		fmt.buffer_type = HFI_BUFFER_OUTPUT;
483 	else if (inst->session_type == VIDC_SESSION_TYPE_ENC)
484 		fmt.buffer_type = HFI_BUFFER_INPUT;
485 	else
486 		return -EINVAL;
487 
488 	switch (pixfmt) {
489 	case V4L2_PIX_FMT_NV12:
490 		fmt.format = HFI_COLOR_FORMAT_NV12;
491 		break;
492 	case V4L2_PIX_FMT_NV21:
493 		fmt.format = HFI_COLOR_FORMAT_NV21;
494 		break;
495 	default:
496 		return -EINVAL;
497 	}
498 
499 	ret = hfi_session_set_property(inst, ptype, &fmt);
500 	if (ret)
501 		return ret;
502 
503 	return 0;
504 }
505 EXPORT_SYMBOL_GPL(venus_helper_set_color_format);
506 
507 static void delayed_process_buf_func(struct work_struct *work)
508 {
509 	struct venus_buffer *buf, *n;
510 	struct venus_inst *inst;
511 	int ret;
512 
513 	inst = container_of(work, struct venus_inst, delayed_process_work);
514 
515 	mutex_lock(&inst->lock);
516 
517 	if (!(inst->streamon_out & inst->streamon_cap))
518 		goto unlock;
519 
520 	list_for_each_entry_safe(buf, n, &inst->delayed_process, ref_list) {
521 		if (buf->flags & HFI_BUFFERFLAG_READONLY)
522 			continue;
523 
524 		ret = session_process_buf(inst, &buf->vb);
525 		if (ret)
526 			return_buf_error(inst, &buf->vb);
527 
528 		list_del_init(&buf->ref_list);
529 	}
530 unlock:
531 	mutex_unlock(&inst->lock);
532 }
533 
534 void venus_helper_release_buf_ref(struct venus_inst *inst, unsigned int idx)
535 {
536 	struct venus_buffer *buf;
537 
538 	list_for_each_entry(buf, &inst->registeredbufs, reg_list) {
539 		if (buf->vb.vb2_buf.index == idx) {
540 			buf->flags &= ~HFI_BUFFERFLAG_READONLY;
541 			schedule_work(&inst->delayed_process_work);
542 			break;
543 		}
544 	}
545 }
546 EXPORT_SYMBOL_GPL(venus_helper_release_buf_ref);
547 
548 void venus_helper_acquire_buf_ref(struct vb2_v4l2_buffer *vbuf)
549 {
550 	struct venus_buffer *buf = to_venus_buffer(vbuf);
551 
552 	buf->flags |= HFI_BUFFERFLAG_READONLY;
553 }
554 EXPORT_SYMBOL_GPL(venus_helper_acquire_buf_ref);
555 
556 static int is_buf_refed(struct venus_inst *inst, struct vb2_v4l2_buffer *vbuf)
557 {
558 	struct venus_buffer *buf = to_venus_buffer(vbuf);
559 
560 	if (buf->flags & HFI_BUFFERFLAG_READONLY) {
561 		list_add_tail(&buf->ref_list, &inst->delayed_process);
562 		schedule_work(&inst->delayed_process_work);
563 		return 1;
564 	}
565 
566 	return 0;
567 }
568 
569 struct vb2_v4l2_buffer *
570 venus_helper_find_buf(struct venus_inst *inst, unsigned int type, u32 idx)
571 {
572 	struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
573 
574 	if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
575 		return v4l2_m2m_src_buf_remove_by_idx(m2m_ctx, idx);
576 	else
577 		return v4l2_m2m_dst_buf_remove_by_idx(m2m_ctx, idx);
578 }
579 EXPORT_SYMBOL_GPL(venus_helper_find_buf);
580 
581 int venus_helper_vb2_buf_init(struct vb2_buffer *vb)
582 {
583 	struct venus_inst *inst = vb2_get_drv_priv(vb->vb2_queue);
584 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
585 	struct venus_buffer *buf = to_venus_buffer(vbuf);
586 	struct sg_table *sgt;
587 
588 	sgt = vb2_dma_sg_plane_desc(vb, 0);
589 	if (!sgt)
590 		return -EFAULT;
591 
592 	buf->size = vb2_plane_size(vb, 0);
593 	buf->dma_addr = sg_dma_address(sgt->sgl);
594 
595 	if (vb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
596 		list_add_tail(&buf->reg_list, &inst->registeredbufs);
597 
598 	return 0;
599 }
600 EXPORT_SYMBOL_GPL(venus_helper_vb2_buf_init);
601 
602 int venus_helper_vb2_buf_prepare(struct vb2_buffer *vb)
603 {
604 	struct venus_inst *inst = vb2_get_drv_priv(vb->vb2_queue);
605 
606 	if (vb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE &&
607 	    vb2_plane_size(vb, 0) < inst->output_buf_size)
608 		return -EINVAL;
609 	if (vb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE &&
610 	    vb2_plane_size(vb, 0) < inst->input_buf_size)
611 		return -EINVAL;
612 
613 	return 0;
614 }
615 EXPORT_SYMBOL_GPL(venus_helper_vb2_buf_prepare);
616 
617 void venus_helper_vb2_buf_queue(struct vb2_buffer *vb)
618 {
619 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
620 	struct venus_inst *inst = vb2_get_drv_priv(vb->vb2_queue);
621 	struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
622 	int ret;
623 
624 	mutex_lock(&inst->lock);
625 
626 	v4l2_m2m_buf_queue(m2m_ctx, vbuf);
627 
628 	if (!(inst->streamon_out & inst->streamon_cap))
629 		goto unlock;
630 
631 	ret = is_buf_refed(inst, vbuf);
632 	if (ret)
633 		goto unlock;
634 
635 	ret = session_process_buf(inst, vbuf);
636 	if (ret)
637 		return_buf_error(inst, vbuf);
638 
639 unlock:
640 	mutex_unlock(&inst->lock);
641 }
642 EXPORT_SYMBOL_GPL(venus_helper_vb2_buf_queue);
643 
644 void venus_helper_buffers_done(struct venus_inst *inst,
645 			       enum vb2_buffer_state state)
646 {
647 	struct vb2_v4l2_buffer *buf;
648 
649 	while ((buf = v4l2_m2m_src_buf_remove(inst->m2m_ctx)))
650 		v4l2_m2m_buf_done(buf, state);
651 	while ((buf = v4l2_m2m_dst_buf_remove(inst->m2m_ctx)))
652 		v4l2_m2m_buf_done(buf, state);
653 }
654 EXPORT_SYMBOL_GPL(venus_helper_buffers_done);
655 
656 void venus_helper_vb2_stop_streaming(struct vb2_queue *q)
657 {
658 	struct venus_inst *inst = vb2_get_drv_priv(q);
659 	struct venus_core *core = inst->core;
660 	int ret;
661 
662 	mutex_lock(&inst->lock);
663 
664 	if (inst->streamon_out & inst->streamon_cap) {
665 		ret = hfi_session_stop(inst);
666 		ret |= hfi_session_unload_res(inst);
667 		ret |= session_unregister_bufs(inst);
668 		ret |= intbufs_free(inst);
669 		ret |= hfi_session_deinit(inst);
670 
671 		if (inst->session_error || core->sys_error)
672 			ret = -EIO;
673 
674 		if (ret)
675 			hfi_session_abort(inst);
676 
677 		load_scale_clocks(core);
678 		INIT_LIST_HEAD(&inst->registeredbufs);
679 	}
680 
681 	venus_helper_buffers_done(inst, VB2_BUF_STATE_ERROR);
682 
683 	if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
684 		inst->streamon_out = 0;
685 	else
686 		inst->streamon_cap = 0;
687 
688 	mutex_unlock(&inst->lock);
689 }
690 EXPORT_SYMBOL_GPL(venus_helper_vb2_stop_streaming);
691 
692 int venus_helper_vb2_start_streaming(struct venus_inst *inst)
693 {
694 	struct venus_core *core = inst->core;
695 	int ret;
696 
697 	ret = intbufs_alloc(inst);
698 	if (ret)
699 		return ret;
700 
701 	ret = session_register_bufs(inst);
702 	if (ret)
703 		goto err_bufs_free;
704 
705 	load_scale_clocks(core);
706 
707 	ret = hfi_session_load_res(inst);
708 	if (ret)
709 		goto err_unreg_bufs;
710 
711 	ret = hfi_session_start(inst);
712 	if (ret)
713 		goto err_unload_res;
714 
715 	return 0;
716 
717 err_unload_res:
718 	hfi_session_unload_res(inst);
719 err_unreg_bufs:
720 	session_unregister_bufs(inst);
721 err_bufs_free:
722 	intbufs_free(inst);
723 	return ret;
724 }
725 EXPORT_SYMBOL_GPL(venus_helper_vb2_start_streaming);
726 
727 void venus_helper_m2m_device_run(void *priv)
728 {
729 	struct venus_inst *inst = priv;
730 	struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx;
731 	struct v4l2_m2m_buffer *buf, *n;
732 	int ret;
733 
734 	mutex_lock(&inst->lock);
735 
736 	v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, buf, n) {
737 		ret = session_process_buf(inst, &buf->vb);
738 		if (ret)
739 			return_buf_error(inst, &buf->vb);
740 	}
741 
742 	v4l2_m2m_for_each_src_buf_safe(m2m_ctx, buf, n) {
743 		ret = session_process_buf(inst, &buf->vb);
744 		if (ret)
745 			return_buf_error(inst, &buf->vb);
746 	}
747 
748 	mutex_unlock(&inst->lock);
749 }
750 EXPORT_SYMBOL_GPL(venus_helper_m2m_device_run);
751 
752 void venus_helper_m2m_job_abort(void *priv)
753 {
754 	struct venus_inst *inst = priv;
755 
756 	v4l2_m2m_job_finish(inst->m2m_dev, inst->m2m_ctx);
757 }
758 EXPORT_SYMBOL_GPL(venus_helper_m2m_job_abort);
759 
760 void venus_helper_init_instance(struct venus_inst *inst)
761 {
762 	if (inst->session_type == VIDC_SESSION_TYPE_DEC) {
763 		INIT_LIST_HEAD(&inst->delayed_process);
764 		INIT_WORK(&inst->delayed_process_work,
765 			  delayed_process_buf_func);
766 	}
767 }
768 EXPORT_SYMBOL_GPL(venus_helper_init_instance);
769