view src/ui/mfw/mfw_em.c @ 265:e57bfdadf49a

mmiIcons.c: fix bogus icnType in incoming_call_animate[] The incoming call animation icons are actually drawn in 256-color format, but they were incorrectly declared as BMP_FORMAT_32BIT_COLOUR in the incoming_call_animate[] array. Why were they still getting displayed correctly despite this bogosity? Answer: because the mmi_dialogs_animation_new_CB() function overrides the icon bitmap type to 0x02, which means 256-color format. Needless to say, the icon format should be made correct at the source of the data, and at some later point we may need to remove the override from the animation display function.
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 17 May 2021 07:18:36 +0000
parents 92abb46dc1ba
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