/* BEGIN_ICS_COPYRIGHT4 ****************************************

Copyright (c) 2015, Intel Corporation

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
    * Neither the name of Intel Corporation nor the names of its contributors
      may be used to endorse or promote products derived from this software
      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

** END_ICS_COPYRIGHT4   ****************************************/

#include "smamain.h"




//
// RegisterMemGlobal
//
//	Registers a given virtual address with all known Channel Adapters
//	to the SMA
//
// Note: If we tweak the PdHandle to be unique for each client
//		 we can expose this function to clients.
//
//
//
// INPUTS:
//
//	VirtualAddress	-Address to register
//
//	Length			-amount of bytes to register in Length.
//
//	AccessControl	-Type of memory access.
//
//
//
// OUTPUTS:
//
//	CaMemIndex		-Global memory index that uniquely identifies this memory
//					 on all Channel Adapters
//
//
// RETURNS:
//
//
//
// caller cannot hold g_Sma->Bin.Lock, but may hold Mutex

FSTATUS
RegisterMemGlobal(
	IN  void				*VirtualAddress,
	IN  size_t				Length,
	IN  IB_ACCESS_CONTROL	AccessControl,
	OUT uint32				*CaMemIndex
	 )
{
	FSTATUS					status = FSUCCESS;
	SMA_CA_OBJ_PRIVATE		*pCaObj;
	CA_MEM_LIST				caMemList;
	boolean					haveIndex = FALSE;


	_DBG_ENTER_LVL(_DBG_LVL_STORE, RegisterMemGlobal);


	// Register memory with all CA's

	SpinLockAcquire(&g_Sma->CaListLock);
	for (pCaObj = g_Sma->CaObj; pCaObj; pCaObj = pCaObj->Next)
	{
		pCaObj->UseCount++;
		SpinLockRelease(&g_Sma->CaListLock);

		if (! haveIndex)
		{
			// get an index for memory
			SmaCreateCaMemIndex( pCaObj, CaMemIndex );
			haveIndex = TRUE;
		}

		status = iba_register_mr( pCaObj->CaHandle, VirtualAddress, Length,
						pCaObj->PdHandle, AccessControl, &caMemList.MrHandle,
						&caMemList.LKey, &caMemList.RKey);

		// Check for return values
		if ( FSUCCESS != status )
		{
			_DBG_ERROR(("Could not register Memory!\n"));
			goto failmr;
		}

		status = SmaAddToCaMemTable( pCaObj, &caMemList, *CaMemIndex);
		if ( FSUCCESS != status )
		{
			_DBG_ERROR(("Could not add to Ca Mem Table!\n"));
			goto failtbl;
		}

		SpinLockAcquire(&g_Sma->CaListLock);
		pCaObj->UseCount--;

	}	// for I loop
	SpinLockRelease(&g_Sma->CaListLock);

	if (! haveIndex)
	{
		// get an index for memory
		SmaCreateCaMemIndex( NULL, CaMemIndex );
	}

done:
	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
	return status;

failtbl:
	(void)iba_deregister_mr(caMemList.MrHandle);

failmr:
	SpinLockAcquire(&g_Sma->CaListLock);
	pCaObj->UseCount--;
	// unwind other CA's
	while (NULL != (pCaObj = pCaObj->Prev))
	{
		pCaObj->UseCount++;
		SpinLockRelease(&g_Sma->CaListLock);

		GetMemInfoFromCaMemTable( pCaObj, *CaMemIndex, &caMemList);

		(void)iba_deregister_mr(caMemList.MrHandle);

		DeleteFromCaMemTable( pCaObj, *CaMemIndex);

		SpinLockAcquire(&g_Sma->CaListLock);
		pCaObj->UseCount--;
	}
	SpinLockRelease(&g_Sma->CaListLock);

	SmaDeleteCaMemIndex( *CaMemIndex );

	goto done;
}


//
// DeregisterMemGlobal
//
//	DeRegisters a given virtual address with all known Channel Adapters
//	to the SMA. The address is defined by the Index it references.
//
//
//
// INPUTS:
//
//	CaMemIndex		-Global memory index that uniquely identifies this memory
//					 on all Channel Adapters
//
//
//
// OUTPUTS:
//
//
//
// RETURNS:
//
//
//

