home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / asm-mips / sn / addrs.h next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  15.2 KB  |  458 lines

  1. /*
  2.  * This file is subject to the terms and conditions of the GNU General Public
  3.  * License.  See the file "COPYING" in the main directory of this archive
  4.  * for more details.
  5.  *
  6.  * Copyright (C) 1992 - 1997, 1999, 2000 Silicon Graphics, Inc.
  7.  * Copyright (C) 1999, 2000 by Ralf Baechle
  8.  */
  9. #ifndef _ASM_SN_ADDRS_H
  10. #define _ASM_SN_ADDRS_H
  11.  
  12.  
  13. #ifndef __ASSEMBLY__
  14. #include <linux/types.h>
  15. #endif /* !__ASSEMBLY__ */
  16.  
  17. #include <asm/addrspace.h>
  18. #include <asm/sn/kldir.h>
  19.  
  20. #if defined(CONFIG_SGI_IP27)
  21. #include <asm/sn/sn0/addrs.h>
  22. #elif defined(CONFIG_SGI_IP35)
  23. #include <asm/sn/sn1/addrs.h>
  24. #endif
  25.  
  26.  
  27. #ifndef __ASSEMBLY__
  28.  
  29. #if defined(CONFIG_SGI_IO)    /* FIXME */
  30. #define PS_UINT_CAST        (__psunsigned_t)
  31. #define UINT64_CAST        (__uint64_t)
  32. #else    /* CONFIG_SGI_IO */
  33. #define PS_UINT_CAST        (unsigned long)
  34. #define UINT64_CAST        (unsigned long)
  35. #endif    /* CONFIG_SGI_IO */
  36.  
  37. #define HUBREG_CAST        (volatile hubreg_t *)
  38.  
  39. #else /* __ASSEMBLY__ */
  40.  
  41. #define PS_UINT_CAST
  42. #define UINT64_CAST
  43. #define HUBREG_CAST
  44.  
  45. #endif /* __ASSEMBLY__ */
  46.  
  47.  
  48. #define NASID_GET_META(_n)    ((_n) >> NASID_LOCAL_BITS)
  49. #ifdef CONFIG_SGI_IP27
  50. #define NASID_GET_LOCAL(_n)    ((_n) & 0xf)
  51. #endif
  52. #define NASID_MAKE(_m, _l)    (((_m) << NASID_LOCAL_BITS) | (_l))
  53.  
  54. #define NODE_ADDRSPACE_MASK    (NODE_ADDRSPACE_SIZE - 1)
  55. #define TO_NODE_ADDRSPACE(_pa)    (UINT64_CAST (_pa) & NODE_ADDRSPACE_MASK)
  56.  
  57. #define CHANGE_ADDR_NASID(_pa, _nasid)    \
  58.         ((UINT64_CAST (_pa) & ~NASID_MASK) | \
  59.          (UINT64_CAST(_nasid) <<  NASID_SHFT))
  60.  
  61.  
  62. /*
  63.  * The following macros are used to index to the beginning of a specific
  64.  * node's address space.
  65.  */
  66.  
  67. #define NODE_OFFSET(_n)        (UINT64_CAST (_n) << NODE_SIZE_BITS)
  68.  
  69. #define NODE_CAC_BASE(_n)    (CAC_BASE   + NODE_OFFSET(_n))
  70. #define NODE_HSPEC_BASE(_n)    (HSPEC_BASE + NODE_OFFSET(_n))
  71. #define NODE_IO_BASE(_n)    (IO_BASE    + NODE_OFFSET(_n))
  72. #define NODE_MSPEC_BASE(_n)    (MSPEC_BASE + NODE_OFFSET(_n))
  73. #define NODE_UNCAC_BASE(_n)    (UNCAC_BASE + NODE_OFFSET(_n))
  74.  
  75. #define TO_NODE(_n, _x)        (NODE_OFFSET(_n)     | ((_x)           ))
  76. #define TO_NODE_CAC(_n, _x)    (NODE_CAC_BASE(_n)   | ((_x) & TO_PHYS_MASK))
  77. #define TO_NODE_UNCAC(_n, _x)    (NODE_UNCAC_BASE(_n) | ((_x) & TO_PHYS_MASK))
  78. #define TO_NODE_MSPEC(_n, _x)    (NODE_MSPEC_BASE(_n) | ((_x) & TO_PHYS_MASK))
  79. #define TO_NODE_HSPEC(_n, _x)    (NODE_HSPEC_BASE(_n) | ((_x) & TO_PHYS_MASK))
  80.  
  81.  
  82. #define RAW_NODE_SWIN_BASE(nasid, widget)                \
  83.     (NODE_IO_BASE(nasid) + (UINT64_CAST (widget) << SWIN_SIZE_BITS))
  84.  
  85. #define WIDGETID_GET(addr)    ((unsigned char)((addr >> SWIN_SIZE_BITS) & 0xff))
  86.  
  87. /*
  88.  * The following definitions pertain to the IO special address
  89.  * space.  They define the location of the big and little windows
  90.  * of any given node.
  91.  */
  92.  
  93. #define SWIN_SIZE_BITS        24
  94. #define SWIN_SIZE        (UINT64_CAST 1 << 24)
  95. #define    SWIN_SIZEMASK        (SWIN_SIZE - 1)
  96. #define    SWIN_WIDGET_MASK    0xF
  97.  
  98. /*
  99.  * Convert smallwindow address to xtalk address.
  100.  *
  101.  * 'addr' can be physical or virtual address, but will be converted
  102.  * to Xtalk address in the range 0 -> SWINZ_SIZEMASK
  103.  */
  104. #define    SWIN_WIDGETADDR(addr)    ((addr) & SWIN_SIZEMASK)
  105. #define    SWIN_WIDGETNUM(addr)    (((addr)  >> SWIN_SIZE_BITS) & SWIN_WIDGET_MASK)
  106. /*
  107.  * Verify if addr belongs to small window address on node with "nasid"
  108.  *
  109.  *
  110.  * NOTE: "addr" is expected to be XKPHYS address, and NOT physical
  111.  * address
  112.  *
  113.  *
  114.  */
  115. #define    NODE_SWIN_ADDR(nasid, addr)    \
  116.         (((addr) >= NODE_SWIN_BASE(nasid, 0))  && \
  117.          ((addr) <  (NODE_SWIN_BASE(nasid, HUB_NUM_WIDGET) + SWIN_SIZE)\
  118.          ))
  119.  
  120. /*
  121.  * The following define the major position-independent aliases used
  122.  * in SN.
  123.  *    UALIAS -- 256MB in size, reads in the UALIAS result in
  124.  *            uncached references to the memory of the reader's node.
  125.  *    CPU_UALIAS -- 128kb in size, the bottom part of UALIAS is flipped
  126.  *            depending on which CPU does the access to provide
  127.  *            all CPUs with unique uncached memory at low addresses.
  128.  *    LBOOT  -- 256MB in size, reads in the LBOOT area result in
  129.  *            uncached references to the local hub's boot prom and
  130.  *            other directory-bus connected devices.
  131.  *    IALIAS -- 8MB in size, reads in the IALIAS result in uncached
  132.  *            references to the local hub's registers.
  133.  */
  134.  
  135. #define UALIAS_BASE        HSPEC_BASE
  136. #define UALIAS_SIZE        0x10000000    /* 256 Megabytes */
  137. #define UALIAS_LIMIT        (UALIAS_BASE + UALIAS_SIZE)
  138.  
  139. /*
  140.  * The bottom of ualias space is flipped depending on whether you're
  141.  * processor 0 or 1 within a node.
  142.  */
  143. #ifdef CONFIG_SGI_IP27
  144. #define UALIAS_FLIP_BASE    UALIAS_BASE
  145. #define UALIAS_FLIP_SIZE    0x20000
  146. #define UALIAS_FLIP_BIT        0x10000
  147. #define UALIAS_FLIP_ADDR(_x)    (cputoslice(smp_processor_id()) ? \
  148.                  (_x) ^ UALIAS_FLIP_BIT : (_x))
  149.  
  150. #define LBOOT_BASE        (HSPEC_BASE + 0x10000000)
  151. #define LBOOT_SIZE        0x10000000
  152. #define LBOOT_LIMIT        (LBOOT_BASE + LBOOT_SIZE)
  153. #define LBOOT_STRIDE        0        /* IP27 has only one CPU PROM */
  154.  
  155. #endif
  156.  
  157. #define    HUB_REGISTER_WIDGET    1
  158. #define IALIAS_BASE        NODE_SWIN_BASE(0, HUB_REGISTER_WIDGET)
  159. #define IALIAS_SIZE        0x800000    /* 8 Megabytes */
  160. #define IS_IALIAS(_a)        (((_a) >= IALIAS_BASE) &&        \
  161.                  ((_a) < (IALIAS_BASE + IALIAS_SIZE)))
  162.  
  163. /*
  164.  * Macro for referring to Hub's RBOOT space
  165.  */
  166.  
  167. #ifdef CONFIG_SGI_IP27
  168. #define RBOOT_SIZE        0x10000000    /* 256 Megabytes */
  169. #define NODE_RBOOT_BASE(_n)    (NODE_HSPEC_BASE(_n) + 0x30000000)
  170. #define NODE_RBOOT_LIMIT(_n)    (NODE_RBOOT_BASE(_n) + RBOOT_SIZE)
  171.  
  172. #endif
  173.  
  174. /*
  175.  * Macros for referring the Hub's back door space
  176.  *
  177.  *   These macros correctly process addresses in any node's space.
  178.  *   WARNING: They won't work in assembler.
  179.  *
  180.  *   BDDIR_ENTRY_LO returns the address of the low double-word of the dir
  181.  *                  entry corresponding to a physical (Cac or Uncac) address.
  182.  *   BDDIR_ENTRY_HI returns the address of the high double-word of the entry.
  183.  *   BDPRT_ENTRY    returns the address of the double-word protection entry
  184.  *                  corresponding to the page containing the physical address.
  185.  *   BDPRT_ENTRY_S  Stores the value into the protection entry.
  186.  *   BDPRT_ENTRY_L  Load the value from the protection entry.
  187.  *   BDECC_ENTRY    returns the address of the ECC byte corresponding to a
  188.  *                  double-word at a specified physical address.
  189.  *   BDECC_ENTRY_H  returns the address of the two ECC bytes corresponding to a
  190.  *                  quad-word at a specified physical address.
  191.  */
  192. #define NODE_BDOOR_BASE(_n)    (NODE_HSPEC_BASE(_n) + (NODE_ADDRSPACE_SIZE/2))
  193.  
  194. #define NODE_BDECC_BASE(_n)    (NODE_BDOOR_BASE(_n))
  195. #define NODE_BDDIR_BASE(_n)    (NODE_BDOOR_BASE(_n) + (NODE_ADDRSPACE_SIZE/4))
  196. #ifdef CONFIG_SGI_IP27
  197. #define BDDIR_ENTRY_LO(_pa)    ((HSPEC_BASE +                      \
  198.                   NODE_ADDRSPACE_SIZE * 3 / 4 +              \
  199.                   0x200)                    | \
  200.                  UINT64_CAST (_pa)     & NASID_MASK        | \
  201.                  UINT64_CAST (_pa) >> 2 & BDDIR_UPPER_MASK  | \
  202.                  UINT64_CAST (_pa) >> 3 & 0x1f << 4)
  203.  
  204. #define BDDIR_ENTRY_HI(_pa)    ((HSPEC_BASE +                      \
  205.                   NODE_ADDRSPACE_SIZE * 3 / 4 +              \
  206.                   0x208)                    | \
  207.                  UINT64_CAST (_pa)     & NASID_MASK        | \
  208.                  UINT64_CAST (_pa) >> 2 & BDDIR_UPPER_MASK  | \
  209.                  UINT64_CAST (_pa) >> 3 & 0x1f << 4)
  210.  
  211. #define BDPRT_ENTRY(_pa, _rgn)    ((HSPEC_BASE +                      \
  212.                   NODE_ADDRSPACE_SIZE * 3 / 4)            | \
  213.                  UINT64_CAST (_pa)     & NASID_MASK        | \
  214.                  UINT64_CAST (_pa) >> 2 & BDDIR_UPPER_MASK  | \
  215.                  (_rgn) << 3)
  216. #define BDPRT_ENTRY_ADDR(_pa,_rgn) (BDPRT_ENTRY((_pa),(_rgn)))
  217. #define BDPRT_ENTRY_S(_pa,_rgn,_val) (*(__psunsigned_t *)BDPRT_ENTRY((_pa),(_rgn))=(_val))
  218. #define BDPRT_ENTRY_L(_pa,_rgn)    (*(__psunsigned_t *)BDPRT_ENTRY((_pa),(_rgn)))
  219.  
  220. #define BDECC_ENTRY(_pa)    ((HSPEC_BASE +                      \
  221.                   NODE_ADDRSPACE_SIZE / 2)            | \
  222.                  UINT64_CAST (_pa)     & NASID_MASK        | \
  223.                  UINT64_CAST (_pa) >> 2 & BDECC_UPPER_MASK  | \
  224.                  UINT64_CAST (_pa) >> 3 & 3)
  225.  
  226. /*
  227.  * Macro to convert a back door directory or protection address into the
  228.  *   raw physical address of the associated cache line or protection page.
  229.  */
  230. #define BDADDR_IS_DIR(_ba)    ((UINT64_CAST  (_ba) & 0x200) != 0)
  231. #define BDADDR_IS_PRT(_ba)    ((UINT64_CAST  (_ba) & 0x200) == 0)
  232.  
  233. #define BDDIR_TO_MEM(_ba)    (UINT64_CAST  (_ba) & NASID_MASK            | \
  234.                  (UINT64_CAST (_ba) & BDDIR_UPPER_MASK)<<2  | \
  235.                  (UINT64_CAST (_ba) & 0x1f << 4) << 3)
  236.  
  237. #define BDPRT_TO_MEM(_ba)     (UINT64_CAST  (_ba) & NASID_MASK        | \
  238.                  (UINT64_CAST (_ba) & BDDIR_UPPER_MASK)<<2)
  239.  
  240. #define BDECC_TO_MEM(_ba)    (UINT64_CAST  (_ba) & NASID_MASK        | \
  241.                  (UINT64_CAST (_ba) & BDECC_UPPER_MASK)<<2  | \
  242.                  (UINT64_CAST (_ba) & 3) << 3)
  243. #endif /* CONFIG_SGI_IP27 */
  244.  
  245.  
  246. /*
  247.  * The following macros produce the correct base virtual address for
  248.  * the hub registers.  The LOCAL_HUB_* macros produce the appropriate
  249.  * address for the local registers.  The REMOTE_HUB_* macro produce
  250.  * the address for the specified hub's registers.  The intent is
  251.  * that the appropriate PI, MD, NI, or II register would be substituted
  252.  * for _x.
  253.  */
  254.  
  255. #ifdef _STANDALONE
  256.  
  257. /* DO NOT USE THESE DIRECTLY IN THE KERNEL. SEE BELOW. */
  258. #define LOCAL_HUB(_x)        (HUBREG_CAST (IALIAS_BASE + (_x)))
  259. #define REMOTE_HUB(_n, _x)    (HUBREG_CAST (NODE_SWIN_BASE(_n, 1) +    \
  260.                           0x800000 + (_x)))
  261. #endif /* _STANDALONE */
  262.  
  263. /*
  264.  * WARNING:
  265.  *    When certain Hub chip workaround are defined, it's not sufficient
  266.  *    to dereference the *_HUB_ADDR() macros.  You should instead use
  267.  *    HUB_L() and HUB_S() if you must deal with pointers to hub registers.
  268.  *    Otherwise, the recommended approach is to use *_HUB_L() and *_HUB_S().
  269.  *    They're always safe.
  270.  */
  271. #define LOCAL_HUB_ADDR(_x)    (HUBREG_CAST (IALIAS_BASE + (_x)))
  272. #define REMOTE_HUB_ADDR(_n, _x)    (HUBREG_CAST (NODE_SWIN_BASE(_n, 1) +    \
  273.                           0x800000 + (_x)))
  274. #ifdef CONFIG_SGI_IP27
  275. #define REMOTE_HUB_PI_ADDR(_n, _sn, _x)    (HUBREG_CAST (NODE_SWIN_BASE(_n, 1) +    \
  276.                           0x800000 + (_x)))
  277. #endif /* CONFIG_SGI_IP27 */
  278.  
  279. #ifndef __ASSEMBLY__
  280.  
  281. #define HUB_L(_a)            *(_a)
  282. #define    HUB_S(_a, _d)            *(_a) = (_d)
  283.  
  284. #define LOCAL_HUB_L(_r)            HUB_L(LOCAL_HUB_ADDR(_r))
  285. #define LOCAL_HUB_S(_r, _d)        HUB_S(LOCAL_HUB_ADDR(_r), (_d))
  286. #define REMOTE_HUB_L(_n, _r)        HUB_L(REMOTE_HUB_ADDR((_n), (_r)))
  287. #define REMOTE_HUB_S(_n, _r, _d)    HUB_S(REMOTE_HUB_ADDR((_n), (_r)), (_d))
  288. #define REMOTE_HUB_PI_L(_n, _sn, _r)    HUB_L(REMOTE_HUB_PI_ADDR((_n), (_sn), (_r)))
  289. #define REMOTE_HUB_PI_S(_n, _sn, _r, _d) HUB_S(REMOTE_HUB_PI_ADDR((_n), (_sn), (_r)), (_d))
  290.  
  291. #endif /* !__ASSEMBLY__ */
  292.  
  293. /*
  294.  * The following macros are used to get to a hub/bridge register, given
  295.  * the base of the register space.
  296.  */
  297. #define HUB_REG_PTR(_base, _off)    \
  298.     (HUBREG_CAST ((__psunsigned_t)(_base) + (__psunsigned_t)(_off)))
  299.  
  300. #define HUB_REG_PTR_L(_base, _off)    \
  301.     HUB_L(HUB_REG_PTR((_base), (_off)))
  302.  
  303. #define HUB_REG_PTR_S(_base, _off, _data)    \
  304.     HUB_S(HUB_REG_PTR((_base), (_off)), (_data))
  305.  
  306. /*
  307.  * Software structure locations -- permanently fixed
  308.  *    See diagram in kldir.h
  309.  */
  310.  
  311. #define PHYS_RAMBASE        0x0
  312. #define K0_RAMBASE        PHYS_TO_K0(PHYS_RAMBASE)
  313.  
  314. #define EX_HANDLER_OFFSET(slice) ((slice) << 16)
  315. #define EX_HANDLER_ADDR(nasid, slice)                    \
  316.     PHYS_TO_K0(NODE_OFFSET(nasid) | EX_HANDLER_OFFSET(slice))
  317. #define EX_HANDLER_SIZE        0x0400
  318.  
  319. #define EX_FRAME_OFFSET(slice)    ((slice) << 16 | 0x400)
  320. #define EX_FRAME_ADDR(nasid, slice)                    \
  321.     PHYS_TO_K0(NODE_OFFSET(nasid) | EX_FRAME_OFFSET(slice))
  322. #define EX_FRAME_SIZE        0x0c00
  323.  
  324. #define ARCS_SPB_OFFSET        0x1000
  325. #define ARCS_SPB_ADDR(nasid)                        \
  326.     PHYS_TO_K0(NODE_OFFSET(nasid) | ARCS_SPB_OFFSET)
  327. #define ARCS_SPB_SIZE        0x0400
  328.  
  329. #ifdef _STANDALONE
  330.  
  331. #define ARCS_TVECTOR_OFFSET    0x2800
  332. #define ARCS_PVECTOR_OFFSET    0x2c00
  333.  
  334. /*
  335.  * These addresses are used by the master CPU to install the transfer
  336.  * and private vectors.  All others use the SPB to find them.
  337.  */
  338. #define TVADDR    (NODE_CAC_BASE(get_nasid()) + ARCS_TVECTOR_OFFSET)
  339. #define PVADDR    (NODE_CAC_BASE(get_nasid()) + ARCS_PVECTOR_OFFSET)
  340.  
  341. #endif /* _STANDALONE */
  342.  
  343. #define KLDIR_OFFSET        0x2000
  344. #define KLDIR_ADDR(nasid)                        \
  345.     TO_NODE_UNCAC((nasid), KLDIR_OFFSET)
  346. #define KLDIR_SIZE        0x0400
  347.  
  348.  
  349. /*
  350.  * Software structure locations -- indirected through KLDIR
  351.  *    See diagram in kldir.h
  352.  *
  353.  * Important:    All low memory structures must only be accessed
  354.  *        uncached, except for the symmon stacks.
  355.  */
  356.  
  357. #define KLI_LAUNCH        0        /* Dir. entries */
  358. #define KLI_KLCONFIG        1
  359. #define    KLI_NMI            2
  360. #define KLI_GDA            3
  361. #define KLI_FREEMEM        4
  362. #define    KLI_SYMMON_STK        5
  363. #define KLI_PI_ERROR        6
  364. #define KLI_KERN_VARS        7
  365. #define    KLI_KERN_XP        8
  366. #define    KLI_KERN_PARTID        9
  367.  
  368. #ifndef __ASSEMBLY__
  369.  
  370. #define KLD_BASE(nasid)        ((kldir_ent_t *) KLDIR_ADDR(nasid))
  371. #define KLD_LAUNCH(nasid)    (KLD_BASE(nasid) + KLI_LAUNCH)
  372. #define KLD_NMI(nasid)        (KLD_BASE(nasid) + KLI_NMI)
  373. #define KLD_KLCONFIG(nasid)    (KLD_BASE(nasid) + KLI_KLCONFIG)
  374. #define KLD_PI_ERROR(nasid)    (KLD_BASE(nasid) + KLI_PI_ERROR)
  375. #define KLD_GDA(nasid)        (KLD_BASE(nasid) + KLI_GDA)
  376. #define KLD_SYMMON_STK(nasid)    (KLD_BASE(nasid) + KLI_SYMMON_STK)
  377. #define KLD_FREEMEM(nasid)    (KLD_BASE(nasid) + KLI_FREEMEM)
  378. #define KLD_KERN_VARS(nasid)    (KLD_BASE(nasid) + KLI_KERN_VARS)
  379. #define    KLD_KERN_XP(nasid)    (KLD_BASE(nasid) + KLI_KERN_XP)
  380. #define    KLD_KERN_PARTID(nasid)    (KLD_BASE(nasid) + KLI_KERN_PARTID)
  381.  
  382. #define LAUNCH_OFFSET(nasid, slice)                    \
  383.     (KLD_LAUNCH(nasid)->offset +                    \
  384.      KLD_LAUNCH(nasid)->stride * (slice))
  385. #define LAUNCH_ADDR(nasid, slice)                    \
  386.     TO_NODE_UNCAC((nasid), LAUNCH_OFFSET(nasid, slice))
  387. #define LAUNCH_SIZE(nasid)    KLD_LAUNCH(nasid)->size
  388.  
  389. #define NMI_OFFSET(nasid, slice)                    \
  390.     (KLD_NMI(nasid)->offset +                    \
  391.      KLD_NMI(nasid)->stride * (slice))
  392. #define NMI_ADDR(nasid, slice)                        \
  393.     TO_NODE_UNCAC((nasid), NMI_OFFSET(nasid, slice))
  394. #define NMI_SIZE(nasid)    KLD_NMI(nasid)->size
  395.  
  396. #define KLCONFIG_OFFSET(nasid)    KLD_KLCONFIG(nasid)->offset
  397. #define KLCONFIG_ADDR(nasid)                        \
  398.     TO_NODE_UNCAC((nasid), KLCONFIG_OFFSET(nasid))
  399. #define KLCONFIG_SIZE(nasid)    KLD_KLCONFIG(nasid)->size
  400.  
  401. #define GDA_ADDR(nasid)        KLD_GDA(nasid)->pointer
  402. #define GDA_SIZE(nasid)        KLD_GDA(nasid)->size
  403.  
  404. #define SYMMON_STK_OFFSET(nasid, slice)                    \
  405.     (KLD_SYMMON_STK(nasid)->offset +                \
  406.      KLD_SYMMON_STK(nasid)->stride * (slice))
  407. #define SYMMON_STK_STRIDE(nasid)    KLD_SYMMON_STK(nasid)->stride
  408.  
  409. #define SYMMON_STK_ADDR(nasid, slice)                    \
  410.     TO_NODE_CAC((nasid), SYMMON_STK_OFFSET(nasid, slice))
  411.  
  412. #define SYMMON_STK_SIZE(nasid)    KLD_SYMMON_STK(nasid)->stride
  413.  
  414. #define SYMMON_STK_END(nasid)    (SYMMON_STK_ADDR(nasid, 0) + KLD_SYMMON_STK(nasid)->size)
  415.  
  416. /* loading symmon 4k below UNIX. the arcs loader needs the topaddr for a
  417.  * relocatable program
  418.  */
  419. #define    UNIX_DEBUG_LOADADDR    0x300000
  420. #define    SYMMON_LOADADDR(nasid)                        \
  421.     TO_NODE(nasid, PHYS_TO_K0(UNIX_DEBUG_LOADADDR - 0x1000))
  422.  
  423. #define FREEMEM_OFFSET(nasid)    KLD_FREEMEM(nasid)->offset
  424. #define FREEMEM_ADDR(nasid)    SYMMON_STK_END(nasid)
  425. /*
  426.  * XXX
  427.  * Fix this. FREEMEM_ADDR should be aware of if symmon is loaded.
  428.  * Also, it should take into account what prom thinks to be a safe
  429.  * address
  430.     PHYS_TO_K0(NODE_OFFSET(nasid) + FREEMEM_OFFSET(nasid))
  431.  */
  432. #define FREEMEM_SIZE(nasid)    KLD_FREEMEM(nasid)->size
  433.  
  434. #define PI_ERROR_OFFSET(nasid)    KLD_PI_ERROR(nasid)->offset
  435. #define PI_ERROR_ADDR(nasid)                        \
  436.     TO_NODE_UNCAC((nasid), PI_ERROR_OFFSET(nasid))
  437. #define PI_ERROR_SIZE(nasid)    KLD_PI_ERROR(nasid)->size
  438.  
  439. #define NODE_OFFSET_TO_K0(_nasid, _off)                    \
  440.     PHYS_TO_K0((NODE_OFFSET(_nasid) + (_off)) | CAC_BASE)
  441. #define NODE_OFFSET_TO_K1(_nasid, _off)                    \
  442.     TO_UNCAC((NODE_OFFSET(_nasid) + (_off)) | UNCAC_BASE)
  443. #define K0_TO_NODE_OFFSET(_k0addr)                    \
  444.     ((__psunsigned_t)(_k0addr) & NODE_ADDRSPACE_MASK)
  445.  
  446. #define KERN_VARS_ADDR(nasid)    KLD_KERN_VARS(nasid)->pointer
  447. #define KERN_VARS_SIZE(nasid)    KLD_KERN_VARS(nasid)->size
  448.  
  449. #define    KERN_XP_ADDR(nasid)    KLD_KERN_XP(nasid)->pointer
  450. #define    KERN_XP_SIZE(nasid)    KLD_KERN_XP(nasid)->size
  451.  
  452. #define GPDA_ADDR(nasid)    TO_NODE_CAC(nasid, GPDA_OFFSET)
  453.  
  454. #endif /* !__ASSEMBLY__ */
  455.  
  456.  
  457. #endif /* _ASM_SN_ADDRS_H */
  458.