17 files changed, 147 insertions, 48 deletions

diff --git a/drivers/acpi/resources/rsxface.c b/drivers/acpi/resources/rsxface.c
index f63813a358c5..4c3fd4cdaf73 100644
--- a/drivers/acpi/resources/rsxface.c
+++ b/drivers/acpi/resources/rsxface.c
@@ -474,8 +474,6 @@ acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context)
         return (AE_CTRL_TERMINATE);
 }
 
-ACPI_EXPORT_SYMBOL(acpi_rs_match_vendor_resource)
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_walk_resources
diff --git a/drivers/char/hvc_lguest.c b/drivers/char/hvc_lguest.c
index feeccbaec438..3d6bd0baa56d 100644
--- a/drivers/char/hvc_lguest.c
+++ b/drivers/char/hvc_lguest.c
@@ -35,6 +35,7 @@
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/lguest_bus.h>
+#include <asm/paravirt.h>
 #include "hvc_console.h"
 
 /*D:340 This is our single console input buffer, with associated "struct
diff --git a/drivers/char/pcmcia/cm4000_cs.c b/drivers/char/pcmcia/cm4000_cs.c
index fee58e03dbe2..4177f6db83e9 100644
--- a/drivers/char/pcmcia/cm4000_cs.c
+++ b/drivers/char/pcmcia/cm4000_cs.c
@@ -1629,7 +1629,7 @@ static int cmm_open(struct inode *inode, struct file *filp)
 {
         struct cm4000_dev *dev;
         struct pcmcia_device *link;
-        int rc, minor = iminor(inode);
+        int minor = iminor(inode);
 
         if (minor >= CM4000_MAX_DEV)
                 return -ENODEV;
@@ -1668,7 +1668,6 @@ static int cmm_open(struct inode *inode, struct file *filp)
         start_monitor(dev);
 
         link->open = 1;         /* only one open per device */
-        rc = 0;
 
         DEBUGP(2, dev, "<- cmm_open\n");
         return nonseekable_open(inode, filp);
@@ -1824,7 +1823,7 @@ static int cm4000_resume(struct pcmcia_device *link)
 
 static void cm4000_release(struct pcmcia_device *link)
 {
-        cmm_cm4000_release(link->priv); /* delay release until device closed */
+        cmm_cm4000_release(link);       /* delay release until device closed */
         pcmcia_disable_device(link);
 }
 
diff --git a/drivers/char/pcmcia/cm4040_cs.c b/drivers/char/pcmcia/cm4040_cs.c
index af88181a17f4..b24a3e7bbb9f 100644
--- a/drivers/char/pcmcia/cm4040_cs.c
+++ b/drivers/char/pcmcia/cm4040_cs.c
@@ -599,7 +599,7 @@ cs_release:
 
 static void reader_release(struct pcmcia_device *link)
 {
-        cm4040_reader_release(link->priv);
+        cm4040_reader_release(link);
         pcmcia_disable_device(link);
 }
 
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index de37ebc3a4cf..51ea93cab6c4 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -369,25 +369,54 @@ static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
 }
 
 /**
- *      tty_buffer_flush                -       flush full tty buffers
+ *      __tty_buffer_flush              -       flush full tty buffers
  *      @tty: tty to flush
  *
- *      flush all the buffers containing receive data
+ *      flush all the buffers containing receive data. Caller must
+ *      hold the buffer lock and must have ensured no parallel flush to
+ *      ldisc is running.
  *
- *      Locking: none
+ *      Locking: Caller must hold tty->buf.lock
  */
 
