Merge master.kernel.org:/pub/scm/linux/kernel/git/kyle/parisc-2.6

* master.kernel.org:/pub/scm/linux/kernel/git/kyle/parisc-2.6: (23 commits)
  [PARISC] Move os_id_to_string() inside #ifndef __ASSEMBLY__
  [PARISC] Fix do_gettimeofday() hang
  [PARISC] Fix PCREL22F relocation problem for most modules
  [PARISC] Refactor show_regs in traps.c
  [PARISC] Add os_id_to_string helper
  [PARISC] OS_ID_LINUX == 0x0006
  [PARISC] Ensure Space ID hashing is turned off
  [PARISC] Match show_cache_info with reality
  [PARISC] Remove unused macro fixup_branch in syscall.S
  [PARISC] Add is_compat_task() helper
  [PARISC] Update Thibaut Varene's CREDITS entry
  [PARISC] Reduce data footprint in pdc_stable.c
  [PARISC] pdc_stable version 0.30
  [PARISC] Work around machines which do not support chassis warnings
  [PARISC] PDC_CHASSIS is implemented on all machines
  [PARISC] Remove unconditional #define PIC in syscall macros
  [PARISC] Use MFIA in current_text_addr on pa2.0 processors
  [PARISC] Remove dead function pc_in_user_space
  [PARISC] Test ioc_needs_fdc variable instead of open coding
  [PARISC] Fix gcc 4.1 warnings in sba_iommu.c
  ...

3 files changed, 237 insertions, 36 deletions

diff --git a/drivers/parisc/Kconfig b/drivers/parisc/Kconfig
index 3f5de867acd7..1d3b84b4af3f 100644
--- a/drivers/parisc/Kconfig
+++ b/drivers/parisc/Kconfig
@@ -140,18 +140,37 @@ config CHASSIS_LCD_LED
           If unsure, say Y.
 
 config PDC_CHASSIS
-        bool "PDC chassis State Panel support"
+        bool "PDC chassis state codes support"
         default y
         help
-          Say Y here if you want to enable support for the LED State front
-          panel as found on E class, and support for the GSP Virtual Front
-          Panel (LED State and message logging)  as found on high end
-          servers such as A, L and N-class.
-          
-          This has nothing to do with Chassis LCD and LED support.
+          Say Y here if you want to enable support for Chassis codes.
+          That includes support for LED State front panel as found on E
+          class, and support for the GSP Virtual Front Panel (LED State and
+          message logging)  as found on high end servers such as A, L and
+          N-class.
+          This driver will also display progress messages on LCD display,
+          such as "INI", "RUN" and "FLT", and might thus clobber messages
+          shown by the LED/LCD driver.
+          This driver updates the state panel (LED and/or LCD) upon system
+          state change (eg: boot, shutdown or panic).
           
           If unsure, say Y.
 
+
+config PDC_CHASSIS_WARN
+        bool "PDC chassis warnings support"
+        depends on PROC_FS
+        default y
+        help
+          Say Y here if you want to enable support for Chassis warnings.
+          This will add a proc entry '/proc/chassis' giving some information
+          about the overall health state of the system.
+          This includes NVRAM battery level, overtemp or failures such as
+          fans or power units.
+
+          If unsure, say Y.
+
+
 config PDC_STABLE
         tristate "PDC Stable Storage support"
         depends on SYSFS
diff --git a/drivers/parisc/pdc_stable.c b/drivers/parisc/pdc_stable.c
index bbeabe3fc4c6..ea1b7a63598e 100644
--- a/drivers/parisc/pdc_stable.c
+++ b/drivers/parisc/pdc_stable.c
@@ -28,8 +28,15 @@
  *    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.
+ *    One last word: there's one path we can always count on: the primary path.
+ *    Anything above 224 bytes is used for 'osdep2' OS-dependent storage area.
+ *
+ *    The first OS-dependent area should always be available. Obviously, this is
+ *    not true for the other one. Also bear in mind that reading/writing from/to
+ *    osdep2 is much more expensive than from/to osdep1.
+ *    NOTE: We do not handle the 2 bytes OS-dep area at 0x5D, nor the first
+ *    2 bytes of storage available right after OSID. That's a total of 4 bytes
+ *    sacrificed: -ETOOLAZY :P
  *
  *    The current policy wrt file permissions is:
  *      - write: root only
@@ -64,15 +71,18 @@
 #include <asm/uaccess.h>
 #include <asm/hardware.h>
 
-#define PDCS_VERSION    "0.22"
+#define PDCS_VERSION    "0.30"
 #define PDCS_PREFIX     "PDC Stable Storage"
 
 #define PDCS_ADDR_PPRI  0x00
 #define PDCS_ADDR_OSID  0x40
+#define PDCS_ADDR_OSD1  0x48
+#define PDCS_ADDR_DIAG  0x58
 #define PDCS_ADDR_FSIZ  0x5C
 #define PDCS_ADDR_PCON  0x60
 #define PDCS_ADDR_PALT  0x80
 #define PDCS_ADDR_PKBD  0xA0
+#define PDCS_ADDR_OSD2  0xE0
 
 MODULE_AUTHOR("Thibaut VARENE <varenet@parisc-linux.org>");
 MODULE_DESCRIPTION("sysfs interface to HP PDC Stable Storage data");
@@ -82,6 +92,9 @@ MODULE_VERSION(PDCS_VERSION);
 /* holds Stable Storage size. Initialized once and for all, no lock needed */
 static unsigned long pdcs_size __read_mostly;
 
+/* holds OS ID. Initialized once and for all, hopefully to 0x0006 */
+static u16 pdcs_osid __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 */
@@ -609,27 +622,64 @@ 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)
+        out += sprintf(out, "%s dependent data (0x%.4x)\n",
+                os_id_to_string(pdcs_osid), pdcs_osid);
+
+        return out - buf;
+}
+
+/**
+ * pdcs_osdep1_read - Stable Storage OS-Dependent data area 1 output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ *
+ * This can hold 16 bytes of OS-Dependent data.
+ */
+static ssize_t
+pdcs_osdep1_read(struct subsystem *entry, char *buf)
+{
+        char *out = buf;
+        u32 result[4];
+
+        if (!entry || !buf)
+                return -EINVAL;
+
+        if (pdc_stable_read(PDCS_ADDR_OSD1, &result, sizeof(result)) != PDC_OK)
                 return -EIO;
 
-        /* the actual result is 16 bits away */
-        switch (result >> 16) {
-                case 0x0000:    tmpstr = "No OS-dependent data"; break;
-                case 0x0001:    tmpstr = "HP-UX dependent data"; break;
-                case 0x0002:    tmpstr = "MPE-iX dependent data"; break;
-                case 0x0003:    tmpstr = "OSF dependent data"; break;
-                case 0x0004:    tmpstr = "HP-RT dependent data"; break;
-                case 0x0005:    tmpstr = "Novell Netware dependent data"; break;
-                default:        tmpstr = "Unknown"; break;
-        }
-        out += sprintf(out, "%s (0x%.4x)\n", tmpstr, (result >> 16));
+        out += sprintf(out, "0x%.8x\n", result[0]);
+        out += sprintf(out, "0x%.8x\n", result[1]);
+        out += sprintf(out, "0x%.8x\n", result[2]);
+        out += sprintf(out, "0x%.8x\n", result[3]);
+
+        return out - buf;
+}
+
+/**
+ * pdcs_diagnostic_read - Stable Storage Diagnostic register output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ *
+ * I have NFC how to interpret the content of that register ;-).
+ */
+static ssize_t
+pdcs_diagnostic_read(struct subsystem *entry, char *buf)
+{
+        char *out = buf;
+        u32 result;
+
+        if (!entry || !buf)
+                return -EINVAL;
+
+        /* get diagnostic */
+        if (pdc_stable_read(PDCS_ADDR_DIAG, &result, sizeof(result)) != PDC_OK)
+                return -EIO;
+
+        out += sprintf(out, "0x%.4x\n", (result >> 16));
 
         return out - buf;
 }
