diff --git a/pcu/GPRS_Components.ttcn b/pcu/GPRS_Components.ttcn
index 7eff399..c0630a6 100644
--- a/pcu/GPRS_Components.ttcn
+++ b/pcu/GPRS_Components.ttcn
@@ -44,16 +44,83 @@
 import from Native_Functions all;
 import from SGSN_Components all;
 
+type union PacketDlAssignChan {
+	PacketDlAssign		ccch,
+	PacketDlAssignment	pacch
+};
+
+type record DlTbf {
+	GsmRrMessage		rr_imm_ass,
+	PacketDlAssignChan	ass,
+	uint5_t			tfi,
+	AckNackDescription	acknack_desc
+};
+
+type union PacketUlAssignChan {
+	PacketUlAssign		ccch,
+	EgprsUlAss		ccch_egprs,
+	PacketUlAssignment	pacch
+};
+
+type record UlTbf {
+	GsmRrMessage		rr_imm_ass,
+	PacketUlAssignChan	ass,
+	uint5_t			tfi,
+	boolean			is_egprs,
+	uint14_t		bsn,
+	CodingScheme		tx_cs_mcs
+};
+
+type record GprsMS {
+	hexstring	imsi,
+	GprsTlli	tlli,
+	uint16_t	ra,
+	uint8_t		ra_is_11bit,
+	PCUIF_BurstType	burst_type,
+	TimingAdvance	ta,
+	int16_t		lqual_cb,
+	UlTbf		ul_tbf optional, /* TODO: Only 1 UL tbf supported for now */
+	DlTbf		dl_tbf optional /* TODO: Only 1 DL tbf supported for now */
+};
+type record of GprsMS GprsMSArray;
+
+template AckNackDescription t_AckNackDescription_init := {
+	final_ack := '0'B,
+	starting_seq_nr := 0,
+	receive_block_bitmap := '0000000000000000000000000000000000000000000000000000000000000000'B
+}
+
+template (value) GprsMS t_GprsMS_def := {
+        imsi := f_gen_imsi(42),
+        tlli := '00000001'O,
+        ra := bit2int(chan_req_def),
+        ra_is_11bit := 0,
+        burst_type := BURST_TYPE_0,
+        ta := 0,
+        lqual_cb := 0,
+        ul_tbf := omit,
+        dl_tbf := omit
+};
+
 type component MS_BTS_IFACE_CT {
 	/* Virtual BTS component */
 	var RAW_PCU_BTS_CT vc_BTS;
 	/* Connection to the BTS component (one for now) */
 	port RAW_PCU_MSG_PT BTS;
 
+	/* Support only 1 ms for now */
+	var GprsMS g_ms[1];
+
 	/* Value at which Countdown Procedure starts. Announced by network (GPRS Cell Options as per TS 04.60 Chapter 12.24) */
 	var uint4_t g_bs_cv_max := 4;
 }
 
+function f_init_gprs_ms(template (value) GprsMS ms_params := t_GprsMS_def) runs on MS_BTS_IFACE_CT
+{
+	g_ms[0] := valueof(ms_params);
+}
+
+
 function f_shutdown(charstring file, integer line,
 		    boolean final := false)
 runs on MS_BTS_IFACE_CT {
@@ -74,10 +141,275 @@
 	mtc.stop;
 }
 
