Subversion Repositories or1k

#ifndef __ALPHA_IO_H

#define __ALPHA_IO_H

/* We don't use IO slowdowns on the Alpha, but.. */

#define __SLOW_DOWN_IO  do { } while (0)

#define SLOW_DOWN_IO    do { } while (0)

/*

 * Virtual -> physical identity mapping starts at this offset

 */

#ifdef USE_48_BIT_KSEG

#define IDENT_ADDR     0xffff800000000000

#else

#define IDENT_ADDR     0xfffffc0000000000

#endif

#ifdef __KERNEL__

#include <linux/config.h>

#include <linux/kernel.h>

#include <asm/system.h>

#include <asm/machvec.h>

#include <asm/hwrpb.h>

/*

 * We try to avoid hae updates (thus the cache), but when we

 * do need to update the hae, we need to do it atomically, so

 * that any interrupts wouldn't get confused with the hae

 * register not being up-to-date with respect to the hardware

 * value.

 */

static inline void __set_hae(unsigned long new_hae)

{

        unsigned long flags;

        __save_and_cli(flags);

        alpha_mv.hae_cache = new_hae;

        *alpha_mv.hae_register = new_hae;

        mb();

        /* Re-read to make sure it was written.  */

        new_hae = *alpha_mv.hae_register;

        __restore_flags(flags);

}

static inline void set_hae(unsigned long new_hae)

{

        if (new_hae != alpha_mv.hae_cache)

                __set_hae(new_hae);

}

/*

 * Change virtual addresses to physical addresses and vv.

 */

#ifdef USE_48_BIT_KSEG

static inline unsigned long virt_to_phys(void *address)

{

        return (unsigned long)address - IDENT_ADDR;

}

static inline void * phys_to_virt(unsigned long address)

{

        return (void *) (address + IDENT_ADDR);

}

#else

static inline unsigned long virt_to_phys(void *address)

{

        unsigned long phys = (unsigned long)address;

        /* Sign-extend from bit 41.  */

        phys <<= (64 - 41);

        phys = (long)phys >> (64 - 41);

        /* Crop to the physical address width of the processor.  */

        phys &= (1ul << hwrpb->pa_bits) - 1;

        return phys;

}

static inline void * phys_to_virt(unsigned long address)

{

        return (void *)(IDENT_ADDR + (address & ((1ul << 41) - 1)));

}

#endif

#define page_to_phys(page)      PAGE_TO_PA(page)

/*

 * Change addresses as seen by the kernel (virtual) to addresses as

 * seen by a device (bus), and vice versa.

 *

 * Note that this only works for a limited range of kernel addresses,

 * and very well may not span all memory.  Consider this interface

 * deprecated in favour of the mapping functions in <asm/pci.h>.

 */

extern unsigned long __direct_map_base;

extern unsigned long __direct_map_size;

static inline unsigned long virt_to_bus(void *address)

{

        unsigned long phys = virt_to_phys(address);

        unsigned long bus = phys + __direct_map_base;

        return phys <= __direct_map_size ? bus : 0;

}

static inline void *bus_to_virt(unsigned long address)

{

        void *virt;

        /* This check is a sanity check but also ensures that bus address 0

           maps to virtual address 0 which is useful to detect null pointers

           (the NCR driver is much simpler if NULL pointers are preserved).  */

        address -= __direct_map_base;

        virt = phys_to_virt(address);

        return (long)address <= 0 ? NULL : virt;

}

#else /* !__KERNEL__ */

/*

 * Define actual functions in private name-space so it's easier to

 * accommodate things like XFree or svgalib that like to define their

 * own versions of inb etc.

 */

extern void __sethae (unsigned long addr);      /* syscall */

extern void _sethae (unsigned long addr);       /* cached version */

#endif /* !__KERNEL__ */

/*

 * There are different chipsets to interface the Alpha CPUs to the world.

 */

#ifdef __KERNEL__

#ifdef CONFIG_ALPHA_GENERIC

/* In a generic kernel, we always go through the machine vector.  */

# define __inb(p)       alpha_mv.mv_inb((unsigned long)(p))

# define __inw(p)       alpha_mv.mv_inw((unsigned long)(p))

# define __inl(p)       alpha_mv.mv_inl((unsigned long)(p))

# define __outb(x,p)    alpha_mv.mv_outb((x),(unsigned long)(p))

# define __outw(x,p)    alpha_mv.mv_outw((x),(unsigned long)(p))

