Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8f042aa7 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/geert/linux-m68k 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/geert/linux-m68k: (29 commits)
  m68k/mac: Remove mac_irq_{en,dis}able() wrappers
  m68k/irq: Remove obsolete support for user vector interrupt fixups
  m68k/irq: Remove obsolete m68k irq framework
  m68k/q40: Convert Q40/Q60 to genirq
  m68k/sun3: Convert Sun3/3x to genirq
  m68k/sun3: Use the kstat_irqs_cpu() wrapper
  m68k/apollo: Convert Apollo to genirq
  m68k/vme: Convert VME to genirq
  m68k/hp300: Convert HP9000/300 and HP9000/400 to genirq
  m68k/mac: Optimize interrupts using chain handlers
  m68k/mac: Convert Mac to genirq
  m68k/amiga: Optimize interrupts using chain handlers
  m68k/amiga: Convert Amiga to genirq
  m68k/amiga: Refactor amiints.c
  m68k/atari: Remove code and comments about different irq types
  m68k/atari: Convert Atari to genirq
  m68k/irq: Add genirq support
  m68k/irq: Remove obsolete IRQ_FLG_* users
  m68k/irq: Rename {,__}m68k_handle_int()
  m68k/irq: Add m68k_setup_irq_controller()
  ...
parents e6f1227e 2690e214

arch/m68k/Kconfig

+2 −2
Original line number Diff line number Diff line
@@ -4,8 +4,8 @@ config M68K 
	select HAVE_IDE

	select HAVE_AOUT if MMU

	select GENERIC_ATOMIC64 if MMU

	select HAVE_GENERIC_HARDIRQS if !MMU

	select GENERIC_IRQ_SHOW if !MMU

	select HAVE_GENERIC_HARDIRQS

	select GENERIC_IRQ_SHOW

	select ARCH_HAVE_NMI_SAFE_CMPXCHG if RMW_INSNS



config RWSEM_GENERIC_SPINLOCK

arch/m68k/Kconfig.bus

+9 −0
Original line number Diff line number Diff line
@@ -2,6 +2,15 @@ if MMU 


comment "Bus Support"



config DIO

	bool "DIO bus support"

	depends on HP300

	default y

	help

	  Say Y here to enable support for the "DIO" expansion bus used in

	  HP300 machines. If you are using such a system you almost certainly

	  want this.



config NUBUS

	bool

	depends on MAC

arch/m68k/Kconfig.devices

+31 −0
Original line number Diff line number Diff line
@@ -24,6 +24,37 @@ config PROC_HARDWARE 
	  including the model, CPU, MMU, clock speed, BogoMIPS rating,

	  and memory size.



config NATFEAT

	bool "ARAnyM emulator support"

	depends on ATARI

	help

	  This option enables support for ARAnyM native features, such as

	  access to a disk image as /dev/hda.



config NFBLOCK

	tristate "NatFeat block device support"

	depends on BLOCK && NATFEAT

	help

	  Say Y to include support for the ARAnyM NatFeat block device

	  which allows direct access to the hard drives without using

	  the hardware emulation.



config NFCON

	tristate "NatFeat console driver"

	depends on NATFEAT

	help

	  Say Y to include support for the ARAnyM NatFeat console driver

	  which allows the console output to be redirected to the stderr

	  output of ARAnyM.



config NFETH

	tristate "NatFeat Ethernet support"

	depends on ETHERNET && NATFEAT

	help

	  Say Y to include support for the ARAnyM NatFeat network device

	  which will emulate a regular ethernet device while presenting an

	  ethertap device to the host system.



endmenu



menu "Character devices"

arch/m68k/amiga/amiints.c

+64 −104
Original line number Diff line number Diff line 
/*

 * linux/arch/m68k/amiga/amiints.c -- Amiga Linux interrupt handling code

 * Amiga Linux interrupt handling code

 *

 * 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.

 *

 * 11/07/96: rewritten interrupt handling, irq lists are exists now only for

 *           this sources where it makes sense (VERTB/PORTS/EXTER) and you must

 *           be careful that dev_id for this sources is unique since this the

 *           only possibility to distinguish between different handlers for

 *           free_irq. irq lists also have different irq flags:

 *           - IRQ_FLG_FAST: handler is inserted at top of list (after other

 *                           fast handlers)

 *           - IRQ_FLG_SLOW: handler is inserted at bottom of list and before

 *                           they're executed irq level is set to the previous

 *                           one, but handlers don't need to be reentrant, if

 *                           reentrance occurred, slow handlers will be just

 *                           called again.

 *           The whole interrupt handling for CIAs is moved to cia.c

 *           /Roman Zippel

 *

 * 07/08/99: rewamp of the interrupt handling - we now have two types of

 *           interrupts, normal and fast handlers, fast handlers being

 *           marked with IRQF_DISABLED and runs with all other interrupts

 *           disabled. Normal interrupts disable their own source but

 *           run with all other interrupt sources enabled.

 *           PORTS and EXTER interrupts are always shared even if the

 *           drivers do not explicitly mark this when calling

 *           request_irq which they really should do.

 *           This is similar to the way interrupts are handled on all

 *           other architectures and makes a ton of sense besides

 *           having the advantage of making it easier to share

 *           drivers.

 *           /Jes

 */



