pcu: Specify (M)CS to use when sending UL rlcmac data blocks

Apply padding and spare bits in the encoder according to CS/MCS format.

Change-Id: I918acac81f550077daeda3374b3de9b426ff3572

6 files changed, 171 insertions, 58 deletions

diff --git a/library/RLCMAC_EncDec.cc b/library/RLCMAC_EncDec.cc
index 4dba35ae..ea93de4b 100644
--- a/library/RLCMAC_EncDec.cc
+++ b/library/RLCMAC_EncDec.cc
@@ -438,6 +438,28 @@ static void put_egprs_data_block(const TTCN_Buffer& aligned_data_block_buffer, u
 	dst_ttcn_buffer.increase_length(length_bytes);
 }
 
+/* Append padding bytes and spare bits at the end of ttcn_buffer, based on requested CS */
+static void encode_trailing_padding_spb(TTCN_Buffer& ttcn_buffer, CodingScheme cs)
+{
+	uint8_t buf[256]; /* enough to fit any RLCMAC buffer*/
+	uint32_t blk_len = RLCMAC__Templates::f__rlcmac__cs__mcs2block__len(cs);
+	uint32_t blk_len_no_spb = RLCMAC__Templates::f__rlcmac__cs__mcs2block__len__no__spare__bits(cs);
+	uint32_t data_len = ttcn_buffer.get_len();
+
+	if (data_len > blk_len_no_spb) {
+		fprintf(stderr, "Buffer too large for requested CS! %s (%s:%u)\n", __func__, __FILE__, __LINE__);
+		// TODO: throw exception?
+	}
+
+	for (int i = 0; i < blk_len_no_spb - data_len; i++)
+		buf[i] = 0x2b; /* Padding bits if needed */
+	for (int i = blk_len_no_spb - data_len; i < blk_len - data_len; i++)
+		buf[i] = 0x00;  /* Spare bits if needed */
+
+	const OCTETSTRING& pad_octstr = OCTETSTRING(blk_len - data_len, buf);
+	ttcn_buffer.put_string(pad_octstr);
+}
+
 /////////////////////
 // DECODE
 /////////////////////
@@ -970,6 +992,8 @@ OCTETSTRING enc__RlcmacDlDataBlock(const RlcmacDlDataBlock& si)
 		}
 	}
 
+	encode_trailing_padding_spb(ttcn_buffer, in.cs());
+
 	ttcn_buffer.get_string(ret_val);
 	return ret_val;
 }
@@ -1040,6 +1064,8 @@ OCTETSTRING enc__RlcmacDlEgprsDataBlock(const RlcmacDlEgprsDataBlock& si)
 		}
 	}
 
+	encode_trailing_padding_spb(ttcn_buffer, in.mcs());
+
 	ttcn_buffer.get_string(ret_val);
 	return ret_val;
 }
@@ -1133,6 +1159,8 @@ OCTETSTRING enc__RlcmacUlDataBlock(const RlcmacUlDataBlock& si)
 		}
 	}
 
+	encode_trailing_padding_spb(ttcn_buffer, in.cs());
+
 	ttcn_buffer.get_string(ret_val);
 	return ret_val;
 }
@@ -1320,6 +1348,8 @@ OCTETSTRING enc__RlcmacUlEgprsDataBlock(const RlcmacUlEgprsDataBlock& si)
 	put_egprs_data_block(aligned_buffer, data_block_offsets[0], data_block_bits, ttcn_buffer);
 	//printbuffer("after merging data block", ttcn_buffer);
 
+	encode_trailing_padding_spb(ttcn_buffer, in.mcs());
+
 	ttcn_buffer.get_string(ret_val);
 	return ret_val;
 }
diff --git a/library/RLCMAC_Templates.ttcn b/library/RLCMAC_Templates.ttcn
index 9722f43c..f016c4dd 100644
--- a/library/RLCMAC_Templates.ttcn
+++ b/library/RLCMAC_Templates.ttcn
@@ -38,6 +38,13 @@ module RLCMAC_Templates {
 		return (current_fn + f_rrbp_fn_delay(rrbp)) mod 2715648;
 	}
 