-template AckNackDescription t_AckNackDescription_init := {
-	final_ack := '0'B,
-	starting_seq_nr := 0,
-	receive_block_bitmap := '0000000000000000000000000000000000000000000000000000000000000000'B
+function f_ultbf_new_from_rr_imm_ass(in GsmRrMessage rr_imm_ass)
+runs on MS_BTS_IFACE_CT return UlTbf {
+	var UlTbf ul_tbf;
+
+	ul_tbf.rr_imm_ass := rr_imm_ass;
+	ul_tbf.bsn := 0;
+
+	/* Make sure we received an UL TBF Assignment */
+	if (match(rr_imm_ass, tr_IMM_TBF_ASS(dl := false, rest := tr_IaRestOctets_ULAss(?)))) {
+		ul_tbf.ass.ccch := rr_imm_ass.payload.imm_ass.rest_octets.hh.pa.uldl.ass.ul;
+		log("Rx Uplink TBF GPRS assignment: ", ul_tbf.ass.ccch);
+		ul_tbf.is_egprs := false;
+		if (match(ul_tbf.ass.ccch, tr_PacketUlDynAssign)) {
+			ul_tbf.tfi := ul_tbf.ass.ccch.dynamic.tfi_assignment;
+		} else if (match(ul_tbf.ass.ccch, tr_PacketUlSglAssign)) {
+			/* Nothing to do here  yet */
+		}
+	} else if (match(rr_imm_ass, tr_IMM_TBF_ASS(dl := false, rest := tr_IaRestOctets_EGPRSULAss(?)))) {
+		ul_tbf.ass.ccch_egprs := rr_imm_ass.payload.imm_ass.rest_octets.lh.egprs_ul;
+		log("Rx Uplink TBF EGPRS assignment: ", ul_tbf.ass.ccch_egprs);
+		ul_tbf.is_egprs := true;
+		if (match(ul_tbf.ass.ccch_egprs, tr_EgprsUlAssDynamic)) {
+			ul_tbf.tfi := ul_tbf.ass.ccch_egprs.dynamic.tfi_assignment;
+		} else if (match(ul_tbf.ass.ccch_egprs, tr_EgprsUlAssMultiblock)) {
+			/* Nothing to do here yet */
+		}
+	} else {
+		setverdict(fail, "Failed to match UL TBF Assignment: ", rr_imm_ass);
+		f_shutdown(__BFILE__, __LINE__);
+	}
+
+	setverdict(pass);
+	return ul_tbf;
+}
+
+function f_ultbf_new_from_ass_pacch(RlcmacDlBlock dl_block)
+runs on MS_BTS_IFACE_CT return UlTbf {
+	var UlTbf ul_tbf;
+
+	ul_tbf.ass.pacch := dl_block.ctrl.payload.u.ul_assignment;
+	ul_tbf.bsn := 0;
+	ul_tbf.tx_cs_mcs := f_rlcmac_dl_block_get_assigned_ul_cs_mcs(dl_block);
+	ul_tbf.tfi := f_rlcmac_dl_block_get_tfi(dl_block);
+	/* TODO: handle GlobalTfiOrTlli	 tfi_or_tlli from pkt_ul_ass */
+
+	/* TODO: support single block allocation */
+	if (match(dl_block, tr_RLCMAC_UL_PACKET_ASS_GPRS(?, tr_PktUlAssGprsDynamic(tr_DynamicAllocation(?))))) {
+		ul_tbf.tfi := dl_block.ctrl.payload.u.ul_assignment.gprs.dyn_block_alloc.ul_tfi_assignment;
+		ul_tbf.is_egprs := false;
+	}
+	if (match(dl_block, tr_RLCMAC_UL_PACKET_ASS_EGPRS(?, tr_PktUlAssEgprsDynamic(tr_DynamicAllocation(?))))) {
+		ul_tbf.tfi := dl_block.ctrl.payload.u.ul_assignment.egprs.dyn_block_alloc.ul_tfi_assignment;
+		ul_tbf.is_egprs := true;
+	}
+	return ul_tbf;
+}
+
+function f_dltbf_new_from_rr_imm_ass(in GsmRrMessage rr_imm_ass, template PacketDlAssign dl_ass := tr_PacketDlAssign(?))
+runs on MS_BTS_IFACE_CT return DlTbf {
+	var DlTbf dl_tbf;
+
+	dl_tbf.rr_imm_ass := rr_imm_ass;
+	dl_tbf.acknack_desc := valueof(t_AckNackDescription_init);
+
+	/* Make sure we received a DL TBF Assignment */
+	if (match(rr_imm_ass, tr_IMM_TBF_ASS(dl := true, rest := tr_IaRestOctets_DLAss(dl_ass)))) {
+		dl_tbf.ass.ccch := rr_imm_ass.payload.imm_ass.rest_octets.hh.pa.uldl.ass.dl;
+		log("Rx Downlink TBF assignment: ", dl_tbf.ass);
+	} else {
+		setverdict(fail, "Failed to match DL TBF Assignment: ", rr_imm_ass);
+		f_shutdown(__BFILE__, __LINE__);
+	}
+
+	/* TODO: match TLLI */
+	if (dl_tbf.ass.ccch.group1_present == '1'B) {
+		dl_tbf.tfi := dl_tbf.ass.ccch.group1.tfi_assignment;
+	} else {
+		setverdict(fail, "Immediate Assignment contains no DL TFI");
+		f_shutdown(__BFILE__, __LINE__);
+	}
+
+	setverdict(pass);
+	return dl_tbf;
+}
+
+/* TODO: get stuff from f_rx_rlcmac_dl_block_exp_pkt_ass */
+function f_dltbf_new_from_ass_pacch(RlcmacDlBlock dl_block)
+runs on MS_BTS_IFACE_CT return DlTbf {
+	var DlTbf dl_tbf;
+
+	dl_tbf.ass.pacch := dl_block.ctrl.payload.u.dl_assignment;
+	dl_tbf.tfi := f_rlcmac_dl_block_get_tfi(dl_block);
+	/* TODO: handle GlobalTfiOrTlli	 tfi_or_tlli from pkt_dl_ass */
+	dl_tbf.acknack_desc := valueof(t_AckNackDescription_init);
+	return dl_tbf;
+}
+
+function f_ms_use_ra(inout GprsMS ms, uint16_t ra, uint8_t ra_is_11bit := 0)
+runs on MS_BTS_IFACE_CT {
+	ms.ra_is_11bit := ra_is_11bit;
+	ms.ra := ra;
+	if (ra_is_11bit == 0) {
+		ms.burst_type := BURST_TYPE_0;
+	} else {
+		ms.burst_type := BURST_TYPE_1;
+	}
+}
+
+function f_ms_rx_imm_ass_ccch(inout GprsMS ms, template PCUIF_Sapi sapi := PCU_IF_SAPI_AGCH, template GsmRrMessage t_imm_ass := ?)
+runs on MS_BTS_IFACE_CT return GsmRrMessage {
+	var PCUIF_Message pcu_msg;
+	var GsmRrMessage rr_imm_ass;
+	var octetstring data;
+	timer T;
+
+	T.start(2.0);
+	alt {
+	[] BTS.receive(tr_PCUIF_DATA_REQ(bts_nr := 0, trx_nr := 0, ts_nr := 0,
+					 sapi := sapi, data := ?)) -> value pcu_msg {
+		/* On PCH the payload is prefixed with paging group (3 octets): skip it.
+		 * TODO: add an additional template parameter, so we can match it. */
+		if (pcu_msg.u.data_req.sapi == PCU_IF_SAPI_PCH) {
+			data := substr(pcu_msg.u.data_req.data, 3, pcu_msg.u.data_req.len - 3);
+		} else {
+			data := pcu_msg.u.data_req.data;
+		}
+
+		rr_imm_ass := dec_GsmRrMessage(data);
+		if (not match(rr_imm_ass, t_imm_ass)) {
+		        /* Not for us? Wait for more. */
+		        repeat;
+		}
+
+		log("Rx Immediate Assignment: ", rr_imm_ass);
+		f_pcuif_tx_data_cnf(pcu_msg);
+		setverdict(pass);
+		return rr_imm_ass;
+		}
+	[] BTS.receive { repeat; }
+	[] T.timeout {
+		setverdict(fail, "Timeout waiting for Immediate Assignment");
+		f_shutdown(__BFILE__, __LINE__);
+		}
+	}
+	return rr_imm_ass; /* make compiler happy */
+}
+
+function f_ms_rx_imm_ass_pacch(inout GprsMS ms, out uint32_t poll_fn, template RlcmacDlBlock t_imm_ass := ?)
+runs on MS_BTS_IFACE_CT return RlcmacDlBlock {
+	var RlcmacDlBlock dl_block;
+	var uint32_t dl_fn;
+
+	f_rx_rlcmac_dl_block(dl_block, dl_fn);
+	if (not match(dl_block, t_imm_ass)) {
+		setverdict(fail, "Failed to match Packet Assignment:", t_imm_ass);
+		f_shutdown(__BFILE__, __LINE__);
+	}
+
+	poll_fn := f_rrbp_ack_fn(dl_fn, dl_block.ctrl.mac_hdr.rrbp);
+
+	if (match(dl_block, tr_RLCMAC_UL_PACKET_ASS)) {
+	       ms.ul_tbf := f_ultbf_new_from_ass_pacch(dl_block);
+	       if (ms.ul_tbf.ass.pacch.identity.tlli.tlli != ms.tlli) {
+		       setverdict(fail, "Wrong TLLI ", ms.ul_tbf.ass.pacch.identity.tlli, " received vs exp ", ms.tlli);
+		       f_shutdown(__BFILE__, __LINE__);
+	       }
+	} else if (match(dl_block, tr_RLCMAC_DL_PACKET_ASS)) {
+		ms.dl_tbf := f_dltbf_new_from_ass_pacch(dl_block);
+		/* TODO: match tlli from ms.dl_tbf.ass.pacch with ms.tlli), or error */
+	} else {
+		setverdict(fail, "Should not happen:", dl_block);
+		f_shutdown(__BFILE__, __LINE__);
+	}
+
+	return dl_block;
+}
+
+function f_ms_establish_ul_tbf(inout GprsMS ms, uint32_t fn := 1337)
+runs on MS_BTS_IFACE_CT {
+	var GsmRrMessage rr_imm_ass;
+	var uint8_t exp_ra;
+
+	/* Send RACH.ind */
+	log("Sending RACH.ind on fn=", fn, " with RA=", ms.ra, ", TA=", ms.ta);
+	BTS.send(ts_PCUIF_RACH_IND(bts_nr := 0, trx_nr := 0, ts_nr := 0,
+				   ra := ms.ra, is_11bit := ms.ra_is_11bit,
+				   burst_type := ms.burst_type,
+				   fn := fn, arfcn := 871,
+				   qta := ms.ta * 4));
+
+	/* 3GPP TS 44.018, table 9.1.8.1, note 2b: Request Reference shall be set to 127
+	 * when Immediate Assignment is triggered by EGPRS Packet Channel Request. Here
+	 * we assume that 11 bit RA always contains EGPRS Packet Channel Request. */
+	if (ms.ra_is_11bit == 0) {
+		exp_ra := ms.ra;
+	} else {
+		exp_ra := 127;
+	}
+
+	/* Expect Immediate (TBF) Assignment on TS0/AGCH */
+	rr_imm_ass := f_ms_rx_imm_ass_ccch(ms, PCU_IF_SAPI_AGCH,
+	                                   tr_IMM_TBF_ASS(false, exp_ra, fn));
+
+	ms.ul_tbf := f_ultbf_new_from_rr_imm_ass(rr_imm_ass);
+}
+
+function f_ms_exp_dl_tbf_ass_ccch(inout GprsMS ms, template PCUIF_Sapi sapi := PCU_IF_SAPI_AGCH, template GsmRrMessage t_imm_ass := tr_IMM_TBF_ASS(true, ?, ?))
+runs on MS_BTS_IFACE_CT {
+	var GsmRrMessage rr_imm_ass;
+
+	rr_imm_ass := f_ms_rx_imm_ass_ccch(ms, sapi, t_imm_ass);
+	ms.dl_tbf := f_dltbf_new_from_rr_imm_ass(rr_imm_ass, tr_PacketDlAssign(ms.tlli));
+}
+
+/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
+function f_ms_tx_data_ind(inout GprsMS ms, octetstring data, uint32_t fn := 0)
+runs on MS_BTS_IFACE_CT {
+	f_pcuif_tx_data_ind(data, ms.lqual_cb, fn);
+}
+
+function f_ms_tx_ul_block(inout GprsMS ms, template (value) RlcmacUlBlock ul_data, uint32_t fn := 0)
+runs on MS_BTS_IFACE_CT return integer {
+	var octetstring data;
+	var integer padding_len;
+	/* Encode the payload of DATA.ind */
+	data := enc_RlcmacUlBlock(valueof(ul_data));
+	padding_len := 23 - lengthof(data);
+	data := f_pad_oct(data, 23, '00'O); /* CS-1 */
+
+	/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
+	f_ms_tx_data_ind(ms, data, fn);
+	return padding_len;
+}
+
+/* FIXME: Only supports sending CS-1 so far */
+function f_ms_tx_ul_data_block(inout GprsMS ms, octetstring payload, uint4_t cv := 15, boolean with_tlli := false, uint32_t fn := 0)
+runs on MS_BTS_IFACE_CT return integer {
+	var template (value) RlcmacUlBlock ul_data;
+	ul_data := t_RLCMAC_UL_DATA(tfi := ms.ul_tbf.tfi,
+				    cv := cv,
+				    bsn := ms.ul_tbf.bsn,
+				    blocks := {t_RLCMAC_LLCBLOCK(payload)});
+	if (with_tlli) {
+		ul_data.data.mac_hdr.tlli_ind := true;
+		ul_data.data.tlli := ms.tlli;
+	}
+	ms.ul_tbf.bsn := ms.ul_tbf.bsn + 1;
+	ms.ul_tbf.bsn := ms.ul_tbf.bsn mod 128; /* FIXME: EGPRS SNS: 2048 */
+	return f_ms_tx_ul_block(ms, ul_data, fn);
+
+}
+
+/* Send random payload for last "num_blocks" blocks in Ul TBF (ending with CV=0). */
+function f_ms_tx_ul_data_block_multi(inout GprsMS ms, integer num_blocks := 1, boolean with_tlli := false)
+runs on MS_BTS_IFACE_CT return octetstring {
+	var octetstring total_payload := ''O;
+
+	for (var integer i := 0; i < num_blocks; i := i + 1) {
+		var integer padding_len;
+		var octetstring payload := f_rnd_octstring(10);
+		/* Prepare a new UL block (CV, random payload) */
+		var integer cv := num_blocks - i - 1;
+		if (cv > g_bs_cv_max) {
+			cv := 15;
+		}
+		padding_len :=  f_ms_tx_ul_data_block(ms, payload, cv := cv, with_tlli := with_tlli)
+		total_payload := total_payload & payload & f_pad_oct(''O, padding_len, '00'O);
+	}
+	return total_payload;
 }
 
 function f_rlcmac_dl_block_get_tfi(RlcmacDlBlock dl_block)
@@ -93,6 +425,9 @@
 		if (match(dl_block, tr_RLCMAC_UL_PACKET_ASS_EGPRS(?, tr_PktUlAssEgprsDynamic(tr_DynamicAllocation(?))))) {
 			return dl_block.ctrl.payload.u.ul_assignment.egprs.dyn_block_alloc.ul_tfi_assignment;
 		}
+		if (match(dl_block, tr_RLCMAC_DL_PACKET_ASS(?))) {
+			return dl_block.ctrl.payload.u.dl_assignment.dl_tfi_assignment;
+		}
 	}
 	setverdict(fail, "DlBlock doesn't contain a TFI:", dl_block);
 	f_shutdown(__BFILE__, __LINE__);