FSTATUS
DeregisterMemGlobal(
	IN	uint32				CaMemIndex
	 )
{
	FSTATUS					status = FSUCCESS;
	SMA_CA_OBJ_PRIVATE		*pCaObj;
	CA_MEM_LIST				caMemList = { 0 };	/* keep compiler happy */


	_DBG_ENTER_LVL(_DBG_LVL_STORE, DeregisterMemGlobal);


	// DeRegister memory with all CA's


	// Loop through all CAs
	SpinLockAcquire(&g_Sma->CaListLock);
	for (pCaObj = g_Sma->CaObj; pCaObj; pCaObj = pCaObj->Next)
	{
		pCaObj->UseCount++;
		SpinLockRelease(&g_Sma->CaListLock);

		GetMemInfoFromCaMemTable( pCaObj, CaMemIndex, &caMemList);

		iba_deregister_mr(caMemList.MrHandle);

		DeleteFromCaMemTable( pCaObj, CaMemIndex);

		SpinLockAcquire(&g_Sma->CaListLock);
		pCaObj->UseCount--;
	}
	SpinLockRelease(&g_Sma->CaListLock);

	SmaDeleteCaMemIndex( CaMemIndex );

	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
	return status;

}


void
AcquireMemListMutex(void)
{
	MutexAcquire( &g_Sma->Bin.Mutex );
}

void
ReleaseMemListMutex(void)
{
	MutexRelease( &g_Sma->Bin.Mutex );
}

//
// CreateGlobalMemList
//
//	Registers a given virtual address with all known Channel Adapters
//	to the SMA.
//
// Note: If we tweak the PdHandle to be unique for each client
//		 we can expose this function to clients.
//
//
// INPUTS:
//
//	VirtualAddress	-Address to register
//
//	Length			-amount of bytes to register in Length.
//
//	HeaderAddress	-Address to block headers that hold registered mem
//
//	HoldingMutex		-is caller already holding g_Sma->Bin.Mutex (eg. MemListMutex)
//
//
//
// OUTPUTS:
//
//	GlobalMemList	-Global memory List that identifies memory across CA's
//
//
// RETURNS:
//
//
//

GLOBAL_MEM_LIST *
CreateGlobalMemList(
	void				*VirtualAddr,		
	uintn				Length,
	void				*HdrAddr,
	boolean				HoldingMutex
	)
{
	GLOBAL_MEM_LIST		*pMemList;

	//
	// Create global memory block in memory list
	//

	pMemList = (GLOBAL_MEM_LIST*)MemoryAllocateAndClear(sizeof(GLOBAL_MEM_LIST), FALSE, SMA_MEM_TAG);
	if ( NULL != pMemList )
	{
		pMemList->VirtualAddr = VirtualAddr;
		pMemList->Length = Length;
		pMemList->HdrAddr = HdrAddr;

		pMemList->Prev = NULL;

		if (! HoldingMutex)
			MutexAcquire( &g_Sma->Bin.Mutex );
		pMemList->Next = g_Sma->Bin.MemList;
		if (g_Sma->Bin.MemList)
			g_Sma->Bin.MemList->Prev = pMemList;
		g_Sma->Bin.MemList = pMemList;
		if (! HoldingMutex)
			MutexRelease( &g_Sma->Bin.Mutex );
	}	// pMemList

	return pMemList;
}

//	caller must not be holding g_Sma->Bin.Mutex
FSTATUS
DeleteGlobalMemList(
	GLOBAL_MEM_LIST				*MemList		
	)
{
	FSTATUS						status=FSUCCESS;

	MutexAcquire( &g_Sma->Bin.Mutex );

	//
	// Delete global memory block in memory list
	//

	//
	// delink from list first
	//

	if ( NULL != MemList->Prev )
	{
		((GLOBAL_MEM_LIST *)MemList->Prev)->Next = MemList->Next;
	}
	
	if ( NULL != MemList->Next )
	{
		((GLOBAL_MEM_LIST *)MemList->Next)->Prev = MemList->Prev;
	}


	//
	// fix head of list if needed
	//

	if ( MemList == g_Sma->Bin.MemList )
	{
		g_Sma->Bin.MemList = (GLOBAL_MEM_LIST*)MemList->Next;
	}

	MutexRelease( &g_Sma->Bin.Mutex );
	
	//
	// Free this block of mem
	//

	MemoryDeallocate( MemList );

	return status;
}



