blob: 55d45b8c63d63bc972f3396a0167303c868f4583 [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 Pedrol906aafc2021-01-18 17:53:29 +010073void bts_trx_free_all_tbf(struct gprs_rlcmac_trx *trx)
74{
75 for (uint8_t ts = 0; ts < 8; ts++)
76 pdch_free_all_tbf(&trx->pdch[ts]);
77}
78
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +020079static struct osmo_tdef T_defs_bts[] = {
80 { .T=3142, .default_val=20, .unit=OSMO_TDEF_S, .desc="timer (s)", .val=0 },
81 { .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 },
82 { .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 },
83 { .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 },
84 { .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 +020085 { .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 +020086};
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +020087
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +010088/**
89 * For gcc-4.4 compat do not use extended initializer list but keep the
90 * order from the enum here. Once we support GCC4.7 and up we can change
91 * the code below.
92 */
93static const struct rate_ctr_desc bts_ctr_description[] = {
Maxa5eb67d2017-11-21 20:24:54 +010094 { "tbf:dl:alloc", "TBF DL Allocated "},
95 { "tbf:dl:freed", "TBF DL Freed "},
96 { "tbf:dl:aborted", "TBF DL Aborted "},
97 { "tbf:ul:alloc", "TBF UL Allocated "},
98 { "tbf:ul:freed", "TBF UL Freed "},
99 { "tbf:ul:aborted", "TBF UL Aborted "},
100 { "tbf:reused", "TBF Reused "},
101 { "tbf:alloc:algo-a", "TBF Alloc Algo A "},
102 { "tbf:alloc:algo-b", "TBF Alloc Algo B "},
Pau Espin Pedrol9688dc92021-02-25 18:30:33 +0100103 { "tbf:alloc:failed", "TBF Alloc Failure (any reason)"},
104 { "tbf:alloc:failed:no_tfi", "TBF Alloc Failure (TFIs exhausted)"},
105 { "tbf:alloc:failed:no_usf", "TBF Alloc Failure (USFs exhausted)"},
106 { "tbf:alloc:failed:no_slot_combi", "TBF Alloc Failure (No valid UL/DL slot combination found)"},
107 { "tbf:alloc:failed:no_slot_avail", "TBF Alloc Failure (No slot available)"},
Maxa5eb67d2017-11-21 20:24:54 +0100108 { "rlc:sent", "RLC Sent "},
109 { "rlc:resent", "RLC Resent "},
110 { "rlc:restarted", "RLC Restarted "},
111 { "rlc:stalled", "RLC Stalled "},
112 { "rlc:nacked", "RLC Nacked "},
113 { "rlc:final_block_resent", "RLC Final Blk resent "},
114 { "rlc:ass:timedout", "RLC Assign Timeout "},
115 { "rlc:ass:failed", "RLC Assign Failed "},
116 { "rlc:ack:timedout", "RLC Ack Timeout "},
117 { "rlc:ack:failed", "RLC Ack Failed "},
118 { "rlc:rel:timedout", "RLC Release Timeout "},
119 { "rlc:late-block", "RLC Late Block "},
120 { "rlc:sent-dummy", "RLC Sent Dummy "},
121 { "rlc:sent-control", "RLC Sent Control "},
122 { "rlc:dl_bytes", "RLC DL Bytes "},
123 { "rlc:dl_payload_bytes", "RLC DL Payload Bytes "},
124 { "rlc:ul_bytes", "RLC UL Bytes "},
125 { "rlc:ul_payload_bytes", "RLC UL Payload Bytes "},
126 { "decode:errors", "Decode Errors "},
127 { "sba:allocated", "SBA Allocated "},
128 { "sba:freed", "SBA Freed "},
129 { "sba:timedout", "SBA Timeout "},
130 { "llc:timeout", "Timedout Frames "},
131 { "llc:dropped", "Dropped Frames "},
132 { "llc:scheduled", "Scheduled Frames "},
133 { "llc:dl_bytes", "RLC encapsulated PDUs"},
134 { "llc:ul_bytes", "full PDUs received "},
135 { "rach:requests", "RACH requests "},
136 { "11bit_rach:requests", "11BIT_RACH requests "},
137 { "spb:uplink_first_segment", "First seg of UL SPB "},
138 { "spb:uplink_second_segment", "Second seg of UL SPB "},
139 { "spb:downlink_first_segment", "First seg of DL SPB "},
140 { "spb:downlink_second_segment","Second seg of DL SPB "},
141 { "immediate:assignment_UL", "Immediate Assign UL "},
142 { "immediate:assignment_rej", "Immediate Assign Rej "},
143 { "immediate:assignment_DL", "Immediate Assign DL "},
144 { "channel:request_description","Channel Request Desc "},
145 { "pkt:ul_assignment", "Packet UL Assignment "},
146 { "pkt:access_reject", "Packet Access Reject "},
147 { "pkt:dl_assignment", "Packet DL Assignment "},
Pau Espin Pedrolc0a250d2021-01-21 18:46:13 +0100148 { "pkt:cell_chg_notification", "Packet Cell Change Notification"},
149 { "pkt:cell_chg_continue", "Packet Cell Change Continue"},
150 { "pkt:neigh_cell_data", "Packet Neighbour Cell Data"},
Maxa5eb67d2017-11-21 20:24:54 +0100151 { "ul:control", "UL control Block "},
152 { "ul:assignment_poll_timeout", "UL Assign Timeout "},
153 { "ul:assignment_failed", "UL Assign Failed "},
154 { "dl:assignment_timeout", "DL Assign Timeout "},
155 { "dl:assignment_failed", "DL Assign Failed "},
156 { "pkt:ul_ack_nack_timeout", "PUAN Poll Timeout "},
157 { "pkt:ul_ack_nack_failed", "PUAN poll Failed "},
158 { "pkt:dl_ack_nack_timeout", "PDAN poll Timeout "},
159 { "pkt:dl_ack_nack_failed", "PDAN poll Failed "},
160 { "gprs:downlink_cs1", "CS1 downlink "},
161 { "gprs:downlink_cs2", "CS2 downlink "},
162 { "gprs:downlink_cs3", "CS3 downlink "},
163 { "gprs:downlink_cs4", "CS4 downlink "},
164 { "egprs:downlink_mcs1", "MCS1 downlink "},
165 { "egprs:downlink_mcs2", "MCS2 downlink "},
166 { "egprs:downlink_mcs3", "MCS3 downlink "},
167 { "egprs:downlink_mcs4", "MCS4 downlink "},
168 { "egprs:downlink_mcs5", "MCS5 downlink "},
169 { "egprs:downlink_mcs6", "MCS6 downlink "},
170 { "egprs:downlink_mcs7", "MCS7 downlink "},
171 { "egprs:downlink_mcs8", "MCS8 downlink "},
172 { "egprs:downlink_mcs9", "MCS9 downlink "},
173 { "gprs:uplink_cs1", "CS1 Uplink "},
174 { "gprs:uplink_cs2", "CS2 Uplink "},
175 { "gprs:uplink_cs3", "CS3 Uplink "},
176 { "gprs:uplink_cs4", "CS4 Uplink "},
177 { "egprs:uplink_mcs1", "MCS1 Uplink "},
178 { "egprs:uplink_mcs2", "MCS2 Uplink "},
179 { "egprs:uplink_mcs3", "MCS3 Uplink "},
180 { "egprs:uplink_mcs4", "MCS4 Uplink "},
181 { "egprs:uplink_mcs5", "MCS5 Uplink "},
182 { "egprs:uplink_mcs6", "MCS6 Uplink "},
183 { "egprs:uplink_mcs7", "MCS7 Uplink "},
184 { "egprs:uplink_mcs8", "MCS8 Uplink "},
185 { "egprs:uplink_mcs9", "MCS9 Uplink "},
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100186};
187
188static const struct rate_ctr_group_desc bts_ctrg_desc = {
189 "bts",
190 "BTS Statistics",
Holger Hans Peter Freytherb8a54262015-11-07 21:00:00 +0100191 OSMO_STATS_CLASS_GLOBAL,
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100192 ARRAY_SIZE(bts_ctr_description),
193 bts_ctr_description,
194};
195
Jacob Erlbeckf5898a02015-11-27 19:05:13 +0100196static const struct osmo_stat_item_desc bts_stat_item_description[] = {
197 { "ms.present", "MS Present ",
198 OSMO_STAT_ITEM_NO_UNIT, 4, 0},
199};
200
201static const struct osmo_stat_item_group_desc bts_statg_desc = {
202 "bts",
203 "BTS Statistics",
204 OSMO_STATS_CLASS_GLOBAL,
205 ARRAY_SIZE(bts_stat_item_description),
206 bts_stat_item_description,
207};
208
Pau Espin Pedrol289f9002021-01-18 12:57:32 +0100209static int bts_talloc_destructor(struct gprs_rlcmac_bts* bts)
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100210{
Pau Espin Pedrol289f9002021-01-18 12:57:32 +0100211 /* this can cause counter updates and must not be left to the
212 * m_ms_store's destructor */
213 bts->ms_store->cleanup();
214 delete bts->ms_store;
215 delete bts->sba;
216 delete bts->pollController;
217
218 if (bts->ratectrs) {
219 rate_ctr_group_free(bts->ratectrs);
220 bts->ratectrs = NULL;
221 }
222
223 if (bts->statg) {
224 osmo_stat_item_group_free(bts->statg);
225 bts->statg = NULL;
226 }
227
228 if (bts->app_info) {
229 msgb_free(bts->app_info);
230 bts->app_info = NULL;
231 }
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100232
233 llist_del(&bts->list);
Pau Espin Pedrol289f9002021-01-18 12:57:32 +0100234 return 0;
235}
236
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100237struct gprs_rlcmac_bts* bts_alloc(struct gprs_pcu *pcu, uint8_t bts_nr)
Pau Espin Pedrol289f9002021-01-18 12:57:32 +0100238{
239 struct gprs_rlcmac_bts* bts;
240 bts = talloc_zero(pcu, struct gprs_rlcmac_bts);
241 if (!bts)
242 return bts;
243 talloc_set_destructor(bts, bts_talloc_destructor);
244
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100245 bts->pcu = pcu;
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100246 bts->nr = bts_nr;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100247
248 bts->pollController = new PollController(*bts);
249 bts->sba = new SBAController(*bts);
250 bts->ms_store = new GprsMsStorage(bts);
251
252 bts->cur_fn = 0;
253 bts->cur_blk_fn = -1;
254 bts->max_cs_dl = MAX_GPRS_CS;
255 bts->max_cs_ul = MAX_GPRS_CS;
256 bts->max_mcs_dl = MAX_EDGE_MCS;
257 bts->max_mcs_ul = MAX_EDGE_MCS;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100258 bts->initial_cs_dl = bts->initial_cs_ul = 1;
259 bts->initial_mcs_dl = bts->initial_mcs_ul = 1;
Pau Espin Pedrold87722d2020-10-30 17:14:26 +0100260 bts->cs_mask = 1 << 0; /* CS-1 always enabled by default */
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100261 bts->n3101 = 10;
262 bts->n3103 = 4;
263 bts->n3105 = 8;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100264 bts->si13_is_set = false;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100265
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100266 bts->app_info = NULL;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100267 bts->T_defs_bts = T_defs_bts;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100268 osmo_tdefs_reset(bts->T_defs_bts);
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100269
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100270 INIT_LLIST_HEAD(&bts->ul_tbfs);
271 INIT_LLIST_HEAD(&bts->dl_tbfs);
272
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100273 /* initialize back pointers */
274 for (size_t trx_no = 0; trx_no < ARRAY_SIZE(bts->trx); ++trx_no) {
275 struct gprs_rlcmac_trx *trx = &bts->trx[trx_no];
276 trx->trx_no = trx_no;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100277 trx->bts = bts;
Pau Espin Pedrol46fd7a02020-11-02 14:36:22 +0100278
279 for (size_t ts_no = 0; ts_no < ARRAY_SIZE(trx->pdch); ++ts_no) {
280 struct gprs_rlcmac_pdch *pdch = &trx->pdch[ts_no];
281 pdch->init_ptcch_msg();
282 pdch->ts_no = ts_no;
283 pdch->trx = trx;
284 }
285 }
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100286
Maxea9968f2017-12-18 22:52:52 +0100287 /* The static allocator might have already registered the counter group.
Max1714aea2017-12-21 11:19:39 +0100288 If this happens and we still called explicitly (in tests/ for example)
Maxea9968f2017-12-18 22:52:52 +0100289 than just allocate the group with different index.
290 This shall be removed once weget rid of BTS singleton */
291 if (rate_ctr_get_group_by_name_idx(bts_ctrg_desc.group_name_prefix, 0))
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100292 bts->ratectrs = rate_ctr_group_alloc(tall_pcu_ctx, &bts_ctrg_desc, 1);
Maxea9968f2017-12-18 22:52:52 +0100293 else
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100294 bts->ratectrs = rate_ctr_group_alloc(tall_pcu_ctx, &bts_ctrg_desc, 0);
295 OSMO_ASSERT(bts->ratectrs);
Maxea9968f2017-12-18 22:52:52 +0100296
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100297 bts->statg = osmo_stat_item_group_alloc(tall_pcu_ctx, &bts_statg_desc, 0);
298 OSMO_ASSERT(bts->statg);
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200299
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100300 llist_add_tail(&bts->list, &pcu->bts_list);
301
Pau Espin Pedrol289f9002021-01-18 12:57:32 +0100302 return bts;
Holger Hans Peter Freytherf5372982013-10-27 09:02:31 +0100303}
304
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100305void bts_set_current_frame_number(struct gprs_rlcmac_bts *bts, int fn)
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200306{
Jacob Erlbeckac49d092015-08-27 13:18:24 +0200307 /* The UL frame numbers lag 3 behind the DL frames and the data
308 * indication is only sent after all 4 frames of the block have been
309 * received. Sometimes there is an idle frame between the end of one
310 * and start of another frame (every 3 blocks). So the timeout should
311 * definitely be there if we're more than 8 frames past poll_fn. Let's
Jacob Erlbecke77d49f2015-08-27 13:28:05 +0200312 * stay on the safe side and say 13 or more. An additional delay can
313 * happen due to the block processing time in the DSP, so the delay of
314 * decoded blocks relative to the timing clock can be much larger.
315 * Values up to 50 frames have been observed under load. */
316 const static int max_delay = 60;
Jacob Erlbeckac49d092015-08-27 13:18:24 +0200317
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100318 bts->cur_fn = fn;
319 bts->pollController->expireTimedout(bts->cur_fn, max_delay);
Holger Hans Peter Freyther9b30c7f2013-10-17 19:59:56 +0200320}
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +0200321
Max9dabfa22017-05-16 16:10:45 +0200322static inline int delta_fn(int fn, int to)
323{
324 return (fn + GSM_MAX_FN * 3 / 2 - to) % GSM_MAX_FN - GSM_MAX_FN/2;
325}
326
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100327void bts_set_current_block_frame_number(struct gprs_rlcmac_bts *bts, int fn, unsigned max_delay)
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200328{
329 int delay = 0;
330 const int late_block_delay_thresh = 13;
331 const int fn_update_ok_min_delay = -500;
332 const int fn_update_ok_max_delay = 0;
333
334 /* frame numbers in the received blocks are assumed to be strongly
335 * monotonic. */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100336 if (bts->cur_blk_fn >= 0) {
337 int delta = delta_fn(fn, bts->cur_blk_fn);
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200338 if (delta <= 0)
339 return;
340 }
341
342 /* Check block delay vs. the current frame number */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100343 if (bts_current_frame_number(bts) != 0)
344 delay = delta_fn(fn, bts_current_frame_number(bts));
Jacob Erlbeckbe4a08b2015-08-25 15:19:31 +0200345 if (delay <= -late_block_delay_thresh) {
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200346 LOGP(DRLCMAC, LOGL_NOTICE,
347 "Late RLC block, FN delta: %d FN: %d curFN: %d\n",
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100348 delay, fn, bts_current_frame_number(bts));
349 bts_do_rate_ctr_inc(bts, CTR_RLC_LATE_BLOCK);
Jacob Erlbeckbe4a08b2015-08-25 15:19:31 +0200350 }
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200351
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100352 bts->cur_blk_fn = fn;
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200353 if (delay < fn_update_ok_min_delay || delay > fn_update_ok_max_delay ||
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100354 bts_current_frame_number(bts) == 0)
355 bts->cur_fn = fn;
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200356
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100357 bts->pollController->expireTimedout(fn, max_delay);
Jacob Erlbeck60f77032015-08-24 14:35:14 +0200358}
359
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100360int 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 +0200361{
362 uint8_t l, trx, ts, any_tbf = 0;
363 struct gprs_rlcmac_tbf *tbf;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100364 struct llist_item *pos;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200365 uint8_t slot_mask[8];
366 int8_t first_ts; /* must be signed */
367
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100368 struct llist_head *tbfs_lists[] = {
369 &bts->ul_tbfs,
370 &bts->dl_tbfs,
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200371 NULL
372 };
373
Neels Hofmeyr00520512020-08-21 15:44:58 +0200374 if (log_check_level(DRLCMAC, LOGL_INFO)) {
Neels Hofmeyr00520512020-08-21 15:44:58 +0200375 char str[64];
Neels Hofmeyr59fc0bd2020-08-21 16:21:23 +0200376 osmo_mobile_identity_to_str_buf(str, sizeof(str), mi);
Neels Hofmeyr00520512020-08-21 15:44:58 +0200377 LOGP(DRLCMAC, LOGL_INFO, "Add RR paging: chan-needed=%d MI=%s\n", chan_needed, str);
378 }
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200379
380 /* collect slots to page
381 * Mark slots for every TBF, but only mark one of it.
382 * Mark only the first slot found.
383 * Don't mark, if TBF uses a different slot that is already marked. */
384 memset(slot_mask, 0, sizeof(slot_mask));
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200385 for (l = 0; tbfs_lists[l]; l++) {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100386 llist_for_each_entry(pos, tbfs_lists[l], list) {
387 tbf = (struct gprs_rlcmac_tbf *)pos->entry;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200388 first_ts = -1;
389 for (ts = 0; ts < 8; ts++) {
390 if (tbf->pdch[ts]) {
391 /* remember the first slot found */
392 if (first_ts < 0)
393 first_ts = ts;
394 /* break, if we already marked a slot */
Holger Hans Peter Freytherec80f822013-10-27 13:44:37 +0100395 if ((slot_mask[tbf->trx->trx_no] & (1 << ts)))
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200396 break;
397 }
398 }
399 /* mark first slot found, if none is marked already */
400 if (ts == 8 && first_ts >= 0) {
Maxc21f0072017-12-15 17:36:45 +0100401 LOGPTBF(tbf, LOGL_DEBUG, "uses "
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200402 "TRX=%d TS=%d, so we mark\n",
Holger Hans Peter Freytherbd449f52013-10-27 16:39:36 +0100403 tbf->trx->trx_no, first_ts);
Holger Hans Peter Freytherec80f822013-10-27 13:44:37 +0100404 slot_mask[tbf->trx->trx_no] |= (1 << first_ts);
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200405 } else
Maxc21f0072017-12-15 17:36:45 +0100406 LOGPTBF(tbf, LOGL_DEBUG, "uses "
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200407 "already marked TRX=%d TS=%d\n",
Holger Hans Peter Freytherbd449f52013-10-27 16:39:36 +0100408 tbf->trx->trx_no, ts);
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200409 }
410 }
411
412 /* Now we have a list of marked slots. Every TBF uses at least one
413 * of these slots. */
414
415 /* schedule paging to all marked slots */
416 for (trx = 0; trx < 8; trx++) {
417 if (slot_mask[trx] == 0)
418 continue;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200419 for (ts = 0; ts < 8; ts++) {
420 if ((slot_mask[trx] & (1 << ts))) {
421 /* schedule */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100422 if (!bts->trx[trx].pdch[ts].add_paging(chan_needed, mi))
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200423 return -ENOMEM;
Max4382e4e2018-01-30 12:00:08 +0100424
425 LOGP(DRLCMAC, LOGL_INFO, "Paging on PACCH of TRX=%d TS=%d\n", trx, ts);
Holger Hans Peter Freyther94464852013-10-19 18:33:52 +0200426 any_tbf = 1;
Holger Hans Peter Freytherf0984892013-10-19 18:28:59 +0200427 }
428 }
429 }
430
431 if (!any_tbf)
432 LOGP(DRLCMAC, LOGL_INFO, "No paging, because no TBF\n");
433
434 return 0;
435}
436
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100437void bts_send_gsmtap_rach(struct gprs_rlcmac_bts *bts,
438 enum pcu_gsmtap_category categ, uint8_t channel,
439 const struct rach_ind_params *rip)
Vadim Yanitskiy07b64872020-06-11 00:26:15 +0700440{
Vadim Yanitskiy55022ea2021-01-06 22:44:06 +0100441 struct pcu_l1_meas meas = { 0 };
Vadim Yanitskiy81b610e2020-06-11 01:04:44 +0700442 uint8_t ra_buf[2];
443
444 /* 3GPP TS 44.004 defines 11 bit RA as follows: xxxx xxxx .... .yyy
445 * On the PCUIF, we get 16 bit machne dependent number (LE/BE)
446 * Over GSMTAP we send the following: xxxx xxxx yyy. ....
447 * This simplifies parsing in Wireshark using its CSN.1 codec. */
448 if (rip->is_11bit) {
449 ra_buf[0] = (uint8_t) ((rip->ra >> 3) & 0xff);
450 ra_buf[1] = (uint8_t) ((rip->ra << 5) & 0xff);
451 } else {
452 ra_buf[0] = (uint8_t) (rip->ra & 0xff);
453 }
454
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100455 bts_send_gsmtap_meas(bts, categ, true, rip->trx_nr, rip->ts_nr, channel,
456 bts_rfn_to_fn(bts, rip->rfn), ra_buf,
Vadim Yanitskiy07b64872020-06-11 00:26:15 +0700457 rip->is_11bit ? 2 : 1, &meas);
458}
459
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100460void bts_send_gsmtap(struct gprs_rlcmac_bts *bts,
461 enum pcu_gsmtap_category categ, bool uplink, uint8_t trx_no,
462 uint8_t ts_no, uint8_t channel, uint32_t fn,
463 const uint8_t *data, unsigned int len)
Harald Welte717cdf52017-07-21 21:56:23 +0200464{
Vadim Yanitskiyeb70a402021-01-13 13:58:14 +0100465 struct pcu_l1_meas meas = { 0 };
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100466 bts_send_gsmtap_meas(bts, categ, uplink, trx_no, ts_no, channel, fn, data, len, &meas);
Pau Espin Pedrol0b0391f2020-05-19 17:23:23 +0200467}
468
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100469void bts_send_gsmtap_meas(struct gprs_rlcmac_bts *bts,
470 enum pcu_gsmtap_category categ, bool uplink, uint8_t trx_no,
471 uint8_t ts_no, uint8_t channel, uint32_t fn,
472 const uint8_t *data, unsigned int len, struct pcu_l1_meas *meas)
Pau Espin Pedrol0b0391f2020-05-19 17:23:23 +0200473{
Harald Welte717cdf52017-07-21 21:56:23 +0200474 uint16_t arfcn;
475
476 /* check if category is activated at all */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100477 if (!(bts->pcu->gsmtap_categ_mask & (1 << categ)))
Harald Welte717cdf52017-07-21 21:56:23 +0200478 return;
479
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100480 arfcn = bts->trx[trx_no].arfcn;
Harald Welte717cdf52017-07-21 21:56:23 +0200481 if (uplink)
482 arfcn |= GSMTAP_ARFCN_F_UPLINK;
483
Pau Espin Pedrol0b0391f2020-05-19 17:23:23 +0200484 /* GSMTAP needs the SNR here, but we only have C/I (meas->link_qual).
485 Those are not the same, but there is no known way to convert them,
486 let's pass C/I instead of nothing */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100487 gsmtap_send(bts->pcu->gsmtap, arfcn, ts_no, channel, 0, fn,
Pau Espin Pedrol0b0391f2020-05-19 17:23:23 +0200488 meas->rssi, meas->link_qual, data, len);
Harald Welte717cdf52017-07-21 21:56:23 +0200489}
490
Max341dccd2017-08-14 15:49:59 +0200491static inline bool tbf_check(gprs_rlcmac_tbf *tbf, uint32_t fn, uint8_t trx_no, uint8_t ts)
492{
Maxcac6b662018-01-24 11:00:17 +0100493 if (tbf->state_is_not(GPRS_RLCMAC_RELEASING) && tbf->poll_scheduled()
Max341dccd2017-08-14 15:49:59 +0200494 && tbf->poll_fn == fn && tbf->trx->trx_no == trx_no && tbf->poll_ts == ts)
495 return true;
496
497 return false;
498}
499
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100500struct 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 +0200501{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100502 struct llist_item *pos;
503 struct gprs_rlcmac_tbf *tbf;
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200504
505 /* only one TBF can poll on specific TS/FN, because scheduler can only
506 * schedule one downlink control block (with polling) at a FN per TS */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100507 llist_for_each_entry(pos, &bts->dl_tbfs, list) {
508 tbf = (struct gprs_rlcmac_tbf *)pos->entry;
509 if (tbf_check(tbf, fn, trx, ts))
510 return as_dl_tbf(tbf);
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200511 }
Daniel Willmannfebf1a02014-07-02 17:58:16 +0200512 return NULL;
513}
Max341dccd2017-08-14 15:49:59 +0200514
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100515struct 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 +0200516{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100517 struct llist_item *pos;
518 struct gprs_rlcmac_tbf *tbf;
Daniel Willmannfebf1a02014-07-02 17:58:16 +0200519
520 /* only one TBF can poll on specific TS/FN, because scheduler can only
521 * schedule one downlink control block (with polling) at a FN per TS */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100522 llist_for_each_entry(pos, &bts->ul_tbfs, list) {
523 tbf = (struct gprs_rlcmac_tbf *)pos->entry;
524 if (tbf_check(tbf, fn, trx, ts))
525 return as_ul_tbf(tbf);
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +0200526 }
527 return NULL;
528}
529
Daniel Willmann54044b02014-07-02 17:58:15 +0200530/* lookup downlink TBF Entity (by TFI) */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100531struct 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 +0200532{
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200533 if (trx >= 8 || ts >= 8)
534 return NULL;
535
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100536 return bts->trx[trx].pdch[ts].dl_tbf_by_tfi(tfi);
Daniel Willmann54044b02014-07-02 17:58:15 +0200537}
538
539/* lookup uplink TBF Entity (by TFI) */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100540struct 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 +0200541{
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200542 if (trx >= 8 || ts >= 8)
Holger Hans Peter Freytherf63cabd2013-10-26 19:10:43 +0200543 return NULL;
544
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100545 return bts->trx[trx].pdch[ts].ul_tbf_by_tfi(tfi);
Holger Hans Peter Freytherf63cabd2013-10-26 19:10:43 +0200546}
547
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100548static unsigned int trx_count_free_tfi(const struct gprs_rlcmac_trx *trx, enum gprs_rlcmac_tbf_direction dir, uint8_t *first_free_tfi)
549{
550 const struct gprs_rlcmac_pdch *pdch;
551 uint8_t ts;
552 unsigned int i;
553 unsigned int free_tfi_cnt = 0;
554 bool has_pdch = false;
555 uint32_t mask = NO_FREE_TFI;
556
557 for (ts = 0; ts < ARRAY_SIZE(trx->pdch); ts++) {
558 pdch = &trx->pdch[ts];
559 if (!pdch->is_enabled())
560 continue;
561 has_pdch = true;
562 mask &= ~pdch->assigned_tfi(dir);
563 }
564
565 if (!has_pdch || !mask) {
566 *first_free_tfi = (uint8_t)-1;
567 return 0;
568 }
569
570 /* Count free tfis and return */
571 for (i = 0; i < sizeof(mask) * 8 ; i++) {
572 if (mask & 1) {
573 if (free_tfi_cnt == 0)
574 *first_free_tfi = i;
575 free_tfi_cnt++;
576 }
577 mask >>= 1;
578 }
579 return free_tfi_cnt;
580}
581
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200582/*
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100583 * Search for free TFI and return TFI, TRX. This method returns the first TFI
584 * that is currently not used in any PDCH of a the TRX with least TFIs currently
585 * assigned. Negative values indicate errors.
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200586 */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100587int bts_tfi_find_free(const struct gprs_rlcmac_bts *bts, enum gprs_rlcmac_tbf_direction dir,
588 uint8_t *_trx, int8_t use_trx)
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200589{
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100590 uint8_t trx_from, trx_to, trx;
591 uint8_t best_trx_nr = 0xff;
592 unsigned int best_cnt = 0;
593 uint8_t best_first_tfi = 0;
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200594
595 if (use_trx >= 0 && use_trx < 8)
596 trx_from = trx_to = use_trx;
597 else {
598 trx_from = 0;
599 trx_to = 7;
600 }
601
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200602 /* find a TFI that is unused on all PDCH */
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200603 for (trx = trx_from; trx <= trx_to; trx++) {
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100604 uint8_t tmp_first_tfi;
605 unsigned int tmp_cnt;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100606 tmp_cnt = trx_count_free_tfi(&bts->trx[trx], dir, &tmp_first_tfi);
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100607 if (tmp_cnt > best_cnt) {
608 best_cnt = tmp_cnt;
609 best_first_tfi = tmp_first_tfi;
610 best_trx_nr = trx;
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200611 }
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200612 }
613
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100614 if (best_trx_nr == 0xff || best_cnt == 0) {
Max69d585e2018-01-26 12:36:43 +0100615 LOGP(DRLCMAC, LOGL_NOTICE, "No TFI available (suggested TRX: %d).\n", use_trx);
Pau Espin Pedrol9688dc92021-02-25 18:30:33 +0100616 bts_do_rate_ctr_inc(bts, CTR_TBF_ALLOC_FAIL_NO_TFI);
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200617 return -EBUSY;
618 }
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200619
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100620 OSMO_ASSERT(best_first_tfi < 32);
Jacob Erlbeck3a10dbd2015-07-10 19:52:37 +0200621
Pau Espin Pedrol983bb7e2020-10-26 14:52:06 +0100622 LOGP(DRLCMAC, LOGL_DEBUG, "Found first unallocated TRX=%d TFI=%d\n",
623 best_trx_nr, best_first_tfi);
624 *_trx = best_trx_nr;
625 return best_first_tfi;
Holger Hans Peter Freyther70ddde62013-10-26 19:17:58 +0200626}
627
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100628int 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 +0200629{
Jacob Erlbeck767193e2015-05-20 12:06:46 +0200630 struct gprs_rlcmac_dl_tbf *dl_tbf = NULL;
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200631 uint8_t plen;
632 uint32_t tlli;
Jacob Erlbeck767193e2015-05-20 12:06:46 +0200633 GprsMs *ms;
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200634
635 /* move to IA Rest Octets */
636 plen = data[0] >> 2;
637 data += 1 + plen;
638
639 if ((*data & 0xf0) != 0xd0) {
640 LOGP(DRLCMAC, LOGL_ERROR, "Got IMM.ASS confirm, but rest "
641 "octets do not start with bit sequence 'HH01' "
642 "(Packet Downlink Assignment)\n");
643 return -EINVAL;
644 }
645
646 /* get TLLI from downlink assignment */
Eric Wildab8b01e2019-07-23 17:16:06 +0200647 tlli = (uint32_t)((*data++) & 0xf) << 28;
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200648 tlli |= (*data++) << 20;
649 tlli |= (*data++) << 12;
650 tlli |= (*data++) << 4;
651 tlli |= (*data++) >> 4;
652
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100653 ms = bts_ms_by_tlli(bts, tlli, GSM_RESERVED_TMSI);
Jacob Erlbeck767193e2015-05-20 12:06:46 +0200654 if (ms)
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +0100655 dl_tbf = ms_dl_tbf(ms);
Daniel Willmann1dac2eb2014-08-07 12:37:34 +0200656 if (!dl_tbf) {
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200657 LOGP(DRLCMAC, LOGL_ERROR, "Got IMM.ASS confirm, but TLLI=%08x "
658 "does not exit\n", tlli);
659 return -EINVAL;
660 }
661
662 LOGP(DRLCMAC, LOGL_DEBUG, "Got IMM.ASS confirm for TLLI=%08x\n", tlli);
663
Daniel Willmann7e994e32014-08-07 15:49:21 +0200664 if (dl_tbf->m_wait_confirm)
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +0200665 T_START(dl_tbf, T0, -2002, "assignment (AGCH)", true);
Holger Hans Peter Freyther40cfaa62013-10-26 19:49:16 +0200666
667 return 0;
668}
669
Philipp Maier1275a3f2017-02-21 19:35:23 +0100670/* Determine the full frame number from a relative frame number */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100671uint32_t bts_rfn_to_fn(const struct gprs_rlcmac_bts *bts, int32_t rfn)
Philipp Maier1275a3f2017-02-21 19:35:23 +0100672{
Max5dd8d1b2017-03-08 12:06:42 +0100673 int32_t m_cur_rfn;
674 int32_t fn;
675 int32_t fn_rounded;
676
677 /* double-check that relative FN is not negative and fits into int32_t */
678 OSMO_ASSERT(rfn < GSM_MAX_FN);
679 OSMO_ASSERT(rfn >= 0);
Philipp Maier1275a3f2017-02-21 19:35:23 +0100680
681 /* Note: If a BTS is sending in a rach request it will be fully aware
682 * of the frame number. If the PCU is used in a BSC-co-located setup.
683 * The BSC will forward the incoming RACH request. The RACH request
684 * only contains the relative frame number (Fn % 42432) in its request
685 * reference. This PCU implementation has to fit both scenarios, so
686 * we need to assume that Fn is a relative frame number. */
687
688 /* Ensure that all following calculations are performed with the
689 * relative frame number */
Max5dd8d1b2017-03-08 12:06:42 +0100690 if (rfn >= RFN_MODULUS)
691 return rfn;
Philipp Maier1275a3f2017-02-21 19:35:23 +0100692
693 /* Compute an internal relative frame number from the full internal
694 frame number */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100695 m_cur_rfn = bts->cur_fn % RFN_MODULUS;
Philipp Maier1275a3f2017-02-21 19:35:23 +0100696
697 /* Compute a "rounded" version of the internal frame number, which
698 * exactly fits in the RFN_MODULUS raster */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100699 fn_rounded = bts->cur_fn - m_cur_rfn;
Philipp Maier1275a3f2017-02-21 19:35:23 +0100700
701 /* If the delta between the internal and the external relative frame
702 * number exceeds a certain limit, we need to assume that the incoming
703 * rach request belongs to a the previous rfn period. To correct this,
704 * we roll back the rounded frame number by one RFN_MODULUS */
705 if (abs(rfn - m_cur_rfn) > RFN_THRESHOLD) {
706 LOGP(DRLCMAC, LOGL_DEBUG,
Thorsten Alteholz8bb79042018-10-06 10:42:58 +0200707 "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 +0100708 rfn, bts->cur_fn, RFN_MODULUS);
Philipp Maier1275a3f2017-02-21 19:35:23 +0100709 if (fn_rounded < RFN_MODULUS) {
710 LOGP(DRLCMAC, LOGL_DEBUG,
711 "Cornercase detected: wrapping crosses %u border\n",
712 GSM_MAX_FN);
713 fn_rounded = GSM_MAX_FN - (RFN_MODULUS - fn_rounded);
714 }
715 else
716 fn_rounded -= RFN_MODULUS;
717 }
718
719 /* The real frame number is the sum of the rounded frame number and the
720 * relative framenumber computed via RACH */
721 fn = fn_rounded + rfn;
722
723 return fn;
724}
725
Pau Espin Pedrol9ee90d22020-05-08 14:20:32 +0200726/* 3GPP TS 44.060:
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700727 * Table 11.2.5.2: PACKET CHANNEL REQUEST
728 * Table 11.2.5a.2: EGPRS PACKET CHANNEL REQUEST
729 * Both GPRS and EGPRS use same MultislotClass coding, but since PRACH is
Pau Espin Pedrol9ee90d22020-05-08 14:20:32 +0200730 * deprecated, no PACKET CHANNEL REQUEST exists, which means for GPRS we will
731 * receive CCCH RACH which doesn't contain any mslot class. Hence in the end we
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700732 * can only receive EGPRS mslot class through 11-bit EGPRS PACKET CHANNEL REQUEST. */
733static int parse_egprs_pkt_ch_req(uint16_t ra11, struct chan_req_params *chan_req)
Max58818582018-01-05 15:04:50 +0100734{
Vadim Yanitskiyb90d34b2020-05-21 20:20:34 +0700735 EGPRS_PacketChannelRequest_t req;
736 int rc;
737
738 rc = decode_egprs_pkt_ch_req(ra11, &req);
739 if (rc) {
740 LOGP(DRLCMAC, LOGL_NOTICE, "Failed to decode "
741 "EGPRS Packet Channel Request: rc=%d\n", rc);
742 return rc;
743 }
744
745 LOGP(DRLCMAC, LOGL_INFO, "Rx EGPRS Packet Channel Request: %s\n",
746 get_value_string(egprs_pkt_ch_req_type_names, req.Type));
747
748 switch (req.Type) {
749 case EGPRS_PKT_CHAN_REQ_ONE_PHASE:
750 chan_req->egprs_mslot_class = req.Content.MultislotClass + 1;
751 chan_req->priority = req.Content.Priority + 1;
752 break;
753 case EGPRS_PKT_CHAN_REQ_SHORT:
754 chan_req->priority = req.Content.Priority + 1;
755 if (req.Content.NumberOfBlocks == 0)
756 chan_req->single_block = true;
757 break;
758 case EGPRS_PKT_CHAN_REQ_ONE_PHASE_RED_LATENCY:
759 chan_req->priority = req.Content.Priority + 1;
760 break;
761 /* Two phase access => single block is needed */
762 case EGPRS_PKT_CHAN_REQ_TWO_PHASE:
763 case EGPRS_PKT_CHAN_REQ_TWO_PHASE_IPA:
764 chan_req->priority = req.Content.Priority + 1;
765 chan_req->single_block = true;
766 break;
767 /* Signalling => single block is needed */
768 case EGPRS_PKT_CHAN_REQ_SIGNALLING:
769 case EGPRS_PKT_CHAN_REQ_SIGNALLING_IPA:
770 chan_req->single_block = true;
771 break;
772
773 /* Neither unacknowledged RLC mode, nor emergency calls are supported */
774 case EGPRS_PKT_CHAN_REQ_ONE_PHASE_UNACK:
775 case EGPRS_PKT_CHAN_REQ_EMERGENCY_CALL:
776 case EGPRS_PKT_CHAN_REQ_DEDICATED_CHANNEL:
777 LOGP(DRLCMAC, LOGL_NOTICE, "%s is not supported, rejecting\n",
778 get_value_string(egprs_pkt_ch_req_type_names, req.Type));
779 return -ENOTSUP;
780
781 default:
782 LOGP(DRLCMAC, LOGL_ERROR, "Unknown EGPRS Packet Channel Request "
783 "type=0x%02x, probably a bug in CSN.1 codec\n", req.Type);
784 return -EINVAL;
785 }
Max58818582018-01-05 15:04:50 +0100786
787 return 0;
788}
789
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700790/* NOTE: chan_req needs to be zero-initialized by the caller */
791static int parse_rach_ind(const struct rach_ind_params *rip,
792 struct chan_req_params *chan_req)
Max58818582018-01-05 15:04:50 +0100793{
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700794 int rc;
Max58818582018-01-05 15:04:50 +0100795
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700796 switch (rip->burst_type) {
Max137fd592018-01-05 15:53:08 +0100797 case GSM_L1_BURST_TYPE_NONE:
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700798 LOGP(DRLCMAC, LOGL_ERROR, "RACH.ind contains no burst type, assuming TS0\n");
799 /* fall-through */
800 case GSM_L1_BURST_TYPE_ACCESS_0:
801 if (rip->is_11bit) { /* 11 bit Access Burst with TS0 => Packet Channel Request */
802 LOGP(DRLCMAC, LOGL_ERROR, "11 bit Packet Channel Request "
803 "is not supported (PBCCH is deprecated)\n");
804 return -ENOTSUP;
805 }
806
807 /* 3GPP TS 44.018, table 9.1.8.1: 8 bit CHANNEL REQUEST.
808 * Mask 01110xxx indicates single block packet access. */
809 chan_req->single_block = ((rip->ra & 0xf8) == 0x70);
810 break;
811 case GSM_L1_BURST_TYPE_ACCESS_1:
812 case GSM_L1_BURST_TYPE_ACCESS_2:
813 if (!rip->is_11bit) { /* TS1/TS2 => EGPRS Packet Channel Request (always 11 bit) */
814 LOGP(DRLCMAC, LOGL_ERROR, "11 bit Packet Channel Request "
815 "is not supported (PBCCH is deprecated)\n");
816 return -ENOTSUP;
817 }
818
819 rc = parse_egprs_pkt_ch_req(rip->ra, chan_req);
820 if (rc)
821 return rc;
Max137fd592018-01-05 15:53:08 +0100822 break;
823 default:
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700824 LOGP(DRLCMAC, LOGL_ERROR, "RACH.ind contains unknown burst type 0x%02x "
825 "(%u bit)\n", rip->burst_type, rip->is_11bit ? 11 : 8);
826 return -EINVAL;
Max58818582018-01-05 15:04:50 +0100827 }
828
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700829 return 0;
Max58818582018-01-05 15:04:50 +0100830}
831
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100832int bts_rcv_rach(struct gprs_rlcmac_bts *bts, const struct rach_ind_params *rip)
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200833{
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700834 struct chan_req_params chan_req = { 0 };
Jacob Erlbeck1f332942015-05-04 08:21:17 +0200835 struct gprs_rlcmac_ul_tbf *tbf = NULL;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700836 uint8_t trx_no, ts_no;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200837 uint32_t sb_fn = 0;
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100838 uint8_t usf = 7;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700839 uint8_t tsc = 0;
840 int plen, rc;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200841
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100842 bts_do_rate_ctr_inc(bts, CTR_RACH_REQUESTS);
Holger Hans Peter Freytherc1ae2262013-10-27 10:50:35 +0100843
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700844 if (rip->is_11bit)
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100845 bts_do_rate_ctr_inc(bts, CTR_11BIT_RACH_REQUESTS);
Mrinal Mishraf86307e2016-11-10 18:16:30 +0530846
Philipp Maier1275a3f2017-02-21 19:35:23 +0100847 /* Determine full frame number */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100848 uint32_t Fn = bts_rfn_to_fn(bts, rip->rfn);
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700849 uint8_t ta = qta2ta(rip->qta);
Philippd935d882016-11-07 13:07:36 +0100850
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100851 bts_send_gsmtap_rach(bts, PCU_GSMTAP_C_UL_RACH, GSMTAP_CHANNEL_RACH, rip);
Pau Espin Pedrol1ec211f2019-09-30 18:33:14 +0200852
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700853 LOGP(DRLCMAC, LOGL_DEBUG, "MS requests Uplink resource on CCCH/RACH: "
854 "ra=0x%02x (%d bit) Fn=%u qta=%d\n", rip->ra,
855 rip->is_11bit ? 11 : 8, Fn, rip->qta);
bhargava628dcfb2016-09-14 20:30:31 +0530856
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700857 /* Parse [EGPRS Packet] Channel Request from RACH.ind */
858 rc = parse_rach_ind(rip, &chan_req);
859 if (rc) /* Send RR Immediate Assignment Reject */
860 goto send_imm_ass_rej;
bhargava628dcfb2016-09-14 20:30:31 +0530861
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700862 if (chan_req.single_block)
863 LOGP(DRLCMAC, LOGL_DEBUG, "MS requests single block allocation\n");
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100864 else if (bts->pcu->vty.force_two_phase) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700865 LOGP(DRLCMAC, LOGL_DEBUG, "MS requests single block allocation, "
866 "but we force two phase access\n");
867 chan_req.single_block = true;
868 }
869
Vadim Yanitskiyb90d34b2020-05-21 20:20:34 +0700870 /* TODO: handle Radio Priority (see 3GPP TS 44.060, table 11.2.5a.5) */
871 if (chan_req.priority > 0)
872 LOGP(DRLCMAC, LOGL_NOTICE, "EGPRS Packet Channel Request indicates "
873 "Radio Priority %u, however we ignore it\n", chan_req.priority);
874
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700875 /* Should we allocate a single block or an Uplink TBF? */
876 if (chan_req.single_block) {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100877 rc = bts_sba(bts)->alloc(&trx_no, &ts_no, &sb_fn, ta);
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530878 if (rc < 0) {
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530879 LOGP(DRLCMAC, LOGL_NOTICE, "No PDCH resource for "
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700880 "single block allocation: rc=%d\n", rc);
881 /* Send RR Immediate Assignment Reject */
882 goto send_imm_ass_rej;
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530883 }
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700884
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100885 tsc = bts->trx[trx_no].pdch[ts_no].tsc;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700886 LOGP(DRLCMAC, LOGL_DEBUG, "Allocated a single block at "
887 "SBFn=%u TRX=%u TS=%u\n", sb_fn, trx_no, ts_no);
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200888 } else {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100889 GprsMs *ms = bts_alloc_ms(bts, 0, chan_req.egprs_mslot_class);
890 tbf = tbf_alloc_ul_tbf(bts, ms, -1, true);
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200891 if (!tbf) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700892 LOGP(DRLCMAC, LOGL_NOTICE, "No PDCH resource for Uplink TBF\n");
893 /* Send RR Immediate Assignment Reject */
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530894 rc = -EBUSY;
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700895 goto send_imm_ass_rej;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200896 }
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700897
898 /* FIXME: Copy and paste with other routines.. */
899 tbf->set_ta(ta);
900 TBF_SET_STATE(tbf, GPRS_RLCMAC_FLOW);
901 TBF_ASS_TYPE_SET(tbf, GPRS_RLCMAC_FLAG_CCCH);
902 T_START(tbf, T3169, 3169, "RACH (new UL-TBF)", true);
903 trx_no = tbf->trx->trx_no;
904 ts_no = tbf->first_ts;
905 usf = tbf->m_usf[ts_no];
906 tsc = tbf->tsc();
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200907 }
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100908
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700909send_imm_ass_rej:
910 /* Allocate a bit-vector for RR Immediate Assignment [Reject] */
911 struct bitvec *bv = bitvec_alloc(22, tall_pcu_ctx); /* without plen */
Vadim Yanitskiyeb1e0fa2020-07-18 20:33:08 +0700912 bitvec_unhex(bv, DUMMY_VEC); /* standard '2B'O padding */
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +0100913
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700914 if (rc != 0) {
915 LOGP(DRLCMAC, LOGL_DEBUG, "Tx Immediate Assignment Reject on AGCH\n");
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530916 plen = Encoding::write_immediate_assignment_reject(
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700917 bv, rip->ra, Fn, rip->burst_type);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100918 bts_do_rate_ctr_inc(bts, CTR_IMMEDIATE_ASSIGN_REJ);
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700919 } else {
920 LOGP(DRLCMAC, LOGL_DEBUG, "Tx Immediate Assignment on AGCH: "
921 "TRX=%u (ARFCN %u) TS=%u TA=%u TSC=%u TFI=%d USF=%d\n",
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100922 trx_no, bts->trx[trx_no].arfcn & ~ARFCN_FLAG_MASK,
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700923 ts_no, ta, tsc, tbf ? tbf->tfi() : -1, usf);
924 plen = Encoding::write_immediate_assignment(
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100925 &bts->trx[trx_no].pdch[ts_no], tbf, bv,
Vadim Yanitskiy11567762020-07-18 23:34:17 +0700926 false, rip->ra, Fn, ta, usf, false, sb_fn,
Pau Espin Pedrolfe8de452021-02-09 18:47:34 +0100927 bts_get_ms_pwr_alpha(bts), bts->pcu->vty.gamma, -1,
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700928 rip->burst_type);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100929 bts_do_rate_ctr_inc(bts, CTR_IMMEDIATE_ASSIGN_UL_TBF);
Mrinal Mishraf86307e2016-11-10 18:16:30 +0530930 }
Jacob Erlbeck2647a332016-02-01 16:13:38 +0100931
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700932 if (plen >= 0)
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100933 pcu_l1if_tx_agch(bts, bv, plen);
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700934 else
935 rc = plen;
936
937 bitvec_free(bv);
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200938
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530939 return rc;
Holger Hans Peter Freyther02beed52013-10-26 20:56:20 +0200940}
941
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700942/* PTCCH/U sub-slot / frame-number mapping (see 3GPP TS 45.002, table 6) */
943static uint32_t ptcch_slot_map[PTCCH_TAI_NUM] = {
944 12, 38, 64, 90,
945 116, 142, 168, 194,
946 220, 246, 272, 298,
947 324, 350, 376, 402,
948};
949
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100950int bts_rcv_ptcch_rach(struct gprs_rlcmac_bts *bts, const struct rach_ind_params *rip)
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700951{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100952 uint32_t fn416 = bts_rfn_to_fn(bts, rip->rfn) % 416;
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700953 struct gprs_rlcmac_pdch *pdch;
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700954 uint8_t ss;
955
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100956 bts_send_gsmtap_rach(bts, PCU_GSMTAP_C_UL_PTCCH, GSMTAP_CHANNEL_PTCCH, rip);
Vadim Yanitskiy07b64872020-06-11 00:26:15 +0700957
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700958 /* Prevent buffer overflow */
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700959 if (rip->trx_nr >= ARRAY_SIZE(bts->trx) || rip->ts_nr >= 8) {
960 LOGP(DRLCMAC, LOGL_ERROR, "(TRX=%u TS=%u RFN=%u) Rx malformed "
961 "RACH.ind (PTCCH/U)\n", rip->trx_nr, rip->ts_nr, rip->rfn);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700962 return -EINVAL;
963 }
964
965 /* Make sure PDCH time-slot is enabled */
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700966 pdch = &bts->trx[rip->trx_nr].pdch[rip->ts_nr];
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700967 if (!pdch->m_is_enabled) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700968 LOGP(DRLCMAC, LOGL_NOTICE, "(TRX=%u TS=%u RFN=%u) Rx RACH.ind (PTCCH/U) "
969 "for inactive PDCH\n", rip->trx_nr, rip->ts_nr, rip->rfn);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700970 return -EAGAIN;
971 }
972
973 /* Convert TDMA frame-number to PTCCH/U sub-slot number */
974 for (ss = 0; ss < PTCCH_TAI_NUM; ss++)
975 if (ptcch_slot_map[ss] == fn416)
976 break;
977 if (ss == PTCCH_TAI_NUM) {
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700978 LOGP(DRLCMAC, LOGL_ERROR, "(TRX=%u TS=%u RFN=%u) Failed to map "
979 "PTCCH/U sub-slot\n", rip->trx_nr, rip->ts_nr, rip->rfn);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700980 return -ENODEV;
981 }
982
983 /* Apply the new Timing Advance value */
984 LOGP(DRLCMAC, LOGL_INFO, "Continuous Timing Advance update "
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700985 "for TAI %u, new TA is %u\n", ss, qta2ta(rip->qta));
986 pdch->update_ta(ss, qta2ta(rip->qta));
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700987
988 return 0;
989}
990
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100991void 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 +0200992{
Vadim Yanitskiy11567762020-07-18 23:34:17 +0700993 uint8_t trx_no = tbf->trx->trx_no;
994 uint8_t ts_no = tbf->first_ts;
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +0200995 int plen;
996
Maxc21f0072017-12-15 17:36:45 +0100997 LOGPTBF(tbf, LOGL_INFO, "TX: START Immediate Assignment Downlink (PCH)\n");
Alexander Couzensccde5c92017-02-04 03:10:08 +0100998 bitvec *immediate_assignment = bitvec_alloc(22, tall_pcu_ctx); /* without plen */
Vadim Yanitskiyeb1e0fa2020-07-18 20:33:08 +0700999 bitvec_unhex(immediate_assignment, DUMMY_VEC); /* standard '2B'O padding */
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +02001000 /* use request reference that has maximum distance to current time,
1001 * so the assignment will not conflict with possible RACH requests. */
Jacob Erlbeck2ca86af2016-01-20 18:26:13 +01001002 LOGP(DRLCMAC, LOGL_DEBUG, " - TRX=%d (%d) TS=%d TA=%d pollFN=%d\n",
Vadim Yanitskiy11567762020-07-18 23:34:17 +07001003 trx_no, tbf->trx->arfcn, ts_no, tbf->ta(), poll ? tbf->poll_fn : -1);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001004 plen = Encoding::write_immediate_assignment(&bts->trx[trx_no].pdch[ts_no],
Vadim Yanitskiy11567762020-07-18 23:34:17 +07001005 tbf, immediate_assignment, true, 125,
1006 (tbf->pdch[ts_no]->last_rts_fn + 21216) % GSM_MAX_FN,
1007 tbf->ta(), 7, poll, tbf->poll_fn,
Pau Espin Pedrolfe8de452021-02-09 18:47:34 +01001008 bts_get_ms_pwr_alpha(bts), bts->pcu->vty.gamma, -1,
Maxfc8afc22019-02-18 18:52:38 +01001009 GSM_L1_BURST_TYPE_ACCESS_0);
Mrinal Mishraf86307e2016-11-10 18:16:30 +05301010 if (plen >= 0) {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001011 bts_do_rate_ctr_inc(bts, CTR_IMMEDIATE_ASSIGN_DL_TBF);
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +01001012 pcu_l1if_tx_pch(bts, immediate_assignment, plen, pgroup);
Mrinal Mishraf86307e2016-11-10 18:16:30 +05301013 }
1014
Holger Hans Peter Freytherd9262b32013-10-26 20:12:59 +02001015 bitvec_free(immediate_assignment);
1016}
1017
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001018/* return maximum DL CS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001019uint8_t bts_max_cs_dl(const struct gprs_rlcmac_bts* bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001020{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001021 return bts->max_cs_dl;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001022}
1023
1024/* return maximum UL CS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001025uint8_t bts_max_cs_ul(const struct gprs_rlcmac_bts* bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001026{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001027 return bts->max_cs_ul;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001028}
1029
1030/* return maximum DL MCS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001031uint8_t bts_max_mcs_dl(const struct gprs_rlcmac_bts* bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001032{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001033 return bts->max_mcs_dl;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001034}
1035
1036/* return maximum UL MCS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001037uint8_t bts_max_mcs_ul(const struct gprs_rlcmac_bts* bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001038{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001039 return bts->max_mcs_ul;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001040}
1041
1042/* Set maximum DL CS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001043void bts_set_max_cs_dl(struct gprs_rlcmac_bts* bts, uint8_t cs_dl)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001044{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001045 bts->max_cs_dl = cs_dl;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001046}
1047
1048/* Set maximum UL CS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001049void bts_set_max_cs_ul(struct gprs_rlcmac_bts* bts, uint8_t cs_ul)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001050{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001051 bts->max_cs_ul = cs_ul;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001052}
1053
1054/* Set maximum DL MCS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001055void bts_set_max_mcs_dl(struct gprs_rlcmac_bts* bts, uint8_t mcs_dl)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001056{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001057 bts->max_mcs_dl = mcs_dl;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001058}
1059
1060/* Set maximum UL MCS supported by BTS and allowed by VTY */
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001061void bts_set_max_mcs_ul(struct gprs_rlcmac_bts* bts, uint8_t mcs_ul)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001062{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001063 bts->max_mcs_ul = mcs_ul;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001064}
Holger Hans Peter Freytherd11290b2013-10-26 17:32:04 +02001065
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001066bool bts_cs_dl_is_supported(const struct gprs_rlcmac_bts* bts, CodingScheme cs)
Pau Espin Pedrol022f9e52020-11-16 18:49:39 +01001067{
1068 OSMO_ASSERT(mcs_is_valid(cs));
1069 uint8_t num = mcs_chan_code(cs);
1070 if (mcs_is_gprs(cs)) {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001071 return (bts_max_cs_dl(bts) >= num) && (bts->cs_mask & (1U << num));
Pau Espin Pedrol022f9e52020-11-16 18:49:39 +01001072 } else {
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001073 return (bts_max_mcs_dl(bts) >= num) && (bts->mcs_mask & (1U << num));
Pau Espin Pedrol022f9e52020-11-16 18:49:39 +01001074 }
1075}
1076
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001077GprsMs *bts_alloc_ms(struct gprs_rlcmac_bts* bts, uint8_t ms_class, uint8_t egprs_ms_class)
Jacob Erlbeckcb1b4942015-06-19 10:59:58 +02001078{
1079 GprsMs *ms;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001080 ms = bts_ms_store(bts)->create_ms();
Jacob Erlbeckcb1b4942015-06-19 10:59:58 +02001081
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001082 ms_set_timeout(ms, osmo_tdef_get(bts->pcu->T_defs, -2030, OSMO_TDEF_S, -1));
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001083 ms_set_ms_class(ms, ms_class);
1084 ms_set_egprs_ms_class(ms, egprs_ms_class);
Jacob Erlbeckcb1b4942015-06-19 10:59:58 +02001085
1086 return ms;
1087}
1088
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001089struct SBAController *bts_sba(struct gprs_rlcmac_bts *bts)
1090{
1091 return bts->sba;
1092}
1093
1094struct GprsMsStorage *bts_ms_store(struct gprs_rlcmac_bts *bts)
1095{
1096 return bts->ms_store;
1097}
1098
1099struct GprsMs *bts_ms_by_tlli(struct gprs_rlcmac_bts *bts, uint32_t tlli, uint32_t old_tlli)
1100{
1101 return bts_ms_store(bts)->get_ms(tlli, old_tlli);
1102}
1103
Minh-Quang Nguyen1bcfa9a2017-11-01 14:41:37 -04001104/* update TA based on TA provided by PH-DATA-IND */
1105void update_tbf_ta(struct gprs_rlcmac_ul_tbf *tbf, int8_t ta_delta)
1106{
1107 int16_t ta_adj;
1108 uint8_t ta_target;
1109
1110 if (ta_delta) {
1111 /* adjust TA based on TA provided by PH-DATA-IND */
1112 ta_adj = tbf->ta() + ta_delta;
1113
1114 /* limit target TA in range 0..63 bits */
1115 ta_target = ta_limit(ta_adj);
1116
1117 LOGP(DL1IF, LOGL_INFO, "PH-DATA-IND is updating TLLI=0x%08x: TA %u -> %u on "
1118 "TRX = %d, TS = %d, FN = %d\n",
1119 tbf->tlli(), tbf->ta(), ta_target,
1120 tbf->trx->trx_no , tbf->poll_ts, tbf->poll_fn);
1121 tbf->set_ta(ta_target);
1122 }
1123}
1124
1125/* set TA based on TA provided by PH-RA-IND */
1126void set_tbf_ta(struct gprs_rlcmac_ul_tbf *tbf, uint8_t ta)
1127{
1128 uint8_t ta_target;
1129
1130 if (tbf->ta() != ta) {
1131 /* limit target TA in range 0..63 bits */
1132 ta_target = ta_limit(ta);
1133
1134 LOGP(DL1IF, LOGL_INFO, "PH-RA-IND is updating TLLI=0x%08x: TA %u -> %u on "
1135 "TRX = %d, TS = %d, FN = %d\n",
1136 tbf->tlli(), tbf->ta(), ta_target,
1137 tbf->trx->trx_no , tbf->poll_ts, tbf->poll_fn);
1138 tbf->set_ta(ta_target);
1139 }
1140}
1141
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +01001142void bts_update_tbf_ta(struct gprs_rlcmac_bts *bts, const char *p, uint32_t fn,
1143 uint8_t trx_no, uint8_t ts, int8_t ta, bool is_rach)
Maxd71e8b32016-09-19 16:17:06 +02001144{
1145 struct gprs_rlcmac_ul_tbf *tbf =
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +01001146 bts_ul_tbf_by_poll_fn(bts, fn, trx_no, ts);
Maxd71e8b32016-09-19 16:17:06 +02001147 if (!tbf)
1148 LOGP(DL1IF, LOGL_DEBUG, "[%s] update TA = %u ignored due to "
1149 "unknown UL TBF on TRX = %d, TS = %d, FN = %d\n",
1150 p, ta, trx_no, ts, fn);
Minh-Quang Nguyen1bcfa9a2017-11-01 14:41:37 -04001151 else {
1152 /* we need to distinguish TA information provided by L1
1153 * from PH-DATA-IND and PHY-RA-IND so that we can properly
1154 * update TA for given TBF
1155 */
1156 if (is_rach)
1157 set_tbf_ta(tbf, (uint8_t)ta);
1158 else
1159 update_tbf_ta(tbf, ta);
1160
Maxd71e8b32016-09-19 16:17:06 +02001161 }
1162}
1163
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001164void bts_trx_reserve_slots(struct gprs_rlcmac_trx *trx, enum gprs_rlcmac_tbf_direction dir,
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001165 uint8_t slots)
1166{
1167 unsigned i;
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001168 for (i = 0; i < ARRAY_SIZE(trx->pdch); i += 1)
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001169 if (slots & (1 << i))
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001170 trx->pdch[i].reserve(dir);
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001171}
1172
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001173void bts_trx_unreserve_slots(struct gprs_rlcmac_trx *trx, enum gprs_rlcmac_tbf_direction dir,
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001174 uint8_t slots)
1175{
1176 unsigned i;
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001177 for (i = 0; i < ARRAY_SIZE(trx->pdch); i += 1)
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001178 if (slots & (1 << i))
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001179 trx->pdch[i].unreserve(dir);
Jacob Erlbeck23f93a12015-06-30 08:52:54 +02001180}
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001181
Pau Espin Pedrol793583e2021-01-14 16:20:57 +01001182void bts_recalc_initial_cs(struct gprs_rlcmac_bts *bts)
1183{
1184 uint8_t max_cs_dl, max_cs_ul;
1185
1186 if (the_pcu->vty.force_initial_cs) {
1187 bts->initial_cs_dl = the_pcu->vty.initial_cs_dl;
1188 bts->initial_cs_ul = the_pcu->vty.initial_cs_ul;
1189 return;
1190 }
1191
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001192 max_cs_dl = bts_max_cs_dl(bts);
Pau Espin Pedrol793583e2021-01-14 16:20:57 +01001193 if (bts->pcuif_info_ind.initial_cs > max_cs_dl) {
1194 LOGP(DL1IF, LOGL_DEBUG, " downgrading initial_cs_dl to %d\n", max_cs_dl);
1195 bts->initial_cs_dl = max_cs_dl;
1196 } else {
1197 bts->initial_cs_dl = bts->pcuif_info_ind.initial_cs;
1198 }
1199 if (bts->initial_cs_dl == 0)
1200 bts->initial_cs_dl = 1; /* CS1 Must always be supported */
1201
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001202 max_cs_ul = bts_max_cs_ul(bts);
Pau Espin Pedrol793583e2021-01-14 16:20:57 +01001203 if (bts->pcuif_info_ind.initial_cs > max_cs_ul) {
1204 LOGP(DL1IF, LOGL_DEBUG, " downgrading initial_cs_ul to %d\n", max_cs_ul);
1205 bts->initial_cs_ul = max_cs_ul;
1206 } else {
1207 bts->initial_cs_ul = bts->pcuif_info_ind.initial_cs;
1208 }
1209 if (bts->initial_cs_ul == 0)
1210 bts->initial_cs_ul = 1; /* CS1 Must always be supported */
1211}
1212void bts_recalc_initial_mcs(struct gprs_rlcmac_bts *bts)
1213{
1214 uint8_t max_mcs_dl, max_mcs_ul;
1215
1216 if (the_pcu->vty.force_initial_mcs) {
1217 bts->initial_mcs_dl = the_pcu->vty.initial_mcs_dl;
1218 bts->initial_mcs_ul = the_pcu->vty.initial_mcs_ul;
1219 return;
1220 }
1221
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001222 max_mcs_dl = bts_max_mcs_dl(bts);
Pau Espin Pedrol793583e2021-01-14 16:20:57 +01001223 if (bts->pcuif_info_ind.initial_mcs > max_mcs_dl) {
1224 LOGP(DL1IF, LOGL_DEBUG, " downgrading initial_mcs_dl to %d\n", max_mcs_dl);
1225 bts->initial_mcs_dl = max_mcs_dl;
1226 } else {
1227 bts->initial_mcs_dl = bts->pcuif_info_ind.initial_mcs;
1228 }
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001229 max_mcs_ul = bts_max_mcs_ul(bts);
Pau Espin Pedrol793583e2021-01-14 16:20:57 +01001230 if (bts->pcuif_info_ind.initial_mcs > max_mcs_ul) {
1231 LOGP(DL1IF, LOGL_DEBUG, " downgrading initial_mcs_ul to %d\n", max_mcs_ul);
1232 bts->initial_mcs_ul = max_mcs_ul;
1233 } else {
1234 bts->initial_mcs_ul = bts->pcuif_info_ind.initial_mcs;
1235 }
1236}
1237
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001238void bts_recalc_max_cs(struct gprs_rlcmac_bts *bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001239{
1240 int i;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001241 uint8_t cs_dl, cs_ul;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001242 struct gprs_pcu *pcu = bts->pcu;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001243
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001244 cs_dl = 0;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001245 for (i = pcu->vty.max_cs_dl - 1; i >= 0; i--) {
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001246 if (bts->cs_mask & (1 << i)) {
1247 cs_dl = i + 1;
1248 break;
1249 }
1250 }
1251
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001252 cs_ul = 0;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001253 for (i = pcu->vty.max_cs_ul - 1; i >= 0; i--) {
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001254 if (bts->cs_mask & (1 << i)) {
1255 cs_ul = i + 1;
1256 break;
1257 }
1258 }
1259
1260 LOGP(DRLCMAC, LOGL_DEBUG, "New max CS: DL=%u UL=%u\n", cs_dl, cs_ul);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001261 bts_set_max_cs_dl(bts, cs_dl);
1262 bts_set_max_cs_ul(bts, cs_ul);
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001263}
1264
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001265void bts_recalc_max_mcs(struct gprs_rlcmac_bts *bts)
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001266{
1267 int i;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001268 uint8_t mcs_dl, mcs_ul;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001269 struct gprs_pcu *pcu = bts->pcu;
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001270
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001271 mcs_dl = 0;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001272 for (i = pcu->vty.max_mcs_dl - 1; i >= 0; i--) {
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001273 if (bts->mcs_mask & (1 << i)) {
1274 mcs_dl = i + 1;
1275 break;
1276 }
1277 }
1278
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001279 mcs_ul = 0;
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +01001280 for (i = pcu->vty.max_mcs_ul - 1; i >= 0; i--) {
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001281 if (bts->mcs_mask & (1 << i)) {
1282 mcs_ul = i + 1;
1283 break;
1284 }
1285 }
1286
1287 LOGP(DRLCMAC, LOGL_DEBUG, "New max MCS: DL=%u UL=%u\n", mcs_dl, mcs_ul);
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001288 bts_set_max_mcs_dl(bts, mcs_dl);
1289 bts_set_max_mcs_ul(bts, mcs_ul);
Pau Espin Pedrol343ec9b2020-10-30 18:35:54 +01001290}
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001291
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001292struct GprsMs *bts_ms_by_imsi(struct gprs_rlcmac_bts *bts, const char *imsi)
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001293{
Pau Espin Pedrol2182e622021-01-14 16:48:38 +01001294 return bts_ms_store(bts)->get_ms(0, 0, imsi);
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +01001295}
Pau Espin Pedrolc0a250d2021-01-21 18:46:13 +01001296
1297const struct llist_head* bts_ms_list(struct gprs_rlcmac_bts *bts)
1298{
1299 return bts_ms_store(bts)->ms_list();
1300}
Pau Espin Pedrolfe8de452021-02-09 18:47:34 +01001301
1302uint8_t bts_get_ms_pwr_alpha(const struct gprs_rlcmac_bts *bts)
1303{
1304 if (bts->pcu->vty.force_alpha != (uint8_t)-1)
1305 return bts->pcu->vty.force_alpha;
1306 if (bts->si13_is_set)
1307 return bts->si31_ro_decoded.pwr_ctrl_pars.alpha;
1308 /* default if no SI13 is received yet: closed loop control, TS 44.060
1309 * B.2 Closed loop control */
1310 return 0;
1311}