marvell/services/mbim/mbim_ril_ind.c

/******************************************************************************
*(C) Copyright 2014 Marvell International Ltd.
* All Rights Reserved
******************************************************************************/
/* -------------------------------------------------------------------------------------------------------------------
 *
 *  Filename: mbim_ril_ind.c
 *
 *  Authors:  Boaz Sommer
 *
 *  Description: MBIM RIL indications interface
 *
 *  HISTORY:
 *
 *   Nov 23, 2014 - Initial Version
 *
 *  Notes:
 *
 ******************************************************************************/

#define LOG_TAG	"MBIM"

/******************************************************************************
 *   Include files
 ******************************************************************************/
#include "mbim_types.h"
#include "mbim_protocol.h"
#include "mbim_basic.h"
#include "mbim_sms.h"
#include "mbim_util.h"
#include "mbim_ussd.h"
#include "mbim_ril.h"
#include "mbim_ril_ind.h"
#include "mbim_ubus.h"

#include "rilutil.h"
#include "ril_ext.h"

extern P_MBIM_MESSAGE_CONTEXT	g_setupdatacallcontext;

#define DEFAULT_CONTEXT_ALLOC_SIZE	(4000)

#define CREATE_INDICATION_CONTEXT(pContext, mBuf, mCid, uuidIdx)												\
				MBIM_LOGD("MBIM INDICATION Cid = %d, uuidIndex = %d", mCid, uuidIdx );							\
				pContext = (P_MBIM_MESSAGE_CONTEXT)MBIM_MALLOC(sizeof(MBIM_MESSAGE_CONTEXT));					\
				if (pContext != NULL) { 																		\
					pContext->hdr.cid		= mCid;																\
					pContext->hdr.transId	= 0;																\
					pContext->hdr.uuidIndex = uuidIdx; 															\
					pContext->hdr.indication= MBIM_NOTIFICATION;												\
					pContext->body			= mBuf; 															\
					pContext->cmd			= NULL;																\
				}																								\
				else {																							\
					if (mBuf != NULL) 																			\
						MBIM_FREE(mBuf);																		\
					MBIM_LOGE("BASIC UUID: %d OUT OF MEMORY CID %d", uuidIdx, mCid);							\
					return;																						\
				}



#define ALLOCATE_RESPONSE_BUFFER(mBuf_p, mSize) 					\
	mBuf_p = (char *)MBIM_MALLOC(mSize);							\
	if (mBuf_p == NULL) {											\
		MBIM_LOGE("INDICATIONS: OUT OF MEMORY");					\
		return; 													\
	}																\
	else {															\
		memset(mBuf_p, 0, mSize);									\
	}




UINT32	MbimRilGetAvailableDataClass	(RIL_RadioTechnology rilRadioTech)
{
	UINT32	ret;

	switch (rilRadioTech)
	{
		case	RADIO_TECH_UNKNOWN:
			ret	=	MBIMDataClassNone;
			break;

		case	RADIO_TECH_GPRS:
			ret	=	MBIMDataClassGPRS;
			break;

		case	RADIO_TECH_EDGE:
			ret	=	MBIMDataClassEDGE;
			break;

		case	RADIO_TECH_UMTS:
			ret	=	MBIMDataClassUMTS;
			break;

		case	RADIO_TECH_HSDPA:
			ret	=	MBIMDataClassHSDPA;
			break;

		case	RADIO_TECH_HSUPA:
			ret =	MBIMDataClassHSUPA;
			break;

		case	RADIO_TECH_LTE:
		case	RADIO_TECH_LTEP:
			ret	=	MBIMDataClassLTE;
			break;

		case	RADIO_TECH_EVDO_0:
			ret	=	MBIMDataClass1XEVDO;
			break;

		case	RADIO_TECH_EVDO_A:
			ret	=	MBIMDataClass1XEVDORevA;
			break;

		case	RADIO_TECH_EVDO_B:
			ret	=	MBIMDataClass1XEVDORevB;
			break;

        case     RADIO_TECH_EUTRAN_TO_5GCN:
        case     RADIO_TECH_NR_TO_5GCN:
        	ret	=	MBIMDataSubClass5GNR;
			break;

		case		RADIO_TECH_GSM:
		default:
			ret	=	MBIMDataClassCustom;
			break;
	}

	return	ret;
}