//
// SmaGrabFromBin
//
//	Grabs a specified number of MADs from pool.
//	If the specified number of MADs are not available in pool, it is made
//	available by more allocations.
//
//
//
// INPUTS:
//
//	NumMad				-Number of buffers requested in MAD sizes 
//
//	MadPool				-Pointer to hold list of alloacted MAD buffers
//
//
// OUTPUTS:
//
//	NumMad				-Number of buffers allocated
//
//	MadPool				-Pointer holds list of alloacted MAD buffers
//
//
// RETURNS:
//
//
//

#if 0 // not yet implemented, if'def out so get errors if anyone tried to use
FSTATUS
SmaGrabFromBin(
	IN OUT	uint32		*NumMad,
	IN OUT	SMP_BLOCK	*MadPool
	)
{
	FSTATUS				status = FSUCCESS;
	
	_DBG_ENTER_LVL(_DBG_LVL_STORE, SmaGrabFromBin);
	

	SpinLockAcquire( &g_Sma->Bin.Lock );

	SpinLockRelease( &g_Sma->Bin.Lock );

	
	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
	return status;
}
#endif





//
// SmaReturnToBin
//
//	Grabs a specified number of MADs from pool.
//	If the specified number of MADs are not available in pool, it is made
//	available by more allocations.
//
//
//
// INPUTS:
//
//	NumMad				-Number of buffers to free (in MAD sizes) 
//
//	MadPool				-Pointer to list of MAD buffers to free
//
//
// OUTPUTS:
//
//
// RETURNS:
//
//
//
//

FSTATUS
SmaReturnToBin(
	IN	POOL_DATA_BLOCK		*SmpBlockList
	)
{
	FSTATUS					status = FSUCCESS;
	POOL_DATA_BLOCK			*pMem, *pMemNext;
	uint32					NumSmps;

	_DBG_ENTER_LVL(_DBG_LVL_STORE, SmaReturnToBin);
	

	//
	// lock
	//
	
	SpinLockAcquire( &g_Sma->Bin.Lock );


	//
	// return to bin
	//

	pMemNext = g_Sma->Bin.Tail;					// get system list
	pMem = SmpBlockList;						// load user list

	_DBG_PRINT(_DBG_LVL_STORE,(
		"(FREE)pMem(x%p) Next(x%p) Prev(x%p)\n",
		_DBG_PTR(pMem), _DBG_PTR(pMem->Block.Next), _DBG_PTR(pMem->Block.Prev)));

	
	//
	// add to system list
	//

	pMem->Block.Prev = pMemNext;
	if ( NULL == pMemNext )
	{
		g_Sma->Bin.Head = pMem;
	}
	else
	{
		_DBG_PRINT(_DBG_LVL_STORE,(
			"(TAIL)pMemNext(x%p) Next(x%p) Prev(x%p)\n",
			_DBG_PTR(pMemNext), _DBG_PTR(pMemNext->Block.Next), _DBG_PTR(pMemNext->Block.Prev)));


		pMemNext->Block.Next = pMem;
	}


	//
	// count the SMPs returned
	//

	NumSmps = 1;								// start from here
	pMem->Block.PathBits = 0;
	pMem->Block.ServiceLevel = 0;
	pMem->Block.StaticRate = 0;
	pMem->Block.pSendContext = (void *)-1;    //reset the sendcontext

	while ( NULL != pMem->Block.Next )
	{
		NumSmps++;								// keep counting
		pMem = (POOL_DATA_BLOCK*)pMem->Block.Next;						// loop

		pMem->Block.PathBits = 0;
		pMem->Block.ServiceLevel = 0;
		pMem->Block.StaticRate = 0;
		pMem->Block.pSendContext = (void *)-1;    //reset the sendcontext
	}


	//
	// update system list
	//

	g_Sma->Bin.Tail = pMem;
	g_Sma->Bin.NumBlocks += NumSmps;

	_DBG_PRINT(_DBG_LVL_STORE,(
		"x%x Free Smps in POOL\n", g_Sma->Bin.NumBlocks));

	//
	// Do house keeping
	// TBD: Do we need to free memory not used?
	//

	
	//
	// unlock
	//

	SpinLockRelease( &g_Sma->Bin.Lock );

	
	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
	return status;

}




