GD32F450_BMC_BaseCode/app/bmc/msghndlr/Transport/SerialModem.c

// /*****************************************************************
//  *****************************************************************
//  ***                                                            **
//  ***    (C)Copyright 2005-2006, American Megatrends Inc.        **
//  ***                                                            **
//  ***            All Rights Reserved.                            **
//  ***                                                            **
//  ***        6145-F, Northbelt Parkway, Norcross,                **
//  ***                                                            **
//  ***        Georgia - 30071, USA. Phone-(770)-246-8600.         **
//  ***                                                            **
//  ***************************************************************** ****************************************************************
//  *
//  * SerialModem.c
//  * Serial/Modem configuration , Callback &  MUX
//  *
//  *  Author: Govindarajan <govindarajann@amiindia.co.in>
//  *          Vinoth Kumar <vinothkumars@amiindia.co.in>
//  ****************************************************************/
// #define ENABLE_DEBUG_MACROS 0
// #include "Types.h"
// #include "Debug.h"
// #include "IPMI_Main.h"
// #include "MsgHndlr.h"
// #include "Support.h"
// #include "IPMIDefs.h"
// #include "IPMI_SerialModem.h"
// #include "SerialModem.h"
// #include "SharedMem.h"
// #include "AppDevice.h"
// #include "Message.h"
// #include "PMConfig.h"
// #include "Util.h"
// #include "SerialIfc.h"
// #include "NVRAccess.h"
// #include "IPMIConf.h"
// #include "PDKDefs.h"
// #include "PDKAccess.h"


// /* Reserved bit macro definitions */
// #define RESERVED_BITS_SETSERIALMODEMCONFIG_CH           0xF0 //(BIT7 | BIT6 | BIT5 | BIT4)
// #define RESERVED_BITS_SETSERIALMODEMCONFIG_SERINPRO     0xFC //(BIT7 | BIT6 | BIT5 | BIT4 | BIT3 | BIT2)

// #define RESERVED_BITS_GETSERIALMODEMCONFIG_REVCH        0X70 //(BIT6 | BIT5 | BIT4)

// #define RESERVED_BITS_CALLBACK_CH                       0xF0 //(BIT7 | BIT6 | BIT5 | BIT4)
// #define RESERVED_BITS_CALLBACK_DESTSEL                  0xF0 //(BIT7 | BIT6 | BIT5 | BIT4)

// #define RESERVED_BITS_SETUSERCALLBACKOPT_USRID          0XC0 //(BIT7 | BIT6)
// #define RESERVED_BITS_SETUSERCALLBACKOPT_CH             0XF0 //(BIT7 | BIT6 | BIT5 | BIT4)
// #define RESERVED_BITS_SETUSERCALLBACKOPT_USRCALLBAKCAP  0xFC //(BIT7 | BIT6 | BIT5 | BIT4 | BIT3 | BIT2)
// #define RESERVED_BITS_SETUSERCALLBACKOPT_CBCNEGOPT      0XF0 //(BIT7 | BIT6 | BIT5 | BIT4)

// #define RESERVED_BITS_GETUSERCALLBACKOPTIONS_USRID      0XC0 //(BIT7 | BIT6)

// #define RESERVED_BITS_SETSERIALMODEMMUX_CH              0XF0 //(BIT7 | BIT6 | BIT5 | BIT4)
// #define RESERVED_BITS_SETSERIALMODEMMUX_MUXSETREQ       0XF0 //(BIT7 | BIT6 | BIT5 | BIT4)

// #define RESERVED_BITS_SERIALMODEMCONNECTACTIVE          0XF0 //(BIT7 | BIT6 | BIT5 | BIT4)

// #define RESERVED_BITS_GETTAPRESPONSECODES_CH            0XF0 //(BIT7 | BIT6 | BIT5 | BIT4)

// /*** Local Typedefs ***/
// /**
//  * @struct SMConfigTable_T
//  * @brief Serial Modem Configuration Table.
// **/

// #pragma pack( )
// typedef struct
// {
//     INT8U   ParamFlags;
//     INT8U   MaxSetSelector;
//     INT8U   MaxBlockSelector;
//     unsigned long  Offset;
//     INT8U   Size;

// } PACKED SMConfigTable_T;

// #pragma pack( )

// /**
//  * @struct RsvdBitsTable_T
//  * @brief Reserved Bits Table.
// **/

// #pragma pack (1)
// typedef struct
// {
//     INT8U   Param;
//     INT8U   Length;

// } PACKED RsvdBitsTable_T;


// #pragma pack( )


// /*** Local Definitions ***/
// #define PARAM_VOLATILE                  0x01
// #define PARAM_NON_VOLATILE              0x02
// #define PARAM_VOLATILE_NON_VOLATILE     0x04
// #define PARAM_READ_ONLY                 0x08
// #define PARAM_WRITE_ONLY                0x10
// #define CHECK_RSVD_BITS                 0x20
// #define BLOCK_SELECTOR_REQ              0x80

// #define GET_PARAM_REV_ONLY              0x80
// #define PARAM_REVISION                  0x11

// #define SET_IN_PROGRESS                 1
// #define SET_COMPLETE                    0
// #define SET_BAUD_RATE                   7
// #define SET_BAD_PWD_THRESHOLD           54

// #define INIT_STR_PARAM                  10

// /* Set Serial Port Mux */
// #define REQ_CUR_MUX_SETTING             0
// #define REQ_MUX_TO_SYS                  1
// #define REQ_MUX_TO_BMC                  2
// #define REQ_MUX_FORCE_TO_SYS            3
// #define REQ_MUX_FORCE_TO_BMC            4
// #define REQ_BLOCK_MUX_TO_SYS            5
// #define REQ_ALLOW_MUX_TO_SYS            6
// #define REQ_BLOCK_MUX_TO_BMC            7
// #define REQ_ALLOW_MUX_TO_BMC            8

// #define REQ_MUX_TO_SYS_MASK             0x80
// #define REQ_MUX_TO_BMC_MASK             0x40

// #define SET_MUX_TO_SYS_MASK             0xFE
// #define SET_MUX_TO_BMC_MASK             0x1

// #define ALLOW_MUX_TO_SYS_MASK           0x7F
// #define BLOCK_MUX_TO_SYS_MASK           0x80
// #define ALLOW_MUX_TO_BMC_MASK           0xBF
// #define BLOCK_MUX_TO_BMC_MASK           0x40

// #define MUX_REQ_ACCEPTED_MASK           0x02
// #define MUX_REQ_REJECTED_MASK           0xFD
// #define MUX_SESSION_ACTIVE_MASK         0x04
// #define MUX_SESSION_ALERT_INACTIVE_MASK 0xF3
// #define MUX_ALERT_IN_PROGRESS_MASK      0x08

// #define SERIAL_PORT_SHARING_ENABLED     0x08

// #define IPMI_CALLBACK_MASK              1
// #define CBCP_CALLBACK_MASK              2

// #define SESSION_STATE_ACTIVE            1
// #define SESSION_STATE_INACTIVE          0
// #define DIRECT_PING_ENABLE_MASK         2
// #define MUX_SWITCHED_TO_SYS             2