static void	MbimRilHandleSimStatusChangedInd	(void)
{
	char						*buf			= NULL;
	P_MBIM_MESSAGE_CONTEXT		mContext		= NULL;

	////////////////////////////////////////////////////////////
	// Send UUID_SUBSCRIBER_READY_STATUS indication
	////////////////////////////////////////////////////////////
	ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
	CREATE_INDICATION_CONTEXT(mContext, buf, UUID_SUBSCRIBER_READY_STATUS, UUID_BASIC_CONNECT_INDEX);

	MbimRilRequestSimStatus((void *)mContext);
}

static void	MbimRilHandleRadioStateChangedInd	(void *data, int len)
{
	UNUSEDPARAM(len);
	char							*buf			= NULL;
	P_MBIM_MESSAGE_CONTEXT			pContext		= NULL;
	P_MBIM_RADIO_STATE_INFO 		pRadioStateInfo	= NULL;
	RIL_RadioState					*rilRadioState;

	rilRadioState	=	(RIL_RadioState *)data;
	if (rilRadioState)
	{
		mbimDb.RadioState	=	(*rilRadioState == RADIO_STATE_OFF)?MBIMRadioOff:MBIMRadioOn;
		MBIM_LOGD("%s: rilRadioState = %d", __FUNCTION__, (int)(*rilRadioState));

		////////////////////////////////////////////////////////////
		// Send UUID_SUBSCRIBER_READY_STATUS indication
		////////////////////////////////////////////////////////////
		ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
		CREATE_INDICATION_CONTEXT(pContext, buf, UUID_RADIO_STATE, UUID_BASIC_CONNECT_INDEX);

		pRadioStateInfo	=	(P_MBIM_RADIO_STATE_INFO)pContext->body;
		pRadioStateInfo->HwRadioState	=	MBIMRadioOn;
		pRadioStateInfo->SwRadioState	=	mbimDb.RadioState;

		MbimSendIndicateStatusMsg(  pContext->hdr.uuidIndex, pContext->hdr.cid,
									sizeof(MBIM_RADIO_STATE_INFO), pContext->body );

		MBIM_FREE_CONTEXT(pContext);

	}

}

static void	MbimRilHandleVoiceNetworkChangedInd	(void)
{
	char						*buf			= NULL;
	P_MBIM_MESSAGE_CONTEXT		mContext		= NULL;

	////////////////////////////////////////////////////////////
	// Send UUID_SUBSCRIBER_READY_STATUS indication
	////////////////////////////////////////////////////////////
	ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
	CREATE_INDICATION_CONTEXT(mContext, buf, UUID_REGISTER_STATE, UUID_BASIC_CONNECT_INDEX);

	MbimTelRequestRegistrationStatus(mContext);
}

static void	MbimRilHandleVoiceRadioTechChangedInd	(void *data, int len)
{
	UNUSEDPARAM(len);
	RIL_RadioTechnology	*rilRadioTech	=	(RIL_RadioTechnology *)data;

	if (rilRadioTech)
	{
		mbimDb.mbimRegisterTech	=	MbimRilGetAvailableDataClass(*rilRadioTech);
	}
}

static void	MbimRilHandleSignalStrengthInd	(void *data, int len)
{
	UNUSEDPARAM(len);
	char						*buf			= NULL;
	P_MBIM_MESSAGE_CONTEXT		pContext		= NULL;
	P_MBIM_SIGNAL_STATE_INFO	signalStateInfo;

	RIL_SignalStrength_v6		*rilSignalStrength;

	////////////////////////////////////////////////////////////
	// Send UUID_SUBSCRIBER_READY_STATUS indication
	////////////////////////////////////////////////////////////
	ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
	CREATE_INDICATION_CONTEXT(pContext, buf, UUID_SIGNAL_STATE, UUID_BASIC_CONNECT_INDEX);
	signalStateInfo	=	(P_MBIM_SIGNAL_STATE_INFO)buf;

	if	(data == NULL)
	{
		//In case of receiveg this command we always send reponse (for Query and for Set)
		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);
	}
	else
	{
		rilSignalStrength	=	(RIL_SignalStrength_v6 *)data;

		MBIM_LOGE("Signal strength notification, stregth = (%d, %d)",
				  rilSignalStrength->GW_SignalStrength.signalStrength,
				  rilSignalStrength->LTE_SignalStrength.signalStrength);

		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					= rilSignalStrength->LTE_SignalStrength.rsrq;//rilSignalStrength->GW_SignalStrength.signalStrength;
		signalStateInfo->errorRate				= rilSignalStrength->GW_SignalStrength.bitErrorRate;
	}

	MbimSendIndicateStatusMsg(  pContext->hdr.uuidIndex, pContext->hdr.cid,
								sizeof(MBIM_SIGNAL_STATE_INFO), pContext->body );


}