//
// SmaAllocToBin
//
//	Creates new entries in MAD pool. The number of new entries is specified
//	as input.
//	The functions adds the an average of the total number of MADs specified.
//	The average is derived from a stored value that may be set at install
//	time.
//
//	In addition to the MAD buffer that is created in pool, a header is also
//	allocated that will hold the transport header like the GRH and the 
//	data transfer values for send/recevies.
//
// Note:
//	Lock taken by caller
//
//
//
// INPUTS:
//
//	NumMads				-Number of MADs buffers to create(in MAD sizes) 
//
//	HoldingMutex			-is caller already holding g_Sma->Bin.Mutex
//
//  Note: Caller must not be holding g_Sma->Bin.Lock
//
// OUTPUTS:
//
//
// RETURNS:
//
//
//
//

FSTATUS
SmaAllocToBin(
	IN uint32			NumMads,
	IN boolean			HoldingMutex
	)
{
	FSTATUS				status = FSUCCESS;
	UD_TOTAL_BLOCK		*pUdBlock=NULL;
	POOL_DATA_BLOCK		*pSmpBlock=NULL;
	GLOBAL_MEM_LIST		*pMemList=NULL;

	POOL_DATA_BLOCK		*pSmpBlockCurr;
	POOL_DATA_BLOCK		*pSmpBlockPrev, *pSmpBlockNext;
	uint32				i, totalSmps;
	
	_DBG_ENTER_LVL(_DBG_LVL_STORE, SmaAllocToBin);
	

	//
	// lookup threshold level for smps in bin
	//
	
	totalSmps = ( NumMads <= g_Settings.MinSMPsPerAllocate ? \
					g_Settings.MinSMPsPerAllocate: \
				 ( NumMads + g_Settings.MinSMPsPerAllocate - \
				   ( NumMads % g_Settings.MinSMPsPerAllocate )));

	if (! HoldingMutex)
		MutexAcquire( &g_Sma->Bin.Mutex );

	if ( g_Settings.MaxSMPs < g_Sma->Bin.TotalAllocated + totalSmps )
	{
		_DBG_ERROR((
			"MaxSMP allocation threshold (x%x) level reached\n",
			g_Settings.MaxSMPs));

		totalSmps = g_Settings.MaxSMPs - g_Sma->Bin.TotalAllocated;
	}

	
	//
	// Allocate memory for SMPs
	//

	//
	// BUGBUG: We should allocate paged mem here for Win2K and lock it
	//
	
	if ( totalSmps )
	{
		pUdBlock = (UD_TOTAL_BLOCK*)MemoryAllocateAndClear(
						 totalSmps * sizeof(MAD), FALSE, SMA_MEM_TAG);
	}

	if ( NULL != pUdBlock )
	{

		//
		// alloc memory for POOL_DATA_BLOCKs
		//

		pSmpBlock = (POOL_DATA_BLOCK*)MemoryAllocateAndClear(
					totalSmps * sizeof(POOL_DATA_BLOCK), FALSE, SMA_MEM_TAG);
		if ( NULL != pSmpBlock )
		{

			//
			// Create global memory block in memory list
			//

			pMemList = CreateGlobalMemList( 
									pUdBlock, 
									( totalSmps * sizeof(MAD)),
									pSmpBlock,
									TRUE );
		}		// pSmpBlock
	}			// pUdBlock

	if ( ( NULL != pUdBlock ) && \
		 ( NULL != pSmpBlock ) && \
		 ( NULL != pMemList ) )
	{
		_DBG_PRINT(_DBG_LVL_STORE,
			("Total : requested(x%x), allocated(x%x)\n", \
			NumMads, totalSmps));
		_DBG_PRINT(_DBG_LVL_STORE,
			("Memory: pUdBlock(x%p), pSmpBlock(x%p)\n", \
			_DBG_PTR(pUdBlock), _DBG_PTR(pSmpBlock)));

		//
		// set access level for memory region
		//

		pMemList->AccessControl.AsUINT16 = 0;
		pMemList->AccessControl.s.LocalWrite = 1;

		status = RegisterMemGlobal(
								pMemList->VirtualAddr,
								pMemList->Length,
								pMemList->AccessControl,
								&pMemList->CaMemIndex
								);

		if ( FSUCCESS == status )
		{

			//
			// get pointers
			//

			pSmpBlockCurr = pSmpBlock;
			pSmpBlockPrev = NULL;	// fill in g_Sma->Bin.Tail at end of loop
			

			//
			// update next value
			//

			pSmpBlockNext = pSmpBlockCurr;
			pSmpBlockNext++;

			for ( i=0; i< totalSmps; i++ )
			{

				//
				// update current pointer values
				//

				pSmpBlockCurr->Block.Smp = &pUdBlock->Mad;
				//pSmpBlockCurr->Block.Grh = &pUdBlock->Grh;
				//pSmpBlockCurr->Block.Lrh = &pUdBlock->Lrh;

				pSmpBlockCurr->Block.Prev = pSmpBlockPrev;
				pSmpBlockCurr->Block.Next = pSmpBlockNext;


				//
				// Add Index for mem keys
				//

				pSmpBlockCurr->CaMemIndex = pMemList->CaMemIndex;
		

				//
				// increment pointers
				//

				pSmpBlockPrev = pSmpBlockCurr;
				pSmpBlockCurr = pSmpBlockNext;
				pSmpBlockNext++;
				pUdBlock++;

			}	// i loop


			//
			// Adjust and add to bin
			//

			SpinLockAcquire( &g_Sma->Bin.Lock );

			pSmpBlock->Block.Prev = g_Sma->Bin.Tail;	// first of new
			pSmpBlockPrev->Block.Next = NULL;			// last of new

			if ( NULL == g_Sma->Bin.Head )
			{
				g_Sma->Bin.Head = pSmpBlock;
			}
			else
			{
				g_Sma->Bin.Tail->Block.Next = pSmpBlock;
			}

			g_Sma->Bin.Tail = pSmpBlockPrev;
			g_Sma->Bin.NumBlocks  += totalSmps;
			SpinLockRelease( &g_Sma->Bin.Lock );

			g_Sma->Bin.TotalAllocated += totalSmps;
		}
	}
	else
	{
		
		//
		// errors in allocations.
		//

		_DBG_ERROR((
			"Could not allocate memory for x%x SMPs; tried x%x\n\n", \
			NumMads, totalSmps));
		
		//
		// return module specific errors
		//

		status = FINSUFFICIENT_MEMORY;
	}

	if (status != FSUCCESS)
	{

		//
		// unwind
		//

		if ( NULL != pMemList )
		{
			g_Sma->Bin.MemList = (GLOBAL_MEM_LIST*)pMemList->Next;
			MemoryDeallocate( pMemList );
		}
		if ( NULL != pSmpBlock )
			MemoryDeallocate( pSmpBlock );
		if ( NULL != pUdBlock )
			MemoryDeallocate( pUdBlock );

	}
	
	if (! HoldingMutex)
		MutexRelease( &g_Sma->Bin.Mutex );
	
	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
	return status;

}




