[net-next-2.6.git] / arch / i386 / mach-voyager / voyager_basic.c

/* Copyright (C) 1999,2001 
 *
 * Author: J.E.J.Bottomley@HansenPartnership.com
 *
 * linux/arch/i386/kernel/voyager.c
 *
 * This file contains all the voyager specific routines for getting
 * initialisation of the architecture to function.  For additional
 * features see:
 *
 *	voyager_cat.c - Voyager CAT bus interface
 *	voyager_smp.c - Voyager SMP hal (emulates linux smp.c)
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/reboot.h>
#include <linux/sysrq.h>
#include <asm/io.h>
#include <asm/voyager.h>
#include <asm/vic.h>
#include <linux/pm.h>
#include <linux/irq.h>
#include <asm/tlbflush.h>
#include <asm/arch_hooks.h>
#include <asm/i8253.h>

/*
 * Power off function, if any
 */
void (*pm_power_off)(void);
EXPORT_SYMBOL(pm_power_off);

int voyager_level = 0;

struct voyager_SUS *voyager_SUS = NULL;

#ifdef CONFIG_SMP
static void
voyager_dump(int dummy1, struct pt_regs *dummy2, struct tty_struct *dummy3)
{
	/* get here via a sysrq */
	voyager_smp_dump();
}

static struct sysrq_key_op sysrq_voyager_dump_op = {
	.handler	= voyager_dump,
	.help_msg	= "Voyager",
	.action_msg	= "Dump Voyager Status",
};
#endif

void
voyager_detect(struct voyager_bios_info *bios)
{
	if(bios->len != 0xff) {
		int class = (bios->class_1 << 8) 
			| (bios->class_2 & 0xff);

		printk("Voyager System detected.\n"
		       "        Class %x, Revision %d.%d\n",
		       class, bios->major, bios->minor);
		if(class == VOYAGER_LEVEL4) 
			voyager_level = 4;
		else if(class < VOYAGER_LEVEL5_AND_ABOVE)
			voyager_level = 3;
		else
			voyager_level = 5;
		printk("        Architecture Level %d\n", voyager_level);
		if(voyager_level < 4)
			printk("\n**WARNING**: Voyager HAL only supports Levels 4 and 5 Architectures at the moment\n\n");
		/* install the power off handler */
		pm_power_off = voyager_power_off;
#ifdef CONFIG_SMP
		register_sysrq_key('v', &sysrq_voyager_dump_op);
#endif
	} else {
		printk("\n\n**WARNING**: No Voyager Subsystem Found\n");
	}
}

void
voyager_system_interrupt(int cpl, void *dev_id, struct pt_regs *regs)
{
	printk("Voyager: detected system interrupt\n");
}

/* Routine to read information from the extended CMOS area */
__u8
voyager_extended_cmos_read(__u16 addr)
{
	outb(addr & 0xff, 0x74);
	outb((addr >> 8) & 0xff, 0x75);
	return inb(0x76);
}

/* internal definitions for the SUS Click Map of memory */

#define CLICK_ENTRIES	16
#define CLICK_SIZE	4096	/* click to byte conversion for Length */

typedef struct ClickMap {
	struct Entry {
		__u32	Address;
		__u32	Length;
	} Entry[CLICK_ENTRIES];
} ClickMap_t;


/* This routine is pretty much an awful hack to read the bios clickmap by
 * mapping it into page 0.  There are usually three regions in the map:
 * 	Base Memory
 * 	Extended Memory
 *	zero length marker for end of map
 *
 * Returns are 0 for failure and 1 for success on extracting region.
 */
int __init
voyager_memory_detect(int region, __u32 *start, __u32 *length)
{
	int i;
	int retval = 0;
	__u8 cmos[4];
	ClickMap_t *map;
	unsigned long map_addr;
	unsigned long old;

	if(region >= CLICK_ENTRIES) {
		printk("Voyager: Illegal ClickMap region %d\n", region);
		return 0;
	}

	for(i = 0; i < sizeof(cmos); i++)
		cmos[i] = voyager_extended_cmos_read(VOYAGER_MEMORY_CLICKMAP + i);

	map_addr = *(unsigned long *)cmos;

	/* steal page 0 for this */
	old = pg0[0];
	pg0[0] = ((map_addr & PAGE_MASK) | _PAGE_RW | _PAGE_PRESENT);
	local_flush_tlb();
	/* now clear everything out but page 0 */
	map = (ClickMap_t *)(map_addr & (~PAGE_MASK));

	/* zero length is the end of the clickmap */
	if(map->Entry[region].Length != 0) {
		*length = map->Entry[region].Length * CLICK_SIZE;
		*start = map->Entry[region].Address;
		retval = 1;
	}

	/* replace the mapping */
	pg0[0] = old;
	local_flush_tlb();
	return retval;
}

