OMAP:TILER: Add debugfs interfaces for Tiler

Added <debugfs>/tiler/map/2x1 file which contains the TILER container map
subsampled 2x1.  Reading this file will perform a dump of the tiler container.

Added <debugfs/tiler/alloc_debug debugfs parameter.  Setting this parameter
to a non-zero value will cause debug prints for each area allocation and
deallocation.

Signed-off-by: Lajos Molnar <molnar@ti.com>
Signed-off-by: Andy Gross<andy.gross@ti.com>

1 files changed, 217 insertions, 1 deletions

diff --git a/drivers/media/video/tiler/tiler-main.c b/drivers/media/video/tiler/tiler-main.c
index 92aac12dc3a..5feb83507a2 100644
--- a/drivers/media/video/tiler/tiler-main.c
+++ b/drivers/media/video/tiler/tiler-main.c
@@ -31,6 +31,8 @@
 #include <linux/pagemap.h>              /* page_cache_release() */
 #include <linux/slab.h>
 #include <linux/sched.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
 
 #include <mach/dmm.h>
 #include "tmm.h"
@@ -40,6 +42,7 @@
 static bool ssptr_id = CONFIG_TILER_SSPTR_ID;
 static uint default_align = CONFIG_TILER_ALIGNMENT;
 static uint granularity = CONFIG_TILER_GRANULARITY;
