path: root/Acceleration/library/icp_telephony/tdm_io_access/icp_hssacc_common.c

/******************************************************************************
 * @file icp_hssacc_common.c
 *
 * @description Content of this file provides the implementation of
 * common functionality used by all modules of the HSS Access component
 *
 * @ingroup icp_HssAcc
 *
 * @Revision 1.0
 *
 * @par
 * This file is provided under a dual BSD/GPLv2 license.  When using or 
 *   redistributing this file, you may do so under either license.
 * 
 *   GPL LICENSE SUMMARY
 * 
 *   Copyright(c) 2007,2008,2009 Intel Corporation. All rights reserved.
 * 
 *   This program is free software; you can redistribute it and/or modify 
 *   it under the terms of version 2 of the GNU General Public License as
 *   published by the Free Software Foundation.
 * 
 *   This program is distributed in the hope that it will be useful, but 
 *   WITHOUT ANY WARRANTY; without even the implied warranty of 
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
 *   General Public License for more details.
 * 
 *   You should have received a copy of the GNU General Public License 
 *   along with this program; if not, write to the Free Software 
 *   Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 *   The full GNU General Public License is included in this distribution 
 *   in the file called LICENSE.GPL.
 * 
 *   Contact Information:
 *   Intel Corporation
 * 
 *   BSD LICENSE 
 * 
 *   Copyright(c) 2007,2008,2009 Intel Corporation. All rights reserved.
 *   All rights reserved.
 * 
 *   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.
 * 
 * 
 *
 *
 *****************************************************************************/

#include "IxOsal.h"

#include "icp.h"
#include "icp_hssacc.h"
#include "icp_hssacc_common.h"
#include "icp_hssacc_trace.h"

/*
 * The command ID offset for TDM I/O Unit messages
 */
#define HSSACC_TDM_IO_UNIT_CMD_ID_OFFSET (ICP_HSSACC_TDM_IO_UNIT_BYTE0_OFFSET)

/*
 * The mask for the command ID in TDM I/O Unit messages
 */
#define HSSACC_TDM_IO_UNIT_CMD_ID_MASK          \
  (0xFF << HSSACC_TDM_IO_UNIT_CMD_ID_OFFSET)

/*
 * The length of time to sleep while waiting for the TDM I/O Unit to
 * respond (in milliseconds)
 */
#define HSSACC_TDM_IO_UNIT_WAIT_SLEEP_TIMEOUT (10)

/*
 * The number of times the HssAcc component will sleep while waiting for a
 * response message from the TDM I/O Unit before triggering a time-out.
 */
#define HSSACC_TDM_IO_UNIT_MAX_NUM_SLEEPS (100)


/*****************************************************************************
 * Abstract:
 *    This struct is used to notify a function that the TDM I/O unit has
 *    replied to the message previously submitted to it.
 *    Typically, the function that submitted the message will poll
 *    respReceived. When this flag is set (in the context of this callback),
 *    the polling client knows that a response has been generated for the
 *    message it submitted.
 *
 * Fields:
 *    respMsg - A 2 element array which is used to save the message response.
 *    respReceived - A boolean flag used to notify the polling client of the
 *                   TDM I/O Unit's response.
 *
 *****************************************************************************/
typedef struct icp_hss_acc_tdm_io_unit_resp_msg_s
{
  IxPiuMhMessage respMsg;
  volatile icp_boolean_t respReceived;
} icp_hss_acc_tdm_io_unit_resp_msg_t;


/*****************************************************************************
 * Abstract:
 *    Static variable used to store the most recent message response from the
 *    the TDM I/O Unit.
 *
 *****************************************************************************/
TDM_PRIVATE icp_hss_acc_tdm_io_unit_resp_msg_t tdmIOUnitResponseMessage;


/*
 * Function prototypes
 */
TDM_PRIVATE
void HssAccTdmIOUnitCmdRespCallback(
                                    IxPiuMhPiuId piuId,
                                    IxPiuMhMessage msg);

TDM_PRIVATE
icp_status_t
HssAccComTdmIOUnitCmdMsgWait (volatile icp_boolean_t *const flagToWaitFor);

