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 
179 	if (!ops)
180 		return -EINVAL;
181 
182 	inst->state = INST_UNINIT;
183 	init_completion(&inst->done);
184 	inst->ops = ops;
185 
186 	mutex_lock(&core->lock);
187 	list_add_tail(&inst->list, &core->instances);
188 	atomic_inc(&core->insts_count);
189 	mutex_unlock(&core->lock);
190 
191 	return 0;
192 }
193 EXPORT_SYMBOL_GPL(hfi_session_create);
194 
195 int hfi_session_init(struct venus_inst *inst, u32 pixfmt)
196 {
197 	struct venus_core *core = inst->core;
198 	const struct hfi_ops *ops = core->ops;
199 	int ret;
200 
201 	/*
202 	 * If core shutdown is in progress or if we are in system
203 	 * recovery, return an error as during system error recovery
204 	 * session_init() can't pass successfully
205 	 */
206 	mutex_lock(&core->lock);
207 	if (!core->ops || core->sys_error) {
208 		mutex_unlock(&core->lock);
209 		return -EIO;
210 	}
211 	mutex_unlock(&core->lock);
212 
213 	if (inst->state != INST_UNINIT)
214 		return -EINVAL;
215 
216 	inst->hfi_codec = to_codec_type(pixfmt);
217 	reinit_completion(&inst->done);
218 
219 	ret = ops->session_init(inst, inst->session_type, inst->hfi_codec);
220 	if (ret)
221 		return ret;
222 
223 	ret = wait_session_msg(inst);
224 	if (ret)
225 		return ret;
226 
227 	inst->state = INST_INIT;
228 
229 	return 0;
230 }
231 EXPORT_SYMBOL_GPL(hfi_session_init);
232 
233 void hfi_session_destroy(struct venus_inst *inst)
234 {
235 	struct venus_core *core = inst->core;
236 
237 	mutex_lock(&core->lock);
238 	list_del_init(&inst->list);
239 	if (atomic_dec_and_test(&core->insts_count))
240 		wake_up_var(&core->insts_count);
241 	mutex_unlock(&core->lock);
242 }
243 EXPORT_SYMBOL_GPL(hfi_session_destroy);
244 
245 int hfi_session_deinit(struct venus_inst *inst)
246 {
247 	const struct hfi_ops *ops = inst->core->ops;
248 	int ret;
249 
250 	if (inst->state == INST_UNINIT)
251 		return 0;
252 
253 	if (inst->state < INST_INIT)
254 		return -EINVAL;
255 
256 	reinit_completion(&inst->done);
257 
258 	ret = ops->session_end(inst);
259 	if (ret)
260 		return ret;
261 
262 	ret = wait_session_msg(inst);
263 	if (ret)
264 		return ret;
265 
266 	inst->state = INST_UNINIT;
267 
268 	return 0;
269 }
270 EXPORT_SYMBOL_GPL(hfi_session_deinit);
271 
272 int hfi_session_start(struct venus_inst *inst)
273 {
274 	const struct hfi_ops *ops = inst->core->ops;
275 	int ret;
276 
277 	if (inst->state != INST_LOAD_RESOURCES)
278 		return -EINVAL;
279 
280 	reinit_completion(&inst->done);
281 
282 	ret = ops->session_start(inst);
283 	if (ret)
284 		return ret;
285 
286 	ret = wait_session_msg(inst);
287 	if (ret)
288 		return ret;
289 
290 	inst->state = INST_START;
291 
292 	return 0;
293 }
294 EXPORT_SYMBOL_GPL(hfi_session_start);
295 
296 int hfi_session_stop(struct venus_inst *inst)
297 {
298 	const struct hfi_ops *ops = inst->core->ops;
299 	int ret;
300 
301 	if (inst->state != INST_START)
302 		return -EINVAL;
303 
304 	reinit_completion(&inst->done);
305 
306 	ret = ops->session_stop(inst);
307 	if (ret)
308 		return ret;
309 
310 	ret = wait_session_msg(inst);
311 	if (ret)
312 		return ret;
313 
314 	inst->state = INST_STOP;
315 
316 	return 0;
317 }
318 EXPORT_SYMBOL_GPL(hfi_session_stop);
319 
320 int hfi_session_continue(struct venus_inst *inst)
321 {
322 	struct venus_core *core = inst->core;
323 
324 	if (core->res->hfi_version == HFI_VERSION_1XX)
325 		return 0;
326 
327 	return core->ops->session_continue(inst);
328 }
329 EXPORT_SYMBOL_GPL(hfi_session_continue);
330 
331 int hfi_session_abort(struct venus_inst *inst)
332 {
333 	const struct hfi_ops *ops = inst->core->ops;
334 	int ret;
335 
336 	reinit_completion(&inst->done);
337 
338 	ret = ops->session_abort(inst);
339 	if (ret)
340 		return ret;
341 
342 	ret = wait_session_msg(inst);
343 	if (ret)
344 		return ret;
345 
346 	return 0;
347 }
348 EXPORT_SYMBOL_GPL(hfi_session_abort);
349 
350 int hfi_session_load_res(struct venus_inst *inst)
351 {
352 	const struct hfi_ops *ops = inst->core->ops;
353 	int ret;
354 
355 	if (inst->state != INST_INIT)
356 		return -EINVAL;
357 
358 	reinit_completion(&inst->done);
359 
360 	ret = ops->session_load_res(inst);
361 	if (ret)
362 		return ret;
363 
364 	ret = wait_session_msg(inst);
365 	if (ret)
366 		return ret;
367 
368 	inst->state = INST_LOAD_RESOURCES;
369 
370 	return 0;
371 }
372 
373 int hfi_session_unload_res(struct venus_inst *inst)
374 {
375 	const struct hfi_ops *ops = inst->core->ops;
376 	int ret;
377 
378 	if (inst->state != INST_STOP)
379 		return -EINVAL;
380 
381 	reinit_completion(&inst->done);
382 
383 	ret = ops->session_release_res(inst);
384 	if (ret)
385 		return ret;
386 
387 	ret = wait_session_msg(inst);
388 	if (ret)
389 		return ret;
390 
391 	inst->state = INST_RELEASE_RESOURCES;
392 
393 	return 0;
394 }
395 EXPORT_SYMBOL_GPL(hfi_session_unload_res);
396 
397 int hfi_session_flush(struct venus_inst *inst, u32 type, bool block)
398 {
399 	const struct hfi_ops *ops = inst->core->ops;
400 	int ret;
401 
402 	reinit_completion(&inst->done);
403 
404 	ret = ops->session_flush(inst, type);
405 	if (ret)
406 		return ret;
407 
408 	if (block) {
409 		ret = wait_session_msg(inst);
410 		if (ret)
411 			return ret;
412 	}
413 
414 	return 0;
415 }
416 EXPORT_SYMBOL_GPL(hfi_session_flush);
417 
418 int hfi_session_set_buffers(struct venus_inst *inst, struct hfi_buffer_desc *bd)
419 {
420 	const struct hfi_ops *ops = inst->core->ops;
421 
422 	return ops->session_set_buffers(inst, bd);
423 }
424 
425 int hfi_session_unset_buffers(struct venus_inst *inst,
426 			      struct hfi_buffer_desc *bd)
427 {
428 	const struct hfi_ops *ops = inst->core->ops;
429 	int ret;
430 
431 	reinit_completion(&inst->done);
432 
433 	ret = ops->session_unset_buffers(inst, bd);
434 	if (ret)
435 		return ret;
436 
437 	if (!bd->response_required)
438 		return 0;
439 
440 	ret = wait_session_msg(inst);
441 	if (ret)
442 		return ret;
443 
444 	return 0;
445 }
446 
447 int hfi_session_get_property(struct venus_inst *inst, u32 ptype,
448 			     union hfi_get_property *hprop)
449 {
450 	const struct hfi_ops *ops = inst->core->ops;
451 	int ret;
452 
453 	if (inst->state < INST_INIT || inst->state >= INST_STOP)
454 		return -EINVAL;
455 
456 	reinit_completion(&inst->done);
457 
458 	ret = ops->session_get_property(inst, ptype);
459 	if (ret)
460 		return ret;
461 
462 	ret = wait_session_msg(inst);
463 	if (ret)
464 		return ret;
465 
466 	*hprop = inst->hprop;
467 
468 	return 0;
469 }
470 EXPORT_SYMBOL_GPL(hfi_session_get_property);
471 
472 int hfi_session_set_property(struct venus_inst *inst, u32 ptype, void *pdata)
473 {
474 	const struct hfi_ops *ops = inst->core->ops;
475 
476 	if (inst->state < INST_INIT || inst->state >= INST_STOP)
477 		return -EINVAL;
478 
479 	return ops->session_set_property(inst, ptype, pdata);
480 }
481 EXPORT_SYMBOL_GPL(hfi_session_set_property);
482 
483 int hfi_session_process_buf(struct venus_inst *inst, struct hfi_frame_data *fd)
484 {
485 	const struct hfi_ops *ops = inst->core->ops;
486 
487 	if (fd->buffer_type == HFI_BUFFER_INPUT)
488 		return ops->session_etb(inst, fd);
489 	else if (fd->buffer_type == HFI_BUFFER_OUTPUT ||
490 		 fd->buffer_type == HFI_BUFFER_OUTPUT2)
491 		return ops->session_ftb(inst, fd);
492 
493 	return -EINVAL;
494 }
495 EXPORT_SYMBOL_GPL(hfi_session_process_buf);
496 
497 irqreturn_t hfi_isr_thread(int irq, void *dev_id)
498 {
499 	struct venus_core *core = dev_id;
500 
501 	return core->ops->isr_thread(core);
502 }
503 
504 irqreturn_t hfi_isr(int irq, void *dev)
505 {
506 	struct venus_core *core = dev;
507 
508 	return core->ops->isr(core);
509 }
510 
511 int hfi_create(struct venus_core *core, const struct hfi_core_ops *ops)
512 {
513 	int ret;
514 
515 	if (!ops)
516 		return -EINVAL;
517 
518 	atomic_set(&core->insts_count, 0);
519 	core->core_ops = ops;
520 	core->state = CORE_UNINIT;
521 	init_completion(&core->done);
522 	pkt_set_version(core->res->hfi_version);
523 	ret = venus_hfi_create(core);
524 
525 	return ret;
526 }
527 
528 void hfi_destroy(struct venus_core *core)
529 {
530 	venus_hfi_destroy(core);
531 }
532 
533 void hfi_reinit(struct venus_core *core)
534 {
535 	venus_hfi_queues_reinit(core);
536 }
537