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
changes/93/21093/5
Pau Espin 2 years ago committed by pespin
parent 7a4fe8541e
commit cb00c52b07
  1. 30
      library/RLCMAC_EncDec.cc
  2. 42
      library/RLCMAC_Templates.ttcn
  3. 14
      library/RLCMAC_Types.ttcn
  4. 88
      pcu/GPRS_Components.ttcn
  5. 4
      pcu/GPRS_TBF.ttcn
  6. 51
      pcu/PCU_Tests.ttcn

@ -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;
}

@ -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,

@ -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)" };

@ -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;
}

@ -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 */

@ -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),

Loading…
Cancel
Save