diff --git a/src/GNUmakefile b/src/GNUmakefile
index 9a52118..6e45445 100644
--- a/src/GNUmakefile
+++ b/src/GNUmakefile
@@ -1,8 +1,8 @@
-CPPFLAGS ?= -O0 -Wall
+CPPFLAGS ?= -g -O0 -Wall
 LIBS = -losmocore
 all: qxdm-log
 
-qxdm-log: framing.o serial.o qxdm-log.o config.o
+qxdm-log: framing.o serial.o qxdm-log.o config.o gprs_rlc.o gprs_mac.o diag_gsm.o protocol.o
 	$(CC) $(CPPFLAGS) -o $@ $^ $(LIBS)
 
 clean:
diff --git a/src/config.c b/src/config.c
index 90887bb..237eb82 100644
--- a/src/config.c
+++ b/src/config.c
@@ -25,7 +25,7 @@
 	uint8_t		data[0];
 } __attribute((packed));
 
-struct msgb *gen_log_config_set_mask(uint32_t last_item)
+struct msgb *gen_log_config_set_mask(uint32_t equip_id, uint32_t last_item)
 {
 	struct msgb *msg = msgb_alloc(MAX_PACKET, "Diag Tx");
 	struct diag_log_config_set_mask *dlcsm;
@@ -35,7 +35,7 @@
 	dlcsm = (struct diag_log_config_set_mask *) msg->l2h;
 	dlcsm->hdr.msg_type = DIAG_LOG_CONFIG_F;
 	dlcsm->hdr.operation = LOG_CONFIG_SET_MASK_OP;
-	dlcsm->equip_id = 5;
+	dlcsm->equip_id = equip_id;
 	dlcsm->last_item = last_item;
 	msg->l3h = msgb_put(msg, dlcsm->last_item/8);
 
diff --git a/src/config.h b/src/config.h
index 1b74fde..39bf4ad 100644
--- a/src/config.h
+++ b/src/config.h
@@ -4,5 +4,5 @@
 
 struct msgb;
 
-struct msgb *gen_log_config_set_mask(uint32_t last_item);
+struct msgb *gen_log_config_set_mask(uint32_t equip_id, uint32_t last_item);
 int log_config_set_mask_bit(struct msgb *msg, uint32_t bit_in);
diff --git a/src/diag_gsm.c b/src/diag_gsm.c
new file mode 100644
index 0000000..30fec29
--- /dev/null
+++ b/src/diag_gsm.c
@@ -0,0 +1,75 @@
+#include <osmocom/core/utils.h>
+#include <osmocom/core/msgb.h>
+
+#include "diagcmd.h"
+#include "diag_gsm.h"
+
+const struct value_string diag_gsm_rr_st_vals[] = {
+	{ DIAG_RR_ST_INACTIVE,		"INACTIVE" },
+	{ DIAG_RR_ST_GOING_ACTIVE,	"GOING_ACTIVE" },
+	{ DIAG_RR_ST_GOING_INACTIVE,	"GOING_INACTIVE" },
+	{ DIAG_RR_ST_CELL_SELECTION,	"CELL_SELECTION" },
+	{ DIAG_RR_ST_PLMN_LIST_CONSTRUCTION, "PLMN_LIST_CONSTR" },
+	{ DIAG_RR_ST_IDLE,		"IDLE" },
+	{ DIAG_RR_ST_CELL_RESELECTION,	"CELL_RESELECTION" },
+	{ DIAG_RR_ST_CONNECTION_PENDING, "CONNECTION_PENDING" },
+	{ DIAG_RR_ST_CHOOSE_CELL,	"CHOOSE_CELL" },
+	{ DIAG_RR_ST_DATA_TRANSFER,	"DATA_TRANSFER" },
+	{ DIAG_RR_ST_NO_CHANNELS,	"NO_CHANNELS" },
+	{ DIAG_RR_ST_CONNECTION_RELEASE, "CONNECTION_RELEASE" },
+	{ DIAG_RR_ST_EARLY_CAMPED_WAIT_FOR_SI, "EARLY_CAMPED_WAIT_SI" },
+	{ DIAG_RR_ST_W2G_INTERRAT_HO_PROGRESS, "IRAT_W2G_HO_PROGRESS" },
+	{ DIAG_RR_ST_W2G_INTERRAT_RESELECTION_PROGRESS, "IRAT_W2G_RESEL_PROGRESS" },
+	{ DIAG_RR_ST_W2G_INTERRAT_CC_ORDER_PROGRESS, "IRAT_W2G_CC_ORDER_PROGRESS" },
+	{ DIAG_RR_ST_G2W_INTERRAT_RESELECTION_PROGRESS, "IRAT_G2W_RESEL_PROGRESS" },
+	{ DIAG_RR_ST_WAIT_FOR_EARLY_PSCAN,	"WAIT_FOR_EARLY_PSCAN" },
+	{ DIAG_RR_ST_GRR,		"GRR" },
+	{ DIAG_RR_ST_G2W_INTERRAT_HO_PROGRESS, "IRAT_G2W_HO_PROGRESS" },
+	{ DIAG_RR_ST_BACKGROUND_PLMN_SEARCH, "BGROUND_PLMN_SEARCH" },
+	{ DIAG_RR_ST_W2G_SERVICE_REDIR_IN_PROGRESS, "W2G_SERVICE_REDIR_PROGRESS" },
+	{ DIAG_RR_ST_RESET,		"RESET" },
+	{ DIAG_RR_ST_W2G_BACKGROUND_PLN_SEARCH, "W2G_BGROUND_PLMN_SEARCH" },
+	{ 0, NULL }
+};
+
+const struct value_string diag_gprs_grr_st_vals[] = {
+	{ DIAG_GRR_ST_NULL,		"NULL" },
+	{ DIAG_GRR_ST_ACQUIRE,		"ACQUIRE" },
+	{ DIAG_GRR_ST_CAMPED,		"CAMPED" },
+	{ DIAG_GRR_ST_CONN_PEND,	"CONN_PEND" },
+	{ DIAG_GRR_ST_CELL_RESEL,	"CELL_RESEL" },
+	{ DIAG_GRR_ST_CELL_RESEL_G2W,	"CELL_RESEL_G2W" },
+	{ DIAG_GRR_ST_BG_PLMN_SEARCH,	"BG_PLMNN_SEARCH" },
+	{ DIAG_GRR_ST_PCCO,		"PCCO" },
+	{ 0, NULL }
+};
+
+const struct value_string diag_gprs_llme_st_vals[] = {
+	{ DIAG_GPRS_LLMES_TLLI_UNASS,	"TLLI_UNASSIGNED" },
+	{ DIAG_GPRS_LLMES_TLLI_ASS,	"TLLI_ASSIGNED" },
+	{ DIAG_GPRS_LLMES_TEST_MODE,	"TEST_MODE" },
+	{ 0, NULL }
+};
+
+
+
+/* GSM_GPRS_LOG_PACKET_REQ_F */
+struct diag_gsm_log_packet_req {
+	uint16_t code;
+	uint8_t zero_stats;
+	uint8_t addl_info;
+} __attribute__((packed));
+
+int diag_gsm_make_log_pack_req(uint16_t log_code, uint8_t zero_stats, uint8_t addl_info)
+{
+	struct msgb *msg = msgb_alloc_headroom(1024, 128, "GSM Log Packet Req");
+	struct diag_gsm_log_packet_req *glpr;
+
+	glpr = (struct diag_gsm_log_packet_req *) msgb_put(msg, sizeof(*glpr));
+	glpr->code = log_code;
+	glpr->zero_stats = zero_stats;
+	glpr->addl_info = addl_info;
+	diag_push_subsys_hdr(msg, DIAG_SUBSYS_GSM, GSM_GPRS_LOG_PACKET_REQ_F);
+
+	return msg;
+}
diff --git a/src/diag_gsm.h b/src/diag_gsm.h
new file mode 100644
index 0000000..dabc02e
--- /dev/null
+++ b/src/diag_gsm.h
@@ -0,0 +1,118 @@
+#pragma once
+
+#include <stdint.h>
+
+enum diag_gsm_cmd {
+	GSM_DIAG_VERNO_F		= 0,
+	GSM_STATUS_F			= 1,
+	GSM_TMC_STATE_RETRIEVAL_F	= 2,
+	GSM_DIAG_CALL_ORIG_F		= 3,
+	GSM_DIAG_CALL_END_F		= 4,
+	GSM_GPRS_LOG_PACKET_REQ_F	= 5,
+	DIAG_GSM_MAX_F			= 6,
+};
+
+/* LOG_GSM_RR_SIGNALING_MESSAGE_C */
+struct diag_gsm_rr_msg {
+	uint8_t chan_type;
+	uint8_t msg_type;
+	uint8_t length;
+	uint8_t data[0];
+} __attribute__((packed));
+
+enum diag_gsm_rr_st {
+	DIAG_RR_ST_INACTIVE		= 0,
+	DIAG_RR_ST_GOING_ACTIVE		= 1,
+	DIAG_RR_ST_GOING_INACTIVE	= 2,
+	DIAG_RR_ST_CELL_SELECTION	= 3,
+	DIAG_RR_ST_PLMN_LIST_CONSTRUCTION = 4,
+	DIAG_RR_ST_IDLE			= 5,
+	DIAG_RR_ST_CELL_RESELECTION	= 6,
+	DIAG_RR_ST_CONNECTION_PENDING	= 7,
+	DIAG_RR_ST_CHOOSE_CELL		= 8,
+	DIAG_RR_ST_DATA_TRANSFER	= 9,
+	DIAG_RR_ST_NO_CHANNELS		= 10,
+	DIAG_RR_ST_CONNECTION_RELEASE	= 11,
+	DIAG_RR_ST_EARLY_CAMPED_WAIT_FOR_SI= 12,
+	DIAG_RR_ST_W2G_INTERRAT_HO_PROGRESS= 13,
+	DIAG_RR_ST_W2G_INTERRAT_RESELECTION_PROGRESS = 14,
+	DIAG_RR_ST_W2G_INTERRAT_CC_ORDER_PROGRESS = 15,
+	DIAG_RR_ST_G2W_INTERRAT_RESELECTION_PROGRESS = 16,
+	DIAG_RR_ST_WAIT_FOR_EARLY_PSCAN	= 17,
+	DIAG_RR_ST_GRR			= 18,
+	DIAG_RR_ST_G2W_INTERRAT_HO_PROGRESS = 20,
+	DIAG_RR_ST_BACKGROUND_PLMN_SEARCH = 21,
+	DIAG_RR_ST_W2G_SERVICE_REDIR_IN_PROGRESS = 22,
+	DIAG_RR_ST_RESET		= 23,
+	DIAG_RR_ST_W2G_BACKGROUND_PLN_SEARCH = 24,
+};
+extern const struct value_string diag_gsm_rr_st_vals[25];
+
+/* LOG_GSM_RR_STATE_C */
+struct diag_gsm_rr_state {
+	uint8_t state;
+	uint8_t substate;
+	uint8_t status;
+	uint8_t mode;
+} __attribute__((packed));
+
+enum diag_gprs_grr_st {
+	DIAG_GRR_ST_NULL	= 0,
+	DIAG_GRR_ST_ACQUIRE	= 1,
+	DIAG_GRR_ST_CAMPED	= 2,
+	DIAG_GRR_ST_CONN_PEND	= 3,
+	DIAG_GRR_ST_CELL_RESEL	= 4,
+	DIAG_GRR_ST_CELL_RESEL_G2W	= 6,
+	DIAG_GRR_ST_BG_PLMN_SEARCH	= 7,
+	DIAG_GRR_ST_PCCO	= 8,
+};
+extern const struct value_string diag_gprs_grr_st_vals[9];
+
+/* LOG_GPRS_GRR_STATE_C */
+struct diag_gprs_grr_state {
+	uint8_t	active_state;
+	uint8_t grr_state;
+} __attribute__((packed));
+
+
+enum diag_gprs_llme_state {
+	DIAG_GPRS_LLMES_TLLI_UNASS	= 0,
+	DIAG_GPRS_LLMES_TLLI_ASS	= 1,
+	DIAG_GPRS_LLMES_TEST_MODE	= 2,
+};
+const struct value_string diag_gprs_llme_st_vals[4];
+
+/* LOG_GPRS_LLC_ME_INFO_C */
+struct diag_gprs_llme_info {
+	uint8_t state;
+	uint8_t xid_version;
+	uint32_t tlli_new;
+	uint32_t tlli_old;
+	uint8_t enc_alg;
+	uint8_t enc_key[8];
+	uint32_t input_offset_iov_ui;
+} __attribute__((packed));
+
+/* LOG_GPRS_LLC_PDU_STATS_C */
+struct diag_gprs_llc_stats {
+	uint8_t	sapi;
+	uint32_t ack_l3pdu_tx;
+	uint32_t ack_octet_tx;
+	uint32_t ack_l3pdu_retrans;
+	uint32_t ack_octet_retrans;
+	uint32_t ack_l3pdu_rx;
+	uint32_t ack_octet_rx;
+	uint32_t unack_l3pdu_tx;
+	uint32_t unack_octet_tx;
+	uint32_t unack_l3pdu_rx;
+	uint32_t unack_octet_rx;
+	uint32_t llpdu_tx;
+	uint32_t llpdu_rx;
+	uint32_t llpdu_fcs_err;
+	uint32_t llpdu_frm_rej;
+	uint32_t llpdu_tlli_err;
+	uint32_t llpdu_addr_err;
+	uint32_t llpdu_short_err;
+} __attribute__((packed));
+
+int diag_gsm_make_log_pack_req(uint16_t log_code, uint8_t zero_stats, uint8_t addl_info);
diff --git a/src/diag_wcdma.h b/src/diag_wcdma.h
new file mode 100644
index 0000000..af4562d
--- /dev/null
+++ b/src/diag_wcdma.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <stdint.h>
+
+enum diag_umts_rrc_chtype {
+	DIAG_UMTS_RRC_CHT_UL_CCCH	= 0,
+	DIAG_UMTS_RRC_CHT_DL_DCCH	= 1,
+	DIAG_UMTS_RRC_CHT_DL_CCCH	= 2,
+	DIAG_UMTS_RRC_CHT_DL_BCCH	= 3,
+	DIAG_UMTS_RRC_CHT_DL_BCCH_BCH	= 4,
+	DIAG_UMTS_RRC_CHT_DL_BCCH_FACH	= 5,
+	DIAG_UMTS_RRC_CHT_DL_PCCH	= 6,
+};
+
+/* LOG_WCDMA_SIGNALING_MSG_C */
+struct diag_umts_rrc_msg {
+	uint8_t		chan_type;
+	uint8_t		rb_id;
+	uint16_t	length;
+	uint8_t		msg[0];
+} __attribute__((packed));
+
diff --git a/src/gprs_mac.h b/src/gprs_mac.h
index 3149351..cc499b3 100644
--- a/src/gprs_mac.h
+++ b/src/gprs_mac.h
@@ -5,6 +5,7 @@
 	IDLE_MODE,
 	TRANSFER_MODE,
 };
