Commit f81f335a authored by Arnd Bergmann's avatar Arnd Bergmann
Browse files

alpha: remove DECpc AXP150 (Jensen) support 



This is one of the hackiest Alpha machines, and the only one without
PCI support. Removing this allows cleaning up code in eise and tty
drivers in addition to the architecture code.

Acked-by: default avatarPaul E. McKenney <paulmck@kernel.org>
Acked-by: default avatarMatt Turner <mattst88@gmail.com>
Signed-off-by: default avatarArnd Bergmann <arnd@arndb.de>
parent 82c525bf

Documentation/driver-api/eisa.rst

+2 −2
Original line number Diff line number Diff line
@@ -196,8 +196,8 @@ eisa_bus.disable_dev 
virtual_root.force_probe

	Force the probing code to probe EISA slots even when it cannot find an

	EISA compliant mainboard (nothing appears on slot 0). Defaults to 0

	(don't force), and set to 1 (force probing) when either

	CONFIG_ALPHA_JENSEN or CONFIG_EISA_VLB_PRIMING are set.

	(don't force), and set to 1 (force probing) when

	CONFIG_EISA_VLB_PRIMING is set.



Random notes

============

arch/alpha/Kconfig

+3 −15
Original line number Diff line number Diff line
@@ -10,7 +10,7 @@ config ALPHA 
	select ARCH_NO_SG_CHAIN

	select ARCH_USE_CMPXCHG_LOCKREF

	select DMA_OPS if PCI

	select FORCE_PCI if !ALPHA_JENSEN

	select FORCE_PCI

	select PCI_DOMAINS if PCI

	select PCI_SYSCALL if PCI

	select HAVE_ASM_MODVERSIONS
@@ -99,7 +99,6 @@ choice 
	  EB64+               EB64+ 21064 evaluation board

	  EB66                EB66 21066 evaluation board

	  EB66+               EB66+ 21066 evaluation board

	  Jensen              DECpc 150, DEC 2000 models 300, 500

	  LX164               AlphaPC164-LX

	  Lynx                AS 2100A

	  Miata               Personal Workstation 433/500/600 a/au
@@ -198,17 +197,6 @@ config ALPHA_EIGER 
	  Apparently an obscure OEM single-board computer based on the

	  Typhoon/Tsunami chipset family. Information on it is scanty.



config ALPHA_JENSEN

	bool "Jensen"

	select HAVE_EISA

	help

	  DEC PC 150 AXP (aka Jensen): This is a very old Digital system - one

	  of the first-generation Alpha systems. A number of these systems

	  seem to be available on the second- hand market. The Jensen is a

	  floor-standing tower system which originally used a 150MHz 21064 It

	  used programmable logic to interface a 486 EISA I/O bridge to the

	  CPU.



config ALPHA_LX164

	bool "LX164"

	help
@@ -337,7 +325,7 @@ config ALPHA_NONAME 


config ALPHA_EV4

	bool

	depends on ALPHA_JENSEN || (ALPHA_SABLE && !ALPHA_GAMMA) || ALPHA_LYNX || ALPHA_NORITAKE && !ALPHA_PRIMO || ALPHA_MIKASA && !ALPHA_PRIMO || ALPHA_CABRIOLET || ALPHA_AVANTI_CH || ALPHA_EB64P_CH || ALPHA_XL || ALPHA_NONAME || ALPHA_EB66 || ALPHA_EB66P || ALPHA_P2K

	depends on (ALPHA_SABLE && !ALPHA_GAMMA) || ALPHA_LYNX || ALPHA_NORITAKE && !ALPHA_PRIMO || ALPHA_MIKASA && !ALPHA_PRIMO || ALPHA_CABRIOLET || ALPHA_AVANTI_CH || ALPHA_EB64P_CH || ALPHA_XL || ALPHA_NONAME || ALPHA_EB66 || ALPHA_EB66P || ALPHA_P2K

	default y if !ALPHA_LYNX

	default y if !ALPHA_EV5
@@ -483,7 +471,7 @@ config ALPHA_QEMU 
config ALPHA_SRM

	bool "Use SRM as bootloader" if ALPHA_CABRIOLET || ALPHA_AVANTI_CH || ALPHA_EB64P || ALPHA_PC164 || ALPHA_TAKARA || ALPHA_EB164 || ALPHA_ALCOR || ALPHA_MIATA || ALPHA_LX164 || ALPHA_SX164 || ALPHA_NAUTILUS || ALPHA_NONAME

	depends on TTY

	default y if ALPHA_JENSEN || ALPHA_MIKASA || ALPHA_SABLE || ALPHA_LYNX || ALPHA_NORITAKE || ALPHA_DP264 || ALPHA_RAWHIDE || ALPHA_EIGER || ALPHA_WILDFIRE || ALPHA_TITAN || ALPHA_SHARK || ALPHA_MARVEL

	default y if ALPHA_MIKASA || ALPHA_SABLE || ALPHA_LYNX || ALPHA_NORITAKE || ALPHA_DP264 || ALPHA_RAWHIDE || ALPHA_EIGER || ALPHA_WILDFIRE || ALPHA_TITAN || ALPHA_SHARK || ALPHA_MARVEL

	help

	  There are two different types of booting firmware on Alphas: SRM,

	  which is command line driven, and ARC, which uses menus and arrow

arch/alpha/include/asm/dma-mapping.h

+0 −4
Original line number Diff line number Diff line
@@ -6,11 +6,7 @@ extern const struct dma_map_ops alpha_pci_ops; 


static inline const struct dma_map_ops *get_arch_dma_ops(void)

{

#ifdef CONFIG_ALPHA_JENSEN

	return NULL;

#else

	return &alpha_pci_ops;

#endif

}



#endif	/* _ALPHA_DMA_MAPPING_H */

arch/alpha/include/asm/io.h

+1 −19
Original line number Diff line number Diff line
@@ -209,8 +209,6 @@ static inline int generic_is_mmio(const volatile void __iomem *a) 
# include <asm/core_cia.h>

#elif defined(CONFIG_ALPHA_IRONGATE)

# include <asm/core_irongate.h>

#elif defined(CONFIG_ALPHA_JENSEN)

# include <asm/jensen.h>

#elif defined(CONFIG_ALPHA_LCA)

# include <asm/core_lca.h>

#elif defined(CONFIG_ALPHA_MARVEL)
@@ -631,23 +629,7 @@ extern void outsl (unsigned long port, const void *src, unsigned long count); 
#define outsw outsw

#define outsl outsl



/*

 * The Alpha Jensen hardware for some rather strange reason puts

 * the RTC clock at 0x170 instead of 0x70. Probably due to some

 * misguided idea about using 0x70 for NMI stuff.

 *

 * These defines will override the defaults when doing RTC queries

 */



#ifdef CONFIG_ALPHA_GENERIC

# define RTC_PORT(x)	((x) + alpha_mv.rtc_port)

#else

# ifdef CONFIG_ALPHA_JENSEN

#  define RTC_PORT(x)	(0x170+(x))

# else

#define RTC_PORT(x)	(0x70 + (x))

# endif

#endif

#define RTC_ALWAYS_BCD	0



/*

arch/alpha/include/asm/jensen.h

deleted100644 → 0
+0 −363
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

#ifndef __ALPHA_JENSEN_H

#define __ALPHA_JENSEN_H



#include <asm/compiler.h>



/*

 * Defines for the AlphaPC EISA IO and memory address space.

 */



/*

 * NOTE! The memory operations do not set any memory barriers, as it's

 * not needed for cases like a frame buffer that is essentially memory-like.

 * You need to do them by hand if the operations depend on ordering.

 *

 * Similarly, the port IO operations do a "mb" only after a write operation:

 * if an mb is needed before (as in the case of doing memory mapped IO

 * first, and then a port IO operation to the same device), it needs to be

 * done by hand.

 *

 * After the above has bitten me 100 times, I'll give up and just do the

 * mb all the time, but right now I'm hoping this will work out.  Avoiding

 * mb's may potentially be a noticeable speed improvement, but I can't

 * honestly say I've tested it.

 *

 * Handling interrupts that need to do mb's to synchronize to non-interrupts

 * is another fun race area.  Don't do it (because if you do, I'll have to

 * do *everything* with interrupts disabled, ugh).

 */



/*

 * EISA Interrupt Acknowledge address

 */

#define EISA_INTA		(IDENT_ADDR + 0x100000000UL)



/*

 * FEPROM addresses

 */

#define EISA_FEPROM0		(IDENT_ADDR + 0x180000000UL)

#define EISA_FEPROM1		(IDENT_ADDR + 0x1A0000000UL)



/*

 * VL82C106 base address

 */

#define EISA_VL82C106		(IDENT_ADDR + 0x1C0000000UL)



/*

 * EISA "Host Address Extension" address (bits 25-31 of the EISA address)

 */

#define EISA_HAE		(IDENT_ADDR + 0x1D0000000UL)



/*

 * "SYSCTL" register address

 */

#define EISA_SYSCTL		(IDENT_ADDR + 0x1E0000000UL)



/*

 * "spare" register address

 */

#define EISA_SPARE		(IDENT_ADDR + 0x1F0000000UL)



/*

 * EISA memory address offset

 */

#define EISA_MEM		(IDENT_ADDR + 0x200000000UL)



/*

 * EISA IO address offset

 */

#define EISA_IO			(IDENT_ADDR + 0x300000000UL)





#ifdef __KERNEL__



#ifndef __EXTERN_INLINE

#define __EXTERN_INLINE extern inline

#define __IO_EXTERN_INLINE

#endif



/*

 * Handle the "host address register". This needs to be set

 * to the high 7 bits of the EISA address.  This is also needed

 * for EISA IO addresses, which are only 16 bits wide (the

 * hae needs to be set to 0).

 *

 * HAE isn't needed for the local IO operations, though.

 */



#define JENSEN_HAE_ADDRESS	EISA_HAE

#define JENSEN_HAE_MASK		0x1ffffff



__EXTERN_INLINE void jensen_set_hae(unsigned long addr)

{

	/* hae on the Jensen is bits 31:25 shifted right */

	addr >>= 25;

	if (addr != alpha_mv.hae_cache)

		set_hae(addr);

}



#define vuip	volatile unsigned int *

#define vulp	volatile unsigned long *



/*

 * IO functions

 *

 * The "local" functions are those that don't go out to the EISA bus,

 * but instead act on the VL82C106 chip directly.. This is mainly the

 * keyboard, RTC,  printer and first two serial lines..

 *

 * The local stuff makes for some complications, but it seems to be

 * gone in the PCI version. I hope I can get DEC suckered^H^H^H^H^H^H^H^H

 * convinced that I need one of the newer machines.

 */



__EXTERN_INLINE unsigned int jensen_local_inb(unsigned long addr)

{

	return 0xff & *(vuip)((addr << 9) + EISA_VL82C106);

}



__EXTERN_INLINE void jensen_local_outb(u8 b, unsigned long addr)

{

	*(vuip)((addr << 9) + EISA_VL82C106) = b;

	mb();

}



__EXTERN_INLINE unsigned int jensen_bus_inb(unsigned long addr)

{

	long result;



	jensen_set_hae(0);

	result = *(volatile int *)((addr << 7) + EISA_IO + 0x00);

	return __kernel_extbl(result, addr & 3);

}



__EXTERN_INLINE void jensen_bus_outb(u8 b, unsigned long addr)

{

	jensen_set_hae(0);

	*(vuip)((addr << 7) + EISA_IO + 0x00) = b * 0x01010101;

	mb();

}



/*

 * It seems gcc is not very good at optimizing away logical

 * operations that result in operations across inline functions.

 * Which is why this is a macro.

 */



#define jensen_is_local(addr) ( \

/* keyboard */	(addr == 0x60 || addr == 0x64) || \

/* RTC */	(addr == 0x170 || addr == 0x171) || \

/* mb COM2 */	(addr >= 0x2f8 && addr <= 0x2ff) || \

/* mb LPT1 */	(addr >= 0x3bc && addr <= 0x3be) || \

/* mb COM2 */	(addr >= 0x3f8 && addr <= 0x3ff))



__EXTERN_INLINE u8 jensen_inb(unsigned long addr)

{

	if (jensen_is_local(addr))

		return jensen_local_inb(addr);

	else

		return jensen_bus_inb(addr);

}



__EXTERN_INLINE void jensen_outb(u8 b, unsigned long addr)

{

	if (jensen_is_local(addr))

		jensen_local_outb(b, addr);

	else

		jensen_bus_outb(b, addr);

}



__EXTERN_INLINE u16 jensen_inw(unsigned long addr)

{

	long result;



	jensen_set_hae(0);

	result = *(volatile int *) ((addr << 7) + EISA_IO + 0x20);

	result >>= (addr & 3) * 8;

	return 0xffffUL & result;

}



__EXTERN_INLINE u32 jensen_inl(unsigned long addr)

{

	jensen_set_hae(0);

	return *(vuip) ((addr << 7) + EISA_IO + 0x60);

}



__EXTERN_INLINE u64 jensen_inq(unsigned long addr)

{

	jensen_set_hae(0);

	return *(vulp) ((addr << 7) + EISA_IO + 0x60);

}



__EXTERN_INLINE void jensen_outw(u16 b, unsigned long addr)

{

	jensen_set_hae(0);

	*(vuip) ((addr << 7) + EISA_IO + 0x20) = b * 0x00010001;

	mb();

}



__EXTERN_INLINE void jensen_outl(u32 b, unsigned long addr)

{

	jensen_set_hae(0);

	*(vuip) ((addr << 7) + EISA_IO + 0x60) = b;

	mb();

}



__EXTERN_INLINE void jensen_outq(u64 b, unsigned long addr)

{

	jensen_set_hae(0);

	*(vulp) ((addr << 7) + EISA_IO + 0x60) = b;

	mb();

}



/*

 * Memory functions.

 */



__EXTERN_INLINE u8 jensen_readb(const volatile void __iomem *xaddr)

{

	unsigned long addr = (unsigned long) xaddr;

	long result;



	jensen_set_hae(addr);

	addr &= JENSEN_HAE_MASK;

	result = *(volatile int *) ((addr << 7) + EISA_MEM + 0x00);

	result >>= (addr & 3) * 8;

	return 0xffUL & result;

}



__EXTERN_INLINE u16 jensen_readw(const volatile void __iomem *xaddr)

{

	unsigned long addr = (unsigned long) xaddr;

	long result;



	jensen_set_hae(addr);

	addr &= JENSEN_HAE_MASK;

	result = *(volatile int *) ((addr << 7) + EISA_MEM + 0x20);

	result >>= (addr & 3) * 8;

	return 0xffffUL & result;

}



__EXTERN_INLINE u32 jensen_readl(const volatile void __iomem *xaddr)

{

	unsigned long addr = (unsigned long) xaddr;

	jensen_set_hae(addr);

	addr &= JENSEN_HAE_MASK;

	return *(vuip) ((addr << 7) + EISA_MEM + 0x60);

}



__EXTERN_INLINE u64 jensen_readq(const volatile void __iomem *xaddr)

{

	unsigned long addr = (unsigned long) xaddr;

	unsigned long r0, r1;



	jensen_set_hae(addr);

	addr &= JENSEN_HAE_MASK;

	addr = (addr << 7) + EISA_MEM + 0x60;

	r0 = *(vuip) (addr);

	r1 = *(vuip) (addr + (4 << 7));

	return r1 << 32 | r0;

}



__EXTERN_INLINE void jensen_writeb(u8 b, volatile void __iomem *xaddr)

{

	unsigned long addr = (unsigned long) xaddr;

	jensen_set_hae(addr);

	addr &= JENSEN_HAE_MASK;

	*(vuip) ((addr << 7) + EISA_MEM + 0x00) = b * 0x01010101;

}



__EXTERN_INLINE void jensen_writew(u16 b, volatile void __iomem *xaddr)

{

	unsigned long addr = (unsigned long) xaddr;

	jensen_set_hae(addr);

	addr &= JENSEN_HAE_MASK;

	*(vuip) ((addr << 7) + EISA_MEM + 0x20) = b * 0x00010001;

}



__EXTERN_INLINE void jensen_writel(u32 b, volatile void __iomem *xaddr)

{

	unsigned long addr = (unsigned long) xaddr;

	jensen_set_hae(addr);

	addr &= JENSEN_HAE_MASK;

	*(vuip) ((addr << 7) + EISA_MEM + 0x60) = b;

}



__EXTERN_INLINE void jensen_writeq(u64 b, volatile void __iomem *xaddr)

{

	unsigned long addr = (unsigned long) xaddr;

	jensen_set_hae(addr);

	addr &= JENSEN_HAE_MASK;

	addr = (addr << 7) + EISA_MEM + 0x60;

	*(vuip) (addr) = b;

	*(vuip) (addr + (4 << 7)) = b >> 32;

}



__EXTERN_INLINE void __iomem *jensen_ioportmap(unsigned long addr)

{

	return (void __iomem *)addr;

}



__EXTERN_INLINE void __iomem *jensen_ioremap(unsigned long addr,

					     unsigned long size)

{

	return (void __iomem *)(addr + 0x100000000ul);

}



__EXTERN_INLINE int jensen_is_ioaddr(unsigned long addr)

{

	return (long)addr >= 0;

}



__EXTERN_INLINE int jensen_is_mmio(const volatile void __iomem *addr)

{

	return (unsigned long)addr >= 0x100000000ul;

}



/* New-style ioread interface.  All the routines are so ugly for Jensen

   that it doesn't make sense to merge them.  */



#define IOPORT(OS, NS)							\

__EXTERN_INLINE u##NS jensen_ioread##NS(const void __iomem *xaddr)	\

{									\

	if (jensen_is_mmio(xaddr))					\

		return jensen_read##OS(xaddr - 0x100000000ul);		\

	else								\

		return jensen_in##OS((unsigned long)xaddr);		\

}									\

__EXTERN_INLINE void jensen_iowrite##NS(u##NS b, void __iomem *xaddr)	\

{									\

	if (jensen_is_mmio(xaddr))					\

		jensen_write##OS(b, xaddr - 0x100000000ul);		\

	else								\

		jensen_out##OS(b, (unsigned long)xaddr);		\

}



IOPORT(b, 8)

IOPORT(w, 16)

IOPORT(l, 32)

IOPORT(q, 64)



#undef IOPORT



#undef vuip

#undef vulp



#undef __IO_PREFIX

#define __IO_PREFIX		jensen

#define jensen_trivial_rw_bw	0

#define jensen_trivial_rw_lq	0

#define jensen_trivial_io_bw	0

#define jensen_trivial_io_lq	0

#define jensen_trivial_iounmap	1

#include <asm/io_trivial.h>



#ifdef __IO_EXTERN_INLINE

#undef __EXTERN_INLINE

#undef __IO_EXTERN_INLINE

#endif



#endif /* __KERNEL__ */



#endif /* __ALPHA_JENSEN_H */