Subversion Repositories funbase_ip_library

/*

 * Copyright (c) 2010, Mentor Graphics Corporation

 * 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.

 * 3. Neither the name of the <ORGANIZATION> 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 HOLDER 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.

 */

//#define   MCAPI_SM_DBG_SUPPORT

#include <mcapi.h>

#include <openmcapi.h>

#include <atomic.h>

#include "shm.h"

#include "shm_os.h"

#ifdef MCAPI_SM_DBG_SUPPORT

#include <stdio.h>

#endif

#define LOCK   1

#define UNLOCK 0

SHM_MGMT_BLOCK*  SHM_Mgmt_Blk = MCAPI_NULL;

SHM_BUFFER*      SHM_Buff_Array_Ptr;

MCAPI_INTERFACE* SHM_Current_Interface_Ptr;

extern MCAPI_BUF_QUEUE MCAPI_RX_Queue[MCAPI_PRIO_COUNT];

extern mcapi_node_t MCAPI_Node_ID;

static void shm_acquire_lock(shm_lock* plock)

{

        const int lockVal = LOCK;

        unsigned int retVal;

        do {

                retVal = xchg(plock, lockVal);

        } while (retVal==lockVal);

}

static void shm_release_lock(shm_lock* plock)

{

        mb();

        *plock = UNLOCK;

}

static mcapi_uint32_t get_first_zero_bit(mcapi_int_t value)

{

        mcapi_uint32_t idx;

        mcapi_uint32_t tmp32;

        /* Invert value */

        value = ~value;

        /* (~value) & (2's complement of value) */

        value = (value & (-value)) - 1;

        /* log2(value) */

        tmp32 = value - ((value >> 1) & 033333333333)- ((value >> 2) & 011111111111);

        idx = ((tmp32 + (tmp32 >> 3))& 030707070707) % 63;

        /* Obtain index (compiler optimized ) */

        //GET_IDX(idx,value);

        return idx;

}

static mcapi_status_t get_sm_buff_index(mcapi_uint32_t* p_idx)

{

        mcapi_uint32_t i, tmp32;

        mcapi_status_t status = MCAPI_ERR_TRANSMISSION;

        /* Find first available buffer */

        for (i = 0; i < BITMASK_WORD_COUNT; i++)

        {

                tmp32 = get_first_zero_bit(SHM_Mgmt_Blk->shm_buff_mgmt_blk.buff_bit_mask[i]);

                if (tmp32 < BITMASK_WORD_SIZE)

                {

                        /* Calculate absolute index of the available buffer */

                        *p_idx = tmp32 + (i * BITMASK_WORD_SIZE);

                        /* Mark the buffer taken */

                        SHM_Mgmt_Blk->shm_buff_mgmt_blk.buff_bit_mask[i] |= 1 << tmp32;

                        status = MCAPI_SUCCESS;

                        break;

                }

        }

        return status;

}

static void clear_sm_buff_index(mcapi_uint32_t idx)

{

        mcapi_uint32_t *word;

        mcapi_uint32_t bit_msk_idx = idx/BITMASK_WORD_SIZE;

        mcapi_uint8_t  bit_idx = idx%BITMASK_WORD_SIZE;

        /* Mark the buffer available */

        word = &SHM_Mgmt_Blk->shm_buff_mgmt_blk.buff_bit_mask[bit_msk_idx];

        *word ^= 1 << bit_idx;

}

/*************************************************************************

*

*   FUNCTION

*

*       shm_get_buffer

*

*   DESCRIPTION

*

*       Obtain a Shared memory driver buffer.

*

*   INPUTS

*

*       None.

*

*   OUTPUTS

*

*       MCAPI_BUFFER*       Pointer to allocated MCAPI buffer

*

*************************************************************************/

static MCAPI_BUFFER* shm_get_buffer(mcapi_node_t node_id, size_t size,

                                    mcapi_uint32_t priority)