// #define PING_MSG_ACTIVE_BIT             0x01

// #define BAUD_RATE_9600          		6
// #define BAUD_RATE_19200         		7
// #define BAUD_RATE_38400         		8
// #define BAUD_RATE_57600         		9
// #define BAUD_RATE_115200        		10

// #define NO_FLOWCONTROL          		0
// #define HARDWARE_FLOWCONTROL    		1
// #define XON_XOFF_FLOWCONTRO     		2

// #define SERIAL_BAUD_RATE            0x0F

// #define SM_OFFSET(MEMBER)               (unsigned long)&(((SMConfig_T*) 0)->MEMBER)


// /**
//  * @brief SerialModem Validation Info Table
// **/
// const SMConfigTable_T SMConfigTable [] =
// {
//     { PARAM_VOLATILE,               0,                          0,                              SM_OFFSET (SetInProgress),          1                           },  // Set In Progress
//     { PARAM_READ_ONLY,              0,                          0,                              SM_OFFSET (AuthTypeSupport),        1                           },  // Authentication Type Support
//     { PARAM_NON_VOLATILE | \
//                 CHECK_RSVD_BITS,    0,                          0,                              SM_OFFSET (AuthTypeEnable),         sizeof (AuthTypeEnable_T)   },  // Authetication Type enable
//     { PARAM_NON_VOLATILE | \
//                 CHECK_RSVD_BITS,    0,                          0,                              SM_OFFSET (ConnectionMode),         1,                          },  // Connection Mode
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (SessionInactivity),1                         },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (ChannelCallBackCtrl),    sizeof (ChannelCallbackCtrl_T)  },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (SessionTermination),     1                               },
//     { PARAM_NON_VOLATILE | \
//                 CHECK_RSVD_BITS,    0,                          0,                              SM_OFFSET (IpmiMsgCommSet),         sizeof (IpmiMsgCommSettings_T)  },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (MUXSwitchCtrl),          sizeof (MuxSwitchCtrl_T)        },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (RingTime),               sizeof (ModemRingTime_T)        },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_MODEM_INIT_STR_BLOCKS,  0,                              SM_OFFSET (ModemInitString [0] [0]),MAX_MODEM_INIT_STR_BLOCK_SIZE + 0x80    },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (ModemEscapeSeq [0]),     MAX_MODEM_ESC_SEQ_SIZE      },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (ModemHangup [0]),        MAX_MODEM_HANG_UP_SEQ_SIZE  },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (ModemDialCmd [0]),       MAX_MODEM_DIAL_CMD_SIZE     },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (PageBlockOut),           1                           },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (CommunityString [0]),    MAX_COMM_STRING_SIZE        },
//     { PARAM_READ_ONLY,              0,                          0,                              SM_OFFSET (TotalAlertDest),         1                           },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_SERIAL_ALERT_DESTINATIONS,0,                            SM_OFFSET (DestinationInfo [0]),        sizeof (DestInfo_T)         },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (CallRetryInterval),      1                           },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_SERIAL_ALERT_DESTINATIONS,0,                            SM_OFFSET (DestComSet [0]),             sizeof (ModemDestCommSettings_T)    },
//     { PARAM_READ_ONLY,              0,                          0,                              SM_OFFSET (TotalDialStr),           1                           },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_MODEM_DIAL_STRS + 0x80, MAX_MODEM_DIAL_STR_BLOCKS,      SM_OFFSET (DestDialStrings [0] [0] [0]),MAX_MODEM_DIAL_STR_BLOCK_SIZE + 0x80},
//     { PARAM_READ_ONLY,              0,                          0,                              SM_OFFSET (TotalDestIP),            1                           },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_MODEM_ALERT_DEST_IP_ADDRS,0,                            SM_OFFSET (DestAddr [0]),           sizeof (DestIPAddr_T)       },
//     { PARAM_READ_ONLY,              0,                          0,                              SM_OFFSET (TotalTAPAcc),            1                           },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_MODEM_TAP_ACCOUNTS,     0,                              SM_OFFSET (TAPAccountSelector[0]),  1                           },
//     { PARAM_VOLATILE_NON_VOLATILE | \
//                 PARAM_WRITE_ONLY,   MAX_MODEM_TAP_ACCOUNTS,     0,                              SM_OFFSET (TAPPasswd [0] [0]),      TAP_PASSWORD_SIZE           },
//     { PARAM_NON_VOLATILE,           MAX_MODEM_TAP_ACCOUNTS,     0,                              SM_OFFSET (TAPPagerIDStrings [0] [0]),TAP_PAGER_ID_STRING_SIZE  },
//     { PARAM_NON_VOLATILE,           MAX_MODEM_TAP_ACCOUNTS,     0,                              SM_OFFSET (TAPServiceSettings [0]), sizeof (TAPServiceSettings_T)},
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (Termconfig),             sizeof (TermConfig_T)       },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (PPPProtocolOptions),     sizeof (PPPProtocolOptions_T)},
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (PPPPrimaryRMCPPort),     sizeof (INT16U)             },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (PPPSecondaryRMCPPort),   sizeof (INT16U)             },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (PPPLinkAuth),            1                           },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (CHAPName [0]),           MAX_MODEM_CHAP_NAME_SIZE + 0x80},
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (PPPACCM),                sizeof (PPPAccm_T)          },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (PPPSnoopACCM),           sizeof (PPPSnoopAccm_T)     },
//     { PARAM_READ_ONLY,              0,                          0,                              SM_OFFSET (TotalPPPAcc),            1                           },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_MODEM_PPP_ACCOUNTS,     0,                              SM_OFFSET (PPPAccDialStrSel [0]),   1                           },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_MODEM_PPP_ACCOUNTS,     0,                              SM_OFFSET (PPPAccIPAddress [0] [0]),IP_ADDR_LEN         },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_MODEM_PPP_ACCOUNTS,     0,                              SM_OFFSET (PPPAccUserNames [0] [0]),PPP_ACC_USER_NAME_DOMAIN_PASSWD_SIZE + 0x80 },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_MODEM_PPP_ACCOUNTS,     0,                              SM_OFFSET (PPPAccUserDomain [0] [0]),PPP_ACC_USER_NAME_DOMAIN_PASSWD_SIZE + 0x80},
//     { PARAM_VOLATILE_NON_VOLATILE | \
//       PARAM_WRITE_ONLY,             MAX_MODEM_PPP_ACCOUNTS,     0,                              SM_OFFSET (PPPAccUserPasswd [0] [0]),PPP_ACC_USER_NAME_DOMAIN_PASSWD_SIZE + 0x80},
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_MODEM_PPP_ACCOUNTS,     0,                              SM_OFFSET (PPPAccAuthSettings [0]), 1                           },
//     { PARAM_VOLATILE_NON_VOLATILE,  MAX_MODEM_PPP_ACCOUNTS,     0,                              SM_OFFSET (PPPAccConnHoldTimes [0]),1                           },
//     { PARAM_NON_VOLATILE,           0,                          0,                              SM_OFFSET (PPPUDPProxyIPHeadData),sizeof (PPPUDPProxyIPHeaderData_T)    },
//     { PARAM_READ_ONLY,              0,                          0,                              SM_OFFSET (PPPUDPProxyTransmitBuffSize),2                       },
//     { PARAM_READ_ONLY,              0,                          0,                              SM_OFFSET (PPPUDPProxyReceiveBuffSize),2                        },
//     { PARAM_READ_ONLY,              0,                          0,                              SM_OFFSET (PPPRemoteConsoleIPAdd [0]),IP_ADDR_LEN           },
//     {0,                             0,                          0,                                                                  0,                     0},
//     {0,                             0,                          0,                                                                  0,                     0},
//     {0,                             0,                          0,                                                                  0,                     0},
//     {0,                             0,                          0,                                                                  0,                     0},
//     {0,                             0,                          0,                                                                  0,                     0},
//     { PARAM_NON_VOLATILE,             0,                          0,                              SM_OFFSET (BadPasswd),sizeof(BadPassword_T)          },

