1 files changed, 245 insertions, 0 deletions

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