+extern struct value_string gprs_mac_mode_vals[4];
 
 enum gprs_mac_null_substates {
 	NULL_INACTIVE,
@@ -20,6 +21,7 @@
 	NULL_DTM_GTTP_UL_CON,
 	NULL_RESET,
 };
+extern struct value_string gprs_mac_null_substate_vals[13];
 
 enum gprs_mac_idle_substates {
 	IDLE_PASSIVE,
@@ -31,6 +33,7 @@
 	IDLE_UL_1PHASE_CONT_RES,
 	IDLE_DL_ASS,
 };
+extern struct value_string gprs_mac_idle_substate_vals[9];
 
 enum gprs_mac_transfer_substates {
 	TRANSFER_INACTIVE,
@@ -47,6 +50,7 @@
 	TRANSFER_CONCURRENT_DYNAMIC_REALLOC,
 	TRANSFER_CONCURRENT_DL_REASSIGN_DYNAMIC_REALLOC,
 };
+extern struct value_string gprs_mac_transfer_substate_vals[14];
 
 /* LOG_GPRS_MAC_STATE_C */
 struct gprs_mac_state_change {
@@ -76,7 +80,7 @@
 } __attribute__((packed));
 
 /* LOG_GPRS_MAC_UL_TBF_ESTABLISH_C */
