[deliverable/linux.git] / arch / x86 / boot / a20.c

/* -*- linux-c -*- ------------------------------------------------------- *
 *
 *   Copyright (C) 1991, 1992 Linus Torvalds
 *   Copyright 2007-2008 rPath, Inc. - All Rights Reserved
 *   Copyright 2009 Intel Corporation
 *
 *   This file is part of the Linux kernel, and is made available under
 *   the terms of the GNU General Public License version 2.
 *
 * ----------------------------------------------------------------------- */

/*
 * Enable A20 gate (return -1 on failure)
 */

#include "boot.h"

#define MAX_8042_LOOPS	100000
#define MAX_8042_FF	32

static int empty_8042(void)
{
	u8 status;
	int loops = MAX_8042_LOOPS;
	int ffs   = MAX_8042_FF;

	while (loops--) {
		io_delay();

		status = inb(0x64);
		if (status == 0xff) {
			/* FF is a plausible, but very unlikely status */
			if (!--ffs)
				return -1; /* Assume no KBC present */
		}
		if (status & 1) {
			/* Read and discard input data */
			io_delay();
			(void)inb(0x60);
		} else if (!(status & 2)) {
			/* Buffers empty, finished! */
			return 0;
		}
	}

	return -1;
}

/* Returns nonzero if the A20 line is enabled.  The memory address
   used as a test is the int $0x80 vector, which should be safe. */

#define A20_TEST_ADDR	(4*0x80)
#define A20_TEST_SHORT  32
#define A20_TEST_LONG	2097152	/* 2^21 */

static int a20_test(int loops)
{
	int ok = 0;
	int saved, ctr;

	set_fs(0x0000);
	set_gs(0xffff);

	saved = ctr = rdfs32(A20_TEST_ADDR);

	while (loops--) {
		wrfs32(++ctr, A20_TEST_ADDR);
		io_delay();	/* Serialize and make delay constant */
		ok = rdgs32(A20_TEST_ADDR+0x10) ^ ctr;
		if (ok)
			break;
	}

	wrfs32(saved, A20_TEST_ADDR);
	return ok;
}

/* Quick test to see if A20 is already enabled */
static int a20_test_short(void)
{
	return a20_test(A20_TEST_SHORT);
}

/* Longer test that actually waits for A20 to come on line; this
   is useful when dealing with the KBC or other slow external circuitry. */
static int a20_test_long(void)
{
	return a20_test(A20_TEST_LONG);
}

static void enable_a20_bios(void)
{
	asm volatile("pushfl; int $0x15; popfl"
		     : : "a" ((u16)0x2401));
}

static void enable_a20_kbc(void)
{
	empty_8042();

	outb(0xd1, 0x64);	/* Command write */
	empty_8042();

	outb(0xdf, 0x60);	/* A20 on */
	empty_8042();

	outb(0xff, 0x64);	/* Null command, but UHCI wants it */
	empty_8042();
}

static void enable_a20_fast(void)
{
	u8 port_a;

	port_a = inb(0x92);	/* Configuration port A */
	port_a |=  0x02;	/* Enable A20 */
	port_a &= ~0x01;	/* Do not reset machine */
	outb(port_a, 0x92);
}

/*
 * Actual routine to enable A20; return 0 on ok, -1 on failure
 */

#define A20_ENABLE_LOOPS 255	/* Number of times to try */

int enable_a20(void)
{
       int loops = A20_ENABLE_LOOPS;
       int kbc_err;

       while (loops--) {
	       /* First, check to see if A20 is already enabled
		  (legacy free, etc.) */
	       if (a20_test_short())
		       return 0;
	       
	       /* Next, try the BIOS (INT 0x15, AX=0x2401) */
	       enable_a20_bios();
	       if (a20_test_short())
		       return 0;
	       
	       /* Try enabling A20 through the keyboard controller */
	       kbc_err = empty_8042();

	       if (a20_test_short())
		       return 0; /* BIOS worked, but with delayed reaction */
	
	       if (!kbc_err) {
		       enable_a20_kbc();
		       if (a20_test_long())
			       return 0;
	       }
	       
	       /* Finally, try enabling the "fast A20 gate" */
	       enable_a20_fast();
	       if (a20_test_long())
		       return 0;
       }
       
       return -1;
}
Commit	Line	Data
5a8a8128 PA	1	/* -- linux-c -- ------------------------------------------------------- *
	2	*
	3	* Copyright (C) 1991, 1992 Linus Torvalds
aa60d13f	4	* Copyright 2007-2008 rPath, Inc. - All Rights Reserved
3bd323a1	5	* Copyright 2009 Intel Corporation
5a8a8128 PA	6	*
	7	* This file is part of the Linux kernel, and is made available under
	8	* the terms of the GNU General Public License version 2.
	9	*
	10	* ----------------------------------------------------------------------- */
	11
	12	/*
5a8a8128 PA	13	* Enable A20 gate (return -1 on failure)
	14	*/
	15
	16	#include "boot.h"
	17
	18	#define MAX_8042_LOOPS 100000
