]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blame - src/patches/bootsplash-3.1.6-2.6.15.diff
projects / people / pmueller / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Hinzugefuegt:
[people/pmueller/ipfire-2.x.git] / src / patches / bootsplash-3.1.6-2.6.15.diff
CommitLineData
c3e36980
MT		 1diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/char/keyboard.c linux-2.6.15-VinX/drivers/char/keyboard.c
2--- linux-2.6.15/drivers/char/keyboard.c 2006-01-03 04:21:10.000000000 +0100
3+++ linux-2.6.15-VinX/drivers/char/keyboard.c 2006-01-05 01:17:07.000000000 +0100
4@@ -1062,6 +1062,15 @@ static void kbd_keycode(unsigned int key
5 if (keycode < BTN_MISC)
6 printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
7
8+#ifdef CONFIG_BOOTSPLASH
9+ /* This code has to be redone for some non-x86 platforms */
10+ if (down == 1 && (keycode == 0x3c || keycode == 0x01)) { /* F2 and ESC on PC keyboard */
11+ extern int splash_verbose(void);
12+ if (splash_verbose())
13+ return;
14+ }
15+#endif
16+
17 #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
18 if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
19 sysrq_down = down;
20diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/char/n_tty.c linux-2.6.15-VinX/drivers/char/n_tty.c
21--- linux-2.6.15/drivers/char/n_tty.c 2006-01-03 04:21:10.000000000 +0100
22+++ linux-2.6.15-VinX/drivers/char/n_tty.c 2006-01-05 01:17:07.000000000 +0100
23@@ -1292,6 +1292,15 @@ do_it_again:
24 tty->minimum_to_wake = (minimum - (b - buf));
25
26 if (!input_available_p(tty, 0)) {
27+#ifdef CONFIG_BOOTSPLASH
28+ if (file->f_dentry->d_inode->i_rdev == MKDEV(TTY_MAJOR,0) ||
29+ file->f_dentry->d_inode->i_rdev == MKDEV(TTY_MAJOR,1) ||
30+ file->f_dentry->d_inode->i_rdev == MKDEV(TTYAUX_MAJOR,0) ||
31+ file->f_dentry->d_inode->i_rdev == MKDEV(TTYAUX_MAJOR,1)) {
32+ extern int splash_verbose(void);
33+ (void)splash_verbose();
34+ }
35+#endif
36 if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
37 retval = -EIO;
38 break;
39diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/char/vt.c linux-2.6.15-VinX/drivers/char/vt.c
40--- linux-2.6.15/drivers/char/vt.c 2006-01-03 04:21:10.000000000 +0100
41+++ linux-2.6.15-VinX/drivers/char/vt.c 2006-01-05 01:17:07.000000000 +0100
42@@ -3260,6 +3260,31 @@ void vcs_scr_writew(struct vc_data *vc,
43 }
44 }
45
46+#ifdef CONFIG_BOOTSPLASH
47+void con_remap_def_color(struct vc_data *vc, int new_color)
48+{
49+ unsigned short *sbuf = vc->vc_screenbuf;
50+ unsigned c, len = vc->vc_screenbuf_size >> 1;
51+ int old_color;
52+
53+ if (sbuf) {
54+ old_color = vc->vc_def_color << 8;
55+ new_color <<= 8;
56+ while(len--) {
57+ c = *sbuf;
58+ if (((c ^ old_color) & 0xf000) == 0)
59+ *sbuf ^= (old_color ^ new_color) & 0xf000;
60+ if (((c ^ old_color) & 0x0f00) == 0)
61+ *sbuf ^= (old_color ^ new_color) & 0x0f00;
62+ sbuf++;
63+ }
64+ new_color >>= 8;
65+ }
66+ vc->vc_def_color = vc->vc_color = new_color;
67+ update_attr(vc);
68+}
69+#endif
70+
71 /*
72 * Visible symbols for modules
73 */
74diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/Kconfig linux-2.6.15-VinX/drivers/video/Kconfig
75--- linux-2.6.15/drivers/video/Kconfig 2006-01-03 04:21:10.000000000 +0100
76+++ linux-2.6.15-VinX/drivers/video/Kconfig 2006-01-05 01:17:11.000000000 +0100
77@@ -1469,5 +1469,9 @@ if FB && SYSFS
78 source "drivers/video/backlight/Kconfig"
79 endif
80
81+if FB
82+ source "drivers/video/bootsplash/Kconfig"
83+endif
84+
85 endmenu
86
87diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/Makefile linux-2.6.15-VinX/drivers/video/Makefile
88--- linux-2.6.15/drivers/video/Makefile 2006-01-03 04:21:10.000000000 +0100
89+++ linux-2.6.15-VinX/drivers/video/Makefile 2006-01-05 01:17:11.000000000 +0100
90@@ -7,6 +7,7 @@
91 obj-$(CONFIG_VT) += console/
92 obj-$(CONFIG_LOGO) += logo/
93 obj-$(CONFIG_SYSFS) += backlight/
94+obj-$(CONFIG_BOOTSPLASH) += bootsplash/
95
96 obj-$(CONFIG_FB) += fb.o
97 fb-y := fbmem.o fbmon.o fbcmap.o fbsysfs.o \
98diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/bootsplash/Kconfig linux-2.6.15-VinX/drivers/video/bootsplash/Kconfig
99--- linux-2.6.15/drivers/video/bootsplash/Kconfig 1970-01-01 01:00:00.000000000 +0100
100+++ linux-2.6.15-VinX/drivers/video/bootsplash/Kconfig 2006-01-05 01:17:11.000000000 +0100
101@@ -0,0 +1,17 @@
102+#
103+# Bootsplash configuration
104+#
105+
106+menu "Bootsplash configuration"
107+
108+config BOOTSPLASH
109+ bool "Bootup splash screen"
110+ depends on FRAMEBUFFER_CONSOLE && FB_VESA
111+ default n
112+ ---help---
113+ This option enables the Linux bootsplash screen. For more
114+ information on the bootsplash screen have a look at
115+ http://www.bootsplash.org/.
116+ If you are unsure, say N
117+endmenu
118+
119diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/bootsplash/Makefile linux-2.6.15-VinX/drivers/video/bootsplash/Makefile
120--- linux-2.6.15/drivers/video/bootsplash/Makefile 1970-01-01 01:00:00.000000000 +0100
121+++ linux-2.6.15-VinX/drivers/video/bootsplash/Makefile 2006-01-05 01:17:11.000000000 +0100
122@@ -0,0 +1,5 @@
123+# Makefile for the Linux bootsplash
124+
125+obj-$(CONFIG_BOOTSPLASH) += bootsplash.o
126+obj-$(CONFIG_BOOTSPLASH) += decode-jpg.o
127+obj-$(CONFIG_BOOTSPLASH) += render.o
128diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/bootsplash/bootsplash.c linux-2.6.15-VinX/drivers/video/bootsplash/bootsplash.c
129--- linux-2.6.15/drivers/video/bootsplash/bootsplash.c 1970-01-01 01:00:00.000000000 +0100
130+++ linux-2.6.15-VinX/drivers/video/bootsplash/bootsplash.c 2006-01-05 01:17:09.000000000 +0100
131@@ -0,0 +1,984 @@
132+/*
133+ * linux/drivers/video/bootsplash/bootsplash.c -
134+ * splash screen handling functions.
135+ *
136+ * (w) 2001-2004 by Volker Poplawski, <volker@poplawski.de>,
137+ * Stefan Reinauer, <stepan@suse.de>,
138+ * Steffen Winterfeldt, <snwint@suse.de>,
139+ * Michael Schroeder <mls@suse.de>
140+ *
141+ * Ideas & SuSE screen work by Ken Wimer, <wimer@suse.de>
142+ *
143+ * For more information on this code check http://www.bootsplash.org/
144+ */
145+
146+#include <linux/config.h>
147+#include <linux/module.h>
148+#include <linux/types.h>
149+#include <linux/fb.h>
150+#include <linux/vt_kern.h>
151+#include <linux/vmalloc.h>
152+#include <linux/unistd.h>
153+#include <linux/syscalls.h>
154+
155+#include <asm/irq.h>
156+#include <asm/system.h>
157+
158+#include "../console/fbcon.h"
159+#include "bootsplash.h"
160+#include "decode-jpg.h"
161+
162+/* extern struct fb_ops vesafb_ops; */
163+extern signed char con2fb_map[MAX_NR_CONSOLES];
164+
165+#define SPLASH_VERSION "3.1.6-2004/03/31"
166+
167+/* These errors have to match fbcon-jpegdec.h */
168+static unsigned char *jpg_errors[] = {
169+ "no SOI found",
170+ "not 8 bit",
171+ "height mismatch",
172+ "width mismatch",
173+ "bad width or height",
174+ "too many COMPPs",
175+ "illegal HV",
176+ "quant table selector",
177+ "picture is not YCBCR 221111",
178+ "unknow CID in scan",
179+ "dct not sequential",
180+ "wrong marker",
181+ "no EOI",
182+ "bad tables",
183+ "depth mismatch"
184+};
185+
186+static struct jpeg_decdata *decdata = 0; /* private decoder data */
187+
188+static int splash_registered = 0;
189+static int splash_usesilent = 0; /* shall we display the silentjpeg? */
190+int splash_default = 0xf01;
191+
192+static int splash_check_jpeg(unsigned char *jpeg, int width, int height, int depth);
193+
194+static int __init splash_setup(char *options)
195+{
196+ if(!strncmp("silent", options, 6)) {
197+ printk(KERN_INFO "bootsplash: silent mode.\n");
198+ splash_usesilent = 1;
199+ /* skip "silent," */
200+ if (strlen(options) == 6)
201+ return 0;
202+ options += 7;
203+ }
204+ if(!strncmp("verbose", options, 7)) {
205+ printk(KERN_INFO "bootsplash: verbose mode.\n");
206+ splash_usesilent = 0;
207+ return 0;
208+ }
209+ splash_default = simple_strtoul(options, NULL, 0);
210+ return 0;
211+}
212+
213+__setup("splash=", splash_setup);
214+
215+
216+static int splash_hasinter(unsigned char *buf, int num)
217+{
218+ unsigned char *bufend = buf + num * 12;
219+ while(buf < bufend) {
220+ if (buf[1] > 127) /* inter? */
221+ return 1;
222+ buf += buf[3] > 127 ? 24 : 12; /* blend? */
223+ }
224+ return 0;
225+}
226+
227+static int boxextract(unsigned char *buf, unsigned short *dp, unsigned char *cols, int *blendp)
228+{
229+ dp[0] = buf[0] | buf[1] << 8;
230+ dp[1] = buf[2] | buf[3] << 8;
231+ dp[2] = buf[4] | buf[5] << 8;
232+ dp[3] = buf[6] | buf[7] << 8;
233+ *(unsigned int *)(cols + 0) =
234+ *(unsigned int *)(cols + 4) =
235+ *(unsigned int *)(cols + 8) =
236+ *(unsigned int *)(cols + 12) = *(unsigned int *)(buf + 8);
237+ if (dp[1] > 32767) {
238+ dp[1] = ~dp[1];
239+ *(unsigned int *)(cols + 4) = *(unsigned int *)(buf + 12);
240+ *(unsigned int *)(cols + 8) = *(unsigned int *)(buf + 16);
241+ *(unsigned int *)(cols + 12) = *(unsigned int *)(buf + 20);
242+ *blendp = 1;
243+ return 24;
244+ }
245+ return 12;
246+}
247+
248+static void boxit(unsigned char *pic, int bytes, unsigned char *buf, int num, int percent, int overpaint)
249+{
250+ int x, y, i, p, doblend, r, g, b, a, add;
251+ unsigned short data1[4];
252+ unsigned char cols1[16];
253+ unsigned short data2[4];
254+ unsigned char cols2[16];
255+ unsigned char *bufend;
256+ unsigned short *picp;
257+ unsigned int stipple[32], sti, stin, stinn, stixs, stixe, stiys, stiye;
258+ int xs, xe, ys, ye, xo, yo;
259+
260+ if (num == 0)
261+ return;
262+ bufend = buf + num * 12;
263+ stipple[0] = 0xffffffff;
264+ stin = 1;
265+ stinn = 0;
266+ stixs = stixe = 0;
267+ stiys = stiye = 0;
268+ while(buf < bufend) {
269+ doblend = 0;
270+ buf += boxextract(buf, data1, cols1, &doblend);
271+ if (data1[0] == 32767 && data1[1] == 32767) {
272+ /* box stipple */
273+ if (stinn == 32)
274+ continue;
275+ if (stinn == 0) {
276+ stixs = data1[2];
277+ stixe = data1[3];
278+ stiys = stiye = 0;
279+ } else if (stinn == 4) {
280+ stiys = data1[2];
281+ stiye = data1[3];
282+ }
283+ stipple[stinn++] = (cols1[ 0] << 24) | (cols1[ 1] << 16) | (cols1[ 2] << 8) | cols1[ 3] ;
284+ stipple[stinn++] = (cols1[ 4] << 24) | (cols1[ 5] << 16) | (cols1[ 6] << 8) | cols1[ 7] ;
285+ stipple[stinn++] = (cols1[ 8] << 24) | (cols1[ 9] << 16) | (cols1[10] << 8) | cols1[11] ;
286+ stipple[stinn++] = (cols1[12] << 24) | (cols1[13] << 16) | (cols1[14] << 8) | cols1[15] ;
287+ stin = stinn;
288+ continue;
289+ }
290+ stinn = 0;
291+ if (data1[0] > 32767)
292+ buf += boxextract(buf, data2, cols2, &doblend);
293+ if (data1[0] == 32767 && data1[1] == 32766) {
294+ /* box copy */
295+ i = 12 * (short)data1[3];
296+ doblend = 0;
297+ i += boxextract(buf + i, data1, cols1, &doblend);
298+ if (data1[0] > 32767)
299+ boxextract(buf + i, data2, cols2, &doblend);
300+ }
301+ if (data1[0] == 32767)
302+ continue;
303+ if (data1[2] > 32767) {
304+ if (overpaint)
305+ continue;
306+ data1[2] = ~data1[2];
307+ }
308+ if (data1[3] > 32767) {
309+ if (percent == 65536)
310+ continue;
311+ data1[3] = ~data1[3];
312+ }
313+ if (data1[0] > 32767) {
314+ data1[0] = ~data1[0];
315+ for (i = 0; i < 4; i++)
316+ data1[i] = (data1[i] * (65536 - percent) + data2[i] * percent) >> 16;
317+ for (i = 0; i < 16; i++)
318+ cols1[i] = (cols1[i] * (65536 - percent) + cols2[i] * percent) >> 16;
319+ }
320+ *(unsigned int *)cols2 = *(unsigned int *)cols1;
321+ a = cols2[3];
322+ if (a == 0 && !doblend)
323+ continue;
324+
325+ if (stixs >= 32768) {
326+ xo = xs = (stixs ^ 65535) + data1[0];
327+ xe = stixe ? stixe + data1[0] : data1[2];
328+ } else if (stixe >= 32768) {
329+ xs = stixs ? data1[2] - stixs : data1[0];
330+ xe = data1[2] - (stixe ^ 65535);
331+ xo = xe + 1;
332+ } else {
333+ xo = xs = stixs;
334+ xe = stixe ? stixe : data1[2];
335+ }
336+ if (stiys >= 32768) {
337+ yo = ys = (stiys ^ 65535) + data1[1];
338+ ye = stiye ? stiye + data1[1] : data1[3];
339+ } else if (stiye >= 32768) {
340+ ys = stiys ? data1[3] - stiys : data1[1];
341+ ye = data1[3] - (stiye ^ 65535);
342+ yo = ye + 1;
343+ } else {
344+ yo = ys = stiys;
345+ ye = stiye ? stiye : data1[3];
346+ }
347+ xo = 32 - (xo & 31);
348+ yo = stin - (yo % stin);
349+ if (xs < data1[0])
350+ xs = data1[0];
351+ if (xe > data1[2])
352+ xe = data1[2];
353+ if (ys < data1[1])
354+ ys = data1[1];
355+ if (ye > data1[3])
356+ ye = data1[3];
357+
358+ for (y = ys; y <= ye; y++) {
359+ sti = stipple[(y + yo) % stin];
360+ x = (xs + xo) & 31;
361+ if (x)
362+ sti = (sti << x) | (sti >> (32 - x));
363+ if (doblend) {
364+ if ((p = data1[3] - data1[1]) != 0)
365+ p = ((y - data1[1]) << 16) / p;
366+ for (i = 0; i < 8; i++)
367+ cols2[i + 8] = (cols1[i] * (65536 - p) + cols1[i + 8] * p) >> 16;
368+ }
369+ add = (xs & 1);
370+ add ^= (add ^ y) & 1 ? 1 : 3; /* 2x2 ordered dithering */
371+ picp = (unsigned short *)(pic + xs * 2 + y * bytes);
372+ for (x = xs; x <= xe; x++) {
373+ if (!(sti & 0x80000000)) {
374+ sti <<= 1;
375+ picp++;
376+ add ^= 3;
377+ continue;
378+ }
379+ sti = (sti << 1) | 1;
380+ if (doblend) {
381+ if ((p = data1[2] - data1[0]) != 0)
382+ p = ((x - data1[0]) << 16) / p;
383+ for (i = 0; i < 4; i++)
384+ cols2[i] = (cols2[i + 8] * (65536 - p) + cols2[i + 12] * p) >> 16;
385+ a = cols2[3];
386+ }
387+ r = cols2[0];
388+ g = cols2[1];
389+ b = cols2[2];
390+ if (a != 255) {
391+ i = *picp;
392+ r = ((i >> 8 & 0xf8) * (255 - a) + r * a) / 255;
393+ g = ((i >> 3 & 0xfc) * (255 - a) + g * a) / 255;
394+ b = ((i << 3 & 0xf8) * (255 - a) + b * a) / 255;
395+ }
396+ #define CLAMP(x) ((x) >= 256 ? 255 : (x))
397+ i = ((CLAMP(r + add*2+1) & 0xf8) << 8) |
398+ ((CLAMP(g + add ) & 0xfc) << 3) |
399+ ((CLAMP(b + add*2+1) ) >> 3);
400+ *picp++ = i;
401+ add ^= 3;
402+ }
403+ }
404+ }
405+}
406+
407+static int splash_check_jpeg(unsigned char *jpeg, int width, int height, int depth)
408+{
409+ int size, err;
410+ unsigned char *mem;
411+
412+ size = ((width + 15) & ~15) * ((height + 15) & ~15) * (depth >> 3);
413+ mem = vmalloc(size);
414+ if (!mem) {
415+ printk(KERN_INFO "bootsplash: no memory for decoded picture.\n");
416+ return -1;
417+ }
418+ if (!decdata)
419+ decdata = vmalloc(sizeof(*decdata));
420+ if ((err = jpeg_decode(jpeg, mem, ((width + 15) & ~15), ((height + 15) & ~15), depth, decdata)))
421+ printk(KERN_INFO "bootsplash: error while decompressing picture: %s (%d)\n",jpg_errors[err - 1], err);
422+ vfree(mem);
423+ return err ? -1 : 0;
424+}
425+
426+static void splash_free(struct vc_data *vc, struct fb_info *info)
427+{
428+ if (!vc->vc_splash_data)
429+ return;
430+ if (info->silent_screen_base)
431+ info->screen_base = info->silent_screen_base;
432+ info->silent_screen_base = 0;
433+ if (vc->vc_splash_data->splash_silentjpeg)
434+ vfree(vc->vc_splash_data->splash_sboxes);
435+ vfree(vc->vc_splash_data);
436+ vc->vc_splash_data = 0;
437+ info->splash_data = 0;
438+}
439+
440+static int splash_mkpenguin(struct splash_data *data, int pxo, int pyo, int pwi, int phe, int pr, int pg, int pb)
441+{
442+ unsigned char *buf;
443+ int i;
444+
445+ if (pwi ==0 || phe == 0)
446+ return 0;
447+ buf = (unsigned char *)data + sizeof(*data);
448+ pwi += pxo - 1;
449+ phe += pyo - 1;
450+ *buf++ = pxo;
451+ *buf++ = pxo >> 8;
452+ *buf++ = pyo;
453+ *buf++ = pyo >> 8;
454+ *buf++ = pwi;
455+ *buf++ = pwi >> 8;
456+ *buf++ = phe;
457+ *buf++ = phe >> 8;
458+ *buf++ = pr;
459+ *buf++ = pg;
460+ *buf++ = pb;
461+ *buf++ = 0;
462+ for (i = 0; i < 12; i++, buf++)
463+ *buf = buf[-12];
464+ buf[-24] ^= 0xff;
465+ buf[-23] ^= 0xff;
466+ buf[-1] = 0xff;
467+ return 2;
468+}
469+
470+static const int splash_offsets[3][16] = {
471+ /* len, unit, size, state, fgcol, col, xo, yo, wi, he
472+ boxcnt, ssize, sboxcnt, percent, overok, palcnt */
473+ /* V1 */
474+ { 20, -1, 16, -1, -1, -1, 8, 10, 12, 14,
475+ -1, -1, -1, -1, -1, -1 },
476+ /* V2 */
477+ { 35, 8, 12, 9, 10, 11, 16, 18, 20, 22,
478+ -1, -1, -1, -1, -1, -1 },
479+ /* V3 */
480+ { 38, 8, 12, 9, 10, 11, 16, 18, 20, 22,
481+ 24, 28, 32, 34, 36, 37 },
482+};
483+
484+#define SPLASH_OFF_LEN offsets[0]
485+#define SPLASH_OFF_UNIT offsets[1]
486+#define SPLASH_OFF_SIZE offsets[2]
487+#define SPLASH_OFF_STATE offsets[3]
488+#define SPLASH_OFF_FGCOL offsets[4]
489+#define SPLASH_OFF_COL offsets[5]
490+#define SPLASH_OFF_XO offsets[6]
491+#define SPLASH_OFF_YO offsets[7]
492+#define SPLASH_OFF_WI offsets[8]
493+#define SPLASH_OFF_HE offsets[9]
494+#define SPLASH_OFF_BOXCNT offsets[10]
495+#define SPLASH_OFF_SSIZE offsets[11]
496+#define SPLASH_OFF_SBOXCNT offsets[12]
497+#define SPLASH_OFF_PERCENT offsets[13]
498+#define SPLASH_OFF_OVEROK offsets[14]
499+#define SPLASH_OFF_PALCNT offsets[15]
500+
501+static inline int splash_getb(unsigned char *pos, int off)
502+{
503+ return off == -1 ? 0 : pos[off];
504+}
505+
506+static inline int splash_gets(unsigned char *pos, int off)
507+{
508+ return off == -1 ? 0 : pos[off] | pos[off + 1] << 8;
509+}
510+
511+static inline int splash_geti(unsigned char *pos, int off)
512+{
513+ return off == -1 ? 0 :
514+ pos[off] | pos[off + 1] << 8 | pos[off + 2] << 16 | pos[off + 3] << 24;
515+}
516+
517+static int splash_getraw(unsigned char *start, unsigned char *end, int *update)
518+{
519+ unsigned char *ndata;
520+ int version;
521+ int splash_size;
522+ int unit;
523+ int width, height;
524+ int silentsize;
525+ int boxcnt;
526+ int sboxcnt;
527+ int palcnt;
528+ int i, len;
529+ const int *offsets;
530+ struct vc_data *vc;
531+ struct fb_info *info;
532+ struct splash_data *sd;
533+
534+ if (update)
535+ *update = -1;
536+
537+ if (!update || start[7] < '2' || start[7] > '3' || splash_geti(start, 12) != (int)0xffffffff)
538+ printk(KERN_INFO "bootsplash %s: looking for picture...", SPLASH_VERSION);
539+
540+ for (ndata = start; ndata < end; ndata++) {
541+ if (ndata[0] != 'B' || ndata[1] != 'O' || ndata[2] != 'O' || ndata[3] != 'T')
542+ continue;
543+ if (ndata[4] != 'S' || ndata[5] != 'P' || ndata[6] != 'L' || ndata[7] < '1' || ndata[7] > '3')
544+ continue;
545+ version = ndata[7] - '0';
546+ offsets = splash_offsets[version - 1];
547+ len = SPLASH_OFF_LEN;
548+ unit = splash_getb(ndata, SPLASH_OFF_UNIT);
549+ if (unit >= MAX_NR_CONSOLES)
550+ continue;
551+ if (unit) {
552+ vc_allocate(unit);
553+ }
554+ vc = vc_cons[unit].d;
555+ info = registered_fb[(int)con2fb_map[unit]];
556+ width = info->var.xres;
557+ height = info->var.yres;
558+ splash_size = splash_geti(ndata, SPLASH_OFF_SIZE);
559+ if (splash_size == (int)0xffffffff && version > 1) {
560+ if ((sd = vc->vc_splash_data) != 0) {
561+ int up = 0;
562+ i = splash_getb(ndata, SPLASH_OFF_STATE);
563+ if (i != 255) {
564+ sd->splash_state = i;
565+ up = -1;
566+ }
567+ i = splash_getb(ndata, SPLASH_OFF_FGCOL);
568+ if (i != 255) {
569+ sd->splash_fg_color = i;
570+ up = -1;
571+ }
572+ i = splash_getb(ndata, SPLASH_OFF_COL);
573+ if (i != 255) {
574+ sd->splash_color = i;
575+ up = -1;
576+ }
577+ boxcnt = sboxcnt = 0;
578+ if (ndata + len <= end) {
579+ boxcnt = splash_gets(ndata, SPLASH_OFF_BOXCNT);
580+ sboxcnt = splash_gets(ndata, SPLASH_OFF_SBOXCNT);
581+ }
582+ if (boxcnt) {
583+ i = splash_gets(ndata, len);
584+ if (boxcnt + i <= sd->splash_boxcount && ndata + len + 2 + boxcnt * 12 <= end) {
585+
586+ if (splash_geti(ndata, len + 2) != 0x7ffd7fff || !memcmp(ndata + len + 2, sd->splash_boxes + i * 12, 8)) {
587+
588+ memcpy(sd->splash_boxes + i * 12, ndata + len + 2, boxcnt * 12);
589+ up |= 1;
590+ }
591+ }
592+ len += boxcnt * 12 + 2;
593+ }
594+ if (sboxcnt) {
595+ i = splash_gets(ndata, len);
596+ if (sboxcnt + i <= sd->splash_sboxcount && ndata + len + 2 + sboxcnt * 12 <= end) {
597+ if (splash_geti(ndata, len + 2) != 0x7ffd7fff || !memcmp(ndata + len + 2, sd->splash_sboxes + i * 12, 8)) {
598+ memcpy(sd->splash_sboxes + i * 12, ndata + len + 2, sboxcnt * 12);
599+ up |= 2;
600+ }
601+ }
602+ }
603+ if (update)
604+ *update = up;
605+ }
606+ return unit;
607+ }
608+ if (splash_size == 0) {
609+ printk(KERN_INFO"...found, freeing memory.\n");
610+ if (vc->vc_splash_data)
611+ splash_free(vc, info);
612+ return unit;
613+ }
614+ boxcnt = splash_gets(ndata, SPLASH_OFF_BOXCNT);
615+ palcnt = 3 * splash_getb(ndata, SPLASH_OFF_PALCNT);
616+ if (ndata + len + splash_size > end) {
617+ printk(KERN_INFO "...found, but truncated!\n");
618+ return -1;
619+ }
620+ if (!jpeg_check_size(ndata + len + boxcnt * 12 + palcnt, width, height)) {
621+ ndata += len + splash_size - 1;
622+ continue;
623+ }
624+ if (splash_check_jpeg(ndata + len + boxcnt * 12 + palcnt, width, height, info->var.bits_per_pixel))
625+ return -1;
626+ silentsize = splash_geti(ndata, SPLASH_OFF_SSIZE);
627+ if (silentsize)
628+ printk(KERN_INFO" silentjpeg size %d bytes,", silentsize);
629+ if (silentsize >= splash_size) {
630+ printk(KERN_INFO " bigger than splashsize!\n");
631+ return -1;
632+ }
633+ splash_size -= silentsize;
634+ if (!splash_usesilent)
635+ silentsize = 0;
636+ else if (height * 2 * info->fix.line_length > info->fix.smem_len) {
637+ printk(KERN_INFO " does not fit into framebuffer.\n");
638+ silentsize = 0;
639+ }
640+ sboxcnt = splash_gets(ndata, SPLASH_OFF_SBOXCNT);
641+ if (silentsize) {
642+ unsigned char *simage = ndata + len + splash_size + 12 * sboxcnt;
643+ if (!jpeg_check_size(simage, width, height) ||
644+ splash_check_jpeg(simage, width, height, info->var.bits_per_pixel)) {
645+ printk(KERN_INFO " error in silent jpeg.\n");
646+ silentsize = 0;
647+ }
648+ }
649+ if (vc->vc_splash_data)
650+ splash_free(vc, info);
651+ vc->vc_splash_data = sd = vmalloc(sizeof(*sd) + splash_size + (version < 3 ? 2 * 12 : 0));
652+ if (!sd)
653+ break;
654+ sd->splash_silentjpeg = 0;
655+ sd->splash_sboxes = 0;
656+ sd->splash_sboxcount = 0;
657+ if (silentsize) {
658+ sd->splash_silentjpeg = vmalloc(silentsize);
659+ if (sd->splash_silentjpeg) {
660+ memcpy(sd->splash_silentjpeg, ndata + len + splash_size, silentsize);
661+ sd->splash_sboxes = vc->vc_splash_data->splash_silentjpeg;
662+ sd->splash_silentjpeg += 12 * sboxcnt;
663+ sd->splash_sboxcount = sboxcnt;
664+ }
665+ }
666+ sd->splash_state = splash_getb(ndata, SPLASH_OFF_STATE);
667+ sd->splash_fg_color = splash_getb(ndata, SPLASH_OFF_FGCOL);
668+ sd->splash_color = splash_getb(ndata, SPLASH_OFF_COL);
669+ sd->splash_overpaintok = splash_getb(ndata, SPLASH_OFF_OVEROK);
670+ sd->splash_text_xo = splash_gets(ndata, SPLASH_OFF_XO);
671+ sd->splash_text_yo = splash_gets(ndata, SPLASH_OFF_YO);
672+ sd->splash_text_wi = splash_gets(ndata, SPLASH_OFF_WI);
673+ sd->splash_text_he = splash_gets(ndata, SPLASH_OFF_HE);
674+ sd->splash_percent = splash_gets(ndata, SPLASH_OFF_PERCENT);
675+ if (version == 1) {
676+ sd->splash_text_xo *= 8;
677+ sd->splash_text_wi *= 8;
678+ sd->splash_text_yo *= 16;
679+ sd->splash_text_he *= 16;
680+ sd->splash_color = (splash_default >> 8) & 0x0f;
681+ sd->splash_fg_color = (splash_default >> 4) & 0x0f;
682+ sd->splash_state = splash_default & 1;
683+ }
684+ if (sd->splash_text_xo + sd->splash_text_wi > width || sd->splash_text_yo + sd->splash_text_he > height) {
685+ splash_free(vc, info);
686+ printk(KERN_INFO " found, but has oversized text area!\n");
687+ return -1;
688+ }
689+/* if (!vc_cons[unit].d || info->fbops != &vesafb_ops) {
690+ splash_free(vc, info);
691+ printk(KERN_INFO " found, but framebuffer can't handle it!\n");
692+ return -1;
693+ } */
694+ printk(KERN_INFO "...found (%dx%d, %d bytes, v%d).\n", width, height, splash_size, version);
695+ if (version == 1) {
696+ printk(KERN_WARNING "bootsplash: Using deprecated v1 header. Updating your splash utility recommended.\n");
697+ printk(KERN_INFO "bootsplash: Find the latest version at http://www.bootsplash.org/\n");
698+ }
699+
700+ /* fake penguin box for older formats */
701+ if (version == 1)
702+ boxcnt = splash_mkpenguin(sd, sd->splash_text_xo + 10, sd->splash_text_yo + 10, sd->splash_text_wi - 20, sd->splash_text_he - 20, 0xf0, 0xf0, 0xf0);
703+ else if (version == 2)
704+ boxcnt = splash_mkpenguin(sd, splash_gets(ndata, 24), splash_gets(ndata, 26), splash_gets(ndata, 28), splash_gets(ndata, 30), splash_getb(ndata, 32), splash_getb(ndata, 33), splash_getb(ndata, 34));
705+
706+ memcpy((char *)sd + sizeof(*sd) + (version < 3 ? boxcnt * 12 : 0), ndata + len, splash_size);
707+ sd->splash_boxcount = boxcnt;
708+ sd->splash_boxes = (unsigned char *)sd + sizeof(*sd);
709+ sd->splash_palette = sd->splash_boxes + boxcnt * 12;
710+ sd->splash_jpeg = sd->splash_palette + palcnt;
711+ sd->splash_palcnt = palcnt / 3;
712+ sd->splash_dosilent = sd->splash_silentjpeg != 0;
713+ return unit;
714+ }
715+ printk(KERN_INFO "...no good signature found.\n");
716+ return -1;
717+}
718+
719+int splash_verbose(void)
720+{
721+ struct vc_data *vc;
722+ struct fb_info *info;
723+
724+ if (!splash_usesilent)
725+ return 0;
726+
727+ vc = vc_cons[0].d;
728+
729+ if (!vc || !vc->vc_splash_data || !vc->vc_splash_data->splash_state)
730+ return 0;
731+ if (fg_console != vc->vc_num)
732+ return 0;
733+ if (!vc->vc_splash_data->splash_silentjpeg || !vc->vc_splash_data->splash_dosilent)
734+ return 0;
735+ vc->vc_splash_data->splash_dosilent = 0;
736+ info = registered_fb[(int)con2fb_map[0]];
737+ if (!info->silent_screen_base)
738+ return 0;
739+ splashcopy(info->silent_screen_base, info->screen_base, info->var.yres, info->var.xres, info->fix.line_length, info->fix.line_length);
740+ info->screen_base = info->silent_screen_base;
741+ info->silent_screen_base = 0;
742+ return 1;
743+}
744+
745+static void splash_off(struct fb_info *info)
746+{
747+ if (info->silent_screen_base)
748+ info->screen_base = info->silent_screen_base;
749+ info->silent_screen_base = 0;
750+ info->splash_data = 0;
751+ if (info->splash_pic)
752+ vfree(info->splash_pic);
753+ info->splash_pic = 0;
754+ info->splash_pic_size = 0;
755+}
756+
757+int splash_prepare(struct vc_data *vc, struct fb_info *info)
758+{
759+ int err;
760+ int width, height, depth, size, sbytes;
761+
762+ if (!vc->vc_splash_data || !vc->vc_splash_data->splash_state) {
763+ if (decdata)
764+ vfree(decdata);
765+ decdata = 0;
766+ splash_off(info);
767+ return -1;
768+ }
769+
770+ width = info->var.xres;
771+ height = info->var.yres;
772+ depth = info->var.bits_per_pixel;
773+ if (depth != 16) { /* Other targets might need fixing */
774+ splash_off(info);
775+ return -2;
776+ }
777+
778+ sbytes = ((width + 15) & ~15) * (depth >> 3);
779+ size = sbytes * ((height + 15) & ~15);
780+ if (size != info->splash_pic_size)
781+ splash_off(info);
782+ if (!info->splash_pic)
783+ info->splash_pic = vmalloc(size);
784+
785+ if (!info->splash_pic) {
786+ printk(KERN_INFO "bootsplash: not enough memory.\n");
787+ splash_off(info);
788+ return -3;
789+ }
790+
791+ if (!decdata)
792+ decdata = vmalloc(sizeof(*decdata));
793+
794+ if (vc->vc_splash_data->splash_silentjpeg && vc->vc_splash_data->splash_dosilent) {
795+ /* fill area after framebuffer with other jpeg */
796+ if ((err = jpeg_decode(vc->vc_splash_data->splash_silentjpeg, info->splash_pic,
797+ ((width + 15) & ~15), ((height + 15) & ~15), depth, decdata))) {
798+ printk(KERN_INFO "bootsplash: error while decompressing silent picture: %s (%d)\n", jpg_errors[err - 1], err);
799+ if (info->silent_screen_base)
800+ info->screen_base = info->silent_screen_base;
801+ vc->vc_splash_data->splash_dosilent = 0;
802+ } else {
803+ if (vc->vc_splash_data->splash_sboxcount)
804+ boxit(info->splash_pic, sbytes, vc->vc_splash_data->splash_sboxes,
805+ vc->vc_splash_data->splash_sboxcount, vc->vc_splash_data->splash_percent, 0);
806+
807+ if (!info->silent_screen_base)
808+ info->silent_screen_base = info->screen_base;
809+ splashcopy(info->silent_screen_base, info->splash_pic, info->var.yres, info->var.xres, info->fix.line_length, sbytes);
810+ info->screen_base = info->silent_screen_base + info->fix.line_length * info->var.yres;
811+ }
812+ } else if (info->silent_screen_base)
813+ info->screen_base = info->silent_screen_base;
814+
815+ if ((err = jpeg_decode(vc->vc_splash_data->splash_jpeg, info->splash_pic,
816+ ((width + 15) & ~15), ((height + 15) & ~15), depth, decdata))) {
817+ printk(KERN_INFO "bootsplash: error while decompressing picture: %s (%d) .\n", jpg_errors[err - 1], err);
818+ splash_off(info);
819+ return -4;
820+ }
821+ info->splash_pic_size = size;
822+ info->splash_bytes = sbytes;
823+ if (vc->vc_splash_data->splash_boxcount)
824+ boxit(info->splash_pic, sbytes, vc->vc_splash_data->splash_boxes, vc->vc_splash_data->splash_boxcount, vc->vc_splash_data->splash_percent, 0);
825+ if (vc->vc_splash_data->splash_state)
826+ info->splash_data = vc->vc_splash_data;
827+ else
828+ splash_off(info);
829+ return 0;
830+}
831+
832+
833+#ifdef CONFIG_PROC_FS
834+
835+#include <linux/proc_fs.h>
836+
837+static int splash_read_proc(char *buffer, char **start, off_t offset, int size,
838+ int *eof, void *data);
839+static int splash_write_proc(struct file *file, const char *buffer,
840+ unsigned long count, void *data);
841+static int splash_status(struct vc_data *vc);
842+static int splash_recolor(struct vc_data *vc);
843+static int splash_proc_register(void);
844+
845+static struct proc_dir_entry *proc_splash;
846+
847+static int splash_recolor(struct vc_data *vc)
848+{
849+ if (!vc->vc_splash_data)
850+ return -1;
851+ if (!vc->vc_splash_data->splash_state)
852+ return 0;
853+ con_remap_def_color(vc, vc->vc_splash_data->splash_color << 4 | vc->vc_splash_data->splash_fg_color);
854+ if (fg_console == vc->vc_num) {
855+ update_region(vc, vc->vc_origin + vc->vc_size_row * vc->vc_top,
856+ vc->vc_size_row * (vc->vc_bottom - vc->vc_top) / 2);
857+ }
858+ return 0;
859+}
860+
861+static int splash_status(struct vc_data *vc)
862+{
863+ struct fb_info *info;
864+ printk(KERN_INFO "bootsplash: status on console %d changed to %s\n", vc->vc_num, vc->vc_splash_data && vc->vc_splash_data->splash_state ? "on" : "off");
865+
866+ info = registered_fb[(int) con2fb_map[vc->vc_num]];
867+ if (fg_console == vc->vc_num)
868+ splash_prepare(vc, info);
869+ if (vc->vc_splash_data && vc->vc_splash_data->splash_state) {
870+ con_remap_def_color(vc, vc->vc_splash_data->splash_color << 4 | vc->vc_splash_data->splash_fg_color);
871+ /* vc_resize also calls con_switch which resets yscroll */
872+ vc_resize(vc, vc->vc_splash_data->splash_text_wi / vc->vc_font.width, vc->vc_splash_data->splash_text_he / vc->vc_font.height);
873+ if (fg_console == vc->vc_num) {
874+ update_region(vc, vc->vc_origin + vc->vc_size_row * vc->vc_top,
875+ vc->vc_size_row * (vc->vc_bottom - vc->vc_top) / 2);
876+ splash_clear_margins(vc->vc_splash_data, vc, info, 0);
877+ }
878+ } else {
879+ /* Switch bootsplash off */
880+ con_remap_def_color(vc, 0x07);
881+ vc_resize(vc, info->var.xres / vc->vc_font.width, info->var.yres / vc->vc_font.height);
882+ }
883+ return 0;
884+}
885+
886+static int splash_read_proc(char *buffer, char **start, off_t offset, int size,
887+ int *eof, void *data)
888+{
889+ int len = 0;
890+ off_t begin = 0;
891+ struct vc_data *vc = vc_cons[0].d;
892+ struct fb_info *info = registered_fb[(int)con2fb_map[0]];
893+ int color = vc->vc_splash_data ? vc->vc_splash_data->splash_color << 4 |
894+ vc->vc_splash_data->splash_fg_color : splash_default >> 4;
895+ int status = vc->vc_splash_data ? vc->vc_splash_data->splash_state & 1 : 0;
896+ len += sprintf(buffer + len, "Splash screen v%s (0x%02x, %dx%d%s): %s\n",
897+ SPLASH_VERSION, color, info->var.xres, info->var.yres,
898+ (vc->vc_splash_data ? vc->vc_splash_data->splash_dosilent : 0)? ", silent" : "",
899+ status ? "on" : "off");
900+ if (offset >= begin + len)
901+ return 0;
902+
903+ *start = buffer + (begin - offset);
904+
905+ return (size < begin + len - offset ? size : begin + len - offset);
906+}
907+
908+static int splash_write_proc(struct file *file, const char *buffer,
909+ unsigned long count, void *data)
910+{
911+ int new, unit;
912+ struct vc_data *vc;
913+
914+ if (!buffer || !splash_default)
915+ return count;
916+
917+ acquire_console_sem();
918+ if (!strncmp(buffer, "show", 4) || !strncmp(buffer, "hide", 4)) {
919+ int pe, oldpe;
920+
921+ vc = vc_cons[0].d;
922+ if (buffer[4] == ' ' && buffer[5] == 'p')
923+ pe = 0;
924+ else if (buffer[4] == '\n')
925+ pe = 65535;
926+ else
927+ pe = simple_strtoul(buffer + 5, NULL, 0);
928+ if (pe < 0)
929+ pe = 0;
930+ if (pe > 65535)
931+ pe = 65535;
932+ if (*buffer == 'h')
933+ pe = 65535 - pe;
934+ pe += pe > 32767;
935+ if (vc->vc_splash_data && vc->vc_splash_data->splash_percent != pe) {
936+ struct fb_info *info;
937+ struct fbcon_ops *ops;
938+
939+ oldpe = vc->vc_splash_data->splash_percent;
940+ vc->vc_splash_data->splash_percent = pe;
941+ if (fg_console != 0 || !vc->vc_splash_data->splash_state) {
942+ release_console_sem();
943+ return count;
944+ }
945+ info = registered_fb[(int) con2fb_map[vc->vc_num]];
946+ ops = info->fbcon_par;
947+ if (ops->blank_state) {
948+ release_console_sem();
949+ return count;
950+ }
951+ if (!vc->vc_splash_data->splash_overpaintok || pe == 65536 || pe < oldpe) {
952+ if (splash_hasinter(vc->vc_splash_data->splash_boxes, vc->vc_splash_data->splash_boxcount))
953+ splash_status(vc);
954+ else
955+ splash_prepare(vc, info);
956+ } else {
957+ if (vc->vc_splash_data->splash_silentjpeg && vc->vc_splash_data->splash_dosilent && info->silent_screen_base)
958+ boxit(info->silent_screen_base, info->fix.line_length, vc->vc_splash_data->splash_sboxes, vc->vc_splash_data->splash_sboxcount, vc->vc_splash_data->splash_percent, 1);
959+ boxit(info->screen_base, info->fix.line_length, vc->vc_splash_data->splash_boxes, vc->vc_splash_data->splash_boxcount, vc->vc_splash_data->splash_percent, 1);
960+ }
961+ }
962+ release_console_sem();
963+ return count;
964+ }
965+ if (!strncmp(buffer,"silent\n",7) || !strncmp(buffer,"verbose\n",8)) {
966+ vc = vc_cons[0].d;
967+ if (vc->vc_splash_data && vc->vc_splash_data->splash_silentjpeg) {
968+ if (vc->vc_splash_data->splash_dosilent != (buffer[0] == 's')) {
969+ vc->vc_splash_data->splash_dosilent = buffer[0] == 's';
970+ splash_status(vc);
971+ }
972+ }
973+ release_console_sem();
974+ return count;
975+ }
976+ if (!strncmp(buffer,"freesilent\n",11)) {
977+ vc = vc_cons[0].d;
978+ if (vc->vc_splash_data && vc->vc_splash_data->splash_silentjpeg) {
979+ printk(KERN_INFO "bootsplash: freeing silent jpeg\n");
980+ vc->vc_splash_data->splash_silentjpeg = 0;
981+ vfree(vc->vc_splash_data->splash_sboxes);
982+ vc->vc_splash_data->splash_sboxes = 0;
983+ vc->vc_splash_data->splash_sboxcount = 0;
984+ if (vc->vc_splash_data->splash_dosilent)
985+ splash_status(vc);
986+ vc->vc_splash_data->splash_dosilent = 0;
987+ }
988+ release_console_sem();
989+ return count;
990+ }
991+
992+ if (!strncmp(buffer, "BOOTSPL", 7)) {
993+ int up = -1;
994+ unit = splash_getraw((unsigned char *)buffer, (unsigned char *)buffer + count, &up);
995+ if (unit >= 0) {
996+ vc = vc_cons[unit].d;
997+ if (up == -1)
998+ splash_status(vc);
999+ else {
1000+ struct fb_info *info = registered_fb[(int) con2fb_map[vc->vc_num]];
1001+ struct fbcon_ops *ops = info->fbcon_par;
1002+ if (ops->blank_state)
1003+ up = 0;
1004+ if ((up & 2) != 0 && vc->vc_splash_data->splash_silentjpeg && vc->vc_splash_data->splash_dosilent && info->silent_screen_base)
1005+ boxit(info->silent_screen_base, info->fix.line_length, vc->vc_splash_data->splash_sboxes, vc->vc_splash_data->splash_sboxcount, vc->vc_splash_data->splash_percent, 1);
1006+ if ((up & 1) != 0)
1007+ boxit(info->screen_base, info->fix.line_length, vc->vc_splash_data->splash_boxes, vc->vc_splash_data->splash_boxcount, vc->vc_splash_data->splash_percent, 1);
1008+ }
1009+ }
1010+ release_console_sem();
1011+ return count;
1012+ }
1013+ vc = vc_cons[0].d;
1014+ if (!vc->vc_splash_data) {
1015+ release_console_sem();
1016+ return count;
1017+ }
1018+ if (buffer[0] == 't') {
1019+ vc->vc_splash_data->splash_state ^= 1;
1020+ splash_status(vc);
1021+ release_console_sem();
1022+ return count;
1023+ }
1024+ new = simple_strtoul(buffer, NULL, 0);
1025+ if (new > 1) {
1026+ /* expert user */
1027+ vc->vc_splash_data->splash_color = new >> 8 & 0xff;
1028+ vc->vc_splash_data->splash_fg_color = new >> 4 & 0x0f;
1029+ }
1030+ if ((new & 1) == vc->vc_splash_data->splash_state)
1031+ splash_recolor(vc);
1032+ else {
1033+ vc->vc_splash_data->splash_state = new & 1;
1034+ splash_status(vc);
1035+ }
1036+ release_console_sem();
1037+ return count;
1038+}
1039+
1040+static int splash_proc_register(void)
1041+{
1042+ if ((proc_splash = create_proc_entry("splash", 0, 0))) {
1043+ proc_splash->read_proc = splash_read_proc;
1044+ proc_splash->write_proc = splash_write_proc;
1045+ return 0;
1046+ }
1047+ return 1;
1048+}
1049+
1050+# if 0
1051+static int splash_proc_unregister(void)
1052+{
1053+ if (proc_splash)
1054+ remove_proc_entry("splash", 0);
1055+ return 0;
1056+}
1057+# endif
1058+#endif /* CONFIG_PROC_FS */
1059+
1060+void splash_init(void)
1061+{
1062+ struct fb_info *info;
1063+ struct vc_data *vc;
1064+ int isramfs = 1;
1065+ int fd;
1066+ int len;
1067+ int max_len = 1024*1024*2;
1068+ char *mem;
1069+
1070+ if (splash_registered)
1071+ return;
1072+ vc = vc_cons[0].d;
1073+ info = registered_fb[0];
1074+ if (!vc || !info || info->var.bits_per_pixel != 16)
1075+ return;
1076+#ifdef CONFIG_PROC_FS
1077+ splash_proc_register();
1078+#endif
1079+ splash_registered = 1;
1080+ if (vc->vc_splash_data)
1081+ return;
1082+ if ((fd = sys_open("/bootsplash", O_RDONLY, 0)) < 0) {
1083+ isramfs = 0;
1084+ fd = sys_open("/initrd.image", O_RDONLY, 0);
1085+ }
1086+ if (fd < 0)
1087+ return;
1088+ if ((len = (int)sys_lseek(fd, (off_t)0, 2)) <= 0) {
1089+ sys_close(fd);
1090+ return;
1091+ }
1092+ /* Don't look for more than the last 2MB */
1093+ if (len > max_len) {
1094+ printk( KERN_INFO "bootsplash: scanning last %dMB of initrd for signature\n",
1095+ max_len>>20);
1096+ sys_lseek(fd, (off_t)(len - max_len), 0);
1097+ len = max_len;
1098+ } else {
1099+ sys_lseek(fd, (off_t)0, 0);
1100+ }
1101+
1102+ mem = vmalloc(len);
1103+ if (mem) {
1104+ acquire_console_sem();
1105+ if ((int)sys_read(fd, mem, len) == len && splash_getraw((unsigned char *)mem, (unsigned char *)mem + len, (int *)0) == 0 && vc->vc_splash_data)
1106+ vc->vc_splash_data->splash_state = splash_default & 1;
1107+ release_console_sem();
1108+ vfree(mem);
1109+ }
1110+ sys_close(fd);
1111+ if (isramfs)
1112+ sys_unlink("/bootsplash");
1113+ return;
1114+}
1115+
1116diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/bootsplash/bootsplash.h linux-2.6.15-VinX/drivers/video/bootsplash/bootsplash.h
1117--- linux-2.6.15/drivers/video/bootsplash/bootsplash.h 1970-01-01 01:00:00.000000000 +0100
1118+++ linux-2.6.15-VinX/drivers/video/bootsplash/bootsplash.h 2006-01-05 01:17:11.000000000 +0100
1119@@ -0,0 +1,44 @@
1120+/*
1121+ * linux/drivers/video/bootsplash/bootsplash.h - splash screen definition.
1122+ *
1123+ * (w) 2001-2003 by Volker Poplawski, <volker@poplawski.de>
1124+ * Stefan Reinauer, <stepan@suse.de>
1125+ *
1126+ *
1127+ * idea and SuSE screen work by Ken Wimer, <wimer@suse.de>
1128+ */
1129+
1130+#ifndef __BOOTSPLASH_H
1131+#define __BOOTSPLASH_H
1132+
1133+struct fb_info;
1134+
1135+/* splash.c */
1136+extern int splash_prepare(struct vc_data *, struct fb_info *);
1137+extern void splash_init(void);
1138+
1139+/* splash_render.c */
1140+extern void splash_putcs(struct splash_data *sd, struct vc_data *vc, struct fb_info *info,
1141+ const unsigned short *s, int count, int ypos, int xpos);
1142+extern void splash_putc(struct splash_data *sd, struct vc_data *vc, struct fb_info *info,
1143+ int c, int ypos, int xpos);
1144+extern void splashcopy(u8 *dst, u8 *src, int height, int width, int dstbytes, int srcbytes);
1145+extern void splash_clear(struct splash_data *sd, struct vc_data *vc, struct fb_info *info, int sy,
1146+ int sx, int height, int width);
1147+extern void splash_bmove(struct splash_data *sd, struct vc_data *vc, struct fb_info *info, int sy,
1148+ int sx, int dy, int dx, int height, int width);
1149+extern void splash_clear_margins(struct splash_data *sd, struct vc_data *vc, struct fb_info *info,
1150+ int bottom_only);
1151+extern int splash_cursor(struct splash_data *sd, struct fb_info *info, struct fb_cursor *cursor);
1152+extern void splash_bmove_redraw(struct splash_data *sd, struct vc_data *vc, struct fb_info *info,
1153+ int y, int sx, int dx, int width);
1154+extern void splash_blank(struct splash_data *sd, struct vc_data *vc, struct fb_info *info,
1155+ int blank);
1156+
1157+/* vt.c */
1158+extern void con_remap_def_color(struct vc_data *, int new_color);
1159+
1160+extern void acquire_console_sem(void);
1161+extern void release_console_sem(void);
1162+
1163+#endif
1164diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/bootsplash/decode-jpg.c linux-2.6.15-VinX/drivers/video/bootsplash/decode-jpg.c
1165--- linux-2.6.15/drivers/video/bootsplash/decode-jpg.c 1970-01-01 01:00:00.000000000 +0100
1166+++ linux-2.6.15-VinX/drivers/video/bootsplash/decode-jpg.c 2006-01-05 01:17:11.000000000 +0100
1167@@ -0,0 +1,958 @@
1168+/*
1169+ * linux/drivers/video/bootsplash/decode-jpg.c - a tiny jpeg decoder.
1170+ *
1171+ * (w) August 2001 by Michael Schroeder, <mls@suse.de>
1172+ *
1173+ */
1174+
1175+#include <linux/config.h>
1176+#include <linux/string.h>
1177+#include <asm/byteorder.h>
1178+
1179+#include "decode-jpg.h"
1180+
1181+#define ISHIFT 11
1182+
1183+#define IFIX(a) ((int)((a) * (1 << ISHIFT) + .5))
1184+#define IMULT(a, b) (((a) * (b)) >> ISHIFT)
1185+#define ITOINT(a) ((a) >> ISHIFT)
1186+
1187+#ifndef __P
1188+# define __P(x) x
1189+#endif
1190+
1191+/* special markers */
1192+#define M_BADHUFF -1
1193+#define M_EOF 0x80
1194+
1195+struct in {
1196+ unsigned char *p;
1197+ unsigned int bits;
1198+ int left;
1199+ int marker;
1200+
1201+ int (*func) __P((void *));
1202+ void *data;
1203+};
1204+
1205+/*********************************/
1206+struct dec_hufftbl;
1207+struct enc_hufftbl;
1208+
1209+union hufftblp {
1210+ struct dec_hufftbl *dhuff;
1211+ struct enc_hufftbl *ehuff;
1212+};
1213+
1214+struct scan {
1215+ int dc; /* old dc value */
1216+
1217+ union hufftblp hudc;
1218+ union hufftblp huac;
1219+ int next; /* when to switch to next scan */
1220+
1221+ int cid; /* component id */
1222+ int hv; /* horiz/vert, copied from comp */
1223+ int tq; /* quant tbl, copied from comp */
1224+};
1225+
1226+/*********************************/
1227+
1228+#define DECBITS 10 /* seems to be the optimum */
1229+
1230+struct dec_hufftbl {
1231+ int maxcode[17];
1232+ int valptr[16];
1233+ unsigned char vals[256];
1234+ unsigned int llvals[1 << DECBITS];
1235+};
1236+
1237+static void decode_mcus __P((struct in *, int *, int, struct scan *, int *));
1238+static int dec_readmarker __P((struct in *));
1239+static void dec_makehuff __P((struct dec_hufftbl *, int *, unsigned char *));
1240+
1241+static void setinput __P((struct in *, unsigned char *));
1242+/*********************************/
1243+
1244+#undef PREC
1245+#define PREC int
1246+
1247+static void idctqtab __P((unsigned char *, PREC *));
1248+static void idct __P((int *, int *, PREC *, PREC, int));
1249+static void scaleidctqtab __P((PREC *, PREC));
1250+
1251+/*********************************/
1252+
1253+static void initcol __P((PREC[][64]));
1254+
1255+static void col221111 __P((int *, unsigned char *, int));
1256+static void col221111_16 __P((int *, unsigned char *, int));
1257+
1258+/*********************************/
1259+
1260+#define M_SOI 0xd8
1261+#define M_APP0 0xe0
1262+#define M_DQT 0xdb
1263+#define M_SOF0 0xc0
1264+#define M_DHT 0xc4
1265+#define M_DRI 0xdd
1266+#define M_SOS 0xda
1267+#define M_RST0 0xd0
1268+#define M_EOI 0xd9
1269+#define M_COM 0xfe
1270+
1271+static unsigned char *datap;
1272+
1273+static int getbyte(void)
1274+{
1275+ return *datap++;
1276+}
1277+
1278+static int getword(void)
1279+{
1280+ int c1, c2;
1281+ c1 = *datap++;
1282+ c2 = *datap++;
1283+ return c1 << 8 | c2;
1284+}
1285+
1286+struct comp {
1287+ int cid;
1288+ int hv;
1289+ int tq;
1290+};
1291+
1292+#define MAXCOMP 4
1293+struct jpginfo {
1294+ int nc; /* number of components */
1295+ int ns; /* number of scans */
1296+ int dri; /* restart interval */
1297+ int nm; /* mcus til next marker */
1298+ int rm; /* next restart marker */
1299+};
1300+
1301+static struct jpginfo info;
1302+static struct comp comps[MAXCOMP];
1303+
1304+static struct scan dscans[MAXCOMP];
1305+
1306+static unsigned char quant[4][64];
1307+
1308+static struct dec_hufftbl dhuff[4];
1309+
1310+#define dec_huffdc (dhuff + 0)
1311+#define dec_huffac (dhuff + 2)
1312+
1313+static struct in in;
1314+
1315+static int readtables(int till)
1316+{
1317+ int m, l, i, j, lq, pq, tq;
1318+ int tc, th, tt;
1319+
1320+ for (;;) {
1321+ if (getbyte() != 0xff)
1322+ return -1;
1323+ if ((m = getbyte()) == till)
1324+ break;
1325+
1326+ switch (m) {
1327+ case 0xc2:
1328+ return 0;
1329+
1330+ case M_DQT:
1331+ lq = getword();
1332+ while (lq > 2) {
1333+ pq = getbyte();
1334+ tq = pq & 15;
1335+ if (tq > 3)
1336+ return -1;
1337+ pq >>= 4;
1338+ if (pq != 0)
1339+ return -1;
1340+ for (i = 0; i < 64; i++)
1341+ quant[tq][i] = getbyte();
1342+ lq -= 64 + 1;
1343+ }
1344+ break;
1345+
1346+ case M_DHT:
1347+ l = getword();
1348+ while (l > 2) {
1349+ int hufflen[16], k;
1350+ unsigned char huffvals[256];
1351+
1352+ tc = getbyte();
1353+ th = tc & 15;
1354+ tc >>= 4;
1355+ tt = tc * 2 + th;
1356+ if (tc > 1 || th > 1)
1357+ return -1;
1358+ for (i = 0; i < 16; i++)
1359+ hufflen[i] = getbyte();
1360+ l -= 1 + 16;
1361+ k = 0;
1362+ for (i = 0; i < 16; i++) {
1363+ for (j = 0; j < hufflen[i]; j++)
1364+ huffvals[k++] = getbyte();
1365+ l -= hufflen[i];
1366+ }
1367+ dec_makehuff(dhuff + tt, hufflen,
1368+ huffvals);
1369+ }
1370+ break;
1371+
1372+ case M_DRI:
1373+ l = getword();
1374+ info.dri = getword();
1375+ break;
1376+
1377+ default:
1378+ l = getword();
1379+ while (l-- > 2)
1380+ getbyte();
1381+ break;
1382+ }
1383+ }
1384+ return 0;
1385+}
1386+
1387+static void dec_initscans(void)
1388+{
1389+ int i;
1390+
1391+ info.nm = info.dri + 1;
1392+ info.rm = M_RST0;
1393+ for (i = 0; i < info.ns; i++)
1394+ dscans[i].dc = 0;
1395+}
1396+
1397+static int dec_checkmarker(void)
1398+{
1399+ int i;
1400+
1401+ if (dec_readmarker(&in) != info.rm)
1402+ return -1;
1403+ info.nm = info.dri;
1404+ info.rm = (info.rm + 1) & ~0x08;
1405+ for (i = 0; i < info.ns; i++)
1406+ dscans[i].dc = 0;
1407+ return 0;
1408+}
1409+
1410+int jpeg_check_size(unsigned char *buf, int width, int height)
1411+{
1412+ datap = buf;
1413+ getbyte();
1414+ getbyte();
1415+ readtables(M_SOF0);
1416+ getword();
1417+ getbyte();
1418+ if (height != getword() || width != getword())
1419+ return 0;
1420+ return 1;
1421+}
1422+
1423+int jpeg_decode(buf, pic, width, height, depth, decdata)
1424+unsigned char *buf, *pic;
1425+int width, height, depth;
1426+struct jpeg_decdata *decdata;
1427+{
1428+ int i, j, m, tac, tdc;
1429+ int mcusx, mcusy, mx, my;
1430+ int max[6];
1431+
1432+ if (!decdata || !buf || !pic)
1433+ return -1;
1434+ datap = buf;
1435+ if (getbyte() != 0xff)
1436+ return ERR_NO_SOI;
1437+ if (getbyte() != M_SOI)
1438+ return ERR_NO_SOI;
1439+ if (readtables(M_SOF0))
1440+ return ERR_BAD_TABLES;
1441+ getword();
1442+ i = getbyte();
1443+ if (i != 8)
1444+ return ERR_NOT_8BIT;
1445+ if (((getword() + 15) & ~15) != height)
1446+ return ERR_HEIGHT_MISMATCH;
1447+ if (((getword() + 15) & ~15) != width)
1448+ return ERR_WIDTH_MISMATCH;
1449+ if ((height & 15) || (width & 15))
1450+ return ERR_BAD_WIDTH_OR_HEIGHT;
1451+ info.nc = getbyte();
1452+ if (info.nc > MAXCOMP)
1453+ return ERR_TOO_MANY_COMPPS;
1454+ for (i = 0; i < info.nc; i++) {
1455+ int h, v;
1456+ comps[i].cid = getbyte();
1457+ comps[i].hv = getbyte();
1458+ v = comps[i].hv & 15;
1459+ h = comps[i].hv >> 4;
1460+ comps[i].tq = getbyte();
1461+ if (h > 3 || v > 3)
1462+ return ERR_ILLEGAL_HV;
1463+ if (comps[i].tq > 3)
1464+ return ERR_QUANT_TABLE_SELECTOR;
1465+ }
1466+ if (readtables(M_SOS))
1467+ return ERR_BAD_TABLES;
1468+ getword();
1469+ info.ns = getbyte();
1470+ if (info.ns != 3)
1471+ return ERR_NOT_YCBCR_221111;
1472+ for (i = 0; i < 3; i++) {
1473+ dscans[i].cid = getbyte();
1474+ tdc = getbyte();
1475+ tac = tdc & 15;
1476+ tdc >>= 4;
1477+ if (tdc > 1 || tac > 1)
1478+ return ERR_QUANT_TABLE_SELECTOR;
1479+ for (j = 0; j < info.nc; j++)
1480+ if (comps[j].cid == dscans[i].cid)
1481+ break;
1482+ if (j == info.nc)
1483+ return ERR_UNKNOWN_CID_IN_SCAN;
1484+ dscans[i].hv = comps[j].hv;
1485+ dscans[i].tq = comps[j].tq;
1486+ dscans[i].hudc.dhuff = dec_huffdc + tdc;
1487+ dscans[i].huac.dhuff = dec_huffac + tac;
1488+ }
1489+
1490+ i = getbyte();
1491+ j = getbyte();
1492+ m = getbyte();
1493+
1494+ if (i != 0 || j != 63 || m != 0)
1495+ return ERR_NOT_SEQUENTIAL_DCT;
1496+
1497+ if (dscans[0].cid != 1 || dscans[1].cid != 2 || dscans[2].cid != 3)
1498+ return ERR_NOT_YCBCR_221111;
1499+
1500+ if (dscans[0].hv != 0x22 || dscans[1].hv != 0x11 || dscans[2].hv != 0x11)
1501+ return ERR_NOT_YCBCR_221111;
1502+
1503+ mcusx = width >> 4;
1504+ mcusy = height >> 4;
1505+
1506+
1507+ idctqtab(quant[dscans[0].tq], decdata->dquant[0]);
1508+ idctqtab(quant[dscans[1].tq], decdata->dquant[1]);
1509+ idctqtab(quant[dscans[2].tq], decdata->dquant[2]);
1510+ initcol(decdata->dquant);
1511+ setinput(&in, datap);
1512+
1513+#if 0
1514+ /* landing zone */
1515+ img[len] = 0;
1516+ img[len + 1] = 0xff;
1517+ img[len + 2] = M_EOF;
1518+#endif
1519+
1520+ dec_initscans();
1521+
1522+ dscans[0].next = 6 - 4;
1523+ dscans[1].next = 6 - 4 - 1;
1524+ dscans[2].next = 6 - 4 - 1 - 1; /* 411 encoding */
1525+ for (my = 0; my < mcusy; my++) {
1526+ for (mx = 0; mx < mcusx; mx++) {
1527+ if (info.dri && !--info.nm)
1528+ if (dec_checkmarker())
1529+ return ERR_WRONG_MARKER;
1530+
1531+ decode_mcus(&in, decdata->dcts, 6, dscans, max);
1532+ idct(decdata->dcts, decdata->out, decdata->dquant[0], IFIX(128.5), max[0]);
1533+ idct(decdata->dcts + 64, decdata->out + 64, decdata->dquant[0], IFIX(128.5), max[1]);
1534+ idct(decdata->dcts + 128, decdata->out + 128, decdata->dquant[0], IFIX(128.5), max[2]);
1535+ idct(decdata->dcts + 192, decdata->out + 192, decdata->dquant[0], IFIX(128.5), max[3]);
1536+ idct(decdata->dcts + 256, decdata->out + 256, decdata->dquant[1], IFIX(0.5), max[4]);
1537+ idct(decdata->dcts + 320, decdata->out + 320, decdata->dquant[2], IFIX(0.5), max[5]);
1538+
1539+ switch (depth) {
1540+ case 24:
1541+ col221111(decdata->out, pic + (my * 16 * mcusx + mx) * 16 * 3, mcusx * 16 * 3);
1542+ break;
1543+ case 16:
1544+ col221111_16(decdata->out, pic + (my * 16 * mcusx + mx) * (16 * 2), mcusx * (16 * 2));
1545+ break;
1546+ default:
1547+ return ERR_DEPTH_MISMATCH;
1548+ break;
1549+ }
1550+ }
1551+ }
1552+
1553+ m = dec_readmarker(&in);
1554+ if (m != M_EOI)
1555+ return ERR_NO_EOI;
1556+
1557+ return 0;
1558+}
1559+
1560+/****************************************************************/
1561+/************** huffman decoder ***************/
1562+/****************************************************************/
1563+
1564+static int fillbits __P((struct in *, int, unsigned int));
1565+static int dec_rec2
1566+__P((struct in *, struct dec_hufftbl *, int *, int, int));
1567+
1568+static void setinput(in, p)
1569+struct in *in;
1570+unsigned char *p;
1571+{
1572+ in->p = p;
1573+ in->left = 0;
1574+ in->bits = 0;
1575+ in->marker = 0;
1576+}
1577+
1578+static int fillbits(in, le, bi)
1579+struct in *in;
1580+int le;
1581+unsigned int bi;
1582+{
1583+ int b, m;
1584+
1585+ if (in->marker) {
1586+ if (le <= 16)
1587+ in->bits = bi << 16, le += 16;
1588+ return le;
1589+ }
1590+ while (le <= 24) {
1591+ b = *in->p++;
1592+ if (b == 0xff && (m = *in->p++) != 0) {
1593+ if (m == M_EOF) {
1594+ if (in->func && (m = in->func(in->data)) == 0)
1595+ continue;
1596+ }
1597+ in->marker = m;
1598+ if (le <= 16)
1599+ bi = bi << 16, le += 16;
1600+ break;
1601+ }
1602+ bi = bi << 8 | b;
1603+ le += 8;
1604+ }
1605+ in->bits = bi; /* tmp... 2 return values needed */
1606+ return le;
1607+}
1608+
1609+static int dec_readmarker(in)
1610+struct in *in;
1611+{
1612+ int m;
1613+
1614+ in->left = fillbits(in, in->left, in->bits);
1615+ if ((m = in->marker) == 0)
1616+ return 0;
1617+ in->left = 0;
1618+ in->marker = 0;
1619+ return m;
1620+}
1621+
1622+#define LEBI_DCL int le, bi
1623+#define LEBI_GET(in) (le = in->left, bi = in->bits)
1624+#define LEBI_PUT(in) (in->left = le, in->bits = bi)
1625+
1626+#define GETBITS(in, n) ( \
1627+ (le < (n) ? le = fillbits(in, le, bi), bi = in->bits : 0), \
1628+ (le -= (n)), \
1629+ bi >> le & ((1 << (n)) - 1) \
1630+)
1631+
1632+#define UNGETBITS(in, n) ( \
1633+ le += (n) \
1634+)
1635+
1636+
1637+static int dec_rec2(in, hu, runp, c, i)
1638+struct in *in;
1639+struct dec_hufftbl *hu;
1640+int *runp;
1641+int c, i;
1642+{
1643+ LEBI_DCL;
1644+
1645+ LEBI_GET(in);
1646+ if (i) {
1647+ UNGETBITS(in, i & 127);
1648+ *runp = i >> 8 & 15;
1649+ i >>= 16;
1650+ } else {
1651+ for (i = DECBITS; (c = ((c << 1) | GETBITS(in, 1))) >= (hu->maxcode[i]); i++);
1652+ if (i >= 16) {
1653+ in->marker = M_BADHUFF;
1654+ return 0;
1655+ }
1656+ i = hu->vals[hu->valptr[i] + c - hu->maxcode[i - 1] * 2];
1657+ *runp = i >> 4;
1658+ i &= 15;
1659+ }
1660+ if (i == 0) { /* sigh, 0xf0 is 11 bit */
1661+ LEBI_PUT(in);
1662+ return 0;
1663+ }
1664+ /* receive part */
1665+ c = GETBITS(in, i);
1666+ if (c < (1 << (i - 1)))
1667+ c += (-1 << i) + 1;
1668+ LEBI_PUT(in);
1669+ return c;
1670+}
1671+
1672+#define DEC_REC(in, hu, r, i) ( \
1673+ r = GETBITS(in, DECBITS), \
1674+ i = hu->llvals[r], \
1675+ i & 128 ? \
1676+ ( \
1677+ UNGETBITS(in, i & 127), \
1678+ r = i >> 8 & 15, \
1679+ i >> 16 \
1680+ ) \
1681+ : \
1682+ ( \
1683+ LEBI_PUT(in), \
1684+ i = dec_rec2(in, hu, &r, r, i), \
1685+ LEBI_GET(in), \
1686+ i \
1687+ ) \
1688+)
1689+
1690+static void decode_mcus(in, dct, n, sc, maxp)
1691+struct in *in;
1692+int *dct;
1693+int n;
1694+struct scan *sc;
1695+int *maxp;
1696+{
1697+ struct dec_hufftbl *hu;
1698+ int i, r, t;
1699+ LEBI_DCL;
1700+
1701+ memset(dct, 0, n * 64 * sizeof(*dct));
1702+ LEBI_GET(in);
1703+ while (n-- > 0) {
1704+ hu = sc->hudc.dhuff;
1705+ *dct++ = (sc->dc += DEC_REC(in, hu, r, t));
1706+
1707+ hu = sc->huac.dhuff;
1708+ i = 63;
1709+ while (i > 0) {
1710+ t = DEC_REC(in, hu, r, t);
1711+ if (t == 0 && r == 0) {
1712+ dct += i;
1713+ break;
1714+ }
1715+ dct += r;
1716+ *dct++ = t;
1717+ i -= r + 1;
1718+ }
1719+ *maxp++ = 64 - i;
1720+ if (n == sc->next)
1721+ sc++;
1722+ }
1723+ LEBI_PUT(in);
1724+}
1725+
1726+static void dec_makehuff(hu, hufflen, huffvals)
1727+struct dec_hufftbl *hu;
1728+int *hufflen;
1729+unsigned char *huffvals;
1730+{
1731+ int code, k, i, j, d, x, c, v;
1732+ for (i = 0; i < (1 << DECBITS); i++)
1733+ hu->llvals[i] = 0;
1734+
1735+/*
1736+ * llvals layout:
1737+ *
1738+ * value v already known, run r, backup u bits:
1739+ * vvvvvvvvvvvvvvvv 0000 rrrr 1 uuuuuuu
1740+ * value unknown, size b bits, run r, backup u bits:
1741+ * 000000000000bbbb 0000 rrrr 0 uuuuuuu
1742+ * value and size unknown:
1743+ * 0000000000000000 0000 0000 0 0000000
1744+ */
1745+ code = 0;
1746+ k = 0;
1747+ for (i = 0; i < 16; i++, code <<= 1) { /* sizes */
1748+ hu->valptr[i] = k;
1749+ for (j = 0; j < hufflen[i]; j++) {
1750+ hu->vals[k] = *huffvals++;
1751+ if (i < DECBITS) {
1752+ c = code << (DECBITS - 1 - i);
1753+ v = hu->vals[k] & 0x0f; /* size */
1754+ for (d = 1 << (DECBITS - 1 - i); --d >= 0;) {
1755+ if (v + i < DECBITS) { /* both fit in table */
1756+ x = d >> (DECBITS - 1 - v -
1757+ i);
1758+ if (v && x < (1 << (v - 1)))
1759+ x += (-1 << v) + 1;
1760+ x = x << 16 | (hu-> vals[k] & 0xf0) << 4 |
1761+ (DECBITS - (i + 1 + v)) | 128;
1762+ } else
1763+ x = v << 16 | (hu-> vals[k] & 0xf0) << 4 |
1764+ (DECBITS - (i + 1));
1765+ hu->llvals[c | d] = x;
1766+ }
1767+ }
1768+ code++;
1769+ k++;
1770+ }
1771+ hu->maxcode[i] = code;
1772+ }
1773+ hu->maxcode[16] = 0x20000; /* always terminate decode */
1774+}
1775+
1776+/****************************************************************/
1777+/************** idct ***************/
1778+/****************************************************************/
1779+
1780+#define ONE ((PREC)IFIX(1.))
1781+#define S2 ((PREC)IFIX(0.382683432))
1782+#define C2 ((PREC)IFIX(0.923879532))
1783+#define C4 ((PREC)IFIX(0.707106781))
1784+
1785+#define S22 ((PREC)IFIX(2 * 0.382683432))
1786+#define C22 ((PREC)IFIX(2 * 0.923879532))
1787+#define IC4 ((PREC)IFIX(1 / 0.707106781))
1788+
1789+#define C3IC1 ((PREC)IFIX(0.847759065)) /* c3/c1 */
1790+#define C5IC1 ((PREC)IFIX(0.566454497)) /* c5/c1 */
1791+#define C7IC1 ((PREC)IFIX(0.198912367)) /* c7/c1 */
1792+
1793+#define XPP(a,b) (t = a + b, b = a - b, a = t)
1794+#define XMP(a,b) (t = a - b, b = a + b, a = t)
1795+#define XPM(a,b) (t = a + b, b = b - a, a = t)
1796+
1797+#define ROT(a,b,s,c) ( t = IMULT(a + b, s), \
1798+ a = IMULT(a, c - s) + t, \
1799+ b = IMULT(b, c + s) - t)
1800+
1801+#define IDCT \
1802+( \
1803+ XPP(t0, t1), \
1804+ XMP(t2, t3), \
1805+ t2 = IMULT(t2, IC4) - t3, \
1806+ XPP(t0, t3), \
1807+ XPP(t1, t2), \
1808+ XMP(t4, t7), \
1809+ XPP(t5, t6), \
1810+ XMP(t5, t7), \
1811+ t5 = IMULT(t5, IC4), \
1812+ ROT(t4, t6, S22, C22),\
1813+ t6 -= t7, \
1814+ t5 -= t6, \
1815+ t4 -= t5, \
1816+ XPP(t0, t7), \
1817+ XPP(t1, t6), \
1818+ XPP(t2, t5), \
1819+ XPP(t3, t4) \
1820+)
1821+
1822+static unsigned char zig2[64] = {
1823+ 0, 2, 3, 9, 10, 20, 21, 35,
1824+ 14, 16, 25, 31, 39, 46, 50, 57,
1825+ 5, 7, 12, 18, 23, 33, 37, 48,
1826+ 27, 29, 41, 44, 52, 55, 59, 62,
1827+ 15, 26, 30, 40, 45, 51, 56, 58,
1828+ 1, 4, 8, 11, 19, 22, 34, 36,
1829+ 28, 42, 43, 53, 54, 60, 61, 63,
1830+ 6, 13, 17, 24, 32, 38, 47, 49
1831+};
1832+
1833+void idct(in, out, quant, off, max)
1834+int *in;
1835+int *out;
1836+PREC *quant;
1837+PREC off;
1838+int max;
1839+{
1840+ PREC t0, t1, t2, t3, t4, t5, t6, t7, t;
1841+ PREC tmp[64], *tmpp;
1842+ int i, j;
1843+ unsigned char *zig2p;
1844+
1845+ t0 = off;
1846+ if (max == 1) {
1847+ t0 += in[0] * quant[0];
1848+ for (i = 0; i < 64; i++)
1849+ out[i] = ITOINT(t0);
1850+ return;
1851+ }
1852+ zig2p = zig2;
1853+ tmpp = tmp;
1854+ for (i = 0; i < 8; i++) {
1855+ j = *zig2p++;
1856+ t0 += in[j] * quant[j];
1857+ j = *zig2p++;
1858+ t5 = in[j] * quant[j];
1859+ j = *zig2p++;
1860+ t2 = in[j] * quant[j];
1861+ j = *zig2p++;
1862+ t7 = in[j] * quant[j];
1863+ j = *zig2p++;
1864+ t1 = in[j] * quant[j];
1865+ j = *zig2p++;
1866+ t4 = in[j] * quant[j];
1867+ j = *zig2p++;
1868+ t3 = in[j] * quant[j];
1869+ j = *zig2p++;
1870+ t6 = in[j] * quant[j];
1871+ IDCT;
1872+ tmpp[0 * 8] = t0;
1873+ tmpp[1 * 8] = t1;
1874+ tmpp[2 * 8] = t2;
1875+ tmpp[3 * 8] = t3;
1876+ tmpp[4 * 8] = t4;
1877+ tmpp[5 * 8] = t5;
1878+ tmpp[6 * 8] = t6;
1879+ tmpp[7 * 8] = t7;
1880+ tmpp++;
1881+ t0 = 0;
1882+ }
1883+ for (i = 0; i < 8; i++) {
1884+ t0 = tmp[8 * i + 0];
1885+ t1 = tmp[8 * i + 1];
1886+ t2 = tmp[8 * i + 2];
1887+ t3 = tmp[8 * i + 3];
1888+ t4 = tmp[8 * i + 4];
1889+ t5 = tmp[8 * i + 5];
1890+ t6 = tmp[8 * i + 6];
1891+ t7 = tmp[8 * i + 7];
1892+ IDCT;
1893+ out[8 * i + 0] = ITOINT(t0);
1894+ out[8 * i + 1] = ITOINT(t1);
1895+ out[8 * i + 2] = ITOINT(t2);
1896+ out[8 * i + 3] = ITOINT(t3);
1897+ out[8 * i + 4] = ITOINT(t4);
1898+ out[8 * i + 5] = ITOINT(t5);
1899+ out[8 * i + 6] = ITOINT(t6);
1900+ out[8 * i + 7] = ITOINT(t7);
1901+ }
1902+}
1903+
1904+static unsigned char zig[64] = {
1905+ 0, 1, 5, 6, 14, 15, 27, 28,
1906+ 2, 4, 7, 13, 16, 26, 29, 42,
1907+ 3, 8, 12, 17, 25, 30, 41, 43,
1908+ 9, 11, 18, 24, 31, 40, 44, 53,
1909+ 10, 19, 23, 32, 39, 45, 52, 54,
1910+ 20, 22, 33, 38, 46, 51, 55, 60,
1911+ 21, 34, 37, 47, 50, 56, 59, 61,
1912+ 35, 36, 48, 49, 57, 58, 62, 63
1913+};
1914+
1915+static PREC aaidct[8] = {
1916+ IFIX(0.3535533906), IFIX(0.4903926402),
1917+ IFIX(0.4619397663), IFIX(0.4157348062),
1918+ IFIX(0.3535533906), IFIX(0.2777851165),
1919+ IFIX(0.1913417162), IFIX(0.0975451610)
1920+};
1921+
1922+
1923+static void idctqtab(qin, qout)
1924+unsigned char *qin;
1925+PREC *qout;
1926+{
1927+ int i, j;
1928+
1929+ for (i = 0; i < 8; i++)
1930+ for (j = 0; j < 8; j++)
1931+ qout[zig[i * 8 + j]] = qin[zig[i * 8 + j]] *
1932+ IMULT(aaidct[i], aaidct[j]);
1933+}
1934+
1935+static void scaleidctqtab(q, sc)
1936+PREC *q;
1937+PREC sc;
1938+{
1939+ int i;
1940+
1941+ for (i = 0; i < 64; i++)
1942+ q[i] = IMULT(q[i], sc);
1943+}
1944+
1945+/****************************************************************/
1946+/************** color decoder ***************/
1947+/****************************************************************/
1948+
1949+#define ROUND
1950+
1951+/*
1952+ * YCbCr Color transformation:
1953+ *
1954+ * y:0..255 Cb:-128..127 Cr:-128..127
1955+ *
1956+ * R = Y + 1.40200 * Cr
1957+ * G = Y - 0.34414 * Cb - 0.71414 * Cr
1958+ * B = Y + 1.77200 * Cb
1959+ *
1960+ * =>
1961+ * Cr *= 1.40200;
1962+ * Cb *= 1.77200;
1963+ * Cg = 0.19421 * Cb + .50937 * Cr;
1964+ * R = Y + Cr;
1965+ * G = Y - Cg;
1966+ * B = Y + Cb;
1967+ *
1968+ * =>
1969+ * Cg = (50 * Cb + 130 * Cr + 128) >> 8;
1970+ */
1971+
1972+static void initcol(q)
1973+PREC q[][64];
1974+{
1975+ scaleidctqtab(q[1], IFIX(1.77200));
1976+ scaleidctqtab(q[2], IFIX(1.40200));
1977+}
1978+
1979+/* This is optimized for the stupid sun SUNWspro compiler. */
1980+#define STORECLAMP(a,x) \
1981+( \
1982+ (a) = (x), \
1983+ (unsigned int)(x) >= 256 ? \
1984+ ((a) = (x) < 0 ? 0 : 255) \
1985+ : \
1986+ 0 \
1987+)
1988+
1989+#define CLAMP(x) ((unsigned int)(x) >= 256 ? ((x) < 0 ? 0 : 255) : (x))
1990+
1991+#ifdef ROUND
1992+
1993+#define CBCRCG(yin, xin) \
1994+( \
1995+ cb = outc[0 +yin*8+xin], \
1996+ cr = outc[64+yin*8+xin], \
1997+ cg = (50 * cb + 130 * cr + 128) >> 8 \
1998+)
1999+
2000+#else
2001+
2002+#define CBCRCG(yin, xin) \
2003+( \
2004+ cb = outc[0 +yin*8+xin], \
2005+ cr = outc[64+yin*8+xin], \
2006+ cg = (3 * cb + 8 * cr) >> 4 \
2007+)
2008+
2009+#endif
2010+
2011+#define PIC(yin, xin, p, xout) \
2012+( \
2013+ y = outy[(yin) * 8 + xin], \
2014+ STORECLAMP(p[(xout) * 3 + 0], y + cr), \
2015+ STORECLAMP(p[(xout) * 3 + 1], y - cg), \
2016+ STORECLAMP(p[(xout) * 3 + 2], y + cb) \
2017+)
2018+
2019+#ifdef __LITTLE_ENDIAN
2020+#define PIC_16(yin, xin, p, xout, add) \
2021+( \
2022+ y = outy[(yin) * 8 + xin], \
2023+ y = ((CLAMP(y + cr + add*2+1) & 0xf8) << 8) | \
2024+ ((CLAMP(y - cg + add ) & 0xfc) << 3) | \
2025+ ((CLAMP(y + cb + add*2+1) ) >> 3), \
2026+ p[(xout) * 2 + 0] = y & 0xff, \
2027+ p[(xout) * 2 + 1] = y >> 8 \
2028+)
2029+#else
2030+#ifdef CONFIG_PPC
2031+#define PIC_16(yin, xin, p, xout, add) \
2032+( \
2033+ y = outy[(yin) * 8 + xin], \
2034+ y = ((CLAMP(y + cr + add*2+1) & 0xf8) << 7) | \
2035+ ((CLAMP(y - cg + add*2+1) & 0xf8) << 2) | \
2036+ ((CLAMP(y + cb + add*2+1) ) >> 3), \
2037+ p[(xout) * 2 + 0] = y >> 8, \
2038+ p[(xout) * 2 + 1] = y & 0xff \
2039+)
2040+#else
2041+#define PIC_16(yin, xin, p, xout, add) \
2042+( \
2043+ y = outy[(yin) * 8 + xin], \
2044+ y = ((CLAMP(y + cr + add*2+1) & 0xf8) << 8) | \
2045+ ((CLAMP(y - cg + add ) & 0xfc) << 3) | \
2046+ ((CLAMP(y + cb + add*2+1) ) >> 3), \
2047+ p[(xout) * 2 + 0] = y >> 8, \
2048+ p[(xout) * 2 + 1] = y & 0xff \
2049+)
2050+#endif
2051+#endif
2052+
2053+#define PIC221111(xin) \
2054+( \
2055+ CBCRCG(0, xin), \
2056+ PIC(xin / 4 * 8 + 0, (xin & 3) * 2 + 0, pic0, xin * 2 + 0), \
2057+ PIC(xin / 4 * 8 + 0, (xin & 3) * 2 + 1, pic0, xin * 2 + 1), \
2058+ PIC(xin / 4 * 8 + 1, (xin & 3) * 2 + 0, pic1, xin * 2 + 0), \
2059+ PIC(xin / 4 * 8 + 1, (xin & 3) * 2 + 1, pic1, xin * 2 + 1) \
2060+)
2061+
2062+#define PIC221111_16(xin) \
2063+( \
2064+ CBCRCG(0, xin), \
2065+ PIC_16(xin / 4 * 8 + 0, (xin & 3) * 2 + 0, pic0, xin * 2 + 0, 3), \
2066+ PIC_16(xin / 4 * 8 + 0, (xin & 3) * 2 + 1, pic0, xin * 2 + 1, 0), \
2067+ PIC_16(xin / 4 * 8 + 1, (xin & 3) * 2 + 0, pic1, xin * 2 + 0, 1), \
2068+ PIC_16(xin / 4 * 8 + 1, (xin & 3) * 2 + 1, pic1, xin * 2 + 1, 2) \
2069+)
2070+
2071+static void col221111(out, pic, width)
2072+int *out;
2073+unsigned char *pic;
2074+int width;
2075+{
2076+ int i, j, k;
2077+ unsigned char *pic0, *pic1;
2078+ int *outy, *outc;
2079+ int cr, cg, cb, y;
2080+
2081+ pic0 = pic;
2082+ pic1 = pic + width;
2083+ outy = out;
2084+ outc = out + 64 * 4;
2085+ for (i = 2; i > 0; i--) {
2086+ for (j = 4; j > 0; j--) {
2087+ for (k = 0; k < 8; k++) {
2088+ PIC221111(k);
2089+ }
2090+ outc += 8;
2091+ outy += 16;
2092+ pic0 += 2 * width;
2093+ pic1 += 2 * width;
2094+ }
2095+ outy += 64 * 2 - 16 * 4;
2096+ }
2097+}
2098+
2099+static void col221111_16(out, pic, width)
2100+int *out;
2101+unsigned char *pic;
2102+int width;
2103+{
2104+ int i, j, k;
2105+ unsigned char *pic0, *pic1;
2106+ int *outy, *outc;
2107+ int cr, cg, cb, y;
2108+
2109+ pic0 = pic;
2110+ pic1 = pic + width;
2111+ outy = out;
2112+ outc = out + 64 * 4;
2113+ for (i = 2; i > 0; i--) {
2114+ for (j = 4; j > 0; j--) {
2115+ for (k = 0; k < 8; k++) {
2116+ PIC221111_16(k);
2117+ }
2118+ outc += 8;
2119+ outy += 16;
2120+ pic0 += 2 * width;
2121+ pic1 += 2 * width;
2122+ }
2123+ outy += 64 * 2 - 16 * 4;
2124+ }
2125+}
2126diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/bootsplash/decode-jpg.h linux-2.6.15-VinX/drivers/video/bootsplash/decode-jpg.h
2127--- linux-2.6.15/drivers/video/bootsplash/decode-jpg.h 1970-01-01 01:00:00.000000000 +0100
2128+++ linux-2.6.15-VinX/drivers/video/bootsplash/decode-jpg.h 2006-01-05 01:17:11.000000000 +0100
2129@@ -0,0 +1,35 @@
2130+/*
2131+ * linux/drivers/video/bootsplash/decode-jpg.h - a tiny jpeg decoder.
2132+ *
2133+ * (w) August 2001 by Michael Schroeder, <mls@suse.de>
2134+ */
2135+
2136+#ifndef __DECODE_JPG_H
2137+#define __DECODE_JPG_H
2138+
2139+#define ERR_NO_SOI 1
2140+#define ERR_NOT_8BIT 2
2141+#define ERR_HEIGHT_MISMATCH 3
2142+#define ERR_WIDTH_MISMATCH 4
2143+#define ERR_BAD_WIDTH_OR_HEIGHT 5
2144+#define ERR_TOO_MANY_COMPPS 6
2145+#define ERR_ILLEGAL_HV 7
2146+#define ERR_QUANT_TABLE_SELECTOR 8
2147+#define ERR_NOT_YCBCR_221111 9
2148+#define ERR_UNKNOWN_CID_IN_SCAN 10
2149+#define ERR_NOT_SEQUENTIAL_DCT 11
2150+#define ERR_WRONG_MARKER 12
2151+#define ERR_NO_EOI 13
2152+#define ERR_BAD_TABLES 14
2153+#define ERR_DEPTH_MISMATCH 15
2154+
2155+struct jpeg_decdata {
2156+ int dcts[6 * 64 + 16];
2157+ int out[64 * 6];
2158+ int dquant[3][64];
2159+};
2160+
2161+extern int jpeg_decode(unsigned char *, unsigned char *, int, int, int, struct jpeg_decdata *);
2162+extern int jpeg_check_size(unsigned char *, int, int);
2163+
2164+#endif
2165diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/bootsplash/render.c linux-2.6.15-VinX/drivers/video/bootsplash/render.c
2166--- linux-2.6.15/drivers/video/bootsplash/render.c 1970-01-01 01:00:00.000000000 +0100
2167+++ linux-2.6.15-VinX/drivers/video/bootsplash/render.c 2006-01-05 01:17:11.000000000 +0100
2168@@ -0,0 +1,316 @@
2169+/*
2170+ * linux/drivers/video/bootsplash/render.c - splash screen render functions.
2171+ */
2172+
2173+#include <linux/config.h>
2174+#include <linux/module.h>
2175+#include <linux/types.h>
2176+#include <linux/fb.h>
2177+#include <linux/vt_kern.h>
2178+#include <asm/irq.h>
2179+#include <asm/system.h>
2180+
2181+#include "../console/fbcon.h"
2182+#include "bootsplash.h"
2183+
2184+void splash_putcs(struct splash_data *sd, struct vc_data *vc, struct fb_info *info,
2185+ const unsigned short *s, int count, int ypos, int xpos)
2186+{
2187+ unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
2188+ int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
2189+ int fgshift = (vc->vc_hi_font_mask) ? 9 : 8;
2190+ u8 *src;
2191+ u8 *dst, *splashsrc;
2192+ unsigned int d, x, y;
2193+ u32 dd, fgx, bgx;
2194+ u16 c = scr_readw(s);
2195+
2196+ int fg_color, bg_color, transparent;
2197+ fg_color = attr_fgcol(fgshift, c);
2198+ bg_color = attr_bgcol(bgshift, c);
2199+ transparent = sd->splash_color == bg_color;
2200+ xpos = xpos * vc->vc_font.width + sd->splash_text_xo;
2201+ ypos = ypos * vc->vc_font.height + sd->splash_text_yo;
2202+ splashsrc = (u8 *)(info->splash_pic + ypos * info->splash_bytes + xpos * 2);
2203+ dst = (u8 *)(info->screen_base + ypos * info->fix.line_length + xpos * 2);
2204+
2205+ fgx = ((u32 *)info->pseudo_palette)[fg_color];
2206+ if (transparent && sd->splash_color == 15) {
2207+ if (fgx == 0xffea)
2208+ fgx = 0xfe4a;
2209+ else if (fgx == 0x57ea)
2210+ fgx = 0x0540;
2211+ else if (fgx == 0xffff)
2212+ fgx = 0x52aa;
2213+ }
2214+ bgx = ((u32 *)info->pseudo_palette)[bg_color];
2215+ d = 0;
2216+
2217+ while (count--) {
2218+ c = scr_readw(s++);
2219+ src = vc->vc_font.data + (c & charmask) * vc->vc_font.height * ((vc->vc_font.width + 7) >> 3);
2220+
2221+ for (y = 0; y < vc->vc_font.height; y++) {
2222+ for (x = 0; x < vc->vc_font.width; x += 2) {
2223+ if ((x & 7) == 0)
2224+ d = *src++;
2225+ if (d & 0x80)
2226+ dd = fgx;
2227+ else
2228+ dd = transparent ? *(u16 *)splashsrc : bgx;
2229+ splashsrc += 2;
2230+ if (d & 0x40)
2231+ dd |= fgx << 16;
2232+ else
2233+ dd |= (transparent ? *(u16 *)splashsrc : bgx) << 16;
2234+ splashsrc += 2;
2235+ d <<= 2;
2236+ fb_writel(dd, dst);
2237+ dst += 4;
2238+ }
2239+ dst += info->fix.line_length - vc->vc_font.width * 2;
2240+ splashsrc += info->splash_bytes - vc->vc_font.width * 2;
2241+ }
2242+ dst -= info->fix.line_length * vc->vc_font.height - vc->vc_font.width * 2;
2243+ splashsrc -= info->splash_bytes * vc->vc_font.height - vc->vc_font.width * 2;
2244+ }
2245+}
2246+
2247+static void splash_renderc(struct splash_data *sd, struct fb_info *info, int fg_color, int bg_color, u8 *src, int ypos, int xpos, int height, int width)
2248+{
2249+ int transparent = sd->splash_color == bg_color;
2250+ u32 dd, fgx, bgx;
2251+ u8 *dst, *splashsrc;
2252+ unsigned int d, x, y;
2253+
2254+ splashsrc = (u8 *)(info->splash_pic + ypos * info->splash_bytes + xpos * 2);
2255+ dst = (u8 *)(info->screen_base + ypos * info->fix.line_length + xpos * 2);
2256+ fgx = ((u32 *)info->pseudo_palette)[fg_color];
2257+ if (transparent && sd->splash_color == 15) {
2258+ if (fgx == 0xffea)
2259+ fgx = 0xfe4a;
2260+ else if (fgx == 0x57ea)
2261+ fgx = 0x0540;
2262+ else if (fgx == 0xffff)
2263+ fgx = 0x52aa;
2264+ }
2265+ bgx = ((u32 *)info->pseudo_palette)[bg_color];
2266+ d = 0;
2267+ for (y = 0; y < height; y++) {
2268+ for (x = 0; x < width; x += 2) {
2269+ if ((x & 7) == 0)
2270+ d = *src++;
2271+ if (d & 0x80)
2272+ dd = fgx;
2273+ else
2274+ dd = transparent ? *(u16 *)splashsrc : bgx;
2275+ splashsrc += 2;
2276+ if (d & 0x40)
2277+ dd |= fgx << 16;
2278+ else
2279+ dd |= (transparent ? *(u16 *)splashsrc : bgx) << 16;
2280+ splashsrc += 2;
2281+ d <<= 2;
2282+ fb_writel(dd, dst);
2283+ dst += 4;
2284+ }
2285+ dst += info->fix.line_length - width * 2;
2286+ splashsrc += info->splash_bytes - width * 2;
2287+ }
2288+}
2289+
2290+void splash_putc(struct splash_data *sd, struct vc_data *vc, struct fb_info *info,
2291+ int c, int ypos, int xpos)
2292+{
2293+ unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
2294+ int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
2295+ int fgshift = (vc->vc_hi_font_mask) ? 9 : 8;
2296+ u8 *src = vc->vc_font.data + (c & charmask) * vc->vc_font.height * ((vc->vc_font.width + 7) >> 3);
2297+ xpos = xpos * vc->vc_font.width + sd->splash_text_xo;
2298+ ypos = ypos * vc->vc_font.height + sd->splash_text_yo;
2299+ splash_renderc(sd, info, attr_fgcol(fgshift, c), attr_bgcol(bgshift, c), src, ypos, xpos, vc->vc_font.height, vc->vc_font.width);
2300+}
2301+
2302+void splashcopy(u8 *dst, u8 *src, int height, int width, int dstbytes, int srcbytes)
2303+{
2304+ int i;
2305+
2306+ while (height-- > 0) {
2307+ u32 *p = (u32 *)dst;
2308+ u32 *q = (u32 *)src;
2309+ for (i=0; i < width/4; i++) {
2310+ fb_writel(*q++,p++);
2311+ fb_writel(*q++,p++);
2312+ }
2313+ if (width & 2)
2314+ fb_writel(*q++,p++);
2315+ if (width & 1)
2316+ fb_writew(*(u16*)q,(u16*)p);
2317+ dst += dstbytes;
2318+ src += srcbytes;
2319+ }
2320+}
2321+
2322+static void splashset(u8 *dst, int height, int width, int dstbytes, u32 bgx) {
2323+ int i;
2324+
2325+ bgx |= bgx << 16;
2326+ while (height-- > 0) {
2327+ u32 *p = (u32 *)dst;
2328+ for (i=0; i < width/4; i++) {
2329+ fb_writel(bgx,p++);
2330+ fb_writel(bgx,p++);
2331+ }
2332+ if (width & 2)
2333+ fb_writel(bgx,p++);
2334+ if (width & 1)
2335+ fb_writew(bgx,(u16*)p);
2336+ dst += dstbytes;
2337+ }
2338+}
2339+
2340+static void splashfill(struct fb_info *info, int sy, int sx, int height, int width) {
2341+ splashcopy((u8 *)(info->screen_base + sy * info->fix.line_length + sx * 2), (u8 *)(info->splash_pic + sy * info->splash_bytes + sx * 2), height, width, info->fix.line_length, info->splash_bytes);
2342+}
2343+
2344+void splash_clear(struct splash_data *sd, struct vc_data *vc, struct fb_info *info, int sy,
2345+ int sx, int height, int width)
2346+{
2347+ int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
2348+ int bg_color = attr_bgcol_ec(bgshift, vc);
2349+ int transparent = sd->splash_color == bg_color;
2350+ u32 bgx;
2351+ u8 *dst;
2352+
2353+ sy = sy * vc->vc_font.height + sd->splash_text_yo;
2354+ sx = sx * vc->vc_font.width + sd->splash_text_xo;
2355+ height *= vc->vc_font.height;
2356+ width *= vc->vc_font.width;
2357+ if (transparent) {
2358+ splashfill(info, sy, sx, height, width);
2359+ return;
2360+ }
2361+ dst = (u8 *)(info->screen_base + sy * info->fix.line_length + sx * 2);
2362+ bgx = ((u32 *)info->pseudo_palette)[bg_color];
2363+ splashset(dst, height, width, info->fix.line_length, bgx);
2364+}
2365+
2366+void splash_bmove(struct splash_data *sd, struct vc_data *vc, struct fb_info *info, int sy,
2367+ int sx, int dy, int dx, int height, int width)
2368+{
2369+ struct fb_copyarea area;
2370+
2371+ area.sx = sx * vc->vc_font.width;
2372+ area.sy = sy * vc->vc_font.height;
2373+ area.dx = dx * vc->vc_font.width;
2374+ area.dy = dy * vc->vc_font.height;
2375+ area.sx += sd->splash_text_xo;
2376+ area.sy += sd->splash_text_yo;
2377+ area.dx += sd->splash_text_xo;
2378+ area.dy += sd->splash_text_yo;
2379+ area.height = height * vc->vc_font.height;
2380+ area.width = width * vc->vc_font.width;
2381+
2382+ info->fbops->fb_copyarea(info, &area);
2383+}
2384+
2385+void splash_clear_margins(struct splash_data *sd, struct vc_data *vc, struct fb_info *info,
2386+ int bottom_only)
2387+{
2388+ unsigned int tw = vc->vc_cols*vc->vc_font.width;
2389+ unsigned int th = vc->vc_rows*vc->vc_font.height;
2390+
2391+ if (!bottom_only) {
2392+ /* top margin */
2393+ splashfill(info, 0, 0, sd->splash_text_yo, info->var.xres);
2394+ /* left margin */
2395+ splashfill(info, sd->splash_text_yo, 0, th, sd->splash_text_xo);
2396+ /* right margin */
2397+ splashfill(info, sd->splash_text_yo, sd->splash_text_xo + tw, th, info->var.xres - sd->splash_text_xo - tw);
2398+
2399+ }
2400+ splashfill(info, sd->splash_text_yo + th, 0, info->var.yres - sd->splash_text_yo - th, info->var.xres);
2401+}
2402+
2403+int splash_cursor(struct splash_data *sd, struct fb_info *info, struct fb_cursor *cursor)
2404+{
2405+ int i;
2406+ unsigned int dsize, s_pitch;
2407+
2408+ if (info->state != FBINFO_STATE_RUNNING)
2409+ return 0;
2410+
2411+ s_pitch = (cursor->image.width + 7) >> 3;
2412+ dsize = s_pitch * cursor->image.height;
2413+ if (cursor->enable) {
2414+ switch (cursor->rop) {
2415+ case ROP_XOR:
2416+ for (i = 0; i < dsize; i++)
2417+ info->fb_cursordata[i] = cursor->image.data[i] ^ cursor->mask[i];
2418+ break;
2419+ case ROP_COPY:
2420+ default:
2421+ for (i = 0; i < dsize; i++)
2422+ info->fb_cursordata[i] = cursor->image.data[i] & cursor->mask[i];
2423+ break;
2424+ }
2425+ } else if (info->fb_cursordata != cursor->image.data)
2426+ memcpy(info->fb_cursordata, cursor->image.data, dsize);
2427+ cursor->image.data = info->fb_cursordata;
2428+ splash_renderc(sd, info, cursor->image.fg_color, cursor->image.bg_color, (u8 *)info->fb_cursordata, cursor->image.dy + sd->splash_text_yo, cursor->image.dx + sd->splash_text_xo, cursor->image.height, cursor->image.width);
2429+ return 0;
2430+}
2431+
2432+void splash_bmove_redraw(struct splash_data *sd, struct vc_data *vc, struct fb_info *info, int y, int sx, int dx, int width)
2433+{
2434+ unsigned short *d = (unsigned short *) (vc->vc_origin + vc->vc_size_row * y + dx * 2);
2435+ unsigned short *s = d + (dx - sx);
2436+ unsigned short *start = d;
2437+ unsigned short *ls = d;
2438+ unsigned short *le = d + width;
2439+ unsigned short c;
2440+ int x = dx;
2441+ unsigned short attr = 1;
2442+
2443+ do {
2444+ c = scr_readw(d);
2445+ if (attr != (c & 0xff00)) {
2446+ attr = c & 0xff00;
2447+ if (d > start) {
2448+ splash_putcs(sd, vc, info, start, d - start, y, x);
2449+ x += d - start;
2450+ start = d;
2451+ }
2452+ }
2453+ if (s >= ls && s < le && c == scr_readw(s)) {
2454+ if (d > start) {
2455+ splash_putcs(sd, vc, info, start, d - start, y, x);
2456+ x += d - start + 1;
2457+ start = d + 1;
2458+ } else {
2459+ x++;
2460+ start++;
2461+ }
2462+ }
2463+ s++;
2464+ d++;
2465+ } while (d < le);
2466+ if (d > start)
2467+ splash_putcs(sd, vc, info, start, d - start, y, x);
2468+}
2469+
2470+void splash_blank(struct splash_data *sd, struct vc_data *vc, struct fb_info *info, int blank)
2471+{
2472+ if (blank) {
2473+ if (info->silent_screen_base)
2474+ splashset((u8 *)info->silent_screen_base, info->var.yres, info->var.xres, info->fix.line_length, 0);
2475+ splashset((u8 *)info->screen_base, info->var.yres, info->var.xres, info->fix.line_length, 0);
2476+ } else {
2477+ if (info->silent_screen_base)
2478+ splash_prepare(vc, info);
2479+ splash_clear_margins(vc->vc_splash_data, vc, info, 0);
2480+ /* no longer needed, done in fbcon_blank */
2481+ /* update_screen(vc->vc_num); */
2482+ }
2483+}
2484+
2485diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/console/bitblit.c linux-2.6.15-VinX/drivers/video/console/bitblit.c
2486--- linux-2.6.15/drivers/video/console/bitblit.c 2006-01-03 04:21:10.000000000 +0100
2487+++ linux-2.6.15-VinX/drivers/video/console/bitblit.c 2006-01-05 01:22:17.000000000 +0100
2488@@ -18,6 +18,9 @@
2489 #include <linux/console.h>
2490 #include <asm/types.h>
2491 #include "fbcon.h"
2492+#ifdef CONFIG_BOOTSPLASH
2493+#include "../bootsplash/bootsplash.h"
2494+#endif
2495
2496 /*
2497 * Accelerated handlers.
2498@@ -48,6 +51,13 @@ static void bit_bmove(struct vc_data *vc
2499 {
2500 struct fb_copyarea area;
2501
2502+#ifdef CONFIG_BOOTSPLASH
2503+ if (info->splash_data) {
2504+ splash_bmove(info->splash_data, vc, info,
2505+ sy, sx, dy, dx, height, width);
2506+ return;
2507+ }
2508+#endif
2509 area.sx = sx * vc->vc_font.width;
2510 area.sy = sy * vc->vc_font.height;
2511 area.dx = dx * vc->vc_font.width;
2512@@ -64,6 +74,13 @@ static void bit_clear(struct vc_data *vc
2513 int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
2514 struct fb_fillrect region;
2515
2516+#ifdef CONFIG_BOOTSPLASH
2517+ if (info->splash_data) {
2518+ splash_clear(info->splash_data, vc, info,
2519+ sy, sx, height, width);
2520+ return;
2521+ }
2522+#endif
2523 region.color = attr_bgcol_ec(bgshift, vc);
2524 region.dx = sx * vc->vc_font.width;
2525 region.dy = sy * vc->vc_font.height;
2526@@ -161,6 +178,13 @@ static void bit_putcs(struct vc_data *vc
2527 image.height = vc->vc_font.height;
2528 image.depth = 1;
2529
2530+#ifdef CONFIG_BOOTSPLASH
2531+ if (info->splash_data) {
2532+ splash_putcs(info->splash_data, vc, info, s, count, yy, xx);
2533+ return;
2534+ }
2535+#endif
2536+
2537 if (attribute) {
2538 buf = kmalloc(cellsize, GFP_KERNEL);
2539 if (!buf)
2540@@ -214,6 +238,13 @@ static void bit_clear_margins(struct vc_
2541 unsigned int bs = info->var.yres - bh;
2542 struct fb_fillrect region;
2543
2544+#ifdef CONFIG_BOOTSPLASH
2545+ if (info->splash_data) {
2546+ splash_clear_margins(info->splash_data, vc, info, bottom_only);
2547+ return;
2548+ }
2549+#endif
2550+
2551 region.color = attr_bgcol_ec(bgshift, vc);
2552 region.rop = ROP_COPY;
2553
2554@@ -380,6 +411,14 @@ static void bit_cursor(struct vc_data *v
2555 cursor.image.depth = 1;
2556 cursor.rop = ROP_XOR;
2557
2558+#ifdef CONFIG_BOOTSPLASH
2559+ if (info->splash_data) {
2560+ splash_cursor(info->splash_data, info, &cursor);
2561+ ops->cursor_reset = 0;
2562+ return;
2563+ }
2564+#endif
2565+
2566 if (info->fbops->fb_cursor)
2567 err = info->fbops->fb_cursor(info, &cursor);
2568
2569diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/console/fbcon.c linux-2.6.15-VinX/drivers/video/console/fbcon.c
2570--- linux-2.6.15/drivers/video/console/fbcon.c 2006-01-03 04:21:10.000000000 +0100
2571+++ linux-2.6.15-VinX/drivers/video/console/fbcon.c 2006-01-05 01:31:49.000000000 +0100
2572@@ -94,6 +94,10 @@
2573
2574 #include "fbcon.h"
2575
2576+#ifdef CONFIG_BOOTSPLASH
2577+#include "../bootsplash/bootsplash.h"
2578+#endif
2579+
2580 #ifdef FBCONDEBUG
2581 # define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
2582 #else
2583@@ -107,8 +111,7 @@ enum {
2584 };
2585
2586 static struct display fb_display[MAX_NR_CONSOLES];
2587-
2588-static signed char con2fb_map[MAX_NR_CONSOLES];
2589+signed char con2fb_map[MAX_NR_CONSOLES];
2590 static signed char con2fb_map_boot[MAX_NR_CONSOLES];
2591 static int logo_height;
2592 static int logo_lines;
2593@@ -559,6 +562,10 @@ static int fbcon_takeover(int show_logo)
2594 for (i = first_fb_vc; i <= last_fb_vc; i++)
2595 con2fb_map[i] = info_idx;
2596
2597+#ifdef CONFIG_BOOTSPLASH
2598+ splash_init();
2599+#endif
2600+
2601 err = take_over_console(&fb_con, first_fb_vc, last_fb_vc,
2602 fbcon_is_default);
2603 if (err) {
2604@@ -1101,6 +1108,16 @@ static void fbcon_init(struct vc_data *v
2605 new_rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
2606 new_cols /= vc->vc_font.width;
2607 new_rows /= vc->vc_font.height;
2608+
2609+#ifdef CONFIG_BOOTSPLASH
2610+ if (vc->vc_splash_data && vc->vc_splash_data->splash_state) {
2611+ new_cols = vc->vc_splash_data->splash_text_wi / vc->vc_font.width;
2612+ new_rows = vc->vc_splash_data->splash_text_he / vc->vc_font.height;
2613+ logo = 0;
2614+ con_remap_def_color(vc, vc->vc_splash_data->splash_color << 4 | vc->vc_splash_data->splash_fg_color);
2615+ }
2616+#endif
2617+
2618 vc_resize(vc, new_cols, new_rows);
2619
2620 /*
2621@@ -1718,6 +1735,10 @@ static int fbcon_scroll(struct vc_data *
2622 fbcon_softback_note(vc, t, count);
2623 if (logo_shown >= 0)
2624 goto redraw_up;
2625+#ifdef CONFIG_BOOTSPLASH
2626+ if (info->splash_data)
2627+ goto redraw_up;
2628+#endif
2629 switch (p->scrollmode) {
2630 case SCROLL_MOVE:
2631 ops->bmove(vc, info, t + count, 0, t, 0,
2632@@ -1802,6 +1823,10 @@ static int fbcon_scroll(struct vc_data *
2633 case SM_DOWN:
2634 if (count > vc->vc_rows) /* Maximum realistic size */
2635 count = vc->vc_rows;
2636+#ifdef CONFIG_BOOTSPLASH
2637+ if (info->splash_data)
2638+ goto redraw_down;
2639+#endif
2640 if (logo_shown >= 0)
2641 goto redraw_down;
2642 switch (p->scrollmode) {
2643@@ -1946,6 +1971,14 @@ static void fbcon_bmove_rec(struct vc_da
2644 }
2645 return;
2646 }
2647+
2648+#ifdef CONFIG_BOOTSPLASH
2649+ if (info->splash_data && sy == dy && height == 1) {
2650+ /* must use slower redraw bmove to keep background pic intact */
2651+ splash_bmove_redraw(info->splash_data, vc, info, sy, sx, dx, width);
2652+ return;
2653+ }
2654+#endif
2655 ops->bmove(vc, info, real_y(p, sy), sx, real_y(p, dy), dx,
2656 height, width);
2657 }
2658@@ -2053,6 +2086,10 @@ static int fbcon_switch(struct vc_data *
2659 info = registered_fb[con2fb_map[vc->vc_num]];
2660 ops = info->fbcon_par;
2661
2662+#ifdef CONFIG_BOOTSPLASH
2663+ splash_prepare(vc, info);
2664+#endif
2665+
2666 if (softback_top) {
2667 if (softback_lines)
2668 fbcon_set_origin(vc);
2669@@ -2173,6 +2210,12 @@ static int fbcon_switch(struct vc_data *
2670 static void fbcon_generic_blank(struct vc_data *vc, struct fb_info *info,
2671 int blank)
2672 {
2673+#ifdef CONFIG_BOOTSPLASH
2674+ if (info->splash_data) {
2675+ splash_blank(info->splash_data, vc, info, blank);
2676+ return;
2677+ }
2678+#endif
2679 if (blank) {
2680 unsigned short charmask = vc->vc_hi_font_mask ?
2681 0x1ff : 0xff;
2682@@ -2373,10 +2416,19 @@ static int fbcon_do_set_font(struct vc_d
2683 if (resize) {
2684 int cols, rows;
2685
2686+ u32 xres = info->var.xres, yres = info->var.yres;
2687 cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres);
2688 rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
2689 cols /= w;
2690 rows /= h;
2691+
2692+#ifdef CONFIG_BOOTSPLASH
2693+ if (info->splash_data) {
2694+ xres = info->splash_data->splash_text_wi;
2695+ yres = info->splash_data->splash_text_he;
2696+ }
2697+#endif
2698+
2699 vc_resize(vc, cols, rows);
2700 if (CON_IS_VISIBLE(vc) && softback_buf)
2701 fbcon_update_softback(vc);
2702diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/console/fbcon.h linux-2.6.15-VinX/drivers/video/console/fbcon.h
2703--- linux-2.6.15/drivers/video/console/fbcon.h 2006-01-03 04:21:10.000000000 +0100
2704+++ linux-2.6.15-VinX/drivers/video/console/fbcon.h 2006-01-05 01:17:11.000000000 +0100
2705@@ -26,6 +26,34 @@
2706 * low-level frame buffer device
2707 */
2708
2709+#ifdef CONFIG_BOOTSPLASH
2710+struct splash_data {
2711+ int splash_state; /* show splash? */
2712+ int splash_color; /* transparent color */
2713+ int splash_fg_color; /* foreground color */
2714+ int splash_width; /* width of image */
2715+ int splash_height; /* height of image */
2716+ int splash_text_xo; /* text area origin */
2717+ int splash_text_yo;
2718+ int splash_text_wi; /* text area size */
2719+ int splash_text_he;
2720+ int splash_showtext; /* silent/verbose mode */
2721+ int splash_boxcount;
2722+ int splash_percent;
2723+ int splash_overpaintok; /* is it ok to overpaint boxes */
2724+ int splash_palcnt;
2725+ char *oldscreen_base; /* pointer to top of virtual screen */
2726+ unsigned char *splash_boxes;
2727+ unsigned char *splash_jpeg; /* jpeg */
2728+ unsigned char *splash_palette; /* palette for 8-bit */
2729+
2730+ int splash_dosilent; /* show silent jpeg */
2731+ unsigned char *splash_silentjpeg;
2732+ unsigned char *splash_sboxes;
2733+ int splash_sboxcount;
2734+};
2735+#endif
2736+
2737 struct display {
2738 /* Filled in by the low-level console driver */
2739 const u_char *fontdata;
2740diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/drivers/video/vesafb.c linux-2.6.15-VinX/drivers/video/vesafb.c
2741--- linux-2.6.15/drivers/video/vesafb.c 2006-01-03 04:21:10.000000000 +0100
2742+++ linux-2.6.15-VinX/drivers/video/vesafb.c 2006-01-05 01:37:18.000000000 +0100
2743@@ -201,7 +201,10 @@ static int vesafb_setcolreg(unsigned reg
2744 return 0;
2745 }
2746
2747-static struct fb_ops vesafb_ops = {
2748+#ifndef CONFIG_BOOTSPLASH
2749+static
2750+#endif
2751+struct fb_ops vesafb_ops = {
2752 .owner = THIS_MODULE,
2753 .fb_setcolreg = vesafb_setcolreg,
2754 .fb_pan_display = vesafb_pan_display,
2755@@ -285,6 +288,11 @@ static int __init vesafb_probe(struct pl
2756 * option to simply use size_total as that
2757 * wastes plenty of kernel address space. */
2758 size_remap = size_vmode * 2;
2759+
2760+#ifdef CONFIG_BOOTSPLASH
2761+ size_remap *= 2; /* some more for the images */
2762+#endif
2763+
2764 if (vram_remap)
2765 size_remap = vram_remap * 1024 * 1024;
2766 if (size_remap < size_vmode)
2767diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/include/linux/console_struct.h linux-2.6.15-VinX/include/linux/console_struct.h
2768--- linux-2.6.15/include/linux/console_struct.h 2006-01-03 04:21:10.000000000 +0100
2769+++ linux-2.6.15-VinX/include/linux/console_struct.h 2006-01-05 01:38:58.000000000 +0100
2770@@ -97,6 +97,11 @@ struct vc_data {
2771 struct vc_data **vc_display_fg; /* [!] Ptr to var holding fg console for this display */
2772 unsigned long vc_uni_pagedir;
2773 unsigned long *vc_uni_pagedir_loc; /* [!] Location of uni_pagedir variable for this console */
2774+
2775+#ifdef CONFIG_BOOTSPLASH
2776+ struct splash_data *vc_splash_data;
2777+#endif
2778+
2779 /* additional information is in vt_kern.h */
2780 };
2781
2782diff -ruNp -X linux-2.6.15/Documentation/dontdiff linux-2.6.15/include/linux/fb.h linux-2.6.15-VinX/include/linux/fb.h
2783--- linux-2.6.15/include/linux/fb.h 2006-01-03 04:21:10.000000000 +0100
2784+++ linux-2.6.15-VinX/include/linux/fb.h 2006-01-05 01:17:11.000000000 +0100
2785@@ -771,6 +771,14 @@ struct fb_info {
2786 void *fbcon_par; /* fbcon use-only private area */
2787 /* From here on everything is device dependent */
2788 void *par;
2789+#ifdef CONFIG_BOOTSPLASH
2790+ struct splash_data *splash_data;
2791+ unsigned char *splash_pic;
2792+ int splash_pic_size;
2793+ int splash_bytes;
2794+ char *silent_screen_base; /* real screen base */
2795+ char fb_cursordata[64];
2796+#endif
2797 };
2798
2799 #ifdef MODULE
Peter's tree of IPFire 2.x