linux-oz-2.6: Add 2.6.13-mm1 as a new development branch (for now). Several patches merged with mainline, others needed updates. Also some pm changes to add fatal battery and batter cover interrupt functionality.

13 files changed, 34526 insertions, 0 deletions

diff --git a/packages/linux/linux-openzaurus-2.6.13-mm1/.mtn2git_empty b/packages/linux/linux-openzaurus-2.6.13-mm1/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/linux/linux-openzaurus-2.6.13-mm1/.mtn2git_empty
diff --git a/packages/linux/linux-openzaurus-2.6.13-mm1/add-elpp-stuff.patch b/packages/linux/linux-openzaurus-2.6.13-mm1/add-elpp-stuff.patch
new file mode 100644
index 0000000000..04ab185f4f
--- /dev/null
+++ b/packages/linux/linux-openzaurus-2.6.13-mm1/add-elpp-stuff.patch
@@ -0,0 +1,26985 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- /dev/null
++++ linux-2.6.12/Documentation/fb/elpp.txt
+@@ -0,0 +1,181 @@
++
++	ELPP, The Enhanced Linux Progress Patch v1.0
++	--------------------------------------------
++
++CONTENTS 
++0. ChangeLog.
++1. What is ELPP.
++2. Who needs it.
++3. Requirements.
++4. How to use it.
++5. Uninstalling.
++6. Creating Themes.
++7. Sample Bootloader entries.
++
++
++0. The following is the summary of changes from ELPP-v0.1
++  -> New format for themes
++  -> Fixes
++  -> Reserving part of palette for ELPP colors 
++
++
++1. What is ELPP? 
++	Hides the bootup messages and shows a fancy logo at boot. It
++can however show a configurable number of messages while at the same
++time showing the logo and a progress bar.  The success, failure and
++the warning messages of the initscripts can also be shown here.
++
++
++2. Who needs it?
++	A few rare people who are not interested in the messages shown when
++booting.  (like the friend of Cajus Pollmeier, The author of the original
++Linux Progress Patch).  A few of my friends use it but I dont.
++
++
++3. Requirements:
++	Requires a vesa capable machine. Linux 2.6 or later are supported.
++If you are looking for patch for 2.4, you can have a look at the Linux
++Progress Patch at "http://freshmeat.net/projects/lpp/". You
++might also be interested in the bootsplash <http://www.bootsplash.org>
++
++
++4. How to use it?
++  -> Download a fresh 2.6 kernel from http://www.kernel.org/
++  -> Download the patch from http://elpp.foofighter.de/
++  -> Apply the patch...
++	cd linux-2.6.XX
++	bzip2 -cd /path/to/patch/elpp-1.0-2.6.XX.bz2 | patch -p1
++  -> Configure and compile the Kernel
++       
++        make xconfig (or menuconfig etc.);
++	
++	and then enable the following
++
++	File systems
++	    -> Pseudo filesystems
++	          -> /proc file system
++
++	Device Drivers
++	    -> Block Devices
++	          -> RAM disk support (and INITRD support too)
++	
++	Device Drivers 
++	    -> Graphics Support 
++	          -> Support for FrameBuffer devices
++			 -> Enhanced Linux Progress Patch
++	
++	Device Drivers
++	    -> Graphics Support 
++	          -> Console Display Driver Support
++	                 -> Framebuffer Console support 
++
++	and select atleast one driver (VESA Preffered) for FB under
++	DeviceDrivers -> Graphics Support -> Support for FrameBuffer Devices.
++
++	After finishing with the configuration, you need to do a
++	make bzImage, make modules, make modules_install and a make install
++	to install the new kernel.
++
++  -> Configure your boot loader.
++
++  	Based on your hardware you need to select a vesa mode. Check
++	linux-2.6.XX/Documentation/fb/vesafb.txt for more information.
++	passing vga=0x301 would in most cases be sufficient.  However
++	higher resolutions are also supported.
++
++	To display the display of messages, you need to pass the
++	arguments "console=/dev/tty2 CONSOLE=/dev/tty2" to the kernel.
++
++	Please refer to the sample LILO and GRUB entries at the bottom.
++
++  -> Change the initscripts.
++  	Changing the init scripts would do the job of passing messages
++	and progress to the kernel.  Take a look at the distributed 
++	files etc/rc and etc/init.d/functions for the modifications. 
++	
++	Hint: Search for the word progress and the matches would 
++	      reveal the changes done.
++
++	In case of RedHat9 The distributed initscripts can directly be used.
++
++	Here's what the modifications mean...
++	  1. If you echo a string "10 Hello world" into /proc/progress
++	     the initial number is taken as progress and the other
++	     part of the string forms the message to be displayed.
++	     
++	  2. If the message starts with a '=' it indicates the
++	     success/failure of the previous message.
++	        	=s is for success.
++			=f is for failure.
++			=w is for warning.
++
++	  3. If the message starts with a '!' its a command.
++	  		!c to clear the previous messages.
++			!s to enable/disable the progress bar.
++
++
++5. Uninstalling:
++	For uninstalling ELPP you can install your backup kernel and
++for the initscripts you may need to reinstall the package that provides
++them.
++
++
++6. Creating Themes:
++	Themes for ELPP-v1.0 are in the form of initrd files. The
++application which is also distributed along with this patch can be used
++for creating themes.
++	For creating themes using the application, load an image into
++the application and select the locations/colors for the progress bar
++and messages to appear.  For distortion free boot-screen use images
++with not more than 200 colors. For this you can use the GNU image 
++manipulation program (GIMP).  The steps involved are as below:
++
++  -> Open your favorite image in GIMP.
++  -> In the context menu... go to Image->Mode->Indexed
++  -> In the dialog that pops up, se the colors to 200.
++  -> Save the image in PNG (avoid gif please)
++
++once you create the theme, save it and you get a file with .eti extension.
++You can either use this file directly as your initrd or append this
++to your initrd.  ie., cat IMG_NAME.eti >> /boot/initrd...  See your
++bootloaders documentation for further information on using initrd.
++
++Note: The size of the theme image will be equal to the size of the input
++      image.  Please ensure that the size of image is according to the
++      entry in BootLoader... If the resolution of theme is greater than
++      that of the screen, the system would not crash but the behaviour of
++      the boot screen is not assured.  However, when a smaller image is
++      given... it is centered to the screen.
++
++Note2: If no themes are loaded using the INITRD, the default inbuilt theme
++       is shown.
++
++7. Sample Boot Loader entries:
++	The following examples demonstrate using a theme from file smile.eti
++on a 640x480 resolution.  For more details on the FB modes refer to the Linux
++kernel documentation... Documentation/fb/vesa.txt in the kernel source tree.
++The following the summary of modes:
++
++        | 640x480  800x600  1024x768 1280x1024
++    ----+-------------------------------------
++    256 |  0x301    0x303    0x305    0x307
++    32k |  0x310    0x313    0x316    0x319
++    64k |  0x311    0x314    0x317    0x31A
++    16M |  0x312    0x315    0x318    0x31B
++
++
++  -> In lilo its done as..
++	image=/boot/vmlinux-2.6.XX
++		label=Linux-ELPP
++		vga=0x301
++		append="console=/dev/tty2 CONSOLE=/dev/tty2"
++		initrd=/boot/smile.eti 
++
++  ->In grub its just
++	kernel /boot/vmlinux vga=0x301 console=/dev/tty2 CONSOLE=/dev/tty2
++	initrd /boot/initrd-2.6.XX
++
++
++            -----------------------------------------
++            Comments, queries and changes welcome at:
++            Matthias Kunze <elpp at foofighter.de>
+--- linux-2.6.12/drivers/video/Kconfig~add-elpp-stuff.patch
++++ linux-2.6.12/drivers/video/Kconfig
+@@ -108,6 +108,11 @@
+ 	 This is particularly important to one driver, matroxfb.  If
+ 	 unsure, say N.
+ 
++config FB_ELPP
++	bool "Enhanced Linux Progress Patch"
++	depends on FB && PROC_FS
++	default y
++
+ config FB_CIRRUS
+ 	tristate "Cirrus Logic support"
+ 	depends on FB && (ZORRO || PCI)
+--- linux-2.6.12/drivers/video/console/Makefile~add-elpp-stuff.patch
++++ linux-2.6.12/drivers/video/console/Makefile
+@@ -31,6 +31,8 @@
+ obj-$(CONFIG_FRAMEBUFFER_CONSOLE)     += tileblit.o
+ endif
+ 
++obj-$(CONFIG_FB_ELPP)  	   += elpp.o symbols_16x16.o
++
+ obj-$(CONFIG_FB_STI)              += sticore.o font.o
+ 
+ # Targets that kbuild needs to know about
+--- /dev/null
++++ linux-2.6.12/drivers/video/console/elpp.c
+@@ -0,0 +1,685 @@
++
++/* 
++ *  The Enhanced Linux Progress Patch
++ *     by Prasad <prasad_s@students.iiit.net>, IIIT - Hyderabad, INDIA
++ *
++ *  drivers/video/console/elpp.c   ELPP implementation file
++ *
++ *  This file is part of the Enhanced Linux Progress Patch.
++ *
++ *  ELPP 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.
++ *
++ *  Foobar 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 ELPP; if not, write to the Free Software 
++ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
++ * 
++ */ 
++
++#include <linux/config.h>
++#include <linux/initrd.h>
++#include <linux/module.h>
++#include <linux/types.h>
++#include <linux/sched.h>
++#include <linux/fs.h>
++#include <linux/kernel.h>
++#include <linux/delay.h>
++#include <linux/tty.h>
++#include <linux/console.h>
++#include <linux/string.h>
++#include <linux/kd.h>
++#include <linux/slab.h>
++#include <linux/fb.h>
++#include <linux/vt_buffer.h>
++#include <linux/vt_kern.h>
++#include <linux/vmalloc.h>
++#include <linux/selection.h>
++#include <linux/smp.h>
++#include <linux/init.h>
++#include <linux/font.h>
++#include <linux/proc_fs.h>
++#include <linux/version.h>
++#include <linux/linux_logo.h>
++#include <linux/elpp.h>
++#include <asm/io.h>
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/uaccess.h>
++
++#define MAX_MSG_LENGTH	100
++
++struct elpp_messages {
++    char text[MAX_MSG_LENGTH];
++    short success;
++    short flag;
++};
++
++extern const struct linux_logo logo_linux_elpp;
++
++struct elpp_prefs backup_prefs = {
++    .bar_x		= 275,
++    .bar_y		= 300,
++    .bar_length		= 365,
++    .bar_width		= 10,
++    .msg_length		= 45,
++    .num_messages	= 7,
++    .msg_x		= 275,
++    .msg_y		= 185,
++    .bar_bg		= {0x00,0x00,0xff},
++    .bar_fg		= {0xff,0x00,0x00},
++    .warning_bg		= {0x00,0x00,0x00},
++    .warning_fg		= {0xff,0xff,0xff},
++    .error_bg		= {0x00,0x00,0x00},
++    .error_fg		= {0xff,0xff,0xff},
++    .success_bg		= {0x00,0x00,0x00},
++    .success_fg		= {0xff,0xff,0xff},
++    .warning_symbol_bg	= {0x00,0x00,0x00},
++    .warning_symbol_fg	= {0xff,0xff,0x00},
++    .error_symbol_bg	= {0x00,0x00,0x00},
++    .error_symbol_fg	= {0xff,0x00,0x00},
++    .success_symbol_bg	= {0x00,0x00,0x00},
++    .success_symbol_fg	= {0x00,0xff,0x00}
++};
++
++struct elpp_struct elpp = {NULL,0,1,0,0,NULL,NULL,NULL,
++			   NULL,NULL,NULL,0,0,0,0,0};
++
++static u16 translated_bar_x, translated_bar_y;
++static u16 translated_msg_x, translated_msg_y;
++
++#define BAR_X		translated_bar_x
++#define BAR_Y		translated_bar_y
++#define BAR_WIDTH	elpp.prefs->bar_length
++#define BAR_HEIGHT	elpp.prefs->bar_width
++#define MSG_LENGTH	elpp.prefs->msg_length
++#define NUM_MSGS	elpp.prefs->num_messages
++#define MSG_X		translated_msg_x
++#define MSG_Y		translated_msg_y
++#define BAR_BG		elpp.prefs->bar_bg
++#define BAR_FG		elpp.prefs->bar_fg
++#define WRN_BG		elpp.prefs->warning_bg
++#define WRN_FG		elpp.prefs->warning_fg
++#define WRN_SYM_BG	elpp.prefs->warning_symbol_bg
++#define WRN_SYM_FG	elpp.prefs->warning_symbol_fg
++#define ERR_BG		elpp.prefs->error_bg
++#define ERR_FG		elpp.prefs->error_fg
++#define ERR_SYM_BG	elpp.prefs->error_symbol_bg
++#define ERR_SYM_FG	elpp.prefs->error_symbol_fg
++#define SUC_BG		elpp.prefs->success_bg
++#define SUC_FG		elpp.prefs->success_fg
++#define SUC_SYM_BG	elpp.prefs->success_symbol_bg
++#define SUC_SYM_FG	elpp.prefs->success_symbol_fg
++
++#define MSG_CUR \
++	elpp.messages[(elpp.msg_position + NUM_MSGS ) % NUM_MSGS]
++#define MSG_PREV \
++	elpp.messages[(elpp.msg_position + NUM_MSGS - 1) % NUM_MSGS]
++#define MSG_NEXT \
++	elpp.messages[(elpp.msg_position + 1) % NUM_MSGS]
++#define COLOR(x)	(elpp.colors_base + x)
++
++static const unsigned char colors[14][3];
++
++enum ELPP_COLORS { eBAR_FG, eBAR_BG,
++                  eSUC_FG, eSUC_BG, eSUC_SYM_FG, eSUC_SYM_BG,
++                  eWRN_FG, eWRN_BG, eWRN_SYM_FG, eWRN_SYM_BG,
++                  eERR_FG, eERR_BG, eERR_SYM_FG, eERR_SYM_BG };
++
++enum ELPP_STATUS { eSUCCESS=1, eWARNING, eFAILURE };
++
++/* ASCII to Integer... needed for progress */
++static int elpp_atoi(const char *name)
++{
++    int val = 0;
++
++    for (;; name++) {
++       switch (*name) {
++           case '0'...'9':
++               val = 10*val+(*name-'0');
++               break;
++           default:
++               return val;
++       }
++    }
++}
++
++/* Parse the message passed from userspace */
++static int elpp_parse(const char *str)
++{
++    int progress = -1, success = 0;
++    char *msg_text; 
++    
++    if( str[0] == '!' ) {
++    
++       /* Its a command... */
++       if( str[1] == 'c' ) {
++       
++           int i;
++           for(i=0; i<NUM_MSGS; i++) 
++               elpp.messages[i].flag = 0;
++           elpp.msg_position = 0;
++
++       } else if( str[1] ==  's' ) 
++           elpp.booting = 1 - elpp.booting;
++
++       /* return without updating */
++       return 0;
++    } else if( str[0] == '=' ) {
++    
++       /* Was the previous operation successful??? */
++
++       switch (str[1]) {
++           case 's': 
++               success = eSUCCESS;
++               break;
++           case 'f': 
++               success = eFAILURE;
++               break;
++           case 'w': 
++               success = eWARNING;
++               break;
++           default:
++               success = 0;
++               break;
++       }
++
++       if( MSG_PREV.flag == 1 )
++               MSG_PREV.success = success;
++
++       /* return without updating */
++       return 0;
++    }
++
++    if (elpp.booting == 0)
++    	return 0;
++
++    /* Its the LPP style input, Progress followed by Message */
++    progress = elpp_atoi(str);
++    msg_text = strchr(str,' ') + 1;
++    strncpy( MSG_CUR.text, msg_text, strlen(msg_text)+1);
++    MSG_CUR.flag = 1;
++    MSG_CUR.success = 0;
++
++    elpp.msg_position++;
++    if(elpp.msg_position == NUM_MSGS)
++       elpp.msg_position = 0;
++    
++    progress = (progress > 100)? 100: progress;
++    return progress;
++}
++
++/* Based on accel_putc in fbcon.c */
++static void elpp_render_char(struct font_desc *font,
++                            int ch, int xx, int yy, int fgcol, int bgcol)
++{
++    struct fb_image image;
++    unsigned short charmask = 0xff;
++    unsigned int scan_align = elpp.info->pixmap.scan_align - 1;
++    unsigned int buf_align = elpp.info->pixmap.buf_align - 1;
++    unsigned int size, pitch;
++    unsigned int width = (font->width + 7) >> 3;
++    u8 *src, *dst;
++
++    image.dx = xx;
++    image.dy = yy;
++    image.width = font->width;
++    image.height = font->height;
++    image.fg_color = fgcol;
++    image.bg_color = bgcol;
++    image.depth = 1;
++
++    pitch = width + scan_align;
++    pitch &= ~scan_align;
++    size = pitch * font->height;
++    size += buf_align;
++    size &= ~buf_align;
++    dst = fb_get_buffer_offset(elpp.info, &(elpp.info->pixmap), size);
++    image.data = dst;
++    src = font->data + (ch & charmask) * font->height * width;
++
++    fb_pad_aligned_buffer(dst, pitch, src, width, image.height);
++    elpp.info->fbops->fb_imageblit(elpp.info, &image);
++}
++
++/* Show the messages */
++static void elpp_show_messages(void)
++{
++    struct font_desc *font = get_default_font(elpp.info->var.xres, 
++    							elpp.info->var.yres);
++    struct font_desc *icons = &symbols_16x16;
++    int i,counter=0;
++    struct fb_fillrect rect;
++    
++    rect.dy = MSG_Y; 
++    rect.dx = MSG_X;
++    rect.width = MSG_LENGTH * font->width;
++    rect.height = font->height * NUM_MSGS;
++    rect.rop = 0;
++    rect.color = COLOR(eSUC_BG);
++    elpp.info->fbops->fb_fillrect(elpp.info, &rect);
++    
++    i = elpp.msg_position ? elpp.msg_position - 1 : NUM_MSGS - 1;
++
++    for(counter = 0; counter < NUM_MSGS; i = i ? i-1 : NUM_MSGS-1, counter++){
++
++         int j;
++         int textbg,textfg,iconbg,iconfg;
++   
++         rect.dy = MSG_Y + font->height * (NUM_MSGS-counter-1);
++         rect.height = font->height;
++   
++         /* Set the background for text */
++         switch(elpp.messages[i].success) {
++	      default:
++             case eSUCCESS:
++                 rect.color = COLOR(eSUC_BG);
++                 textbg = COLOR(eSUC_BG);
++		 textfg = COLOR(eSUC_FG);
++		 iconbg = COLOR(eSUC_SYM_BG);
++		 iconfg = COLOR(eSUC_SYM_FG);
++                 break;
++             case eWARNING:
++                 rect.color = COLOR(eWRN_BG);
++                 textbg = COLOR(eWRN_BG);
++		 textfg = COLOR(eWRN_FG);
++		 iconbg = COLOR(eWRN_SYM_BG);
++		 iconfg = COLOR(eWRN_SYM_FG);
++                 break;
++             case eFAILURE:
++                 rect.color = COLOR(eERR_BG);
++                 textbg = COLOR(eERR_BG);
++		 textfg = COLOR(eERR_FG);
++		 iconbg = COLOR(eERR_SYM_BG);
++		 iconfg = COLOR(eERR_SYM_FG);
++                 break;
++         }
++         elpp.info->fbops->fb_fillrect(elpp.info, &rect);
++                
++         if(elpp.messages[i].flag == 0)
++              break;
++         
++         /* Show the text now */
++         for( j = 0; j < strlen(elpp.messages[i].text); j++ ) {
++              elpp_render_char( font, elpp.messages[i].text[j], 
++	          MSG_X + font->width * j,
++                  MSG_Y + font->height * (NUM_MSGS-counter-1), textfg, textbg );
++         }
++         
++	  /* Show the bitmap for success/failure/warning */
++	  if(elpp.messages[i].success != 0) {
++	      elpp_render_char( icons, (elpp.messages[i].success - 1) * 2,
++	      		MSG_X + (font->width * (MSG_LENGTH - 3)),
++		  	MSG_Y + font->height * (NUM_MSGS - counter - 1), 
++		  	iconfg, iconbg );
++	      elpp_render_char( icons, (elpp.messages[i].success - 1) * 2 + 1,
++	          	MSG_X + (font->width * (MSG_LENGTH - 2)),
++		  	MSG_Y + font->height * (NUM_MSGS - counter - 1), 
++		  	iconfg, iconbg );
++	  }
++    }
++}
++
++/* Update the contents on the screen */
++static void elpp_show_progress(int progress)
++{
++    struct fb_fillrect rect;
++
++    /* Draw the BG of progress Bar */
++    rect.dx = BAR_X;
++    rect.dy = BAR_Y;
++    rect.height = BAR_HEIGHT;
++    rect.width = BAR_WIDTH;
++    rect.color = COLOR(eBAR_BG);
++    rect.rop = 0;
++    elpp.info->fbops->fb_fillrect(elpp.info, &rect);
++
++    /* Draw the progress */
++    rect.dx = BAR_X;
++    rect.dy = BAR_Y + 1;
++    rect.width = (progress * BAR_WIDTH)/100;
++    rect.height = BAR_HEIGHT - 2;
++    rect.color = COLOR(eBAR_FG);
++    elpp.info->fbops->fb_fillrect(elpp.info, &rect);
++
++}
++
++/* Function that can be called from other parts of kernel */
++void elpp_progress(char *str)
++{
++    int progress;
++    
++    progress = elpp_parse(str);
++    if( progress > 0 ) {
++        elpp_show_progress(progress);
++	elpp_show_messages();
++    }
++}
++
++/* Something written into /proc/progress */
++static ssize_t elpp_proc_write(struct file *file, const char *buf, 
++                                       size_t length, loff_t *offset)
++{
++    int progress;
++    char tmp_string[MSG_LENGTH];
++    int len = length < MSG_LENGTH ? length : MSG_LENGTH;
++   
++    /* If disabled do not process input */
++    if( elpp.disable == 1 )
++	return length;
++    
++    copy_from_user(tmp_string,buf, len );
++    tmp_string[len-1] = '\0';
++    progress = elpp_parse(tmp_string);
++    if( progress > 0 ) {
++        elpp_show_progress(progress);
++	elpp_show_messages();
++    }
++
++    /* We have read the entire string */
++    return length;
++}
++
++/* /proc/progress access permissions */
++int elpp_permissions(struct inode *inode, int op, struct nameidata *dummy)
++{
++    /* W for root */
++    if ( op == 2 && current->euid == 0 )
++       return 0;
++    return -EACCES;
++}
++
++/* Create proc entry */
++static struct file_operations elpp_file_operations = {
++       .owner =        THIS_MODULE,
++       .write =        elpp_proc_write
++};
++
++static struct inode_operations elpp_inode_operations = {
++       .lookup =       &elpp_file_operations,
++       .permission =   elpp_permissions
++};
++
++/* Registers an entry in the /proc directory */
++void __init elpp_register(void)
++{
++    elpp.proc_progress_entry = create_proc_entry("progress",
++                           S_IFREG | S_IRUGO | S_IWUSR, &proc_root );
++    if( elpp.proc_progress_entry == NULL )
++    {
++       printk("[ELPP] Unable to create proc entry.\n");
++       return;
++    }
++
++    elpp.proc_progress_entry->owner = THIS_MODULE;
++    elpp.proc_progress_entry->proc_iops = &elpp_inode_operations;
++    elpp.proc_progress_entry->write_proc = elpp_proc_write;
++}
++
++static inline unsigned safe_shift(unsigned d, int n)
++{
++	return n < 0 ? d >> -n : d << n;
++}
++
++/* Based on fb_set_logocmap() */
++static void __init elpp_set_cmap(void)
++{
++    struct fb_cmap palette_cmap;
++    u16 palette_green[14];
++    u16 palette_blue[14];
++    u16 palette_red[14];
++    int i;
++
++    palette_cmap.len = 14;
++    palette_cmap.red = palette_red;
++    palette_cmap.green = palette_green;
++    palette_cmap.blue = palette_blue;
++    palette_cmap.transp = NULL;
++    palette_cmap.start = 235;
++    for (i = 0; i < 14; ++i) {
++       palette_cmap.red[i] = colors[i][0] << 8 | colors[i][0];
++       palette_cmap.green[i] = colors[i][1] << 8 | colors[i][1];
++       palette_cmap.blue[i] = colors[i][2] << 8 | colors[i][2];
++    }
++    fb_set_cmap(&palette_cmap, elpp.info);
++
++    elpp.colors_base = 235;
++}
++
++/* Based on fb_set_logo_truepalette() */
++static void __init elpp_set_truepalette(void)
++{
++    unsigned char mask[9] = { 0,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff };
++    struct fb_info *info = elpp.info;
++    unsigned char redmask, greenmask, bluemask;
++    int redshift, greenshift, blueshift;
++    int i;
++
++    /*
++    * We have to create a temporary palette since console palette is only
++    * 16 colors long.
++    */
++    /* Bug: Doesn't obey msb_right ... (who needs that?) */
++    redmask   = mask[info->var.red.length   < 8 ? info->var.red.length   : 8];
++    greenmask = mask[info->var.green.length < 8 ? info->var.green.length : 8];
++    bluemask  = mask[info->var.blue.length  < 8 ? info->var.blue.length  : 8];
++    redshift   = info->var.red.offset   - (8 - info->var.red.length);
++    greenshift = info->var.green.offset - (8 - info->var.green.length);
++    blueshift  = info->var.blue.offset  - (8 - info->var.blue.length);
++
++    for ( i = 0; i < 14; i++) {
++        elpp.palette[i+32] = (safe_shift((colors[i][0] & redmask), redshift) | 
++			safe_shift((colors[i][1] & greenmask), greenshift) | 
++			safe_shift((colors[i][2] & bluemask), blueshift));
++    }
++
++    elpp.colors_base = 32;
++}
++
++/* Based on fb_set_logo_directpalette() */
++static void __init elpp_set_directpalette(void)
++{
++    struct fb_info *info = elpp.info;
++    int redshift, greenshift, blueshift;
++    int i;
++
++    redshift = info->var.red.offset;
++    greenshift = info->var.green.offset;
++    blueshift = info->var.blue.offset;
++
++    for (i = 32; i < 46; i++)
++	elpp.palette[i] = i << redshift | i << greenshift | i << blueshift;
++
++    elpp.colors_base = 32;
++}
++
++void __init elpp_find_initrd_theme(void)
++{
++    unsigned long i, j, k, theme_complete=0;
++    int imgW, imgH, img_size, clut_size;
++    
++    printk("[ELPP] Searching for initrd_theme preferences... ");
++#ifdef BLK_DEV_INITRD
++    if( ! initrd_start )
++	goto find_initrd_theme_end;
++    for(i = initrd_start; i < initrd_end - sizeof(struct elpp_prefs); i++){
++	if(strncmp((char *)i,"ELPP-THEME-START",16) == 0) {
++	    printk("Found at 0x%08lx\n", i);
++            elpp.prefs = vmalloc(sizeof(struct elpp_prefs));
++	    memcpy(elpp.prefs, (void*)(i+16), sizeof(struct elpp_prefs));
++	    
++	    printk("[ELPP] Searching for initrd_theme image... ");
++	    for(j = i; j < initrd_end; j++) {
++		if(strncmp((char *)j,"ELPP-START-IMAGE",16) == 0) {
++		    printk("Found at 0x%08lx\n", j);
++		    elpp.logo = vmalloc(sizeof(struct linux_logo));
++		    memcpy(elpp.logo, (void*)(j+16), sizeof(struct linux_logo));
++		    elpp.logo->clut = NULL;
++		    elpp.logo->data = NULL;
++		    imgW = elpp.logo->width;
++		    imgH = elpp.logo->height;
++		    img_size = imgW * imgH * sizeof(char);
++		    clut_size = elpp.logo->clutsize * 3 * sizeof(char);
++		    printk("[ELPP] Image: (%d,%d), %d colors\n",
++		    		imgW, imgH, elpp.logo->clutsize);
++
++		    for(k = j+sizeof(struct linux_logo); k < initrd_end; k++){
++			if(strncmp((char *)k, "ELPP-START-IMAGE-DATA",21) == 0){
++			    elpp.logo->data = vmalloc(img_size);
++			    memcpy((void *)elpp.logo->data, 
++			    			(void*)(k+21), img_size);
++			    k+=img_size;
++			}
++			if(strncmp((char *)k, "ELPP-START-IMAGE-CLUT",21) == 0){
++			    elpp.logo->clut = vmalloc(clut_size);
++			    memcpy((void*)elpp.logo->clut, 
++			    			(void*)(k+21), clut_size);
++			    k+=clut_size;
++			}
++			if(strncmp((char *)k, "ELPP-THEME-END", 14) == 0) {
++			    theme_complete = 1;
++			    goto find_initrd_theme_end;
++			}
++		    }
++		    goto find_initrd_theme_end;
++		}
++	    }
++	    goto find_initrd_theme_end;
++	}
++    }
++#endif
++find_initrd_theme_end:
++    if(theme_complete != 1) {
++	printk("Not found or Incomplete\n");
++	printk("[ELPP] Disabling the Progress Patch\n");
++	if(elpp.logo && elpp.logo->data)
++	    vfree((void *)elpp.logo->data);
++	if(elpp.logo && elpp.logo->clut)
++	    vfree((void *)elpp.logo->clut);
++	if(elpp.logo)
++	    vfree(elpp.logo);
++
++	elpp.logo = (struct linux_logo*)(&logo_linux_elpp);
++	elpp.prefs = &backup_prefs;
++    }
++}
++
++u16 __init elpp_translate_x(u16 x)
++{
++    if(elpp.logo->width < elpp.info->var.xres)
++	return (x + ((elpp.info->var.xres - elpp.logo->width)/2));
++    else
++	return x;
++}
++
++u16 __init elpp_translate_y(u16 y)
++{
++    if(elpp.logo->height < elpp.info->var.yres)
++	return (y + ((elpp.info->var.yres - elpp.logo->height)/2));
++    else
++	return y;
++}
++
++/* Initialize ELPP */
++int __init elpp_init(void)
++{
++    extern signed char con2fb_map[MAX_NR_CONSOLES];
++    struct fb_info *info;
++   
++    /* Are we using the FB */
++    if(num_registered_fb == 0) {
++	printk("[ELPP] There is no registered frame buffer\n");
++	goto error_return;
++    }
++    
++    /* Which console am I using for showing the ProgressBar */
++    elpp.console = fg_console;
++    elpp.info = registered_fb[(int)con2fb_map[elpp.console]];
++    if(elpp.info == NULL) {
++	printk("[ELPP] The current console is not on a FrameBuffer\n");
++	goto error_return;
++    }
++    
++    info = elpp.info;
++    if(elpp.logo->width > info->var.xres ) {
++	printk("[ELPP] Logo is bigger than the screen\n");
++	goto error_return;
++    }
++
++    /* Prepare the colors */
++    
++    memcpy((void*)colors[eBAR_BG], elpp.prefs->bar_bg, 3);
++    memcpy((void*)colors[eBAR_FG], elpp.prefs->bar_fg, 3);
++    
++    memcpy((void*)colors[eSUC_FG], elpp.prefs->success_fg, 3);
++    memcpy((void*)colors[eSUC_BG], elpp.prefs->success_bg, 3);
++    memcpy((void*)colors[eSUC_SYM_FG], elpp.prefs->success_symbol_fg, 3);
++    memcpy((void*)colors[eSUC_SYM_BG], elpp.prefs->success_symbol_bg, 3);
++    
++    memcpy((void*)colors[eWRN_FG], elpp.prefs->warning_fg, 3);
++    memcpy((void*)colors[eWRN_BG], elpp.prefs->warning_bg, 3);
++    memcpy((void*)colors[eWRN_SYM_FG], elpp.prefs->warning_symbol_fg, 3);
++    memcpy((void*)colors[eWRN_SYM_BG], elpp.prefs->warning_symbol_bg, 3);
++    
++    memcpy((void*)colors[eERR_FG], elpp.prefs->error_fg, 3);
++    memcpy((void*)colors[eERR_BG], elpp.prefs->error_bg, 3);
++    memcpy((void*)colors[eERR_SYM_FG], elpp.prefs->error_symbol_fg, 3);
++    memcpy((void*)colors[eERR_SYM_BG], elpp.prefs->error_symbol_bg, 3);
++
++    switch (info->fix.visual) {
++
++	case FB_VISUAL_TRUECOLOR:
++	    if (info->var.bits_per_pixel >= 8)
++		elpp.needs_truepalette = 1;
++	    break;
++	case FB_VISUAL_DIRECTCOLOR:
++	    if (info->var.bits_per_pixel >= 24) {
++		elpp.needs_directpalette = 1;
++		elpp.needs_cmapreset = 1;
++	    }
++	    break;
++	case FB_VISUAL_PSEUDOCOLOR:
++	    elpp.needs_cmapreset = 1;
++	    break;
++    }
++
++    if(elpp.needs_cmapreset)
++	elpp_set_cmap();
++
++    if(elpp.needs_truepalette || elpp.needs_directpalette) {
++	elpp.palette = vmalloc(256*4);
++	if(!elpp.palette)
++	    goto error_return;
++	if (elpp.needs_truepalette)
++	    elpp_set_truepalette();
++	else
++	    elpp_set_directpalette();
++
++	elpp.saved_palette = info->pseudo_palette;
++	info->pseudo_palette = elpp.palette;
++    }
++
++    /* Allocate memory to the message structures */
++    elpp.messages = vmalloc(sizeof(struct elpp_messages)*NUM_MSGS);
++    if(!elpp.messages)
++	goto error_return;
++    memset(elpp.messages,0,sizeof(struct elpp_messages)*NUM_MSGS);
++
++    /* Every thing is ok... now perform some calculations */
++    translated_msg_x = elpp_translate_x(elpp.prefs->msg_x);
++    translated_msg_y = elpp_translate_y(elpp.prefs->msg_y);
++    translated_bar_x = elpp_translate_x(elpp.prefs->bar_x);
++    translated_bar_y = elpp_translate_y(elpp.prefs->bar_y);
++
++    return 0;
++error_return:
++    elpp.disable = 1;
++    return -1;
++}
++
+--- linux-2.6.12/drivers/video/console/fbcon.c~add-elpp-stuff.patch
++++ linux-2.6.12/drivers/video/console/fbcon.c
+@@ -91,6 +91,9 @@
+ #include <asm/machdep.h>
+ #include <asm/setup.h>
+ #endif
++#ifdef CONFIG_FB_ELPP
++#include <linux/elpp.h>
++#endif
+ 
+ #include "fbcon.h"
+ 
+@@ -107,7 +110,7 @@
+ };
+ 
+ struct display fb_display[MAX_NR_CONSOLES];
+-static signed char con2fb_map[MAX_NR_CONSOLES];
++signed char con2fb_map[MAX_NR_CONSOLES];
+ static signed char con2fb_map_boot[MAX_NR_CONSOLES];
+ static int logo_height;
+ static int logo_lines;
+@@ -997,6 +1000,19 @@
+ 			softback_top = 0;
+ 		}
+ 	}
++
++ #ifdef CONFIG_FB_ELPP
++       extern struct elpp_struct elpp;
++ 
++       if(elpp.init == 0) {
++           if(elpp_init() == 0) {
++               elpp_register();
++           }
++           elpp.init = 1;
++       }
++ #endif
++
++
+ }
+ 
+ static void fbcon_deinit(struct vc_data *vc)
+@@ -1997,6 +2013,12 @@
+ 		logo_shown = fg_console;
+ 		/* This is protected above by initmem_freed */
+ 		fb_show_logo(info);
++#ifdef CONFIG_FB_ELPP
++		if(!elpp.disable) {
++		    elpp_progr