\hypertarget{RIM_8h}{
\section{RIM.h File Reference}
\label{RIM_8h}\index{RIM.h@{RIM.h}}
}
Public definitions for the RIM (Register In-Memory) facility. 

{\tt \#include $<$stdlib.h$>$}\par


Include dependency graph for RIM.h:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=87pt]{RIM_8h__incl}
\end{center}
\end{figure}


This graph shows which files directly or indirectly include this file:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=223pt]{RIM_8h__dep__incl}
\end{center}
\end{figure}
\subsection*{Data Structures}
\begin{CompactItemize}
\item 
struct \hyperlink{struct__Layer__addr}{\_\-Layer\_\-addr}
\begin{CompactList}\small\item\em Address of a TFE/SPT node. \item\end{CompactList}\item 
struct \hyperlink{struct__ACD__addr}{\_\-ACD\_\-addr}
\begin{CompactList}\small\item\em Address of a ARC/AFE node. \item\end{CompactList}\item 
struct \hyperlink{struct__TEM__addr}{\_\-TEM\_\-addr}
\begin{CompactList}\small\item\em Address of a TEM/TIC/CCC/TCC/CRC/TRC/CFE node. \item\end{CompactList}\item 
union \hyperlink{union__RIM__addr}{\_\-RIM\_\-addr}
\begin{CompactList}\small\item\em Union of all the address structures and an array, used for hierarchical leaf identification throughout RIM. \item\end{CompactList}\item 
struct \hyperlink{struct__RIM__rqstInfo}{\_\-RIM\_\-rqst\-Info}
\begin{CompactList}\small\item\em Information describing a read request. \item\end{CompactList}\end{CompactItemize}
\subsection*{Typedefs}
\begin{CompactItemize}
\item 
\hypertarget{RIM_8h_a0}{
typedef unsigned \hyperlink{RIM_8h_a0}{RIM\_\-type}}
\label{RIM_8h_a0}

\begin{CompactList}\small\item\em Creates a new type used to identify components (TEM, TFE etc). \item\end{CompactList}\item 
\hypertarget{RIM_8h_a1}{
typedef RIM\_\- \hyperlink{RIM_8h_a1}{RIM}}
\label{RIM_8h_a1}

\begin{CompactList}\small\item\em Forward declaration of the RIM structure. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a2}{
typedef RIM\_\-map\_\- \hyperlink{RIM_8h_a2}{RIM\_\-map}}
\label{RIM_8h_a2}

\begin{CompactList}\small\item\em Forward declaration of the RIM\_\-map structure, a bit-map of all the LAT components. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a3}{
typedef \hyperlink{struct__Layer__addr}{\_\-Layer\_\-addr} \hyperlink{RIM_8h_a3}{Layer\_\-addr}}
\label{RIM_8h_a3}

\begin{CompactList}\small\item\em Address of a TFE/SPT node. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a4}{
typedef \hyperlink{struct__ACD__addr}{\_\-ACD\_\-addr} \hyperlink{RIM_8h_a4}{ACD\_\-addr}}
\label{RIM_8h_a4}

\begin{CompactList}\small\item\em Address of a ARC/AFE node. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a5}{
typedef \hyperlink{struct__TEM__addr}{\_\-TEM\_\-addr} \hyperlink{RIM_8h_a5}{TEM\_\-addr}}
\label{RIM_8h_a5}

\begin{CompactList}\small\item\em Address of a TEM/TIC/CCC/TCC/CRC/TRC/CFE node. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a6}{
typedef \hyperlink{union__RIM__addr}{\_\-RIM\_\-addr} \hyperlink{RIM_8h_a6}{RIM\_\-addr}}
\label{RIM_8h_a6}

\begin{CompactList}\small\item\em Union of all the address structures and an array, used for hierarchical leaf identification throughout RIM. \item\end{CompactList}\item 
typedef \hyperlink{struct__RIM__rqstInfo}{\_\-RIM\_\-rqst\-Info} \hyperlink{RIM_8h_a7}{RIM\_\-rqst\-Info}
\begin{CompactList}\small\item\em Information describing a read request. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a8}{
typedef void \hyperlink{RIM_8h_a8}{RIM\_\-decode\-Fn} (unsigned short $\ast$pkt, void $\ast$ptr, const \hyperlink{struct__RIM__rqstInfo}{RIM\_\-rqst\-Info} $\ast$info)}
\label{RIM_8h_a8}

\begin{CompactList}\small\item\em Function that Decodes the response from one type of LAT register. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a9}{
typedef unsigned \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} (void $\ast$param, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$addr, unsigned reg\-Id, const void $\ast$value)}
\label{RIM_8h_a9}

\begin{CompactList}\small\item\em Function that Loads one type of LAT register. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a10}{
typedef unsigned \hyperlink{RIM_8h_a10}{RIM\_\-read\-Fn} (void $\ast$param, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$addr, unsigned reg\-Id, \hyperlink{RIM_8h_a8}{RIM\_\-decode\-Fn} $\ast$decode\-Fn, void $\ast$dst, const \hyperlink{struct__RIM__rqstInfo}{RIM\_\-rqst\-Info} $\ast$info)}
\label{RIM_8h_a10}

\begin{CompactList}\small\item\em Function that Reads one type of LAT register. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a11}{
typedef unsigned \hyperlink{RIM_8h_a11}{RIM\_\-exp\-Recd\-CB} (void $\ast$parm, unsigned type, int leng)}
\label{RIM_8h_a11}

\begin{CompactList}\small\item\em Function called to start the export of a new record. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a12}{
typedef unsigned \hyperlink{RIM_8h_a12}{RIM\_\-exp\-Data\-CB} (void $\ast$parm, void $\ast$data, int leng)}
\label{RIM_8h_a12}

\begin{CompactList}\small\item\em Function called to export data for a record. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a13}{
typedef unsigned \hyperlink{RIM_8h_a13}{RIM\_\-imp\-Recd\-CB} (void $\ast$parm, unsigned $\ast$type, int $\ast$leng)}
\label{RIM_8h_a13}

\begin{CompactList}\small\item\em Function called to start the import of a new record. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a14}{
typedef unsigned \hyperlink{RIM_8h_a14}{RIM\_\-imp\-Data\-CB} (void $\ast$parm, void $\ast$data, int r\-Leng, int $\ast$leng)}
\label{RIM_8h_a14}

\begin{CompactList}\small\item\em Function called to import data for a record. \item\end{CompactList}\end{CompactItemize}
\subsection*{Enumerations}
\begin{CompactItemize}
\item 
enum \{ \par
{\bf LATC\_\-MAJ} =  15, 
\par
{\bf LATC\_\-MIN} =  0
 \}
\begin{CompactList}\small\item\em Current version numbers. \item\end{CompactList}\item 
enum \{ {\bf RIM\_\-MEM\_\-ALIGN} =  sizeof(unsigned long long)
 \}
