From cb00c52b0727ae10086bdc8417060110f317900b Mon Sep 17 00:00:00 2001 From: Pau Espin Pedrol Date: Fri, 6 Nov 2020 19:52:05 +0100 Subject: [PATCH] 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 --- library/RLCMAC_EncDec.cc | 30 ++++++++++++ library/RLCMAC_Templates.ttcn | 42 ++++++++++++++--- library/RLCMAC_Types.ttcn | 14 +++++- pcu/GPRS_Components.ttcn | 88 ++++++++++++++++++++++------------- pcu/GPRS_TBF.ttcn | 4 +- pcu/PCU_Tests.ttcn | 51 +++++++++++++------- 6 files changed, 171 insertions(+), 58 deletions(-) diff --git a/library/RLCMAC_EncDec.cc b/library/RLCMAC_EncDec.cc index 4dba35aeb..ea93de4bb 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 9722f43cd..f016c4dd8 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 eb9d8455a..3110a6652 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 1cbca4cba..0f4649090 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 fb4209721..f946f2945 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 8f424aba2..f183e4c17 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),