Attachment #13771 for bug #23369




		break;
	}
	return 0;
}

#ifdef CONFIG_FBCON_SPLASHSCREEN
void con_remap_def_color(int currcons, int new_color)
{
   unsigned short *sbuf = screenbuf;
   unsigned c, len = screenbuf_size >> 1;
   int old_color;
   
   if (sbuf) {
       old_color = def_color << 8;
       new_color <<= 8;
       while(len--) {
           c = *sbuf;
           if (((c ^ old_color) & 0xf000) == 0)
               *sbuf ^= (old_color ^ new_color) & 0xf000;
           if (((c ^ old_color) & 0x0f00) == 0)
               *sbuf ^= (old_color ^ new_color) & 0x0f00;
           sbuf++;
       }
       new_color >>= 8;
   }
   def_color = color = new_color;
   update_attr(currcons);
}
#endif


/*
 *	Visible symbols for modules
 */

EXPORT_SYMBOL(color_table);




		if(!test_and_clear_bit(keycode, key_down))
		    up_flag = kbd_unexpected_up(keycode);
	} else
		rep = test_and_set_bit(keycode, key_down);

#ifdef CONFIG_FBCON_SPLASHSCREEN
   /* This code has to be redone for some non-x86 platforms */
   if (keycode == 0x3c || keycode == 0x01) {   /* F2 and ESC on a PC keyboard */
       extern int splash_verbose(void);
       if (splash_verbose())
           goto out;
   }
#endif


#ifdef CONFIG_MAGIC_SYSRQ		/* Handle the SysRq Hack */
	if (keycode == SYSRQ_KEY) {
		sysrq_pressed = !up_flag;
		goto out;
	} else if (sysrq_pressed) {




#include <linux/kd.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/config.h>

#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/bitops.h>


	if (!tty->read_buf) {
		printk("n_tty_read_chan: called with read_buf == NULL?!?\n");
		return -EIO;
	}

#ifdef CONFIG_FBCON_SPLASHSCREEN
    if (file->f_dentry->d_inode->i_rdev == CONSOLE_DEV ||
                   file->f_dentry->d_inode->i_rdev == SYSCONS_DEV ||
                   file->f_dentry->d_inode->i_rdev == MKDEV(TTYAUX_MAJOR,0) ||
                   file->f_dentry->d_inode->i_rdev == MKDEV(TTY_MAJOR,1)) {
       extern int splash_verbose(void);
       (void)splash_verbose();
    }
#endif

	/* Job control check -- must be done at start and after
	   every sleep (POSIX.1 7.1.1.4). */
	/* NOTE: not yet done after every sleep pending a thorough
	   check of the logic of this change. -- jlc */
	/* don't stop on /dev/console */




export-objs    := fbmem.o fbcmap.o fbcon.o fbmon.o modedb.o \
		  fbcon-afb.o fbcon-ilbm.o \
		  fbcon-vga.o fbcon-iplan2p2.o fbcon-iplan2p4.o \
		  fbcon-iplan2p8.o fbcon-vga-planes.o fbcon-cfb16.o \
		  fbcon-cfb2.o fbcon-cfb24.o fbcon-cfb32.o fbcon-cfb4.o \
		  fbcon-cfb8.o fbcon-splash16.o fbcon-mac.o fbcon-mfb.o \
		  cyber2000fb.o sa1100fb.o fbcon-hga.o fbgen.o

# Each configuration option enables a list of files.

obj-$(CONFIG_DUMMY_CONSOLE)       += dummycon.o

obj-$(CONFIG_FBCON_MFB)           += fbcon-mfb.o
obj-$(CONFIG_FBCON_VGA)           += fbcon-vga.o
obj-$(CONFIG_FBCON_HGA)           += fbcon-hga.o
obj-$(CONFIG_FBCON_STI)           += fbcon-sti.o

obj-$(CONFIG_FBCON_SPLASHSCREEN)  += fbcon-splash.o
obj-$(CONFIG_FBCON_SPLASHSCREEN)  += fbcon-splash16.o
obj-$(CONFIG_FBCON_SPLASHSCREEN)  += fbcon-jpegdec.o


include $(TOPDIR)/Rules.make

clean:
	rm -f core *.o *.a *.s





/* 
 *    linux/drivers/video/fbcon-jpegdec.c - a tiny jpeg decoder.
 *      
 *      (w) August 2001 by Michael Schroeder, <mls@suse.de>
 *                  
 */

#include <linux/config.h>
#include <linux/string.h>
#include <asm/byteorder.h>

struct display;
#include "fbcon-splash.h"
#include "fbcon-jpegdec.h"

#define ISHIFT 11

#define IFIX(a) ((int)((a) * (1 << ISHIFT) + .5))
#define IMULT(a, b) (((a) * (b)) >> ISHIFT)
#define ITOINT(a) ((a) >> ISHIFT)

#ifndef __P
# define __P(x) x
#endif

/* special markers */
#define M_BADHUFF	-1
#define M_EOF		0x80

struct in {
	unsigned char *p;
	unsigned int bits;
	int left;
	int marker;

	int (*func) __P((void *));
	void *data;
};

/*********************************/
struct dec_hufftbl;
struct enc_hufftbl;

union hufftblp {
	struct dec_hufftbl *dhuff;
	struct enc_hufftbl *ehuff;
};

struct scan {
	int dc;			/* old dc value */

	union hufftblp hudc;
	union hufftblp huac;
	int next;		/* when to switch to next scan */

	int cid;		/* component id */
	int hv;			/* horiz/vert, copied from comp */
	int tq;			/* quant tbl, copied from comp */
};

/*********************************/

#define DECBITS 10		/* seems to be the optimum */

struct dec_hufftbl {
	int maxcode[17];
	int valptr[16];
	unsigned char vals[256];
	unsigned int llvals[1 << DECBITS];
};

static void decode_mcus __P((struct in *, int *, int, struct scan *, int *));
static int dec_readmarker __P((struct in *));
static void dec_makehuff __P((struct dec_hufftbl *, int *, unsigned char *));

static void setinput __P((struct in *, unsigned char *));
/*********************************/

#undef PREC
#define PREC int

static void idctqtab __P((unsigned char *, PREC *));
static void idct __P((int *, int *, PREC *, PREC, int));
static void scaleidctqtab __P((PREC *, PREC));

/*********************************/

static void initcol __P((PREC[][64]));

static void col221111 __P((int *, unsigned char *, int));
static void col221111_16 __P((int *, unsigned char *, int));

/*********************************/

#define M_SOI	0xd8
#define M_APP0	0xe0
#define M_DQT	0xdb
#define M_SOF0	0xc0
#define M_DHT   0xc4
#define M_DRI	0xdd
#define M_SOS	0xda
#define M_RST0	0xd0
#define M_EOI	0xd9
#define M_COM	0xfe

static unsigned char *datap;

static int getbyte(void)
{
	return *datap++;
}

static int getword(void)
{
	int c1, c2;
	c1 = *datap++;
	c2 = *datap++;
	return c1 << 8 | c2;
}

struct comp {
	int cid;
	int hv;
	int tq;
};

#define MAXCOMP 4
struct jpginfo {
	int nc;			/* number of components */
	int ns;			/* number of scans */
	int dri;		/* restart interval */
	int nm;			/* mcus til next marker */
	int rm;			/* next restart marker */
};

static struct jpginfo info;
static struct comp comps[MAXCOMP];

static struct scan dscans[MAXCOMP];

static unsigned char quant[4][64];

static struct dec_hufftbl dhuff[4];

#define dec_huffdc (dhuff + 0)
#define dec_huffac (dhuff + 2)

static struct in in;

static int readtables(int till)
{
	int m, l, i, j, lq, pq, tq;
	int tc, th, tt;

	for (;;) {
		if (getbyte() != 0xff)
			return -1;
		if ((m = getbyte()) == till)
			break;

		switch (m) {
		case 0xc2:
			return 0;

		case M_DQT:
			lq = getword();
			while (lq > 2) {
				pq = getbyte();
				tq = pq & 15;
				if (tq > 3)
					return -1;
				pq >>= 4;
				if (pq != 0)
					return -1;
				for (i = 0; i < 64; i++)
					quant[tq][i] = getbyte();
				lq -= 64 + 1;
			}
			break;

		case M_DHT:
			l = getword();
			while (l > 2) {
				int hufflen[16], k;
				unsigned char huffvals[256];

				tc = getbyte();
				th = tc & 15;
				tc >>= 4;
				tt = tc * 2 + th;
				if (tc > 1 || th > 1)
					return -1;
				for (i = 0; i < 16; i++)
					hufflen[i] = getbyte();
				l -= 1 + 16;
				k = 0;
				for (i = 0; i < 16; i++) {
					for (j = 0; j < hufflen[i]; j++)
						huffvals[k++] = getbyte();
					l -= hufflen[i];
				}
				dec_makehuff(dhuff + tt, hufflen,
					     huffvals);
			}
			break;

		case M_DRI:
			l = getword();
			info.dri = getword();
			break;

		default:
			l = getword();
			while (l-- > 2)
				getbyte();
			break;
		}
	}
	return 0;
}

static void dec_initscans(void)
{
	int i;

	info.nm = info.dri + 1;
	info.rm = M_RST0;
	for (i = 0; i < info.ns; i++)
		dscans[i].dc = 0;
}

static int dec_checkmarker(void)
{
	int i;

	if (dec_readmarker(&in) != info.rm)
		return -1;
	info.nm = info.dri;
	info.rm = (info.rm + 1) & ~0x08;
	for (i = 0; i < info.ns; i++)
		dscans[i].dc = 0;
	return 0;
}

int jpeg_check_size(unsigned char *buf, int width, int height)
{
  	datap = buf;
	getbyte(); 
	getbyte(); 
	readtables(M_SOF0);
	getword();
	getbyte();
        if (height != getword() || width != getword())
		return 0;
        return 1;
}

int jpeg_decode(buf, pic, width, height, depth, decdata)
unsigned char *buf, *pic;
int width, height, depth;
struct jpeg_decdata *decdata;
{
	int i, j, m, tac, tdc;
	int mcusx, mcusy, mx, my;
	int max[6];

	if (!decdata)
		return -1;
	datap = buf;
	if (getbyte() != 0xff)
		return ERR_NO_SOI;
	if (getbyte() != M_SOI)
		return ERR_NO_SOI;
	if (readtables(M_SOF0))
		return ERR_BAD_TABLES;
	getword();
	i = getbyte();
	if (i != 8)
		return ERR_NOT_8BIT;
	if (((getword() + 15) & ~15) != height)
		return ERR_HEIGHT_MISMATCH;
	if (((getword() + 15) & ~15) != width)
		return ERR_WIDTH_MISMATCH;
	if ((height & 15) || (width & 15))
		return ERR_BAD_WIDTH_OR_HEIGHT;
	info.nc = getbyte();
	if (info.nc > MAXCOMP)
		return ERR_TOO_MANY_COMPPS;
	for (i = 0; i < info.nc; i++) {
		int h, v;
		comps[i].cid = getbyte();
		comps[i].hv = getbyte();
		v = comps[i].hv & 15;
		h = comps[i].hv >> 4;
		comps[i].tq = getbyte();
		if (h > 3 || v > 3)
			return ERR_ILLEGAL_HV;
		if (comps[i].tq > 3)
			return ERR_QUANT_TABLE_SELECTOR;
	}
	if (readtables(M_SOS))
		return ERR_BAD_TABLES;
	getword();
	info.ns = getbyte();
	if (info.ns != 3)
		return ERR_NOT_YCBCR_221111;
	for (i = 0; i < 3; i++) {
		dscans[i].cid = getbyte();
		tdc = getbyte();
		tac = tdc & 15;
		tdc >>= 4;
		if (tdc > 1 || tac > 1)
			return ERR_QUANT_TABLE_SELECTOR;
		for (j = 0; j < info.nc; j++)
			if (comps[j].cid == dscans[i].cid)
				break;
		if (j == info.nc)
			return ERR_UNKNOWN_CID_IN_SCAN;
		dscans[i].hv = comps[j].hv;
		dscans[i].tq = comps[j].tq;
		dscans[i].hudc.dhuff = dec_huffdc + tdc;
		dscans[i].huac.dhuff = dec_huffac + tac;
	}
	
	i = getbyte();
	j = getbyte();
	m = getbyte();
	
	if (i != 0 || j != 63 || m != 0)
		return ERR_NOT_SEQUENTIAL_DCT;
	
	if (dscans[0].cid != 1 || dscans[1].cid != 2 || dscans[2].cid != 3)
		return ERR_NOT_YCBCR_221111;

	if (dscans[0].hv != 0x22 || dscans[1].hv != 0x11 || dscans[2].hv != 0x11)
		return ERR_NOT_YCBCR_221111;

	mcusx = width >> 4;
	mcusy = height >> 4;


	idctqtab(quant[dscans[0].tq], decdata->dquant[0]);
	idctqtab(quant[dscans[1].tq], decdata->dquant[1]);
	idctqtab(quant[dscans[2].tq], decdata->dquant[2]);
	initcol(decdata->dquant);
	setinput(&in, datap);

#if 0
	/* landing zone */
	img[len] = 0;
	img[len + 1] = 0xff;
	img[len + 2] = M_EOF;
#endif

	dec_initscans();

	dscans[0].next = 6 - 4;
	dscans[1].next = 6 - 4 - 1;
	dscans[2].next = 6 - 4 - 1 - 1;	/* 411 encoding */
	for (my = 0; my < mcusy; my++) {
		for (mx = 0; mx < mcusx; mx++) {
			if (info.dri && !--info.nm)
				if (dec_checkmarker())
					return ERR_WRONG_MARKER;
			
			decode_mcus(&in, decdata->dcts, 6, dscans, max);
			idct(decdata->dcts, decdata->out, decdata->dquant[0], IFIX(128.5), max[0]);
			idct(decdata->dcts + 64, decdata->out + 64, decdata->dquant[0], IFIX(128.5), max[1]);
			idct(decdata->dcts + 128, decdata->out + 128, decdata->dquant[0], IFIX(128.5), max[2]);
			idct(decdata->dcts + 192, decdata->out + 192, decdata->dquant[0], IFIX(128.5), max[3]);
			idct(decdata->dcts + 256, decdata->out + 256, decdata->dquant[1], IFIX(0.5), max[4]);
			idct(decdata->dcts + 320, decdata->out + 320, decdata->dquant[2], IFIX(0.5), max[5]);

			switch (depth) {
			case 24:
				col221111(decdata->out, pic + (my * 16 * mcusx + mx) * 16 * 3, mcusx * 16 * 3);
				break;
			case 16:
				col221111_16(decdata->out, pic + (my * 16 * mcusx + mx) * (16 * 2), mcusx * (16 * 2));
				break;
			default:
				return ERR_DEPTH_MISMATCH;
				break;
			}
		}
	}
	
	m = dec_readmarker(&in);
	if (m != M_EOI)
		return ERR_NO_EOI;

	return 0;
}

/****************************************************************/
/**************       huffman decoder             ***************/
/****************************************************************/

static int fillbits __P((struct in *, int, unsigned int));
static int dec_rec2
__P((struct in *, struct dec_hufftbl *, int *, int, int));

static void setinput(in, p)
struct in *in;
unsigned char *p;
{
	in->p = p;
	in->left = 0;
	in->bits = 0;
	in->marker = 0;
}

static int fillbits(in, le, bi)
struct in *in;
int le;
unsigned int bi;
{
	int b, m;

	if (in->marker) {
		if (le <= 16)
			in->bits = bi << 16, le += 16;
		return le;
	}
	while (le <= 24) {
		b = *in->p++;
		if (b == 0xff && (m = *in->p++) != 0) {
			if (m == M_EOF) {
				if (in->func && (m = in->func(in->data)) == 0)
					continue;
			}
			in->marker = m;
			if (le <= 16)
				bi = bi << 16, le += 16;
			break;
		}
		bi = bi << 8 | b;
		le += 8;
	}
	in->bits = bi;		/* tmp... 2 return values needed */
	return le;
}

static int dec_readmarker(in)
struct in *in;
{
	int m;

	in->left = fillbits(in, in->left, in->bits);
	if ((m = in->marker) == 0)
		return 0;
	in->left = 0;
	in->marker = 0;
	return m;
}

#define LEBI_DCL	int le, bi
#define LEBI_GET(in)	(le = in->left, bi = in->bits)
#define LEBI_PUT(in)	(in->left = le, in->bits = bi)

#define GETBITS(in, n) (					\
  (le < (n) ? le = fillbits(in, le, bi), bi = in->bits : 0),	\
  (le -= (n)),							\
  bi >> le & ((1 << (n)) - 1)					\
)

#define UNGETBITS(in, n) (	\
  le += (n)			\
)


static int dec_rec2(in, hu, runp, c, i)
struct in *in;
struct dec_hufftbl *hu;
int *runp;
int c, i;
{
	LEBI_DCL;

	LEBI_GET(in);
	if (i) {
		UNGETBITS(in, i & 127);
		*runp = i >> 8 & 15;
		i >>= 16;
	} else {
		for (i = DECBITS; (c = ((c << 1) | GETBITS(in, 1))) >= (hu->maxcode[i]); i++);
		if (i >= 16) {
			in->marker = M_BADHUFF;
			return 0;
		}
		i = hu->vals[hu->valptr[i] + c - hu->maxcode[i - 1] * 2];
		*runp = i >> 4;
		i &= 15;
	}
	if (i == 0) {		/* sigh, 0xf0 is 11 bit */
		LEBI_PUT(in);
		return 0;
	}
	/* receive part */
	c = GETBITS(in, i);
	if (c < (1 << (i - 1)))
		c += (-1 << i) + 1;
	LEBI_PUT(in);
	return c;
}

#define DEC_REC(in, hu, r, i)	 (	\
  r = GETBITS(in, DECBITS),		\
  i = hu->llvals[r],			\
  i & 128 ?				\
    (					\
      UNGETBITS(in, i & 127),		\
      r = i >> 8 & 15,			\
      i >> 16				\
    )					\
  :					\
    (					\
      LEBI_PUT(in),			\
      i = dec_rec2(in, hu, &r, r, i),	\
      LEBI_GET(in),			\
      i					\
    )					\
)

static void decode_mcus(in, dct, n, sc, maxp)
struct in *in;
int *dct;
int n;
struct scan *sc;
int *maxp;
{
	struct dec_hufftbl *hu;
	int i, r, t;
	LEBI_DCL;

	memset(dct, 0, n * 64 * sizeof(*dct));
	LEBI_GET(in);
	while (n-- > 0) {
		hu = sc->hudc.dhuff;
		*dct++ = (sc->dc += DEC_REC(in, hu, r, t));

		hu = sc->huac.dhuff;
		i = 63;
		while (i > 0) {
			t = DEC_REC(in, hu, r, t);
			if (t == 0 && r == 0) {
				dct += i;
				break;
			}
			dct += r;
			*dct++ = t;
			i -= r + 1;
		}
		*maxp++ = 64 - i;
		if (n == sc->next)
			sc++;
	}
	LEBI_PUT(in);
}