\begin{CompactList}\small\item\em Memory alignment requirements on a memory block used for a RIM structure. \item\end{CompactList}\item 
enum \{ {\bf FIO\_\-PERMS} =  0666
 \}
\begin{CompactList}\small\item\em File permissions for output files. \item\end{CompactList}\item 
enum \hyperlink{RIM_8h_a71}{LATC\_\-CTB\_\-BASE\_\-ID} \{ \par
{\bf LATC\_\-SSR\_\-APID} =  0x3fd, 
\par
{\bf LATC\_\-CTB\_\-MAP} =  0, 
\par
{\bf LATC\_\-CTB\_\-DATA} =  128
 \}
\begin{CompactList}\small\item\em Contribution type base ID for the two types of LATC contributions. \item\end{CompactList}\item 
enum \{ \par
{\bf RIM\_\-BCAST\_\-ADDR} =  255, 
\par
{\bf N\_\-RIM\_\-ADDR\_\-CPTS} =  4
 \}
\begin{CompactList}\small\item\em Constant values associated with addressing LAT component instances. \item\end{CompactList}\item 
enum \{ {\bf RIM\_\-BAD\_\-TYPE} =  -1
 \}
\item 
enum \{ \par
\hyperlink{RIM_8h_a74a25}{UID\_\-INDEX} =  0x0ffff, 
\par
\hyperlink{RIM_8h_a74a26}{UID\_\-IGN\_\-ERROR} =  0x10000, 
\par
\hyperlink{RIM_8h_a74a27}{UID\_\-SPT\_\-HIGH} =  0x20000, 
\par
\hyperlink{RIM_8h_a74a28}{UID\_\-SPT\_\-TFE} =  0x40000, 
\par
\hyperlink{RIM_8h_a74a29}{UID\_\-SPT\_\-LAST} =  0x80000
 \}
\begin{CompactList}\small\item\em Masks for fields in the read request uid value. \item\end{CompactList}\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item 
int \hyperlink{RIM_8h_a30}{RIM\_\-check\-Bit} (const \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$addr)
\begin{CompactList}\small\item\em Check a bit in the map. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a31}{RIM\_\-check\-Split} (short $\ast$ptr, unsigned long long value, unsigned uid)
\begin{CompactList}\small\item\em Decode a result item used to check a split. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a32}{RIM\_\-clear} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim)
\begin{CompactList}\small\item\em Clear out the map and data portions of the RIM structure. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a33}{RIM\_\-clear\-Bit} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$addr)
\begin{CompactList}\small\item\em Clear a bit in the map. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a34}{RIM\_\-clear\-Map} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map)
\begin{CompactList}\small\item\em Clear the map. \item\end{CompactList}\item 
int \hyperlink{RIM_8h_a35}{RIM\_\-compare} (const \hyperlink{RIM_8h_a1}{RIM} $\ast$this, const \hyperlink{RIM_8h_a1}{RIM} $\ast$that, \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map)
\begin{CompactList}\small\item\em Compare all the nodes of {\em this\/} and {\em that\/}, marking differences in the {\em map\/}. \item\end{CompactList}\item 
int \hyperlink{RIM_8h_a36}{RIM\_\-compare\-Type} (const char $\ast$string, \hyperlink{RIM_8h_a0}{RIM\_\-type} type)
\begin{CompactList}\small\item\em Compare string with the name of a type. \item\end{CompactList}\item 
\hyperlink{RIM_8h_a1}{RIM} $\ast$ \hyperlink{RIM_8h_a37}{RIM\_\-construct} (void $\ast$buffer)
\begin{CompactList}\small\item\em Initialise a block of memory as a RIM object. \item\end{CompactList}\item 
\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ \hyperlink{RIM_8h_a38}{RIM\_\-construct\-Map} (void $\ast$buffer)
\begin{CompactList}\small\item\em Initialise the supplied memory as a RIM\_\-map object. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a39}{RIM\_\-contrast} (const \hyperlink{RIM_8h_a1}{RIM} $\ast$this, const \hyperlink{RIM_8h_a1}{RIM} $\ast$that, const \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a0}{RIM\_\-type} $\ast$r\_\-type, \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$r\_\-addr)
\begin{CompactList}\small\item\em Compare all the nodes of {\em this\/} and {\em that\/}, that are not marked to be ignored. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a40}{RIM\_\-correct} (\hyperlink{RIM_8h_a1}{RIM} $\ast$orig, \hyperlink{RIM_8h_a1}{RIM} $\ast$capt)
\begin{CompactList}\small\item\em Copy select portions of an original RIM into a copy, to ensure that the subsequent comparison will succeed. \item\end{CompactList}\item 
int \hyperlink{RIM_8h_a41}{RIM\_\-count\-Map} (const \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a0}{RIM\_\-type} type)
\begin{CompactList}\small\item\em Count the number of set bits in the map. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a42}{RIM\_\-data\-Masks} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, unsigned $\ast$df\-Tpres, unsigned $\ast$ex\-Types)
\begin{CompactList}\small\item\em Get summary of data types present in a RIM. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a43}{RIM\_\-export} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, unsigned typ\-Mask, \hyperlink{RIM_8h_a11}{RIM\_\-exp\-Recd\-CB} recd\-Rtn, \hyperlink{RIM_8h_a12}{RIM\_\-exp\-Data\-CB} data\-Rtn, void $\ast$parm)
\begin{CompactList}\small\item\em Export RIM data as a series of records. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a44}{RIM\_\-export\-Map} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a11}{RIM\_\-exp\-Recd\-CB} recd\-Rtn, \hyperlink{RIM_8h_a12}{RIM\_\-exp\-Data\-CB} data\-Rtn, void $\ast$parm)
\begin{CompactList}\small\item\em Export RIM map data as a series of records. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a45}{RIM\_\-get} (const \hyperlink{RIM_8h_a1}{RIM} $\ast$rim, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$addr, int reg\-Id, void $\ast$value)
\begin{CompactList}\small\item\em Put the contents of the requested register and field into {\em value\/}. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a46}{RIM\_\-get\-Address} (\hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$addr, unsigned index, \hyperlink{RIM_8h_a0}{RIM\_\-type} type)
\begin{CompactList}\small\item\em Convert flat addressing to hierarchical bit addressing. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a47}{RIM\_\-get\-Addr\-Rng} (const char $\ast$string, \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$addr)
\begin{CompactList}\small\item\em Finds the address range associated with the type identifed by the string. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a48}{RIM\_\-get\-Index} (const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$addr, unsigned $\ast$index, \hyperlink{RIM_8h_a0}{RIM\_\-type} type)
\begin{CompactList}\small\item\em Convert hierarchical bit addressing to flat addressing. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a49}{RIM\_\-get\-Layer\-ID} (const char $\ast$name, unsigned $\ast$layer)
\begin{CompactList}\small\item\em Convert a layer name to a layer ID. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a50}{RIM\_\-get\-Layer\-Name} (unsigned layer, char $\ast$name)
\begin{CompactList}\small\item\em Form the layer name from the layer ID. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a51}{RIM\_\-import} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, int swap, \hyperlink{RIM_8h_a13}{RIM\_\-imp\-Recd\-CB} recd\-Rtn, \hyperlink{RIM_8h_a14}{RIM\_\-imp\-Data\-CB} data\-Rtn, void $\ast$parm)
\begin{CompactList}\small\item\em Import RIM data as a series of records. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a52}{RIM\_\-import\-Map} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, int swap, \hyperlink{RIM_8h_a13}{RIM\_\-imp\-Recd\-CB} recd\-Rtn, \hyperlink{RIM_8h_a14}{RIM\_\-imp\-Data\-CB} data\-Rtn, void $\ast$parm)
\begin{CompactList}\small\item\em Import RIM map data as a series of records. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a53}{RIM\_\-load} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, void $\ast$param, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$load\-Fn)
\begin{CompactList}\small\item\em Load the LAT with the configuration held in a RIM structure. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a54}{RIM\_\-load\-Afe\-Config} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, unsigned int mask, unsigned int value0, unsigned int value1, unsigned int rc\-Mask, unsigned int fe\-Mask, void $\ast$param, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$load\-Fn)
\begin{CompactList}\small\item\em Load the AFE configuration register. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a55}{RIM\_\-load\-Cfe\-Config0} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, unsigned int mask, unsigned int value, void $\ast$param, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$load\-Fn)
\begin{CompactList}\small\item\em Load CFE configuration register 0. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a56}{RIM\_\-load\-Cfe\-Config1} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, unsigned int mask, unsigned int value0, unsigned int value1, unsigned int c\-Mask, void $\ast$param, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$load\-Fn)
\begin{CompactList}\small\item\em Load CFE configuration register 1. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a57}{RIM\_\-load\-Split} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, int n\-Low, int n\-High, void $\ast$param, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$load\-Fn)
\begin{CompactList}\small\item\em Load TKR split values. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a58}{RIM\_\-load\-Tfe\-Dac} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, unsigned int mask, unsigned int value, int n\-Low, int n\-High, void $\ast$param, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$load\-Fn)
\begin{CompactList}\small\item\em Load the TFE DAC register. \item\end{CompactList}\item 
\hyperlink{RIM_8h_a0}{RIM\_\-type} \hyperlink{RIM_8h_a59}{RIM\_\-lookup\-Type} (const char $\ast$string)
\begin{CompactList}\small\item\em Hunt through the list of component types and return the index of the input string. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a60}{RIM\_\-name\-Type} (char $\ast$string, \hyperlink{RIM_8h_a0}{RIM\_\-type} type)
\begin{CompactList}\small\item\em Place the four-character string describing this type into {\em name\/}. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a61}{RIM\_\-n\-Types} (void)
\begin{CompactList}\small\item\em Return the number of component types within the LAT register description. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a62}{RIM\_\-read} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, void $\ast$param, \hyperlink{RIM_8h_a10}{RIM\_\-read\-Fn} $\ast$$\ast$read\-Fn, \hyperlink{RIM_8h_a8}{RIM\_\-decode\-Fn} $\ast$$\ast$decode\-Fn, const \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ign)
\begin{CompactList}\small\item\em Populate the RIM structure with the current state of the LAT. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a63}{RIM\_\-set} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$addr, int reg\-Id, const void $\ast$value)
\begin{CompactList}\small\item\em Set the value of a register. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a64}{RIM\_\-set\-Bit} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$addr)
\begin{CompactList}\small\item\em Set a bit in the map. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a65}{RIM\_\-set\-Split} (short $\ast$ptr, unsigned long long value, unsigned uid)
\begin{CompactList}\small\item\em Decode the result item used to populate a split. \item\end{CompactList}\item 
size\_\-t \hyperlink{RIM_8h_a66}{RIM\_\-sizeof} (void)
\begin{CompactList}\small\item\em Calculate the footprint of the RIM structure. \item\end{CompactList}\item 
size\_\-t \hyperlink{RIM_8h_a67}{RIM\_\-sizeof\-Map} (void)
\begin{CompactList}\small\item\em Calculate the total size of a RIM\_\-map object. \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
Public definitions for the RIM (Register In-Memory) facility. 

