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

#include "gsi_params.h"

extern uint32 CmMaxDgrms;

FSTATUS

SmaDeviceReserve(

	IN	SMA_CA_OBJ_PRIVATE		*CaObj

	)

{

	FSTATUS						status				= FSUCCESS;

	IB_CA_ATTRIBUTES			*pCaAttributes		= NULL;

	IB_PORT_ATTRIBUTES			*pPortAttributesList= NULL;

	SMA_PORT_TABLE_PRIV			*pPortTbl			= NULL;

	uint32						qp0CqSize			= 0;

	IB_PORT_ATTRIBUTES			*pTempPortAttributesList;

	IB_QP_ATTRIBUTES_CREATE		qpCreateAttributes;

	IB_QP_ATTRIBUTES_QUERY		qpAttributes;

	uint32						i=0;

	_DBG_ENTER_LVL(_DBG_LVL_DEVICE, DeviceReserve);

	// query the device attributes from VCA

	pCaAttributes = (IB_CA_ATTRIBUTES*)MemoryAllocateAndClear(sizeof(IB_CA_ATTRIBUTES), FALSE, SMA_MEM_TAG);

	if ( !pCaAttributes )

	{

		status = FINSUFFICIENT_MEMORY;

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

		goto failcaalloc;

	}			

	status = iba_query_ca(CaObj->CaHandle, pCaAttributes, NULL/*pContext*/);

	if ( FSUCCESS != status )

	{

		_DBG_ERROR ((

			"iba_query_ca() failed with NULL PortAttribs! :%s\n",

			_DBG_PTR(FSTATUS_MSG (status)) ));

		goto failquery;

	}		

	pPortAttributesList = (IB_PORT_ATTRIBUTES*)MemoryAllocateAndClear(pCaAttributes->PortAttributesListSize, FALSE, SMA_MEM_TAG);

	if ( !pPortAttributesList )

	{

		status = FINSUFFICIENT_MEMORY;

		_DBG_ERROR ((

			"MemAlloc failed for PortAttributesList!\n" ));

		goto failportalloc;

	}		

	_DBG_PRINT (_DBG_LVL_DEVICE,(

		"Processing device CA      :GUID(x%"PRIx64")\n",

		CaObj->CaPublic.CaGuid ));

	// build list and add Port info and tag other requirements

	pCaAttributes->PortAttributesList	= pPortAttributesList;

	pTempPortAttributesList				= pPortAttributesList; 

	status = iba_query_ca(CaObj->CaHandle, pCaAttributes, NULL/*pContext*/);

	if ( FSUCCESS != status )

	{

		_DBG_ERROR ((

				"iba_query_ca() failed for PortAttribs!:%s\n",

				_DBG_PTR(FSTATUS_MSG (status)) ));

		goto failquery2;

	}		

	pPortTbl = (SMA_PORT_TABLE_PRIV*)MemoryAllocateAndClear(sizeof(SMA_PORT_BLOCK_PRIV) * pCaAttributes->Ports, FALSE, SMA_MEM_TAG);

	if ( !pPortTbl )

	{

		status = FINSUFFICIENT_MEMORY;

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

		goto failtblalloc;

	}	

	// Reserve device resources

	// Fill in Ca details

	CaObj->WorkReqId			 = 0;

	CaObj->Partitions			 = pCaAttributes->Partitions;

	CaObj->AddressVectors		 = pCaAttributes->AddressVectors;

	CaObj->CaPublic.Ports		 = pCaAttributes->Ports;

	CaObj->CaPublic.Capabilities = pCaAttributes->Capabilities;

	// add port tables to list

	CaObj->CaPublic.PortTbl 	 = (SMA_PORT_TABLE *)pPortTbl;

	// Allocate PD Resource

	status = iba_alloc_sqp_pd( 

						CaObj->CaHandle,

// BUGBUG - does not account for send buffers allocated by registering Gsa/Smi managers

// CM is likely to be the largest so we account for its Dgrms

// however for SMI and GSI the Recv buffers will not use AVs, so this is

// a reasonable guess

#ifdef BUILD_CM

						g_Settings.MaxSMPs +g_GsaSettings.MaxRecvBuffers

						+ CmMaxDgrms,

#else

						g_Settings.MaxSMPs +g_GsaSettings.MaxRecvBuffers,

#endif

						&CaObj->PdHandle );

	if ( FSUCCESS != status )

	{

		_DBG_ERROR (("AllocatePD() failed! :%s\n",

				_DBG_PTR(FSTATUS_MSG (status)) ));

		goto failpd;

	}	

	// Create One CQ per CA for SMA

	status = iba_create_cq(

						CaObj->CaHandle,

								// CqReqSize

						MIN(pCaAttributes->WorkCompletions,

								(CaObj->CaPublic.Ports	

						 		* (g_Settings.SendQDepth

									 + g_Settings.RecvQDepth))),

						(void *)QPTypeSMI,					// Context

						&CaObj->CqHandle,

						&CaObj->CqSize );

	if ( FSUCCESS != status )

	{

		_DBG_ERROR (( "iba_create_cq for SMA failed! :%s\n",

								_DBG_PTR(FSTATUS_MSG (status)) ));

		goto failcq;

	}

	// Create One CQ per CA for GSA

	status = iba_create_cq(

						CaObj->CaHandle,

								// CqReqSize

						MIN(pCaAttributes->WorkCompletions,

							(CaObj->CaPublic.Ports * (g_GsaSettings.SendQDepth+g_GsaSettings.RecvQDepth))),

						(void *)QPTypeGSI,					// Context

						&CaObj->Qp1CqHandle,

						&CaObj->Qp1CqSize );

	if ( FSUCCESS != status )

	{

		_DBG_ERROR (( "iba_create_cq for GSA failed! :%s\n",

						_DBG_PTR(FSTATUS_MSG (status)) ));

		goto failcq2;

	}

	// Get a Special QP each for SMA and GSA on each port

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

	{

		_DBG_PRINT(_DBG_LVL_DEVICE,(

				"Processing device port(%d) :GUID(x%"PRIx64")\n",

				i+1, 

				pTempPortAttributesList->GUID ));

		// Fill in per Port details

		pPortTbl->PortBlock[i].Public.PortNumber	= (uint8)i+1;

		pPortTbl->PortBlock[i].Public.GUID			= \

				pTempPortAttributesList->GUID;

		pPortTbl->PortBlock[i].Public.NumGIDs		= \

				pTempPortAttributesList->NumGIDs;

		pPortTbl->PortBlock[i].Public.NumPKeys		= \

				pTempPortAttributesList->NumPkeys;

		// fill in default Port state

		pPortTbl->PortBlock[i].Public.State			= \

				pTempPortAttributesList->PortState;

		// set QP attribs for SMA

		qpCreateAttributes.Type				= QPTypeSMI;

		qpCreateAttributes.PDHandle			= CaObj->PdHandle;

		qpCreateAttributes.SendCQHandle		= CaObj->CqHandle;

		qpCreateAttributes.RecvCQHandle		= CaObj->CqHandle;

		qpCreateAttributes.SendQDepth		= 

						MIN(pCaAttributes->WorkReqs, g_Settings.SendQDepth);

		qpCreateAttributes.RecvQDepth		= 

						MIN(pCaAttributes->WorkReqs, g_Settings.RecvQDepth);

		qpCreateAttributes.SendDSListDepth	= 1;

		qpCreateAttributes.RecvDSListDepth	= 2;

		qpCreateAttributes.CompletionFlags	= IB_COMPL_CNTL_SEND;

		status = iba_create_special_qp(

						CaObj->CaHandle,

						pPortTbl->PortBlock[i].Public.GUID,

						&qpCreateAttributes,

						&pPortTbl->PortBlock[i].QpHandle,	// Context

						&pPortTbl->PortBlock[i].QpHandle,

						&qpAttributes );

		if ( FSUCCESS != status )

		{

			_DBG_ERROR ((

					"CreateSpecialQP() failed on port(%d) for SMA :%s!\n",

					i+1,

					_DBG_PTR(FSTATUS_MSG (status)) ));

			goto failsmi;

		}

		// set QP attribs for GSA

		// Note: GSA QP created with fixed settings. Changes 

		//	to QP and CQ size will be done in GSA module if applicable

		qpCreateAttributes.Type				= QPTypeGSI;

		qpCreateAttributes.PDHandle			= CaObj->PdHandle;

		qpCreateAttributes.SendCQHandle		= CaObj->Qp1CqHandle;

		qpCreateAttributes.RecvCQHandle		= CaObj->Qp1CqHandle;

		qpCreateAttributes.RecvDSListDepth	= 2; //pCaAttributes->DSListDepth;

		qpCreateAttributes.SendDSListDepth	= 3; //pCaAttributes->DSListDepth;

		qpCreateAttributes.RecvQDepth		= 

						MIN(pCaAttributes->WorkReqs, g_GsaSettings.RecvQDepth);

		qpCreateAttributes.SendQDepth		= 

						MIN(pCaAttributes->WorkReqs, g_GsaSettings.SendQDepth);

		qpCreateAttributes.CompletionFlags = IB_COMPL_CNTL_SEND;

		status = iba_create_special_qp(

						CaObj->CaHandle,

						pPortTbl->PortBlock[i].Public.GUID,

						&qpCreateAttributes,

						&pPortTbl->PortBlock[i].Qp1Handle,	// Context

						&pPortTbl->PortBlock[i].Qp1Handle,

						&qpAttributes );

		if ( FSUCCESS != status )

		{

			_DBG_ERROR ((

					"CreateSpecialQP() failed on port(%d) for GSA :%s!\n",

					i+1,

					_DBG_PTR(FSTATUS_MSG (status)) ));

			goto failgsi;

		}

		// Spinlock for Qp0 & Qp1

		SpinLockInitState( &pPortTbl->PortBlock[i].Qp0Lock );

		SpinLockInitState( &pPortTbl->PortBlock[i].QpLock );

		if( !SpinLockInit( &pPortTbl->PortBlock[i].Qp0Lock ) )

		{

			_DBG_ERROR(( "Unable to initialize spinlocks for Port(%d)!\n", i+1 ));

			goto faillock0;

		}

		if ( !SpinLockInit( &pPortTbl->PortBlock[i].QpLock ) )

		{

			_DBG_ERROR(( "Unable to initialize spinlocks for Port(%d)!\n", i+1 ));

			goto faillock;

		}

		// update info

		pPortTbl->PortBlock[i].Qp0SendQDepth = \

					qpAttributes.SendQDepth;

		AtomicWrite(&pPortTbl->PortBlock[i].Qp0SendQTop,

					qpAttributes.SendQDepth);

		pPortTbl->PortBlock[i].Qp0RecvQDepth = \

					qpAttributes.RecvQDepth;

		AtomicWrite(&pPortTbl->PortBlock[i].Qp0RecvQTop,

					qpAttributes.RecvQDepth);

		// keep count of All QP depths

		qp0CqSize += pPortTbl->PortBlock[i].Qp0SendQDepth + \

						pPortTbl->PortBlock[i].Qp0RecvQDepth;

		// loop

		pTempPortAttributesList			= pTempPortAttributesList->Next;

	}	// i loop

	// add port tables to list

	CaObj->CaPublic.PortTbl				= (SMA_PORT_TABLE *)pPortTbl;

	// SMA Only: GSA resize of QP and CQ handled in GSA module

	// Resize CQ if necessary

	// Validate CQ size depth with all Qp depths

	_DBG_PRINT (_DBG_LVL_DEVICE, (

				"CqSize: \n"

				"\tStored.......:%d\n"

				"\tCalculated...:%d\n"

				"\tResize.......:%s\n",

				MIN(pCaAttributes->WorkCompletions, g_Settings.MaxCqSize),

				qp0CqSize,

				_DBG_PTR(qp0CqSize < MIN(pCaAttributes->WorkCompletions, g_Settings.MaxCqSize) ? "TRUE":"FALSE") ));

	// Update Cqsize only if we have allocated more than 

	// the h/w can achieve.

	if ( qp0CqSize < MIN(pCaAttributes->WorkCompletions, g_Settings.MaxCqSize))

	{

		status = iba_resize_cq(

					CaObj->CqHandle,

					MIN(pCaAttributes->WorkCompletions, g_Settings.MaxCqSize),

					&CaObj->CqSize );

		if (FSUCCESS != status)

		{

			_DBG_ERROR ((

						"iba_resize_cq() failed for SMA :%s!\n",

						_DBG_PTR(FSTATUS_MSG (status)) ));

			goto failresize;

		}

	}

	MemoryDeallocate ( pPortAttributesList );

	MemoryDeallocate ( pCaAttributes );

done:

	_DBG_LEAVE_LVL(_DBG_LVL_DEVICE);

    return status;

failresize:

	--i;

	SpinLockDestroy( &pPortTbl->PortBlock[i].QpLock );

faillock:

	SpinLockDestroy( &pPortTbl->PortBlock[i].Qp0Lock );

faillock0:

	iba_destroy_qp( pPortTbl->PortBlock[i].Qp1Handle );

failgsi:

	iba_destroy_qp( pPortTbl->PortBlock[i].QpHandle );

failsmi:

	while (i > 0)

	{

		--i;

		SpinLockDestroy( &pPortTbl->PortBlock[i].QpLock );

		SpinLockDestroy( &pPortTbl->PortBlock[i].Qp0Lock );

		iba_destroy_qp( pPortTbl->PortBlock[i].Qp1Handle );

		iba_destroy_qp( pPortTbl->PortBlock[i].QpHandle );

	}

	iba_destroy_cq( CaObj->Qp1CqHandle );

	CaObj->Qp1CqHandle = NULL;

failcq2:

	iba_destroy_cq( CaObj->CqHandle );

	CaObj->CqHandle = NULL;

failcq:

	iba_free_pd( CaObj->PdHandle );

	CaObj->PdHandle = NULL;

failpd:

	MemoryDeallocate ( pPortTbl );

	CaObj->CaPublic.PortTbl = NULL;

failtblalloc:

failquery2:

	MemoryDeallocate ( pPortAttributesList );

failportalloc:

failquery:

	MemoryDeallocate ( pCaAttributes );

failcaalloc:

	goto done;

}

