view src/g23m-fad/app/app_pei.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

/* 
+------------------------------------------------------------------------------
|  File:       app_pei.c
+------------------------------------------------------------------------------
|  Copyright 2003 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 implements the PEI interface
|             for the entity app.
+----------------------------------------------------------------------------- 
*/ 

#define APP_PEI_C

#define ENTITY_APP
/* this #define SAP_TCPIP and #define SAP_DCM in prim.h - */

#define APP_STACK_SIZE    1500
#define APP_QUEUE_SIZE    10   /* queue entries */
#define APP_PRIORITY      90   /* priority (1->low, 255->high) */
#define APP_NUM_TIMER     10   /* number of timers */


/*==== INCLUDES =============================================================*/

#include <string.h>     /* to get strcmp() */
#include <stdlib.h>     /* to get atoi() */
#include <stdio.h>      /* to get sprintf() */

#include "typedefs.h"   /* to get Condat data types */
#include "vsi.h"        /* to get a lot of macros */
#include "gsm.h"        /* to get a lot of macros */
#include "prim.h"       /* to get the definitions of used SAP and directions */
#include "pei.h"        /* to get PEI interface */
#include "tools.h"      /* to get common tools */

#ifdef FF_GPF_TCPIP
#include "socket_api.h"     /* to get sockets' definitions */
#endif /* FF_GPF_TCPIP */

#include "mon_app.h"    /* to get mon-definitions */
#include "app.h"        /* to get the global entity definitions */


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

EXTERN char *app_handle_command_gdd(char *);
EXTERN char *app_handle_at_command(char *);
EXTERN char* app_handle_command_bat(char *);

/*==== CONSTS ================================================================*/

/* 
 * Wait as long as possible. This is the time in ms that is waited for a 
 * message in the input queue in the active variant. 
 * It can be decreased by the customer.  
 */   
#define APP_TIMEOUT     0xffffffff   

/* Entity name 
 */
#define ENTITY_NAME_APP "APP"

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

/*==== LOCALS ================================================================*/

static  BOOL          first_access  = TRUE;
static  BOOL          exit_flag = FALSE;
static  T_MONITOR     app_mon;


#ifdef FF_GPF_TCPIP
T_SOCK_API_INSTANCE   sock_api_inst = 0 ; /* Also needed by the appl. core. */
// System wide handle of a bearer connection. For future use (multiple PDP contexts)!!
T_SOCK_BEARER_HANDLE  sock_bearer_handle = 0;
#endif /* FF_GPF_TCPIP */

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

/*
+------------------------------------------------------------------------------
|  Function     :  primitive_not_supported
+------------------------------------------------------------------------------
|  Description  :  This function handles unsupported primitives.
|
|  Parameters   :  data - not used
|
|  Return       :  void
+------------------------------------------------------------------------------
*/
LOCAL  void primitive_not_supported (void *data)
{
  TRACE_FUNCTION ("primitive_not_supported");

  PFREE (data);
}


/*
+------------------------------------------------------------------------------
|  Function     :  pei_primitive
+------------------------------------------------------------------------------
|  Description  :  Process protocol specific primitive.
|
|  Parameters   :  prim      - pointer to the received primitive
|
|  Return       :  PEI_OK    - function succeeded
|                  PEI_ERROR - function failed
+------------------------------------------------------------------------------
*/
static short pei_primitive (void * ptr)
{
  T_PRIM * prim = (T_PRIM *) ptr;
  unsigned long  opc;
  BOOL           result = FALSE;

  TRACE_FUNCTION ("pei_primitive");

  if (prim EQ NULL)
  {
    TRACE_EVENT("Empty primitive");
    return PEI_OK;
  }
  
  /*
   * This must be called for Partition Pool supervision. Will be replaced
   * by another macro some time.
   */
  VSI_PPM_REC (&prim->custom, __FILE__, __LINE__);

  opc = prim->custom.opc;
  PTRACE_IN(opc);

#ifdef FF_GPF_TCPIP
  result = sock_api_handles_primitive(sock_api_inst, prim);
#endif /* FF_GPF_TCPIP */
  if(FALSE EQ result)
  {
    // primitive is not a GSM primitive - forward it to the environment
    if(opc & SYS_MASK)
    {
      vsi_c_primitive (VSI_CALLER prim);
    }
    else
    {
      primitive_not_supported (P2D(prim));
      return PEI_ERROR;
    }
  }
  return PEI_OK;
}