\begin{Desc}
\item[Author:]James Swain \& Owen Saxton\end{Desc}
\begin{Desc}
\item[Id]\hyperlink{RIM_8h}{RIM.h},v 1.6 2008/10/24 23:38:36 saxton Exp \end{Desc}


\subsection{Typedef Documentation}
\hypertarget{RIM_8h_a7}{
\index{RIM.h@{RIM.h}!RIM_rqstInfo@{RIM\_\-rqstInfo}}
\index{RIM_rqstInfo@{RIM\_\-rqstInfo}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-rqstInfo]{\setlength{\rightskip}{0pt plus 5cm}typedef struct \hyperlink{struct__RIM__rqstInfo}{\_\-RIM\_\-rqst\-Info}  \hyperlink{struct__RIM__rqstInfo}{RIM\_\-rqst\-Info}}}
\label{RIM_8h_a7}


Information describing a read request. 

This is used mainly in handling read errors, but is also used when processing registers read during a read of the splits

This structure should really be private to RIM, since the information it contains is essentially held in escrow by LATC and returned in the event that the response to a read command contains an error. However, the additional scaffold required to support an opaque handle just seems like overkill.

\subsection{Enumeration Type Documentation}
\hypertarget{RIM_8h_a74}{
\subsubsection["@5]{\setlength{\rightskip}{0pt plus 5cm}anonymous enum}}
\label{RIM_8h_a74}


Masks for fields in the read request uid value. 

\begin{Desc}
\item[Enumerator: ]\par
\begin{description}
\index{UID_INDEX@{UID\_\-INDEX}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!UID_INDEX@{UID\_\-INDEX}}\item[{\em 
\hypertarget{RIM_8h_a74a25}{
UID\_\-INDEX}
\label{RIM_8h_a74a25}
}]Index of component. \index{UID_IGN_ERROR@{UID\_\-IGN\_\-ERROR}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!UID_IGN_ERROR@{UID\_\-IGN\_\-ERROR}}\item[{\em 
\hypertarget{RIM_8h_a74a26}{
UID\_\-IGN\_\-ERROR}
\label{RIM_8h_a74a26}
}]Ignore any read errors. \index{UID_SPT_HIGH@{UID\_\-SPT\_\-HIGH}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!UID_SPT_HIGH@{UID\_\-SPT\_\-HIGH}}\item[{\em 
\hypertarget{RIM_8h_a74a27}{
UID\_\-SPT\_\-HIGH}
\label{RIM_8h_a74a27}
}]Set if high side split; otherwise low. \index{UID_SPT_TFE@{UID\_\-SPT\_\-TFE}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!UID_SPT_TFE@{UID\_\-SPT\_\-TFE}}\item[{\em 
\hypertarget{RIM_8h_a74a28}{
UID\_\-SPT\_\-TFE}
\label{RIM_8h_a74a28}
}]Set if reading TFE; otherwise TRC. \index{UID_SPT_LAST@{UID\_\-SPT\_\-LAST}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!UID_SPT_LAST@{UID\_\-SPT\_\-LAST}}\item[{\em 
\hypertarget{RIM_8h_a74a29}{
UID\_\-SPT\_\-LAST}
\label{RIM_8h_a74a29}
}]Set if last read of the group. \end{description}
\end{Desc}



\subsection{Function Documentation}
\hypertarget{RIM_8h_a30}{
\index{RIM.h@{RIM.h}!RIM_checkBit@{RIM\_\-checkBit}}
\index{RIM_checkBit@{RIM\_\-checkBit}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-checkBit]{\setlength{\rightskip}{0pt plus 5cm}int RIM\_\-check\-Bit (const \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type}, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{RIM_8h_a30}


Check a bit in the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated\item[{\em type}]Identifies map to manipulate\item[{\em addr}]bit to check\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em 0}]if the bit is clear \item[{\em 1}]if the bit is set\end{description}
\end{Desc}
\hypertarget{RIM_8h_a31}{
\index{RIM.h@{RIM.h}!RIM_checkSplit@{RIM\_\-checkSplit}}
\index{RIM_checkSplit@{RIM\_\-checkSplit}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-checkSplit]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-check\-Split (short $\ast$ {\em ptr}, unsigned long long {\em value}, unsigned {\em uid})}}
\label{RIM_8h_a31}


Decode a result item used to check a split. 

The read value of a TFE mode register is compared with the expected value and the split value set to indicate an error if it doesn't match

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ptr}]Pointer to split registers instance\item[{\em value}]Value read from the TFE mode register\item[{\em uid}]The unique ID of the TFE mode register\end{description}
\end{Desc}
\hypertarget{RIM_8h_a32}{
\index{RIM.h@{RIM.h}!RIM_clear@{RIM\_\-clear}}
\index{RIM_clear@{RIM\_\-clear}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-clear]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-clear (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim})}}
\label{RIM_8h_a32}


