include/asm-xtensa/xtensa/config-linux_be/core.h

   1 /*
   2  * xtensa/config/core.h -- HAL definitions that are dependent on CORE configuration
   3  *
   4  *  This header file is sometimes referred to as the "compile-time HAL" or CHAL.
   5  *  It was generated for a specific Xtensa processor configuration.
   6  *
   7  *  Source for configuration-independent binaries (which link in a
   8  *  configuration-specific HAL library) must NEVER include this file.
   9  *  It is perfectly normal, however, for the HAL source itself to include this file.
  10  */
  11
  12 /*
  13  * Copyright (c) 2003 Tensilica, Inc.  All Rights Reserved.
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of version 2.1 of the GNU Lesser General Public
  17  * License as published by the Free Software Foundation.
  18  *
  19  * This program is distributed in the hope that it would be useful, but
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  22  *
  23  * Further, this software is distributed without any warranty that it is
  24  * free of the rightful claim of any third person regarding infringement
  25  * or the like.  Any license provided herein, whether implied or
  26  * otherwise, applies only to this software file.  Patent licenses, if
  27  * any, provided herein do not apply to combinations of this program with
  28  * other software, or any other product whatsoever.
  29  *
  30  * You should have received a copy of the GNU Lesser General Public
  31  * License along with this program; if not, write the Free Software
  32  * Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307,
  33  * USA.
  34  */
  35
  36
  37 #ifndef XTENSA_CONFIG_CORE_H
  38 #define XTENSA_CONFIG_CORE_H
  39
  40 #include <xtensa/hal.h>
  41
  42
  43 /*----------------------------------------------------------------------
  44                                 GENERAL
  45   ----------------------------------------------------------------------*/
  46
  47 /*
  48  *  Separators for macros that expand into arrays.
  49  *  These can be predefined by files that #include this one,
  50  *  when different separators are required.
  51  */
  52 /*  Element separator for macros that expand into 1-dimensional arrays:  */
  53 #ifndef XCHAL_SEP
  54 #define XCHAL_SEP                       ,
  55 #endif
  56 /*  Array separator for macros that expand into 2-dimensional arrays:  */
  57 #ifndef XCHAL_SEP2
  58 #define XCHAL_SEP2                      },{
  59 #endif
  60
  61
  62 /*----------------------------------------------------------------------
  63                                 ENDIANNESS
  64   ----------------------------------------------------------------------*/
  65
  66 #define XCHAL_HAVE_BE                   1
  67 #define XCHAL_HAVE_LE                   0
  68 #define XCHAL_MEMORY_ORDER              XTHAL_BIGENDIAN
  69
  70
  71 /*----------------------------------------------------------------------
  72                                 REGISTER WINDOWS
  73   ----------------------------------------------------------------------*/
  74
  75 #define XCHAL_HAVE_WINDOWED             1       /* 1 if windowed registers option configured, 0 otherwise */
  76 #define XCHAL_NUM_AREGS                 64      /* number of physical address regs */
  77 #define XCHAL_NUM_AREGS_LOG2            6       /* log2(XCHAL_NUM_AREGS) */
  78
  79
  80 /*----------------------------------------------------------------------
  81                                 ADDRESS ALIGNMENT
  82   ----------------------------------------------------------------------*/
  83
  84 /*  These apply to a selected set of core load and store instructions only (see ISA):  */
  85 #define XCHAL_UNALIGNED_LOAD_EXCEPTION  1       /* 1 if unaligned loads cause an exception, 0 otherwise */
  86 #define XCHAL_UNALIGNED_STORE_EXCEPTION 1       /* 1 if unaligned stores cause an exception, 0 otherwise */
  87
  88
  89 /*----------------------------------------------------------------------
  90                                 INTERRUPTS
  91   ----------------------------------------------------------------------*/
  92
  93 #define XCHAL_HAVE_INTERRUPTS           1       /* 1 if interrupt option configured, 0 otherwise */
  94 #define XCHAL_HAVE_HIGHPRI_INTERRUPTS   1       /* 1 if high-priority interrupt option configured, 0 otherwise */
  95 #define XCHAL_HAVE_HIGHLEVEL_INTERRUPTS XCHAL_HAVE_HIGHPRI_INTERRUPTS
  96 #define XCHAL_HAVE_NMI                  0       /* 1 if NMI option configured, 0 otherwise */
  97 #define XCHAL_NUM_INTERRUPTS            17      /* number of interrupts */
  98 #define XCHAL_NUM_INTERRUPTS_LOG2       5       /* number of bits to hold an interrupt number: roundup(log2(number of interrupts)) */
  99 #define XCHAL_NUM_EXTINTERRUPTS         10      /* number of external interrupts */
 100 #define XCHAL_NUM_INTLEVELS             4       /* number of interrupt levels (not including level zero!) */
 101 #define XCHAL_NUM_LOWPRI_LEVELS         1                       /* number of low-priority interrupt levels (always 1) */
 102 #define XCHAL_FIRST_HIGHPRI_LEVEL       (XCHAL_NUM_LOWPRI_LEVELS+1)     /* level of first high-priority interrupt (always 2) */
 103 #define XCHAL_EXCM_LEVEL                1                       /* level of interrupts masked by PS.EXCM (XEA2 only; always 1 in T10xx);
 104                                                                    for XEA1, where there is no PS.EXCM, this is always 1;
 105                                                                    interrupts at levels FIRST_HIGHPRI <= n <= EXCM_LEVEL, if any,
 106                                                                    are termed "medium priority" interrupts (post T10xx only) */
 107 /*  Note:  1 <= LOWPRI_LEVELS <= EXCM_LEVEL < DEBUGLEVEL <= NUM_INTLEVELS < NMILEVEL <= 15  */
 108
 109 /*  Masks of interrupts at each interrupt level:  */
 110 #define XCHAL_INTLEVEL0_MASK            0x00000000
 111 #define XCHAL_INTLEVEL1_MASK            0x000064F9
 112 #define XCHAL_INTLEVEL2_MASK            0x00008902
 113 #define XCHAL_INTLEVEL3_MASK            0x00011204
 114 #define XCHAL_INTLEVEL4_MASK            0x00000000
 115 #define XCHAL_INTLEVEL5_MASK            0x00000000
 116 #define XCHAL_INTLEVEL6_MASK            0x00000000
 117 #define XCHAL_INTLEVEL7_MASK            0x00000000
 118 #define XCHAL_INTLEVEL8_MASK            0x00000000
 119 #define XCHAL_INTLEVEL9_MASK            0x00000000
 120 #define XCHAL_INTLEVEL10_MASK           0x00000000
 121 #define XCHAL_INTLEVEL11_MASK           0x00000000
 122 #define XCHAL_INTLEVEL12_MASK           0x00000000
 123 #define XCHAL_INTLEVEL13_MASK           0x00000000
 124 #define XCHAL_INTLEVEL14_MASK           0x00000000
 125 #define XCHAL_INTLEVEL15_MASK           0x00000000
 126 /*  As an array of entries (eg. for C constant arrays):  */
 127 #define XCHAL_INTLEVEL_MASKS            0x00000000      XCHAL_SEP \
 128                                         0x000064F9      XCHAL_SEP \
 129                                         0x00008902      XCHAL_SEP \
 130                                         0x00011204      XCHAL_SEP \
 131                                         0x00000000      XCHAL_SEP \
 132                                         0x00000000      XCHAL_SEP \
 133                                         0x00000000      XCHAL_SEP \
 134                                         0x00000000      XCHAL_SEP \
 135                                         0x00000000      XCHAL_SEP \
 136                                         0x00000000      XCHAL_SEP \
 137                                         0x00000000      XCHAL_SEP \
 138                                         0x00000000      XCHAL_SEP \
 139                                         0x00000000      XCHAL_SEP \
 140                                         0x00000000      XCHAL_SEP \
 141                                         0x00000000      XCHAL_SEP \
 142                                         0x00000000
 143
 144 /*  Masks of interrupts at each range 1..n of interrupt levels:  */
 145 #define XCHAL_INTLEVEL0_ANDBELOW_MASK   0x00000000
 146 #define XCHAL_INTLEVEL1_ANDBELOW_MASK   0x000064F9
 147 #define XCHAL_INTLEVEL2_ANDBELOW_MASK   0x0000EDFB
 148 #define XCHAL_INTLEVEL3_ANDBELOW_MASK   0x0001FFFF
 149 #define XCHAL_INTLEVEL4_ANDBELOW_MASK   0x0001FFFF
 150 #define XCHAL_INTLEVEL5_ANDBELOW_MASK   0x0001FFFF
 151 #define XCHAL_INTLEVEL6_ANDBELOW_MASK   0x0001FFFF
 152 #define XCHAL_INTLEVEL7_ANDBELOW_MASK   0x0001FFFF
 153 #define XCHAL_INTLEVEL8_ANDBELOW_MASK   0x0001FFFF
 154 #define XCHAL_INTLEVEL9_ANDBELOW_MASK   0x0001FFFF
 155 #define XCHAL_INTLEVEL10_ANDBELOW_MASK  0x0001FFFF
 156 #define XCHAL_INTLEVEL11_ANDBELOW_MASK  0x0001FFFF
 157 #define XCHAL_INTLEVEL12_ANDBELOW_MASK  0x0001FFFF
 158 #define XCHAL_INTLEVEL13_ANDBELOW_MASK  0x0001FFFF
 159 #define XCHAL_INTLEVEL14_ANDBELOW_MASK  0x0001FFFF
 160 #define XCHAL_INTLEVEL15_ANDBELOW_MASK  0x0001FFFF
 161 #define XCHAL_LOWPRI_MASK               XCHAL_INTLEVEL1_ANDBELOW_MASK   /* mask of all low-priority interrupts */
 162 #define XCHAL_EXCM_MASK                 XCHAL_INTLEVEL1_ANDBELOW_MASK   /* mask of all interrupts masked by PS.EXCM (or CEXCM) */
 163 /*  As an array of entries (eg. for C constant arrays):  */
 164 #define XCHAL_INTLEVEL_ANDBELOW_MASKS   0x00000000      XCHAL_SEP \
 165                                         0x000064F9      XCHAL_SEP \
 166                                         0x0000EDFB      XCHAL_SEP \
 167                                         0x0001FFFF      XCHAL_SEP \
 168                                         0x0001FFFF      XCHAL_SEP \
 169                                         0x0001FFFF      XCHAL_SEP \
 170                                         0x0001FFFF      XCHAL_SEP \
 171                                         0x0001FFFF      XCHAL_SEP \
 172                                         0x0001FFFF      XCHAL_SEP \
 173                                         0x0001FFFF      XCHAL_SEP \
 174                                         0x0001FFFF      XCHAL_SEP \
 175                                         0x0001FFFF      XCHAL_SEP \
 176                                         0x0001FFFF      XCHAL_SEP \
 177                                         0x0001FFFF      XCHAL_SEP \
 178                                         0x0001FFFF      XCHAL_SEP \
 179                                         0x0001FFFF
 180
 181 /*  Interrupt numbers for each interrupt level at which only one interrupt was configured:  */
 182 /*#define XCHAL_INTLEVEL1_NUM           ...more than one interrupt at this level...*/
 183 /*#define XCHAL_INTLEVEL2_NUM           ...more than one interrupt at this level...*/
 184 /*#define XCHAL_INTLEVEL3_NUM           ...more than one interrupt at this level...*/
 185
 186 /*  Level of each interrupt:  */
 187 #define XCHAL_INT0_LEVEL                1
 188 #define XCHAL_INT1_LEVEL                2
 189 #define XCHAL_INT2_LEVEL                3
 190 #define XCHAL_INT3_LEVEL                1
 191 #define XCHAL_INT4_LEVEL                1
 192 #define XCHAL_INT5_LEVEL                1
 193 #define XCHAL_INT6_LEVEL                1
 194 #define XCHAL_INT7_LEVEL                1
 195 #define XCHAL_INT8_LEVEL                2
 196 #define XCHAL_INT9_LEVEL                3
 197 #define XCHAL_INT10_LEVEL               1
 198 #define XCHAL_INT11_LEVEL               2
 199 #define XCHAL_INT12_LEVEL               3
 200 #define XCHAL_INT13_LEVEL               1
 201 #define XCHAL_INT14_LEVEL               1
 202 #define XCHAL_INT15_LEVEL               2
 203 #define XCHAL_INT16_LEVEL               3
 204 #define XCHAL_INT17_LEVEL               0
 205 #define XCHAL_INT18_LEVEL               0
 206 #define XCHAL_INT19_LEVEL               0
 207 #define XCHAL_INT20_LEVEL               0
 208 #define XCHAL_INT21_LEVEL               0
 209 #define XCHAL_INT22_LEVEL               0
 210 #define XCHAL_INT23_LEVEL               0
 211 #define XCHAL_INT24_LEVEL               0
 212 #define XCHAL_INT25_LEVEL               0
 213 #define XCHAL_INT26_LEVEL               0
 214 #define XCHAL_INT27_LEVEL               0
 215 #define XCHAL_INT28_LEVEL               0
 216 #define XCHAL_INT29_LEVEL               0
 217 #define XCHAL_INT30_LEVEL               0
 218 #define XCHAL_INT31_LEVEL               0
 219 /*  As an array of entries (eg. for C constant arrays):  */
 220 #define XCHAL_INT_LEVELS                1       XCHAL_SEP \
 221                                         2       XCHAL_SEP \
 222                                         3       XCHAL_SEP \
 223                                         1       XCHAL_SEP \
 224                                         1       XCHAL_SEP \
 225                                         1       XCHAL_SEP \
 226                                         1       XCHAL_SEP \
 227                                         1       XCHAL_SEP \
 228                                         2       XCHAL_SEP \
 229                                         3       XCHAL_SEP \
 230                                         1       XCHAL_SEP \
 231                                         2       XCHAL_SEP \
 232                                         3       XCHAL_SEP \
 233                                         1       XCHAL_SEP \
 234                                         1       XCHAL_SEP \
 235                                         2       XCHAL_SEP \
 236                                         3       XCHAL_SEP \
 237                                         0       XCHAL_SEP \
 238                                         0       XCHAL_SEP \
 239                                         0       XCHAL_SEP \
 240                                         0       XCHAL_SEP \
 241                                         0       XCHAL_SEP \
 242                                         0       XCHAL_SEP \
 243                                         0       XCHAL_SEP \
 244                                         0       XCHAL_SEP \
 245                                         0       XCHAL_SEP \
 246                                         0       XCHAL_SEP \
 247                                         0       XCHAL_SEP \
 248                                         0       XCHAL_SEP \
 249                                         0       XCHAL_SEP \
 250                                         0       XCHAL_SEP \
 251                                         0
 252
 253 /*  Type of each interrupt:  */
 254 #define XCHAL_INT0_TYPE         XTHAL_INTTYPE_EXTERN_LEVEL
 255 #define XCHAL_INT1_TYPE         XTHAL_INTTYPE_EXTERN_LEVEL
 256 #define XCHAL_INT2_TYPE         XTHAL_INTTYPE_EXTERN_LEVEL
 257 #define XCHAL_INT3_TYPE         XTHAL_INTTYPE_EXTERN_LEVEL
 258 #define XCHAL_INT4_TYPE         XTHAL_INTTYPE_EXTERN_LEVEL
 259 #define XCHAL_INT5_TYPE         XTHAL_INTTYPE_EXTERN_LEVEL
 260 #define XCHAL_INT6_TYPE         XTHAL_INTTYPE_EXTERN_LEVEL
 261 #define XCHAL_INT7_TYPE         XTHAL_INTTYPE_EXTERN_EDGE
 262 #define XCHAL_INT8_TYPE         XTHAL_INTTYPE_EXTERN_EDGE
 263 #define XCHAL_INT9_TYPE         XTHAL_INTTYPE_EXTERN_EDGE
 264 #define XCHAL_INT10_TYPE        XTHAL_INTTYPE_TIMER
 265 #define XCHAL_INT11_TYPE        XTHAL_INTTYPE_TIMER
 266 #define XCHAL_INT12_TYPE        XTHAL_INTTYPE_TIMER
 267 #define XCHAL_INT13_TYPE        XTHAL_INTTYPE_SOFTWARE
 268 #define XCHAL_INT14_TYPE        XTHAL_INTTYPE_SOFTWARE
 269 #define XCHAL_INT15_TYPE        XTHAL_INTTYPE_SOFTWARE
 270 #define XCHAL_INT16_TYPE        XTHAL_INTTYPE_SOFTWARE
 271 #define XCHAL_INT17_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 272 #define XCHAL_INT18_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 273 #define XCHAL_INT19_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 274 #define XCHAL_INT20_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 275 #define XCHAL_INT21_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 276 #define XCHAL_INT22_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 277 #define XCHAL_INT23_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 278 #define XCHAL_INT24_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 279 #define XCHAL_INT25_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 280 #define XCHAL_INT26_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 281 #define XCHAL_INT27_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 282 #define XCHAL_INT28_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 283 #define XCHAL_INT29_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 284 #define XCHAL_INT30_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 285 #define XCHAL_INT31_TYPE        XTHAL_INTTYPE_UNCONFIGURED
 286 /*  As an array of entries (eg. for C constant arrays):  */
 287 #define XCHAL_INT_TYPES         XTHAL_INTTYPE_EXTERN_LEVEL      XCHAL_SEP \
 288                                 XTHAL_INTTYPE_EXTERN_LEVEL      XCHAL_SEP \
 289                                 XTHAL_INTTYPE_EXTERN_LEVEL      XCHAL_SEP \
 290                                 XTHAL_INTTYPE_EXTERN_LEVEL      XCHAL_SEP \
 291                                 XTHAL_INTTYPE_EXTERN_LEVEL      XCHAL_SEP \
 292                                 XTHAL_INTTYPE_EXTERN_LEVEL      XCHAL_SEP \
 293                                 XTHAL_INTTYPE_EXTERN_LEVEL      XCHAL_SEP \
 294                                 XTHAL_INTTYPE_EXTERN_EDGE       XCHAL_SEP \
 295                                 XTHAL_INTTYPE_EXTERN_EDGE       XCHAL_SEP \
 296                                 XTHAL_INTTYPE_EXTERN_EDGE       XCHAL_SEP \
 297                                 XTHAL_INTTYPE_TIMER             XCHAL_SEP \
 298                                 XTHAL_INTTYPE_TIMER             XCHAL_SEP \
 299                                 XTHAL_INTTYPE_TIMER             XCHAL_SEP \
 300                                 XTHAL_INTTYPE_SOFTWARE          XCHAL_SEP \
 301                                 XTHAL_INTTYPE_SOFTWARE          XCHAL_SEP \
 302                                 XTHAL_INTTYPE_SOFTWARE          XCHAL_SEP \
 303                                 XTHAL_INTTYPE_SOFTWARE          XCHAL_SEP \
 304                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 305                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 306                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 307                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 308                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 309                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 310                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 311                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 312                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 313                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 314                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 315                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 316                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 317                                 XTHAL_INTTYPE_UNCONFIGURED      XCHAL_SEP \
 318                                 XTHAL_INTTYPE_UNCONFIGURED
 319
 320 /*  Masks of interrupts for each type of interrupt:  */
 321 #define XCHAL_INTTYPE_MASK_UNCONFIGURED 0xFFFE0000
 322 #define XCHAL_INTTYPE_MASK_SOFTWARE     0x0001E000
 323 #define XCHAL_INTTYPE_MASK_EXTERN_EDGE  0x00000380
 324 #define XCHAL_INTTYPE_MASK_EXTERN_LEVEL 0x0000007F
 325 #define XCHAL_INTTYPE_MASK_TIMER        0x00001C00
 326 #define XCHAL_INTTYPE_MASK_NMI          0x00000000
 327 /*  As an array of entries (eg. for C constant arrays):  */
 328 #define XCHAL_INTTYPE_MASKS             0xFFFE0000      XCHAL_SEP \
 329                                         0x0001E000      XCHAL_SEP \
 330                                         0x00000380      XCHAL_SEP \
 331                                         0x0000007F      XCHAL_SEP \
 332                                         0x00001C00      XCHAL_SEP \
 333                                         0x00000000
 334
 335 /*  Interrupts assigned to each timer (CCOMPARE0 to CCOMPARE3), -1 if unassigned  */
 336 #define XCHAL_TIMER0_INTERRUPT  10
 337 #define XCHAL_TIMER1_INTERRUPT  11
 338 #define XCHAL_TIMER2_INTERRUPT  12
 339 #define XCHAL_TIMER3_INTERRUPT  XTHAL_TIMER_UNCONFIGURED
 340 /*  As an array of entries (eg. for C constant arrays):  */
 341 #define XCHAL_TIMER_INTERRUPTS  10      XCHAL_SEP \
 342                                 11      XCHAL_SEP \
 343                                 12      XCHAL_SEP \
 344                                 XTHAL_TIMER_UNCONFIGURED
 345
 346 /*  Indexing macros:  */
 347 #define _XCHAL_INTLEVEL_MASK(n)         XCHAL_INTLEVEL ## n ## _MASK
 348 #define XCHAL_INTLEVEL_MASK(n)          _XCHAL_INTLEVEL_MASK(n)         /* n = 0 .. 15 */
 349 #define _XCHAL_INTLEVEL_ANDBELOWMASK(n) XCHAL_INTLEVEL ## n ## _ANDBELOW_MASK
 350 #define XCHAL_INTLEVEL_ANDBELOW_MASK(n) _XCHAL_INTLEVEL_ANDBELOWMASK(n) /* n = 0 .. 15 */
 351 #define _XCHAL_INT_LEVEL(n)             XCHAL_INT ## n ## _LEVEL
 352 #define XCHAL_INT_LEVEL(n)              _XCHAL_INT_LEVEL(n)             /* n = 0 .. 31 */
 353 #define _XCHAL_INT_TYPE(n)              XCHAL_INT ## n ## _TYPE
 354 #define XCHAL_INT_TYPE(n)               _XCHAL_INT_TYPE(n)              /* n = 0 .. 31 */
 355 #define _XCHAL_TIMER_INTERRUPT(n)       XCHAL_TIMER ## n ## _INTERRUPT
 356 #define XCHAL_TIMER_INTERRUPT(n)        _XCHAL_TIMER_INTERRUPT(n)       /* n = 0 .. 3 */
 357
 358
 359
 360 /*
 361  *  External interrupt vectors/levels.
 362  *  These macros describe how Xtensa processor interrupt numbers
 363  *  (as numbered internally, eg. in INTERRUPT and INTENABLE registers)
 364  *  map to external BInterrupt<n> pins, for those interrupts
 365  *  configured as external (level-triggered, edge-triggered, or NMI).
 366  *  See the Xtensa processor databook for more details.
 367  */
 368
 369 /*  Core interrupt numbers mapped to each EXTERNAL interrupt number:  */
 370 #define XCHAL_EXTINT0_NUM               0       /* (intlevel 1) */
 371 #define XCHAL_EXTINT1_NUM               1       /* (intlevel 2) */
 372 #define XCHAL_EXTINT2_NUM               2       /* (intlevel 3) */
 373 #define XCHAL_EXTINT3_NUM               3       /* (intlevel 1) */
 374 #define XCHAL_EXTINT4_NUM               4       /* (intlevel 1) */
 375 #define XCHAL_EXTINT5_NUM               5       /* (intlevel 1) */
 376 #define XCHAL_EXTINT6_NUM               6       /* (intlevel 1) */
 377 #define XCHAL_EXTINT7_NUM               7       /* (intlevel 1) */
 378 #define XCHAL_EXTINT8_NUM               8       /* (intlevel 2) */
 379 #define XCHAL_EXTINT9_NUM               9       /* (intlevel 3) */
 380
 381 /*  Corresponding interrupt masks:  */
 382 #define XCHAL_EXTINT0_MASK              0x00000001
 383 #define XCHAL_EXTINT1_MASK              0x00000002
 384 #define XCHAL_EXTINT2_MASK              0x00000004
 385 #define XCHAL_EXTINT3_MASK              0x00000008
 386 #define XCHAL_EXTINT4_MASK              0x00000010
 387 #define XCHAL_EXTINT5_MASK              0x00000020
 388 #define XCHAL_EXTINT6_MASK              0x00000040
 389 #define XCHAL_EXTINT7_MASK              0x00000080
 390 #define XCHAL_EXTINT8_MASK              0x00000100
 391 #define XCHAL_EXTINT9_MASK              0x00000200
 392
 393 /*  Core config interrupt levels mapped to each external interrupt:  */
 394 #define XCHAL_EXTINT0_LEVEL             1       /* (int number 0) */
 395 #define XCHAL_EXTINT1_LEVEL             2       /* (int number 1) */
 396 #define XCHAL_EXTINT2_LEVEL             3       /* (int number 2) */
 397 #define XCHAL_EXTINT3_LEVEL             1       /* (int number 3) */
 398 #define XCHAL_EXTINT4_LEVEL             1       /* (int number 4) */
 399 #define XCHAL_EXTINT5_LEVEL             1       /* (int number 5) */
 400 #define XCHAL_EXTINT6_LEVEL             1       /* (int number 6) */
 401 #define XCHAL_EXTINT7_LEVEL             1       /* (int number 7) */
 402 #define XCHAL_EXTINT8_LEVEL             2       /* (int number 8) */
 403 #define XCHAL_EXTINT9_LEVEL             3       /* (int number 9) */
 404
 405
 406 /*----------------------------------------------------------------------
 407                         EXCEPTIONS and VECTORS
 408   ----------------------------------------------------------------------*/
 409
 410 #define XCHAL_HAVE_EXCEPTIONS           1       /* 1 if exception option configured, 0 otherwise */
 411
 412 #define XCHAL_XEA_VERSION               2       /* Xtensa Exception Architecture number: 1 for XEA1 (old), 2 for XEA2 (new) */
 413 #define XCHAL_HAVE_XEA1                 0       /* 1 if XEA1, 0 otherwise */
 414 #define XCHAL_HAVE_XEA2                 1       /* 1 if XEA2, 0 otherwise */
 415 /*  For backward compatibility ONLY -- DO NOT USE (will be removed in future release):  */
 416 #define XCHAL_HAVE_OLD_EXC_ARCH         XCHAL_HAVE_XEA1 /* (DEPRECATED) 1 if old exception architecture (XEA1), 0 otherwise (eg. XEA2) */
 417 #define XCHAL_HAVE_EXCM                 XCHAL_HAVE_XEA2 /* (DEPRECATED) 1 if PS.EXCM bit exists (currently equals XCHAL_HAVE_TLBS) */
 418
 419 #define XCHAL_RESET_VECTOR_VADDR        0xFE000020
 420 #define XCHAL_RESET_VECTOR_PADDR        0xFE000020
 421 #define XCHAL_USER_VECTOR_VADDR         0xD0000220
 422 #define XCHAL_PROGRAMEXC_VECTOR_VADDR   XCHAL_USER_VECTOR_VADDR         /* for backward compatibility */
 423 #define XCHAL_USEREXC_VECTOR_VADDR      XCHAL_USER_VECTOR_VADDR         /* for backward compatibility */
 424 #define XCHAL_USER_VECTOR_PADDR         0x00000220
 425 #define XCHAL_PROGRAMEXC_VECTOR_PADDR   XCHAL_USER_VECTOR_PADDR         /* for backward compatibility */
 426 #define XCHAL_USEREXC_VECTOR_PADDR      XCHAL_USER_VECTOR_PADDR         /* for backward compatibility */
 427 #define XCHAL_KERNEL_VECTOR_VADDR       0xD0000200
 428 #define XCHAL_STACKEDEXC_VECTOR_VADDR   XCHAL_KERNEL_VECTOR_VADDR       /* for backward compatibility */
 429 #define XCHAL_KERNELEXC_VECTOR_VADDR    XCHAL_KERNEL_VECTOR_VADDR       /* for backward compatibility */
 430 #define XCHAL_KERNEL_VECTOR_PADDR       0x00000200
 431 #define XCHAL_STACKEDEXC_VECTOR_PADDR   XCHAL_KERNEL_VECTOR_PADDR       /* for backward compatibility */
 432 #define XCHAL_KERNELEXC_VECTOR_PADDR    XCHAL_KERNEL_VECTOR_PADDR       /* for backward compatibility */
 433 #define XCHAL_DOUBLEEXC_VECTOR_VADDR    0xD0000290
 434 #define XCHAL_DOUBLEEXC_VECTOR_PADDR    0x00000290
 435 #define XCHAL_WINDOW_VECTORS_VADDR      0xD0000000
 436 #define XCHAL_WINDOW_VECTORS_PADDR      0x00000000
 437 #define XCHAL_INTLEVEL2_VECTOR_VADDR    0xD0000240
 438 #define XCHAL_INTLEVEL2_VECTOR_PADDR    0x00000240
 439 #define XCHAL_INTLEVEL3_VECTOR_VADDR    0xD0000250
 440 #define XCHAL_INTLEVEL3_VECTOR_PADDR    0x00000250
 441 #define XCHAL_INTLEVEL4_VECTOR_VADDR    0xFE000520
 442 #define XCHAL_INTLEVEL4_VECTOR_PADDR    0xFE000520
 443 #define XCHAL_DEBUG_VECTOR_VADDR        XCHAL_INTLEVEL4_VECTOR_VADDR
 444 #define XCHAL_DEBUG_VECTOR_PADDR        XCHAL_INTLEVEL4_VECTOR_PADDR
 445
 446 /*  Indexing macros:  */
 447 #define _XCHAL_INTLEVEL_VECTOR_VADDR(n)         XCHAL_INTLEVEL ## n ## _VECTOR_VADDR
 448 #define XCHAL_INTLEVEL_VECTOR_VADDR(n)          _XCHAL_INTLEVEL_VECTOR_VADDR(n)         /* n = 0 .. 15 */
 449
 450 /*
 451  *  General Exception Causes
 452  *  (values of EXCCAUSE special register set by general exceptions,
 453  *   which vector to the user, kernel, or double-exception vectors):
 454  */
 455 #define XCHAL_EXCCAUSE_ILLEGAL_INSTRUCTION              0       /* Illegal Instruction (IllegalInstruction) */
 456 #define XCHAL_EXCCAUSE_SYSTEM_CALL                      1       /* System Call (SystemCall) */
 457 #define XCHAL_EXCCAUSE_INSTRUCTION_FETCH_ERROR          2       /* Instruction Fetch Error (InstructionFetchError) */
 458 #define XCHAL_EXCCAUSE_LOAD_STORE_ERROR                 3       /* Load Store Error (LoadStoreError) */
 459 #define XCHAL_EXCCAUSE_LEVEL1_INTERRUPT                 4       /* Level 1 Interrupt (Level1Interrupt) */
 460 #define XCHAL_EXCCAUSE_ALLOCA                           5       /* Stack Extension Assist (Alloca) */
 461 #define XCHAL_EXCCAUSE_INTEGER_DIVIDE_BY_ZERO           6       /* Integer Divide by Zero (IntegerDivideByZero) */
 462 #define XCHAL_EXCCAUSE_SPECULATION                      7       /* Speculation (Speculation) */
 463 #define XCHAL_EXCCAUSE_PRIVILEGED                       8       /* Privileged Instruction (Privileged) */
 464 #define XCHAL_EXCCAUSE_UNALIGNED                        9       /* Unaligned Load Store (Unaligned) */
 465 #define XCHAL_EXCCAUSE_ITLB_MISS                        16      /* ITlb Miss Exception (ITlbMiss) */
 466 #define XCHAL_EXCCAUSE_ITLB_MULTIHIT                    17      /* ITlb Mutltihit Exception (ITlbMultihit) */
 467 #define XCHAL_EXCCAUSE_ITLB_PRIVILEGE                   18      /* ITlb Privilege Exception (ITlbPrivilege) */
 468 #define XCHAL_EXCCAUSE_ITLB_SIZE_RESTRICTION            19      /* ITlb Size Restriction Exception (ITlbSizeRestriction) */
 469 #define XCHAL_EXCCAUSE_FETCH_CACHE_ATTRIBUTE            20      /* Fetch Cache Attribute Exception (FetchCacheAttribute) */
 470 #define XCHAL_EXCCAUSE_DTLB_MISS                        24      /* DTlb Miss Exception (DTlbMiss) */
 471 #define XCHAL_EXCCAUSE_DTLB_MULTIHIT                    25      /* DTlb Multihit Exception (DTlbMultihit) */
 472 #define XCHAL_EXCCAUSE_DTLB_PRIVILEGE                   26      /* DTlb Privilege Exception (DTlbPrivilege) */
 473 #define XCHAL_EXCCAUSE_DTLB_SIZE_RESTRICTION            27      /* DTlb Size Restriction Exception (DTlbSizeRestriction) */
 474 #define XCHAL_EXCCAUSE_LOAD_CACHE_ATTRIBUTE             28      /* Load Cache Attribute Exception (LoadCacheAttribute) */
 475 #define XCHAL_EXCCAUSE_STORE_CACHE_ATTRIBUTE            29      /* Store Cache Attribute Exception (StoreCacheAttribute) */
 476 #define XCHAL_EXCCAUSE_FLOATING_POINT                   40      /* Floating Point Exception (FloatingPoint) */
 477
 478
 479
 480 /*----------------------------------------------------------------------
 481                                 TIMERS
 482   ----------------------------------------------------------------------*/
 483
 484 #define XCHAL_HAVE_CCOUNT               1       /* 1 if have CCOUNT, 0 otherwise */
 485 /*#define XCHAL_HAVE_TIMERS             XCHAL_HAVE_CCOUNT*/
 486 #define XCHAL_NUM_TIMERS                3       /* number of CCOMPAREn regs */
 487
 488
 489
 490 /*----------------------------------------------------------------------
 491                                 DEBUG
 492   ----------------------------------------------------------------------*/
 493
 494 #define XCHAL_HAVE_DEBUG                1       /* 1 if debug option configured, 0 otherwise */
 495 #define XCHAL_HAVE_OCD                  1       /* 1 if OnChipDebug option configured, 0 otherwise */
 496 #define XCHAL_NUM_IBREAK                2       /* number of IBREAKn regs */
 497 #define XCHAL_NUM_DBREAK                2       /* number of DBREAKn regs */
 498 #define XCHAL_DEBUGLEVEL                4       /* debug interrupt level */
 499 /*DebugExternalInterrupt                0               0|1*/
 500 /*DebugUseDIRArray                      0               0|1*/
 501
 502
 503
 504
 505 /*----------------------------------------------------------------------
 506                         COPROCESSORS and EXTRA STATE
 507   ----------------------------------------------------------------------*/
 508
 509 #define XCHAL_HAVE_CP                   0       /* 1 if coprocessor option configured (CPENABLE present) */
 510 #define XCHAL_CP_MAXCFG                 0       /* max allowed cp id plus one (per cfg) */
 511
 512 #include <xtensa/config/tie.h>
 513
 514
 515
 516
 517 /*----------------------------------------------------------------------
 518                         INTERNAL I/D RAM/ROMs and XLMI
 519   ----------------------------------------------------------------------*/
 520
 521 #define XCHAL_NUM_INSTROM               0       /* number of core instruction ROMs configured */
 522 #define XCHAL_NUM_INSTRAM               0       /* number of core instruction RAMs configured */
 523 #define XCHAL_NUM_DATAROM               0       /* number of core data ROMs configured */
 524 #define XCHAL_NUM_DATARAM               0       /* number of core data RAMs configured */
 525 #define XCHAL_NUM_XLMI                  0       /* number of core XLMI ports configured */
 526 #define  XCHAL_NUM_IROM                 XCHAL_NUM_INSTROM       /* (DEPRECATED) */
 527 #define  XCHAL_NUM_IRAM                 XCHAL_NUM_INSTRAM       /* (DEPRECATED) */
 528 #define  XCHAL_NUM_DROM                 XCHAL_NUM_DATAROM       /* (DEPRECATED) */
 529 #define  XCHAL_NUM_DRAM                 XCHAL_NUM_DATARAM       /* (DEPRECATED) */
 530
 531
 532
 533 /*----------------------------------------------------------------------
 534                                 CACHE
 535   ----------------------------------------------------------------------*/
 536
 537 /*  Size of the cache lines in log2(bytes):  */
 538 #define XCHAL_ICACHE_LINEWIDTH          4
 539 #define XCHAL_DCACHE_LINEWIDTH          4
 540 /*  Size of the cache lines in bytes:  */
 541 #define XCHAL_ICACHE_LINESIZE           16
 542 #define XCHAL_DCACHE_LINESIZE           16
 543 /*  Max for both I-cache and D-cache (used for general alignment):  */
 544 #define XCHAL_CACHE_LINEWIDTH_MAX       4
 545 #define XCHAL_CACHE_LINESIZE_MAX        16
 546
 547 /*  Number of cache sets in log2(lines per way):  */
 548 #define XCHAL_ICACHE_SETWIDTH           8
 549 #define XCHAL_DCACHE_SETWIDTH           8
 550 /*  Max for both I-cache and D-cache (used for general cache-coherency page alignment):  */
 551 #define XCHAL_CACHE_SETWIDTH_MAX        8
 552 #define XCHAL_CACHE_SETSIZE_MAX         256
 553
 554 /*  Cache set associativity (number of ways):  */
 555 #define XCHAL_ICACHE_WAYS               2
 556 #define XCHAL_DCACHE_WAYS               2
 557
 558 /*  Size of the caches in bytes (ways * 2^(linewidth + setwidth)):  */
 559 #define XCHAL_ICACHE_SIZE               8192
 560 #define XCHAL_DCACHE_SIZE               8192
 561
 562 /*  Cache features:  */
 563 #define XCHAL_DCACHE_IS_WRITEBACK       0
 564 /*  Whether cache locking feature is available:  */
 565 #define XCHAL_ICACHE_LINE_LOCKABLE      0
 566 #define XCHAL_DCACHE_LINE_LOCKABLE      0
 567
 568 /*  Number of (encoded) cache attribute bits:  */
 569 #define XCHAL_CA_BITS                   4       /* number of bits needed to hold cache attribute encoding */
 570 /*  (The number of access mode bits (decoded cache attribute bits) is defined by the architecture; see xtensa/hal.h?)  */
 571
 572
 573 /*  Cache Attribute encodings -- lists of access modes for each cache attribute:  */
 574 #define XCHAL_FCA_LIST          XTHAL_FAM_EXCEPTION     XCHAL_SEP \
 575                                 XTHAL_FAM_BYPASS        XCHAL_SEP \
 576                                 XTHAL_FAM_EXCEPTION     XCHAL_SEP \
 577                                 XTHAL_FAM_BYPASS        XCHAL_SEP \
 578                                 XTHAL_FAM_EXCEPTION     XCHAL_SEP \
 579                                 XTHAL_FAM_CACHED        XCHAL_SEP \
 580                                 XTHAL_FAM_EXCEPTION     XCHAL_SEP \
 581                                 XTHAL_FAM_CACHED        XCHAL_SEP \
 582                                 XTHAL_FAM_EXCEPTION     XCHAL_SEP \
 583                                 XTHAL_FAM_CACHED        XCHAL_SEP \
 584                                 XTHAL_FAM_EXCEPTION     XCHAL_SEP \
 585                                 XTHAL_FAM_CACHED        XCHAL_SEP \
 586                                 XTHAL_FAM_EXCEPTION     XCHAL_SEP \
 587                                 XTHAL_FAM_EXCEPTION     XCHAL_SEP \
 588                                 XTHAL_FAM_EXCEPTION     XCHAL_SEP \
 589                                 XTHAL_FAM_EXCEPTION
 590 #define XCHAL_LCA_LIST          XTHAL_LAM_EXCEPTION     XCHAL_SEP \
 591                                 XTHAL_LAM_BYPASSG       XCHAL_SEP \
 592                                 XTHAL_LAM_EXCEPTION     XCHAL_SEP \
 593                                 XTHAL_LAM_BYPASSG       XCHAL_SEP \
 594                                 XTHAL_LAM_EXCEPTION     XCHAL_SEP \
 595                                 XTHAL_LAM_CACHED        XCHAL_SEP \
 596                                 XTHAL_LAM_EXCEPTION     XCHAL_SEP \
 597                                 XTHAL_LAM_CACHED        XCHAL_SEP \
 598                                 XTHAL_LAM_EXCEPTION     XCHAL_SEP \
 599                                 XTHAL_LAM_NACACHED      XCHAL_SEP \
 600                                 XTHAL_LAM_EXCEPTION     XCHAL_SEP \
 601                                 XTHAL_LAM_NACACHED      XCHAL_SEP \
 602                                 XTHAL_LAM_EXCEPTION     XCHAL_SEP \
 603                                 XTHAL_LAM_ISOLATE       XCHAL_SEP \
 604                                 XTHAL_LAM_EXCEPTION     XCHAL_SEP \
 605                                 XTHAL_LAM_CACHED
 606 #define XCHAL_SCA_LIST          XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 607                                 XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 608                                 XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 609                                 XTHAL_SAM_BYPASS        XCHAL_SEP \
 610                                 XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 611                                 XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 612                                 XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 613                                 XTHAL_SAM_WRITETHRU     XCHAL_SEP \
 614                                 XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 615                                 XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 616                                 XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 617                                 XTHAL_SAM_WRITETHRU     XCHAL_SEP \
 618                                 XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 619                                 XTHAL_SAM_ISOLATE       XCHAL_SEP \
 620                                 XTHAL_SAM_EXCEPTION     XCHAL_SEP \
 621                                 XTHAL_SAM_WRITETHRU
 622
 623 /*  Test:
 624         read/only: 0 + 1 + 2 + 4 + 5 + 6 + 8 + 9 + 10 + 12 + 14
 625         read/only: 0 + 1 + 2 + 4 + 5 + 6 + 8 + 9 + 10 + 12 + 14
 626         all:       0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15
 627         fault:     0 + 2 + 4 + 6 + 8 + 10 + 12 + 14
 628         r/w/x cached:
 629         r/w/x dcached:
 630         I-bypass:  1 + 3
 631
 632         load guard bit set: 1 + 3
 633         load guard bit clr: 0 + 2 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15
 634         hit-cache r/w/x: 7 + 11
 635
 636         fams: 5
 637         fams: 0 / 6 / 18 / 1 / 2
 638         fams: Bypass / Isolate / Cached / Exception / NACached
 639
 640         MMU okay:  yes
 641 */
 642
 643
 644 /*----------------------------------------------------------------------
 645                                 MMU
 646   ----------------------------------------------------------------------*/
 647
 648 /*
 649  *  General notes on MMU parameters.
 650  *
 651  *  Terminology:
 652  *      ASID = address-space ID (acts as an "extension" of virtual addresses)
 653  *      VPN  = virtual page number
 654  *      PPN  = physical page number
 655  *      CA   = encoded cache attribute (access modes)
 656  *      TLB  = translation look-aside buffer (term is stretched somewhat here)
 657  *      I    = instruction (fetch accesses)
 658  *      D    = data (load and store accesses)
 659  *      way  = each TLB (ITLB and DTLB) consists of a number of "ways"
 660  *              that simultaneously match the virtual address of an access;
 661  *              a TLB successfully translates a virtual address if exactly
 662  *              one way matches the vaddr; if none match, it is a miss;
 663  *              if multiple match, one gets a "multihit" exception;
 664  *              each way can be independently configured in terms of number of
 665  *              entries, page sizes, which fields are writable or constant, etc.
 666  *      set  = group of contiguous ways with exactly identical parameters
 667  *      ARF  = auto-refill; hardware services a 1st-level miss by loading a PTE
 668  *              from the page table and storing it in one of the auto-refill ways;
 669  *              if this PTE load also misses, a miss exception is posted for s/w.
 670  *      min-wired = a "min-wired" way can be used to map a single (minimum-sized)
 671  *              page arbitrarily under program control; it has a single entry,
 672  *              is non-auto-refill (some other way(s) must be auto-refill),
 673  *              all its fields (VPN, PPN, ASID, CA) are all writable, and it
 674  *              supports the XCHAL_MMU_MIN_PTE_PAGE_SIZE page size (a current
 675  *              restriction is that this be the only page size it supports).
 676  *
 677  *  TLB way entries are virtually indexed.
 678  *  TLB ways that support multiple page sizes:
 679  *      - must have all writable VPN and PPN fields;
 680  *      - can only use one page size at any given time (eg. setup at startup),
 681  *        selected by the respective ITLBCFG or DTLBCFG special register,
 682  *        whose bits n*4+3 .. n*4 index the list of page sizes for way n
 683  *        (XCHAL_xTLB_SETm_PAGESZ_LOG2_LIST for set m corresponding to way n);
 684  *        this list may be sparse for auto-refill ways because auto-refill
 685  *        ways have independent lists of supported page sizes sharing a
 686  *        common encoding with PTE entries; the encoding is the index into
 687  *        this list; unsupported sizes for a given way are zero in the list;
 688  *        selecting unsupported sizes results in undefined hardware behaviour;
 689  *      - is only possible for ways 0 thru 7 (due to ITLBCFG/DTLBCFG definition).
 690  */
 691
 692 #define XCHAL_HAVE_CACHEATTR            0       /* 1 if CACHEATTR register present, 0 if TLBs present instead */
 693 #define XCHAL_HAVE_TLBS                 1       /* 1 if TLBs present, 0 if CACHEATTR present instead */
 694 #define XCHAL_HAVE_MMU                  XCHAL_HAVE_TLBS /* (DEPRECATED; use XCHAL_HAVE_TLBS instead; will be removed in future release) */
 695 #define XCHAL_HAVE_SPANNING_WAY         0       /* 1 if single way maps entire virtual address space in I+D */
 696 #define XCHAL_HAVE_IDENTITY_MAP         0       /* 1 if virtual addr == physical addr always, 0 otherwise */
 697 #define XCHAL_HAVE_MIMIC_CACHEATTR      0       /* 1 if have MMU that mimics a CACHEATTR config (CaMMU) */
 698 #define XCHAL_HAVE_XLT_CACHEATTR        0       /* 1 if have MMU that mimics a CACHEATTR config, but with translation (CaXltMMU) */
 699
 700 #define XCHAL_MMU_ASID_BITS             8       /* number of bits in ASIDs (address space IDs) */
 701 #define XCHAL_MMU_ASID_INVALID          0       /* ASID value indicating invalid address space */
 702 #define XCHAL_MMU_ASID_KERNEL           1       /* ASID value indicating kernel (ring 0) address space */
 703 #define XCHAL_MMU_RINGS                 4       /* number of rings supported (1..4) */
 704 #define XCHAL_MMU_RING_BITS             2       /* number of bits needed to hold ring number */
 705 #define XCHAL_MMU_SR_BITS               0       /* number of size-restriction bits supported */
 706 #define XCHAL_MMU_CA_BITS               4       /* number of bits needed to hold cache attribute encoding */
 707 #define XCHAL_MMU_MAX_PTE_PAGE_SIZE     12      /* max page size in a PTE structure (log2) */
 708 #define XCHAL_MMU_MIN_PTE_PAGE_SIZE     12      /* min page size in a PTE structure (log2) */
 709
 710
 711 /***  Instruction TLB:  ***/
 712
 713 #define XCHAL_ITLB_WAY_BITS             3       /* number of bits holding the ways */
 714 #define XCHAL_ITLB_WAYS                 7       /* number of ways (n-way set-associative TLB) */
 715 #define XCHAL_ITLB_ARF_WAYS             4       /* number of auto-refill ways */
 716 #define XCHAL_ITLB_SETS                 4       /* number of sets (groups of ways with identical settings) */
 717
 718 /*  Way set to which each way belongs:  */
 719 #define XCHAL_ITLB_WAY0_SET             0
 720 #define XCHAL_ITLB_WAY1_SET             0
 721 #define XCHAL_ITLB_WAY2_SET             0
 722 #define XCHAL_ITLB_WAY3_SET             0
 723 #define XCHAL_ITLB_WAY4_SET             1
 724 #define XCHAL_ITLB_WAY5_SET             2
 725 #define XCHAL_ITLB_WAY6_SET             3
 726
 727 /*  Ways sets that are used by hardware auto-refill (ARF):  */
 728 #define XCHAL_ITLB_ARF_SETS             1       /* number of auto-refill sets */
 729 #define XCHAL_ITLB_ARF_SET0             0       /* index of n'th auto-refill set */
 730
 731 /*  Way sets that are "min-wired" (see terminology comment above):  */
 732 #define XCHAL_ITLB_MINWIRED_SETS        0       /* number of "min-wired" sets */
 733
 734
 735 /*  ITLB way set 0 (group of ways 0 thru 3):  */
 736 #define XCHAL_ITLB_SET0_WAY                     0       /* index of first way in this way set */
 737 #define XCHAL_ITLB_SET0_WAYS                    4       /* number of (contiguous) ways in this way set */
 738 #define XCHAL_ITLB_SET0_ENTRIES_LOG2            2       /* log2(number of entries in this way) */
 739 #define XCHAL_ITLB_SET0_ENTRIES                 4       /* number of entries in this way (always a power of 2) */
 740 #define XCHAL_ITLB_SET0_ARF                     1       /* 1=autorefill by h/w, 0=non-autorefill (wired/constant/static) */
 741 #define XCHAL_ITLB_SET0_PAGESIZES               1       /* number of supported page sizes in this way */
 742 #define XCHAL_ITLB_SET0_PAGESZ_BITS             0       /* number of bits to encode the page size */
 743 #define XCHAL_ITLB_SET0_PAGESZ_LOG2_MIN         12      /* log2(minimum supported page size) */
 744 #define XCHAL_ITLB_SET0_PAGESZ_LOG2_MAX         12      /* log2(maximum supported page size) */
 745 #define XCHAL_ITLB_SET0_PAGESZ_LOG2_LIST        12      /* list of log2(page size)s, separated by XCHAL_SEP;
 746                                                            2^PAGESZ_BITS entries in list, unsupported entries are zero */
 747 #define XCHAL_ITLB_SET0_ASID_CONSTMASK          0       /* constant ASID bits; 0 if all writable */
 748 #define XCHAL_ITLB_SET0_VPN_CONSTMASK           0       /* constant VPN bits, not including entry index bits; 0 if all writable */
 749 #define XCHAL_ITLB_SET0_PPN_CONSTMASK           0       /* constant PPN bits, including entry index bits; 0 if all writable */
 750 #define XCHAL_ITLB_SET0_CA_CONSTMASK            0       /* constant CA bits; 0 if all writable */
 751 #define XCHAL_ITLB_SET0_ASID_RESET              0       /* 1 if ASID reset values defined (and all writable); 0 otherwise */
 752 #define XCHAL_ITLB_SET0_VPN_RESET               0       /* 1 if VPN reset values defined (and all writable); 0 otherwise */
 753 #define XCHAL_ITLB_SET0_PPN_RESET               0       /* 1 if PPN reset values defined (and all writable); 0 otherwise */
 754 #define XCHAL_ITLB_SET0_CA_RESET                0       /* 1 if CA reset values defined (and all writable); 0 otherwise */
 755
 756 /*  ITLB way set 1 (group of ways 4 thru 4):  */
 757 #define XCHAL_ITLB_SET1_WAY                     4       /* index of first way in this way set */
 758 #define XCHAL_ITLB_SET1_WAYS                    1       /* number of (contiguous) ways in this way set */
 759 #define XCHAL_ITLB_SET1_ENTRIES_LOG2            2       /* log2(number of entries in this way) */
 760 #define XCHAL_ITLB_SET1_ENTRIES                 4       /* number of entries in this way (always a power of 2) */
 761 #define XCHAL_ITLB_SET1_ARF                     0       /* 1=autorefill by h/w, 0=non-autorefill (wired/constant/static) */
 762 #define XCHAL_ITLB_SET1_PAGESIZES               4       /* number of supported page sizes in this way */
 763 #define XCHAL_ITLB_SET1_PAGESZ_BITS             2       /* number of bits to encode the page size */
 764 #define XCHAL_ITLB_SET1_PAGESZ_LOG2_MIN         20      /* log2(minimum supported page size) */
 765 #define XCHAL_ITLB_SET1_PAGESZ_LOG2_MAX         26      /* log2(maximum supported page size) */
 766 #define XCHAL_ITLB_SET1_PAGESZ_LOG2_LIST        20 XCHAL_SEP 22 XCHAL_SEP 24 XCHAL_SEP 26       /* list of log2(page size)s, separated by XCHAL_SEP;
 767                                                            2^PAGESZ_BITS entries in list, unsupported entries are zero */
 768 #define XCHAL_ITLB_SET1_ASID_CONSTMASK          0       /* constant ASID bits; 0 if all writable */
 769 #define XCHAL_ITLB_SET1_VPN_CONSTMASK           0       /* constant VPN bits, not including entry index bits; 0 if all writable */
 770 #define XCHAL_ITLB_SET1_PPN_CONSTMASK           0       /* constant PPN bits, including entry index bits; 0 if all writable */
 771 #define XCHAL_ITLB_SET1_CA_CONSTMASK            0       /* constant CA bits; 0 if all writable */
 772 #define XCHAL_ITLB_SET1_ASID_RESET              0       /* 1 if ASID reset values defined (and all writable); 0 otherwise */
 773 #define XCHAL_ITLB_SET1_VPN_RESET               0       /* 1 if VPN reset values defined (and all writable); 0 otherwise */
 774 #define XCHAL_ITLB_SET1_PPN_RESET               0       /* 1 if PPN reset values defined (and all writable); 0 otherwise */
 775 #define XCHAL_ITLB_SET1_CA_RESET                0       /* 1 if CA reset values defined (and all writable); 0 otherwise */
 776
 777 /*  ITLB way set 2 (group of ways 5 thru 5):  */
 778 #define XCHAL_ITLB_SET2_WAY                     5       /* index of first way in this way set */
 779 #define XCHAL_ITLB_SET2_WAYS                    1       /* number of (contiguous) ways in this way set */
 780 #define XCHAL_ITLB_SET2_ENTRIES_LOG2            1       /* log2(number of entries in this way) */
 781 #define XCHAL_ITLB_SET2_ENTRIES                 2       /* number of entries in this way (always a power of 2) */
 782 #define XCHAL_ITLB_SET2_ARF                     0       /* 1=autorefill by h/w, 0=non-autorefill (wired/constant/static) */
 783 #define XCHAL_ITLB_SET2_PAGESIZES               1       /* number of supported page sizes in this way */
 784 #define XCHAL_ITLB_SET2_PAGESZ_BITS             0       /* number of bits to encode the page size */
 785 #define XCHAL_ITLB_SET2_PAGESZ_LOG2_MIN         27      /* log2(minimum supported page size) */
 786 #define XCHAL_ITLB_SET2_PAGESZ_LOG2_MAX         27      /* log2(maximum supported page size) */
 787 #define XCHAL_ITLB_SET2_PAGESZ_LOG2_LIST        27      /* list of log2(page size)s, separated by XCHAL_SEP;
 788                                                            2^PAGESZ_BITS entries in list, unsupported entries are zero */
 789 #define XCHAL_ITLB_SET2_ASID_CONSTMASK          0xFF    /* constant ASID bits; 0 if all writable */
 790 #define XCHAL_ITLB_SET2_VPN_CONSTMASK           0xF0000000      /* constant VPN bits, not including entry index bits; 0 if all writable */
 791 #define XCHAL_ITLB_SET2_PPN_CONSTMASK           0xF8000000      /* constant PPN bits, including entry index bits; 0 if all writable */
 792 #define XCHAL_ITLB_SET2_CA_CONSTMASK            0x0000000F      /* constant CA bits; 0 if all writable */
 793 #define XCHAL_ITLB_SET2_ASID_RESET              0       /* 1 if ASID reset values defined (and all writable); 0 otherwise */
 794 #define XCHAL_ITLB_SET2_VPN_RESET               0       /* 1 if VPN reset values defined (and all writable); 0 otherwise */
 795 #define XCHAL_ITLB_SET2_PPN_RESET               0       /* 1 if PPN reset values defined (and all writable); 0 otherwise */
 796 #define XCHAL_ITLB_SET2_CA_RESET                0       /* 1 if CA reset values defined (and all writable); 0 otherwise */
 797 /*  Constant ASID values for each entry of ITLB way set 2 (because ASID_CONSTMASK is non-zero):  */
 798 #define XCHAL_ITLB_SET2_E0_ASID_CONST           0x01
 799 #define XCHAL_ITLB_SET2_E1_ASID_CONST           0x01
 800 /*  Constant VPN values for each entry of ITLB way set 2 (because VPN_CONSTMASK is non-zero):  */
 801 #define XCHAL_ITLB_SET2_E0_VPN_CONST            0xD0000000
 802 #define XCHAL_ITLB_SET2_E1_VPN_CONST            0xD8000000
 803 /*  Constant PPN values for each entry of ITLB way set 2 (because PPN_CONSTMASK is non-zero):  */
 804 #define XCHAL_ITLB_SET2_E0_PPN_CONST            0x00000000
 805 #define XCHAL_ITLB_SET2_E1_PPN_CONST            0x00000000
 806 /*  Constant CA values for each entry of ITLB way set 2 (because CA_CONSTMASK is non-zero):  */
 807 #define XCHAL_ITLB_SET2_E0_CA_CONST             0x07
 808 #define XCHAL_ITLB_SET2_E1_CA_CONST             0x03
 809
 810 /*  ITLB way set 3 (group of ways 6 thru 6):  */
 811 #define XCHAL_ITLB_SET3_WAY                     6       /* index of first way in this way set */
 812 #define XCHAL_ITLB_SET3_WAYS                    1       /* number of (contiguous) ways in this way set */
 813 #define XCHAL_ITLB_SET3_ENTRIES_LOG2            1       /* log2(number of entries in this way) */
 814 #define XCHAL_ITLB_SET3_ENTRIES                 2       /* number of entries in this way (always a power of 2) */
 815 #define XCHAL_ITLB_SET3_ARF                     0       /* 1=autorefill by h/w, 0=non-autorefill (wired/constant/static) */
 816 #define XCHAL_ITLB_SET3_PAGESIZES               1       /* number of supported page sizes in this way */
 817 #define XCHAL_ITLB_SET3_PAGESZ_BITS             0       /* number of bits to encode the page size */
 818 #define XCHAL_ITLB_SET3_PAGESZ_LOG2_MIN         28      /* log2(minimum supported page size) */
 819 #define XCHAL_ITLB_SET3_PAGESZ_LOG2_MAX         28      /* log2(maximum supported page size) */
 820 #define XCHAL_ITLB_SET3_PAGESZ_LOG2_LIST        28      /* list of log2(page size)s, separated by XCHAL_SEP;
 821                                                            2^PAGESZ_BITS entries in list, unsupported entries are zero */
 822 #define XCHAL_ITLB_SET3_ASID_CONSTMASK          0xFF    /* constant ASID bits; 0 if all writable */
 823 #define XCHAL_ITLB_SET3_VPN_CONSTMASK           0xE0000000      /* constant VPN bits, not including entry index bits; 0 if all writable */
 824 #define XCHAL_ITLB_SET3_PPN_CONSTMASK           0xF0000000      /* constant PPN bits, including entry index bits; 0 if all writable */
 825 #define XCHAL_ITLB_SET3_CA_CONSTMASK            0x0000000F      /* constant CA bits; 0 if all writable */
 826 #define XCHAL_ITLB_SET3_ASID_RESET              0       /* 1 if ASID reset values defined (and all writable); 0 otherwise */
 827 #define XCHAL_ITLB_SET3_VPN_RESET               0       /* 1 if VPN reset values defined (and all writable); 0 otherwise */
 828 #define XCHAL_ITLB_SET3_PPN_RESET               0       /* 1 if PPN reset values defined (and all writable); 0 otherwise */
 829 #define XCHAL_ITLB_SET3_CA_RESET                0       /* 1 if CA reset values defined (and all writable); 0 otherwise */
 830 /*  Constant ASID values for each entry of ITLB way set 3 (because ASID_CONSTMASK is non-zero):  */
 831 #define XCHAL_ITLB_SET3_E0_ASID_CONST           0x01
 832 #define XCHAL_ITLB_SET3_E1_ASID_CONST           0x01
 833 /*  Constant VPN values for each entry of ITLB way set 3 (because VPN_CONSTMASK is non-zero):  */
 834 #define XCHAL_ITLB_SET3_E0_VPN_CONST            0xE0000000
 835 #define XCHAL_ITLB_SET3_E1_VPN_CONST            0xF0000000
 836 /*  Constant PPN values for each entry of ITLB way set 3 (because PPN_CONSTMASK is non-zero):  */
 837 #define XCHAL_ITLB_SET3_E0_PPN_CONST            0xF0000000
 838 #define XCHAL_ITLB_SET3_E1_PPN_CONST            0xF0000000
 839 /*  Constant CA values for each entry of ITLB way set 3 (because CA_CONSTMASK is non-zero):  */
 840 #define XCHAL_ITLB_SET3_E0_CA_CONST             0x07
 841 #define XCHAL_ITLB_SET3_E1_CA_CONST             0x03
 842
 843 /*  Indexing macros:  */
 844 #define _XCHAL_ITLB_SET(n,_what)        XCHAL_ITLB_SET ## n ## _what
 845 #define XCHAL_ITLB_SET(n,what)          _XCHAL_ITLB_SET(n, _ ## what )
 846 #define _XCHAL_ITLB_SET_E(n,i,_what)    XCHAL_ITLB_SET ## n ## _E ## i ## _what
 847 #define XCHAL_ITLB_SET_E(n,i,what)      _XCHAL_ITLB_SET_E(n,i, _ ## what )
 848 /*
 849  *  Example use:  XCHAL_ITLB_SET(XCHAL_ITLB_ARF_SET0,ENTRIES)
 850  *      to get the value of XCHAL_ITLB_SET<n>_ENTRIES where <n> is the first auto-refill set.
 851  */
 852
 853
 854 /***  Data TLB:  ***/
 855
 856 #define XCHAL_DTLB_WAY_BITS             4       /* number of bits holding the ways */
 857 #define XCHAL_DTLB_WAYS                 10      /* number of ways (n-way set-associative TLB) */
 858 #define XCHAL_DTLB_ARF_WAYS             4       /* number of auto-refill ways */
 859 #define XCHAL_DTLB_SETS                 5       /* number of sets (groups of ways with identical settings) */
 860
 861 /*  Way set to which each way belongs:  */
 862 #define XCHAL_DTLB_WAY0_SET             0
 863 #define XCHAL_DTLB_WAY1_SET             0
 864 #define XCHAL_DTLB_WAY2_SET             0
 865 #define XCHAL_DTLB_WAY3_SET             0
 866 #define XCHAL_DTLB_WAY4_SET             1
 867 #define XCHAL_DTLB_WAY5_SET             2
 868 #define XCHAL_DTLB_WAY6_SET             3
 869 #define XCHAL_DTLB_WAY7_SET             4
 870 #define XCHAL_DTLB_WAY8_SET             4
 871 #define XCHAL_DTLB_WAY9_SET             4
 872
 873 /*  Ways sets that are used by hardware auto-refill (ARF):  */
 874 #define XCHAL_DTLB_ARF_SETS             1       /* number of auto-refill sets */
 875 #define XCHAL_DTLB_ARF_SET0             0       /* index of n'th auto-refill set */
 876
 877 /*  Way sets that are "min-wired" (see terminology comment above):  */
 878 #define XCHAL_DTLB_MINWIRED_SETS        1       /* number of "min-wired" sets */
 879 #define XCHAL_DTLB_MINWIRED_SET0        4       /* index of n'th "min-wired" set */
 880
 881
 882 /*  DTLB way set 0 (group of ways 0 thru 3):  */
 883 #define XCHAL_DTLB_SET0_WAY                     0       /* index of first way in this way set */
 884 #define XCHAL_DTLB_SET0_WAYS                    4       /* number of (contiguous) ways in this way set */
 885 #define XCHAL_DTLB_SET0_ENTRIES_LOG2            2       /* log2(number of entries in this way) */
 886 #define XCHAL_DTLB_SET0_ENTRIES                 4       /* number of entries in this way (always a power of 2) */
 887 #define XCHAL_DTLB_SET0_ARF                     1       /* 1=autorefill by h/w, 0=non-autorefill (wired/constant/static) */
 888 #define XCHAL_DTLB_SET0_PAGESIZES               1       /* number of supported page sizes in this way */
 889 #define XCHAL_DTLB_SET0_PAGESZ_BITS             0       /* number of bits to encode the page size */
 890 #define XCHAL_DTLB_SET0_PAGESZ_LOG2_MIN         12      /* log2(minimum supported page size) */
 891 #define XCHAL_DTLB_SET0_PAGESZ_LOG2_MAX         12      /* log2(maximum supported page size) */
 892 #define XCHAL_DTLB_SET0_PAGESZ_LOG2_LIST        12      /* list of log2(page size)s, separated by XCHAL_SEP;
 893                                                            2^PAGESZ_BITS entries in list, unsupported entries are zero */
 894 #define XCHAL_DTLB_SET0_ASID_CONSTMASK          0       /* constant ASID bits; 0 if all writable */
 895 #define XCHAL_DTLB_SET0_VPN_CONSTMASK           0       /* constant VPN bits, not including entry index bits; 0 if all writable */
 896 #define XCHAL_DTLB_SET0_PPN_CONSTMASK           0       /* constant PPN bits, including entry index bits; 0 if all writable */
 897 #define XCHAL_DTLB_SET0_CA_CONSTMASK            0       /* constant CA bits; 0 if all writable */
 898 #define XCHAL_DTLB_SET0_ASID_RESET              0       /* 1 if ASID reset values defined (and all writable); 0 otherwise */
 899 #define XCHAL_DTLB_SET0_VPN_RESET               0       /* 1 if VPN reset values defined (and all writable); 0 otherwise */
 900 #define XCHAL_DTLB_SET0_PPN_RESET               0       /* 1 if PPN reset values defined (and all writable); 0 otherwise */
 901 #define XCHAL_DTLB_SET0_CA_RESET                0       /* 1 if CA reset values defined (and all writable); 0 otherwise */
 902
 903 /*  DTLB way set 1 (group of ways 4 thru 4):  */
 904 #define XCHAL_DTLB_SET1_WAY                     4       /* index of first way in this way set */
 905 #define XCHAL_DTLB_SET1_WAYS                    1       /* number of (contiguous) ways in this way set */
 906 #define XCHAL_DTLB_SET1_ENTRIES_LOG2            2       /* log2(number of entries in this way) */
 907 #define XCHAL_DTLB_SET1_ENTRIES                 4       /* number of entries in this way (always a power of 2) */
 908 #define XCHAL_DTLB_SET1_ARF                     0       /* 1=autorefill by h/w, 0=non-autorefill (wired/constant/static) */
 909 #define XCHAL_DTLB_SET1_PAGESIZES               4       /* number of supported page sizes in this way */
 910 #define XCHAL_DTLB_SET1_PAGESZ_BITS             2       /* number of bits to encode the page size */
 911 #define XCHAL_DTLB_SET1_PAGESZ_LOG2_MIN         20      /* log2(minimum supported page size) */
 912 #define XCHAL_DTLB_SET1_PAGESZ_LOG2_MAX         26      /* log2(maximum supported page size) */
 913 #define XCHAL_DTLB_SET1_PAGESZ_LOG2_LIST        20 XCHAL_SEP 22 XCHAL_SEP 24 XCHAL_SEP 26       /* list of log2(page size)s, separated by XCHAL_SEP;
 914                                                            2^PAGESZ_BITS entries in list, unsupported entries are zero */
 915 #define XCHAL_DTLB_SET1_ASID_CONSTMASK          0       /* constant ASID bits; 0 if all writable */
 916 #define XCHAL_DTLB_SET1_VPN_CONSTMASK           0       /* constant VPN bits, not including entry index bits; 0 if all writable */
 917 #define XCHAL_DTLB_SET1_PPN_CONSTMASK           0       /* constant PPN bits, including entry index bits; 0 if all writable */
 918 #define XCHAL_DTLB_SET1_CA_CONSTMASK            0       /* constant CA bits; 0 if all writable */
 919 #define XCHAL_DTLB_SET1_ASID_RESET              0       /* 1 if ASID reset values defined (and all writable); 0 otherwise */
 920 #define XCHAL_DTLB_SET1_VPN_RESET               0       /* 1 if VPN reset values defined (and all writable); 0 otherwise */
 921 #define XCHAL_DTLB_SET1_PPN_RESET               0       /* 1 if PPN reset values defined (and all writable); 0 otherwise */
 922 #define XCHAL_DTLB_SET1_CA_RESET                0       /* 1 if CA reset values defined (and all writable); 0 otherwise */
 923
 924 /*  DTLB way set 2 (group of ways 5 thru 5):  */
 925 #define XCHAL_DTLB_SET2_WAY                     5       /* index of first way in this way set */
 926 #define XCHAL_DTLB_SET2_WAYS                    1       /* number of (contiguous) ways in this way set */
 927 #define XCHAL_DTLB_SET2_ENTRIES_LOG2            1       /* log2(number of entries in this way) */
 928 #define XCHAL_DTLB_SET2_ENTRIES                 2       /* number of entries in this way (always a power of 2) */
 929 #define XCHAL_DTLB_SET2_ARF                     0       /* 1=autorefill by h/w, 0=non-autorefill (wired/constant/static) */
 930 #define XCHAL_DTLB_SET2_PAGESIZES               1       /* number of supported page sizes in this way */
 931 #define XCHAL_DTLB_SET2_PAGESZ_BITS             0       /* number of bits to encode the page size */
 932 #define XCHAL_DTLB_SET2_PAGESZ_LOG2_MIN         27      /* log2(minimum supported page size) */
 933 #define XCHAL_DTLB_SET2_PAGESZ_LOG2_MAX         27      /* log2(maximum supported page size) */
 934 #define XCHAL_DTLB_SET2_PAGESZ_LOG2_LIST        27      /* list of log2(page size)s, separated by XCHAL_SEP;
 935                                                            2^PAGESZ_BITS entries in list, unsupported entries are zero */
 936 #define XCHAL_DTLB_SET2_ASID_CONSTMASK          0xFF    /* constant ASID bits; 0 if all writable */
 937 #define XCHAL_DTLB_SET2_VPN_CONSTMASK           0xF0000000      /* constant VPN bits, not including entry index bits; 0 if all writable */
 938 #define XCHAL_DTLB_SET2_PPN_CONSTMASK           0xF8000000      /* constant PPN bits, including entry index bits; 0 if all writable */
 939 #define XCHAL_DTLB_SET2_CA_CONSTMASK            0x0000000F      /* constant CA bits; 0 if all writable */
 940 #define XCHAL_DTLB_SET2_ASID_RESET              0       /* 1 if ASID reset values defined (and all writable); 0 otherwise */
 941 #define XCHAL_DTLB_SET2_VPN_RESET               0       /* 1 if VPN reset values defined (and all writable); 0 otherwise */
 942 #define XCHAL_DTLB_SET2_PPN_RESET               0       /* 1 if PPN reset values defined (and all writable); 0 otherwise */
 943 #define XCHAL_DTLB_SET2_CA_RESET                0       /* 1 if CA reset values defined (and all writable); 0 otherwise */
 944 /*  Constant ASID values for each entry of DTLB way set 2 (because ASID_CONSTMASK is non-zero):  */
 945 #define XCHAL_DTLB_SET2_E0_ASID_CONST           0x01
 946 #define XCHAL_DTLB_SET2_E1_ASID_CONST           0x01
 947 /*  Constant VPN values for each entry of DTLB way set 2 (because VPN_CONSTMASK is non-zero):  */
 948 #define XCHAL_DTLB_SET2_E0_VPN_CONST            0xD0000000
 949 #define XCHAL_DTLB_SET2_E1_VPN_CONST            0xD8000000
 950 /*  Constant PPN values for each entry of DTLB way set 2 (because PPN_CONSTMASK is non-zero):  */
 951 #define XCHAL_DTLB_SET2_E0_PPN_CONST            0x00000000
 952 #define XCHAL_DTLB_SET2_E1_PPN_CONST            0x00000000
 953 /*  Constant CA values for each entry of DTLB way set 2 (because CA_CONSTMASK is non-zero):  */
 954 #define XCHAL_DTLB_SET2_E0_CA_CONST             0x07
 955 #define XCHAL_DTLB_SET2_E1_CA_CONST             0x03
 956
 957 /*  DTLB way set 3 (group of ways 6 thru 6):  */
 958 #define XCHAL_DTLB_SET3_WAY                     6       /* index of first way in this way set */
 959 #define XCHAL_DTLB_SET3_WAYS                    1       /* number of (contiguous) ways in this way set */
 960 #define XCHAL_DTLB_SET3_ENTRIES_LOG2            1       /* log2(number of entries in this way) */
 961 #define XCHAL_DTLB_SET3_ENTRIES                 2       /* number of entries in this way (always a power of 2) */
 962 #define XCHAL_DTLB_SET3_ARF                     0       /* 1=autorefill by h/w, 0=non-autorefill (wired/constant/static) */
 963 #define XCHAL_DTLB_SET3_PAGESIZES               1       /* number of supported page sizes in this way */
 964 #define XCHAL_DTLB_SET3_PAGESZ_BITS             0       /* number of bits to encode the page size */
 965 #define XCHAL_DTLB_SET3_PAGESZ_LOG2_MIN         28      /* log2(minimum supported page size) */
 966 #define XCHAL_DTLB_SET3_PAGESZ_LOG2_MAX         28      /* log2(maximum supported page size) */
 967 #define XCHAL_DTLB_SET3_PAGESZ_LOG2_LIST        28      /* list of log2(page size)s, separated by XCHAL_SEP;
 968                                                            2^PAGESZ_BITS entries in list, unsupported entries are zero */
 969 #define XCHAL_DTLB_SET3_ASID_CONSTMASK          0xFF    /* constant ASID bits; 0 if all writable */
 970 #define XCHAL_DTLB_SET3_VPN_CONSTMASK           0xE0000000      /* constant VPN bits, not including entry index bits; 0 if all writable */
 971 #define XCHAL_DTLB_SET3_PPN_CONSTMASK           0xF0000000      /* constant PPN bits, including entry index bits; 0 if all writable */
 972 #define XCHAL_DTLB_SET3_CA_CONSTMASK            0x0000000F      /* constant CA bits; 0 if all writable */
 973 #define XCHAL_DTLB_SET3_ASID_RESET              0       /* 1 if ASID reset values defined (and all writable); 0 otherwise */
 974 #define XCHAL_DTLB_SET3_VPN_RESET               0       /* 1 if VPN reset values defined (and all writable); 0 otherwise */
 975 #define XCHAL_DTLB_SET3_PPN_RESET               0       /* 1 if PPN reset values defined (and all writable); 0 otherwise */
 976 #define XCHAL_DTLB_SET3_CA_RESET                0       /* 1 if CA reset values defined (and all writable); 0 otherwise */
 977 /*  Constant ASID values for each entry of DTLB way set 3 (because ASID_CONSTMASK is non-zero):  */
 978 #define XCHAL_DTLB_SET3_E0_ASID_CONST           0x01
 979 #define XCHAL_DTLB_SET3_E1_ASID_CONST           0x01
 980 /*  Constant VPN values for each entry of DTLB way set 3 (because VPN_CONSTMASK is non-zero):  */
 981 #define XCHAL_DTLB_SET3_E0_VPN_CONST            0xE0000000
 982 #define XCHAL_DTLB_SET3_E1_VPN_CONST            0xF0000000
 983 /*  Constant PPN values for each entry of DTLB way set 3 (because PPN_CONSTMASK is non-zero):  */
 984 #define XCHAL_DTLB_SET3_E0_PPN_CONST            0xF0000000
 985 #define XCHAL_DTLB_SET3_E1_PPN_CONST            0xF0000000
 986 /*  Constant CA values for each entry of DTLB way set 3 (because CA_CONSTMASK is non-zero):  */
 987 #define XCHAL_DTLB_SET3_E0_CA_CONST             0x07
 988 #define XCHAL_DTLB_SET3_E1_CA_CONST             0x03
 989
 990 /*  DTLB way set 4 (group of ways 7 thru 9):  */
 991 #define XCHAL_DTLB_SET4_WAY                     7       /* index of first way in this way set */
 992 #define XCHAL_DTLB_SET4_WAYS                    3       /* number of (contiguous) ways in this way set */
 993 #define XCHAL_DTLB_SET4_ENTRIES_LOG2            0       /* log2(number of entries in this way) */
 994 #define XCHAL_DTLB_SET4_ENTRIES                 1       /* number of entries in this way (always a power of 2) */
 995 #define XCHAL_DTLB_SET4_ARF                     0       /* 1=autorefill by h/w, 0=non-autorefill (wired/constant/static) */
 996 #define XCHAL_DTLB_SET4_PAGESIZES               1       /* number of supported page sizes in this way */
 997 #define XCHAL_DTLB_SET4_PAGESZ_BITS             0       /* number of bits to encode the page size */
 998 #define XCHAL_DTLB_SET4_PAGESZ_LOG2_MIN         12      /* log2(minimum supported page size) */
 999 #define XCHAL_DTLB_SET4_PAGESZ_LOG2_MAX         12      /* log2(maximum supported page size) */
