qaGobiApiCbk.h

Go to the documentation of this file.

/*
 * Copyright: © 2011-2015 Sierra Wireless, Inc. all rights reserved
 */
#ifndef __GOBI_API_CBK_H__
#define __GOBI_API_CBK_H__

#ifdef __cplusplus
extern "C" {
#endif

#include "qmudefs.h"

#include "qaGobiApiNas.h"
#include "qaGobiApiVoice.h"
#include "qaGobiApiSms.h"
#include "qaGobiApiUim.h"
#include "qaGobiApiQos.h"
#include "qaGobiApiWds.h"
#include "qaGobiApiLoc.h"
#include "qaGobiApiTmd.h"
#include "qaGobiApiSwiAvms.h"

#define SIGSTRENGTH_THRESHOLD_ARR_SZ  5
#define QMI_WMS_MAX_PAYLOAD_LENGTH    256
#define QMI_ETWS_MAX_PAYLOAD_LENGTH   1254  /* Qualcomm defined max */
#define QMI_MAX_VOICE_NUMBER_LENGTH   81
#define MAX_NO_OF_UUSINFO             20
#define MAXUSSDLENGTH                 182
#define MAX_NO_OF_CALLS               20
#define CBK_ENABLE_EVENT              0x01
#define CBK_DISABLE_EVENT             0x00
#define CBK_NOCHANGE                  0xFF
#define MAX_NO_OF_APPLICATIONS        10
#define MAX_NO_OF_SLOTS               5
#define MAX_NO_OF_FILES               255
#define MAX_PATH_LENGTH               255
#define EVENT_MASK_CARD               0x00000001
#define EVENT_MASK_PHY_SLOT_STATUS    0x00000010
#define EVENT_MASK_DEREGISTER_ALL     0x00000000
#define REGISTER_EVENT                0x01
#define DEREGISTER_EVENT              0x00
#define FIRST_INSTANCE                0x00
#define SECOND_INSTANCE               0x01
#define THIRD_INSTANCE                0x02
#define INVALID_INSTACNE              0x08
#define REGISTER_SRV                  0x01
#define DEREGISTER_SRV                0x00
#define WDS_SRV                       0x01
#define NAS_SRV                       0x02
#define PDS_SRV                       0x04
#define VOICE_SRV                     0x08
#define NUM_OF_SET                    0xFF
#define IPV4                          4
#define IPV6                          6
#define IPV4V6                        7
#define LOC_EVENT_MASK_ENG_STATE      0x00000080
#define LOC_EVENT_MASK_TIME_SYNC      0x00000800
#define LOC_EVENT_MASK_INJECT_TIME    0x00000010
#define LOC_EVENT_MASK_SENSOR_STREAM  0x00000400
#define LOC_EVENT_POSITION_REPORT     0x00000001
#define LOC_EVENT_MASK_GNSS_SV_INFO   0x00000002
#define LOC_EVENT_MASK_NMEA           0x00000004

#define MAX_NMEA_STR_LEN           201

#define DHCP_MAX_NUM_OPTIONS       30
#define DHCP_OPTION_DATA_BUF_SIZE  2048  /* current max size of raw message in SDK process is 2048 */

#define MAX_MITIGATION_DEV_ID_LEN  255

#define MAX_URL_ADDR_STR_LEN       256

typedef enum
{
   eQA_QMI_SVC_WDS = 0x01,
   eQA_QMI_SVC_NAS = 0x03,
   eQA_QMI_SVC_NA  = 0xFF, /* Used when the service information is not required
                            * to be exposed to the user
                            */
} eQaQMIService;

typedef struct{
    BYTE          qaQmiinstanceid;
    eQaQMIService qaQmisvctype;
    ULONG         v4sessionId;
    ULONG         v6sessionId;
} qaQmiInterfaceInfo;


typedef struct
{
    qaQmiInterfaceInfo *pQmiInterfaceInfo;
    ULONG reconfiguration_required;
    ULONG state;
    ULONG sessionEndReason;
} slqsSessionStateInfo;

typedef void (* tFNSLQSSessionState)( slqsSessionStateInfo *pSessionStateInfo );

ULONG SLQSSetSessionStateCallback( tFNSLQSSessionState pCallback );


typedef struct
{
    qaQmiInterfaceInfo *pQmiInterfaceInfo;
    ULONG              *pDormancyStatus;
    ULONG              *pDataBearer;
    ULONG              *pPacketsCountTX;
    ULONG              *pPacketsCountRX;
    ULONGLONG          *pTotalBytesTX;
    ULONGLONG          *pTotalBytesRX;
} slqsWdsEventInfo;

typedef void (* tFNSLQSWDSEvent)( slqsWdsEventInfo *pWdsEventInfo );

ULONG SLQSSetWdsEventCallback(
    tFNSLQSWDSEvent pCallback,
    BYTE            interval,
    BYTE            instanceid,
    BYTE            ipfamily );

ULONG SLQSSetWdsTransferStatisticCallback(
    tFNSLQSWDSEvent pXferStatsCb,
    BYTE            interval,
    BYTE            instanceid,
    BYTE            ipfamily );

/*
 *  For internal use only, not to be exposed to the user
 *  This structure will hold the input parameters passed for TransferStatsCbk
 *  by the user
 *
 * \param  interval
 *           - Interval in seconds.
 *           - ignored when disabling, should be non-zero when enabling
 *
 * Note:    None
 *
 */
struct TransferStatsDataType
{
    BYTE interval;
};

/*
 *  Enables/disables the WDS event callback function. The most recent
 *  successfully subscribed callback function will be the only function that
 *  is invoked when the corresponding event occurs. This callback provide extra
 *  information regarding the multiple PDP interface
 *
 *  \param  pCallback[IN]
 *          - Callback function pointer (0 - disable)

 *  \return eQCWWAN_ERR_NONE on success, eQCWWAN_xxx error value otherwise
 *
 *  \sa     See qmerrno.h for eQCWWAN_xxx error values
 *
 *  \note   None
 *
 */
ULONG iSLQSSetWdsFirstInstEventCallback( tFNSLQSWDSEvent pCallback );

/*
 *  Enables/disables the WDS event callback function. The most recent
 *  successfully subscribed callback function will be the only function that
 *  is invoked when the corresponding event occurs. This callback provide extra
 *  information regarding the multiple PDP interface
 *
 *  \param  pCallback[IN]
 *          - Callback function pointer (0 - disable)

 *  \return eQCWWAN_ERR_NONE on success, eQCWWAN_xxx error value otherwise
 *
 *  \sa     See qmerrno.h for eQCWWAN_xxx error values
 *
 *  \note   None
 *
 */
ULONG iSLQSSetWdsSecondInstEventCallback( tFNSLQSWDSEvent pCallback );

/*
 *  Enables/disables the WDS event callback function. The most recent
 *  successfully subscribed callback function will be the only function that
 *  is invoked when the corresponding event occurs. This callback provide extra
 *  information regarding the multiple PDP interface
 *
 *  \param  pCallback[IN]
 *          - Callback function pointer (0 - disable)

 *  \return eQCWWAN_ERR_NONE on success, eQCWWAN_xxx error value otherwise
 *
 *  \sa     See qmerrno.h for eQCWWAN_xxx error values
 *
 *  \note   None
 *
 */
ULONG iSLQSSetWdsThirdInstEventCallback( tFNSLQSWDSEvent pCallback );

/*
 *  Enables/disables the WDS transfer statistic event callback function. The most recent
 *  successfully subscribed callback function will be the only function that
 *  is invoked when the corresponding event occurs. This callback provide extra
 *  information regarding the multiple PDP interface
 *
 *  \param  pCallback[IN]
 *          - Callback function pointer (0 - disable)

 *  \return eQCWWAN_ERR_NONE on success, eQCWWAN_xxx error value otherwise
 *
 *  \sa     See qmerrno.h for eQCWWAN_xxx error values
 *
 *  \note   None
 *
 */
ULONG iSLQSSetWdsXferStatsFirstInstCallback( tFNSLQSWDSEvent pCallback );

/*
 *  Enables/disables the WDS transfer statistic event callback function. The most recent
 *  successfully subscribed callback function will be the only function that
 *  is invoked when the corresponding event occurs. This callback provide extra
 *  information regarding the multiple PDP interface
 *
 *  \param  pCallback[IN]
 *          - Callback function pointer (0 - disable)

 *  \return eQCWWAN_ERR_NONE on success, eQCWWAN_xxx error value otherwise
 *
 *  \sa     See qmerrno.h for eQCWWAN_xxx error values
 *
 *  \note   None
 *
 */
ULONG iSLQSSetWdsXferStatsSecondInstCallback( tFNSLQSWDSEvent pCallback );

/*
 *  Enables/disables the WDS event callback function. The most recent
 *  successfully subscribed callback function will be the only function that
 *  is invoked when the corresponding event occurs. This callback provide extra
 *  information regarding the multiple PDP interface
 *
 *  \param  pCallback[IN]
 *          - Callback function pointer (0 - disable)

 *  \return eQCWWAN_ERR_NONE on success, eQCWWAN_xxx error value otherwise
 *
 *  \sa     See qmerrno.h for eQCWWAN_xxx error values
 *
 *  \note   None
 *
 */

typedef void (* tFNPower)( ULONG operatingMode );

ULONG SetPowerCallback(
    tFNPower pCallback );

typedef void (* tFNActivationStatus)( ULONG activationStatus );

ULONG SetActivationStatusCallback(
    tFNActivationStatus pCallback );

typedef void (* tFNMobileIPStatus)( ULONG mipStatus );

ULONG SetMobileIPStatusCallback(
    tFNMobileIPStatus pCallback );

typedef void (* tFNRoamingIndicator)( ULONG roaming );

ULONG SetRoamingIndicatorCallback(
    tFNRoamingIndicator pCallback );

typedef void (* tFNDataCapabilities)(
   BYTE                       dataCapsSize,
   BYTE *                     pDataCaps );

ULONG SetDataCapabilitiesCallback(
    tFNDataCapabilities pCallback );

typedef void (* tFNSignalStrength)(
   INT8                       signalStrength,
   ULONG                      radioInterface );

ULONG SetSignalStrengthCallback(
    tFNSignalStrength pCallback,
    BYTE              thresholdsSize,
    INT8              *pThresholds );

/*
 *  For internal use only, not to be exposed to the user
 *  This structure will hold the input parameters passed for
 *  SetSignalStrengthCallback by the user
 *
 *  \param  thresholdsSize
 *          - Number of elements threshold array contains; a maximum of five
 *            thresholds is supported;
 *
 *  \param  pThresholds[IN]
 *          - Signal threshold array for each entry (in dBm).
 *
 * Note:    None
 *
 */
struct SignalStrengthDataType
{
    BYTE thresholdsSize;
    INT8 thresholds[SIGSTRENGTH_THRESHOLD_ARR_SZ];
};

/*
 *  For internal use only, not to be exposed to the user
 *  Enables the Signal Strength callback function.
 *
 *  \param  pCallback[IN]
 *          - Callback function pointer
 *
 *  \return eQCWWAN_ERR_NONE on success, eQCWWAN_xxx error value otherwise
 *
 *  \sa     See qmerrno.h for eQCWWAN_xxx error values
 *
 *  \note   None
 *
 */
ULONG iSetSignalStrengthCallback(
    tFNSignalStrength pCallback );

typedef void (* tFNRFInfo)(
   ULONG                      radioInterface,
   ULONG                      activeBandClass,
   ULONG                      activeChannel );

ULONG SetRFInfoCallback(
    tFNRFInfo pCallback );

typedef void (* tFNLUReject)(
   ULONG                      serviceDomain,
   ULONG                      rejectCause );

ULONG SetLURejectCallback(
    tFNLUReject pCallback );

typedef void (* tFNNewSMS)(
   ULONG                      storageType,
   ULONG                      messageIndex );

ULONG SetNewSMSCallback(
    tFNNewSMS pCallback );

typedef enum SMSEventType
{
    SMS_EVENT_MT_MESSAGE                = 0x01,
    SMS_EVENT_TRANSFER_ROUTE_MT_MESSAGE = 0x02,
    SMS_EVENT_MESSAGE_MODE              = 0x04,
    SMS_EVENT_ETWS                      = 0x08,
    SMS_EVENT_ETWS_PLMN                 = 0x10,
    SMS_EVENT_SMSC_ADDRESS              = 0x20,
    SMS_EVENT_SMS_ON_IMS                = 0x40,
} eSMSEventType;

typedef struct SMSMTMessage
{
    ULONG storageType;
    ULONG messageIndex;
} SMSMTMessageInfo;

typedef struct SMSTransferRouteMTMessage
{
    BYTE  ackIndicator;
    ULONG transactionID;
    BYTE  format;
    WORD  length;
    BYTE  data[QMI_WMS_MAX_PAYLOAD_LENGTH];
} SMSTransferRouteMTMessageInfo;

typedef struct SMSMessageMode
{
    BYTE  messageMode;
} SMSMessageModeInfo;

typedef struct SMSEtwsMessage
{
    BYTE notificationType;
    WORD length;
    BYTE data[QMI_ETWS_MAX_PAYLOAD_LENGTH];
} SMSEtwsMessageInfo;

typedef struct SMSEtwsPlmn
{
    WORD mobileCountryCode;
    WORD mobileNetworkCode;
} SMSEtwsPlmnInfo;

typedef struct SMSCAddress
{
    BYTE length;
    BYTE data[QMI_WMS_MAX_PAYLOAD_LENGTH];
} SMSCAddressInfo;

typedef struct SMSOnIMS
{
    BYTE smsOnIMS;
}SMSOnIMSInfo;

typedef struct SMSEventInfo_s
{
    BYTE                          smsEventType;
    SMSMTMessageInfo              *pMTMessageInfo;
    SMSTransferRouteMTMessageInfo *pTransferRouteMTMessageInfo;
    SMSMessageModeInfo            *pMessageModeInfo;
    SMSEtwsMessageInfo            *pEtwsMessageInfo;
    SMSEtwsPlmnInfo               *pEtwsPlmnInfo;
    SMSCAddressInfo               *pSMSCAddressInfo;
    SMSOnIMSInfo                  *pSMSOnIMSInfo;
} SMSEventInfo;

typedef void (* tFNSMSEvents)( SMSEventInfo *pSMSEventInfo );

ULONG SLQSSetSMSEventCallback( tFNSMSEvents pCallback );

typedef void (* tFNNewNMEA)( LPCSTR pNMEA );

ULONG SetNMEACallback(
    tFNNewNMEA pCallback );

typedef void (* tFNPDSState)(
   ULONG                      enabledStatus,
   ULONG                      trackingStatus );

ULONG SetPDSStateCallback(
    tFNPDSState pCallback );

typedef void (* tFNCATEvent)(
   ULONG                      eventID,
   ULONG                      eventLen,
   BYTE *                     pEventData );

ULONG SetCATEventCallback(
    tFNCATEvent pCallback,
    ULONG       eventMask,
    ULONG       *pErrorMask );

/*
 *  For internal use only, not to be exposed to the user
 *  This structure will hold the input parameters passed for
 *  SetCATEventCallback by the user
 *
 *  \param  eventMask
 *          - bitmask of CAT events to register for
 *
 *  \param  pErrorMask[OUT]
 *          - error bitmask. Each bit set indicates the proactive command that
 *            caused the error
 *
 * Note:    None
 *
 */
struct CATEventDataType
{
    ULONG eventMask;
    ULONG *pErrorMask;
};

/*
 *  For internal use only, not to be exposed to the user
 *  Enables the CAT Event callback function.
 *
 *  \param  pCallback[IN]
 *          - Callback function pointer
 *
 *  \return eQCWWAN_ERR_NONE on success, eQCWWAN_xxx error value otherwise
 *
 *  \sa     See qmerrno.h for eQCWWAN_xxx error values
 *
 *  \note   None
 *
 */
ULONG iSetCATEventCallback(
    tFNCATEvent pCallback );

typedef enum device_state_enum
{
    DEVICE_STATE_DISCONNECTED,
    DEVICE_STATE_READY,
    DEVICE_STATE_BOOT,
    DEVICE_STATE_SERIAL_ONLY
}eDevState;

typedef void (* tFNDeviceStateChange)(
    eDevState   device_state );

typedef void (* tFNNet)(
    ULONG   q_depth,
    BYTE    isThrottle,
    BYTE    instanceId);

ULONG SetDeviceStateChangeCbk(
    tFNDeviceStateChange pCallback );

ULONG SetNetChangeCbk(
    BYTE            instance,
    tFNNet          pCallback,
    ULONG           loMark,
    ULONG           hiMark,
    ULONG           period);

typedef void (* tFNFwDldCompletion)( ULONG fwdld_completion_status );

ULONG SetFwDldCompletionCbk(
    tFNFwDldCompletion pCallback );

typedef void (* tFNSLQSOMADMAlert)(
    ULONG eventType,
    BYTE  *pEventFields );

ULONG SetSLQSOMADMAlertCallback(
    tFNSLQSOMADMAlert pCallback );


ULONG SetSLQSOMADMAlertCallbackExt(
    tFNSLQSOMADMAlert pCallback );

typedef void (* tFNOMADMState)(
    ULONG sessionState,
    ULONG failureReason );

ULONG SetOMADMStateCallback(
    tFNOMADMState pCallback );

#define  MAX_RADIO_INTERFACE_LIST 255

struct ServingSystemInfo
{
    BYTE registrationState;
    BYTE csAttachState;
    BYTE psAttachState;
    BYTE selectedNetwork;
    BYTE radioInterfaceNo;
    BYTE radioInterfaceList[MAX_RADIO_INTERFACE_LIST];
    BYTE hdrPersonality;
};

struct RoamingInfo
{
    BYTE TlvPresent;
    BYTE roaming_ind;
};

typedef void (* tFNServingSystem)(
    struct ServingSystemInfo *pServingSystem ,struct RoamingInfo *pRoamingInfo);

ULONG SLQSSetServingSystemCallback(
    tFNServingSystem pCallback );

typedef void (* tFNBandPreference)(
    ULONGLONG  band_pref );

ULONG SLQSSetBandPreferenceCbk(
    tFNBandPreference pCallback );

typedef void (* tFNUSSDRelease)( void );

ULONG SetUSSDReleaseCallback(
    tFNUSSDRelease pCallback );

typedef void (* tFNUSSDNotification)(
    ULONG type,
    BYTE  *pNetworkInfo );

ULONG SetUSSDNotificationCallback(
    tFNUSSDNotification pCallback );

struct SLQSSignalStrengthsInformation{
    struct rxSignalStrengthListElement rxSignalStrengthInfo;
    struct ecioListElement             ecioInfo;
    ULONG                              io;
    BYTE                               sinr;
    struct errorRateListElement        errorRateInfo;
    struct rsrqInformation             rsrqInfo;
    struct lteSnrinformation           lteSnrinfo;
    struct lteRsrpinformation          lteRsrpinfo;
};

typedef void (* tFNSLQSSignalStrengths )(
    struct SLQSSignalStrengthsInformation sSLQSSignalStrengthsInfo );

struct SLQSSignalStrengthsIndReq{
    BYTE  rxSignalStrengthDelta;
    BYTE  ecioDelta;
    BYTE  ioDelta;
    BYTE  sinrDelta;
    BYTE  rsrqDelta;
    BYTE  ecioThresholdListLen;
    SHORT ecioThresholdList[10];
    BYTE  sinrThresholdListLen;
    BYTE  sinrThresholdList[5];
    WORD  lteSnrDelta;
    BYTE  lteRsrpDelta;
};

ULONG SLQSSetSignalStrengthsCallback(
    tFNSLQSSignalStrengths           pCallback,
    struct SLQSSignalStrengthsIndReq *pSLQSSignalStrengthsIndReq );

/*
 *  For internal use only, not to be exposed to the user
 *  Enables the Received Signal Strength Information callback function.
 *
 *  \param  pCallback[IN]
 *          - Callback function pointer
 *
 *  \return eQCWWAN_ERR_NONE on success, eQCWWAN_xxx error value otherwise
 *
 *  \sa     See qmerrno.h for eQCWWAN_xxx error values
 *
 *  \note   None
 *
 */
ULONG iSLQSSetSignalStrengthsCallback(
    tFNSLQSSignalStrengths pCallback );

typedef struct
{
    BYTE ECTCallState;
    BYTE presentationInd;
    BYTE number[QMI_MAX_VOICE_NUMBER_LENGTH];
} ECTNum;

typedef struct
{
    BYTE   callID;
    BYTE   notifType;
    WORD   *pCUGIndex;
    ECTNum *pECTNum;
} voiceSUPSNotification;

typedef void (*tFNSUPSNotification)
    ( voiceSUPSNotification *pVoiceSUPSNotification );

ULONG SLQSVoiceSetSUPSNotificationCallback( tFNSUPSNotification pCallback );

typedef void (* tFNSDKTerminated)(
    BYTE *psReason );

ULONG SLQSSetSDKTerminatedCallback(
    tFNSDKTerminated pCallback );

typedef struct
{
    arrCallInfo        arrCallInfomation;
    arrRemotePartyNum  *pArrRemotePartyNum;
    arrRemotePartyName *pArrRemotePartyName;
    arrAlertingType    *pArrAlertingType;
    arrSvcOption       *pArrSvcOption;
    arrCallEndReason   *pArrCallEndReason;
    arrAlphaID         *pArrAlphaID;
    arrConnectPartyNum *pArrConnectPartyNum;
    arrDiagInfo        *pArrDiagInfo;
    arrCalledPartyNum  *pArrCalledPartyNum;
    arrRedirPartyNum   *pArrRedirPartyNum;
    arrAlertingPattern *pArrAlertingPattern;
} voiceSetAllCallStatusCbkInfo;

typedef void (* tFNAllCallStatus )(
    voiceSetAllCallStatusCbkInfo *pVoiceSetAllCallStatusCbkInfo );

ULONG SLQSVoiceSetAllCallStatusCallBack (
    tFNAllCallStatus pCallback );

typedef struct _transLayerInfoNotification
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    BYTE           regInd;
    transLayerInfo *pTransLayerInfo;
} transLayerNotification;