static void dec_makehuff(hu, hufflen, huffvals)
struct dec_hufftbl *hu;
int *hufflen;
unsigned char *huffvals;
{
	int code, k, i, j, d, x, c, v;
	for (i = 0; i < (1 << DECBITS); i++)
		hu->llvals[i] = 0;

/*
 * llvals layout:
 *
 * value v already known, run r, backup u bits:
 *  vvvvvvvvvvvvvvvv 0000 rrrr 1 uuuuuuu
 * value unknown, size b bits, run r, backup u bits:
 *  000000000000bbbb 0000 rrrr 0 uuuuuuu
 * value and size unknown:
 *  0000000000000000 0000 0000 0 0000000
 */
	code = 0;
	k = 0;
	for (i = 0; i < 16; i++, code <<= 1) {	/* sizes */
		hu->valptr[i] = k;
		for (j = 0; j < hufflen[i]; j++) {
			hu->vals[k] = *huffvals++;
			if (i < DECBITS) {
				c = code << (DECBITS - 1 - i);
				v = hu->vals[k] & 0x0f;	/* size */
				for (d = 1 << (DECBITS - 1 - i); --d >= 0;) {
					if (v + i < DECBITS) {	/* both fit in table */
						x = d >> (DECBITS - 1 - v -
							  i);
						if (v && x < (1 << (v - 1)))
							x += (-1 << v) + 1;
						x = x << 16 | (hu-> vals[k] & 0xf0) << 4 |
							(DECBITS - (i + 1 + v)) | 128;
					} else
						x = v << 16 | (hu-> vals[k] & 0xf0) << 4 |
						        (DECBITS - (i + 1));
					hu->llvals[c | d] = x;
				}
			}
			code++;
			k++;
		}
		hu->maxcode[i] = code;
	}
	hu->maxcode[16] = 0x20000;	/* always terminate decode */
}

/****************************************************************/
/**************             idct                  ***************/
/****************************************************************/

#define ONE ((PREC)IFIX(1.))
#define S2  ((PREC)IFIX(0.382683432))
#define C2  ((PREC)IFIX(0.923879532))
#define C4  ((PREC)IFIX(0.707106781))

#define S22 ((PREC)IFIX(2 * 0.382683432))
#define C22 ((PREC)IFIX(2 * 0.923879532))
#define IC4 ((PREC)IFIX(1 / 0.707106781))

#define C3IC1 ((PREC)IFIX(0.847759065))	/* c3/c1 */
#define C5IC1 ((PREC)IFIX(0.566454497))	/* c5/c1 */
#define C7IC1 ((PREC)IFIX(0.198912367))	/* c7/c1 */

#define XPP(a,b) (t = a + b, b = a - b, a = t)
#define XMP(a,b) (t = a - b, b = a + b, a = t)
#define XPM(a,b) (t = a + b, b = b - a, a = t)

#define ROT(a,b,s,c) (	t = IMULT(a + b, s),	\
			a = IMULT(a, c - s) + t,	\
			b = IMULT(b, c + s) - t)

#define IDCT		\
(			\
  XPP(t0, t1),		\
  XMP(t2, t3),		\
  t2 = IMULT(t2, IC4) - t3,	\
  XPP(t0, t3),		\
  XPP(t1, t2),		\
  XMP(t4, t7),		\
  XPP(t5, t6),		\
  XMP(t5, t7),		\
  t5 = IMULT(t5, IC4),	\
  ROT(t4, t6, S22, C22),\
  t6 -= t7,		\
  t5 -= t6,		\
  t4 -= t5,		\
  XPP(t0, t7),		\
  XPP(t1, t6),		\
  XPP(t2, t5),		\
  XPP(t3, t4)		\
)

static unsigned char zig2[64] = {
	0, 2, 3, 9, 10, 20, 21, 35,
	14, 16, 25, 31, 39, 46, 50, 57,
	5, 7, 12, 18, 23, 33, 37, 48,
	27, 29, 41, 44, 52, 55, 59, 62,
	15, 26, 30, 40, 45, 51, 56, 58,
	1, 4, 8, 11, 19, 22, 34, 36,
	28, 42, 43, 53, 54, 60, 61, 63,
	6, 13, 17, 24, 32, 38, 47, 49
};

void idct(in, out, quant, off, max)
int *in;
int *out;
PREC *quant;
PREC off;
int max;
{
	PREC t0, t1, t2, t3, t4, t5, t6, t7, t;
	PREC tmp[64], *tmpp;
	int i, j;
	unsigned char *zig2p;

	t0 = off;
	if (max == 1) {
		t0 += in[0] * quant[0];
		for (i = 0; i < 64; i++)
			out[i] = ITOINT(t0);
		return;
	}
	zig2p = zig2;
	tmpp = tmp;
	for (i = 0; i < 8; i++) {
		j = *zig2p++;
		t0 += in[j] * quant[j];
		j = *zig2p++;
		t5 = in[j] * quant[j];
		j = *zig2p++;
		t2 = in[j] * quant[j];
		j = *zig2p++;
		t7 = in[j] * quant[j];
		j = *zig2p++;
		t1 = in[j] * quant[j];
		j = *zig2p++;
		t4 = in[j] * quant[j];
		j = *zig2p++;
		t3 = in[j] * quant[j];
		j = *zig2p++;
		t6 = in[j] * quant[j];
		IDCT;
		tmpp[0 * 8] = t0;
		tmpp[1 * 8] = t1;
		tmpp[2 * 8] = t2;
		tmpp[3 * 8] = t3;
		tmpp[4 * 8] = t4;
		tmpp[5 * 8] = t5;
		tmpp[6 * 8] = t6;
		tmpp[7 * 8] = t7;
		tmpp++;
		t0 = 0;
	}
	for (i = 0; i < 8; i++) {
		t0 = tmp[8 * i + 0];
		t1 = tmp[8 * i + 1];
		t2 = tmp[8 * i + 2];
		t3 = tmp[8 * i + 3];
		t4 = tmp[8 * i + 4];
		t5 = tmp[8 * i + 5];
		t6 = tmp[8 * i + 6];
		t7 = tmp[8 * i + 7];
		IDCT;
		out[8 * i + 0] = ITOINT(t0);
		out[8 * i + 1] = ITOINT(t1);
		out[8 * i + 2] = ITOINT(t2);
		out[8 * i + 3] = ITOINT(t3);
		out[8 * i + 4] = ITOINT(t4);
		out[8 * i + 5] = ITOINT(t5);
		out[8 * i + 6] = ITOINT(t6);
		out[8 * i + 7] = ITOINT(t7);
	}
}

static unsigned char zig[64] = {
	0, 1, 5, 6, 14, 15, 27, 28,
	2, 4, 7, 13, 16, 26, 29, 42,
	3, 8, 12, 17, 25, 30, 41, 43,
	9, 11, 18, 24, 31, 40, 44, 53,
	10, 19, 23, 32, 39, 45, 52, 54,
	20, 22, 33, 38, 46, 51, 55, 60,
	21, 34, 37, 47, 50, 56, 59, 61,
	35, 36, 48, 49, 57, 58, 62, 63
};

static PREC aaidct[8] = {
	IFIX(0.3535533906), IFIX(0.4903926402),
	IFIX(0.4619397663), IFIX(0.4157348062),
	IFIX(0.3535533906), IFIX(0.2777851165),
	IFIX(0.1913417162), IFIX(0.0975451610)
};


static void idctqtab(qin, qout)
unsigned char *qin;
PREC *qout;
{
	int i, j;

	for (i = 0; i < 8; i++)
		for (j = 0; j < 8; j++)
			qout[zig[i * 8 + j]] = qin[zig[i * 8 + j]] * 
			  			IMULT(aaidct[i], aaidct[j]);
}

static void scaleidctqtab(q, sc)
PREC *q;
PREC sc;
{
	int i;

	for (i = 0; i < 64; i++)
		q[i] = IMULT(q[i], sc);
}

/****************************************************************/
/**************          color decoder            ***************/
/****************************************************************/

#define ROUND

/*
 * YCbCr Color transformation:
 *
 * y:0..255   Cb:-128..127   Cr:-128..127
 *
 *      R = Y                + 1.40200 * Cr
 *      G = Y - 0.34414 * Cb - 0.71414 * Cr
 *      B = Y + 1.77200 * Cb
 *
 * =>
 *      Cr *= 1.40200;
 *      Cb *= 1.77200;
 *      Cg = 0.19421 * Cb + .50937 * Cr;
 *      R = Y + Cr;
 *      G = Y - Cg;
 *      B = Y + Cb;
 *
 * =>
 *      Cg = (50 * Cb + 130 * Cr + 128) >> 8;
 */

static void initcol(q)
PREC q[][64];
{
	scaleidctqtab(q[1], IFIX(1.77200));
	scaleidctqtab(q[2], IFIX(1.40200));
}

/* This is optimized for the stupid sun SUNWspro compiler. */
#define STORECLAMP(a,x)				\
(						\
  (a) = (x),					\
  (unsigned int)(x) >= 256 ? 			\
    ((a) = (x) < 0 ? 0 : 255)			\
  :						\
    0						\
)

#define CLAMP(x) ((unsigned int)(x) >= 256 ? ((x) < 0 ? 0 : 255) : (x))

#ifdef ROUND

#define CBCRCG(yin, xin)			\
(						\
  cb = outc[0 +yin*8+xin],			\
  cr = outc[64+yin*8+xin],			\
  cg = (50 * cb + 130 * cr + 128) >> 8		\
)

#else

#define CBCRCG(yin, xin)			\
(						\
  cb = outc[0 +yin*8+xin],			\
  cr = outc[64+yin*8+xin],			\
  cg = (3 * cb + 8 * cr) >> 4			\
)

#endif

#define PIC(yin, xin, p, xout)			\
(						\
  y = outy[(yin) * 8 + xin],			\
  STORECLAMP(p[(xout) * 3 + 0], y + cr),	\
  STORECLAMP(p[(xout) * 3 + 1], y - cg),	\
  STORECLAMP(p[(xout) * 3 + 2], y + cb)		\
)

#ifdef __LITTLE_ENDIAN
#define PIC_16(yin, xin, p, xout, add)		 \
(                                                \
  y = outy[(yin) * 8 + xin],                     \
  y = ((CLAMP(y + cr + add*2+1) & 0xf8) <<  8) | \
      ((CLAMP(y - cg + add    ) & 0xfc) <<  3) | \
      ((CLAMP(y + cb + add*2+1)       ) >>  3),  \
  p[(xout) * 2 + 0] = y & 0xff,                  \
  p[(xout) * 2 + 1] = y >> 8                     \
)
#else
#ifdef CONFIG_PPC
#define PIC_16(yin, xin, p, xout, add)		 \
(                                                \
  y = outy[(yin) * 8 + xin],                     \
  y = ((CLAMP(y + cr + add*2+1) & 0xf8) <<  7) | \
      ((CLAMP(y - cg + add*2+1) & 0xf8) <<  2) | \
      ((CLAMP(y + cb + add*2+1)       ) >>  3),  \
  p[(xout) * 2 + 0] = y >> 8,                    \
  p[(xout) * 2 + 1] = y & 0xff                   \
)
#else
#define PIC_16(yin, xin, p, xout, add)	 	 \
(                                                \
  y = outy[(yin) * 8 + xin],                     \
  y = ((CLAMP(y + cr + add*2+1) & 0xf8) <<  8) | \
      ((CLAMP(y - cg + add    ) & 0xfc) <<  3) | \
      ((CLAMP(y + cb + add*2+1)       ) >>  3),  \
  p[(xout) * 2 + 0] = y >> 8,                    \
  p[(xout) * 2 + 1] = y & 0xff                   \
)
#endif
#endif

#define PIC221111(xin)						\
(								\
  CBCRCG(0, xin),						\
  PIC(xin / 4 * 8 + 0, (xin & 3) * 2 + 0, pic0, xin * 2 + 0),	\
  PIC(xin / 4 * 8 + 0, (xin & 3) * 2 + 1, pic0, xin * 2 + 1),	\
  PIC(xin / 4 * 8 + 1, (xin & 3) * 2 + 0, pic1, xin * 2 + 0),	\
  PIC(xin / 4 * 8 + 1, (xin & 3) * 2 + 1, pic1, xin * 2 + 1)	\
)

#define PIC221111_16(xin)                                               \
(                                                               	\
  CBCRCG(0, xin),                                               	\
  PIC_16(xin / 4 * 8 + 0, (xin & 3) * 2 + 0, pic0, xin * 2 + 0, 3),     \
  PIC_16(xin / 4 * 8 + 0, (xin & 3) * 2 + 1, pic0, xin * 2 + 1, 0),     \
  PIC_16(xin / 4 * 8 + 1, (xin & 3) * 2 + 0, pic1, xin * 2 + 0, 1),     \
  PIC_16(xin / 4 * 8 + 1, (xin & 3) * 2 + 1, pic1, xin * 2 + 1, 2)      \
)

static void col221111(out, pic, width)
int *out;
unsigned char *pic;
int width;
{
	int i, j, k;
	unsigned char *pic0, *pic1;
	int *outy, *outc;
	int cr, cg, cb, y;

	pic0 = pic;
	pic1 = pic + width;
	outy = out;
	outc = out + 64 * 4;
	for (i = 2; i > 0; i--) {
		for (j = 4; j > 0; j--) {
			for (k = 0; k < 8; k++) {
				PIC221111(k);
			}
			outc += 8;
			outy += 16;
			pic0 += 2 * width;
			pic1 += 2 * width;
		}
		outy += 64 * 2 - 16 * 4;
	}
}

static void col221111_16(out, pic, width)
int *out;
unsigned char *pic;
int width;
{
	int i, j, k;
	unsigned char *pic0, *pic1;
	int *outy, *outc;
	int cr, cg, cb, y;

	pic0 = pic;
	pic1 = pic + width;
	outy = out;
	outc = out + 64 * 4;
	for (i = 2; i > 0; i--) {
		for (j = 4; j > 0; j--) {
			for (k = 0; k < 8; k++) {
			    PIC221111_16(k);
			}
			outc += 8;
			outy += 16;
			pic0 += 2 * width;
			pic1 += 2 * width;
		}
		outy += 64 * 2 - 16 * 4;
	}
}




#define ERR_NO_SOI 1
#define ERR_NOT_8BIT 2
#define ERR_HEIGHT_MISMATCH 3
#define ERR_WIDTH_MISMATCH 4
#define ERR_BAD_WIDTH_OR_HEIGHT 5
#define ERR_TOO_MANY_COMPPS 6
#define ERR_ILLEGAL_HV 7
#define ERR_QUANT_TABLE_SELECTOR 8
#define ERR_NOT_YCBCR_221111 9
#define ERR_UNKNOWN_CID_IN_SCAN 10
#define ERR_NOT_SEQUENTIAL_DCT 11
#define ERR_WRONG_MARKER 12
#define ERR_NO_EOI 13
#define ERR_BAD_TABLES 14
#define ERR_DEPTH_MISMATCH 15

struct jpeg_decdata {
	int dcts[6 * 64 + 16];
	int out[64 * 6];
	int dquant[3][64];
};

extern int jpeg_decode(unsigned char *, unsigned char *, int, int, int, struct jpeg_decdata *);
extern int jpeg_check_size(unsigned char *, int, int);




/* 
 *    linux/drivers/video/fbcon-splash.c - splash screen handling functions.
 *	
 *	(w) 2001-2003 by Volker Poplawski, <volker@suse.de>
 * 		    Stefan Reinauer, <stepan@suse.de>
 * 		    Steffen Winterfeldt, <snwint@suse.de>
 * 		    
 * 	       Ideas & SuSE screen work by Ken Wimer, <wimer@suse.de>
 */

#include <linux/version.h>
#include <linux/config.h>
#include <linux/module.h>
#include <linux/fb.h>
#include <linux/vt_kern.h>
#include <linux/vmalloc.h>

#include <asm/irq.h>
#include <asm/system.h>

#include <video/fbcon.h>
#include <video/font.h>
#include <video/fbcon-cfb16.h>  /* for fbcon_cfb16 */

#include "fbcon-splash.h"
#include "fbcon-jpegdec.h"

#define SPLASH_VERSION "3.0.7-2003/03/10"

#ifdef CONFIG_BLK_DEV_INITRD
unsigned char signature[] = "BOOTSPL1SPL2SPL3";
#endif

/* from drivers/char/console.c */
extern void con_remap_def_color(int currcons, int new_color);

/* from drivers/video/fbcon-splash16.c */
extern void splashfill(u8 *dest, u8 *src, int width, int height, 
			int dest_linesize, int src_linesize);

/* internal control states and data pointers */
struct splash_data splash_data;

unsigned char *linux_splash;	/* decoded picture */
int linux_splash_size = 0;

static struct jpeg_decdata *decdata = 0; /* private decoder data */

int splash_bytes;		/* bytes per line in linux_splash */
int splash_shown = 0;		/* is the splash onscreen? */
int splash_usesilent = 0;	/* shall we display the silentjpeg */
int splash_default = 0xf01;

static int splash_status(struct display *p);
static int splash_recolor(struct display *p);
static int splash_check_jpeg(unsigned char *jpeg, int width, int height, int depth);

extern struct display_switch fbcon_splash16;

int __init splash_init(char *options)
{
	if(!strncmp("silent",options,6)) {
		printk(KERN_INFO "bootsplash: silent mode.\n");
		splash_usesilent = 1;
		/* skip "silent," */
		if (strlen(options)==6)
			return 0;
		options+=7;
	}
	if(!strncmp("verbose",options,7)) {
		printk(KERN_INFO "bootsplash: verbose mode.\n");
		splash_usesilent = 0;
		return 0;
	}
		
	splash_default = simple_strtoul(options, NULL, 0);

	return 0;
}

__setup("splash=", splash_init);


static int splash_hasinter(unsigned char *buf, int num)
{
    unsigned char *bufend = buf + num * 12;
    while(buf < bufend) {
	if (buf[1] > 127)		/* inter? */
	    return 1;
	buf += buf[3] > 127 ? 24 : 12;	/* blend? */
    }
    return 0;
}

static int boxextract(unsigned char *buf, unsigned short *dp, unsigned char *cols, int *blendp)
{
    dp[0] = buf[0] | buf[1] << 8;
    dp[1] = buf[2] | buf[3] << 8;
    dp[2] = buf[4] | buf[5] << 8;
    dp[3] = buf[6] | buf[7] << 8;
    *(unsigned int *)(cols + 0) =
	*(unsigned int *)(cols + 4) =
	*(unsigned int *)(cols + 8) =
	*(unsigned int *)(cols + 12) = *(unsigned int *)(buf + 8);
    if (dp[1] > 32767) {
	dp[1] = ~dp[1];
	*(unsigned int *)(cols + 4) = *(unsigned int *)(buf + 12);
	*(unsigned int *)(cols + 8) = *(unsigned int *)(buf + 16);
	*(unsigned int *)(cols + 12) = *(unsigned int *)(buf + 20);
	*blendp = 1;
	return 24;
    }
    return 12;
}

