10 files changed, 450 insertions, 270 deletions

diff --git a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c
index 9e0229f7e25f..93f8a8fa8890 100644
--- a/drivers/parisc/ccio-dma.c
+++ b/drivers/parisc/ccio-dma.c
@@ -40,6 +40,8 @@
 #include <linux/string.h>
 #include <linux/pci.h>
 #include <linux/reboot.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 
 #include <asm/byteorder.h>
 #include <asm/cache.h>          /* for L1_CACHE_BYTES */
@@ -1019,62 +1021,33 @@ static struct hppa_dma_ops ccio_ops = {
 };
 
 #ifdef CONFIG_PROC_FS
-static int proc_append(char *src, int len, char **dst, off_t *offset, int *max)
-{
-        if (len < *offset) {
-                *offset -= len;
-                return 0;
-        }
-        if (*offset > 0) {
-                src += *offset;
-                len -= *offset;
-                *offset = 0;
-        }
-        if (len > *max) {
-                len = *max;
-        }
-        memcpy(*dst, src, len);
-        *dst += len;
-        *max -= len;
-        return (*max == 0);
-}
-
-static int ccio_proc_info(char *buf, char **start, off_t offset, int count,
-                          int *eof, void *data)
+static int ccio_proc_info(struct seq_file *m, void *p)
 {
-        int max = count;
-        char tmp[80]; /* width of an ANSI-standard terminal */
+        int len = 0;
         struct ioc *ioc = ioc_list;
 
         while (ioc != NULL) {
                 unsigned int total_pages = ioc->res_size << 3;
                 unsigned long avg = 0, min, max;
-                int j, len;
+                int j;
 
-                len = sprintf(tmp, "%s\n", ioc->name);
-                if (proc_append(tmp, len, &buf, &offset, &count))
-                        break;
+                len += seq_printf(m, "%s\n", ioc->name);
                 
-                len = sprintf(tmp, "Cujo 2.0 bug    : %s\n",
-                              (ioc->cujo20_bug ? "yes" : "no"));
-                if (proc_append(tmp, len, &buf, &offset, &count))
-                        break;
+                len += seq_printf(m, "Cujo 2.0 bug    : %s\n",
+                                  (ioc->cujo20_bug ? "yes" : "no"));
                 
-                len = sprintf(tmp, "IO PDIR size    : %d bytes (%d entries)\n",
-                              total_pages * 8, total_pages);
-                if (proc_append(tmp, len, &buf, &offset, &count))
-                        break;
+                len += seq_printf(m, "IO PDIR size    : %d bytes (%d entries)\n",
+                               total_pages * 8, total_pages);
+
 #ifdef CCIO_MAP_STATS
-                len = sprintf(tmp, "IO PDIR entries : %ld free  %ld used (%d%%)\n",
-                              total_pages - ioc->used_pages, ioc->used_pages,
-                              (int)(ioc->used_pages * 100 / total_pages));
-                if (proc_append(tmp, len, &buf, &offset, &count))
-                        break;
+                len += seq_printf(m, "IO PDIR entries : %ld free  %ld used (%d%%)\n",
+                                  total_pages - ioc->used_pages, ioc->used_pages,
+                                  (int)(ioc->used_pages * 100 / total_pages));
 #endif
-                len = sprintf(tmp, "Resource bitmap : %d bytes (%d pages)\n", 
-                        ioc->res_size, total_pages);
-                if (proc_append(tmp, len, &buf, &offset, &count))
-                        break;
+
+                len += seq_printf(m, "Resource bitmap : %d bytes (%d pages)\n", 
+                                  ioc->res_size, total_pages);
+
 #ifdef CCIO_SEARCH_TIME
                 min = max = ioc->avg_search[0];
                 for(j = 0; j < CCIO_SEARCH_SAMPLE; ++j) {
@@ -1085,70 +1058,83 @@ static int ccio_proc_info(char *buf, char **start, off_t offset, int count,
                                 min = ioc->avg_search[j];
                 }
                 avg /= CCIO_SEARCH_SAMPLE;
-                len = sprintf(tmp, "  Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)\n",
-                              min, avg, max);
-                if (proc_append(tmp, len, &buf, &offset, &count))
-                        break;
+                len += seq_printf(m, "  Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)\n",
+                                  min, avg, max);
 #endif
 #ifdef CCIO_MAP_STATS
-                len = sprintf(tmp, "pci_map_single(): %8ld calls  %8ld pages (avg %d/1000)\n",
-                              ioc->msingle_calls, ioc->msingle_pages,
-                              (int)((ioc->msingle_pages * 1000)/ioc->msingle_calls));
-                if (proc_append(tmp, len, &buf, &offset, &count))
-                        break;
-                
+                len += seq_printf(m, "pci_map_single(): %8ld calls  %8ld pages (avg %d/1000)\n",
+                                  ioc->msingle_calls, ioc->msingle_pages,
+                                  (int)((ioc->msingle_pages * 1000)/ioc->msingle_calls));
 
                 /* KLUGE - unmap_sg calls unmap_single for each mapped page */
                 min = ioc->usingle_calls - ioc->usg_calls;
                 max = ioc->usingle_pages - ioc->usg_pages;
-                len = sprintf(tmp, "pci_unmap_single: %8ld calls  %8ld pages (avg %d/1000)\n",
-                              min, max, (int)((max * 1000)/min));
-                if (proc_append(tmp, len, &buf, &offset, &count))
-                        break;
+                len += seq_printf(m, "pci_unmap_single: %8ld calls  %8ld pages (avg %d/1000)\n",
+                                  min, max, (int)((max * 1000)/min));
  
-                len = sprintf(tmp, "pci_map_sg()    : %8ld calls  %8ld pages (avg %d/1000)\n",
-                              ioc->msg_calls, ioc->msg_pages,
-                              (int)((ioc->msg_pages * 1000)/ioc->msg_calls));
-                if (proc_append(tmp, len, &buf, &offset, &count))
-                        break;
-                len = sprintf(tmp, "pci_unmap_sg()  : %8ld calls  %8ld pages (avg %d/1000)\n\n\n",
-                              ioc->usg_calls, ioc->usg_pages,
-                              (int)((ioc->usg_pages * 1000)/ioc->usg_calls));
-                if (proc_append(tmp, len, &buf, &offset, &count))
-                        break;
+                len += seq_printf(m, "pci_map_sg()    : %8ld calls  %8ld pages (avg %d/1000)\n",
+                                  ioc->msg_calls, ioc->msg_pages,
+                                  (int)((ioc->msg_pages * 1000)/ioc->msg_calls));
+
+                len += seq_printf(m, "pci_unmap_sg()  : %8ld calls  %8ld pages (avg %d/1000)\n\n\n",
+                                  ioc->usg_calls, ioc->usg_pages,
+                                  (int)((ioc->usg_pages * 1000)/ioc->usg_calls));
 #endif  /* CCIO_MAP_STATS */
+
                 ioc = ioc->next;
         }
 
-        if (count == 0) {
-                *eof = 1;
-        }
-        return (max - count);
+        return 0;
+}
+
+static int ccio_proc_info_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, &ccio_proc_info, NULL);
 }
 
