1 files changed, 53 insertions, 361 deletions

diff --git a/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c b/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c
index ac3a3d57..46560a56 100644
--- a/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/fifo_gk20a.c
@@ -29,12 +29,11 @@
 #include <nvgpu/log.h>
 #include <nvgpu/soc.h>
 #include <nvgpu/atomic.h>
-#include <nvgpu/sort.h>
 #include <nvgpu/bug.h>
 #include <nvgpu/log2.h>
+#include <nvgpu/debug.h>
 
 #include "gk20a.h"
-#include "debug_gk20a.h"
 #include "ctxsw_trace_gk20a.h"
 #include "mm_gk20a.h"
 
@@ -46,10 +45,6 @@
 #include <nvgpu/hw/gk20a/hw_mc_gk20a.h>
 #include <nvgpu/hw/gk20a/hw_gr_gk20a.h>
 
-#ifdef CONFIG_DEBUG_FS
-#include "platform_gk20a.h"
-#endif
-
 #define FECS_METHOD_WFI_RESTORE 0x80000
 
 static int gk20a_fifo_update_runlist_locked(struct gk20a *g, u32 runlist_id,
@@ -57,10 +52,6 @@ static int gk20a_fifo_update_runlist_locked(struct gk20a *g, u32 runlist_id,
                                             bool wait_for_finish);
 static u32 gk20a_fifo_engines_on_id(struct gk20a *g, u32 id, bool is_tsg);
 
-#ifdef CONFIG_DEBUG_FS
-static void __gk20a_fifo_profile_free(struct kref *ref);
-#endif
-
 u32 gk20a_fifo_get_engine_ids(struct gk20a *g,
                 u32 engine_id[], u32 engine_id_sz,
                 u32 engine_enum)
@@ -562,14 +553,6 @@ static void gk20a_remove_fifo_support(struct fifo_gk20a *f)
         f->engine_info = NULL;
         nvgpu_kfree(g, f->active_engines_list);
         f->active_engines_list = NULL;
-#ifdef CONFIG_DEBUG_FS
-        nvgpu_mutex_acquire(&f->profile.lock);
-        if (f->profile.enabled) {
-                f->profile.enabled = false;
-                kref_put(&f->profile.ref, __gk20a_fifo_profile_free);
-        }
-        nvgpu_mutex_release(&f->profile.lock);
-#endif
 }
 
 /* reads info from hardware and fills in pbmda exception info record */
@@ -1543,7 +1526,7 @@ static bool gk20a_fifo_handle_mmu_fault(
         } else {
                 fault_id = gk20a_readl(g, fifo_intr_mmu_fault_id_r());
                 fake_fault = false;
-                gk20a_debug_dump(g->dev);
+                gk20a_debug_dump(g);
         }
 
 
@@ -1833,7 +1816,7 @@ void gk20a_fifo_recover_ch(struct gk20a *g, u32 hw_chid, bool verbose)
                         gk20a_channel_abort(ch, false);
 
                         if (gk20a_fifo_error_ch(g, ch))
-                                gk20a_debug_dump(g->dev);
+                                gk20a_debug_dump(g);
 
                         gk20a_channel_put(ch);
                 }
@@ -1860,7 +1843,7 @@ void gk20a_fifo_recover_tsg(struct gk20a *g, u32 tsgid, bool verbose)
                 struct tsg_gk20a *tsg = &g->fifo.tsg[tsgid];
 
                 if (gk20a_fifo_error_tsg(g, tsg))
-                        gk20a_debug_dump(g->dev);
+                        gk20a_debug_dump(g);
 
                 gk20a_fifo_abort_tsg(g, tsgid, false);
         }
