diff -urN -X dontdiff linux-vanilla/drivers/char/console.c linux/drivers/char/console.c
--- linux-vanilla/drivers/char/console.c	2003-07-04 10:11:31.000000000 +0200
+++ linux/drivers/char/console.c	2005-03-16 19:34:17.000000000 +0100
@@ -110,7 +110,7 @@
 #include "console_macros.h"
 
 
-const struct consw *conswitchp;
+const struct consw *conswitchp = &dummy_con;
 
 /* A bitmap for codes <32. A bit of 1 indicates that the code
  * corresponding to that bit number invokes some special action
@@ -161,7 +161,7 @@
 int console_blanked;
 
 static int vesa_blank_mode; /* 0:none 1:suspendV 2:suspendH 3:powerdown */
-static int blankinterval = 10*60*HZ;
+static int blankinterval = 0;
 static int vesa_off_interval;
 
 static struct tq_struct console_callback_tq = {
diff -urN -X dontdiff linux-vanilla/drivers/video/Config.in linux/drivers/video/Config.in
--- linux-vanilla/drivers/video/Config.in	2003-07-04 10:12:02.000000000 +0200
+++ linux/drivers/video/Config.in	2005-03-06 11:22:01.000000000 +0100
@@ -9,6 +9,7 @@
 
 if [ "$CONFIG_FB" = "y" ]; then
    define_bool CONFIG_DUMMY_CONSOLE y
+   define_bool CONFIG_FB_LCD y
    if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
       if [ "$CONFIG_PCI" = "y" ]; then
          tristate '  nVidia Riva support (EXPERIMENTAL)' CONFIG_FB_RIVA
diff -urN -X dontdiff linux-vanilla/drivers/video/fbcon.c linux/drivers/video/fbcon.c
--- linux-vanilla/drivers/video/fbcon.c	2003-07-04 10:12:03.000000000 +0200
+++ linux/drivers/video/fbcon.c	2005-03-16 19:35:16.000000000 +0100
@@ -572,8 +572,8 @@
     int i, charcnt = 256;
     struct fbcon_font_desc *font;
     
-    if (con != fg_console || (p->fb_info->flags & FBINFO_FLAG_MODULE) ||
-        p->type == FB_TYPE_TEXT)
+    /*    if (con != fg_console || (p->fb_info->flags & FBINFO_FLAG_MODULE) ||
+	  p->type == FB_TYPE_TEXT) */
     	logo = 0;
 
     p->var.xoffset = p->var.yoffset = p->yscroll = 0;  /* reset wrap/pan */
diff -urN -X dontdiff linux-vanilla/drivers/video/fb-lcd.c linux/drivers/video/fb-lcd.c
--- linux-vanilla/drivers/video/fb-lcd.c	1970-01-01 01:00:00.000000000 +0100
+++ linux/drivers/video/fb-lcd.c	2005-03-13 21:26:57.000000000 +0100
@@ -0,0 +1,647 @@
+/*
+ * fb.c - Frame-buffer driver for Nokia 3310 LCD
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/tty.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/ioctl.h>
+#include <linux/proc_fs.h>
+
+#include <asm/io.h>
+#include <asm/uaccess.h>
+
+#include <video/fbcon.h>
+#include <video/fbcon-mfb.h>
+
+#define LCD_WIDTH 84
+#define LCD_HEIGHT 48
+
+/* allow for 1bpp */
+static unsigned char *lcd_scr;
+
+#define SD_DI 0x20
+#define SD_DO 0x10
+#define SD_CLK 0x08
+#define SD_CS 0x80
+
+typedef unsigned int uint32;
+static unsigned char port_state = 0x00;
+static volatile uint32 *gpioaddr_input = (uint32 *)0xb8000060;
+static volatile uint32 *gpioaddr_output = (uint32 *)0xb8000064;
+static volatile uint32 *gpioaddr_enable = (uint32 *)0xb8000068;
+static volatile uint32 *gpioaddr_control = (uint32 *)0xb800006c;
+
+static inline void lcd_spi_cs_low(void)
+{
+  port_state &= ~(SD_CS);
+  *gpioaddr_output = port_state;
+}
+
+static inline void lcd_spi_cs_high(void)
+{
+  port_state |= SD_CS;
+  *gpioaddr_output = port_state;
+}
+
+static inline void lcd_data_mode(void)
+{
+  port_state |= SD_DO;
+  *gpioaddr_output = port_state;
+}
+
+static inline void lcd_command_mode(void)
+{
+  port_state &= ~(SD_DO);
+  *gpioaddr_output = port_state;
+}
+
+static unsigned char lcd_spi_io(unsigned char data_out)
+{
+  int i;
+  unsigned char result = 0, tmp_data = 0;
+  
+  for(i=0; i<8; i++) {
+	  if(data_out & (0x01 << (7-i)))
+		  port_state |= SD_DI;
+	  else
+		  port_state &= ~SD_DI;
+	  
+	  *gpioaddr_output = port_state;
+	  port_state |= SD_CLK;
+	  *gpioaddr_output = port_state;
+	  
+	  tmp_data = *gpioaddr_input;
+	  
+	  port_state &= ~SD_CLK;
+	  *gpioaddr_output = port_state;
+	  
+	  result <<= 1;
+	  
+	  if(tmp_data & SD_DO)
+		  result |= 1;
+  }
+  
+  return(result);
+}
+
+#if 0
+static void lcd_out(int x, int y, const char c)
+{
+	lcd_command_mode();
+
+	lcd_spi_io(x | 0x80);
+	lcd_spi_io(y | 0x40);
+
+	lcd_data_mode();
+
+	lcd_spi_io(c);
+}
+#endif
+
+static void lcd_clear(void)
+{
+	int p, q;
+	port_state &= ~(SD_DI);
+	*gpioaddr_output = port_state;	
+
+	lcd_data_mode();
+
+	lcd_spi_cs_low();
+
+	for(p=0; p<6; p++) {
+		for(q=0; q<84; q++) {
+			lcd_spi_io(0);
+		}
+	}
+}
+
+
+/* initialise the LCD */
+static void
+init_lcd(void)
+{
+	*gpioaddr_enable |= SD_DI | SD_CLK | SD_CS | SD_DO;
+
+	port_state = *gpioaddr_output;
+	port_state &= ~(SD_CLK | SD_DI | SD_CS);
+	*gpioaddr_output = port_state;
+
+	lcd_spi_cs_low();
+	lcd_command_mode();
+
+	lcd_spi_io(0x21);
+	lcd_spi_io(0xc5);
+	lcd_spi_io(0x06);
+	lcd_spi_io(0x13);
+	lcd_spi_io(0x20);
+	lcd_spi_io(0x0c);
+
+	lcd_clear();
+
+	lcd_spi_cs_high();
+}
+
+static void lcd_detect(void)
+{
+
+}
+
+static void lcd_update_display(struct display *p, int sx, int sy, int mx, int my)
+{
+	int x, y, i, bit;
+
+	*gpioaddr_enable |= SD_DI | SD_CLK | SD_CS | SD_DO;
+	port_state = *gpioaddr_output;
+
+	lcd_spi_cs_low();
+
+	unsigned char *scr = lcd_scr;
+
+	lcd_command_mode();
+
+	lcd_spi_io(0x80);
+	lcd_spi_io(0x40);
+
+	lcd_data_mode();
+
+	// For now we just do braindead updating of the entire screen
+	for(y = 0; y<LCD_HEIGHT/8; y++) {
+		for(x = 0; x < (LCD_WIDTH+4)/8; x++) {
+			for(bit = (x == LCD_WIDTH/8) ? 0x8 : 0x80;
+			    bit != 0;
+			    bit >>= 1) {
+				for(i=7; i>=0; i--) {
+					if(scr[x+(LCD_WIDTH+4)*i/8] & bit)
+						port_state |= SD_DI;
+					else
+						port_state &= ~SD_DI;
+					
+					*gpioaddr_output = port_state;
+					
+					*gpioaddr_output = port_state | SD_CLK;
+					*gpioaddr_output = port_state;
+				}
+			}
+		}
+		scr+=(LCD_WIDTH+4);
+	}
+
+	lcd_spi_cs_high();
+}
+
+struct lcdfb_info {
+	struct fb_info_gen gen;
+};
+
+
+struct lcdfb_par {
+	/*
+	 *  The hardware specific data in this structure uniquely defines a video
+	 *  mode.
+	 *
+	 *  If your hardware supports only one video mode, you can leave it empty.
+	 */
+};
+
+
+void lcd_fb_setup(struct display *p)
+{
+	fbcon_mfb.setup(p);
+}
+
+void lcd_fb_bmove(struct display *p, int sy, int sx, int dy, int dx,
+		     int height, int width)
+{
+	fbcon_mfb.bmove(p, sy, sx, dy, dx, height, width);
+	lcd_update_display(p, 0, 0, LCD_WIDTH/8, LCD_HEIGHT/fontheight(p));
+}
+
+void lcd_fb_clear(struct vc_data *conp, struct display *p, int sy, int sx,
+		     int height, int width)
+{
+	fbcon_mfb.clear(conp, p, sy, sx, height, width);
+	lcd_update_display(p, sx, sy, sx+width, sy+height);
+}
+
+void lcd_fb_putc(struct vc_data *conp, struct display *p, int c, int yy,
+		    int xx)
+{
+	fbcon_mfb.putc(conp, p, c, yy, xx);
+	lcd_update_display(p, xx, yy, xx+1, yy+1);
+}
+
+void lcd_fb_putcs(struct vc_data *conp, struct display *p, 
+		     const unsigned short *s, int count, int yy, int xx)
+{
+	fbcon_mfb.putcs(conp, p, s, count, yy, xx);
+	lcd_update_display(p, xx, yy, xx+count, yy+1);
+}
+
+void lcd_fb_revc(struct display *p, int xx, int yy)
+{
+	fbcon_mfb.revc(p, xx, yy);
+	lcd_update_display(p, xx, yy, xx+1, yy+1);
+}
+
+void lcd_fb_clear_margins(struct vc_data *conp, struct display *p,
+			  int bottom_only)
+{
+	fbcon_mfb.clear_margins(conp, p, bottom_only);
+	lcd_update_display(p, 0, 0, LCD_WIDTH, LCD_HEIGHT);
+}
+
+/*
+ *  `switch' for the low level operations
+ */
+
+struct display_switch fbcon_lcd = {
+	setup:		lcd_fb_setup,
+	bmove:		lcd_fb_bmove,
+	clear:		lcd_fb_clear,
+	putc:		lcd_fb_putc,
+	putcs:		lcd_fb_putcs,
+	revc:		lcd_fb_revc,
+	clear_margins:  lcd_fb_clear_margins,
+	fontwidthmask:	FONTWIDTH(8)
+};
+
+static struct lcdfb_info fb_info;
+static struct lcdfb_par current_par;
+static int current_par_valid = 0;
+static struct display disp;
+
+int lcdfb_init(void);
+int lcdfb_setup(char*);
+
+static int lcd_encode_fix(struct fb_fix_screeninfo *fix, struct lcdfb_par *par,
+			  const struct fb_info *info)
+{
+	/*
+	 *  This function should fill in the 'fix' structure based on the values
+	 *  in the `par' structure.
+	 */
+
+
+	memset(fix, 0x0, sizeof(*fix));
+
+	strcpy(fix->id, "lcd");
+	/* required for mmap() */
+	fix->smem_start = lcd_scr;
+	fix->smem_len = LCD_HEIGHT * (LCD_WIDTH+4)/8;
+
+	fix->type= FB_TYPE_PACKED_PIXELS;
+
+	fix->visual = FB_VISUAL_MONO10;	/* fixed visual */
+	fix->line_length = (LCD_WIDTH+4) / 8;
+
+	fix->xpanstep = 0;	/* no hardware panning */
+	fix->ypanstep = 0;	/* no hardware panning */
+	fix->ywrapstep = 0;	/* */
+
+	fix->accel = FB_ACCEL_NONE;
+
+	return 0;
+}
+
+static int lcd_decode_var(struct fb_var_screeninfo *var, struct lcdfb_par *par,
+			  const struct fb_info *info)
+{
+	/*
+	 *  Get the video params out of 'var'. If a value doesn't fit, round it up,
+	 *  if it's too big, return -EINVAL.
+	 *
+	 *  Suggestion: Round up in the following order: bits_per_pixel, xres,
+	 *  yres, xres_virtual, yres_virtual, xoffset, yoffset, grayscale,
+	 *  bitfields, horizontal timing, vertical timing.
+	 */
+
+
+	if ( var->xres > LCD_WIDTH ||
+		var->yres > LCD_HEIGHT ||
+		var->xres_virtual != var->xres ||
+		var->yres_virtual != var->yres ||
+		var->xoffset != 0 ||
+		var->yoffset != 0 ) {
+		return -EINVAL;
+	}
+
+	if ( var->bits_per_pixel != 1 ) {
+		return -EINVAL;
+	}
+
+
+	return 0;
+}
+
+static int lcd_encode_var(struct fb_var_screeninfo *var, struct lcdfb_par *par,
+			  const struct fb_info *info)
+{
+
+	/*
+	 *  Fill the 'var' structure based on the values in 'par' and maybe other
+	 *  values read out of the hardware.
+	 */
+
+	var->xres = LCD_WIDTH;
+	var->yres = LCD_HEIGHT;
+	var->xres_virtual = var->xres;
+	var->yres_virtual = var->yres;
+	var->xoffset = 0;
+	var->yoffset = 0;
+
+	var->bits_per_pixel = 1;
+	var->grayscale = 1;
+
+	return 0;
+}
+
+static void lcd_get_par(struct lcdfb_par *par, const struct fb_info *info)
+{
+	/*
+	 *  Fill the hardware's 'par' structure.
+	 */
+
+	if ( current_par_valid ) {
+		*par = current_par;
+	}
+	else {
+		/* ... */
+	}
+}
+
+static void lcd_set_par(struct lcdfb_par *par, const struct fb_info *info)
+{
+	/*
+	 *  Set the hardware according to 'par'.
+	 */
+
+	current_par = *par;
+	current_par_valid = 1;
+
+	/* ... */
+}
+
+static int lcd_getcolreg(unsigned regno, unsigned *red, unsigned *green,
+			 unsigned *blue, unsigned *transp,
+			 const struct fb_info *info)
+{
+	/*
+	 *  Read a single color register and split it into colors/transparent.
+	 *  The return values must have a 16 bit magnitude.
+	 *  Return != 0 for invalid regno.
+	 */
+
+	/* ... */
+	return 0;
+}
+
+static int lcd_setcolreg(unsigned regno, unsigned red, unsigned green,
+			 unsigned blue, unsigned transp,
+			 const struct fb_info *info)
+{
+	/*
+	 *  Set a single color register. The values supplied have a 16 bit
+	 *  magnitude.
+	 *  Return != 0 for invalid regno.
+	 */
+
+	/* ... */
+	return 0;
+}
+
+static int lcd_pan_display(struct fb_var_screeninfo *var,
+			   struct lcdfb_par *par, const struct fb_info *info)
+{
+	/*
+	 *  Pan (or wrap, depending on the `vmode' field) the display using the
+	 *  `xoffset' and `yoffset' fields of the `var' structure.
+	 *  If the values don't fit, return -EINVAL.
+	 */
+
+	/* ... */
+	return -EINVAL;
+}
+
+static int lcd_blank(int blank_mode, const struct fb_info *info)
+{
+
+	switch (blank_mode) {
+	case VESA_NO_BLANKING:
+		break;
+
+	case VESA_VSYNC_SUSPEND:
+	case VESA_HSYNC_SUSPEND:
+		break;
+
+	case VESA_POWERDOWN:
+		break;
+
+	default:
+		/* printk(KERN_ERR "unknown blank value %d\n", blank_mode); */
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static void lcd_set_disp(const void *par, struct display *disp,
+			 struct fb_info_gen *info)
+{
+
+	/*
+	 *  Fill in a pointer with the virtual address of the mapped frame buffer.
+	 *  Fill in a pointer to appropriate low level text console operations (and
+	 *  optionally a pointer to help data) for the video mode `par' of your
+	 *  video hardware. These can be generic software routines, or hardware
+	 *  accelerated routines specifically tailored for your hardware.
+	 *  If you don't have any appropriate operations, you must fill in a
+	 *  pointer to dummy operations, and there will be no text output.
+	 */
+
+	disp->screen_base = lcd_scr;
+	disp->dispsw = &fbcon_lcd;
+}
+
+
+/* ------------ Interfaces to hardware functions ------------ */
+
+struct fbgen_hwswitch lcd_switch = {
+	detect:		lcd_detect,
+	encode_fix:	lcd_encode_fix,
+	decode_var:	lcd_decode_var,
+	encode_var:	lcd_encode_var,
+	get_par:	lcd_get_par,
+	set_par:	lcd_set_par,
+	getcolreg:	lcd_getcolreg,
+	setcolreg:	lcd_setcolreg,
+	pan_display:	lcd_pan_display,
+	blank:		lcd_blank,
+	set_disp:	lcd_set_disp,
+};
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/*
+ *  Frame buffer operations
+ */
+
+static int lcd_fp_open(const struct fb_info *info, int user)
+{
+
+	return 0;
+}
+
+static int lcd_fb_ioctl(struct inode *inode, struct file *file, u_int cmd,
+	u_long arg, int con, struct fb_info *info)
+
+{
+	return -EINVAL;
+}
+
+
+/*
+ *  In most cases the `generic' routines (fbgen_*) should be satisfactory.
+ *  However, you're free to fill in your own replacements.
+ */
+
+static struct fb_ops lcdfb_ops = {
+	owner:		THIS_MODULE,
+	fb_open:	lcd_fp_open,
+	fb_get_fix:	fbgen_get_fix,
+	fb_get_var:	fbgen_get_var,
+	fb_set_var:	fbgen_set_var,
+	fb_get_cmap:	fbgen_get_cmap,
+	fb_set_cmap:	fbgen_set_cmap,
+	fb_pan_display:	fbgen_pan_display,
+	fb_ioctl:	lcd_fb_ioctl,
+};
+
+
+/* ------------ Hardware Independent Functions ------------ */
+
+
+/*
+ *  Initialization
+ */
+
+int read_proc(char *buf, char **start, off_t offset, int count,
+		     int *eof, void *data)
+{
+	int length = sprintf(buf, "No debug at this point\n");
+
+	/* housekeeping */
+	if (length <= offset + count)
+		*eof = 1;
+	*start = buf + offset;
+	length -= offset;
+	if (length > count)
+		length = count;
+	if (length < 0)
+		length = 0;
+
+	return length;
+}
+
+
+int __init lcdfb_init(void)
+{
+	lcd_scr = kmalloc(LCD_HEIGHT * (LCD_WIDTH+4)/8, GFP_KERNEL);
+	if(lcd_scr == NULL)
+		return -EINVAL;
+
+	memset(lcd_scr, 0, LCD_HEIGHT * (LCD_WIDTH+4)/8);
+
+        if (!create_proc_read_entry("lcdfb", 0, 0, read_proc, NULL)) {
+		// Too bad
+	}
+
+	fb_info.gen.fbhw = &lcd_switch;
+
+	fb_info.gen.fbhw->detect();
+
+	strcpy(fb_info.gen.info.modename, "lcd");
+
+	fb_info.gen.info.changevar = NULL;
+	fb_info.gen.info.node = -1;
+	fb_info.gen.info.fbops = &lcdfb_ops;
+	fb_info.gen.info.disp = &disp;
+	fb_info.gen.info.switch_con = &fbgen_switch;
+	fb_info.gen.info.updatevar = &fbgen_update_var;
+	fb_info.gen.info.blank = &fbgen_blank;
+	fb_info.gen.info.flags = FBINFO_FLAG_DEFAULT;
+
+	/* This should give a reasonable default video mode */
+	fbgen_get_var(&disp.var, -1, &fb_info.gen.info);
+	fbgen_do_set_var(&disp.var, 1, &fb_info.gen);
+	fbgen_set_disp(-1, &fb_info.gen);
+	fbgen_install_cmap(0, &fb_info.gen);
+
+	if ( register_framebuffer(&fb_info.gen.info) < 0 ) {
+		kfree(lcd_scr);
+		return -EINVAL;
+	}
+
+	init_lcd();
+
+	printk(KERN_INFO "fb%d: %s frame buffer device\n", GET_FB_IDX(fb_info.gen.info.node), fb_info.gen.info.modename);
+
+	/* uncomment this if your driver cannot be unloaded */
+	/* MOD_INC_USE_COUNT; */
+	return 0;
+}
+
+
+/*
+ *  Cleanup
+ */
+
+void lcdfb_cleanup(struct fb_info *info)
+{
+	/*
+	 *  If your driver supports multiple boards, you should unregister and
+	 *  clean up all instances.
+	 */
+
+	unregister_framebuffer(info);
+	kfree(lcd_scr);
+
+	/* ... */
+}
+
+
+/*
+ *  Setup
+ */
+
+int __init lcdfb_setup(char *options)
+{
+	/* Parse user speficied options (`video=lcdfb:') */
+	return 0;
+}
+
+#ifdef MODULE
+MODULE_LICENSE("GPL");
+int init_module(void)
+{
+	return lcdfb_init();
+}
+
+void cleanup_module(void)
+{
+	
+}
+
+#endif /* MODULE */
diff -urN -X dontdiff linux-vanilla/drivers/video/fbmem.c linux/drivers/video/fbmem.c
--- linux-vanilla/drivers/video/fbmem.c	2003-07-04 10:12:03.000000000 +0200
+++ linux/drivers/video/fbmem.c	2005-03-07 20:50:24.000000000 +0100
@@ -140,6 +140,8 @@
 extern int pvr2fb_setup(char*);
 extern int sstfb_init(void);
 extern int sstfb_setup(char*);
+extern int lcdfb_init(void);
+extern int lcdfb_setup(char*);
 
 static struct {
 	const char *name;
@@ -189,6 +191,9 @@
 #ifdef CONFIG_FB_ATY128
 	{ "aty128fb", aty128fb_init, aty128fb_setup },
 #endif
+#ifdef CONFIG_FB_LCD
+	{ "lcd", lcdfb_init, lcdfb_setup },
+#endif
 #ifdef CONFIG_FB_NEOMAGIC
 	{ "neo", neofb_init, neofb_setup },
 #endif
