[POWERPC] Remove APUS support from arch/ppc

	  Select PReP if configuring for a PReP machine.

	  Select Gemini if configuring for a Synergy Microsystems' Gemini

	  series Single Board Computer.  More information is available at:

	  <http://www.synergymicro.com/PressRel/97_10_15.html>.

	  Select APUS if configuring for a PowerUP Amiga.  More information is

	  available at: <http://linux-apus.sourceforge.net/>.

config PPC_PREP

	bool "PReP"

config APUS

	bool "Amiga-APUS"

	depends on BROKEN

	help

	  Select APUS if configuring for a PowerUP Amiga.

	  More information is available at:

	  <http://linux-apus.sourceforge.net/>.

config KATANA

	bool "Artesyn-Katana"

	help

	  some command-line options at build time by entering them here.  In

	  most cases you will need to specify the root device here.

config AMIGA

	bool

	depends on APUS

	default y

	help

	  This option enables support for the Amiga series of computers.

config ZORRO

	bool

	depends on APUS

	default y

	help

	  This enables support for the Zorro bus in the Amiga. If you have

	  expansion cards in your Amiga that conform to the Amiga

	  AutoConfig(tm) specification, say Y, otherwise N. Note that even

	  expansion cards that do not fit in the Zorro slots but fit in e.g.

	  the CPU slot may fall in this category, so you have to say Y to let

	  Linux use these.

config ABSTRACT_CONSOLE

	bool

	depends on APUS

	default y

config APUS_FAST_EXCEPT

	bool

	depends on APUS

	default y

config AMIGA_PCMCIA

	bool "Amiga 1200/600 PCMCIA support"

	depends on APUS && EXPERIMENTAL

	help

	  Include support in the kernel for pcmcia on Amiga 1200 and Amiga

	  600. If you intend to use pcmcia cards say Y; otherwise say N.

config AMIGA_BUILTIN_SERIAL

	tristate "Amiga builtin serial support"

	depends on APUS

	help

	  If you want to use your Amiga's built-in serial port in Linux,

	  answer Y.

	  To compile this driver as a module, choose M here.

config GVPIOEXT

	tristate "GVP IO-Extender support"

	depends on APUS

	help

	  If you want to use a GVP IO-Extender serial card in Linux, say Y.

	  Otherwise, say N.

config GVPIOEXT_LP

	tristate "GVP IO-Extender parallel printer support"

	depends on GVPIOEXT

	help

	  Say Y to enable driving a printer from the parallel port on your

	  GVP IO-Extender card, N otherwise.

config GVPIOEXT_PLIP

	tristate "GVP IO-Extender PLIP support"

	depends on GVPIOEXT

	help

	  Say Y to enable doing IP over the parallel port on your GVP

	  IO-Extender card, N otherwise.

config MULTIFACE_III_TTY

	tristate "Multiface Card III serial support"

	depends on APUS

	help

	  If you want to use a Multiface III card's serial port in Linux,

	  answer Y.

	  To compile this driver as a module, choose M here.

config A2232

	tristate "Commodore A2232 serial support (EXPERIMENTAL)"

	depends on EXPERIMENTAL && APUS

	---help---

	  This option supports the 2232 7-port serial card shipped with the

	  Amiga 2000 and other Zorro-bus machines, dating from 1989.  At

	  a max of 19,200 bps, the ports are served by a 6551 ACIA UART chip

	  each, plus a 8520 CIA, and a master 6502 CPU and buffer as well. The

	  ports were connected with 8 pin DIN connectors on the card bracket,

	  for which 8 pin to DB25 adapters were supplied. The card also had

	  jumpers internally to toggle various pinning configurations.

	  This driver can be built as a module; but then "generic_serial"

	  will also be built as a module. This has to be loaded before

	  "ser_a2232". If you want to do this, answer M here.