typedef void (*tFNtransLayerInfo)
    ( transLayerNotification *pTransLayerNotification );

ULONG SLQSSetTransLayerInfoCallback( tFNtransLayerInfo pCallback );

typedef struct _transNWRegInfoNotification
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    BYTE NWRegStat;
} transNWRegInfoNotification;

typedef void (*tFNtransNWRegInfo)
    ( transNWRegInfoNotification *pTransNWRegInfoNotification );

ULONG SLQSSetTransNWRegInfoCallback( tFNtransNWRegInfo pCallback );

typedef void (* tFNSysSelectionPref )
       ( sysSelectPrefInfo *pSysSelectPrefInfo );

ULONG SLQSSetSysSelectionPrefCallBack( tFNSysSelectionPref pCallback );

typedef void (* tFNUIMRefresh )
    ( UIMRefreshEvent *pUIMRefreshEvent );

ULONG SLQSUIMSetRefreshCallBack ( tFNUIMRefresh pCallback );

typedef struct
{
    cardStatus statusChange;
}UIMStatusChangeInfo;

typedef void ( * tFNUIMStatusChangeInfo)
    (UIMStatusChangeInfo  *pUIMStatusChangeInfo );

ULONG SLQSUIMSetStatusChangeCallBack (
    tFNUIMStatusChangeInfo pCallback );

