Commit ed24432f authored by Tony Luck's avatar Tony Luck

Merge agluck-lia64.sc.intel.com:/data/home/aegl/BK/work/trivial

into agluck-lia64.sc.intel.com:/data/home/aegl/BK/linux-ia64-release-2.6.9
parents 664d4fca 2cb7bcfc
...@@ -357,7 +357,20 @@ sn_pci_fixup_slot(struct pci_dev *dev) ...@@ -357,7 +357,20 @@ sn_pci_fixup_slot(struct pci_dev *dev)
if (dev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_MEM) if (dev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_MEM)
cmd |= PCI_COMMAND_MEMORY; cmd |= PCI_COMMAND_MEMORY;
} }
} } else {
/*
* Remove other ROM resources since they don't have valid
* CPU addresses.
*/
size = dev->resource[PCI_ROM_RESOURCE].end -
dev->resource[PCI_ROM_RESOURCE].start;
if (size) {
dev->resource[PCI_ROM_RESOURCE].start = 0;
dev->resource[PCI_ROM_RESOURCE].end = 0;
dev->resource[PCI_ROM_RESOURCE].flags = 0;
}
}
/* /*
* Update the Command Word on the Card. * Update the Command Word on the Card.
......
...@@ -10,67 +10,41 @@ ...@@ -10,67 +10,41 @@
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/sn/sgi.h> #include <asm/sn/sgi.h>
#include <asm/sn/sn_sal.h> #include <asm/sn/sn_sal.h>
static int partition_id_show(struct seq_file *s, void *p)
static int partition_id_read_proc(char *page, char **start, off_t off, {
int count, int *eof, void *data) { seq_printf(s, "%d\n", sn_local_partid());
return 0;
return sprintf(page, "%d\n", sn_local_partid());
} }
static struct proc_dir_entry * sgi_proc_dir; static int partition_id_open(struct inode *inode, struct file *file)
{
void return single_open(file, partition_id_show, NULL);
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 static int system_serial_number_show(struct seq_file *s, void *p)
system_serial_number_read_proc(char *page, char **start, off_t off, {
int count, int *eof, void *data) { seq_printf(s, "%s\n", sn_system_serial_number());
return sprintf(page, "%s\n", sn_system_serial_number()); return 0;
} }
static int static int system_serial_number_open(struct inode *inode, struct file *file)
licenseID_read_proc(char *page, char **start, off_t off, {
int count, int *eof, void *data) { return single_open(file, system_serial_number_show, NULL);
return sprintf(page, "0x%lx\n",sn_partition_serial_number_val());
} }
void static int licenseID_show(struct seq_file *s, void *p)
register_sn_serial_numbers(void) { {
struct proc_dir_entry *entry; seq_printf(s, "0x%lx\n", sn_partition_serial_number_val());
return 0;
}
if (!sgi_proc_dir) { static int licenseID_open(struct inode *inode, struct file *file)
sgi_proc_dir = proc_mkdir("sgi_sn", 0); {
} return single_open(file, licenseID_show, NULL);
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;
}
} }
/* /*
...@@ -81,70 +55,83 @@ register_sn_serial_numbers(void) { ...@@ -81,70 +55,83 @@ register_sn_serial_numbers(void) {
*/ */
int sn_force_interrupt_flag = 1; int sn_force_interrupt_flag = 1;
static int static int sn_force_interrupt_show(struct seq_file *s, void *p)
sn_force_interrupt_read_proc(char *page, char **start, off_t off, {
int count, int *eof, void *data) { seq_printf(s, "Force interrupt is %s\n",
if (sn_force_interrupt_flag) { sn_force_interrupt_flag ? "enabled" : "disabled");
return sprintf(page, "Force interrupt is enabled\n"); return 0;
}
return sprintf(page, "Force interrupt is disabled\n");
} }
static int static ssize_t sn_force_interrupt_write_proc(struct file *file,
sn_force_interrupt_write_proc(struct file *file, const char *buffer, const __user char *buffer, size_t count, loff_t *data)
unsigned long count, void *data)
{ {
if (*buffer == '0') { sn_force_interrupt_flag = (*buffer == '0') ? 0 : 1;
sn_force_interrupt_flag = 0; return count;
} else {
sn_force_interrupt_flag = 1;
}
return 1;
} }
void static int sn_force_interrupt_open(struct inode *inode, struct file *file)
register_sn_force_interrupt(void) { {
struct proc_dir_entry *entry; return single_open(file, sn_force_interrupt_show, NULL);
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;
}
} }
static int coherence_id_read_proc(char *page, char **start, off_t off, static int coherence_id_show(struct seq_file *s, void *p)
int count, int *eof, void *data) { {
return sprintf(page, "%d\n", cpuid_to_coherence_id(smp_processor_id())); seq_printf(s, "%d\n", cpuid_to_coherence_id(smp_processor_id()));
return 0;
} }
void static int coherence_id_open(struct inode *inode, struct file *file)
register_sn_coherence_id(void) { {
struct proc_dir_entry *entry; return single_open(file, coherence_id_show, NULL);
}
if (!sgi_proc_dir) { static struct proc_dir_entry *sn_procfs_create_entry(
sgi_proc_dir = proc_mkdir("sgi_sn", 0); const char *name, struct proc_dir_entry *parent,
} int (*openfunc)(struct inode *, struct file *),
entry = create_proc_entry("coherence_id", 0444, sgi_proc_dir); int (*releasefunc)(struct inode *, struct file *))
if (entry) { {
entry->nlink = 1; struct proc_dir_entry *e = create_proc_entry(name, 0444, parent);
entry->data = 0;
entry->read_proc = coherence_id_read_proc; if (e) {
entry->write_proc = NULL; e->proc_fops = (struct file_operations *)kmalloc(
sizeof(struct file_operations), GFP_KERNEL);
if (e->proc_fops) {
memset(e->proc_fops, 0, sizeof(struct file_operations));
e->proc_fops->open = openfunc;
e->proc_fops->read = seq_read;
e->proc_fops->llseek = seq_lseek;
e->proc_fops->release = releasefunc;
}
} }
return e;
} }
void void register_sn_procfs(void)
register_sn_procfs(void) { {
register_sn_partition_id(); static struct proc_dir_entry *sgi_proc_dir = NULL;
register_sn_serial_numbers(); struct proc_dir_entry *e;
register_sn_force_interrupt();
register_sn_coherence_id(); BUG_ON(sgi_proc_dir != NULL);
if (!(sgi_proc_dir = proc_mkdir("sgi_sn", 0)))
return;
sn_procfs_create_entry("partition_id", sgi_proc_dir,
partition_id_open, single_release);
sn_procfs_create_entry("system_serial_number", sgi_proc_dir,
system_serial_number_open, single_release);
sn_procfs_create_entry("licenseID", sgi_proc_dir,
licenseID_open, single_release);
e = sn_procfs_create_entry("sn_force_interrupt", sgi_proc_dir,
sn_force_interrupt_open, single_release);
if (e)
e->proc_fops->write = sn_force_interrupt_write_proc;
sn_procfs_create_entry("coherence_id", sgi_proc_dir,
coherence_id_open, single_release);
} }
#endif /* CONFIG_PROC_FS */ #endif /* CONFIG_PROC_FS */
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment