Merge branch 'mainline' into upstream-linus

21 files changed, 1112 insertions, 120 deletions

diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index c40e487d9f5c..52ea94b891f5 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -495,6 +495,21 @@ config LEGACY_PTY_COUNT
           When not in use, each legacy PTY occupies 12 bytes on 32-bit
           architectures and 24 bytes on 64-bit architectures.
 
+config BRIQ_PANEL
+        tristate 'Total Impact briQ front panel driver'
+        depends on PPC_CHRP
+        ---help---
+          The briQ is a small footprint CHRP computer with a frontpanel VFD, a
+          tristate led and two switches. It is the size of a CDROM drive.
+
+          If you have such one and want anything showing on the VFD then you
+          must answer Y here.
+
+          To compile this driver as a module, choose M here: the
+          module will be called briq_panel.
+
+          It's safe to say N here.
+
 config PRINTER
         tristate "Parallel printer support"
         depends on PARPORT
@@ -596,6 +611,13 @@ config HVC_CONSOLE
           console. This driver allows each pSeries partition to have a console
           which is accessed via the HMC.
 
+config HVC_ISERIES
+        bool "iSeries Hypervisor Virtual Console support"
+        depends on PPC_ISERIES && !VIOCONS
+        select HVC_DRIVER
+        help
+          iSeries machines support a hypervisor virtual console.
+
 config HVC_RTAS
         bool "IBM RTAS Console support"
         depends on PPC_RTAS
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 6e0f4469d8bb..8c6dfc621520 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -42,6 +42,7 @@ obj-$(CONFIG_AMIGA_BUILTIN_SERIAL) += amiserial.o
 obj-$(CONFIG_SX)                += sx.o generic_serial.o
 obj-$(CONFIG_RIO)               += rio/ generic_serial.o
 obj-$(CONFIG_HVC_CONSOLE)       += hvc_vio.o hvsi.o
+obj-$(CONFIG_HVC_ISERIES)       += hvc_iseries.o
 obj-$(CONFIG_HVC_RTAS)          += hvc_rtas.o
 obj-$(CONFIG_HVC_DRIVER)        += hvc_console.o
 obj-$(CONFIG_RAW_DRIVER)        += raw.o
@@ -51,6 +52,7 @@ obj-$(CONFIG_VIOCONS)		+= viocons.o
 obj-$(CONFIG_VIOTAPE)           += viotape.o
 obj-$(CONFIG_HVCS)              += hvcs.o
 obj-$(CONFIG_SGI_MBCS)          += mbcs.o
+obj-$(CONFIG_BRIQ_PANEL)        += briq_panel.o
 
 obj-$(CONFIG_PRINTER)           += lp.o
 obj-$(CONFIG_TIPAR)             += tipar.o