static void boxit(unsigned char *pic, int bytes, unsigned char *buf, int num, int percent, int overpaint)
{
    int x, y, i, p, doblend, r, g, b, a, add;
    unsigned short data1[4];
    unsigned char cols1[16];
    unsigned short data2[4];
    unsigned char cols2[16];
    unsigned char *bufend;
    unsigned short *picp;

    if (num == 0)
	return;
    bufend = buf + num * 12;
    while(buf < bufend) {
	doblend = 0;
	buf += boxextract(buf, data1, cols1, &doblend);
	if (data1[0] > 32767)
	    buf += boxextract(buf, data2, cols2, &doblend);
	if (data1[2] > 32767) {
	    if (overpaint)
		continue;
	    data1[2] = ~data1[2];
	}
	if (data1[3] > 32767) {
	    if (percent == 65536)
		continue;
	    data1[3] = ~data1[3];
	}
	if (data1[0] > 32767) {
	    data1[0] = ~data1[0];
	    for (i = 0; i < 4; i++)
		data1[i] = (data1[i] * (65536 - percent) + data2[i] * percent) >> 16;
	    for (i = 0; i < 16; i++)
		cols1[i] = (cols1[i] * (65536 - percent) + cols2[i] * percent) >> 16;
	}
	*(unsigned int *)cols2 = *(unsigned int *)cols1;
	a = cols2[3];
	if (a == 0 && !doblend)
	    continue;
	for (y = data1[1]; y <= data1[3]; y++) {
	    if (doblend) {
		if ((p = data1[3] - data1[1]) != 0)
		    p = ((y - data1[1]) << 16) / p;
		for (i = 0; i < 8; i++)
		    cols2[i + 8] = (cols1[i] * (65536 - p) + cols1[i + 8] * p) >> 16;
	    }
	    add = (data1[0] & 1);
	    add ^= (add ^ y) & 1 ? 1 : 3;		/* 2x2 ordered dithering */
	    picp = (unsigned short *)(pic + data1[0] * 2 + y * bytes);
	    for (x = data1[0]; x <= data1[2]; x++) {
		if (doblend) {
		    if ((p = data1[2] - data1[0]) != 0)
			p = ((x - data1[0]) << 16) / p;
		    for (i = 0; i < 4; i++)
			cols2[i] = (cols2[i + 8] * (65536 - p) + cols2[i + 12] * p) >> 16;
		    a = cols2[3];
		}
		r = cols2[0];
		g = cols2[1];
		b = cols2[2];
		if (a != 255) {
		    i = *picp;
		    r = ((i >> 8 & 0xf8) * (255 - a) + r * a) / 255;
		    g = ((i >> 3 & 0xfc) * (255 - a) + g * a) / 255;
		    b = ((i << 3 & 0xf8) * (255 - a) + b * a) / 255;
		}
  #define CLAMP(x) ((x) >= 256 ? 255 : (x))
		i = ((CLAMP(r + add*2+1) & 0xf8) <<  8) |
		    ((CLAMP(g + add    ) & 0xfc) <<  3) |
		    ((CLAMP(b + add*2+1)       ) >>  3);
		*picp++ = i;
		add ^= 3;
	    }
	}
    }
}

static int splash_check_jpeg(unsigned char *jpeg, int width, int height, int depth)
{
    int size, err;
    unsigned char *mem;

    size = ((width + 15) & ~15) * ((height + 15) & ~15) * (depth >> 3);
    mem = vmalloc(size);
    if (!mem) {
	printk(KERN_INFO "No memory for decoded picture!\n");
	return -1;
    }
    if (!decdata)
	decdata = vmalloc(sizeof(*decdata));
    if ((err = jpeg_decode(jpeg, mem, ((width + 15) & ~15), ((height + 15) & ~15), depth, decdata)))
	  printk(KERN_INFO "error %d while decompressing picture.\n",err);
    vfree(mem);
    return err ? -1 : 0;
}

static void splash_free(struct display * p)
{
    if (!p->splash_data)
	return;
    if (p->splash_data->oldscreen_base)
	    p->screen_base = p->splash_data->oldscreen_base;
    if (p->splash_data->olddispsw)
	    p->dispsw = p->splash_data->olddispsw;
    if (p->splash_data->splash_silentjpeg)
	    vfree(p->splash_data->splash_sboxes);
    vfree(p->splash_data);
    p->splash_data = 0;
}

static int splash_mkpenguin(struct splash_data *data, int pxo, int pyo, int pwi, int phe, int pr, int pg, int pb)
{
    unsigned char *buf;
    int i;

    if (pwi ==0 || phe == 0)
	return 0;
    buf = (unsigned char *)data + sizeof(*data);
    pwi += pxo - 1;
    phe += pyo - 1;
    *buf++ = pxo;
    *buf++ = pxo >> 8;
    *buf++ = pyo;
    *buf++ = pyo >> 8;
    *buf++ = pwi;
    *buf++ = pwi >> 8;
    *buf++ = phe;
    *buf++ = phe >> 8;
    *buf++ = pr;
    *buf++ = pg;
    *buf++ = pb;
    *buf++ = 0;
    for (i = 0; i < 12; i++, buf++)
	*buf = buf[-12];
    buf[-24] ^= 0xff;
    buf[-23] ^= 0xff;
    buf[-1] = 0xff;
    return 2;
}

int splash_getraw(unsigned char *start, unsigned char *end)
{
	unsigned char *ndata;
	int found = 0;
	int splash_size = 0;
	void *splash_start = 0;
        int unit = 0;
        int width = 0, height = 0;
	int silentsize;
	int boxcount = 0;
	int sboxcount = 0;
	int palcnt = 0;
	struct display *p;

	printk(KERN_INFO "Looking for splash picture...");

	p = &fb_display[0];
        silentsize = 0;

	for (ndata = start; ndata < end; ndata++) {
		if (*((unsigned int *)ndata) != *((unsigned int *)signature))
			continue;
		if (*((unsigned int *)(ndata+4))==*((unsigned int *)(signature+4))) {
			printk(".");
			unit = 0;
			p = &fb_display[0];
			width = p->var.xres;
			height = p->var.yres;

			splash_size = ndata[16] + (ndata[17] << 8) + (ndata[18] << 16) + (ndata[19] << 24);
			if (ndata + 20 + splash_size > end) {
				printk(" found, but truncated!\n");
				return -1;
			}
			if (!jpeg_check_size(ndata + 20, width, height)) { 
				ndata += 20 - 1 + splash_size;
				continue;
			}
			if (splash_check_jpeg(ndata + 20, width, height, p->var.bits_per_pixel))
				return -1;
			if (p->splash_data)
				splash_free(p);
			p->splash_data = vmalloc(sizeof(*p->splash_data) + splash_size + 24);
			if (!p->splash_data)
				break;

			p->splash_data->oldscreen_base = 0;
			p->splash_data->olddispsw = 0;
			p->splash_data->splash_silentjpeg = 0;

			p->splash_data->splash_text_xo = ndata[ 8] + (ndata[ 9] << 8);
			p->splash_data->splash_text_yo = ndata[10] + (ndata[11] << 8);
			p->splash_data->splash_text_wi = ndata[12] + (ndata[13] << 8);
			p->splash_data->splash_text_he = ndata[14] + (ndata[15] << 8);
			/* use 8x16 font... */
			p->splash_data->splash_text_xo *= 8;
			p->splash_data->splash_text_wi *= 8;
			p->splash_data->splash_text_yo *= 16;
			p->splash_data->splash_text_he *= 16;
			p->splash_data->splash_color = (splash_default >> 8) & 0x0f;
			p->splash_data->splash_fg_color = (splash_default >> 4) & 0x0f;
			p->splash_data->splash_state = splash_default & 1;
			p->splash_data->splash_percent = 0;
			p->splash_data->splash_overpaintok = 0;
			boxcount = splash_mkpenguin(p->splash_data, p->splash_data->splash_text_xo + 10, p->splash_data->splash_text_yo + 10, p->splash_data->splash_text_wi - 20, p->splash_data->splash_text_he - 20, 0xf0, 0xf0, 0xf0);
			splash_start = ndata + 20;
			found = 1;
			break;
		}
		if (*((unsigned int *)(ndata + 4)) == *((unsigned int *)(signature+8))) {
			printk(".");
			unit = ndata[8];
			if (unit >= MAX_NR_CONSOLES)
			    continue;
			if (unit)
			    vc_allocate(unit);
			p = &fb_display[unit];
			width = fb_display[unit].var.xres;
			height = fb_display[unit].var.yres;
			splash_size = ndata[12] + (ndata[13] << 8) + (ndata[14] << 16) + (ndata[15] << 24);
			if (splash_size == -1) {
			    printk(" found, updating values.\n");
			    if (p->splash_data) {
				if (ndata[9] != 255)
				    p->splash_data->splash_state = ndata[9];
				if (ndata[10] != 255)
				    p->splash_data->splash_fg_color = ndata[10];
				if (ndata[11] != 255)
				    p->splash_data->splash_color = ndata[11];
			    }
			    return unit;
			}
			if (splash_size == 0) {
				printk(" found, freeing memory.\n");
				if (p->splash_data)
					splash_free(p);
				return unit;
			}
			if (ndata + 35 + splash_size > end) {
				printk(" found, but truncated!\n");
				return -1;
			}
			if (!jpeg_check_size(ndata + 35, width, height)) {
				ndata += 35 - 1 + splash_size;
				continue;
			}
			if (splash_check_jpeg(ndata + 35, width, height, p->var.bits_per_pixel))
				return -1;
			if (p->splash_data)
				splash_free(p);
			p->splash_data = vmalloc(sizeof(*p->splash_data) + splash_size + 24);
			if (!p->splash_data)
				break;

			p->splash_data->oldscreen_base = 0;
			p->splash_data->olddispsw = 0;
			p->splash_data->splash_silentjpeg = 0;

			p->splash_data->splash_state = ndata[9];
			p->splash_data->splash_fg_color = ndata[10];
			p->splash_data->splash_color = ndata[11];
			p->splash_data->splash_text_xo = ndata[16] + (ndata[17] << 8);
			p->splash_data->splash_text_yo = ndata[18] + (ndata[19] << 8);
			p->splash_data->splash_text_wi = ndata[20] + (ndata[21] << 8);
			p->splash_data->splash_text_he = ndata[22] + (ndata[23] << 8);
			p->splash_data->splash_percent = 0;
			p->splash_data->splash_overpaintok = 0;
			boxcount = splash_mkpenguin(p->splash_data, ndata[24] + (ndata[25] << 8), ndata[26] + (ndata[27] << 8), ndata[28] + (ndata[29] << 8), ndata[30] + (ndata[31] << 8), ndata[32], ndata[33], ndata[34]);
			splash_start = ndata + 35;
			found = 2;
			break;
		}
		if (*((unsigned int *)(ndata + 4)) == *((unsigned int *)(signature+12))) {
			printk(".");
			unit = ndata[8];
			if (unit >= MAX_NR_CONSOLES)
			    continue;
			if (unit)
			    vc_allocate(unit);
			p = &fb_display[unit];
			width = p->var.xres;
			height = p->var.yres;
			splash_size = ndata[12] + (ndata[13] << 8) + (ndata[14] << 16) + (ndata[15] << 24);
			if (splash_size == -1) {
			    printk(" found, updating values.\n");
			    if (p->splash_data) {
				if (ndata[9] != 255)
				    p->splash_data->splash_state = ndata[9];
				if (ndata[10] != 255)
				    p->splash_data->splash_fg_color = ndata[10];
				if (ndata[11] != 255)
				    p->splash_data->splash_color = ndata[11];
			    }
			    return unit;
			}
			if (splash_size == 0) {
				printk(" found, freeing memory.\n");
				if (p->splash_data)
					splash_free(p);
				return unit;
			}
			boxcount = ndata[24] + (ndata[25] << 8);
			palcnt = ndata[37] * 3;
			if (ndata + 38 + splash_size > end) {
				printk(" found, but truncated!\n");
				return -1;
			}
			if (!jpeg_check_size(ndata + 38 + boxcount * 12 + palcnt, width, height)) {
				ndata += 38 - 1 + splash_size;
				continue;
			}
			if (splash_check_jpeg(ndata + 38 + boxcount * 12 + palcnt, width, height, p->var.bits_per_pixel))
				return -1;
			silentsize = ndata[28] + (ndata[29] << 8) + (ndata[30] << 16) + (ndata[31] << 24);
			if (silentsize)
			    printk(" silenjpeg size %d bytes,", silentsize);
			if (silentsize >= splash_size) {
				printk(" bigger than splashsize!\n");
				return -1;
			}
			splash_size -= silentsize;
			if (!splash_usesilent || !p->fb_info->fbops->fb_get_fix ) {
				silentsize = 0;
			} else {
				struct fb_fix_screeninfo fix;
				p->fb_info->fbops->fb_get_fix(&fix, unit, 0);
				if (height * 2 * p->next_line > fix.smem_len) {
					printk(" does not fit into framebuffer.\n");
					silentsize = 0;
				}
			}

			sboxcount = ndata[32] + (ndata[33] << 8);
			if (silentsize) {
				char *simage=ndata + 38 + splash_size + 12 * sboxcount;
				if (!jpeg_check_size(simage, width, height) ||
				    splash_check_jpeg(simage, width, height, p->var.bits_per_pixel)) {
					printk(" error in silent jpeg.\n");
					silentsize = 0;
				}
			}
			if (p->splash_data)
				splash_free(p);
			p->splash_data = vmalloc(sizeof(*p->splash_data) + splash_size);
			if (!p->splash_data)
				break;
			p->splash_data->oldscreen_base = 0;
			p->splash_data->olddispsw = 0;
			p->splash_data->splash_silentjpeg = 0;
			if (silentsize) {
				p->splash_data->splash_silentjpeg = vmalloc(silentsize);
				if (p->splash_data->splash_silentjpeg) {
					memcpy(p->splash_data->splash_silentjpeg, ndata + 38 + splash_size, silentsize);
					p->splash_data->splash_sboxes = p->splash_data->splash_silentjpeg;
					p->splash_data->splash_silentjpeg += 12 * sboxcount;
					p->splash_data->splash_sboxcount = sboxcount;
				}
			}
			p->splash_data->splash_state = ndata[9];
			p->splash_data->splash_fg_color = ndata[10];
			p->splash_data->splash_color = ndata[11];
			p->splash_data->splash_overpaintok = ndata[36];
			p->splash_data->splash_text_xo = ndata[16] + (ndata[17] << 8);
			p->splash_data->splash_text_yo = ndata[18] + (ndata[19] << 8);
			p->splash_data->splash_text_wi = ndata[20] + (ndata[21] << 8);
			p->splash_data->splash_text_he = ndata[22] + (ndata[23] << 8);
			p->splash_data->splash_percent = ndata[34] + (ndata[35] << 8);
			p->splash_data->splash_percent += p->splash_data->splash_percent > 32767;
			splash_start = ndata + 38;
			found = 3;
			break;
		}
	}
	
	if (!found) {
		printk(" no good signature found.\n");
		return -1;
	}
	if (p->splash_data->splash_text_xo + p->splash_data->splash_text_wi > width || p->splash_data->splash_text_yo + p->splash_data->splash_text_he > height) {
		splash_free(p);
		p->splash_data = 0;
		printk(" found, but has oversized text area!\n");
		return -1;
	}
	if (p->dispsw->setup != fbcon_cfb16.setup) {
		splash_free(p);
		p->splash_data = 0;
		printk(" found, but framebuffer can't handle it!\n");
		return -1;
	}
	printk(" found (%dx%d, %d bytes, v%d).\n", width, height, splash_size, found);

	if (found==1) {
		printk(KERN_WARNING "bootsplash: Using deprecated v1 header. Updating your splash utility recommended.\n");
		printk(KERN_INFO    "bootsplash: Find the latest version at ftp.suse.com/pub/people/stepan/bootsplash/\n");
	}

	/* copy data so that initrd memory can be freed. */
	memcpy((char *)p->splash_data + sizeof(*p->splash_data) + (found < 3 ? boxcount * 12 : 0), splash_start, splash_size);
	p->splash_data->splash_boxcount = boxcount;
	p->splash_data->splash_boxes = (unsigned char *)p->splash_data + sizeof(*p->splash_data);
	p->splash_data->splash_jpeg = (unsigned char *)p->splash_data + sizeof(*p->splash_data) + boxcount * 12 + palcnt;
	p->splash_data->splash_palette = (unsigned char *)p->splash_data + sizeof(*p->splash_data) + boxcount * 12;
	p->splash_data->splash_palcnt = palcnt / 3;
	p->splash_data->splash_dosilent = p->splash_data->splash_silentjpeg != 0;
	return unit;
}

int splash_verbose(void) 
{
    struct display *p;

    p = &fb_display[0];
    if (!p || !p->splash_data || !p->splash_data->splash_state || !p->conp)
	return 0;
    if (fg_console != p->conp->vc_num)
	return 0;
    if (!p->splash_data->splash_silentjpeg || !p->splash_data->splash_dosilent)
	return 0;
    if (!p->splash_data->oldscreen_base)
	return 0;

    p->splash_data->splash_dosilent = 0;

    splashfill(p->splash_data->oldscreen_base, p->screen_base, p->var.xres, p->var.yres, p->next_line, p->next_line);
    p->screen_base = p->splash_data->oldscreen_base;

    return 1;
}

static void splash_off(struct display *p)
{
    if (p->splash_data && p->splash_data->oldscreen_base)
	p->screen_base = p->splash_data->oldscreen_base;
    if (p->splash_data && p->splash_data->olddispsw)
	p->dispsw = p->splash_data->olddispsw;
    splash_shown = 0;
}

int splash_prepare(struct display *p)
{
	int err;
        int width, height, depth, size, sbytes;

	if (!p->splash_data || !p->splash_data->splash_state) {
		if (linux_splash)
			vfree(linux_splash);
		if (decdata)
			vfree(decdata);
		linux_splash = 0;
		decdata = 0;
		linux_splash_size = 0;
		splash_off(p);
		return -1;
	}

        width = p->var.xres;
        height = p->var.yres;
        depth = p->var.bits_per_pixel;
	if (depth != 16) {	/* Other targets might need fixing */
		splash_off(p);
		return -2;
	}

	sbytes = ((width + 15) & ~15) * (depth >> 3);
	size = sbytes * ((height + 15) & ~15);
	if (size != linux_splash_size) {
		if (linux_splash)
			vfree(linux_splash);
		linux_splash_size = 0;
		linux_splash = 0;
		splash_off(p);
	}
	if (!linux_splash)
		linux_splash = vmalloc(size);

	if (!linux_splash) {
		linux_splash_size = 0;
		printk(KERN_INFO "Not enough memory for splash screen.\n");
		splash_off(p);
		return -3;
	}

	if (!decdata)
	    decdata = vmalloc(sizeof(*decdata));

	if (!p->splash_data->oldscreen_base)
		p->splash_data->oldscreen_base = p->screen_base;

	if (p->splash_data->splash_silentjpeg && p->splash_data->splash_dosilent) {
		printk(KERN_INFO "Got silent jpeg.\n");
		/* fill area after framebuffer with other jpeg */
		if ((err = jpeg_decode(p->splash_data->splash_silentjpeg, linux_splash, 
			 ((width + 15) & ~15), ((height + 15) & ~15), depth, decdata))) {
			printk(KERN_INFO "Error %d while decompressing silent jpeg.\n", err);
			p->screen_base = p->splash_data->oldscreen_base;
			p->splash_data->splash_dosilent = 0;
		} else {
			if (p->splash_data->splash_sboxcount)
				boxit(linux_splash, sbytes, p->splash_data->splash_sboxes, 
					p->splash_data->splash_sboxcount, p->splash_data->splash_percent, 0);

			splashfill(p->screen_base, linux_splash, p->var.xres, p->var.yres, p->next_line, sbytes);
			p->screen_base = p->splash_data->oldscreen_base + p->next_line * p->var.yres;
		}
	} else
		p->screen_base = p->splash_data->oldscreen_base;

	if ((err = jpeg_decode(p->splash_data->splash_jpeg, linux_splash, 
		 ((width + 15) & ~15), ((height + 15) & ~15), depth, decdata))) {
		printk(KERN_INFO "Error %d while decompressing splash screen.\n", err);
		vfree(linux_splash);
		linux_splash = 0;
		linux_splash_size = 0;
		splash_off(p);
		return -4;
	}
	linux_splash_size = size;
	splash_bytes = sbytes;
	if (p->splash_data->splash_boxcount)
		boxit(linux_splash, sbytes, p->splash_data->splash_boxes, p->splash_data->splash_boxcount, p->splash_data->splash_percent, 0);
	splash_data = *p->splash_data;
	splash_shown = p->splash_data->splash_state;
	if (splash_shown) {
	    if (p->dispsw != &fbcon_splash16)
		p->splash_data->olddispsw = p->dispsw;
	    p->dispsw = &fbcon_splash16;
	} else
		splash_off(p);
	return 0;
}