config WHIPPET_SERIAL

	tristate "Hisoft Whippet PCMCIA serial support"

	depends on AMIGA_PCMCIA

	help

	  HiSoft has a web page at <http://www.hisoft.co.uk/>, but there

	  is no listing for the Whippet in their Amiga section.

config APNE

	tristate "PCMCIA NE2000 support"

	depends on AMIGA_PCMCIA

	help

	  If you have a PCMCIA NE2000 compatible adapter, say Y.  Otherwise,

	  say N.

	  To compile this driver as a module, choose M here: the

	  module will be called apne.

config SERIAL_CONSOLE

	bool "Support for serial port console"

	depends on APUS && (AMIGA_BUILTIN_SERIAL=y || GVPIOEXT=y || MULTIFACE_III_TTY=y)

config HEARTBEAT

	bool "Use power LED as a heartbeat"

	depends on APUS

	help

	  Use the power-on LED on your machine as a load meter.  The exact

	  behavior is platform-dependent, but normally the flash frequency is

	  a hyperbolic function of the 5-minute load average.

config PROC_HARDWARE

	bool "/proc/hardware support"

	depends on APUS

source "drivers/zorro/Kconfig"

if !44x || BROKEN

source kernel/power/Kconfig

endif

config PCI

	bool "PCI support" if 40x || CPM2 || 83xx || 85xx || PPC_MPC52xx

	default y if !40x && !CPM2 && !8xx && !APUS && !83xx && !85xx

	default PCI_PERMEDIA if !4xx && !CPM2 && !8xx && APUS

	default y if !40x && !CPM2 && !8xx && !83xx && !85xx

	default PCI_QSPAN if !4xx && !CPM2 && 8xx

	help

	  Find out whether your system includes a PCI bus. PCI is the name of

endchoice

config PCI_PERMEDIA

	bool "PCI for Permedia2"

	depends on !4xx && !8xx && APUS

source "drivers/pci/Kconfig"

source "drivers/pcmcia/Kconfig"

core-$(CONFIG_85xx)		+= arch/ppc/platforms/85xx/

core-$(CONFIG_MATH_EMULATION)	+= arch/powerpc/math-emu/

core-$(CONFIG_XMON)		+= arch/ppc/xmon/

core-$(CONFIG_APUS)		+= arch/ppc/amiga/

drivers-$(CONFIG_8xx)		+= arch/ppc/8xx_io/

drivers-$(CONFIG_4xx)		+= arch/ppc/4xx_io/

drivers-$(CONFIG_CPM2)		+= arch/ppc/8260_io/

#

# Makefile for Linux arch/m68k/amiga source directory

#

obj-y		:= config.o amiints.o cia.o time.o bootinfo.o amisound.o \

			chipram.o amiga_ksyms.o

obj-$(CONFIG_AMIGA_PCMCIA) += pcmcia.o

#include "../../m68k/amiga/amiga_ksyms.c"

/*

 * 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 SA_INTERRUPT 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/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/system.h>

#include <asm/irq.h>

#include <asm/traps.h>

#include <asm/amigahw.h>

#include <asm/amigaints.h>

#include <asm/amipcmcia.h>

#ifdef CONFIG_APUS

#include <asm/amigappc.h>

#endif

extern void cia_init_IRQ(struct ciabase *base);

unsigned short ami_intena_vals[AMI_STD_IRQS] = {

	IF_VERTB, IF_COPER, IF_AUD0, IF_AUD1, IF_AUD2, IF_AUD3, IF_BLIT,

	IF_DSKSYN, IF_DSKBLK, IF_RBF, IF_TBE, IF_SOFT, IF_PORTS, IF_EXTER

};

static const unsigned char ami_servers[AMI_STD_IRQS] = {

	1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1

};

static short ami_ablecount[AMI_IRQS];

static void ami_badint(int irq, void *dev_id, struct pt_regs *fp)

{

/*	num_spurious += 1;*/

}