Clear out the map and data portions of the RIM structure. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the RIM object to clear\end{description}
\end{Desc}
\hypertarget{RIM_8h_a33}{
\index{RIM.h@{RIM.h}!RIM_clearBit@{RIM\_\-clearBit}}
\index{RIM_clearBit@{RIM\_\-clearBit}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-clearBit]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-clear\-Bit (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type}, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{RIM_8h_a33}


Clear a bit in the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated\item[{\em type}]Identifies map to manipulate\item[{\em addr}]bit to clear\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if everything goes well \item[{\em RIM\_\-TYPEUNKN}]if the type does not exist \item[{\em RIM\_\-MAPNONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDRBCST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDRRNGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDRINDX}]if the final index exceeds the total number of bits in the map\end{description}
\end{Desc}
\hypertarget{RIM_8h_a34}{
\index{RIM.h@{RIM.h}!RIM_clearMap@{RIM\_\-clearMap}}
\index{RIM_clearMap@{RIM\_\-clearMap}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-clearMap]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-clear\-Map (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map})}}
\label{RIM_8h_a34}


Clear the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated\end{description}
\end{Desc}
\hypertarget{RIM_8h_a35}{
\index{RIM.h@{RIM.h}!RIM_compare@{RIM\_\-compare}}
\index{RIM_compare@{RIM\_\-compare}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-compare]{\setlength{\rightskip}{0pt plus 5cm}int RIM\_\-compare (const \hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em this}, const \hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em that}, \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map})}}
\label{RIM_8h_a35}


Compare all the nodes of {\em this\/} and {\em that\/}, marking differences in the {\em map\/}. 

If a node is NULL, then the default node is used.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em this}]First in-memory configuration structure\item[{\em that}]Second in-memory configuration structure\item[{\em map}]Indicates which nodes are different\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]Number of different nodes\end{Desc}
\hypertarget{RIM_8h_a36}{
\index{RIM.h@{RIM.h}!RIM_compareType@{RIM\_\-compareType}}
\index{RIM_compareType@{RIM\_\-compareType}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-compareType]{\setlength{\rightskip}{0pt plus 5cm}int RIM\_\-compare\-Type (const char $\ast$ {\em string}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type})}}
\label{RIM_8h_a36}


Compare string with the name of a type. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em string}]Name of a component type\item[{\em type}]Type to compare to\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em -1}]If the type is unknown (exceeds the range of acceptable types) \item[{\em 0}]If the type is known, and the name matches the string \item[{\em 1}]If the type is known, and the name does not match the string\end{description}
\end{Desc}
\hypertarget{RIM_8h_a37}{
\index{RIM.h@{RIM.h}!RIM_construct@{RIM\_\-construct}}
\index{RIM_construct@{RIM\_\-construct}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-construct]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{RIM_8h_a1}{RIM}$\ast$ RIM\_\-construct (void $\ast$ {\em buffer})}}
\label{RIM_8h_a37}


Initialise a block of memory as a RIM object. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em buffer}]Pointer to uninitialised memory to use for the RIM structure\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The address of the initialised RIM structure, or NULL if the buffer is misaligned\end{Desc}
\hypertarget{RIM_8h_a38}{
\index{RIM.h@{RIM.h}!RIM_constructMap@{RIM\_\-constructMap}}
\index{RIM_constructMap@{RIM\_\-constructMap}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-constructMap]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{RIM_8h_a2}{RIM\_\-map}$\ast$ RIM\_\-construct\-Map (void $\ast$ {\em buf})}}
\label{RIM_8h_a38}


Initialise the supplied memory as a RIM\_\-map object. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em buf}]Block of memory, at least as large as RIM\_\-sizeof\-Map, to initalise as a RIM\_\-map object\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]Pointer to an initialised RIM\_\-map object\end{Desc}
\hypertarget{RIM_8h_a39}{
\index{RIM.h@{RIM.h}!RIM_contrast@{RIM\_\-contrast}}
\index{RIM_contrast@{RIM\_\-contrast}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-contrast]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-contrast (const \hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em this}, const \hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em that}, const \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em ign}, \hyperlink{RIM_8h_a0}{RIM\_\-type} $\ast$ {\em r\_\-type}, \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$ {\em r\_\-addr})}}
\label{RIM_8h_a39}


Compare all the nodes of {\em this\/} and {\em that\/}, that are not marked to be ignored. 