@@ -169,6 +504,10 @@
 	BTS.send(pcu_msg_cnf);
 }
 
+////////////////////////
+// OLD APIs
+////////////////////////
+
 function f_pcuif_rx_imm_ass(out GsmRrMessage rr_imm_ass,
 			    template PCUIF_Sapi sapi := PCU_IF_SAPI_AGCH,
 			    template GsmRrMessage t_imm_ass := ?)
@@ -248,34 +587,6 @@
 				  tr_IMM_TBF_ASS(false, ra, fn));
 }
 
-function f_imm_ass_verify_ul_tbf_ass(in GsmRrMessage rr_imm_ass, out PacketUlAssign ul_tbf_ass, template PacketUlAssign ul_ass := tr_PacketUlDynAssign)
-runs on MS_BTS_IFACE_CT {
-
-	/* Make sure we received an UL TBF Assignment */
-	if (match(rr_imm_ass, tr_IMM_TBF_ASS(dl := false, rest := tr_IaRestOctets_ULAss(ul_ass)))) {
-		ul_tbf_ass := rr_imm_ass.payload.imm_ass.rest_octets.hh.pa.uldl.ass.ul;
-		log("Rx Uplink TBF assignment: ", ul_tbf_ass);
-		setverdict(pass);
-	} else {
-		setverdict(fail, "Failed to match UL TBF Assignment");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-}
-
-function f_imm_ass_verify_dl_tbf_ass(in GsmRrMessage rr_imm_ass, out PacketDlAssign dl_tbf_ass)
-runs on MS_BTS_IFACE_CT {
-
-	/* Make sure we received a DL TBF Assignment */
-	if (match(rr_imm_ass, tr_IMM_TBF_ASS(dl := true, rest := tr_IaRestOctets_DLAss(?)))) {
-		dl_tbf_ass := rr_imm_ass.payload.imm_ass.rest_octets.hh.pa.uldl.ass.dl;
-		log("Rx Downlink TBF assignment: ", dl_tbf_ass);
-		setverdict(pass);
-	} else {
-		setverdict(fail, "Failed to match DL TBF Assignment");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-}
-
 /* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
 function f_pcuif_tx_data_ind(octetstring data, int16_t lqual_cb := 0, uint32_t fn := 0)
 runs on MS_BTS_IFACE_CT {
@@ -299,23 +610,6 @@
 				      sapi := PCU_IF_SAPI_PDTCH)) -> value pcu_msg;
 }
 
-/* Expect an Immediate Assignment (paging) from PCU on PCUIF on specified sapi.  */
-function f_pcuif_rx_pch_imm_tbf_ass(out GsmRrMessage rr_imm_ass)
-runs on MS_BTS_IFACE_CT {
-	var PCUIF_Message pcu_msg;
-	var octetstring macblock;
-	BTS.receive(tr_PCUIF_DATA_REQ(bts_nr := 0, trx_nr := 0, ts_nr := 0,
-				      sapi := PCU_IF_SAPI_PCH)) -> value pcu_msg;
-	/* First 3 bytes contain paging group: */
-	macblock := substr(pcu_msg.u.data_req.data, 3, pcu_msg.u.data_req.len - 3);
-	rr_imm_ass := dec_GsmRrMessage(macblock);
-	if (not match(rr_imm_ass, tr_IMM_TBF_ASS())) {
-		setverdict(fail, "Failed to match Immediate Assignment: ", rr_imm_ass);
-		f_shutdown(__BFILE__, __LINE__);
-	}
-	f_pcuif_tx_data_cnf(pcu_msg);
-}
-
 /* Expect a Paging Request Type 1 from PCU on PCUIF on specified sapi.  */
 function f_pcuif_rx_pch_pag_req1(template MobileIdentityV mi1 := ?,
 				 template integer pag_group := ?)
@@ -353,56 +647,6 @@
 	return rr_pag_req1;
 }
 
-/* Send one rlcmac UL block adding necessary extra padding at the end.
- * returns length of extra padding added at the end, in octets.
- *  FIXME: Only supports CS-1 so far.
- */
-function f_tx_rlcmac_ul_block(template (value) RlcmacUlBlock ul_data, int16_t lqual_cb := 0, uint32_t fn := 0)
-runs on MS_BTS_IFACE_CT return integer {
-	var octetstring data;
-	var integer padding_len;
-	/* Encode the payload of DATA.ind */
-	data := enc_RlcmacUlBlock(valueof(ul_data));
-	padding_len := 23 - lengthof(data);
-	data := f_pad_oct(data, 23, '00'O); /* CS-1 */
-
-	/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-	f_pcuif_tx_data_ind(data, lqual_cb, fn);
-	return padding_len;
-}
-
-function f_tx_rlcmac_ul_n_blocks(uint5_t tfi, inout uint14_t bsn, integer num_blocks := 1, template (omit) GprsTlli tlli := omit)
-runs on MS_BTS_IFACE_CT return octetstring {
-	var octetstring total_payload := ''O;
-	var template (value) RlcmacUlBlock ul_data := t_RLCMAC_UL_DATA(
-		tfi := tfi,
-		cv := 15, /* num UL blocks to be sent (to be overridden in loop) */
-		bsn := 0, /* To be generated in loop */
-		blocks := { /* To be generated in loop */ });
-
-	if (not istemplatekind(tlli, "omit")) {
-		ul_data.data.mac_hdr.tlli_ind := true;
-		ul_data.data.tlli := tlli;
-	}
-
-	for (var integer i := 0; i < num_blocks; i := i + 1) {
-		var integer padding_len;
-		var octetstring payload := f_rnd_octstring(10);
-		/* Prepare a new UL block (CV, random payload) */
-		var integer cv := num_blocks - i - 1;
-		if (cv > g_bs_cv_max) {
-			cv := 15;
-		}
-		ul_data.data.mac_hdr.countdown := cv;
-		ul_data.data.mac_hdr.bsn := bsn + i;
-		ul_data.data.blocks := { valueof(t_RLCMAC_LLCBLOCK(payload)) };
-		padding_len := f_tx_rlcmac_ul_block(ul_data);
-		total_payload := total_payload & payload & f_pad_oct(''O, padding_len, '00'O);
-	}
-	bsn := valueof(ul_data.data.mac_hdr.bsn) + 1; /* update bsn to point to next one */
-	return total_payload;
-}
-
 function f_rx_rlcmac_dl_block(out RlcmacDlBlock dl_block, out uint32_t dl_fn, template (present) CodingScheme exp_cs_mcs := ?)
 runs on MS_BTS_IFACE_CT {
 	var PCUIF_Message pcu_msg;
@@ -443,46 +687,6 @@
 	}
 }
 