# define __outl(x,p)    alpha_mv.mv_outl((x),(unsigned long)(p))

# define __readb(a)     alpha_mv.mv_readb((unsigned long)(a))

# define __readw(a)     alpha_mv.mv_readw((unsigned long)(a))

# define __readl(a)     alpha_mv.mv_readl((unsigned long)(a))

# define __readq(a)     alpha_mv.mv_readq((unsigned long)(a))

# define __writeb(v,a)  alpha_mv.mv_writeb((v),(unsigned long)(a))

# define __writew(v,a)  alpha_mv.mv_writew((v),(unsigned long)(a))

# define __writel(v,a)  alpha_mv.mv_writel((v),(unsigned long)(a))

# define __writeq(v,a)  alpha_mv.mv_writeq((v),(unsigned long)(a))

# define __ioremap(a,s) alpha_mv.mv_ioremap((unsigned long)(a),(s))

# define __iounmap(a)   alpha_mv.mv_iounmap((unsigned long)(a))

# define __is_ioaddr(a) alpha_mv.mv_is_ioaddr((unsigned long)(a))

# define inb            __inb

# define inw            __inw

# define inl            __inl

# define outb           __outb

# define outw           __outw

# define outl           __outl

# define __raw_readb    __readb

# define __raw_readw    __readw

# define __raw_readl    __readl

# define __raw_readq    __readq

# define __raw_writeb   __writeb

# define __raw_writew   __writew

# define __raw_writel   __writel

# define __raw_writeq   __writeq

#else

/* Control how and what gets defined within the core logic headers.  */

#define __WANT_IO_DEF

#if defined(CONFIG_ALPHA_APECS)

# include <asm/core_apecs.h>

#elif defined(CONFIG_ALPHA_CIA)

# 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)

# include <asm/core_marvel.h>

#elif defined(CONFIG_ALPHA_MCPCIA)

# include <asm/core_mcpcia.h>

#elif defined(CONFIG_ALPHA_POLARIS)

# include <asm/core_polaris.h>

#elif defined(CONFIG_ALPHA_T2)

# include <asm/core_t2.h>

#elif defined(CONFIG_ALPHA_TSUNAMI)

# include <asm/core_tsunami.h>

#elif defined(CONFIG_ALPHA_TITAN)

# include <asm/core_titan.h>

#elif defined(CONFIG_ALPHA_WILDFIRE)

# include <asm/core_wildfire.h>

#else

#error "What system is this?"

#endif

#undef __WANT_IO_DEF

#endif /* GENERIC */

#endif /* __KERNEL__ */

/*

 * The convention used for inb/outb etc. is that names starting with

 * two underscores are the inline versions, names starting with a

 * single underscore are proper functions, and names starting with a

 * letter are macros that map in some way to inline or proper function

 * versions.  Not all that pretty, but before you change it, be sure

 * to convince yourself that it won't break anything (in particular

 * module support).

 */

extern u8               _inb (unsigned long port);

extern u16              _inw (unsigned long port);

extern u32              _inl (unsigned long port);

extern void             _outb (u8 b,unsigned long port);

extern void             _outw (u16 w,unsigned long port);

extern void             _outl (u32 l,unsigned long port);

extern u8               _readb(unsigned long addr);

extern u16              _readw(unsigned long addr);

extern u32              _readl(unsigned long addr);

extern u64              _readq(unsigned long addr);

extern void             _writeb(u8 b, unsigned long addr);

extern void             _writew(u16 b, unsigned long addr);

extern void             _writel(u32 b, unsigned long addr);

extern void             _writeq(u64 b, unsigned long addr);

#ifdef __KERNEL__

/*

 * The platform header files may define some of these macros to use

 * the inlined versions where appropriate.  These macros may also be

 * redefined by userlevel programs.

 */

#ifndef inb

# define inb(p)         _inb(p)

#endif

#ifndef inw

# define inw(p)         _inw(p)

#endif

#ifndef inl

# define inl(p)         _inl(p)

#endif

#ifndef outb

# define outb(b,p)      _outb((b),(p))

#endif

#ifndef outw

# define outw(w,p)      _outw((w),(p))

#endif

#ifndef outl

# define outl(l,p)      _outl((l),(p))

#endif

#ifndef inb_p

# define inb_p          inb

#endif

#ifndef inw_p

# define inw_p          inw

#endif

#ifndef inl_p

# define inl_p          inl

#endif

#ifndef outb_p