FSTATUS

SmaConfigQp(

	IN	IB_HANDLE				QpHandle,

	IN	IB_QP_STATE				QpState,

	IN	IB_QP_TYPE				QpType

	)

{

	FSTATUS						status = FSUCCESS;

	IB_QP_ATTRIBUTES_MODIFY		qpModAttributes;

	_DBG_ENTER_LVL(_DBG_LVL_DEVICE, SmaConfigQp);

	// set QP attribs based on transition and QpType

	switch (QpState)

	{

	default:

		_DBG_ERROR(("Invalid QP State requested!\n"));

		status = FINVALID_SETTING;

		goto done;

		break;

	case QPStateInit:

		{

			qpModAttributes.RequestState	= QPStateInit;

			qpModAttributes.Attrs = (IB_QP_ATTR_PKEYINDEX

												| IB_QP_ATTR_QKEY);

			qpModAttributes.PkeyIndex = 0;	// BUGBUG not applicable

			if ( QPTypeSMI == QpType )

				qpModAttributes.Qkey = 0;

			else

				qpModAttributes.Qkey = QP1_WELL_KNOWN_Q_KEY;

		}

		break;

	case QPStateReadyToRecv:

		{

			qpModAttributes.RequestState = QPStateReadyToRecv;

			qpModAttributes.Attrs = 0;

		}

		break;

	case QPStateReadyToSend:

		{

			qpModAttributes.RequestState = QPStateReadyToSend;

			qpModAttributes.Attrs = IB_QP_ATTR_SENDPSN;

			qpModAttributes.SendPSN = 0x00000001;

		}

		break;

	}	// switch

	// transition QP states

	status = iba_modify_qp( QpHandle, &qpModAttributes, NULL );

	if ( FSUCCESS != status )

	{

		_DBG_ERROR(("Modify Qp failed!\n"));

	}

done:

	_DBG_LEAVE_LVL(_DBG_LVL_DEVICE);

    return status;

}