/*
+------------------------------------------------------------------------------
|  Function     : pei_init
+------------------------------------------------------------------------------
|  Description  :  Initialize Protocol Stack Entity
|
|  Parameters   :  handle    - task handle
|
|  Return       :  PEI_OK    - entity initialised
|                  PEI_ERROR - entity not (yet) initialised
+------------------------------------------------------------------------------
*/
static short pei_init (T_HANDLE handle)
{
  short ret_value = PEI_OK;
  BOOL ret = FALSE;
  TRACE_FUNCTION ("pei_init()");

  /* Initialize task handle */
  APP_handle = handle;
  
  /*
   * Initialize global pointer app_data. This is required to access all
   * entity data.
   */
  app_data = &app_data_base;

#ifdef FF_GPF_TCPIP
  /* initialize socket API */
  ret = sock_api_initialize(&sock_api_inst, handle, ENTITY_NAME_APP); 
  if (FALSE == ret)
  {
    TRACE_ERROR("sock_api_initialize() failed") ;
    return PEI_ERROR ;
  }
  TRACE_EVENT("sock_api_initialize()d successfully") ;
  ret_value = app_initialize_tcpip(handle) ;
#endif /* FF_GPF_TCPIP */

  return ret_value;
}

/*
+------------------------------------------------------------------------------
|  Function     :  pei_timeout
+------------------------------------------------------------------------------
|  Description  :  Process timeout.
|
|  Parameters   :  index     - timer index
|
|  Return       :  PEI_OK    - timeout processed
|                  PEI_ERROR - timeout not processed
+------------------------------------------------------------------------------
*/
static short pei_timeout (unsigned short index)
{
  TRACE_FUNCTION ("pei_timeout");

  /* Process timeout */
  switch (index)
  {
    case 0:
      /* Call of timeout routine */
      break;
    default:
      TRACE_ERROR("Unknown Timeout");
      return PEI_ERROR;
  }
  return PEI_OK;
}

/*
+------------------------------------------------------------------------------
|  Function     :  pei_signal
+------------------------------------------------------------------------------
|  Description  :  Process signal.
|
|  Parameters   :  opc       - signal operation code
|                  data      - pointer to primitive
|
|  Return       :  PEI_OK    - signal processed
|                  PEI_ERROR - signal not processed
+------------------------------------------------------------------------------
*/
static short pei_signal (unsigned long opc, void* data)
{
  TRACE_FUNCTION ("pei_signal()");

  /* Process signal */
  TRACE_ERROR("Unknown Signal OPC");
  return PEI_ERROR;
}

/*
+------------------------------------------------------------------------------
|  Function     :  pei_exit
+------------------------------------------------------------------------------
|  Description  :  Close Resources and terminate.
|
|  Parameters   :            - 
|
|  Return       :  PEI_OK    - exit sucessful
+------------------------------------------------------------------------------
*/
static short pei_exit (void)
{
  TRACE_FUNCTION ("pei_exit()");

#ifdef FF_GPF_TCPIP
  sock_api_deinitialize(sock_api_inst) ;
#endif /* FF_GPF_TCPIP */

  exit_flag = TRUE;

  return PEI_OK;
}

/*
+------------------------------------------------------------------------------
|  Function     :  pei_run
+------------------------------------------------------------------------------
|  Description  :  Process Primitives, main loop is located in the
|                  Protocol Stack Entity.
|                  Only needed in active body variant
|
|  Parameters   :  taskhandle  - handle of current process
|                  comhandle   - queue handle of current process
|
|  Return       :  PEI_OK      - sucessful
|                  PEI_ERROR   - not successful
+------------------------------------------------------------------------------
*/
static short pei_run (T_HANDLE taskhandle, T_HANDLE comhandle )
{
  T_QMSG message;
  unsigned long timeout = APP_TIMEOUT;

  TRACE_FUNCTION ("pei_run()");

  while (!exit_flag)
  {
    vsi_c_await (VSI_CALLER comhandle, &message, timeout);
    switch (message.MsgType)
    {
      case MSG_PRIMITIVE:
        pei_primitive (message.Msg.Primitive.Prim );
        break;
      case MSG_SIGNAL:
        pei_signal ( (USHORT)message.Msg.Signal.SigOPC, 
          message.Msg.Signal.SigBuffer );
        break;
      case MSG_TIMEOUT:
        pei_timeout ( (USHORT)message.Msg.Timer.Index );
        break;
      default:
        TRACE_ERROR("Unknown Message Type");
        break;
    }
  }

  exit_flag = FALSE;

  return PEI_OK;
}