//
// SmaRemoveFromBin
//
// Note:
//	Lock taken by caller
//
//
//
// INPUTS:
//
//
//
// OUTPUTS:
//
//
// RETURNS:
//
//
//
//

#if 0 // not yet implemented, if'def out so get errors if anyone tried to use
FSTATUS
SmaRemoveFromBin(void)
{
	FSTATUS				status = FSUCCESS;
	
	_DBG_ENTER_LVL(_DBG_LVL_STORE, SmaRemoveFromBin);
	

	//
	// SpinLockDestroy( g_Sma->Lock);
	//

	
	
	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
	return status;

}
#endif




//
// SmaCreateCaMemIndex
//
//	Creates new entries in MAD pool. The number of new entries is specified
//	as input.
//	The functions adds the an average of the total number of MADs specified.
//	The average is derived from a stored value that may be set at install
//	time.
//
//	In addition to the MAD buffer that is created in pool, a header is also
//	allocated that will hold the transport header like the GRH and the 
//	data transfer values for send/recevies.
//
// Note:
//	Lock taken by caller
//
//
//
// INPUTS:
//
//	NumMads				-Number of MADs buffers to create(in MAD sizes) 
//
//
// OUTPUTS:
//
//
// RETURNS:
//
//
//
//
//
// Memory functions to Store, Get and delete registered memory info
//
// caller cannot hold g_Sma->Bin.Lock
void
SmaCreateCaMemIndex(
	IN	SMA_CA_OBJ_PRIVATE	*CaObj,
	OUT	uint32				*CaMemIndex
	)
{	
	CA_MEM_TABLE			*pCaMemTbl;


	_DBG_ENTER_LVL(_DBG_LVL_STORE, SmaCreateCaMemIndex);
	
	if (CaObj)
		pCaMemTbl = CaObj->CaMemTbl;
	else
		pCaMemTbl = NULL;


	SpinLockAcquire( &g_Sma->Bin.Lock );

	//
	// Allocate Index from global entry
	//

	*CaMemIndex = g_Sma->Bin.CurrentIndex++;
	
	//_DBG_PRINT(_DBG_LVL_STORE,("MemIndex = x%x\n",*CaMemIndex));

	//
	// Is an Index available in table ?
	//

	if ( NULL !=	pCaMemTbl )
	{
		
		//
		// If index is from the middle, scan for new index
		//

		while (0 != pCaMemTbl->MemBlock[g_Sma->Bin.CurrentIndex].LKey)
		{
			g_Sma->Bin.CurrentIndex++;

			//
			// TBD:need logic here to scan from start
			//

			//
			// if the index is greater than what it can hold, a table 
			// will subsiquently be created
			//
			// if we have reached out, break
			//

			if ( g_Sma->Bin.CurrentIndex > pCaMemTbl->Total )	
				break;
		}
	}
	SpinLockRelease( &g_Sma->Bin.Lock );

	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
}

