1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright 2020-2021 NXP
4  */
5 
6 #include <linux/init.h>
7 #include <linux/device.h>
8 #include <linux/ioctl.h>
9 #include <linux/list.h>
10 #include <linux/module.h>
11 #include <linux/kernel.h>
12 #include <linux/types.h>
13 #include <linux/pm_runtime.h>
14 #include <media/v4l2-device.h>
15 #include <linux/debugfs.h>
16 #include "vpu.h"
17 #include "vpu_defs.h"
18 #include "vpu_helpers.h"
19 #include "vpu_cmds.h"
20 #include "vpu_rpc.h"
21 #include "vpu_v4l2.h"
22 
23 struct print_buf_desc {
24 	u32 start_h_phy;
25 	u32 start_h_vir;
26 	u32 start_m;
27 	u32 bytes;
28 	u32 read;
29 	u32 write;
30 	char buffer[0];
31 };
32 
33 static char *vb2_stat_name[] = {
34 	[VB2_BUF_STATE_DEQUEUED] = "dequeued",
35 	[VB2_BUF_STATE_IN_REQUEST] = "in_request",
36 	[VB2_BUF_STATE_PREPARING] = "preparing",
37 	[VB2_BUF_STATE_QUEUED] = "queued",
38 	[VB2_BUF_STATE_ACTIVE] = "active",
39 	[VB2_BUF_STATE_DONE] = "done",
40 	[VB2_BUF_STATE_ERROR] = "error",
41 };
42 
43 static char *vpu_stat_name[] = {
44 	[VPU_BUF_STATE_IDLE] = "idle",
45 	[VPU_BUF_STATE_INUSE] = "inuse",
46 	[VPU_BUF_STATE_DECODED] = "decoded",
47 	[VPU_BUF_STATE_READY] = "ready",
48 	[VPU_BUF_STATE_SKIP] = "skip",
49 	[VPU_BUF_STATE_ERROR] = "error",
50 };
51 
52 static int vpu_dbg_instance(struct seq_file *s, void *data)
53 {
54 	struct vpu_inst *inst = s->private;
55 	char str[128];
56 	int num;
57 	struct vb2_queue *vq;
58 	int i;
59 
60 	if (!inst->fh.m2m_ctx)
61 		return 0;
62 	num = scnprintf(str, sizeof(str), "[%s]\n", vpu_core_type_desc(inst->type));
63 	if (seq_write(s, str, num))
64 		return 0;
65 
66 	num = scnprintf(str, sizeof(str), "tgig = %d,pid = %d\n", inst->tgid, inst->pid);
67 	if (seq_write(s, str, num))
68 		return 0;
69 	num = scnprintf(str, sizeof(str), "state = %d\n", inst->state);
70 	if (seq_write(s, str, num))
71 		return 0;
72 	num = scnprintf(str, sizeof(str),
73 			"min_buffer_out = %d, min_buffer_cap = %d\n",
74 			inst->min_buffer_out, inst->min_buffer_cap);
75 	if (seq_write(s, str, num))
76 		return 0;
77 
78 	vq = v4l2_m2m_get_src_vq(inst->fh.m2m_ctx);
79 	num = scnprintf(str, sizeof(str),
80 			"output (%2d, %2d): fmt = %c%c%c%c %d x %d, %d;",
81 			vb2_is_streaming(vq),
82 			vq->num_buffers,
83 			inst->out_format.pixfmt,
84 			inst->out_format.pixfmt >> 8,
85 			inst->out_format.pixfmt >> 16,
86 			inst->out_format.pixfmt >> 24,
87 			inst->out_format.width,
88 			inst->out_format.height,
89 			vq->last_buffer_dequeued);
90 	if (seq_write(s, str, num))
91 		return 0;
92 	for (i = 0; i < inst->out_format.num_planes; i++) {
93 		num = scnprintf(str, sizeof(str), " %d(%d)",
94 				inst->out_format.sizeimage[i],
95 				inst->out_format.bytesperline[i]);
96 		if (seq_write(s, str, num))
97 			return 0;
98 	}
99 	if (seq_write(s, "\n", 1))
100 		return 0;
101 
102 	vq = v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx);
103 	num = scnprintf(str, sizeof(str),
104 			"capture(%2d, %2d): fmt = %c%c%c%c %d x %d, %d;",
105 			vb2_is_streaming(vq),
106 			vq->num_buffers,
107 			inst->cap_format.pixfmt,
108 			inst->cap_format.pixfmt >> 8,
109 			inst->cap_format.pixfmt >> 16,
110 			inst->cap_format.pixfmt >> 24,
111 			inst->cap_format.width,
112 			inst->cap_format.height,
113 			vq->last_buffer_dequeued);
114 	if (seq_write(s, str, num))
115 		return 0;
116 	for (i = 0; i < inst->cap_format.num_planes; i++) {
117 		num = scnprintf(str, sizeof(str), " %d(%d)",
118 				inst->cap_format.sizeimage[i],
119 				inst->cap_format.bytesperline[i]);
120 		if (seq_write(s, str, num))
121 			return 0;
122 	}
123 	if (seq_write(s, "\n", 1))
124 		return 0;
125 	num = scnprintf(str, sizeof(str), "crop: (%d, %d) %d x %d\n",
126 			inst->crop.left,
127 			inst->crop.top,
128 			inst->crop.width,
129 			inst->crop.height);
130 	if (seq_write(s, str, num))
131 		return 0;
132 
133 	vq = v4l2_m2m_get_src_vq(inst->fh.m2m_ctx);
134 	for (i = 0; i < vq->num_buffers; i++) {
135 		struct vb2_buffer *vb = vq->bufs[i];
136 		struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
137 
138 		if (vb->state == VB2_BUF_STATE_DEQUEUED)
139 			continue;
140 		num = scnprintf(str, sizeof(str),
141 				"output [%2d] state = %10s, %8s\n",
142 				i, vb2_stat_name[vb->state],
143 				vpu_stat_name[vpu_get_buffer_state(vbuf)]);
144 		if (seq_write(s, str, num))
145 			return 0;
146 	}
147 
148 	vq = v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx);
149 	for (i = 0; i < vq->num_buffers; i++) {
150 		struct vb2_buffer *vb = vq->bufs[i];
151 		struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
152 
153 		if (vb->state == VB2_BUF_STATE_DEQUEUED)
154 			continue;
155 		num = scnprintf(str, sizeof(str),
156 				"capture[%2d] state = %10s, %8s\n",
157 				i, vb2_stat_name[vb->state],
158 				vpu_stat_name[vpu_get_buffer_state(vbuf)]);
159 		if (seq_write(s, str, num))
160 			return 0;
161 	}
162 
163 	num = scnprintf(str, sizeof(str), "sequence = %d\n", inst->sequence);
164 	if (seq_write(s, str, num))
165 		return 0;
166 
167 	if (inst->use_stream_buffer) {
168 		num = scnprintf(str, sizeof(str), "stream_buffer = %d / %d, <%pad, 0x%x>\n",
169 				vpu_helper_get_used_space(inst),
170 				inst->stream_buffer.length,
171 				&inst->stream_buffer.phys,
172 				inst->stream_buffer.length);
173 		if (seq_write(s, str, num))
174 			return 0;
175 	}
176 	num = scnprintf(str, sizeof(str), "kfifo len = 0x%x\n", kfifo_len(&inst->msg_fifo));
177 	if (seq_write(s, str, num))
178 		return 0;
179 
180 	num = scnprintf(str, sizeof(str), "flow :\n");
181 	if (seq_write(s, str, num))
182 		return 0;
183 
184 	mutex_lock(&inst->core->cmd_lock);
185 	for (i = 0; i < ARRAY_SIZE(inst->flows); i++) {
186 		u32 idx = (inst->flow_idx + i) % (ARRAY_SIZE(inst->flows));
187 
188 		if (!inst->flows[idx])
189 			continue;
190 		num = scnprintf(str, sizeof(str), "\t[%s]0x%x\n",
191 				inst->flows[idx] >= VPU_MSG_ID_NOOP ? "M" : "C",
192 				inst->flows[idx]);
193 		if (seq_write(s, str, num)) {
194 			mutex_unlock(&inst->core->cmd_lock);
195 			return 0;
196 		}
197 	}
198 	mutex_unlock(&inst->core->cmd_lock);
199 
200 	i = 0;
201 	while (true) {
202 		num = call_vop(inst, get_debug_info, str, sizeof(str), i++);
203 		if (num <= 0)
204 			break;
205 		if (seq_write(s, str, num))
206 			return 0;
207 	}
208 
209 	return 0;
210 }
211 
212 static int vpu_dbg_core(struct seq_file *s, void *data)
213 {
214 	struct vpu_core *core = s->private;
215 	struct vpu_shared_addr *iface = core->iface;
216 	char str[128];
217 	int num;
218 
219 	num = scnprintf(str, sizeof(str), "[%s]\n", vpu_core_type_desc(core->type));
220 	if (seq_write(s, str, num))
221 		return 0;
222 
223 	num = scnprintf(str, sizeof(str), "boot_region  = <%pad, 0x%x>\n",
224 			&core->fw.phys, core->fw.length);
225 	if (seq_write(s, str, num))
226 		return 0;
227 	num = scnprintf(str, sizeof(str), "rpc_region   = <%pad, 0x%x> used = 0x%x\n",
228 			&core->rpc.phys, core->rpc.length, core->rpc.bytesused);
229 	if (seq_write(s, str, num))
230 		return 0;
231 	num = scnprintf(str, sizeof(str), "fwlog_region = <%pad, 0x%x>\n",
232 			&core->log.phys, core->log.length);
233 	if (seq_write(s, str, num))
234 		return 0;
235 
236 	num = scnprintf(str, sizeof(str), "state = %d\n", core->state);
237 	if (seq_write(s, str, num))
238 		return 0;
239 	if (core->state == VPU_CORE_DEINIT)
240 		return 0;
241 	num = scnprintf(str, sizeof(str), "fw version = %d.%d.%d\n",
242 			(core->fw_version >> 16) & 0xff,
243 			(core->fw_version >> 8) & 0xff,
244 			core->fw_version & 0xff);
245 	if (seq_write(s, str, num))
246 		return 0;
247 	num = scnprintf(str, sizeof(str), "instances = %d/%d (0x%02lx), %d\n",
248 			hweight32(core->instance_mask),
249 			core->supported_instance_count,
250 			core->instance_mask,
251 			core->request_count);
252 	if (seq_write(s, str, num))
253 		return 0;
254 	num = scnprintf(str, sizeof(str), "kfifo len = 0x%x\n", kfifo_len(&core->msg_fifo));
255 	if (seq_write(s, str, num))
256 		return 0;
257 	num = scnprintf(str, sizeof(str),
258 			"cmd_buf:[0x%x, 0x%x], wptr = 0x%x, rptr = 0x%x\n",
259 			iface->cmd_desc->start,
260 			iface->cmd_desc->end,
261 			iface->cmd_desc->wptr,
262 			iface->cmd_desc->rptr);
263 	if (seq_write(s, str, num))
264 		return 0;
265 	num = scnprintf(str, sizeof(str),
266 			"msg_buf:[0x%x, 0x%x], wptr = 0x%x, rptr = 0x%x\n",
267 			iface->msg_desc->start,
268 			iface->msg_desc->end,
269 			iface->msg_desc->wptr,
270 			iface->msg_desc->rptr);
271 	if (seq_write(s, str, num))
272 		return 0;
273 
274 	return 0;
275 }
276 
277 static int vpu_dbg_fwlog(struct seq_file *s, void *data)
278 {
279 	struct vpu_core *core = s->private;
280 	struct print_buf_desc *print_buf;
281 	int length;
282 	u32 rptr;
283 	u32 wptr;
284 	int ret = 0;
285 
286 	if (!core->log.virt || core->state == VPU_CORE_DEINIT)
287 		return 0;
288 
289 	print_buf = core->log.virt;
290 	rptr = print_buf->read;
291 	wptr = print_buf->write;
292 
293 	if (rptr == wptr)
294 		return 0;
295 	else if (rptr < wptr)
296 		length = wptr - rptr;
297 	else
298 		length = print_buf->bytes + wptr - rptr;
299 
300 	if (s->count + length >= s->size) {
301 		s->count = s->size;
302 		return 0;
303 	}
304 
305 	if (rptr + length >= print_buf->bytes) {
306 		int num = print_buf->bytes - rptr;
307 
308 		if (seq_write(s, print_buf->buffer + rptr, num))
309 			ret = -1;
310 		length -= num;
311 		rptr = 0;
312 	}
313 
314 	if (length) {
315 		if (seq_write(s, print_buf->buffer + rptr, length))
316 			ret = -1;
317 		rptr += length;
318 	}
319 	if (!ret)
320 		print_buf->read = rptr;
321 
322 	return 0;
323 }
324 
325 static int vpu_dbg_inst_open(struct inode *inode, struct file *filp)
326 {
327 	return single_open(filp, vpu_dbg_instance, inode->i_private);
328 }
329 
330 static ssize_t vpu_dbg_inst_write(struct file *file,
331 				  const char __user *user_buf, size_t size, loff_t *ppos)
332 {
333 	struct seq_file *s = file->private_data;
334 	struct vpu_inst *inst = s->private;
335 
336 	vpu_session_debug(inst);
337 
338 	return size;
339 }
340 
341 static ssize_t vpu_dbg_core_write(struct file *file,
342 				  const char __user *user_buf, size_t size, loff_t *ppos)
343 {
344 	struct seq_file *s = file->private_data;
345 	struct vpu_core *core = s->private;
346 
347 	pm_runtime_resume_and_get(core->dev);
348 	mutex_lock(&core->lock);
349 	if (core->state != VPU_CORE_DEINIT && !core->instance_mask) {
350 		dev_info(core->dev, "reset\n");
351 		if (!vpu_core_sw_reset(core)) {
352 			core->state = VPU_CORE_ACTIVE;
353 			core->hang_mask = 0;
354 		}
355 	}
356 	mutex_unlock(&core->lock);
357 	pm_runtime_put_sync(core->dev);
358 
359 	return size;
360 }
361 
362 static int vpu_dbg_core_open(struct inode *inode, struct file *filp)
363 {
364 	return single_open(filp, vpu_dbg_core, inode->i_private);
365 }
366 
367 static int vpu_dbg_fwlog_open(struct inode *inode, struct file *filp)
368 {
369 	return single_open(filp, vpu_dbg_fwlog, inode->i_private);
370 }
371 
372 static const struct file_operations vpu_dbg_inst_fops = {
373 	.owner = THIS_MODULE,
374 	.open = vpu_dbg_inst_open,
375 	.release = single_release,
376 	.read = seq_read,
377 	.write = vpu_dbg_inst_write,
378 };
379 
380 static const struct file_operations vpu_dbg_core_fops = {
381 	.owner = THIS_MODULE,
382 	.open = vpu_dbg_core_open,
383 	.release = single_release,
384 	.read = seq_read,
385 	.write = vpu_dbg_core_write,
386 };
387 
388 static const struct file_operations vpu_dbg_fwlog_fops = {
389 	.owner = THIS_MODULE,
390 	.open = vpu_dbg_fwlog_open,
391 	.release = single_release,
392 	.read = seq_read,
393 };
394 
395 int vpu_inst_create_dbgfs_file(struct vpu_inst *inst)
396 {
397 	struct vpu_dev *vpu;
398 	char name[64];
399 
400 	if (!inst || !inst->core || !inst->core->vpu)
401 		return -EINVAL;
402 
403 	vpu = inst->core->vpu;
404 	if (!vpu->debugfs)
405 		return -EINVAL;
406 
407 	if (inst->debugfs)
408 		return 0;
409 
410 	scnprintf(name, sizeof(name), "instance.%d.%d", inst->core->id, inst->id);
411 	inst->debugfs = debugfs_create_file((const char *)name,
412 					    VERIFY_OCTAL_PERMISSIONS(0644),
413 					    vpu->debugfs,
414 					    inst,
415 					    &vpu_dbg_inst_fops);
416 
417 	return 0;
418 }
419 
420 int vpu_inst_remove_dbgfs_file(struct vpu_inst *inst)
421 {
422 	if (!inst)
423 		return 0;
424 
425 	debugfs_remove(inst->debugfs);
426 	inst->debugfs = NULL;
427 
428 	return 0;
429 }
430 
431 int vpu_core_create_dbgfs_file(struct vpu_core *core)
432 {
433 	struct vpu_dev *vpu;
434 	char name[64];
435 
436 	if (!core || !core->vpu)
437 		return -EINVAL;
438 
439 	vpu = core->vpu;
440 	if (!vpu->debugfs)
441 		return -EINVAL;
442 
443 	if (!core->debugfs) {
444 		scnprintf(name, sizeof(name), "core.%d", core->id);
445 		core->debugfs = debugfs_create_file((const char *)name,
446 						    VERIFY_OCTAL_PERMISSIONS(0644),
447 						    vpu->debugfs,
448 						    core,
449 						    &vpu_dbg_core_fops);
450 	}
451 	if (!core->debugfs_fwlog) {
452 		scnprintf(name, sizeof(name), "fwlog.%d", core->id);
453 		core->debugfs_fwlog = debugfs_create_file((const char *)name,
454 							  VERIFY_OCTAL_PERMISSIONS(0444),
455 							  vpu->debugfs,
456 							  core,
457 							  &vpu_dbg_fwlog_fops);
458 	}
459 
460 	return 0;
461 }
462 
463 int vpu_core_remove_dbgfs_file(struct vpu_core *core)
464 {
465 	if (!core)
466 		return 0;
467 	debugfs_remove(core->debugfs);
468 	core->debugfs = NULL;
469 	debugfs_remove(core->debugfs_fwlog);
470 	core->debugfs_fwlog = NULL;
471 
472 	return 0;
473 }
474 
475 void vpu_inst_record_flow(struct vpu_inst *inst, u32 flow)
476 {
477 	if (!inst)
478 		return;
479 
480 	inst->flows[inst->flow_idx] = flow;
481 	inst->flow_idx = (inst->flow_idx + 1) % (ARRAY_SIZE(inst->flows));
482 }
483