typedef struct
{
    BYTE callID;
    BYTE voicePrivacy;
} voicePrivacyInfo;

typedef void ( * tFNPrivacyChange) ( voicePrivacyInfo *pVoicePrivacyInfo );

ULONG SLQSVoiceSetPrivacyChangeCallBack( tFNPrivacyChange pCallback );

typedef struct
{
    DTMFInfo DTMFInformation;
    BYTE     *pOnLength;
    BYTE     *pOffLength;
} voiceDTMFEventInfo;

typedef void ( * tFNDTMFEvent)
    ( voiceDTMFEventInfo *pVoiceDTMFEventInfo );

ULONG SLQSVoiceSetDTMFEventCallBack( tFNDTMFEvent pCallback );

typedef struct
{
    SUPSInfo       SUPSInformation;
    BYTE           *pSvcClass;
    BYTE           *pReason;
    BYTE           *pCallFWNum;
    BYTE           *pCallFWTimerVal;
    struct USSInfo *pUSSInfo;
    BYTE           *pCallID;
    alphaIDInfo    *pAlphaIDInfo;
    BYTE           *pCallBarPasswd;
    newPwdData     *pNewPwdData;
    BYTE           *pDataSrc;
    WORD           *pFailCause;
    getCallFWInfo  *pCallFwdInfo;
    CLIRResp       *pCLIRstatus;
    CLIPResp       *pCLIPstatus;
    COLPResp       *pCOLPstatus;
    COLRResp       *pCOLRstatus;
    CNAPResp       *pCNAPstatus;
} voiceSUPSInfo;