#ifdef CONFIG_PROC_FS
#include <linux/proc_fs.h>

struct proc_dir_entry *proc_splash;
int splash_read_proc(char *buffer, char **start, off_t offset, int size,
			int *eof, void *data);
int splash_write_proc(struct file *file, const char *buffer,
			unsigned long count, void *data);

int splash_read_proc(char *buffer, char **start, off_t offset, int size,
			int *eof, void *data)
{
	int len = 0;
	
	off_t begin = 0;
	struct display *p = &fb_display[0];

	int color = p->splash_data ? p->splash_data->splash_color << 4 |
			p->splash_data->splash_fg_color : splash_default >> 4;
	int status = p->splash_data ? p->splash_data->splash_state & 1 : 0;
	len += sprintf(buffer + len, "Splash screen v%s (0x%02x, %dx%d%s): %s\n",
		        SPLASH_VERSION, color, p->var.xres, p->var.yres,
			(p->splash_data ?  p->splash_data->splash_dosilent : 0)? ", silent" : "",
					status ? "on" : "off");
	if (offset >= begin + len)
		return 0;

	*start = buffer + (begin - offset);

	return (size < begin + len - offset ? size : begin + len - offset);
}

static int splash_recolor(struct display *p)
{
	if (!p->splash_data)
	    return -1;
	if (!p->splash_data->splash_state)
	    return 0;
	con_remap_def_color(p->conp->vc_num, p->splash_data->splash_color << 4 | p->splash_data->splash_fg_color);
	if (fg_console == p->conp->vc_num) {
	        splash_data = *p->splash_data;
		update_region(fg_console,
			      p->conp->vc_origin +
			      p->conp->vc_size_row *
			      p->conp->vc_top,
			      p->conp->vc_size_row *
			      (p->conp->vc_bottom -
			       p->conp->vc_top) / 2);
	}
	return 0;
}

static int splash_status(struct display *p)
{
	printk(KERN_INFO "Splash status on console %d changed to %s\n", p->conp->vc_num, p->splash_data && p->splash_data->splash_state ? "on" : "off");

	if (fg_console == p->conp->vc_num)
		splash_prepare(p);
	if (p->splash_data && p->splash_data->splash_state) {
		con_remap_def_color(p->conp->vc_num, p->splash_data->splash_color << 4 | p->splash_data->splash_fg_color);
		/* resize_con also calls con_switch which resets yscroll */
		vc_resize_con(p->splash_data->splash_text_he / fontheight(p),
                              p->splash_data->splash_text_wi / fontwidth(p),
                              p->conp->vc_num);
		if (fg_console == p->conp->vc_num) {
			update_region(fg_console,
				      p->conp->vc_origin +
				      p->conp->vc_size_row *
				      p->conp->vc_top,
				      p->conp->vc_size_row *
				      (p->conp->vc_bottom -
				       p->conp->vc_top) / 2);
			    fbcon_splash16.clear_margins(p->conp, p, 0);
		}
	} else {
	  	/* Switch bootsplash off */
		con_remap_def_color(p->conp->vc_num, 0x07);
		vc_resize_con(p->var.yres / fontheight(p),
			      p->var.xres / fontwidth(p),
			      p->conp->vc_num);
	}
	return 0;
}

int splash_write_proc(struct file *file, const char *buffer,
		      unsigned long count, void *data)
{
        int new, unit;
	struct display *p;
	
	if (!buffer || !splash_default)
		return count;

	if (!strncmp(buffer, "show", 4) || !strncmp(buffer, "hide", 4)) {
		int pe;

		p = &fb_display[0];
		if (buffer[4] == ' ' && buffer[5] == 'p')
			pe = 0;
		else if (buffer[4] == '\n')
			pe = 65535;
		else
			pe = simple_strtoul(buffer + 5, NULL, 0);
		if (pe < 0)
			pe = 0;
		if (pe > 65535)
			pe = 65535;
		if (*buffer == 'h')
			pe = 65535 - pe;
		pe += pe > 32767;
		if (p->splash_data && p->splash_data->splash_percent != pe) {
			p->splash_data->splash_percent = pe;
			if (fg_console != p->conp->vc_num || !p->splash_data->splash_state)
			    return count;
			if (!p->splash_data->splash_overpaintok || p->splash_data->splash_percent == 65536) {
				if (splash_hasinter(p->splash_data->splash_boxes, p->splash_data->splash_boxcount))
					splash_status(p);
				else
					splash_prepare(p);
			} else {
				if (p->splash_data->splash_silentjpeg && p->splash_data->splash_dosilent && p->splash_data->oldscreen_base)
					boxit(p->splash_data->oldscreen_base, p->next_line, p->splash_data->splash_sboxes, p->splash_data->splash_sboxcount, p->splash_data->splash_percent, 1);
				boxit(p->screen_base, p->next_line, p->splash_data->splash_boxes, p->splash_data->splash_boxcount, p->splash_data->splash_percent, 1);
			}
		}
		return count;
	}
	if (!strncmp(buffer,"silent\n",7) || !strncmp(buffer,"verbose\n",8)) {
		p = &fb_display[0];
		if (p->splash_data && p->splash_data->splash_silentjpeg) {
		    if (p->splash_data->splash_dosilent != (buffer[0] == 's')) {
			p->splash_data->splash_dosilent = buffer[0] == 's';
			splash_status(p);
		    }
		}
		return count;
	}
	if (!strncmp(buffer,"freesilent\n",11)) {
		p = &fb_display[0];
		if (p->splash_data && p->splash_data->splash_silentjpeg) {
		    printk(KERN_INFO "bootsplash: freeing silent jpeg\n");
		    p->splash_data->splash_silentjpeg = 0;
		    vfree(p->splash_data->splash_sboxes);
		    p->splash_data->splash_sboxes = 0;
		    p->splash_data->splash_sboxcount = 0;
		    if (p->splash_data->splash_dosilent)
			splash_status(p);
		    p->splash_data->splash_dosilent = 0;
		}
		return count;
	}

	if (!strncmp(buffer, signature, 7)) {
	    unit = splash_getraw((unsigned char *)buffer, (unsigned char *)buffer + count);
	    if (unit >= 0) {
		p = &fb_display[unit];
		splash_status(p);
	    }
	    return count;
	}
	p = &fb_display[0];
	if (!p->splash_data)
		return count;
	if (buffer[0] == 't') {
	        p->splash_data->splash_state ^= 1;
		splash_status(p);
		return count;
	}
	new = simple_strtoul(buffer, NULL, 0);
	if (new > 1) {
		/* expert user */
		p->splash_data->splash_color    = new >> 8 & 0xff;
		p->splash_data->splash_fg_color = new >> 4 & 0x0f;
	}
	if ((new & 1) == p->splash_data->splash_state)
		splash_recolor(p);
	else {
	        p->splash_data->splash_state = new & 1;
		splash_status(p);
	}
	return count;
}

int splash_proc_register(void)
{
	if ((proc_splash = create_proc_entry("splash", 0, 0))) {
		proc_splash->read_proc = splash_read_proc;
		proc_splash->write_proc = splash_write_proc;
		return 0;
	}
	return 1;
}

int splash_proc_unregister(void)
{
	if (proc_splash)
		remove_proc_entry("splash", 0);
	return 0;
}
#endif




/* 
	 *    linux/drivers/video/splash.h - splash screen definition.
	 * 
	 * (w) 2001-2003 by Volker Poplawski, <volker@suse.de>
	 *             Stefan Reinauer, <stepan@suse.de>
	 *             
	 *             
	 *     idea and SuSE screen work by Ken Wimer, <wimer@suse.de>
	 */

extern int splash_getraw(unsigned char *, unsigned char *);
extern int splash_prepare(struct display *);

extern int splash_shown;       /* is splash shown? */
extern struct splash_data splash_data; /* image data, copied over
										                         from display */
extern unsigned char *linux_splash;    /* decoded pic data */
extern int splash_bytes;       /* bytes per line */





/*
 *  linux/drivers/video/fbcon-splash16.c -- Low level frame buffer operations for 16 bpp
 *                                          framebuffer operation. Modified to present
 *					    boot splash screen. 2002/11/7 stepan@suse.de
 * 
 * Based on linux/drivers/video/fbcon-cfb16.c, which is
 *
 *	Created 5 Apr 1997 by Geert Uytterhoeven
 *
 *  This file is subject to the terms and conditions of the GNU General Public
 *  License.  See the file COPYING in the main directory of this archive for
 *  more details.
 */

#include <linux/module.h>
#include <linux/config.h>
#include <linux/tty.h>
#include <linux/console.h>
#include <linux/string.h>
#include <linux/fb.h>
#include <asm/io.h>

#include <video/fbcon.h>
#include <video/fbcon-cfb16.h>

#include "fbcon-splash.h"

    /*
     *  16 bpp packed pixels
     */

static u32 tab_cfb16[] = {
#if defined(__BIG_ENDIAN)
    0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff
#elif defined(__LITTLE_ENDIAN)
    0x00000000, 0xffff0000, 0x0000ffff, 0xffffffff
#else
#error FIXME: No endianness??
#endif
};

void fbcon_splash16_bmove(struct display *p, int sy, int sx, int dy, int dx,
		       int height, int width)
{
    int bytes = p->next_line, linesize = bytes * fontheight(p), rows;
    u8 *src, *dst;

    if (sx == 0 && dx == 0 && width * fontwidth(p) * 2 == bytes) {
	fb_memmove(p->screen_base + dy * linesize,
		  p->screen_base + sy * linesize,
		  height * linesize);
	return;
    }
    if (fontwidthlog(p)) {
	sx <<= fontwidthlog(p)+1;
	dx <<= fontwidthlog(p)+1;
	width <<= fontwidthlog(p)+1;
    } else {
	sx *= fontwidth(p)*2;
	dx *= fontwidth(p)*2;
	width *= fontwidth(p)*2;
    }
    sx += splash_data.splash_text_xo*2 + splash_data.splash_text_yo * bytes;
    dx += splash_data.splash_text_xo*2 + splash_data.splash_text_yo * bytes;
    if (dy < sy || (dy == sy && dx < sx)) {
	src = p->screen_base + sy * linesize + sx;
	dst = p->screen_base + dy * linesize + dx;
	for (rows = height * fontheight(p); rows--;) {
	    fb_memmove(dst, src, width);
	    src += bytes;
	    dst += bytes;
	}
    } else {
	src = p->screen_base + (sy+height) * linesize + sx - bytes;
	dst = p->screen_base + (dy+height) * linesize + dx - bytes;
	for (rows = height * fontheight(p); rows--;) {
	    fb_memmove(dst, src, width);
	    src -= bytes;
	    dst -= bytes;
	}
    }
}

static inline void rectfill(u8 *dest, int width, int height, u32 data,
			    int linesize)
{
    int i;

    data |= data<<16;

    while (height-- > 0) {
	u32 *p = (u32 *)dest;
	for (i = 0; i < width/4; i++) {
	    fb_writel(data, p++);
	    fb_writel(data, p++);
	}
	if (width & 2)
	    fb_writel(data, p++);
	if (width & 1)
	    fb_writew(data, (u16*)p);
	dest += linesize;
    }
}

void splashfill(u8 *dest, u8 *src, int width, int height,
                       int dest_linesize, int src_linesize)
{

    int i;

    while (height-- > 0) {
	u32 *p = (u32 *)dest;
	u32 *q = (u32 *)src;

	for (i=0; i < width/4; i++) {
	    fb_writel(*q++,p++);
	    fb_writel(*q++,p++);
	}
	if (width & 2)
	    fb_writel(*q++,p++);
	if (width & 1)
	    fb_writew(*(u16*)q,(u16*)p);
	dest += dest_linesize;
	src  += src_linesize;
    }
}

void fbcon_splash16_clear(struct vc_data *conp, struct display *p, int sy, int sx,
		       int height, int width)
{
    u8 *dest;
    int bytes = p->next_line, lines = height * fontheight(p);
    u32 bgx;
    int offset, transparent=0;

    dest = p->screen_base + sy * fontheight(p) * bytes + sx * fontwidth(p) * 2;

    bgx = ((u16 *)p->dispsw_data)[attr_bgcol_ec(p, conp)];

    width *= fontwidth(p)/4;

    dest   += splash_data.splash_text_yo * bytes  +
		  splash_data.splash_text_xo * 2;

    transparent = (splash_data.splash_color == attr_bgcol_ec(p, conp));
    
    if (transparent) {
	offset = (sy * fontheight(p) + splash_data.splash_text_yo) * splash_bytes +
		 (sx * fontwidth(p) + splash_data.splash_text_xo) *  2;
	
	if ((width * 8 == bytes && splash_bytes == bytes))
	    splashfill(dest,linux_splash + offset, lines * width * 4, 
			    1, bytes, splash_bytes);
	else
	    splashfill(dest,linux_splash + offset, width*4, lines,
			    bytes, splash_bytes);
    } else {
	 if (width * 8 == bytes)
	    rectfill(dest, lines * width * 4, 1, bgx, bytes);
	 else
	    rectfill(dest, width * 4, lines, bgx, bytes);
    }
}


/*
 *  Helper function to read the background from the splashscreen
 */
# define SPLASH_BGX(off)			\
	if (transparent) {			\
	    bgx = *(u32*)(splashbgx + (off));	\
	    eorx = fgx ^ bgx;			\
	}


void fbcon_splash16_putc(struct vc_data *conp, struct display *p, int c, int yy,
		      int xx)
{
    u8 *dest, *cdat, bits;
    int bytes = p->next_line, rows;
    u32 eorx, fgx, bgx;
    int transparent = 0;
    u8 *splashbgx = 0;
 
    dest = p->screen_base + yy * fontheight(p) * bytes + xx * fontwidth(p) * 2;

    fgx = ((u16 *)p->dispsw_data)[attr_fgcol(p, c)];
    bgx = ((u16 *)p->dispsw_data)[attr_bgcol(p, c)];

    transparent = (splash_data.splash_color == attr_bgcol(p, c));
    
    dest += splash_data.splash_text_xo * 2 + splash_data.splash_text_yo * bytes;
    splashbgx = linux_splash +
	    (yy * fontheight(p) + splash_data.splash_text_yo) * splash_bytes + 
	    (xx * fontwidth(p) + splash_data.splash_text_xo) * 2;

    if (transparent && splash_data.splash_color == 0xf) {
	if (fgx == 0xffea)
	    fgx = 0xfe4a;
	else if (fgx == 0x57ea)
	    fgx = 0x0540;
	else if (fgx == 0xffff)
	    fgx = 0x52aa;
    }

    fgx |= (fgx << 16);
    bgx |= (bgx << 16);
    eorx = fgx ^ bgx;

    switch (fontwidth(p)) {
    case 4:
    case 8:
	cdat = p->fontdata + (c & p->charmask) * fontheight(p);
	for (rows = fontheight(p); rows--; dest += bytes) {
	    bits = *cdat++;
	    SPLASH_BGX(0);
	    fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest);
	    SPLASH_BGX(4);
	    fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+4);
	    if (fontwidth(p) == 8) {
		SPLASH_BGX(8);
		fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+8);
		SPLASH_BGX(12);
		fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+12);
	    }

	    splashbgx += splash_bytes;

	}
	break;
    case 12:
    case 16:
	cdat = p->fontdata + ((c & p->charmask) * fontheight(p) << 1);
	for (rows = fontheight(p); rows--; dest += bytes) {
	    bits = *cdat++;
	    SPLASH_BGX(0);
	    fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest);
	    SPLASH_BGX(4);
	    fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+4);
	    SPLASH_BGX(8);
	    fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+8);
	    SPLASH_BGX(12);
	    fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+12);
	    bits = *cdat++;
	    SPLASH_BGX(16);
	    fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest+16);
	    SPLASH_BGX(20);
	    fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+20);
	    if (fontwidth(p) == 16) {
		SPLASH_BGX(24);
		fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+24);
		SPLASH_BGX(28);
		fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+28);
	    }
	}
	break;
    }
}

void fbcon_splash16_putcs(struct vc_data *conp, struct display *p,
		       const unsigned short *s, int count, int yy, int xx)
{
    u8 *cdat, *dest, *dest0;
    u16 c;
    int rows, bytes = p->next_line;
    u32 eorx, fgx, bgx;
    int transparent = 0;
    u8 *splashbgx0 = 0, *splashbgx;

    dest0 = p->screen_base + yy * fontheight(p) * bytes + xx * fontwidth(p) * 2;
    c = scr_readw(s);
    fgx = ((u16 *)p->dispsw_data)[attr_fgcol(p, c)];
    bgx = ((u16 *)p->dispsw_data)[attr_bgcol(p, c)];

    transparent = (splash_data.splash_color == attr_bgcol(p, c));
    
    dest0 += splash_data.splash_text_xo * 2 + splash_data.splash_text_yo * bytes;
    splashbgx0 = linux_splash +
	      (yy * fontheight(p) + splash_data.splash_text_yo) * splash_bytes +
	      (xx * fontwidth(p) + splash_data.splash_text_xo) * 2;

    if (transparent && splash_data.splash_color == 0xf) {
	if (fgx == 0xffea)
	    fgx = 0xfe4a;
	else if (fgx == 0x57ea)
	    fgx = 0x0540;
	else if (fgx == 0xffff)
	    fgx = 0x52aa;
    }

    fgx |= (fgx << 16);
    bgx |= (bgx << 16);
    eorx = fgx ^ bgx;

    switch (fontwidth(p)) {
    case 4:
    case 8:
	while (count--) {
	    c = scr_readw(s++) & p->charmask;
	    cdat = p->fontdata + c * fontheight(p);

	    splashbgx = splashbgx0;

	    for (rows = fontheight(p), dest = dest0; rows--; dest += bytes) {
		u8 bits = *cdat++;
		SPLASH_BGX(0);
	        fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest);
		SPLASH_BGX(4);
	        fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+4);
		if (fontwidth(p) == 8) {
		    SPLASH_BGX(8);
		    fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+8);
		    SPLASH_BGX(12);
		    fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+12);
		}
		splashbgx += splash_bytes;
	    }

	    dest0 += fontwidth(p)*2;
	    splashbgx0 += fontwidth(p) * 2;
	}

	break;
    case 12:
    case 16:
	while (count--) {
	    c = scr_readw(s++) & p->charmask;
	    cdat = p->fontdata + (c * fontheight(p) << 1);

	    splashbgx = splashbgx0;

	    for (rows = fontheight(p), dest = dest0; rows--; dest += bytes) {
		u8 bits = *cdat++;
		SPLASH_BGX(0);
	        fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest);
		SPLASH_BGX(4);
	        fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+4);
		SPLASH_BGX(8);
	        fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+8);
		SPLASH_BGX(12);
	        fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+12);
		bits = *cdat++;
		SPLASH_BGX(16);
	        fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest+16);
		SPLASH_BGX(20);
	        fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+20);
		if (fontwidth(p) == 16) {
		    SPLASH_BGX(24);
		    fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+24);
		    SPLASH_BGX(28);
		    fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+28);
		}
		splashbgx += splash_bytes;
	    }

	    dest0 += fontwidth(p)*2;
	    splashbgx0 += fontwidth(p) * 2;
	}

	break;
    }
}

