view src/g23m-aci/aci/psa_psis.c @ 205:81f5c4ca1fb3

mmiDialogs.c: make dialog_info() static The function in question was first declared as static, then defined as non-static, which should be considered invalid C. Given that this function is not referenced from any other modules and appears to have been intended as static, make it so.
author Mychaela Falconia <falcon@freecalypso.org>
date Tue, 06 Apr 2021 01:28:52 +0000
parents fa8dc04885d8
children
line wrap: on
line source

/* 
+----------------------------------------------------------------------------- 
|  Project :  GSM-PS (6147)
|  Modul   :  PSA_PSIS
+----------------------------------------------------------------------------- 
|  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 module defines the processing functions for the
|             primitives sent to the protocol stack adapter by the DTI
|             interface.
+----------------------------------------------------------------------------- 
*/ 

#ifdef FF_PSI
#define PSA_PSIS_C


#include "aci_all.h"

/*==== INCLUDES ===================================================*/
#include "aci_cmh.h"
#include "ati_cmd.h"
#include "aci_cmd.h"
#include "dti.h"      /* functionality of the dti library */

#include "aci.h"
#include "aci_lst.h"
#include "dti_conn_mng.h"
#include "dti_cntrl_mng.h"
#include "psa_psi.h"
#include "cmh_psi.h"

#include "aci_mem.h"

#include "aci_io.h"

#include "sap_dti.h"



/*==== CONSTANTS ==================================================*/


/*==== TYPES ======================================================*/


/*==== EXPORT =====================================================*/

/*==== VARIABLES ==================================================*/


/*==== FUNCTIONS ==================================================*/

LOCAL USHORT psi_get_desc_size (T_desc2 *data)
{
  USHORT size = 0;
  T_desc2 *next_data;

  next_data = data;
  while (next_data NEQ NULL)
  {
    size += next_data->len;
    next_data = (T_desc2*)next_data->next;
  }

  return (size);
}

#ifdef DTI

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : PSA_PSIS              |
| STATE   : finished              ROUTINE : psaPSI_ConnectRej       |
+-------------------------------------------------------------------+

  PURPOSE : Indicates that ACI can not handle a DTI connection with PSI

*/
GLOBAL void psaPSI_ConnRej ( U32 devId)
{
  TRACE_FUNCTION ("psaPSI_ConnRej()");
  {
    PALLOC ( psi_conn_rej, PSI_CONN_REJ);
    psi_conn_rej->devId = devId;
    PSENDX (PSI, psi_conn_rej);
  }
}

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : PSA_PSIS              |
| STATE   : finished              ROUTINE : psaPSI_ConnectRes       |
+-------------------------------------------------------------------+

  PURPOSE : Response to PSI_CONN_IND sent by PSI with confirmed
            DIO capabilities

*/
GLOBAL void psaPSI_ConnRes ( U32 devId)
{
  TRACE_FUNCTION ("psaPSI_ConnRes()");
  {
    PALLOC ( psi_conn_res, PSI_CONN_RES);
    psi_conn_res->devId = devId;
    PSENDX (PSI, psi_conn_res);
  }
}

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : PSA_PSIS              |
| STATE   : finished              ROUTINE : psaPSI_CloseReq      |
+-------------------------------------------------------------------+

  PURPOSE : Request closing of DTI connection with PSI

*/
GLOBAL void psaPSI_CloseReq ( U32 devId)
{
  TRACE_FUNCTION ("psaPSI_DTICloseReq()");
  {
    PALLOC ( psi_close_req, PSI_CLOSE_REQ);
    psi_close_req->devId = devId;
    PSENDX (PSI, psi_close_req);
  }
}

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : PSA_PSIS              |
| STATE   : finished              ROUTINE : psaPSI_DTICloseReq      |
+-------------------------------------------------------------------+

  PURPOSE : Request closing of DTI connection with PSI

*/
GLOBAL void psaPSI_DTICloseReq ( U32 devId, U32 link_id)
{
  TRACE_FUNCTION ("psaPSI_DTICloseReq()");
  {
    PALLOC ( psi_dti_close_req, PSI_DTI_CLOSE_REQ);
    psi_dti_close_req->devId = devId;
    psi_dti_close_req->link_id = link_id;
    PSENDX (PSI, psi_dti_close_req);
  }
}

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)           MODULE  : PSA_PKTIOS              |
| STATE   : finished              ROUTINE : psaPSI_DTIOpenReq       |
+-------------------------------------------------------------------+

  PURPOSE : Request opening of DTI connection with PSI

