blob: cfd36d77e5774ba8c62b40f4ba55827392890aa3 [file] [log] [blame]
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +04001/* pcu_l1_if.cpp
2 *
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +04003 * Copyright (C) 2012 Andreas Eversberg <jolly@eversberg.eu>
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +04004 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 */
19
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +040020#include <stdio.h>
21#include <unistd.h>
Pau Espin Pedrol32499b62019-12-09 13:55:12 +010022#include <inttypes.h>
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +040023#include <stdlib.h>
Andreas Eversberg0aed6542012-06-23 10:33:16 +020024#include <string.h>
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +040025#include <errno.h>
26#include <assert.h>
Andreas Eversberg0aed6542012-06-23 10:33:16 +020027#include <sys/socket.h>
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +040028#include <sys/un.h>
Andreas Eversberg81a12be2013-03-16 16:16:41 +010029#include <arpa/inet.h>
Pau Espin Pedrol754b0932020-03-26 14:47:13 +010030#include <ctype.h>
Max1187a772018-01-26 13:31:42 +010031
Andreas Eversberg0aed6542012-06-23 10:33:16 +020032extern "C" {
33#include <osmocom/core/talloc.h>
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +040034#include <osmocom/core/select.h>
35#include <osmocom/core/msgb.h>
Max528ff392016-02-22 11:42:33 +010036#include <osmocom/core/gsmtap_util.h>
37#include <osmocom/core/gsmtap.h>
Max1187a772018-01-26 13:31:42 +010038#include <osmocom/core/bitvec.h>
Alexander Couzens290d9032020-09-16 21:52:02 +020039#include <osmocom/core/sockaddr_str.h>
Max1187a772018-01-26 13:31:42 +010040#include <osmocom/core/logging.h>
41#include <osmocom/core/utils.h>
Alexander Couzens5bece2a2020-10-12 02:27:22 +020042#include <osmocom/gprs/gprs_ns2.h>
Max1187a772018-01-26 13:31:42 +010043#include <osmocom/gsm/l1sap.h>
44#include <osmocom/gsm/protocol/gsm_04_08.h>
Pau Espin Pedrolfe8de452021-02-09 18:47:34 +010045#include <osmocom/gsm/gsm48_rest_octets.h>
Philipp Maiera58ec612021-01-25 23:43:52 +010046#include <osmocom/gsm/sysinfo.h>
Andreas Eversberg0aed6542012-06-23 10:33:16 +020047}
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +040048
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +040049#include <gprs_rlcmac.h>
50#include <pcu_l1_if.h>
51#include <gprs_debug.h>
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +040052#include <gprs_bssgp_pcu.h>
Harald Welte68fc1272016-11-16 22:48:33 +010053#include <osmocom/pcu/pcuif_proto.h>
Holger Hans Peter Freyther67ed34e2013-10-17 17:01:54 +020054#include <bts.h>
Max6dc90b82018-02-19 17:17:28 +010055#include <pdch.h>
Pau Espin Pedrolbd9973a2020-09-22 15:57:37 +020056#include <tbf_ul.h>
57#include <tbf_dl.h>
Pau Espin Pedrol2182e622021-01-14 16:48:38 +010058#include <gprs_ms_storage.h>
Andreas Eversberg0aed6542012-06-23 10:33:16 +020059
Andreas Eversberga23c7ee2012-12-18 10:47:28 +010060// FIXME: move this, when changed from c++ to c.
61extern "C" {
Max58b66462016-05-13 10:34:15 +020062void *l1if_open_pdch(uint8_t trx_no, uint32_t hlayer1,
63 struct gsmtap_inst *gsmtap);
Andreas Eversberga23c7ee2012-12-18 10:47:28 +010064int l1if_connect_pdch(void *obj, uint8_t ts);
65int l1if_pdch_req(void *obj, uint8_t ts, int is_ptcch, uint32_t fn,
66 uint16_t arfcn, uint8_t block_nr, uint8_t *data, uint8_t len);
67}
68
Andreas Eversberge266bd42012-07-13 14:00:21 +020069extern void *tall_pcu_ctx;
70
Pau Espin Pedrold7c32652019-12-23 12:41:34 +010071#define PAGING_GROUP_LEN 3
72
73/* returns [0,999] on success, > 999 on error */
74uint16_t imsi2paging_group(const char* imsi)
75{
76 uint16_t pgroup = 0;
Vadim Yanitskiybd0b0b32020-01-16 00:25:48 +070077 size_t len;
Pau Espin Pedrold7c32652019-12-23 12:41:34 +010078
Vadim Yanitskiybd0b0b32020-01-16 00:25:48 +070079 len = (imsi != NULL) ? strlen(imsi) : 0;
80 if (len < PAGING_GROUP_LEN)
Pau Espin Pedrold7c32652019-12-23 12:41:34 +010081 return 0xFFFF;
82 imsi += len - PAGING_GROUP_LEN;
83
84 while (*imsi != '\0') {
85 if (!isdigit(*imsi))
86 return 0xFFFF;
87 pgroup *= 10;
88 pgroup += *imsi - '0';
89 imsi++;
90 }
91 return pgroup;
92}
93
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +040094/*
95 * PCU messages
96 */
Ivan Kluchnikove3a05962012-03-18 15:48:51 +040097
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +040098struct msgb *pcu_msgb_alloc(uint8_t msg_type, uint8_t bts_nr)
99{
100 struct msgb *msg;
101 struct gsm_pcu_if *pcu_prim;
102
103 msg = msgb_alloc(sizeof(struct gsm_pcu_if), "pcu_sock_tx");
104 if (!msg)
105 return NULL;
106 msgb_put(msg, sizeof(struct gsm_pcu_if));
107 pcu_prim = (struct gsm_pcu_if *) msg->data;
108 pcu_prim->msg_type = msg_type;
109 pcu_prim->bts_nr = bts_nr;
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400110
111 return msg;
112}
113
Max0a8fae82017-03-08 18:53:30 +0100114const struct value_string gsm_pcu_if_text_type_names[] = {
115 OSMO_VALUE_STRING(PCU_VERSION),
116 OSMO_VALUE_STRING(PCU_OML_ALERT),
117 { 0, NULL }
118};
119
120int pcu_tx_txt_ind(enum gsm_pcu_if_text_type t, const char *fmt, ...)
121{
122 struct gsm_pcu_if *pcu_prim;
123 struct gsm_pcu_if_txt_ind *txt;
124 va_list ap;
125 char *rep;
126 struct msgb *msg = pcu_msgb_alloc(PCU_IF_MSG_TXT_IND, 0);
127 if (!msg)
128 return -ENOMEM;
129
130 pcu_prim = (struct gsm_pcu_if *) msg->data;
131 txt = &pcu_prim->u.txt_ind;
132 txt->type = t;
133
134 va_start(ap, fmt);
135 rep = talloc_vasprintf(tall_pcu_ctx, fmt, ap);
136 va_end(ap);
137
138 if (!rep)
139 return -ENOMEM;
140
141 osmo_strlcpy(txt->text, rep, TXT_MAX_LEN);
142 talloc_free(rep);
143
144 LOGP(DL1IF, LOGL_INFO, "Sending %s TXT as %s to BTS\n", txt->text,
145 get_value_string(gsm_pcu_if_text_type_names, t));
146
147 return pcu_sock_send(msg);
148}
149
Pau Espin Pedroldf58ddf2021-03-09 16:19:22 +0100150static int pcu_tx_act_req(struct gprs_rlcmac_bts *bts, const struct gprs_rlcmac_pdch *pdch,
151 uint8_t activate)
Ivan Kluchnikov4277f0c2012-04-12 14:24:35 +0400152{
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400153 struct msgb *msg;
154 struct gsm_pcu_if *pcu_prim;
155 struct gsm_pcu_if_act_req *act_req;
156
Pau Espin Pedroldf58ddf2021-03-09 16:19:22 +0100157 LOGPDCH(pdch, DL1IF, LOGL_INFO, "Sending %s request\n",
158 (activate) ? "activate" : "deactivate");
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400159
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100160 msg = pcu_msgb_alloc(PCU_IF_MSG_ACT_REQ, bts->nr);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400161 if (!msg)
162 return -ENOMEM;
163 pcu_prim = (struct gsm_pcu_if *) msg->data;
164 act_req = &pcu_prim->u.act_req;
165 act_req->activate = activate;
Pau Espin Pedroldf58ddf2021-03-09 16:19:22 +0100166 act_req->trx_nr = pdch->trx_no();
167 act_req->ts_nr = pdch->ts_no;
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400168
169 return pcu_sock_send(msg);
170}
171
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100172static int pcu_tx_data_req(struct gprs_rlcmac_bts *bts, uint8_t trx, uint8_t ts, uint8_t sapi,
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400173 uint16_t arfcn, uint32_t fn, uint8_t block_nr, uint8_t *data,
174 uint8_t len)
175{
176 struct msgb *msg;
177 struct gsm_pcu_if *pcu_prim;
178 struct gsm_pcu_if_data *data_req;
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100179 int current_fn = bts_current_frame_number(bts);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400180
Pau Espin Pedroldf58ddf2021-03-09 16:19:22 +0100181 LOGP(DL1IF, LOGL_DEBUG, "(bts=%u,trx=%u,ts=%u) FN=%u Sending data request: sapi=%d "
182 "arfcn=%d cur_fn=%d block=%d data=%s\n", bts->nr, trx, ts, fn, sapi,
183 arfcn, current_fn, block_nr, osmo_hexdump(data, len));
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400184
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100185 msg = pcu_msgb_alloc(PCU_IF_MSG_DATA_REQ, bts->nr);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400186 if (!msg)
187 return -ENOMEM;
188 pcu_prim = (struct gsm_pcu_if *) msg->data;
189 data_req = &pcu_prim->u.data_req;
190
191 data_req->sapi = sapi;
192 data_req->fn = fn;
193 data_req->arfcn = arfcn;
194 data_req->trx_nr = trx;
195 data_req->ts_nr = ts;
196 data_req->block_nr = block_nr;
197 memcpy(data_req->data, data, len);
198 data_req->len = len;
199
200 return pcu_sock_send(msg);
201}
202
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100203void pcu_l1if_tx_pdtch(msgb *msg, struct gprs_rlcmac_bts *bts, uint8_t trx, uint8_t ts, uint16_t arfcn,
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400204 uint32_t fn, uint8_t block_nr)
205{
Maxb216c6b2017-09-01 11:00:39 +0200206#ifdef ENABLE_DIRECT_PHY
Max528ff392016-02-22 11:42:33 +0100207 if (bts->trx[trx].fl1h) {
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100208 l1if_pdch_req(bts->trx[trx].fl1h, ts, 0, fn, arfcn, block_nr,
209 msg->data, msg->len);
Max528ff392016-02-22 11:42:33 +0100210 msgb_free(msg);
211 return;
212 }
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100213#endif
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100214 pcu_tx_data_req(bts, trx, ts, PCU_IF_SAPI_PDTCH, arfcn, fn, block_nr,
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100215 msg->data, msg->len);
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200216 msgb_free(msg);
Ivan Kluchnikov4277f0c2012-04-12 14:24:35 +0400217}
218
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100219void pcu_l1if_tx_ptcch(struct gprs_rlcmac_bts *bts,
220 uint8_t trx, uint8_t ts, uint16_t arfcn,
Vadim Yanitskiy78f58612019-10-05 22:22:08 +0700221 uint32_t fn, uint8_t block_nr,
222 uint8_t *data, size_t data_len)
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400223{
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100224 if (the_pcu->gsmtap_categ_mask & (1 << PCU_GSMTAP_C_DL_PTCCH))
225 gsmtap_send(the_pcu->gsmtap, arfcn, ts, GSMTAP_CHANNEL_PTCCH, 0, fn, 0, 0, data, data_len);
Maxcad867e2016-04-21 14:35:55 +0200226#ifdef ENABLE_DIRECT_PHY
Max528ff392016-02-22 11:42:33 +0100227 if (bts->trx[trx].fl1h) {
Vadim Yanitskiy78f58612019-10-05 22:22:08 +0700228 l1if_pdch_req(bts->trx[trx].fl1h, ts, 1, fn, arfcn, block_nr, data, data_len);
Max528ff392016-02-22 11:42:33 +0100229 return;
230 }
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100231#endif
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100232 pcu_tx_data_req(bts, trx, ts, PCU_IF_SAPI_PTCCH, arfcn, fn, block_nr, data, data_len);
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400233}
234
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100235void pcu_l1if_tx_agch(struct gprs_rlcmac_bts *bts, bitvec * block, int plen)
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400236{
Pau Espin Pedrold752d7c2019-10-07 20:56:48 +0200237 uint8_t data[GSM_MACBLOCK_LEN]; /* prefix PLEN */
238
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400239 /* FIXME: why does OpenBTS has no PLEN and no fill in message? */
240 bitvec_pack(block, data + 1);
241 data[0] = (plen << 2) | 0x01;
Pau Espin Pedrol58543702019-09-30 19:07:16 +0200242
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100243 if (the_pcu->gsmtap_categ_mask & (1 << PCU_GSMTAP_C_DL_AGCH))
244 gsmtap_send(the_pcu->gsmtap, 0, 0, GSMTAP_CHANNEL_AGCH, 0, 0, 0, 0, data, GSM_MACBLOCK_LEN);
Pau Espin Pedrol58543702019-09-30 19:07:16 +0200245
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100246 pcu_tx_data_req(bts, 0, 0, PCU_IF_SAPI_AGCH, 0, 0, 0, data, GSM_MACBLOCK_LEN);
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400247}
248
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100249void pcu_l1if_tx_pch(struct gprs_rlcmac_bts *bts, bitvec * block, int plen, uint16_t pgroup)
Ivan Kluchnikovc7e7f682012-06-29 22:53:15 +0400250{
Pau Espin Pedrol8dc09e72019-10-07 20:56:02 +0200251 uint8_t data[PAGING_GROUP_LEN + GSM_MACBLOCK_LEN];
Pau Espin Pedrold7c32652019-12-23 12:41:34 +0100252 int i;
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400253
Pau Espin Pedrol8dc09e72019-10-07 20:56:02 +0200254 /* prepend paging group */
Pau Espin Pedrold7c32652019-12-23 12:41:34 +0100255 for (i = 0; i < PAGING_GROUP_LEN; i++) {
256 data[PAGING_GROUP_LEN - 1 - i] = '0' + (char)(pgroup % 10);
257 pgroup = pgroup / 10;
258 }
259 OSMO_ASSERT(pgroup == 0);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400260
Pau Espin Pedrol8dc09e72019-10-07 20:56:02 +0200261 /* block provided by upper layer comes without first byte (plen),
262 * prepend it manually:
263 */
264 OSMO_ASSERT(sizeof(data) >= PAGING_GROUP_LEN + 1 + block->data_len);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400265 data[3] = (plen << 2) | 0x01;
Pau Espin Pedrol8dc09e72019-10-07 20:56:02 +0200266 bitvec_pack(block, data + PAGING_GROUP_LEN + 1);
Pau Espin Pedrol58543702019-09-30 19:07:16 +0200267
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100268 if (the_pcu->gsmtap_categ_mask & (1 << PCU_GSMTAP_C_DL_PCH))
269 gsmtap_send(the_pcu->gsmtap, 0, 0, GSMTAP_CHANNEL_PCH, 0, 0, 0, 0, data + 3, GSM_MACBLOCK_LEN);
Pau Espin Pedrol58543702019-09-30 19:07:16 +0200270
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100271 pcu_tx_data_req(bts, 0, 0, PCU_IF_SAPI_PCH, 0, 0, 0, data, PAGING_GROUP_LEN + GSM_MACBLOCK_LEN);
Ivan Kluchnikovc7e7f682012-06-29 22:53:15 +0400272}
273
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100274void pcu_rx_block_time(struct gprs_rlcmac_bts *bts, uint16_t arfcn, uint32_t fn, uint8_t ts_no)
Jacob Erlbeckaf75ce82015-08-26 13:22:28 +0200275{
Pau Espin Pedrolfecab502021-03-17 15:26:37 +0100276 bts_set_current_block_frame_number(bts, fn);
Jacob Erlbeckaf75ce82015-08-26 13:22:28 +0200277}
278
Pau Espin Pedrolc1f31c42021-03-09 14:50:14 +0100279int pcu_rx_data_ind_pdtch(struct gprs_rlcmac_bts *bts, struct gprs_rlcmac_pdch *pdch, uint8_t *data,
Jacob Erlbeck20f6fd12015-06-08 11:05:45 +0200280 uint8_t len, uint32_t fn, struct pcu_l1_meas *meas)
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100281{
Pau Espin Pedrol15c58ac2021-03-08 14:57:58 +0100282 int rc;
283
284 rc = pdch->rcv_block(data, len, fn, meas);
285 pdch_ulc_expire_fn(pdch->ulc, fn);
286 return rc;
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100287}
288
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100289static int pcu_rx_data_ind_bcch(struct gprs_rlcmac_bts *bts, uint8_t *data, uint8_t len)
Max84bf0fa2017-09-01 11:02:40 +0200290{
Pau Espin Pedrolfe8de452021-02-09 18:47:34 +0100291 const uint8_t *si_ro;
Philipp Maiera58ec612021-01-25 23:43:52 +0100292 switch (len) {
293 case 0:
294 /* Due to historical reasons also accept a completely empty message as
295 * revoke command for SI13. */
296 LOGP(DL1IF, LOGL_ERROR,
297 "Received PCU data indication that contains no data -- Revoked SI13.\n");
Max84bf0fa2017-09-01 11:02:40 +0200298 bts->si13_is_set = false;
Max84bf0fa2017-09-01 11:02:40 +0200299
Philipp Maiera58ec612021-01-25 23:43:52 +0100300 return 0;
301 case 1:
302 /* Revoke SI, type is identified by a single byte which is coded after
303 * enum osmo_sysinfo_type. */
304 switch (data[0]) {
305 case SYSINFO_TYPE_1:
306 bts->si1_is_set = false;
307 break;
308 case SYSINFO_TYPE_3:
309 bts->si3_is_set = false;
310 break;
311 case SYSINFO_TYPE_13:
312 bts->si13_is_set = false;
313 break;
314 default:
315 LOGP(DL1IF, LOGL_ERROR,
316 "Received PCU data indication that contains an unsupported system information identifier (%02x,OSMO) -- ignored.\n", data[0]);
317 return -EINVAL;
318 }
319 LOGP(DPCU, LOGL_DEBUG,
320 "Received PCU data indication: Revoked SI%s\n",
321 get_value_string(osmo_sitype_strs, data[0]));
322 return 0;
323 case GSM_MACBLOCK_LEN:
324 /* Update SI, type is identified by the RR sysinfo type, which is the
325 * 3rd byte in the buffer. */
326 switch (data[2]) {
327 case GSM48_MT_RR_SYSINFO_1:
328 memcpy(bts->si1, data, GSM_MACBLOCK_LEN);
329 bts->si1_is_set = true;
330 break;
331 case GSM48_MT_RR_SYSINFO_3:
332 memcpy(bts->si3, data, GSM_MACBLOCK_LEN);
333 bts->si3_is_set = true;
334 break;
335 case GSM48_MT_RR_SYSINFO_13:
336 memcpy(bts->si13, data, GSM_MACBLOCK_LEN);
337 bts->si13_is_set = true;
Pau Espin Pedrolfe8de452021-02-09 18:47:34 +0100338 si_ro = ((struct gsm48_system_information_type_13*)data)->rest_octets;
339 if (osmo_gsm48_rest_octets_si13_decode(&bts->si31_ro_decoded, si_ro) < 0)
340 LOGP(DPCU, LOGL_ERROR, "Error decoding SI13\n");
Philipp Maiera58ec612021-01-25 23:43:52 +0100341 break;
342 default:
343 LOGP(DL1IF, LOGL_ERROR,
344 "Received PCU data indication that contains an unsupported system information identifier (%02x,RR) -- ignored.\n", data[2]);
345 return -EINVAL;
346 }
347 LOGP(DPCU, LOGL_DEBUG,
348 "Received PCU data indication: Updated %s: %s\n",
349 gsm48_pdisc_msgtype_name(data[1], data[2]),
350 osmo_hexdump_nospc(data + 1, GSM_MACBLOCK_LEN));
351 return 0;
352 default:
353 LOGP(DL1IF, LOGL_ERROR,
354 "Received PCU data indication with unexpected data length: %u -- ignored.\n",
355 len);
Max84bf0fa2017-09-01 11:02:40 +0200356 return -EINVAL;
357 }
Max84bf0fa2017-09-01 11:02:40 +0200358}
359
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100360static int pcu_rx_data_ind(struct gprs_rlcmac_bts *bts, struct gsm_pcu_if_data *data_ind)
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400361{
Max528ff392016-02-22 11:42:33 +0100362 int rc;
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100363 int current_fn = bts_current_frame_number(bts);
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +0100364 struct pcu_l1_meas meas = {0};
Pau Espin Pedrolc1f31c42021-03-09 14:50:14 +0100365 struct gprs_rlcmac_pdch *pdch;
Pau Espin Pedrol72e39562020-06-30 17:57:42 +0200366 uint8_t gsmtap_chantype;
Maxb216c6b2017-09-01 11:00:39 +0200367
Pau Espin Pedrolc1f31c42021-03-09 14:50:14 +0100368 LOGP(DL1IF, LOGL_DEBUG, "(bts=%" PRIu8 ",trx=%" PRIu8 ",ts=%" PRIu8 ") FN=%u "
369 "Rx DATA.ind: sapi=%d arfcn=%d cur_fn=%d "
370 "block=%d data=%s\n", bts->nr, data_ind->trx_nr, data_ind->ts_nr,
371 data_ind->fn, data_ind->sapi, data_ind->arfcn, current_fn,
372 data_ind->block_nr, osmo_hexdump(data_ind->data, data_ind->len));
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400373
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400374 switch (data_ind->sapi) {
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400375 case PCU_IF_SAPI_PDTCH:
Pau Espin Pedrolc1f31c42021-03-09 14:50:14 +0100376 pdch = &bts->trx[data_ind->trx_nr].pdch[data_ind->ts_nr];
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +0100377 pcu_l1_meas_set_rssi(&meas, data_ind->rssi);
Maxb216c6b2017-09-01 11:00:39 +0200378 /* convert BER to % value */
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +0100379 pcu_l1_meas_set_ber(&meas, data_ind->ber10k / 100);
380 pcu_l1_meas_set_bto(&meas, data_ind->ta_offs_qbits);
381 pcu_l1_meas_set_link_qual(&meas, data_ind->lqual_cb / 10);
Vadim Yanitskiyf17dfc02019-07-09 16:16:35 +0700382
Pau Espin Pedrolc1f31c42021-03-09 14:50:14 +0100383 LOGPDCH(pdch, DL1IF, LOGL_DEBUG, "FN=%u Rx DATA.ind PDTCH: "
384 "BER10k = %d, BTO = %d, Q = %d\n", data_ind->fn,
385 data_ind->ber10k, data_ind->ta_offs_qbits, data_ind->lqual_cb);
Vadim Yanitskiyf17dfc02019-07-09 16:16:35 +0700386
Pau Espin Pedrolc1f31c42021-03-09 14:50:14 +0100387 rc = pcu_rx_data_ind_pdtch(bts, pdch, data_ind->data, data_ind->len,
388 data_ind->fn, &meas);
Pau Espin Pedrol72e39562020-06-30 17:57:42 +0200389 gsmtap_chantype = GSMTAP_CHANNEL_PDTCH;
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400390 break;
Max84bf0fa2017-09-01 11:02:40 +0200391 case PCU_IF_SAPI_BCCH:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100392 rc = pcu_rx_data_ind_bcch(bts, data_ind->data, data_ind->len);
Pau Espin Pedrol72e39562020-06-30 17:57:42 +0200393 gsmtap_chantype = GSMTAP_CHANNEL_BCCH;
Max84bf0fa2017-09-01 11:02:40 +0200394 break;
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400395 default:
Pau Espin Pedrolc1f31c42021-03-09 14:50:14 +0100396 LOGP(DL1IF, LOGL_ERROR, "(bts=%" PRIu8 ",trx=%" PRIu8 ",ts=%" PRIu8 ") "
397 "FN=%u Rx DATA.ind with unsupported sapi %d\n",
398 bts->nr, data_ind->trx_nr, data_ind->ts_nr, data_ind->fn, data_ind->sapi);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400399 rc = -EINVAL;
Pau Espin Pedrol72e39562020-06-30 17:57:42 +0200400 gsmtap_chantype = GSMTAP_CHANNEL_UNKNOWN;
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400401 }
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400402
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100403 if (rc < 0 && (the_pcu->gsmtap_categ_mask & (1 <<PCU_GSMTAP_C_UL_UNKNOWN))) {
404 gsmtap_send(the_pcu->gsmtap, data_ind->arfcn | GSMTAP_ARFCN_F_UPLINK, data_ind->ts_nr,
Pau Espin Pedrol72e39562020-06-30 17:57:42 +0200405 gsmtap_chantype, 0, data_ind->fn, meas.rssi, meas.link_qual, data_ind->data, data_ind->len);
Harald Welte717cdf52017-07-21 21:56:23 +0200406 }
407
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400408 return rc;
409}
410
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100411static int pcu_rx_data_cnf(struct gprs_rlcmac_bts *bts, struct gsm_pcu_if_data *data_cnf)
Andreas Eversberga9be1542012-09-27 09:23:24 +0200412{
413 int rc = 0;
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100414 int current_fn = bts_current_frame_number(bts);
Andreas Eversberga9be1542012-09-27 09:23:24 +0200415
Philipp Maier7e8e3972018-04-10 13:31:45 +0200416 LOGP(DL1IF, LOGL_DEBUG, "Data confirm received: sapi=%d fn=%d cur_fn=%d\n",
417 data_cnf->sapi, data_cnf->fn, current_fn);
Andreas Eversberga9be1542012-09-27 09:23:24 +0200418
419 switch (data_cnf->sapi) {
420 case PCU_IF_SAPI_PCH:
Andreas Eversberg8c3680d2012-10-08 12:30:56 +0200421 if (data_cnf->data[2] == 0x3f)
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100422 bts_rcv_imm_ass_cnf(bts, data_cnf->data, data_cnf->fn);
Andreas Eversberga9be1542012-09-27 09:23:24 +0200423 break;
424 default:
425 LOGP(DL1IF, LOGL_ERROR, "Received PCU data confirm with "
426 "unsupported sapi %d\n", data_cnf->sapi);
427 rc = -EINVAL;
428 }
429
430 return rc;
431}
432
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100433// FIXME: remove this, when changed from c++ to c.
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100434int pcu_rx_rts_req_pdtch(struct gprs_rlcmac_bts *bts, uint8_t trx, uint8_t ts,
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100435 uint32_t fn, uint8_t block_nr)
436{
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100437 return gprs_rlcmac_rcv_rts_block(bts,
Max878bd1f2016-07-20 13:05:05 +0200438 trx, ts, fn, block_nr);
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100439}
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100440int pcu_rx_rts_req_ptcch(struct gprs_rlcmac_bts *bts, uint8_t trx, uint8_t ts,
Vadim Yanitskiy78f58612019-10-05 22:22:08 +0700441 uint32_t fn, uint8_t block_nr)
442{
Vadim Yanitskiy78f58612019-10-05 22:22:08 +0700443 struct gprs_rlcmac_pdch *pdch;
444
445 /* Prevent buffer overflow */
446 if (trx >= ARRAY_SIZE(bts->trx) || ts >= 8)
447 return -EINVAL;
448
449 /* Make sure PDCH time-slot is enabled */
450 pdch = &bts->trx[trx].pdch[ts];
451 if (!pdch->m_is_enabled)
452 return -EAGAIN;
453
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100454 pcu_l1if_tx_ptcch(bts, trx, ts, bts->trx[trx].arfcn, fn, block_nr,
Vadim Yanitskiy78f58612019-10-05 22:22:08 +0700455 pdch->ptcch_msg, GSM_MACBLOCK_LEN);
456 return 0;
457}
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100458
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100459static int pcu_rx_rts_req(struct gprs_rlcmac_bts *bts, struct gsm_pcu_if_rts_req *rts_req)
Ivan Kluchnikov5310d452012-04-17 22:00:31 +0400460{
461 int rc = 0;
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100462 int current_fn = bts_current_frame_number(bts);
Pau Espin Pedroldf58ddf2021-03-09 16:19:22 +0100463 const struct gprs_rlcmac_pdch *pdch;
464 pdch = &bts->trx[rts_req->trx_nr].pdch[rts_req->ts_nr];
Ivan Kluchnikov5310d452012-04-17 22:00:31 +0400465
Pau Espin Pedroldf58ddf2021-03-09 16:19:22 +0100466 LOGPDCH(pdch, DL1IF, LOGL_DEBUG, "FN=%u RX RTS.req: sapi=%d "
467 "arfcn=%d cur_fn=%d block=%d\n", rts_req->fn,
468 rts_req->sapi, rts_req->arfcn, current_fn, rts_req->block_nr);
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400469
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400470 switch (rts_req->sapi) {
471 case PCU_IF_SAPI_PDTCH:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100472 pcu_rx_rts_req_pdtch(bts, rts_req->trx_nr, rts_req->ts_nr,
Max878bd1f2016-07-20 13:05:05 +0200473 rts_req->fn, rts_req->block_nr);
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400474 break;
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400475 case PCU_IF_SAPI_PTCCH:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100476 pcu_rx_rts_req_ptcch(bts, rts_req->trx_nr, rts_req->ts_nr,
Vadim Yanitskiy78f58612019-10-05 22:22:08 +0700477 rts_req->fn, rts_req->block_nr);
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400478 break;
479 default:
Pau Espin Pedroldf58ddf2021-03-09 16:19:22 +0100480 LOGP(DL1IF, LOGL_ERROR, "(bts=%u,trx=%u,ts=%u) FN=%u RX RTS.req with "
481 "unsupported sapi %d\n", bts->nr, rts_req->trx_nr, rts_req->ts_nr,
482 rts_req->fn, rts_req->sapi);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400483 rc = -EINVAL;
484 }
485
486 return rc;
487}
488
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700489/* C -> C++ adapter for direct DSP access code (e.g. osmo-bts-sysmo) */
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100490extern "C" int pcu_rx_rach_ind_ptcch(struct gprs_rlcmac_bts *bts, uint8_t trx_nr, uint8_t ts_nr, uint32_t fn, int16_t qta)
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700491{
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700492 struct rach_ind_params rip = {
493 /* The content of RA is not of interest on PTCCH/U */
494 .burst_type = GSM_L1_BURST_TYPE_ACCESS_0,
495 .is_11bit = false,
496 .ra = 0x00,
497 .trx_nr = trx_nr,
498 .ts_nr = ts_nr,
499 .rfn = fn,
500 .qta = qta,
501 };
502
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100503 return bts_rcv_ptcch_rach(bts, &rip);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700504}
505
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100506static int pcu_rx_rach_ind(struct gprs_rlcmac_bts *bts, const struct gsm_pcu_if_rach_ind *rach_ind)
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400507{
508 int rc = 0;
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100509 int current_fn = bts_current_frame_number(bts);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400510
511 LOGP(DL1IF, LOGL_INFO, "RACH request received: sapi=%d "
Vadim Yanitskiyb30f28f2020-03-29 19:01:58 +0700512 "qta=%d, ra=0x%02x, fn=%u, cur_fn=%d, is_11bit=%d\n", rach_ind->sapi, rach_ind->qta,
Philipp Maier7e8e3972018-04-10 13:31:45 +0200513 rach_ind->ra, rach_ind->fn, current_fn, rach_ind->is_11bit);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400514
Vadim Yanitskiya0a0b7f2020-05-21 19:55:46 +0700515 struct rach_ind_params rip = {
516 .burst_type = (enum ph_burst_type) rach_ind->burst_type,
517 .is_11bit = rach_ind->is_11bit > 0,
518 .ra = rach_ind->ra,
519 .trx_nr = rach_ind->trx_nr,
520 .ts_nr = rach_ind->ts_nr,
521 .rfn = rach_ind->fn,
522 .qta = rach_ind->qta,
523 };
524
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400525 switch (rach_ind->sapi) {
526 case PCU_IF_SAPI_RACH:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100527 rc = bts_rcv_rach(bts, &rip);
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400528 break;
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700529 case PCU_IF_SAPI_PTCCH:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100530 rc = bts_rcv_ptcch_rach(bts, &rip);
Vadim Yanitskiyffebd242019-10-05 23:45:31 +0700531 break;
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400532 default:
533 LOGP(DL1IF, LOGL_ERROR, "Received PCU rach request with "
534 "unsupported sapi %d\n", rach_ind->sapi);
535 rc = -EINVAL;
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400536 }
537
Ivan Kluchnikove3a05962012-03-18 15:48:51 +0400538 return rc;
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400539}
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200540
Alexander Couzens5bece2a2020-10-12 02:27:22 +0200541static int pcu_info_ind_ns(struct gprs_rlcmac_bts *bts,
542 const struct gsm_pcu_if_info_ind *info_ind)
543{
544 struct osmo_sockaddr remote[PCU_IF_NUM_NSVC] = { };
545 struct osmo_sockaddr local[PCU_IF_NUM_NSVC] = { };
546 uint16_t nsvci[PCU_IF_NUM_NSVC] = { };
547 uint16_t valid = 0;
548
549 for (unsigned int i = 0; i < PCU_IF_NUM_NSVC; i++) {
550 struct osmo_sockaddr_str sockstr;
551
552 switch (info_ind->address_type[i]) {
553 case PCU_IF_ADDR_TYPE_IPV4:
554 local[i].u.sin.sin_family = AF_INET;
555 local[i].u.sin.sin_addr.s_addr = INADDR_ANY;
556 local[i].u.sin.sin_port = htons(info_ind->local_port[i]);
557
558 remote[i].u.sin.sin_family = AF_INET;
Alexander Couzens87c6dd32020-10-27 13:24:40 +0100559 memcpy(&remote[i].u.sin.sin_addr, &info_ind->remote_ip[i].v4,
560 sizeof(struct in_addr));
Alexander Couzens5bece2a2020-10-12 02:27:22 +0200561 remote[i].u.sin.sin_port = htons(info_ind->remote_port[i]);
562 break;
563 case PCU_IF_ADDR_TYPE_IPV6:
564 local[i].u.sin6.sin6_family = AF_INET6;
565 local[i].u.sin6.sin6_addr = in6addr_any;
566 local[i].u.sin6.sin6_port = htons(info_ind->local_port[i]);
567
568 remote[i].u.sin6.sin6_family = AF_INET6;
Alexander Couzens87c6dd32020-10-27 13:24:40 +0100569 memcpy(&remote[i].u.sin6.sin6_addr,
570 &info_ind->remote_ip[i].v6,
571 sizeof(struct in6_addr));
Alexander Couzens5bece2a2020-10-12 02:27:22 +0200572 remote[i].u.sin6.sin6_port = htons(info_ind->remote_port[i]);
573 break;
574 default:
575 continue;
576 }
577 nsvci[i] = info_ind->nsvci[i];
578
579 LOGP(DL1IF, LOGL_DEBUG, " NS%u nsvci=%u\n", i, nsvci[i]);
580 if (osmo_sockaddr_str_from_sockaddr(&sockstr, &remote[i].u.sas))
581 strcpy(sockstr.ip, "invalid");
582
583 LOGP(DL1IF, LOGL_DEBUG, " NS%u address: r=%s:%u<->l=NULL:%u\n",
584 i, sockstr.ip, sockstr.port, info_ind->local_port[i]);
585
586 valid |= 1 << i;
587 }
588
589 if (valid == 0) {
590 LOGP(DL1IF, LOGL_ERROR, "No NSVC available to connect to the SGSN!\n");
591 return -EINVAL;
592 }
593
Alexander Couzens94a367f2021-02-16 16:57:15 +0100594 return gprs_ns_update_config(bts, info_ind->nsei, local, remote, nsvci, valid);
Alexander Couzens5bece2a2020-10-12 02:27:22 +0200595}
596
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100597static int pcu_rx_info_ind(struct gprs_rlcmac_bts *bts, const struct gsm_pcu_if_info_ind *info_ind)
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200598{
Holger Hans Peter Freythere8d9a5f2013-07-28 19:11:20 +0200599 struct gprs_bssgp_pcu *pcu;
Harald Weltebb47d952016-11-17 18:40:02 +0100600 int rc = 0;
Vadim Yanitskiy11b0f002020-07-24 01:24:47 +0700601 unsigned int trx_nr, ts_nr;
Pau Espin Pedrold87722d2020-10-30 17:14:26 +0100602 unsigned int i;
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200603
Andreas Eversberg8389fd02012-07-18 10:06:48 +0200604 if (info_ind->version != PCU_IF_VERSION) {
Vadim Yanitskiyfad21282020-07-19 02:05:33 +0700605 fprintf(stderr, "PCU interface version number of BTS (%u) is "
606 "different (%u).\nPlease re-compile!\n",
Andreas Eversberg8389fd02012-07-18 10:06:48 +0200607 info_ind->version, PCU_IF_VERSION);
608 exit(-1);
609 }
610
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400611 LOGP(DL1IF, LOGL_DEBUG, "Info indication received:\n");
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200612
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400613 if (!(info_ind->flags & PCU_IF_FLAG_ACTIVE)) {
614 LOGP(DL1IF, LOGL_NOTICE, "BTS not available\n");
Stefan Sperling5b22fb72018-02-14 19:46:33 +0100615 if (!bts->active)
616 return -EAGAIN;
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400617bssgp_failed:
Stefan Sperling5b22fb72018-02-14 19:46:33 +0100618 bts->active = false;
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400619 /* free all TBF */
Vadim Yanitskiy11b0f002020-07-24 01:24:47 +0700620 for (trx_nr = 0; trx_nr < ARRAY_SIZE(bts->trx); trx_nr++) {
621 bts->trx[trx_nr].arfcn = info_ind->trx[trx_nr].arfcn;
622 for (ts_nr = 0; ts_nr < ARRAY_SIZE(bts->trx[0].pdch); ts_nr++)
623 bts->trx[trx_nr].pdch[ts_nr].free_resources();
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400624 }
Alexander Couzens290d9032020-09-16 21:52:02 +0200625 gprs_bssgp_destroy(bts);
Daniel Willmann6d8884d2014-06-04 18:30:59 +0200626 exit(0);
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200627 }
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400628 LOGP(DL1IF, LOGL_INFO, "BTS available\n");
Neels Hofmeyrbdc55fa2018-02-21 00:39:07 +0100629 LOGP(DL1IF, LOGL_DEBUG, " mcc=%03u\n", info_ind->mcc);
630 LOGP(DL1IF, LOGL_DEBUG, " mnc=%0*u\n", info_ind->mnc_3_digits, info_ind->mnc);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400631 LOGP(DL1IF, LOGL_DEBUG, " lac=%d\n", info_ind->lac);
632 LOGP(DL1IF, LOGL_DEBUG, " rac=%d\n", info_ind->rac);
Harald Welte1473b372019-03-21 19:48:55 +0100633 LOGP(DL1IF, LOGL_DEBUG, " cell_id=%d\n", info_ind->cell_id);
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100634 LOGP(DL1IF, LOGL_DEBUG, " bsic=%d\n", info_ind->bsic);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400635 LOGP(DL1IF, LOGL_DEBUG, " nsei=%d\n", info_ind->nsei);
636 LOGP(DL1IF, LOGL_DEBUG, " nse_timer=%d %d %d %d %d %d %d\n",
637 info_ind->nse_timer[0], info_ind->nse_timer[1],
638 info_ind->nse_timer[2], info_ind->nse_timer[3],
639 info_ind->nse_timer[4], info_ind->nse_timer[5],
640 info_ind->nse_timer[6]);
641 LOGP(DL1IF, LOGL_DEBUG, " cell_timer=%d %d %d %d %d %d %d %d %d %d "
642 "%d\n",
643 info_ind->cell_timer[0], info_ind->cell_timer[1],
644 info_ind->cell_timer[2], info_ind->cell_timer[3],
645 info_ind->cell_timer[4], info_ind->cell_timer[5],
646 info_ind->cell_timer[6], info_ind->cell_timer[7],
647 info_ind->cell_timer[8], info_ind->cell_timer[9],
648 info_ind->cell_timer[10]);
649 LOGP(DL1IF, LOGL_DEBUG, " repeat_time=%d\n", info_ind->repeat_time);
650 LOGP(DL1IF, LOGL_DEBUG, " repeat_count=%d\n", info_ind->repeat_count);
651 LOGP(DL1IF, LOGL_DEBUG, " bvci=%d\n", info_ind->bvci);
652 LOGP(DL1IF, LOGL_DEBUG, " t3142=%d\n", info_ind->t3142);
653 LOGP(DL1IF, LOGL_DEBUG, " t3169=%d\n", info_ind->t3169);
654 LOGP(DL1IF, LOGL_DEBUG, " t3191=%d\n", info_ind->t3191);
655 LOGP(DL1IF, LOGL_DEBUG, " t3193=%d (ms)\n", info_ind->t3193_10ms * 10);
656 LOGP(DL1IF, LOGL_DEBUG, " t3195=%d\n", info_ind->t3195);
657 LOGP(DL1IF, LOGL_DEBUG, " n3101=%d\n", info_ind->n3101);
658 LOGP(DL1IF, LOGL_DEBUG, " n3103=%d\n", info_ind->n3103);
659 LOGP(DL1IF, LOGL_DEBUG, " n3105=%d\n", info_ind->n3105);
660 LOGP(DL1IF, LOGL_DEBUG, " cv_countdown=%d\n", info_ind->cv_countdown);
661 LOGP(DL1IF, LOGL_DEBUG, " dl_tbf_ext=%d\n", info_ind->dl_tbf_ext);
662 LOGP(DL1IF, LOGL_DEBUG, " ul_tbf_ext=%d\n", info_ind->ul_tbf_ext);
Pau Espin Pedrol2e6b60d2021-01-20 13:48:31 +0100663 bts->cgi_ps.rai.lac.plmn.mcc = info_ind->mcc;
664 bts->cgi_ps.rai.lac.plmn.mnc = info_ind->mnc;
665 bts->cgi_ps.rai.lac.plmn.mnc_3_digits = info_ind->mnc_3_digits;
666 bts->cgi_ps.rai.lac.lac = info_ind->lac;
667 bts->cgi_ps.rai.rac = info_ind->rac;
668 bts->cgi_ps.cell_identity = info_ind->cell_id;
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100669 bts->bsic = info_ind->bsic;
Pau Espin Pedrold87722d2020-10-30 17:14:26 +0100670
671 bts->cs_mask = 1 << 0; /* We need at least 1 CS, let's enable CS1 */
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400672 for (i = 0; i < 4; i++) {
Pau Espin Pedrold87722d2020-10-30 17:14:26 +0100673 uint8_t allowed = !!(info_ind->flags & (PCU_IF_FLAG_CS1 << i));
674 bts->cs_mask |= allowed << i;
675 if (allowed)
676 LOGP(DL1IF, LOGL_DEBUG, " Use CS%d\n", i + 1);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400677 }
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100678 bts_recalc_max_cs(bts);
Pau Espin Pedrold87722d2020-10-30 17:14:26 +0100679
680 bts->mcs_mask = 0;
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400681 for (i = 0; i < 9; i++) {
Pau Espin Pedrold87722d2020-10-30 17:14:26 +0100682 uint8_t allowed = !!(info_ind->flags & (PCU_IF_FLAG_MCS1 << i));
683 bts->mcs_mask |= allowed << i;
Pau Espin Pedrol87eec1f2020-10-30 18:46:24 +0100684 if (allowed)
Pau Espin Pedrold87722d2020-10-30 17:14:26 +0100685 LOGP(DL1IF, LOGL_DEBUG, " Use MCS%d\n", i + 1);
Pau Espin Pedrol87eec1f2020-10-30 18:46:24 +0100686
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400687 }
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100688 bts_recalc_max_mcs(bts);
Pau Espin Pedrold87722d2020-10-30 17:14:26 +0100689
Pau Espin Pedrolb47b1372020-11-03 15:59:39 +0100690 LOGP(DL1IF, LOGL_DEBUG, " initial_cs=%u%s\n", info_ind->initial_cs,
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100691 the_pcu->vty.force_initial_cs ? " (VTY forced, ignoring)" : "");
Pau Espin Pedrol793583e2021-01-14 16:20:57 +0100692 bts->pcuif_info_ind.initial_cs = info_ind->initial_cs;
693 bts_recalc_initial_cs(bts);
Pau Espin Pedrolb47b1372020-11-03 15:59:39 +0100694
695 LOGP(DL1IF, LOGL_DEBUG, " initial_mcs=%u%s\n", info_ind->initial_mcs,
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100696 the_pcu->vty.force_initial_mcs ? " (VTY forced, ignoring)" : "");
Pau Espin Pedrol793583e2021-01-14 16:20:57 +0100697 bts->pcuif_info_ind.initial_mcs = info_ind->initial_mcs;
698 bts_recalc_initial_mcs(bts);
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200699
Alexander Couzens290d9032020-09-16 21:52:02 +0200700 pcu = gprs_bssgp_init(
701 bts,
702 info_ind->nsei, info_ind->bvci,
703 info_ind->mcc, info_ind->mnc, info_ind->mnc_3_digits,
704 info_ind->lac, info_ind->rac, info_ind->cell_id);
705 if (!pcu) {
Vadim Yanitskiyc1a726c2020-10-08 22:46:26 +0700706 LOGP(DL1IF, LOGL_ERROR, "Failed to init BSSGP\n");
Alexander Couzens9b5c9602020-07-28 13:47:18 +0200707 goto bssgp_failed;
708 }
709
Alexander Couzens5bece2a2020-10-12 02:27:22 +0200710 rc = pcu_info_ind_ns(pcu->bts, info_ind);
711 if (rc < 0) {
Alexander Couzens290d9032020-09-16 21:52:02 +0200712 LOGP(DL1IF, LOGL_ERROR, "No NSVC available to connect to the SGSN!\n");
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400713 goto bssgp_failed;
714 }
715
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400716 if (info_ind->t3142) { /* if timer values are set */
Pau Espin Pedrol28f160e2019-09-05 14:48:35 +0200717 osmo_tdef_set(bts->T_defs_bts, 3142, info_ind->t3142, OSMO_TDEF_S);
718 osmo_tdef_set(bts->T_defs_bts, 3169, info_ind->t3169, OSMO_TDEF_S);
719 osmo_tdef_set(bts->T_defs_bts, 3191, info_ind->t3191, OSMO_TDEF_S);
720 osmo_tdef_set(bts->T_defs_bts, 3193, info_ind->t3193_10ms * 10, OSMO_TDEF_MS);
721 osmo_tdef_set(bts->T_defs_bts, 3195, info_ind->t3195, OSMO_TDEF_S);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400722 bts->n3101 = info_ind->n3101;
723 bts->n3103 = info_ind->n3103;
724 bts->n3105 = info_ind->n3105;
725 }
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400726
Vadim Yanitskiy11b0f002020-07-24 01:24:47 +0700727 for (trx_nr = 0; trx_nr < ARRAY_SIZE(bts->trx); trx_nr++) {
728 bts->trx[trx_nr].arfcn = info_ind->trx[trx_nr].arfcn;
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100729 if ((info_ind->flags & PCU_IF_FLAG_SYSMO)
Vadim Yanitskiy11b0f002020-07-24 01:24:47 +0700730 && info_ind->trx[trx_nr].hlayer1) {
Maxcad867e2016-04-21 14:35:55 +0200731#ifdef ENABLE_DIRECT_PHY
Vadim Yanitskiy11b0f002020-07-24 01:24:47 +0700732 LOGP(DL1IF, LOGL_DEBUG, " TRX %d hlayer1=%x\n", trx_nr,
733 info_ind->trx[trx_nr].hlayer1);
734 if (!bts->trx[trx_nr].fl1h)
735 bts->trx[trx_nr].fl1h = l1if_open_pdch(
736 trx_nr,
737 info_ind->trx[trx_nr].hlayer1,
Pau Espin Pedrolac3fd122021-01-13 18:54:38 +0100738 the_pcu->gsmtap);
Vadim Yanitskiy11b0f002020-07-24 01:24:47 +0700739 if (!bts->trx[trx_nr].fl1h) {
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100740 LOGP(DL1IF, LOGL_FATAL, "Failed to open direct "
741 "DSP access for PDCH.\n");
742 exit(0);
743 }
744#else
745 LOGP(DL1IF, LOGL_FATAL, "Compiled without direct DSP "
746 "access for PDCH, but enabled at "
747 "BTS. Please deactivate it!\n");
748 exit(0);
749#endif
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100750 }
751
Vadim Yanitskiy11b0f002020-07-24 01:24:47 +0700752 for (ts_nr = 0; ts_nr < ARRAY_SIZE(bts->trx[0].pdch); ts_nr++) {
Vadim Yanitskiy8e2bd1e2020-07-21 00:54:42 +0700753 const struct gsm_pcu_if_info_ts *its = &info_ind->trx[trx_nr].ts[ts_nr];
Vadim Yanitskiy0f41b712020-07-24 01:28:13 +0700754 struct gprs_rlcmac_pdch *pdch = &bts->trx[trx_nr].pdch[ts_nr];
Vadim Yanitskiy11b0f002020-07-24 01:24:47 +0700755 if ((info_ind->trx[trx_nr].pdch_mask & (1 << ts_nr))) {
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400756 /* FIXME: activate dynamically at RLCMAC */
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +0200757 if (!pdch->is_enabled()) {
Maxcad867e2016-04-21 14:35:55 +0200758#ifdef ENABLE_DIRECT_PHY
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100759 if ((info_ind->flags &
760 PCU_IF_FLAG_SYSMO))
761 l1if_connect_pdch(
Vadim Yanitskiy11b0f002020-07-24 01:24:47 +0700762 bts->trx[trx_nr].fl1h, ts_nr);
Andreas Eversberga23c7ee2012-12-18 10:47:28 +0100763#endif
Pau Espin Pedroldf58ddf2021-03-09 16:19:22 +0100764 pcu_tx_act_req(bts, pdch, 1);
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +0200765 pdch->enable();
Andreas Eversberg3b7461c2012-07-20 11:19:59 +0200766 }
Vadim Yanitskiy8e2bd1e2020-07-21 00:54:42 +0700767
768 pdch->tsc = its->tsc;
769
770 /* (Optional) frequency hopping parameters */
771 if (its->h) {
772 pdch->fh.enabled = true;
773 pdch->fh.maio = its->maio;
774 pdch->fh.hsn = its->hsn;
775
776 OSMO_ASSERT(its->ma_bit_len <= sizeof(pdch->fh.ma) * 8);
777 pdch->fh.ma_oct_len = OSMO_BYTES_FOR_BITS(its->ma_bit_len);
778 pdch->fh.ma_bit_len = its->ma_bit_len;
779
780 /* Mobile Allocation + padding (byte/bit order as on the wire):
781 * | 00 00 00 00 00 cc bb aa | -> | cc bb aa 00 00 00 00 00 | */
782 unsigned int offset = sizeof(pdch->fh.ma) - pdch->fh.ma_oct_len;
783 memcpy(pdch->fh.ma, its->ma + offset, pdch->fh.ma_oct_len);
784 }
785
786 LOGP(DL1IF, LOGL_INFO, "PDCH (trx=%u, ts=%u): tsc=%u, hopping=%s\n",
787 trx_nr, ts_nr, pdch->tsc, pdch->fh.enabled ? "yes" : "no");
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400788 } else {
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +0200789 if (pdch->is_enabled()) {
Pau Espin Pedroldf58ddf2021-03-09 16:19:22 +0100790 pcu_tx_act_req(bts, pdch, 0);
Holger Hans Peter Freyther09ef27a2013-10-20 16:37:05 +0200791 pdch->free_resources();
Holger Hans Peter Freyther17b0d832013-10-19 17:37:48 +0200792 pdch->disable();
Andreas Eversberg3b7461c2012-07-20 11:19:59 +0200793 }
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400794 }
795 }
796 }
797
Stefan Sperling5b22fb72018-02-14 19:46:33 +0100798 bts->active = true;
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200799 return rc;
800}
801
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100802static int pcu_rx_time_ind(struct gprs_rlcmac_bts *bts, struct gsm_pcu_if_time_ind *time_ind)
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200803{
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400804 uint8_t fn13 = time_ind->fn % 13;
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200805
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400806 /* omit frame numbers not starting at a MAC block */
807 if (fn13 != 0 && fn13 != 4 && fn13 != 8)
808 return 0;
Max3741f142017-06-26 12:10:12 +0200809
810 LOGP(DL1IF, LOGL_DEBUG, "Time indication received: %d\n", time_ind->fn % 52);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400811
Pau Espin Pedrol30617112021-03-05 18:59:05 +0100812 /* Ignore TIME.ind completely, we nowadays relay on DATA.ind always
813 * providing all block FNs. */
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200814 return 0;
815}
816
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100817static int pcu_rx_pag_req(struct gprs_rlcmac_bts *bts, struct gsm_pcu_if_pag_req *pag_req)
Andreas Eversberg2b914642012-07-19 13:06:26 +0200818{
Neels Hofmeyr59fc0bd2020-08-21 16:21:23 +0200819 struct osmo_mobile_identity mi;
Pau Espin Pedrolbd542052021-05-13 17:44:51 +0200820 struct GprsMs *ms = NULL;
821 struct paging_req_cs req = { .chan_needed = pag_req->chan_needed,
822 .tlli = GSM_RESERVED_TMSI };
Neels Hofmeyr59fc0bd2020-08-21 16:21:23 +0200823 int rc;
824
Andreas Eversberg2b914642012-07-19 13:06:26 +0200825 LOGP(DL1IF, LOGL_DEBUG, "Paging request received: chan_needed=%d "
826 "length=%d\n", pag_req->chan_needed, pag_req->identity_lv[0]);
827
Pau Espin Pedrol32499b62019-12-09 13:55:12 +0100828 /* check if identity does not fit: length > sizeof(lv) - 1 */
829 if (pag_req->identity_lv[0] >= sizeof(pag_req->identity_lv)) {
830 LOGP(DL1IF, LOGL_ERROR, "Paging identity too large (%" PRIu8 ")\n",
831 pag_req->identity_lv[0]);
832 return -EINVAL;
833 }
834
Neels Hofmeyr59fc0bd2020-08-21 16:21:23 +0200835 rc = osmo_mobile_identity_decode(&mi, &pag_req->identity_lv[1], pag_req->identity_lv[0], true);
836 if (rc < 0) {
837 LOGP(DL1IF, LOGL_ERROR, "Failed to decode Mobile Identity in Paging Request (rc=%d)\n", rc);
838 return -EINVAL;
839 }
840
Pau Espin Pedrolbd542052021-05-13 17:44:51 +0200841 switch (mi.type) {
842 case GSM_MI_TYPE_TMSI:
843 req.mi_tmsi = mi;
844 req.mi_tmsi_present = true;
845 /* TODO: look up MS by TMSI? Derive TLLI? */
846 break;
847 case GSM_MI_TYPE_IMSI:
848 req.mi_imsi = mi;
849 req.mi_imsi_present = true;
850 ms = bts_ms_by_imsi(bts, req.mi_imsi.imsi);
851 break;
852 default:
853 LOGP(DL1IF, LOGL_ERROR, "Unexpected MI type %u\n", mi.type);
854 return -EINVAL;
855 }
856
857 return bts_add_paging(bts, &req, ms);
Andreas Eversberg2b914642012-07-19 13:06:26 +0200858}
859
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100860static int pcu_rx_susp_req(struct gprs_rlcmac_bts *bts, struct gsm_pcu_if_susp_req *susp_req)
Harald Welte3447c4a2017-07-11 00:06:38 +0200861{
Philipp Maiera58ec612021-01-25 23:43:52 +0100862 struct bssgp_bvc_ctx *bctx = the_pcu->bssgp.bctx;
Pau Espin Pedrolbd9973a2020-09-22 15:57:37 +0200863 GprsMs *ms;
864 struct gprs_rlcmac_dl_tbf *dl_tbf;
865 struct gprs_rlcmac_ul_tbf *ul_tbf;
Harald Welte3447c4a2017-07-11 00:06:38 +0200866 struct gprs_ra_id ra_id;
867
868 gsm48_parse_ra(&ra_id, susp_req->ra_id);
869
870 LOGP(DL1IF, LOGL_INFO, "GPRS Suspend request received: TLLI=0x%08x RAI=%s\n",
871 susp_req->tlli, osmo_rai_name(&ra_id));
872
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100873 if ((ms = bts_ms_store(bts)->get_ms(susp_req->tlli))) {
Pau Espin Pedrolbd9973a2020-09-22 15:57:37 +0200874 /* We need to catch both pointers here since MS may become freed
875 after first tbf_free(dl_tbf) if only DL TBF was available */
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +0100876 dl_tbf = ms_dl_tbf(ms);
877 ul_tbf = ms_ul_tbf(ms);
Pau Espin Pedrolbd9973a2020-09-22 15:57:37 +0200878 if (dl_tbf)
879 tbf_free(dl_tbf);
880 if (ul_tbf)
881 tbf_free(ul_tbf);
882 }
883
Harald Welte3447c4a2017-07-11 00:06:38 +0200884 if (!bctx)
885 return -1;
886
887 return bssgp_tx_suspend(bctx->nsei, susp_req->tlli, &ra_id);
888}
889
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100890static int pcu_rx_app_info_req(struct gprs_rlcmac_bts *bts, struct gsm_pcu_if_app_info_req *app_info_req)
Oliver Smithcfb63212019-09-05 17:13:33 +0200891{
Pau Espin Pedrol54faf022021-01-14 12:12:43 +0100892 struct llist_head *tmp;
Oliver Smithcfb63212019-09-05 17:13:33 +0200893
894 LOGP(DL1IF, LOGL_DEBUG, "Application Information Request received: type=0x%08x len=%i\n",
895 app_info_req->application_type, app_info_req->len);
896
Pau Espin Pedrol0ece97d2021-01-18 12:53:54 +0100897 bts->app_info_pending = 0;
Pau Espin Pedrol2182e622021-01-14 16:48:38 +0100898 llist_for_each(tmp, bts_ms_store(bts)->ms_list()) {
Pau Espin Pedrol54faf022021-01-14 12:12:43 +0100899 GprsMs *ms = llist_entry(tmp, typeof(*ms), list);
Pau Espin Pedrolda971ee2020-12-16 15:59:45 +0100900 if (!ms_dl_tbf(ms))
Oliver Smithcfb63212019-09-05 17:13:33 +0200901 continue;
Pau Espin Pedrol0ece97d2021-01-18 12:53:54 +0100902 bts->app_info_pending++;
Oliver Smithcfb63212019-09-05 17:13:33 +0200903 ms->app_info_pending = true;
904 }
905
Pau Espin Pedrol0ece97d2021-01-18 12:53:54 +0100906 if (!bts->app_info_pending) {
Oliver Smithcfb63212019-09-05 17:13:33 +0200907 LOGP(DL1IF, LOGL_NOTICE, "Packet Application Information will not be sent, no subscribers with active"
908 " TBF\n");
909 return -1;
910 }
911
Pau Espin Pedrol0ece97d2021-01-18 12:53:54 +0100912 if (bts->app_info) {
Oliver Smithcfb63212019-09-05 17:13:33 +0200913 LOGP(DL1IF, LOGL_NOTICE, "Previous Packet Application Information was not sent to all subscribers,"
914 " overwriting with new one\n");
Pau Espin Pedrol0ece97d2021-01-18 12:53:54 +0100915 msgb_free(bts->app_info);
Oliver Smithcfb63212019-09-05 17:13:33 +0200916 }
917
918 LOGP(DL1IF, LOGL_INFO, "Sending Packet Application Information to %i subscribers with active TBF\n",
Pau Espin Pedrol0ece97d2021-01-18 12:53:54 +0100919 bts->app_info_pending);
920 bts->app_info = gprs_rlcmac_app_info_msg(app_info_req);
Oliver Smithcfb63212019-09-05 17:13:33 +0200921 return 0;
922}
923
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400924int pcu_rx(uint8_t msg_type, struct gsm_pcu_if *pcu_prim)
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200925{
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400926 int rc = 0;
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100927 struct gprs_rlcmac_bts *bts = gprs_pcu_get_bts_by_nr(the_pcu, pcu_prim->bts_nr);
928 if (!bts) {
929 LOGP(DL1IF, LOGL_NOTICE, "Received message for new BTS%d\n", pcu_prim->bts_nr);
930 bts = bts_alloc(the_pcu, pcu_prim->bts_nr);
931 if (!bts) {
932 LOGP(DL1IF, LOGL_ERROR, "Failed to create object for BTS%d!\n", pcu_prim->bts_nr);
933 return -EAGAIN;
934 }
935 }
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200936
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400937 switch (msg_type) {
938 case PCU_IF_MSG_DATA_IND:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100939 rc = pcu_rx_data_ind(bts, &pcu_prim->u.data_ind);
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400940 break;
Andreas Eversberga9be1542012-09-27 09:23:24 +0200941 case PCU_IF_MSG_DATA_CNF:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100942 rc = pcu_rx_data_cnf(bts, &pcu_prim->u.data_cnf);
Andreas Eversberga9be1542012-09-27 09:23:24 +0200943 break;
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400944 case PCU_IF_MSG_RTS_REQ:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100945 rc = pcu_rx_rts_req(bts, &pcu_prim->u.rts_req);
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400946 break;
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400947 case PCU_IF_MSG_RACH_IND:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100948 rc = pcu_rx_rach_ind(bts, &pcu_prim->u.rach_ind);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400949 break;
950 case PCU_IF_MSG_INFO_IND:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100951 rc = pcu_rx_info_ind(bts, &pcu_prim->u.info_ind);
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400952 break;
953 case PCU_IF_MSG_TIME_IND:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100954 rc = pcu_rx_time_ind(bts, &pcu_prim->u.time_ind);
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400955 break;
Andreas Eversberg2b914642012-07-19 13:06:26 +0200956 case PCU_IF_MSG_PAG_REQ:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100957 rc = pcu_rx_pag_req(bts, &pcu_prim->u.pag_req);
Andreas Eversberg2b914642012-07-19 13:06:26 +0200958 break;
Harald Welte3447c4a2017-07-11 00:06:38 +0200959 case PCU_IF_MSG_SUSP_REQ:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100960 rc = pcu_rx_susp_req(bts, &pcu_prim->u.susp_req);
Harald Welte3447c4a2017-07-11 00:06:38 +0200961 break;
Oliver Smithcfb63212019-09-05 17:13:33 +0200962 case PCU_IF_MSG_APP_INFO_REQ:
Pau Espin Pedrold1049dc2021-01-18 17:14:14 +0100963 rc = pcu_rx_app_info_req(bts, &pcu_prim->u.app_info_req);
Oliver Smithcfb63212019-09-05 17:13:33 +0200964 break;
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400965 default:
Thorsten Alteholz8bb79042018-10-06 10:42:58 +0200966 LOGP(DL1IF, LOGL_ERROR, "Received unknown PCU msg type %d\n",
Ivan Kluchnikovef7f28c2012-07-12 14:49:15 +0400967 msg_type);
968 rc = -EINVAL;
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200969 }
Philipp Maier8ccf7042018-04-10 13:12:42 +0200970
Ivan Kluchnikov8ee60512012-03-05 19:24:57 +0400971 return rc;
Andreas Eversberg0aed6542012-06-23 10:33:16 +0200972}