Subversion Repositories HelenOS

Rev

Rev 3607 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2005 Jakub Jermar
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. /** @addtogroup sparc64mm  
  30.  * @{
  31.  */
  32. /** @file
  33.  */
  34.  
  35. #ifndef KERN_sparc64_TLB_H_
  36. #define KERN_sparc64_TLB_H_
  37.  
  38. #if defined (US)
  39. #define ITLB_ENTRY_COUNT        64
  40. #define DTLB_ENTRY_COUNT        64
  41. #define DTLB_MAX_LOCKED_ENTRIES     DTLB_ENTRY_COUNT
  42. #endif
  43.  
  44. /** TLB_DSMALL is the only of the three DMMUs that can hold locked entries. */
  45. #if defined (US3)
  46. #define DTLB_MAX_LOCKED_ENTRIES     16
  47. #endif
  48.  
  49. #define MEM_CONTEXT_KERNEL      0
  50. #define MEM_CONTEXT_TEMP        1
  51.  
  52. /** Page sizes. */
  53. #define PAGESIZE_8K 0
  54. #define PAGESIZE_64K    1
  55. #define PAGESIZE_512K   2
  56. #define PAGESIZE_4M 3
  57.  
  58. /** Bit width of the TLB-locked portion of kernel address space. */
  59. #define KERNEL_PAGE_WIDTH       22  /* 4M */
  60.  
  61. /* TLB Demap Operation types. */
  62. #define TLB_DEMAP_PAGE      0
  63. #define TLB_DEMAP_CONTEXT   1
  64. #if defined (US3)
  65. #define TLB_DEMAP_ALL       2
  66. #endif
  67.  
  68. #define TLB_DEMAP_TYPE_SHIFT    6
  69.  
  70. /* TLB Demap Operation Context register encodings. */
  71. #define TLB_DEMAP_PRIMARY   0
  72. #define TLB_DEMAP_SECONDARY 1
  73. #define TLB_DEMAP_NUCLEUS   2
  74.  
  75. /* There are more TLBs in one MMU in US3, their codes are defined here. */
  76. #if defined (US3)
  77. /* D-MMU: one small (16-entry) TLB and two big (512-entry) TLBs */
  78. #define TLB_DSMALL  0
  79. #define TLB_DBIG_0  2
  80. #define TLB_DBIG_1  3
  81.    
  82. /* I-MMU: one small (16-entry) TLB and one big TLB */
  83. #define TLB_ISMALL  0
  84. #define TLB_IBIG    2
  85. #endif
  86.  
  87. #define TLB_DEMAP_CONTEXT_SHIFT 4
  88.  
  89. /* TLB Tag Access shifts */
  90. #define TLB_TAG_ACCESS_CONTEXT_SHIFT    0
  91. #define TLB_TAG_ACCESS_CONTEXT_MASK ((1 << 13) - 1)
  92. #define TLB_TAG_ACCESS_VPN_SHIFT    13
  93.  
  94. #ifndef __ASM__
  95.  
  96. #include <arch/mm/tte.h>
  97. #include <arch/mm/mmu.h>
  98. #include <arch/mm/page.h>
  99. #include <arch/asm.h>
  100. #include <arch/barrier.h>
  101. #include <arch/types.h>
  102. #include <arch/register.h>
  103. #include <arch/cpu.h>
  104.  
  105. union tlb_context_reg {
  106.     uint64_t v;
  107.     struct {
  108.         unsigned long : 51;
  109.         unsigned context : 13;      /**< Context/ASID. */
  110.     } __attribute__ ((packed));
  111. };
  112. typedef union tlb_context_reg tlb_context_reg_t;
  113.  
  114. /** I-/D-TLB Data In/Access Register type. */
  115. typedef tte_data_t tlb_data_t;
  116.  
  117. /** I-/D-TLB Data Access Address in Alternate Space. */
  118.  
  119. #if defined (US)
  120.  
  121. union tlb_data_access_addr {
  122.     uint64_t value;
  123.     struct {
  124.         uint64_t : 55;
  125.         unsigned tlb_entry : 6;
  126.         unsigned : 3;
  127.     } __attribute__ ((packed));
  128. };
  129. typedef union tlb_data_access_addr dtlb_data_access_addr_t;
  130. typedef union tlb_data_access_addr dtlb_tag_read_addr_t;
  131. typedef union tlb_data_access_addr itlb_data_access_addr_t;
  132. typedef union tlb_data_access_addr itlb_tag_read_addr_t;
  133.  
  134. #elif defined (US3)
  135.  
  136. /*
  137.  * In US3, I-MMU and D-MMU have different formats of the data
  138.  * access register virtual address. In the corresponding
  139.  * structures the member variable for the entry number is
  140.  * called "local_tlb_entry" - it contrast with the "tlb_entry"
  141.  * for the US data access register VA structure. The rationale
  142.  * behind this is to prevent careless mistakes in the code
  143.  * caused by setting only the entry number and not the TLB
  144.  * number in the US3 code (when taking the code from US).
  145.  */
  146.  
  147. union dtlb_data_access_addr {
  148.     uint64_t value;
  149.     struct {
  150.         uint64_t : 45;
  151.         unsigned : 1;
  152.         unsigned tlb_number : 2;
  153.         unsigned : 4;
  154.         unsigned local_tlb_entry : 9;
  155.         unsigned : 3;
  156.     } __attribute__ ((packed));
  157. };
  158. typedef union dtlb_data_access_addr dtlb_data_access_addr_t;
  159. typedef union dtlb_data_access_addr dtlb_tag_read_addr_t;
  160.  
  161. union itlb_data_access_addr {
  162.     uint64_t value;
  163.     struct {
  164.         uint64_t : 45;
  165.         unsigned : 1;
  166.         unsigned tlb_number : 2;
  167.         unsigned : 6;
  168.         unsigned local_tlb_entry : 7;
  169.         unsigned : 3;
  170.     } __attribute__ ((packed));
  171. };
  172. typedef union itlb_data_access_addr itlb_data_access_addr_t;
  173. typedef union itlb_data_access_addr itlb_tag_read_addr_t;
  174.  
  175. #endif
  176.  
  177. /** I-/D-TLB Tag Read Register. */
  178. union tlb_tag_read_reg {
  179.     uint64_t value;
  180.     struct {
  181.         uint64_t vpn : 51;  /**< Virtual Address bits 63:13. */
  182.         unsigned context : 13;  /**< Context identifier. */
  183.     } __attribute__ ((packed));
  184. };
  185. typedef union tlb_tag_read_reg tlb_tag_read_reg_t;
  186. typedef union tlb_tag_read_reg tlb_tag_access_reg_t;
  187.  
  188.  
  189. /** TLB Demap Operation Address. */
  190. union tlb_demap_addr {
  191.     uint64_t value;
  192.     struct {
  193.         uint64_t vpn: 51;   /**< Virtual Address bits 63:13. */
  194. #if defined (US)
  195.         unsigned : 6;       /**< Ignored. */
  196.         unsigned type : 1;  /**< The type of demap operation. */
  197. #elif defined (US3)
  198.         unsigned : 5;       /**< Ignored. */
  199.         unsigned type: 2;   /**< The type of demap operation. */
  200. #endif
  201.         unsigned context : 2;   /**< Context register selection. */
  202.         unsigned : 4;       /**< Zero. */
  203.     } __attribute__ ((packed));
  204. };
  205. typedef union tlb_demap_addr tlb_demap_addr_t;
  206.  
  207. /** TLB Synchronous Fault Status Register. */
  208. union tlb_sfsr_reg {
  209.     uint64_t value;
  210.     struct {
  211. #if defined (US)
  212.         unsigned long : 40; /**< Implementation dependent. */
  213.         unsigned asi : 8;   /**< ASI. */
  214.         unsigned : 2;
  215.         unsigned ft : 7;    /**< Fault type. */
  216. #elif defined (US3)
  217.         unsigned long : 39; /**< Implementation dependent. */
  218.         unsigned nf : 1;    /**< Non-faulting load. */
  219.         unsigned asi : 8;   /**< ASI. */
  220.         unsigned tm : 1;    /**< I-TLB miss. */
  221.         unsigned : 3;       /**< Reserved. */
  222.         unsigned ft : 5;    /**< Fault type. */
  223. #endif
  224.         unsigned e : 1;     /**< Side-effect bit. */
  225.         unsigned ct : 2;    /**< Context Register selection. */
  226.         unsigned pr : 1;    /**< Privilege bit. */
  227.         unsigned w : 1;     /**< Write bit. */
  228.         unsigned ow : 1;    /**< Overwrite bit. */
  229.         unsigned fv : 1;    /**< Fault Valid bit. */
  230.     } __attribute__ ((packed));
  231. };
  232. typedef union tlb_sfsr_reg tlb_sfsr_reg_t;
  233.  
  234. #if defined (US3)
  235.  
  236. /*
  237.  * Functions for determining the number of entries in TLBs. They either return
  238.  * a constant value or a value based on the CPU autodetection.
  239.  */
  240.  
  241. /**
  242.  * Determine the number od entries in the DMMU's small TLB.
  243.  */
  244. static inline uint16_t tlb_dsmall_size(void)
  245. {
  246.     return 16;
  247. }
  248.  
  249. /**
  250.  * Determine the number od entries in each DMMU's big TLB.
  251.  */
  252. static inline uint16_t tlb_dbig_size(void)
  253. {
  254.     return 512;
  255. }
  256.  
  257. /**
  258.  * Determine the number od entries in the IMMU's small TLB.
  259.  */
  260. static inline uint16_t tlb_ismall_size(void)
  261. {
  262.     return 16;
  263. }
  264.  
  265. /**
  266.  * Determine the number od entries in the IMMU's big TLB.
  267.  */
  268. static inline uint16_t tlb_ibig_size(void)
  269. {
  270.     if (((ver_reg_t) ver_read()).impl == IMPL_ULTRASPARCIV_PLUS)
  271.         return 512;
  272.     else
  273.         return 128;
  274. }
  275.  
  276. #endif
  277.  
  278. /** Read MMU Primary Context Register.
  279.  *
  280.  * @return Current value of Primary Context Register.
  281.  */
  282. static inline uint64_t mmu_primary_context_read(void)
  283. {
  284.     return asi_u64_read(ASI_DMMU, VA_PRIMARY_CONTEXT_REG);
  285. }
  286.  
  287. /** Write MMU Primary Context Register.
  288.  *
  289.  * @param v New value of Primary Context Register.
  290.  */
  291. static inline void mmu_primary_context_write(uint64_t v)
  292. {
  293.     asi_u64_write(ASI_DMMU, VA_PRIMARY_CONTEXT_REG, v);
  294.     flush_pipeline();
  295. }
  296.  
  297. /** Read MMU Secondary Context Register.
  298.  *
  299.  * @return Current value of Secondary Context Register.
  300.  */
  301. static inline uint64_t mmu_secondary_context_read(void)
  302. {
  303.     return asi_u64_read(ASI_DMMU, VA_SECONDARY_CONTEXT_REG);
  304. }
  305.  
  306. /** Write MMU Primary Context Register.
  307.  *
  308.  * @param v New value of Primary Context Register.
  309.  */
  310. static inline void mmu_secondary_context_write(uint64_t v)
  311. {
  312.     asi_u64_write(ASI_DMMU, VA_SECONDARY_CONTEXT_REG, v);
  313.     flush_pipeline();
  314. }
  315.  
  316. #if defined (US)
  317.  
  318. /** Read IMMU TLB Data Access Register.
  319.  *
  320.  * @param entry TLB Entry index.
  321.  *
  322.  * @return Current value of specified IMMU TLB Data Access Register.
  323.  */
  324. static inline uint64_t itlb_data_access_read(index_t entry)
  325. {
  326.     itlb_data_access_addr_t reg;
  327.    
  328.     reg.value = 0;
  329.     reg.tlb_entry = entry;
  330.     return asi_u64_read(ASI_ITLB_DATA_ACCESS_REG, reg.value);
  331. }
  332.  
  333. /** Write IMMU TLB Data Access Register.
  334.  *
  335.  * @param entry TLB Entry index.
  336.  * @param value Value to be written.
  337.  */
  338. static inline void itlb_data_access_write(index_t entry, uint64_t value)
  339. {
  340.     itlb_data_access_addr_t reg;
  341.    
  342.     reg.value = 0;
  343.     reg.tlb_entry = entry;
  344.     asi_u64_write(ASI_ITLB_DATA_ACCESS_REG, reg.value, value);
  345.     flush_pipeline();
  346. }
  347.  
  348. /** Read DMMU TLB Data Access Register.
  349.  *
  350.  * @param entry TLB Entry index.
  351.  *
  352.  * @return Current value of specified DMMU TLB Data Access Register.
  353.  */
  354. static inline uint64_t dtlb_data_access_read(index_t entry)
  355. {
  356.     dtlb_data_access_addr_t reg;
  357.    
  358.     reg.value = 0;
  359.     reg.tlb_entry = entry;
  360.     return asi_u64_read(ASI_DTLB_DATA_ACCESS_REG, reg.value);
  361. }
  362.  
  363. /** Write DMMU TLB Data Access Register.
  364.  *
  365.  * @param entry TLB Entry index.
  366.  * @param value Value to be written.
  367.  */
  368. static inline void dtlb_data_access_write(index_t entry, uint64_t value)
  369. {
  370.     dtlb_data_access_addr_t reg;
  371.    
  372.     reg.value = 0;
  373.     reg.tlb_entry = entry;
  374.     asi_u64_write(ASI_DTLB_DATA_ACCESS_REG, reg.value, value);
  375.     membar();
  376. }
  377.  
  378. /** Read IMMU TLB Tag Read Register.
  379.  *
  380.  * @param entry TLB Entry index.
  381.  *
  382.  * @return Current value of specified IMMU TLB Tag Read Register.
  383.  */
  384. static inline uint64_t itlb_tag_read_read(index_t entry)
  385. {
  386.     itlb_tag_read_addr_t tag;
  387.  
  388.     tag.value = 0;
  389.     tag.tlb_entry = entry;
  390.     return asi_u64_read(ASI_ITLB_TAG_READ_REG, tag.value);
  391. }
  392.  
  393. /** Read DMMU TLB Tag Read Register.
  394.  *
  395.  * @param entry TLB Entry index.
  396.  *
  397.  * @return Current value of specified DMMU TLB Tag Read Register.
  398.  */
  399. static inline uint64_t dtlb_tag_read_read(index_t entry)
  400. {
  401.     dtlb_tag_read_addr_t tag;
  402.  
  403.     tag.value = 0;
  404.     tag.tlb_entry = entry;
  405.     return asi_u64_read(ASI_DTLB_TAG_READ_REG, tag.value);
  406. }
  407.  
  408. #elif defined (US3)
  409.  
  410.  
  411. /** Read IMMU TLB Data Access Register.
  412.  *
  413.  * @param tlb TLB number (one of TLB_ISMALL or TLB_IBIG)
  414.  * @param entry TLB Entry index.
  415.  *
  416.  * @return Current value of specified IMMU TLB Data Access Register.
  417.  */
  418. static inline uint64_t itlb_data_access_read(int tlb, index_t entry)
  419. {
  420.     itlb_data_access_addr_t reg;
  421.    
  422.     reg.value = 0;
  423.     reg.tlb_number = tlb;
  424.     reg.local_tlb_entry = entry;
  425.     return asi_u64_read(ASI_ITLB_DATA_ACCESS_REG, reg.value);
  426. }
  427.  
  428. /** Write IMMU TLB Data Access Register.
  429.  * @param tlb TLB number (one of TLB_ISMALL or TLB_IBIG)
  430.  * @param entry TLB Entry index.
  431.  * @param value Value to be written.
  432.  */
  433. static inline void itlb_data_access_write(int tlb, index_t entry,
  434.     uint64_t value)
  435. {
  436.     itlb_data_access_addr_t reg;
  437.    
  438.     reg.value = 0;
  439.     reg.tlb_number = tlb;
  440.     reg.local_tlb_entry = entry;
  441.     asi_u64_write(ASI_ITLB_DATA_ACCESS_REG, reg.value, value);
  442.     flush_pipeline();
  443. }
  444.  
  445. /** Read DMMU TLB Data Access Register.
  446.  *
  447.  * @param tlb TLB number (one of TLB_DSMALL, TLB_DBIG, TLB_DBIG)
  448.  * @param entry TLB Entry index.
  449.  *
  450.  * @return Current value of specified DMMU TLB Data Access Register.
  451.  */
  452. static inline uint64_t dtlb_data_access_read(int tlb, index_t entry)
  453. {
  454.     dtlb_data_access_addr_t reg;
  455.    
  456.     reg.value = 0;
  457.     reg.tlb_number = tlb;
  458.     reg.local_tlb_entry = entry;
  459.     return asi_u64_read(ASI_DTLB_DATA_ACCESS_REG, reg.value);
  460. }
  461.  
  462. /** Write DMMU TLB Data Access Register.
  463.  *
  464.  * @param tlb TLB number (one of TLB_DSMALL, TLB_DBIG_0, TLB_DBIG_1)  
  465.  * @param entry TLB Entry index.
  466.  * @param value Value to be written.
  467.  */
  468. static inline void dtlb_data_access_write(int tlb, index_t entry,
  469.     uint64_t value)
  470. {
  471.     dtlb_data_access_addr_t reg;
  472.    
  473.     reg.value = 0;
  474.     reg.tlb_number = tlb;
  475.     reg.local_tlb_entry = entry;
  476.     asi_u64_write(ASI_DTLB_DATA_ACCESS_REG, reg.value, value);
  477.     membar();
  478. }
  479.  
  480. /** Read IMMU TLB Tag Read Register.
  481.  *
  482.  * @param tlb TLB number (one of TLB_ISMALL or TLB_IBIG)
  483.  * @param entry TLB Entry index.
  484.  *
  485.  * @return Current value of specified IMMU TLB Tag Read Register.
  486.  */
  487. static inline uint64_t itlb_tag_read_read(int tlb, index_t entry)
  488. {
  489.     itlb_tag_read_addr_t tag;
  490.  
  491.     tag.value = 0;
  492.     tag.tlb_number = tlb;
  493.     tag.local_tlb_entry = entry;
  494.     return asi_u64_read(ASI_ITLB_TAG_READ_REG, tag.value);
  495. }
  496.  
  497. /** Read DMMU TLB Tag Read Register.
  498.  *
  499.  * @param tlb TLB number (one of TLB_DSMALL, TLB_DBIG_0, TLB_DBIG_1)  
  500.  * @param entry TLB Entry index.
  501.  *
  502.  * @return Current value of specified DMMU TLB Tag Read Register.
  503.  */
  504. static inline uint64_t dtlb_tag_read_read(int tlb, index_t entry)
  505. {
  506.     dtlb_tag_read_addr_t tag;
  507.  
  508.     tag.value = 0;
  509.     tag.tlb_number = tlb;
  510.     tag.local_tlb_entry = entry;
  511.     return asi_u64_read(ASI_DTLB_TAG_READ_REG, tag.value);
  512. }
  513.  
  514. #endif
  515.  
  516.  
  517. /** Write IMMU TLB Tag Access Register.
  518.  *
  519.  * @param v Value to be written.
  520.  */
  521. static inline void itlb_tag_access_write(uint64_t v)
  522. {
  523.     asi_u64_write(ASI_IMMU, VA_IMMU_TAG_ACCESS, v);
  524.     flush_pipeline();
  525. }
  526.  
  527. /** Read IMMU TLB Tag Access Register.
  528.  *
  529.  * @return Current value of IMMU TLB Tag Access Register.
  530.  */
  531. static inline uint64_t itlb_tag_access_read(void)
  532. {
  533.     return asi_u64_read(ASI_IMMU, VA_IMMU_TAG_ACCESS);
  534. }
  535.  
  536. /** Write DMMU TLB Tag Access Register.
  537.  *
  538.  * @param v Value to be written.
  539.  */
  540. static inline void dtlb_tag_access_write(uint64_t v)
  541. {
  542.     asi_u64_write(ASI_DMMU, VA_DMMU_TAG_ACCESS, v);
  543.     membar();
  544. }
  545.  
  546. /** Read DMMU TLB Tag Access Register.
  547.  *
  548.  * @return Current value of DMMU TLB Tag Access Register.
  549.  */
  550. static inline uint64_t dtlb_tag_access_read(void)
  551. {
  552.     return asi_u64_read(ASI_DMMU, VA_DMMU_TAG_ACCESS);
  553. }
  554.  
  555.  
  556. /** Write IMMU TLB Data in Register.
  557.  *
  558.  * @param v Value to be written.
  559.  */
  560. static inline void itlb_data_in_write(uint64_t v)
  561. {
  562.     asi_u64_write(ASI_ITLB_DATA_IN_REG, 0, v);
  563.     flush_pipeline();
  564. }
  565.  
  566. /** Write DMMU TLB Data in Register.
  567.  *
  568.  * @param v Value to be written.
  569.  */
  570. static inline void dtlb_data_in_write(uint64_t v)
  571. {
  572.     asi_u64_write(ASI_DTLB_DATA_IN_REG, 0, v);
  573.     membar();
  574. }
  575.  
  576. /** Read ITLB Synchronous Fault Status Register.
  577.  *
  578.  * @return Current content of I-SFSR register.
  579.  */
  580. static inline uint64_t itlb_sfsr_read(void)
  581. {
  582.     return asi_u64_read(ASI_IMMU, VA_IMMU_SFSR);
  583. }
  584.  
  585. /** Write ITLB Synchronous Fault Status Register.
  586.  *
  587.  * @param v New value of I-SFSR register.
  588.  */
  589. static inline void itlb_sfsr_write(uint64_t v)
  590. {
  591.     asi_u64_write(ASI_IMMU, VA_IMMU_SFSR, v);
  592.     flush_pipeline();
  593. }
  594.  
  595. /** Read DTLB Synchronous Fault Status Register.
  596.  *
  597.  * @return Current content of D-SFSR register.
  598.  */
  599. static inline uint64_t dtlb_sfsr_read(void)
  600. {
  601.     return asi_u64_read(ASI_DMMU, VA_DMMU_SFSR);
  602. }
  603.  
  604. /** Write DTLB Synchronous Fault Status Register.
  605.  *
  606.  * @param v New value of D-SFSR register.
  607.  */
  608. static inline void dtlb_sfsr_write(uint64_t v)
  609. {
  610.     asi_u64_write(ASI_DMMU, VA_DMMU_SFSR, v);
  611.     membar();
  612. }
  613.  
  614. /** Read DTLB Synchronous Fault Address Register.
  615.  *
  616.  * @return Current content of D-SFAR register.
  617.  */
  618. static inline uint64_t dtlb_sfar_read(void)
  619. {
  620.     return asi_u64_read(ASI_DMMU, VA_DMMU_SFAR);
  621. }
  622.  
  623. /** Perform IMMU TLB Demap Operation.
  624.  *
  625.  * @param type
  626.  *  Selects between context and page demap
  627.  *  (and entire MMU demap on US3).
  628.  * @param context_encoding Specifies which Context register has Context ID for
  629.  *  demap.
  630.  * @param page Address which is on the page to be demapped.
  631.  */
  632. static inline void itlb_demap(int type, int context_encoding, uintptr_t page)
  633. {
  634.     tlb_demap_addr_t da;
  635.     page_address_t pg;
  636.    
  637.     da.value = 0;
  638.     pg.address = page;
  639.    
  640.     da.type = type;
  641.     da.context = context_encoding;
  642.     da.vpn = pg.vpn;
  643.    
  644.     asi_u64_write(ASI_IMMU_DEMAP, da.value, 0); /* da.value is the
  645.                              * address within the
  646.                              * ASI */
  647.     flush_pipeline();
  648. }
  649.  
  650. /** Perform DMMU TLB Demap Operation.
  651.  *
  652.  * @param type
  653.  *  Selects between context and page demap
  654.  *  (and entire MMU demap on US3).
  655.  * @param context_encoding Specifies which Context register has Context ID for
  656.  *   demap.
  657.  * @param page Address which is on the page to be demapped.
  658.  */
  659. static inline void dtlb_demap(int type, int context_encoding, uintptr_t page)
  660. {
  661.     tlb_demap_addr_t da;
  662.     page_address_t pg;
  663.    
  664.     da.value = 0;
  665.     pg.address = page;
  666.    
  667.     da.type = type;
  668.     da.context = context_encoding;
  669.     da.vpn = pg.vpn;
  670.    
  671.     asi_u64_write(ASI_DMMU_DEMAP, da.value, 0); /* da.value is the
  672.                              * address within the
  673.                              * ASI */
  674.     membar();
  675. }
  676.  
  677. extern void fast_instruction_access_mmu_miss(unative_t unused, istate_t *istate);
  678. extern void fast_data_access_mmu_miss(tlb_tag_access_reg_t tag, istate_t *istate);
  679. extern void fast_data_access_protection(tlb_tag_access_reg_t tag , istate_t *istate);
  680.  
  681. extern void dtlb_insert_mapping(uintptr_t page, uintptr_t frame, int pagesize, bool locked, bool cacheable);
  682.  
  683. extern void dump_sfsr_and_sfar(void);
  684.  
  685. #endif /* !def __ASM__ */
  686.  
  687. #endif
  688.  
  689. /** @}
  690.  */
  691.