#include <linux/init.h>

#include <linux/interrupt.h>

#include <linux/errno.h>

#include <linux/irq.h>



#include <asm/irq.h>

#include <asm/traps.h>
@@ -45,56 +17,6 @@ 
#include <asm/amigaints.h>

#include <asm/amipcmcia.h>



static void amiga_enable_irq(unsigned int irq);

static void amiga_disable_irq(unsigned int irq);

static irqreturn_t ami_int1(int irq, void *dev_id);

static irqreturn_t ami_int3(int irq, void *dev_id);

static irqreturn_t ami_int4(int irq, void *dev_id);

static irqreturn_t ami_int5(int irq, void *dev_id);



static struct irq_controller amiga_irq_controller = {

	.name		= "amiga",

	.lock		= __SPIN_LOCK_UNLOCKED(amiga_irq_controller.lock),

	.enable		= amiga_enable_irq,

	.disable	= amiga_disable_irq,

};



/*

 * void amiga_init_IRQ(void)

 *

 * Parameters:	None

 *

 * Returns:	Nothing

 *

 * This function should be called during kernel startup to initialize

 * the amiga IRQ handling routines.

 */



void __init amiga_init_IRQ(void)

{

	if (request_irq(IRQ_AUTO_1, ami_int1, 0, "int1", NULL))

		pr_err("Couldn't register int%d\n", 1);

	if (request_irq(IRQ_AUTO_3, ami_int3, 0, "int3", NULL))

		pr_err("Couldn't register int%d\n", 3);

	if (request_irq(IRQ_AUTO_4, ami_int4, 0, "int4", NULL))

		pr_err("Couldn't register int%d\n", 4);

	if (request_irq(IRQ_AUTO_5, ami_int5, 0, "int5", NULL))

		pr_err("Couldn't register int%d\n", 5);



	m68k_setup_irq_controller(&amiga_irq_controller, IRQ_USER, AMI_STD_IRQS);



	/* turn off PCMCIA interrupts */

	if (AMIGAHW_PRESENT(PCMCIA))

		gayle.inten = GAYLE_IRQ_IDE;



	/* turn off all interrupts and enable the master interrupt bit */

	amiga_custom.intena = 0x7fff;

	amiga_custom.intreq = 0x7fff;

	amiga_custom.intena = IF_SETCLR | IF_INTEN;



	cia_init_IRQ(&ciaa_base);

	cia_init_IRQ(&ciab_base);

}



/*

 * Enable/disable a particular machine specific interrupt source.
@@ -103,112 +25,150 @@ void __init amiga_init_IRQ(void) 
 * internal data, that may not be changed by the interrupt at the same time.

 */



static void amiga_enable_irq(unsigned int irq)

static void amiga_irq_enable(struct irq_data *data)

{

	amiga_custom.intena = IF_SETCLR | (1 << (irq - IRQ_USER));

	amiga_custom.intena = IF_SETCLR | (1 << (data->irq - IRQ_USER));

}



static void amiga_disable_irq(unsigned int irq)

static void amiga_irq_disable(struct irq_data *data)

{

	amiga_custom.intena = 1 << (irq - IRQ_USER);

	amiga_custom.intena = 1 << (data->irq - IRQ_USER);

}



static struct irq_chip amiga_irq_chip = {

	.name		= "amiga",

	.irq_enable	= amiga_irq_enable,

	.irq_disable	= amiga_irq_disable,

};





/*

 * The builtin Amiga hardware interrupt handlers.

 */



static irqreturn_t ami_int1(int irq, void *dev_id)

static void ami_int1(unsigned int irq, struct irq_desc *desc)

