* License. See the file "COPYING" in the main directory of this archive
* for more details.
*
- * Copyright (C) 2000-2003 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2000-2005 Silicon Graphics, Inc. All rights reserved.
*/
-#include <linux/config.h>
-#include <asm/uaccess.h>
#ifdef CONFIG_PROC_FS
#include <linux/proc_fs.h>
-#include <asm/sn/sgi.h>
+#include <linux/seq_file.h>
+#include <asm/uaccess.h>
#include <asm/sn/sn_sal.h>
-
-static int partition_id_read_proc(char *page, char **start, off_t off,
- int count, int *eof, void *data) {
-
- return sprintf(page, "%d\n", sn_local_partid());
+static int partition_id_show(struct seq_file *s, void *p)
+{
+ seq_printf(s, "%d\n", sn_partition_id);
+ return 0;
}
-static struct proc_dir_entry * sgi_proc_dir;
-
-void
-register_sn_partition_id(void) {
- struct proc_dir_entry *entry;
-
- if (!sgi_proc_dir) {
- sgi_proc_dir = proc_mkdir("sgi_sn", 0);
- }
- entry = create_proc_entry("partition_id", 0444, sgi_proc_dir);
- if (entry) {
- entry->nlink = 1;
- entry->data = 0;
- entry->read_proc = partition_id_read_proc;
- entry->write_proc = NULL;
- }
+static int partition_id_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, partition_id_show, NULL);
}
-static int
-system_serial_number_read_proc(char *page, char **start, off_t off,
- int count, int *eof, void *data) {
- return sprintf(page, "%s\n", sn_system_serial_number());
+static int system_serial_number_show(struct seq_file *s, void *p)
+{
+ seq_printf(s, "%s\n", sn_system_serial_number());
+ return 0;
}
-static int
-licenseID_read_proc(char *page, char **start, off_t off,
- int count, int *eof, void *data) {
- return sprintf(page, "0x%lx\n",sn_partition_serial_number_val());
+static int system_serial_number_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, system_serial_number_show, NULL);
}
-void
-register_sn_serial_numbers(void) {
- struct proc_dir_entry *entry;
+static int licenseID_show(struct seq_file *s, void *p)
+{
+ seq_printf(s, "0x%lx\n", sn_partition_serial_number_val());
+ return 0;
+}
- if (!sgi_proc_dir) {
- sgi_proc_dir = proc_mkdir("sgi_sn", 0);
- }
- entry = create_proc_entry("system_serial_number", 0444, sgi_proc_dir);
- if (entry) {
- entry->nlink = 1;
- entry->data = 0;
- entry->read_proc = system_serial_number_read_proc;
- entry->write_proc = NULL;
- }
- entry = create_proc_entry("licenseID", 0444, sgi_proc_dir);
- if (entry) {
- entry->nlink = 1;
- entry->data = 0;
- entry->read_proc = licenseID_read_proc;
- entry->write_proc = NULL;
- }
+static int licenseID_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, licenseID_show, NULL);
}
/*
* the bridge chip. The hardware will then send an interrupt message if the
* interrupt line is active. This mimics a level sensitive interrupt.
*/
-int sn_force_interrupt_flag = 1;
+extern int sn_force_interrupt_flag;
-static int
-sn_force_interrupt_read_proc(char *page, char **start, off_t off,
- int count, int *eof, void *data) {
- if (sn_force_interrupt_flag) {
- return sprintf(page, "Force interrupt is enabled\n");
- }
- return sprintf(page, "Force interrupt is disabled\n");
+static int sn_force_interrupt_show(struct seq_file *s, void *p)
+{
+ seq_printf(s, "Force interrupt is %s\n",
+ sn_force_interrupt_flag ? "enabled" : "disabled");
+ return 0;
}
-static int
-sn_force_interrupt_write_proc(struct file *file, const char *buffer,
- unsigned long count, void *data)
+static ssize_t sn_force_interrupt_write_proc(struct file *file,
+ const char __user *buffer, size_t count, loff_t *data)
{
- if (*buffer == '0') {
- sn_force_interrupt_flag = 0;
- } else {
- sn_force_interrupt_flag = 1;
- }
- return 1;
+ char val;
+
+ if (copy_from_user(&val, buffer, 1))
+ return -EFAULT;
+
+ sn_force_interrupt_flag = (val == '0') ? 0 : 1;
+ return count;
+}
+
+static int sn_force_interrupt_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, sn_force_interrupt_show, NULL);
}
-void
-register_sn_force_interrupt(void) {
- struct proc_dir_entry *entry;
+static int coherence_id_show(struct seq_file *s, void *p)
+{
+ seq_printf(s, "%d\n", partition_coherence_id());
- if (!sgi_proc_dir) {
- sgi_proc_dir = proc_mkdir("sgi_sn", 0);
- }
- entry = create_proc_entry("sn_force_interrupt",0444, sgi_proc_dir);
- if (entry) {
- entry->nlink = 1;
- entry->data = 0;
- entry->read_proc = sn_force_interrupt_read_proc;
- entry->write_proc = sn_force_interrupt_write_proc;
+ return 0;
+}
+
+static int coherence_id_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, coherence_id_show, NULL);
+}
+
+static struct proc_dir_entry
+*sn_procfs_create_entry(const char *name, struct proc_dir_entry *parent,
+ int (*openfunc)(struct inode *, struct file *),
+ int (*releasefunc)(struct inode *, struct file *),
+ ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *))
+{
+ struct proc_dir_entry *e = create_proc_entry(name, 0444, parent);
+
+ if (e) {
+ struct file_operations *f;
+
+ f = kzalloc(sizeof(*f), GFP_KERNEL);
+ if (f) {
+ f->open = openfunc;
+ f->read = seq_read;
+ f->llseek = seq_lseek;
+ f->release = releasefunc;
+ f->write = write;
+ e->proc_fops = f;
+ }
}
+
+ return e;
}
-void
-register_sn_procfs(void) {
- register_sn_partition_id();
- register_sn_serial_numbers();
- register_sn_force_interrupt();
+/* /proc/sgi_sn/sn_topology uses seq_file, see sn_hwperf.c */
+extern int sn_topology_open(struct inode *, struct file *);
+extern int sn_topology_release(struct inode *, struct file *);
+
+void register_sn_procfs(void)
+{
+ static struct proc_dir_entry *sgi_proc_dir = NULL;
+
+ BUG_ON(sgi_proc_dir != NULL);
+ if (!(sgi_proc_dir = proc_mkdir("sgi_sn", NULL)))
+ return;
+
+ sn_procfs_create_entry("partition_id", sgi_proc_dir,
+ partition_id_open, single_release, NULL);
+
+ sn_procfs_create_entry("system_serial_number", sgi_proc_dir,
+ system_serial_number_open, single_release, NULL);
+
+ sn_procfs_create_entry("licenseID", sgi_proc_dir,
+ licenseID_open, single_release, NULL);
+
+ sn_procfs_create_entry("sn_force_interrupt", sgi_proc_dir,
+ sn_force_interrupt_open, single_release,
+ sn_force_interrupt_write_proc);
+
+ sn_procfs_create_entry("coherence_id", sgi_proc_dir,
+ coherence_id_open, single_release, NULL);
+
+ sn_procfs_create_entry("sn_topology", sgi_proc_dir,
+ sn_topology_open, sn_topology_release, NULL);
}
#endif /* CONFIG_PROC_FS */
git://git.onelab.eu / linux-2.6.git / blobdiff