laforge has submitted this change. (
https://gerrit.osmocom.org/c/osmo-bts/+/38557?usp=email )
Change subject: CSD NT modes: transmit properly aligned RLP frames on DL
......................................................................
CSD NT modes: transmit properly aligned RLP frames on DL
There are two levels of alignment inside clearmode RTP packets
carrying CSData per TS 48.103 section 5.6:
1) Alignment of 2 or 4 V.110 (T) or pseudo-V.110 (NT) frames within
one RTP packet of 160 octets of an imaginary ISDN B channel;
2) For NT modes only, alignment of 4 pseudo-V.110 frames to form
a single 240-bit RLP frame.
Per previous patch, alignment 1 is to be treated as mandatory for
RTP transport inside an Osmocom network. Alignment 2 _could_ be
made mandatory for TCH/F9.6 NT, but the same is not possible for
TCH/[FH]4.8 NT: in the best case of half-alignment, alternating
RTP packets will carry alternating halves of RLP frames.
Implemented solution: allow arbitrary state of alignment 2
(aligned or misaligned) in the incoming RTP stream for all CSD NT
modes, and perform the necessary alignment internally.
This approach is consistent with the world of E1 BTS: a TRAU in
data mode is responsible for alignment 1 (with 20 ms TRAU frames
taking the place of our clearmode RTP packets), but only the BTS can
perform alignment 2, as the TRAU is agnostic to T vs NT distinction.
Related: OS#6579
Change-Id: Idaebfce6da13b23ba265a197502712d83991873e
---
M include/osmo-bts/csd_rlp.h
M include/osmo-bts/lchan.h
M src/common/csd_rlp.c
M src/common/l1sap.c
4 files changed, 301 insertions(+), 29 deletions(-)
Approvals:
Jenkins Builder: Verified
pespin: Looks good to me, but someone else must approve
laforge: Looks good to me, but someone else must approve
fixeria: Looks good to me, approved
diff --git a/include/osmo-bts/csd_rlp.h b/include/osmo-bts/csd_rlp.h
index fd4c6e7..94fa3d2 100644
--- a/include/osmo-bts/csd_rlp.h
+++ b/include/osmo-bts/csd_rlp.h
@@ -11,6 +11,26 @@
#include <osmocom/gsm/l1sap.h>
#include <osmo-bts/lchan.h>
+extern const uint8_t csd_tchf48_nt_e2_map[26];
+
+/* Per TS 48.020 section 15.1, the cadence of E2+E3 bits in a properly
+ * aligned sequence of pseudo-V.110 frames forming a single RLP frame
+ * is 00-01-10-11. The following constant captures this bit sequence
+ * in hex, for comparison against align_bits output from
+ * csd_v110_rtp_decode() or against rlpdl_align_bits accumulator
+ * in CSD NT lchan state.
+ */
+#define NTCSD_ALIGNED_EBITS 0x1B
+
+void ntcsd_dl_reset(struct gsm_lchan *lchan);
+void ntcsd_dl_input_48(struct gsm_lchan *lchan, const ubit_t *data_bits,
+ uint8_t align_bits);
+void ntcsd_dl_input_96(struct gsm_lchan *lchan, const ubit_t *data_bits,
+ uint8_t align_bits);
+bool ntcsd_dl_output(struct gsm_lchan *lchan, ubit_t *rlp_frame_out);
+
void gsmtap_csd_rlp_process(struct gsm_lchan *lchan, bool is_uplink,
const struct ph_tch_param *tch_ind,
const ubit_t *data, unsigned int data_len);
+void gsmtap_csd_rlp_dl(struct gsm_lchan *lchan, uint32_t fn,
+ const ubit_t *data, unsigned int data_len);
diff --git a/include/osmo-bts/lchan.h b/include/osmo-bts/lchan.h
index df2f4fa..5c34015 100644
--- a/include/osmo-bts/lchan.h
+++ b/include/osmo-bts/lchan.h
@@ -4,6 +4,7 @@
#include <stdint.h>
#include <netinet/in.h>
+#include <osmocom/core/bits.h>
#include <osmocom/core/timer.h>
#include <osmocom/core/linuxlist.h>
#include <osmocom/core/logging.h>
@@ -295,9 +296,14 @@
uint8_t last_cmr;
uint32_t last_fn;
struct {
- /* buffers to re-combine RLP frame from multiple Um
blocks */
+ /* RLP GSMTAP mechanism */
uint8_t rlp_buf_ul[576/8]; /* maximum size of RLP frame
*/
uint8_t rlp_buf_dl[576/8]; /* maximum size of RLP frame
*/
+ /* alignment of RLP frames in DL for NT modes */
+ ubit_t rlpdl_data_bits[60 * 7];
+ uint16_t rlpdl_align_bits;
+ uint8_t rlpdl_fill_level;
+ ubit_t tchf48_nt_2ndhalf[120];
} csd;
} tch;
diff --git a/src/common/csd_rlp.c b/src/common/csd_rlp.c
index aa4fdd9..349094c 100644
--- a/src/common/csd_rlp.c
+++ b/src/common/csd_rlp.c
@@ -41,6 +41,102 @@
#include <osmo-bts/bts.h>
#include <osmo-bts/csd_rlp.h>
+/* In the case of TCH/F4.8 NT, each 240-bit RLP frame is split between
+ * two channel-coding blocks of 120 bits each. We need to know which
+ * frame numbers correspond to which half: in the UL-to-RTP path we have
+ * to set bit E2 based on the TDMA frame number at which we received the
+ * block in question, and in the DL direction we have to transmit the
+ * right half at the right time.
+ *
+ * See GSM 05.03 section 3.4.1 and the mapping tables of GSM 05.02;
+ * having "e2_map" in the array name shall serve as a mnemonic as to
+ * the sense of this array: 0 means 1st half and 1 means 2nd half,
+ * exactly as the value of bit E2 per TS 48.020 section 15.1.
+ */
+const uint8_t csd_tchf48_nt_e2_map[26] = {
+ [4] = 1, /* B1 position */
+ [13] = 1, /* B3 position */
+ [21] = 1, /* B5 position */
+};
+
+/* This function resets (clears) the state of the DL alignment buffer.
+ * It needs to be called when we encounter a gap (packet loss, invalid
+ * packets, etc) in our RTP input stream. */
+void ntcsd_dl_reset(struct gsm_lchan *lchan)
+{
+ lchan->tch.csd.rlpdl_fill_level = 0;
+}
+
+/* This function is to be called with the decoded content of a single
+ * incoming RTP packet (data and alignment bits) for TCH/[FH]4.8 NT. */
+void ntcsd_dl_input_48(struct gsm_lchan *lchan, const ubit_t *data_bits,
+ uint8_t align_bits)
+{
+ memmove(lchan->tch.csd.rlpdl_data_bits,
+ lchan->tch.csd.rlpdl_data_bits + 60 * 2, 60 * 5);
+ memcpy(lchan->tch.csd.rlpdl_data_bits + 60 * 5, data_bits, 60 * 2);
+ lchan->tch.csd.rlpdl_align_bits <<= 4;
+ lchan->tch.csd.rlpdl_align_bits |= (align_bits & 0xF);
+ lchan->tch.csd.rlpdl_fill_level += 2;
+ if (lchan->tch.csd.rlpdl_fill_level > 7)
+ lchan->tch.csd.rlpdl_fill_level = 7;
+}
+
+/* This function is to be called with the decoded content of a single
+ * incoming RTP packet (data and alignment bits) for TCH/F9.6 NT. */
+void ntcsd_dl_input_96(struct gsm_lchan *lchan, const ubit_t *data_bits,
+ uint8_t align_bits)
+{
+ memmove(lchan->tch.csd.rlpdl_data_bits,
+ lchan->tch.csd.rlpdl_data_bits + 60 * 4, 60 * 3);
+ memcpy(lchan->tch.csd.rlpdl_data_bits + 60 * 3, data_bits, 60 * 4);
+ lchan->tch.csd.rlpdl_align_bits <<= 8;
+ lchan->tch.csd.rlpdl_align_bits |= (align_bits & 0xFF);
+ lchan->tch.csd.rlpdl_fill_level += 4;
+ if (lchan->tch.csd.rlpdl_fill_level > 7)
+ lchan->tch.csd.rlpdl_fill_level = 7;
+}
+
+/* This function is to be called to obtain a complete RLP frame for
+ * downlink transmission. It will provide either a properly aligned
+ * frame (return value true) or a filler (return value false). */
+bool ntcsd_dl_output(struct gsm_lchan *lchan, ubit_t *rlp_frame_out)
+{
+ if (lchan->tch.csd.rlpdl_fill_level < 4)
+ goto no_frame_out;
+ if (((lchan->tch.csd.rlpdl_align_bits >> 0) & 0xFF) ==
NTCSD_ALIGNED_EBITS) {
+ memcpy(rlp_frame_out, lchan->tch.csd.rlpdl_data_bits + 60 * 3,
+ 60 * 4);
+ return true;
+ }
+ if (lchan->tch.csd.rlpdl_fill_level < 5)
+ goto no_frame_out;
+ if (((lchan->tch.csd.rlpdl_align_bits >> 2) & 0xFF) ==
NTCSD_ALIGNED_EBITS) {
+ memcpy(rlp_frame_out, lchan->tch.csd.rlpdl_data_bits + 60 * 2,
+ 60 * 4);
+ return true;
+ }
+ if (lchan->tch.csd.rlpdl_fill_level < 6)
+ goto no_frame_out;
+ if (((lchan->tch.csd.rlpdl_align_bits >> 4) & 0xFF) ==
NTCSD_ALIGNED_EBITS) {
+ memcpy(rlp_frame_out, lchan->tch.csd.rlpdl_data_bits + 60 * 1,
+ 60 * 4);
+ return true;
+ }
+ if (lchan->tch.csd.rlpdl_fill_level < 7)
+ goto no_frame_out;
+ if (((lchan->tch.csd.rlpdl_align_bits >> 6) & 0xFF) ==
NTCSD_ALIGNED_EBITS) {
+ memcpy(rlp_frame_out, lchan->tch.csd.rlpdl_data_bits, 60 * 4);
+ return true;
+ }
+no_frame_out:
+ /* TS 44.021 section 12.1 says that a missing/unavailable 240-bit
+ * RLP frame is to be filled with 0 bits, unlike ones-fill
+ * used everywhere else in the world of V.110 and CSD. */
+ memset(rlp_frame_out, 0, 60 * 4);
+ return false;
+}
+
/* process one MAC block of unpacked bits of a non-transparent CSD channel */
void gsmtap_csd_rlp_process(struct gsm_lchan *lchan, bool is_uplink,
const struct ph_tch_param *tch_ind,
@@ -71,13 +167,17 @@
* TCH/F 14.4: 2x 290 bit block (starting with M1=0) => 576-bit RLP
frame
*/
- if (lchan->type == GSM_LCHAN_TCH_F && lchan->tch_mode ==
GSM48_CMODE_DATA_6k0) {
- /* in this mode we have 120bit MAC blocks; two of them need to
be concatenated
- * to render a 240-bit RLP frame. The fist block is present in
B0/B2/B4.
- * The E7 bit is used to indicate the Frame MF0a */
+ if (lchan->type == GSM_LCHAN_TCH_F &&
+ lchan->tch_mode == GSM48_CMODE_DATA_6k0 && is_uplink) {
+ /* In this mode we have 120-bit MAC blocks; two of them need
+ * to be concatenated to render a 240-bit RLP frame. The first
+ * block is present in B0/B2/B4, and we have to use FN to
+ * detect this position.
+ * This code path is only for UL: in the case of DL,
+ * alignment logic elsewhere in the code will present us
+ * with a fully assembled RLP frame. */
OSMO_ASSERT(data_len == 120);
- ubit_t e7 = data[4*7+3];
- if (e7 == 0) {
+ if (csd_tchf48_nt_e2_map[tch_ind->fn % 26] == 0) {
osmo_ubit2pbit_ext(rlp_buf, 0, data, 0, data_len, 1);
return;
}
@@ -116,3 +216,13 @@
lchan->nr, tch_ind->fn, tch_ind->rssi, 0, rlp_buf,
byte_len);
}
+
+/* wrapper for downlink path */
+void gsmtap_csd_rlp_dl(struct gsm_lchan *lchan, uint32_t fn,
+ const ubit_t *data, unsigned int data_len)
+{
+ /* 'fake' tch_ind containing all-zero so gsmtap code can be shared
+ * between UL and DL */
+ const struct ph_tch_param fake_tch_ind = { .fn = fn };
+ gsmtap_csd_rlp_process(lchan, false, &fake_tch_ind, data, data_len);
+}
diff --git a/src/common/l1sap.c b/src/common/l1sap.c
index aab69c5..06ab051 100644
--- a/src/common/l1sap.c
+++ b/src/common/l1sap.c
@@ -1540,17 +1540,37 @@
&lchan->dl_tch_queue_len);
}
+ if (lchan->csd_mode == LCHAN_CSD_M_NT) {
+ for (i = 0; i < ARRAY_SIZE(input_msg); i++) {
+ if (input_msg[i]) {
+ ntcsd_dl_input_48(lchan, input_msg[i]->data,
+ rtpmsg_csd_align_bits(input_msg[i]));
+ } else {
+ ntcsd_dl_reset(lchan);
+ }
+ }
+ }
+
phy_msg = l1sap_msgb_alloc(bits_per_20ms * 2);
if (phy_msg) {
resp_l1sap = msgb_l1sap_prim(phy_msg);
phy_msg->l2h = phy_msg->tail;
- for (i = 0; i < ARRAY_SIZE(input_msg); i++) {
- phy_data = msgb_put(phy_msg, bits_per_20ms);
- if (input_msg[i]) {
- memcpy(phy_data, input_msg[i]->data,
bits_per_20ms);
- } else {
- /* IDLE frame, filled with 1 bits */
- memset(phy_data, 0x01, bits_per_20ms);
+ if (lchan->csd_mode == LCHAN_CSD_M_NT) {
+ bool good_rlp;
+ phy_data = msgb_put(phy_msg, 240); /* RLP frame */
+ good_rlp = ntcsd_dl_output(lchan, phy_data);
+ if (good_rlp)
+ gsmtap_csd_rlp_dl(lchan, fn, phy_data, 240);
+ } else {
+ for (i = 0; i < ARRAY_SIZE(input_msg); i++) {
+ phy_data = msgb_put(phy_msg, bits_per_20ms);
+ if (input_msg[i]) {
+ memcpy(phy_data, input_msg[i]->data,
+ bits_per_20ms);
+ } else {
+ /* IDLE frame, filled with 1 bits */
+ memset(phy_data, 0x01, bits_per_20ms);
+ }
}
}
} else {
@@ -1576,6 +1596,111 @@
return 0;
}
+/* The case of TCH/F4.8 NT also requires special processing that is
+ * somewhat similar to half-rate CSD. We have to produce an RLP frame
+ * for DL every 40 ms, thus it makes the most sense for us to poll
+ * the Rx jitter buffer every 40 ms just like with CSD-HR. However,
+ * we need to send TCH.req to the PHY every 20 ms, sending either
+ * the first half or the second half of the RLP frame we put together
+ * every 40 ms. */
+static int tch_rts_ind_tchf48_nt(struct gsm_bts_trx *trx,
+ struct gsm_lchan *lchan,
+ struct ph_tch_param *rts_ind)
+{
+ uint8_t chan_nr = rts_ind->chan_nr;
+ uint32_t fn = rts_ind->fn;
+ struct msgb *input_msg, *phy_msg;
+ struct osmo_phsap_prim *resp_l1sap, empty_l1sap;
+ ubit_t rlp_frame[240];
+ bool good_rlp;
+ struct gsm_time g_time;
+ int i;
+
+ gsm_fn2gsmtime(&g_time, fn);
+
+ /* Input processing happens every 40 ms */
+ if (csd_tchf48_nt_e2_map[fn % 26] == 0) {
+ for (i = 0; i < 2; i++) {
+ if (!lchan->loopback && lchan->abis_ip.rtp_socket) {
+ osmo_rtp_socket_poll(lchan->abis_ip.rtp_socket);
+ lchan->abis_ip.rtp_socket->rx_user_ts +=
GSM_RTP_DURATION;
+ }
+ input_msg = msgb_dequeue_count(&lchan->dl_tch_queue,
+
&lchan->dl_tch_queue_len);
+ if (input_msg) {
+ ntcsd_dl_input_48(lchan, input_msg->data,
+ rtpmsg_csd_align_bits(input_msg));
+ msgb_free(input_msg);
+ } else {
+ ntcsd_dl_reset(lchan);
+ }
+ }
+ good_rlp = ntcsd_dl_output(lchan, rlp_frame);
+ if (good_rlp)
+ gsmtap_csd_rlp_dl(lchan, fn, rlp_frame, 240);
+ memcpy(lchan->tch.csd.tchf48_nt_2ndhalf, rlp_frame+120, 120);
+ }
+
+ /* back to every 20 ms code path */
+ phy_msg = l1sap_msgb_alloc(120); /* half of RLP frame */
+ if (phy_msg) {
+ resp_l1sap = msgb_l1sap_prim(phy_msg);
+ phy_msg->l2h = msgb_put(phy_msg, 120);
+ if (csd_tchf48_nt_e2_map[fn % 26] == 0)
+ memcpy(phy_msg->l2h, rlp_frame, 120);
+ else
+ memcpy(phy_msg->l2h, lchan->tch.csd.tchf48_nt_2ndhalf,
120);
+ } else {
+ resp_l1sap = &empty_l1sap;
+ }
+
+ memset(resp_l1sap, 0, sizeof(*resp_l1sap));
+ osmo_prim_init(&resp_l1sap->oph, SAP_GSM_PH, PRIM_TCH, PRIM_OP_REQUEST,
+ phy_msg);
+ resp_l1sap->u.tch.chan_nr = chan_nr;
+ resp_l1sap->u.tch.fn = fn;
+ resp_l1sap->u.tch.marker = 0; /* M bit is undefined for clearmode */
+
+ LOGPLCGT(lchan, &g_time, DL1P, LOGL_DEBUG, "Tx TCH.req\n");
+
+ l1sap_down(trx, resp_l1sap);
+
+ return 0;
+}
+
+/* For TCH/F9.6 NT we need much less special processing than for TCH/F4.8 NT
+ * or for CSD-HR, but we still need to handle the possibility of misaligned
+ * RTP input, i.e., pseudo-V.110 frames aligned in the packet, but not
+ * forming proper RLP frame alignment via E2 & E3 bits. */
+static void tchf96_nt_dl_alignment(struct gsm_lchan *lchan, struct msgb *msg,
+ uint32_t fn)
+{
+ bool good_rlp;
+
+ if (!msg) {
+ ntcsd_dl_reset(lchan);
+ /* FIXME: do we really need to generate a PHY packet filled
+ * with 0 bits to satisfy TS 44.021 section 12.1, or can we
+ * get by with letting the PHY fill in ones like it does
+ * for all other CSD modes? */
+ return;
+ }
+ /* Fast path: handle the good case of already proper alignment */
+ if ((rtpmsg_csd_align_bits(msg) & 0xFF) == NTCSD_ALIGNED_EBITS) {
+ /* clear the buffer in case we have to do misaligned packets
+ * later, but otherwise let it go! */
+ ntcsd_dl_reset(lchan);
+ gsmtap_csd_rlp_dl(lchan, fn, msgb_l2(msg), msgb_l2len(msg));
+ return;
+ }
+ /* Slow path: realign like in other NT modes */
+ OSMO_ASSERT(msgb_l2len(msg) == 240);
+ ntcsd_dl_input_96(lchan, msgb_l2(msg), rtpmsg_csd_align_bits(msg));
+ good_rlp = ntcsd_dl_output(lchan, msgb_l2(msg));
+ if (good_rlp)
+ gsmtap_csd_rlp_dl(lchan, fn, msgb_l2(msg), msgb_l2len(msg));
+}
+
/* TCH-RTS-IND prim received from bts model */
static int l1sap_tch_rts_ind(struct gsm_bts_trx *trx,
struct osmo_phsap_prim *l1sap, struct ph_tch_param *rts_ind)
@@ -1601,8 +1726,14 @@
LOGPLCGT(lchan, &g_time, DL1P, LOGL_DEBUG, "Rx TCH-RTS.ind\n");
}
- if (lchan->rsl_cmode == RSL_CMOD_SPD_DATA && lchan->type ==
GSM_LCHAN_TCH_H)
+ /* CSD-HR requires special processing */
+ if (lchan->rsl_cmode == RSL_CMOD_SPD_DATA &&
+ lchan->type == GSM_LCHAN_TCH_H)
return tch_rts_ind_csd_hr(trx, lchan, rts_ind);
+ /* so does TCH/F4.8 NT mode */
+ if (lchan->tch_mode == GSM48_CMODE_DATA_6k0 &&
+ lchan->csd_mode == LCHAN_CSD_M_NT)
+ return tch_rts_ind_tchf48_nt(trx, lchan, rts_ind);
if (!lchan->loopback && lchan->abis_ip.rtp_socket) {
osmo_rtp_socket_poll(lchan->abis_ip.rtp_socket);
@@ -1650,6 +1781,24 @@
&resp_l1sap, &empty_l1sap);
}
+ /* minimal extra handling for the remaining CSD NT modes */
+ if (lchan->rsl_cmode == RSL_CMOD_SPD_DATA &&
+ lchan->csd_mode == LCHAN_CSD_M_NT) {
+ switch (lchan->tch_mode) {
+ case GSM48_CMODE_DATA_12k0:
+ tchf96_nt_dl_alignment(lchan, resp_msg, fn);
+ break;
+ case GSM48_CMODE_DATA_14k5:
+ gsmtap_csd_rlp_dl(lchan, fn, msgb_l2(resp_msg),
+ msgb_l2len(resp_msg));
+ break;
+ default:
+ LOGPLCGT(lchan, &g_time, DL1P, LOGL_ERROR,
+ "Invalid TCH mode in TCH-RTS.ind under CSD
NT\n");
+ break;
+ }
+ }
+
memset(resp_l1sap, 0, sizeof(*resp_l1sap));
osmo_prim_init(&resp_l1sap->oph, SAP_GSM_PH, PRIM_TCH, PRIM_OP_REQUEST,
resp_msg);
@@ -1979,20 +2128,11 @@
lchan->rtp_tx_marker = false;
}
-/* In the case of TCH/F4.8 NT, we have to set bit E2 based on the TDMA
- * frame number at which we received the block in question. See
- * GSM 05.03 section 3.4.1 and the mapping tables of GSM 05.02. */
-static const uint8_t tchf48_nt_e2_map[26] = {
- [4] = 1, /* B1 position */
- [13] = 1, /* B3 position */
- [21] = 1, /* B5 position */
-};
-
static void handle_tch_ind_csd_fr(struct gsm_lchan *lchan, const struct
ph_tch_param *tch_ind,
const uint8_t *data, uint16_t data_len)
{
uint8_t rtp_pl[RFC4040_RTP_PLEN];
- uint8_t tchf48_half = tchf48_nt_e2_map[tch_ind->fn % 26];
+ uint8_t tchf48_half = csd_tchf48_nt_e2_map[tch_ind->fn % 26];
int rc;
gsmtap_csd_rlp_process(lchan, true, tch_ind, data, data_len);
@@ -2558,10 +2698,6 @@
int rc = csd_v110_rtp_decode(lchan, msg->tail, &csd_align_bits,
rtp_pl, rtp_pl_len);
if (rc > 0) {
- /* 'fake' tch_ind containing all-zero so gsmtap code
can be shared
- * between UL and DL */
- static const struct ph_tch_param fake_tch_ind = {};
- gsmtap_csd_rlp_process(lchan, false, &fake_tch_ind,
msg->tail, rc);
msgb_put(msg, rc);
} else {
rate_ctr_inc2(bts->ctrs, BTS_CTR_RTP_RX_DROP_V110_DEC);
--
To view, visit https://gerrit.osmocom.org/c/osmo-bts/+/38557?usp=email
To unsubscribe, or for help writing mail filters, visit
https://gerrit.osmocom.org/settings?usp=email
Gerrit-MessageType: merged
Gerrit-Project: osmo-bts
Gerrit-Branch: master
Gerrit-Change-Id: Idaebfce6da13b23ba265a197502712d83991873e
Gerrit-Change-Number: 38557
Gerrit-PatchSet: 4
Gerrit-Owner: falconia <[email protected]>
Gerrit-Reviewer: Jenkins Builder
Gerrit-Reviewer: fixeria <[email protected]>
Gerrit-Reviewer: laforge <[email protected]>
Gerrit-Reviewer: pespin <[email protected]>