{

        mcapi_uint32_t  idx;

        SHM_BUFFER*     p_sm_buff = MCAPI_NULL;

        MCAPI_BUFFER*   p_mcapi_buff = MCAPI_NULL;

        mcapi_status_t  status = MCAPI_SUCCESS;

        /* Acquire lock of SM buffer management block */

        shm_acquire_lock(&SHM_Mgmt_Blk->shm_buff_mgmt_blk.lock);

        /* Check if obtained buff index is less than the buff count */

        if ((priority == SHM_PRIO_0) ||

                (SHM_Mgmt_Blk->shm_buff_mgmt_blk.shm_buff_count <= SHM_LOW_PRI_BUF_CONT))

        {

                for (idx = 0; idx < CONFIG_SHM_NR_NODES; idx++)

                {

                        if (SHM_Mgmt_Blk->shm_routes[idx].node_id == node_id)

                        {

                                /* Obtain the index of the first available SM buffer */

                                status = get_sm_buff_index(&idx);

#ifdef MCAPI_SM_DBG_SUPPORT

                                printf("Get buffer - priority  = %d \r\n",priority);

                                printf("Get buffer - obtained buffer index  = %d \r\n",idx);

#endif

                                if (status == MCAPI_SUCCESS)

                                {

                                        /* Obtain the address of the SM buffer for the index */

                                        p_sm_buff = (SHM_BUFFER*)OFFSET_TO_ADDRESS(SHM_Mgmt_Blk->shm_buff_mgmt_blk.shm_buff_base_offset + (sizeof(SHM_BUFFER)* idx));

                                        /* Obtain pointer to MCAPI buffer */

                                        p_mcapi_buff = &p_sm_buff->mcapi_buff;

                                        /* increment used buffer count */

                                        SHM_Mgmt_Blk->shm_buff_mgmt_blk.shm_buff_count++;

                                        break;

                                }

                        }

                }

        }

        /* Release lock of SM buffer management block */

        shm_release_lock(&SHM_Mgmt_Blk->shm_buff_mgmt_blk.lock);

        /* Return a MCAPI buffer to the caller */

        return p_mcapi_buff;

}

/*************************************************************************

*

*   FUNCTION

*

*       shm_free_buffer

*

*   DESCRIPTION

*

*       Free shared memory buffer.

*

*   INPUTS

*

*       SHM_BUFFER*          Pointer to SM buffer

*

*   OUTPUTS

*

*       None

*

*************************************************************************/

static void shm_free_buffer(MCAPI_BUFFER* buff)

{

        mcapi_uint32_t idx;

        /* Obtain the index of the buffer */

        idx = *((mcapi_uint32_t*)((mcapi_uint32_t)buff - (sizeof(mcapi_uint32_t))));

        shm_acquire_lock(&SHM_Mgmt_Blk->shm_buff_mgmt_blk.lock);

        /* Mark the buffer available */

        clear_sm_buff_index(idx);

        /* Decrement used buffer count */

        SHM_Mgmt_Blk->shm_buff_mgmt_blk.shm_buff_count--;

        shm_release_lock(&SHM_Mgmt_Blk->shm_buff_mgmt_blk.lock);

#ifdef MCAPI_SM_DBG_SUPPORT

        printf("Free buffer - freed index  = %d \r\n",idx);

#endif

}

/*************************************************************************

*

*   FUNCTION

*

*       get_sm_ring_q

*

*   DESCRIPTION

*

*       Obtain the SM packet descriptor ring queue for the node ID

*       requested.

*

*   INPUTS

*

*       mcapi_uint32_t      Destination node ID

*       mcapi_uint32_t*     Pointer to unit ID for the destination node

*

*   OUTPUTS

*

*       SHM_BUFF_DESC_Q*     Pointer to SM ring queue for requested node ID.

*

*************************************************************************/

static SHM_BUFF_DESC_Q* get_sm_ring_q(mcapi_uint32_t node_id,

                                      mcapi_uint32_t *p_unit_id)