FSTATUS

SmaDeviceConfig(

	IN	SMA_CA_OBJ_PRIVATE		*CaObj,

	IN	IB_QP_TYPE				QpType

	)

{

	FSTATUS						status = FSUCCESS;

	SMA_PORT_TABLE_PRIV			*pPortTbl;

	uint32						i;

	_DBG_ENTER_LVL(_DBG_LVL_DEVICE, SmaDeviceConfig);

	pPortTbl = (SMA_PORT_TABLE_PRIV *)CaObj->CaPublic.PortTbl;

	// Loop thru' all QP0's 

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

	{

		// set QP to Init state

		status = SmaConfigQp(

			(( QPTypeSMI == QpType ) ? \

			pPortTbl->PortBlock[i].QpHandle:pPortTbl->PortBlock[i].Qp1Handle),

			QPStateInit,

			QpType );

		if ( FSUCCESS != status )

		{

			_DBG_ERROR((

				"Could not transition QP%s to Init on port %d!\n", 

				_DBG_PTR((( QPTypeSMI == QpType ) ? "0":"1")),

				i+1));

		} else {

			// transition QP states

			// RecvQ to RTR

			status = SmaConfigQp(

						(( QPTypeSMI == QpType ) ? \

						pPortTbl->PortBlock[i].QpHandle : \

						pPortTbl->PortBlock[i].Qp1Handle),

						QPStateReadyToRecv,

						QpType );

			if ( FSUCCESS == status )

			{

				// SendQ to RTS

				status = SmaConfigQp(

							(( QPTypeSMI == QpType ) ? \

							pPortTbl->PortBlock[i].QpHandle : \

							pPortTbl->PortBlock[i].Qp1Handle),

							QPStateReadyToSend,

							QpType );

				if ( FSUCCESS != status )

				{

					// BUGBUG: return module error

					_DBG_ERROR((

						"Error transitioning QP%s on Port[%d] to RTS!\n", 

						_DBG_PTR((( QPTypeSMI == QpType ) ? "0":"1")),

						i+1));

				}

			} else {

				// BUGBUG: return module error

				_DBG_ERROR((

					"Error transitioning QP%s on Port[%d] to RTR!\n", 

					_DBG_PTR((( QPTypeSMI == QpType ) ? "0":"1")),

					i+1));

			}

		}		// modify QP to hold CQ

	}			// for Port loop

	_DBG_LEAVE_LVL(_DBG_LVL_DEVICE);

    return status;

}