-static int ccio_resource_map(char *buf, char **start, off_t offset, int len,
-                             int *eof, void *data)
+static struct file_operations ccio_proc_info_fops = {
+        .owner = THIS_MODULE,
+        .open = ccio_proc_info_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static int ccio_proc_bitmap_info(struct seq_file *m, void *p)
 {
+        int len = 0;
         struct ioc *ioc = ioc_list;
 
-        buf[0] = '\0';
         while (ioc != NULL) {
                 u32 *res_ptr = (u32 *)ioc->res_map;
                 int j;
 
                 for (j = 0; j < (ioc->res_size / sizeof(u32)); j++) {
                         if ((j & 7) == 0)
-                                strcat(buf,"\n   ");
-                        sprintf(buf, "%s %08x", buf, *res_ptr);
+                                len += seq_puts(m, "\n   ");
+                        len += seq_printf(m, "%08x", *res_ptr);
                         res_ptr++;
                 }
-                strcat(buf, "\n\n");
+                len += seq_puts(m, "\n\n");
                 ioc = ioc->next;
                 break; /* XXX - remove me */
         }
 
-        return strlen(buf);
+        return 0;
 }
+
+static int ccio_proc_bitmap_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, &ccio_proc_bitmap_info, NULL);
+}
+
+static struct file_operations ccio_proc_bitmap_fops = {
+        .owner = THIS_MODULE,
+        .open = ccio_proc_bitmap_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
 #endif
 
 /**
@@ -1423,7 +1409,7 @@ static void __init ccio_init_resources(struct ioc *ioc)
         struct resource *res = ioc->mmio_region;
         char *name = kmalloc(14, GFP_KERNEL);
 
-        sprintf(name, "GSC Bus [%d/]", ioc->hw_path);
+        snprintf(name, 14, "GSC Bus [%d/]", ioc->hw_path);
 
         ccio_init_resource(res, name, &ioc->ioc_regs->io_io_low);
         ccio_init_resource(res + 1, name, &ioc->ioc_regs->io_io_low_hv);
@@ -1556,13 +1542,13 @@ static int ccio_probe(struct parisc_device *dev)
 {
         int i;
         struct ioc *ioc, **ioc_p = &ioc_list;
+        struct proc_dir_entry *info_entry, *bitmap_entry;
         
-        ioc = kmalloc(sizeof(struct ioc), GFP_KERNEL);
+        ioc = kzalloc(sizeof(struct ioc), GFP_KERNEL);
         if (ioc == NULL) {
                 printk(KERN_ERR MODULE_NAME ": memory allocation failure\n");
                 return 1;
         }
-        memset(ioc, 0, sizeof(struct ioc));
 
         ioc->name = dev->id.hversion == U2_IOA_RUNWAY ? "U2" : "UTurn";
 
@@ -1578,19 +1564,20 @@ static int ccio_probe(struct parisc_device *dev)
         ccio_ioc_init(ioc);
         ccio_init_resources(ioc);
         hppa_dma_ops = &ccio_ops;
-        dev->dev.platform_data = kmalloc(sizeof(struct pci_hba_data), GFP_KERNEL);
+        dev->dev.platform_data = kzalloc(sizeof(struct pci_hba_data), GFP_KERNEL);
 
         /* if this fails, no I/O cards will work, so may as well bug */
         BUG_ON(dev->dev.platform_data == NULL);
         HBA_DATA(dev->dev.platform_data)->iommu = ioc;
         
-
         if (ioc_count == 0) {
-                /* FIXME: Create separate entries for each ioc */
-                create_proc_read_entry(MODULE_NAME, S_IRWXU, proc_runway_root,
-                                       ccio_proc_info, NULL);
-                create_proc_read_entry(MODULE_NAME"-bitmap", S_IRWXU,
-                                       proc_runway_root, ccio_resource_map, NULL);
+                info_entry = create_proc_entry(MODULE_NAME, 0, proc_runway_root);
+                if (info_entry)
+                        info_entry->proc_fops = &ccio_proc_info_fops;
+
+                bitmap_entry = create_proc_entry(MODULE_NAME"-bitmap", 0, proc_runway_root);
+                if (bitmap_entry)
+                        bitmap_entry->proc_fops = &ccio_proc_bitmap_fops;
         }
 
         ioc_count++;
diff --git a/drivers/parisc/dino.c b/drivers/parisc/dino.c
index 216d1d859326..3d1a7f98c676 100644
--- a/drivers/parisc/dino.c
+++ b/drivers/parisc/dino.c
@@ -989,14 +989,12 @@ static int __init dino_probe(struct parisc_device *dev)
 */
         }
 
-        dino_dev = kmalloc(sizeof(struct dino_device), GFP_KERNEL);
+        dino_dev = kzalloc(sizeof(struct dino_device), GFP_KERNEL);
         if (!dino_dev) {
                 printk("dino_init_chip - couldn't alloc dino_device\n");
                 return 1;
         }
 
-        memset(dino_dev, 0, sizeof(struct dino_device));
-
         dino_dev->hba.dev = dev;
         dino_dev->hba.base_addr = ioremap(hpa, 4096);
         dino_dev->hba.lmmio_space_offset = 0;   /* CPU addrs == bus addrs */
diff --git a/drivers/parisc/hppb.c b/drivers/parisc/hppb.c
index 5edf93f80757..07dc2b6d4e93 100644
--- a/drivers/parisc/hppb.c
+++ b/drivers/parisc/hppb.c
@@ -60,12 +60,11 @@ static int hppb_probe(struct parisc_device *dev)
         }
 
         if(card->hpa) {
-                card->next = kmalloc(sizeof(struct hppb_card), GFP_KERNEL);
+                card->next = kzalloc(sizeof(struct hppb_card), GFP_KERNEL);
                 if(!card->next) {
                         printk(KERN_ERR "HP-PB: Unable to allocate memory.\n");
                         return 1;
                 }
-                memset(card->next, '\0', sizeof(struct hppb_card));
                 card = card->next;
         }
         printk(KERN_INFO "Found GeckoBoa at 0x%lx\n", dev->hpa.start);
diff --git a/drivers/parisc/iosapic.c b/drivers/parisc/iosapic.c
index 19657efa8dc3..8d7a36392eb8 100644
--- a/drivers/parisc/iosapic.c
+++ b/drivers/parisc/iosapic.c
@@ -873,28 +873,24 @@ void *iosapic_register(unsigned long hpa)
                 return NULL;
         }
 
-        isi = (struct iosapic_info *)kmalloc(sizeof(struct iosapic_info), GFP_KERNEL);
+        isi = (struct iosapic_info *)kzalloc(sizeof(struct iosapic_info), GFP_KERNEL);
         if (!isi) {
                 BUG();
                 return NULL;
         }
 
-        memset(isi, 0, sizeof(struct iosapic_info));
-
         isi->addr = ioremap(hpa, 4096);
         isi->isi_hpa = hpa;
         isi->isi_version = iosapic_rd_version(isi);
         isi->isi_num_vectors = IOSAPIC_IRDT_MAX_ENTRY(isi->isi_version) + 1;
 
         vip = isi->isi_vector = (struct vector_info *)
-                kmalloc(sizeof(struct vector_info) * isi->isi_num_vectors, GFP_KERNEL);
+                kzalloc(sizeof(struct vector_info) * isi->isi_num_vectors, GFP_KERNEL);
         if (vip == NULL) {
                 kfree(isi);
                 return NULL;
         }
 
