view src/ui3/mfw/mfw_em.c @ 581:a0a45c5eb3ef

gsmcomp.c: bumping trace partition size to 220 like in gprscomp.c This change is safe in terms of RAM usage because all of these partition pools have already been moved from XRAM to IRAM earlier, and our IRAM usage in VO configs is currently quite low - the one near the limit is XRAM on C11x.
author Mychaela Falconia <falcon@freecalypso.org>
date Tue, 29 Jan 2019 03:52:49 +0000
parents f914fb46e1a5
children
line wrap: on
line source

/*
+--------------------------------------------------------------------+
| PROJECT: MMI-Framework (8417)         $Workfile:: mfw_em.c         $|
| $Author:: MC  $ CONDAT UK          $Revision:: 1                  $|
| CREATED: 23.09.02                                                 $|
| STATE  : code                                                      |
+--------------------------------------------------------------------+

   MODULE  : MFW_EM

   PURPOSE : Engineering Mode functions

*/

/*
********************************Include Files**********************************************
**/

#define ENTITY_MFW


#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include "typedefs.h"
#include "vsi.h"
#include "pei.h"
#include "custom.h"
#include "gsm.h"

#ifndef PCM_2_FFS
#include "pcm.h"
#endif

#ifndef NEPTUNE_BOARD
#include "ffs/ffs.h"
#else
#include "ffs.h"
#endif

#include "message.h"
#include "prim.h"
#include "aci_cmh.h"
#if defined (FAX_AND_DATA)
#include "aci_fd.h"
#endif

#ifdef GPRS
#include "gprs.h"
#endif
#include "dti_conn_mng.h"
#include "phb.h"
#include "psa.h"
#include "cmh.h"
#include "cmh_phb.h"
#include "psa.h"
#include "psa_sim.h"
#include "cus_aci.h"
#include "cmh_mm.h"
#include "cmh_sim.h"
#include "Mfw_em.h"
#include "aci_em.h" 
#include "mfw_win.h"

#ifdef NEPTUNE_BOARD /*EngMode */
#include "Aci_cmh.h"
#endif

#ifdef NEPTUNE_BOARD
T_ENG_INFO_REQ* Eng_Info_Req;  /*EngMode */
T_ENG_INFO_STATIC_REQ* Eng_Info_Static_Req;

int EmType = NULL;
#endif

#define ASCII_OFFSET 0x30 /*SPR 1554*/

/*
********************************Internal data types**********************************************
**/

#ifndef NEPTUNE_BOARD
typedef union
{
	MFW_EM_Mobile_Info MobileInfo;
	MFW_EM_Serving_Cell_Parameters SCInfo;
	MFW_EM_Neighbour_Cell_Parameters NCInfo;
	MFW_EM_Location_Parameters	LocInfo;
	MFW_EM_Ciph_hop_DTX_Parameters CHDTXInfo;
	MFW_EM_GPRS_Parameter GPRSInfo;
}
	T_MFW_EM_PARA;
#endif    

typedef struct
{
    T_MFW_EVENT     emask;          /* events of interest */
    T_MFW_EVENT     event;          /* current event */
    T_MFW_CB        handler;
#ifndef NEPTUNE_BOARD
    T_MFW_EM_PARA  para;
#endif
    
} T_MFW_EM;
/*
********************************Global variables**********************************************
**/

#ifndef NEPTUNE_BOARD
MFW_EM_Data* MfwEmData= NULL;
#endif

EXTERN MfwHdr *current_mfw_elem;

/*
********************************Prototypes**********************************************
**/

#ifndef NEPTUNE_BOARD
int Mfw_em_sign_exec(T_MFW_HDR * hdr, T_MFW_EVENT event,T_MFW_EM_PARA *para); 
#else /*if NEPTUNE BOARD*/
int Mfw_em_sign_exec(T_MFW_HDR * hdr, T_MFW_EVENT event,int* dummy); 
#endif
void Mfw_em_signal(MfwEvt event, void *para);

#ifndef NEPTUNE_BOARD  /*EngMode */
void Mfw_em_cb(T_DRV_SIGNAL_EM* signal);
#endif
static int emCommand (U32 cmd, void *h);

/**************************************Public Functions*****************************************/

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EM            |
| STATE   : code                        ROUTINE : Mfw_em_init           |
+--------------------------------------------------------------------+

  PURPOSE : initialise module