typedef void ( * tFNSUPSInfo)
    ( voiceSUPSInfo *pVoiceSUPSInfo );

ULONG SLQSVoiceSetSUPSCallBack( tFNSUPSInfo pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    SrvStatusInfo      *pCDMASrvStatusInfo;
    SrvStatusInfo      *pHDRSrvStatusInfo;
    GSMSrvStatusInfo   *pGSMSrvStatusInfo;
    GSMSrvStatusInfo   *pWCDMASrvStatusInfo;
    GSMSrvStatusInfo   *pLTESrvStatusInfo;
    CDMASysInfo        *pCDMASysInfo;
    HDRSysInfo         *pHDRSysInfo;
    GSMSysInfo         *pGSMSysInfo;
    WCDMASysInfo       *pWCDMASysInfo;
    LTESysInfo         *pLTESysInfo;
    AddCDMASysInfo     *pAddCDMASysInfo;
    WORD               *pAddHDRSysInfo;
    AddSysInfo         *pAddGSMSysInfo;
    AddSysInfo         *pAddWCDMASysInfo;
    WORD               *pAddLTESysInfo;
    CallBarringSysInfo *pGSMCallBarringSysInfo;
    CallBarringSysInfo *pWCDMACallBarringSysInfo;
    BYTE               *pLTEVoiceSupportSysInfo;
    BYTE               *pGSMCipherDomainSysInfo;
    BYTE               *pWCDMACipherDomainSysInfo;
    BYTE               *pSysInfoNoChange;
} nasSysInfo;

typedef void ( *tFNSysInfo )
    ( nasSysInfo *pNasSysInfo ) ;

ULONG SLQSNasSysInfoCallBack( tFNSysInfo pCallback );

typedef struct
{
    WORD year;
    BYTE month;
    BYTE day;
    BYTE hour;
    BYTE minute;
    BYTE second;
    BYTE dayOfWeek;
} UniversalTime;

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    UniversalTime universalTime;
    BYTE          *pTimeZone;
    BYTE          *pDayltSavAdj;
    BYTE          *pRadioInterface;
} nasNetworkTime;

typedef void ( *tFNNetworkTime )
    ( nasNetworkTime *pNasNetworkTime );

ULONG SLQSNasNetworkTimeCallBack( tFNNetworkTime pCallback );

struct omaDmFotaTlv
{
    BYTE   state;
    BYTE   userInputReq;
    USHORT userInputTimeout;
    ULONG  fwdloadsize;
    ULONG  fwloadComplete;
    USHORT updateCompleteStatus;
    BYTE   severity;
    USHORT versionlength;
    BYTE   version[256];
    USHORT namelength;
    BYTE   package_name[256];
    USHORT descriptionlength;
    BYTE   description[256];
    BYTE   sessionType;
};


struct omaDmFotaTlvExt
{
    BYTE   state;
    BYTE   reserved;
    USHORT userInputTimeout;
    ULONG  packageSize;
    ULONG  receivedBytes;
    USHORT fumoResultCode;
    USHORT versionlength;
    BYTE   version[256];
    USHORT namelength;
    BYTE   package_name[256];
    USHORT descriptionlength;
    BYTE   description[256];
};

struct omaDmConfigTlvExt
{
    BYTE   state;
    BYTE   userInputReq;
    USHORT userInputTimeout;
    USHORT alertmsglength;
    BYTE   alertmsg[256];
};

struct omaDmConfigTlv
{
    BYTE   state;
    BYTE   userInputReq;
    USHORT userInputTimeout;
    USHORT alertmsglength;
    BYTE   alertmsg[256];
};

struct omaDmNotificationsTlv
{
    BYTE   notification;
    USHORT sessionStatus;
};

typedef union sessionInfo
{
    struct omaDmFotaTlv          omaDmFota;
    struct omaDmConfigTlv        omaDmConfig;
    struct omaDmNotificationsTlv omaDmNotifications;
} sessionInformation;

typedef union sessionInfoExt
{
    struct omaDmFotaTlvExt   omaDmFota;
    struct omaDmConfigTlvExt omaDmConfig;
} sessionInformationExt;

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    BYTE storageType;
    BYTE messageMode;
} SMSMemoryInfo;

typedef void (* tFNMemoryFull)( SMSMemoryInfo *pSMSMemoryFullInfo );

ULONG SLQSWmsMemoryFullCallBack( tFNMemoryFull pCallback );

typedef struct
{
    BYTE callID;
    BYTE OTASPStatus;
}voiceOTASPStatusInfo;

typedef void ( * tFNOTASPStatus )
    ( voiceOTASPStatusInfo *pVoiceOTASPStatusInfo );

ULONG SLQSVoiceSetOTASPStatusCallBack(
    tFNOTASPStatus pCallback );

typedef struct
{
    BYTE signalType;
    BYTE alertPitch;
    BYTE signal;
} signalInfo;

typedef struct
{
    BYTE PI;
    BYTE callerIDLen;
    BYTE callerID[255];
} callerIDInfo;

typedef struct
{
    BYTE PI;
    BYTE SI;
    BYTE numType;
    BYTE numPlan;
    BYTE numLen;
    BYTE number[255];
} callingPartyInfo;

typedef struct
{
    BYTE PI;
    BYTE SI;
    BYTE numType;
    BYTE numPlan;
    BYTE numLen;
    BYTE number[255];
} calledPartyInfo;

typedef struct
{
    BYTE PI;
    BYTE SI;
    BYTE numType;
    BYTE numPlan;
    BYTE reason;
    BYTE numLen;
    BYTE number[255];
} redirNumInfo;

typedef struct
{
    BYTE upLink;
    BYTE downLink;
} NSSAudioCtrl;

typedef struct
{
    BYTE polarityIncluded;
    BYTE toggleMode;
    BYTE revPolarity;
    BYTE pwrDenialTime;
} lineCtrlInfo;

typedef struct
{
    BYTE dispType;
    BYTE extDispInfoLen;
    BYTE extDispInfo[255];
} extDispRecInfo;

typedef struct
{
    BYTE            callID;
    signalInfo      *pSignalInfo;
    callerIDInfo    *pCallerIDInfo;
    BYTE            *pDispInfo;
    BYTE            *pExtDispInfo;
    BYTE            *pCallerNameInfo ;
    BYTE            *pCallWaitInd;
    connectNumInfo  *pConnectNumInfo;
    connectNumInfo  *pCallingPartyInfo;
    calledPartyInfo *pCalledPartyInfo;
    redirNumInfo    *pRedirNumInfo;
    BYTE            *pCLIRCause;
    NSSAudioCtrl    *pNSSAudioCtrl;
    BYTE            *pNSSRelease;
    lineCtrlInfo    *pLineCtrlInfo;
    extDispRecInfo  *pExtDispRecInfo;
} voiceInfoRec;

typedef void ( * tFNInfoRec) ( voiceInfoRec *pVoiceInfoRec );

ULONG SLQSVoiceInfoRecCallback( tFNInfoRec pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult        results;
    BYTE                      numInstances;
    messageWaitingInfoContent msgWaitInfo[NUM_OF_SET];
} msgWaitingInfo;

typedef void (* tFNMessageWaiting)( msgWaitingInfo *pSMSMessageWaitingInfo );

ULONG SLQSWmsMessageWaitingCallBack( tFNMessageWaiting pCallback );

typedef struct
{
    ULONG   id;
    BYTE    isNewFlow;
    BYTE    state;
} QosFlowInfoState;

