[mirror_ubuntu-artful-kernel.git] / arch / alpha / kernel / sys_jensen.c

/*
 *	linux/arch/alpha/kernel/sys_jensen.c
 *
 *	Copyright (C) 1995 Linus Torvalds
 *	Copyright (C) 1998, 1999 Richard Henderson
 *
 * Code supporting the Jensen.
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/pci.h>
#include <linux/init.h>

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

#define __EXTERN_INLINE inline
#include <asm/io.h>
#include <asm/jensen.h>
#undef  __EXTERN_INLINE

#include <asm/dma.h>
#include <asm/irq.h>
#include <asm/mmu_context.h>
#include <asm/pgtable.h>
#include <asm/tlbflush.h>

#include "proto.h"
#include "irq_impl.h"
#include "pci_impl.h"
#include "machvec_impl.h"


/*
 * Jensen is special: the vector is 0x8X0 for EISA interrupt X, and
 * 0x9X0 for the local motherboard interrupts.
 *
 * Note especially that those local interrupts CANNOT be masked,
 * which causes much of the pain below...
 *
 *	0x660 - NMI
 *
 *	0x800 - IRQ0  interval timer (not used, as we use the RTC timer)
 *	0x810 - IRQ1  line printer (duh..)
 *	0x860 - IRQ6  floppy disk
 *
 *	0x900 - COM1
 *	0x920 - COM2
 *	0x980 - keyboard
 *	0x990 - mouse
 *
 * PCI-based systems are more sane: they don't have the local
 * interrupts at all, and have only normal PCI interrupts from
 * devices.  Happily it's easy enough to do a sane mapping from the
 * Jensen.
 * 
 * Note that this means that we may have to do a hardware
 * "local_op" to a different interrupt than we report to the rest of the
 * world.
 */

static void
jensen_local_enable(unsigned int irq)
{
	/* the parport is really hw IRQ 1, silly Jensen.  */
	if (irq == 7)
		i8259a_enable_irq(1);
}

static void
jensen_local_disable(unsigned int irq)
{
	/* the parport is really hw IRQ 1, silly Jensen.  */
	if (irq == 7)
		i8259a_disable_irq(1);
}

static void
jensen_local_mask_ack(unsigned int irq)
{
	/* the parport is really hw IRQ 1, silly Jensen.  */
	if (irq == 7)
		i8259a_mask_and_ack_irq(1);
}

static struct irq_chip jensen_local_irq_type = {
	.name		= "LOCAL",
	.unmask		= jensen_local_enable,
	.mask		= jensen_local_disable,
	.mask_ack	= jensen_local_mask_ack,
};

static void 
jensen_device_interrupt(unsigned long vector)
{
	int irq;

	switch (vector) {
	case 0x660:
		printk("Whee.. NMI received. Probable hardware error\n");
		printk("61=%02x, 461=%02x\n", inb(0x61), inb(0x461));
		return;

	/* local device interrupts: */
	case 0x900: irq = 4; break;		/* com1 -> irq 4 */
	case 0x920: irq = 3; break;		/* com2 -> irq 3 */
	case 0x980: irq = 1; break;		/* kbd -> irq 1 */
	case 0x990: irq = 9; break;		/* mouse -> irq 9 */

	default:
		if (vector > 0x900) {
			printk("Unknown local interrupt %lx\n", vector);
			return;
		}

		irq = (vector - 0x800) >> 4;
		if (irq == 1)
			irq = 7;
		break;
	}

	/* If there is no handler yet... */
	if (!irq_has_action(irq)) {
	    /* If it is a local interrupt that cannot be masked... */
	    if (vector >= 0x900)
	    {
	        /* Clear keyboard/mouse state */
	    	inb(0x64);
		inb(0x60);
		/* Reset serial ports */
		inb(0x3fa);
		inb(0x2fa);
		outb(0x0c, 0x3fc);
		outb(0x0c, 0x2fc);
		/* Clear NMI */
		outb(0,0x61);
		outb(0,0x461);
	    }
	}

#if 0
        /* A useful bit of code to find out if an interrupt is going wild.  */
        {
          static unsigned int last_msg = 0, last_cc = 0;
          static int last_irq = -1, count = 0;
          unsigned int cc;

          __asm __volatile("rpcc %0" : "=r"(cc));
          ++count;
#define JENSEN_CYCLES_PER_SEC	(150000000)
          if (cc - last_msg > ((JENSEN_CYCLES_PER_SEC) * 3) ||
	      irq != last_irq) {
                printk(KERN_CRIT " irq %d count %d cc %u @ %lx\n",
                       irq, count, cc-last_cc, get_irq_regs()->pc);
                count = 0;
                last_msg = cc;
                last_irq = irq;
          }
          last_cc = cc;
        }
#endif

	handle_irq(irq);
}