-        memset(vip, 0, sizeof(struct vector_info) * isi->isi_num_vectors);
-
         for (cnt=0; cnt < isi->isi_num_vectors; cnt++, vip++) {
                 vip->irqline = (unsigned char) cnt;
                 vip->iosapic = isi;
diff --git a/drivers/parisc/lasi.c b/drivers/parisc/lasi.c
index 2b3ba1dcf332..cb3d28176129 100644
--- a/drivers/parisc/lasi.c
+++ b/drivers/parisc/lasi.c
@@ -166,11 +166,12 @@ static void lasi_power_off(void)
 int __init
 lasi_init_chip(struct parisc_device *dev)
 {
+        extern void (*chassis_power_off)(void);
         struct gsc_asic *lasi;
         struct gsc_irq gsc_irq;
         int ret;
 
-        lasi = kmalloc(sizeof(*lasi), GFP_KERNEL);
+        lasi = kzalloc(sizeof(*lasi), GFP_KERNEL);
         if (!lasi)
                 return -ENOMEM;
 
@@ -222,7 +223,7 @@ lasi_init_chip(struct parisc_device *dev)
          * ensure that only the first LASI (the one controlling the power off)
          * should set the HPA here */
         lasi_power_off_hpa = lasi->hpa;
-        pm_power_off = lasi_power_off;
+        chassis_power_off = lasi_power_off;
         
         return ret;
 }
diff --git a/drivers/parisc/lba_pci.c b/drivers/parisc/lba_pci.c
index cbae8c8963fa..e8a2a4a852f5 100644
--- a/drivers/parisc/lba_pci.c
+++ b/drivers/parisc/lba_pci.c
@@ -1565,7 +1565,7 @@ lba_driver_probe(struct parisc_device *dev)
         } else if (IS_MERCURY(dev) || IS_QUICKSILVER(dev)) {
                 func_class &= 0xff;
                 version = kmalloc(6, GFP_KERNEL);
-                sprintf(version,"TR%d.%d",(func_class >> 4),(func_class & 0xf));
+                snprintf(version, 6, "TR%d.%d",(func_class >> 4),(func_class & 0xf));
                 /* We could use one printk for both Elroy and Mercury,
                  * but for the mask for func_class.
                  */ 
@@ -1586,14 +1586,12 @@ lba_driver_probe(struct parisc_device *dev)
         **      have an IRT entry will get NULL back from iosapic code.
         */
         
-        lba_dev = kmalloc(sizeof(struct lba_device), GFP_KERNEL);
+        lba_dev = kzalloc(sizeof(struct lba_device), GFP_KERNEL);
         if (!lba_dev) {
                 printk(KERN_ERR "lba_init_chip - couldn't alloc lba_device\n");
                 return(1);
         }
 
-        memset(lba_dev, 0, sizeof(struct lba_device));
-
 
         /* ---------- First : initialize data we already have --------- */
 
diff --git a/drivers/parisc/pdc_stable.c b/drivers/parisc/pdc_stable.c
index 42a3c54e8e6c..a28e17898fbd 100644
--- a/drivers/parisc/pdc_stable.c
+++ b/drivers/parisc/pdc_stable.c
@@ -1,7 +1,7 @@
 /* 
  *    Interfaces to retrieve and set PDC Stable options (firmware)
  *
- *    Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org>
+ *    Copyright (C) 2005-2006 Thibaut VARENE <varenet@parisc-linux.org>
  *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -26,11 +26,19 @@
  *
  *    Since locations between 96 and 192 are the various paths, most (if not
  *    all) PA-RISC machines should have them. Anyway, for safety reasons, the
- *    following code can deal with only 96 bytes of Stable Storage, and all
+ *    following code can deal with just 96 bytes of Stable Storage, and all
  *    sizes between 96 and 192 bytes (provided they are multiple of struct
  *    device_path size, eg: 128, 160 and 192) to provide full information.
  *    The code makes no use of data above 192 bytes. One last word: there's one
  *    path we can always count on: the primary path.
+ *
+ *    The current policy wrt file permissions is:
+ *      - write: root only
+ *      - read: (reading triggers PDC calls) ? root only : everyone
+ *    The rationale is that PDC calls could hog (DoS) the machine.
+ *
+ *      TODO:
+ *      - timer/fastsize write calls
  */
 
 #undef PDCS_DEBUG
@@ -50,13 +58,15 @@
 #include <linux/kobject.h>
 #include <linux/device.h>
 #include <linux/errno.h>
+#include <linux/spinlock.h>
 
 #include <asm/pdc.h>
 #include <asm/page.h>
 #include <asm/uaccess.h>
 #include <asm/hardware.h>
 
-#define PDCS_VERSION    "0.10"
+#define PDCS_VERSION    "0.22"
+#define PDCS_PREFIX     "PDC Stable Storage"
 
 #define PDCS_ADDR_PPRI  0x00
 #define PDCS_ADDR_OSID  0x40
@@ -70,10 +80,12 @@ MODULE_DESCRIPTION("sysfs interface to HP PDC Stable Storage data");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(PDCS_VERSION);
 
+/* holds Stable Storage size. Initialized once and for all, no lock needed */
 static unsigned long pdcs_size __read_mostly;
 
 /* This struct defines what we need to deal with a parisc pdc path entry */
 struct pdcspath_entry {
+        rwlock_t rw_lock;               /* to protect path entry access */
         short ready;                    /* entry record is valid if != 0 */
         unsigned long addr;             /* entry address in stable storage */
         char *name;                     /* entry name */
@@ -121,6 +133,8 @@ struct pdcspath_attribute paths_attr_##_name = { \
  * content of the stable storage WRT various paths in these structs. We read
  * these structs when reading the files, and we will write to these structs when
  * writing to the files, and only then write them back to the Stable Storage.
+ *
+ * This function expects to be called with @entry->rw_lock write-hold.
  */
 static int
 pdcspath_fetch(struct pdcspath_entry *entry)
@@ -160,14 +174,15 @@ pdcspath_fetch(struct pdcspath_entry *entry)
  * pointer, from which it'll find out the corresponding hardware path.
  * For now we do not handle the case where there's an error in writing to the
  * Stable Storage area, so you'd better not mess up the data :P
+ *
+ * This function expects to be called with @entry->rw_lock write-hold.
  */
-static int
+static void
 pdcspath_store(struct pdcspath_entry *entry)
 {
         struct device_path *devpath;
 
-        if (!entry)
-                return -EINVAL;
+        BUG_ON(!entry);
 
         devpath = &entry->devpath;
         
@@ -176,10 +191,8 @@ pdcspath_store(struct pdcspath_entry *entry)
            First case, we don't have a preset hwpath... */
         if (!entry->ready) {
                 /* ...but we have a device, map it */
-                if (entry->dev)
-                        device_to_hwpath(entry->dev, (struct hardware_path *)devpath);
-                else
-                        return -EINVAL;
+                BUG_ON(!entry->dev);
+                device_to_hwpath(entry->dev, (struct hardware_path *)devpath);
         }
         /* else, we expect the provided hwpath to be valid. */
         
@@ -191,15 +204,13 @@ pdcspath_store(struct pdcspath_entry *entry)
                 printk(KERN_ERR "%s: an error occured when writing to PDC.\n"
                                 "It is likely that the Stable Storage data has been corrupted.\n"
                                 "Please check it carefully upon next reboot.\n", __func__);
-                return -EIO;
+                WARN_ON(1);
         }
                 
         /* kobject is already registered */
         entry->ready = 2;
         
         DPRINTK("%s: device: 0x%p\n", __func__, entry->dev);
-        
-        return 0;
 }
 
 /**
@@ -214,14 +225,17 @@ pdcspath_hwpath_read(struct pdcspath_entry *entry, char *buf)
 {
         char *out = buf;
         struct device_path *devpath;
-        unsigned short i;
+        short i;
 
         if (!entry || !buf)
                 return -EINVAL;
 
+        read_lock(&entry->rw_lock);
         devpath = &entry->devpath;
+        i = entry->ready;
+        read_unlock(&entry->rw_lock);
 
-        if (!entry->ready)
+        if (!i) /* entry is not ready */
                 return -ENODATA;
         
         for (i = 0; i < 6; i++) {
@@ -242,7 +256,7 @@ pdcspath_hwpath_read(struct pdcspath_entry *entry, char *buf)
  * 
  * We will call this function to change the current hardware path.
  * Hardware paths are to be given '/'-delimited, without brackets.
- * We take care to make sure that the provided path actually maps to an existing
+ * We make sure that the provided path actually maps to an existing
  * device, BUT nothing would prevent some foolish user to set the path to some
  * PCI bridge or even a CPU...
  * A better work around would be to make sure we are at the end of a device tree
@@ -298,17 +312,19 @@ pdcspath_hwpath_write(struct pdcspath_entry *entry, const char *buf, size_t coun
         }
         
         /* So far so good, let's get in deep */
+        write_lock(&entry->rw_lock);
         entry->ready = 0;
         entry->dev = dev;
         
         /* Now, dive in. Write back to the hardware */
-        WARN_ON(pdcspath_store(entry)); /* this warn should *NEVER* happen */
+        pdcspath_store(entry);
         
         /* Update the symlink to the real device */
         sysfs_remove_link(&entry->kobj, "device");
         sysfs_create_link(&entry->kobj, &entry->dev->kobj, "device");
+        write_unlock(&entry->rw_lock);
         
-        printk(KERN_INFO "PDC Stable Storage: changed \"%s\" path to \"%s\"\n",
+        printk(KERN_INFO PDCS_PREFIX ": changed \"%s\" path to \"%s\"\n",
                 entry->name, buf);
         
         return count;
@@ -326,14 +342,17 @@ pdcspath_layer_read(struct pdcspath_entry *entry, char *buf)
 {
         char *out = buf;
         struct device_path *devpath;
-        unsigned short i;
+        short i;
 
         if (!entry || !buf)
                 return -EINVAL;
         
+        read_lock(&entry->rw_lock);
         devpath = &entry->devpath;
+        i = entry->ready;
+        read_unlock(&entry->rw_lock);
 
-        if (!entry->ready)
+        if (!i) /* entry is not ready */
                 return -ENODATA;
         
         for (i = 0; devpath->layers[i] && (likely(i < 6)); i++)
@@ -388,15 +407,17 @@ pdcspath_layer_write(struct pdcspath_entry *entry, const char *buf, size_t count
         }
                 
         /* So far so good, let's get in deep */
+        write_lock(&entry->rw_lock);
         
         /* First, overwrite the current layers with the new ones, not touching
            the hardware path. */
         memcpy(&entry->devpath.layers, &layers, sizeof(layers));
         
         /* Now, dive in. Write back to the hardware */
-        WARN_ON(pdcspath_store(entry)); /* this warn should *NEVER* happen */
+        pdcspath_store(entry);
+        write_unlock(&entry->rw_lock);
         
-        printk(KERN_INFO "PDC Stable Storage: changed \"%s\" layers to \"%s\"\n",
+        printk(KERN_INFO PDCS_PREFIX ": changed \"%s\" layers to \"%s\"\n",
                 entry->name, buf);
         
         return count;
@@ -415,9 +436,6 @@ pdcspath_attr_show(struct kobject *kobj, struct attribute *attr, char *buf)
         struct pdcspath_attribute *pdcs_attr = to_pdcspath_attribute(attr);
         ssize_t ret = 0;
 
-        if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
-
         if (pdcs_attr->show)
                 ret = pdcs_attr->show(entry, buf);
 
@@ -454,8 +472,8 @@ static struct sysfs_ops pdcspath_attr_ops = {
 };
 
 /* These are the two attributes of any PDC path. */
-static PATHS_ATTR(hwpath, 0600, pdcspath_hwpath_read, pdcspath_hwpath_write);
-static PATHS_ATTR(layer, 0600, pdcspath_layer_read, pdcspath_layer_write);
+static PATHS_ATTR(hwpath, 0644, pdcspath_hwpath_read, pdcspath_hwpath_write);
+static PATHS_ATTR(layer, 0644, pdcspath_layer_read, pdcspath_layer_write);
 
 static struct attribute *paths_subsys_attrs[] = {
         &paths_attr_hwpath.attr,
@@ -484,36 +502,119 @@ static struct pdcspath_entry *pdcspath_entries[] = {
         NULL,
 };
 
+
+/* For more insight of what's going on here, refer to PDC Procedures doc,
+ * Section PDC_STABLE */
+
 /**
- * pdcs_info_read - Pretty printing of the remaining useful data.
+ * pdcs_size_read - Stable Storage size output.
  * @entry: An allocated and populated subsytem struct. We don't use it tho.
  * @buf: The output buffer to write to.
- * 
- * We will call this function to format the output of the 'info' attribute file.
- * Please refer to PDC Procedures documentation, section PDC_STABLE to get a
- * better insight of what we're doing here.
  */
 static ssize_t
-pdcs_info_read(struct subsystem *entry, char *buf)
+pdcs_size_read(struct subsystem *entry, char *buf)
 {
         char *out = buf;
-        __u32 result;
-        struct device_path devpath;
-        char *tmpstr = NULL;
         
         if (!entry || !buf)
                 return -EINVAL;
                 
         /* show the size of the stable storage */
-        out += sprintf(out, "Stable Storage size: %ld bytes\n", pdcs_size);
+        out += sprintf(out, "%ld\n", pdcs_size);
 
-        /* deal with flags */
-        if (pdc_stable_read(PDCS_ADDR_PPRI, &devpath, sizeof(devpath)) != PDC_OK)
-                return -EIO;
+        return out - buf;
+}
+
+/**
+ * pdcs_auto_read - Stable Storage autoboot/search flag output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ * @knob: The PF_AUTOBOOT or PF_AUTOSEARCH flag
+ */
+static ssize_t
+pdcs_auto_read(struct subsystem *entry, char *buf, int knob)
+{
+        char *out = buf;
+        struct pdcspath_entry *pathentry;
         
-        out += sprintf(out, "Autoboot: %s\n", (devpath.flags & PF_AUTOBOOT) ? "On" : "Off");
-        out += sprintf(out, "Autosearch: %s\n", (devpath.flags & PF_AUTOSEARCH) ? "On" : "Off");
-        out += sprintf(out, "Timer: %u s\n", (devpath.flags & PF_TIMER) ? (1 << (devpath.flags & PF_TIMER)) : 0);
+        if (!entry || !buf)
+                return -EINVAL;
+
+        /* Current flags are stored in primary boot path entry */
+        pathentry = &pdcspath_entry_primary;
+
+        read_lock(&pathentry->rw_lock);
+        out += sprintf(out, "%s\n", (pathentry->devpath.flags & knob) ?
+                                        "On" : "Off");
+        read_unlock(&pathentry->rw_lock);
+
+        return out - buf;
+}
+
+/**
+ * pdcs_autoboot_read - Stable Storage autoboot flag output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ */
+static inline ssize_t
+pdcs_autoboot_read(struct subsystem *entry, char *buf)
+{
+        return pdcs_auto_read(entry, buf, PF_AUTOBOOT);
+}
+
+/**
+ * pdcs_autosearch_read - Stable Storage autoboot flag output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ */
+static inline ssize_t
+pdcs_autosearch_read(struct subsystem *entry, char *buf)
+{
+        return pdcs_auto_read(entry, buf, PF_AUTOSEARCH);
+}
+
+/**
+ * pdcs_timer_read - Stable Storage timer count output (in seconds).
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ *
+ * The value of the timer field correponds to a number of seconds in powers of 2.
+ */
+static ssize_t
+pdcs_timer_read(struct subsystem *entry, char *buf)
+{
+        char *out = buf;
+        struct pdcspath_entry *pathentry;
+
+        if (!entry || !buf)
+                return -EINVAL;
+
+        /* Current flags are stored in primary boot path entry */
+        pathentry = &pdcspath_entry_primary;
+
+        /* print the timer value in seconds */
+        read_lock(&pathentry->rw_lock);
+        out += sprintf(out, "%u\n", (pathentry->devpath.flags & PF_TIMER) ?
+                                (1 << (pathentry->devpath.flags & PF_TIMER)) : 0);
+        read_unlock(&pathentry->rw_lock);
+
+        return out - buf;
+}
+
+/**
+ * pdcs_osid_read - Stable Storage OS ID register output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ */
+static ssize_t
+pdcs_osid_read(struct subsystem *entry, char *buf)
+{
+        char *out = buf;
+        __u32 result;
+        char *tmpstr = NULL;
+
+        if (!entry || !buf)
+                return -EINVAL;
 
         /* get OSID */
         if (pdc_stable_read(PDCS_ADDR_OSID, &result, sizeof(result)) != PDC_OK)
@@ -529,13 +630,31 @@ pdcs_info_read(struct subsystem *entry, char *buf)
                 case 0x0005:    tmpstr = "Novell Netware dependent data"; break;
                 default:        tmpstr = "Unknown"; break;
         }
-        out += sprintf(out, "OS ID: %s (0x%.4x)\n", tmpstr, (result >> 16));
+        out += sprintf(out, "%s (0x%.4x)\n", tmpstr, (result >> 16));
+
+        return out - buf;
+}
+
+/**
+ * pdcs_fastsize_read - Stable Storage FastSize register output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ *
+ * This register holds the amount of system RAM to be tested during boot sequence.
+ */
+static ssize_t
+pdcs_fastsize_read(struct subsystem *entry, char *buf)
+{
+        char *out = buf;
+        __u32 result;
+
+        if (!entry || !buf)
+                return -EINVAL;
 
         /* get fast-size */
         if (pdc_stable_read(PDCS_ADDR_FSIZ, &result, sizeof(result)) != PDC_OK)
                 return -EIO;
 
-        out += sprintf(out, "Memory tested: ");
         if ((result & 0x0F) < 0x0E)
                 out += sprintf(out, "%d kB", (1<<(result & 0x0F))*256);
         else
@@ -546,22 +665,18 @@ pdcs_info_read(struct subsystem *entry, char *buf)
 }
 
 /**
- * pdcs_info_write - This function handles boot flag modifying.
+ * pdcs_auto_write - This function handles autoboot/search flag modifying.
  * @entry: An allocated and populated subsytem struct. We don't use it tho.
  * @buf: The input buffer to read from.
  * @count: The number of bytes to be read.
+ * @knob: The PF_AUTOBOOT or PF_AUTOSEARCH flag
  * 
- * We will call this function to change the current boot flags.
+ * We will call this function to change the current autoboot flag.
  * We expect a precise syntax:
- *      \"n n\" (n == 0 or 1) to toggle respectively AutoBoot and AutoSearch
- *
- * As of now there is no incentive on my side to provide more "knobs" to that
- * interface, since modifying the rest of the data is pretty meaningless when
- * the machine is running and for the expected use of that facility, such as
- * PALO setting up the boot disk when installing a Linux distribution...
+ *      \"n\" (n == 0 or 1) to toggle AutoBoot Off or On
  */
 static ssize_t
-pdcs_info_write(struct subsystem *entry, const char *buf, size_t count)
+pdcs_auto_write(struct subsystem *entry, const char *buf, size_t count, int knob)
 {
         struct pdcspath_entry *pathentry;
         unsigned char flags;
@@ -582,7 +697,9 @@ pdcs_info_write(struct subsystem *entry, const char *buf, size_t count)
         pathentry = &pdcspath_entry_primary;
         
         /* Be nice to the existing flag record */
+        read_lock(&pathentry->rw_lock);
         flags = pathentry->devpath.flags;
+        read_unlock(&pathentry->rw_lock);
         
         DPRINTK("%s: flags before: 0x%X\n", __func__, flags);
                         
@@ -595,50 +712,85 @@ pdcs_info_write(struct subsystem *entry, const char *buf, size_t count)
         if ((c != 0) && (c != 1))
                 goto parse_error;
         if (c == 0)
-                flags &= ~PF_AUTOBOOT;
+                flags &= ~knob;
         else
-                flags |= PF_AUTOBOOT;
-        
-        if (*temp++ != ' ')
-                goto parse_error;
-        
-        c = *temp++ - '0';
-        if ((c != 0) && (c != 1))
-                goto parse_error;
-        if (c == 0)
-                flags &= ~PF_AUTOSEARCH;
-        else
-                flags |= PF_AUTOSEARCH;
+                flags |= knob;
         
         DPRINTK("%s: flags after: 0x%X\n", __func__, flags);
                 
         /* So far so good, let's get in deep */
+        write_lock(&pathentry->rw_lock);
         
         /* Change the path entry flags first */
         pathentry->devpath.flags = flags;
                 
         /* Now, dive in. Write back to the hardware */
-        WARN_ON(pdcspath_store(pathentry));     /* this warn should *NEVER* happen */
+        pdcspath_store(pathentry);
+        write_unlock(&pathentry->rw_lock);
         
-        printk(KERN_INFO "PDC Stable Storage: changed flags to \"%s\"\n", buf);
+        printk(KERN_INFO PDCS_PREFIX ": changed \"%s\" to \"%s\"\n",
+                (knob & PF_AUTOBOOT) ? "autoboot" : "autosearch",
+                (flags & knob) ? "On" : "Off");
         
         return count;
 
 parse_error:
-        printk(KERN_WARNING "%s: Parse error: expect \"n n\" (n == 0 or 1) for AB and AS\n", __func__);
+        printk(KERN_WARNING "%s: Parse error: expect \"n\" (n == 0 or 1)\n", __func__);
         return -EINVAL;
 }
 
-/* The last attribute (the 'root' one actually) with all remaining data. */
-static PDCS_ATTR(info, 0600, pdcs_info_read, pdcs_info_write);
+/**
+ * pdcs_autoboot_write - This function handles autoboot flag modifying.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The input buffer to read from.
+ * @count: The number of bytes to be read.
+ *
+ * We will call this function to change the current boot flags.
+ * We expect a precise syntax:
+ *      \"n\" (n == 0 or 1) to toggle AutoSearch Off or On
+ */
+static inline ssize_t
+pdcs_autoboot_write(struct subsystem *entry, const char *buf, size_t count)
+{
+        return pdcs_auto_write(entry, buf, count, PF_AUTOBOOT);
+}
+
+/**
+ * pdcs_autosearch_write - This function handles autosearch flag modifying.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The input buffer to read from.
+ * @count: The number of bytes to be read.
+ *
+ * We will call this function to change the current boot flags.
+ * We expect a precise syntax:
+ *      \"n\" (n == 0 or 1) to toggle AutoSearch Off or On
+ */
+static inline ssize_t
+pdcs_autosearch_write(struct subsystem *entry, const char *buf, size_t count)
+{
+        return pdcs_auto_write(entry, buf, count, PF_AUTOSEARCH);
+}
+
+/* The remaining attributes. */
+static PDCS_ATTR(size, 0444, pdcs_size_read, NULL);
+static PDCS_ATTR(autoboot, 0644, pdcs_autoboot_read, pdcs_autoboot_write);
+static PDCS_ATTR(autosearch, 0644, pdcs_autosearch_read, pdcs_autosearch_write);
+static PDCS_ATTR(timer, 0444, pdcs_timer_read, NULL);
+static PDCS_ATTR(osid, 0400, pdcs_osid_read, NULL);
+static PDCS_ATTR(fastsize, 0400, pdcs_fastsize_read, NULL);
 
 static struct subsys_attribute *pdcs_subsys_attrs[] = {
-        &pdcs_attr_info,
-        NULL,   /* maybe more in the future? */
+        &pdcs_attr_size,
+        &pdcs_attr_autoboot,
+        &pdcs_attr_autosearch,
+        &pdcs_attr_timer,
+        &pdcs_attr_osid,
+        &pdcs_attr_fastsize,
+        NULL,
 };
 
 static decl_subsys(paths, &ktype_pdcspath, NULL);
-static decl_subsys(pdc, NULL, NULL);
+static decl_subsys(stable, NULL, NULL);
 
 /**
  * pdcs_register_pathentries - Prepares path entries kobjects for sysfs usage.
@@ -656,8 +808,16 @@ pdcs_register_pathentries(void)
         struct pdcspath_entry *entry;
         int err;
         
+        /* Initialize the entries rw_lock before anything else */
+        for (i = 0; (entry = pdcspath_entries[i]); i++)
+                rwlock_init(&entry->rw_lock);
+
         for (i = 0; (entry = pdcspath_entries[i]); i++) {
-                if (pdcspath_fetch(entry) < 0)
+                write_lock(&entry->rw_lock);
+                err = pdcspath_fetch(entry);
+                write_unlock(&entry->rw_lock);
+
+                if (err < 0)
                         continue;
 
                 if ((err = kobject_set_name(&entry->kobj, "%s", entry->name)))
@@ -667,13 +827,14 @@ pdcs_register_pathentries(void)
                         return err;
                 
                 /* kobject is now registered */
+                write_lock(&entry->rw_lock);
                 entry->ready = 2;
                 
-                if (!entry->dev)
-                        continue;
-
                 /* Add a nice symlink to the real device */
-                sysfs_create_link(&entry->kobj, &entry->dev->kobj, "device");
+                if (entry->dev)
+                        sysfs_create_link(&entry->kobj, &entry->dev->kobj, "device");
+
+                write_unlock(&entry->rw_lock);
         }
         
         return 0;
@@ -688,14 +849,17 @@ pdcs_unregister_pathentries(void)
         unsigned short i;
         struct pdcspath_entry *entry;
         
-        for (i = 0; (entry = pdcspath_entries[i]); i++)
+        for (i = 0; (entry = pdcspath_entries[i]); i++) {
+                read_lock(&entry->rw_lock);
                 if (entry->ready >= 2)
-                        kobject_unregister(&entry->kobj);       
+                        kobject_unregister(&entry->kobj);
+                read_unlock(&entry->rw_lock);
+        }
 }
 
 /*
- * For now we register the pdc subsystem with the firmware subsystem
- * and the paths subsystem with the pdc subsystem
+ * For now we register the stable subsystem with the firmware subsystem
+ * and the paths subsystem with the stable subsystem
  */
 static int __init
 pdc_stable_init(void)
@@ -707,19 +871,23 @@ pdc_stable_init(void)
         if (pdc_stable_get_size(&pdcs_size) != PDC_OK) 
                 return -ENODEV;
 
-        printk(KERN_INFO "PDC Stable Storage facility v%s\n", PDCS_VERSION);
+        /* make sure we have enough data */
+        if (pdcs_size < 96)
+                return -ENODATA;
+
+        printk(KERN_INFO PDCS_PREFIX " facility v%s\n", PDCS_VERSION);
 
-        /* For now we'll register the pdc subsys within this driver */
-        if ((rc = firmware_register(&pdc_subsys)))
+        /* For now we'll register the stable subsys within this driver */
+        if ((rc = firmware_register(&stable_subsys)))
                 goto fail_firmreg;
 
-        /* Don't forget the info entry */
+        /* Don't forget the root entries */
         for (i = 0; (attr = pdcs_subsys_attrs[i]) && !error; i++)
                 if (attr->show)
-                        error = subsys_create_file(&pdc_subsys, attr);
+                        error = subsys_create_file(&stable_subsys, attr);
         
-        /* register the paths subsys as a subsystem of pdc subsys */
-        kset_set_kset_s(&paths_subsys, pdc_subsys);
+        /* register the paths subsys as a subsystem of stable subsys */
+        kset_set_kset_s(&paths_subsys, stable_subsys);
         if ((rc= subsystem_register(&paths_subsys)))
                 goto fail_subsysreg;
 
@@ -734,10 +902,10 @@ fail_pdcsreg:
         subsystem_unregister(&paths_subsys);
         
 fail_subsysreg:
-        firmware_unregister(&pdc_subsys);
+        firmware_unregister(&stable_subsys);
         
 fail_firmreg:
-        printk(KERN_INFO "PDC Stable Storage bailing out\n");
+        printk(KERN_INFO PDCS_PREFIX " bailing out\n");
         return rc;
 }
 
@@ -747,7 +915,7 @@ pdc_stable_exit(void)
         pdcs_unregister_pathentries();
         subsystem_unregister(&paths_subsys);
 
-        firmware_unregister(&pdc_subsys);
+        firmware_unregister(&stable_subsys);
 }
 
 
diff --git a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c
index c85653f315aa..5d47c5965c51 100644
--- a/drivers/parisc/sba_iommu.c
+++ b/drivers/parisc/sba_iommu.c
@@ -37,6 +37,8 @@
 #include <asm/hardware.h>       /* for register_parisc_driver() stuff */
 
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+
 #include <asm/runway.h>         /* for proc_runway_root */
 #include <asm/pdc.h>            /* for PDC_MODEL_* */
 #include <asm/pdcpat.h>         /* for is_pdc_pat() */
@@ -1892,46 +1894,43 @@ sba_common_init(struct sba_device *sba_dev)
 }
 
 #ifdef CONFIG_PROC_FS
-static int sba_proc_info(char *buf, char **start, off_t offset, int len)
+static int sba_proc_info(struct seq_file *m, void *p)
 {
         struct sba_device *sba_dev = sba_list;
         struct ioc *ioc = &sba_dev->ioc[0];     /* FIXME: Multi-IOC support! */
         int total_pages = (int) (ioc->res_size << 3); /* 8 bits per byte */
-        unsigned long i;
 #ifdef SBA_COLLECT_STATS
         unsigned long avg = 0, min, max;
 #endif
+        int i, len = 0;
 
-        sprintf(buf, "%s rev %d.%d\n",
+        len += seq_printf(m, "%s rev %d.%d\n",
                 sba_dev->name,
                 (sba_dev->hw_rev & 0x7) + 1,
                 (sba_dev->hw_rev & 0x18) >> 3
                 );
-        sprintf(buf, "%sIO PDIR size    : %d bytes (%d entries)\n",
-                buf,
+        len += seq_printf(m, "IO PDIR size    : %d bytes (%d entries)\n",
                 (int) ((ioc->res_size << 3) * sizeof(u64)), /* 8 bits/byte */
                 total_pages);
 
-        sprintf(buf, "%sResource bitmap : %d bytes (%d pages)\n", 
-                buf, ioc->res_size, ioc->res_size << 3);   /* 8 bits per byte */
+        len += seq_printf(m, "Resource bitmap : %d bytes (%d pages)\n", 
+                ioc->res_size, ioc->res_size << 3);   /* 8 bits per byte */
 
-        sprintf(buf, "%sLMMIO_BASE/MASK/ROUTE %08x %08x %08x\n",
-                buf,
+        len += seq_printf(m, "LMMIO_BASE/MASK/ROUTE %08x %08x %08x\n",
                 READ_REG32(sba_dev->sba_hpa + LMMIO_DIST_BASE),
                 READ_REG32(sba_dev->sba_hpa + LMMIO_DIST_MASK),
                 READ_REG32(sba_dev->sba_hpa + LMMIO_DIST_ROUTE)
                 );
 
         for (i=0; i<4; i++)
-                sprintf(buf, "%sDIR%ld_BASE/MASK/ROUTE %08x %08x %08x\n",
-                        buf, i,
+                len += seq_printf(m, "DIR%d_BASE/MASK/ROUTE %08x %08x %08x\n", i,
                         READ_REG32(sba_dev->sba_hpa + LMMIO_DIRECT0_BASE  + i*0x18),
                         READ_REG32(sba_dev->sba_hpa + LMMIO_DIRECT0_MASK  + i*0x18),
                         READ_REG32(sba_dev->sba_hpa + LMMIO_DIRECT0_ROUTE + i*0x18)
                 );
 
 #ifdef SBA_COLLECT_STATS
-        sprintf(buf, "%sIO PDIR entries : %ld free  %ld used (%d%%)\n", buf,
+        len += seq_printf(m, "IO PDIR entries : %ld free  %ld used (%d%%)\n",
                 total_pages - ioc->used_pages, ioc->used_pages,
                 (int) (ioc->used_pages * 100 / total_pages));
 
@@ -1942,53 +1941,76 @@ static int sba_proc_info(char *buf, char **start, off_t offset, int len)
                 if (ioc->avg_search[i] < min) min = ioc->avg_search[i];
         }
         avg /= SBA_SEARCH_SAMPLE;
-        sprintf(buf, "%s  Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)\n",
-                buf, min, avg, max);
+        len += seq_printf(m, "  Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)\n",
+                min, avg, max);
 
-        sprintf(buf, "%spci_map_single(): %12ld calls  %12ld pages (avg %d/1000)\n",
-                buf, ioc->msingle_calls, ioc->msingle_pages,
+        len += seq_printf(m, "pci_map_single(): %12ld calls  %12ld pages (avg %d/1000)\n",
+                ioc->msingle_calls, ioc->msingle_pages,
                 (int) ((ioc->msingle_pages * 1000)/ioc->msingle_calls));
 
         /* KLUGE - unmap_sg calls unmap_single for each mapped page */
         min = ioc->usingle_calls;
         max = ioc->usingle_pages - ioc->usg_pages;
-        sprintf(buf, "%spci_unmap_single: %12ld calls  %12ld pages (avg %d/1000)\n",
-                buf, min, max,
-                (int) ((max * 1000)/min));
+        len += seq_printf(m, "pci_unmap_single: %12ld calls  %12ld pages (avg %d/1000)\n",
+                min, max, (int) ((max * 1000)/min));
 
-        sprintf(buf, "%spci_map_sg()    : %12ld calls  %12ld pages (avg %d/1000)\n",
-                buf, ioc->msg_calls, ioc->msg_pages,
+        len += seq_printf(m, "pci_map_sg()    : %12ld calls  %12ld pages (avg %d/1000)\n",
+                ioc->msg_calls, ioc->msg_pages, 
                 (int) ((ioc->msg_pages * 1000)/ioc->msg_calls));
 
-        sprintf(buf, "%spci_unmap_sg()  : %12ld calls  %12ld pages (avg %d/1000)\n",
-                buf, ioc->usg_calls, ioc->usg_pages,
+        len += seq_printf(m, "pci_unmap_sg()  : %12ld calls  %12ld pages (avg %d/1000)\n",
+                ioc->usg_calls, ioc->usg_pages,
                 (int) ((ioc->usg_pages * 1000)/ioc->usg_calls));
 #endif
 
-        return strlen(buf);
+        return 0;
 }
 
-#if 0
-/* XXX too much output - exceeds 4k limit and needs to be re-written */
 static int
-sba_resource_map(char *buf, char **start, off_t offset, int len)
+sba_proc_open(struct inode *i, struct file *f)
+{
+        return single_open(f, &sba_proc_info, NULL);
+}
+
+static struct file_operations sba_proc_fops = {
+        .owner = THIS_MODULE,
+        .open = sba_proc_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static int
+sba_proc_bitmap_info(struct seq_file *m, void *p)
 {
         struct sba_device *sba_dev = sba_list;
-        struct ioc *ioc = &sba_dev->ioc[0];     /* FIXME: Mutli-IOC suppoer! */
+        struct ioc *ioc = &sba_dev->ioc[0];     /* FIXME: Multi-IOC support! */
         unsigned int *res_ptr = (unsigned int *)ioc->res_map;
-        int i;
+        int i, len = 0;
 
-        buf[0] = '\0';
-        for(i = 0; i < (ioc->res_size / sizeof(unsigned int)); ++i, ++res_ptr) {
+        for (i = 0; i < (ioc->res_size/sizeof(unsigned int)); ++i, ++res_ptr) {
                 if ((i & 7) == 0)
-                    strcat(buf,"\n   ");
-                sprintf(buf, "%s %08x", buf, *res_ptr);
+                        len += seq_printf(m, "\n   ");
+                len += seq_printf(m, " %08x", *res_ptr);
         }
-        strcat(buf, "\n");
+        len += seq_printf(m, "\n");
 
-        return strlen(buf);
+        return 0;
 }
-#endif /* 0 */
+
+static int
+sba_proc_bitmap_open(struct inode *i, struct file *f)
+{
+        return single_open(f, &sba_proc_bitmap_info, NULL);
+}
+
+static struct file_operations sba_proc_bitmap_fops = {
+        .owner = THIS_MODULE,
+        .open = sba_proc_bitmap_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
 #endif /* CONFIG_PROC_FS */
 
 static struct parisc_device_id sba_tbl[] = {
@@ -2021,6 +2043,7 @@ sba_driver_callback(struct parisc_device *dev)
         int i;
         char *version;
         void __iomem *sba_addr = ioremap(dev->hpa.start, SBA_FUNC_SIZE);
+        struct proc_dir_entry *info_entry, *bitmap_entry, *root;
 
         sba_dump_ranges(sba_addr);
 
@@ -2064,14 +2087,13 @@ sba_driver_callback(struct parisc_device *dev)
         printk(KERN_INFO "%s found %s at 0x%lx\n",
                 MODULE_NAME, version, dev->hpa.start);
 
-        sba_dev = kmalloc(sizeof(struct sba_device), GFP_KERNEL);
+        sba_dev = kzalloc(sizeof(struct sba_device), GFP_KERNEL);
         if (!sba_dev) {
                 printk(KERN_ERR MODULE_NAME " - couldn't alloc sba_device\n");
                 return -ENOMEM;
         }
 
         parisc_set_drvdata(dev, sba_dev);
-        memset(sba_dev, 0, sizeof(struct sba_device));
 
         for(i=0; i<MAX_IOC; i++)
                 spin_lock_init(&(sba_dev->ioc[i].res_lock));
@@ -2089,19 +2111,27 @@ sba_driver_callback(struct parisc_device *dev)
         hppa_dma_ops = &sba_ops;
 
 #ifdef CONFIG_PROC_FS
-        if (IS_ASTRO(&dev->id)) {
-                create_proc_info_entry("Astro", 0, proc_runway_root, sba_proc_info);
-        } else if (IS_IKE(&dev->id)) {
-                create_proc_info_entry("Ike", 0, proc_runway_root, sba_proc_info);
-        } else if (IS_PLUTO(&dev->id)) {
-                create_proc_info_entry("Pluto", 0, proc_mckinley_root, sba_proc_info);
-        } else {
-                create_proc_info_entry("Reo", 0, proc_runway_root, sba_proc_info);
+        switch (dev->id.hversion) {
+        case PLUTO_MCKINLEY_PORT:
+                root = proc_mckinley_root;
+                break;
+        case ASTRO_RUNWAY_PORT:
+        case IKE_MERCED_PORT:
+        default:
+                root = proc_runway_root;
+                break;
         }
-#if 0
-        create_proc_info_entry("bitmap", 0, proc_runway_root, sba_resource_map);
-#endif
+
+        info_entry = create_proc_entry("sba_iommu", 0, root);
+        bitmap_entry = create_proc_entry("sba_iommu-bitmap", 0, root);
+
+        if (info_entry)
+                info_entry->proc_fops = &sba_proc_fops;
+
+        if (bitmap_entry)
+                bitmap_entry->proc_fops = &sba_proc_bitmap_fops;
 #endif
+
         parisc_vmerge_boundary = IOVP_SIZE;
         parisc_vmerge_max_size = IOVP_SIZE * BITS_PER_LONG;
         parisc_has_iommu();
diff --git a/drivers/parisc/superio.c b/drivers/parisc/superio.c
index d14888e149bb..ba971fecd0d8 100644
--- a/drivers/parisc/superio.c
+++ b/drivers/parisc/superio.c
@@ -89,6 +89,9 @@ static struct superio_device sio_dev;
 #define DBG_INIT(x...)
 #endif
 
+#define SUPERIO "SuperIO"
+#define PFX     SUPERIO ": "
+
 static irqreturn_t
 superio_interrupt(int parent_irq, void *devp, struct pt_regs *regs)
 {
@@ -117,7 +120,7 @@ superio_interrupt(int parent_irq, void *devp, struct pt_regs *regs)
         local_irq = results & 0x0f;
 
         if (local_irq == 2 || local_irq > 7) {
-                printk(KERN_ERR "SuperIO: slave interrupted!\n");
+                printk(KERN_ERR PFX "slave interrupted!\n");
                 return IRQ_HANDLED;
         }
 
@@ -128,7 +131,7 @@ superio_interrupt(int parent_irq, void *devp, struct pt_regs *regs)
                 outb(OCW3_ISR,IC_PIC1+0);
                 results = inb(IC_PIC1+0);
                 if ((results & 0x80) == 0) { /* if ISR7 not set: spurious */
-                        printk(KERN_WARNING "SuperIO: spurious interrupt!\n");
+                        printk(KERN_WARNING PFX "spurious interrupt!\n");
                         return IRQ_HANDLED;
                 }
         }
@@ -163,27 +166,27 @@ superio_init(struct pci_dev *pcidev)
         /* ...then properly fixup the USB to point at suckyio PIC */
         sio->usb_pdev->irq = superio_fixup_irq(sio->usb_pdev);
 
-        printk(KERN_INFO "SuperIO: Found NS87560 Legacy I/O device at %s (IRQ %i) \n",
+        printk(KERN_INFO PFX "Found NS87560 Legacy I/O device at %s (IRQ %i) \n",
                pci_name(pdev), pdev->irq);
 
         pci_read_config_dword (pdev, SIO_SP1BAR, &sio->sp1_base);
         sio->sp1_base &= ~1;
-        printk (KERN_INFO "SuperIO: Serial port 1 at 0x%x\n", sio->sp1_base);
+        printk(KERN_INFO PFX "Serial port 1 at 0x%x\n", sio->sp1_base);
 
         pci_read_config_dword (pdev, SIO_SP2BAR, &sio->sp2_base);
         sio->sp2_base &= ~1;
-        printk (KERN_INFO "SuperIO: Serial port 2 at 0x%x\n", sio->sp2_base);
+        printk(KERN_INFO PFX "Serial port 2 at 0x%x\n", sio->sp2_base);
 
         pci_read_config_dword (pdev, SIO_PPBAR, &sio->pp_base);
         sio->pp_base &= ~1;
-        printk (KERN_INFO "SuperIO: Parallel port at 0x%x\n", sio->pp_base);
+        printk(KERN_INFO PFX "Parallel port at 0x%x\n", sio->pp_base);
 
         pci_read_config_dword (pdev, SIO_FDCBAR, &sio->fdc_base);
         sio->fdc_base &= ~1;
-        printk (KERN_INFO "SuperIO: Floppy controller at 0x%x\n", sio->fdc_base);
+        printk(KERN_INFO PFX "Floppy controller at 0x%x\n", sio->fdc_base);
         pci_read_config_dword (pdev, SIO_ACPIBAR, &sio->acpi_base);
         sio->acpi_base &= ~1;
-        printk (KERN_INFO "SuperIO: ACPI at 0x%x\n", sio->acpi_base);
+        printk(KERN_INFO PFX "ACPI at 0x%x\n", sio->acpi_base);
 
         request_region (IC_PIC1, 0x1f, "pic1");
         request_region (IC_PIC2, 0x1f, "pic2");
@@ -263,14 +266,14 @@ superio_init(struct pci_dev *pcidev)
         /* Setup USB power regulation */
         outb(1, sio->acpi_base + USB_REG_CR);
         if (inb(sio->acpi_base + USB_REG_CR) & 1)
-                printk(KERN_INFO "SuperIO: USB regulator enabled\n");
+                printk(KERN_INFO PFX "USB regulator enabled\n");
         else
-                printk(KERN_ERR "USB regulator not initialized!\n");
+                printk(KERN_ERR PFX "USB regulator not initialized!\n");
 
         if (request_irq(pdev->irq, superio_interrupt, SA_INTERRUPT,
-                        "SuperIO", (void *)sio)) {
+                        SUPERIO, (void *)sio)) {
 
-                printk(KERN_ERR "SuperIO: could not get irq\n");
+                printk(KERN_ERR PFX "could not get irq\n");
                 BUG();
                 return;
         }
@@ -284,7 +287,7 @@ static void superio_disable_irq(unsigned int irq)
         u8 r8;
 
         if ((irq < 1) || (irq == 2) || (irq > 7)) {
-                printk(KERN_ERR "SuperIO: Illegal irq number.\n");
+                printk(KERN_ERR PFX "Illegal irq number.\n");
                 BUG();
                 return;
         }
@@ -301,7 +304,7 @@ static void superio_enable_irq(unsigned int irq)
         u8 r8;
 
         if ((irq < 1) || (irq == 2) || (irq > 7)) {
-                printk(KERN_ERR "SuperIO: Illegal irq number (%d).\n", irq);
+                printk(KERN_ERR PFX "Illegal irq number (%d).\n", irq);
                 BUG();
                 return;
         }
@@ -319,7 +322,7 @@ static unsigned int superio_startup_irq(unsigned int irq)
 }
 
 static struct hw_interrupt_type superio_interrupt_type = {
-        .typename =     "SuperIO",
+        .typename =     SUPERIO,
         .startup =      superio_startup_irq,
         .shutdown =     superio_disable_irq,
         .enable =       superio_enable_irq,
@@ -413,7 +416,7 @@ static void __devinit superio_serial_init(void)
 
         retval = early_serial_setup(&serial[0]);
         if (retval < 0) {
-                printk(KERN_WARNING "SuperIO: Register Serial #0 failed.\n");
+                printk(KERN_WARNING PFX "Register Serial #0 failed.\n");
                 return;
         }
 
@@ -423,7 +426,7 @@ static void __devinit superio_serial_init(void)
         retval = early_serial_setup(&serial[1]);
 
         if (retval < 0)
-                printk(KERN_WARNING "SuperIO: Register Serial #1 failed.\n");
+                printk(KERN_WARNING PFX "Register Serial #1 failed.\n");
 #endif /* CONFIG_SERIAL_8250 */
 }
 
@@ -437,7 +440,7 @@ static void __devinit superio_parport_init(void)
                         PARPORT_DMA_NONE /* dma */,
                         NULL /*struct pci_dev* */) )
 
-                printk(KERN_WARNING "SuperIO: Probing parallel port failed.\n");
+                printk(KERN_WARNING PFX "Probing parallel port failed.\n");
 #endif  /* CONFIG_PARPORT_PC */
 }
 
@@ -499,7 +502,7 @@ static struct pci_device_id superio_tbl[] = {
 };
 
 static struct pci_driver superio_driver = {
-        .name =         "SuperIO",
+        .name =         SUPERIO,
         .id_table =     superio_tbl,
         .probe =        superio_probe,
 };
diff --git a/drivers/parisc/wax.c b/drivers/parisc/wax.c
index 17dce2adf7fe..813c2c24ab1e 100644
--- a/drivers/parisc/wax.c
+++ b/drivers/parisc/wax.c
@@ -76,7 +76,7 @@ wax_init_chip(struct parisc_device *dev)
         struct gsc_irq gsc_irq;
         int ret;
 
-        wax = kmalloc(sizeof(*wax), GFP_KERNEL);
+        wax = kzalloc(sizeof(*wax), GFP_KERNEL);
         if (!wax)
                 return -ENOMEM;