\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 $<$stdio.h$>$}\par


Include dependency graph for RIM.h:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=85pt]{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=174pt]{RIM_8h__dep__incl}
\end{center}
\end{figure}
\subsection*{Data Structures}
\begin{CompactItemize}
\item 
struct \hyperlink{structLayer__addr}{Layer\_\-addr}
\begin{CompactList}\small\item\em Address of a TFE/SPT node. \item\end{CompactList}\item 
struct \hyperlink{structACD__addr}{ACD\_\-addr}
\begin{CompactList}\small\item\em Address of a ARC/AFE node. \item\end{CompactList}\item 
struct \hyperlink{structTEM__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{unionRIM__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{structRIM__errorInfo}{RIM\_\-error\-Info}
\begin{CompactList}\small\item\em Information used to record a read error occured. \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 void( \hyperlink{RIM_8h_a3}{RIM\_\-decode\-Fn} )(unsigned short $\ast$pkt, void $\ast$ptr)}
\label{RIM_8h_a3}

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

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

\begin{CompactList}\small\item\em Function that Reads one type of LAT register. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a6}{
typedef void( \hyperlink{RIM_8h_a6}{RIM\_\-start\-Dgm} )(void $\ast$ctl)}
\label{RIM_8h_a6}

\begin{CompactList}\small\item\em Function called to start a new datagram. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a7}{
typedef unsigned( \hyperlink{RIM_8h_a7}{RIM\_\-start\-Ctb} )(void $\ast$ctl, size\_\-t size, unsigned type)}
\label{RIM_8h_a7}

\begin{CompactList}\small\item\em Function called to start a new contribution. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a8}{
typedef void( \hyperlink{RIM_8h_a8}{RIM\_\-add\-Data} )(void $\ast$ctl, void $\ast$data, size\_\-t size)}
\label{RIM_8h_a8}

\begin{CompactList}\small\item\em Function called to add data to a contribution. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a9}{
typedef void( \hyperlink{RIM_8h_a9}{RIM\_\-end\-Ctb} )(void $\ast$ctl)}
\label{RIM_8h_a9}

\begin{CompactList}\small\item\em Function called to end a datagram. \item\end{CompactList}\item 
\hypertarget{RIM_8h_a10}{
typedef unsigned( \hyperlink{RIM_8h_a10}{RIM\_\-end\-Dgm} )(void $\ast$ctl)}
\label{RIM_8h_a10}