-function f_rx_rlcmac_dl_block_exp_pkt_ass(out RlcmacDlBlock dl_block, out uint32_t poll_fn)
-runs on MS_BTS_IFACE_CT {
-	var uint32_t dl_fn;
-
-	f_rx_rlcmac_dl_block(dl_block, dl_fn);
-	if (not match(dl_block, tr_RLCMAC_DL_PACKET_ASS())) {
-		setverdict(fail, "Failed to match Packet Downlink Assignment");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	poll_fn := f_rrbp_ack_fn(dl_fn, dl_block.ctrl.mac_hdr.rrbp);
-}
-
-function f_rx_rlcmac_dl_block_exp_pkt_ul_ass(out RlcmacDlBlock dl_block, out uint32_t poll_fn)
-runs on MS_BTS_IFACE_CT {
-        var uint32_t dl_fn;
-
-        f_rx_rlcmac_dl_block(dl_block, dl_fn);
-        if (not match(dl_block, tr_RLCMAC_UL_PACKET_ASS())) {
-                setverdict(fail, "Failed to match Packet Uplink Assignment");
-		f_shutdown(__BFILE__, __LINE__);
-        }
-
-	poll_fn := f_rrbp_ack_fn(dl_fn, dl_block.ctrl.mac_hdr.rrbp);
-}
-
-function f_rx_rlcmac_dl_block_exp_pkt_dl_ass(out RlcmacDlBlock dl_block, out uint32_t poll_fn)
-runs on MS_BTS_IFACE_CT {
-        var uint32_t dl_fn;
-
-        f_rx_rlcmac_dl_block(dl_block, dl_fn);
-        if (not match(dl_block, tr_RLCMAC_DL_PACKET_ASS())) {
-                setverdict(fail, "Failed to match Packet Downlink Assignment");
-		f_shutdown(__BFILE__, __LINE__);
-        }
-
-	poll_fn := f_rrbp_ack_fn(dl_fn, dl_block.ctrl.mac_hdr.rrbp);
-}
-
-
 function f_rx_rlcmac_dl_block_exp_pkt_pag_req(out RlcmacDlBlock dl_block)
 runs on MS_BTS_IFACE_CT {
 	var uint32_t dl_fn;
diff --git a/pcu/PCU_Tests.ttcn b/pcu/PCU_Tests.ttcn
index 9e7c92b..ca37431 100644
--- a/pcu/PCU_Tests.ttcn
+++ b/pcu/PCU_Tests.ttcn
@@ -253,9 +253,11 @@
 /* Test of correct Timing Advance at the time of TBF establishment
  * (derived from timing offset of the Access Burst). */
 testcase TC_ta_rach_imm_ass() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_msg;
-	var boolean ok;
+	var GprsMS ms;
 
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
@@ -263,16 +265,13 @@
 	 * at some point the PCU will fail to allocate a new TBF. */
 	for (var TimingAdvance ta := 0; ta < 64; ta := ta + 16) {
 		/* Establish an Uplink TBF (send RACH.ind with current TA) */
-		ok := f_establish_tbf(rr_msg, ta := ta);
-		if (not ok) {
-			setverdict(fail, "Failed to establish an Uplink TBF");
-			break;
-		}
+		ms.ta := ta;
+		f_ms_establish_ul_tbf(ms, fn := 1337 + ta);
 
 		/* Make sure Timing Advance IE matches out expectations */
-		if (rr_msg.payload.imm_ass.timing_advance != ta) {
+		if (ms.ul_tbf.rr_imm_ass.payload.imm_ass.timing_advance != ta) {
 			setverdict(fail, "Timing Advance mismatch: ",
-				   rr_msg.payload.imm_ass.timing_advance,
+				   ms.ul_tbf.rr_imm_ass.payload.imm_ass.timing_advance,
 				   " vs expected ", ta);
 			break;
 		}
@@ -286,30 +285,29 @@
  * IUT that causes it to send an unreasonable Timing Advance value > 0 despite
  * no active TBF exists at the moment of establishment (idle mode). */
 testcase TC_ta_idle_dl_tbf_ass() runs on RAW_PCU_Test_CT {
-	var OCT4 tlli := f_rnd_octstring(4);
-	var GsmRrMessage rr_imm_ass;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* SGSN sends some DL data, PCU will initiate Packet Downlink
 	 * Assignment on CCCH (PCH). We don't care about the payload. */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, f_rnd_octstring(10)));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass); // TODO: match by TLLI!
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, f_rnd_octstring(10)));
 
 	/* Make sure that Timing Advance is 0 (the actual value is not known yet).
 	 * As per 3GPP S 44.018, section 3.5.3.1.2, the network *shall* initiate
 	 * the procedures defined in 3GPP TS 44.060 or use the polling mechanism. */
-	if (not match(rr_imm_ass, tr_IMM_TBF_ASS(ta := 0))) {
-		setverdict(fail, "Timing Advance value doesn't match");
-	}
+	f_ms_rx_imm_ass_ccch(ms,  PCU_IF_SAPI_PCH, tr_IMM_TBF_ASS(ta := 0));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
@@ -460,9 +458,11 @@
 
 testcase TC_ta_ptcch_ul_multi_tbf() runs on RAW_PCU_Test_CT {
 	var template PacketUlAssign t_ul_tbf_ass;
-	var PacketUlAssign ul_tbf_ass[7];
-	var GsmRrMessage rr_msg[7];
-	var boolean ok;
+	var GprsMS ms;
+
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
@@ -472,30 +472,18 @@
 
 	/* Establish 7 Uplink TBFs (USF flag is 3 bits long, '111'B is reserved) */
 	for (var integer i := 0; i < 7; i := i + 1) {
-		ok := f_establish_tbf(rr_msg[i], ta := 0);
-		if (not ok) {
-			setverdict(fail, "Failed to establish an Uplink TBF #", i);
-			break;
-		}
-
-		/* Make sure we received an UL TBF Assignment */
-		if (match(rr_msg[i], tr_IMM_TBF_ASS(dl := false, rest := tr_IaRestOctets_ULAss(?)))) {
-			ul_tbf_ass[i] := rr_msg[i].payload.imm_ass.rest_octets.hh.pa.uldl.ass.ul;
-			log("Rx Uplink TBF assignment for #", i, ": ", ul_tbf_ass[i]);
-		} else {
-			setverdict(fail, "Failed to match UL TBF Assignment for #", i);
-			break;
-		}
+		/* Establish an Uplink TBF */
+		f_ms_establish_ul_tbf(ms);
 
 		/* We expect incremental TFI/USF assignment (dynamic allocation) */
 		t_ul_tbf_ass := tr_PacketUlDynAssign(tfi := i, usf := i);
-		if (not match(ul_tbf_ass[i], t_ul_tbf_ass)) {
+		if (not match(ms.ul_tbf.ass.ccch, t_ul_tbf_ass)) {
 			setverdict(fail, "Failed to match Packet Uplink Assignment for #", i);
 			break;
 		}
 
 		/* We also expect Timing Advance Index to be a part of the assignment */
-		if (ul_tbf_ass[i].dynamic.ta_index != i) {
+		if (ms.ul_tbf.ass.ccch.dynamic.ta_index != i) {
 			setverdict(fail, "Failed to match Timing Advance Index for #", i);
 			/* Keep going, the current OsmoPCU does not assign TA Index */
 		}
@@ -540,13 +528,14 @@
 private template integer CS4_lqual_dB_range := (12 .. infinity);
 
 testcase TC_cs_lqual_ul_tbf() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var PCUIF_Message pcu_msg;
-	var octetstring data;
-	var boolean ok;
-	var uint32_t unused_fn;
+	var GprsMS ms;
+	var uint32_t unused_fn, sched_fn;
+	var uint4_t cv;
+
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
@@ -555,47 +544,51 @@
 	f_pcuvty_set_link_quality_ranges();
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
+	f_ms_establish_ul_tbf(ms);
 
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
-
-	var template (value) RlcmacUlBlock ul_data := t_RLCMAC_UL_DATA(
-		tfi := ul_tbf_ass.dynamic.tfi_assignment,
-		cv := 15, /* 16 UL blocks to be sent (to be overridden in loop) */
-		bsn := 0, /* TODO: what should be here? */
-		blocks := { /* To be generated in loop */ });
-
-	/* HACK: patch missing TLLI; otherwise OsmoPCU rejects DATA.req */
-	ul_data.data.tlli := '00000001'O;
 
 	/* The actual / old link quality values. We need to keep track of the old
 	 * (basically previous) link quality value, because OsmoPCU actually
 	 * changes the coding scheme if not only the actual, but also the old
 	 * value leaves the current link quality range (window). */
-	var integer lqual := 0;
 	var integer lqual_old;
+	ms.lqual_cb := 0;
 
-	/* 16 UL blocks (0 .. 15 dB, step = 1 dB) */
-	for (var integer i := 0; i < 16; i := i + 1) {
-		/* Prepare a new UL block (CV, random payload) */
-		ul_data.data.mac_hdr.countdown := (15 - i);
-		ul_data.data.blocks := { valueof(t_RLCMAC_LLCBLOCK(f_rnd_octstring(10))) };
+	/* Send one UL block (with TLLI since we are in One-Phase Access
+	   contention resoultion) and make sure it is ACKED fine. */
+	/* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
+	/* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
+	f_ms_tx_ul_data_block(ms, f_rnd_octstring(16), cv := 15, with_tlli := true)
+	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
+	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
+	/* 16 UL blocks (0 .. 15 dB, step = 1 cB) */
+	for (var integer i := 150; i >= 0; i := i - 1) {
 		/* Update the old / actual link quality */
-		lqual_old := lqual;
-		lqual := i;
+		lqual_old := ms.lqual_cb;
+		ms.lqual_cb := 150 - i;
 
 		/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-		log("Sending DATA.ind with link quality (dB): ", lqual);
-		f_tx_rlcmac_ul_block(ul_data, lqual * 10);
+		log("Sending DATA.ind with link quality (dB): ", ms.lqual_cb);
+		if (i > g_bs_cv_max) {
+			cv := 15;
+		} else {
+			cv := i;
+		}
 
-		/* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
-		f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
+		f_ms_tx_ul_data_block(ms, f_rnd_octstring(10), cv := cv)
+
+		/* we will receive UL ACK/NACK from time to time. In that case, check CdCofing increases */
+		f_rx_rlcmac_dl_block(dl_block, unused_fn);
+		if (match(dl_block, tr_RLCMAC_DUMMY_CTRL())) {
+			continue;
+		}
+		if (not match(dl_block, tr_RLCMAC_UL_ACK_NACK_GPRS(ul_tfi := ?)) and
+		    not match(dl_block, tr_RLCMAC_UL_ACK_NACK_EGPRS(ul_tfi := ?))) {
+			setverdict(fail, "Failed to match Packet Uplink ACK / NACK:", dl_block);
+			f_shutdown(__BFILE__, __LINE__);
+		}
 
 		log("Rx Packet Uplink ACK / NACK with Channel Coding Command: ",
 		    dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd);
@@ -604,7 +597,7 @@
 		 * the link quality value on each iteration and not decreasing, there
 		 * is no need to check the both old and current link quality values. */
 		var template ChCodingCommand ch_coding;
-		select (lqual_old) {
+		select (lqual_old / 10) {
 		case (CS1_lqual_dB_range) { ch_coding := CH_CODING_CS1; }
 		case (CS2_lqual_dB_range) { ch_coding := CH_CODING_CS2; }
 		case (CS3_lqual_dB_range) { ch_coding := CH_CODING_CS3; }
@@ -621,13 +614,14 @@
 
 /* Test the max UL CS set by VTY works fine */
 testcase TC_cs_initial_ul() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var boolean ok;
-	var integer lqual_cb;
 	var ChCodingCommand last_ch_coding;
-	var uint32_t unused_fn;
+	var uint32_t unused_fn, sched_fn;
+	var GprsMS ms;
+
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
@@ -638,62 +632,52 @@
 	f_pcuvty_set_link_quality_ranges();
 
 	/* Take lqual (dB->cB) so that we stay in that CS */
-	lqual_cb := g_cs_lqual_ranges[2].low * 10;
+	ms.lqual_cb := g_cs_lqual_ranges[2].low * 10;
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
+	f_ms_establish_ul_tbf(ms);
 
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	/* Send one UL block (with TLLI since we are in One-Phase Access
+	   contention resoultion) and make sure it is ACKED fine. */
+	/* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
+	/* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
+	f_ms_tx_ul_data_block(ms, f_rnd_octstring(16), cv := 15, with_tlli := true)
+	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
+	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
-	var template (value) RlcmacUlBlock ul_data := t_RLCMAC_UL_DATA(
-		tfi := ul_tbf_ass.dynamic.tfi_assignment,
-		cv := 3, /* 8 UL blocks to be sent (to be overridden in loop) */
-		bsn := 0, /* TODO: what should be here? */
-		blocks := { /* To be generated in loop */ });
+	/* Send UL blocks, until we receive UL ACK/NACK and check we are in same initial CS: */
+	while (true) {
+		f_ms_tx_ul_data_block(ms, f_rnd_octstring(10), cv := 15);
+		f_rx_rlcmac_dl_block(dl_block, unused_fn);
+		if (match(dl_block, tr_RLCMAC_DUMMY_CTRL())) {
+			continue;
+		}
 
-	/* HACK: patch missing TLLI; otherwise OsmoPCU rejects DATA.req */
-	ul_data.data.tlli := '00000001'O;
+		if (not match(dl_block, tr_RLCMAC_UL_ACK_NACK_GPRS(ul_tfi := ?)) and
+		    not match(dl_block, tr_RLCMAC_UL_ACK_NACK_EGPRS(ul_tfi := ?))) {
+			setverdict(fail, "Failed to match Packet Uplink ACK / NACK:", dl_block);
+			f_shutdown(__BFILE__, __LINE__);
+			break;
+		}
 
-	/* 3 UL blocks, check we are in same initial CS: */
-	for (var integer i := 0; i < 3; i := i + 1) {
-		/* Prepare a new UL block (CV, random payload) */
-		ul_data.data.mac_hdr.countdown := (7 - i);
-		ul_data.data.blocks := { valueof(t_RLCMAC_LLCBLOCK(f_rnd_octstring(10))) };
-
-		/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-		f_tx_rlcmac_ul_block(ul_data, lqual_cb);
-
-		/* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
-		f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
 		last_ch_coding := dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd;
+		break;
 	}
-
 	if (last_ch_coding != CH_CODING_CS3) {
 		setverdict(fail, "Channel Coding does not match our expectations (CS-3): ", last_ch_coding);
+		f_shutdown(__BFILE__, __LINE__);
 	}
 
 	/* Remaining UL blocks are used to make sure regardless of initial
 	/* lqual, we can go lower at any time */
-
+	 /* 0 dB, make sure we downgrade CS */
+	ms.lqual_cb := 0;
 	/* 5 UL blocks, check we are in same initial CS: */
-	for (var integer i := 3; i < 8; i := i + 1) {
-		/* Prepare a new UL block (CV, random payload) */
-		ul_data.data.mac_hdr.countdown := (7 - i);
-		ul_data.data.blocks := { valueof(t_RLCMAC_LLCBLOCK(f_rnd_octstring(10))) };
-
-		/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-		f_tx_rlcmac_ul_block(ul_data, 0); /* 0 dB, make sure we downgrade CS */
-
-		/* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
-		f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
-
-		last_ch_coding := dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd;
-	}
+	f_ms_tx_ul_data_block_multi(ms, 5);
+	/* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
+	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
+	last_ch_coding := dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd;
 
 	if (last_ch_coding != CH_CODING_CS1) {
 		setverdict(fail, "Channel Coding does not match our expectations (CS-1): ", last_ch_coding);
@@ -704,12 +688,14 @@
 
 /* Test the max UL CS set by VTY works fine */
 testcase TC_cs_max_ul() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var boolean ok;
 	var ChCodingCommand last_ch_coding;
-	var uint32_t unused_fn;
+	var uint32_t unused_fn, sched_fn;
+	var GprsMS ms;
+
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
@@ -720,38 +706,22 @@
 	f_pcuvty_set_link_quality_ranges();
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
+	f_ms_establish_ul_tbf(ms);
 
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	/* Send one UL block (with TLLI since we are in One-Phase Access
+	   contention resoultion) and make sure it is ACKED fine. */
+	/* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
+	/* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
+	f_ms_tx_ul_data_block(ms, f_rnd_octstring(16), cv := 15, with_tlli := true)
+	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
+	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
-	var template (value) RlcmacUlBlock ul_data := t_RLCMAC_UL_DATA(
-		tfi := ul_tbf_ass.dynamic.tfi_assignment,
-		cv := 15, /* 16 UL blocks to be sent (to be overridden in loop) */
-		bsn := 0, /* TODO: what should be here? */
-		blocks := { /* To be generated in loop */ });
+	ms.lqual_cb :=  40*10; /* 40 dB */
+	f_ms_tx_ul_data_block_multi(ms, 16);
 
-	/* HACK: patch missing TLLI; otherwise OsmoPCU rejects DATA.req */
-	ul_data.data.tlli := '00000001'O;
-
-	/* 16 UL blocks */
-	for (var integer i := 0; i < 16; i := i + 1) {
-		/* Prepare a new UL block (CV, random payload) */
-		ul_data.data.mac_hdr.countdown := (15 - i);
-		ul_data.data.blocks := { valueof(t_RLCMAC_LLCBLOCK(f_rnd_octstring(10))) };
-
-		/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
-		f_tx_rlcmac_ul_block(ul_data, 40*10); /* 40 dB */
-
-		/* Enqueue RTS.req, expect DATA.req with UL ACK from the PCU */
-		f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
-
-		last_ch_coding := dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd;
-	}
+	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
+	last_ch_coding := dl_block.ctrl.payload.u.ul_ack_nack.gprs.ch_coding_cmd;
 
 	if (last_ch_coding != CH_CODING_CS3) {
 		setverdict(fail, "Channel Coding does not match our expectations (CS-3): ", last_ch_coding);
@@ -763,18 +733,15 @@
 /* Verify PCU drops TBF after some time of inactivity. */
 testcase TC_t3169() runs on RAW_PCU_Test_CT {
 	var PCUIF_info_ind info_ind;
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var PCUIF_Message pcu_msg;
-	var octetstring data;
-	var boolean ok;
 	var uint32_t unused_fn;
-	var OCT4 tlli := '00000001'O;
-	var uint14_t bsn := 0;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	info_ind := valueof(ts_PCUIF_INFO_default);
 	/* Set timer to 1 sec (default 5) to speedup test: */
@@ -785,31 +752,22 @@
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Send one UL block (with TLLI since we are in One-Phase Access
 	   contention resoultion) and make sure it is ACKED fine */
-	f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, 1, tlli);
+	f_ms_tx_ul_data_block(ms, f_rnd_octstring(10), cv := 1, with_tlli := true)
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
-	/* UL block should be received in SGSN */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id));
+	/* UL block should NOT be received in SGSN, since we didn't get CV=0 */
 
 	/* Wait until T3169 fires (plus 1 extra sec to make sure) */
 	f_sleep(int2float(info_ind.t3169) + 1.0);
 
 	/* Send an UL block once again, the TBF should be gone by now so no ACK */
-	bsn := 0;
-	f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, 1);
+	f_ms_tx_ul_data_block(ms, f_rnd_octstring(10), cv := 0)
 	f_rx_rlcmac_dl_block_exp_dummy(dl_block);
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
@@ -819,181 +777,149 @@
  * release of prev DL TBF due to MS staying in PDCH for a while (T3192, in PCU
  * T3193) after DL TBF release */
 testcase TC_t3193() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketDlAssign dl_tbf_ass;
 	var RlcmacDlBlock dl_block;
 	var octetstring data := f_rnd_octstring(10);
 	var boolean ok;
 	var uint32_t sched_fn;
 	var uint32_t dl_fn;
-	var OCT4 tlli := '00000001'O;
+	var GprsMS ms;
 	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* SGSN sends some DL data, PCU will page on CCCH (PCH) */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_exp_dl_tbf_ass_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS: */
 	f_sleep(X2002);
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0);
 
 	/* ACK the DL block */
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
-	/* we are done with the DL-TBF here so far, let's clean up our local state: */
-	ack_nack_desc := valueof(t_AckNackDescription_init)
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc),
+			 f_dl_block_ack_fn(dl_block, dl_fn));
 
 	/* Now that final DL block is ACKED and TBF is released, T3193 in PCU
-	   (T3192 in MS) was started and until it fires the MS will be abailable
+	   (T3192 in MS) was started and until it fires the MS will be available
 	   on PDCH in case new data arrives from SGSN. Let's verify it: */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_rx_rlcmac_dl_block_exp_pkt_ass(dl_block, sched_fn);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_rx_imm_ass_pacch(ms, sched_fn, tr_RLCMAC_DL_PACKET_ASS);
+
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* Now that we confirmed the new assignment in the dl-tbf, lets receive the data and ack it */
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0);
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc),
+			 f_dl_block_ack_fn(dl_block, dl_fn));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
 
 /* Verify PCU handles correctly Countdown Procedure based on BS_CV_MAX */
 testcase TC_countdown_procedure() runs on RAW_PCU_Test_CT  {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var boolean ok;
 	var uint32_t sched_fn;
-	var OCT4 tlli := '00000001'O;
-	var uint14_t bsn := 1;
-	var PDU_BSSGP bssgp_pdu;
 	var octetstring total_payload;
-	var integer padding_len;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Send one UL block (with TLLI since we are in One-Phase Access
 	   contention resoultion) and make sure it is ACKED fine. */
-	   total_payload := f_rnd_octstring(16); /* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
-	var template (value) RlcmacUlBlock ul_data := t_RLCMAC_UL_DATA_TLLI(
-		tfi := ul_tbf_ass.dynamic.tfi_assignment,
-		cv := 15, /* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
-		bsn := 0,
-		blocks := { valueof(t_RLCMAC_LLCBLOCK(total_payload)) },
-		tlli := tlli);
-
-	f_tx_rlcmac_ul_block(ul_data, 0);
+	total_payload := f_rnd_octstring(16); /* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
+	/* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
+	f_ms_tx_ul_data_block(ms, total_payload, cv := 15, with_tlli := true)
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* Send enough blocks to test whole procedure: Until Nth block
 	   (N=BS_CV_MAX), CV=15 is sent, and then the decreasing countdown value is sent.
 	 */
-	total_payload := total_payload & f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, 20);
+	total_payload := total_payload & f_ms_tx_ul_data_block_multi(ms, 20);
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* receive one message on BSSGP with all aggregated data in payload: */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id, total_payload));
+	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.cell_id, total_payload));
 }
 
 /* Test scenario where MS wants to send some data on PDCH against SGSN and it is
  * answered, so TBFs for uplink and later for downlink are created.
  */
 private function f_TC_mo_ping_pong_1phase_access(template (present) CodingScheme exp_cs_mcs := ?) runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
