OpenBSC

openbsc@lists.osmocom.org

20 participants
4286 discussions

Cosmetic early RTP sending issue and please test
by Holger Freyther 05 Feb '16

05 Feb '16

Hi, before the l1sap changes were merged I fixed a case where after a ip.access CRCX with recvonly mode the BTS would already start to send RTP frames to UDP port 0 which will trigger an ICMP unreachable. This is not harmful but still a bug. After the l1sap merge the sysmobts is still doing it when it receives a TCH frame and all other bts models behave like before the bugfix. The below diff copies this into the common code. Besides administratives work I try to work on the SMSC, so if anyone could testdrive this patch and check for ICMP errors it would be greatly appreciated. holger

1 0

[PATCH 0/3] Fix handling PDP update messages
by Daniel Willmann 05 Feb '16

05 Feb '16

From: Daniel Willmann <daniel(a)totalueberwachung.de> Hello, it seems PDP context updates was never really used/tested to an Update PDP context would not go through. The following patches fix that (at least for gtpv1). Regards Daniel Daniel Willmann (3): gtp: Pass pdp along when calling gtp_req() in gtp_update_context() gtp: Make gtp_update_pdp_conf() work for gtp0 and gtp1 connections gtp: Handle gtpv1 in gtp_update_pdp_conf() correctly gtp/gtp.c | 162 +++++++++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 118 insertions(+), 44 deletions(-) -- 2.1.4 -- - Daniel Willmann <dwillmann(a)sysmocom.de> http://www.sysmocom.de/ ======================================================================= * sysmocom - systems for mobile communications GmbH * Alt-Moabit 93 * 10559 Berlin, Germany * Sitz / Registered office: Berlin, HRB 134158 B * Geschaeftsfuehrer / Managing Directors: Holger Freyther, Harald Welte

3 6

[PATCH 1/2] Expand bitvec interface
by suraev＠alumni.ntnu.no 05 Feb '16

05 Feb '16

From: Max <msuraev(a)sysmocom.de> Add bit filling, shifting and other functions necessary for bit compression implementation. Add corresponding tests. --- include/osmocom/core/bitvec.h | 9 +++ src/bitvec.c | 132 ++++++++++++++++++++++++++++++++++++-- tests/bitvec/bitvec_test.c | 143 +++++++++++++++++++++++++++++++++++++++++- tests/bitvec/bitvec_test.ok | 119 +++++++++++++++++++++++++++++++++++ 4 files changed, 396 insertions(+), 7 deletions(-) diff --git a/include/osmocom/core/bitvec.h b/include/osmocom/core/bitvec.h index a7e6fc4..5314cf2 100644 --- a/include/osmocom/core/bitvec.h +++ b/include/osmocom/core/bitvec.h @@ -4,6 +4,7 @@ /* (C) 2009 by Harald Welte <laforge(a)gnumonks.org> * (C) 2012 Ivan Klyuchnikov + * (C) 2015 Sysmocom s.f.m.c. GmbH * * All Rights Reserved * @@ -41,6 +42,7 @@ #include <stdint.h> #include <talloc.h> +#include <stdbool.h> /*! \brief A single GSM bit * @@ -82,5 +84,12 @@ unsigned int bitvec_pack(const struct bitvec *bv, uint8_t *buffer); unsigned int bitvec_unpack(struct bitvec *bv, const uint8_t *buffer); uint64_t bitvec_read_field(struct bitvec *bv, unsigned int *read_index, unsigned int len); int bitvec_write_field(struct bitvec *bv, unsigned int *write_index, uint64_t val, unsigned int len); +int bitvec_fill(struct bitvec *bv, unsigned int num_bits, enum bit_value fill); +char bit_value_to_char(enum bit_value v); +void bitvec_to_string_r(const struct bitvec *bv, char *str); +void bitvec_zero(struct bitvec *bv); +unsigned bitvec_rl(const struct bitvec *bv, bool b); +void bitvec_shiftl(struct bitvec *bv, unsigned int n); +int16_t bitvec_get_int16_msb(const struct bitvec *bv, unsigned int num_bits); /*! @} */ diff --git a/src/bitvec.c b/src/bitvec.c index b5d2c24..fc016a6 100644 --- a/src/bitvec.c +++ b/src/bitvec.c @@ -34,7 +34,9 @@ #include <stdint.h> #include <string.h> #include <stdio.h> +#include <stdbool.h> +#include <osmocom/core/bits.h> #include <osmocom/core/bitvec.h> #define BITNUM_FROM_COMP(byte, bit) ((byte*8)+bit) @@ -224,6 +226,20 @@ int bitvec_set_uint(struct bitvec *bv, unsigned int ui, unsigned int num_bits) return 0; } +/*! \brief get multiple bits (num_bits) from beginning of vector (MSB side) */ +int16_t bitvec_get_int16_msb(const struct bitvec *bv, unsigned int num_bits) +{ + uint8_t tmp[2]; + if (num_bits > 15 || bv->cur_bit < num_bits) + return -EINVAL; + + if (num_bits < 9) + return bv->data[0] >> (8 - num_bits); + + memcpy(tmp, bv->data, 2); + return osmo_load16be(tmp) >> (16 - num_bits); +} + /*! \brief get multiple bits (based on numeric value) from current pos */ int bitvec_get_uint(struct bitvec *bv, unsigned int num_bits) { @@ -242,15 +258,27 @@ int bitvec_get_uint(struct bitvec *bv, unsigned int num_bits) return ui; } +/*! \brief fill num_bits with \fill starting from the current position + * returns 0 on success, negative otherwise (out of vector boundary) + */ +int bitvec_fill(struct bitvec *bv, unsigned int num_bits, enum bit_value fill) +{ + unsigned i, stop = bv->cur_bit + num_bits; + for (i = bv->cur_bit; i < stop; i++) + if (bitvec_set_bit(bv, fill) < 0) + return -EINVAL; + + return 0; +} + /*! \brief pad all remaining bits up to num_bits */ int bitvec_spare_padding(struct bitvec *bv, unsigned int up_to_bit) { - unsigned int i; - - for (i = bv->cur_bit; i <= up_to_bit; i++) - bitvec_set_bit(bv, L); + int n = up_to_bit - bv->cur_bit + 1; + if (n < 1) + return 0; - return 0; + return bitvec_fill(bv, n, L); } /*! \brief find first bit set in bit vector */ @@ -446,4 +474,98 @@ int bitvec_write_field(struct bitvec *bv, unsigned int *write_index, uint64_t va return 0; } +/*! \brief convert enum to corresponding character */ +char bit_value_to_char(enum bit_value v) +{ + switch (v) { + case ZERO: return '0'; + case ONE: return '1'; + case L: return 'L'; + case H: return 'H'; + } + /* make compiler happy - "avoid control reaches end of non-void function" warning: */ + return '?'; +} + +/*! \brief prints bit vector to provided string + * It's caller's responcibility to ensure that we won't shoot him in the foot. + */ +void bitvec_to_string_r(const struct bitvec *bv, char *str) +{ + unsigned i, pos = 0; + char *cur = str; + for (i = 0; i < bv->cur_bit; i++) { + if (0 == i % 8) + *cur++ = ' '; + *cur++ = bit_value_to_char(bitvec_get_bit_pos(bv, i)); + pos++; + } + *cur = 0; +} + +/* we assume that x have at least 1 non-b bit */ +static inline unsigned _leading_bits(uint8_t x, bool b) +{ + if (b) { + if (x < 0x80) return 0; + if (x < 0xC0) return 1; + if (x < 0xE0) return 2; + if (x < 0xF0) return 3; + if (x < 0xF8) return 4; + if (x < 0xFC) return 5; + if (x < 0xFE) return 6; + } else { + if (x > 0x7F) return 0; + if (x > 0x3F) return 1; + if (x > 0x1F) return 2; + if (x > 0xF) return 3; + if (x > 7) return 4; + if (x > 3) return 5; + if (x > 1) return 6; + } + return 7; +} +/*! \brief force bit vector to all 0 and current bit to the beginnig of the vector */ +void bitvec_zero(struct bitvec *bv) +{ + bv->cur_bit = 0; + memset(bv->data, 0, bv->data_len); +} + +/*! \brief Return number (bits) of uninterrupted run of \b in \bv starting from the MSB */ +unsigned bitvec_rl(const struct bitvec *bv, bool b) +{ + unsigned i; + for (i = 0; i < (bv->cur_bit % 8 ? bv->cur_bit / 8 + 1 : bv->cur_bit / 8); i++) { + if ( (b ? 0xFF : 0) != bv->data[i]) + return i * 8 + _leading_bits(bv->data[i], b); + } + + return bv->cur_bit; +} + +/*! \brief Shifts bitvec to the left, n MSB bits lost */ +void bitvec_shiftl(struct bitvec *bv, unsigned n) +{ + if (0 == n) + return; + if (n >= bv->cur_bit) { + bitvec_zero(bv); + return; + } + + memmove(bv->data, bv->data + n / 8, bv->data_len - n / 8); + + uint8_t tmp[2]; + unsigned i; + for (i = 0; i < bv->data_len - 2; i++) { + uint16_t t = osmo_load16be(bv->data + i); + osmo_store16be(t << (n % 8), &tmp); + bv->data[i] = tmp[0]; + } + + bv->data[bv->data_len - 1] <<= (n % 8); + bv->cur_bit -= n; +} + /*! @} */ diff --git a/tests/bitvec/bitvec_test.c b/tests/bitvec/bitvec_test.c index 7d131e0..4fc9db3 100644 --- a/tests/bitvec/bitvec_test.c +++ b/tests/bitvec/bitvec_test.c @@ -3,9 +3,82 @@ #include <stdlib.h> #include <stdint.h> #include <string.h> +#include <time.h> +#include <stdbool.h> +#include <errno.h> #include <osmocom/core/utils.h> #include <osmocom/core/bitvec.h> +#include <osmocom/core/bits.h> + +#define BIN_PATTERN "%d%d%d%d%d%d%d%d" +#define BIN(byte) \ + (byte & 0x80 ? 1 : 0), \ + (byte & 0x40 ? 1 : 0), \ + (byte & 0x20 ? 1 : 0), \ + (byte & 0x10 ? 1 : 0), \ + (byte & 0x08 ? 1 : 0), \ + (byte & 0x04 ? 1 : 0), \ + (byte & 0x02 ? 1 : 0), \ + (byte & 0x01 ? 1 : 0) + +static char lol[1024]; // we pollute this with printed vectors +static inline void test_rl(const struct bitvec *bv) +{ + bitvec_to_string_r(bv, lol); + printf("%s [%d] RL0=%d, RL1=%d\n", lol, bv->cur_bit, bitvec_rl(bv, false), bitvec_rl(bv, true)); +} + +static inline void test_shift(struct bitvec *bv, unsigned n) +{ + bitvec_to_string_r(bv, lol); + printf("%s << %d:\n", lol, n); + bitvec_shiftl(bv, n); + bitvec_to_string_r(bv, lol); + printf("%s\n", lol); +} + +static inline void test_get(struct bitvec *bv, unsigned n) +{ + bitvec_to_string_r(bv, lol); + printf("%s [%d]", lol, bv->cur_bit); + int16_t x = bitvec_get_int16_msb(bv, n); + uint8_t tmp[2]; + osmo_store16be(x, &tmp); + printf(" -> %d (%u bit) ["BIN_PATTERN" "BIN_PATTERN"]:\n", x, n, BIN(tmp[0]), BIN(tmp[1])); + bitvec_to_string_r(bv, lol); + printf("%s [%d]\n", lol, bv->cur_bit); +} + +static inline void test_fill(struct bitvec *bv, unsigned n, enum bit_value val) +{ + bitvec_to_string_r(bv, lol); + unsigned bvlen = bv->cur_bit; + int fi = bitvec_fill(bv, n, val); + printf("%c> FILL %s [%d] -%d-> [%d]:\n", bit_value_to_char(val), lol, bvlen, n, fi); + bitvec_to_string_r(bv, lol); + printf(" %s [%d]\n\n", lol, bv->cur_bit); +} + +static inline void test_spare(struct bitvec *bv, unsigned n) +{ + bitvec_to_string_r(bv, lol); + unsigned bvlen = bv->cur_bit; + int sp = bitvec_spare_padding(bv, n); + printf("%c> SPARE %s [%d] -%d-> [%d]:\n", bit_value_to_char(L), lol, bvlen, n, sp); + bitvec_to_string_r(bv, lol); + printf(" %s [%d]\n\n", lol, bv->cur_bit); +} + +static inline void test_set(struct bitvec *bv, enum bit_value bit) +{ + bitvec_to_string_r(bv, lol); + unsigned bvlen = bv->cur_bit; + int set = bitvec_set_bit(bv, bit); + printf("%c> SET %s [%d] ++> [%d]:\n", bit_value_to_char(bit), lol, bvlen, set); + bitvec_to_string_r(bv, lol); + printf(" %s [%d]\n\n", lol, bv->cur_bit); +} static void test_byte_ops() { @@ -33,7 +106,7 @@ static void test_byte_ops() rc = bitvec_set_uint(&bv, 0x7e, 8); OSMO_ASSERT(rc >= 0); - fprintf(stderr, "bitvec: %s\n", osmo_hexdump(bv.data, bv.data_len)); + printf("bitvec: %s\n", osmo_hexdump(bv.data, bv.data_len)); /* Read from bitvec */ memset(out, 0xff, sizeof(out)); @@ -45,7 +118,7 @@ static void test_byte_ops() rc = bitvec_get_uint(&bv, 8); OSMO_ASSERT(rc == 0x7e); - fprintf(stderr, "out: %s\n", osmo_hexdump(out, sizeof(out))); + printf("out: %s\n", osmo_hexdump(out, sizeof(out))); OSMO_ASSERT(out[0] == 0xff); OSMO_ASSERT(out[in_size+1] == 0xff); @@ -72,11 +145,77 @@ static void test_unhex(const char *hex) int main(int argc, char **argv) { + srand(time(NULL)); + + struct bitvec bv; + uint8_t i = 8, test[i]; + + memset(test, 0, i); + bv.data_len = i; + bv.data = test; + bv.cur_bit = 0; + + printf("test shifting...\n"); + + bitvec_set_uint(&bv, 0x0E, 7); + test_shift(&bv, 3); + test_shift(&bv, 17); + bitvec_set_uint(&bv, 0, 32); + bitvec_set_uint(&bv, 0x0A, 7); + test_shift(&bv, 24); + + printf("checking RL functions...\n"); + + bitvec_zero(&bv); + test_rl(&bv); + bitvec_set_uint(&bv, 0x000F, 32); + test_rl(&bv); + bitvec_shiftl(&bv, 18); + test_rl(&bv); + bitvec_set_uint(&bv, 0x0F, 8); + test_rl(&bv); + bitvec_zero(&bv); + bitvec_set_uint(&bv, 0xFF, 8); + test_rl(&bv); + bitvec_set_uint(&bv, 0xFE, 7); + test_rl(&bv); + bitvec_set_uint(&bv, 0, 17); + test_rl(&bv); + bitvec_shiftl(&bv, 18); + test_rl(&bv); + + printf("probing bit access...\n"); + + bitvec_zero(&bv); + bitvec_set_uint(&bv, 0x3747817, 32); + bitvec_shiftl(&bv, 10); + + test_get(&bv, 2); + test_get(&bv, 7); + test_get(&bv, 9); + test_get(&bv, 13); + test_get(&bv, 16); + test_get(&bv, 42); + + printf("feeling bit fills...\n"); + + test_set(&bv, ONE); + test_fill(&bv, 3, ZERO); + test_spare(&bv, 38); + test_spare(&bv, 43); + test_spare(&bv, 1); + test_spare(&bv, 7); + test_fill(&bv, 5, ONE); + test_fill(&bv, 3, L); + + printf("byte me...\n"); + test_byte_ops(); test_unhex("48282407a6a074227201000b2b2b2b2b2b2b2b2b2b2b2b"); test_unhex("47240c00400000000000000079eb2ac9402b2b2b2b2b2b"); test_unhex("47283c367513ba333004242b2b2b2b2b2b2b2b2b2b2b2b"); test_unhex("DEADFACE000000000000000000000000000000BEEFFEED"); test_unhex("FFFFFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"); + return 0; } diff --git a/tests/bitvec/bitvec_test.ok b/tests/bitvec/bitvec_test.ok index 83328b2..1c993d3 100644 --- a/tests/bitvec/bitvec_test.ok +++ b/tests/bitvec/bitvec_test.ok @@ -1,4 +1,123 @@ +test shifting... + 0001110 << 3: + 1110 + 1110 << 17: + + 00000000 00000000 00000000 00000000 0001010 << 24: + 00000000 0001010 +checking RL functions... + [0] RL0=0, RL1=0 + 00000000 00000000 00000000 00001111 [32] RL0=28, RL1=0 + 00000000 001111 [14] RL0=10, RL1=0 + 00000000 00111100 001111 [22] RL0=10, RL1=0 + 11111111 [8] RL0=0, RL1=8 + 11111111 1111110 [15] RL0=0, RL1=14 + 11111111 11111100 00000000 00000000 [32] RL0=0, RL1=14 + 00000000 000000 [14] RL0=14, RL1=0 +probing bit access... + 11010001 11100000 010111 [22] -> 3 (2 bit) [00000000 00000011]: + 11010001 11100000 010111 [22] + 11010001 11100000 010111 [22] -> 104 (7 bit) [00000000 01101000]: + 11010001 11100000 010111 [22] + 11010001 11100000 010111 [22] -> 419 (9 bit) [00000001 10100011]: + 11010001 11100000 010111 [22] + 11010001 11100000 010111 [22] -> 6716 (13 bit) [00011010 00111100]: + 11010001 11100000 010111 [22] + 11010001 11100000 010111 [22] -> -22 (16 bit) [11111111 11101010]: + 11010001 11100000 010111 [22] + 11010001 11100000 010111 [22] -> -22 (42 bit) [11111111 11101010]: + 11010001 11100000 010111 [22] +feeling bit fills... +1> SET 11010001 11100000 010111 [22] ++> [0]: + 11010001 11100000 0101111 [23] + +0> FILL 11010001 11100000 0101111 [23] -3-> [0]: + 11010001 11100000 01011110 00 [26] + +L> SPARE 11010001 11100000 01011110 00 [26] -38-> [0]: + 11010001 11100000 01011110 00101011 0010101 [39] + +L> SPARE 11010001 11100000 01011110 00101011 0010101 [39] -43-> [0]: + 11010001 11100000 01011110 00101011 00101011 0010 [44] + +L> SPARE 11010001 11100000 01011110 00101011 00101011 0010 [44] -1-> [0]: + 11010001 11100000 01011110 00101011 00101011 0010 [44] + +L> SPARE 11010001 11100000 01011110 00101011 00101011 0010 [44] -7-> [0]: + 11010001 11100000 01011110 00101011 00101011 0010 [44] + +1> FILL 11010001 11100000 01011110 00101011 00101011 0010 [44] -5-> [0]: + 11010001 11100000 01011110 00101011 00101011 00101111 1 [49] + +L> FILL 11010001 11100000 01011110 00101011 00101011 00101111 1 [49] -3-> [0]: + 11010001 11100000 01011110 00101011 00101011 00101111 1010 [52] + +byte me... === start test_byte_ops === +bitvec: 7e 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a 7e 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 3f 20 a1 21 a2 22 a3 23 a4 24 a5 25 a6 26 a7 27 a8 28 a9 29 aa 2a ab 2b ac 2c ad 3f 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 1f 90 50 90 d1 11 51 91 d2 12 52 92 d3 13 53 93 d4 14 54 94 d5 15 55 95 d6 16 56 9f 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 0f c8 28 48 68 88 a8 c8 e9 09 29 49 69 89 a9 c9 ea 0a 2a 4a 6a 8a aa ca eb 0b 2b 4f c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 07 e4 14 24 34 44 54 64 74 84 94 a4 b4 c4 d4 e4 f5 05 15 25 35 45 55 65 75 85 95 a7 e0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 03 f2 0a 12 1a 22 2a 32 3a 42 4a 52 5a 62 6a 72 7a 82 8a 92 9a a2 aa b2 ba c2 ca d3 f0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 01 f9 05 09 0d 11 15 19 1d 21 25 29 2d 31 35 39 3d 41 45 49 4d 51 55 59 5d 61 65 69 f8 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 fc 82 84 86 88 8a 8c 8e 90 92 94 96 98 9a 9c 9e a0 a2 a4 a6 a8 aa ac ae b0 b2 b4 fc 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 7e 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a 7e 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 3f 20 a1 21 a2 22 a3 23 a4 24 a5 25 a6 26 a7 27 a8 28 a9 29 aa 2a ab 2b ac 2c ad 3f 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 1f 90 50 90 d1 11 51 91 d2 12 52 92 d3 13 53 93 d4 14 54 94 d5 15 55 95 d6 16 56 9f 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 0f c8 28 48 68 88 a8 c8 e9 09 29 49 69 89 a9 c9 ea 0a 2a 4a 6a 8a aa ca eb 0b 2b 4f c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 07 e4 14 24 34 44 54 64 74 84 94 a4 b4 c4 d4 e4 f5 05 15 25 35 45 55 65 75 85 95 a7 e0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 03 f2 0a 12 1a 22 2a 32 3a 42 4a 52 5a 62 6a 72 7a 82 8a 92 9a a2 aa b2 ba c2 ca d3 f0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 01 f9 05 09 0d 11 15 19 1d 21 25 29 2d 31 35 39 3d 41 45 49 4d 51 55 59 5d 61 65 69 f8 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 fc 82 84 86 88 8a 8c 8e 90 92 94 96 98 9a 9c 9e a0 a2 a4 a6 a8 aa ac ae b0 b2 b4 fc 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 7e 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a 7e 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 3f 20 a1 21 a2 22 a3 23 a4 24 a5 25 a6 26 a7 27 a8 28 a9 29 aa 2a ab 2b ac 2c ad 3f 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 1f 90 50 90 d1 11 51 91 d2 12 52 92 d3 13 53 93 d4 14 54 94 d5 15 55 95 d6 16 56 9f 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 0f c8 28 48 68 88 a8 c8 e9 09 29 49 69 89 a9 c9 ea 0a 2a 4a 6a 8a aa ca eb 0b 2b 4f c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 07 e4 14 24 34 44 54 64 74 84 94 a4 b4 c4 d4 e4 f5 05 15 25 35 45 55 65 75 85 95 a7 e0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 03 f2 0a 12 1a 22 2a 32 3a 42 4a 52 5a 62 6a 72 7a 82 8a 92 9a a2 aa b2 ba c2 ca d3 f0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 01 f9 05 09 0d 11 15 19 1d 21 25 29 2d 31 35 39 3d 41 45 49 4d 51 55 59 5d 61 65 69 f8 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 00 fc 82 84 86 88 8a 8c 8e 90 92 94 96 98 9a 9c 9e a0 a2 a4 a6 a8 aa ac ae b0 b2 b4 fc 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 00 7e 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a 7e 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 00 3f 20 a1 21 a2 22 a3 23 a4 24 a5 25 a6 26 a7 27 a8 28 a9 29 aa 2a ab 2b ac 2c ad 3f 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 00 1f 90 50 90 d1 11 51 91 d2 12 52 92 d3 13 53 93 d4 14 54 94 d5 15 55 95 d6 16 56 9f 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 00 0f c8 28 48 68 88 a8 c8 e9 09 29 49 69 89 a9 c9 ea 0a 2a 4a 6a 8a aa ca eb 0b 2b 4f c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 00 07 e4 14 24 34 44 54 64 74 84 94 a4 b4 c4 d4 e4 f5 05 15 25 35 45 55 65 75 85 95 a7 e0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 00 03 f2 0a 12 1a 22 2a 32 3a 42 4a 52 5a 62 6a 72 7a 82 8a 92 9a a2 aa b2 ba c2 ca d3 f0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 00 01 f9 05 09 0d 11 15 19 1d 21 25 29 2d 31 35 39 3d 41 45 49 4d 51 55 59 5d 61 65 69 f8 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff +bitvec: 00 00 00 00 fc 82 84 86 88 8a 8c 8e 90 92 94 96 98 9a 9c 9e a0 a2 a4 a6 a8 aa ac ae b0 b2 b4 fc 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +out: ff 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f 50 51 52 53 54 55 56 57 58 59 5a ff === end test_byte_ops === 1 -=> cur_bit=184 48282407a6a074227201000b2b2b2b2b2b2b2b2b2b2b2b0000000000000000000000000000000000000000000000000000000000000000000000000000000000 -- 2.5.0

3 4

[PATCH 1/3] Introduce new phy_link and phy_instance abstraction
by laforge＠gnumonks.org 04 Feb '16

04 Feb '16