*/
int Mfw_em_init(void)
{	TRACE_EVENT("Mfw_em_init()");
#ifndef NEPTUNE_BOARD
	em_Init(Mfw_em_cb, NULL); /*init EM driver*/	
#endif /* NEPTUNE_BOARD */    
	mfwCommand[MfwTypEm] = (MfwCb) emCommand;
	return TRUE;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EM            |
| STATE   : code                        ROUTINE : Mfw_em_create           |
+--------------------------------------------------------------------+

  PURPOSE : binds passed callback function to event mask

*/
MfwHnd Mfw_em_create(MfwHnd hWin, MfwEvt event,  MfwCb cb_func)
{
	MfwHdr *hdr;
    T_MFW_EM *em_para;

    TRACE_EVENT("em_create()");

    hdr = (MfwHdr *) mfwAlloc(sizeof(MfwHdr));
    em_para = (T_MFW_EM *) mfwAlloc(sizeof(T_MFW_EM));

    if (!hdr || !em_para)
        return 0;

    em_para->emask = event;
    em_para->handler = cb_func;

    hdr->data = em_para;
    hdr->type = MfwTypEm;

    return mfwInsert((MfwHdr *) hWin,hdr);
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EM            |
| STATE   : code                        ROUTINE : Mfw_em_exit           |
+--------------------------------------------------------------------+

  PURPOSE : exit module

*/
void Mfw_em_exit(void)
{	TRACE_EVENT("Mfw_em_exit()");
#ifndef NEPTUNE_BOARD
	if (MfwEmData != NULL)
		mfwFree((void*)MfwEmData, sizeof(MFW_EM_Data));
	
	em_Exit();
#endif    
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EM            |
| STATE   : code                        ROUTINE : Mfw_em_get_data           |
+--------------------------------------------------------------------+

  PURPOSE : requests data from ACI EM driver

*/
int Mfw_em_get_data(MfwEmDataType type)
{
    TRACE_EVENT("Mfw_em_get_data()");

#ifdef NEPTUNE_BOARD
    EmType = type;
#endif

#ifndef NEPTUNE_BOARD /* EngMode */

#ifndef _EM_MMI_MFW_TEST
/*If not already allocated, Allocate memory to store data in*/
if (MfwEmData == NULL)	
	if ((MfwEmData = (MFW_EM_Data*)mfwAlloc(sizeof(MFW_EM_Data))) == NULL)
		return FALSE;
	/*Request appropriate data from Em driver*/
	switch(type)
	{
		case EM_MOBILE_INFO: 
			/*MC SPR 1554, added call to request software version and identity param*/
			em_Read_Data_Parameter(EM_CLASS_MOBILE_DATA, EM_SUBCLASS_SW_VERSION, 1,Mfw_em_cb);
			em_Read_Data_Parameter(EM_CLASS_MOBILE_DATA,EM_SUBCLASS_ID, 1, Mfw_em_cb);
		break;
		case EM_SERVING_CELL_PARAMS:
			em_Read_Data_Parameter(EM_CLASS_INFRA_DATA, EM_SUBCLASS_SC, 1, Mfw_em_cb);
		break;
		case EM_NEIGHBOURING_CELL_PARAMS:
			em_Read_Data_Parameter(EM_CLASS_INFRA_DATA, EM_SUBCLASS_SC, 1, Mfw_em_cb);
      em_Read_Data_Parameter(EM_CLASS_INFRA_DATA, EM_SUBCLASS_NC, 1, Mfw_em_cb);
		break;
		case EM_LOCATION_PARAMS:
			em_Read_Data_Parameter(EM_CLASS_INFRA_DATA, EM_SUBCLASS_LOC_PAG, 1, Mfw_em_cb);
      em_Read_Data_Parameter(EM_CLASS_INFRA_DATA, EM_SUBCLASS_SC, 1, Mfw_em_cb);
		break;
		case EM_CIPH_HOP_DTX_PARAMS:
			em_Read_Data_Parameter(EM_CLASS_INFRA_DATA, EM_SUBCLASS_CIPH_HOP_DTX, 1, Mfw_em_cb);
		break;
		case EM_GPRS_PARAMS:
			em_Read_Data_Parameter(EM_CLASS_INFRA_DATA, EM_SUBCLASS_SC_GPRS, 1, Mfw_em_cb);
		break;
	}
	return TRUE;
#endif 


			
#ifdef _EM_MMI_MFW_TEST
/*Test harness, just returns made-up data to MMI*/
if (MfwEmData == NULL)	
	if ((MfwEmData = (MFW_EM_Data*)mfwAlloc(sizeof(MFW_EM_Data))) == NULL)
		return FALSE;
	switch(type)
	{
		case EM_MOBILE_INFO:
		{	//MfwEmData->MobileInfo.software_version = 0x44;
			strcpy(MfwEmData->MobileInfo.IMEI,  "123456789ABC");
			strcpy(MfwEmData->MobileInfo.IMSI,  "123456789ABC");
			MfwEmData->MobileInfo.TMSI = 76;
			Mfw_em_signal(EM_MOBILE_INFO, (void*)&MfwEmData->MobileInfo);
		}
		break;
		case EM_SERVING_CELL_PARAMS:
		{	
			MfwEmData->SCInfo.arfcn= 0x44;
			MfwEmData->SCInfo.RSSI= 86;
			MfwEmData->SCInfo.RXQ = 67;
			MfwEmData->SCInfo.RLT = 67;
			Mfw_em_signal(EM_SERVING_CELL_PARAMS, (void*)&MfwEmData->SCInfo);
		}
		break;		
		case EM_NEIGHBOURING_CELL_PARAMS:
		{	MfwEmData->NCInfo.NUM= 0x05;
			strcpy((char*)MfwEmData->NCInfo.arfcn, "WERTYUIOPAS");
			strcpy((char*)MfwEmData->NCInfo.RSSI, "12345");
			
			Mfw_em_signal(EM_NEIGHBOURING_CELL_PARAMS, (void*)&MfwEmData->NCInfo);
				
		}
		break;
		case EM_LOCATION_PARAMS:
		{	strcpy((char*)MfwEmData->LocInfo.MCC, "123");
			strcpy((char*)MfwEmData->LocInfo.MNC, "456");
			MfwEmData->LocInfo.LAC = 12345;
			MfwEmData->LocInfo.CI = 12045;
			
			Mfw_em_signal(EM_LOCATION_PARAMS, (void*)&MfwEmData->LocInfo);
				
		}
		break;
		case EM_GPRS_PARAMS:
		{	MfwEmData->GPRSInfo.ULS= 0;
			MfwEmData->GPRSInfo.DLS= 0;
			MfwEmData->GPRSInfo.coding_scheme = 0;
			Mfw_em_signal(EM_GPRS_PARAMS, (void*)&MfwEmData->GPRSInfo);
				
		}
		break;
		case EM_CIPH_HOP_DTX_PARAMS:
		{	MfwEmData->CHDTXInfo.ciph_status= 0;
			MfwEmData->CHDTXInfo.hopping_channels= 0;
			MfwEmData->CHDTXInfo.DTX_status = 1;
			Mfw_em_signal(EM_CIPH_HOP_DTX_PARAMS, (void*)&MfwEmData->CHDTXInfo);
				
		}
		break;
	}
	return TRUE;
#endif

#endif
}

/***********************************************Private functions:********************************/
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EM            |
| STATE   : code                        ROUTINE : emCommand         |
+--------------------------------------------------------------------+

  PURPOSE : handle mfw windows command

*/

static int emCommand (U32 cmd, void *h)
{TRACE_EVENT("emCommand()");
    switch (cmd)
    {
        case MfwCmdDelete:              /* delete me                */
            if (!h)
                return 0;
            em_delete(h);
            return 1;
        default:
            break;
    }

    return 0;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EM            |
| STATE   : code                        ROUTINE : em_delete         |
+--------------------------------------------------------------------+

  PURPOSE : delete EM event handler

*/

MfwRes em_delete (MfwHnd h)
{
    TRACE_EVENT("em_delete()");

    if (!h || !((MfwHdr *) h)->data)
        return MfwResIllHnd;

    if (!mfwRemove((MfwHdr *) h))
        return MfwResIllHnd;

    mfwFree((U8 *) ((MfwHdr *) h)->data,sizeof(T_MFW_EM));
    mfwFree((U8 *) h,sizeof(MfwHdr));

    return MfwResOk;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EM            |
| STATE   : code                        ROUTINE : Mfw_em_sign_exec           |
+--------------------------------------------------------------------+

  PURPOSE : send event to MMI

*/
#ifndef NEPTUNE_BOARD
int Mfw_em_sign_exec(T_MFW_HDR * cur_elem, T_MFW_EVENT event,T_MFW_EM_PARA *para)
{
 TRACE_EVENT("Mfw_em_sign_exec()");

    while (cur_elem)
    {
        if (cur_elem->type == MfwTypEm)
        {
            T_MFW_EM *em_data;
            em_data = (T_MFW_EM *) cur_elem->data;
            if (em_data->emask & event)
            {
                em_data->event = event;
                switch (event)
                {
                    case EM_MOBILE_INFO:
                        memcpy(&em_data->para.MobileInfo,
                                para,sizeof(MFW_EM_Mobile_Info));
                        break;
                   
                    case EM_SERVING_CELL_PARAMS:
                        memcpy(&em_data->para.SCInfo,
                                para,sizeof(MFW_EM_Serving_Cell_Parameters));
                        break;
                    case EM_NEIGHBOURING_CELL_PARAMS:
                        memcpy(&em_data->para.NCInfo,
                                para,sizeof(MFW_EM_Neighbour_Cell_Parameters));
                        break;
                   
                    case EM_LOCATION_PARAMS:
                        memcpy(&em_data->para.LocInfo,
                                para,sizeof(MFW_EM_Location_Parameters));
                        break;
                     case EM_CIPH_HOP_DTX_PARAMS:
                        memcpy(&em_data->para.CHDTXInfo,
                                para,sizeof(MFW_EM_Ciph_hop_DTX_Parameters));
                        break;
                   
                    case EM_GPRS_PARAMS:
                        memcpy(&em_data->para.GPRSInfo,
                                para,sizeof(MFW_EM_GPRS_Parameter));
                        break;
                }
                if (em_data->handler)
                {
                
                  // store current mfw elem
                  current_mfw_elem = cur_elem;
             
                  if ((*(em_data->handler))(em_data->event,
                                             (void *) &em_data->para))
                    return TRUE;
                }
            }
        }
        cur_elem = cur_elem->next;
    }

    return FALSE;


}

#else /* if NEPTUNE BOARD*/
int Mfw_em_sign_exec(T_MFW_HDR * cur_elem, T_MFW_EVENT event, int* dummy)
{
 TRACE_EVENT("Mfw_em_sign_exec()");

    while (cur_elem)
    {
        if (cur_elem->type == MfwTypEm)
        {
            T_MFW_EM *em_data;
            em_data = (T_MFW_EM *) cur_elem->data;
                em_data->event = event;
                if (em_data->handler)
                {
                  // store current mfw elem
                  current_mfw_elem = cur_elem;
             
                  if ((*(em_data->handler))(em_data->event,
                                             (void *) &dummy))
                    return TRUE;
                }
        }
        cur_elem = cur_elem->next;
    }

    return FALSE;


}

#endif
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EM            |
| STATE   : code                        ROUTINE : Mfw_em_signal           |
+--------------------------------------------------------------------+

  PURPOSE : sends event to MMi via Mfw_em_sign_exec()

*/
void Mfw_em_signal(MfwEvt event, void *para)
{
 UBYTE temp = dspl_Enable(0);
    TRACE_EVENT ("em_signal()");

  if (mfwSignallingMethod EQ 0)
  {
    if (mfwFocus)
        if (Mfw_em_sign_exec(mfwFocus,event,para))
			{
				dspl_Enable(temp);            
				return;
			}
    if (mfwRoot)
        Mfw_em_sign_exec(mfwRoot,event,para);
  }
  else
    {
      MfwHdr * h = 0;

      /*
       * Focus set, then start here
       */
      if (mfwFocus)
        h = mfwFocus;
      /*
       * Focus not set, then start root
       */
      if (!h)
        h = mfwRoot;

      /*
       * No elements available, return
       */

      while (h)


      {
        /*
         * Signal consumed, then return
         */
        if (Mfw_em_sign_exec (h, event, para))
			{
				dspl_Enable(temp);            
				return;
			}

        /*
         * All windows tried inclusive root
         */
        if (h == mfwRoot)
			{
				dspl_Enable(temp);            
				return;
			}

        /*
         * get parent window
         */
        h = mfwParent(mfwParent(h));
		if(h)
			h = ((MfwWin * )(h->data))->elems;
      }
      Mfw_em_sign_exec (mfwRoot, event, para);
    }      
	dspl_Enable(temp);            
	return;


}

#ifndef NEPTUNE_BOARD /*EngMode */
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EM            |
| STATE   : code                        ROUTINE : Mfw_em_cb           |
+--------------------------------------------------------------------+

  PURPOSE : Handles events from the ACI EM driver

*/
void Mfw_em_cb(T_DRV_SIGNAL_EM* signal)
{
	TRACE_EVENT_P1("Mfw_em_cb, signalType: %d", signal->SignalType);
	
	switch(signal->SignalType)
	{
		case EM_SUBCLASS_SC:
		{	/*copy Serving Cell Information to appropriate data structure*/

            T_EM_SC_INFO_CNF *serv_cell = (T_EM_SC_INFO_CNF*)&signal->UserData.sc;
               
			MfwEmData->SCInfo.arfcn = serv_cell->arfcn;
			MfwEmData->SCInfo.RSSI = serv_cell->rxlev;
			MfwEmData->SCInfo.RXQ = serv_cell->rxqual_f;
			MfwEmData->SCInfo.RLT = serv_cell->rlt;
      MfwEmData->SCInfo.C1  = serv_cell->c1;
      MfwEmData->SCInfo.C2  = serv_cell->c2;
      MfwEmData->SCInfo.BSIC  = serv_cell->bsic;
      MfwEmData->SCInfo.TAV  = serv_cell->tav;
      MfwEmData->SCInfo.LAC  = serv_cell->lac;
      
      MfwEmData->NCInfo.arfcn[6] = MfwEmData->SCInfo.arfcn;
      MfwEmData->NCInfo.RSSI[6] = MfwEmData->SCInfo.RSSI;
      MfwEmData->NCInfo.C2[6] = MfwEmData->SCInfo.C2;
      MfwEmData->NCInfo.LAC_NC[6] = MfwEmData->SCInfo.LAC;
      MfwEmData->NCInfo.BSIC_NC[6] = MfwEmData->SCInfo.BSIC;

			/* copy Location Info*/
			MfwEmData->LocInfo.LAC = serv_cell->lac;

      			/*send event to MMI*/
			Mfw_em_signal(EM_SERVING_CELL_PARAMS, (void*)&MfwEmData->SCInfo);
		}		
		break;	
		case EM_SUBCLASS_SC_GPRS:
		{	/*MC, SPR 1554 added code to copy NMOinto GPRS data structure*/

			T_EM_SC_GPRS_INFO_CNF *gprs_info = (T_EM_SC_GPRS_INFO_CNF*)&signal->UserData.sc_gprs;

			MfwEmData->GPRSInfo.NMO = gprs_info->nmo;
      MfwEmData->GPRSInfo.NDTS = gprs_info->tn;
      MfwEmData->GPRSInfo.RAC = gprs_info->rac;
      MfwEmData->GPRSInfo.C31 = gprs_info->c31;
      MfwEmData->GPRSInfo.C32 = gprs_info->c32;

			Mfw_em_signal(EM_GPRS_PARAMS, (void*)&MfwEmData->GPRSInfo);
		}
		break;
		case EM_SUBCLASS_NC:
		{	T_EM_NC_INFO_CNF *neighbour_cell = (T_EM_NC_INFO_CNF*)&signal->UserData.nc;
			MfwEmData->NCInfo.NUM = neighbour_cell->no_ncells;
			memcpy(MfwEmData->NCInfo.arfcn, neighbour_cell->arfcn_nc, 6*sizeof(USHORT));
			memcpy(MfwEmData->NCInfo.RSSI, neighbour_cell->rxlev_nc, 6*sizeof(UBYTE));
			memcpy(MfwEmData->NCInfo.C2, neighbour_cell->c2_nc, 6*sizeof(SHORT));
			memcpy(MfwEmData->NCInfo.LAC_NC, neighbour_cell->lac_nc, 6*sizeof(USHORT));
			memcpy(MfwEmData->NCInfo.BSIC_NC, neighbour_cell->bsic_nc, 6*sizeof(UBYTE));
     Mfw_em_signal(EM_NEIGHBOURING_CELL_PARAMS, (void*)&MfwEmData->NCInfo);
		}
		case EM_SUBCLASS_LOC_PAG:
		{	MfwEmData->LocInfo.LUP = signal->UserData.log_pag.t3212;
			/*Convert MCC & MNC to ASCII strings from BCD*/
			utl_BCD2DialStr (signal->UserData.log_pag.mcc, MfwEmData->LocInfo.MCC, 3);
			utl_BCD2DialStr (signal->UserData.log_pag.mnc, MfwEmData->LocInfo.MNC, 3);
			Mfw_em_signal(EM_LOCATION_PARAMS, (void*)&MfwEmData->LocInfo);
		}
		case EM_SUBCLASS_CIPH_HOP_DTX:
		{	MfwEmData->CHDTXInfo.ciph_status = signal->UserData.cip.ciph_stat;
			MfwEmData->CHDTXInfo.HSN = signal->UserData.cip.hsn;
			//!!!!!HOPPING CHANNELS!!!!!!!!!!!!!!
 /*     memcpy(MfwEmData->CHDTXInfo.ma, signal->UserData.cip.hop_chn.ma, 65);
      if (signal->UserData.cip.hop_chn.v_start)
      {
			  memcpy(MfwEmData->CHDTXInfo.ma2, signal->UserData.cip.hop_chn.ma2, 65);
      }*/
      MfwEmData->CHDTXInfo.DTX_status = signal->UserData.cip.dtx_stat;
			Mfw_em_signal(EM_CIPH_HOP_DTX_PARAMS, (void*)&MfwEmData->CHDTXInfo);
		}
		case EM_SUBCLASS_ID:
		{	/*MC, SPR 1554 added conversion of IMEI and IMSI from numbers to ASCII*/
			
			int i;
			/*convert to ASCII digits*/
			for (i=0; i < 15; i++)
			{
				MfwEmData->MobileInfo.IMEI[i]= signal->UserData.id.em_imeisv.ident_dig[i] + ASCII_OFFSET;
				MfwEmData->MobileInfo.IMSI[i]=signal->UserData.id.em_imsi.ident_dig[i] +ASCII_OFFSET;
			}
			MfwEmData->MobileInfo.IMEI[15] = NULL;
			MfwEmData->MobileInfo.IMSI[15] = NULL;	
	
			MfwEmData->MobileInfo.TMSI = signal->UserData.id.tmsi;
			
			Mfw_em_signal(EM_MOBILE_INFO, (void*)&MfwEmData->MobileInfo);
		}
		case EM_SUBCLASS_SW_VERSION:
		{	
			T_EM_SW_VER* sw_ver = &signal->UserData.version;
			memcpy(MfwEmData->MobileInfo.SIM_version, sw_ver->sim, MAX_VER*sizeof(char));
			memcpy(MfwEmData->MobileInfo.CC_version , sw_ver->cc, MAX_VER*sizeof(char));
			memcpy(MfwEmData->MobileInfo.SS_version , sw_ver->ss, MAX_VER*sizeof(char));
			memcpy(MfwEmData->MobileInfo.SMS_version , sw_ver->sms, MAX_VER*sizeof(char));
			memcpy(MfwEmData->MobileInfo.MM_version, sw_ver->mm, MAX_VER*sizeof(char));
			memcpy(MfwEmData->MobileInfo.RR_version , sw_ver->rr, MAX_VER*sizeof(char));
			memcpy(MfwEmData->MobileInfo.DL_version , sw_ver->dl, MAX_VER*sizeof(char));
			memcpy(MfwEmData->MobileInfo.ALR_version , sw_ver->alr, MAX_VER*sizeof(char));
		}
		default:
			TRACE_EVENT("Unknown EM data type");

	}

}

#endif

#ifdef NEPTUNE_BOARD
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_EM            |
| STATE   : code                        ROUTINE : Mfw_em_response           |
+--------------------------------------------------------------------+

  PURPOSE : sends event to MMi via Mfw_em_sign_exec()

*/
void Mfw_em_response_EINFO(T_ENG_INFO_REQ *emode_data, 
            T_ENG_INFO_STATIC_REQ *emode_static_data)
{
    int* dummy;
    TRACE_FUNCTION("Mfw_em_response_EINFO()");
    Eng_Info_Req = emode_data;
    Mfw_em_signal(EmType, (void*)&dummy);
    
}

void Mfw_em_response_ESINFO(T_ENG_INFO_STATIC_REQ *emode_static_data)
{
    TRACE_FUNCTION("Mfw_em_response_ESINFO()");
    Eng_Info_Static_Req = emode_static_data;
}


#endif