-	var PacketDlAssign dl_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var PCUIF_Message pcu_msg;
 	var octetstring data := f_rnd_octstring(10);
-	var boolean ok;
 	var uint32_t sched_fn;
 	var uint32_t dl_fn;
-	var OCT4 tlli := '00000001'O;
-	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
-	var uint14_t bsn := 0;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Send one UL block (with TLLI since we are in One-Phase Access
 	   contention resoultion) and make sure it is ACKED fine */
-	f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, 1, tlli);
+	f_ms_tx_ul_data_block_multi(ms, 1, with_tlli := true);
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* UL block should be received in SGSN */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id));
+	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.cell_id));
 
 	/* Now SGSN sends some DL data, PCU will page on CCCH (PCH) */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_exp_dl_tbf_ass_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS: */
 	f_sleep(X2002);
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0, exp_cs_mcs);
 
 	/* ACK the DL block */
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc),
+			     f_dl_block_ack_fn(dl_block, dl_fn));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
@@ -1013,20 +939,13 @@
 						 template (present) CodingScheme exp_ul_cs_mcs := ?,
 						 template (present) CodingScheme exp_dl_cs_mcs := ?)
 runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
-	var PacketDlAssign dl_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var PCUIF_Message pcu_msg;
 	var octetstring data := f_rnd_octstring(10);