typedef struct
{
    QosFlowInfoState *pQFlowState;
    swiQosFlow   *pTxQFlowGranted;
    swiQosFlow   *pRxQFlowGranted;
    swiQosFilter *pTxQFilter[MAX_QOS_FILTER_TLV];
    swiQosFilter *pRxQFilter[MAX_QOS_FILTER_TLV];
    BYTE         *pBearerID;
} QosFlowInfo;


typedef struct
{
    //TODO temp commented for compilation
    //QosFlowInfoTlv   QFlowInf

    ULONG              *pDataBearer;
    ULONG              *pPacketsCountTX;
    ULONG              *pPacketsCountRX;
    ULONGLONG          *pTotalBytesTX;
    ULONGLONG          *pTotalBytesRX;
} QosEventInfo;


typedef void (* tFNSLQSQOSEvent)(
        BYTE    instance,
        QosFlowInfo *pFlowInfo
        );

ULONG SLQSSetQosEventCallback(
    BYTE instance,
    tFNSLQSQOSEvent pCallback
    );

typedef void (* tFNQosStatus)(
        BYTE    instance,
        ULONG   id,
        BYTE    status,
        BYTE    event,
        BYTE    reason
        );

ULONG SLQSSetQosStatusCallback(
    BYTE instance,
    tFNQosStatus pCallback
    );

typedef void (* tFNQosNWStatus)(
        BYTE    status
        );

ULONG SLQSSetQosNWStatusCallback(
    tFNQosNWStatus pCallback
    );

typedef void (* tFNQosPriEvent)(
        WORD    event
        );

ULONG SLQSSetQosPriEventCallback(
    tFNQosPriEvent pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    CDMASSInfo        *pCDMASigInfo;
    HDRSSInfo         *pHDRSigInfo;
    INT8              *pGSMSigInfo;
    CDMASSInfo        *pWCDMASigInfo;
    LTESSInfo         *pLTESigInfo;
    INT8              *pRscp;
    TDSCDMASigInfoExt *pTDSCDMASigInfoExt;
} nasSigInfo;

typedef void (*tFNSigInfo)( nasSigInfo *pNasSigInfo );

ULONG SLQSNasSigInfoCallBack(
    tFNSigInfo pCallback,
    sigInfo    *pSigInfo );

typedef struct _modemTempNotification
{
    BYTE ModemTempState;
    WORD ModemTemperature;
} modemTempNotification;

typedef void (*tFNModemTempInfo)
    ( modemTempNotification *pModemTempNotification );

ULONG SLQSSetModemTempCallback( tFNModemTempInfo pCallback );

typedef struct _packetSrvStatus
{
    qaQmiInterfaceInfo *pQmiInterfaceInfo;
    BYTE               connStatus;
    BYTE               reconfigReqd;
    WORD               sessionEndReason;
    WORD               verboseSessnEndReasonType;
    WORD               verboseSessnEndReason;
    BYTE               ipFamily;
    WORD               techName;
    BYTE               bearerID;
} packetSrvStatus;

typedef void (* tFNPacketSrvState)(
    packetSrvStatus *pPacketSrvStatus );

ULONG SLQSSetPacketSrvStatusCallback(
    tFNPacketSrvState pCallback );

/*
 * Name:    HDRPersonalityInd
 *
 * Purpose: Structure used to store the Tlv parameters for HDRPersonalityInd
 *
 * Members: pCurrentPersonality
 *          - Current active personality index.
 *
 *          pPersonalityListLength
 *          - Number of Personality Protocol Subtype contains in this response.
 *
 *          pProtocolSubtypeElement
 *          - See \ref protocolSubtypeElement for more information.
 */
typedef struct
{
    WORD                   *pCurrentPersonality;
    BYTE                   *pPersonalityListLength;
    protocolSubtypeElement *pProtocolSubtypeElement;
}HDRPersonalityInd;

typedef void ( *tFNHDRPersonaity )( HDRPersonalityInd *pHDRPers );

ULONG SLQSSetSwiHDRPersCallback( tFNHDRPersonaity pCallback );

typedef struct
{
    WORD  *pSIPLocalPort;
    ULONG *pTimerSIPReg;
    ULONG *pSubscribeTimer;
    ULONG *pTimerT1;
    ULONG *pTimerT2;
    ULONG *pTimerTf;
    BYTE  *pSigCompEnabled;
} imsSIPConfigInfo;

typedef void ( * tFNImsSIPConfig) ( imsSIPConfigInfo *pImsSIPConfigInfo );

ULONG SLQSSetSIPConfigCallback( tFNImsSIPConfig pCallback );

typedef struct
{
    WORD *pPriCSCFPort;
    BYTE *pCSCFPortName;
    BYTE *pIMSTestMode;
} imsRegMgrConfigInfo;

typedef void ( * tFNImsRegMgrConfig) (
    imsRegMgrConfigInfo *pImsRegMgrConfigInfo );

ULONG SLQSSetRegMgrConfigCallback( tFNImsRegMgrConfig pCallback );

typedef struct
{
    BYTE *pSMSFormat;
    BYTE *pSMSOverIPNwInd;
    BYTE *pPhoneCtxtURI;
} imsSMSConfigInfo;

typedef void ( * tFNImsSMSConfig) (
    imsSMSConfigInfo *pImsSMSConfigInfo );

ULONG SLQSSetIMSSMSConfigCallback( tFNImsSMSConfig pCallback );

typedef struct
{
    BYTE *pIMSDomain;
} imsUserConfigInfo;

typedef void ( * tFNImsUserConfig) (
    imsUserConfigInfo *pImsUserConfigInfo );

ULONG SLQSSetIMSUserConfigCallback( tFNImsUserConfig pCallback );

typedef struct
{
    WORD *pSessionExpiryTimer;
    WORD *pMinSessionExpiryTimer;
    BYTE *pAmrWbEnable;
    BYTE *pScrAmrEnable;
    BYTE *pScrAmrWbEnable;
    BYTE *pAmrMode;
    WORD *pAmrWBMode;
    BYTE *pAmrOctetAligned;
    BYTE *pAmrWBOctetAligned;
    WORD *pRingingTimer;
    WORD *pRingBackTimer;
    WORD *pRTPRTCPInactTimer;
} imsVoIPConfigInfo;

typedef void ( * tFNImsVoIPConfig) (
    imsVoIPConfigInfo *pImsVoIPConfigInfo );

ULONG SLQSSetIMSVoIPConfigCallback( tFNImsVoIPConfig pCallback );
typedef struct
{
    BYTE            *pError;
    BYTE            *pFailureCause;
    struct USSInfo  *pUSSDData;
    alphaIDInfo     *pAlphaIdentifier;
}USSDNoWaitIndicationInfo;

typedef void (* tFNUSSDNoWaitIndication)(
      USSDNoWaitIndicationInfo  *pNetworkInfo );
ULONG SetUSSDNoWaitIndicationCallback(
    tFNUSSDNoWaitIndication pCallback );

/* Unstructured supplementary service data coding scheme*/
#define USSD_DCS_ASCII  0x01 /* ASCII coding scheme */
#define USSD_DCS_8BIT   0x02 /* 8-bit coding scheme */
#define USSD_DCS_UCS2   0x03 /* UCS2  coding scheme */

typedef struct
{
    ULONG CurrChanTxRate;
    ULONG CurrChanRxRate;
} channelRate;