#if defined DEPRICATED_REQUEST_DATA_LIST
static	void MbimRilSendIpConfigurationInd(int sessionId)
{
	char							*buf;
	P_MBIM_IP_CONFIGURATION_INFO	pIpConfigInfoRsp	= NULL;
	P_MBIM_IPV4_ELEMENT				pIpv4Element		= NULL;
	P_MBIM_IPV4_ADDRESS				pIpv4Address		= NULL;
	int								dataLen				= 0;

	ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
	pIpConfigInfoRsp = (P_MBIM_IP_CONFIGURATION_INFO)buf;


	///////////////////////////////////////
	//No error, process the command
	///////////////////////////////////////
	memset((char *)pIpConfigInfoRsp, 0, sizeof(MBIM_IP_CONFIGURATION_INFO));
	pIpConfigInfoRsp->sessionId = sessionId;

	if (1/*mbimDb.loopbackEnabled == FALSE*/)
	{
		//This is provisory
		/////////////////////////////
		//Set available (For Hostless mode) -->  Need to add if
		/////////////////////////////
		pIpConfigInfoRsp->ipPv4ConfigurationAvailable.intRepresentation = 0xffffffff;

		pIpConfigInfoRsp->iPv4AddressCount 			= 1;
		pIpConfigInfoRsp->iPv4AddressOffset 		= offsetof(MBIM_IP_CONFIGURATION_INFO, dataBuffer[0]);
		pIpv4Element = (P_MBIM_IPV4_ELEMENT)((char *)pIpConfigInfoRsp + pIpConfigInfoRsp->iPv4AddressOffset);
		pIpv4Element->onLinkPrefixLength 			= IP_CONFIG_MASK_LEN;
		*((UINT32 *)(&pIpv4Element->ipv4Address))	= IP_CONFIG_IPV4_ADDRESS_BASE + (mbimDb.session[sessionId].cid << 24);

		pIpConfigInfoRsp->iPv4GatewayOffset			= pIpConfigInfoRsp->iPv4AddressOffset + sizeof(MBIM_IPV4_ELEMENT)*pIpConfigInfoRsp->iPv4AddressCount;
		pIpv4Address = (P_MBIM_IPV4_ADDRESS)((char *)pIpConfigInfoRsp + pIpConfigInfoRsp->iPv4GatewayOffset);
		*((UINT32 *)pIpv4Address) 					=  IP_CONFIG_GATEWAY;

		pIpConfigInfoRsp->iPv4DnsServerCount		= 1;
		pIpConfigInfoRsp->iPv4DnsServerOffset		= pIpConfigInfoRsp->iPv4GatewayOffset + sizeof(MBIM_IPV4_ADDRESS);
		pIpv4Address 								= (P_MBIM_IPV4_ADDRESS)((char *)pIpConfigInfoRsp + pIpConfigInfoRsp->iPv4DnsServerOffset);
		*((UINT32 *)pIpv4Address)					= 0x08080808;
		pIpConfigInfoRsp->iPv4Mtu					= 1400;

		dataLen	= pIpConfigInfoRsp->iPv4DnsServerOffset + pIpConfigInfoRsp->iPv4DnsServerCount*sizeof(MBIM_IPV4_ADDRESS);
	}
	else
	{
		MBIM_LOGD("Loopback, Setting no IP as requested in SPEC");
		pIpConfigInfoRsp->ipPv4ConfigurationAvailable.intRepresentation = 0;
		pIpConfigInfoRsp->iPv4AddressCount 								= 0;
	}


	//Send Indication to host
	MbimSendIndicateStatusMsg(	UUID_BASIC_CONNECT_INDEX,
								UUID_IP_CONFIGURATION,
								dataLen,
								(char *)pIpConfigInfoRsp);

#if 0
	//Set routing tables
	if (mbimDb.loopbackEnabled == FALSE)
		setRoutingTable(mbimDb.session[pIpConfigInfoRsp->sessionId].cid);
#endif

	//Free the allocated buffer
	MBIM_FREE(buf);

}
#endif	//DEPRICATED_REQUEST_DATA_LIST

