[mirror_ubuntu-artful-kernel.git] / drivers / media / platform / sti / bdisp / bdisp-debug.c

/*
 * Copyright (C) STMicroelectronics SA 2014
 * Authors: Fabien Dessenne <fabien.dessenne@st.com> for STMicroelectronics.
 * License terms:  GNU General Public License (GPL), version 2
 */

#include <linux/debugfs.h>
#include <linux/pm_runtime.h>

#include "bdisp.h"
#include "bdisp-filter.h"
#include "bdisp-reg.h"

void bdisp_dbg_perf_begin(struct bdisp_dev *bdisp)
{
	bdisp->dbg.hw_start = ktime_get();
}

void bdisp_dbg_perf_end(struct bdisp_dev *bdisp)
{
	s64 time_us;

	time_us = ktime_us_delta(ktime_get(), bdisp->dbg.hw_start);

	if (!bdisp->dbg.min_duration)
		bdisp->dbg.min_duration = time_us;
	else
		bdisp->dbg.min_duration = min(time_us, bdisp->dbg.min_duration);

	bdisp->dbg.last_duration = time_us;
	bdisp->dbg.max_duration = max(time_us, bdisp->dbg.max_duration);
	bdisp->dbg.tot_duration += time_us;
}

static void bdisp_dbg_dump_ins(struct seq_file *s, u32 val)
{
	seq_printf(s, "INS\t0x%08X\t", val);

	switch (val & BLT_INS_S1_MASK) {
	case BLT_INS_S1_OFF:
		break;
	case BLT_INS_S1_MEM:
		seq_puts(s, "SRC1=mem - ");
		break;
	case BLT_INS_S1_CF:
		seq_puts(s, "SRC1=ColorFill - ");
		break;
	case BLT_INS_S1_COPY:
		seq_puts(s, "SRC1=copy - ");
		break;
	case BLT_INS_S1_FILL:
		seq_puts(s, "SRC1=fil - ");
		break;
	default:
		seq_puts(s, "SRC1=??? - ");
		break;
	}

	switch (val & BLT_INS_S2_MASK) {
	case BLT_INS_S2_OFF:
		break;
	case BLT_INS_S2_MEM:
		seq_puts(s, "SRC2=mem - ");
		break;
	case BLT_INS_S2_CF:
		seq_puts(s, "SRC2=ColorFill - ");
		break;
	default:
		seq_puts(s, "SRC2=??? - ");
		break;
	}

	if ((val & BLT_INS_S3_MASK) == BLT_INS_S3_MEM)
		seq_puts(s, "SRC3=mem - ");

	if (val & BLT_INS_IVMX)
		seq_puts(s, "IVMX - ");
	if (val & BLT_INS_CLUT)
		seq_puts(s, "CLUT - ");
	if (val & BLT_INS_SCALE)
		seq_puts(s, "Scale - ");
	if (val & BLT_INS_FLICK)
		seq_puts(s, "Flicker - ");
	if (val & BLT_INS_CLIP)
		seq_puts(s, "Clip - ");
	if (val & BLT_INS_CKEY)
		seq_puts(s, "ColorKey - ");
	if (val & BLT_INS_OVMX)
		seq_puts(s, "OVMX - ");
	if (val & BLT_INS_DEI)
		seq_puts(s, "Deint - ");
	if (val & BLT_INS_PMASK)
		seq_puts(s, "PlaneMask - ");
	if (val & BLT_INS_VC1R)
		seq_puts(s, "VC1R - ");
	if (val & BLT_INS_ROTATE)
		seq_puts(s, "Rotate - ");
	if (val & BLT_INS_GRAD)
		seq_puts(s, "GradFill - ");
	if (val & BLT_INS_AQLOCK)
		seq_puts(s, "AQLock - ");
	if (val & BLT_INS_PACE)
		seq_puts(s, "Pace - ");
	if (val & BLT_INS_IRQ)
		seq_puts(s, "IRQ - ");

	seq_puts(s, "\n");
}

static void bdisp_dbg_dump_tty(struct seq_file *s, u32 val)
{
	seq_printf(s, "TTY\t0x%08X\t", val);
	seq_printf(s, "Pitch=%d - ", val & 0xFFFF);

	switch ((val & BLT_TTY_COL_MASK) >> BLT_TTY_COL_SHIFT) {
	case BDISP_RGB565:
		seq_puts(s, "RGB565 - ");
		break;
	case BDISP_XRGB8888:
		seq_puts(s, "xRGB888 - ");
		break;
	case BDISP_ARGB8888:
		seq_puts(s, "ARGB8888 - ");
		break;
	case BDISP_NV12:
		seq_puts(s, "NV12 - ");
		break;
	case BDISP_YUV_3B:
		seq_puts(s, "YUV420P - ");
		break;
	default:
		seq_puts(s, "ColorFormat ??? - ");
		break;
	}

	if (val & BLT_TTY_ALPHA_R)
		seq_puts(s, "AlphaRange - ");
	if (val & BLT_TTY_CR_NOT_CB)
		seq_puts(s, "CrNotCb - ");
	if (val & BLT_TTY_MB)
		seq_puts(s, "MB - ");
	if (val & BLT_TTY_HSO)
		seq_puts(s, "HSO inverse - ");
	if (val & BLT_TTY_VSO)
		seq_puts(s, "VSO inverse - ");
	if (val & BLT_TTY_DITHER)
		seq_puts(s, "Dither - ");
	if (val & BLT_TTY_CHROMA)
		seq_puts(s, "Write CHROMA - ");
	if (val & BLT_TTY_BIG_END)
		seq_puts(s, "BigEndian - ");

	seq_puts(s, "\n");
}

static void bdisp_dbg_dump_xy(struct seq_file *s, u32 val, char *name)
{
	seq_printf(s, "%s\t0x%08X\t", name, val);
	seq_printf(s, "(%d,%d)\n", val & 0xFFFF, (val >> 16));
}

static void bdisp_dbg_dump_sz(struct seq_file *s, u32 val, char *name)
{
	seq_printf(s, "%s\t0x%08X\t", name, val);
	seq_printf(s, "%dx%d\n", val & 0x1FFF, (val >> 16) & 0x1FFF);
}