3bd323a1	19	#define MAX_8042_FF 32
5a8a8128 PA	20
	21	static int empty_8042(void)
	22	{
	23	u8 status;
	24	int loops = MAX_8042_LOOPS;
3bd323a1	25	int ffs = MAX_8042_FF;
5a8a8128 PA	26
	27	while (loops--) {
	28	io_delay();
	29
	30	status = inb(0x64);
3bd323a1 PA	31	if (status == 0xff) {
	32	/* FF is a plausible, but very unlikely status */
	33	if (!--ffs)
	34	return -1; /* Assume no KBC present */
	35	}
5a8a8128 PA	36	if (status & 1) {
	37	/* Read and discard input data */
	38	io_delay();
	39	(void)inb(0x60);
	40	} else if (!(status & 2)) {
	41	/* Buffers empty, finished! */
	42	return 0;
	43	}
	44	}
	45
	46	return -1;
	47	}
	48
	49	/* Returns nonzero if the A20 line is enabled. The memory address
	50	used as a test is the int $0x80 vector, which should be safe. */
	51
	52	#define A20_TEST_ADDR (4*0x80)
	53	#define A20_TEST_SHORT 32
	54	#define A20_TEST_LONG 2097152 /* 2^21 */
	55
	56	static int a20_test(int loops)
	57	{
	58	int ok = 0;
	59	int saved, ctr;
	60
	61	set_fs(0x0000);
	62	set_gs(0xffff);
	63
	64	saved = ctr = rdfs32(A20_TEST_ADDR);
	65
	66	while (loops--) {
	67	wrfs32(++ctr, A20_TEST_ADDR);
	68	io_delay(); /* Serialize and make delay constant */
	69	ok = rdgs32(A20_TEST_ADDR+0x10) ^ ctr;
	70	if (ok)
	71	break;
	72	}
	73
	74	wrfs32(saved, A20_TEST_ADDR);
	75	return ok;
	76	}
	77
	78	/* Quick test to see if A20 is already enabled */
	79	static int a20_test_short(void)
	80	{
	81	return a20_test(A20_TEST_SHORT);
	82	}
	83
	84	/* Longer test that actually waits for A20 to come on line; this
	85	is useful when dealing with the KBC or other slow external circuitry. */
	86	static int a20_test_long(void)
	87	{
	88	return a20_test(A20_TEST_LONG);
	89	}
	90
	91	static void enable_a20_bios(void)
	92	{
	93	asm volatile("pushfl; int $0x15; popfl"
	94	: : "a" ((u16)0x2401));
	95	}
	96
	97	static void enable_a20_kbc(void)
	98	{
	99	empty_8042();
100
101	outb(0xd1, 0x64); /* Command write */
102	empty_8042();
103
104	outb(0xdf, 0x60); /* A20 on */
105	empty_8042();
aa60d13f PA	106
	107	outb(0xff, 0x64); /* Null command, but UHCI wants it */
	108	empty_8042();
5a8a8128 PA	109	}
	110
	111	static void enable_a20_fast(void)
	112	{
	113	u8 port_a;
	114
	115	port_a = inb(0x92); /* Configuration port A */
	116	port_a \|= 0x02; /* Enable A20 */
	117	port_a &= ~0x01; /* Do not reset machine */
	118	outb(port_a, 0x92);
	119	}
	120
	121	/*
	122	* Actual routine to enable A20; return 0 on ok, -1 on failure
	123	*/
	124
	125	#define A20_ENABLE_LOOPS 255 /* Number of times to try */
	126
	127	int enable_a20(void)
	128	{
52aaa12f	129	int loops = A20_ENABLE_LOOPS;
3bd323a1 PA	130	int kbc_err;
	131
	132	while (loops--) {
	133	/* First, check to see if A20 is already enabled
	134	(legacy free, etc.) */
	135	if (a20_test_short())
	136	return 0;
	137
	138	/* Next, try the BIOS (INT 0x15, AX=0x2401) */
	139	enable_a20_bios();
	140	if (a20_test_short())
	141	return 0;
	142
	143	/* Try enabling A20 through the keyboard controller */
	144	kbc_err = empty_8042();
	145
	146	if (a20_test_short())
	147	return 0; /* BIOS worked, but with delayed reaction */
	148
	149	if (!kbc_err) {
	150	enable_a20_kbc();
	151	if (a20_test_long())
	152	return 0;
	153	}
	154
	155	/* Finally, try enabling the "fast A20 gate" */
	156	enable_a20_fast();
	157	if (a20_test_long())
	158	return 0;
	159	}
	160
	161	return -1;
5a8a8128	162	}