Author: pluto Date: Thu Dec 1 00:57:17 2005 GMT Module: SOURCES Tag: LINUX_2_6 ---- Log message: - back to fbsplash 'coz it works with fb != vesa (vesafb bootsplash sux).
---- Files affected: SOURCES: fbsplash-0.9.2-r5-2.6.14.patch (NONE -> 1.1.2.1) (NEW) ---- Diffs: ================================================================ Index: SOURCES/fbsplash-0.9.2-r5-2.6.14.patch diff -u /dev/null SOURCES/fbsplash-0.9.2-r5-2.6.14.patch:1.1.2.1 --- /dev/null Thu Dec 1 01:57:17 2005 +++ SOURCES/fbsplash-0.9.2-r5-2.6.14.patch Thu Dec 1 01:57:12 2005 @@ -0,0 +1,1774 @@ +diff --git a/Documentation/fb/00-INDEX b/Documentation/fb/00-INDEX +--- a/Documentation/fb/00-INDEX ++++ b/Documentation/fb/00-INDEX +@@ -19,6 +19,8 @@ matroxfb.txt + - info on the Matrox frame buffer driver + pvr2fb.txt + - info on the PowerVR 2 frame buffer driver ++splash.txt ++ - info on the Framebuffer Splash + tgafb.txt + - info on the TGA (DECChip 21030) frame buffer driver + vesafb.txt +diff --git a/Documentation/fb/splash.txt b/Documentation/fb/splash.txt +new file mode 100644 +--- /dev/null ++++ b/Documentation/fb/splash.txt +@@ -0,0 +1,207 @@ ++What is it? ++----------- ++ ++The framebuffer splash is a kernel feature that allows displaying a background ++picture on selected consoles. ++ ++What do I need to get it to work? ++--------------------------------- ++ ++To get fb splash up-and-running you will have to: ++ 1) get a copy of splashutils [1] or a similar program ++ 2) get some splash themes ++ 3) build the kernel helper program ++ 4) build your kernel with the FB_SPLASH option enabled. ++ ++To get fb splash operational right after fbcon initialization is finished, you ++will have to include a theme and the kernel helper into your initramfs image. ++Please refer to splashutils documentation for instructions on how to do that. ++ ++[1] The splashutils package can be downloaded from: ++ http://dev.gentoo.org/~spock/projects/splashutils/ ++ ++The userspace helper ++-------------------- ++ ++The userspace splash helper (by default: /sbin/splash_helper) is called by the ++kernel whenever an important event occurs and the kernel needs some kind of ++job to be carried out. Important events include console switches and graphic ++mode switches (the kernel requests background images and configuration ++parameters for the current console). The splash helper must be accessible at ++all times. If it's not, fbsplash will be switched off automatically. ++ ++It's possible to set path to the splash helper by writing it to ++/proc/sys/kernel/fbsplash. ++ ++***************************************************************************** ++ ++The information below is mostly technical stuff. There's probably no need to ++read it unless you plan to develop a userspace helper. ++ ++The splash protocol ++------------------- ++ ++The splash protocol defines a communication interface between the kernel and ++the userspace splash helper. ++ ++The kernel side is responsible for: ++ ++ o rendering console text, using an image as a background (instead of a ++ standard solid color fbcon uses), ++ o accepting commands from the user via ioctls on the fbsplash device, ++ o calling the userspace helper to set things up as soon as the fb subsystem ++ is initialized. ++ ++The userspace helper is responsible for everything else, including parsing ++configuration files, decompressing the image files whenever the kernel needs ++it, and communicating with the kernel if necessary. ++ ++The splash protocol specifies how communication is done in both ways: ++kernel->userspace and userspace->helper. ++ ++Kernel -> Userspace ++------------------- ++ ++The kernel communicates with the userspace helper by calling it and specifying ++the task to be done in a series of arguments. ++ ++The arguments follow the pattern: ++<splash protocol version> <command> <parameters> ++ ++All commands defined in splash protocol v2 have the following parameters: ++ virtual console ++ framebuffer number ++ theme ++ ++Splash protocol v1 specified an additional 'fbsplash mode' after the ++framebuffer number. Splash protocol v1 is deprecated and should not be used. ++ ++Splash protocol v2 specifies the following commands: ++ ++getpic ++------ ++ The kernel issues this command to request image data. It's up to the userspace ++ helper to find a background image appropriate for the specified theme and the ++ current resolution. The userspace helper should respond by issuing the ++ FBIOSPLASH_SETPIC ioctl. ++ ++init ++---- ++ The kernel issues this command after the fbsplash device is created and ++ the fbsplash interface is initialized. Upon receiving 'init', the userspace ++ helper should parse the kernel command line (/proc/cmdline) or otherwise ++ decide whether fbsplash is to be activated. ++ ++ To activate fbsplash on the first console the helper should issue the ++ FBIOSPLASH_SETCFG, FBIOSPLASH_SETPIC and FBIOSPLASH_SETSTATE commands, ++ in the above-mentioned order. ++ ++ When the userspace helper is called in an early phase of the boot process ++ (right after the initialization of fbcon), no filesystems will be mounted. ++ The helper program should mount sysfs and then create the appropriate ++ framebuffer, fbsplash and tty0 devices (if they don't already exist) to get ++ current display settings and to be able to communicate with the kernel side. ++ It should probably also mount the procfs to be able to parse the kernel ++ command line parameters. ++ ++ Note that the console sem is not held when the kernel calls splash_helper ++ with the 'init' command. The splash helper should perform all ioctls with ++ origin set to FB_SPLASH_IO_ORIG_USER. ++ ++modechange ++---------- ++ The kernel issues this command on a mode change. The helper's response should ++ be similar to the response to the 'init' command. Note that this time the ++ console sem is held and all ioctls must be performed with origin set to ++ FB_SPLASH_IO_ORIG_KERNEL. ++ ++ ++Userspace -> Kernel ++------------------- ++ ++Userspace programs can communicate with fbsplash via ioctls on the fbsplash ++device. These ioctls are to be used by both the userspace helper (called ++only by the kernel) and userspace configuration tools (run by the users). ++ ++The splash helper should set the origin field to FB_SPLASH_IO_ORIG_KERNEL ++when doing the appropriate ioctls. All userspace configuration tools should ++use FB_SPLASH_IO_ORIG_USER. Failure to set the appropriate value in the origin ++field when performing ioctls from the kernel helper will most likely result ++in a console deadlock. ++ ++FB_SPLASH_IO_ORIG_KERNEL instructs fbsplash not to try to acquire the console ++semaphore. Not surprisingly, FB_SPLASH_IO_ORIG_USER instructs it to acquire ++the console sem. ++ ++The framebuffer splash provides the following ioctls (all defined in ++linux/fb.h): ++ ++FBIOSPLASH_SETPIC ++description: loads a background picture for a virtual console ++argument: struct fb_splash_iowrapper*; data: struct fb_image* ++notes: ++If called for consoles other than the current foreground one, the picture data ++will be ignored. ++ ++If the current virtual console is running in a 8-bpp mode, the cmap substruct ++of fb_image has to be filled appropriately: start should be set to 16 (first ++16 colors are reserved for fbcon), len to a value <= 240 and red, green and ++blue should point to valid cmap data. The transp field is ingored. The fields ++dx, dy, bg_color, fg_color in fb_image are ignored as well. ++ ++FBIOSPLASH_SETCFG ++description: sets the fbsplash config for a virtual console ++argument: struct fb_splash_iowrapper*; data: struct vc_splash* ++notes: The structure has to be filled with valid data. ++ ++FBIOSPLASH_GETCFG ++description: gets the fbsplash config for a virtual console ++argument: struct fb_splash_iowrapper*; data: struct vc_splash* ++ ++FBIOSPLASH_SETSTATE ++description: sets the fbsplash state for a virtual console ++argument: struct fb_splash_iowrapper*; data: unsigned int* ++ values: 0 = disabled, 1 = enabled. ++ ++FBIOSPLASH_GETSTATE ++description: gets the fbsplash state for a virtual console ++argument: struct fb_splash_iowrapper*; data: unsigned int* ++ values: as in FBIOSPLASH_SETSTATE ++ ++Info on used structures: ++ ++Definition of struct vc_splash can be found in linux/console_splash.h. It's ++heavily commented. Note that the 'theme' field should point to a string ++no longer than FB_SPLASH_THEME_LEN. When FBIOSPLASH_GETCFG call is ++performed, the theme field should point to a char buffer of length ++FB_SPLASH_THEME_LEN. ++ ++Definition of struct fb_splash_iowrapper can be found in linux/fb.h. ++The fields in this struct have the following meaning: ++ ++vc: ++Virtual console number. ++ ++origin: ++Specifies if the ioctl is performed as a response to a kernel request. The ++splash helper should set this field to FB_SPLASH_IO_ORIG_KERNEL, userspace ++programs should set it to FB_SPLASH_IO_ORIG_USER. This field is necessary to ++avoid console semaphore deadlocks. ++ ++data: ++Pointer to a data structure appropriate for the performed ioctl. Type of ++the data struct is specified in the ioctls description. ++ ++***************************************************************************** ++ ++Credit ++------ ++ ++Original 'bootsplash' project & implementation by: ++ Volker Poplawski <[EMAIL PROTECTED]>, Stefan Reinauer <[EMAIL PROTECTED]>, ++ Steffen Winterfeldt <[EMAIL PROTECTED]>, Michael Schroeder <[EMAIL PROTECTED]>, ++ Ken Wimer <[EMAIL PROTECTED]>. ++ ++Fbsplash, splash protocol design, current implementation & docs by: ++ Michael Januszewski <[EMAIL PROTECTED]> ++ +diff --git a/drivers/Makefile b/drivers/Makefile +--- a/drivers/Makefile ++++ b/drivers/Makefile +@@ -7,16 +7,15 @@ + + obj-$(CONFIG_PCI) += pci/ + obj-$(CONFIG_PARISC) += parisc/ ++# char/ comes before serial/ etc so that the VT console is the boot-time ++# default. ++obj-y += char/ + obj-y += video/ + obj-$(CONFIG_ACPI) += acpi/ + # PnP must come after ACPI since it will eventually need to check if acpi + # was used and do nothing if so + obj-$(CONFIG_PNP) += pnp/ + +-# char/ comes before serial/ etc so that the VT console is the boot-time +-# default. +-obj-y += char/ +- + obj-$(CONFIG_CONNECTOR) += connector/ + + # i810fb and intelfb depend on char/agp/ +diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig +--- a/drivers/video/Kconfig ++++ b/drivers/video/Kconfig +@@ -792,7 +792,6 @@ config FB_MATROX + select FB_CFB_COPYAREA + select FB_CFB_IMAGEBLIT + select FB_SOFT_CURSOR +- select FB_TILEBLITTING + select FB_MACMODES if PPC_PMAC + ---help--- + Say Y here if you have a Matrox Millennium, Matrox Millennium II, +@@ -1576,5 +1575,15 @@ if FB && SYSFS + source "drivers/video/backlight/Kconfig" + endif + +-endmenu ++config FB_SPLASH ++ bool "Support for the framebuffer splash" ++ depends on FRAMEBUFFER_CONSOLE=y && !FB_TILEBLITTING ++ default n ++ ---help--- ++ This option enables support for the Linux boot-up splash screen and ++ graphical backgrounds on consoles. Note that you will need userspace ++ splash utilities in order to take advantage of these features. Refer ++ to Documentation/fb/splash.txt for more information. + ++ If unsure, say N. ++endmenu +diff --git a/drivers/video/Makefile b/drivers/video/Makefile +--- a/drivers/video/Makefile ++++ b/drivers/video/Makefile +@@ -7,6 +7,7 @@ + obj-$(CONFIG_VT) += console/ + obj-$(CONFIG_LOGO) += logo/ + obj-$(CONFIG_SYSFS) += backlight/ ++obj-$(CONFIG_FB_SPLASH) += fbsplash.o cfbsplash.o + + obj-$(CONFIG_FB) += fb.o + fb-y := fbmem.o fbmon.o fbcmap.o fbsysfs.o \ +diff --git a/drivers/video/cfbsplash.c b/drivers/video/cfbsplash.c +new file mode 100644 +--- /dev/null ++++ b/drivers/video/cfbsplash.c +@@ -0,0 +1,472 @@ ++/* ++ * linux/drivers/video/cfbsplash.c -- Framebuffer splash render functions ++ * ++ * Copyright (C) 2004 Michal Januszewski <[EMAIL PROTECTED]> ++ * ++ * Code based upon "Bootsplash" (C) 2001-2003 ++ * Volker Poplawski <[EMAIL PROTECTED]>, ++ * Stefan Reinauer <[EMAIL PROTECTED]>, ++ * Steffen Winterfeldt <[EMAIL PROTECTED]>, ++ * Michael Schroeder <[EMAIL PROTECTED]>, ++ * Ken Wimer <[EMAIL PROTECTED]>. ++ * ++ * This file is subject to the terms and conditions of the GNU General Public ++ * License. See the file COPYING in the main directory of this archive for ++ * more details. ++ */ ++#include <linux/config.h> ++#include <linux/module.h> ++#include <linux/types.h> ++#include <linux/fb.h> ++#include <linux/selection.h> ++#include <linux/vt_kern.h> ++#include <asm/irq.h> ++#include <asm/system.h> ++ ++#include "console/fbcon.h" ++#include "fbsplash.h" ++ ++#define parse_pixel(shift,bpp,type) \ ++ do { \ ++ if (d & (0x80 >> (shift))) \ ++ dd2[(shift)] = fgx; \ ++ else \ ++ dd2[(shift)] = transparent ? *(type *)splash_src : bgx; \ ++ splash_src += (bpp); \ ++ } while (0) \ ++ ++extern int get_color(struct vc_data *vc, struct fb_info *info, ++ u16 c, int is_fg); ++ ++void fbsplash_fix_pseudo_pal(struct fb_info *info, struct vc_data *vc) ++{ ++ int i, j, k; ++ int minlen = min(min(info->var.red.length, info->var.green.length), ++ info->var.blue.length); ++ u32 col; ++ ++ for (j = i = 0; i < 16; i++) { ++ k = color_table[i]; ++ ++ col = ((vc->vc_palette[j++] >> (8-minlen)) ++ << info->var.red.offset); ++ col |= ((vc->vc_palette[j++] >> (8-minlen)) ++ << info->var.green.offset); ++ col |= ((vc->vc_palette[j++] >> (8-minlen)) ++ << info->var.blue.offset); ++ ((u32 *)info->pseudo_palette)[k] = col; ++ } ++} ++ ++void fbsplash_renderc(struct fb_info *info, int ypos, int xpos, int height, ++ int width, u8* src, u32 fgx, u32 bgx, u8 transparent) ++{ ++ unsigned int x, y; ++ u32 dd; ++ int bytespp = ((info->var.bits_per_pixel + 7) >> 3); ++ unsigned int d = ypos * info->fix.line_length + xpos * bytespp; ++ unsigned int ds = (ypos * info->var.xres + xpos) * bytespp; ++ u16 dd2[4]; ++ ++ u8* splash_src = (u8 *)(info->splash.data + ds); ++ u8* dst = (u8 *)(info->screen_base + d); ++ ++ if ((ypos + height) > info->var.yres || (xpos + width) > info->var.xres) ++ return; ++ ++ for (y = 0; y < height; y++) { ++ switch (info->var.bits_per_pixel) { ++ ++ case 32: ++ for (x = 0; x < width; x++) { ++ ++ if ((x & 7) == 0) ++ d = *src++; ++ if (d & 0x80) ++ dd = fgx; ++ else ++ dd = transparent ? ++ *(u32 *)splash_src : bgx; ++ ++ d <<= 1; ++ splash_src += 4; ++ fb_writel(dd, dst); ++ dst += 4; ++ } ++ break; ++ case 24: ++ for (x = 0; x < width; x++) { ++ ++ if ((x & 7) == 0) ++ d = *src++; ++ if (d & 0x80) ++ dd = fgx; ++ else ++ dd = transparent ? ++ (*(u32 *)splash_src & 0xffffff) : bgx; ++ ++ d <<= 1; ++ splash_src += 3; ++#ifdef __LITTLE_ENDIAN ++ fb_writew(dd & 0xffff, dst); ++ dst += 2; ++ fb_writeb((dd >> 16), dst); ++#else ++ fb_writew(dd >> 8, dst); ++ dst += 2; ++ fb_writeb(dd & 0xff, dst); ++#endif ++ dst++; ++ } ++ break; ++ case 16: ++ for (x = 0; x < width; x += 2) { ++ if ((x & 7) == 0) ++ d = *src++; ++ ++ parse_pixel(0, 2, u16); ++ parse_pixel(1, 2, u16); ++#ifdef __LITTLE_ENDIAN ++ dd = dd2[0] | (dd2[1] << 16); ++#else ++ dd = dd2[1] | (dd2[0] << 16); ++#endif ++ d <<= 2; ++ fb_writel(dd, dst); ++ dst += 4; ++ } ++ break; ++ ++ case 8: ++ for (x = 0; x < width; x += 4) { ++ if ((x & 7) == 0) ++ d = *src++; ++ ++ parse_pixel(0, 1, u8); ++ parse_pixel(1, 1, u8); ++ parse_pixel(2, 1, u8); ++ parse_pixel(3, 1, u8); ++ ++#ifdef __LITTLE_ENDIAN ++ dd = dd2[0] | (dd2[1] << 8) | (dd2[2] << 16) | (dd2[3] << 24); ++#else ++ dd = dd2[3] | (dd2[2] << 8) | (dd2[1] << 16) | (dd2[0] << 24); ++#endif ++ d <<= 4; ++ fb_writel(dd, dst); ++ dst += 4; ++ } ++ } ++ ++ dst += info->fix.line_length - width * bytespp; ++ splash_src += (info->var.xres - width) * bytespp; ++ } ++} ++ ++#define cc2cx(a) \ ++ ((info->fix.visual == FB_VISUAL_TRUECOLOR || \ ++ info->fix.visual == FB_VISUAL_DIRECTCOLOR) ? \ ++ ((u32*)info->pseudo_palette)[a] : a) ++ ++void fbsplash_putcs(struct vc_data *vc, struct fb_info *info, ++ const unsigned short *s, int count, int yy, int xx) ++{ ++ unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff; ++ struct fbcon_ops *ops = info->fbcon_par; ++ int fg_color, bg_color, transparent; ++ u8 *src; ++ u32 bgx, fgx; ++ u16 c = scr_readw(s); ++ ++ fg_color = get_color(vc, info, c, 1); ++ bg_color = get_color(vc, info, c, 0); ++ ++ /* Don't paint the background image if console is blanked */ ++ transparent = ops->blank_state ? 0 : ++ (vc->vc_splash.bg_color == bg_color); ++ ++ xx = xx * vc->vc_font.width + vc->vc_splash.tx; ++ yy = yy * vc->vc_font.height + vc->vc_splash.ty; ++ ++ fgx = cc2cx(fg_color); ++ bgx = cc2cx(bg_color); ++ ++ while (count--) { ++ c = scr_readw(s++); ++ src = vc->vc_font.data + (c & charmask) * vc->vc_font.height * ++ ((vc->vc_font.width + 7) >> 3); ++ ++ fbsplash_renderc(info, yy, xx, vc->vc_font.height, ++ vc->vc_font.width, src, fgx, bgx, transparent); ++ xx += vc->vc_font.width; ++ } ++} ++ ++void fbsplash_cursor(struct fb_info *info, struct fb_cursor *cursor) ++{ ++ int i; ++ unsigned int dsize, s_pitch; ++ struct fbcon_ops *ops = info->fbcon_par; ++ struct vc_data* vc; ++ u8 *src; ++ ++ /* we really don't need any cursors while the console is blanked */ ++ if (info->state != FBINFO_STATE_RUNNING || ops->blank_state) ++ return; ++ ++ vc = vc_cons[ops->currcon].d; ++ ++ src = kmalloc(64 + sizeof(struct fb_image), GFP_ATOMIC); ++ if (!src) ++ return; ++ ++ s_pitch = (cursor->image.width + 7) >> 3; ++ dsize = s_pitch * cursor->image.height; ++ if (cursor->enable) { ++ switch (cursor->rop) { ++ case ROP_XOR: ++ for (i = 0; i < dsize; i++) ++ src[i] = cursor->image.data[i] ^ cursor->mask[i]; ++ break; ++ case ROP_COPY: ++ default: ++ for (i = 0; i < dsize; i++) ++ src[i] = cursor->image.data[i] & cursor->mask[i]; ++ break; ++ } ++ } else ++ memcpy(src, cursor->image.data, dsize); ++ ++ fbsplash_renderc(info, ++ cursor->image.dy + vc->vc_splash.ty, ++ cursor->image.dx + vc->vc_splash.tx, ++ cursor->image.height, ++ cursor->image.width, ++ (u8*)src, ++ cc2cx(cursor->image.fg_color), ++ cc2cx(cursor->image.bg_color), ++ cursor->image.bg_color == vc->vc_splash.bg_color); ++ ++ kfree(src); ++} ++ ++static void splashset(u8 *dst, int height, int width, int dstbytes, ++ u32 bgx, int bpp) ++{ ++ int i; ++ ++ if (bpp == 8) ++ bgx |= bgx << 8; ++ if (bpp == 16 || bpp == 8) ++ bgx |= bgx << 16; ++ ++ while (height-- > 0) { ++ u8 *p = dst; ++ ++ switch (bpp) { ++ ++ case 32: ++ for (i=0; i < width; i++) { ++ fb_writel(bgx, p); p += 4; ++ } ++ break; ++ case 24: ++ for (i=0; i < width; i++) { ++#ifdef __LITTLE_ENDIAN ++ fb_writew((bgx & 0xffff),(u16*)p); p += 2; ++ fb_writeb((bgx >> 16),p++); ++#else ++ fb_writew((bgx >> 8),(u16*)p); p += 2; ++ fb_writeb((bgx & 0xff),p++); ++#endif ++ } ++ case 16: ++ for (i=0; i < width/4; i++) { ++ fb_writel(bgx,p); p += 4; ++ fb_writel(bgx,p); p += 4; ++ } ++ if (width & 2) { ++ fb_writel(bgx,p); p += 4; ++ } ++ if (width & 1) ++ fb_writew(bgx,(u16*)p); ++ break; ++ case 8: ++ for (i=0; i < width/4; i++) { ++ fb_writel(bgx,p); p += 4; ++ } ++ ++ if (width & 2) { ++ fb_writew(bgx,p); p += 2; <<Diff was trimmed, longer than 597 lines>> _______________________________________________ pld-cvs-commit mailing list [email protected] http://lists.pld-linux.org/mailman/listinfo/pld-cvs-commit