/*
 * Name:    DUNCallInfoInd
 *
 * Purpose: Structure used to store the Tlv parameters for DUNCallInfoInd
 *
 *  \param  MdmConnStatus
 *          - Current link status
 *              - 0x01 - Disconnected
 *              - 0x02 - Connected
 *
 *  \param  CallEndReason
 *          - Last modem call end reason
 *          - See qaGobiApiTableCallEndReasons.h for Call End Reason
 *
 *  \param  TXOKBytesCount
 *          - Number of bytes transmitted without error
 *
 *  \param  RXOKBytesCount
 *          - Number of bytes transmitted without error
 *
 *  \param  DormancyStatus
 *          - Dormancy Status
 *              - 0x01 - Traffic channel dormant
 *              - 0x02 - Traffic channel active
 *
 *  \param  DataBearerTech
 *          - Current data bearer technology
 *          - Returned only if a data call is up
 *              - 0x01 - cdma2000 1X
 *              - 0x02 - cdma2000 HRPD (1xEV-DO)
 *              - 0x03 - GSM
 *              - 0x04 - UMTS
 *              - 0x05 - cdma200 HRPD ( 1xEV-DO RevA)
 *              - 0x06 - EDGE
 *              - 0x07 - HSDPA and WCDMA
 *              - 0x08 - WCDMA and HSUPA
 *              - 0x09 - HSDPA and HSUPA
 *              - 0x0A - LTE
 *              - 0x0B - cdma2000 EHRPD
 *              - 0x0C - HSDPA+ and WCDMA
 *              - 0x0D - HSDPA+ and HSUPA
 *              - 0x0E - DC_HSDPA+ and WCDMA
 *              - 0x0F - DC_HSDPA+ and HSUPA
 *              - 0x10 - HSDPA+ and 64QAM
 *              - 0x11 - HSDPA+, 64QAM and HSUPA
 *              - 0x12 - TDSCDMA
 *              - 0x13 - TDSCDMA and HSDPA
 *              - 0xFF - Unknown
 *
 *  \param  ChannelRate
 *          - See \ref channelRate for more information
 */
typedef struct
{
    BYTE        MdmConnStatus;
    WORD        CallEndReason;
    ULONGLONG   TXOKBytesCount;
    ULONGLONG   RXOKBytesCount;
    BYTE        DormancyStatus;
    BYTE        DataBearerTech;
    channelRate ChannelRate;
}DUNCallInfoInd;

typedef void ( *tFNDUNCallInfo )( DUNCallInfoInd *pDUNCallInfo );

ULONG SLQSSetDUNCallInfoCallback( BYTE StatsPeriod, tFNDUNCallInfo pCallback );

ULONG iSLQSSetDUNCallInfoCallback ( tFNDUNCallInfo pCallback );

typedef void ( *tFNDataSysStatus )( CurrDataSysStat *pCurrDataSysStat );

ULONG SLQSSetDataSystemStatusCallback( tFNDataSysStatus pCallback );

typedef struct SMSAsyncRawSend_s
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    WORD  sendStatus;
    WORD  messageID;
    WORD  causeCode;
    BYTE  errorClass;
    WORD  RPCause;
    BYTE  TPCause;
    BYTE  msgDelFailureType;
    BYTE  msgDelFailureCause;
    BYTE  alphaIDLen;
    BYTE  *pAlphaID;
    ULONG userData;
} SMSAsyncRawSend;

typedef void (* tFNAsyncRawSend)( SMSAsyncRawSend *pSMSAsyncRawSend );

ULONG SLQSWmsAsyncRawSendCallBack( tFNAsyncRawSend pCallback );

typedef struct LteNasReleaseInfo_s
{
    BYTE nas_release;
    BYTE nas_major;
    BYTE nas_minor;
}LteNasReleaseInfo;

typedef struct SwiOTAMsg_s
{
    ULONG type;
    WORD  data_len;
    BYTE  data[2048]; /* current max size of raw message in SDK process is 2048 */
    LteNasReleaseInfo *pLteNasRelInfo;
    ULONGLONG *pTime;
} SwiOTAMsg;

typedef void (* tFNASwiOTAMsg)( SwiOTAMsg *pSwiOTAMsg );

ULONG SLQSNasSwiOTAMessageCallback( NasSwiIndReg *req, tFNASwiOTAMsg pCallback );



typedef void (* tFNNewGPS)( double dLongitude,double dLatitude,
      BYTE session_status, ULONG pos_src  );

ULONG SetGPSCallback(
    tFNNewGPS pCallback );

typedef void (* tFNNewRMTransferStatistics)(  
    QmiCbkWdsStatisticsIndState *pMsg);

ULONG SetRMTransferStatisticsCallback(
    tFNNewRMTransferStatistics pCallback );

typedef struct
{
    BYTE optCode;
    BYTE optValLen;
    BYTE *pOptVal;
} DHCPOption;

typedef struct
{
    BYTE numOpt;
    DHCPOption *pOptions;
} DHCPOptionList;

typedef struct
{
    WdsDHCPv4ProfileId *pProfileId;
    BYTE           *pLeaseState;
    ULONG          *pIPv4Addr;
    DHCPOptionList *pOptList;
} WdsDHCPv4ClientLeaseInd;

typedef void (* tFNDHCPv4ClientLeaseStatus)(  
    BYTE instance,
    WdsDHCPv4ClientLeaseInd *pMsg );

ULONG SLQSSetDHCPv4ClientLeaseStatusCallback (
    BYTE instance,
    tFNDHCPv4ClientLeaseStatus pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG cradleMountConfigStatus;
} QmiCbkLocCradleMountInd;

typedef void (* tFNSetCradleMount)( QmiCbkLocCradleMountInd *pSetLocCradleMount );

ULONG SetLocCradleMountCallback (
        tFNSetCradleMount pCallback);

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG timeSyncRefCounter;
} QmiCbkLocEventTimeSyncInd;

typedef void (* tFNSetEventTimeSync)( QmiCbkLocEventTimeSyncInd *pSetLocEventTimeSync );

ULONG SetLocEventTimeSyncCallback (
      tFNSetEventTimeSync pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG injectTimeSyncStatus;
} QmiCbkLocInjectTimeInd;

typedef void (* tFNInjectTimeStatus)( QmiCbkLocInjectTimeInd *pLocInjectTime );

ULONG SetLocInjectTimeCallback (
       tFNInjectTimeStatus pCallback );
typedef struct accelAcceptReady_s{
     BYTE    injectEnable;
     WORD    samplesPerBatch;
     WORD    batchPerSec;
}accelAcceptReady;

typedef struct gyroAcceptReady_s{
     BYTE    injectEnable;
     WORD    samplesPerBatch;
     WORD    batchPerSec;
}gyroAcceptReady;
typedef struct accelTempAcceptReady_s{
     BYTE    injectEnable;
     WORD    samplesPerBatch;
     WORD    batchPerSec;
}accelTempAcceptReady;
typedef struct gyroTempAcceptReady_s{
     BYTE    injectEnable;
     WORD    samplesPerBatch;
     WORD    batchPerSec;
}gyroTempAcceptReady;

typedef struct{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    accelAcceptReady       *pAccelAcceptReady;
    gyroAcceptReady        *pGyroAcceptReady;
    accelTempAcceptReady   *pAccelTempAcceptReady;
    gyroTempAcceptReady    *pGyroTempAcceptReady;
} QmiCbkLocSensorStreamingInd;

typedef void (* tFNSensorStreaming)( QmiCbkLocSensorStreamingInd *pLocSensorStream );

ULONG SetLocSensorStreamingCallback (
       tFNSensorStreaming pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG injectSensorDataStatus;
    ULONG *pOpaqueIdentifier;
    BYTE  *pAccelSamplesAccepted;
    BYTE  *pGyroSamplesAccepted;
    BYTE  *pAccelTempSamplesAccepted;
    BYTE  *pGyroTempSamplesAccepted;
} QmiCbkLocInjectSensorDataInd;

typedef void (* tFNInjectSensorData)( QmiCbkLocInjectSensorDataInd *pLocInjectSensorData );

ULONG SetLocInjectSensorDataCallback (
       tFNInjectSensorData pCallback );
typedef struct precisionDilution_s{
     ULONG    PDOP;
     ULONG    HDOP;
     ULONG    VDOP;
}precisionDilution;

typedef struct gpsTime_s{
     WORD     gpsWeek;
     ULONG    gpsTimeOfWeekMs;
}gpsTime;

typedef struct sensorDataUsage_s{
     ULONG     usageMask;
     ULONG     aidingIndicatorMask;
}sensorDataUsage;