// };


// /**
//  * @brief SerialModem Reserved Bits Validation Info Table
// **/
// const INT8U ReservedBitsTable [] =
// {
//     /*Param,    Length, ReservedBits Masks*/
//      2,         5,      0xc8,0xc8,0xc8,0xc8,0xc8,
//      3,         1,      0x78,
//      7,         2,      0x0f,0xf0,
// };


// /*** Prototype Declarations ***/
// static _FAR_ INT8U* getSMConfigAddr (_FAR_ const SMConfigTable_T* SMEntry,
//                                                  INT8U            SetSelector,
//                                                  INT8U            BlockSelector,
//                                                  int			  BMCInst);
// static _FAR_ ChannelUserInfo_T* GetCBChUserInfo (INT8U UserID, INT8U Channel );
// static  int     SetSerialPort (int BMCInst);


// /*---------------------------------------
//  * SetSerialModemConfig
//  *---------------------------------------*/
// int
// SetSerialModemConfig (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst)
// {
//     _NEAR_ SetSerialModemConfigReq_T* SetReq =
//                               (_NEAR_ SetSerialModemConfigReq_T*) pReq;
//     const  SMConfigTable_T*           SMEntry;
//     _NEAR_ RsvdBitsTable_T*           RsvdEntry;
//     INT8U                      SetSelector;
//     INT8U                      BlockSelector;
//     INT8U                      ReqStartOffset,i,tempdata;
//     _FAR_  INT8U*                     SetStart;
//     _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];
//     INT8U  m_Serial_SetInProgress; /**< Contains setting Serial configuration status */

//     IPMI_DBG_PRINT ("Set SerialModem Configuration Cmd\n");

// 	if(SetReq->ChannelNo & RESERVED_BITS_SETSERIALMODEMCONFIG_CH)
// 	{
// 		*pRes = CC_INV_DATA_FIELD;
// 		return sizeof(*pRes);
// 	}

//     /* Verify if the Channel number & param selector is valid */
//     if (SetReq->ChannelNo != pBMCInfo->SERIALch)
//     {
//         *pRes = CC_INV_DATA_FIELD;
//         return sizeof (*pRes);
//     }

//     if (SetReq->ParamSel >= sizeof (SMConfigTable) / sizeof (SMConfigTable [0]))
//     {
//         *pRes = CC_PARAM_NOT_SUPPORTED;
//         return sizeof (*pRes);
//     }

//     SMEntry = &(SMConfigTable [SetReq->ParamSel]);

//     /*Adjust length if Set Selector Needed */
//     if (0 != (SMEntry->MaxSetSelector & 0x7f))
//     {
//         ReqLen--;
//     }

//     /*Adjust length if Block Selector Needed */
//     if (0 != (SMEntry->MaxSetSelector & BLOCK_SELECTOR_REQ))
//     {
//         ReqLen--;
//     }

//     /* Verify length */
//     if (0 == (SMEntry->Size & 0x80))
//     {
//         if ((ReqLen - sizeof (SetSerialModemConfigReq_T)) != SMEntry->Size)
//         {
//             *pRes = CC_REQ_INV_LEN;
//             return sizeof (*pRes);
//         }
//     }
//     else
//     {
//         IPMI_DBG_PRINT_1 ("ReqLen = %d\n",ReqLen);
//         if ((ReqLen - sizeof (SetSerialModemConfigReq_T)) > (SMEntry->Size & 0x7f))
//         {
//             *pRes = CC_REQ_INV_LEN;
//             return sizeof (*pRes);
//         }
//     }

//     LOCK_BMC_SHARED_MEM(BMCInst);
//     m_Serial_SetInProgress = BMC_GET_SHARED_MEM(BMCInst)->m_Serial_SetInProgress;
//     UNLOCK_BMC_SHARED_MEM(BMCInst);
//     /*Process Set In Progress parameter */
//     if (SetReq->ParamSel == SET_IN_PROGRESS_PARAM)
//     {
// 		if((pReq[2] & RESERVED_BITS_SETSERIALMODEMCONFIG_SERINPRO))
// 		{
// 			*pRes = CC_INV_DATA_FIELD;
// 			return sizeof(*pRes);
// 		}

//         /* Commit Write is optional and supported
//          * only if rollback is supported */
//         if ((SET_COMPLETE != pReq [2]) && (SET_IN_PROGRESS != pReq [2]))
//         {
//             *pRes = CC_PARAM_NOT_SUPPORTED;
//             return sizeof (*pRes);
//         }
//         else if ((SET_IN_PROGRESS == m_Serial_SetInProgress) &&
//                 (SET_IN_PROGRESS == pReq [2]))
//         {
//             /*Set In Progress already Set */
//             *pRes = CC_SET_IN_PROGRESS;
//             return sizeof (*pRes);
//         }

//         LOCK_BMC_SHARED_MEM(BMCInst);
//         BMC_GET_SHARED_MEM(BMCInst)->m_Serial_SetInProgress = pReq [2];
//         UNLOCK_BMC_SHARED_MEM(BMCInst);
//         *pRes           = CC_NORMAL;
//         return sizeof (*pRes);
//     }


//     /* Get the param selector & Block Selector */
//     if (0 != (SMEntry->MaxSetSelector & BLOCK_SELECTOR_REQ))
//     {
//         SetSelector     = pReq [2];
//         BlockSelector   = pReq [3];
//         ReqStartOffset  = sizeof (SetSerialModemConfigReq_T) +
//                           sizeof (SetSelector) + sizeof (BlockSelector);
//     }
//     else if (0 == (SMEntry->MaxSetSelector & 0x7f))
//     {
//         SetSelector     = 0;
//         BlockSelector   = 0;
//         ReqStartOffset  = sizeof (SetSerialModemConfigReq_T);
//     }
//     else
//     {
//         SetSelector     = pReq [2];
//         BlockSelector   = 0;
//         ReqStartOffset  = sizeof (SetSerialModemConfigReq_T) +
//                           sizeof (SetSelector);
//     }

//     /*Check Reserved Bits */

//     i = 0;
//     while ((0 != (SMEntry->ParamFlags & CHECK_RSVD_BITS)) &&
//                  (i < sizeof (ReservedBitsTable)))
//     {
//         RsvdEntry   = (_NEAR_ RsvdBitsTable_T*)&ReservedBitsTable [i];
//         i = i + sizeof (RsvdBitsTable_T);
//         if (RsvdEntry->Param == SetReq->ParamSel)
//         {
//             INT8U j;

