Subversion Repositories or1k

#ifndef _OR1K_IO_HW_SWAP_H

#define _OR1K_IO_HW_SWAP_H

/*

 * swap functions are sometimes needed to interface little-endian hardware

 */

static inline unsigned short _swapw(volatile unsigned short v)

{

    return ((v << 8) | (v >> 8));

}

static inline unsigned int _swapl(volatile unsigned long v)

{

    return ((v << 24) | ((v & 0xff00) << 8) | ((v & 0xff0000) >> 8) | (v >> 24));

}

/*

 * readX/writeX() are used to access memory mapped devices. On some

 * architectures the memory mapped IO stuff needs to be accessed

 * differently. On the m68k architecture, we just read/write the

 * memory location directly.

 */

/* ++roman: The assignments to temp. vars avoid that gcc sometimes generates

 * two accesses to memory, which may be undesireable for some devices.

 */

#define readb(addr) \

    ({ unsigned char __v = (*(volatile unsigned char *) (addr)); __v; })

#define readw(addr) \

    ({ unsigned short __v = (*(volatile unsigned short *) (addr)); __v; })

#define readl(addr) \

    ({ unsigned int __v = (*(volatile unsigned int *) (addr)); __v; })

#define writeb(b,addr) ((*(volatile unsigned char *) (addr)) = (b))

#define writew(b,addr) ((*(volatile unsigned short *) (addr)) = (b))

#define writel(b,addr) ((*(volatile unsigned int *) (addr)) = (b))

/* There is no difference between I/O and memory on 68k, these are the same */

#define inb(addr) \

    ({ unsigned char __v = (*(volatile unsigned char *) (addr)); __v; })

#define inw(addr) \

    ({ unsigned short __v = (*(volatile unsigned short *) (addr)); \

       _swapw(__v); })

#define inl(addr) \

    ({ unsigned int __v = (*(volatile unsigned int *) (addr)); _swapl(__v); })

#define outb(b,addr) ((*(volatile unsigned char *) (addr)) = (b))

#define outw(b,addr) ((*(volatile unsigned short *) (addr)) = (_swapw(b)))

#define outl(b,addr) ((*(volatile unsigned int *) (addr)) = (_swapl(b)))

/* FIXME: these need to be optimized.  Watch out for byte swapping, they

 * are used mostly for Intel devices... */

#define outsw(addr,buf,len) \

    ({ unsigned short * __e = (unsigned short *)(buf) + (len); \

       unsigned short * __p = (unsigned short *)(buf); \

       while (__p < __e) { \

          *(volatile unsigned short *)(addr) = *__p++;\

       } \

     })

#define insw(addr,buf,len) \

    ({ unsigned short * __e = (unsigned short *)(buf) + (len); \

       unsigned short * __p = (unsigned short *)(buf); \

       while (__p < __e) { \

          *(__p++) = *(volatile unsigned short *)(addr); \

       } \

     })

static inline unsigned char get_user_byte_io(const char * addr)

{

        register unsigned char _v;

        __asm__ __volatile__ ("moveb %1,%0":"=dm" (_v):"m" (*addr));

        return _v;

}

#define inb_p(addr) get_user_byte_io((char *)(addr))

static inline void put_user_byte_io(char val,char *addr)

{

        __asm__ __volatile__ ("moveb %0,%1"

                              : /* no outputs */

                              :"idm" (val),"m" (*addr)

                              : "memory");

}

#define outb_p(x,addr) put_user_byte_io((x),(char *)(addr))

/*

 * Change virtual addresses to physical addresses and vv.

 * These are trivial on the 1:1 Linux/i386 mapping (but if we ever

 * make the kernel segment mapped at 0, we need to do translation

 * on the i386 as well)

 */

extern unsigned long mm_vtop(unsigned long addr);

extern unsigned long mm_ptov(unsigned long addr);

extern inline unsigned long virt_to_phys(volatile void * address)

{

        return (unsigned long) mm_vtop((unsigned long)address);

}

extern inline void * phys_to_virt(unsigned long address)

{

        return (void *) mm_ptov(address);

}

/*

 * IO bus memory addresses are also 1:1 with the physical address

 */

#define virt_to_bus virt_to_phys

#define bus_to_virt phys_to_virt

#endif /* _OR1K_IO_HW_SWAP_H */