/*
+------------------------------------------------------------------------------
|  Function     :  pei_config
+------------------------------------------------------------------------------
|  Description  :  Dynamic Configuration.
|
|  Parameters   :  in_string   - configuration string
|
|  Return       :  PEI_OK      - sucessful
|                  PEI_ERROR   - not successful
+------------------------------------------------------------------------------
*/
static short pei_config (char * in_string)
{
  char *errmsg = 0 ;   /* Error message from application. */

  TRACE_FUNCTION ("pei_config()");
  TRACE_EVENT_P1 ("Command:%s",in_string);

  if (ConfigTimer (VSI_CALLER in_string, NULL) == VSI_OK)
  {
    return PEI_OK;
  }
  
  /* BEGIN testing via PCO config strings */
  if (in_string)
  {
    /* Test commands for GDD (BAT adapter) are prefixed with 'gdd' */
    if(!strncmp("gdd", in_string, 3))
    {
      errmsg = app_handle_command_gdd(in_string);
    }
    else if (!strncmp("at_", in_string, 3))
    {
      errmsg = app_handle_at_command(in_string);
    }
/*    else if(!strncmp("batcfg_", in_string, 7))
    {
      errmsg = app_handle_command_bat(in_string);
    }*/
    /* Test commands for BAT Lib are prefixed with 'bat' */
    else if(!strncmp("bat", in_string, 3))
    {
      errmsg = app_handle_command_bat(in_string);
    }
    
#ifdef FF_GPF_TCPIP
    else
    {
      // returns '0' in case of success, errorstring else
      errmsg = app_handle_command_tcpip(in_string) ;
    }
#endif /* FF_GPF_TCPIP */
    if (errmsg)
    {
      TRACE_ERROR(errmsg) ;
    }
    else
    {
      TRACE_EVENT("command successful") ;
    }
  }
  else
  {
    TRACE_ERROR("empty config primitive") ;
  }
  return PEI_OK;
}

/*
+------------------------------------------------------------------------------
|  Function     :  pei_monitor
+------------------------------------------------------------------------------
|  Description  :  Monitoring of physical Parameters.
|
|  Parameters   :  out_monitor - return the address of the data to be monitored
|
|  Return       :  PEI_OK      - sucessful (address in out_monitor is valid)
|                  PEI_ERROR   - not successful
+------------------------------------------------------------------------------
*/
static short pei_monitor (void ** out_monitor)
{
  TRACE_FUNCTION ("pei_monitor()");

  /*
   * Version = "0.S" (S = Step).
   */
  app_mon.version = "app 0.1";
  *out_monitor = &app_mon;

  return PEI_OK;
}

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

/*
+------------------------------------------------------------------------------
|  Function     :  app_pei_create
+------------------------------------------------------------------------------
|  Description  :  Create the Protocol Stack Entity.
|
|  Parameters   :  info        - Pointer to the structure of entity parameters
|
|  Return       :  PEI_OK      - entity created successfully
|                  
+------------------------------------------------------------------------------
*/
short app_pei_create (T_PEI_INFO **info)
{
  static T_PEI_INFO pei_info =
  {
    ENTITY_NAME_APP,         /* name */
    {              /* pei-table */
      pei_init,
      pei_exit,
      pei_primitive,
      pei_timeout,
      pei_signal,
      pei_run,
      pei_config,
      pei_monitor
    },
    APP_STACK_SIZE,          
    APP_QUEUE_SIZE,            
    APP_PRIORITY,           
    APP_NUM_TIMER,            
    0x03           /* flags: bit 0   active(0) body/passive(1) */
  };               /*        bit 1   com by copy(0)/reference(1) */

  /* Close Resources if open */
  if (first_access) {
    first_access = FALSE;
  }
  else {
    pei_exit ();
  }

  /* Export startup configuration data */
  *info = &pei_info;

  return PEI_OK;
}


/*==== END OF FILE ==========================================================*/