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

Copyright (c) 2015-2017, 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 "bmamain.h"

#include "bmadebug.h"

#include "bma_provider.h"

#include "bspcommon/h/usrBootManager.h"

#include "bspcommon/ibml/h/icsApi.h"

//

// Debug params

//

#if ICS_LOGGING

_IB_DBG_PARAM_BLOCK(_DBG_LVL_ALL, _DBG_BREAK_ENABLE, BMA_TAG, "Bma", MOD_BMA, Bma);

#else

_IB_DBG_PARAM_BLOCK((_DBG_LVL_FATAL | _DBG_LVL_ERROR), _DBG_BREAK_ENABLE, BMA_TAG, "Bma");

#endif

//

// Global Info

//

BMA_GLOBAL_INFO  *g_BmaGlobalInfo;

//

// Stored settings

//

BMA_GLOBAL_CONFIG_PARAMETERS	g_BmaSettings = BMA_DEFAULT_SETTINGS;

//

// BmaLoad

//

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

// This routine is to create and initialize the BMA agent global data structures.

//

// INPUTS:

//

//	ComponentInfo - Address of IBT_COMPONENT_INFO that needs to be updated

//	with this driver's specific handlers for add/remove of a channel adapter

//	device as well as the overall driver unload handler.

//

// OUTPUTS:

//

//	None.

//

// RETURNS:

//

//	FSUCCESS - Indicates a successful load.

//

FSTATUS

BmaLoad(

	IN IBT_COMPONENT_INFO		*ComponentInfo

	)

{

	FSTATUS						status = FSUCCESS;

	extern uint32 BmaDbg;

#ifdef IB_TRACE

	extern uint32 BmaTrace;

#endif

	_DBG_ENTER_LVL(_DBG_LVL_MAIN, BMALoad);

	_DBG_INIT;

	__DBG_LEVEL__ = BmaDbg;

#ifdef IB_TRACE

	__DBG_TRACE_LEVEL__ = BmaTrace;

#endif

#if defined(IB_DEBUG) || defined(DBG)

	MsgOut ("Bma:DebugFlags = 0x%8x\n", __DBG_LEVEL__);

#endif

#if defined(VXWORKS)

	_DBG_PRINT(_DBG_LVL_MAIN,  

	(" InfiniBand Baseboard Management Class agent. Built %s %s\n",\

	__DATE__, __TIME__ ));

#else

	_DBG_PRINT(_DBG_LVL_MAIN,  

	(" InfiniBand Baseboard Management Class agent. Built %s %s\n",\

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

#endif

	_TRC_REGISTER();

	//

    // Establish dispatch entry points for the functions supported.

	//

	MemoryClear( ComponentInfo, sizeof(IBT_COMPONENT_INFO) );

	ComponentInfo->AddDevice = BmaAddDevice;

	ComponentInfo->RemoveDevice = BmaRemoveDevice;

	ComponentInfo->Unload = BmaUnload;

	//

    // Read any registry parameters for the driver which may be present.

	//

	//BmaReadRegistryParameters();

	//

    // This function is called to initialize the GSA subsystem. This must be 

	// called only once and if the function does not return success, the 

	// caller must unload the component containing GSA or else not use the 

	// GSA functionality since GSA will not be available.

	//

	// We are being asked to do a one-time initialization. Here we initialize 

	// the list of channel adapters as well as initialize the list of service 

	// classes as well as initialize the spin locks guarding these lists.

	//

	//

	// Allocate space for Global data

	//

	g_BmaGlobalInfo = (BMA_GLOBAL_INFO*)MemoryAllocateAndClear(

									 sizeof(BMA_GLOBAL_INFO), FALSE, BMA_TAG );

	if ( NULL != g_BmaGlobalInfo )

	{

		//

		// initialize global data

		//

		g_BmaGlobalInfo->binitsuccess = FALSE; 

		SpinLockInitState( &g_BmaGlobalInfo->DevListLock );

		if( !SpinLockInit( &g_BmaGlobalInfo->DevListLock ) )

		{

			_DBG_ERROR(( "Unable to initialize spin locks!\n" ));

			status = FINSUFFICIENT_RESOURCES;

			goto fail_lock;

		}

		//

		// Recv Queue and Thread

		//

		CmdThreadInitState(&g_BmaGlobalInfo->RecvThread);

		if ( ! CmdThreadCreate(&g_BmaGlobalInfo->RecvThread,

				THREAD_PRI_HIGH, "Bma", (CMD_THREAD_CALLBACK)BmaThreadCallback,

				(CMD_THREAD_CALLBACK)BmaFreeCallback, (void*)g_BmaGlobalInfo))

		{

			_DBG_ERROR(("BmaMain: Unable to Create RecvThread\n"));

			status = FINSUFFICIENT_RESOURCES;

			goto fail_thread;

		}

		// initialize this general service class manager with GSI

		status = iba_gsi_register_class(MCLASS_BM, 

									IB_BM_CLASS_VERSION,

									GSI_REGISTER_RESPONDER,	// Register as a Responder

									FALSE,					// No SAR cap needed

									g_BmaGlobalInfo,		// Context

									BmaSendCallback,

									BmaRecvCallback,

									&g_BmaGlobalInfo->GsaHandle);

		if (status != FSUCCESS)

		{

			CmdThreadDestroy(&g_BmaGlobalInfo->RecvThread);

fail_thread:

			SpinLockDestroy( &g_BmaGlobalInfo->DevListLock );

fail_lock:

			MemoryDeallocate(g_BmaGlobalInfo);

			g_BmaGlobalInfo = NULL;

			_DBG_ERROR(("BmaMain: Unable to register with GSA!!! <status %d>\n", status));

			_DBG_LEAVE_EXT(_DBG_LVL_FUNC_TRACE);

			return status;

		}

	}

	else

	{

		status = FINSUFFICIENT_RESOURCES;

		_DBG_PRINT(_DBG_LVL_MAIN,("Not enough memory!\n"));

	}

	_DBG_LEAVE_LVL(_DBG_LVL_MAIN);

    return status;

}

//

// BmaUnload

//

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

//	Also, since their is a single instance of the service for all channel

//	adapters in the system, it will also release resources allocated in the

//	BmaAddDevice function. 

//

// INPUTS:

//

//	None.

//

// OUTPUTS:

//

//	None.

//

// RETURNS:

//

//	None

//

//

void

BmaUnload(void)

{

	_DBG_ENTER_LVL(_DBG_LVL_MAIN, BmaUnload);

	_TRC_UNREGISTER();

	if ( g_BmaGlobalInfo )

	{

		// Destroy the datagram pool

		if ( g_BmaGlobalInfo->DgrmPoolHandle )

			iba_gsi_destroy_dgrm_pool( g_BmaGlobalInfo->DgrmPoolHandle );

		// Deregister this class agent with the GSA	

		if ( g_BmaGlobalInfo->GsaHandle )

			iba_gsi_deregister_class(g_BmaGlobalInfo->GsaHandle);

		//

		// Recv Thread

		//

		CmdThreadDestroy(&g_BmaGlobalInfo->RecvThread);

		//

		// Ca List Members

		//

		while ( g_BmaGlobalInfo->DevList )

		{

			BmaRemoveDevice( g_BmaGlobalInfo->DevList->CaGuid, NULL );

		}

		//

		// Ca List Lock

		//

		SpinLockDestroy( &g_BmaGlobalInfo->DevListLock );

		//

		// Free up global memory

		//

		MemoryDeallocate( g_BmaGlobalInfo );

		g_BmaGlobalInfo = NULL;

	} // if g_BmaGlobalInfo

	_DBG_LEAVE_LVL(_DBG_LVL_MAIN);

}

//////////////////////////////////////////////////////////////////////////

// BmaAddDevice()

//

// This routine is called once for every new device added.

//

// INPUTS:

//		CaGuid - the channel adapters GUID

//

// OUTPUTS:

//

//	None.  Although function is defined to return context value, this

//	value is not set since their is nothing specifically allocated for

//	each new channel adapter, so nothing is done in the BmaRemoveDevice

//	function that needs the context.

//

// RETURNS:

//

//	FSUCCESS - Indicates a successful initialization.

//

//

FSTATUS

BmaAddDevice(

	IN	EUI64			CaGuid,

	OUT void			**Context

	)

{

	FSTATUS			status = FSUCCESS;

	uint32			BufferSize;

	BMA_DEV_INFO	*pDevInfo=NULL;

	_DBG_ENTER_LVL(_DBG_LVL_MAIN, BmaAddDevice);

	ASSERT(g_BmaGlobalInfo);

	if (!g_BmaGlobalInfo->binitsuccess)

	{

		// Create the datagram pool

		BufferSize = sizeof(MAD);

		status = iba_gsi_create_dgrm_pool(g_BmaGlobalInfo->GsaHandle,

								g_BmaSettings.MaxNDgrm,

								1,

								&BufferSize,

								0, //1,

								&g_BmaGlobalInfo->DgrmPoolHandle

								);

		if (status != FSUCCESS)

		{

			// Cleanup

			iba_gsi_deregister_class(g_BmaGlobalInfo->GsaHandle);

			MemoryDeallocate(g_BmaGlobalInfo);

			g_BmaGlobalInfo = NULL;

			_DBG_ERROR(("Unable to create BMA datagram pool!!! <status %d>\n", status));

		}

		else

		{

			g_BmaGlobalInfo->binitsuccess = TRUE;

		}

	}

	if (g_BmaGlobalInfo->binitsuccess)

	{

		pDevInfo = (BMA_DEV_INFO*)MemoryAllocateAndClear(sizeof(BMA_DEV_INFO), FALSE, BMA_TAG );

		if (pDevInfo)

		{

			IB_CA_ATTRIBUTES CaAttributes;

			pDevInfo->CaGuid = CaGuid;

			status = iba_query_ca_by_guid_alloc(CaGuid, &CaAttributes);

			if ( status == FSUCCESS )

			{

				pDevInfo->NumPorts = CaAttributes.Ports;

				pDevInfo->Port = (BMA_PORT_INFO*)

					MemoryAllocateAndClear(sizeof(BMA_PORT_INFO)*pDevInfo->NumPorts, FALSE, BMA_TAG);

				if (pDevInfo->Port)

				{

					IB_PORT_ATTRIBUTES *pPortAttr;

					unsigned i;

					for ( i = 0, pPortAttr = CaAttributes.PortAttributesList;

						  i < pDevInfo->NumPorts;

						  i++, pPortAttr = pPortAttr->Next )

					{

						// Traps disabled by default, Trap settings are all zero

						// BKey, BKeyProtect, BKeyViolations, and BKeyLease all init to zero

						pDevInfo->Port[i].Guid = pPortAttr->GUID;

					}

					MemoryDeallocate(CaAttributes.PortAttributesList);

					// Success, add this CA to the list

					SpinLockAcquire( &g_BmaGlobalInfo->DevListLock );

					pDevInfo->Next = g_BmaGlobalInfo->DevList;

					g_BmaGlobalInfo->DevList = pDevInfo;

					SpinLockRelease( &g_BmaGlobalInfo->DevListLock );

				}

				else

				{

					_DBG_ERROR(("MemAlloc failed for Port List!\n"));

					status = FINSUFFICIENT_MEMORY;

				}

			}

			else

			{

				_DBG_ERROR(("CA Query Failed!\n"));

				MemoryDeallocate(pDevInfo);

			}

		}

		else

		{

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

			status = FINSUFFICIENT_MEMORY;

		}

	}

	_DBG_LEAVE_LVL(_DBG_LVL_MAIN);

	return status;

} // BmaAddDevice()

//////////////////////////////////////////////////////////////////////////

// BmaRemoveDevice()

//

// This routine is called once for every CA device being removed.  Nothing

//	is performed in this function.  All cleanup is performed in the BmaUnload

//	function.

//

// INPUTS:

//		CaGuid - the channel adapters GUID

//		Context - driver defined unique context for this CA

//

// OUTPUTS:

//

//	None.

//

// RETURNS:

//

//	FSUCCESS - Indicates a successful initialization.

//

//

FSTATUS

BmaRemoveDevice(

	IN	EUI64			CaGuid,

	IN void				*Context

	)

{

	FSTATUS			status = FSUCCESS;

	BMA_DEV_INFO	*pDevInfo=NULL;

	_DBG_ENTER_LVL(_DBG_LVL_MAIN, BmaRemoveDevice);

	ASSERT(g_BmaGlobalInfo);

	SpinLockAcquire( &g_BmaGlobalInfo->DevListLock );

	pDevInfo = g_BmaGlobalInfo->DevList;

	if ( g_BmaGlobalInfo->DevList->CaGuid == CaGuid )

	{

		g_BmaGlobalInfo->DevList = pDevInfo->Next;

	}

	else

	{

		while ( pDevInfo->Next )

		{

			if ( pDevInfo->Next->CaGuid == CaGuid )

			{

				BMA_DEV_INFO *Found = pDevInfo->Next;

				pDevInfo->Next = Found->Next;

				pDevInfo = Found;

				break;

			}

			pDevInfo = pDevInfo->Next;

		}

	}

	SpinLockRelease( &g_BmaGlobalInfo->DevListLock );

	if (pDevInfo && pDevInfo->CaGuid == CaGuid)

	{

		MemoryDeallocate( pDevInfo->Port );

		MemoryDeallocate( pDevInfo );

	}

	else

	{

		_DBG_ERROR(("Unable to find Ca with GUID 0x%"PRIx64"\n", CaGuid));

		status = FERROR;

	}

	_DBG_LEAVE_LVL(_DBG_LVL_MAIN);

	return status;

} // BmaRemoveDevice()