{

	unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;



	/* if serial transmit buffer empty, interrupt */

	if (ints & IF_TBE) {

		amiga_custom.intreq = IF_TBE;

		m68k_handle_int(IRQ_AMIGA_TBE);

		generic_handle_irq(IRQ_AMIGA_TBE);

	}



	/* if floppy disk transfer complete, interrupt */

	if (ints & IF_DSKBLK) {

		amiga_custom.intreq = IF_DSKBLK;

		m68k_handle_int(IRQ_AMIGA_DSKBLK);

		generic_handle_irq(IRQ_AMIGA_DSKBLK);

	}



	/* if software interrupt set, interrupt */

	if (ints & IF_SOFT) {

		amiga_custom.intreq = IF_SOFT;

		m68k_handle_int(IRQ_AMIGA_SOFT);

		generic_handle_irq(IRQ_AMIGA_SOFT);

	}

	return IRQ_HANDLED;

}



static irqreturn_t ami_int3(int irq, void *dev_id)

static void ami_int3(unsigned int irq, struct irq_desc *desc)

{

	unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;



	/* if a blitter interrupt */

	if (ints & IF_BLIT) {

		amiga_custom.intreq = IF_BLIT;

		m68k_handle_int(IRQ_AMIGA_BLIT);

		generic_handle_irq(IRQ_AMIGA_BLIT);

	}



	/* if a copper interrupt */

	if (ints & IF_COPER) {

		amiga_custom.intreq = IF_COPER;

		m68k_handle_int(IRQ_AMIGA_COPPER);

		generic_handle_irq(IRQ_AMIGA_COPPER);

	}



	/* if a vertical blank interrupt */

	if (ints & IF_VERTB) {

		amiga_custom.intreq = IF_VERTB;

		m68k_handle_int(IRQ_AMIGA_VERTB);

		generic_handle_irq(IRQ_AMIGA_VERTB);

	}

	return IRQ_HANDLED;

}



static irqreturn_t ami_int4(int irq, void *dev_id)

static void ami_int4(unsigned int irq, struct irq_desc *desc)

{

	unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;



	/* if audio 0 interrupt */

	if (ints & IF_AUD0) {

		amiga_custom.intreq = IF_AUD0;

		m68k_handle_int(IRQ_AMIGA_AUD0);

		generic_handle_irq(IRQ_AMIGA_AUD0);

	}



	/* if audio 1 interrupt */

	if (ints & IF_AUD1) {

		amiga_custom.intreq = IF_AUD1;

		m68k_handle_int(IRQ_AMIGA_AUD1);

		generic_handle_irq(IRQ_AMIGA_AUD1);

	}



	/* if audio 2 interrupt */

	if (ints & IF_AUD2) {

		amiga_custom.intreq = IF_AUD2;

		m68k_handle_int(IRQ_AMIGA_AUD2);

		generic_handle_irq(IRQ_AMIGA_AUD2);

	}



	/* if audio 3 interrupt */

	if (ints & IF_AUD3) {

		amiga_custom.intreq = IF_AUD3;

		m68k_handle_int(IRQ_AMIGA_AUD3);

		generic_handle_irq(IRQ_AMIGA_AUD3);

	}

	return IRQ_HANDLED;

}



static irqreturn_t ami_int5(int irq, void *dev_id)

static void ami_int5(unsigned int irq, struct irq_desc *desc)

{

	unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;



	/* if serial receive buffer full interrupt */

	if (ints & IF_RBF) {

		/* acknowledge of IF_RBF must be done by the serial interrupt */

		m68k_handle_int(IRQ_AMIGA_RBF);

		generic_handle_irq(IRQ_AMIGA_RBF);

	}



	/* if a disk sync interrupt */

	if (ints & IF_DSKSYN) {

		amiga_custom.intreq = IF_DSKSYN;

		m68k_handle_int(IRQ_AMIGA_DSKSYN);

		generic_handle_irq(IRQ_AMIGA_DSKSYN);

	}

}

	return IRQ_HANDLED;





/*

 * void amiga_init_IRQ(void)

 *

 * Parameters:	None

 *

 * Returns:	Nothing

 *

 * This function should be called during kernel startup to initialize

 * the amiga IRQ handling routines.

 */



void __init amiga_init_IRQ(void)

