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/slab.h>
7 #include <linux/mutex.h>
8 #include <linux/list.h>
9 #include <linux/completion.h>
10 #include <linux/platform_device.h>
11 #include <linux/videodev2.h>
12 
13 #include "core.h"
14 #include "hfi.h"
15 #include "hfi_cmds.h"
16 #include "hfi_venus.h"
17 
18 #define TIMEOUT		msecs_to_jiffies(1000)
19 
20 static u32 to_codec_type(u32 pixfmt)
21 {
22 	switch (pixfmt) {
23 	case V4L2_PIX_FMT_H264:
24 	case V4L2_PIX_FMT_H264_NO_SC:
25 		return HFI_VIDEO_CODEC_H264;
26 	case V4L2_PIX_FMT_H263:
27 		return HFI_VIDEO_CODEC_H263;
28 	case V4L2_PIX_FMT_MPEG1:
29 		return HFI_VIDEO_CODEC_MPEG1;
30 	case V4L2_PIX_FMT_MPEG2:
31 		return HFI_VIDEO_CODEC_MPEG2;
32 	case V4L2_PIX_FMT_MPEG4:
33 		return HFI_VIDEO_CODEC_MPEG4;
34 	case V4L2_PIX_FMT_VC1_ANNEX_G:
35 	case V4L2_PIX_FMT_VC1_ANNEX_L:
36 		return HFI_VIDEO_CODEC_VC1;
37 	case V4L2_PIX_FMT_VP8:
38 		return HFI_VIDEO_CODEC_VP8;
39 	case V4L2_PIX_FMT_VP9:
40 		return HFI_VIDEO_CODEC_VP9;
41 	case V4L2_PIX_FMT_XVID:
42 		return HFI_VIDEO_CODEC_DIVX;
43 	case V4L2_PIX_FMT_HEVC:
44 		return HFI_VIDEO_CODEC_HEVC;
45 	default:
46 		return 0;
47 	}
48 }
49 
50 int hfi_core_init(struct venus_core *core)
51 {
52 	int ret = 0;
53 
54 	mutex_lock(&core->lock);
55 
56 	if (core->state >= CORE_INIT)
57 		goto unlock;
58 
59 	reinit_completion(&core->done);
60 
61 	ret = core->ops->core_init(core);
62 	if (ret)
63 		goto unlock;
64 
65 	ret = wait_for_completion_timeout(&core->done, TIMEOUT);
66 	if (!ret) {
67 		ret = -ETIMEDOUT;
68 		goto unlock;
69 	}
70 
71 	ret = 0;
72 
73 	if (core->error != HFI_ERR_NONE) {
74 		ret = -EIO;
75 		goto unlock;
76 	}
77 
78 	core->state = CORE_INIT;
79 unlock:
80 	mutex_unlock(&core->lock);
81 	return ret;
82 }
83 
84 int hfi_core_deinit(struct venus_core *core, bool blocking)
85 {
86 	int ret = 0, empty;
87 
88 	mutex_lock(&core->lock);
89 
90 	if (core->state == CORE_UNINIT)
91 		goto unlock;
92 
93 	empty = list_empty(&core->instances);
94 
95 	if (!empty && !blocking) {
96 		ret = -EBUSY;
97 		goto unlock;
98 	}
99 
100 	if (!empty) {
101 		mutex_unlock(&core->lock);
102 		wait_var_event(&core->insts_count,
103 			       !atomic_read(&core->insts_count));
104 		mutex_lock(&core->lock);
105 	}
106 
107 	ret = core->ops->core_deinit(core);
108 
109 	if (!ret)
110 		core->state = CORE_UNINIT;
111 
112 unlock:
113 	mutex_unlock(&core->lock);
114 	return ret;
115 }
116 
117 int hfi_core_suspend(struct venus_core *core)
118 {
119 	if (core->state != CORE_INIT)
120 		return 0;
121 
122 	return core->ops->suspend(core);
123 }
124 
125 int hfi_core_resume(struct venus_core *core, bool force)
126 {
127 	if (!force && core->state != CORE_INIT)
128 		return 0;
129 
130 	return core->ops->resume(core);
131 }
132 
133 int hfi_core_trigger_ssr(struct venus_core *core, u32 type)
134 {
135 	return core->ops->core_trigger_ssr(core, type);
136 }
137 
138 int hfi_core_ping(struct venus_core *core)
139 {
140 	int ret;
141 
142 	mutex_lock(&core->lock);
143 
144 	ret = core->ops->core_ping(core, 0xbeef);
145 	if (ret)
146 		goto unlock;
147 
148 	ret = wait_for_completion_timeout(&core->done, TIMEOUT);
149 	if (!ret) {
150 		ret = -ETIMEDOUT;
151 		goto unlock;
152 	}
153 	ret = 0;
154 	if (core->error != HFI_ERR_NONE)
155 		ret = -ENODEV;
156 unlock:
157 	mutex_unlock(&core->lock);
158 	return ret;
159 }
160 
161 static int wait_session_msg(struct venus_inst *inst)
162 {
163 	int ret;
164 
165 	ret = wait_for_completion_timeout(&inst->done, TIMEOUT);
166 	if (!ret)
167 		return -ETIMEDOUT;
168 
169 	if (inst->error != HFI_ERR_NONE)
170 		return -EIO;
171 
172 	return 0;
173 }
174 
175 int hfi_session_create(struct venus_inst *inst, const struct hfi_inst_ops *ops)
176 {
177 	struct venus_core *core = inst->core;
178 	bool max;
179 	int ret;
180 
181 	if (!ops)
182 		return -EINVAL;
183 
184 	inst->state = INST_UNINIT;
185 	init_completion(&inst->done);
186 	inst->ops = ops;
187 
188 	mutex_lock(&core->lock);
189 
190 	max = atomic_add_unless(&core->insts_count, 1,
191 				core->max_sessions_supported);
192 	if (!max) {
193 		ret = -EAGAIN;
194 	} else {
195 		list_add_tail(&inst->list, &core->instances);
196 		ret = 0;
197 	}
198 
199 	mutex_unlock(&core->lock);
200 
201 	return ret;
202 }
203 EXPORT_SYMBOL_GPL(hfi_session_create);
204 
205 int hfi_session_init(struct venus_inst *inst, u32 pixfmt)
206 {
207 	struct venus_core *core = inst->core;
208 	const struct hfi_ops *ops = core->ops;
209 	int ret;
210 
211 	/*
212 	 * If core shutdown is in progress or if we are in system
213 	 * recovery, return an error as during system error recovery
214 	 * session_init() can't pass successfully
215 	 */
216 	mutex_lock(&core->lock);
217 	if (!core->ops || core->sys_error) {
218 		mutex_unlock(&core->lock);
219 		return -EIO;
220 	}
221 	mutex_unlock(&core->lock);
222 
223 	if (inst->state != INST_UNINIT)
224 		return -EALREADY;
225 
226 	inst->hfi_codec = to_codec_type(pixfmt);
227 	reinit_completion(&inst->done);
228 
229 	ret = ops->session_init(inst, inst->session_type, inst->hfi_codec);
230 	if (ret)
231 		return ret;
232 
233 	ret = wait_session_msg(inst);
234 	if (ret)
235 		return ret;
236 
237 	inst->state = INST_INIT;
238 
239 	return 0;
240 }
241 EXPORT_SYMBOL_GPL(hfi_session_init);
242 
243 void hfi_session_destroy(struct venus_inst *inst)
244 {
245 	struct venus_core *core = inst->core;
246 
247 	mutex_lock(&core->lock);
248 	list_del_init(&inst->list);
249 	if (atomic_dec_and_test(&core->insts_count))
250 		wake_up_var(&core->insts_count);
251 	mutex_unlock(&core->lock);
252 }
253 EXPORT_SYMBOL_GPL(hfi_session_destroy);
254 
255 int hfi_session_deinit(struct venus_inst *inst)
256 {
257 	const struct hfi_ops *ops = inst->core->ops;
258 	int ret;
259 
260 	if (inst->state == INST_UNINIT)
261 		return 0;
262 
263 	if (inst->state < INST_INIT)
264 		return -EINVAL;
265 
266 	reinit_completion(&inst->done);
267 
268 	ret = ops->session_end(inst);
269 	if (ret)
270 		return ret;
271 
272 	ret = wait_session_msg(inst);
273 	if (ret)
274 		return ret;
275 
276 	inst->state = INST_UNINIT;
277 
278 	return 0;
279 }
280 EXPORT_SYMBOL_GPL(hfi_session_deinit);
281 
282 int hfi_session_start(struct venus_inst *inst)
283 {
284 	const struct hfi_ops *ops = inst->core->ops;
285 	int ret;
286 
287 	if (inst->state != INST_LOAD_RESOURCES)
288 		return -EINVAL;
289 
290 	reinit_completion(&inst->done);
291 
292 	ret = ops->session_start(inst);
293 	if (ret)
294 		return ret;
295 
296 	ret = wait_session_msg(inst);
297 	if (ret)
298 		return ret;
299 
300 	inst->state = INST_START;
301 
302 	return 0;
303 }
304 EXPORT_SYMBOL_GPL(hfi_session_start);
305 
306 int hfi_session_stop(struct venus_inst *inst)
307 {
308 	const struct hfi_ops *ops = inst->core->ops;
309 	int ret;
310 
311 	if (inst->state != INST_START)
312 		return -EINVAL;
313 
314 	reinit_completion(&inst->done);
315 
316 	ret = ops->session_stop(inst);
317 	if (ret)
318 		return ret;
319 
320 	ret = wait_session_msg(inst);
321 	if (ret)
322 		return ret;
323 
324 	inst->state = INST_STOP;
325 
326 	return 0;
327 }
328 EXPORT_SYMBOL_GPL(hfi_session_stop);
329 
330 int hfi_session_continue(struct venus_inst *inst)
331 {
332 	struct venus_core *core = inst->core;
333 
334 	if (core->res->hfi_version == HFI_VERSION_1XX)
335 		return 0;
336 
337 	return core->ops->session_continue(inst);
338 }
339 EXPORT_SYMBOL_GPL(hfi_session_continue);
340 
341 int hfi_session_abort(struct venus_inst *inst)
342 {
343 	const struct hfi_ops *ops = inst->core->ops;
344 	int ret;
345 
346 	reinit_completion(&inst->done);
347 
348 	ret = ops->session_abort(inst);
349 	if (ret)
350 		return ret;
351 
352 	ret = wait_session_msg(inst);
353 	if (ret)
354 		return ret;
355 
356 	return 0;
357 }
358 EXPORT_SYMBOL_GPL(hfi_session_abort);
359 
360 int hfi_session_load_res(struct venus_inst *inst)
361 {
362 	const struct hfi_ops *ops = inst->core->ops;
363 	int ret;
364 
365 	if (inst->state != INST_INIT)
366 		return -EINVAL;
367 
368 	reinit_completion(&inst->done);
369 
370 	ret = ops->session_load_res(inst);
371 	if (ret)
372 		return ret;
373 
374 	ret = wait_session_msg(inst);
375 	if (ret)
376 		return ret;
377 
378 	inst->state = INST_LOAD_RESOURCES;
379 
380 	return 0;
381 }
382 
383 int hfi_session_unload_res(struct venus_inst *inst)
384 {
385 	const struct hfi_ops *ops = inst->core->ops;
386 	int ret;
387 
388 	if (inst->state != INST_STOP)
389 		return -EINVAL;
390 
391 	reinit_completion(&inst->done);
392 
393 	ret = ops->session_release_res(inst);
394 	if (ret)
395 		return ret;
396 
397 	ret = wait_session_msg(inst);
398 	if (ret)
399 		return ret;
400 
401 	inst->state = INST_RELEASE_RESOURCES;
402 
403 	return 0;
404 }
405 EXPORT_SYMBOL_GPL(hfi_session_unload_res);
406 
407 int hfi_session_flush(struct venus_inst *inst, u32 type, bool block)
408 {
409 	const struct hfi_ops *ops = inst->core->ops;
410 	int ret;
411 
412 	reinit_completion(&inst->done);
413 
414 	ret = ops->session_flush(inst, type);
415 	if (ret)
416 		return ret;
417 
418 	if (block) {
419 		ret = wait_session_msg(inst);
420 		if (ret)
421 			return ret;
422 	}
423 
424 	return 0;
425 }
426 EXPORT_SYMBOL_GPL(hfi_session_flush);
427 
428 int hfi_session_set_buffers(struct venus_inst *inst, struct hfi_buffer_desc *bd)
429 {
430 	const struct hfi_ops *ops = inst->core->ops;
431 
432 	return ops->session_set_buffers(inst, bd);
433 }
434 
435 int hfi_session_unset_buffers(struct venus_inst *inst,
436 			      struct hfi_buffer_desc *bd)
437 {
438 	const struct hfi_ops *ops = inst->core->ops;
439 	int ret;
440 
441 	reinit_completion(&inst->done);
442 
443 	ret = ops->session_unset_buffers(inst, bd);
444 	if (ret)
445 		return ret;
446 
447 	if (!bd->response_required)
448 		return 0;
449 
450 	ret = wait_session_msg(inst);
451 	if (ret)
452 		return ret;
453 
454 	return 0;
455 }
456 
457 int hfi_session_get_property(struct venus_inst *inst, u32 ptype,
458 			     union hfi_get_property *hprop)
459 {
460 	const struct hfi_ops *ops = inst->core->ops;
461 	int ret;
462 
463 	if (inst->state < INST_INIT || inst->state >= INST_STOP)
464 		return -EINVAL;
465 
466 	reinit_completion(&inst->done);
467 
468 	ret = ops->session_get_property(inst, ptype);
469 	if (ret)
470 		return ret;
471 
472 	ret = wait_session_msg(inst);
473 	if (ret)
474 		return ret;
475 
476 	*hprop = inst->hprop;
477 
478 	return 0;
479 }
480 EXPORT_SYMBOL_GPL(hfi_session_get_property);
481 
482 int hfi_session_set_property(struct venus_inst *inst, u32 ptype, void *pdata)
483 {
484 	const struct hfi_ops *ops = inst->core->ops;
485 
486 	if (inst->state < INST_INIT || inst->state >= INST_STOP)
487 		return -EINVAL;
488 
489 	return ops->session_set_property(inst, ptype, pdata);
490 }
491 EXPORT_SYMBOL_GPL(hfi_session_set_property);
492 
493 int hfi_session_process_buf(struct venus_inst *inst, struct hfi_frame_data *fd)
494 {
495 	const struct hfi_ops *ops = inst->core->ops;
496 
497 	if (fd->buffer_type == HFI_BUFFER_INPUT)
498 		return ops->session_etb(inst, fd);
499 	else if (fd->buffer_type == HFI_BUFFER_OUTPUT ||
500 		 fd->buffer_type == HFI_BUFFER_OUTPUT2)
501 		return ops->session_ftb(inst, fd);
502 
503 	return -EINVAL;
504 }
505 EXPORT_SYMBOL_GPL(hfi_session_process_buf);
506 
507 irqreturn_t hfi_isr_thread(int irq, void *dev_id)
508 {
509 	struct venus_core *core = dev_id;
510 
511 	return core->ops->isr_thread(core);
512 }
513 
514 irqreturn_t hfi_isr(int irq, void *dev)
515 {
516 	struct venus_core *core = dev;
517 
518 	return core->ops->isr(core);
519 }
520 
521 int hfi_create(struct venus_core *core, const struct hfi_core_ops *ops)
522 {
523 	int ret;
524 
525 	if (!ops)
526 		return -EINVAL;
527 
528 	atomic_set(&core->insts_count, 0);
529 	core->core_ops = ops;
530 	core->state = CORE_UNINIT;
531 	init_completion(&core->done);
532 	pkt_set_version(core->res->hfi_version);
533 	ret = venus_hfi_create(core);
534 
535 	return ret;
536 }
537 
538 void hfi_destroy(struct venus_core *core)
539 {
540 	venus_hfi_destroy(core);
541 }
542 
543 void hfi_reinit(struct venus_core *core)
544 {
545 	venus_hfi_queues_reinit(core);
546 }
547