\begin{CompactList}\small\item\em Function called to end (and send) a datagram. \item\end{CompactList}\end{CompactItemize}
\subsection*{Enumerations}
\begin{CompactItemize}
\item 
enum \{ \par
{\bf LATC\_\-MAJ} =  14, 
\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_a87}{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 \hyperlink{RIM_8h_a90}{RIM\_\-ERROR} \{ \par
{\bf RIM\_\-SUCCESS} =  0, 
\par
\hyperlink{RIM_8h_a90a22}{RIM\_\-ADDR\_\-BCAST} =  -11, 
\par
\hyperlink{RIM_8h_a90a23}{RIM\_\-ADDR\_\-RANGE} =  -12, 
\par
\hyperlink{RIM_8h_a90a24}{RIM\_\-ADDR\_\-INDEX} =  -13, 
\par
\hyperlink{RIM_8h_a90a25}{RIM\_\-ADDR\_\-LAYER} =  -14, 
\par
\hyperlink{RIM_8h_a90a26}{RIM\_\-ADDR\_\-LSIG} =  -15, 
\par
\hyperlink{RIM_8h_a90a27}{RIM\_\-ADDR\_\-LXY} =  -16, 
\par
\hyperlink{RIM_8h_a90a28}{RIM\_\-ADDR\_\-LIND} =  -17, 
\par
\hyperlink{RIM_8h_a90a29}{RIM\_\-TYPE\_\-UK} =  -21, 
\par
\hyperlink{RIM_8h_a90a30}{RIM\_\-TYPE\_\-STR} =  -22, 
\par
\hyperlink{RIM_8h_a90a31}{RIM\_\-MAP\_\-NONE} =  -31, 
\par
\hyperlink{RIM_8h_a90a32}{RIM\_\-DIFFER} =  -41, 
\par
\hyperlink{RIM_8h_a90a33}{RIM\_\-REG\_\-ID} =  -42, 
\par
\hyperlink{RIM_8h_a90a34}{RIM\_\-FLD\_\-ID} =  -43, 
\par
\hyperlink{RIM_8h_a90a35}{RIM\_\-NOT\_\-SET} =  -44, 
\par
\hyperlink{RIM_8h_a90a36}{RIM\_\-CPT\_\-NONE} =  -45, 
\par
\hyperlink{RIM_8h_a90a37}{RIM\_\-XML\_\-PARSE} =  -51, 
\par
\hyperlink{RIM_8h_a90a38}{RIM\_\-FILE\_\-END} =  -61, 
\par
\hyperlink{RIM_8h_a90a39}{RIM\_\-FILE\_\-READ} =  -62, 
\par
\hyperlink{RIM_8h_a90a40}{RIM\_\-FILE\_\-WRITE} =  -63, 
\par
\hyperlink{RIM_8h_a90a41}{RIM\_\-FILE\_\-OPEN} =  -64, 
\par
\hyperlink{RIM_8h_a90a42}{RIM\_\-FILE\_\-CLOSE} =  -65, 
\par
\hyperlink{RIM_8h_a90a43}{RIM\_\-BUF\_\-SHORT} =  -71, 
\par
\hyperlink{RIM_8h_a90a44}{RIM\_\-FLD\_\-RANGE} =  -81
 \}
\begin{CompactList}\small\item\em RIM error codes. \item\end{CompactList}\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item 
int \hyperlink{RIM_8h_a45}{RIM\_\-check\-Bit} (const \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$addr)
\begin{CompactList}\small\item\em Check a bit in the map. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a46}{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_a47}{RIM\_\-clear\-Bit} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$addr)
\begin{CompactList}\small\item\em Clear a bit in the map. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a48}{RIM\_\-clear\-By\-TWR} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, unsigned twr)
\begin{CompactList}\small\item\em Clear all bits in a submap corresponding to a particular tower. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a49}{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_a50}{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_a51}{RIM\_\-compare\-Type} (const char $\ast$string, \hyperlink{RIM_8h_a0}{RIM\_\-type} type)
\begin{CompactList}\small\item\em Compare {\em string\/} with the name of {\em type\/}. \item\end{CompactList}\item 
\hyperlink{RIM_8h_a1}{RIM} $\ast$ \hyperlink{RIM_8h_a52}{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_a53}{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_a54}{RIM\_\-consume} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, int fd)
\begin{CompactList}\small\item\em Read the block of data into the RIM structure. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a55}{RIM\_\-consume\-Map} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, int fd)
\begin{CompactList}\small\item\em Read map data into the map structure. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a56}{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{unionRIM__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_a57}{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 
unsigned \hyperlink{RIM_8h_a58}{RIM\_\-create} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, int fd)
\begin{CompactList}\small\item\em Create a single binary configuration file containing the data of one component (or the default data). \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a59}{RIM\_\-create\-Map} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, int fd)
\begin{CompactList}\small\item\em Write out the data of a RIM\_\-map structure. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a60}{RIM\_\-create\-Mask} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim)
\begin{CompactList}\small\item\em Creates a bitmask indicating which types can successfully be used with RIM\_\-create. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a61}{RIM\_\-dump\-Map} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, FILE $\ast$fp)
\begin{CompactList}\small\item\em Print out the map. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a62}{RIM\_\-get} (const \hyperlink{RIM_8h_a1}{RIM} $\ast$rim, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, const \hyperlink{unionRIM__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_a63}{RIM\_\-get\-Address} (\hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$addr, unsigned 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_a64}{RIM\_\-get\-Addr\-Rng} (const char $\ast$string, \hyperlink{unionRIM__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 
const char $\ast$ \hyperlink{RIM_8h_a65}{RIM\_\-get\-Error\-String} (\hyperlink{RIM_8h_a90}{RIM\_\-ERROR} err)
\begin{CompactList}\small\item\em Look up descriptive string for an error code. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a66}{RIM\_\-get\-Index} (const \hyperlink{unionRIM__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_a67}{RIM\_\-get\-Layer\-ID} (char sign, char xy, char index, unsigned $\ast$layer)
\begin{CompactList}\small\item\em Take three characters and convert them to a layer ID. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a68}{RIM\_\-get\-Layer\-Name} (unsigned layer, char $\ast$sign, char $\ast$xy, char $\ast$index)
\begin{CompactList}\small\item\em Get the characters of the layer name from the layer ID. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a69}{RIM\_\-load} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, void $\ast$param, \hyperlink{RIM_8h_a4}{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_a70}{RIM\_\-load\-Mdfy} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, unsigned reg, unsigned fe\-Mask, void $\ast$mask, void $\ast$value, void $\ast$param, \hyperlink{RIM_8h_a4}{RIM\_\-load\-Fn} $\ast$$\ast$load\-Fn)
\begin{CompactList}\small\item\em Load all instances of a register with a modified version of its value in the LAT configuration. \item\end{CompactList}\item 
\hyperlink{RIM_8h_a0}{RIM\_\-type} \hyperlink{RIM_8h_a71}{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_a72}{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_a73}{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_a74}{RIM\_\-read} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, void $\ast$param, \hyperlink{RIM_8h_a5}{RIM\_\-read\-Fn} $\ast$$\ast$read\-Fn, \hyperlink{RIM_8h_a3}{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_a75}{RIM\_\-record} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, void $\ast$pkt, \hyperlink{RIM_8h_a6}{RIM\_\-start\-Dgm} $\ast$start\-Dgm, \hyperlink{RIM_8h_a7}{RIM\_\-start\-Ctb} $\ast$start\-Ctb, \hyperlink{RIM_8h_a8}{RIM\_\-add\-Data} $\ast$add\-Data, \hyperlink{RIM_8h_a9}{RIM\_\-end\-Ctb} $\ast$end\-Ctb, \hyperlink{RIM_8h_a10}{RIM\_\-end\-Dgm} $\ast$end\-Dgm)
\begin{CompactList}\small\item\em Send the RIM to the SSR. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a76}{RIM\_\-report} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, FILE $\ast$fp, unsigned no\-Dflt)
\begin{CompactList}\small\item\em Print a report of the contents of the RIM to a file. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a77}{RIM\_\-retrieve} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, char $\ast$dat, size\_\-t len, unsigned id, int verb)
\begin{CompactList}\small\item\em Recover a portion of the RIM from a data buffer (actually an LSF contribution). \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a78}{RIM\_\-set} (\hyperlink{RIM_8h_a1}{RIM} $\ast$rim, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$addr, int reg\-Id, const void $\ast$value)
\begin{CompactList}\small\item\em Set the value of a register field. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a79}{RIM\_\-set\-Bit} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, const \hyperlink{unionRIM__addr}{RIM\_\-addr} $\ast$addr)
\begin{CompactList}\small\item\em Set a bit in the map. \item\end{CompactList}\item 
unsigned \hyperlink{RIM_8h_a80}{RIM\_\-set\-By\-TWR} (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$map, \hyperlink{RIM_8h_a0}{RIM\_\-type} type, unsigned twr)
\begin{CompactList}\small\item\em Set all bits in a submap corresponding to a particular tower. \item\end{CompactList}\item 
void \hyperlink{RIM_8h_a81}{RIM\_\-set\-SPT} (void $\ast$ptr, unsigned short value, unsigned is\-High)
\begin{CompactList}\small\item\em Decode the result item use to populate a split. \item\end{CompactList}\item 
size\_\-t \hyperlink{RIM_8h_a82}{RIM\_\-sizeof} (void)
\begin{CompactList}\small\item\em Calculate the footprint of the RIM structure. \item\end{CompactList}\item 
size\_\-t \hyperlink{RIM_8h_a83}{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.2 2007/03/22 23:40:00 saxton Exp \end{Desc}


\subsection{Enumeration Type Documentation}
\hypertarget{RIM_8h_a90}{
\index{RIM.h@{RIM.h}!RIM_ERROR@{RIM\_\-ERROR}}
\index{RIM_ERROR@{RIM\_\-ERROR}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-ERROR]{\setlength{\rightskip}{0pt plus 5cm}enum \hyperlink{RIM_8h_a90}{RIM\_\-ERROR}}}
\label{RIM_8h_a90}


RIM error codes. 

\begin{Desc}
\item[Enumerator: ]\par
\begin{description}
\index{RIM_ADDR_BCAST@{RIM\_\-ADDR\_\-BCAST}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_ADDR_BCAST@{RIM\_\-ADDR\_\-BCAST}}\item[{\em 
\hypertarget{RIM_8h_a90a22}{
RIM\_\-ADDR\_\-BCAST}
\label{RIM_8h_a90a22}
}]Address structure has a mixture of broadcast and unicast components. \index{RIM_ADDR_RANGE@{RIM\_\-ADDR\_\-RANGE}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_ADDR_RANGE@{RIM\_\-ADDR\_\-RANGE}}\item[{\em 
\hypertarget{RIM_8h_a90a23}{
RIM\_\-ADDR\_\-RANGE}
\label{RIM_8h_a90a23}
}]Address structure has a component out of range. \index{RIM_ADDR_INDEX@{RIM\_\-ADDR\_\-INDEX}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_ADDR_INDEX@{RIM\_\-ADDR\_\-INDEX}}\item[{\em 
\hypertarget{RIM_8h_a90a24}{
RIM\_\-ADDR\_\-INDEX}
\label{RIM_8h_a90a24}
}]The final index exceeds the total number of bits in the map. \index{RIM_ADDR_LAYER@{RIM\_\-ADDR\_\-LAYER}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_ADDR_LAYER@{RIM\_\-ADDR\_\-LAYER}}\item[{\em 
\hypertarget{RIM_8h_a90a25}{
RIM\_\-ADDR\_\-LAYER}
\label{RIM_8h_a90a25}
}]The layer information is nonsensical. \index{RIM_ADDR_LSIG@{RIM\_\-ADDR\_\-LSIG}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_ADDR_LSIG@{RIM\_\-ADDR\_\-LSIG}}\item[{\em 
\hypertarget{RIM_8h_a90a26}{
RIM\_\-ADDR\_\-LSIG}
\label{RIM_8h_a90a26}
}]The layer sign is wrong. \index{RIM_ADDR_LXY@{RIM\_\-ADDR\_\-LXY}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_ADDR_LXY@{RIM\_\-ADDR\_\-LXY}}\item[{\em 
\hypertarget{RIM_8h_a90a27}{
RIM\_\-ADDR\_\-LXY}
\label{RIM_8h_a90a27}
}]The layer x/y is wrong. \index{RIM_ADDR_LIND@{RIM\_\-ADDR\_\-LIND}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_ADDR_LIND@{RIM\_\-ADDR\_\-LIND}}\item[{\em 
\hypertarget{RIM_8h_a90a28}{
RIM\_\-ADDR\_\-LIND}
\label{RIM_8h_a90a28}
}]The layer index is wrong. \index{RIM_TYPE_UK@{RIM\_\-TYPE\_\-UK}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_TYPE_UK@{RIM\_\-TYPE\_\-UK}}\item[{\em 
\hypertarget{RIM_8h_a90a29}{
RIM\_\-TYPE\_\-UK}
\label{RIM_8h_a90a29}
}]RIM\_\-type is unknown. \index{RIM_TYPE_STR@{RIM\_\-TYPE\_\-STR}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_TYPE_STR@{RIM\_\-TYPE\_\-STR}}\item[{\em 
\hypertarget{RIM_8h_a90a30}{
RIM\_\-TYPE\_\-STR}
\label{RIM_8h_a90a30}
}]The string does not match a type name. \index{RIM_MAP_NONE@{RIM\_\-MAP\_\-NONE}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_MAP_NONE@{RIM\_\-MAP\_\-NONE}}\item[{\em 
\hypertarget{RIM_8h_a90a31}{
RIM\_\-MAP\_\-NONE}
\label{RIM_8h_a90a31}
}]There is no sub-map corresponding to this type. \index{RIM_DIFFER@{RIM\_\-DIFFER}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_DIFFER@{RIM\_\-DIFFER}}\item[{\em 
\hypertarget{RIM_8h_a90a32}{
RIM\_\-DIFFER}
\label{RIM_8h_a90a32}
}]Two RIM structures are functionally different. \index{RIM_REG_ID@{RIM\_\-REG\_\-ID}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_REG_ID@{RIM\_\-REG\_\-ID}}\item[{\em 
\hypertarget{RIM_8h_a90a33}{
RIM\_\-REG\_\-ID}
\label{RIM_8h_a90a33}
}]The register ID is out of range. \index{RIM_FLD_ID@{RIM\_\-FLD\_\-ID}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_FLD_ID@{RIM\_\-FLD\_\-ID}}\item[{\em 
\hypertarget{RIM_8h_a90a34}{
RIM\_\-FLD\_\-ID}
\label{RIM_8h_a90a34}
}]The field ID is out of range. \index{RIM_NOT_SET@{RIM\_\-NOT\_\-SET}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_NOT_SET@{RIM\_\-NOT\_\-SET}}\item[{\em 
\hypertarget{RIM_8h_a90a35}{
RIM\_\-NOT\_\-SET}
\label{RIM_8h_a90a35}
}]The requested node has not be previously set. \index{RIM_CPT_NONE@{RIM\_\-CPT\_\-NONE}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_CPT_NONE@{RIM\_\-CPT\_\-NONE}}\item[{\em 
\hypertarget{RIM_8h_a90a36}{
RIM\_\-CPT\_\-NONE}
\label{RIM_8h_a90a36}
}]The requested node has no real data. \index{RIM_XML_PARSE@{RIM\_\-XML\_\-PARSE}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_XML_PARSE@{RIM\_\-XML\_\-PARSE}}\item[{\em 
\hypertarget{RIM_8h_a90a37}{
RIM\_\-XML\_\-PARSE}
\label{RIM_8h_a90a37}
}]There was an error parsing the XML. \index{RIM_FILE_END@{RIM\_\-FILE\_\-END}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_FILE_END@{RIM\_\-FILE\_\-END}}\item[{\em 
\hypertarget{RIM_8h_a90a38}{
RIM\_\-FILE\_\-END}
\label{RIM_8h_a90a38}
}]File end was reached. \index{RIM_FILE_READ@{RIM\_\-FILE\_\-READ}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_FILE_READ@{RIM\_\-FILE\_\-READ}}\item[{\em 
\hypertarget{RIM_8h_a90a39}{
RIM\_\-FILE\_\-READ}
\label{RIM_8h_a90a39}
}]There was an error reading a file. \index{RIM_FILE_WRITE@{RIM\_\-FILE\_\-WRITE}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_FILE_WRITE@{RIM\_\-FILE\_\-WRITE}}\item[{\em 
\hypertarget{RIM_8h_a90a40}{
RIM\_\-FILE\_\-WRITE}
\label{RIM_8h_a90a40}
}]There was an error writing to a file. \index{RIM_FILE_OPEN@{RIM\_\-FILE\_\-OPEN}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_FILE_OPEN@{RIM\_\-FILE\_\-OPEN}}\item[{\em 
\hypertarget{RIM_8h_a90a41}{
RIM\_\-FILE\_\-OPEN}
\label{RIM_8h_a90a41}
}]There was an error opening a file. \index{RIM_FILE_CLOSE@{RIM\_\-FILE\_\-CLOSE}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_FILE_CLOSE@{RIM\_\-FILE\_\-CLOSE}}\item[{\em 
\hypertarget{RIM_8h_a90a42}{
RIM\_\-FILE\_\-CLOSE}
\label{RIM_8h_a90a42}
}]There was an error closing a file. \index{RIM_BUF_SHORT@{RIM\_\-BUF\_\-SHORT}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_BUF_SHORT@{RIM\_\-BUF\_\-SHORT}}\item[{\em 
\hypertarget{RIM_8h_a90a43}{
RIM\_\-BUF\_\-SHORT}
\label{RIM_8h_a90a43}
}]Supplied buffer is too short. \index{RIM_FLD_RANGE@{RIM\_\-FLD\_\-RANGE}!RIM.h@{RIM.h}}\index{RIM.h@{RIM.h}!RIM_FLD_RANGE@{RIM\_\-FLD\_\-RANGE}}\item[{\em 
\hypertarget{RIM_8h_a90a44}{
RIM\_\-FLD\_\-RANGE}
\label{RIM_8h_a90a44}
}]Value being loaded into a field is too large. \end{description}
\end{Desc}



\subsection{Function Documentation}
\hypertarget{RIM_8h_a45}{
\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{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{RIM_8h_a45}


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_a46}{
\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_a46}


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_a47}{
\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{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{RIM_8h_a47}


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\_\-TYPE\_\-UK}]if the type does not exist \item[{\em RIM\_\-MAP\_\-NONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDR\_\-INDEX}]if the final index exceeds the total number of bits in the map\end{description}
\end{Desc}
\hypertarget{RIM_8h_a48}{
\index{RIM.h@{RIM.h}!RIM_clearByTWR@{RIM\_\-clearByTWR}}
\index{RIM_clearByTWR@{RIM\_\-clearByTWR}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-clearByTWR]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-clear\-By\-TWR (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type}, unsigned {\em twr})}}
\label{RIM_8h_a48}