-	var boolean ok;
 	var uint32_t sched_fn;
 	var uint32_t dl_fn;
 	var uint32_t unused_fn;
-	var OCT4 tlli := '00000001'O;
-	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
-	var CodingScheme cs_mcs;
-	var uint14_t bsn := 0;
+	var GprsMS ms;
+
 	/* 0111 0xxx: Single block packet access; one block period on a PDCH is needed for two phase packet access or other RR signalling purpose. */
 	var uint16_t ra := oct2int('70'O);
 	if (g_force_two_phase_access) {
@@ -1038,55 +957,52 @@
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass, ra := ra);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
+	f_ms_use_ra(ms, ra, ra_is_11bit := 0);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass, tr_PacketUlSglAssign);
+	if (not match(ms.ul_tbf.ass.ccch, tr_PacketUlSglAssign)) {
+		setverdict(fail, "Wrong Packet Uplink Assignment received: ", ms.ul_tbf.ass.ccch, " vs exp: ", tr_PacketUlSglAssign);
+		f_shutdown(__BFILE__, __LINE__);
+	}
 
 	/* Send PACKET RESOURCE REQUEST to upgrade to EGPRS
 	 * (see 3GPP TS 04.60 "7.1.3.1 Initiation of the Packet resource request procedure")
 	 */
