Commit b48e213e authored by Linus Torvalds's avatar Linus Torvalds

Merge http://lia64.bkbits.net/linux-ia64-release-2.6.9

into ppc970.osdl.org:/home/torvalds/v2.6/linux
parents 0142b7ae 30851dc0
......@@ -20,7 +20,7 @@ AFLAGS_KERNEL := -mconstant-gp
EXTRA :=
cflags-y := -pipe $(EXTRA) -ffixed-r13 -mfixed-range=f12-f15,f32-f127 \
-falign-functions=32 -frename-registers
-falign-functions=32 -frename-registers -fno-optimize-sibling-calls
CFLAGS_KERNEL := -mconstant-gp
GCC_VERSION := $(call cc-version)
......
......@@ -357,6 +357,19 @@ sn_pci_fixup_slot(struct pci_dev *dev)
if (dev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_MEM)
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;
}
}
/*
......
......@@ -10,67 +10,41 @@
#ifdef CONFIG_PROC_FS
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/sn/sgi.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_local_partid());
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);
}
/*
......@@ -81,70 +55,83 @@ register_sn_serial_numbers(void) {
*/
int sn_force_interrupt_flag = 1;
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 __user char *buffer, size_t count, loff_t *data)
{
if (*buffer == '0') {
sn_force_interrupt_flag = 0;
} else {
sn_force_interrupt_flag = 1;
}
return 1;
sn_force_interrupt_flag = (*buffer == '0') ? 0 : 1;
return count;
}
void
register_sn_force_interrupt(void) {
struct proc_dir_entry *entry;
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 sn_force_interrupt_open(struct inode *inode, struct file *file)
{
return single_open(file, sn_force_interrupt_show, NULL);
}
static int coherence_id_read_proc(char *page, char **start, off_t off,
int count, int *eof, void *data) {
return sprintf(page, "%d\n", cpuid_to_coherence_id(smp_processor_id()));
static int coherence_id_show(struct seq_file *s, void *p)
{
seq_printf(s, "%d\n", cpuid_to_coherence_id(smp_processor_id()));
return 0;
}
void
register_sn_coherence_id(void) {
struct proc_dir_entry *entry;
static int coherence_id_open(struct inode *inode, struct file *file)
{
return single_open(file, coherence_id_show, NULL);
}
if (!sgi_proc_dir) {
sgi_proc_dir = proc_mkdir("sgi_sn", 0);
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 *))
{
struct proc_dir_entry *e = create_proc_entry(name, 0444, parent);
if (e) {
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;
}
entry = create_proc_entry("coherence_id", 0444, sgi_proc_dir);
if (entry) {
entry->nlink = 1;
entry->data = 0;
entry->read_proc = coherence_id_read_proc;
entry->write_proc = NULL;
}
return e;
}
void
register_sn_procfs(void) {
register_sn_partition_id();
register_sn_serial_numbers();
register_sn_force_interrupt();
register_sn_coherence_id();
void register_sn_procfs(void)
{
static struct proc_dir_entry *sgi_proc_dir = NULL;
struct proc_dir_entry *e;
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 */
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