Clear all bits in a submap corresponding to a particular tower. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a RIM\_\-map structure\item[{\em type}]Identifies the sub-map to manipulate\item[{\em twr}]Index of a tower\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if everything goes well \item[{\em RIM\_\-TYPE\_\-UK}]if the type does not exist \item[{\em RIM\_\-MAP\_\-NONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDR\_\-INDEX}]if the final index exceeds the total number of bits in the map\end{description}
\end{Desc}
\hypertarget{RIM_8h_a49}{
\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_a49}


Clear the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Structure being manipulated\end{description}
\end{Desc}
\hypertarget{RIM_8h_a50}{
\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_a50}


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_a51}{
\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_a51}


Compare {\em string\/} with the name of {\em 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 {\em type\/} is unknown (exceeds the range of acceptable types) \item[{\em 0}]If the {\em type\/} is known, and the name matches the {\em string\/} \item[{\em 1}]If the {\em type\/} is known, and the name does not match the {\em string\/} \end{description}
\end{Desc}
\hypertarget{RIM_8h_a52}{
\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_a52}


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_a53}{
\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_a53}


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_a54}{
\index{RIM.h@{RIM.h}!RIM_consume@{RIM\_\-consume}}
\index{RIM_consume@{RIM\_\-consume}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-consume]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-consume (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, int {\em fd})}}
\label{RIM_8h_a54}