@@ -645,7 +695,7 @@ static ssize_t
 pdcs_fastsize_read(struct subsystem *entry, char *buf)
 {
         char *out = buf;
-        __u32 result;
+        u32 result;
 
         if (!entry || !buf)
                 return -EINVAL;
@@ -664,6 +714,39 @@ pdcs_fastsize_read(struct subsystem *entry, char *buf)
 }
 
 /**
+ * pdcs_osdep2_read - Stable Storage OS-Dependent data area 2 output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ *
+ * This can hold pdcs_size - 224 bytes of OS-Dependent data, when available.
+ */
+static ssize_t
+pdcs_osdep2_read(struct subsystem *entry, char *buf)
+{
+        char *out = buf;
+        unsigned long size;
+        unsigned short i;
+        u32 result;
+
+        if (unlikely(pdcs_size <= 224))
+                return -ENODATA;
+
+        size = pdcs_size - 224;
+
+        if (!entry || !buf)
+                return -EINVAL;
+
+        for (i=0; i<size; i+=4) {
+                if (unlikely(pdc_stable_read(PDCS_ADDR_OSD2 + i, &result,
+                                        sizeof(result)) != PDC_OK))
+                        return -EIO;
+                out += sprintf(out, "0x%.8x\n", result);
+        }
+
+        return out - buf;
+}
+
+/**
  * 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.
@@ -770,13 +853,100 @@ pdcs_autosearch_write(struct subsystem *entry, const char *buf, size_t count)
         return pdcs_auto_write(entry, buf, count, PF_AUTOSEARCH);
 }
 
+/**
+ * pdcs_osdep1_write - Stable Storage OS-Dependent data area 1 input.
+ * @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.
+ *
+ * This can store 16 bytes of OS-Dependent data. We use a byte-by-byte
+ * write approach. It's up to userspace to deal with it when constructing
+ * its input buffer.
+ */
+static ssize_t
+pdcs_osdep1_write(struct subsystem *entry, const char *buf, size_t count)
+{
+        u8 in[16];
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        if (!entry || !buf || !count)
+                return -EINVAL;
+
+        if (unlikely(pdcs_osid != OS_ID_LINUX))
+                return -EPERM;
+
+        if (count > 16)
+                return -EMSGSIZE;
+
+        /* We'll use a local copy of buf */
+        memset(in, 0, 16);
+        memcpy(in, buf, count);
+
+        if (pdc_stable_write(PDCS_ADDR_OSD1, &in, sizeof(in)) != PDC_OK)
+                return -EIO;
+
+        return count;
+}
+
+/**
+ * pdcs_osdep2_write - Stable Storage OS-Dependent data area 2 input.
+ * @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.
+ *
+ * This can store pdcs_size - 224 bytes of OS-Dependent data. We use a
+ * byte-by-byte write approach. It's up to userspace to deal with it when
+ * constructing its input buffer.
+ */
+static ssize_t
+pdcs_osdep2_write(struct subsystem *entry, const char *buf, size_t count)
+{
+        unsigned long size;
+        unsigned short i;
+        u8 in[4];
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        if (!entry || !buf || !count)
+                return -EINVAL;
+
+        if (unlikely(pdcs_size <= 224))
+                return -ENOSYS;
+
+        if (unlikely(pdcs_osid != OS_ID_LINUX))
+                return -EPERM;
+
+        size = pdcs_size - 224;
+
+        if (count > size)
+                return -EMSGSIZE;
+
+        /* We'll use a local copy of buf */
+
+        for (i=0; i<count; i+=4) {
+                memset(in, 0, 4);
+                memcpy(in, buf+i, (count-i < 4) ? count-i : 4);
+                if (unlikely(pdc_stable_write(PDCS_ADDR_OSD2 + i, &in,
+                                        sizeof(in)) != PDC_OK))
+                        return -EIO;
+        }
+
+        return count;
+}
+
 /* 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(osid, 0444, pdcs_osid_read, NULL);
+static PDCS_ATTR(osdep1, 0600, pdcs_osdep1_read, pdcs_osdep1_write);
+static PDCS_ATTR(diagnostic, 0400, pdcs_diagnostic_read, NULL);
 static PDCS_ATTR(fastsize, 0400, pdcs_fastsize_read, NULL);
+static PDCS_ATTR(osdep2, 0600, pdcs_osdep2_read, pdcs_osdep2_write);
 
 static struct subsys_attribute *pdcs_subsys_attrs[] = {
         &pdcs_attr_size,
@@ -784,7 +954,10 @@ static struct subsys_attribute *pdcs_subsys_attrs[] = {
         &pdcs_attr_autosearch,
         &pdcs_attr_timer,
         &pdcs_attr_osid,
+        &pdcs_attr_osdep1,
+        &pdcs_attr_diagnostic,
         &pdcs_attr_fastsize,
+        &pdcs_attr_osdep2,
         NULL,
 };
 
@@ -865,6 +1038,7 @@ pdc_stable_init(void)
 {
         struct subsys_attribute *attr;
         int i, rc = 0, error = 0;
+        u32 result;
 
         /* find the size of the stable storage */
         if (pdc_stable_get_size(&pdcs_size) != PDC_OK) 
@@ -876,6 +1050,13 @@ pdc_stable_init(void)
 
         printk(KERN_INFO PDCS_PREFIX " facility v%s\n", PDCS_VERSION);
 
