include/asm-alpha/core_polaris.h

   1 #ifndef __ALPHA_POLARIS__H__
   2 #define __ALPHA_POLARIS__H__
   3
   4 #include <linux/config.h>
   5 #include <linux/types.h>
   6 #include <asm/compiler.h>
   7
   8 /*
   9  * POLARIS is the internal name for a core logic chipset which provides
  10  * memory controller and PCI access for the 21164PC chip based systems.
  11  *
  12  * This file is based on:
  13  *
  14  * Polaris System Controller
  15  * Device Functional Specification
  16  * 22-Jan-98
  17  * Rev. 4.2
  18  *
  19  */
  20
  21 /* Polaris memory regions */
  22 #define         POLARIS_SPARSE_MEM_BASE         (IDENT_ADDR + 0xf800000000)
  23 #define         POLARIS_DENSE_MEM_BASE          (IDENT_ADDR + 0xf900000000)
  24 #define         POLARIS_SPARSE_IO_BASE          (IDENT_ADDR + 0xf980000000)
  25 #define         POLARIS_SPARSE_CONFIG_BASE      (IDENT_ADDR + 0xf9c0000000)
  26 #define         POLARIS_IACK_BASE               (IDENT_ADDR + 0xf9f8000000)
  27 #define         POLARIS_DENSE_IO_BASE           (IDENT_ADDR + 0xf9fc000000)
  28 #define         POLARIS_DENSE_CONFIG_BASE       (IDENT_ADDR + 0xf9fe000000)
  29
  30 #define         POLARIS_IACK_SC                 POLARIS_IACK_BASE
  31
  32 /* The Polaris command/status registers live in PCI Config space for
  33  * bus 0/device 0.  As such, they may be bytes, words, or doublewords.
  34  */
  35 #define         POLARIS_W_VENID         (POLARIS_DENSE_CONFIG_BASE)
  36 #define         POLARIS_W_DEVID         (POLARIS_DENSE_CONFIG_BASE+2)
  37 #define         POLARIS_W_CMD           (POLARIS_DENSE_CONFIG_BASE+4)
  38 #define         POLARIS_W_STATUS        (POLARIS_DENSE_CONFIG_BASE+6)
  39
  40 /* No HAE address.  Polaris has no concept of an HAE, since it
  41  * supports transfers of all sizes in dense space.
  42  */
  43
  44 #define POLARIS_DMA_WIN_BASE_DEFAULT    0x80000000      /* fixed, 2G @ 2G */
  45 #define POLARIS_DMA_WIN_SIZE_DEFAULT    0x80000000      /* fixed, 2G @ 2G */
  46
  47 #if defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_SRM_SETUP)
  48 #define POLARIS_DMA_WIN_BASE            alpha_mv.dma_win_base
  49 #define POLARIS_DMA_WIN_SIZE            alpha_mv.dma_win_size
  50 #else
  51 #define POLARIS_DMA_WIN_BASE            POLARIS_DMA_WIN_BASE_DEFAULT
  52 #define POLARIS_DMA_WIN_SIZE            POLARIS_DMA_WIN_SIZE_DEFAULT
  53 #endif
  54
  55 /*
  56  * Data structure for handling POLARIS machine checks:
  57  */
  58 struct el_POLARIS_sysdata_mcheck {
  59     u_long      psc_status;
  60     u_long      psc_pcictl0;
  61     u_long      psc_pcictl1;
  62     u_long      psc_pcictl2;
  63 };
  64
  65  #ifdef __KERNEL__
  66
  67 #ifndef __EXTERN_INLINE
  68 #define __EXTERN_INLINE extern inline
  69 #define __IO_EXTERN_INLINE
  70 #endif
  71
  72 __EXTERN_INLINE unsigned long polaris_virt_to_bus(void * address)
  73 {
  74         return virt_to_phys(address) + POLARIS_DMA_WIN_BASE;
  75 }
  76
  77 __EXTERN_INLINE void * polaris_bus_to_virt(unsigned long address)
  78 {
  79         return phys_to_virt(address - POLARIS_DMA_WIN_BASE);
  80 }
  81
  82 /*
  83  * I/O functions:
  84  *
  85  * POLARIS, the PCI/memory support chipset for the PCA56 (21164PC)
  86  * processors, can use either a sparse address  mapping scheme, or the
  87  * so-called byte-word PCI address space, to get at PCI memory and I/O.
  88  *
  89  * However, we will support only the BWX form.
  90  */
  91
  92 #define vucp    volatile unsigned char *
  93 #define vusp    volatile unsigned short *
  94 #define vuip    volatile unsigned int  *
  95 #define vulp    volatile unsigned long  *
  96
  97 __EXTERN_INLINE unsigned int polaris_inb(unsigned long addr)
  98 {
  99         return __kernel_ldbu(*(vucp)(addr + POLARIS_DENSE_IO_BASE));
 100 }
 101
 102 __EXTERN_INLINE void polaris_outb(unsigned char b, unsigned long addr)
 103 {
 104         __kernel_stb(b, *(vucp)(addr + POLARIS_DENSE_IO_BASE));
 105         mb();
 106 }
 107
 108 __EXTERN_INLINE unsigned int polaris_inw(unsigned long addr)
 109 {
 110         return __kernel_ldwu(*(vusp)(addr + POLARIS_DENSE_IO_BASE));
 111 }
 112
 113 __EXTERN_INLINE void polaris_outw(unsigned short b, unsigned long addr)
 114 {
 115         __kernel_stw(b, *(vusp)(addr + POLARIS_DENSE_IO_BASE));
 116         mb();
 117 }
 118
 119 __EXTERN_INLINE unsigned int polaris_inl(unsigned long addr)
 120 {
 121         return *(vuip)(addr + POLARIS_DENSE_IO_BASE);
 122 }
 123
 124 __EXTERN_INLINE void polaris_outl(unsigned int b, unsigned long addr)
 125 {
 126         *(vuip)(addr + POLARIS_DENSE_IO_BASE) = b;
 127         mb();
 128 }
 129
 130 /*
 131  * Memory functions.  Polaris allows all accesses (byte/word
 132  * as well as long/quad) to be done through dense space.
 133  *
 134  * We will only support DENSE access via BWX insns.
 135  */
 136
 137 __EXTERN_INLINE unsigned long polaris_readb(unsigned long addr)
 138 {
 139         return __kernel_ldbu(*(vucp)(addr + POLARIS_DENSE_MEM_BASE));
 140 }
 141
 142 __EXTERN_INLINE unsigned long polaris_readw(unsigned long addr)
 143 {
 144         return __kernel_ldwu(*(vusp)(addr + POLARIS_DENSE_MEM_BASE));
 145 }
 146
 147 __EXTERN_INLINE unsigned long polaris_readl(unsigned long addr)
 148 {
 149         return *(vuip)(addr + POLARIS_DENSE_MEM_BASE);
 150 }
 151
 152 __EXTERN_INLINE unsigned long polaris_readq(unsigned long addr)
 153 {
 154         return *(vulp)(addr + POLARIS_DENSE_MEM_BASE);
 155 }
 156
 157 __EXTERN_INLINE void polaris_writeb(unsigned char b, unsigned long addr)
 158 {
 159         __kernel_stb(b, *(vucp)(addr + POLARIS_DENSE_MEM_BASE));
 160         mb();
 161 }
 162
 163 __EXTERN_INLINE void polaris_writew(unsigned short b, unsigned long addr)
 164 {
 165         __kernel_stw(b, *(vusp)(addr + POLARIS_DENSE_MEM_BASE));
 166         mb();
 167 }
 168
 169 __EXTERN_INLINE void polaris_writel(unsigned int b, unsigned long addr)
 170 {
 171         *(vuip)(addr + POLARIS_DENSE_MEM_BASE) = b;
 172         mb();
 173 }
 174
 175 __EXTERN_INLINE void polaris_writeq(unsigned long b, unsigned long addr)
 176 {
 177         *(vulp)(addr + POLARIS_DENSE_MEM_BASE) = b;
 178         mb();
 179 }
 180
 181 /* Find the DENSE memory area for a given bus address.  */
 182
 183 __EXTERN_INLINE unsigned long polaris_dense_mem(unsigned long addr)
 184 {
 185         return POLARIS_DENSE_MEM_BASE;
 186 }
 187
 188 #undef vucp
 189 #undef vusp
 190 #undef vuip
 191 #undef vulp
 192
 193 #ifdef __WANT_IO_DEF
 194
 195 #define virt_to_bus     polaris_virt_to_bus
 196 #define bus_to_virt     polaris_bus_to_virt
 197
 198 #define __inb           polaris_inb
 199 #define __inw           polaris_inw
 200 #define __inl           polaris_inl
 201 #define __outb          polaris_outb
 202 #define __outw          polaris_outw
 203 #define __outl          polaris_outl
 204 #define __readb         polaris_readb
 205 #define __readw         polaris_readw
 206 #define __writeb        polaris_writeb
 207 #define __writew        polaris_writew
 208 #define __readl         polaris_readl
 209 #define __readq         polaris_readq
 210 #define __writel        polaris_writel
 211 #define __writeq        polaris_writeq
 212 #define dense_mem       polaris_dense_mem
 213
 214 #define inb(port) __inb((port))
 215 #define inw(port) __inw((port))
 216 #define inl(port) __inl((port))
 217
 218 #define outb(v, port) __outb((v),(port))
 219 #define outw(v, port) __outw((v),(port))
 220 #define outl(v, port) __outl((v),(port))
 221
 222 #define readb(a)        __readb((unsigned long)(a))
 223 #define readw(a)        __readw((unsigned long)(a))
 224 #define readl(a)        __readl((unsigned long)(a))
 225 #define readq(a)        __readq((unsigned long)(a))
 226
 227 #define writeb(v,a)     __writeb((v),(unsigned long)(a))
 228 #define writew(v,a)     __writew((v),(unsigned long)(a))
 229 #define writel(v,a)     __writel((v),(unsigned long)(a))
 230 #define writeq(v,a)     __writeq((v),(unsigned long)(a))
 231
 232 #endif /* __WANT_IO_DEF */
 233
 234 #ifdef __IO_EXTERN_INLINE
 235 #undef __EXTERN_INLINE
 236 #undef __IO_EXTERN_INLINE
 237 #endif
 238
 239 #endif /* __KERNEL__ */
 240
 241 #endif /* __ALPHA_POLARIS__H__ */