TDM_PRIVATE
icp_status_t
HssAccComTdmIOUnitCmdMsgSend(
                             IxPiuMhMessage message,
                             icp_boolean_t reqResp,
                             volatile icp_boolean_t *const flagToWaitFor,
                             IxPiuMhCallback respCallback,
                             uint8_t solicitedPiuMsgId);


/*****************************************************************************
 * Abstract:
 *    Constructs a 4-byte, 1-word TDM I/O Unit message.
 *
 *
 *****************************************************************************/
void
HssAccComTdmIOUnitCmd4byte1wordMsgCreate (uint32_t byte0,
                                          uint32_t byte1,
                                          uint32_t byte2,
                                          uint32_t byte3,
                                          uint32_t word,
                                          IxPiuMhMessage *pMessage)
{
  /* create the message */
  pMessage->data[0] =
    (byte3 << ICP_HSSACC_TDM_IO_UNIT_BYTE3_OFFSET) |
    (byte2 << ICP_HSSACC_TDM_IO_UNIT_BYTE2_OFFSET) |
    (byte1 << ICP_HSSACC_TDM_IO_UNIT_BYTE1_OFFSET) |
    (byte0 << ICP_HSSACC_TDM_IO_UNIT_BYTE0_OFFSET);
  pMessage->data[1] = word;
  ICP_HSSACC_TRACE_2 (ICP_HSSACC_DEBUG,
                      "HssAccComTdmIOUnitCmd4byte1wordMsgCreate "
                      "0x%08X 0x%08X\n",
                      pMessage->data[0], pMessage->data[1]);
}


/*****************************************************************************
 * Abstract:
 *    Constructs an 8-byte TDM I/O Unit message.
 *
 *
 *****************************************************************************/
void
HssAccComTdmIOUnitCmd8byteMsgCreate (uint32_t byte0,
                                     uint32_t byte1,
                                     uint32_t byte2,
                                     uint32_t byte3,
                                     uint32_t byte4,
                                     uint32_t byte5,
                                     uint32_t byte6,
                                     uint32_t byte7,
                                     IxPiuMhMessage *pMessage)
{


  /* Create the TDM I/O Unit message format */
  pMessage->data[0] =
    (byte3 << ICP_HSSACC_TDM_IO_UNIT_BYTE3_OFFSET) |
    (byte2 << ICP_HSSACC_TDM_IO_UNIT_BYTE2_OFFSET) |
    (byte1 << ICP_HSSACC_TDM_IO_UNIT_BYTE1_OFFSET) |
    (byte0 << ICP_HSSACC_TDM_IO_UNIT_BYTE0_OFFSET);

  pMessage->data[1] =
    (byte7 << ICP_HSSACC_TDM_IO_UNIT_BYTE3_OFFSET) |
    (byte6 << ICP_HSSACC_TDM_IO_UNIT_BYTE2_OFFSET) |
    (byte5 << ICP_HSSACC_TDM_IO_UNIT_BYTE1_OFFSET) |
    (byte4 << ICP_HSSACC_TDM_IO_UNIT_BYTE0_OFFSET);

  ICP_HSSACC_TRACE_2(ICP_HSSACC_DEBUG,
                     "HssAccComTdmIOUnitCmd8byteMsgCreate 0x%08X 0x%08X\n",
                     pMessage->data[0], pMessage->data[1]);
}





/*****************************************************************************
 * Abstract:
 *    Submits a message to the TDM I/O Unit, waits for a response and verifies
 *    that the correct response was received, response word is
 *    passed back to client
 *
 *
 *****************************************************************************/