/* voyager specific handling code for timer interrupts.  Used to hand
 * off the timer tick to the SMP code, since the VIC doesn't have an
 * internal timer (The QIC does, but that's another story). */
void
voyager_timer_interrupt(struct pt_regs *regs)
{
	if((jiffies & 0x3ff) == 0) {

		/* There seems to be something flaky in either
		 * hardware or software that is resetting the timer 0
		 * count to something much higher than it should be
		 * This seems to occur in the boot sequence, just
		 * before root is mounted.  Therefore, every 10
		 * seconds or so, we sanity check the timer zero count
		 * and kick it back to where it should be.
		 *
		 * FIXME: This is the most awful hack yet seen.  I
		 * should work out exactly what is interfering with
		 * the timer count settings early in the boot sequence
		 * and swiftly introduce it to something sharp and
		 * pointy.  */
		__u16 val;

		spin_lock(&i8253_lock);
		
		outb_p(0x00, 0x43);
		val = inb_p(0x40);
		val |= inb(0x40) << 8;
		spin_unlock(&i8253_lock);

		if(val > LATCH) {
			printk("\nVOYAGER: countdown timer value too high (%d), resetting\n\n", val);
			spin_lock(&i8253_lock);
			outb(0x34,0x43);
			outb_p(LATCH & 0xff , 0x40);	/* LSB */
			outb(LATCH >> 8 , 0x40);	/* MSB */
			spin_unlock(&i8253_lock);
		}
	}
#ifdef CONFIG_SMP
	smp_vic_timer_interrupt(regs);
#endif
}

void
voyager_power_off(void)
{
	printk("VOYAGER Power Off\n");

	if(voyager_level == 5) {
		voyager_cat_power_off();
	} else if(voyager_level == 4) {
		/* This doesn't apparently work on most L4 machines,
		 * but the specs say to do this to get automatic power
		 * off.  Unfortunately, if it doesn't power off the
		 * machine, it ends up doing a cold restart, which
		 * isn't really intended, so comment out the code */
#if 0
		int port;

	  
		/* enable the voyager Configuration Space */
		outb((inb(VOYAGER_MC_SETUP) & 0xf0) | 0x8, 
		     VOYAGER_MC_SETUP);
		/* the port for the power off flag is an offset from the
		   floating base */
		port = (inb(VOYAGER_SSPB_RELOCATION_PORT) << 8) + 0x21;
		/* set the power off flag */
		outb(inb(port) | 0x1, port);
#endif
	}
	/* and wait for it to happen */
	local_irq_disable();
	for(;;)
		halt();
}

/* copied from process.c */
static inline void
kb_wait(void)
{
	int i;

	for (i=0; i<0x10000; i++)
		if ((inb_p(0x64) & 0x02) == 0)
			break;
}

void
machine_shutdown(void)
{
	/* Architecture specific shutdown needed before a kexec */
}

void
machine_restart(char *cmd)
{
	printk("Voyager Warm Restart\n");
	kb_wait();

	if(voyager_level == 5) {
		/* write magic values to the RTC to inform system that
		 * shutdown is beginning */
		outb(0x8f, 0x70);
		outb(0x5 , 0x71);
		
		udelay(50);
		outb(0xfe,0x64);         /* pull reset low */
	} else if(voyager_level == 4) {
		__u16 catbase = inb(VOYAGER_SSPB_RELOCATION_PORT)<<8;
		__u8 basebd = inb(VOYAGER_MC_SETUP);
		
		outb(basebd | 0x08, VOYAGER_MC_SETUP);
		outb(0x02, catbase + 0x21);
	}
	local_irq_disable();
	for(;;)
		halt();
}

void
machine_emergency_restart(void)
{
	/*for now, just hook this to a warm restart */
	machine_restart(NULL);
}