@@ -1957,7 +1940,7 @@ void gk20a_fifo_recover(struct gk20a *g, u32 __engine_ids,
         unsigned int id_type;
 
         if (verbose)
-                gk20a_debug_dump(g->dev);
+                gk20a_debug_dump(g);
 
         if (g->ops.ltc.flush)
                 g->ops.ltc.flush(g);
@@ -3441,345 +3424,6 @@ struct channel_gk20a *gk20a_fifo_channel_from_hw_chid(struct gk20a *g,
                 return NULL;
 }
 
-#ifdef CONFIG_DEBUG_FS
-
-/* Get the next element in the ring buffer of profile entries
- * and grab a reference to the structure
- */
-struct fifo_profile_gk20a *gk20a_fifo_profile_acquire(struct gk20a *g)
-{
-        struct fifo_gk20a *f = &g->fifo;
-        struct fifo_profile_gk20a *profile;
-        unsigned int index;
-
-        /* If kref is zero, profiling is not enabled */
-        if (!kref_get_unless_zero(&f->profile.ref))
-                return NULL;
-        index = atomic_inc_return(&f->profile.get);
-        profile = &f->profile.data[index % FIFO_PROFILING_ENTRIES];
-
-        return profile;
-}
-
-/* Free the reference to the structure. This allows deferred cleanups */
-void gk20a_fifo_profile_release(struct gk20a *g,
-                                        struct fifo_profile_gk20a *profile)
-{
-        kref_put(&g->fifo.profile.ref, __gk20a_fifo_profile_free);
-}
-
-static void *gk20a_fifo_sched_debugfs_seq_start(
-                struct seq_file *s, loff_t *pos)
-{
-        struct gk20a *g = s->private;
-        struct fifo_gk20a *f = &g->fifo;
-
-        if (*pos >= f->num_channels)
-                return NULL;
-
-        return &f->channel[*pos];
-}
-
-static void *gk20a_fifo_sched_debugfs_seq_next(
-                struct seq_file *s, void *v, loff_t *pos)
-{
-        struct gk20a *g = s->private;
-        struct fifo_gk20a *f = &g->fifo;
-
-        ++(*pos);
-        if (*pos >= f->num_channels)
-                return NULL;
-
-        return &f->channel[*pos];
-}
-
-static void gk20a_fifo_sched_debugfs_seq_stop(
-                struct seq_file *s, void *v)
-{
-}
-
-static int gk20a_fifo_sched_debugfs_seq_show(
-                struct seq_file *s, void *v)
-{
-        struct gk20a *g = s->private;
-        struct fifo_gk20a *f = &g->fifo;
-        struct channel_gk20a *ch = v;
-        struct tsg_gk20a *tsg = NULL;
-
-        struct fifo_engine_info_gk20a *engine_info;
-        struct fifo_runlist_info_gk20a *runlist;
-        u32 runlist_id;
-        int ret = SEQ_SKIP;
-        u32 engine_id;
-
-        engine_id = gk20a_fifo_get_gr_engine_id(g);
-        engine_info = (f->engine_info + engine_id);
-        runlist_id = engine_info->runlist_id;
-        runlist = &f->runlist_info[runlist_id];
-
-        if (ch == f->channel) {
-                seq_puts(s, "chid     tsgid    pid      timeslice  timeout  interleave graphics_preempt compute_preempt\n");
-                seq_puts(s, "                            (usecs)   (msecs)\n");
-                ret = 0;
-        }
-
-        if (!test_bit(ch->hw_chid, runlist->active_channels))
-                return ret;
-
-        if (gk20a_channel_get(ch)) {
-                if (gk20a_is_channel_marked_as_tsg(ch))
-                        tsg = &f->tsg[ch->tsgid];
-
-                seq_printf(s, "%-8d %-8d %-8d %-9d %-8d %-10d %-8d %-8d\n",
-                                ch->hw_chid,
-                                ch->tsgid,
-                                ch->tgid,
-                                tsg ? tsg->timeslice_us : ch->timeslice_us,
-                                ch->timeout_ms_max,
-                                tsg ? tsg->interleave_level : ch->interleave_level,
-                                ch->ch_ctx.gr_ctx ? ch->ch_ctx.gr_ctx->graphics_preempt_mode : U32_MAX,
-                                ch->ch_ctx.gr_ctx ? ch->ch_ctx.gr_ctx->compute_preempt_mode : U32_MAX);
-                gk20a_channel_put(ch);
-        }
-        return 0;
-}
-
-static const struct seq_operations gk20a_fifo_sched_debugfs_seq_ops = {
-        .start = gk20a_fifo_sched_debugfs_seq_start,
-        .next = gk20a_fifo_sched_debugfs_seq_next,
-        .stop = gk20a_fifo_sched_debugfs_seq_stop,
-        .show = gk20a_fifo_sched_debugfs_seq_show
-};
-
-static int gk20a_fifo_sched_debugfs_open(struct inode *inode,
-        struct file *file)
-{
-        int err;
-
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
-
-        err = seq_open(file, &gk20a_fifo_sched_debugfs_seq_ops);
-        if (err)
-                return err;
-
-        gk20a_dbg(gpu_dbg_info, "i_private=%p", inode->i_private);
-
-        ((struct seq_file *)file->private_data)->private = inode->i_private;
-        return 0;
-};
-
-/*
- * The file operations structure contains our open function along with
- * set of the canned seq_ ops.
- */
-static const struct file_operations gk20a_fifo_sched_debugfs_fops = {
-        .owner = THIS_MODULE,
-        .open = gk20a_fifo_sched_debugfs_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = seq_release
-};
-
-static void __gk20a_fifo_profile_free(struct kref *ref)
-{
-        struct fifo_gk20a *f = container_of(ref, struct fifo_gk20a,
-                                                profile.ref);
-        nvgpu_vfree(f->g, f->profile.data);
-        nvgpu_vfree(f->g, f->profile.sorted);
-}
-
-static int gk20a_fifo_profile_enable(void *data, u64 val)
-{
-        struct gk20a *g = (struct gk20a *) data;
-        struct fifo_gk20a *f = &g->fifo;
-
-
-        nvgpu_mutex_acquire(&f->profile.lock);
-        if (val == 0) {
-                if (f->profile.enabled) {
-                        f->profile.enabled = false;
-                        kref_put(&f->profile.ref, __gk20a_fifo_profile_free);
-                }
-        } else {
-                if (!f->profile.enabled) {
-                        /* not kref init as it can have a running condition if
-                         * we enable/disable/enable while kickoff is happening
-                         */
-                        if (!kref_get_unless_zero(&f->profile.ref)) {
-                                f->profile.data = vzalloc(
-                                                        FIFO_PROFILING_ENTRIES *
-                                        sizeof(struct fifo_profile_gk20a));
-                                f->profile.sorted  = vzalloc(
-                                                        FIFO_PROFILING_ENTRIES *
-                                                        sizeof(u64));
-                                if (!(f->profile.data && f->profile.sorted)) {
-                                        nvgpu_vfree(g, f->profile.data);
-                                        nvgpu_vfree(g, f->profile.sorted);
-                                        nvgpu_mutex_release(&f->profile.lock);
-                                        return -ENOMEM;
-                                }
-                                kref_init(&f->profile.ref);
-                        }
-                        atomic_set(&f->profile.get, 0);
-                        f->profile.enabled = true;
-                }
-        }
-        nvgpu_mutex_release(&f->profile.lock);
-
-        return 0;
-}
-
-DEFINE_SIMPLE_ATTRIBUTE(
-        gk20a_fifo_profile_enable_debugfs_fops,
-        NULL,
-        gk20a_fifo_profile_enable,
-        "%llu\n"
-);
-
-static int __profile_cmp(const void *a, const void *b)
-{
-        return *((unsigned long long *) a) - *((unsigned long long *) b);
-}
-
-/*
- * This uses about 800b in the stack, but the function using it is not part
- * of a callstack where much memory is being used, so it is fine
- */
-#define PERCENTILE_WIDTH        5
-#define PERCENTILE_RANGES       (100/PERCENTILE_WIDTH)
-
-static unsigned int __gk20a_fifo_create_stats(struct gk20a *g,
-                u64 *percentiles, u32 index_end, u32 index_start)
-{
-        unsigned int nelem = 0;
-        unsigned int index;
-        struct fifo_profile_gk20a *profile;
-
-        for (index = 0; index < FIFO_PROFILING_ENTRIES; index++) {
-                profile = &g->fifo.profile.data[index];
-
-                if (profile->timestamp[index_end] >
-                                profile->timestamp[index_start]) {
-                        /* This is a valid element */
-                        g->fifo.profile.sorted[nelem] =
-                                                profile->timestamp[index_end] -
-                                                profile->timestamp[index_start];
-                        nelem++;
-                }
-        }
-
-        /* sort it */
-        sort(g->fifo.profile.sorted, nelem, sizeof(unsigned long long),
-                __profile_cmp, NULL);
-
-        /* build ranges */
-        for (index = 0; index < PERCENTILE_RANGES; index++)
-                percentiles[index] =
-                        g->fifo.profile.sorted[(PERCENTILE_WIDTH * (index + 1) *
-                                                nelem)/100 - 1];
-        return nelem;
-}
-
-static int gk20a_fifo_profile_stats(struct seq_file *s, void *unused)
-{
-        struct gk20a *g = s->private;
-        unsigned int get, nelem, index;
-        /*
-         * 800B in the stack, but function is declared statically and only
-         * called from debugfs handler
-         */
-        u64 percentiles_ioctl[PERCENTILE_RANGES];
-        u64 percentiles_kickoff[PERCENTILE_RANGES];
-        u64 percentiles_jobtracking[PERCENTILE_RANGES];
-        u64 percentiles_append[PERCENTILE_RANGES];
-        u64 percentiles_userd[PERCENTILE_RANGES];
-
-        if (!kref_get_unless_zero(&g->fifo.profile.ref)) {
-                seq_printf(s, "Profiling disabled\n");
-                return 0;
-        }
-
-        get = atomic_read(&g->fifo.profile.get);
-
-        __gk20a_fifo_create_stats(g, percentiles_ioctl,
-                PROFILE_IOCTL_EXIT, PROFILE_IOCTL_ENTRY);
-        __gk20a_fifo_create_stats(g, percentiles_kickoff,
-                PROFILE_END, PROFILE_ENTRY);
-        __gk20a_fifo_create_stats(g, percentiles_jobtracking,
-                PROFILE_JOB_TRACKING, PROFILE_IOCTL_ENTRY);
-        __gk20a_fifo_create_stats(g, percentiles_append,
-                PROFILE_APPEND, PROFILE_JOB_TRACKING);
-        nelem = __gk20a_fifo_create_stats(g, percentiles_userd,
-                PROFILE_END, PROFILE_APPEND);
-
-        seq_printf(s, "Number of kickoffs: %d\n", nelem);
-        seq_printf(s, "Perc \t ioctl(ns) \t kickoff(ns) \t pbcopy(ns) \t jobtrack(ns) \t userd(ns)\n");
-
-        for (index = 0; index < PERCENTILE_RANGES; index++)
-                seq_printf(s, "[%2dpc]\t%8lld\t%8lld\t%8lld\t%8lld\t%8lld\n",
-                        PERCENTILE_WIDTH * (index+1),
-                        percentiles_ioctl[index],
-                        percentiles_kickoff[index],
-                        percentiles_append[index],
-                        percentiles_jobtracking[index],
-                        percentiles_userd[index]);
-
-        kref_put(&g->fifo.profile.ref, __gk20a_fifo_profile_free);
-
-        return 0;
-}
-
-static int gk20a_fifo_profile_stats_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, gk20a_fifo_profile_stats, inode->i_private);
-}
-
-static const struct file_operations gk20a_fifo_profile_stats_debugfs_fops = {
-        .open           = gk20a_fifo_profile_stats_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
-
-void gk20a_fifo_debugfs_init(struct device *dev)
-{
-        struct gk20a_platform *platform = dev_get_drvdata(dev);
-        struct gk20a *g = get_gk20a(dev);
-
-        struct dentry *gpu_root = platform->debugfs;
-        struct dentry *fifo_root;
-        struct dentry *profile_root;
-
-
-        fifo_root = debugfs_create_dir("fifo", gpu_root);
-        if (IS_ERR_OR_NULL(fifo_root))
-                return;
-
-        gk20a_dbg(gpu_dbg_info, "g=%p", g);
-
-        debugfs_create_file("sched", 0600, fifo_root, g,
-                &gk20a_fifo_sched_debugfs_fops);
-
-        profile_root = debugfs_create_dir("profile", fifo_root);
-        if (IS_ERR_OR_NULL(profile_root))
-                return;
-
-        nvgpu_mutex_init(&g->fifo.profile.lock);
-        g->fifo.profile.enabled = false;
-        atomic_set(&g->fifo.profile.get, 0);
-        atomic_set(&g->fifo.profile.ref.refcount, 0);
-
-        debugfs_create_file("enable", 0600, profile_root, g,
-                &gk20a_fifo_profile_enable_debugfs_fops);
-
-        debugfs_create_file("stats", 0600, profile_root, g,
-                &gk20a_fifo_profile_stats_debugfs_fops);
-
-}
-#endif /* CONFIG_DEBUG_FS */
-
 static const char * const ccsr_chan_status_str[] = {
         "idle",
         "pending",
@@ -3901,6 +3545,54 @@ void gk20a_dump_channel_status_ramfc(struct gk20a *g,
         gk20a_debug_output(o, "\n");
 }
 
+void gk20a_debug_dump_all_channel_status_ramfc(struct gk20a *g,
+                 struct gk20a_debug_output *o)
+{
+        struct fifo_gk20a *f = &g->fifo;
+        u32 chid;
+        struct ch_state **ch_state;
+
+        ch_state = nvgpu_kzalloc(g, sizeof(*ch_state) * f->num_channels);
+        if (!ch_state) {
+                gk20a_debug_output(o, "cannot alloc memory for channels\n");
+                return;
+        }
+
+        for (chid = 0; chid < f->num_channels; chid++) {
+                struct channel_gk20a *ch = &f->channel[chid];
+                if (gk20a_channel_get(ch)) {
+                        ch_state[chid] =
+                                nvgpu_kmalloc(g, sizeof(struct ch_state) +
+                                        ram_in_alloc_size_v());
+                        /* ref taken stays to below loop with
+                         * successful allocs */
+                        if (!ch_state[chid])
+                                gk20a_channel_put(ch);
+                }
+        }
+
+        for (chid = 0; chid < f->num_channels; chid++) {
+                struct channel_gk20a *ch = &f->channel[chid];
+                if (!ch_state[chid])
+                        continue;
+
+                ch_state[chid]->pid = ch->pid;
+                ch_state[chid]->refs = atomic_read(&ch->ref_count);
+                nvgpu_mem_rd_n(g, &ch->inst_block, 0,
+                                &ch_state[chid]->inst_block[0],
+                                ram_in_alloc_size_v());
+                gk20a_channel_put(ch);
+        }
+        for (chid = 0; chid < f->num_channels; chid++) {
+                if (ch_state[chid]) {
+                        g->ops.fifo.dump_channel_status_ramfc(g, o, chid,
+                                                 ch_state[chid]);
+                        nvgpu_kfree(g, ch_state[chid]);
+                }
+        }
+        nvgpu_kfree(g, ch_state);
+}
+
 void gk20a_dump_pbdma_status(struct gk20a *g,
                                  struct gk20a_debug_output *o)
 {