mirror of https://github.com/pvnis/srsRAN_4G.git
Merge branch 'next_private' into novolk
Ismael Gomez
8 years ago
commit
975a41d55f
@ -0,0 +1,75 @@
|
||||
# Find the CUnit includes and library
|
||||
#
|
||||
# This module defines
|
||||
# LIBCONFIG_INCLUDE_DIR, where to find cppunit include files, etc.
|
||||
# LIBCONFIG_LIBRARIES, the libraries to link against to use CppUnit.
|
||||
# LIBCONFIG_STATIC_LIBRARIY_PATH
|
||||
# LIBCONFIG_FOUND, If false, do not try to use CppUnit.
|
||||
|
||||
# also defined, but not for general use are
|
||||
# LIBCONFIG_LIBRARY, where to find the CUnit library.
|
||||
|
||||
#MESSAGE("Searching for libconfig library")
|
||||
|
||||
FIND_PATH(LIBCONFIG_INCLUDE_DIR libconfig.h
|
||||
/usr/local/include
|
||||
/usr/include
|
||||
)
|
||||
|
||||
FIND_PATH(LIBCONFIGPP_INCLUDE_DIR libconfig.h++
|
||||
/usr/local/include
|
||||
/usr/include
|
||||
)
|
||||
|
||||
FIND_LIBRARY(LIBCONFIG_LIBRARY config
|
||||
/usr/local/lib
|
||||
/usr/lib
|
||||
)
|
||||
|
||||
FIND_LIBRARY(LIBCONFIGPP_LIBRARY config++
|
||||
/usr/local/lib
|
||||
/usr/lib
|
||||
)
|
||||
|
||||
FIND_LIBRARY(LIBCONFIG_STATIC_LIBRARY "libconfig${CMAKE_STATIC_LIBRARY_SUFFIX}"
|
||||
/usr/local/lib
|
||||
/usr/lib
|
||||
)
|
||||
|
||||
FIND_LIBRARY(LIBCONFIGPP_STATIC_LIBRARY "libconfig++${CMAKE_STATIC_LIBRARY_SUFFIX}"
|
||||
/usr/local/lib
|
||||
/usr/lib
|
||||
)
|
||||
|
||||
|
||||
IF(LIBCONFIG_INCLUDE_DIR)
|
||||
IF(LIBCONFIG_LIBRARY)
|
||||
SET(LIBCONFIG_FOUND TRUE)
|
||||
SET(LIBCONFIG_LIBRARIES ${LIBCONFIG_LIBRARY})
|
||||
SET(LIBCONFIG_STATIC_LIBRARY_PATH ${LIBCONFIG_STATIC_LIBRARY})
|
||||
ENDIF(LIBCONFIG_LIBRARY)
|
||||
ENDIF(LIBCONFIG_INCLUDE_DIR)
|
||||
|
||||
IF(LIBCONFIGPP_INCLUDE_DIR)
|
||||
IF(LIBCONFIGPP_LIBRARY)
|
||||
SET(LIBCONFIGPP_FOUND TRUE)
|
||||
SET(LIBCONFIGPP_LIBRARIES ${LIBCONFIGPP_LIBRARY})
|
||||
SET(LIBCONFIGPP_STATIC_LIBRARY_PATH ${LIBCONFIGPP_STATIC_LIBRARY})
|
||||
ENDIF(LIBCONFIGPP_LIBRARY)
|
||||
ENDIF(LIBCONFIGPP_INCLUDE_DIR)
|
||||
|
||||
IF (LIBCONFIGPP_FOUND)
|
||||
IF (NOT LibConfig_FIND_QUIETLY)
|
||||
MESSAGE(STATUS "Found LibConfig++: ${LIBCONFIGPP_LIBRARIES}" )
|
||||
MESSAGE(STATUS "static LibConfig++ path: ${LIBCONFIGPP_STATIC_LIBRARY_PATH}")
|
||||
MESSAGE(STATUS "Found LibConfig: ${LIBCONFIG_LIBRARIES}")
|
||||
MESSAGE(STATUS "static LibConfig path: ${LIBCONFIG_STATIC_LIBRARY_PATH}")
|
||||
ENDIF (NOT LibConfig_FIND_QUIETLY)
|
||||
ELSE (LIBCONFIGPP_FOUND)
|
||||
IF (LibConfig_FIND_REQUIRED)
|
||||
MESSAGE(SEND_ERROR "Could NOT find LibConfig")
|
||||
ENDIF (LibConfig_FIND_REQUIRED)
|
||||
ENDIF (LIBCONFIGPP_FOUND)
|
||||
|
||||
MARK_AS_ADVANCED(LIBCONFIG_INCLUDE_DIR LIBCONFIG_LIBRARY LIBCONFIG_STATIC_LIBRARY)
|
||||
MARK_AS_ADVANCED(LIBCONFIGPP_INCLUDE_DIR LIBCONFIGPP_LIBRARY LIBCONFIGPP_STATIC_LIBRARY)
|
||||
@ -0,0 +1,28 @@
|
||||
if(NOT LIMESDR_FOUND)
|
||||
pkg_check_modules (LIMESDR_PKG LimeSuite)
|
||||
|
||||
find_path(LIMESDR_INCLUDE_DIRS
|
||||
NAMES LimeSuite.h
|
||||
PATHS ${LIMESDR_PKG_INCLUDE_DIRS}
|
||||
/usr/include/lime
|
||||
/usr/local/include/lime
|
||||
)
|
||||
|
||||
find_library(LIMESDR_LIBRARIES
|
||||
NAMES LimeSuite
|
||||
PATHS ${LIMESDR_PKG_LIBRARY_DIRS}
|
||||
/usr/lib
|
||||
/usr/local/lib
|
||||
)
|
||||
|
||||
if(LIMESDR_INCLUDE_DIRS AND LIMESDR_LIBRARIES)
|
||||
set(LIMESDR_FOUND TRUE CACHE INTERNAL "libLimeSuite found")
|
||||
message(STATUS "Found libLimeSuite: ${LIMESDR_INCLUDE_DIRS}, ${LIMESDR_LIBRARIES}")
|
||||
else(LIMESDR_INCLUDE_DIRS AND LIMESDR_LIBRARIES)
|
||||
set(LIMESDR_FOUND FALSE CACHE INTERNAL "libLimeSuite found")
|
||||
message(STATUS "libLimeSuite not found.")
|
||||
endif(LIMESDR_INCLUDE_DIRS AND LIMESDR_LIBRARIES)
|
||||
|
||||
mark_as_advanced(LIMESDR_LIBRARIES LIMESDR_INCLUDE_DIRS)
|
||||
|
||||
endif(NOT LIMESDR_FOUND)
|
||||
@ -0,0 +1,40 @@
|
||||
# - Try to find mbedtls
|
||||
#
|
||||
# Once done this will define
|
||||
# MBEDTLS_FOUND - System has mbedtls
|
||||
# MBEDTLS_INCLUDE_DIRS - The mbedtls include directories
|
||||
# MBEDTLS_LIBRARIES - The mbedtls library
|
||||
|
||||
INCLUDE(FindPkgConfig)
|
||||
PKG_CHECK_MODULES(PC_MBEDTLS mbedtls)
|
||||
|
||||
#find Mbedtls
|
||||
FIND_PATH(
|
||||
MBEDTLS_INCLUDE_DIRS
|
||||
NAMES mbedtls/md.h
|
||||
HINTS $ENV{MBEDTLS_DIR}/include
|
||||
${PC_MBEDTLS_INCLUDEDIR}
|
||||
${CMAKE_INSTALL_PREFIX}/include
|
||||
PATHS /usr/local/include
|
||||
/usr/include
|
||||
)
|
||||
|
||||
FIND_LIBRARY(
|
||||
MBEDTLS_LIBRARIES
|
||||
NAMES mbedcrypto
|
||||
HINTS $ENV{MBEDTLS_DIR}/lib
|
||||
${PC_MBEDTLS_LIBDIR}
|
||||
${CMAKE_INSTALL_PREFIX}/lib
|
||||
${CMAKE_INSTALL_PREFIX}/lib64
|
||||
PATHS /usr/local/lib
|
||||
/usr/local/lib64
|
||||
/usr/lib
|
||||
/usr/lib64
|
||||
)
|
||||
|
||||
message(STATUS "MBEDTLS LIBRARIES: " ${MBEDTLS_LIBRARIES})
|
||||
message(STATUS "MBEDTLS INCLUDE DIRS: " ${MBEDTLS_INCLUDE_DIRS})
|
||||
|
||||
INCLUDE(FindPackageHandleStandardArgs)
|
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(MBEDTLS DEFAULT_MSG MBEDTLS_LIBRARIES MBEDTLS_INCLUDE_DIRS)
|
||||
MARK_AS_ADVANCED(MBEDTLS_LIBRARIES MBEDTLS_INCLUDE_DIRS)
|
||||
@ -0,0 +1,39 @@
|
||||
# - Try to find polarssl
|
||||
#
|
||||
# Once done this will define
|
||||
# POLARSSL_FOUND - System has polarssl
|
||||
# POLARSSL_INCLUDE_DIRS - The polarssl include directories
|
||||
# POLARSSL_LIBRARIES - The polarssl library
|
||||
|
||||
INCLUDE(FindPkgConfig)
|
||||
PKG_CHECK_MODULES(PC_POLARSSL polarssl)
|
||||
|
||||
FIND_PATH(
|
||||
POLARSSL_INCLUDE_DIRS
|
||||
NAMES polarssl/version.h
|
||||
HINTS $ENV{POLARSSL_DIR}/include
|
||||
${PC_POLARSSL_INCLUDEDIR}
|
||||
${CMAKE_INSTALL_PREFIX}/include
|
||||
PATHS /usr/local/include
|
||||
/usr/include
|
||||
)
|
||||
|
||||
FIND_LIBRARY(
|
||||
POLARSSL_LIBRARIES
|
||||
NAMES polarssl
|
||||
HINTS $ENV{POLARSSL_DIR}/lib
|
||||
${PC_POLARSSL_LIBDIR}
|
||||
${CMAKE_INSTALL_PREFIX}/lib
|
||||
${CMAKE_INSTALL_PREFIX}/lib64
|
||||
PATHS /usr/local/lib
|
||||
/usr/local/lib64
|
||||
/usr/lib
|
||||
/usr/lib64
|
||||
)
|
||||
|
||||
message(STATUS "POLARSSL LIBRARIES: " ${POLARSSL_LIBRARIES})
|
||||
message(STATUS "POLARSSL INCLUDE DIRS: " ${POLARSSL_INCLUDE_DIRS})
|
||||
|
||||
INCLUDE(FindPackageHandleStandardArgs)
|
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(POLARSSL DEFAULT_MSG POLARSSL_LIBRARIES POLARSSL_INCLUDE_DIRS)
|
||||
MARK_AS_ADVANCED(POLARSSL_LIBRARIES POLARSSL_INCLUDE_DIRS)
|
||||
@ -0,0 +1,38 @@
|
||||
# - Try to find sctp
|
||||
#
|
||||
# Once done this will define
|
||||
# SCTP_FOUND - System has mbedtls
|
||||
# SCTP_INCLUDE_DIRS - The mbedtls include directories
|
||||
# SCTP_LIBRARIES - The mbedtls library
|
||||
|
||||
INCLUDE(FindPkgConfig)
|
||||
PKG_CHECK_MODULES(PC_SCTP sctp)
|
||||
|
||||
#find Mbedtls
|
||||
FIND_PATH(
|
||||
SCTP_INCLUDE_DIRS
|
||||
NAMES netinet/sctp.h
|
||||
HINTS ${PC_SCTP_INCLUDEDIR}
|
||||
${CMAKE_INSTALL_PREFIX}/include
|
||||
PATHS /usr/local/include
|
||||
/usr/include
|
||||
)
|
||||
|
||||
FIND_LIBRARY(
|
||||
SCTP_LIBRARIES
|
||||
NAMES sctp
|
||||
HINTS ${PC_SCTP_LIBDIR}
|
||||
${CMAKE_INSTALL_PREFIX}/lib
|
||||
${CMAKE_INSTALL_PREFIX}/lib64
|
||||
PATHS /usr/local/lib
|
||||
/usr/local/lib64
|
||||
/usr/lib
|
||||
/usr/lib64
|
||||
)
|
||||
|
||||
message(STATUS "SCTP LIBRARIES: " ${SCTP_LIBRARIES})
|
||||
message(STATUS "SCTP INCLUDE DIRS: " ${SCTP_INCLUDE_DIRS})
|
||||
|
||||
INCLUDE(FindPackageHandleStandardArgs)
|
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(SCTP DEFAULT_MSG SCTP_LIBRARIES SCTP_INCLUDE_DIRS)
|
||||
MARK_AS_ADVANCED(SCTP_LIBRARIES SCTP_INCLUDE_DIRS)
|
||||
@ -0,0 +1,32 @@
|
||||
|
||||
message(STATUS "FINDING SOAPY.")
|
||||
if(NOT SOAPYSDR_FOUND)
|
||||
pkg_check_modules (SOAPYSDR_PKG SoapySDR)
|
||||
|
||||
find_path(SOAPYSDR_INCLUDE_DIRS
|
||||
NAMES Device.h
|
||||
PATHS ${SOAPYSDR_PKG_INCLUDE_DIRS}
|
||||
/usr/include/SoapySDR
|
||||
/usr/local/include/SoapySDR
|
||||
)
|
||||
|
||||
find_library(SOAPYSDR_LIBRARIES
|
||||
NAMES SoapySDR
|
||||
PATHS ${LIMESDR_PKG_LIBRARY_DIRS}
|
||||
/usr/lib
|
||||
/usr/local/lib
|
||||
/usr/lib/arm-linux-gnueabihf
|
||||
)
|
||||
|
||||
|
||||
if(SOAPYSDR_INCLUDE_DIRS AND SOAPYSDR_LIBRARIES)
|
||||
set(SOAPYSDR_FOUND TRUE CACHE INTERNAL "libSOAPYSDR found")
|
||||
message(STATUS "Found libSOAPYSDR: ${SOAPYSDR_INCLUDE_DIRS}, ${SOAPYSDR_LIBRARIES}")
|
||||
else(SOAPYSDR_INCLUDE_DIRS AND SOAPYSDR_LIBRARIES)
|
||||
set(SOAPYSDR_FOUND FALSE CACHE INTERNAL "libSOAPYSDR found")
|
||||
message(STATUS "libSOAPYSDR not found.")
|
||||
endif(SOAPYSDR_INCLUDE_DIRS AND SOAPYSDR_LIBRARIES)
|
||||
|
||||
mark_as_advanced(SOAPYSDR_LIBRARIES SOAPYSDR_INCLUDE_DIRS)
|
||||
|
||||
endif(NOT SOAPYSDR_FOUND)
|
||||
@ -0,0 +1,34 @@
|
||||
#
|
||||
# Copyright 2013-2017 Software Radio Systems Limited
|
||||
#
|
||||
# This file is part of srsLTE
|
||||
#
|
||||
# srsLTE is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Affero General Public License as
|
||||
# published by the Free Software Foundation, either version 3 of
|
||||
# the License, or (at your option) any later version.
|
||||
#
|
||||
# srsLTE is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU Affero General Public License for more details.
|
||||
#
|
||||
# A copy of the GNU Affero General Public License can be found in
|
||||
# the LICENSE file in the top-level directory of this distribution
|
||||
# and at http://www.gnu.org/licenses/.
|
||||
#
|
||||
|
||||
########################################################################
|
||||
# Add subdirectories
|
||||
########################################################################
|
||||
add_subdirectory(src)
|
||||
add_subdirectory(include)
|
||||
add_subdirectory(examples)
|
||||
add_subdirectory(test)
|
||||
|
||||
########################################################################
|
||||
# Install library headers
|
||||
########################################################################
|
||||
INSTALL( DIRECTORY include/
|
||||
DESTINATION "${INCLUDE_DIR}"
|
||||
FILES_MATCHING PATTERN "*.h" )
|
||||
@ -1,7 +1,7 @@
|
||||
#
|
||||
# Copyright 2013-2015 Software Radio Systems Limited
|
||||
# Copyright 2013-2017 Software Radio Systems Limited
|
||||
#
|
||||
# This file is part of the srsLTE library.
|
||||
# This file is part of srsLTE
|
||||
#
|
||||
# srsLTE is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Affero General Public License as
|
||||
@ -1,7 +1,7 @@
|
||||
#
|
||||
# Copyright 2013-2015 Software Radio Systems Limited
|
||||
# Copyright 2013-2017 Software Radio Systems Limited
|
||||
#
|
||||
# This file is part of the srsLTE library.
|
||||
# This file is part of srsLTE
|
||||
#
|
||||
# srsLTE is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU Affero General Public License as
|
||||
@ -0,0 +1,247 @@
|
||||
/*******************************************************************************
|
||||
|
||||
Copyright 2012-2014 Ben Wojtowicz
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
*******************************************************************************
|
||||
|
||||
File: liblte_common.h
|
||||
|
||||
Description: Contains all the common definitions for the LTE library.
|
||||
|
||||
Revision History
|
||||
---------- ------------- --------------------------------------------
|
||||
02/26/2012 Ben Wojtowicz Created file.
|
||||
07/21/2013 Ben Wojtowicz Added a common message structure.
|
||||
06/15/2014 Ben Wojtowicz Split LIBLTE_MSG_STRUCT into bit and byte
|
||||
aligned messages.
|
||||
08/03/2014 Ben Wojtowicz Commonized value_2_bits and bits_2_value.
|
||||
11/29/2014 Ben Wojtowicz Added liblte prefix to value_2_bits and
|
||||
bits_2_value.
|
||||
|
||||
*******************************************************************************/
|
||||
|
||||
#ifndef __LIBLTE_COMMON_H__
|
||||
#define __LIBLTE_COMMON_H__
|
||||
|
||||
/*******************************************************************************
|
||||
INCLUDES
|
||||
*******************************************************************************/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/*******************************************************************************
|
||||
DEFINES
|
||||
*******************************************************************************/
|
||||
|
||||
// FIXME: This was chosen arbitrarily
|
||||
#define LIBLTE_ASN1_OID_MAXSUBIDS 128
|
||||
#define LIBLTE_MAX_MSG_SIZE_BITS 102048
|
||||
#define LIBLTE_MAX_MSG_SIZE_BYTES 12756
|
||||
#define LIBLTE_MSG_HEADER_OFFSET 1024
|
||||
|
||||
/*******************************************************************************
|
||||
TYPEDEFS
|
||||
*******************************************************************************/
|
||||
|
||||
typedef int8_t int8;
|
||||
typedef uint8_t uint8;
|
||||
typedef int16_t int16;
|
||||
typedef uint16_t uint16;
|
||||
typedef int32_t int32;
|
||||
typedef uint32_t uint32;
|
||||
typedef int64_t int64;
|
||||
typedef uint64_t uint64;
|
||||
|
||||
typedef enum{
|
||||
LIBLTE_SUCCESS = 0,
|
||||
LIBLTE_ERROR_INVALID_INPUTS,
|
||||
LIBLTE_ERROR_ENCODE_FAIL,
|
||||
LIBLTE_ERROR_DECODE_FAIL,
|
||||
LIBLTE_ERROR_INVALID_CRC,
|
||||
LIBLTE_ERROR_N_ITEMS
|
||||
}LIBLTE_ERROR_ENUM;
|
||||
static const char liblte_error_text[LIBLTE_ERROR_N_ITEMS][64] = {
|
||||
"Invalid inputs",
|
||||
"Encode failure",
|
||||
"Decode failure",
|
||||
};
|
||||
|
||||
typedef void* LIBLTE_ASN1_OPEN_TYPE_STRUCT;
|
||||
|
||||
typedef struct {
|
||||
uint32_t numids; // number of subidentifiers
|
||||
uint32_t subid[LIBLTE_ASN1_OID_MAXSUBIDS]; // subidentifier values
|
||||
} LIBLTE_ASN1_OID_STRUCT;
|
||||
|
||||
typedef struct{
|
||||
bool data_valid;
|
||||
bool data;
|
||||
}LIBLTE_BOOL_MSG_STRUCT;
|
||||
|
||||
typedef struct{
|
||||
uint32 N_bits;
|
||||
uint8 msg[LIBLTE_MAX_MSG_SIZE_BITS];
|
||||
}LIBLTE_SIMPLE_BIT_MSG_STRUCT;
|
||||
|
||||
typedef struct{
|
||||
uint32 N_bytes;
|
||||
uint8 msg[LIBLTE_MAX_MSG_SIZE_BYTES];
|
||||
}LIBLTE_SIMPLE_BYTE_MSG_STRUCT;
|
||||
|
||||
|
||||
struct LIBLTE_BYTE_MSG_STRUCT{
|
||||
uint32 N_bytes;
|
||||
uint8 buffer[LIBLTE_MAX_MSG_SIZE_BYTES];
|
||||
uint8 *msg;
|
||||
|
||||
LIBLTE_BYTE_MSG_STRUCT():N_bytes(0)
|
||||
{
|
||||
msg = &buffer[LIBLTE_MSG_HEADER_OFFSET];
|
||||
}
|
||||
LIBLTE_BYTE_MSG_STRUCT(const LIBLTE_BYTE_MSG_STRUCT& buf)
|
||||
{
|
||||
N_bytes = buf.N_bytes;
|
||||
memcpy(msg, buf.msg, N_bytes);
|
||||
}
|
||||
LIBLTE_BYTE_MSG_STRUCT & operator= (const LIBLTE_BYTE_MSG_STRUCT & buf)
|
||||
{
|
||||
// avoid self assignment
|
||||
if (&buf == this)
|
||||
return *this;
|
||||
N_bytes = buf.N_bytes;
|
||||
memcpy(msg, buf.msg, N_bytes);
|
||||
return *this;
|
||||
}
|
||||
uint32 get_headroom()
|
||||
{
|
||||
return msg-buffer;
|
||||
}
|
||||
void reset()
|
||||
{
|
||||
N_bytes = 0;
|
||||
msg = &buffer[LIBLTE_MSG_HEADER_OFFSET];
|
||||
}
|
||||
};
|
||||
|
||||
struct LIBLTE_BIT_MSG_STRUCT{
|
||||
uint32 N_bits;
|
||||
uint8 buffer[LIBLTE_MAX_MSG_SIZE_BITS];
|
||||
uint8 *msg;
|
||||
|
||||
LIBLTE_BIT_MSG_STRUCT():N_bits(0)
|
||||
{
|
||||
msg = &buffer[LIBLTE_MSG_HEADER_OFFSET];
|
||||
while( (uint64_t)(msg) % 8 > 0) {
|
||||
msg++;
|
||||
}
|
||||
}
|
||||
LIBLTE_BIT_MSG_STRUCT(const LIBLTE_BIT_MSG_STRUCT& buf){
|
||||
N_bits = buf.N_bits;
|
||||
memcpy(msg, buf.msg, N_bits);
|
||||
}
|
||||
LIBLTE_BIT_MSG_STRUCT & operator= (const LIBLTE_BIT_MSG_STRUCT & buf){
|
||||
// avoid self assignment
|
||||
if (&buf == this)
|
||||
return *this;
|
||||
N_bits = buf.N_bits;
|
||||
memcpy(msg, buf.msg, N_bits);
|
||||
return *this;
|
||||
}
|
||||
uint32 get_headroom()
|
||||
{
|
||||
return msg-buffer;
|
||||
}
|
||||
void reset()
|
||||
{
|
||||
N_bits = 0;
|
||||
msg = &buffer[LIBLTE_MSG_HEADER_OFFSET];
|
||||
while( (uint64_t)(msg) % 8 > 0) {
|
||||
msg++;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
DECLARATIONS
|
||||
*******************************************************************************/
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_value_2_bits
|
||||
|
||||
Description: Converts a value to a bit string
|
||||
*********************************************************************/
|
||||
void liblte_value_2_bits(uint32 value,
|
||||
uint8 **bits,
|
||||
uint32 N_bits);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_bits_2_value
|
||||
|
||||
Description: Converts a bit string to a value
|
||||
*********************************************************************/
|
||||
uint32 liblte_bits_2_value(uint8 **bits,
|
||||
uint32 N_bits);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_pack
|
||||
|
||||
Description: Pack a bit array into a byte array
|
||||
*********************************************************************/
|
||||
void liblte_pack(LIBLTE_BIT_MSG_STRUCT *bits,
|
||||
LIBLTE_BYTE_MSG_STRUCT *bytes);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_unpack
|
||||
|
||||
Description: Unpack a byte array into a bit array
|
||||
*********************************************************************/
|
||||
void liblte_unpack(LIBLTE_BYTE_MSG_STRUCT *bytes,
|
||||
LIBLTE_BIT_MSG_STRUCT *bits);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_pack
|
||||
|
||||
Description: Pack a bit array into a byte array
|
||||
*********************************************************************/
|
||||
void liblte_pack(uint8_t *bits, uint32_t n_bits, uint8_t *bytes);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_unpack
|
||||
|
||||
Description: Unpack a byte array into a bit array
|
||||
*********************************************************************/
|
||||
void liblte_unpack(uint8_t *bytes, uint32_t n_bytes, uint8_t *bits);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_align_up
|
||||
|
||||
Description: Aligns a pointer to a multibyte boundary
|
||||
*********************************************************************/
|
||||
void liblte_align_up(uint8_t **ptr, uint32_t align);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_align_up_zero
|
||||
|
||||
Description: Aligns a pointer to a multibyte boundary and zeros
|
||||
bytes skipped
|
||||
*********************************************************************/
|
||||
void liblte_align_up_zero(uint8_t **ptr, uint32_t align);
|
||||
|
||||
#endif /* __LIBLTE_COMMON_H__ */
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,118 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef BCD_HELPERS
|
||||
#define BCD_HELPERS
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
|
||||
namespace srslte {
|
||||
|
||||
/******************************************************************************
|
||||
* Convert between string and BCD-coded MCC.
|
||||
* Digits are represented by 4-bit nibbles. Unused nibbles are filled with 0xF.
|
||||
* MCC 001 results in 0xF001
|
||||
*****************************************************************************/
|
||||
inline bool string_to_mcc(std::string str, uint16_t *mcc)
|
||||
{
|
||||
uint32_t len = str.size();
|
||||
if(len != 3) {
|
||||
return false;
|
||||
}
|
||||
if(!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2])) {
|
||||
return false;
|
||||
}
|
||||
*mcc = 0xF000;
|
||||
*mcc |= ((uint8_t)(str[0]-'0') << 8);
|
||||
*mcc |= ((uint8_t)(str[1]-'0') << 4);
|
||||
*mcc |= ((uint8_t)(str[2]-'0'));
|
||||
return true;
|
||||
}
|
||||
|
||||
inline bool mcc_to_string(uint16_t mcc, std::string *str)
|
||||
{
|
||||
if((mcc & 0xF000) != 0xF000) {
|
||||
return false;
|
||||
}
|
||||
*str = "";
|
||||
*str += ((mcc & 0x0F00) >> 8) + '0';
|
||||
*str += ((mcc & 0x00F0) >> 4) + '0';
|
||||
*str += (mcc & 0x000F) + '0';
|
||||
return true;
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* Convert between string and BCD-coded MNC.
|
||||
* Digits are represented by 4-bit nibbles. Unused nibbles are filled with 0xF.
|
||||
* MNC 001 results in 0xF001
|
||||
* MNC 01 results in 0xFF01
|
||||
*****************************************************************************/
|
||||
inline bool string_to_mnc(std::string str, uint16_t *mnc)
|
||||
{
|
||||
uint32_t len = str.size();
|
||||
if(len != 3 && len != 2) {
|
||||
return false;
|
||||
}
|
||||
if(len == 3) {
|
||||
if(!isdigit(str[0]) || !isdigit(str[1]) || !isdigit(str[2])) {
|
||||
return false;
|
||||
}
|
||||
*mnc = 0xF000;
|
||||
*mnc |= ((uint8_t)(str[0]-'0') << 8);
|
||||
*mnc |= ((uint8_t)(str[1]-'0') << 4);
|
||||
*mnc |= ((uint8_t)(str[2]-'0'));
|
||||
}
|
||||
if(len == 2) {
|
||||
if(!isdigit(str[0]) || !isdigit(str[1])) {
|
||||
return false;
|
||||
}
|
||||
*mnc = 0xFF00;
|
||||
*mnc |= ((uint8_t)(str[0]-'0') << 4);
|
||||
*mnc |= ((uint8_t)(str[1]-'0'));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline bool mnc_to_string(uint16_t mnc, std::string *str)
|
||||
{
|
||||
if((mnc & 0xF000) != 0xF000) {
|
||||
return false;
|
||||
}
|
||||
*str = "";
|
||||
if((mnc & 0xFF00) != 0xFF00) {
|
||||
*str += ((mnc & 0x0F00) >> 8) + '0';
|
||||
}
|
||||
*str += ((mnc & 0x00F0) >> 4) + '0';
|
||||
*str += (mnc & 0x000F) + '0';
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace srslte
|
||||
|
||||
#endif // BCD_HELPERS
|
||||
@ -0,0 +1,97 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef BLOCK_QUEUE
|
||||
#define BLOCK_QUEUE
|
||||
|
||||
#include <queue>
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
namespace srslte {
|
||||
|
||||
template<typename myobj>
|
||||
class block_queue {
|
||||
|
||||
public:
|
||||
block_queue<myobj>() {
|
||||
pthread_mutex_init(&mutex, NULL);
|
||||
pthread_cond_init(&cvar, NULL);
|
||||
}
|
||||
void push(const myobj& value) {
|
||||
pthread_mutex_lock(&mutex);
|
||||
q.push(value);
|
||||
pthread_cond_signal(&cvar);
|
||||
pthread_mutex_unlock(&mutex);
|
||||
}
|
||||
|
||||
bool try_pop(myobj *value) {
|
||||
pthread_mutex_lock(&mutex);
|
||||
if (q.empty()) {
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return false;
|
||||
}
|
||||
if (value) {
|
||||
*value = q.front();
|
||||
q.pop();
|
||||
}
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return true;
|
||||
}
|
||||
|
||||
myobj wait_pop() { // blocking pop
|
||||
pthread_mutex_lock(&mutex);
|
||||
while(q.empty()) {
|
||||
pthread_cond_wait(&cvar, &mutex);
|
||||
}
|
||||
myobj value = q.front();
|
||||
q.pop();
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return value;
|
||||
}
|
||||
|
||||
bool empty() const { // queue is empty?
|
||||
pthread_mutex_lock(&mutex);
|
||||
bool ret = q.empty();
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void clear() { // remove all items
|
||||
myobj item;
|
||||
while (try_pop(item));
|
||||
}
|
||||
|
||||
private:
|
||||
std::queue<myobj> q;
|
||||
pthread_mutex_t mutex;
|
||||
pthread_cond_t cvar;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,169 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef BUFFER_POOL_H
|
||||
#define BUFFER_POOL_H
|
||||
|
||||
#include <pthread.h>
|
||||
#include <vector>
|
||||
#include <stack>
|
||||
#include <algorithm>
|
||||
|
||||
/*******************************************************************************
|
||||
INCLUDES
|
||||
*******************************************************************************/
|
||||
|
||||
#include "srslte/common/common.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
/******************************************************************************
|
||||
* Buffer pool
|
||||
*
|
||||
* Preallocates a large number of buffer_t and provides allocate and
|
||||
* deallocate functions. Provides quick object creation and deletion as well
|
||||
* as object reuse.
|
||||
* Singleton class of byte_buffer_t (but other pools of different type can be created)
|
||||
*****************************************************************************/
|
||||
|
||||
template <class buffer_t>
|
||||
class buffer_pool{
|
||||
public:
|
||||
|
||||
// non-static methods
|
||||
buffer_pool(uint32_t nof_buffers = POOL_SIZE)
|
||||
{
|
||||
pthread_mutex_init(&mutex, NULL);
|
||||
for(uint32_t i=0;i<nof_buffers;i++) {
|
||||
buffer_t *b = new buffer_t;
|
||||
available.push(b);
|
||||
}
|
||||
capacity = nof_buffers;
|
||||
}
|
||||
|
||||
~buffer_pool() {
|
||||
// this destructor assumes all buffers have been properly deallocated
|
||||
while(available.size()) {
|
||||
delete available.top();
|
||||
available.pop();
|
||||
}
|
||||
}
|
||||
|
||||
void print_all_buffers()
|
||||
{
|
||||
printf("%d buffers in queue\n", (int) used.size());
|
||||
for (uint32_t i=0;i<used.size();i++) {
|
||||
printf("%s\n", strlen(used[i]->debug_name)?used[i]->debug_name:"Undefined");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
buffer_t* allocate(const char *debug_name = NULL)
|
||||
{
|
||||
pthread_mutex_lock(&mutex);
|
||||
buffer_t* b = NULL;
|
||||
|
||||
if(available.size() > 0)
|
||||
{
|
||||
b = available.top();
|
||||
used.push_back(b);
|
||||
available.pop();
|
||||
|
||||
if (available.size() < capacity/20) {
|
||||
printf("Warning buffer pool capacity is %f %%\n", (float) available.size()/capacity);
|
||||
}
|
||||
#ifdef SRSLTE_BUFFER_POOL_LOG_ENABLED
|
||||
if (debug_name) {
|
||||
strncpy(b->debug_name, debug_name, SRSLTE_BUFFER_POOL_LOG_NAME_LEN);
|
||||
b->debug_name[SRSLTE_BUFFER_POOL_LOG_NAME_LEN-1] = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
} else {
|
||||
printf("Error - buffer pool is empty\n");
|
||||
|
||||
#ifdef SRSLTE_BUFFER_POOL_LOG_ENABLED
|
||||
print_all_buffers();
|
||||
#endif
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return b;
|
||||
}
|
||||
|
||||
bool deallocate(buffer_t *b)
|
||||
{
|
||||
bool ret = false;
|
||||
pthread_mutex_lock(&mutex);
|
||||
typename std::vector<buffer_t*>::iterator elem = std::find(used.begin(), used.end(), b);
|
||||
if (elem != used.end()) {
|
||||
used.erase(elem);
|
||||
available.push(b);
|
||||
ret = true;
|
||||
} else {
|
||||
printf("Error deallocating from buffer pool: buffer not created in this pool.\n");
|
||||
}
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
static const int POOL_SIZE = 2048;
|
||||
std::stack<buffer_t*> available;
|
||||
std::vector<buffer_t*> used;
|
||||
pthread_mutex_t mutex;
|
||||
uint32_t capacity;
|
||||
};
|
||||
|
||||
|
||||
class byte_buffer_pool {
|
||||
public:
|
||||
// Singleton static methods
|
||||
static byte_buffer_pool *instance;
|
||||
static byte_buffer_pool* get_instance(void);
|
||||
static void cleanup(void);
|
||||
byte_buffer_pool() {
|
||||
pool = new buffer_pool<byte_buffer_t>;
|
||||
}
|
||||
~byte_buffer_pool() {
|
||||
delete pool;
|
||||
}
|
||||
byte_buffer_t* allocate(const char *debug_name = NULL) {
|
||||
return pool->allocate(debug_name);
|
||||
}
|
||||
void deallocate(byte_buffer_t *b) {
|
||||
b->reset();
|
||||
pool->deallocate(b);
|
||||
}
|
||||
private:
|
||||
buffer_pool<byte_buffer_t> *pool;
|
||||
};
|
||||
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // BUFFER_POOL_H
|
||||
@ -0,0 +1,250 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef COMMON_H
|
||||
#define COMMON_H
|
||||
|
||||
/*******************************************************************************
|
||||
INCLUDES
|
||||
*******************************************************************************/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
/*******************************************************************************
|
||||
DEFINES
|
||||
*******************************************************************************/
|
||||
|
||||
#define SRSLTE_UE_CATEGORY 4
|
||||
|
||||
#define SRSLTE_N_SRB 3
|
||||
#define SRSLTE_N_DRB 8
|
||||
#define SRSLTE_N_RADIO_BEARERS 11
|
||||
|
||||
// Cat 3 UE - Max number of DL-SCH transport block bits received within a TTI
|
||||
// 3GPP 36.306 Table 4.1.1
|
||||
#define SRSLTE_MAX_BUFFER_SIZE_BITS 102048
|
||||
#define SRSLTE_MAX_BUFFER_SIZE_BYTES 12756
|
||||
#define SRSLTE_BUFFER_HEADER_OFFSET 1024
|
||||
|
||||
#define SRSLTE_BUFFER_POOL_LOG_ENABLED
|
||||
|
||||
#ifdef SRSLTE_BUFFER_POOL_LOG_ENABLED
|
||||
#define pool_allocate (pool->allocate(__FUNCTION__))
|
||||
#define SRSLTE_BUFFER_POOL_LOG_NAME_LEN 128
|
||||
#else
|
||||
#define pool_allocate (pool->allocate())
|
||||
#endif
|
||||
|
||||
#include "srslte/srslte.h"
|
||||
|
||||
/*******************************************************************************
|
||||
TYPEDEFS
|
||||
*******************************************************************************/
|
||||
|
||||
namespace srslte {
|
||||
|
||||
typedef enum{
|
||||
ERROR_NONE = 0,
|
||||
ERROR_INVALID_PARAMS,
|
||||
ERROR_INVALID_COMMAND,
|
||||
ERROR_OUT_OF_BOUNDS,
|
||||
ERROR_CANT_START,
|
||||
ERROR_ALREADY_STARTED,
|
||||
ERROR_N_ITEMS,
|
||||
}error_t;
|
||||
static const char error_text[ERROR_N_ITEMS][20] = { "None",
|
||||
"Invalid parameters",
|
||||
"Invalid command",
|
||||
"Out of bounds",
|
||||
"Can't start",
|
||||
"Already started"};
|
||||
|
||||
typedef enum{
|
||||
RB_ID_SRB0 = 0,
|
||||
RB_ID_SRB1,
|
||||
RB_ID_SRB2,
|
||||
RB_ID_DRB1,
|
||||
RB_ID_DRB2,
|
||||
RB_ID_DRB3,
|
||||
RB_ID_DRB4,
|
||||
RB_ID_DRB5,
|
||||
RB_ID_DRB6,
|
||||
RB_ID_DRB7,
|
||||
RB_ID_DRB8,
|
||||
RB_ID_N_ITEMS,
|
||||
}rb_id_t;
|
||||
static const char rb_id_text[RB_ID_N_ITEMS][20] = { "SRB0",
|
||||
"SRB1",
|
||||
"SRB2",
|
||||
"DRB1",
|
||||
"DRB2",
|
||||
"DRB3",
|
||||
"DRB4",
|
||||
"DRB5",
|
||||
"DRB6",
|
||||
"DRB7",
|
||||
"DRB8"};
|
||||
|
||||
/******************************************************************************
|
||||
* Byte and Bit buffers
|
||||
*
|
||||
* Generic buffers with headroom to accommodate packet headers and custom
|
||||
* copy constructors & assignment operators for quick copying. Byte buffer
|
||||
* holds a next pointer to support linked lists.
|
||||
*****************************************************************************/
|
||||
class byte_buffer_t{
|
||||
public:
|
||||
uint32_t N_bytes;
|
||||
uint8_t buffer[SRSLTE_MAX_BUFFER_SIZE_BYTES];
|
||||
uint8_t *msg;
|
||||
#ifdef SRSLTE_BUFFER_POOL_LOG_ENABLED
|
||||
char debug_name[SRSLTE_BUFFER_POOL_LOG_NAME_LEN];
|
||||
#endif
|
||||
|
||||
byte_buffer_t():N_bytes(0)
|
||||
{
|
||||
timestamp_is_set = false;
|
||||
msg = &buffer[SRSLTE_BUFFER_HEADER_OFFSET];
|
||||
next = NULL;
|
||||
#ifdef SRSLTE_BUFFER_POOL_LOG_ENABLED
|
||||
debug_name[0] = 0;
|
||||
#endif
|
||||
}
|
||||
byte_buffer_t(const byte_buffer_t& buf)
|
||||
{
|
||||
N_bytes = buf.N_bytes;
|
||||
memcpy(msg, buf.msg, N_bytes);
|
||||
}
|
||||
byte_buffer_t & operator= (const byte_buffer_t & buf)
|
||||
{
|
||||
// avoid self assignment
|
||||
if (&buf == this)
|
||||
return *this;
|
||||
N_bytes = buf.N_bytes;
|
||||
memcpy(msg, buf.msg, N_bytes);
|
||||
return *this;
|
||||
}
|
||||
void reset()
|
||||
{
|
||||
msg = &buffer[SRSLTE_BUFFER_HEADER_OFFSET];
|
||||
N_bytes = 0;
|
||||
timestamp_is_set = false;
|
||||
}
|
||||
uint32_t get_headroom()
|
||||
{
|
||||
return msg-buffer;
|
||||
}
|
||||
long get_latency_us()
|
||||
{
|
||||
if(!timestamp_is_set)
|
||||
return 0;
|
||||
gettimeofday(×tamp[2], NULL);
|
||||
get_time_interval(timestamp);
|
||||
return timestamp[0].tv_usec;
|
||||
}
|
||||
|
||||
void set_timestamp()
|
||||
{
|
||||
gettimeofday(×tamp[1], NULL);
|
||||
timestamp_is_set = true;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
|
||||
void get_time_interval(struct timeval * tdata) {
|
||||
|
||||
tdata[0].tv_sec = tdata[2].tv_sec - tdata[1].tv_sec;
|
||||
tdata[0].tv_usec = tdata[2].tv_usec - tdata[1].tv_usec;
|
||||
if (tdata[0].tv_usec < 0) {
|
||||
tdata[0].tv_sec--;
|
||||
tdata[0].tv_usec += 1000000;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
struct timeval timestamp[3];
|
||||
bool timestamp_is_set;
|
||||
byte_buffer_t *next;
|
||||
};
|
||||
|
||||
struct bit_buffer_t{
|
||||
uint32_t N_bits;
|
||||
uint8_t buffer[SRSLTE_MAX_BUFFER_SIZE_BITS];
|
||||
uint8_t *msg;
|
||||
#ifdef SRSLTE_BUFFER_POOL_LOG_ENABLED
|
||||
char debug_name[128];
|
||||
#endif
|
||||
|
||||
bit_buffer_t():N_bits(0)
|
||||
{
|
||||
msg = &buffer[SRSLTE_BUFFER_HEADER_OFFSET];
|
||||
}
|
||||
bit_buffer_t(const bit_buffer_t& buf){
|
||||
N_bits = buf.N_bits;
|
||||
memcpy(msg, buf.msg, N_bits);
|
||||
}
|
||||
bit_buffer_t & operator= (const bit_buffer_t & buf){
|
||||
// avoid self assignment
|
||||
if (&buf == this)
|
||||
return *this;
|
||||
N_bits = buf.N_bits;
|
||||
memcpy(msg, buf.msg, N_bits);
|
||||
return *this;
|
||||
}
|
||||
void reset()
|
||||
{
|
||||
msg = &buffer[SRSLTE_BUFFER_HEADER_OFFSET];
|
||||
N_bits = 0;
|
||||
timestamp_is_set = false;
|
||||
}
|
||||
uint32_t get_headroom()
|
||||
{
|
||||
return msg-buffer;
|
||||
}
|
||||
long get_latency_us()
|
||||
{
|
||||
if(!timestamp_is_set)
|
||||
return 0;
|
||||
gettimeofday(×tamp[2], NULL);
|
||||
return timestamp[0].tv_usec;
|
||||
}
|
||||
void set_timestamp()
|
||||
{
|
||||
gettimeofday(×tamp[1], NULL);
|
||||
timestamp_is_set = true;
|
||||
}
|
||||
|
||||
private:
|
||||
struct timeval timestamp[3];
|
||||
bool timestamp_is_set;
|
||||
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // COMMON_H
|
||||
@ -0,0 +1,57 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef CONFIG_H
|
||||
#define CONFIG_H
|
||||
|
||||
// Generic helper definitions for shared library support
|
||||
#if defined _WIN32 || defined __CYGWIN__
|
||||
#define SRSAPPS_IMPORT __declspec(dllimport)
|
||||
#define SRSAPPS_EXPORT __declspec(dllexport)
|
||||
#define SRSAPPS_LOCAL
|
||||
#else
|
||||
#if __GNUC__ >= 4
|
||||
#define SRSAPPS_IMPORT __attribute__ ((visibility ("default")))
|
||||
#define SRSAPPS_EXPORT __attribute__ ((visibility ("default")))
|
||||
#else
|
||||
#define SRSAPPS_IMPORT
|
||||
#define SRSAPPS_EXPORT
|
||||
#define SRSAPPS_LOCAL
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Define SRSAPPS_API
|
||||
// is used for the public API symbols.
|
||||
#ifdef SRSAPPS_DLL_EXPORTS // defined if we are building the SRSAPPS DLL (instead of using it)
|
||||
#define SRSAPPS_EXPORT
|
||||
#else
|
||||
#define SRSAPPS_IMPORT
|
||||
#endif
|
||||
|
||||
// cf_t definition
|
||||
typedef _Complex float cf_t;
|
||||
|
||||
#endif // CONFIG_H
|
||||
@ -0,0 +1,52 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2017 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of srsLTE.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef INTERFACE_COMMON_H
|
||||
#define INTERFACE_COMMON_H
|
||||
|
||||
#include "srslte/common/timers.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class mac_interface_timers
|
||||
{
|
||||
public:
|
||||
/* Timer services with ms resolution.
|
||||
* timer_id must be lower than MAC_NOF_UPPER_TIMERS
|
||||
*/
|
||||
virtual timers::timer* get(uint32_t timer_id) = 0;
|
||||
virtual uint32_t get_unique_id() = 0;
|
||||
};
|
||||
|
||||
class read_pdu_interface
|
||||
{
|
||||
public:
|
||||
virtual int read_pdu(uint32_t lcid, uint8_t *payload, uint32_t requested_bytes) = 0;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,270 @@
|
||||
/*******************************************************************************
|
||||
|
||||
Copyright 2014 Ben Wojtowicz
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
*******************************************************************************
|
||||
|
||||
File: liblte_security.h
|
||||
|
||||
Description: Contains all the definitions for the LTE security algorithm
|
||||
library.
|
||||
|
||||
Revision History
|
||||
---------- ------------- --------------------------------------------
|
||||
08/03/2014 Ben Wojtowicz Created file.
|
||||
09/03/2014 Ben Wojtowicz Added key generation and EIA2.
|
||||
|
||||
*******************************************************************************/
|
||||
|
||||
#ifndef __LIBLTE_SECURITY_H__
|
||||
#define __LIBLTE_SECURITY_H__
|
||||
|
||||
/*******************************************************************************
|
||||
INCLUDES
|
||||
*******************************************************************************/
|
||||
|
||||
#include "srslte/asn1/liblte_common.h"
|
||||
|
||||
/*******************************************************************************
|
||||
DEFINES
|
||||
*******************************************************************************/
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
TYPEDEFS
|
||||
*******************************************************************************/
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
DECLARATIONS
|
||||
*******************************************************************************/
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_security_generate_k_asme
|
||||
|
||||
Description: Generate the security key Kasme.
|
||||
|
||||
Document Reference: 33.401 v10.0.0 Annex A.2
|
||||
*********************************************************************/
|
||||
// Defines
|
||||
// Enums
|
||||
// Structs
|
||||
// Functions
|
||||
LIBLTE_ERROR_ENUM liblte_security_generate_k_asme(uint8 *ck,
|
||||
uint8 *ik,
|
||||
uint8 *ak,
|
||||
uint8 *sqn,
|
||||
uint16 mcc,
|
||||
uint16 mnc,
|
||||
uint8 *k_asme);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_security_generate_k_enb
|
||||
|
||||
Description: Generate the security key Kenb.
|
||||
|
||||
Document Reference: 33.401 v10.0.0 Annex A.2
|
||||
*********************************************************************/
|
||||
// Defines
|
||||
// Enums
|
||||
// Structs
|
||||
// Functions
|
||||
LIBLTE_ERROR_ENUM liblte_security_generate_k_enb(uint8 *k_asme,
|
||||
uint32 nas_count,
|
||||
uint8 *k_enb);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_security_generate_k_nas
|
||||
|
||||
Description: Generate the NAS security keys KNASenc and KNASint.
|
||||
|
||||
Document Reference: 33.401 v10.0.0 Annex A.2
|
||||
*********************************************************************/
|
||||
// Defines
|
||||
// Enums
|
||||
typedef enum{
|
||||
LIBLTE_SECURITY_CIPHERING_ALGORITHM_ID_EEA0 = 0,
|
||||
LIBLTE_SECURITY_CIPHERING_ALGORITHM_ID_128_EEA1,
|
||||
LIBLTE_SECURITY_CIPHERING_ALGORITHM_ID_128_EEA2,
|
||||
LIBLTE_SECURITY_CIPHERING_ALGORITHM_ID_N_ITEMS,
|
||||
}LIBLTE_SECURITY_CIPHERING_ALGORITHM_ID_ENUM;
|
||||
static const char liblte_security_ciphering_algorithm_id_text[LIBLTE_SECURITY_CIPHERING_ALGORITHM_ID_N_ITEMS][20] = {"EEA0",
|
||||
"128-EEA1",
|
||||
"128-EEA2"};
|
||||
typedef enum{
|
||||
LIBLTE_SECURITY_INTEGRITY_ALGORITHM_ID_EIA0 = 0,
|
||||
LIBLTE_SECURITY_INTEGRITY_ALGORITHM_ID_128_EIA1,
|
||||
LIBLTE_SECURITY_INTEGRITY_ALGORITHM_ID_128_EIA2,
|
||||
LIBLTE_SECURITY_INTEGRITY_ALGORITHM_ID_N_ITEMS,
|
||||
}LIBLTE_SECURITY_INTEGRITY_ALGORITHM_ID_ENUM;
|
||||
static const char liblte_security_integrity_algorithm_id_text[LIBLTE_SECURITY_INTEGRITY_ALGORITHM_ID_N_ITEMS][20] = {"EIA0",
|
||||
"128-EIA1",
|
||||
"128-EIA2"};
|
||||
// Structs
|
||||
// Functions
|
||||
LIBLTE_ERROR_ENUM liblte_security_generate_k_nas(uint8 *k_asme,
|
||||
LIBLTE_SECURITY_CIPHERING_ALGORITHM_ID_ENUM enc_alg_id,
|
||||
LIBLTE_SECURITY_INTEGRITY_ALGORITHM_ID_ENUM int_alg_id,
|
||||
uint8 *k_nas_enc,
|
||||
uint8 *k_nas_int);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_security_generate_k_rrc
|
||||
|
||||
Description: Generate the RRC security keys KRRCenc and KRRCint.
|
||||
|
||||
Document Reference: 33.401 v10.0.0 Annex A.2
|
||||
*********************************************************************/
|
||||
// Defines
|
||||
// Enums
|
||||
// Structs
|
||||
// Functions
|
||||
LIBLTE_ERROR_ENUM liblte_security_generate_k_rrc(uint8 *k_enb,
|
||||
LIBLTE_SECURITY_CIPHERING_ALGORITHM_ID_ENUM enc_alg_id,
|
||||
LIBLTE_SECURITY_INTEGRITY_ALGORITHM_ID_ENUM int_alg_id,
|
||||
uint8 *k_rrc_enc,
|
||||
uint8 *k_rrc_int);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_security_generate_k_up
|
||||
|
||||
Description: Generate the user plane security keys KUPenc and
|
||||
KUPint.
|
||||
|
||||
Document Reference: 33.401 v10.0.0 Annex A.2
|
||||
*********************************************************************/
|
||||
// Defines
|
||||
// Enums
|
||||
// Structs
|
||||
// Functions
|
||||
LIBLTE_ERROR_ENUM liblte_security_generate_k_up(uint8 *k_enb,
|
||||
LIBLTE_SECURITY_CIPHERING_ALGORITHM_ID_ENUM enc_alg_id,
|
||||
LIBLTE_SECURITY_INTEGRITY_ALGORITHM_ID_ENUM int_alg_id,
|
||||
uint8 *k_up_enc,
|
||||
uint8 *k_up_int);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_security_128_eia2
|
||||
|
||||
Description: 128-bit integrity algorithm EIA2.
|
||||
|
||||
Document Reference: 33.401 v10.0.0 Annex B.2.3
|
||||
33.102 v10.0.0 Section 6.5.4
|
||||
RFC4493
|
||||
*********************************************************************/
|
||||
// Defines
|
||||
#define LIBLTE_SECURITY_DIRECTION_UPLINK 0
|
||||
#define LIBLTE_SECURITY_DIRECTION_DOWNLINK 1
|
||||
// Enums
|
||||
// Structs
|
||||
// Functions
|
||||
LIBLTE_ERROR_ENUM liblte_security_128_eia2(uint8 *key,
|
||||
uint32 count,
|
||||
uint8 bearer,
|
||||
uint8 direction,
|
||||
uint8 *msg,
|
||||
uint32 msg_len,
|
||||
uint8 *mac);
|
||||
LIBLTE_ERROR_ENUM liblte_security_128_eia2(uint8 *key,
|
||||
uint32 count,
|
||||
uint8 bearer,
|
||||
uint8 direction,
|
||||
LIBLTE_BIT_MSG_STRUCT *msg,
|
||||
uint8 *mac);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_security_milenage_f1
|
||||
|
||||
Description: Milenage security function F1. Computes network
|
||||
authentication code MAC-A from key K, random
|
||||
challenge RAND, sequence number SQN, and
|
||||
authentication management field AMF.
|
||||
|
||||
Document Reference: 35.206 v10.0.0 Annex 3
|
||||
*********************************************************************/
|
||||
// Defines
|
||||
// Enums
|
||||
// Structs
|
||||
// Functions
|
||||
LIBLTE_ERROR_ENUM liblte_security_milenage_f1(uint8 *k,
|
||||
uint8 *op,
|
||||
uint8 *rand,
|
||||
uint8 *sqn,
|
||||
uint8 *amf,
|
||||
uint8 *mac_a);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_security_milenage_f1_star
|
||||
|
||||
Description: Milenage security function F1*. Computes resynch
|
||||
authentication code MAC-S from key K, random
|
||||
challenge RAND, sequence number SQN, and
|
||||
authentication management field AMF.
|
||||
|
||||
Document Reference: 35.206 v10.0.0 Annex 3
|
||||
*********************************************************************/
|
||||
// Defines
|
||||
// Enums
|
||||
// Structs
|
||||
// Functions
|
||||
LIBLTE_ERROR_ENUM liblte_security_milenage_f1_star(uint8 *k,
|
||||
uint8 *op,
|
||||
uint8 *rand,
|
||||
uint8 *sqn,
|
||||
uint8 *amf,
|
||||
uint8 *mac_s);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_security_milenage_f2345
|
||||
|
||||
Description: Milenage security functions F2, F3, F4, and F5.
|
||||
Computes response RES, confidentiality key CK,
|
||||
integrity key IK, and anonymity key AK from random
|
||||
challenge RAND.
|
||||
|
||||
Document Reference: 35.206 v10.0.0 Annex 3
|
||||
*********************************************************************/
|
||||
// Defines
|
||||
// Enums
|
||||
// Structs
|
||||
// Functions
|
||||
LIBLTE_ERROR_ENUM liblte_security_milenage_f2345(uint8 *k,
|
||||
uint8 *op,
|
||||
uint8 *rand,
|
||||
uint8 *res,
|
||||
uint8 *ck,
|
||||
uint8 *ik,
|
||||
uint8 *ak);
|
||||
|
||||
/*********************************************************************
|
||||
Name: liblte_security_milenage_f5_star
|
||||
|
||||
Description: Milenage security function F5*. Computes resynch
|
||||
anonymity key AK from key K and random challenge
|
||||
RAND.
|
||||
|
||||
Document Reference: 35.206 v10.0.0 Annex 3
|
||||
*********************************************************************/
|
||||
// Defines
|
||||
// Enums
|
||||
// Structs
|
||||
// Functions
|
||||
LIBLTE_ERROR_ENUM liblte_security_milenage_f5_star(uint8 *k,
|
||||
uint8 *op,
|
||||
uint8 *rand,
|
||||
uint8 *ak);
|
||||
|
||||
#endif /* __LIBLTE_SECURITY_H__ */
|
||||
@ -0,0 +1,53 @@
|
||||
#ifndef __LIBLTE_SSL_H__
|
||||
#define __LIBLTE_SSL_H__
|
||||
|
||||
#ifdef HAVE_POLARSSL
|
||||
|
||||
#include "polarssl/sha256.h"
|
||||
#include "polarssl/aes.h"
|
||||
|
||||
void sha256(const unsigned char *key, size_t keylen,
|
||||
const unsigned char *input, size_t ilen,
|
||||
unsigned char output[32], int is224 )
|
||||
{
|
||||
sha256_hmac(key, keylen, input, ilen, output, is224);
|
||||
}
|
||||
|
||||
#endif // HAVE_POLARSSL
|
||||
|
||||
#ifdef HAVE_MBEDTLS
|
||||
|
||||
#include "mbedtls/md.h"
|
||||
#include "mbedtls/aes.h"
|
||||
|
||||
typedef mbedtls_aes_context aes_context;
|
||||
|
||||
#define AES_ENCRYPT 1
|
||||
#define AES_DECRYPT 0
|
||||
|
||||
int aes_setkey_enc( aes_context *ctx, const unsigned char *key, unsigned int keysize )
|
||||
{
|
||||
return mbedtls_aes_setkey_enc(ctx, key, keysize);
|
||||
}
|
||||
|
||||
int aes_crypt_ecb( aes_context *ctx,
|
||||
int mode,
|
||||
const unsigned char input[16],
|
||||
unsigned char output[16] )
|
||||
{
|
||||
return mbedtls_aes_crypt_ecb(ctx, mode, input, output);
|
||||
}
|
||||
|
||||
void sha256(const unsigned char *key, size_t keylen,
|
||||
const unsigned char *input, size_t ilen,
|
||||
unsigned char output[32], int is224 )
|
||||
{
|
||||
mbedtls_md_hmac(mbedtls_md_info_from_type(MBEDTLS_MD_SHA256),
|
||||
key, keylen,
|
||||
input, ilen,
|
||||
output );
|
||||
}
|
||||
|
||||
#endif // HAVE_MBEDTLS
|
||||
|
||||
#endif // __LIBLTE_SSL_H__
|
||||
@ -0,0 +1,127 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: log.h
|
||||
*
|
||||
* Description: Abstract logging service
|
||||
*
|
||||
* Reference:
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef LOG_H
|
||||
#define LOG_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
|
||||
namespace srslte {
|
||||
|
||||
typedef enum {
|
||||
LOG_LEVEL_NONE = 0,
|
||||
LOG_LEVEL_ERROR,
|
||||
LOG_LEVEL_WARNING,
|
||||
LOG_LEVEL_INFO,
|
||||
LOG_LEVEL_DEBUG,
|
||||
LOG_LEVEL_N_ITEMS
|
||||
} LOG_LEVEL_ENUM;
|
||||
static const char log_level_text[LOG_LEVEL_N_ITEMS][16] = {"None ",
|
||||
"Error ",
|
||||
"Warning",
|
||||
"Info ",
|
||||
"Debug "};
|
||||
|
||||
class log
|
||||
{
|
||||
public:
|
||||
|
||||
log() {
|
||||
service_name = "";
|
||||
tti = 0;
|
||||
level = LOG_LEVEL_NONE;
|
||||
hex_limit = 0;
|
||||
}
|
||||
|
||||
log(std::string service_name_) {
|
||||
service_name = service_name_;
|
||||
tti = 0;
|
||||
level = LOG_LEVEL_NONE;
|
||||
hex_limit = 0;
|
||||
}
|
||||
|
||||
// This function shall be called at the start of every tti for printing tti
|
||||
void step(uint32_t tti_) {
|
||||
tti = tti_;
|
||||
}
|
||||
uint32_t get_tti() {
|
||||
return tti;
|
||||
}
|
||||
|
||||
void set_level(LOG_LEVEL_ENUM l) {
|
||||
level = l;
|
||||
}
|
||||
LOG_LEVEL_ENUM get_level() {
|
||||
return level;
|
||||
}
|
||||
|
||||
void set_hex_limit(int limit) {
|
||||
hex_limit = limit;
|
||||
}
|
||||
int get_hex_limit() {
|
||||
return hex_limit;
|
||||
}
|
||||
|
||||
// Pure virtual methods for logging
|
||||
virtual void console(std::string message, ...) = 0;
|
||||
virtual void error(std::string message, ...) = 0;
|
||||
virtual void warning(std::string message, ...) = 0;
|
||||
virtual void info(std::string message, ...) = 0;
|
||||
virtual void debug(std::string message, ...) = 0;
|
||||
|
||||
// Same with hex dump
|
||||
virtual void error_hex(uint8_t *hex, int size, std::string message, ...){error("error_hex not implemented.\n");}
|
||||
virtual void warning_hex(uint8_t *hex, int size, std::string message, ...){error("warning_hex not implemented.\n");}
|
||||
virtual void info_hex(uint8_t *hex, int size, std::string message, ...){error("info_hex not implemented.\n");}
|
||||
virtual void debug_hex(uint8_t *hex, int size, std::string message, ...){error("debug_hex not implemented.\n");}
|
||||
|
||||
// Same with line and file info
|
||||
virtual void error_line(std::string file, int line, std::string message, ...){error("error_line not implemented.\n");}
|
||||
virtual void warning_line(std::string file, int line, std::string message, ...){error("warning_line not implemented.\n");}
|
||||
virtual void info_line(std::string file, int line, std::string message, ...){error("info_line not implemented.\n");}
|
||||
virtual void debug_line(std::string file, int line, std::string message, ...){error("debug_line not implemented.\n");}
|
||||
|
||||
protected:
|
||||
std::string get_service_name() { return service_name; }
|
||||
uint32_t tti;
|
||||
LOG_LEVEL_ENUM level;
|
||||
int hex_limit;
|
||||
std::string service_name;
|
||||
};
|
||||
|
||||
} // namespace srslte
|
||||
|
||||
#endif // LOG_H
|
||||
|
||||
@ -0,0 +1,83 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: log_filter.h
|
||||
* Description: Log filter for a specific layer or element.
|
||||
* Performs filtering based on log level, generates
|
||||
* timestamped log strings and passes them to the
|
||||
* common logger object.
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef LOG_FILTER_H
|
||||
#define LOG_FILTER_H
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <string>
|
||||
#include "srslte/common/log.h"
|
||||
#include "logger.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class log_filter : public srslte::log
|
||||
{
|
||||
public:
|
||||
|
||||
log_filter();
|
||||
log_filter(std::string layer, logger *logger_, bool tti=false);
|
||||
|
||||
void init(std::string layer, logger *logger_, bool tti=false);
|
||||
|
||||
void console(std::string message, ...);
|
||||
void error(std::string message, ...);
|
||||
void warning(std::string message, ...);
|
||||
void info(std::string message, ...);
|
||||
void debug(std::string message, ...);
|
||||
|
||||
void error_hex(uint8_t *hex, int size, std::string message, ...);
|
||||
void warning_hex(uint8_t *hex, int size, std::string message, ...);
|
||||
void info_hex(uint8_t *hex, int size, std::string message, ...);
|
||||
void debug_hex(uint8_t *hex, int size, std::string message, ...);
|
||||
|
||||
void error_line(std::string file, int line, std::string message, ...);
|
||||
void warning_line(std::string file, int line, std::string message, ...);
|
||||
void info_line(std::string file, int line, std::string message, ...);
|
||||
void debug_line(std::string file, int line, std::string message, ...);
|
||||
|
||||
private:
|
||||
logger *logger_h;
|
||||
bool do_tti;
|
||||
|
||||
void all_log(srslte::LOG_LEVEL_ENUM level, uint32_t tti, char *msg);
|
||||
void all_log(srslte::LOG_LEVEL_ENUM level, uint32_t tti, char *msg, uint8_t *hex, int size);
|
||||
void all_log_line(srslte::LOG_LEVEL_ENUM level, uint32_t tti, std::string file, int line, char *msg);
|
||||
std::string now_time();
|
||||
std::string hex_string(uint8_t *hex, int size);
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // LOG_FILTER_H
|
||||
@ -0,0 +1,82 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: log_stout.h
|
||||
*
|
||||
* Description: Logging service through standard output. Inherits log interface
|
||||
*
|
||||
* Reference:
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef LOGSTDOUT_H
|
||||
#define LOGSTDOUT_H
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <string>
|
||||
#include "srslte/common/log.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class log_stdout : public log
|
||||
{
|
||||
public:
|
||||
|
||||
log_stdout(std::string service_name_) : log(service_name_) { }
|
||||
|
||||
void console(std::string message, ...);
|
||||
void error(std::string message, ...);
|
||||
void warning(std::string message, ...);
|
||||
void info(std::string message, ...);
|
||||
void debug(std::string message, ...);
|
||||
|
||||
// Same with hex dump
|
||||
void error_hex(uint8_t *hex, int size, std::string message, ...);
|
||||
void warning_hex(uint8_t *hex, int size, std::string message, ...);
|
||||
void info_hex(uint8_t *hex, int size, std::string message, ...);
|
||||
void debug_hex(uint8_t *hex, int size, std::string message, ...);
|
||||
|
||||
// Same with line and file info
|
||||
void error_line(std::string file, int line, std::string message, ...);
|
||||
void warning_line(std::string file, int line, std::string message, ...);
|
||||
void info_line(std::string file, int line, std::string message, ...);
|
||||
void debug_line(std::string file, int line, std::string message, ...);
|
||||
|
||||
private:
|
||||
void printlog(srslte::LOG_LEVEL_ENUM level, uint32_t tti, std::string file, int line, std::string message, va_list args);
|
||||
void printlog(srslte::LOG_LEVEL_ENUM level, uint32_t tti, std::string message, va_list args);
|
||||
|
||||
void all_log(srslte::LOG_LEVEL_ENUM level, uint32_t tti, char *msg);
|
||||
void all_log(srslte::LOG_LEVEL_ENUM level, uint32_t tti, char *msg, uint8_t *hex, int size);
|
||||
void all_log_line(srslte::LOG_LEVEL_ENUM level, uint32_t tti, std::string file, int line, char *msg);
|
||||
std::string now_time();
|
||||
std::string hex_string(uint8_t *hex, int size);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -0,0 +1,74 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: logger.h
|
||||
* Description: Common log object. Maintains a queue of log messages
|
||||
* and runs a thread to read messages and write to file.
|
||||
* Multiple producers, single consumer. If full, producers
|
||||
* increase queue size. If empty, consumer blocks.
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef LOGGER_H
|
||||
#define LOGGER_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include <deque>
|
||||
#include <string>
|
||||
#include "srslte/common/threads.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
typedef std::string* str_ptr;
|
||||
|
||||
class logger : public thread
|
||||
{
|
||||
public:
|
||||
logger();
|
||||
logger(std::string file);
|
||||
~logger();
|
||||
void init(std::string file);
|
||||
void log(const char *msg);
|
||||
void log(str_ptr msg);
|
||||
|
||||
private:
|
||||
void run_thread();
|
||||
void flush();
|
||||
|
||||
FILE* logfile;
|
||||
bool inited;
|
||||
bool not_done;
|
||||
std::string filename;
|
||||
pthread_cond_t not_empty;
|
||||
pthread_cond_t not_full;
|
||||
pthread_mutex_t mutex;
|
||||
pthread_t thread;
|
||||
std::deque<str_ptr> buffer;
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // LOGGER_H
|
||||
@ -0,0 +1,61 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MACPCAP_H
|
||||
#define MACPCAP_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "srslte/common/pcap.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class mac_pcap
|
||||
{
|
||||
public:
|
||||
mac_pcap() {enable_write=false; ue_id=0; pcap_file = NULL; };
|
||||
void enable(bool en);
|
||||
void open(const char *filename, uint32_t ue_id = 0);
|
||||
void close();
|
||||
void write_ul_crnti(uint8_t *pdu, uint32_t pdu_len_bytes, uint16_t crnti, uint32_t reTX, uint32_t tti);
|
||||
void write_dl_crnti(uint8_t *pdu, uint32_t pdu_len_bytes, uint16_t crnti, bool crc_ok, uint32_t tti);
|
||||
void write_dl_ranti(uint8_t *pdu, uint32_t pdu_len_bytes, uint16_t ranti, bool crc_ok, uint32_t tti);
|
||||
|
||||
// SI and BCH only for DL
|
||||
void write_dl_sirnti(uint8_t *pdu, uint32_t pdu_len_bytes, bool crc_ok, uint32_t tti);
|
||||
void write_dl_bch(uint8_t *pdu, uint32_t pdu_len_bytes, bool crc_ok, uint32_t tti);
|
||||
void write_dl_pch(uint8_t *pdu, uint32_t pdu_len_bytes, bool crc_ok, uint32_t tti);
|
||||
|
||||
private:
|
||||
bool enable_write;
|
||||
FILE *pcap_file;
|
||||
uint32_t ue_id;
|
||||
void pack_and_write(uint8_t* pdu, uint32_t pdu_len_bytes, uint32_t reTX, bool crc_ok, uint32_t tti,
|
||||
uint16_t crnti_, uint8_t direction, uint8_t rnti_type);
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // MACPCAP_H
|
||||
@ -0,0 +1,61 @@
|
||||
|
||||
/******************************************************************************
|
||||
* File: metrics_hub.h
|
||||
* Description: Centralizes metrics interfaces to allow different metrics clients
|
||||
* to get metrics
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef METRICS_HUB_H
|
||||
#define METRICS_HUB_H
|
||||
|
||||
#include <vector>
|
||||
#include "srslte/common/threads.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
template<typename metrics_t>
|
||||
class metrics_interface
|
||||
{
|
||||
public:
|
||||
virtual bool get_metrics(metrics_t &m) = 0;
|
||||
};
|
||||
|
||||
template<typename metrics_t>
|
||||
class metrics_listener
|
||||
{
|
||||
public:
|
||||
virtual void set_metrics(metrics_t &m) = 0;
|
||||
};
|
||||
|
||||
template<typename metrics_t>
|
||||
class metrics_hub : public periodic_thread
|
||||
{
|
||||
public:
|
||||
bool init(metrics_interface<metrics_t> *m_, float report_period_secs=1.0) {
|
||||
m = m_;
|
||||
start_periodic(report_period_secs*1e6);
|
||||
}
|
||||
void stop() {
|
||||
thread_cancel();
|
||||
}
|
||||
|
||||
void add_listener(metrics_listener<metrics_t> *listener) {
|
||||
listeners.push_back(listener);
|
||||
}
|
||||
|
||||
private:
|
||||
void run_period() {
|
||||
metrics_t metric;
|
||||
m->get_metrics(metric);
|
||||
for (int i=0;i<listeners.size();i++) {
|
||||
listeners[i]->set_metrics(metric);
|
||||
}
|
||||
}
|
||||
metrics_interface<metrics_t> *m;
|
||||
std::vector<metrics_listener<metrics_t>*> listeners;
|
||||
|
||||
};
|
||||
|
||||
} // namespace srslte
|
||||
|
||||
#endif // METRICS_HUB_H
|
||||
@ -0,0 +1,152 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: msg_queue.h
|
||||
* Description: Thread-safe bounded circular buffer of srsue_byte_buffer pointers.
|
||||
* Reference:
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef MSG_QUEUE_H
|
||||
#define MSG_QUEUE_H
|
||||
|
||||
#include "srslte/common/common.h"
|
||||
#include <pthread.h>
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class msg_queue
|
||||
{
|
||||
public:
|
||||
msg_queue(uint32_t capacity_ = 128)
|
||||
:head(0)
|
||||
,tail(0)
|
||||
,unread(0)
|
||||
,unread_bytes(0)
|
||||
,capacity(capacity_)
|
||||
{
|
||||
buf = new byte_buffer_t*[capacity];
|
||||
pthread_mutex_init(&mutex, NULL);
|
||||
pthread_cond_init(¬_empty, NULL);
|
||||
pthread_cond_init(¬_full, NULL);
|
||||
}
|
||||
|
||||
~msg_queue()
|
||||
{
|
||||
delete [] buf;
|
||||
}
|
||||
|
||||
void write(byte_buffer_t *msg)
|
||||
{
|
||||
pthread_mutex_lock(&mutex);
|
||||
while(is_full()) {
|
||||
pthread_cond_wait(¬_full, &mutex);
|
||||
}
|
||||
buf[head] = msg;
|
||||
head = (head+1)%capacity;
|
||||
unread++;
|
||||
unread_bytes += msg->N_bytes;
|
||||
|
||||
pthread_cond_signal(¬_empty);
|
||||
pthread_mutex_unlock(&mutex);
|
||||
}
|
||||
|
||||
void read(byte_buffer_t **msg)
|
||||
{
|
||||
pthread_mutex_lock(&mutex);
|
||||
while(is_empty()) {
|
||||
pthread_cond_wait(¬_empty, &mutex);
|
||||
}
|
||||
*msg = buf[tail];
|
||||
tail = (tail+1)%capacity;
|
||||
unread--;
|
||||
unread_bytes -= (*msg)->N_bytes;
|
||||
|
||||
pthread_cond_signal(¬_full);
|
||||
pthread_mutex_unlock(&mutex);
|
||||
}
|
||||
|
||||
bool try_read(byte_buffer_t **msg)
|
||||
{
|
||||
pthread_mutex_lock(&mutex);
|
||||
if(is_empty())
|
||||
{
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return false;
|
||||
}else{
|
||||
*msg = buf[tail];
|
||||
tail = (tail+1)%capacity;
|
||||
unread--;
|
||||
unread_bytes -= (*msg)->N_bytes;
|
||||
pthread_cond_signal(¬_full);
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t size()
|
||||
{
|
||||
pthread_mutex_lock(&mutex);
|
||||
uint32_t r = unread;
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return r;
|
||||
}
|
||||
|
||||
uint32_t size_bytes()
|
||||
{
|
||||
pthread_mutex_lock(&mutex);
|
||||
uint32_t r = unread_bytes;
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return r;
|
||||
}
|
||||
|
||||
uint32_t size_tail_bytes()
|
||||
{
|
||||
pthread_mutex_lock(&mutex);
|
||||
uint32_t r = buf[tail]->N_bytes;
|
||||
pthread_mutex_unlock(&mutex);
|
||||
return r;
|
||||
}
|
||||
|
||||
private:
|
||||
bool is_empty() const { return unread == 0; }
|
||||
bool is_full() const { return unread == capacity; }
|
||||
|
||||
pthread_cond_t not_empty;
|
||||
pthread_cond_t not_full;
|
||||
pthread_mutex_t mutex;
|
||||
byte_buffer_t **buf;
|
||||
uint32_t capacity;
|
||||
uint32_t unread;
|
||||
uint32_t unread_bytes;
|
||||
uint32_t head;
|
||||
uint32_t tail;
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
|
||||
#endif // MSG_QUEUE_H
|
||||
@ -0,0 +1,218 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef UEPCAP_H
|
||||
#define UEPCAP_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#define MAC_LTE_DLT 147
|
||||
|
||||
|
||||
/* This structure gets written to the start of the file */
|
||||
typedef struct pcap_hdr_s {
|
||||
unsigned int magic_number; /* magic number */
|
||||
unsigned short version_major; /* major version number */
|
||||
unsigned short version_minor; /* minor version number */
|
||||
unsigned int thiszone; /* GMT to local correction */
|
||||
unsigned int sigfigs; /* accuracy of timestamps */
|
||||
unsigned int snaplen; /* max length of captured packets, in octets */
|
||||
unsigned int network; /* data link type */
|
||||
} pcap_hdr_t;
|
||||
|
||||
/* This structure precedes each packet */
|
||||
typedef struct pcaprec_hdr_s {
|
||||
unsigned int ts_sec; /* timestamp seconds */
|
||||
unsigned int ts_usec; /* timestamp microseconds */
|
||||
unsigned int incl_len; /* number of octets of packet saved in file */
|
||||
unsigned int orig_len; /* actual length of packet */
|
||||
} pcaprec_hdr_t;
|
||||
|
||||
|
||||
/* radioType */
|
||||
#define FDD_RADIO 1
|
||||
#define TDD_RADIO 2
|
||||
|
||||
/* Direction */
|
||||
#define DIRECTION_UPLINK 0
|
||||
#define DIRECTION_DOWNLINK 1
|
||||
|
||||
/* rntiType */
|
||||
#define NO_RNTI 0 /* Used for BCH-BCH */
|
||||
#define P_RNTI 1
|
||||
#define RA_RNTI 2
|
||||
#define C_RNTI 3
|
||||
#define SI_RNTI 4
|
||||
#define SPS_RNTI 5
|
||||
#define M_RNTI 6
|
||||
|
||||
#define MAC_LTE_START_STRING "mac-lte"
|
||||
|
||||
#define MAC_LTE_RNTI_TAG 0x02
|
||||
/* 2 bytes, network order */
|
||||
|
||||
#define MAC_LTE_UEID_TAG 0x03
|
||||
/* 2 bytes, network order */
|
||||
|
||||
#define MAC_LTE_SUBFRAME_TAG 0x04
|
||||
/* 2 bytes, network order */
|
||||
|
||||
#define MAC_LTE_PREDFINED_DATA_TAG 0x05
|
||||
/* 1 byte */
|
||||
|
||||
#define MAC_LTE_RETX_TAG 0x06
|
||||
/* 1 byte */
|
||||
|
||||
#define MAC_LTE_CRC_STATUS_TAG 0x07
|
||||
/* 1 byte */
|
||||
|
||||
/* MAC PDU. Following this tag comes the actual MAC PDU (there is no length, the PDU
|
||||
continues until the end of the frame) */
|
||||
#define MAC_LTE_PAYLOAD_TAG 0x01
|
||||
|
||||
|
||||
/* Context information for every MAC PDU that will be logged */
|
||||
typedef struct MAC_Context_Info_t {
|
||||
unsigned short radioType;
|
||||
unsigned char direction;
|
||||
unsigned char rntiType;
|
||||
unsigned short rnti;
|
||||
unsigned short ueid;
|
||||
unsigned char isRetx;
|
||||
unsigned char crcStatusOK;
|
||||
|
||||
unsigned short sysFrameNumber;
|
||||
unsigned short subFrameNumber;
|
||||
|
||||
} MAC_Context_Info_t;
|
||||
|
||||
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
/* API functions for opening/writing/closing MAC-LTE PCAP files */
|
||||
|
||||
/* Open the file and write file header */
|
||||
inline FILE *MAC_LTE_PCAP_Open(const char *fileName)
|
||||
{
|
||||
pcap_hdr_t file_header =
|
||||
{
|
||||
0xa1b2c3d4, /* magic number */
|
||||
2, 4, /* version number is 2.4 */
|
||||
0, /* timezone */
|
||||
0, /* sigfigs - apparently all tools do this */
|
||||
65535, /* snaplen - this should be long enough */
|
||||
MAC_LTE_DLT /* Data Link Type (DLT). Set as unused value 147 for now */
|
||||
};
|
||||
|
||||
FILE *fd = fopen(fileName, "w");
|
||||
if (fd == NULL) {
|
||||
printf("Failed to open file \"%s\" for writing\n", fileName);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Write the file header */
|
||||
fwrite(&file_header, sizeof(pcap_hdr_t), 1, fd);
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
/* Write an individual PDU (PCAP packet header + mac-context + mac-pdu) */
|
||||
inline int MAC_LTE_PCAP_WritePDU(FILE *fd, MAC_Context_Info_t *context,
|
||||
const unsigned char *PDU, unsigned int length)
|
||||
{
|
||||
pcaprec_hdr_t packet_header;
|
||||
char context_header[256];
|
||||
int offset = 0;
|
||||
unsigned short tmp16;
|
||||
|
||||
/* Can't write if file wasn't successfully opened */
|
||||
if (fd == NULL) {
|
||||
printf("Error: Can't write to empty file handle\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*****************************************************************/
|
||||
/* Context information (same as written by UDP heuristic clients */
|
||||
context_header[offset++] = context->radioType;
|
||||
context_header[offset++] = context->direction;
|
||||
context_header[offset++] = context->rntiType;
|
||||
|
||||
/* RNTI */
|
||||
context_header[offset++] = MAC_LTE_RNTI_TAG;
|
||||
tmp16 = htons(context->rnti);
|
||||
memcpy(context_header+offset, &tmp16, 2);
|
||||
offset += 2;
|
||||
|
||||
/* UEId */
|
||||
context_header[offset++] = MAC_LTE_UEID_TAG;
|
||||
tmp16 = htons(context->ueid);
|
||||
memcpy(context_header+offset, &tmp16, 2);
|
||||
offset += 2;
|
||||
|
||||
/* Subframe number */
|
||||
context_header[offset++] = MAC_LTE_SUBFRAME_TAG;
|
||||
tmp16 = htons(context->subFrameNumber);
|
||||
memcpy(context_header+offset, &tmp16, 2);
|
||||
offset += 2;
|
||||
|
||||
/* CRC Status */
|
||||
context_header[offset++] = MAC_LTE_CRC_STATUS_TAG;
|
||||
context_header[offset++] = context->crcStatusOK;
|
||||
|
||||
/* Data tag immediately preceding PDU */
|
||||
context_header[offset++] = MAC_LTE_PAYLOAD_TAG;
|
||||
|
||||
|
||||
/****************************************************************/
|
||||
/* PCAP Header */
|
||||
struct timeval t;
|
||||
gettimeofday(&t, NULL);
|
||||
packet_header.ts_sec = t.tv_sec;
|
||||
packet_header.ts_usec = t.tv_usec;
|
||||
packet_header.incl_len = offset + length;
|
||||
packet_header.orig_len = offset + length;
|
||||
|
||||
/***************************************************************/
|
||||
/* Now write everything to the file */
|
||||
fwrite(&packet_header, sizeof(pcaprec_hdr_t), 1, fd);
|
||||
fwrite(context_header, 1, offset, fd);
|
||||
fwrite(PDU, 1, length, fd);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Close the PCAP file */
|
||||
inline void MAC_LTE_PCAP_Close(FILE *fd)
|
||||
{
|
||||
if(fd)
|
||||
fclose(fd);
|
||||
}
|
||||
|
||||
#endif /* UEPCAP_H */
|
||||
@ -0,0 +1,339 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MACPDU_H
|
||||
#define MACPDU_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "srslte/common/log.h"
|
||||
#include "srslte/common/interfaces_common.h"
|
||||
#include <vector>
|
||||
#include <stdio.h>
|
||||
|
||||
/* MAC PDU Packing/Unpacking functions. Section 6 of 36.321 */
|
||||
|
||||
|
||||
namespace srslte {
|
||||
|
||||
template<class SubH>
|
||||
class pdu
|
||||
{
|
||||
public:
|
||||
|
||||
pdu(uint32_t max_subheaders_) : subheaders(max_subheaders_) {
|
||||
max_subheaders = max_subheaders_;
|
||||
nof_subheaders = 0;
|
||||
cur_idx = -1;
|
||||
pdu_len = 0;
|
||||
rem_len = 0;
|
||||
last_sdu_idx = -1;
|
||||
pdu_is_ul = false;
|
||||
buffer_tx = NULL;
|
||||
total_sdu_len = 0;
|
||||
}
|
||||
|
||||
void fprint(FILE *stream) {
|
||||
fprintf(stream, "Number of Subheaders: %d\n", nof_subheaders);
|
||||
for (int i=0;i<nof_subheaders;i++) {
|
||||
fprintf(stream, " -- Subheader %d: ", i);
|
||||
subheaders[i].fprint(stream);
|
||||
}
|
||||
}
|
||||
|
||||
/* Resets the Read/Write position and remaining PDU length */
|
||||
void reset() {
|
||||
cur_idx = -1;
|
||||
last_sdu_idx = -1;
|
||||
rem_len = pdu_len;
|
||||
}
|
||||
|
||||
void init_rx(uint32_t pdu_len_bytes, bool is_ulsch = false) {
|
||||
init_(NULL, pdu_len_bytes, is_ulsch);
|
||||
}
|
||||
|
||||
void init_tx(uint8_t *payload, uint32_t pdu_len_bytes, bool is_ulsch = false) {
|
||||
init_(payload, pdu_len_bytes, is_ulsch);
|
||||
}
|
||||
|
||||
uint32_t nof_subh() {
|
||||
return nof_subheaders;
|
||||
}
|
||||
|
||||
bool new_subh() {
|
||||
if (nof_subheaders < (int)max_subheaders - 1 && rem_len > 0) {
|
||||
nof_subheaders++;
|
||||
next();
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool next() {
|
||||
if (cur_idx < nof_subheaders - 1) {
|
||||
cur_idx++;
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void del_subh() {
|
||||
if (nof_subheaders > 0) {
|
||||
nof_subheaders--;
|
||||
}
|
||||
if (cur_idx > 0) {
|
||||
cur_idx--;
|
||||
}
|
||||
}
|
||||
|
||||
SubH* get() {
|
||||
if (cur_idx >= 0) {
|
||||
return &subheaders[cur_idx];
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
bool is_ul() {
|
||||
return pdu_is_ul;
|
||||
}
|
||||
|
||||
uint8_t* get_current_sdu_ptr() {
|
||||
return &buffer_tx[total_sdu_len+sdu_offset_start];
|
||||
}
|
||||
|
||||
void add_sdu(uint32_t sdu_sz) {
|
||||
total_sdu_len += sdu_sz;
|
||||
}
|
||||
|
||||
// Section 6.1.2
|
||||
void parse_packet(uint8_t *ptr) {
|
||||
uint8_t *init_ptr = ptr;
|
||||
nof_subheaders = 0;
|
||||
while(subheaders[nof_subheaders].read_subheader(&ptr)) {
|
||||
nof_subheaders++;
|
||||
}
|
||||
nof_subheaders++;
|
||||
for (int i=0;i<nof_subheaders;i++) {
|
||||
subheaders[i].read_payload(&ptr);
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
std::vector<SubH> subheaders;
|
||||
uint32_t pdu_len;
|
||||
uint32_t rem_len;
|
||||
int cur_idx;
|
||||
int nof_subheaders;
|
||||
uint32_t max_subheaders;
|
||||
bool pdu_is_ul;
|
||||
uint8_t* buffer_tx;
|
||||
uint32_t total_sdu_len;
|
||||
uint32_t sdu_offset_start;
|
||||
int last_sdu_idx;
|
||||
|
||||
private:
|
||||
|
||||
/* Prepares the PDU for parsing or writing by setting the number of subheaders to 0 and the pdu length */
|
||||
void init_(uint8_t *buffer_tx_ptr, uint32_t pdu_len_bytes, bool is_ulsch) {
|
||||
nof_subheaders = 0;
|
||||
pdu_len = pdu_len_bytes;
|
||||
rem_len = pdu_len;
|
||||
pdu_is_ul = is_ulsch;
|
||||
buffer_tx = buffer_tx_ptr;
|
||||
sdu_offset_start = max_subheaders*2 + 13; // Assuming worst-case 2 bytes per sdu subheader + all possible CE
|
||||
total_sdu_len = 0;
|
||||
last_sdu_idx = -1;
|
||||
reset();
|
||||
for (uint32_t i=0;i<max_subheaders;i++) {
|
||||
subheaders[i].parent = this;
|
||||
subheaders[i].init();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<class SubH>
|
||||
class subh
|
||||
{
|
||||
public:
|
||||
|
||||
virtual bool read_subheader(uint8_t** ptr) = 0;
|
||||
virtual void read_payload(uint8_t **ptr) = 0;
|
||||
virtual void write_subheader(uint8_t** ptr, bool is_last) = 0;
|
||||
virtual void write_payload(uint8_t **ptr) = 0;
|
||||
virtual void fprint(FILE *stream) = 0;
|
||||
|
||||
pdu<SubH>* parent;
|
||||
private:
|
||||
virtual void init() = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
class sch_subh : public subh<sch_subh>
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
typedef enum {
|
||||
PHR_REPORT = 26,
|
||||
CRNTI = 27,
|
||||
CON_RES_ID = 28,
|
||||
TRUNC_BSR = 28,
|
||||
TA_CMD = 29,
|
||||
SHORT_BSR = 29,
|
||||
DRX_CMD = 30,
|
||||
LONG_BSR = 30,
|
||||
PADDING = 31,
|
||||
SDU = 0
|
||||
} cetype;
|
||||
|
||||
// Size of MAC CEs
|
||||
const static int MAC_CE_CONTRES_LEN = 6;
|
||||
|
||||
// Reading functions
|
||||
bool is_sdu();
|
||||
cetype ce_type();
|
||||
uint32_t size_plus_header();
|
||||
void set_payload_size(uint32_t size);
|
||||
|
||||
bool read_subheader(uint8_t** ptr);
|
||||
void read_payload(uint8_t **ptr);
|
||||
uint32_t get_sdu_lcid();
|
||||
uint32_t get_payload_size();
|
||||
uint32_t get_header_size(bool is_last);
|
||||
uint8_t* get_sdu_ptr();
|
||||
|
||||
uint16_t get_c_rnti();
|
||||
uint64_t get_con_res_id();
|
||||
uint8_t get_ta_cmd();
|
||||
float get_phr();
|
||||
int get_bsr(uint32_t buff_size[4]);
|
||||
|
||||
// Writing functions
|
||||
void write_subheader(uint8_t** ptr, bool is_last);
|
||||
void write_payload(uint8_t **ptr);
|
||||
int set_sdu(uint32_t lcid, uint32_t nof_bytes, uint8_t *payload);
|
||||
int set_sdu(uint32_t lcid, uint32_t requested_bytes, read_pdu_interface *sdu_itf);
|
||||
bool set_c_rnti(uint16_t crnti);
|
||||
bool set_bsr(uint32_t buff_size[4], sch_subh::cetype format);
|
||||
bool set_con_res_id(uint64_t con_res_id);
|
||||
bool set_ta_cmd(uint8_t ta_cmd);
|
||||
bool set_phr(float phr);
|
||||
void set_padding();
|
||||
void set_padding(uint32_t padding_len);
|
||||
|
||||
void init();
|
||||
void fprint(FILE *stream);
|
||||
|
||||
|
||||
private:
|
||||
static const int MAX_CE_PAYLOAD_LEN = 8;
|
||||
uint32_t lcid;
|
||||
int nof_bytes;
|
||||
uint8_t* payload;
|
||||
uint8_t w_payload_ce[8];
|
||||
bool F_bit;
|
||||
uint32_t sizeof_ce(uint32_t lcid, bool is_ul);
|
||||
static uint8_t buff_size_table(uint32_t buffer_size);
|
||||
static uint8_t phr_report_table(float phr_value);
|
||||
};
|
||||
|
||||
class sch_pdu : public pdu<sch_subh>
|
||||
{
|
||||
public:
|
||||
|
||||
sch_pdu(uint32_t max_subh) : pdu(max_subh) {}
|
||||
|
||||
void parse_packet(uint8_t *ptr);
|
||||
uint8_t* write_packet();
|
||||
uint8_t* write_packet(srslte::log *log_h);
|
||||
bool has_space_ce(uint32_t nbytes);
|
||||
bool has_space_sdu(uint32_t nbytes);
|
||||
int get_pdu_len();
|
||||
int rem_size();
|
||||
int get_sdu_space();
|
||||
|
||||
static uint32_t size_header_sdu(uint32_t nbytes);
|
||||
bool update_space_ce(uint32_t nbytes);
|
||||
bool update_space_sdu(uint32_t nbytes);
|
||||
void fprint(FILE *stream);
|
||||
};
|
||||
|
||||
class rar_subh : public subh<rar_subh>
|
||||
{
|
||||
public:
|
||||
|
||||
static const uint32_t RAR_GRANT_LEN = 20;
|
||||
|
||||
// Reading functions
|
||||
bool read_subheader(uint8_t** ptr);
|
||||
void read_payload(uint8_t** ptr);
|
||||
uint32_t get_rapid();
|
||||
uint32_t get_ta_cmd();
|
||||
uint16_t get_temp_crnti();
|
||||
void get_sched_grant(uint8_t grant[RAR_GRANT_LEN]);
|
||||
|
||||
// Writing functoins
|
||||
void write_subheader(uint8_t** ptr, bool is_last);
|
||||
void write_payload(uint8_t** ptr);
|
||||
void set_rapid(uint32_t rapid);
|
||||
void set_ta_cmd(uint32_t ta);
|
||||
void set_temp_crnti(uint16_t temp_rnti);
|
||||
void set_sched_grant(uint8_t grant[RAR_GRANT_LEN]);
|
||||
|
||||
void init();
|
||||
void fprint(FILE *stream);
|
||||
|
||||
private:
|
||||
uint8_t grant[RAR_GRANT_LEN];
|
||||
uint32_t ta;
|
||||
uint16_t temp_rnti;
|
||||
uint32_t preamble;
|
||||
};
|
||||
|
||||
class rar_pdu : public pdu<rar_subh>
|
||||
{
|
||||
public:
|
||||
|
||||
rar_pdu(uint32_t max_rars = 16);
|
||||
|
||||
void set_backoff(uint8_t bi);
|
||||
bool has_backoff();
|
||||
uint8_t get_backoff();
|
||||
|
||||
bool write_packet(uint8_t* ptr);
|
||||
void fprint(FILE *stream);
|
||||
|
||||
private:
|
||||
bool has_backoff_indicator;
|
||||
uint8_t backoff_indicator;
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // MACPDU_H
|
||||
@ -0,0 +1,85 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef PDUPROC_H
|
||||
#define PDUPROC_H
|
||||
|
||||
#include "srslte/common/log.h"
|
||||
#include "srslte/common/block_queue.h"
|
||||
#include "srslte/common/buffer_pool.h"
|
||||
#include "srslte/common/timers.h"
|
||||
#include "srslte/common/pdu.h"
|
||||
|
||||
/* Logical Channel Demultiplexing and MAC CE dissassemble */
|
||||
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class pdu_queue
|
||||
{
|
||||
public:
|
||||
class process_callback
|
||||
{
|
||||
public:
|
||||
virtual void process_pdu(uint8_t *buff, uint32_t len, uint32_t tstamp) = 0;
|
||||
};
|
||||
|
||||
pdu_queue(uint32_t pool_size = DEFAULT_POOL_SIZE) : pool(pool_size), callback(NULL), log_h(NULL) {}
|
||||
void init(process_callback *callback, log* log_h_);
|
||||
|
||||
uint8_t* request(uint32_t len);
|
||||
void deallocate(uint8_t* pdu);
|
||||
void push(uint8_t *ptr, uint32_t len, uint32_t tstamp = 0);
|
||||
|
||||
bool process_pdus();
|
||||
|
||||
private:
|
||||
const static int DEFAULT_POOL_SIZE = 64; // Number of PDU buffers in total
|
||||
const static int MAX_PDU_LEN = 150*1024/8; // ~ 150 Mbps
|
||||
|
||||
typedef struct {
|
||||
uint8_t ptr[MAX_PDU_LEN];
|
||||
uint32_t len;
|
||||
uint32_t tstamp;
|
||||
#ifdef SRSLTE_BUFFER_POOL_LOG_ENABLED
|
||||
char debug_name[128];
|
||||
#endif
|
||||
|
||||
} pdu_t;
|
||||
|
||||
block_queue<pdu_t*> pdu_q;
|
||||
buffer_pool<pdu_t> pool;
|
||||
|
||||
process_callback *callback;
|
||||
log *log_h;
|
||||
};
|
||||
|
||||
} // namespace srslte
|
||||
|
||||
#endif // PDUPROC_H
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,151 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SECURITY_H
|
||||
#define SECURITY_H
|
||||
|
||||
/******************************************************************************
|
||||
* Common security header - wraps ciphering/integrity check algorithms.
|
||||
*****************************************************************************/
|
||||
|
||||
|
||||
#include "srslte/common/common.h"
|
||||
|
||||
|
||||
#define SECURITY_DIRECTION_UPLINK 0
|
||||
#define SECURITY_DIRECTION_DOWNLINK 1
|
||||
|
||||
namespace srslte {
|
||||
|
||||
typedef enum{
|
||||
CIPHERING_ALGORITHM_ID_EEA0 = 0,
|
||||
CIPHERING_ALGORITHM_ID_128_EEA1,
|
||||
CIPHERING_ALGORITHM_ID_128_EEA2,
|
||||
CIPHERING_ALGORITHM_ID_N_ITEMS,
|
||||
}CIPHERING_ALGORITHM_ID_ENUM;
|
||||
static const char ciphering_algorithm_id_text[CIPHERING_ALGORITHM_ID_N_ITEMS][20] = {"EEA0",
|
||||
"128-EEA1",
|
||||
"128-EEA2"};
|
||||
typedef enum{
|
||||
INTEGRITY_ALGORITHM_ID_EIA0 = 0,
|
||||
INTEGRITY_ALGORITHM_ID_128_EIA1,
|
||||
INTEGRITY_ALGORITHM_ID_128_EIA2,
|
||||
INTEGRITY_ALGORITHM_ID_N_ITEMS,
|
||||
}INTEGRITY_ALGORITHM_ID_ENUM;
|
||||
static const char integrity_algorithm_id_text[INTEGRITY_ALGORITHM_ID_N_ITEMS][20] = {"EIA0",
|
||||
"128-EIA1",
|
||||
"128-EIA2"};
|
||||
|
||||
|
||||
/******************************************************************************
|
||||
* Key Generation
|
||||
*****************************************************************************/
|
||||
|
||||
uint8_t security_generate_k_asme( uint8_t *ck,
|
||||
uint8_t *ik,
|
||||
uint8_t *ak,
|
||||
uint8_t *sqn,
|
||||
uint16_t mcc,
|
||||
uint16_t mnc,
|
||||
uint8_t *k_asme);
|
||||
|
||||
uint8_t security_generate_k_enb( uint8_t *k_asme,
|
||||
uint32_t nas_count,
|
||||
uint8_t *k_enb);
|
||||
|
||||
uint8_t security_generate_k_nas( uint8_t *k_asme,
|
||||
CIPHERING_ALGORITHM_ID_ENUM enc_alg_id,
|
||||
INTEGRITY_ALGORITHM_ID_ENUM int_alg_id,
|
||||
uint8_t *k_nas_enc,
|
||||
uint8_t *k_nas_int);
|
||||
|
||||
uint8_t security_generate_k_rrc( uint8_t *k_enb,
|
||||
CIPHERING_ALGORITHM_ID_ENUM enc_alg_id,
|
||||
INTEGRITY_ALGORITHM_ID_ENUM int_alg_id,
|
||||
uint8_t *k_rrc_enc,
|
||||
uint8_t *k_rrc_int);
|
||||
|
||||
uint8_t security_generate_k_up( uint8_t *k_enb,
|
||||
CIPHERING_ALGORITHM_ID_ENUM enc_alg_id,
|
||||
INTEGRITY_ALGORITHM_ID_ENUM int_alg_id,
|
||||
uint8_t *k_up_enc,
|
||||
uint8_t *k_up_int);
|
||||
|
||||
/******************************************************************************
|
||||
* Integrity Protection
|
||||
*****************************************************************************/
|
||||
|
||||
uint8_t security_128_eia1( uint8_t *key,
|
||||
uint32_t count,
|
||||
uint8_t bearer,
|
||||
uint8_t direction,
|
||||
uint8_t *msg,
|
||||
uint32_t msg_len,
|
||||
uint8_t *mac);
|
||||
|
||||
uint8_t security_128_eia2( uint8_t *key,
|
||||
uint32_t count,
|
||||
uint8_t bearer,
|
||||
uint8_t direction,
|
||||
uint8_t *msg,
|
||||
uint32_t msg_len,
|
||||
uint8_t *mac);
|
||||
|
||||
/******************************************************************************
|
||||
* Authentication
|
||||
*****************************************************************************/
|
||||
|
||||
uint8_t security_milenage_f1( uint8_t *k,
|
||||
uint8_t *op,
|
||||
uint8_t *rand,
|
||||
uint8_t *sqn,
|
||||
uint8_t *amf,
|
||||
uint8_t *mac_a);
|
||||
|
||||
uint8_t security_milenage_f1_star( uint8_t *k,
|
||||
uint8_t *op,
|
||||
uint8_t *rand,
|
||||
uint8_t *sqn,
|
||||
uint8_t *amf,
|
||||
uint8_t *mac_s);
|
||||
|
||||
uint8_t security_milenage_f2345( uint8_t *k,
|
||||
uint8_t *op,
|
||||
uint8_t *rand,
|
||||
uint8_t *res,
|
||||
uint8_t *ck,
|
||||
uint8_t *ik,
|
||||
uint8_t *ak);
|
||||
|
||||
uint8_t security_milenage_f5_star( uint8_t *k,
|
||||
uint8_t *op,
|
||||
uint8_t *rand,
|
||||
uint8_t *ak);
|
||||
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // SECURITY_H
|
||||
@ -0,0 +1,71 @@
|
||||
/*---------------------------------------------------------
|
||||
* snow_3g.h
|
||||
*
|
||||
* Adapted from ETSI/SAGE specifications:
|
||||
* "Specification of the 3GPP Confidentiality and
|
||||
* Integrity Algorithms UEA2 & UIA2.
|
||||
* Document 1: UEA2 and UIA2 Specification"
|
||||
* "Specification of the 3GPP Confidentiality
|
||||
* and Integrity Algorithms UEA2 & UIA2.
|
||||
* Document 2: SNOW 3G Specification"
|
||||
*---------------------------------------------------------*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
typedef unsigned char u8;
|
||||
typedef unsigned int u32;
|
||||
typedef unsigned long long u64;
|
||||
|
||||
/* Initialization.
|
||||
* Input k[4]: Four 32-bit words making up 128-bit key.
|
||||
* Input IV[4]: Four 32-bit words making 128-bit initialization variable.
|
||||
* Output: All the LFSRs and FSM are initialized for key generation.
|
||||
* See Section 4.1.
|
||||
*/
|
||||
|
||||
void snow3g_initialize(u32 k[4], u32 IV[4]);
|
||||
|
||||
/* Generation of Keystream.
|
||||
* input n: number of 32-bit words of keystream.
|
||||
* input z: space for the generated keystream, assumes
|
||||
* memory is allocated already.
|
||||
* output: generated keystream which is filled in z
|
||||
* See section 4.2.
|
||||
*/
|
||||
|
||||
void snow3g_generate_keystream(u32 n, u32 *z);
|
||||
|
||||
/* f8.
|
||||
* Input key: 128 bit Confidentiality Key.
|
||||
* Input count:32-bit Count, Frame dependent input.
|
||||
* Input bearer: 5-bit Bearer identity (in the LSB side).
|
||||
* Input dir:1 bit, direction of transmission.
|
||||
* Input data: length number of bits, input bit stream.
|
||||
* Input length: 32 bit Length, i.e., the number of bits to be encrypted or
|
||||
* decrypted.
|
||||
* Output data: Output bit stream. Assumes data is suitably memory
|
||||
* allocated.
|
||||
* Encrypts/decrypts blocks of data between 1 and 2^32 bits in length as
|
||||
* defined in Section 3.
|
||||
*/
|
||||
|
||||
void snow3g_f8( u8 *key, u32 count, u32 bearer, u32 dir, \
|
||||
u8 *data, u32 length );
|
||||
|
||||
/* f9.
|
||||
* Input key: 128 bit Integrity Key.
|
||||
* Input count:32-bit Count, Frame dependent input.
|
||||
* Input fresh: 32-bit Random number.
|
||||
* Input dir:1 bit, direction of transmission (in the LSB).
|
||||
* Input data: length number of bits, input bit stream.
|
||||
* Input length: 64 bit Length, i.e., the number of bits to be MAC'd.
|
||||
* Output : 32 bit block used as MAC
|
||||
* Generates 32-bit MAC using UIA2 algorithm as defined in Section 4.
|
||||
*/
|
||||
|
||||
u8* snow3g_f9( u8* key, u32 count, u32 fresh, u32 dir, \
|
||||
u8 *data, u64 length);
|
||||
|
||||
@ -0,0 +1,61 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: task_dispatcher.h
|
||||
* Description:
|
||||
* Reference:
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef TASK_DISPATCHER_H
|
||||
#define TASK_DISPATCHER_H
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
#include <queue>
|
||||
#include "srslte/common/threads.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class task_dispatcher : public thread
|
||||
{
|
||||
public:
|
||||
task_dispatcher(uint32_t max_pending_tasks);
|
||||
~task_dispatcher();
|
||||
void push_task(uint32_t task_code);
|
||||
virtual void run_task(uint32_t task_code) = 0;
|
||||
private:
|
||||
std::queue<uint32_t> pending_tasks;
|
||||
void run_thread();
|
||||
pthread_mutex_t mutex;
|
||||
pthread_cond_t cvar;
|
||||
bool running;
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // TASK_DISPATCHER_H
|
||||
@ -0,0 +1,105 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: thread_pool.h
|
||||
* Description: Implements a pool of threads. Pending tasks to execute are
|
||||
* identified by a pointer.
|
||||
* Reference:
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef THREAD_POOL_H
|
||||
#define THREAD_POOL_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <stack>
|
||||
|
||||
#include "srslte/common/threads.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class thread_pool
|
||||
{
|
||||
public:
|
||||
|
||||
class worker : public thread
|
||||
{
|
||||
public:
|
||||
void setup(uint32_t id, thread_pool *parent, uint32_t prio=0, uint32_t mask = 255);
|
||||
void stop();
|
||||
uint32_t get_id();
|
||||
void release();
|
||||
protected:
|
||||
virtual void work_imp() = 0;
|
||||
private:
|
||||
uint32_t my_id;
|
||||
thread_pool *my_parent;
|
||||
bool running;
|
||||
void run_thread();
|
||||
void wait_to_start();
|
||||
void finished();
|
||||
};
|
||||
|
||||
|
||||
thread_pool(uint32_t nof_workers);
|
||||
void init_worker(uint32_t id, worker*, uint32_t prio = 0, uint32_t mask = 255);
|
||||
void stop();
|
||||
worker* wait_worker();
|
||||
worker* wait_worker(uint32_t tti);
|
||||
worker* wait_worker_nb(uint32_t tti);
|
||||
void start_worker(worker*);
|
||||
void start_worker(uint32_t id);
|
||||
worker* get_worker(uint32_t id);
|
||||
uint32_t get_nof_workers();
|
||||
|
||||
|
||||
private:
|
||||
|
||||
bool find_finished_worker(uint32_t tti, uint32_t *id);
|
||||
|
||||
typedef enum {
|
||||
IDLE,
|
||||
START_WORK,
|
||||
WORKER_READY,
|
||||
WORKING
|
||||
}worker_status;
|
||||
|
||||
std::vector<worker*> workers;
|
||||
uint32_t nof_workers;
|
||||
uint32_t max_workers;
|
||||
bool running;
|
||||
pthread_cond_t cvar_queue;
|
||||
pthread_mutex_t mutex_queue;
|
||||
std::vector<worker_status> status;
|
||||
std::vector<pthread_cond_t> cvar;
|
||||
std::vector<pthread_mutex_t> mutex;
|
||||
std::stack<worker*> available_workers;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,151 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/timerfd.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif // __cplusplus
|
||||
|
||||
bool threads_new_rt(pthread_t *thread, void *(*start_routine) (void*), void *arg);
|
||||
bool threads_new_rt_prio(pthread_t *thread, void *(*start_routine) (void*), void *arg, int prio_offset);
|
||||
bool threads_new_rt_cpu(pthread_t *thread, void *(*start_routine) (void*), void *arg, int cpu, int prio_offset);
|
||||
bool threads_new_rt_mask(pthread_t *thread, void *(*start_routine) (void*), void *arg, int mask, int prio_offset);
|
||||
void threads_print_self();
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
#ifndef THREADS_
|
||||
#define THREADS_
|
||||
|
||||
class thread
|
||||
{
|
||||
public:
|
||||
bool start(int prio = -1) {
|
||||
return threads_new_rt_prio(&_thread, thread_function_entry, this, prio);
|
||||
}
|
||||
bool start_cpu(int prio, int cpu) {
|
||||
return threads_new_rt_cpu(&_thread, thread_function_entry, this, cpu, prio);
|
||||
}
|
||||
bool start_cpu_mask(int prio, int mask){
|
||||
return threads_new_rt_mask(&_thread, thread_function_entry, this, mask, prio);
|
||||
}
|
||||
void print_priority() {
|
||||
threads_print_self();
|
||||
}
|
||||
void wait_thread_finish() {
|
||||
pthread_join(_thread, NULL);
|
||||
}
|
||||
void thread_cancel() {
|
||||
pthread_cancel(_thread);
|
||||
}
|
||||
protected:
|
||||
virtual void run_thread() = 0;
|
||||
private:
|
||||
static void *thread_function_entry(void *_this) { ((thread*) _this)->run_thread(); return NULL; }
|
||||
pthread_t _thread;
|
||||
};
|
||||
|
||||
class periodic_thread : public thread
|
||||
{
|
||||
public:
|
||||
void start_periodic(int period_us_, int priority = -1) {
|
||||
period_us = period_us_;
|
||||
start(priority);
|
||||
}
|
||||
protected:
|
||||
virtual void run_period() = 0;
|
||||
private:
|
||||
int wakeups_missed;
|
||||
int timer_fd;
|
||||
int period_us;
|
||||
void run_thread() {
|
||||
if (make_periodic()) {
|
||||
return;
|
||||
}
|
||||
while(1) {
|
||||
run_period();
|
||||
wait_period();
|
||||
}
|
||||
}
|
||||
int make_periodic() {
|
||||
int ret = -1;
|
||||
unsigned int ns;
|
||||
unsigned int sec;
|
||||
struct itimerspec itval;
|
||||
|
||||
/* Create the timer */
|
||||
ret = timerfd_create (CLOCK_MONOTONIC, 0);
|
||||
wakeups_missed = 0;
|
||||
timer_fd = ret;
|
||||
if (ret > 0) {
|
||||
/* Make the timer periodic */
|
||||
sec = period_us/1e6;
|
||||
ns = (period_us - (sec * 1000000)) * 1000;
|
||||
itval.it_interval.tv_sec = sec;
|
||||
itval.it_interval.tv_nsec = ns;
|
||||
itval.it_value.tv_sec = sec;
|
||||
itval.it_value.tv_nsec = ns;
|
||||
ret = timerfd_settime (timer_fd, 0, &itval, NULL);
|
||||
if (ret < 0) {
|
||||
perror("timerfd_settime");
|
||||
}
|
||||
} else {
|
||||
perror("timerfd_create");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
void wait_period() {
|
||||
unsigned long long missed;
|
||||
int ret;
|
||||
|
||||
/* Wait for the next timer event. If we have missed any the
|
||||
number is written to "missed" */
|
||||
ret = read (timer_fd, &missed, sizeof (missed));
|
||||
if (ret == -1)
|
||||
{
|
||||
perror ("read timer");
|
||||
return;
|
||||
}
|
||||
|
||||
/* "missed" should always be >= 1, but just to be sure, check it is not 0 anyway */
|
||||
if (missed > 0) {
|
||||
wakeups_missed += (missed - 1);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // THREADS_
|
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
@ -0,0 +1,124 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: timeout.h
|
||||
* Description: Millisecond resolution timeouts. Uses a dedicated thread to
|
||||
* call an optional callback function upon timeout expiry.
|
||||
* Reference:
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef TIMEOUT_H
|
||||
#define TIMEOUT_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/time.h>
|
||||
#include "srslte/srslte.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class timeout_callback
|
||||
{
|
||||
public:
|
||||
virtual void timeout_expired(uint32_t timeout_id) = 0;
|
||||
};
|
||||
|
||||
class timeout
|
||||
{
|
||||
public:
|
||||
timeout():running(false),callback(NULL), thread(0), timeout_id(0) {}
|
||||
~timeout()
|
||||
{
|
||||
if(running && callback)
|
||||
pthread_join(thread, NULL);
|
||||
}
|
||||
void start(int duration_msec_, uint32_t timeout_id_=0,timeout_callback *callback_=NULL)
|
||||
{
|
||||
if(duration_msec_ < 0)
|
||||
return;
|
||||
reset();
|
||||
gettimeofday(&start_time[1], NULL);
|
||||
duration_msec = duration_msec_;
|
||||
running = true;
|
||||
timeout_id = timeout_id_;
|
||||
callback = callback_;
|
||||
if(callback)
|
||||
pthread_create(&thread, NULL, &thread_start, this);
|
||||
}
|
||||
void reset()
|
||||
{
|
||||
if(callback)
|
||||
pthread_cancel(thread);
|
||||
running = false;
|
||||
}
|
||||
static void* thread_start(void *t_)
|
||||
{
|
||||
timeout *t = (timeout*)t_;
|
||||
t->thread_func();
|
||||
return NULL;
|
||||
}
|
||||
void thread_func()
|
||||
{
|
||||
|
||||
// substract time elapsed until now from timer duration
|
||||
gettimeofday(&start_time[2], NULL);
|
||||
get_time_interval(start_time);
|
||||
|
||||
int32_t usec = duration_msec*1000-start_time[0].tv_usec;
|
||||
if(usec > 0)
|
||||
usleep(usec);
|
||||
if(callback && running)
|
||||
callback->timeout_expired(timeout_id);
|
||||
}
|
||||
bool expired()
|
||||
{
|
||||
if(running) {
|
||||
gettimeofday(&start_time[2], NULL);
|
||||
get_time_interval(start_time);
|
||||
return start_time[0].tv_usec > duration_msec*1000;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
bool is_running()
|
||||
{
|
||||
return running;
|
||||
}
|
||||
|
||||
private:
|
||||
struct timeval start_time[3];
|
||||
pthread_t thread;
|
||||
uint32_t timeout_id;
|
||||
timeout_callback *callback;
|
||||
bool running;
|
||||
int duration_msec;
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // TIMEOUT_H
|
||||
@ -0,0 +1,151 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/******************************************************************************
|
||||
* File: timers.h
|
||||
* Description: Manually incremented timers. Call a callback function upon
|
||||
* expiry.
|
||||
* Reference:
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef TIMERS_H
|
||||
#define TIMERS_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <vector>
|
||||
#include <time.h>
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class timer_callback
|
||||
{
|
||||
public:
|
||||
virtual void timer_expired(uint32_t timer_id) = 0;
|
||||
};
|
||||
|
||||
class timers
|
||||
{
|
||||
public:
|
||||
class timer
|
||||
{
|
||||
public:
|
||||
timer(uint32_t id_=0) {id = id_; counter = 0; timeout = 0; running = false; callback = NULL; }
|
||||
void set(timer_callback *callback_, uint32_t timeout_) {
|
||||
callback = callback_;
|
||||
timeout = timeout_;
|
||||
reset();
|
||||
}
|
||||
bool is_running() {
|
||||
return (counter < timeout) && running;
|
||||
}
|
||||
bool is_expired() {
|
||||
return callback && (counter >= timeout || !running);
|
||||
}
|
||||
uint32_t get_timeout() {
|
||||
return timeout;
|
||||
}
|
||||
void reset() {
|
||||
counter = 0;
|
||||
}
|
||||
void step() {
|
||||
if (running) {
|
||||
counter++;
|
||||
if (is_expired()) {
|
||||
running = false;
|
||||
if (callback) {
|
||||
callback->timer_expired(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
void stop() {
|
||||
running = false;
|
||||
}
|
||||
void run() {
|
||||
running = true;
|
||||
}
|
||||
uint32_t id;
|
||||
private:
|
||||
timer_callback *callback;
|
||||
uint32_t timeout;
|
||||
uint32_t counter;
|
||||
bool running;
|
||||
};
|
||||
|
||||
timers(uint32_t nof_timers_) : timer_list(nof_timers_) {
|
||||
nof_timers = nof_timers_;
|
||||
next_timer = 0;
|
||||
for (uint32_t i=0;i<nof_timers;i++) {
|
||||
timer_list[i].id = i;
|
||||
}
|
||||
}
|
||||
|
||||
void step_all() {
|
||||
for (uint32_t i=0;i<nof_timers;i++) {
|
||||
get(i)->step();
|
||||
}
|
||||
}
|
||||
void stop_all() {
|
||||
for (uint32_t i=0;i<nof_timers;i++) {
|
||||
get(i)->stop();
|
||||
}
|
||||
}
|
||||
void run_all() {
|
||||
for (uint32_t i=0;i<nof_timers;i++) {
|
||||
get(i)->run();
|
||||
}
|
||||
}
|
||||
void reset_all() {
|
||||
for (uint32_t i=0;i<nof_timers;i++) {
|
||||
get(i)->reset();
|
||||
}
|
||||
}
|
||||
timer *get(uint32_t i) {
|
||||
if (i < nof_timers) {
|
||||
return &timer_list[i];
|
||||
} else {
|
||||
printf("Error accessing invalid timer %d (Only %d timers available)\n", i, nof_timers);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
uint32_t get_unique_id() {
|
||||
if (next_timer == nof_timers){
|
||||
printf("No more unique timer ids (Only %d timers available)\n", nof_timers);
|
||||
next_timer = 0;
|
||||
}
|
||||
return next_timer++;
|
||||
}
|
||||
private:
|
||||
uint32_t nof_timers;
|
||||
uint32_t next_timer;
|
||||
std::vector<timer> timer_list;
|
||||
};
|
||||
|
||||
} // namespace srslte
|
||||
|
||||
#endif // TIMERS_H
|
||||
@ -0,0 +1,101 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: trace.h
|
||||
* Description:
|
||||
* Reference:
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef TRACE_H
|
||||
#define TRACE_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace srslte {
|
||||
|
||||
template<class elemType>
|
||||
class trace
|
||||
{
|
||||
public:
|
||||
|
||||
trace(uint32_t nof_elems_) : tti(nof_elems_), data(nof_elems_) {
|
||||
rpm=0;
|
||||
nof_elems=nof_elems_;
|
||||
wrapped = false;
|
||||
};
|
||||
void push_cur_time_us(uint32_t cur_tti) {
|
||||
struct timeval t;
|
||||
gettimeofday(&t, NULL);
|
||||
elemType us = t.tv_sec*1e6+t.tv_usec;
|
||||
push(cur_tti, us);
|
||||
}
|
||||
void push(uint32_t value_tti, elemType value) {
|
||||
tti[rpm] = value_tti;
|
||||
data[rpm] = value;
|
||||
rpm++;
|
||||
if (rpm >= nof_elems) {
|
||||
rpm = 0;
|
||||
wrapped = true;
|
||||
}
|
||||
}
|
||||
bool writeToBinary(std::string filename) {
|
||||
FILE *f = fopen(filename.c_str(), "w");
|
||||
if (f != NULL) {
|
||||
uint32_t st=wrapped?(rpm+1):0;
|
||||
do {
|
||||
writeToBinaryValue(f, st++);
|
||||
if (st >= nof_elems) {
|
||||
st=0;
|
||||
}
|
||||
} while(st!=rpm);
|
||||
fclose(f);
|
||||
return true;
|
||||
} else {
|
||||
perror("fopen");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
std::vector<uint32_t> tti;
|
||||
std::vector<elemType> data;
|
||||
uint32_t rpm;
|
||||
uint32_t nof_elems;
|
||||
bool wrapped;
|
||||
|
||||
void writeToBinaryValue(FILE *f, uint32_t idx) {
|
||||
fwrite(&tti[idx], 1, sizeof(uint32_t), f);
|
||||
fwrite(&data[idx], 1, sizeof(elemType), f);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // namespace srslte
|
||||
|
||||
#endif // TRACE_H
|
||||
@ -0,0 +1,78 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: tti_synch.h
|
||||
* Description: Interface used for PHY-MAC synchronization
|
||||
* (producer-consumer model). The consumer waits while its
|
||||
* counter is lower than the producer counter.
|
||||
* The PHY is the consumer. The MAC is the producer.
|
||||
* Reference:
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef TTISYNC_H
|
||||
#define TTISYNC_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class tti_sync
|
||||
{
|
||||
public:
|
||||
tti_sync(uint32_t modulus_)
|
||||
{
|
||||
modulus = modulus_;
|
||||
increment = 1;
|
||||
init_counters(0);
|
||||
}
|
||||
virtual void increase() = 0;
|
||||
virtual void resync() = 0;
|
||||
virtual uint32_t wait() = 0;
|
||||
virtual void set_producer_cntr(uint32_t) = 0;
|
||||
uint32_t get_producer_cntr() { return producer_cntr; }
|
||||
uint32_t get_consumer_cntr() { return consumer_cntr; }
|
||||
void set_increment(uint32_t increment_) {
|
||||
increment = increment_;
|
||||
}
|
||||
protected:
|
||||
void increase_producer() { producer_cntr = (producer_cntr + increment)%modulus; }
|
||||
void increase_consumer() { consumer_cntr = (consumer_cntr + increment)%modulus; }
|
||||
bool wait_condition() { return producer_cntr == consumer_cntr; }
|
||||
void init_counters(uint32_t val)
|
||||
{
|
||||
consumer_cntr = val;
|
||||
producer_cntr = val;
|
||||
}
|
||||
uint32_t increment;
|
||||
uint32_t modulus;
|
||||
uint32_t producer_cntr;
|
||||
uint32_t consumer_cntr;
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // TTISYNC_H
|
||||
@ -0,0 +1,58 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: tti_synch_cv.h
|
||||
* Description: Implements tti_sync interface with condition variables.
|
||||
* Reference:
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef TTISYNC_CV_H
|
||||
#define TTISYNC_CV_H
|
||||
|
||||
#include <pthread.h>
|
||||
#include "srslte/common/tti_sync.h"
|
||||
|
||||
namespace srslte {
|
||||
|
||||
class tti_sync_cv : public tti_sync
|
||||
{
|
||||
public:
|
||||
tti_sync_cv(uint32_t modulus = 10240);
|
||||
~tti_sync_cv();
|
||||
void increase();
|
||||
uint32_t wait();
|
||||
void resync();
|
||||
void set_producer_cntr(uint32_t producer_cntr);
|
||||
|
||||
private:
|
||||
pthread_cond_t cond;
|
||||
pthread_mutex_t mutex;
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // TTISYNC_CV_H
|
||||
@ -0,0 +1,268 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2017 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of srsLTE.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "srslte/srslte.h"
|
||||
|
||||
#include "srslte/common/common.h"
|
||||
#include "srslte/common/security.h"
|
||||
#include "srslte/interfaces/sched_interface.h"
|
||||
#include "srslte/asn1/liblte_rrc.h"
|
||||
#include "srslte/asn1/liblte_s1ap.h"
|
||||
|
||||
#include <vector>
|
||||
|
||||
#ifndef ENBINTERFACES_H
|
||||
#define ENBINTERFACES_H
|
||||
|
||||
namespace srsenb {
|
||||
|
||||
/* Interface PHY -> MAC */
|
||||
class mac_interface_phy
|
||||
{
|
||||
public:
|
||||
const static int MAX_GRANTS = 64;
|
||||
|
||||
typedef struct {
|
||||
srslte_enb_dl_pdsch_t sched_grants[MAX_GRANTS];
|
||||
uint32_t nof_grants;
|
||||
uint32_t cfi;
|
||||
} dl_sched_t;
|
||||
|
||||
typedef struct {
|
||||
srslte_enb_ul_pusch_t sched_grants[MAX_GRANTS];
|
||||
srslte_enb_dl_phich_t phich[MAX_GRANTS];
|
||||
uint32_t nof_grants;
|
||||
uint32_t nof_phich;
|
||||
} ul_sched_t;
|
||||
|
||||
|
||||
virtual int sr_detected(uint32_t tti, uint16_t rnti) = 0;
|
||||
virtual int rach_detected(uint32_t tti, uint32_t preamble_idx, uint32_t time_adv) = 0;
|
||||
|
||||
virtual int cqi_info(uint32_t tti, uint16_t rnti, uint32_t cqi_value) = 0;
|
||||
virtual int snr_info(uint32_t tti, uint16_t rnti, float snr_db) = 0;
|
||||
virtual int ack_info(uint32_t tti, uint16_t rnti, bool ack) = 0;
|
||||
virtual int crc_info(uint32_t tti, uint16_t rnti, uint32_t nof_bytes, bool crc_res) = 0;
|
||||
|
||||
virtual int get_dl_sched(uint32_t tti, dl_sched_t *dl_sched_res) = 0;
|
||||
virtual int get_ul_sched(uint32_t tti, ul_sched_t *ul_sched_res) = 0;
|
||||
|
||||
// Radio-Link status
|
||||
virtual void rl_failure(uint16_t rnti) = 0;
|
||||
virtual void rl_ok(uint16_t rnti) = 0;
|
||||
|
||||
virtual void tti_clock() = 0;
|
||||
};
|
||||
|
||||
/* Interface MAC -> PHY */
|
||||
class phy_interface_mac
|
||||
{
|
||||
public:
|
||||
|
||||
/* MAC adds/removes an RNTI to the list of active RNTIs */
|
||||
virtual int add_rnti(uint16_t rnti) = 0;
|
||||
virtual void rem_rnti(uint16_t rnti) = 0;
|
||||
};
|
||||
|
||||
/* Interface RRC -> PHY */
|
||||
class phy_interface_rrc
|
||||
{
|
||||
public:
|
||||
virtual void set_config_dedicated(uint16_t rnti, LIBLTE_RRC_PHYSICAL_CONFIG_DEDICATED_STRUCT* dedicated) = 0;
|
||||
|
||||
};
|
||||
|
||||
class mac_interface_rrc
|
||||
{
|
||||
public:
|
||||
/* Provides cell configuration including SIB periodicity, etc. */
|
||||
virtual int cell_cfg(sched_interface::cell_cfg_t *cell_cfg) = 0;
|
||||
virtual void reset() = 0;
|
||||
|
||||
/* Manages UE configuration context */
|
||||
virtual int ue_cfg(uint16_t rnti, sched_interface::ue_cfg_t *cfg) = 0;
|
||||
virtual int ue_rem(uint16_t rnti) = 0;
|
||||
|
||||
/* Manages UE bearers and associated configuration */
|
||||
virtual int bearer_ue_cfg(uint16_t rnti, uint32_t lc_id, sched_interface::ue_bearer_cfg_t *cfg) = 0;
|
||||
virtual int bearer_ue_rem(uint16_t rnti, uint32_t lc_id) = 0;
|
||||
virtual void phy_config_enabled(uint16_t rnti, bool enabled) = 0;
|
||||
|
||||
};
|
||||
|
||||
class mac_interface_rlc
|
||||
{
|
||||
public:
|
||||
virtual int rlc_buffer_state(uint16_t rnti, uint32_t lc_id, uint32_t tx_queue, uint32_t retx_queue) = 0;
|
||||
};
|
||||
|
||||
//RLC interface for MAC
|
||||
class rlc_interface_mac
|
||||
{
|
||||
public:
|
||||
|
||||
/* MAC calls RLC to get RLC segment of nof_bytes length.
|
||||
* Segmentation happens in this function. RLC PDU is stored in payload. */
|
||||
virtual int read_pdu(uint16_t rnti, uint32_t lcid, uint8_t *payload, uint32_t nof_bytes) = 0;
|
||||
|
||||
virtual void read_pdu_bcch_dlsch(uint32_t sib_index, uint8_t *payload) = 0;
|
||||
virtual void read_pdu_pcch(uint8_t* payload, uint32_t buffer_size) = 0;
|
||||
|
||||
/* MAC calls RLC to push an RLC PDU. This function is called from an independent MAC thread.
|
||||
* PDU gets placed into the buffer and higher layer thread gets notified. */
|
||||
virtual void write_pdu(uint16_t rnti, uint32_t lcid, uint8_t *payload, uint32_t nof_bytes) = 0;
|
||||
|
||||
};
|
||||
|
||||
|
||||
// RLC interface for PDCP
|
||||
class rlc_interface_pdcp
|
||||
{
|
||||
public:
|
||||
/* PDCP calls RLC to push an RLC SDU. SDU gets placed into the RLC buffer and MAC pulls
|
||||
* RLC PDUs according to TB size. */
|
||||
virtual void write_sdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t *sdu) = 0;
|
||||
};
|
||||
|
||||
// RLC interface for RRC
|
||||
class rlc_interface_rrc
|
||||
{
|
||||
public:
|
||||
virtual void reset(uint16_t rnti) = 0;
|
||||
virtual void clear_buffer(uint16_t rnti) = 0;
|
||||
virtual void add_user(uint16_t rnti) = 0;
|
||||
virtual void rem_user(uint16_t rnti) = 0;
|
||||
virtual void add_bearer(uint16_t rnti, uint32_t lcid) = 0;
|
||||
virtual void add_bearer(uint16_t rnti, uint32_t lcid, LIBLTE_RRC_RLC_CONFIG_STRUCT *cnfg) = 0;
|
||||
};
|
||||
|
||||
// PDCP interface for GTPU
|
||||
class pdcp_interface_gtpu
|
||||
{
|
||||
public:
|
||||
virtual void write_sdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t *sdu) = 0;
|
||||
};
|
||||
|
||||
// PDCP interface for RRC
|
||||
class pdcp_interface_rrc
|
||||
{
|
||||
public:
|
||||
virtual void reset(uint16_t rnti) = 0;
|
||||
virtual void add_user(uint16_t rnti) = 0;
|
||||
virtual void rem_user(uint16_t rnti) = 0;
|
||||
virtual void write_sdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t *sdu) = 0;
|
||||
virtual void add_bearer(uint16_t rnti, uint32_t lcid, LIBLTE_RRC_PDCP_CONFIG_STRUCT *cnfg=NULL) = 0;
|
||||
virtual void config_security(uint16_t rnti,
|
||||
uint32_t lcid,
|
||||
uint8_t *k_rrc_enc_,
|
||||
uint8_t *k_rrc_int_,
|
||||
srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo_,
|
||||
srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo_) = 0;
|
||||
};
|
||||
|
||||
// PDCP interface for RLC
|
||||
class pdcp_interface_rlc
|
||||
{
|
||||
public:
|
||||
/* RLC calls PDCP to push a PDCP PDU. */
|
||||
virtual void write_pdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t *sdu) = 0;
|
||||
};
|
||||
|
||||
// RRC interface for RLC
|
||||
class rrc_interface_rlc
|
||||
{
|
||||
public:
|
||||
virtual void read_pdu_bcch_dlsch(uint32_t sib_index, uint8_t *payload) = 0;
|
||||
virtual void read_pdu_pcch(uint8_t *payload, uint32_t payload_size) = 0;
|
||||
virtual void max_retx_attempted(uint16_t rnti) = 0;
|
||||
};
|
||||
|
||||
// RRC interface for MAC
|
||||
class rrc_interface_mac
|
||||
{
|
||||
public:
|
||||
/* Radio Link failure */
|
||||
virtual void rl_failure(uint16_t rnti) = 0;
|
||||
virtual void add_user(uint16_t rnti) = 0;
|
||||
virtual void upd_user(uint16_t new_rnti, uint16_t old_rnti) = 0;
|
||||
virtual void set_activity_user(uint16_t rnti) = 0;
|
||||
virtual bool is_paging_opportunity(uint32_t tti, uint32_t *payload_len) = 0;
|
||||
};
|
||||
|
||||
// RRC interface for PDCP
|
||||
class rrc_interface_pdcp
|
||||
{
|
||||
public:
|
||||
virtual void write_pdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t *pdu) = 0;
|
||||
};
|
||||
|
||||
// RRC interface for S1AP
|
||||
class rrc_interface_s1ap
|
||||
{
|
||||
public:
|
||||
virtual void write_dl_info(uint16_t rnti, srslte::byte_buffer_t *sdu) = 0;
|
||||
virtual void release_complete(uint16_t rnti) = 0;
|
||||
virtual bool setup_ue_ctxt(uint16_t rnti, LIBLTE_S1AP_MESSAGE_INITIALCONTEXTSETUPREQUEST_STRUCT *msg) = 0;
|
||||
virtual bool setup_ue_erabs(uint16_t rnti, LIBLTE_S1AP_MESSAGE_E_RABSETUPREQUEST_STRUCT *msg) = 0;
|
||||
virtual bool release_erabs(uint32_t rnti) = 0;
|
||||
virtual void add_paging_id(uint32_t ueid, LIBLTE_S1AP_UEPAGINGID_STRUCT UEPagingID) = 0;
|
||||
};
|
||||
|
||||
// GTPU interface for PDCP
|
||||
class gtpu_interface_pdcp
|
||||
{
|
||||
public:
|
||||
virtual void write_pdu(uint16_t rnti, uint32_t lcid, srslte::byte_buffer_t *pdu) = 0;
|
||||
};
|
||||
|
||||
// GTPU interface for RRC
|
||||
class gtpu_interface_rrc
|
||||
{
|
||||
public:
|
||||
virtual void add_bearer(uint16_t rnti, uint32_t lcid, uint32_t teid_out, uint32_t *teid_in) = 0;
|
||||
virtual void rem_bearer(uint16_t rnti, uint32_t lcid) = 0;
|
||||
virtual void rem_user(uint16_t rnti) = 0;
|
||||
};
|
||||
|
||||
// S1AP interface for RRC
|
||||
class s1ap_interface_rrc
|
||||
{
|
||||
public:
|
||||
virtual void initial_ue(uint16_t rnti, srslte::byte_buffer_t *pdu) = 0;
|
||||
virtual void initial_ue(uint16_t rnti, srslte::byte_buffer_t *pdu, uint32_t m_tmsi, uint8_t mmec) = 0;
|
||||
virtual void write_pdu(uint16_t rnti, srslte::byte_buffer_t *pdu) = 0;
|
||||
virtual bool user_exists(uint16_t rnti) = 0;
|
||||
virtual void user_inactivity(uint16_t rnti) = 0;
|
||||
virtual void release_eutran(uint16_t rnti) = 0;
|
||||
virtual bool user_link_lost(uint16_t rnti) = 0;
|
||||
virtual void ue_ctxt_setup_complete(uint16_t rnti, LIBLTE_S1AP_MESSAGE_INITIALCONTEXTSETUPRESPONSE_STRUCT *res) = 0;
|
||||
virtual void ue_erab_setup_complete(uint16_t rnti, LIBLTE_S1AP_MESSAGE_E_RABSETUPRESPONSE_STRUCT *res) = 0;
|
||||
// virtual void ue_capabilities(uint16_t rnti, LIBLTE_RRC_UE_EUTRA_CAPABILITY_STRUCT *caps) = 0;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,67 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2017 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of srsLTE.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef ENB_METRICS_INTERFACE_H
|
||||
#define ENB_METRICS_INTERFACE_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "upper/common_enb.h"
|
||||
#include "upper/s1ap_metrics.h"
|
||||
#include "upper/rrc_metrics.h"
|
||||
#include "srslte/upper/gw_metrics.h"
|
||||
#include "srslte/upper/rlc_metrics.h"
|
||||
#include "mac/mac_metrics.h"
|
||||
#include "phy/phy_metrics.h"
|
||||
|
||||
namespace srsenb {
|
||||
|
||||
typedef struct {
|
||||
uint32_t rf_o;
|
||||
uint32_t rf_u;
|
||||
uint32_t rf_l;
|
||||
bool rf_error;
|
||||
}rf_metrics_t;
|
||||
|
||||
typedef struct {
|
||||
rf_metrics_t rf;
|
||||
phy_metrics_t phy[ENB_METRICS_MAX_USERS];
|
||||
mac_metrics_t mac[ENB_METRICS_MAX_USERS];
|
||||
rrc_metrics_t rrc;
|
||||
s1ap_metrics_t s1ap;
|
||||
bool running;
|
||||
}enb_metrics_t;
|
||||
|
||||
// ENB interface
|
||||
class enb_metrics_interface
|
||||
{
|
||||
public:
|
||||
virtual bool get_metrics(enb_metrics_t &m) = 0;
|
||||
};
|
||||
|
||||
} // namespace srsenb
|
||||
|
||||
#endif // ENB_METRICS_INTERFACE_H
|
||||
@ -0,0 +1,247 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2017 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of srsLTE.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "srslte/srslte.h"
|
||||
|
||||
#ifndef SCHED_INTERFACE_H
|
||||
#define SCHED_INTERFACE_H
|
||||
|
||||
namespace srsenb {
|
||||
|
||||
class sched_interface
|
||||
{
|
||||
public:
|
||||
|
||||
const static int MAX_SIB_PAYLOAD_LEN = 2048;
|
||||
const static int MAX_SIBS = 16;
|
||||
const static int MAX_LC = 6;
|
||||
const static int MAX_DATA_LIST = 32;
|
||||
const static int MAX_RAR_LIST = 8;
|
||||
const static int MAX_BC_LIST = 8;
|
||||
const static int MAX_RLC_PDU_LIST = 8;
|
||||
const static int MAX_PHICH_LIST = 8;
|
||||
|
||||
typedef struct {
|
||||
uint32_t len;
|
||||
uint32_t period_rf;
|
||||
} cell_cfg_sib_t;
|
||||
|
||||
|
||||
typedef struct {
|
||||
int pdsch_mcs;
|
||||
int pdsch_max_mcs;
|
||||
int pusch_mcs;
|
||||
int pusch_max_mcs;
|
||||
int nof_ctrl_symbols;
|
||||
} sched_args_t;
|
||||
|
||||
|
||||
typedef struct {
|
||||
|
||||
// Main cell configuration (used to calculate DCI locations in scheduler)
|
||||
srslte_cell_t cell;
|
||||
|
||||
/* SIB configuration */
|
||||
cell_cfg_sib_t sibs[MAX_SIBS];
|
||||
uint32_t si_window_ms;
|
||||
|
||||
/* pusch configuration */
|
||||
srslte_pusch_hopping_cfg_t pusch_hopping_cfg;
|
||||
|
||||
/* prach configuration */
|
||||
uint32_t prach_config;
|
||||
uint32_t prach_freq_offset;
|
||||
uint32_t prach_rar_window;
|
||||
uint32_t prach_contention_resolution_timer;
|
||||
|
||||
uint32_t maxharq_msg3tx;
|
||||
uint32_t n1pucch_an;
|
||||
uint32_t delta_pucch_shift;
|
||||
|
||||
uint32_t nrb_cqi;
|
||||
uint32_t ncs_an;
|
||||
|
||||
uint32_t srs_subframe_config;
|
||||
uint32_t srs_subframe_offset;
|
||||
uint32_t srs_bw_config;
|
||||
|
||||
} cell_cfg_t;
|
||||
|
||||
|
||||
typedef struct {
|
||||
int priority;
|
||||
int bsd;
|
||||
int pbr;
|
||||
enum {IDLE = 0, UL, DL, BOTH} direction;
|
||||
} ue_bearer_cfg_t;
|
||||
|
||||
typedef struct {
|
||||
|
||||
bool continuous_pusch;
|
||||
|
||||
/* ue capabilities, etc */
|
||||
|
||||
uint32_t maxharq_tx;
|
||||
uint32_t aperiodic_cqi_period; // if 0 is periodic CQI
|
||||
uint32_t beta_ack_index;
|
||||
uint32_t beta_ri_index;
|
||||
uint32_t beta_cqi_index;
|
||||
|
||||
srslte_pucch_cfg_t pucch_cfg;
|
||||
uint32_t n_pucch_cqi;
|
||||
uint32_t sr_I;
|
||||
uint32_t sr_N_pucch;
|
||||
bool sr_enabled;
|
||||
uint32_t cqi_pucch;
|
||||
uint32_t cqi_idx;
|
||||
bool cqi_enabled;
|
||||
|
||||
ue_bearer_cfg_t ue_bearers[MAX_LC];
|
||||
|
||||
} ue_cfg_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t lcid;
|
||||
uint32_t nbytes;
|
||||
} dl_sched_pdu_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t rnti;
|
||||
srslte_ra_dl_dci_t dci;
|
||||
srslte_dci_location_t dci_location;
|
||||
uint32_t tbs;
|
||||
bool mac_ce_ta;
|
||||
bool mac_ce_rnti;
|
||||
uint32_t nof_pdu_elems;
|
||||
dl_sched_pdu_t pdu[MAX_RLC_PDU_LIST];
|
||||
} dl_sched_data_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t rnti;
|
||||
bool needs_pdcch;
|
||||
uint32_t current_tx_nb;
|
||||
uint32_t tbs;
|
||||
srslte_ra_ul_dci_t dci;
|
||||
srslte_dci_location_t dci_location;
|
||||
} ul_sched_data_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t ra_id;
|
||||
srslte_dci_rar_grant_t grant;
|
||||
} dl_sched_rar_grant_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t rarnti;
|
||||
uint32_t tbs;
|
||||
srslte_ra_dl_dci_t dci;
|
||||
srslte_dci_location_t dci_location;
|
||||
uint32_t nof_grants;
|
||||
dl_sched_rar_grant_t grants[MAX_RAR_LIST];
|
||||
} dl_sched_rar_t;
|
||||
|
||||
typedef struct {
|
||||
srslte_ra_dl_dci_t dci;
|
||||
srslte_dci_location_t dci_location;
|
||||
|
||||
enum bc_type {
|
||||
BCCH, PCCH
|
||||
} type;
|
||||
|
||||
uint32_t index;
|
||||
|
||||
uint32_t tbs;
|
||||
|
||||
} dl_sched_bc_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t cfi;
|
||||
uint32_t nof_data_elems;
|
||||
uint32_t nof_rar_elems;
|
||||
uint32_t nof_bc_elems;
|
||||
dl_sched_data_t data[MAX_DATA_LIST];
|
||||
dl_sched_rar_t rar[MAX_RAR_LIST];
|
||||
dl_sched_bc_t bc[MAX_BC_LIST];
|
||||
} dl_sched_res_t;
|
||||
|
||||
typedef struct {
|
||||
uint16_t rnti;
|
||||
enum phich_elem {
|
||||
ACK, NACK
|
||||
} phich;
|
||||
} ul_sched_phich_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t nof_dci_elems;
|
||||
uint32_t nof_phich_elems;
|
||||
ul_sched_data_t pusch[MAX_DATA_LIST];
|
||||
ul_sched_phich_t phich[MAX_PHICH_LIST];
|
||||
} ul_sched_res_t;
|
||||
|
||||
/******************* Scheduler Control ****************************/
|
||||
|
||||
/* Provides cell configuration including SIB periodicity, etc. */
|
||||
virtual int cell_cfg(cell_cfg_t *cell_cfg) = 0;
|
||||
virtual int reset() = 0;
|
||||
|
||||
/* Manages UE scheduling context */
|
||||
virtual int ue_cfg(uint16_t rnti, ue_cfg_t *cfg) = 0;
|
||||
virtual int ue_rem(uint16_t rnti) = 0;
|
||||
virtual bool ue_exists(uint16_t rnti) = 0;
|
||||
|
||||
/* Manages UE bearers and associated configuration */
|
||||
virtual int bearer_ue_cfg(uint16_t rnti, uint32_t lc_id, ue_bearer_cfg_t *cfg) = 0;
|
||||
virtual int bearer_ue_rem(uint16_t rnti, uint32_t lc_id) = 0;
|
||||
|
||||
virtual uint32_t get_ul_buffer(uint16_t rnti) = 0;
|
||||
virtual uint32_t get_dl_buffer(uint16_t rnti) = 0;
|
||||
|
||||
/******************* Scheduling Interface ***********************/
|
||||
/* DL buffer status report */
|
||||
virtual int dl_rlc_buffer_state(uint16_t rnti, uint32_t lc_id, uint32_t tx_queue, uint32_t retx_queue) = 0;
|
||||
virtual int dl_mac_buffer_state(uint16_t rnti, uint32_t ce_code) = 0;
|
||||
|
||||
/* DL information */
|
||||
virtual int dl_ack_info(uint32_t tti, uint16_t rnti, bool ack) = 0;
|
||||
virtual int dl_rach_info(uint32_t tti, uint32_t ra_id, uint16_t rnti, uint32_t estimated_size) = 0;
|
||||
virtual int dl_cqi_info(uint32_t tti, uint16_t rnti, uint32_t cqi_value) = 0;
|
||||
|
||||
/* UL information */
|
||||
virtual int ul_crc_info(uint32_t tti, uint16_t rnti, bool crc) = 0;
|
||||
virtual int ul_sr_info(uint32_t tti, uint16_t rnti) = 0;
|
||||
virtual int ul_bsr(uint16_t rnti, uint32_t lcid, uint32_t bsr) = 0;
|
||||
virtual int ul_recv_len(uint16_t rnti, uint32_t lcid, uint32_t len) = 0;
|
||||
virtual int ul_phr(uint16_t rnti, int phr) = 0;
|
||||
virtual int ul_cqi_info(uint32_t tti, uint16_t rnti, uint32_t cqi, uint32_t ul_ch_code) = 0;
|
||||
|
||||
/* Run Scheduler for this tti */
|
||||
virtual int dl_sched(uint32_t tti, dl_sched_res_t *sched_result) = 0;
|
||||
virtual int ul_sched(uint32_t tti, ul_sched_res_t *sched_result) = 0;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,481 @@
|
||||
/**
|
||||
*
|
||||
* \section COPYRIGHT
|
||||
*
|
||||
* Copyright 2013-2015 Software Radio Systems Limited
|
||||
*
|
||||
* \section LICENSE
|
||||
*
|
||||
* This file is part of the srsUE library.
|
||||
*
|
||||
* srsUE is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version.
|
||||
*
|
||||
* srsUE is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* A copy of the GNU Affero General Public License can be found in
|
||||
* the LICENSE file in the top-level directory of this distribution
|
||||
* and at http://www.gnu.org/licenses/.
|
||||
*
|
||||
*/
|
||||
|
||||
/******************************************************************************
|
||||
* File: interfaces.h
|
||||
* Description: Abstract base class interfaces provided by layers
|
||||
* to other layers.
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef INTERFACES_H
|
||||
#define INTERFACES_H
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "srslte/asn1/liblte_rrc.h"
|
||||
#include "srslte/common/interfaces_common.h"
|
||||
#include "srslte/common/common.h"
|
||||
#include "srslte/common/security.h"
|
||||
|
||||
namespace srsue {
|
||||
|
||||
// UE interface
|
||||
class ue_interface
|
||||
{
|
||||
};
|
||||
|
||||
// USIM interface for NAS
|
||||
class usim_interface_nas
|
||||
{
|
||||
public:
|
||||
virtual void get_imsi_vec(uint8_t* imsi_, uint32_t n) = 0;
|
||||
virtual void get_imei_vec(uint8_t* imei_, uint32_t n) = 0;
|
||||
virtual void generate_authentication_response(uint8_t *rand,
|
||||
uint8_t *autn_enb,
|
||||
uint16_t mcc,
|
||||
uint16_t mnc,
|
||||
bool *net_valid,
|
||||
uint8_t *res) = 0;
|
||||
virtual void generate_nas_keys(uint8_t *k_nas_enc,
|
||||
uint8_t *k_nas_int,
|
||||
srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo,
|
||||
srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo) = 0;
|
||||
};
|
||||
|
||||
// USIM interface for RRC
|
||||
class usim_interface_rrc
|
||||
{
|
||||
public:
|
||||
virtual void generate_as_keys(uint32_t count_ul,
|
||||
uint8_t *k_rrc_enc,
|
||||
uint8_t *k_rrc_int,
|
||||
uint8_t *k_up_enc,
|
||||
uint8_t *k_up_int,
|
||||
srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo,
|
||||
srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo) = 0;
|
||||
};
|
||||
|
||||
// GW interface for NAS
|
||||
class gw_interface_nas
|
||||
{
|
||||
public:
|
||||
virtual srslte::error_t setup_if_addr(uint32_t ip_addr, char *err_str) = 0;
|
||||
};
|
||||
|
||||
// GW interface for PDCP
|
||||
class gw_interface_pdcp
|
||||
{
|
||||
public:
|
||||
virtual void write_pdu(uint32_t lcid, srslte::byte_buffer_t *pdu) = 0;
|
||||
};
|
||||
|
||||
// NAS interface for RRC
|
||||
class nas_interface_rrc
|
||||
{
|
||||
public:
|
||||
virtual bool is_attached() = 0;
|
||||
virtual void notify_connection_setup() = 0;
|
||||
virtual void write_pdu(uint32_t lcid, srslte::byte_buffer_t *pdu) = 0;
|
||||
virtual uint32_t get_ul_count() = 0;
|
||||
virtual bool get_s_tmsi(LIBLTE_RRC_S_TMSI_STRUCT *s_tmsi) = 0;
|
||||
};
|
||||
|
||||
// RRC interface for MAC
|
||||
class rrc_interface_mac
|
||||
{
|
||||
public:
|
||||
virtual void release_pucch_srs() = 0;
|
||||
virtual void ra_problem() = 0;
|
||||
};
|
||||
|
||||
// RRC interface for PHY
|
||||
class rrc_interface_phy
|
||||
{
|
||||
public:
|
||||
virtual void in_sync() = 0;
|
||||
virtual void out_of_sync() = 0;
|
||||
};
|
||||
|
||||
// RRC interface for NAS
|
||||
class rrc_interface_nas
|
||||
{
|
||||
public:
|
||||
virtual void write_sdu(uint32_t lcid, srslte::byte_buffer_t *sdu) = 0;
|
||||
virtual uint16_t get_mcc() = 0;
|
||||
virtual uint16_t get_mnc() = 0;
|
||||
virtual void enable_capabilities() = 0;
|
||||
};
|
||||
|
||||
// RRC interface for GW
|
||||
class rrc_interface_gw
|
||||
{
|
||||
public:
|
||||
virtual bool rrc_connected() = 0;
|
||||
virtual void rrc_connect() = 0;
|
||||
virtual bool have_drb() = 0;
|
||||
};
|
||||
|
||||
// RRC interface for PDCP
|
||||
class rrc_interface_pdcp
|
||||
{
|
||||
public:
|
||||
virtual void write_pdu(uint32_t lcid, srslte::byte_buffer_t *pdu) = 0;
|
||||
virtual void write_pdu_bcch_bch(srslte::byte_buffer_t *pdu) = 0;
|
||||
virtual void write_pdu_bcch_dlsch(srslte::byte_buffer_t *pdu) = 0;
|
||||
virtual void write_pdu_pcch(srslte::byte_buffer_t *pdu) = 0;
|
||||
};
|
||||
|
||||
// RRC interface for RLC
|
||||
class rrc_interface_rlc
|
||||
{
|
||||
public:
|
||||
virtual void max_retx_attempted() = 0;
|
||||
};
|
||||
|
||||
// PDCP interface for GW
|
||||
class pdcp_interface_gw
|
||||
{
|
||||
public:
|
||||
virtual void write_sdu(uint32_t lcid, srslte::byte_buffer_t *sdu) = 0;
|
||||
};
|
||||
|
||||
// PDCP interface for RRC
|
||||
class pdcp_interface_rrc
|
||||
{
|
||||
public:
|
||||
virtual void reset() = 0;
|
||||
virtual void write_sdu(uint32_t lcid, srslte::byte_buffer_t *sdu) = 0;
|
||||
virtual void add_bearer(uint32_t lcid, LIBLTE_RRC_PDCP_CONFIG_STRUCT *cnfg=NULL) = 0;
|
||||
virtual void config_security(uint32_t lcid,
|
||||
uint8_t *k_rrc_enc_,
|
||||
uint8_t *k_rrc_int_,
|
||||
srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo_,
|
||||
srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo_) = 0;
|
||||
};
|
||||
|
||||
// PDCP interface for RLC
|
||||
class pdcp_interface_rlc
|
||||
{
|
||||
public:
|
||||
/* RLC calls PDCP to push a PDCP PDU. */
|
||||
virtual void write_pdu(uint32_t lcid, srslte::byte_buffer_t *sdu) = 0;
|
||||
virtual void write_pdu_bcch_bch(srslte::byte_buffer_t *sdu) = 0;
|
||||
virtual void write_pdu_bcch_dlsch(srslte::byte_buffer_t *sdu) = 0;
|
||||
virtual void write_pdu_pcch(srslte::byte_buffer_t *sdu) = 0;
|
||||
};
|
||||
|
||||
// RLC interface for RRC
|
||||
class rlc_interface_rrc
|
||||
{
|
||||
public:
|
||||
virtual void reset() = 0;
|
||||
virtual void add_bearer(uint32_t lcid) = 0;
|
||||
virtual void add_bearer(uint32_t lcid, LIBLTE_RRC_RLC_CONFIG_STRUCT *cnfg) = 0;
|
||||
};
|
||||
|
||||
// RLC interface for PDCP
|
||||
class rlc_interface_pdcp
|
||||
{
|
||||
public:
|
||||
/* PDCP calls RLC to push an RLC SDU. SDU gets placed into the RLC buffer and MAC pulls
|
||||
* RLC PDUs according to TB size. */
|
||||
virtual void write_sdu(uint32_t lcid, srslte::byte_buffer_t *sdu) = 0;
|
||||
};
|
||||
|
||||
//RLC interface for MAC
|
||||
class rlc_interface_mac : public srslte::read_pdu_interface
|
||||
{
|
||||
public:
|
||||
/* MAC calls RLC to get buffer state for a logical channel.
|
||||
* This function should return quickly. */
|
||||
virtual uint32_t get_buffer_state(uint32_t lcid) = 0;
|
||||
virtual uint32_t get_total_buffer_state(uint32_t lcid) = 0;
|
||||
|
||||
|
||||
const static int MAX_PDU_SEGMENTS = 20;
|
||||
|
||||
/* MAC calls RLC to get RLC segment of nof_bytes length.
|
||||
* Segmentation happens in this function. RLC PDU is stored in payload. */
|
||||
virtual int read_pdu(uint32_t lcid, uint8_t *payload, uint32_t nof_bytes) = 0;
|
||||
|
||||
/* MAC calls RLC to push an RLC PDU. This function is called from an independent MAC thread.
|
||||
* PDU gets placed into the buffer and higher layer thread gets notified. */
|
||||
virtual void write_pdu(uint32_t lcid, uint8_t *payload, uint32_t nof_bytes) = 0;
|
||||
virtual void write_pdu_bcch_bch(uint8_t *payload, uint32_t nof_bytes) = 0;
|
||||
virtual void write_pdu_bcch_dlsch(uint8_t *payload, uint32_t nof_bytes) = 0;
|
||||
virtual void write_pdu_pcch(uint8_t *payload, uint32_t nof_bytes) = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
/** MAC interface
|
||||
*
|
||||
*/
|
||||
/* Interface PHY -> MAC */
|
||||
class mac_interface_phy
|
||||
{
|
||||
public:
|
||||
|
||||
typedef struct {
|
||||
uint32_t pid;
|
||||
uint32_t tti;
|
||||
uint32_t last_tti;
|
||||
bool ndi;
|
||||
bool last_ndi;
|
||||
uint32_t n_bytes;
|
||||
int rv;
|
||||
uint16_t rnti;
|
||||
bool is_from_rar;
|
||||
bool is_sps_release;
|
||||
bool has_cqi_request;
|
||||
srslte_rnti_type_t rnti_type;
|
||||
srslte_phy_grant_t phy_grant;
|
||||
} mac_grant_t;
|
||||
|
||||
typedef struct {
|
||||
bool decode_enabled;
|
||||
int rv;
|
||||
uint16_t rnti;
|
||||
bool generate_ack;
|
||||
bool default_ack;
|
||||
// If non-null, called after tb_decoded_ok to determine if ack needs to be sent
|
||||
bool (*generate_ack_callback)(void*);
|
||||
void *generate_ack_callback_arg;
|
||||
uint8_t *payload_ptr;
|
||||
srslte_softbuffer_rx_t *softbuffer;
|
||||
srslte_phy_grant_t phy_grant;
|
||||
} tb_action_dl_t;
|
||||
|
||||
typedef struct {
|
||||
bool tx_enabled;
|
||||
bool expect_ack;
|
||||
uint32_t rv;
|
||||
uint16_t rnti;
|
||||
uint32_t current_tx_nb;
|
||||
srslte_softbuffer_tx_t *softbuffer;
|
||||
srslte_phy_grant_t phy_grant;
|
||||
uint8_t *payload_ptr;
|
||||
} tb_action_ul_t;
|
||||
|
||||
/* Indicate reception of UL grant.
|
||||
* payload_ptr points to memory where MAC PDU must be written by MAC layer */
|
||||
virtual void new_grant_ul(mac_grant_t grant, tb_action_ul_t *action) = 0;
|
||||
|
||||
/* Indicate reception of UL grant + HARQ information throught PHICH in the same TTI. */
|
||||
virtual void new_grant_ul_ack(mac_grant_t grant, bool ack, tb_action_ul_t *action) = 0;
|
||||
|
||||
/* Indicate reception of HARQ information only through PHICH. */
|
||||
virtual void harq_recv(uint32_t tti, bool ack, tb_action_ul_t *action) = 0;
|
||||
|
||||
/* Indicate reception of DL grant. */
|
||||
virtual void new_grant_dl(mac_grant_t grant, tb_action_dl_t *action) = 0;
|
||||
|
||||
/* Indicate successfull decoding of PDSCH TB. */
|
||||
virtual void tb_decoded(bool ack, srslte_rnti_type_t rnti_type, uint32_t harq_pid) = 0;
|
||||
|
||||
/* Indicate successfull decoding of BCH TB through PBCH */
|
||||
virtual void bch_decoded_ok(uint8_t *payload, uint32_t len) = 0;
|
||||
|
||||
/* Indicate successfull decoding of PCH TB through PDSCH */
|
||||
virtual void pch_decoded_ok(uint32_t len) = 0;
|
||||
|
||||
/* Function called every start of a subframe (TTI). Warning, this function is called
|
||||
* from a high priority thread and should terminate asap
|
||||
*/
|
||||
virtual void tti_clock(uint32_t tti) = 0;
|
||||
|
||||
};
|
||||
|
||||
|
||||
/* Interface RRC -> MAC */
|
||||
class mac_interface_rrc
|
||||
{
|
||||
public:
|
||||
|
||||
typedef struct {
|
||||
LIBLTE_RRC_MAC_MAIN_CONFIG_STRUCT main;
|
||||
LIBLTE_RRC_RACH_CONFIG_COMMON_STRUCT rach;
|
||||
LIBLTE_RRC_SCHEDULING_REQUEST_CONFIG_STRUCT sr;
|
||||
uint32_t prach_config_index;
|
||||
} mac_cfg_t;
|
||||
|
||||
|
||||
// Class to handle UE specific RNTIs between RRC and MAC
|
||||
typedef struct {
|
||||
uint16_t crnti;
|
||||
uint16_t temp_rnti;
|
||||
uint16_t tpc_rnti;
|
||||
uint16_t sps_rnti;
|
||||
uint64_t contention_id;
|
||||
} ue_rnti_t;
|
||||
|
||||
/* Instructs the MAC to start receiving BCCH */
|
||||
virtual void bcch_start_rx() = 0;
|
||||
virtual void bcch_stop_rx() = 0;
|
||||
virtual void bcch_start_rx(int si_window_start, int si_window_length) = 0;
|
||||
|
||||
/* Instructs the MAC to start receiving PCCH */
|
||||
virtual void pcch_start_rx() = 0;
|
||||
virtual void pcch_stop_rx() = 0;
|
||||
|
||||
/* RRC configures a logical channel */
|
||||
virtual void setup_lcid(uint32_t lcid, uint32_t lcg, uint32_t priority, int PBR_x_tti, uint32_t BSD) = 0;
|
||||
|
||||
virtual uint32_t get_current_tti() = 0;
|
||||
|
||||
virtual void set_config(mac_cfg_t *mac_cfg) = 0;
|
||||
virtual void set_config_main(LIBLTE_RRC_MAC_MAIN_CONFIG_STRUCT *main_cfg) = 0;
|
||||
virtual void set_config_rach(LIBLTE_RRC_RACH_CONFIG_COMMON_STRUCT *rach_cfg, uint32_t prach_config_index) = 0;
|
||||
virtual void set_config_sr(LIBLTE_RRC_SCHEDULING_REQUEST_CONFIG_STRUCT *sr_cfg) = 0;
|
||||
virtual void get_config(mac_cfg_t *mac_cfg) = 0;
|
||||
|
||||
virtual void get_rntis(ue_rnti_t *rntis) = 0;
|
||||
virtual void set_contention_id(uint64_t uecri) = 0;
|
||||
|
||||
|
||||
virtual void reconfiguration() = 0;
|
||||
virtual void reset() = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
/** PHY interface
|
||||
*
|
||||
*/
|
||||
|
||||
typedef struct {
|
||||
bool ul_pwr_ctrl_en;
|
||||
float prach_gain;
|
||||
int pdsch_max_its;
|
||||
bool attach_enable_64qam;
|
||||
int nof_phy_threads;
|
||||
|
||||
int worker_cpu_mask;
|
||||
int sync_cpu_affinity;
|
||||
|
||||
uint32_t nof_rx_ant;
|
||||
std::string equalizer_mode;
|
||||
int cqi_max;
|
||||
int cqi_fixed;
|
||||
float snr_ema_coeff;
|
||||
std::string snr_estim_alg;
|
||||
bool cfo_integer_enabled;
|
||||
float cfo_correct_tol_hz;
|
||||
int time_correct_period;
|
||||
bool sfo_correct_disable;
|
||||
std::string sss_algorithm;
|
||||
float estimator_fil_w;
|
||||
bool rssi_sensor_enabled;
|
||||
} phy_args_t;
|
||||
|
||||
/* Interface MAC -> PHY */
|
||||
class phy_interface_mac
|
||||
{
|
||||
public:
|
||||
/* Configure PRACH using parameters written by RRC */
|
||||
virtual void configure_prach_params() = 0;
|
||||
|
||||
/* Start synchronization with strongest cell in the current carrier frequency */
|
||||
virtual void sync_start() = 0;
|
||||
virtual void sync_stop() = 0;
|
||||
|
||||
/* Sets a C-RNTI allowing the PHY to pregenerate signals if necessary */
|
||||
virtual void set_crnti(uint16_t rnti) = 0;
|
||||
|
||||
virtual void prach_send(uint32_t preamble_idx, int allowed_subframe, float target_power_dbm) = 0;
|
||||
virtual int prach_tx_tti() = 0;
|
||||
|
||||
/* Indicates the transmission of a SR signal in the next opportunity */
|
||||
virtual void sr_send() = 0;
|
||||
virtual int sr_last_tx_tti() = 0;
|
||||
|
||||
/* Time advance commands */
|
||||
virtual void set_timeadv_rar(uint32_t ta_cmd) = 0;
|
||||
virtual void set_timeadv(uint32_t ta_cmd) = 0;
|
||||
|
||||
/* Sets RAR grant payload */
|
||||
virtual void set_rar_grant(uint32_t tti, uint8_t grant_payload[SRSLTE_RAR_GRANT_LEN]) = 0;
|
||||
|
||||
/* Instruct the PHY to decode PDCCH with the CRC scrambled with given RNTI */
|
||||
virtual void pdcch_ul_search(srslte_rnti_type_t rnti_type, uint16_t rnti, int tti_start = -1, int tti_end = -1) = 0;
|
||||
virtual void pdcch_dl_search(srslte_rnti_type_t rnti_type, uint16_t rnti, int tti_start = -1, int tti_end = -1) = 0;
|
||||
virtual void pdcch_ul_search_reset() = 0;
|
||||
virtual void pdcch_dl_search_reset() = 0;
|
||||
|
||||
virtual uint32_t get_current_tti() = 0;
|
||||
|
||||
virtual float get_phr() = 0;
|
||||
virtual float get_pathloss_db() = 0;
|
||||
|
||||
};
|
||||
|
||||
class phy_interface_rrc
|
||||
{
|
||||
public:
|
||||
|
||||
typedef struct {
|
||||
LIBLTE_RRC_PRACH_CONFIG_SIB_STRUCT prach_cnfg;
|
||||
LIBLTE_RRC_PDSCH_CONFIG_COMMON_STRUCT pdsch_cnfg;
|
||||
LIBLTE_RRC_PUSCH_CONFIG_COMMON_STRUCT pusch_cnfg;
|
||||
LIBLTE_RRC_PHICH_CONFIG_STRUCT phich_cnfg;
|
||||
LIBLTE_RRC_PUCCH_CONFIG_COMMON_STRUCT pucch_cnfg;
|
||||
LIBLTE_RRC_SRS_UL_CONFIG_COMMON_STRUCT srs_ul_cnfg;
|
||||
LIBLTE_RRC_UL_POWER_CONTROL_COMMON_STRUCT ul_pwr_ctrl;
|
||||
LIBLTE_RRC_TDD_CONFIG_STRUCT tdd_cnfg;
|
||||
LIBLTE_RRC_ANTENNA_PORTS_COUNT_ENUM ant_info;
|
||||
} phy_cfg_common_t;
|
||||
|
||||
typedef struct {
|
||||
LIBLTE_RRC_PHYSICAL_CONFIG_DEDICATED_STRUCT dedicated;
|
||||
phy_cfg_common_t common;
|
||||
bool enable_64qam;
|
||||
} phy_cfg_t;
|
||||
|
||||
virtual void get_current_cell(srslte_cell_t *cell) = 0;
|
||||
virtual void get_config(phy_cfg_t *phy_cfg) = 0;
|
||||
virtual void set_config(phy_cfg_t *phy_cfg) = 0;
|
||||
virtual void set_config_dedicated(LIBLTE_RRC_PHYSICAL_CONFIG_DEDICATED_STRUCT *dedicated) = 0;
|
||||
virtual void set_config_common(phy_cfg_common_t *common) = 0;
|
||||
virtual void set_config_tdd(LIBLTE_RRC_TDD_CONFIG_STRUCT *tdd) = 0;
|
||||
virtual void set_config_64qam_en(bool enable) = 0;
|
||||
|
||||
/* Is the PHY downlink synchronized? */
|
||||
virtual bool status_is_sync() = 0;
|
||||
|
||||
/* Configure UL using parameters written with set_param() */
|
||||
virtual void configure_ul_params(bool pregen_disabled = false) = 0;
|
||||
|
||||
virtual void reset() = 0;
|
||||
|
||||
virtual void resync_sfn() = 0;
|
||||
|
||||
};
|
||||
|
||||
|
||||
} // namespace srslte
|
||||
|
||||
#endif // INTERFACES_H
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue