/* 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"

// Globals

// Debug params

#ifdef ICS_LOGGING

_IB_DBG_PARAM_BLOCK((_DBG_LVL_FATAL|_DBG_LVL_ERROR), _DBG_BREAK_ENABLE, SMA_MEM_TAG, "Sma", MOD_SMA, Sma);

#else

_IB_DBG_PARAM_BLOCK((_DBG_LVL_FATAL|_DBG_LVL_ERROR), _DBG_BREAK_ENABLE, SMA_MEM_TAG, "Sma");

#endif

// Global Info

SMA_GLOBAL_INFO	*g_Sma;

// Stored settings

SMA_STORED_SETTINGS g_Settings = DEFAULT_SMA_SETTINGS;

//

// SmaLoad

//

// This routine is called by the VCA Init when the driver is first loaded. 

// This routine is to create and initialize driver data structures.

//

// INPUTS:

//

//	ComponentInfo - Pointer to ComponentInfo that is OS specific

//

// OUTPUTS:

//

//	None.

//

// RETURNS:

//

//	FSUCCESS - Indicates a successful load.

//

// IRQL:

//

//	This routine is called at IRQL_PASSIVE_LEVEL.

//

FSTATUS

SMALoad(

	IN IBT_COMPONENT_INFO	 *ComponentInfo

	)

{

	FSTATUS				status = FSUCCESS;

	_DBG_ENTER_LVL(_DBG_LVL_MAIN, SmaLoad);

	_DBG_INIT;

	_TRC_REGISTER();

#if !defined(VXWORKS)

	_DBG_PRINT(_DBG_LVL_MAIN,  

	(" InfiniBand Subnet Management Agent. Built %s %s\n",\

	__DATE__, __TIME__ ));

#else

	_DBG_PRINT(_DBG_LVL_MAIN,  

	(" InfiniBand Subnet Management Agent. Built %s %s\n",\

	_DBG_PTR(__DATE__), _DBG_PTR(__TIME__) ));

#endif

    // Establish dispatch entry points for the functions supported.

	MemoryClear( ComponentInfo, sizeof(IBT_COMPONENT_INFO) );

	ComponentInfo->AddDevice = SmaAddDevice;

	ComponentInfo->RemoveDevice = SmaRemoveDevice;

	ComponentInfo->Unload = SMAUnload;

    // Read Global settings for the driver which may be set in a 

	// OS specific way.

	SmaInitGlobalSettings();

	// Allocate space for Global data

	g_Sma = (SMA_GLOBAL_INFO*)MemoryAllocate2AndClear(sizeof(SMA_GLOBAL_INFO), IBA_MEM_FLAG_PREMPTABLE, SMA_MEM_TAG);

	if ( NULL == g_Sma )

	{

		_DBG_ERROR(("MemAlloc failed for g_Sma!\n"));

		goto done;

	}

	// initialize global data

	g_Sma->NumCa = 0;

	g_Sma->CaObj = NULL;

	g_Sma->WorkReqRecv = g_Sma->WorkReqSend = NULL;

	g_Sma->SmUserTbl = NULL;

	g_Sma->NumUser = 0;

	// SpinLockInitState( &g_Sma->Lock )

	// SpinLockInit( &g_Sma->Lock )

	// Init Storage area for MADs

	g_Sma->Bin.NumBlocks = 0;

	g_Sma->Bin.Head = g_Sma->Bin.Tail = NULL;

	g_Sma->Bin.MemList = NULL;

	g_Sma->Bin.CurrentIndex = 0;			// set start mem index

	// Locks

	SpinLockInitState( &g_Sma->CaListLock );

	SpinLockInit( &g_Sma->CaListLock );

	SpinLockInitState( &g_Sma->Bin.Lock );

	SpinLockInit( &g_Sma->Bin.Lock );

	MutexInitState( &g_Sma->Bin.Mutex );

	MutexInit( &g_Sma->Bin.Mutex );

	SpinLockInitState( &g_Sma->RQ.Lock );

	SpinLockInit( &g_Sma->RQ.Lock );

	// Init Global Ibt user group for notifications

	IbtInitNotifyGroup(NotifyIbtCallback);

	// Allocate memory for Global GRH since the SMA does not need a GRH.

	// This memory will automatically get mapped to all CA registrations.

	g_Sma->GlobalGrh = CreateGlobalMemList( 0, sizeof(IB_GRH), 0, FALSE );

	if ( NULL == g_Sma->GlobalGrh )

	{

		status = FINSUFFICIENT_RESOURCES;

		goto failmemlist;

	}

	g_Sma->GlobalGrh->VirtualAddr = MemoryAllocate2AndClear(sizeof(IB_GRH), IBA_MEM_FLAG_PREMPTABLE, SMA_MEM_TAG);

	if ( NULL == g_Sma->GlobalGrh->VirtualAddr )

	{

		status = FINSUFFICIENT_RESOURCES;

		goto failgrhvirt;

	}

	g_Sma->GlobalGrh->AccessControl.AsUINT16 = 0;

	g_Sma->GlobalGrh->AccessControl.s.LocalWrite = 1;

	g_Sma->GlobalGrh->CaMemIndex = 0;

	// Increment index for future allocations

	g_Sma->Bin.CurrentIndex++;

done:

	_DBG_LEAVE_LVL(_DBG_LVL_MAIN);

    return status;

failgrhvirt:

	MemoryDeallocate( g_Sma->GlobalGrh );

failmemlist:

	IbtDestroyNotifyGroup();

	SpinLockDestroy( &g_Sma->RQ.Lock );

	MutexDestroy( &g_Sma->Bin.Mutex );

	SpinLockDestroy( &g_Sma->Bin.Lock );

	SpinLockDestroy( &g_Sma->CaListLock );

	MemoryDeallocate( g_Sma );

	goto done;

}

//

// SmaUnload

//

//	This routine should release resources allocated in the SmaLoad function. 

//

// INPUTS:

//

//	None.

//

// OUTPUTS:

//

//	None.

//

// RETURNS:

//

//	FSUCCESS - Successful unload of SMA.

//

//	This routine is called at IRQL_PASSIVE_LEVEL.

//

void

SMAUnload(void)

{

	GLOBAL_MEM_LIST		*pMemList;

	_DBG_ENTER_LVL(_DBG_LVL_MAIN, SmaUnload);

	// there should be no CAs at this point, all VPD must be unloaded

	// before IbAccess

	ASSERT(0 == g_Sma->NumCa);

	ASSERT(NULL == g_Sma->CaObj);

	// Free up global memory

	//

	//Note: Global Grh gets freed automatically here

	for (pMemList = g_Sma->Bin.MemList; NULL != pMemList; )

	{

		GLOBAL_MEM_LIST	*pMemListNext;

		pMemListNext = (GLOBAL_MEM_LIST*)pMemList->Next;

		MemoryDeallocate( pMemList->VirtualAddr );	// registered SMP emm

		if (pMemList->HdrAddr )

			MemoryDeallocate( pMemList->HdrAddr );	// SmpBlock memory

		MemoryDeallocate( pMemList );

		pMemList = pMemListNext;

	}

	_TRC_UNREGISTER();

	// Remove user list

	if ( NULL != g_Sma->SmUserTbl )

		MemoryDeallocate( g_Sma->SmUserTbl );

	IbtDestroyNotifyGroup();

	// Locks

	MutexDestroy( &g_Sma->Bin.Mutex );

	SpinLockDestroy( &g_Sma->Bin.Lock );

	SpinLockDestroy( &g_Sma->RQ.Lock );

	SpinLockDestroy( &g_Sma->CaListLock );

	MemoryDeallocate( g_Sma );

	_DBG_LEAVE_LVL(_DBG_LVL_MAIN);

}

//

// SmaAddDevice

//

// This routine is called by the VCA Startdevice loop for all driver libs. 

// The CA device that just started will be identified by its GUID.

//

// INPUTS:

//

//	CaGUID - GUID to the CA that was added and started.

//

// OUTPUTS:

//

//	None

//

// RETURNS:

//

//	FSTATUS.

//

// IRQL:

//

//	This routine is called at IRQL_PASSIVE_LEVEL.

//

FSTATUS

SmaAddDevice(

	IN	EUI64			CaGuid,

	OUT void			**Context

	)

{

	FSTATUS				status = FSUCCESS;

	SMA_CA_OBJ_PRIVATE	*pCaObj=NULL;

	uint32				i;

	_DBG_ENTER_LVL(_DBG_LVL_MAIN, SmaAddDevice);

	pCaObj = (SMA_CA_OBJ_PRIVATE*)MemoryAllocateAndClear(sizeof(SMA_CA_OBJ_PRIVATE), FALSE, SMA_MEM_TAG);

	if ( NULL == pCaObj ) 

	{

		_DBG_ERROR(("MemAlloc failed for pCaObj/WorkReq!\n"));

		status = FINSUFFICIENT_MEMORY;

		goto done;

	}

	pCaObj->CaPublic.CaGuid = CaGuid;

	pCaObj->CaPublic.SmaCaContext = pCaObj;

	EventThreadInitState(&pCaObj->SmaEventThread);

	if (! EventThreadCreate(&pCaObj->SmaEventThread, "Smi",

		THREAD_PRI_VERY_HIGH, SmaCompletionCallback, pCaObj))

	{

		_DBG_ERROR(("Sma Event Thread Create FAILED\n"));

		goto failsmathread;

	}

	EventThreadInitState(&pCaObj->GsaEventThread);

	if (! EventThreadCreate(&pCaObj->GsaEventThread, "Gsi",

		THREAD_PRI_VERY_HIGH, GsaCompletionThreadCallback, pCaObj))

	{

		_DBG_ERROR(("Gsa Event Thread Create FAILED\n"));

		goto failgsathread;

	}

	status = iba_open_ca( CaGuid, SmaGsaCompletionCallback,

				SmaAsyncEventCallback, pCaObj/*Context*/, &pCaObj->CaHandle);

	if ( FSUCCESS != status )

	{

		_DBG_ERROR(("OpenCA() failed!\n"));

		goto failopen;

	}

	status = SetCAInternal(pCaObj->CaHandle);

	if ( FSUCCESS != status )

	{

		_DBG_ERROR(("SetCAInternal() failed!\n"));

		goto failinternal;

	}

	// Reserve CQ/QP/PD...

	status = SmaDeviceReserve( pCaObj );

	if ( FSUCCESS != status )

	{

		goto failreserve;

	}

	// we hold the Mutex across Bind and addition to Ca list

	// so that CreateDgrmPool cannot race and cause double

	// registration of memory in new DgrmPool

	AcquireMemListMutex();

	status = SmaBindGlobalMem( pCaObj );

	if (status != FSUCCESS)

	{

		ReleaseMemListMutex();

		// TBD need to undo SmaDeviceReserve

		goto failreserve;

	}

	// lock

	// update global info

	SpinLockAcquire(&g_Sma->CaListLock);

	g_Sma->NumCa++;

	pCaObj->Next = g_Sma->CaObj;

	pCaObj->Prev = NULL;

	if ( NULL != g_Sma->CaObj )

		g_Sma->CaObj->Prev = pCaObj;

	g_Sma->CaObj = pCaObj;

	pCaObj->UseCount++;	// hold reference so we can use object below

	SpinLockRelease(&g_Sma->CaListLock);

	ReleaseMemListMutex();

	// QPConfig 

	status = SmaDeviceConfig( pCaObj, QPTypeSMI );

	status = SmaDeviceConfig( pCaObj, QPTypeGSI );

	// Create GSA data structures

	GsaUpdateCaList();

	// Preallocate Buffers based on per device.

	// If we know the amount of buffers we need per device and go ahead

	// and allocate them in advance, subnet sweeps will not allocate

	// any buffers in the speed path

	//

	// NOTE: This call can fail if there are no system resources

	SmaAllocToBin( g_Settings.PreAllocSMPsPerDevice, FALSE );

	// post some descriptors on recv side if port is up or something...

	for (i=0; i<pCaObj->CaPublic.Ports; i++)

	{

		status = iba_smi_post_recv( NULL, pCaObj, (uint8)(i+1), 

							g_Settings.MinSMPsToPostPerPort );	

	}

	// Set Port capabilities across all CA's

	SetPortCapabilities();

	// Rearm CQ to receive event notifications.

	// The next Work Completion written to the CQ 

	// will generate an event

	status = iba_rearm_cq( pCaObj->CqHandle, CQEventSelNextWC);						

	SpinLockAcquire(&g_Sma->CaListLock);

	pCaObj->UseCount--;

	SpinLockRelease(&g_Sma->CaListLock);

	// Bind 

	// unlock

	// notify users through callbacks!

	IbtNotifyGroup( CaGuid, IB_NOTIFY_CA_ADD );

	// TBD - failure above causes bad status return here, can confuse caller

	// also does not cleanup QPs, CQ, PD, MRs, buffers

	// SmaRemoveCaObj might solve, but not clear if safe to call it

	// need some peers to the SmaDeviceReserve and SmaDeviceConfig routines

	// to undo their effects

