diff options
Diffstat (limited to 'drivers/isimodem/debug.c')
| -rw-r--r-- | drivers/isimodem/debug.c | 818 |
1 files changed, 818 insertions, 0 deletions
diff --git a/drivers/isimodem/debug.c b/drivers/isimodem/debug.c new file mode 100644 index 00000000..4aef0d53 --- /dev/null +++ b/drivers/isimodem/debug.c @@ -0,0 +1,818 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#define _GNU_SOURCE +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <string.h> +#include <errno.h> + +#include <glib.h> + +#define OFONO_API_SUBJECT_TO_CHANGE +#include <ofono/log.h> + +#include "debug.h" + +#define _(X) case X: return #X + +const char *pn_resource_name(int value) +{ + switch (value) { + _(PN_NETWORK); + _(PN_PHONE_INFO); + _(PN_SS); + _(PN_CALL); + _(PN_SMS); + _(PN_SIM); + _(PN_MTC); + } + return "<UNKNOWN>"; +} + +const char *ss_message_id_name(enum ss_message_id value) +{ + switch (value) { + _(SS_SERVICE_REQ); + _(SS_SERVICE_COMPLETED_RESP); + _(SS_SERVICE_FAILED_RESP); + _(SS_COMMON_MESSAGE); + } + return "<UNKNOWN>"; +} + +const char *ss_subblock_name(enum ss_subblock value) +{ + switch (value) { + _(SS_FORWARDING); + _(SS_STATUS_RESULT); + _(SS_GSM_PASSWORD); + _(SS_GSM_FORWARDING_INFO); + _(SS_GSM_FORWARDING_FEATURE); + _(SS_GSM_DATA); + _(SS_GSM_BSC_INFO); + _(SS_GSM_PASSWORD_INFO); + _(SS_GSM_INDICATE_PASSWORD_ERROR); + _(SS_GSM_INDICATE_ERROR); + _(SS_GSM_ADDITIONAL_INFO); + } + return "<UNKNOWN>"; +} + +const char *mtc_isi_cause_name(enum mtc_isi_cause value) +{ + switch (value) { + _(MTC_OK); + _(MTC_FAIL); + _(MTC_NOT_ALLOWED); + _(MTC_STATE_TRANSITION_GOING_ON); + _(MTC_ALREADY_ACTIVE); + _(MTC_SERVICE_DISABLED); + _(MTC_NOT_READY_YET); + _(MTC_NOT_SUPPORTED); + _(MTC_TRANSITION_ONGOING); + _(MTC_RESET_REQUIRED); + } + return "<UNKNOWN>"; +} + +const char *mtc_message_id_name(enum mtc_message_id value) +{ + switch (value) { + _(MTC_STATE_QUERY_REQ); + _(MTC_POWER_OFF_REQ); + _(MTC_POWER_ON_REQ); + _(MTC_STATE_QUERY_RESP); + _(MTC_POWER_OFF_RESP); + _(MTC_POWER_ON_RESP); + _(MTC_STATE_INFO_IND); + _(MTC_COMMON_MESSAGE); + } + return "<UNKNOWN>"; +} + +const char *mtc_modem_state_name(enum mtc_modem_state value) +{ + switch (value) { + _(MTC_POWER_OFF); + _(MTC_NORMAL); + _(MTC_CHARGING); + _(MTC_ALARM); + _(MTC_TEST); + _(MTC_LOCAL); + _(MTC_WARRANTY); + _(MTC_RELIABILITY); + _(MTC_SELFTEST_FAIL); + _(MTC_SWDL); + _(MTC_RF_INACTIVE); + _(MTC_ID_WRITE); + _(MTC_DISCHARGING); + _(MTC_DISK_WIPE); + _(MTC_SW_RESET); + _(MTC_CMT_ONLY_MODE); + } + return "<UNKNOWN>"; +} + +const char *sms_isi_cause_name(enum sms_isi_cause value) +{ + switch (value) { + _(SMS_OK); + _(SMS_ERR_ROUTING_RELEASED); + _(SMS_ERR_INVALID_PARAMETER); + _(SMS_ERR_DEVICE_FAILURE); + _(SMS_ERR_PP_RESERVED); + _(SMS_ERR_ROUTE_NOT_AVAILABLE); + _(SMS_ERR_ROUTE_NOT_ALLOWED); + _(SMS_ERR_SERVICE_RESERVED); + _(SMS_ERR_INVALID_LOCATION); + _(SMS_ERR_NO_SIM); + _(SMS_ERR_SIM_NOT_READY); + _(SMS_ERR_NO_NETW_RESPONSE); + _(SMS_ERR_DEST_ADDR_FDN_RESTRICTED); + _(SMS_ERR_SMSC_ADDR_FDN_RESTRICTED); + _(SMS_ERR_RESEND_ALREADY_DONE); + _(SMS_ERR_SMSC_ADDR_NOT_AVAILABLE); + _(SMS_ERR_ROUTING_FAILED); + _(SMS_ERR_CS_INACTIVE); + _(SMS_ERR_SAT_MO_CONTROL_MODIFIED); + _(SMS_ERR_SAT_MO_CONTROL_REJECT); + _(SMS_ERR_TRACFONE_FAILED); + } + return "<UNKNOWN>"; +} + +const char *sms_gsm_cause_name(enum sms_gsm_cause value) +{ + switch (value) { + _(SMS_GSM_ERR_UNASSIGNED_NUMBER); + _(SMS_GSM_ERR_OPER_DETERMINED_BARR); + _(SMS_GSM_ERR_CALL_BARRED); + _(SMS_GSM_ERR_RESERVED); + _(SMS_GSM_ERR_MSG_TRANSFER_REJ); + _(SMS_GSM_ERR_MEMORY_CAPACITY_EXC); + _(SMS_GSM_ERR_DEST_OUT_OF_ORDER); + _(SMS_GSM_ERR_UNDEFINED_SUBSCRIBER); + _(SMS_GSM_ERR_FACILITY_REJECTED); + _(SMS_GSM_ERR_UNKNOWN_SUBSCRIBER); + _(SMS_GSM_ERR_NETW_OUT_OF_ORDER); + _(SMS_GSM_ERR_TEMPORARY_FAILURE); + _(SMS_GSM_ERR_CONGESTION); + _(SMS_GSM_ERR_RESOURCE_UNAVAILABLE); + _(SMS_GSM_ERR_REQ_FACILITY_NOT_SUB); + _(SMS_GSM_ERR_REQ_FACILITY_NOT_IMP); + _(SMS_GSM_ERR_INVALID_REFERENCE); + _(SMS_GSM_ERR_INCORRECT_MESSAGE); + _(SMS_GSM_ERR_INVALID_MAND_INFO); + _(SMS_GSM_ERR_INVALID_MSG_TYPE); + _(SMS_GSM_ERR_MSG_NOT_COMP_WITH_ST); + _(SMS_GSM_ERR_INVALID_INFO_ELEMENT); + _(SMS_GSM_ERR_PROTOCOL_ERROR); + _(SMS_GSM_ERR_INTERWORKING); + _(SMS_GSM_ERR_NO_CAUSE); + _(SMS_GSM_ERR_IMSI_UNKNOWN_HLR); + _(SMS_GSM_ERR_ILLEGAL_MS); + _(SMS_GSM_ERR_IMSI_UNKNOWN_VLR); + _(SMS_GSM_ERR_IMEI_NOT_ACCEPTED); + _(SMS_GSM_ERR_ILLEGAL_ME); + _(SMS_GSM_ERR_PLMN_NOT_ALLOWED); + _(SMS_GSM_ERR_LA_NOT_ALLOWED); + _(SMS_GSM_ERR_ROAM_NOT_ALLOWED_LA); + _(SMS_GSM_ERR_NO_SUITABLE_CELLS_LA); + _(SMS_GSM_ERR_NETWORK_FAILURE); + _(SMS_GSM_ERR_MAC_FAILURE); + _(SMS_GSM_ERR_SYNC_FAILURE); + _(SMS_GSM_ERR_LOW_LAYER_CONGESTION); + _(SMS_GSM_ERR_AUTH_UNACCEPTABLE); + _(SMS_GSM_ERR_SERV_OPT_NOT_SUPPORTED); + _(SMS_GSM_ERR_SERV_OPT_NOT_SUBSCRIBED); + _(SMS_GSM_ERR_SERV_OPT_TEMP_OUT_OF_ORDER); + _(SMS_GSM_ERR_CALL_CANNOT_BE_IDENTIFIED); + _(SMS_GSM_ERR_SEMANTICALLY_INCORR_MSG); + _(SMS_GSM_ERR_LOW_LAYER_INVALID_MAND_INFO); + _(SMS_GSM_ERR_LOW_LAYER_INVALID_MSG_TYPE); + _(SMS_GSM_ERR_LOW_LAYER_MSG_TYPE_NOT_COMP_WITH_ST); + _(SMS_GSM_ERR_LOW_LAYER_INVALID_INFO_ELEMENT); + _(SMS_GSM_ERR_CONDITIONAL_IE_ERROR); + _(SMS_GSM_ERR_LOW_LAYER_MSG_NOT_COMP_WITH_ST); + _(SMS_GSM_ERR_CS_BARRED); + _(SMS_GSM_ERR_LOW_LAYER_PROTOCOL_ERROR); + } + return "<UNKNOWN>"; +} + +const char *sms_message_id_name(enum sms_message_id value) +{ + switch (value) { + _(SMS_MESSAGE_SEND_REQ); + _(SMS_MESSAGE_SEND_RESP); + _(SMS_PP_ROUTING_REQ); + _(SMS_PP_ROUTING_RESP); + _(SMS_PP_ROUTING_NTF); + _(SMS_GSM_CB_ROUTING_REQ); + _(SMS_GSM_CB_ROUTING_RESP); + _(SMS_GSM_CB_ROUTING_NTF); + _(SMS_COMMON_MESSAGE); + } + return "<UNKNOWN>"; +} + +const char *sms_subblock_name(enum sms_subblock value) +{ + switch (value) { + _(SMS_GSM_DELIVER); + _(SMS_GSM_STATUS_REPORT); + _(SMS_GSM_SUBMIT); + _(SMS_GSM_COMMAND); + _(SMS_GSM_ROUTING); + } + return "<UNKNOWN>"; +} + +const char *sim_isi_cause_name(enum sim_isi_cause value) +{ + switch (value) { + _(SIM_SERV_NOT_AVAIL); + _(SIM_SERV_OK); + _(SIM_SERV_PIN_VERIFY_REQUIRED); + _(SIM_SERV_PIN_REQUIRED); + _(SIM_SERV_SIM_BLOCKED); + _(SIM_SERV_SIM_PERMANENTLY_BLOCKED); + _(SIM_SERV_SIM_DISCONNECTED); + _(SIM_SERV_SIM_REJECTED); + _(SIM_SERV_LOCK_ACTIVE); + _(SIM_SERV_AUTOLOCK_CLOSED); + _(SIM_SERV_AUTOLOCK_ERROR); + _(SIM_SERV_INIT_OK); + _(SIM_SERV_INIT_NOT_OK); + _(SIM_SERV_WRONG_OLD_PIN); + _(SIM_SERV_PIN_DISABLED); + _(SIM_SERV_COMMUNICATION_ERROR); + _(SIM_SERV_UPDATE_IMPOSSIBLE); + _(SIM_SERV_NO_SECRET_CODE_IN_SIM); + _(SIM_SERV_PIN_ENABLE_OK); + _(SIM_SERV_PIN_DISABLE_OK); + _(SIM_SERV_WRONG_UNBLOCKING_KEY); + _(SIM_SERV_ILLEGAL_NUMBER); + _(SIM_SERV_NOT_OK); + _(SIM_SERV_PN_LIST_ENABLE_OK); + _(SIM_SERV_PN_LIST_DISABLE_OK); + _(SIM_SERV_NO_PIN); + _(SIM_SERV_PIN_VERIFY_OK); + _(SIM_SERV_PIN_BLOCKED); + _(SIM_SERV_PIN_PERM_BLOCKED); + _(SIM_SERV_DATA_NOT_AVAIL); + _(SIM_SERV_IN_HOME_ZONE); + _(SIM_SERV_STATE_CHANGED); + _(SIM_SERV_INF_NBR_READ_OK); + _(SIM_SERV_INF_NBR_READ_NOT_OK); + _(SIM_SERV_IMSI_EQUAL); + _(SIM_SERV_IMSI_NOT_EQUAL); + _(SIM_SERV_INVALID_LOCATION); + _(SIM_SERV_STA_SIM_REMOVED); + _(SIM_SERV_SECOND_SIM_REMOVED_CS); + _(SIM_SERV_CONNECTED_INDICATION_CS); + _(SIM_SERV_SECOND_SIM_CONNECTED_CS); + _(SIM_SERV_PIN_RIGHTS_LOST_IND_CS); + _(SIM_SERV_PIN_RIGHTS_GRANTED_IND_CS); + _(SIM_SERV_INIT_OK_CS); + _(SIM_SERV_INIT_NOT_OK_CS); + _(SIM_FDN_ENABLED); + _(SIM_FDN_DISABLED); + _(SIM_SERV_INVALID_FILE); + _(SIM_SERV_DATA_AVAIL); + _(SIM_SERV_ICC_EQUAL); + _(SIM_SERV_ICC_NOT_EQUAL); + _(SIM_SERV_SIM_NOT_INITIALISED); + _(SIM_SERV_SERVICE_NOT_AVAIL); + _(SIM_SERV_FDN_STATUS_ERROR); + _(SIM_SERV_FDN_CHECK_PASSED); + _(SIM_SERV_FDN_CHECK_FAILED); + _(SIM_SERV_FDN_CHECK_DISABLED); + _(SIM_SERV_FDN_CHECK_NO_FDN_SIM); + _(SIM_STA_ISIM_AVAILEBLE_PIN_REQUIRED); + _(SIM_STA_ISIM_AVAILEBLE); + _(SIM_STA_USIM_AVAILEBLE); + _(SIM_STA_SIM_AVAILEBLE); + _(SIM_STA_ISIM_NOT_INITIALIZED); + _(SIM_STA_IMS_READY); + _(SIM_STA_APP_DATA_READ_OK); + _(SIM_STA_APP_ACTIVATE_OK); + _(SIM_STA_APP_ACTIVATE_NOT_OK); + _(SIM_SERV_NOT_DEFINED); + _(SIM_SERV_NOSERVICE); + _(SIM_SERV_NOTREADY); + _(SIM_SERV_ERROR); + _(SIM_SERV_CIPHERING_INDICATOR_DISPLAY_REQUIRED); + _(SIM_SERV_CIPHERING_INDICATOR_DISPLAY_NOT_REQUIRED); + _(SIM_SERV_FILE_NOT_AVAILABLE); + } + return "<UNKNOWN>"; +} + +const char *sim_message_id_name(enum sim_message_id value) +{ + switch (value) { + _(SIM_IMSI_REQ_READ_IMSI); + _(SIM_IMSI_RESP_READ_IMSI); + _(SIM_SERV_PROV_NAME_REQ); + _(SIM_SERV_PROV_NAME_RESP); + _(SIM_PB_REQ_SIM_PB_READ); + _(SIM_PB_RESP_SIM_PB_READ); + _(SIM_COMMON_MESSAGE); + } + return "<UNKNOWN>"; +} + +const char *sim_subblock_name(enum sim_subblock value) +{ + switch (value) { + _(SIM_PB_INFO_REQUEST); + _(SIM_PB_STATUS); + _(SIM_PB_LOCATION); + _(SIM_PB_LOCATION_SEARCH); + } + return "<UNKNOWN>"; +} + +const char *info_isi_cause_name(enum info_isi_cause value) +{ + switch (value) { + _(INFO_OK); + _(INFO_FAIL); + _(INFO_NO_NUMBER); + _(INFO_NOT_SUPPORTED); + } + return "<UNKNOWN>"; +} + +const char *info_message_id_name(enum info_message_id value) +{ + switch (value) { + _(INFO_SERIAL_NUMBER_READ_REQ); + _(INFO_SERIAL_NUMBER_READ_RESP); + _(INFO_VERSION_READ_REQ); + _(INFO_VERSION_READ_RESP); + _(INFO_PRODUCT_INFO_READ_REQ); + _(INFO_PRODUCT_INFO_READ_RESP); + _(INFO_COMMON_MESSAGE); + } + return "<UNKNOWN>"; +} + +const char *info_subblock_name(enum info_subblock value) +{ + switch (value) { + _(INFO_SB_PRODUCT_INFO_NAME); + _(INFO_SB_PRODUCT_INFO_MANUFACTURER); + _(INFO_SB_SN_IMEI_PLAIN); + _(INFO_SB_MCUSW_VERSION); + } + return "<UNKNOWN>"; +} + +const char *call_status_name(enum call_status value) +{ + switch (value) { + _(CALL_STATUS_IDLE); + _(CALL_STATUS_CREATE); + _(CALL_STATUS_COMING); + _(CALL_STATUS_PROCEEDING); + _(CALL_STATUS_MO_ALERTING); + _(CALL_STATUS_MT_ALERTING); + _(CALL_STATUS_WAITING); + _(CALL_STATUS_ANSWERED); + _(CALL_STATUS_ACTIVE); + _(CALL_STATUS_MO_RELEASE); + _(CALL_STATUS_MT_RELEASE); + _(CALL_STATUS_HOLD_INITIATED); + _(CALL_STATUS_HOLD); + _(CALL_STATUS_RETRIEVE_INITIATED); + _(CALL_STATUS_RECONNECT_PENDING); + _(CALL_STATUS_TERMINATED); + _(CALL_STATUS_SWAP_INITIATED); + } + return "<UNKNOWN>"; +} + +char const *call_message_id_name(enum call_message_id value) +{ + switch (value) { + _(CALL_CREATE_REQ); + _(CALL_CREATE_RESP); + _(CALL_COMING_IND); + _(CALL_MO_ALERT_IND); + _(CALL_MT_ALERT_IND); + _(CALL_WAITING_IND); + _(CALL_ANSWER_REQ); + _(CALL_ANSWER_RESP); + _(CALL_RELEASE_REQ); + _(CALL_RELEASE_RESP); + _(CALL_RELEASE_IND); + _(CALL_TERMINATED_IND); + _(CALL_STATUS_REQ); + _(CALL_STATUS_RESP); + _(CALL_STATUS_IND); + _(CALL_SERVER_STATUS_IND); + _(CALL_CONTROL_REQ); + _(CALL_CONTROL_RESP); + _(CALL_CONTROL_IND); + _(CALL_MODE_SWITCH_REQ); + _(CALL_MODE_SWITCH_RESP); + _(CALL_MODE_SWITCH_IND); + _(CALL_DTMF_SEND_REQ); + _(CALL_DTMF_SEND_RESP); + _(CALL_DTMF_STOP_REQ); + _(CALL_DTMF_STOP_RESP); + _(CALL_DTMF_STATUS_IND); + _(CALL_DTMF_TONE_IND); + _(CALL_RECONNECT_IND); + _(CALL_PROPERTY_GET_REQ); + _(CALL_PROPERTY_GET_RESP); + _(CALL_PROPERTY_SET_REQ); + _(CALL_PROPERTY_SET_RESP); + _(CALL_PROPERTY_SET_IND); + _(CALL_EMERGENCY_NBR_CHECK_REQ); + _(CALL_EMERGENCY_NBR_CHECK_RESP); + _(CALL_EMERGENCY_NBR_GET_REQ); + _(CALL_EMERGENCY_NBR_GET_RESP); + _(CALL_EMERGENCY_NBR_MODIFY_REQ); + _(CALL_EMERGENCY_NBR_MODIFY_RESP); + _(CALL_GSM_NOTIFICATION_IND); + _(CALL_GSM_USER_TO_USER_REQ); + _(CALL_GSM_USER_TO_USER_RESP); + _(CALL_GSM_USER_TO_USER_IND); + _(CALL_GSM_BLACKLIST_CLEAR_REQ); + _(CALL_GSM_BLACKLIST_CLEAR_RESP); + _(CALL_GSM_BLACKLIST_TIMER_IND); + _(CALL_GSM_DATA_CH_INFO_IND); + _(CALL_GSM_CCP_GET_REQ); + _(CALL_GSM_CCP_GET_RESP); + _(CALL_GSM_CCP_CHECK_REQ); + _(CALL_GSM_CCP_CHECK_RESP); + _(CALL_GSM_COMING_REJ_IND); + _(CALL_GSM_RAB_IND); + _(CALL_GSM_IMMEDIATE_MODIFY_IND); + _(CALL_CREATE_NO_SIMATK_REQ); + _(CALL_GSM_SS_DATA_IND); + _(CALL_TIMER_REQ); + _(CALL_TIMER_RESP); + _(CALL_TIMER_NTF); + _(CALL_TIMER_IND); + _(CALL_TIMER_RESET_REQ); + _(CALL_TIMER_RESET_RESP); + _(CALL_EMERGENCY_NBR_IND); + _(CALL_SERVICE_DENIED_IND); + _(CALL_RELEASE_END_REQ); + _(CALL_RELEASE_END_RESP); + _(CALL_USER_CONNECT_IND); + _(CALL_AUDIO_CONNECT_IND); + _(CALL_KODIAK_ALLOW_CTRL_REQ); + _(CALL_KODIAK_ALLOW_CTRL_RESP); + _(CALL_SERVICE_ACTIVATE_IND); + _(CALL_SERVICE_ACTIVATE_REQ); + _(CALL_SERVICE_ACTIVATE_RESP); + _(CALL_SIM_ATK_IND); + _(CALL_CONTROL_OPER_IND); + _(CALL_TEST_CALL_STATUS_IND); + _(CALL_SIM_ATK_INFO_IND); + _(CALL_SECURITY_IND); + _(CALL_MEDIA_HANDLE_REQ); + _(CALL_MEDIA_HANDLE_RESP); + _(CALL_COMMON_MESSAGE); + } + return "<UNKNOWN>"; +} + +char const *call_isi_cause_name(enum call_isi_cause value) +{ + switch (value) { + _(CALL_CAUSE_NO_CAUSE); + _(CALL_CAUSE_NO_CALL); + _(CALL_CAUSE_TIMEOUT); + _(CALL_CAUSE_RELEASE_BY_USER); + _(CALL_CAUSE_BUSY_USER_REQUEST); + _(CALL_CAUSE_ERROR_REQUEST); + _(CALL_CAUSE_COST_LIMIT_REACHED); + _(CALL_CAUSE_CALL_ACTIVE); + _(CALL_CAUSE_NO_CALL_ACTIVE); + _(CALL_CAUSE_INVALID_CALL_MODE); + _(CALL_CAUSE_SIGNALLING_FAILURE); + _(CALL_CAUSE_TOO_LONG_ADDRESS); + _(CALL_CAUSE_INVALID_ADDRESS); + _(CALL_CAUSE_EMERGENCY); + _(CALL_CAUSE_NO_TRAFFIC_CHANNEL); + _(CALL_CAUSE_NO_COVERAGE); + _(CALL_CAUSE_CODE_REQUIRED); + _(CALL_CAUSE_NOT_ALLOWED); + _(CALL_CAUSE_NO_DTMF); + _(CALL_CAUSE_CHANNEL_LOSS); + _(CALL_CAUSE_FDN_NOT_OK); + _(CALL_CAUSE_USER_TERMINATED); + _(CALL_CAUSE_BLACKLIST_BLOCKED); + _(CALL_CAUSE_BLACKLIST_DELAYED); + _(CALL_CAUSE_NUMBER_NOT_FOUND); + _(CALL_CAUSE_NUMBER_CANNOT_REMOVE); + _(CALL_CAUSE_EMERGENCY_FAILURE); + _(CALL_CAUSE_CS_SUSPENDED); + _(CALL_CAUSE_DCM_DRIVE_MODE); + _(CALL_CAUSE_MULTIMEDIA_NOT_ALLOWED); + _(CALL_CAUSE_SIM_REJECTED); + _(CALL_CAUSE_NO_SIM); + _(CALL_CAUSE_SIM_LOCK_OPERATIVE); + _(CALL_CAUSE_SIMATKCC_REJECTED); + _(CALL_CAUSE_SIMATKCC_MODIFIED); + _(CALL_CAUSE_DTMF_INVALID_DIGIT); + _(CALL_CAUSE_DTMF_SEND_ONGOING); + _(CALL_CAUSE_CS_INACTIVE); + _(CALL_CAUSE_SECURITY_MODE); + _(CALL_CAUSE_TRACFONE_FAILED); + _(CALL_CAUSE_TRACFONE_WAIT_FAILED); + _(CALL_CAUSE_TRACFONE_CONF_FAILED); + _(CALL_CAUSE_TEMPERATURE_LIMIT); + _(CALL_CAUSE_KODIAK_POC_FAILED); + _(CALL_CAUSE_NOT_REGISTERED); + _(CALL_CAUSE_CS_CALLS_ONLY); + _(CALL_CAUSE_VOIP_CALLS_ONLY); + _(CALL_CAUSE_LIMITED_CALL_ACTIVE); + _(CALL_CAUSE_LIMITED_CALL_NOT_ALLOWED); + _(CALL_CAUSE_SECURE_CALL_NOT_POSSIBLE); + _(CALL_CAUSE_INTERCEPT); + } + return "<UNKNOWN>"; +} + +char const *call_gsm_cause_name(enum call_gsm_cause value) +{ + switch (value) { + _(CALL_GSM_CAUSE_UNASSIGNED_NUMBER); + _(CALL_GSM_CAUSE_NO_ROUTE); + _(CALL_GSM_CAUSE_CH_UNACCEPTABLE); + _(CALL_GSM_CAUSE_OPER_BARRING); + _(CALL_GSM_CAUSE_NORMAL); + _(CALL_GSM_CAUSE_USER_BUSY); + _(CALL_GSM_CAUSE_NO_USER_RESPONSE); + _(CALL_GSM_CAUSE_ALERT_NO_ANSWER); + _(CALL_GSM_CAUSE_CALL_REJECTED); + _(CALL_GSM_CAUSE_NUMBER_CHANGED); + _(CALL_GSM_CAUSE_NON_SELECT_CLEAR); + _(CALL_GSM_CAUSE_DEST_OUT_OF_ORDER); + _(CALL_GSM_CAUSE_INVALID_NUMBER); + _(CALL_GSM_CAUSE_FACILITY_REJECTED); + _(CALL_GSM_CAUSE_RESP_TO_STATUS); + _(CALL_GSM_CAUSE_NORMAL_UNSPECIFIED); + _(CALL_GSM_CAUSE_NO_CHANNEL); + _(CALL_GSM_CAUSE_NETW_OUT_OF_ORDER); + _(CALL_GSM_CAUSE_TEMPORARY_FAILURE); + _(CALL_GSM_CAUSE_CONGESTION); + _(CALL_GSM_CAUSE_ACCESS_INFO_DISC); + _(CALL_GSM_CAUSE_CHANNEL_NA); + _(CALL_GSM_CAUSE_RESOURCES_NA); + _(CALL_GSM_CAUSE_QOS_NA); + _(CALL_GSM_CAUSE_FACILITY_UNSUBS); + _(CALL_GSM_CAUSE_COMING_BARRED_CUG); + _(CALL_GSM_CAUSE_BC_UNAUTHORIZED); + _(CALL_GSM_CAUSE_BC_NA); + _(CALL_GSM_CAUSE_SERVICE_NA); + _(CALL_GSM_CAUSE_BEARER_NOT_IMPL); + _(CALL_GSM_CAUSE_ACM_MAX); + _(CALL_GSM_CAUSE_FACILITY_NOT_IMPL); + _(CALL_GSM_CAUSE_ONLY_RDI_BC); + _(CALL_GSM_CAUSE_SERVICE_NOT_IMPL); + _(CALL_GSM_CAUSE_INVALID_TI); + _(CALL_GSM_CAUSE_NOT_IN_CUG); + _(CALL_GSM_CAUSE_INCOMPATIBLE_DEST); + _(CALL_GSM_CAUSE_INV_TRANS_NET_SEL); + _(CALL_GSM_CAUSE_SEMANTICAL_ERR); + _(CALL_GSM_CAUSE_INVALID_MANDATORY); + _(CALL_GSM_CAUSE_MSG_TYPE_INEXIST); + _(CALL_GSM_CAUSE_MSG_TYPE_INCOMPAT); + _(CALL_GSM_CAUSE_IE_NON_EXISTENT); + _(CALL_GSM_CAUSE_COND_IE_ERROR); + _(CALL_GSM_CAUSE_MSG_INCOMPATIBLE); + _(CALL_GSM_CAUSE_TIMER_EXPIRY); + _(CALL_GSM_CAUSE_PROTOCOL_ERROR); + _(CALL_GSM_CAUSE_INTERWORKING); + } + return "<UNKNOWN>"; +} + +const char *net_gsm_cause_name(enum net_gsm_cause value) +{ + switch (value) { + _(NET_GSM_IMSI_UNKNOWN_IN_HLR); + _(NET_GSM_ILLEGAL_MS); + _(NET_GSM_IMSI_UNKNOWN_IN_VLR); + _(NET_GSM_IMEI_NOT_ACCEPTED); + _(NET_GSM_ILLEGAL_ME); + _(NET_GSM_GPRS_SERVICES_NOT_ALLOWED); + _(NET_GSM_GPRS_AND_NON_GPRS_NA); + _(NET_GSM_MS_ID_CANNOT_BE_DERIVED); + _(NET_GSM_IMPLICITLY_DETACHED); + _(NET_GSM_PLMN_NOT_ALLOWED); + _(NET_GSM_LA_NOT_ALLOWED); + _(NET_GSM_ROAMING_NOT_IN_THIS_LA); + _(NET_GSM_GPRS_SERV_NA_IN_THIS_PLMN); + _(NET_GSM_NO_SUITABLE_CELLS_IN_LA); + _(NET_GSM_MSC_TEMP_NOT_REACHABLE); + _(NET_GSM_NETWORK_FAILURE); + _(NET_GSM_MAC_FAILURE); + _(NET_GSM_SYNCH_FAILURE); + _(NET_GSM_CONGESTION); + _(NET_GSM_AUTH_UNACCEPTABLE); + _(NET_GSM_SERV_OPT_NOT_SUPPORTED); + _(NET_GSM_SERV_OPT_NOT_SUBSCRIBED); + _(NET_GSM_SERV_TEMP_OUT_OF_ORDER); + _(NET_GSM_RETRY_ENTRY_NEW_CELL_LOW); + _(NET_GSM_RETRY_ENTRY_NEW_CELL_HIGH); + _(NET_GSM_SEMANTICALLY_INCORRECT); + _(NET_GSM_INVALID_MANDATORY_INFO); + _(NET_GSM_MSG_TYPE_NONEXISTENT); + _(NET_GSM_CONDITIONAL_IE_ERROR); + _(NET_GSM_MSG_TYPE_WRONG_STATE); + _(NET_GSM_PROTOCOL_ERROR_UNSPECIFIED); + } + return "<UNKNOWN>"; +} + +const char *net_isi_cause_name(enum net_isi_cause value) +{ + switch (value) { + _(NET_CAUSE_OK); + _(NET_CAUSE_COMMUNICATION_ERROR); + _(NET_CAUSE_INVALID_PARAMETER); + _(NET_CAUSE_NO_SIM); + _(NET_CAUSE_SIM_NOT_YET_READY); + _(NET_CAUSE_NET_NOT_FOUND); + _(NET_CAUSE_REQUEST_NOT_ALLOWED); + _(NET_CAUSE_CALL_ACTIVE); + _(NET_CAUSE_SERVER_BUSY); + _(NET_CAUSE_SECURITY_CODE_REQUIRED); + _(NET_CAUSE_NOTHING_TO_CANCEL); + _(NET_CAUSE_UNABLE_TO_CANCEL); + _(NET_CAUSE_NETWORK_FORBIDDEN); + _(NET_CAUSE_REQUEST_REJECTED); + _(NET_CAUSE_CS_NOT_SUPPORTED); + _(NET_CAUSE_PAR_INFO_NOT_AVAILABLE); + _(NET_CAUSE_NOT_DONE); + _(NET_CAUSE_NO_SELECTED_NETWORK); + _(NET_CAUSE_REQUEST_INTERRUPTED); + _(NET_CAUSE_TOO_BIG_INDEX); + _(NET_CAUSE_MEMORY_FULL); + _(NET_CAUSE_SERVICE_NOT_ALLOWED); + _(NET_CAUSE_NOT_SUPPORTED_IN_TECH); + } + return "<UNKNOWN>"; +} + +const char *net_status_name(enum net_reg_status value) +{ + switch (value) { + _(NET_REG_STATUS_HOME); + _(NET_REG_STATUS_ROAM); + _(NET_REG_STATUS_ROAM_BLINK); + _(NET_REG_STATUS_NOSERV); + _(NET_REG_STATUS_NOSERV_SEARCHING); + _(NET_REG_STATUS_NOSERV_NOTSEARCHING); + _(NET_REG_STATUS_NOSERV_NOSIM); + _(NET_REG_STATUS_POWER_OFF); + _(NET_REG_STATUS_NSPS); + _(NET_REG_STATUS_NSPS_NO_COVERAGE); + _(NET_REG_STATUS_NOSERV_SIM_REJECTED_BY_NW); + } + return "<UNKNOWN>"; +} + +const char *net_message_id_name(enum net_message_id value) +{ + switch (value) { + _(NET_SET_REQ); + _(NET_SET_RESP); + _(NET_RSSI_GET_REQ); + _(NET_RSSI_GET_RESP); + _(NET_RSSI_IND); + _(NET_RAT_IND); + _(NET_RAT_REQ); + _(NET_RAT_RESP); + _(NET_REG_STATUS_GET_REQ); + _(NET_REG_STATUS_GET_RESP); + _(NET_REG_STATUS_IND); + _(NET_AVAILABLE_GET_REQ); + _(NET_AVAILABLE_GET_RESP); + _(NET_OPER_NAME_READ_REQ); + _(NET_OPER_NAME_READ_RESP); + _(NET_COMMON_MESSAGE); + } + return "<UNKNOWN>"; +} + +const char *net_subblock_name(enum net_subblock value) +{ + switch (value) { + _(NET_REG_INFO_COMMON); + _(NET_OPERATOR_INFO_COMMON); + _(NET_RSSI_CURRENT); + _(NET_GSM_REG_INFO); + _(NET_DETAILED_NETWORK_INFO); + _(NET_GSM_OPERATOR_INFO); + _(NET_GSM_BAND_INFO); + _(NET_RAT_INFO); + _(NET_AVAIL_NETWORK_INFO_COMMON); + _(NET_OPER_NAME_INFO); + } + return "<UNKNOWN>"; +} + +#undef _ + +static void hex_dump(const char *name, const uint8_t m[], size_t len) +{ + char hex[3 * 16 + 1]; + char ascii[16 + 1]; + size_t i, j, k; + + ofono_debug("%s [%s=0x%02X len=%zu]:", name, + "message_id", m[0], len); + + strcpy(hex, " **"), j = 3; + strcpy(ascii, "."), k = 1; + + for (i = 0; i < len; i++) { + sprintf(hex + j, " %02X", m[i]), j += 3; + ascii[k++] = g_ascii_isgraph(m[i]) ? m[i] : '.'; + + if ((i & 15) == 15) { + ofono_debug(" *%-48s : %.*s", hex, (int)k, ascii); + j = 0, k = 0; + } + } + + if (j) { + ofono_debug(" *%-48s : %.*s", hex, (int)k, ascii); + } +} + +void ss_debug(const void *restrict buf, size_t len, void *data) +{ + const uint8_t *m = buf; + hex_dump(ss_message_id_name(m[0]), m, len); +} + +void mtc_debug(const void *restrict buf, size_t len, void *data) +{ + const uint8_t *m = buf; + hex_dump(mtc_message_id_name(m[0]), m, len); +} + +void sms_debug(const void *restrict buf, size_t len, void *data) +{ + const uint8_t *m = buf; + hex_dump(sms_message_id_name(m[0]), m, len); +} + +void sim_debug(const void *restrict buf, size_t len, void *data) +{ + const uint8_t *m = buf; + hex_dump(sim_message_id_name(m[0]), m, len); +} + +void info_debug(const void *restrict buf, size_t len, void *data) +{ + const uint8_t *m = buf; + hex_dump(info_message_id_name(m[0]), m, len); +} + +void call_debug(const void *restrict buf, size_t len, void *data) +{ + const uint8_t *m = buf; + hex_dump(call_message_id_name(m[0]), m, len); +} + +void net_debug(const void *restrict buf, size_t len, void *data) +{ + const uint8_t *m = buf; + hex_dump(net_message_id_name(m[0]), m, len); +} |