aboutsummaryrefslogtreecommitdiffstats
path: root/src/osmo-bsc/timeslot_fsm.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/osmo-bsc/timeslot_fsm.c')
-rw-r--r--src/osmo-bsc/timeslot_fsm.c861
1 files changed, 861 insertions, 0 deletions
diff --git a/src/osmo-bsc/timeslot_fsm.c b/src/osmo-bsc/timeslot_fsm.c
new file mode 100644
index 000000000..e3085be07
--- /dev/null
+++ b/src/osmo-bsc/timeslot_fsm.c
@@ -0,0 +1,861 @@
+/* osmo-bsc API to manage timeslot status: init and switch of dynamic PDCH.
+ *
+ * (C) 2017 by sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
+ * All Rights Reserved
+ *
+ * Author: Neels Hofmeyr <neels@hofmeyr.de>
+ *
+ * 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/>.
+ *
+ */
+
+#include <osmocom/core/logging.h>
+
+#include <osmocom/bsc/debug.h>
+
+#include <osmocom/bsc/timeslot_fsm.h>
+#include <osmocom/bsc/lchan_fsm.h>
+#include <osmocom/bsc/abis_rsl.h>
+#include <osmocom/bsc/pcu_if.h>
+
+static struct osmo_fsm ts_fsm;
+
+#define CHAN_ACT_DEACT_TIMEOUT 4 /* TODO: proper T number? */
+
+enum ts_fsm_T {
+ T_CHAN_ACT_DEACT=23001,
+};
+
+struct gsm_bts_trx_ts *ts_fi_ts(struct osmo_fsm_inst *fi)
+{
+ OSMO_ASSERT(fi);
+ OSMO_ASSERT(fi->fsm == &ts_fsm);
+ OSMO_ASSERT(fi->priv);
+ return fi->priv;
+}
+
+static void ts_fsm_update_id(struct gsm_bts_trx_ts *ts)
+{
+ osmo_fsm_inst_update_id_f(ts->fi, "%u-%u-%u-%s", ts->trx->bts->nr, ts->trx->nr, ts->nr,
+ gsm_pchan_id(ts->pchan_on_init));
+}
+
+void ts_fsm_alloc(struct gsm_bts_trx_ts *ts)
+{
+ static bool g_initialized = false;
+ if (!g_initialized) {
+ OSMO_ASSERT(osmo_fsm_register(&ts_fsm) == 0);
+ g_initialized = true;
+ }
+ OSMO_ASSERT(!ts->fi);
+ OSMO_ASSERT(ts->trx);
+ ts->fi = osmo_fsm_inst_alloc(&ts_fsm, ts->trx, ts, LOGL_DEBUG, NULL);
+ OSMO_ASSERT(ts->fi);
+}
+
+enum lchan_sanity {
+ LCHAN_IS_INSANE = -1,
+ LCHAN_IS_READY_TO_GO,
+ LCHAN_NEEDS_PCHAN_CHANGE,
+};
+
+static enum lchan_sanity is_lchan_sane(struct gsm_bts_trx_ts *ts, struct gsm_lchan *lchan)
+{
+ OSMO_ASSERT(ts);
+ OSMO_ASSERT(lchan);
+ if (lchan->ts != ts)
+ return LCHAN_IS_INSANE;
+ if (!lchan->fi)
+ return LCHAN_IS_INSANE;
+
+ if (lchan->type == gsm_lchan_type_by_pchan(ts->pchan_is))
+ return LCHAN_IS_READY_TO_GO;
+
+ switch (ts->pchan_on_init) {
+ case GSM_PCHAN_TCH_F_TCH_H_PDCH:
+ if (lchan->type == GSM_LCHAN_TCH_H)
+ return LCHAN_NEEDS_PCHAN_CHANGE;
+ /* fall thru */
+ case GSM_PCHAN_TCH_F_PDCH:
+ if (lchan->type == GSM_LCHAN_TCH_F)
+ return LCHAN_NEEDS_PCHAN_CHANGE;
+ /* fall thru */
+ default:
+ return LCHAN_IS_INSANE;
+ }
+
+}
+
+static void lchan_dispatch(struct gsm_lchan *lchan, uint32_t lchan_ev)
+{
+ if (!lchan->fi)
+ return;
+ osmo_fsm_inst_dispatch(lchan->fi, lchan_ev, NULL);
+ OSMO_ASSERT(lchan->fi->state != LCHAN_ST_WAIT_TS_READY);
+}
+
+static int ts_count_active_lchans(struct gsm_bts_trx_ts *ts)
+{
+ struct gsm_lchan *lchan;
+ int count = 0;
+
+ ts_for_each_lchan(lchan, ts) {
+ if (lchan->fi->state == LCHAN_ST_UNUSED)
+ continue;
+ count++;
+ }
+
+ return count;
+}
+
+static void ts_lchans_dispatch(struct gsm_bts_trx_ts *ts, int lchan_state, uint32_t lchan_ev)
+{
+ struct gsm_lchan *lchan;
+
+ ts_for_each_lchan(lchan, ts) {
+ if (lchan_state >= 0
+ && !lchan_state_is(lchan, lchan_state))
+ continue;
+ lchan_dispatch(lchan, lchan_ev);
+ }
+}
+
+static void ts_terminate_lchan_fsms(struct gsm_bts_trx_ts *ts)
+{
+ struct gsm_lchan *lchan;
+
+ ts_for_each_lchan(lchan, ts) {
+ osmo_fsm_inst_term(lchan->fi, OSMO_FSM_TERM_REQUEST, NULL);
+ }
+}
+
+static int ts_lchans_waiting(struct gsm_bts_trx_ts *ts)
+{
+ struct gsm_lchan *lchan;
+ int count = 0;
+ ts_for_each_lchan(lchan, ts)
+ if (lchan->fi->state == LCHAN_ST_WAIT_TS_READY)
+ count++;
+ return count;
+}
+
+static void ts_fsm_error(struct osmo_fsm_inst *fi, uint32_t state_chg, const char *fmt, ...)
+{
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+
+ char *errmsg = NULL;
+
+ if (fmt) {
+ va_list ap;
+
+ va_start(ap, fmt);
+ errmsg = talloc_vasprintf(ts->trx, fmt, ap);
+ va_end(ap);
+ }
+
+ if (ts->last_errmsg)
+ talloc_free(ts->last_errmsg);
+ ts->last_errmsg = errmsg;
+
+ if (errmsg)
+ LOG_TS(ts, LOGL_ERROR, "%s", errmsg);
+
+ ts_lchans_dispatch(ts, LCHAN_ST_WAIT_TS_READY, LCHAN_EV_TS_ERROR);
+ if (fi->state != state_chg)
+ osmo_fsm_inst_state_chg(fi, state_chg, 0, 0);
+}
+
+static void ts_fsm_err_ready_to_go_in_pdch(struct osmo_fsm_inst *fi, struct gsm_lchan *lchan)
+{
+ /* This shouldn't ever happen, so aggressively mark it. */
+ ts_fsm_error(fi, TS_ST_BORKEN,
+ "Internal error: lchan marked as 'ready to go', but activating"
+ " any lchan should need PCHAN switchover in state %s (lchan: %s)",
+ osmo_fsm_inst_state_name(fi), gsm_lchan_name(lchan));
+}
+
+static void ts_setup_lchans(struct gsm_bts_trx_ts *ts)
+{
+ int i, max_lchans;
+
+ ts->pchan_on_init = ts->pchan_from_config;
+ ts_fsm_update_id(ts);
+
+ max_lchans = pchan_subslots(ts->pchan_on_init);
+ LOG_TS(ts, LOGL_DEBUG, "max lchans: %d", max_lchans);
+
+ for (i = 0; i < max_lchans; i++) {
+ /* We sometimes receive more than one Channel OPSTART ACK. Not quite sure why, just
+ * seeing it happen with bts_ipaccess_nanobts. Don't fail on the second init. */
+ if (ts->lchan[i].fi)
+ continue;
+ lchan_fsm_alloc(&ts->lchan[i]);
+ }
+
+ switch (ts->pchan_on_init) {
+ case GSM_PCHAN_TCH_F_TCH_H_PDCH:
+ ts->pchan_is = GSM_PCHAN_NONE;
+ break;
+ case GSM_PCHAN_TCH_F_PDCH:
+ ts->pchan_is = GSM_PCHAN_TCH_F;
+ break;
+ default:
+ ts->pchan_is = ts->pchan_on_init;
+ break;
+ }
+
+ LOG_TS(ts, LOGL_DEBUG, "lchans initialized: %d", max_lchans);
+}
+
+static void ts_fsm_not_initialized(struct osmo_fsm_inst *fi, uint32_t event, void *data)
+{
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+ struct gsm_bts *bts = ts->trx->bts;
+ switch (event) {
+
+ case TS_EV_OML_READY:
+ ts->pdch_act_allowed = true;
+ ts_setup_lchans(ts);
+ if (!ts->trx->rsl_link) {
+ LOG_TS(ts, LOGL_DEBUG, "No RSL link yet");
+ return;
+ }
+ /* -> UNUSED below */
+ break;
+
+ case TS_EV_RSL_READY:
+ ts->pdch_act_allowed = true;
+ if (bts->model->oml_is_ts_ready
+ && !bts->model->oml_is_ts_ready(ts)) {
+ LOG_TS(ts, LOGL_DEBUG, "OML not ready yet");
+ return;
+ }
+ /* -> UNUSED below */
+ break;
+
+ case TS_EV_LCHAN_REQUESTED:
+ {
+ /* TS is not initialized, no lchan can be requested. */
+ struct gsm_lchan *lchan = data;
+ if (lchan && lchan->fi)
+ osmo_fsm_inst_dispatch(fi, LCHAN_EV_TS_ERROR, NULL);
+ }
+ return;
+
+ case TS_EV_LCHAN_UNUSED:
+ /* ignored. */
+ return;
+
+ default:
+ OSMO_ASSERT(false);
+ }
+
+ osmo_fsm_inst_state_chg(fi, TS_ST_UNUSED, 0, 0);
+}
+
+static void ts_fsm_unused_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state)
+{
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+ struct gsm_bts *bts = ts->trx->bts;
+
+ /* We are entering the unused state. There must by definition not be any lchans waiting to be
+ * activated. */
+ if (ts_lchans_waiting(ts)) {
+ ts_fsm_error(fi, TS_ST_BORKEN,
+ "Internal error: entering UNUSED state, but there are lchans waiting to be"
+ " activated. Not activating them to prevent infinite loops.");
+ return;
+ }
+
+ switch (ts->pchan_on_init) {
+ case GSM_PCHAN_TCH_F_TCH_H_PDCH:
+ case GSM_PCHAN_TCH_F_PDCH:
+ if (bts->gprs.mode == BTS_GPRS_NONE) {
+ LOG_TS(ts, LOGL_DEBUG, "GPRS mode is 'none': not activating PDCH.");
+ return;
+ }
+ if (!ts->pdch_act_allowed) {
+ LOG_TS(ts, LOGL_DEBUG, "PDCH is disabled for this timeslot,"
+ " either due to a PDCH ACT NACK, or from manual VTY command:"
+ " not activating PDCH. (last error: %s)",
+ ts->last_errmsg ? : "-");
+ return;
+ }
+ osmo_fsm_inst_state_chg(fi, TS_ST_WAIT_PDCH_ACT, CHAN_ACT_DEACT_TIMEOUT,
+ T_CHAN_ACT_DEACT);
+ break;
+
+ default:
+ /* nothing to do */
+ break;
+ }
+}
+
+static void ts_fsm_unused(struct osmo_fsm_inst *fi, uint32_t event, void *data)
+{
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+
+ switch (event) {
+
+ case TS_EV_LCHAN_REQUESTED:
+ {
+ struct gsm_lchan *lchan = data;
+ switch (is_lchan_sane(ts, lchan)) {
+ case LCHAN_NEEDS_PCHAN_CHANGE:
+ /* Osmocom style dyn TS: in UNUSED state, PDCH is already switched off,
+ * we merely need to RSL Chan Activ the new lchan. For ip.access style
+ * dyn TS this is already TCH/F, and we should never hit this. */
+ case LCHAN_IS_READY_TO_GO:
+ osmo_fsm_inst_state_chg(fi, TS_ST_IN_USE, 0, 0);
+ return;
+ default:
+ osmo_fsm_inst_dispatch(lchan->fi, LCHAN_EV_TS_ERROR, NULL);
+ return;
+ }
+ }
+
+ case TS_EV_LCHAN_UNUSED:
+ /* ignored. */
+ return;
+
+ default:
+ OSMO_ASSERT(false);
+ }
+}
+
+static inline void ts_fsm_pdch_deact(struct osmo_fsm_inst *fi)
+{
+ osmo_fsm_inst_state_chg(fi, TS_ST_WAIT_PDCH_DEACT, CHAN_ACT_DEACT_TIMEOUT, T_CHAN_ACT_DEACT);
+}
+
+static void ts_fsm_wait_pdch_act_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state)
+{
+ int rc;
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+
+ rc = rsl_tx_dyn_ts_pdch_act_deact(ts, true);
+
+ /* On error, we couldn't send the activation message and remain unused. */
+ if (rc)
+ ts_fsm_error(fi, TS_ST_UNUSED, "Unable to send PDCH activation");
+}
+
+static void ts_fsm_wait_pdch_act(struct osmo_fsm_inst *fi, uint32_t event, void *data)
+{
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+ switch (event) {
+
+ case TS_EV_PDCH_ACT_ACK:
+ osmo_fsm_inst_state_chg(fi, TS_ST_PDCH, 0, 0);
+ return;
+
+ case TS_EV_PDCH_ACT_NACK:
+ if (ts->pchan_on_init == GSM_PCHAN_TCH_F_PDCH)
+ rate_ctr_inc(&ts->trx->bts->bts_ctrs->ctr[BTS_CTR_RSL_IPA_NACK]);
+ else
+ rate_ctr_inc(&ts->trx->bts->bts_ctrs->ctr[BTS_CTR_CHAN_ACT_NACK]);
+ ts->pdch_act_allowed = false;
+ ts_fsm_error(fi, TS_ST_UNUSED, "Received PDCH activation NACK");
+ return;
+
+ case TS_EV_LCHAN_REQUESTED:
+ {
+ struct gsm_lchan *lchan = data;
+ switch (is_lchan_sane(ts, lchan)) {
+ case LCHAN_IS_READY_TO_GO:
+ /* PDCH activation has not been acked, the previous pchan kind may still
+ * linger in ts->pchan and make it look like the ts is usable right away.
+ * But we've started the switchover and must finish that first. */
+ case LCHAN_NEEDS_PCHAN_CHANGE:
+ /* PDCH onenter will see that the lchan is waiting and continue to switch
+ * off PDCH right away. */
+ return;
+
+ default:
+ lchan_dispatch(lchan, LCHAN_EV_TS_ERROR);
+ return;
+ }
+ }
+
+ case TS_EV_LCHAN_UNUSED:
+ /* ignored. */
+ return;
+
+ default:
+ OSMO_ASSERT(false);
+ }
+}
+
+static void ts_fsm_pdch_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state)
+{
+ int count;
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+
+ /* Set pchan = PDCH status, but double check. */
+ switch (ts->pchan_on_init) {
+ case GSM_PCHAN_TCH_F_TCH_H_PDCH:
+ case GSM_PCHAN_TCH_F_PDCH:
+ case GSM_PCHAN_PDCH:
+ ts->pchan_is = GSM_PCHAN_PDCH;
+ break;
+ default:
+ ts_fsm_error(fi, TS_ST_BORKEN, "pchan %s is incapable of activating PDCH",
+ gsm_pchan_name(ts->pchan_on_init));
+ return;
+ }
+
+ /* PDCH use has changed, tell the PCU about it. */
+ pcu_info_update(ts->trx->bts);
+
+ /* If we received TS_EV_LCHAN_REQUESTED in the meantime, go right out of PDCH again. */
+ if ((count = ts_lchans_waiting(ts))) {
+ LOG_TS(ts, LOGL_DEBUG, "%d lchan(s) waiting for usable timeslot", count);
+ ts_fsm_pdch_deact(fi);
+ }
+}
+
+static void ts_fsm_pdch(struct osmo_fsm_inst *fi, uint32_t event, void *data)
+{
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+ switch (event) {
+
+ case TS_EV_LCHAN_REQUESTED:
+ {
+ struct gsm_lchan *lchan = data;
+ switch (is_lchan_sane(ts, lchan)) {
+ case LCHAN_NEEDS_PCHAN_CHANGE:
+ ts_fsm_pdch_deact(fi);
+ return;
+
+ case LCHAN_IS_READY_TO_GO:
+ ts_fsm_err_ready_to_go_in_pdch(fi, lchan);
+ return;
+
+ default:
+ /* Reject just this lchan. */
+ lchan_dispatch(lchan, LCHAN_EV_TS_ERROR);
+ return;
+ }
+ }
+
+ case TS_EV_LCHAN_UNUSED:
+ /* ignored */
+ return;
+
+ default:
+ OSMO_ASSERT(false);
+ }
+}
+
+static void ts_fsm_wait_pdch_deact_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state)
+{
+ int rc;
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+
+ rc = rsl_tx_dyn_ts_pdch_act_deact(ts, false);
+
+ /* On error, we couldn't send the deactivation message and remain in PDCH. */
+ if (rc)
+ ts_fsm_error(fi, TS_ST_PDCH, "Unable to send PDCH deactivation");
+}
+
+static void ts_fsm_wait_pdch_deact(struct osmo_fsm_inst *fi, uint32_t event, void *data)
+{
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+ switch (event) {
+
+ case TS_EV_PDCH_DEACT_ACK:
+ /* Remove pchan = PDCH status, but double check. */
+ switch (ts->pchan_on_init) {
+ case GSM_PCHAN_TCH_F_TCH_H_PDCH:
+ ts->pchan_is = GSM_PCHAN_NONE;
+ break;
+ case GSM_PCHAN_TCH_F_PDCH:
+ ts->pchan_is = GSM_PCHAN_TCH_F;
+ break;
+ default:
+ ts_fsm_error(fi, TS_ST_BORKEN, "pchan %s is incapable of deactivating PDCH",
+ gsm_pchan_name(ts->pchan_on_init));
+ return;
+ }
+ osmo_fsm_inst_state_chg(fi, TS_ST_IN_USE, 0, 0);
+ /* IN_USE onenter will signal all waiting lchans. */
+
+ /* PDCH use has changed, tell the PCU about it. */
+ pcu_info_update(ts->trx->bts);
+ return;
+
+ case TS_EV_PDCH_DEACT_NACK:
+ if (ts->pchan_on_init == GSM_PCHAN_TCH_F_PDCH)
+ rate_ctr_inc(&ts->trx->bts->bts_ctrs->ctr[BTS_CTR_RSL_IPA_NACK]);
+ /* For Osmocom style dyn TS, there actually is no NACK, since there is no RF Channel
+ * Release NACK message in RSL. */
+ ts_fsm_error(fi, TS_ST_BORKEN, "Received PDCH deactivation NACK");
+ return;
+
+ case TS_EV_LCHAN_REQUESTED:
+ {
+ struct gsm_lchan *lchan = data;
+ switch (is_lchan_sane(ts, lchan)) {
+ case LCHAN_NEEDS_PCHAN_CHANGE:
+ /* IN_USE onenter will see that the lchan is waiting and signal it. */
+ return;
+
+ case LCHAN_IS_READY_TO_GO:
+ ts_fsm_err_ready_to_go_in_pdch(fi, lchan);
+ return;
+
+ default:
+ /* Reject just this lchan. */
+ lchan_dispatch(lchan, LCHAN_EV_TS_ERROR);
+ return;
+ }
+ }
+
+ default:
+ OSMO_ASSERT(false);
+ }
+}
+
+static void ts_fsm_in_use_onenter(struct osmo_fsm_inst *fi, uint32_t prev_event)
+{
+ int in_use;
+ struct gsm_lchan *lchan;
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+
+ /* After being in use, allow PDCH act again, if appropriate. */
+ ts->pdch_act_allowed = true;
+
+ ts_lchans_dispatch(ts, LCHAN_ST_WAIT_TS_READY, LCHAN_EV_TS_READY);
+
+ in_use = 0;
+ ts_for_each_lchan(lchan, ts) {
+ if (lchan_state_is(lchan, LCHAN_ST_UNUSED))
+ continue;
+ in_use ++;
+ }
+ if (!in_use) {
+ LOG_TS(ts, LOGL_DEBUG, "Entered IN_USE state but no lchans are actually in use now.");
+ osmo_fsm_inst_state_chg(fi, TS_ST_UNUSED, 0, 0);
+ }
+}
+
+static void ts_fsm_in_use(struct osmo_fsm_inst *fi, uint32_t event, void *data)
+{
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+ switch (event) {
+ case TS_EV_LCHAN_UNUSED:
+ if (!ts_count_active_lchans(ts))
+ osmo_fsm_inst_state_chg(fi, TS_ST_UNUSED, 0, 0);
+ return;
+
+ case TS_EV_LCHAN_REQUESTED:
+ {
+ struct gsm_lchan *lchan = data;
+ switch (is_lchan_sane(ts, lchan)) {
+ case LCHAN_IS_READY_TO_GO:
+ osmo_fsm_inst_dispatch(lchan->fi, LCHAN_EV_TS_READY, NULL);
+ return;
+
+ case LCHAN_NEEDS_PCHAN_CHANGE:
+ LOG_TS(ts, LOGL_ERROR,
+ "cannot activate lchan of mismatching pchan type"
+ " when the TS is already in use: %s",
+ gsm_lchan_name(lchan));
+ /* fall thru */
+ default:
+ /* Reject just this lchan. */
+ lchan_dispatch(lchan, LCHAN_EV_TS_ERROR);
+ return;
+ }
+ }
+
+ default:
+ OSMO_ASSERT(false);
+ }
+}
+
+static void ts_fsm_borken(struct osmo_fsm_inst *fi, uint32_t event, void *data)
+{
+ switch (event) {
+ case TS_EV_LCHAN_UNUSED:
+ /* ignored */
+ return;
+
+ case TS_EV_LCHAN_REQUESTED:
+ {
+ struct gsm_lchan *lchan = data;
+ lchan_dispatch(lchan, LCHAN_EV_TS_ERROR);
+ return;
+ }
+
+ default:
+ OSMO_ASSERT(false);
+ }
+}
+
+static int ts_fsm_timer_cb(struct osmo_fsm_inst *fi)
+{
+ switch (fi->state) {
+ case TS_ST_WAIT_PDCH_ACT:
+ ts_fsm_error(fi, TS_ST_BORKEN, "PDCH activation timeout");
+ return 0;
+
+ case TS_ST_WAIT_PDCH_DEACT:
+ ts_fsm_error(fi, TS_ST_BORKEN, "PDCH deactivation timeout");
+ return 0;
+
+ default:
+ ts_fsm_error(fi, TS_ST_BORKEN, "Unknown timeout in state %s",
+ osmo_fsm_inst_state_name(fi));
+ return 0;
+ }
+}
+
+static void ts_fsm_allstate(struct osmo_fsm_inst *fi, uint32_t event, void *data)
+{
+ struct gsm_bts_trx_ts *ts = ts_fi_ts(fi);
+ switch (event) {
+ case TS_EV_OML_DOWN:
+ if (fi->state != TS_ST_NOT_INITIALIZED)
+ osmo_fsm_inst_state_chg(fi, TS_ST_NOT_INITIALIZED, 0, 0);
+ OSMO_ASSERT(fi->state == TS_ST_NOT_INITIALIZED);
+ ts_terminate_lchan_fsms(ts);
+ ts->pchan_is = ts->pchan_on_init = GSM_PCHAN_NONE;
+ ts_fsm_update_id(ts);
+ break;
+
+ case TS_EV_RSL_DOWN:
+ if (fi->state != TS_ST_NOT_INITIALIZED)
+ osmo_fsm_inst_state_chg(fi, TS_ST_NOT_INITIALIZED, 0, 0);
+ OSMO_ASSERT(fi->state == TS_ST_NOT_INITIALIZED);
+ ts->pchan_is = GSM_PCHAN_NONE;
+ ts_lchans_dispatch(ts, -1, LCHAN_EV_TS_ERROR);
+ break;
+
+ default:
+ OSMO_ASSERT(false);
+ }
+}
+
+#define S(x) (1 << (x))
+
+static const struct osmo_fsm_state ts_fsm_states[] = {
+ [TS_ST_NOT_INITIALIZED] = {
+ .name = "NOT_INITIALIZED",
+ .action = ts_fsm_not_initialized,
+ .in_event_mask = 0
+ | S(TS_EV_OML_READY)
+ | S(TS_EV_RSL_READY)
+ | S(TS_EV_LCHAN_REQUESTED)
+ | S(TS_EV_LCHAN_UNUSED)
+ ,
+ .out_state_mask = 0
+ | S(TS_ST_UNUSED)
+ ,
+ },
+ [TS_ST_UNUSED] = {
+ .name = "UNUSED",
+ .onenter = ts_fsm_unused_onenter,
+ .action = ts_fsm_unused,
+ .in_event_mask = 0
+ | S(TS_EV_LCHAN_REQUESTED)
+ | S(TS_EV_LCHAN_UNUSED)
+ ,
+ .out_state_mask = 0
+ | S(TS_ST_WAIT_PDCH_ACT)
+ | S(TS_ST_IN_USE)
+ | S(TS_ST_NOT_INITIALIZED)
+ ,
+ },
+ [TS_ST_WAIT_PDCH_ACT] = {
+ .name = "WAIT_PDCH_ACT",
+ .onenter = ts_fsm_wait_pdch_act_onenter,
+ .action = ts_fsm_wait_pdch_act,
+ .in_event_mask = 0
+ | S(TS_EV_PDCH_ACT_ACK)
+ | S(TS_EV_PDCH_ACT_NACK)
+ | S(TS_EV_LCHAN_REQUESTED)
+ | S(TS_EV_LCHAN_UNUSED)
+ ,
+ .out_state_mask = 0
+ | S(TS_ST_PDCH)
+ | S(TS_ST_UNUSED)
+ | S(TS_ST_BORKEN)
+ | S(TS_ST_NOT_INITIALIZED)
+ ,
+ },
+ [TS_ST_PDCH] = {
+ .name = "PDCH",
+ .onenter = ts_fsm_pdch_onenter,
+ .action = ts_fsm_pdch,
+ .in_event_mask = 0
+ | S(TS_EV_LCHAN_REQUESTED)
+ | S(TS_EV_LCHAN_UNUSED)
+ ,
+ .out_state_mask = 0
+ | S(TS_ST_WAIT_PDCH_DEACT)
+ | S(TS_ST_NOT_INITIALIZED)
+ ,
+ },
+ [TS_ST_WAIT_PDCH_DEACT] = {
+ .name = "WAIT_PDCH_ACT",
+ .onenter = ts_fsm_wait_pdch_deact_onenter,
+ .action = ts_fsm_wait_pdch_deact,
+ .in_event_mask = 0
+ | S(TS_EV_PDCH_DEACT_ACK)
+ | S(TS_EV_PDCH_DEACT_NACK)
+ | S(TS_EV_LCHAN_REQUESTED)
+ | S(TS_EV_LCHAN_UNUSED)
+ ,
+ .out_state_mask = 0
+ | S(TS_ST_IN_USE)
+ | S(TS_ST_UNUSED)
+ | S(TS_ST_BORKEN)
+ | S(TS_ST_NOT_INITIALIZED)
+ ,
+ },
+ [TS_ST_IN_USE] = {
+ .name = "IN_USE",
+ .onenter = ts_fsm_in_use_onenter,
+ .action = ts_fsm_in_use,
+ .in_event_mask = 0
+ | S(TS_EV_LCHAN_REQUESTED)
+ | S(TS_EV_LCHAN_UNUSED)
+ ,
+ .out_state_mask = 0
+ | S(TS_ST_UNUSED)
+ | S(TS_ST_NOT_INITIALIZED)
+ ,
+ },
+ [TS_ST_BORKEN] = {
+ .name = "BORKEN",
+ .action = ts_fsm_borken,
+ .in_event_mask = 0
+ | S(TS_EV_LCHAN_REQUESTED)
+ | S(TS_EV_LCHAN_UNUSED)
+ ,
+ .out_state_mask = 0
+ | S(TS_ST_NOT_INITIALIZED)
+ ,
+ },
+
+};
+
+static const struct value_string ts_fsm_event_names[] = {
+ OSMO_VALUE_STRING(TS_EV_OML_READY),
+ OSMO_VALUE_STRING(TS_EV_OML_DOWN),
+ OSMO_VALUE_STRING(TS_EV_RSL_READY),
+ OSMO_VALUE_STRING(TS_EV_RSL_DOWN),
+ OSMO_VALUE_STRING(TS_EV_LCHAN_REQUESTED),
+ OSMO_VALUE_STRING(TS_EV_LCHAN_UNUSED),
+ OSMO_VALUE_STRING(TS_EV_PDCH_ACT_ACK),
+ OSMO_VALUE_STRING(TS_EV_PDCH_ACT_NACK),
+ OSMO_VALUE_STRING(TS_EV_PDCH_DEACT_ACK),
+ OSMO_VALUE_STRING(TS_EV_PDCH_DEACT_NACK),
+ {}
+};
+
+static struct osmo_fsm ts_fsm = {
+ .name = "timeslot",
+ .states = ts_fsm_states,
+ .num_states = ARRAY_SIZE(ts_fsm_states),
+ .timer_cb = ts_fsm_timer_cb,
+ .log_subsys = DRSL,
+ .event_names = ts_fsm_event_names,
+ .allstate_event_mask = 0
+ | S(TS_EV_OML_DOWN)
+ | S(TS_EV_RSL_DOWN)
+ ,
+ .allstate_action = ts_fsm_allstate,
+};
+
+/* Return true if any lchans are waiting for this timeslot to become a specific PCHAN. If target_pchan is
+ * not NULL, also return the PCHAN being waited for. */
+bool ts_is_lchan_waiting_for_pchan(struct gsm_bts_trx_ts *ts, enum gsm_phys_chan_config *target_pchan)
+{
+ struct gsm_lchan *lchan;
+ ts_for_each_lchan(lchan, ts) {
+ if (lchan->fi->state == LCHAN_ST_WAIT_TS_READY) {
+ if (target_pchan)
+ *target_pchan = gsm_pchan_by_lchan_type(lchan->type);
+ return true;
+ }
+ }
+
+ if (target_pchan)
+ *target_pchan = ts->pchan_is;
+ return false;
+}
+
+/* Return true if we are busy changing the PCHAN kind. If target_pchan is not NULL, also return the PCHAN
+ * (ultimately) being switched to. */
+bool ts_is_pchan_switching(struct gsm_bts_trx_ts *ts, enum gsm_phys_chan_config *target_pchan)
+{
+ switch (ts->fi->state) {
+ case TS_ST_NOT_INITIALIZED:
+ case TS_ST_BORKEN:
+ return false;
+ default:
+ break;
+ }
+
+ /* If an lchan is waiting, return the final pchan after all switching is done. */
+ if (ts_is_lchan_waiting_for_pchan(ts, target_pchan))
+ return true;
+
+ /* No lchans waiting. Return any ongoing switching. */
+
+ switch (ts->fi->state) {
+ case TS_ST_WAIT_PDCH_ACT:
+ if (target_pchan)
+ *target_pchan = GSM_PCHAN_PDCH;
+ return true;
+
+ case TS_ST_WAIT_PDCH_DEACT:
+ /* If we were switching to a specific pchan kind, an lchan would be waiting. So this must
+ * be NONE then. */
+ if (target_pchan)
+ *target_pchan = GSM_PCHAN_NONE;
+ return true;
+
+ default:
+ return false;
+ }
+}
+
+/* Does the timeslot's *current* state allow use as this PCHAN kind? If the ts is in switchover, return
+ * true if the switchover's target PCHAN matches, i.e. an lchan for this pchan kind could be requested
+ * and will be served after the switch. (Do not check whether any lchans are actually available.) */
+bool ts_usable_as_pchan(struct gsm_bts_trx_ts *ts, enum gsm_phys_chan_config as_pchan)
+{
+ if (!ts_is_usable(ts))
+ return false;
+
+ switch (ts->fi->state) {
+ case TS_ST_IN_USE:
+ return ts->pchan_is == as_pchan;
+
+ default:
+ break;
+ }
+
+ {
+ enum gsm_phys_chan_config target_pchan;
+ if (ts_is_lchan_waiting_for_pchan(ts, &target_pchan))
+ return target_pchan == as_pchan;
+ }
+
+ return ts_is_capable_of_pchan(ts, as_pchan);
+}