Read the block of data into the RIM structure. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the RIM structure to populate\item[{\em fd}]Descriptor of a file opened for reading\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]The data was successfully read \item[{\em RIM\_\-TYPE\_\-UK}]The type identifier at the start of the block did not correspond to a known type \item[{\em RIM\_\-CPT\_\-NONE}]The type ID does not appear to be associated with a LAT component \item[{\em RIM\_\-MAP\_\-NONE}]The data was of a singleton type, by an attempt to recover a map was made \item[{\em RIM\_\-FILE\_\-END}]If the end of the file is reached \item[{\em RIM\_\-FILE\_\-READ}]If there is an error reading from the file\end{description}
\end{Desc}
\hypertarget{RIM_8h_a55}{
\index{RIM.h@{RIM.h}!RIM_consumeMap@{RIM\_\-consumeMap}}
\index{RIM_consumeMap@{RIM\_\-consumeMap}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-consumeMap]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-consume\-Map (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, int {\em fd})}}
\label{RIM_8h_a55}


Read map data into the map structure. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Map structure to populate from file\item[{\em fd}]Descriptor of a file opened for reading\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all goes well \item[{\em RIM\_\-FILE\_\-READ}]if an error occures whilst the file is being read \item[{\em RIM\_\-FILE\_\-END}]if the end of the file is unexpectedly encountered\end{description}
\end{Desc}
\hypertarget{RIM_8h_a56}{
\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{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em r\_\-addr})}}
\label{RIM_8h_a56}


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_a57}{
\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_a57}


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_a58}{
\index{RIM.h@{RIM.h}!RIM_create@{RIM\_\-create}}
\index{RIM_create@{RIM\_\-create}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-create]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-create (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type}, int {\em fd})}}
\label{RIM_8h_a58}