static void bdisp_dbg_dump_sty(struct seq_file *s,
			       u32 val, u32 addr, char *name)
{
	bool s1, s2, s3;

	seq_printf(s, "%s\t0x%08X\t", name, val);

	if (!addr || !name || (strlen(name) < 2))
		goto done;

	s1 = name[strlen(name) - 1] == '1';
	s2 = name[strlen(name) - 1] == '2';
	s3 = name[strlen(name) - 1] == '3';

	seq_printf(s, "Pitch=%d - ", val & 0xFFFF);

	switch ((val & BLT_TTY_COL_MASK) >> BLT_TTY_COL_SHIFT) {
	case BDISP_RGB565:
		seq_puts(s, "RGB565 - ");
		break;
	case BDISP_XRGB8888:
		seq_puts(s, "xRGB888 - ");
		break;
	case BDISP_ARGB8888:
		seq_puts(s, "ARGB888 - ");
		break;
	case BDISP_NV12:
		seq_puts(s, "NV12 - ");
		break;
	case BDISP_YUV_3B:
		seq_puts(s, "YUV420P - ");
		break;
	default:
		seq_puts(s, "ColorFormat ??? - ");
		break;
	}

	if ((val & BLT_TTY_ALPHA_R) && !s3)
		seq_puts(s, "AlphaRange - ");
	if ((val & BLT_S1TY_A1_SUBSET) && !s3)
		seq_puts(s, "A1SubSet - ");
	if ((val & BLT_TTY_MB) && !s1)
		seq_puts(s, "MB - ");
	if (val & BLT_TTY_HSO)
		seq_puts(s, "HSO inverse - ");
	if (val & BLT_TTY_VSO)
		seq_puts(s, "VSO inverse - ");
	if ((val & BLT_S1TY_CHROMA_EXT) && (s1 || s2))
		seq_puts(s, "ChromaExt - ");
	if ((val & BLT_S3TY_BLANK_ACC) && s3)
		seq_puts(s, "Blank Acc - ");
	if ((val & BTL_S1TY_SUBBYTE) && !s3)
		seq_puts(s, "SubByte - ");
	if ((val & BLT_S1TY_RGB_EXP) && !s3)
		seq_puts(s, "RGBExpand - ");
	if ((val & BLT_TTY_BIG_END) && !s3)
		seq_puts(s, "BigEndian - ");

done:
	seq_puts(s, "\n");
}

static void bdisp_dbg_dump_fctl(struct seq_file *s, u32 val)
{
	seq_printf(s, "FCTL\t0x%08X\t", val);

	if ((val & BLT_FCTL_Y_HV_SCALE) == BLT_FCTL_Y_HV_SCALE)
		seq_puts(s, "Resize Luma - ");
	else if ((val & BLT_FCTL_Y_HV_SCALE) == BLT_FCTL_Y_HV_SAMPLE)
		seq_puts(s, "Sample Luma - ");

	if ((val & BLT_FCTL_HV_SCALE) == BLT_FCTL_HV_SCALE)
		seq_puts(s, "Resize Chroma");
	else if ((val & BLT_FCTL_HV_SCALE) == BLT_FCTL_HV_SAMPLE)
		seq_puts(s, "Sample Chroma");

	seq_puts(s, "\n");
}

static void bdisp_dbg_dump_rsf(struct seq_file *s, u32 val, char *name)
{
	u32 inc;

	seq_printf(s, "%s\t0x%08X\t", name, val);

	if (!val)
		goto done;

	inc = val & 0xFFFF;
	seq_printf(s, "H: %d(6.10) / scale~%dx0.1 - ", inc, 1024 * 10 / inc);

	inc = val >> 16;
	seq_printf(s, "V: %d(6.10) / scale~%dx0.1", inc, 1024 * 10 / inc);

done:
	seq_puts(s, "\n");
}

static void bdisp_dbg_dump_rzi(struct seq_file *s, u32 val, char *name)
{
	seq_printf(s, "%s\t0x%08X\t", name, val);

	if (!val)
		goto done;

	seq_printf(s, "H: init=%d repeat=%d - ", val & 0x3FF, (val >> 12) & 7);
	val >>= 16;
	seq_printf(s, "V: init=%d repeat=%d", val & 0x3FF, (val >> 12) & 7);

done:
	seq_puts(s, "\n");
}

static void bdisp_dbg_dump_ivmx(struct seq_file *s,
				u32 c0, u32 c1, u32 c2, u32 c3)
{
	seq_printf(s, "IVMX0\t0x%08X\n", c0);
	seq_printf(s, "IVMX1\t0x%08X\n", c1);
	seq_printf(s, "IVMX2\t0x%08X\n", c2);
	seq_printf(s, "IVMX3\t0x%08X\t", c3);

	if (!c0 && !c1 && !c2 && !c3) {
		seq_puts(s, "\n");
		return;
	}

	if ((c0 == bdisp_rgb_to_yuv[0]) &&
	    (c1 == bdisp_rgb_to_yuv[1]) &&
	    (c2 == bdisp_rgb_to_yuv[2]) &&
	    (c3 == bdisp_rgb_to_yuv[3])) {
		seq_puts(s, "RGB to YUV\n");
		return;
	}

	if ((c0 == bdisp_yuv_to_rgb[0]) &&
	    (c1 == bdisp_yuv_to_rgb[1]) &&
	    (c2 == bdisp_yuv_to_rgb[2]) &&
	    (c3 == bdisp_yuv_to_rgb[3])) {
		seq_puts(s, "YUV to RGB\n");
		return;
	}
	seq_puts(s, "Unknown conversion\n");
}