# define outb_p         outb

#endif

#ifndef outw_p

# define outw_p         outw

#endif

#ifndef outl_p

# define outl_p         outl

#endif

#define IO_SPACE_LIMIT 0xffff

#else 

/* Userspace declarations.  Kill in 2.5. */

extern unsigned int     inb(unsigned long port);

extern unsigned int     inw(unsigned long port);

extern unsigned int     inl(unsigned long port);

extern void             outb(unsigned char b,unsigned long port);

extern void             outw(unsigned short w,unsigned long port);

extern void             outl(unsigned int l,unsigned long port);

extern unsigned long    readb(unsigned long addr);

extern unsigned long    readw(unsigned long addr);

extern unsigned long    readl(unsigned long addr);

extern void             writeb(unsigned char b, unsigned long addr);

extern void             writew(unsigned short b, unsigned long addr);

extern void             writel(unsigned int b, unsigned long addr);

#endif /* __KERNEL__ */

#ifdef __KERNEL__

/*

 * On Alpha, we have the whole of I/O space mapped at all times, but

 * at odd and sometimes discontinuous addresses.  Note that the

 * discontinuities are all across busses, so we need not care for that

 * for any one device.

 *

 * The DRM drivers need to be able to map contiguously a (potentially)

 * discontiguous set of I/O pages. This set of pages is scatter-gather

 * mapped contiguously from the perspective of the bus, but we can't

 * directly access DMA addresses from the CPU, these addresses need to

 * have a real ioremap. Therefore, iounmap and the size argument to

 * ioremap are needed to give the platforms the ability to fully implement

 * ioremap.

 *

 * Map the I/O space address into the kernel's virtual address space.

 */

static inline void * ioremap(unsigned long offset, unsigned long size)

{

        return (void *) __ioremap(offset, size);

}

static inline void iounmap(void *addr)

{

        __iounmap(addr);

}

static inline void * ioremap_nocache(unsigned long offset, unsigned long size)

{

        return ioremap(offset, size);

}

/* Indirect back to the macros provided.  */

extern u8               ___raw_readb(unsigned long addr);

extern u16              ___raw_readw(unsigned long addr);

extern u32              ___raw_readl(unsigned long addr);

extern u64              ___raw_readq(unsigned long addr);

extern void             ___raw_writeb(u8 b, unsigned long addr);

extern void             ___raw_writew(u16 b, unsigned long addr);

extern void             ___raw_writel(u32 b, unsigned long addr);

extern void             ___raw_writeq(u64 b, unsigned long addr);

#ifdef __raw_readb

# define readb(a)       ({ u8 r_ = __raw_readb(a); mb(); r_; })

#endif

#ifdef __raw_readw

# define readw(a)       ({ u16 r_ = __raw_readw(a); mb(); r_; })

#endif

#ifdef __raw_readl

# define readl(a)       ({ u32 r_ = __raw_readl(a); mb(); r_; })

#endif

#ifdef __raw_readq

# define readq(a)       ({ u64 r_ = __raw_readq(a); mb(); r_; })

#endif

#ifdef __raw_writeb

# define writeb(v,a)    ({ __raw_writeb((v),(a)); mb(); })

#endif

#ifdef __raw_writew

# define writew(v,a)    ({ __raw_writew((v),(a)); mb(); })

#endif

#ifdef __raw_writel

# define writel(v,a)    ({ __raw_writel((v),(a)); mb(); })

#endif

#ifdef __raw_writeq

# define writeq(v,a)    ({ __raw_writeq((v),(a)); mb(); })

#endif

#ifndef __raw_readb

# define __raw_readb(a) ___raw_readb((unsigned long)(a))

#endif

#ifndef __raw_readw

# define __raw_readw(a) ___raw_readw((unsigned long)(a))

#endif

#ifndef __raw_readl

# define __raw_readl(a) ___raw_readl((unsigned long)(a))

#endif

#ifndef __raw_readq

# define __raw_readq(a) ___raw_readq((unsigned long)(a))

#endif

#ifndef __raw_writeb

# define __raw_writeb(v,a)  ___raw_writeb((v),(unsigned long)(a))

#endif

#ifndef __raw_writew

# define __raw_writew(v,a)  ___raw_writew((v),(unsigned long)(a))

#endif

#ifndef __raw_writel

# define __raw_writel(v,a)  ___raw_writel((v),(unsigned long)(a))

#endif

#ifndef __raw_writeq