icp_status_t
HssAccComTdmIOUnitMsgSendAndRecv(IxPiuMhMessage message,
                                 uint8_t response,
                                 icp_hssacc_msg_with_resp_stats_t * stats,
                                 uint32_t * responseWord)
{
  icp_status_t status = ICP_STATUS_SUCCESS;
  uint8_t cmdType = 0;
  ICP_HSSACC_TRACE_0 (ICP_HSSACC_FN_ENTRY_EXIT,
                      "Entering HssAccTdmIOUnitMsgSendAndRecv\n");
  status =
    HssAccComTdmIOUnitCmdMsgSend (message,
                                  TRUE,
                                  &(tdmIOUnitResponseMessage.respReceived),
                                  HssAccTdmIOUnitCmdRespCallback,
                                  response);
  if (ICP_STATUS_SUCCESS == status)
    {
      stats->numTdmIOUnitMessagesSent ++;
      stats->numTdmIOUnitRespReceived ++;
      /* Extract the command ID from the message */
      cmdType = ( (tdmIOUnitResponseMessage.respMsg.data[0] &
                   HSSACC_TDM_IO_UNIT_CMD_ID_MASK) >>
                  HSSACC_TDM_IO_UNIT_CMD_ID_OFFSET );

      if (cmdType != response)
        {
          stats->numTdmIOUnitInvalidResp ++;
          ICP_HSSACC_REPORT_ERROR_2("HssAccComTdmIOUnitmsgSendAndRecv - "
                                    "TDM I/O Unit provided invalid response\n"
                                    "Expected %u Cmd and got %u\n",
                                    cmdType, response);
          status = ICP_STATUS_FATAL;
        }
    }
  else if (ICP_STATUS_FATAL == status)
    {
      stats->numTdmIOUnitMessagesSent ++;
      stats->numTdmIOUnitTimeoutErrs ++;
    }

  if (ICP_STATUS_SUCCESS == status)
    {
      if (NULL != responseWord)
        {
          *responseWord =
            tdmIOUnitResponseMessage.respMsg.data[1];
        }
    }

  ICP_HSSACC_TRACE_0 (ICP_HSSACC_FN_ENTRY_EXIT,
                      "Exiting HssAccTdmIOUnitMsgSendAndRecv\n");
  return status;
}


/*****************************************************************************
 * Abstract:
 *    This callback is triggered by the TDM I/O unit in response to a message.
 *
  *
 *****************************************************************************/
TDM_PRIVATE
void HssAccTdmIOUnitCmdRespCallback(IxPiuMhPiuId piuId,
                                    IxPiuMhMessage msg)
{
  ICP_HSSACC_TRACE_0 (ICP_HSSACC_FN_ENTRY_EXIT,
                      "Entering HssAccTdmIOUnitCmdRespCallback\n");

  tdmIOUnitResponseMessage.respMsg = msg;

  ICP_HSSACC_TRACE_3 (ICP_HSSACC_DEBUG,
                      "HssAccTdmIOUnitCmdRespCallback 0x%08X 0x%08X "
                      "from TDM I/O Unit %u\n",
                      msg.data[0], msg.data[1],
                      piuId);
  ICP_HSSACC_TRACE_0 (ICP_HSSACC_FN_ENTRY_EXIT,
                      "Exiting HssAccTdmIOUnitCmdRespCallback\n");

  /* This must be the last step in the callback */
  tdmIOUnitResponseMessage.respReceived = TRUE;
}


/*****************************************************************************
 * Abstract:
 *    Sleeps until the specified flag is set (this occurs in
 *    HssAccTdmIOUnitCmdRespCallback), or times out and returns an error.
 *
 *
 *****************************************************************************/
TDM_PRIVATE
icp_status_t
HssAccComTdmIOUnitCmdMsgWait (volatile icp_boolean_t *const flagToWaitFor)
{
  icp_status_t status = ICP_STATUS_SUCCESS;
  uint32_t numSleepsWithNoResp = 0;

  ICP_HSSACC_TRACE_0 (ICP_HSSACC_FN_ENTRY_EXIT,
                      "Entering HssAccComTdmIOUnitCmdMsgWait\n");

  ICP_HSSACC_TRACE_0 (ICP_HSSACC_DEBUG,
                      "HssAccComTdmIOUnitCmdMsgWait - "
                      "Waiting on the TDM I/O Unit to respond...\n");

  /* wait until a response is received */
  while (numSleepsWithNoResp < HSSACC_TDM_IO_UNIT_MAX_NUM_SLEEPS)
    {
      if (TRUE == *flagToWaitFor)
        {
          ICP_HSSACC_TRACE_0 (ICP_HSSACC_DEBUG,
                              "HssAccComTdmIOUnitCmdMsgWait - "
                              "TDM I/O Unit responded\n");
          break;
        }
      numSleepsWithNoResp ++;
      ixOsalSleep (HSSACC_TDM_IO_UNIT_WAIT_SLEEP_TIMEOUT);
    }

  /* check for timeout */
  if (HSSACC_TDM_IO_UNIT_MAX_NUM_SLEEPS == numSleepsWithNoResp)
    {
      ICP_HSSACC_REPORT_ERROR("HssAccComTdmIOUnitCmdMsgWait - "
                              "TDM I/O Unit failed to respond in time\n");
      status = ICP_STATUS_FATAL;
    }

  ICP_HSSACC_TRACE_0 (ICP_HSSACC_FN_ENTRY_EXIT,
                      "Exiting HssAccComTdmIOUnitCmdMsgWait\n");

  return status;
}


