maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/nr-rlc-pdcp-config-file' into integration_2025_w24 (!3383)

Browse Source 
Add configurable values of NR RLC and NR PDCP to the configuration file

This is for the gNB (the UE gets the values from the gNB).

The physical simulators were also adapted (we put the previously
hardcoded values that were everywhere in the code into the simulators
themselves). I don't think we need to have those values configurable for
the simulators, but I can study the possibility to add this if someone
tells me it's important (if not important I prefer not to do it, I am
not sure if it is trivial to do or not).
This commit is contained in:
Robert Schmidt
2025-06-10 15:02:05 +02:00
parent 852fd7fd6c c5f5ab2820
commit 9a34b31470
28 changed files with 769 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ci-scripts/conf_files/gnb-cucp.sa.f1.quectel.conf
+8
View File
@@ -58,6 +58,14 @@ gNBs =
}
);
pdcp = {
drb = {
sn_size = "len18bits"
t_reordering = "ms100"
discard_timer = "infinity"
}
}
security = {
# preferred ciphering algorithms
# the first one of the list that an UE supports in chosen
ci-scripts/conf_files/gnb-du.sa.band78.106prb.usrpb200.conf
+25
View File
@@ -163,6 +163,31 @@ gNBs =
}
);
rlc = {
srb = {
t_poll_retransmit = "ms45"
t_reassembly = "ms25"
t_status_prohibit = "ms0"
poll_pdu = "infinity"
poll_byte = "infinity"
max_retx_threshold = "t8"
sn_field_length = "size12"
}
drb_am = {
t_poll_retransmit = "ms45"
t_reassembly = "ms15"
t_status_prohibit = "ms15"
poll_pdu = "p64"
poll_byte = "kB500"
max_retx_threshold = "t32"
sn_field_length = "size18"
}
drb_um = {
t_reassembly = "ms15"
sn_field_length = "size12"
}
}
MACRLCs = (
{
num_cc = 1;
common/config/config_paramdesc.h
+1 -1
View File
@@ -53,7 +53,7 @@
#define PARAMFLAG_PARAMSETDEF (1 << 17) // parameter has been set to default value in get functions
/* checkedparam_t is possibly used in paramdef_t for specific parameter value validation */
#define CONFIG_MAX_NUMCHECKVAL 20
#define CONFIG_MAX_NUMCHECKVAL 64
typedef struct paramdef paramdef_t;
typedef struct configmodule_interface configmodule_interface_t;
typedef union checkedparam {
openair1/SIMULATION/NR_PHY/dlsim.c
+25 -1
View File
@@ -714,12 +714,36 @@ printf("%d\n", slot);
.timer_config.n311 = 1,
.timer_config.t319 = 400,
.num_agg_level_candidates = {0, 0, 1, 1, 0}};
const nr_rlc_configuration_t rlc_config = {
.srb = {
.t_poll_retransmit = 45,
.t_reassembly = 35,
.t_status_prohibit = 0,
.poll_pdu = -1,
.poll_byte = -1,
.max_retx_threshold = 8,
.sn_field_length = 12,
},
.drb_am = {
.t_poll_retransmit = 45,
.t_reassembly = 15,
.t_status_prohibit = 15,
.poll_pdu = 64,
.poll_byte = 1024 * 500,
.max_retx_threshold = 32,
.sn_field_length = 18,
},
.drb_um = {
.t_reassembly = 15,
.sn_field_length = 12,
}
};
RC.nb_nr_macrlc_inst = 1;
RC.nb_nr_mac_CC = (int*)malloc(RC.nb_nr_macrlc_inst*sizeof(int));
for (i = 0; i < RC.nb_nr_macrlc_inst; i++)
RC.nb_nr_mac_CC[i] = 1;
mac_top_init_gNB(ngran_gNB, scc, NULL, &conf);
mac_top_init_gNB(ngran_gNB, scc, NULL, &conf, &rlc_config);
gNB_mac = RC.nrmac[0];
nr_mac_config_scc(RC.nrmac[0], scc, &conf);
openair1/SIMULATION/NR_PHY/ulsim.c
+25 -1
View File
@@ -668,12 +668,36 @@ int main(int argc, char *argv[])
.timer_config.t311 = 3000,
.timer_config.n311 = 1,
.timer_config.t319 = 400};
const nr_rlc_configuration_t rlc_config = {
.srb = {
.t_poll_retransmit = 45,
.t_reassembly = 35,
.t_status_prohibit = 0,
.poll_pdu = -1,
.poll_byte = -1,
.max_retx_threshold = 8,
.sn_field_length = 12,
},
.drb_am = {
.t_poll_retransmit = 45,
.t_reassembly = 15,
.t_status_prohibit = 15,
.poll_pdu = 64,
.poll_byte = 1024 * 500,
.max_retx_threshold = 32,
.sn_field_length = 18,
},
.drb_um = {
.t_reassembly = 15,
.sn_field_length = 12,
}
};
RC.nb_nr_macrlc_inst = 1;
RC.nb_nr_mac_CC = (int*)malloc(RC.nb_nr_macrlc_inst*sizeof(int));
for (i = 0; i < RC.nb_nr_macrlc_inst; i++)
RC.nb_nr_mac_CC[i] = 1;
mac_top_init_gNB(ngran_gNB, scc, NULL /* scd will be updated further below */, &conf);
mac_top_init_gNB(ngran_gNB, scc, NULL /* scd will be updated further below */, &conf, &rlc_config);
nr_mac_config_scc(RC.nrmac[0], scc, &conf);
NR_ServingCellConfig_t *scd = calloc(1,sizeof(NR_ServingCellConfig_t));
openair2/GNB_APP/gnb_config.c
+64 -2
View File
@@ -846,7 +846,11 @@ static void verify_section_notset(configmodule_interface_t *cfg, char *aprefix,
paramlist_def_t pl = {0};
strncpy(pl.listname, secname, sizeof(pl.listname) - 1);
config_getlist(cfg, &pl, NULL, 0, aprefix);
AssertFatal(pl.numelt == 0, "Section \"%s.%s\" not allowed in this config, please remove it\n", aprefix ? aprefix : "", secname);
AssertFatal(pl.numelt == 0,
"Section \"%s%s%s\" not allowed in this config, please remove it\n",
aprefix ? aprefix : "",
aprefix ? "." : "",
secname);
}
void RCconfig_verify(configmodule_interface_t *cfg, ngran_node_t node_type)
{
@@ -879,6 +883,7 @@ void RCconfig_verify(configmodule_interface_t *cfg, ngran_node_t node_type)
verify_section_notset(cfg, NULL, CONFIG_STRING_L1_LIST);
verify_section_notset(cfg, NULL, CONFIG_STRING_RU_LIST);
verify_section_notset(cfg, NULL, CONFIG_STRING_MACRLC_LIST);
verify_section_notset(cfg, NULL, CONFIG_STRING_NR_RLC_LIST);
} else if (NODE_IS_DU(node_type)) {
// verify that there is no bearer config
verify_gnb_param_notset(gnbp, GNB_ENABLE_SDAP_IDX, GNB_CONFIG_STRING_ENABLE_SDAP);
@@ -886,6 +891,7 @@ void RCconfig_verify(configmodule_interface_t *cfg, ngran_node_t node_type)
verify_section_notset(cfg, GNB_CONFIG_STRING_GNB_LIST ".[0]", GNB_CONFIG_STRING_AMF_IP_ADDRESS);
verify_section_notset(cfg, NULL, CONFIG_STRING_SECURITY);
verify_section_notset(cfg, NULL, CONFIG_STRING_NR_PDCP_LIST);
} // else nothing to be checked
/* other possible verifications: PNF, VNF, CU-CP, CU-UP, ...? */
@@ -1467,6 +1473,55 @@ static seq_arr_t *fill_du_sibs(paramdef_t *GNBparamarray)
return du_SIBs;
}
void config_rlc(configmodule_interface_t *cfg, nr_rlc_configuration_t *rlc_config)
{
/* SRB configuration */
paramdef_t rlc_srb_params[] = NR_RLC_SRB_GLOBALPARAMS_DESC;
int ret = config_get(cfg, rlc_srb_params, sizeofArray(rlc_srb_params), CONFIG_STRING_NR_RLC_SRB);
AssertFatal(ret >= 0, "problem reading NR RLC configuration from configuration file\n");
rlc_config->srb.t_poll_retransmit = config_get_processedint(cfg, &rlc_srb_params[CONFIG_NR_RLC_SRB_T_POLL_RETRANSMIT_IDX]);
rlc_config->srb.t_reassembly = config_get_processedint(cfg, &rlc_srb_params[CONFIG_NR_RLC_SRB_T_REASSEMBLY_IDX]);
rlc_config->srb.t_status_prohibit = config_get_processedint(cfg, &rlc_srb_params[CONFIG_NR_RLC_SRB_T_STATUS_PROHIBIT_IDX]);
rlc_config->srb.poll_pdu = config_get_processedint(cfg, &rlc_srb_params[CONFIG_NR_RLC_SRB_POLL_PDU_IDX]);
rlc_config->srb.poll_byte = config_get_processedint(cfg, &rlc_srb_params[CONFIG_NR_RLC_SRB_POLL_BYTE_IDX]);
rlc_config->srb.max_retx_threshold = config_get_processedint(cfg, &rlc_srb_params[CONFIG_NR_RLC_SRB_MAX_RETX_THRESHOLD_IDX]);
rlc_config->srb.sn_field_length = config_get_processedint(cfg, &rlc_srb_params[CONFIG_NR_RLC_SRB_SN_FIELD_LENGTH_IDX]);
/* DRB AM configuration */
paramdef_t rlc_drb_am_params[] = NR_RLC_DRB_AM_GLOBALPARAMS_DESC;
ret = config_get(cfg, rlc_drb_am_params, sizeofArray(rlc_drb_am_params), CONFIG_STRING_NR_RLC_DRB_AM);
AssertFatal(ret >= 0, "problem reading NR RLC configuration from configuration file\n");
rlc_config->drb_am.t_poll_retransmit = config_get_processedint(cfg, &rlc_drb_am_params[CONFIG_NR_RLC_DRB_AM_T_POLL_RETRANSMIT_IDX]);
rlc_config->drb_am.t_reassembly = config_get_processedint(cfg, &rlc_drb_am_params[CONFIG_NR_RLC_DRB_AM_T_REASSEMBLY_IDX]);
rlc_config->drb_am.t_status_prohibit = config_get_processedint(cfg, &rlc_drb_am_params[CONFIG_NR_RLC_DRB_AM_T_STATUS_PROHIBIT_IDX]);
rlc_config->drb_am.poll_pdu = config_get_processedint(cfg, &rlc_drb_am_params[CONFIG_NR_RLC_DRB_AM_POLL_PDU_IDX]);
rlc_config->drb_am.poll_byte = config_get_processedint(cfg, &rlc_drb_am_params[CONFIG_NR_RLC_DRB_AM_POLL_BYTE_IDX]);
rlc_config->drb_am.max_retx_threshold = config_get_processedint(cfg, &rlc_drb_am_params[CONFIG_NR_RLC_DRB_AM_MAX_RETX_THRESHOLD_IDX]);
rlc_config->drb_am.sn_field_length = config_get_processedint(cfg, &rlc_drb_am_params[CONFIG_NR_RLC_DRB_AM_SN_FIELD_LENGTH_IDX]);
/* DRB UM configuration */
paramdef_t rlc_drb_um_params[] = NR_RLC_DRB_UM_GLOBALPARAMS_DESC;
ret = config_get(cfg, rlc_drb_um_params, sizeofArray(rlc_drb_um_params), CONFIG_STRING_NR_RLC_DRB_UM);
AssertFatal(ret >= 0, "problem reading NR RLC configuration from configuration file\n");
rlc_config->drb_um.t_reassembly = config_get_processedint(cfg, &rlc_drb_um_params[CONFIG_NR_RLC_DRB_UM_T_REASSEMBLY_IDX]);
rlc_config->drb_um.sn_field_length = config_get_processedint(cfg, &rlc_drb_um_params[CONFIG_NR_RLC_DRB_UM_SN_FIELD_LENGTH_IDX]);
}
void config_pdcp(configmodule_interface_t *cfg, nr_pdcp_configuration_t *pdcp_config)
{
/* DRB configuration */
paramdef_t pdcp_params[] = NR_PDCP_DRB_GLOBALPARAMS_DESC;
int ret = config_get(cfg, pdcp_params, sizeofArray(pdcp_params), CONFIG_STRING_NR_PDCP_DRB);
AssertFatal(ret >= 0, "problem reading NR PDCP configuration from configuration file\n");
pdcp_config->drb.sn_size = config_get_processedint(cfg, &pdcp_params[CONFIG_NR_PDCP_DRB_SN_SIZE_IDX]);
pdcp_config->drb.t_reordering = config_get_processedint(cfg, &pdcp_params[CONFIG_NR_PDCP_DRB_T_REORDERING_IDX]);
pdcp_config->drb.discard_timer = config_get_processedint(cfg, &pdcp_params[CONFIG_NR_PDCP_DRB_DISCARD_TIMER_IDX]);
}
void RCconfig_nr_macrlc(configmodule_interface_t *cfg)
{
int j = 0;
@@ -1612,8 +1667,12 @@ void RCconfig_nr_macrlc(configmodule_interface_t *cfg)
NR_ServingCellConfig_t *scd = get_scd_config(cfg);
if (MacRLC_ParamList.numelt > 0) {
/* NR RLC config is needed by mac_top_init_gNB() */
nr_rlc_configuration_t default_rlc_config;
config_rlc(cfg, &default_rlc_config);
ngran_node_t node_type = get_node_type();
mac_top_init_gNB(node_type, scc, scd, &config);
mac_top_init_gNB(node_type, scc, scd, &config, &default_rlc_config);
RC.nb_nr_mac_CC = (int *)malloc(RC.nb_nr_macrlc_inst * sizeof(int));
for (j = 0; j < RC.nb_nr_macrlc_inst; j++) {
@@ -2142,6 +2201,9 @@ gNB_RRC_INST *RCconfig_NRRRC()
if (!NODE_IS_DU(rrc->node_type))
config_security(rrc);
config_rlc(config_get_if(), &rrc->rlc_config);
config_pdcp(config_get_if(), &rrc->pdcp_config);
return rrc;
}
openair2/GNB_APP/gnb_paramdef.h
+211 -1
View File
@@ -680,5 +680,215 @@ typedef enum {
/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
#endif
#define CONFIG_STRING_NR_RLC_LIST "rlc"
#define CONFIG_STRING_NR_PDCP_LIST "pdcp"
#define CONFIG_NR_RLC_T_POLL_RETRANSMIT "t_poll_retransmit"
#define CONFIG_NR_RLC_T_REASSEMBLY "t_reassembly"
#define CONFIG_NR_RLC_T_STATUS_PROHIBIT "t_status_prohibit"
#define CONFIG_NR_RLC_POLL_PDU "poll_pdu"
#define CONFIG_NR_RLC_POLL_BYTE "poll_byte"
#define CONFIG_NR_RLC_MAX_RETX_THRESHOLD "max_retx_threshold"
#define CONFIG_NR_RLC_SN_FIELD_LENGTH "sn_field_length"
/*----------------------------------------------------------------------*/
/* nr rlc srb configuration */
/*----------------------------------------------------------------------*/
#define CONFIG_STRING_NR_RLC_SRB "rlc.srb"
#define CONFIG_NR_RLC_SRB_T_POLL_RETRANSMIT_IDX 0
#define CONFIG_NR_RLC_SRB_T_REASSEMBLY_IDX 1
#define CONFIG_NR_RLC_SRB_T_STATUS_PROHIBIT_IDX 2
#define CONFIG_NR_RLC_SRB_POLL_PDU_IDX 3
#define CONFIG_NR_RLC_SRB_POLL_BYTE_IDX 4
#define CONFIG_NR_RLC_SRB_MAX_RETX_THRESHOLD_IDX 5
#define CONFIG_NR_RLC_SRB_SN_FIELD_LENGTH_IDX 6
#define NR_RLC_SRB_GLOBALPARAMS_DESC { \
{ .optname = CONFIG_NR_RLC_T_POLL_RETRANSMIT, \
.defstrval = "ms45", \
.helpstr = "poll retransmit timer", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_T_POLL_RETRANSMIT_STR }, \
.setintval = { VALUES_NR_RLC_T_POLL_RETRANSMIT }, \
.num_okstrval = SIZEOF_NR_RLC_T_POLL_RETRANSMIT }}}, \
{ .optname = CONFIG_NR_RLC_T_REASSEMBLY, \
.defstrval = "ms35", \
.helpstr = "reassembly timer", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_T_REASSEMBLY_STR }, \
.setintval = { VALUES_NR_RLC_T_REASSEMBLY }, \
.num_okstrval = SIZEOF_NR_RLC_T_REASSEMBLY }}}, \
{ .optname = CONFIG_NR_RLC_T_STATUS_PROHIBIT, \
.defstrval = "ms0", \
.helpstr = "status prohibit timer", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_T_STATUS_PROHIBIT_STR }, \
.setintval = { VALUES_NR_RLC_T_STATUS_PROHIBIT }, \
.num_okstrval = SIZEOF_NR_RLC_T_STATUS_PROHIBIT }}}, \
{ .optname = CONFIG_NR_RLC_POLL_PDU, \
.defstrval = "infinity", \
.helpstr = "pollPDU", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_POLL_PDU_STR }, \
.setintval = { VALUES_NR_RLC_POLL_PDU }, \
.num_okstrval = SIZEOF_NR_RLC_POLL_PDU }}}, \
{ .optname = CONFIG_NR_RLC_POLL_BYTE, \
.defstrval = "infinity", \
.helpstr = "pollByte", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_POLL_BYTE_STR }, \
.setintval = { VALUES_NR_RLC_POLL_BYTE }, \
.num_okstrval = SIZEOF_NR_RLC_POLL_BYTE }}}, \
{ .optname = CONFIG_NR_RLC_MAX_RETX_THRESHOLD, \
.defstrval = "t8", \
.helpstr = "max reTX threshold", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_MAX_RETX_THRESHOLD_STR }, \
.setintval = { VALUES_NR_RLC_MAX_RETX_THRESHOLD }, \
.num_okstrval = SIZEOF_NR_RLC_MAX_RETX_THRESHOLD }}}, \
{ .optname = CONFIG_NR_RLC_SN_FIELD_LENGTH, \
.defstrval = "size12", \
.helpstr = "SN size", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_SN_FIELD_LENGTH_AM_STR }, \
.setintval = { VALUES_NR_RLC_SN_FIELD_LENGTH_AM }, \
.num_okstrval = SIZEOF_NR_RLC_SN_FIELD_LENGTH_AM }}}, \
}
/*----------------------------------------------------------------------*/
/* nr rlc drb am configuration */
/*----------------------------------------------------------------------*/
#define CONFIG_STRING_NR_RLC_DRB_AM "rlc.drb_am"
#define CONFIG_NR_RLC_DRB_AM_T_POLL_RETRANSMIT_IDX 0
#define CONFIG_NR_RLC_DRB_AM_T_REASSEMBLY_IDX 1
#define CONFIG_NR_RLC_DRB_AM_T_STATUS_PROHIBIT_IDX 2
#define CONFIG_NR_RLC_DRB_AM_POLL_PDU_IDX 3
#define CONFIG_NR_RLC_DRB_AM_POLL_BYTE_IDX 4
#define CONFIG_NR_RLC_DRB_AM_MAX_RETX_THRESHOLD_IDX 5
#define CONFIG_NR_RLC_DRB_AM_SN_FIELD_LENGTH_IDX 6
#define NR_RLC_DRB_AM_GLOBALPARAMS_DESC { \
{ .optname = CONFIG_NR_RLC_T_POLL_RETRANSMIT, \
.defstrval = "ms45", \
.helpstr = "poll retransmit timer", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_T_POLL_RETRANSMIT_STR }, \
.setintval = { VALUES_NR_RLC_T_POLL_RETRANSMIT }, \
.num_okstrval = SIZEOF_NR_RLC_T_POLL_RETRANSMIT }}}, \
{ .optname = CONFIG_NR_RLC_T_REASSEMBLY, \
.defstrval = "ms15", \
.helpstr = "reassembly timer", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_T_REASSEMBLY_STR }, \
.setintval = { VALUES_NR_RLC_T_REASSEMBLY }, \
.num_okstrval = SIZEOF_NR_RLC_T_REASSEMBLY }}}, \
{ .optname = CONFIG_NR_RLC_T_STATUS_PROHIBIT, \
.defstrval = "ms15", \
.helpstr = "status prohibit timer", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_T_STATUS_PROHIBIT_STR }, \
.setintval = { VALUES_NR_RLC_T_STATUS_PROHIBIT }, \
.num_okstrval = SIZEOF_NR_RLC_T_STATUS_PROHIBIT }}}, \
{ .optname = CONFIG_NR_RLC_POLL_PDU, \
.defstrval = "p64", \
.helpstr = "pollPDU", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_POLL_PDU_STR }, \
.setintval = { VALUES_NR_RLC_POLL_PDU }, \
.num_okstrval = SIZEOF_NR_RLC_POLL_PDU }}}, \
{ .optname = CONFIG_NR_RLC_POLL_BYTE, \
.defstrval = "kB500", \
.helpstr = "pollByte", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_POLL_BYTE_STR }, \
.setintval = { VALUES_NR_RLC_POLL_BYTE }, \
.num_okstrval = SIZEOF_NR_RLC_POLL_BYTE }}}, \
{ .optname = CONFIG_NR_RLC_MAX_RETX_THRESHOLD, \
.defstrval = "t32", \
.helpstr = "max reTX threshold", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_MAX_RETX_THRESHOLD_STR }, \
.setintval = { VALUES_NR_RLC_MAX_RETX_THRESHOLD }, \
.num_okstrval = SIZEOF_NR_RLC_MAX_RETX_THRESHOLD }}}, \
{ .optname = CONFIG_NR_RLC_SN_FIELD_LENGTH, \
.defstrval = "size18", \
.helpstr = "SN size", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_SN_FIELD_LENGTH_AM_STR }, \
.setintval = { VALUES_NR_RLC_SN_FIELD_LENGTH_AM }, \
.num_okstrval = SIZEOF_NR_RLC_SN_FIELD_LENGTH_AM }}}, \
}
/*----------------------------------------------------------------------*/
/* nr rlc drb um configuration */
/*----------------------------------------------------------------------*/
#define CONFIG_STRING_NR_RLC_DRB_UM "rlc.drb_um"
#define CONFIG_NR_RLC_DRB_UM_T_REASSEMBLY_IDX 0
#define CONFIG_NR_RLC_DRB_UM_SN_FIELD_LENGTH_IDX 1
#define NR_RLC_DRB_UM_GLOBALPARAMS_DESC { \
{ .optname = CONFIG_NR_RLC_T_REASSEMBLY, \
.defstrval = "ms15", \
.helpstr = "reassembly timer", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_T_REASSEMBLY_STR }, \
.setintval = { VALUES_NR_RLC_T_REASSEMBLY }, \
.num_okstrval = SIZEOF_NR_RLC_T_REASSEMBLY }}}, \
{ .optname = CONFIG_NR_RLC_SN_FIELD_LENGTH, \
.defstrval = "size12", \
.helpstr = "SN size", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_RLC_SN_FIELD_LENGTH_UM_STR }, \
.setintval = { VALUES_NR_RLC_SN_FIELD_LENGTH_UM }, \
.num_okstrval = SIZEOF_NR_RLC_SN_FIELD_LENGTH_UM }}}, \
}
/*----------------------------------------------------------------------*/
#define CONFIG_NR_PDCP_SN_SIZE "sn_size"
#define CONFIG_NR_PDCP_T_REORDERING "t_reordering"
#define CONFIG_NR_PDCP_DISCARD_TIMER "discard_timer"
/*----------------------------------------------------------------------*/
/* nr pdcp drb configuration */
/*----------------------------------------------------------------------*/
#define CONFIG_STRING_NR_PDCP_DRB "pdcp.drb"
#define CONFIG_NR_PDCP_DRB_SN_SIZE_IDX 0
#define CONFIG_NR_PDCP_DRB_T_REORDERING_IDX 1
#define CONFIG_NR_PDCP_DRB_DISCARD_TIMER_IDX 2
#define NR_PDCP_DRB_GLOBALPARAMS_DESC { \
{ .optname = CONFIG_NR_PDCP_SN_SIZE, \
.defstrval = "len18bits", \
.helpstr = "SN size", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_PDCP_SN_SIZE_STR }, \
.setintval = { VALUES_NR_PDCP_SN_SIZE }, \
.num_okstrval = SIZEOF_NR_PDCP_SN_SIZE }}}, \
{ .optname = CONFIG_NR_PDCP_T_REORDERING, \
.defstrval = "ms100", \
.helpstr = "reordering timer", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_PDCP_T_REORDERING_STR }, \
.setintval = { VALUES_NR_PDCP_T_REORDERING }, \
.num_okstrval = SIZEOF_NR_PDCP_T_REORDERING }}}, \
{ .optname = CONFIG_NR_PDCP_DISCARD_TIMER, \
.defstrval = "infinity", \
.helpstr = "discard timer", .paramflags = 0, .strptr = NULL, .type = TYPE_STRING, .numelt = 0, \
.chkPptr = &(checkedparam_t){ .s3a = { .f3a = config_checkstr_assign_integer, \
.okstrval = { VALUES_NR_PDCP_DISCARD_TIMER_STR }, \
.setintval = { VALUES_NR_PDCP_DISCARD_TIMER }, \
.num_okstrval = SIZEOF_NR_PDCP_DISCARD_TIMER }}} \
}
/*----------------------------------------------------------------------*/
#endif
openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c
+1 -1
View File
@@ -3326,7 +3326,7 @@ bool prepare_initial_ul_rrc_message(gNB_MAC_INST *mac, NR_UE_info_t *UE)
int srb_id = 1;
const NR_ServingCellConfigCommon_t *scc = mac->common_channels[CC_id].ServingCellConfigCommon;
const NR_ServingCellConfig_t *sccd = UE->is_redcap ? NULL : mac->common_channels[CC_id].pre_ServingCellConfig;
NR_CellGroupConfig_t *cellGroupConfig = get_initial_cellGroupConfig(UE->uid, scc, sccd, &mac->radio_config);
NR_CellGroupConfig_t *cellGroupConfig = get_initial_cellGroupConfig(UE->uid, scc, sccd, &mac->radio_config, &mac->rlc_config);
ASN_STRUCT_FREE(asn_DEF_NR_CellGroupConfig, UE->CellGroup);
UE->CellGroup = cellGroupConfig;
openair2/LAYER2/NR_MAC_gNB/mac_proto.h
+3 -1
View File
@@ -34,6 +34,7 @@
#include "LAYER2/NR_MAC_gNB/nr_mac_gNB.h"
#include "NR_TAG-Id.h"
#include "common/ngran_types.h"
#include "openair2/LAYER2/nr_pdcp/nr_pdcp_configuration.h"
void set_cset_offset(uint16_t);
void get_K1_K2(int N1, int N2, int *K1, int *K2, int layers);
@@ -52,7 +53,8 @@ void delete_nr_ue_data(NR_UE_info_t *UE, NR_COMMON_channels_t *ccPtr, uid_alloca
void mac_top_init_gNB(ngran_node_t node_type,
NR_ServingCellConfigCommon_t *scc,
NR_ServingCellConfig_t *scd,
const nr_mac_config_t *conf);
const nr_mac_config_t *conf,
const nr_rlc_configuration_t *default_rlc_config);
void mac_top_destroy_gNB(gNB_MAC_INST *mac);
void nr_mac_send_f1_setup_req(void);
openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.c
+21 -13
View File
@@ -221,19 +221,21 @@ void gnb_du_configuration_update_acknowledge(const f1ap_gnb_du_configuration_upd
LOG_I(MAC, "received gNB-DU configuration update acknowledge\n");
}
static NR_RLC_BearerConfig_t *get_bearerconfig_from_srb(const f1ap_srb_to_be_setup_t *srb)
static NR_RLC_BearerConfig_t *get_bearerconfig_from_srb(const f1ap_srb_to_be_setup_t *srb,
const nr_rlc_configuration_t *rlc_config)
{
long priority = srb->srb_id == 2 ? 3 : 1; // see 38.331 sec 9.2.1
e_NR_LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration bucket =
NR_LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms5;
return get_SRB_RLC_BearerConfig(get_lcid_from_srbid(srb->srb_id), priority, bucket);
return get_SRB_RLC_BearerConfig(get_lcid_from_srbid(srb->srb_id), priority, bucket, rlc_config);
}
static int handle_ue_context_srbs_setup(NR_UE_info_t *UE,
int srbs_len,
const f1ap_srb_to_be_setup_t *req_srbs,
f1ap_srb_to_be_setup_t **resp_srbs,
NR_CellGroupConfig_t *cellGroupConfig)
NR_CellGroupConfig_t *cellGroupConfig,
const nr_rlc_configuration_t *rlc_config)
{
DevAssert(req_srbs != NULL && resp_srbs != NULL && cellGroupConfig != NULL);
@@ -241,7 +243,7 @@ static int handle_ue_context_srbs_setup(NR_UE_info_t *UE,
AssertFatal(*resp_srbs != NULL, "out of memory\n");
for (int i = 0; i < srbs_len; i++) {
const f1ap_srb_to_be_setup_t *srb = &req_srbs[i];
NR_RLC_BearerConfig_t *rlc_BearerConfig = get_bearerconfig_from_srb(srb);
NR_RLC_BearerConfig_t *rlc_BearerConfig = get_bearerconfig_from_srb(srb, rlc_config);
nr_rlc_add_srb(UE->rnti, srb->srb_id, rlc_BearerConfig);
int priority = rlc_BearerConfig->mac_LogicalChannelConfig->ul_SpecificParameters->priority;
@@ -265,11 +267,12 @@ static int handle_ue_context_srbs_setup(NR_UE_info_t *UE,
return srbs_len;
}
static NR_RLC_BearerConfig_t *get_bearerconfig_from_drb(const f1ap_drb_to_be_setup_t *drb)
static NR_RLC_BearerConfig_t *get_bearerconfig_from_drb(const f1ap_drb_to_be_setup_t *drb,
const nr_rlc_configuration_t *rlc_config)
{
const NR_RLC_Config_PR rlc_conf = drb->rlc_mode == F1AP_RLC_MODE_AM ? NR_RLC_Config_PR_am : NR_RLC_Config_PR_um_Bi_Directional;
long priority = 13; // hardcoded for the moment
return get_DRB_RLC_BearerConfig(get_lcid_from_drbid(drb->drb_id), drb->drb_id, rlc_conf, priority);
return get_DRB_RLC_BearerConfig(get_lcid_from_drbid(drb->drb_id), drb->drb_id, rlc_conf, priority, rlc_config);
}
static int get_non_dynamic_priority(int fiveqi)
@@ -304,7 +307,8 @@ static int handle_ue_context_drbs_setup(NR_UE_info_t *UE,
int drbs_len,
const f1ap_drb_to_be_setup_t *req_drbs,
f1ap_drb_to_be_setup_t **resp_drbs,
NR_CellGroupConfig_t *cellGroupConfig)
NR_CellGroupConfig_t *cellGroupConfig,
const nr_rlc_configuration_t *rlc_config)
{
DevAssert(req_drbs != NULL && resp_drbs != NULL && cellGroupConfig != NULL);
instance_t f1inst = get_f1_gtp_instance();
@@ -316,7 +320,7 @@ static int handle_ue_context_drbs_setup(NR_UE_info_t *UE,
for (int i = 0; i < drbs_len; i++) {
const f1ap_drb_to_be_setup_t *drb = &req_drbs[i];
f1ap_drb_to_be_setup_t *resp_drb = &(*resp_drbs)[i];
NR_RLC_BearerConfig_t *rlc_BearerConfig = get_bearerconfig_from_drb(drb);
NR_RLC_BearerConfig_t *rlc_BearerConfig = get_bearerconfig_from_drb(drb, rlc_config);
nr_rlc_add_drb(UE->rnti, drb->drb_id, rlc_BearerConfig);
nr_lc_config_t c = {.lcid = rlc_BearerConfig->logicalChannelIdentity, .nssai = drb->nssai};
@@ -557,7 +561,7 @@ static NR_UE_info_t *create_new_UE(gNB_MAC_INST *mac, uint32_t cu_id, const NR_C
const NR_ServingCellConfig_t *sccd = cc->pre_ServingCellConfig;
const nr_mac_config_t *configuration = &mac->radio_config;
if (is_SA) {
cellGroupConfig = get_initial_cellGroupConfig(UE->uid, scc, sccd, &mac->radio_config);
cellGroupConfig = get_initial_cellGroupConfig(UE->uid, scc, sccd, &mac->radio_config, &mac->rlc_config);
cellGroupConfig->spCellConfig->reconfigurationWithSync = get_reconfiguration_with_sync(UE->rnti, UE->uid, scc);
} else {
NR_UE_NR_Capability_t *cap = get_ue_nr_cap_from_cg_config_info(cgci);
@@ -649,7 +653,8 @@ void ue_context_setup_request(const f1ap_ue_context_setup_t *req)
req->srbs_to_be_setup_length,
req->srbs_to_be_setup,
&resp.srbs_to_be_setup,
new_CellGroup);
new_CellGroup,
&mac->rlc_config);
}
if (req->drbs_to_be_setup_length > 0) {
@@ -657,7 +662,8 @@ void ue_context_setup_request(const f1ap_ue_context_setup_t *req)
req->drbs_to_be_setup_length,
req->drbs_to_be_setup,
&resp.drbs_to_be_setup,
new_CellGroup);
new_CellGroup,
&mac->rlc_config);
}
if (req->rrc_container != NULL) {
@@ -747,7 +753,8 @@ void ue_context_modification_request(const f1ap_ue_context_modif_req_t *req)
req->srbs_to_be_setup_length,
req->srbs_to_be_setup,
&resp.srbs_to_be_setup,
new_CellGroup);
new_CellGroup,
&mac->rlc_config);
}
if (req->drbs_to_be_setup_length > 0) {
@@ -755,7 +762,8 @@ void ue_context_modification_request(const f1ap_ue_context_modif_req_t *req)
req->drbs_to_be_setup_length,
req->drbs_to_be_setup,
&resp.drbs_to_be_setup,
new_CellGroup);
new_CellGroup,
&mac->rlc_config);
}
if (req->drbs_to_be_released_length > 0) {
openair2/LAYER2/NR_MAC_gNB/main.c
+3 -1
View File
@@ -236,7 +236,8 @@ static void mac_rrc_init(gNB_MAC_INST *mac, ngran_node_t node_type)
void mac_top_init_gNB(ngran_node_t node_type,
NR_ServingCellConfigCommon_t *scc,
NR_ServingCellConfig_t *scd,
const nr_mac_config_t *config)
const nr_mac_config_t *config,
const nr_rlc_configuration_t *default_rlc_config)
{
module_id_t i;
gNB_MAC_INST *nrmac;
@@ -272,6 +273,7 @@ void mac_top_init_gNB(ngran_node_t node_type,
RC.nrmac[i]->common_channels[0].ServingCellConfigCommon = scc;
RC.nrmac[i]->radio_config = *config;
RC.nrmac[i]->rlc_config = *default_rlc_config;
RC.nrmac[i]->common_channels[0].pre_ServingCellConfig = scd;
openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h
+2
View File
@@ -45,6 +45,7 @@
#include "common/utils/ds/seq_arr.h"
#include "common/utils/nr/nr_common.h"
#include "common/utils/ds/byte_array.h"
#include "openair2/LAYER2/nr_rlc/nr_rlc_configuration.h"
#define NR_SCHED_LOCK(lock) \
do { \
@@ -899,6 +900,7 @@ typedef struct gNB_MAC_INST_s {
nr_pp_impl_ul pre_processor_ul;
nr_mac_config_t radio_config;
nr_rlc_configuration_t rlc_config;
NR_UE_sched_ctrl_t *sched_ctrlCommon;
NR_sched_pdcch_t *sched_pdcch_otherSI;
openair2/LAYER2/NR_MAC_gNB/nr_radio_config.c
+36 -25
View File
@@ -40,6 +40,7 @@
#include "openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h"
#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h"
#include "openair3/UTILS/conversions.h"
#include "LAYER2/nr_rlc/nr_rlc_asn1_utils.h"
#include "NR_MeasurementTimingConfiguration.h"
#include "uper_decoder.h"
@@ -3338,7 +3339,10 @@ static NR_SpCellConfig_t *get_initial_SpCellConfig(int uid,
return SpCellConfig;
}
NR_RLC_BearerConfig_t *get_SRB_RLC_BearerConfig(long channelId, long priority, long bucketSizeDuration)
NR_RLC_BearerConfig_t *get_SRB_RLC_BearerConfig(long channelId,
long priority,
long bucketSizeDuration,
const nr_rlc_configuration_t *default_rlc_config)
{
NR_RLC_BearerConfig_t *rlc_BearerConfig = NULL;
rlc_BearerConfig = calloc(1, sizeof(NR_RLC_BearerConfig_t));
@@ -3352,15 +3356,15 @@ NR_RLC_BearerConfig_t *get_SRB_RLC_BearerConfig(long channelId, long priority, l
rlc_Config->present = NR_RLC_Config_PR_am;
rlc_Config->choice.am = calloc(1, sizeof(*rlc_Config->choice.am));
rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength = calloc(1, sizeof(NR_SN_FieldLengthAM_t));
*(rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength) = NR_SN_FieldLengthAM_size12;
rlc_Config->choice.am->dl_AM_RLC.t_Reassembly = NR_T_Reassembly_ms35;
rlc_Config->choice.am->dl_AM_RLC.t_StatusProhibit = NR_T_StatusProhibit_ms0;
*(rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength) = encode_sn_field_length_am(default_rlc_config->srb.sn_field_length);
rlc_Config->choice.am->dl_AM_RLC.t_Reassembly = encode_t_reassembly(default_rlc_config->srb.t_reassembly);
rlc_Config->choice.am->dl_AM_RLC.t_StatusProhibit = encode_t_status_prohibit(default_rlc_config->srb.t_status_prohibit);
rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength = calloc(1, sizeof(NR_SN_FieldLengthAM_t));
*(rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength) = NR_SN_FieldLengthAM_size12;
rlc_Config->choice.am->ul_AM_RLC.t_PollRetransmit = NR_T_PollRetransmit_ms45;
rlc_Config->choice.am->ul_AM_RLC.pollPDU = NR_PollPDU_infinity;
rlc_Config->choice.am->ul_AM_RLC.pollByte = NR_PollByte_infinity;
rlc_Config->choice.am->ul_AM_RLC.maxRetxThreshold = NR_UL_AM_RLC__maxRetxThreshold_t8;
*(rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength) = encode_sn_field_length_am(default_rlc_config->srb.sn_field_length);
rlc_Config->choice.am->ul_AM_RLC.t_PollRetransmit = encode_t_poll_retransmit(default_rlc_config->srb.t_poll_retransmit);
rlc_Config->choice.am->ul_AM_RLC.pollPDU = encode_poll_pdu(default_rlc_config->srb.poll_pdu);
rlc_Config->choice.am->ul_AM_RLC.pollByte = encode_poll_byte(default_rlc_config->srb.poll_byte);
rlc_Config->choice.am->ul_AM_RLC.maxRetxThreshold = encode_max_retx_threshold(default_rlc_config->srb.max_retx_threshold);
rlc_BearerConfig->rlc_Config = rlc_Config;
NR_LogicalChannelConfig_t *logicalChannelConfig = calloc(1, sizeof(NR_LogicalChannelConfig_t));
@@ -3381,7 +3385,9 @@ NR_RLC_BearerConfig_t *get_SRB_RLC_BearerConfig(long channelId, long priority, l
return rlc_BearerConfig;
}
static void nr_drb_config(struct NR_RLC_Config *rlc_Config, NR_RLC_Config_PR rlc_config_pr)
static void nr_drb_config(struct NR_RLC_Config *rlc_Config,
NR_RLC_Config_PR rlc_config_pr,
const nr_rlc_configuration_t *default_rlc_config)
{
switch (rlc_config_pr) {
case NR_RLC_Config_PR_um_Bi_Directional:
@@ -3390,25 +3396,25 @@ static void nr_drb_config(struct NR_RLC_Config *rlc_Config, NR_RLC_Config_PR rlc
rlc_Config->choice.um_Bi_Directional = calloc(1, sizeof(*rlc_Config->choice.um_Bi_Directional));
rlc_Config->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength =
calloc(1, sizeof(*rlc_Config->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength));
*rlc_Config->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NR_SN_FieldLengthUM_size12;
*rlc_Config->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = encode_sn_field_length_um(default_rlc_config->drb_um.sn_field_length);
rlc_Config->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength =
calloc(1, sizeof(*rlc_Config->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength));
*rlc_Config->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NR_SN_FieldLengthUM_size12;
rlc_Config->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = NR_T_Reassembly_ms15;
*rlc_Config->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = encode_sn_field_length_um(default_rlc_config->drb_um.sn_field_length);
rlc_Config->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = encode_t_reassembly(default_rlc_config->drb_um.t_reassembly);
break;
case NR_RLC_Config_PR_am:
// RLC AM Bearer configuration
rlc_Config->choice.am = calloc(1, sizeof(*rlc_Config->choice.am));
rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength = calloc(1, sizeof(*rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength));
*rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength = NR_SN_FieldLengthAM_size18;
rlc_Config->choice.am->ul_AM_RLC.t_PollRetransmit = NR_T_PollRetransmit_ms45;
rlc_Config->choice.am->ul_AM_RLC.pollPDU = NR_PollPDU_p64;
rlc_Config->choice.am->ul_AM_RLC.pollByte = NR_PollByte_kB500;
rlc_Config->choice.am->ul_AM_RLC.maxRetxThreshold = NR_UL_AM_RLC__maxRetxThreshold_t32;
*rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength = encode_sn_field_length_am(default_rlc_config->drb_am.sn_field_length);
rlc_Config->choice.am->ul_AM_RLC.t_PollRetransmit = encode_t_poll_retransmit(default_rlc_config->drb_am.t_poll_retransmit);
rlc_Config->choice.am->ul_AM_RLC.pollPDU = encode_poll_pdu(default_rlc_config->drb_am.poll_pdu);
rlc_Config->choice.am->ul_AM_RLC.pollByte = encode_poll_byte(default_rlc_config->drb_am.poll_byte);
rlc_Config->choice.am->ul_AM_RLC.maxRetxThreshold = encode_max_retx_threshold(default_rlc_config->drb_am.max_retx_threshold);
rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength = calloc(1, sizeof(*rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength));
*rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength = NR_SN_FieldLengthAM_size18;
rlc_Config->choice.am->dl_AM_RLC.t_Reassembly = NR_T_Reassembly_ms15;
rlc_Config->choice.am->dl_AM_RLC.t_StatusProhibit = NR_T_StatusProhibit_ms15;
*rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength = encode_sn_field_length_am(default_rlc_config->drb_am.sn_field_length);
rlc_Config->choice.am->dl_AM_RLC.t_Reassembly = encode_t_reassembly(default_rlc_config->drb_am.t_reassembly);
rlc_Config->choice.am->dl_AM_RLC.t_StatusProhibit = encode_t_status_prohibit(default_rlc_config->drb_am.t_status_prohibit);
break;
default:
AssertFatal(false, "RLC config type %d not handled\n", rlc_config_pr);
@@ -3417,7 +3423,11 @@ static void nr_drb_config(struct NR_RLC_Config *rlc_Config, NR_RLC_Config_PR rlc
rlc_Config->present = rlc_config_pr;
}
NR_RLC_BearerConfig_t *get_DRB_RLC_BearerConfig(long lcChannelId, long drbId, NR_RLC_Config_PR rlc_conf, long priority)
NR_RLC_BearerConfig_t *get_DRB_RLC_BearerConfig(long lcChannelId,
long drbId,
NR_RLC_Config_PR rlc_conf,
long priority,
const nr_rlc_configuration_t *default_rlc_config)
{
NR_RLC_BearerConfig_t *rlc_BearerConfig = calloc(1, sizeof(NR_RLC_BearerConfig_t));
rlc_BearerConfig->logicalChannelIdentity = lcChannelId;
@@ -3427,7 +3437,7 @@ NR_RLC_BearerConfig_t *get_DRB_RLC_BearerConfig(long lcChannelId, long drbId, NR
rlc_BearerConfig->reestablishRLC = NULL;
NR_RLC_Config_t *rlc_Config = calloc(1, sizeof(NR_RLC_Config_t));
nr_drb_config(rlc_Config, rlc_conf);
nr_drb_config(rlc_Config, rlc_conf, default_rlc_config);
rlc_BearerConfig->rlc_Config = rlc_Config;
NR_LogicalChannelConfig_t *logicalChannelConfig = calloc(1, sizeof(NR_LogicalChannelConfig_t));
@@ -3451,7 +3461,8 @@ NR_RLC_BearerConfig_t *get_DRB_RLC_BearerConfig(long lcChannelId, long drbId, NR
NR_CellGroupConfig_t *get_initial_cellGroupConfig(int uid,
const NR_ServingCellConfigCommon_t *scc,
const NR_ServingCellConfig_t *servingcellconfigdedicated,
const nr_mac_config_t *configuration)
const nr_mac_config_t *configuration,
const nr_rlc_configuration_t *default_rlc_config)
{
NR_CellGroupConfig_t *cellGroupConfig = calloc(1, sizeof(*cellGroupConfig));
cellGroupConfig->cellGroupId = 0;
@@ -3460,7 +3471,7 @@ NR_CellGroupConfig_t *get_initial_cellGroupConfig(int uid,
/* TS38.331 9.2.1 Default SRB configurations */
cellGroupConfig->rlc_BearerToAddModList = calloc(1, sizeof(*cellGroupConfig->rlc_BearerToAddModList));
NR_RLC_BearerConfig_t *rlc_BearerConfig =
get_SRB_RLC_BearerConfig(1, 1, NR_LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms1000);
get_SRB_RLC_BearerConfig(1, 1, NR_LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms1000, default_rlc_config);
asn1cSeqAdd(&cellGroupConfig->rlc_BearerToAddModList->list, rlc_BearerConfig);
cellGroupConfig->rlc_BearerToReleaseList = NULL;
openair2/LAYER2/NR_MAC_gNB/nr_radio_config.h
+12 -3
View File
@@ -31,6 +31,7 @@
#include "NR_UL-CCCH-Message.h"
#include "f1ap_messages_types.h"
#include "common/platform_types.h"
#include "openair2/LAYER2/nr_rlc/nr_rlc_configuration.h"
struct NR_MeasurementTimingConfiguration;
struct NR_PDSCH_TimeDomainResourceAllocationList;
@@ -84,7 +85,8 @@ NR_SIB19_r17_t *get_SIB19_NR(const NR_ServingCellConfigCommon_t *scc);
NR_CellGroupConfig_t *get_initial_cellGroupConfig(int uid,
const NR_ServingCellConfigCommon_t *scc,
const NR_ServingCellConfig_t *servingcellconfigdedicated,
const nr_mac_config_t *configuration);
const nr_mac_config_t *configuration,
const nr_rlc_configuration_t *default_rlc_config);
void update_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig,
const int uid,
NR_UE_NR_Capability_t *uecap,
@@ -107,7 +109,14 @@ NR_CellGroupConfig_t *get_default_secondaryCellGroup(const NR_ServingCellConfigC
NR_ReconfigurationWithSync_t *get_reconfiguration_with_sync(rnti_t rnti, uid_t uid, const NR_ServingCellConfigCommon_t *scc);
NR_RLC_BearerConfig_t *get_SRB_RLC_BearerConfig(long channelId, long priority, long bucketSizeDuration);
NR_RLC_BearerConfig_t *get_DRB_RLC_BearerConfig(long lcChannelId, long drbId, NR_RLC_Config_PR rlc_conf, long priority);
NR_RLC_BearerConfig_t *get_SRB_RLC_BearerConfig(long channelId,
long priority,
long bucketSizeDuration,
const nr_rlc_configuration_t *default_rlc_config);
NR_RLC_BearerConfig_t *get_DRB_RLC_BearerConfig(long lcChannelId,
long drbId,
NR_RLC_Config_PR rlc_conf,
long priority,
const nr_rlc_configuration_t *default_rlc_config);
#endif
openair2/LAYER2/nr_pdcp/asn1_utils.c
+22 -55
View File
@@ -19,63 +19,30 @@
* contact@openairinterface.org
*/
#include "nr_pdcp_asn1_utils.h"
#include "common/utils/LOG/log.h"
#include "nr_pdcp_entity.h"
#include "nr_pdcp_configuration.h"
int decode_t_reordering(int v)
{
static const int tab[36] = {0, 1, 2, 4, 5, 8, 10, 15, 20, 30, 40, 50, 60, 80, 100, 120, 140, 160,
180, 200, 220, 240, 260, 280, 300, 500, 750, 1000, 1250, 1500, 1750, 2000, 2250, 2500, 2750, 3000};
if (v < 0 || v > 35) {
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
return tab[v];
#define ENCODE_DECODE(a, b) \
int decode_##a(int v) \
{ \
static const int tab[] = { VALUES_NR_PDCP_##b }; \
AssertFatal(v >= 0 && v < SIZEOF_NR_PDCP_##b, \
"bad encoded value " #a " %d\n", v); \
return tab[v]; \
} \
\
int encode_##a(int v) \
{ \
static const int tab[] = { VALUES_NR_PDCP_##b }; \
for (int ret = 0; ret < SIZEOF_NR_PDCP_##b; ret++) \
if (tab[ret] == v) \
return ret; \
AssertFatal(0, "bad " #a " value %d\n", v); \
}
int decode_sn_size_ul(long s)
{
if (s == 0) return SHORT_SN_SIZE;
if (s == 1) return LONG_SN_SIZE;
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
int decode_sn_size_dl(long s)
{
if (s == 0) return SHORT_SN_SIZE;
if (s == 1) return LONG_SN_SIZE;
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
int decode_discard_timer(long v)
{
static const int tab[16] = {
10,
20,
30,
40,
50,
60,
75,
100,
150,
200,
250,
300,
500,
750,
1500,
-1,
};
if (v < 0 || v > 15) {
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
return tab[v];
}
ENCODE_DECODE(t_reordering, T_REORDERING)
ENCODE_DECODE(sn_size_ul, SN_SIZE)
ENCODE_DECODE(sn_size_dl, SN_SIZE)
ENCODE_DECODE(discard_timer, DISCARD_TIMER)
openair2/LAYER2/nr_pdcp/nr_pdcp_asn1_utils.h
+8 -3
View File
@@ -23,8 +23,13 @@
#define _OPENAIR2_LAYER2_NR_PDCP_ASN1_UTILS_H_
int decode_t_reordering(int v);
int decode_sn_size_ul(long s);
int decode_sn_size_dl(long s);
int decode_discard_timer(long v);
int decode_sn_size_ul(int v);
int decode_sn_size_dl(int v);
int decode_discard_timer(int v);
int encode_t_reordering(int v);
int encode_sn_size_ul(int v);
int encode_sn_size_dl(int v);
int encode_discard_timer(int v);
#endif /* _OPENAIR2_LAYER2_NR_PDCP_ASN1_UTILS_H_ */
openair2/LAYER2/nr_pdcp/nr_pdcp_configuration.h
+70
View File
@@ -0,0 +1,70 @@
/*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.1 (the "License"); you may not use this file
* except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.openairinterface.org/?page_id=698
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org
*/
#ifndef _NR_PDCP_CONFIGURATION_H_
#define _NR_PDCP_CONFIGURATION_H_
#ifndef INT_LIST_SIZE
#define INT_LIST_SIZE(x) (sizeof((int[]){x})/sizeof(int))
#endif
/* values taken from 3GPP TS 38.331 version 17.3.0 */
#define VALUES_NR_PDCP_SN_SIZE \
12, 18
#define VALUES_NR_PDCP_SN_SIZE_STR \
"len12bits", "len18bits"
#define SIZEOF_NR_PDCP_SN_SIZE INT_LIST_SIZE(VALUES_NR_PDCP_SN_SIZE)
#define VALUES_NR_PDCP_T_REORDERING \
0, 1, 2, 4, 5, 8, 10, 15, 20, 30, 40, 50, \
60, 80, 100, 120, 140, 160, 180, 200, 220, 240, 260, 280, \
300, 500, 750, 1000, 1250, 1500, 1750, 2000, 2250, 2500, 2750, 3000, \
-1 /* -1 means infinity */ \
#define VALUES_NR_PDCP_T_REORDERING_STR \
"ms0", "ms1", "ms2", "ms4", "ms5", "ms8", "ms10", "ms15", "ms20", "ms30", "ms40", "ms50", \
"ms60", "ms80", "ms100", "ms120", "ms140", "ms160", "ms180", "ms200", "ms220", "ms240", "ms260", "ms280", \
"ms300", "ms500", "ms750", "ms1000", "ms1250", "ms1500", "ms1750", "ms2000", "ms2250", "ms2500", "ms2750", "ms3000", \
"infinity"
#define SIZEOF_NR_PDCP_T_REORDERING INT_LIST_SIZE(VALUES_NR_PDCP_T_REORDERING)
#define VALUES_NR_PDCP_DISCARD_TIMER \
10, 20, 30, 40, 50, 60, 75, 100, 150, 200, 250, 300, 500, 750, 1500, -1 /* -1 means infinity */
#define VALUES_NR_PDCP_DISCARD_TIMER_STR \
"ms10", "ms20", "ms30", "ms40", "ms50", "ms60", "ms75", "ms100", "ms150", "ms200", "ms250", "ms300", "ms500", "ms750", "ms1500", "infinity"
#define SIZEOF_NR_PDCP_DISCARD_TIMER INT_LIST_SIZE(VALUES_NR_PDCP_DISCARD_TIMER)
/* configuration of NR PDCP, coming from configuration file */
typedef struct {
struct {
int sn_size;
int t_reordering;
int discard_timer;
} drb;
} nr_pdcp_configuration_t;
#endif /* _NR_PDCP_CONFIGURATION_H_ */
openair2/LAYER2/nr_rlc/asn1_utils.c
+26 -150
View File
@@ -19,157 +19,33 @@
* contact@openairinterface.org
*/
#include "nr_rlc_asn1_utils.h"
#include "rlc.h"
#include "nr_rlc_configuration.h"
int decode_t_reassembly(int v)
{
static const int tab[31] = {0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75,
80, 85, 90, 95, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200};
if (v < 0 || v > 30) {
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
return tab[v];
#define ENCODE_DECODE(a, b) \
int decode_##a(int v) \
{ \
static const int tab[] = { VALUES_NR_RLC_##b }; \
AssertFatal(v >= 0 && v < SIZEOF_NR_RLC_##b, \
"bad encoded value " #a " %d\n", v); \
return tab[v]; \
} \
\
int encode_##a(int v) \
{ \
static const int tab[] = { VALUES_NR_RLC_##b }; \
for (int ret = 0; ret < SIZEOF_NR_RLC_##b; ret++) \
if (tab[ret] == v) \
return ret; \
AssertFatal(0, "bad " #a " value %d\n", v); \
}
int decode_t_status_prohibit(int v)
{
static const int tab[62] = {0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75,
80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155,
160, 165, 170, 175, 180, 185, 190, 195, 200, 205, 210, 215, 220, 225, 230, 235,
240, 245, 250, 300, 350, 400, 450, 500, 800, 1000, 1200, 1600, 2000, 2400};
if (v < 0 || v > 61) {
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
return tab[v];
}
int decode_t_poll_retransmit(int v)
{
static const int tab[59] = {5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100,
105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, 180, 185, 190, 195, 200,
205, 210, 215, 220, 225, 230, 235, 240, 245, 250, 300, 350, 400, 450, 500, 800, 1000, 2000, 4000};
if (v < 0 || v > 58) {
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
return tab[v];
}
int decode_poll_pdu(int v)
{
static const int tab[24] = {
4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 6144,
8192, 12288, 16384, 20480, 24576, 28672, 32768, 40960, 49152, 57344, 65536, -1 /* -1 means infinity */
};
if (v < 0 || v > 23) {
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
return tab[v];
}
int decode_poll_byte(int v)
{
static const int tab[44] = {
/* KB */
1024 * 1,
1024 * 2,
1024 * 5,
1024 * 8,
1024 * 10,
1024 * 15,
1024 * 25,
1024 * 50,
1024 * 75,
1024 * 100,
1024 * 125,
1024 * 250,
1024 * 375,
1024 * 500,
1024 * 750,
1024 * 1000,
1024 * 1250,
1024 * 1500,
1024 * 2000,
1024 * 3000,
1024 * 4000,
1024 * 4500,
1024 * 5000,
1024 * 5500,
1024 * 6000,
1024 * 6500,
1024 * 7000,
1024 * 7500,
/* MB */
1024 * 1024 * 8,
1024 * 1024 * 9,
1024 * 1024 * 10,
1024 * 1024 * 11,
1024 * 1024 * 12,
1024 * 1024 * 13,
1024 * 1024 * 14,
1024 * 1024 * 15,
1024 * 1024 * 16,
1024 * 1024 * 17,
1024 * 1024 * 18,
1024 * 1024 * 20,
1024 * 1024 * 25,
1024 * 1024 * 30,
1024 * 1024 * 40,
-1 /* -1 means infinity */
};
if (v < 0 || v > 43) {
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
if (tab[v] == -1) return -1;
return tab[v];
}
int decode_max_retx_threshold(int v)
{
static const int tab[8] = {1, 2, 3, 4, 6, 8, 16, 32};
if (v < 0 || v > 7) {
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
return tab[v];
}
int decode_sn_field_length_um(int v)
{
static const int tab[2] = {6, 12};
if (v < 0 || v > 1) {
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
return tab[v];
}
int decode_sn_field_length_am(int v)
{
static const int tab[2] = {12, 18};
if (v < 0 || v > 1) {
LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
return tab[v];
}
ENCODE_DECODE(t_reassembly, T_REASSEMBLY)
ENCODE_DECODE(t_status_prohibit, T_STATUS_PROHIBIT)
ENCODE_DECODE(t_poll_retransmit, T_POLL_RETRANSMIT)
ENCODE_DECODE(poll_pdu, POLL_PDU)
ENCODE_DECODE(poll_byte, POLL_BYTE)
ENCODE_DECODE(max_retx_threshold, MAX_RETX_THRESHOLD)
ENCODE_DECODE(sn_field_length_am, SN_FIELD_LENGTH_AM)
ENCODE_DECODE(sn_field_length_um, SN_FIELD_LENGTH_UM)
openair2/LAYER2/nr_rlc/nr_rlc_asn1_utils.h
+9
View File
@@ -31,4 +31,13 @@ int decode_max_retx_threshold(int v);
int decode_sn_field_length_um(int v);
int decode_sn_field_length_am(int v);
int encode_t_reassembly(int v);
int encode_t_status_prohibit(int v);
int encode_t_poll_retransmit(int v);
int encode_poll_pdu(int v);
int encode_poll_byte(int v);
int encode_max_retx_threshold(int v);
int encode_sn_field_length_um(int v);
int encode_sn_field_length_am(int v);
#endif /* _OPENAIR2_LAYER2_NR_RLC_ASN1_UTILS_H_ */
openair2/LAYER2/nr_rlc/nr_rlc_configuration.h
+160
View File
@@ -0,0 +1,160 @@
/*
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The OpenAirInterface Software Alliance licenses this file to You under
* the OAI Public License, Version 1.1 (the "License"); you may not use this file
* except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.openairinterface.org/?page_id=698
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*-------------------------------------------------------------------------------
* For more information about the OpenAirInterface (OAI) Software Alliance:
* contact@openairinterface.org
*/
#ifndef _NR_RLC_CONFIGURATION_H_
#define _NR_RLC_CONFIGURATION_H_
#ifndef INT_LIST_SIZE
#define INT_LIST_SIZE(x) (sizeof((int[]){x})/sizeof(int))
#endif
/* values taken from 3GPP TS 38.331 version 17.3.0 */
#define VALUES_NR_RLC_T_POLL_RETRANSMIT \
5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, \
75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, \
145, 150, 155, 160, 165, 170, 175, 180, 185, 190, 195, 200, 205, 210, \
215, 220, 225, 230, 235, 240, 245, 250, 300, 350, 400, 450, 500, 800, \
1000, 2000, 4000, 1, 2, 4
#define VALUES_NR_RLC_T_POLL_RETRANSMIT_STR \
"ms5", "ms10", "ms15", "ms20", "ms25", "ms30", "ms35", "ms40", "ms45", "ms50", "ms55", "ms60", "ms65", "ms70", \
"ms75", "ms80", "ms85", "ms90", "ms95", "ms100", "ms105", "ms110", "ms115", "ms120", "ms125", "ms130", "ms135", "ms140", \
"ms145", "ms150", "ms155", "ms160", "ms165", "ms170", "ms175", "ms180", "ms185", "ms190", "ms195", "ms200", "ms205", "ms210", \
"ms215", "ms220", "ms225", "ms230", "ms235", "ms240", "ms245", "ms250", "ms300", "ms350", "ms400", "ms450", "ms500", "ms800", \
"ms1000", "ms2000", "ms4000", "ms1", "ms2", "ms4"
#define SIZEOF_NR_RLC_T_POLL_RETRANSMIT INT_LIST_SIZE(VALUES_NR_RLC_T_POLL_RETRANSMIT)
#define VALUES_NR_RLC_T_REASSEMBLY \
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, \
80, 85, 90, 95, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200
#define VALUES_NR_RLC_T_REASSEMBLY_STR \
"ms0", "ms5", "ms10", "ms15", "ms20", "ms25", "ms30", "ms35", "ms40", "ms45", "ms50", "ms55", "ms60", "ms65", "ms70", "ms75", \
"ms80", "ms85", "ms90", "ms95", "ms100", "ms110", "ms120", "ms130", "ms140", "ms150", "ms160", "ms170", "ms180", "ms190", "ms200"
#define SIZEOF_NR_RLC_T_REASSEMBLY INT_LIST_SIZE(VALUES_NR_RLC_T_REASSEMBLY)
#define VALUES_NR_RLC_T_STATUS_PROHIBIT \
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, \
60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, \
120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, \
180, 185, 190, 195, 200, 205, 210, 215, 220, 225, 230, 235, \
240, 245, 250, 300, 350, 400, 450, 500, 800, 1000, 1200, 1600, \
2000, 2400
#define VALUES_NR_RLC_T_STATUS_PROHIBIT_STR \
"ms0", "ms5", "ms10", "ms15", "ms20", "ms25", "ms30", "ms35", "ms40", "ms45", "ms50", "ms55", \
"ms60", "ms65", "ms70", "ms75", "ms80", "ms85", "ms90", "ms95", "ms100", "ms105", "ms110", "ms115", \
"ms120", "ms125", "ms130", "ms135", "ms140", "ms145", "ms150", "ms155", "ms160", "ms165", "ms170", "ms175", \
"ms180", "ms185", "ms190", "ms195", "ms200", "ms205", "ms210", "ms215", "ms220", "ms225", "ms230", "ms235", \
"ms240", "ms245", "ms250", "ms300", "ms350", "ms400", "ms450", "ms500", "ms800", "ms1000", "ms1200", "ms1600", \
"ms2000", "ms2400"
#define SIZEOF_NR_RLC_T_STATUS_PROHIBIT INT_LIST_SIZE(VALUES_NR_RLC_T_STATUS_PROHIBIT)
#define VALUES_NR_RLC_POLL_PDU \
4, 8, 16, 32, 64, 128, 256, 512, 1024, \
2048, 4096, 6144, 8192, 12288, 16384, 20480, 24576, 28672, \
32768, 40960, 49152, 57344, 65536, -1 /* -1 means infinity */
#define VALUES_NR_RLC_POLL_PDU_STR \
"p4", "p8", "p16", "p32", "p64", "p128", "p256", "p512", "p1024", \
"p2048", "p4096", "p6144", "p8192", "p12288", "p16384", "p20480", "p24576", "p28672", \
"p32768", "p40960", "p49152", "p57344", "p65536", "infinity"
#define SIZEOF_NR_RLC_POLL_PDU INT_LIST_SIZE(VALUES_NR_RLC_POLL_PDU)
#define VALUES_NR_RLC_POLL_BYTE \
/* KB */ \
1024 * 1, 1024 * 2, 1024 * 5, 1024 * 8, 1024 * 10, 1024 * 15, 1024 * 25, 1024 * 50, 1024 * 75, \
1024 * 100, 1024 * 125, 1024 * 250, 1024 * 375, 1024 * 500, 1024 * 750, 1024 * 1000, 1024 * 1250, \
1024 * 1500, 1024 * 2000, 1024 * 3000, 1024 * 4000, 1024 * 4500, 1024 * 5000, 1024 * 5500, \
1024 * 6000, 1024 * 6500, 1024 * 7000, 1024 * 7500, \
/* MB */ \
1024 * 1024 * 8, 1024 * 1024 * 9, 1024 * 1024 * 10, 1024 * 1024 * 11, 1024 * 1024 * 12, \
1024 * 1024 * 13, 1024 * 1024 * 14, 1024 * 1024 * 15, 1024 * 1024 * 16, 1024 * 1024 * 17, \
1024 * 1024 * 18, 1024 * 1024 * 20, 1024 * 1024 * 25, 1024 * 1024 * 30, 1024 * 1024 * 40, \
-1 /* -1 means infinity */
#define VALUES_NR_RLC_POLL_BYTE_STR \
"kB1", "kB2", "kB5", "kB8", "kB10", "kB15", "kB25", "kB50", "kB75", \
"kB100", "kB125", "kB250", "kB375", "kB500", "kB750", "kB1000", "kB1250", \
"kB1500", "kB2000", "kB3000", "kB4000", "kB4500", "kB5000", "kB5500", \
"kB6000", "kB6500", "kB7000", "kB7500", \
"mB8", "mB9", "mB10", "mB11", "mB12", "mB13", "mB14", "mB15", \
"mB16", "mB17", "mB18", "mB20", "mB25", "mB30", "mB40", \
"infinity"
#define SIZEOF_NR_RLC_POLL_BYTE INT_LIST_SIZE(VALUES_NR_RLC_POLL_BYTE)
#define VALUES_NR_RLC_MAX_RETX_THRESHOLD \
1, 2, 3, 4, 6, 8, 16, 32
#define VALUES_NR_RLC_MAX_RETX_THRESHOLD_STR \
"t1", "t2", "t3", "t4", "t6", "t8", "t16", "t32"
#define SIZEOF_NR_RLC_MAX_RETX_THRESHOLD INT_LIST_SIZE(VALUES_NR_RLC_MAX_RETX_THRESHOLD)
#define VALUES_NR_RLC_SN_FIELD_LENGTH_AM \
12, 18
#define VALUES_NR_RLC_SN_FIELD_LENGTH_AM_STR \
"size12", "size18"
#define SIZEOF_NR_RLC_SN_FIELD_LENGTH_AM INT_LIST_SIZE(VALUES_NR_RLC_SN_FIELD_LENGTH_AM)
#define VALUES_NR_RLC_SN_FIELD_LENGTH_UM \
6, 12
#define VALUES_NR_RLC_SN_FIELD_LENGTH_UM_STR \
"size6", "size12"
#define SIZEOF_NR_RLC_SN_FIELD_LENGTH_UM INT_LIST_SIZE(VALUES_NR_RLC_SN_FIELD_LENGTH_UM)
/* configuration of NR RLC, coming from configuration file */
typedef struct {
struct {
int t_poll_retransmit;
int t_reassembly;
int t_status_prohibit;
int poll_pdu;
int poll_byte;
int max_retx_threshold;
int sn_field_length;
} srb;
struct {
int t_poll_retransmit;
int t_reassembly;
int t_status_prohibit;
int poll_pdu;
int poll_byte;
int max_retx_threshold;
int sn_field_length;
} drb_am;
struct {
int t_reassembly;
int sn_field_length;
} drb_um;
} nr_rlc_configuration_t;
#endif /* _NR_RLC_CONFIGURATION_H_ */
openair2/RRC/NR/MESSAGES/asn1_msg.c
+7 -5
View File
@@ -46,6 +46,7 @@
#include "LAYER2/nr_rlc/nr_rlc_oai_api.h"
#include "asn1_msg.h"
#include "../nr_rrc_proto.h"
#include "LAYER2/nr_pdcp/nr_pdcp_asn1_utils.h"
#include "openair3/SECU/key_nas_deriver.h"
@@ -274,7 +275,8 @@ int do_RRCReject(uint8_t *const buffer)
NR_RadioBearerConfig_t *get_default_rbconfig(int eps_bearer_id,
int rb_id,
e_NR_CipheringAlgorithm ciphering_algorithm,
e_NR_SecurityConfig__keyToUse key_to_use)
e_NR_SecurityConfig__keyToUse key_to_use,
const nr_pdcp_configuration_t *pdcp_config)
{
NR_RadioBearerConfig_t *rbconfig = calloc(1, sizeof(*rbconfig));
rbconfig->srb_ToAddModList = NULL;
@@ -289,9 +291,9 @@ NR_RadioBearerConfig_t *get_default_rbconfig(int eps_bearer_id,
drb_ToAddMod->recoverPDCP = NULL;
drb_ToAddMod->pdcp_Config = calloc(1,sizeof(*drb_ToAddMod->pdcp_Config));
asn1cCalloc(drb_ToAddMod->pdcp_Config->drb, drb);
asn1cCallocOne(drb->discardTimer, NR_PDCP_Config__drb__discardTimer_infinity);
asn1cCallocOne(drb->pdcp_SN_SizeUL, NR_PDCP_Config__drb__pdcp_SN_SizeUL_len18bits);
asn1cCallocOne(drb->pdcp_SN_SizeDL, NR_PDCP_Config__drb__pdcp_SN_SizeDL_len18bits);
asn1cCallocOne(drb->discardTimer, encode_discard_timer(pdcp_config->drb.discard_timer));
asn1cCallocOne(drb->pdcp_SN_SizeUL, encode_sn_size_ul(pdcp_config->drb.sn_size));
asn1cCallocOne(drb->pdcp_SN_SizeDL, encode_sn_size_dl(pdcp_config->drb.sn_size));
drb->headerCompression.present = NR_PDCP_Config__drb__headerCompression_PR_notUsed;
drb->headerCompression.choice.notUsed = 0;
drb->integrityProtection = NULL;
@@ -299,7 +301,7 @@ NR_RadioBearerConfig_t *get_default_rbconfig(int eps_bearer_id,
drb->outOfOrderDelivery = NULL;
drb_ToAddMod->pdcp_Config->moreThanOneRLC = NULL;
asn1cCallocOne(drb_ToAddMod->pdcp_Config->t_Reordering, NR_PDCP_Config__t_Reordering_ms100);
asn1cCallocOne(drb_ToAddMod->pdcp_Config->t_Reordering, encode_t_reordering(pdcp_config->drb.t_reordering));
drb_ToAddMod->pdcp_Config->ext1 = NULL;
asn1cSeqAdd(&rbconfig->drb_ToAddModList->list,drb_ToAddMod);
openair2/RRC/NR/MESSAGES/asn1_msg.h
+3 -1
View File
@@ -53,6 +53,7 @@
#include "ds/seq_arr.h"
#include "ds/byte_array.h"
#include "rrc_messages_types.h"
#include "openair2/LAYER2/nr_pdcp/nr_pdcp_configuration.h"
struct asn_TYPE_descriptor_s;
typedef struct {
@@ -86,7 +87,8 @@ int do_RRCReject(uint8_t *const buffer);
NR_RadioBearerConfig_t *get_default_rbconfig(int eps_bearer_id,
int rb_id,
e_NR_CipheringAlgorithm ciphering_algorithm,
e_NR_SecurityConfig__keyToUse key_to_use);
e_NR_SecurityConfig__keyToUse key_to_use,
const nr_pdcp_configuration_t *pdcp_config);
int do_RRCSetup(uint8_t *const buffer,
size_t buffer_size,
openair2/RRC/NR/MESSAGES/tests/CMakeLists.txt
+4 -1
View File
@@ -1,4 +1,7 @@
add_executable(test_asn1_msg test_asn1_msg.cpp)
add_executable(test_asn1_msg
test_asn1_msg.cpp
${OPENAIR2_DIR}/LAYER2/nr_pdcp/asn1_utils.c
${OPENAIR2_DIR}/LAYER2/nr_rlc/asn1_utils.c)
target_link_libraries(test_asn1_msg PRIVATE nr_rrc SECURITY minimal_lib GTest::gtest UTIL)
add_dependencies(tests test_asn1_msg)
add_test(NAME test_asn1_msg
openair2/RRC/NR/nr_rrc_defs.h
+4
View File
@@ -54,6 +54,8 @@
#include "NR_UE-MRDC-Capability.h"
#include "NR_UE-NR-Capability.h"
#include "intertask_interface.h"
#include "openair2/LAYER2/nr_pdcp/nr_pdcp_configuration.h"
#include "openair2/LAYER2/nr_rlc/nr_rlc_configuration.h"
typedef enum {
NR_RRC_OK=0,
@@ -383,6 +385,8 @@ typedef struct gNB_RRC_INST_s {
RB_HEAD(rrc_cuup_tree, nr_rrc_cuup_container_t) cuups; // CU-UPs, indexed by assoc_id
size_t num_cuups;
nr_pdcp_configuration_t pdcp_config;
nr_rlc_configuration_t rlc_config;
} gNB_RRC_INST;
#define UE_LOG_FMT "(cellID %lx, UE ID %d RNTI %04x)"
openair2/RRC/NR/rrc_gNB_NGAP.c
+2 -1
View File
@@ -397,7 +397,8 @@ bool trigger_bearer_setup(gNB_RRC_INST *rrc, gNB_RRC_UE_t *UE, int n, pdusession
pduSession,
rrc->configuration.enable_sdap,
rrc->security.do_drb_integrity,
rrc->security.do_drb_ciphering);
rrc->security.do_drb_ciphering,
&rrc->pdcp_config);
pdu->numDRB2Setup = 1; // One DRB per PDU Session. TODO: Remove hardcoding
for (int j=0; j < pdu->numDRB2Setup; j++) {
openair2/RRC/NR/rrc_gNB_nsa.c
+2 -2
View File
@@ -141,7 +141,7 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc, x2ap_ENDC_sgnb_addition_req_t *m, sctp_
uint32_t cgci_len = 0;
if (get_softmodem_params()->phy_test == 1 || get_softmodem_params()->do_ra == 1) {
DevAssert(m == NULL);
UE->rb_config = get_default_rbconfig(10 /* EPS bearer ID */, 1 /* drb ID */, NR_CipheringAlgorithm_nea0, NR_SecurityConfig__keyToUse_master);
UE->rb_config = get_default_rbconfig(10 /* EPS bearer ID */, 1 /* drb ID */, NR_CipheringAlgorithm_nea0, NR_SecurityConfig__keyToUse_master, &rrc->pdcp_config);
cgci_len = cg_config_info_from_ue_cap_file(sizeof tmp, tmp);
DevAssert(cgci_len > 0);
cgci_buf = tmp;
@@ -223,7 +223,7 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc, x2ap_ENDC_sgnb_addition_req_t *m, sctp_
exit(1);
}
UE->rb_config = get_default_rbconfig(m->e_rabs_tobeadded[0].e_rab_id, m->e_rabs_tobeadded[0].drb_ID, cipher_algo, NR_SecurityConfig__keyToUse_secondary);
UE->rb_config = get_default_rbconfig(m->e_rabs_tobeadded[0].e_rab_id, m->e_rabs_tobeadded[0].drb_ID, cipher_algo, NR_SecurityConfig__keyToUse_secondary, &rrc->pdcp_config);
}
if(m!=NULL) {
openair2/RRC/NR/rrc_gNB_radio_bearers.c
+12 -7
View File
@@ -30,6 +30,7 @@
#include "common/utils/T/T.h"
#include "ngap_messages_types.h"
#include "oai_asn1.h"
#include "openair2/LAYER2/nr_pdcp/nr_pdcp_asn1_utils.h"
rrc_pdu_session_param_t *find_pduSession(gNB_RRC_UE_t *ue, int id, bool create)
{
@@ -71,13 +72,16 @@ drb_t *get_drb(gNB_RRC_UE_t *ue, uint8_t drb_id)
return &ue->established_drbs[drb_id - 1];
}
void set_default_drb_pdcp_config(struct pdcp_config_s *pdcp_config, int do_drb_integrity, int do_drb_ciphering)
void set_default_drb_pdcp_config(struct pdcp_config_s *pdcp_config,
int do_drb_integrity,
int do_drb_ciphering,
const nr_pdcp_configuration_t *default_pdcp_config)
{
AssertError(pdcp_config != NULL, return, "Failed to set default PDCP configuration for DRB!\n");
pdcp_config->discardTimer = NR_PDCP_Config__drb__discardTimer_infinity;
pdcp_config->pdcp_SN_SizeDL = NR_PDCP_Config__drb__pdcp_SN_SizeDL_len18bits;
pdcp_config->pdcp_SN_SizeUL = NR_PDCP_Config__drb__pdcp_SN_SizeUL_len18bits;
pdcp_config->t_Reordering = NR_PDCP_Config__t_Reordering_ms100;
pdcp_config->discardTimer = encode_discard_timer(default_pdcp_config->drb.discard_timer);
pdcp_config->pdcp_SN_SizeDL = encode_sn_size_dl(default_pdcp_config->drb.sn_size);
pdcp_config->pdcp_SN_SizeUL = encode_sn_size_ul(default_pdcp_config->drb.sn_size);
pdcp_config->t_Reordering = encode_t_reordering(default_pdcp_config->drb.t_reordering);
pdcp_config->headerCompression.present = NR_PDCP_Config__drb__headerCompression_PR_notUsed;
pdcp_config->headerCompression.NotUsed = 0;
pdcp_config->integrityProtection = do_drb_integrity ? NR_PDCP_Config__drb__integrityProtection_enabled : 1;
@@ -99,7 +103,8 @@ drb_t *generateDRB(gNB_RRC_UE_t *ue,
const rrc_pdu_session_param_t *pduSession,
bool enable_sdap,
int do_drb_integrity,
int do_drb_ciphering)
int do_drb_ciphering,
const nr_pdcp_configuration_t *pdcp_config)
{
DevAssert(ue != NULL);
@@ -130,7 +135,7 @@ drb_t *generateDRB(gNB_RRC_UE_t *ue,
est_drb->status = DRB_ACTIVE;
}
/* PDCP Configuration */
set_default_drb_pdcp_config(&est_drb->pdcp_config, do_drb_integrity, do_drb_ciphering);
set_default_drb_pdcp_config(&est_drb->pdcp_config, do_drb_integrity, do_drb_ciphering, pdcp_config);
drb_t *rrc_drb = get_drb(ue, drb_id);
DevAssert(rrc_drb == est_drb); /* to double check that we create the same which we would retrieve */
openair2/RRC/NR/rrc_gNB_radio_bearers.h
+3 -1
View File
@@ -49,13 +49,15 @@ drb_t *get_drb(gNB_RRC_UE_t *ue, uint8_t drb_id);
/// @param enable_sdap If true the SDAP header will be added to the packet, else it will not add or search for SDAP header.
/// @param do_drb_integrity
/// @param do_drb_ciphering
/// @param pdcp_config
/// @return returns a pointer to the generated DRB structure
drb_t *generateDRB(gNB_RRC_UE_t *ue,
uint8_t drb_id,
const rrc_pdu_session_param_t *pduSession,
bool enable_sdap,
int do_drb_integrity,
int do_drb_ciphering);
int do_drb_ciphering,
const nr_pdcp_configuration_t *pdcp_config);
/// @brief return the next available (inactive) DRB ID of UE ue
uint8_t get_next_available_drb_id(gNB_RRC_UE_t *ue);