Create a single binary configuration file containing the data of one component (or the default data). 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]RIM structure to use as a source\item[{\em type}]Component type to write out\item[{\em fd}]Descriptor of a file opened for writing\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all goes well \item[{\em RIM\_\-FILE\_\-WRITE}]if one of the file write operations failed \item[{\em RIM\_\-MAP\_\-NONE}]if the selected type is not written seperately \item[{\em RIM\_\-CPT\_\-NONE}]if the selected type has not data specified\end{description}
\end{Desc}
\hypertarget{RIM_8h_a59}{
\index{RIM.h@{RIM.h}!RIM_createMap@{RIM\_\-createMap}}
\index{RIM_createMap@{RIM\_\-createMap}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-createMap]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-create\-Map (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, int {\em fd})}}
\label{RIM_8h_a59}


Write out the data of a RIM\_\-map structure. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to the RIM\_\-map whose data should be written to file\item[{\em fd}]Descriptor of a file opened for writing\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if all goes well \item[{\em RIM\_\-FILE\_\-WRITE}]if one of the file write operations failed\end{description}
\end{Desc}
\hypertarget{RIM_8h_a60}{
\index{RIM.h@{RIM.h}!RIM_createMask@{RIM\_\-createMask}}
\index{RIM_createMask@{RIM\_\-createMask}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-createMask]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-create\-Mask (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim})}}
\label{RIM_8h_a60}