//             for (j=0; j < RsvdEntry->Length; j++)
//             {
//                 if (0 != (pReq [ReqStartOffset + j] & ReservedBitsTable [i + j]))
//                 {
//                     *pRes = CC_INV_DATA_FIELD;
//                     return sizeof (*pRes);
//                 }
//             }
//             break;
//         }

//         i =  i + RsvdEntry->Length;
//     }

//     /* Verify the set selector & block selector */
//     if ((0 != (SMEntry->MaxSetSelector & 0x7f)) &&
//         ((SMEntry->MaxSetSelector & 0x7f) < SetSelector))
//     {
//         *pRes = CC_PARAM_OUT_OF_RANGE;
//         return sizeof (*pRes);
//     }

//     if ((0 != SMEntry->MaxBlockSelector) &&
//         (SMEntry->MaxBlockSelector <= BlockSelector))
//     {
//         *pRes = CC_PARAM_OUT_OF_RANGE;
//         return sizeof (*pRes);
//     }

//     /* Check read only access */
//     if (0 != (SMEntry->ParamFlags & PARAM_READ_ONLY))
//     {
//         *pRes = CC_ATTEMPT_TO_SET_RO_PARAM;
//         return sizeof (*pRes);
//     }

//    /* Get the address where we want to set */
//     SetStart = getSMConfigAddr (SMEntry , SetSelector, BlockSelector,BMCInst);

//     switch(SetReq->ParamSel)
//     {
//         case SET_BAUD_RATE:
//             /*Check for Valid Baud Rate*/
//             tempdata = GetBits (pReq[3], SERIAL_BAUD_RATE);
//             if((tempdata > BAUD_RATE_115200)||(tempdata < BAUD_RATE_9600))
//             {
//             *pRes = CC_PARAM_OUT_OF_RANGE;
//             return sizeof(*pRes);
//             }
//             LOCK_BMC_SHARED_MEM(BMCInst);
//             _fmemcpy (SetStart, (_FAR_ INT8U*) (pReq + ReqStartOffset), (SMEntry->Size & 0x7f));
//             UNLOCK_BMC_SHARED_MEM(BMCInst);

//             /* if Set serial port setting, initlize the serial port */
//             SetSerialPort (BMCInst);
//             break;

//         case SET_BAD_PWD_THRESHOLD:
//             LOCK_BMC_SHARED_MEM(BMCInst);
//             _fmemcpy (SetStart, (_FAR_ INT8U*) (pReq + ReqStartOffset), (SMEntry->Size & 0x7f));
//             UNLOCK_BMC_SHARED_MEM(BMCInst);
//             break;

//         default:
//             *pRes=CC_PARAM_NOT_SUPPORTED;
//             return sizeof(INT8U);
//    }

//     FlushIPMI((INT8U*)&pBMCInfo->SMConfig,(INT8U*)&pBMCInfo->SMConfig,pBMCInfo->IPMIConfLoc.SMConfigAddr,
//                       sizeof(SMConfig_T),BMCInst);

//     *pRes = CC_NORMAL;
//     return sizeof (*pRes);
// }


// /*---------------------------------------
//  * GetSerialModemConfig
//  *---------------------------------------*/
// int
// GetSerialModemConfig (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst)
// {
//     _NEAR_ GetSerialModemConfigReq_T* GetReq =
//                               (_NEAR_ GetSerialModemConfigReq_T*) pReq;
//     _NEAR_ GetSerialModemConfigRes_T* GetRes =
//                               (_NEAR_ GetSerialModemConfigRes_T*) pRes;
//     const  SMConfigTable_T*           SMEntry;
//     _FAR_  INT8U*                     SetStart;
//     INT8U                      ResStartOffset;
//     _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];
//     INT8U  m_Serial_SetInProgress; /**< Contains setting Serial configuration status */

// 	if(GetReq->ParamRevChannelNo & RESERVED_BITS_GETSERIALMODEMCONFIG_REVCH)
// 	{
// 		*pRes = CC_INV_DATA_FIELD;
// 		return sizeof(*pRes);
// 	}

//     /* Verify if the Channel number & param selector is valid */
//     if ((GetReq->ParamRevChannelNo & 0x7f) != pBMCInfo->SERIALch)
//     {
//         *pRes = CC_INV_DATA_FIELD;
//         return sizeof (*pRes);
//     }
//     if (GetReq->ParamSel >= sizeof (SMConfigTable) / sizeof (SMConfigTable [0]))
//     {
//         *pRes = CC_PARAM_NOT_SUPPORTED;
//         return sizeof (*pRes);
//     }


//     SMEntry = &(SMConfigTable [GetReq->ParamSel]);

//     /* Verify length */
//     if (ReqLen != sizeof (GetSerialModemConfigReq_T))
//     {
//         *pRes = CC_REQ_INV_LEN;
//         return (*pRes);
//     }

//     GetRes->CompCode = CC_NORMAL;
//     GetRes->ParamRev = PARAM_REVISION;

//     /* Check if only parameter revision is required */
//     if (0 != (GetReq->ParamRevChannelNo & GET_PARAM_REV_ONLY))
//     {
//         return sizeof (GetSerialModemConfigRes_T);
//     }

//     /* Get the param selector & Block Selector */
//     if (0 != (SMEntry->MaxSetSelector & BLOCK_SELECTOR_REQ))
//     {
//         IPMI_DBG_PRINT ("Param With Set & BLock Selector \n");
//         *(pRes + 2)    = GetReq->SetSel;
//         *(pRes + 3)    = GetReq->BlockSel;
//         ResStartOffset = sizeof (GetSerialModemConfigRes_T) +
//                          sizeof (GetReq->SetSel) + sizeof (GetReq->BlockSel);
//     }
//     else if (0 == (SMEntry->MaxSetSelector & 0x7F))
//     {
//         IPMI_DBG_PRINT ("Param With No Set Selector \n");
//         ResStartOffset  = sizeof (GetSerialModemConfigRes_T);
//     }
//     else
//     {
//         IPMI_DBG_PRINT ("Param With Set Selector \n");
//         *(pRes + 2)    = GetReq->SetSel;
//         ResStartOffset = sizeof (GetSerialModemConfigRes_T) +
//                          sizeof (GetReq->SetSel);
//     }

//     /* Verify the set selector & block selector */
//     *pRes = CC_PARAM_OUT_OF_RANGE;

//     if (GetReq->ParamSel == INIT_STR_PARAM)
//     {
//         if (0 != GetReq->SetSel)
//         {
//             return sizeof (*pRes);
//         }
//         GetReq->SetSel   = GetReq->BlockSel;
//         GetReq->BlockSel = 0;
//         *(pRes + 2)      = GetReq->SetSel;
//         ResStartOffset   = sizeof (GetSerialModemConfigRes_T) +
//                            sizeof (GetReq->SetSel);
//     }