FSTATUS

GetAV(

	IN	SMA_CA_OBJ_PRIVATE		*CaObj,

	IN	IB_ADDRESS_VECTOR		*AvInfo,

	OUT	IB_HANDLE				*AvHandle

	)

{

	FSTATUS						status			= FSUCCESS;

	SMA_PORT_TABLE_PRIV			*pPortTbl;

	_DBG_ENTER_LVL(_DBG_LVL_DEVICE, GetAV);

	pPortTbl = (SMA_PORT_TABLE_PRIV *)CaObj->CaPublic.PortTbl;

	// Create AV if one does not exist

	_DBG_PRINT(_DBG_LVL_DEVICE,(

		"AV Info:\n"

		"Local:\n"

		"\tPortGUID.....:x%"PRIx64"\n"

		"\tPathBits.....:x%X\n"

		"\tServiceLevel.:x%X\n"

		"\tStaticRate...:x%X\n"

		"Remote:\n"

		"\tLID..........:x%X\n"

		"\tGlobalRoute..:%s\n",

		AvInfo->PortGUID,

		AvInfo->PathBits,

		AvInfo->ServiceLevel,

		AvInfo->StaticRate,

		AvInfo->DestLID,

		_DBG_PTR(AvInfo->GlobalRoute == TRUE	? "TRUE":"FALSE" )));

	// Add Global Routing Info if present

	if (AvInfo->GlobalRoute)

	{

		_DBG_PRINT(_DBG_LVL_DEVICE,(

			"Global Route Info:\n"

			"\tFlowLabel....:x%X\n"

			"\tHopLimit.....:x%X\n"

			"\tSrcGIDIndex..:x%X\n"

			"\tTrafficClass.:x%X\n",

			AvInfo->GlobalRouteInfo.FlowLabel,

			AvInfo->GlobalRouteInfo.HopLimit,

			AvInfo->GlobalRouteInfo.SrcGIDIndex,

			AvInfo->GlobalRouteInfo.TrafficClass ));

	}

	status = iba_create_av( CaObj->CaHandle, CaObj->PdHandle, AvInfo, AvHandle);

	_DBG_LEAVE_LVL(_DBG_LVL_DEVICE);

    return status;

}

