FreeCalypso > hg > fc-magnetite

view src/g23m-aci/aci/aci_bat_fd.c @ 598:717ed17d82c6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
aci3 vocoder control revamped, AT@VSEL now works as it should The vocoder control code (hl_audio_drv.c) that came with the TCS3 version of ACI was totally broken in the Calypso config (VOCODER_FUNC_INTERFACE) and worked in the standard analog voice environment only by luck. This code has now been rewritten to work correctly with our Calypso platform and TCS211 L1, and our new AT@VSEL mechanism (automatic enabling and disabling of MCSI voice path as the modem enters and exits the voice call state) now also works as designed.
author Mychaela Falconia <falcon@freecalypso.org>
date Wed, 27 Mar 2019 23:44:35 +0000
parents 53929b40109c
children
line wrap: on
line source

/*
+-----------------------------------------------------------------------------
|  Project :  GSM-F&D (8411)
|  Modul   :  ACI_BAT
+-----------------------------------------------------------------------------
|  Copyright 2002 Texas Instruments Berlin, AG
|                 All rights reserved.
|
|                 This file is confidential and a trade secret of Texas
|                 Instruments Berlin, AG
|                 The receipt of or possession of this file does not convey
|                 any rights to reproduce or disclose its contents or to
|                 manufacture, use, or sell anything it may describe, in
|                 whole, or in part, without the specific written consent of
|                 Texas Instruments Berlin, AG.
+-----------------------------------------------------------------------------
|  Purpose :  This BAT wrapper modul is ...
|
+-----------------------------------------------------------------------------
*/

#include "aci_all.h"     /* includes prim.h, which includes p_bat.h */
#include "aci_cmh.h"     /* prototypes of sAT_, qAT_, tAT_    */
#include "aci_bat_cmh.h" /* prototypes of sBAT_, qBAT_, tBAT_ */
#include "aci_bat.h"
#include "aci_fd.h"

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : BAT_O                |
+--------------------------------------------------------------------+

  PURPOSE :