void fbcon_splash16_revc(struct display *p, int xx, int yy)
{
    u8 *dest;
    int bytes = p->next_line, rows;

    dest = p->screen_base + yy * fontheight(p) * bytes + xx * fontwidth(p)*2;
    dest += splash_data.splash_text_yo * bytes + splash_data.splash_text_xo * 2;

    for (rows = fontheight(p); rows--; dest += bytes) {
	switch (fontwidth(p)) {
	case 16:
	    fb_writel(fb_readl(dest+24) ^ 0xffffffff, dest+24);
	    fb_writel(fb_readl(dest+28) ^ 0xffffffff, dest+28);
	    /* FALL THROUGH */
	case 12:
	    fb_writel(fb_readl(dest+16) ^ 0xffffffff, dest+16);
	    fb_writel(fb_readl(dest+20) ^ 0xffffffff, dest+20);
	    /* FALL THROUGH */
	case 8:
	    fb_writel(fb_readl(dest+8) ^ 0xffffffff, dest+8);
	    fb_writel(fb_readl(dest+12) ^ 0xffffffff, dest+12);
	    /* FALL THROUGH */
	case 4:
	    fb_writel(fb_readl(dest+0) ^ 0xffffffff, dest+0);
	    fb_writel(fb_readl(dest+4) ^ 0xffffffff, dest+4);
	}
    }
}

void fbcon_splash16_clear_margins(struct vc_data *conp, struct display *p,
			       int bottom_only)
{
    int bytes = p->next_line;
    u32 bgx;

    unsigned int right_start = conp->vc_cols*fontwidth(p);
    unsigned int bottom_start = conp->vc_rows*fontheight(p);
    unsigned int right_width, bottom_width;

    int left_margin_width = splash_data.splash_text_xo;
    int text_width = conp->vc_cols * fontwidth(p);
    int right_margin_width = p->var.xres - text_width - left_margin_width;
    int top_margin_height = splash_data.splash_text_yo;
    int text_height = conp->vc_rows * fontheight(p);
    int bottom_margin_height = p->var.yres - text_height - top_margin_height;
 
    bgx = ((u16 *)p->dispsw_data)[attr_bgcol_ec(p, conp)];

    if (bottom_only == -1) {
	printk(KERN_DEBUG "Called with bottom-only\n");
	splashfill(p->screen_base, linux_splash, p->var.xres, p->var.yres, bytes, splash_bytes); 
	return;
    }

    if (!bottom_only && (right_width = p->var.xres-right_start)) {
  	/* left margin */
	splashfill(p->screen_base + top_margin_height * bytes,
		   linux_splash + top_margin_height * 
		   splash_bytes, left_margin_width,
		   text_height, bytes, splash_bytes);

	/* right margin */
	splashfill(p->screen_base + left_margin_width*2 + text_width*2 +
		    top_margin_height * bytes, linux_splash +
		    left_margin_width*2 + text_width*2 + top_margin_height *
		    splash_bytes, right_margin_width, text_height,
		    bytes, splash_bytes);
    }

    if ((bottom_width = p->var.yres-bottom_start))
	/* bottom margin */
	splashfill(p->screen_base + (top_margin_height + text_height) *
		    bytes, linux_splash + (top_margin_height +
		    text_height) * splash_bytes, p->var.xres, 
		    bottom_margin_height, bytes, splash_bytes);

    /* top margin */
    splashfill(p->screen_base, linux_splash,
	    p->var.xres, top_margin_height,
	    bytes, splash_bytes);

    /* leave function if work is done */
    return;
}


    /*
     *  `switch' for the low level operations
     */

struct display_switch fbcon_splash16 = {
    bmove:		fbcon_splash16_bmove,
    clear:		fbcon_splash16_clear,
    putc:		fbcon_splash16_putc,
    putcs:		fbcon_splash16_putcs,
    revc:		fbcon_splash16_revc,
    clear_margins:	fbcon_splash16_clear_margins,
    fontwidthmask:	FONTWIDTH(4)|FONTWIDTH(8)|FONTWIDTH(12)|FONTWIDTH(16)
};


#ifdef MODULE
MODULE_LICENSE("GPL");

int init_module(void)
{
    return 0;
}

void cleanup_module(void)
{}
#endif /* MODULE */


    /*
     *  Visible symbols for modules
     */

EXPORT_SYMBOL(fbcon_splash16);
EXPORT_SYMBOL(fbcon_splash16_bmove);
EXPORT_SYMBOL(fbcon_splash16_clear);
EXPORT_SYMBOL(fbcon_splash16_putc);
EXPORT_SYMBOL(fbcon_splash16_putcs);
EXPORT_SYMBOL(fbcon_splash16_revc);
EXPORT_SYMBOL(fbcon_splash16_clear_margins);




#include <linux/vt_kern.h>
#include <linux/selection.h>
#include <linux/smp.h>
#include <linux/init.h>
#include <linux/pm.h>
#include <linux/vmalloc.h>

#include <asm/irq.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#ifdef CONFIG_AMIGA

#include <asm/linux_logo.h>

#include <video/fbcon.h>
#include <video/fbcon-mac.h>	/* for 6x11 font on mac */
#include <video/font.h>
#ifdef CONFIG_FBCON_SPLASHSCREEN
#include <video/fbcon-cfb16.h> /* for fbcon_cfb16 */
#include "fbcon-splash.h"

extern void con_remap_def_color(int currcons, int new_color);

extern int splash_default;
extern int splash_shown;

extern struct display_switch fbcon_splash16;

#ifdef CONFIG_PROC_FS
int splash_proc_register(void);
int splash_proc_unregister(void);
#endif
#endif


#ifdef FBCONDEBUG
#  define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
#else
#  define DPRINTK(fmt, args...)

#endif

    return display_desc;
}

#ifdef CONFIG_FBCON_SPLASHSCREEN
    static int splash_registered=0;
#endif

static void fbcon_init(struct vc_data *conp, int init)
{
    int unit = conp->vc_num;
    struct fb_info *info;

    fb_display[unit].cmap.len = 0;
    fb_display[unit].cmap.red = 0;
    fb_display[unit].cmap.green = 0;
    fb_display[unit].cmap.blue = 0;
    fb_display[unit].cmap.transp = 0;

#ifdef CONFIG_FBCON_SPLASHSCREEN 
   if (!splash_registered && fb_display[unit].var.bits_per_pixel == 16 ) {
   if (unit == 0 && !fb_display[unit].splash_data) {
       extern unsigned long initrd_start, initrd_end;

       if (initrd_start && !splash_getraw((unsigned char *)initrd_start, (unsigned char *)initrd_end) && fb_display[unit].splash_data)
       fb_display[unit].splash_data->splash_state = splash_default & 1;
   }
   splash_registered = 1;
#ifdef CONFIG_PROC_FS
   splash_proc_register();
#endif
    }
    if (fb_display[unit].splash_data && fb_display[unit].var.bits_per_pixel != 16 ) {
        vfree(fb_display[unit].splash_data);
        fb_display[unit].splash_data = 0;
    }
#endif

    fbcon_setup(unit, init, !init);
    /* Must be done after fbcon_setup to prevent excess updates */
    conp->vc_display_fg = &info->display_fg;
    if (!info->display_fg)
        info->display_fg = conp;

    struct display *p = &fb_display[unit];

    fbcon_free_font(p);
    p->dispsw = &fbcon_dummy;
    p->conp = 0;
#ifdef CONFIG_FBCON_SPLASHSCREEN
    if (splash_registered) {
#ifdef CONFIG_PROC_FS
        splash_proc_unregister();
#endif
   splash_registered = 0;
    }
#endif
}


