blob: 6a7960c259e9dc44a68af4ab57023d32a5ad2cbc [file] [log] [blame]
Holger Hans Peter Freytherb6acfda2013-10-17 19:41:11 +02001/*
2 * Copyright (C) 2013 by Holger Hans Peter Freyther
3 *
4 * All Rights Reserved
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU Affero General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU Affero General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21#include <bts.h>
Holger Hans Peter Freytherb78adcd2013-10-17 20:12:37 +020022#include <poll_controller.h>
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +020023#include <tbf.h>
Pau Espin Pedrol9d1cdb12019-09-25 17:47:02 +020024#include <tbf_ul.h>
Holger Hans Peter Freyther63f29d62013-10-19 19:04:03 +020025#include <encoding.h>
Holger Hans Peter Freytherd11290b2013-10-26 17:32:04 +020026#include <decoding.h>
27#include <rlc.h>
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +020028#include <pcu_l1_if.h>
Max1187a772018-01-26 13:31:42 +010029#include <gprs_ms.h>
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +020030#include <gprs_rlcmac.h>
Holger Hans Peter Freyther24e98d02013-10-19 18:15:44 +020031#include <gprs_debug.h>
Max1187a772018-01-26 13:31:42 +010032#include <cxx_linuxlist.h>
Max6dc90b82018-02-19 17:17:28 +010033#include <pdch.h>
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +020034
35extern "C" {
36 #include <osmocom/core/talloc.h>
Holger Hans Peter Freyther24e98d02013-10-19 18:15:44 +020037 #include <osmocom/core/msgb.h>
Holger Hans Peter Freyther8df447d2015-11-07 21:04:40 +010038 #include <osmocom/core/stats.h>
Max9bbe1602016-07-18 12:50:18 +020039 #include <osmocom/gsm/protocol/gsm_04_08.h>
Philipp Maier1275a3f2017-02-21 19:35:23 +010040 #include <osmocom/gsm/gsm_utils.h>
Pau Espin Pedrolfbfab292019-12-23 13:19:25 +010041 #include <osmocom/gsm/gsm48.h>
Harald Welte717cdf52017-07-21 21:56:23 +020042 #include <osmocom/core/gsmtap_util.h>
Harald Welte3e51d3e2017-10-29 10:57:27 +010043 #include <osmocom/core/application.h>
Max1187a772018-01-26 13:31:42 +010044 #include <osmocom/core/bitvec.h>
45 #include <osmocom/core/gsmtap.h>
46 #include <osmocom/core/logging.h>
47 #include <osmocom/core/utils.h>
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +020048}
Holger Hans Peter Freytherb78adcd2013-10-17 20:12:37 +020049
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +020050#include <errno.h>
Holger Hans Peter Freytherb6acfda2013-10-17 19:41:11 +020051#include <string.h>
52
Philipp Maier1275a3f2017-02-21 19:35:23 +010053#define RFN_MODULUS 42432
54#define RFN_THRESHOLD RFN_MODULUS / 2
55
Holger Hans Peter Freyther24e98d02013-10-19 18:15:44 +020056extern void *tall_pcu_ctx;
57
Harald Welte3e51d3e2017-10-29 10:57:27 +010058extern "C" {
59 /* e must make sure to initialize logging before the BTS static
60 * constructors are executed below, as those call libosmocore APIs that
61 * require logging already to be initialized. */
Harald Welte0a369e52020-09-30 19:57:02 +020062 __attribute__((constructor (101))) static void early_init(void)
Harald Welte3e51d3e2017-10-29 10:57:27 +010063 {
Neels Hofmeyr42f2d612018-04-01 16:54:40 +020064 if (!tall_pcu_ctx) {
65 tall_pcu_ctx = talloc_named_const(NULL, 1, "Osmo-PCU context");
66 osmo_init_logging2(tall_pcu_ctx, &gprs_log_info);
67 }
Harald Welte3e51d3e2017-10-29 10:57:27 +010068 }
69}
70
Holger Hans Peter Freytherb6acfda2013-10-17 19:41:11 +020071static BTS s_bts;
72
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +020073static struct osmo_tdef T_defs_bts[] = {
74 { .T=3142, .default_val=20, .unit=OSMO_TDEF_S, .desc="timer (s)", .val=0 },
75 { .T=3169, .default_val=5, .unit=OSMO_TDEF_S, .desc="Reuse of USF and TFI(s) after the MS uplink TBF assignment is invalid (s)", .val=0 },
76 { .T=3191, .default_val=5, .unit=OSMO_TDEF_S, .desc="Reuse of TFI(s) after sending (1) last RLC Data Block on TBF(s), or (2) PACKET TBF RELEASE for an MBMS radio bearer (s)", .val=0 },
77 { .T=3193, .default_val=100, .unit=OSMO_TDEF_MS, .desc="Reuse of TFI(s) after reception of final PACKET DOWNLINK ACK/NACK from MS for TBF (ms)", .val=0 },
78 { .T=3195, .default_val=5, .unit=OSMO_TDEF_S, .desc="Reuse of TFI(s) upon no response from the MS (radio failure or cell change) for TBF/MBMS radio bearer (s)", .val=0 },
Pau Espin Pedrol5360ef52019-09-13 12:41:54 +020079 { .T=0, .default_val=0, .unit=OSMO_TDEF_S, .desc=NULL, .val=0 } /* empty item at the end */
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +020080};
81static struct osmo_tdef T_defs_pcu[] = {
Pau Espin Pedrol5211d9d2019-09-05 16:20:22 +020082 { .T=1, .default_val=30, .unit=OSMO_TDEF_S, .desc="BSSGP (un)blocking procedures timer (s)", .val=0 },
83 { .T=2, .default_val=30, .unit=OSMO_TDEF_S, .desc="BSSGP reset procedure timer (s)", .val=0 },
Pau Espin Pedrol38cfa732019-09-09 12:55:01 +020084 { .T=3190, .default_val=5, .unit=OSMO_TDEF_S, .desc="Return to packet idle mode after Packet DL Assignment on CCCH (s)", .val=0},
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +020085 { .T=-2000, .default_val=2, .unit=OSMO_TDEF_MS, .desc="Tbf reject for PRR timer (ms)", .val=0 },
86 { .T=-2001, .default_val=2, .unit=OSMO_TDEF_S, .desc="PACCH assignment timer (s)", .val=0 },
87 { .T=-2002, .default_val=200, .unit=OSMO_TDEF_MS, .desc="Waiting after IMM.ASS confirm timer (ms)", .val=0 },
Pau Espin Pedrol63700ea2019-09-09 13:19:06 +020088 { .T=-2030, .default_val=60, .unit=OSMO_TDEF_S, .desc="Time to keep an idle MS object alive (s)", .val=0 }, /* slightly above T3314 (default 44s, 24.008, 11.2.2) */
Pau Espin Pedrol2b5c6292019-09-09 13:41:00 +020089 { .T=-2031, .default_val=2000, .unit=OSMO_TDEF_MS, .desc="Time to keep an idle DL TBF alive (ms)", .val=0 },
Pau Espin Pedrol5360ef52019-09-13 12:41:54 +020090 { .T=0, .default_val=0, .unit=OSMO_TDEF_S, .desc=NULL, .val=0 } /* empty item at the end */
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +020091};
92
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +010093/**
94 * For gcc-4.4 compat do not use extended initializer list but keep the
95 * order from the enum here. Once we support GCC4.7 and up we can change
96 * the code below.
97 */
98static const struct rate_ctr_desc bts_ctr_description[] = {
Maxa5eb67d2017-11-21 20:24:54 +010099 { "tbf:dl:alloc", "TBF DL Allocated "},
100 { "tbf:dl:freed", "TBF DL Freed "},
101 { "tbf:dl:aborted", "TBF DL Aborted "},
102 { "tbf:ul:alloc", "TBF UL Allocated "},
103 { "tbf:ul:freed", "TBF UL Freed "},
104 { "tbf:ul:aborted", "TBF UL Aborted "},
105 { "tbf:reused", "TBF Reused "},
106 { "tbf:alloc:algo-a", "TBF Alloc Algo A "},
107 { "tbf:alloc:algo-b", "TBF Alloc Algo B "},
108 { "tbf:failed:egprs-only", "TBF Failed EGPRS-only"},
109 { "rlc:sent", "RLC Sent "},
110 { "rlc:resent", "RLC Resent "},
111 { "rlc:restarted", "RLC Restarted "},
112 { "rlc:stalled", "RLC Stalled "},
113 { "rlc:nacked", "RLC Nacked "},
114 { "rlc:final_block_resent", "RLC Final Blk resent "},
115 { "rlc:ass:timedout", "RLC Assign Timeout "},
116 { "rlc:ass:failed", "RLC Assign Failed "},
117 { "rlc:ack:timedout", "RLC Ack Timeout "},
118 { "rlc:ack:failed", "RLC Ack Failed "},
119 { "rlc:rel:timedout", "RLC Release Timeout "},
120 { "rlc:late-block", "RLC Late Block "},
121 { "rlc:sent-dummy", "RLC Sent Dummy "},
122 { "rlc:sent-control", "RLC Sent Control "},
123 { "rlc:dl_bytes", "RLC DL Bytes "},
124 { "rlc:dl_payload_bytes", "RLC DL Payload Bytes "},
125 { "rlc:ul_bytes", "RLC UL Bytes "},
126 { "rlc:ul_payload_bytes", "RLC UL Payload Bytes "},
127 { "decode:errors", "Decode Errors "},
128 { "sba:allocated", "SBA Allocated "},
129 { "sba:freed", "SBA Freed "},
130 { "sba:timedout", "SBA Timeout "},
131 { "llc:timeout", "Timedout Frames "},
132 { "llc:dropped", "Dropped Frames "},
133 { "llc:scheduled", "Scheduled Frames "},
134 { "llc:dl_bytes", "RLC encapsulated PDUs"},
135 { "llc:ul_bytes", "full PDUs received "},
136 { "rach:requests", "RACH requests "},
137 { "11bit_rach:requests", "11BIT_RACH requests "},
138 { "spb:uplink_first_segment", "First seg of UL SPB "},
139 { "spb:uplink_second_segment", "Second seg of UL SPB "},
140 { "spb:downlink_first_segment", "First seg of DL SPB "},
141 { "spb:downlink_second_segment","Second seg of DL SPB "},
142 { "immediate:assignment_UL", "Immediate Assign UL "},
143 { "immediate:assignment_rej", "Immediate Assign Rej "},
144 { "immediate:assignment_DL", "Immediate Assign DL "},
145 { "channel:request_description","Channel Request Desc "},
146 { "pkt:ul_assignment", "Packet UL Assignment "},
147 { "pkt:access_reject", "Packet Access Reject "},
148 { "pkt:dl_assignment", "Packet DL Assignment "},
149 { "ul:control", "UL control Block "},
150 { "ul:assignment_poll_timeout", "UL Assign Timeout "},
151 { "ul:assignment_failed", "UL Assign Failed "},
152 { "dl:assignment_timeout", "DL Assign Timeout "},
153 { "dl:assignment_failed", "DL Assign Failed "},
154 { "pkt:ul_ack_nack_timeout", "PUAN Poll Timeout "},
155 { "pkt:ul_ack_nack_failed", "PUAN poll Failed "},
156 { "pkt:dl_ack_nack_timeout", "PDAN poll Timeout "},
157 { "pkt:dl_ack_nack_failed", "PDAN poll Failed "},
158 { "gprs:downlink_cs1", "CS1 downlink "},
159 { "gprs:downlink_cs2", "CS2 downlink "},
160 { "gprs:downlink_cs3", "CS3 downlink "},
161 { "gprs:downlink_cs4", "CS4 downlink "},
162 { "egprs:downlink_mcs1", "MCS1 downlink "},
163 { "egprs:downlink_mcs2", "MCS2 downlink "},
164 { "egprs:downlink_mcs3", "MCS3 downlink "},
165 { "egprs:downlink_mcs4", "MCS4 downlink "},
166 { "egprs:downlink_mcs5", "MCS5 downlink "},
167 { "egprs:downlink_mcs6", "MCS6 downlink "},
168 { "egprs:downlink_mcs7", "MCS7 downlink "},
169 { "egprs:downlink_mcs8", "MCS8 downlink "},
170 { "egprs:downlink_mcs9", "MCS9 downlink "},
171 { "gprs:uplink_cs1", "CS1 Uplink "},
172 { "gprs:uplink_cs2", "CS2 Uplink "},
173 { "gprs:uplink_cs3", "CS3 Uplink "},
174 { "gprs:uplink_cs4", "CS4 Uplink "},
175 { "egprs:uplink_mcs1", "MCS1 Uplink "},
176 { "egprs:uplink_mcs2", "MCS2 Uplink "},
177 { "egprs:uplink_mcs3", "MCS3 Uplink "},
178 { "egprs:uplink_mcs4", "MCS4 Uplink "},
179 { "egprs:uplink_mcs5", "MCS5 Uplink "},
180 { "egprs:uplink_mcs6", "MCS6 Uplink "},
181 { "egprs:uplink_mcs7", "MCS7 Uplink "},
182 { "egprs:uplink_mcs8", "MCS8 Uplink "},
183 { "egprs:uplink_mcs9", "MCS9 Uplink "},
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100184};
185
186static const struct rate_ctr_group_desc bts_ctrg_desc = {
187 "bts",
188 "BTS Statistics",
Holger Hans Peter Freytherb8a54262015-11-07 21:00:00 +0100189 OSMO_STATS_CLASS_GLOBAL,
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100190 ARRAY_SIZE(bts_ctr_description),
191 bts_ctr_description,
192};
193
Jacob Erlbeckf5898a02015-11-27 19:05:13 +0100194static const struct osmo_stat_item_desc bts_stat_item_description[] = {
195 { "ms.present", "MS Present ",
196 OSMO_STAT_ITEM_NO_UNIT, 4, 0},
197};
198
199static const struct osmo_stat_item_group_desc bts_statg_desc = {
200 "bts",
201 "BTS Statistics",
202 OSMO_STATS_CLASS_GLOBAL,
203 ARRAY_SIZE(bts_stat_item_description),
204 bts_stat_item_description,
205};
206
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100207static void bts_init(struct gprs_rlcmac_bts *bts, BTS* bts_obj)
208{
209 memset(bts, 0, sizeof(*bts));
210 bts->fc_interval = 1;
211 bts->initial_cs_dl = bts->initial_cs_ul = 1;
212 bts->initial_mcs_dl = bts->initial_mcs_ul = 1;
213 bts->cs1 = 1;
214 bts->n3101 = 10;
215 bts->n3103 = 4;
216 bts->n3105 = 8;
217 bts->alpha = 0; /* a = 0.0 */
218 bts->si13_is_set = false;
219 bts->cs_adj_enabled = 1;
220 bts->cs_adj_upper_limit = 33; /* Decrease CS if the error rate is above */
221 bts->cs_adj_lower_limit = 10; /* Increase CS if the error rate is below */
222 bts->max_cs_ul = MAX_GPRS_CS;
223 bts->max_cs_dl = MAX_GPRS_CS;
224 bts->max_mcs_ul = MAX_EDGE_MCS;
225 bts->max_mcs_dl = MAX_EDGE_MCS;
226 /* CS-1 to CS-4 */
227 bts->cs_lqual_ranges[0].low = -256;
228 bts->cs_lqual_ranges[0].high = 6;
229 bts->cs_lqual_ranges[1].low = 5;
230 bts->cs_lqual_ranges[1].high = 8;
231 bts->cs_lqual_ranges[2].low = 7;
232 bts->cs_lqual_ranges[2].high = 13;
233 bts->cs_lqual_ranges[3].low = 12;
234 bts->cs_lqual_ranges[3].high = 256;
235
236 /* MCS-1 to MCS-9 */
237 /* Default thresholds are referenced from literature */
238 /* Fig. 2.3, Chapter 2, Optimizing Wireless Communication Systems, Springer (2009) */
239 bts->mcs_lqual_ranges[0].low = -256;
240 bts->mcs_lqual_ranges[0].high = 6;
241 bts->mcs_lqual_ranges[1].low = 5;
242 bts->mcs_lqual_ranges[1].high = 8;
243 bts->mcs_lqual_ranges[2].low = 7;
244 bts->mcs_lqual_ranges[2].high = 13;
245 bts->mcs_lqual_ranges[3].low = 12;
246 bts->mcs_lqual_ranges[3].high = 15;
247 bts->mcs_lqual_ranges[4].low = 14;
248 bts->mcs_lqual_ranges[4].high = 17;
249 bts->mcs_lqual_ranges[5].low = 16;
250 bts->mcs_lqual_ranges[5].high = 18;
251 bts->mcs_lqual_ranges[6].low = 17;
252 bts->mcs_lqual_ranges[6].high = 20;
253 bts->mcs_lqual_ranges[7].low = 19;
254 bts->mcs_lqual_ranges[7].high = 24;
255 bts->mcs_lqual_ranges[8].low = 23;
256 bts->mcs_lqual_ranges[8].high = 256;
257 bts->cs_downgrade_threshold = 200;
258
259 /* TODO: increase them when CRBB decoding is implemented */
260 bts->ws_base = 64;
261 bts->ws_pdch = 0;
262
263 bts->llc_codel_interval_msec = LLC_CODEL_USE_DEFAULT;
264 bts->llc_idle_ack_csec = 10;
265
266 /*
267 * By default resegmentation is supported in DL
268 * can also be configured through VTY
269 */
270 bts->dl_arq_type = EGPRS_ARQ1;
271
272 bts->app_info = NULL;
273 bts->bts = bts_obj;
274 bts->dl_tbf_preemptive_retransmission = true;
275 bts->T_defs_bts = T_defs_bts;
276 bts->T_defs_pcu = T_defs_pcu;
277 osmo_tdefs_reset(bts->T_defs_bts);
278 osmo_tdefs_reset(bts->T_defs_pcu);
279
280 /* initialize back pointers */
281 for (size_t trx_no = 0; trx_no < ARRAY_SIZE(bts->trx); ++trx_no) {
282 struct gprs_rlcmac_trx *trx = &bts->trx[trx_no];
283 trx->trx_no = trx_no;
284 trx->bts = bts_obj;
285
286 for (size_t ts_no = 0; ts_no < ARRAY_SIZE(trx->pdch); ++ts_no) {
287 struct gprs_rlcmac_pdch *pdch = &trx->pdch[ts_no];
288 pdch->init_ptcch_msg();
289 pdch->ts_no = ts_no;
290 pdch->trx = trx;
291 }
292 }
293}
294
Holger Hans Peter Freytherb6acfda2013-10-17 19:41:11 +0200295BTS* BTS::main_bts()
296{
297 return &s_bts;
298}
299
300struct gprs_rlcmac_bts *BTS::bts_data()
301{
302 return &m_bts;
303}
304
305struct gprs_rlcmac_bts *bts_main_data()
306{
307 return BTS::main_bts()->bts_data();
308}
309
Maxd5ffeb52019-03-18 15:48:38 +0100310void bts_cleanup()
311{
312 return BTS::main_bts()->cleanup();
313}
314
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100315struct rate_ctr_group *bts_main_data_stats()
316{
317 return BTS::main_bts()->rate_counters();
318}
319
Holger Hans Peter Freytherb6acfda2013-10-17 19:41:11 +0200320BTS::BTS()
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200321 : m_cur_fn(0)
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200322 , m_cur_blk_fn(-1)
Holger Hans Peter Freytherb78adcd2013-10-17 20:12:37 +0200323 , m_pollController(*this)
Holger Hans Peter Freythercedf8902013-10-19 20:47:12 +0200324 , m_sba(*this)
Jacob Erlbeck17214bb2015-06-02 14:06:12 +0200325 , m_ms_store(this)
Holger Hans Peter Freytherb6acfda2013-10-17 19:41:11 +0200326{
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100327 bts_init(&m_bts, this);
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100328
Maxea9968f2017-12-18 22:52:52 +0100329 /* The static allocator might have already registered the counter group.
Max1714aea2017-12-21 11:19:39 +0100330 If this happens and we still called explicitly (in tests/ for example)
Maxea9968f2017-12-18 22:52:52 +0100331 than just allocate the group with different index.
332 This shall be removed once weget rid of BTS singleton */
333 if (rate_ctr_get_group_by_name_idx(bts_ctrg_desc.group_name_prefix, 0))
334 m_ratectrs = rate_ctr_group_alloc(tall_pcu_ctx, &bts_ctrg_desc, 1);
335 else
336 m_ratectrs = rate_ctr_group_alloc(tall_pcu_ctx, &bts_ctrg_desc, 0);
Harald Welte9530a402017-07-12 00:46:36 +0200337 OSMO_ASSERT(m_ratectrs);
Maxea9968f2017-12-18 22:52:52 +0100338
Jacob Erlbeckf5898a02015-11-27 19:05:13 +0100339 m_statg = osmo_stat_item_group_alloc(tall_pcu_ctx, &bts_statg_desc, 0);
Harald Welte9530a402017-07-12 00:46:36 +0200340 OSMO_ASSERT(m_statg);
Holger Hans Peter Freytherb6acfda2013-10-17 19:41:11 +0200341}
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200342
Maxd5ffeb52019-03-18 15:48:38 +0100343void BTS::cleanup()
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100344{
Jacob Erlbeckc362df22016-01-20 22:02:19 +0100345 /* this can cause counter updates and must not be left to the
346 * m_ms_store's destructor */
347 m_ms_store.cleanup();
348
Maxd5ffeb52019-03-18 15:48:38 +0100349 if (m_ratectrs) {
350 rate_ctr_group_free(m_ratectrs);
351 m_ratectrs = NULL;
352 }
353
354 if (m_statg) {
355 osmo_stat_item_group_free(m_statg);
356 m_statg = NULL;
357 }
Oliver Smithcfb63212019-09-05 17:13:33 +0200358
359 if (m_bts.app_info) {
360 msgb_free(m_bts.app_info);
361 m_bts.app_info = NULL;
362 }
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100363}
364
Maxd5ffeb52019-03-18 15:48:38 +0100365BTS::~BTS()
366{
367 cleanup();
368}
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100369
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200370void BTS::set_current_frame_number(int fn)
371{
Jacob Erlbeckac49d092015-08-27 13:18:24 +0200372 /* The UL frame numbers lag 3 behind the DL frames and the data
373 * indication is only sent after all 4 frames of the block have been
374 * received. Sometimes there is an idle frame between the end of one
375 * and start of another frame (every 3 blocks). So the timeout should
376 * definitely be there if we're more than 8 frames past poll_fn. Let's
Jacob Erlbecke77d49f2015-08-27 13:28:05 +0200377 * stay on the safe side and say 13 or more. An additional delay can
378 * happen due to the block processing time in the DSP, so the delay of
379 * decoded blocks relative to the timing clock can be much larger.
380 * Values up to 50 frames have been observed under load. */
381 const static int max_delay = 60;
Jacob Erlbeckac49d092015-08-27 13:18:24 +0200382
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200383 m_cur_fn = fn;
Jacob Erlbeckac49d092015-08-27 13:18:24 +0200384 m_pollController.expireTimedout(m_cur_fn, max_delay);
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200385}
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +0200386
Max9dabfa22017-05-16 16:10:45 +0200387static inline int delta_fn(int fn, int to)
388{
389 return (fn + GSM_MAX_FN * 3 / 2 - to) % GSM_MAX_FN - GSM_MAX_FN/2;
390}
391
Jacob Erlbeckaf75ce82015-08-26 13:22:28 +0200392void BTS::set_current_block_frame_number(int fn, unsigned max_delay)
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200393{
394 int delay = 0;
395 const int late_block_delay_thresh = 13;
396 const int fn_update_ok_min_delay = -500;
397 const int fn_update_ok_max_delay = 0;
398
399 /* frame numbers in the received blocks are assumed to be strongly
400 * monotonic. */
401 if (m_cur_blk_fn >= 0) {
Max9dabfa22017-05-16 16:10:45 +0200402 int delta = delta_fn(fn, m_cur_blk_fn);
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200403 if (delta <= 0)
404 return;
405 }
406
407 /* Check block delay vs. the current frame number */
408 if (current_frame_number() != 0)
Max9dabfa22017-05-16 16:10:45 +0200409 delay = delta_fn(fn, current_frame_number());
Jacob Erlbeckbe4a08b2015-08-25 15:19:31 +0200410 if (delay <= -late_block_delay_thresh) {
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200411 LOGP(DRLCMAC, LOGL_NOTICE,
412 "Late RLC block, FN delta: %d FN: %d curFN: %d\n",
413 delay, fn, current_frame_number());
Pau Espin Pedrol2338e532020-05-12 20:54:35 +0200414 do_rate_ctr_inc(CTR_RLC_LATE_BLOCK);
Jacob Erlbeckbe4a08b2015-08-25 15:19:31 +0200415 }
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200416
417 m_cur_blk_fn = fn;
418 if (delay < fn_update_ok_min_delay || delay > fn_update_ok_max_delay ||
419 current_frame_number() == 0)
420 m_cur_fn = fn;
421
Jacob Erlbeckaf75ce82015-08-26 13:22:28 +0200422 m_pollController.expireTimedout(fn, max_delay);
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200423}
424
Neels Hofmeyr59fc0bd2020-08-21 16:21:23 +0200425int BTS::add_paging(uint8_t chan_needed, const struct osmo_mobile_identity *mi)
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200426{
427 uint8_t l, trx, ts, any_tbf = 0;
428 struct gprs_rlcmac_tbf *tbf;
Jacob Erlbecked2dbf62015-12-28 19:15:40 +0100429 LListHead<gprs_rlcmac_tbf> *pos;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200430 uint8_t slot_mask[8];
431 int8_t first_ts; /* must be signed */
432
Jacob Erlbecked2dbf62015-12-28 19:15:40 +0100433 LListHead<gprs_rlcmac_tbf> *tbfs_lists[] = {
434 &m_ul_tbfs,
435 &m_dl_tbfs,
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200436 NULL
437 };
438
Neels Hofmeyr00520512020-08-21 15:44:58 +0200439 if (log_check_level(DRLCMAC, LOGL_INFO)) {
Neels Hofmeyr00520512020-08-21 15:44:58 +0200440 char str[64];
Neels Hofmeyr59fc0bd2020-08-21 16:21:23 +0200441 osmo_mobile_identity_to_str_buf(str, sizeof(str), mi);
Neels Hofmeyr00520512020-08-21 15:44:58 +0200442 LOGP(DRLCMAC, LOGL_INFO, "Add RR paging: chan-needed=%d MI=%s\n", chan_needed, str);
443 }
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200444
445 /* collect slots to page
446 * Mark slots for every TBF, but only mark one of it.
447 * Mark only the first slot found.
448 * Don't mark, if TBF uses a different slot that is already marked. */
449 memset(slot_mask, 0, sizeof(slot_mask));
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200450 for (l = 0; tbfs_lists[l]; l++) {
Jacob Erlbecked2dbf62015-12-28 19:15:40 +0100451 llist_for_each(pos, tbfs_lists[l]) {
452 tbf = pos->entry();
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200453 first_ts = -1;
454 for (ts = 0; ts < 8; ts++) {
455 if (tbf->pdch[ts]) {
456 /* remember the first slot found */
457 if (first_ts < 0)
458 first_ts = ts;
459 /* break, if we already marked a slot */
Holger Hans Peter Freytherec80f822013-10-27 13:44:37 +0100460 if ((slot_mask[tbf->trx->trx_no] & (1 << ts)))
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200461 break;
462 }
463 }
464 /* mark first slot found, if none is marked already */
465 if (ts == 8 && first_ts >= 0) {
Maxc21f0072017-12-15 17:36:45 +0100466 LOGPTBF(tbf, LOGL_DEBUG, "uses "
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200467 "TRX=%d TS=%d, so we mark\n",
Holger Hans Peter Freytherbd449f52013-10-27 16:39:36 +0100468 tbf->trx->trx_no, first_ts);
Holger Hans Peter Freytherec80f822013-10-27 13:44:37 +0100469 slot_mask[tbf->trx->trx_no] |= (1 << first_ts);
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200470 } else
Maxc21f0072017-12-15 17:36:45 +0100471 LOGPTBF(tbf, LOGL_DEBUG, "uses "
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200472 "already marked TRX=%d TS=%d\n",
Holger Hans Peter Freytherbd449f52013-10-27 16:39:36 +0100473 tbf->trx->trx_no, ts);
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200474 }
475 }
476
477 /* Now we have a list of marked slots. Every TBF uses at least one
478 * of these slots. */
479
480 /* schedule paging to all marked slots */
481 for (trx = 0; trx < 8; trx++) {
482 if (slot_mask[trx] == 0)
483 continue;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200484 for (ts = 0; ts < 8; ts++) {
485 if ((slot_mask[trx] & (1 << ts))) {
486 /* schedule */
Neels Hofmeyr59fc0bd2020-08-21 16:21:23 +0200487 if (!m_bts.trx[trx].pdch[ts].add_paging(chan_needed, mi))
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200488 return -ENOMEM;
Max4382e4e2018-01-30 12:00:08 +0100489
490 LOGP(DRLCMAC, LOGL_INFO, "Paging on PACCH of TRX=%d TS=%d\n", trx, ts);
Holger Hans Peter Freyther94464852013-10-19 18:33:52 +0200491 any_tbf = 1;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200492 }
493 }
494 }
495
496 if (!any_tbf)
497 LOGP(DRLCMAC, LOGL_INFO, "No paging, because no TBF\n");
498
499 return 0;
500}
501
Vadim Yanitskiy07b64872020-06-11 00:26:15 +0700502void BTS::send_gsmtap_rach(enum pcu_gsmtap_category categ, uint8_t channel,
503 const struct rach_ind_params *rip)
504{
505 struct pcu_l1_meas meas;
Vadim Yanitskiy81b610e2020-06-11 01:04:44 +0700506 uint8_t ra_buf[2];
507
508 /* 3GPP TS 44.004 defines 11 bit RA as follows: xxxx xxxx .... .yyy
509 * On the PCUIF, we get 16 bit machne dependent number (LE/BE)
510 * Over GSMTAP we send the following: xxxx xxxx yyy. ....
511 * This simplifies parsing in Wireshark using its CSN.1 codec. */
512 if (rip->is_11bit) {
513 ra_buf[0] = (uint8_t) ((rip->ra >> 3) & 0xff);
514 ra_buf[1] = (uint8_t) ((rip->ra << 5) & 0xff);
515 } else {
516 ra_buf[0] = (uint8_t) (rip->ra & 0xff);
517 }
518
Vadim Yanitskiy07b64872020-06-11 00:26:15 +0700519 send_gsmtap_meas(categ, true, rip->trx_nr, rip->ts_nr, channel,
Vadim Yanitskiy81b610e2020-06-11 01:04:44 +0700520 rfn_to_fn(rip->rfn), ra_buf,
Vadim Yanitskiy07b64872020-06-11 00:26:15 +0700521 rip->is_11bit ? 2 : 1, &meas);
522}
523
Harald Welte717cdf52017-07-21 21:56:23 +0200524void BTS::send_gsmtap(enum pcu_gsmtap_category categ, bool uplink, uint8_t trx_no,
525 uint8_t ts_no, uint8_t channel, uint32_t fn,
526 const uint8_t *data, unsigned int len)
527{
Pau Espin Pedrol0b0391f2020-05-19 17:23:23 +0200528 struct pcu_l1_meas meas;
529 send_gsmtap_meas(categ, uplink, trx_no, ts_no, channel, fn, data, len, &meas);
530}
531
532void BTS::send_gsmtap_meas(enum pcu_gsmtap_category categ, bool uplink, uint8_t trx_no,
533 uint8_t ts_no, uint8_t channel, uint32_t fn,
534 const uint8_t *data, unsigned int len, struct pcu_l1_meas *meas)
535{
Harald Welte717cdf52017-07-21 21:56:23 +0200536 uint16_t arfcn;
537
538 /* check if category is activated at all */
539 if (!(m_bts.gsmtap_categ_mask & (1 << categ)))
540 return;
541
542 arfcn = m_bts.trx[trx_no].arfcn;
543 if (uplink)
544 arfcn |= GSMTAP_ARFCN_F_UPLINK;
545
Pau Espin Pedrol0b0391f2020-05-19 17:23:23 +0200546 /* GSMTAP needs the SNR here, but we only have C/I (meas->link_qual).
547 Those are not the same, but there is no known way to convert them,
548 let's pass C/I instead of nothing */
549 gsmtap_send(m_bts.gsmtap, arfcn, ts_no, channel, 0, fn,
550 meas->rssi, meas->link_qual, data, len);
Harald Welte717cdf52017-07-21 21:56:23 +0200551}
552
Max341dccd2017-08-14 15:49:59 +0200553static inline bool tbf_check(gprs_rlcmac_tbf *tbf, uint32_t fn, uint8_t trx_no, uint8_t ts)
554{
Maxcac6b662018-01-24 11:00:17 +0100555 if (tbf->state_is_not(GPRS_RLCMAC_RELEASING) && tbf->poll_scheduled()
Max341dccd2017-08-14 15:49:59 +0200556 && tbf->poll_fn == fn && tbf->trx->trx_no == trx_no && tbf->poll_ts == ts)
557 return true;
558
559 return false;
560}
561
Daniel Willmannfe6e2e42014-07-10 17:44:06 +0200562gprs_rlcmac_dl_tbf *BTS::dl_tbf_by_poll_fn(uint32_t fn, uint8_t trx, uint8_t ts)
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200563{
Jacob Erlbecked2dbf62015-12-28 19:15:40 +0100564 LListHead<gprs_rlcmac_tbf> *pos;
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200565
566 /* only one TBF can poll on specific TS/FN, because scheduler can only
567 * schedule one downlink control block (with polling) at a FN per TS */
Jacob Erlbecked2dbf62015-12-28 19:15:40 +0100568 llist_for_each(pos, &m_dl_tbfs) {
Max341dccd2017-08-14 15:49:59 +0200569 if (tbf_check(pos->entry(), fn, trx, ts))
570 return as_dl_tbf(pos->entry());
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200571 }
Daniel Willmannfebf1a02014-07-02 17:58:16 +0200572 return NULL;
573}
Max341dccd2017-08-14 15:49:59 +0200574
Daniel Willmannfe6e2e42014-07-10 17:44:06 +0200575gprs_rlcmac_ul_tbf *BTS::ul_tbf_by_poll_fn(uint32_t fn, uint8_t trx, uint8_t ts)
Daniel Willmannfebf1a02014-07-02 17:58:16 +0200576{
Jacob Erlbecked2dbf62015-12-28 19:15:40 +0100577 LListHead<gprs_rlcmac_tbf> *pos;
Daniel Willmannfebf1a02014-07-02 17:58:16 +0200578
579 /* only one TBF can poll on specific TS/FN, because scheduler can only
580 * schedule one downlink control block (with polling) at a FN per TS */
Jacob Erlbecked2dbf62015-12-28 19:15:40 +0100581 llist_for_each(pos, &m_ul_tbfs) {
Max341dccd2017-08-14 15:49:59 +0200582 if (tbf_check(pos->entry(), fn, trx, ts))
583 return as_ul_tbf(pos->entry());
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200584 }
585 return NULL;
586}
587
Daniel Willmann54044b02014-07-02 17:58:15 +0200588/* lookup downlink TBF Entity (by TFI) */
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200589gprs_rlcmac_dl_tbf *BTS::dl_tbf_by_tfi(uint8_t tfi, uint8_t trx, uint8_t ts)
Daniel Willmann54044b02014-07-02 17:58:15 +0200590{
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200591 if (trx >= 8 || ts >= 8)
592 return NULL;
593
594 return m_bts.trx[trx].pdch[ts].dl_tbf_by_tfi(tfi);
Daniel Willmann54044b02014-07-02 17:58:15 +0200595}
596
597/* lookup uplink TBF Entity (by TFI) */
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200598gprs_rlcmac_ul_tbf *BTS::ul_tbf_by_tfi(uint8_t tfi, uint8_t trx, uint8_t ts)
Daniel Willmann54044b02014-07-02 17:58:15 +0200599{
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200600 if (trx >= 8 || ts >= 8)
Holger Hans Peter Freytherf63cabd2013-10-26 19:10:43 +0200601 return NULL;
602
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200603 return m_bts.trx[trx].pdch[ts].ul_tbf_by_tfi(tfi);
Holger Hans Peter Freytherf63cabd2013-10-26 19:10:43 +0200604}
605
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100606static unsigned int trx_count_free_tfi(const struct gprs_rlcmac_trx *trx, enum gprs_rlcmac_tbf_direction dir, uint8_t *first_free_tfi)
607{
608 const struct gprs_rlcmac_pdch *pdch;
609 uint8_t ts;
610 unsigned int i;
611 unsigned int free_tfi_cnt = 0;
612 bool has_pdch = false;
613 uint32_t mask = NO_FREE_TFI;
614
615 for (ts = 0; ts < ARRAY_SIZE(trx->pdch); ts++) {
616 pdch = &trx->pdch[ts];
617 if (!pdch->is_enabled())
618 continue;
619 has_pdch = true;
620 mask &= ~pdch->assigned_tfi(dir);
621 }
622
623 if (!has_pdch || !mask) {
624 *first_free_tfi = (uint8_t)-1;
625 return 0;
626 }
627
628 /* Count free tfis and return */
629 for (i = 0; i < sizeof(mask) * 8 ; i++) {
630 if (mask & 1) {
631 if (free_tfi_cnt == 0)
632 *first_free_tfi = i;
633 free_tfi_cnt++;
634 }
635 mask >>= 1;
636 }
637 return free_tfi_cnt;
638}
639
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200640/*
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100641 * Search for free TFI and return TFI, TRX. This method returns the first TFI
642 * that is currently not used in any PDCH of a the TRX with least TFIs currently
643 * assigned. Negative values indicate errors.
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200644 */
Maxa76a7d02018-01-26 11:09:16 +0100645int BTS::tfi_find_free(enum gprs_rlcmac_tbf_direction dir, uint8_t *_trx, int8_t use_trx) const
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200646{
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100647 uint8_t trx_from, trx_to, trx;
648 uint8_t best_trx_nr = 0xff;
649 unsigned int best_cnt = 0;
650 uint8_t best_first_tfi = 0;
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200651
652 if (use_trx >= 0 && use_trx < 8)
653 trx_from = trx_to = use_trx;
654 else {
655 trx_from = 0;
656 trx_to = 7;
657 }
658
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200659 /* find a TFI that is unused on all PDCH */
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200660 for (trx = trx_from; trx <= trx_to; trx++) {
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100661 uint8_t tmp_first_tfi;
662 unsigned int tmp_cnt;
663 tmp_cnt = trx_count_free_tfi(&m_bts.trx[trx], dir, &tmp_first_tfi);
664 if (tmp_cnt > best_cnt) {
665 best_cnt = tmp_cnt;
666 best_first_tfi = tmp_first_tfi;
667 best_trx_nr = trx;
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200668 }
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200669 }
670
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100671 if (best_trx_nr == 0xff || best_cnt == 0) {
Max69d585e2018-01-26 12:36:43 +0100672 LOGP(DRLCMAC, LOGL_NOTICE, "No TFI available (suggested TRX: %d).\n", use_trx);
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200673 return -EBUSY;
674 }
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200675
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100676 OSMO_ASSERT(best_first_tfi < 32);
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200677
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100678 LOGP(DRLCMAC, LOGL_DEBUG, "Found first unallocated TRX=%d TFI=%d\n",
679 best_trx_nr, best_first_tfi);
680 *_trx = best_trx_nr;
681 return best_first_tfi;
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200682}
683
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200684int BTS::rcv_imm_ass_cnf(const uint8_t *data, uint32_t fn)
685{
Jacob Erlbeck767193e2015-05-20 12:06:46 +0200686 struct gprs_rlcmac_dl_tbf *dl_tbf = NULL;
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200687 uint8_t plen;
688 uint32_t tlli;
Jacob Erlbeck767193e2015-05-20 12:06:46 +0200689 GprsMs *ms;
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200690
691 /* move to IA Rest Octets */
692 plen = data[0] >> 2;
693 data += 1 + plen;
694
695 if ((*data & 0xf0) != 0xd0) {
696 LOGP(DRLCMAC, LOGL_ERROR, "Got IMM.ASS confirm, but rest "
697 "octets do not start with bit sequence 'HH01' "
698 "(Packet Downlink Assignment)\n");
699 return -EINVAL;
700 }
701
702 /* get TLLI from downlink assignment */
Eric Wildab8b01e2019-07-23 17:16:06 +0200703 tlli = (uint32_t)((*data++) & 0xf) << 28;
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200704 tlli |= (*data++) << 20;
705 tlli |= (*data++) << 12;
706 tlli |= (*data++) << 4;
707 tlli |= (*data++) >> 4;
708
Jacob Erlbeck767193e2015-05-20 12:06:46 +0200709 ms = ms_by_tlli(tlli);
710 if (ms)
711 dl_tbf = ms->dl_tbf();
Daniel Willmann1dac2eb2014-08-07 12:37:34 +0200712 if (!dl_tbf) {
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200713 LOGP(DRLCMAC, LOGL_ERROR, "Got IMM.ASS confirm, but TLLI=%08x "
714 "does not exit\n", tlli);
715 return -EINVAL;
716 }
717
718 LOGP(DRLCMAC, LOGL_DEBUG, "Got IMM.ASS confirm for TLLI=%08x\n", tlli);
719
Daniel Willmann7e994e32014-08-07 15:49:21 +0200720 if (dl_tbf->m_wait_confirm)
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +0200721 T_START(dl_tbf, T0, -2002, "assignment (AGCH)", true);
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200722
723 return 0;
724}
725
Philipp Maier1275a3f2017-02-21 19:35:23 +0100726/* Determine the full frame number from a relative frame number */
Max5dd8d1b2017-03-08 12:06:42 +0100727uint32_t BTS::rfn_to_fn(int32_t rfn)
Philipp Maier1275a3f2017-02-21 19:35:23 +0100728{
Max5dd8d1b2017-03-08 12:06:42 +0100729 int32_t m_cur_rfn;
730 int32_t fn;
731 int32_t fn_rounded;
732
733 /* double-check that relative FN is not negative and fits into int32_t */
734 OSMO_ASSERT(rfn < GSM_MAX_FN);
735 OSMO_ASSERT(rfn >= 0);
Philipp Maier1275a3f2017-02-21 19:35:23 +0100736
737 /* Note: If a BTS is sending in a rach request it will be fully aware
738 * of the frame number. If the PCU is used in a BSC-co-located setup.
739 * The BSC will forward the incoming RACH request. The RACH request
740 * only contains the relative frame number (Fn % 42432) in its request
741 * reference. This PCU implementation has to fit both scenarios, so
742 * we need to assume that Fn is a relative frame number. */
743
744 /* Ensure that all following calculations are performed with the
745 * relative frame number */
Max5dd8d1b2017-03-08 12:06:42 +0100746 if (rfn >= RFN_MODULUS)
747 return rfn;
Philipp Maier1275a3f2017-02-21 19:35:23 +0100748
749 /* Compute an internal relative frame number from the full internal
750 frame number */
751 m_cur_rfn = m_cur_fn % RFN_MODULUS;
752
753 /* Compute a "rounded" version of the internal frame number, which
754 * exactly fits in the RFN_MODULUS raster */
755 fn_rounded = m_cur_fn - m_cur_rfn;
756
757 /* If the delta between the internal and the external relative frame
758 * number exceeds a certain limit, we need to assume that the incoming
759 * rach request belongs to a the previous rfn period. To correct this,
760 * we roll back the rounded frame number by one RFN_MODULUS */
761 if (abs(rfn - m_cur_rfn) > RFN_THRESHOLD) {
762 LOGP(DRLCMAC, LOGL_DEBUG,
Thorsten Alteholz8bb79042018-10-06 10:42:58 +0200763 "Race condition between rfn (%u) and m_cur_fn (%u) detected: rfn belongs to the previous modulus %u cycle, wrapping...\n",
Philipp Maier1275a3f2017-02-21 19:35:23 +0100764 rfn, m_cur_fn, RFN_MODULUS);
765 if (fn_rounded < RFN_MODULUS) {
766 LOGP(DRLCMAC, LOGL_DEBUG,
767 "Cornercase detected: wrapping crosses %u border\n",
768 GSM_MAX_FN);
769 fn_rounded = GSM_MAX_FN - (RFN_MODULUS - fn_rounded);
770 }
771 else
772 fn_rounded -= RFN_MODULUS;
773 }
774
775 /* The real frame number is the sum of the rounded frame number and the
776 * relative framenumber computed via RACH */
777 fn = fn_rounded + rfn;
778
779 return fn;
780}
781
Pau Espin Pedrol9ee90d22020-05-08 14:20:32 +0200782/* 3GPP TS 44.060:
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700783 * Table 11.2.5.2: PACKET CHANNEL REQUEST
784 * Table 11.2.5a.2: EGPRS PACKET CHANNEL REQUEST
785 * Both GPRS and EGPRS use same MultislotClass coding, but since PRACH is
Pau Espin Pedrol9ee90d22020-05-08 14:20:32 +0200786 * deprecated, no PACKET CHANNEL REQUEST exists, which means for GPRS we will
787 * receive CCCH RACH which doesn't contain any mslot class. Hence in the end we
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700788 * can only receive EGPRS mslot class through 11-bit EGPRS PACKET CHANNEL REQUEST. */
789static int parse_egprs_pkt_ch_req(uint16_t ra11, struct chan_req_params *chan_req)
Max58818582018-01-05 15:04:50 +0100790{
Vadim Yanitskiyb90d34b2020-05-21 20:20:34 +0700791 EGPRS_PacketChannelRequest_t req;
792 int rc;
793
794 rc = decode_egprs_pkt_ch_req(ra11, &req);
795 if (rc) {
796 LOGP(DRLCMAC, LOGL_NOTICE, "Failed to decode "
797 "EGPRS Packet Channel Request: rc=%d\n", rc);
798 return rc;
799 }
800
801 LOGP(DRLCMAC, LOGL_INFO, "Rx EGPRS Packet Channel Request: %s\n",
802 get_value_string(egprs_pkt_ch_req_type_names, req.Type));
803
804 switch (req.Type) {
805 case EGPRS_PKT_CHAN_REQ_ONE_PHASE:
806 chan_req->egprs_mslot_class = req.Content.MultislotClass + 1;
807 chan_req->priority = req.Content.Priority + 1;
808 break;
809 case EGPRS_PKT_CHAN_REQ_SHORT:
810 chan_req->priority = req.Content.Priority + 1;
811 if (req.Content.NumberOfBlocks == 0)
812 chan_req->single_block = true;
813 break;
814 case EGPRS_PKT_CHAN_REQ_ONE_PHASE_RED_LATENCY:
815 chan_req->priority = req.Content.Priority + 1;
816 break;
817 /* Two phase access => single block is needed */
818 case EGPRS_PKT_CHAN_REQ_TWO_PHASE:
819 case EGPRS_PKT_CHAN_REQ_TWO_PHASE_IPA:
820 chan_req->priority = req.Content.Priority + 1;
821 chan_req->single_block = true;
822 break;
823 /* Signalling => single block is needed */
824 case EGPRS_PKT_CHAN_REQ_SIGNALLING:
825 case EGPRS_PKT_CHAN_REQ_SIGNALLING_IPA:
826 chan_req->single_block = true;
827 break;
828
829 /* Neither unacknowledged RLC mode, nor emergency calls are supported */
830 case EGPRS_PKT_CHAN_REQ_ONE_PHASE_UNACK:
831 case EGPRS_PKT_CHAN_REQ_EMERGENCY_CALL:
832 case EGPRS_PKT_CHAN_REQ_DEDICATED_CHANNEL:
833 LOGP(DRLCMAC, LOGL_NOTICE, "%s is not supported, rejecting\n",
834 get_value_string(egprs_pkt_ch_req_type_names, req.Type));
835 return -ENOTSUP;
836
837 default:
838 LOGP(DRLCMAC, LOGL_ERROR, "Unknown EGPRS Packet Channel Request "
839 "type=0x%02x, probably a bug in CSN.1 codec\n", req.Type);
840 return -EINVAL;
841 }
Max58818582018-01-05 15:04:50 +0100842
843 return 0;
844}
845
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700846/* NOTE: chan_req needs to be zero-initialized by the caller */
847static int parse_rach_ind(const struct rach_ind_params *rip,
848 struct chan_req_params *chan_req)
Max58818582018-01-05 15:04:50 +0100849{
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700850 int rc;
Max58818582018-01-05 15:04:50 +0100851
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700852 switch (rip->burst_type) {
Max137fd592018-01-05 15:53:08 +0100853 case GSM_L1_BURST_TYPE_NONE:
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700854 LOGP(DRLCMAC, LOGL_ERROR, "RACH.ind contains no burst type, assuming TS0\n");
855 /* fall-through */
856 case GSM_L1_BURST_TYPE_ACCESS_0:
857 if (rip->is_11bit) { /* 11 bit Access Burst with TS0 => Packet Channel Request */
858 LOGP(DRLCMAC, LOGL_ERROR, "11 bit Packet Channel Request "
859 "is not supported (PBCCH is deprecated)\n");
860 return -ENOTSUP;
861 }
862
863 /* 3GPP TS 44.018, table 9.1.8.1: 8 bit CHANNEL REQUEST.
864 * Mask 01110xxx indicates single block packet access. */
865 chan_req->single_block = ((rip->ra & 0xf8) == 0x70);
866 break;
867 case GSM_L1_BURST_TYPE_ACCESS_1:
868 case GSM_L1_BURST_TYPE_ACCESS_2:
869 if (!rip->is_11bit) { /* TS1/TS2 => EGPRS Packet Channel Request (always 11 bit) */
870 LOGP(DRLCMAC, LOGL_ERROR, "11 bit Packet Channel Request "
871 "is not supported (PBCCH is deprecated)\n");
872 return -ENOTSUP;
873 }
874
875 rc = parse_egprs_pkt_ch_req(rip->ra, chan_req);
876 if (rc)
877 return rc;
Max137fd592018-01-05 15:53:08 +0100878 break;
879 default:
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700880 LOGP(DRLCMAC, LOGL_ERROR, "RACH.ind contains unknown burst type 0x%02x "
881 "(%u bit)\n", rip->burst_type, rip->is_11bit ? 11 : 8);
882 return -EINVAL;
Max58818582018-01-05 15:04:50 +0100883 }
884
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700885 return 0;
Max58818582018-01-05 15:04:50 +0100886}
887
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700888int BTS::rcv_rach(const struct rach_ind_params *rip)
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200889{
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700890 struct chan_req_params chan_req = { 0 };
Jacob Erlbeck1f332942015-05-04 08:21:17 +0200891 struct gprs_rlcmac_ul_tbf *tbf = NULL;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700892 uint8_t trx_no, ts_no;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200893 uint32_t sb_fn = 0;
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100894 uint8_t usf = 7;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700895 uint8_t tsc = 0;
896 int plen, rc;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200897
Pau Espin Pedrol2338e532020-05-12 20:54:35 +0200898 do_rate_ctr_inc(CTR_RACH_REQUESTS);
Holger Hans Peter Freytherc1ae2262013-10-27 10:50:35 +0100899
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700900 if (rip->is_11bit)
Pau Espin Pedrol2338e532020-05-12 20:54:35 +0200901 do_rate_ctr_inc(CTR_11BIT_RACH_REQUESTS);
Mrinal Mishraf86307e2016-11-10 18:16:30 +0530902
Philipp Maier1275a3f2017-02-21 19:35:23 +0100903 /* Determine full frame number */
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700904 uint32_t Fn = rfn_to_fn(rip->rfn);
905 uint8_t ta = qta2ta(rip->qta);
Philippd935d882016-11-07 13:07:36 +0100906
Vadim Yanitskiy07b64872020-06-11 00:26:15 +0700907 send_gsmtap_rach(PCU_GSMTAP_C_UL_RACH, GSMTAP_CHANNEL_RACH, rip);
Pau Espin Pedrol1ec211f2019-09-30 18:33:14 +0200908
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700909 LOGP(DRLCMAC, LOGL_DEBUG, "MS requests Uplink resource on CCCH/RACH: "
910 "ra=0x%02x (%d bit) Fn=%u qta=%d\n", rip->ra,
911 rip->is_11bit ? 11 : 8, Fn, rip->qta);
bhargava628dcfb2016-09-14 20:30:31 +0530912
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700913 /* Parse [EGPRS Packet] Channel Request from RACH.ind */
914 rc = parse_rach_ind(rip, &chan_req);
915 if (rc) /* Send RR Immediate Assignment Reject */
916 goto send_imm_ass_rej;
bhargava628dcfb2016-09-14 20:30:31 +0530917
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700918 if (chan_req.single_block)
919 LOGP(DRLCMAC, LOGL_DEBUG, "MS requests single block allocation\n");
920 else if (m_bts.force_two_phase) {
921 LOGP(DRLCMAC, LOGL_DEBUG, "MS requests single block allocation, "
922 "but we force two phase access\n");
923 chan_req.single_block = true;
924 }
925
Vadim Yanitskiyb90d34b2020-05-21 20:20:34 +0700926 /* TODO: handle Radio Priority (see 3GPP TS 44.060, table 11.2.5a.5) */
927 if (chan_req.priority > 0)
928 LOGP(DRLCMAC, LOGL_NOTICE, "EGPRS Packet Channel Request indicates "
929 "Radio Priority %u, however we ignore it\n", chan_req.priority);
930
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700931 /* Should we allocate a single block or an Uplink TBF? */
932 if (chan_req.single_block) {
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100933 rc = sba()->alloc(&trx_no, &ts_no, &sb_fn, ta);
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530934 if (rc < 0) {
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530935 LOGP(DRLCMAC, LOGL_NOTICE, "No PDCH resource for "
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700936 "single block allocation: rc=%d\n", rc);
937 /* Send RR Immediate Assignment Reject */
938 goto send_imm_ass_rej;
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530939 }
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700940
941 tsc = m_bts.trx[trx_no].pdch[ts_no].tsc;
942 LOGP(DRLCMAC, LOGL_DEBUG, "Allocated a single block at "
943 "SBFn=%u TRX=%u TS=%u\n", sb_fn, trx_no, ts_no);
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200944 } else {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700945 GprsMs *ms = ms_alloc(0, chan_req.egprs_mslot_class);
Pau Espin Pedrol17402a52020-05-08 17:44:33 +0200946 tbf = tbf_alloc_ul_tbf(&m_bts, ms, -1, true);
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200947 if (!tbf) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700948 LOGP(DRLCMAC, LOGL_NOTICE, "No PDCH resource for Uplink TBF\n");
949 /* Send RR Immediate Assignment Reject */
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530950 rc = -EBUSY;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700951 goto send_imm_ass_rej;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200952 }
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700953
954 /* FIXME: Copy and paste with other routines.. */
955 tbf->set_ta(ta);
956 TBF_SET_STATE(tbf, GPRS_RLCMAC_FLOW);
957 TBF_ASS_TYPE_SET(tbf, GPRS_RLCMAC_FLAG_CCCH);
958 T_START(tbf, T3169, 3169, "RACH (new UL-TBF)", true);
959 trx_no = tbf->trx->trx_no;
960 ts_no = tbf->first_ts;
961 usf = tbf->m_usf[ts_no];
962 tsc = tbf->tsc();
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200963 }
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100964
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700965send_imm_ass_rej:
966 /* Allocate a bit-vector for RR Immediate Assignment [Reject] */
967 struct bitvec *bv = bitvec_alloc(22, tall_pcu_ctx); /* without plen */
Vadim Yanitskiyeb1e0fa2020-07-18 20:33:08 +0700968 bitvec_unhex(bv, DUMMY_VEC); /* standard '2B'O padding */
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100969
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700970 if (rc != 0) {
971 LOGP(DRLCMAC, LOGL_DEBUG, "Tx Immediate Assignment Reject on AGCH\n");
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530972 plen = Encoding::write_immediate_assignment_reject(
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700973 bv, rip->ra, Fn, rip->burst_type);
Pau Espin Pedrol2338e532020-05-12 20:54:35 +0200974 do_rate_ctr_inc(CTR_IMMEDIATE_ASSIGN_REJ);
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700975 } else {
976 LOGP(DRLCMAC, LOGL_DEBUG, "Tx Immediate Assignment on AGCH: "
977 "TRX=%u (ARFCN %u) TS=%u TA=%u TSC=%u TFI=%d USF=%d\n",
978 trx_no, m_bts.trx[trx_no].arfcn & ~ARFCN_FLAG_MASK,
979 ts_no, ta, tsc, tbf ? tbf->tfi() : -1, usf);
980 plen = Encoding::write_immediate_assignment(
Vadim Yanitskiy11567762020-07-18 23:34:17 +0700981 &m_bts.trx[trx_no].pdch[ts_no], tbf, bv,
982 false, rip->ra, Fn, ta, usf, false, sb_fn,
983 m_bts.alpha, m_bts.gamma, -1,
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700984 rip->burst_type);
Pau Espin Pedrol2338e532020-05-12 20:54:35 +0200985 do_rate_ctr_inc(CTR_IMMEDIATE_ASSIGN_UL_TBF);
Mrinal Mishraf86307e2016-11-10 18:16:30 +0530986 }
Jacob Erlbeck2647a332016-02-01 16:13:38 +0100987
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700988 if (plen >= 0)
989 pcu_l1if_tx_agch(bv, plen);
990 else
991 rc = plen;
992
993 bitvec_free(bv);
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200994
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530995 return rc;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200996}
997
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700998/* PTCCH/U sub-slot / frame-number mapping (see 3GPP TS 45.002, table 6) */
999static uint32_t ptcch_slot_map[PTCCH_TAI_NUM] = {
1000 12, 38, 64, 90,
1001 116, 142, 168, 194,
1002 220, 246, 272, 298,
1003 324, 350, 376, 402,
1004};
1005
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +07001006int BTS::rcv_ptcch_rach(const struct rach_ind_params *rip)
Vadim Yanitskiyffebd242019-10-05 23:45:31 +07001007{
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +07001008 uint32_t fn416 = rfn_to_fn(rip->rfn) % 416;
Vadim Yanitskiyffebd242019-10-05 23:45:31 +07001009 struct gprs_rlcmac_bts *bts = bts_data();
1010 struct gprs_rlcmac_pdch *pdch;
Vadim Yanitskiyffebd242019-10-05 23:45:31 +07001011 uint8_t ss;
1012
Vadim Yanitskiy07b64872020-06-11 00:26:15 +07001013 send_gsmtap_rach(PCU_GSMTAP_C_UL_PTCCH, GSMTAP_CHANNEL_PTCCH, rip);
1014
Vadim Yanitskiyffebd242019-10-05 23:45:31 +07001015 /* Prevent buffer overflow */
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +07001016 if (rip->trx_nr >= ARRAY_SIZE(bts->trx) || rip->ts_nr >= 8) {
1017 LOGP(DRLCMAC, LOGL_ERROR, "(TRX=%u TS=%u RFN=%u) Rx malformed "
1018 "RACH.ind (PTCCH/U)\n", rip->trx_nr, rip->ts_nr, rip->rfn);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +07001019 return -EINVAL;
1020 }
1021
1022 /* Make sure PDCH time-slot is enabled */
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +07001023 pdch = &bts->trx[rip->trx_nr].pdch[rip->ts_nr];
Vadim Yanitskiyffebd242019-10-05 23:45:31 +07001024 if (!pdch->m_is_enabled) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +07001025 LOGP(DRLCMAC, LOGL_NOTICE, "(TRX=%u TS=%u RFN=%u) Rx RACH.ind (PTCCH/U) "
1026 "for inactive PDCH\n", rip->trx_nr, rip->ts_nr, rip->rfn);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +07001027 return -EAGAIN;
1028 }
1029
1030 /* Convert TDMA frame-number to PTCCH/U sub-slot number */
1031 for (ss = 0; ss < PTCCH_TAI_NUM; ss++)
1032 if (ptcch_slot_map[ss] == fn416)
1033 break;
1034 if (ss == PTCCH_TAI_NUM) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +07001035 LOGP(DRLCMAC, LOGL_ERROR, "(TRX=%u TS=%u RFN=%u) Failed to map "
1036 "PTCCH/U sub-slot\n", rip->trx_nr, rip->ts_nr, rip->rfn);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +07001037 return -ENODEV;
1038 }
1039
1040 /* Apply the new Timing Advance value */
1041 LOGP(DRLCMAC, LOGL_INFO, "Continuous Timing Advance update "
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +07001042 "for TAI %u, new TA is %u\n", ss, qta2ta(rip->qta));
1043 pdch->update_ta(ss, qta2ta(rip->qta));
Vadim Yanitskiyffebd242019-10-05 23:45:31 +07001044
1045 return 0;
1046}
1047
Pau Espin Pedrold7c32652019-12-23 12:41:34 +01001048void BTS::snd_dl_ass(gprs_rlcmac_tbf *tbf, bool poll, uint16_t pgroup)
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +02001049{
Vadim Yanitskiy11567762020-07-18 23:34:17 +07001050 uint8_t trx_no = tbf->trx->trx_no;
1051 uint8_t ts_no = tbf->first_ts;
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +02001052 int plen;
1053
Maxc21f0072017-12-15 17:36:45 +01001054 LOGPTBF(tbf, LOGL_INFO, "TX: START Immediate Assignment Downlink (PCH)\n");
Alexander Couzensccde5c92017-02-04 03:10:08 +01001055 bitvec *immediate_assignment = bitvec_alloc(22, tall_pcu_ctx); /* without plen */
Vadim Yanitskiyeb1e0fa2020-07-18 20:33:08 +07001056 bitvec_unhex(immediate_assignment, DUMMY_VEC); /* standard '2B'O padding */
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +02001057 /* use request reference that has maximum distance to current time,
1058 * so the assignment will not conflict with possible RACH requests. */
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +01001059 LOGP(DRLCMAC, LOGL_DEBUG, " - TRX=%d (%d) TS=%d TA=%d pollFN=%d\n",
Vadim Yanitskiy11567762020-07-18 23:34:17 +07001060 trx_no, tbf->trx->arfcn, ts_no, tbf->ta(), poll ? tbf->poll_fn : -1);
1061 plen = Encoding::write_immediate_assignment(&m_bts.trx[trx_no].pdch[ts_no],
1062 tbf, immediate_assignment, true, 125,
1063 (tbf->pdch[ts_no]->last_rts_fn + 21216) % GSM_MAX_FN,
1064 tbf->ta(), 7, poll, tbf->poll_fn,
1065 m_bts.alpha, m_bts.gamma, -1,
Maxfc8afc22019-02-18 18:52:38 +01001066 GSM_L1_BURST_TYPE_ACCESS_0);
Mrinal Mishraf86307e2016-11-10 18:16:30 +05301067 if (plen >= 0) {
Pau Espin Pedrol2338e532020-05-12 20:54:35 +02001068 do_rate_ctr_inc(CTR_IMMEDIATE_ASSIGN_DL_TBF);
Pau Espin Pedrold7c32652019-12-23 12:41:34 +01001069 pcu_l1if_tx_pch(immediate_assignment, plen, pgroup);
Mrinal Mishraf86307e2016-11-10 18:16:30 +05301070 }
1071
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +02001072 bitvec_free(immediate_assignment);
1073}
1074
Holger Hans Peter Freytherd11290b2013-10-26 17:32:04 +02001075
Jacob Erlbeck86b6f052015-11-27 15:17:34 +01001076GprsMs *BTS::ms_alloc(uint8_t ms_class, uint8_t egprs_ms_class)
Jacob Erlbeckcb1b4942015-06-19 10:59:58 +02001077{
1078 GprsMs *ms;
1079 ms = ms_store().create_ms();
1080
Pau Espin Pedrol63700ea2019-09-09 13:19:06 +02001081 ms->set_timeout(osmo_tdef_get(m_bts.T_defs_pcu, -2030, OSMO_TDEF_S, -1));
Jacob Erlbeckcb1b4942015-06-19 10:59:58 +02001082 ms->set_ms_class(ms_class);
Jacob Erlbeck86b6f052015-11-27 15:17:34 +01001083 ms->set_egprs_ms_class(egprs_ms_class);
Jacob Erlbeckcb1b4942015-06-19 10:59:58 +02001084
1085 return ms;
1086}
1087
Minh-Quang Nguyen1bcfa9a2017-11-01 14:41:37 -04001088/* update TA based on TA provided by PH-DATA-IND */
1089void update_tbf_ta(struct gprs_rlcmac_ul_tbf *tbf, int8_t ta_delta)
1090{
1091 int16_t ta_adj;
1092 uint8_t ta_target;
1093
1094 if (ta_delta) {
1095 /* adjust TA based on TA provided by PH-DATA-IND */
1096 ta_adj = tbf->ta() + ta_delta;
1097
1098 /* limit target TA in range 0..63 bits */
1099 ta_target = ta_limit(ta_adj);
1100
1101 LOGP(DL1IF, LOGL_INFO, "PH-DATA-IND is updating TLLI=0x%08x: TA %u -> %u on "
1102 "TRX = %d, TS = %d, FN = %d\n",
1103 tbf->tlli(), tbf->ta(), ta_target,
1104 tbf->trx->trx_no , tbf->poll_ts, tbf->poll_fn);
1105 tbf->set_ta(ta_target);
1106 }
1107}
1108
1109/* set TA based on TA provided by PH-RA-IND */
1110void set_tbf_ta(struct gprs_rlcmac_ul_tbf *tbf, uint8_t ta)
1111{
1112 uint8_t ta_target;
1113
1114 if (tbf->ta() != ta) {
1115 /* limit target TA in range 0..63 bits */
1116 ta_target = ta_limit(ta);
1117
1118 LOGP(DL1IF, LOGL_INFO, "PH-RA-IND is updating TLLI=0x%08x: TA %u -> %u on "
1119 "TRX = %d, TS = %d, FN = %d\n",
1120 tbf->tlli(), tbf->ta(), ta_target,
1121 tbf->trx->trx_no , tbf->poll_ts, tbf->poll_fn);
1122 tbf->set_ta(ta_target);
1123 }
1124}
1125
1126void bts_update_tbf_ta(const char *p, uint32_t fn, uint8_t trx_no, uint8_t ts, int8_t ta, bool is_rach)
Maxd71e8b32016-09-19 16:17:06 +02001127{
1128 struct gprs_rlcmac_ul_tbf *tbf =
1129 bts_main_data()->bts->ul_tbf_by_poll_fn(fn, trx_no, ts);
1130 if (!tbf)
1131 LOGP(DL1IF, LOGL_DEBUG, "[%s] update TA = %u ignored due to "
1132 "unknown UL TBF on TRX = %d, TS = %d, FN = %d\n",
1133 p, ta, trx_no, ts, fn);
Minh-Quang Nguyen1bcfa9a2017-11-01 14:41:37 -04001134 else {
1135 /* we need to distinguish TA information provided by L1
1136 * from PH-DATA-IND and PHY-RA-IND so that we can properly
1137 * update TA for given TBF
1138 */
1139 if (is_rach)
1140 set_tbf_ta(tbf, (uint8_t)ta);
1141 else
1142 update_tbf_ta(tbf, ta);
1143
Maxd71e8b32016-09-19 16:17:06 +02001144 }
1145}
1146
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001147void gprs_rlcmac_trx::reserve_slots(enum gprs_rlcmac_tbf_direction dir,
1148 uint8_t slots)
1149{
1150 unsigned i;
1151 for (i = 0; i < ARRAY_SIZE(pdch); i += 1)
1152 if (slots & (1 << i))
1153 pdch[i].reserve(dir);
1154}
1155
1156void gprs_rlcmac_trx::unreserve_slots(enum gprs_rlcmac_tbf_direction dir,
1157 uint8_t slots)
1158{
1159 unsigned i;
1160 for (i = 0; i < ARRAY_SIZE(pdch); i += 1)
1161 if (slots & (1 << i))
1162 pdch[i].unreserve(dir);
1163}