+	function f_rlcmac_cs_mcs_is_mcs(CodingScheme cs_mcs) return boolean {
+		if (cs_mcs >= MCS_0) {
+			return true;
+		}
+		return false;
+	}
+
 	function f_rlcmac_mcs2headertype(CodingScheme mcs) return EgprsHeaderType {
 		select (mcs) {
 		case (MCS_0) { return RLCMAC_HDR_TYPE_3; }
@@ -97,7 +104,27 @@ module RLCMAC_Templates {
 		return CS_1;
 	}
 
-	/* Minimum CodingScheme required to fit RLCMAC block */
+	function f_rlcmac_cs_mcs2block_len_no_spare_bits(CodingScheme cs_mcs) return uint32_t {
+		select (cs_mcs) {
+		/* 3GPP TS 44.060 Table 10.2.1: RLC data block size, discounting padding in octet */
+		case (CS_1) { return 23; }
+		case (CS_2) { return 33; }
+		case (CS_3) { return 39; }
+		case (CS_4) { return 53; }
+		case (MCS_1) { return 27; }
+		case (MCS_2) { return 33; }
+		case (MCS_3) { return 42; }
+		case (MCS_4) { return 49; }
+		case (MCS_5) { return 61; }
+		case (MCS_6) { return 79; }
+		case (MCS_7) { return 119; }
+		case (MCS_8) { return 143; }
+		case (MCS_9) { return 155; }
+		}
+		return 0;
+	}
+
+	/* Minimum CodingScheme required to fit RLCMAC block. Spare bits not counted. */
 	function f_rlcmac_block_len_required_cs_mcs(uint32_t len, boolean is_mcs) return CodingScheme {
 		if (is_mcs) {
 			if (len <= 27) { return MCS_1; }
@@ -375,10 +402,11 @@ module RLCMAC_Templates {
 	}
 
 	/* Template for uplink Data block */
-	template RlcmacUlBlock t_RLCMAC_UL_DATA(template uint5_t tfi, template uint4_t cv, template uint7_t bsn,
+	template RlcmacUlBlock t_RLCMAC_UL_DATA(template CodingScheme cs, template uint5_t tfi,
+						template uint4_t cv, template uint7_t bsn,
 						template LlcBlocks blocks := {}, template boolean stall := false) := {
 		data := {
-			cs := CS_1, /* TODO: make this available to template */
+			cs := cs,
 			mac_hdr := {
 				payload_type := MAC_PT_RLC_DATA,
 				countdown := cv,
@@ -396,10 +424,12 @@ module RLCMAC_Templates {
 			blocks := blocks
 		}
 	}
-	template RlcmacUlBlock t_RLCMAC_UL_DATA_TLLI(template uint5_t tfi, template uint4_t cv, template uint7_t bsn,
-						     template LlcBlocks blocks := {}, template boolean stall := false, template GprsTlli tlli) := {
+	template RlcmacUlBlock t_RLCMAC_UL_DATA_TLLI(template CodingScheme cs, template uint5_t tfi,
+						     template uint4_t cv, template uint7_t bsn,
+						     template LlcBlocks blocks := {}, template boolean stall := false,
+						     template GprsTlli tlli) := {
 		data := {
-			cs := CS_1, /* TODO: make this available to template */
+			cs := cs,
 			mac_hdr := {
 				payload_type := MAC_PT_RLC_DATA,
 				countdown := cv,
diff --git a/library/RLCMAC_Types.ttcn b/library/RLCMAC_Types.ttcn
index eb9d8455..3110a665 100644
--- a/library/RLCMAC_Types.ttcn
+++ b/library/RLCMAC_Types.ttcn
@@ -115,6 +115,11 @@ module RLCMAC_Types {
 		DlCtrlOptOctets		opt optional,
 		RlcmacDlCtrlMsg		payload
 	} with {
+		/* Automatic padding by RAW encoder seems to causing problems
+		 * due to padding sequence 2b inserted shifted from octet
+		 * boundary on some messags. See UL CTRL blocks in TC_t3193.
+		 * See 3GPP TS 44.060 Figure 11.1 (below)
+		 * variant "PADDING(184), PADDING_PATTERN('00101011'B)" */
 		variant (opt) "PRESENCE(mac_hdr.payload_type = MAC_PT_RLCMAC_OPT)"
 	};
 
@@ -133,7 +138,14 @@ module RLCMAC_Types {
 	type record RlcmacUlCtrlBlock {
 		UlMacCtrlHeader		mac_hdr,
 		RlcmacUlCtrlMsg		payload
-	} with { variant "" };
+	} with {
+		/* Automatic padding by RAW encoder seems to causing problems
+		 * due to padding sequence 2b inserted shifted from octet
+		 * boundary on some messags. See UL CTRL blocks in TC_t3193.
+		 * See 3GPP TS 44.060 Figure 11.1 (below)
+		 * variant "PADDING(184), PADDING_PATTERN('00101011'B)" */
+		 variant ""
+		};
 
 	external function enc_RlcmacUlCtrlBlock(in RlcmacUlCtrlBlock si) return octetstring
 		with { extension "prototype(convert) encode(RAW)" };
diff --git a/pcu/GPRS_Components.ttcn b/pcu/GPRS_Components.ttcn
index 1cbca4cb..0f464909 100644
--- a/pcu/GPRS_Components.ttcn
+++ b/pcu/GPRS_Components.ttcn
@@ -432,6 +432,24 @@ runs on MS_BTS_IFACE_CT return integer  {
 	return n;
 }
 
+function f_ultbf_payload_fill_length(UlTbf ul_tbf, boolean tlli := false, integer li_bytes := 0)
+runs on MS_BTS_IFACE_CT return uint32_t {
+	var uint32_t blk_len := f_rlcmac_cs_mcs2block_len_no_spare_bits(ul_tbf.tx_cs_mcs);
+	var uint32_t payload_fill_len;
+
+	if (f_rlcmac_cs_mcs_is_mcs(ul_tbf.tx_cs_mcs)) {
+		payload_fill_len := blk_len - 5 - li_bytes;
+	} else {
+		/* GPRS: blk_len = 3 Header bytes + payload length. No LI byte in this case. */
+		payload_fill_len := blk_len - 3 - li_bytes;
+	}
+
+	if (tlli) {
+		payload_fill_len := payload_fill_len - 4;
+	}
+	return payload_fill_len;
+}
+
 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;
@@ -507,53 +525,57 @@ runs on MS_BTS_IFACE_CT {
 function f_ms_tx_ul_block(inout GprsMS ms, template (value) RlcmacUlBlock ul_data,
 			  uint32_t fn := 0, template (omit) CodingScheme force_cs_mcs := omit,
 			  template (value) TsTrxBtsNum nr := ts_TsTrxBtsNum)
-runs on MS_BTS_IFACE_CT return integer {
+runs on MS_BTS_IFACE_CT {
 	var octetstring data;
-	var integer padding_len;
 	var CodingScheme cs_mcs;
 	var uint32_t cs_mcs_len;
 
 	/* Encode the payload of DATA.ind */
 	data := enc_RlcmacUlBlock(valueof(ul_data));
 
-	if (ispresent(force_cs_mcs)) {
-		cs_mcs := valueof(force_cs_mcs);
-	} else if (ischosen(ul_data.ctrl)) {
-		cs_mcs := CS_1; /* CTRL is always CS1 */
-	} else {
-		/* Add padding to encode payload to minimum required CS/MCS: */
-		cs_mcs := f_rlcmac_block_len_required_cs_mcs(lengthof(data), ischosen(ul_data.data_egprs));
+	if (ischosen(ul_data.ctrl)) {
+		/* Ctrl blocks are right now encoded by RAW encoder, which was
+		 * found to have some issue with final padding, so we add it
+		 * here manually. This is actually still incorrect because the
+		 * remaining bits of last octet with data are not filled with
+		 * the padding sequence, but it's good enough since anyway PCU
+		 * don't check these. */
+		data := f_pad_oct(data, f_rlcmac_cs_mcs2block_len(CS_1), '2b'O);
 	}
-
-	cs_mcs_len := f_rlcmac_cs_mcs2block_len(cs_mcs);
-	padding_len := cs_mcs_len - lengthof(data);
-	if (padding_len < 0) {
-		setverdict(fail, "Unable to encode UL block of size ", lengthof(data), " with ", cs_mcs);
-		f_shutdown(__BFILE__, __LINE__);
-	}
-	data := f_pad_oct(data, cs_mcs_len, '00'O);
-
 	/* Enqueue DATA.ind (both TDMA frame and block numbers to be patched) */
 	f_ms_tx_data_ind(ms, data, fn, nr := nr);
-	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,
 			       template (value) TsTrxBtsNum nr := ts_TsTrxBtsNum)
-runs on MS_BTS_IFACE_CT return integer {
+runs on MS_BTS_IFACE_CT {
 	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;
+
+	if (f_rlcmac_cs_mcs_is_mcs(ms.ul_tbf.tx_cs_mcs)) {
+		ul_data := t_RLCMAC_UL_EGPRS_DATA(mcs := ms.ul_tbf.tx_cs_mcs,
+						  tfi := ms.ul_tbf.tfi,
+						  cv := cv,
+						  bsn1 := ms.ul_tbf.bsn,
+						  bsn2_offset := 0,
+						  blocks := {t_RLCMAC_LLCBLOCK_EGPRS(payload)})
+		if (with_tlli) {
+			ul_data.data_egprs.tlli_ind := true;
+			ul_data.data_egprs.tlli := ms.tlli;
+		}
+	} else {
+		ul_data := t_RLCMAC_UL_DATA(cs := ms.ul_tbf.tx_cs_mcs,
+					    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;
+		}
 	}
 	f_ultbf_inc_bsn(ms.ul_tbf);
-	return f_ms_tx_ul_block(ms, ul_data, fn, nr := nr);
+	f_ms_tx_ul_block(ms, ul_data, fn, nr := nr);
 }
 
 /* Send random payload for last "num_blocks" blocks in Ul TBF (ending with CV=0). */
@@ -561,17 +583,17 @@ function f_ms_tx_ul_data_block_multi(inout GprsMS ms, integer num_blocks := 1, b
 				     template (value) TsTrxBtsNum nr := ts_TsTrxBtsNum)
 runs on MS_BTS_IFACE_CT return octetstring {
 	var octetstring total_payload := ''O;
+	var uint32_t payload_fill_len := f_ultbf_payload_fill_length(ms.ul_tbf, with_tlli, 0);
 
 	for (var integer i := 0; i < num_blocks; i := i + 1) {
-		var integer padding_len;
-		var octetstring payload := f_rnd_octstring(10);
+		var octetstring payload := f_rnd_octstring(payload_fill_len);
 		/* 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, nr := nr);
-		total_payload := total_payload & payload & f_pad_oct(''O, padding_len, '00'O);
+		f_ms_tx_ul_data_block(ms, payload, cv := cv, with_tlli := with_tlli, nr := nr);
+		total_payload := total_payload & payload;
 	}
 	return total_payload;
 }
diff --git a/pcu/GPRS_TBF.ttcn b/pcu/GPRS_TBF.ttcn
index fb420972..f946f294 100644
--- a/pcu/GPRS_TBF.ttcn
+++ b/pcu/GPRS_TBF.ttcn
@@ -326,10 +326,10 @@ function f_ul_tbf_get_next_block(out RlcmacUlBlock blk, inout UlTbfState us, ino
 
 	/* include TLLI when needed */
 	if (tlli_needed) {
-		blk := valueof(t_RLCMAC_UL_DATA_TLLI(us.tfi, cv, us.et.v_s,
+		blk := valueof(t_RLCMAC_UL_DATA_TLLI(CS_1, us.tfi, cv, us.et.v_s,
 						llc_blocks, false, mmctx.tlli));
 	} else {
-		blk := valueof(t_RLCMAC_UL_DATA(us.tfi, cv, us.et.v_s, llc_blocks, false));
+		blk := valueof(t_RLCMAC_UL_DATA(CS_1, us.tfi, cv, us.et.v_s, llc_blocks, false));
 	}
 
 	/* Increment Block Sequence Number */
diff --git a/pcu/PCU_Tests.ttcn b/pcu/PCU_Tests.ttcn
index 8f424aba..f183e4c1 100644
--- a/pcu/PCU_Tests.ttcn
+++ b/pcu/PCU_Tests.ttcn
@@ -97,7 +97,7 @@ friend template (value) PCUIF_info_ind ts_PCUIF_INFO_default(template (value) PC
 	dl_tbf_ext := 250 * 10, /* ms */
 	ul_tbf_ext := 250 * 10, /* ms */
 	initial_cs := 2,
-	initial_mcs := 6,
+	initial_mcs := 1,
 	nsvci := { mp_nsconfig.nsvc[0].nsvci, 0 },
 	local_port := { mp_nsconfig.nsvc[0].provider.ip.remote_udp_port, 0 },
 	remote_port := { mp_nsconfig.nsvc[0].provider.ip.local_udp_port, 0 },
@@ -1085,7 +1085,7 @@ testcase TC_countdown_procedure() runs on RAW_PCU_Test_CT  {
 
 	/* 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) */
+	total_payload := f_rnd_octstring(f_ultbf_payload_fill_length(ms.ul_tbf, true));
 	/* 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);
@@ -1114,6 +1114,8 @@ testcase TC_ul_all_sizes() runs on RAW_PCU_Test_CT  {
 	var template (value) RlcmacUlBlock ul_data;
 	var template (value) LlcBlockHdr blk_hdr;
 	var template (value) LlcBlocks blocks;
+	var integer blk_len;
+	var CodingScheme tx_cs;
 	var GprsMS ms;
 
 	/* Initialize NS/BSSGP side */
@@ -1139,7 +1141,8 @@ testcase TC_ul_all_sizes() runs on RAW_PCU_Test_CT  {
 					 more := false, e := true);
 	blocks := { t_RLCMAC_LLCBLOCK(payload, blk_hdr) };
 	/* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
-	ul_data := t_RLCMAC_UL_DATA_TLLI(tfi := ms.ul_tbf.tfi,
+	ul_data := t_RLCMAC_UL_DATA_TLLI(cs := ms.ul_tbf.tx_cs_mcs,
+					 tfi := ms.ul_tbf.tfi,
 					 cv := 15,
 					 bsn := ms.ul_tbf.bsn,
 					 blocks := blocks,
@@ -1166,12 +1169,15 @@ testcase TC_ul_all_sizes() runs on RAW_PCU_Test_CT  {
 			cv := max_size - i;
 		}
 
+		blk_len := 3 + 1 + i; /* 3 Header bytes + LI byte + payload length */
+		tx_cs := f_rlcmac_block_len_required_cs_mcs(blk_len, false);
 		payload := f_rnd_octstring(i);
 		blk_hdr := t_RLCMAC_LLCBLOCK_HDR(length_ind := lengthof(payload),
 						 more := false, e := true);
 		blocks := { t_RLCMAC_LLCBLOCK(payload, blk_hdr) };
 		/* Set CV = 15 to signal there's still more than BS_CV_MAX blocks to be sent */
-		ul_data := t_RLCMAC_UL_DATA(tfi := ms.ul_tbf.tfi,
+		ul_data := t_RLCMAC_UL_DATA(cs := tx_cs,
+					    tfi := ms.ul_tbf.tfi,
 					    cv := cv,
 					    bsn := ms.ul_tbf.bsn,
 					    blocks := blocks);
@@ -1218,7 +1224,8 @@ function f_TC_ul_data_toolong_fills_padding_cs(inout GprsMS ms, CodingScheme cs,
 	blk_hdr := t_RLCMAC_LLCBLOCK_HDR(length_ind := lengthof(payload),
 					 more := false, e := true);
 	blocks := { t_RLCMAC_LLCBLOCK(payload, blk_hdr) };
-	ul_data := t_RLCMAC_UL_DATA_TLLI(tfi := ms.ul_tbf.tfi,
+	ul_data := t_RLCMAC_UL_DATA_TLLI(cs := cs,
+					 tfi := ms.ul_tbf.tfi,
 					 cv := cv,
 					 bsn := ms.ul_tbf.bsn,
 					 blocks := blocks,
@@ -1368,7 +1375,7 @@ runs on RAW_PCU_Test_CT {
 
 	/* Send one UL block (without TLLI since we are in Second-Phase Access)
 	   and make sure it is ACKED fine */
-	f_ms_tx_ul_data_block_multi(ms, 1, with_tlli := true);  /* TODO: send using cs_mcs */
+	f_ms_tx_ul_data_block_multi(ms, 1, with_tlli := true);
 
 	/* DL ACK/NACK sets poll+rrbp requesting PACKET CONTROL ACK */
 	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), pollctx.fn, nr := pollctx.tstrxbts);
@@ -1524,6 +1531,7 @@ testcase TC_ul_intermediate_retrans() runs on RAW_PCU_Test_CT {
 	var octetstring lost_payload;
 	var uint5_t tfi;
 	var GprsMS ms;
+	var uint32_t payload_fill_len;
 
 	/* Initialize NS/BSSGP side */
 	f_init_bssgp();
@@ -1544,7 +1552,7 @@ testcase TC_ul_intermediate_retrans() runs on RAW_PCU_Test_CT {
 
 	/* 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) */
+	payload := f_rnd_octstring(f_ultbf_payload_fill_length(ms.ul_tbf, true)); /* 16 bytes fills the llc block (because TLLI takes 4 bytes) */
 	f_ms_tx_ul_data_block(ms, payload, cv := 15, with_tlli := true);
 
 	f_rx_rlcmac_dl_block_exp_ack_nack(dl_block, sched_fn);
@@ -1552,20 +1560,22 @@ testcase TC_ul_intermediate_retrans() runs on RAW_PCU_Test_CT {
 	f_ms_tx_ul_block(ms, ts_RLCMAC_CTRL_ACK(ms.tlli), sched_fn);
 	total_payload := payload;
 
+	payload_fill_len := f_ultbf_payload_fill_length(ms.ul_tbf);
+
 	/* Send 2 packets, skip 1 (inc bsn) and send another one */
-	payload := f_rnd_octstring(20); /* 20 bytes fills the CS-1 llc block */
+	payload := f_rnd_octstring(payload_fill_len);
 	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 */
+	payload := f_rnd_octstring(payload_fill_len);
 	f_ms_tx_ul_data_block(ms, payload, cv := 15);
 	total_payload := total_payload & payload;
 
-	lost_payload := f_rnd_octstring(20);
+	lost_payload := f_rnd_octstring(payload_fill_len);
 	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 */
+	payload := f_rnd_octstring(payload_fill_len)
 	f_ms_tx_ul_data_block(ms, payload, cv := 15);
 	total_payload := total_payload & payload;
 
@@ -1575,7 +1585,11 @@ testcase TC_ul_intermediate_retrans() runs on RAW_PCU_Test_CT {
 	/* 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)});
+	ul_data := t_RLCMAC_UL_DATA(cs := ms.ul_tbf.tx_cs_mcs,
+				    tfi := tfi,
+				    cv := 15,
+				    bsn := 3,
+				    blocks := {t_RLCMAC_LLCBLOCK(lost_payload)});
 	f_ms_tx_ul_block(ms, ul_data);
 
 	/* Now final ack is recieved */
@@ -1760,7 +1774,8 @@ testcase TC_ul_flow_multiple_llc_blocks() runs on RAW_PCU_Test_CT {
 	 */
 
 	/*  UL RlcDataBlock(dataA) [BSN=0, CV=3] */
-	ul_data := t_RLCMAC_UL_DATA_TLLI(tfi := ms.ul_tbf.tfi,
+	ul_data := t_RLCMAC_UL_DATA_TLLI(cs := CS_1,
+				    tfi := ms.ul_tbf.tfi,
 				    cv := 3,
 				    bsn := ms.ul_tbf.bsn,
 				    blocks := { t_RLCMAC_LLCBLOCK(substr(dataA, 0, 16)) },
@@ -1772,7 +1787,8 @@ testcase TC_ul_flow_multiple_llc_blocks() runs on RAW_PCU_Test_CT {
 	f_ms_tx_ul_block(ms, ul_data);
 
 	/* UL RlcDataBlock(dataA finished, dataB starts) [BSN=1, CV=2] */
-	ul_data := t_RLCMAC_UL_DATA_TLLI(tfi := ms.ul_tbf.tfi,
+	ul_data := t_RLCMAC_UL_DATA_TLLI(cs := CS_1,
+				    tfi := ms.ul_tbf.tfi,
 				    cv := 2,
 				    bsn := ms.ul_tbf.bsn,
 				    blocks := { t_RLCMAC_LLCBLOCK(substr(dataA, 16, 4),
@@ -1787,7 +1803,8 @@ testcase TC_ul_flow_multiple_llc_blocks() runs on RAW_PCU_Test_CT {
 	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.bvc[0].cell_id, dataA));
 
 	/* UL RlcDataBlock(dataB finished, dataC starts and finishes, dataD starts) [BSN=2, CV=1] */
-	ul_data := t_RLCMAC_UL_DATA_TLLI(tfi := ms.ul_tbf.tfi,
+	ul_data := t_RLCMAC_UL_DATA_TLLI(cs := CS_1,
+				    tfi := ms.ul_tbf.tfi,
 				    cv := 1,
 				    bsn := ms.ul_tbf.bsn,
 				    blocks := { t_RLCMAC_LLCBLOCK(substr(dataB, 11, 2),
@@ -1805,7 +1822,9 @@ testcase TC_ul_flow_multiple_llc_blocks() runs on RAW_PCU_Test_CT {
 	BSSGP[0].receive(tr_BSSGP_UL_UD(ms.tlli, mp_gb_cfg.bvc[0].cell_id, dataC));
 
 	/* UL RlcDataBlock(dataD finishes) [BSN=3, CV=0] */
-	ul_data := t_RLCMAC_UL_DATA_TLLI(tfi := ms.ul_tbf.tfi,
+	ul_data := t_RLCMAC_UL_DATA_TLLI(
+				    cs := CS_1,
+				    tfi := ms.ul_tbf.tfi,
 				    cv := 0,
 				    bsn := ms.ul_tbf.bsn,
 				    blocks := { t_RLCMAC_LLCBLOCK(substr(dataD, 9, 3),