static int fbcon_changevar(int con)
{

    old_cols = conp->vc_cols;
    old_rows = conp->vc_rows;
    
    nr_cols = p->var.xres/fontwidth(p);
    nr_rows = p->var.yres/fontheight(p);
#ifdef CONFIG_FBCON_SPLASHSCREEN
    if (p->splash_data && p->splash_data->splash_state) {
   nr_cols = p->splash_data->splash_text_wi / fontwidth(p);
   nr_rows = p->splash_data->splash_text_he / fontheight(p);
   logo = 0;
    }
#endif

    if (logo) {
    	/* Need to make room for the logo */
	int cnt;
	int step;
    

	       "supported\n", p->type, p->type_aux, p->var.bits_per_pixel);
    p->dispsw->setup(p);

    p->fgcol = p->var.bits_per_pixel > 2 ? 7 : (1<<p->var.bits_per_pixel)-1;
    p->bgcol = 0;
#ifdef CONFIG_FBCON_SPLASHSCREEN
    if(p->splash_data && p->splash_data->splash_state)
   con_remap_def_color(con, p->splash_data->splash_color << 4 | p->splash_data->splash_fg_color);
#endif 


    if (!init) {
	if (conp->vc_cols != nr_cols || conp->vc_rows != nr_rows)
	    vc_resize_con(nr_rows, nr_cols, con);
	else if (CON_IS_VISIBLE(conp) &&

	    if (count > conp->vc_rows)	/* Maximum realistic size */
		count = conp->vc_rows;
	    if (softback_top)
	        fbcon_softback_note(conp, t, count);
	    if (logo_shown >= 0) goto redraw_up;
#ifdef CONFIG_FBCON_SPLASHSCREEN
       if (splash_shown) goto redraw_up;
#endif
	    switch (p->scrollmode & __SCROLL_YMASK) {
	    case __SCROLL_YMOVE:
		p->dispsw->bmove(p, t+count, 0, t, 0, b-t-count,
				 conp->vc_cols);
		p->dispsw->clear(conp, p, b-count, 0, count,

	    break;

	case SM_DOWN:
	    if (count > conp->vc_rows)	/* Maximum realistic size */
		count = conp->vc_rows;
#ifdef CONFIG_FBCON_SPLASHSCREEN
       if (splash_shown) goto redraw_down;
#endif
	    switch (p->scrollmode & __SCROLL_YMASK) {
	    case __SCROLL_YMOVE:
		p->dispsw->bmove(p, t, 0, t+count, 0, b-t-count,
				 conp->vc_cols);
		p->dispsw->clear(conp, p, t, 0,

	    fbcon_bmove_rec(p, sy+b, sx, dy+b, dx, height-b, width, y_break);
	    fbcon_bmove_rec(p, sy, sx, dy, dx, b, width, y_break);
	}
	return;
    }
#ifdef CONFIG_FBCON_SPLASHSCREEN
   if (splash_shown && sy == dy) {
   /* must use slower redraw bmove to keep background pic intact */
    fbcon_redraw_bmove(p, real_y(p, sy), sx, real_y(p, dy), dx, height, width);
    return;
   }
#endif
    p->dispsw->bmove(p, real_y(p, sy), sx, real_y(p, dy), dx, height, width);
}


static int fbcon_switch(struct vc_data *conp)
{
    int unit = conp->vc_num;
    struct display *p = &fb_display[unit];
    struct fb_info *info = p->fb_info;
#ifdef CONFIG_FBCON_SPLASHSCREEN
    splash_prepare(p);
#endif

    if (softback_top) {
    	int l = fbcon_softback_size / conp->vc_size_row;
	if (softback_lines)
	    fbcon_set_origin(conp);


static int fbcon_blank(struct vc_data *conp, int blank)
{
    struct display *p = &fb_display[conp->vc_num];
    struct fb_info *info = p->fb_info;
#ifdef CONFIG_FBCON_SPLASHSCREEN
    struct display_switch *olddispsw=NULL;
    char    *oldscreen_base=NULL;
#endif

    if (blank < 0)	/* Entering graphics mode */
	return 0;

#ifdef CONFIG_FBCON_SPLASHSCREEN
    if (p->splash_data && p->splash_data->oldscreen_base) {
        oldscreen_base = p->screen_base;
        p->screen_base = p->splash_data->oldscreen_base;
    }
    if (p->splash_data && p->splash_data->olddispsw) {
        olddispsw = p->dispsw;
        p->dispsw = p->splash_data->olddispsw;
    }
#endif

    fbcon_cursor(p->conp, blank ? CM_ERASE : CM_DRAW);

    if (!p->can_soft_blank) {
	if (blank) {
#ifdef CONFIG_FBCON_SPLASHSCREEN
       if (p->splash_data && p->splash_data->oldscreen_base) {
           oldscreen_base = p->screen_base;
           p->screen_base = p->splash_data->oldscreen_base;
       }
       if (p->splash_data && p->splash_data->olddispsw) {
           olddispsw = p->dispsw;
           p->dispsw = p->splash_data->olddispsw;
       }
#endif

	    if (p->visual == FB_VISUAL_MONO01) {
		if (p->screen_base)
		    fb_memset255(p->screen_base,
				 p->var.xres_virtual*p->var.yres_virtual*
				 p->var.bits_per_pixel>>3);
	    } else {
	    	unsigned short oldc;
	    	u_int height;
            u_int width;
	    	u_int y_break;

	    	oldc = conp->vc_video_erase_char;
	    	conp->vc_video_erase_char &= p->charmask;
	    	height = conp->vc_rows;
            width  = conp->vc_cols;
		    y_break = p->vrows-p->yscroll;
#ifdef CONFIG_FBCON_SPLASHSCREEN
       if (splash_shown) {
           width=p->var.xres/fontwidth(p);
           height=p->var.yres/fontheight(p);
       }
#endif
		if (height > y_break) {
            p->dispsw->clear(conp, p, real_y(p, 0), 0, y_break, width);
            p->dispsw->clear(conp, p, real_y(p, y_break), 0, height-y_break, width);
		} else
			p->dispsw->clear(conp, p, real_y(p, 0), 0, height, width);
		conp->vc_video_erase_char = oldc;
	    }
#ifdef CONFIG_FBCON_SPLASHSCREEN
       if(oldscreen_base)
       p->screen_base=oldscreen_base;
       if(olddispsw)
       p->dispsw=olddispsw;
#endif
	    return 0;
	} else {
	    /* Tell console.c that it has to restore the screen itself */
	    return 1;
	}

    }
    fbcon_font_widths(p);

    if (resize) {
    	struct vc_data *conp = p->conp;
        __u32 xres = p->var.xres, yres = p->var.yres;
	/* reset wrap/pan */
	p->var.xoffset = p->var.yoffset = p->yscroll = 0;
	p->vrows = p->var.yres_virtual/h;
#ifdef CONFIG_FBCON_SPLASHSCREEN
   if (p->splash_data && p->splash_data->splash_state) {
       xres = p->splash_data->splash_text_wi;
       yres = p->splash_data->splash_text_he;
        }
#endif
   if ((yres % h) && (p->var.yres_virtual % h < p->var.yres % h))
	    p->vrows--;
	updatescrollmode(p);
	vc_resize_con( yres/h, xres/w, unit );
        if (CON_IS_VISIBLE(conp) && softback_buf) {
	    int l = fbcon_softback_size / conp->vc_size_row;
	    if (l > 5)
		softback_end = softback_buf + l * conp->vc_size_row;
	    else {

	logo_depth = 1;
    }
    
    if (p->fb_info->fbops->fb_rasterimg)
    	p->fb_info->fbops->fb_rasterimg(p->fb_info, 1);
#ifdef CONFIG_FBCON_SPLASHSCREEN
    if (!splash_shown) {
#endif

    for (x = 0; x < smp_num_cpus * (LOGO_W + 8) &&
    	 x < p->var.xres - (LOGO_W + 8); x += (LOGO_W + 8)) {
    	 
#if defined(CONFIG_FBCON_CFB16) || defined(CONFIG_FBCON_CFB24) || \

		}
		done = 1;
	}
#endif			
    }
#ifdef CONFIG_FBCON_SPLASHSCREEN
    }
#endif

    if (p->fb_info->fbops->fb_rasterimg)
    	p->fb_info->fbops->fb_rasterimg(p->fb_info, 0);

    /* Modes not yet supported: packed pixels with depth != 8 (does such a
     * thing exist in reality?) */




    void (*clear_margins)(struct vc_data *conp, struct display *p,
			  int bottom_only);
    unsigned int fontwidthmask;      /* 1 at (1 << (width - 1)) if width is supported */
}; 

#ifdef CONFIG_FBCON_SPLASHSCREEN
struct splash_data {
   int splash_state;           /* show splash? */
   int splash_color;           /* transparent color */
   int splash_fg_color;        /* foreground color */
   int splash_width;           /* width of image */
   int splash_height;          /* height of image */
   int splash_text_xo;         /* text area origin */
   int splash_text_yo;
   int splash_text_wi;         /* text area size */ 
   int splash_text_he;
   int splash_showtext;        /* silent/verbose mode */
   int splash_boxcount;
   int splash_percent;
   int splash_overpaintok;     /* is it ok to overpaint boxes */
   int splash_palcnt;
   struct display_switch *olddispsw;   /* old dispsw, normally &fbcon_cfb16*/
   char    *oldscreen_base;        /* pointer to top of virtual screen */    
   unsigned char *splash_boxes;
   unsigned char *splash_jpeg;     /* jpeg */
   unsigned char *splash_palette;      /* palette for 8-bit */

   int splash_dosilent;        /* show silent jpeg */
   unsigned char *splash_silentjpeg;
   unsigned char *splash_sboxes;
   int splash_sboxcount;
};
#endif

extern struct display_switch fbcon_dummy;

   /*
    *    This is the interface between the low-level console driver and the
    *    low-level frame buffer device

    int userfont;                   /* != 0 if fontdata kmalloc()ed */
    u_short scrollmode;             /* Scroll Method */
    short yscroll;                  /* Hardware scrolling */
    unsigned char fgshift, bgshift;
    unsigned short charmask;        /* 0xff or 0x1ff */
#ifdef CONFIG_FBCON_SPLASHSCREEN
    struct splash_data *splash_data;
#endif

};

/* drivers/video/fbcon.c */
extern struct display fb_display[MAX_NR_CONSOLES];
extern char con2fb_map[MAX_NR_CONSOLES];

Lines 73-82 Link Here

(-)linux-2.4.21/kernel/panic.c (-1 / +13 lines)
73	/*	73	/*
74	* Delay timeout seconds before rebooting the machine.	74	* Delay timeout seconds before rebooting the machine.
75	* We can't use the "normal" timers since we just panicked..	75	* We can't use the "normal" timers since we just panicked..
76	*/	76	*/
77	printk(KERN_EMERG "Rebooting in %d seconds..",panic_timeout);	77	printk(KERN_EMERG "Rebooting in %d seconds..",panic_timeout);
		78	#ifdef CONFIG_FBCON_SPLASHSCREEN
		79	{
		80	extern int splash_verbose(void);
		81	(void)splash_verbose();
		82	}
		83	#endif
78	mdelay(panic_timeout*1000);	84	mdelay(panic_timeout*1000);
79	/*	85	/*
80	* Should we run the reboot notifier. For the moment Im	86	* Should we run the reboot notifier. For the moment Im
81	* choosing not too. It might crash, be corrupt or do	87	* choosing not too. It might crash, be corrupt or do
82	* more harm than good for other reasons.	88	* more harm than good for other reasons.
Lines 92-102 Link Here
92	}	98	}
93	#endif	99	#endif
94	#if defined(CONFIG_ARCH_S390)	100	#if defined(CONFIG_ARCH_S390)
95	disabled_wait(caller);	101	disabled_wait(caller);
96	#endif	102	#endif
97	sti();	103	sti();
		104	#ifdef CONFIG_FBCON_SPLASHSCREEN
		105	{
		106	extern int splash_verbose(void);
		107	(void)splash_verbose();
		108	}
		109	#endif
98	for(;;) {	110	for(;;) {
99	#if defined(CONFIG_X86) && defined(CONFIG_VT)	111	#if defined(CONFIG_X86) && defined(CONFIG_VT)
100	extern void panic_blink(void);	112	extern void panic_blink(void);
101	panic_blink();	113	panic_blink();
102	#endif	114	#endif

Return to bug 23369

Lines 3005-3014 Link Here

(-)linux-2.4.21/drivers/char/console.c (+26 lines)
3005	break;	3005	break;
3006	}	3006	}
3007	return 0;	3007	return 0;
3008	}	3008	}
3009		3009
		3010	#ifdef CONFIG_FBCON_SPLASHSCREEN
		3011	void con_remap_def_color(int currcons, int new_color)
		3012	{
		3013	unsigned short *sbuf = screenbuf;
		3014	unsigned c, len = screenbuf_size >> 1;
		3015	int old_color;
		3016
		3017	if (sbuf) {
		3018	old_color = def_color << 8;
		3019	new_color <<= 8;
		3020	while(len--) {
		3021	c = *sbuf;
		3022	if (((c ^ old_color) & 0xf000) == 0)
		3023	*sbuf ^= (old_color ^ new_color) & 0xf000;
		3024	if (((c ^ old_color) & 0x0f00) == 0)
		3025	*sbuf ^= (old_color ^ new_color) & 0x0f00;
		3026	sbuf++;
		3027	}
		3028	new_color >>= 8;
		3029	}
		3030	def_color = color = new_color;
		3031	update_attr(currcons);
		3032	}
		3033	#endif
		3034
		3035
3010	/*	3036	/*
3011	* Visible symbols for modules	3037	* Visible symbols for modules
3012	*/	3038	*/
3013		3039
3014	EXPORT_SYMBOL(color_table);	3040	EXPORT_SYMBOL(color_table);

Lines 249-258 Link Here

(-)linux-2.4.21/drivers/char/keyboard.c (+10 lines)
249	if(!test_and_clear_bit(keycode, key_down))	249	if(!test_and_clear_bit(keycode, key_down))
250	up_flag = kbd_unexpected_up(keycode);	250	up_flag = kbd_unexpected_up(keycode);
251	} else	251	} else
252	rep = test_and_set_bit(keycode, key_down);	252	rep = test_and_set_bit(keycode, key_down);
253		253
		254	#ifdef CONFIG_FBCON_SPLASHSCREEN
		255	/* This code has to be redone for some non-x86 platforms */
		256	if (keycode == 0x3c \|\| keycode == 0x01) { /* F2 and ESC on a PC keyboard */
		257	extern int splash_verbose(void);
		258	if (splash_verbose())
		259	goto out;
		260	}
		261	#endif
		262
		263
254	#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */	264	#ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */
255	if (keycode == SYSRQ_KEY) {	265	if (keycode == SYSRQ_KEY) {
256	sysrq_pressed = !up_flag;	266	sysrq_pressed = !up_flag;
257	goto out;	267	goto out;
258	} else if (sysrq_pressed) {	268	} else if (sysrq_pressed) {

Lines 43-52 Link Here

(-)linux-2.4.21/drivers/char/n_tty.c (+11 lines)
43	#include <linux/kd.h>	43	#include <linux/kd.h>
44	#include <linux/mm.h>	44	#include <linux/mm.h>
45	#include <linux/string.h>	45	#include <linux/string.h>
46	#include <linux/slab.h>	46	#include <linux/slab.h>
47	#include <linux/poll.h>	47	#include <linux/poll.h>
		48	#include <linux/config.h>
48		49
49	#include <asm/uaccess.h>	50	#include <asm/uaccess.h>
50	#include <asm/system.h>	51	#include <asm/system.h>
51	#include <asm/bitops.h>	52	#include <asm/bitops.h>
52		53
Lines 969-978 Link Here
969	if (!tty->read_buf) {	970	if (!tty->read_buf) {
970	printk("n_tty_read_chan: called with read_buf == NULL?!?\n");	971	printk("n_tty_read_chan: called with read_buf == NULL?!?\n");
971	return -EIO;	972	return -EIO;
972	}	973	}
973		974
		975	#ifdef CONFIG_FBCON_SPLASHSCREEN
		976	if (file->f_dentry->d_inode->i_rdev == CONSOLE_DEV \|\|
		977	file->f_dentry->d_inode->i_rdev == SYSCONS_DEV \|\|
		978	file->f_dentry->d_inode->i_rdev == MKDEV(TTYAUX_MAJOR,0) \|\|
		979	file->f_dentry->d_inode->i_rdev == MKDEV(TTY_MAJOR,1)) {
		980	extern int splash_verbose(void);
		981	(void)splash_verbose();
		982	}
		983	#endif
		984
974	/* Job control check -- must be done at start and after	985	/* Job control check -- must be done at start and after
975	every sleep (POSIX.1 7.1.1.4). */	986	every sleep (POSIX.1 7.1.1.4). */
976	/* NOTE: not yet done after every sleep pending a thorough	987	/* NOTE: not yet done after every sleep pending a thorough
977	check of the logic of this change. -- jlc */	988	check of the logic of this change. -- jlc */
978	/* don't stop on /dev/console */	989	/* don't stop on /dev/console */

Lines 227-243 Link Here

(-)linux-2.4.21/drivers/video/Config.in (-3 / +16 lines)
227	fi	227	fi
228	if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then	228	if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
229	tristate ' Virtual Frame Buffer support (ONLY FOR TESTING!) (EXPERIMENTAL)' CONFIG_FB_VIRTUAL	229	tristate ' Virtual Frame Buffer support (ONLY FOR TESTING!) (EXPERIMENTAL)' CONFIG_FB_VIRTUAL
230	fi	230	fi
231		231
		232	dep_bool ' Use splash screen instead of boot logo' CONFIG_FBCON_SPLASHSCREEN $CONFIG_BLK_DEV_INITRD
		233	if [ "$CONFIG_FBCON_SPLASHSCREEN" = "y" ]; then
		234	define_bool CONFIG_FBCON_CFB16 y
		235	fi
		236
232	bool ' Advanced low level driver options' CONFIG_FBCON_ADVANCED	237	bool ' Advanced low level driver options' CONFIG_FBCON_ADVANCED
233	if [ "$CONFIG_FBCON_ADVANCED" = "y" ]; then	238	if [ "$CONFIG_FBCON_ADVANCED" = "y" ]; then
234	tristate ' Monochrome support' CONFIG_FBCON_MFB	239	tristate ' Monochrome support' CONFIG_FBCON_MFB
235	tristate ' 2 bpp packed pixels support' CONFIG_FBCON_CFB2	240	tristate ' 2 bpp packed pixels support' CONFIG_FBCON_CFB2
236	tristate ' 4 bpp packed pixels support' CONFIG_FBCON_CFB4	241	tristate ' 4 bpp packed pixels support' CONFIG_FBCON_CFB4
237	tristate ' 8 bpp packed pixels support' CONFIG_FBCON_CFB8	242	tristate ' 8 bpp packed pixels support' CONFIG_FBCON_CFB8
238	tristate ' 16 bpp packed pixels support' CONFIG_FBCON_CFB16	243	if [ "$CONFIG_FBCON_SPLASHSCREEN" != "y" ]; then
		244	tristate ' 16 bpp packed pixels support' CONFIG_FBCON_CFB16
		245	fi
239	tristate ' 24 bpp packed pixels support' CONFIG_FBCON_CFB24	246	tristate ' 24 bpp packed pixels support' CONFIG_FBCON_CFB24
240	tristate ' 32 bpp packed pixels support' CONFIG_FBCON_CFB32	247	tristate ' 32 bpp packed pixels support' CONFIG_FBCON_CFB32
241	tristate ' Amiga bitplanes support' CONFIG_FBCON_AFB	248	tristate ' Amiga bitplanes support' CONFIG_FBCON_AFB
242	tristate ' Amiga interleaved bitplanes support' CONFIG_FBCON_ILBM	249	tristate ' Amiga interleaved bitplanes support' CONFIG_FBCON_ILBM
243	tristate ' Atari interleaved bitplanes (2 planes) support' CONFIG_FBCON_IPLAN2P2	250	tristate ' Atari interleaved bitplanes (2 planes) support' CONFIG_FBCON_IPLAN2P2
Lines 339-349 Link Here
339	"$CONFIG_FB_RIVA" = "y" -o "$CONFIG_FB_ATY128" = "y" -o \	346	"$CONFIG_FB_RIVA" = "y" -o "$CONFIG_FB_ATY128" = "y" -o \
340	"$CONFIG_FB_CYBER2000" = "y" -o "$CONFIG_FB_3DFX" = "y" -o \	347	"$CONFIG_FB_CYBER2000" = "y" -o "$CONFIG_FB_3DFX" = "y" -o \
341	"$CONFIG_FB_SIS" = "y" -o "$CONFIG_FB_SA1100" = "y" -o \	348	"$CONFIG_FB_SIS" = "y" -o "$CONFIG_FB_SA1100" = "y" -o \
342	"$CONFIG_FB_PVR2" = "y" -o "$CONFIG_FB_VOODOO1" = "y" -o \	349	"$CONFIG_FB_PVR2" = "y" -o "$CONFIG_FB_VOODOO1" = "y" -o \
343	"$CONFIG_FB_NEOMAGIC" = "y" -o "$CONFIG_FB_INTEL" = "y" ]; then	350	"$CONFIG_FB_NEOMAGIC" = "y" -o "$CONFIG_FB_INTEL" = "y" ]; then
344	define_tristate CONFIG_FBCON_CFB16 y	351	if [ "$CONFIG_FBCON_CFB16" != "m" ]; then
		352	define_tristate CONFIG_FBCON_CFB16 y
		353	fi
		354
345	else	355	else
346	if [ "$CONFIG_FB_ATARI" = "m" -o "$CONFIG_FB_ATY" = "m" -o \	356	if [ "$CONFIG_FB_ATARI" = "m" -o "$CONFIG_FB_ATY" = "m" -o \
347	"$CONFIG_FB_MAC" = "m" -o "$CONFIG_FB_VESA" = "m" -o \	357	"$CONFIG_FB_MAC" = "m" -o "$CONFIG_FB_VESA" = "m" -o \
348	"$CONFIG_FB_VIRTUAL" = "m" -o "$CONFIG_FB_TBOX" = "m" -o \	358	"$CONFIG_FB_VIRTUAL" = "m" -o "$CONFIG_FB_TBOX" = "m" -o \
349	"$CONFIG_FB_Q40" = "m" -o "$CONFIG_FB_3DFX" = "m" -o \	359	"$CONFIG_FB_Q40" = "m" -o "$CONFIG_FB_3DFX" = "m" -o \
Lines 356-366 Link Here
356	"$CONFIG_FB_RIVA" = "m" -o "$CONFIG_FB_ATY128" = "m" -o \	366	"$CONFIG_FB_RIVA" = "m" -o "$CONFIG_FB_ATY128" = "m" -o \
357	"$CONFIG_FB_CYBER2000" = "m" -o "$CONFIG_FB_SIS" = "m" -o \	367	"$CONFIG_FB_CYBER2000" = "m" -o "$CONFIG_FB_SIS" = "m" -o \
358	"$CONFIG_FB_SA1100" = "m" -o "$CONFIG_FB_RADEON" = "m" -o \	368	"$CONFIG_FB_SA1100" = "m" -o "$CONFIG_FB_RADEON" = "m" -o \
359	"$CONFIG_FB_PVR2" = "m" -o "$CONFIG_FB_VOODOO1" = "m" -o \	369	"$CONFIG_FB_PVR2" = "m" -o "$CONFIG_FB_VOODOO1" = "m" -o \
360	"$CONFIG_FB_NEOMAGIC" = "m" -o "$CONFIG_FB_INTEL" = "m" ]; then	370	"$CONFIG_FB_NEOMAGIC" = "m" -o "$CONFIG_FB_INTEL" = "m" ]; then
361	define_tristate CONFIG_FBCON_CFB16 m	371	if [ "$CONFIG_FBCON_CFB16" != "y" ]; then
		372	define_tristate CONFIG_FBCON_CFB16 m
		373	fi
		374
362	fi	375	fi
363	fi	376	fi
364	if [ "$CONFIG_FB_ATY" = "y" -o "$CONFIG_FB_VIRTUAL" = "y" -o \	377	if [ "$CONFIG_FB_ATY" = "y" -o "$CONFIG_FB_VIRTUAL" = "y" -o \
365	"$CONFIG_FB_CLGEN" = "y" -o "$CONFIG_FB_VESA" = "y" -o \	378	"$CONFIG_FB_CLGEN" = "y" -o "$CONFIG_FB_VESA" = "y" -o \
366	"$CONFIG_FB_MATROX" = "y" -o "$CONFIG_FB_PM2" = "y" -o \	379	"$CONFIG_FB_MATROX" = "y" -o "$CONFIG_FB_PM2" = "y" -o \

Lines 12-22 Link Here

(-)linux-2.4.21/drivers/video/Makefile (-1 / +6 lines)
12	export-objs := fbmem.o fbcmap.o fbcon.o fbmon.o modedb.o \	12	export-objs := fbmem.o fbcmap.o fbcon.o fbmon.o modedb.o \
13	fbcon-afb.o fbcon-ilbm.o \	13	fbcon-afb.o fbcon-ilbm.o \
14	fbcon-vga.o fbcon-iplan2p2.o fbcon-iplan2p4.o \	14	fbcon-vga.o fbcon-iplan2p2.o fbcon-iplan2p4.o \
15	fbcon-iplan2p8.o fbcon-vga-planes.o fbcon-cfb16.o \	15	fbcon-iplan2p8.o fbcon-vga-planes.o fbcon-cfb16.o \
16	fbcon-cfb2.o fbcon-cfb24.o fbcon-cfb32.o fbcon-cfb4.o \	16	fbcon-cfb2.o fbcon-cfb24.o fbcon-cfb32.o fbcon-cfb4.o \
17	fbcon-cfb8.o fbcon-mac.o fbcon-mfb.o \	17	fbcon-cfb8.o fbcon-splash16.o fbcon-mac.o fbcon-mfb.o \
18	cyber2000fb.o sa1100fb.o fbcon-hga.o fbgen.o	18	cyber2000fb.o sa1100fb.o fbcon-hga.o fbgen.o
19		19
20	# Each configuration option enables a list of files.	20	# Each configuration option enables a list of files.
21		21
22	obj-$(CONFIG_DUMMY_CONSOLE) += dummycon.o	22	obj-$(CONFIG_DUMMY_CONSOLE) += dummycon.o
Lines 150-159 Link Here
150	obj-$(CONFIG_FBCON_MFB) += fbcon-mfb.o	150	obj-$(CONFIG_FBCON_MFB) += fbcon-mfb.o
151	obj-$(CONFIG_FBCON_VGA) += fbcon-vga.o	151	obj-$(CONFIG_FBCON_VGA) += fbcon-vga.o
152	obj-$(CONFIG_FBCON_HGA) += fbcon-hga.o	152	obj-$(CONFIG_FBCON_HGA) += fbcon-hga.o
153	obj-$(CONFIG_FBCON_STI) += fbcon-sti.o	153	obj-$(CONFIG_FBCON_STI) += fbcon-sti.o
154		154
		155	obj-$(CONFIG_FBCON_SPLASHSCREEN) += fbcon-splash.o
		156	obj-$(CONFIG_FBCON_SPLASHSCREEN) += fbcon-splash16.o
		157	obj-$(CONFIG_FBCON_SPLASHSCREEN) += fbcon-jpegdec.o
		158
		159
155	include $(TOPDIR)/Rules.make	160	include $(TOPDIR)/Rules.make
156		161
157	clean:	162	clean:
158	rm -f core .o .a *.s	163	rm -f core .o .a *.s
159		164

Line 0 Link Here

(-)linux-2.4.21/drivers/video/fbcon-jpegdec.h (+24 lines)
	1	#define ERR_NO_SOI 1
	2	#define ERR_NOT_8BIT 2
	3	#define ERR_HEIGHT_MISMATCH 3
	4	#define ERR_WIDTH_MISMATCH 4
	5	#define ERR_BAD_WIDTH_OR_HEIGHT 5
	6	#define ERR_TOO_MANY_COMPPS 6
	7	#define ERR_ILLEGAL_HV 7
	8	#define ERR_QUANT_TABLE_SELECTOR 8
	9	#define ERR_NOT_YCBCR_221111 9
	10	#define ERR_UNKNOWN_CID_IN_SCAN 10
	11	#define ERR_NOT_SEQUENTIAL_DCT 11
	12	#define ERR_WRONG_MARKER 12
	13	#define ERR_NO_EOI 13
	14	#define ERR_BAD_TABLES 14
	15	#define ERR_DEPTH_MISMATCH 15
	16
	17	struct jpeg_decdata {
	18	int dcts[6 * 64 + 16];
	19	int out[64 * 6];
	20	int dquant[3][64];
	21	};
	22
	23	extern int jpeg_decode(unsigned char , unsigned char , int, int, int, struct jpeg_decdata *);
	24	extern int jpeg_check_size(unsigned char *, int, int);

Line 0 Link Here

(-)linux-2.4.21/drivers/video/fbcon-splash.h (+19 lines)
	1	/*
	2	* linux/drivers/video/splash.h - splash screen definition.
	3	*
	4	* (w) 2001-2003 by Volker Poplawski, <volker@suse.de>
	5	* Stefan Reinauer, <stepan@suse.de>
	6	*
	7	*
	8	* idea and SuSE screen work by Ken Wimer, <wimer@suse.de>
	9	*/
	10
	11	extern int splash_getraw(unsigned char , unsigned char );
	12	extern int splash_prepare(struct display *);
	13
	14	extern int splash_shown; /* is splash shown? */
	15	extern struct splash_data splash_data; /* image data, copied over
	16	from display */
	17	extern unsigned char linux_splash; / decoded pic data */
	18	extern int splash_bytes; /* bytes per line */
	19

Line 0 Link Here

(-)linux-2.4.21/drivers/video/fbcon-splash16.c (+488 lines)
		1	/*
		2	* linux/drivers/video/fbcon-splash16.c -- Low level frame buffer operations for 16 bpp
		3	* framebuffer operation. Modified to present
		4	* boot splash screen. 2002/11/7 stepan@suse.de
		5	*
		6	* Based on linux/drivers/video/fbcon-cfb16.c, which is
		7	*
		8	* Created 5 Apr 1997 by Geert Uytterhoeven
		9	*
		10	* This file is subject to the terms and conditions of the GNU General Public
		11	* License. See the file COPYING in the main directory of this archive for
		12	* more details.
		13	*/
		14
		15	#include <linux/module.h>
		16	#include <linux/config.h>
		17	#include <linux/tty.h>
		18	#include <linux/console.h>
		19	#include <linux/string.h>
		20	#include <linux/fb.h>
		21	#include <asm/io.h>
		22
		23	#include <video/fbcon.h>
		24	#include <video/fbcon-cfb16.h>
		25
		26	#include "fbcon-splash.h"
		27
		28	/*
		29	* 16 bpp packed pixels
		30	*/
		31
		32	static u32 tab_cfb16[] = {
		33	#if defined(__BIG_ENDIAN)
		34	0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff
		35	#elif defined(__LITTLE_ENDIAN)
		36	0x00000000, 0xffff0000, 0x0000ffff, 0xffffffff
		37	#else
		38	#error FIXME: No endianness??
		39	#endif
		40	};
		41
		42	void fbcon_splash16_bmove(struct display *p, int sy, int sx, int dy, int dx,
		43	int height, int width)
		44	{
		45	int bytes = p->next_line, linesize = bytes * fontheight(p), rows;
		46	u8 src, dst;
		47
		48	if (sx == 0 && dx == 0 && width * fontwidth(p) * 2 == bytes) {
		49	fb_memmove(p->screen_base + dy * linesize,
		50	p->screen_base + sy * linesize,
		51	height * linesize);
		52	return;
		53	}
		54	if (fontwidthlog(p)) {
		55	sx <<= fontwidthlog(p)+1;
		56	dx <<= fontwidthlog(p)+1;
		57	width <<= fontwidthlog(p)+1;
		58	} else {
		59	sx = fontwidth(p)2;
		60	dx = fontwidth(p)2;
		61	width = fontwidth(p)2;
		62	}
		63	sx += splash_data.splash_text_xo2 + splash_data.splash_text_yo bytes;
		64	dx += splash_data.splash_text_xo2 + splash_data.splash_text_yo bytes;
65	if (dy < sy \|\| (dy == sy && dx < sx)) {
66	src = p->screen_base + sy * linesize + sx;
67	dst = p->screen_base + dy * linesize + dx;
68	for (rows = height * fontheight(p); rows--;) {
69	fb_memmove(dst, src, width);
70	src += bytes;
71	dst += bytes;
72	}
73	} else {
74	src = p->screen_base + (sy+height) * linesize + sx - bytes;
75	dst = p->screen_base + (dy+height) * linesize + dx - bytes;
76	for (rows = height * fontheight(p); rows--;) {
77	fb_memmove(dst, src, width);
78	src -= bytes;
79	dst -= bytes;
80	}
81	}
82	}
83
84	static inline void rectfill(u8 *dest, int width, int height, u32 data,
85	int linesize)
86	{
87	int i;
88
89	data \|= data<<16;
90
91	while (height-- > 0) {
92	u32 p = (u32 )dest;
93	for (i = 0; i < width/4; i++) {
94	fb_writel(data, p++);
95	fb_writel(data, p++);
96	}
97	if (width & 2)
98	fb_writel(data, p++);
99	if (width & 1)
100	fb_writew(data, (u16*)p);
101	dest += linesize;
102	}
103	}
104
105	void splashfill(u8 dest, u8 src, int width, int height,
106	int dest_linesize, int src_linesize)
107	{
108
109	int i;
110
111	while (height-- > 0) {
112	u32 p = (u32 )dest;
113	u32 q = (u32 )src;
114
115	for (i=0; i < width/4; i++) {
116	fb_writel(*q++,p++);
117	fb_writel(*q++,p++);
118	}
119	if (width & 2)
120	fb_writel(*q++,p++);
121	if (width & 1)
122	fb_writew((u16)q,(u16*)p);
123	dest += dest_linesize;
124	src += src_linesize;
125	}
126	}
127
128	void fbcon_splash16_clear(struct vc_data conp, struct display p, int sy, int sx,
129	int height, int width)
130	{
131	u8 *dest;
132	int bytes = p->next_line, lines = height * fontheight(p);
133	u32 bgx;
134	int offset, transparent=0;
135
136	dest = p->screen_base + sy * fontheight(p) * bytes + sx * fontwidth(p) * 2;
137
138	bgx = ((u16 *)p->dispsw_data)[attr_bgcol_ec(p, conp)];
139
140	width *= fontwidth(p)/4;
141
142	dest += splash_data.splash_text_yo * bytes +
143	splash_data.splash_text_xo * 2;
144
145	transparent = (splash_data.splash_color == attr_bgcol_ec(p, conp));
146
147	if (transparent) {
148	offset = (sy * fontheight(p) + splash_data.splash_text_yo) * splash_bytes +
149	(sx * fontwidth(p) + splash_data.splash_text_xo) * 2;
150
151	if ((width * 8 == bytes && splash_bytes == bytes))
152	splashfill(dest,linux_splash + offset, lines * width * 4,
153	1, bytes, splash_bytes);
154	else
155	splashfill(dest,linux_splash + offset, width*4, lines,
156	bytes, splash_bytes);
157	} else {
158	if (width * 8 == bytes)
159	rectfill(dest, lines * width * 4, 1, bgx, bytes);
160	else
161	rectfill(dest, width * 4, lines, bgx, bytes);
162	}
163	}
164
165
166	/*
167	* Helper function to read the background from the splashscreen
168	*/
169	# define SPLASH_BGX(off) \
170	if (transparent) { \
171	bgx = (u32)(splashbgx + (off)); \
172	eorx = fgx ^ bgx; \
173	}
174
175
176	void fbcon_splash16_putc(struct vc_data conp, struct display p, int c, int yy,
177	int xx)
178	{
179	u8 dest, cdat, bits;
180	int bytes = p->next_line, rows;
181	u32 eorx, fgx, bgx;
182	int transparent = 0;
183	u8 *splashbgx = 0;
184
185	dest = p->screen_base + yy * fontheight(p) * bytes + xx * fontwidth(p) * 2;
186
187	fgx = ((u16 *)p->dispsw_data)[attr_fgcol(p, c)];
188	bgx = ((u16 *)p->dispsw_data)[attr_bgcol(p, c)];
189
190	transparent = (splash_data.splash_color == attr_bgcol(p, c));
191
192	dest += splash_data.splash_text_xo * 2 + splash_data.splash_text_yo * bytes;
193	splashbgx = linux_splash +
194	(yy * fontheight(p) + splash_data.splash_text_yo) * splash_bytes +
195	(xx * fontwidth(p) + splash_data.splash_text_xo) * 2;
196
197	if (transparent && splash_data.splash_color == 0xf) {
198	if (fgx == 0xffea)
199	fgx = 0xfe4a;
200	else if (fgx == 0x57ea)
201	fgx = 0x0540;
202	else if (fgx == 0xffff)
203	fgx = 0x52aa;
204	}
205
206	fgx \|= (fgx << 16);
207	bgx \|= (bgx << 16);
208	eorx = fgx ^ bgx;
209
210	switch (fontwidth(p)) {
211	case 4:
212	case 8:
213	cdat = p->fontdata + (c & p->charmask) * fontheight(p);
214	for (rows = fontheight(p); rows--; dest += bytes) {
215	bits = *cdat++;
216	SPLASH_BGX(0);
217	fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest);
218	SPLASH_BGX(4);
219	fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+4);
220	if (fontwidth(p) == 8) {
221	SPLASH_BGX(8);
222	fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+8);
223	SPLASH_BGX(12);
224	fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+12);
225	}
226
227	splashbgx += splash_bytes;
228
229	}
230	break;
231	case 12:
232	case 16:
233	cdat = p->fontdata + ((c & p->charmask) * fontheight(p) << 1);
234	for (rows = fontheight(p); rows--; dest += bytes) {
235	bits = *cdat++;
236	SPLASH_BGX(0);
237	fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest);
238	SPLASH_BGX(4);
239	fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+4);
240	SPLASH_BGX(8);
241	fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+8);
242	SPLASH_BGX(12);
243	fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+12);
244	bits = *cdat++;
245	SPLASH_BGX(16);
246	fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest+16);
247	SPLASH_BGX(20);
248	fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+20);
249	if (fontwidth(p) == 16) {
250	SPLASH_BGX(24);
251	fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+24);
252	SPLASH_BGX(28);
253	fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+28);
254	}
255	}
256	break;
257	}
258	}
259
260	void fbcon_splash16_putcs(struct vc_data conp, struct display p,
261	const unsigned short *s, int count, int yy, int xx)
262	{
263	u8 cdat, dest, *dest0;
264	u16 c;
265	int rows, bytes = p->next_line;
266	u32 eorx, fgx, bgx;
267	int transparent = 0;
268	u8 splashbgx0 = 0, splashbgx;
269
270	dest0 = p->screen_base + yy * fontheight(p) * bytes + xx * fontwidth(p) * 2;
271	c = scr_readw(s);
272	fgx = ((u16 *)p->dispsw_data)[attr_fgcol(p, c)];
273	bgx = ((u16 *)p->dispsw_data)[attr_bgcol(p, c)];
274
275	transparent = (splash_data.splash_color == attr_bgcol(p, c));
276
277	dest0 += splash_data.splash_text_xo * 2 + splash_data.splash_text_yo * bytes;
278	splashbgx0 = linux_splash +
279	(yy * fontheight(p) + splash_data.splash_text_yo) * splash_bytes +
280	(xx * fontwidth(p) + splash_data.splash_text_xo) * 2;
281
282	if (transparent && splash_data.splash_color == 0xf) {
283	if (fgx == 0xffea)
284	fgx = 0xfe4a;
285	else if (fgx == 0x57ea)
286	fgx = 0x0540;
287	else if (fgx == 0xffff)
288	fgx = 0x52aa;
289	}
290
291	fgx \|= (fgx << 16);
292	bgx \|= (bgx << 16);
293	eorx = fgx ^ bgx;
294
295	switch (fontwidth(p)) {
296	case 4:
297	case 8:
298	while (count--) {
299	c = scr_readw(s++) & p->charmask;
300	cdat = p->fontdata + c * fontheight(p);
301
302	splashbgx = splashbgx0;
303
304	for (rows = fontheight(p), dest = dest0; rows--; dest += bytes) {
305	u8 bits = *cdat++;
306	SPLASH_BGX(0);
307	fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest);
308	SPLASH_BGX(4);
309	fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+4);
310	if (fontwidth(p) == 8) {
311	SPLASH_BGX(8);
312	fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+8);
313	SPLASH_BGX(12);
314	fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+12);
315	}
316	splashbgx += splash_bytes;
317	}
318
319	dest0 += fontwidth(p)*2;
320	splashbgx0 += fontwidth(p) * 2;
321	}
322
323	break;
324	case 12:
325	case 16:
326	while (count--) {
327	c = scr_readw(s++) & p->charmask;
328	cdat = p->fontdata + (c * fontheight(p) << 1);
329
330	splashbgx = splashbgx0;
331
332	for (rows = fontheight(p), dest = dest0; rows--; dest += bytes) {
333	u8 bits = *cdat++;
334	SPLASH_BGX(0);
335	fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest);
336	SPLASH_BGX(4);
337	fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+4);
338	SPLASH_BGX(8);
339	fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+8);
340	SPLASH_BGX(12);
341	fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+12);
342	bits = *cdat++;
343	SPLASH_BGX(16);
344	fb_writel((tab_cfb16[bits >> 6] & eorx) ^ bgx, dest+16);
345	SPLASH_BGX(20);
346	fb_writel((tab_cfb16[bits >> 4 & 3] & eorx) ^ bgx, dest+20);
347	if (fontwidth(p) == 16) {
348	SPLASH_BGX(24);
349	fb_writel((tab_cfb16[bits >> 2 & 3] & eorx) ^ bgx, dest+24);
350	SPLASH_BGX(28);
351	fb_writel((tab_cfb16[bits & 3] & eorx) ^ bgx, dest+28);
352	}
353	splashbgx += splash_bytes;
354	}
355
356	dest0 += fontwidth(p)*2;
357	splashbgx0 += fontwidth(p) * 2;
358	}
359
360	break;
361	}
362	}
363
364	void fbcon_splash16_revc(struct display *p, int xx, int yy)
365	{
366	u8 *dest;
367	int bytes = p->next_line, rows;
368
369	dest = p->screen_base + yy * fontheight(p) * bytes + xx * fontwidth(p)*2;
370	dest += splash_data.splash_text_yo * bytes + splash_data.splash_text_xo * 2;
371
372	for (rows = fontheight(p); rows--; dest += bytes) {
373	switch (fontwidth(p)) {
374	case 16:
375	fb_writel(fb_readl(dest+24) ^ 0xffffffff, dest+24);
376	fb_writel(fb_readl(dest+28) ^ 0xffffffff, dest+28);
377	/* FALL THROUGH */
378	case 12:
379	fb_writel(fb_readl(dest+16) ^ 0xffffffff, dest+16);
380	fb_writel(fb_readl(dest+20) ^ 0xffffffff, dest+20);
381	/* FALL THROUGH */
382	case 8:
383	fb_writel(fb_readl(dest+8) ^ 0xffffffff, dest+8);
384	fb_writel(fb_readl(dest+12) ^ 0xffffffff, dest+12);
385	/* FALL THROUGH */
386	case 4:
387	fb_writel(fb_readl(dest+0) ^ 0xffffffff, dest+0);
388	fb_writel(fb_readl(dest+4) ^ 0xffffffff, dest+4);
389	}
390	}
391	}
392
393	void fbcon_splash16_clear_margins(struct vc_data conp, struct display p,
394	int bottom_only)
395	{
396	int bytes = p->next_line;
397	u32 bgx;
398
399	unsigned int right_start = conp->vc_cols*fontwidth(p);
400	unsigned int bottom_start = conp->vc_rows*fontheight(p);
401	unsigned int right_width, bottom_width;
402
403	int left_margin_width = splash_data.splash_text_xo;
404	int text_width = conp->vc_cols * fontwidth(p);
405	int right_margin_width = p->var.xres - text_width - left_margin_width;
406	int top_margin_height = splash_data.splash_text_yo;
407	int text_height = conp->vc_rows * fontheight(p);
408	int bottom_margin_height = p->var.yres - text_height - top_margin_height;
409
410	bgx = ((u16 *)p->dispsw_data)[attr_bgcol_ec(p, conp)];
411
412	if (bottom_only == -1) {
413	printk(KERN_DEBUG "Called with bottom-only\n");
414	splashfill(p->screen_base, linux_splash, p->var.xres, p->var.yres, bytes, splash_bytes);
415	return;
416	}
417
418	if (!bottom_only && (right_width = p->var.xres-right_start)) {
419	/* left margin */
420	splashfill(p->screen_base + top_margin_height * bytes,
421	linux_splash + top_margin_height *
422	splash_bytes, left_margin_width,
423	text_height, bytes, splash_bytes);
424
425	/* right margin */
426	splashfill(p->screen_base + left_margin_width2 + text_width2 +
427	top_margin_height * bytes, linux_splash +
428	left_margin_width2 + text_width2 + top_margin_height *
429	splash_bytes, right_margin_width, text_height,
430	bytes, splash_bytes);
431	}
432
433	if ((bottom_width = p->var.yres-bottom_start))
434	/* bottom margin */
435	splashfill(p->screen_base + (top_margin_height + text_height) *
436	bytes, linux_splash + (top_margin_height +
437	text_height) * splash_bytes, p->var.xres,
438	bottom_margin_height, bytes, splash_bytes);
439
440	/* top margin */
441	splashfill(p->screen_base, linux_splash,
442	p->var.xres, top_margin_height,
443	bytes, splash_bytes);
444
445	/* leave function if work is done */
446	return;
447	}
448
449
450	/*
451	* `switch' for the low level operations
452	*/
453
454	struct display_switch fbcon_splash16 = {
455	bmove: fbcon_splash16_bmove,
456	clear: fbcon_splash16_clear,
457	putc: fbcon_splash16_putc,
458	putcs: fbcon_splash16_putcs,
459	revc: fbcon_splash16_revc,
460	clear_margins: fbcon_splash16_clear_margins,
461	fontwidthmask: FONTWIDTH(4)\|FONTWIDTH(8)\|FONTWIDTH(12)\|FONTWIDTH(16)
462	};
463
464
465	#ifdef MODULE
466	MODULE_LICENSE("GPL");
467
468	int init_module(void)
469	{
470	return 0;
471	}
472
473	void cleanup_module(void)
474	{}
475	#endif /* MODULE */
476
477
478	/*
479	* Visible symbols for modules
480	*/
481
482	EXPORT_SYMBOL(fbcon_splash16);
483	EXPORT_SYMBOL(fbcon_splash16_bmove);
484	EXPORT_SYMBOL(fbcon_splash16_clear);
485	EXPORT_SYMBOL(fbcon_splash16_putc);
486	EXPORT_SYMBOL(fbcon_splash16_putcs);
487	EXPORT_SYMBOL(fbcon_splash16_revc);
488	EXPORT_SYMBOL(fbcon_splash16_clear_margins);