Creates a bitmask indicating which types can successfully be used with RIM\_\-create. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the in-memory model\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]Bit mask indicating the types of files that can be created\end{Desc}
\hypertarget{RIM_8h_a61}{
\index{RIM.h@{RIM.h}!RIM_dumpMap@{RIM\_\-dumpMap}}
\index{RIM_dumpMap@{RIM\_\-dumpMap}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-dumpMap]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-dump\-Map (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, FILE $\ast$ {\em fp})}}
\label{RIM_8h_a61}


Print out the map. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fp}]Pointer to file to dump the map to\item[{\em map}]Pointer to an initialised map structure\end{description}
\end{Desc}
\hypertarget{RIM_8h_a62}{
\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{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr}, int {\em reg\-Id}, void $\ast$ {\em value})}}
\label{RIM_8h_a62}


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\_\-TYPE\_\-UK}]if {\em type\/} is not a valid RIM\_\-type \item[{\em RIM\_\-CPT\_\-NONE}]if the requested type has no real data \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and unicast components \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is outside the allowable range for this type \item[{\em RIM\_\-REG\_\-ID}]if {\em reg\-Id\/} is outside the acceptable range of register IDs for this type \item[{\em RIM\_\-NOT\_\-SET}]if the requested node has not been previously set\end{description}
\end{Desc}
\hypertarget{RIM_8h_a63}{
\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{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr}, unsigned {\em index}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type})}}
\label{RIM_8h_a63}


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-$>$RIM 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}]if the address is successfully converted to an index \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is outside the allowable range for this type\end{description}
\end{Desc}
\hypertarget{RIM_8h_a64}{
\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{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{RIM_8h_a64}


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 {\em string\/} is a good type name. \item[{\em RIM\_\-TYPE\_\-STR}]If the {\em string\/} does not match a known type\end{description}
\end{Desc}
\hypertarget{RIM_8h_a65}{
\index{RIM.h@{RIM.h}!RIM_getErrorString@{RIM\_\-getErrorString}}
\index{RIM_getErrorString@{RIM\_\-getErrorString}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-getErrorString]{\setlength{\rightskip}{0pt plus 5cm}const char$\ast$ RIM\_\-get\-Error\-String (\hyperlink{RIM_8h_a90}{RIM\_\-ERROR} {\em err})}}
\label{RIM_8h_a65}


Look up descriptive string for an error code. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em err}]Error code to lookup\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]Pointer to a string describing the error code.\end{Desc}
\hypertarget{RIM_8h_a66}{
\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{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr}, unsigned $\ast$ {\em index}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type})}}
\label{RIM_8h_a66}


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 type}]Type of address to convert\item[{\em index}]Index corresponding to address\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if the address is successfully converted to an index \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and unicast components \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is outside the allowable range for this type\end{description}
\end{Desc}
\hypertarget{RIM_8h_a67}{
\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 (char {\em sign}, char {\em xy}, char {\em index}, unsigned $\ast$ {\em layer})}}
\label{RIM_8h_a67}


Take three characters and convert them to a layer ID. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em sign}]'+' or '-'\item[{\em xy}]'x' or 'y'\item[{\em index}]'0' -$>$ '8'\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\_\-ADDR\_\-LSIG}]If the layer sign is nonsensical \item[{\em RIM\_\-ADDR\_\-LXY}]If the layer xy value is nonsensical \item[{\em RIM\_\-ADDR\_\-LIND}]If the layer index is nonsensical\end{description}
\end{Desc}
\hypertarget{RIM_8h_a68}{
\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 sign}, char $\ast$ {\em xy}, char $\ast$ {\em index})}}
\label{RIM_8h_a68}


