[mirror_ubuntu-jammy-kernel.git] / arch / ppc / amiga / cia.c

/*
 *  arch/ppc/amiga/cia.c - CIA support
 *
 *  Copyright (C) 1996 Roman Zippel
 *
 *  The concept of some functions bases on the original Amiga OS function
 *
 * 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/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/kernel_stat.h>
#include <linux/init.h>

#include <asm/irq.h>
#include <asm/amigahw.h>
#include <asm/amigaints.h>

struct ciabase {
	volatile struct CIA *cia;
	u_char icr_mask, icr_data;
	u_short int_mask;
	int handler_irq, cia_irq, server_irq;
	char *name;
} ciaa_base = {
	&ciaa, 0, 0, IF_PORTS,
	IRQ_AMIGA_AUTO_2, IRQ_AMIGA_CIAA,
	IRQ_AMIGA_PORTS,
	"CIAA handler"
}, ciab_base = {
	&ciab, 0, 0, IF_EXTER,
	IRQ_AMIGA_AUTO_6, IRQ_AMIGA_CIAB,
	IRQ_AMIGA_EXTER,
	"CIAB handler"
};

#define CIA_SET_BASE_ADJUST_IRQ(base, irq)	\
do {						\
	if (irq >= IRQ_AMIGA_CIAB) {		\
		base = &ciab_base;		\
		irq -= IRQ_AMIGA_CIAB;		\
	} else {				\
		base = &ciaa_base;		\
		irq -= IRQ_AMIGA_CIAA;		\
	}					\
} while (0)

/*
 *  Cause or clear CIA interrupts, return old interrupt status.
 */

static unsigned char cia_set_irq_private(struct ciabase *base,
					 unsigned char mask)
{
	u_char old;

	old = (base->icr_data |= base->cia->icr);
	if (mask & CIA_ICR_SETCLR)
		base->icr_data |= mask;
	else
		base->icr_data &= ~mask;
	if (base->icr_data & base->icr_mask)
		amiga_custom.intreq = IF_SETCLR | base->int_mask;
	return old & base->icr_mask;
}

unsigned char cia_set_irq(unsigned int irq, int set)
{
	struct ciabase *base;
	unsigned char mask;

	if (irq >= IRQ_AMIGA_CIAB)
		mask = (1 << (irq - IRQ_AMIGA_CIAB));
	else
		mask = (1 << (irq - IRQ_AMIGA_CIAA));
	mask |= (set) ? CIA_ICR_SETCLR : 0;

	CIA_SET_BASE_ADJUST_IRQ(base, irq);

	return cia_set_irq_private(base, mask);
}

unsigned char cia_get_irq_mask(unsigned int irq)
{
	struct ciabase *base;

	CIA_SET_BASE_ADJUST_IRQ(base, irq);

	return base->cia->icr;
}

/*
 *  Enable or disable CIA interrupts, return old interrupt mask.
 */

static unsigned char cia_able_irq_private(struct ciabase *base,
					  unsigned char mask)
{
	u_char old;

	old = base->icr_mask;
	base->icr_data |= base->cia->icr;
	base->cia->icr = mask;
	if (mask & CIA_ICR_SETCLR)
		base->icr_mask |= mask;
	else
		base->icr_mask &= ~mask;
	base->icr_mask &= CIA_ICR_ALL;

	if (base->icr_data & base->icr_mask)
		amiga_custom.intreq = IF_SETCLR | base->int_mask;
	return old;
}

unsigned char cia_able_irq(unsigned int irq, int enable)
{
	struct ciabase *base;
	unsigned char mask;

	if (irq >= IRQ_AMIGA_CIAB)
		mask = (1 << (irq - IRQ_AMIGA_CIAB));
	else
		mask = (1 << (irq - IRQ_AMIGA_CIAA));
	mask |= (enable) ? CIA_ICR_SETCLR : 0;

	CIA_SET_BASE_ADJUST_IRQ(base, irq);

	return cia_able_irq_private(base, mask);
}

