]> git.ipfire.org Git - ipfire-2.x.git/blob - src/patches/bootsplash-3.1.6-2.6.15.diff
projects / ipfire-2.x.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
EXPERIMENTELLE Konfiguration fuer den Installer-Kernel.
[ipfire-2.x.git] / src / patches / bootsplash-3.1.6-2.6.15.diff
1 diff -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;
20 diff -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;
39 diff -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 */
74 diff -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
87 diff -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 \
98 diff -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 +
119 diff -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
128 diff -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 +
1116 diff -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
1164 diff -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 +}
2126 diff -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
2165 diff -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 +
2485 diff -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
2569 diff -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);
2702 diff -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;
2740 diff -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)
2767 diff -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
2782 diff -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
IPFire 2.x development tree