/*****************************************************************************
 * Abstract:
 *    Submits a message to the TDM I/O Unit and waits for the specified
 *    response from the TDM I/O Unit (if specified).
 *
 *
 *****************************************************************************/
TDM_PRIVATE
icp_status_t
HssAccComTdmIOUnitCmdMsgSend(
                             IxPiuMhMessage message,
                             icp_boolean_t reqResp,
                             volatile icp_boolean_t *const flagToWaitFor,
                             IxPiuMhCallback respCallback,
                             uint8_t solicitedPiuMsgId)
{
  icp_status_t status = ICP_STATUS_SUCCESS;
  IX_STATUS mhStatus = IX_SUCCESS;

  ICP_HSSACC_TRACE_0 (ICP_HSSACC_FN_ENTRY_EXIT,
                      "Entering HssAccComTdmIOUnitCmdMsgSend\n");

  ICP_HSSACC_TRACE_2 (ICP_HSSACC_DEBUG,
                      "HssAccComTdmIOUnitCmdMsgSend\n",
                      message.data[0], message.data[1]);

  /* check if a response is required */
  if (TRUE == reqResp)
    {
      ICP_HSSACC_TRACE_0 (ICP_HSSACC_DEBUG,
                          "HssAccComTdmIOUnitCmdMsgSend - "
                          "Calling ixPiuMhMessageWithResponseSend\n");

      /* Send the message to the Programmable I/O Unit
         (TDM I/O Unit in this case)  */
      *flagToWaitFor = FALSE;
      mhStatus = ixPiuMhMessageWithResponseSend(IX_PIUMH_PIUID_PIU0,
                                              message,
                                              solicitedPiuMsgId,
                                              respCallback,
                                              IX_PIUMH_SEND_RETRIES_DEFAULT);
    }
  else
    {
      ICP_HSSACC_TRACE_0 (ICP_HSSACC_DEBUG,
                          "HssAccComTdmIOUnitCmdMsgSend - "
                          "Calling ixPiuMhMessageSend\n");

      /* Send the message to the PiuMh */
      mhStatus = ixPiuMhMessageSend (IX_PIUMH_PIUID_PIU0,
                                   message,
                                   IX_PIUMH_SEND_RETRIES_DEFAULT);
    }

  /* check the return from the Message Handler and block for response if
     requested */
  if (IX_SUCCESS != mhStatus)
    {
      /* report the error */
      ICP_HSSACC_REPORT_ERROR ("HssAccComTdmIOUnitCmdMsgSend - "
                               "Message Handler failed to send\n");
      /* set return status */
      status = ICP_STATUS_FAIL;
    }
  else
    {
      /* wait for a response from the TDM I/O Unit if one is expected */
      if (TRUE == reqResp)
        {
          status = HssAccComTdmIOUnitCmdMsgWait (flagToWaitFor);
        }
    }

  ICP_HSSACC_TRACE_0 (ICP_HSSACC_FN_ENTRY_EXIT,
                      "Exiting HssAccComTdmIOUnitCmdMsgSend\n");

  return status;
}




/*****************************************************************************
 * Abstract:
 *    Single message stat struct show
 *
 *
 *****************************************************************************/
void HssAccSingleMessageStatsShow (icp_hssacc_msg_with_resp_stats_t stat)
{
  ixOsalLog(IX_OSAL_LOG_LVL_MESSAGE,
            IX_OSAL_LOG_DEV_STDOUT,
            "\n\t%u messages Sent\n\t%u messages received\n\t"
            "%u invalid responses\t\n%u timeouts\n",
            stat.numTdmIOUnitMessagesSent, stat.numTdmIOUnitRespReceived,
            stat.numTdmIOUnitInvalidResp, stat.numTdmIOUnitTimeoutErrs, 0, 0);
}