Lines 74-83 Link Here

(-)linux-2.4.21/drivers/video/fbcon.c (-8 / +138 lines)
74	#include <linux/vt_kern.h>	74	#include <linux/vt_kern.h>
75	#include <linux/selection.h>	75	#include <linux/selection.h>
76	#include <linux/smp.h>	76	#include <linux/smp.h>
77	#include <linux/init.h>	77	#include <linux/init.h>
78	#include <linux/pm.h>	78	#include <linux/pm.h>
		79	#include <linux/vmalloc.h>
79		80
80	#include <asm/irq.h>	81	#include <asm/irq.h>
81	#include <asm/system.h>	82	#include <asm/system.h>
82	#include <asm/uaccess.h>	83	#include <asm/uaccess.h>
83	#ifdef CONFIG_AMIGA	84	#ifdef CONFIG_AMIGA
Lines 101-110 Link Here
101	#include <asm/linux_logo.h>	102	#include <asm/linux_logo.h>
102		103
103	#include <video/fbcon.h>	104	#include <video/fbcon.h>
104	#include <video/fbcon-mac.h> /* for 6x11 font on mac */	105	#include <video/fbcon-mac.h> /* for 6x11 font on mac */
105	#include <video/font.h>	106	#include <video/font.h>
		107	#ifdef CONFIG_FBCON_SPLASHSCREEN
		108	#include <video/fbcon-cfb16.h> /* for fbcon_cfb16 */
		109	#include "fbcon-splash.h"
		110
		111	extern void con_remap_def_color(int currcons, int new_color);
		112
		113	extern int splash_default;
		114	extern int splash_shown;
		115
		116	extern struct display_switch fbcon_splash16;
		117
		118	#ifdef CONFIG_PROC_FS
		119	int splash_proc_register(void);
		120	int splash_proc_unregister(void);
		121	#endif
		122	#endif
		123
106		124
107	#ifdef FBCONDEBUG	125	#ifdef FBCONDEBUG
108	# define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)	126	# define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
109	#else	127	#else
110	# define DPRINTK(fmt, args...)	128	# define DPRINTK(fmt, args...)
Lines 476-485 Link Here
476	#endif	494	#endif
477		495
478	return display_desc;	496	return display_desc;
479	}	497	}
480		498
		499	#ifdef CONFIG_FBCON_SPLASHSCREEN
		500	static int splash_registered=0;
		501	#endif
