313 lines
12 KiB
C
313 lines
12 KiB
C
/*
|
|
* SPDX-License-Identifier: LicenseRef-CSSL-1.0
|
|
*/
|
|
|
|
/*! \file PHY/NR_TRANSPORT/nr_dlsch_coding_slot.c
|
|
* \brief Top-level routines for implementing LDPC-coded (DLSCH) transport channels from 38-212, 15.2
|
|
*/
|
|
|
|
#include "PHY/defs_gNB.h"
|
|
#include "PHY/CODING/coding_extern.h"
|
|
#include "PHY/CODING/coding_defs.h"
|
|
#include "PHY/CODING/nrLDPC_coding/nrLDPC_coding_interface.h"
|
|
#include "PHY/CODING/nrLDPC_extern.h"
|
|
#include "PHY/NR_TRANSPORT/nr_transport_proto.h"
|
|
#include "PHY/NR_TRANSPORT/nr_transport_common_proto.h"
|
|
#include "PHY/NR_TRANSPORT/nr_dlsch.h"
|
|
#include "SCHED_NR/sched_nr.h"
|
|
#include "common/utils/LOG/log.h"
|
|
#include "common/utils/nr/nr_common.h"
|
|
#include <syscall.h>
|
|
#include <openair2/UTIL/OPT/opt.h>
|
|
|
|
// #define DEBUG_DLSCH_CODING
|
|
// #define DEBUG_DLSCH_FREE 1
|
|
|
|
/* Keep the PHY encoder independent of the MAC helper with the same rule from
|
|
* TS 38.212 section 5.3.2. A dual-codeword PDSCH may have a different TBS
|
|
* (and therefore a different base graph) for each codeword. */
|
|
static uint8_t dlsch_base_graph(uint32_t A, uint16_t R)
|
|
{
|
|
const float code_rate = (float)R / 10240.0f;
|
|
return (A <= 292 || (A <= NR_MAX_PDSCH_TBS && code_rate <= 0.6667f) || code_rate <= 0.25f) ? 2 : 1;
|
|
}
|
|
|
|
void free_gNB_dlsch(NR_gNB_DLSCH_t *dlsch, uint16_t N_RB, const NR_DL_FRAME_PARMS *frame_parms)
|
|
{
|
|
int max_layers = (frame_parms->nb_antennas_tx < NR_MAX_NB_LAYERS) ? frame_parms->nb_antennas_tx : NR_MAX_NB_LAYERS;
|
|
const int max_cw_layers = min(max_layers, 4);
|
|
uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER * max_cw_layers;
|
|
|
|
if (N_RB != 273) {
|
|
a_segments = a_segments * N_RB;
|
|
a_segments = a_segments / 273 + 1;
|
|
}
|
|
|
|
const size_t f_bytes = N_RB * frame_parms->symbols_per_slot * NR_NB_SC_PER_RB * 8 * max_cw_layers;
|
|
(void)f_bytes; /* free16 ignores its size argument on the supported allocators. */
|
|
for (int q = 0; q < NR_MAX_NB_CODEWORDS; q++) {
|
|
if (dlsch->b[q]) {
|
|
free16(dlsch->b[q], a_segments * 1056);
|
|
dlsch->b[q] = NULL;
|
|
}
|
|
if (dlsch->f[q]) {
|
|
free16(dlsch->f[q], f_bytes);
|
|
dlsch->f[q] = NULL;
|
|
}
|
|
if (!dlsch->c[q])
|
|
continue;
|
|
for (int r = 0; r < a_segments; r++) {
|
|
free(dlsch->c[q][r]);
|
|
dlsch->c[q][r] = NULL;
|
|
}
|
|
free(dlsch->c[q]);
|
|
dlsch->c[q] = NULL;
|
|
}
|
|
}
|
|
|
|
NR_gNB_DLSCH_t new_gNB_dlsch(NR_DL_FRAME_PARMS *frame_parms, uint16_t N_RB)
|
|
{
|
|
int max_layers = (frame_parms->nb_antennas_tx < NR_MAX_NB_LAYERS) ? frame_parms->nb_antennas_tx : NR_MAX_NB_LAYERS;
|
|
const int max_cw_layers = min(max_layers, 4);
|
|
uint16_t a_segments = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER * max_cw_layers; // segments allocated per codeword
|
|
|
|
if (N_RB != 273) {
|
|
a_segments = a_segments * N_RB;
|
|
a_segments = a_segments / 273 + 1;
|
|
}
|
|
|
|
LOG_D(PHY, "Allocating %d segments (MAX %d, N_PRB %d)\n", a_segments, MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER, N_RB);
|
|
uint32_t dlsch_bytes = a_segments * 1056;
|
|
NR_gNB_DLSCH_t dlsch = {0};
|
|
const size_t f_bytes = N_RB * frame_parms->symbols_per_slot * NR_NB_SC_PER_RB * 8 * max_cw_layers;
|
|
|
|
for (int q = 0; q < NR_MAX_NB_CODEWORDS; q++) {
|
|
dlsch.b[q] = malloc16(dlsch_bytes);
|
|
AssertFatal(dlsch.b[q], "cannot allocate memory for dlsch.b[%d]\n", q);
|
|
bzero(dlsch.b[q], dlsch_bytes);
|
|
|
|
dlsch.c[q] = (uint8_t **)malloc16(a_segments * sizeof(uint8_t *));
|
|
AssertFatal(dlsch.c[q], "cannot allocate memory for dlsch.c[%d]\n", q);
|
|
for (int r = 0; r < a_segments; r++) {
|
|
// 8448 is the maximum NR code-block size, including filler and CRC.
|
|
dlsch.c[q][r] = malloc16(8448);
|
|
AssertFatal(dlsch.c[q][r], "cannot allocate dlsch.c[%d][%d]\n", q, r);
|
|
bzero(dlsch.c[q][r], 8448);
|
|
}
|
|
|
|
dlsch.f[q] = malloc16(f_bytes);
|
|
AssertFatal(dlsch.f[q], "cannot allocate dlsch.f[%d]\n", q);
|
|
bzero(dlsch.f[q], f_bytes);
|
|
}
|
|
|
|
return (dlsch);
|
|
}
|
|
|
|
int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
|
|
int n_dlsch,
|
|
NR_gNB_DLSCH_t *dlsch_array,
|
|
int frame,
|
|
uint8_t slot,
|
|
unsigned char *output,
|
|
time_stats_t *tinput,
|
|
time_stats_t *tprep,
|
|
time_stats_t *tparity,
|
|
time_stats_t *toutput,
|
|
time_stats_t *dlsch_rate_matching_stats,
|
|
time_stats_t *dlsch_interleaving_stats,
|
|
time_stats_t *dlsch_segmentation_stats)
|
|
{
|
|
int n_tbs = 0;
|
|
for (int i = 0; i < n_dlsch; i++) {
|
|
const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch_array[i].pdsch_pdu->pdsch_pdu_rel15;
|
|
AssertFatal(rel15->NrOfCodewords == nr_pdsch_num_codewords(rel15->nrOfLayers),
|
|
"PDSCH has %u codewords for %u layers\n",
|
|
rel15->NrOfCodewords,
|
|
rel15->nrOfLayers);
|
|
n_tbs += rel15->NrOfCodewords;
|
|
}
|
|
|
|
nrLDPC_TB_encoding_parameters_t TBs[n_tbs];
|
|
memset(TBs, 0, sizeof(TBs));
|
|
NR_gNB_DLSCH_t *tb_dlsch[n_tbs];
|
|
uint8_t tb_cw[n_tbs];
|
|
|
|
int num_segments = 0;
|
|
int tb_index = 0;
|
|
|
|
for (int i = 0; i < n_dlsch; i++) {
|
|
NR_gNB_DLSCH_t *dlsch = &dlsch_array[i];
|
|
const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->pdsch_pdu->pdsch_pdu_rel15;
|
|
NR_gNB_PHY_STATS_t *phy_stats = NULL;
|
|
if (rel15->rnti != 0xFFFF)
|
|
phy_stats = get_phy_stats(gNB, rel15->rnti);
|
|
if (phy_stats) {
|
|
phy_stats->frame = frame;
|
|
phy_stats->dlsch_stats.current_RI = rel15->nrOfLayers;
|
|
phy_stats->dlsch_stats.current_Qm = rel15->qamModOrder[0];
|
|
}
|
|
|
|
for (int q = 0; q < rel15->NrOfCodewords; q++, tb_index++) {
|
|
const int cw_layers = nr_pdsch_layers_per_codeword(rel15->nrOfLayers, q);
|
|
const uint32_t A = rel15->TBSize[q] << 3;
|
|
unsigned char *a = dlsch->pdu[q];
|
|
AssertFatal(a != NULL, "Missing PDSCH transport block for codeword %d\n", q);
|
|
|
|
if (rel15->rnti != SI_RNTI) {
|
|
ws_trace_t tmp = {.nr = true,
|
|
.direction = DIRECTION_DOWNLINK,
|
|
.pdu_buffer = a,
|
|
.pdu_buffer_size = rel15->TBSize[q],
|
|
.ueid = 0,
|
|
.rntiType = WS_C_RNTI,
|
|
.rnti = rel15->rnti,
|
|
.sysFrame = frame,
|
|
.subframe = slot,
|
|
.harq_pid = 0,
|
|
.oob_event = 0,
|
|
.oob_event_value = 0};
|
|
trace_pdu(&tmp);
|
|
}
|
|
if (phy_stats)
|
|
phy_stats->dlsch_stats.total_bytes_tx += rel15->TBSize[q];
|
|
|
|
unsigned int crc = 1;
|
|
const int max_bytes = MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER * cw_layers * 1056;
|
|
int B;
|
|
if (A > NR_MAX_PDSCH_TBS) {
|
|
crc = crc24a(a, A) >> 8;
|
|
a[A >> 3] = ((uint8_t *)&crc)[2];
|
|
a[1 + (A >> 3)] = ((uint8_t *)&crc)[1];
|
|
a[2 + (A >> 3)] = ((uint8_t *)&crc)[0];
|
|
B = A + 24;
|
|
AssertFatal((A / 8) + 4 <= max_bytes, "A %u is too big (%u > %d)\n", A, (A / 8) + 4, max_bytes);
|
|
memcpy(dlsch->b[q], a, (A / 8) + 4);
|
|
} else {
|
|
crc = crc16(a, A) >> 16;
|
|
a[A >> 3] = ((uint8_t *)&crc)[1];
|
|
a[1 + (A >> 3)] = ((uint8_t *)&crc)[0];
|
|
B = A + 16;
|
|
AssertFatal((A / 8) + 3 <= max_bytes, "A %u is too big (%u > %d)\n", A, (A / 8) + 3, max_bytes);
|
|
memcpy(dlsch->b[q], a, (A / 8) + 3);
|
|
}
|
|
|
|
nrLDPC_TB_encoding_parameters_t *TB_parameters = &TBs[tb_index];
|
|
tb_dlsch[tb_index] = dlsch;
|
|
tb_cw[tb_index] = q;
|
|
// A HARQ PID is not globally unique, so use the flattened TB index.
|
|
TB_parameters->harq_unique_pid = tb_index;
|
|
TB_parameters->BG = dlsch_base_graph(A, rel15->targetCodeRate[q]);
|
|
TB_parameters->A = A;
|
|
start_meas(dlsch_segmentation_stats);
|
|
TB_parameters->Kb = nr_segmentation(dlsch->b[q],
|
|
dlsch->c[q],
|
|
B,
|
|
&TB_parameters->C,
|
|
&TB_parameters->K,
|
|
&TB_parameters->Z,
|
|
&TB_parameters->F,
|
|
TB_parameters->BG);
|
|
stop_meas(dlsch_segmentation_stats);
|
|
|
|
if (TB_parameters->C > MAX_NUM_NR_DLSCH_SEGMENTS_PER_LAYER * cw_layers) {
|
|
LOG_E(PHY, "nr_segmentation.c: too many segments %d, B %d, codeword layers %d\n", TB_parameters->C, B, cw_layers);
|
|
return -1;
|
|
}
|
|
num_segments += TB_parameters->C;
|
|
}
|
|
}
|
|
|
|
nrLDPC_segment_encoding_parameters_t segments[num_segments];
|
|
memset(segments, 0, sizeof(segments));
|
|
size_t segments_offset = 0;
|
|
size_t dlsch_offset = 0;
|
|
|
|
for (int i = 0; i < n_tbs; i++) {
|
|
NR_gNB_DLSCH_t *dlsch = tb_dlsch[i];
|
|
const nfapi_nr_dl_tti_pdsch_pdu_rel15_t *rel15 = &dlsch->pdsch_pdu->pdsch_pdu_rel15;
|
|
const int q = tb_cw[i];
|
|
const int cw_layers = nr_pdsch_layers_per_codeword(rel15->nrOfLayers, q);
|
|
nrLDPC_TB_encoding_parameters_t *TB_parameters = &TBs[i];
|
|
|
|
#ifdef DEBUG_DLSCH_CODING
|
|
for (int r = 0; r < TB_parameters->C; r++) {
|
|
LOG_D(PHY, "Encoder: B %d F %d \n", dlsch->B, TB_parameters->F);
|
|
LOG_D(PHY, "start ldpc encoder segment %d/%d\n", r, TB_parameters->C);
|
|
LOG_D(PHY,
|
|
"input %d %d %d %d %d \n",
|
|
dlsch->c[q][r][0],
|
|
dlsch->c[q][r][1],
|
|
dlsch->c[q][r][2],
|
|
dlsch->c[q][r][3],
|
|
dlsch->c[q][r][4]);
|
|
for (int cnt = 0; cnt < 22 * (TB_parameters->Z) / 8; cnt++) {
|
|
LOG_D(PHY, "%d ", dlsch->c[q][r][cnt]);
|
|
}
|
|
LOG_D(PHY, "\n");
|
|
}
|
|
#endif
|
|
|
|
int rbsize = dlsch->freq_alloc.num_rbs;
|
|
TB_parameters->nb_rb = rbsize;
|
|
TB_parameters->Qm = rel15->qamModOrder[q];
|
|
TB_parameters->mcs = rel15->mcsIndex[q];
|
|
TB_parameters->nb_layers = cw_layers;
|
|
TB_parameters->rv_index = rel15->rvIndex[q];
|
|
|
|
int nb_re_dmrs =
|
|
(rel15->dmrsConfigType == NFAPI_NR_DMRS_TYPE1) ? (6 * rel15->numDmrsCdmGrpsNoData) : (4 * rel15->numDmrsCdmGrpsNoData);
|
|
TB_parameters->G = nr_get_G(rbsize,
|
|
rel15->NrOfSymbols,
|
|
nb_re_dmrs,
|
|
get_num_dmrs(rel15->dlDmrsSymbPos),
|
|
dlsch->unav_res,
|
|
rel15->qamModOrder[q],
|
|
cw_layers);
|
|
|
|
TB_parameters->tbslbrm = rel15->maintenance_parms_v3.tbSizeLbrmBytes;
|
|
TB_parameters->output = &output[dlsch_offset >> 3];
|
|
TB_parameters->segments = &segments[segments_offset];
|
|
|
|
for (int r = 0; r < TB_parameters->C; r++) {
|
|
nrLDPC_segment_encoding_parameters_t *segment_parameters = &TB_parameters->segments[r];
|
|
segment_parameters->c = dlsch->c[q][r];
|
|
segment_parameters->E = nr_get_E(TB_parameters->G, TB_parameters->C, TB_parameters->Qm, cw_layers, r);
|
|
|
|
reset_meas(&segment_parameters->ts_interleave);
|
|
reset_meas(&segment_parameters->ts_rate_match);
|
|
reset_meas(&segment_parameters->ts_ldpc_encode);
|
|
}
|
|
|
|
segments_offset += TB_parameters->C;
|
|
|
|
/* output and its parts for each dlsch should be aligned on 64 bytes (or 8 * 64 bits)
|
|
* => dlsch_offset should remain a multiple of 8 * 64 with enough offset to fit each dlsch
|
|
*/
|
|
const size_t dlsch_size =
|
|
rbsize * gNB->frame_parms.symbols_per_slot * NR_NB_SC_PER_RB * rel15->qamModOrder[q] * cw_layers;
|
|
dlsch_offset += ceil_mod(dlsch_size, 8 * 64);
|
|
}
|
|
|
|
nrLDPC_slot_encoding_parameters_t slot_parameters = {.frame = frame,
|
|
.slot = slot,
|
|
.nb_TBs = n_tbs,
|
|
.threadPool = &gNB->threadPool,
|
|
.tinput = tinput,
|
|
.tprep = tprep,
|
|
.tparity = tparity,
|
|
.toutput = toutput,
|
|
.TBs = TBs};
|
|
gNB->nrLDPC_coding_interface.nrLDPC_coding_encoder(&slot_parameters);
|
|
|
|
for (int i = 0; i < n_tbs; i++) {
|
|
nrLDPC_TB_encoding_parameters_t *TB_parameters = &TBs[i];
|
|
for (int r = 0; r < TB_parameters->C; r++) {
|
|
nrLDPC_segment_encoding_parameters_t *segment_parameters = &TB_parameters->segments[r];
|
|
merge_meas(dlsch_interleaving_stats, &segment_parameters->ts_interleave);
|
|
merge_meas(dlsch_rate_matching_stats, &segment_parameters->ts_rate_match);
|
|
// merge_meas(, &segment_parameters->ts_ldpc_encode);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|