// caller cannot hold g_Sma->Bin.Lock
void
SmaDeleteCaMemIndex( 
	IN	uint32					CaMemIndex 
	)
{
	SpinLockAcquire( &g_Sma->Bin.Lock );

	if ( g_Sma->Bin.CurrentIndex > CaMemIndex )
		g_Sma->Bin.CurrentIndex = CaMemIndex;	

	SpinLockRelease( &g_Sma->Bin.Lock );
}


FSTATUS
SmaAddToCaMemTable(
	IN	SMA_CA_OBJ_PRIVATE	*CaObj,
	IN	CA_MEM_LIST			*CaMemList,
	IN	uint32				CaMemIndex
	)
{	
	FSTATUS					status = FSUCCESS;
	CA_MEM_TABLE			*pCaMemTbl, *pNewCaMemTbl;
	uint32					memSize;
	boolean					newTable=FALSE;


	_DBG_ENTER_LVL(_DBG_LVL_STORE, SmaAddToCaMemTable);
	
	pCaMemTbl = CaObj->CaMemTbl;

	_DBG_PRINT(_DBG_LVL_STORE,(\
		"Index = x%x \n",
		CaMemIndex));

	//
	// do we need a new table ?
	//

	if (( NULL != pCaMemTbl ) && ( CaMemIndex > pCaMemTbl->Total ))
		newTable = TRUE;


	//
	// Allocate table if it does not exist or if too small
	//

	if (( NULL == pCaMemTbl ) || ( TRUE == newTable ))
	{

		//
		// calculate amount of memory needed
		//

		memSize = g_Settings.MemTableSize;
		if (TRUE == newTable)
		{
			memSize = (CaMemIndex + 1) * sizeof(CA_MEM_BLOCK);

			//
			// adjust in page sizes set in global settings
			//

			memSize += ((CaMemIndex + 1) * sizeof(CA_MEM_BLOCK) % \
				g_Settings.MemTableSize );
		}

		pNewCaMemTbl = (CA_MEM_TABLE*)MemoryAllocateAndClear(memSize, FALSE, SMA_MEM_TAG);
		if ( NULL != pNewCaMemTbl )
		{
			if (TRUE == newTable)
			{

				//
				// copy old entries
				//

				MemoryCopy(
					&pNewCaMemTbl->MemBlock[0], 
					&pCaMemTbl->MemBlock[0], 
					pCaMemTbl->Total*sizeof(CA_MEM_BLOCK) 
					);
				

				//
				// free old table
				//

				MemoryDeallocate( pCaMemTbl );
			}


			//
			// write down total entries
			//

			pNewCaMemTbl->Total = (memSize)/sizeof(CA_MEM_BLOCK) - 1;

			
			//
			// reassign pointers
			//

			pCaMemTbl = pNewCaMemTbl;		
			CaObj->CaMemTbl = pCaMemTbl;
		}
		else
		{
			status = FERROR;
		}
	}
	
	if ( FSUCCESS == status )
	{

		//
		// ASSERT on out of table experience
		//

		pCaMemTbl->MemBlock[CaMemIndex].MrHandle = CaMemList->MrHandle;
		pCaMemTbl->MemBlock[CaMemIndex].LKey = CaMemList->LKey;
		//pCaMemTbl->MemBlock[CaMemIndex].RKey = CaMemList->RKey;
	}

	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
	return status;
}