static int bdisp_dbg_last_nodes(struct seq_file *s, void *data)
{
	/* Not dumping all fields, focusing on significant ones */
	struct bdisp_dev *bdisp = s->private;
	struct bdisp_node *node;
	int i = 0;

	if (!bdisp->dbg.copy_node[0]) {
		seq_puts(s, "No node built yet\n");
		return 0;
	}

	do {
		node = bdisp->dbg.copy_node[i];
		if (!node)
			break;
		seq_printf(s, "--------\nNode %d:\n", i);
		seq_puts(s, "-- General --\n");
		seq_printf(s, "NIP\t0x%08X\n", node->nip);
		seq_printf(s, "CIC\t0x%08X\n", node->cic);
		bdisp_dbg_dump_ins(s, node->ins);
		seq_printf(s, "ACK\t0x%08X\n", node->ack);
		seq_puts(s, "-- Target --\n");
		seq_printf(s, "TBA\t0x%08X\n", node->tba);
		bdisp_dbg_dump_tty(s, node->tty);
		bdisp_dbg_dump_xy(s, node->txy, "TXY");
		bdisp_dbg_dump_sz(s, node->tsz, "TSZ");
		/* Color Fill not dumped */
		seq_puts(s, "-- Source 1 --\n");
		seq_printf(s, "S1BA\t0x%08X\n", node->s1ba);
		bdisp_dbg_dump_sty(s, node->s1ty, node->s1ba, "S1TY");
		bdisp_dbg_dump_xy(s, node->s1xy, "S1XY");
		seq_puts(s, "-- Source 2 --\n");
		seq_printf(s, "S2BA\t0x%08X\n", node->s2ba);
		bdisp_dbg_dump_sty(s, node->s2ty, node->s2ba, "S2TY");
		bdisp_dbg_dump_xy(s, node->s2xy, "S2XY");
		bdisp_dbg_dump_sz(s, node->s2sz, "S2SZ");
		seq_puts(s, "-- Source 3 --\n");
		seq_printf(s, "S3BA\t0x%08X\n", node->s3ba);
		bdisp_dbg_dump_sty(s, node->s3ty, node->s3ba, "S3TY");
		bdisp_dbg_dump_xy(s, node->s3xy, "S3XY");
		bdisp_dbg_dump_sz(s, node->s3sz, "S3SZ");
		/* Clipping not dumped */
		/* CLUT not dumped */
		seq_puts(s, "-- Filter & Mask --\n");
		bdisp_dbg_dump_fctl(s, node->fctl);
		/* PMK not dumped */
		seq_puts(s, "-- Chroma Filter --\n");
		bdisp_dbg_dump_rsf(s, node->rsf, "RSF");
		bdisp_dbg_dump_rzi(s, node->rzi, "RZI");
		seq_printf(s, "HFP\t0x%08X\n", node->hfp);
		seq_printf(s, "VFP\t0x%08X\n", node->vfp);
		seq_puts(s, "-- Luma Filter --\n");
		bdisp_dbg_dump_rsf(s, node->y_rsf, "Y_RSF");
		bdisp_dbg_dump_rzi(s, node->y_rzi, "Y_RZI");
		seq_printf(s, "Y_HFP\t0x%08X\n", node->y_hfp);
		seq_printf(s, "Y_VFP\t0x%08X\n", node->y_vfp);
		/* Flicker not dumped */
		/* Color key not dumped */
		/* Reserved not dumped */
		/* Static Address & User not dumped */
		seq_puts(s, "-- Input Versatile Matrix --\n");
		bdisp_dbg_dump_ivmx(s, node->ivmx0, node->ivmx1,
				    node->ivmx2, node->ivmx3);
		/* Output Versatile Matrix not dumped */
		/* Pace not dumped */
		/* VC1R & DEI not dumped */
		/* Gradient Fill not dumped */
	} while ((++i < MAX_NB_NODE) && node->nip);

	return 0;
}

static int bdisp_dbg_last_nodes_raw(struct seq_file *s, void *data)
{
	struct bdisp_dev *bdisp = s->private;
	struct bdisp_node *node;
	u32 *val;
	int j, i = 0;

	if (!bdisp->dbg.copy_node[0]) {
		seq_puts(s, "No node built yet\n");
		return 0;
	}

	do {
		node = bdisp->dbg.copy_node[i];
		if (!node)
			break;

		seq_printf(s, "--------\nNode %d:\n", i);
		val = (u32 *)node;
		for (j = 0; j < sizeof(struct bdisp_node) / sizeof(u32); j++)
			seq_printf(s, "0x%08X\n", *val++);
	} while ((++i < MAX_NB_NODE) && node->nip);

	return 0;
}

static const char *bdisp_fmt_to_str(struct bdisp_frame frame)
{
	switch (frame.fmt->pixelformat) {
	case V4L2_PIX_FMT_YUV420:
		return "YUV420P";
	case V4L2_PIX_FMT_NV12:
		if (frame.field == V4L2_FIELD_INTERLACED)
			return "NV12 interlaced";
		else
			return "NV12";
	case V4L2_PIX_FMT_RGB565:
		return "RGB16";
	case V4L2_PIX_FMT_XBGR32:
		return "XRGB";
	case V4L2_PIX_FMT_ABGR32:
		return "ARGB";
	default:
		return "????";
	}
}

static int bdisp_dbg_last_request(struct seq_file *s, void *data)
{
	struct bdisp_dev *bdisp = s->private;
	struct bdisp_request *request = &bdisp->dbg.copy_request;
	struct bdisp_frame src, dst;

	if (!request->nb_req) {
		seq_puts(s, "No request\n");
		return 0;
	}

	src = request->src;
	dst = request->dst;

	seq_printf(s, "\nRequest #%d\n", request->nb_req);

	seq_printf(s, "Format:    %s\t\t\t%s\n",
		   bdisp_fmt_to_str(src), bdisp_fmt_to_str(dst));
	seq_printf(s, "Crop area: %dx%d @ %d,%d  ==>\t%dx%d @ %d,%d\n",
		   src.crop.width, src.crop.height,
		   src.crop.left, src.crop.top,
		   dst.crop.width, dst.crop.height,
		   dst.crop.left, dst.crop.top);
	seq_printf(s, "Buff size: %dx%d\t\t%dx%d\n\n",
		   src.width, src.height, dst.width, dst.height);

	if (request->hflip)
		seq_puts(s, "Horizontal flip\n\n");

	if (request->vflip)
		seq_puts(s, "Vertical flip\n\n");

	return 0;
}

#define DUMP(reg) seq_printf(s, #reg " \t0x%08X\n", readl(bdisp->regs + reg))

