Added cache /proc

4 files changed, 263 insertions, 2 deletions

diff --git a/arch/arm/mach-imx/Makefile b/arch/arm/mach-imx/Makefile
index 25366995d4df..02d0208dce31 100644
--- a/arch/arm/mach-imx/Makefile
+++ b/arch/arm/mach-imx/Makefile
@@ -107,13 +107,13 @@ obj-$(CONFIG_SOC_IMX6SX) += clk-imx6sx.o mach-imx6sx.o
 AFLAGS_suspend-imx6.o :=-Wa,-march=armv7-a
 obj-$(CONFIG_PM) += pm-imx6.o headsmp.o suspend-imx6.o
 
-ifeq ($(CONFIG_ARM_IMX6_CPUFREQ),y)
+#ifeq ($(CONFIG_ARM_IMX6_CPUFREQ),y)
 obj-y += busfreq-imx6.o
 obj-$(CONFIG_SOC_IMX6Q) += ddr3_freq_imx6.o busfreq_ddr3.o
 obj-$(CONFIG_SOC_IMX6SL) += lpddr2_freq_imx6.o busfreq_lpddr2.o imx6sl_wfi.o
 obj-$(CONFIG_SOC_IMX6SX) += ddr3_freq_imx6sx.o lpddr2_freq_imx6sx.o
 
-endif
+#endif
 
 
 # i.MX5 based machines
diff --git a/arch/arm/mm/cache-l2x0.c b/arch/arm/mm/cache-l2x0.c
index c465faca51b0..5efe6b6e9d53 100644
--- a/arch/arm/mm/cache-l2x0.c
+++ b/arch/arm/mm/cache-l2x0.c
@@ -27,6 +27,8 @@
 #include <asm/hardware/cache-l2x0.h>
 #include "cache-aurora-l2.h"
 
+#include <litmus/cache_proc.h>
+
 #define CACHE_LINE_SIZE         32
 
 static void __iomem *l2x0_base;
@@ -393,6 +395,8 @@ void __init l2x0_init(void __iomem *base, u32 aux_val, u32 aux_mask)
                 l2x0_unlock(cache_id);
 
                 /* l2x0 controller is disabled */
+                //aux |= (1 << 12);
+                //printk("AUX BIT = %08x\n", aux);
                 writel_relaxed(aux, l2x0_base + L2X0_AUX_CTRL);
 
                 l2x0_inv_all();
@@ -420,6 +424,8 @@ void __init l2x0_init(void __iomem *base, u32 aux_val, u32 aux_mask)
         printk(KERN_INFO "%s cache controller enabled\n", type);
         printk(KERN_INFO "l2x0: %d ways, CACHE_ID 0x%08x, AUX_CTRL 0x%08x, Cache size: %d B\n",
                         ways, cache_id, aux, l2x0_size);
+
+        litmus_setup_lockdown(l2x0_base, cache_id);
 }
 
 #ifdef CONFIG_OF
