blob: 294739c54f1df9fa7cc2ae36d9afae806cb7f3bd [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>
Pau Espin Pedrol2182e622021-01-14 16:48:38 +010034#include <gprs_ms_storage.h>
35#include <sba.h>
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +020036
37extern "C" {
38 #include <osmocom/core/talloc.h>
Holger Hans Peter Freyther24e98d02013-10-19 18:15:44 +020039 #include <osmocom/core/msgb.h>
Holger Hans Peter Freyther8df447d2015-11-07 21:04:40 +010040 #include <osmocom/core/stats.h>
Max9bbe1602016-07-18 12:50:18 +020041 #include <osmocom/gsm/protocol/gsm_04_08.h>
Philipp Maier1275a3f2017-02-21 19:35:23 +010042 #include <osmocom/gsm/gsm_utils.h>
Pau Espin Pedrolfbfab292019-12-23 13:19:25 +010043 #include <osmocom/gsm/gsm48.h>
Harald Welte717cdf52017-07-21 21:56:23 +020044 #include <osmocom/core/gsmtap_util.h>
Harald Welte3e51d3e2017-10-29 10:57:27 +010045 #include <osmocom/core/application.h>
Max1187a772018-01-26 13:31:42 +010046 #include <osmocom/core/bitvec.h>
47 #include <osmocom/core/gsmtap.h>
48 #include <osmocom/core/logging.h>
49 #include <osmocom/core/utils.h>
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +020050}
Holger Hans Peter Freytherb78adcd2013-10-17 20:12:37 +020051
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +020052#include <errno.h>
Holger Hans Peter Freytherb6acfda2013-10-17 19:41:11 +020053#include <string.h>
54
Philipp Maier1275a3f2017-02-21 19:35:23 +010055#define RFN_MODULUS 42432
56#define RFN_THRESHOLD RFN_MODULUS / 2
57
Holger Hans Peter Freyther24e98d02013-10-19 18:15:44 +020058extern void *tall_pcu_ctx;
59
Harald Welte3e51d3e2017-10-29 10:57:27 +010060extern "C" {
61 /* e must make sure to initialize logging before the BTS static
62 * constructors are executed below, as those call libosmocore APIs that
63 * require logging already to be initialized. */
Harald Welte0a369e52020-09-30 19:57:02 +020064 __attribute__((constructor (101))) static void early_init(void)
Harald Welte3e51d3e2017-10-29 10:57:27 +010065 {
Neels Hofmeyr42f2d612018-04-01 16:54:40 +020066 if (!tall_pcu_ctx) {
67 tall_pcu_ctx = talloc_named_const(NULL, 1, "Osmo-PCU context");
68 osmo_init_logging2(tall_pcu_ctx, &gprs_log_info);
69 }
Harald Welte3e51d3e2017-10-29 10:57:27 +010070 }
71}
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};
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +020081
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +010082/**
83 * For gcc-4.4 compat do not use extended initializer list but keep the
84 * order from the enum here. Once we support GCC4.7 and up we can change
85 * the code below.
86 */
87static const struct rate_ctr_desc bts_ctr_description[] = {
Maxa5eb67d2017-11-21 20:24:54 +010088 { "tbf:dl:alloc", "TBF DL Allocated "},
89 { "tbf:dl:freed", "TBF DL Freed "},
90 { "tbf:dl:aborted", "TBF DL Aborted "},
91 { "tbf:ul:alloc", "TBF UL Allocated "},
92 { "tbf:ul:freed", "TBF UL Freed "},
93 { "tbf:ul:aborted", "TBF UL Aborted "},
94 { "tbf:reused", "TBF Reused "},
95 { "tbf:alloc:algo-a", "TBF Alloc Algo A "},
96 { "tbf:alloc:algo-b", "TBF Alloc Algo B "},
Maxa5eb67d2017-11-21 20:24:54 +010097 { "rlc:sent", "RLC Sent "},
98 { "rlc:resent", "RLC Resent "},
99 { "rlc:restarted", "RLC Restarted "},
100 { "rlc:stalled", "RLC Stalled "},
101 { "rlc:nacked", "RLC Nacked "},
102 { "rlc:final_block_resent", "RLC Final Blk resent "},
103 { "rlc:ass:timedout", "RLC Assign Timeout "},
104 { "rlc:ass:failed", "RLC Assign Failed "},
105 { "rlc:ack:timedout", "RLC Ack Timeout "},
106 { "rlc:ack:failed", "RLC Ack Failed "},
107 { "rlc:rel:timedout", "RLC Release Timeout "},
108 { "rlc:late-block", "RLC Late Block "},
109 { "rlc:sent-dummy", "RLC Sent Dummy "},
110 { "rlc:sent-control", "RLC Sent Control "},
111 { "rlc:dl_bytes", "RLC DL Bytes "},
112 { "rlc:dl_payload_bytes", "RLC DL Payload Bytes "},
113 { "rlc:ul_bytes", "RLC UL Bytes "},
114 { "rlc:ul_payload_bytes", "RLC UL Payload Bytes "},
115 { "decode:errors", "Decode Errors "},
116 { "sba:allocated", "SBA Allocated "},
117 { "sba:freed", "SBA Freed "},
118 { "sba:timedout", "SBA Timeout "},
119 { "llc:timeout", "Timedout Frames "},
120 { "llc:dropped", "Dropped Frames "},
121 { "llc:scheduled", "Scheduled Frames "},
122 { "llc:dl_bytes", "RLC encapsulated PDUs"},
123 { "llc:ul_bytes", "full PDUs received "},
124 { "rach:requests", "RACH requests "},
125 { "11bit_rach:requests", "11BIT_RACH requests "},
126 { "spb:uplink_first_segment", "First seg of UL SPB "},
127 { "spb:uplink_second_segment", "Second seg of UL SPB "},
128 { "spb:downlink_first_segment", "First seg of DL SPB "},
129 { "spb:downlink_second_segment","Second seg of DL SPB "},
130 { "immediate:assignment_UL", "Immediate Assign UL "},
131 { "immediate:assignment_rej", "Immediate Assign Rej "},
132 { "immediate:assignment_DL", "Immediate Assign DL "},
133 { "channel:request_description","Channel Request Desc "},
134 { "pkt:ul_assignment", "Packet UL Assignment "},
135 { "pkt:access_reject", "Packet Access Reject "},
136 { "pkt:dl_assignment", "Packet DL Assignment "},
137 { "ul:control", "UL control Block "},
138 { "ul:assignment_poll_timeout", "UL Assign Timeout "},
139 { "ul:assignment_failed", "UL Assign Failed "},
140 { "dl:assignment_timeout", "DL Assign Timeout "},
141 { "dl:assignment_failed", "DL Assign Failed "},
142 { "pkt:ul_ack_nack_timeout", "PUAN Poll Timeout "},
143 { "pkt:ul_ack_nack_failed", "PUAN poll Failed "},
144 { "pkt:dl_ack_nack_timeout", "PDAN poll Timeout "},
145 { "pkt:dl_ack_nack_failed", "PDAN poll Failed "},
146 { "gprs:downlink_cs1", "CS1 downlink "},
147 { "gprs:downlink_cs2", "CS2 downlink "},
148 { "gprs:downlink_cs3", "CS3 downlink "},
149 { "gprs:downlink_cs4", "CS4 downlink "},
150 { "egprs:downlink_mcs1", "MCS1 downlink "},
151 { "egprs:downlink_mcs2", "MCS2 downlink "},
152 { "egprs:downlink_mcs3", "MCS3 downlink "},
153 { "egprs:downlink_mcs4", "MCS4 downlink "},
154 { "egprs:downlink_mcs5", "MCS5 downlink "},
155 { "egprs:downlink_mcs6", "MCS6 downlink "},
156 { "egprs:downlink_mcs7", "MCS7 downlink "},
157 { "egprs:downlink_mcs8", "MCS8 downlink "},
158 { "egprs:downlink_mcs9", "MCS9 downlink "},
159 { "gprs:uplink_cs1", "CS1 Uplink "},
160 { "gprs:uplink_cs2", "CS2 Uplink "},
161 { "gprs:uplink_cs3", "CS3 Uplink "},
162 { "gprs:uplink_cs4", "CS4 Uplink "},
163 { "egprs:uplink_mcs1", "MCS1 Uplink "},
164 { "egprs:uplink_mcs2", "MCS2 Uplink "},
165 { "egprs:uplink_mcs3", "MCS3 Uplink "},
166 { "egprs:uplink_mcs4", "MCS4 Uplink "},
167 { "egprs:uplink_mcs5", "MCS5 Uplink "},
168 { "egprs:uplink_mcs6", "MCS6 Uplink "},
169 { "egprs:uplink_mcs7", "MCS7 Uplink "},
170 { "egprs:uplink_mcs8", "MCS8 Uplink "},
171 { "egprs:uplink_mcs9", "MCS9 Uplink "},
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100172};
173
174static const struct rate_ctr_group_desc bts_ctrg_desc = {
175 "bts",
176 "BTS Statistics",
Holger Hans Peter Freytherb8a54262015-11-07 21:00:00 +0100177 OSMO_STATS_CLASS_GLOBAL,
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100178 ARRAY_SIZE(bts_ctr_description),
179 bts_ctr_description,
180};
181
Jacob Erlbeckf5898a02015-11-27 19:05:13 +0100182static const struct osmo_stat_item_desc bts_stat_item_description[] = {
183 { "ms.present", "MS Present ",
184 OSMO_STAT_ITEM_NO_UNIT, 4, 0},
185};
186
187static const struct osmo_stat_item_group_desc bts_statg_desc = {
188 "bts",
189 "BTS Statistics",
190 OSMO_STATS_CLASS_GLOBAL,
191 ARRAY_SIZE(bts_stat_item_description),
192 bts_stat_item_description,
193};
194
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100195static void bts_init(struct gprs_rlcmac_bts *bts, struct gprs_pcu *pcu)
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100196{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100197 bts->pcu = pcu;
198
199 bts->pollController = new PollController(*bts);
200 bts->sba = new SBAController(*bts);
201 bts->ms_store = new GprsMsStorage(bts);
202
203 bts->cur_fn = 0;
204 bts->cur_blk_fn = -1;
205 bts->max_cs_dl = MAX_GPRS_CS;
206 bts->max_cs_ul = MAX_GPRS_CS;
207 bts->max_mcs_dl = MAX_EDGE_MCS;
208 bts->max_mcs_ul = MAX_EDGE_MCS;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100209 bts->initial_cs_dl = bts->initial_cs_ul = 1;
210 bts->initial_mcs_dl = bts->initial_mcs_ul = 1;
Pau Espin Pedrold87722d2020-10-30 17:14:26 +0100211 bts->cs_mask = 1 << 0; /* CS-1 always enabled by default */
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100212 bts->n3101 = 10;
213 bts->n3103 = 4;
214 bts->n3105 = 8;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100215 bts->si13_is_set = false;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100216
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100217 bts->app_info = NULL;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100218 bts->T_defs_bts = T_defs_bts;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100219 osmo_tdefs_reset(bts->T_defs_bts);
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100220
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100221 INIT_LLIST_HEAD(&bts->ul_tbfs);
222 INIT_LLIST_HEAD(&bts->dl_tbfs);
223
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100224 /* initialize back pointers */
225 for (size_t trx_no = 0; trx_no < ARRAY_SIZE(bts->trx); ++trx_no) {
226 struct gprs_rlcmac_trx *trx = &bts->trx[trx_no];
227 trx->trx_no = trx_no;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100228 trx->bts = bts;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100229
230 for (size_t ts_no = 0; ts_no < ARRAY_SIZE(trx->pdch); ++ts_no) {
231 struct gprs_rlcmac_pdch *pdch = &trx->pdch[ts_no];
232 pdch->init_ptcch_msg();
233 pdch->ts_no = ts_no;
234 pdch->trx = trx;
235 }
236 }
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100237
Maxea9968f2017-12-18 22:52:52 +0100238 /* The static allocator might have already registered the counter group.
Max1714aea2017-12-21 11:19:39 +0100239 If this happens and we still called explicitly (in tests/ for example)
Maxea9968f2017-12-18 22:52:52 +0100240 than just allocate the group with different index.
241 This shall be removed once weget rid of BTS singleton */
242 if (rate_ctr_get_group_by_name_idx(bts_ctrg_desc.group_name_prefix, 0))
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100243 bts->ratectrs = rate_ctr_group_alloc(tall_pcu_ctx, &bts_ctrg_desc, 1);
Maxea9968f2017-12-18 22:52:52 +0100244 else
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100245 bts->ratectrs = rate_ctr_group_alloc(tall_pcu_ctx, &bts_ctrg_desc, 0);
246 OSMO_ASSERT(bts->ratectrs);
Maxea9968f2017-12-18 22:52:52 +0100247
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100248 bts->statg = osmo_stat_item_group_alloc(tall_pcu_ctx, &bts_statg_desc, 0);
249 OSMO_ASSERT(bts->statg);
Holger Hans Peter Freytherb6acfda2013-10-17 19:41:11 +0200250}
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200251
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100252struct gprs_rlcmac_bts *bts_main_data()
253{
254 return the_pcu->bts;
255}
256
257struct rate_ctr_group *bts_main_data_stats()
258{
259 return bts_rate_counters(the_pcu->bts);
260}
261
262static void bts_cleanup(gprs_rlcmac_bts *bts)
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100263{
Jacob Erlbeckc362df22016-01-20 22:02:19 +0100264 /* this can cause counter updates and must not be left to the
265 * m_ms_store's destructor */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100266 bts->ms_store->cleanup();
267 delete bts->ms_store;
268 delete bts->sba;
269 delete bts->pollController;
Jacob Erlbeckc362df22016-01-20 22:02:19 +0100270
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100271 if (bts->ratectrs) {
272 rate_ctr_group_free(bts->ratectrs);
273 bts->ratectrs = NULL;
Maxd5ffeb52019-03-18 15:48:38 +0100274 }
275
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100276 if (bts->statg) {
277 osmo_stat_item_group_free(bts->statg);
278 bts->statg = NULL;
Maxd5ffeb52019-03-18 15:48:38 +0100279 }
Oliver Smithcfb63212019-09-05 17:13:33 +0200280
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100281 if (bts->app_info) {
282 msgb_free(bts->app_info);
283 bts->app_info = NULL;
Oliver Smithcfb63212019-09-05 17:13:33 +0200284 }
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100285}
286
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100287void bts_set_current_frame_number(struct gprs_rlcmac_bts *bts, int fn)
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200288{
Jacob Erlbeckac49d092015-08-27 13:18:24 +0200289 /* The UL frame numbers lag 3 behind the DL frames and the data
290 * indication is only sent after all 4 frames of the block have been
291 * received. Sometimes there is an idle frame between the end of one
292 * and start of another frame (every 3 blocks). So the timeout should
293 * definitely be there if we're more than 8 frames past poll_fn. Let's
Jacob Erlbecke77d49f2015-08-27 13:28:05 +0200294 * stay on the safe side and say 13 or more. An additional delay can
295 * happen due to the block processing time in the DSP, so the delay of
296 * decoded blocks relative to the timing clock can be much larger.
297 * Values up to 50 frames have been observed under load. */
298 const static int max_delay = 60;
Jacob Erlbeckac49d092015-08-27 13:18:24 +0200299
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100300 bts->cur_fn = fn;
301 bts->pollController->expireTimedout(bts->cur_fn, max_delay);
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200302}
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +0200303
Max9dabfa22017-05-16 16:10:45 +0200304static inline int delta_fn(int fn, int to)
305{
306 return (fn + GSM_MAX_FN * 3 / 2 - to) % GSM_MAX_FN - GSM_MAX_FN/2;
307}
308
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100309void bts_set_current_block_frame_number(struct gprs_rlcmac_bts *bts, int fn, unsigned max_delay)
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200310{
311 int delay = 0;
312 const int late_block_delay_thresh = 13;
313 const int fn_update_ok_min_delay = -500;
314 const int fn_update_ok_max_delay = 0;
315
316 /* frame numbers in the received blocks are assumed to be strongly
317 * monotonic. */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100318 if (bts->cur_blk_fn >= 0) {
319 int delta = delta_fn(fn, bts->cur_blk_fn);
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200320 if (delta <= 0)
321 return;
322 }
323
324 /* Check block delay vs. the current frame number */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100325 if (bts_current_frame_number(bts) != 0)
326 delay = delta_fn(fn, bts_current_frame_number(bts));
Jacob Erlbeckbe4a08b2015-08-25 15:19:31 +0200327 if (delay <= -late_block_delay_thresh) {
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200328 LOGP(DRLCMAC, LOGL_NOTICE,
329 "Late RLC block, FN delta: %d FN: %d curFN: %d\n",
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100330 delay, fn, bts_current_frame_number(bts));
331 bts_do_rate_ctr_inc(bts, CTR_RLC_LATE_BLOCK);
Jacob Erlbeckbe4a08b2015-08-25 15:19:31 +0200332 }
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200333
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100334 bts->cur_blk_fn = fn;
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200335 if (delay < fn_update_ok_min_delay || delay > fn_update_ok_max_delay ||
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100336 bts_current_frame_number(bts) == 0)
337 bts->cur_fn = fn;
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200338
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100339 bts->pollController->expireTimedout(fn, max_delay);
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200340}
341
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100342int bts_add_paging(struct gprs_rlcmac_bts *bts, uint8_t chan_needed, const struct osmo_mobile_identity *mi)
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200343{
344 uint8_t l, trx, ts, any_tbf = 0;
345 struct gprs_rlcmac_tbf *tbf;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100346 struct llist_item *pos;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200347 uint8_t slot_mask[8];
348 int8_t first_ts; /* must be signed */
349
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100350 struct llist_head *tbfs_lists[] = {
351 &bts->ul_tbfs,
352 &bts->dl_tbfs,
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200353 NULL
354 };
355
Neels Hofmeyr00520512020-08-21 15:44:58 +0200356 if (log_check_level(DRLCMAC, LOGL_INFO)) {
Neels Hofmeyr00520512020-08-21 15:44:58 +0200357 char str[64];
Neels Hofmeyr59fc0bd2020-08-21 16:21:23 +0200358 osmo_mobile_identity_to_str_buf(str, sizeof(str), mi);
Neels Hofmeyr00520512020-08-21 15:44:58 +0200359 LOGP(DRLCMAC, LOGL_INFO, "Add RR paging: chan-needed=%d MI=%s\n", chan_needed, str);
360 }
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200361
362 /* collect slots to page
363 * Mark slots for every TBF, but only mark one of it.
364 * Mark only the first slot found.
365 * Don't mark, if TBF uses a different slot that is already marked. */
366 memset(slot_mask, 0, sizeof(slot_mask));
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200367 for (l = 0; tbfs_lists[l]; l++) {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100368 llist_for_each_entry(pos, tbfs_lists[l], list) {
369 tbf = (struct gprs_rlcmac_tbf *)pos->entry;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200370 first_ts = -1;
371 for (ts = 0; ts < 8; ts++) {
372 if (tbf->pdch[ts]) {
373 /* remember the first slot found */
374 if (first_ts < 0)
375 first_ts = ts;
376 /* break, if we already marked a slot */
Holger Hans Peter Freytherec80f822013-10-27 13:44:37 +0100377 if ((slot_mask[tbf->trx->trx_no] & (1 << ts)))
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200378 break;
379 }
380 }
381 /* mark first slot found, if none is marked already */
382 if (ts == 8 && first_ts >= 0) {
Maxc21f0072017-12-15 17:36:45 +0100383 LOGPTBF(tbf, LOGL_DEBUG, "uses "
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200384 "TRX=%d TS=%d, so we mark\n",
Holger Hans Peter Freytherbd449f52013-10-27 16:39:36 +0100385 tbf->trx->trx_no, first_ts);
Holger Hans Peter Freytherec80f822013-10-27 13:44:37 +0100386 slot_mask[tbf->trx->trx_no] |= (1 << first_ts);
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200387 } else
Maxc21f0072017-12-15 17:36:45 +0100388 LOGPTBF(tbf, LOGL_DEBUG, "uses "
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200389 "already marked TRX=%d TS=%d\n",
Holger Hans Peter Freytherbd449f52013-10-27 16:39:36 +0100390 tbf->trx->trx_no, ts);
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200391 }
392 }
393
394 /* Now we have a list of marked slots. Every TBF uses at least one
395 * of these slots. */
396
397 /* schedule paging to all marked slots */
398 for (trx = 0; trx < 8; trx++) {
399 if (slot_mask[trx] == 0)
400 continue;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200401 for (ts = 0; ts < 8; ts++) {
402 if ((slot_mask[trx] & (1 << ts))) {
403 /* schedule */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100404 if (!bts->trx[trx].pdch[ts].add_paging(chan_needed, mi))
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200405 return -ENOMEM;
Max4382e4e2018-01-30 12:00:08 +0100406
407 LOGP(DRLCMAC, LOGL_INFO, "Paging on PACCH of TRX=%d TS=%d\n", trx, ts);
Holger Hans Peter Freyther94464852013-10-19 18:33:52 +0200408 any_tbf = 1;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200409 }
410 }
411 }
412
413 if (!any_tbf)
414 LOGP(DRLCMAC, LOGL_INFO, "No paging, because no TBF\n");
415
416 return 0;
417}
418
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100419void bts_send_gsmtap_rach(struct gprs_rlcmac_bts *bts,
420 enum pcu_gsmtap_category categ, uint8_t channel,
421 const struct rach_ind_params *rip)
Vadim Yanitskiy07b64872020-06-11 00:26:15 +0700422{
Vadim Yanitskiy55022ea2021-01-06 22:44:06 +0100423 struct pcu_l1_meas meas = { 0 };
Vadim Yanitskiy81b610e2020-06-11 01:04:44 +0700424 uint8_t ra_buf[2];
425
426 /* 3GPP TS 44.004 defines 11 bit RA as follows: xxxx xxxx .... .yyy
427 * On the PCUIF, we get 16 bit machne dependent number (LE/BE)
428 * Over GSMTAP we send the following: xxxx xxxx yyy. ....
429 * This simplifies parsing in Wireshark using its CSN.1 codec. */
430 if (rip->is_11bit) {
431 ra_buf[0] = (uint8_t) ((rip->ra >> 3) & 0xff);
432 ra_buf[1] = (uint8_t) ((rip->ra << 5) & 0xff);
433 } else {
434 ra_buf[0] = (uint8_t) (rip->ra & 0xff);
435 }
436
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100437 bts_send_gsmtap_meas(bts, categ, true, rip->trx_nr, rip->ts_nr, channel,
438 bts_rfn_to_fn(bts, rip->rfn), ra_buf,
Vadim Yanitskiy07b64872020-06-11 00:26:15 +0700439 rip->is_11bit ? 2 : 1, &meas);
440}
441
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100442void bts_send_gsmtap(struct gprs_rlcmac_bts *bts,
443 enum pcu_gsmtap_category categ, bool uplink, uint8_t trx_no,
444 uint8_t ts_no, uint8_t channel, uint32_t fn,
445 const uint8_t *data, unsigned int len)
Harald Welte717cdf52017-07-21 21:56:23 +0200446{
Vadim Yanitskiyeb70a402021-01-13 13:58:14 +0100447 struct pcu_l1_meas meas = { 0 };
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100448 bts_send_gsmtap_meas(bts, categ, uplink, trx_no, ts_no, channel, fn, data, len, &meas);
Pau Espin Pedrol0b0391f2020-05-19 17:23:23 +0200449}
450
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100451void bts_send_gsmtap_meas(struct gprs_rlcmac_bts *bts,
452 enum pcu_gsmtap_category categ, bool uplink, uint8_t trx_no,
453 uint8_t ts_no, uint8_t channel, uint32_t fn,
454 const uint8_t *data, unsigned int len, struct pcu_l1_meas *meas)
Pau Espin Pedrol0b0391f2020-05-19 17:23:23 +0200455{
Harald Welte717cdf52017-07-21 21:56:23 +0200456 uint16_t arfcn;
457
458 /* check if category is activated at all */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100459 if (!(bts->pcu->gsmtap_categ_mask & (1 << categ)))
Harald Welte717cdf52017-07-21 21:56:23 +0200460 return;
461
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100462 arfcn = bts->trx[trx_no].arfcn;
Harald Welte717cdf52017-07-21 21:56:23 +0200463 if (uplink)
464 arfcn |= GSMTAP_ARFCN_F_UPLINK;
465
Pau Espin Pedrol0b0391f2020-05-19 17:23:23 +0200466 /* GSMTAP needs the SNR here, but we only have C/I (meas->link_qual).
467 Those are not the same, but there is no known way to convert them,
468 let's pass C/I instead of nothing */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100469 gsmtap_send(bts->pcu->gsmtap, arfcn, ts_no, channel, 0, fn,
Pau Espin Pedrol0b0391f2020-05-19 17:23:23 +0200470 meas->rssi, meas->link_qual, data, len);
Harald Welte717cdf52017-07-21 21:56:23 +0200471}
472
Max341dccd2017-08-14 15:49:59 +0200473static inline bool tbf_check(gprs_rlcmac_tbf *tbf, uint32_t fn, uint8_t trx_no, uint8_t ts)
474{
Maxcac6b662018-01-24 11:00:17 +0100475 if (tbf->state_is_not(GPRS_RLCMAC_RELEASING) && tbf->poll_scheduled()
Max341dccd2017-08-14 15:49:59 +0200476 && tbf->poll_fn == fn && tbf->trx->trx_no == trx_no && tbf->poll_ts == ts)
477 return true;
478
479 return false;
480}
481
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100482struct gprs_rlcmac_dl_tbf *bts_dl_tbf_by_poll_fn(struct gprs_rlcmac_bts *bts, uint32_t fn, uint8_t trx, uint8_t ts)
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200483{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100484 struct llist_item *pos;
485 struct gprs_rlcmac_tbf *tbf;
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200486
487 /* only one TBF can poll on specific TS/FN, because scheduler can only
488 * schedule one downlink control block (with polling) at a FN per TS */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100489 llist_for_each_entry(pos, &bts->dl_tbfs, list) {
490 tbf = (struct gprs_rlcmac_tbf *)pos->entry;
491 if (tbf_check(tbf, fn, trx, ts))
492 return as_dl_tbf(tbf);
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200493 }
Daniel Willmannfebf1a02014-07-02 17:58:16 +0200494 return NULL;
495}
Max341dccd2017-08-14 15:49:59 +0200496
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100497struct gprs_rlcmac_ul_tbf *bts_ul_tbf_by_poll_fn(struct gprs_rlcmac_bts *bts, uint32_t fn, uint8_t trx, uint8_t ts)
Daniel Willmannfebf1a02014-07-02 17:58:16 +0200498{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100499 struct llist_item *pos;
500 struct gprs_rlcmac_tbf *tbf;
Daniel Willmannfebf1a02014-07-02 17:58:16 +0200501
502 /* only one TBF can poll on specific TS/FN, because scheduler can only
503 * schedule one downlink control block (with polling) at a FN per TS */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100504 llist_for_each_entry(pos, &bts->ul_tbfs, list) {
505 tbf = (struct gprs_rlcmac_tbf *)pos->entry;
506 if (tbf_check(tbf, fn, trx, ts))
507 return as_ul_tbf(tbf);
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200508 }
509 return NULL;
510}
511
Daniel Willmann54044b02014-07-02 17:58:15 +0200512/* lookup downlink TBF Entity (by TFI) */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100513struct gprs_rlcmac_dl_tbf *bts_dl_tbf_by_tfi(struct gprs_rlcmac_bts *bts, uint8_t tfi, uint8_t trx, uint8_t ts)
Daniel Willmann54044b02014-07-02 17:58:15 +0200514{
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200515 if (trx >= 8 || ts >= 8)
516 return NULL;
517
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100518 return bts->trx[trx].pdch[ts].dl_tbf_by_tfi(tfi);
Daniel Willmann54044b02014-07-02 17:58:15 +0200519}
520
521/* lookup uplink TBF Entity (by TFI) */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100522struct gprs_rlcmac_ul_tbf *bts_ul_tbf_by_tfi(struct gprs_rlcmac_bts *bts, uint8_t tfi, uint8_t trx, uint8_t ts)
Daniel Willmann54044b02014-07-02 17:58:15 +0200523{
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200524 if (trx >= 8 || ts >= 8)
Holger Hans Peter Freytherf63cabd2013-10-26 19:10:43 +0200525 return NULL;
526
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100527 return bts->trx[trx].pdch[ts].ul_tbf_by_tfi(tfi);
Holger Hans Peter Freytherf63cabd2013-10-26 19:10:43 +0200528}
529
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100530static unsigned int trx_count_free_tfi(const struct gprs_rlcmac_trx *trx, enum gprs_rlcmac_tbf_direction dir, uint8_t *first_free_tfi)
531{
532 const struct gprs_rlcmac_pdch *pdch;
533 uint8_t ts;
534 unsigned int i;
535 unsigned int free_tfi_cnt = 0;
536 bool has_pdch = false;
537 uint32_t mask = NO_FREE_TFI;
538
539 for (ts = 0; ts < ARRAY_SIZE(trx->pdch); ts++) {
540 pdch = &trx->pdch[ts];
541 if (!pdch->is_enabled())
542 continue;
543 has_pdch = true;
544 mask &= ~pdch->assigned_tfi(dir);
545 }
546
547 if (!has_pdch || !mask) {
548 *first_free_tfi = (uint8_t)-1;
549 return 0;
550 }
551
552 /* Count free tfis and return */
553 for (i = 0; i < sizeof(mask) * 8 ; i++) {
554 if (mask & 1) {
555 if (free_tfi_cnt == 0)
556 *first_free_tfi = i;
557 free_tfi_cnt++;
558 }
559 mask >>= 1;
560 }
561 return free_tfi_cnt;
562}
563
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200564/*
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100565 * Search for free TFI and return TFI, TRX. This method returns the first TFI
566 * that is currently not used in any PDCH of a the TRX with least TFIs currently
567 * assigned. Negative values indicate errors.
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200568 */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100569int bts_tfi_find_free(const struct gprs_rlcmac_bts *bts, enum gprs_rlcmac_tbf_direction dir,
570 uint8_t *_trx, int8_t use_trx)
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200571{
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100572 uint8_t trx_from, trx_to, trx;
573 uint8_t best_trx_nr = 0xff;
574 unsigned int best_cnt = 0;
575 uint8_t best_first_tfi = 0;
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200576
577 if (use_trx >= 0 && use_trx < 8)
578 trx_from = trx_to = use_trx;
579 else {
580 trx_from = 0;
581 trx_to = 7;
582 }
583
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200584 /* find a TFI that is unused on all PDCH */
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200585 for (trx = trx_from; trx <= trx_to; trx++) {
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100586 uint8_t tmp_first_tfi;
587 unsigned int tmp_cnt;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100588 tmp_cnt = trx_count_free_tfi(&bts->trx[trx], dir, &tmp_first_tfi);
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100589 if (tmp_cnt > best_cnt) {
590 best_cnt = tmp_cnt;
591 best_first_tfi = tmp_first_tfi;
592 best_trx_nr = trx;
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200593 }
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200594 }
595
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100596 if (best_trx_nr == 0xff || best_cnt == 0) {
Max69d585e2018-01-26 12:36:43 +0100597 LOGP(DRLCMAC, LOGL_NOTICE, "No TFI available (suggested TRX: %d).\n", use_trx);
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200598 return -EBUSY;
599 }
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200600
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100601 OSMO_ASSERT(best_first_tfi < 32);
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200602
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100603 LOGP(DRLCMAC, LOGL_DEBUG, "Found first unallocated TRX=%d TFI=%d\n",
604 best_trx_nr, best_first_tfi);
605 *_trx = best_trx_nr;
606 return best_first_tfi;
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200607}
608
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100609int bts_rcv_imm_ass_cnf(struct gprs_rlcmac_bts *bts, const uint8_t *data, uint32_t fn)
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200610{
Jacob Erlbeck767193e2015-05-20 12:06:46 +0200611 struct gprs_rlcmac_dl_tbf *dl_tbf = NULL;
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200612 uint8_t plen;
613 uint32_t tlli;
Jacob Erlbeck767193e2015-05-20 12:06:46 +0200614 GprsMs *ms;
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200615
616 /* move to IA Rest Octets */
617 plen = data[0] >> 2;
618 data += 1 + plen;
619
620 if ((*data & 0xf0) != 0xd0) {
621 LOGP(DRLCMAC, LOGL_ERROR, "Got IMM.ASS confirm, but rest "
622 "octets do not start with bit sequence 'HH01' "
623 "(Packet Downlink Assignment)\n");
624 return -EINVAL;
625 }
626
627 /* get TLLI from downlink assignment */
Eric Wildab8b01e2019-07-23 17:16:06 +0200628 tlli = (uint32_t)((*data++) & 0xf) << 28;
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200629 tlli |= (*data++) << 20;
630 tlli |= (*data++) << 12;
631 tlli |= (*data++) << 4;
632 tlli |= (*data++) >> 4;
633
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100634 ms = bts_ms_by_tlli(bts, tlli, GSM_RESERVED_TMSI);
Jacob Erlbeck767193e2015-05-20 12:06:46 +0200635 if (ms)
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +0100636 dl_tbf = ms_dl_tbf(ms);
Daniel Willmann1dac2eb2014-08-07 12:37:34 +0200637 if (!dl_tbf) {
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200638 LOGP(DRLCMAC, LOGL_ERROR, "Got IMM.ASS confirm, but TLLI=%08x "
639 "does not exit\n", tlli);
640 return -EINVAL;
641 }
642
643 LOGP(DRLCMAC, LOGL_DEBUG, "Got IMM.ASS confirm for TLLI=%08x\n", tlli);
644
Daniel Willmann7e994e32014-08-07 15:49:21 +0200645 if (dl_tbf->m_wait_confirm)
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +0200646 T_START(dl_tbf, T0, -2002, "assignment (AGCH)", true);
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200647
648 return 0;
649}
650
Philipp Maier1275a3f2017-02-21 19:35:23 +0100651/* Determine the full frame number from a relative frame number */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100652uint32_t bts_rfn_to_fn(const struct gprs_rlcmac_bts *bts, int32_t rfn)
Philipp Maier1275a3f2017-02-21 19:35:23 +0100653{
Max5dd8d1b2017-03-08 12:06:42 +0100654 int32_t m_cur_rfn;
655 int32_t fn;
656 int32_t fn_rounded;
657
658 /* double-check that relative FN is not negative and fits into int32_t */
659 OSMO_ASSERT(rfn < GSM_MAX_FN);
660 OSMO_ASSERT(rfn >= 0);
Philipp Maier1275a3f2017-02-21 19:35:23 +0100661
662 /* Note: If a BTS is sending in a rach request it will be fully aware
663 * of the frame number. If the PCU is used in a BSC-co-located setup.
664 * The BSC will forward the incoming RACH request. The RACH request
665 * only contains the relative frame number (Fn % 42432) in its request
666 * reference. This PCU implementation has to fit both scenarios, so
667 * we need to assume that Fn is a relative frame number. */
668
669 /* Ensure that all following calculations are performed with the
670 * relative frame number */
Max5dd8d1b2017-03-08 12:06:42 +0100671 if (rfn >= RFN_MODULUS)
672 return rfn;
Philipp Maier1275a3f2017-02-21 19:35:23 +0100673
674 /* Compute an internal relative frame number from the full internal
675 frame number */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100676 m_cur_rfn = bts->cur_fn % RFN_MODULUS;
Philipp Maier1275a3f2017-02-21 19:35:23 +0100677
678 /* Compute a "rounded" version of the internal frame number, which
679 * exactly fits in the RFN_MODULUS raster */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100680 fn_rounded = bts->cur_fn - m_cur_rfn;
Philipp Maier1275a3f2017-02-21 19:35:23 +0100681
682 /* If the delta between the internal and the external relative frame
683 * number exceeds a certain limit, we need to assume that the incoming
684 * rach request belongs to a the previous rfn period. To correct this,
685 * we roll back the rounded frame number by one RFN_MODULUS */
686 if (abs(rfn - m_cur_rfn) > RFN_THRESHOLD) {
687 LOGP(DRLCMAC, LOGL_DEBUG,
Thorsten Alteholz8bb79042018-10-06 10:42:58 +0200688 "Race condition between rfn (%u) and m_cur_fn (%u) detected: rfn belongs to the previous modulus %u cycle, wrapping...\n",
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100689 rfn, bts->cur_fn, RFN_MODULUS);
Philipp Maier1275a3f2017-02-21 19:35:23 +0100690 if (fn_rounded < RFN_MODULUS) {
691 LOGP(DRLCMAC, LOGL_DEBUG,
692 "Cornercase detected: wrapping crosses %u border\n",
693 GSM_MAX_FN);
694 fn_rounded = GSM_MAX_FN - (RFN_MODULUS - fn_rounded);
695 }
696 else
697 fn_rounded -= RFN_MODULUS;
698 }
699
700 /* The real frame number is the sum of the rounded frame number and the
701 * relative framenumber computed via RACH */
702 fn = fn_rounded + rfn;
703
704 return fn;
705}
706
Pau Espin Pedrol9ee90d22020-05-08 14:20:32 +0200707/* 3GPP TS 44.060:
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700708 * Table 11.2.5.2: PACKET CHANNEL REQUEST
709 * Table 11.2.5a.2: EGPRS PACKET CHANNEL REQUEST
710 * Both GPRS and EGPRS use same MultislotClass coding, but since PRACH is
Pau Espin Pedrol9ee90d22020-05-08 14:20:32 +0200711 * deprecated, no PACKET CHANNEL REQUEST exists, which means for GPRS we will
712 * receive CCCH RACH which doesn't contain any mslot class. Hence in the end we
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700713 * can only receive EGPRS mslot class through 11-bit EGPRS PACKET CHANNEL REQUEST. */
714static int parse_egprs_pkt_ch_req(uint16_t ra11, struct chan_req_params *chan_req)
Max58818582018-01-05 15:04:50 +0100715{
Vadim Yanitskiyb90d34b2020-05-21 20:20:34 +0700716 EGPRS_PacketChannelRequest_t req;
717 int rc;
718
719 rc = decode_egprs_pkt_ch_req(ra11, &req);
720 if (rc) {
721 LOGP(DRLCMAC, LOGL_NOTICE, "Failed to decode "
722 "EGPRS Packet Channel Request: rc=%d\n", rc);
723 return rc;
724 }
725
726 LOGP(DRLCMAC, LOGL_INFO, "Rx EGPRS Packet Channel Request: %s\n",
727 get_value_string(egprs_pkt_ch_req_type_names, req.Type));
728
729 switch (req.Type) {
730 case EGPRS_PKT_CHAN_REQ_ONE_PHASE:
731 chan_req->egprs_mslot_class = req.Content.MultislotClass + 1;
732 chan_req->priority = req.Content.Priority + 1;
733 break;
734 case EGPRS_PKT_CHAN_REQ_SHORT:
735 chan_req->priority = req.Content.Priority + 1;
736 if (req.Content.NumberOfBlocks == 0)
737 chan_req->single_block = true;
738 break;
739 case EGPRS_PKT_CHAN_REQ_ONE_PHASE_RED_LATENCY:
740 chan_req->priority = req.Content.Priority + 1;
741 break;
742 /* Two phase access => single block is needed */
743 case EGPRS_PKT_CHAN_REQ_TWO_PHASE:
744 case EGPRS_PKT_CHAN_REQ_TWO_PHASE_IPA:
745 chan_req->priority = req.Content.Priority + 1;
746 chan_req->single_block = true;
747 break;
748 /* Signalling => single block is needed */
749 case EGPRS_PKT_CHAN_REQ_SIGNALLING:
750 case EGPRS_PKT_CHAN_REQ_SIGNALLING_IPA:
751 chan_req->single_block = true;
752 break;
753
754 /* Neither unacknowledged RLC mode, nor emergency calls are supported */
755 case EGPRS_PKT_CHAN_REQ_ONE_PHASE_UNACK:
756 case EGPRS_PKT_CHAN_REQ_EMERGENCY_CALL:
757 case EGPRS_PKT_CHAN_REQ_DEDICATED_CHANNEL:
758 LOGP(DRLCMAC, LOGL_NOTICE, "%s is not supported, rejecting\n",
759 get_value_string(egprs_pkt_ch_req_type_names, req.Type));
760 return -ENOTSUP;
761
762 default:
763 LOGP(DRLCMAC, LOGL_ERROR, "Unknown EGPRS Packet Channel Request "
764 "type=0x%02x, probably a bug in CSN.1 codec\n", req.Type);
765 return -EINVAL;
766 }
Max58818582018-01-05 15:04:50 +0100767
768 return 0;
769}
770
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700771/* NOTE: chan_req needs to be zero-initialized by the caller */
772static int parse_rach_ind(const struct rach_ind_params *rip,
773 struct chan_req_params *chan_req)
Max58818582018-01-05 15:04:50 +0100774{
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700775 int rc;
Max58818582018-01-05 15:04:50 +0100776
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700777 switch (rip->burst_type) {
Max137fd592018-01-05 15:53:08 +0100778 case GSM_L1_BURST_TYPE_NONE:
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700779 LOGP(DRLCMAC, LOGL_ERROR, "RACH.ind contains no burst type, assuming TS0\n");
780 /* fall-through */
781 case GSM_L1_BURST_TYPE_ACCESS_0:
782 if (rip->is_11bit) { /* 11 bit Access Burst with TS0 => Packet Channel Request */
783 LOGP(DRLCMAC, LOGL_ERROR, "11 bit Packet Channel Request "
784 "is not supported (PBCCH is deprecated)\n");
785 return -ENOTSUP;
786 }
787
788 /* 3GPP TS 44.018, table 9.1.8.1: 8 bit CHANNEL REQUEST.
789 * Mask 01110xxx indicates single block packet access. */
790 chan_req->single_block = ((rip->ra & 0xf8) == 0x70);
791 break;
792 case GSM_L1_BURST_TYPE_ACCESS_1:
793 case GSM_L1_BURST_TYPE_ACCESS_2:
794 if (!rip->is_11bit) { /* TS1/TS2 => EGPRS Packet Channel Request (always 11 bit) */
795 LOGP(DRLCMAC, LOGL_ERROR, "11 bit Packet Channel Request "
796 "is not supported (PBCCH is deprecated)\n");
797 return -ENOTSUP;
798 }
799
800 rc = parse_egprs_pkt_ch_req(rip->ra, chan_req);
801 if (rc)
802 return rc;
Max137fd592018-01-05 15:53:08 +0100803 break;
804 default:
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700805 LOGP(DRLCMAC, LOGL_ERROR, "RACH.ind contains unknown burst type 0x%02x "
806 "(%u bit)\n", rip->burst_type, rip->is_11bit ? 11 : 8);
807 return -EINVAL;
Max58818582018-01-05 15:04:50 +0100808 }
809
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700810 return 0;
Max58818582018-01-05 15:04:50 +0100811}
812
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100813int bts_rcv_rach(struct gprs_rlcmac_bts *bts, const struct rach_ind_params *rip)
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200814{
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700815 struct chan_req_params chan_req = { 0 };
Jacob Erlbeck1f332942015-05-04 08:21:17 +0200816 struct gprs_rlcmac_ul_tbf *tbf = NULL;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700817 uint8_t trx_no, ts_no;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200818 uint32_t sb_fn = 0;
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100819 uint8_t usf = 7;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700820 uint8_t tsc = 0;
821 int plen, rc;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200822
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100823 bts_do_rate_ctr_inc(bts, CTR_RACH_REQUESTS);
Holger Hans Peter Freytherc1ae2262013-10-27 10:50:35 +0100824
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700825 if (rip->is_11bit)
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100826 bts_do_rate_ctr_inc(bts, CTR_11BIT_RACH_REQUESTS);
Mrinal Mishraf86307e2016-11-10 18:16:30 +0530827
Philipp Maier1275a3f2017-02-21 19:35:23 +0100828 /* Determine full frame number */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100829 uint32_t Fn = bts_rfn_to_fn(bts, rip->rfn);
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700830 uint8_t ta = qta2ta(rip->qta);
Philippd935d882016-11-07 13:07:36 +0100831
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100832 bts_send_gsmtap_rach(bts, PCU_GSMTAP_C_UL_RACH, GSMTAP_CHANNEL_RACH, rip);
Pau Espin Pedrol1ec211f2019-09-30 18:33:14 +0200833
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700834 LOGP(DRLCMAC, LOGL_DEBUG, "MS requests Uplink resource on CCCH/RACH: "
835 "ra=0x%02x (%d bit) Fn=%u qta=%d\n", rip->ra,
836 rip->is_11bit ? 11 : 8, Fn, rip->qta);
bhargava628dcfb2016-09-14 20:30:31 +0530837
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700838 /* Parse [EGPRS Packet] Channel Request from RACH.ind */
839 rc = parse_rach_ind(rip, &chan_req);
840 if (rc) /* Send RR Immediate Assignment Reject */
841 goto send_imm_ass_rej;
bhargava628dcfb2016-09-14 20:30:31 +0530842
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700843 if (chan_req.single_block)
844 LOGP(DRLCMAC, LOGL_DEBUG, "MS requests single block allocation\n");
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100845 else if (bts->pcu->vty.force_two_phase) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700846 LOGP(DRLCMAC, LOGL_DEBUG, "MS requests single block allocation, "
847 "but we force two phase access\n");
848 chan_req.single_block = true;
849 }
850
Vadim Yanitskiyb90d34b2020-05-21 20:20:34 +0700851 /* TODO: handle Radio Priority (see 3GPP TS 44.060, table 11.2.5a.5) */
852 if (chan_req.priority > 0)
853 LOGP(DRLCMAC, LOGL_NOTICE, "EGPRS Packet Channel Request indicates "
854 "Radio Priority %u, however we ignore it\n", chan_req.priority);
855
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700856 /* Should we allocate a single block or an Uplink TBF? */
857 if (chan_req.single_block) {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100858 rc = bts_sba(bts)->alloc(&trx_no, &ts_no, &sb_fn, ta);
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530859 if (rc < 0) {
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530860 LOGP(DRLCMAC, LOGL_NOTICE, "No PDCH resource for "
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700861 "single block allocation: rc=%d\n", rc);
862 /* Send RR Immediate Assignment Reject */
863 goto send_imm_ass_rej;
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530864 }
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700865
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100866 tsc = bts->trx[trx_no].pdch[ts_no].tsc;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700867 LOGP(DRLCMAC, LOGL_DEBUG, "Allocated a single block at "
868 "SBFn=%u TRX=%u TS=%u\n", sb_fn, trx_no, ts_no);
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200869 } else {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100870 GprsMs *ms = bts_alloc_ms(bts, 0, chan_req.egprs_mslot_class);
871 tbf = tbf_alloc_ul_tbf(bts, ms, -1, true);
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200872 if (!tbf) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700873 LOGP(DRLCMAC, LOGL_NOTICE, "No PDCH resource for Uplink TBF\n");
874 /* Send RR Immediate Assignment Reject */
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530875 rc = -EBUSY;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700876 goto send_imm_ass_rej;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200877 }
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700878
879 /* FIXME: Copy and paste with other routines.. */
880 tbf->set_ta(ta);
881 TBF_SET_STATE(tbf, GPRS_RLCMAC_FLOW);
882 TBF_ASS_TYPE_SET(tbf, GPRS_RLCMAC_FLAG_CCCH);
883 T_START(tbf, T3169, 3169, "RACH (new UL-TBF)", true);
884 trx_no = tbf->trx->trx_no;
885 ts_no = tbf->first_ts;
886 usf = tbf->m_usf[ts_no];
887 tsc = tbf->tsc();
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200888 }
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100889
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700890send_imm_ass_rej:
891 /* Allocate a bit-vector for RR Immediate Assignment [Reject] */
892 struct bitvec *bv = bitvec_alloc(22, tall_pcu_ctx); /* without plen */
Vadim Yanitskiyeb1e0fa2020-07-18 20:33:08 +0700893 bitvec_unhex(bv, DUMMY_VEC); /* standard '2B'O padding */
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100894
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700895 if (rc != 0) {
896 LOGP(DRLCMAC, LOGL_DEBUG, "Tx Immediate Assignment Reject on AGCH\n");
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530897 plen = Encoding::write_immediate_assignment_reject(
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700898 bv, rip->ra, Fn, rip->burst_type);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100899 bts_do_rate_ctr_inc(bts, CTR_IMMEDIATE_ASSIGN_REJ);
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700900 } else {
901 LOGP(DRLCMAC, LOGL_DEBUG, "Tx Immediate Assignment on AGCH: "
902 "TRX=%u (ARFCN %u) TS=%u TA=%u TSC=%u TFI=%d USF=%d\n",
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100903 trx_no, bts->trx[trx_no].arfcn & ~ARFCN_FLAG_MASK,
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700904 ts_no, ta, tsc, tbf ? tbf->tfi() : -1, usf);
905 plen = Encoding::write_immediate_assignment(
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100906 &bts->trx[trx_no].pdch[ts_no], tbf, bv,
Vadim Yanitskiy11567762020-07-18 23:34:17 +0700907 false, rip->ra, Fn, ta, usf, false, sb_fn,
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100908 bts->pcu->vty.alpha, bts->pcu->vty.gamma, -1,
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700909 rip->burst_type);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100910 bts_do_rate_ctr_inc(bts, CTR_IMMEDIATE_ASSIGN_UL_TBF);
Mrinal Mishraf86307e2016-11-10 18:16:30 +0530911 }
Jacob Erlbeck2647a332016-02-01 16:13:38 +0100912
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700913 if (plen >= 0)
914 pcu_l1if_tx_agch(bv, plen);
915 else
916 rc = plen;
917
918 bitvec_free(bv);
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200919
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530920 return rc;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200921}
922
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700923/* PTCCH/U sub-slot / frame-number mapping (see 3GPP TS 45.002, table 6) */
924static uint32_t ptcch_slot_map[PTCCH_TAI_NUM] = {
925 12, 38, 64, 90,
926 116, 142, 168, 194,
927 220, 246, 272, 298,
928 324, 350, 376, 402,
929};
930
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100931int bts_rcv_ptcch_rach(struct gprs_rlcmac_bts *bts, const struct rach_ind_params *rip)
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700932{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100933 uint32_t fn416 = bts_rfn_to_fn(bts, rip->rfn) % 416;
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700934 struct gprs_rlcmac_pdch *pdch;
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700935 uint8_t ss;
936
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100937 bts_send_gsmtap_rach(bts, PCU_GSMTAP_C_UL_PTCCH, GSMTAP_CHANNEL_PTCCH, rip);
Vadim Yanitskiy07b64872020-06-11 00:26:15 +0700938
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700939 /* Prevent buffer overflow */
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700940 if (rip->trx_nr >= ARRAY_SIZE(bts->trx) || rip->ts_nr >= 8) {
941 LOGP(DRLCMAC, LOGL_ERROR, "(TRX=%u TS=%u RFN=%u) Rx malformed "
942 "RACH.ind (PTCCH/U)\n", rip->trx_nr, rip->ts_nr, rip->rfn);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700943 return -EINVAL;
944 }
945
946 /* Make sure PDCH time-slot is enabled */
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700947 pdch = &bts->trx[rip->trx_nr].pdch[rip->ts_nr];
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700948 if (!pdch->m_is_enabled) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700949 LOGP(DRLCMAC, LOGL_NOTICE, "(TRX=%u TS=%u RFN=%u) Rx RACH.ind (PTCCH/U) "
950 "for inactive PDCH\n", rip->trx_nr, rip->ts_nr, rip->rfn);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700951 return -EAGAIN;
952 }
953
954 /* Convert TDMA frame-number to PTCCH/U sub-slot number */
955 for (ss = 0; ss < PTCCH_TAI_NUM; ss++)
956 if (ptcch_slot_map[ss] == fn416)
957 break;
958 if (ss == PTCCH_TAI_NUM) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700959 LOGP(DRLCMAC, LOGL_ERROR, "(TRX=%u TS=%u RFN=%u) Failed to map "
960 "PTCCH/U sub-slot\n", rip->trx_nr, rip->ts_nr, rip->rfn);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700961 return -ENODEV;
962 }
963
964 /* Apply the new Timing Advance value */
965 LOGP(DRLCMAC, LOGL_INFO, "Continuous Timing Advance update "
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700966 "for TAI %u, new TA is %u\n", ss, qta2ta(rip->qta));
967 pdch->update_ta(ss, qta2ta(rip->qta));
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700968
969 return 0;
970}
971
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100972void bts_snd_dl_ass(struct gprs_rlcmac_bts *bts, struct gprs_rlcmac_tbf *tbf, bool poll, uint16_t pgroup)
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +0200973{
Vadim Yanitskiy11567762020-07-18 23:34:17 +0700974 uint8_t trx_no = tbf->trx->trx_no;
975 uint8_t ts_no = tbf->first_ts;
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +0200976 int plen;
977
Maxc21f0072017-12-15 17:36:45 +0100978 LOGPTBF(tbf, LOGL_INFO, "TX: START Immediate Assignment Downlink (PCH)\n");
Alexander Couzensccde5c92017-02-04 03:10:08 +0100979 bitvec *immediate_assignment = bitvec_alloc(22, tall_pcu_ctx); /* without plen */
Vadim Yanitskiyeb1e0fa2020-07-18 20:33:08 +0700980 bitvec_unhex(immediate_assignment, DUMMY_VEC); /* standard '2B'O padding */
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +0200981 /* use request reference that has maximum distance to current time,
982 * so the assignment will not conflict with possible RACH requests. */
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100983 LOGP(DRLCMAC, LOGL_DEBUG, " - TRX=%d (%d) TS=%d TA=%d pollFN=%d\n",
Vadim Yanitskiy11567762020-07-18 23:34:17 +0700984 trx_no, tbf->trx->arfcn, ts_no, tbf->ta(), poll ? tbf->poll_fn : -1);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100985 plen = Encoding::write_immediate_assignment(&bts->trx[trx_no].pdch[ts_no],
Vadim Yanitskiy11567762020-07-18 23:34:17 +0700986 tbf, immediate_assignment, true, 125,
987 (tbf->pdch[ts_no]->last_rts_fn + 21216) % GSM_MAX_FN,
988 tbf->ta(), 7, poll, tbf->poll_fn,
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100989 bts->pcu->vty.alpha, bts->pcu->vty.gamma, -1,
Maxfc8afc22019-02-18 18:52:38 +0100990 GSM_L1_BURST_TYPE_ACCESS_0);
Mrinal Mishraf86307e2016-11-10 18:16:30 +0530991 if (plen >= 0) {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100992 bts_do_rate_ctr_inc(bts, CTR_IMMEDIATE_ASSIGN_DL_TBF);
Pau Espin Pedrold7c32652019-12-23 12:41:34 +0100993 pcu_l1if_tx_pch(immediate_assignment, plen, pgroup);
Mrinal Mishraf86307e2016-11-10 18:16:30 +0530994 }
995
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +0200996 bitvec_free(immediate_assignment);
997}
998
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +0100999/* return maximum DL CS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001000uint8_t bts_max_cs_dl(const struct gprs_rlcmac_bts* bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001001{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001002 return bts->max_cs_dl;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001003}
1004
1005/* return maximum UL CS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001006uint8_t bts_max_cs_ul(const struct gprs_rlcmac_bts* bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001007{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001008 return bts->max_cs_ul;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001009}
1010
1011/* return maximum DL MCS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001012uint8_t bts_max_mcs_dl(const struct gprs_rlcmac_bts* bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001013{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001014 return bts->max_mcs_dl;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001015}
1016
1017/* return maximum UL MCS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001018uint8_t bts_max_mcs_ul(const struct gprs_rlcmac_bts* bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001019{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001020 return bts->max_mcs_ul;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001021}
1022
1023/* Set maximum DL CS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001024void bts_set_max_cs_dl(struct gprs_rlcmac_bts* bts, uint8_t cs_dl)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001025{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001026 bts->max_cs_dl = cs_dl;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001027}
1028
1029/* Set maximum UL CS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001030void bts_set_max_cs_ul(struct gprs_rlcmac_bts* bts, uint8_t cs_ul)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001031{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001032 bts->max_cs_ul = cs_ul;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001033}
1034
1035/* Set maximum DL MCS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001036void bts_set_max_mcs_dl(struct gprs_rlcmac_bts* bts, uint8_t mcs_dl)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001037{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001038 bts->max_mcs_dl = mcs_dl;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001039}
1040
1041/* Set maximum UL MCS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001042void bts_set_max_mcs_ul(struct gprs_rlcmac_bts* bts, uint8_t mcs_ul)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001043{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001044 bts->max_mcs_ul = mcs_ul;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001045}
Holger Hans Peter Freytherd11290b2013-10-26 17:32:04 +02001046
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001047bool bts_cs_dl_is_supported(const struct gprs_rlcmac_bts* bts, CodingScheme cs)
Pau Espin Pedrol022f9e52020-11-16 18:49:39 +01001048{
1049 OSMO_ASSERT(mcs_is_valid(cs));
1050 uint8_t num = mcs_chan_code(cs);
1051 if (mcs_is_gprs(cs)) {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001052 return (bts_max_cs_dl(bts) >= num) && (bts->cs_mask & (1U << num));
Pau Espin Pedrol022f9e52020-11-16 18:49:39 +01001053 } else {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001054 return (bts_max_mcs_dl(bts) >= num) && (bts->mcs_mask & (1U << num));
Pau Espin Pedrol022f9e52020-11-16 18:49:39 +01001055 }
1056}
1057
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001058GprsMs *bts_alloc_ms(struct gprs_rlcmac_bts* bts, uint8_t ms_class, uint8_t egprs_ms_class)
Jacob Erlbeckcb1b4942015-06-19 10:59:58 +02001059{
1060 GprsMs *ms;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001061 ms = bts_ms_store(bts)->create_ms();
Jacob Erlbeckcb1b4942015-06-19 10:59:58 +02001062
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001063 ms_set_timeout(ms, osmo_tdef_get(bts->pcu->T_defs, -2030, OSMO_TDEF_S, -1));
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001064 ms_set_ms_class(ms, ms_class);
1065 ms_set_egprs_ms_class(ms, egprs_ms_class);
Jacob Erlbeckcb1b4942015-06-19 10:59:58 +02001066
1067 return ms;
1068}
1069
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001070
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001071static int bts_talloc_destructor(struct gprs_rlcmac_bts* bts)
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001072{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001073 bts_cleanup(bts);
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001074 return 0;
1075}
1076
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001077struct gprs_rlcmac_bts* bts_alloc(struct gprs_pcu *pcu)
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001078{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001079 struct gprs_rlcmac_bts* bts;
1080 bts = talloc_zero(pcu, struct gprs_rlcmac_bts);
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001081 if (!bts)
1082 return bts;
1083 talloc_set_destructor(bts, bts_talloc_destructor);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001084 bts_init(bts, pcu);
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001085 return bts;
1086}
1087
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001088struct SBAController *bts_sba(struct gprs_rlcmac_bts *bts)
1089{
1090 return bts->sba;
1091}
1092
1093struct GprsMsStorage *bts_ms_store(struct gprs_rlcmac_bts *bts)
1094{
1095 return bts->ms_store;
1096}
1097
1098struct GprsMs *bts_ms_by_tlli(struct gprs_rlcmac_bts *bts, uint32_t tlli, uint32_t old_tlli)
1099{
1100 return bts_ms_store(bts)->get_ms(tlli, old_tlli);
1101}
1102
Minh-Quang Nguyen1bcfa9a2017-11-01 14:41:37 -04001103/* update TA based on TA provided by PH-DATA-IND */
1104void update_tbf_ta(struct gprs_rlcmac_ul_tbf *tbf, int8_t ta_delta)
1105{
1106 int16_t ta_adj;
1107 uint8_t ta_target;
1108
1109 if (ta_delta) {
1110 /* adjust TA based on TA provided by PH-DATA-IND */
1111 ta_adj = tbf->ta() + ta_delta;
1112
1113 /* limit target TA in range 0..63 bits */
1114 ta_target = ta_limit(ta_adj);
1115
1116 LOGP(DL1IF, LOGL_INFO, "PH-DATA-IND is updating TLLI=0x%08x: TA %u -> %u on "
1117 "TRX = %d, TS = %d, FN = %d\n",
1118 tbf->tlli(), tbf->ta(), ta_target,
1119 tbf->trx->trx_no , tbf->poll_ts, tbf->poll_fn);
1120 tbf->set_ta(ta_target);
1121 }
1122}
1123
1124/* set TA based on TA provided by PH-RA-IND */
1125void set_tbf_ta(struct gprs_rlcmac_ul_tbf *tbf, uint8_t ta)
1126{
1127 uint8_t ta_target;
1128
1129 if (tbf->ta() != ta) {
1130 /* limit target TA in range 0..63 bits */
1131 ta_target = ta_limit(ta);
1132
1133 LOGP(DL1IF, LOGL_INFO, "PH-RA-IND is updating TLLI=0x%08x: TA %u -> %u on "
1134 "TRX = %d, TS = %d, FN = %d\n",
1135 tbf->tlli(), tbf->ta(), ta_target,
1136 tbf->trx->trx_no , tbf->poll_ts, tbf->poll_fn);
1137 tbf->set_ta(ta_target);
1138 }
1139}
1140
1141void 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 +02001142{
1143 struct gprs_rlcmac_ul_tbf *tbf =
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001144 bts_ul_tbf_by_poll_fn(the_pcu->bts, fn, trx_no, ts);
Maxd71e8b32016-09-19 16:17:06 +02001145 if (!tbf)
1146 LOGP(DL1IF, LOGL_DEBUG, "[%s] update TA = %u ignored due to "
1147 "unknown UL TBF on TRX = %d, TS = %d, FN = %d\n",
1148 p, ta, trx_no, ts, fn);
Minh-Quang Nguyen1bcfa9a2017-11-01 14:41:37 -04001149 else {
1150 /* we need to distinguish TA information provided by L1
1151 * from PH-DATA-IND and PHY-RA-IND so that we can properly
1152 * update TA for given TBF
1153 */
1154 if (is_rach)
1155 set_tbf_ta(tbf, (uint8_t)ta);
1156 else
1157 update_tbf_ta(tbf, ta);
1158
Maxd71e8b32016-09-19 16:17:06 +02001159 }
1160}
1161
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001162void bts_trx_reserve_slots(struct gprs_rlcmac_trx *trx, enum gprs_rlcmac_tbf_direction dir,
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001163 uint8_t slots)
1164{
1165 unsigned i;
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001166 for (i = 0; i < ARRAY_SIZE(trx->pdch); i += 1)
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001167 if (slots & (1 << i))
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001168 trx->pdch[i].reserve(dir);
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001169}
1170
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001171void bts_trx_unreserve_slots(struct gprs_rlcmac_trx *trx, enum gprs_rlcmac_tbf_direction dir,
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001172 uint8_t slots)
1173{
1174 unsigned i;
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001175 for (i = 0; i < ARRAY_SIZE(trx->pdch); i += 1)
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001176 if (slots & (1 << i))
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001177 trx->pdch[i].unreserve(dir);
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001178}
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001179
Pau Espin Pedrol793583e2021-01-14 16:20:57 +01001180void bts_recalc_initial_cs(struct gprs_rlcmac_bts *bts)
1181{
1182 uint8_t max_cs_dl, max_cs_ul;
1183
1184 if (the_pcu->vty.force_initial_cs) {
1185 bts->initial_cs_dl = the_pcu->vty.initial_cs_dl;
1186 bts->initial_cs_ul = the_pcu->vty.initial_cs_ul;
1187 return;
1188 }
1189
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001190 max_cs_dl = bts_max_cs_dl(bts);
Pau Espin Pedrol793583e2021-01-14 16:20:57 +01001191 if (bts->pcuif_info_ind.initial_cs > max_cs_dl) {
1192 LOGP(DL1IF, LOGL_DEBUG, " downgrading initial_cs_dl to %d\n", max_cs_dl);
1193 bts->initial_cs_dl = max_cs_dl;
1194 } else {
1195 bts->initial_cs_dl = bts->pcuif_info_ind.initial_cs;
1196 }
1197 if (bts->initial_cs_dl == 0)
1198 bts->initial_cs_dl = 1; /* CS1 Must always be supported */
1199
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001200 max_cs_ul = bts_max_cs_ul(bts);
Pau Espin Pedrol793583e2021-01-14 16:20:57 +01001201 if (bts->pcuif_info_ind.initial_cs > max_cs_ul) {
1202 LOGP(DL1IF, LOGL_DEBUG, " downgrading initial_cs_ul to %d\n", max_cs_ul);
1203 bts->initial_cs_ul = max_cs_ul;
1204 } else {
1205 bts->initial_cs_ul = bts->pcuif_info_ind.initial_cs;
1206 }
1207 if (bts->initial_cs_ul == 0)
1208 bts->initial_cs_ul = 1; /* CS1 Must always be supported */
1209}
1210void bts_recalc_initial_mcs(struct gprs_rlcmac_bts *bts)
1211{
1212 uint8_t max_mcs_dl, max_mcs_ul;
1213
1214 if (the_pcu->vty.force_initial_mcs) {
1215 bts->initial_mcs_dl = the_pcu->vty.initial_mcs_dl;
1216 bts->initial_mcs_ul = the_pcu->vty.initial_mcs_ul;
1217 return;
1218 }
1219
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001220 max_mcs_dl = bts_max_mcs_dl(bts);
Pau Espin Pedrol793583e2021-01-14 16:20:57 +01001221 if (bts->pcuif_info_ind.initial_mcs > max_mcs_dl) {
1222 LOGP(DL1IF, LOGL_DEBUG, " downgrading initial_mcs_dl to %d\n", max_mcs_dl);
1223 bts->initial_mcs_dl = max_mcs_dl;
1224 } else {
1225 bts->initial_mcs_dl = bts->pcuif_info_ind.initial_mcs;
1226 }
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001227 max_mcs_ul = bts_max_mcs_ul(bts);
Pau Espin Pedrol793583e2021-01-14 16:20:57 +01001228 if (bts->pcuif_info_ind.initial_mcs > max_mcs_ul) {
1229 LOGP(DL1IF, LOGL_DEBUG, " downgrading initial_mcs_ul to %d\n", max_mcs_ul);
1230 bts->initial_mcs_ul = max_mcs_ul;
1231 } else {
1232 bts->initial_mcs_ul = bts->pcuif_info_ind.initial_mcs;
1233 }
1234}
1235
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001236void bts_recalc_max_cs(struct gprs_rlcmac_bts *bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001237{
1238 int i;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001239 uint8_t cs_dl, cs_ul;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001240 struct gprs_pcu *pcu = bts->pcu;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001241
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001242 cs_dl = 0;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001243 for (i = pcu->vty.max_cs_dl - 1; i >= 0; i--) {
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001244 if (bts->cs_mask & (1 << i)) {
1245 cs_dl = i + 1;
1246 break;
1247 }
1248 }
1249
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001250 cs_ul = 0;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001251 for (i = pcu->vty.max_cs_ul - 1; i >= 0; i--) {
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001252 if (bts->cs_mask & (1 << i)) {
1253 cs_ul = i + 1;
1254 break;
1255 }
1256 }
1257
1258 LOGP(DRLCMAC, LOGL_DEBUG, "New max CS: DL=%u UL=%u\n", cs_dl, cs_ul);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001259 bts_set_max_cs_dl(bts, cs_dl);
1260 bts_set_max_cs_ul(bts, cs_ul);
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001261}
1262
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001263void bts_recalc_max_mcs(struct gprs_rlcmac_bts *bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001264{
1265 int i;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001266 uint8_t mcs_dl, mcs_ul;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001267 struct gprs_pcu *pcu = bts->pcu;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001268
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001269 mcs_dl = 0;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001270 for (i = pcu->vty.max_mcs_dl - 1; i >= 0; i--) {
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001271 if (bts->mcs_mask & (1 << i)) {
1272 mcs_dl = i + 1;
1273 break;
1274 }
1275 }
1276
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001277 mcs_ul = 0;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001278 for (i = pcu->vty.max_mcs_ul - 1; i >= 0; i--) {
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001279 if (bts->mcs_mask & (1 << i)) {
1280 mcs_ul = i + 1;
1281 break;
1282 }
1283 }
1284
1285 LOGP(DRLCMAC, LOGL_DEBUG, "New max MCS: DL=%u UL=%u\n", mcs_dl, mcs_ul);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001286 bts_set_max_mcs_dl(bts, mcs_dl);
1287 bts_set_max_mcs_ul(bts, mcs_ul);
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001288}
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001289
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001290struct GprsMs *bts_ms_by_imsi(struct gprs_rlcmac_bts *bts, const char *imsi)
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001291{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001292 return bts_ms_store(bts)->get_ms(0, 0, imsi);
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001293}