void
mca_nmi_hook(void)
{
	__u8 dumpval __attribute__((unused)) = inb(0xf823);
	__u8 swnmi __attribute__((unused)) = inb(0xf813);

	/* FIXME: assume dump switch pressed */
	/* check to see if the dump switch was pressed */
	VDEBUG(("VOYAGER: dumpval = 0x%x, swnmi = 0x%x\n", dumpval, swnmi));
	/* clear swnmi */
	outb(0xff, 0xf813);
	/* tell SUS to ignore dump */
	if(voyager_level == 5 && voyager_SUS != NULL) {
		if(voyager_SUS->SUS_mbox == VOYAGER_DUMP_BUTTON_NMI) {
			voyager_SUS->kernel_mbox = VOYAGER_NO_COMMAND;
			voyager_SUS->kernel_flags |= VOYAGER_OS_IN_PROGRESS;
			udelay(1000);
			voyager_SUS->kernel_mbox = VOYAGER_IGNORE_DUMP;
			voyager_SUS->kernel_flags &= ~VOYAGER_OS_IN_PROGRESS;
		}
	}
	printk(KERN_ERR "VOYAGER: Dump switch pressed, printing CPU%d tracebacks\n", smp_processor_id());
	show_stack(NULL, NULL);
	show_state();
}


void
machine_halt(void)
{
	/* treat a halt like a power off */
	machine_power_off();
}

void machine_power_off(void)
{
	if (pm_power_off)
		pm_power_off();
}
Commit	Line	Data
1da177e4 LT	1	/* Copyright (C) 1999,2001
	2	*
	3	* Author: J.E.J.Bottomley@HansenPartnership.com
	4	*
	5	* linux/arch/i386/kernel/voyager.c
	6	*
	7	* This file contains all the voyager specific routines for getting
	8	* initialisation of the architecture to function. For additional
	9	* features see:
	10	*
	11	* voyager_cat.c - Voyager CAT bus interface
	12	* voyager_smp.c - Voyager SMP hal (emulates linux smp.c)
	13	*/
	14
	15	#include <linux/config.h>
	16	#include <linux/module.h>
	17	#include <linux/types.h>
	18	#include <linux/sched.h>
	19	#include <linux/ptrace.h>
	20	#include <linux/ioport.h>
	21	#include <linux/interrupt.h>
	22	#include <linux/init.h>
	23	#include <linux/delay.h>
	24	#include <linux/reboot.h>
	25	#include <linux/sysrq.h>
	26	#include <asm/io.h>
	27	#include <asm/voyager.h>
	28	#include <asm/vic.h>
	29	#include <linux/pm.h>
	30	#include <linux/irq.h>
	31	#include <asm/tlbflush.h>
	32	#include <asm/arch_hooks.h>
306e440d	33	#include <asm/i8253.h>
1da177e4 LT	34
	35	/*
	36	* Power off function, if any
	37	*/
	38	void (*pm_power_off)(void);
153f8057	39	EXPORT_SYMBOL(pm_power_off);
1da177e4 LT	40
	41	int voyager_level = 0;
	42
	43	struct voyager_SUS *voyager_SUS = NULL;
	44
	45	#ifdef CONFIG_SMP
	46	static void
	47	voyager_dump(int dummy1, struct pt_regs dummy2, struct tty_struct dummy3)
	48	{
	49	/* get here via a sysrq */
	50	voyager_smp_dump();
	51	}
	52
	53	static struct sysrq_key_op sysrq_voyager_dump_op = {
	54	.handler = voyager_dump,
	55	.help_msg = "Voyager",
	56	.action_msg = "Dump Voyager Status",
	57	};
	58	#endif
	59
	60	void
	61	voyager_detect(struct voyager_bios_info *bios)
	62	{
	63	if(bios->len != 0xff) {
	64	int class = (bios->class_1 << 8)
	65	\| (bios->class_2 & 0xff);
	66
	67	printk("Voyager System detected.\n"
	68	" Class %x, Revision %d.%d\n",
	69	class, bios->major, bios->minor);
	70	if(class == VOYAGER_LEVEL4)
	71	voyager_level = 4;
	72	else if(class < VOYAGER_LEVEL5_AND_ABOVE)
	73	voyager_level = 3;
	74	else
	75	voyager_level = 5;
	76	printk(" Architecture Level %d\n", voyager_level);
	77	if(voyager_level < 4)
	78	printk("\nWARNING: Voyager HAL only supports Levels 4 and 5 Architectures at the moment\n\n");
	79	/* install the power off handler */
	80	pm_power_off = voyager_power_off;
	81	#ifdef CONFIG_SMP
	82	register_sysrq_key('v', &sysrq_voyager_dump_op);
	83	#endif
	84	} else {
	85	printk("\n\nWARNING: No Voyager Subsystem Found\n");
	86	}
	87	}
	88
	89	void
	90	voyager_system_interrupt(int cpl, void dev_id, struct pt_regs regs)
	91	{
	92	printk("Voyager: detected system interrupt\n");
	93	}
	94
	95	/* Routine to read information from the extended CMOS area */
	96	__u8
	97	voyager_extended_cmos_read(__u16 addr)
	98	{
	99	outb(addr & 0xff, 0x74);
	100	outb((addr >> 8) & 0xff, 0x75);
	101	return inb(0x76);
	102	}
	103