static int bdisp_dbg_regs(struct seq_file *s, void *data)
{
	struct bdisp_dev *bdisp = s->private;
	int ret;
	unsigned int i;

	ret = pm_runtime_get_sync(bdisp->dev);
	if (ret < 0) {
		seq_puts(s, "Cannot wake up IP\n");
		return 0;
	}

	seq_printf(s, "Reg @ = 0x%p\n", bdisp->regs);

	seq_puts(s, "\nStatic:\n");
	DUMP(BLT_CTL);
	DUMP(BLT_ITS);
	DUMP(BLT_STA1);
	DUMP(BLT_AQ1_CTL);
	DUMP(BLT_AQ1_IP);
	DUMP(BLT_AQ1_LNA);
	DUMP(BLT_AQ1_STA);
	DUMP(BLT_ITM0);

	seq_puts(s, "\nPlugs:\n");
	DUMP(BLT_PLUGS1_OP2);
	DUMP(BLT_PLUGS1_CHZ);
	DUMP(BLT_PLUGS1_MSZ);
	DUMP(BLT_PLUGS1_PGZ);
	DUMP(BLT_PLUGS2_OP2);
	DUMP(BLT_PLUGS2_CHZ);
	DUMP(BLT_PLUGS2_MSZ);
	DUMP(BLT_PLUGS2_PGZ);
	DUMP(BLT_PLUGS3_OP2);
	DUMP(BLT_PLUGS3_CHZ);
	DUMP(BLT_PLUGS3_MSZ);
	DUMP(BLT_PLUGS3_PGZ);
	DUMP(BLT_PLUGT_OP2);
	DUMP(BLT_PLUGT_CHZ);
	DUMP(BLT_PLUGT_MSZ);
	DUMP(BLT_PLUGT_PGZ);

	seq_puts(s, "\nNode:\n");
	DUMP(BLT_NIP);
	DUMP(BLT_CIC);
	DUMP(BLT_INS);
	DUMP(BLT_ACK);
	DUMP(BLT_TBA);
	DUMP(BLT_TTY);
	DUMP(BLT_TXY);
	DUMP(BLT_TSZ);
	DUMP(BLT_S1BA);
	DUMP(BLT_S1TY);
	DUMP(BLT_S1XY);
	DUMP(BLT_S2BA);
	DUMP(BLT_S2TY);
	DUMP(BLT_S2XY);
	DUMP(BLT_S2SZ);
	DUMP(BLT_S3BA);
	DUMP(BLT_S3TY);
	DUMP(BLT_S3XY);
	DUMP(BLT_S3SZ);
	DUMP(BLT_FCTL);
	DUMP(BLT_RSF);
	DUMP(BLT_RZI);
	DUMP(BLT_HFP);
	DUMP(BLT_VFP);
	DUMP(BLT_Y_RSF);
	DUMP(BLT_Y_RZI);
	DUMP(BLT_Y_HFP);
	DUMP(BLT_Y_VFP);
	DUMP(BLT_IVMX0);
	DUMP(BLT_IVMX1);
	DUMP(BLT_IVMX2);
	DUMP(BLT_IVMX3);
	DUMP(BLT_OVMX0);
	DUMP(BLT_OVMX1);
	DUMP(BLT_OVMX2);
	DUMP(BLT_OVMX3);
	DUMP(BLT_DEI);

	seq_puts(s, "\nFilter:\n");
	for (i = 0; i < BLT_NB_H_COEF; i++) {
		seq_printf(s, "BLT_HFC%d \t0x%08X\n", i,
			   readl(bdisp->regs + BLT_HFC_N + i * 4));
	}
	for (i = 0; i < BLT_NB_V_COEF; i++) {
		seq_printf(s, "BLT_VFC%d \t0x%08X\n", i,
			   readl(bdisp->regs + BLT_VFC_N + i * 4));
	}

	seq_puts(s, "\nLuma filter:\n");
	for (i = 0; i < BLT_NB_H_COEF; i++) {
		seq_printf(s, "BLT_Y_HFC%d \t0x%08X\n", i,
			   readl(bdisp->regs + BLT_Y_HFC_N + i * 4));
	}
	for (i = 0; i < BLT_NB_V_COEF; i++) {
		seq_printf(s, "BLT_Y_VFC%d \t0x%08X\n", i,
			   readl(bdisp->regs + BLT_Y_VFC_N + i * 4));
	}

	pm_runtime_put(bdisp->dev);

	return 0;
}

static int bdisp_dbg_perf(struct seq_file *s, void *data)
{
	struct bdisp_dev *bdisp = s->private;
	struct bdisp_request *request = &bdisp->dbg.copy_request;
	s64 avg_time_us;
	int avg_fps, min_fps, max_fps, last_fps;

	if (!request->nb_req) {
		seq_puts(s, "No request\n");
		return 0;
	}

	avg_time_us = bdisp->dbg.tot_duration;
	do_div(avg_time_us, request->nb_req);

	avg_fps = 1000000;
	min_fps = 1000000;
	max_fps = 1000000;
	last_fps = 1000000;
	do_div(avg_fps, avg_time_us);
	do_div(min_fps, bdisp->dbg.min_duration);
	do_div(max_fps, bdisp->dbg.max_duration);
	do_div(last_fps, bdisp->dbg.last_duration);

	seq_printf(s, "HW processing (%d requests):\n", request->nb_req);
	seq_printf(s, " Average: %5lld us  (%3d fps)\n",
		   avg_time_us, avg_fps);
	seq_printf(s, " Min-Max: %5lld us  (%3d fps) - %5lld us  (%3d fps)\n",
		   bdisp->dbg.min_duration, min_fps,
		   bdisp->dbg.max_duration, max_fps);
	seq_printf(s, " Last:    %5lld us  (%3d fps)\n",
		   bdisp->dbg.last_duration, last_fps);

	return 0;
}

#define bdisp_dbg_declare(name) \
	static int bdisp_dbg_##name##_open(struct inode *i, struct file *f) \
	{ \
		return single_open(f, bdisp_dbg_##name, i->i_private); \
	} \
	static const struct file_operations bdisp_dbg_##name##_fops = { \
		.open           = bdisp_dbg_##name##_open, \
		.read           = seq_read, \
		.llseek         = seq_lseek, \
		.release        = single_release, \
	}

