LXR linux/arch/tile/kernel/proc.c

   1/*
   2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
   3 *
   4 *   This program is free software; you can redistribute it and/or
   5 *   modify it under the terms of the GNU General Public License
   6 *   as published by the Free Software Foundation, version 2.
   7 *
   8 *   This program is distributed in the hope that it will be useful, but
   9 *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11 *   NON INFRINGEMENT.  See the GNU General Public License for
  12 *   more details.
  13 */
  14
  15#include <linux/smp.h>
  16#include <linux/seq_file.h>
  17#include <linux/threads.h>
  18#include <linux/cpumask.h>
  19#include <linux/timex.h>
  20#include <linux/delay.h>
  21#include <linux/fs.h>
  22#include <linux/proc_fs.h>
  23#include <linux/sysctl.h>
  24#include <linux/hardirq.h>
  25#include <linux/hugetlb.h>
  26#include <linux/mman.h>
  27#include <asm/unaligned.h>
  28#include <asm/pgtable.h>
  29#include <asm/processor.h>
  30#include <asm/sections.h>
  31#include <asm/homecache.h>
  32#include <asm/hardwall.h>
  33#include <arch/chip.h>
  34
  35
  36/*
  37 * Support /proc/cpuinfo
  38 */
  39
  40#define cpu_to_ptr(n) ((void *)((long)(n)+1))
  41#define ptr_to_cpu(p) ((long)(p) - 1)
  42
  43static int show_cpuinfo(struct seq_file *m, void *v)
  44{
  45        int n = ptr_to_cpu(v);
  46
  47        if (n == 0) {
  48                seq_printf(m, "cpu count\t: %d\n", num_online_cpus());
  49                seq_printf(m, "cpu list\t: %*pbl\n",
  50                           cpumask_pr_args(cpu_online_mask));
  51                seq_printf(m, "model name\t: %s\n", chip_model);
  52                seq_printf(m, "flags\t\t:\n");  /* nothing for now */
  53                seq_printf(m, "cpu MHz\t\t: %llu.%06llu\n",
  54                           get_clock_rate() / 1000000,
  55                           (get_clock_rate() % 1000000));
  56                seq_printf(m, "bogomips\t: %lu.%02lu\n\n",
  57                           loops_per_jiffy/(500000/HZ),
  58                           (loops_per_jiffy/(5000/HZ)) % 100);
  59        }
  60
  61#ifdef CONFIG_SMP
  62        if (!cpu_online(n))
  63                return 0;
  64#endif
  65
  66        seq_printf(m, "processor\t: %d\n", n);
  67
  68        /* Print only num_online_cpus() blank lines total. */
  69        if (cpumask_next(n, cpu_online_mask) < nr_cpu_ids)
  70                seq_printf(m, "\n");
  71
  72        return 0;
  73}
  74
  75static void *c_start(struct seq_file *m, loff_t *pos)
  76{
  77        return *pos < nr_cpu_ids ? cpu_to_ptr(*pos) : NULL;
  78}
  79static void *c_next(struct seq_file *m, void *v, loff_t *pos)
  80{
  81        ++*pos;
  82        return c_start(m, pos);
  83}
  84static void c_stop(struct seq_file *m, void *v)
  85{
  86}
  87const struct seq_operations cpuinfo_op = {
  88        .start  = c_start,
  89        .next   = c_next,
  90        .stop   = c_stop,
  91        .show   = show_cpuinfo,
  92};
  93
  94/*
  95 * Support /proc/tile directory
  96 */
  97
  98static int __init proc_tile_init(void)
  99{
 100        struct proc_dir_entry *root = proc_mkdir("tile", NULL);
 101        if (root == NULL)
 102                return 0;
 103
 104        proc_tile_hardwall_init(root);
 105
 106        return 0;
 107}
 108
 109arch_initcall(proc_tile_init);
 110
 111/*
 112 * Support /proc/sys/tile directory
 113 */
 114
 115static struct ctl_table unaligned_subtable[] = {
 116        {
 117                .procname       = "enabled",
 118                .data           = &unaligned_fixup,
 119                .maxlen         = sizeof(int),
 120                .mode           = 0644,
 121                .proc_handler   = &proc_dointvec
 122        },
 123        {
 124                .procname       = "printk",
 125                .data           = &unaligned_printk,
 126                .maxlen         = sizeof(int),
 127                .mode           = 0644,
 128                .proc_handler   = &proc_dointvec
 129        },
 130        {
 131                .procname       = "count",
 132                .data           = &unaligned_fixup_count,
 133                .maxlen         = sizeof(int),
 134                .mode           = 0644,
 135                .proc_handler   = &proc_dointvec
 136        },
 137        {}
 138};
 139
 140static struct ctl_table unaligned_table[] = {
 141        {
 142                .procname       = "unaligned_fixup",
 143                .mode           = 0555,
 144                .child          = unaligned_subtable
 145        },
 146        {}
 147};
 148
 149static struct ctl_path tile_path[] = {
 150        { .procname = "tile" },
 151        { }
 152};
 153
 154static int __init proc_sys_tile_init(void)
 155{
 156        register_sysctl_paths(tile_path, unaligned_table);
 157        return 0;
 158}
 159
 160arch_initcall(proc_sys_tile_init);
 161