+        /* get OSID */
+        if (pdc_stable_read(PDCS_ADDR_OSID, &result, sizeof(result)) != PDC_OK)
+                return -EIO;
+
+        /* the actual result is 16 bits away */
+        pdcs_osid = (u16)(result >> 16);
+
         /* For now we'll register the stable subsys within this driver */
         if ((rc = firmware_register(&stable_subsys)))
                 goto fail_firmreg;
@@ -887,7 +1068,7 @@ pdc_stable_init(void)
         
         /* register the paths subsys as a subsystem of stable subsys */
         kset_set_kset_s(&paths_subsys, stable_subsys);
-        if ((rc= subsystem_register(&paths_subsys)))
+        if ((rc = subsystem_register(&paths_subsys)))
                 goto fail_subsysreg;
 
         /* now we create all "files" for the paths subsys */
diff --git a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c
index 278f325021ee..d09e39e39c60 100644
--- a/drivers/parisc/sba_iommu.c
+++ b/drivers/parisc/sba_iommu.c
@@ -316,10 +316,10 @@ static int reserve_sba_gart = 1;
 **
 ** Superdome (in particular, REO) allows only 64-bit CSR accesses.
 */
-#define READ_REG32(addr)         le32_to_cpu(__raw_readl(addr))
-#define READ_REG64(addr)         le64_to_cpu(__raw_readq(addr))
-#define WRITE_REG32(val, addr) __raw_writel(cpu_to_le32(val), addr)
-#define WRITE_REG64(val, addr) __raw_writeq(cpu_to_le64(val), addr)
+#define READ_REG32(addr)        readl(addr)
+#define READ_REG64(addr)        readq(addr)
+#define WRITE_REG32(val, addr)  writel((val), (addr))
+#define WRITE_REG64(val, addr)  writeq((val), (addr))
 
 #ifdef CONFIG_64BIT
 #define READ_REG(addr)          READ_REG64(addr)
@@ -1427,7 +1427,7 @@ sba_ioc_init_pluto(struct parisc_device *sba, struct ioc *ioc, int ioc_num)
         iov_order = get_order(iova_space_size >> (IOVP_SHIFT - PAGE_SHIFT));
         ioc->pdir_size = (iova_space_size / IOVP_SIZE) * sizeof(u64);
 
-        DBG_INIT("%s() hpa 0x%lx IOV %dMB (%d bits)\n",
+        DBG_INIT("%s() hpa 0x%p IOV %dMB (%d bits)\n",
                 __FUNCTION__, ioc->ioc_hpa, iova_space_size >> 20,
                 iov_order + PAGE_SHIFT);
 
@@ -1764,7 +1764,7 @@ printk("sba_hw_init(): mem_boot 0x%x 0x%x 0x%x 0x%x\n", PAGE0->mem_boot.hpa,
 
         sba_dev->num_ioc = num_ioc;
         for (i = 0; i < num_ioc; i++) {
-                unsigned long ioc_hpa = sba_dev->ioc[i].ioc_hpa;
+                void __iomem *ioc_hpa = sba_dev->ioc[i].ioc_hpa;
                 unsigned int j;
 
                 for (j=0; j < sizeof(u64) * ROPES_PER_IOC; j+=sizeof(u64)) {
@@ -1776,7 +1776,8 @@ printk("sba_hw_init(): mem_boot 0x%x 0x%x 0x%x 0x%x\n", PAGE0->mem_boot.hpa,
                          * Improves netperf UDP_STREAM by ~10% for bcm5701.
                          */
                         if (IS_PLUTO(sba_dev->iodc)) {
-                                unsigned long rope_cfg, cfg_val;
+                                void __iomem *rope_cfg;
+                                unsigned long cfg_val;
 
                                 rope_cfg = ioc_hpa + IOC_ROPE0_CFG + j;
                                 cfg_val = READ_REG(rope_cfg);
@@ -1902,7 +1903,7 @@ sba_common_init(struct sba_device *sba_dev)
          * (bit #61, big endian), we have to flush and sync every time
          * IO-PDIR is changed in Ike/Astro.
          */
-        if (boot_cpu_data.pdc.capabilities & PDC_MODEL_IOPDIR_FDC) {
+        if (ioc_needs_fdc) {
                 printk(KERN_INFO MODULE_NAME " FDC/SYNC required.\n");
         } else {
                 printk(KERN_INFO MODULE_NAME " IOC has cache coherent PDIR.\n");