FSTATUS

PutAV(

	IN	SMA_CA_OBJ_PRIVATE		*CaObj,

	IN	IB_HANDLE				AvHandle

	)

{

	FSTATUS						status = FSUCCESS;

	_DBG_ENTER_LVL(_DBG_LVL_DEVICE, PutAV);

	// Destroy AV or cache it

	status = iba_destroy_av( AvHandle );

	_DBG_LEAVE_LVL (_DBG_LVL_DEVICE);

    return status;

}

void

NotifyIbtCallback (

	IN	void				*Context

	)

{

	SMA_CA_OBJ_PRIVATE		*pCaObj;

	SMA_PORT_TABLE_PRIV		*pPortTbl;

	SMA_PORT_BLOCK_PRIV		*pPortBlock;

	uint32					j;

	_DBG_ENTER_LVL(_DBG_LVL_DEVICE, NotifyIbtCallback);

	// Scan through all CA's

	SpinLockAcquire(&g_Sma->CaListLock);

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

	{

		boolean exists;

		pCaObj->UseCount++;

		SpinLockRelease(&g_Sma->CaListLock);

		exists = IbtNotifyUserEvent( Context,

								pCaObj->CaPublic.CaGuid, // Port/Node GUID

								IB_NOTIFY_CA_ADD );

		if (! exists)

			goto release;

		// Now notify about port events too

		pPortTbl = (SMA_PORT_TABLE_PRIV *)pCaObj->CaPublic.PortTbl;

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

		{

			pPortBlock = &pPortTbl->PortBlock[j];

			if ( IB_PORT_ACTIVE == pPortBlock->Public.State )

			{

				exists = IbtNotifyUserEvent( Context,

								pPortBlock->Public.GUID,// Port/Node GUID

								IB_NOTIFY_LID_EVENT );

				if (! exists)

					goto release;

			}

		}

		SpinLockAcquire(&g_Sma->CaListLock);

		pCaObj->UseCount--;

	}

done:

	SpinLockRelease(&g_Sma->CaListLock);

	_DBG_LEAVE_LVL (_DBG_LVL_DEVICE);

	return;

release:

	SpinLockAcquire(&g_Sma->CaListLock);

	pCaObj->UseCount--;

	goto done;

}