If a node is NULL then the default node is used.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em this}]First in memory configuration model\item[{\em that}]Second in memory configuration model\item[{\em ign}]Pointer to a bit-map of sections of the LAT to ignore\item[{\em r\_\-type}]Location to fill with the type of the first different node (can be NULL if not interested)\item[{\em r\_\-addr}]Pointer to an address structure to populate with the first different node (can be NULL if not interested)\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]If the two in-memory models are functionally identical \item[{\em RIM\_\-DIFFER}]If the two in-memory models are different\end{description}
\end{Desc}
\hypertarget{RIM_8h_a40}{
\index{RIM.h@{RIM.h}!RIM_correct@{RIM\_\-correct}}
\index{RIM_correct@{RIM\_\-correct}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-correct]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-correct (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em orig}, \hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em capt})}}
\label{RIM_8h_a40}


Copy select portions of an original RIM into a copy, to ensure that the subsequent comparison will succeed. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em orig}]Orignal RIM\item[{\em capt}]New copy of the RIM (probably captured from the LAT)\end{description}
\end{Desc}
\hypertarget{RIM_8h_a41}{
\index{RIM.h@{RIM.h}!RIM_countMap@{RIM\_\-countMap}}
\index{RIM_countMap@{RIM\_\-countMap}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-countMap]{\setlength{\rightskip}{0pt plus 5cm}int RIM\_\-count\-Map (const \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type})}}
\label{RIM_8h_a41}


Count the number of set bits in the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated\item[{\em type}]Identifies map to count\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]Number of bits set in the map, or -1 for an illegal type\end{Desc}
\hypertarget{RIM_8h_a42}{
\index{RIM.h@{RIM.h}!RIM_dataMasks@{RIM\_\-dataMasks}}
\index{RIM_dataMasks@{RIM\_\-dataMasks}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-dataMasks]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-data\-Masks (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, unsigned $\ast$ {\em df\-Types}, unsigned $\ast$ {\em ex\-Types})}}
\label{RIM_8h_a42}


Get summary of data types present in a RIM. 

This routine returns two bitmasks indicating what kinds of data are present in the specified RIM structure. The first indicates the types with default data present, while the second indicates which types have exception data. The principle use of this routine is to avoid creating empty sets of exported data.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the in-memory model data\item[{\em df\-Types}]The address of an integer to receive the bitmask of types with default data present.\item[{\em ex\-Types}]The address of an integer to receive the bitmask of types with exception data present.\end{description}
\end{Desc}
\hypertarget{RIM_8h_a43}{
\index{RIM.h@{RIM.h}!RIM_export@{RIM\_\-export}}
\index{RIM_export@{RIM\_\-export}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-export]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-export (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, unsigned {\em typ\-Mask}, \hyperlink{RIM_8h_a11}{RIM\_\-exp\-Recd\-CB} {\em recd\-Rtn}, \hyperlink{RIM_8h_a12}{RIM\_\-exp\-Data\-CB} {\em data\-Rtn}, void $\ast$ {\em parm})}}
\label{RIM_8h_a43}


Export RIM data as a series of records. 

This routine provides a general way to export the data from a RIM structure. The data are presented as a series of records to the supplied callback routines. One routine is called at the start of each record to receive the record type and length of the data in the record. The second routine is called to receive data for the record, and is called as many times as necessary to receive all the data.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]RIM structure to use as a source\item[{\em typ\-Mask}]Mask of component types to write out. If the default (DFT) bit is set, the default data for all types is exported in addition to the data indicated by the other type bits.\item[{\em recd\-Rtn}]Routine to be called at the start of each record to be exported.\item[{\em data\-Rtn}]Routine to be called for each block of data to be exported.\item[{\em parm}]Parameter to pass to the callback routines.\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all goes well\end{description}
\end{Desc}
\hypertarget{RIM_8h_a44}{
\index{RIM.h@{RIM.h}!RIM_exportMap@{RIM\_\-exportMap}}
\index{RIM_exportMap@{RIM\_\-exportMap}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-exportMap]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-export\-Map (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{RIM_8h_a11}{RIM\_\-exp\-Recd\-CB} {\em recd\-Rtn}, \hyperlink{RIM_8h_a12}{RIM\_\-exp\-Data\-CB} {\em data\-Rtn}, void $\ast$ {\em parm})}}
\label{RIM_8h_a44}


Export RIM map data as a series of records. 

This routine provides a general way to export the data from a RIM map structure. The data are presented as a series of records to the supplied callback routines. One routine is called at the start of each record to receive the record type and length of the data in the record. The second routine is called to receive data for the record, and is called as many times as necessary to receive all the data.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]RIM map structure to use as a source\item[{\em recd\-Rtn}]Routine to be called at the start of each record to be exported.\item[{\em data\-Rtn}]Routine to be called for each block of data to be exported.\item[{\em parm}]Parameter to pass to the callback routines.\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all goes well\end{description}
\end{Desc}
\hypertarget{RIM_8h_a45}{
\index{RIM.h@{RIM.h}!RIM_get@{RIM\_\-get}}
\index{RIM_get@{RIM\_\-get}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-get]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-get (const \hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type}, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$ {\em addr}, int {\em reg\-Id}, void $\ast$ {\em value})}}
\label{RIM_8h_a45}


Put the contents of the requested register and field into {\em value\/}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]In memory configuration structure to be interogated\item[{\em type}]Type of data sought\item[{\em addr}]Address of the leaf requested\item[{\em reg\-Id}]Register to get, as LAT hardware ID\item[{\em value}]Location to put the contents of the target field\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all the parameters are in bounds and the data is successfully retrieved. \item[{\em RIM\_\-TYPEUNKN}]if type is not a valid RIM\_\-type \item[{\em RIM\_\-CPTNONE}]if the requested type has no real data \item[{\em RIM\_\-ADDRBCST}]if the address contains a mixture of broadcast and unicast components \item[{\em RIM\_\-ADDRRNGE}]if any component of the address is outside the allowable range for this type \item[{\em RIM\_\-BADREGID}]if reg\-Id is outside the acceptable range of register IDs for this type \item[{\em RIM\_\-NOTSET}]if the requested node has not been previously set \item[{\em RIM\_\-BADREGID}]The register ID was unrecognized\end{description}
\end{Desc}
\hypertarget{RIM_8h_a46}{
\index{RIM.h@{RIM.h}!RIM_getAddress@{RIM\_\-getAddress}}
\index{RIM_getAddress@{RIM\_\-getAddress}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-getAddress]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-get\-Address (\hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$ {\em addr}, unsigned {\em index}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type})}}
\label{RIM_8h_a46}


Convert flat addressing to hierarchical bit addressing. 