From: Harald Welte <laforge(a)gnumonks.org> This way we can model a flexible mapping between any number of PHYs, each having multiple instances, and then map BTSs with TRXx on top of those PHYs. --- doc/examples/octphy/osmo-bts.cfg | 8 +- include/osmo-bts/Makefile.am | 2 +- include/osmo-bts/bts.h | 3 +- include/osmo-bts/bts_model.h | 5 + include/osmo-bts/gsm_data.h | 15 -- include/osmo-bts/phy_link.h | 115 +++++++++++ include/osmo-bts/scheduler.h | 4 +- include/osmo-bts/vty.h | 7 +- src/common/Makefile.am | 2 +- src/common/bts.c | 33 +++- src/common/main.c | 20 ++ src/common/phy_link.c | 155 +++++++++++++++ src/common/scheduler.c | 6 +- src/common/vty.c | 194 ++++++++++++++++++- src/osmo-bts-octphy/l1_if.c | 133 ++++++++----- src/osmo-bts-octphy/l1_if.h | 31 ++- src/osmo-bts-octphy/l1_oml.c | 96 +++++---- src/osmo-bts-octphy/main.c | 1 + src/osmo-bts-octphy/octphy_hw_api.c | 14 +- src/osmo-bts-octphy/octphy_vty.c | 198 +++++++++++-------- src/osmo-bts-trx/l1_if.c | 84 ++++---- src/osmo-bts-trx/l1_if.h | 18 +- src/osmo-bts-trx/main.c | 56 ++---- src/osmo-bts-trx/scheduler_trx.c | 16 +- src/osmo-bts-trx/trx_if.c | 124 +++++++++--- src/osmo-bts-trx/trx_if.h | 1 + src/osmo-bts-trx/trx_vty.c | 377 ++++++++++++++++++++++-------------- 27 files changed, 1220 insertions(+), 498 deletions(-) create mode 100644 include/osmo-bts/phy_link.h create mode 100644 src/common/phy_link.c diff --git a/doc/examples/octphy/osmo-bts.cfg b/doc/examples/octphy/osmo-bts.cfg index 07bcae0..4f27c8d 100644 --- a/doc/examples/octphy/osmo-bts.cfg +++ b/doc/examples/octphy/osmo-bts.cfg @@ -20,9 +20,13 @@ log stderr line vty no login ! +phy 0 + octphy hw-addr 00:0C:90:2e:80:1e + octphy net-device eth0.2342 + instance 0 bts 0 band 1800 ipa unit-id 1234 0 oml remote-ip 127.0.0.1 - phy-hw-addr 00:0C:90:2e:80:1e - phy-netdev eth0.2342 + trx 0 + phy 0 instance 0 diff --git a/include/osmo-bts/Makefile.am b/include/osmo-bts/Makefile.am index af88a1a..d0b55ff 100644 --- a/include/osmo-bts/Makefile.am +++ b/include/osmo-bts/Makefile.am @@ -1,4 +1,4 @@ noinst_HEADERS = abis.h bts.h bts_model.h gsm_data.h logging.h measurement.h \ oml.h paging.h rsl.h signal.h vty.h amr.h pcu_if.h pcuif_proto.h \ handover.h msg_utils.h tx_power.h control_if.h cbch.h l1sap.h \ - power_control.h scheduler.h scheduler_backend.h + power_control.h scheduler.h scheduler_backend.h phy_link.h diff --git a/include/osmo-bts/bts.h b/include/osmo-bts/bts.h index 9e21186..af0b305 100644 --- a/include/osmo-bts/bts.h +++ b/include/osmo-bts/bts.h @@ -21,13 +21,12 @@ void destroy_bts(struct gsm_bts *bts); int work_bts(struct gsm_bts *bts); int bts_link_estab(struct gsm_bts *bts); int trx_link_estab(struct gsm_bts_trx *trx); +int trx_set_available(struct gsm_bts_trx *trx, int avail); void bts_new_si(void *arg); void bts_setup_slot(struct gsm_bts_trx_ts *slot, uint8_t comb); int bts_agch_enqueue(struct gsm_bts *bts, struct msgb *msg); struct msgb *bts_agch_dequeue(struct gsm_bts *bts); -void bts_update_agch_max_queue_length(struct gsm_bts *bts); -int bts_agch_max_queue_length(int T, int bcch_conf); int bts_ccch_copy_msg(struct gsm_bts *bts, uint8_t *out_buf, struct gsm_time *gt, int is_ag_res); diff --git a/include/osmo-bts/bts_model.h b/include/osmo-bts/bts_model.h index 41b5e93..dfea988 100644 --- a/include/osmo-bts/bts_model.h +++ b/include/osmo-bts/bts_model.h @@ -8,6 +8,9 @@ #include <osmo-bts/gsm_data.h> +struct phy_link; +struct phy_instance; + /* BTS model specific functions needed by the common code */ int bts_model_init(struct gsm_bts *bts); @@ -32,6 +35,8 @@ int bts_model_vty_init(struct gsm_bts *bts); void bts_model_config_write_bts(struct vty *vty, struct gsm_bts *bts); void bts_model_config_write_trx(struct vty *vty, struct gsm_bts_trx *trx); +void bts_model_config_write_phy(struct vty *vty, struct phy_link *plink); +void bts_model_config_write_phy_inst(struct vty *vty, struct phy_instance *pinst); int bts_model_oml_estab(struct gsm_bts *bts); diff --git a/include/osmo-bts/gsm_data.h b/include/osmo-bts/gsm_data.h index 6a7bca8..f9e6ed1 100644 --- a/include/osmo-bts/gsm_data.h +++ b/include/osmo-bts/gsm_data.h @@ -119,21 +119,6 @@ enum lchan_ciph_state { #include "openbsc/gsm_data_shared.h" -struct femtol1_hdl; - -static inline struct femtol1_hdl *trx_femtol1_hdl(struct gsm_bts_trx *trx) -{ - return trx->role_bts.l1h; -} - -struct trx_l1h; - -static inline struct trx_l1h *trx_l1h_hdl(struct gsm_bts_trx *trx) -{ - return trx->role_bts.l1h; -} - - void lchan_set_state(struct gsm_lchan *lchan, enum gsm_lchan_state state); /* cipher code */ diff --git a/include/osmo-bts/phy_link.h b/include/osmo-bts/phy_link.h new file mode 100644 index 0000000..b9fc412 --- /dev/null +++ b/include/osmo-bts/phy_link.h @@ -0,0 +1,115 @@ +#pragma once + +#include <stdint.h> +#include <osmocom/core/linuxlist.h> + +#include <osmo-bts/scheduler.h> + +#include <linux/if_packet.h> + +struct gsm_bts_trx; + +enum phy_link_type { + PHY_LINK_T_NONE, + PHY_LINK_T_SYSMOBTS, + PHY_LINK_T_OSMOTRX, +}; + +enum phy_link_state { + PHY_LINK_SHUTDOWN, + PHY_LINK_CONNECTING, + PHY_LINK_CONNECTED, +}; + +/* A PHY link represents the connection to a given PHYsical layer + * implementation. That PHY link contains 1...N PHY instances, one for + * each TRX */ +struct phy_link { + struct llist_head list; + int num; + enum phy_link_type type; + enum phy_link_state state; + struct llist_head instances; + char *description; + union { + struct { + } sysmobts; + struct { + char *transceiver_ip; + uint16_t base_port_local; + uint16_t base_port_remote; + struct osmo_fd trx_ofd_clk; + + uint32_t clock_advance; + uint32_t rts_advance; + + int rxgain_valid; + int rxgain; + int rxgain_sent; + + int power_valid; + int power; + int power_oml; + int power_sent; + } osmotrx; + struct { + /* MAC address of the PHY */ + struct sockaddr_ll phy_addr; + /* Network device name */ + char *netdev_name; + + /* configuration */ + uint32_t rf_port_index; + uint32_t rx_gain_db; + uint32_t tx_atten_db; + + struct octphy_hdl *hdl; + } octphy; + } u; +}; + +struct phy_instance { + /* liked inside phy_link.linstances */ + struct llist_head list; + int num; + char *description; + + /* pointer to the PHY link to which we belong */ + struct phy_link *phy_link; + + /* back-pointer to the TRX to which we're associated */ + struct gsm_bts_trx *trx; + + union { + struct { + } sysmobts; + struct { + struct trx_l1h *hdl; + } osmotrx; + struct { + /* logical transceiver number within one PHY */ + uint32_t trx_id; + } octphy; + } u; +}; + +struct phy_link *phy_link_by_num(int num); +struct phy_link *phy_link_create(void *ctx, int num); +void phy_link_destroy(struct phy_link *plink); +void phy_link_state_set(struct phy_link *plink, enum phy_link_state state); +int phy_links_open(void); + +struct phy_instance *phy_instance_by_num(struct phy_link *plink, int num); +struct phy_instance *phy_instance_create(struct phy_link *plink, int num); +void phy_instance_link_to_trx(struct phy_instance *pinst, struct gsm_bts_trx *trx); +void phy_instance_destroy(struct phy_instance *pinst); +const char *phy_instance_name(struct phy_instance *pinst); + +void phy_user_statechg_notif(struct phy_instance *pinst, enum phy_link_state link_state); + +static inline struct phy_instance *trx_phy_instance(struct gsm_bts_trx *trx) +{ + return trx->role_bts.l1h; +} + +int bts_model_phy_link_open(struct phy_link *plink); diff --git a/include/osmo-bts/scheduler.h b/include/osmo-bts/scheduler.h index 13ef051..b11e6f1 100644 --- a/include/osmo-bts/scheduler.h +++ b/include/osmo-bts/scheduler.h @@ -1,6 +1,8 @@ #ifndef TRX_SCHEDULER_H #define TRX_SCHEDULER_H +#include <osmo-bts/gsm_data.h> + /* These types define the different channels on a multiframe. * Each channel has queues and can be activated individually. */ @@ -133,7 +135,7 @@ extern uint32_t transceiver_last_fn; /*! \brief Initialize the scheudler data structures */ -int trx_sched_init(struct l1sched_trx *l1t); +int trx_sched_init(struct l1sched_trx *l1t, struct gsm_bts_trx *trx); /*! \brief De-initialize the scheudler data structures */ void trx_sched_exit(struct l1sched_trx *l1t); diff --git a/include/osmo-bts/vty.h b/include/osmo-bts/vty.h index 546729c..5d8d4a7 100644 --- a/include/osmo-bts/vty.h +++ b/include/osmo-bts/vty.h @@ -5,7 +5,12 @@ #include <osmocom/vty/command.h> enum bts_vty_node { - BTS_NODE = _LAST_OSMOVTY_NODE + 1, + /* PHY_NODE must come before BTS node to ensure the phy + * instances are created at the time the TRX nodes want to refer + * to them */ + PHY_NODE = _LAST_OSMOVTY_NODE + 1, + PHY_INST_NODE, + BTS_NODE, TRX_NODE, }; diff --git a/src/common/Makefile.am b/src/common/Makefile.am index fea205c..8df6513 100644 --- a/src/common/Makefile.am +++ b/src/common/Makefile.am @@ -8,6 +8,6 @@ libbts_a_SOURCES = gsm_data_shared.c sysinfo.c logging.c abis.c oml.c bts.c \ load_indication.c pcu_sock.c handover.c msg_utils.c \ load_indication.c pcu_sock.c handover.c msg_utils.c \ tx_power.c bts_ctrl_commands.c bts_ctrl_lookup.c \ - l1sap.c cbch.c power_control.c main.c + l1sap.c cbch.c power_control.c main.c phy_link.c libl1sched_a_SOURCES = scheduler.c diff --git a/src/common/bts.c b/src/common/bts.c index 43f4c25..a775329 100644 --- a/src/common/bts.c +++ b/src/common/bts.c @@ -44,6 +44,8 @@ #include <osmo-bts/oml.h> #include <osmo-bts/signal.h> +static void bts_update_agch_max_queue_length(struct gsm_bts *bts); +static int bts_agch_max_queue_length(int T, int bcch_conf); struct gsm_network bts_gsmnet = { .bts_list = { &bts_gsmnet.bts_list, &bts_gsmnet.bts_list }, @@ -72,6 +74,8 @@ static int bts_signal_cbfn(unsigned int subsys, unsigned int signal, return 0; } +/* Initialize the BTS (and TRX) data structures, called before config + * file reading */ int bts_init(struct gsm_bts *bts) { struct gsm_bts_role_bts *btsb; @@ -255,6 +259,31 @@ int trx_link_estab(struct gsm_bts_trx *trx) return 0; } +/* set the availability of the TRX (used by PHY driver) */ +int trx_set_available(struct gsm_bts_trx *trx, int avail) +{ + int tn; + + LOGP(DSUM, LOGL_INFO, "TRX(%d): Setting available = %d\n", + trx->nr, avail); + if (avail) { + oml_mo_state_chg(&trx->mo, NM_OPSTATE_DISABLED, NM_AVSTATE_OK); + oml_mo_tx_sw_act_rep(&trx->mo); + oml_mo_state_chg(&trx->bb_transc.mo, -1, NM_AVSTATE_OK); + oml_mo_tx_sw_act_rep(&trx->bb_transc.mo); + + for (tn = 0; tn < ARRAY_SIZE(trx->ts); tn++) + oml_mo_state_chg(&trx->ts[tn].mo, NM_OPSTATE_DISABLED, NM_AVSTATE_DEPENDENCY); + } else { + oml_mo_state_chg(&trx->mo, NM_OPSTATE_DISABLED, NM_AVSTATE_OFF_LINE); + oml_mo_state_chg(&trx->bb_transc.mo, -1, NM_AVSTATE_OFF_LINE); + + for (tn = 0; tn < ARRAY_SIZE(trx->ts); tn++) + oml_mo_state_chg(&trx->ts[tn].mo, NM_OPSTATE_DISABLED, NM_AVSTATE_OFF_LINE); + } + return 0; +} + int lchan_init_lapdm(struct gsm_lchan *lchan) { struct lapdm_channel *lc = &lchan->lapdm_ch; @@ -271,7 +300,7 @@ int lchan_init_lapdm(struct gsm_lchan *lchan) #define CCCH_RACH_RATIO_COMBINED256 (256*1/9) #define CCCH_RACH_RATIO_SEPARATE256 (256*10/55) -int bts_agch_max_queue_length(int T, int bcch_conf) +static int bts_agch_max_queue_length(int T, int bcch_conf) { int S, ccch_rach_ratio256, i; int T_group = 0; @@ -310,7 +339,7 @@ int bts_agch_max_queue_length(int T, int bcch_conf) return (T + 2 * S) * ccch_rach_ratio256 / 256; } -void bts_update_agch_max_queue_length(struct gsm_bts *bts) +static void bts_update_agch_max_queue_length(struct gsm_bts *bts) { struct gsm_bts_role_bts *btsb = bts_role_bts(bts); struct gsm48_system_information_type_3 *si3; diff --git a/src/common/main.c b/src/common/main.c index fabe482..e454a28 100644 --- a/src/common/main.c +++ b/src/common/main.c @@ -42,6 +42,7 @@ #include <osmocom/core/gsmtap.h> #include <osmo-bts/gsm_data.h> +#include <osmo-bts/phy_link.h> #include <osmo-bts/logging.h> #include <osmo-bts/abis.h> #include <osmo-bts/bts.h> @@ -284,6 +285,19 @@ int bts_main(int argc, char **argv) exit(1); } + if (!phy_link_by_num(0)) { + fprintf(stderr, "You need to configure at last phy0\n"); + exit(1); + } + + llist_for_each_entry(trx, &bts->trx_list, list) { + if (!trx->role_bts.l1h) { + fprintf(stderr, "TRX %u has no associated PHY instance\n", + trx->nr); + exit(1); + } + } + write_pid_file("osmo-bts"); bts_controlif_setup(bts); @@ -317,6 +331,12 @@ int bts_main(int argc, char **argv) exit(2); } + rc = phy_links_open(); + if (rc < 0) { + fprintf(stderr, "unable ot open PHY link(s)\n"); + exit(2); + } + if (daemonize) { rc = osmo_daemonize(); if (rc < 0) { diff --git a/src/common/phy_link.c b/src/common/phy_link.c new file mode 100644 index 0000000..9442349 --- /dev/null +++ b/src/common/phy_link.c @@ -0,0 +1,155 @@ +#include <stdint.h> + +#include <osmocom/core/linuxlist.h> +#include <osmocom/core/talloc.h> + +#include <osmo-bts/bts.h> +#include <osmo-bts/gsm_data.h> +#include <osmo-bts/phy_link.h> +#include <osmo-bts/oml.h> +#include <osmo-bts/logging.h> + +static LLIST_HEAD(g_phy_links); + +struct phy_link *phy_link_by_num(int num) +{ + struct phy_link *plink; + + llist_for_each_entry(plink, &g_phy_links, list) { + if (plink->num == num) + return plink; + } + + return NULL; +} + +struct phy_link *phy_link_create(void *ctx, int num) +{ + struct phy_link *plink = talloc_zero(ctx, struct phy_link); + + if (phy_link_by_num(num)) + return NULL; + + plink = talloc_zero(ctx, struct phy_link); + plink->num = num; + plink->state = PHY_LINK_SHUTDOWN; + INIT_LLIST_HEAD(&plink->instances); + llist_add_tail(&plink->list, &g_phy_links); + + return plink; +} + +const struct value_string phy_link_state_vals[] = { + { PHY_LINK_SHUTDOWN, "shutdown" }, + { PHY_LINK_CONNECTING, "connectiong" }, + { PHY_LINK_CONNECTED, "connected" }, + { 0, NULL } +}; + +void phy_link_state_set(struct phy_link *plink, enum phy_link_state state) +{ + struct phy_instance *pinst; + + LOGP(DL1C, LOGL_INFO, "PHY link state change %s -> %s\n", + get_value_string(phy_link_state_vals, plink->state), + get_value_string(phy_link_state_vals, state)); + + /* notify all TRX associated with this phy */ + llist_for_each_entry(pinst, &plink->instances, list) { + struct gsm_bts_trx *trx = pinst->trx; + if (!trx) + continue; + + switch (state) { + case PHY_LINK_CONNECTED: + LOGP(DL1C, LOGL_INFO, "trx_set_avail(1)\n"); + trx_set_available(trx, 1); + break; + default: + LOGP(DL1C, LOGL_INFO, "trx_set_avail(0)\n"); + trx_set_available(trx, 0); + break; + } + } + + plink->state = state; +} + +struct phy_instance *phy_instance_by_num(struct phy_link *plink, int num) +{ + struct phy_instance *pinst; + + llist_for_each_entry(pinst, &plink->instances, list) { + if (pinst->num == num) + return pinst; + } + return NULL; +} + +struct phy_instance *phy_instance_create(struct phy_link *plink, int num) +{ + struct phy_instance *pinst = talloc_zero(plink, struct phy_instance); + + if (phy_instance_by_num(plink, num)) + return NULL; + + pinst = talloc_zero(plink, struct phy_instance); + pinst->num = num; + pinst->phy_link = plink; + llist_add_tail(&pinst->list, &plink->instances); + + return pinst; +} + +void phy_instance_link_to_trx(struct phy_instance *pinst, struct gsm_bts_trx *trx) +{ + trx->role_bts.l1h = pinst; + pinst->trx = trx; +} + +void phy_instance_destroy(struct phy_instance *pinst) +{ + /* remove from list of instances in the link */ + llist_del(&pinst->list); + + /* remove reverse link from TRX */ + OSMO_ASSERT(pinst->trx->role_bts.l1h == pinst); + pinst->trx->role_bts.l1h = NULL; + pinst->trx = NULL; + + talloc_free(pinst); +} + +void phy_link_destroy(struct phy_link *plink) +{ + struct phy_instance *pinst, *pinst2; + + llist_for_each_entry_safe(pinst, pinst2, &plink->instances, list) + phy_instance_destroy(pinst); + + talloc_free(plink); +} + +int phy_links_open(void) +{ + struct phy_link *plink; + + llist_for_each_entry(plink, &g_phy_links, list) { + int rc; + + rc = bts_model_phy_link_open(plink); + if (rc < 0) + return rc; + } + + return 0; +} + +const char *phy_instance_name(struct phy_instance *pinst) +{ + static char buf[32]; + + snprintf(buf, sizeof(buf), "phy%u.%u", pinst->phy_link->num, + pinst->num); + return buf; +} diff --git a/src/common/scheduler.c b/src/common/scheduler.c index 64d89ac..de09fbf 100644 --- a/src/common/scheduler.c +++ b/src/common/scheduler.c @@ -134,11 +134,13 @@ const struct trx_chan_desc trx_chan_desc[_TRX_CHAN_MAX] = { * init / exit */ -int trx_sched_init(struct l1sched_trx *l1t) +int trx_sched_init(struct l1sched_trx *l1t, struct gsm_bts_trx *trx) { uint8_t tn; int i; + l1t->trx = trx; + LOGP(DL1C, LOGL_NOTICE, "Init scheduler for trx=%u\n", l1t->trx->nr); for (tn = 0; tn < ARRAY_SIZE(l1t->ts); tn++) { @@ -191,7 +193,7 @@ void trx_sched_exit(struct l1sched_trx *l1t) void trx_sched_reset(struct l1sched_trx *l1t) { trx_sched_exit(l1t); - trx_sched_init(l1t); + trx_sched_init(l1t, l1t->trx); } struct msgb *_sched_dequeue_prim(struct l1sched_trx *l1t, int8_t tn, uint32_t fn, diff --git a/src/common/vty.c b/src/common/vty.c index 4fd65d0..94ccdbe 100644 --- a/src/common/vty.c +++ b/src/common/vty.c @@ -40,6 +40,7 @@ #include <osmo-bts/logging.h> #include <osmo-bts/gsm_data.h> +#include <osmo-bts/phy_link.h> #include <osmo-bts/abis.h> #include <osmo-bts/bts.h> #include <osmo-bts/rsl.h> @@ -53,6 +54,13 @@ int bts_vty_go_parent(struct vty *vty) { switch (vty->node) { + case PHY_INST_NODE: + vty->node = PHY_NODE; + { + struct phy_instance *pinst = vty->index; + vty->index = pinst->phy_link; + } + break; case TRX_NODE: vty->node = BTS_NODE; { @@ -60,6 +68,7 @@ int bts_vty_go_parent(struct vty *vty) vty->index = trx->bts; } break; + case PHY_NODE: default: vty->node = CONFIG_NODE; } @@ -71,6 +80,8 @@ int bts_vty_is_config_node(struct vty *vty, int node) switch (node) { case TRX_NODE: case BTS_NODE: + case PHY_NODE: + case PHY_INST_NODE: return 1; default: return 0; @@ -81,6 +92,17 @@ gDEFUN(ournode_exit, ournode_exit_cmd, "exit", "Exit current node, go down to provious node") { switch (vty->node) { + case PHY_INST_NODE: + vty->node = PHY_NODE; + { + struct phy_instance *pinst = vty->index; + vty->index = pinst->phy_link; + } + break; + case PHY_NODE: + vty->node = CONFIG_NODE; + vty->index = NULL; + break; case TRX_NODE: vty->node = BTS_NODE; { @@ -141,6 +163,7 @@ static struct cmd_node trx_node = { 1, }; + DEFUN(cfg_bts_trx, cfg_bts_trx_cmd, "trx <0-254>", "Select a TRX to configure\n" "TRX number\n") @@ -151,7 +174,7 @@ DEFUN(cfg_bts_trx, cfg_bts_trx_cmd, trx = gsm_bts_trx_num(bts, trx_nr); if (!trx) { - vty_out(vty, "Unknown TRX %u. Aavialable TRX are: 0..%d%s", + vty_out(vty, "Unknown TRX %u. Aavialable TRX are: 0..%u%s", trx_nr, bts->num_trx - 1, VTY_NEWLINE); return CMD_WARNING; } @@ -232,6 +255,7 @@ static void config_write_bts_single(struct vty *vty, struct gsm_bts *bts) llist_for_each_entry(trx, &bts->trx_list, list) { struct trx_power_params *tpp = &trx->power_params; + struct phy_instance *pinst = trx_phy_instance(trx); vty_out(vty, " trx %u%s", trx->nr, VTY_NEWLINE); if (trx->power_params.user_gain_mdB) @@ -246,6 +270,8 @@ static void config_write_bts_single(struct vty *vty, struct gsm_bts *bts) vty_out(vty, " ms-power-control %s%s", trx->ms_power_control == 0 ? "dsp" : "osmo", VTY_NEWLINE); + vty_out(vty, " phy %u instance %u%s", pinst->phy_link->num, + pinst->num, VTY_NEWLINE); bts_model_config_write_trx(vty, trx); } @@ -262,6 +288,35 @@ static int config_write_bts(struct vty *vty) return CMD_SUCCESS; } +static void config_write_phy_single(struct vty *vty, struct phy_link *plink) +{ + int i; + + vty_out(vty, "phy %u%s", plink->num, VTY_NEWLINE); + bts_model_config_write_phy(vty, plink); + + for (i = 0; i < 255; i++) { + struct phy_instance *pinst = phy_instance_by_num(plink, i); + if (!pinst) + break; + vty_out(vty, " instance %u%s", pinst->num, VTY_NEWLINE); + } +} + +static int config_write_phy(struct vty *vty) +{ + int i; + + for (i = 0; i < 255; i++) { + struct phy_link *plink = phy_link_by_num(i); + if (!plink) + break; + config_write_phy_single(vty, plink); + } + + return CMD_SUCCESS; +} + static int config_write_dummy(struct vty *vty) { return CMD_SUCCESS; @@ -532,6 +587,33 @@ DEFUN(cfg_trx_ms_power_control, cfg_trx_ms_power_control_cmd, return CMD_SUCCESS; } +DEFUN(cfg_trx_phy, cfg_trx_phy_cmd, + "phy <0-255> instance <0-255>", + "Configure PHY Link+Instance for this TRX\n" + "PHY Link number\n" "PHY instance\n" "PHY Instance number") +{ + struct gsm_bts_trx *trx = vty->index; + struct phy_link *plink = phy_link_by_num(atoi(argv[0])); + struct phy_instance *pinst; + + if (!plink) { + vty_out(vty, "phy%s does not exist%s", + argv[0], VTY_NEWLINE); + return CMD_WARNING; + } + + pinst = phy_instance_by_num(plink, atoi(argv[1])); + if (!pinst) { + vty_out(vty, "phy%s instance %s does not exit%s", + argv[0], argv[1], VTY_NEWLINE); + return CMD_WARNING; + } + + trx->role_bts.l1h = pinst; + pinst->trx = trx; + + return CMD_SUCCESS; +} /* ====================================================================== * SHOW @@ -702,6 +784,106 @@ DEFUN(cfg_trx_no_gsmtap_sapi, cfg_trx_no_gsmtap_sapi_cmd, return CMD_SUCCESS; } +static struct cmd_node phy_node = { + PHY_NODE, + "%s(phy)#", + 1, +}; + +static struct cmd_node phy_inst_node = { + PHY_INST_NODE, + "%s(phy-inst)#", + 1, +}; + +DEFUN(cfg_phy, cfg_phy_cmd, + "phy <0-255>", + "Select a PHY to configure\n" "PHY number\n") +{ + int phy_nr = atoi(argv[0]); + struct phy_link *plink; + + plink = phy_link_by_num(phy_nr); + if (!plink) + plink = phy_link_create(tall_bts_ctx, phy_nr); + if (!plink) + return CMD_WARNING; + + vty->index = plink; + vty->index_sub = &plink->description; + vty->node = PHY_NODE; + + return CMD_SUCCESS; +} + +DEFUN(cfg_phy_inst, cfg_phy_inst_cmd, + "instance <0-255>", + "Select a PHY instance to configure\n" "PHY Instance number\n") +{ + int inst_nr = atoi(argv[0]); + struct phy_link *plink = vty->index; + struct phy_instance *pinst; + + pinst = phy_instance_by_num(plink, inst_nr); + if (!pinst) { + pinst = phy_instance_create(plink, inst_nr); + if (!pinst) { + vty_out(vty, "Unable to create phy%u instance %u%s", + plink->num, inst_nr, VTY_NEWLINE); + return CMD_WARNING; + } + } + + vty->index = pinst; + vty->index_sub = &pinst->description; + vty->node = PHY_INST_NODE; + + return CMD_SUCCESS; +} + +DEFUN(cfg_phy_no_inst, cfg_phy_no_inst_cmd, + "no instance <0-255>" + NO_STR "Select a PHY instance to remove\n", "PHY Instance number\n") +{ + int inst_nr = atoi(argv[0]); + struct phy_link *plink = vty->index; + struct phy_instance *pinst; + + pinst = phy_instance_by_num(plink, inst_nr); + if (!pinst) { + vty_out(vty, "No such instance %u%s", inst_nr, VTY_NEWLINE); + return CMD_WARNING; + } + + phy_instance_destroy(pinst); + + return CMD_SUCCESS; +} + +#if 0 +DEFUN(cfg_phy_type, cfg_phy_type_cmd, + "type (sysmobts|osmo-trx|virtual)", + "configure the type of the PHY\n" + "sysmocom sysmoBTS PHY\n" + "OsmoTRX based PHY\n" + "Virtual PHY (GSMTAP based)\n") +{ + struct phy_link *plink = vty->index; + + if (plink->state != PHY_LINK_SHUTDOWN) { + vty_out(vty, "Cannot change type of active PHY%s", VTY_NEWLINE); + return CMD_WARNING; + } + + if (!strcmp(argv[0], "sysmobts")) + plink->type = PHY_LINK_T_SYSMOBTS; + else if (!strcmp(argv[0], "osmo-trx")) + plink->type = PHY_LINK_T_OSMOTRX; + else if (!strcmp(argv[0], "virtual")) + plink->type = PHY_LINK_T_VIRTUAL; +} +#endif + DEFUN(bts_t_t_l_jitter_buf, bts_t_t_l_jitter_buf_cmd, "bts <0-0> trx <0-0> ts <0-7> lchan <0-1> rtp jitter-buffer <0-10000>", @@ -813,10 +995,20 @@ int bts_vty_init(struct gsm_bts *bts, const struct log_info *cat) install_element(TRX_NODE, &cfg_trx_pr_step_size_cmd); install_element(TRX_NODE, &cfg_trx_pr_step_interval_cmd); install_element(TRX_NODE, &cfg_trx_ms_power_control_cmd); + install_element(TRX_NODE, &cfg_trx_phy_cmd); install_element(ENABLE_NODE, &bts_t_t_l_jitter_buf_cmd); install_element(ENABLE_NODE, &bts_t_t_l_loopback_cmd); install_element(ENABLE_NODE, &no_bts_t_t_l_loopback_cmd); + install_element(CONFIG_NODE, &cfg_phy_cmd); + install_node(&phy_node, config_write_phy); + install_default(PHY_NODE); + install_element(PHY_NODE, &cfg_phy_inst_cmd); + install_element(PHY_NODE, &cfg_phy_no_inst_cmd); + + install_node(&phy_inst_node, config_write_dummy); + install_default(PHY_INST_NODE); + return 0; } diff --git a/src/osmo-bts-octphy/l1_if.c b/src/osmo-bts-octphy/l1_if.c index db6e032..f73e4f9 100644 --- a/src/osmo-bts-octphy/l1_if.c +++ b/src/osmo-bts-octphy/l1_if.c @@ -38,6 +38,7 @@ #include <osmocom/core/socket.h> #include <osmo-bts/gsm_data.h> +#include <osmo-bts/bts_model.h> #include <osmo-bts/oml.h> #include <osmo-bts/logging.h> #include <osmo-bts/l1sap.h> @@ -109,6 +110,17 @@ osmocom_to_octphy_band(enum gsm_band osmo_band, unsigned int arfcn) } }; +struct gsm_bts_trx *trx_by_l1h(struct octphy_hdl *fl1h, unsigned int trx_id) +{ + struct phy_instance *pinst; + + pinst = phy_instance_by_num(fl1h->phy_link, trx_id); + if (!pinst) + return NULL; + + return pinst->trx; +} + struct gsm_lchan *get_lchan_by_lchid(struct gsm_bts_trx *trx, tOCTVC1_GSM_LOGICAL_CHANNEL_ID *lch_id) { @@ -282,10 +294,9 @@ int l1if_req_compl(struct octphy_hdl *fl1h, struct msgb *msg, } /* For OctPHY, this only about sending state changes to BSC */ -int l1if_activate_rf(struct octphy_hdl *fl1h, int on) +int l1if_activate_rf(struct gsm_bts_trx *trx, int on) { int i; - struct gsm_bts_trx *trx = fl1h->priv; if (on) { /* signal availability */ oml_mo_state_chg(&trx->mo, NM_OPSTATE_DISABLED, NM_AVSTATE_OK); @@ -422,7 +433,8 @@ static void empty_req_from_rts_ind(tOCTVC1_GSM_MSG_TRX_REQUEST_LOGICAL_CHANNEL_E static int ph_data_req(struct gsm_bts_trx *trx, struct msgb *msg, struct osmo_phsap_prim *l1sap) { - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct msgb *l1msg = l1p_msgb_alloc(); uint32_t u32Fn; uint8_t u8Tn, subCh, sapi = 0; @@ -489,7 +501,7 @@ static int ph_data_req(struct gsm_bts_trx *trx, struct msgb *msg, l1if_fill_msg_hdr(&data_req->Header, l1msg, fl1h, cOCTVC1_MSG_TYPE_COMMAND, cOCTVC1_GSM_MSG_TRX_REQUEST_LOGICAL_CHANNEL_DATA_CID); - data_req->TrxId.byTrxId = trx->nr; + data_req->TrxId.byTrxId = pinst->u.octphy.trx_id; data_req->LchId.byTimeslotNb = u8Tn; data_req->LchId.bySAPI = sapi; data_req->LchId.bySubChannelNb = subCh; @@ -508,7 +520,7 @@ static int ph_data_req(struct gsm_bts_trx *trx, struct msgb *msg, l1if_fill_msg_hdr(&empty_frame_req->Header, l1msg, fl1h, cOCTVC1_MSG_TYPE_COMMAND, cOCTVC1_GSM_MSG_TRX_REQUEST_LOGICAL_CHANNEL_EMPTY_FRAME_CID); - empty_frame_req->TrxId.byTrxId = trx->nr; + empty_frame_req->TrxId.byTrxId = pinst->u.octphy.trx_id; empty_frame_req->LchId.byTimeslotNb = u8Tn; empty_frame_req->LchId.bySAPI = sapi; empty_frame_req->LchId.bySubChannelNb = subCh; @@ -527,7 +539,8 @@ done: static int ph_tch_req(struct gsm_bts_trx *trx, struct msgb *msg, struct osmo_phsap_prim *l1sap) { - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct gsm_lchan *lchan; uint32_t u32Fn; uint8_t u8Tn, subCh, sapi, ss; @@ -565,7 +578,7 @@ static int ph_tch_req(struct gsm_bts_trx *trx, struct msgb *msg, l1if_fill_msg_hdr(&data_req->Header, nmsg, fl1h, cOCTVC1_MSG_TYPE_COMMAND, cOCTVC1_GSM_MSG_TRX_REQUEST_LOGICAL_CHANNEL_DATA_CID); - data_req->TrxId.byTrxId = trx->nr; + data_req->TrxId.byTrxId = pinst->u.octphy.trx_id; data_req->LchId.byTimeslotNb = u8Tn; data_req->LchId.bySAPI = sapi; data_req->LchId.bySubChannelNb = subCh; @@ -590,7 +603,7 @@ static int ph_tch_req(struct gsm_bts_trx *trx, struct msgb *msg, l1if_fill_msg_hdr(&empty_frame_req->Header, nmsg, fl1h, cOCTVC1_MSG_TYPE_COMMAND, cOCTVC1_GSM_MSG_TRX_REQUEST_LOGICAL_CHANNEL_EMPTY_FRAME_CID); - empty_frame_req->TrxId.byTrxId = trx->nr; + empty_frame_req->TrxId.byTrxId = pinst->u.octphy.trx_id; empty_frame_req->LchId.byTimeslotNb = u8Tn; empty_frame_req->LchId.bySAPI = sapi; empty_frame_req->LchId.bySubChannelNb = subCh; @@ -686,32 +699,37 @@ int bts_model_l1sap_down(struct gsm_bts_trx *trx, struct osmo_phsap_prim *l1sap) return rc; } +int bts_model_phy_link_open(struct phy_link *plink) +{ + if (plink->u.octphy.hdl) + l1if_close(plink->u.octphy.hdl); + + phy_link_state_set(plink, PHY_LINK_CONNECTING); + + plink->u.octphy.hdl = l1if_open(plink); + if (!plink->u.octphy.hdl) { + phy_link_state_set(plink, PHY_LINK_SHUTDOWN); + return -1; + } + + /* do we need to iterate over the list of instances and do some + * instance-specific initialization? */ + + /* FIXME: delay this until we know the PHY responds */ + phy_link_state_set(plink, PHY_LINK_CONNECTED); + + return 0; +} + int bts_model_init(struct gsm_bts *bts) { struct gsm_bts_role_bts *btsb; - struct octphy_hdl *fl1h; LOGP(DL1C, LOGL_NOTICE, "model_init()\n"); btsb = bts_role_bts(bts); btsb->support.ciphers = CIPHER_A5(1) | CIPHER_A5(2) | CIPHER_A5(3); - fl1h = talloc_zero(bts, struct octphy_hdl); - if (!fl1h) - return -ENOMEM; - - INIT_LLIST_HEAD(&fl1h->wlc_list); - INIT_LLIST_HEAD(&fl1h->wlc_postponed); - fl1h->priv = bts->c0; - bts->c0->role_bts.l1h = fl1h; - /* FIXME: what is the nominal transmit power of the PHY/board? */ - bts->c0->nominal_power = 15; - - /* configure some reasonable defaults, to be overridden by VTY */ - fl1h->config.rf_port_index = 0; - fl1h->config.rx_gain_db = 70; - fl1h->config.tx_atten_db = 0; - bts_model_vty_init(bts); return 0; @@ -750,23 +768,15 @@ static void dump_meas_res(int ll, tOCTVC1_GSM_MEASUREMENT_INFO * m) static int handle_mph_time_ind(struct octphy_hdl *fl1, uint8_t trx_id, uint32_t fn) { - struct gsm_bts_trx *trx = fl1->priv; - struct gsm_bts *bts = trx->bts; + struct gsm_bts_trx *trx = trx_by_l1h(fl1, trx_id); struct osmo_phsap_prim l1sap; /* increment the primitive count for the alive timer */ fl1->alive_prim_cnt++; /* ignore every time indication, except for c0 */ - if (trx != bts->c0) - return 0; - - if (trx_id != trx->nr) { - LOGP(DL1C, LOGL_FATAL, - "TRX id %d from response does not match the L1 context trx %d\n", - trx_id, trx->nr); + if (trx != trx->bts->c0) return 0; - } memset(&l1sap, 0, sizeof(l1sap)); osmo_prim_init(&l1sap.oph, SAP_GSM_PH, PRIM_MPH_INFO, @@ -783,7 +793,7 @@ static int handle_ph_readytosend_ind(struct octphy_hdl *fl1, tOCTVC1_GSM_MSG_TRX_LOGICAL_CHANNEL_READY_TO_SEND_INDICATION_EVT *evt, struct msgb *l1p_msg) { - struct gsm_bts_trx *trx = fl1->priv; + struct gsm_bts_trx *trx = trx_by_l1h(fl1, evt->TrxId.byTrxId); struct gsm_bts *bts = trx->bts; struct osmo_phsap_prim *l1sap; struct gsm_time g_time; @@ -908,7 +918,7 @@ static int handle_ph_data_ind(struct octphy_hdl *fl1, tOCTVC1_GSM_MSG_TRX_LOGICAL_CHANNEL_DATA_INDICATION_EVT *data_ind, struct msgb *l1p_msg) { - struct gsm_bts_trx *trx = fl1->priv; + struct gsm_bts_trx *trx = trx_by_l1h(fl1, data_ind->TrxId.byTrxId); uint8_t chan_nr, link_id; struct osmo_phsap_prim *l1sap; uint32_t fn; @@ -992,7 +1002,7 @@ static int handle_ph_rach_ind(struct octphy_hdl *fl1, tOCTVC1_GSM_MSG_TRX_LOGICAL_CHANNEL_RACH_INDICATION_EVT *ra_ind, struct msgb *l1p_msg) { - struct gsm_bts_trx *trx = fl1->priv; + struct gsm_bts_trx *trx = trx_by_l1h(fl1, ra_ind->TrxId.byTrxId); struct gsm_bts *bts = trx->bts; struct gsm_bts_role_bts *btsb = bts_role_bts(bts); struct gsm_lchan *lchan; @@ -1131,7 +1141,7 @@ static int rx_octvc1_resp(struct msgb *msg, uint32_t msg_id, uint32_t trans_id) if (wlc->cb) { /* call-back function must take msgb * ownership. */ - rc = wlc->cb(fl1h->priv, msg, wlc->cb_data); + rc = wlc->cb(fl1h, msg, wlc->cb_data); } else { rc = 0; msgb_free(msg); @@ -1534,15 +1544,35 @@ static int octphy_write_cb(struct osmo_fd *fd, struct msgb *msg) return rc; } -int l1if_open(struct octphy_hdl *fl1h) +struct octphy_hdl *l1if_open(struct phy_link *plink) { + struct octphy_hdl *fl1h; struct ifreq ifr; int sfd, rc; - char *phy_dev = fl1h->netdev_name; + char *phy_dev = plink->u.octphy.netdev_name; + + fl1h = talloc_zero(plink, struct octphy_hdl); + if (!fl1h) + return NULL; + + INIT_LLIST_HEAD(&fl1h->wlc_list); + INIT_LLIST_HEAD(&fl1h->wlc_postponed); + fl1h->phy_link = plink; +#if 0 + bts->c0->role_bts.l1h = fl1h; + /* FIXME: what is the nominal transmit power of the PHY/board? */ + bts->c0->nominal_power = 15; + + /* configure some reasonable defaults, to be overridden by VTY */ + fl1h->config.rf_port_index = 0; + fl1h->config.rx_gain_db = 70; + fl1h->config.tx_atten_db = 0; +#endif if (!phy_dev) { LOGP(DL1C, LOGL_ERROR, "You have to specify a phy-netdev\n"); - return -EINVAL; + talloc_free(fl1h); + return NULL; } LOGP(DL1C, LOGL_NOTICE, "Opening L1 interface for OctPHY (%s)\n", @@ -1553,7 +1583,8 @@ int l1if_open(struct octphy_hdl *fl1h) if (sfd < 0) { LOGP(DL1C, LOGL_FATAL, "Error opening PHY socket: %s\n", strerror(errno)); - return -EIO; + talloc_free(fl1h); + return NULL; } /* resolve the string device name to an ifindex */ @@ -1564,18 +1595,21 @@ int l1if_open(struct octphy_hdl *fl1h) LOGP(DL1C, LOGL_FATAL, "Error using network device %s: %s\n", phy_dev, strerror(errno)); close(sfd); - return -EIO; + talloc_free(fl1h); + return NULL; } fl1h->session_id = rand(); - /* set fl1h->phy_addr, which we use as sendto() destionation */ + /* set fl1h->phy_addr, which we use as sendto() destination */ fl1h->phy_addr.sll_family = AF_PACKET; fl1h->phy_addr.sll_protocol = htons(cOCTPKT_HDR_ETHERTYPE); fl1h->phy_addr.sll_ifindex = ifr.ifr_ifindex; fl1h->phy_addr.sll_hatype = ARPHRD_ETHER; - fl1h->phy_addr.sll_halen = 6; - /* sll_addr is filled by bts_model_vty code */ + fl1h->phy_addr.sll_halen = ETH_ALEN; + /* plink->phy_addr.sll_addr is filled by bts_model_vty code */ + memcpy(fl1h->phy_addr.sll_addr, plink->u.octphy.phy_addr.sll_addr, + ETH_ALEN); /* Write queue / osmo_fd registration */ osmo_wqueue_init(&fl1h->phy_wq, 10); @@ -1588,10 +1622,11 @@ int l1if_open(struct octphy_hdl *fl1h) rc = osmo_fd_register(&fl1h->phy_wq.bfd); if (rc < 0) { close(sfd); - return -EIO; + talloc_free(fl1h); + return NULL; } - return 0; + return fl1h; } int l1if_close(struct octphy_hdl *fl1h) diff --git a/src/osmo-bts-octphy/l1_if.h b/src/osmo-bts-octphy/l1_if.h index 4277865..2dee178 100644 --- a/src/osmo-bts-octphy/l1_if.h +++ b/src/osmo-bts-octphy/l1_if.h @@ -13,16 +13,16 @@ #include <osmocom/gsm/protocol/gsm_04_08.h> #include <osmo-bts/gsm_data.h> +#include <osmo-bts/phy_link.h> #include <octphy/octvc1/gsm/octvc1_gsm_api.h> struct octphy_hdl { + /* MAC address of the PHY */ + struct sockaddr_ll phy_addr; + /* packet socket to talk with PHY */ struct osmo_wqueue phy_wq; - /* MAC address of th PHY */ - struct sockaddr_ll phy_addr; - /* Network device name */ - char *netdev_name; /* address parameters of the PHY */ uint32_t session_id; @@ -33,12 +33,6 @@ struct octphy_hdl { uint32_t clkmgr_state; struct { - uint32_t rf_port_index; - uint32_t rx_gain_db; - uint32_t tx_atten_db; - } config; - - struct { struct { char *name; char *description; @@ -72,8 +66,8 @@ struct octphy_hdl { struct llist_head wlc_postponed; int wlc_postponed_len; - /* private pointer, points back to TRX */ - void *priv; + /* back pointer to the PHY link */ + struct phy_link *phy_link; struct osmo_timer_list alive_timer; uint32_t alive_prim_cnt; @@ -82,15 +76,10 @@ struct octphy_hdl { int opened; }; -static inline struct octphy_hdl *trx_octphy_hdl(struct gsm_bts_trx *trx) -{ - return trx->role_bts.l1h; -} - void l1if_fill_msg_hdr(tOCTVC1_MSG_HEADER *mh, struct msgb *msg, struct octphy_hdl *fl1h, uint32_t msg_type, uint32_t api_cmd); -typedef int l1if_compl_cb(struct gsm_bts_trx *trx, struct msgb *l1_msg, void *data); +typedef int l1if_compl_cb(struct octphy_hdl *fl1, struct msgb *l1_msg, void *data); /* send a request primitive to the L1 and schedule completion call-back */ int l1if_req_compl(struct octphy_hdl *fl1h, struct msgb *msg, @@ -100,19 +89,21 @@ int l1if_req_compl(struct octphy_hdl *fl1h, struct msgb *msg, struct gsm_lchan *get_lchan_by_lchid(struct gsm_bts_trx *trx, tOCTVC1_GSM_LOGICAL_CHANNEL_ID *lch_id); -int l1if_open(struct octphy_hdl *fl1h); +struct octphy_hdl *l1if_open(struct phy_link *plink); int l1if_close(struct octphy_hdl *hdl); int l1if_trx_open(struct gsm_bts_trx *trx); int l1if_trx_close_all(struct gsm_bts *bts); int l1if_enable_events(struct gsm_bts_trx *trx); -int l1if_activate_rf(struct octphy_hdl *fl1h, int on); +int l1if_activate_rf(struct gsm_bts_trx *trx, int on); int l1if_tch_rx(struct gsm_bts_trx *trx, uint8_t chan_nr, tOCTVC1_GSM_MSG_TRX_LOGICAL_CHANNEL_DATA_INDICATION_EVT * data_ind); +struct gsm_bts_trx *trx_by_l1h(struct octphy_hdl *fl1h, unsigned int trx_id); + struct msgb *l1p_msgb_alloc(void); /* tch.c */ diff --git a/src/osmo-bts-octphy/l1_oml.c b/src/osmo-bts-octphy/l1_oml.c index 318c384..627b238 100644 --- a/src/osmo-bts-octphy/l1_oml.c +++ b/src/osmo-bts-octphy/l1_oml.c @@ -348,10 +348,11 @@ static void sapi_clear_queue(struct llist_head *queue) } } -static int lchan_act_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *data) +static int lchan_act_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_GSM_MSG_TRX_ACTIVATE_LOGICAL_CHANNEL_RSP *ar = (tOCTVC1_GSM_MSG_TRX_ACTIVATE_LOGICAL_CHANNEL_RSP *) resp->l2h; + struct gsm_bts_trx *trx; struct gsm_lchan *lchan; uint8_t sapi; uint8_t direction; @@ -361,7 +362,7 @@ static int lchan_act_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void * * release it before returning */ mOCTVC1_GSM_MSG_TRX_ACTIVATE_LOGICAL_CHANNEL_RSP_SWAP(ar); - OSMO_ASSERT(ar->TrxId.byTrxId == trx->nr); + trx = trx_by_l1h(fl1, ar->TrxId.byTrxId); lchan = get_lchan_by_lchid(trx, &ar->LchId); sapi = ar->LchId.bySAPI; @@ -411,7 +412,8 @@ err: static int mph_send_activate_req(struct gsm_lchan *lchan, struct sapi_cmd *cmd) { - struct octphy_hdl *fl1h = trx_octphy_hdl(lchan->ts->trx); + struct phy_instance *pinst = trx_phy_instance(lchan->ts->trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct msgb *msg = l1p_msgb_alloc(); tOCTVC1_GSM_MSG_TRX_ACTIVATE_LOGICAL_CHANNEL_CMD *lac; @@ -420,7 +422,7 @@ static int mph_send_activate_req(struct gsm_lchan *lchan, struct sapi_cmd *cmd) l1if_fill_msg_hdr(&lac->Header, msg, fl1h, cOCTVC1_MSG_TYPE_COMMAND, cOCTVC1_GSM_MSG_TRX_ACTIVATE_LOGICAL_CHANNEL_CID); - lac->TrxId.byTrxId = lchan->ts->trx->nr; + lac->TrxId.byTrxId = pinst->u.octphy.trx_id; lac->LchId.byTimeslotNb = lchan->ts->nr; lac->LchId.bySubChannelNb = lchan_to_GsmL1_SubCh_t(lchan); lac->LchId.bySAPI = cmd->sapi; @@ -451,10 +453,11 @@ static tOCTVC1_GSM_CIPHERING_ID_ENUM rsl2l1_ciph[] = { [4] = cOCTVC1_GSM_CIPHERING_ID_ENUM_A5_3 }; -static int set_ciph_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *data) +static int set_ciph_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_GSM_MSG_TRX_MODIFY_PHYSICAL_CHANNEL_CIPHERING_RSP *pcr = (tOCTVC1_GSM_MSG_TRX_MODIFY_PHYSICAL_CHANNEL_CIPHERING_RSP *) resp->l2h; + struct gsm_bts_trx *trx; struct gsm_bts_trx_ts *ts; struct gsm_lchan *lchan; @@ -470,6 +473,7 @@ static int set_ciph_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *d exit(-1); } + trx = trx_by_l1h(fl1, pcr->TrxId.byTrxId); OSMO_ASSERT(pcr->TrxId.byTrxId == trx->nr); ts = &trx->ts[pcr->PchId.byTimeslotNb]; /* for some strange reason the response does not tell which @@ -508,8 +512,8 @@ err: static int mph_send_config_ciphering(struct gsm_lchan *lchan, struct sapi_cmd *cmd) { - struct gsm_bts_trx *trx = lchan->ts->trx; - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(lchan->ts->trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct msgb *msg = l1p_msgb_alloc(); tOCTVC1_GSM_MSG_TRX_MODIFY_PHYSICAL_CHANNEL_CIPHERING_CMD *pcc; @@ -518,6 +522,7 @@ static int mph_send_config_ciphering(struct gsm_lchan *lchan, struct sapi_cmd *c l1if_fill_msg_hdr(&pcc->Header, msg, fl1h, cOCTVC1_MSG_TYPE_COMMAND, cOCTVC1_GSM_MSG_TRX_MODIFY_PHYSICAL_CHANNEL_CIPHERING_CID); + pcc->TrxId.byTrxId = pinst->u.octphy.trx_id; pcc->PchId.byTimeslotNb = lchan->ts->nr; pcc->ulSubchannelNb = lchan_to_GsmL1_SubCh_t(lchan); pcc->ulDirection = cmd->dir; @@ -627,7 +632,8 @@ static int check_sapi_release(struct gsm_lchan *lchan, int sapi, int dir) static int lchan_deactivate_sapis(struct gsm_lchan *lchan) { - struct octphy_hdl *fl1h = trx_octphy_hdl(lchan->ts->trx); + struct phy_instance *pinst = trx_phy_instance(lchan->ts->trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; const struct lchan_sapis *s4l = &sapis_for_lchan[lchan->type]; int i, res; @@ -654,10 +660,11 @@ static int lchan_deactivate_sapis(struct gsm_lchan *lchan) return res; } -static int lchan_deact_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *data) +static int lchan_deact_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_GSM_MSG_TRX_DEACTIVATE_LOGICAL_CHANNEL_RSP *ldr = (tOCTVC1_GSM_MSG_TRX_DEACTIVATE_LOGICAL_CHANNEL_RSP *) resp->l2h; + struct gsm_bts_trx *trx; struct gsm_lchan *lchan; struct sapi_cmd *cmd; uint8_t status; @@ -666,7 +673,7 @@ static int lchan_deact_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void * release it before returning */ mOCTVC1_GSM_MSG_TRX_DEACTIVATE_LOGICAL_CHANNEL_RSP_SWAP(ldr); - OSMO_ASSERT(ldr->TrxId.byTrxId == trx->nr); + trx = trx_by_l1h(fl1, ldr->TrxId.byTrxId); lchan = get_lchan_by_lchid(trx, &ldr->LchId); @@ -725,7 +732,8 @@ err: static int mph_send_deactivate_req(struct gsm_lchan *lchan, struct sapi_cmd *cmd) { - struct octphy_hdl *fl1h = trx_octphy_hdl(lchan->ts->trx); + struct phy_instance *pinst = trx_phy_instance(lchan->ts->trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct msgb *msg = l1p_msgb_alloc(); tOCTVC1_GSM_MSG_TRX_DEACTIVATE_LOGICAL_CHANNEL_CMD *ldc; @@ -734,6 +742,7 @@ static int mph_send_deactivate_req(struct gsm_lchan *lchan, struct sapi_cmd *cmd l1if_fill_msg_hdr(&ldc->Header, msg, fl1h,cOCTVC1_MSG_TYPE_COMMAND, cOCTVC1_GSM_MSG_TRX_DEACTIVATE_LOGICAL_CHANNEL_CID); + ldc->TrxId.byTrxId = pinst->u.octphy.trx_id; ldc->LchId.byTimeslotNb = lchan->ts->nr; ldc->LchId.bySubChannelNb = lchan_to_GsmL1_SubCh_t(lchan); ldc->LchId.byDirection = cmd->dir; @@ -1031,7 +1040,8 @@ static void enqueue_sapi_act_cmd(struct gsm_lchan *lchan, int sapi, int dir) int lchan_activate(struct gsm_lchan *lchan) { - struct octphy_hdl *fl1h = trx_octphy_hdl(lchan->ts->trx); + struct phy_instance *pinst = trx_phy_instance(lchan->ts->trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; const struct lchan_sapis *s4l = &sapis_for_lchan[lchan->type]; unsigned int i; @@ -1069,7 +1079,7 @@ int l1if_rsl_chan_act(struct gsm_lchan *lchan) return 0; } -static int enable_events_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *data) +static int enable_events_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_MAIN_MSG_API_SYSTEM_MODIFY_SESSION_EVT_RSP *mser = (tOCTVC1_MAIN_MSG_API_SYSTEM_MODIFY_SESSION_EVT_RSP *) resp->l2h; @@ -1088,7 +1098,8 @@ static int enable_events_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, vo int l1if_enable_events(struct gsm_bts_trx *trx) { - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct msgb *msg = l1p_msgb_alloc(); tOCTVC1_MAIN_MSG_API_SYSTEM_MODIFY_SESSION_EVT_CMD *mse; @@ -1112,9 +1123,8 @@ int l1if_enable_events(struct gsm_bts_trx *trx) dst = talloc_strdup(ctx, (const char *) src); \ } while (0) -static int app_info_sys_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *data) +static int app_info_sys_compl_cb(struct octphy_hdl *fl1h, struct msgb *resp, void *data) { - struct octphy_hdl *fl1h = resp->dst; tOCTVC1_MAIN_MSG_APPLICATION_INFO_SYSTEM_RSP *aisr = (tOCTVC1_MAIN_MSG_APPLICATION_INFO_SYSTEM_RSP *) resp->l2h; @@ -1136,7 +1146,8 @@ static int app_info_sys_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, voi int l1if_check_app_sys_version(struct gsm_bts_trx *trx) { - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct msgb *msg = l1p_msgb_alloc(); tOCTVC1_MAIN_MSG_APPLICATION_INFO_SYSTEM_CMD *ais; @@ -1152,9 +1163,8 @@ int l1if_check_app_sys_version(struct gsm_bts_trx *trx) return l1if_req_compl(fl1h, msg, app_info_sys_compl_cb, 0); } -static int app_info_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *data) +static int app_info_compl_cb(struct octphy_hdl *fl1h, struct msgb *resp, void *data) { - struct octphy_hdl *fl1h = resp->dst; tOCTVC1_MAIN_MSG_APPLICATION_INFO_RSP *air = (tOCTVC1_MAIN_MSG_APPLICATION_INFO_RSP *) resp->l2h; @@ -1178,7 +1188,8 @@ static int app_info_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *d int l1if_check_app_version(struct gsm_bts_trx *trx) { - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct msgb *msg = l1p_msgb_alloc(); tOCTVC1_MAIN_MSG_APPLICATION_INFO_CMD *ai; @@ -1194,8 +1205,11 @@ int l1if_check_app_version(struct gsm_bts_trx *trx) } /* call-back once the TRX_OPEN_CID response arrives */ -static int trx_open_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *data) +static int trx_open_compl_cb(struct octphy_hdl *fl1h, struct msgb *resp, void *data) { + struct gsm_bts_trx *trx; + struct phy_instance *pinst; + tOCTVC1_GSM_MSG_TRX_OPEN_RSP *or = (tOCTVC1_GSM_MSG_TRX_OPEN_RSP *) resp->l2h; @@ -1203,8 +1217,8 @@ static int trx_open_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *d * release it before returning */ mOCTVC1_GSM_MSG_TRX_OPEN_RSP_SWAP(or); - - OSMO_ASSERT(or->TrxId.byTrxId == trx->nr); + trx = trx_by_l1h(fl1h, or->TrxId.byTrxId); + pinst = trx_phy_instance(trx); LOGP(DL1C, LOGL_INFO, "TRX-OPEN.resp(trx=%u) = %s\n", trx->nr, octvc1_rc2string(or->Header.ulReturnCode)); @@ -1221,7 +1235,6 @@ static int trx_open_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *d opstart_compl(&trx->mo); - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); octphy_hw_get_pcb_info(fl1h); octphy_hw_get_rf_port_info(fl1h, 0); octphy_hw_get_rf_ant_rx_config(fl1h, 0, 0); @@ -1238,22 +1251,24 @@ static int trx_open_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *d int l1if_trx_open(struct gsm_bts_trx *trx) { /* putting it all together */ - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct phy_link *plink = pinst->phy_link; + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct msgb *msg = l1p_msgb_alloc(); tOCTVC1_GSM_MSG_TRX_OPEN_CMD *oc; oc = (tOCTVC1_GSM_MSG_TRX_OPEN_CMD *) msgb_put(msg, sizeof(*oc)); l1if_fill_msg_hdr(&oc->Header, msg, fl1h, cOCTVC1_MSG_TYPE_COMMAND, cOCTVC1_GSM_MSG_TRX_OPEN_CID); - oc->ulRfPortIndex = fl1h->config.rf_port_index; - oc->TrxId.byTrxId = trx->nr; + oc->ulRfPortIndex = plink->u.octphy.rf_port_index; + oc->TrxId.byTrxId = pinst->u.octphy.trx_id; oc->Config.ulBand = osmocom_to_octphy_band(trx->bts->band, trx->arfcn); oc->Config.usArfcn = trx->arfcn; oc->Config.usTsc = trx->bts->bsic & 0x7; oc->Config.usBcchArfcn = trx->bts->c0->arfcn; - oc->RfConfig.ulRxGainDb = fl1h->config.rx_gain_db; + oc->RfConfig.ulRxGainDb = plink->u.octphy.rx_gain_db; /* FIXME: compute this based on nominal transmit power, etc. */ - oc->RfConfig.ulTxAttndB = fl1h->config.tx_atten_db; + oc->RfConfig.ulTxAttndB = plink->u.octphy.tx_atten_db; LOGP(DL1C, LOGL_INFO, "Tx TRX-OPEN.req(trx=%u, rf_port=%u, arfcn=%u, " "tsc=%u, rx_gain=%u, tx_atten=%u)\n", @@ -1266,7 +1281,7 @@ int l1if_trx_open(struct gsm_bts_trx *trx) return l1if_req_compl(fl1h, msg, trx_open_compl_cb, NULL); } -static int trx_close_all_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *data) +static int trx_close_all_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_GSM_MSG_TRX_CLOSE_ALL_RSP *car = (tOCTVC1_GSM_MSG_TRX_CLOSE_ALL_RSP *) resp->l2h; @@ -1283,7 +1298,9 @@ static int trx_close_all_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *da int l1if_trx_close_all(struct gsm_bts *bts) { - struct octphy_hdl *fl1h = trx_octphy_hdl(bts->c0); +#warning "Truly iterate over all TRX in this BTS" + struct phy_instance *pinst = trx_phy_instance(bts->c0); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct msgb *msg = l1p_msgb_alloc(); tOCTVC1_GSM_MSG_TRX_CLOSE_ALL_CMD *cac; @@ -1325,11 +1342,12 @@ static int trx_init(struct gsm_bts_trx *trx) * PHYSICAL CHANNE ACTIVATION ***********************************************************************/ -static int pchan_act_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *data) +static int pchan_act_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_GSM_MSG_TRX_ACTIVATE_PHYSICAL_CHANNEL_RSP *ar = (tOCTVC1_GSM_MSG_TRX_ACTIVATE_PHYSICAL_CHANNEL_RSP *) resp->l2h; uint8_t ts_nr; + struct gsm_bts_trx *trx; struct gsm_bts_trx_ts *ts; struct gsm_abis_mo *mo; @@ -1337,9 +1355,8 @@ static int pchan_act_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void * * release it before returning */ mOCTVC1_GSM_MSG_TRX_ACTIVATE_PHYSICAL_CHANNEL_RSP_SWAP(ar); + trx = trx_by_l1h(fl1, ar->TrxId.byTrxId); ts_nr = ar->PchId.byTimeslotNb; - - OSMO_ASSERT(ar->TrxId.byTrxId == trx->nr); OSMO_ASSERT(ts_nr <= ARRAY_SIZE(trx->ts)); ts = &trx->ts[ts_nr]; @@ -1367,7 +1384,8 @@ static int pchan_act_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void * static int ts_connect(struct gsm_bts_trx_ts *ts) { - struct octphy_hdl *fl1h = trx_octphy_hdl(ts->trx); + struct phy_instance *pinst = trx_phy_instance(ts->trx); + struct octphy_hdl *fl1h = pinst->phy_link->u.octphy.hdl; struct msgb *msg = l1p_msgb_alloc(); tOCTVC1_GSM_MSG_TRX_ACTIVATE_PHYSICAL_CHANNEL_CMD *oc = (tOCTVC1_GSM_MSG_TRX_ACTIVATE_PHYSICAL_CHANNEL_CMD *) oc; @@ -1376,7 +1394,7 @@ static int ts_connect(struct gsm_bts_trx_ts *ts) l1if_fill_msg_hdr(&oc->Header, msg, fl1h, cOCTVC1_MSG_TYPE_COMMAND, cOCTVC1_GSM_MSG_TRX_ACTIVATE_PHYSICAL_CHANNEL_CID); - oc->TrxId.byTrxId = ts->trx->nr; + oc->TrxId.byTrxId = pinst->u.octphy.trx_id; oc->PchId.byTimeslotNb = ts->nr; oc->ulChannelType = pchan_to_logChComb[ts->pchan]; @@ -1430,8 +1448,7 @@ int bts_model_oml_estab(struct gsm_bts *bts) int i; for (i = 0; i < bts->num_trx; i++) { struct gsm_bts_trx *trx = gsm_bts_trx_num(bts, i); - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); - l1if_activate_rf(fl1h, 1); + l1if_activate_rf(trx, 1); } return 0; } @@ -1447,8 +1464,7 @@ int bts_model_chg_adm_state(struct gsm_bts *bts, struct gsm_abis_mo *mo, int bts_model_trx_deact_rf(struct gsm_bts_trx *trx) { - struct octphy_hdl *fl1 = trx_octphy_hdl(trx); - return l1if_activate_rf(fl1, 0); + return l1if_activate_rf(trx, 0); } int bts_model_trx_close(struct gsm_bts_trx *trx) diff --git a/src/osmo-bts-octphy/main.c b/src/osmo-bts-octphy/main.c index 1f516e4..d237e42 100644 --- a/src/osmo-bts-octphy/main.c +++ b/src/osmo-bts-octphy/main.c @@ -56,6 +56,7 @@ static struct gsm_bts *bts; int bts_model_print_help() { + return 0; } int bts_model_handle_options(int argc, char **argv) diff --git a/src/osmo-bts-octphy/octphy_hw_api.c b/src/osmo-bts-octphy/octphy_hw_api.c index 5291742..ec7c4be 100644 --- a/src/osmo-bts-octphy/octphy_hw_api.c +++ b/src/osmo-bts-octphy/octphy_hw_api.c @@ -35,7 +35,7 @@ #include <octphy/octvc1/hw/octvc1_hw_api_swap.h> /* Chapter 12.1 */ -static int get_pcb_info_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, void *data) +static int get_pcb_info_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_HW_MSG_PCB_INFO_RSP *pir = (tOCTVC1_HW_MSG_PCB_INFO_RSP *) resp->l2h; @@ -69,7 +69,7 @@ int octphy_hw_get_pcb_info(struct octphy_hdl *fl1h) } /* Chapter 12.9 */ -static int rf_port_info_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, +static int rf_port_info_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_HW_MSG_RF_PORT_INFO_RSP *pir = @@ -114,7 +114,7 @@ static const struct value_string radio_std_vals[] = { }; /* Chapter 12.10 */ -static int rf_port_stats_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, +static int rf_port_stats_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_HW_MSG_RF_PORT_STATS_RSP *psr = @@ -167,7 +167,7 @@ static const struct value_string rx_gain_mode_vals[] = { }; /* Chapter 12.13 */ -static int rf_ant_rx_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, +static int rf_ant_rx_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_HW_MSG_RF_PORT_INFO_ANTENNA_RX_CONFIG_RSP *arc = @@ -209,7 +209,7 @@ int octphy_hw_get_rf_ant_rx_config(struct octphy_hdl *fl1h, uint32_t port_idx, } /* Chapter 12.14 */ -static int rf_ant_tx_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, +static int rf_ant_tx_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_HW_MSG_RF_PORT_INFO_ANTENNA_TX_CONFIG_RSP *atc = @@ -292,7 +292,7 @@ static const struct value_string clocksync_state_vals[] = { }; /* Chapter 12.15 */ -static int get_clock_sync_compl_cb(struct gsm_bts_trx *trx, struct msgb *resp, +static int get_clock_sync_compl_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_HW_MSG_CLOCK_SYNC_MGR_INFO_RSP *cir = @@ -326,7 +326,7 @@ int octphy_hw_get_clock_sync_info(struct octphy_hdl *fl1h) } /* Chapter 12.16 */ -static int get_clock_sync_stats_cb(struct gsm_bts_trx *trx, struct msgb *resp, +static int get_clock_sync_stats_cb(struct octphy_hdl *fl1, struct msgb *resp, void *data) { tOCTVC1_HW_MSG_CLOCK_SYNC_MGR_STATS_RSP *csr = diff --git a/src/osmo-bts-octphy/octphy_vty.c b/src/osmo-bts-octphy/octphy_vty.c index dbc903a..e2000e9 100644 --- a/src/osmo-bts-octphy/octphy_vty.c +++ b/src/osmo-bts-octphy/octphy_vty.c @@ -38,6 +38,7 @@ #include <osmocom/vty/misc.h> #include <osmo-bts/gsm_data.h> +#include <osmo-bts/phy_link.h> #include <osmo-bts/logging.h> #include <osmo-bts/vty.h> @@ -51,149 +52,189 @@ SHOW_STR \ TRX_STR +#define OCT_STR "OCTPHY Um interface\n" + static struct gsm_bts *vty_bts; /* configuration */ -DEFUN(cfg_bts_phy_hwaddr, cfg_bts_phy_hwaddr_cmd, - "phy-hw-addr HWADDR", - "Configure the hardware addess of the OCTPHY\n" +DEFUN(cfg_phy_hwaddr, cfg_phy_hwaddr_cmd, + "octphy hw-addr HWADDR", + OCT_STR "Configure the hardware addess of the OCTPHY\n" "hardware address in aa:bb:cc:dd:ee:ff format\n") { - struct gsm_bts *bts = vty->index; - struct gsm_bts_trx *trx = bts->c0; - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_link *plink = vty->index; int rc; - rc = osmo_macaddr_parse(fl1h->phy_addr.sll_addr, argv[0]); + if (plink->state != PHY_LINK_SHUTDOWN) { + vty_out(vty, "Can only reconfigure a PHY link that is down%s", + VTY_NEWLINE); + return CMD_WARNING; + } + + rc = osmo_macaddr_parse(plink->u.octphy.phy_addr.sll_addr, argv[0]); if (rc < 0) return CMD_WARNING; return CMD_SUCCESS; } -DEFUN(cfg_bts_phy_netdev, cfg_bts_phy_netdev_cmd, - "phy-netdev NAME", - "Configure the hardware device towards the OCTPHY\n" +DEFUN(cfg_phy_netdev, cfg_phy_netdev_cmd, + "octphy net-device NAME", + OCT_STR "Configure the hardware device towards the OCTPHY\n" "Ethernet device name\n") { - struct gsm_bts *bts = vty->index; - struct gsm_bts_trx *trx = bts->c0; - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_link *plink = vty->index; - if (fl1h->netdev_name) - talloc_free(fl1h->netdev_name); - fl1h->netdev_name = talloc_strdup(fl1h, argv[0]); + if (plink->state != PHY_LINK_SHUTDOWN) { + vty_out(vty, "Can only reconfigure a PHY link that is down%s", + VTY_NEWLINE); + return CMD_WARNING; + } + + if (plink->u.octphy.netdev_name) + talloc_free(plink->u.octphy.netdev_name); + plink->u.octphy.netdev_name = talloc_strdup(plink, argv[0]); return CMD_SUCCESS; } -DEFUN(cfg_trx_rf_port_idx, cfg_trx_rf_port_idx_cmd, - "rf-port-index <0-255>", - "Configure the RF Port for this TRX\n" +DEFUN(cfg_phy_rf_port_idx, cfg_phy_rf_port_idx_cmd, + "octphy rf-port-index <0-255>", + OCT_STR "Configure the RF Port for this TRX\n" "RF Port Index\n") { - struct gsm_bts_trx *trx = vty->index; - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_link *plink = vty->index; - fl1h->config.rf_port_index = atoi(argv[0]); + if (plink->state != PHY_LINK_SHUTDOWN) { + vty_out(vty, "Can only reconfigure a PHY link that is down%s", + VTY_NEWLINE); + return CMD_WARNING; + } + + plink->u.octphy.rf_port_index = atoi(argv[0]); return CMD_SUCCESS; } -DEFUN(cfg_trx_rx_gain_db, cfg_trx_rx_gain_db_cmd, - "rx-gain <0-73>", - "Configure the Rx Gain in dB\n" +DEFUN(cfg_phy_rx_gain_db, cfg_phy_rx_gain_db_cmd, + "octphy rx-gain <0-73>", + OCT_STR "Configure the Rx Gain in dB\n" "Rx gain in dB\n") { - struct gsm_bts_trx *trx = vty->index; - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_link *plink = vty->index; + + if (plink->state != PHY_LINK_SHUTDOWN) { + vty_out(vty, "Can only reconfigure a PHY link that is down%s", + VTY_NEWLINE); + return CMD_WARNING; + } - fl1h->config.rx_gain_db = atoi(argv[0]); + plink->u.octphy.rx_gain_db = atoi(argv[0]); return CMD_SUCCESS; } -DEFUN(cfg_trx_tx_atten_db, cfg_trx_tx_atten_db_cmd, - "tx-attenuation <0-359>", - "Configure the Tx Attenuation in quarter-dB\n" +DEFUN(cfg_phy_tx_atten_db, cfg_phy_tx_atten_db_cmd, + "octphy tx-attenuation <0-359>", + OCT_STR "Configure the Tx Attenuation in quarter-dB\n" "Tx attenuation in quarter-dB\n") { - struct gsm_bts_trx *trx = vty->index; - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); + struct phy_link *plink = vty->index; + + if (plink->state != PHY_LINK_SHUTDOWN) { + vty_out(vty, "Can only reconfigure a PHY link that is down%s", + VTY_NEWLINE); + return CMD_WARNING; + } - fl1h->config.tx_atten_db = atoi(argv[0]); + plink->u.octphy.tx_atten_db = atoi(argv[0]); return CMD_SUCCESS; } -DEFUN(get_rf_port_stats, get_rf_port_stats_cmd, - "get-rf-port-stats <0-1>", - "Obtain statistics for the RF Port\n" +DEFUN(show_rf_port_stats, show_rf_port_stats_cmd, + "show phy <0-255> rf-port-stats <0-1>", + "Show statistics for the RF Port\n" "RF Port Number\n") { - struct octphy_hdl *fl1h = trx_octphy_hdl(vty_bts->c0); + int phy_nr = atoi(argv[0]); + struct phy_link *plink = phy_link_by_num(phy_nr); - octphy_hw_get_rf_port_stats(fl1h, atoi(argv[0])); + octphy_hw_get_rf_port_stats(plink->u.octphy.hdl, atoi(argv[1])); + + /* FIXME */ + vty_out(vty, "Please check the log file for the response%s", + VTY_NEWLINE); return CMD_SUCCESS; } -DEFUN(get_clk_sync_stats, get_clk_sync_stats_cmd, - "get-clk-sync-stats", +DEFUN(show_clk_sync_stats, show_clk_sync_stats_cmd, + "show phy <0-255> clk-sync-stats", "Obtain statistics for the Clock Sync Manager\n") { - struct octphy_hdl *fl1h = trx_octphy_hdl(vty_bts->c0); + int phy_nr = atoi(argv[0]); + struct phy_link *plink = phy_link_by_num(phy_nr); + + octphy_hw_get_clock_sync_stats(plink->u.octphy.hdl); - octphy_hw_get_clock_sync_stats(fl1h); + /* FIXME */ + vty_out(vty, "Please check the log file for the response%s", + VTY_NEWLINE); return CMD_SUCCESS; } +void bts_model_config_write_phy(struct vty *vty, struct phy_link *plink) +{ + if (plink->u.octphy.netdev_name) + vty_out(vty, " netdev %s%s", plink->u.octphy.netdev_name, + VTY_NEWLINE); + + vty_out(vty, " hw-addr %02x:%02x:%02x:%02x:%02x:%02x%s", + plink->u.octphy.phy_addr.sll_addr[0], + plink->u.octphy.phy_addr.sll_addr[1], + plink->u.octphy.phy_addr.sll_addr[2], + plink->u.octphy.phy_addr.sll_addr[3], + plink->u.octphy.phy_addr.sll_addr[4], + plink->u.octphy.phy_addr.sll_addr[5], + VTY_NEWLINE); + vty_out(vty, " rx-gain %u%s", plink->u.octphy.rx_gain_db, + VTY_NEWLINE); + vty_out(vty, " tx-attenuation %u%s", plink->u.octphy.tx_atten_db, + VTY_NEWLINE); + vty_out(vty, " rf-port-index %u%s", plink->u.octphy.rf_port_index, + VTY_NEWLINE); +} + void bts_model_config_write_bts(struct vty *vty, struct gsm_bts *bts) { struct gsm_bts_role_bts *btsb = bts_role_bts(bts); - struct octphy_hdl *fl1h = trx_octphy_hdl(bts->c0); - - if (fl1h->netdev_name) - vty_out(vty, " phy-netdev %s%s", fl1h->netdev_name, - VTY_NEWLINE); if (btsb->auto_band) vty_out(vty, " auto-band%s", VTY_NEWLINE); - vty_out(vty, " phy-hw-addr %02x:%02x:%02x:%02x:%02x:%02x%s", - fl1h->phy_addr.sll_addr[0], fl1h->phy_addr.sll_addr[1], - fl1h->phy_addr.sll_addr[2], fl1h->phy_addr.sll_addr[3], - fl1h->phy_addr.sll_addr[4], fl1h->phy_addr.sll_addr[5], - VTY_NEWLINE); } void bts_model_config_write_trx(struct vty *vty, struct gsm_bts_trx *trx) { - struct octphy_hdl *fl1h = trx_octphy_hdl(trx); - - vty_out(vty, " rx-gain %u%s", fl1h->config.rx_gain_db, - VTY_NEWLINE); - vty_out(vty, " tx-attenuation %u%s", fl1h->config.tx_atten_db, - VTY_NEWLINE); } DEFUN(show_sys_info, show_sys_info_cmd, - "show trx <0-255> system-information", + "show phy <0-255> system-information", SHOW_TRX_STR "Display information about system\n") { - int trx_nr = atoi(argv[0]); - struct gsm_bts_trx *trx = gsm_bts_trx_num(vty_bts, trx_nr); + int phy_nr = atoi(argv[0]); + struct phy_link *plink = phy_link_by_num(phy_nr); struct octphy_hdl *fl1h; - int i; - if (!trx) { - vty_out(vty, "Cannot find TRX number %u%s", - trx_nr, VTY_NEWLINE); + if (!plink) { + vty_out(vty, "Cannot find PHY number %u%s", + phy_nr, VTY_NEWLINE); return CMD_WARNING; } - fl1h = trx_octphy_hdl(trx); + fl1h = plink->u.octphy.hdl; vty_out(vty, "System Platform: '%s', Version: '%s'%s", fl1h->info.system.platform, fl1h->info.system.version, @@ -210,15 +251,14 @@ int bts_model_vty_init(struct gsm_bts *bts) { vty_bts = bts; - install_element(BTS_NODE, &cfg_bts_phy_hwaddr_cmd); - install_element(BTS_NODE, &cfg_bts_phy_netdev_cmd); + install_element(PHY_NODE, &cfg_phy_hwaddr_cmd); + install_element(PHY_NODE, &cfg_phy_netdev_cmd); + install_element(PHY_NODE, &cfg_phy_rf_port_idx_cmd); + install_element(PHY_NODE, &cfg_phy_rx_gain_db_cmd); + install_element(PHY_NODE, &cfg_phy_tx_atten_db_cmd); - install_element(TRX_NODE, &cfg_trx_rf_port_idx_cmd); - install_element(TRX_NODE, &cfg_trx_rx_gain_db_cmd); - install_element(TRX_NODE, &cfg_trx_tx_atten_db_cmd); - - install_element_ve(&get_rf_port_stats_cmd); - install_element_ve(&get_clk_sync_stats_cmd); + install_element_ve(&show_rf_port_stats_cmd); + install_element_ve(&show_clk_sync_stats_cmd); install_element_ve(&show_sys_info_cmd); return 0; @@ -226,13 +266,5 @@ int bts_model_vty_init(struct gsm_bts *bts) int bts_model_ctrl_cmds_install(struct gsm_bts *bts) { - /* FIXME: really ugly hack: We can only initialize the L1 intrface - * after reading the config file, and this is the only call-back after - * vty_read_config_fioe() at this point. Will be cleaned up with the - * phy interface generalization patches coming up soon as part of the - * multi-trx work */ - struct octphy_hdl *fl1h = bts->c0->role_bts.l1h; - l1if_open(fl1h); - return 0; } diff --git a/src/osmo-bts-trx/l1_if.c b/src/osmo-bts-trx/l1_if.c index edd4b7b..befaffd 100644 --- a/src/osmo-bts-trx/l1_if.c +++ b/src/osmo-bts-trx/l1_if.c @@ -59,7 +59,7 @@ static const uint8_t transceiver_chan_types[_GSM_PCHAN_MAX] = { * create/destroy trx l1 instance */ -struct trx_l1h *l1if_open(struct gsm_bts_trx *trx) +struct trx_l1h *l1if_open(struct phy_instance *pinst) { struct trx_l1h *l1h; int rc; @@ -67,11 +67,9 @@ struct trx_l1h *l1if_open(struct gsm_bts_trx *trx) l1h = talloc_zero(tall_bts_ctx, struct trx_l1h); if (!l1h) return NULL; - l1h->trx = trx; - l1h->l1s.trx = trx; - trx->role_bts.l1h = l1h; + l1h->phy_inst = pinst; - trx_sched_init(&l1h->l1s); + trx_sched_init(&l1h->l1s, pinst->trx); rc = trx_if_open(l1h); if (rc < 0) { @@ -83,7 +81,6 @@ struct trx_l1h *l1if_open(struct gsm_bts_trx *trx) err: l1if_close(l1h); - trx->role_bts.l1h = NULL; return NULL; } @@ -100,7 +97,8 @@ void l1if_reset(struct trx_l1h *l1h) static void check_transceiver_availability_trx(struct trx_l1h *l1h, int avail) { - struct gsm_bts_trx *trx = l1h->trx; + struct phy_instance *pinst = l1h->phy_inst; + struct gsm_bts_trx *trx = pinst->trx; uint8_t tn; /* HACK, we should change state when we receive first clock from @@ -132,10 +130,10 @@ static void check_transceiver_availability_trx(struct trx_l1h *l1h, int avail) int check_transceiver_availability(struct gsm_bts *bts, int avail) { struct gsm_bts_trx *trx; - struct trx_l1h *l1h; llist_for_each_entry(trx, &bts->trx_list, list) { - l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; check_transceiver_availability_trx(l1h, avail); } return 0; @@ -147,6 +145,7 @@ int check_transceiver_availability(struct gsm_bts *bts, int avail) */ int l1if_provision_transceiver_trx(struct trx_l1h *l1h) { + struct phy_link *plink = l1h->phy_inst->phy_link; uint8_t tn; if (!transceiver_available) @@ -177,18 +176,23 @@ int l1if_provision_transceiver_trx(struct trx_l1h *l1h) } /* after power on */ - if (l1h->config.rxgain_valid && !l1h->config.rxgain_sent) { - trx_if_cmd_setrxgain(l1h, l1h->config.rxgain); - l1h->config.rxgain_sent = 1; - } - if (l1h->config.power_valid && !l1h->config.power_sent) { - trx_if_cmd_setpower(l1h, l1h->config.power); - l1h->config.power_sent = 1; + if (l1h->phy_inst->num == 0) { + if (plink->u.osmotrx.rxgain_valid && + !plink->u.osmotrx.rxgain_sent) { + trx_if_cmd_setrxgain(l1h, plink->u.osmotrx.rxgain); + plink->u.osmotrx.rxgain_sent = 1; + } + if (plink->u.osmotrx.power_valid && + !plink->u.osmotrx.power_sent) { + trx_if_cmd_setpower(l1h, plink->u.osmotrx.power); + plink->u.osmotrx.power_sent = 1; + } } if (l1h->config.maxdly_valid && !l1h->config.maxdly_sent) { trx_if_cmd_setmaxdly(l1h, l1h->config.maxdly); l1h->config.maxdly_sent = 1; } + for (tn = 0; tn < TRX_NR_TS; tn++) { if (l1h->config.slottype_valid[tn] && !l1h->config.slottype_sent[tn]) { @@ -203,8 +207,10 @@ int l1if_provision_transceiver_trx(struct trx_l1h *l1h) if (!l1h->config.poweron && !l1h->config.poweron_sent) { trx_if_cmd_poweroff(l1h); l1h->config.poweron_sent = 1; - l1h->config.rxgain_sent = 0; - l1h->config.power_sent = 0; + if (l1h->phy_inst->num == 0) { + plink->u.osmotrx.rxgain_sent = 0; + plink->u.osmotrx.power_sent = 0; + } l1h->config.maxdly_sent = 0; for (tn = 0; tn < TRX_NR_TS; tn++) l1h->config.slottype_sent[tn] = 0; @@ -216,17 +222,20 @@ int l1if_provision_transceiver_trx(struct trx_l1h *l1h) int l1if_provision_transceiver(struct gsm_bts *bts) { struct gsm_bts_trx *trx; - struct trx_l1h *l1h; uint8_t tn; llist_for_each_entry(trx, &bts->trx_list, list) { - l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct phy_link *plink = pinst->phy_link; + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; l1h->config.arfcn_sent = 0; l1h->config.tsc_sent = 0; l1h->config.bsic_sent = 0; l1h->config.poweron_sent = 0; - l1h->config.rxgain_sent = 0; - l1h->config.power_sent = 0; + if (l1h->phy_inst->num == 0) { + plink->u.osmotrx.rxgain_sent = 0; + plink->u.osmotrx.power_sent = 0; + } l1h->config.maxdly_sent = 0; for (tn = 0; tn < TRX_NR_TS; tn++) l1h->config.slottype_sent[tn] = 0; @@ -242,7 +251,8 @@ int l1if_provision_transceiver(struct gsm_bts *bts) /* initialize the layer1 */ static int trx_init(struct gsm_bts_trx *trx) { - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; /* power on transceiver, if not already */ if (!l1h->config.poweron) { @@ -264,7 +274,8 @@ static int trx_init(struct gsm_bts_trx *trx) /* deactivate transceiver */ int bts_model_trx_close(struct gsm_bts_trx *trx) { - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; enum gsm_phys_chan_config pchan = trx->ts[0].pchan; /* close all logical channels and reset timeslots */ @@ -308,7 +319,6 @@ int bts_model_adjst_ms_pwr(struct gsm_lchan *lchan) static uint8_t trx_set_bts(struct gsm_bts *bts, struct tlv_parsed *new_attr) { struct gsm_bts_trx *trx; - struct trx_l1h *l1h; uint8_t bsic = bts->bsic; struct gsm_bts_role_bts *btsb = bts_role_bts(bts); @@ -318,7 +328,8 @@ static uint8_t trx_set_bts(struct gsm_bts *bts, struct tlv_parsed *new_attr) } llist_for_each_entry(trx, &bts->trx_list, list) { - l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; if (l1h->config.bsic != bsic || !l1h->config.bsic_valid) { l1h->config.bsic = bsic; l1h->config.bsic_valid = 1; @@ -335,7 +346,9 @@ static uint8_t trx_set_bts(struct gsm_bts *bts, struct tlv_parsed *new_attr) /* set trx attributes */ static uint8_t trx_set_trx(struct gsm_bts_trx *trx) { - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct phy_link *plink = pinst->phy_link; + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; uint16_t arfcn = trx->arfcn; if (l1h->config.arfcn != arfcn || !l1h->config.arfcn_valid) { @@ -345,10 +358,10 @@ static uint8_t trx_set_trx(struct gsm_bts_trx *trx) l1if_provision_transceiver_trx(l1h); } - if (l1h->config.power_oml) { - l1h->config.power = trx->max_power_red; - l1h->config.power_valid = 1; - l1h->config.power_sent = 0; + if (plink->u.osmotrx.power_oml && pinst->num == 0) { + plink->u.osmotrx.power = trx->max_power_red; + plink->u.osmotrx.power_valid = 1; + plink->u.osmotrx.power_sent = 0; l1if_provision_transceiver_trx(l1h); } @@ -358,7 +371,8 @@ static uint8_t trx_set_trx(struct gsm_bts_trx *trx) /* set ts attributes */ static uint8_t trx_set_ts(struct gsm_bts_trx_ts *ts) { - struct trx_l1h *l1h = trx_l1h_hdl(ts->trx); + struct phy_instance *pinst = trx_phy_instance(ts->trx); + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; uint8_t tn = ts->nr; uint16_t tsc = ts->tsc; enum gsm_phys_chan_config pchan = ts->pchan; @@ -439,6 +453,7 @@ static int l1if_set_ciphering(struct trx_l1h *l1h, struct gsm_lchan *lchan, static int mph_info_chan_confirm(struct trx_l1h *l1h, uint8_t chan_nr, enum osmo_mph_info_type type, uint8_t cause) { + struct phy_instance *pinst = l1h->phy_inst; struct osmo_phsap_prim l1sap; memset(&l1sap, 0, sizeof(l1sap)); @@ -448,7 +463,7 @@ static int mph_info_chan_confirm(struct trx_l1h *l1h, uint8_t chan_nr, l1sap.u.info.u.act_cnf.chan_nr = chan_nr; l1sap.u.info.u.act_cnf.cause = cause; - return l1sap_up(l1h->trx, &l1sap); + return l1sap_up(pinst->trx, &l1sap); } int l1if_mph_time_ind(struct gsm_bts *bts, uint32_t fn) @@ -503,7 +518,8 @@ int l1if_process_meas_res(struct gsm_bts_trx *trx, uint8_t tn, uint32_t fn, uint /* primitive from common part */ int bts_model_l1sap_down(struct gsm_bts_trx *trx, struct osmo_phsap_prim *l1sap) { - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; struct msgb *msg = l1sap->oph.msg; uint8_t chan_nr; uint8_t tn, ss; diff --git a/src/osmo-bts-trx/l1_if.h b/src/osmo-bts-trx/l1_if.h index f492687..187303c 100644 --- a/src/osmo-bts-trx/l1_if.h +++ b/src/osmo-bts-trx/l1_if.h @@ -2,6 +2,7 @@ #define L1_IF_H_TRX #include <osmo-bts/scheduler.h> +#include <osmo-bts/phy_link.h> struct trx_config { uint8_t poweron; /* poweron(1) or poweroff(0) */ @@ -19,15 +20,6 @@ struct trx_config { uint8_t bsic; int bsic_sent; - int rxgain_valid; - int rxgain; - int rxgain_sent; - - int power_valid; - int power; - int power_oml; - int power_sent; - int maxdly_valid; int maxdly; int maxdly_sent; @@ -42,7 +34,8 @@ struct trx_config { struct trx_l1h { struct llist_head trx_ctrl_list; - struct gsm_bts_trx *trx; + //struct gsm_bts_trx *trx; + struct phy_instance *phy_inst; struct osmo_fd trx_ofd_ctrl; struct osmo_timer_list trx_ctrl_timer; @@ -55,7 +48,7 @@ struct trx_l1h { struct l1sched_trx l1s; }; -struct trx_l1h *l1if_open(struct gsm_bts_trx *trx); +struct trx_l1h *l1if_open(struct phy_instance *pinst); void l1if_close(struct trx_l1h *l1h); void l1if_reset(struct trx_l1h *l1h); int check_transceiver_availability(struct gsm_bts *bts, int avail); @@ -69,7 +62,8 @@ int l1if_process_meas_res(struct gsm_bts_trx *trx, uint8_t tn, uint32_t fn, uint static inline struct l1sched_trx *trx_l1sched_hdl(struct gsm_bts_trx *trx) { - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = trx->role_bts.l1h; + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; return &l1h->l1s; } diff --git a/src/osmo-bts-trx/main.c b/src/osmo-bts-trx/main.c index aa6987c..40cbcac 100644 --- a/src/osmo-bts-trx/main.c +++ b/src/osmo-bts-trx/main.c @@ -45,6 +45,7 @@ #include <osmocom/core/bits.h> #include <osmo-bts/gsm_data.h> +#include <osmo-bts/phy_link.h> #include <osmo-bts/logging.h> #include <osmo-bts/abis.h> #include <osmo-bts/bts.h> @@ -58,42 +59,13 @@ #include "l1_if.h" #include "trx_if.h" -int bts_model_init(struct gsm_bts *bts) -{ - void *l1h; - struct gsm_bts_trx *trx; - struct gsm_bts_role_bts *btsb = bts_role_bts(bts); - - btsb->support.ciphers = CIPHER_A5(1) | CIPHER_A5(2); - if (!settsc_enabled && !setbsic_enabled) - settsc_enabled = setbsic_enabled = 1; - - llist_for_each_entry(trx, &bts->trx_list, list) { - l1h = l1if_open(trx); - if (!l1h) { - LOGP(DL1C, LOGL_FATAL, "Cannot open L1 Interface\n"); - goto error; - } - +#if 0 trx->role_bts.l1h = l1h; trx->nominal_power = 23; l1if_reset(l1h); - } - - bts_model_vty_init(bts); +#endif - return 0; - -error: - llist_for_each_entry(trx, &bts->trx_list, list) { - l1h = trx->role_bts.l1h; - if (l1h) - l1if_close(l1h); - } - - return -EIO; -} /* dummy, since no direct dsp support */ uint32_t trx_get_hlayer1(struct gsm_bts_trx *trx) @@ -103,10 +75,6 @@ uint32_t trx_get_hlayer1(struct gsm_bts_trx *trx) void bts_model_print_help() { - printf( - " -I --local-trx-ip Local IP for transceiver to connect (default=%s)\n" - , transceiver_ip - ); } int bts_model_handle_options(int argc, char **argv) @@ -116,21 +84,16 @@ int bts_model_handle_options(int argc, char **argv) while (1) { int option_idx = 0, c; static const struct option long_options[] = { - /* specific to this hardware */ - { "local-trx-ip", 1, 0, 'I' }, { 0, 0, 0, 0 } }; - c = getopt_long(argc, argv, "I:", + c = getopt_long(argc, argv, "", long_options, &option_idx); if (c == -1) break; switch (c) { - case 'I': - transceiver_ip = strdup(optarg); - break; default: num_errors++; break; @@ -140,6 +103,17 @@ int bts_model_handle_options(int argc, char **argv) return num_errors; } +int bts_model_init(struct gsm_bts *bts) +{ + struct gsm_bts_role_bts *btsb = bts_role_bts(bts); + + btsb->support.ciphers = CIPHER_A5(1) | CIPHER_A5(2); + + bts_model_vty_init(bts); + + return 0; +} + int main(int argc, char **argv) { return bts_main(argc, argv); diff --git a/src/osmo-bts-trx/scheduler_trx.c b/src/osmo-bts-trx/scheduler_trx.c index ac9212b..87d21ff 100644 --- a/src/osmo-bts-trx/scheduler_trx.c +++ b/src/osmo-bts-trx/scheduler_trx.c @@ -1268,8 +1268,9 @@ static int trx_sched_fn(struct gsm_bts *bts, uint32_t fn) /* process every TRX */ llist_for_each_entry(trx, &bts->trx_list, list) { - struct trx_l1h *l1h = trx_l1h_hdl(trx); - struct l1sched_trx *l1t = trx_l1sched_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; + struct l1sched_trx *l1t = &l1h->l1s; /* we don't schedule, if power is off */ if (!trx_if_powered(l1h)) @@ -1323,10 +1324,12 @@ no_clock: /* flush pending messages of transceiver */ /* close all logical channels and reset timeslots */ llist_for_each_entry(trx, &bts->trx_list, list) { - trx_if_flush(trx_l1h_hdl(trx)); - trx_sched_reset(trx_l1sched_hdl(trx)); + struct phy_instance *pinst = trx_phy_instance(trx); + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; + trx_if_flush(l1h); + trx_sched_reset(&l1h->l1s); if (trx->nr == 0) - trx_if_cmd_poweroff(trx_l1h_hdl(trx)); + trx_if_cmd_poweroff(l1h); } /* tell BSC */ @@ -1461,7 +1464,8 @@ new_clock: void _sched_act_rach_det(struct l1sched_trx *l1t, uint8_t tn, uint8_t ss, int activate) { - struct trx_l1h *l1h = trx_l1h_hdl(l1t->trx); + struct phy_instance *pinst = trx_phy_instance(l1t->trx); + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; if (activate) trx_if_cmd_handover(l1h, tn, ss); diff --git a/src/osmo-bts-trx/trx_if.c b/src/osmo-bts-trx/trx_if.c index dbe6f68..6743d0b 100644 --- a/src/osmo-bts-trx/trx_if.c +++ b/src/osmo-bts-trx/trx_if.c @@ -2,6 +2,7 @@ * OpenBTS TRX interface handling * * Copyright (C) 2013 Andreas Eversberg <jolly(a)eversberg.eu> + * Copyright (C) 2016 Harald Welte <laforge(a)gnumonks.org> * * All Rights Reserved * @@ -34,6 +35,7 @@ #include <osmocom/core/talloc.h> #include <osmocom/core/bits.h> +#include <osmo-bts/phy_link.h> #include <osmo-bts/logging.h> #include <osmo-bts/bts.h> #include <osmo-bts/scheduler.h> @@ -45,7 +47,6 @@ //#define TOA_RSSI_DEBUG int transceiver_available = 0; -const char *transceiver_ip = "127.0.0.1"; int settsc_enabled = 0; int setbsic_enabled = 0; @@ -56,8 +57,9 @@ int setbsic_enabled = 0; static uint16_t base_port_local = 5800; /* open socket */ -static int trx_udp_open(void *priv, struct osmo_fd *ofd, uint16_t port, - int (*cb)(struct osmo_fd *fd, unsigned int what)) +static int trx_udp_open(void *priv, struct osmo_fd *ofd, const char *host, + uint16_t port_local, uint16_t port_remote, + int (*cb)(struct osmo_fd *fd, unsigned int what)) { struct sockaddr_storage sas; struct sockaddr *sa = (struct sockaddr *)&sas; @@ -71,8 +73,8 @@ static int trx_udp_open(void *priv, struct osmo_fd *ofd, uint16_t port, ofd->data = priv; /* Listen / Binds */ - rc = osmo_sock_init_ofd(ofd, AF_UNSPEC, SOCK_DGRAM, 0, transceiver_ip, - port, OSMO_SOCK_F_BIND); + rc = osmo_sock_init_ofd(ofd, AF_UNSPEC, SOCK_DGRAM, 0, host, + port_local, OSMO_SOCK_F_BIND); if (rc < 0) return rc; @@ -84,10 +86,10 @@ static int trx_udp_open(void *priv, struct osmo_fd *ofd, uint16_t port, if (sa->sa_family == AF_INET) { struct sockaddr_in *sin = (struct sockaddr_in *)sa; - sin->sin_port = htons(ntohs(sin->sin_port) - 100); + sin->sin_port = htons(port_remote); } else if (sa->sa_family == AF_INET6) { struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa; - sin6->sin6_port = htons(ntohs(sin6->sin6_port) - 100); + sin6->sin6_port = htons(port_remote); } else { return -EINVAL; } @@ -96,7 +98,6 @@ static int trx_udp_open(void *priv, struct osmo_fd *ofd, uint16_t port, if (rc) return rc; - return 0; } @@ -115,13 +116,11 @@ static void trx_udp_close(struct osmo_fd *ofd) * clock */ -static struct osmo_fd trx_ofd_clk; - - /* get clock from clock socket */ static int trx_clk_read_cb(struct osmo_fd *ofd, unsigned int what) { - struct trx_l1h *l1h = ofd->data; + struct phy_link *plink = ofd->data; + struct phy_instance *pinst = phy_instance_by_num(plink, 0); char buf[1500]; int len; uint32_t fn; @@ -146,7 +145,7 @@ static int trx_clk_read_cb(struct osmo_fd *ofd, unsigned int what) "correctly, correcting to fn=%u\n", fn); } - trx_sched_clock(l1h->trx->bts, fn); + trx_sched_clock(pinst->trx->bts, fn); return 0; } @@ -168,8 +167,8 @@ static void trx_ctrl_send(struct trx_l1h *l1h) return; tcm = llist_entry(l1h->trx_ctrl_list.next, struct trx_ctrl_msg, list); - LOGP(DTRX, LOGL_DEBUG, "Sending control '%s' to trx=%u\n", tcm->cmd, - l1h->trx->nr); + LOGP(DTRX, LOGL_DEBUG, "Sending control '%s' to %s\n", tcm->cmd, + phy_instance_name(l1h->phy_inst)); /* send command */ send(l1h->trx_ofd_ctrl.fd, tcm->cmd, strlen(tcm->cmd)+1, 0); @@ -184,8 +183,8 @@ static void trx_ctrl_timer_cb(void *data) { struct trx_l1h *l1h = data; - LOGP(DTRX, LOGL_NOTICE, "No response from transceiver for trx=%d\n", - l1h->trx->nr); + LOGP(DTRX, LOGL_NOTICE, "No response from transceiver for %s\n", + phy_instance_name(l1h->phy_inst)); trx_ctrl_send(l1h); } @@ -232,7 +231,8 @@ static int trx_ctrl_cmd(struct trx_l1h *l1h, int critical, const char *cmd, int trx_if_cmd_poweroff(struct trx_l1h *l1h) { - if (l1h->trx->nr == 0) + struct phy_instance *pinst = l1h->phy_inst; + if (pinst->num == 0) return trx_ctrl_cmd(l1h, 1, "POWEROFF", ""); else return 0; @@ -240,7 +240,8 @@ int trx_if_cmd_poweroff(struct trx_l1h *l1h) int trx_if_cmd_poweron(struct trx_l1h *l1h) { - if (l1h->trx->nr == 0) + struct phy_instance *pinst = l1h->phy_inst; + if (pinst->num == 0) return trx_ctrl_cmd(l1h, 1, "POWERON", ""); else return 0; @@ -324,6 +325,7 @@ int trx_if_cmd_nohandover(struct trx_l1h *l1h, uint8_t tn, uint8_t ss) static int trx_ctrl_read_cb(struct osmo_fd *ofd, unsigned int what) { struct trx_l1h *l1h = ofd->data; + struct phy_instance *pinst = l1h->phy_inst; char buf[1500]; int len, resp; @@ -374,11 +376,12 @@ static int trx_ctrl_read_cb(struct osmo_fd *ofd, unsigned int what) sscanf(p + 1, "%d", &resp); if (resp) { LOGP(DTRX, (tcm->critical) ? LOGL_FATAL : LOGL_NOTICE, - "transceiver (trx=%d) rejected TRX command " - "with response: '%s'\n", l1h->trx->nr, buf); + "transceiver (%s) rejected TRX command " + "with response: '%s'\n", + phy_instance_name(pinst), buf); rsp_error: if (tcm->critical) { - bts_shutdown(l1h->trx->bts, "SIGINT"); + bts_shutdown(pinst->trx->bts, "SIGINT"); /* keep tcm list, so process is stopped */ return -EIO; } @@ -493,11 +496,67 @@ int trx_if_data(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, uint8_t pwr, * open/close */ +int bts_model_phy_link_open(struct phy_link *plink) +{ + struct phy_instance *pinst; + int rc; + + phy_link_state_set(plink, PHY_LINK_CONNECTING); + + /* open the shared/common clock socket */ + rc = trx_udp_open(plink, &plink->u.osmotrx.trx_ofd_clk, + plink->u.osmotrx.transceiver_ip, + plink->u.osmotrx.base_port_local, + plink->u.osmotrx.base_port_remote, + trx_clk_read_cb); + if (rc < 0) { + phy_link_state_set(plink, PHY_LINK_SHUTDOWN); + return -1; + } + + /* open the individual instances with their ctrl+data sockets */ + llist_for_each_entry(pinst, &plink->instances, list) { + pinst->u.osmotrx.hdl = l1if_open(pinst); + if (!pinst->u.osmotrx.hdl) + goto cleanup; + } + + return 0; + +cleanup: + phy_link_state_set(plink, PHY_LINK_SHUTDOWN); + llist_for_each_entry(pinst, &plink->instances, list) { + if (pinst->u.osmotrx.hdl) { + trx_if_close(pinst->u.osmotrx.hdl); + pinst->u.osmotrx.hdl = NULL; + } + } + trx_udp_close(&plink->u.osmotrx.trx_ofd_clk); + return -1; +} + +static uint16_t compute_port(struct phy_instance *pinst, int remote, int is_data) +{ + struct phy_link *plink = pinst->phy_link; + uint16_t inc = 1; + + if (is_data) + inc = 2; + + if (remote) + return plink->u.osmotrx.base_port_remote + (pinst->num << 1) + inc; + else + return plink->u.osmotrx.base_port_local + (pinst->num << 1) + inc; +} + int trx_if_open(struct trx_l1h *l1h) { + struct phy_instance *pinst = l1h->phy_inst; + struct phy_link *plink = pinst->phy_link; int rc; - LOGP(DTRX, LOGL_NOTICE, "Open transceiver for trx=%u\n", l1h->trx->nr); + LOGP(DTRX, LOGL_NOTICE, "Open transceiver for %s\n", + phy_instance_name(pinst)); /* initialize ctrl queue */ INIT_LLIST_HEAD(&l1h->trx_ctrl_list); @@ -511,19 +570,24 @@ int trx_if_open(struct trx_l1h *l1h) LOGP(DTRX, LOGL_NOTICE, "Waiting for transceiver send clock\n"); } rc = trx_udp_open(l1h, &l1h->trx_ofd_ctrl, - base_port_local + (l1h->trx->nr << 1) + 1, trx_ctrl_read_cb); + plink->u.osmotrx.transceiver_ip, + compute_port(pinst, 0, 0), + compute_port(pinst, 1, 0), trx_ctrl_read_cb); if (rc < 0) goto err; rc = trx_udp_open(l1h, &l1h->trx_ofd_data, - base_port_local + (l1h->trx->nr << 1) + 2, trx_data_read_cb); + plink->u.osmotrx.transceiver_ip, + compute_port(pinst, 0, 1), + compute_port(pinst, 1, 1), trx_data_read_cb); if (rc < 0) goto err; /* enable all slots */ l1h->config.slotmask = 0xff; - if (l1h->trx->nr == 0) - trx_if_cmd_poweroff(l1h); + /* FIXME: why was this only for TRX0 ? */ + //if (l1h->trx->nr == 0) + trx_if_cmd_poweroff(l1h); return 0; @@ -548,13 +612,13 @@ void trx_if_flush(struct trx_l1h *l1h) void trx_if_close(struct trx_l1h *l1h) { - LOGP(DTRX, LOGL_NOTICE, "Close transceiver for trx=%u\n", l1h->trx->nr); + struct phy_instance *pinst = l1h->phy_inst; + LOGP(DTRX, LOGL_NOTICE, "Close transceiver for %s\n", + phy_instance_name(pinst)); trx_if_flush(l1h); /* close sockets */ - if (l1h->trx->nr == 0) - trx_udp_close(&trx_ofd_clk); trx_udp_close(&l1h->trx_ofd_ctrl); trx_udp_close(&l1h->trx_ofd_data); } diff --git a/src/osmo-bts-trx/trx_if.h b/src/osmo-bts-trx/trx_if.h index 3862e2b..1ea0da9 100644 --- a/src/osmo-bts-trx/trx_if.h +++ b/src/osmo-bts-trx/trx_if.h @@ -6,6 +6,7 @@ extern const char *transceiver_ip; extern int settsc_enabled; extern int setbsic_enabled; +struct trx_l1h; struct trx_ctrl_msg { struct llist_head list; diff --git a/src/osmo-bts-trx/trx_vty.c b/src/osmo-bts-trx/trx_vty.c index a4a7909..b273e94 100644 --- a/src/osmo-bts-trx/trx_vty.c +++ b/src/osmo-bts-trx/trx_vty.c @@ -45,6 +45,8 @@ #include "trx_if.h" #include "loops.h" +#define OSMOTRX_STR "OsmoTRX Transceiver configuration\n" + static struct gsm_bts *vty_bts; DEFUN(show_transceiver, show_transceiver_cmd, "show transceiver", @@ -53,7 +55,6 @@ DEFUN(show_transceiver, show_transceiver_cmd, "show transceiver", struct gsm_bts *bts = vty_bts; struct gsm_bts_trx *trx; struct trx_l1h *l1h; - uint8_t tn; if (!transceiver_available) { vty_out(vty, "transceiver is not connected%s", VTY_NEWLINE); @@ -63,7 +64,8 @@ DEFUN(show_transceiver, show_transceiver_cmd, "show transceiver", } llist_for_each_entry(trx, &bts->trx_list, list) { - l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = trx_phy_instance(trx); + l1h = pinst->u.osmotrx.hdl; vty_out(vty, "TRX %d%s", trx->nr, VTY_NEWLINE); vty_out(vty, " %s%s", (l1h->config.poweron) ? "poweron":"poweroff", @@ -85,56 +87,70 @@ DEFUN(show_transceiver, show_transceiver_cmd, "show transceiver", VTY_NEWLINE); else vty_out(vty, " bisc : undefined%s", VTY_NEWLINE); - if (l1h->config.rxgain_valid) - vty_out(vty, " rxgain : %d%s", l1h->config.rxgain, + } + + return CMD_SUCCESS; +} + + +static void show_phy_inst_single(struct vty *vty, struct phy_instance *pinst) +{ + uint8_t tn; + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; + + vty_out(vty, "PHY Instance %s%s", + phy_instance_name(pinst), VTY_NEWLINE); + if (l1h->config.maxdly_valid) + vty_out(vty, " maxdly : %d%s", l1h->config.maxdly, + VTY_NEWLINE); + else + vty_out(vty, " maxdly : undefined%s", VTY_NEWLINE); + for (tn = 0; tn < TRX_NR_TS; tn++) { + if (!((1 << tn) & l1h->config.slotmask)) + vty_out(vty, " slot #%d: unsupported%s", tn, VTY_NEWLINE); - else - vty_out(vty, " rxgain : undefined%s", VTY_NEWLINE); - if (l1h->config.power_valid) - vty_out(vty, " power : %d%s", l1h->config.power, + else if (l1h->config.slottype_valid[tn]) + vty_out(vty, " slot #%d: type %d%s", tn, + l1h->config.slottype[tn], VTY_NEWLINE); else - vty_out(vty, " power : undefined%s", VTY_NEWLINE); - if (l1h->config.maxdly_valid) - vty_out(vty, " maxdly : %d%s", l1h->config.maxdly, + vty_out(vty, " slot #%d: undefined%s", tn, VTY_NEWLINE); - else - vty_out(vty, " maxdly : undefined%s", VTY_NEWLINE); - for (tn = 0; tn < TRX_NR_TS; tn++) { - if (!((1 << tn) & l1h->config.slotmask)) - vty_out(vty, " slot #%d: unsupported%s", tn, - VTY_NEWLINE); - else if (l1h->config.slottype_valid[tn]) - vty_out(vty, " slot #%d: type %d%s", tn, - l1h->config.slottype[tn], - VTY_NEWLINE); - else - vty_out(vty, " slot #%d: undefined%s", tn, - VTY_NEWLINE); - } } - - return CMD_SUCCESS; } -DEFUN(cfg_bts_fn_advance, cfg_bts_fn_advance_cmd, - "fn-advance <0-30>", - "Set the number of frames to be transmitted to transceiver in advance " - "of current FN\n" - "Advance in frames\n") +static void show_phy_single(struct vty *vty, struct phy_link *plink) { - trx_clock_advance = atoi(argv[0]); + struct phy_instance *pinst; - return CMD_SUCCESS; + vty_out(vty, "PHY %u%s", plink->num, VTY_NEWLINE); + + if (plink->u.osmotrx.rxgain_valid) + vty_out(vty, " rx-gain : %d dB%s", + plink->u.osmotrx.rxgain, VTY_NEWLINE); + else + vty_out(vty, " rx-gain : undefined%s", VTY_NEWLINE); + if (plink->u.osmotrx.power_valid) + vty_out(vty, " tx-attenuation : %d dB%s", + plink->u.osmotrx.power, VTY_NEWLINE); + else + vty_out(vty, " tx-attenuation : undefined%s", VTY_NEWLINE); + + llist_for_each_entry(pinst, &plink->instances, list) + show_phy_inst_single(vty, pinst); } -DEFUN(cfg_bts_rts_advance, cfg_bts_rts_advance_cmd, - "rts-advance <0-30>", - "Set the number of frames to be requested (PCU) in advance of current " - "FN. Do not change this, unless you have a good reason!\n" - "Advance in frames\n") +DEFUN(show_phy, show_phy_cmd, "show phy", + SHOW_STR "Display information about the available PHYs") { - trx_rts_advance = atoi(argv[0]); + int i; + + for (i = 0; i < 255; i++) { + struct phy_link *plink = phy_link_by_num(i); + if (!plink) + break; + show_phy_single(vty, plink); + } return CMD_SUCCESS; } @@ -220,63 +236,14 @@ DEFUN(cfg_bts_no_setbsic, cfg_bts_no_setbsic_cmd, return CMD_SUCCESS; } -DEFUN(cfg_trx_rxgain, cfg_trx_rxgain_cmd, - "rxgain <0-50>", - "Set the receiver gain in dB\n" - "Gain in dB\n") -{ - struct gsm_bts_trx *trx = vty->index; - struct trx_l1h *l1h = trx_l1h_hdl(trx); - - l1h->config.rxgain = atoi(argv[0]); - l1h->config.rxgain_valid = 1; - l1h->config.rxgain_sent = 0; - l1if_provision_transceiver_trx(l1h); - - return CMD_SUCCESS; -} - -DEFUN(cfg_trx_power, cfg_trx_power_cmd, - "power <0-50>", - "Set the transmitter power dampening\n" - "Power dampening in dB\n") -{ - struct gsm_bts_trx *trx = vty->index; - struct trx_l1h *l1h = trx_l1h_hdl(trx); - - l1h->config.power = atoi(argv[0]); - l1h->config.power_oml = 0; - l1h->config.power_valid = 1; - l1h->config.power_sent = 0; - l1if_provision_transceiver_trx(l1h); - - return CMD_SUCCESS; -} - -DEFUN(cfg_trx_poweroml_, cfg_trx_power_oml_cmd, - "power oml", - "Set the transmitter power dampening\n" - "Given by NM_ATT_RF_MAXPOWR_R (max power reduction) via OML\n") -{ - struct gsm_bts_trx *trx = vty->index; - struct trx_l1h *l1h = trx_l1h_hdl(trx); - - l1h->config.power = trx->max_power_red; - l1h->config.power_oml = 1; - l1h->config.power_valid = 1; - l1h->config.power_sent = 0; - l1if_provision_transceiver_trx(l1h); - return CMD_SUCCESS; -} - -DEFUN(cfg_trx_maxdly, cfg_trx_maxdly_cmd, - "maxdly <0-31>", +DEFUN(cfg_phyinst_maxdly, cfg_phyinst_maxdly_cmd, + "osmotrx maxdly <0-31>", "Set the maximum delay of GSM symbols\n" "GSM symbols (approx. 1.1km per symbol)\n") { - struct gsm_bts_trx *trx = vty->index; - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = vty->index; + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; l1h->config.maxdly = atoi(argv[0]); l1h->config.maxdly_valid = 1; @@ -286,7 +253,7 @@ DEFUN(cfg_trx_maxdly, cfg_trx_maxdly_cmd, return CMD_SUCCESS; } -DEFUN(cfg_trx_slotmask, cfg_trx_slotmask_cmd, +DEFUN(cfg_phyinst_slotmask, cfg_phyinst_slotmask_cmd, "slotmask (1|0) (1|0) (1|0) (1|0) (1|0) (1|0) (1|0) (1|0)", "Set the supported slots\n" "TS0 supported\nTS0 unsupported\nTS1 supported\nTS1 unsupported\n" @@ -294,8 +261,8 @@ DEFUN(cfg_trx_slotmask, cfg_trx_slotmask_cmd, "TS4 supported\nTS4 unsupported\nTS5 supported\nTS5 unsupported\n" "TS6 supported\nTS6 unsupported\nTS7 supported\nTS7 unsupported\n") { - struct gsm_bts_trx *trx = vty->index; - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_instance *pinst = vty->index; + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; uint8_t tn; l1h->config.slotmask = 0; @@ -306,76 +273,167 @@ DEFUN(cfg_trx_slotmask, cfg_trx_slotmask_cmd, return CMD_SUCCESS; } -DEFUN(cfg_trx_no_rxgain, cfg_trx_no_rxgain_cmd, - "no rxgain <0-50>", - NO_STR "Unset the receiver gain in dB\n" + +DEFUN(cfg_phy_fn_advance, cfg_phy_fn_advance_cmd, + "osmotrx fn-advance <0-30>", + OSMOTRX_STR + "Set the number of frames to be transmitted to transceiver in advance " + "of current FN\n" + "Advance in frames\n") +{ + trx_clock_advance = atoi(argv[0]); + + return CMD_SUCCESS; +} + +DEFUN(cfg_phy_rts_advance, cfg_phy_rts_advance_cmd, + "osmotrx rts-advance <0-30>", + OSMOTRX_STR + "Set the number of frames to be requested (PCU) in advance of current " + "FN. Do not change this, unless you have a good reason!\n" + "Advance in frames\n") +{ + trx_rts_advance = atoi(argv[0]); + + return CMD_SUCCESS; +} + +DEFUN(cfg_phy_rxgain, cfg_phy_rxgain_cmd, + "osmotrx rx-gain <0-50>", + OSMOTRX_STR + "Set the receiver gain in dB\n" "Gain in dB\n") { - struct gsm_bts_trx *trx = vty->index; - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_link *plink = vty->index; - l1h->config.rxgain_valid = 0; + plink->u.osmotrx.rxgain = atoi(argv[0]); + plink->u.osmotrx.rxgain_valid = 1; + plink->u.osmotrx.rxgain_sent = 0; return CMD_SUCCESS; } -DEFUN(cfg_trx_no_power, cfg_trx_no_power_cmd, - "no power <0-50>", - NO_STR "Unset the transmitter power dampening\n" - "Power dampening in dB\n") +DEFUN(cfg_phy_tx_atten, cfg_phy_tx_atten_cmd, + "osmotrx tx-attenuation <0-50>", + OSMOTRX_STR + "Set the transmitter attenuation\n" + "Fixed attenuation in dB, overriding OML\n") { - struct gsm_bts_trx *trx = vty->index; - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_link *plink = vty->index; - l1h->config.power_valid = 0; + plink->u.osmotrx.power = atoi(argv[0]); + plink->u.osmotrx.power_oml = 0; + plink->u.osmotrx.power_valid = 1; + plink->u.osmotrx.power_sent = 0; return CMD_SUCCESS; } -DEFUN(cfg_trx_no_maxdly, cfg_trx_no_maxdly_cmd, - "no maxdly <0-31>", - NO_STR "Unset the maximum delay of GSM symbols\n" - "GSM symbols (approx. 1.1km per symbol)\n") +DEFUN(cfg_phy_tx_atten_oml, cfg_phy_tx_atten_oml_cmd, + "osmotrx tx-attenuation oml", + OSMOTRX_STR + "Set the transmitter attenuation\n" + "Use NM_ATT_RF_MAXPOWR_R (max power reduction) from BSC via OML\n") +{ + struct phy_link *plink = vty->index; + + plink->u.osmotrx.power_oml = 1; + plink->u.osmotrx.power_valid = 1; + plink->u.osmotrx.power_sent = 0; + + return CMD_SUCCESS; +} + +DEFUN(cfg_phy_no_rxgain, cfg_phy_no_rxgain_cmd, + "no osmotrx rx-gain", + NO_STR OSMOTRX_STR "Unset the receiver gain in dB\n") +{ + struct phy_link *plink = vty->index; + + plink->u.osmotrx.rxgain_valid = 0; + + return CMD_SUCCESS; +} + +DEFUN(cfg_phy_no_tx_atten, cfg_phy_no_tx_atten_cmd, + "no osmotrx tx-attenuation", + NO_STR OSMOTRX_STR "Unset the transmitter attenuation\n") { - struct gsm_bts_trx *trx = vty->index; - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_link *plink = vty->index; + + plink->u.osmotrx.power_valid = 0; + + return CMD_SUCCESS; +} + +DEFUN(cfg_phyinst_no_maxdly, cfg_phyinst_no_maxdly_cmd, + "no osmotrx maxdly", + NO_STR "Unset the maximum delay of GSM symbols\n") +{ + struct phy_instance *pinst = vty->index; + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; l1h->config.maxdly_valid = 0; return CMD_SUCCESS; } -void bts_model_config_write_bts(struct vty *vty, struct gsm_bts *bts) +DEFUN(cfg_phy_transc_ip, cfg_phy_transc_ip_cmd, + "osmotrx ip HOST", + OSMOTRX_STR + "Set remote IP address\n" + "IP address of OsmoTRX\n") { - vty_out(vty, " fn-advance %d%s", trx_clock_advance, VTY_NEWLINE); - vty_out(vty, " rts-advance %d%s", trx_rts_advance, VTY_NEWLINE); + struct phy_link *plink = vty->index; - if (trx_ms_power_loop) - vty_out(vty, " ms-power-loop %d%s", trx_target_rssi, - VTY_NEWLINE); - else - vty_out(vty, " no ms-power-loop%s", VTY_NEWLINE); - vty_out(vty, " %stiming-advance-loop%s", (trx_ta_loop) ? "":"no ", - VTY_NEWLINE); - if (settsc_enabled) - vty_out(vty, " settsc%s", VTY_NEWLINE); - if (setbsic_enabled) - vty_out(vty, " setbsic%s", VTY_NEWLINE); + if (plink->u.osmotrx.transceiver_ip) + talloc_free(plink->u.osmotrx.transceiver_ip); + plink->u.osmotrx.transceiver_ip = talloc_strdup(plink, argv[0]); + + return CMD_SUCCESS; } -void bts_model_config_write_trx(struct vty *vty, struct gsm_bts_trx *trx) +DEFUN(cfg_phy_base_port, cfg_phy_base_port_cmd, + "osmotrx base-port (local|remote) <0-65535>", + OSMOTRX_STR "Set base UDP port number\n" "Local UDP port\n" + "Remote UDP port\n" "UDP base port number\n") { - struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct phy_link *plink = vty->index; + + if (!strcmp(argv[0], "local")) + plink->u.osmotrx.base_port_local = atoi(argv[1]); + else + plink->u.osmotrx.base_port_remote = atoi(argv[1]); + + return CMD_SUCCESS; +} - if (l1h->config.rxgain_valid) - vty_out(vty, " rxgain %d%s", l1h->config.rxgain, VTY_NEWLINE); - if (l1h->config.power_valid) { - if (l1h->config.power_oml) - vty_out(vty, " power oml%s", VTY_NEWLINE); +void bts_model_config_write_phy(struct vty *vty, struct phy_link *plink) +{ + if (plink->u.osmotrx.transceiver_ip) + vty_out(vty, " osmotrx ip %s%s", + plink->u.osmotrx.transceiver_ip, VTY_NEWLINE); + + vty_out(vty, " osmotrx fn-advance %d%s", + plink->u.osmotrx.clock_advance, VTY_NEWLINE); + vty_out(vty, " osmotrx rts-advance %d%s", + plink->u.osmotrx.rts_advance, VTY_NEWLINE); + if (plink->u.osmotrx.rxgain_valid) + vty_out(vty, " osmotrx rx-gain %d%s", + plink->u.osmotrx.rxgain, VTY_NEWLINE); + if (plink->u.osmotrx.power_valid) { + if (plink->u.osmotrx.power_oml) + vty_out(vty, " osmotrx tx-attenuation oml%s", VTY_NEWLINE); else - vty_out(vty, " power %d%s", l1h->config.power, - VTY_NEWLINE); + vty_out(vty, " osmotrx tx-attenuation %d%s", + plink->u.osmotrx.power, VTY_NEWLINE); } +} + +void bts_model_config_write_phy_inst(struct vty *vty, struct phy_instance *pinst) +{ + struct trx_l1h *l1h = pinst->u.osmotrx.hdl; + if (l1h->config.maxdly_valid) vty_out(vty, " maxdly %d%s", l1h->config.maxdly, VTY_NEWLINE); if (l1h->config.slotmask != 0xff) @@ -391,14 +449,32 @@ void bts_model_config_write_trx(struct vty *vty, struct gsm_bts_trx *trx) VTY_NEWLINE); } +void bts_model_config_write_bts(struct vty *vty, struct gsm_bts *bts) +{ + if (trx_ms_power_loop) + vty_out(vty, " ms-power-loop %d%s", trx_target_rssi, + VTY_NEWLINE); + else + vty_out(vty, " no ms-power-loop%s", VTY_NEWLINE); + vty_out(vty, " %stiming-advance-loop%s", (trx_ta_loop) ? "":"no ", + VTY_NEWLINE); + if (settsc_enabled) + vty_out(vty, " settsc%s", VTY_NEWLINE); + if (setbsic_enabled) + vty_out(vty, " setbsic%s", VTY_NEWLINE); +} + +void bts_model_config_write_trx(struct vty *vty, struct gsm_bts_trx *trx) +{ +} + int bts_model_vty_init(struct gsm_bts *bts) { vty_bts = bts; install_element_ve(&show_transceiver_cmd); + install_element_ve(&show_phy_cmd); - install_element(BTS_NODE, &cfg_bts_fn_advance_cmd); - install_element(BTS_NODE, &cfg_bts_rts_advance_cmd); install_element(BTS_NODE, &cfg_bts_ms_power_loop_cmd); install_element(BTS_NODE, &cfg_bts_no_ms_power_loop_cmd); install_element(BTS_NODE, &cfg_bts_timing_advance_loop_cmd); @@ -408,14 +484,19 @@ int bts_model_vty_init(struct gsm_bts *bts) install_element(BTS_NODE, &cfg_bts_no_settsc_cmd); install_element(BTS_NODE, &cfg_bts_no_setbsic_cmd); - install_element(TRX_NODE, &cfg_trx_rxgain_cmd); - install_element(TRX_NODE, &cfg_trx_power_cmd); - install_element(TRX_NODE, &cfg_trx_power_oml_cmd); - install_element(TRX_NODE, &cfg_trx_maxdly_cmd); - install_element(TRX_NODE, &cfg_trx_slotmask_cmd); - install_element(TRX_NODE, &cfg_trx_no_rxgain_cmd); - install_element(TRX_NODE, &cfg_trx_no_power_cmd); - install_element(TRX_NODE, &cfg_trx_no_maxdly_cmd); + install_element(PHY_NODE, &cfg_phy_base_port_cmd); + install_element(PHY_NODE, &cfg_phy_fn_advance_cmd); + install_element(PHY_NODE, &cfg_phy_rts_advance_cmd); + install_element(PHY_NODE, &cfg_phy_transc_ip_cmd); + install_element(PHY_NODE, &cfg_phy_rxgain_cmd); + install_element(PHY_NODE, &cfg_phy_tx_atten_cmd); + install_element(PHY_NODE, &cfg_phy_tx_atten_oml_cmd); + install_element(PHY_NODE, &cfg_phy_no_rxgain_cmd); + install_element(PHY_NODE, &cfg_phy_no_tx_atten_cmd); + + install_element(PHY_INST_NODE, &cfg_phyinst_slotmask_cmd); + install_element(PHY_INST_NODE, &cfg_phyinst_maxdly_cmd); + install_element(PHY_INST_NODE, &cfg_phyinst_no_maxdly_cmd); return 0; } -- 2.7.0