Get the characters of the layer name from the layer ID. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em layer}]ID of the layer to name\item[{\em sign}]Pointer to location to place the sign character\item[{\em xy}]Pointer to location to place the xy character\item[{\em index}]Pointer to location to place the index character\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]If the layer is located \item[{\em RIM\_\-ADDR\_\-LAYER}]If the layer is out of range\end{description}
\end{Desc}
\hypertarget{RIM_8h_a69}{
\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_a4}{RIM\_\-load\-Fn} $\ast$$\ast$ {\em load\-Fn})}}
\label{RIM_8h_a69}


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_a70}{
\index{RIM.h@{RIM.h}!RIM_loadMdfy@{RIM\_\-loadMdfy}}
\index{RIM_loadMdfy@{RIM\_\-loadMdfy}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-loadMdfy]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-load\-Mdfy (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type}, unsigned {\em reg\-Id}, unsigned {\em fe\-Mask}, void $\ast$ {\em mask}, void $\ast$ {\em value}, void $\ast$ {\em param}, \hyperlink{RIM_8h_a4}{RIM\_\-load\-Fn} $\ast$$\ast$ {\em load\-Fn})}}
\label{RIM_8h_a70}


Load all instances of a register with a modified version of its value in the LAT configuration. 

This routine, in its simplest form, allows all registers of a single component of the configuration to be written to the LAT. Additionally this may be further restricted to a single register of that component. In this case, each instance of the register may also have its value modified by a supplied value under a supplied mask. Furthermore, if the register is a front-end one (AFE, CFE or TFE), the modification can be optionally restricted to only those front-ends with a corresponding bit set in the supplied front-end mask.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the cached in-memory model of the LAT registers\item[{\em type}]The type (from RIM/RIM\_\-AG\_\-types.h) of the component to be loaded.\item[{\em reg\-Id}]The hardware ID of the register being loaded, or RIM\_\-BCAST\_\-ADDR if all registers are to be loaded unmodified.\item[{\em fe\-Mask}]If the specified register is a front-end register, restricts the modification to only those front-ends with bits set in this mask. The value -1 indicates in an optimal way that all front-ends are modified.\item[{\em mask}]The address of the bit mask of the fields of the register being replaced\item[{\em value}]The address of the value to use in place of the masked part of the register\item[{\em param}]Parameter passed through to the load function\item[{\em load\-Fn}]Type ordered array of pointers to functions that load the LAT registers\end{description}
\end{Desc}
\hypertarget{RIM_8h_a71}{
\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_a71}


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_a72}{
\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_a72}


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\_\-TYPE\_\-UK}]If the type is unknown\end{description}
\end{Desc}
\hypertarget{RIM_8h_a73}{
\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_a73}


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

\begin{Desc}
\item[Returns:]Number of component types\end{Desc}
\hypertarget{RIM_8h_a74}{
\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_a5}{RIM\_\-read\-Fn} $\ast$$\ast$ {\em read\-Fn}, \hyperlink{RIM_8h_a3}{RIM\_\-decode\-Fn} $\ast$$\ast$ {\em decode\-Fn}, const \hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em ign})}}
\label{RIM_8h_a74}


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_a75}{
\index{RIM.h@{RIM.h}!RIM_record@{RIM\_\-record}}
\index{RIM_record@{RIM\_\-record}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-record]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-record (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, void $\ast$ {\em pkt}, \hyperlink{RIM_8h_a6}{RIM\_\-start\-Dgm} $\ast$ {\em start\-Dgm}, \hyperlink{RIM_8h_a7}{RIM\_\-start\-Ctb} $\ast$ {\em start\-Ctb}, \hyperlink{RIM_8h_a8}{RIM\_\-add\-Data} $\ast$ {\em add\-Data}, \hyperlink{RIM_8h_a9}{RIM\_\-end\-Ctb} $\ast$ {\em end\-Ctb}, \hyperlink{RIM_8h_a10}{RIM\_\-end\-Dgm} $\ast$ {\em end\-Dgm})}}
\label{RIM_8h_a75}


Send the RIM to the SSR. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the RIM structure used to populate the datagram\item[{\em pkt}]Opaque pointer to the control structure passed back to the call-backs\item[{\em start\-Dgm}]Pointer to function used to start datagram\item[{\em start\-Ctb}]Pointer to function used to start a contribution\item[{\em add\-Data}]Pointer to function used to add a block of data\item[{\em end\-Ctb}]Pointer to function used to end a contribution\item[{\em end\-Dgm}]Pointer to function used to end a datagram\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]One of the error codes from ITC\_\-send, LATC\_\-OUTSIZE if there is a coding error and one of the contributions will not fit into an otherwise empty datagram or LATC\_\-SUCCESS if all goes well.\end{Desc}
\hypertarget{RIM_8h_a76}{
\index{RIM.h@{RIM.h}!RIM_report@{RIM\_\-report}}
\index{RIM_report@{RIM\_\-report}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-report]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-report (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, FILE $\ast$ {\em fp}, unsigned {\em no\-Dflt})}}
\label{RIM_8h_a76}


