cellular-infrastructure
/
osmo-pcu
mirror of https://gerrit.osmocom.org/osmo-pcu
9
0
Fork 1
Code Issues Releases Wiki Activity
osmo-pcu/src/rlc.h

562 lines
12 KiB
C
Raw Normal View History

pdch/tbf: Move gprs_rlcmac_rcv_data_block_acknowledged into the pdch Move the method into the PDCH. Extract the finding of TLLI into a new class called Decoding. Move the assemble and forward LLC frames into the TBF as it is poking in the internals of the TBF.
2013-10-26 15:32:04 +00:00
/* rlc header descriptions
*
* Copyright (C) 2012 Ivan Klyuchnikov
* Copyright (C) 2012 Andreas Eversberg <jolly@eversberg.eu>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#pragma once
edge: Add unified decoder methods for GPRS/EGPRS This commit adds new RLC block decoder functions that support both GPRS and EGPRS. The code path is selected based on the value of the GprsCodingScheme cs object. - rlc_parse_ul_data_header parses the header of an RLC data block including the E and FBI/TI flags (currently supported CS-1 - CS-4, MCS-1 - MCS-4). - rlc_copy_to_aligned_buffer copies an RLC data unit to a byte aligned buffer and returns the unit's length. - rlc_get_data_aligned is a convenience wrapper around rlc_copy_to_aligned_buffer that avoids copying if the data unit is already byte aligned. Sponsored-by: On-Waves ehf
2015-12-08 14:14:05 +00:00
#include "gprs_coding_scheme.h"
rlc: Check endianness for bit field declarations Currently the declarations of rlc_ul_header, rlc_dl_header, and rlc_li_field silently assume that a gcc for a little endian platform is being used. This commit adds '#if OSMO_IS_LITTLE_ENDIAN' the ensure the correct byte ordering. Sponsored-by: On-Waves ehf
2015-12-14 10:13:30 +00:00
#include <osmocom/core/endian.h>
pdch/tbf: Move gprs_rlcmac_rcv_data_block_acknowledged into the pdch Move the method into the PDCH. Extract the finding of TLLI into a new class called Decoding. Move the assemble and forward LLC frames into the TBF as it is poking in the internals of the TBF.
2013-10-26 15:32:04 +00:00
#include <stdint.h>
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
#define RLC_GPRS_SNS 128 /* GPRS, must be power of 2 */
#define RLC_GPRS_WS 64 /* max window size */
#define RLC_EGPRS_SNS 2048 /* EGPRS, must be power of 2 */
#define RLC_EGPRS_MIN_WS 64 /* min window size */
#define RLC_EGPRS_MAX_WS 1024 /* min window size */
#define RLC_EGPRS_SNS 2048 /* EGPRS, must be power of 2 */
#define RLC_MAX_SNS RLC_EGPRS_SNS
#define RLC_MAX_LEN 74 /* MCS-9 data unit */
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
misc: Do not mix struct/class in the forward declaration
2014-07-02 12:48:44 +00:00
struct BTS;
rlc/tbf: Move the code to raise V(R) into the ul_window handling
2013-11-25 22:26:06 +00:00
struct gprs_rlc_v_n;
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
/* The state of a BSN in the send/receive window */
enum gprs_rlc_ul_bsn_state {
GPRS_RLC_UL_BSN_INVALID,
GPRS_RLC_UL_BSN_RECEIVED,
GPRS_RLC_UL_BSN_MISSING,
GPRS_RLC_UL_BSN_MAX,
};
enum gprs_rlc_dl_bsn_state {
GPRS_RLC_DL_BSN_INVALID,
GPRS_RLC_DL_BSN_NACKED,
GPRS_RLC_DL_BSN_ACKED,
GPRS_RLC_DL_BSN_UNACKED,
GPRS_RLC_DL_BSN_RESEND,
GPRS_RLC_DL_BSN_MAX,
};
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
static inline uint16_t mod_sns_half()
{
return (RLC_MAX_SNS / 2) - 1;
}
edge: Rename gprs_rlc_ul_header_egprs and gprs_rlc_ul_data_block_info These struct names are more specific than necessary. They are used for GPRS (uplink) already. In downlink direction, only a few fields will be added to the header struct. Add addition, gprs_rlc_ul_header_egprs does not map directly to an encoded header, like many other 'header' structs do. Change the names to fit both modes and both directions: gprs_rlc_ul_header_egprs -> gprs_rlc_data_info gprs_rlc_ul_data_block_info -> gprs_rlc_data_block_info Sponsored-by: On-Waves ehf
2016-01-07 17:59:28 +00:00
struct gprs_rlc_data_block_info {
edge: Add unified decoder methods for GPRS/EGPRS This commit adds new RLC block decoder functions that support both GPRS and EGPRS. The code path is selected based on the value of the GprsCodingScheme cs object. - rlc_parse_ul_data_header parses the header of an RLC data block including the E and FBI/TI flags (currently supported CS-1 - CS-4, MCS-1 - MCS-4). - rlc_copy_to_aligned_buffer copies an RLC data unit to a byte aligned buffer and returns the unit's length. - rlc_get_data_aligned is a convenience wrapper around rlc_copy_to_aligned_buffer that avoids copying if the data unit is already byte aligned. Sponsored-by: On-Waves ehf
2015-12-08 14:14:05 +00:00
unsigned int data_len; /* EGPRS: N2, GPRS: N2-2, N-2 */
unsigned int bsn;
unsigned int ti;
unsigned int e;
rlc: Add info fields for downlink This commit extends gprs_rlc_data_info and gprs_rlc_data_block_info by the fields required for downlink RLC data messages. Sponsored-by: On-Waves ehf
2016-01-11 11:53:08 +00:00
unsigned int cv; /* FBI == 1 <=> CV == 0 */
edge: Add unified decoder methods for GPRS/EGPRS This commit adds new RLC block decoder functions that support both GPRS and EGPRS. The code path is selected based on the value of the GprsCodingScheme cs object. - rlc_parse_ul_data_header parses the header of an RLC data block including the E and FBI/TI flags (currently supported CS-1 - CS-4, MCS-1 - MCS-4). - rlc_copy_to_aligned_buffer copies an RLC data unit to a byte aligned buffer and returns the unit's length. - rlc_get_data_aligned is a convenience wrapper around rlc_copy_to_aligned_buffer that avoids copying if the data unit is already byte aligned. Sponsored-by: On-Waves ehf
2015-12-08 14:14:05 +00:00
unsigned int pi;
unsigned int spb;
};
edge: Rename gprs_rlc_ul_header_egprs and gprs_rlc_ul_data_block_info These struct names are more specific than necessary. They are used for GPRS (uplink) already. In downlink direction, only a few fields will be added to the header struct. Add addition, gprs_rlc_ul_header_egprs does not map directly to an encoded header, like many other 'header' structs do. Change the names to fit both modes and both directions: gprs_rlc_ul_header_egprs -> gprs_rlc_data_info gprs_rlc_ul_data_block_info -> gprs_rlc_data_block_info Sponsored-by: On-Waves ehf
2016-01-07 17:59:28 +00:00
struct gprs_rlc_data_info {
edge: Add unified decoder methods for GPRS/EGPRS This commit adds new RLC block decoder functions that support both GPRS and EGPRS. The code path is selected based on the value of the GprsCodingScheme cs object. - rlc_parse_ul_data_header parses the header of an RLC data block including the E and FBI/TI flags (currently supported CS-1 - CS-4, MCS-1 - MCS-4). - rlc_copy_to_aligned_buffer copies an RLC data unit to a byte aligned buffer and returns the unit's length. - rlc_get_data_aligned is a convenience wrapper around rlc_copy_to_aligned_buffer that avoids copying if the data unit is already byte aligned. Sponsored-by: On-Waves ehf
2015-12-08 14:14:05 +00:00
GprsCodingScheme cs;
unsigned int r;
unsigned int si;
unsigned int tfi;
unsigned int cps;
unsigned int rsb;
rlc: Add info fields for downlink This commit extends gprs_rlc_data_info and gprs_rlc_data_block_info by the fields required for downlink RLC data messages. Sponsored-by: On-Waves ehf
2016-01-11 11:53:08 +00:00
unsigned int usf;
unsigned int es_p;
unsigned int rrbp;
unsigned int pr;
edge: Add unified decoder methods for GPRS/EGPRS This commit adds new RLC block decoder functions that support both GPRS and EGPRS. The code path is selected based on the value of the GprsCodingScheme cs object. - rlc_parse_ul_data_header parses the header of an RLC data block including the E and FBI/TI flags (currently supported CS-1 - CS-4, MCS-1 - MCS-4). - rlc_copy_to_aligned_buffer copies an RLC data unit to a byte aligned buffer and returns the unit's length. - rlc_get_data_aligned is a convenience wrapper around rlc_copy_to_aligned_buffer that avoids copying if the data unit is already byte aligned. Sponsored-by: On-Waves ehf
2015-12-08 14:14:05 +00:00
unsigned int num_data_blocks;
unsigned int data_offs_bits[2];
edge: Rename gprs_rlc_ul_header_egprs and gprs_rlc_ul_data_block_info These struct names are more specific than necessary. They are used for GPRS (uplink) already. In downlink direction, only a few fields will be added to the header struct. Add addition, gprs_rlc_ul_header_egprs does not map directly to an encoded header, like many other 'header' structs do. Change the names to fit both modes and both directions: gprs_rlc_ul_header_egprs -> gprs_rlc_data_info gprs_rlc_ul_data_block_info -> gprs_rlc_data_block_info Sponsored-by: On-Waves ehf
2016-01-07 17:59:28 +00:00
struct gprs_rlc_data_block_info block_info[2];
edge: Add unified decoder methods for GPRS/EGPRS This commit adds new RLC block decoder functions that support both GPRS and EGPRS. The code path is selected based on the value of the GprsCodingScheme cs object. - rlc_parse_ul_data_header parses the header of an RLC data block including the E and FBI/TI flags (currently supported CS-1 - CS-4, MCS-1 - MCS-4). - rlc_copy_to_aligned_buffer copies an RLC data unit to a byte aligned buffer and returns the unit's length. - rlc_get_data_aligned is a convenience wrapper around rlc_copy_to_aligned_buffer that avoids copying if the data unit is already byte aligned. Sponsored-by: On-Waves ehf
2015-12-08 14:14:05 +00:00
};
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
struct gprs_rlc_data {
uint8_t *prepare(size_t block_data_length);
tbf/rlc: Move the putting of a block into the rlc code
2013-11-25 22:24:29 +00:00
void put_data(const uint8_t *data, size_t len);
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
/* block history */
uint8_t block[RLC_MAX_LEN];
/* block len of history */
uint8_t len;
tbf: Add adaptive DL CS adjustment To cope with transmission failures due to bad radio conditions, a different coding scheme with more redundance can be used. This commit adds an implemenation that is based on the Ack/Nack ratio per PACKET DOWNLINK ACK/NACK message received from the MS. Basically the CS level is decreased, if the block error rate goes above cs_adj_upper_limit (default 33%), and it is increased, if the rate drops below cs_adj_lower_limit (default 10%). Only blocks that have been encoded with the current CS are taken into account. Note that this approach doesn't measure the MS->BTS conditions and that the measurement values reported by the MS are not taken into account. Ticket: #1739 Sponsored-by: On-Waves ehf
2015-06-04 10:12:32 +00:00
edge: Rename gprs_rlc_ul_header_egprs and gprs_rlc_ul_data_block_info These struct names are more specific than necessary. They are used for GPRS (uplink) already. In downlink direction, only a few fields will be added to the header struct. Add addition, gprs_rlc_ul_header_egprs does not map directly to an encoded header, like many other 'header' structs do. Change the names to fit both modes and both directions: gprs_rlc_ul_header_egprs -> gprs_rlc_data_info gprs_rlc_ul_data_block_info -> gprs_rlc_data_block_info Sponsored-by: On-Waves ehf
2016-01-07 17:59:28 +00:00
struct gprs_rlc_data_block_info block_info;
edge: Store GprsCodingScheme in gprs_rlc_data Currently the coding scene is stored as number N, where there scheme is CS-N. This commit replaces this by a GprsCodingScheme type cs value. The gprs_rlcmac_cs table is no longer needed and thus removed. Sponsored-by: On-Waves ehf
2015-12-14 11:04:01 +00:00
GprsCodingScheme cs;
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
};
edge: Add init functions for gprs_rlc_data_info Add the functions gprs_rlc_data_info_init_dl/ul which initialise a gprs_rlc_data_info structure depending on the coding scheme. The fields num_data_blocks, data_offs_bits, cs, and the data_blocks are valid after this call. The other fields are set to 0. The data blocks are initialised to the correct data_len, e == 1 (no extension header field), cv == 15 (not a final block). The other data block fields are set to 0. The gprs_rlc_data_block_info can also be initialised separately by using the gprs_rlc_data_block_info_init function. Sponsored-by: On-Waves ehf
2016-01-11 10:15:45 +00:00
void gprs_rlc_data_info_init_dl(struct gprs_rlc_data_info *rlc,
GprsCodingScheme cs);
void gprs_rlc_data_info_init_ul(struct gprs_rlc_data_info *rlc,
GprsCodingScheme cs);
void gprs_rlc_data_block_info_init(struct gprs_rlc_data_block_info *rdbi,
GprsCodingScheme cs);
edge: Provide and use CS -> CPS conversion The MS' RLC receiver needs a valid CPS field to decode the block. Add the function gprs_rlc_mcs_cps to generate the CPS value based on coding scheme, puncturing, and padding. Sponsored-by: On-Waves ehf
2016-01-13 12:09:09 +00:00
unsigned int gprs_rlc_mcs_cps(GprsCodingScheme cs, int punct, int with_padding);
edge: Add init functions for gprs_rlc_data_info Add the functions gprs_rlc_data_info_init_dl/ul which initialise a gprs_rlc_data_info structure depending on the coding scheme. The fields num_data_blocks, data_offs_bits, cs, and the data_blocks are valid after this call. The other fields are set to 0. The data blocks are initialised to the correct data_len, e == 1 (no extension header field), cv == 15 (not a final block). The other data block fields are set to 0. The gprs_rlc_data_block_info can also be initialised separately by using the gprs_rlc_data_block_info_init function. Sponsored-by: On-Waves ehf
2016-01-11 10:15:45 +00:00
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
/*
* I hold the currently transferred blocks and will provide
* the routines to manipulate these arrays.
*/
struct gprs_rlc {
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
gprs_rlc_data *block(int bsn);
gprs_rlc_data m_blocks[RLC_MAX_SNS/2];
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
};
rlc/tbf: Move v_b into DL window Move functions resend_needed(), mark_for_resend(), update(), move_window(), state(), count_unacked() out of v_b directly into the UL window and provide a function get_state in v_b to access the v_b elements.
2013-12-28 17:24:42 +00:00
/**
* TODO: for GPRS/EDGE maybe make sns a template parameter
* so we create specialized versions...
*/
struct gprs_rlc_v_b {
/* Check for an individual frame */
bool is_unacked(int bsn) const;
bool is_nacked(int bsn) const;
bool is_acked(int bsn) const;
bool is_resend(int bsn) const;
bool is_invalid(int bsn) const;
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
gprs_rlc_dl_bsn_state get_state(int bsn) const;
rlc/tbf: Move v_b into DL window Move functions resend_needed(), mark_for_resend(), update(), move_window(), state(), count_unacked() out of v_b directly into the UL window and provide a function get_state in v_b to access the v_b elements.
2013-12-28 17:24:42 +00:00
/* Mark a RLC frame for something */
void mark_unacked(int bsn);
void mark_nacked(int bsn);
void mark_acked(int bsn);
void mark_resend(int bsn);
void mark_invalid(int bsn);
void reset();
private:
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
bool is_state(int bsn, const gprs_rlc_dl_bsn_state state) const;
void mark(int bsn, const gprs_rlc_dl_bsn_state state);
rlc/tbf: Move v_b into DL window Move functions resend_needed(), mark_for_resend(), update(), move_window(), state(), count_unacked() out of v_b directly into the UL window and provide a function get_state in v_b to access the v_b elements.
2013-12-28 17:24:42 +00:00
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
gprs_rlc_dl_bsn_state m_v_b[RLC_MAX_SNS/2]; /* acknowledge state array */
rlc/tbf: Move v_b into DL window Move functions resend_needed(), mark_for_resend(), update(), move_window(), state(), count_unacked() out of v_b directly into the UL window and provide a function get_state in v_b to access the v_b elements.
2013-12-28 17:24:42 +00:00
};
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
/**
tbf: Use LListHead instead of llist_pods LListHead does basically the same like llist_pods, but more C++ish and with type safety. This commit turns the former list field of gprs_rlcmac_tbf into a private field, provides accessors, moves the related code from pcu_vty.c to pcu_vty_functions.cpp, and removes the llist_pods type and related code. Sponsored-by: On-Waves ehf
2015-12-28 18:15:40 +00:00
* TODO: The UL/DL code could/should share a base class.
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
*/
struct gprs_rlc_dl_window {
tbf, ...: Make the fields in the dl/ul struct member variables There is no need for the union/struct anymore. Make the variable members of the UL/DL class. As a result gprs_rlc_dl_window gets a reset() method because memset(&dir.dl, 0, sizeof(dir.dl)) doesn't work anymore in reuse_tbf(). Ticket: SYS#389 Sponsored by: On-Waves ehf
2014-08-07 13:49:21 +00:00
void reset();
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
const uint16_t mod_sns() const;
rlc: Add and use mod_sns(bsn) method Currently there is only a mod_sns() method which is being used in expression like bsn_expr & win.mod_sns(). This only works, because it is known that mod_sns() is (sns() - 1) where sns() in turn is always 2^n. This is error prone, hard to read, and relies on window specifics that should be kept inside the respective module. This commit adds a mod_sns(uint bsn) method to gprs_rlc_ul_window and gprs_rlc_dl_window, that encapsulates and hides this optimized computation. Sponsored-by: On-Waves ehf
2015-12-23 15:29:07 +00:00
const uint16_t mod_sns(uint16_t bsn) const;
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
const uint16_t sns() const;
const uint16_t ws() const;
bool window_stalled() const;
bool window_empty() const;
void increment_send();
void raise(int moves);
const uint16_t v_s() const;
const uint16_t v_s_mod(int offset) const;
const uint16_t v_a() const;
const int16_t distance() const;
rlc/tbf: Move v_b into DL window Move functions resend_needed(), mark_for_resend(), update(), move_window(), state(), count_unacked() out of v_b directly into the UL window and provide a function get_state in v_b to access the v_b elements.
2013-12-28 17:24:42 +00:00
/* Methods to manage reception */
int resend_needed();
int mark_for_resend();
rlc/edge: Consistently use uint16_t for BSNs and SSNs Currently in some places uint8_t is being used to encode BSNs and SSNs. This is inconsistent and (even worse) not enough for EPGRS which uses an SNS of 2014. This commit changes these to uint16_t. Sponsored-by: On-Waves ehf
2015-12-23 15:40:56 +00:00
void update(BTS *bts, char *show_rbb, uint16_t ssn,
rlc/tbf: Move v_b into DL window Move functions resend_needed(), mark_for_resend(), update(), move_window(), state(), count_unacked() out of v_b directly into the UL window and provide a function get_state in v_b to access the v_b elements.
2013-12-28 17:24:42 +00:00
uint16_t *lost, uint16_t *received);
int move_window();
rlc: Rename state() to show_state() to better reflect its function show_state() is only used for debugging output to make the v(b) array human readable.
2014-01-15 11:45:56 +00:00
void show_state(char *show_rbb);
rlc/tbf: Move v_b into DL window Move functions resend_needed(), mark_for_resend(), update(), move_window(), state(), count_unacked() out of v_b directly into the UL window and provide a function get_state in v_b to access the v_b elements.
2013-12-28 17:24:42 +00:00
int count_unacked();
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
uint16_t m_v_s; /* send state */
uint16_t m_v_a; /* ack state */
rlc/tbf: Move v_b into DL window Move functions resend_needed(), mark_for_resend(), update(), move_window(), state(), count_unacked() out of v_b directly into the UL window and provide a function get_state in v_b to access the v_b elements.
2013-12-28 17:24:42 +00:00
gprs_rlc_v_b m_v_b;
rlc: Add constructor to window classes Currently the gprs_rlc_dl_window and gprs_rlc_ul_window do not have constructors, but need to get initialized explicitly. This commit adds constructors to both classes and removes explicit external initialization code. Sponsored-by: On-Waves ehf
2015-12-28 12:46:32 +00:00
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
void set_sns(uint16_t sns);
void set_ws(uint16_t ws);
rlc: Add constructor to window classes Currently the gprs_rlc_dl_window and gprs_rlc_ul_window do not have constructors, but need to get initialized explicitly. This commit adds constructors to both classes and removes explicit external initialization code. Sponsored-by: On-Waves ehf
2015-12-28 12:46:32 +00:00
gprs_rlc_dl_window();
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
private:
uint16_t m_sns;
uint16_t m_ws;
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
};
rlc/tbf: Move v_n into gprs_rlc_ul_window and adapt the tests v_n is part of the UL window handling so move it inside the ul_window
2013-12-28 12:59:24 +00:00
struct gprs_rlc_v_n {
void reset();
void mark_received(int bsn);
void mark_missing(int bsn);
bool is_received(int bsn) const;
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
gprs_rlc_ul_bsn_state state(int bsn) const;
rlc/tbf: Move v_n into gprs_rlc_ul_window and adapt the tests v_n is part of the UL window handling so move it inside the ul_window
2013-12-28 12:59:24 +00:00
private:
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
bool is_state(int bsn, const gprs_rlc_ul_bsn_state state) const;
void mark(int bsn, const gprs_rlc_ul_bsn_state state);
gprs_rlc_ul_bsn_state m_v_n[RLC_MAX_SNS/2]; /* receive state array */
rlc/tbf: Move v_n into gprs_rlc_ul_window and adapt the tests v_n is part of the UL window handling so move it inside the ul_window
2013-12-28 12:59:24 +00:00
};
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
struct gprs_rlc_ul_window {
const uint16_t mod_sns() const;
rlc: Add and use mod_sns(bsn) method Currently there is only a mod_sns() method which is being used in expression like bsn_expr & win.mod_sns(). This only works, because it is known that mod_sns() is (sns() - 1) where sns() in turn is always 2^n. This is error prone, hard to read, and relies on window specifics that should be kept inside the respective module. This commit adds a mod_sns(uint bsn) method to gprs_rlc_ul_window and gprs_rlc_dl_window, that encapsulates and hides this optimized computation. Sponsored-by: On-Waves ehf
2015-12-23 15:29:07 +00:00
const uint16_t mod_sns(uint16_t bsn) const;
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
const uint16_t sns() const;
const uint16_t ws() const;
const uint16_t v_r() const;
const uint16_t v_q() const;
rlc: Manage the received block bitmap in the ul_window Added two methods to gprs_rlc_ul_window * ssn() returns the starting sequence number * update_rbb() returns an array of chars representing the state of the received block bitmap. Each element is either 'I'nvalid or 'R'eceived. The rbb is generated from v_n rbb[63] relates to BSN ssn-1 ... rbb[0] relates to BSN ssn-64
2013-11-27 16:08:35 +00:00
const uint16_t ssn() const;
rlc/edge: Consistently use uint16_t for BSNs and SSNs Currently in some places uint8_t is being used to encode BSNs and SSNs. This is inconsistent and (even worse) not enough for EPGRS which uses an SNS of 2014. This commit changes these to uint16_t. Sponsored-by: On-Waves ehf
2015-12-23 15:40:56 +00:00
bool is_in_window(uint16_t bsn) const;
bool is_received(uint16_t bsn) const;
tbf/rlc: Move the check if something is in the window out.
2013-11-24 21:43:03 +00:00
rlc/tbf: Move v_n into gprs_rlc_ul_window and adapt the tests v_n is part of the UL window handling so move it inside the ul_window
2013-12-28 12:59:24 +00:00
void update_rbb(char *rbb);
rlc: Rename the simple raise_v_r method to avoid naming conflicts
2013-12-28 12:57:31 +00:00
void raise_v_r_to(int moves);
rlc/tbf: Move v_n into gprs_rlc_ul_window and adapt the tests v_n is part of the UL window handling so move it inside the ul_window
2013-12-28 12:59:24 +00:00
void raise_v_r(const uint16_t bsn);
uint16_t raise_v_q();
rlc/tbf: Move the code to raise V(R) into the ul_window handling
2013-11-25 22:26:06 +00:00
tbf/rlc: Move raising of V(Q) into the ul window code
2013-11-25 22:51:19 +00:00
void raise_v_q(int);
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
rlc: Do not raise_v_q in receive_bsn Currently gprs_rlc_ul_window::receive_bsn calls raise_v_q and returns the number of RLC data blocks that can be taken from the queue. This does not fit the EGPRS feature to put 2 independant data blocks in a single RLC block. This commit removes raise_v_q from receive_bsn, hence it must be called explicitely to get the number of processable data blocks. Sponsored-by: On-Waves ehf
2015-12-14 10:43:04 +00:00
void receive_bsn(const uint16_t bsn);
edge: Add is_received and invalidate_bsn to gprs_rlc_ul_window These methods will be needed for EGPRS decoding. The is_received method returns true iff a block with the given BSN has already been received in the current window. A call to invalidate_bsn marks the block as not received. Sponsored-by: On-Waves ehf
2015-12-14 10:54:29 +00:00
bool invalidate_bsn(const uint16_t bsn);
rlc/tbf: Add function receive_bsn that updates v_r, v_q, v_n We don't need to expose the mecanics of updating the variables to the outside.
2013-12-28 13:41:00 +00:00
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
uint16_t m_v_r; /* receive state */
uint16_t m_v_q; /* receive window state */
rlc/tbf: Move v_n into gprs_rlc_ul_window and adapt the tests v_n is part of the UL window handling so move it inside the ul_window
2013-12-28 12:59:24 +00:00
gprs_rlc_v_n m_v_n;
rlc: Add constructor to window classes Currently the gprs_rlc_dl_window and gprs_rlc_ul_window do not have constructors, but need to get initialized explicitly. This commit adds constructors to both classes and removes explicit external initialization code. Sponsored-by: On-Waves ehf
2015-12-28 12:46:32 +00:00
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
void set_sns(uint16_t sns);
void set_ws(uint16_t ws);
rlc: Add constructor to window classes Currently the gprs_rlc_dl_window and gprs_rlc_ul_window do not have constructors, but need to get initialized explicitly. This commit adds constructors to both classes and removes explicit external initialization code. Sponsored-by: On-Waves ehf
2015-12-28 12:46:32 +00:00
gprs_rlc_ul_window();
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
private:
uint16_t m_sns;
uint16_t m_ws;
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
};
pdch/tbf: Move gprs_rlcmac_rcv_data_block_acknowledged into the pdch Move the method into the PDCH. Extract the finding of TLLI into a new class called Decoding. Move the assemble and forward LLC frames into the TBF as it is poking in the internals of the TBF.
2013-10-26 15:32:04 +00:00
extern "C" {
/* TS 04.60 10.2.2 */
rlc: Check endianness for bit field declarations Currently the declarations of rlc_ul_header, rlc_dl_header, and rlc_li_field silently assume that a gcc for a little endian platform is being used. This commit adds '#if OSMO_IS_LITTLE_ENDIAN' the ensure the correct byte ordering. Sponsored-by: On-Waves ehf
2015-12-14 10:13:30 +00:00
#if OSMO_IS_LITTLE_ENDIAN
pdch/tbf: Move gprs_rlcmac_rcv_data_block_acknowledged into the pdch Move the method into the PDCH. Extract the finding of TLLI into a new class called Decoding. Move the assemble and forward LLC frames into the TBF as it is poking in the internals of the TBF.
2013-10-26 15:32:04 +00:00
struct rlc_ul_header {
uint8_t r:1,
si:1,
cv:4,
pt:2;
uint8_t ti:1,
tfi:5,
pi:1,
spare:1;
uint8_t e:1,
bsn:7;
} __attribute__ ((packed));
struct rlc_dl_header {
uint8_t usf:3,
s_p:1,
rrbp:2,
pt:2;
uint8_t fbi:1,
tfi:5,
pr:2;
uint8_t e:1,
bsn:7;
} __attribute__ ((packed));
struct rlc_li_field {
uint8_t e:1,
m:1,
li:6;
} __attribute__ ((packed));
edge: Add unified decoder methods for GPRS/EGPRS This commit adds new RLC block decoder functions that support both GPRS and EGPRS. The code path is selected based on the value of the GprsCodingScheme cs object. - rlc_parse_ul_data_header parses the header of an RLC data block including the E and FBI/TI flags (currently supported CS-1 - CS-4, MCS-1 - MCS-4). - rlc_copy_to_aligned_buffer copies an RLC data unit to a byte aligned buffer and returns the unit's length. - rlc_get_data_aligned is a convenience wrapper around rlc_copy_to_aligned_buffer that avoids copying if the data unit is already byte aligned. Sponsored-by: On-Waves ehf
2015-12-08 14:14:05 +00:00
struct rlc_li_field_egprs {
uint8_t e:1,
li:7;
} __attribute__ ((packed));
struct gprs_rlc_ul_header_egprs_3 {
uint8_t r:1,
si:1,
cv:4,
tfi_a:2;
uint8_t tfi_b:3,
bsn1_a:5;
uint8_t bsn1_b:6,
cps_a:2;
uint8_t cps_b:2,
spb:2,
rsb:1,
pi:1,
spare:1,
dummy:1;
} __attribute__ ((packed));
edge: Add encoder for downlink RLC data blocks Currently the (GPRS) RLC block encoding is done by setting the header fields directly in gprs_rlcmac_dl_tbf::create_new_bsn. This is much more complex with EGPRS, since the data fields are not byte aligned, the header formats depend on the header type, and the mapping of bits to bytes is LSB first. This commit adds Encoding::rlc_write_dl_data_header which writes the header according to the given gprs_rlc_data_header structure. Encoding::rlc_copy_from_aligned_buffer is also added to copy byte sequences into the message. Note that the actual encoding of data units is not yet present. Sponsored-by: On-Waves ehf
2016-01-08 09:07:53 +00:00
struct gprs_rlc_dl_header_egprs_3 {
uint8_t usf:3,
es_p:2,
rrbp:2,
tfi_a:1;
uint8_t tfi_b:4,
pr:2,
bsn1_a:2;
uint8_t bsn1_b:8;
uint8_t bsn1_c:1,
cps:4,
spb:2,
dummy:1;
} __attribute__ ((packed));
rlc: Check endianness for bit field declarations Currently the declarations of rlc_ul_header, rlc_dl_header, and rlc_li_field silently assume that a gcc for a little endian platform is being used. This commit adds '#if OSMO_IS_LITTLE_ENDIAN' the ensure the correct byte ordering. Sponsored-by: On-Waves ehf
2015-12-14 10:13:30 +00:00
#else
# error "Only little endian headers are supported yet. TODO: add missing structs"
#endif
pdch/tbf: Move gprs_rlcmac_rcv_data_block_acknowledged into the pdch Move the method into the PDCH. Extract the finding of TLLI into a new class called Decoding. Move the assemble and forward LLC frames into the TBF as it is poking in the internals of the TBF.
2013-10-26 15:32:04 +00:00
}
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
inline bool gprs_rlc_v_b::is_state(int bsn, const gprs_rlc_dl_bsn_state type) const
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
return m_v_b[bsn & mod_sns_half()] == type;
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
inline void gprs_rlc_v_b::mark(int bsn, const gprs_rlc_dl_bsn_state type)
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
m_v_b[bsn & mod_sns_half()] = type;
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline bool gprs_rlc_v_b::is_nacked(int bsn) const
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return is_state(bsn, GPRS_RLC_DL_BSN_NACKED);
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline bool gprs_rlc_v_b::is_acked(int bsn) const
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return is_state(bsn, GPRS_RLC_DL_BSN_ACKED);
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline bool gprs_rlc_v_b::is_unacked(int bsn) const
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return is_state(bsn, GPRS_RLC_DL_BSN_UNACKED);
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline bool gprs_rlc_v_b::is_resend(int bsn) const
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return is_state(bsn, GPRS_RLC_DL_BSN_RESEND);
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline bool gprs_rlc_v_b::is_invalid(int bsn) const
rlc: Create a basic test that mark/is is talking about the same
2013-11-23 15:18:18 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return is_state(bsn, GPRS_RLC_DL_BSN_INVALID);
rlc: Create a basic test that mark/is is talking about the same
2013-11-23 15:18:18 +00:00
}
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
inline gprs_rlc_dl_bsn_state gprs_rlc_v_b::get_state(int bsn) const
rlc/tbf: Move v_b into DL window Move functions resend_needed(), mark_for_resend(), update(), move_window(), state(), count_unacked() out of v_b directly into the UL window and provide a function get_state in v_b to access the v_b elements.
2013-12-28 17:24:42 +00:00
{
return m_v_b[bsn & mod_sns_half()];
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline void gprs_rlc_v_b::mark_resend(int bsn)
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return mark(bsn, GPRS_RLC_DL_BSN_RESEND);
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline void gprs_rlc_v_b::mark_unacked(int bsn)
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return mark(bsn, GPRS_RLC_DL_BSN_UNACKED);
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline void gprs_rlc_v_b::mark_acked(int bsn)
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return mark(bsn, GPRS_RLC_DL_BSN_ACKED);
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline void gprs_rlc_v_b::mark_nacked(int bsn)
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return mark(bsn, GPRS_RLC_DL_BSN_NACKED);
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline void gprs_rlc_v_b::mark_invalid(int bsn)
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return mark(bsn, GPRS_RLC_DL_BSN_INVALID);
rlc: Move the rlc headers into a separate header file
2013-11-23 15:10:48 +00:00
}
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
rlc: Add constructor to window classes Currently the gprs_rlc_dl_window and gprs_rlc_ul_window do not have constructors, but need to get initialized explicitly. This commit adds constructors to both classes and removes explicit external initialization code. Sponsored-by: On-Waves ehf
2015-12-28 12:46:32 +00:00
inline gprs_rlc_dl_window::gprs_rlc_dl_window()
: m_v_s(0)
, m_v_a(0)
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
, m_sns(RLC_GPRS_SNS)
, m_ws(RLC_GPRS_WS)
rlc: Add constructor to window classes Currently the gprs_rlc_dl_window and gprs_rlc_ul_window do not have constructors, but need to get initialized explicitly. This commit adds constructors to both classes and removes explicit external initialization code. Sponsored-by: On-Waves ehf
2015-12-28 12:46:32 +00:00
{
}
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
inline const uint16_t gprs_rlc_dl_window::sns() const
{
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
return m_sns;
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
}
inline const uint16_t gprs_rlc_dl_window::ws() const
{
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
return m_ws;
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
}
inline const uint16_t gprs_rlc_dl_window::mod_sns() const
{
return sns() - 1;
}
rlc: Add and use mod_sns(bsn) method Currently there is only a mod_sns() method which is being used in expression like bsn_expr & win.mod_sns(). This only works, because it is known that mod_sns() is (sns() - 1) where sns() in turn is always 2^n. This is error prone, hard to read, and relies on window specifics that should be kept inside the respective module. This commit adds a mod_sns(uint bsn) method to gprs_rlc_ul_window and gprs_rlc_dl_window, that encapsulates and hides this optimized computation. Sponsored-by: On-Waves ehf
2015-12-23 15:29:07 +00:00
inline const uint16_t gprs_rlc_dl_window::mod_sns(uint16_t bsn) const
{
return bsn & mod_sns();
}
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
inline const uint16_t gprs_rlc_dl_window::v_s() const
{
return m_v_s;
}
inline const uint16_t gprs_rlc_dl_window::v_s_mod(int offset) const
{
rlc: Add and use mod_sns(bsn) method Currently there is only a mod_sns() method which is being used in expression like bsn_expr & win.mod_sns(). This only works, because it is known that mod_sns() is (sns() - 1) where sns() in turn is always 2^n. This is error prone, hard to read, and relies on window specifics that should be kept inside the respective module. This commit adds a mod_sns(uint bsn) method to gprs_rlc_ul_window and gprs_rlc_dl_window, that encapsulates and hides this optimized computation. Sponsored-by: On-Waves ehf
2015-12-23 15:29:07 +00:00
return mod_sns(m_v_s + offset);
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
}
inline const uint16_t gprs_rlc_dl_window::v_a() const
{
return m_v_a;
}
inline bool gprs_rlc_dl_window::window_stalled() const
{
rlc: Add and use mod_sns(bsn) method Currently there is only a mod_sns() method which is being used in expression like bsn_expr & win.mod_sns(). This only works, because it is known that mod_sns() is (sns() - 1) where sns() in turn is always 2^n. This is error prone, hard to read, and relies on window specifics that should be kept inside the respective module. This commit adds a mod_sns(uint bsn) method to gprs_rlc_ul_window and gprs_rlc_dl_window, that encapsulates and hides this optimized computation. Sponsored-by: On-Waves ehf
2015-12-23 15:29:07 +00:00
return (mod_sns(m_v_s - m_v_a)) == ws();
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
}
inline bool gprs_rlc_dl_window::window_empty() const
{
return m_v_s == m_v_a;
}
inline void gprs_rlc_dl_window::increment_send()
{
m_v_s = (m_v_s + 1) & mod_sns();
}
inline void gprs_rlc_dl_window::raise(int moves)
{
m_v_a = (m_v_a + moves) & mod_sns();
}
inline const int16_t gprs_rlc_dl_window::distance() const
{
return (m_v_s - m_v_a) & mod_sns();
tbf/rlc: Move the check if something is in the window out.
2013-11-24 21:43:03 +00:00
}
rlc: Add constructor to window classes Currently the gprs_rlc_dl_window and gprs_rlc_ul_window do not have constructors, but need to get initialized explicitly. This commit adds constructors to both classes and removes explicit external initialization code. Sponsored-by: On-Waves ehf
2015-12-28 12:46:32 +00:00
inline gprs_rlc_ul_window::gprs_rlc_ul_window()
: m_v_r(0)
, m_v_q(0)
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
, m_sns(RLC_GPRS_SNS)
, m_ws(RLC_GPRS_WS)
rlc: Add constructor to window classes Currently the gprs_rlc_dl_window and gprs_rlc_ul_window do not have constructors, but need to get initialized explicitly. This commit adds constructors to both classes and removes explicit external initialization code. Sponsored-by: On-Waves ehf
2015-12-28 12:46:32 +00:00
{
}
rlc/edge: Consistently use uint16_t for BSNs and SSNs Currently in some places uint8_t is being used to encode BSNs and SSNs. This is inconsistent and (even worse) not enough for EPGRS which uses an SNS of 2014. This commit changes these to uint16_t. Sponsored-by: On-Waves ehf
2015-12-23 15:40:56 +00:00
inline bool gprs_rlc_ul_window::is_in_window(uint16_t bsn) const
tbf/rlc: Move the check if something is in the window out.
2013-11-24 21:43:03 +00:00
{
uint16_t offset_v_q;
/* current block relative to lowest unreceived block */
offset_v_q = (bsn - m_v_q) & mod_sns();
/* If out of window (may happen if blocks below V(Q) are received
* again. */
return offset_v_q < ws();
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
}
rlc/edge: Consistently use uint16_t for BSNs and SSNs Currently in some places uint8_t is being used to encode BSNs and SSNs. This is inconsistent and (even worse) not enough for EPGRS which uses an SNS of 2014. This commit changes these to uint16_t. Sponsored-by: On-Waves ehf
2015-12-23 15:40:56 +00:00
inline bool gprs_rlc_ul_window::is_received(uint16_t bsn) const
edge: Add is_received and invalidate_bsn to gprs_rlc_ul_window These methods will be needed for EGPRS decoding. The is_received method returns true iff a block with the given BSN has already been received in the current window. A call to invalidate_bsn marks the block as not received. Sponsored-by: On-Waves ehf
2015-12-14 10:54:29 +00:00
{
uint16_t offset_v_r;
/* Offset to the end of the received window */
offset_v_r = (m_v_r - 1 - bsn) & mod_sns();
return is_in_window(bsn) && m_v_n.is_received(bsn) && offset_v_r < ws();
}
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
inline const uint16_t gprs_rlc_ul_window::sns() const
{
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
return m_sns;
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
}
inline const uint16_t gprs_rlc_ul_window::ws() const
{
rlc: Make WS and SNS variable Currently the values for WS and SNS are fixed to 64 (WS) and 128 (SNS) which are the only values that can be used with GPRS. On the other hand, EGPRS requires an SNS of 2014 and a WS in the range of 64 to 1024. This commit adds member variables and setters to both window classes. By default, the GPRS values are being used. Sponsored-by: On-Waves ehf
2015-12-28 12:51:44 +00:00
return m_ws;
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
}
inline const uint16_t gprs_rlc_ul_window::mod_sns() const
{
return sns() - 1;
}
rlc: Add and use mod_sns(bsn) method Currently there is only a mod_sns() method which is being used in expression like bsn_expr & win.mod_sns(). This only works, because it is known that mod_sns() is (sns() - 1) where sns() in turn is always 2^n. This is error prone, hard to read, and relies on window specifics that should be kept inside the respective module. This commit adds a mod_sns(uint bsn) method to gprs_rlc_ul_window and gprs_rlc_dl_window, that encapsulates and hides this optimized computation. Sponsored-by: On-Waves ehf
2015-12-23 15:29:07 +00:00
inline const uint16_t gprs_rlc_ul_window::mod_sns(uint16_t bsn) const
{
return bsn & mod_sns();
}
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
inline const uint16_t gprs_rlc_ul_window::v_r() const
{
return m_v_r;
}
inline const uint16_t gprs_rlc_ul_window::v_q() const
{
return m_v_q;
}
rlc: Manage the received block bitmap in the ul_window Added two methods to gprs_rlc_ul_window * ssn() returns the starting sequence number * update_rbb() returns an array of chars representing the state of the received block bitmap. Each element is either 'I'nvalid or 'R'eceived. The rbb is generated from v_n rbb[63] relates to BSN ssn-1 ... rbb[0] relates to BSN ssn-64
2013-11-27 16:08:35 +00:00
inline const uint16_t gprs_rlc_ul_window::ssn() const
{
return m_v_r;
}
rlc: Rename the simple raise_v_r method to avoid naming conflicts
2013-12-28 12:57:31 +00:00
inline void gprs_rlc_ul_window::raise_v_r_to(int moves)
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
{
rlc: Add and use mod_sns(bsn) method Currently there is only a mod_sns() method which is being used in expression like bsn_expr & win.mod_sns(). This only works, because it is known that mod_sns() is (sns() - 1) where sns() in turn is always 2^n. This is error prone, hard to read, and relies on window specifics that should be kept inside the respective module. This commit adds a mod_sns(uint bsn) method to gprs_rlc_ul_window and gprs_rlc_dl_window, that encapsulates and hides this optimized computation. Sponsored-by: On-Waves ehf
2015-12-23 15:29:07 +00:00
m_v_r = mod_sns(m_v_r + moves);
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
}
tbf/rlc: Move raising of V(Q) into the ul window code
2013-11-25 22:51:19 +00:00
inline void gprs_rlc_ul_window::raise_v_q(int incr)
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
{
rlc: Add and use mod_sns(bsn) method Currently there is only a mod_sns() method which is being used in expression like bsn_expr & win.mod_sns(). This only works, because it is known that mod_sns() is (sns() - 1) where sns() in turn is always 2^n. This is error prone, hard to read, and relies on window specifics that should be kept inside the respective module. This commit adds a mod_sns(uint bsn) method to gprs_rlc_ul_window and gprs_rlc_dl_window, that encapsulates and hides this optimized computation. Sponsored-by: On-Waves ehf
2015-12-23 15:29:07 +00:00
m_v_q = mod_sns(m_v_q + incr);
tbf/rlc: Big change and move the window handling out to the rlc The send and receive window is now managed by an external object. There are some issues that can only be solved with C++11 but it is progres and removes some of the spaghetti code. For GPRS the sns and ws is hardcoded. Move that into the window code.
2013-11-24 19:36:36 +00:00
}
tbf/rlc: Move the v_n handling into a dedicated object
2013-11-24 19:55:02 +00:00
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline void gprs_rlc_v_n::mark_received(int bsn)
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return mark(bsn, GPRS_RLC_UL_BSN_RECEIVED);
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
}
inline void gprs_rlc_v_n::mark_missing(int bsn)
tbf/rlc: Move the v_n handling into a dedicated object
2013-11-24 19:55:02 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return mark(bsn, GPRS_RLC_UL_BSN_MISSING);
tbf/rlc: Move the v_n handling into a dedicated object
2013-11-24 19:55:02 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline bool gprs_rlc_v_n::is_received(int bsn) const
tbf/rlc: Move the v_n handling into a dedicated object
2013-11-24 19:55:02 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return is_state(bsn, GPRS_RLC_UL_BSN_RECEIVED);
tbf/rlc: Move the v_n handling into a dedicated object
2013-11-24 19:55:02 +00:00
}
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
inline bool gprs_rlc_v_n::is_state(int bsn, gprs_rlc_ul_bsn_state type) const
tbf/rlc: Move the v_n handling into a dedicated object
2013-11-24 19:55:02 +00:00
{
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
return m_v_n[bsn & mod_sns_half()] == type;
tbf/rlc: Move the v_n handling into a dedicated object
2013-11-24 19:55:02 +00:00
}
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
inline void gprs_rlc_v_n::mark(int bsn, gprs_rlc_ul_bsn_state type)
tbf/rlc: Move the v_n handling into a dedicated object
2013-11-24 19:55:02 +00:00
{
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
m_v_n[bsn & mod_sns_half()] = type;
}
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
inline gprs_rlc_ul_bsn_state gprs_rlc_v_n::state(int bsn) const
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
{
rlc: Use an enum for the state array instead of chars gprs_rlc_bsn_state is now used to hold the ACK state of sent/received rlc packets.
2013-12-28 20:16:13 +00:00
return m_v_n[bsn & mod_sns_half()];
tbf/rlc: Move the v_n handling into a dedicated object
2013-11-24 19:55:02 +00:00
}
rlc: Make the RLC types only operate on the BSN The code has an internal optimization to only use window_size space. This means that the caller needed to know that only half of the size was used. Change the API to work on the BSN and do the mapping internally. The compiler should have plenty of opportunity to propagate the constant(s) but this has not been verified.
2013-11-26 20:43:58 +00:00
inline gprs_rlc_data *gprs_rlc::block(int bsn)
{
return &m_blocks[bsn & mod_sns_half()];
}