diff --git a/drivers/char/agp/agp.h b/drivers/char/agp/agp.h
index 3c623b67ea1c..8b3317fd46c9 100644
--- a/drivers/char/agp/agp.h
+++ b/drivers/char/agp/agp.h
@@ -117,7 +117,7 @@ struct agp_bridge_driver {
 };
 
 struct agp_bridge_data {
-        struct agp_version *version;
+        const struct agp_version *version;
         struct agp_bridge_driver *driver;
         struct vm_operations_struct *vm_ops;
         void *previous_size;
diff --git a/drivers/char/agp/backend.c b/drivers/char/agp/backend.c
index 509adc403250..d59e037ddd12 100644
--- a/drivers/char/agp/backend.c
+++ b/drivers/char/agp/backend.c
@@ -44,7 +44,7 @@
  * past 0.99 at all due to some boolean logic error. */
 #define AGPGART_VERSION_MAJOR 0
 #define AGPGART_VERSION_MINOR 101
-static struct agp_version agp_current_version =
+static const struct agp_version agp_current_version =
 {
         .major = AGPGART_VERSION_MAJOR,
         .minor = AGPGART_VERSION_MINOR,
diff --git a/drivers/char/agp/efficeon-agp.c b/drivers/char/agp/efficeon-agp.c
index b788b0a3bbf3..30f730ff81c1 100644
--- a/drivers/char/agp/efficeon-agp.c
+++ b/drivers/char/agp/efficeon-agp.c
@@ -337,13 +337,6 @@ static struct agp_bridge_driver efficeon_driver = {
         .agp_destroy_page       = agp_generic_destroy_page,
 };
 
-
-static int agp_efficeon_resume(struct pci_dev *pdev)
-{
-        printk(KERN_DEBUG PFX "agp_efficeon_resume()\n");
-        return efficeon_configure();
-}
-
 static int __devinit agp_efficeon_probe(struct pci_dev *pdev,
                                      const struct pci_device_id *ent)
 {
@@ -414,11 +407,18 @@ static void __devexit agp_efficeon_remove(struct pci_dev *pdev)
         agp_put_bridge(bridge);
 }
 
+#ifdef CONFIG_PM
 static int agp_efficeon_suspend(struct pci_dev *dev, pm_message_t state)
 {
         return 0;
 }
 
+static int agp_efficeon_resume(struct pci_dev *pdev)
+{
+        printk(KERN_DEBUG PFX "agp_efficeon_resume()\n");
+        return efficeon_configure();
+}
+#endif
 
 static struct pci_device_id agp_efficeon_pci_table[] = {
         {
@@ -439,8 +439,10 @@ static struct pci_driver agp_efficeon_pci_driver = {
         .id_table       = agp_efficeon_pci_table,
         .probe          = agp_efficeon_probe,
         .remove         = agp_efficeon_remove,
+#ifdef CONFIG_PM
         .suspend        = agp_efficeon_suspend,
         .resume         = agp_efficeon_resume,
+#endif
 };
 
 static int __init agp_efficeon_init(void)
diff --git a/drivers/char/agp/frontend.c b/drivers/char/agp/frontend.c
index d9c5a9142ad1..0f2ed2aa2d81 100644
--- a/drivers/char/agp/frontend.c
+++ b/drivers/char/agp/frontend.c
@@ -151,35 +151,12 @@ static void agp_add_seg_to_client(struct agp_client *client,
         client->segments = seg;
 }
 
-/* Originally taken from linux/mm/mmap.c from the array
- * protection_map.
- * The original really should be exported to modules, or
- * some routine which does the conversion for you
- */
-
-static const pgprot_t my_protect_map[16] =
-{
-        __P000, __P001, __P010, __P011, __P100, __P101, __P110, __P111,
-        __S000, __S001, __S010, __S011, __S100, __S101, __S110, __S111
-};
-
 static pgprot_t agp_convert_mmap_flags(int prot)
 {
-#define _trans(x,bit1,bit2) \
-((bit1==bit2)?(x&bit1):(x&bit1)?bit2:0)
-
         unsigned long prot_bits;
-        pgprot_t temp;
-
-        prot_bits = _trans(prot, PROT_READ, VM_READ) |
-            _trans(prot, PROT_WRITE, VM_WRITE) |
-            _trans(prot, PROT_EXEC, VM_EXEC);
-
-        prot_bits |= VM_SHARED;
 
-        temp = my_protect_map[prot_bits & 0x0000000f];
-
-        return temp;
+        prot_bits = calc_vm_prot_bits(prot) | VM_SHARED;
+        return vm_get_page_prot(prot_bits);
 }
 
 static int agp_create_segment(struct agp_client *client, struct agp_region *region)
diff --git a/drivers/char/agp/generic.c b/drivers/char/agp/generic.c
index cc5ea347a8a7..0dcdb363923f 100644
--- a/drivers/char/agp/generic.c
+++ b/drivers/char/agp/generic.c
@@ -568,25 +568,34 @@ static void agp_v3_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_
                 *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
                 goto done;
 
+        } else if (*requested_mode & AGPSTAT3_4X) {
+                *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
+                *bridge_agpstat |= AGPSTAT3_4X;
+                goto done;
+
         } else {
 
                 /*
-                 * If we didn't specify AGPx8, we can only do x4.
-                 * If the hardware can't do x4, we're up shit creek, and never
-                 *  should have got this far.
+                 * If we didn't specify an AGP mode, we see if both
+                 * the graphics card, and the bridge can do x8, and use if so.
+                 * If not, we fall back to x4 mode.
                  */
-                *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
-                if ((*bridge_agpstat & AGPSTAT3_4X) && (*vga_agpstat & AGPSTAT3_4X))
-                        *bridge_agpstat |= AGPSTAT3_4X;
-                else {
-                        printk(KERN_INFO PFX "Badness. Don't know which AGP mode to set. "
-                                                        "[bridge_agpstat:%x vga_agpstat:%x fell back to:- bridge_agpstat:%x vga_agpstat:%x]\n",
-                                                        origbridge, origvga, *bridge_agpstat, *vga_agpstat);
-                        if (!(*bridge_agpstat & AGPSTAT3_4X))
-                                printk(KERN_INFO PFX "Bridge couldn't do AGP x4.\n");
-                        if (!(*vga_agpstat & AGPSTAT3_4X))
-                                printk(KERN_INFO PFX "Graphic card couldn't do AGP x4.\n");
-                        return;
+                if ((*bridge_agpstat & AGPSTAT3_8X) && (*vga_agpstat & AGPSTAT3_8X)) {
+                        printk(KERN_INFO PFX "No AGP mode specified. Setting to highest mode supported by bridge & card (x8).\n");
+                        *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
+                        *vga_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
+                } else {
+                        printk(KERN_INFO PFX "Fell back to AGPx4 mode because");
+                        if (!(*bridge_agpstat & AGPSTAT3_8X)) {
+                                printk("bridge couldn't do x8. bridge_agpstat:%x (orig=%x)\n", *bridge_agpstat, origbridge);
+                                *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
+                                *bridge_agpstat |= AGPSTAT3_4X;
+                        }
+                        if (!(*vga_agpstat & AGPSTAT3_8X)) {
+                                printk("graphics card couldn't do x8. vga_agpstat:%x (orig=%x)\n", *vga_agpstat, origvga);
+                                *vga_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
+                                *vga_agpstat |= AGPSTAT3_4X;
+                        }
                 }
         }
 
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
index 61ac3809f997..d1ede7db5a12 100644
--- a/drivers/char/agp/intel-agp.c
+++ b/drivers/char/agp/intel-agp.c
@@ -2,14 +2,6 @@
  * Intel AGPGART routines.
  */
 
-/*
- * Intel(R) 855GM/852GM and 865G support added by David Dawes
- * <dawes@tungstengraphics.com>.
- *
- * Intel(R) 915G/915GM support added by Alan Hourihane
- * <alanh@tungstengraphics.com>.
- */
-
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/init.h>
@@ -17,6 +9,21 @@
 #include <linux/agp_backend.h>
 #include "agp.h"
 
+#define PCI_DEVICE_ID_INTEL_82946GZ_HB      0x2970
+#define PCI_DEVICE_ID_INTEL_82946GZ_IG      0x2972
+#define PCI_DEVICE_ID_INTEL_82965G_1_HB     0x2980
+#define PCI_DEVICE_ID_INTEL_82965G_1_IG     0x2982
+#define PCI_DEVICE_ID_INTEL_82965Q_HB       0x2990
+#define PCI_DEVICE_ID_INTEL_82965Q_IG       0x2992
+#define PCI_DEVICE_ID_INTEL_82965G_HB       0x29A0
+#define PCI_DEVICE_ID_INTEL_82965G_IG       0x29A2
+
+#define IS_I965 (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82946GZ_HB || \
+                 agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965G_1_HB || \
+                 agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965Q_HB || \
+                 agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82965G_HB)
+
+
 /* Intel 815 register */
 #define INTEL_815_APCONT        0x51
 #define INTEL_815_ATTBASE_MASK  ~0x1FFFFFFF
@@ -40,6 +47,8 @@
 #define I915_GMCH_GMS_STOLEN_48M        (0x6 << 4)
 #define I915_GMCH_GMS_STOLEN_64M        (0x7 << 4)
 
+/* Intel 965G registers */
+#define I965_MSAC 0x62
 
 /* Intel 7505 registers */
 #define INTEL_I7505_APSIZE      0x74
@@ -354,6 +363,7 @@ static struct aper_size_info_fixed intel_i830_sizes[] =
         /* The 64M mode still requires a 128k gatt */
         {64, 16384, 5},
         {256, 65536, 6},
+        {512, 131072, 7},
 };
 
 static struct _intel_i830_private {
@@ -377,7 +387,11 @@ static void intel_i830_init_gtt_entries(void)
         /* We obtain the size of the GTT, which is also stored (for some
          * reason) at the top of stolen memory. Then we add 4KB to that
          * for the video BIOS popup, which is also stored in there. */
-        size = agp_bridge->driver->fetch_size() + 4;
+
+        if (IS_I965)
+                size = 512 + 4;
+        else
+                size = agp_bridge->driver->fetch_size() + 4;
 
         if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82830_HB ||
             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82845G_HB) {
@@ -423,7 +437,7 @@ static void intel_i830_init_gtt_entries(void)
                         if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915G_HB ||
                             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB ||
                             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB ||
-                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB)
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB || IS_I965 )
                                 gtt_entries = MB(48) - KB(size);
                         else
                                 gtt_entries = 0;
@@ -433,7 +447,7 @@ static void intel_i830_init_gtt_entries(void)
                         if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915G_HB ||
                             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB ||
                             agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB ||
-                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB)
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945GM_HB || IS_I965)
                                 gtt_entries = MB(64) - KB(size);
                         else
                                 gtt_entries = 0;
@@ -791,6 +805,77 @@ static int intel_i915_create_gatt_table(struct agp_bridge_data *bridge)
 
         return 0;
 }
