Gitiles
Code Review Sign In
192.168.1.100 / T108 / e958203796650e3959a43708d67534bf36f4c83b / . / marvell / services / mbim / mbim_basic.c
blob: 08e9f6a0e1c8645a8ab06f70fc52b0f6debd04b2 [file] [log] [blame]
/******************************************************************************
*(C) Copyright 2014 Marvell International Ltd.
* All Rights Reserved
******************************************************************************/
/* -------------------------------------------------------------------------------------------------------------------
*
* Filename: mbim_util.c
*
* Authors: Adrian Zelezniak
*
* Description: all utiliy functions and macros needed for the MIBM translator
*
* HISTORY:
* Jan 7, 2014 - Initial Version
*
* Notes:
*
******************************************************************************/
#define LOG_TAG "MBIM"
/******************************************************************************
* Include files
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include "mbim_types.h"
#include "mbim_basic.h"
#include "mbim_sms.h"
#include "mbim_ussd.h"
#include "mbim_util.h"
#include "mbim_protocol.h"
#if defined (MBIM_MTIL)
#include "mbim_mtil.h"
#include "mbim_mtil_ind.h"
#include "MtilAPI.h"
#include "mbim_cm.h"
#else
#include "mbim_ril.h"
#endif
#ifndef MBIM_BASIC_UNUSEDPARAM
#define MBIM_BASIC_UNUSEDPARAM() ((void) cid);((void) transactionId);((void) commandType);((void) infoBufLen);((void) infoBuf_p)
#endif
extern int property_get(const char *name, const char* value, const char* default_value);
/******************************************************************************
* Macros
******************************************************************************/
#define CREATE_BASIC_CONNECT_CONTEXT(pContext, mBuf) \
pContext = (P_MBIM_MESSAGE_CONTEXT)MBIM_MALLOC(sizeof(MBIM_MESSAGE_CONTEXT)); \
if (pContext != NULL) { \
pContext->hdr.cid = cid; \
pContext->hdr.transId = transactionId; \
pContext->hdr.uuidIndex = UUID_BASIC_CONNECT_INDEX; \
pContext->hdr.indication= MBIM_REQUEST; \
pContext->body = mBuf; \
pContext->cmd = NULL; \
} \
else { \
if (mBuf != NULL) \
MBIM_FREE(mBuf); \
MBIM_LOGE("BASIC UUID: OUT OF MEMORY CID %d (TransactionId = %d, Cmd Type = %d)", cid, transactionId, commandType); \
return MbimSendFunctionErrorMsg(transactionId, MBIM_ERROR_UNKNOWN); \
}
#define ALLOCATE_RESPONSE_BUFFER(mBuf_p, mSize) \
mBuf_p = (char *)MBIM_MALLOC(mSize); \
if (mBuf_p == NULL) { \
MBIM_LOGE("BASIC UUID: OUT OF MEMORY CID %d (TransactionId = %d, Cmd Type = %d)", cid, transactionId, commandType); \
return MbimSendFunctionErrorMsg(transactionId, MBIM_ERROR_UNKNOWN); \
} else \
{ memset(mBuf_p, 0, mSize); }
#define ALLOCATE_CMD_BUFFER(context_p, mBuf_p, mSize) \
mBuf_p = (char *)MBIM_MALLOC(mSize); \
if (mBuf_p == NULL) { \
if (context_p->body != NULL) \
MBIM_FREE(context_p->body); \
MBIM_LOGE("BASIC UUID: OUT OF MEMORY CID %d (TransactionId = %d, Cmd Type = %d)", cid, transactionId, commandType); \
return MbimSendFunctionErrorMsg(transactionId, MBIM_ERROR_UNKNOWN); \
} else { \
memset(mBuf_p, 0, mSize); \
context_p->cmd = mBuf_p; \
}
#define ADD_DEVICE_SERVICES(service) *pCidSupported = service; \
pCidSupported++; \
pBuf->cidCount++;
/******************************************************************************
* #defines
******************************************************************************/
#define DEFAULT_CONTEXT_ALLOC_SIZE (4000)
/******************************************************************************
* Global Variables
******************************************************************************/
extern MBIM_DATABASE mbimDb;
Boolean ConfigureAzw = TRUE;
/* services filer arrays */
char basicFilterArray[UUID_BASIC_CID_MAX];
char smsFilterArray[UUID_SMS_CID_MAX];
char ussdFilterArray[UUID_USSD_CID_MAX];
UINT32 cidsFilterArray[UUID_MAX_SERVICE_INDEX][2] =
{
{(UINT32)&basicFilterArray,sizeof(basicFilterArray)},
{(UINT32)&smsFilterArray,sizeof(smsFilterArray)},
{(UINT32)&ussdFilterArray,sizeof(ussdFilterArray)},
{0,0},
{0,0},
{0,0},
{0,0}
};
//BS:
Boolean disableUnsolCidConnect = FALSE;
/******************************************************************************
* Function prototypes
******************************************************************************/
static int addBasicConnectServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf);
static int addSmsServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf);
static int addUssdServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf);
static int addPhonebookServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf);
static int addStkServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf);
static int addAuthServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf);
static int addDssServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf);
static int addBasicExtServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf);
static int addUICCServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf);
static void MbimSetDeviceServiceSubscribeList (P_MBIM_DEVICE_SERVICE_SUBSCRIBE_LIST pDevServSubsList);
//static int validateCidConnectSetCommand(P_MBIM_SET_CONNECT pSetConnect);
int CID_DeviceCaps(BASIC_CID_PARAMS);
int CID_SubscriberReadyStatus(BASIC_CID_PARAMS);
int CID_RadioState(BASIC_CID_PARAMS);
int CID_Pin(BASIC_CID_PARAMS);
int CID_PinList(BASIC_CID_PARAMS);
int CID_HomeProvider(BASIC_CID_PARAMS);
int CID_PreferedProviders(BASIC_CID_PARAMS);
int CID_VisibleProviders(BASIC_CID_PARAMS);
int CID_RegisterState(BASIC_CID_PARAMS);
int CID_PacketService(BASIC_CID_PARAMS);
int CID_SignalState(BASIC_CID_PARAMS);
int CID_Connect(BASIC_CID_PARAMS);
int CID_ProvisionedContexts(BASIC_CID_PARAMS);
int CID_ServiceActivation(BASIC_CID_PARAMS);
int CID_IpConfiguration(BASIC_CID_PARAMS);
int CID_DeviceServices(BASIC_CID_PARAMS);
int CID_DeviceServicesSubscribeList(BASIC_CID_PARAMS);
int CID_PacketStatistics(BASIC_CID_PARAMS);
int CID_NetworkIdleHint(BASIC_CID_PARAMS);
int CID_EmergencyMode(BASIC_CID_PARAMS);
int CID_IpPacketFilters(BASIC_CID_PARAMS);
int CID_MultiCarrierProviders(BASIC_CID_PARAMS);
int CID_NotSupported(BASIC_CID_PARAMS);
/******************************************************************************
* External variables
******************************************************************************/
basicUuidProcessors basicCidProcessor[UUID_BASIC_CID_MAX] = {
CID_NotSupported, //0
CID_DeviceCaps,
CID_SubscriberReadyStatus,
CID_RadioState,
CID_Pin,
CID_PinList,
CID_HomeProvider,
CID_PreferedProviders,
CID_VisibleProviders,
CID_RegisterState,
CID_PacketService, //10
CID_SignalState,
CID_Connect,
CID_ProvisionedContexts,
CID_ServiceActivation,
CID_IpConfiguration,
CID_DeviceServices,
CID_NotSupported, //17
CID_NotSupported,//18
CID_DeviceServicesSubscribeList,
CID_PacketStatistics,
CID_NetworkIdleHint,
CID_EmergencyMode,
CID_IpPacketFilters,
CID_MultiCarrierProviders,
};
/******************************************************************************
* Code
******************************************************************************/
/*******************************************************************************\
* Function: CID_NotSupported
* Description: This function sends Error to HOST when a unknown command is received
* Parameters: dataBuf - String
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_NotSupported(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
MBIM_LOGE("BASIC UUID: Command %d not supported (TransactionId = %d, Cmd Type = %d)", cid, transactionId, commandType);
//rc = MbimSendFunctionErrorMsg(transactionId, MBIM_ERROR_UNKNOWN); //Send Error to MBIM
rc = MbimSendCommandDone(transactionId, UUID_BASIC_CONNECT_INDEX,
cid, MBIM_STATUS_NO_DEVICE_SUPPORT, 0 , NULL);
return rc;
}
#define NUMBER_OF_MAX_DSS_SERVICES 7
#define NUMBER_OF_MAX_CID 18
/*******************************************************************************\
* Function: CID_DeviceServices
* Description: MBIM_CID_DEVEICE_SERVICES (Chapter 10.5.29)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_DeviceServices(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_DEVICE_SERVICE_INFO serviecInfo_p;
P_OL_PAIR_LIST pairList_p;
P_OL_PAIR_LIST prevPairList_p;
int serviceIndex;
//We only support Query for this command
if (commandType != MBIM_QUERY_COMMAND)
{
return CID_NotSupported(BASIC_CID_PARAMS_USAGE);
}
//This command is HC
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Pickup pointer to header
serviecInfo_p = (P_MBIM_DEVICE_SERVICE_INFO)&buf[0];
serviecInfo_p->deviceServicesCount = UUID_MAX_SERVICE_INDEX;
serviecInfo_p->maxDssSessions = 1; // Number of Session supported (We start with 1, need to change in the future).
//////////////////////////////////////////
//Add BASIC-CONNECT Cid elements
//////////////////////////////////////////
//Add BASIC CID supported Services
pairList_p = (P_OL_PAIR_LIST)&buf[sizeof(MBIM_DEVICE_SERVICE_INFO)];
pairList_p->offset = sizeof(MBIM_DEVICE_SERVICE_INFO) + serviecInfo_p->deviceServicesCount*sizeof(OL_PAIR_LIST);
pairList_p->size = addBasicConnectServiceElements((P_MBIM_DEVICE_SERVICE_ELEMENT)(&buf[pairList_p->offset]));
for (serviceIndex = 1 ; serviceIndex < (int)serviecInfo_p->deviceServicesCount ; serviceIndex++)
{
//Add supported services
prevPairList_p = pairList_p;
pairList_p++;
pairList_p->offset = prevPairList_p->offset + prevPairList_p->size;
switch(serviceIndex)
{
case UUID_SMS_INDEX:
pairList_p->size = addSmsServiceElements((P_MBIM_DEVICE_SERVICE_ELEMENT)(&buf[pairList_p->offset]));
break;
case UUID_USSD_INDEX:
pairList_p->size = addUssdServiceElements((P_MBIM_DEVICE_SERVICE_ELEMENT)(&buf[pairList_p->offset]));
break;
case UUID_PHONEBOOK_INDEX:
pairList_p->size = addPhonebookServiceElements((P_MBIM_DEVICE_SERVICE_ELEMENT)(&buf[pairList_p->offset]));
break;
case UUID_STK_INDEX:
pairList_p->size = addStkServiceElements((P_MBIM_DEVICE_SERVICE_ELEMENT)(&buf[pairList_p->offset]));
break;
case UUID_AUTH_INDEX:
pairList_p->size = addAuthServiceElements((P_MBIM_DEVICE_SERVICE_ELEMENT)(&buf[pairList_p->offset]));
break;
case UUID_DSS_INDEX:
pairList_p->size = addDssServiceElements((P_MBIM_DEVICE_SERVICE_ELEMENT)(&buf[pairList_p->offset]));
break;
case UUID_BASIC_CONNECT_EXTENSIONS_INDEX:
pairList_p->size = addBasicExtServiceElements((P_MBIM_DEVICE_SERVICE_ELEMENT)(&buf[pairList_p->offset]));
break;
case UUID_MS_UICC_LOW_LEVEL_INDEX:
pairList_p->size = addUICCServiceElements((P_MBIM_DEVICE_SERVICE_ELEMENT)(&buf[pairList_p->offset]));
break;
default:
break;
}
}
//Send the Command Done back to MBIM Host
MbimSendCommandDone(transactionId, UUID_BASIC_CONNECT_INDEX, cid, MBIM_STATUS_SUCCESS, (pairList_p->offset+pairList_p->size) , buf);
//Free the buffer
MBIM_FREE(buf);
return rc;
}
/*******************************************************************************\
* Function: addBasicConnectServiceElements
* Description: Adds the supported BASIC_CONNECT CID to the Service Element
* Parameters: P_MBIM_DEVICE_SERVICE_ELEMENT pBuf - Pointer to the beggining of the service Element
*
* Returns: the size of the current element
\*******************************************************************************/
static int addBasicConnectServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf)
{
UINT32 *pCidSupported;
Index2UUID((P_MBIM_UUID)&pBuf->deviceServiceId.uuid[0], UUID_BASIC_CONNECT_INDEX);
pBuf->dssPayload = 0;
pBuf->maxDssInstaces = 0;
pBuf->cidCount = 0; //This grows each time a command CID is added (See macro ADD_DEVICE_SERVICES)
pCidSupported = (UINT32 *)&pBuf->dataBuffer[0];
ADD_DEVICE_SERVICES(UUID_BASIC_CID_DEVICE_CAPS);
ADD_DEVICE_SERVICES(UUID_SUBSCRIBER_READY_STATUS);
ADD_DEVICE_SERVICES(UUID_RADIO_STATE);
ADD_DEVICE_SERVICES(UUID_PIN);
ADD_DEVICE_SERVICES(UUID_PIN_LIST);
ADD_DEVICE_SERVICES(UUID_HOME_PROVIDER);
ADD_DEVICE_SERVICES(UUID_PREFERRED_PROVIDERS);
ADD_DEVICE_SERVICES(UUID_VISIBLE_PROVIDERS);
ADD_DEVICE_SERVICES(UUID_REGISTER_STATE);
ADD_DEVICE_SERVICES(UUID_PACKET_SERVICE);
ADD_DEVICE_SERVICES(UUID_SIGNAL_STATE);
ADD_DEVICE_SERVICES(UUID_CONNECT);
ADD_DEVICE_SERVICES(UUID_PROVISIONED_CONTEXTS);
ADD_DEVICE_SERVICES(UUID_SERVICE_ACTIVATION);
ADD_DEVICE_SERVICES(UUID_IP_CONFIGURATION);
ADD_DEVICE_SERVICES(UUID_DEVICE_SERVICES);
ADD_DEVICE_SERVICES(UUID_DEVICE_SERVICE_SUBSCRIBE_LIST);
ADD_DEVICE_SERVICES(UUID_PACKET_STATISTICS);
ADD_DEVICE_SERVICES(UUID_NETWORK_IDLE_HINT);
ADD_DEVICE_SERVICES(UUID_EMERGENCY_MODE);
ADD_DEVICE_SERVICES(UUID_IP_PACKET_FILTERS);
//return the size of the service element
return ((UINT32)pCidSupported - (UINT32)pBuf );
}
/*******************************************************************************\
* Function: addSmsServiceElements
* Description: Adds the supported SMS CID to the Service Element
* Parameters: P_MBIM_DEVICE_SERVICE_ELEMENT pBuf - Pointer to the beggining of the service Element
*
* Returns: the size of the current element
\*******************************************************************************/
static int addSmsServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf)
{
UINT32 *pCidSupported;
Index2UUID((P_MBIM_UUID)&pBuf->deviceServiceId.uuid[0], UUID_SMS_INDEX);
pBuf->dssPayload = 0;
pBuf->maxDssInstaces = 0;
pBuf->cidCount = 0; //This grows each time a command CID is added (See macro ADD_DEVICE_SERVICES)
pCidSupported = (UINT32 *)&pBuf->dataBuffer[0];
ADD_DEVICE_SERVICES(UUID_SMS_CONFIGURATION);
ADD_DEVICE_SERVICES(UUID_SMS_READ);
ADD_DEVICE_SERVICES(UUID_SMS_SEND);
ADD_DEVICE_SERVICES(UUID_SMS_DELETE);
ADD_DEVICE_SERVICES(UUID_SMS_MESSAGE_STORE_STATUS);
//return the size of the service element
return ((UINT32)pCidSupported - (UINT32)pBuf );
}
/*******************************************************************************\
* Function: addUssdServiceElements
* Description: Adds the supported USSD CID to the Service Element
* Parameters: P_MBIM_DEVICE_SERVICE_ELEMENT pBuf - Pointer to the beggining of the service Element
*
* Returns: the size of the current element
\*******************************************************************************/
static int addUssdServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf)
{
UINT32 *pCidSupported;
Index2UUID((P_MBIM_UUID)&pBuf->deviceServiceId.uuid[0], UUID_USSD_INDEX);
pBuf->dssPayload = 0;
pBuf->maxDssInstaces = 0;
pBuf->cidCount = 0; //This grows each time a command CID is added (See macro ADD_DEVICE_SERVICES)
pCidSupported = (UINT32 *)&pBuf->dataBuffer[0];
ADD_DEVICE_SERVICES(MBIM_CID_USSD);
//return the size of the service element
return ((UINT32)pCidSupported - (UINT32)pBuf );
}
/*******************************************************************************\
* Function: addPhonebookServiceElements
* Description: Adds the supported PHONEBOOK CID to the Service Element
* Parameters: P_MBIM_DEVICE_SERVICE_ELEMENT pBuf - Pointer to the beggining of the service Element
*
* Returns: the size of the current element
\*******************************************************************************/
static int addPhonebookServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf)
{
UINT32 *pCidSupported;
Index2UUID((P_MBIM_UUID)&pBuf->deviceServiceId.uuid[0], UUID_PHONEBOOK_INDEX);
pBuf->dssPayload = 0;
pBuf->maxDssInstaces = 0;
pBuf->cidCount = 0; //This grows each time a command CID is added (See macro ADD_DEVICE_SERVICES)
pCidSupported = (UINT32 *)&pBuf->dataBuffer[0];
ADD_DEVICE_SERVICES(MBIM_CID_PHONEBOOK_CONFIGURATION);
ADD_DEVICE_SERVICES(MBIM_CID_PHONEBOOK_READ);
ADD_DEVICE_SERVICES(MBIM_CID_PHONEBOOK_DELETE);
ADD_DEVICE_SERVICES(MBIM_CID_PHONEBOOK_WRITE);
//return the size of the service element
return ((UINT32)pCidSupported - (UINT32)pBuf );
}
/*******************************************************************************\
* Function: addStkServiceElements
* Description: Adds the supported STK CID to the Service Element
* Parameters: P_MBIM_DEVICE_SERVICE_ELEMENT pBuf - Pointer to the beggining of the service Element
*
* Returns: the size of the current element
\*******************************************************************************/
static int addStkServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf)
{
UINT32 *pCidSupported;
Index2UUID((P_MBIM_UUID)&pBuf->deviceServiceId.uuid[0], UUID_STK_INDEX);
pBuf->dssPayload = 0;
pBuf->maxDssInstaces = 0;
pBuf->cidCount = 0; //This grows each time a command CID is added (See macro ADD_DEVICE_SERVICES)
pCidSupported = (UINT32 *)&pBuf->dataBuffer[0];
ADD_DEVICE_SERVICES(MBIM_CID_STK_PAC);
ADD_DEVICE_SERVICES(MBIM_CID_STK_TERMINAL_RESPONSE);
ADD_DEVICE_SERVICES(MBIM_CID_STK_ENVELOPE);
//return the size of the service element
return ((UINT32)pCidSupported - (UINT32)pBuf );
}
/*******************************************************************************\
* Function: addAuthServiceElements
* Description: Adds the supported AUTH CID to the Service Element
* Parameters: P_MBIM_DEVICE_SERVICE_ELEMENT pBuf - Pointer to the beggining of the service Element
*
* Returns: the size of the current element
\*******************************************************************************/
static int addAuthServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf)
{
UINT32 *pCidSupported;
Index2UUID((P_MBIM_UUID)&pBuf->deviceServiceId.uuid[0], UUID_AUTH_INDEX);
pBuf->dssPayload = 0;
pBuf->maxDssInstaces = 0;
pBuf->cidCount = 0; //This grows each time a command CID is added (See macro ADD_DEVICE_SERVICES)
pCidSupported = (UINT32 *)&pBuf->dataBuffer[0];
// ADD_DEVICE_SERVICES(MBIM_CID_AKA_AUTH);
// ADD_DEVICE_SERVICES(MBIM_CID_AKAP_AUTH);
// ADD_DEVICE_SERVICES(MBIM_CID_SIM_AUTH);
//return the size of the service element
return ((UINT32)pCidSupported - (UINT32)pBuf );
}
/*******************************************************************************\
* Function: addDssServiceElements
* Description: Adds the supported DSS CID to the Service Element
* Parameters: P_MBIM_DEVICE_SERVICE_ELEMENT pBuf - Pointer to the beggining of the service Element
*
* Returns: the size of the current element
\*******************************************************************************/
static int addDssServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf)
{
UINT32 *pCidSupported;
Index2UUID((P_MBIM_UUID)&pBuf->deviceServiceId.uuid[0], UUID_DSS_INDEX);
pBuf->dssPayload = 0;
pBuf->maxDssInstaces = 0;
pBuf->cidCount = 0; //This grows each time a command CID is added (See macro ADD_DEVICE_SERVICES)
pCidSupported = (UINT32 *)&pBuf->dataBuffer[0];
ADD_DEVICE_SERVICES(MBIM_CID_DSS_CONNECT);
//return the size of the service element
return ((UINT32)pCidSupported - (UINT32)pBuf );
}
/*******************************************************************************\
* Function: addBasicExtServiceElements
* Description: Adds the supported Basic connect extension CID to the Service Element
* Parameters: P_MBIM_DEVICE_SERVICE_ELEMENT pBuf - Pointer to the beggining of the service Element
*
* Returns: the size of the current element
\*******************************************************************************/
static int addBasicExtServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf)
{
UINT32 *pCidSupported;
Index2UUID((P_MBIM_UUID)&pBuf->deviceServiceId.uuid[0], UUID_BASIC_CONNECT_EXTENSIONS_INDEX);
pBuf->dssPayload = 0;
pBuf->maxDssInstaces = 0;
pBuf->cidCount = 0; //This grows each time a command CID is added (See macro ADD_DEVICE_SERVICES)
pCidSupported = (UINT32 *)&pBuf->dataBuffer[0];
ADD_DEVICE_SERVICES(MBIM_MS_PROVISIONED_CONTEXT_V2);
ADD_DEVICE_SERVICES(MBIM_CID_VERSION);
ADD_DEVICE_SERVICES(MBIM_CID_MS_MODEM_CONFIG);
ADD_DEVICE_SERVICES(MBIM_CID_MS_REGISTRATION_PARAMS);
//return the size of the service element
return ((UINT32)pCidSupported - (UINT32)pBuf );
}
static int addUICCServiceElements(P_MBIM_DEVICE_SERVICE_ELEMENT pBuf)
{
UINT32 *pCidSupported;
Index2UUID((P_MBIM_UUID)&pBuf->deviceServiceId.uuid[0], UUID_MS_UICC_LOW_LEVEL_INDEX);
pBuf->dssPayload = 0;
pBuf->maxDssInstaces = 0;
pBuf->cidCount = 0; //This grows each time a command CID is added (See macro ADD_DEVICE_SERVICES)
pCidSupported = (UINT32 *)&pBuf->dataBuffer[0];
ADD_DEVICE_SERVICES(MBIM_CID_MS_UICC_ATR);
ADD_DEVICE_SERVICES(MBIM_CID_MS_UICC_OPEN_CHANNEL);
ADD_DEVICE_SERVICES(MBIM_CID_MS_UICC_CLOSE_CHANNEL);
ADD_DEVICE_SERVICES(MBIM_CID_MS_UICC_APDU);
ADD_DEVICE_SERVICES(MBIM_CID_MS_UICC_TERMINAL_CAPABILITY);
ADD_DEVICE_SERVICES(MBIM_CID_MS_UICC_RESET);
//return the size of the service element
return ((UINT32)pCidSupported - (UINT32)pBuf );
}
/*******************************************************************************\
* Function: CID_DeviceCaps
* Description: MBIM_CID_DEVICE_CAPS (Chapter 10.5.1)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_DeviceCaps(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
//We only support Query for this command
if (commandType != MBIM_QUERY_COMMAND)
{
return CID_NotSupported(BASIC_CID_PARAMS_USAGE);
}
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
/////////////////////////////////////////
//Fill the static data
/////////////////////////////////////////
if (mbimDb.mbimNegVersion >= MBIMEx_v4)
{
P_MBIM_DEVICE_CAPS_INFO_V3 pCapsInfo = NULL;
pCapsInfo = (P_MBIM_DEVICE_CAPS_INFO_V3)buf;
pCapsInfo->deviceType = MBIMDeviceTypeRemovable;
pCapsInfo->cellularClass = MBIMCellularClassGsm;
pCapsInfo->voiceClass = MBIMVoiceClassNoVoice; //MBIMVoiceClassSimultaneousVoiceData;
pCapsInfo->simClass = MBIMSimClassSimRemovable;
pCapsInfo->dataClass = (MBIMDataClassLTE | MBIMDataClass5G);
pCapsInfo->smsCaps = MBIMSmsCapsNone;//(MBIMSmsCapsPduReceive | MBIMSmsCapsPduSend);
pCapsInfo->controlCaps = MBIMCtrlCapsRegManual;
pCapsInfo->DataSubClass = MBIMDataSubClass5GNR | MBIMDataSubClass5GENDC;
pCapsInfo->maxSessions = 1;
pCapsInfo->ExecutorIndex = 0;
pCapsInfo->WcdmaBandClass = 0;
}
else
{
P_MBIM_DEVICE_CAPS_INFO pCapsInfo = NULL;
pCapsInfo = (P_MBIM_DEVICE_CAPS_INFO)buf;
pCapsInfo->deviceType = MBIMDeviceTypeRemovable;
pCapsInfo->cellularClass = MBIMCellularClassGsm;
pCapsInfo->voiceClass = MBIMVoiceClassNoVoice; //MBIMVoiceClassSimultaneousVoiceData;
pCapsInfo->simClass = MBIMSimClassSimRemovable;
pCapsInfo->dataClass = (MBIMDataClassLTE | MBIMDataClass5G);
pCapsInfo->smsCaps = MBIMSmsCapsNone;//(MBIMSmsCapsPduReceive | MBIMSmsCapsPduSend);
pCapsInfo->controlCaps = MBIMCtrlCapsRegManual;
pCapsInfo->maxSessions = 1;//MAX_NUM_OF_SESSIONS; --> Adrian
pCapsInfo->CustomDataClassOffset = 0;
pCapsInfo->CustomDataClassSize = 0;
pCapsInfo->deviceIdOffset = offsetof(MBIM_DEVICE_CAPS_INFO, dataBuffer[0]);
}
#if defined (MBIM_MTIL)
MBIM_LOGD("Sending CGSN. Context = %d", mContext);
//send MTIL GET command
rc = MtilSendGetNoParams(mContext, MTIL_CODE_AT_CGSN_GET);
#else
rc = MbimTelRequestDeviceId(mContext);
#endif
return rc;
}
/*******************************************************************************\
* Function: CID_SubscriberReadyStatus
* Description: MBIM_CID_SUBSCRIBER_READY_STATUS (Chapter 10.5.2)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_SubscriberReadyStatus(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
//We only support Query for this command
if (commandType != MBIM_QUERY_COMMAND)
{
return CID_NotSupported(BASIC_CID_PARAMS_USAGE);
}
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
#if defined (MBIM_MTIL)
MtilSendGetNoParams(mContext, MTIL_CODE_AT_SIM_DEV_STATUS_GET);
#else
MbimTelRequestSimStatus(mContext);
#endif
return rc;
}
/*******************************************************************************\
* Function: CID_RadioState
* Description: MBIM_CID_RADIO_STATE (Chapter 10.5.3)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_RadioState(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
P_MBIM_SET_RADIO_STATE pSetRadioState = NULL;
P_MBIM_RADIO_STATE_INFO pRadioStateInfo = NULL;
#if defined (MBIM_MTIL)
char prop [255]; //Added for testing LTE configuration in 3G NW (Will open 3 pdp's as VZN)
#endif
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
//////////////////////////////////////////////////////
//Take care SET
/////////////////////////////////////////////////////
if (commandType == MBIM_SET_COMMAND)
{
pSetRadioState = (P_MBIM_SET_RADIO_STATE)infoBuf_p;
MBIM_LOGD("MBIM_CID_RADIO_STATE --> Set. RadioState = %d", pSetRadioState->RadioState);
pRadioStateInfo = (P_MBIM_RADIO_STATE_INFO)buf;
pRadioStateInfo->HwRadioState = MBIMRadioOn;
pRadioStateInfo->SwRadioState = (pSetRadioState->RadioState?1:4);
#if defined (MBIM_MTIL)
//If we are turning radio ON, check if we are in 3G Debug Mode
if (pSetRadioState->RadioState != 0)
{
//check if we are in test mode
property_get(MBIM_VZN_APN_RULE_PROPERTY, (const char *)prop, "replace");
if (strcmp(prop, MBIM_VZN_APN_RULE_3G_VZN_TEST) == 0)
{
//Send Simulated PLMN Indication
simulatePlmnInfoInd();
}
}
#endif
//save in context the requested configuration. (Need to free buffer in failure below)
ALLOCATE_CMD_BUFFER(mContext, mContext->cmd, infoBufLen);
memcpy( mContext->cmd, (char *)infoBuf_p, infoBufLen);
}
//////////////////////////////////////////////////////
//Take care QUERY
/////////////////////////////////////////////////////
else
{
MBIM_LOGD("MBIM_CID_RADIO_STATE --> Get");
}
#if defined (MBIM_MTIL)
rc = MtilSendGetNoParams(mContext, MTIL_CODE_AT_CFUN_GET);
#else
rc = MbimTelRequestRadioState(mContext);
#endif
return rc;
}
/*******************************************************************************\
* Function: CID_Pin
* Description: MBIM_CID_PIN(Chapter 10.5.4)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_Pin(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
P_MBIM_SET_PIN pPinSet = NULL;
char pin[16+1] = {0};
char newPin[16+1] = {0};
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, sizeof(MBIM_PIN_INFO));
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
//save in context the requested configuration
ALLOCATE_CMD_BUFFER(mContext, mContext->cmd, sizeof(MBIM_SET_PIN));
memset(mContext->cmd, 0, sizeof(MBIM_SET_PIN));
//////////////////////////////////////////////////////
//Take care of SET
/////////////////////////////////////////////////////
if (commandType == MBIM_SET_COMMAND)
{
pPinSet = (P_MBIM_SET_PIN)infoBuf_p;
memcpy(mContext->cmd, pPinSet, sizeof(MBIM_SET_PIN));
//Get Pin
copyUtf16ToStr(pin, infoBuf_p + pPinSet->pinOffset, pPinSet->pinSize);
pin[pPinSet->pinSize / 2] = 0;
copyUtf16ToStr(newPin, infoBuf_p + pPinSet->newPinOffset, pPinSet->newPinSize);
newPin[pPinSet->newPinSize / 2] = 0;
switch (pPinSet->pinOperation)
{
case MBIMPinOperationEnter:
// here we suppose that host knows current PIN state and performs correct operation
#if defined (MBIM_MTIL)
MtilSendCpinSet(mContext, pin, newPin);
#else
MbimTelRequestPinSet(mContext, pin, newPin);
#endif
break;
case MBIMPinOperationEnable:
#if defined (MBIM_MTIL)
MtilSendClckSet(mContext, MTIL_FAC_SC, 1, pin);
#else
MbimTelRequestPinEnable(mContext, pin);
#endif
break;
case MBIMPinOperationDisable:
#if defined (MBIM_MTIL)
MtilSendClckSet(mContext, MTIL_FAC_SC, 0, pin);
#else
MbimTelRequestPinDisable(mContext, pin);
#endif
break;
case MBIMPinOperationChange:
//Get the newPin number
copyUtf16ToStr(newPin, infoBuf_p + pPinSet->newPinOffset, pPinSet->newPinSize);
newPin[pPinSet->newPinSize / 2] = 0;
#if defined (MBIM_MTIL)
MtilSendCpwdSet(mContext, MTIL_FAC_SC, pin, newPin);
#else
MbimTelRequestPinModify(mContext, pin, newPin);
#endif
break;
}//end of switch
}
//////////////////////////////////////////////////////
//Take care of Query
/////////////////////////////////////////////////////
else
{
#if defined (MBIM_MTIL)
MtilSendGetNoParams(mContext, MTIL_CODE_AT_SIM_DEV_STATUS_GET);
#else
MbimTelRequestSimStatus(mContext);
#endif
}
return rc;
}
/*******************************************************************************\
* Function: CID_PinList
* Description: MBIM_CID_PIN_LIST(Chapter 10.5.5)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_PinList(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
//We only support Query for this command (Set is supported only if we support MBIM_CTRL_CAPS_MULTI_CARRIER).
if (commandType != MBIM_QUERY_COMMAND)
{
return CID_NotSupported(BASIC_CID_PARAMS_USAGE);
}
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
//Get CPIN information
#if defined (MBIM_MTIL)
MtilSendGetNoParams(mContext, MTIL_CODE_AT_SIM_DEV_STATUS_GET);
#else
MbimTelRequestPinList(mContext);
#endif
return rc;
}
/*******************************************************************************\
* Function: CID_HomeProvider
* Description: MBIM_CID_HOME_PROVIDER (Chapter 10.5.6)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_HomeProvider(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
P_MBIM_PROVIDER pMbimProvider = NULL;
UINT32 mbimStatus = MBIM_STATUS_SUCCESS;
//We only support Query for this command (Set is supported only if we support MBIM_CTRL_CAPS_MULTI_CARRIER).
if (commandType != MBIM_QUERY_COMMAND)
{
return CID_NotSupported(BASIC_CID_PARAMS_USAGE);
}
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
pMbimProvider = (P_MBIM_PROVIDER)buf;
pMbimProvider->errorRate = 0; //Set to Zero if we don't support MBIM_CTRL_CAPS_MULTI_CARRIER;
pMbimProvider->rssi = CID_SIGNAL_STRENGTH_RSSI_UNKOWN; //Set to Zero if we don't support MBIM_CTRL_CAPS_MULTI_CARRIER;
pMbimProvider->cellularClass = MBIMCellularClassGsm; //(set 1 as reference)Set to Zero if we don't support MBIM_CTRL_CAPS_MULTI_CARRIER;
if (mbimDb.HomeProviderIdSize == 0)
{
#if defined (MBIM_MTIL)
//Call the next AT command
MtilSendGetNoParams((void *)mContext, MTIL_CODE_AT_CIMI_GET);
#else
MbimTelRequestHomeProviderId(mContext);
#endif
}
else
{
//set the correct provider Id,with the correct size
pMbimProvider->providerIdState = MBIM_PROVIDER_STATE_HOME;
pMbimProvider->providerIdOffset = offsetof(MBIM_PROVIDER, dataBuffer[0]);
pMbimProvider->providerIdSize = copyStrToUtf16(((char *)pMbimProvider) + pMbimProvider->providerIdOffset, mbimDb.HomeProviderMccMnc, mbimDb.HomeProviderIdSize);
//Set provider ID name
pMbimProvider->providerNameOffset = (pMbimProvider->providerIdOffset + pMbimProvider->providerIdSize + 3)&~3; /* account for padding */
pMbimProvider->providerNameSize = copyStrToUtf16(((char *)pMbimProvider) + pMbimProvider->providerNameOffset, mbimDb.HomeProviderName, strlen(mbimDb.HomeProviderName));
//Add Zero termination (UTF-16)
/* Again, padding, and it should not affect the Size */
//memset((char *)pMbimProvider + pMbimProvider->providerNameOffset + pMbimProvider->providerNameSize, 0, 2);
//pMbimProvider->providerNameSize += 2;
if (mbimDb.sim.simReadyState == MBIMSubscriberReadyStateSimNotInserted)
mbimStatus = MBIM_STATUS_SIM_NOT_INSERTED;
else if (mbimDb.sim.simReadyState == MBIMSubscriberReadyStateBadSim)
mbimStatus = MBIM_STATUS_BAD_SIM;
//Send answer here until next AT command is implemented [TBD ADRIAN - Need to get provider name from SIM]
MbimSendCommandDone( mContext->hdr.transId,
mContext->hdr.uuidIndex,
mContext->hdr.cid,
mbimStatus,
ALIGN32(pMbimProvider->providerNameOffset+pMbimProvider->providerNameSize),
mContext->body );
MBIM_FREE_CONTEXT(mContext);
}
return rc;
}
/*******************************************************************************\
* Function: CID_PreferedProviders
* Description: MBIM_CID_PREFERRED_PROVIDERS (Chapter 10.5.7)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_PreferedProviders(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
//We only support Query for this command (Set is supported only if we support MBIM_CTRL_CAPS_MULTI_CARRIER).
if (commandType == MBIM_SET_COMMAND)
{
//send Error to Host
rc = MbimSendCommandDone(mContext->hdr.transId,
mContext->hdr.uuidIndex,
mContext->hdr.cid,
MBIM_STATUS_OPERATION_NOT_ALLOWED,
0, NULL);
MBIM_FREE_CONTEXT(mContext);
}
else
{
//Get prefered providers
#if defined (MBIM_MTIL)
MtilSendGetNoParams((void *)mContext, MTIL_CODE_AT_CPOL_GET);
#else
MbimTelRequestPreferredProviders(mContext);
#endif
}
return rc;
}
/*******************************************************************************\
* Function: CID_VisibleProviders
* Description: MBIM_CID_VISIBLE_PROVIDERS (Chapter 10.5.8)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_VisibleProviders(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
#if defined (MBIM_MTIL)
P_MBIM_VISIBLE_PROVIDERS_REQ pVisibleProvReq = NULL;
#endif
P_MBIM_PROVIDERS pMbimProviders = NULL;
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
//We only support Query for this command (Set is supported only if we support MBIM_CTRL_CAPS_MULTI_CARRIER).
if (commandType != MBIM_QUERY_COMMAND)
{
return CID_NotSupported(BASIC_CID_PARAMS_USAGE);
}
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
if (mbimDb.sim.simReadyState == MBIMSubscriberReadyStateSimNotInserted)
{
pMbimProviders = (P_MBIM_PROVIDERS)buf;
pMbimProviders->elementCount = 0;
//send Error to Host
MbimSendCommandDone( mContext->hdr.transId,
mContext->hdr.uuidIndex,
mContext->hdr.cid,
MBIM_STATUS_SIM_NOT_INSERTED,
sizeof(MBIM_RADIO_STATE_INFO),
mContext->body );
MBIM_FREE_CONTEXT(mContext);
}
else
{
//Pick up pointer to request
#if defined (MBIM_MTIL)
pVisibleProvReq = (P_MBIM_VISIBLE_PROVIDERS_REQ)infoBuf_p;
if (pVisibleProvReq->action == MBIMVisibleProvidersActionFullScan)
{
MtilSendGetNoParams((void *)mContext, MTIL_CODE_AT_COPS_OPT);
MBIM_LOGD("MBIM_CID_VISIBLE_PROVIDERS: CID_VisibleProviders Full scan");
}
else
{
MBIM_LOGD("MBIM_CID_VISIBLE_PROVIDERS: CID_VisibleProviders Prefered Scan");
//[TBD];
//MtilSendGetNoParams((void *)mContext, MTIL_CODE_AT_CPOL_OPT); //This return prefered Providers
MtilSendGetNoParams((void *)mContext, MTIL_CODE_AT_COPS_OPT); //[WorkAround] Adrian need to fix
//MBIM_FREE_CONTEXT(mContext);
}
#else
MbimTelRequestVisibleProviders(mContext);
MBIM_LOGD("MBIM_CID_VISIBLE_PROVIDERS: CID_VisibleProviders Full scan");
#endif
}
return rc;
}
/*******************************************************************************\
* Function: CID_RegisterState
* Description: MBIM_CID_REGISTER_STATE (Chapter 10.5.9)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_RegisterState(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
P_MBIM_SET_REGISTRATION_STATE pSetRegisterState = NULL;
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
//////////////////////////////////////////////////////
//Take care SET
/////////////////////////////////////////////////////
if (commandType == MBIM_SET_COMMAND)
{
char providerId[9] = {0};
int mode, accessTechnology;
MBIM_LOGD("CID_RegisterState - SET");
pSetRegisterState = (P_MBIM_SET_REGISTRATION_STATE)infoBuf_p;
if (pSetRegisterState->registerAction == MBIMRegisterActionManual)
{
mode = TEL_REG_MODE_MANUAL;
copyUtf16ToStr(providerId, (infoBuf_p + pSetRegisterState->providerIdOffset), MIN(pSetRegisterState->providerIdSize,16));
}
else
{
mode = TEL_REG_MODE_AUTO;
}
accessTechnology = getRegisterTech(pSetRegisterState->dataClass);
MBIM_LOGD("CID_RegisterState - Mode = %d, providerId = %s, accessTechnology = %d",mode, providerId, accessTechnology );
//Send Command to server
#if defined (MBIM_MTIL)
mtilSendCopsSet((void *)mContext, mode, accessTechnology, providerId);
#else
MbimTelRequestNetworkSelection(mContext, mode, accessTechnology, providerId);
#endif
}
//////////////////////////////////////////////////////
//Take care Get
/////////////////////////////////////////////////////
else
{
MBIM_LOGD("CID_RegisterState - GET");
#if defined (MBIM_MTIL)
//Call the next AT command
MtilSendGetNoParams((void *)mContext, MTIL_CODE_AT_CGREG_GET);
#else
MbimTelRequestRegistrationStatus(mContext);
#endif
}
return rc;
}
/*******************************************************************************\
* Function: CID_PacketService
* Description: MBIM_CID_PACKET_SERVICE (Chapter 10.5.10)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_PacketService(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
P_MBIM_SET_PACKET_SERVICE pSetPacketService = NULL;
#if defined (MBIM_MTIL)
UINT32 action;
#endif
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
//ToDo - find alternative to packet service set and query
//////////////////////////////////////////////////////
//Take care SET
/////////////////////////////////////////////////////
if (commandType == MBIM_SET_COMMAND)
{
pSetPacketService = (P_MBIM_SET_PACKET_SERVICE)infoBuf_p;
MBIM_LOGD("MBIM_CID_PACKET_SERVICE: SET. Action = %d", pSetPacketService->packetServiceAction);
#if defined (MBIM_MTIL)
//Need to send command to Attach or detach
if (pSetPacketService->packetServiceAction == MBIMPacketServiceActionAttach)
action = 1;
else
action = 0;
MtilSendAtCgattSet((void *)mContext, action);
#else
MbimTelRequestPacketService(mContext);
#endif
}
else
{
MBIM_LOGD("MBIM_CID_PACKET_SERVICE: GET");
#if defined (MBIM_MTIL)
//Call the next AT command
MtilSendGetNoParams((void *)mContext, MTIL_CODE_AT_CGATT_GET);
#else
MbimTelRequestPacketServiceStatus(mContext);
#endif
}
return rc;
}
/*******************************************************************************\
* Function: CID_SignalState
* Description: MBIM_CID_SIGNAL_STATE (Chapter 10.5.11)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_SignalState(BASIC_CID_PARAMS)
{
P_MBIM_SET_SIGNAL_STATE pSetSignalState = NULL;
MBIM_SIGNAL_STATE_INFO signalStateInfo;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
char *buf = NULL;
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
//If we received command we update the configuration
if (commandType == MBIM_SET_COMMAND)
{
signalStateInfo.signalStrengthInterval = (mbimDb.signalState.signalStrengthInterval?mbimDb.signalState.signalStrengthInterval:1);
signalStateInfo.RssiThreshold = 0;//mbimDb.signalState.rssiThreshold;
signalStateInfo.errorRateThreshold = CID_SIGNAL_STRENGTH_ERROR_RATE_THR_DONT_CARE;
signalStateInfo.rssi = mbimDb.signalState.rssiDb;
signalStateInfo.errorRate = CID_SIGNAL_STRENGTH_ERROR_RATE_UNKOWN;//CodeBer2MbimCodedValue(mbimDb.signalState.errorRate);
pSetSignalState = (P_MBIM_SET_SIGNAL_STATE)infoBuf_p;
mbimDb.signalState.signalStrengthInterval = pSetSignalState->signalStrengthInterval;
mbimDb.signalState.rssiThreshold = pSetSignalState->rssiThreshold;
mbimDb.signalState.errorRateThreshold = pSetSignalState->errorRateThreshold;
//Send command done to host
MbimSendCommandDone(transactionId, UUID_BASIC_CONNECT_INDEX, cid, MBIM_STATUS_SUCCESS, sizeof(MBIM_SIGNAL_STATE_INFO), (char *)&signalStateInfo);
}
else
{
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
MbimTelRequestSignalStrength(mContext);
}
return 0;
}
/*******************************************************************************\
* Function: CID_Connect
* Description: MBIM_CID_CONNECT (Chapter 10.5.12)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_Connect(BASIC_CID_PARAMS)
{
int rc = MBIM_OK;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
P_MBIM_SET_CONNECT pSetConnect = NULL;
P_MBIM_CONNECT_INFO connectInfoRsp;
int mbimStatus = MBIM_STATUS_SUCCESS;
//////////////////////////////////////////////////////
//Take care of SET command
/////////////////////////////////////////////////////
if (commandType == MBIM_SET_COMMAND)
{
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
//save in context the requested configuration. (Need to free buffer in failure below)
ALLOCATE_CMD_BUFFER(mContext, mContext->cmd, infoBufLen);
memcpy( mContext->cmd, (char *)infoBuf_p, infoBufLen);
//BS: Turn off CID_CONNECT unsolicitate indication until COMMAND_DONE
disableUnsolCidConnect = TRUE;
MBIM_LOGD("MBIM_CID_CONNECT: disableUnsolCidConnect = %d", disableUnsolCidConnect);
#if defined (MBIM_MTIL)
//Send Get
MtilSendGetNoParams((void *)mContext, MTIL_CODE_AT_CGDCONT_GET);
#else
MbimTelRequestSetupDataCall(mContext);
#endif
}
//////////////////////////////////////////////////////
//Take care of GET command
/////////////////////////////////////////////////////
else
{
P_MBIM_CONNECT_QUERY_INFO_EX3 pQuery = NULL;
int len = 0;
int sessionId = 0;
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
connectInfoRsp = (P_MBIM_CONNECT_INFO)mContext->body;
if (mbimDb.mbimNegVersion >= MBIMEx_v3)
{
pQuery = (P_MBIM_CONNECT_QUERY_INFO_EX3)infoBuf_p;
sessionId = pQuery->SessionId;
len = offsetof(MBIM_CONNECT_INFO, dataBuffer);
}
else
{
pSetConnect = (P_MBIM_SET_CONNECT)infoBuf_p;
sessionId = pSetConnect->sessionId;
len = sizeof(MBIM_CONNECT_INFO_V1);
}
if (sessionId < MAX_NUM_OF_SESSIONS)
{
MBIM_LOGD("MBIM_CID_CONNECT: Session Id: %d, Cid = %d", sessionId, mbimDb.session[sessionId].cid);
if (mbimDb.session[sessionId].cid == 0)
{
memset(connectInfoRsp, 0, sizeof(MBIM_CONNECT_INFO));
connectInfoRsp->sessionId = sessionId;
connectInfoRsp->activationState = MBIMActivationStateDeactivated;
connectInfoRsp->ipType = MBIMContextIPTypeIPv4;
connectInfoRsp->nwError = CID_CONNECT_MBIM_STATUS_SUCCESS;
memcpy( (char *)connectInfoRsp->contextType.uuid, MBIMContextTypeNone, sizeof(MBIM_UUID));
}
else
{
connectInfoRsp->sessionId = sessionId;
MBIM_LOGD("MBIM_CID_CONNECT: Session Id: %d, Activation State = %d", sessionId, mbimDb.session[sessionId].sessionState);
connectInfoRsp->activationState = mbimDb.session[sessionId].sessionState;
MBIM_LOGD("MBIM_CID_CONNECT: Session Id: %d, Voice Call State = %d", sessionId, mbimDb.session[sessionId].voiceCallState);
connectInfoRsp->voiceCallState = mbimDb.session[sessionId].voiceCallState;
MBIM_LOGD("MBIM_CID_CONNECT: Session Id: %d, Ip type = %d", sessionId, mbimDb.session[sessionId].ipType);
connectInfoRsp->ipType = mbimDb.session[sessionId].ipType;
connectInfoRsp->ipType = MBIMContextIPTypeIPv4; //adrian debug
memcpy( (char *)connectInfoRsp->contextType.uuid, (char *)&mbimDb.session[sessionId].contextType, sizeof(MBIM_UUID));
connectInfoRsp->nwError = CID_CONNECT_MBIM_STATUS_SUCCESS;
mbimDb.internetSessionId = sessionId;
}
if (mbimDb.mbimNegVersion >= MBIMEx_v3)
{
if (mbimDb.session[sessionId].cid == 0)
{
connectInfoRsp->AccessMedia = MBIMAccessMediaTypeNone;
len += mbim_tlv_new((UINT8 *)connectInfoRsp + len, MBIM_TLV_TYPE_WCHAR_STR, NULL, 0);
}
else
{
connectInfoRsp->AccessMedia = MBIMAccessMediaType3GPP;
len += mbim_tlv_new_str((UINT8 *)connectInfoRsp + len, (UINT8 *)mbimDb.session[sessionId].APN, strlen(mbimDb.session[sessionId].APN));
}
}
}
else
{
memset((char *)connectInfoRsp, 0, sizeof(MBIM_CONNECT_INFO));
connectInfoRsp->sessionId = sessionId;
connectInfoRsp->nwError = 0;
mbimStatus = (MBIM_STATUS_CODE_ENUM)CID_CONNECT_MBIM_STATUS_MAX_ACTIVATED_CONTEXTS;
}
//if (mbimDb.sim.simReadyState == MBIMSubscriberReadyStateSimNotInserted)
// mbimStatus = MBIM_STATUS_SIM_NOT_INSERTED;
//Send reponse to host
MbimSendCommandDone(transactionId, UUID_BASIC_CONNECT_INDEX, cid, mbimStatus, len, (char *)mContext->body);
MBIM_FREE_CONTEXT(mContext);
}
return rc;
}
/*******************************************************************************\
* Function: CID_ProvisionedContexts
* Description: MBIM_CID_PROVISIONED_CONTEXTS(Chapter 10.5.13)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_ProvisionedContexts(BASIC_CID_PARAMS)
{
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
int rc = MBIM_STATUS_SUCCESS;
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
MBIM_LOGD("MBIM_CID_PROVISIONED_CONTEXTS:commandType = %d", commandType);
//save in context the requested configuration. (Need to free buffer in failure below)
ALLOCATE_CMD_BUFFER(mContext, mContext->cmd, infoBufLen);
memcpy( mContext->cmd, (char *)infoBuf_p, infoBufLen);
#if defined (MBIM_MTIL)
//Send Get
MtilSendGetNoParams((void *)mContext, MTIL_CODE_AT_CGDCONT_GET);
#else
MbimTelRequestDataCallList((void *)mContext);
#endif
return rc;
}
int CID_ServiceActivation(BASIC_CID_PARAMS)
{
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
return 0;
}
/*******************************************************************************\
* Function: CID_IpConfiguration
* Description: MBIM_CID_IP_CONFIGURATION(Chapter 10.5.20)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_IpConfiguration(BASIC_CID_PARAMS)
{
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
P_MBIM_IP_CONFIGURATION_INFO pIpConfigInfoCmd = NULL;
int rc = MBIM_STATUS_SUCCESS;
#if 0
P_MBIM_IPV4_ELEMENT pIpv4Element = NULL;
P_MBIM_IPV4_ADDRESS pIpv4Address = NULL;
int dataLen = 0;
P_MBIM_IP_CONFIGURATION_INFO pIpConfigInfoRsp = NULL;
#endif
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
//////////////////////////////////////////////////////
//We dont support SET command
/////////////////////////////////////////////////////
if (commandType != MBIM_QUERY_COMMAND)
{
return CID_NotSupported(BASIC_CID_PARAMS_USAGE);
}
//////////////////////////////////////////////////////
//Take care of QUERY command
/////////////////////////////////////////////////////
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
pIpConfigInfoCmd = (P_MBIM_IP_CONFIGURATION_INFO)infoBuf_p;
///////////////////////////////////////
//check for errors
///////////////////////////////////////
if (pIpConfigInfoCmd->sessionId > MAX_NUM_OF_SESSIONS)
{
MBIM_LOGE("IP Configuration: Received invalid Session ID = %d", pIpConfigInfoCmd->sessionId);
rc = MBIM_STATUS_CONTEXT_NOT_ACTIVATED;
}
if (rc != MBIM_STATUS_SUCCESS)
{
MbimSendFunctionErrorMsg(transactionId, rc);
MBIM_FREE_CONTEXT(mContext);
return 0;
}
MbimTelRequestIpConfig(mContext);
return rc;
}
/*******************************************************************************\
* Function: MbimSetDeviceServiceSubscribeList
* Description: ToDo - move to static functions....
* Parameters:
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
static void MbimSetDeviceServiceSubscribeList (P_MBIM_DEVICE_SERVICE_SUBSCRIBE_LIST pDevServSubsList)
{
P_MBIM_EVENT_ENTRY pMbimServiceElement;
UINT32 elementIdx, elementCount;
int serviceIdx;
UINT32 cidCount,cidIdx;
char filterArrayString1 [64];
char filterArrayString [256];
char *pFilterArray;
UINT32 deviceServiceSubscribeRefListAddr;
elementCount = pDevServSubsList->elementCount;
MBIM_LOGD("%s: element count = %d", __FUNCTION__, elementCount);
if (elementCount > 0)
{
deviceServiceSubscribeRefListAddr = (UINT32)&pDevServSubsList->deviceServiceSubscribeRefList;
pMbimServiceElement = (P_MBIM_EVENT_ENTRY)(deviceServiceSubscribeRefListAddr + 8 * elementCount);
for (elementIdx = 0 ; elementIdx < elementCount ; elementIdx++)
{
serviceIdx = UUID2Index(&pMbimServiceElement->deviceServiceId);
MBIM_LOGD("%s: serviceIdx = %d", __FUNCTION__, serviceIdx);
if (cidsFilterArray[serviceIdx][0] == 0)
{
pMbimServiceElement = (P_MBIM_EVENT_ENTRY)((char *)pMbimServiceElement +
sizeof(pMbimServiceElement->deviceServiceId) +
sizeof(pMbimServiceElement->cidCount) +
(pMbimServiceElement->cidCount * sizeof(*pMbimServiceElement->dataBuffer)));
continue;
}
pFilterArray = (char *)cidsFilterArray[serviceIdx][0];
cidCount = pMbimServiceElement->cidCount;
MBIM_LOGD("%s: cidCount = %d, max = %d", __FUNCTION__, cidCount, cidsFilterArray[serviceIdx][1]);
if ((serviceIdx >= 0) && (cidCount > 0) && (cidCount < cidsFilterArray[serviceIdx][1]))
{
memset((void *)pFilterArray, 0, cidsFilterArray[serviceIdx][1]);
for (cidIdx = 0; cidIdx < cidCount; cidIdx++)
{
pFilterArray[pMbimServiceElement->dataBuffer[cidIdx]] = 1;
}
//Debug
sprintf (filterArrayString1, "service %d filter: ", serviceIdx);
for (cidIdx = 0; cidIdx < cidsFilterArray[serviceIdx][1]; cidIdx++)
{
sprintf (filterArrayString, "%s %u=%u ", filterArrayString1,
(unsigned char)cidIdx, (unsigned char)pFilterArray[cidIdx]);
}
MBIM_LOGD("%s: %s", __FUNCTION__, filterArrayString);
}
pMbimServiceElement = (P_MBIM_EVENT_ENTRY)((char *)pMbimServiceElement +
sizeof(pMbimServiceElement->deviceServiceId) +
sizeof(pMbimServiceElement->cidCount) +
(pMbimServiceElement->cidCount * sizeof(*pMbimServiceElement->dataBuffer)));
}
}
}
/*******************************************************************************\
* Function: CID_DeviceServicesSubscribeList
* Description: MBIM_CID_DEVICE_SERVICE_SUBSCRIBE_LIST (Chapter 10.5.30)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_DeviceServicesSubscribeList(BASIC_CID_PARAMS)
{
int rc = MBIM_STATUS_SUCCESS;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
P_MBIM_DEVICE_SERVICE_SUBSCRIBE_LIST pDevServSubsList = NULL;
//////////////////////////////////////////////////////
//GET is not supported by this command
/////////////////////////////////////////////////////
if (commandType != MBIM_SET_COMMAND)
{
return CID_NotSupported(BASIC_CID_PARAMS_USAGE);
}
//////////////////////////////////////////////////////
//SET which Indications we want to receive
/////////////////////////////////////////////////////
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
//Copy request to context (we return the same request we received for now).
memcpy(buf, infoBuf_p, infoBufLen);
//MtilSendInden(mContext, TRUE);
pDevServSubsList = (P_MBIM_DEVICE_SERVICE_SUBSCRIBE_LIST)infoBuf_p;
MbimSetDeviceServiceSubscribeList(pDevServSubsList);
MbimSendCommandDone(transactionId, UUID_BASIC_CONNECT_INDEX, cid, MBIM_STATUS_SUCCESS, infoBufLen, (char *)pDevServSubsList);
MBIM_FREE_CONTEXT(mContext);
return rc;
}
int CID_PacketStatistics(BASIC_CID_PARAMS)
{
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
return 0;
}
/*******************************************************************************\
* Function: CID_NetworkIdleHint
* Description: MBIM_CID_NETWORK_IDLE_HINT (Chapter 10.5.35)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_NetworkIdleHint(BASIC_CID_PARAMS)
{
int rc = MBIM_STATUS_SUCCESS;
MBIM_NETWORK_IDLE_HINT networkIdleHint;
P_MBIM_NETWORK_IDLE_HINT pNetworkIdleHint;
MBIM_BASIC_UNUSEDPARAM();
if (commandType == MBIM_SET_COMMAND)
{
//Pick up pointer to buffer
pNetworkIdleHint = (P_MBIM_NETWORK_IDLE_HINT)infoBuf_p;
#if 0
if (pNetworkIdleHint->networkIdleHintState == MBIMNetworkIdleHintEnabled)
; //Check if we can enter Fast dormancy mode
else
; //Wake up
#endif
//[TBD what to do --> Need to talk to power people] For now we just return the value
MbimSendCommandDone( transactionId,
UUID_BASIC_CONNECT_INDEX,
cid,
MBIM_STATUS_SUCCESS,
sizeof(MBIM_NETWORK_IDLE_HINT),
(char *)pNetworkIdleHint);
}
else
{
//[TBD] We need to query the fast dormancy
networkIdleHint.networkIdleHintState = MBIMNetworkIdleHintDisabled;
MbimSendCommandDone( transactionId,
UUID_BASIC_CONNECT_INDEX,
cid,
MBIM_STATUS_SUCCESS,
sizeof(MBIM_NETWORK_IDLE_HINT),
(char *)&networkIdleHint);
}
return rc;
}
/*******************************************************************************\
* Function: CID_EmergencyMode
* Description: MBIM_CID_EMERGENCY_MODE (Chapter 10.5.36)
* Parameters: BASIC_CID_PARAMS - See description at the start of file
*
* Returns: 0=OK, <0=Error Code
\*******************************************************************************/
int CID_EmergencyMode(BASIC_CID_PARAMS)
{
int rc = MBIM_STATUS_SUCCESS;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
P_MBIM_EMERGENCY_MODE_INFO pEmergencyMode = NULL;
UINT32 mbimStatus = MBIM_STATUS_SUCCESS;
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
//////////////////////////////////////////////////////
//We dont support SET command
/////////////////////////////////////////////////////
if (commandType != MBIM_QUERY_COMMAND)
{
return CID_NotSupported(BASIC_CID_PARAMS_USAGE);
}
#ifdef DUMMY
{
static int first = 0;
if (!first)
{
first = 1;
sendMbimSmsConfigurationInd();
}
}
#endif
//Allocate buffer for response
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
//Creat the context for this command
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
//Pick up pointer to buffer
pEmergencyMode = (P_MBIM_EMERGENCY_MODE_INFO)buf;
pEmergencyMode->EmergencyMode = MBIMEmergencyModeOff;
if (mbimDb.sim.simReadyState == MBIMSubscriberReadyStateSimNotInserted)
mbimStatus = MBIM_STATUS_SIM_NOT_INSERTED;
MbimSendCommandDone( transactionId,
UUID_BASIC_CONNECT_INDEX,
cid,
mbimStatus,
sizeof(MBIM_EMERGENCY_MODE_INFO),
(char *)pEmergencyMode);
MBIM_FREE_CONTEXT(mContext);
return rc;
}
int CID_IpPacketFilters(BASIC_CID_PARAMS)
{
int rc = MBIM_STATUS_SUCCESS;
char *buf = NULL;
P_MBIM_MESSAGE_CONTEXT mContext = NULL;
P_MBIM_IP_PACKET_FILTER pIpFilter;
//MBIM_BASIC_UNUSEDPARAM();
if (commandType == MBIM_SET_COMMAND)
{
pIpFilter = (P_MBIM_IP_PACKET_FILTER)infoBuf_p;
MbimSendCommandDone( transactionId,
UUID_BASIC_CONNECT_INDEX,
cid,
MBIM_STATUS_SUCCESS,
infoBufLen,
(char *)pIpFilter);
}
else
{
ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
CREATE_BASIC_CONNECT_CONTEXT(mContext, buf);
pIpFilter = (P_MBIM_IP_PACKET_FILTER)buf;
pIpFilter->packetFilterCount = 0;
MbimSendCommandDone( transactionId,
UUID_BASIC_CONNECT_INDEX,
cid,
MBIM_STATUS_SUCCESS,
sizeof(MBIM_IP_PACKET_FILTER),
(char *)pIpFilter);
MBIM_FREE_CONTEXT(mContext);
}
return rc;
}
int CID_MultiCarrierProviders(BASIC_CID_PARAMS)
{
//Added for compilation uof unused parameters on Codeline
MBIM_BASIC_UNUSEDPARAM();
return 0;
}