*/
GLOBAL void psaPSI_DTIOpenReq ( U32 devId, char* peer_name,
                                ULONG link_id, UBYTE dti_direction)
{
  TRACE_FUNCTION ("psaPSI_DTIOpenReq()");

 /* if (dti_cntrl_set_conn_parms(link_id, DTI_ENTITY_PSI, (UBYTE)(devId&DIO_DEVICE_MASK), 
             UART_DLCI_NOT_MULTIPLEXED) EQ FALSE)
  {
    return;
  }*/
  {
    PALLOC ( psi_dti_open_req, PSI_DTI_OPEN_REQ);
    psi_dti_open_req->devId = devId;
    memcpy( &(psi_dti_open_req->peer.name), peer_name, strlen(peer_name) + 1 );    
    psi_dti_open_req->link_id = link_id;
    psi_dti_open_req->dti_direction = dti_direction;

    PSENDX (PSI, psi_dti_open_req);
  }
}

/*
+-------------------------------------------------------------------+
| PROJECT : GPRS (8441)            MODULE  : PSA_PSIS               |
| STATE   : finished               ROUTINE : psaPSI_Dti_Req         |
+-------------------------------------------------------------------+

  PURPOSE : Request for DTI connection by DTI managment

*/
GLOBAL void psaPSI_Dti_Req ( ULONG  link_id, UBYTE  peer, 
                             T_DTI_MNG_PSI_MODE con_mode)
{
  UBYTE device_no;
  U32  devId;
  char*  peer_name;
  T_DTI_CNTRL  device_info;
  U32 cpblty = DTI_CPBLTY_NO;
  
  TRACE_FUNCTION ("psaPSI_Dti_Req()"); 
      
  dti_cntrl_get_info_from_dti_id(EXTRACT_DTI_ID(link_id), &device_info);

  device_no = device_info.dev_no;
  switch (device_info.capability-DTI_CPBLTY_CMD )
  {
    case DTI_CPBLTY_CMD: 
       cpblty = DTI_CPBLTY_CMD;
       break;
    case DTI_CPBLTY_SER: 
       if (device_info.sub_no EQ 0)
       {
          cpblty = DIO_DATA_SER;
       }
       else
       {
          cpblty = DIO_DATA_SER_MUX;
       }
       break;
    case DTI_CPBLTY_PKT: 
       cpblty = DIO_DATA_PKT;
       break;
    default: 
       break;       
  }
/*the mapping of capability between DTI and PSI should be done here, since devId relates 
    to the device type */
  devId = ((device_info.driver_id & 0xff)<<24|
            cpblty|
            (device_info.dio_ctrl_id & 0xff)<<8|
            device_no);
  peer_name = dti_entity_name[peer].name;
 
  if(con_mode EQ PSI_CONNECT_DTI)
  {
    dti_cntrl_set_conn_parms((T_DTI_CONN_LINK_ID)link_id, DTI_ENTITY_PSI,
                              device_info.dev_no, UART_DLCI_NOT_MULTIPLEXED);

    psaPSI_DTIOpenReq (devId, peer_name, link_id, DTI_CHANNEL_TO_HIGHER_LAYER);
  }
  else
  { 
    psaPSI_DTICloseReq(devId, link_id);                           
  }
}
#endif /* DTI */

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : PSA_PSIS                     |
|                            ROUTINE : psa_psi_DTI_data_req         |
+-------------------------------------------------------------------+

  PURPOSE :

*/

GLOBAL void psa_psi_DTI_data_req (
                               T_desc2 *data,
                               T_ACI_DTI_PRC_PSI *src_infos,
                               T_DTI_ENTITY_ID peer_id
                               )
{
  USHORT data_len = 0;

  TRACE_FUNCTION("psa_psi_DTI_data_req()");

  {
    PALLOC_DESC2(dti_data_ind, DTI2_DATA_IND);

    data_len = psi_get_desc_size (data);

    dti_data_ind->desc_list2.list_len  = data_len;
    dti_data_ind->desc_list2.first     = (ULONG)data;

    dti_data_ind->parameters.p_id               = 0; /*dummy_ubyte; */

    if (BITFIELD_CHECK (src_infos->data_cntr, PSI_DTI_FLOW_OFF))
    {
      dti_data_ind->parameters.st_lines.st_flow = DTI_FLOW_OFF;
    }
    else
    {
      dti_data_ind->parameters.st_lines.st_flow = DTI_FLOW_ON;
    }

    if (BITFIELD_CHECK (src_infos->data_cntr, PSI_DTI_SB_BIT))
    {
      TRACE_EVENT("SB is ON");
      dti_data_ind->parameters.st_lines.st_line_sb = DTI_SB_ON;
    }
    else
    {
      TRACE_EVENT("SB is OFF");
      dti_data_ind->parameters.st_lines.st_line_sb = DTI_SB_OFF;
    }

    dti_data_ind->parameters.st_lines.st_line_sa = DTI_SA_ON;
    dti_data_ind->parameters.st_lines.st_break_len = DTI_BREAK_OFF;

    dti_send_data
    (
      aci_hDTI,
      src_infos->srcId,
      (UBYTE)peer_id,
      ACI_DTI_DN_CHANNEL,
      dti_data_ind
    );
  }
}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : PSA_PSI                      |
|                            ROUTINE : psa_psi_DTI_getdata          |
+-------------------------------------------------------------------+

  PURPOSE :

