mirror of https://github.com/pvnis/srsRAN_4G.git
SRSUE: Added time accurate SCell activation
Xavier Arteaga
4 years ago
committed by
Andre Puschmann
parent
f64c268a69
commit
c5cb4d9984
@ -0,0 +1,234 @@
|
||||
/*
|
||||
* Copyright 2013-2020 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/.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SRSLTE_SCELL_STATE_H
|
||||
#define SRSLTE_SCELL_STATE_H
|
||||
|
||||
#include <cinttypes>
|
||||
#include <mutex>
|
||||
#include <srslte/common/common.h>
|
||||
|
||||
namespace srsue {
|
||||
namespace scell {
|
||||
|
||||
/**
|
||||
* References
|
||||
*
|
||||
* According to 3GPP 36.321 R10 (MAC procedures) section 5.13 Activation/Deactivation of SCells
|
||||
* An activated cell operation shall include (Summarised):
|
||||
* - SRS transmissions on the SCell;
|
||||
* - CQI/PMI/RI/PTI reporting for the SCell;
|
||||
* - PDCCH monitoring on the SCell;
|
||||
* - PDCCH monitoring for the SCell
|
||||
*
|
||||
* According to 3GPP 36.213 R10 (PHY procedures) section 4.3 Timing for Secondary Cell Activation / Deactivation
|
||||
* When a UE receives an activation command for a secondary cell in subframe n, the corresponding actions shall be
|
||||
* applied at subframe n+8. (Summarised)
|
||||
*/
|
||||
class state
|
||||
{
|
||||
private:
|
||||
static constexpr uint32_t activation_delay_tti = FDD_HARQ_DELAY_DL_MS + FDD_HARQ_DELAY_UL_MS;
|
||||
static constexpr uint32_t activation_margin_tti = FDD_HARQ_DELAY_DL_MS;
|
||||
|
||||
// SCell EARFCN, PCI, configured and enabled list
|
||||
struct cfg {
|
||||
uint32_t earfcn = 0;
|
||||
uint32_t pci = 0;
|
||||
enum { none = 0, inactive, active } status = none;
|
||||
};
|
||||
|
||||
std::array<cfg, SRSLTE_MAX_CARRIERS> scell_cfg;
|
||||
|
||||
enum { idle = 0, waiting, transition } activation_state = idle;
|
||||
uint32_t activation_cmd = 0;
|
||||
uint32_t activation_tti = 0;
|
||||
mutable std::mutex mutex;
|
||||
|
||||
bool _get_cmd_activation(uint32_t cc_idx) const { return ((activation_cmd >> cc_idx) & 0x1) == 0x1; }
|
||||
|
||||
bool _tti_greater_or_equal_than(uint32_t a, uint32_t b) const { return TTI_SUB(a, b) < 10240 / 2; }
|
||||
|
||||
public:
|
||||
/**
|
||||
* A SCell Activation/Deactivation command is received. Stores the new command and the TTI. Also, the internal state
|
||||
* goes to waiting.
|
||||
*
|
||||
* If a previous command was received and not applied, it will discard it.
|
||||
*
|
||||
* @param cmd SCell Activation/Deactivation command
|
||||
* @param tti TTI in which the command was received
|
||||
*/
|
||||
void set_activation_deactivation(uint32_t cmd, uint32_t tti)
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
|
||||
// Store command
|
||||
activation_cmd = cmd;
|
||||
|
||||
// Command is waiting
|
||||
activation_state = waiting;
|
||||
|
||||
activation_tti = TTI_ADD(tti, activation_delay_tti);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Deactivates all the active SCells
|
||||
*/
|
||||
void deactivate_all()
|
||||
{
|
||||
for (cfg& e : scell_cfg) {
|
||||
if (e.status == cfg::active) {
|
||||
e.status = cfg::inactive;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void run_tti(uint32_t tti)
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
|
||||
switch (activation_state) {
|
||||
|
||||
case idle:
|
||||
// waiting for receiving a command, do nothing
|
||||
break;
|
||||
case waiting:
|
||||
// Detect that TTI when the CMD needs to be applied, the activation cannot be done instantly because some
|
||||
// workers might be currently ongoing, so only update state
|
||||
if (_tti_greater_or_equal_than(tti, activation_tti)) {
|
||||
activation_state = transition;
|
||||
}
|
||||
break;
|
||||
case transition:
|
||||
// Detect when the TTI has increased enough to make sure there arent workers, set the configuration
|
||||
if (TTI_SUB(tti, activation_tti) >= activation_margin_tti) {
|
||||
|
||||
// Reload cell states
|
||||
for (uint32_t i = 1; i < SRSLTE_MAX_CARRIERS; i++) {
|
||||
// Get Activation command value
|
||||
bool activate = _get_cmd_activation(i);
|
||||
|
||||
// Apply activation only if the cell was configured
|
||||
if (scell_cfg[i].status != cfg::none) {
|
||||
scell_cfg[i].status = activate ? cfg::active : cfg::inactive;
|
||||
}
|
||||
}
|
||||
|
||||
// Go back to initial state
|
||||
activation_state = idle;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void configure(uint32_t cc_idx, uint32_t earfcn, uint32_t pci)
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
|
||||
if (cc_idx == 0 or cc_idx >= SRSLTE_MAX_CARRIERS) {
|
||||
ERROR("CC IDX %d out-of-range\n", cc_idx);
|
||||
return;
|
||||
}
|
||||
|
||||
scell_cfg[cc_idx].status = cfg::inactive;
|
||||
scell_cfg[cc_idx].earfcn = earfcn;
|
||||
scell_cfg[cc_idx].pci = pci;
|
||||
}
|
||||
|
||||
bool is_active(uint32_t cc_idx, uint32_t tti) const
|
||||
{
|
||||
|
||||
if (cc_idx == 0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (cc_idx >= SRSLTE_MAX_CARRIERS) {
|
||||
return false;
|
||||
}
|
||||
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
|
||||
// Use stashed activation if the activation is transitioning and the current TTI requires new value
|
||||
if (activation_state == transition and scell_cfg[cc_idx].status != cfg::none and
|
||||
_tti_greater_or_equal_than(tti, activation_tti)) {
|
||||
return _get_cmd_activation(cc_idx);
|
||||
}
|
||||
|
||||
return scell_cfg[cc_idx].status == cfg::active;
|
||||
}
|
||||
|
||||
bool is_configured(uint32_t cc_idx) const
|
||||
{
|
||||
|
||||
if (cc_idx == 0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (cc_idx >= SRSLTE_MAX_CARRIERS) {
|
||||
return false;
|
||||
}
|
||||
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
|
||||
return scell_cfg[cc_idx].status != cfg::none;
|
||||
}
|
||||
|
||||
void reset()
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
|
||||
activation_state = idle;
|
||||
|
||||
for (cfg& e : scell_cfg) {
|
||||
e.status = cfg::none;
|
||||
e.earfcn = 0;
|
||||
e.pci = UINT32_MAX;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t get_pci(uint32_t cc_idx)
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
|
||||
if (cc_idx == 0 or cc_idx >= SRSLTE_MAX_CARRIERS) {
|
||||
ERROR("CC IDX %d out-of-range\n", cc_idx);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return scell_cfg[cc_idx].pci;
|
||||
}
|
||||
|
||||
uint32_t get_earfcn(uint32_t cc_idx)
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
|
||||
if (cc_idx == 0 or cc_idx >= SRSLTE_MAX_CARRIERS) {
|
||||
ERROR("CC IDX %d out-of-range\n", cc_idx);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return scell_cfg[cc_idx].earfcn;
|
||||
}
|
||||
};
|
||||
} // namespace scell
|
||||
} // namespace srsue
|
||||
#endif // SRSLTE_SCELL_STATE_H
|
||||
Loading…
Reference in New Issue