{

        int idx;

        mcapi_uint32_t unit_id;

        SHM_BUFF_DESC_Q* p_sm_ring_queue = MCAPI_NULL;

        /* Look up routes for the requested node ID

         * and obtain the corresponding unit ID and SM ring queue */

        for (idx = 0; idx < CONFIG_SHM_NR_NODES; idx++)

        {

                if (SHM_Mgmt_Blk->shm_routes[idx].node_id == node_id)

                {

                        unit_id = SHM_Mgmt_Blk->shm_routes[idx].unit_id;

                        /* Load unit ID for the caller */

                        *p_unit_id = unit_id;

                        /* Obtain pointer to ring queue */

                        p_sm_ring_queue = &SHM_Mgmt_Blk->shm_queues[node_id];

                        break;

                }

        }

        /* Return pointer to SM ring queue for the unit ID identified */

        return p_sm_ring_queue;

}

/*************************************************************************

*

*   FUNCTION

*

*       enqueue_sm_ring_q

*

*   DESCRIPTION

*

*       Enqueue a transmission request to the SM descriptor ring queue.

*

*   INPUTS

*

*       SHM_BUFF_DESC_Q*     Pointer to the SM packet descriptor queue

*       mcapi_uint16_t      Destination node ID

*       SHM_BUFFER*          Pointer to the SM buffer (payload)

*       size_t              Size of the SM buffer (payload)

*       mcapi_uint8_t       Message type

*

*   OUTPUTS

*

*       mcapi_status_t      status of attempt to enqueue.

*

*************************************************************************/

static mcapi_status_t enqueue_sm_ring_q(SHM_BUFF_DESC_Q *shm_des_q,

                                        mcapi_node_t node_id,

                                        MCAPI_BUFFER *buff,

                                        mcapi_priority_t priority,

                                        size_t buff_size, mcapi_uint8_t type)

{

        mcapi_uint32_t idx;

        mcapi_status_t status = MCAPI_SUCCESS;

        SHM_BUFF_DESC* shm_desc;

        /* Acquire lock of the SM packet descriptor queue */

        shm_acquire_lock(&shm_des_q->lock);

        /* Obtain put index into the queue */

        idx = shm_des_q->put_idx;

        if (shm_des_q->count == SHM_BUFF_DESC_Q_SIZE)

        {

                /* Queue is full fail denqueue operation */

                status = MCAPI_ERR_TRANSMISSION;

        }

        else

        {

                /* Load packet descriptor */

                shm_desc = &shm_des_q->pkt_desc_q[idx];

                shm_desc->priority = priority;

                shm_desc->type = type;

                shm_desc->value = ADDRESS_TO_OFFSET(buff);

                shm_des_q->put_idx = (shm_des_q->put_idx + 1) % SHM_BUFF_DESC_Q_SIZE;

                shm_des_q->count++;

                /* Enqueue operation successfully completed */

                status = MCAPI_SUCCESS;

        }

        /* Release lock of the SM packet descriptor queue */

        shm_release_lock(&shm_des_q->lock);

        return status;

}

/*************************************************************************

*

*   FUNCTION

*

*       shm_tx

*

*   DESCRIPTION

*

*       Transmit data using SM driver.

*

*   INPUTS

*

*       None.

*

*   OUTPUTS

*

*       mcapi_status_t      Return status of initialization

*

*************************************************************************/

static mcapi_status_t shm_tx(MCAPI_BUFFER *buffer, size_t buffer_size,

                             mcapi_priority_t priority,

                             struct _mcapi_endpoint *tx_endpoint)

{

        SHM_BUFF_DESC_Q* shm_q;

        mcapi_uint32_t  unit_id;

        mcapi_uint32_t  node_id;

        mcapi_status_t  status = MCAPI_SUCCESS;

#ifdef MCAPI_SM_DBG_SUPPORT

        mcapi_uint32_t  add = (mcapi_uint32_t)buffer;

        printf("TX buffer - transmitting buffer address  = %x \r\n",add);

        printf("TX buffer - transmitting buffer size     = %d \r\n",buffer_size);

        printf("TX buffer - transmitting buffer priority = %d \r\n",priority);

#endif