//     if ((0 != (SMEntry->MaxSetSelector & 0x7f)) &&
//         ((SMEntry->MaxSetSelector & 0x7f) < GetReq->SetSel))
//     {
//         return sizeof (*pRes);
//     }

//     if ((0 != SMEntry->MaxBlockSelector) &&
//         ((SMEntry->MaxBlockSelector <= GetReq->BlockSel) ||
//          (0 == GetReq->BlockSel)))
//     {
//         return sizeof (*pRes);
//     }

//     if ((0 == (SMEntry->MaxSetSelector & 0x7f)) &&
//         (0 != GetReq->SetSel))
//     {
//         return sizeof (*pRes);
//     }

//     if ((0 == SMEntry->MaxBlockSelector) &&
//         (0 != GetReq->BlockSel))
//     {
//         return sizeof (*pRes);
//     }

//     if ((0 == GetReq->SetSel) && (GetReq->ParamSel == INIT_STR_PARAM))
//     {
//         return sizeof (*pRes);
//     }

//     /* Load Response */
//     GetRes->CompCode = CC_NORMAL;

//     /* Process Set In Progress parameter */
//     if (GetReq->ParamSel == SET_IN_PROGRESS_PARAM)
//     {
//         LOCK_BMC_SHARED_MEM(BMCInst);
//         m_Serial_SetInProgress = BMC_GET_SHARED_MEM(BMCInst)->m_Serial_SetInProgress;
//         UNLOCK_BMC_SHARED_MEM(BMCInst);
//         *(pRes + 2) = m_Serial_SetInProgress;
//         return (sizeof (GetSerialModemConfigRes_T) + sizeof (m_Serial_SetInProgress));
//     }

//     /* Check Write only access */
//     if (0 != (SMEntry->ParamFlags & PARAM_WRITE_ONLY))
//     {
//         *pRes = CC_WRITE_ONLY_PARAM;
//         return sizeof (*pRes);
//     }

//     /* Get the address where we want to set */
//     SetStart = getSMConfigAddr (SMEntry, GetReq->SetSel, GetReq->BlockSel, BMCInst);

//     LOCK_BMC_SHARED_MEM(BMCInst);
//     _fmemcpy ( (pRes + ResStartOffset), SetStart,  (SMEntry->Size & 0x7f));
//     UNLOCK_BMC_SHARED_MEM(BMCInst);

//     return ( (SMEntry->Size & 0x7f) + ResStartOffset);
// }


// /*---------------------------------------
//  * getSMConfigAddr
//  *--------------------------------------*/
// static _FAR_ INT8U*
// getSMConfigAddr (_FAR_ const SMConfigTable_T* SMEntry,
//                                 INT8U            SetSelector,
//                                 INT8U            BlockSelector,
//                                 int			  BMCInst)
// {
//     _FAR_ INT8U*        SetStart;
//     INT8U         Size;
//     INT8U         MaxBlockSel;
//     BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst];

//     /* Get the NVRAM PM config address */
//     SetStart = (_FAR_ INT8U*) &pBMCInfo->SMConfig;
//     Size     = SMEntry->Size & 0x7f;

//     if (0 == SMEntry->MaxBlockSelector)
//     {
//         MaxBlockSel = 1;
//     }
//     else
//     {
//         MaxBlockSel = SMEntry->MaxBlockSelector;
//     }

//     if (0 != (SMEntry->ParamFlags & PARAM_VOLATILE_NON_VOLATILE))
//     {
//         if (0 == SetSelector)
//         {
//             /*Get Shared Memory Info */
//             SetStart = (_FAR_ INT8U*)&BMC_GET_SHARED_MEM (BMCInst)->SMConfig;
//             SetStart = SetStart + SMEntry->Offset +
//                        (Size * ((SetSelector * MaxBlockSel) + BlockSelector));
//             return SetStart;
//         }
//         else
//         {
//             SetSelector--;
//             if (0 != BlockSelector)
//             {
//                 BlockSelector--;
//             }
//         }
//     }

//     SetStart = SetStart + SMEntry->Offset +
//                (Size * ((SetSelector * MaxBlockSel) + BlockSelector));

//     return SetStart;
// }


// /*---------------------------------------
//  * CallBack
//  *---------------------------------------*/
// int
// CallBack (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst)
// {
//     _NEAR_  CallbackReq_T*  CallBackReq = (_NEAR_ CallbackReq_T*) pReq;
//     _FAR_   SMConfig_T*     pVSMConfig  =
//                  &(((_FAR_ BMCSharedMem_T*) BMC_GET_SHARED_MEM (BMCInst))->SMConfig);
//     _FAR_   ChannelInfo_T*  pChannelInfo;
//     _FAR_   DestInfo_T*     pDestInfo;
//     INT8U           DestType,*curchannel;
//     MsgPkt_T        MsgPkt;
//     _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];			
//     _FAR_   SMConfig_T*     pNVSMConfig = &pBMCInfo->SMConfig;
//     INT32U *CurSesID;

// 	if(CallBackReq->ChannelNum & RESERVED_BITS_CALLBACK_CH)
// 	{
// 		*pRes = CC_INV_DATA_FIELD;
// 		return sizeof(*pRes);
// 	}

// 	if(CallBackReq->DestSel & RESERVED_BITS_CALLBACK_DESTSEL)
// 	{
// 		*pRes = CC_INV_DATA_FIELD;
// 		return sizeof(*pRes);
// 	}

//     OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel);
//     /* Check if Session Already exist */
//     if ((pBMCInfo->SERIALch!= (*curchannel  & 0xF)) &&
//         (TRUE == BMC_GET_SHARED_MEM (BMCInst)->SerialSessionActive))
//     {
//         *pRes = CC_CALLBACK_REJ_SESSION_ACTIVE;
//         return sizeof (*pRes);
//     }

//     CallBackReq->DestSel &= 0x0f;

//     /* Check the validity of Destination Selector */
//     if (CallBackReq->DestSel > pNVSMConfig->TotalAlertDest)
//     {
//         *pRes = CC_DEST_UNAVAILABLE;
//         return sizeof (*pRes);
//     }

//     if (0 == CallBackReq->DestSel)
//     {
//         /* Destination Info is volatile */
//         pDestInfo = (_FAR_ DestInfo_T*) &pVSMConfig->DestinationInfo [0];
//     }
//     else
//     {
//         /* Destination Info is non-volatile */
//         pDestInfo = (_FAR_ DestInfo_T*) &pNVSMConfig->DestinationInfo [CallBackReq->DestSel - 1];
//     }

//     /*Check if Destination if Configured & Enabled for CALLBACK */
//     *pRes     = CC_INV_DATA_FIELD;
//     DestType  = pDestInfo->DesType & MODEM_CFG_DEST_INFO_DEST_TYPE_MASK;


//     if ((BASIC_MODE_CALLBACK != DestType) && (PPP_MODE_CALLBACK != DestType))
//     {
//         return sizeof (*pRes);
//     }

//     if (0 == (pNVSMConfig->ChannelCallBackCtrl.CallBackEnable & IPMI_CALLBACK_MASK))
//     {
//         return sizeof (*pRes);
//     }

