arch/ia64/sn/kernel/sn2/sn_proc_fs.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 2000-2003 Silicon Graphics, Inc. All rights reserved.
   7  */
   8 #include <linux/config.h>
   9 #include <asm/uaccess.h>
  10
  11 #ifdef CONFIG_PROC_FS
  12 #include <linux/proc_fs.h>
  13 #include <asm/sn/sgi.h>
  14 #include <asm/sn/sn_sal.h>
  15
  16
  17 static int partition_id_read_proc(char *page, char **start, off_t off,
  18                 int count, int *eof, void *data) {
  19
  20         return sprintf(page, "%d\n", sn_local_partid());
  21 }
  22
  23 static struct proc_dir_entry * sgi_proc_dir;
  24
  25 void
  26 register_sn_partition_id(void) {
  27         struct proc_dir_entry *entry;
  28
  29         if (!sgi_proc_dir) {
  30                 sgi_proc_dir = proc_mkdir("sgi_sn", 0);
  31         }
  32         entry = create_proc_entry("partition_id", 0444, sgi_proc_dir);
  33         if (entry) {
  34                 entry->nlink = 1;
  35                 entry->data = 0;
  36                 entry->read_proc = partition_id_read_proc;
  37                 entry->write_proc = NULL;
  38         }
  39 }
  40
  41 static int
  42 system_serial_number_read_proc(char *page, char **start, off_t off,
  43                 int count, int *eof, void *data) {
  44         return sprintf(page, "%s\n", sn_system_serial_number());
  45 }
  46
  47 static int
  48 licenseID_read_proc(char *page, char **start, off_t off,
  49                 int count, int *eof, void *data) {
  50         return sprintf(page, "0x%lx\n",sn_partition_serial_number_val());
  51 }
  52
  53 void
  54 register_sn_serial_numbers(void) {
  55         struct proc_dir_entry *entry;
  56
  57         if (!sgi_proc_dir) {
  58                 sgi_proc_dir = proc_mkdir("sgi_sn", 0);
  59         }
  60         entry = create_proc_entry("system_serial_number", 0444, sgi_proc_dir);
  61         if (entry) {
  62                 entry->nlink = 1;
  63                 entry->data = 0;
  64                 entry->read_proc = system_serial_number_read_proc;
  65                 entry->write_proc = NULL;
  66         }
  67         entry = create_proc_entry("licenseID", 0444, sgi_proc_dir);
  68         if (entry) {
  69                 entry->nlink = 1;
  70                 entry->data = 0;
  71                 entry->read_proc = licenseID_read_proc;
  72                 entry->write_proc = NULL;
  73         }
  74 }
  75
  76 /*
  77  * Enable forced interrupt by default.
  78  * When set, the sn interrupt handler writes the force interrupt register on
  79  * the bridge chip.  The hardware will then send an interrupt message if the
  80  * interrupt line is active.  This mimics a level sensitive interrupt.
  81  */
  82 int sn_force_interrupt_flag = 1;
  83
  84 static int
  85 sn_force_interrupt_read_proc(char *page, char **start, off_t off,
  86                 int count, int *eof, void *data) {
  87         if (sn_force_interrupt_flag) {
  88                 return sprintf(page, "Force interrupt is enabled\n");
  89         }
  90         return sprintf(page, "Force interrupt is disabled\n");
  91 }
  92
  93 static int
  94 sn_force_interrupt_write_proc(struct file *file, const char *buffer,
  95                                         unsigned long count, void *data)
  96 {
  97         if (*buffer == '0') {
  98                 sn_force_interrupt_flag = 0;
  99         } else {
 100                 sn_force_interrupt_flag = 1;
 101         }
 102         return 1;
 103 }
 104
 105 void
 106 register_sn_force_interrupt(void) {
 107         struct proc_dir_entry *entry;
 108
 109         if (!sgi_proc_dir) {
 110                 sgi_proc_dir = proc_mkdir("sgi_sn", 0);
 111         }
 112         entry = create_proc_entry("sn_force_interrupt",0444, sgi_proc_dir);
 113         if (entry) {
 114                 entry->nlink = 1;
 115                 entry->data = 0;
 116                 entry->read_proc = sn_force_interrupt_read_proc;
 117                 entry->write_proc = sn_force_interrupt_write_proc;
 118         }
 119 }
 120
 121 void
 122 register_sn_procfs(void) {
 123         register_sn_partition_id();
 124         register_sn_serial_numbers();
 125         register_sn_force_interrupt();
 126 }
 127
 128 #endif /* CONFIG_PROC_FS */