typedef struct svUsedforFix_s{
     BYTE     gnssSvUsedList_len ;
     WORD     gnssSvUsedList[255];
}svUsedforFix;

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult      results;
    ULONG                   sessionStatus;
    BYTE                    sessionId;
    ULONGLONG               *pLatitude;
    ULONGLONG               *pLongitude;
    ULONG                   *pHorUncCircular;
    ULONG                   *pHorUncEllipseSemiMinor;
    ULONG                   *pHorUncEllipseSemiMajor;
    ULONG                   *pHorUncEllipseOrientAzimuth;
    BYTE                    *pHorConfidence;
    ULONG                   *pHorReliability;
    ULONG                   *pSpeedHorizontal;
    ULONG                   *pSpeedUnc;
    ULONG                   *pAltitudeWrtEllipsoid;
    ULONG                   *pAltitudeWrtMeanSeaLevel;
    ULONG                   *pVertUnc;
    BYTE                    *pVertConfidence;
    ULONG                   *pVertReliability;
    ULONG                   *pSpeedVertical;
    ULONG                   *pHeading;
    ULONG                   *pHeadingUnc;
    ULONG                   *pMagneticDeviation;
    ULONG                   *pTechnologyMask;
    precisionDilution       *pPrecisionDilution;
    ULONGLONG               *pTimestampUtc;
    BYTE                    *pLeapSeconds;
    gpsTime                 *pGpsTime;
    ULONG                   *pTimeUnc;
    ULONG                   *pTimeSrc;
    sensorDataUsage         *pSensorDataUsage;
    ULONG                   *pFixId;
    svUsedforFix            *pSvUsedforFix;
    BYTE                    *pAltitudeAssumed;
} QmiCbkLocPositionReportInd;

typedef void (* tFNEventPosition)( QmiCbkLocPositionReportInd *pLocPositionReport );
typedef struct
{
    BYTE len;
    USHORT entries[255];
} t_Sv;

typedef struct
{
    ULONG usageMask;
    ULONG aidingIndicatorMask;
} t_sensor;

typedef struct
{
    USHORT gpsWeek;
    ULONG gpsTimeOfWeekMs;
} t_gpsTime;

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult      results;
    ULONG                   status;
    ULONG                   *pXid;
    ULONGLONG               *pLatitude;
    ULONGLONG               *pLongitude;
    ULONG                   *pHorUncCircular;
    ULONG                   *pAltitudeWrtEllipsoid;
    ULONG                   *pVertUnc;
    ULONGLONG               *pTimestampUtc;
    ULONG                   *pTimeUnc;
    ULONG                   *pHorUncEllipseSemiMinor;
    ULONG                   *pHorUncEllipseSemiMajor;
    ULONG                   *pHorUncEllipseOrientAzimuth;
    BYTE                    *pHorCirConf;
    BYTE                    *pHorEllpConf;
    ULONG                   *pHorReliability;
    ULONG                   *pSpeedHorizontal;
    ULONG                   *pSpeedUnc;
    ULONG                   *pAltitudeWrtMeanSeaLevel;
    BYTE                    *pVertConfidence;
    ULONG                   *pVertReliability;
    ULONG                   *pSpeedVertical;
    ULONG                   *pSpeedVerticalUnc;
    ULONG                   *pHeading;
    ULONG                   *pHeadingUnc;
    ULONG                   *pMagneticDeviation;
    ULONG                   *pTechnologyMask;
    precisionDilution       *pPrecisionDilution;
    gpsTime                 *pGpsTime;
    ULONG                   *pTimeSrc;
    sensorDataUsage         *pSensorDataUsage;
    svUsedforFix            *pSvUsedforFix;
} QmiCbkLocBestAvailPosInd;

typedef void (* tFNBestAvailPos)( QmiCbkLocBestAvailPosInd *pBestAvailPos );


typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult  results;
    ULONG               mode;
} QmiCbkLocOpModeInd;

typedef void (* tFNOpMode)( QmiCbkLocOpModeInd *pLocOpmode );

ULONG SetLocEventPositionCallback (
       tFNEventPosition pCallback );

ULONG SetLocOpModeCallback (
       tFNOpMode pCallback );

typedef struct
{
    BYTE *pbIMSRegistered;
    WORD *pRegStatusErrorCode;
    ULONG *pImsRegStatus;
} imsaRegStatusInfo;

typedef void ( * tFNImsaRegStatus) (
    imsaRegStatusInfo *pImsaRegStatusInfo );

ULONG SLQSSetIMSARegStatusCallback( tFNImsaRegStatus pCallback );

typedef struct
{
    ULONG *pSMSSvcStatus;
    ULONG *pVOIPSvcStatus;
    ULONG *pVTSvcStatus;
    ULONG *pSMSSvcRAT;
    ULONG *pVOIPSvcRAT;
    ULONG *pVTSvcRAT;
    ULONG *pUTSvcStatus;
    ULONG *pUTSvcRAT;
} imsaSvcStatusInfo;

typedef void ( * tFNImsaSvcStatus) (
    imsaSvcStatusInfo *pImsaSvcStatusInfo );

ULONG SLQSSetIMSASvcStatusCallback( tFNImsaSvcStatus pCallback );

typedef struct
{
    ULONG *pRATStatus;
    ULONG *pSrcRAT;
    ULONG *pTgtRAT;
    BYTE  *pErrorCodeStr;
} imsaRatStatusInfo;

typedef void ( * tFNImsaRatStatus) (
    imsaRatStatusInfo *pImsaRatStatusInfo );

ULONG SLQSSetIMSARatStatusCallback( tFNImsaRatStatus pCallback );

typedef struct
{
    BYTE  connetionState;
    ULONG *pFailErrorCode;
} imsaPdpStatusInfo;

typedef void ( * tFNImsaPdpStatus) (
        imsaPdpStatusInfo *pImsaPdpStatusInfo );

ULONG SLQSSetIMSAPdpStatusCallback( tFNImsaPdpStatus pCallback );

ULONG SLQSNasSigInfo2CallBack(
    tFNSigInfo             pCallback,
    setSignalStrengthInfo  *pSigInfo2 );

typedef struct
{
    BYTE  svListLen;
    ULONG validMask;
    ULONG system;
    WORD  gnssSvId;
    BYTE  healthStatus;
    ULONG svStatus;
    BYTE  svInfoMask;
    FLOAT elevation;
    FLOAT azimuth;
    FLOAT snr;
} satelliteInfo;

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    BYTE bAltitudeAssumed;
    satelliteInfo *pSatelliteInfo;    
} gnssSvInfoNotification;

typedef void (*tFNGnssSvInfo)
    (gnssSvInfoNotification *pGnssSvInfoNotification );

ULONG SetLocGnssSvInfoCallback(
    tFNGnssSvInfo pCallback );


typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG status;
} delAssistDataStatus;

typedef void (*tFNDelAssistData)
    (delAssistDataStatus *pAssistDataNotification );

ULONG SetLocDeleteAssistDataCallback(
    tFNDelAssistData pCallback );


typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    PhyCaAggScellIndType    sPhyCaAggScellIndType;
    PhyCaAggScellDlBw       sPhyCaAggScellDlBw;
    PhyCaAggScellInfo       sPhyCaAggScellInfo;
    PhyCaAggPcellInfo       sPhyCaAggPcellInfo;
    PhyCaAggScellIndex      sPhyCaAggScellIndex;
} QmiCbkNasLTECphyCaInfo;


typedef void (* tFNASwiLTECphyCalInfo)( QmiCbkNasLTECphyCaInfo *pQmiCbkNasLTECphyCaInfo );

ULONG SetNasLTECphyCaIndCallback(tFNASwiLTECphyCalInfo pCallback);

/*
 * Name:    RankIndicatorInd
 *
 * Purpose: Structure used to store the Tlv parameters for RankIndicatorInd
 *
 *  \param  pCount1
 *          - Count of Rank 1
 *
 *  \param  pCount2
 *          - Count of Rank 2
 */
typedef struct
{
    WORD                   Count1;
    WORD                   Count2;
}RankIndicatorInd;

typedef void ( *tFNRankIndicator )( RankIndicatorInd *pRankIndicatorInd );

ULONG SetRankIndicatorCallback(
    tFNRankIndicator pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG status;
}QmiCbkLocInjectUTCTimeInd;

typedef void (*tFNInjectUTCTime)
    (QmiCbkLocInjectUTCTimeInd *pInjectUTCTimeNotification );

ULONG SLQSSetLocInjectUTCTimeCallback(
    tFNInjectUTCTime pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG status;
}QmiCbkLocInjectPositionInd;