Print a report of the contents of the RIM to a file. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]RIM structure to use as a source\item[{\em fp}]Pointer to destination of the report\item[{\em no\-Dflt}]True if default values not present\end{description}
\end{Desc}
\hypertarget{RIM_8h_a77}{
\index{RIM.h@{RIM.h}!RIM_retrieve@{RIM\_\-retrieve}}
\index{RIM_retrieve@{RIM\_\-retrieve}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-retrieve]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-retrieve (\hyperlink{RIM_8h_a1}{RIM} $\ast$ {\em rim}, char $\ast$ {\em dat}, size\_\-t {\em len}, unsigned {\em id}, int {\em verb})}}
\label{RIM_8h_a77}


Recover a portion of the RIM from a data buffer (actually an LSF contribution). 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em rim}]Pointer to the RIM to populate\item[{\em dat}]Pointer to a block of data to use\item[{\em len}]Length of the data\item[{\em id}]Contribution identfier\item[{\em verb}]1 - print information messages, 0 - don't\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESSS}]If the contribution is successfully handled \item[{\em RIM\_\-TYPE\_\-UK}]If the type ID in the contribution indicates a component type that does not have configuration data \item[{\em RIM\_\-MAP\_\-NONE}]If the type ID in the contribution indicates a component map for a single component \item[{\em RIM\_\-BUF\_\-SHORT}]If the contribution is too short to contain the specified data\end{description}
\end{Desc}
\hypertarget{RIM_8h_a78}{
\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{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr}, int {\em reg\-Id}, const void $\ast$ {\em value})}}
\label{RIM_8h_a78}


Set the value of a register field. 

\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\_\-TYPE\_\-UK}]if {\em type\/} is not a valid RIM\_\-type \item[{\em RIM\_\-CPT\_\-NONE}]if the requested type has no real data \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and unicast components \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is outside the allowable range for this type \item[{\em RIM\_\-REG\_\-ID}]if {\em reg\-Id\/} is outside the acceptable range of register IDs for this type \item[{\em RIM\_\-FLD\_\-ID}]if {\em fld\-Id\/} is outside the acceptable range of field IDs\end{description}
\end{Desc}
\hypertarget{RIM_8h_a79}{
\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{unionRIM__addr}{RIM\_\-addr} $\ast$ {\em addr})}}
\label{RIM_8h_a79}


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\_\-TYPE\_\-UK}]if the type does not exist \item[{\em RIM\_\-MAP\_\-NONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDR\_\-INDEX}]if the final index exceeds the total number of bits in the map\end{description}
\end{Desc}
\hypertarget{RIM_8h_a80}{
\index{RIM.h@{RIM.h}!RIM_setByTWR@{RIM\_\-setByTWR}}
\index{RIM_setByTWR@{RIM\_\-setByTWR}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-setByTWR]{\setlength{\rightskip}{0pt plus 5cm}unsigned RIM\_\-set\-By\-TWR (\hyperlink{RIM_8h_a2}{RIM\_\-map} $\ast$ {\em map}, \hyperlink{RIM_8h_a0}{RIM\_\-type} {\em type}, unsigned {\em twr})}}
\label{RIM_8h_a80}


Set all bits in a submap corresponding to a particular tower. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em map}]Pointer to a RIM\_\-map structure\item[{\em type}]Identifies the sub-map to manipulate\item[{\em twr}]Index of a tower\end{description}
\end{Desc}
\begin{Desc}
\item[Return values:]
\begin{description}
\item[{\em RIM\_\-SUCCESS}]if everything goes well \item[{\em RIM\_\-TYPE\_\-UK}]if the type does not exist \item[{\em RIM\_\-MAP\_\-NONE}]if there is no sub-map corresponding to this type \item[{\em RIM\_\-ADDR\_\-BCAST}]if the address contains a mixture of broadcast and singlecast addresses \item[{\em RIM\_\-ADDR\_\-RANGE}]if any component of the address is out of range \item[{\em RIM\_\-ADDR\_\-INDEX}]if the final index exceeds the total number of bits in the map\end{description}
\end{Desc}
\hypertarget{RIM_8h_a81}{
\index{RIM.h@{RIM.h}!RIM_setSPT@{RIM\_\-setSPT}}
\index{RIM_setSPT@{RIM\_\-setSPT}!RIM.h@{RIM.h}}
\subsubsection[RIM\_\-setSPT]{\setlength{\rightskip}{0pt plus 5cm}void RIM\_\-set\-SPT (void $\ast$ {\em ptr}, unsigned short {\em value}, unsigned {\em is\-High})}}
\label{RIM_8h_a81}


Decode the result item use to populate a split. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em ptr}]Pointer to memory location to put decoded value\item[{\em value}]One of the split fields\item[{\em is\-High}]Indicates which of the split fields this is\end{description}
\end{Desc}
\hypertarget{RIM_8h_a82}{
\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_a82}


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_a83}{
\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_a83}


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}