-struct gprs_mcc_ul_tbf_est {
+struct gprs_mac_ul_tbf_est {
 	uint8_t tbf_req_cause;
 	uint8_t acc_granted;
 	uint8_t radio_prio;
@@ -120,6 +124,7 @@
 	PBCCH_CHANNEL		= 0x82,
 	DL_PACCH_CHANNEL	= 0x83,
 };
+extern struct value_string gprs_mac_chan_type_vals[8];
 
 enum gprs_mac_msg_type {
 	PACKET_CELL_CHANGE_FAILURE		= 0x00,
@@ -139,6 +144,7 @@
 	PACKET_CS_REQUEST			= 0x0e,
 	PACKET_CHANNEL_REQUEST			= 0x20,
 };
+extern struct value_string gprs_mac_msg_type_vals[17];
 
 struct evt_gprs_mac_msg {
 	uint8_t msg_type;
diff --git a/src/gprs_rlc.c b/src/gprs_rlc.c
index 31e7128..7ea5437 100644
--- a/src/gprs_rlc.c
+++ b/src/gprs_rlc.c
@@ -2,7 +2,7 @@
 
 #include "gprs_rlc.h"
 
-struct value_string gprs_rlc_ul_state_vals[] = {
+struct value_string gprs_rlc_ul_state_vals[8] = {
 	{ US_NULL,		"US_NULL" },
 	{ US_AWAIT_ASS,		"US_AWAIT_ASS" },
 	{ US_ACK_XFER,		"US_AWAIT_XFER" },
@@ -13,7 +13,7 @@
 	{ 0, NULL }
 };
 
-struct value_string gprs_rlc_ul_substate_vals[] = {
+struct value_string gprs_rlc_ul_substate_vals[5] = {
 	{ RALS_NULL,		"RALS_NULL" },
 	{ RALS_AWAIT_TX_COMPLETE, "RALS_AWAIT_TX_COMPLETE" },
 	{ RALS_CURRENT_PDU_TX_COMPLETED, "RALS_CURRENT_PDU_TX_COMPLETED" },
@@ -21,7 +21,7 @@
 	{ 0, NULL }
 };
 
-struct value_string gprs_rlc_dl_state_vals[] = {
+struct value_string gprs_rlc_dl_state_vals[7] = {
 	{ DS_NULL,		"DS_NULL" },
 	{ DS_RX_ACK,		"DS_RX_ACK" },
 	{ DS_RX_UNACK,		"DS_RX_UNACK" },
diff --git a/src/gprs_rlc.h b/src/gprs_rlc.h
index 545eaef..d577c8d 100644
--- a/src/gprs_rlc.h
+++ b/src/gprs_rlc.h
@@ -26,6 +26,7 @@
 	US_TEST_MODE,
 	US_AWAIT_RECOVERY,
 };
+extern struct value_string gprs_rlc_ul_state_vals[8];
 
 enum gprs_rlc_ul_substate {
 	RALS_NULL,
@@ -33,6 +34,7 @@
 	RALS_CURRENT_PDU_TX_COMPLETED,
 	RALS_COMPLETE,
 };
+extern struct value_string gprs_rlc_ul_substate_vals[5];
 
 enum gprs_rlc_dl_state {
 	DS_NULL,
@@ -42,6 +44,7 @@
 	DS_RX_UNACK_PENDING_RELEASE,
 	DS_TEST_MODE,
 };
+extern struct value_string gprs_rlc_dl_state_vals[7];
 
 struct gprs_rlc_ul_stats {
 	uint8_t	rlc_ul_state;
@@ -119,6 +122,8 @@
 	EGPRS_HEADER_TYPE_2,
 	EGPRS_HEADER_TYPE_3
 };
+extern struct value_string gprs_rlc_hdr_type_vals[5];
+
 
 /* LOG_EGPRS_RLC_DL_HEADER_C */
 struct gprs_rlc_dl_header {
diff --git a/src/log_codes_gsm.h b/src/log_codes_gsm.h
index 19d1f07..457e046 100644
--- a/src/log_codes_gsm.h
+++ b/src/log_codes_gsm.h
@@ -1,6 +1,17 @@
 #pragma once
 
 enum diag_log_code_gsm {
+	LOG_GSM_POWER_SCAN_C				= 0x64,
+	LOG_GSM_FCCH_DECODE_C				= 0x65,
+	LOG_GSM_NCELL_ACQ_C				= 0x75,
+	LOG_GSM_AFC_ADJUST_C				= 0x7c,
+	LOG_GSM_MON_BURST_C				= 0x82,
+	LOG_GSM_BCCH_BURST_METRICS_C			= 0x85,
+	LOG_GSM_GL1_HW_CMD_C				= 0x8d,
+	LOG_GSM_RR_STATE_C				= 0x12c,
+	LOG_GSM_RR_SIGNALING_MESSAGE_C			= 0x12f,
+
+
 	LOG_GSM_RR_CONTROL_CHANNEL_PARAMS_C		= 306,
 
 	LOG_GPRS_INDICATORS_C				= 500,
@@ -16,7 +27,7 @@
 	LOG_GPRS_RR_PSI2_C				= 510,
 	LOG_GPRS_RR_PSI3_C				= 511,
 	LOG_GPRS_RLC_UL_ABNRML_RLS_COUNTS_C		= 512,
-	LOG_GPRS_RLC_UL_EVENT_COUNTS_C			= 512,
+	LOG_GPRS_RLC_UL_EVENT_COUNTS_C			= 513,
 	LOG_GPRS_RLC_UL_STATS_C				= 514,
 	LOG_EGPRS_RLC_UL_HEADER_C			= 517,
 	LOG_EGPRS_RLC_DL_HEADER_C			= 518,
diff --git a/src/log_codes_wcdma.h b/src/log_codes_wcdma.h
new file mode 100644
index 0000000..d19f82f
--- /dev/null
+++ b/src/log_codes_wcdma.h
@@ -0,0 +1,8 @@
+#pragma once
+
+enum diag_log_code_umts {
+	LOG_WCDMA_RRC_STATES_C				= 0x125,
+	LOG_WCDMA_RRC_PROTOCOL_ERRORS_C			= 0x126,
+	LOG_WCDMA_CELL_ID_C				= 0x127,
+	LOG_WCDMA_SIGNALING_MSG_C			= 0x12f,
+};
diff --git a/src/protocol.c b/src/protocol.c
new file mode 100644
index 0000000..64a7ae2
--- /dev/null
+++ b/src/protocol.c
@@ -0,0 +1,14 @@
+#include <osmocom/core/msgb.h>
+#include "protocol.h"
+#include "diagcmd.h"
+
+int diag_push_subsys_hdr(struct msgb *msg, uint8_t subsys, uint8_t code)
+{
+	struct diagpkt_subsys_hdr *ssh;
+	ssh = (struct diagpkt_subsys_hdr *) msgb_push(msg, sizeof(*ssh));
+	ssh->command = DIAG_SUBSYS_CMD_F;
+	ssh->subsys_id = subsys;
+	ssh->subsys_cmd_code = code;
+
+	return 0;
+}
diff --git a/src/protocol.h b/src/protocol.h
index 49463b2..13a2da9 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -22,4 +22,55 @@
 	uint8_t		data[0];	/* two NULL terminated strings from here */
 } __attribute__((packed));
 
+
+/* message header */
+struct diag_msg_hdr {
+	uint8_t		cmd_code;
+	uint8_t		timestamp_type;
+	uint8_t		num_args;
+	uint8_t		drop_count;
+	uint64_t	ts;
+} __attribute__((packed));
+
+/* message descriptor */
+struct diag_msg_desc {
+	uint16_t	line;
+	uint16_t	subsys_id;
+	uint16_t	subsys_mask;
+} __attribute__((packed));
+
+/* message header for DIAG_EXT_MSG_F */
+struct diag_msg_ext {
+	struct diag_msg_hdr	hdr;
+	struct diag_msg_desc	desc;
+	uint32_t		args[0];	/* see hdr.num_args */
+	/* followed by null-terminated strings */
+} __attribute__((packed));
+
+
+/* message header for DIAG_LOG_F */
+struct diag_log_hdr {
+	uint8_t		cmd_code;
+	uint8_t		more;
+	uint16_t	len;
+	uint8_t		data[0];
+} __attribute__((packed));
+
+struct log_hdr {
+	uint16_t	len;
+	uint16_t	code;
+	uint64_t	ts;
+	uint8_t		data[0];
+} __attribute__((packed));
+
+
+/* extended DIAG packet, */
+struct diagpkt_subsys_hdr {
+	uint8_t		command;	/* DIAG_SUBSYS_CMD_F */
+	uint8_t		subsys_id;
+	uint8_t		subsys_cmd_code;
+} __attribute__((packed));
+
+int diag_push_subsys_hdr(struct msgb *msg, uint8_t subsys, uint8_t code);
+
 #endif
diff --git a/src/qxdm-log.c b/src/qxdm-log.c
index f58c875..b9074e4 100644
--- a/src/qxdm-log.c
+++ b/src/qxdm-log.c
@@ -1,5 +1,6 @@
 
 #include <stdlib.h>
+#include <inttypes.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <string.h>
@@ -16,10 +17,17 @@
 #include "protocol.h"
 #include "serial.h"
 #include "config.h"
+#include "diagcmd.h"
+#include "diag_gsm.h"
+#include "log_codes_gsm.h"
+#include "log_codes_wcdma.h"
+#include "diag_wcdma.h"
+#include "gprs_rlc.h"
+#include "gprs_mac.h"
 
 char *DumpBYTEs(unsigned char *p, long n, int nBytesPerRow /* = 16 */, char *szLineSep /* = "\n" */, int bRaw /* = FALSE */, const char *szIndent /* = "" */)
 {
-  long i;
+  int i;
   char szBuf[20];
   static char szRes[4 * 1024];
 
@@ -169,9 +177,220 @@
 	return 0;
 }
 
-static int do_read(int fd, uint8_t *data)
+static void handle_rr_sig_msg(struct log_hdr *lh, struct msgb *msg)
 {
-	uint8_t buf[MAX_PACKET];
+	struct diag_gsm_rr_msg *rm = (struct diag_gsm_rr_msg *) msgb_data(msg);
+
+	printf("RR: %02x %02x %u: %s\n", rm->chan_type, rm->msg_type,
+		rm->length, osmo_hexdump(msgb_data(msg), rm->length));
+}
+
+static void handle_rr_state_msg(struct log_hdr *lh, struct msgb *msg)
+{
+	struct diag_gsm_rr_state *rrs = (struct diag_gsm_rr_state *) msgb_data(msg);
+	printf("RR-STATE { state=%s, substate=%u, status=%u, mode=%u }\n",
+		get_value_string(diag_gsm_rr_st_vals, rrs->state)
+		, rrs->substate, rrs->status, rrs->mode);
+
+}
+
+static void handle_grr_state_msg(struct log_hdr *lh, struct msgb *msg)
+{
+	struct diag_gprs_grr_state *rrs = (struct diag_gprs_grr_state *) msgb_data(msg);
+
+	printf("GRR-STATE { active=%u, state=%s }\n", rrs->active_state,
+		get_value_string(diag_gprs_grr_st_vals, rrs->grr_state));
+}
+
+static void handle_rrc_sig_msg(struct log_hdr *lh, struct msgb *msg)
+{
+	struct diag_umts_rrc_msg *rrm = (struct diag_umts_rrc_msg *) msgb_data(msg);
+
+	printf("RRC: %u %u %u: %s\n", rrm->chan_type, rrm->rb_id, rrm->length,
+		osmo_hexdump(msgb_data(msg), rrm->length));
+}
+
+static void handle_rlc_ul_abnrml_rls(struct log_hdr *lh, struct msgb *msg)
+{
+	struct gprs_rlc_ul_abnrml_rls_counts *arc;
+	arc = (struct gprs_rlc_ul_abnrml_rls_counts *) msgb_data(msg);
+
+	printf("RLC-UL-ABNRML-RLS-COUNTS { access_reject_cnt=%u, arc_retry_cnt=%u, arc_wo_retry_cnt=%u, arc_sys_info_cnt=%u }",
+		arc->access_reject_cnt, arc->arc_retry_cnt, arc->arc_wo_retry_cnt, arc->arc_sys_info_cnt);
+}
+
+static void handle_mac_sign_msg(struct log_hdr *lh, struct msgb *msg)
+{
+	struct gprs_mac_signalling_msg *msm;
+	msm = (struct gprs_mac_signalling_msg *) msgb_data(msg);
+	printf("MAC-SIGN-MSG { chan_type=%s, msg_type=%s, msg=%s }\n",
+		get_value_string(gprs_mac_chan_type_vals, msm->chan_type),
+		get_value_string(gprs_mac_msg_type_vals, msm->msg_type),
+			osmo_hexdump(msm->msg, msm->msg_len));
+}
+
+static void handle_llc_me_info(struct log_hdr *lh, struct msgb *msg)
+{
+	struct diag_gprs_llme_info *gli;
+	gli = (struct diag_gprs_llme_info *) msgb_data(msg);
+	printf("LLC-ME-INFO { state=%s, xid_version=%u, tlli_new=0x%08x, tlli_old=0x%08x, gea=%u, key=%s }\n",
+		get_value_string(diag_gprs_llme_st_vals, gli->state), gli->xid_version,
+		gli->tlli_new, gli->tlli_old, gli->enc_alg,
+		osmo_hexdump_nospc(gli->enc_key, sizeof(gli->enc_key)));
+}
+
+static void handle_llc_pdu_stats(struct log_hdr *lh, struct msgb *msg)
+{
+	struct diag_gprs_llc_stats *gls;
+	gls = (struct diag_gprs_llc_stats *) msgb_data(msg);
+	printf("LLC-PDU-STATS-ACK { sap=%u, l3pdu_tx=%u, octet_tx=%u, octet_retrans=%u, l3pdu_rx=%u, octet_rx=%u }\n",
+		gls->sapi, gls->ack_l3pdu_tx, gls->ack_octet_tx, gls->ack_l3pdu_retrans, gls->ack_l3pdu_rx, gls->ack_octet_rx);
+	printf("LLC-PDU-STATS-UNACK { sapi=%u, l3pdu_tx=%u, octet_tx=%u, l3pdu_rx=%u, octet_rx=%u }\n",
+		gls->sapi, gls->unack_l3pdu_tx, gls->unack_octet_tx, gls->unack_l3pdu_rx, gls->unack_octet_rx);
+	printf("LLC-PDU-STATS-LLPDU { tx=%u, rx=%u, fcs_err=%u, frm_rej=%u, tlli_err=%u, addr_err=%u, short_err=%u }\n",
+		gls->llpdu_tx, gls->llpdu_rx, gls->llpdu_fcs_err, gls->llpdu_frm_rej, gls->llpdu_tlli_err, gls->llpdu_addr_err, gls->llpdu_short_err);
+}
+
+static void handle_mac_state(struct log_hdr *lh, struct msgb *msg)
+{
+	struct gprs_mac_state_change *msc;
+	msc = (struct gprs_mac_state_change *) msgb_data(msg);
+	const char *name = "";
+
+	switch (msc->mac_mode) {
+	case NULL_MODE:
+		name = get_value_string(gprs_mac_null_substate_vals, msc->mac_null_fsm_state);
+		break;
+	case IDLE_MODE:
+		name = get_value_string(gprs_mac_idle_substate_vals, msc->mac_idle_fsm_state);
+		break;
+	case TRANSFER_MODE:
+		name = get_value_string(gprs_mac_transfer_substate_vals, msc->mac_transfer_fsm_state);
+		break;
+	}
+
+	printf("MAC-STATE { mode=%s, state=%s }\n",
+		get_value_string(gprs_mac_mode_vals, msc->mac_mode), name);
+}
+
+static void handle_mac_dl_tbf_est(struct log_hdr *lh, struct msgb *msg)
+{
+	struct gprs_mac_dl_tbf_est *dte;
+	dte = (struct gprs_mac_dl_tbf_est *) msgb_data(msg);
+
+	printf("MAC-DL-TBF-EST { tfi=%u, rlc_mode=%u, dl_ts_bmap=0x%x, is_egprs=%u, egprs_win_size=%u, egprs_link_qual_mode=%u, bep_period2=%u }\n",
+		dte->dl_tfi, dte->rlc_mode, dte->dl_ts_bmap, dte->is_egprs_tbf, dte->egprs_win_size, dte->egprs_link_qual_mode, dte->bep_period2);
+}
+
+static void handle_mac_ul_tbf_est(struct log_hdr *lh, struct msgb *msg)
+{
+	struct gprs_mac_ul_tbf_est *ute;
+	ute = (struct gprs_mac_ul_tbf_est *) msgb_data(msg);
+
+	printf("MAC-UL-TBF-EST { tbf_req_cause=%u, acc_granted=%u, radio_prio=%u, peak_tput=%u, ul_tfi=%u, rlc_mode=%u, ul_ts_bmap=0x%x, is_egprs=%u, egprs_win_size=%u, resegment=%u, bep_period2=%u }\n",
+		ute->tbf_req_cause, ute->acc_granted, ute->radio_prio, ute->peak_tput, ute->ul_tfi, ute->rlc_mode, ute->ul_ts_bmap, ute->is_egprs_tbf, ute->egprs_win_size, ute->resegment, ute->bep_period2);
+}
+
+static void handle_rlc_ul_evt_cnt(struct log_hdr *lh, struct msgb *msg)
+{
+	struct gprs_rlc_ul_event_counts *uec;
+	uec = (struct gprs_rlc_ul_event_counts *) msgb_data(msg);
+
+	printf("RLC-UL-EVT-CNT { llc_event_cnt=%u, mac_event_cnt=%u, pl1_event_cnt=%u, tmr_event_cnt=%u }\n",
+		uec->llc_event_cnt, uec->mac_event_cnt, uec->pl1_event_cnt, uec->tmr_event_cnt);
+}
+
+static void handle_rlc_ul_stats(struct log_hdr *lh, struct msgb *msg)
+{
+	struct gprs_rlc_ul_stats *uls;
+	uls = (struct gprs_rlc_ul_stats *) msgb_data(msg);
+
+	printf("RLC-UL-STATS { state=%s(%s), FIXME... }\n",
+		get_value_string(gprs_rlc_ul_state_vals, uls->rlc_ul_state),
+		get_value_string(gprs_rlc_ul_substate_vals, uls->rlc_ul_substate));
+}
+
+static void handle_rlc_dl_stats(struct log_hdr *lh, struct msgb *msg)
+{
+	struct gprs_rlc_dl_stats *dls;
+	dls = (struct gprs_rlc_dl_stats *) msgb_data(msg);
+
+	printf("RLC-DL-STATS { state=%s, FIXME... }\n",
+		get_value_string(gprs_rlc_dl_state_vals, dls->rlc_dl_state));
+}
+
+static void handle_rlc_rel(struct log_hdr *lh, struct msgb *msg)
+{
+	struct gprs_rlc_release_ind *rli;
+	rli = (struct gprs_rlc_release_ind *) msgb_data(msg);
+	char ud = 'D';
+
+	if (lh->code == LOG_GPRS_RLC_UL_RELEASE_IND_C)
+		ud ='U';
+
+	printf("RLC-%cL-RELEASE { tfi=%u, cause=%u }\n", ud, rli->tfi, rli->cause);
+}
+
+
+
+struct log_dispatch_tbl {
+	uint16_t code;
+	void (*handler)(struct log_hdr *lh, struct msgb *msg);
+};
+
+#define GSM(x)	(0x5000 + x)
+#define UMTS(x)	(0x4000 + x)
+
+static const struct log_dispatch_tbl log_tbl[] = {
+	{ GSM(LOG_GSM_RR_SIGNALING_MESSAGE_C), handle_rr_sig_msg },
+	{ GSM(LOG_GSM_RR_STATE_C), handle_rr_state_msg },
+	{ GSM(LOG_GPRS_LLC_ME_INFO_C), handle_llc_me_info },
+	{ GSM(LOG_GPRS_LLC_PDU_STATS_C), handle_llc_pdu_stats },
+	{ GSM(LOG_GPRS_GRR_STATE_C), handle_grr_state_msg },
+	{ GSM(LOG_GPRS_RLC_UL_ABNRML_RLS_COUNTS_C), handle_rlc_ul_abnrml_rls },
+	{ GSM(LOG_GPRS_RLC_UL_EVENT_COUNTS_C), handle_rlc_ul_evt_cnt },
+	{ GSM(LOG_GPRS_RLC_UL_RELEASE_IND_C), handle_rlc_rel },
+	{ GSM(LOG_GPRS_RLC_DL_RELEASE_IND_C), handle_rlc_rel },
+	{ GSM(LOG_GPRS_MAC_SIGNALLING_MESSAGE_C), handle_mac_sign_msg },
+	{ GSM(LOG_GPRS_MAC_STATE_C), handle_mac_state },
+	{ GSM(LOG_GPRS_MAC_DL_TBF_ESTABLISH_C), handle_mac_dl_tbf_est },
+	{ GSM(LOG_GPRS_MAC_UL_TBF_ESTABLISH_C), handle_mac_ul_tbf_est },
+	{ GSM(LOG_GPRS_RLC_UL_STATS_C), handle_rlc_ul_stats },
+	{ GSM(LOG_GPRS_RLC_DL_STATS_C), handle_rlc_dl_stats },
+	{ UMTS(LOG_WCDMA_SIGNALING_MSG_C), handle_rrc_sig_msg },
+};
+
+static void diag_log_handle(struct msgb *msg)
+{
+	struct diag_log_hdr *dlh;
+	struct log_hdr *lh;
+	int i;
+
+	dlh = (struct diag_log_hdr *) msg->data;
+	/* FIXME: verify length */
+	msg->l3h = msgb_pull(msg, sizeof(*dlh));
+
+	lh = (struct log_hdr *) msg->l3h;
+	/* FIXME: verify length */
+	msgb_pull(msg, sizeof(*lh));
+
+	for (i = 0; i < ARRAY_SIZE(log_tbl); i++) {
+		if (log_tbl[i].code == lh->code) {
+			log_tbl[i].handler(lh, msg);
+			return;
+		}
+	}
+
+	printf("LOG(0x%04x, %"PRIu64"u, %u): %s\n", lh->code, lh->ts, lh->len,
+		osmo_hexdump(lh->data, lh->len));
+}
+
+/*********/
+
+static int do_read(int fd)
+{
+	uint8_t buf[MAX_PACKET*2];
+	struct msgb *msg = msgb_alloc(MAX_PACKET, "DIAG Rx");
 	int rc;
 
 	rc = read(fd, buf, sizeof(buf));
@@ -180,71 +399,136 @@
 		exit(EXIT_FAILURE);
 	}
 
-	rc = frame_unpack(buf, rc, data);	
-	if (rc <= 0)
-		return 0;
+	rc = frame_unpack(buf, rc, msgb_data(msg));
+	if (rc <= 0) {
+		msgb_free(msg);
+		return rc;
+	}
+	msg->l2h = msgb_put(msg, rc);
 
-
-	switch (data[0]) {
-	case 0x79:
-		dump_log(data, rc);
+	switch (msg->l2h[0]) {
+	case DIAG_LOG_F:
+		diag_log_handle(msg);
+		break;
+	case DIAG_EXT_MSG_F:
+		dump_log(msgb_data(msg), msgb_length(msg));
 		break;
 	default:
 		printf("Got %d data of payload\n", rc); 
-		printf("%s\n", DumpBYTEs(data, rc, 16, "\n", 0, ""));
+		printf("%s\n", DumpBYTEs(msgb_data(msg), msgb_length(msg), 16, "\n", 0, ""));
 		break;
 	};
 
+	msgb_free(msg);
+
 	return rc;
 }
 
 static void do_configure(int fd)
 {
-	static uint8_t timestamp[] = { 0x1D };
-#if 0
+	static uint8_t timestamp[] = { DIAG_TS_F };
 	static const uint8_t enable_evt_report[] = {
-		0x60, 0x01
+		DIAG_EVENT_REPORT_F, 0x01
 	};
-#endif
 	static const uint8_t disable_evt_report[] = {
-		0x60, 0x00
+		DIAG_EVENT_REPORT_F, 0x00
 	};
 	static const uint8_t extended_report_cfg[] = {
-		0x7D, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		/* command code */
+		DIAG_EXT_MSG_CONFIG_F,
+		/* sub command */
+		0x04,
+		/* subsystem ID range start */
+		0x00, 0x00,
+		/* subsystem ID range end */
+		0x00, 0x00,
+		/* pad */
+		0x00, 0x00,
+		/* array of runtime masks */
 		0x02, 0x00, 0x00, 0x00,
 	};
 
-	uint8_t data[MAX_PACKET];
-
 	/* TODO: introduce a wait for response kind of method */
 	transmit_packet(fd, timestamp, sizeof(timestamp));
-	do_read(fd, data);
+	do_read(fd);
 
 	/* enable|disable the event report */
 #if 0
 	transmit_packet(fd, enable_evt_report, sizeof(enable_evt_report));
-	do_read(fd, data);
-#endif
+	do_read(fd);
+#else
 	transmit_packet(fd, disable_evt_report, sizeof(disable_evt_report));
-	do_read(fd, data);
+	do_read(fd);
+#endif
 
 	transmit_packet(fd, extended_report_cfg, sizeof(extended_report_cfg));
-	do_read(fd, data);
+	do_read(fd);
 
-	struct msgb *msg = gen_log_config_set_mask(1064);
-	log_config_set_mask_bit(msg, 306);
-	log_config_set_mask_bit(msg, 544);
-	log_config_set_mask_bit(msg, 545);
+	printf("GSM\n");
+	struct msgb *msg = gen_log_config_set_mask(5, 1064);
+#if 0
+	for (int i = 0; i < 1064; i++)
+		log_config_set_mask_bit(msg, i);
+#endif
+
+	log_config_set_mask_bit(msg, LOG_GSM_RR_CONTROL_CHANNEL_PARAMS_C);
+	log_config_set_mask_bit(msg, LOG_GSM_RR_SIGNALING_MESSAGE_C);
+	log_config_set_mask_bit(msg, LOG_GSM_RR_STATE_C);
+
+	log_config_set_mask_bit(msg, LOG_GPRS_GRR_STATE_C);
+
+	log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_ABNRML_RLS_COUNTS_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_EVENT_COUNTS_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_STATS_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_RLC_DL_STATS_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_ACKNACK_PARAMS_VER2_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_RLC_DL_ACKNACK_PARAMS_VER2_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_RELEASE_IND_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_RLC_DL_RELEASE_IND_C);
+	log_config_set_mask_bit(msg, LOG_EGPRS_RLC_DL_HEADER_C);
+	log_config_set_mask_bit(msg, LOG_EGPRS_RLC_UL_HEADER_C);
+
+	log_config_set_mask_bit(msg, LOG_GPRS_LLC_ME_INFO_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_LLC_PDU_STATS_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_LLC_PERIODIC_STATS_C);
+
+	log_config_set_mask_bit(msg, LOG_GPRS_SNDCP_UL_TCP_HDR_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_SNDCP_DL_TCP_HDR_C);
 	log_config_set_mask_bit(msg, 546);
 	log_config_set_mask_bit(msg, 547);
-	log_config_set_mask_bit(msg, 553);
+	log_config_set_mask_bit(msg, LOG_GPRS_MAC_STATE_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_MAC_SIGNALLING_MESSAGE_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_MAC_UL_TBF_ESTABLISH_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_MAC_DL_TBF_ESTABLISH_C);
+	log_config_set_mask_bit(msg, LOG_EGPRS_MAC_UL_ACKNACK_C);
+	log_config_set_mask_bit(msg, LOG_EGPRS_MAC_DL_ACKNACK_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_MAC_UL_TBF_RELEASE_C);
+	log_config_set_mask_bit(msg, LOG_GPRS_MAC_DL_TBF_RELEASE_C);
+
 	transmit_msgb(fd, msg);
+	do_read(fd);
+
+	printf("WCDMA\n");
+	msg = gen_log_config_set_mask(4, 1064);
+#if 0
+	for (int i = 0; i < 1064; i++)
+		log_config_set_mask_bit(msg, i);
+#endif
+	log_config_set_mask_bit(msg, 0x125);
+	log_config_set_mask_bit(msg, 0x126);
+	log_config_set_mask_bit(msg, 0x127);
+	log_config_set_mask_bit(msg, 0x128);
+	log_config_set_mask_bit(msg, 0x129);
+	log_config_set_mask_bit(msg, LOG_WCDMA_SIGNALING_MSG_C);
+
+	transmit_msgb(fd, msg);
+	do_read(fd);
+
 }
 
 int main(int argc, char **argv)
 {
-	uint8_t data[MAX_PACKET];
-	int flags;
+	int flags, i;
 
 	int fd, rc;
 	if (argc < 2) {
@@ -280,6 +564,18 @@
 
 	do_configure(fd);
 
-	while (1)
-		do_read(fd, data);
+	while (1) {
+		i++;
+		do_read(fd);
+#if 0
+		/* some packets need to be explicitly requested and
+		 * don't appear automatically */
+		if (i % 10 == 0) {
+			struct msgb *msg = diag_gsm_make_log_pack_req(LOG_GPRS_LLC_PDU_STATS_C , 0, 0);
+			printf("Requesting LLC stats...(%s)\n", osmo_hexdump(msgb_data(msg), msgb_length(msg)));
+			transmit_msgb(fd, msg);
+		}
+#endif
+
+	}
 }