typedef void (*tFNInjectPosition)
    (QmiCbkLocInjectPositionInd *pInjectPositionNotification );

ULONG SLQSSetLocInjectPositionCallback(
    tFNInjectPosition pCallback );

typedef struct
{
    UIMSlotsStatus slotsstatusChange;
    BYTE bNumberOfPhySlots;
}UIMSlotStatusChangeInfo;

typedef void (*tFNCbkUimSlotStatusChangeInd)
    (UIMSlotStatusChangeInfo *pQmiCbkUimSlotStatusChangeInd );

ULONG SetUimSlotStatusChangeCallback(
    tFNCbkUimSlotStatusChangeInd pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG engineState;
} QmiCbkLocEngineStateInd;

typedef void (* tFNSetEngineState)( QmiCbkLocEngineStateInd *pSetLocEngineState );

ULONG SetLocEngineStateCallback (
      tFNSetEngineState pCallback );


typedef struct _getResetInfoNotification
{
    BYTE type;
    BYTE source;
} ResetInfoNotification;

typedef void (*tFNResetInfo)
    ( ResetInfoNotification *pResetInfoNotification );

ULONG SLQSSetSwiGetResetInfoCallback (
      tFNResetInfo pCallback );


typedef struct
{
    BYTE  deviceIdLen;
    CHAR  deviceID [MAX_MITIGATION_DEV_ID_LEN];
} _MitigationDevInfo;


typedef struct
{
    struct qmTlvResult results;
    _MitigationDevInfo MitigationDevInfo;
    BYTE              currentMitigationLvl;
} QmiCbkTmdMitiLvlRptInd;

typedef void (* tFNMitiLvlRpt)( QmiCbkTmdMitiLvlRptInd *pSetLocCradleMount );


ULONG SLQSTmdMitigationLvlRptCallback(
        TmdMitigationLvlIndReq *req,
        tFNMitiLvlRpt pCallback );


typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG status;
} QmiCbkLocSetExtPowerConfigInd;

typedef void (* tFNSetExtPowerConfig)( QmiCbkLocSetExtPowerConfigInd *pSetExtConfigIndStatus );

ULONG SetLocSetExtPowerConfigCallback (
        tFNSetExtPowerConfig pCallback);

ULONG SetLocBestAvailPosCallback (
        tFNBestAvailPos pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    char t3396_apn[101];
    BYTE t3396_plmn_id[3];
    ULONG t3396_val;
} nasTimers;

typedef void (*tFNNasTimer) (nasTimers *timers);

ULONG SLQSNasTimerCallback( tFNNasTimer pCallback );

typedef enum
{
    SYS_SRV_DOMAIN_NO_SRV  = 0x00,
    SYS_SRV_DOMAIN_CS_ONLY = 0x01,
    SYS_SRV_DOMAIN_PS_ONLY = 0x02,
    SYS_SRV_DOMAIN_CS_PS   = 0x03,
    SYS_SRV_DOMAIN_CAMPED  = 0x04
}TYPE_OF_SERVICE_DOMAIN;

typedef struct
{
    ULONG csgId;
    BYTE TlvPresent;
}CsgId;

typedef struct
{
    WORD mcc;
    WORD mnc;
    BOOL pcsDigit;
    BYTE TlvPresent;
}PlmnID;

typedef struct
{
    BYTE radioIf;
    TYPE_OF_SERVICE_DOMAIN serviceDomain;
    BYTE rejectCause;
    PlmnID *pPlmnId;
    CsgId *pCsgId;
} nasNetworkReject;

typedef void ( *tFNNetworkReject )
    ( nasNetworkReject *pNetworkReject );

ULONG SLQSNasNetworkRejectCallback( tFNNetworkReject pCallback );

/*
 *  Structure for Swi AVMS Event Report indication parameters.
 *
 *  \param  pBinaryUPdateSessionInfo (optional)
 *          - See \ref QmiSwiAvmsEventReportBinaryUpdateSessionInfoResp for more information
 *
 *  \param  pConfig (optional)
 *          - See \ref QmiSwiAvmsEventReportConfigResp for more information.
 *
 *  \param  pNotification (optional)
 *          - See \ref QmiSwiAvmsEventReportNotificationResp for more information.
 *
 *  \param  pConnectionRequest (optional)
 *          - See \ref QmiSwiAvmsEventReportConnectionRequestResp for more information.
 *
 *  \param  pWAMSParaChanged (optional)
 *          - See \ref QmiSwiAvmsEventReportWAMSParamChangeResp for more information.
 *
 *  \param  pPackageID (optional)
 *          - See \ref QmiSwiAvmsEventReportPackageIDResp for more information.
 *
 *  \param  pRegStatus (optional)
 *          - See \ref QmiSwiAvmsEventReportRegStatusResp for more information.
 *
 *  \param  pDataSessionStatus (optional)
 *          - See \ref QmiSwiAvmsEventReportNotifStatusResp for more information.
 *
 *  \param  pSessionType (optional)
 *          - See \ref QmiSwiAvmsEventReportSessionTypeResp for more information.
 */
typedef struct _SwiAvmsEventInd
{
    QmiSwiAvmsEventReportBinaryUpdateSessionInfoResp 
        BinaryUpdateSessionInfo;
    QmiSwiAvmsEventReportConfigResp 
        Config;
    QmiSwiAvmsEventReportNotificationResp 
        Notification;
    QmiSwiAvmsEventReportConnectionRequestResp 
        ConnectionRequest;
    QmiSwiAvmsEventReportWAMSParamChangeResp 
        WAMSParaChanged;
    QmiSwiAvmsEventReportPackageIDResp 
        PackageID;
    QmiSwiAvmsEventReportDataSessionStatusResp
        DataSessionStatus;
    QmiSwiAvmsEventReportSessionTypeResp 
        SessionType;
    QmiSwiAvmsEventReportHTTPStatusResp 
        HTTPStatus;
    QmiSwiAvmsEventReportRegStatusResp 
        RegStatus;
   
}SwiAvmsEventInd;

typedef void ( *tFNSwiAvmEventReport )
    ( SwiAvmsEventInd *pEvent );

ULONG SLQSSwiAVMSEventReportCallback( tFNSwiAvmEventReport pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    CHAR               *pNMEAData;
} QmiCbkLocEventNMEAInd;

typedef void (*tFNEventNmea)
    (QmiCbkLocEventNMEAInd *pNMEAEventData );

ULONG SetLocEventMaskNMEACallback( tFNEventNmea pCallback );

typedef struct
{
    ULONG address;
    WORD  port;
    BYTE TlvPresent;
} IPv4Info;

typedef struct
{
    WORD  address[8];
    ULONG port;
    BYTE TlvPresent;
} IPv6Info;

typedef struct
{
    CHAR  address[256];
    BYTE TlvPresent;
} urlAddr;

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG      serverStatus;
    ULONG      serverType;
    IPv4Info   *pIPv4AddrInfo;
    IPv6Info   *pIPv6AddrInfo;
    urlAddr    *pURL;
} QmiCbkLocGetServerInd;

typedef void (* tFNGetServer)( QmiCbkLocGetServerInd *pGetLocServerInfo );

ULONG SetLocGetServerCallback (LocGetServerReq *req,
        tFNGetServer pCallback );

typedef struct
{
    BYTE         *pEnableState;
    ULONG        *pActiveTimer;
    ULONG        *pPeriodicUpdateTimer;
} dmsPsmCfgParamChange;

typedef void (*tFNPSMCfgParamChange)( dmsPsmCfgParamChange *pPSMCfgParamInd );

ULONG SetCfgParamChangeCallback(tFNPSMCfgParamChange pCallback );

typedef struct
{
    /* Every response message must have a results structure */
    struct qmTlvResult results;
    ULONG      serverStatus;
} QmiCbkLocSetServerInd;

typedef void (* tFNSetServer)( QmiCbkLocSetServerInd *pSetLocServerInfo );

ULONG SetLocSetServerCallback (LocSetServerReq *req,
        tFNSetServer pCallback );

#ifdef __cplusplus
} /* extern "C" { */
#endif

#endif /* __GOBI_API_CBK_H__ */