mirror of
https://github.com/opnsense/src.git
synced 2026-04-15 14:29:58 -04:00
933 lines
33 KiB
C
933 lines
33 KiB
C
/*******************************************************************************
|
|
**
|
|
*Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
|
|
*
|
|
*Redistribution and use in source and binary forms, with or without modification, are permitted provided
|
|
*that the following conditions are met:
|
|
*1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
|
|
*following disclaimer.
|
|
*2. 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.
|
|
*
|
|
*THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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
|
|
|
|
********************************************************************************/
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
#include <dev/pms/config.h>
|
|
|
|
#include <dev/pms/freebsd/driver/common/osenv.h>
|
|
#include <dev/pms/freebsd/driver/common/ostypes.h>
|
|
#include <dev/pms/freebsd/driver/common/osdebug.h>
|
|
|
|
#include <dev/pms/RefTisa/sallsdk/api/sa.h>
|
|
#include <dev/pms/RefTisa/sallsdk/api/saapi.h>
|
|
#include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
|
|
|
|
#ifdef FDS_DM
|
|
#include <dev/pms/RefTisa/discovery/api/dm.h>
|
|
#include <dev/pms/RefTisa/discovery/api/dmapi.h>
|
|
#include <dev/pms/RefTisa/discovery/api/tddmapi.h>
|
|
|
|
#include <dev/pms/RefTisa/discovery/dm/dmdefs.h>
|
|
#include <dev/pms/RefTisa/discovery/dm/dmtypes.h>
|
|
#include <dev/pms/RefTisa/discovery/dm/dmproto.h>
|
|
|
|
#ifdef DM_DEBUG
|
|
bit32 gDMDebugLevel = 1;
|
|
#endif
|
|
|
|
osGLOBAL void
|
|
dmGetRequirements(
|
|
dmRoot_t *dmRoot,
|
|
dmSwConfig_t *swConfig,
|
|
dmMemoryRequirement_t *memoryRequirement,
|
|
bit32 *usecsPerTick,
|
|
bit32 *maxNumLocks)
|
|
{
|
|
bit32 memoryReqCount = 0;
|
|
bit32 max_expander = DM_MAX_EXPANDER_DEV;
|
|
char *buffer;
|
|
bit32 buffLen;
|
|
bit32 lenRecv = 0;
|
|
static char tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
|
|
char *pLastUsedChar = agNULL;
|
|
char globalStr[] = "Global";
|
|
char iniParmsStr[] = "InitiatorParms";
|
|
char SwParmsStr[] = "SWParms";
|
|
|
|
DM_DBG3(("dmGetRequirements: start\n"));
|
|
/* sanity check */
|
|
DM_ASSERT((agNULL != swConfig), "");
|
|
DM_ASSERT((agNULL != memoryRequirement), "");
|
|
DM_ASSERT((agNULL != usecsPerTick), "");
|
|
DM_ASSERT((agNULL != maxNumLocks), "");
|
|
|
|
/* memory requirement for dmRoot, CACHE memory */
|
|
memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].singleElementLength = sizeof(dmIntRoot_t);
|
|
memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].numElements = 1;
|
|
memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].totalLength =
|
|
(memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].numElements);
|
|
memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].alignment = 4;
|
|
memoryRequirement->dmMemory[DM_ROOT_MEM_INDEX].type = DM_CACHED_MEM;
|
|
memoryReqCount++;
|
|
|
|
/* memory requirement for Port Context Links, CACHE memory */
|
|
memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].singleElementLength = sizeof(dmIntPortContext_t);
|
|
memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].numElements = DM_MAX_PORT_CONTEXT;
|
|
memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].totalLength =
|
|
(memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].numElements);
|
|
memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].alignment = 4;
|
|
memoryRequirement->dmMemory[DM_PORT_MEM_INDEX].type = DM_CACHED_MEM;
|
|
memoryReqCount++;
|
|
|
|
/* memory requirement for Device Links, CACHE memory */
|
|
memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].singleElementLength = sizeof(dmDeviceData_t);
|
|
memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].numElements = DM_MAX_DEV;
|
|
memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].totalLength =
|
|
(memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].numElements);
|
|
memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].alignment = 4;
|
|
memoryRequirement->dmMemory[DM_DEVICE_MEM_INDEX].type = DM_CACHED_MEM;
|
|
memoryReqCount++;
|
|
|
|
/* memory requirement for Expander Device Links, CACHE memory */
|
|
/*
|
|
Maximum number of expanders are configurable
|
|
The default is DM_MAX_EXPANDER_DEV
|
|
*/
|
|
buffer = tmpBuffer;
|
|
buffLen = sizeof(tmpBuffer);
|
|
|
|
dm_memset(buffer, 0, buffLen);
|
|
lenRecv = 0;
|
|
|
|
if ((tddmGetTransportParam(
|
|
dmRoot,
|
|
globalStr,
|
|
iniParmsStr,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
"MaxExpanders",
|
|
buffer,
|
|
buffLen,
|
|
&lenRecv
|
|
) == DM_RC_SUCCESS) && (lenRecv != 0))
|
|
{
|
|
if (osti_strncmp(buffer, "0x", 2) == 0)
|
|
{
|
|
max_expander = osti_strtoul (buffer, &pLastUsedChar, 0);
|
|
}
|
|
else
|
|
{
|
|
max_expander = osti_strtoul (buffer, &pLastUsedChar, 10);
|
|
}
|
|
}
|
|
DM_DBG3(("dmGetRequirements: max_expander %d\n", max_expander));
|
|
|
|
|
|
memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].singleElementLength = sizeof(dmExpander_t);
|
|
memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].numElements = max_expander;
|
|
memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].totalLength =
|
|
(memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].numElements);
|
|
memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].alignment = 4;
|
|
memoryRequirement->dmMemory[DM_EXPANDER_MEM_INDEX].type = DM_CACHED_MEM;
|
|
memoryReqCount++;
|
|
|
|
/* memory requirement for SMP command Links, CACHE memory */
|
|
memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].singleElementLength = sizeof(dmSMPRequestBody_t);
|
|
memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].numElements = DM_MAX_SMP;
|
|
memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].totalLength =
|
|
(memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].numElements);
|
|
memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].alignment = 4;
|
|
memoryRequirement->dmMemory[DM_SMP_MEM_INDEX].type = DM_CACHED_MEM;
|
|
memoryReqCount++;
|
|
|
|
/* memory requirement for INDIRECT SMP command/response Links, DMA memory */
|
|
memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].singleElementLength = SMP_INDIRECT_PAYLOAD; /* 512 */
|
|
memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].numElements = DM_MAX_INDIRECT_SMP;
|
|
memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].totalLength =
|
|
(memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].singleElementLength) * (memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].numElements);
|
|
memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].alignment = 4;
|
|
memoryRequirement->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].type = DM_DMA_MEM;
|
|
memoryReqCount++;
|
|
|
|
|
|
/* set up memory requirement count */
|
|
memoryRequirement->count = memoryReqCount;
|
|
|
|
/* requirement for locks */
|
|
*maxNumLocks = DM_MAX_LOCKS;
|
|
|
|
/* setup the time tick */
|
|
*usecsPerTick = DM_USECS_PER_TICK;
|
|
|
|
|
|
/* set up the number of Expander device handles */
|
|
swConfig->numDevHandles = DM_MAX_DEV;
|
|
swConfig->itNexusTimeout = IT_NEXUS_TIMEOUT; /* default is 2000 ms*/
|
|
|
|
dm_memset(buffer, 0, buffLen);
|
|
lenRecv = 0;
|
|
|
|
if ((tddmGetTransportParam(
|
|
dmRoot,
|
|
globalStr,
|
|
SwParmsStr,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
"IT_NEXUS_TIMEOUT",
|
|
buffer,
|
|
buffLen,
|
|
&lenRecv
|
|
) == DM_RC_SUCCESS) && (lenRecv != 0))
|
|
{
|
|
if (osti_strncmp(buffer, "0x", 2) == 0)
|
|
{
|
|
swConfig->itNexusTimeout = osti_strtoul (buffer, &pLastUsedChar, 0);
|
|
}
|
|
else
|
|
{
|
|
swConfig->itNexusTimeout = osti_strtoul (buffer, &pLastUsedChar, 10);
|
|
}
|
|
}
|
|
|
|
DM_DBG1(("dmGetRequirements: swConfig->itNexusTimeout 0x%X\n", swConfig->itNexusTimeout));
|
|
|
|
DM_DBG3(("dmGetRequirements: memoryReqCount %d\n", memoryRequirement->count));
|
|
|
|
return;
|
|
}
|
|
/*
|
|
??? processing swConfig
|
|
*/
|
|
osGLOBAL bit32
|
|
dmInitialize(
|
|
dmRoot_t *dmRoot,
|
|
agsaRoot_t *agRoot,
|
|
dmMemoryRequirement_t *memoryAllocated,
|
|
dmSwConfig_t *swConfig,
|
|
bit32 usecsPerTick )
|
|
{
|
|
dmIntRoot_t *dmIntRoot;
|
|
dmIntPortContext_t *dmIntPortContext;
|
|
dmDeviceData_t *dmDevice;
|
|
dmExpander_t *dmExpander;
|
|
dmSMPRequestBody_t *dmSMPRequest;
|
|
bit8 *dmIndirectSMPRequest;
|
|
dmIntContext_t *dmAllShared;
|
|
bit32 i;
|
|
bit32 max_expander = DM_MAX_EXPANDER_DEV;
|
|
char *buffer;
|
|
bit32 buffLen;
|
|
bit32 lenRecv = 0;
|
|
static char tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
|
|
char *pLastUsedChar = agNULL;
|
|
char globalStr[] = "Global";
|
|
char iniParmsStr[] = "InitiatorParms";
|
|
char SwParmsStr[] = "SWParms";
|
|
|
|
DM_DBG3(("dmInitialize: start\n"));
|
|
/* sanity check */
|
|
DM_ASSERT((agNULL != dmRoot), "");
|
|
DM_ASSERT((agNULL != agRoot), "");
|
|
DM_ASSERT((agNULL != memoryAllocated), "");
|
|
DM_ASSERT((agNULL != swConfig), "");
|
|
DM_ASSERT((DM_ROOT_MEM_INDEX < memoryAllocated->count), "");
|
|
DM_ASSERT((DM_PORT_MEM_INDEX < memoryAllocated->count), "");
|
|
DM_ASSERT((DM_DEVICE_MEM_INDEX < memoryAllocated->count), "");
|
|
DM_ASSERT((DM_EXPANDER_MEM_INDEX < memoryAllocated->count), "");
|
|
DM_ASSERT((DM_SMP_MEM_INDEX < memoryAllocated->count), "");
|
|
DM_ASSERT((DM_INDIRECT_SMP_MEM_INDEX < memoryAllocated->count), "");
|
|
|
|
/* Check the memory allocated */
|
|
for ( i = 0; i < memoryAllocated->count; i ++ )
|
|
{
|
|
/* If memory allocatation failed */
|
|
if (memoryAllocated->dmMemory[i].singleElementLength &&
|
|
memoryAllocated->dmMemory[i].numElements)
|
|
{
|
|
if ( (0 != memoryAllocated->dmMemory[i].numElements)
|
|
&& (0 == memoryAllocated->dmMemory[i].totalLength) )
|
|
{
|
|
/* return failure */
|
|
DM_DBG1(("dmInitialize: Memory[%d] singleElementLength = 0x%0x numElements = 0x%x NOT allocated!!!\n",
|
|
i,
|
|
memoryAllocated->dmMemory[i].singleElementLength,
|
|
memoryAllocated->dmMemory[i].numElements));
|
|
return DM_RC_FAILURE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* DM's internal root */
|
|
dmIntRoot = (dmIntRoot_t *) (memoryAllocated->dmMemory[DM_ROOT_MEM_INDEX].virtPtr);
|
|
dmRoot->dmData = (void *) dmIntRoot;
|
|
|
|
dmAllShared = (dmIntContext_t *)&(dmIntRoot->dmAllShared);
|
|
/**< Initialize the TDM data part of the interrupt context */
|
|
dmAllShared->dmRootOsData.dmRoot = dmRoot;
|
|
dmAllShared->dmRootOsData.dmAllShared = (void *) dmAllShared;
|
|
|
|
/* Port Contexts */
|
|
dmIntPortContext = (dmIntPortContext_t *) (memoryAllocated->dmMemory[DM_PORT_MEM_INDEX].virtPtr);
|
|
dmAllShared->PortContextMem = (dmIntPortContext_t *)dmIntPortContext;
|
|
|
|
/* Devices */
|
|
dmDevice = (dmDeviceData_t *) (memoryAllocated->dmMemory[DM_DEVICE_MEM_INDEX].virtPtr);
|
|
dmAllShared->DeviceMem = (dmDeviceData_t *)dmDevice;
|
|
|
|
/* Expanders */
|
|
dmExpander = (dmExpander_t *) (memoryAllocated->dmMemory[DM_EXPANDER_MEM_INDEX].virtPtr);
|
|
dmAllShared->ExpanderMem = (dmExpander_t *)dmExpander;
|
|
|
|
/* SMP commands */
|
|
dmSMPRequest = (dmSMPRequestBody_t *) (memoryAllocated->dmMemory[DM_SMP_MEM_INDEX].virtPtr);
|
|
dmAllShared->SMPMem = (dmSMPRequestBody_t *)dmSMPRequest;
|
|
|
|
/* DMAable SMP request/reponse pointed by dmSMPRequestBody_t */
|
|
dmIndirectSMPRequest = (bit8 *) (memoryAllocated->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].virtPtr);
|
|
dmAllShared->IndirectSMPMem = (bit8 *)dmIndirectSMPRequest;
|
|
dmAllShared->IndirectSMPUpper32 = memoryAllocated->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].physAddrUpper;
|
|
dmAllShared->IndirectSMPLower32 = memoryAllocated->dmMemory[DM_INDIRECT_SMP_MEM_INDEX].physAddrLower;
|
|
|
|
dmAllShared->agRoot = agRoot;
|
|
|
|
|
|
dmAllShared->usecsPerTick = usecsPerTick;
|
|
dmAllShared->itNexusTimeout = IT_NEXUS_TIMEOUT;/*swConfig->itNexusTimeout;*/
|
|
dmAllShared->MaxRetryDiscovery = DISCOVERY_RETRIES;
|
|
dmAllShared->RateAdjust = 0;
|
|
/**< initializes timers */
|
|
dmInitTimers(dmRoot);
|
|
|
|
/**< initializes port contexts */
|
|
dmPortContextInit(dmRoot);
|
|
|
|
/**< initializes devices */
|
|
dmDeviceDataInit(dmRoot);
|
|
|
|
/**< initializes expander devices */
|
|
buffer = tmpBuffer;
|
|
buffLen = sizeof(tmpBuffer);
|
|
|
|
dm_memset(buffer, 0, buffLen);
|
|
lenRecv = 0;
|
|
|
|
if ((tddmGetTransportParam(
|
|
dmRoot,
|
|
globalStr,
|
|
iniParmsStr,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
"MaxExpanders",
|
|
buffer,
|
|
buffLen,
|
|
&lenRecv
|
|
) == DM_RC_SUCCESS) && (lenRecv != 0))
|
|
{
|
|
if (osti_strncmp(buffer, "0x", 2) == 0)
|
|
{
|
|
max_expander = osti_strtoul (buffer, &pLastUsedChar, 0);
|
|
}
|
|
else
|
|
{
|
|
max_expander = osti_strtoul (buffer, &pLastUsedChar, 10);
|
|
}
|
|
}
|
|
|
|
dm_memset(buffer, 0, buffLen);
|
|
lenRecv = 0;
|
|
|
|
if ((tddmGetTransportParam(
|
|
dmRoot,
|
|
globalStr,
|
|
SwParmsStr,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
"IT_NEXUS_TIMEOUT",
|
|
buffer,
|
|
buffLen,
|
|
&lenRecv
|
|
) == DM_RC_SUCCESS) && (lenRecv != 0))
|
|
{
|
|
if (osti_strncmp(buffer, "0x", 2) == 0)
|
|
{
|
|
dmAllShared->itNexusTimeout = osti_strtoul (buffer, &pLastUsedChar, 0);
|
|
}
|
|
else
|
|
{
|
|
dmAllShared->itNexusTimeout = osti_strtoul (buffer, &pLastUsedChar, 10);
|
|
}
|
|
}
|
|
|
|
DM_DBG1(("dmAllShared->itNexusTimeout %d \n", dmAllShared->itNexusTimeout));
|
|
|
|
dm_memset(buffer, 0, buffLen);
|
|
lenRecv = 0;
|
|
|
|
if ((tddmGetTransportParam(
|
|
dmRoot,
|
|
globalStr,
|
|
SwParmsStr,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
"MaxRetryDiscovery",
|
|
buffer,
|
|
buffLen,
|
|
&lenRecv
|
|
) == DM_RC_SUCCESS) && (lenRecv != 0))
|
|
{
|
|
if (osti_strncmp(buffer, "0x", 2) == 0)
|
|
{
|
|
dmAllShared->MaxRetryDiscovery = osti_strtoul (buffer, &pLastUsedChar, 0);
|
|
}
|
|
else
|
|
{
|
|
dmAllShared->MaxRetryDiscovery = osti_strtoul (buffer, &pLastUsedChar, 10);
|
|
}
|
|
}
|
|
|
|
DM_DBG1(("dmAllShared->MaxRetryDiscovery %d \n", dmAllShared->MaxRetryDiscovery));
|
|
|
|
dm_memset(buffer, 0, buffLen);
|
|
lenRecv = 0;
|
|
if ((tddmGetTransportParam(
|
|
dmRoot,
|
|
globalStr,
|
|
SwParmsStr,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
agNULL,
|
|
"RateAdjust",
|
|
buffer,
|
|
buffLen,
|
|
&lenRecv
|
|
) == DM_RC_SUCCESS) && (lenRecv != 0))
|
|
{
|
|
if (osti_strncmp(buffer, "0x", 2) == 0)
|
|
{
|
|
dmAllShared->RateAdjust = osti_strtoul (buffer, &pLastUsedChar, 0);
|
|
}
|
|
else
|
|
{
|
|
dmAllShared->RateAdjust = osti_strtoul (buffer, &pLastUsedChar, 10);
|
|
}
|
|
}
|
|
DM_DBG1(("dmAllShared->RateAdjust %d \n", dmAllShared->RateAdjust));
|
|
|
|
dmExpanderDeviceDataInit(dmRoot, max_expander);
|
|
|
|
/**< initializes SMP commands */
|
|
dmSMPInit(dmRoot);
|
|
|
|
#ifdef DM_DEBUG
|
|
gDMDebugLevel = swConfig->DMDebugLevel;
|
|
#endif
|
|
return DM_RC_SUCCESS;
|
|
}
|
|
|
|
osGLOBAL void
|
|
dmSMPInit(
|
|
dmRoot_t *dmRoot
|
|
)
|
|
{
|
|
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
|
|
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
|
|
dmSMPRequestBody_t *dmSMPCommand = (dmSMPRequestBody_t *)dmAllShared->SMPMem;
|
|
bit8 *dmIndirectSMPReqRsp = (bit8 *)dmAllShared->IndirectSMPMem;
|
|
bit32 prev_PhysAddrLower;
|
|
|
|
int i = 0;
|
|
DM_DBG3(("dmSMPInit: start \n"));
|
|
|
|
DMLIST_INIT_HDR(&(dmAllShared->freeSMPList));
|
|
|
|
for(i=0;i<DM_MAX_SMP;i++)
|
|
{
|
|
DMLIST_INIT_ELEMENT(&(dmSMPCommand[i].Link));
|
|
/* initialize expander fields */
|
|
dmSMPCommand[i].dmRoot = agNULL;
|
|
dmSMPCommand[i].dmDevice = agNULL;
|
|
dmSMPCommand[i].dmPortContext = agNULL;
|
|
dmSMPCommand[i].retries = 0;
|
|
dmSMPCommand[i].id = i;
|
|
dm_memset( &(dmSMPCommand[i].smpPayload), 0, sizeof(dmSMPCommand[i].smpPayload));
|
|
/* indirect SMP related */
|
|
dmSMPCommand[i].IndirectSMPResponse = agNULL;
|
|
dmSMPCommand[i].IndirectSMP = ((bit8 *)dmIndirectSMPReqRsp) + (i*SMP_INDIRECT_PAYLOAD);
|
|
dmSMPCommand[i].IndirectSMPUpper32 = dmAllShared->IndirectSMPUpper32;
|
|
dmSMPCommand[i].IndirectSMPLower32 = dmAllShared->IndirectSMPLower32;
|
|
|
|
prev_PhysAddrLower = dmAllShared->IndirectSMPLower32;
|
|
dmAllShared->IndirectSMPLower32 = dmAllShared->IndirectSMPLower32 + SMP_INDIRECT_PAYLOAD;
|
|
if (dmAllShared->IndirectSMPLower32 <= prev_PhysAddrLower)
|
|
{
|
|
dmAllShared->IndirectSMPUpper32++;
|
|
}
|
|
|
|
DMLIST_ENQUEUE_AT_TAIL(&(dmSMPCommand[i].Link), &(dmAllShared->freeSMPList));
|
|
}
|
|
return;
|
|
|
|
}
|
|
|
|
osGLOBAL void
|
|
dmDeviceDataInit(
|
|
dmRoot_t *dmRoot
|
|
)
|
|
{
|
|
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
|
|
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
|
|
dmDeviceData_t *dmDeviceData = (dmDeviceData_t *)dmAllShared->DeviceMem;
|
|
int i;
|
|
|
|
DM_DBG3(("dmDeviceDataInit: start \n"));
|
|
|
|
DMLIST_INIT_HDR(&(dmAllShared->MainDeviceList));
|
|
DMLIST_INIT_HDR(&(dmAllShared->FreeDeviceList));
|
|
|
|
for(i=0;i<DM_MAX_DEV;i++)
|
|
{
|
|
DMLIST_INIT_ELEMENT(&(dmDeviceData[i].FreeLink));
|
|
DMLIST_INIT_ELEMENT(&(dmDeviceData[i].MainLink));
|
|
DMLIST_INIT_ELEMENT(&(dmDeviceData[i].IncDisLink));
|
|
dmDeviceData[i].id = i;
|
|
dmDeviceData[i].DeviceType = DM_DEFAULT_DEVICE;
|
|
dmDeviceData[i].dmRoot = agNULL;
|
|
// dmDeviceData[i].agDevHandle = agNULL;
|
|
|
|
dmDeviceData[i].dmPortContext = agNULL;
|
|
dmDeviceData[i].dmExpander = agNULL;
|
|
dmDeviceData[i].ExpDevice = agNULL;
|
|
dmDeviceData[i].phyID = 0xFF;
|
|
dmDeviceData[i].SASAddressID.sasAddressHi = 0;
|
|
dmDeviceData[i].SASAddressID.sasAddressLo = 0;
|
|
dmDeviceData[i].valid = agFALSE;
|
|
dmDeviceData[i].valid2 = agFALSE;
|
|
dmDeviceData[i].processed = agFALSE;
|
|
dmDeviceData[i].initiator_ssp_stp_smp = 0;
|
|
dmDeviceData[i].target_ssp_stp_smp = 0;
|
|
dmDeviceData[i].numOfPhys = 0;
|
|
// dmDeviceData[i].registered = agFALSE;
|
|
dmDeviceData[i].directlyAttached = agFALSE;
|
|
dmDeviceData[i].SASSpecDeviceType = 0xFF;
|
|
dmDeviceData[i].IOStart = 0;
|
|
dmDeviceData[i].IOResponse = 0;
|
|
dmDeviceData[i].agDeviceResetContext.osData = agNULL;
|
|
dmDeviceData[i].agDeviceResetContext.sdkData = agNULL;
|
|
dmDeviceData[i].TRflag = agFALSE;
|
|
dmDeviceData[i].ResetCnt = 0;
|
|
dmDeviceData[i].registered = agFALSE;
|
|
dmDeviceData[i].reported = agFALSE;
|
|
|
|
dmDeviceData[i].MCN = 0;
|
|
dmDeviceData[i].MCNDone = agFALSE;
|
|
dmDeviceData[i].PrevMCN = 0;
|
|
|
|
dm_memset( &(dmDeviceData[i].dmDeviceInfo), 0, sizeof(dmDeviceInfo_t));
|
|
/* some other variables */
|
|
DMLIST_ENQUEUE_AT_TAIL(&(dmDeviceData[i].FreeLink), &(dmAllShared->FreeDeviceList));
|
|
}
|
|
|
|
return;
|
|
}
|
|
osGLOBAL void
|
|
dmDeviceDataReInit(
|
|
dmRoot_t *dmRoot,
|
|
dmDeviceData_t *oneDeviceData
|
|
)
|
|
{
|
|
DM_DBG3(("dmDeviceDataReInit: start \n"));
|
|
|
|
oneDeviceData->DeviceType = DM_DEFAULT_DEVICE;
|
|
// oneDeviceData->agDevHandle = agNULL;
|
|
|
|
oneDeviceData->dmPortContext = agNULL;
|
|
oneDeviceData->dmExpander = agNULL;
|
|
oneDeviceData->ExpDevice = agNULL;
|
|
oneDeviceData->phyID = 0xFF;
|
|
oneDeviceData->SASAddressID.sasAddressHi = 0;
|
|
oneDeviceData->SASAddressID.sasAddressLo = 0;
|
|
oneDeviceData->valid = agFALSE;
|
|
oneDeviceData->valid2 = agFALSE;
|
|
oneDeviceData->processed = agFALSE;
|
|
oneDeviceData->initiator_ssp_stp_smp = 0;
|
|
oneDeviceData->target_ssp_stp_smp = 0;
|
|
oneDeviceData->numOfPhys = 0;
|
|
// oneDeviceData->registered = agFALSE;
|
|
oneDeviceData->directlyAttached = agFALSE;
|
|
oneDeviceData->SASSpecDeviceType = 0xFF;
|
|
oneDeviceData->IOStart = 0;
|
|
oneDeviceData->IOResponse = 0;
|
|
oneDeviceData->agDeviceResetContext.osData = agNULL;
|
|
oneDeviceData->agDeviceResetContext.sdkData = agNULL;
|
|
oneDeviceData->TRflag = agFALSE;
|
|
oneDeviceData->ResetCnt = 0;
|
|
oneDeviceData->registered = agFALSE;
|
|
oneDeviceData->reported = agFALSE;
|
|
|
|
oneDeviceData->MCN = 0;
|
|
oneDeviceData->MCNDone = agFALSE;
|
|
oneDeviceData->PrevMCN = 0;
|
|
|
|
dm_memset( &(oneDeviceData->dmDeviceInfo), 0, sizeof(dmDeviceInfo_t));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
osGLOBAL void
|
|
dmExpanderDeviceDataInit(
|
|
dmRoot_t *dmRoot,
|
|
bit32 max_exp
|
|
)
|
|
{
|
|
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
|
|
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
|
|
dmExpander_t *dmExpData = (dmExpander_t *)dmAllShared->ExpanderMem;
|
|
bit32 i = 0;
|
|
DM_DBG3(("dmExpanderDeviceDataInit: start \n"));
|
|
|
|
DMLIST_INIT_HDR(&(dmAllShared->freeExpanderList));
|
|
DMLIST_INIT_HDR(&(dmAllShared->mainExpanderList));
|
|
|
|
for(i=0;i<max_exp;i++)
|
|
{
|
|
DMLIST_INIT_ELEMENT(&(dmExpData[i].linkNode));
|
|
DMLIST_INIT_ELEMENT(&(dmExpData[i].upNode));
|
|
/* initialize expander fields */
|
|
dmExpData[i].dmRoot = agNULL;
|
|
dmExpData[i].agDevHandle = agNULL;
|
|
dmExpData[i].dmDevice = agNULL;
|
|
dmExpData[i].dmUpStreamExpander = agNULL;
|
|
dmExpData[i].dmCurrentDownStreamExpander = agNULL;
|
|
dmExpData[i].hasUpStreamDevice = agFALSE;
|
|
dmExpData[i].numOfUpStreamPhys = 0;
|
|
dmExpData[i].currentUpStreamPhyIndex = 0;
|
|
dmExpData[i].numOfDownStreamPhys = 0;
|
|
dmExpData[i].currentDownStreamPhyIndex = 0;
|
|
dmExpData[i].discoveringPhyId = 0;
|
|
dmExpData[i].underDiscovering = agFALSE;
|
|
dmExpData[i].id = i;
|
|
DM_DBG3(("dmExpanderDeviceDataInit: exp id %d\n", i));
|
|
|
|
dmExpData[i].dmReturnginExpander = agNULL;
|
|
dmExpData[i].discoverSMPAllowed = agTRUE;
|
|
dm_memset( &(dmExpData[i].currentIndex), 0, sizeof(dmExpData[i].currentIndex));
|
|
dm_memset( &(dmExpData[i].upStreamPhys), 0, sizeof(dmExpData[i].upStreamPhys));
|
|
dm_memset( &(dmExpData[i].downStreamPhys), 0, sizeof(dmExpData[i].downStreamPhys));
|
|
dm_memset( &(dmExpData[i].routingAttribute), 0, sizeof(dmExpData[i].routingAttribute));
|
|
dmExpData[i].configSASAddrTableIndex = 0;
|
|
dm_memset( &(dmExpData[i].configSASAddressHiTable), 0, sizeof(dmExpData[i].configSASAddressHiTable));
|
|
dm_memset( &(dmExpData[i].configSASAddressLoTable), 0, sizeof(dmExpData[i].configSASAddressLoTable));
|
|
dmExpData[i].SAS2 = 0; /* default is SAS 1.1 spec */
|
|
dmExpData[i].TTTSupported = agFALSE; /* Table to Table is supported */
|
|
dmExpData[i].UndoDueToTTTSupported = agFALSE;
|
|
|
|
|
|
DMLIST_ENQUEUE_AT_TAIL(&(dmExpData[i].linkNode), &(dmAllShared->freeExpanderList));
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* re-intialize an expander */
|
|
osGLOBAL void
|
|
dmExpanderDeviceDataReInit(
|
|
dmRoot_t *dmRoot,
|
|
dmExpander_t *oneExpander
|
|
)
|
|
{
|
|
DM_DBG3(("dmExpanderDeviceDataReInit: start \n"));
|
|
oneExpander->dmRoot = agNULL;
|
|
oneExpander->agDevHandle = agNULL;
|
|
oneExpander->dmDevice = agNULL;
|
|
oneExpander->dmUpStreamExpander = agNULL;
|
|
oneExpander->dmCurrentDownStreamExpander = agNULL;
|
|
oneExpander->hasUpStreamDevice = agFALSE;
|
|
oneExpander->numOfUpStreamPhys = 0;
|
|
oneExpander->currentUpStreamPhyIndex = 0;
|
|
oneExpander->numOfDownStreamPhys = 0;
|
|
oneExpander->currentDownStreamPhyIndex = 0;
|
|
oneExpander->discoveringPhyId = 0;
|
|
oneExpander->underDiscovering = agFALSE;
|
|
oneExpander->dmReturnginExpander = agNULL;
|
|
oneExpander->discoverSMPAllowed = agTRUE;
|
|
dm_memset( &(oneExpander->currentIndex), 0, sizeof(oneExpander->currentIndex));
|
|
dm_memset( &(oneExpander->upStreamPhys), 0, sizeof(oneExpander->upStreamPhys));
|
|
dm_memset( &(oneExpander->downStreamPhys), 0, sizeof(oneExpander->downStreamPhys));
|
|
dm_memset( &(oneExpander->routingAttribute), 0, sizeof(oneExpander->routingAttribute));
|
|
oneExpander->configSASAddrTableIndex = 0;
|
|
dm_memset( &(oneExpander->configSASAddressHiTable), 0, sizeof(oneExpander->configSASAddressHiTable));
|
|
dm_memset( &(oneExpander->configSASAddressLoTable), 0, sizeof(oneExpander->configSASAddressLoTable));
|
|
oneExpander->SAS2 = 0; /* default is SAS 1.1 spec */
|
|
oneExpander->TTTSupported = agFALSE; /* Table to Table is supported */
|
|
oneExpander->UndoDueToTTTSupported = agFALSE;
|
|
|
|
return;
|
|
}
|
|
|
|
osGLOBAL void
|
|
dmPortContextInit(
|
|
dmRoot_t *dmRoot
|
|
)
|
|
{
|
|
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
|
|
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
|
|
dmIntPortContext_t *dmPortContext = (dmIntPortContext_t *)dmAllShared->PortContextMem;
|
|
int i = 0;
|
|
#ifdef TBD
|
|
int j = 0;
|
|
#endif
|
|
|
|
DM_DBG3(("dmPortContextInit: start \n"));
|
|
|
|
DMLIST_INIT_HDR(&(dmAllShared->MainPortContextList));
|
|
DMLIST_INIT_HDR(&(dmAllShared->FreePortContextList));
|
|
for(i=0;i<DM_MAX_PORT_CONTEXT;i++)
|
|
{
|
|
DMLIST_INIT_ELEMENT(&(dmPortContext[i].FreeLink));
|
|
DMLIST_INIT_ELEMENT(&(dmPortContext[i].MainLink));
|
|
|
|
DMLIST_INIT_HDR(&(dmPortContext[i].discovery.discoveringExpanderList));
|
|
DMLIST_INIT_HDR(&(dmPortContext[i].discovery.UpdiscoveringExpanderList));
|
|
dmPortContext[i].discovery.type = DM_DISCOVERY_OPTION_FULL_START;
|
|
dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.discoveryTimer));
|
|
dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.configureRouteTimer));
|
|
dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.deviceRegistrationTimer));
|
|
dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.SMPBusyTimer));
|
|
dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.BCTimer));
|
|
dmInitTimerRequest(dmRoot, &(dmPortContext[i].discovery.DiscoverySMPTimer));
|
|
dmPortContext[i].discovery.retries = 0;
|
|
dmPortContext[i].discovery.configureRouteRetries = 0;
|
|
dmPortContext[i].discovery.deviceRetistrationRetries = 0;
|
|
dmPortContext[i].discovery.pendingSMP = 0;
|
|
dmPortContext[i].discovery.SeenBC = agFALSE;
|
|
dmPortContext[i].discovery.forcedOK = agFALSE;
|
|
dmPortContext[i].discovery.SMPRetries = 0;
|
|
dmPortContext[i].discovery.DeferredError = agFALSE;
|
|
dmPortContext[i].discovery.ConfiguresOthers = agFALSE;
|
|
dmPortContext[i].discovery.ResetTriggerred = agFALSE;
|
|
|
|
#ifdef INITIATOR_DRIVER
|
|
dmPortContext[i].DiscoveryState = DM_DSTATE_NOT_STARTED;
|
|
dmPortContext[i].DiscoveryAbortInProgress = agFALSE;
|
|
dmPortContext[i].directAttatchedSAS = agFALSE;
|
|
dmPortContext[i].DiscoveryRdyGiven = agFALSE;
|
|
dmPortContext[i].SeenLinkUp = agFALSE;
|
|
|
|
#endif
|
|
dmPortContext[i].id = i;
|
|
#ifdef TBD
|
|
dmPortContext[i].agPortContext = agNULL;
|
|
#endif
|
|
dmPortContext[i].LinkRate = 0;
|
|
dmPortContext[i].Count = 0;
|
|
dmPortContext[i].valid = agFALSE;
|
|
dmPortContext[i].RegFailed = agFALSE;
|
|
|
|
#ifdef TBD
|
|
for (j=0;j<DM_MAX_NUM_PHYS;j++)
|
|
{
|
|
dmPortContext[i].PhyIDList[j] = agFALSE;
|
|
}
|
|
#endif
|
|
dmPortContext[i].RegisteredDevNums = 0;
|
|
dmPortContext[i].eventPhyID = 0xFF;
|
|
dmPortContext[i].Transient = agFALSE;
|
|
|
|
/* add more variables later */
|
|
DMLIST_ENQUEUE_AT_TAIL(&(dmPortContext[i].FreeLink), &(dmAllShared->FreePortContextList));
|
|
}
|
|
|
|
#ifdef DM_INTERNAL_DEBUG /* for debugging only */
|
|
for(i=0;i<DM_MAX_PORT_CONTEXT;i++)
|
|
{
|
|
DM_DBG6(("dmPortContextInit: index %d &tdsaPortContext[] %p\n", i, &(dmPortContext[i])));
|
|
}
|
|
DM_DBG6(("dmPortContextInit: sizeof(tdsaPortContext_t) %d 0x%x\n", sizeof(dmIntPortContext_t), sizeof(dmIntPortContext_t)));
|
|
#endif
|
|
|
|
return;
|
|
}
|
|
|
|
osGLOBAL void
|
|
dmPortContextReInit(
|
|
dmRoot_t *dmRoot,
|
|
dmIntPortContext_t *onePortContext
|
|
)
|
|
{
|
|
dmDiscovery_t *discovery;
|
|
|
|
DM_DBG3(("dmPortContextReInit: start \n"));
|
|
|
|
discovery = &(onePortContext->discovery);
|
|
|
|
onePortContext->discovery.type = DM_DISCOVERY_OPTION_FULL_START;
|
|
onePortContext->discovery.retries = 0;
|
|
onePortContext->discovery.configureRouteRetries = 0;
|
|
onePortContext->discovery.deviceRetistrationRetries = 0;
|
|
onePortContext->discovery.pendingSMP = 0;
|
|
onePortContext->discovery.SeenBC = agFALSE;
|
|
onePortContext->discovery.forcedOK = agFALSE;
|
|
onePortContext->discovery.SMPRetries = 0;
|
|
onePortContext->discovery.DeferredError = agFALSE;
|
|
onePortContext->discovery.ConfiguresOthers = agFALSE;
|
|
onePortContext->discovery.ResetTriggerred = agFALSE;
|
|
|
|
/* free expander lists */
|
|
dmCleanAllExp(dmRoot, onePortContext);
|
|
|
|
/* kill the discovery-related timers if they are running */
|
|
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
|
|
if (discovery->discoveryTimer.timerRunning == agTRUE)
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
dmKillTimer(
|
|
dmRoot,
|
|
&discovery->discoveryTimer
|
|
);
|
|
}
|
|
else
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
}
|
|
|
|
|
|
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
|
|
if (discovery->configureRouteTimer.timerRunning == agTRUE)
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
dmKillTimer(
|
|
dmRoot,
|
|
&discovery->configureRouteTimer
|
|
);
|
|
}
|
|
else
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
}
|
|
|
|
|
|
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
|
|
if (discovery->deviceRegistrationTimer.timerRunning == agTRUE)
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
dmKillTimer(
|
|
dmRoot,
|
|
&discovery->deviceRegistrationTimer
|
|
);
|
|
}
|
|
else
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
}
|
|
|
|
|
|
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
|
|
if (discovery->BCTimer.timerRunning == agTRUE)
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
dmKillTimer(
|
|
dmRoot,
|
|
&discovery->BCTimer
|
|
);
|
|
}
|
|
else
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
}
|
|
|
|
|
|
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
|
|
if (discovery->SMPBusyTimer.timerRunning == agTRUE)
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
dmKillTimer(
|
|
dmRoot,
|
|
&discovery->SMPBusyTimer
|
|
);
|
|
}
|
|
else
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
}
|
|
|
|
|
|
tddmSingleThreadedEnter(dmRoot, DM_TIMER_LOCK);
|
|
if (discovery->DiscoverySMPTimer.timerRunning == agTRUE)
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
dmKillTimer(
|
|
dmRoot,
|
|
&discovery->DiscoverySMPTimer
|
|
);
|
|
}
|
|
else
|
|
{
|
|
tddmSingleThreadedLeave(dmRoot, DM_TIMER_LOCK);
|
|
}
|
|
|
|
onePortContext->DiscoveryState = DM_DSTATE_NOT_STARTED;
|
|
onePortContext->DiscoveryAbortInProgress = agFALSE;
|
|
onePortContext->directAttatchedSAS = agFALSE;
|
|
onePortContext->DiscoveryRdyGiven = agFALSE;
|
|
onePortContext->SeenLinkUp = agFALSE;
|
|
|
|
onePortContext->dmPortContext->dmData = agNULL;
|
|
onePortContext->dmPortContext = agNULL;
|
|
onePortContext->dmRoot = agNULL;
|
|
|
|
onePortContext->LinkRate = 0;
|
|
onePortContext->Count = 0;
|
|
onePortContext->valid = agFALSE;
|
|
onePortContext->RegisteredDevNums = 0;
|
|
onePortContext->eventPhyID = 0xFF;
|
|
onePortContext->Transient = agFALSE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
osGLOBAL void
|
|
dmInitTimers(
|
|
dmRoot_t *dmRoot
|
|
)
|
|
{
|
|
dmIntRoot_t *dmIntRoot = (dmIntRoot_t *)dmRoot->dmData;
|
|
dmIntContext_t *dmAllShared = (dmIntContext_t *)&dmIntRoot->dmAllShared;
|
|
|
|
#ifdef DM_DEBUG_ENABLE
|
|
dmIntPortContext_t *dmPortContext = (dmIntPortContext_t *)dmAllShared->PortContextMem;
|
|
|
|
DM_DBG6(("dmInitTimers: start \n"));
|
|
DM_DBG6(("dmInitTimers: ******* tdsaRoot %p \n", dmIntRoot));
|
|
DM_DBG6(("dmInitTimers: ******* tdsaPortContext %p \n",dmPortContext));
|
|
#endif
|
|
|
|
/* initialize the timerlist */
|
|
DMLIST_INIT_HDR(&(dmAllShared->timerlist));
|
|
|
|
return;
|
|
}
|
|
#endif /* FDS_ DM */
|
|
|
|
|