-	f_tx_rlcmac_ul_block(ts_RLC_UL_CTRL_ACK(valueof(ts_RlcMacUlCtrl_PKT_RES_REQ(tlli, ms_racap))), 0);
-	f_rx_rlcmac_dl_block_exp_pkt_ul_ass(dl_block, sched_fn);
-	if (dl_block.ctrl.payload.u.ul_assignment.identity.tlli.tlli != tlli) {
-		setverdict(fail, "Wrong TLLI ", dl_block.ctrl.payload.u.ul_assignment.identity.tlli, " received vs exp ", tlli);
-		f_shutdown(__BFILE__, __LINE__);
-	}
-	cs_mcs := f_rlcmac_dl_block_get_assigned_ul_cs_mcs(dl_block);
-	if (not match(cs_mcs, exp_ul_cs_mcs)) {
-		setverdict(fail, "Wrong CS_MCS ", cs_mcs, " received vs exp ", exp_ul_cs_mcs);
+	f_ms_tx_ul_block(ms, ts_RLC_UL_CTRL_ACK(valueof(ts_RlcMacUlCtrl_PKT_RES_REQ(ms.tlli, ms_racap))), 0);
+	f_ms_rx_imm_ass_pacch(ms, sched_fn, tr_RLCMAC_UL_PACKET_ASS);
+	if (not match(ms.ul_tbf.tx_cs_mcs, exp_ul_cs_mcs)) {
+		setverdict(fail, "Wrong CS_MCS ", ms.ul_tbf.tx_cs_mcs, " received vs exp ", exp_ul_cs_mcs);
 		f_shutdown(__BFILE__, __LINE__);
 	}
 
 	/* Send one UL block (without TLLI since we are in Second-Phase Access)
 	   and make sure it is ACKED fine */
-	f_tx_rlcmac_ul_n_blocks(f_rlcmac_dl_block_get_tfi(dl_block), bsn, 1);  /* TODO: send using cs_mcs */
+	f_ms_tx_ul_data_block_multi(ms, 1, with_tlli := true);  /* TODO: send using cs_mcs */
 
-	//f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* UL block should be received in SGSN */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id));
+	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.cell_id));
 
 	/* Now SGSN sends some DL data, PCU will page on PACCH */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_rx_rlcmac_dl_block_exp_pkt_dl_ass(dl_block, sched_fn);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_rx_imm_ass_pacch(ms, sched_fn, tr_RLCMAC_DL_PACKET_ASS);
 	/* DL Ass sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* PCU acks the UL data after having received CV=0) */
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, unused_fn);
@@ -1095,9 +1011,9 @@
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0, exp_dl_cs_mcs);
 
 	/* ACK the DL block */
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.ul_tbf.tfi, ms.dl_tbf.acknack_desc),
+			 f_dl_block_ack_fn(dl_block, dl_fn));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
@@ -1152,64 +1068,50 @@
  * answered by the MS on PDCH, so TBFs for downlink and later for uplink are created.
  */
 private function f_TC_mt_ping_pong(template (omit) MSRadioAccessCapabilityV_BSSGP ms_racap := omit, template (present) CodingScheme exp_cs_mcs := ?) runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
-	var PacketDlAssign dl_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var PCUIF_Message pcu_msg;
 	var octetstring data := f_rnd_octstring(10);
-	var boolean ok;
 	var uint32_t sched_fn;
 	var uint32_t dl_fn;
-	var OCT4 tlli := '00000001'O;
-	var uint14_t bsn := 0;
-	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* SGSN sends some DL data, PCU will page on CCCH (PCH) */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data, ms_racap));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data, ms_racap));
+	f_ms_exp_dl_tbf_ass_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS: */
 	f_sleep(X2002);
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0, exp_cs_mcs);
 
 	/* ACK the DL block */
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc),
+			 f_dl_block_ack_fn(dl_block, dl_fn));
 
 	/* Now MS wants to answer the DL data, Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Send one UL block (with TLLI since we are in One-Phase Access
 	   contention resoultion) and make sure it is ACKED fine */
-	f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, 1, tlli);
+	f_ms_tx_ul_data_block_multi(ms, 1, with_tlli := true);
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* UL block should be received in SGSN */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id));
+	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.cell_id));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
@@ -1237,123 +1139,102 @@
  * be transferred).
  */
 testcase TC_ul_intermediate_retrans() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
 	var template (value) RlcmacUlBlock ul_data;
-	var boolean ok;
 	var uint32_t sched_fn;
-	var OCT4 tlli := '00000001'O;
-	var uint14_t bsn := 5;
-	var PDU_BSSGP bssgp_pdu;
 	var octetstring total_payload;
 	var octetstring payload;
 	var octetstring lost_payload;
-	var integer padding_len;
 	var uint5_t tfi;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
-	tfi := ul_tbf_ass.dynamic.tfi_assignment;
+	f_ms_establish_ul_tbf(ms);
+	tfi := ms.ul_tbf.tfi;
 
 	/* Send one UL block (with TLLI since we are in One-Phase Access
 	   contention resoultion) and make sure it is ACKED fine. */
 	payload := f_rnd_octstring(16); /* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
-	ul_data := t_RLCMAC_UL_DATA_TLLI(
-		tfi := tfi,
-		cv := 15, /* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
-		bsn := 0,
-		blocks := { valueof(t_RLCMAC_LLCBLOCK(payload)) },
-		tlli := tlli);
+	f_ms_tx_ul_data_block(ms, payload, cv := 15, with_tlli := true);
 
-	f_tx_rlcmac_ul_block(ul_data, 0);
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 	total_payload := payload;
 
 	/* Send 2 packets, skip 1 (inc bsn) and send another one */
 	payload := f_rnd_octstring(20); /* 20 bytes fills the CS-1 llc block */
-	ul_data := t_RLCMAC_UL_DATA(tfi := tfi, cv := 15, bsn := 1, blocks := {t_RLCMAC_LLCBLOCK(payload)});
-	f_tx_rlcmac_ul_block(ul_data, 0);
+	f_ms_tx_ul_data_block(ms, payload, cv := 15);
 	total_payload := total_payload & payload;
 
 	payload := f_rnd_octstring(20); /* 20 bytes fills the CS-1 llc block */
-	ul_data := t_RLCMAC_UL_DATA(tfi := tfi, cv := 15, bsn := 2, blocks := {t_RLCMAC_LLCBLOCK(payload)});
-	f_tx_rlcmac_ul_block(ul_data, 0);
+	f_ms_tx_ul_data_block(ms, payload, cv := 15);
 	total_payload := total_payload & payload;
 
-	lost_payload := f_rnd_octstring(20); /* LOST PAYLOAD bsn=3, will be retransmitted, next bsn is increased +2 */
+	lost_payload := f_rnd_octstring(20);
+	ms.ul_tbf.bsn := ms.ul_tbf.bsn + 1;  /* LOST PAYLOAD bsn=3, will be retransmitted, next bsn is increased +2 */
 	total_payload := total_payload & lost_payload;
 
 	payload := f_rnd_octstring(20); /* 20 bytes fills the CS-1 llc block */
-	ul_data := t_RLCMAC_UL_DATA(tfi := tfi, cv := 15, bsn := 4, blocks := {t_RLCMAC_LLCBLOCK(payload)});
-	f_tx_rlcmac_ul_block(ul_data, 0);
+	f_ms_tx_ul_data_block(ms, payload, cv := 15);
 	total_payload := total_payload & payload;
 
 	/* Send enough blocks to finish the transmission (since we were sending BSN=15, send BS_CV_MAX packets) */
-	total_payload := total_payload & f_tx_rlcmac_ul_n_blocks(ul_tbf_ass.dynamic.tfi_assignment, bsn, g_bs_cv_max);
+	total_payload := total_payload & f_ms_tx_ul_data_block_multi(ms, g_bs_cv_max);
 
 	/* On CV=0, we'll receive a UL ACK asking about missing block */
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* TODO: check ack ack bitmap (URBB) */
 	ul_data := t_RLCMAC_UL_DATA(tfi := tfi, cv := 15, bsn := 3, blocks := {t_RLCMAC_LLCBLOCK(lost_payload)});
-	f_tx_rlcmac_ul_block(ul_data, 0);
+	f_ms_tx_ul_block(ms, ul_data);
 
 	/* Now final ack is recieved */
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_CTRL_ACK(tlli), 0, sched_fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 
 	/* receive one message on BSSGP with all aggregated data in payload: */
-	BSSGP[0].receive(tr_BSSGP_UL_UD(tlli, mp_gb_cfg.cell_id, total_payload));
+	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.cell_id, total_payload));
 }
 
 /* Verify that if PCU doesn't get an ACK for first DL block after IMM ASS, it
  * will retry by retransmitting both the IMM ASS + DL block after poll (ack)
  * timeout occurs (specified by sent RRBP on DL block). */
 testcase TC_imm_ass_dl_block_retrans() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketDlAssign dl_tbf_ass;
 	var RlcmacDlBlock dl_block;
 	var octetstring data := f_rnd_octstring(10);
-	var boolean ok;
 	var uint32_t dl_fn;
-	var OCT4 tlli := '00000001'O;
-	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* SGSN sends some DL data, PCU will page on CCCH (PCH) */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_exp_dl_tbf_ass_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS: */
 	f_sleep(X2002);