static void	MbimRilHandleDataCallListChangedInd	(void *data, int len)
{
	UNUSEDPARAM(data);
	UNUSEDPARAM(len);
	char						*buf;
	P_MBIM_MESSAGE_CONTEXT		pContext		= NULL;

	ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
	CREATE_INDICATION_CONTEXT(pContext, buf, UUID_CONNECT, UUID_BASIC_CONNECT_INDEX);

	MBIM_LOGD("%s: calling RIL_REQUEST_DATA_CALL_LIST", __FUNCTION__);
	MbimRilRequestDataCallList(pContext);

}
#if defined DEPRICATED_REQUEST_DATA_LIST
static void	MbimRilHandleDataCallListChangedInd	(void *data, int len)
{
	MBIM_CONNECT_INFO			connectInfoRsp;
	RIL_Data_Call_Response_v6	**rilDataCallList	=	(RIL_Data_Call_Response_v6	**)data;
	int							numDataCalls		=	len/sizeof(RIL_Data_Call_Response_v6);
	int							i;
	int  						sessionId			=	MAX_NUM_OF_SESSIONS;

	if	(rilDataCallList)
	{
		MBIM_LOGD("%s: numDataCalls = %d", __FUNCTION__, numDataCalls);
		for (i = 0 ; i < numDataCalls; i++)
		{
			MBIM_LOGD("%s: rilDataCallList[%d] = %08X", __FUNCTION__, i, rilDataCallList[i]);
			if (rilDataCallList[i])
			{
				sessionId = getSessionIdFromCid(rilDataCallList[i]->cid);
				MBIM_LOGD("%s: cid = %d, sessionId = %d", __FUNCTION__, rilDataCallList[i]->cid, sessionId);

				if (sessionId < MAX_NUM_OF_SESSIONS)
				{
					connectInfoRsp.sessionId		= sessionId;
					connectInfoRsp.activationState	= (rilDataCallList[i]->active == 0)?MBIMActivationStateDeactivated:MBIMActivationStateActivated;
					connectInfoRsp.voiceCallState 	= MBIMVoiceCallStateNone;
					connectInfoRsp.ipType 			= MBIMContextIPTypeIPv4;
					memcpy((char *)&connectInfoRsp.contextType,MBIMContextTypeInternet, sizeof(MBIM_UUID));
					connectInfoRsp.nwError			= 0;

					//Update the database
					mbimDb.session[sessionId].ipType = connectInfoRsp.ipType;
					memcpy(mbimDb.session[sessionId].contextType.uuid, MBIMContextTypeInternet, sizeof(MBIM_UUID));

					MBIM_LOGD("%s: Sending Ind: SessionId = %d, IpType = %d", __FUNCTION__, sessionId, mbimDb.session[sessionId].ipType);

					//Send Indication to MBIM host taht we are connected
					MbimSendIndicateStatusMsg(  UUID_BASIC_CONNECT_INDEX,
												UUID_CONNECT,
												sizeof(MBIM_CONNECT_INFO),
												(char *)&connectInfoRsp);


					break;
				}
				else if (rilDataCallList[i]->active)	// activate new PDP
				{
					mbimDb.cidActivated		=	rilDataCallList[i]->cid;
				}
			}
		}
	}

	if	(sessionId < MAX_NUM_OF_SESSIONS)
		MbimRilSendIpConfigurationInd(sessionId);
}
#endif //DEPRICATED