void

SetClassMask (

	IN	uint8				Class,

	IN	boolean				Enabled

	)

{

	switch (Class)

	{

	case MCLASS_COMM_MGT:

		if ( TRUE == Enabled )

			g_Sma->IsConnectionManagementSupported = 1;

		else

			g_Sma->IsConnectionManagementSupported = 0;

		break;

#if 0

	case MCLASS_SNMP:

		if ( TRUE == Enabled )

			g_Sma->IsSNMPTunnelingSupported = 1;

		else

			g_Sma->IsSNMPTunnelingSupported = 0;

		break;

	case MCLASS_DEV_MGT:

		if ( TRUE == Enabled )

			g_Sma->IsDeviceManagementSupported = 1;

		else

			g_Sma->IsDeviceManagementSupported = 0;

		break;

#endif

	//

	// TBD:

	// Must handle vendor Classes here

	//case MCLASS_X:

	//

	default:

		_DBG_PRINT(_DBG_LVL_DEVICE,(

			"No capabilities for this Class [x%X]\n", 

			Class ));

	}

}

void

SetPortCapabilities ( void )

{

	SMA_CA_OBJ_PRIVATE		*pCaObj;

	FSTATUS					status;

	SMA_PORT_TABLE_PRIV		*pPortTbl;

	SMA_PORT_BLOCK_PRIV		*pPortBlock;

	STL_SMP					*pSmp;

	STL_PORT_INFO			*pPortInfo;

	uint32					j;

	uint8					portNo;

	uint32					smps;

	POOL_DATA_BLOCK			*pSmpBlock;

	_DBG_ENTER_LVL (_DBG_LVL_DEVICE, SetPortCapabilities);

	for ( ;; )

	{

		smps		= 1;

		pSmpBlock	= NULL;

		status = iba_smi_pool_get(

					NULL,

					&smps,			

					(SMP_BLOCK **)&pSmpBlock );

		if ( (FSUCCESS != status) || (pSmpBlock == NULL) )

		{

			_DBG_ERROR ((

					"Could not Grab from Pool!\n" ));

			break;

		}

		pSmp		= (STL_SMP*)pSmpBlock->Block.Smp;

		pPortInfo	= (STL_PORT_INFO*)pSmp->SmpExt.DirectedRoute.SMPData;

		// Scan through all CA's

		SpinLockAcquire(&g_Sma->CaListLock);

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

		{

			uint32	capMaskUpdate=0;

			uint32	MadQueryLength;

			pCaObj->UseCount++;

			SpinLockRelease(&g_Sma->CaListLock);

			// Set each port

			pPortTbl = (SMA_PORT_TABLE_PRIV *)pCaObj->CaPublic.PortTbl;

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

			{

				pPortBlock							= &pPortTbl->PortBlock[j];

				portNo								= (uint8)j;	// switch port zero

				// Format MAD get PortInfo

				pSmp->common.BaseVersion				= STL_BASE_VERSION;

				pSmp->common.ClassVersion				= STL_SM_CLASS_VERSION;

				pSmp->common.mr.AsReg8				= 0;

				pSmp->common.mr.s.Method				= MMTHD_GET;

				pSmp->SmpExt.DirectedRoute.DrDLID	= STL_LID_PERMISSIVE;

				pSmp->SmpExt.DirectedRoute.DrSLID	= STL_LID_PERMISSIVE;

				pSmp->common.u.DR.s.Status		= 0;

				pSmp->common.u.DR.s.D			= 0;

				pSmp->common.u.DR.HopCount		= 0;

				pSmp->common.u.DR.HopPointer	= 0;

				//pSmp->common.TransactionID	= 0;

				pSmp->common.MgmtClass			= MCLASS_SM_DIRECTED_ROUTE;

				pSmp->common.AttributeID		= STL_MCLASS_ATTRIB_ID_PORT_INFO;

				pSmp->common.AttributeModifier	= 0x01000000 | portNo;

				STL_SMP_SET_LOCAL(pSmp);		// local request

				MadQueryLength = sizeof(*pSmp) - STL_MAX_PAYLOAD_SMP_DR;

				status = iba_get_set_mad( pPortBlock->QpHandle, portNo,

									0, // SLID ignored, local request

									pSmp,

									&MadQueryLength );

				if ( FSUCCESS != status )

				{

					_DBG_ERROR ((

						"Could not GET Port capabilities!\n" ));

					break;

				}

				// SWAP THE GETPORTINFO response

				BSWAP_STL_PORT_INFO(pPortInfo);

				ZERO_RSVD_STL_PORT_INFO(pPortInfo);

				// Set capability if necessary

				if (g_Sma->IsConnectionManagementSupported && !pPortInfo->CapabilityMask.s.IsConnectionManagementSupported) {

					pPortInfo->CapabilityMask.s.IsConnectionManagementSupported = \

						g_Sma->IsConnectionManagementSupported;

					capMaskUpdate = 1;

				}

				if (g_Sma->IsDeviceManagementSupported && !pPortInfo->CapabilityMask.s.IsDeviceManagementSupported) {

					pPortInfo->CapabilityMask.s.IsDeviceManagementSupported = \

						g_Sma->IsDeviceManagementSupported;

					capMaskUpdate = 1;

				}

				if (!capMaskUpdate)

					break;				// nothing to change

				// Do not change other fields

				pPortInfo->LinkWidth.Enabled = STL_LINK_WIDTH_NOP;

				pPortInfo->PortStates.s.PortState = IB_PORT_NOP;

				pPortInfo->PortStates.s.PortPhysicalState = IB_PORT_PHYS_NOP;

				pPortInfo->s4.OperationalVL = 0;

				pPortInfo->LinkSpeed.Enabled = IB_LINK_SPEED_NOP;

				// SWAP THE SET PORT INFO payload

				BSWAP_STL_PORT_INFO(pPortInfo);

				// Set base MAD info

				pSmp->common.BaseVersion				= STL_BASE_VERSION;

				pSmp->common.ClassVersion				= STL_SM_CLASS_VERSION;

				pSmp->common.mr.AsReg8				= 0;

				pSmp->common.mr.s.Method			= MMTHD_SET;

				pSmp->SmpExt.DirectedRoute.DrDLID	= STL_LID_PERMISSIVE;

				pSmp->SmpExt.DirectedRoute.DrSLID	= STL_LID_PERMISSIVE;

				pSmp->common.u.DR.s.Status		= 0;

				pSmp->common.u.DR.s.D			= 0;

				pSmp->common.u.DR.HopCount		= 0;

				pSmp->common.u.DR.HopPointer	= 0;

				//pSmp->common.TransactionID	= 0;

				pSmp->common.MgmtClass			= MCLASS_SM_DIRECTED_ROUTE;

				pSmp->common.AttributeID		= STL_MCLASS_ATTRIB_ID_PORT_INFO;

				pSmp->common.AttributeModifier	= 0x01000000 | portNo;

				STL_SMP_SET_LOCAL(pSmp);		// local request

				MadQueryLength = sizeof(*pSmp) - STL_MAX_PAYLOAD_SMP_DR + sizeof(*pPortInfo);

				status = iba_get_set_mad( pPortBlock->QpHandle, portNo,

										0, // SLID ignored, local request

										pSmp,

										&MadQueryLength );

				if ( FSUCCESS != status )

					break;

 			}	// loop j - ports

			SpinLockAcquire(&g_Sma->CaListLock);

			pCaObj->UseCount--;

			if ( FSUCCESS != status )

				break;

		}		// loop - CA's

		SpinLockRelease(&g_Sma->CaListLock);

		status = iba_smi_pool_put( NULL, (SMP_BLOCK *)pSmpBlock );

		break;

	}

	_DBG_LEAVE_LVL (_DBG_LVL_DEVICE);

}

void

SetPortCapabilityMask (

	IN	uint8				Class,

	IN	boolean				Enabled

	)

{

	_DBG_ENTER_LVL (_DBG_LVL_DEVICE, SetPortCapabilityMask );

	// Check init state of drivers

	SetClassMask ( Class, Enabled );

	if ( g_Sma->NumCa )

	{

		SetPortCapabilities ();

	} else {

		_DBG_PRINT (_DBG_LVL_DEVICE, (

			"No devices present. Caching capabilities for an Add Device\n" ));

	}

	_DBG_LEAVE_LVL (_DBG_LVL_DEVICE);

}