*/
GLOBAL T_ACI_BAT_RSLT BAT_O(T_ACI_DTI_PRC_PSI *src_infos_psi,
                            T_BAT_cmd_send    *cmd)
{
  TRACE_FUNCTION ("BAT_O()");
  return(ACI_BAT_FAIL);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusDS          |
+--------------------------------------------------------------------+

  PURPOSE : V.42bis data compression functions
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusDS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                  T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusDS()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusDS((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_DS_DIR)cmd->params.ptr_set_plus_ds->dir,
                    (T_ACI_DS_COMP)cmd->params.ptr_set_plus_ds->neg,
                    cmd->params.ptr_set_plus_ds->p1,
                    cmd->params.ptr_set_plus_ds->p2);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusDS          |
+--------------------------------------------------------------------+

  PURPOSE : V.42bis data compression functions
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusDS          (T_ACI_DTI_PRC_PSI *src_infos_psi,
                                            T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_ds ds;

  TRACE_FUNCTION ("qBAT_PlusDS()");
  resp.ctrl_response = BAT_RES_QUE_PLUS_DS;
  resp.response.ptr_que_plus_ds = &ds;

  ret =(T_ACI_BAT_RSLT)qAT_PlusDS((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	             (T_ACI_DS_DIR*)&ds.dir,(T_ACI_DS_COMP*)&ds.neg,
  	             (LONG*)&ds.p1,(SHORT*)&ds.p2);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusCRLP        |
+--------------------------------------------------------------------+

  PURPOSE : Radio link protocol
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusCRLP(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                    T_BAT_cmd_send *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusCRLP()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusCRLP((T_ACI_CMD_SRC)src_infos_psi->srcId,
                     (S16)cmd->params.ptr_set_plus_crlp->iws,
                     (S16)cmd->params.ptr_set_plus_crlp->mws,
                     (S16)cmd->params.ptr_set_plus_crlp->t1,
                     (S16)cmd->params.ptr_set_plus_crlp->n2);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusCRLP        |
+--------------------------------------------------------------------+

  PURPOSE : Radio link protocol
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusCRLP(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                    T_BAT_cmd_send *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_crlp crlp;

  TRACE_FUNCTION ("qBAT_PlusCRLP()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_CRLP;
  resp.response.ptr_que_plus_crlp = &crlp;

  ret = (T_ACI_BAT_RSLT)qAT_PlusCRLP( (T_ACI_CMD_SRC)src_infos_psi->srcId,
                      (SHORT*)&crlp.iws, (SHORT*)&crlp.mws, (SHORT*)&crlp.t1, (SHORT*)&crlp.n2);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

#ifdef FF_FAX

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFAP         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFAP(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFAP()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFAP((T_ACI_CMD_SRC)src_infos_psi->srcId, 
                    (T_ACI_FAP_VAL)cmd->params.ptr_set_plus_fap->sub,
                    (T_ACI_FAP_VAL)cmd->params.ptr_set_plus_fap->sep,
                    (T_ACI_FAP_VAL)cmd->params.ptr_set_plus_fap->pwd);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFAP         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFAP(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fap fap;
  
  TRACE_FUNCTION ("qBAT_PlusFAP()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FAP;
  resp.response.ptr_que_plus_fap = &fap;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFAP((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	             (T_ACI_FAP_VAL*)&fap.sub,(T_ACI_FAP_VAL*)&fap.sep,(T_ACI_FAP_VAL*)&fap.pwd);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFBO         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFBO(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFBO()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFBO((T_ACI_CMD_SRC)src_infos_psi->srcId, 
                    (T_ACI_FBO_VAL)cmd->params.ptr_set_plus_fbo->value);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFBO         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFBO(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fbo fbo;

  TRACE_FUNCTION ("qBAT_PlusFBO()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FBO;
  resp.response.ptr_que_plus_fbo  = &fbo;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFBO((T_ACI_CMD_SRC)src_infos_psi->srcId, 
  	              (T_ACI_FBO_VAL*)&fbo.value);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFBS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFBS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fbs fbs;

  TRACE_FUNCTION ("qBAT_PlusFBS()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FBS; 
  resp.response.ptr_que_plus_fbs = &fbs;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFBS((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	              (S16*)&fbs.tbs, (S16*)&fbs.rbs);
  
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFBU         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFBU(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret = ACI_BAT_FAIL;

  TRACE_FUNCTION ("sBAT_PlusFBU(): is obsolete <=== !!! consult KJF");

  /*
  ret = sAT_PlusFBU(src_infos_psi->srcId, 
                    cmd->params.ptr_set_plus_fbu->value);
  */

  ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotSupp);
  
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFBU         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFBU(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret = ACI_BAT_FAIL;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fbu fbu;

  TRACE_FUNCTION ("qBAT_PlusFBU()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FBU;
  resp.response.ptr_que_plus_fbu = &fbu;
  
  //???ret = qAT_PlusFBU(src_infos_psi->srcId, &fbu.val);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFCC         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFCC(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  
  T_BAT_cmd_set_plus_fcc *fcc = cmd->params.ptr_set_plus_fcc;

  TRACE_FUNCTION ("sBAT_PlusFCC()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFCC((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_F_VR)fcc->vr,
                    (T_ACI_F_BR)fcc->br,
                    (T_ACI_F_WD)fcc->wd,
                    (T_ACI_F_LN)fcc->ln,
                    (T_ACI_F_DF)fcc->df,
                    (T_ACI_F_EC)fcc->ec,
                    (T_ACI_F_BF)fcc->bf,
                    (T_ACI_F_ST)fcc->st,
                    (T_ACI_F_JP)fcc->jp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFCC         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFCC(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fcc fcc;

  TRACE_FUNCTION ("qBAT_PlusFCC()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FCC;
  resp.response.ptr_que_plus_fcc = &fcc;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFCC((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_F_VR*)&fcc.vr,
                    (T_ACI_F_BR*)&fcc.br,
                    (T_ACI_F_WD*)&fcc.wd,
                    (T_ACI_F_LN*)&fcc.ln,
                    (T_ACI_F_DF*)&fcc.df,
                    (T_ACI_F_EC*)&fcc.ec,
                    (T_ACI_F_BF*)&fcc.bf,
                    (T_ACI_F_ST*)&fcc.st,
                    (T_ACI_F_JP*)&fcc.jp);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFCLASS      |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFCLASS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                      T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFCLASS()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFCLASS((T_ACI_CMD_SRC)src_infos_psi->srcId,
                       (T_ACI_FCLASS_CLASS)cmd->params.ptr_set_plus_fclass->n); 
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFCLASS      |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFCLASS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                      T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fclass fclass;

  TRACE_FUNCTION ("qBAT_PlusFCLASS()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FCLASS;
  resp.response.ptr_que_plus_fclass = &fclass;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFCLASS((T_ACI_CMD_SRC)src_infos_psi->srcId, 
  	               (T_ACI_FCLASS_CLASS*)&fclass.n); 

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFCQ         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFCQ(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFCQ()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFCQ((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_FCQ_RQ)cmd->params.ptr_set_plus_fcq->rq,
                    (T_ACI_FCQ_TQ)cmd->params.ptr_set_plus_fcq->tq);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFCQ         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFCQ(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fcq fcq;

  TRACE_FUNCTION ("qBAT_PlusFCQ()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FCQ;
  resp.response.ptr_que_plus_fcq = &fcq;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFCQ((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	              (T_ACI_FCQ_RQ*)&fcq.rq,(T_ACI_FCQ_TQ*)&fcq.tq); 

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFCR         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFCR(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFCR()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFCR((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_FCR_VAL)cmd->params.ptr_set_plus_fcr->value);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFCR         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFCR(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fcr fcr;

  TRACE_FUNCTION ("qBAT_PlusFCR()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FCR;
  resp.response.ptr_que_plus_fcr = &fcr;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFCR((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	             (T_ACI_FCR_VAL*)&fcr.value); 

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFCS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFCS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fcs fcs;

  TRACE_FUNCTION ("qBAT_PlusFCS()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FCS;
  resp.response.ptr_que_plus_fcs = &fcs;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFCS((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_F_VR*)&fcs.vr,
                    (T_ACI_F_BR*)&fcs.br,
                    (T_ACI_F_WD*)&fcs.wd,
                    (T_ACI_F_LN*)&fcs.ln,
                    (T_ACI_F_DF*)&fcs.df,
                    (T_ACI_F_EC*)&fcs.ec,
                    (T_ACI_F_BF*)&fcs.bf,
                    (T_ACI_F_ST*)&fcs.st,
                    (T_ACI_F_JP*)&fcs.jp); 

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFEA         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFEA(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret = ACI_BAT_FAIL;

  TRACE_FUNCTION ("sBAT_PlusFEA(): is obsolete <=== !!! consult KJF");
  /* adjust the left hand side
    xxx = cmd->params.ptr_set_plus_fea->value;
  */
  /* hmm, do not know which ACI function to call ! */
  ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotSupp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFEA         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFEA(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret = ACI_BAT_FAIL;

  TRACE_FUNCTION ("qBAT_PlusFEA(): is obsolete <=== !!! consult KJF");
  /* hmm, do not know which ACI function to call ! */
  ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotSupp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFFC         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFFC(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  T_BAT_cmd_set_plus_ffc *ffc = cmd->params.ptr_set_plus_ffc;

  TRACE_FUNCTION ("sBAT_PlusFFC()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFFC((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_FFC_VRC)ffc->vrc,
                    (T_ACI_FFC_DFC)ffc->dfc,
                    (T_ACI_FFC_LNC)ffc->lnc,
                    (T_ACI_FFC_WDC)ffc->wdc);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFFC         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFFC(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_ffc ffc;

  TRACE_FUNCTION ("qBAT_PlusFFC()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FFC;
  resp.response.ptr_que_plus_ffc = &ffc;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFFC((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_FFC_VRC*)&ffc.vrc,(T_ACI_FFC_DFC*)&ffc.dfc,
                    (T_ACI_FFC_LNC*)&ffc.lnc,(T_ACI_FFC_WDC*)&ffc.wdc);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFHS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFHS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fhs fhs;

  TRACE_FUNCTION ("qBAT_PlusFHS()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FHS;
  resp.response.ptr_que_plus_fhs = &fhs;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFHS((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	              (T_ACI_FHS_STAT*)&fhs.status); 

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFIE         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFIE(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFIE()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFIE((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_FIE_VAL)cmd->params.ptr_set_plus_fie->value);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFIE         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFIE(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;

  T_BAT_res_que_plus_fie fie;

  TRACE_FUNCTION ("qBAT_PlusFIE()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FIE;
  resp.response.ptr_que_plus_fie = &fie;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFIE((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	              (T_ACI_FIE_VAL*)&fie.value); 
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFIS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFIS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  T_BAT_cmd_set_plus_fis *fis = cmd->params.ptr_set_plus_fis;

  TRACE_FUNCTION ("sBAT_PlusFIS()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFIS((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_F_VR)fis->vr,
                    (T_ACI_F_BR)fis->br,
                    (T_ACI_F_WD)fis->wd,
                    (T_ACI_F_LN)fis->ln,
                    (T_ACI_F_DF)fis->df,
                    (T_ACI_F_EC)fis->ec,
                    (T_ACI_F_BF)fis->bf,
                    (T_ACI_F_ST)fis->st,
                    (T_ACI_F_JP)fis->jp); 
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFIS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFIS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;

  T_BAT_res_que_plus_fis fis;

  TRACE_FUNCTION ("qBAT_PlusFIS()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FIS;
  resp.response.ptr_que_plus_fis = &fis;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFIS((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_F_VR*)&fis.vr,
                    (T_ACI_F_BR*)&fis.br,
                    (T_ACI_F_WD*)&fis.wd,
                    (T_ACI_F_LN*)&fis.ln,
                    (T_ACI_F_DF*)&fis.df,
                    (T_ACI_F_EC*)&fis.ec,
                    (T_ACI_F_BF*)&fis.bf,
                    (T_ACI_F_ST*)&fis.st,
                    (T_ACI_F_JP*)&fis.jp); 

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFLI         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFLI(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFLI()");
 
  ret = (T_ACI_BAT_RSLT)sAT_PlusFLI((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (CHAR*)cmd->params.ptr_set_plus_fli->id_str);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFLI         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFLI(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fli fli;

  TRACE_FUNCTION ("qBAT_PlusFLI()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FLI;
  resp.response.ptr_que_plus_fli = &fli;
  
  ret = (T_ACI_BAT_RSLT)qAT_PlusFLI((T_ACI_CMD_SRC)src_infos_psi->srcId, 
  	              (CHAR*)fli.id_str);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFLO         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFLO(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFLO()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusIFC((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_RX_FLOW_CTRL)cmd->params.ptr_set_plus_flo->flo_c,
                    (T_ACI_RX_FLOW_CTRL)cmd->params.ptr_set_plus_flo->flo_c); 
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFLO         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFLO(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_flo flo;
  T_ACI_RX_FLOW_CTRL DCE_by_DTE;
  T_ACI_RX_FLOW_CTRL DTE_by_DCE;
  
  TRACE_FUNCTION ("qBAT_PlusFLO()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FLO;
  resp.response.ptr_que_plus_flo = &flo;

  ret = (T_ACI_BAT_RSLT)qAT_PlusIFC((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	              &DCE_by_DTE, &DTE_by_DCE);

  flo.flo_q = (T_BAT_plus_flo_flo_q)DCE_by_DTE;

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFLP         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFLP(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFLP()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFLP((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_FLP_VAL)cmd->params.ptr_set_plus_flp->value);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFLP         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFLP(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_flp flp;

  TRACE_FUNCTION ("qBAT_PlusFLP()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FLP;
  resp.response.ptr_que_plus_flp = &flp;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFLP((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	             (T_ACI_FLP_VAL*)&flp.value);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFMS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFMS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFMS()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFMS((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_F_BR)cmd->params.ptr_set_plus_fms->value); 
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFMS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFMS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fms fms;

  TRACE_FUNCTION ("qBAT_PlusFMS()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FMS;
  resp.response.ptr_que_plus_fms = &fms;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFMS((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	             (T_ACI_F_BR*)&fms.value);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFNS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFNS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFNS()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFNS((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    cmd->params.ptr_set_plus_fns->c_nsf,
                    cmd->params.ptr_set_plus_fns->nsf); 
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFNS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFNS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fns fns;

  TRACE_FUNCTION ("qBAT_PlusFNS()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FNS;
  resp.response.ptr_que_plus_fns = &fns;
  
  ret = (T_ACI_BAT_RSLT)qAT_PlusFNS((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	              &fns.c_nsf, fns.nsf);
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFPA         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFPA(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFPA()");
  ret = (T_ACI_BAT_RSLT)sAT_PlusFPA((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (CHAR*)cmd->params.ptr_set_plus_fpa->spa_str); 
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFPA         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFPA(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fpa fpa;

  TRACE_FUNCTION ("qBAT_PlusFPA()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FPA;
  resp.response.ptr_que_plus_fpa = &fpa;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFPA((T_ACI_CMD_SRC)src_infos_psi->srcId, 
  	             (CHAR*)fpa.spa_str);
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFPI         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFPI(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFPI()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFPI((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (CHAR*)cmd->params.ptr_set_plus_fpi->id_str);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFPI         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFPI(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fpi fpi;

  TRACE_FUNCTION ("qBAT_PlusFPI()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FPI;
  resp.response.ptr_que_plus_fpi = &fpi;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFPI((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	             (CHAR*)fpi.id_str); 
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFPS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFPS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFPS()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFPS((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (T_ACI_FPS_PPR)cmd->params.ptr_set_plus_fps->ppr);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFPS         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFPS(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fps fps;

  TRACE_FUNCTION ("qBAT_PlusFPS()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FPS;
  resp.response.ptr_que_plus_fps = &fps;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFPS((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	               (T_ACI_FPS_PPR*)&fps.ppr); 
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFPW         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFPW(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFPW()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFPW((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    (CHAR*)cmd->params.ptr_set_plus_fpw->pw_str);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFPW         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFPW(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fpw fpw;

  TRACE_FUNCTION ("qBAT_PlusFPW()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FPW;
  resp.response.ptr_que_plus_fpw = &fpw;
  
  ret = (T_ACI_BAT_RSLT)qAT_PlusFPW((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	               (CHAR*)fpw.pw_str);
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFRQ         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFRQ(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFRQ()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFRQ((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    cmd->params.ptr_set_plus_frq->pgl,
                    cmd->params.ptr_set_plus_frq->cbl);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFRQ         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFRQ(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_frq frq;

  TRACE_FUNCTION ("qBAT_PlusFRQ()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FRQ;
  resp.response.ptr_que_plus_frq = &frq;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFRQ((T_ACI_CMD_SRC)src_infos_psi->srcId, 
  	             (SHORT*)&frq.pgl, (SHORT*)&frq.cbl);
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFCT         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFCT(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFCT()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFCT((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    cmd->params.ptr_set_plus_fct->value);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFCT         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFCT(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fct fct;

  TRACE_FUNCTION ("qBAT_PlusFCT()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FCT;
  resp.response.ptr_que_plus_fct = &fct;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFCT((T_ACI_CMD_SRC)src_infos_psi->srcId, 
  	               (SHORT*)&fct.value); 
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFSA         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFSA(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFSA()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFSA((T_ACI_CMD_SRC)src_infos_psi->srcId, 
                    (CHAR*)cmd->params.ptr_set_plus_fsa->sub_str);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFSA         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFSA(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fsa fsa;

  TRACE_FUNCTION ("qBAT_PlusFSA()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FSA;
  resp.response.ptr_que_plus_fsa = &fsa;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFSA((T_ACI_CMD_SRC)src_infos_psi->srcId,
  	                                                    (CHAR*)fsa.sub_str);
  
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFSP         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFSP(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFSP()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFSP((T_ACI_CMD_SRC)src_infos_psi->srcId, 
          (T_ACI_FSP_VAL)cmd->params.ptr_set_plus_fsp->poll);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFSP         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFSP(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fsp fsp;

  TRACE_FUNCTION ("qBAT_PlusFSP()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FSP;
  resp.response.ptr_que_plus_fsp = &fsp;

  ret = (T_ACI_BAT_RSLT)qAT_PlusFSP((T_ACI_CMD_SRC)src_infos_psi->srcId, 
  	    (T_ACI_FSP_VAL*)&fsp.poll);

  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : sBAT_PlusFIT         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT sBAT_PlusFIT(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;

  TRACE_FUNCTION ("sBAT_PlusFIT()");

  ret = (T_ACI_BAT_RSLT)sAT_PlusFIT((T_ACI_CMD_SRC)src_infos_psi->srcId,
                    cmd->params.ptr_set_plus_fit->time,
                    (T_ACI_FIT_ACT)cmd->params.ptr_set_plus_fit->action);
  return(ret);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)            MODULE  : ACI_BAT              |
| STATE   : code                      ROUTINE : qBAT_PlusFIT         |
+--------------------------------------------------------------------+

  PURPOSE : ITU-T.32
*/
GLOBAL T_ACI_BAT_RSLT qBAT_PlusFIT(T_ACI_DTI_PRC_PSI *src_infos_psi,
                                   T_BAT_cmd_send    *cmd)
{
  T_ACI_BAT_RSLT ret;
  T_BAT_cmd_response resp;
  T_BAT_res_que_plus_fit fit;

  TRACE_FUNCTION ("qBAT_PlusFIT()");

  resp.ctrl_response = BAT_RES_QUE_PLUS_FIT;
  resp.response.ptr_que_plus_fit = &fit;
  
  ret = (T_ACI_BAT_RSLT)qAT_PlusFIT((T_ACI_CMD_SRC)src_infos_psi->srcId, 
  	   (SHORT*)&fit.time, (T_ACI_FIT_ACT*)&fit.action);
  aci_bat_send(src_infos_psi, &resp);
  return(ret);
}

#endif /* FF_FAX */