static void __init
jensen_init_irq(void)
{
	init_i8259a_irqs();

	set_irq_chip_and_handler(1, &jensen_local_irq_type, handle_level_irq);
	set_irq_chip_and_handler(4, &jensen_local_irq_type, handle_level_irq);
	set_irq_chip_and_handler(3, &jensen_local_irq_type, handle_level_irq);
	set_irq_chip_and_handler(7, &jensen_local_irq_type, handle_level_irq);
	set_irq_chip_and_handler(9, &jensen_local_irq_type, handle_level_irq);

	common_init_isa_dma();
}

static void __init
jensen_init_arch(void)
{
	struct pci_controller *hose;
#ifdef CONFIG_PCI
	static struct pci_dev fake_isa_bridge = { .dma_mask = 0xffffffffUL, };

	isa_bridge = &fake_isa_bridge;
#endif

	/* Create a hose so that we can report i/o base addresses to
	   userland.  */

	pci_isa_hose = hose = alloc_pci_controller();
	hose->io_space = &ioport_resource;
	hose->mem_space = &iomem_resource;
	hose->index = 0;

	hose->sparse_mem_base = EISA_MEM - IDENT_ADDR;
	hose->dense_mem_base = 0;
	hose->sparse_io_base = EISA_IO - IDENT_ADDR;
	hose->dense_io_base = 0;

	hose->sg_isa = hose->sg_pci = NULL;
	__direct_map_base = 0;
	__direct_map_size = 0xffffffff;
}

static void
jensen_machine_check(unsigned long vector, unsigned long la)
{
	printk(KERN_CRIT "Machine check\n");
}

/*
 * The System Vector
 */

struct alpha_machine_vector jensen_mv __initmv = {
	.vector_name		= "Jensen",
	DO_EV4_MMU,
	IO_LITE(JENSEN,jensen),
	.machine_check		= jensen_machine_check,
	.max_isa_dma_address	= ALPHA_MAX_ISA_DMA_ADDRESS,
	.rtc_port		= 0x170,
	.rtc_get_time		= common_get_rtc_time,
	.rtc_set_time		= common_set_rtc_time,

	.nr_irqs		= 16,
	.device_interrupt	= jensen_device_interrupt,