481		502
482	static void fbcon_init(struct vc_data *conp, int init)	503	static void fbcon_init(struct vc_data *conp, int init)
483	{	504	{
484	int unit = conp->vc_num;	505	int unit = conp->vc_num;
485	struct fb_info *info;	506	struct fb_info *info;
Lines 500-509 Link Here
500	fb_display[unit].cmap.len = 0;	521	fb_display[unit].cmap.len = 0;
501	fb_display[unit].cmap.red = 0;	522	fb_display[unit].cmap.red = 0;
502	fb_display[unit].cmap.green = 0;	523	fb_display[unit].cmap.green = 0;
503	fb_display[unit].cmap.blue = 0;	524	fb_display[unit].cmap.blue = 0;
504	fb_display[unit].cmap.transp = 0;	525	fb_display[unit].cmap.transp = 0;
		526
		527	#ifdef CONFIG_FBCON_SPLASHSCREEN
		528	if (!splash_registered && fb_display[unit].var.bits_per_pixel == 16 ) {
		529	if (unit == 0 && !fb_display[unit].splash_data) {
		530	extern unsigned long initrd_start, initrd_end;
		531
		532	if (initrd_start && !splash_getraw((unsigned char )initrd_start, (unsigned char )initrd_end) && fb_display[unit].splash_data)
		533	fb_display[unit].splash_data->splash_state = splash_default & 1;
		534	}
		535	splash_registered = 1;
		536	#ifdef CONFIG_PROC_FS
		537	splash_proc_register();
		538	#endif
		539	}
		540	if (fb_display[unit].splash_data && fb_display[unit].var.bits_per_pixel != 16 ) {
		541	vfree(fb_display[unit].splash_data);
		542	fb_display[unit].splash_data = 0;
		543	}
		544	#endif
		545
505	fbcon_setup(unit, init, !init);	546	fbcon_setup(unit, init, !init);
506	/* Must be done after fbcon_setup to prevent excess updates */	547	/* Must be done after fbcon_setup to prevent excess updates */
507	conp->vc_display_fg = &info->display_fg;	548	conp->vc_display_fg = &info->display_fg;
508	if (!info->display_fg)	549	if (!info->display_fg)
509	info->display_fg = conp;	550	info->display_fg = conp;
Lines 516-525 Link Here
516	struct display *p = &fb_display[unit];	557	struct display *p = &fb_display[unit];
517		558
518	fbcon_free_font(p);	559	fbcon_free_font(p);
519	p->dispsw = &fbcon_dummy;	560	p->dispsw = &fbcon_dummy;
520	p->conp = 0;	561	p->conp = 0;
		562	#ifdef CONFIG_FBCON_SPLASHSCREEN
		563	if (splash_registered) {
		564	#ifdef CONFIG_PROC_FS
		565	splash_proc_unregister();
		566	#endif
		567	splash_registered = 0;
		568	}
		569	#endif
521	}	570	}
522		571
523		572
524	static int fbcon_changevar(int con)	573	static int fbcon_changevar(int con)
525	{	574	{
Lines 656-666 Link Here
656	old_cols = conp->vc_cols;	705	old_cols = conp->vc_cols;
657	old_rows = conp->vc_rows;	706	old_rows = conp->vc_rows;
658		707
659	nr_cols = p->var.xres/fontwidth(p);	708	nr_cols = p->var.xres/fontwidth(p);
660	nr_rows = p->var.yres/fontheight(p);	709	nr_rows = p->var.yres/fontheight(p);
661		710	#ifdef CONFIG_FBCON_SPLASHSCREEN
		711	if (p->splash_data && p->splash_data->splash_state) {
		712	nr_cols = p->splash_data->splash_text_wi / fontwidth(p);
		713	nr_rows = p->splash_data->splash_text_he / fontheight(p);
		714	logo = 0;
		715	}
		716	#endif
		717
662	if (logo) {	718	if (logo) {
663	/* Need to make room for the logo */	719	/* Need to make room for the logo */
664	int cnt;	720	int cnt;
665	int step;	721	int step;
666		722
Lines 732-741 Link Here
732	"supported\n", p->type, p->type_aux, p->var.bits_per_pixel);	788	"supported\n", p->type, p->type_aux, p->var.bits_per_pixel);
733	p->dispsw->setup(p);	789	p->dispsw->setup(p);
734		790
735	p->fgcol = p->var.bits_per_pixel > 2 ? 7 : (1<<p->var.bits_per_pixel)-1;	791	p->fgcol = p->var.bits_per_pixel > 2 ? 7 : (1<<p->var.bits_per_pixel)-1;
736	p->bgcol = 0;	792	p->bgcol = 0;
		793	#ifdef CONFIG_FBCON_SPLASHSCREEN
		794	if(p->splash_data && p->splash_data->splash_state)
		795	con_remap_def_color(con, p->splash_data->splash_color << 4 \| p->splash_data->splash_fg_color);
		796	#endif
		797
737		798
738	if (!init) {	799	if (!init) {
739	if (conp->vc_cols != nr_cols \|\| conp->vc_rows != nr_rows)	800	if (conp->vc_cols != nr_cols \|\| conp->vc_rows != nr_rows)
740	vc_resize_con(nr_rows, nr_cols, con);	801	vc_resize_con(nr_rows, nr_cols, con);
741	else if (CON_IS_VISIBLE(conp) &&	802	else if (CON_IS_VISIBLE(conp) &&
Lines 1321-1330 Link Here
1321	if (count > conp->vc_rows) /* Maximum realistic size */	1382	if (count > conp->vc_rows) /* Maximum realistic size */
1322	count = conp->vc_rows;	1383	count = conp->vc_rows;
1323	if (softback_top)	1384	if (softback_top)
1324	fbcon_softback_note(conp, t, count);	1385	fbcon_softback_note(conp, t, count);
1325	if (logo_shown >= 0) goto redraw_up;	1386	if (logo_shown >= 0) goto redraw_up;
		1387	#ifdef CONFIG_FBCON_SPLASHSCREEN
		1388	if (splash_shown) goto redraw_up;
		1389	#endif
1326	switch (p->scrollmode & __SCROLL_YMASK) {	1390	switch (p->scrollmode & __SCROLL_YMASK) {
1327	case __SCROLL_YMOVE:	1391	case __SCROLL_YMOVE:
1328	p->dispsw->bmove(p, t+count, 0, t, 0, b-t-count,	1392	p->dispsw->bmove(p, t+count, 0, t, 0, b-t-count,
1329	conp->vc_cols);	1393	conp->vc_cols);
1330	p->dispsw->clear(conp, p, b-count, 0, count,	1394	p->dispsw->clear(conp, p, b-count, 0, count,
Lines 1381-1390 Link Here
1381	break;	1445	break;
1382		1446
1383	case SM_DOWN:	1447	case SM_DOWN:
1384	if (count > conp->vc_rows) /* Maximum realistic size */	1448	if (count > conp->vc_rows) /* Maximum realistic size */
1385	count = conp->vc_rows;	1449	count = conp->vc_rows;
		1450	#ifdef CONFIG_FBCON_SPLASHSCREEN
		1451	if (splash_shown) goto redraw_down;
		1452	#endif
1386	switch (p->scrollmode & __SCROLL_YMASK) {	1453	switch (p->scrollmode & __SCROLL_YMASK) {
1387	case __SCROLL_YMOVE:	1454	case __SCROLL_YMOVE:
1388	p->dispsw->bmove(p, t, 0, t+count, 0, b-t-count,	1455	p->dispsw->bmove(p, t, 0, t+count, 0, b-t-count,
1389	conp->vc_cols);	1456	conp->vc_cols);
1390	p->dispsw->clear(conp, p, t, 0,	1457	p->dispsw->clear(conp, p, t, 0,
Lines 1497-1515 Link Here
1497	fbcon_bmove_rec(p, sy+b, sx, dy+b, dx, height-b, width, y_break);	1564	fbcon_bmove_rec(p, sy+b, sx, dy+b, dx, height-b, width, y_break);
1498	fbcon_bmove_rec(p, sy, sx, dy, dx, b, width, y_break);	1565	fbcon_bmove_rec(p, sy, sx, dy, dx, b, width, y_break);
1499	}	1566	}
1500	return;	1567	return;
1501	}	1568	}
		1569	#ifdef CONFIG_FBCON_SPLASHSCREEN
		1570	if (splash_shown && sy == dy) {
		1571	/* must use slower redraw bmove to keep background pic intact */
		1572	fbcon_redraw_bmove(p, real_y(p, sy), sx, real_y(p, dy), dx, height, width);
		1573	return;
		1574	}
		1575	#endif
1502	p->dispsw->bmove(p, real_y(p, sy), sx, real_y(p, dy), dx, height, width);	1576	p->dispsw->bmove(p, real_y(p, sy), sx, real_y(p, dy), dx, height, width);
1503	}	1577	}
1504		1578
1505		1579
1506	static int fbcon_switch(struct vc_data *conp)	1580	static int fbcon_switch(struct vc_data *conp)
1507	{	1581	{
1508	int unit = conp->vc_num;	1582	int unit = conp->vc_num;
1509	struct display *p = &fb_display[unit];	1583	struct display *p = &fb_display[unit];
1510	struct fb_info *info = p->fb_info;	1584	struct fb_info *info = p->fb_info;
		1585	#ifdef CONFIG_FBCON_SPLASHSCREEN
		1586	splash_prepare(p);
		1587	#endif
1511		1588
1512	if (softback_top) {	1589	if (softback_top) {
1513	int l = fbcon_softback_size / conp->vc_size_row;	1590	int l = fbcon_softback_size / conp->vc_size_row;
1514	if (softback_lines)	1591	if (softback_lines)
1515	fbcon_set_origin(conp);	1592	fbcon_set_origin(conp);
Lines 1566-1604 Link Here
1566		1643
1567	static int fbcon_blank(struct vc_data *conp, int blank)	1644	static int fbcon_blank(struct vc_data *conp, int blank)
1568	{	1645	{
1569	struct display *p = &fb_display[conp->vc_num];	1646	struct display *p = &fb_display[conp->vc_num];
1570	struct fb_info *info = p->fb_info;	1647	struct fb_info *info = p->fb_info;
		1648	#ifdef CONFIG_FBCON_SPLASHSCREEN
		1649	struct display_switch *olddispsw=NULL;
		1650	char *oldscreen_base=NULL;
		1651	#endif
1571		1652
1572	if (blank < 0) /* Entering graphics mode */	1653	if (blank < 0) /* Entering graphics mode */
1573	return 0;	1654	return 0;
1574		1655
		1656	#ifdef CONFIG_FBCON_SPLASHSCREEN
		1657	if (p->splash_data && p->splash_data->oldscreen_base) {
		1658	oldscreen_base = p->screen_base;
		1659	p->screen_base = p->splash_data->oldscreen_base;
		1660	}
		1661	if (p->splash_data && p->splash_data->olddispsw) {
		1662	olddispsw = p->dispsw;
		1663	p->dispsw = p->splash_data->olddispsw;
		1664	}
		1665	#endif
		1666
1575	fbcon_cursor(p->conp, blank ? CM_ERASE : CM_DRAW);	1667	fbcon_cursor(p->conp, blank ? CM_ERASE : CM_DRAW);
1576		1668
1577	if (!p->can_soft_blank) {	1669	if (!p->can_soft_blank) {
1578	if (blank) {	1670	if (blank) {
		1671	#ifdef CONFIG_FBCON_SPLASHSCREEN
		1672	if (p->splash_data && p->splash_data->oldscreen_base) {
		1673	oldscreen_base = p->screen_base;
		1674	p->screen_base = p->splash_data->oldscreen_base;
		1675	}
		1676	if (p->splash_data && p->splash_data->olddispsw) {
		1677	olddispsw = p->dispsw;
		1678	p->dispsw = p->splash_data->olddispsw;
		1679	}
		1680	#endif
		1681
1579	if (p->visual == FB_VISUAL_MONO01) {	1682	if (p->visual == FB_VISUAL_MONO01) {
1580	if (p->screen_base)	1683	if (p->screen_base)
1581	fb_memset255(p->screen_base,	1684	fb_memset255(p->screen_base,
1582	p->var.xres_virtualp->var.yres_virtual	1685	p->var.xres_virtualp->var.yres_virtual
1583	p->var.bits_per_pixel>>3);	1686	p->var.bits_per_pixel>>3);
1584	} else {	1687	} else {
1585	unsigned short oldc;	1688	unsigned short oldc;
1586	u_int height;	1689	u_int height;
		1690	u_int width;
1587	u_int y_break;	1691	u_int y_break;
1588		1692
1589	oldc = conp->vc_video_erase_char;	1693	oldc = conp->vc_video_erase_char;
1590	conp->vc_video_erase_char &= p->charmask;	1694	conp->vc_video_erase_char &= p->charmask;
1591	height = conp->vc_rows;	1695	height = conp->vc_rows;
1592	y_break = p->vrows-p->yscroll;	1696	width = conp->vc_cols;
		1697	y_break = p->vrows-p->yscroll;
		1698	#ifdef CONFIG_FBCON_SPLASHSCREEN
		1699	if (splash_shown) {
		1700	width=p->var.xres/fontwidth(p);
		1701	height=p->var.yres/fontheight(p);
		1702	}
		1703	#endif
1593	if (height > y_break) {	1704	if (height > y_break) {
1594	p->dispsw->clear(conp, p, real_y(p, 0), 0, y_break, conp->vc_cols);	1705	p->dispsw->clear(conp, p, real_y(p, 0), 0, y_break, width);
1595	p->dispsw->clear(conp, p, real_y(p, y_break), 0, height-y_break, conp->vc_cols);	1706	p->dispsw->clear(conp, p, real_y(p, y_break), 0, height-y_break, width);
1596	} else	1707	} else
1597	p->dispsw->clear(conp, p, real_y(p, 0), 0, height, conp->vc_cols);	1708	p->dispsw->clear(conp, p, real_y(p, 0), 0, height, width);
1598	conp->vc_video_erase_char = oldc;	1709	conp->vc_video_erase_char = oldc;
1599	}	1710	}
		1711	#ifdef CONFIG_FBCON_SPLASHSCREEN
		1712	if(oldscreen_base)
		1713	p->screen_base=oldscreen_base;
		1714	if(olddispsw)
		1715	p->dispsw=olddispsw;
		1716	#endif
1600	return 0;	1717	return 0;
1601	} else {	1718	} else {
1602	/* Tell console.c that it has to restore the screen itself */	1719	/* Tell console.c that it has to restore the screen itself */
1603	return 1;	1720	return 1;
1604	}	1721	}
Lines 1760-1776 Link Here
1760	}	1877	}
1761	fbcon_font_widths(p);	1878	fbcon_font_widths(p);
1762		1879
1763	if (resize) {	1880	if (resize) {
1764	struct vc_data *conp = p->conp;	1881	struct vc_data *conp = p->conp;
		1882	__u32 xres = p->var.xres, yres = p->var.yres;
1765	/* reset wrap/pan */	1883	/* reset wrap/pan */
1766	p->var.xoffset = p->var.yoffset = p->yscroll = 0;	1884	p->var.xoffset = p->var.yoffset = p->yscroll = 0;
1767	p->vrows = p->var.yres_virtual/h;	1885	p->vrows = p->var.yres_virtual/h;
1768	if ((p->var.yres % h) && (p->var.yres_virtual % h < p->var.yres % h))	1886	#ifdef CONFIG_FBCON_SPLASHSCREEN
		1887	if (p->splash_data && p->splash_data->splash_state) {
		1888	xres = p->splash_data->splash_text_wi;
		1889	yres = p->splash_data->splash_text_he;
		1890	}
		1891	#endif
		1892	if ((yres % h) && (p->var.yres_virtual % h < p->var.yres % h))
1769	p->vrows--;	1893	p->vrows--;
1770	updatescrollmode(p);	1894	updatescrollmode(p);
1771	vc_resize_con( p->var.yres/h, p->var.xres/w, unit );	1895	vc_resize_con( yres/h, xres/w, unit );
1772	if (CON_IS_VISIBLE(conp) && softback_buf) {	1896	if (CON_IS_VISIBLE(conp) && softback_buf) {
1773	int l = fbcon_softback_size / conp->vc_size_row;	1897	int l = fbcon_softback_size / conp->vc_size_row;
1774	if (l > 5)	1898	if (l > 5)
1775	softback_end = softback_buf + l * conp->vc_size_row;	1899	softback_end = softback_buf + l * conp->vc_size_row;
1776	else {	1900	else {
Lines 2186-2195 Link Here
2186	logo_depth = 1;	2310	logo_depth = 1;
2187	}	2311	}
2188		2312
2189	if (p->fb_info->fbops->fb_rasterimg)	2313	if (p->fb_info->fbops->fb_rasterimg)
2190	p->fb_info->fbops->fb_rasterimg(p->fb_info, 1);	2314	p->fb_info->fbops->fb_rasterimg(p->fb_info, 1);
		2315	#ifdef CONFIG_FBCON_SPLASHSCREEN
		2316	if (!splash_shown) {
		2317	#endif
2191		2318
2192	for (x = 0; x < smp_num_cpus * (LOGO_W + 8) &&	2319	for (x = 0; x < smp_num_cpus * (LOGO_W + 8) &&
2193	x < p->var.xres - (LOGO_W + 8); x += (LOGO_W + 8)) {	2320	x < p->var.xres - (LOGO_W + 8); x += (LOGO_W + 8)) {
2194		2321
2195	#if defined(CONFIG_FBCON_CFB16) \|\| defined(CONFIG_FBCON_CFB24) \|\| \	2322	#if defined(CONFIG_FBCON_CFB16) \|\| defined(CONFIG_FBCON_CFB24) \|\| \
Lines 2448-2458 Link Here
2448	}	2575	}
2449	done = 1;	2576	done = 1;
2450	}	2577	}
2451	#endif	2578	#endif
2452	}	2579	}
2453		2580	#ifdef CONFIG_FBCON_SPLASHSCREEN
		2581	}
		2582	#endif
		2583
2454	if (p->fb_info->fbops->fb_rasterimg)	2584	if (p->fb_info->fbops->fb_rasterimg)
2455	p->fb_info->fbops->fb_rasterimg(p->fb_info, 0);	2585	p->fb_info->fbops->fb_rasterimg(p->fb_info, 0);
2456		2586
2457	/* Modes not yet supported: packed pixels with depth != 8 (does such a	2587	/* Modes not yet supported: packed pixels with depth != 8 (does such a
2458	* thing exist in reality?) */	2588	* thing exist in reality?) */

Lines 40-49 Link Here

(-)linux-2.4.21/include/video/fbcon.h (+33 lines)
40	void (clear_margins)(struct vc_data conp, struct display *p,	40	void (clear_margins)(struct vc_data conp, struct display *p,
41	int bottom_only);	41	int bottom_only);
42	unsigned int fontwidthmask; /* 1 at (1 << (width - 1)) if width is supported */	42	unsigned int fontwidthmask; /* 1 at (1 << (width - 1)) if width is supported */
43	};	43	};
44		44
		45	#ifdef CONFIG_FBCON_SPLASHSCREEN
		46	struct splash_data {
		47	int splash_state; /* show splash? */
		48	int splash_color; /* transparent color */
		49	int splash_fg_color; /* foreground color */
		50	int splash_width; /* width of image */
		51	int splash_height; /* height of image */
		52	int splash_text_xo; /* text area origin */
		53	int splash_text_yo;
		54	int splash_text_wi; /* text area size */
		55	int splash_text_he;
		56	int splash_showtext; /* silent/verbose mode */
		57	int splash_boxcount;
		58	int splash_percent;
		59	int splash_overpaintok; /* is it ok to overpaint boxes */
		60	int splash_palcnt;
		61	struct display_switch olddispsw; / old dispsw, normally &fbcon_cfb16*/
		62	char oldscreen_base; / pointer to top of virtual screen */
		63	unsigned char *splash_boxes;
		64	unsigned char splash_jpeg; / jpeg */
		65	unsigned char splash_palette; / palette for 8-bit */
		66
		67	int splash_dosilent; /* show silent jpeg */
		68	unsigned char *splash_silentjpeg;
		69	unsigned char *splash_sboxes;
		70	int splash_sboxcount;
		71	};
		72	#endif
		73
45	extern struct display_switch fbcon_dummy;	74	extern struct display_switch fbcon_dummy;
46		75
47	/*	76	/*
48	* This is the interface between the low-level console driver and the	77	* This is the interface between the low-level console driver and the
49	* low-level frame buffer device	78	* low-level frame buffer device
Lines 93-102 Link Here
93	int userfont; /* != 0 if fontdata kmalloc()ed */	122	int userfont; /* != 0 if fontdata kmalloc()ed */
94	u_short scrollmode; /* Scroll Method */	123	u_short scrollmode; /* Scroll Method */
95	short yscroll; /* Hardware scrolling */	124	short yscroll; /* Hardware scrolling */
96	unsigned char fgshift, bgshift;	125	unsigned char fgshift, bgshift;
97	unsigned short charmask; /* 0xff or 0x1ff */	126	unsigned short charmask; /* 0xff or 0x1ff */
		127	#ifdef CONFIG_FBCON_SPLASHSCREEN
		128	struct splash_data *splash_data;
		129	#endif
		130
98	};	131	};
99		132
100	/* drivers/video/fbcon.c */	133	/* drivers/video/fbcon.c */
101	extern struct display fb_display[MAX_NR_CONSOLES];	134	extern struct display fb_display[MAX_NR_CONSOLES];
102	extern char con2fb_map[MAX_NR_CONSOLES];	135	extern char con2fb_map[MAX_NR_CONSOLES];