static void	MbimRilHandlePsAttachStateChangeInd	(void *data, int len)
{
	UNUSEDPARAM(len);
	P_MBIM_PACKET_SERVICE_INFO		pPacketServiceInfo;
	char							*packetStatus	=	(char *)data;
	char							*buf;
	P_MBIM_MESSAGE_CONTEXT			pContext		= NULL;


	ALLOCATE_RESPONSE_BUFFER(buf, DEFAULT_CONTEXT_ALLOC_SIZE);
	CREATE_INDICATION_CONTEXT(pContext, buf, UUID_PACKET_SERVICE, UUID_BASIC_CONNECT_INDEX);

	pPacketServiceInfo	=	(P_MBIM_PACKET_SERVICE_INFO)buf;

	if	(packetStatus)
	{
		if (*packetStatus == 0)
			pPacketServiceInfo->packetServiceState	=	MBIMPacketServiceStateDetached;
		else
			pPacketServiceInfo->packetServiceState	=	MBIMPacketServiceStateAttached;

	}

	MbimRilRequestPacketServiceStatus(pContext);

}

#define CHECK_HDR2(context, mcid, uuid, notification)				 \
						   ( (context->hdr.cid        == mcid) && 	 \
							 (context->hdr.uuidIndex  == uuid) &&    \
							 (context->hdr.indication == notification ) )


static void	MbimRilHandlePdpActivedChangeInd	(void *data, int len)
{
	P_MBIM_MESSAGE_CONTEXT 			pContext		= g_setupdatacallcontext;;
	P_MBIM_SET_CONNECT				pSetConnect		= NULL;
	P_MBIM_CONNECT_INFO				pConnectInfoRsp	= NULL;
	MBIM_STATUS_CODE_ENUM			mbimStatus		= MBIM_STATUS_SUCCESS;
	char							apn[128];

	UNUSEDPARAM(len);
    int state = *(int *)data;
    int cid   = *((int *)data+1);
    
    MBIM_LOGD("%s: actived = %d, cid = %d.", __FUNCTION__, state, cid);

    /* Just matched CID Indication is parsed. */
    if(mbimDb.cidActivated != cid)
    {
        return;
    }
	if(pContext == NULL)
	{
		return;
	}
	///////////////////////////////////////////////////////////////
	//Check if the answer is "Basic Connect" && "UUID_CONNECT"
	///////////////////////////////////////////////////////////////
	if (CHECK_HDR2(pContext, UUID_CONNECT, UUID_BASIC_CONNECT_INDEX, MBIM_REQUEST))
	{
		pSetConnect	=	(P_MBIM_SET_CONNECT)pContext->cmd;
		pConnectInfoRsp	=	(P_MBIM_CONNECT_INFO)pContext->body;

		pConnectInfoRsp->sessionId			= pSetConnect->sessionId;
		pConnectInfoRsp->ipType				= pSetConnect->ipType;
		if (0 == state) {
			pConnectInfoRsp->activationState	= MBIMActivationStateDeactivated;           
            mbimDb.cidstatus[cid-1] = 0;
        }
        else {
			pConnectInfoRsp->activationState	= MBIMActivationStateActivated;
            mbimDb.cidstatus[cid-1] = 1;
        }    
		pConnectInfoRsp->nwError			= 0;
		pConnectInfoRsp->voiceCallState		= MBIMVoiceCallStateNone;
		memcpy((char *)&pConnectInfoRsp->contextType,(char *)&pSetConnect->contextType, sizeof(MBIM_UUID));

		if(1){
			copyUtf16ToStr(apn, ((char *)pSetConnect) + pSetConnect->accessStringOffset, MIN((int)pSetConnect->accessStringSize,128));         
			initSessionDb(pSetConnect->sessionId, apn, pSetConnect->ipType, &pSetConnect->contextType, cid);
            
            
	    }
       
		if (mbimDb.sim.simReadyState == MBIMSubscriberReadyStateSimNotInserted)
			mbimStatus = MBIM_STATUS_SIM_NOT_INSERTED;
		else if (mbimDb.sim.simReadyState == MBIMSubscriberReadyStateBadSim)
			mbimStatus = MBIM_STATUS_BAD_SIM;

		MbimSendCommandDone(	pContext->hdr.transId,
								pContext->hdr.uuidIndex,
								pContext->hdr.cid,
								mbimStatus,
								sizeof(MBIM_CONNECT_INFO),
								pContext->body );

		MBIM_FREE_CONTEXT(pContext);
		g_setupdatacallcontext = NULL;

	}
	else if (CHECK_HDR2(pContext, UUID_CONNECT, UUID_BASIC_CONNECT_INDEX, MBIM_NOTIFICATION))
	{
		pConnectInfoRsp	=	(P_MBIM_CONNECT_INFO)pContext->body;
		int sid = pConnectInfoRsp->sessionId;
		pConnectInfoRsp->activationState = mbimDb.session[sid].sessionState;
		pConnectInfoRsp->voiceCallState = MBIMVoiceCallStateNone;
		pConnectInfoRsp->nwError = 0;
		pConnectInfoRsp->ipType = mbimDb.session[sid].ipType;
		memcpy((char *)&pConnectInfoRsp->contextType,(char *)&mbimDb.session[sid].contextType, sizeof(MBIM_UUID));
		MbimSendIndicateStatusMsg(pContext->hdr.uuidIndex, pContext->hdr.cid, 
									sizeof(MBIM_CONNECT_INFO),
									pContext->body);
		MBIM_FREE_CONTEXT(pContext);
		g_setupdatacallcontext = NULL;
    }

}