104	/* internal definitions for the SUS Click Map of memory */
105
106	#define CLICK_ENTRIES 16
107	#define CLICK_SIZE 4096 /* click to byte conversion for Length */
108
109	typedef struct ClickMap {
110	struct Entry {
111	__u32 Address;
112	__u32 Length;
113	} Entry[CLICK_ENTRIES];
114	} ClickMap_t;
115
116
117	/* This routine is pretty much an awful hack to read the bios clickmap by
118	* mapping it into page 0. There are usually three regions in the map:
119	* Base Memory
120	* Extended Memory
121	* zero length marker for end of map
122	*
123	* Returns are 0 for failure and 1 for success on extracting region.
124	*/
125	int __init
126	voyager_memory_detect(int region, __u32 start, __u32 length)
127	{
128	int i;
129	int retval = 0;
130	__u8 cmos[4];
131	ClickMap_t *map;
132	unsigned long map_addr;
133	unsigned long old;
134
135	if(region >= CLICK_ENTRIES) {
136	printk("Voyager: Illegal ClickMap region %d\n", region);
137	return 0;
138	}
139
140	for(i = 0; i < sizeof(cmos); i++)
141	cmos[i] = voyager_extended_cmos_read(VOYAGER_MEMORY_CLICKMAP + i);
142
143	map_addr = (unsigned long )cmos;
144
145	/* steal page 0 for this */
146	old = pg0[0];
147	pg0[0] = ((map_addr & PAGE_MASK) \| _PAGE_RW \| _PAGE_PRESENT);
148	local_flush_tlb();
149	/* now clear everything out but page 0 */
150	map = (ClickMap_t *)(map_addr & (~PAGE_MASK));
151
152	/* zero length is the end of the clickmap */
153	if(map->Entry[region].Length != 0) {
154	length = map->Entry[region].Length CLICK_SIZE;
155	*start = map->Entry[region].Address;
156	retval = 1;
157	}
158
159	/* replace the mapping */
160	pg0[0] = old;
161	local_flush_tlb();
162	return retval;
163	}
164
165	/* voyager specific handling code for timer interrupts. Used to hand
166	* off the timer tick to the SMP code, since the VIC doesn't have an
167	* internal timer (The QIC does, but that's another story). */
168	void
169	voyager_timer_interrupt(struct pt_regs *regs)
170	{
171	if((jiffies & 0x3ff) == 0) {
172
173	/* There seems to be something flaky in either
174	* hardware or software that is resetting the timer 0
175	* count to something much higher than it should be
176	* This seems to occur in the boot sequence, just
177	* before root is mounted. Therefore, every 10
178	* seconds or so, we sanity check the timer zero count
179	* and kick it back to where it should be.
180	*
181	* FIXME: This is the most awful hack yet seen. I
182	* should work out exactly what is interfering with
183	* the timer count settings early in the boot sequence
184	* and swiftly introduce it to something sharp and
185	* pointy. */
186	__u16 val;
1da177e4 LT	187
	188	spin_lock(&i8253_lock);
	189
	190	outb_p(0x00, 0x43);
	191	val = inb_p(0x40);
	192	val \|= inb(0x40) << 8;
	193	spin_unlock(&i8253_lock);
	194
	195	if(val > LATCH) {
	196	printk("\nVOYAGER: countdown timer value too high (%d), resetting\n\n", val);
	197	spin_lock(&i8253_lock);
	198	outb(0x34,0x43);
	199	outb_p(LATCH & 0xff , 0x40); /* LSB */
	200	outb(LATCH >> 8 , 0x40); /* MSB */
	201	spin_unlock(&i8253_lock);
	202	}
	203	}
	204	#ifdef CONFIG_SMP
	205	smp_vic_timer_interrupt(regs);
	206	#endif
	207	}
	208
	209	void
	210	voyager_power_off(void)
	211	{
	212	printk("VOYAGER Power Off\n");
	213
	214	if(voyager_level == 5) {
	215	voyager_cat_power_off();
	216	} else if(voyager_level == 4) {
	217	/* This doesn't apparently work on most L4 machines,
	218	* but the specs say to do this to get automatic power
	219	* off. Unfortunately, if it doesn't power off the
	220	* machine, it ends up doing a cold restart, which
	221	* isn't really intended, so comment out the code */
	222	#if 0
	223	int port;
	224
	225
	226	/* enable the voyager Configuration Space */
	227	outb((inb(VOYAGER_MC_SETUP) & 0xf0) \| 0x8,
	228	VOYAGER_MC_SETUP);
	229	/* the port for the power off flag is an offset from the
	230	floating base */
	231	port = (inb(VOYAGER_SSPB_RELOCATION_PORT) << 8) + 0x21;
	232	/* set the power off flag */
	233	outb(inb(port) \| 0x1, port);
	234	#endif
	235	}
	236	/* and wait for it to happen */
f2ab4461 ZA	237	local_irq_disable();
	238	for(;;)
	239	halt();
1da177e4 LT	240	}
	241
	242	/* copied from process.c */
	243	static inline void
	244	kb_wait(void)
	245	{
	246	int i;
	247
	248	for (i=0; i<0x10000; i++)
	249	if ((inb_p(0x64) & 0x02) == 0)
	250	break;
	251	}
	252
