Add debug implementation

Alsoo remove call specific debugs.

2 files changed, 818 insertions, 345 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);
+}
diff --git a/drivers/isimodem/isi-call-debug.c b/drivers/isimodem/isi-call-debug.c
deleted file mode 100644
index 5d6483c4..00000000
--- a/drivers/isimodem/isi-call-debug.c
+++ /dev/null
@@ -1,345 +0,0 @@
-/*
- * This file is part of oFono - Open Source Telephony
- *
- * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
- *
- * Contact: <Pekka.Pessi@nokia.com>
- *
- * 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 <string.h>
-#include <errno.h>
-
-#include <glib.h>
-
-#include <gisi/client.h>
-#include <gisi/iter.h>
-
-#include "isi-call.h"
-
-#include <ofono/log.h>
-
-#define DUMP(fmt, arg...) ofono_debug(fmt, ## arg)
-
-char const *isi_call_status_name(enum isi_call_status value)
-{
-	switch (value) {
-#define _(X) case CALL_STATUS_ ## X: return #X
-		_(IDLE);
-		_(CREATE);
-		_(COMING);
-		_(PROCEEDING);
-		_(MO_ALERTING);
-		_(MT_ALERTING);
-		_(WAITING);
-		_(ANSWERED);
-		_(ACTIVE);
-		_(MO_RELEASE);
-		_(MT_RELEASE);
-		_(HOLD_INITIATED);
-		_(HOLD);
-		_(RETRIEVE_INITIATED);
-		_(RECONNECT_PENDING);
-		_(TERMINATED);
-		_(SWAP_INITIATED);
-#undef _
-	}
-	return "<UNKNOWN>";
-}
-
-char const *isi_call_message_id_name(enum isi_call_message_id value)
-{
-	switch (value) {
-#define _(X) case X: return #X
-		_(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);
-		_(COMMON_MESSAGE);
-#undef _
-	}
-	return "<UNKNOWN>";
-}
-
-char const *isi_call_isi_cause_name(enum isi_call_isi_cause value)
-{
-	switch (value)
-	{
-#define _(X) case CALL_CAUSE_ ## X: return "CAUSE_" #X
-		_(NO_CAUSE);
-		_(NO_CALL);
-		_(TIMEOUT);
-		_(RELEASE_BY_USER);
-		_(BUSY_USER_REQUEST);
-		_(ERROR_REQUEST);
-		_(COST_LIMIT_REACHED);
-		_(CALL_ACTIVE);
-		_(NO_CALL_ACTIVE);
-		_(INVALID_CALL_MODE);
-		_(SIGNALLING_FAILURE);
-		_(TOO_LONG_ADDRESS);
-		_(INVALID_ADDRESS);
-		_(EMERGENCY);
-		_(NO_TRAFFIC_CHANNEL);
-		_(NO_COVERAGE);
-		_(CODE_REQUIRED);
-		_(NOT_ALLOWED);
-		_(NO_DTMF);
-		_(CHANNEL_LOSS);
-		_(FDN_NOT_OK);
-		_(USER_TERMINATED);
-		_(BLACKLIST_BLOCKED);
-		_(BLACKLIST_DELAYED);
-		_(NUMBER_NOT_FOUND);
-		_(NUMBER_CANNOT_REMOVE);
-		_(EMERGENCY_FAILURE);
-		_(CS_SUSPENDED);
-		_(DCM_DRIVE_MODE);
-		_(MULTIMEDIA_NOT_ALLOWED);
-		_(SIM_REJECTED);
-		_(NO_SIM);
-		_(SIM_LOCK_OPERATIVE);
-		_(SIMATKCC_REJECTED);
-		_(SIMATKCC_MODIFIED);
-		_(DTMF_INVALID_DIGIT);
-		_(DTMF_SEND_ONGOING);
-		_(CS_INACTIVE);
-		_(SECURITY_MODE);
-		_(TRACFONE_FAILED);
-		_(TRACFONE_WAIT_FAILED);
-		_(TRACFONE_CONF_FAILED);
-		_(TEMPERATURE_LIMIT);
-		_(KODIAK_POC_FAILED);
-		_(NOT_REGISTERED);
-		_(CS_CALLS_ONLY);
-		_(VOIP_CALLS_ONLY);
-		_(LIMITED_CALL_ACTIVE);
-		_(LIMITED_CALL_NOT_ALLOWED);
-		_(SECURE_CALL_NOT_POSSIBLE);
-		_(INTERCEPT);
-#undef _
-	}
-	return "<UNKNOWN>";
-}
-
-char const *isi_call_gsm_cause_name(enum isi_call_gsm_cause value)
-{
-	switch (value)
-	{
-#define _(X) case CALL_GSM_CAUSE_ ## X: return "GSM_CAUSE_" #X
-		_(UNASSIGNED_NUMBER);
-		_(NO_ROUTE);
-		_(CH_UNACCEPTABLE);
-		_(OPER_BARRING);
-		_(NORMAL);
-		_(USER_BUSY);
-		_(NO_USER_RESPONSE);
-		_(ALERT_NO_ANSWER);
-		_(CALL_REJECTED);
-		_(NUMBER_CHANGED);
-		_(NON_SELECT_CLEAR);
-		_(DEST_OUT_OF_ORDER);
-		_(INVALID_NUMBER);
-		_(FACILITY_REJECTED);
-		_(RESP_TO_STATUS);
-		_(NORMAL_UNSPECIFIED);
-		_(NO_CHANNEL);
-		_(NETW_OUT_OF_ORDER);
-		_(TEMPORARY_FAILURE);
-		_(CONGESTION);
-		_(ACCESS_INFO_DISC);
-		_(CHANNEL_NA);
-		_(RESOURCES_NA);
-		_(QOS_NA);
-		_(FACILITY_UNSUBS);
-		_(COMING_BARRED_CUG);
-		_(BC_UNAUTHORIZED);
-		_(BC_NA);
-		_(SERVICE_NA);
-		_(BEARER_NOT_IMPL);
-		_(ACM_MAX);
-		_(FACILITY_NOT_IMPL);
-		_(ONLY_RDI_BC);
-		_(SERVICE_NOT_IMPL);
-		_(INVALID_TI);
-		_(NOT_IN_CUG);
-		_(INCOMPATIBLE_DEST);
-		_(INV_TRANS_NET_SEL);
-		_(SEMANTICAL_ERR);
-		_(INVALID_MANDATORY);
-		_(MSG_TYPE_INEXIST);
-		_(MSG_TYPE_INCOMPAT);
-		_(IE_NON_EXISTENT);
-		_(COND_IE_ERROR);
-		_(MSG_INCOMPATIBLE);
-		_(TIMER_EXPIRY);
-		_(PROTOCOL_ERROR);
-		_(INTERWORKING);
-#undef _
-	}
-	return "<UNKNOWN>";
-}
-
-char const *isi_call_cause_name(uint8_t cause_type, uint8_t cause)
-{
-	switch (cause_type)
-	{
-	case CALL_CAUSE_TYPE_DEFAULT:
-	case CALL_CAUSE_TYPE_CLIENT:
-	case CALL_CAUSE_TYPE_SERVER:
-		return isi_call_isi_cause_name(cause);
-	case CALL_CAUSE_TYPE_NETWORK:
-		return isi_call_gsm_cause_name(cause);
-	}
-	return "<UNKNOWN>";
-}
-
-static void isi_call_hex_dump(uint8_t const m[],
-			      size_t len,
-			      char const *name)
-{
-	char const *prefix;
-	char hex[3 * 16 + 1];
-	char ascii[16 + 1];
-	size_t i, j, k;
-
-	if (strncmp(name, "CALL_", 5))
-		prefix = "CALL ";
-	else
-		prefix = "";
-
-	DUMP("%s%s [%s=0x%02X len=%zu]:",
-	     prefix, name, "message_id", m[1], len);
-
-	strcpy(hex, " **"), j = 3;
-	strcpy(ascii, "."), k = 1;
-
-	for (i = 1; i < len; i++) {
-		sprintf(hex + j, " %02X", m[i]), j += 3;
-		ascii[k++] = g_ascii_isgraph(m[i]) ? m[i] : '.';
-
-		if ((i & 15) == 15) {
-			DUMP("    *%-48s : %.*s", hex, (int)k, ascii);
-			j = 0, k = 0;
-		}
-	}
-
-	if (j) {
-		DUMP("    *%-48s : %.*s", hex, (int)k, ascii);
-	}
-}
-
-void isi_call_debug(const void *restrict buf, size_t len, void *data)
-{
-	uint8_t const *m = buf;
-	char const *name;
-
-	m = buf, m--, len++, buf = m;
-
-	if (len < 4) {
-		DUMP("CALL: %s [len=%zu]", "RUNT", len);
-		return;
-	}
-
-	name = isi_call_message_id_name(m[1]);
-
-	isi_call_hex_dump(m, len, name);
-}