Note that GTFEs are usually referred to as being part of an X or Y layer. This identification is converted to an absolute layer number and stored in the rc space by addr-$>$rc = (layer\-Number $<$$<$ 1) $|$ is\-Ylayer. This conversion is performed by the XLM-$>$RIM converter, but is documented here since it is a storage convention.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em addr}]Address corresponding to index\item[{\em index}]Index to convert\item[{\em type}]Type of address to convert\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]Success \item[{\em RIM\_\-TYPEUNKN}]The component type is unknown \item[{\em RIM\_\-ADDRRNGE}]The index is outside the allowable range for this type\end{description}
\end{Desc}
\hypertarget{RIM_8h_a47}{
\index{RIM.h@{RIM.h}!RIM_getAddrRng@{RIM\_\-getAddrRng}}
\index{RIM_getAddrRng@{RIM\_\-getAddrRng}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-getAddrRng]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-get\-Addr\-Rng (const char $\ast$ {\em string}, \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{RIM_8h_a47}


Finds the address range associated with the type identifed by the string. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em string}]Identifies the address range required\item[{\em addr}]Pointer to address stucture to populate with the address range\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]If the string is a good type name. \item[{\em RIM\_\-TYPESTR}]If the string does not match a known type\end{description}
\end{Desc}
\hypertarget{RIM_8h_a48}{
\index{RIM.h@{RIM.h}!RIM_getIndex@{RIM\_\-getIndex}}
\index{RIM_getIndex@{RIM\_\-getIndex}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-getIndex]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-get\-Index (const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$ {\em addr}, unsigned $\ast$ {\em index}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type})}}
\label{RIM_8h_a48}


Convert hierarchical bit addressing to flat addressing. 

Note that GTFEs are usually referred to as being part of an X or Y layer. This identification is converted to an absolute layer number and stored in the rc space by addr-$>$rc = (layer\-Number $<$$<$ 1) $|$ is\-Ylayer. This conversion is performed by the XLM-$>$binary converter, but is documented here since it is a storage convention.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em addr}]Address to convert\item[{\em index}]Index corresponding to address\item[{\em type}]Type of address to convert\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]Success \item[{\em RIM\_\-TYPEUNKN}]The component type is unknown \item[{\em RIM\_\-ADDRBCST}]The address contains a mixture of broadcast and unicast components \item[{\em RIM\_\-ADDRRNGE}]A component of the address is outside the allowable range for this type\end{description}
\end{Desc}
\hypertarget{RIM_8h_a49}{
\index{RIM.h@{RIM.h}!RIM_getLayerID@{RIM\_\-getLayerID}}
\index{RIM_getLayerID@{RIM\_\-getLayerID}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-getLayerID]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-get\-Layer\-ID (const char $\ast$ {\em name}, unsigned $\ast$ {\em layer})}}
\label{RIM_8h_a49}


Convert a layer name to a layer ID. 

A three-character layer name of the form \mbox{[}sign\mbox{]}\mbox{[}xory\mbox{]}\mbox{[}index\mbox{]} is converted to a layer ID.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]The address of the three-byte layer name.\item[{\em layer}]Location to store the layer ID\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]If the layer ID was successfully found \item[{\em RIM\_\-ADDRLSIG}]If the layer sign is nonsensical \item[{\em RIM\_\-ADDRLXY}]If the layer xy value is nonsensical \item[{\em RIM\_\-ADDRLIND}]If the layer index is nonsensical\end{description}
\end{Desc}
\hypertarget{RIM_8h_a50}{
\index{RIM.h@{RIM.h}!RIM_getLayerName@{RIM\_\-getLayerName}}
\index{RIM_getLayerName@{RIM\_\-getLayerName}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-getLayerName]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-get\-Layer\-Name (unsigned {\em layer}, char $\ast$ {\em name})}}
\label{RIM_8h_a50}


Form the layer name from the layer ID. 

The name has the form \mbox{[}sign\mbox{]}\mbox{[}xory\mbox{]}\mbox{[}index\mbox{]}, e.g. +y5, -x1.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em layer}]ID of the layer to name\item[{\em name}]The address of a 4-byte array to hold the layer name (3 bytes) plus the trailing null.\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]If the layer is located \item[{\em RIM\_\-ADDRLAYR}]If the layer is out of range\end{description}
\end{Desc}
\hypertarget{RIM_8h_a51}{
\index{RIM.h@{RIM.h}!RIM_import@{RIM\_\-import}}
\index{RIM_import@{RIM\_\-import}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-import]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-import (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, int {\em swap}, \hyperlink{RIM_8h_a13}{RIM\_\-imp\-Recd\-CB} {\em recd\-Rtn}, \hyperlink{RIM_8h_a14}{RIM\_\-imp\-Data\-CB} {\em data\-Rtn}, void $\ast$ {\em parm})}}
\label{RIM_8h_a51}


Import RIM data as a series of records. 

This routine provides a general way to import data into a RIM structure. The data are received as a series of records from the supplied callback routines. One routine is called to position at the start of the next record to be imported and supplies the record type and data length. The second routine is called to retrieve data for the record, and is called as many times as necessary to retrieve all the data.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]RIM structure to use as a source\item[{\em swap}]If TRUE, the bytes of the imported data are to be swapped from big-endian to machine order.\item[{\em recd\-Rtn}]Routine to be called at the start of each record to be imported.\item[{\em data\-Rtn}]Routine to be called for each block of data to be imported.\item[{\em parm}]Parameter to pass to the callback routines.\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]Success \item[{\em RIM\_\-RTYPUNKN}]Received a record with invalid record type \item[{\em RIM\_\-TYPEUNKN}]Received a record with invalid RIM type\end{description}
\end{Desc}
\hypertarget{RIM_8h_a52}{
\index{RIM.h@{RIM.h}!RIM_importMap@{RIM\_\-importMap}}
\index{RIM_importMap@{RIM\_\-importMap}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-importMap]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-import\-Map (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, int {\em swap}, \hyperlink{RIM_8h_a13}{RIM\_\-imp\-Recd\-CB} {\em recd\-Rtn}, \hyperlink{RIM_8h_a14}{RIM\_\-imp\-Data\-CB} {\em data\-Rtn}, void $\ast$ {\em parm})}}
\label{RIM_8h_a52}


Import RIM map data as a series of records. 

This routine provides a general way to export the data from a RIM map structure. The data are presented as a series of records to the supplied callback routines. One routine is called at the start of each record to receive the record type and length of the data in the record. The second routine is called to receive data for the record, and is called as many times as necessary to receive all the data.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]RIM map structure to use as a source\item[{\em swap}]If TRUE, the bytes of the imported data are to be swapped from big-endian to machine order.\item[{\em recd\-Rtn}]Routine to be called at the start of each record to be exported.\item[{\em data\-Rtn}]Routine to be called for each block of data to be exported.\item[{\em parm}]Parameter to pass to the callback routines.\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]Success \item[{\em RIM\_\-RTYPUNKN}]Received a record with invalid record type \item[{\em RIM\_\-TYPEUNKN}]Received a record with invalid RIM type\end{description}
\end{Desc}
\hypertarget{RIM_8h_a53}{
\index{RIM.h@{RIM.h}!RIM_load@{RIM\_\-load}}
\index{RIM_load@{RIM\_\-load}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-load]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-load (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, void $\ast$ {\em param}, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$ {\em load\-Fn})}}
\label{RIM_8h_a53}


