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