	.init_arch		= jensen_init_arch,
	.init_irq		= jensen_init_irq,
	.init_rtc		= common_init_rtc,
	.init_pci		= NULL,
	.kill_arch		= NULL,
};
ALIAS_MV(jensen)
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/alpha/kernel/sys_jensen.c
	3	*
	4	* Copyright (C) 1995 Linus Torvalds
	5	* Copyright (C) 1998, 1999 Richard Henderson
	6	*
	7	* Code supporting the Jensen.
	8	*/
	9
	10	#include <linux/kernel.h>
	11	#include <linux/types.h>
	12	#include <linux/mm.h>
	13	#include <linux/sched.h>
	14	#include <linux/pci.h>
	15	#include <linux/init.h>
	16
	17	#include <asm/ptrace.h>
	18	#include <asm/system.h>
	19
	20	#define __EXTERN_INLINE inline
	21	#include <asm/io.h>
	22	#include <asm/jensen.h>
	23	#undef __EXTERN_INLINE
	24
	25	#include <asm/dma.h>
	26	#include <asm/irq.h>
	27	#include <asm/mmu_context.h>
	28	#include <asm/pgtable.h>
	29	#include <asm/tlbflush.h>
	30
	31	#include "proto.h"
	32	#include "irq_impl.h"
	33	#include "pci_impl.h"
	34	#include "machvec_impl.h"
	35
	36
	37	/*
	38	* Jensen is special: the vector is 0x8X0 for EISA interrupt X, and
	39	* 0x9X0 for the local motherboard interrupts.
	40	*
	41	* Note especially that those local interrupts CANNOT be masked,
	42	* which causes much of the pain below...
	43	*
	44	* 0x660 - NMI
	45	*
	46	* 0x800 - IRQ0 interval timer (not used, as we use the RTC timer)
	47	* 0x810 - IRQ1 line printer (duh..)
	48	* 0x860 - IRQ6 floppy disk
	49	*
	50	* 0x900 - COM1
	51	* 0x920 - COM2
	52	* 0x980 - keyboard
	53	* 0x990 - mouse
	54	*
	55	* PCI-based systems are more sane: they don't have the local
	56	* interrupts at all, and have only normal PCI interrupts from
	57	* devices. Happily it's easy enough to do a sane mapping from the
	58	* Jensen.
	59	*
	60	* Note that this means that we may have to do a hardware
	61	* "local_op" to a different interrupt than we report to the rest of the
	62	* world.
	63	*/
	64
1da177e4 LT	65	static void
	66	jensen_local_enable(unsigned int irq)
	67	{
	68	/* the parport is really hw IRQ 1, silly Jensen. */
	69	if (irq == 7)
	70	i8259a_enable_irq(1);
	71	}
	72
	73	static void
	74	jensen_local_disable(unsigned int irq)
	75	{
	76	/* the parport is really hw IRQ 1, silly Jensen. */
	77	if (irq == 7)
	78	i8259a_disable_irq(1);
	79	}
	80
	81	static void
7d209c81	82	jensen_local_mask_ack(unsigned int irq)
1da177e4 LT	83	{
	84	/* the parport is really hw IRQ 1, silly Jensen. */
	85	if (irq == 7)
	86	i8259a_mask_and_ack_irq(1);
	87	}
	88
44377f62	89	static struct irq_chip jensen_local_irq_type = {
8ab1221c	90	.name = "LOCAL",
7d209c81 KM	91	.unmask = jensen_local_enable,
	92	.mask = jensen_local_disable,
	93	.mask_ack = jensen_local_mask_ack,
1da177e4 LT	94	};
	95
	96	static void
