FreeBSD/Linux Kernel Cross Reference
sys/include/asm-alpha/core_polaris.h

     #ifndef __ALPHA_POLARIS__H__
     #define __ALPHA_POLARIS__H__
     
     #include <linux/types.h>
     #include <asm/compiler.h>
     
     /*
      * POLARIS is the internal name for a core logic chipset which provides
      * memory controller and PCI access for the 21164PC chip based systems.
     *
     * This file is based on:
     *
     * Polaris System Controller
     * Device Functional Specification
     * 22-Jan-98
     * Rev. 4.2
     *
     */
    
    /* Polaris memory regions */
    #define POLARIS_SPARSE_MEM_BASE         (IDENT_ADDR + 0xf800000000)
    #define POLARIS_DENSE_MEM_BASE          (IDENT_ADDR + 0xf900000000)
    #define POLARIS_SPARSE_IO_BASE          (IDENT_ADDR + 0xf980000000)
    #define POLARIS_SPARSE_CONFIG_BASE      (IDENT_ADDR + 0xf9c0000000)
    #define POLARIS_IACK_BASE               (IDENT_ADDR + 0xf9f8000000)
    #define POLARIS_DENSE_IO_BASE           (IDENT_ADDR + 0xf9fc000000)
    #define POLARIS_DENSE_CONFIG_BASE       (IDENT_ADDR + 0xf9fe000000)
    
    #define POLARIS_IACK_SC                 POLARIS_IACK_BASE
    
    /* The Polaris command/status registers live in PCI Config space for
     * bus 0/device 0.  As such, they may be bytes, words, or doublewords.
     */
    #define POLARIS_W_VENID         (POLARIS_DENSE_CONFIG_BASE)
    #define POLARIS_W_DEVID         (POLARIS_DENSE_CONFIG_BASE+2)
    #define POLARIS_W_CMD           (POLARIS_DENSE_CONFIG_BASE+4)
    #define POLARIS_W_STATUS        (POLARIS_DENSE_CONFIG_BASE+6)
    
    /*
     * Data structure for handling POLARIS machine checks:
     */
    struct el_POLARIS_sysdata_mcheck {
        u_long      psc_status;
        u_long      psc_pcictl0;
        u_long      psc_pcictl1;
        u_long      psc_pcictl2;
    };
    
    #ifdef __KERNEL__
    
    #ifndef __EXTERN_INLINE
    #define __EXTERN_INLINE extern inline
    #define __IO_EXTERN_INLINE
    #endif
    
    /*
     * I/O functions:
     *
     * POLARIS, the PCI/memory support chipset for the PCA56 (21164PC)
     * processors, can use either a sparse address  mapping scheme, or the 
     * so-called byte-word PCI address space, to get at PCI memory and I/O.
     *
     * However, we will support only the BWX form.
     */
    
    #define vucp    volatile unsigned char *
    #define vusp    volatile unsigned short *
    #define vuip    volatile unsigned int  *
    #define vulp    volatile unsigned long  *
    
    __EXTERN_INLINE u8 polaris_inb(unsigned long addr)
    {
            /* ??? I wish I could get rid of this.  But there's no ioremap
               equivalent for I/O space.  PCI I/O can be forced into the
               POLARIS I/O region, but that doesn't take care of legacy
               ISA crap.  */
    
            return __kernel_ldbu(*(vucp)(addr + POLARIS_DENSE_IO_BASE));
    }
    
    __EXTERN_INLINE void polaris_outb(u8 b, unsigned long addr)
    {
            __kernel_stb(b, *(vucp)(addr + POLARIS_DENSE_IO_BASE));
            mb();
    }
    
    __EXTERN_INLINE u16 polaris_inw(unsigned long addr)
    {
            return __kernel_ldwu(*(vusp)(addr + POLARIS_DENSE_IO_BASE));
    }
    
    __EXTERN_INLINE void polaris_outw(u16 b, unsigned long addr)
    {
            __kernel_stw(b, *(vusp)(addr + POLARIS_DENSE_IO_BASE));
            mb();
    }
    
    __EXTERN_INLINE u32 polaris_inl(unsigned long addr)
    {
           return *(vuip)(addr + POLARIS_DENSE_IO_BASE);
   }
   
   __EXTERN_INLINE void polaris_outl(u32 b, unsigned long addr)
   {
           *(vuip)(addr + POLARIS_DENSE_IO_BASE) = b;
           mb();
   }
   
   /*
    * Memory functions.  Polaris allows all accesses (byte/word
    * as well as long/quad) to be done through dense space.
    *
    * We will only support DENSE access via BWX insns.
    */
   
   __EXTERN_INLINE u8 polaris_readb(unsigned long addr)
   {
           return __kernel_ldbu(*(vucp)addr);
   }
   
   __EXTERN_INLINE u16 polaris_readw(unsigned long addr)
   {
           return __kernel_ldwu(*(vusp)addr);
   }
   
   __EXTERN_INLINE u32 polaris_readl(unsigned long addr)
   {
           return (*(vuip)addr) & 0xffffffff;
   }
   
   __EXTERN_INLINE u64 polaris_readq(unsigned long addr)
   {
           return *(vulp)addr;
   }
   
   __EXTERN_INLINE void polaris_writeb(u8 b, unsigned long addr)
   {
           __kernel_stb(b, *(vucp)addr);
   }
   
   __EXTERN_INLINE void polaris_writew(u16 b, unsigned long addr)
   {
           __kernel_stw(b, *(vusp)addr);
   }
   
   __EXTERN_INLINE void polaris_writel(u32 b, unsigned long addr)
   {
           *(vuip)addr = b;
   }
   
   __EXTERN_INLINE void polaris_writeq(u64 b, unsigned long addr)
   {
           *(vulp)addr = b;
   }
   
   __EXTERN_INLINE unsigned long polaris_ioremap(unsigned long addr,
                                                 unsigned long size
                                                 __attribute__((unused)))
   {
           return addr + POLARIS_DENSE_MEM_BASE;
   }
   
   __EXTERN_INLINE void polaris_iounmap(unsigned long addr)
   {
           return;
   }
   
   __EXTERN_INLINE int polaris_is_ioaddr(unsigned long addr)
   {
           return addr >= POLARIS_SPARSE_MEM_BASE;
   }
   
   #undef vucp
   #undef vusp
   #undef vuip
   #undef vulp
   
   #ifdef __WANT_IO_DEF
   
   #define __inb(p)                polaris_inb((unsigned long)(p))
   #define __inw(p)                polaris_inw((unsigned long)(p))
   #define __inl(p)                polaris_inl((unsigned long)(p))
   #define __outb(x,p)             polaris_outb((x),(unsigned long)(p))
   #define __outw(x,p)             polaris_outw((x),(unsigned long)(p))
   #define __outl(x,p)             polaris_outl((x),(unsigned long)(p))
   #define __readb(a)              polaris_readb((unsigned long)(a))
   #define __readw(a)              polaris_readw((unsigned long)(a))
   #define __readl(a)              polaris_readl((unsigned long)(a))
   #define __readq(a)              polaris_readq((unsigned long)(a))
   #define __writeb(x,a)           polaris_writeb((x),(unsigned long)(a))
   #define __writew(x,a)           polaris_writew((x),(unsigned long)(a))
   #define __writel(x,a)           polaris_writel((x),(unsigned long)(a))
   #define __writeq(x,a)           polaris_writeq((x),(unsigned long)(a))
   #define __ioremap(a,s)          polaris_ioremap((unsigned long)(a),(s))
   #define __iounmap(a)            polaris_iounmap((unsigned long)(a))
   #define __is_ioaddr(a)          polaris_is_ioaddr((unsigned long)(a))
   
   #define inb(p)                  __inb(p)
   #define inw(p)                  __inw(p)
   #define inl(p)                  __inl(p)
   #define outb(x,p)               __outb((x),(p))
   #define outw(x,p)               __outw((x),(p))
   #define outl(x,p)               __outl((x),(p))
   #define __raw_readb(a)          __readb(a)
   #define __raw_readw(a)          __readw(a)
   #define __raw_readl(a)          __readl(a)
   #define __raw_readq(a)          __readq(a)
   #define __raw_writeb(v,a)       __writeb((v),(a))
   #define __raw_writew(v,a)       __writew((v),(a))
   #define __raw_writel(v,a)       __writel((v),(a))
   #define __raw_writeq(v,a)       __writeq((v),(a))
   
   #endif /* __WANT_IO_DEF */
   
   #ifdef __IO_EXTERN_INLINE
   #undef __EXTERN_INLINE
   #undef __IO_EXTERN_INLINE
   #endif
   
   #endif /* __KERNEL__ */
   
   #endif /* __ALPHA_POLARIS__H__ */

Cache object: 7149e328d0421885cce93f65a601c514