//     OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE);
//     /* If Current Channel is Session Based, Check is User is allowed for CallBack */
//     pChannelInfo = getChannelInfo (*curchannel  & 0xF, BMCInst);
//     if(NULL == pChannelInfo)
//     {
//         OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex);
//         *pRes = CC_INV_DATA_FIELD;
//         return	sizeof (*pRes);
//     }

//     /* Disable Ping during CallBack */
//     pNVSMConfig->MUXSwitchCtrl.Data2  &=  ~DIRECT_PING_ENABLE_MASK;


//     if (pChannelInfo->SessionSupport != SESSIONLESS_CHANNEL)
//     {
//         _FAR_ SessionInfo_T*     pSessionInfo;
//         _FAR_ SessionTblInfo_T*  pSessionTblInfo =
//                          &pBMCInfo->SessionTblInfo;
//         _FAR_ ChannelUserInfo_T* pChUserInfo;
//         INT8U              Index;

//         IPMI_DBG_PRINT_1 ("Session Less ch  - %d\n",*curchannel  & 0xF);

//         OS_THREAD_TLS_GET(g_tls.CurSessionID,CurSesID);
//         OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->SessionTblMutex,WAIT_INFINITE);
//         pSessionInfo = getSessionInfo (SESSION_ID_INFO,CurSesID, BMCInst);
//         if(pSessionInfo == NULL)
//         {
//             OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex);
//             return sizeof (*pRes);
//         }
//         pChUserInfo = getChUserIdInfo (pSessionInfo->UserId,&Index,
//                                        pChannelInfo->ChannelUserInfo, BMCInst);
//         if(pChUserInfo == NULL)
//         {
//             OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex);
//             return sizeof (*pRes);
//         }

//         if (0 == (pChUserInfo->UserCallbackCapabilities & 0x01))
//         {
//             OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex);
//             return sizeof (*pRes);
//         }

//         /* For Serial Channel Existing Session should be deleted */
//         if ((pBMCInfo->SERIALch!= (*curchannel  & 0xF)) &&
//             (TRUE == BMC_GET_SHARED_MEM (BMCInst)->SerialSessionActive))
//         {
//             for (Index=0; Index < pBMCInfo->IpmiConfig.MaxSession; Index++)
//             {
//                 if (pBMCInfo->SERIALch == pSessionTblInfo->SessionTbl [Index].Channel)
//                 {
//                     pSessionTblInfo->SessionTbl [Index].TimeOutValue = 0;
//                 }
//             }
//         }
//     }

//     OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex);
//     /* Request to Initiate CallBack */
//     MsgPkt.Channel  = pBMCInfo->SERIALch;
//     MsgPkt.Param    = SERIAL_INIT_CALLBACK_REQUEST;
//     MsgPkt.Size     = sizeof (CallBackReq->DestSel);
//     MsgPkt.Data [0] = CallBackReq->DestSel;

//     IPMI_DBG_PRINT ("Posting CallBack Request\n");
//     if( 0 != PostMsg (&MsgPkt,SERIAL_IFC_Q,BMCInst ))
//     {
//            IPMI_WARNING ("SerialModem.c: Unable to post messages to hSerialIfc_Q\n");
//     }    

//     *pRes = CC_NORMAL;

//     return sizeof (*pRes);
// }


// /*---------------------------------------
//  * SetUserCallBackOptions
//  *---------------------------------------*/
// int
// SetUserCallBackOptions (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst)
// {
//     _NEAR_ SetUserCallbackReq_T *Req = (_NEAR_ SetUserCallbackReq_T*) pReq;
//     _FAR_  ChannelUserInfo_T    *pChUserInfo;
//     BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst];

// 	if(Req->UserID & RESERVED_BITS_SETUSERCALLBACKOPT_USRID)
// 	{
// 		*pRes = CC_INV_DATA_FIELD;
// 		return sizeof(*pRes);
// 	}
	
// 	if(Req->ChannelNum & RESERVED_BITS_SETUSERCALLBACKOPT_CH)
// 	{
// 		*pRes = CC_INV_DATA_FIELD;
// 		return sizeof(*pRes);
// 	}

// 	if(Req->UserCallbackCapabilities & RESERVED_BITS_SETUSERCALLBACKOPT_USRCALLBAKCAP)
// 	{
// 		*pRes = CC_INV_DATA_FIELD;
// 		return sizeof(*pRes);
// 	}
	
// 	if(Req->CBCPNegOptions & RESERVED_BITS_SETUSERCALLBACKOPT_CBCNEGOPT)
// 	{
// 		*pRes = CC_INV_DATA_FIELD;
// 		return sizeof(*pRes);
// 	}

//     OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE);
//     pChUserInfo = GetCBChUserInfo (Req->UserID, Req->ChannelNum, BMCInst);

//     *pRes = CC_INV_DATA_FIELD;

//     /*Check if the user info exits */
//     if (NULL == pChUserInfo)
//     {
//         OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex);
//         return sizeof (*pRes);
//     }

//     /*Set CallBack Options */
//     pChUserInfo->UserAccessCallback       = (Req->UserCallbackCapabilities &
//                                              IPMI_CALLBACK_MASK);
//     pChUserInfo->UserAccessCBCPCallback   = (Req->UserCallbackCapabilities &
//                                              CBCP_CALLBACK_MASK);
//     pChUserInfo->UserCallbackCapabilities = Req->UserCallbackCapabilities;
//     pChUserInfo->CBCPNegOptions           = Req->CBCPNegOptions;
//     pChUserInfo->CallBack1                = Req->CallBack1;
//     pChUserInfo->CallBack2                = Req->CallBack2;
//     pChUserInfo->CallBack3                = Req->CallBack3;
//     OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex);

//     *pRes = CC_NORMAL;
//     return sizeof (*pRes);
// }


// /*---------------------------------------
//  * SetUserCallBackOptions
//  *---------------------------------------*/
// int
// GetUserCallBackOptions (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst)
// {
//     _NEAR_   GetUserCallbackReq_T* Req = ( _NEAR_ GetUserCallbackReq_T*) pReq;
//     _NEAR_   GetUserCallbackRes_T* Res = ( _NEAR_ GetUserCallbackRes_T*) pRes;
//     _FAR_    ChannelUserInfo_T*    pChUserInfo;
//     BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst];

// 	if(Req->UserID & RESERVED_BITS_GETUSERCALLBACKOPTIONS_USRID)
// 	{
// 		*pRes = CC_INV_DATA_FIELD;
// 		return sizeof(*pRes);
// 	}

//     OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE);
//     pChUserInfo  = GetCBChUserInfo (Req->UserID , Req->ChannelNum, BMCInst);

//     *pRes = CC_INV_DATA_FIELD;

//     /*Check if the user info exits */
//     if (NULL == pChUserInfo  )
//     {
//         OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex);
//         return sizeof (*pRes);
//     }

//     /*Set CallBack Options */
//     Res->CompletionCode           = CC_NORMAL;
//     Res->UserCallbackCapabilities = pChUserInfo->UserCallbackCapabilities ;
//     Res->CBCPNegOptions           = pChUserInfo->CBCPNegOptions;
//     Res->CallBack1                = pChUserInfo->CallBack1;
//     Res->CallBack2                = pChUserInfo->CallBack2;
//     Res->CallBack3                = pChUserInfo->CallBack3;
//     OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex);