        /* Obtain SM ring queue for the destination node ID */

        node_id = tx_endpoint->mcapi_foreign_node_id;

        shm_q = get_sm_ring_q(node_id, &unit_id);

        if (shm_q)

        {

                /* Enqueue request to transmit data */

                status = enqueue_sm_ring_q(shm_q, node_id, buffer, priority,

                        buffer_size, tx_endpoint->mcapi_chan_type);

                /* Resume Tasks suspensed on TX */

                mcapi_check_resume(MCAPI_REQ_TX_FIN, tx_endpoint->mcapi_endp_handle,

                                                   MCAPI_NULL, (buffer->buf_size - MCAPI_HEADER_LEN), status);

                /* Start data transmission */

                if (status == MCAPI_SUCCESS)

                {

                        status = openmcapi_shm_notify(unit_id, node_id);

#ifdef MCAPI_SM_DBG_SUPPORT

                        printf("TX buffer - TX success \r\n");

#endif

                }

        }

        else

        {

                /* TX request to unrecognized node ID */

                status = MCAPI_ERR_NODE_NOTINIT;

#ifdef MCAPI_SM_DBG_SUPPORT

                printf("TX buffer - TX Failed \r\n");

#endif

        }

        return status;

}

/*************************************************************************

*

*   FUNCTION

*

*       shm_finalize

*

*   DESCRIPTION

*

*       Finalization sequence for SM driver.

*

*   INPUTS

*

*       mcapi_node_t    Local node ID.

*

*       SHM_MGMT_BLOCK*  Pointer to SM driver management.

*       structure

*

*   OUTPUTS

*

*       mcapi_status_t          Initialization status.

*

*************************************************************************/

static mcapi_status_t shm_finalize(mcapi_node_t node_id,

                                   SHM_MGMT_BLOCK *SHM_Mgmt_Blk)

{

        int i;

        mcapi_status_t status = MCAPI_ERR_NODE_INITFAILED;

        for (i = 0; i < CONFIG_SHM_NR_NODES; i++)

        {

                if (SHM_Mgmt_Blk->shm_routes[i].node_id == node_id)

                {

                        status = MCAPI_SUCCESS;

                        SHM_Mgmt_Blk->shm_routes[i].node_id = SHM_INVALID_NODE;

                        SHM_Mgmt_Blk->shm_routes[i].unit_id = SHM_INVALID_SCH_UNIT;

                        break;

                }

        }

        /* Return finalization status */

        return status;

}

/*************************************************************************

*

*   FUNCTION

*

*       shm_ioctl

*

*   DESCRIPTION

*

*       IOCTL routine for the shared memory driver interface.

*

*   INPUTS

*

*       optname                 The name of the IOCTL option.

*       *option                 A pointer to memory that will be

*                               filled in if this is a GET option

*                               or the new value if this is a SET

*                               option.

*       optlen                  The length of the memory at option.

*

*   OUTPUTS

*

*       MCAPI_SUCCESS           The call was successful.

*       MCAPI_ERR_ATTR_NUM         Unrecognized option.

*       MCAPI_ERR_ATTR_SIZE        The size of option is invalid.

*

*************************************************************************/

static mcapi_status_t shm_ioctl(mcapi_uint_t optname, void *option,

                                size_t optlen)