7ca56053	97	jensen_device_interrupt(unsigned long vector)
1da177e4 LT	98	{
	99	int irq;
	100
	101	switch (vector) {
	102	case 0x660:
	103	printk("Whee.. NMI received. Probable hardware error\n");
	104	printk("61=%02x, 461=%02x\n", inb(0x61), inb(0x461));
	105	return;
	106
	107	/* local device interrupts: */
	108	case 0x900: irq = 4; break; /* com1 -> irq 4 */
	109	case 0x920: irq = 3; break; /* com2 -> irq 3 */
	110	case 0x980: irq = 1; break; /* kbd -> irq 1 */
	111	case 0x990: irq = 9; break; /* mouse -> irq 9 */
	112
	113	default:
	114	if (vector > 0x900) {
	115	printk("Unknown local interrupt %lx\n", vector);
	116	return;
	117	}
	118
	119	irq = (vector - 0x800) >> 4;
	120	if (irq == 1)
	121	irq = 7;
	122	break;
	123	}
	124
	125	/* If there is no handler yet... */
a891b393	126	if (!irq_has_action(irq)) {
1da177e4 LT	127	/* If it is a local interrupt that cannot be masked... */
	128	if (vector >= 0x900)
	129	{
	130	/* Clear keyboard/mouse state */
	131	inb(0x64);
	132	inb(0x60);
	133	/* Reset serial ports */
	134	inb(0x3fa);
	135	inb(0x2fa);
	136	outb(0x0c, 0x3fc);
	137	outb(0x0c, 0x2fc);
	138	/* Clear NMI */
	139	outb(0,0x61);
	140	outb(0,0x461);
	141	}
	142	}
	143
	144	#if 0
	145	/* A useful bit of code to find out if an interrupt is going wild. */
	146	{
	147	static unsigned int last_msg = 0, last_cc = 0;
	148	static int last_irq = -1, count = 0;
	149	unsigned int cc;
	150
	151	__asm __volatile("rpcc %0" : "=r"(cc));
	152	++count;
	153	#define JENSEN_CYCLES_PER_SEC (150000000)
	154	if (cc - last_msg > ((JENSEN_CYCLES_PER_SEC) * 3) \|\|
	155	irq != last_irq) {
	156	printk(KERN_CRIT " irq %d count %d cc %u @ %lx\n",
7ca56053	157	irq, count, cc-last_cc, get_irq_regs()->pc);
1da177e4 LT	158	count = 0;
	159	last_msg = cc;
	160	last_irq = irq;
	161	}
	162	last_cc = cc;
	163	}
	164	#endif
	165
3dbb8c62	166	handle_irq(irq);
1da177e4 LT	167	}
	168
	169	static void __init
	170	jensen_init_irq(void)
	171	{
	172	init_i8259a_irqs();
	173
7d209c81 KM	174	set_irq_chip_and_handler(1, &jensen_local_irq_type, handle_level_irq);
	175	set_irq_chip_and_handler(4, &jensen_local_irq_type, handle_level_irq);
	176	set_irq_chip_and_handler(3, &jensen_local_irq_type, handle_level_irq);
	177	set_irq_chip_and_handler(7, &jensen_local_irq_type, handle_level_irq);
	178	set_irq_chip_and_handler(9, &jensen_local_irq_type, handle_level_irq);
1da177e4 LT	179
	180	common_init_isa_dma();
	181	}
	182
	183	static void __init
	184	jensen_init_arch(void)
	185	{
	186	struct pci_controller *hose;
	187	#ifdef CONFIG_PCI
	188	static struct pci_dev fake_isa_bridge = { .dma_mask = 0xffffffffUL, };
	189
	190	isa_bridge = &fake_isa_bridge;
	191	#endif
	192
	193	/* Create a hose so that we can report i/o base addresses to
	194	userland. */
	195
	196	pci_isa_hose = hose = alloc_pci_controller();
	197	hose->io_space = &ioport_resource;
	198	hose->mem_space = &iomem_resource;
	199	hose->index = 0;
	200
	201	hose->sparse_mem_base = EISA_MEM - IDENT_ADDR;
	202	hose->dense_mem_base = 0;
	203	hose->sparse_io_base = EISA_IO - IDENT_ADDR;
	204	hose->dense_io_base = 0;
	205
	206	hose->sg_isa = hose->sg_pci = NULL;
	207	__direct_map_base = 0;
	208	__direct_map_size = 0xffffffff;
	209	}
	210
	211	static void
5f0e3da6	212	jensen_machine_check(unsigned long vector, unsigned long la)
1da177e4 LT	213	{
	214	printk(KERN_CRIT "Machine check\n");
	215	}
	216
1da177e4 LT	217	/*
	218	* The System Vector
	219	*/
	220
	221	struct alpha_machine_vector jensen_mv __initmv = {
	222	.vector_name = "Jensen",
	223	DO_EV4_MMU,
	224	IO_LITE(JENSEN,jensen),
	225	.machine_check = jensen_machine_check,
	226	.max_isa_dma_address = ALPHA_MAX_ISA_DMA_ADDRESS,
	227	.rtc_port = 0x170,
5f7dc5d7 IK	228	.rtc_get_time = common_get_rtc_time,
5f7dc5d7 IK	229	.rtc_set_time = common_set_rtc_time,
1da177e4 LT	230
	231	.nr_irqs = 16,
	232	.device_interrupt = jensen_device_interrupt,
	233
	234	.init_arch = jensen_init_arch,
	235	.init_irq = jensen_init_irq,
	236	.init_rtc = common_init_rtc,
	237	.init_pci = NULL,
	238	.kill_arch = NULL,
	239	};
	240	ALIAS_MV(jensen)