//     return sizeof (GetUserCallbackRes_T);
// }


// /*---------------------------------------
//  * GetCBChUserInfo
//  *---------------------------------------*/
// static _FAR_ ChannelUserInfo_T*
// GetCBChUserInfo (INT8U UserID, INT8U Channel )
// {
//     _FAR_   ChannelInfo_T* pChannelInfo;
//     INT8U          Index;

//     /*Get Channel Info */
//     pChannelInfo = getChannelInfo (Channel, BMCInst);
//     if (NULL == pChannelInfo )
//     {
//         return NULL;
//     }

//     /*Get the particular user entitled for callback */
//     return getChUserIdInfo (UserID,&Index,pChannelInfo->ChannelUserInfo, BMCInst);
// }


// /*---------------------------------------
//  * SetSerialModemMUX
//  *---------------------------------------*/
// int
// SetSerialModemMUX (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst)
// {
//     _NEAR_ SetMuxReq_T* Req         = (_NEAR_   SetMuxReq_T*) pReq;
//     _NEAR_ SetMuxRes_T* Res         = (_NEAR_   SetMuxRes_T*) pRes;
//      INT8U        TSettings;
//     ChannelInfo_T* pChannelInfo;
//     _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];
//     _FAR_  SMConfig_T*  pNVSMConfig = &(pBMCInfo->SMConfig);

//     Res->CompCode = CC_INV_DATA_FIELD;

// 	if(Req->ChannelNo & RESERVED_BITS_SETSERIALMODEMMUX_CH) return sizeof(*pRes);
// 	if(Req->MuxSettingReq & RESERVED_BITS_SETSERIALMODEMMUX_MUXSETREQ) return sizeof(*pRes);

//     if (Req->ChannelNo != pBMCInfo->SERIALch)
//     {
//         return sizeof(*pRes);
//     }

//     TSettings = BMC_GET_SHARED_MEM (BMCInst)->SerialMuxSetting;
//     /* No Session or Alert  In progress */
//     TSettings = TSettings & MUX_SESSION_ALERT_INACTIVE_MASK;
//     if (TRUE == BMC_GET_SHARED_MEM (BMCInst)->SerialSessionActive)
//     {
//         TSettings |= MUX_SESSION_ACTIVE_MASK;
//     }

//     /* Accept Request */
//     TSettings = TSettings | MUX_REQ_ACCEPTED_MASK;

//     Res->CompCode = CC_NORMAL;

//     pChannelInfo = getChannelInfo(pBMCInfo->SERIALch, BMCInst);
//     if(NULL == pChannelInfo)
//     {
//         Res->CompCode = CC_INV_DATA_FIELD;
//         return	sizeof (*pRes);
//     }

//     /*Check if Serial Port Sharing Enabled */
//     if ((0 == (pNVSMConfig->MUXSwitchCtrl.Data2 & SERIAL_PORT_SHARING_ENABLED)) ||
//         (CHANNEL_ALWAYS_AVAILABLE == pChannelInfo->AccessMode))
//     {

//         if(Req->MuxSettingReq==0x0)
//         {
//             Res->MuxSetting = TSettings& MUX_REQ_REJECTED_MASK;
//             return sizeof (SetMuxRes_T);
//         }
//         else
//         {
//             Res->CompCode = CC_COULD_NOT_PROVIDE_RESP;
//             return sizeof(*pRes);
//         }
//     }

//     switch (Req->MuxSettingReq)
//     {
//         case REQ_CUR_MUX_SETTING:
//             break;

//         case REQ_MUX_TO_SYS:

//             if (0 == (REQ_MUX_TO_SYS_MASK & TSettings))
//             {
//                 IPMI_DBG_PRINT ("SYS HOLDS EMP\n");
//                 if(g_PDKHandle[PDK_SWITCHEMPMUX] != NULL)
//                 {
//                     ((void(*)(INT8U,int))g_PDKHandle[PDK_SWITCHEMPMUX]) (MUX_2_SYS,BMCInst);
//                 }
//                 TSettings = (TSettings & SET_MUX_TO_SYS_MASK);
//             }
//             else
//             {
//                 TSettings &= MUX_REQ_REJECTED_MASK;
//             }
//             break;

//         case REQ_MUX_TO_BMC:

//             if (0 == (REQ_MUX_TO_BMC_MASK & TSettings))
//             {
//                 IPMI_DBG_PRINT ("BMC HOLDS EMP\n");
//                 if(g_PDKHandle[PDK_SWITCHEMPMUX] != NULL)
//                 {
//                     ((void(*)(INT8U,int))g_PDKHandle[PDK_SWITCHEMPMUX]) (MUX_2_BMC,BMCInst);
//                 }
//                 TSettings = (TSettings | SET_MUX_TO_BMC_MASK);
//             }
//             else
//             {
//                 TSettings &= MUX_REQ_REJECTED_MASK;
//             }
//             break;

//         case REQ_MUX_FORCE_TO_SYS:

//             IPMI_DBG_PRINT ("SYS HOLDS EMP\n");
//             if(g_PDKHandle[PDK_SWITCHEMPMUX] != NULL)
//             {
//                 ((void(*)(INT8U,int))g_PDKHandle[PDK_SWITCHEMPMUX]) (MUX_2_SYS,BMCInst);
//             }
//             TSettings = (TSettings & SET_MUX_TO_SYS_MASK);
//             break;

//         case REQ_MUX_FORCE_TO_BMC:

//             IPMI_DBG_PRINT ("BMC HOLDS EMP\n");
//             if(g_PDKHandle[PDK_SWITCHEMPMUX] != NULL)
//             {
//                 ((void(*)(INT8U,int))g_PDKHandle[PDK_SWITCHEMPMUX]) (MUX_2_BMC,BMCInst);
//             }
//             TSettings = (TSettings | SET_MUX_TO_BMC_MASK);
//             break;

//         case REQ_BLOCK_MUX_TO_SYS:

//             TSettings = (TSettings | BLOCK_MUX_TO_SYS_MASK);
//             break;

//         case REQ_ALLOW_MUX_TO_SYS:

//             TSettings = (TSettings & ALLOW_MUX_TO_SYS_MASK);
//             break;

//         case REQ_BLOCK_MUX_TO_BMC:

//             TSettings = (TSettings | BLOCK_MUX_TO_BMC_MASK);
//             break;

//         case REQ_ALLOW_MUX_TO_BMC:

//             TSettings = (TSettings & ALLOW_MUX_TO_BMC_MASK);
//             break;

//         default:

//         return sizeof (*pRes);
//     }

//     Res->MuxSetting = TSettings;
//     BMC_GET_SHARED_MEM (BMCInst)->SerialMuxSetting = TSettings;
//     IPMI_DBG_PRINT_1 ("SerialMUXSetting = %X\n",TSettings);

//     return sizeof (SetMuxRes_T);
// }


// /*---------------------------------------
//  * SerialModemConnectActive
//  *---------------------------------------*/
// int
// SerialModemConnectActive (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst)
// {
//     _NEAR_ SerialModemActivePingReq_T* Req = (_NEAR_ SerialModemActivePingReq_T*) pReq;