#define bdisp_dbg_create_entry(name) \
	debugfs_create_file(#name, S_IRUGO, bdisp->dbg.debugfs_entry, bdisp, \
			    &bdisp_dbg_##name##_fops)

bdisp_dbg_declare(regs);
bdisp_dbg_declare(last_nodes);
bdisp_dbg_declare(last_nodes_raw);
bdisp_dbg_declare(last_request);
bdisp_dbg_declare(perf);

int bdisp_debugfs_create(struct bdisp_dev *bdisp)
{
	char dirname[16];

	snprintf(dirname, sizeof(dirname), "%s%d", BDISP_NAME, bdisp->id);
	bdisp->dbg.debugfs_entry = debugfs_create_dir(dirname, NULL);
	if (!bdisp->dbg.debugfs_entry)
		goto err;

	if (!bdisp_dbg_create_entry(regs))
		goto err;

	if (!bdisp_dbg_create_entry(last_nodes))
		goto err;

	if (!bdisp_dbg_create_entry(last_nodes_raw))
		goto err;

	if (!bdisp_dbg_create_entry(last_request))
		goto err;

	if (!bdisp_dbg_create_entry(perf))
		goto err;

	return 0;

err:
	bdisp_debugfs_remove(bdisp);
	return 0;
}

void bdisp_debugfs_remove(struct bdisp_dev *bdisp)
{
	debugfs_remove_recursive(bdisp->dbg.debugfs_entry);
	bdisp->dbg.debugfs_entry = NULL;
}
Commit	Line	Data
34b6beb6 FD	1	/*
	2	* Copyright (C) STMicroelectronics SA 2014
	3	* Authors: Fabien Dessenne <fabien.dessenne@st.com> for STMicroelectronics.
	4	* License terms: GNU General Public License (GPL), version 2
	5	*/
	6
	7	#include <linux/debugfs.h>
	8	#include <linux/pm_runtime.h>
	9
	10	#include "bdisp.h"
	11	#include "bdisp-filter.h"
	12	#include "bdisp-reg.h"
	13
	14	void bdisp_dbg_perf_begin(struct bdisp_dev *bdisp)
	15	{
	16	bdisp->dbg.hw_start = ktime_get();
	17	}
	18
	19	void bdisp_dbg_perf_end(struct bdisp_dev *bdisp)
	20	{
	21	s64 time_us;
	22
	23	time_us = ktime_us_delta(ktime_get(), bdisp->dbg.hw_start);
	24
	25	if (!bdisp->dbg.min_duration)
	26	bdisp->dbg.min_duration = time_us;
	27	else
	28	bdisp->dbg.min_duration = min(time_us, bdisp->dbg.min_duration);
	29
	30	bdisp->dbg.last_duration = time_us;
	31	bdisp->dbg.max_duration = max(time_us, bdisp->dbg.max_duration);
	32	bdisp->dbg.tot_duration += time_us;
	33	}
	34
	35	static void bdisp_dbg_dump_ins(struct seq_file *s, u32 val)
	36	{
	37	seq_printf(s, "INS\t0x%08X\t", val);
	38
	39	switch (val & BLT_INS_S1_MASK) {
	40	case BLT_INS_S1_OFF:
	41	break;
	42	case BLT_INS_S1_MEM:
	43	seq_puts(s, "SRC1=mem - ");
	44	break;
	45	case BLT_INS_S1_CF:
	46	seq_puts(s, "SRC1=ColorFill - ");
	47	break;
	48	case BLT_INS_S1_COPY:
	49	seq_puts(s, "SRC1=copy - ");
	50	break;
	51	case BLT_INS_S1_FILL:
	52	seq_puts(s, "SRC1=fil - ");
	53	break;
	54	default:
	55	seq_puts(s, "SRC1=??? - ");
	56	break;
	57	}
	58
	59	switch (val & BLT_INS_S2_MASK) {
	60	case BLT_INS_S2_OFF:
	61	break;
	62	case BLT_INS_S2_MEM:
	63	seq_puts(s, "SRC2=mem - ");
	64	break;
65	case BLT_INS_S2_CF:
66	seq_puts(s, "SRC2=ColorFill - ");
67	break;
68	default:
69	seq_puts(s, "SRC2=??? - ");
70	break;
71	}
72
73	if ((val & BLT_INS_S3_MASK) == BLT_INS_S3_MEM)
74	seq_puts(s, "SRC3=mem - ");
75
76	if (val & BLT_INS_IVMX)
77	seq_puts(s, "IVMX - ");
78	if (val & BLT_INS_CLUT)
79	seq_puts(s, "CLUT - ");
80	if (val & BLT_INS_SCALE)
81	seq_puts(s, "Scale - ");
82	if (val & BLT_INS_FLICK)
83	seq_puts(s, "Flicker - ");
84	if (val & BLT_INS_CLIP)
85	seq_puts(s, "Clip - ");
86	if (val & BLT_INS_CKEY)
87	seq_puts(s, "ColorKey - ");
88	if (val & BLT_INS_OVMX)
89	seq_puts(s, "OVMX - ");
90	if (val & BLT_INS_DEI)
91	seq_puts(s, "Deint - ");
92	if (val & BLT_INS_PMASK)
93	seq_puts(s, "PlaneMask - ");
94	if (val & BLT_INS_VC1R)
95	seq_puts(s, "VC1R - ");
96	if (val & BLT_INS_ROTATE)
97	seq_puts(s, "Rotate - ");
98	if (val & BLT_INS_GRAD)
99	seq_puts(s, "GradFill - ");
100	if (val & BLT_INS_AQLOCK)
101	seq_puts(s, "AQLock - ");
102	if (val & BLT_INS_PACE)
103	seq_puts(s, "Pace - ");
104	if (val & BLT_INS_IRQ)
105	seq_puts(s, "IRQ - ");
106
107	seq_puts(s, "\n");
108	}
109
110	static void bdisp_dbg_dump_tty(struct seq_file *s, u32 val)
111	{
112	seq_printf(s, "TTY\t0x%08X\t", val);
113	seq_printf(s, "Pitch=%d - ", val & 0xFFFF);
114
115	switch ((val & BLT_TTY_COL_MASK) >> BLT_TTY_COL_SHIFT) {
116	case BDISP_RGB565:
117	seq_puts(s, "RGB565 - ");
118	break;
119	case BDISP_XRGB8888:
120	seq_puts(s, "xRGB888 - ");
121	break;
122	case BDISP_ARGB8888:
123	seq_puts(s, "ARGB8888 - ");
124	break;
125	case BDISP_NV12:
126	seq_puts(s, "NV12 - ");
127	break;
128	case BDISP_YUV_3B:
129	seq_puts(s, "YUV420P - ");
130	break;
131	default:
132	seq_puts(s, "ColorFormat ??? - ");
133	break;
134	}
135
136	if (val & BLT_TTY_ALPHA_R)
137	seq_puts(s, "AlphaRange - ");
138	if (val & BLT_TTY_CR_NOT_CB)
139	seq_puts(s, "CrNotCb - ");
140	if (val & BLT_TTY_MB)
141	seq_puts(s, "MB - ");
142	if (val & BLT_TTY_HSO)
143	seq_puts(s, "HSO inverse - ");
144	if (val & BLT_TTY_VSO)
145	seq_puts(s, "VSO inverse - ");
146	if (val & BLT_TTY_DITHER)
147	seq_puts(s, "Dither - ");
148	if (val & BLT_TTY_CHROMA)
149	seq_puts(s, "Write CHROMA - ");
150	if (val & BLT_TTY_BIG_END)
151	seq_puts(s, "BigEndian - ");
152
153	seq_puts(s, "\n");
154	}
155
156	static void bdisp_dbg_dump_xy(struct seq_file s, u32 val, char name)
157	{
158	seq_printf(s, "%s\t0x%08X\t", name, val);
159	seq_printf(s, "(%d,%d)\n", val & 0xFFFF, (val >> 16));
160	}
161
162	static void bdisp_dbg_dump_sz(struct seq_file s, u32 val, char name)
163	{
164	seq_printf(s, "%s\t0x%08X\t", name, val);
165	seq_printf(s, "%dx%d\n", val & 0x1FFF, (val >> 16) & 0x1FFF);
166	}
167
168	static void bdisp_dbg_dump_sty(struct seq_file *s,
169	u32 val, u32 addr, char *name)
170	{
171	bool s1, s2, s3;
172
173	seq_printf(s, "%s\t0x%08X\t", name, val);
174
175	if (!addr \|\| !name \|\| (strlen(name) < 2))
176	goto done;
177
178	s1 = name[strlen(name) - 1] == '1';
179	s2 = name[strlen(name) - 1] == '2';
180	s3 = name[strlen(name) - 1] == '3';
181
182	seq_printf(s, "Pitch=%d - ", val & 0xFFFF);
183
184	switch ((val & BLT_TTY_COL_MASK) >> BLT_TTY_COL_SHIFT) {
185	case BDISP_RGB565:
186	seq_puts(s, "RGB565 - ");
187	break;
188	case BDISP_XRGB8888:
189	seq_puts(s, "xRGB888 - ");
190	break;
191	case BDISP_ARGB8888:
192	seq_puts(s, "ARGB888 - ");
193	break;
194	case BDISP_NV12:
195	seq_puts(s, "NV12 - ");
196	break;
197	case BDISP_YUV_3B:
198	seq_puts(s, "YUV420P - ");
199	break;
200	default:
201	seq_puts(s, "ColorFormat ??? - ");
202	break;
203	}
204
205	if ((val & BLT_TTY_ALPHA_R) && !s3)
206	seq_puts(s, "AlphaRange - ");
207	if ((val & BLT_S1TY_A1_SUBSET) && !s3)
208	seq_puts(s, "A1SubSet - ");
209	if ((val & BLT_TTY_MB) && !s1)
210	seq_puts(s, "MB - ");
211	if (val & BLT_TTY_HSO)
212	seq_puts(s, "HSO inverse - ");
213	if (val & BLT_TTY_VSO)
214	seq_puts(s, "VSO inverse - ");
215	if ((val & BLT_S1TY_CHROMA_EXT) && (s1 \|\| s2))
216	seq_puts(s, "ChromaExt - ");
217	if ((val & BLT_S3TY_BLANK_ACC) && s3)
218	seq_puts(s, "Blank Acc - ");
219	if ((val & BTL_S1TY_SUBBYTE) && !s3)
220	seq_puts(s, "SubByte - ");
221	if ((val & BLT_S1TY_RGB_EXP) && !s3)
222	seq_puts(s, "RGBExpand - ");
223	if ((val & BLT_TTY_BIG_END) && !s3)
224	seq_puts(s, "BigEndian - ");
225
226	done:
227	seq_puts(s, "\n");
228	}
229
230	static void bdisp_dbg_dump_fctl(struct seq_file *s, u32 val)
231	{
232	seq_printf(s, "FCTL\t0x%08X\t", val);
233
234	if ((val & BLT_FCTL_Y_HV_SCALE) == BLT_FCTL_Y_HV_SCALE)
235	seq_puts(s, "Resize Luma - ");
236	else if ((val & BLT_FCTL_Y_HV_SCALE) == BLT_FCTL_Y_HV_SAMPLE)
237	seq_puts(s, "Sample Luma - ");
238
239	if ((val & BLT_FCTL_HV_SCALE) == BLT_FCTL_HV_SCALE)
240	seq_puts(s, "Resize Chroma");
241	else if ((val & BLT_FCTL_HV_SCALE) == BLT_FCTL_HV_SAMPLE)
242	seq_puts(s, "Sample Chroma");
243
244	seq_puts(s, "\n");
245	}
246
247	static void bdisp_dbg_dump_rsf(struct seq_file s, u32 val, char name)
248	{
249	u32 inc;
250
251	seq_printf(s, "%s\t0x%08X\t", name, val);
252
253	if (!val)
254	goto done;
255
256	inc = val & 0xFFFF;
257	seq_printf(s, "H: %d(6.10) / scale~%dx0.1 - ", inc, 1024 * 10 / inc);
258
259	inc = val >> 16;
260	seq_printf(s, "V: %d(6.10) / scale~%dx0.1", inc, 1024 * 10 / inc);
261
262	done:
263	seq_puts(s, "\n");
264	}
265
266	static void bdisp_dbg_dump_rzi(struct seq_file s, u32 val, char name)
267	{
268	seq_printf(s, "%s\t0x%08X\t", name, val);
269
270	if (!val)
271	goto done;
272
273	seq_printf(s, "H: init=%d repeat=%d - ", val & 0x3FF, (val >> 12) & 7);
274	val >>= 16;
275	seq_printf(s, "V: init=%d repeat=%d", val & 0x3FF, (val >> 12) & 7);
276
277	done:
278	seq_puts(s, "\n");
279	}
280
281	static void bdisp_dbg_dump_ivmx(struct seq_file *s,
282	u32 c0, u32 c1, u32 c2, u32 c3)
283	{
284	seq_printf(s, "IVMX0\t0x%08X\n", c0);
285	seq_printf(s, "IVMX1\t0x%08X\n", c1);
286	seq_printf(s, "IVMX2\t0x%08X\n", c2);
287	seq_printf(s, "IVMX3\t0x%08X\t", c3);
288
289	if (!c0 && !c1 && !c2 && !c3) {
290	seq_puts(s, "\n");
291	return;
292	}
293
294	if ((c0 == bdisp_rgb_to_yuv[0]) &&
295	(c1 == bdisp_rgb_to_yuv[1]) &&
296	(c2 == bdisp_rgb_to_yuv[2]) &&
297	(c3 == bdisp_rgb_to_yuv[3])) {
298	seq_puts(s, "RGB to YUV\n");
299	return;
300	}
301
302	if ((c0 == bdisp_yuv_to_rgb[0]) &&
303	(c1 == bdisp_yuv_to_rgb[1]) &&
304	(c2 == bdisp_yuv_to_rgb[2]) &&
305	(c3 == bdisp_yuv_to_rgb[3])) {
306	seq_puts(s, "YUV to RGB\n");
307	return;
308	}
309	seq_puts(s, "Unknown conversion\n");
310	}
311
312	static int bdisp_dbg_last_nodes(struct seq_file s, void data)
313	{
314	/* Not dumping all fields, focusing on significant ones */
315	struct bdisp_dev *bdisp = s->private;
316	struct bdisp_node *node;
317	int i = 0;
318
319	if (!bdisp->dbg.copy_node[0]) {
320	seq_puts(s, "No node built yet\n");
321	return 0;
322	}
323
324	do {
325	node = bdisp->dbg.copy_node[i];
326	if (!node)
327	break;
328	seq_printf(s, "--------\nNode %d:\n", i);
329	seq_puts(s, "-- General --\n");
330	seq_printf(s, "NIP\t0x%08X\n", node->nip);
331	seq_printf(s, "CIC\t0x%08X\n", node->cic);
332	bdisp_dbg_dump_ins(s, node->ins);
333	seq_printf(s, "ACK\t0x%08X\n", node->ack);
334	seq_puts(s, "-- Target --\n");
335	seq_printf(s, "TBA\t0x%08X\n", node->tba);
336	bdisp_dbg_dump_tty(s, node->tty);
337	bdisp_dbg_dump_xy(s, node->txy, "TXY");
338	bdisp_dbg_dump_sz(s, node->tsz, "TSZ");
339	/* Color Fill not dumped */
340	seq_puts(s, "-- Source 1 --\n");
341	seq_printf(s, "S1BA\t0x%08X\n", node->s1ba);
342	bdisp_dbg_dump_sty(s, node->s1ty, node->s1ba, "S1TY");
343	bdisp_dbg_dump_xy(s, node->s1xy, "S1XY");
344	seq_puts(s, "-- Source 2 --\n");
345	seq_printf(s, "S2BA\t0x%08X\n", node->s2ba);
346	bdisp_dbg_dump_sty(s, node->s2ty, node->s2ba, "S2TY");
347	bdisp_dbg_dump_xy(s, node->s2xy, "S2XY");
348	bdisp_dbg_dump_sz(s, node->s2sz, "S2SZ");
349	seq_puts(s, "-- Source 3 --\n");
350	seq_printf(s, "S3BA\t0x%08X\n", node->s3ba);
351	bdisp_dbg_dump_sty(s, node->s3ty, node->s3ba, "S3TY");
352	bdisp_dbg_dump_xy(s, node->s3xy, "S3XY");
353	bdisp_dbg_dump_sz(s, node->s3sz, "S3SZ");
354	/* Clipping not dumped */
355	/* CLUT not dumped */
356	seq_puts(s, "-- Filter & Mask --\n");
357	bdisp_dbg_dump_fctl(s, node->fctl);
358	/* PMK not dumped */
359	seq_puts(s, "-- Chroma Filter --\n");
360	bdisp_dbg_dump_rsf(s, node->rsf, "RSF");
361	bdisp_dbg_dump_rzi(s, node->rzi, "RZI");
362	seq_printf(s, "HFP\t0x%08X\n", node->hfp);
363	seq_printf(s, "VFP\t0x%08X\n", node->vfp);
364	seq_puts(s, "-- Luma Filter --\n");
365	bdisp_dbg_dump_rsf(s, node->y_rsf, "Y_RSF");
366	bdisp_dbg_dump_rzi(s, node->y_rzi, "Y_RZI");
367	seq_printf(s, "Y_HFP\t0x%08X\n", node->y_hfp);
368	seq_printf(s, "Y_VFP\t0x%08X\n", node->y_vfp);
369	/* Flicker not dumped */
370	/* Color key not dumped */
371	/* Reserved not dumped */
372	/* Static Address & User not dumped */
373	seq_puts(s, "-- Input Versatile Matrix --\n");
374	bdisp_dbg_dump_ivmx(s, node->ivmx0, node->ivmx1,
375	node->ivmx2, node->ivmx3);
376	/* Output Versatile Matrix not dumped */
377	/* Pace not dumped */
378	/* VC1R & DEI not dumped */
379	/* Gradient Fill not dumped */
380	} while ((++i < MAX_NB_NODE) && node->nip);
381
382	return 0;
383	}
384
385	static int bdisp_dbg_last_nodes_raw(struct seq_file s, void data)
386	{
387	struct bdisp_dev *bdisp = s->private;
388	struct bdisp_node *node;
389	u32 *val;
390	int j, i = 0;
391
392	if (!bdisp->dbg.copy_node[0]) {
393	seq_puts(s, "No node built yet\n");
394	return 0;
395	}
396
397	do {
398	node = bdisp->dbg.copy_node[i];
399	if (!node)
400	break;
401
402	seq_printf(s, "--------\nNode %d:\n", i);
403	val = (u32 *)node;
404	for (j = 0; j < sizeof(struct bdisp_node) / sizeof(u32); j++)
405	seq_printf(s, "0x%08X\n", *val++);
406	} while ((++i < MAX_NB_NODE) && node->nip);
407
408	return 0;
409	}
410
411	static const char *bdisp_fmt_to_str(struct bdisp_frame frame)
412	{
413	switch (frame.fmt->pixelformat) {
414	case V4L2_PIX_FMT_YUV420:
415	return "YUV420P";
416	case V4L2_PIX_FMT_NV12:
417	if (frame.field == V4L2_FIELD_INTERLACED)
418	return "NV12 interlaced";
419	else
420	return "NV12";
421	case V4L2_PIX_FMT_RGB565:
422	return "RGB16";
423	case V4L2_PIX_FMT_XBGR32:
424	return "XRGB";
425	case V4L2_PIX_FMT_ABGR32:
426	return "ARGB";
427	default:
428	return "????";
429	}
430	}
431
432	static int bdisp_dbg_last_request(struct seq_file s, void data)
433	{
434	struct bdisp_dev *bdisp = s->private;
435	struct bdisp_request *request = &bdisp->dbg.copy_request;
436	struct bdisp_frame src, dst;
437
438	if (!request->nb_req) {
439	seq_puts(s, "No request\n");
440	return 0;
441	}
442
443	src = request->src;
444	dst = request->dst;
445
446	seq_printf(s, "\nRequest #%d\n", request->nb_req);
447
448	seq_printf(s, "Format: %s\t\t\t%s\n",
449	bdisp_fmt_to_str(src), bdisp_fmt_to_str(dst));
450	seq_printf(s, "Crop area: %dx%d @ %d,%d ==>\t%dx%d @ %d,%d\n",
451	src.crop.width, src.crop.height,
452	src.crop.left, src.crop.top,
453	dst.crop.width, dst.crop.height,
454	dst.crop.left, dst.crop.top);
455	seq_printf(s, "Buff size: %dx%d\t\t%dx%d\n\n",
456	src.width, src.height, dst.width, dst.height);
457
458	if (request->hflip)
459	seq_puts(s, "Horizontal flip\n\n");
460
461	if (request->vflip)
462	seq_puts(s, "Vertical flip\n\n");
463
464	return 0;
465	}
466
467	#define DUMP(reg) seq_printf(s, #reg " \t0x%08X\n", readl(bdisp->regs + reg))
468
469	static int bdisp_dbg_regs(struct seq_file s, void data)
470	{
471	struct bdisp_dev *bdisp = s->private;
472	int ret;
473	unsigned int i;
474
475	ret = pm_runtime_get_sync(bdisp->dev);
476	if (ret < 0) {
477	seq_puts(s, "Cannot wake up IP\n");
478	return 0;
479	}
480
481	seq_printf(s, "Reg @ = 0x%p\n", bdisp->regs);
482
483	seq_puts(s, "\nStatic:\n");
484	DUMP(BLT_CTL);
485	DUMP(BLT_ITS);
486	DUMP(BLT_STA1);
487	DUMP(BLT_AQ1_CTL);
488	DUMP(BLT_AQ1_IP);
489	DUMP(BLT_AQ1_LNA);
490	DUMP(BLT_AQ1_STA);
491	DUMP(BLT_ITM0);
492
493	seq_puts(s, "\nPlugs:\n");
494	DUMP(BLT_PLUGS1_OP2);
495	DUMP(BLT_PLUGS1_CHZ);
496	DUMP(BLT_PLUGS1_MSZ);
497	DUMP(BLT_PLUGS1_PGZ);
498	DUMP(BLT_PLUGS2_OP2);
499	DUMP(BLT_PLUGS2_CHZ);
500	DUMP(BLT_PLUGS2_MSZ);
501	DUMP(BLT_PLUGS2_PGZ);
502	DUMP(BLT_PLUGS3_OP2);
503	DUMP(BLT_PLUGS3_CHZ);
504	DUMP(BLT_PLUGS3_MSZ);
505	DUMP(BLT_PLUGS3_PGZ);
506	DUMP(BLT_PLUGT_OP2);
507	DUMP(BLT_PLUGT_CHZ);
508	DUMP(BLT_PLUGT_MSZ);
509	DUMP(BLT_PLUGT_PGZ);
510
511	seq_puts(s, "\nNode:\n");
512	DUMP(BLT_NIP);
513	DUMP(BLT_CIC);
514	DUMP(BLT_INS);
515	DUMP(BLT_ACK);
516	DUMP(BLT_TBA);
517	DUMP(BLT_TTY);
518	DUMP(BLT_TXY);
519	DUMP(BLT_TSZ);
520	DUMP(BLT_S1BA);
521	DUMP(BLT_S1TY);
522	DUMP(BLT_S1XY);
523	DUMP(BLT_S2BA);
524	DUMP(BLT_S2TY);
525	DUMP(BLT_S2XY);
526	DUMP(BLT_S2SZ);
527	DUMP(BLT_S3BA);
528	DUMP(BLT_S3TY);
529	DUMP(BLT_S3XY);
530	DUMP(BLT_S3SZ);
531	DUMP(BLT_FCTL);
532	DUMP(BLT_RSF);
533	DUMP(BLT_RZI);
534	DUMP(BLT_HFP);
535	DUMP(BLT_VFP);
536	DUMP(BLT_Y_RSF);
537	DUMP(BLT_Y_RZI);
538	DUMP(BLT_Y_HFP);
539	DUMP(BLT_Y_VFP);
540	DUMP(BLT_IVMX0);
541	DUMP(BLT_IVMX1);
542	DUMP(BLT_IVMX2);
543	DUMP(BLT_IVMX3);
544	DUMP(BLT_OVMX0);
545	DUMP(BLT_OVMX1);
546	DUMP(BLT_OVMX2);
547	DUMP(BLT_OVMX3);
548	DUMP(BLT_DEI);
549
550	seq_puts(s, "\nFilter:\n");
551	for (i = 0; i < BLT_NB_H_COEF; i++) {
552	seq_printf(s, "BLT_HFC%d \t0x%08X\n", i,
553	readl(bdisp->regs + BLT_HFC_N + i * 4));
554	}
555	for (i = 0; i < BLT_NB_V_COEF; i++) {
556	seq_printf(s, "BLT_VFC%d \t0x%08X\n", i,
557	readl(bdisp->regs + BLT_VFC_N + i * 4));
558	}
559
560	seq_puts(s, "\nLuma filter:\n");
561	for (i = 0; i < BLT_NB_H_COEF; i++) {
562	seq_printf(s, "BLT_Y_HFC%d \t0x%08X\n", i,
563	readl(bdisp->regs + BLT_Y_HFC_N + i * 4));
564	}
565	for (i = 0; i < BLT_NB_V_COEF; i++) {
566	seq_printf(s, "BLT_Y_VFC%d \t0x%08X\n", i,
567	readl(bdisp->regs + BLT_Y_VFC_N + i * 4));
568	}
569
570	pm_runtime_put(bdisp->dev);
571
572	return 0;
573	}
574
575	static int bdisp_dbg_perf(struct seq_file s, void data)
576	{
577	struct bdisp_dev *bdisp = s->private;
578	struct bdisp_request *request = &bdisp->dbg.copy_request;
579	s64 avg_time_us;
580	int avg_fps, min_fps, max_fps, last_fps;
581
582	if (!request->nb_req) {
583	seq_puts(s, "No request\n");
584	return 0;
585	}
586
587	avg_time_us = bdisp->dbg.tot_duration;
588	do_div(avg_time_us, request->nb_req);
589
590	avg_fps = 1000000;
591	min_fps = 1000000;
592	max_fps = 1000000;
593	last_fps = 1000000;
594	do_div(avg_fps, avg_time_us);
595	do_div(min_fps, bdisp->dbg.min_duration);
596	do_div(max_fps, bdisp->dbg.max_duration);
597	do_div(last_fps, bdisp->dbg.last_duration);
598
599	seq_printf(s, "HW processing (%d requests):\n", request->nb_req);
600	seq_printf(s, " Average: %5lld us (%3d fps)\n",
601	avg_time_us, avg_fps);
602	seq_printf(s, " Min-Max: %5lld us (%3d fps) - %5lld us (%3d fps)\n",
603	bdisp->dbg.min_duration, min_fps,
604	bdisp->dbg.max_duration, max_fps);
605	seq_printf(s, " Last: %5lld us (%3d fps)\n",
606	bdisp->dbg.last_duration, last_fps);
607
608	return 0;
609	}
610
611	#define bdisp_dbg_declare(name) \
612	static int bdisp_dbg_##name##_open(struct inode i, struct file f) \
613	{ \
614	return single_open(f, bdisp_dbg_##name, i->i_private); \
615	} \
616	static const struct file_operations bdisp_dbg_##name##_fops = { \
617	.open = bdisp_dbg_##name##_open, \
618	.read = seq_read, \
619	.llseek = seq_lseek, \
620	.release = single_release, \
621	}
622
623	#define bdisp_dbg_create_entry(name) \
624	debugfs_create_file(#name, S_IRUGO, bdisp->dbg.debugfs_entry, bdisp, \
625	&bdisp_dbg_##name##_fops)
626
627	bdisp_dbg_declare(regs);
628	bdisp_dbg_declare(last_nodes);
629	bdisp_dbg_declare(last_nodes_raw);
630	bdisp_dbg_declare(last_request);
631	bdisp_dbg_declare(perf);
632
633	int bdisp_debugfs_create(struct bdisp_dev *bdisp)
634	{
635	char dirname[16];
636
637	snprintf(dirname, sizeof(dirname), "%s%d", BDISP_NAME, bdisp->id);
638	bdisp->dbg.debugfs_entry = debugfs_create_dir(dirname, NULL);
639	if (!bdisp->dbg.debugfs_entry)
640	goto err;
641
642	if (!bdisp_dbg_create_entry(regs))
643	goto err;
644
645	if (!bdisp_dbg_create_entry(last_nodes))
646	goto err;
647
648	if (!bdisp_dbg_create_entry(last_nodes_raw))
649	goto err;
650
651	if (!bdisp_dbg_create_entry(last_request))
652	goto err;
653
654	if (!bdisp_dbg_create_entry(perf))
655	goto err;
656
657	return 0;
658
659	err:
660	bdisp_debugfs_remove(bdisp);
661	return 0;
662	}
663
664	void bdisp_debugfs_remove(struct bdisp_dev *bdisp)
665	{
666	debugfs_remove_recursive(bdisp->dbg.debugfs_entry);
667	bdisp->dbg.debugfs_entry = NULL;
668	}