*/

GLOBAL void psa_psi_DTI_getdata( UBYTE src_id, T_DTI_ENTITY_ID peer_id)
{
  T_ACI_DTI_PRC_PSI *src_infos = NULL;

  TRACE_FUNCTION("psaDTI_getdata");

  src_infos = find_element (psi_src_params, src_id, cmhPSItest_srcId);
  if (src_infos EQ NULL)
  {
    TRACE_EVENT_P1("[ERR] psaDTI_getdata: link_id=%d not found", src_id) ;
    return ;
  }

  if( src_infos->RecState NEQ RECEIVING)
  {
    src_infos->RecState = READY_REC;
  }

  {
    dti_start
    (
      aci_hDTI,
      src_id,
      (UBYTE)peer_id,
      ACI_DTI_DN_CHANNEL
    );
  }
}

#ifdef DTI
/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : PSA_PSI                     |
|                            ROUTINE : psaPSI_DCDreq               |
+-------------------------------------------------------------------+

  PURPOSE :

*/

GLOBAL void psaPSI_DCDreq( UBYTE c_Id, UBYTE line_state )
{
  T_ACI_DTI_PRC_PSI *cmd  = NULL;

  TRACE_FUNCTION("psaPSI_DCDreq()");

  cmd = find_element (psi_src_params, c_Id, cmhPSItest_srcId);
  if (cmd EQ NULL)
  {
    TRACE_EVENT_P1("[ERR] psaPSI_DCDreq: c_Id=%d not found", c_Id) ;
    return ;
  }

  {
    PALLOC( psi_line_state_req, PSI_LINE_STATE_REQ);
    psi_line_state_req -> devId = cmd->devId;
    if( line_state EQ IO_DCD_ON )
    {
      psi_line_state_req -> line_state = LINE_STD_DCD_ON;
    }
    else if ( line_state EQ IO_DCD_OFF )
    {
      psi_line_state_req -> line_state = LINE_STD_DCD_OFF;
    }

    PSENDX( PSI, psi_line_state_req );
  }
}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : PSA_PSI                      |
|                            ROUTINE : psaPSI_ESCAPEreq               |
+-------------------------------------------------------------------+

  PURPOSE :

*/

GLOBAL BOOL psaPSI_ESCAPEreq( UBYTE c_Id, UBYTE detection )
{
  T_ACI_DEVICE_DCB_ENTRY *device_entry = cmhPSI_GetDeviceParOverSrcID( c_Id );
  U32 device_type;
  if ( device_entry EQ NULL )
  {
    TRACE_EVENT_P1("[ERR] cmhPSI_SetDataRate: device for source ID = %d not found", c_Id);
    return (FALSE);
  }

  TRACE_FUNCTION("psaPSI_ESCAPEreq()");
  
  device_type = device_entry->devId & DIO_TYPE_DAT_MASK;
  cmhPSI_SetDcbParToUnchanged( device_entry );
  if (device_type EQ DIO_DATA_SER)
  {
    if( detection EQ ESC_DETECTION_ON)
    {
      device_entry->dcbPar.dio_dcb_ser.guard_period = DIO_GUARD_PER_DEFAULT;
    }
    else
    {
      device_entry->dcbPar.dio_dcb_ser.guard_period = 0;
    }
  }      
  else if (device_type EQ DIO_DATA_MUX)
  {
    if( detection EQ ESC_DETECTION_ON)
    {
      device_entry->dcbPar.dio_dcb_ser_mux.guard_period = DIO_GUARD_PER_DEFAULT;
    }
    else
    {
      device_entry->dcbPar.dio_dcb_ser_mux.guard_period = 0;  
    }
  }

  else /* if (device_type EQ DIO_DATA_PKT)*/
  {
    return (FALSE);
  }
  
  psaPSI_SetConfReq(device_entry);
  
  return (TRUE);

}

