drivers/media/platform/sti/bdisp/bdisp-debug.c

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