-static void tty_buffer_flush(struct tty_struct *tty)
+static void __tty_buffer_flush(struct tty_struct *tty)
 {
         struct tty_buffer *thead;
-        unsigned long flags;
 
-        spin_lock_irqsave(&tty->buf.lock, flags);
         while((thead = tty->buf.head) != NULL) {
                 tty->buf.head = thead->next;
                 tty_buffer_free(tty, thead);
         }
         tty->buf.tail = NULL;
+}
+
+/**
+ *      tty_buffer_flush                -       flush full tty buffers
+ *      @tty: tty to flush
+ *
+ *      flush all the buffers containing receive data. If the buffer is
+ *      being processed by flush_to_ldisc then we defer the processing
+ *      to that function
+ *
+ *      Locking: none
+ */
+
+static void tty_buffer_flush(struct tty_struct *tty)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&tty->buf.lock, flags);
+
+        /* If the data is being pushed to the tty layer then we can't
+           process it here. Instead set a flag and the flush_to_ldisc
+           path will process the flush request before it exits */
+        if (test_bit(TTY_FLUSHING, &tty->flags)) {
+                set_bit(TTY_FLUSHPENDING, &tty->flags);
+                spin_unlock_irqrestore(&tty->buf.lock, flags);
+                wait_event(tty->read_wait,
+                                test_bit(TTY_FLUSHPENDING, &tty->flags) == 0);
+                return;
+        } else
+                __tty_buffer_flush(tty);
         spin_unlock_irqrestore(&tty->buf.lock, flags);
 }
 
@@ -3594,6 +3623,7 @@ static void flush_to_ldisc(struct work_struct *work)
                 return;
 
         spin_lock_irqsave(&tty->buf.lock, flags);
+        set_bit(TTY_FLUSHING, &tty->flags);     /* So we know a flush is running */
         head = tty->buf.head;
         if (head != NULL) {
                 tty->buf.head = NULL;
@@ -3607,6 +3637,11 @@ static void flush_to_ldisc(struct work_struct *work)
                                 tty_buffer_free(tty, tbuf);
                                 continue;
                         }
+                        /* Ldisc or user is trying to flush the buffers
+                           we are feeding to the ldisc, stop feeding the
+                           line discipline as we want to empty the queue */
+                        if (test_bit(TTY_FLUSHPENDING, &tty->flags))
+                                break;
                         if (!tty->receive_room) {
                                 schedule_delayed_work(&tty->buf.work, 1);
                                 break;
@@ -3620,8 +3655,17 @@ static void flush_to_ldisc(struct work_struct *work)
                         disc->receive_buf(tty, char_buf, flag_buf, count);
                         spin_lock_irqsave(&tty->buf.lock, flags);
                 }
+                /* Restore the queue head */
                 tty->buf.head = head;
         }
+        /* We may have a deferred request to flush the input buffer,
+           if so pull the chain under the lock and empty the queue */
+        if (test_bit(TTY_FLUSHPENDING, &tty->flags)) {
+                __tty_buffer_flush(tty);
+                clear_bit(TTY_FLUSHPENDING, &tty->flags);
+                wake_up(&tty->read_wait);
+        }
+        clear_bit(TTY_FLUSHING, &tty->flags);
         spin_unlock_irqrestore(&tty->buf.lock, flags);
 
         tty_ldisc_deref(disc);
diff --git a/drivers/lguest/lguest.c b/drivers/lguest/lguest.c
index 524beea7fb19..6e135ac0834f 100644
--- a/drivers/lguest/lguest.c
+++ b/drivers/lguest/lguest.c
@@ -936,23 +936,24 @@ static const struct lguest_insns
 /* Now our patch routine is fairly simple (based on the native one in
  * paravirt.c).  If we have a replacement, we copy it in and return how much of
  * the available space we used. */
-static unsigned lguest_patch(u8 type, u16 clobber, void *insns, unsigned len)
+static unsigned lguest_patch(u8 type, u16 clobber, void *ibuf,
+                             unsigned long addr, unsigned len)
 {
         unsigned int insn_len;
 
         /* Don't do anything special if we don't have a replacement */
         if (type >= ARRAY_SIZE(lguest_insns) || !lguest_insns[type].start)
-                return paravirt_patch_default(type, clobber, insns, len);
+                return paravirt_patch_default(type, clobber, ibuf, addr, len);
 
         insn_len = lguest_insns[type].end - lguest_insns[type].start;
 
         /* Similarly if we can't fit replacement (shouldn't happen, but let's
          * be thorough). */
         if (len < insn_len)
-                return paravirt_patch_default(type, clobber, insns, len);
+                return paravirt_patch_default(type, clobber, ibuf, addr, len);
 
         /* Copy in our instructions. */
-        memcpy(insns, lguest_insns[type].start, insn_len);
+        memcpy(ibuf, lguest_insns[type].start, insn_len);
         return insn_len;
 }
 