static void cia_handler(int irq, void *dev_id, struct pt_regs *fp)
{
	struct ciabase *base = (struct ciabase *)dev_id;
	irq_desc_t *desc;
	struct irqaction *action;
	int i;
	unsigned char ints;

	irq = base->cia_irq;
	desc = irq_desc + irq;
	ints = cia_set_irq_private(base, CIA_ICR_ALL);
	amiga_custom.intreq = base->int_mask;
	for (i = 0; i < CIA_IRQS; i++, irq++) {
		if (ints & 1) {
			kstat_cpu(0).irqs[irq]++;
			action = desc->action;
			action->handler(irq, action->dev_id, fp);
		}
		ints >>= 1;
		desc++;
	}
	amiga_do_irq_list(base->server_irq, fp);
}

void __init cia_init_IRQ(struct ciabase *base)
{
	extern struct irqaction amiga_sys_irqaction[AUTO_IRQS];
	struct irqaction *action;

	/* clear any pending interrupt and turn off all interrupts */
	cia_set_irq_private(base, CIA_ICR_ALL);
	cia_able_irq_private(base, CIA_ICR_ALL);

	/* install CIA handler */
	action = &amiga_sys_irqaction[base->handler_irq-IRQ_AMIGA_AUTO];
	action->handler = cia_handler;
	action->dev_id = base;
	action->name = base->name;
	setup_irq(base->handler_irq, &amiga_sys_irqaction[base->handler_irq-IRQ_AMIGA_AUTO]);

	amiga_custom.intena = IF_SETCLR | base->int_mask;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* arch/ppc/amiga/cia.c - CIA support
	3	*
	4	* Copyright (C) 1996 Roman Zippel
	5	*
	6	* The concept of some functions bases on the original Amiga OS function
	7	*
	8	* This file is subject to the terms and conditions of the GNU General Public
	9	* License. See the file COPYING in the main directory of this archive
	10	* for more details.
	11	*/
	12
	13	#include <linux/types.h>
	14	#include <linux/kernel.h>
	15	#include <linux/sched.h>
	16	#include <linux/interrupt.h>
	17	#include <linux/irq.h>
	18	#include <linux/kernel_stat.h>
	19	#include <linux/init.h>
	20
	21	#include <asm/irq.h>
	22	#include <asm/amigahw.h>
	23	#include <asm/amigaints.h>
	24
	25	struct ciabase {
	26	volatile struct CIA *cia;
	27	u_char icr_mask, icr_data;
	28	u_short int_mask;
	29	int handler_irq, cia_irq, server_irq;
	30	char *name;
	31	} ciaa_base = {
	32	&ciaa, 0, 0, IF_PORTS,
	33	IRQ_AMIGA_AUTO_2, IRQ_AMIGA_CIAA,
	34	IRQ_AMIGA_PORTS,
	35	"CIAA handler"
	36	}, ciab_base = {
	37	&ciab, 0, 0, IF_EXTER,
	38	IRQ_AMIGA_AUTO_6, IRQ_AMIGA_CIAB,
	39	IRQ_AMIGA_EXTER,
	40	"CIAB handler"
	41	};
	42
	43	#define CIA_SET_BASE_ADJUST_IRQ(base, irq) \
	44	do { \
	45	if (irq >= IRQ_AMIGA_CIAB) { \
	46	base = &ciab_base; \
	47	irq -= IRQ_AMIGA_CIAB; \
	48	} else { \
	49	base = &ciaa_base; \
	50	irq -= IRQ_AMIGA_CIAA; \
	51	} \
	52	} while (0)
	53
	54	/*
	55	* Cause or clear CIA interrupts, return old interrupt status.
	56	*/
	57
	58	static unsigned char cia_set_irq_private(struct ciabase *base,
	59	unsigned char mask)
	60	{
	61	u_char old;
	62
	63	old = (base->icr_data \|= base->cia->icr);
	64	if (mask & CIA_ICR_SETCLR)
65	base->icr_data \|= mask;
66	else
67	base->icr_data &= ~mask;
68	if (base->icr_data & base->icr_mask)
b4290a23	69	amiga_custom.intreq = IF_SETCLR \| base->int_mask;
1da177e4 LT	70	return old & base->icr_mask;
	71	}
	72
	73	unsigned char cia_set_irq(unsigned int irq, int set)
	74	{
	75	struct ciabase *base;
	76	unsigned char mask;
	77
	78	if (irq >= IRQ_AMIGA_CIAB)
	79	mask = (1 << (irq - IRQ_AMIGA_CIAB));
	80	else
	81	mask = (1 << (irq - IRQ_AMIGA_CIAA));
	82	mask \|= (set) ? CIA_ICR_SETCLR : 0;
	83
	84	CIA_SET_BASE_ADJUST_IRQ(base, irq);
	85
	86	return cia_set_irq_private(base, mask);
	87	}
	88
	89	unsigned char cia_get_irq_mask(unsigned int irq)
	90	{
	91	struct ciabase *base;
	92
	93	CIA_SET_BASE_ADJUST_IRQ(base, irq);
	94
	95	return base->cia->icr;
	96	}
	97
	98	/*
	99	* Enable or disable CIA interrupts, return old interrupt mask.
	100	*/
	101
	102	static unsigned char cia_able_irq_private(struct ciabase *base,
	103	unsigned char mask)
	104	{
	105	u_char old;
	106
	107	old = base->icr_mask;
	108	base->icr_data \|= base->cia->icr;
	109	base->cia->icr = mask;
	110	if (mask & CIA_ICR_SETCLR)
	111	base->icr_mask \|= mask;
	112	else
	113	base->icr_mask &= ~mask;
	114	base->icr_mask &= CIA_ICR_ALL;
	115
	116	if (base->icr_data & base->icr_mask)
b4290a23	117	amiga_custom.intreq = IF_SETCLR \| base->int_mask;
1da177e4 LT	118	return old;
	119	}
	120
	121	unsigned char cia_able_irq(unsigned int irq, int enable)
	122	{
	123	struct ciabase *base;
	124	unsigned char mask;
	125
	126	if (irq >= IRQ_AMIGA_CIAB)
	127	mask = (1 << (irq - IRQ_AMIGA_CIAB));
	128	else
	129	mask = (1 << (irq - IRQ_AMIGA_CIAA));
	130	mask \|= (enable) ? CIA_ICR_SETCLR : 0;
	131
	132	CIA_SET_BASE_ADJUST_IRQ(base, irq);
	133
	134	return cia_able_irq_private(base, mask);
	135	}
	136
	137	static void cia_handler(int irq, void dev_id, struct pt_regs fp)
	138	{
	139	struct ciabase base = (struct ciabase )dev_id;
	140	irq_desc_t *desc;
	141	struct irqaction *action;
	142	int i;
	143	unsigned char ints;
	144
	145	irq = base->cia_irq;
	146	desc = irq_desc + irq;
	147	ints = cia_set_irq_private(base, CIA_ICR_ALL);
b4290a23	148	amiga_custom.intreq = base->int_mask;
1da177e4 LT	149	for (i = 0; i < CIA_IRQS; i++, irq++) {
	150	if (ints & 1) {
	151	kstat_cpu(0).irqs[irq]++;
	152	action = desc->action;
	153	action->handler(irq, action->dev_id, fp);
	154	}
	155	ints >>= 1;
	156	desc++;
	157	}
	158	amiga_do_irq_list(base->server_irq, fp);
	159	}
	160
	161	void __init cia_init_IRQ(struct ciabase *base)
	162	{
	163	extern struct irqaction amiga_sys_irqaction[AUTO_IRQS];
	164	struct irqaction *action;
	165
	166	/* clear any pending interrupt and turn off all interrupts */
	167	cia_set_irq_private(base, CIA_ICR_ALL);
	168	cia_able_irq_private(base, CIA_ICR_ALL);
	169
	170	/* install CIA handler */
	171	action = &amiga_sys_irqaction[base->handler_irq-IRQ_AMIGA_AUTO];
	172	action->handler = cia_handler;
	173	action->dev_id = base;
	174	action->name = base->name;
	175	setup_irq(base->handler_irq, &amiga_sys_irqaction[base->handler_irq-IRQ_AMIGA_AUTO]);
	176
b4290a23	177	amiga_custom.intena = IF_SETCLR \| base->int_mask;
1da177e4	178	}