/*
+-------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : PSA_PSI                      |
|                            ROUTINE : psaPSI_RINGreq              |
+-------------------------------------------------------------------+

  PURPOSE :

*/

GLOBAL void psaPSI_RINGreq( UBYTE c_Id, UBYTE line_state )
{
  T_ACI_DTI_PRC_PSI *cmd  = NULL;

  TRACE_FUNCTION("psaPSI_RINGreq");

  cmd = find_element (psi_src_params, c_Id, cmhPSItest_srcId);
  if (cmd EQ NULL)
  {
    TRACE_EVENT_P1("[ERR] psaPSI_RINGreq: c_Id=%d not found", c_Id) ;
    return ;
  }

  if (BITFIELD_CHECK (cmd->data_cntr, PSI_RING_RUNNING))
  {
    TRACE_EVENT_P2 ("[WRN] psaPSI_RINGreq(): no CNF for previous REQ (device: %d; dlci=%d)",
                    cmd->devId, cmd->dlci);
    return;
  }

  /*
     store that PSI_RING_REQ was send
     this is important so that the primitive queue in the PSI entity not
     overloaded if no PC is connected
  */
  BITFIELD_SET (cmd->data_cntr, PSI_RING_RUNNING);

  {
    PALLOC( psi_line_state_req, PSI_LINE_STATE_REQ);
    psi_line_state_req -> devId = cmd->devId;

    if( line_state EQ IO_RING_ON)
    {
      psi_line_state_req -> line_state = LINE_STD_RING_ON;
    }
    else if( line_state EQ IO_RING_OFF )
    {
      psi_line_state_req -> line_state = LINE_STD_RING_OFF;
    }

    PSENDX( PSI, psi_line_state_req);
  }
}

/*
+------------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)    MODULE  : PSA_PSI                           |
|                            ROUTINE : psaPSI_SetConfReq                 |
+------------------------------------------------------------------------+

  PURPOSE :

*/

GLOBAL void psaPSI_SetConfReq( T_ACI_DEVICE_DCB_ENTRY *dcbPar )
{
  U32 device_type;
#ifdef _SIMULATION_
  PALLOC(psi_setconf_req_test, PSI_SETCONF_REQ_TEST);

  device_type = dcbPar->devId & DIO_TYPE_DAT_MASK;
  psi_setconf_req_test->devId = dcbPar->devId;
  switch (device_type)
  {
     case DIO_DATA_SER:
        memcpy(&psi_setconf_req_test->DIO_DCB_UN.DIO_DCB_SER,&dcbPar->dcbPar.dio_dcb_ser,sizeof(T_DIO_DCB_SER));
        break;
     case DIO_DATA_PKT:
        memcpy(&psi_setconf_req_test->DIO_DCB_UN.DIO_DCB_PKT,&dcbPar->dcbPar.dio_dcb_pkt,sizeof(T_DIO_DCB_PKT));
        break;
     case DIO_DATA_SER_MUX:
        memcpy(&psi_setconf_req_test->DIO_DCB_UN.DIO_DCB_SER_MUX,&dcbPar->dcbPar.dio_dcb_ser_mux,sizeof(T_DIO_DCB_SER_MUX));
        break;  
     default:
         break;
  } 
  PSENDX( PSI, psi_setconf_req_test );
#else
  PALLOC(psi_setconf_req, PSI_SETCONF_REQ);

  device_type = dcbPar->devId & DIO_TYPE_DAT_MASK;
  psi_setconf_req->devId = dcbPar->devId;
  switch (device_type)
  {
     case DIO_DATA_SER:
        psi_setconf_req->ptr_DIO_DCB   = (T_DIO_DCB *) &dcbPar->dcbPar.dio_dcb_ser;
         break;
       case DIO_DATA_PKT:
         psi_setconf_req->ptr_DIO_DCB   =(T_DIO_DCB *)  &dcbPar->dcbPar.dio_dcb_pkt;
         break;
       case DIO_DATA_SER_MUX:
        psi_setconf_req->ptr_DIO_DCB   =(T_DIO_DCB *)  &dcbPar->dcbPar.dio_dcb_ser_mux;
         break;
     default:
         break;
  } 
  PSENDX( PSI, psi_setconf_req );
#endif /* _SIMULATION_ */
}
#endif /* DTI */
#endif /*FF_PSI*/
/*==== EOF =======================================================*/