+static u32 tiler_alloc_debug;
 
 /*
  * We can only change ssptr_id if there are no blocks allocated, so that
@@ -52,10 +55,14 @@ module_param_named(align, default_align, uint, 0644);
 MODULE_PARM_DESC(align, "Default block ssptr alignment");
 module_param_named(grain, granularity, uint, 0644);
 MODULE_PARM_DESC(grain, "Granularity (bytes)");
+module_param_named(alloc_debug, tiler_alloc_debug, uint, 0644);
+MODULE_PARM_DESC(alloc_debug, "Allocation debug flag");
 
 struct tiler_dev {
         struct cdev cdev;
 };
+static struct dentry *dbgfs;
+static struct dentry *dbg_map;
 
 struct platform_driver tiler_driver_ldm = {
         .driver = {
@@ -163,6 +170,152 @@ static u32 _m_get_id(void)
         return id;
 }
 
+#define TILER_WIDTH 256
+#define TILER_HEIGHT 128
+
+static void fill_map(char **map, int div, struct tcm_area *a, char c, bool ovw)
+{
+        int x, y;
+        for (y = a->p0.y; y <= a->p1.y; y++)
+                for (x = a->p0.x / div; x <= a->p1.x / div; x++)
+                        if (map[y][x] == ' ' || ovw)
+                                map[y][x] = c;
+}
+
+static void fill_map_pt(char **map, int div, struct tcm_pt *p, char c)
+{
+        map[p->y][p->x / div] = c;
+}
+
+static char read_map_pt(char **map, int div, struct tcm_pt *p)
+{
+        return map[p->y][p->x / div];
+}
+
+static int map_width(int div, int x0, int x1)
+{
+        return (x1 / div) - (x0 / div) + 1;
+}
+
+static void text_map(char **map, int div, char *nice, int y, int x0, int x1)
+{
+        char *p = map[y] + (x0 / div);
+        int w = (map_width(div, x0, x1) - strlen(nice)) / 2;
+        if (w >= 0) {
+                p += w;
+                while (*nice)
+                        *p++ = *nice++;
+        }
+}
+
+static void map_1d_info(char **map, int div, char *nice, struct tcm_area *a)
+{
+        sprintf(nice, "%dK", tcm_sizeof(*a) * 4);
+        if (a->p0.y + 1 < a->p1.y) {
+                text_map(map, div, nice, (a->p0.y + a->p1.y) / 2, 0,
+                                                        TILER_WIDTH - 1);
+        } else if (a->p0.y < a->p1.y) {
+                if (strlen(nice) < map_width(div, a->p0.x, TILER_WIDTH - 1))
+                        text_map(map, div, nice, a->p0.y, a->p0.x + div,
+                                                        TILER_WIDTH - 1);
+                else if (strlen(nice) < map_width(div, 0, a->p1.x))
+                        text_map(map, div, nice, a->p1.y, 0, a->p1.y - div);
+        } else if (strlen(nice) + 1 < map_width(div, a->p0.x, a->p1.x)) {
+                text_map(map, div, nice, a->p0.y, a->p0.x, a->p1.x);
+        }
+}
+
+static void map_2d_info(char **map, int div, char *nice, struct tcm_area *a)
+{
+        sprintf(nice, "(%d*%d)", tcm_awidth(*a), tcm_aheight(*a));
+        if (strlen(nice) + 1 < map_width(div, a->p0.x, a->p1.x))
+                text_map(map, div, nice, (a->p0.y + a->p1.y) / 2, a->p0.x,
+                         a->p1.x);
+}
+
+static void debug_allocation_map(struct seq_file *s)
+{
+        int div = 2;
+        int i;
+        char **map, *global_map;
+        struct area_info *ai;
+        struct mem_info *mi;
+        struct tcm_area a, p;
+        static char *m2d = "abcdefghijklmnopqrstuvwxyz"
+                                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        static char *a2d = ".,:;'\"`~!^-+";
+        char *m2dp = m2d, *a2dp = a2d;
+        char nice[128];
+
+        /* allocate map */
+        map = kzalloc(TILER_HEIGHT * sizeof(*map), GFP_KERNEL);
+        global_map = kzalloc((TILER_WIDTH / div + 1) * TILER_HEIGHT,
+                                                                GFP_KERNEL);
+        if (!map || !global_map) {
+                printk(KERN_ERR "could not allocate map for debug print\n");
+                goto error;
+        }
+        memset(global_map, ' ', (TILER_WIDTH / div + 1) * TILER_HEIGHT);
+        for (i = 0; i < TILER_HEIGHT; i++) {
+                map[i] = global_map + i * (TILER_WIDTH / div + 1);
+                map[i][TILER_WIDTH / div] = 0;
+        }
+
+        /* get all allocations */
+        mutex_lock(&mtx);
+
+        list_for_each_entry(mi, &blocks, global) {
+                if (mi->area.is2d) {
+                        ai = mi->parent;
+                        fill_map(map, div, &ai->area, *a2dp, false);
+                        fill_map(map, div, &mi->area, *m2dp, true);
+                        if (!*++a2dp)
+                                a2dp = a2d;
+                        if (!*++m2dp)
+                                m2dp = m2d;
+                        map_2d_info(map, div, nice, &mi->area);
+                } else {
+                        bool start = read_map_pt(map, div, &mi->area.p0) == ' ';
+                        bool end = read_map_pt(map, div, &mi->area.p1) == ' ';
+                        tcm_for_each_slice(a, mi->area, p)
+                        fill_map(map, div, &a, '=', true);
+                        fill_map_pt(map, div, &mi->area.p0, start ? '<' : 'X');
+                        fill_map_pt(map, div, &mi->area.p1, end ? '>' : 'X');
+                        map_1d_info(map, div, nice, &mi->area);
+                }
+        }
+
+        seq_printf(s, "BEGIN TILER MAP\n");
+        for (i = 0; i < TILER_HEIGHT; i++)
+                seq_printf(s, "%03d:%s\n", i, map[i]);
+        seq_printf(s, "END TILER MAP\n");
+
+        mutex_unlock(&mtx);
+
+error:
+        kfree(map);
+        kfree(global_map);
+}
+
+static int tiler_debug_show(struct seq_file *s, void *unused)
+{
+        void (*func)(struct seq_file *) = s->private;
+        func(s);
+        return 0;
+}
+
+static int tiler_debug_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, tiler_debug_show, inode->i_private);
+}
+
+static const struct file_operations tiler_debug_fops = {
+        .open           = tiler_debug_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 /*
  *  gid_info handling methods
  *  ==========================================================================
@@ -434,6 +587,16 @@ static struct mem_info *get_2d_area(u16 w, u16 h, u16 align, u16 offs, u16 band,
 
                         /* remove from reserved list */
                         list_del(&mi->global);
+                        if (tiler_alloc_debug & 1)
+                                 printk(KERN_ERR "(=2d (%d-%d,%d-%d) in (%d-%d,%d-%d) prereserved)\n",
+                                 mi->area.p0.x, mi->area.p1.x,
+                                 mi->area.p0.y, mi->area.p1.y,
+                                 ((struct area_info *) mi->parent)->area.p0.x,
+                                 ((struct area_info *) mi->parent)->area.p1.x,
+                                 ((struct area_info *) mi->parent)->area.p0.y,
+                                 ((struct area_info *) mi->parent)->area.p1.y);
+
+
                         goto done;
                 }
         }
@@ -454,6 +617,16 @@ static struct mem_info *get_2d_area(u16 w, u16 h, u16 align, u16 offs, u16 band,
                         x = _m_blk_find_fit(w, align, offs, ai, &before);
                         if (x) {
                                 _m_add2area(mi, ai, x - w, w, before);
+
+                                if (tiler_alloc_debug & 1)
+                                        printk(KERN_ERR "(+2d (%d-%d,%d-%d) in (%d-%d,%d-%d) existing)\n",
+                                        mi->area.p0.x, mi->area.p1.x,
+                                        mi->area.p0.y, mi->area.p1.y,
+                                        ((struct area_info *) mi->parent)->area.p0.x,
+                                        ((struct area_info *) mi->parent)->area.p1.x,
+                                        ((struct area_info *) mi->parent)->area.p0.y,
+                                        ((struct area_info *) mi->parent)->area.p1.y);
+
                                 goto done;
                         }
                 }