/*

 * void amiga_init_IRQ(void)

 *

 * Parameters:	None

 *

 * Returns:	Nothing

 *

 * This function should be called during kernel startup to initialize

 * the amiga IRQ handling routines.

 */

__init

void amiga_init_IRQ(void)

{

	int i;

	for (i = 0; i < AMI_IRQS; i++)

		ami_ablecount[i] = 0;

	/* turn off PCMCIA interrupts */

	if (AMIGAHW_PRESENT(PCMCIA))

		gayle.inten = GAYLE_IRQ_IDE;

	/* turn off all interrupts... */

	amiga_custom.intena = 0x7fff;

	amiga_custom.intreq = 0x7fff;

#ifdef CONFIG_APUS

	/* Clear any inter-CPU interrupt requests. Circumvents bug in

           Blizzard IPL emulation HW (or so it appears). */

	APUS_WRITE(APUS_INT_LVL, INTLVL_SETRESET | INTLVL_MASK);

	/* Init IPL emulation. */

	APUS_WRITE(APUS_REG_INT, REGINT_INTMASTER | REGINT_ENABLEIPL);

	APUS_WRITE(APUS_IPL_EMU, IPLEMU_DISABLEINT);

	APUS_WRITE(APUS_IPL_EMU, IPLEMU_SETRESET | IPLEMU_IPLMASK);

#endif

	/* ... and enable the master interrupt bit */

	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.

 * Note that this may affect other interrupts in case of a shared interrupt.

 * This function should only be called for a _very_ short time to change some

 * internal data, that may not be changed by the interrupt at the same time.

 * ami_(enable|disable)_irq calls may also be nested.

 */

void amiga_enable_irq(unsigned int irq)

{

	if (irq >= AMI_IRQS) {

		printk("%s: Unknown IRQ %d\n", __FUNCTION__, irq);

		return;

	}

	ami_ablecount[irq]--;

	if (ami_ablecount[irq]<0)

		ami_ablecount[irq]=0;

	else if (ami_ablecount[irq])

		return;

	/* No action for auto-vector interrupts */

	if (irq >= IRQ_AMIGA_AUTO){

		printk("%s: Trying to enable auto-vector IRQ %i\n",

		       __FUNCTION__, irq - IRQ_AMIGA_AUTO);

		return;

	}

	if (irq >= IRQ_AMIGA_CIAA) {

		cia_set_irq(irq, 0);

		cia_able_irq(irq, 1);

		return;

	}

	/* enable the interrupt */

	amiga_custom.intena = IF_SETCLR | ami_intena_vals[irq];

}

void amiga_disable_irq(unsigned int irq)

{

	if (irq >= AMI_IRQS) {

		printk("%s: Unknown IRQ %d\n", __FUNCTION__, irq);

		return;

	}

	if (ami_ablecount[irq]++)

		return;

	/* No action for auto-vector interrupts */

	if (irq >= IRQ_AMIGA_AUTO) {

		printk("%s: Trying to disable auto-vector IRQ %i\n",

		       __FUNCTION__, irq - IRQ_AMIGA_AUTO);

		return;

	}

	if (irq >= IRQ_AMIGA_CIAA) {

		cia_able_irq(irq, 0);

		return;

	}

	/* disable the interrupt */

	amiga_custom.intena = ami_intena_vals[irq];

}

inline void amiga_do_irq(int irq, struct pt_regs *fp)

{

	irq_desc_t *desc = irq_desc + irq;

	struct irqaction *action = desc->action;

	kstat_cpu(0).irqs[irq]++;

	action->handler(irq, action->dev_id, fp);

}

void amiga_do_irq_list(int irq, struct pt_regs *fp)

{

	irq_desc_t *desc = irq_desc + irq;

	struct irqaction *action;

	kstat_cpu(0).irqs[irq]++;

	amiga_custom.intreq = ami_intena_vals[irq];

	for (action = desc->action; action; action = action->next)

		action->handler(irq, action->dev_id, fp);

}

/*

 * The builtin Amiga hardware interrupt handlers.

 */

static void ami_int1(int irq, void *dev_id, struct pt_regs *fp)

{

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

	/* if serial transmit buffer empty, interrupt */

	if (ints & IF_TBE) {

		amiga_custom.intreq = IF_TBE;

		amiga_do_irq(IRQ_AMIGA_TBE, fp);

	}

	/* if floppy disk transfer complete, interrupt */

	if (ints & IF_DSKBLK) {

		amiga_custom.intreq = IF_DSKBLK;

		amiga_do_irq(IRQ_AMIGA_DSKBLK, fp);

	}

	/* if software interrupt set, interrupt */

	if (ints & IF_SOFT) {

		amiga_custom.intreq = IF_SOFT;

		amiga_do_irq(IRQ_AMIGA_SOFT, fp);

	}

}

static void ami_int3(int irq, void *dev_id, struct pt_regs *fp)

{

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

	/* if a blitter interrupt */

	if (ints & IF_BLIT) {

		amiga_custom.intreq = IF_BLIT;

		amiga_do_irq(IRQ_AMIGA_BLIT, fp);

	}

	/* if a copper interrupt */

	if (ints & IF_COPER) {

		amiga_custom.intreq = IF_COPER;

		amiga_do_irq(IRQ_AMIGA_COPPER, fp);

	}

	/* if a vertical blank interrupt */

	if (ints & IF_VERTB)

		amiga_do_irq_list(IRQ_AMIGA_VERTB, fp);

}

static void ami_int4(int irq, void *dev_id, struct pt_regs *fp)

{

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

	/* if audio 0 interrupt */

	if (ints & IF_AUD0) {

		amiga_custom.intreq = IF_AUD0;

		amiga_do_irq(IRQ_AMIGA_AUD0, fp);

	}

	/* if audio 1 interrupt */

	if (ints & IF_AUD1) {

		amiga_custom.intreq = IF_AUD1;

		amiga_do_irq(IRQ_AMIGA_AUD1, fp);

	}

	/* if audio 2 interrupt */

	if (ints & IF_AUD2) {

		amiga_custom.intreq = IF_AUD2;

		amiga_do_irq(IRQ_AMIGA_AUD2, fp);

	}

	/* if audio 3 interrupt */

	if (ints & IF_AUD3) {

		amiga_custom.intreq = IF_AUD3;

		amiga_do_irq(IRQ_AMIGA_AUD3, fp);

	}

}

static void ami_int5(int irq, void *dev_id, struct pt_regs *fp)

{

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

		amiga_do_irq(IRQ_AMIGA_RBF, fp);

	}

	/* if a disk sync interrupt */

	if (ints & IF_DSKSYN) {

		amiga_custom.intreq = IF_DSKSYN;

		amiga_do_irq(IRQ_AMIGA_DSKSYN, fp);

	}

}

static void ami_int7(int irq, void *dev_id, struct pt_regs *fp)

{

	panic ("level 7 interrupt received\n");

}

#ifdef CONFIG_APUS

/* The PPC irq handling links all handlers requested on the same vector

   and executes them in a loop. Having ami_badint at the end of the chain

   is a bad idea. */

struct irqaction amiga_sys_irqaction[AUTO_IRQS] = {

	{ .handler = ami_badint, .name = "spurious int" },

	{ .handler = ami_int1, .name = "int1 handler" },

	{ 0, /* CIAA */ },

	{ .handler = ami_int3, .name = "int3 handler" },

	{ .handler = ami_int4, .name = "int4 handler" },

	{ .handler = ami_int5, .name = "int5 handler" },

	{ 0, /* CIAB */ },

	{ .handler = ami_int7, .name = "int7 handler" },

};

#else

void (*amiga_default_handler[SYS_IRQS])(int, void *, struct pt_regs *) = {

	ami_badint, ami_int1, ami_badint, ami_int3,

	ami_int4, ami_int5, ami_badint, ami_int7

};

#endif