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