@@ -465,6 +638,13 @@ static struct mem_info *get_2d_area(u16 w, u16 h, u16 align, u16 offs, u16 band,
                       max(band, align), tcm, gi);
         if (ai) {
                 _m_add2area(mi, ai, ai->area.p0.x + offs, w, &ai->blocks);
+                if (tiler_alloc_debug & 1)
+                        printk(KERN_ERR "(+2d (%d-%d,%d-%d) in (%d-%d,%d-%d) new)\n",
+                                        mi->area.p0.x, mi->area.p1.x,
+                                        mi->area.p0.y, mi->area.p1.y,
+                                        ai->area.p0.x, ai->area.p1.x,
+                                        ai->area.p0.y, ai->area.p1.y);
+
         } else {
                 /* clean up */
                 kfree(mi);
@@ -608,14 +788,31 @@ static s32 _m_free(struct mem_info *mi)
 
                 /* check to see if area needs removing also */
                 if (ai && !--ai->nblocks) {
+                        if (tiler_alloc_debug & 1)
+                                printk(KERN_ERR "(-2d (%d-%d,%d-%d) in (%d-%d,%d-%d) last)\n",
+                                                   mi->area.p0.x, mi->area.p1.x,
+                                                   mi->area.p0.y, mi->area.p1.y,
+                                                   ai->area.p0.x, ai->area.p1.x,
+                                                   ai->area.p0.y, ai->area.p1.y);
+
                         res = tcm_free(&ai->area);
                         list_del(&ai->by_gid);
                         /* try to remove parent if it became empty */
                         _m_try_free_group(ai->gi);
                         kfree(ai);
                         ai = NULL;
-                }
+                } else if (tiler_alloc_debug & 1)
+                                        printk(KERN_ERR "(-2d (%d-%d,%d-%d) in (%d-%d,%d-%d) remaining)\n",
+                                                mi->area.p0.x, mi->area.p1.x,
+                                                mi->area.p0.y, mi->area.p1.y,
+                                                ai->area.p0.x, ai->area.p1.x,
+                                                ai->area.p0.y, ai->area.p1.y);
         } else {
+                if (tiler_alloc_debug & 1)
+                        printk(KERN_ERR "(-1d: %d,%d..%d,%d)\n",
+                        mi->area.p0.x, mi->area.p0.y,
+                        mi->area.p1.x, mi->area.p1.y);
+
                 /* remove 1D area */
                 res = tcm_free(&mi->area);
                 /* try to remove parent if it became empty */
@@ -892,6 +1089,11 @@ static struct mem_info *alloc_area(enum tiler_fmt fmt, u32 width, u32 height,
                         return NULL;
                 }
 
+                if (tiler_alloc_debug & 1)
+                         printk(KERN_ERR "(+1d: %d,%d..%d,%d)\n",
+                                                mi->area.p0.x, mi->area.p0.y,
+                                                mi->area.p1.x, mi->area.p1.y);
+
                 mutex_lock(&mtx);
                 mi->parent = gi;
                 list_add(&mi->by_area, &gi->onedim);
@@ -1329,6 +1531,18 @@ static s32 __init tiler_init(void)
         INIT_LIST_HEAD(&orphan_areas);
         INIT_LIST_HEAD(&orphan_onedim);
 
+        dbgfs = debugfs_create_dir("tiler", NULL);
+        if (IS_ERR_OR_NULL(dbgfs))
+                dev_warn(device, "failed to create debug files.\n");
+        else
+                dbg_map = debugfs_create_dir("map", dbgfs);
+        if (!IS_ERR_OR_NULL(dbg_map))
+                debugfs_create_file("2x1", S_IRUGO, dbg_map,
+                                &debug_allocation_map, &tiler_debug_fops);
+        if (!IS_ERR_OR_NULL(dbgfs))
+                debugfs_create_bool("alloc_debug", S_IRUGO | S_IWUSR, dbgfs,
+                                        (u32*)&tiler_alloc_debug);
+
 error:
         /* TODO: error handling for device registration */
         if (r) {
@@ -1348,6 +1562,8 @@ static void __exit tiler_exit(void)
 
         mutex_lock(&mtx);
 
+        debugfs_remove_recursive(dbgfs);
+
         /* free all process data */
         tiler.cleanup();