diff --git a/include/litmus/cache_proc.h b/include/litmus/cache_proc.h
new file mode 100644
index 000000000000..a7a740e7bc01
--- /dev/null
+++ b/include/litmus/cache_proc.h
@@ -0,0 +1,10 @@
+#ifndef LITMUS_CACHE_PROC_H
+#define LITMUS_CACHE_PROC_H
+
+#ifdef __KERNEL__
+
+void litmus_setup_lockdown(void __iomem*, u32);
+
+#endif
+
+#endif
diff --git a/litmus/cache_proc.c b/litmus/cache_proc.c
new file mode 100644
index 000000000000..4425bfb8bbd4
--- /dev/null
+++ b/litmus/cache_proc.c
@@ -0,0 +1,245 @@
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/sysctl.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+#include <linux/mutex.h>
+
+#include <litmus/litmus_proc.h>
+#include <litmus/sched_trace.h>
+
+#include <asm/hardware/cache-l2x0.h>
+#include <asm/cacheflush.h>
+
+#define UNLOCK_ALL      0x00000000 /* allocation in any way */
+#define LOCK_ALL        (~UNLOCK_ALL)
+#define MAX_NR_WAYS     16
+
+u32 nr_unlocked_way[MAX_NR_WAYS+1]  = {
+        0xFFFFFFFF, /* all ways are locked. usable = 0*/
+        0xFFFFFFFE, /* way ~0 unlocked. usable = 1 */
+        0xFFFFFFFC,
+        0xFFFFFFF8,
+        0xFFFFFFF0,
+        0xFFFFFFE0,
+        0xFFFFFFC0,
+        0xFFFFFF80,
+        0xFFFFFF00,
+        0xFFFFFE00,
+        0xFFFFFC00,
+        0xFFFFF800,
+        0xFFFFF000,
+        0xFFFFE000,
+        0xFFFFC000,
+        0xFFFF8000,
+        0xFFFF0000, /* way ~15 unlocked. usable = 16 */
+};
+
+static void __iomem *cache_base;
+static void __iomem *lockreg_d;
+static void __iomem *lockreg_i;
+
+static u32 cache_id;
+
+struct mutex actlr_mutex;
+struct mutex l2x0_prefetch_mutex;
+struct mutex lockdown_proc;
+
+static int min_usable_ways = 0;
+static int max_usable_ways = 16;
+static int zero = 0;
+static int one = 1;
+
+#define ld_d_reg(cpu) ({ int __cpu = cpu; \
+                        void __iomem *__v = cache_base + L2X0_LOCKDOWN_WAY_D_BASE + \
+                        __cpu * L2X0_LOCKDOWN_STRIDE; __v; })
+#define ld_i_reg(cpu) ({ int __cpu = cpu; \
+                        void __iomem *__v = cache_base + L2X0_LOCKDOWN_WAY_I_BASE + \
+                        __cpu * L2X0_LOCKDOWN_STRIDE; __v; })
+
+int l2_usable_ways;
+int lock_all;
+int nr_lockregs;
+
+static void print_lockdown_registers(void)
+{
+        int i;
+
+        for (i = 0; i < nr_lockregs; i++) {
+                printk("Lockdown Data CPU %2d: 0x%8x\n",
+                                i, readl_relaxed(ld_d_reg(i)));
+                printk("Lockdown Inst CPU %2d: 0x%8x\n",
+                                i, readl_relaxed(ld_i_reg(i)));
+        }
+}
+
+static void test_lockdown(void *ignore)
+{
+        int i;
+
+        printk("Start lockdown test on CPU %d.\n", smp_processor_id());
+
+        for (i = 0; i < nr_lockregs; i++) {
+                printk("CPU %2d data reg: 0x%8p\n", i, ld_d_reg(i));
+                printk("CPU %2d inst reg: 0x%8p\n", i, ld_i_reg(i));
+        }
+
+        printk("Lockdown initial state:\n");
+        print_lockdown_registers();
+        printk("---\n");
+
+        for (i = 0; i < nr_lockregs; i++) {
+                writel_relaxed(1, ld_d_reg(i));
+                writel_relaxed(2, ld_i_reg(i));
+        }
+        printk("Lockdown all data=1 instr=2:\n");
+        print_lockdown_registers();
+        printk("---\n");
+
+        for (i = 0; i < nr_lockregs; i++) {
+                writel_relaxed((1 << i), ld_d_reg(i));
+                writel_relaxed(((1 << 8) >> i), ld_i_reg(i));
+        }
+        printk("Lockdown varies:\n");
+        print_lockdown_registers();
+        printk("---\n");
+
+        for (i = 0; i < nr_lockregs; i++) {
+                writel_relaxed(UNLOCK_ALL, ld_d_reg(i));
+                writel_relaxed(UNLOCK_ALL, ld_i_reg(i));
+        }
+        printk("Lockdown all zero:\n");
+        print_lockdown_registers();
+
+        printk("End lockdown test.\n");
+}
+
+void litmus_setup_lockdown(void __iomem *base, u32 id)
+{
+    cache_base = base;
+        cache_id = id;
+        lockreg_d = cache_base + L2X0_LOCKDOWN_WAY_D_BASE;
+        lockreg_i = cache_base + L2X0_LOCKDOWN_WAY_I_BASE;
+    
+        if (L2X0_CACHE_ID_PART_L310 == (cache_id & L2X0_CACHE_ID_PART_MASK)) {
+                nr_lockregs = 8;
+        } else {
+                printk("Unknown cache ID!\n");
+                nr_lockregs = 1;
+        }
+        
+        mutex_init(&actlr_mutex);
+        mutex_init(&l2x0_prefetch_mutex);
+        mutex_init(&lockdown_proc);
+        
+        test_lockdown(NULL);
+}
+int lock_all_handler(struct ctl_table *table, int write, void __user *buffer,
+                size_t *lenp, loff_t *ppos)
+{
+        int ret = 0, i;
+        
+        mutex_lock(&lockdown_proc);
+        
+        flush_cache_all();
+        
+        ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+        if (ret)
+                goto out;
+        
+        if (write && lock_all == 1) {
+                for (i = 0; i < nr_lockregs;  i++) {
+                        writel_relaxed(nr_unlocked_way[0], ld_d_reg(i));
+                        writel_relaxed(nr_unlocked_way[0], ld_i_reg(i));
+                }
+                print_lockdown_registers();
+        }
+
+out:
+        mutex_unlock(&lockdown_proc);
+        return ret;
+}
+
+int l2_usable_ways_handler(struct ctl_table *table, int write, void __user *buffer,
+                size_t *lenp, loff_t *ppos)
+{
+        int ret = 0, i = 0;
+        
+        mutex_lock(&lockdown_proc);
+        
+        flush_cache_all();
+        
+        ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+        if (ret)
+                goto out;
+                
+        TRACE_CUR("l2_usable_ways : %d\n", l2_usable_ways);
+        
+        if (write) {
+                //for (i = 0; i < nr_lockregs;  i++) {
+                        writel_relaxed(nr_unlocked_way[l2_usable_ways], ld_d_reg(i));
+                        writel_relaxed(nr_unlocked_way[l2_usable_ways], ld_i_reg(i));
+                //}
+                print_lockdown_registers();
+        }
+
+out:
+        mutex_unlock(&lockdown_proc);
+        return ret;
+}
+
+static struct ctl_table cache_table[] =
+{
+        {
+                .procname       = "l2_usable_ways",
+                .mode           = 0666,
+                .proc_handler   = l2_usable_ways_handler,
+                .data           = &l2_usable_ways,
+                .maxlen         = sizeof(l2_usable_ways),
+                .extra1         = &min_usable_ways,
+                .extra2         = &max_usable_ways,
+        },
+        {
+                .procname       = "lock_all",
+                .mode           = 0666,
+                .proc_handler   = lock_all_handler,
+                .data           = &lock_all,
+                .maxlen         = sizeof(lock_all),
+                .extra1         = &zero,
+                .extra2         = &one,
+        },
+        { }
+};
+
+static struct ctl_table litmus_dir_table[] = {
+        {
+                .procname       = "litmus",
+                .mode           = 0555,
+                .child          = cache_table,
+        },
+        { }
+};
+
+static struct ctl_table_header *litmus_sysctls;
+
+static int __init litmus_sysctl_init(void)
+{
+        int ret = 0;
+
+        printk(KERN_INFO "Registering LITMUS^RT proc sysctl.\n");
+        litmus_sysctls = register_sysctl_table(litmus_dir_table);
+        if (!litmus_sysctls) {
+                printk(KERN_WARNING "Could not register LITMUS^RT sysctl.\n");
+                ret = -EFAULT;
+                goto out;
+        }
+
+        l2_usable_ways = 16;
+
+out:
+        return ret;
+}
+
+module_init(litmus_sysctl_init);
\ No newline at end of file