@@ -1362,19 +1243,16 @@
 	/* Now we don't ack the dl block (emulate MS failed receiveing IMM ASS
 	 * or GPRS DL, or DL ACK was lost for some reason). As a result, PCU
 	 * should retrigger IMM ASS + GPRS DL procedure after poll timeout. */
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
+	f_ms_exp_dl_tbf_ass_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS: */
 	f_sleep(X2002);
 	f_rx_rlcmac_dl_block_exp_data(dl_block, dl_fn, data, 0);
 
 	/* ACK the DL block */
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block, '1'B);
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(f_rlcmac_dl_block_get_tfi(dl_block), ack_nack_desc),
-			     0, f_dl_block_ack_fn(dl_block, dl_fn));
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block, '1'B);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc),
+			 f_dl_block_ack_fn(dl_block, dl_fn));
 
 	f_shutdown(__BFILE__, __LINE__, final := true);
 }
@@ -1383,44 +1261,36 @@
 testcase TC_dl_flow_more_blocks() runs on RAW_PCU_Test_CT {
 	var AckNackDescription ack_nack_desc := valueof(t_AckNackDescription_init);
 	var octetstring data := f_rnd_octstring(16);
-	var OCT4 tlli := f_rnd_octstring(4);
 	var PacketDlAssign dl_tbf_ass;
-	var GsmRrMessage rr_imm_ass;
 	var RlcmacDlBlock dl_block;
 	var uint32_t ack_fn;
 	var uint32_t fn;
+	var GprsMS ms;
 	timer T := 5.0;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* SGSN sends some DL data, PCU will page on CCCH (PCH) */
-	BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
-	f_pcuif_rx_pch_imm_tbf_ass(rr_imm_ass);
-
-	/* Make sure we've got a Downlink TBF assignment with DL TFI */
-	f_imm_ass_verify_dl_tbf_ass(rr_imm_ass, dl_tbf_ass);
-	if (not ispresent(dl_tbf_ass.group1)) {
-		setverdict(fail, "Immediate Assignment contains no DL TFI");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Get DL TFI from received Downlink TBF assignment */
-	var uint5_t tfi := dl_tbf_ass.group1.tfi_assignment;
+	BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
+	f_ms_exp_dl_tbf_ass_ccch(ms, PCU_IF_SAPI_PCH);
 
 	/* Wait timer X2002 and DL block is available after CCCH IMM ASS */
 	f_sleep(X2002);
 
 	/* Expect the first (GPRS DL) block with bsn=0 and rrbp_valid=1 */
 	f_rx_rlcmac_dl_block_exp_data(dl_block, fn, data, 0);
-	f_acknackdesc_ack_block(ack_nack_desc, dl_block);
+	f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block);
 
 	/* TDMA frame number on which we are supposed to send the ACK */
 	ack_fn := f_dl_block_ack_fn(dl_block, fn);
@@ -1428,30 +1298,30 @@
 	/* SGSN sends more blocks during the indicated RRBP */
 	for (var integer bsn := 1; bsn < 63; bsn := bsn + 1) {
 		data := f_rnd_octstring(16); /* Random LLC data */
-		BSSGP[0].send(ts_BSSGP_DL_UD(tlli, data));
+		BSSGP[0].send(ts_BSSGP_DL_UD(ms.tlli, data));
 
 		f_rx_rlcmac_dl_block_exp_data(dl_block, fn, data, bsn);
 
 		/* Make sure this block has the same TFI as was assigned
 		 * FIXME: this is only valid for GPRS, not EGPRS. */
-		if (dl_block.data.mac_hdr.hdr_ext.tfi != tfi) {
+		if (dl_block.data.mac_hdr.hdr_ext.tfi != ms.dl_tbf.tfi) {
 			setverdict(fail, "Rx DL data block with unexpected TFI: ",
 				   dl_block.data.mac_hdr.hdr_ext.tfi);
 			f_shutdown(__BFILE__, __LINE__);
 		}
 
 		/* Keep Ack/Nack description updated */
-		f_acknackdesc_ack_block(ack_nack_desc, dl_block);
+		f_acknackdesc_ack_block(ms.dl_tbf.acknack_desc, dl_block);
 
 		/* Break if this is the end of RRBP */
 		if (fn == ack_fn) {
-			ack_nack_desc.final_ack := '1'B;
+			ms.dl_tbf.acknack_desc.final_ack := '1'B;
 			break;
 		}
 	}
 
 	/* This is the end of RRBP, send Packet Downlink Ack/Nack */
-	f_tx_rlcmac_ul_block(ts_RLCMAC_DL_ACK_NACK(tfi, ack_nack_desc), fn := fn);
+	f_ms_tx_ul_block(ms, ts_RLCMAC_DL_ACK_NACK(ms.dl_tbf.tfi, ms.dl_tbf.acknack_desc), fn := fn);
 
 	/* Make sure that the next block (after the Ack) is dummy */
 	f_rx_rlcmac_dl_block_exp_dummy(dl_block);
@@ -1491,34 +1361,27 @@
  * 3. Expect a Paging Frame
  */
 testcase TC_paging_cs_from_bts() runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var boolean ok;
-	var OCT4 tlli := '00000001'O;
 	var MobileIdentityLV mi;
 	var octetstring mi_enc_lv;
 	var hexstring imsi := f_gen_imsi(42);
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* build mobile Identity */
 	mi := valueof(ts_MI_IMSI_LV(imsi));
@@ -1540,33 +1403,26 @@
  */
 private function f_tc_paging_cs_from_sgsn(Nsvci bvci, boolean use_ptmsi := false)
 runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_imm_ass;
-	var PacketUlAssign ul_tbf_ass;
 	var RlcmacDlBlock dl_block;
-	var boolean ok;
-	var OCT4 tlli := '00000001'O;
 	var hexstring imsi := f_gen_imsi(42);
 	var GsmTmsi tmsi;
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Establish an Uplink TBF */
-	ok := f_establish_tbf(rr_imm_ass);
-	if (not ok) {
-		setverdict(fail, "Failed to establish TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
-
-	/* Make sure we've got an Uplink TBF assignment */
-	f_imm_ass_verify_ul_tbf_ass(rr_imm_ass, ul_tbf_ass);
+	f_ms_establish_ul_tbf(ms);
 
 	/* Send paging request with or without TMSI */
 	if (use_ptmsi) {
@@ -1605,19 +1461,22 @@
  */
 private function f_tc_paging_ps_from_sgsn(Nsvci bvci, boolean use_ptmsi := false)
 runs on RAW_PCU_Test_CT {
-	var OCT4 tlli := '00000001'O;
 	var integer imsi_suff_tx := 423;
 	var hexstring imsi := f_gen_imsi(imsi_suff_tx);
+	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
 	/* Establish BSSGP connection to the PCU */
 	f_bssgp_establish();
-	f_bssgp_client_llgmm_assign('FFFFFFFF'O, tlli);
+	f_bssgp_client_llgmm_assign('FFFFFFFF'O, ms.tlli);
 
 	/* Send BSSGP PAGING-PS (with or without TMSI), wait for RR Paging Request Type 1.
 	 * Make sure that both paging group (IMSI suffix) and Mobile Identity match. */
@@ -1646,23 +1505,20 @@
 }
 
 private function f_TC_egprs_pkt_chan_req(in EGPRSPktChRequest req,
-					 template GsmRrMessage t_imm_ass := ?,
-					 PCUIF_BurstType bt := BURST_TYPE_1)
+					 template GsmRrMessage t_imm_ass := ?)
 runs on RAW_PCU_Test_CT {
-	var GsmRrMessage rr_msg;
 	var uint16_t ra11;
-	var boolean ok;
+	var GprsMS ms;
+
+	ms := g_ms[0]; /* We only use first MS in this test */
 
 	ra11 := enc_EGPRSPktChRequest2uint(req);
+	f_ms_use_ra(ms, ra11, ra_is_11bit := 1);
 	log("Sending EGPRS Packet Channel Request (", ra11, "): ", req);
 
-	ok := f_establish_tbf(rr_msg, ra := ra11, is_11bit := 1, burst_type := bt);
-	if (not ok) {
-		setverdict(fail, "Failed to establush an Uplink TBF");
-		f_shutdown(__BFILE__, __LINE__);
-	}
+	f_ms_establish_ul_tbf(ms);
 
-	if (not match(rr_msg, t_imm_ass)) {
+	if (not match(ms.ul_tbf.rr_imm_ass, t_imm_ass)) {
 		setverdict(fail, "Immediate Assignment does not match");
 		f_shutdown(__BFILE__, __LINE__);
 	}
@@ -1675,6 +1531,9 @@
 	var template IaRestOctets rest;
 	var template EgprsUlAss ul_ass;
 
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
@@ -1703,6 +1562,9 @@
 	var template IaRestOctets rest;
 	var template EgprsUlAss ul_ass;
 
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());
 
@@ -1737,6 +1599,9 @@
 	var template IaRestOctets rest;
 	var template EgprsUlAss ul_ass;
 
+	/* Initialize GPRS MS side */
+	f_init_gprs_ms();
+
 	/* Initialize the PCU interface abstraction */
 	f_init_raw(testcasename());