{

        mcapi_status_t status = MCAPI_SUCCESS;

        switch (optname)

        {

                /* The total number of buffers in the system. */

                case MCAPI_ATTR_NO_BUFFERS:

                        /* Ensure the buffer can hold the value. */

                        if (optlen >= sizeof(mcapi_uint32_t))

                                *(mcapi_uint32_t *)option = SHM_BUFF_COUNT;

                        else

                                status = MCAPI_ERR_ATTR_SIZE;

                        break;

                /* The maximum size of an interface buffer. */

                case MCAPI_ATTR_BUFFER_SIZE:

                        /* Ensure the buffer can hold the value. */

                        if (optlen >= sizeof(mcapi_uint32_t))

                                *(mcapi_uint32_t *)option = MCAPI_MAX_DATA_LEN;

                        else

                                status = MCAPI_ERR_ATTR_SIZE;

                        break;

                /* The number of buffers available for receiving data. */

                case MCAPI_ATTR_RECV_BUFFERS_AVAILABLE:

                        /* Ensure the buffer can hold the value. */

                        if (optlen >= sizeof(mcapi_uint32_t))

                                *(mcapi_uint32_t *)option = SHM_Mgmt_Blk->shm_buff_mgmt_blk.shm_buff_count;

                        else

                                status = MCAPI_ERR_ATTR_SIZE;

                        break;

                /* The number of buffers available for receiving data. */

                case MCAPI_ATTR_NO_PRIORITIES:

                        /* Ensure the buffer can hold the value. */

                        if (optlen >= sizeof(mcapi_uint32_t))

                                *(mcapi_uint32_t *)option = SHM_NUM_PRIORITIES;

                        else

                                status = MCAPI_ERR_ATTR_SIZE;

                        break;

                /* The number of buffers available for receiving data. */

                case MCAPI_FINALIZE_DRIVER:

                        /* Finalize OS layer */

                        status = openmcapi_shm_os_finalize();

                        if (status == MCAPI_SUCCESS)

                        {

                                /* Finalize SM driver */

                                status = shm_finalize(MCAPI_Node_ID, SHM_Mgmt_Blk);

                        }

                        if (status == MCAPI_SUCCESS)

                        {

                                /* Unmap SM device */

                                openmcapi_shm_unmap((void*)SHM_Mgmt_Blk);

                        }

                        break;

                default:

                        status = MCAPI_ERR_ATTR_NUM;

                        break;

        }

        return status;

}

/*************************************************************************

*

*   FUNCTION

*

*       shm_master_node_init

*

*   DESCRIPTION

*

*       Initialize Shared memory driver as the Master node.

*

*   INPUTS

*

*       mcapi_node_t    Local node ID.

*

*       SHM_MGMT_BLOCK*  Pointer to SM driver management.

*       structure

*

*   OUTPUTS

*

*       mcapi_status_t              Initialization status.

*

*************************************************************************/

static mcapi_status_t shm_master_node_init(mcapi_node_t node_id,

                                           SHM_MGMT_BLOCK* SHM_Mgmt_Blk)

{

        int i;

        mcapi_status_t status = MCAPI_SUCCESS;

        /* The current node is the first node executing in the system.

         * Initialize SM driver as master node. */

        /* Initialize routes and SM buffer queue data structures */

        for (i = 0; i < CONFIG_SHM_NR_NODES; i++)

        {

                /* Initialize routes */

                SHM_Mgmt_Blk->shm_routes[i].node_id = SHM_INVALID_NODE;

                SHM_Mgmt_Blk->shm_routes[i].unit_id = SHM_INVALID_SCH_UNIT;

        }

        /* Initialize the base of shared memory buffers  */

        SHM_Buff_Array_Ptr = (SHM_BUFFER*)((((mcapi_uint32_t)SHM_Mgmt_Blk & (~(SHM_4K_ALIGN_SIZE - 1))) + SHM_4K_ALIGN_SIZE));

        /* Obtain the offset of the SM buffer space */

        SHM_Mgmt_Blk->shm_buff_mgmt_blk.shm_buff_base_offset = ADDRESS_TO_OFFSET(SHM_Buff_Array_Ptr);

        /* Initialize all SM buffers */

        for (i = 0; i < SHM_BUFF_COUNT; i++)

        {

                /* Initialize index and offset */

                SHM_Buff_Array_Ptr[i].idx = i;

        }

        /* Make all SM buffers available */

        for (i = 0; i < BITMASK_WORD_COUNT; i++)

        {

                SHM_Mgmt_Blk->shm_buff_mgmt_blk.buff_bit_mask[i] = 0;

        }

        /* Initialize used buff count */

        SHM_Mgmt_Blk->shm_buff_mgmt_blk.shm_buff_count = 0;

        /* Load the route for the current node */

        SHM_Mgmt_Blk->shm_routes[0].node_id = node_id;

        SHM_Mgmt_Blk->shm_routes[0].unit_id = openmcapi_shm_schedunitid();

        /* Load shared memory initialization complete key */

        SHM_Mgmt_Blk->shm_init_field = SHM_INIT_COMPLETE_KEY;

        /* Return master node initialization status */

        return status;

}