done:

	_DBG_LEAVE_LVL(_DBG_LVL_MAIN);

    return status;

failreserve:

failinternal:

	iba_close_ca( pCaObj->CaHandle );

failopen:

	EventThreadDestroy(&pCaObj->GsaEventThread);

failgsathread:

	EventThreadDestroy(&pCaObj->SmaEventThread);

failsmathread:

	MemoryDeallocate( pCaObj );

	goto done;

}

//

// SmaRemoveDevice

//

// This routine is called by the VCA Removedevice loop for all driver libs. 

// The CA device that was removed will be identified by its GUID.

//

// INPUTS:

//

//	CaGUID - GUID to the CA that was added and started.

//

// OUTPUTS:

//

//	None.

//

// RETURNS:

//

//	FSTATUS.

//

// IRQL:

//

//	This routine is called at IRQL_PASSIVE_LEVEL.

//

FSTATUS

SmaRemoveDevice(

		IN EUI64	CaGuid,

		IN void		*Context

		)

{

	FSTATUS				status = FSUCCESS;

	SMA_CA_OBJ_PRIVATE	*pCaObj;

	_DBG_ENTER_LVL(_DBG_LVL_MAIN, SmaRemoveDevice);

	// notify users through callbacks

	// SM should stop access to all registered memory on this Ca

	IbtNotifyGroup( CaGuid, IB_NOTIFY_CA_REMOVE );

	// lock

	// find CaObj

	SpinLockAcquire(&g_Sma->CaListLock);

	for (pCaObj = g_Sma->CaObj; NULL != pCaObj; pCaObj = pCaObj->Next)

	{

		if ( CaGuid == pCaObj->CaPublic.CaGuid )

			break;

	}

	if ( NULL != pCaObj )

	{

		pCaObj->UseCount++;

		SpinLockRelease(&g_Sma->CaListLock);

		status = SmaRemoveCaObj( pCaObj );	// will release reference to pCaObj

	} else {

		SpinLockRelease(&g_Sma->CaListLock);

		_DBG_ERROR(("Could not find CA device!\n"));

	}

	// Rebuild CA list for GSA

	GsaUpdateCaList();

	// unlock

	_DBG_LEAVE_LVL(_DBG_LVL_MAIN);

    return status;

}