2 3

[PATCH 1/7] TRX: factor out the scheduler from remaining code
by laforge＠gnumonks.org 04 Feb '16

04 Feb '16

From: Harald Welte <laforge(a)gnumonks.org> The L1 scheduler is a generally useful component that is unfortunately tied quite a bit into the OsmoTRX support. Let's try to separate it out by having separate per-trx/per-ts/per-chan data structures pre-fixed with l1sched_ Using this patch it should be one step easier to use the scheduler for other BTS models, such as the intended upcoming virtual BTS. --- src/osmo-bts-trx/l1_if.c | 35 ++-- src/osmo-bts-trx/l1_if.h | 121 +---------- src/osmo-bts-trx/loops.c | 83 ++++---- src/osmo-bts-trx/loops.h | 14 +- src/osmo-bts-trx/scheduler.c | 486 +++++++++++++++++++++++-------------------- src/osmo-bts-trx/scheduler.h | 143 ++++++++++++- src/osmo-bts-trx/trx_if.c | 2 +- 7 files changed, 473 insertions(+), 411 deletions(-) diff --git a/src/osmo-bts-trx/l1_if.c b/src/osmo-bts-trx/l1_if.c index a45ba05..70a5c59 100644 --- a/src/osmo-bts-trx/l1_if.c +++ b/src/osmo-bts-trx/l1_if.c @@ -68,9 +68,10 @@ struct trx_l1h *l1if_open(struct gsm_bts_trx *trx) if (!l1h) return NULL; l1h->trx = trx; + l1h->l1s.trx = trx; trx->role_bts.l1h = l1h; - trx_sched_init(l1h); + trx_sched_init(&l1h->l1s); rc = trx_if_open(l1h); if (rc < 0) { @@ -89,7 +90,7 @@ err: void l1if_close(struct trx_l1h *l1h) { trx_if_close(l1h); - trx_sched_exit(l1h); + trx_sched_exit(&l1h->l1s); talloc_free(l1h); } @@ -267,7 +268,7 @@ int bts_model_trx_close(struct gsm_bts_trx *trx) enum gsm_phys_chan_config pchan = trx->ts[0].pchan; /* close all logical channels and reset timeslots */ - trx_sched_reset(l1h); + trx_sched_reset(&l1h->l1s); /* deactivate lchan for CCCH */ if (pchan == GSM_PCHAN_CCCH || pchan == GSM_PCHAN_CCCH_SDCCH4) { @@ -374,8 +375,12 @@ static uint8_t trx_set_ts(struct gsm_bts_trx_ts *ts) l1if_provision_transceiver_trx(l1h); } + /* ignore disabled slots */ + if (!(l1h->config.slotmask & (1 << tn))) + return NM_NACK_RES_NOTAVAIL; + /* set physical channel */ - rc = trx_sched_set_pchan(l1h, tn, pchan); + rc = trx_sched_set_pchan(&l1h->l1s, tn, pchan); if (rc) return NM_NACK_RES_NOTAVAIL; @@ -413,17 +418,17 @@ static int l1if_set_ciphering(struct trx_l1h *l1h, struct gsm_lchan *lchan, if (!downlink) { /* set uplink */ - trx_sched_set_cipher(l1h, chan_nr, 0, lchan->encr.alg_id - 1, + trx_sched_set_cipher(&l1h->l1s, chan_nr, 0, lchan->encr.alg_id - 1, lchan->encr.key, lchan->encr.key_len); lchan->ciph_state = LCHAN_CIPH_RX_CONF; } else { /* set downlink and also set uplink, if not already */ if (lchan->ciph_state != LCHAN_CIPH_RX_CONF) { - trx_sched_set_cipher(l1h, chan_nr, 0, + trx_sched_set_cipher(&l1h->l1s, chan_nr, 0, lchan->encr.alg_id - 1, lchan->encr.key, lchan->encr.key_len); } - trx_sched_set_cipher(l1h, chan_nr, 1, lchan->encr.alg_id - 1, + trx_sched_set_cipher(&l1h->l1s, chan_nr, 1, lchan->encr.alg_id - 1, lchan->encr.key, lchan->encr.key_len); lchan->ciph_state = LCHAN_CIPH_RXTX_CONF; } @@ -510,12 +515,12 @@ int bts_model_l1sap_down(struct gsm_bts_trx *trx, struct osmo_phsap_prim *l1sap) if (!msg) break; /* put data into scheduler's queue */ - return trx_sched_ph_data_req(l1h, l1sap); + return trx_sched_ph_data_req(&l1h->l1s, l1sap); case OSMO_PRIM(PRIM_TCH, PRIM_OP_REQUEST): if (!msg) break; /* put data into scheduler's queue */ - return trx_sched_tch_req(l1h, l1sap); + return trx_sched_tch_req(&l1h->l1s, l1sap); case OSMO_PRIM(PRIM_MPH_INFO, PRIM_OP_REQUEST): switch (l1sap->u.info.type) { case PRIM_INFO_ACT_CIPH: @@ -542,11 +547,11 @@ int bts_model_l1sap_down(struct gsm_bts_trx *trx, struct osmo_phsap_prim *l1sap) break; } /* activate dedicated channel */ - trx_sched_set_lchan(l1h, chan_nr, 0x00, 1); + trx_sched_set_lchan(&l1h->l1s, chan_nr, 0x00, 1); /* activate associated channel */ - trx_sched_set_lchan(l1h, chan_nr, 0x40, 1); + trx_sched_set_lchan(&l1h->l1s, chan_nr, 0x40, 1); /* set mode */ - trx_sched_set_mode(l1h, chan_nr, + trx_sched_set_mode(&l1h->l1s, chan_nr, lchan->rsl_cmode, lchan->tch_mode, lchan->tch.amr_mr.num_modes, lchan->tch.amr_mr.bts_mode[0].mode, @@ -574,7 +579,7 @@ int bts_model_l1sap_down(struct gsm_bts_trx *trx, struct osmo_phsap_prim *l1sap) } if (l1sap->u.info.type == PRIM_INFO_MODIFY) { /* change mode */ - trx_sched_set_mode(l1h, chan_nr, + trx_sched_set_mode(&l1h->l1s, chan_nr, lchan->rsl_cmode, lchan->tch_mode, lchan->tch.amr_mr.num_modes, lchan->tch.amr_mr.bts_mode[0].mode, @@ -591,12 +596,12 @@ int bts_model_l1sap_down(struct gsm_bts_trx *trx, struct osmo_phsap_prim *l1sap) break; } /* deactivate associated channel */ - trx_sched_set_lchan(l1h, chan_nr, 0x40, 0); + trx_sched_set_lchan(&l1h->l1s, chan_nr, 0x40, 0); if (!l1sap->u.info.u.act_req.sacch_only) { /* set lchan inactive */ lchan_set_state(lchan, LCHAN_S_NONE); /* deactivate dedicated channel */ - trx_sched_set_lchan(l1h, chan_nr, 0x00, 0); + trx_sched_set_lchan(&l1h->l1s, chan_nr, 0x00, 0); /* confirm only on dedicated channel */ mph_info_chan_confirm(l1h, chan_nr, PRIM_INFO_DEACTIVATE, 0); diff --git a/src/osmo-bts-trx/l1_if.h b/src/osmo-bts-trx/l1_if.h index 2c672cb..6dec273 100644 --- a/src/osmo-bts-trx/l1_if.h +++ b/src/osmo-bts-trx/l1_if.h @@ -1,109 +1,7 @@ #ifndef L1_IF_H_TRX #define L1_IF_H_TRX -/* These types define the different channels on a multiframe. - * Each channel has queues and can be activated individually. - */ -enum trx_chan_type { - TRXC_IDLE = 0, - TRXC_FCCH, - TRXC_SCH, - TRXC_BCCH, - TRXC_RACH, - TRXC_CCCH, - TRXC_TCHF, - TRXC_TCHH_0, - TRXC_TCHH_1, - TRXC_SDCCH4_0, - TRXC_SDCCH4_1, - TRXC_SDCCH4_2, - TRXC_SDCCH4_3, - TRXC_SDCCH8_0, - TRXC_SDCCH8_1, - TRXC_SDCCH8_2, - TRXC_SDCCH8_3, - TRXC_SDCCH8_4, - TRXC_SDCCH8_5, - TRXC_SDCCH8_6, - TRXC_SDCCH8_7, - TRXC_SACCHTF, - TRXC_SACCHTH_0, - TRXC_SACCHTH_1, - TRXC_SACCH4_0, - TRXC_SACCH4_1, - TRXC_SACCH4_2, - TRXC_SACCH4_3, - TRXC_SACCH8_0, - TRXC_SACCH8_1, - TRXC_SACCH8_2, - TRXC_SACCH8_3, - TRXC_SACCH8_4, - TRXC_SACCH8_5, - TRXC_SACCH8_6, - TRXC_SACCH8_7, - TRXC_PDTCH, - TRXC_PTCCH, - _TRX_CHAN_MAX -}; - -/* States each channel on a multiframe */ -struct trx_chan_state { - /* scheduler */ - uint8_t active; /* Channel is active */ - ubit_t *dl_bursts; /* burst buffer for TX */ - sbit_t *ul_bursts; /* burst buffer for RX */ - uint32_t ul_first_fn; /* fn of first burst */ - uint8_t ul_mask; /* mask of received bursts */ - - /* RSSI / TOA */ - uint8_t rssi_num; /* number of RSSI values */ - float rssi_sum; /* sum of RSSI values */ - uint8_t toa_num; /* number of TOA values */ - float toa_sum; /* sum of TOA values */ - - /* loss detection */ - uint8_t lost; /* (SACCH) loss detection */ - - /* mode */ - uint8_t rsl_cmode, tch_mode; /* mode for TCH channels */ - - /* AMR */ - uint8_t codec[4]; /* 4 possible codecs for amr */ - int codecs; /* number of possible codecs */ - float ber_sum; /* sum of bit error rates */ - int ber_num; /* number of bit error rates */ - uint8_t ul_ft; /* current uplink FT index */ - uint8_t dl_ft; /* current downlink FT index */ - uint8_t ul_cmr; /* current uplink CMR index */ - uint8_t dl_cmr; /* current downlink CMR index */ - uint8_t amr_loop; /* if AMR loop is enabled */ - - /* TCH/H */ - uint8_t dl_ongoing_facch; /* FACCH/H on downlink */ - uint8_t ul_ongoing_facch; /* FACCH/H on uplink */ - - /* encryption */ - int ul_encr_algo; /* A5/x encry algo downlink */ - int dl_encr_algo; /* A5/x encry algo uplink */ - int ul_encr_key_len; - int dl_encr_key_len; - uint8_t ul_encr_key[MAX_A5_KEY_LEN]; - uint8_t dl_encr_key[MAX_A5_KEY_LEN]; - - /* measurements */ - struct { - uint8_t clock; /* cyclic clock counter */ - int8_t rssi[32]; /* last RSSI values */ - int rssi_count; /* received RSSI values */ - int rssi_valid_count; /* number of stored value */ - int rssi_got_burst; /* any burst received so far */ - float toa_sum; /* sum of TOA values */ - int toa_num; /* number of TOA value */ - } meas; - - /* handover */ - uint8_t ho_rach_detect; /* if rach detection is on */ -}; +#include "scheduler.h" struct trx_config { uint8_t poweron; /* poweron(1) or poweroff(0) */ @@ -152,16 +50,9 @@ struct trx_l1h { /* transceiver config */ struct trx_config config; - - uint8_t mf_index[TRX_NR_TS]; /* selected multiframe index */ - uint32_t mf_last_fn[TRX_NR_TS]; /* last received frame */ - uint8_t mf_period[TRX_NR_TS]; /* period of multiframe */ - const struct trx_sched_frame *mf_frames[TRX_NR_TS]; /* pointer to frame layout */ - - /* Channel states for all channels on all timeslots */ - struct trx_chan_state chan_states[TRX_NR_TS][_TRX_CHAN_MAX]; - struct llist_head dl_prims[TRX_NR_TS]; /* Queue primitves for TX */ uint8_t ho_rach_detect[TRX_NR_TS][TS_MAX_LCHAN]; + + struct l1sched_trx l1s; }; struct trx_l1h *l1if_open(struct gsm_bts_trx *trx); @@ -176,4 +67,10 @@ void l1if_fill_meas_res(struct osmo_phsap_prim *l1sap, uint8_t chan_nr, float ta int l1if_process_meas_res(struct gsm_bts_trx *trx, uint8_t tn, uint32_t fn, uint8_t chan_nr, int n_errors, int n_bits_total, float rssi, float toa); +static inline struct l1sched_trx *trx_l1sched_hdl(struct gsm_bts_trx *trx) +{ + struct trx_l1h *l1h = trx_l1h_hdl(trx); + return &l1h->l1s; +} + #endif /* L1_IF_H_TRX */ diff --git a/src/osmo-bts-trx/loops.c b/src/osmo-bts-trx/loops.c index 52ac170..8070e80 100644 --- a/src/osmo-bts-trx/loops.c +++ b/src/osmo-bts-trx/loops.c @@ -33,7 +33,7 @@ #include "l1_if.h" #include "loops.h" -#define MS_PWR_DBM(lvl) ms_pwr_dbm(gsm_arfcn2band(l1h->config.arfcn), lvl) +#define MS_PWR_DBM(arfcn, lvl) ms_pwr_dbm(gsm_arfcn2band(arfcn), lvl) /* * MS Power loop @@ -42,11 +42,12 @@ int trx_ms_power_loop = 0; int8_t trx_target_rssi = -10; -static int ms_power_diff(struct trx_l1h *l1h, struct gsm_lchan *lchan, - uint8_t chan_nr, struct trx_chan_state *chan_state, int8_t diff) +static int ms_power_diff(struct gsm_lchan *lchan, uint8_t chan_nr, int8_t diff) { + struct gsm_bts_trx *trx = lchan->ts->trx; + uint16_t arfcn = trx->arfcn; int8_t new_power; - + new_power = lchan->ms_power - (diff >> 1); if (diff == 0) @@ -56,7 +57,7 @@ static int ms_power_diff(struct trx_l1h *l1h, struct gsm_lchan *lchan, new_power = 0; // FIXME: to go above 1W, we need to know classmark of MS - if (l1h->config.arfcn >= 512 && l1h->config.arfcn <= 885) { + if (arfcn >= 512 && arfcn <= 885) { if (new_power > 15) new_power = 15; } else { @@ -73,8 +74,8 @@ static int ms_power_diff(struct trx_l1h *l1h, struct gsm_lchan *lchan, if (lchan->ms_power == new_power) { LOGP(DLOOP, LOGL_INFO, "Keeping MS new_power of trx=%u " "chan_nr=0x%02x at control level %d (%d dBm)\n", - l1h->trx->nr, chan_nr, new_power, - MS_PWR_DBM(new_power)); + trx->nr, chan_nr, new_power, + MS_PWR_DBM(arfcn, new_power)); return 0; } @@ -82,15 +83,16 @@ static int ms_power_diff(struct trx_l1h *l1h, struct gsm_lchan *lchan, LOGP(DLOOP, LOGL_INFO, "%s MS new_power of trx=%u chan_nr=0x%02x from " "control level %d (%d dBm) to %d (%d dBm)\n", (diff > 0) ? "Raising" : "Lowering", - l1h->trx->nr, chan_nr, lchan->ms_power, - MS_PWR_DBM(lchan->ms_power), new_power, MS_PWR_DBM(new_power)); + trx->nr, chan_nr, lchan->ms_power, + MS_PWR_DBM(arfcn, lchan->ms_power), new_power, + MS_PWR_DBM(arfcn, new_power)); lchan->ms_power = new_power; return 0; } -static int ms_power_val(struct trx_chan_state *chan_state, int8_t rssi) +static int ms_power_val(struct l1sched_chan_state *chan_state, int8_t rssi) { /* ignore inserted dummy frames, treat as lost frames */ if (rssi < -127) @@ -112,9 +114,10 @@ static int ms_power_val(struct trx_chan_state *chan_state, int8_t rssi) return 0; } -static int ms_power_clock(struct trx_l1h *l1h, struct gsm_lchan *lchan, - uint8_t chan_nr, struct trx_chan_state *chan_state) +static int ms_power_clock(struct gsm_lchan *lchan, + uint8_t chan_nr, struct l1sched_chan_state *chan_state) { + struct gsm_bts_trx *trx = lchan->ts->trx; int rssi; int i; @@ -134,9 +137,8 @@ static int ms_power_clock(struct trx_l1h *l1h, struct gsm_lchan *lchan, if (chan_state->meas.rssi_count == 0) { LOGP(DLOOP, LOGL_NOTICE, "LOST SACCH frame of trx=%u " "chan_nr=0x%02x, so we raise MS power\n", - l1h->trx->nr, chan_nr); - return ms_power_diff(l1h, lchan, chan_nr, chan_state, - MS_RAISE_MAX); + trx->nr, chan_nr); + return ms_power_diff(lchan, chan_nr, MS_RAISE_MAX); } /* reset total counter */ @@ -157,9 +159,10 @@ static int ms_power_clock(struct trx_l1h *l1h, struct gsm_lchan *lchan, /* change RSSI */ LOGP(DLOOP, LOGL_DEBUG, "Lowest RSSI: %d Target RSSI: %d Current " "MS power: %d (%d dBm) of trx=%u chan_nr=0x%02x\n", rssi, - trx_target_rssi, lchan->ms_power, MS_PWR_DBM(lchan->ms_power), - l1h->trx->nr, chan_nr); - ms_power_diff(l1h, lchan, chan_nr, chan_state, trx_target_rssi - rssi); + trx_target_rssi, lchan->ms_power, + MS_PWR_DBM(trx->arfcn, lchan->ms_power), + trx->nr, chan_nr); + ms_power_diff(lchan, chan_nr, trx_target_rssi - rssi); return 0; } @@ -171,9 +174,11 @@ static int ms_power_clock(struct trx_l1h *l1h, struct gsm_lchan *lchan, int trx_ta_loop = 1; -int ta_val(struct trx_l1h *l1h, struct gsm_lchan *lchan, uint8_t chan_nr, - struct trx_chan_state *chan_state, float toa) +int ta_val(struct gsm_lchan *lchan, uint8_t chan_nr, + struct l1sched_chan_state *chan_state, float toa) { + struct gsm_bts_trx *trx = lchan->ts->trx; + /* check if the current L1 header acks to the current ordered TA */ if (lchan->meas.l1_info[1] != lchan->rqd_ta) return 0; @@ -190,19 +195,19 @@ int ta_val(struct trx_l1h *l1h, struct gsm_lchan *lchan, uint8_t chan_nr, if (toa < -0.9F && lchan->rqd_ta > 0) { LOGP(DLOOP, LOGL_INFO, "TOA of trx=%u chan_nr=0x%02x is too " "early (%.2f), now lowering TA from %d to %d\n", - l1h->trx->nr, chan_nr, toa, lchan->rqd_ta, + trx->nr, chan_nr, toa, lchan->rqd_ta, lchan->rqd_ta - 1); lchan->rqd_ta--; } else if (toa > 0.9F && lchan->rqd_ta < 63) { LOGP(DLOOP, LOGL_INFO, "TOA of trx=%u chan_nr=0x%02x is too " "late (%.2f), now raising TA from %d to %d\n", - l1h->trx->nr, chan_nr, toa, lchan->rqd_ta, + trx->nr, chan_nr, toa, lchan->rqd_ta, lchan->rqd_ta + 1); lchan->rqd_ta++; } else LOGP(DLOOP, LOGL_INFO, "TOA of trx=%u chan_nr=0x%02x is " "correct (%.2f), keeping current TA of %d\n", - l1h->trx->nr, chan_nr, toa, lchan->rqd_ta); + trx->nr, chan_nr, toa, lchan->rqd_ta); chan_state->meas.toa_num = 0; chan_state->meas.toa_sum = 0; @@ -210,29 +215,29 @@ int ta_val(struct trx_l1h *l1h, struct gsm_lchan *lchan, uint8_t chan_nr, return 0; } -int trx_loop_sacch_input(struct trx_l1h *l1h, uint8_t chan_nr, - struct trx_chan_state *chan_state, int8_t rssi, float toa) +int trx_loop_sacch_input(struct l1sched_trx *l1t, uint8_t chan_nr, + struct l1sched_chan_state *chan_state, int8_t rssi, float toa) { - struct gsm_lchan *lchan = &l1h->trx->ts[L1SAP_CHAN2TS(chan_nr)] + struct gsm_lchan *lchan = &l1t->trx->ts[L1SAP_CHAN2TS(chan_nr)] .lchan[l1sap_chan2ss(chan_nr)]; if (trx_ms_power_loop) ms_power_val(chan_state, rssi); if (trx_ta_loop) - ta_val(l1h, lchan, chan_nr, chan_state, toa); + ta_val(lchan, chan_nr, chan_state, toa); return 0; } -int trx_loop_sacch_clock(struct trx_l1h *l1h, uint8_t chan_nr, - struct trx_chan_state *chan_state) +int trx_loop_sacch_clock(struct l1sched_trx *l1t, uint8_t chan_nr, + struct l1sched_chan_state *chan_state) { - struct gsm_lchan *lchan = &l1h->trx->ts[L1SAP_CHAN2TS(chan_nr)] + struct gsm_lchan *lchan = &l1t->trx->ts[L1SAP_CHAN2TS(chan_nr)] .lchan[l1sap_chan2ss(chan_nr)]; if (trx_ms_power_loop) - ms_power_clock(l1h, lchan, chan_nr, chan_state); + ms_power_clock(lchan, chan_nr, chan_state); /* count the number of SACCH clocks */ chan_state->meas.clock++; @@ -240,10 +245,11 @@ int trx_loop_sacch_clock(struct trx_l1h *l1h, uint8_t chan_nr, return 0; } -int trx_loop_amr_input(struct trx_l1h *l1h, uint8_t chan_nr, - struct trx_chan_state *chan_state, float ber) +int trx_loop_amr_input(struct l1sched_trx *l1t, uint8_t chan_nr, + struct l1sched_chan_state *chan_state, float ber) { - struct gsm_lchan *lchan = &l1h->trx->ts[L1SAP_CHAN2TS(chan_nr)] + struct gsm_bts_trx *trx = l1t->trx; + struct gsm_lchan *lchan = &trx->ts[L1SAP_CHAN2TS(chan_nr)] .lchan[l1sap_chan2ss(chan_nr)]; int c_i; @@ -280,7 +286,7 @@ int trx_loop_amr_input(struct trx_l1h *l1h, uint8_t chan_nr, LOGP(DLOOP, LOGL_DEBUG, "Current bit error rate (BER) %.6f " "codec id %d of trx=%u chan_nr=0x%02x\n", ber, - chan_state->ul_ft, l1h->trx->nr, chan_nr); + chan_state->ul_ft, trx->nr, chan_nr); /* degrade */ if (chan_state->dl_cmr > 0) { @@ -290,7 +296,7 @@ int trx_loop_amr_input(struct trx_l1h *l1h, uint8_t chan_nr, LOGP(DLOOP, LOGL_DEBUG, "Degrading due to BER %.6f " "from codec id %d to %d of trx=%u " "chan_nr=0x%02x\n", ber, chan_state->dl_cmr, - chan_state->dl_cmr - 1, l1h->trx->nr, chan_nr); + chan_state->dl_cmr - 1, trx->nr, chan_nr); chan_state->dl_cmr--; } @@ -306,7 +312,7 @@ int trx_loop_amr_input(struct trx_l1h *l1h, uint8_t chan_nr, LOGP(DLOOP, LOGL_DEBUG, "Upgrading due to BER %.6f " "from codec id %d to %d of trx=%u " "chan_nr=0x%02x\n", ber, chan_state->dl_cmr, - chan_state->dl_cmr + 1, l1h->trx->nr, chan_nr); + chan_state->dl_cmr + 1, trx->nr, chan_nr); chan_state->dl_cmr++; } @@ -316,7 +322,7 @@ int trx_loop_amr_input(struct trx_l1h *l1h, uint8_t chan_nr, return 0; } -int trx_loop_amr_set(struct trx_chan_state *chan_state, int loop) +int trx_loop_amr_set(struct l1sched_chan_state *chan_state, int loop) { if (chan_state->amr_loop && !loop) { chan_state->amr_loop = 0; @@ -336,4 +342,3 @@ int trx_loop_amr_set(struct trx_chan_state *chan_state, int loop) return 0; } - diff --git a/src/osmo-bts-trx/loops.h b/src/osmo-bts-trx/loops.h index 27b0ef2..613d2d0 100644 --- a/src/osmo-bts-trx/loops.h +++ b/src/osmo-bts-trx/loops.h @@ -17,15 +17,15 @@ extern int trx_ms_power_loop; extern int8_t trx_target_rssi; extern int trx_ta_loop; -int trx_loop_sacch_input(struct trx_l1h *l1h, uint8_t chan_nr, - struct trx_chan_state *chan_state, int8_t rssi, float toa); +int trx_loop_sacch_input(struct l1sched_trx *l1t, uint8_t chan_nr, + struct l1sched_chan_state *chan_state, int8_t rssi, float toa); -int trx_loop_sacch_clock(struct trx_l1h *l1h, uint8_t chan_nr, - struct trx_chan_state *chan_state); +int trx_loop_sacch_clock(struct l1sched_trx *l1t, uint8_t chan_nr, + struct l1sched_chan_state *chan_state); -int trx_loop_amr_input(struct trx_l1h *l1h, uint8_t chan_nr, - struct trx_chan_state *chan_state, float ber); +int trx_loop_amr_input(struct l1sched_trx *l1t, uint8_t chan_nr, + struct l1sched_chan_state *chan_state, float ber); -int trx_loop_amr_set(struct trx_chan_state *chan_state, int loop); +int trx_loop_amr_set(struct l1sched_chan_state *chan_state, int loop); #endif /* _TRX_LOOPS_H */ diff --git a/src/osmo-bts-trx/scheduler.c b/src/osmo-bts-trx/scheduler.c index 1710b4e..6d0f180 100644 --- a/src/osmo-bts-trx/scheduler.c +++ b/src/osmo-bts-trx/scheduler.c @@ -2,6 +2,7 @@ /* (C) 2013 by Andreas Eversberg <jolly(a)eversberg.eu> * (C) 2015 by Alexander Chemeris <Alexander.Chemeris(a)fairwaves.co> + * (C) 2015 by Harald Welte <laforge(a)gnumonks.org> * * All Rights Reserved * @@ -67,47 +68,47 @@ uint32_t trx_clock_advance = 20; /* advance RTS to give some time for data processing. (especially PCU) */ uint32_t trx_rts_advance = 5; /* about 20ms */ -typedef int trx_sched_rts_func(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +typedef int trx_sched_rts_func(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan); -typedef ubit_t *trx_sched_dl_func(struct trx_l1h *l1h, uint8_t tn, +typedef ubit_t *trx_sched_dl_func(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid); -typedef int trx_sched_ul_func(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +typedef int trx_sched_ul_func(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa); -static int rts_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rts_data_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan); -static int rts_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rts_tchf_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan); -static int rts_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rts_tchh_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan); -static ubit_t *tx_idle_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_idle_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid); -static ubit_t *tx_fcch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_fcch_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid); -static ubit_t *tx_sch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_sch_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid); -static ubit_t *tx_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_data_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid); -static ubit_t *tx_pdtch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_pdtch_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid); -static ubit_t *tx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_tchf_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid); -static ubit_t *tx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_tchh_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid); -static int rx_rach_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rx_rach_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa); -static int rx_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rx_data_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa); -static int rx_pdtch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rx_pdtch_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa); -static int rx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rx_tchf_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa); -static int rx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rx_tchh_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa); @@ -219,23 +220,22 @@ static const struct trx_chan_desc trx_chan_desc[_TRX_CHAN_MAX] = { * init / exit */ -int trx_sched_init(struct trx_l1h *l1h) +int trx_sched_init(struct l1sched_trx *l1t) { uint8_t tn; int i; - struct trx_chan_state *chan_state; - LOGP(DL1C, LOGL_NOTICE, "Init scheduler for trx=%u\n", l1h->trx->nr); + LOGP(DL1C, LOGL_NOTICE, "Init scheduler for trx=%u\n", l1t->trx->nr); - /* hack to get bts */ - bts = l1h->trx->bts; + for (tn = 0; tn < ARRAY_SIZE(l1t->ts); tn++) { + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); - for (tn = 0; tn < TRX_NR_TS; tn++) { - l1h->mf_index[tn] = 0; - l1h->mf_last_fn[tn] = 0; - INIT_LLIST_HEAD(&l1h->dl_prims[tn]); - for (i = 0; i < _TRX_CHAN_MAX; i++) { - chan_state = &l1h->chan_states[tn][i]; + l1ts->mf_index = 0; + l1ts->mf_last_fn = 0; + INIT_LLIST_HEAD(&l1ts->dl_prims); + for (i = 0; i < ARRAY_SIZE(&l1ts->chan_state); i++) { + struct l1sched_chan_state *chan_state; + chan_state = &l1ts->chan_state[i]; chan_state->active = 0; } } @@ -243,18 +243,20 @@ int trx_sched_init(struct trx_l1h *l1h) return 0; } -void trx_sched_exit(struct trx_l1h *l1h) +void trx_sched_exit(struct l1sched_trx *l1t) { + struct gsm_bts_trx_ts *ts; uint8_t tn; int i; - struct trx_chan_state *chan_state; - LOGP(DL1C, LOGL_NOTICE, "Exit scheduler for trx=%u\n", l1h->trx->nr); + LOGP(DL1C, LOGL_NOTICE, "Exit scheduler for trx=%u\n", l1t->trx->nr); - for (tn = 0; tn < TRX_NR_TS; tn++) { - msgb_queue_flush(&l1h->dl_prims[tn]); + for (tn = 0; tn < ARRAY_SIZE(l1t->ts); tn++) { + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + msgb_queue_flush(&l1ts->dl_prims); for (i = 0; i < _TRX_CHAN_MAX; i++) { - chan_state = &l1h->chan_states[tn][i]; + struct l1sched_chan_state *chan_state; + chan_state = &l1ts->chan_state[i]; if (chan_state->dl_bursts) { talloc_free(chan_state->dl_bursts); chan_state->dl_bursts = NULL; @@ -265,16 +267,17 @@ void trx_sched_exit(struct trx_l1h *l1h) } } /* clear lchan channel states */ - for (i = 0; i < TRX_NR_TS; i++) - l1h->trx->ts[tn].lchan[i].state = LCHAN_S_NONE; + ts = &l1t->trx->ts[tn]; + for (i = 0; i < ARRAY_SIZE(ts->lchan); i++) + lchan_set_state(&ts->lchan[i], LCHAN_S_NONE); } } /* close all logical channels and reset timeslots */ -void trx_sched_reset(struct trx_l1h *l1h) +void trx_sched_reset(struct l1sched_trx *l1t) { - trx_sched_exit(l1h); - trx_sched_init(l1h); + trx_sched_exit(l1t); + trx_sched_init(l1t); } @@ -282,13 +285,14 @@ void trx_sched_reset(struct trx_l1h *l1h) * data request (from upper layer) */ -int trx_sched_ph_data_req(struct trx_l1h *l1h, struct osmo_phsap_prim *l1sap) +int trx_sched_ph_data_req(struct l1sched_trx *l1t, struct osmo_phsap_prim *l1sap) { uint8_t tn = l1sap->u.data.chan_nr & 7; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); LOGP(DL1C, LOGL_INFO, "PH-DATA.req: chan_nr=0x%02x link_id=0x%02x " "fn=%u ts=%u trx=%u\n", l1sap->u.data.chan_nr, - l1sap->u.data.link_id, l1sap->u.data.fn, tn, l1h->trx->nr); + l1sap->u.data.link_id, l1sap->u.data.fn, tn, l1t->trx->nr); if (!l1sap->oph.msg) abort(); @@ -299,18 +303,19 @@ int trx_sched_ph_data_req(struct trx_l1h *l1h, struct osmo_phsap_prim *l1sap) return 0; } - msgb_enqueue(&l1h->dl_prims[tn], l1sap->oph.msg); + msgb_enqueue(&l1ts->dl_prims, l1sap->oph.msg); return 0; } -int trx_sched_tch_req(struct trx_l1h *l1h, struct osmo_phsap_prim *l1sap) +int trx_sched_tch_req(struct l1sched_trx *l1t, struct osmo_phsap_prim *l1sap) { uint8_t tn = l1sap->u.tch.chan_nr & 7; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); LOGP(DL1C, LOGL_INFO, "TCH.req: chan_nr=0x%02x " "fn=%u ts=%u trx=%u\n", l1sap->u.tch.chan_nr, - l1sap->u.tch.fn, tn, l1h->trx->nr); + l1sap->u.tch.fn, tn, l1t->trx->nr); if (!l1sap->oph.msg) abort(); @@ -321,7 +326,7 @@ int trx_sched_tch_req(struct trx_l1h *l1h, struct osmo_phsap_prim *l1sap) return 0; } - msgb_enqueue(&l1h->dl_prims[tn], l1sap->oph.msg); + msgb_enqueue(&l1ts->dl_prims, l1sap->oph.msg); return 0; } @@ -332,12 +337,13 @@ int trx_sched_tch_req(struct trx_l1h *l1h, struct osmo_phsap_prim *l1sap) */ /* RTS for data frame */ -static int rts_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rts_data_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan) { uint8_t chan_nr, link_id; struct msgb *msg; struct osmo_phsap_prim *l1sap; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); /* get data for RTS indication */ chan_nr = trx_chan_desc[chan].chan_nr | tn; @@ -351,11 +357,11 @@ static int rts_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, LOGP(DL1C, LOGL_INFO, "PH-RTS.ind: chan=%s chan_nr=0x%02x " "link_id=0x%02x fn=%u ts=%u trx=%u\n", trx_chan_desc[chan].name, - chan_nr, link_id, fn, tn, l1h->trx->nr); + chan_nr, link_id, fn, tn, l1t->trx->nr); /* send clock information to loops process */ if (L1SAP_IS_LINK_SACCH(link_id)) - trx_loop_sacch_clock(l1h, chan_nr, &l1h->chan_states[tn][chan]); + trx_loop_sacch_clock(l1t, chan_nr, &l1ts->chan_state[chan]); /* generate prim */ msg = l1sap_msgb_alloc(200); @@ -368,15 +374,16 @@ static int rts_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, l1sap->u.data.link_id = link_id; l1sap->u.data.fn = fn; - return l1sap_up(l1h->trx, l1sap); + return l1sap_up(l1t->trx, l1sap); } -static int rts_tch_common(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rts_tch_common(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, int facch) { uint8_t chan_nr, link_id; struct msgb *msg; struct osmo_phsap_prim *l1sap; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); int rc = 0; /* get data for RTS indication */ @@ -391,7 +398,7 @@ static int rts_tch_common(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, LOGP(DL1C, LOGL_INFO, "TCH RTS.ind: chan=%s chan_nr=0x%02x " "fn=%u ts=%u trx=%u\n", trx_chan_desc[chan].name, - chan_nr, fn, tn, l1h->trx->nr); + chan_nr, fn, tn, l1t->trx->nr); /* only send, if FACCH is selected */ if (facch) { @@ -406,11 +413,11 @@ static int rts_tch_common(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, l1sap->u.data.link_id = link_id; l1sap->u.data.fn = fn; - rc = l1sap_up(l1h->trx, l1sap); + rc = l1sap_up(l1t->trx, l1sap); } /* dont send, if TCH is in signalling only mode */ - if (l1h->chan_states[tn][chan].rsl_cmode != RSL_CMOD_SPD_SIGN) { + if (l1ts->chan_state[chan].rsl_cmode != RSL_CMOD_SPD_SIGN) { /* generate prim */ msg = l1sap_msgb_alloc(200); if (!msg) @@ -421,27 +428,27 @@ static int rts_tch_common(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, l1sap->u.tch.chan_nr = chan_nr; l1sap->u.tch.fn = fn; - return l1sap_up(l1h->trx, l1sap); + return l1sap_up(l1t->trx, l1sap); } return rc; } /* RTS for full rate traffic frame */ -static int rts_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rts_tchf_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan) { /* TCH/F may include FACCH on every 4th burst */ - return rts_tch_common(l1h, tn, fn, chan, 1); + return rts_tch_common(l1t, tn, fn, chan, 1); } /* RTS for half rate traffic frame */ -static int rts_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rts_tchh_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan) { /* the FN 4/5, 13/14, 21/22 defines that FACCH may be included. */ - return rts_tch_common(l1h, tn, fn, chan, ((fn % 26) >> 2) & 1); + return rts_tch_common(l1t, tn, fn, chan, ((fn % 26) >> 2) & 1); } @@ -450,25 +457,25 @@ static int rts_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, */ /* an IDLE burst returns nothing. on C0 it is replaced by dummy burst */ -static ubit_t *tx_idle_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_idle_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid) { LOGP(DL1C, LOGL_DEBUG, "Transmitting %s fn=%u ts=%u trx=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr); return NULL; } -static ubit_t *tx_fcch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_fcch_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid) { LOGP(DL1C, LOGL_DEBUG, "Transmitting %s fn=%u ts=%u trx=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr); return (ubit_t *) fcch_burst; } -static ubit_t *tx_sch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_sch_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid) { static ubit_t bits[148], burst[78]; @@ -477,12 +484,12 @@ static ubit_t *tx_sch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, uint8_t t3p, bsic; LOGP(DL1C, LOGL_DEBUG, "Transmitting %s fn=%u ts=%u trx=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr); /* create SB info from GSM time and BSIC */ gsm_fn2gsmtime(&t, fn); t3p = t.t3 / 10; - bsic = l1h->trx->bts->bsic; + bsic = l1t->trx->bts->bsic; sb_info[0] = ((bsic & 0x3f) << 2) | ((t.t1 & 0x600) >> 9); @@ -508,16 +515,17 @@ static ubit_t *tx_sch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, return bits; } -static struct msgb *dequeue_prim(struct trx_l1h *l1h, int8_t tn,uint32_t fn, +static struct msgb *dequeue_prim(struct l1sched_trx *l1t, int8_t tn, uint32_t fn, enum trx_chan_type chan) { struct msgb *msg, *msg2; struct osmo_phsap_prim *l1sap; uint32_t prim_fn; uint8_t chan_nr, link_id; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); /* get prim of current fn from queue */ - llist_for_each_entry_safe(msg, msg2, &l1h->dl_prims[tn], list) { + llist_for_each_entry_safe(msg, msg2, &l1ts->dl_prims, list) { l1sap = msgb_l1sap_prim(msg); if (l1sap->oph.operation != PRIM_OP_REQUEST) { wrong_type: @@ -548,7 +556,7 @@ free_msg: "is out of range, or channel already disabled. " "If this happens in conjunction with PCU, " "increase 'rts-advance' by 5. (current fn=%u)\n", - l1h->trx->nr, tn, l1sap->u.data.fn, fn); + l1t->trx->nr, tn, l1sap->u.data.fn, fn); /* unlink and free message */ llist_del(&msg->list); msgb_free(msg); @@ -578,12 +586,13 @@ found_msg: return msg; } -static int compose_ph_data_ind(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int compose_ph_data_ind(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t *l2, uint8_t l2_len, float rssi) { struct msgb *msg; struct osmo_phsap_prim *l1sap; uint8_t chan_nr = trx_chan_desc[chan].chan_nr | tn; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); /* compose primitive */ msg = l1sap_msgb_alloc(l2_len); @@ -599,19 +608,20 @@ static int compose_ph_data_ind(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, memcpy(msg->l2h, l2, l2_len); if (L1SAP_IS_LINK_SACCH(trx_chan_desc[chan].link_id)) - l1h->chan_states[tn][chan].lost = 0; + l1ts->chan_state[chan].lost = 0; /* forward primitive */ - l1sap_up(l1h->trx, l1sap); + l1sap_up(l1t->trx, l1sap); return 0; } -static int compose_tch_ind(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int compose_tch_ind(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t *tch, uint8_t tch_len) { struct msgb *msg; struct osmo_phsap_prim *l1sap; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); /* compose primitive */ msg = l1sap_msgb_alloc(tch_len); @@ -624,20 +634,22 @@ static int compose_tch_ind(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, if (tch_len) memcpy(msg->l2h, tch, tch_len); - if (l1h->chan_states[tn][chan].lost) - l1h->chan_states[tn][chan].lost--; + if (l1ts->chan_state[chan].lost) + l1ts->chan_state[chan].lost--; /* forward primitive */ - l1sap_up(l1h->trx, l1sap); + l1sap_up(l1t->trx, l1sap); return 0; } -static ubit_t *tx_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_data_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid) { + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct gsm_bts_trx_ts *ts = &l1t->trx->ts[tn]; struct msgb *msg = NULL; /* make GCC happy */ - ubit_t *burst, **bursts_p = &l1h->chan_states[tn][chan].dl_bursts; + ubit_t *burst, **bursts_p = &l1ts->chan_state[chan].dl_bursts; static ubit_t bits[148]; /* send burst, if we already got a frame */ @@ -648,13 +660,13 @@ static ubit_t *tx_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, } /* get mac block from queue */ - msg = dequeue_prim(l1h, tn, fn, chan); + msg = dequeue_prim(l1t, tn, fn, chan); if (msg) goto got_msg; LOGP(DL1C, LOGL_INFO, "%s has not been served !! No prim for " "trx=%u ts=%u at fn=%u to transmit.\n", - trx_chan_desc[chan].name, l1h->trx->nr, tn, fn); + trx_chan_desc[chan].name, l1t->trx->nr, tn, fn); no_msg: /* free burst memory */ @@ -677,15 +689,15 @@ got_msg: /* handle loss detection of sacch */ if (L1SAP_IS_LINK_SACCH(trx_chan_desc[chan].link_id)) { /* count and send BFI */ - if (++(l1h->chan_states[tn][chan].lost) > 1) { + if (++(l1ts->chan_state[chan].lost) > 1) { /* TODO: Should we pass old TOA here? Otherwise we risk * unnecessary decreasing TA */ /* Send uplnk measurement information to L2 */ - l1if_process_meas_res(l1h->trx, tn, fn, trx_chan_desc[chan].chan_nr | tn, + l1if_process_meas_res(l1t->trx, tn, fn, trx_chan_desc[chan].chan_nr | tn, 456, 456, -110, 0); - compose_ph_data_ind(l1h, tn, 0, chan, NULL, 0, -110); + compose_ph_data_ind(l1t, tn, 0, chan, NULL, 0, -110); } } @@ -707,21 +719,23 @@ send_burst: burst = *bursts_p + bid * 116; memset(bits, 0, 3); memcpy(bits + 3, burst, 58); - memcpy(bits + 61, tsc[l1h->config.tsc], 26); + memcpy(bits + 61, tsc[gsm_ts_tsc(ts)], 26); memcpy(bits + 87, burst + 58, 58); memset(bits + 145, 0, 3); LOGP(DL1C, LOGL_DEBUG, "Transmitting %s fn=%u ts=%u trx=%u burst=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr, bid); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr, bid); return bits; } -static ubit_t *tx_pdtch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_pdtch_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid) { + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct gsm_bts_trx_ts *ts = &l1t->trx->ts[tn]; struct msgb *msg = NULL; /* make GCC happy */ - ubit_t *burst, **bursts_p = &l1h->chan_states[tn][chan].dl_bursts; + ubit_t *burst, **bursts_p = &l1ts->chan_state[chan].dl_bursts; static ubit_t bits[148]; int rc; @@ -733,13 +747,13 @@ static ubit_t *tx_pdtch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, } /* get mac block from queue */ - msg = dequeue_prim(l1h, tn, fn, chan); + msg = dequeue_prim(l1t, tn, fn, chan); if (msg) goto got_msg; LOGP(DL1C, LOGL_INFO, "%s has not been served !! No prim for " "trx=%u ts=%u at fn=%u to transmit.\n", - trx_chan_desc[chan].name, l1h->trx->nr, tn, fn); + trx_chan_desc[chan].name, l1t->trx->nr, tn, fn); no_msg: /* free burst memory */ @@ -777,29 +791,30 @@ send_burst: burst = *bursts_p + bid * 116; memset(bits, 0, 3); memcpy(bits + 3, burst, 58); - memcpy(bits + 61, tsc[l1h->config.tsc], 26); + memcpy(bits + 61, tsc[gsm_ts_tsc(ts)], 26); memcpy(bits + 87, burst + 58, 58); memset(bits + 145, 0, 3); LOGP(DL1C, LOGL_DEBUG, "Transmitting %s fn=%u ts=%u trx=%u burst=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr, bid); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr, bid); return bits; } -static void tx_tch_common(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static void tx_tch_common(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, struct msgb **_msg_tch, struct msgb **_msg_facch, int codec_mode_request) { + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); struct msgb *msg1, *msg2, *msg_tch = NULL, *msg_facch = NULL; - struct trx_chan_state *chan_state = &l1h->chan_states[tn][chan]; + struct l1sched_chan_state *chan_state = &l1ts->chan_state[chan]; uint8_t rsl_cmode = chan_state->rsl_cmode; uint8_t tch_mode = chan_state->tch_mode; struct osmo_phsap_prim *l1sap; /* handle loss detection of received TCH frames */ if (rsl_cmode == RSL_CMOD_SPD_SPEECH - && ++(l1h->chan_states[tn][chan].lost) > 5) { + && ++(chan_state->lost) > 5) { uint8_t tch_data[GSM_FR_BYTES]; int len; @@ -831,7 +846,7 @@ static void tx_tch_common(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, if (len < 2) break; memset(tch_data + 2, 0, len - 2); - compose_tch_ind(l1h, tn, 0, chan, tch_data, len); + compose_tch_ind(l1t, tn, 0, chan, tch_data, len); break; default: inval_mode1: @@ -840,12 +855,12 @@ inval_mode1: len = 0; } if (len) - compose_tch_ind(l1h, tn, 0, chan, tch_data, len); + compose_tch_ind(l1t, tn, 0, chan, tch_data, len); } /* get frame and unlink from queue */ - msg1 = dequeue_prim(l1h, tn, fn, chan); - msg2 = dequeue_prim(l1h, tn, fn, chan); + msg1 = dequeue_prim(l1t, tn, fn, chan); + msg2 = dequeue_prim(l1t, tn, fn, chan); if (msg1) { l1sap = msgb_l1sap_prim(msg1); if (l1sap->oph.primitive == PRIM_TCH) { @@ -898,7 +913,7 @@ inval_mode1: LOGP(DL1C, LOGL_NOTICE, "%s Dropping speech frame, " "because we are not in speech mode trx=%u " "ts=%u at fn=%u.\n", trx_chan_desc[chan].name, - l1h->trx->nr, tn, fn); + l1t->trx->nr, tn, fn); goto free_bad_msg; } @@ -913,7 +928,7 @@ inval_mode1: "HR frame' trx=%u ts=%u at " "fn=%u.\n", trx_chan_desc[chan].name, - l1h->trx->nr, tn, fn); + l1t->trx->nr, tn, fn); goto free_bad_msg; } break; @@ -924,7 +939,7 @@ inval_mode1: LOGP(DL1C, LOGL_NOTICE, "%s Transmitting 'bad " "FR frame' trx=%u ts=%u at fn=%u.\n", trx_chan_desc[chan].name, - l1h->trx->nr, tn, fn); + l1t->trx->nr, tn, fn); goto free_bad_msg; } break; @@ -937,7 +952,7 @@ inval_mode1: LOGP(DL1C, LOGL_NOTICE, "%s Transmitting 'bad " "EFR frame' trx=%u ts=%u at fn=%u.\n", trx_chan_desc[chan].name, - l1h->trx->nr, tn, fn); + l1t->trx->nr, tn, fn); goto free_bad_msg; } break; @@ -966,7 +981,7 @@ inval_mode1: " of RTP frame not in list. " "trx=%u ts=%u\n", trx_chan_desc[chan].name, ft_codec, - l1h->trx->nr, tn); + l1t->trx->nr, tn); goto free_bad_msg; } if (codec_mode_request && chan_state->dl_ft != ft) { @@ -974,7 +989,7 @@ inval_mode1: " of RTP cannot be changed now, but in " "next frame. trx=%u ts=%u\n", trx_chan_desc[chan].name, ft_codec, - l1h->trx->nr, tn); + l1t->trx->nr, tn); goto free_bad_msg; } chan_state->dl_ft = ft; @@ -982,7 +997,7 @@ inval_mode1: LOGP(DL1C, LOGL_NOTICE, "%s Transmitting 'bad " "AMR frame' trx=%u ts=%u at fn=%u.\n", trx_chan_desc[chan].name, - l1h->trx->nr, tn, fn); + l1t->trx->nr, tn, fn); goto free_bad_msg; } break; @@ -1014,11 +1029,13 @@ send_frame: *_msg_facch = msg_facch; } -static ubit_t *tx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_tchf_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid) { struct msgb *msg_tch = NULL, *msg_facch = NULL; - struct trx_chan_state *chan_state = &l1h->chan_states[tn][chan]; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct gsm_bts_trx_ts *ts = &l1t->trx->ts[tn]; + struct l1sched_chan_state *chan_state = &l1ts->chan_state[chan]; uint8_t tch_mode = chan_state->tch_mode; ubit_t *burst, **bursts_p = &chan_state->dl_bursts; static ubit_t bits[148]; @@ -1030,7 +1047,7 @@ static ubit_t *tx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, goto send_burst; } - tx_tch_common(l1h, tn, fn, chan, bid, &msg_tch, &msg_facch, + tx_tch_common(l1t, tn, fn, chan, bid, &msg_tch, &msg_facch, (((fn + 4) % 26) >> 2) & 1); /* alloc burst memory, if not already, @@ -1048,7 +1065,7 @@ static ubit_t *tx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, if (!msg_tch && !msg_facch) { LOGP(DL1C, LOGL_INFO, "%s has not been served !! No prim for " "trx=%u ts=%u at fn=%u to transmit.\n", - trx_chan_desc[chan].name, l1h->trx->nr, tn, fn); + trx_chan_desc[chan].name, l1t->trx->nr, tn, fn); goto send_burst; } @@ -1079,21 +1096,23 @@ send_burst: burst = *bursts_p + bid * 116; memset(bits, 0, 3); memcpy(bits + 3, burst, 58); - memcpy(bits + 61, tsc[l1h->config.tsc], 26); + memcpy(bits + 61, tsc[gsm_ts_tsc(ts)], 26); memcpy(bits + 87, burst + 58, 58); memset(bits + 145, 0, 3); LOGP(DL1C, LOGL_DEBUG, "Transmitting %s fn=%u ts=%u trx=%u burst=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr, bid); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr, bid); return bits; } -static ubit_t *tx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static ubit_t *tx_tchh_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid) { struct msgb *msg_tch = NULL, *msg_facch = NULL; - struct trx_chan_state *chan_state = &l1h->chan_states[tn][chan]; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct gsm_bts_trx_ts *ts = &l1t->trx->ts[tn]; + struct l1sched_chan_state *chan_state = &l1ts->chan_state[chan]; uint8_t tch_mode = chan_state->tch_mode; ubit_t *burst, **bursts_p = &chan_state->dl_bursts; static ubit_t bits[148]; @@ -1106,7 +1125,7 @@ static ubit_t *tx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, } /* get TCH and/or FACCH */ - tx_tch_common(l1h, tn, fn, chan, bid, &msg_tch, &msg_facch, + tx_tch_common(l1t, tn, fn, chan, bid, &msg_tch, &msg_facch, (((fn + 4) % 26) >> 2) & 1); /* check for FACCH alignment */ @@ -1138,7 +1157,7 @@ static ubit_t *tx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, if (!msg_tch && !msg_facch && !chan_state->dl_ongoing_facch) { LOGP(DL1C, LOGL_INFO, "%s has not been served !! No prim for " "trx=%u ts=%u at fn=%u to transmit.\n", - trx_chan_desc[chan].name, l1h->trx->nr, tn, fn); + trx_chan_desc[chan].name, l1t->trx->nr, tn, fn); goto send_burst; } @@ -1171,12 +1190,12 @@ send_burst: burst = *bursts_p + bid * 116; memset(bits, 0, 3); memcpy(bits + 3, burst, 58); - memcpy(bits + 61, tsc[l1h->config.tsc], 26); + memcpy(bits + 61, tsc[gsm_ts_tsc(ts)], 26); memcpy(bits + 87, burst + 58, 58); memset(bits + 145, 0, 3); LOGP(DL1C, LOGL_DEBUG, "Transmitting %s fn=%u ts=%u trx=%u burst=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr, bid); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr, bid); return bits; } @@ -1186,7 +1205,7 @@ send_burst: * RX on uplink (indication to upper layer) */ -static int rx_rach_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rx_rach_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa) { @@ -1201,7 +1220,7 @@ static int rx_rach_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, trx_chan_desc[chan].name, fn, toa); /* decode */ - rc = rach_decode(&ra, bits + 8 + 41, l1h->trx->bts->bsic); + rc = rach_decode(&ra, bits + 8 + 41, l1t->trx->bts->bsic); if (rc) { LOGP(DL1C, LOGL_NOTICE, "Received bad AB frame at fn=%u " "(%u/51)\n", fn, fn % 51); @@ -1223,17 +1242,18 @@ static int rx_rach_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, l1sap.u.rach_ind.fn = fn; /* forward primitive */ - l1sap_up(l1h->trx, &l1sap); + l1sap_up(l1t->trx, &l1sap); return 0; } /*! \brief a single burst was received by the PHY, process it */ -static int rx_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rx_data_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa) { - struct trx_chan_state *chan_state = &l1h->chan_states[tn][chan]; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct l1sched_chan_state *chan_state = &l1ts->chan_state[chan]; sbit_t *burst, **bursts_p = &chan_state->ul_bursts; uint32_t *first_fn = &chan_state->ul_first_fn; uint8_t *mask = &chan_state->ul_mask; @@ -1247,10 +1267,10 @@ static int rx_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, /* handle rach, if handover rach detection is turned on */ if (chan_state->ho_rach_detect == 1) - return rx_rach_fn(l1h, tn, fn, chan, bid, bits, rssi, toa); + return rx_rach_fn(l1t, tn, fn, chan, bid, bits, rssi, toa); LOGP(DL1C, LOGL_DEBUG, "Data received %s fn=%u ts=%u trx=%u bid=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr, bid); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr, bid); /* alloc burst memory, if not already */ if (!*bursts_p) { @@ -1284,7 +1304,7 @@ static int rx_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, /* send burst information to loops process */ if (L1SAP_IS_LINK_SACCH(trx_chan_desc[chan].link_id)) { - trx_loop_sacch_input(l1h, trx_chan_desc[chan].chan_nr | tn, + trx_loop_sacch_input(l1t, trx_chan_desc[chan].chan_nr | tn, chan_state, rssi, toa); } @@ -1296,7 +1316,7 @@ static int rx_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, if ((*mask & 0xf) != 0xf) { LOGP(DL1C, LOGL_NOTICE, "Received incomplete data frame at " "fn=%u (%u/%u) for %s\n", *first_fn, - (*first_fn) % l1h->mf_period[tn], l1h->mf_period[tn], + (*first_fn) % l1ts->mf_period, l1ts->mf_period, trx_chan_desc[chan].name); /* we require first burst to have correct FN */ @@ -1312,24 +1332,25 @@ static int rx_data_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, if (rc) { LOGP(DL1C, LOGL_NOTICE, "Received bad data frame at fn=%u " "(%u/%u) for %s\n", *first_fn, - (*first_fn) % l1h->mf_period[tn], l1h->mf_period[tn], + (*first_fn) % l1ts->mf_period, l1ts->mf_period, trx_chan_desc[chan].name); l2_len = 0; } else l2_len = GSM_MACBLOCK_LEN; /* Send uplnk measurement information to L2 */ - l1if_process_meas_res(l1h->trx, tn, fn, trx_chan_desc[chan].chan_nr | tn, + l1if_process_meas_res(l1t->trx, tn, fn, trx_chan_desc[chan].chan_nr | tn, n_errors, n_bits_total, *rssi_sum / *rssi_num, *toa_sum / *toa_num); - return compose_ph_data_ind(l1h, tn, *first_fn, chan, l2, l2_len, *rssi_sum / *rssi_num); + return compose_ph_data_ind(l1t, tn, *first_fn, chan, l2, l2_len, *rssi_sum / *rssi_num); } -static int rx_pdtch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rx_pdtch_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa) { - struct trx_chan_state *chan_state = &l1h->chan_states[tn][chan]; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct l1sched_chan_state *chan_state = &l1ts->chan_state[chan]; sbit_t *burst, **bursts_p = &chan_state->ul_bursts; uint8_t *mask = &chan_state->ul_mask; float *rssi_sum = &chan_state->rssi_sum; @@ -1341,7 +1362,7 @@ static int rx_pdtch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, int rc; LOGP(DL1C, LOGL_DEBUG, "PDTCH received %s fn=%u ts=%u trx=%u bid=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr, bid); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr, bid); /* alloc burst memory, if not already */ if (!*bursts_p) { @@ -1380,7 +1401,7 @@ static int rx_pdtch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, if ((*mask & 0xf) != 0xf) { LOGP(DL1C, LOGL_NOTICE, "Received incomplete PDTCH block " "ending at fn=%u (%u/%u) for %s\n", fn, - fn % l1h->mf_period[tn], l1h->mf_period[tn], + fn % l1ts->mf_period, l1ts->mf_period, trx_chan_desc[chan].name); } *mask = 0x0; @@ -1389,27 +1410,28 @@ static int rx_pdtch_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, rc = pdtch_decode(l2 + 1, *bursts_p, NULL, &n_errors, &n_bits_total); /* Send uplnk measurement information to L2 */ - l1if_process_meas_res(l1h->trx, tn, fn, trx_chan_desc[chan].chan_nr | tn, + l1if_process_meas_res(l1t->trx, tn, fn, trx_chan_desc[chan].chan_nr | tn, n_errors, n_bits_total, *rssi_sum / *rssi_num, *toa_sum / *toa_num); if (rc <= 0) { LOGP(DL1C, LOGL_NOTICE, "Received bad PDTCH block ending at " - "fn=%u (%u/%u) for %s\n", fn, fn % l1h->mf_period[tn], - l1h->mf_period[tn], trx_chan_desc[chan].name); + "fn=%u (%u/%u) for %s\n", fn, fn % l1ts->mf_period, + l1ts->mf_period, trx_chan_desc[chan].name); return 0; } l2[0] = 7; /* valid frame */ - return compose_ph_data_ind(l1h, tn, (fn + GSM_HYPERFRAME - 3) % GSM_HYPERFRAME, chan, + return compose_ph_data_ind(l1t, tn, (fn + GSM_HYPERFRAME - 3) % GSM_HYPERFRAME, chan, l2, rc + 1, *rssi_sum / *rssi_num); } -static int rx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rx_tchf_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa) { - struct trx_chan_state *chan_state = &l1h->chan_states[tn][chan]; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct l1sched_chan_state *chan_state = &l1ts->chan_state[chan]; sbit_t *burst, **bursts_p = &chan_state->ul_bursts; uint8_t *mask = &chan_state->ul_mask; uint8_t rsl_cmode = chan_state->rsl_cmode; @@ -1420,10 +1442,10 @@ static int rx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, /* handle rach, if handover rach detection is turned on */ if (chan_state->ho_rach_detect == 1) - return rx_rach_fn(l1h, tn, fn, chan, bid, bits, rssi, toa); + return rx_rach_fn(l1t, tn, fn, chan, bid, bits, rssi, toa); LOGP(DL1C, LOGL_DEBUG, "TCH/F received %s fn=%u ts=%u trx=%u bid=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr, bid); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr, bid); /* alloc burst memory, if not already */ if (!*bursts_p) { @@ -1454,7 +1476,7 @@ static int rx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, if ((*mask & 0xf) != 0xf) { LOGP(DL1C, LOGL_NOTICE, "Received incomplete TCH frame ending " "at fn=%u (%u/%u) for %s\n", fn, - fn % l1h->mf_period[tn], l1h->mf_period[tn], + fn % l1ts->mf_period, l1ts->mf_period, trx_chan_desc[chan].name); } *mask = 0x0; @@ -1479,7 +1501,7 @@ static int rx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, chan_state->codecs, &chan_state->ul_ft, &chan_state->ul_cmr, &n_errors, &n_bits_total); if (rc) - trx_loop_amr_input(l1h, + trx_loop_amr_input(l1t, trx_chan_desc[chan].chan_nr | tn, chan_state, (float)n_errors/(float)n_bits_total); amr = 2; /* we store tch_data + 2 header bytes */ @@ -1498,7 +1520,7 @@ static int rx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, memcpy(*bursts_p, *bursts_p + 464, 464); /* Send uplnk measurement information to L2 */ - l1if_process_meas_res(l1h->trx, tn, fn, trx_chan_desc[chan].chan_nr|tn, + l1if_process_meas_res(l1t->trx, tn, fn, trx_chan_desc[chan].chan_nr|tn, n_errors, n_bits_total, rssi, toa); /* Check if the frame is bad */ @@ -1516,7 +1538,7 @@ static int rx_tchf_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, /* FACCH */ if (rc == GSM_MACBLOCK_LEN) { - compose_ph_data_ind(l1h, tn, (fn + GSM_HYPERFRAME - 7) % GSM_HYPERFRAME, chan, + compose_ph_data_ind(l1t, tn, (fn + GSM_HYPERFRAME - 7) % GSM_HYPERFRAME, chan, tch_data + amr, GSM_MACBLOCK_LEN, rssi); bfi: if (rsl_cmode == RSL_CMOD_SPD_SPEECH) { @@ -1551,15 +1573,16 @@ bfi: return 0; /* TCH or BFI */ - return compose_tch_ind(l1h, tn, (fn + GSM_HYPERFRAME - 7) % GSM_HYPERFRAME, chan, + return compose_tch_ind(l1t, tn, (fn + GSM_HYPERFRAME - 7) % GSM_HYPERFRAME, chan, tch_data, rc); } -static int rx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +static int rx_tchh_fn(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, enum trx_chan_type chan, uint8_t bid, sbit_t *bits, int8_t rssi, float toa) { - struct trx_chan_state *chan_state = &l1h->chan_states[tn][chan]; + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct l1sched_chan_state *chan_state = &l1ts->chan_state[chan]; sbit_t *burst, **bursts_p = &chan_state->ul_bursts; uint8_t *mask = &chan_state->ul_mask; uint8_t rsl_cmode = chan_state->rsl_cmode; @@ -1570,10 +1593,10 @@ static int rx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, /* handle rach, if handover rach detection is turned on */ if (chan_state->ho_rach_detect == 1) - return rx_rach_fn(l1h, tn, fn, chan, bid, bits, rssi, toa); + return rx_rach_fn(l1t, tn, fn, chan, bid, bits, rssi, toa); LOGP(DL1C, LOGL_DEBUG, "TCH/H received %s fn=%u ts=%u trx=%u bid=%u\n", - trx_chan_desc[chan].name, fn, tn, l1h->trx->nr, bid); + trx_chan_desc[chan].name, fn, tn, l1t->trx->nr, bid); /* alloc burst memory, if not already */ if (!*bursts_p) { @@ -1604,7 +1627,7 @@ static int rx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, if ((*mask & 0x3) != 0x3) { LOGP(DL1C, LOGL_NOTICE, "Received incomplete TCH frame ending " "at fn=%u (%u/%u) for %s\n", fn, - fn % l1h->mf_period[tn], l1h->mf_period[tn], + fn % l1ts->mf_period, l1ts->mf_period, trx_chan_desc[chan].name); } *mask = 0x0; @@ -1641,7 +1664,7 @@ static int rx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, chan_state->codecs, &chan_state->ul_ft, &chan_state->ul_cmr, &n_errors, &n_bits_total); if (rc) - trx_loop_amr_input(l1h, + trx_loop_amr_input(l1t, trx_chan_desc[chan].chan_nr | tn, chan_state, (float)n_errors/(float)n_bits_total); amr = 2; /* we store tch_data + 2 two */ @@ -1661,7 +1684,7 @@ static int rx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, memcpy(*bursts_p + 232, *bursts_p + 464, 232); /* Send uplnk measurement information to L2 */ - l1if_process_meas_res(l1h->trx, tn, fn, trx_chan_desc[chan].chan_nr|tn, + l1if_process_meas_res(l1t->trx, tn, fn, trx_chan_desc[chan].chan_nr|tn, n_errors, n_bits_total, rssi, toa); /* Check if the frame is bad */ @@ -1680,7 +1703,7 @@ static int rx_tchh_fn(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, /* FACCH */ if (rc == GSM_MACBLOCK_LEN) { chan_state->ul_ongoing_facch = 1; - compose_ph_data_ind(l1h, tn, + compose_ph_data_ind(l1t, tn, (fn + GSM_HYPERFRAME - 10 - ((fn % 26) >= 19)) % GSM_HYPERFRAME, chan, tch_data + amr, GSM_MACBLOCK_LEN, rssi); bfi: @@ -1718,7 +1741,7 @@ bfi: * with the slot 12, so an extra FN must be substracted to get correct * start of frame. */ - return compose_tch_ind(l1h, tn, + return compose_tch_ind(l1t, tn, (fn + GSM_HYPERFRAME - 10 - ((fn%26)==19) - ((fn%26)==20)) % GSM_HYPERFRAME, chan, tch_data, rc); } @@ -2487,61 +2510,59 @@ static const struct trx_sched_multiframe trx_sched_multiframes[] = { */ /* set multiframe scheduler to given pchan */ -int trx_sched_set_pchan(struct trx_l1h *l1h, uint8_t tn, +int trx_sched_set_pchan(struct l1sched_trx *l1t, uint8_t tn, enum gsm_phys_chan_config pchan) { + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); int i; - /* ignore disabled slots */ - if (!(l1h->config.slotmask & (1 << tn))) - return -ENOTSUP; - for (i = 0; i < ARRAY_SIZE(trx_sched_multiframes); i++) { if (trx_sched_multiframes[i].pchan == pchan && (trx_sched_multiframes[i].slotmask & (1 << tn))) { - l1h->mf_index[tn] = i; - l1h->mf_period[tn] = trx_sched_multiframes[i].period; - l1h->mf_frames[tn] = trx_sched_multiframes[i].frames; + l1ts->mf_index = i; + l1ts->mf_period = trx_sched_multiframes[i].period; + l1ts->mf_frames = trx_sched_multiframes[i].frames; LOGP(DL1C, LOGL_NOTICE, "Configuring multiframe with " "%s trx=%d ts=%d\n", trx_sched_multiframes[i].name, - l1h->trx->nr, tn); + l1t->trx->nr, tn); return 0; } } LOGP(DL1C, LOGL_NOTICE, "Failed to configuring multiframe " - "trx=%d ts=%d\n", l1h->trx->nr, tn); + "trx=%d ts=%d\n", l1t->trx->nr, tn); return -ENOTSUP; } /* setting all logical channels given attributes to active/inactive */ -int trx_sched_set_lchan(struct trx_l1h *l1h, uint8_t chan_nr, uint8_t link_id, +int trx_sched_set_lchan(struct l1sched_trx *l1t, uint8_t chan_nr, uint8_t link_id, int active) { uint8_t tn = L1SAP_CHAN2TS(chan_nr); + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); uint8_t ss = l1sap_chan2ss(chan_nr); int i; int rc = -EINVAL; - struct trx_chan_state *chan_state; /* look for all matching chan_nr/link_id */ for (i = 0; i < _TRX_CHAN_MAX; i++) { + struct l1sched_chan_state *chan_state; + chan_state = &l1ts->chan_state[i]; /* skip if pchan type does not match pdch flag */ - if ((trx_sched_multiframes[l1h->mf_index[tn]].pchan + if ((trx_sched_multiframes[l1ts->mf_index].pchan == GSM_PCHAN_PDCH) != trx_chan_desc[i].pdch) continue; if (trx_chan_desc[i].chan_nr == (chan_nr & 0xf8) && trx_chan_desc[i].link_id == link_id) { - chan_state = &l1h->chan_states[tn][i]; rc = 0; if (chan_state->active == active) continue; LOGP(DL1C, LOGL_NOTICE, "%s %s on trx=%d ts=%d\n", (active) ? "Activating" : "Deactivating", - trx_chan_desc[i].name, l1h->trx->nr, tn); + trx_chan_desc[i].name, l1t->trx->nr, tn); if (active) memset(chan_state, 0, sizeof(*chan_state)); chan_state->active = active; @@ -2554,12 +2575,14 @@ int trx_sched_set_lchan(struct trx_l1h *l1h, uint8_t chan_nr, uint8_t link_id, talloc_free(chan_state->ul_bursts); chan_state->ul_bursts = NULL; } + if (!active) + chan_state->ho_rach_detect = 0; } } /* disable handover detection (on deactivation) */ - if (l1h->ho_rach_detect[tn][ss]) { - l1h->ho_rach_detect[tn][ss] = 0; + if (!active) { + struct trx_l1h *l1h = trx_l1h_hdl(l1t->trx); trx_if_cmd_nohandover(l1h, tn, ss); } @@ -2567,28 +2590,30 @@ int trx_sched_set_lchan(struct trx_l1h *l1h, uint8_t chan_nr, uint8_t link_id, } /* setting all logical channels given attributes to active/inactive */ -int trx_sched_set_mode(struct trx_l1h *l1h, uint8_t chan_nr, uint8_t rsl_cmode, +int trx_sched_set_mode(struct l1sched_trx *l1t, uint8_t chan_nr, uint8_t rsl_cmode, uint8_t tch_mode, int codecs, uint8_t codec0, uint8_t codec1, uint8_t codec2, uint8_t codec3, uint8_t initial_id, uint8_t handover) { uint8_t tn = L1SAP_CHAN2TS(chan_nr); + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct trx_l1h *l1h = trx_l1h_hdl(l1t->trx); uint8_t ss = l1sap_chan2ss(chan_nr); int i; int rc = -EINVAL; - struct trx_chan_state *chan_state; + struct l1sched_chan_state *chan_state; /* no mode for PDCH */ - if (trx_sched_multiframes[l1h->mf_index[tn]].pchan == GSM_PCHAN_PDCH) + if (trx_sched_multiframes[l1ts->mf_index].pchan == GSM_PCHAN_PDCH) return 0; /* look for all matching chan_nr/link_id */ for (i = 0; i < _TRX_CHAN_MAX; i++) { if (trx_chan_desc[i].chan_nr == (chan_nr & 0xf8) && trx_chan_desc[i].link_id == 0x00) { - chan_state = &l1h->chan_states[tn][i]; + chan_state = &l1ts->chan_state[i]; LOGP(DL1C, LOGL_NOTICE, "Set mode %u, %u, handover %u " "on %s of trx=%d ts=%d\n", rsl_cmode, tch_mode, - handover, trx_chan_desc[i].name, l1h->trx->nr, + handover, trx_chan_desc[i].name, l1t->trx->nr, tn); chan_state->rsl_cmode = rsl_cmode; chan_state->tch_mode = tch_mode; @@ -2617,10 +2642,8 @@ int trx_sched_set_mode(struct trx_l1h *l1h, uint8_t chan_nr, uint8_t rsl_cmode, * disable handover, if state is still set, since we might not know * the actual state of transceiver (due to loss of link) */ if (handover) { - l1h->ho_rach_detect[tn][ss] = 1; trx_if_cmd_handover(l1h, tn, ss); - } else if (l1h->ho_rach_detect[tn][ss]) { - l1h->ho_rach_detect[tn][ss] = 0; + } else { trx_if_cmd_nohandover(l1h, tn, ss); } @@ -2628,16 +2651,17 @@ int trx_sched_set_mode(struct trx_l1h *l1h, uint8_t chan_nr, uint8_t rsl_cmode, } /* setting cipher on logical channels */ -int trx_sched_set_cipher(struct trx_l1h *l1h, uint8_t chan_nr, int downlink, +int trx_sched_set_cipher(struct l1sched_trx *l1t, uint8_t chan_nr, int downlink, int algo, uint8_t *key, int key_len) { uint8_t tn = L1SAP_CHAN2TS(chan_nr); + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); int i; int rc = -EINVAL; - struct trx_chan_state *chan_state; + struct l1sched_chan_state *chan_state; /* no cipher for PDCH */ - if (trx_sched_multiframes[l1h->mf_index[tn]].pchan == GSM_PCHAN_PDCH) + if (trx_sched_multiframes[l1ts->mf_index].pchan == GSM_PCHAN_PDCH) return 0; /* no algorithm given means a5/0 */ @@ -2655,11 +2679,11 @@ int trx_sched_set_cipher(struct trx_l1h *l1h, uint8_t chan_nr, int downlink, if (trx_chan_desc[i].pdch) continue; if (trx_chan_desc[i].chan_nr == (chan_nr & 0xf8)) { - chan_state = &l1h->chan_states[tn][i]; + chan_state = &l1ts->chan_state[i]; LOGP(DL1C, LOGL_NOTICE, "Set a5/%d %s for %s on trx=%d " "ts=%d\n", algo, (downlink) ? "downlink" : "uplink", - trx_chan_desc[i].name, l1h->trx->nr, tn); + trx_chan_desc[i].name, l1t->trx->nr, tn); if (downlink) { chan_state->dl_encr_algo = algo; memcpy(chan_state->dl_encr_key, key, key_len); @@ -2677,21 +2701,22 @@ int trx_sched_set_cipher(struct trx_l1h *l1h, uint8_t chan_nr, int downlink, } /* process ready-to-send */ -static int trx_sched_rts(struct trx_l1h *l1h, uint8_t tn, uint32_t fn) +static int trx_sched_rts(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn) { + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); const struct trx_sched_frame *frame; uint8_t offset, period, bid; trx_sched_rts_func *func; enum trx_chan_type chan; /* no multiframe set */ - if (!l1h->mf_index[tn]) + if (!l1ts->mf_index) return 0; /* get frame from multiframe */ - period = l1h->mf_period[tn]; + period = l1ts->mf_period; offset = fn % period; - frame = l1h->mf_frames[tn] + offset; + frame = l1ts->mf_frames + offset; chan = frame->dl_chan; bid = frame->dl_bid; @@ -2707,49 +2732,51 @@ static int trx_sched_rts(struct trx_l1h *l1h, uint8_t tn, uint32_t fn) /* check if channel is active */ if (!trx_chan_desc[chan].auto_active - && !l1h->chan_states[tn][chan].active) + && !l1ts->chan_state[chan].active) return -EINVAL; - return func(l1h, tn, fn, frame->dl_chan); + return func(l1t, tn, fn, frame->dl_chan); } /* process downlink burst */ -static const ubit_t *trx_sched_dl_burst(struct trx_l1h *l1h, uint8_t tn, +static const ubit_t *trx_sched_dl_burst(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn) { + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct l1sched_chan_state *l1cs; const struct trx_sched_frame *frame; uint8_t offset, period, bid; trx_sched_dl_func *func; enum trx_chan_type chan; ubit_t *bits = NULL; - if (!l1h->mf_index[tn]) + if (!l1ts->mf_index) goto no_data; /* get frame from multiframe */ - period = l1h->mf_period[tn]; + period = l1ts->mf_period; offset = fn % period; - frame = l1h->mf_frames[tn] + offset; + frame = l1ts->mf_frames + offset; chan = frame->dl_chan; bid = frame->dl_bid; func = trx_chan_desc[chan].dl_fn; + l1cs = &l1ts->chan_state[chan]; + /* check if channel is active */ - if (!trx_chan_desc[chan].auto_active - && !l1h->chan_states[tn][chan].active) + if (!trx_chan_desc[chan].auto_active && !l1cs->active) goto no_data; /* get burst from function */ - bits = func(l1h, tn, fn, chan, bid); + bits = func(l1t, tn, fn, chan, bid); /* encrypt */ - if (bits && l1h->chan_states[tn][chan].dl_encr_algo) { + if (bits && l1cs->dl_encr_algo) { ubit_t ks[114]; int i; - osmo_a5(l1h->chan_states[tn][chan].dl_encr_algo, - l1h->chan_states[tn][chan].dl_encr_key, fn, ks, NULL); + osmo_a5(l1cs->dl_encr_algo, l1cs->dl_encr_key, fn, ks, NULL); for (i = 0; i < 57; i++) { bits[i + 3] ^= ks[i]; bits[i + 88] ^= ks[i + 57]; @@ -2758,7 +2785,7 @@ static const ubit_t *trx_sched_dl_burst(struct trx_l1h *l1h, uint8_t tn, no_data: /* in case of C0, we need a dummy burst to maintain RF power */ - if (bits == NULL && l1h->trx == l1h->trx->bts->c0) { + if (bits == NULL && l1t->trx == l1t->trx->bts->c0) { if (0) if (chan != TRXC_IDLE) // hack LOGP(DL1C, LOGL_DEBUG, "No burst data for %s fn=%u ts=%u " "burst=%d on C0, so filling with dummy burst\n", @@ -2770,41 +2797,44 @@ if (0) if (chan != TRXC_IDLE) // hack } /* process uplink burst */ -int trx_sched_ul_burst(struct trx_l1h *l1h, uint8_t tn, uint32_t current_fn, +int trx_sched_ul_burst(struct l1sched_trx *l1t, uint8_t tn, uint32_t current_fn, sbit_t *bits, int8_t rssi, float toa) { + struct l1sched_ts *l1ts = l1sched_trx_get_ts(l1t, tn); + struct l1sched_chan_state *l1cs; const struct trx_sched_frame *frame; uint8_t offset, period, bid; trx_sched_ul_func *func; enum trx_chan_type chan; uint32_t fn, elapsed; - if (!l1h->mf_index[tn]) + if (!l1ts->mf_index) return -EINVAL; /* calculate how many frames have been elapsed */ - elapsed = (current_fn + GSM_HYPERFRAME - l1h->mf_last_fn[tn]) % GSM_HYPERFRAME; + elapsed = (current_fn + GSM_HYPERFRAME - l1ts->mf_last_fn) % GSM_HYPERFRAME; /* start counting from last fn + 1, but only if not too many fn have * been elapsed */ if (elapsed < 10) - fn = (l1h->mf_last_fn[tn] + 1) % GSM_HYPERFRAME; + fn = (l1ts->mf_last_fn + 1) % GSM_HYPERFRAME; else fn = current_fn; while (42) { /* get frame from multiframe */ - period = l1h->mf_period[tn]; + period = l1ts->mf_period; offset = fn % period; - frame = l1h->mf_frames[tn] + offset; + frame = l1ts->mf_frames + offset; chan = frame->ul_chan; bid = frame->ul_bid; func = trx_chan_desc[chan].ul_fn; + l1cs = &l1ts->chan_state[chan]; + /* check if channel is active */ - if (!trx_chan_desc[chan].auto_active - && !l1h->chan_states[tn][chan].active) + if (!trx_chan_desc[chan].auto_active && !l1cs->active) goto next_frame; /* omit bursts which have no handler, like IDLE bursts */ @@ -2814,12 +2844,12 @@ int trx_sched_ul_burst(struct trx_l1h *l1h, uint8_t tn, uint32_t current_fn, /* put burst to function */ if (fn == current_fn) { /* decrypt */ - if (bits && l1h->chan_states[tn][chan].ul_encr_algo) { + if (bits && l1cs->ul_encr_algo) { ubit_t ks[114]; int i; - osmo_a5(l1h->chan_states[tn][chan].ul_encr_algo, - l1h->chan_states[tn][chan].ul_encr_key, + osmo_a5(l1cs->ul_encr_algo, + l1cs->ul_encr_key, fn, NULL, ks); for (i = 0; i < 57; i++) { if (ks[i]) @@ -2829,13 +2859,12 @@ int trx_sched_ul_burst(struct trx_l1h *l1h, uint8_t tn, uint32_t current_fn, } } - func(l1h, tn, fn, chan, bid, bits, rssi, toa); - } else if (chan != TRXC_RACH - && !l1h->chan_states[tn][chan].ho_rach_detect) { + func(l1t, tn, fn, chan, bid, bits, rssi, toa); + } else if (chan != TRXC_RACH && !l1cs->ho_rach_detect) { sbit_t spare[148]; memset(spare, 0, 148); - func(l1h, tn, fn, chan, bid, spare, -128, 0); + func(l1t, tn, fn, chan, bid, spare, -128, 0); } next_frame: @@ -2846,7 +2875,7 @@ next_frame: fn = (fn + 1) % GSM_HYPERFRAME; } - l1h->mf_last_fn[tn] = fn; + l1ts->mf_last_fn = fn; return 0; } @@ -2855,7 +2884,6 @@ next_frame: static int trx_sched_fn(uint32_t fn) { struct gsm_bts_trx *trx; - struct trx_l1h *l1h; uint8_t tn; const ubit_t *bits; uint8_t gain; @@ -2869,22 +2897,20 @@ static int trx_sched_fn(uint32_t fn) /* process every TRX */ llist_for_each_entry(trx, &bts->trx_list, list) { - l1h = trx_l1h_hdl(trx); + struct trx_l1h *l1h = trx_l1h_hdl(trx); + struct l1sched_trx *l1t = trx_l1sched_hdl(trx); /* we don't schedule, if power is off */ if (!l1h->config.poweron) continue; /* process every TS of TRX */ - for (tn = 0; tn < TRX_NR_TS; tn++) { - /* ignore disabled slots */ - if (!(l1h->config.slotmask & (1 << tn))) - continue; + for (tn = 0; tn < ARRAY_SIZE(l1t->ts); tn++) { /* ready-to-send */ - trx_sched_rts(l1h, tn, + trx_sched_rts(l1t, tn, (fn + trx_rts_advance) % GSM_HYPERFRAME); /* get burst for FN */ - bits = trx_sched_dl_burst(l1h, tn, fn); + bits = trx_sched_dl_burst(l1t, tn, fn); if (!bits) { /* if no bits, send no burst */ continue; @@ -2910,6 +2936,7 @@ extern int quit; /* this timer fires for every FN to be processed */ static void trx_ctrl_timer_cb(void *data) { + struct gsm_bts *bts = data; struct timeval tv_now, *tv_clock = &transceiver_clock_tv; int32_t elapsed; @@ -2926,7 +2953,7 @@ no_clock: /* close all logical channels and reset timeslots */ llist_for_each_entry(trx, &bts->trx_list, list) { trx_if_flush(trx_l1h_hdl(trx)); - trx_sched_reset(trx_l1h_hdl(trx)); + trx_sched_reset(trx_l1sched_hdl(trx)); if (trx->nr == 0) trx_if_cmd_poweroff(trx_l1h_hdl(trx)); } @@ -3061,3 +3088,8 @@ new_clock: return 0; } +struct l1sched_ts *l1sched_trx_get_ts(struct l1sched_trx *l1t, uint8_t tn) +{ + OSMO_ASSERT(tn < ARRAY_SIZE(l1t->ts)); + return &l1t->ts[tn]; +} diff --git a/src/osmo-bts-trx/scheduler.h b/src/osmo-bts-trx/scheduler.h index 3e30693..c153b9e 100644 --- a/src/osmo-bts-trx/scheduler.h +++ b/src/osmo-bts-trx/scheduler.h @@ -1,6 +1,129 @@ #ifndef TRX_SCHEDULER_H #define TRX_SCHEDULER_H +/* These types define the different channels on a multiframe. + * Each channel has queues and can be activated individually. + */ +enum trx_chan_type { + TRXC_IDLE = 0, + TRXC_FCCH, + TRXC_SCH, + TRXC_BCCH, + TRXC_RACH, + TRXC_CCCH, + TRXC_TCHF, + TRXC_TCHH_0, + TRXC_TCHH_1, + TRXC_SDCCH4_0, + TRXC_SDCCH4_1, + TRXC_SDCCH4_2, + TRXC_SDCCH4_3, + TRXC_SDCCH8_0, + TRXC_SDCCH8_1, + TRXC_SDCCH8_2, + TRXC_SDCCH8_3, + TRXC_SDCCH8_4, + TRXC_SDCCH8_5, + TRXC_SDCCH8_6, + TRXC_SDCCH8_7, + TRXC_SACCHTF, + TRXC_SACCHTH_0, + TRXC_SACCHTH_1, + TRXC_SACCH4_0, + TRXC_SACCH4_1, + TRXC_SACCH4_2, + TRXC_SACCH4_3, + TRXC_SACCH8_0, + TRXC_SACCH8_1, + TRXC_SACCH8_2, + TRXC_SACCH8_3, + TRXC_SACCH8_4, + TRXC_SACCH8_5, + TRXC_SACCH8_6, + TRXC_SACCH8_7, + TRXC_PDTCH, + TRXC_PTCCH, + _TRX_CHAN_MAX +}; + +/* States each channel on a multiframe */ +struct l1sched_chan_state { + /* scheduler */ + uint8_t active; /* Channel is active */ + ubit_t *dl_bursts; /* burst buffer for TX */ + sbit_t *ul_bursts; /* burst buffer for RX */ + uint32_t ul_first_fn; /* fn of first burst */ + uint8_t ul_mask; /* mask of received bursts */ + + /* RSSI / TOA */ + uint8_t rssi_num; /* number of RSSI values */ + float rssi_sum; /* sum of RSSI values */ + uint8_t toa_num; /* number of TOA values */ + float toa_sum; /* sum of TOA values */ + + /* loss detection */ + uint8_t lost; /* (SACCH) loss detection */ + + /* mode */ + uint8_t rsl_cmode, tch_mode; /* mode for TCH channels */ + + /* AMR */ + uint8_t codec[4]; /* 4 possible codecs for amr */ + int codecs; /* number of possible codecs */ + float ber_sum; /* sum of bit error rates */ + int ber_num; /* number of bit error rates */ + uint8_t ul_ft; /* current uplink FT index */ + uint8_t dl_ft; /* current downlink FT index */ + uint8_t ul_cmr; /* current uplink CMR index */ + uint8_t dl_cmr; /* current downlink CMR index */ + uint8_t amr_loop; /* if AMR loop is enabled */ + + /* TCH/H */ + uint8_t dl_ongoing_facch; /* FACCH/H on downlink */ + uint8_t ul_ongoing_facch; /* FACCH/H on uplink */ + + /* encryption */ + int ul_encr_algo; /* A5/x encry algo downlink */ + int dl_encr_algo; /* A5/x encry algo uplink */ + int ul_encr_key_len; + int dl_encr_key_len; + uint8_t ul_encr_key[MAX_A5_KEY_LEN]; + uint8_t dl_encr_key[MAX_A5_KEY_LEN]; + + /* measurements */ + struct { + uint8_t clock; /* cyclic clock counter */ + int8_t rssi[32]; /* last RSSI values */ + int rssi_count; /* received RSSI values */ + int rssi_valid_count; /* number of stored value */ + int rssi_got_burst; /* any burst received so far */ + float toa_sum; /* sum of TOA values */ + int toa_num; /* number of TOA value */ + } meas; + + /* handover */ + uint8_t ho_rach_detect; /* if rach detection is on */ +}; + +struct l1sched_ts { + uint8_t mf_index; /* selected multiframe index */ + uint32_t mf_last_fn; /* last received frame number */ + uint8_t mf_period; /* period of multiframe */ + const struct trx_sched_frame *mf_frames; /* pointer to frame layout */ + + struct llist_head dl_prims; /* Queue primitves for TX */ + + /* Channel states for all logical channels */ + struct l1sched_chan_state chan_state[_TRX_CHAN_MAX]; +}; + +struct l1sched_trx { + struct gsm_bts_trx *trx; + struct l1sched_ts ts[TRX_NR_TS]; +}; + +struct l1sched_ts *l1sched_trx_get_ts(struct l1sched_trx *l1t, uint8_t tn); + /*! \brief how many frame numbers in advance we should send bursts to PHY */ extern uint32_t trx_clock_advance; /*! \brief advance RTS.ind to L2 by that many clocks */ @@ -10,43 +133,43 @@ extern uint32_t transceiver_last_fn; /*! \brief Initialize the scheudler data structures */ -int trx_sched_init(struct trx_l1h *l1h); +int trx_sched_init(struct l1sched_trx *l1t); /*! \brief De-initialize the scheudler data structures */ -void trx_sched_exit(struct trx_l1h *l1h); +void trx_sched_exit(struct l1sched_trx *l1t); /*! \brief Handle a PH-DATA.req from L2 down to L1 */ -int trx_sched_ph_data_req(struct trx_l1h *l1h, struct osmo_phsap_prim *l1sap); +int trx_sched_ph_data_req(struct l1sched_trx *l1t, struct osmo_phsap_prim *l1sap); /*! \brief Handle a PH-TCH.req from L2 down to L1 */ -int trx_sched_tch_req(struct trx_l1h *l1h, struct osmo_phsap_prim *l1sap); +int trx_sched_tch_req(struct l1sched_trx *l1t, struct osmo_phsap_prim *l1sap); /*! \brief PHY informs us of new (current) GSM freme nunmber */ int trx_sched_clock(uint32_t fn); /*! \brief handle an UL burst received by PHY */ -int trx_sched_ul_burst(struct trx_l1h *l1h, uint8_t tn, uint32_t fn, +int trx_sched_ul_burst(struct l1sched_trx *l1t, uint8_t tn, uint32_t fn, sbit_t *bits, int8_t rssi, float toa); /*! \brief set multiframe scheduler to given physical channel config */ -int trx_sched_set_pchan(struct trx_l1h *l1h, uint8_t tn, +int trx_sched_set_pchan(struct l1sched_trx *l1t, uint8_t tn, enum gsm_phys_chan_config pchan); /*! \brief set all matching logical channels active/inactive */ -int trx_sched_set_lchan(struct trx_l1h *l1h, uint8_t chan_nr, uint8_t link_id, +int trx_sched_set_lchan(struct l1sched_trx *l1t, uint8_t chan_nr, uint8_t link_id, int active); /*! \brief set mode of all matching logical channels to given mode(s) */ -int trx_sched_set_mode(struct trx_l1h *l1h, uint8_t chan_nr, uint8_t rsl_cmode, +int trx_sched_set_mode(struct l1sched_trx *l1t, uint8_t chan_nr, uint8_t rsl_cmode, uint8_t tch_mode, int codecs, uint8_t codec0, uint8_t codec1, uint8_t codec2, uint8_t codec3, uint8_t initial_codec, uint8_t handover); /*! \brief set ciphering on given logical channels */ -int trx_sched_set_cipher(struct trx_l1h *l1h, uint8_t chan_nr, int downlink, +int trx_sched_set_cipher(struct l1sched_trx *l1t, uint8_t chan_nr, int downlink, int algo, uint8_t *key, int key_len); /* \brief close all logical channels and reset timeslots */ -void trx_sched_reset(struct trx_l1h *l1h); +void trx_sched_reset(struct l1sched_trx *l1t); #endif /* TRX_SCHEDULER_H */ diff --git a/src/osmo-bts-trx/trx_if.c b/src/osmo-bts-trx/trx_if.c index 419fea6..fef2064 100644 --- a/src/osmo-bts-trx/trx_if.c +++ b/src/osmo-bts-trx/trx_if.c @@ -454,7 +454,7 @@ static int trx_data_read_cb(struct osmo_fd *ofd, unsigned int what) fprintf(stderr, "%s\n", deb); #endif - trx_sched_ul_burst(l1h, tn, fn, bits, rssi, toa); + trx_sched_ul_burst(&l1h->l1s, tn, fn, bits, rssi, toa); return 0; } -- 2.7.0

1 6

[PATCH 0/4] Cleanup and restructure
by suraev＠alumni.ntnu.no 02 Feb '16

02 Feb '16

From: Max <msuraev(a)sysmocom.de> This is v2 of patchset to simplify new hardware support by restructuring sources, simplifying internal API and cleaining up various bits and pieces. Max (4): Cleanup build Rename define for direct hw access Restructure sources Change internal API for consistency .gitignore | 3 +- configure.ac | 2 +- src/Makefile.am | 51 +++++++++++++++++++-------------- src/{ => osmo-bts-sysmo}/femtobts.c | 0 src/{ => osmo-bts-sysmo}/femtobts.h | 0 src/{ => osmo-bts-sysmo}/sysmo_l1_fwd.c | 0 src/{ => osmo-bts-sysmo}/sysmo_l1_hw.c | 0 src/{ => osmo-bts-sysmo}/sysmo_l1_if.c | 8 +++--- src/{ => osmo-bts-sysmo}/sysmo_l1_if.h | 2 +- src/osmobts_sock.cpp | 2 +- src/pcu_l1_if.cpp | 17 ++++++----- 11 files changed, 47 insertions(+), 38 deletions(-) rename src/{ => osmo-bts-sysmo}/femtobts.c (100%) rename src/{ => osmo-bts-sysmo}/femtobts.h (100%) rename src/{ => osmo-bts-sysmo}/sysmo_l1_fwd.c (100%) rename src/{ => osmo-bts-sysmo}/sysmo_l1_hw.c (100%) rename src/{ => osmo-bts-sysmo}/sysmo_l1_if.c (98%) rename src/{ => osmo-bts-sysmo}/sysmo_l1_if.h (98%) -- 2.5.0

1 4

[PATCH 0/3] Cleanup and restructure
by suraev＠alumni.ntnu.no 02 Feb '16

02 Feb '16

From: Max <msuraev(a)sysmocom.de> This small patchset enables future hardware support by restructuring sources and cleaning up few bits here and there. Max (3): Cleanup build Rename define for direct hw access Restructure sources .gitignore | 2 ++ configure.ac | 2 +- src/Makefile.am | 51 +++++++++++++++++++-------------- src/{ => osmo-bts-sysmo}/femtobts.c | 0 src/{ => osmo-bts-sysmo}/femtobts.h | 0 src/{ => osmo-bts-sysmo}/sysmo_l1_fwd.c | 0 src/{ => osmo-bts-sysmo}/sysmo_l1_hw.c | 4 +-- src/{ => osmo-bts-sysmo}/sysmo_l1_if.c | 0 src/{ => osmo-bts-sysmo}/sysmo_l1_if.h | 0 src/osmobts_sock.cpp | 2 +- src/pcu_l1_if.cpp | 6 ++-- 11 files changed, 39 insertions(+), 28 deletions(-) rename src/{ => osmo-bts-sysmo}/femtobts.c (100%) rename src/{ => osmo-bts-sysmo}/femtobts.h (100%) rename src/{ => osmo-bts-sysmo}/sysmo_l1_fwd.c (100%) rename src/{ => osmo-bts-sysmo}/sysmo_l1_hw.c (97%) rename src/{ => osmo-bts-sysmo}/sysmo_l1_if.c (100%) rename src/{ => osmo-bts-sysmo}/sysmo_l1_if.h (100%) -- 2.5.0

3 7

cscn copyright question
by Neels Hofmeyr 01 Feb '16

01 Feb '16

Is this a proper way to copyright OsmoCSCN? I'm trying to mention both the facts that it's something new as well as that it is based on a copy-paste of OsmoNITB: /* (C) 2016 by sysmocom s.f.m.c. GmbH <info(a)sysmocom.de> * All Rights Reserved * * Based on OsmoNITB: * (C) 2008-2010 by Harald Welte <laforge(a)gnumonks.org> * (C) 2009-2012 by Holger Hans Peter Freyther <zecke(a)selfish.org> * All Rights Reserved [...] Thanks! ~Neels -- - Neels Hofmeyr <nhofmeyr(a)sysmocom.de> http://www.sysmocom.de/ ======================================================================= * sysmocom - systems for mobile communications GmbH * Alt-Moabit 93 * 10559 Berlin, Germany * Sitz / Registered office: Berlin, HRB 134158 B * Geschäftsführer / Managing Directors: Holger Freyther, Harald Welte

2 1

LCR segfault on SIP invite
by OMAR RAMADAN 01 Feb '16

01 Feb '16

I'm using LCR as a GSM <-> SIP interface and I've been trying to figure out why MO calls result in a segfault. I am running openbsc on cdc548cb and LCR on c14326641a built and run on an ubuntu 14.04 64bit. >From what I've investigated so far, the request_uri passed to sofia-sip is malformed. Has anyone seen this problem before? Would appreciate pointers. Here are the full logs and stack trace: ** LCR Version 1.14 > 000000 DEBUG (in route.c/getrulesetbyname() line 1928): ruleset main found. > 000000 DEBUG (in sip.cpp/sip_init() line 1997): SIP globals initialized > 000000 DEBUG (in gsm.cpp/mncc_socket_retry_cb() line 1443): Connected to > MNCC socket /tmp/bsc_mncc! > su_port_create(0x6ad410): epoll_create() => 0: OK > su_socket_port_init(0x6ad410, 0x7ffff7dcf880) called > su_pthread_port_init(0x6ad410, 0x7ffff7dcf880) called > nua: nua_create: entering > [New Thread 0x7ffff6c52700 (LWP 11520)] > su_port_create(0x7ffff00008c0): epoll_create() => 0: OK > su_socket_port_init(0x7ffff00008c0, 0x7ffff7dcf880) called > su_pthread_port_init(0x7ffff00008c0, 0x7ffff7dcf880) called > nua: nua_stack_init: entering > nua: nua_stack_set_params: entering > soa_create("default", 0x7ffff0001130, 0x7ffff0001230) called > soa_set_params(static::0x7ffff0001920, ...) called > soa_set_params(static::0x7ffff0001920, ...) called > nta_agent_create: initialized hash tables > nta_agent_create: initialized transports > nta_agent_create: initialized random identifiers > nta_agent_create: initialized timer > nta_agent_create: initialized resolver > tport_create(): 0x7ffff0003df0 > nta: master transport created > tport_bind_server(0x7ffff0003df0) to */127.0.0.1:5062/sip > tport_bind_server(0x7ffff0003df0): calling tport_listen for udp > tport_alloc_primary(0x7ffff0003df0): new primary tport 0x7ffff0004470 > tport_listen(0x7ffff0004470): listening at udp/127.0.0.1:5062/sip > tport_bind_server(0x7ffff0003df0): calling tport_listen for tcp > tport_alloc_primary(0x7ffff0003df0): new primary tport 0x7ffff0004910 > tport_listen(0x7ffff0004910): listening at tcp/127.0.0.1:5062/sip > nta: bound to (127.0.0.1:5062;transport=*) > nta: agent_init_via: SIP/2.0/udp 127.0.0.1:5062 (sip) > nta: agent_init_via: SIP/2.0/tcp 127.0.0.1:5062 (sip) > nta: Via fields initialized > nta: Contact header created > nua_register: Adding contact URL '127.0.0.1' to list. > nua: nua_set_params: entering > nua((nil)): sent signal r_set_params > 000000 DEBUG (in sip.cpp/sip_init_inst() line 1942): SIP interface created > (inst=0x6acce0) > nua((nil)): recv signal r_set_params > nua: nua_stack_set_params: entering > soa_set_params(static::0x7ffff0001920, ...) called > nua((nil)): event r_set_params 200 OK > LCR 1.14 started, waiting for calls... > 000000 TRACE 15.01.16 11:36:21.011 --: LCR 1.14 started, waiting for > calls... > nua: nua_application_event: entering > 000000 DEBUG (in sip.cpp/sip_callback() line 1785): Event 23 from stack > received (handle=(nil)) > 000000 DEBUG (in port.cpp/Port() line 210): new port (1) of type 0x3101, > name 'gsm-0-in' interface 'gsm' > 000000 DEBUG (in gsm.cpp/Pgsm() line 239): Created new GSMPort(gsm-0-in). > 000000 DEBUG (in gsm_bs.cpp/Pgsm_bs() line 56): Created new > GSMBSPort(gsm-0-in). > 000000 TRACE 15.01.16 11:37:28.210 CH(1): New call ref LCR<->BSC callref > new=0x8000000d > 000000 TRACE 15.01.16 11:37:28.210 CH(1): Codec negotiation LCR<->BSC > bearer capa='given by MS' speech version='Full Rate given' > 000000 TRACE 15.01.16 11:37:28.210 CH(1): MNCC_SETUP_IND LCR<->BSC > calling number=639360100037 imsi=901550000000824 dialing number=12345678 > 000000 DEBUG (in endpoint.cpp/Endpoint() line 48): EPOINT(1): Allocating > enpoint 1 and connecting it with: ioport > 000000 DEBUG (in endpoint.cpp/portlist_new() line 150): EPOINT(1) > allocating port_list, attaching to port 1 > 000000 DEBUG (in appbridge.cpp/EndpointAppBridge() line 31): Bridge > endpoint created > 000000 DEBUG (in port.cpp/epointlist_new() line 131): PORT(1) allocating > epoint_list. > 000000 TRACE 15.01.16 11:37:28.211 CH(1): MNCC_CALL_PROC_REQ LCR<->BSC > progress coding=3 location=1 descr=8 > 000000 DEBUG (in port.cpp/new_state() line 283): PORT(gsm-0-in) new state > PORT_STATE_IDLE --> PORT_STATE_IN_PROCEEDING > 000000 TRACE 15.01.16 11:37:28.211 CH(1): MNCC_FRAME_RECV LCR<->BSC > 000000 DEBUG (in gsm_bs.cpp/setup_ind() line 631): Request RTP peer info, > before forwarding setup > 000000 DEBUG (in gsm.cpp/rtp_create_ind() line 869): Got RTP peer info > (7f000001,52103) forwarding setup > 000000 DEBUG (in message.c/_message_put() line 70): message MESSAGE_SETUP > written from 140733193388033 to 140733193388033 (memory 6b1a50 at file > gsm.cpp, line 872) > 000000 DEBUG (in message.c/message_get() line 115): message MESSAGE_SETUP > reading from 1 to 140733193388033 (memory 6b1a50) > 000000 DEBUG (in appbridge.cpp/port_setup() line 94): EPOINT(1) epoint > received setup from='639360100037' to='12345678' > 000000 DEBUG (in port.cpp/Port() line 210): new port (2) of type 0x2002, > name 'sip-0-out' interface 'sip' > 000000 DEBUG (in sip.cpp/Psip() line 72): Created new Psip(sip-0-out). > 000000 DEBUG (in endpoint.cpp/portlist_new() line 150): EPOINT(1) > allocating port_list, attaching to port 2 > 000000 DEBUG (in message.c/_message_put() line 70): message MESSAGE_SETUP > written from 1 to 2 (memory 6b1a50 at file message.c, line 94) > 000000 DEBUG (in message.c/_message_put() line 70): message MESSAGE_BRIDGE > written from 1 to 1 (memory 6b6c00 at file appbridge.cpp, line 222) > 000000 DEBUG (in message.c/_message_put() line 70): message MESSAGE_BRIDGE > written from 1 to 2 (memory 6ba6e0 at file appbridge.cpp, line 225) > 000000 DEBUG (in message.c/message_get() line 115): message MESSAGE_SETUP > reading from 140733193388033 to 2 (memory 6b1a50) > 000000 DEBUG (in sip.cpp/message_setup() line 954): Doing Setup (inst > 0x6acce0) > 000000 DEBUG (in sip.cpp/message_setup() line 961): RTP info given by > remote, forward that > 000000 DEBUG (in sip.cpp/message_setup() line 968): local ip 7f000001 port > 52103 > 000000 DEBUG (in sip.cpp/message_setup() line 969): remote ip 00000000 > port 0 > nua: nh_create_handle: entering > 000000 TRACE 15.01.16 11:37:28.816 CH(2): NEW handle handle new=0x6b09c0 > 000000 DEBUG (in sip.cpp/message_setup() line 1038): Using SDP for invite: > v=0 > o=LCR-Sofia-SIP 0 0 IN IP4 127.0.0.1 > s=SIP Call > c=IN IP4 127.0.0.1 > t=0 0 > m=audio 52103 RTP/AVP 3 > a=rtpmap:3 GSM/8000 > 000000 TRACE 15.01.16 11:37:28.816 CH(2): INVITE from uri= > sip:639360100037@127.0.0.1:5062 to uri=sip:12345678@192.168.40.100:5060 > rtp ip=127.0.0.1 port=52103,52104 payload=GSM:3 > nua: nua_invite: entering > nua(0x6b09c0): sent signal r_invite > 000000 DEBUG (in port.cpp/new_state() line 283): PORT(sip-0-out) new state > PORT_STATE_IDLE --> PORT_STATE_OUT_SETUP > 000000 DEBUG (in sip.cpp/message_setup() line 1069): do proceeding > 000000 DEBUG (in port.cpp/new_state() line 283): PORT(sip-0-out) new state > PORT_STATE_OUT_SETUP --> PORT_STATE_OUT_PROCEEDING > 000000 DEBUG (in message.c/_message_put() line 70): message > MESSAGE_PROCEEDING written from 2 to 1 (memory 6be1c0 at file sip.cpp, line > 1072) > 000000 DEBUG (in port.cpp/epointlist_new() line 131): PORT(2) allocating > epoint_list. > 000000 DEBUG (in message.c/message_get() line 115): message MESSAGE_BRIDGE > reading from 1 to 1 (memory 6b6c00) > 000000 DEBUG (in port.cpp/message_epoint() line 657): PORT(gsm-0-in) > bridging to id 1 > nua(0x6b09c0): recv signal r_invite > 000000 DEBUG (in port.cpp/bridge() line 1305): Port 1 creating not > existing bridge 1. > 000000 DEBUG (in message.c/message_get() line 115): message MESSAGE_BRIDGE > reading from 1 to 2 (memory 6ba6e0) > 000000 DEBUG (in port.cpp/message_epoint() line 657): PORT(sip-0-out) > bridging to id 1 > nua: nua_stack_set_params: entering > 000000 DEBUG (in port.cpp/bridge() line 1290): Port 2 found existing > bridge 1. > 000000 DEBUG (in message.c/message_get() line 115): message > MESSAGE_PROCEEDING reading from 2 to 1 (memory 6be1c0) > 000000 DEBUG (in appbridge.cpp/port_other() line 259): EPOINT(8) epoint > received message 7070144 from port > 000000 DEBUG (in message.c/_message_put() line 70): message > MESSAGE_PROCEEDING written from 1 to 140733193388033 (memory 6be1c0 at file > message.c, line 94) > 000000 DEBUG (in message.c/message_get() line 115): message > MESSAGE_PROCEEDING reading from 1 to 1 (memory 6be1c0) > nua(0x6b09c0): adding session usage > nta_leg_tcreate(0x7ffff0006b00) > Program received signal SIGSEGV, Segmentation fault. > [Switching to Thread 0x7ffff6c52700 (LWP 11520)] > strlen () at ../sysdeps/x86_64/strlen.S:106 > 106 ../sysdeps/x86_64/strlen.S: No such file or directory. > (gdb) bt > #0 strlen () at ../sysdeps/x86_64/strlen.S:106 > #1 0x00007ffff7b70896 in url_xtra (url=url@entry=0x7ffff00075d0) at > url.c:1048 > #2 0x00007ffff7b2deaf in sip_request_create (home=home@entry=0x7ffff0006fc0, > method=method@entry=sip_method_invite, name=0x7ffff7b916e2 > <sip_method_name_invite> "INVITE", > name@entry=0x7ffff7b8ed49 "INVITE", uri=uri@entry=0x7ffff00075d0, > version=version@entry=0x0) at sip_basic.c:225 > #3 0x00007ffff7ae3512 in nta_msg_request_complete (msg=msg@entry=0x7ffff0006fc0, > leg=leg@entry=0x7ffff0006b00, method=method@entry=sip_method_invite, > method_name=method_name@entry=0x7ffff7b8ed49 "INVITE", > request_uri=0x7ffff00075d0, request_uri@entry=0x0) at nta.c:3890 > #4 0x00007ffff7b07d92 in nua_client_request_sendmsg (cr=cr@entry=0x7ffff0005af0) > at nua_client.c:803 > #5 0x00007ffff7b08de9 in nua_client_request_try (cr=0x7ffff0005af0) at > nua_client.c:708 > #6 0x00007ffff7b06b93 in nua_client_init_request0 (cr=0x7ffff0005af0) at > nua_client.c:605 > #7 nua_client_init_request (cr=0x7ffff0005af0) at nua_client.c:442 > #8 0x00007ffff7b07246 in nua_client_create (nh=nh@entry=0x6b09c0, > event=event@entry=31, methods=methods@entry=0x7ffff7dc4d20 > <nua_invite_client_methods>, tags=tags@entry=0x6b0eb0) > at nua_client.c:199 > #9 0x00007ffff7b1cc61 in nua_stack_invite (nua=nua@entry=0x6adc80, > nh=nh@entry=0x6b09c0, e=e@entry=nua_r_invite, tags=tags@entry=0x6b0eb0) > at nua_session.c:705 > #10 0x00007ffff7b03eb3 in nua_stack_signal (nua=0x6adc80, msg=<optimized > out>, ee=0x6b0e88) at nua_stack.c:582 > #11 0x00007ffff7b522b2 in su_base_port_execute_msgs (queue=0x0) at > su_base_port.c:280 > #12 0x00007ffff7b527bd in su_base_port_run (self=0x7ffff00008c0) at > su_base_port.c:335 > #13 0x00007ffff7b52f10 in su_pthread_port_clone_main (varg=0x7fffffffe4c0) > at su_pthread_port.c:324 > #14 0x00007ffff7840182 in start_thread (arg=0x7ffff6c52700) at > pthread_create.c:312 > #15 0x00007ffff6d4d47d in clone () at > ../sysdeps/unix/sysv/linux/x86_64/clone.S:111 > >

4 4

[PATCH 1/4] Improve code style and readability
by suraev＠alumni.ntnu.no 30 Jan '16

30 Jan '16

From: Max <msuraev(a)sysmocom.de> --- src/bitvec.c | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/src/bitvec.c b/src/bitvec.c index f9341b7..7254674 100644 --- a/src/bitvec.c +++ b/src/bitvec.c @@ -383,14 +383,12 @@ unsigned int bitvec_unpack(struct bitvec *bv, const uint8_t *buffer) int bitvec_unhex(struct bitvec *bv, const char *src) { - unsigned val; - unsigned write_index = 0; - unsigned digits = bv->data_len * 2; - for (unsigned i = 0; i < digits; i++) { - if (sscanf(src + i, "%1x", &val) < 1) { + unsigned val, i, write_index = 0; + for (i = 0; i < bv->data_len * 2; i++) { + if (sscanf(src + i, "%1x", &val) < 1) return 1; - } - bitvec_write_field(bv, write_index,val, 4); + + bitvec_write_field(bv, write_index, val, 4); } return 0; } -- 2.5.0

2 5

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

OpenBSC