FSTATUS
GetMemInfoFromCaMemTable(
	IN	SMA_CA_OBJ_PRIVATE	*CaObj,
	IN	uint32				CaMemIndex,
	OUT	CA_MEM_LIST			*CaMemList
	)
{	
	FSTATUS					status = FSUCCESS;
	CA_MEM_TABLE			*pCaMemTbl;


	_DBG_ENTER_LVL(_DBG_LVL_STORE, GetMemInfoFromCaMemTable);
	
	pCaMemTbl = CaObj->CaMemTbl;

	_DBG_PRINT(_DBG_LVL_STORE,(\
		"Index = x%x\n",
		CaMemIndex));

	//
	// Allocate table if it does not exist
	//

	if ( NULL !=	pCaMemTbl )
	{
		CaMemList->MrHandle = pCaMemTbl->MemBlock[CaMemIndex].MrHandle;
		CaMemList->LKey = pCaMemTbl->MemBlock[CaMemIndex].LKey;
//		CaMemList->RKey = pCaMemTbl->MemBlock[CaMemIndex].RKey;
	}
	else
	{
		status = FERROR;
	}

	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
	return status;
}

FSTATUS
DeleteFromCaMemTable(
	IN	SMA_CA_OBJ_PRIVATE	*CaObj,
	IN	uint32				CaMemIndex
   )
{	
	FSTATUS					status = FSUCCESS;
	CA_MEM_TABLE			*pCaMemTbl;


	_DBG_ENTER_LVL(_DBG_LVL_STORE, DeleteFromCaMemTable);
	
	pCaMemTbl = CaObj->CaMemTbl;

	//
	// Allocate table if it does not exist
	//
	if ( NULL !=	pCaMemTbl )
	{
		pCaMemTbl->MemBlock[CaMemIndex].MrHandle = NULL;
		pCaMemTbl->MemBlock[CaMemIndex].LKey = 0;
//		pCaMemTbl->MemBlock[CaMemIndex].RKey = 0;
	}
	else
	{
		status = FERROR;
	}

	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
	return status;
}


//
// Register any registered memory with this CA
// caller cannot hold g_Sma->Bin.Lock
// caller must hold g_Sma->Bin.Mutex
FSTATUS
SmaBindGlobalMem(
	IN	SMA_CA_OBJ_PRIVATE	*CaObj
	)
{
	FSTATUS					status = FSUCCESS;
	GLOBAL_MEM_LIST			*pMemList;
	CA_MEM_LIST				caMemList;


	_DBG_ENTER_LVL(_DBG_LVL_STORE, SmaBindGlobalMem);

	pMemList = g_Sma->Bin.MemList;

	while ( NULL != pMemList )
	{

		status = iba_register_mr( CaObj->CaHandle, pMemList->VirtualAddr,
						pMemList->Length, CaObj->PdHandle,
						pMemList->AccessControl, &caMemList.MrHandle,
						&caMemList.LKey, &caMemList.RKey); 

		// Check returns
		if ( FSUCCESS != status )
		{
			_DBG_ERROR(("Could not register Memory x%p!\n", 
						_DBG_PTR(pMemList->VirtualAddr)));

			//
			// unwind
			//

			while ( NULL != pMemList->Prev )
			{
				pMemList = (GLOBAL_MEM_LIST*)pMemList->Prev;

				GetMemInfoFromCaMemTable(
						CaObj,
						pMemList->CaMemIndex,
						&caMemList
						);

				iba_deregister_mr(caMemList.MrHandle);

			}


			//
			// remove the memlink
			//

			if ( NULL != CaObj->CaMemTbl )
				MemoryDeallocate( CaObj->CaMemTbl );

			break;
		}
		else
		{
			status = SmaAddToCaMemTable(
							CaObj,
							&caMemList,
							pMemList->CaMemIndex
							);
		}


		//
		// loop thru' all lists
		//

		pMemList = (GLOBAL_MEM_LIST*)pMemList->Next;

	}	// while loop

	_DBG_LEAVE_LVL(_DBG_LVL_STORE);
	return status;

}