094528a7 EB	253	void
	254	machine_shutdown(void)
	255	{
	256	/* Architecture specific shutdown needed before a kexec */
	257	}
	258
1da177e4 LT	259	void
	260	machine_restart(char *cmd)
	261	{
	262	printk("Voyager Warm Restart\n");
	263	kb_wait();
	264
	265	if(voyager_level == 5) {
	266	/* write magic values to the RTC to inform system that
	267	* shutdown is beginning */
	268	outb(0x8f, 0x70);
	269	outb(0x5 , 0x71);
	270
	271	udelay(50);
	272	outb(0xfe,0x64); /* pull reset low */
	273	} else if(voyager_level == 4) {
	274	__u16 catbase = inb(VOYAGER_SSPB_RELOCATION_PORT)<<8;
	275	__u8 basebd = inb(VOYAGER_MC_SETUP);
	276
	277	outb(basebd \| 0x08, VOYAGER_MC_SETUP);
	278	outb(0x02, catbase + 0x21);
	279	}
f2ab4461 ZA	280	local_irq_disable();
	281	for(;;)
	282	halt();
1da177e4 LT	283	}
1da177e4 LT	284
e6cb9941 JB	285	void
	286	machine_emergency_restart(void)
	287	{
	288	/for now, just hook this to a warm restart /
	289	machine_restart(NULL);
	290	}
	291
1da177e4 LT	292	void
	293	mca_nmi_hook(void)
	294	{
	295	__u8 dumpval __attribute__((unused)) = inb(0xf823);
	296	__u8 swnmi __attribute__((unused)) = inb(0xf813);
	297
	298	/* FIXME: assume dump switch pressed */
	299	/* check to see if the dump switch was pressed */
	300	VDEBUG(("VOYAGER: dumpval = 0x%x, swnmi = 0x%x\n", dumpval, swnmi));
	301	/* clear swnmi */
	302	outb(0xff, 0xf813);
	303	/* tell SUS to ignore dump */
	304	if(voyager_level == 5 && voyager_SUS != NULL) {
	305	if(voyager_SUS->SUS_mbox == VOYAGER_DUMP_BUTTON_NMI) {
	306	voyager_SUS->kernel_mbox = VOYAGER_NO_COMMAND;
	307	voyager_SUS->kernel_flags \|= VOYAGER_OS_IN_PROGRESS;
	308	udelay(1000);
	309	voyager_SUS->kernel_mbox = VOYAGER_IGNORE_DUMP;
	310	voyager_SUS->kernel_flags &= ~VOYAGER_OS_IN_PROGRESS;
	311	}
	312	}
	313	printk(KERN_ERR "VOYAGER: Dump switch pressed, printing CPU%d tracebacks\n", smp_processor_id());
	314	show_stack(NULL, NULL);
	315	show_state();
	316	}
	317
	318
	319
	320	void
	321	machine_halt(void)
	322	{
	323	/* treat a halt like a power off */
	324	machine_power_off();
	325	}
	326
1da177e4 LT	327	void machine_power_off(void)
	328	{
	329	if (pm_power_off)
	330	pm_power_off();
	331	}
	332