Load the LAT with the configuration held in a RIM structure. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the RIM structure to populate from the LAT\item[{\em param}]Pointer passed through to the {\em load\-Reg\-Fn\/} \item[{\em load\-Fn}]Type ordered array of pointers to functions that load the LAT registers\end{description}
\end{Desc}
\hypertarget{RIM_8h_a54}{
\index{RIM.h@{RIM.h}!RIM_loadAfeConfig@{RIM\_\-loadAfeConfig}}
\index{RIM_loadAfeConfig@{RIM\_\-loadAfeConfig}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-loadAfeConfig]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-load\-Afe\-Config (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, unsigned int {\em mask}, unsigned int {\em value0}, unsigned int {\em value1}, unsigned int {\em rc\-Mask}, unsigned int {\em fe\-Mask}, void $\ast$ {\em param}, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$ {\em load\-Fn})}}
\label{RIM_8h_a54}


Load the AFE configuration register. 

The AFE configuration register is loaded with a modified version of the value from the LAT configuration, with the specified bits replaced.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the cached in-memory model of the LATC registers\item[{\em mask}]Mask of bits to be changed from the configuration.\item[{\em value0}]The value to be masked and merged with the configuration value for front-ends not selected by the RC and FE masks.\item[{\em value1}]The value to be masked and merged with the configuration value for front-ends selected by the RC and FE masks.\item[{\em rc\-Mask}]Mask of bits, one per RC, specifying which RCs are selected.\item[{\em fe\-Mask}]Mask of bits, one per FE, specifying which FEs within selected RCs are selected.\item[{\em param}]Parameter to be passed to the load routine.\item[{\em load\-Fn}]Type ordered array of pointers to functions that load the LAT registers\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all goes well \item[{\em LEM\_\-$\ast$}]if there is an error arising from one of the register load commands\end{description}
\end{Desc}
\hypertarget{RIM_8h_a55}{
\index{RIM.h@{RIM.h}!RIM_loadCfeConfig0@{RIM\_\-loadCfeConfig0}}
\index{RIM_loadCfeConfig0@{RIM\_\-loadCfeConfig0}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-loadCfeConfig0]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-load\-Cfe\-Config0 (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, unsigned int {\em mask}, unsigned int {\em value}, void $\ast$ {\em param}, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$ {\em load\-Fn})}}
\label{RIM_8h_a55}


Load CFE configuration register 0. 

CFE configuration register 0 is loaded with a modified version of the value from the LAT configuration, with the specified bits replaced.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the cached in-memory model of the LATC registers\item[{\em mask}]Mask of bits to be changed from the configuration.\item[{\em value}]The value to be masked and merged with the configuration value.\item[{\em param}]Parameter to be passed to the load routine.\item[{\em load\-Fn}]Type ordered array of pointers to functions that load the LAT registers\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all goes well \item[{\em LEM\_\-$\ast$}]if there is an error arising from one of the register load commands\end{description}
\end{Desc}
\hypertarget{RIM_8h_a56}{
\index{RIM.h@{RIM.h}!RIM_loadCfeConfig1@{RIM\_\-loadCfeConfig1}}
\index{RIM_loadCfeConfig1@{RIM\_\-loadCfeConfig1}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-loadCfeConfig1]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-load\-Cfe\-Config1 (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, unsigned int {\em mask}, unsigned int {\em value0}, unsigned int {\em value1}, unsigned int {\em c\-Mask}, void $\ast$ {\em param}, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$ {\em load\-Fn})}}
\label{RIM_8h_a56}


Load CFE configuration register 1. 

CFE configuration register 1 is loaded with a modified version of the value from the LAT configuration, with the specified bits replaced.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the cached in-memory model of the LATC registers\item[{\em mask}]Mask of bits to be changed from the configuration.\item[{\em value0}]The value to be masked and merged with the configuration value for front-ends whose bit is clear in the column mask.\item[{\em value1}]The value to be masked and merged with the configuration value for front-ends whose bit is set in the column mask.\item[{\em c\-Mask}]Mask of bits, one per column, specifying which value is to be used for loading the config register.\item[{\em param}]Parameter to be passed to the load routine.\item[{\em load\-Fn}]Type ordered array of pointers to functions that load the LAT registers\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all goes well \item[{\em LEM\_\-$\ast$}]if there is an error arising from one of the register load commands\end{description}
\end{Desc}
\hypertarget{RIM_8h_a57}{
\index{RIM.h@{RIM.h}!RIM_loadSplit@{RIM\_\-loadSplit}}
\index{RIM_loadSplit@{RIM\_\-loadSplit}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-loadSplit]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-load\-Split (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, int {\em n\-Low}, int {\em n\-High}, void $\ast$ {\em param}, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$ {\em load\-Fn})}}
\label{RIM_8h_a57}


Load TKR split values. 

The tracker RC and FE registers are loaded to reflect the given split values.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]RIM structure containing the values to load onto the LAT\item[{\em n\-Low}]Number of TFEs to talk on the low side, or -1 if the configured values are to be used.\item[{\em n\-High}]Number of TFEs to talk on the high side, or -1 if the configured values are to be used.\item[{\em param}]Parameter to be passed to the load function.\item[{\em load\-Fn}]Type ordered array of pointers to functions that load the LAT registers\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all goes well \item[{\em LEM\_\-$\ast$}]if there is an error arising from one of the register load commands\end{description}
\end{Desc}
\hypertarget{RIM_8h_a58}{
\index{RIM.h@{RIM.h}!RIM_loadTfeDac@{RIM\_\-loadTfeDac}}
\index{RIM_loadTfeDac@{RIM\_\-loadTfeDac}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-loadTfeDac]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-load\-Tfe\-Dac (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, unsigned int {\em mask}, unsigned int {\em value}, int {\em n\-Low}, int {\em n\-High}, void $\ast$ {\em param}, \hyperlink{RIM_8h_a9}{RIM\_\-load\-Fn} $\ast$$\ast$ {\em load\-Fn})}}
\label{RIM_8h_a58}


Load the TFE DAC register. 

