/*! \file v110_ta.c * TA (Terminal Adapter) implementation as per ITU-T V.110. */ /* * (C) 2022 by Harald Welte * (C) 2023 by sysmocom - s.f.m.c. GmbH * * Initial (Work-in-Progress) implementation by Harald Welte, * completed and co-authored by Vadim Yanitskiy. * * All Rights Reserved * * SPDX-License-Identifier: GPL-2.0+ * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 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 General Public License for more details. * */ #include #include #include #include #include #include #include #include #include #include #include #define S(x) (1 << (x)) #define V24_FLAGMASK_IS_ON(flags, circuit) \ (((flags) & S(circuit)) != 0) #define V24_FLAGMASK_IS_OFF(flags, circuit) \ (((flags) & S(circuit)) == 0) #define V24_FLAGMASK_SET_ON(flags, circuit) \ (flags) |= S(circuit) #define V24_FLAGMASK_SET_OFF(flags, circuit) \ (flags) &= ~S(circuit) /* inverse logic: ON = binary 0; OFF = binary 1 */ #define V110_SX_BIT_ON 0 #define V110_SX_BIT_OFF 1 const struct value_string osmo_v110_ta_circuit_names[] = { { OSMO_V110_TA_C_105, "105/RTS" }, { OSMO_V110_TA_C_106, "106/CTS" }, { OSMO_V110_TA_C_107, "107/DSR" }, { OSMO_V110_TA_C_108, "108/DTR" }, { OSMO_V110_TA_C_109, "109/DCD" }, { OSMO_V110_TA_C_133, "133" }, { 0, NULL } }; const struct value_string osmo_v110_ta_circuit_descs[] = { { OSMO_V110_TA_C_105, "Request to Send" }, { OSMO_V110_TA_C_106, "Clear to Send" }, { OSMO_V110_TA_C_107, "Data Set Ready" }, { OSMO_V110_TA_C_108, "Data Terminal Ready" }, { OSMO_V110_TA_C_109, "Data Carrier Detect" }, { OSMO_V110_TA_C_133, "Ready for receiving" }, { 0, NULL } }; static const struct osmo_tdef v110_ta_tdef[] = { { .T = OSMO_V110_TA_TIMER_X1, .unit = OSMO_TDEF_MS, .default_val = 3000, /* suggested in 7.1.5 e) */ .desc = "ITU-T V.110 7.1.5 Loss of frame synchronization: sync recovery timer" }, { .T = OSMO_V110_TA_TIMER_T1, .unit = OSMO_TDEF_MS, .default_val = 10000, /* suggested in 7.1.2.2 */ .desc = "ITU-T V.110 7.1.2 Connect TA to line: sync establishment timer" }, { .T = OSMO_V110_TA_TIMER_T2, .unit = OSMO_TDEF_MS, .default_val = 5000, /* suggested in 7.1.4.1 */ .desc = "ITU-T V.110 7.1.4 Disconnect mode: disconnect confirmation timer" }, { /* end of list */ } }; /********************************************************************************* * V.110 TERMINAL ADAPTER FSM *********************************************************************************/ enum v110_ta_fsm_state { V110_TA_ST_IDLE_READY, /* 7.1.1 Idle (or ready) state */ V110_TA_ST_CON_TA_TO_LINE, /* 7.1.2 Connect TA to line state */ V110_TA_ST_DATA_TRANSFER, /* 7.1.3 Data transfer state */ V110_TA_ST_DISCONNECTING, /* 7.1.4 Disconnect mode */ V110_TA_ST_RESYNCING, /* 7.1.5 Re-synchronizing state */ }; enum v110_ta_fsm_event { V110_TA_EV_RX_FRAME_IND, /* a V.110 frame was received by the lower layer */ V110_TA_EV_TX_FRAME_RTS, /* a V.110 frame is to be sent by the lower layer */ V110_TA_EV_V24_STATUS_CHG, /* V.24 flag-mask has been updated by TE */ V110_TA_EV_SYNC_IND, /* the lower layer has synchronized to the frame clock */ V110_TA_EV_DESYNC_IND, /* the lower layer has lost frame clock synchronization */ V110_TA_EV_TIMEOUT, /* generic event for handling a timeout condition */ }; static const struct value_string v110_ta_fsm_event_names[] = { { V110_TA_EV_RX_FRAME_IND, "RX_FRAME_IND" }, { V110_TA_EV_TX_FRAME_RTS, "TX_FRAME_RTS" }, { V110_TA_EV_V24_STATUS_CHG, "V24_STATUS_CHG" }, { V110_TA_EV_SYNC_IND, "SYNC_IND" }, { V110_TA_EV_DESYNC_IND, "DESYNC_IND" }, { V110_TA_EV_TIMEOUT, "TIMEOUT" }, { 0, NULL } }; enum v110_ta_d_bit_mode { V110_TA_DBIT_M_ALL_ZERO = 0, /* set all bits to binary '0' */ V110_TA_DBIT_M_ALL_ONE = 1, /* set all bits to binary '1' */ V110_TA_DBIT_M_FORWARD, /* forward D-bits to/from DTE */ }; struct v110_ta_state { /*! V.24 status flags shared between DTE (user) and DCE (TA, us) */ unsigned int v24_flags; struct { /* what kind of D-bits to transmit in V.110 frames */ enum v110_ta_d_bit_mode d_bit_mode; /* what to put in S-bits of transmitted V.110 frames */ ubit_t s_bits; /* what to put in X-bits of transmitted V.110 frames */ ubit_t x_bits; } tx; struct { enum v110_ta_d_bit_mode d_bit_mode; } rx; }; struct osmo_v110_ta { const char *name; struct osmo_tdef *Tdefs; struct osmo_fsm_inst *fi; struct osmo_v110_ta_cfg *cfg; struct v110_ta_state state; }; static inline bool v110_df_x_bits_are(const struct osmo_v110_decoded_frame *df, ubit_t cmp) { return (df->x_bits[0] == cmp) && (df->x_bits[1] == cmp); } static inline bool v110_df_s_bits_are(const struct osmo_v110_decoded_frame *df, ubit_t cmp) { /* ITU-T Table 2/V.110 (see also 5.1.2.3) defines the following S-bits: * S1, S3, S4, S6, S8, S9 (6 bits total). However, fr->s_bits[] contains * 9 (MAX_S_BITS) bits, including the undefined bits S2, S5, S7. * Hence we must skip those undefined bits. */ static const uint8_t sbit_map[] = { 0, 2, 3, 5, 7, 8 }; for (unsigned int i = 0; i < ARRAY_SIZE(sbit_map); i++) { uint8_t idx = sbit_map[i]; if (df->s_bits[idx] != cmp) return false; } return true; } static inline bool v110_df_d_bits_are(const struct osmo_v110_decoded_frame *df, ubit_t cmp) { for (unsigned int i = 0; i < MAX_D_BITS; i++) { if (df->d_bits[i] != cmp) return false; } return true; } /* handle one V.110 frame and forward user bits to the application */ static void v110_ta_handle_frame(const struct osmo_v110_ta *ta, const struct osmo_v110_decoded_frame *df) { const struct osmo_v110_ta_cfg *cfg = ta->cfg; const struct v110_ta_state *ts = &ta->state; ubit_t user_bits[MAX_D_BITS]; int num_user_bits; int rc; switch (ts->rx.d_bit_mode) { case V110_TA_DBIT_M_ALL_ZERO: case V110_TA_DBIT_M_ALL_ONE: /* generate as many user bits as needed for the configured rate */ num_user_bits = osmo_v110_sync_ra1_get_user_data_chunk_bitlen(cfg->rate); OSMO_ASSERT(num_user_bits > 0); /* set them all to binary '0' or binary '1' */ memset(&user_bits[0], (int)ts->rx.d_bit_mode, num_user_bits); cfg->rx_cb(cfg->priv, &user_bits[0], num_user_bits); break; case V110_TA_DBIT_M_FORWARD: rc = osmo_v110_sync_ra1_ir_to_user(cfg->rate, &user_bits[0], sizeof(user_bits), df); if (rc > 0) cfg->rx_cb(cfg->priv, &user_bits[0], rc); /* XXX else: indicate an error somehow? */ break; } } /* build one V.110 frame to transmit */ static void v110_ta_build_frame(const struct osmo_v110_ta *ta, struct osmo_v110_decoded_frame *df) { const struct osmo_v110_ta_cfg *cfg = ta->cfg; const struct v110_ta_state *ts = &ta->state; ubit_t user_bits[MAX_D_BITS]; int num_user_bits; int rc; /* E-bits (E1/E2/E3 may be overwritten below) */ memset(df->e_bits, 1, sizeof(df->e_bits)); /* S-bits */ memset(df->s_bits, ts->tx.s_bits, sizeof(df->s_bits)); /* X-bits */ memset(df->x_bits, ts->tx.x_bits, sizeof(df->x_bits)); /* D-bits */ switch (ts->tx.d_bit_mode) { case V110_TA_DBIT_M_ALL_ZERO: case V110_TA_DBIT_M_ALL_ONE: /* set them all to binary '0' or binary '1' */ memset(df->d_bits, (int)ts->tx.d_bit_mode, sizeof(df->d_bits)); break; case V110_TA_DBIT_M_FORWARD: /* how many user bits to retrieve */ num_user_bits = osmo_v110_sync_ra1_get_user_data_chunk_bitlen(cfg->rate); OSMO_ASSERT(num_user_bits > 0); /* retrieve user bits from the application */ cfg->tx_cb(cfg->priv, &user_bits[0], num_user_bits); /* convert user bits to intermediate rate (store to df) */ rc = osmo_v110_sync_ra1_user_to_ir(cfg->rate, df, &user_bits[0], num_user_bits); OSMO_ASSERT(rc == 0); break; } } static void v110_ta_flags_update(struct osmo_v110_ta *ta, unsigned int v24_flags) { struct osmo_v110_ta_cfg *cfg = ta->cfg; if (ta->state.v24_flags == v24_flags) return; if (cfg->status_update_cb != NULL) cfg->status_update_cb(cfg->priv, v24_flags); ta->state.v24_flags = v24_flags; } static const struct osmo_tdef_state_timeout v110_ta_fsm_timeouts[32] = { [V110_TA_ST_RESYNCING] = { .T = OSMO_V110_TA_TIMER_X1 }, [V110_TA_ST_CON_TA_TO_LINE] = { .T = OSMO_V110_TA_TIMER_T1 }, [V110_TA_ST_DISCONNECTING] = { .T = OSMO_V110_TA_TIMER_T2 }, }; #define v110_ta_fsm_state_chg(state) \ osmo_tdef_fsm_inst_state_chg(fi, state, \ v110_ta_fsm_timeouts, \ ((struct osmo_v110_ta *)(fi->priv))->Tdefs, \ 0) /* ITU-T V.110 Section 7.1.1 */ static void v110_ta_fsm_idle_ready_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state) { struct osmo_v110_ta *ta = (struct osmo_v110_ta *)fi->priv; struct v110_ta_state *ts = &ta->state; unsigned int v24_flags = ta->state.v24_flags; /* 7.1.1.2 During the idle (or ready) state the TA will transmit continuous binary 1s into the B-channel */ ts->tx.d_bit_mode = V110_TA_DBIT_M_ALL_ONE; /* circuit 103: continuous binary '1' */ ts->tx.s_bits = V110_SX_BIT_OFF; /* OFF is binary '1' */ ts->tx.x_bits = V110_SX_BIT_OFF; /* OFF is binary '1' */ /* 7.1.1.3 During the idle (or ready) state the TA (DCE) will transmit the following toward the DTE: */ /* - circuit 104: continuous binary '1' */ ts->rx.d_bit_mode = V110_TA_DBIT_M_ALL_ONE; /* - circuits 107, 106, 109 = OFF */ V24_FLAGMASK_SET_OFF(v24_flags, OSMO_V110_TA_C_106); V24_FLAGMASK_SET_OFF(v24_flags, OSMO_V110_TA_C_107); V24_FLAGMASK_SET_OFF(v24_flags, OSMO_V110_TA_C_109); v110_ta_flags_update(ta, v24_flags); } /* ITU-T V.110 Section 7.1.1 */ static void v110_ta_fsm_idle_ready(struct osmo_fsm_inst *fi, uint32_t event, void *data) { struct osmo_v110_ta *ta = (struct osmo_v110_ta *)fi->priv; struct v110_ta_state *ts = &ta->state; switch (event) { case V110_TA_EV_V24_STATUS_CHG: /* When the TA is to be switched to the data mode, circuit 108 must be ON */ if (V24_FLAGMASK_IS_ON(ts->v24_flags, OSMO_V110_TA_C_108)) { /* 7.12.2: Start timer T1 when switching to CON_TA_LINE */ v110_ta_fsm_state_chg(V110_TA_ST_CON_TA_TO_LINE); } break; case V110_TA_EV_RX_FRAME_IND: v110_ta_handle_frame(ta, (const struct osmo_v110_decoded_frame *)data); break; case V110_TA_EV_TX_FRAME_RTS: v110_ta_build_frame(ta, (struct osmo_v110_decoded_frame *)data); break; default: OSMO_ASSERT(0); } } /* ITU-T V.110 Section 7.1.2 */ static void v110_ta_fsm_connect_ta_to_line_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state) { struct osmo_v110_ta *ta = (struct osmo_v110_ta *)fi->priv; struct v110_ta_state *ts = &ta->state; /* 7.1.2.1 Switching to the data mode causes the TA to transmit the following towards the ISDN: */ /* a) frame synchronization pattern as described in 5.1.3.1 and 5.2.1 (done by the API user) */ /* b) circuit 103: continuous binary '1' */ ts->tx.d_bit_mode = V110_TA_DBIT_M_ALL_ONE; /* c) status bits S = OFF and X = OFF */ ts->tx.s_bits = V110_SX_BIT_OFF; /* OFF is binary '1' */ ts->tx.x_bits = V110_SX_BIT_OFF; /* OFF is binary '1' */ /* 7.1.2.2 ... the receiver in the TA will begin to search for the frame synchronization * pattern in the received bit stream (see 5.1.3.1 and 5.2.1) and start timer T1. */ OSMO_ASSERT(fi->T == OSMO_V110_TA_TIMER_T1); } /* ITU-T V.110 Section 7.1.2 */ static void v110_ta_fsm_connect_ta_to_line(struct osmo_fsm_inst *fi, uint32_t event, void *data) { struct osmo_v110_ta *ta = (struct osmo_v110_ta *)fi->priv; struct v110_ta_state *ts = &ta->state; switch (event) { case V110_TA_EV_V24_STATUS_CHG: /* If circuit 108 is OFF, we go back to IDLE/READY */ if (V24_FLAGMASK_IS_OFF(ts->v24_flags, OSMO_V110_TA_C_108)) v110_ta_fsm_state_chg(V110_TA_ST_IDLE_READY); break; case V110_TA_EV_SYNC_IND: /* 7.1.2.3 When the receiver recognizes the frame synchronization pattern, it causes the S- * and X-bits in the transmitted frames to be turned ON (provided that circuit 108 is ON). */ OSMO_ASSERT(V24_FLAGMASK_IS_ON(ts->v24_flags, OSMO_V110_TA_C_108)); ts->tx.s_bits = V110_SX_BIT_ON; ts->tx.x_bits = V110_SX_BIT_ON; break; case V110_TA_EV_RX_FRAME_IND: { const struct osmo_v110_decoded_frame *df = data; unsigned int v24_flags = ta->state.v24_flags; /* 7.1.2.4 When the receiver recognizes that the status of bits S and X are ON */ if (v110_df_s_bits_are(df, V110_SX_BIT_ON) && v110_df_x_bits_are(df, V110_SX_BIT_ON)) { /* ... it will perform the following functions: */ /* a) Turn ON circuit 107 toward the DTE and stop timer T1 */ V24_FLAGMASK_SET_ON(v24_flags, OSMO_V110_TA_C_107); osmo_timer_del(&fi->timer); /* b) Then, circuit 103 may be connected to the data bits in the frame; however, the * DTE must maintain a binary 1 condition on circuit 103 until circuit 106 is turned * ON in the next portion of the sequence. */ /* c) Turn ON circuit 109 and connect the data bits to circuit 104. */ V24_FLAGMASK_SET_ON(v24_flags, OSMO_V110_TA_C_109); ts->rx.d_bit_mode = V110_TA_DBIT_M_FORWARD; /* d) After an interval of N bits (see 6.3), it will turn ON circuit 106. */ V24_FLAGMASK_SET_ON(v24_flags, OSMO_V110_TA_C_106); ts->tx.d_bit_mode = V110_TA_DBIT_M_FORWARD; v110_ta_flags_update(ta, v24_flags); /* Circuit 106 transitioning from OFF to ON will cause the transmitted data to * transition from binary 1 to the data mode. */ v110_ta_fsm_state_chg(V110_TA_ST_DATA_TRANSFER); } v110_ta_handle_frame(ta, df); break; } case V110_TA_EV_TX_FRAME_RTS: v110_ta_build_frame(ta, (struct osmo_v110_decoded_frame *)data); break; case V110_TA_EV_TIMEOUT: v110_ta_fsm_state_chg(V110_TA_ST_IDLE_READY); break; default: OSMO_ASSERT(0); } } /* ITU-T V.110 Section 7.1.3 */ static void v110_ta_fsm_data_transfer_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state) { struct osmo_v110_ta *ta = (struct osmo_v110_ta *)fi->priv; struct v110_ta_state *ts = &ta->state; unsigned int v24_flags = ta->state.v24_flags; /* 7.1.3.1 While in the data transfer state, the following circuit conditions exist: * a): 105, 107, 108, and 109 are in the ON condition */ /* XXX: OSMO_ASSERT(V24_FLAGMASK_IS_ON(ts->v24_flags, OSMO_V110_TA_C_105)); */ V24_FLAGMASK_SET_ON(v24_flags, OSMO_V110_TA_C_107); /* XXX: OSMO_ASSERT(V24_FLAGMASK_IS_ON(ts->v24_flags, OSMO_V110_TA_C_108)); */ V24_FLAGMASK_SET_ON(v24_flags, OSMO_V110_TA_C_109); /* b) data is being transmitted on circuit 103 and received on circuit 104 */ ts->rx.d_bit_mode = V110_TA_DBIT_M_FORWARD; ts->tx.d_bit_mode = V110_TA_DBIT_M_FORWARD; /* c) circuits 133 (when implemented) and 106 are in the ON condition unless local out-of-band * flow control is being used, either or both circuits may be in the ON or the OFF condition. */ if (!ta->cfg->flow_ctrl.end_to_end) { /* XXX: OSMO_ASSERT(V24_FLAGMASK_IS_ON(ts->v24_flags, OSMO_V110_TA_C_133)); */ V24_FLAGMASK_SET_ON(v24_flags, OSMO_V110_TA_C_106); } v110_ta_flags_update(ta, v24_flags); /* 7.1.3.2 While in the data transfer state, the following status bit conditions exist: */ /* a) status bits S in both directions are in the ON condition; */ ts->tx.s_bits = V110_SX_BIT_ON; /* b) status bits X in both directions are in the ON condition unless end-to-end flow control * is being used, in which case status bit X in either or both directions may be in the * ON or the OFF condition. */ if (!ta->cfg->flow_ctrl.end_to_end) ts->tx.x_bits = V110_SX_BIT_ON; } /* ITU-T V.110 Section 7.1.3 */ static void v110_ta_fsm_data_transfer(struct osmo_fsm_inst *fi, uint32_t event, void *data) { struct osmo_v110_ta *ta = (struct osmo_v110_ta *)fi->priv; struct v110_ta_state *ts = &ta->state; /* 7.1.3.3 While in the data transfer state: */ /* a) the S status bits shall *not* be mapped to/from the interchange circuits */ /* b) the X status bits shall *not* be mapped according to Table 3, * unless end-to-end flow control is implemented */ /* TODO: if (ta->cfg->flow_ctrl.end_to_end) { ... } */ switch (event) { case V110_TA_EV_V24_STATUS_CHG: /* 7.1.4.1 At the completion of the data transfer phase, the local DTE will indicate a * disconnect request by turning OFF circuit 108 */ if (V24_FLAGMASK_IS_ON(ts->v24_flags, OSMO_V110_TA_C_108)) break; v110_ta_fsm_state_chg(V110_TA_ST_DISCONNECTING); break; case V110_TA_EV_DESYNC_IND: v110_ta_fsm_state_chg(V110_TA_ST_RESYNCING); break; case V110_TA_EV_TX_FRAME_RTS: v110_ta_build_frame(ta, (struct osmo_v110_decoded_frame *)data); break; case V110_TA_EV_RX_FRAME_IND: { const struct osmo_v110_decoded_frame *df = data; unsigned int v24_flags = ta->state.v24_flags; /* 7.1.4.2 ... this TA will recognize the transition of the status bits S from * ON to OFF and the data bits from data to binary 0 as a disconnect request */ if (v110_df_s_bits_are(df, V110_SX_BIT_OFF) && v110_df_d_bits_are(df, 0)) { /* ... and it will turn OFF circuits 107 and 109. */ V24_FLAGMASK_SET_OFF(v24_flags, OSMO_V110_TA_C_107); V24_FLAGMASK_SET_OFF(v24_flags, OSMO_V110_TA_C_109); v110_ta_flags_update(ta, v24_flags); /* DTE should respond by turning OFF circuit 108 */ break; /* XXX: shall we forward D-bits to DTE anyway? */ } v110_ta_handle_frame(ta, df); break; } default: OSMO_ASSERT(0); } } /* ITU-T V.110 Section 7.1.4 */ static void v110_ta_fsm_disconnect_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state) { struct osmo_v110_ta *ta = (struct osmo_v110_ta *)fi->priv; struct v110_ta_state *ts = &ta->state; unsigned int v24_flags = ta->state.v24_flags; /* 7.1.4.1 At the completion of the data transfer phase, the local DTE will indicate a * disconnect request by turning OFF circuit 108. This will cause the following to occur: */ /* a) the status bits S in the frame toward ISDN will turn OFF, status bits X are kept ON */ ts->tx.s_bits = V110_SX_BIT_OFF; /* b) circuit 106 will be turned OFF */ V24_FLAGMASK_SET_OFF(v24_flags, OSMO_V110_TA_C_106); v110_ta_flags_update(ta, v24_flags); /* c) the data bits in the frame will be set to binary 0. */ ts->tx.d_bit_mode = V110_TA_DBIT_M_ALL_ZERO; /* To guard against the failure of the remote TA to respond to the disconnect request, * the local TA may start a timer T2 (suggested value 5 s) which is stopped by the * reception or transmission of any D-channel clearing message (DISCONNECT, RELEASE, * RELEASE COMPLETE). */ OSMO_ASSERT(fi->T == OSMO_V110_TA_TIMER_T2); } /* ITU-T V.110 Section 7.1.4 */ static void v110_ta_fsm_disconnect(struct osmo_fsm_inst *fi, uint32_t event, void *data) { struct osmo_v110_ta *ta = (struct osmo_v110_ta *)fi->priv; switch (event) { case V110_TA_EV_V24_STATUS_CHG: break; /* nothing to do */ case V110_TA_EV_TX_FRAME_RTS: v110_ta_build_frame(ta, (struct osmo_v110_decoded_frame *)data); break; case V110_TA_EV_RX_FRAME_IND: { const struct osmo_v110_decoded_frame *df = data; /* 7.1.4.3 The TA at the station that originated the disconnect request will * recognize reception of S = OFF or the loss of framing signals as a disconnect * acknowledgement and turn OFF circuits 107 and 109. */ if (v110_df_s_bits_are(df, V110_SX_BIT_OFF)) { /* circuits 107 and 109 set to off in .onenter() */ v110_ta_fsm_state_chg(V110_TA_ST_IDLE_READY); } v110_ta_handle_frame(ta, df); break; } case V110_TA_EV_DESYNC_IND: case V110_TA_EV_TIMEOUT: /* circuits 107 and 109 set to off in .onenter() */ v110_ta_fsm_state_chg(V110_TA_ST_IDLE_READY); break; default: OSMO_ASSERT(0); } } /* ITU-T V.110 Section 7.1.5 */ static void v110_ta_fsm_resyncing_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state) { struct osmo_v110_ta *ta = (struct osmo_v110_ta *)fi->priv; struct v110_ta_state *ts = &ta->state; /* 7.1.5 In the event of loss of frame synchronization, the (local) TA should * attempt to resynchronize as follows: */ /* a) Place circuit 104 in binary 1 condition (passes from the data mode) */ ts->rx.d_bit_mode = V110_TA_DBIT_M_ALL_ONE; /* b) Turn OFF status bit X in the transmitted frame */ ts->tx.x_bits = V110_SX_BIT_OFF; /* guard timeout, see 7.1.5 e) */ OSMO_ASSERT(fi->T == OSMO_V110_TA_TIMER_X1); } /* ITU-T V.110 Section 7.1.5 */ static void v110_ta_fsm_resyncing(struct osmo_fsm_inst *fi, uint32_t event, void *data) { struct osmo_v110_ta *ta = (struct osmo_v110_ta *)fi->priv; struct v110_ta_state *ts = &ta->state; unsigned int v24_flags = ta->state.v24_flags; switch (event) { case V110_TA_EV_V24_STATUS_CHG: break; /* TODO: handle circuit 108 being set to OFF? */ case V110_TA_EV_TX_FRAME_RTS: v110_ta_build_frame(ta, (struct osmo_v110_decoded_frame *)data); break; case V110_TA_EV_SYNC_IND: /* f) If resynchronization is achieved, the local TA should turn ON status bit X */ ts->tx.x_bits = V110_SX_BIT_ON; v110_ta_fsm_state_chg(V110_TA_ST_DATA_TRANSFER); break; case V110_TA_EV_TIMEOUT: /* e) If after an interval of X1 seconds the local TA cannot attain synchronization, * it should send a disconnect request by turning OFF all of the status bits for several * (at least three) frames with data bits set to binary 0 and then disconnect by turning * OFF circuit 107 and transferring to the disconnected mode as discussed in 7.1.4.2. */ ts->tx.s_bits = V110_SX_BIT_OFF; ts->tx.x_bits = V110_SX_BIT_OFF; ts->tx.d_bit_mode = V110_TA_DBIT_M_ALL_ZERO; /* TODO: actually Tx those frames (delay state transition) */ V24_FLAGMASK_SET_OFF(v24_flags, OSMO_V110_TA_C_107); v110_ta_flags_update(ta, v24_flags); v110_ta_fsm_state_chg(V110_TA_ST_DISCONNECTING); break; default: OSMO_ASSERT(0); } } static int v110_ta_timer_cb(struct osmo_fsm_inst *fi) { osmo_fsm_inst_dispatch(fi, V110_TA_EV_TIMEOUT, NULL); return 0; } static const struct osmo_fsm_state v110_ta_states[] = { [V110_TA_ST_IDLE_READY] = { .name = "IDLE_READY", .in_event_mask = S(V110_TA_EV_V24_STATUS_CHG) | S(V110_TA_EV_TX_FRAME_RTS) | S(V110_TA_EV_RX_FRAME_IND), .out_state_mask = S(V110_TA_ST_IDLE_READY) | S(V110_TA_ST_CON_TA_TO_LINE), .action = &v110_ta_fsm_idle_ready, .onenter = &v110_ta_fsm_idle_ready_onenter, }, [V110_TA_ST_CON_TA_TO_LINE] = { .name = "CONNECT_TA_TO_LINE", .in_event_mask = S(V110_TA_EV_V24_STATUS_CHG) | S(V110_TA_EV_TIMEOUT) | S(V110_TA_EV_SYNC_IND) | S(V110_TA_EV_TX_FRAME_RTS) | S(V110_TA_EV_RX_FRAME_IND), .out_state_mask = S(V110_TA_ST_DATA_TRANSFER) | S(V110_TA_ST_IDLE_READY), .action = &v110_ta_fsm_connect_ta_to_line, .onenter = &v110_ta_fsm_connect_ta_to_line_onenter, }, [V110_TA_ST_DATA_TRANSFER] = { .name = "DATA_TRANSFER", .in_event_mask = S(V110_TA_EV_V24_STATUS_CHG) | S(V110_TA_EV_DESYNC_IND) | S(V110_TA_EV_TX_FRAME_RTS) | S(V110_TA_EV_RX_FRAME_IND), .out_state_mask = S(V110_TA_ST_RESYNCING) | S(V110_TA_ST_DISCONNECTING), .action = &v110_ta_fsm_data_transfer, .onenter = &v110_ta_fsm_data_transfer_onenter, }, [V110_TA_ST_DISCONNECTING] = { .name = "DISCONNECTING", .in_event_mask = S(V110_TA_EV_V24_STATUS_CHG) | S(V110_TA_EV_TIMEOUT) | S(V110_TA_EV_TX_FRAME_RTS) | S(V110_TA_EV_RX_FRAME_IND) | S(V110_TA_EV_DESYNC_IND), .out_state_mask = S(V110_TA_ST_IDLE_READY), .action = &v110_ta_fsm_disconnect, .onenter = &v110_ta_fsm_disconnect_onenter, }, [V110_TA_ST_RESYNCING] = { .name = "RESYNCING", .in_event_mask = S(V110_TA_EV_V24_STATUS_CHG) | S(V110_TA_EV_TIMEOUT) | S(V110_TA_EV_TX_FRAME_RTS) | S(V110_TA_EV_SYNC_IND), .out_state_mask = S(V110_TA_ST_IDLE_READY) | S(V110_TA_ST_DATA_TRANSFER), .action = &v110_ta_fsm_resyncing, .onenter = &v110_ta_fsm_resyncing_onenter, }, }; static struct osmo_fsm osmo_v110_ta_fsm = { .name = "V110-TA", .states = v110_ta_states, .num_states = ARRAY_SIZE(v110_ta_states), .timer_cb = v110_ta_timer_cb, .log_subsys = DLGLOBAL, .event_names = v110_ta_fsm_event_names, }; static __attribute__((constructor)) void on_dso_load(void) { OSMO_ASSERT(osmo_fsm_register(&osmo_v110_ta_fsm) == 0); } /*! Allocate a V.110 TA (Terminal Adapter) instance. * \param[in] ctx parent talloc context. * \param[in] name name of the TA instance. * \param[in] cfg initial configuration of the TA instance. * \returns pointer to allocated TA instance; NULL on error. */ struct osmo_v110_ta *osmo_v110_ta_alloc(void *ctx, const char *name, const struct osmo_v110_ta_cfg *cfg) { struct osmo_v110_ta *ta; OSMO_ASSERT(cfg != NULL); OSMO_ASSERT(cfg->rx_cb != NULL); OSMO_ASSERT(cfg->tx_cb != NULL); /* local (TE-TA) flow control is not implemented */ if (cfg->flow_ctrl.local != OSMO_V110_LOCAL_FLOW_CTRL_NONE) { LOGP(DLGLOBAL, LOGL_ERROR, "Local (TE-TA) flow control is not implemented\n"); return NULL; } ta = talloc_zero(ctx, struct osmo_v110_ta); if (ta == NULL) return NULL; ta->name = talloc_strdup(ta, name); ta->cfg = talloc_memdup(ta, cfg, sizeof(*cfg)); if (ta->name == NULL || ta->cfg == NULL) goto exit_free; ta->Tdefs = talloc_memdup(ta, v110_ta_tdef, sizeof(v110_ta_tdef)); if (ta->Tdefs == NULL) goto exit_free; osmo_tdefs_reset(ta->Tdefs); /* apply default values */ ta->fi = osmo_fsm_inst_alloc(&osmo_v110_ta_fsm, ta, ta, LOGL_DEBUG, name); if (ta->fi == NULL) goto exit_free; /* perform a loop transition to init the internal state */ osmo_fsm_inst_state_chg(ta->fi, V110_TA_ST_IDLE_READY, 0, 0); return ta; exit_free: if (ta->fi != NULL) osmo_fsm_inst_free(ta->fi); talloc_free(ta); return NULL; } /*! Release memory taken by the given V.110 TA instance. * \param[in] ta TA instance to be free()d. */ void osmo_v110_ta_free(struct osmo_v110_ta *ta) { if (ta == NULL) return; if (ta->fi != NULL) osmo_fsm_inst_free(ta->fi); talloc_free(ta); /* also free()s name and cfg */ } /*! Configure a timer of the given V.110 TA instance. * \param[in] ta TA instance to be configured. * \param[in] timer a timer to be configured. * \param[in] val_ms the new timeout value to set (in milliseconds). * \returns 0 in case of success; negative on error. */ int osmo_v110_ta_set_timer_val_ms(struct osmo_v110_ta *ta, enum osmo_v110_ta_timer timer, unsigned long val_ms) { return osmo_tdef_set(ta->Tdefs, (int)timer, val_ms, OSMO_TDEF_MS); } /*! Feed a [decoded] V.110 frame into the given TA instance. * * This function, like its _out counterpart, is intended to be used by the lower layers * receiving V.110 frames over some medium. The caller of this function is responsible * for finding the synchronization pattern (if needed), aligning to the frame boundaries, * and decoding frames using osmo_v110_decode_frame() or osmo_csd_*_decode_frame(). * * Bits E1/E2/E3 are expected to be set by the caller (if not being transmitted * over the medium) in accordance with the configured synchronous user rate. * * Bits D1..D48 are passed to the bit rate adaption function RA1. The resulting output * is then passed to the upper layer (application) via the configured .rx_cb(). Though, * in certain states of the TA's FSM, bits D1..D48 are ignored and the upper layer * gets a sequence of binary '0' or '1'. * * \param[in] ta TA instance to feed the given frame into. * \param[in] in pointer to a [decoded] V.110 frame. * \returns 0 in case of success; negative on error. */ int osmo_v110_ta_frame_in(struct osmo_v110_ta *ta, const struct osmo_v110_decoded_frame *in) { return osmo_fsm_inst_dispatch(ta->fi, V110_TA_EV_RX_FRAME_IND, (void *)in); } /*! Pull a [decoded] V.110 frame out of the given TA instance. * * This function, like its _in counterpart, is intended to be used by the lower layers * transmitting V.110 frames over some medium. The caller of this function is responsible * for encoding the output frame using osmo_v110_encode_frame() or osmo_csd_*_encode_frame(). * * Bits E1/E2/E3 are set in accordance with the configured synchronous user rate. * Bits E4/E5/E6/E7 are unconditionally set to binary '1'. * * Bits D1..D48 are set depending on the state of TA's FSM: * * - In data transfer mode, the user bits are obtained from the upper layer (application) * via the configured .tx_cb(), and then passed to the bit rate adaption function RA1, * which generates bits D1..D48. * - In other modes, bits D1..D48 are all set to binary '0' or '1'. * * \param[in] ta TA instance to pull a frame from. * \param[out] out where to store a [decoded] V.110 frame. * \returns 0 in case of success; negative on error. */ int osmo_v110_ta_frame_out(struct osmo_v110_ta *ta, struct osmo_v110_decoded_frame *out) { return osmo_fsm_inst_dispatch(ta->fi, V110_TA_EV_TX_FRAME_RTS, (void *)out); } /*! Indicate a synchronization establishment event. * * This function is intended to be called when the lower layer * achieves synchronization to the frame clock. * * \param[in] ta TA instance to indicate the event to. * \returns 0 in case of success; negative on error. */ int osmo_v110_ta_sync_ind(struct osmo_v110_ta *ta) { return osmo_fsm_inst_dispatch(ta->fi, V110_TA_EV_SYNC_IND, NULL); } /*! Indicate a synchronization loss event. * * This function is intended to be called when the lower layer * experiences a loss of synchronization with the frame clock. * * \param[in] ta TA instance to indicate the event to. * \returns 0 in case of success; negative on error. */ int osmo_v110_ta_desync_ind(struct osmo_v110_ta *ta) { return osmo_fsm_inst_dispatch(ta->fi, V110_TA_EV_DESYNC_IND, NULL); } /*! Get the V.24 status bit-mask of the given TA instance. * \param[in] ta TA instance to get the circuit bit-mask. * \returns bitmask of OSMO_V110_TA_C_*. */ unsigned int osmo_v110_ta_get_status(const struct osmo_v110_ta *ta) { return ta->state.v24_flags; } /*! Set the V.24 status bit-mask of the given TA instance. * \param[in] ta TA instance to update the circuit state. * \param[in] status bit-mask of OSMO_V110_TA_C_*. * \returns 0 on success; negative on error. */ static int v110_ta_set_status(struct osmo_v110_ta *ta, unsigned int status) { const unsigned int old_status = ta->state.v24_flags; int rc = 0; ta->state.v24_flags = status; if (status != old_status) rc = osmo_fsm_inst_dispatch(ta->fi, V110_TA_EV_V24_STATUS_CHG, NULL); return rc; } /*! Get state of a V.24 circuit of the given TA instance. * \param[in] ta TA instance to get the circuit state. * \param[in] circuit a V.24 circuit, one of OSMO_V110_TA_C_*. * \returns circuit state: active (true) or inactive (false). */ bool osmo_v110_ta_get_circuit(const struct osmo_v110_ta *ta, enum osmo_v110_ta_circuit circuit) { return V24_FLAGMASK_IS_ON(ta->state.v24_flags, circuit); } /*! Activate/deactivate a V.24 circuit of the given TA instance. * \param[in] ta TA instance to update the circuit state. * \param[in] circuit a V.24 circuit, one of OSMO_V110_TA_C_* (DTE->DCE). * \param[in] active activate (true) or deactivate (false) the circuit. * \returns 0 on success; negative on error. */ int osmo_v110_ta_set_circuit(struct osmo_v110_ta *ta, enum osmo_v110_ta_circuit circuit, bool active) { unsigned int status = ta->state.v24_flags; /* permit setting only DTE->DCE circuits */ switch (circuit) { case OSMO_V110_TA_C_105: case OSMO_V110_TA_C_108: case OSMO_V110_TA_C_133: break; default: LOGPFSML(ta->fi, LOGL_ERROR, "Setting circuit %s is not permitted (wrong direction?)\n", osmo_v110_ta_circuit_name(circuit)); return -EACCES; } if (active) V24_FLAGMASK_SET_ON(status, circuit); else V24_FLAGMASK_SET_OFF(status, circuit); return v110_ta_set_status(ta, status); }