//     if(Req->SessionState & RESERVED_BITS_SERIALMODEMCONNECTACTIVE)
//     {
//     	*pRes = CC_INV_DATA_FIELD;
//     	return sizeof(*pRes);
//     }

//     *pRes = CC_NORMAL;

//     if ((Req->SessionState != 0)    && /* No Session State      */
//         (Req->SessionState != 1)    && /* Session State Active  */
//         (Req->SessionState != 2)    && /* MUX Switch to SYS     */
//         (Req->IPMIVersion  != 0x51))   /* IPMIVersion 1.5       */
//     {
//         *pRes = CC_INV_DATA_FIELD;
//     }

//     return sizeof (*pRes);
// }


// /*---------------------------------------
//  * SerialModemPingTask
//  *---------------------------------------*/
// void
// SerialModemPingTask ( int BMCInst )
// {
//       MsgPkt_T     MsgPkt;
//     _FAR_ static INT8U MuxSwitchToSys;
//     _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];
//     _FAR_ SMConfig_T*  pNVSMConfig = &pBMCInfo->SMConfig;

//     /* Check if Serial Port Sharing Enabled & Mux is switched to BMC */
//     if (0 == (pNVSMConfig->MUXSwitchCtrl.Data2 & SERIAL_PORT_SHARING_ENABLED))
//     {
//         return;
//     }

//     /* Check if Serial Ping Message Enabled */
//     if (0 == (pNVSMConfig->MUXSwitchCtrl.Data2 & DIRECT_PING_ENABLE_MASK))
//     {
//         return;
//     }

//     /* Update Session State */
//     if (0 == (BMC_GET_SHARED_MEM (BMCInst)->SerialMuxSetting & SET_MUX_TO_BMC_MASK))
//     {
//         /* Ping should be generated Only once before Mux switch to System */
//         if (1 == MuxSwitchToSys )
//         {
//             return;
//         }

//         MsgPkt.Data [0] = MUX_SWITCHED_TO_SYS;
//         MuxSwitchToSys  = 1;
//     }
//     else
//     {
//         /* Check for periodical ping message active flag */
//         if (0 == (pNVSMConfig->MUXSwitchCtrl.Data2 & PING_MSG_ACTIVE_BIT))
//         {
//             return;
//         }

//         MsgPkt.Data [0] = SESSION_STATE_INACTIVE;
//         MuxSwitchToSys  = 0;

//         if (TRUE == BMC_GET_SHARED_MEM (BMCInst)->SerialSessionActive)
//         {
//             MsgPkt.Data [0] = SESSION_STATE_ACTIVE;
//         }
//     }

//     /* Request to give Ping Message */
//     MsgPkt.Channel  = pBMCInfo->SERIALch;
//     MsgPkt.Param    = SERIAL_PING_REQUEST;
//     MsgPkt.Size     = 1;


//     /* Post Ping Request */
//     if( 0 != PostMsg (&MsgPkt,SERIAL_IFC_Q ,BMCInst))
//     {
//            IPMI_WARNING ("SerialModem.c: Unable to post messages to hSerialIfc_Q\n");
//     }    
    
// }


// /*---------------------------------------
//  * GetTAPResponseCodes
//  *---------------------------------------*/
// int
// GetTAPResponseCodes (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst)
// {
//     _NEAR_ GetTAPResCodeReq_T* Req      = (_NEAR_ GetTAPResCodeReq_T*) pReq;
//     _NEAR_ GetTAPResCodeRes_T* Res      = (_NEAR_ GetTAPResCodeRes_T*) pRes;
//     _FAR_  TAPResCode_T*       TAPCodes = &(((_FAR_ BMCSharedMem_T*) BMC_GET_SHARED_MEM (BMCInst))->TAPRes);
//     _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];

//     IPMI_DBG_PRINT ("Get TAP Respone Code CMD\n");

//     if(Req->ChannelNo & RESERVED_BITS_GETTAPRESPONSECODES_CH)
//     {
//     	*pRes = CC_INV_DATA_FIELD;
//     	return sizeof(*pRes);
//     }

//     /* Check Channel No */
//     if (Req->ChannelNo != pBMCInfo->SERIALch)
//     {
//         Res->CompCode = CC_INV_DATA_FIELD;
//         return sizeof (*pRes);
//     }

//     /*Load Response Codes*/
//     Res->CompCode = CC_NORMAL;
//     LOCK_BMC_SHARED_MEM(BMCInst);
//     _fmemcpy (&pRes [1],TAPCodes,sizeof (TAPResCode_T));
//     UNLOCK_BMC_SHARED_MEM(BMCInst);

//     return sizeof (GetTAPResCodeRes_T);
// }


// /**
//  * SetSerialPort
//  * @brief Initilize the Serial port
//  **/

// int
// SetSerialPort (int BMCInst)
// {
//     INT8U   BaudRate;
//     //INT8U   FlowCtrl;
//     //int     status;
//     int		fd;
//     struct  termios tty_struct;
//     _FAR_  BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst];

//     if ((fd = open(pBMCInfo->IpmiConfig.pSerialPort, O_RDONLY)) < 0)
//     {
//         IPMI_WARNING ("Can't open serial port..%s\n",strerror(errno));
//         return -1;
//     }

//     /* Get the default Baudrate & FlowControl from Serial Modem configureation */
//     BaudRate = pBMCInfo->SMConfig.IpmiMsgCommSet.BitRate;
//     //FlowCtrl = pBMCInfo->SMConfig.IpmiMsgCommSet.FlowCtrl;

//     tcgetattr(fd,&tty_struct);   			   /* get termios structure */

//     switch (BaudRate) 
//     {
//         case BAUD_RATE_9600:
//             cfsetospeed(&tty_struct, B9600);
//             cfsetispeed(&tty_struct, B9600);
//             break;
//         case BAUD_RATE_19200:
//             cfsetospeed(&tty_struct, B19200);
//             cfsetispeed(&tty_struct, B19200);
//             break;
//         case BAUD_RATE_38400:
//             cfsetospeed(&tty_struct, B38400);
//             cfsetispeed(&tty_struct, B38400);
//             break;
//         case BAUD_RATE_57600:
//             cfsetospeed(&tty_struct, B57600);
//             cfsetispeed(&tty_struct, B57600);
//             break;
//         case BAUD_RATE_115200:
//             cfsetospeed(&tty_struct, B115200);
//             cfsetispeed(&tty_struct, B115200);
//             break;
//         default:
//             IPMI_ERROR ("SerialIfc.c : Invalid baud rate\n");
//     }

//     tty_struct.c_cflag |= CS8;              /* Set 8bits/charecter          */
//     tty_struct.c_cflag &= ~CSTOPB;          /* set framing to 1 stop bits   */
//     tty_struct.c_cflag &= ~(PARENB);        /* set parity to NONE           */
//     tty_struct.c_iflag &= ~(INPCK);

//     /* set the new attributes in the tty driver */
//     tcsetattr(fd, TCSANOW, &tty_struct);

//     close (fd);

//     return 0;
// }