/*************************************************************************

*

*   FUNCTION

*

*       shm_slave_node_init

*

*   DESCRIPTION

*

*       Initialization sequence for SM driver for a slave node.

*

*   INPUTS

*

*       mcapi_node_id   Local node ID.

*

*       SHM_MGMT_BLOCK*  Pointer to SM driver management structure.

*

*   OUTPUTS

*

*       mcapi_status_t          Initialization status.

*

*************************************************************************/

static mcapi_status_t shm_slave_node_init(mcapi_node_t node_id,

                                          SHM_MGMT_BLOCK* SHM_Mgmt_Blk)

{

        int i;

        mcapi_status_t status = MCAPI_SUCCESS;

        /* SM driver has already been initialized by the master node */

        /* Perform slave initialization of SM driver */

        /* Make sure the current node has not been initialized */

        for (i = 0; i < CONFIG_SHM_NR_NODES; i++)

        {

                if (SHM_Mgmt_Blk->shm_routes[i].node_id == node_id)

                {

                        status = MCAPI_ERR_NODE_INITFAILED;

                        break;

                }

        }

        if (status == MCAPI_SUCCESS)

        {

                /* Load the route for the current node */

                for (i = 0; i < CONFIG_SHM_NR_NODES; i++)

                {

                        if (SHM_Mgmt_Blk->shm_routes[i].node_id == SHM_INVALID_NODE)

                        {

                                SHM_Mgmt_Blk->shm_routes[i].node_id = node_id;

                                SHM_Mgmt_Blk->shm_routes[i].unit_id = openmcapi_shm_schedunitid();

                                break;

                        }

                }

        }

        /* Return slave node initialization status */

        return status;

}

/*************************************************************************

*

*   FUNCTION

*

*       openmcapi_shm_init

*

*   DESCRIPTION

*

*       Initialize the Shared Memory driver interface.

*

*   INPUTS

*

*       None.

*

*   OUTPUTS

*

*       mcapi_status_t  Return status of initialization

*

*************************************************************************/

mcapi_status_t openmcapi_shm_init(mcapi_node_t node_id,

                                  MCAPI_INTERFACE* int_ptr)

{

        mcapi_status_t status = MCAPI_SUCCESS;

        if (node_id >= CONFIG_SHM_NR_NODES)

                return MCAPI_ERR_NODE_INVALID;

        /* Store the name of this interface. */

        memcpy(int_ptr->mcapi_int_name, OPENMCAPI_SHM_NAME, MCAPI_INT_NAME_LEN);

        /* Set the maximum buffer size for incoming / outgoing data. */

        int_ptr->mcapi_max_buf_size = MCAPI_MAX_DATA_LEN;

        /* Set up function pointers for sending data, reserving an outgoing

         * driver buffer, returning the buffer to the free list, and

         * issuing ioctl commands.

         */

        int_ptr->mcapi_tx_output = shm_tx;

        int_ptr->mcapi_get_buffer = shm_get_buffer;

        int_ptr->mcapi_recover_buffer = shm_free_buffer;

        int_ptr->mcapi_ioctl = shm_ioctl;

        /* Obtain Shared memory base address */

        SHM_Mgmt_Blk = openmcapi_shm_map();

        if (SHM_Mgmt_Blk != MCAPI_NULL)

        {

                /* Initialize OS specific component */

                openmcapi_shm_os_init();

                /* Obtain SM driver initialization lock */

                shm_acquire_lock(&SHM_Mgmt_Blk->shm_init_lock);

                /* Has another node completed SM driver initialization */