{

	m68k_setup_irq_controller(&amiga_irq_chip, handle_simple_irq, IRQ_USER,

				  AMI_STD_IRQS);



	irq_set_chained_handler(IRQ_AUTO_1, ami_int1);

	irq_set_chained_handler(IRQ_AUTO_3, ami_int3);

	irq_set_chained_handler(IRQ_AUTO_4, ami_int4);

	irq_set_chained_handler(IRQ_AUTO_5, ami_int5);



	/* turn off PCMCIA interrupts */

	if (AMIGAHW_PRESENT(PCMCIA))

		gayle.inten = GAYLE_IRQ_IDE;



	/* turn off all interrupts and enable the master interrupt bit */

	amiga_custom.intena = 0x7fff;

	amiga_custom.intreq = 0x7fff;

	amiga_custom.intena = IF_SETCLR | IF_INTEN;



	cia_init_IRQ(&ciaa_base);

	cia_init_IRQ(&ciab_base);

}

arch/m68k/amiga/cia.c

+21 −18
Original line number Diff line number Diff line
@@ -93,13 +93,14 @@ static irqreturn_t cia_handler(int irq, void *dev_id) 
	amiga_custom.intreq = base->int_mask;

	for (; ints; mach_irq++, ints >>= 1) {

		if (ints & 1)

			m68k_handle_int(mach_irq);

			generic_handle_irq(mach_irq);

	}

	return IRQ_HANDLED;

}



static void cia_enable_irq(unsigned int irq)

static void cia_irq_enable(struct irq_data *data)

{

	unsigned int irq = data->irq;

	unsigned char mask;



	if (irq >= IRQ_AMIGA_CIAB) {
@@ -113,19 +114,20 @@ static void cia_enable_irq(unsigned int irq) 
	}

}



static void cia_disable_irq(unsigned int irq)

static void cia_irq_disable(struct irq_data *data)

{

	unsigned int irq = data->irq;



	if (irq >= IRQ_AMIGA_CIAB)

		cia_able_irq(&ciab_base, 1 << (irq - IRQ_AMIGA_CIAB));

	else

		cia_able_irq(&ciaa_base, 1 << (irq - IRQ_AMIGA_CIAA));

}



static struct irq_controller cia_irq_controller = {

static struct irq_chip cia_irq_chip = {

	.name		= "cia",

	.lock		= __SPIN_LOCK_UNLOCKED(cia_irq_controller.lock),

	.enable		= cia_enable_irq,

	.disable	= cia_disable_irq,

	.irq_enable	= cia_irq_enable,

	.irq_disable	= cia_irq_disable,

};



/*
@@ -134,9 +136,9 @@ static struct irq_controller cia_irq_controller = { 
 * into this chain.

 */



static void auto_enable_irq(unsigned int irq)

static void auto_irq_enable(struct irq_data *data)

{

	switch (irq) {

	switch (data->irq) {

	case IRQ_AUTO_2:

		amiga_custom.intena = IF_SETCLR | IF_PORTS;

		break;
@@ -146,9 +148,9 @@ static void auto_enable_irq(unsigned int irq) 
	}

}



static void auto_disable_irq(unsigned int irq)

static void auto_irq_disable(struct irq_data *data)

{

	switch (irq) {

	switch (data->irq) {

	case IRQ_AUTO_2:

		amiga_custom.intena = IF_PORTS;

		break;
@@ -158,24 +160,25 @@ static void auto_disable_irq(unsigned int irq) 
	}

}



static struct irq_controller auto_irq_controller = {

static struct irq_chip auto_irq_chip = {

	.name		= "auto",

	.lock		= __SPIN_LOCK_UNLOCKED(auto_irq_controller.lock),

	.enable		= auto_enable_irq,

	.disable	= auto_disable_irq,

	.irq_enable	= auto_irq_enable,

	.irq_disable	= auto_irq_disable,

};



void __init cia_init_IRQ(struct ciabase *base)

{

	m68k_setup_irq_controller(&cia_irq_controller, base->cia_irq, CIA_IRQS);

	m68k_setup_irq_controller(&cia_irq_chip, handle_simple_irq,

				  base->cia_irq, CIA_IRQS);



	/* clear any pending interrupt and turn off all interrupts */

	cia_set_irq(base, CIA_ICR_ALL);

	cia_able_irq(base, CIA_ICR_ALL);



	/* override auto int and install CIA handler */

	m68k_setup_irq_controller(&auto_irq_controller, base->handler_irq, 1);

	m68k_irq_startup(base->handler_irq);

	m68k_setup_irq_controller(&auto_irq_chip, handle_simple_irq,

				  base->handler_irq, 1);

	m68k_irq_startup_irq(base->handler_irq);

	if (request_irq(base->handler_irq, cia_handler, IRQF_SHARED,

			base->name, base))

		pr_err("Couldn't register %s interrupt\n", base->name);