# define __raw_writeq(v,a)  ___raw_writeq((v),(unsigned long)(a))

#endif

#ifndef readb

# define readb(a)       _readb((unsigned long)(a))

#endif

#ifndef readw

# define readw(a)       _readw((unsigned long)(a))

#endif

#ifndef readl

# define readl(a)       _readl((unsigned long)(a))

#endif

#ifndef readq

# define readq(a)       _readq((unsigned long)(a))

#endif

#ifndef writeb

# define writeb(v,a)    _writeb((v),(unsigned long)(a))

#endif

#ifndef writew

# define writew(v,a)    _writew((v),(unsigned long)(a))

#endif

#ifndef writel

# define writel(v,a)    _writel((v),(unsigned long)(a))

#endif

#ifndef writeq

# define writeq(v,a)    _writeq((v),(unsigned long)(a))

#endif

/*

 * String version of IO memory access ops:

 */

extern void _memcpy_fromio(void *, unsigned long, long);

extern void _memcpy_toio(unsigned long, const void *, long);

extern void _memset_c_io(unsigned long, unsigned long, long);

#define memcpy_fromio(to,from,len) \

  _memcpy_fromio((to),(unsigned long)(from),(len))

#define memcpy_toio(to,from,len) \

  _memcpy_toio((unsigned long)(to),(from),(len))

#define memset_io(addr,c,len) \

  _memset_c_io((unsigned long)(addr),0x0101010101010101UL*(u8)(c),(len))

#define __HAVE_ARCH_MEMSETW_IO

#define memsetw_io(addr,c,len) \

  _memset_c_io((unsigned long)(addr),0x0001000100010001UL*(u16)(c),(len))

/*

 * String versions of in/out ops:

 */

extern void insb (unsigned long port, void *dst, unsigned long count);

extern void insw (unsigned long port, void *dst, unsigned long count);

extern void insl (unsigned long port, void *dst, unsigned long count);

extern void outsb (unsigned long port, const void *src, unsigned long count);

extern void outsw (unsigned long port, const void *src, unsigned long count);

extern void outsl (unsigned long port, const void *src, unsigned long count);

/*

 * XXX - We don't have csum_partial_copy_fromio() yet, so we cheat here and

 * just copy it. The net code will then do the checksum later. Presently

 * only used by some shared memory 8390 Ethernet cards anyway.

 */

#define eth_io_copy_and_sum(skb,src,len,unused) \

  memcpy_fromio((skb)->data,(src),(len))

#define isa_eth_io_copy_and_sum(skb,src,len,unused) \

  isa_memcpy_fromio((skb)->data,(src),(len))

static inline int

check_signature(unsigned long io_addr, const unsigned char *signature,

                int length)

{

        int retval = 0;

        do {

                if (readb(io_addr) != *signature)

                        goto out;

                io_addr++;

                signature++;

                length--;

        } while (length);

        retval = 1;

out:

        return retval;

}

/*

 * ISA space is mapped to some machine-specific location on Alpha.

 * Call into the existing hooks to get the address translated.

 */

#define isa_readb(a)                    readb(__ioremap((a),1))

#define isa_readw(a)                    readw(__ioremap((a),2))

#define isa_readl(a)                    readl(__ioremap((a),4))

#define isa_writeb(b,a)                 writeb((b),__ioremap((a),1))

#define isa_writew(w,a)                 writew((w),__ioremap((a),2))

#define isa_writel(l,a)                 writel((l),__ioremap((a),4))

#define isa_memset_io(a,b,c)            memset_io(__ioremap((a),(c)),(b),(c))

#define isa_memcpy_fromio(a,b,c)        memcpy_fromio((a),__ioremap((b),(c)),(c))

#define isa_memcpy_toio(a,b,c)          memcpy_toio(__ioremap((a),(c)),(b),(c))

static inline int

isa_check_signature(unsigned long io_addr, const unsigned char *signature,

                int length)

{

        int retval = 0;

        do {

                if (isa_readb(io_addr) != *signature)

                        goto out;

                io_addr++;

                signature++;

                length--;

        } while (length);

        retval = 1;

out:

        return retval;

}

/*

 * 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

/* Nothing to do */

#define dma_cache_inv(_start,_size)             do { } while (0)

#define dma_cache_wback(_start,_size)           do { } while (0)

#define dma_cache_wback_inv(_start,_size)       do { } while (0)

#endif /* __KERNEL__ */

#endif /* __ALPHA_IO_H */