diff --git a/drivers/lguest/lguest_bus.c b/drivers/lguest/lguest_bus.c
index 55a7940ca732..9e7752cc8002 100644
--- a/drivers/lguest/lguest_bus.c
+++ b/drivers/lguest/lguest_bus.c
@@ -5,6 +5,7 @@
 #include <linux/bootmem.h>
 #include <linux/lguest_bus.h>
 #include <asm/io.h>
+#include <asm/paravirt.h>
 
 static ssize_t type_show(struct device *_dev,
                          struct device_attribute *attr, char *buf)
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index 8c86b802f212..d091b2430b48 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -7,6 +7,7 @@
 
 #include <linux/device.h>
 #include <linux/fs.h>
+#include <linux/mm.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
diff --git a/drivers/spi/spi_mpc83xx.c b/drivers/spi/spi_mpc83xx.c
index 0c16a2b39b41..2adf856e44c2 100644
--- a/drivers/spi/spi_mpc83xx.c
+++ b/drivers/spi/spi_mpc83xx.c
@@ -86,7 +86,7 @@ struct mpc83xx_spi {
 
         unsigned nsecs;         /* (clock cycle time)/2 */
 
-        u32 sysclk;
+        u32 spibrg;             /* SPIBRG input clock */
         u32 rx_shift;           /* RX data reg shift when in qe mode */
         u32 tx_shift;           /* TX data reg shift when in qe mode */
 
@@ -148,6 +148,8 @@ static void mpc83xx_spi_chipselect(struct spi_device *spi, int value)
         if (value == BITBANG_CS_ACTIVE) {
                 u32 regval = mpc83xx_spi_read_reg(&mpc83xx_spi->base->mode);
                 u32 len = spi->bits_per_word;
+                u8 pm;
+
                 if (len == 32)
                         len = 0;
                 else
@@ -169,17 +171,20 @@ static void mpc83xx_spi_chipselect(struct spi_device *spi, int value)
 
                 regval |= SPMODE_LEN(len);
 
-                if ((mpc83xx_spi->sysclk / spi->max_speed_hz) >= 64) {
-                        u8 pm = mpc83xx_spi->sysclk / (spi->max_speed_hz * 64);
+                if ((mpc83xx_spi->spibrg / spi->max_speed_hz) >= 64) {
+                        pm = mpc83xx_spi->spibrg / (spi->max_speed_hz * 64) - 1;
                         if (pm > 0x0f) {
-                                printk(KERN_WARNING "MPC83xx SPI: SPICLK can't be less then a SYSCLK/1024!\n"
-                                                "Requested SPICLK is %d Hz. Will use %d Hz instead.\n",
-                                                spi->max_speed_hz, mpc83xx_spi->sysclk / 1024);
+                                dev_err(&spi->dev, "Requested speed is too "
+                                        "low: %d Hz. Will use %d Hz instead.\n",
+                                        spi->max_speed_hz,
+                                        mpc83xx_spi->spibrg / 1024);
                                 pm = 0x0f;
                         }
                         regval |= SPMODE_PM(pm) | SPMODE_DIV16;
                 } else {
-                        u8 pm = mpc83xx_spi->sysclk / (spi->max_speed_hz * 4);
+                        pm = mpc83xx_spi->spibrg / (spi->max_speed_hz * 4);
+                        if (pm)
+                                pm--;
                         regval |= SPMODE_PM(pm);
                 }
 
@@ -429,13 +434,17 @@ static int __init mpc83xx_spi_probe(struct platform_device *dev)
         mpc83xx_spi->bitbang.chipselect = mpc83xx_spi_chipselect;
         mpc83xx_spi->bitbang.setup_transfer = mpc83xx_spi_setup_transfer;
         mpc83xx_spi->bitbang.txrx_bufs = mpc83xx_spi_bufs;
-        mpc83xx_spi->sysclk = pdata->sysclk;
         mpc83xx_spi->activate_cs = pdata->activate_cs;
         mpc83xx_spi->deactivate_cs = pdata->deactivate_cs;
         mpc83xx_spi->qe_mode = pdata->qe_mode;
         mpc83xx_spi->get_rx = mpc83xx_spi_rx_buf_u8;
         mpc83xx_spi->get_tx = mpc83xx_spi_tx_buf_u8;
 
+        if (mpc83xx_spi->qe_mode)
+                mpc83xx_spi->spibrg = pdata->sysclk / 2;
+        else
+                mpc83xx_spi->spibrg = pdata->sysclk;
+
         mpc83xx_spi->rx_shift = 0;
         mpc83xx_spi->tx_shift = 0;
         if (mpc83xx_spi->qe_mode) {
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
index 630f781aeb19..c55459c592b8 100644
--- a/drivers/spi/spidev.c
+++ b/drivers/spi/spidev.c
@@ -183,7 +183,9 @@ static int spidev_message(struct spidev_data *spidev,
 
                 if (u_tmp->rx_buf) {
                         k_tmp->rx_buf = buf;
-                        if (!access_ok(VERIFY_WRITE, u_tmp->rx_buf, u_tmp->len))
+                        if (!access_ok(VERIFY_WRITE, (u8 __user *)
+                                                (ptrdiff_t) u_tmp->rx_buf,
+                                                u_tmp->len))
                                 goto done;
                 }
                 if (u_tmp->tx_buf) {
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index decfdc8eb9cc..e58c87b3e3a0 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -127,8 +127,20 @@ static int last_fb_vc = MAX_NR_CONSOLES - 1;
 static int fbcon_is_default = 1; 
 static int fbcon_has_exited;
 static int primary_device = -1;
+
+#ifdef CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY
 static int map_override;
 
+static inline void fbcon_map_override(void)
+{
+        map_override = 1;
+}
+#else
+static inline void fbcon_map_override(void)
+{
+}
+#endif /* CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY */
+
 /* font data */
 static char fontname[40];
 
@@ -506,7 +518,7 @@ static int __init fb_console_setup(char *this_opt)
                                                 (options[j++]-'0') % FB_MAX;
                                 }
 
-                                map_override = 1;
+                                fbcon_map_override();
                         }
 
                         return 1;
diff --git a/drivers/video/matrox/g450_pll.c b/drivers/video/matrox/g450_pll.c
index 7c76e079ca7d..d42346e7fdda 100644
--- a/drivers/video/matrox/g450_pll.c
+++ b/drivers/video/matrox/g450_pll.c
@@ -331,16 +331,19 @@ static int __g450_setclk(WPMINFO unsigned int fout, unsigned int pll,
                                         tmp |= M1064_XPIXCLKCTRL_PLL_UP;
                                 }
                                 matroxfb_DAC_out(PMINFO M1064_XPIXCLKCTRL, tmp);
-#ifdef __powerpc__
-                                /* This is necessary to avoid jitter on PowerPC
-                                 * (OpenFirmware) systems, but apparently
-                                 * introduces jitter, at least on a x86-64
-                                 * using DVI.
-                                 * A simple workaround is disable for non-PPC.
-                                 */
-                                matroxfb_DAC_out(PMINFO M1064_XDVICLKCTRL, 0);
-#endif /* __powerpc__ */
-                                matroxfb_DAC_out(PMINFO M1064_XPWRCTRL, xpwrctrl);
+                                /* DVI PLL preferred for frequencies up to
+                                   panel link max, standard PLL otherwise */
+                                if (fout >= MINFO->max_pixel_clock_panellink)
+                                        tmp = 0;
+                                else tmp =
+                                        M1064_XDVICLKCTRL_DVIDATAPATHSEL |
+                                        M1064_XDVICLKCTRL_C1DVICLKSEL |
+                                        M1064_XDVICLKCTRL_C1DVICLKEN |
+                                        M1064_XDVICLKCTRL_DVILOOPCTL |
+                                        M1064_XDVICLKCTRL_P1LOOPBWDTCTL;
+                                matroxfb_DAC_out(PMINFO M1064_XDVICLKCTRL,tmp);
+                                matroxfb_DAC_out(PMINFO M1064_XPWRCTRL,
+                                                 xpwrctrl);
 
                                 matroxfb_DAC_unlock_irqrestore(flags);
                         }
diff --git a/drivers/video/matrox/matroxfb_DAC1064.h b/drivers/video/matrox/matroxfb_DAC1064.h
index df39c3193735..7a98ce8043d7 100644
--- a/drivers/video/matrox/matroxfb_DAC1064.h
+++ b/drivers/video/matrox/matroxfb_DAC1064.h
@@ -33,6 +33,21 @@ void DAC1064_global_restore(WPMINFO2);
 #define     M1064_XCURCTRL_3COLOR       0x01    /* transparent, 0, 1, 2 */
 #define     M1064_XCURCTRL_XGA          0x02    /* 0, 1, transparent, complement */
 #define     M1064_XCURCTRL_XWIN         0x03    /* transparent, transparent, 0, 1 */
+        /* drive DVI by standard(0)/DVI(1) PLL */
+        /* if set(1), C?DVICLKEN and C?DVICLKSEL must be set(1) */
+#define      M1064_XDVICLKCTRL_DVIDATAPATHSEL   0x01
+        /* drive CRTC1 by standard(0)/DVI(1) PLL */
+#define      M1064_XDVICLKCTRL_C1DVICLKSEL      0x02
+        /* drive CRTC2 by standard(0)/DVI(1) PLL */
+#define      M1064_XDVICLKCTRL_C2DVICLKSEL      0x04
+        /* pixel clock allowed to(0)/blocked from(1) driving CRTC1 */
+#define      M1064_XDVICLKCTRL_C1DVICLKEN       0x08
+        /* DVI PLL loop filter bandwidth selection bits */
+#define      M1064_XDVICLKCTRL_DVILOOPCTL       0x30
+        /* CRTC2 pixel clock allowed to(0)/blocked from(1) driving CRTC2 */
+#define      M1064_XDVICLKCTRL_C2DVICLKEN       0x40
+        /* P1PLL loop filter bandwith selection */
+#define      M1064_XDVICLKCTRL_P1LOOPBWDTCTL    0x80
 #define M1064_XCURCOL0RED       0x08
 #define M1064_XCURCOL0GREEN     0x09
 #define M1064_XCURCOL0BLUE      0x0A
diff --git a/drivers/video/matrox/matroxfb_base.h b/drivers/video/matrox/matroxfb_base.h
index d59577c8de86..f3107ad7e545 100644
--- a/drivers/video/matrox/matroxfb_base.h
+++ b/drivers/video/matrox/matroxfb_base.h
@@ -424,6 +424,7 @@ struct matrox_fb_info {
                       } mmio;
 
         unsigned int    max_pixel_clock;
+        unsigned int    max_pixel_clock_panellink;
 
         struct matrox_switch*   hw_switch;
 
diff --git a/drivers/video/matrox/matroxfb_misc.c b/drivers/video/matrox/matroxfb_misc.c
index 5948e54b9ef9..ab7fb50bc1de 100644
--- a/drivers/video/matrox/matroxfb_misc.c
+++ b/drivers/video/matrox/matroxfb_misc.c
@@ -658,6 +658,7 @@ static int parse_pins5(WPMINFO const struct matrox_bios* bd) {
                 MINFO->values.reg.mctlwtst_core = (MINFO->values.reg.mctlwtst & ~7) |
                                                   wtst_xlat[MINFO->values.reg.mctlwtst & 7];
         }
+        MINFO->max_pixel_clock_panellink = bd->pins[47] * 4000;
         return 0;
 }
 
diff --git a/drivers/video/pvr2fb.c b/drivers/video/pvr2fb.c
index f9300266044d..7d6c29800d14 100644
--- a/drivers/video/pvr2fb.c
+++ b/drivers/video/pvr2fb.c
@@ -94,6 +94,7 @@
 #define DISP_DIWCONF (DISP_BASE + 0xe8)
 #define DISP_DIWHSTRT (DISP_BASE + 0xec)
 #define DISP_DIWVSTRT (DISP_BASE + 0xf0)
+#define DISP_PIXDEPTH (DISP_BASE + 0x108)
 
 /* Pixel clocks, one for TV output, doubled for VGA output */
 #define TV_CLK 74239
@@ -143,6 +144,7 @@ static struct pvr2fb_par {
         unsigned char is_lowres;        /* Is horizontal pixel-doubling enabled? */
 
         unsigned long mmio_base;        /* MMIO base */
+        u32 palette[16];
 } *currentpar;
 
 static struct fb_info *fb_info;
@@ -599,6 +601,7 @@ static void pvr2_init_display(struct fb_info *info)
 
         /* bits per pixel */
         fb_writel(fb_readl(DISP_DIWMODE) | (--bytesperpixel << 2), DISP_DIWMODE);
+        fb_writel(bytesperpixel << 2, DISP_PIXDEPTH);
 
         /* video enable, color sync, interlace,
          * hsync and vsync polarity (currently unused) */
@@ -790,7 +793,7 @@ static int __devinit pvr2fb_common_init(void)
         fb_info->fbops          = &pvr2fb_ops;
         fb_info->fix            = pvr2_fix;
         fb_info->par            = currentpar;
-        fb_info->pseudo_palette = (void *)(fb_info->par + 1);
+        fb_info->pseudo_palette = currentpar->palette;
         fb_info->flags          = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN;
 
         if (video_output == VO_VGA)
@@ -807,6 +810,8 @@ static int __devinit pvr2fb_common_init(void)
 
         if (register_framebuffer(fb_info) < 0)
                 goto out_err;
+        /*Must write PIXDEPTH to register before anything is displayed - so force init */
+        pvr2_init_display(fb_info);
 
         modememused = get_line_length(fb_info->var.xres_virtual,
                                       fb_info->var.bits_per_pixel);
@@ -1082,14 +1087,15 @@ static int __init pvr2fb_init(void)
 #endif
         size = sizeof(struct fb_info) + sizeof(struct pvr2fb_par) + 16 * sizeof(u32);
 
-        fb_info = kzalloc(size, GFP_KERNEL);
+        fb_info = framebuffer_alloc(sizeof(struct pvr2fb_par), NULL);
+
         if (!fb_info) {
                 printk(KERN_ERR "Failed to allocate memory for fb_info\n");
                 return -ENOMEM;
         }
 
 
-        currentpar = (struct pvr2fb_par *)(fb_info + 1);
+        currentpar = fb_info->par;
 
         for (i = 0; i < ARRAY_SIZE(board_driver); i++) {
                 struct pvr2_board *pvr_board = board_driver + i;
@@ -1102,7 +1108,7 @@ static int __init pvr2fb_init(void)
                 if (ret != 0) {
                         printk(KERN_ERR "pvr2fb: Failed init of %s device\n",
                                 pvr_board->name);
-                        kfree(fb_info);
+                        framebuffer_release(fb_info);
                         break;
                 }
         }
@@ -1126,7 +1132,7 @@ static void __exit pvr2fb_exit(void)
 #endif
 
         unregister_framebuffer(fb_info);
-        kfree(fb_info);
+        framebuffer_release(fb_info);
 }
 
 module_init(pvr2fb_init);
diff --git a/drivers/video/stifb.c b/drivers/video/stifb.c
index c97709ecbad0..e7c8db2eb49b 100644
--- a/drivers/video/stifb.c
+++ b/drivers/video/stifb.c
@@ -1100,13 +1100,18 @@ stifb_init_fb(struct sti_struct *sti, int bpp_pref)
         /* only supported cards are allowed */
         switch (fb->id) {
         case CRT_ID_VISUALIZE_EG:
-                /* look for a double buffering device like e.g. the 
-                   "INTERNAL_EG_DX1024" in the RDI precisionbook laptop
-                   which won't work. The same device in non-double 
-                   buffering mode returns "INTERNAL_EG_X1024". */
-                if (strstr(sti->outptr.dev_name, "EG_DX")) {
-                   printk(KERN_WARNING 
-                        "stifb: ignoring '%s'. Disable double buffering in IPL menu.\n",
+                /* Visualize cards can run either in "double buffer" or
+                  "standard" mode. Depending on the mode, the card reports
+                  a different device name, e.g. "INTERNAL_EG_DX1024" in double
+                  buffer mode and "INTERNAL_EG_X1024" in standard mode.
+                  Since this driver only supports standard mode, we check
+                  if the device name contains the string "DX" and tell the
+                  user how to reconfigure the card. */
+                if (strstr(sti->outptr.dev_name, "DX")) {
+                   printk(KERN_WARNING "WARNING: stifb framebuffer driver does not "
+                        "support '%s' in double-buffer mode.\n"
+                        KERN_WARNING "WARNING: Please disable the double-buffer mode "
+                        "in IPL menu (the PARISC-BIOS).\n",
                         sti->outptr.dev_name);
                    goto out_err0;
                 }