1000 #define XCHAL_DTLB_SET4_PAGESZ_LOG2_LIST        12      /* list of log2(page size)s, separated by XCHAL_SEP;
1001                                                            2^PAGESZ_BITS entries in list, unsupported entries are zero */
1002 #define XCHAL_DTLB_SET4_ASID_CONSTMASK          0       /* constant ASID bits; 0 if all writable */
1003 #define XCHAL_DTLB_SET4_VPN_CONSTMASK           0       /* constant VPN bits, not including entry index bits; 0 if all writable */
1004 #define XCHAL_DTLB_SET4_PPN_CONSTMASK           0       /* constant PPN bits, including entry index bits; 0 if all writable */
1005 #define XCHAL_DTLB_SET4_CA_CONSTMASK            0       /* constant CA bits; 0 if all writable */
1006 #define XCHAL_DTLB_SET4_ASID_RESET              0       /* 1 if ASID reset values defined (and all writable); 0 otherwise */
1007 #define XCHAL_DTLB_SET4_VPN_RESET               0       /* 1 if VPN reset values defined (and all writable); 0 otherwise */
1008 #define XCHAL_DTLB_SET4_PPN_RESET               0       /* 1 if PPN reset values defined (and all writable); 0 otherwise */
1009 #define XCHAL_DTLB_SET4_CA_RESET                0       /* 1 if CA reset values defined (and all writable); 0 otherwise */
1010
1011 /*  Indexing macros:  */
1012 #define _XCHAL_DTLB_SET(n,_what)        XCHAL_DTLB_SET ## n ## _what
1013 #define XCHAL_DTLB_SET(n,what)          _XCHAL_DTLB_SET(n, _ ## what )
1014 #define _XCHAL_DTLB_SET_E(n,i,_what)    XCHAL_DTLB_SET ## n ## _E ## i ## _what
1015 #define XCHAL_DTLB_SET_E(n,i,what)      _XCHAL_DTLB_SET_E(n,i, _ ## what )
1016 /*
1017  *  Example use:  XCHAL_DTLB_SET(XCHAL_DTLB_ARF_SET0,ENTRIES)
1018  *      to get the value of XCHAL_DTLB_SET<n>_ENTRIES where <n> is the first auto-refill set.
1019  */
1020
1021
1022 /*
1023  *  Determine whether we have a full MMU (with Page Table and Protection)
1024  *  usable for an MMU-based OS:
1025  */
1026 #if XCHAL_HAVE_TLBS && !XCHAL_HAVE_SPANNING_WAY && XCHAL_ITLB_ARF_WAYS > 0 && XCHAL_DTLB_ARF_WAYS > 0 && XCHAL_MMU_RINGS >= 2
1027 # define XCHAL_HAVE_PTP_MMU             1       /* have full MMU (with page table [autorefill] and protection) */
1028 #else
1029 # define XCHAL_HAVE_PTP_MMU             0       /* don't have full MMU */
1030 #endif
1031
1032 /*
1033  *  For full MMUs, report kernel RAM segment and kernel I/O segment static page mappings:
1034  */
1035 #if XCHAL_HAVE_PTP_MMU
1036 #define XCHAL_KSEG_CACHED_VADDR         0xD0000000      /* virt.addr of kernel RAM cached static map */
1037 #define XCHAL_KSEG_CACHED_PADDR         0x00000000      /* phys.addr of kseg_cached */
1038 #define XCHAL_KSEG_CACHED_SIZE          0x08000000      /* size in bytes of kseg_cached (assumed power of 2!!!) */
1039 #define XCHAL_KSEG_BYPASS_VADDR         0xD8000000      /* virt.addr of kernel RAM bypass (uncached) static map */
1040 #define XCHAL_KSEG_BYPASS_PADDR         0x00000000      /* phys.addr of kseg_bypass */
1041 #define XCHAL_KSEG_BYPASS_SIZE          0x08000000      /* size in bytes of kseg_bypass (assumed power of 2!!!) */
1042
1043 #define XCHAL_KIO_CACHED_VADDR          0xE0000000      /* virt.addr of kernel I/O cached static map */
1044 #define XCHAL_KIO_CACHED_PADDR          0xF0000000      /* phys.addr of kio_cached */
1045 #define XCHAL_KIO_CACHED_SIZE           0x10000000      /* size in bytes of kio_cached (assumed power of 2!!!) */
1046 #define XCHAL_KIO_BYPASS_VADDR          0xF0000000      /* virt.addr of kernel I/O bypass (uncached) static map */
1047 #define XCHAL_KIO_BYPASS_PADDR          0xF0000000      /* phys.addr of kio_bypass */
1048 #define XCHAL_KIO_BYPASS_SIZE           0x10000000      /* size in bytes of kio_bypass (assumed power of 2!!!) */
1049
1050 #define XCHAL_SEG_MAPPABLE_VADDR        0x00000000      /* start of largest non-static-mapped virtual addr area */
1051 #define XCHAL_SEG_MAPPABLE_SIZE         0xD0000000      /* size in bytes of  "  */
1052 /* define XCHAL_SEG_MAPPABLE2_xxx if more areas present, sorted in order of descending size.  */
1053 #endif
1054
1055
1056 /*----------------------------------------------------------------------
1057                                 MISC
1058   ----------------------------------------------------------------------*/
1059
1060 #define XCHAL_NUM_WRITEBUFFER_ENTRIES   4       /* number of write buffer entries */
1061
1062 #define XCHAL_CORE_ID                   "linux_be"      /* configuration's alphanumeric core identifier
1063                                                            (CoreID) set in the Xtensa Processor Generator */
1064
1065 #define XCHAL_BUILD_UNIQUE_ID           0x00003256      /* software build-unique ID (22-bit) */
1066
1067 /*  These definitions describe the hardware targeted by this software:  */
1068 #define XCHAL_HW_CONFIGID0              0xC103D1FF      /* config ID reg 0 value (upper 32 of 64 bits) */
1069 #define XCHAL_HW_CONFIGID1              0x00803256      /* config ID reg 1 value (lower 32 of 64 bits) */
1070 #define XCHAL_CONFIGID0                 XCHAL_HW_CONFIGID0      /* for backward compatibility only -- don't use! */
1071 #define XCHAL_CONFIGID1                 XCHAL_HW_CONFIGID1      /* for backward compatibility only -- don't use! */
1072 #define XCHAL_HW_RELEASE_MAJOR          1050    /* major release of targeted hardware */
1073 #define XCHAL_HW_RELEASE_MINOR          1       /* minor release of targeted hardware */
1074 #define XCHAL_HW_RELEASE_NAME           "T1050.1"       /* full release name of targeted hardware */
1075 #define XTHAL_HW_REL_T1050      1
1076 #define XTHAL_HW_REL_T1050_1    1
1077 #define XCHAL_HW_CONFIGID_RELIABLE      1
1078
1079
1080 /*
1081  *  Miscellaneous special register fields:
1082  */
1083
1084
1085 /*  DBREAKC (special register number 160):  */
1086 #define XCHAL_DBREAKC_VALIDMASK 0xC000003F      /* bits of DBREAKC that are defined */
1087 /*  MASK field:  */
1088 #define XCHAL_DBREAKC_MASK_BITS         6               /* number of bits in MASK field */
1089 #define XCHAL_DBREAKC_MASK_NUM          64              /* max number of possible causes (2^bits) */
1090 #define XCHAL_DBREAKC_MASK_SHIFT        0               /* position of MASK bits in DBREAKC, starting from lsbit */
1091 #define XCHAL_DBREAKC_MASK_MASK         0x0000003F      /* mask of bits in MASK field of DBREAKC */
1092 /*  LOADBREAK field:  */
1093 #define XCHAL_DBREAKC_LOADBREAK_BITS    1               /* number of bits in LOADBREAK field */
1094 #define XCHAL_DBREAKC_LOADBREAK_NUM     2               /* max number of possible causes (2^bits) */
1095 #define XCHAL_DBREAKC_LOADBREAK_SHIFT   30              /* position of LOADBREAK bits in DBREAKC, starting from lsbit */
1096 #define XCHAL_DBREAKC_LOADBREAK_MASK    0x40000000      /* mask of bits in LOADBREAK field of DBREAKC */
1097 /*  STOREBREAK field:  */
1098 #define XCHAL_DBREAKC_STOREBREAK_BITS   1               /* number of bits in STOREBREAK field */
1099 #define XCHAL_DBREAKC_STOREBREAK_NUM    2               /* max number of possible causes (2^bits) */
1100 #define XCHAL_DBREAKC_STOREBREAK_SHIFT  31              /* position of STOREBREAK bits in DBREAKC, starting from lsbit */
1101 #define XCHAL_DBREAKC_STOREBREAK_MASK   0x80000000      /* mask of bits in STOREBREAK field of DBREAKC */
1102
1103 /*  PS (special register number 230):  */
1104 #define XCHAL_PS_VALIDMASK      0x00070FFF      /* bits of PS that are defined */
1105 /*  INTLEVEL field:  */
1106 #define XCHAL_PS_INTLEVEL_BITS  4               /* number of bits in INTLEVEL field */
1107 #define XCHAL_PS_INTLEVEL_NUM   16              /* max number of possible causes (2^bits) */
1108 #define XCHAL_PS_INTLEVEL_SHIFT 0               /* position of INTLEVEL bits in PS, starting from lsbit */
1109 #define XCHAL_PS_INTLEVEL_MASK  0x0000000F      /* mask of bits in INTLEVEL field of PS */
1110 /*  EXCM field:  */
1111 #define XCHAL_PS_EXCM_BITS      1               /* number of bits in EXCM field */
1112 #define XCHAL_PS_EXCM_NUM       2               /* max number of possible causes (2^bits) */
1113 #define XCHAL_PS_EXCM_SHIFT     4               /* position of EXCM bits in PS, starting from lsbit */
1114 #define XCHAL_PS_EXCM_MASK      0x00000010      /* mask of bits in EXCM field of PS */
1115 /*  PROGSTACK field:  */
1116 #define XCHAL_PS_PROGSTACK_BITS         1               /* number of bits in PROGSTACK field */
1117 #define XCHAL_PS_PROGSTACK_NUM          2               /* max number of possible causes (2^bits) */
1118 #define XCHAL_PS_PROGSTACK_SHIFT        5               /* position of PROGSTACK bits in PS, starting from lsbit */
1119 #define XCHAL_PS_PROGSTACK_MASK         0x00000020      /* mask of bits in PROGSTACK field of PS */
1120 /*  RING field:  */
1121 #define XCHAL_PS_RING_BITS      2               /* number of bits in RING field */
1122 #define XCHAL_PS_RING_NUM       4               /* max number of possible causes (2^bits) */
1123 #define XCHAL_PS_RING_SHIFT     6               /* position of RING bits in PS, starting from lsbit */
1124 #define XCHAL_PS_RING_MASK      0x000000C0      /* mask of bits in RING field of PS */
1125 /*  OWB field:  */
1126 #define XCHAL_PS_OWB_BITS       4               /* number of bits in OWB field */
1127 #define XCHAL_PS_OWB_NUM        16              /* max number of possible causes (2^bits) */
1128 #define XCHAL_PS_OWB_SHIFT      8               /* position of OWB bits in PS, starting from lsbit */
1129 #define XCHAL_PS_OWB_MASK       0x00000F00      /* mask of bits in OWB field of PS */
1130 /*  CALLINC field:  */
1131 #define XCHAL_PS_CALLINC_BITS   2               /* number of bits in CALLINC field */
1132 #define XCHAL_PS_CALLINC_NUM    4               /* max number of possible causes (2^bits) */
1133 #define XCHAL_PS_CALLINC_SHIFT  16              /* position of CALLINC bits in PS, starting from lsbit */
1134 #define XCHAL_PS_CALLINC_MASK   0x00030000      /* mask of bits in CALLINC field of PS */
1135 /*  WOE field:  */
1136 #define XCHAL_PS_WOE_BITS       1               /* number of bits in WOE field */
1137 #define XCHAL_PS_WOE_NUM        2               /* max number of possible causes (2^bits) */
1138 #define XCHAL_PS_WOE_SHIFT      18              /* position of WOE bits in PS, starting from lsbit */
1139 #define XCHAL_PS_WOE_MASK       0x00040000      /* mask of bits in WOE field of PS */
1140
1141 /*  EXCCAUSE (special register number 232):  */
1142 #define XCHAL_EXCCAUSE_VALIDMASK        0x0000003F      /* bits of EXCCAUSE that are defined */
1143 /*  EXCCAUSE field:  */
1144 #define XCHAL_EXCCAUSE_BITS             6               /* number of bits in EXCCAUSE register */
1145 #define XCHAL_EXCCAUSE_NUM              64              /* max number of possible causes (2^bits) */
1146 #define XCHAL_EXCCAUSE_SHIFT            0               /* position of EXCCAUSE bits in register, starting from lsbit */
1147 #define XCHAL_EXCCAUSE_MASK             0x0000003F      /* mask of bits in EXCCAUSE register */
1148
1149 /*  DEBUGCAUSE (special register number 233):  */
1150 #define XCHAL_DEBUGCAUSE_VALIDMASK      0x0000003F      /* bits of DEBUGCAUSE that are defined */
1151 /*  ICOUNT field:  */
1152 #define XCHAL_DEBUGCAUSE_ICOUNT_BITS    1               /* number of bits in ICOUNT field */
1153 #define XCHAL_DEBUGCAUSE_ICOUNT_NUM     2               /* max number of possible causes (2^bits) */
1154 #define XCHAL_DEBUGCAUSE_ICOUNT_SHIFT   0               /* position of ICOUNT bits in DEBUGCAUSE, starting from lsbit */
1155 #define XCHAL_DEBUGCAUSE_ICOUNT_MASK    0x00000001      /* mask of bits in ICOUNT field of DEBUGCAUSE */
1156 /*  IBREAK field:  */
1157 #define XCHAL_DEBUGCAUSE_IBREAK_BITS    1               /* number of bits in IBREAK field */
1158 #define XCHAL_DEBUGCAUSE_IBREAK_NUM     2               /* max number of possible causes (2^bits) */
1159 #define XCHAL_DEBUGCAUSE_IBREAK_SHIFT   1               /* position of IBREAK bits in DEBUGCAUSE, starting from lsbit */
1160 #define XCHAL_DEBUGCAUSE_IBREAK_MASK    0x00000002      /* mask of bits in IBREAK field of DEBUGCAUSE */
1161 /*  DBREAK field:  */
1162 #define XCHAL_DEBUGCAUSE_DBREAK_BITS    1               /* number of bits in DBREAK field */
1163 #define XCHAL_DEBUGCAUSE_DBREAK_NUM     2               /* max number of possible causes (2^bits) */
1164 #define XCHAL_DEBUGCAUSE_DBREAK_SHIFT   2               /* position of DBREAK bits in DEBUGCAUSE, starting from lsbit */
1165 #define XCHAL_DEBUGCAUSE_DBREAK_MASK    0x00000004      /* mask of bits in DBREAK field of DEBUGCAUSE */
1166 /*  BREAK field:  */
1167 #define XCHAL_DEBUGCAUSE_BREAK_BITS     1               /* number of bits in BREAK field */
1168 #define XCHAL_DEBUGCAUSE_BREAK_NUM      2               /* max number of possible causes (2^bits) */
1169 #define XCHAL_DEBUGCAUSE_BREAK_SHIFT    3               /* position of BREAK bits in DEBUGCAUSE, starting from lsbit */
1170 #define XCHAL_DEBUGCAUSE_BREAK_MASK     0x00000008      /* mask of bits in BREAK field of DEBUGCAUSE */
1171 /*  BREAKN field:  */
1172 #define XCHAL_DEBUGCAUSE_BREAKN_BITS    1               /* number of bits in BREAKN field */
1173 #define XCHAL_DEBUGCAUSE_BREAKN_NUM     2               /* max number of possible causes (2^bits) */
1174 #define XCHAL_DEBUGCAUSE_BREAKN_SHIFT   4               /* position of BREAKN bits in DEBUGCAUSE, starting from lsbit */
1175 #define XCHAL_DEBUGCAUSE_BREAKN_MASK    0x00000010      /* mask of bits in BREAKN field of DEBUGCAUSE */
1176 /*  DEBUGINT field:  */
1177 #define XCHAL_DEBUGCAUSE_DEBUGINT_BITS  1               /* number of bits in DEBUGINT field */
1178 #define XCHAL_DEBUGCAUSE_DEBUGINT_NUM   2               /* max number of possible causes (2^bits) */
1179 #define XCHAL_DEBUGCAUSE_DEBUGINT_SHIFT 5               /* position of DEBUGINT bits in DEBUGCAUSE, starting from lsbit */
1180 #define XCHAL_DEBUGCAUSE_DEBUGINT_MASK  0x00000020      /* mask of bits in DEBUGINT field of DEBUGCAUSE */
1181
1182
1183
1184 /*----------------------------------------------------------------------
1185                                 ISA
1186   ----------------------------------------------------------------------*/
1187
1188 #define XCHAL_HAVE_DENSITY              1       /* 1 if density option configured, 0 otherwise */
1189 #define XCHAL_HAVE_LOOPS                1       /* 1 if zero-overhead loops option configured, 0 otherwise */
1190 /*  Misc instructions:  */
1191 #define XCHAL_HAVE_NSA                  0       /* 1 if NSA/NSAU instructions option configured, 0 otherwise */
1192 #define XCHAL_HAVE_MINMAX               0       /* 1 if MIN/MAX instructions option configured, 0 otherwise */
1193 #define XCHAL_HAVE_SEXT                 0       /* 1 if sign-extend instruction option configured, 0 otherwise */
1194 #define XCHAL_HAVE_CLAMPS               0       /* 1 if CLAMPS instruction option configured, 0 otherwise */
1195 #define XCHAL_HAVE_MAC16                0       /* 1 if MAC16 option configured, 0 otherwise */
1196 #define XCHAL_HAVE_MUL16                0       /* 1 if 16-bit integer multiply option configured, 0 otherwise */
1197 /*#define XCHAL_HAVE_POPC               0*/     /* 1 if CRC instruction option configured, 0 otherwise */
1198 /*#define XCHAL_HAVE_CRC                0*/     /* 1 if POPC instruction option configured, 0 otherwise */
1199
1200 #define XCHAL_HAVE_SPECULATION          0       /* 1 if speculation option configured, 0 otherwise */
1201 /*#define XCHAL_HAVE_MP_SYNC            0*/     /* 1 if multiprocessor sync. option configured, 0 otherwise */
1202 #define XCHAL_HAVE_PRID                 0       /* 1 if processor ID register configured, 0 otherwise */
1203
1204 #define XCHAL_NUM_MISC_REGS             2       /* number of miscellaneous registers (0..4) */
1205
1206 /*  These relate a bit more to TIE:  */
1207 #define XCHAL_HAVE_BOOLEANS             0       /* 1 if booleans option configured, 0 otherwise */
1208 #define XCHAL_HAVE_MUL32                0       /* 1 if 32-bit integer multiply option configured, 0 otherwise */
1209 #define XCHAL_HAVE_MUL32_HIGH           0       /* 1 if MUL32 option includes MULUH and MULSH, 0 otherwise */
1210 #define XCHAL_HAVE_FP                   0       /* 1 if floating point option configured, 0 otherwise */
1211
1212
1213 /*----------------------------------------------------------------------
1214                                 DERIVED
1215   ----------------------------------------------------------------------*/
1216
1217 #if XCHAL_HAVE_BE
1218 #define XCHAL_INST_ILLN                 0xD60F          /* 2-byte illegal instruction, msb-first */
1219 #define XCHAL_INST_ILLN_BYTE0           0xD6            /* 2-byte illegal instruction, 1st byte */
1220 #define XCHAL_INST_ILLN_BYTE1           0x0F            /* 2-byte illegal instruction, 2nd byte */
1221 #else
1222 #define XCHAL_INST_ILLN                 0xF06D          /* 2-byte illegal instruction, lsb-first */
1223 #define XCHAL_INST_ILLN_BYTE0           0x6D            /* 2-byte illegal instruction, 1st byte */
1224 #define XCHAL_INST_ILLN_BYTE1           0xF0            /* 2-byte illegal instruction, 2nd byte */
1225 #endif
1226 /*  Belongs in xtensa/hal.h:  */
1227 #define XTHAL_INST_ILL                  0x000000        /* 3-byte illegal instruction */
1228
1229
1230 /*
1231  *  Because information as to exactly which hardware release is targeted
1232  *  by a given software build is not always available, compile-time HAL
1233  *  Hardware-Release "_AT" macros are fuzzy (return 0, 1, or XCHAL_MAYBE):
1234  */
1235 #ifndef XCHAL_HW_RELEASE_MAJOR
1236 # define XCHAL_HW_CONFIGID_RELIABLE     0
1237 #endif
1238 #if XCHAL_HW_CONFIGID_RELIABLE
1239 # define XCHAL_HW_RELEASE_AT_OR_BELOW(major,minor)      (XTHAL_REL_LE( XCHAL_HW_RELEASE_MAJOR,XCHAL_HW_RELEASE_MINOR, major,minor ) ? 1 : 0)
1240 # define XCHAL_HW_RELEASE_AT_OR_ABOVE(major,minor)      (XTHAL_REL_GE( XCHAL_HW_RELEASE_MAJOR,XCHAL_HW_RELEASE_MINOR, major,minor ) ? 1 : 0)
1241 # define XCHAL_HW_RELEASE_AT(major,minor)               (XTHAL_REL_EQ( XCHAL_HW_RELEASE_MAJOR,XCHAL_HW_RELEASE_MINOR, major,minor ) ? 1 : 0)
1242 # define XCHAL_HW_RELEASE_MAJOR_AT(major)               ((XCHAL_HW_RELEASE_MAJOR == (major)) ? 1 : 0)
1243 #else
1244 # define XCHAL_HW_RELEASE_AT_OR_BELOW(major,minor)      ( ((major) < 1040 && XCHAL_HAVE_XEA2) ? 0 \
1245                                                         : ((major) > 1050 && XCHAL_HAVE_XEA1) ? 1 \
1246                                                         : XTHAL_MAYBE )
1247 # define XCHAL_HW_RELEASE_AT_OR_ABOVE(major,minor)      ( ((major) >= 2000 && XCHAL_HAVE_XEA1) ? 0 \
1248                                                         : (XTHAL_REL_LE(major,minor, 1040,0) && XCHAL_HAVE_XEA2) ? 1 \
1249                                                         : XTHAL_MAYBE )
1250 # define XCHAL_HW_RELEASE_AT(major,minor)               ( (((major) < 1040 && XCHAL_HAVE_XEA2) || \
1251                                                            ((major) >= 2000 && XCHAL_HAVE_XEA1)) ? 0 : XTHAL_MAYBE)
1252 # define XCHAL_HW_RELEASE_MAJOR_AT(major)               XCHAL_HW_RELEASE_AT(major,0)
1253 #endif
1254
1255 /*
1256  *  Specific errata:
1257  */
1258
1259 /*
1260  *  Erratum T1020.H13, T1030.H7, T1040.H10, T1050.H4 (fixed in T1040.3 and T1050.1;
1261  *  relevant only in XEA1, kernel-vector mode, level-one interrupts and overflows enabled):
1262  */
1263 #define XCHAL_MAYHAVE_ERRATUM_XEA1KWIN  (XCHAL_HAVE_XEA1 && \
1264                                          (XCHAL_HW_RELEASE_AT_OR_BELOW(1040,2) != 0 \
1265                                           || XCHAL_HW_RELEASE_AT(1050,0)))
1266
1267
1268
1269 #endif /*XTENSA_CONFIG_CORE_H*/
1270