+static int intel_i965_fetch_size(void)
+{
+       struct aper_size_info_fixed *values;
+       u32 offset = 0;
+       u8 temp;
+
+#define I965_512MB_ADDRESS_MASK (3<<1)
+
+       values = A_SIZE_FIX(agp_bridge->driver->aperture_sizes);
+
+       pci_read_config_byte(intel_i830_private.i830_dev, I965_MSAC, &temp);
+       temp &= I965_512MB_ADDRESS_MASK;
+       switch (temp) {
+       case 0x00:
+               offset = 0; /* 128MB */
+               break;
+       case 0x06:
+               offset = 3; /* 512MB */
+               break;
+       default:
+       case 0x02:
+               offset = 2; /* 256MB */
+               break;
+       }
+
+       agp_bridge->previous_size = agp_bridge->current_size = (void *)(values + offset);
+
+       return values[offset].size;
+}
+
+/* The intel i965 automatically initializes the agp aperture during POST.
++ * Use the memory already set aside for in the GTT.
++ */
+static int intel_i965_create_gatt_table(struct agp_bridge_data *bridge)
+{
+       int page_order;
+       struct aper_size_info_fixed *size;
+       int num_entries;
+       u32 temp;
+
+       size = agp_bridge->current_size;
+       page_order = size->page_order;
+       num_entries = size->num_entries;
+       agp_bridge->gatt_table_real = NULL;
+
+       pci_read_config_dword(intel_i830_private.i830_dev, I915_MMADDR, &temp);
+
+       temp &= 0xfff00000;
+       intel_i830_private.gtt = ioremap((temp + (512 * 1024)) , 512 * 1024);
+
+       if (!intel_i830_private.gtt)
+               return -ENOMEM;
+
+
+       intel_i830_private.registers = ioremap(temp,128 * 4096);
+       if (!intel_i830_private.registers)
+               return -ENOMEM;
+
+       temp = readl(intel_i830_private.registers+I810_PGETBL_CTL) & 0xfffff000;
+       global_cache_flush();   /* FIXME: ? */
+
+       /* we have to call this as early as possible after the MMIO base address is known */
+       intel_i830_init_gtt_entries();
+
+       agp_bridge->gatt_table = NULL;
+
+       agp_bridge->gatt_bus_addr = temp;
+
+       return 0;
+}
+
 
 static int intel_fetch_size(void)
 {
@@ -1307,7 +1392,7 @@ static struct agp_bridge_driver intel_830_driver = {
         .owner                  = THIS_MODULE,
         .aperture_sizes         = intel_i830_sizes,
         .size_type              = FIXED_APER_SIZE,
-        .num_aperture_sizes     = 3,
+        .num_aperture_sizes     = 4,
         .needs_scratch_page     = TRUE,
         .configure              = intel_i830_configure,
         .fetch_size             = intel_i830_fetch_size,
@@ -1469,7 +1554,7 @@ static struct agp_bridge_driver intel_915_driver = {
         .owner                  = THIS_MODULE,
         .aperture_sizes         = intel_i830_sizes,
         .size_type              = FIXED_APER_SIZE,
-        .num_aperture_sizes     = 3,
+        .num_aperture_sizes     = 4,
         .needs_scratch_page     = TRUE,
         .configure              = intel_i915_configure,
         .fetch_size             = intel_i915_fetch_size,
@@ -1489,6 +1574,29 @@ static struct agp_bridge_driver intel_915_driver = {
         .agp_destroy_page       = agp_generic_destroy_page,
 };
 
+static struct agp_bridge_driver intel_i965_driver = {
+       .owner                  = THIS_MODULE,
+       .aperture_sizes         = intel_i830_sizes,
+       .size_type              = FIXED_APER_SIZE,
+       .num_aperture_sizes     = 4,
+       .needs_scratch_page     = TRUE,
+       .configure              = intel_i915_configure,
+       .fetch_size             = intel_i965_fetch_size,
+       .cleanup                = intel_i915_cleanup,
+       .tlb_flush              = intel_i810_tlbflush,
+       .mask_memory            = intel_i810_mask_memory,
+       .masks                  = intel_i810_masks,
+       .agp_enable             = intel_i810_agp_enable,
+       .cache_flush            = global_cache_flush,
+       .create_gatt_table      = intel_i965_create_gatt_table,
+       .free_gatt_table        = intel_i830_free_gatt_table,
+       .insert_memory          = intel_i915_insert_entries,
+       .remove_memory          = intel_i915_remove_entries,
+       .alloc_by_type          = intel_i830_alloc_by_type,
+       .free_by_type           = intel_i810_free_by_type,
+       .agp_alloc_page         = agp_generic_alloc_page,
+       .agp_destroy_page       = agp_generic_destroy_page,
+};
 
 static struct agp_bridge_driver intel_7505_driver = {
         .owner                  = THIS_MODULE,
@@ -1684,6 +1792,35 @@ static int __devinit agp_intel_probe(struct pci_dev *pdev,
                         bridge->driver = &intel_845_driver;
                 name = "945GM";
                 break;
+        case PCI_DEVICE_ID_INTEL_82946GZ_HB:
+                if (find_i830(PCI_DEVICE_ID_INTEL_82946GZ_IG))
+                        bridge->driver = &intel_i965_driver;
+                else
+                        bridge->driver = &intel_845_driver;
+                name = "946GZ";
+                break;
+        case PCI_DEVICE_ID_INTEL_82965G_1_HB:
+                if (find_i830(PCI_DEVICE_ID_INTEL_82965G_1_IG))
+                        bridge->driver = &intel_i965_driver;
+                else
+                        bridge->driver = &intel_845_driver;
+                name = "965G";
+                break;
+        case PCI_DEVICE_ID_INTEL_82965Q_HB:
+                if (find_i830(PCI_DEVICE_ID_INTEL_82965Q_IG))
+                        bridge->driver = &intel_i965_driver;
+                else
+                        bridge->driver = &intel_845_driver;
+                name = "965Q";
+                break;
+        case PCI_DEVICE_ID_INTEL_82965G_HB:
+                if (find_i830(PCI_DEVICE_ID_INTEL_82965G_IG))
+                        bridge->driver = &intel_i965_driver;
+                else
+                        bridge->driver = &intel_845_driver;
+                name = "965G";
+                break;
+
         case PCI_DEVICE_ID_INTEL_7505_0:
                 bridge->driver = &intel_7505_driver;
                 name = "E7505";
@@ -1766,6 +1903,7 @@ static void __devexit agp_intel_remove(struct pci_dev *pdev)
         agp_put_bridge(bridge);
 }
 
+#ifdef CONFIG_PM
 static int agp_intel_resume(struct pci_dev *pdev)
 {
         struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
@@ -1786,9 +1924,12 @@ static int agp_intel_resume(struct pci_dev *pdev)
                 intel_i830_configure();
         else if (bridge->driver == &intel_810_driver)
                 intel_i810_configure();
+        else if (bridge->driver == &intel_i965_driver)
+                intel_i915_configure();
 
         return 0;
 }
+#endif
 
 static struct pci_device_id agp_intel_pci_table[] = {
 #define ID(x)                                           \
@@ -1825,6 +1966,10 @@ static struct pci_device_id agp_intel_pci_table[] = {
         ID(PCI_DEVICE_ID_INTEL_82915GM_HB),
         ID(PCI_DEVICE_ID_INTEL_82945G_HB),
         ID(PCI_DEVICE_ID_INTEL_82945GM_HB),
+        ID(PCI_DEVICE_ID_INTEL_82946GZ_HB),
+        ID(PCI_DEVICE_ID_INTEL_82965G_1_HB),
+        ID(PCI_DEVICE_ID_INTEL_82965Q_HB),
+        ID(PCI_DEVICE_ID_INTEL_82965G_HB),
         { }
 };
 
@@ -1835,7 +1980,9 @@ static struct pci_driver agp_intel_pci_driver = {
         .id_table       = agp_intel_pci_table,
         .probe          = agp_intel_probe,
         .remove         = __devexit_p(agp_intel_remove),
+#ifdef CONFIG_PM
         .resume         = agp_intel_resume,
+#endif
 };
 
 static int __init agp_intel_init(void)
diff --git a/drivers/char/agp/uninorth-agp.c b/drivers/char/agp/uninorth-agp.c
index 1de1b12043bf..91b71e750ee1 100644
--- a/drivers/char/agp/uninorth-agp.c
+++ b/drivers/char/agp/uninorth-agp.c
@@ -601,8 +601,8 @@ static int __devinit agp_uninorth_probe(struct pci_dev *pdev,
                 uninorth_node = of_find_node_by_name(NULL, "u3");
         }
         if (uninorth_node) {
-                int *revprop = (int *)
-                        get_property(uninorth_node, "device-rev", NULL);
+                const int *revprop = get_property(uninorth_node,
+                                "device-rev", NULL);
                 if (revprop != NULL)
                         uninorth_rev = *revprop & 0x3f;
                 of_node_put(uninorth_node);
diff --git a/drivers/char/agp/via-agp.c b/drivers/char/agp/via-agp.c
index b8ec25d17478..c149ac9ce9a7 100644
--- a/drivers/char/agp/via-agp.c
+++ b/drivers/char/agp/via-agp.c
@@ -9,7 +9,7 @@
 #include <linux/agp_backend.h>
 #include "agp.h"
 
-static struct pci_device_id agp_via_pci_table[];
+static const struct pci_device_id agp_via_pci_table[];
 
 #define VIA_GARTCTRL    0x80
 #define VIA_APSIZE      0x84
@@ -485,7 +485,7 @@ static int agp_via_resume(struct pci_dev *pdev)
 #endif /* CONFIG_PM */
 
 /* must be the same order as name table above */
-static struct pci_device_id agp_via_pci_table[] = {
+static const struct pci_device_id agp_via_pci_table[] = {
 #define ID(x) \
         {                                               \
         .class          = (PCI_CLASS_BRIDGE_HOST << 8), \
diff --git a/drivers/char/briq_panel.c b/drivers/char/briq_panel.c
new file mode 100644
index 000000000000..a0e5eac5f33a
--- /dev/null
+++ b/drivers/char/briq_panel.c
@@ -0,0 +1,268 @@
+/*
+ * Drivers for the Total Impact PPC based computer "BRIQ"
+ * by Dr. Karsten Jeppesen
+ *
+ */
+
+#include <linux/module.h>
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/tty.h>
+#include <linux/timer.h>
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/wait.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/delay.h>
+#include <linux/miscdevice.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/init.h>
+
+#include <asm/uaccess.h>
+#include <asm/io.h>
+#include <asm/prom.h>
+
+#define         BRIQ_PANEL_MINOR        156
+#define         BRIQ_PANEL_VFD_IOPORT   0x0390
+#define         BRIQ_PANEL_LED_IOPORT   0x0398
+#define         BRIQ_PANEL_VER          "1.1 (04/20/2002)"
+#define         BRIQ_PANEL_MSG0         "Loading Linux"
+
+static int              vfd_is_open;
+static unsigned char    vfd[40];
+static int              vfd_cursor;
+static unsigned char    ledpb, led;
+
+static void update_vfd(void)
+{
+        int     i;
+
+        /* cursor home */
+        outb(0x02, BRIQ_PANEL_VFD_IOPORT);
+        for (i=0; i<20; i++)
+                outb(vfd[i], BRIQ_PANEL_VFD_IOPORT + 1);
+
+        /* cursor to next line */
+        outb(0xc0, BRIQ_PANEL_VFD_IOPORT);
+        for (i=20; i<40; i++)
+                outb(vfd[i], BRIQ_PANEL_VFD_IOPORT + 1);
+
+}
+
+static void set_led(char state)
+{
+        if (state == 'R')
+                led = 0x01;
+        else if (state == 'G')
+                led = 0x02;
+        else if (state == 'Y')
+                led = 0x03;
+        else if (state == 'X')
+                led = 0x00;
+        outb(led, BRIQ_PANEL_LED_IOPORT);
+}
+
+static int briq_panel_open(struct inode *ino, struct file *filep)
+{
+        /* enforce single access */
+        if (vfd_is_open)
+                return -EBUSY;
+        vfd_is_open = 1;
+
+        return 0;
+}
+
+static int briq_panel_release(struct inode *ino, struct file *filep)
+{
+        if (!vfd_is_open)
+                return -ENODEV;
+
+        vfd_is_open = 0;
+
+        return 0;
+}
+
+static ssize_t briq_panel_read(struct file *file, char *buf, size_t count,
+                         loff_t *ppos)
+{
+        unsigned short c;
+        unsigned char cp;
+
+#if 0   /*  Can't seek (pread) on this device  */
+        if (ppos != &file->f_pos)
+                return -ESPIPE;
+#endif
+
+        if (!vfd_is_open)
+                return -ENODEV;
+
+        c = (inb(BRIQ_PANEL_LED_IOPORT) & 0x000c) | (ledpb & 0x0003);
+        set_led(' ');
+        /* upper button released */
+        if ((!(ledpb & 0x0004)) && (c & 0x0004)) {
+                cp = ' ';
+                ledpb = c;
+                if (copy_to_user(buf, &cp, 1))
+                        return -EFAULT;
+                return 1;
+        }
+        /* lower button released */
+        else if ((!(ledpb & 0x0008)) && (c & 0x0008)) {
+                cp = '\r';
+                ledpb = c;
+                if (copy_to_user(buf, &cp, 1))
+                        return -EFAULT;
+                return 1;
+        } else {
+                ledpb = c;
+                return 0;
+        }
+}
+
+static void scroll_vfd( void )
+{
+        int     i;
+
+        for (i=0; i<20; i++) {
+                vfd[i] = vfd[i+20];
+                vfd[i+20] = ' ';
+        }
+        vfd_cursor = 20;
+}
+
+static ssize_t briq_panel_write(struct file *file, const char *buf, size_t len,
+                          loff_t *ppos)
+{
+        size_t indx = len;
+        int i, esc = 0;
+
+#if 0   /*  Can't seek (pwrite) on this device  */
+        if (ppos != &file->f_pos)
+                return -ESPIPE;
+#endif
+
+        if (!vfd_is_open)
+                return -EBUSY;
+
+        for (;;) {
+                if (!indx)
+                        break;
+                if (esc) {
+                        set_led(*buf);
+                        esc = 0;
+                } else if (*buf == 27) {
+                        esc = 1;
+                } else if (*buf == 12) {
+                        /* do a form feed */
+                        for (i=0; i<40; i++)
+                                vfd[i] = ' ';
+                        vfd_cursor = 0;
+                } else if (*buf == 10) {
+                        if (vfd_cursor < 20)
+                                vfd_cursor = 20;
+                        else if (vfd_cursor < 40)
+                                vfd_cursor = 40;
+                        else if (vfd_cursor < 60)
+                                vfd_cursor = 60;
+                        if (vfd_cursor > 59)
+                                scroll_vfd();
+                } else {
+                        /* just a character */
+                        if (vfd_cursor > 39)
+                                scroll_vfd();
+                        vfd[vfd_cursor++] = *buf;
+                }
+                indx--;
+                buf++;
+        }
+        update_vfd();
+
+        return len;
+}
+
+static struct file_operations briq_panel_fops = {
+        .owner          = THIS_MODULE,
+        .read           = briq_panel_read,
+        .write          = briq_panel_write,
+        .open           = briq_panel_open,
+        .release        = briq_panel_release,
+};
+
+static struct miscdevice briq_panel_miscdev = {
+        BRIQ_PANEL_MINOR,
+        "briq_panel",
+        &briq_panel_fops
+};
+
+static int __init briq_panel_init(void)
+{
+        struct device_node *root = find_path_device("/");
+        char *machine;
+        int i;
+
+        machine = get_property(root, "model", NULL);
+        if (!machine || strncmp(machine, "TotalImpact,BRIQ-1", 18) != 0)
+                return -ENODEV;
+
+        printk(KERN_INFO
+                "briq_panel: v%s Dr. Karsten Jeppesen (kj@totalimpact.com)\n",
+                BRIQ_PANEL_VER);
+
+        if (!request_region(BRIQ_PANEL_VFD_IOPORT, 4, "BRIQ Front Panel"))
+                return -EBUSY;
+
+        if (!request_region(BRIQ_PANEL_LED_IOPORT, 2, "BRIQ Front Panel")) {
+                release_region(BRIQ_PANEL_VFD_IOPORT, 4);
+                return -EBUSY;
+        }
+        ledpb = inb(BRIQ_PANEL_LED_IOPORT) & 0x000c;
+
+        if (misc_register(&briq_panel_miscdev) < 0) {
+                release_region(BRIQ_PANEL_VFD_IOPORT, 4);
+                release_region(BRIQ_PANEL_LED_IOPORT, 2);
+                return -EBUSY;
+        }
+
+        outb(0x38, BRIQ_PANEL_VFD_IOPORT);      /* Function set */
+        outb(0x01, BRIQ_PANEL_VFD_IOPORT);      /* Clear display */
+        outb(0x0c, BRIQ_PANEL_VFD_IOPORT);      /* Display on */
+        outb(0x06, BRIQ_PANEL_VFD_IOPORT);      /* Entry normal */
+        for (i=0; i<40; i++)
+                vfd[i]=' ';
+#ifndef MODULE
+        vfd[0] = 'L';
+        vfd[1] = 'o';
+        vfd[2] = 'a';
+        vfd[3] = 'd';
+        vfd[4] = 'i';
+        vfd[5] = 'n';
+        vfd[6] = 'g';
+        vfd[7] = ' ';
+        vfd[8] = '.';
+        vfd[9] = '.';
+        vfd[10] = '.';
+#endif /* !MODULE */
+
+        update_vfd();
+
+        return 0;
+}
+
+static void __exit briq_panel_exit(void)
+{
+        misc_deregister(&briq_panel_miscdev);
+        release_region(BRIQ_PANEL_VFD_IOPORT, 4);
+        release_region(BRIQ_PANEL_LED_IOPORT, 2);
+}
+
+module_init(briq_panel_init);
+module_exit(briq_panel_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Karsten Jeppesen <karsten@jeppesens.com>");
+MODULE_DESCRIPTION("Driver for the Total Impact briQ front panel");
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index 613d67f1c7f0..a76d2c40dd5e 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -80,7 +80,8 @@ struct hvc_struct {
         struct tty_struct *tty;
         unsigned int count;
         int do_wakeup;
-        char outbuf[N_OUTBUF] __ALIGNED__;
+        char *outbuf;
+        int outbuf_size;
         int n_outbuf;
         uint32_t vtermno;
         struct hv_ops *ops;
@@ -319,10 +320,8 @@ static int hvc_open(struct tty_struct *tty, struct file * filp)
         struct kobject *kobjp;
 
         /* Auto increments kobject reference if found. */
-        if (!(hp = hvc_get_by_index(tty->index))) {
-                printk(KERN_WARNING "hvc_console: tty open failed, no vty associated with tty.\n");
+        if (!(hp = hvc_get_by_index(tty->index)))
                 return -ENODEV;
-        }
 
         spin_lock_irqsave(&hp->lock, flags);
         /* Check and then increment for fast path open. */
@@ -505,7 +504,7 @@ static int hvc_write(struct tty_struct *tty, const unsigned char *buf, int count
         if (hp->n_outbuf > 0)
                 hvc_push(hp);
 
-        while (count > 0 && (rsize = N_OUTBUF - hp->n_outbuf) > 0) {
+        while (count > 0 && (rsize = hp->outbuf_size - hp->n_outbuf) > 0) {
                 if (rsize > count)
                         rsize = count;
                 memcpy(hp->outbuf + hp->n_outbuf, buf, rsize);
@@ -538,7 +537,7 @@ static int hvc_write_room(struct tty_struct *tty)
         if (!hp)
                 return -1;
 
-        return N_OUTBUF - hp->n_outbuf;
+        return hp->outbuf_size - hp->n_outbuf;
 }
 
 static int hvc_chars_in_buffer(struct tty_struct *tty)
@@ -729,12 +728,13 @@ static struct kobj_type hvc_kobj_type = {
 };
 
 struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int irq,
-                                        struct hv_ops *ops)
+                                        struct hv_ops *ops, int outbuf_size)
 {
         struct hvc_struct *hp;
         int i;
 
-        hp = kmalloc(sizeof(*hp), GFP_KERNEL);
+        hp = kmalloc(ALIGN(sizeof(*hp), sizeof(long)) + outbuf_size,
+                        GFP_KERNEL);
         if (!hp)
                 return ERR_PTR(-ENOMEM);
 
@@ -743,6 +743,8 @@ struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int irq,
         hp->vtermno = vtermno;
         hp->irq = irq;
         hp->ops = ops;
+        hp->outbuf_size = outbuf_size;
+        hp->outbuf = &((char *)hp)[ALIGN(sizeof(*hp), sizeof(long))];
 
         kobject_init(&hp->kobj);
         hp->kobj.ktype = &hvc_kobj_type;
diff --git a/drivers/char/hvc_console.h b/drivers/char/hvc_console.h
index 96b7401319c1..8c59818050e6 100644
--- a/drivers/char/hvc_console.h
+++ b/drivers/char/hvc_console.h
@@ -56,7 +56,7 @@ extern int hvc_instantiate(uint32_t vtermno, int index, struct hv_ops *ops);
 
 /* register a vterm for hvc tty operation (module_init or hotplug add) */
 extern struct hvc_struct * __devinit hvc_alloc(uint32_t vtermno, int irq,
-                                                 struct hv_ops *ops);
+                                struct hv_ops *ops, int outbuf_size);
 /* remove a vterm from hvc tty operation (modele_exit or hotplug remove) */
 extern int __devexit hvc_remove(struct hvc_struct *hp);
 
diff --git a/drivers/char/hvc_iseries.c b/drivers/char/hvc_iseries.c
new file mode 100644
index 000000000000..4747729459c7
--- /dev/null
+++ b/drivers/char/hvc_iseries.c
@@ -0,0 +1,594 @@
+/*
+ * iSeries vio driver interface to hvc_console.c
+ *
+ * This code is based heavily on hvc_vio.c and viocons.c
+ *
+ * Copyright (C) 2006 Stephen Rothwell, IBM Corporation
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+#include <stdarg.h>
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/console.h>
+
+#include <asm/hvconsole.h>
+#include <asm/vio.h>
+#include <asm/prom.h>
+#include <asm/iseries/vio.h>
+#include <asm/iseries/hv_call.h>
+#include <asm/iseries/hv_lp_config.h>
+#include <asm/iseries/hv_lp_event.h>
+
+#include "hvc_console.h"
+
+#define VTTY_PORTS 10
+
+static DEFINE_SPINLOCK(consolelock);
+static DEFINE_SPINLOCK(consoleloglock);
+
+static const char hvc_driver_name[] = "hvc_console";
+
+#define IN_BUF_SIZE     200
+
+/*
+ * Our port information.
+ */
+static struct port_info {
+        HvLpIndex lp;
+        u64 seq;        /* sequence number of last HV send */
+        u64 ack;        /* last ack from HV */
+        struct hvc_struct *hp;
+        int in_start;
+        int in_end;
+        unsigned char in_buf[IN_BUF_SIZE];
+} port_info[VTTY_PORTS] = {
+        [ 0 ... VTTY_PORTS - 1 ] = {
+                .lp = HvLpIndexInvalid
+        }
+};
+
+#define viochar_is_console(pi)  ((pi) == &port_info[0])
+
+static struct vio_device_id hvc_driver_table[] __devinitdata = {
+        {"serial", "IBM,iSeries-vty"},
+        { "", "" }
+};
+MODULE_DEVICE_TABLE(vio, hvc_driver_table);
+
+static void hvlog(char *fmt, ...)
+{
+        int i;
+        unsigned long flags;
+        va_list args;
+        static char buf[256];
+
+        spin_lock_irqsave(&consoleloglock, flags);
+        va_start(args, fmt);
+        i = vscnprintf(buf, sizeof(buf) - 1, fmt, args);
+        va_end(args);
+        buf[i++] = '\r';
+        HvCall_writeLogBuffer(buf, i);
+        spin_unlock_irqrestore(&consoleloglock, flags);
+}
+
+/*
+ * Initialize the common fields in a charLpEvent
+ */
+static void init_data_event(struct viocharlpevent *viochar, HvLpIndex lp)
+{
+        struct HvLpEvent *hev = &viochar->event;
+
+        memset(viochar, 0, sizeof(struct viocharlpevent));
+
+        hev->flags = HV_LP_EVENT_VALID | HV_LP_EVENT_DEFERRED_ACK |
+                HV_LP_EVENT_INT;
+        hev->xType = HvLpEvent_Type_VirtualIo;
+        hev->xSubtype = viomajorsubtype_chario | viochardata;
+        hev->xSourceLp = HvLpConfig_getLpIndex();
+        hev->xTargetLp = lp;
+        hev->xSizeMinus1 = sizeof(struct viocharlpevent);
+        hev->xSourceInstanceId = viopath_sourceinst(lp);
+        hev->xTargetInstanceId = viopath_targetinst(lp);
+}
+
+static int get_chars(uint32_t vtermno, char *buf, int count)
+{
+        struct port_info *pi;
+        int n = 0;
+        unsigned long flags;
+
+        if (vtermno >= VTTY_PORTS)
+                return -EINVAL;
+        if (count == 0)
+                return 0;
+
+        pi = &port_info[vtermno];
+        spin_lock_irqsave(&consolelock, flags);
+
+        if (pi->in_end == 0)
+                goto done;
+
+        n = pi->in_end - pi->in_start;
+        if (n > count)
+                n = count;
+        memcpy(buf, &pi->in_buf[pi->in_start], n);
+        pi->in_start += n;
+        if (pi->in_start == pi->in_end) {
+                pi->in_start = 0;
+                pi->in_end = 0;
+        }
+done:
+        spin_unlock_irqrestore(&consolelock, flags);
+        return n;
+}
+
+static int put_chars(uint32_t vtermno, const char *buf, int count)
+{
+        struct viocharlpevent *viochar;
+        struct port_info *pi;
+        HvLpEvent_Rc hvrc;
+        unsigned long flags;
+        int sent = 0;
+
+        if (vtermno >= VTTY_PORTS)
+                return -EINVAL;
+
+        pi = &port_info[vtermno];
+
+        spin_lock_irqsave(&consolelock, flags);
+
+        if (viochar_is_console(pi) && !viopath_isactive(pi->lp)) {
+                spin_lock_irqsave(&consoleloglock, flags);
+                HvCall_writeLogBuffer(buf, count);
+                spin_unlock_irqrestore(&consoleloglock, flags);
+                sent = count;
+                goto done;
+        }
+
+        viochar = vio_get_event_buffer(viomajorsubtype_chario);
+        if (viochar == NULL) {
+                hvlog("\n\rviocons: Can't get viochar buffer.");
+                goto done;
+        }
+
+        while ((count > 0) && ((pi->seq - pi->ack) < VIOCHAR_WINDOW)) {
+                int len;
+
+                len = (count > VIOCHAR_MAX_DATA) ? VIOCHAR_MAX_DATA : count;
+
+                if (viochar_is_console(pi)) {
+                        spin_lock_irqsave(&consoleloglock, flags);
+                        HvCall_writeLogBuffer(buf, len);
+                        spin_unlock_irqrestore(&consoleloglock, flags);
+                }
+
+                init_data_event(viochar, pi->lp);
+
+                viochar->len = len;
+                viochar->event.xCorrelationToken = pi->seq++;
+                viochar->event.xSizeMinus1 =
+                        offsetof(struct viocharlpevent, data) + len;
+
+                memcpy(viochar->data, buf, len);
+
+                hvrc = HvCallEvent_signalLpEvent(&viochar->event);
+                if (hvrc)
+                        hvlog("\n\rerror sending event! return code %d\n\r",
+                                (int)hvrc);
+                sent += len;
+                count -= len;
+                buf += len;
+        }
+
+        vio_free_event_buffer(viomajorsubtype_chario, viochar);
+done:
+        spin_unlock_irqrestore(&consolelock, flags);
+        return sent;
+}
+
+static struct hv_ops hvc_get_put_ops = {
+        .get_chars = get_chars,
+        .put_chars = put_chars,
+};
+
+static int __devinit hvc_vio_probe(struct vio_dev *vdev,
+                        const struct vio_device_id *id)
+{
+        struct hvc_struct *hp;
+        struct port_info *pi;
+
+        /* probed with invalid parameters. */
+        if (!vdev || !id)
+                return -EPERM;
+
+        if (vdev->unit_address >= VTTY_PORTS)
+                return -ENODEV;
+
+        pi = &port_info[vdev->unit_address];
+
+        hp = hvc_alloc(vdev->unit_address, vdev->irq, &hvc_get_put_ops,
+                        VIOCHAR_MAX_DATA);
+        if (IS_ERR(hp))
+                return PTR_ERR(hp);
+        pi->hp = hp;
+        dev_set_drvdata(&vdev->dev, pi);
+
+        return 0;
+}
+
+static int __devexit hvc_vio_remove(struct vio_dev *vdev)
+{
+        struct port_info *pi = dev_get_drvdata(&vdev->dev);
+        struct hvc_struct *hp = pi->hp;
+
+        return hvc_remove(hp);
+}
+
+static struct vio_driver hvc_vio_driver = {
+        .id_table       = hvc_driver_table,
+        .probe          = hvc_vio_probe,
+        .remove         = hvc_vio_remove,
+        .driver         = {
+                .name   = hvc_driver_name,
+                .owner  = THIS_MODULE,
+        }
+};
+
+static void hvc_open_event(struct HvLpEvent *event)
+{
+        unsigned long flags;
+        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
+        u8 port = cevent->virtual_device;
+        struct port_info *pi;
+        int reject = 0;
+
+        if (hvlpevent_is_ack(event)) {
+                if (port >= VTTY_PORTS)
+                        return;
+
+                spin_lock_irqsave(&consolelock, flags);
+
+                pi = &port_info[port];
+                if (event->xRc == HvLpEvent_Rc_Good) {
+                        pi->seq = pi->ack = 0;
+                        /*
+                         * This line allows connections from the primary
+                         * partition but once one is connected from the
+                         * primary partition nothing short of a reboot
+                         * of linux will allow access from the hosting
+                         * partition again without a required iSeries fix.
+                         */
+                        pi->lp = event->xTargetLp;
+                }
+
+                spin_unlock_irqrestore(&consolelock, flags);
+                if (event->xRc != HvLpEvent_Rc_Good)
+                        printk(KERN_WARNING
+                               "hvc: handle_open_event: event->xRc == (%d).\n",
+                               event->xRc);
+
+                if (event->xCorrelationToken != 0) {
+                        atomic_t *aptr= (atomic_t *)event->xCorrelationToken;
+                        atomic_set(aptr, 1);
+                } else
+                        printk(KERN_WARNING
+                               "hvc: weird...got open ack without atomic\n");
+                return;
+        }
+
+        /* This had better require an ack, otherwise complain */
+        if (!hvlpevent_need_ack(event)) {
+                printk(KERN_WARNING "hvc: viocharopen without ack bit!\n");
+                return;
+        }
+
+        spin_lock_irqsave(&consolelock, flags);
+
+        /* Make sure this is a good virtual tty */
+        if (port >= VTTY_PORTS) {
+                event->xRc = HvLpEvent_Rc_SubtypeError;
+                cevent->subtype_result_code = viorc_openRejected;
+                /*
+                 * Flag state here since we can't printk while holding
+                 * the consolelock spinlock.
+                 */
+                reject = 1;
+        } else {
+                pi = &port_info[port];
+                if ((pi->lp != HvLpIndexInvalid) &&
+                                (pi->lp != event->xSourceLp)) {
+                        /*
+                         * If this is tty is already connected to a different
+                         * partition, fail.
+                         */
+                        event->xRc = HvLpEvent_Rc_SubtypeError;
+                        cevent->subtype_result_code = viorc_openRejected;
+                        reject = 2;
+                } else {
+                        pi->lp = event->xSourceLp;
+                        event->xRc = HvLpEvent_Rc_Good;
+                        cevent->subtype_result_code = viorc_good;
+                        pi->seq = pi->ack = 0;
+                }
+        }
+
+        spin_unlock_irqrestore(&consolelock, flags);
+
+        if (reject == 1)
+                printk(KERN_WARNING "hvc: open rejected: bad virtual tty.\n");
+        else if (reject == 2)
+                printk(KERN_WARNING "hvc: open rejected: console in exclusive "
+                                "use by another partition.\n");
+
+        /* Return the acknowledgement */
+        HvCallEvent_ackLpEvent(event);
+}
+
+/*
+ * Handle a close charLpEvent.  This should ONLY be an Interrupt because the
+ * virtual console should never actually issue a close event to the hypervisor
+ * because the virtual console never goes away.  A close event coming from the
+ * hypervisor simply means that there are no client consoles connected to the
+ * virtual console.
+ */
+static void hvc_close_event(struct HvLpEvent *event)
+{
+        unsigned long flags;
+        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
+        u8 port = cevent->virtual_device;
+
+        if (!hvlpevent_is_int(event)) {
+                printk(KERN_WARNING
+                        "hvc: got unexpected close acknowlegement\n");
+                return;
+        }
+
+        if (port >= VTTY_PORTS) {
+                printk(KERN_WARNING
+                        "hvc: close message from invalid virtual device.\n");
+                return;
+        }
+
+        /* For closes, just mark the console partition invalid */
+        spin_lock_irqsave(&consolelock, flags);
+
+        if (port_info[port].lp == event->xSourceLp)
+                port_info[port].lp = HvLpIndexInvalid;
+
+        spin_unlock_irqrestore(&consolelock, flags);
+}
+
+static void hvc_data_event(struct HvLpEvent *event)
+{
+        unsigned long flags;
+        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
+        struct port_info *pi;
+        int n;
+        u8 port = cevent->virtual_device;
+
+        if (port >= VTTY_PORTS) {
+                printk(KERN_WARNING "hvc: data on invalid virtual device %d\n",
+                                port);
+                return;
+        }
+        if (cevent->len == 0)
+                return;
+
+        /*
+         * Change 05/01/2003 - Ryan Arnold: If a partition other than
+         * the current exclusive partition tries to send us data
+         * events then just drop them on the floor because we don't
+         * want his stinking data.  He isn't authorized to receive
+         * data because he wasn't the first one to get the console,
+         * therefore he shouldn't be allowed to send data either.
+         * This will work without an iSeries fix.
+         */
+        pi = &port_info[port];
+        if (pi->lp != event->xSourceLp)
+                return;
+
+        spin_lock_irqsave(&consolelock, flags);
+
+        n = IN_BUF_SIZE - pi->in_end;
+        if (n > cevent->len)
+                n = cevent->len;
+        if (n > 0) {
+                memcpy(&pi->in_buf[pi->in_end], cevent->data, n);
+                pi->in_end += n;
+        }
+        spin_unlock_irqrestore(&consolelock, flags);
+        if (n == 0)
+                printk(KERN_WARNING "hvc: input buffer overflow\n");
+}
+
+static void hvc_ack_event(struct HvLpEvent *event)
+{
+        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
+        unsigned long flags;
+        u8 port = cevent->virtual_device;
+
+        if (port >= VTTY_PORTS) {
+                printk(KERN_WARNING "hvc: data on invalid virtual device\n");
+                return;
+        }
+
+        spin_lock_irqsave(&consolelock, flags);
+        port_info[port].ack = event->xCorrelationToken;
+        spin_unlock_irqrestore(&consolelock, flags);
+}
+
+static void hvc_config_event(struct HvLpEvent *event)
+{
+        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
+
+        if (cevent->data[0] == 0x01)
+                printk(KERN_INFO "hvc: window resized to %d: %d: %d: %d\n",
+                       cevent->data[1], cevent->data[2],
+                       cevent->data[3], cevent->data[4]);
+        else
+                printk(KERN_WARNING "hvc: unknown config event\n");
+}
+
+static void hvc_handle_event(struct HvLpEvent *event)
+{
+        int charminor;
+
+        if (event == NULL)
+                return;
+
+        charminor = event->xSubtype & VIOMINOR_SUBTYPE_MASK;
+        switch (charminor) {
+        case viocharopen:
+                hvc_open_event(event);
+                break;
+        case viocharclose:
+                hvc_close_event(event);
+                break;
+        case viochardata:
+                hvc_data_event(event);
+                break;
+        case viocharack:
+                hvc_ack_event(event);
+                break;
+        case viocharconfig:
+                hvc_config_event(event);
+                break;
+        default:
+                if (hvlpevent_is_int(event) && hvlpevent_need_ack(event)) {
+                        event->xRc = HvLpEvent_Rc_InvalidSubtype;
+                        HvCallEvent_ackLpEvent(event);
+                }
+        }
+}
+
+static int send_open(HvLpIndex remoteLp, void *sem)
+{
+        return HvCallEvent_signalLpEventFast(remoteLp,
+                        HvLpEvent_Type_VirtualIo,
+                        viomajorsubtype_chario | viocharopen,
+                        HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
+                        viopath_sourceinst(remoteLp),
+                        viopath_targetinst(remoteLp),
+                        (u64)(unsigned long)sem, VIOVERSION << 16,
+                        0, 0, 0, 0);
+}
+
+static int hvc_vio_init(void)
+{
+        atomic_t wait_flag;
+        int rc;
+
+        /* +2 for fudge */
+        rc = viopath_open(HvLpConfig_getPrimaryLpIndex(),
+                        viomajorsubtype_chario, VIOCHAR_WINDOW + 2);
+        if (rc)
+                printk(KERN_WARNING "hvc: error opening to primary %d\n", rc);
+
+        if (viopath_hostLp == HvLpIndexInvalid)
+                vio_set_hostlp();
+
+        /*
+         * And if the primary is not the same as the hosting LP, open to the
+         * hosting lp
+         */
+        if ((viopath_hostLp != HvLpIndexInvalid) &&
+            (viopath_hostLp != HvLpConfig_getPrimaryLpIndex())) {
+                printk(KERN_INFO "hvc: open path to hosting (%d)\n",
+                                viopath_hostLp);
+                rc = viopath_open(viopath_hostLp, viomajorsubtype_chario,
+                                VIOCHAR_WINDOW + 2);    /* +2 for fudge */
+                if (rc)
+                        printk(KERN_WARNING
+                                "error opening to partition %d: %d\n",
+                                viopath_hostLp, rc);
+        }
+
+        if (vio_setHandler(viomajorsubtype_chario, hvc_handle_event) < 0)
+                printk(KERN_WARNING
+                        "hvc: error seting handler for console events!\n");
+
+        /*
+         * First, try to open the console to the hosting lp.
+         * Wait on a semaphore for the response.
+         */
+        atomic_set(&wait_flag, 0);
+        if ((viopath_isactive(viopath_hostLp)) &&
+            (send_open(viopath_hostLp, &wait_flag) == 0)) {
+                printk(KERN_INFO "hvc: hosting partition %d\n", viopath_hostLp);
+                while (atomic_read(&wait_flag) == 0)
+                        mb();
+                atomic_set(&wait_flag, 0);
+        }
+
+        /*
+         * If we don't have an active console, try the primary
+         */
+        if ((!viopath_isactive(port_info[0].lp)) &&
+            (viopath_isactive(HvLpConfig_getPrimaryLpIndex())) &&
+            (send_open(HvLpConfig_getPrimaryLpIndex(), &wait_flag) == 0)) {
+                printk(KERN_INFO "hvc: opening console to primary partition\n");
+                while (atomic_read(&wait_flag) == 0)
+                        mb();
+        }
+
+        /* Register as a vio device to receive callbacks */
+        rc = vio_register_driver(&hvc_vio_driver);
+
+        return rc;
+}
+module_init(hvc_vio_init); /* after drivers/char/hvc_console.c */
+
+static void hvc_vio_exit(void)
+{
+        vio_unregister_driver(&hvc_vio_driver);
+}
+module_exit(hvc_vio_exit);
+
+/* the device tree order defines our numbering */
+static int hvc_find_vtys(void)
+{
+        struct device_node *vty;
+        int num_found = 0;
+
+        for (vty = of_find_node_by_name(NULL, "vty"); vty != NULL;
+                        vty = of_find_node_by_name(vty, "vty")) {
+                uint32_t *vtermno;
+
+                /* We have statically defined space for only a certain number
+                 * of console adapters.
+                 */
+                if ((num_found >= MAX_NR_HVC_CONSOLES) ||
+                                (num_found >= VTTY_PORTS))
+                        break;
+
+                vtermno = (uint32_t *)get_property(vty, "reg", NULL);
+                if (!vtermno)
+                        continue;
+
+                if (!device_is_compatible(vty, "IBM,iSeries-vty"))
+                        continue;
+
+                if (num_found == 0)
+                        add_preferred_console("hvc", 0, NULL);
+                hvc_instantiate(*vtermno, num_found, &hvc_get_put_ops);
+                ++num_found;
+        }
+
+        return num_found;
+}
+console_initcall(hvc_find_vtys);
diff --git a/drivers/char/hvc_rtas.c b/drivers/char/hvc_rtas.c
index 57106e02fd2e..4b97eaf18602 100644
--- a/drivers/char/hvc_rtas.c
+++ b/drivers/char/hvc_rtas.c
@@ -94,7 +94,7 @@ static int hvc_rtas_init(void)
 
         /* Allocate an hvc_struct for the console device we instantiated
          * earlier.  Save off hp so that we can return it on exit */
-        hp = hvc_alloc(hvc_rtas_cookie, NO_IRQ, &hvc_rtas_get_put_ops);
+        hp = hvc_alloc(hvc_rtas_cookie, NO_IRQ, &hvc_rtas_get_put_ops, 16);
         if (IS_ERR(hp))
                 return PTR_ERR(hp);
 
diff --git a/drivers/char/hvc_vio.c b/drivers/char/hvc_vio.c
index 9add81ceb440..cc95941148fb 100644
--- a/drivers/char/hvc_vio.c
+++ b/drivers/char/hvc_vio.c
@@ -90,7 +90,8 @@ static int __devinit hvc_vio_probe(struct vio_dev *vdev,
         if (!vdev || !id)
                 return -EPERM;
 
-        hp = hvc_alloc(vdev->unit_address, vdev->irq, &hvc_get_put_ops);
+        hp = hvc_alloc(vdev->unit_address, vdev->irq, &hvc_get_put_ops,
+                        MAX_VIO_PUT_CHARS);
         if (IS_ERR(hp))
                 return PTR_ERR(hp);
         dev_set_drvdata(&vdev->dev, hp);
@@ -140,7 +141,7 @@ static int hvc_find_vtys(void)
 
         for (vty = of_find_node_by_name(NULL, "vty"); vty != NULL;
                         vty = of_find_node_by_name(vty, "vty")) {
-                uint32_t *vtermno;
+                const uint32_t *vtermno;
 
                 /* We have statically defined space for only a certain number
                  * of console adapters.
@@ -148,7 +149,7 @@ static int hvc_find_vtys(void)
                 if (num_found >= MAX_NR_HVC_CONSOLES)
                         break;
 
-                vtermno = (uint32_t *)get_property(vty, "reg", NULL);
+                vtermno = get_property(vty, "reg", NULL);
                 if (!vtermno)
                         continue;
 
diff --git a/drivers/char/hvsi.c b/drivers/char/hvsi.c
index 017f755632a3..a89a95fb5e40 100644
--- a/drivers/char/hvsi.c
+++ b/drivers/char/hvsi.c
@@ -1274,11 +1274,10 @@ static int __init hvsi_console_init(void)
                         vty != NULL;
                         vty = of_find_compatible_node(vty, "serial", "hvterm-protocol")) {
                 struct hvsi_struct *hp;
-                uint32_t *vtermno;
-                uint32_t *irq;
+                const uint32_t *vtermno, *irq;
 
-                vtermno = (uint32_t *)get_property(vty, "reg", NULL);
-                irq = (uint32_t *)get_property(vty, "interrupts", NULL);
+                vtermno = get_property(vty, "reg", NULL);
+                irq = get_property(vty, "interrupts", NULL);
                 if (!vtermno || !irq)
                         continue;
 
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index 84dfc4278139..8c09997cc3d6 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -3488,7 +3488,7 @@ static int stli_initecp(stlibrd_t *brdp)
  */
         EBRDENABLE(brdp);
         sigsp = (cdkecpsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
-        memcpy(&sig, sigsp, sizeof(cdkecpsig_t));
+        memcpy_fromio(&sig, sigsp, sizeof(cdkecpsig_t));
         EBRDDISABLE(brdp);
 
         if (sig.magic != cpu_to_le32(ECP_MAGIC))
diff --git a/drivers/char/tpm/tpm_atmel.h b/drivers/char/tpm/tpm_atmel.h
index 2e68eeb8a2cd..aefd683c60b7 100644
--- a/drivers/char/tpm/tpm_atmel.h
+++ b/drivers/char/tpm/tpm_atmel.h
@@ -37,7 +37,7 @@ static void __iomem * atmel_get_base_addr(unsigned long *base, int *region_size)
 {
         struct device_node *dn;
         unsigned long address, size;
-        unsigned int *reg;
+        const unsigned int *reg;
         int reglen;
         int naddrc;
         int nsizec;
@@ -52,7 +52,7 @@ static void __iomem * atmel_get_base_addr(unsigned long *base, int *region_size)
                 return NULL;
         }
 
-        reg = (unsigned int *) get_property(dn, "reg", &reglen);
+        reg = get_property(dn, "reg", &reglen);
         naddrc = prom_n_addr_cells(dn);
         nsizec = prom_n_size_cells(dn);
 
diff --git a/drivers/char/viocons.c b/drivers/char/viocons.c
index 766f7864c6c6..f3efeaf2826e 100644
--- a/drivers/char/viocons.c
+++ b/drivers/char/viocons.c
@@ -43,7 +43,6 @@
 #include <linux/sysrq.h>
 
 #include <asm/iseries/vio.h>
-
 #include <asm/iseries/hv_lp_event.h>
 #include <asm/iseries/hv_call_event.h>
 #include <asm/iseries/hv_lp_config.h>
@@ -67,35 +66,6 @@ static int vio_sysrq_pressed;
 extern int sysrq_enabled;
 #endif
 
-/*
- * The structure of the events that flow between us and OS/400.  You can't
- * mess with this unless the OS/400 side changes too
- */
-struct viocharlpevent {
-        struct HvLpEvent event;
-        u32 reserved;
-        u16 version;
-        u16 subtype_result_code;
-        u8 virtual_device;
-        u8 len;
-        u8 data[VIOCHAR_MAX_DATA];
-};
-
-#define VIOCHAR_WINDOW          10
-#define VIOCHAR_HIGHWATERMARK   3
-
-enum viocharsubtype {
-        viocharopen = 0x0001,
-        viocharclose = 0x0002,
-        viochardata = 0x0003,
-        viocharack = 0x0004,
-        viocharconfig = 0x0005
-};
-
-enum viochar_rc {
-        viochar_rc_ebusy = 1
-};
-
 #define VIOCHAR_NUM_BUF         16
 
 /*
@@ -1183,6 +1153,7 @@ static int __init viocons_init(void)
                 port_info[i].magic = VIOTTY_MAGIC;
         }
         HvCall_setLogBufferFormatAndCodepage(HvCall_LogBuffer_ASCII, 437);
+        add_preferred_console("viocons", 0, NULL);
         register_console(&viocons_early);
         return 0;
 }
diff --git a/drivers/char/viotape.c b/drivers/char/viotape.c
index b72b2049aaae..73c78bf75d7f 100644
--- a/drivers/char/viotape.c
+++ b/drivers/char/viotape.c
@@ -940,7 +940,6 @@ static void vioHandleTapeEvent(struct HvLpEvent *event)
 
 static int viotape_probe(struct vio_dev *vdev, const struct vio_device_id *id)
 {
-        char tapename[32];
         int i = vdev->unit_address;
         int j;
 
@@ -956,10 +955,9 @@ static int viotape_probe(struct vio_dev *vdev, const struct vio_device_id *id)
                         "iseries!vt%d", i);
         class_device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i | 0x80),
                         NULL, "iseries!nvt%d", i);
-        sprintf(tapename, "iseries/vt%d", i);
-        printk(VIOTAPE_KERN_INFO "tape %s is iSeries "
+        printk(VIOTAPE_KERN_INFO "tape iseries/vt%d is iSeries "
                         "resource %10.10s type %4.4s, model %3.3s\n",
-                        tapename, viotape_unitinfo[i].rsrcname,
+                        i, viotape_unitinfo[i].rsrcname,
                         viotape_unitinfo[i].type, viotape_unitinfo[i].model);
         return 0;
 }