The TFE DAC register is loaded with a modified version of the value from the LAT configuration, with the specified bits replaced.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the cached in-memory model of the LATC registers\item[{\em mask}]Mask of bits to be changed from the configuration.\item[{\em value}]The value to be masked and merged with the configuration value.\item[{\em n\-Low}]Number of TFEs talking on the low side, or -1 if the configured values are being used.\item[{\em n\-High}]Number of TFEs talking on the high side, or -1 if the configured values are being used.\item[{\em param}]Parameter to be passed to the load routine.\item[{\em load\-Fn}]Type ordered array of pointers to functions that load the LAT registers\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all goes well \item[{\em LEM\_\-$\ast$}]if there is an error arising from one of the register load commands\end{description}
\end{Desc}
\hypertarget{RIM_8h_a59}{
\index{RIM.h@{RIM.h}!RIM_lookupType@{RIM\_\-lookupType}}
\index{RIM_lookupType@{RIM\_\-lookupType}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-lookupType]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{RIM_8h_a0}{RIM\_\-type} RIM\_\-lookup\-Type (const char $\ast$ {\em string})}}
\label{RIM_8h_a59}


Hunt through the list of component types and return the index of the input string. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em string}]String corresponding to one of the component types used in the LAT register description\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]integer corresponding to the type identified by {\em string\/} or RIM\_\-BAD\_\-TYPE if the string does not match any on the list\end{Desc}
\hypertarget{RIM_8h_a60}{
\index{RIM.h@{RIM.h}!RIM_nameType@{RIM\_\-nameType}}
\index{RIM_nameType@{RIM\_\-nameType}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-nameType]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-name\-Type (char $\ast$ {\em string}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type})}}
\label{RIM_8h_a60}


Place the four-character string describing this type into {\em name\/}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em type}]Type to be named\item[{\em string}]Location to place name\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]If the type is known to RIM \item[{\em RIM\_\-TYPEUNKN}]If the type is unknown\end{description}
\end{Desc}
\hypertarget{RIM_8h_a61}{
\index{RIM.h@{RIM.h}!RIM_nTypes@{RIM\_\-nTypes}}
\index{RIM_nTypes@{RIM\_\-nTypes}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-nTypes]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-n\-Types (void)}}
\label{RIM_8h_a61}


Return the number of component types within the LAT register description. 

\begin{Desc}
\item[Returns:]Number of component types\end{Desc}
\hypertarget{RIM_8h_a62}{
\index{RIM.h@{RIM.h}!RIM_read@{RIM\_\-read}}
\index{RIM_read@{RIM\_\-read}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-read]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-read (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, void $\ast$ {\em param}, \hyperlink{RIM_8h_a10}{RIM\_\-read\-Fn} $\ast$$\ast$ {\em read\-Fn}, \hyperlink{RIM_8h_a8}{RIM\_\-decode\-Fn} $\ast$$\ast$ {\em decode\-Fn}, const \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em ign})}}
\label{RIM_8h_a62}


Populate the RIM structure with the current state of the LAT. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the RIM structure to populate from the LAT\item[{\em param}]Pointer passed through to the {\em read\-Reg\-Fn\/} \item[{\em read\-Fn}]Type ordered array of pointers to functions that read the LAT registers\item[{\em decode\-Fn}]Type ordered array of pointers to functions that decode the register responses\item[{\em ign}]Map of the sections of the LAT known to be bad or not present so can be ignored.\end{description}
\end{Desc}
\hypertarget{RIM_8h_a63}{
\index{RIM.h@{RIM.h}!RIM_set@{RIM\_\-set}}
\index{RIM_set@{RIM\_\-set}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-set]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-set (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type}, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$ {\em addr}, int {\em reg\-Id}, const void $\ast$ {\em value})}}
\label{RIM_8h_a63}


Set the value of a register. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]In memory configuration structure to manipulated\item[{\em type}]Type of data sought\item[{\em addr}]Address of the leaf requested\item[{\em reg\-Id}]Register to set, as a LAT hardware ID\item[{\em value}]Ptr to value to set the register field to\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all the parameters are in bounds and the data is successfully retrieved. \item[{\em RIM\_\-TYPEUNKN}]if type is not a valid RIM\_\-type \item[{\em RIM\_\-CPTNONE}]if the requested type has no real data \item[{\em RIM\_\-ADDRBCST}]if the address contains a mixture of broadcast and unicast components \item[{\em RIM\_\-ADDRRNGE}]if any component of the address is outside the allowable range for this type \item[{\em RIM\_\-BADREGID}]if reg\-Id is outside the acceptable range of register IDs for this type\end{description}
\end{Desc}
\hypertarget{RIM_8h_a64}{
\index{RIM.h@{RIM.h}!RIM_setBit@{RIM\_\-setBit}}
\index{RIM_setBit@{RIM\_\-setBit}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-setBit]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-set\-Bit (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type}, const \hyperlink{union__RIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{RIM_8h_a64}


Set a bit in the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated\item[{\em type}]Identifies map to manipulate\item[{\em addr}]bit to set\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if everything goes well \item[{\em RIM\_\-TYPEUNKN}]if the type does not exist \item[{\em RIM\_\-MAPNONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDRBCST}]if the address contains a mixture of broadcast and unicast addresses \item[{\em RIM\_\-ADDRRNGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDRINDX}]if the final index exceeds the total number of bits in the map\end{description}
\end{Desc}
\hypertarget{RIM_8h_a65}{
\index{RIM.h@{RIM.h}!RIM_setSplit@{RIM\_\-setSplit}}
\index{RIM_setSplit@{RIM\_\-setSplit}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-setSplit]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-set\-Split (short $\ast$ {\em ptr}, unsigned long long {\em value}, unsigned {\em uid})}}
\label{RIM_8h_a65}


Decode the result item used to populate a split. 

The value from the TRC register is converted and assigned to the appropriate split register.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ptr}]Pointer to split registers instance\item[{\em value}]Value read from the TRC register\item[{\em uid}]The unique ID of the SPT register\end{description}
\end{Desc}
\hypertarget{RIM_8h_a66}{
\index{RIM.h@{RIM.h}!RIM_sizeof@{RIM\_\-sizeof}}
\index{RIM_sizeof@{RIM\_\-sizeof}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-sizeof]{\setlength{\rightskip}{0pt plus 5cm}size\_\-t RIM\_\-sizeof (void)}}
\label{RIM_8h_a66}


Calculate the footprint of the RIM structure. 

\begin{Desc}
\item[Returns:]Amount of memory required to hold the RIM structure\end{Desc}
\hypertarget{RIM_8h_a67}{
\index{RIM.h@{RIM.h}!RIM_sizeofMap@{RIM\_\-sizeofMap}}
\index{RIM_sizeofMap@{RIM\_\-sizeofMap}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-sizeofMap]{\setlength{\rightskip}{0pt plus 5cm}size\_\-t RIM\_\-sizeof\-Map (void)}}
\label{RIM_8h_a67}


Calculate the total size of a RIM\_\-map object. 

\begin{Desc}
\item[Returns:]Amount of memory required to accomodate a RIM\_\-map object\end{Desc}
