blob: d5ba3466185340d57ad417949ce6753b2eaad7dd [file] [log] [blame]
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001/* encoding.cpp
2 *
3 * Copyright (C) 2012 Ivan Klyuchnikov
4 * Copyright (C) 2012 Andreas Eversberg <jolly@eversberg.eu>
5 * Copyright (C) 2013 by Holger Hans Peter Freyther
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 */
21
Holger Hans Peter Freyther63f29d62013-10-19 19:04:03 +020022#include <encoding.h>
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +020023#include <gprs_rlcmac.h>
Holger Hans Peter Freyther34bd8bd2013-10-19 21:10:38 +020024#include <bts.h>
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +020025#include <tbf.h>
26#include <gprs_debug.h>
sivasankari8adfcd02017-01-16 15:41:21 +053027#include <egprs_rlc_compression.h>
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +020028
Tom Tsoudf698092016-07-11 17:05:19 -070029extern "C" {
30#include <osmocom/gprs/protocol/gsm_04_60.h>
Maxd5720542016-07-14 15:41:17 +020031#include <osmocom/gsm/protocol/gsm_04_08.h>
Max0c55bf12019-02-19 18:08:27 +010032}
Maxd5720542016-07-14 15:41:17 +020033
34#include <stdbool.h>
Jacob Erlbeckf0e40392016-01-08 10:07:53 +010035#include <errno.h>
36#include <string.h>
37
Max23c0e012019-02-19 17:49:27 +010038#define CHECK(rc) { if (rc < 0) return rc; }
39#define SET_X(bv, x) { if (bitvec_set_bit(bv, x) < 0) return -EOWNERDEAD; }
40#define SET_0(bv) SET_X(bv, ZERO)
41#define SET_1(bv) SET_X(bv, ONE)
42#define SET_L(bv) SET_X(bv, L)
43#define SET_H(bv) SET_X(bv, H)
44
45/* 3GPP TS 44.018 § 10.5.2.16:
46 { 0 | 1 < ALPHA : bit (4) > }
47 < GAMMA : bit (5) >
48*/
49static int write_alpha_gamma(bitvec *dest, uint8_t alpha, uint8_t gamma)
50{
51 int rc;
52
53 if (alpha) {
54 SET_1(dest);
55 rc = bitvec_set_u64(dest, alpha, 4, false);
56 CHECK(rc);
57 } else
58 SET_0(dest);
59
60 rc = bitvec_set_u64(dest, gamma, 5, false);
61 CHECK(rc);
62
63 return 0;
64}
65
66/* TBF_STARTING_TIME -- same as 3GPP TS 44.018 §10.5.2.38 Starting Time without tag: */
67static int write_tbf_start_time(bitvec *dest, uint32_t fn)
68{
69 int rc;
70
71 /* Set values according to 3GPP TS 44.018 Table 10.5.2.38.1 */
72
73 /* T1' */
74 rc = bitvec_set_u64(dest, (fn / (26 * 51)) % 32, 5, false);
75 CHECK(rc);
76
77 /* T3 */
78 rc = bitvec_set_u64(dest, fn % 51, 6, false);
79 CHECK(rc);
80
81 /* T2 */
82 rc = bitvec_set_u64(dest, fn % 26, 5, false);
83 CHECK(rc);
84
85 return rc;
86}
87
Max2a47c732019-02-19 18:25:13 +010088/* 3GPP TS 44.018 §10.5.2.16:
89 < TFI_ASSIGNMENT : bit (5) >
90 < POLLING : bit >
91 0 -- The value '1' was allocated in an earlier version of the protocol and shall not be used.
92 < USF: bit (3) >
93 < USF_GRANULARITY : bit >
94 { 0 | 1 < P0 : bit (4) > < PR_MODE : bit (1) > }
95*/
96static int write_tfi_usf(bitvec *dest, const gprs_rlcmac_ul_tbf *tbf, uint8_t usf)
97{
98 int rc = bitvec_set_u64(dest, tbf->tfi(), 5, false); /* TFI_ASSIGNMENT */
99 CHECK(rc);
100
101 SET_0(dest); /* POLLING -- no action is required from MS */
102
103 SET_0(dest);
104
105 rc = bitvec_set_u64(dest, usf, 3, false); /* USF */
106 CHECK(rc);
107
108 SET_0(dest); /* USF_GRANULARITY -- the mobile station shall transmit one RLC/MAC block */
109
110 SET_0(dest); /* No P0 nor PR_MODE */
111
112 return 0;
113}
114
Maxae483812016-07-28 12:03:08 +0200115/* { 0 | 1 < TIMING_ADVANCE_INDEX : bit (4) > } */
Max23c0e012019-02-19 17:49:27 +0100116static int write_ta_index(bitvec *dest, int8_t tai)
117{
118 int rc;
119
Max02fbfc12019-03-13 15:55:54 +0100120 if (tai < 0) { /* No TIMING_ADVANCE_INDEX: */
Max23c0e012019-02-19 17:49:27 +0100121 SET_0(dest);
Max02fbfc12019-03-13 15:55:54 +0100122 } else { /* TIMING_ADVANCE_INDEX: */
123 SET_1(dest);
124 rc = bitvec_set_u64(dest, tai, 4, false);
125 CHECK(rc);
126 }
Max23c0e012019-02-19 17:49:27 +0100127
128 return 0;
129}
130
Maxae483812016-07-28 12:03:08 +0200131static inline bool write_tai(bitvec *dest, unsigned& wp, int8_t tai)
132{
133 if (tai < 0) { /* No TIMING_ADVANCE_INDEX: */
Alexander Couzensccde5c92017-02-04 03:10:08 +0100134 bitvec_write_field(dest, &wp, 0, 1);
Maxae483812016-07-28 12:03:08 +0200135 return false;
136 }
137 /* TIMING_ADVANCE_INDEX: */
Alexander Couzensccde5c92017-02-04 03:10:08 +0100138 bitvec_write_field(dest, &wp, 1, 1);
139 bitvec_write_field(dest, &wp, tai, 4);
Maxae483812016-07-28 12:03:08 +0200140 return true;
141}
142
143/* { 0 | 1 < TIMING_ADVANCE_VALUE : bit (6) > } */
144static inline void write_ta(bitvec *dest, unsigned& wp, int8_t ta)
145{
146 if (ta < 0) /* No TIMING_ADVANCE_VALUE: */
Alexander Couzensccde5c92017-02-04 03:10:08 +0100147 bitvec_write_field(dest, &wp, 0, 1);
Maxae483812016-07-28 12:03:08 +0200148 else { /* TIMING_ADVANCE_VALUE: */
Alexander Couzensccde5c92017-02-04 03:10:08 +0100149 bitvec_write_field(dest, &wp, 1, 1);
150 bitvec_write_field(dest, &wp, ta, 6);
Maxae483812016-07-28 12:03:08 +0200151 }
152}
153
Maxa4f570f2017-12-15 11:21:57 +0100154/* 3GPP TS 44.060 Table 12.5.2.1 */
155static inline uint16_t enc_ws(uint16_t ws)
156{
157 return (ws - 64) / 32;
158}
159
160static inline void write_ws(bitvec *dest, unsigned int *write_index, uint16_t ws)
161{
162 dest->cur_bit = *write_index;
163
164 bitvec_set_u64(dest, enc_ws(ws), 5, false);
165
166 *write_index += 5;
167}
168
Maxae483812016-07-28 12:03:08 +0200169/* 3GPP TS 44.060 § 12.12:
170 { 0 | 1 < TIMING_ADVANCE_VALUE : bit (6) > }
171 { 0 | 1 < TIMING_ADVANCE_INDEX : bit (4) >
172 < TIMING_ADVANCE_TIMESLOT_NUMBER : bit (3) > }
173 */
174static inline void write_ta_ie(bitvec *dest, unsigned& wp,
175 int8_t ta, int8_t tai, uint8_t ts)
176{
177 write_ta(dest, wp, ta);
178 if (write_tai(dest, wp, tai)) /* TIMING_ADVANCE_TIMESLOT_NUMBER: */
Alexander Couzensccde5c92017-02-04 03:10:08 +0100179 bitvec_write_field(dest, &wp, ts, 3);
Maxae483812016-07-28 12:03:08 +0200180}
181
Max0160a292019-02-19 15:37:03 +0100182static int write_ia_rest_downlink(const gprs_rlcmac_dl_tbf *tbf, bitvec * dest, bool polling, bool ta_valid,
Max23c0e012019-02-19 17:49:27 +0100183 uint32_t fn, uint8_t alpha, uint8_t gamma, int8_t ta_idx)
Jacob Erlbeck18831c32016-02-01 15:23:35 +0100184{
Max0160a292019-02-19 15:37:03 +0100185 int rc = 0;
186
Max23c0e012019-02-19 17:49:27 +0100187 SET_H(dest); SET_H(dest);
188 SET_0(dest); SET_1(dest); /* 00 Packet Downlink Assignment */
189
190 rc = bitvec_set_u64(dest, tbf->tlli(), 32, false); /* TLLI */
191 CHECK(rc);
192
193 SET_1(dest);
194 rc = bitvec_set_u64(dest, tbf->tfi(), 5, false); /* TFI_ASSIGNMENT */
195 CHECK(rc);
196
197 /* RLC acknowledged mode */
198 SET_0(dest); /* RLC_MODE */
199
200 rc = write_alpha_gamma(dest, alpha, gamma);
201 CHECK(rc);
202
203 rc = bitvec_set_bit(dest, (bit_value)polling); /* POLLING */
204 CHECK(rc);
205
206 /* N. B: NOT related to TAI! */
207 rc = bitvec_set_bit(dest, (bit_value)ta_valid); /* TA_VALID */
208 CHECK(rc);
209
210 rc = write_ta_index(dest, ta_idx);
211 CHECK(rc);
212
Jacob Erlbeck18831c32016-02-01 15:23:35 +0100213 if (polling) {
Max23c0e012019-02-19 17:49:27 +0100214 SET_1(dest);
215 rc = write_tbf_start_time(dest, fn);
216 CHECK(rc);
217 } else
218 SET_0(dest);
219
220 SET_0(dest); /* No P0 nor PR_MODE */
221
Jacob Erlbeckbe80c362016-02-01 16:39:52 +0100222 if (tbf->is_egprs_enabled()) {
Max23c0e012019-02-19 17:49:27 +0100223 SET_H(dest);
224 rc = bitvec_set_u64(dest, enc_ws(tbf->window_size()), 5, false); /* EGPRS Window Size */
225 CHECK(rc);
226
227 /* The mobile station shall not report measurements: (see 3GPP TS 44.060 Table 11.2.7.1) */
228 SET_0(dest); SET_0(dest); /* LINK_QUALITY_MEASUREMENT_MODE */
229 SET_1(dest); /* No BEP_PERIOD2 */
230 } else
231 SET_L(dest); /* No Additions for Rel-6 */
Jacob Erlbeck2647a332016-02-01 16:13:38 +0100232
Max0160a292019-02-19 15:37:03 +0100233 return rc;
Jacob Erlbeck18831c32016-02-01 15:23:35 +0100234}
235
Max3eb47362019-02-19 18:41:22 +0100236/* 3GPP TS 44.018 Table 10.5.2.16.1 < Packet Uplink Assignment > -- Single Block Allocation */
237static int write_ia_rest_uplink_sba(bitvec *dest, uint32_t fn, uint8_t alpha, uint8_t gamma)
Jacob Erlbeck18831c32016-02-01 15:23:35 +0100238{
Max0160a292019-02-19 15:37:03 +0100239 int rc = 0;
Jacob Erlbeckbe80c362016-02-01 16:39:52 +0100240
Max3eb47362019-02-19 18:41:22 +0100241 SET_0(dest); /* Single Block Allocation */
242 rc = write_alpha_gamma(dest, alpha, gamma);
243 CHECK(rc);
Max0160a292019-02-19 15:37:03 +0100244
Max3eb47362019-02-19 18:41:22 +0100245 /* A 'Timing Advance index' shall not be allocated at a Single Block allocation.
246 A 'TBF Starting Time' shall be allocated at a Single Block allocation. */
247 SET_0(dest);
248 SET_1(dest);
Max0160a292019-02-19 15:37:03 +0100249
Max3eb47362019-02-19 18:41:22 +0100250 rc = write_tbf_start_time(dest, fn);
251 CHECK(rc);
252
253 /* No P0 nor PR_MODE */
254 SET_L(dest);
255
256 /* No Additions for R99 */
257 SET_L(dest);
258
259 /* No Additions for Rel-6 */
260 SET_L(dest);
Max0160a292019-02-19 15:37:03 +0100261
262 return rc;
Jacob Erlbeck18831c32016-02-01 15:23:35 +0100263}
264
Max0160a292019-02-19 15:37:03 +0100265static int write_ia_rest_uplink_mba(const gprs_rlcmac_ul_tbf *tbf, bitvec *dest, uint8_t usf,
Maxe742cc02019-03-12 18:42:09 +0100266 uint8_t alpha, uint8_t gamma, int8_t ta_idx)
Jacob Erlbeckbe80c362016-02-01 16:39:52 +0100267{
Max0160a292019-02-19 15:37:03 +0100268 int rc = 0;
bhargava465f5bb2016-09-02 16:50:43 +0530269
Max0367ddd2019-03-12 18:31:54 +0100270 SET_1(dest); /* Multi Block Allocation */
bhargava465f5bb2016-09-02 16:50:43 +0530271
Max0367ddd2019-03-12 18:31:54 +0100272 rc = write_tfi_usf(dest, tbf, usf);
273 CHECK(rc);
bhargava465f5bb2016-09-02 16:50:43 +0530274
Max0367ddd2019-03-12 18:31:54 +0100275 /* 3GPP TS 44.060 Table 11.2.28.2 Channel Coding Indicator */
276 rc = bitvec_set_u64(dest, mcs_chan_code(tbf->current_cs()), 2, false); /* CHANNEL_CODING_COMMAND */
277 CHECK(rc);
278
279 /* TLLI_BLOCK_CHANNEL_CODING */
280 SET_1(dest); /* use coding scheme as specified by the corresponding CHANNEL CODING COMMAND */
281
282 rc = write_alpha_gamma(dest, alpha, gamma);
283 CHECK(rc);
284
Maxe742cc02019-03-12 18:42:09 +0100285 rc = write_ta_index(dest, ta_idx);
286 CHECK(rc);
Max0367ddd2019-03-12 18:31:54 +0100287
288 /* No TBF_STARTING_TIME */
289 SET_0(dest);
bhargava465f5bb2016-09-02 16:50:43 +0530290
Max0160a292019-02-19 15:37:03 +0100291 return rc;
292}
bhargava465f5bb2016-09-02 16:50:43 +0530293
Maxbd5647e2019-02-19 18:10:12 +0100294static int write_ia_rest_egprs_uplink_mba(bitvec * dest, uint32_t fn, uint8_t alpha, uint8_t gamma)
Max0160a292019-02-19 15:37:03 +0100295{
296 int rc = 0;
bhargava465f5bb2016-09-02 16:50:43 +0530297
Maxbd5647e2019-02-19 18:10:12 +0100298 SET_0(dest); /* Multi Block Allocation */
bhargava465f5bb2016-09-02 16:50:43 +0530299
Maxbd5647e2019-02-19 18:10:12 +0100300 rc = write_alpha_gamma(dest, alpha, gamma);
301 CHECK(rc);
bhargava465f5bb2016-09-02 16:50:43 +0530302
Maxbd5647e2019-02-19 18:10:12 +0100303 rc = write_tbf_start_time(dest, fn);
304 CHECK(rc);
Max0160a292019-02-19 15:37:03 +0100305
Maxbd5647e2019-02-19 18:10:12 +0100306 SET_0(dest); /* NUMBER OF RADIO BLOCKS ALLOCATED: */
307 SET_0(dest); /* 1 radio block reserved for uplink transmission */
308 SET_0(dest); /* No P0 */
Max0160a292019-02-19 15:37:03 +0100309
310 return rc;
311}
312
313static int write_ia_rest_egprs_uplink_sba(const gprs_rlcmac_ul_tbf *tbf, bitvec * dest, uint8_t usf,
Maxe742cc02019-03-12 18:42:09 +0100314 uint8_t alpha, uint8_t gamma, int8_t ta_idx)
Max0160a292019-02-19 15:37:03 +0100315{
316 int rc = 0;
317
Max2a47c732019-02-19 18:25:13 +0100318 SET_1(dest); /* Single Block Allocation */
Max0160a292019-02-19 15:37:03 +0100319
Max2a47c732019-02-19 18:25:13 +0100320 rc = write_tfi_usf(dest, tbf, usf);
321 CHECK(rc);
Max0160a292019-02-19 15:37:03 +0100322
Max2a47c732019-02-19 18:25:13 +0100323 /* 3GPP TS 44.060 §12.10d EGPRS Modulation and coding Scheme description: */
Max6e96dd42019-03-06 18:17:32 +0100324 rc = bitvec_set_u64(dest, mcs_chan_code(tbf->current_cs()), 4, false); /* EGPRS CHANNEL_CODING_COMMAND */
Max2a47c732019-02-19 18:25:13 +0100325 CHECK(rc);
Max0160a292019-02-19 15:37:03 +0100326
Max2a47c732019-02-19 18:25:13 +0100327 /* TLLI_BLOCK_CHANNEL_CODING */
328 rc = bitvec_set_bit(dest, (bit_value)tbf->tlli());
Max0160a292019-02-19 15:37:03 +0100329
Max2a47c732019-02-19 18:25:13 +0100330 /* No BEP_PERIOD2 */
331 SET_0(dest);
332
333 /* Retransmitted RLC data blocks shall not be re-segmented: (see 3GPP TS 44.060 §12.10e) */
334 SET_0(dest); /* RESEGMENT */
335
336 rc = bitvec_set_u64(dest, enc_ws(tbf->window_size()), 5, false); /* EGPRS Window Size */
337 CHECK(rc);
338
339 rc = write_alpha_gamma(dest, alpha, gamma);
340 CHECK(rc);
341
Maxe742cc02019-03-12 18:42:09 +0100342 rc = write_ta_index(dest, ta_idx);
343 CHECK(rc);
Max2a47c732019-02-19 18:25:13 +0100344
345 /* No TBF_STARTING_TIME */
346 SET_0(dest);
347
348 /* No Additions for Rel-7 */
349 SET_0(dest);
Max0160a292019-02-19 15:37:03 +0100350
351 return rc;
Jacob Erlbeckbe80c362016-02-01 16:39:52 +0100352}
353
Jacob Erlbeck18831c32016-02-01 15:23:35 +0100354/*
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530355 * Immediate assignment reject, sent on the CCCH/AGCH
356 * see GSM 44.018, 9.1.20 + 10.5.2.30
357 */
358int Encoding::write_immediate_assignment_reject(
359 bitvec *dest, uint16_t ra,
360 uint32_t ref_fn,
361 enum ph_burst_type burst_type)
362{
363 unsigned wp = 0;
364 int plen;
365 int i;
366
Alexander Couzensccde5c92017-02-04 03:10:08 +0100367 bitvec_write_field(dest, &wp, 0x0, 4); // Skip Indicator
368 bitvec_write_field(dest, &wp, 0x6, 4); // Protocol Discriminator
369 bitvec_write_field(dest, &wp, 0x3A, 8); // Immediate Assign Message Type
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530370
371 // feature indicator
Alexander Couzensccde5c92017-02-04 03:10:08 +0100372 bitvec_write_field(dest, &wp, 0x0, 1); // spare
373 bitvec_write_field(dest, &wp, 0x0, 1); // spare
374 bitvec_write_field(dest, &wp, 0x0, 1); // no cs
375 bitvec_write_field(dest, &wp, 0x1, 1); // implicit detach for PS
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530376
Alexander Couzensccde5c92017-02-04 03:10:08 +0100377 bitvec_write_field(dest, &wp, 0x0, 4); // Page Mode
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530378 /*
379 * 9.1.20.2 of 44.018 version 11.7.0 Release 11
380 * Filling of the message
381 * If necessary the request reference information element and the
382 * wait indication information element should be duplicated to
383 * fill the message.
384 * TODO: group rejection for multiple MS
385 */
386 for (i = 0; i < 4; i++) {
387 //10.5.2.30 Request Reference
388 if (((burst_type == GSM_L1_BURST_TYPE_ACCESS_1) ||
389 (burst_type == GSM_L1_BURST_TYPE_ACCESS_2))) {
390 //9.1.20.2a of 44.018 version 11.7.0 Release 11
Alexander Couzensccde5c92017-02-04 03:10:08 +0100391 bitvec_write_field(dest, &wp, 0x7f, 8); /* RACH value */
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530392 } else {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100393 bitvec_write_field(dest, &wp, ra, 8); /* RACH value */
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530394 }
395
Alexander Couzensccde5c92017-02-04 03:10:08 +0100396 bitvec_write_field(dest, &wp,
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530397 (ref_fn / (26 * 51)) % 32, 5); // T1'
Alexander Couzensccde5c92017-02-04 03:10:08 +0100398 bitvec_write_field(dest, &wp, ref_fn % 51, 6); // T3
399 bitvec_write_field(dest, &wp, ref_fn % 26, 5); // T2
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530400
401 /* TODO: Make it configurable */
Alexander Couzensccde5c92017-02-04 03:10:08 +0100402 bitvec_write_field(dest, &wp, 20, 8); //Wait Indication 1
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530403 }
404
405 plen = wp / 8;
406
407 if ((wp % 8)) {
408 LOGP(DRLCMACUL, LOGL_ERROR, "Length of IMM.ASS.Rej without"
409 "rest octets is not multiple of 8 bits, PLEASE FIX!\n");
410 return -1;
411 }
412
413 // Extended RA
414 else if (((burst_type == GSM_L1_BURST_TYPE_ACCESS_1) ||
415 (burst_type == GSM_L1_BURST_TYPE_ACCESS_2))) {
416 //9.1.20.2a of 44.018 version 11.7.0 Release 11
417 uint8_t extended_ra = 0;
418
419 extended_ra = (ra & 0x1F);
Alexander Couzensccde5c92017-02-04 03:10:08 +0100420 bitvec_write_field(dest, &wp, 0x1, 1);
421 bitvec_write_field(dest, &wp, extended_ra, 5); /* Extended RA */
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530422 } else {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100423 bitvec_write_field(dest, &wp, 0x0, 1);
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530424 }
Alexander Couzensccde5c92017-02-04 03:10:08 +0100425 bitvec_write_field(dest, &wp, 0x0, 1);
426 bitvec_write_field(dest, &wp, 0x0, 1);
427 bitvec_write_field(dest, &wp, 0x0, 1);
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530428
429 return plen;
430}
431
Max0a8fae82017-03-08 18:53:30 +0100432static inline void log_alert_exit(const char * error)
433{
434 LOGP(DRLCMACUL, LOGL_ERROR, error);
435 pcu_tx_txt_ind(PCU_OML_ALERT, error);
436 exit(1);
437}
438
aravind sirsikarc0c3afd2016-11-09 16:27:00 +0530439/*
Jacob Erlbeck18831c32016-02-01 15:23:35 +0100440 * Immediate assignment, sent on the CCCH/AGCH
441 * see GSM 04.08, 9.1.18 and GSM 44.018, 9.1.18 + 10.5.2.16
442 */
Holger Hans Peter Freyther63f29d62013-10-19 19:04:03 +0200443int Encoding::write_immediate_assignment(
Jacob Erlbeck2647a332016-02-01 16:13:38 +0100444 struct gprs_rlcmac_tbf *tbf,
Maxfc8afc22019-02-18 18:52:38 +0100445 bitvec * dest, bool downlink, uint16_t ra,
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200446 uint32_t ref_fn, uint8_t ta, uint16_t arfcn, uint8_t ts, uint8_t tsc,
Maxfc8afc22019-02-18 18:52:38 +0100447 uint8_t usf, bool polling, uint32_t fn, uint8_t alpha,
448 uint8_t gamma, int8_t ta_idx, enum ph_burst_type burst_type)
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200449{
450 unsigned wp = 0;
Jacob Erlbeck2647a332016-02-01 16:13:38 +0100451 int plen;
452 int rc;
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200453
Alexander Couzensccde5c92017-02-04 03:10:08 +0100454 bitvec_write_field(dest, &wp,0x0,4); // Skip Indicator
455 bitvec_write_field(dest, &wp,0x6,4); // Protocol Discriminator
456 bitvec_write_field(dest, &wp,0x3F,8); // Immediate Assignment Message Type
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200457
458 // 10.5.2.25b Dedicated mode or TBF
Alexander Couzensccde5c92017-02-04 03:10:08 +0100459 bitvec_write_field(dest, &wp,0x0,1); // spare
460 bitvec_write_field(dest, &wp,0x0,1); // TMA : Two-message assignment: No meaning
461 bitvec_write_field(dest, &wp,downlink,1); // Downlink : Downlink assignment to mobile in packet idle mode
462 bitvec_write_field(dest, &wp,0x1,1); // T/D : TBF or dedicated mode: this message assigns a Temporary Block Flow (TBF).
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200463
Alexander Couzensccde5c92017-02-04 03:10:08 +0100464 bitvec_write_field(dest, &wp,0x0,4); // Page Mode
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200465
466 // GSM 04.08 10.5.2.25a Packet Channel Description
Alexander Couzensccde5c92017-02-04 03:10:08 +0100467 bitvec_write_field(dest, &wp,0x1,5); // Channel type
468 bitvec_write_field(dest, &wp,ts,3); // TN
469 bitvec_write_field(dest, &wp,tsc,3); // TSC
470 bitvec_write_field(dest, &wp,0x0,3); // non-hopping RF channel configuraion
471 bitvec_write_field(dest, &wp,arfcn,10); // ARFCN
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200472
473 //10.5.2.30 Request Reference
bhargava465f5bb2016-09-02 16:50:43 +0530474 if (((burst_type == GSM_L1_BURST_TYPE_ACCESS_1) ||
475 (burst_type == GSM_L1_BURST_TYPE_ACCESS_2))) {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100476 bitvec_write_field(dest, &wp, 0x7f, 8); /* RACH value */
bhargava465f5bb2016-09-02 16:50:43 +0530477 } else {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100478 bitvec_write_field(dest, &wp, ra, 8); /* RACH value */
bhargava465f5bb2016-09-02 16:50:43 +0530479 }
480
Alexander Couzensccde5c92017-02-04 03:10:08 +0100481 bitvec_write_field(dest, &wp,(ref_fn / (26 * 51)) % 32,5); // T1'
482 bitvec_write_field(dest, &wp,ref_fn % 51,6); // T3
483 bitvec_write_field(dest, &wp,ref_fn % 26,5); // T2
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200484
485 // 10.5.2.40 Timing Advance
Alexander Couzensccde5c92017-02-04 03:10:08 +0100486 bitvec_write_field(dest, &wp,0x0,2); // spare
487 bitvec_write_field(dest, &wp,ta,6); // Timing Advance value
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200488
489 // No mobile allocation in non-hopping systems.
490 // A zero-length LV. Just write L=0.
Alexander Couzensccde5c92017-02-04 03:10:08 +0100491 bitvec_write_field(dest, &wp,0,8);
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200492
Max0a8fae82017-03-08 18:53:30 +0100493 if ((wp % 8))
494 log_alert_exit("Length of IMM.ASS without rest octets is not "
495 "multiple of 8 bits, PLEASE FIX!\n");
496
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200497 plen = wp / 8;
498
Max0160a292019-02-19 15:37:03 +0100499 /* 3GPP TS 44.018 §10.5.2.16 IA Rest Octets */
Max3fa235f2019-03-13 19:08:02 +0100500 dest->cur_bit = wp;
Max0160a292019-02-19 15:37:03 +0100501 if (downlink) {
502 if (!as_dl_tbf(tbf)) {
503 LOGP(DRLCMACDL, LOGL_ERROR, "Cannot encode DL IMMEDIATE ASSIGNMENT without TBF\n");
504 return -EINVAL;
505 }
Max23c0e012019-02-19 17:49:27 +0100506
Max0160a292019-02-19 15:37:03 +0100507 rc = write_ia_rest_downlink(as_dl_tbf(tbf), dest, polling, gsm48_ta_is_valid(ta), fn, alpha, gamma,
Max23c0e012019-02-19 17:49:27 +0100508 ta_idx);
Max0160a292019-02-19 15:37:03 +0100509 } else if (((burst_type == GSM_L1_BURST_TYPE_ACCESS_1) || (burst_type == GSM_L1_BURST_TYPE_ACCESS_2))) {
Max3fa235f2019-03-13 19:08:02 +0100510 SET_L(dest); SET_H(dest); // "LH"
511 SET_0(dest); SET_0(dest); // "00" < EGPRS Packet Uplink Assignment >
512 rc = bitvec_set_u64(dest, ra & 0x1F, 5, false); // < Extended RA >
513 CHECK(rc);
Max0160a292019-02-19 15:37:03 +0100514
Max3fa235f2019-03-13 19:08:02 +0100515 SET_0(dest); // No < Access Technologies Request struct >
516
517 if (as_ul_tbf(tbf) != NULL)
Maxe742cc02019-03-12 18:42:09 +0100518 rc = write_ia_rest_egprs_uplink_sba(as_ul_tbf(tbf), dest, usf, alpha, gamma, ta_idx);
Max3fa235f2019-03-13 19:08:02 +0100519 else
Maxbd5647e2019-02-19 18:10:12 +0100520 rc = write_ia_rest_egprs_uplink_mba(dest, fn, alpha, gamma);
Max0160a292019-02-19 15:37:03 +0100521 } else {
522 OSMO_ASSERT(!tbf || !tbf->is_egprs_enabled());
523
Max3fa235f2019-03-13 19:08:02 +0100524 SET_H(dest); SET_H(dest); // "HH"
525 SET_0(dest); SET_0(dest); // "00" < Packet Uplink Assignment >
Max0160a292019-02-19 15:37:03 +0100526
Max3fa235f2019-03-13 19:08:02 +0100527 if (as_ul_tbf(tbf) != NULL)
Maxe742cc02019-03-12 18:42:09 +0100528 rc = write_ia_rest_uplink_mba(as_ul_tbf(tbf), dest, usf, alpha, gamma, ta_idx);
Max3fa235f2019-03-13 19:08:02 +0100529 else
Max3eb47362019-02-19 18:41:22 +0100530 rc = write_ia_rest_uplink_sba(dest, fn, alpha, gamma);
Max0160a292019-02-19 15:37:03 +0100531 }
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200532
Jacob Erlbeck2647a332016-02-01 16:13:38 +0100533 if (rc < 0) {
534 LOGP(DRLCMAC, LOGL_ERROR,
535 "Failed to create IMMEDIATE ASSIGMENT (%s) for %s\n",
536 downlink ? "downlink" : "uplink",
537 tbf ? tbf->name() : "single block allocation");
538 return rc;
539 }
540
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200541 return plen;
542}
543
544/* generate uplink assignment */
Holger Hans Peter Freyther63f29d62013-10-19 19:04:03 +0200545void Encoding::write_packet_uplink_assignment(
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200546 bitvec * dest, uint8_t old_tfi,
547 uint8_t old_downlink, uint32_t tlli, uint8_t use_tlli,
Jacob Erlbeckf2694b72016-01-26 21:46:26 +0100548 struct gprs_rlcmac_ul_tbf *tbf, uint8_t poll, uint8_t rrbp, uint8_t alpha,
Jacob Erlbeck76d767c2015-09-28 18:54:32 +0200549 uint8_t gamma, int8_t ta_idx, int8_t use_egprs)
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200550{
551 // TODO We should use our implementation of encode RLC/MAC Control messages.
552 unsigned wp = 0;
553 uint8_t ts;
Maxae483812016-07-28 12:03:08 +0200554 /* timeslot assigned for the Continuous Timing Advance procedure */
555 uint8_t ta_ts = 0; /* FIXME: supply it as parameter from caller */
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200556
Alexander Couzensccde5c92017-02-04 03:10:08 +0100557 bitvec_write_field(dest, &wp,0x1,2); // Payload Type
558 bitvec_write_field(dest, &wp,0x0,2); // Uplink block with TDMA framenumber (N+13)
559 bitvec_write_field(dest, &wp,poll,1); // Suppl/Polling Bit
560 bitvec_write_field(dest, &wp,0x0,3); // Uplink state flag
561 bitvec_write_field(dest, &wp,0xa,6); // MESSAGE TYPE
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200562
Alexander Couzensccde5c92017-02-04 03:10:08 +0100563 bitvec_write_field(dest, &wp,0x0,2); // Page Mode
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200564
Alexander Couzensccde5c92017-02-04 03:10:08 +0100565 bitvec_write_field(dest, &wp,0x0,1); // switch PERSIST_LEVEL: off
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200566 if (use_tlli) {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100567 bitvec_write_field(dest, &wp,0x2,2); // switch TLLI : on
568 bitvec_write_field(dest, &wp,tlli,32); // TLLI
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200569 } else {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100570 bitvec_write_field(dest, &wp,0x0,1); // switch TFI : on
571 bitvec_write_field(dest, &wp,old_downlink,1); // 0=UPLINK TFI, 1=DL TFI
572 bitvec_write_field(dest, &wp,old_tfi,5); // TFI
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200573 }
574
Jacob Erlbeck76d767c2015-09-28 18:54:32 +0200575 if (!use_egprs) {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100576 bitvec_write_field(dest, &wp,0x0,1); // Message escape
Max6e96dd42019-03-06 18:17:32 +0100577 bitvec_write_field(dest, &wp, mcs_chan_code(tbf->current_cs()), 2); // CHANNEL_CODING_COMMAND
Alexander Couzensccde5c92017-02-04 03:10:08 +0100578 bitvec_write_field(dest, &wp,0x1,1); // TLLI_BLOCK_CHANNEL_CODING
Maxae483812016-07-28 12:03:08 +0200579 write_ta_ie(dest, wp,tbf->ta(), ta_idx, ta_ts);
Jacob Erlbeck76d767c2015-09-28 18:54:32 +0200580 } else { /* EPGRS */
Alexander Couzensccde5c92017-02-04 03:10:08 +0100581 bitvec_write_field(dest, &wp,0x1,1); // Message escape
582 bitvec_write_field(dest, &wp,0x0,2); // EGPRS message contents
583 bitvec_write_field(dest, &wp,0x0,1); // No CONTENTION_RESOLUTION_TLLI
584 bitvec_write_field(dest, &wp,0x0,1); // No COMPACT reduced MA
Max6e96dd42019-03-06 18:17:32 +0100585 bitvec_write_field(dest, &wp, mcs_chan_code(tbf->current_cs()), 4); // EGPRS Modulation and Coding IE
Aravind Sirsikar505a86d2016-07-26 18:26:21 +0530586 /* 0: no RESEGMENT, 1: Segmentation*/
Alexander Couzensccde5c92017-02-04 03:10:08 +0100587 bitvec_write_field(dest, &wp, 0x1, 1);
Maxa4f570f2017-12-15 11:21:57 +0100588 write_ws(dest, &wp, tbf->window_size()); // EGPRS Window Size
Alexander Couzensccde5c92017-02-04 03:10:08 +0100589 bitvec_write_field(dest, &wp,0x0,1); // No Access Technologies Request
590 bitvec_write_field(dest, &wp,0x0,1); // No ARAC RETRANSMISSION REQUEST
591 bitvec_write_field(dest, &wp,0x1,1); // TLLI_BLOCK_CHANNEL_CODING
592 bitvec_write_field(dest, &wp,0x0,1); // No BEP_PERIOD2
Maxae483812016-07-28 12:03:08 +0200593 write_ta_ie(dest, wp,tbf->ta(), ta_idx, ta_ts);
Alexander Couzensccde5c92017-02-04 03:10:08 +0100594 bitvec_write_field(dest, &wp,0x0,1); // No Packet Extended Timing Advance
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200595 }
596
597#if 1
Alexander Couzensccde5c92017-02-04 03:10:08 +0100598 bitvec_write_field(dest, &wp,0x1,1); // Frequency Parameters information elements = present
599 bitvec_write_field(dest, &wp,tbf->tsc(),3); // Training Sequence Code (TSC)
600 bitvec_write_field(dest, &wp,0x0,2); // ARFCN = present
601 bitvec_write_field(dest, &wp,tbf->trx->arfcn,10); // ARFCN
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200602#else
Alexander Couzensccde5c92017-02-04 03:10:08 +0100603 bitvec_write_field(dest, &wp,0x0,1); // Frequency Parameters = off
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200604#endif
605
Alexander Couzensccde5c92017-02-04 03:10:08 +0100606 bitvec_write_field(dest, &wp,0x1,2); // Dynamic Allocation
Jacob Erlbeckedfd7e32015-11-17 16:30:58 +0100607
Alexander Couzensccde5c92017-02-04 03:10:08 +0100608 bitvec_write_field(dest, &wp,0x0,1); // Extended Dynamic Allocation = off
609 bitvec_write_field(dest, &wp,0x0,1); // P0 = off
Jacob Erlbeckedfd7e32015-11-17 16:30:58 +0100610
Alexander Couzensccde5c92017-02-04 03:10:08 +0100611 bitvec_write_field(dest, &wp,0x0,1); // USF_GRANULARITY
612 bitvec_write_field(dest, &wp,0x1,1); // switch TFI : on
613 bitvec_write_field(dest, &wp,tbf->tfi(),5);// TFI
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200614
Alexander Couzensccde5c92017-02-04 03:10:08 +0100615 bitvec_write_field(dest, &wp,0x0,1); //
616 bitvec_write_field(dest, &wp,0x0,1); // TBF Starting Time = off
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200617 if (alpha || gamma) {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100618 bitvec_write_field(dest, &wp,0x1,1); // Timeslot Allocation with Power Control
619 bitvec_write_field(dest, &wp,alpha,4); // ALPHA
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200620 } else
Alexander Couzensccde5c92017-02-04 03:10:08 +0100621 bitvec_write_field(dest, &wp,0x0,1); // Timeslot Allocation
Jacob Erlbeckedfd7e32015-11-17 16:30:58 +0100622
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200623 for (ts = 0; ts < 8; ts++) {
624 if (tbf->pdch[ts]) {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100625 bitvec_write_field(dest, &wp,0x1,1); // USF_TN(i): on
626 bitvec_write_field(dest, &wp,tbf->m_usf[ts],3); // USF_TN(i)
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200627 if (alpha || gamma)
Alexander Couzensccde5c92017-02-04 03:10:08 +0100628 bitvec_write_field(dest, &wp,gamma,5); // GAMMA power control parameter
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200629 } else
Alexander Couzensccde5c92017-02-04 03:10:08 +0100630 bitvec_write_field(dest, &wp,0x0,1); // USF_TN(i): off
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200631 }
Alexander Couzensccde5c92017-02-04 03:10:08 +0100632 // bitvec_write_field(dest, &wp,0x0,1); // Measurement Mapping struct not present
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200633}
634
635
636/* generate downlink assignment */
Jacob Erlbeck166c9fc2016-01-07 16:04:29 +0100637void Encoding::write_packet_downlink_assignment(RlcMacDownlink_t * block,
Jacob Erlbeck6b356a52016-01-29 16:39:21 +0100638 bool old_tfi_is_valid, uint8_t old_tfi, uint8_t old_downlink,
Maxa4f570f2017-12-15 11:21:57 +0100639 struct gprs_rlcmac_dl_tbf *tbf, uint8_t poll, uint8_t rrbp,
Jacob Erlbeck6b356a52016-01-29 16:39:21 +0100640 uint8_t alpha, uint8_t gamma, int8_t ta_idx,
Jacob Erlbeckf2694b72016-01-26 21:46:26 +0100641 uint8_t ta_ts, bool use_egprs)
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200642{
643 // Packet downlink assignment TS 44.060 11.2.7
644
Jacob Erlbeck166c9fc2016-01-07 16:04:29 +0100645 PDA_AdditionsR99_t *pda_r99;
646
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200647 uint8_t tn;
648
649 block->PAYLOAD_TYPE = 0x1; // RLC/MAC control block that does not include the optional octets of the RLC/MAC control header
Jacob Erlbeckf2694b72016-01-26 21:46:26 +0100650 block->RRBP = rrbp; // 0: N+13
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200651 block->SP = poll; // RRBP field is valid
652 block->USF = 0x0; // Uplink state flag
653
654 block->u.Packet_Downlink_Assignment.MESSAGE_TYPE = 0x2; // Packet Downlink Assignment
655 block->u.Packet_Downlink_Assignment.PAGE_MODE = 0x0; // Normal Paging
656
657 block->u.Packet_Downlink_Assignment.Exist_PERSISTENCE_LEVEL = 0x0; // PERSISTENCE_LEVEL: off
658
Jacob Erlbeck6b356a52016-01-29 16:39:21 +0100659 if (old_tfi_is_valid) {
660 block->u.Packet_Downlink_Assignment.ID.UnionType = 0x0; // TFI = on
661 block->u.Packet_Downlink_Assignment.ID.u.Global_TFI.UnionType = old_downlink; // 0=UPLINK TFI, 1=DL TFI
662 block->u.Packet_Downlink_Assignment.ID.u.Global_TFI.u.UPLINK_TFI = old_tfi; // TFI
663 } else {
664 block->u.Packet_Downlink_Assignment.ID.UnionType = 0x1; // TLLI
665 block->u.Packet_Downlink_Assignment.ID.u.TLLI = tbf->tlli();
666 }
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200667
668 block->u.Packet_Downlink_Assignment.MAC_MODE = 0x0; // Dynamic Allocation
669 block->u.Packet_Downlink_Assignment.RLC_MODE = 0x0; // RLC acknowledged mode
Daniel Willmann73191a42014-05-30 17:58:00 +0200670 block->u.Packet_Downlink_Assignment.CONTROL_ACK = tbf->was_releasing; // NW establishes no new DL TBF for the MS with running timer T3192
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200671 block->u.Packet_Downlink_Assignment.TIMESLOT_ALLOCATION = 0; // timeslot(s)
672 for (tn = 0; tn < 8; tn++) {
673 if (tbf->pdch[tn])
674 block->u.Packet_Downlink_Assignment.TIMESLOT_ALLOCATION |= 0x80 >> tn; // timeslot(s)
675 }
676
677 block->u.Packet_Downlink_Assignment.Packet_Timing_Advance.Exist_TIMING_ADVANCE_VALUE = 0x1; // TIMING_ADVANCE_VALUE = on
Jacob Erlbeck9200ce62015-05-22 17:48:04 +0200678 block->u.Packet_Downlink_Assignment.Packet_Timing_Advance.TIMING_ADVANCE_VALUE = tbf->ta(); // TIMING_ADVANCE_VALUE
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200679 if (ta_idx < 0) {
680 block->u.Packet_Downlink_Assignment.Packet_Timing_Advance.Exist_IndexAndtimeSlot = 0x0; // TIMING_ADVANCE_INDEX = off
681 } else {
682 block->u.Packet_Downlink_Assignment.Packet_Timing_Advance.Exist_IndexAndtimeSlot = 0x1; // TIMING_ADVANCE_INDEX = on
683 block->u.Packet_Downlink_Assignment.Packet_Timing_Advance.TIMING_ADVANCE_INDEX = ta_idx; // TIMING_ADVANCE_INDEX
684 block->u.Packet_Downlink_Assignment.Packet_Timing_Advance.TIMING_ADVANCE_TIMESLOT_NUMBER = ta_ts; // TIMING_ADVANCE_TS
685 }
686
687 block->u.Packet_Downlink_Assignment.Exist_P0_and_BTS_PWR_CTRL_MODE = 0x0; // POWER CONTROL = off
688
689 block->u.Packet_Downlink_Assignment.Exist_Frequency_Parameters = 0x1; // Frequency Parameters = on
Holger Hans Peter Freyther8f399de2013-12-25 20:22:35 +0100690 block->u.Packet_Downlink_Assignment.Frequency_Parameters.TSC = tbf->tsc(); // Training Sequence Code (TSC)
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200691 block->u.Packet_Downlink_Assignment.Frequency_Parameters.UnionType = 0x0; // ARFCN = on
Holger Hans Peter Freytherfc498c92013-10-27 13:38:54 +0100692 block->u.Packet_Downlink_Assignment.Frequency_Parameters.u.ARFCN = tbf->trx->arfcn; // ARFCN
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200693
694 block->u.Packet_Downlink_Assignment.Exist_DOWNLINK_TFI_ASSIGNMENT = 0x1; // DOWNLINK TFI ASSIGNMENT = on
Holger Hans Peter Freyther34f6e5e2013-10-27 20:31:47 +0100695 block->u.Packet_Downlink_Assignment.DOWNLINK_TFI_ASSIGNMENT = tbf->tfi(); // TFI
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200696
697 block->u.Packet_Downlink_Assignment.Exist_Power_Control_Parameters = 0x1; // Power Control Parameters = on
698 block->u.Packet_Downlink_Assignment.Power_Control_Parameters.ALPHA = alpha; // ALPHA
699
700 for (tn = 0; tn < 8; tn++)
701 {
702 if (tbf->pdch[tn])
703 {
704 block->u.Packet_Downlink_Assignment.Power_Control_Parameters.Slot[tn].Exist = 0x1; // Slot[i] = on
705 block->u.Packet_Downlink_Assignment.Power_Control_Parameters.Slot[tn].GAMMA_TN = gamma; // GAMMA_TN
706 }
707 else
708 {
709 block->u.Packet_Downlink_Assignment.Power_Control_Parameters.Slot[tn].Exist = 0x0; // Slot[i] = off
710 }
711 }
712
713 block->u.Packet_Downlink_Assignment.Exist_TBF_Starting_Time = 0x0; // TBF Starting TIME = off
714 block->u.Packet_Downlink_Assignment.Exist_Measurement_Mapping = 0x0; // Measurement_Mapping = off
Jacob Erlbeck166c9fc2016-01-07 16:04:29 +0100715 if (!use_egprs) {
716 block->u.Packet_Downlink_Assignment.Exist_AdditionsR99 = 0x0; // AdditionsR99 = off
717 return;
718 }
Jacob Erlbeck36df7742016-01-19 15:53:30 +0100719
Jacob Erlbeck166c9fc2016-01-07 16:04:29 +0100720 block->u.Packet_Downlink_Assignment.Exist_AdditionsR99 = 0x1; // AdditionsR99 = on
721 pda_r99 = &block->u.Packet_Downlink_Assignment.AdditionsR99;
722 pda_r99->Exist_EGPRS_Params = 1;
Maxa4f570f2017-12-15 11:21:57 +0100723 pda_r99->EGPRS_WindowSize = enc_ws(tbf->window_size()); /* see TS 44.060, table 12.5.2.1 */
Jacob Erlbeck166c9fc2016-01-07 16:04:29 +0100724 pda_r99->LINK_QUALITY_MEASUREMENT_MODE = 0x0; /* no meas, see TS 44.060, table 11.2.7.2 */
725 pda_r99->Exist_BEP_PERIOD2 = 0; /* No extra EGPRS BEP PERIOD */
726 pda_r99->Exist_Packet_Extended_Timing_Advance = 0;
727 pda_r99->Exist_COMPACT_ReducedMA = 0;
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200728}
729
Stefan Sperling513c9bc2018-05-02 14:53:16 +0200730/* Generate paging request. See 44.018, sections 10 and 9.1.22 */
Holger Hans Peter Freyther63f29d62013-10-19 19:04:03 +0200731int Encoding::write_paging_request(bitvec * dest, uint8_t *ptmsi, uint16_t ptmsi_len)
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200732{
733 unsigned wp = 0;
734 int plen;
735
Alexander Couzensccde5c92017-02-04 03:10:08 +0100736 bitvec_write_field(dest, &wp,0x0,4); // Skip Indicator
737 bitvec_write_field(dest, &wp,0x6,4); // Protocol Discriminator
Stefan Sperling513c9bc2018-05-02 14:53:16 +0200738 bitvec_write_field(dest, &wp,0x21,8); // Paging Request Message Type 1
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200739
Alexander Couzensccde5c92017-02-04 03:10:08 +0100740 bitvec_write_field(dest, &wp,0x0,4); // Page Mode
741 bitvec_write_field(dest, &wp,0x0,4); // Channel Needed
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200742
743 // Mobile Identity
Alexander Couzensccde5c92017-02-04 03:10:08 +0100744 bitvec_write_field(dest, &wp,ptmsi_len+1,8); // Mobile Identity length
745 bitvec_write_field(dest, &wp,0xf,4); // unused
746 bitvec_write_field(dest, &wp,0x4,4); // PTMSI type
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200747 for (int i = 0; i < ptmsi_len; i++)
748 {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100749 bitvec_write_field(dest, &wp,ptmsi[i],8); // PTMSI
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200750 }
Max0a8fae82017-03-08 18:53:30 +0100751
752 if ((wp % 8))
753 log_alert_exit("Length of PAG.REQ without rest octets is not "
754 "multiple of 8 bits, PLEASE FIX!\n");
755
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200756 plen = wp / 8;
Stefan Sperling513c9bc2018-05-02 14:53:16 +0200757 bitvec_write_field(dest, &wp,0x0,1); // "L" Notification List Number; NLN(PCH) = off
Alexander Couzensccde5c92017-02-04 03:10:08 +0100758 bitvec_write_field(dest, &wp,0x0,1); // "L" Priority1 = off
759 bitvec_write_field(dest, &wp,0x1,1); // "L" Priority2 = off
760 bitvec_write_field(dest, &wp,0x0,1); // "L" Group Call information = off
761 bitvec_write_field(dest, &wp,0x0,1); // "H" Packet Page Indication 1 = packet paging procedure
762 bitvec_write_field(dest, &wp,0x1,1); // "H" Packet Page Indication 2 = packet paging procedure
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +0200763
764 return plen;
765}
766
Daniel Willmann5241c1a2013-12-11 14:35:29 +0100767/**
768 * The index of the array show_rbb is the bit position inside the rbb
769 * (show_rbb[63] relates to BSN ssn-1)
770 */
771void Encoding::encode_rbb(const char *show_rbb, uint8_t *rbb)
772{
773 uint8_t rbb_byte = 0;
774
775 // RECEIVE_BLOCK_BITMAP
776 for (int i = 0; i < 64; i++) {
777 /* Set bit at the appropriate position (see 3GPP TS 04.60 9.1.8.1) */
778 if (show_rbb[i] == 'R')
779 rbb_byte |= 1<< (7-(i%8));
780
781 if((i%8) == 7) {
782 rbb[i/8] = rbb_byte;
783 rbb_byte = 0;
784 }
785 }
786}
787
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100788static void write_packet_ack_nack_desc_gprs(
Alexander Couzens19e933b2019-06-16 15:25:30 +0200789 bitvec * dest, unsigned& wp,
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100790 gprs_rlc_ul_window *window, bool is_final)
791{
792 char rbb[65];
793
794 window->update_rbb(rbb);
795
796 rbb[64] = 0;
797 LOGP(DRLCMACUL, LOGL_DEBUG, "- V(N): \"%s\" R=Received "
798 "I=Invalid\n", rbb);
799
Alexander Couzensccde5c92017-02-04 03:10:08 +0100800 bitvec_write_field(dest, &wp, is_final, 1); // FINAL_ACK_INDICATION
801 bitvec_write_field(dest, &wp, window->ssn(), 7); // STARTING_SEQUENCE_NUMBER
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100802
803 for (int i = 0; i < 64; i++) {
804 /* Set bit at the appropriate position (see 3GPP TS 04.60 9.1.8.1) */
805 bool is_ack = (rbb[i] == 'R');
Alexander Couzensccde5c92017-02-04 03:10:08 +0100806 bitvec_write_field(dest, &wp, is_ack, 1);
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100807 }
808}
809
810static void write_packet_uplink_ack_gprs(
Alexander Couzens19e933b2019-06-16 15:25:30 +0200811 bitvec * dest, unsigned& wp,
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100812 struct gprs_rlcmac_ul_tbf *tbf, bool is_final)
813{
814
Max6e96dd42019-03-06 18:17:32 +0100815 bitvec_write_field(dest, &wp, mcs_chan_code(tbf->current_cs()), 2); // CHANNEL_CODING_COMMAND
Alexander Couzens19e933b2019-06-16 15:25:30 +0200816 write_packet_ack_nack_desc_gprs(dest, wp, tbf->window(), is_final);
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100817
Alexander Couzensccde5c92017-02-04 03:10:08 +0100818 bitvec_write_field(dest, &wp, 1, 1); // 1: have CONTENTION_RESOLUTION_TLLI
819 bitvec_write_field(dest, &wp, tbf->tlli(), 32); // CONTENTION_RESOLUTION_TLLI
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100820
Alexander Couzensccde5c92017-02-04 03:10:08 +0100821 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have Packet Timing Advance
822 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have Power Control Parameters
823 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have Extension Bits
824 bitvec_write_field(dest, &wp, 0, 1); // fixed 0
825 bitvec_write_field(dest, &wp, 1, 1); // 1: have Additions R99
826 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have Packet Extended Timing Advance
827 bitvec_write_field(dest, &wp, 1, 1); // TBF_EST (enabled)
828 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have REL 5
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100829};
830
831static void write_packet_ack_nack_desc_egprs(
Alexander Couzens19e933b2019-06-16 15:25:30 +0200832 bitvec * dest, unsigned& wp,
sivasankari8adfcd02017-01-16 15:41:21 +0530833 gprs_rlc_ul_window *window, bool is_final, unsigned& rest_bits)
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100834{
sivasankari8adfcd02017-01-16 15:41:21 +0530835 unsigned int urbb_len = 0;
836 uint8_t crbb_len = 0;
837 uint8_t len;
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100838 bool bow = true;
839 bool eow = true;
Alexander Couzensafe9d4e2019-06-16 16:20:10 +0200840 uint16_t ssn = window->mod_sns(window->v_q() + 1);
sivasankari8adfcd02017-01-16 15:41:21 +0530841 unsigned int num_blocks = window->mod_sns(window->v_r() - window->v_q());
Alexander Couzensafe9d4e2019-06-16 16:20:10 +0200842 uint16_t esn_crbb = window->mod_sns(ssn - 1);
sivasankari8adfcd02017-01-16 15:41:21 +0530843 static uint8_t rbb[RLC_EGPRS_MAX_WS] = {'\0'};
844 uint8_t iter = 0;
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530845 int is_compressed = 0;
sivasankari8adfcd02017-01-16 15:41:21 +0530846 bool try_compression = false;
Alexander Couzensafe9d4e2019-06-16 16:20:10 +0200847 uint16_t ucmp_bmplen;
sivasankari8adfcd02017-01-16 15:41:21 +0530848 uint8_t crbb_bitmap[23] = {'\0'};
849 bitvec ucmp_vec;
850 bitvec crbb_vec;
851 uint8_t uclen_crbb = 0;
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530852 bool len_coded = true;
sivasankari8adfcd02017-01-16 15:41:21 +0530853 uint8_t crbb_start_clr_code;
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530854 uint8_t i;
Alexander Couzens6c945302019-06-16 15:16:30 +0200855 /* static size of 16 bits
sivasankari8adfcd02017-01-16 15:41:21 +0530856 ..0. .... = ACKNACK: (Union)
857 Desc
858
859 ...0 .... = FINAL_ACK_INDICATION: False
860
861 .... 1... = BEGINNING_OF_WINDOW: 1
862
863 .... .1.. = END_OF_WINDOW: 1
864
865 .... ..10 0101 0001 1... .... = STARTING_SEQUENCE_NUMBER: 1187
866
Alexander Couzens6c945302019-06-16 15:16:30 +0200867 .0.. .... = CRBB Exist: 0 */
sivasankari8adfcd02017-01-16 15:41:21 +0530868 rest_bits -= 16;
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100869
870 if (num_blocks > 0)
871 /* V(Q) is NACK and omitted -> SSN = V(Q) + 1 */
872 num_blocks -= 1;
873
874 if (num_blocks > window->ws())
875 num_blocks = window->ws();
sivasankari8adfcd02017-01-16 15:41:21 +0530876 /* Try Compression as number of blocks does not fit */
877 if (num_blocks > rest_bits) {
878 try_compression = true;
879 }
880 if (try_compression == true) {
881 ucmp_bmplen = window->update_egprs_rbb(rbb);
882 ucmp_vec.data = rbb;
883 ucmp_vec.cur_bit = ucmp_bmplen;
884 ucmp_vec.data_len = 127;
885 crbb_vec.data = crbb_bitmap;
886 crbb_vec.cur_bit = 0;
887 crbb_vec.data_len = 127;
888 LOGP(DRLCMACUL, LOGL_DEBUG,
889 "rest_bits=%d uncompressed len %d and uncompressed bitmap = %s\n",
890 rest_bits, ucmp_bmplen,
891 osmo_hexdump(ucmp_vec.data, (ucmp_bmplen+7)/8));
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100892
sivasankari8adfcd02017-01-16 15:41:21 +0530893 is_compressed = egprs_compress::compress_rbb(&ucmp_vec, /* Uncompressed bitmap*/
894 &crbb_vec, /*Compressed bitmap vector */
895 &uclen_crbb,
896 (rest_bits - 16));/* CRBBlength:7 colourcode:1 dissector length:8*/
897 LOGP(DRLCMACUL, LOGL_DEBUG,
898 "the ucmp len=%d uclen_crbb=%d num_blocks=%d crbb length %d, "
899 "and the CRBB bitmap = %s\n",
900 ucmp_bmplen, uclen_crbb, num_blocks, crbb_vec.cur_bit,
901 osmo_hexdump(crbb_bitmap, (crbb_vec.cur_bit+7)/8));
902 crbb_len = crbb_vec.cur_bit;
903 }
904
905 if (is_compressed == 0) {
Alexander Couzenseace1042019-06-16 17:05:40 +0200906 /* define if the length field is needed or not.
907 * length field takes 8 bits */
908 if (num_blocks == rest_bits) {
909 urbb_len = rest_bits;
910 len_coded = false;
911 } else if (num_blocks > rest_bits) {
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530912 eow = false;
sivasankari8adfcd02017-01-16 15:41:21 +0530913 urbb_len = rest_bits;
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530914 len_coded = false;
Alexander Couzenseace1042019-06-16 17:05:40 +0200915 } else if (num_blocks <= (rest_bits - 8)) {
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530916 urbb_len = num_blocks;
Alexander Couzenseace1042019-06-16 17:05:40 +0200917 } else {
918 /* num_blocks < rest_bit && num_block > rest_bit - 8
919 * The spec is not clear, what happens this case.
920 * The problem here is an URBB without length field, but the URBB would
921 * have more bits than the window is valid.
922 * Enfore the length field and might loose 7 bits in worst case of performance
923 * to have a clear case. */
924 eow = false;
925 urbb_len = rest_bits - 8;
926 }
sivasankari8adfcd02017-01-16 15:41:21 +0530927
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100928 len = urbb_len + 15;
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530929 } else {
Alexander Couzens5fec67d2019-06-16 18:35:09 +0200930 /* 8 = 7 (CRBBlength) + 1 (CRBB starting color code) */
931 if (num_blocks > uclen_crbb + (rest_bits - crbb_len - 8)) {
sivasankari8adfcd02017-01-16 15:41:21 +0530932 eow = false;
933 len_coded = false;
934 urbb_len = rest_bits - crbb_len - 8;
Alexander Couzens5fec67d2019-06-16 18:35:09 +0200935 } else if (num_blocks == uclen_crbb + (rest_bits - crbb_len - 8)) {
sivasankari8adfcd02017-01-16 15:41:21 +0530936 len_coded = false;
Alexander Couzens5fec67d2019-06-16 18:35:09 +0200937 urbb_len = rest_bits - crbb_len - 8;
938 /* 16 = 8 (Length) + 7 (CRBBlength) + 1 (CRBB starting color code) */
939 } else if (num_blocks <= uclen_crbb + (rest_bits - crbb_len - 16)) {
940 urbb_len = rest_bits - crbb_len - 16;
941 } else {
942 /* Same problem when not compressing, last case.
943 * The spec is not clear, what happens this case.
944 * The problem here is an URBB without length field, but the URBB would
945 * have more bits than the window is valid.
946 * Enfore the length field and might loose 7 bits in worst case of performance
947 * to have a clear case. */
948 eow = false;
sivasankari8adfcd02017-01-16 15:41:21 +0530949 urbb_len = rest_bits - crbb_len - 16;
950 }
Alexander Couzens5fec67d2019-06-16 18:35:09 +0200951
sivasankari8adfcd02017-01-16 15:41:21 +0530952 len = urbb_len + crbb_len + 23;
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530953 }
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100954
955 /* EGPRS Ack/Nack Description IE */
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530956 if (len_coded == false) {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100957 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have length
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100958 } else {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100959 bitvec_write_field(dest, &wp, 1, 1); // 1: have length
960 bitvec_write_field(dest, &wp, len, 8); // length
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100961 }
962
Alexander Couzensccde5c92017-02-04 03:10:08 +0100963 bitvec_write_field(dest, &wp, is_final, 1); // FINAL_ACK_INDICATION
964 bitvec_write_field(dest, &wp, bow, 1); // BEGINNING_OF_WINDOW
965 bitvec_write_field(dest, &wp, eow, 1); // END_OF_WINDOW
966 bitvec_write_field(dest, &wp, ssn, 11); // STARTING_SEQUENCE_NUMBER
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530967 if (is_compressed) {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100968 bitvec_write_field(dest, &wp, 1, 1); // CRBB_Exist
969 bitvec_write_field(dest, &wp, crbb_len, 7); // CRBB_LENGTH
sivasankari8adfcd02017-01-16 15:41:21 +0530970 crbb_start_clr_code = (0x80 & ucmp_vec.data[0])>>7;
Alexander Couzensccde5c92017-02-04 03:10:08 +0100971 bitvec_write_field(dest, &wp, crbb_start_clr_code, 1); // CRBB_clr_code
sivasankari8adfcd02017-01-16 15:41:21 +0530972 LOGP(DRLCMACUL, LOGL_DEBUG,
973 "EGPRS CRBB, crbb_len = %d, crbb_start_clr_code = %d\n",
974 crbb_len, crbb_start_clr_code);
975 while (crbb_len != 0) {
976 if (crbb_len > 8) {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100977 bitvec_write_field(dest, &wp, crbb_bitmap[iter], 8);
sivasankari8adfcd02017-01-16 15:41:21 +0530978 crbb_len = crbb_len - 8;
979 iter++;
980 } else {
Alexander Couzens3f640772019-05-31 17:19:53 +0200981 bitvec_write_field(dest, &wp, crbb_bitmap[iter] >> (8 - crbb_len), crbb_len);
sivasankari8adfcd02017-01-16 15:41:21 +0530982 crbb_len = 0;
983 }
984 }
985 esn_crbb = window->mod_sns(esn_crbb + uclen_crbb);
986 } else {
Alexander Couzensccde5c92017-02-04 03:10:08 +0100987 bitvec_write_field(dest, &wp, 0, 1); // CRBB_Exist
sivasankari8adfcd02017-01-16 15:41:21 +0530988 }
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100989 LOGP(DRLCMACUL, LOGL_DEBUG,
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530990 "EGPRS URBB, urbb len = %d, SSN = %d, ESN_CRBB = %d, "
991 "len present = %s,desc len = %d, "
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100992 "SNS = %d, WS = %d, V(Q) = %d, V(R) = %d%s%s\n",
sivasankari8adfcd02017-01-16 15:41:21 +0530993 urbb_len, ssn, esn_crbb, len_coded ? "yes" : "No" , len,
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100994 window->sns(), window->ws(), window->v_q(), window->v_r(),
995 bow ? ", BOW" : "", eow ? ", EOW" : "");
Pravin Kumarvel06bdb352016-10-24 12:21:21 +0530996
997 for (i = urbb_len; i > 0; i--) {
Jacob Erlbeck37005a12015-12-22 14:58:34 +0100998 /* Set bit at the appropriate position (see 3GPP TS 04.60 12.3.1) */
999 bool is_ack = window->m_v_n.is_received(esn_crbb + i);
Alexander Couzensccde5c92017-02-04 03:10:08 +01001000 bitvec_write_field(dest, &wp, is_ack, 1);
Jacob Erlbeck37005a12015-12-22 14:58:34 +01001001 }
1002}
1003
1004static void write_packet_uplink_ack_egprs(
Alexander Couzens19e933b2019-06-16 15:25:30 +02001005 bitvec * dest, unsigned& wp,
Jacob Erlbeck37005a12015-12-22 14:58:34 +01001006 struct gprs_rlcmac_ul_tbf *tbf, bool is_final)
1007{
Alexander Couzensccde5c92017-02-04 03:10:08 +01001008 bitvec_write_field(dest, &wp, 0, 2); // fixed 00
Aravind Sirsikar99ab0a82016-06-15 17:46:41 +05301009 /* CHANNEL_CODING_COMMAND */
Alexander Couzensccde5c92017-02-04 03:10:08 +01001010 bitvec_write_field(dest, &wp,
Max6e96dd42019-03-06 18:17:32 +01001011 mcs_chan_code(tbf->current_cs()), 4);
Aravind Sirsikar505a86d2016-07-26 18:26:21 +05301012 /* 0: no RESEGMENT, 1: Segmentation*/
Alexander Couzensccde5c92017-02-04 03:10:08 +01001013 bitvec_write_field(dest, &wp, 1, 1);
1014 bitvec_write_field(dest, &wp, 1, 1); // PRE_EMPTIVE_TRANSMISSION, TODO: This resembles GPRS, change it?
1015 bitvec_write_field(dest, &wp, 0, 1); // 0: no PRR_RETRANSMISSION_REQUEST, TODO: clarify
1016 bitvec_write_field(dest, &wp, 0, 1); // 0: no ARAC_RETRANSMISSION_REQUEST, TODO: clarify
1017 bitvec_write_field(dest, &wp, 1, 1); // 1: have CONTENTION_RESOLUTION_TLLI
1018 bitvec_write_field(dest, &wp, tbf->tlli(), 32); // CONTENTION_RESOLUTION_TLLI
1019 bitvec_write_field(dest, &wp, 1, 1); // TBF_EST (enabled)
1020 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have Packet Timing Advance
1021 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have Packet Extended Timing Advance
1022 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have Power Control Parameters
1023 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have Extension Bits
Jacob Erlbeck37005a12015-12-22 14:58:34 +01001024
sivasankari8adfcd02017-01-16 15:41:21 +05301025 /* -2 for last bit 0 mandatory and REL5 not supported */
1026 unsigned bits_ack_nack = dest->data_len * 8 - wp - 2;
Alexander Couzens19e933b2019-06-16 15:25:30 +02001027 write_packet_ack_nack_desc_egprs(dest, wp, tbf->window(), is_final, bits_ack_nack);
Jacob Erlbeck37005a12015-12-22 14:58:34 +01001028
Alexander Couzensccde5c92017-02-04 03:10:08 +01001029 bitvec_write_field(dest, &wp, 0, 1); // fixed 0
1030 bitvec_write_field(dest, &wp, 0, 1); // 0: don't have REL 5
Jacob Erlbeck37005a12015-12-22 14:58:34 +01001031};
1032
1033void Encoding::write_packet_uplink_ack(
Alexander Couzens19e933b2019-06-16 15:25:30 +02001034 bitvec * dest, struct gprs_rlcmac_ul_tbf *tbf, bool is_final,
Jacob Erlbeckf2694b72016-01-26 21:46:26 +01001035 uint8_t rrbp)
Jacob Erlbeck37005a12015-12-22 14:58:34 +01001036{
1037 unsigned wp = 0;
1038
1039 LOGP(DRLCMACUL, LOGL_DEBUG, "Encoding Ack/Nack for %s "
1040 "(final=%d)\n", tbf_name(tbf), is_final);
1041
Alexander Couzensccde5c92017-02-04 03:10:08 +01001042 bitvec_write_field(dest, &wp, 0x1, 2); // Payload Type
1043 bitvec_write_field(dest, &wp, rrbp, 2); // Uplink block with TDMA framenumber
1044 bitvec_write_field(dest, &wp, is_final, 1); // Suppl/Polling Bit
1045 bitvec_write_field(dest, &wp, 0x0, 3); // Uplink state flag
1046 bitvec_write_field(dest, &wp, 0x9, 6); // MESSAGE TYPE Uplink Ack/Nack
1047 bitvec_write_field(dest, &wp, 0x0, 2); // Page Mode
Jacob Erlbeck37005a12015-12-22 14:58:34 +01001048
Alexander Couzensccde5c92017-02-04 03:10:08 +01001049 bitvec_write_field(dest, &wp, 0x0, 2); // fixed 00
1050 bitvec_write_field(dest, &wp, tbf->tfi(), 5); // Uplink TFI
Jacob Erlbeck37005a12015-12-22 14:58:34 +01001051
1052 if (tbf->is_egprs_enabled()) {
1053 /* PU_AckNack_EGPRS = on */
Alexander Couzensccde5c92017-02-04 03:10:08 +01001054 bitvec_write_field(dest, &wp, 1, 1); // 1: EGPRS
Alexander Couzens19e933b2019-06-16 15:25:30 +02001055 write_packet_uplink_ack_egprs(dest, wp, tbf, is_final);
Jacob Erlbeck37005a12015-12-22 14:58:34 +01001056 } else {
1057 /* PU_AckNack_GPRS = on */
Alexander Couzensccde5c92017-02-04 03:10:08 +01001058 bitvec_write_field(dest, &wp, 0, 1); // 0: GPRS
Alexander Couzens19e933b2019-06-16 15:25:30 +02001059 write_packet_uplink_ack_gprs(dest, wp, tbf, is_final);
Jacob Erlbeck37005a12015-12-22 14:58:34 +01001060 }
1061
1062 LOGP(DRLCMACUL, LOGL_DEBUG,
1063 "Uplink Ack/Nack bit count %d, max %d, message = %s\n",
1064 wp, dest->data_len * 8,
1065 osmo_hexdump(dest->data, dest->data_len));
1066}
1067
Holger Hans Peter Freyther63f29d62013-10-19 19:04:03 +02001068unsigned Encoding::write_packet_paging_request(bitvec * dest)
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001069{
1070 unsigned wp = 0;
1071
Alexander Couzensccde5c92017-02-04 03:10:08 +01001072 bitvec_write_field(dest, &wp,0x1,2); // Payload Type
1073 bitvec_write_field(dest, &wp,0x0,3); // No polling
1074 bitvec_write_field(dest, &wp,0x0,3); // Uplink state flag
1075 bitvec_write_field(dest, &wp,0x22,6); // MESSAGE TYPE
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001076
Alexander Couzensccde5c92017-02-04 03:10:08 +01001077 bitvec_write_field(dest, &wp,0x0,2); // Page Mode
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001078
Alexander Couzensccde5c92017-02-04 03:10:08 +01001079 bitvec_write_field(dest, &wp,0x0,1); // No PERSISTENCE_LEVEL
1080 bitvec_write_field(dest, &wp,0x0,1); // No NLN
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001081
1082 return wp;
1083}
1084
JF Dionne1beed382016-07-26 15:16:08 -04001085/* 3GPP TS 44.060 § 11.2.10:
1086 < Repeated Page info struct > ::=
1087 { 0 -- Page request for TBF establishment
1088 { 0 < PTMSI : bit (32) >
1089 | 1 < Length of Mobile Identity contents : bit (4) >
1090 < Mobile Identity : octet (val (Length of Mobile Identity contents)) > }
1091 | 1 -- Page request for RR conn. establishment
1092 { 0 < TMSI : bit (32) >
1093 | 1 < Length of Mobile Identity contents : bit (4) >
1094 < Mobile Identity : octet (val (Length of Mobile Identity contents)) > }
1095 < CHANNEL_NEEDED : bit (2) >
1096 { 0 | 1 < eMLPP_PRIORITY : bit (3) > }
1097 }
1098 */
Holger Hans Peter Freyther63f29d62013-10-19 19:04:03 +02001099unsigned Encoding::write_repeated_page_info(bitvec * dest, unsigned& wp, uint8_t len,
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001100 uint8_t *identity, uint8_t chan_needed)
1101{
Alexander Couzensccde5c92017-02-04 03:10:08 +01001102 bitvec_write_field(dest, &wp,0x1,1); // Repeated Page info exists
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001103
Alexander Couzensccde5c92017-02-04 03:10:08 +01001104 bitvec_write_field(dest, &wp,0x1,1); // RR connection paging
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001105
1106 if ((identity[0] & 0x07) == 4) {
Alexander Couzensccde5c92017-02-04 03:10:08 +01001107 bitvec_write_field(dest, &wp,0x0,1); // TMSI
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001108 identity++;
1109 len--;
1110 } else {
JF Dionne1beed382016-07-26 15:16:08 -04001111 bitvec_write_field(dest, &wp,0x1,1); // MI
Alexander Couzensccde5c92017-02-04 03:10:08 +01001112 bitvec_write_field(dest, &wp,len,4); // MI len
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001113 }
1114 while (len) {
Alexander Couzensccde5c92017-02-04 03:10:08 +01001115 bitvec_write_field(dest, &wp,*identity++,8); // MI data
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001116 len--;
1117 }
Alexander Couzensccde5c92017-02-04 03:10:08 +01001118 bitvec_write_field(dest, &wp,chan_needed,2); // CHANNEL_NEEDED
1119 bitvec_write_field(dest, &wp,0x0,1); // No eMLPP_PRIORITY
Holger Hans Peter Freyther6ca0a902013-10-19 18:50:22 +02001120
1121 return wp;
1122}
1123
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001124int Encoding::rlc_write_dl_data_header(const struct gprs_rlc_data_info *rlc,
1125 uint8_t *data)
1126{
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001127 struct gprs_rlc_dl_header_egprs_1 *egprs1;
1128 struct gprs_rlc_dl_header_egprs_2 *egprs2;
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001129 struct gprs_rlc_dl_header_egprs_3 *egprs3;
1130 struct rlc_dl_header *gprs;
1131 unsigned int e_fbi_header;
1132 GprsCodingScheme cs = rlc->cs;
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001133 unsigned int offs;
1134 unsigned int bsn_delta;
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001135
1136 switch(cs.headerTypeData()) {
Max51754b62019-03-13 17:14:13 +01001137 case HEADER_GPRS_DATA:
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001138 gprs = static_cast<struct rlc_dl_header *>
1139 ((void *)data);
1140
1141 gprs->usf = rlc->usf;
1142 gprs->s_p = rlc->es_p != 0 ? 1 : 0;
1143 gprs->rrbp = rlc->rrbp;
1144 gprs->pt = 0;
1145 gprs->tfi = rlc->tfi;
1146 gprs->pr = rlc->pr;
1147
1148 gprs->fbi = rlc->block_info[0].cv == 0;
1149 gprs->e = rlc->block_info[0].e;
1150 gprs->bsn = rlc->block_info[0].bsn;
1151 break;
1152
Max51754b62019-03-13 17:14:13 +01001153 case HEADER_EGPRS_DATA_TYPE_1:
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001154 egprs1 = static_cast<struct gprs_rlc_dl_header_egprs_1 *>
1155 ((void *)data);
1156
1157 egprs1->usf = rlc->usf;
1158 egprs1->es_p = rlc->es_p;
1159 egprs1->rrbp = rlc->rrbp;
Tom Tsoudf698092016-07-11 17:05:19 -07001160 egprs1->tfi_hi = rlc->tfi >> 0; /* 1 bit LSB */
1161 egprs1->tfi_lo = rlc->tfi >> 1; /* 4 bits */
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001162 egprs1->pr = rlc->pr;
1163 egprs1->cps = rlc->cps;
1164
Tom Tsoudf698092016-07-11 17:05:19 -07001165 egprs1->bsn1_hi = rlc->block_info[0].bsn >> 0; /* 2 bits LSB */
1166 egprs1->bsn1_mid = rlc->block_info[0].bsn >> 2; /* 8 bits */
1167 egprs1->bsn1_lo = rlc->block_info[0].bsn >> 10; /* 1 bit */
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001168
1169 bsn_delta = (rlc->block_info[1].bsn - rlc->block_info[0].bsn) &
1170 (RLC_EGPRS_SNS - 1);
1171
Tom Tsoudf698092016-07-11 17:05:19 -07001172 egprs1->bsn2_hi = bsn_delta >> 0; /* 7 bits LSB */
1173 egprs1->bsn2_lo = bsn_delta >> 7; /* 3 bits */
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001174
1175 /* first FBI/E header */
1176 e_fbi_header = rlc->block_info[0].e ? 0x01 : 0;
1177 e_fbi_header |= rlc->block_info[0].cv == 0 ? 0x02 : 0; /* FBI */
Jacob Erlbeck0f5c6952016-02-03 18:35:27 +01001178 offs = rlc->data_offs_bits[0] / 8;
1179 OSMO_ASSERT(rlc->data_offs_bits[0] % 8 == 2);
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001180 e_fbi_header <<= 0;
Jacob Erlbeck0f5c6952016-02-03 18:35:27 +01001181 data[offs] = (data[offs] & 0b11111100) | e_fbi_header;
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001182
1183 /* second FBI/E header */
1184 e_fbi_header = rlc->block_info[1].e ? 0x01 : 0;
1185 e_fbi_header |= rlc->block_info[1].cv == 0 ? 0x02 : 0; /* FBI */
1186 offs = rlc->data_offs_bits[1] / 8;
1187 OSMO_ASSERT(rlc->data_offs_bits[1] % 8 == 4);
1188 e_fbi_header <<= 2;
1189 data[offs] = (data[offs] & 0b11110011) | e_fbi_header;
1190 break;
1191
Max51754b62019-03-13 17:14:13 +01001192 case HEADER_EGPRS_DATA_TYPE_2:
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001193 egprs2 = static_cast<struct gprs_rlc_dl_header_egprs_2 *>
1194 ((void *)data);
1195
1196 egprs2->usf = rlc->usf;
1197 egprs2->es_p = rlc->es_p;
1198 egprs2->rrbp = rlc->rrbp;
Tom Tsoudf698092016-07-11 17:05:19 -07001199 egprs2->tfi_hi = rlc->tfi >> 0; /* 1 bit LSB */
1200 egprs2->tfi_lo = rlc->tfi >> 1; /* 4 bits */
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001201 egprs2->pr = rlc->pr;
1202 egprs2->cps = rlc->cps;
1203
Tom Tsoudf698092016-07-11 17:05:19 -07001204 egprs2->bsn1_hi = rlc->block_info[0].bsn >> 0; /* 2 bits LSB */
1205 egprs2->bsn1_mid = rlc->block_info[0].bsn >> 2; /* 8 bits */
1206 egprs2->bsn1_lo = rlc->block_info[0].bsn >> 10; /* 1 bit */
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001207
1208 e_fbi_header = rlc->block_info[0].e ? 0x01 : 0;
1209 e_fbi_header |= rlc->block_info[0].cv == 0 ? 0x02 : 0; /* FBI */
Jacob Erlbeck0f5c6952016-02-03 18:35:27 +01001210 offs = rlc->data_offs_bits[0] / 8;
1211 OSMO_ASSERT(rlc->data_offs_bits[0] % 8 == 6);
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001212 e_fbi_header <<= 4;
Jacob Erlbeck0f5c6952016-02-03 18:35:27 +01001213 data[offs] = (data[offs] & 0b11001111) | e_fbi_header;
Jacob Erlbeck9e859392016-02-02 11:48:37 +01001214 break;
1215
Max51754b62019-03-13 17:14:13 +01001216 case HEADER_EGPRS_DATA_TYPE_3:
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001217 egprs3 = static_cast<struct gprs_rlc_dl_header_egprs_3 *>
1218 ((void *)data);
1219
1220 egprs3->usf = rlc->usf;
1221 egprs3->es_p = rlc->es_p;
1222 egprs3->rrbp = rlc->rrbp;
Tom Tsoudf698092016-07-11 17:05:19 -07001223 egprs3->tfi_hi = rlc->tfi >> 0; /* 1 bit LSB */
1224 egprs3->tfi_lo = rlc->tfi >> 1; /* 4 bits */
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001225 egprs3->pr = rlc->pr;
1226 egprs3->cps = rlc->cps;
1227
Tom Tsoudf698092016-07-11 17:05:19 -07001228 egprs3->bsn1_hi = rlc->block_info[0].bsn >> 0; /* 2 bits LSB */
1229 egprs3->bsn1_mid = rlc->block_info[0].bsn >> 2; /* 8 bits */
1230 egprs3->bsn1_lo = rlc->block_info[0].bsn >> 10; /* 1 bit */
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001231
1232 egprs3->spb = rlc->block_info[0].spb;
1233
1234 e_fbi_header = rlc->block_info[0].e ? 0x01 : 0;
1235 e_fbi_header |= rlc->block_info[0].cv == 0 ? 0x02 : 0; /* FBI */
Jacob Erlbeck0f5c6952016-02-03 18:35:27 +01001236 offs = rlc->data_offs_bits[0] / 8;
1237 OSMO_ASSERT(rlc->data_offs_bits[0] % 8 == 1);
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001238 e_fbi_header <<= 7;
Jacob Erlbeck0f5c6952016-02-03 18:35:27 +01001239 data[offs-1] = (data[offs-1] & 0b01111111) | (e_fbi_header >> 0);
1240 data[offs] = (data[offs] & 0b11111110) | (e_fbi_header >> 8);
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001241 break;
1242
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001243 default:
1244 LOGP(DRLCMACDL, LOGL_ERROR,
1245 "Encoding of uplink %s data blocks not yet supported.\n",
Max136ebcc2019-03-05 14:59:03 +01001246 mcs_name(cs));
Jacob Erlbeckf0e40392016-01-08 10:07:53 +01001247 return -ENOTSUP;
1248 };
1249
1250 return 0;
1251}
1252
1253/**
1254 * \brief Copy LSB bitstream RLC data block from byte aligned buffer.
1255 *
1256 * Note that the bitstream is encoded in LSB first order, so the two octets
1257 * 654321xx xxxxxx87 contain the octet 87654321 starting at bit position 3
1258 * (LSB has bit position 1). This is a different order than the one used by
1259 * CSN.1.
1260 *
1261 * \param data_block_idx The block index, 0..1 for header type 1, 0 otherwise
1262 * \param src A pointer to the start of the RLC block (incl. the header)
1263 * \param buffer A data area of a least the size of the RLC block
1264 * \returns the number of bytes copied
1265 */
1266unsigned int Encoding::rlc_copy_from_aligned_buffer(
1267 const struct gprs_rlc_data_info *rlc,
1268 unsigned int data_block_idx,
1269 uint8_t *dst, const uint8_t *buffer)
1270{
1271 unsigned int hdr_bytes;
1272 unsigned int extra_bits;
1273 unsigned int i;
1274
1275 uint8_t c, last_c;
1276 const uint8_t *src;
1277 const struct gprs_rlc_data_block_info *rdbi;
1278
1279 OSMO_ASSERT(data_block_idx < rlc->num_data_blocks);
1280 rdbi = &rlc->block_info[data_block_idx];
1281
1282 hdr_bytes = rlc->data_offs_bits[data_block_idx] / 8;
1283 extra_bits = (rlc->data_offs_bits[data_block_idx] % 8);
1284
1285 if (extra_bits == 0) {
1286 /* It is aligned already */
1287 memmove(dst + hdr_bytes, buffer, rdbi->data_len);
1288 return rdbi->data_len;
1289 }
1290
1291 src = buffer;
1292 dst = dst + hdr_bytes;
1293 last_c = *dst << (8 - extra_bits);
1294
1295 for (i = 0; i < rdbi->data_len; i++) {
1296 c = src[i];
1297 *(dst++) = (last_c >> (8 - extra_bits)) | (c << extra_bits);
1298 last_c = c;
1299 }
1300
1301 /* overwrite the lower extra_bits */
1302 *dst = (*dst & (0xff << extra_bits)) | (last_c >> (8 - extra_bits));
1303
1304 return rdbi->data_len;
1305}
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001306
Alexander Couzenscb846ec2016-05-30 19:10:48 +02001307/*!
1308 * \brief (GPRS) put llc pdu into an rlc/mac block. fragment the llc pdu if needed
1309 * \param rdbi rlc/mac block info
1310 * \param llc llc pdu
1311 * \param offset given offset within the rlc/mac block
1312 * \param num_chunks count the chunks (llc pdu data) within rlc/mac
1313 * \param data_block buffer holds rlc/mac data
1314 * \param is_final if this is the last rlc/mac within a TBF
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001315 * \param count_payload if not NULL save the written size of payload in bytes into it
Alexander Couzenscb846ec2016-05-30 19:10:48 +02001316 * \return the state of the rlc/mac like if there is more space for another chunk
1317 */
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001318static Encoding::AppendResult rlc_data_to_dl_append_gprs(
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001319 struct gprs_rlc_data_block_info *rdbi,
1320 gprs_llc *llc, int *offset, int *num_chunks,
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001321 uint8_t *data_block, bool is_final, int *count_payload)
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001322{
1323 int chunk;
1324 int space;
1325 struct rlc_li_field *li;
1326 uint8_t *delimiter, *data, *e_pointer;
1327
1328 data = data_block + *offset;
1329 delimiter = data_block + *num_chunks;
1330 e_pointer = (*num_chunks ? delimiter - 1 : NULL);
1331
1332 chunk = llc->chunk_size();
1333 space = rdbi->data_len - *offset;
1334
1335 /* if chunk will exceed block limit */
1336 if (chunk > space) {
1337 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Chunk with length %d "
1338 "larger than space (%d) left in block: copy "
1339 "only remaining space, and we are done\n",
1340 chunk, space);
1341 /* block is filled, so there is no extension */
1342 if (e_pointer)
1343 *e_pointer |= 0x01;
1344 /* fill only space */
1345 llc->consume(data, space);
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001346 if (count_payload)
1347 *count_payload = space;
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001348 /* return data block as message */
1349 *offset = rdbi->data_len;
1350 (*num_chunks)++;
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001351 return Encoding::AR_NEED_MORE_BLOCKS;
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001352 }
1353 /* if FINAL chunk would fit precisely in space left */
1354 if (chunk == space && is_final)
1355 {
1356 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Chunk with length %d "
1357 "would exactly fit into space (%d): because "
1358 "this is a final block, we don't add length "
1359 "header, and we are done\n", chunk, space);
1360 /* block is filled, so there is no extension */
1361 if (e_pointer)
1362 *e_pointer |= 0x01;
1363 /* fill space */
1364 llc->consume(data, space);
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001365 if (count_payload)
1366 *count_payload = space;
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001367 *offset = rdbi->data_len;
1368 (*num_chunks)++;
1369 rdbi->cv = 0;
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001370 return Encoding::AR_COMPLETED_BLOCK_FILLED;
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001371 }
1372 /* if chunk would fit exactly in space left */
1373 if (chunk == space) {
1374 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Chunk with length %d "
1375 "would exactly fit into space (%d): add length "
1376 "header with LI=0, to make frame extend to "
1377 "next block, and we are done\n", chunk, space);
1378 /* make space for delimiter */
1379 if (delimiter != data)
1380 memmove(delimiter + 1, delimiter,
1381 data - delimiter);
1382 data++;
1383 (*offset)++;
1384 space--;
1385 /* add LI with 0 length */
1386 li = (struct rlc_li_field *)delimiter;
1387 li->e = 1; /* not more extension */
1388 li->m = 0; /* shall be set to 0, in case of li = 0 */
1389 li->li = 0; /* chunk fills the complete space */
1390 rdbi->e = 0; /* 0: extensions present */
1391 // no need to set e_pointer nor increase delimiter
1392 /* fill only space, which is 1 octet less than chunk */
1393 llc->consume(data, space);
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001394 if (count_payload)
1395 *count_payload = space;
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001396 /* return data block as message */
1397 *offset = rdbi->data_len;
1398 (*num_chunks)++;
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001399 return Encoding::AR_NEED_MORE_BLOCKS;
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001400 }
1401
1402 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Chunk with length %d is less "
1403 "than remaining space (%d): add length header to "
1404 "to delimit LLC frame\n", chunk, space);
1405 /* the LLC frame chunk ends in this block */
1406 /* make space for delimiter */
1407 if (delimiter != data)
1408 memmove(delimiter + 1, delimiter, data - delimiter);
1409 data++;
1410 (*offset)++;
1411 space--;
1412 /* add LI to delimit frame */
1413 li = (struct rlc_li_field *)delimiter;
1414 li->e = 0; /* Extension bit, maybe set later */
1415 li->m = 0; /* will be set later, if there is more LLC data */
1416 li->li = chunk; /* length of chunk */
1417 rdbi->e = 0; /* 0: extensions present */
1418 (*num_chunks)++;
1419 /* copy (rest of) LLC frame to space and reset later */
1420 llc->consume(data, chunk);
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001421 if (count_payload)
1422 *count_payload = chunk;
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001423 data += chunk;
1424 space -= chunk;
1425 (*offset) += chunk;
1426 /* if we have more data and we have space left */
1427 if (space > 0 && !is_final) {
1428 li->m = 1; /* we indicate more frames to follow */
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001429 return Encoding::AR_COMPLETED_SPACE_LEFT;
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001430 }
1431 /* if we don't have more LLC frames */
1432 if (is_final) {
1433 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Final block, so we "
1434 "done.\n");
1435 li->e = 1; /* we cannot extend */
1436 rdbi->cv = 0;
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001437 return Encoding::AR_COMPLETED_BLOCK_FILLED;
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001438 }
1439 /* we have no space left */
1440 LOGP(DRLCMACDL, LOGL_DEBUG, "-- No space left, so we are "
1441 "done.\n");
1442 li->e = 1; /* we cannot extend */
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001443 return Encoding::AR_COMPLETED_BLOCK_FILLED;
1444}
1445
Alexander Couzenscb846ec2016-05-30 19:10:48 +02001446/*!
1447 * \brief (EGPRS) put llc pdu into an rlc/mac block. fragment the llc pdu if needed
1448 * \param rdbi rlc/mac block info
1449 * \param llc llc pdu
1450 * \param offset given offset within the rlc/mac block
1451 * \param num_chunks count the chunks (llc pdu data) within rlc/mac
1452 * \param data_block buffer holds rlc/mac data
1453 * \param is_final if this is the last rlc/mac within a TBF
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001454 * \param count_payload if not NULL save the written size of payload in bytes into it
Alexander Couzenscb846ec2016-05-30 19:10:48 +02001455 * \return the state of the rlc/mac like if there is more space for another chunk
1456 */
Jacob Erlbecka88d0652016-01-13 11:28:10 +01001457static Encoding::AppendResult rlc_data_to_dl_append_egprs(
1458 struct gprs_rlc_data_block_info *rdbi,
1459 gprs_llc *llc, int *offset, int *num_chunks,
1460 uint8_t *data_block,
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001461 bool is_final, int *count_payload)
Jacob Erlbecka88d0652016-01-13 11:28:10 +01001462{
1463 int chunk;
1464 int space;
1465 struct rlc_li_field_egprs *li;
1466 struct rlc_li_field_egprs *prev_li;
1467 uint8_t *delimiter, *data;
1468
1469 data = data_block + *offset;
1470 delimiter = data_block + *num_chunks;
1471 prev_li = (struct rlc_li_field_egprs *)
1472 (*num_chunks ? delimiter - 1 : NULL);
1473
1474 chunk = llc->chunk_size();
1475 space = rdbi->data_len - *offset;
1476
1477 /* if chunk will exceed block limit */
1478 if (chunk > space) {
1479 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Chunk with length %d "
1480 "larger than space (%d) left in block: copy "
1481 "only remaining space, and we are done\n",
1482 chunk, space);
1483 /* fill only space */
1484 llc->consume(data, space);
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001485 if (count_payload)
1486 *count_payload = space;
Jacob Erlbecka88d0652016-01-13 11:28:10 +01001487 /* return data block as message */
1488 *offset = rdbi->data_len;
1489 (*num_chunks)++;
1490 return Encoding::AR_NEED_MORE_BLOCKS;
1491 }
1492 /* if FINAL chunk would fit precisely in space left */
1493 if (chunk == space && is_final)
1494 {
1495 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Chunk with length %d "
1496 "would exactly fit into space (%d): because "
1497 "this is a final block, we don't add length "
1498 "header, and we are done\n", chunk, space);
1499 /* fill space */
1500 llc->consume(data, space);
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001501 if (count_payload)
1502 *count_payload = space;
Jacob Erlbecka88d0652016-01-13 11:28:10 +01001503 *offset = rdbi->data_len;
1504 (*num_chunks)++;
1505 rdbi->cv = 0;
1506 return Encoding::AR_COMPLETED_BLOCK_FILLED;
1507 }
1508 /* if chunk would fit exactly in space left */
1509 if (chunk == space) {
1510 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Chunk with length %d "
1511 "would exactly fit into space (%d): just copy "
1512 "it, and we are done. The next block will have "
1513 "to start with an empty chunk\n",
1514 chunk, space);
1515 /* fill space */
1516 llc->consume(data, space);
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001517 if (count_payload)
1518 *count_payload = space;
Jacob Erlbecka88d0652016-01-13 11:28:10 +01001519 *offset = rdbi->data_len;
1520 (*num_chunks)++;
1521 return Encoding::AR_NEED_MORE_BLOCKS;
1522 }
1523
1524 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Chunk with length %d is less "
1525 "than remaining space (%d): add length header to "
1526 "to delimit LLC frame\n", chunk, space);
1527 /* the LLC frame chunk ends in this block */
1528 /* make space for delimiter */
1529
1530 if (delimiter != data)
1531 memmove(delimiter + 1, delimiter, data - delimiter);
1532
1533 data += 1;
1534 (*offset) += 1;
1535 space -= 1;
1536 /* add LI to delimit frame */
1537 li = (struct rlc_li_field_egprs *)delimiter;
1538 li->e = 1; /* Extension bit, maybe set later */
1539 li->li = chunk; /* length of chunk */
1540 /* tell previous extension header about the new one */
1541 if (prev_li)
1542 prev_li->e = 0;
1543 rdbi->e = 0; /* 0: extensions present */
1544 delimiter++;
1545 prev_li = li;
1546 (*num_chunks)++;
1547 /* copy (rest of) LLC frame to space and reset later */
1548 llc->consume(data, chunk);
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001549 if (count_payload)
1550 *count_payload = chunk;
Jacob Erlbecka88d0652016-01-13 11:28:10 +01001551 data += chunk;
1552 space -= chunk;
1553 (*offset) += chunk;
1554 /* if we have more data and we have space left */
1555 if (space > 0) {
1556 if (!is_final)
1557 return Encoding::AR_COMPLETED_SPACE_LEFT;
1558
1559 /* we don't have more LLC frames */
1560 /* We will have to add another chunk with filling octets */
1561 LOGP(DRLCMACDL, LOGL_DEBUG,
1562 "-- There is remaining space (%d): add filling byte chunk\n",
1563 space);
1564
1565 if (delimiter != data)
1566 memmove(delimiter + 1, delimiter, data - delimiter);
1567
1568 data += 1;
1569 (*offset) += 1;
1570 space -= 1;
1571
1572 /* set filling bytes extension */
1573 li = (struct rlc_li_field_egprs *)delimiter;
1574 li->e = 1;
1575 li->li = 127;
1576
1577 /* tell previous extension header about the new one */
1578 if (prev_li)
1579 prev_li->e = 0;
1580
1581 delimiter++;
1582 (*num_chunks)++;
1583
1584 rdbi->cv = 0;
1585
1586 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Final block, so we "
1587 "are done.\n");
1588
1589 *offset = rdbi->data_len;
1590 return Encoding::AR_COMPLETED_BLOCK_FILLED;
1591 }
1592
1593 if (is_final) {
1594 /* we don't have more LLC frames */
1595 LOGP(DRLCMACDL, LOGL_DEBUG, "-- Final block, so we "
1596 "are done.\n");
1597 rdbi->cv = 0;
1598 return Encoding::AR_COMPLETED_BLOCK_FILLED;
1599 }
1600
1601 /* we have no space left */
1602 LOGP(DRLCMACDL, LOGL_DEBUG, "-- No space left, so we are "
1603 "done.\n");
1604 return Encoding::AR_COMPLETED_BLOCK_FILLED;
1605}
1606
Alexander Couzenscb846ec2016-05-30 19:10:48 +02001607/*!
1608 * \brief Encoding::rlc_data_to_dl_append
1609 * \param rdbi rlc/mac block info
1610 * \param cs the coding scheme to use
1611 * \param llc llc pdu
1612 * \param offset given offset within the rlc/mac block
1613 * \param num_chunks count the chunks (llc pdu data) within rlc/mac
1614 * \param data_block buffer holds rlc/mac data
1615 * \param is_final if this is the last rlc/mac within a TBF
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001616 * \param count_payload if not NULL save the written size of payload in bytes into it
Alexander Couzenscb846ec2016-05-30 19:10:48 +02001617 * \return the state of the rlc/mac like if there is more space for another chunk
1618 */
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001619Encoding::AppendResult Encoding::rlc_data_to_dl_append(
1620 struct gprs_rlc_data_block_info *rdbi, GprsCodingScheme cs,
1621 gprs_llc *llc, int *offset, int *num_chunks,
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001622 uint8_t *data_block, bool is_final, int *count_payload)
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001623{
Max8a8e0fb2019-03-25 16:32:50 +01001624 if (mcs_is_gprs(cs))
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001625 return rlc_data_to_dl_append_gprs(rdbi,
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001626 llc, offset, num_chunks, data_block, is_final,
1627 count_payload);
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001628
Max8a8e0fb2019-03-25 16:32:50 +01001629 if (mcs_is_edge(cs))
Jacob Erlbecka88d0652016-01-13 11:28:10 +01001630 return rlc_data_to_dl_append_egprs(rdbi,
Alexander Couzens6f0dc962016-05-30 19:30:21 +02001631 llc, offset, num_chunks, data_block, is_final,
1632 count_payload);
Jacob Erlbecka88d0652016-01-13 11:28:10 +01001633
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001634 LOGP(DRLCMACDL, LOGL_ERROR, "%s data block encoding not implemented\n",
Max136ebcc2019-03-05 14:59:03 +01001635 mcs_name(cs));
Jacob Erlbeck5058bd62016-01-13 10:51:25 +01001636
1637 return AR_NEED_MORE_BLOCKS;
Jacob Erlbeck14bb0942016-01-12 11:58:13 +01001638}
aravind sirsikared3413e2016-11-11 17:15:10 +05301639
1640/*
1641 * Refer 44.060 version 7.27.0 Release 7
1642 * section 7.1.3.2.1 On receipt of a PACKET RESOURCE REQUEST message
1643 * 8.1.2.5 Establishment of uplink TBF
1644 */
1645void Encoding::write_packet_access_reject(
1646 bitvec * dest, uint32_t tlli)
1647{
1648 unsigned wp = 0;
1649
Alexander Couzensccde5c92017-02-04 03:10:08 +01001650 bitvec_write_field(dest, &wp, 0x1, 2); // Payload Type
1651 bitvec_write_field(dest, &wp, 0x0, 2); // Uplink block with TDMA FN
1652 bitvec_write_field(dest, &wp, 0, 1); // No Polling Bit
1653 bitvec_write_field(dest, &wp, 0x0, 3); // Uplink state flag
1654 bitvec_write_field(dest, &wp,
aravind sirsikared3413e2016-11-11 17:15:10 +05301655 MT_PACKET_ACCESS_REJECT, 6); // MESSAGE TYPE
Alexander Couzensccde5c92017-02-04 03:10:08 +01001656 bitvec_write_field(dest, &wp, 0, 2); // fixed 00
1657 bitvec_write_field(dest, &wp, 0x0, 1); // TLLI / G-RNTI : bit (32)
1658 bitvec_write_field(dest, &wp, tlli, 32); // CONTENTION_RESOLUTION_TLLI
1659 bitvec_write_field(dest, &wp, 1, 1); // WAIT_INDICATION size in seconds
aravind sirsikared3413e2016-11-11 17:15:10 +05301660 /* TODO: make it configurable */
Alexander Couzensccde5c92017-02-04 03:10:08 +01001661 bitvec_write_field(dest, &wp, 5, 8); // WAIT_INDICATION value
1662 bitvec_write_field(dest, &wp, 0, 1); // WAIT_INDICATION size in seconds
aravind sirsikared3413e2016-11-11 17:15:10 +05301663}