static void	MbimRilHandleSmsMemStatusInd	(void *data, int len)
{
	if(len != 2)
        return;

    int sms_ready  = *(int *)data;
    int sms_full   = *((int *)data+1);
    
    MBIM_LOGD("%s: smsR = %d, smsF = %d.", __FUNCTION__, sms_ready, sms_ready);

    if (sms_ready == 0 || sms_ready == 2 || sms_ready == 3)
        mbimDb.smsready = 1;
    else
        mbimDb.smsready = 0;

    mbimDb.smsfull = sms_full;

    return;
}


void	MbimRilHandleCmConnectionNotification	(struct cm_connection_info *connection_info)
{
	RIL_Data_Call_Response_v6	*data_call_info[2];
	char	iptype_str	[3][10]	=	{"IPV4V6", "IPV4", "IPV6"};

	MBIM_LOGD("%s: active = %d, cid = %d, type = %d (%s)", __FUNCTION__,
			  connection_info->status, connection_info->cid, connection_info->iptype,
			  (connection_info->iptype < (int)((sizeof(iptype_str)/sizeof(*iptype_str))))?iptype_str[connection_info->iptype]:"");

	data_call_info[0] = calloc(1, sizeof(RIL_Data_Call_Response_v6));

	if (data_call_info[0] == NULL)
	{
		MBIM_LOGE("%s: allocation of data_call_info[0] failed", __FUNCTION__);
		return;
	}

	data_call_info[0]->active	=	(connection_info->status == 0)?0:1;
	data_call_info[0]->cid		=	connection_info->cid-1;
	if	(connection_info->iptype < (int)((sizeof(iptype_str)/sizeof(*iptype_str))))
		data_call_info[0]->type	=	strdup	(iptype_str[connection_info->iptype]);
	else
	{
		data_call_info[0]->type	=	strdup	("");
		MBIM_LOGE("%s: wrong iptype = %d", __FUNCTION__, connection_info->iptype);
	}

	MbimRilHandleDataCallListChangedInd(&data_call_info, sizeof(RIL_Data_Call_Response_v6));

	free(data_call_info[0]->type);
	free(data_call_info[0]);

}
void	MbimRilHandleUnsolicitedNotification	(unsigned int requestid, void *data, int datalen)
{
	switch(requestid)
	{
		case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED:
			MbimRilHandleSimStatusChangedInd();
			break;

		case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
			MbimRilHandleRadioStateChangedInd(data, datalen);
			break;

		case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED:
			MbimRilHandleVoiceNetworkChangedInd();
			break;

		case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED:
			MbimRilHandleVoiceRadioTechChangedInd(data, datalen);
			break;

		case RIL_UNSOL_SIGNAL_STRENGTH:
			MbimRilHandleSignalStrengthInd(data, datalen);
			break;

		case RIL_UNSOL_DATA_CALL_LIST_CHANGED:
			MbimRilHandleDataCallListChangedInd(data, datalen);
			break;

		case RIL_UNSOL_PS_ATTACH_STATUS:
			MbimRilHandlePsAttachStateChangeInd(data, datalen);
			break;

		case RIL_UNSOL_CON_STAT:
			MbimRilHandlePdpActivedChangeInd(data, datalen);
			break;

        case RIL_UNSOL_SMS_MEM_STATUS:
            MbimRilHandleSmsMemStatusInd(data, datalen);
            break;

		default:
			MBIM_LOGD("%s: id of %d is not supported\n", __FUNCTION__,requestid);
	}

}