15052 lines
436 KiB
C
15052 lines
436 KiB
C
/*
|
|
*
|
|
Copyright (c) Eicon Networks, 2002.
|
|
*
|
|
This source file is supplied for the use with
|
|
Eicon Networks range of DIVA Server Adapters.
|
|
*
|
|
Eicon File Revision : 2.1
|
|
*
|
|
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, or (at your option)
|
|
any later version.
|
|
*
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY
|
|
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
See the GNU General Public License for more details.
|
|
*
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include "platform.h"
|
|
#include "di_defs.h"
|
|
#include "pc.h"
|
|
#include "capi20.h"
|
|
#include "divacapi.h"
|
|
#include "mdm_msg.h"
|
|
#include "divasync.h"
|
|
|
|
|
|
|
|
#define FILE_ "MESSAGE.C"
|
|
#define dprintf
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* This is options supported for all adapters that are server by */
|
|
/* XDI driver. Allo it is not necessary to ask it from every adapter*/
|
|
/* and it is not necessary to save it separate for every adapter */
|
|
/* Macrose defined here have only local meaning */
|
|
/*------------------------------------------------------------------*/
|
|
static dword diva_xdi_extended_features = 0;
|
|
|
|
#define DIVA_CAPI_USE_CMA 0x00000001
|
|
#define DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR 0x00000002
|
|
#define DIVA_CAPI_XDI_PROVIDES_NO_CANCEL 0x00000004
|
|
#define DIVA_CAPI_XDI_PROVIDES_RX_DMA 0x00000008
|
|
|
|
/*
|
|
CAPI can request to process all return codes self only if:
|
|
protocol code supports this && xdi supports this
|
|
*/
|
|
#define DIVA_CAPI_SUPPORTS_NO_CANCEL(__a__) (((__a__)->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL) && ((__a__)->manufacturer_features & MANUFACTURER_FEATURE_OK_FC_LABEL) && (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_NO_CANCEL))
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* local function prototypes */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci);
|
|
static void set_group_ind_mask(PLCI *plci);
|
|
static void clear_group_ind_mask_bit(PLCI *plci, word b);
|
|
static byte test_group_ind_mask_bit(PLCI *plci, word b);
|
|
void AutomaticLaw(DIVA_CAPI_ADAPTER *);
|
|
word CapiRelease(word);
|
|
word CapiRegister(word);
|
|
word api_put(APPL *, CAPI_MSG *);
|
|
static word api_parse(byte *, word, byte *, API_PARSE *);
|
|
static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out);
|
|
static void api_load_msg(API_SAVE *in, API_PARSE *out);
|
|
|
|
word api_remove_start(void);
|
|
void api_remove_complete(void);
|
|
|
|
static void plci_remove(PLCI *);
|
|
static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a);
|
|
static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *, IDI_SYNC_REQ *);
|
|
|
|
void callback(ENTITY *);
|
|
|
|
static void control_rc(PLCI *, byte, byte, byte, byte, byte);
|
|
static void data_rc(PLCI *, byte);
|
|
static void data_ack(PLCI *, byte);
|
|
static void sig_ind(PLCI *);
|
|
static void SendInfo(PLCI *, dword, byte **, byte);
|
|
static void SendSetupInfo(APPL *, PLCI *, dword, byte **, byte);
|
|
static void SendSSExtInd(APPL *, PLCI *plci, dword Id, byte **parms);
|
|
|
|
static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms);
|
|
|
|
static void nl_ind(PLCI *);
|
|
|
|
static byte connect_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte connect_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte connect_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte disconnect_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte disconnect_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte listen_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte info_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte info_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte alert_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte facility_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte facility_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte connect_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte connect_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte connect_b3_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte disconnect_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte disconnect_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte data_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte data_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte reset_b3_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte reset_b3_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte connect_b3_t90_a_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte select_b_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte manufacturer_req(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
static byte manufacturer_res(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
|
|
static word get_plci(DIVA_CAPI_ADAPTER *);
|
|
static void add_p(PLCI *, byte, byte *);
|
|
static void add_s(PLCI *plci, byte code, API_PARSE *p);
|
|
static void add_ss(PLCI *plci, byte code, API_PARSE *p);
|
|
static void add_ie(PLCI *plci, byte code, byte *p, word p_length);
|
|
static void add_d(PLCI *, word, byte *);
|
|
static void add_ai(PLCI *, API_PARSE *);
|
|
static word add_b1(PLCI *, API_PARSE *, word, word);
|
|
static word add_b23(PLCI *, API_PARSE *);
|
|
static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms);
|
|
static void sig_req(PLCI *, byte, byte);
|
|
static void nl_req_ncci(PLCI *, byte, byte);
|
|
static void send_req(PLCI *);
|
|
static void send_data(PLCI *);
|
|
static word plci_remove_check(PLCI *);
|
|
static void listen_check(DIVA_CAPI_ADAPTER *);
|
|
static byte AddInfo(byte **, byte **, byte *, byte *);
|
|
static byte getChannel(API_PARSE *);
|
|
static void IndParse(PLCI *, word *, byte **, byte);
|
|
static byte ie_compare(byte *, byte *);
|
|
static word find_cip(DIVA_CAPI_ADAPTER *, byte *, byte *);
|
|
static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *, word);
|
|
|
|
/*
|
|
XON protocol helpers
|
|
*/
|
|
static void channel_flow_control_remove(PLCI *plci);
|
|
static void channel_x_off(PLCI *plci, byte ch, byte flag);
|
|
static void channel_x_on(PLCI *plci, byte ch);
|
|
static void channel_request_xon(PLCI *plci, byte ch);
|
|
static void channel_xmit_xon(PLCI *plci);
|
|
static int channel_can_xon(PLCI *plci, byte ch);
|
|
static void channel_xmit_extended_xon(PLCI *plci);
|
|
|
|
static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type, dword info_mask, byte setupParse);
|
|
static word AdvCodecSupport(DIVA_CAPI_ADAPTER *, PLCI *, APPL *, byte);
|
|
static void CodecIdCheck(DIVA_CAPI_ADAPTER *, PLCI *);
|
|
static void SetVoiceChannel(PLCI *, byte *, DIVA_CAPI_ADAPTER *);
|
|
static void VoiceChannelOff(PLCI *plci);
|
|
static void adv_voice_write_coefs(PLCI *plci, word write_command);
|
|
static void adv_voice_clear_config(PLCI *plci);
|
|
|
|
static word get_b1_facilities(PLCI *plci, byte b1_resource);
|
|
static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities);
|
|
static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities);
|
|
static word adjust_b_process(dword Id, PLCI *plci, byte Rc);
|
|
static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command);
|
|
static void adjust_b_restore(dword Id, PLCI *plci, byte Rc);
|
|
static void reset_b3_command(dword Id, PLCI *plci, byte Rc);
|
|
static void select_b_command(dword Id, PLCI *plci, byte Rc);
|
|
static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc);
|
|
static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc);
|
|
static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc);
|
|
static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc);
|
|
static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc);
|
|
static void hold_save_command(dword Id, PLCI *plci, byte Rc);
|
|
static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc);
|
|
static void init_b1_config(PLCI *plci);
|
|
static void clear_b1_config(PLCI *plci);
|
|
|
|
static void dtmf_command(dword Id, PLCI *plci, byte Rc);
|
|
static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
|
|
static void dtmf_confirmation(dword Id, PLCI *plci);
|
|
static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length);
|
|
static void dtmf_parameter_write(PLCI *plci);
|
|
|
|
|
|
static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id);
|
|
static void mixer_set_bchannel_id(PLCI *plci, byte *chi);
|
|
static void mixer_clear_config(PLCI *plci);
|
|
static void mixer_notify_update(PLCI *plci, byte others);
|
|
static void mixer_command(dword Id, PLCI *plci, byte Rc);
|
|
static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
|
|
static void mixer_indication_coefs_set(dword Id, PLCI *plci);
|
|
static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length);
|
|
static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length);
|
|
static void mixer_remove(PLCI *plci);
|
|
|
|
|
|
static void ec_command(dword Id, PLCI *plci, byte Rc);
|
|
static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg);
|
|
static void ec_indication(dword Id, PLCI *plci, byte *msg, word length);
|
|
|
|
|
|
static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc);
|
|
static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc);
|
|
|
|
|
|
static int diva_get_dma_descriptor(PLCI *plci, dword *dma_magic);
|
|
static void diva_free_dma_descriptor(PLCI *plci, int nr);
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* external function prototypes */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
extern byte MapController(byte);
|
|
extern byte UnMapController(byte);
|
|
#define MapId(Id)(((Id) & 0xffffff00L) | MapController((byte)(Id)))
|
|
#define UnMapId(Id)(((Id) & 0xffffff00L) | UnMapController((byte)(Id)))
|
|
|
|
void sendf(APPL *, word, dword, word, byte *, ...);
|
|
void *TransmitBufferSet(APPL *appl, dword ref);
|
|
void *TransmitBufferGet(APPL *appl, void *p);
|
|
void TransmitBufferFree(APPL *appl, void *p);
|
|
void *ReceiveBufferGet(APPL *appl, int Num);
|
|
|
|
int fax_head_line_time(char *buffer);
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* Global data definitions */
|
|
/*------------------------------------------------------------------*/
|
|
extern byte max_adapter;
|
|
extern byte max_appl;
|
|
extern DIVA_CAPI_ADAPTER *adapter;
|
|
extern APPL *application;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static byte remove_started = false;
|
|
static PLCI dummy_plci;
|
|
|
|
|
|
static struct _ftable {
|
|
word command;
|
|
byte *format;
|
|
byte (*function)(dword, word, DIVA_CAPI_ADAPTER *, PLCI *, APPL *, API_PARSE *);
|
|
} ftable[] = {
|
|
{_DATA_B3_R, "dwww", data_b3_req},
|
|
{_DATA_B3_I | RESPONSE, "w", data_b3_res},
|
|
{_INFO_R, "ss", info_req},
|
|
{_INFO_I | RESPONSE, "", info_res},
|
|
{_CONNECT_R, "wsssssssss", connect_req},
|
|
{_CONNECT_I | RESPONSE, "wsssss", connect_res},
|
|
{_CONNECT_ACTIVE_I | RESPONSE, "", connect_a_res},
|
|
{_DISCONNECT_R, "s", disconnect_req},
|
|
{_DISCONNECT_I | RESPONSE, "", disconnect_res},
|
|
{_LISTEN_R, "dddss", listen_req},
|
|
{_ALERT_R, "s", alert_req},
|
|
{_FACILITY_R, "ws", facility_req},
|
|
{_FACILITY_I | RESPONSE, "ws", facility_res},
|
|
{_CONNECT_B3_R, "s", connect_b3_req},
|
|
{_CONNECT_B3_I | RESPONSE, "ws", connect_b3_res},
|
|
{_CONNECT_B3_ACTIVE_I | RESPONSE, "", connect_b3_a_res},
|
|
{_DISCONNECT_B3_R, "s", disconnect_b3_req},
|
|
{_DISCONNECT_B3_I | RESPONSE, "", disconnect_b3_res},
|
|
{_RESET_B3_R, "s", reset_b3_req},
|
|
{_RESET_B3_I | RESPONSE, "", reset_b3_res},
|
|
{_CONNECT_B3_T90_ACTIVE_I | RESPONSE, "ws", connect_b3_t90_a_res},
|
|
{_CONNECT_B3_T90_ACTIVE_I | RESPONSE, "", connect_b3_t90_a_res},
|
|
{_SELECT_B_REQ, "s", select_b_req},
|
|
{_MANUFACTURER_R, "dws", manufacturer_req},
|
|
{_MANUFACTURER_I | RESPONSE, "dws", manufacturer_res},
|
|
{_MANUFACTURER_I | RESPONSE, "", manufacturer_res}
|
|
};
|
|
|
|
static byte *cip_bc[29][2] = {
|
|
{ "", "" }, /* 0 */
|
|
{ "\x03\x80\x90\xa3", "\x03\x80\x90\xa2" }, /* 1 */
|
|
{ "\x02\x88\x90", "\x02\x88\x90" }, /* 2 */
|
|
{ "\x02\x89\x90", "\x02\x89\x90" }, /* 3 */
|
|
{ "\x03\x90\x90\xa3", "\x03\x90\x90\xa2" }, /* 4 */
|
|
{ "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 5 */
|
|
{ "\x02\x98\x90", "\x02\x98\x90" }, /* 6 */
|
|
{ "\x04\x88\xc0\xc6\xe6", "\x04\x88\xc0\xc6\xe6" }, /* 7 */
|
|
{ "\x04\x88\x90\x21\x8f", "\x04\x88\x90\x21\x8f" }, /* 8 */
|
|
{ "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 9 */
|
|
{ "", "" }, /* 10 */
|
|
{ "", "" }, /* 11 */
|
|
{ "", "" }, /* 12 */
|
|
{ "", "" }, /* 13 */
|
|
{ "", "" }, /* 14 */
|
|
{ "", "" }, /* 15 */
|
|
|
|
{ "\x03\x80\x90\xa3", "\x03\x80\x90\xa2" }, /* 16 */
|
|
{ "\x03\x90\x90\xa3", "\x03\x90\x90\xa2" }, /* 17 */
|
|
{ "\x02\x88\x90", "\x02\x88\x90" }, /* 18 */
|
|
{ "\x02\x88\x90", "\x02\x88\x90" }, /* 19 */
|
|
{ "\x02\x88\x90", "\x02\x88\x90" }, /* 20 */
|
|
{ "\x02\x88\x90", "\x02\x88\x90" }, /* 21 */
|
|
{ "\x02\x88\x90", "\x02\x88\x90" }, /* 22 */
|
|
{ "\x02\x88\x90", "\x02\x88\x90" }, /* 23 */
|
|
{ "\x02\x88\x90", "\x02\x88\x90" }, /* 24 */
|
|
{ "\x02\x88\x90", "\x02\x88\x90" }, /* 25 */
|
|
{ "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 26 */
|
|
{ "\x03\x91\x90\xa5", "\x03\x91\x90\xa5" }, /* 27 */
|
|
{ "\x02\x88\x90", "\x02\x88\x90" } /* 28 */
|
|
};
|
|
|
|
static byte *cip_hlc[29] = {
|
|
"", /* 0 */
|
|
"", /* 1 */
|
|
"", /* 2 */
|
|
"", /* 3 */
|
|
"", /* 4 */
|
|
"", /* 5 */
|
|
"", /* 6 */
|
|
"", /* 7 */
|
|
"", /* 8 */
|
|
"", /* 9 */
|
|
"", /* 10 */
|
|
"", /* 11 */
|
|
"", /* 12 */
|
|
"", /* 13 */
|
|
"", /* 14 */
|
|
"", /* 15 */
|
|
|
|
"\x02\x91\x81", /* 16 */
|
|
"\x02\x91\x84", /* 17 */
|
|
"\x02\x91\xa1", /* 18 */
|
|
"\x02\x91\xa4", /* 19 */
|
|
"\x02\x91\xa8", /* 20 */
|
|
"\x02\x91\xb1", /* 21 */
|
|
"\x02\x91\xb2", /* 22 */
|
|
"\x02\x91\xb5", /* 23 */
|
|
"\x02\x91\xb8", /* 24 */
|
|
"\x02\x91\xc1", /* 25 */
|
|
"\x02\x91\x81", /* 26 */
|
|
"\x03\x91\xe0\x01", /* 27 */
|
|
"\x03\x91\xe0\x02" /* 28 */
|
|
};
|
|
|
|
/*------------------------------------------------------------------*/
|
|
|
|
#define V120_HEADER_LENGTH 1
|
|
#define V120_HEADER_EXTEND_BIT 0x80
|
|
#define V120_HEADER_BREAK_BIT 0x40
|
|
#define V120_HEADER_C1_BIT 0x04
|
|
#define V120_HEADER_C2_BIT 0x08
|
|
#define V120_HEADER_FLUSH_COND (V120_HEADER_BREAK_BIT | V120_HEADER_C1_BIT | V120_HEADER_C2_BIT)
|
|
|
|
static byte v120_default_header[] =
|
|
{
|
|
|
|
0x83 /* Ext, BR , res, res, C2 , C1 , B , F */
|
|
|
|
};
|
|
|
|
static byte v120_break_header[] =
|
|
{
|
|
|
|
0xc3 | V120_HEADER_BREAK_BIT /* Ext, BR , res, res, C2 , C1 , B , F */
|
|
|
|
};
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* API_PUT function */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
word api_put(APPL *appl, CAPI_MSG *msg)
|
|
{
|
|
word i, j, k, l, n;
|
|
word ret;
|
|
byte c;
|
|
byte controller;
|
|
DIVA_CAPI_ADAPTER *a;
|
|
PLCI *plci;
|
|
NCCI *ncci_ptr;
|
|
word ncci;
|
|
CAPI_MSG *m;
|
|
API_PARSE msg_parms[MAX_MSG_PARMS + 1];
|
|
|
|
if (msg->header.length < sizeof(msg->header) ||
|
|
msg->header.length > MAX_MSG_SIZE) {
|
|
dbug(1, dprintf("bad len"));
|
|
return _BAD_MSG;
|
|
}
|
|
|
|
controller = (byte)((msg->header.controller & 0x7f) - 1);
|
|
|
|
/* controller starts with 0 up to (max_adapter - 1) */
|
|
if (controller >= max_adapter)
|
|
{
|
|
dbug(1, dprintf("invalid ctrl"));
|
|
return _BAD_MSG;
|
|
}
|
|
|
|
a = &adapter[controller];
|
|
plci = NULL;
|
|
if ((msg->header.plci != 0) && (msg->header.plci <= a->max_plci) && !a->adapter_disabled)
|
|
{
|
|
dbug(1, dprintf("plci=%x", msg->header.plci));
|
|
plci = &a->plci[msg->header.plci - 1];
|
|
ncci = GET_WORD(&msg->header.ncci);
|
|
if (plci->Id
|
|
&& (plci->appl
|
|
|| (plci->State == INC_CON_PENDING)
|
|
|| (plci->State == INC_CON_ALERT)
|
|
|| (msg->header.command == (_DISCONNECT_I | RESPONSE)))
|
|
&& ((ncci == 0)
|
|
|| (msg->header.command == (_DISCONNECT_B3_I | RESPONSE))
|
|
|| ((ncci < MAX_NCCI + 1) && (a->ncci_plci[ncci] == plci->Id))))
|
|
{
|
|
i = plci->msg_in_read_pos;
|
|
j = plci->msg_in_write_pos;
|
|
if (j >= i)
|
|
{
|
|
if (j + msg->header.length + MSG_IN_OVERHEAD <= MSG_IN_QUEUE_SIZE)
|
|
i += MSG_IN_QUEUE_SIZE - j;
|
|
else
|
|
j = 0;
|
|
}
|
|
else
|
|
{
|
|
|
|
n = (((CAPI_MSG *)(plci->msg_in_queue))->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc;
|
|
|
|
if (i > MSG_IN_QUEUE_SIZE - n)
|
|
i = MSG_IN_QUEUE_SIZE - n + 1;
|
|
i -= j;
|
|
}
|
|
|
|
if (i <= ((msg->header.length + MSG_IN_OVERHEAD + 3) & 0xfffc))
|
|
|
|
{
|
|
dbug(0, dprintf("Q-FULL1(msg) - len=%d write=%d read=%d wrap=%d free=%d",
|
|
msg->header.length, plci->msg_in_write_pos,
|
|
plci->msg_in_read_pos, plci->msg_in_wrap_pos, i));
|
|
|
|
return _QUEUE_FULL;
|
|
}
|
|
c = false;
|
|
if ((((byte *) msg) < ((byte *)(plci->msg_in_queue)))
|
|
|| (((byte *) msg) >= ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
|
|
{
|
|
if (plci->msg_in_write_pos != plci->msg_in_read_pos)
|
|
c = true;
|
|
}
|
|
if (msg->header.command == _DATA_B3_R)
|
|
{
|
|
if (msg->header.length < 20)
|
|
{
|
|
dbug(1, dprintf("DATA_B3 REQ wrong length %d", msg->header.length));
|
|
return _BAD_MSG;
|
|
}
|
|
ncci_ptr = &(a->ncci[ncci]);
|
|
n = ncci_ptr->data_pending;
|
|
l = ncci_ptr->data_ack_pending;
|
|
k = plci->msg_in_read_pos;
|
|
while (k != plci->msg_in_write_pos)
|
|
{
|
|
if (k == plci->msg_in_wrap_pos)
|
|
k = 0;
|
|
if ((((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.command == _DATA_B3_R)
|
|
&& (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.ncci == ncci))
|
|
{
|
|
n++;
|
|
if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->info.data_b3_req.Flags & 0x0004)
|
|
l++;
|
|
}
|
|
|
|
k += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[k]))->header.length +
|
|
MSG_IN_OVERHEAD + 3) & 0xfffc;
|
|
|
|
}
|
|
if ((n >= MAX_DATA_B3) || (l >= MAX_DATA_ACK))
|
|
{
|
|
dbug(0, dprintf("Q-FULL2(data) - pending=%d/%d ack_pending=%d/%d",
|
|
ncci_ptr->data_pending, n, ncci_ptr->data_ack_pending, l));
|
|
|
|
return _QUEUE_FULL;
|
|
}
|
|
if (plci->req_in || plci->internal_command)
|
|
{
|
|
if ((((byte *) msg) >= ((byte *)(plci->msg_in_queue)))
|
|
&& (((byte *) msg) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
|
|
{
|
|
dbug(0, dprintf("Q-FULL3(requeue)"));
|
|
|
|
return _QUEUE_FULL;
|
|
}
|
|
c = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (plci->req_in || plci->internal_command)
|
|
c = true;
|
|
else
|
|
{
|
|
plci->command = msg->header.command;
|
|
plci->number = msg->header.number;
|
|
}
|
|
}
|
|
if (c)
|
|
{
|
|
dbug(1, dprintf("enqueue msg(0x%04x,0x%x,0x%x) - len=%d write=%d read=%d wrap=%d free=%d",
|
|
msg->header.command, plci->req_in, plci->internal_command,
|
|
msg->header.length, plci->msg_in_write_pos,
|
|
plci->msg_in_read_pos, plci->msg_in_wrap_pos, i));
|
|
if (j == 0)
|
|
plci->msg_in_wrap_pos = plci->msg_in_write_pos;
|
|
m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]);
|
|
for (i = 0; i < msg->header.length; i++)
|
|
((byte *)(plci->msg_in_queue))[j++] = ((byte *) msg)[i];
|
|
if (m->header.command == _DATA_B3_R)
|
|
{
|
|
|
|
m->info.data_b3_req.Data = (dword)(long)(TransmitBufferSet(appl, m->info.data_b3_req.Data));
|
|
|
|
}
|
|
|
|
j = (j + 3) & 0xfffc;
|
|
|
|
*((APPL **)(&((byte *)(plci->msg_in_queue))[j])) = appl;
|
|
plci->msg_in_write_pos = j + MSG_IN_OVERHEAD;
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
plci = NULL;
|
|
}
|
|
}
|
|
dbug(1, dprintf("com=%x", msg->header.command));
|
|
|
|
for (j = 0; j < MAX_MSG_PARMS + 1; j++) msg_parms[j].length = 0;
|
|
for (i = 0, ret = _BAD_MSG; i < ARRAY_SIZE(ftable); i++) {
|
|
|
|
if (ftable[i].command == msg->header.command) {
|
|
/* break loop if the message is correct, otherwise continue scan */
|
|
/* (for example: CONNECT_B3_T90_ACT_RES has two specifications) */
|
|
if (!api_parse(msg->info.b, (word)(msg->header.length - 12), ftable[i].format, msg_parms)) {
|
|
ret = 0;
|
|
break;
|
|
}
|
|
for (j = 0; j < MAX_MSG_PARMS + 1; j++) msg_parms[j].length = 0;
|
|
}
|
|
}
|
|
if (ret) {
|
|
dbug(1, dprintf("BAD_MSG"));
|
|
if (plci) plci->command = 0;
|
|
return ret;
|
|
}
|
|
|
|
|
|
c = ftable[i].function(GET_DWORD(&msg->header.controller),
|
|
msg->header.number,
|
|
a,
|
|
plci,
|
|
appl,
|
|
msg_parms);
|
|
|
|
channel_xmit_extended_xon(plci);
|
|
|
|
if (c == 1) send_req(plci);
|
|
if (c == 2 && plci) plci->req_in = plci->req_in_start = plci->req_out = 0;
|
|
if (plci && !plci->req_in) plci->command = 0;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* api_parse function, check the format of api messages */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static word api_parse(byte *msg, word length, byte *format, API_PARSE *parms)
|
|
{
|
|
word i;
|
|
word p;
|
|
|
|
for (i = 0, p = 0; format[i]; i++) {
|
|
if (parms)
|
|
{
|
|
parms[i].info = &msg[p];
|
|
}
|
|
switch (format[i]) {
|
|
case 'b':
|
|
p += 1;
|
|
break;
|
|
case 'w':
|
|
p += 2;
|
|
break;
|
|
case 'd':
|
|
p += 4;
|
|
break;
|
|
case 's':
|
|
if (msg[p] == 0xff) {
|
|
parms[i].info += 2;
|
|
parms[i].length = msg[p + 1] + (msg[p + 2] << 8);
|
|
p += (parms[i].length + 3);
|
|
}
|
|
else {
|
|
parms[i].length = msg[p];
|
|
p += (parms[i].length + 1);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (p > length) return true;
|
|
}
|
|
if (parms) parms[i].info = NULL;
|
|
return false;
|
|
}
|
|
|
|
static void api_save_msg(API_PARSE *in, byte *format, API_SAVE *out)
|
|
{
|
|
word i, j, n = 0;
|
|
byte *p;
|
|
|
|
p = out->info;
|
|
for (i = 0; format[i] != '\0'; i++)
|
|
{
|
|
out->parms[i].info = p;
|
|
out->parms[i].length = in[i].length;
|
|
switch (format[i])
|
|
{
|
|
case 'b':
|
|
n = 1;
|
|
break;
|
|
case 'w':
|
|
n = 2;
|
|
break;
|
|
case 'd':
|
|
n = 4;
|
|
break;
|
|
case 's':
|
|
n = in[i].length + 1;
|
|
break;
|
|
}
|
|
for (j = 0; j < n; j++)
|
|
*(p++) = in[i].info[j];
|
|
}
|
|
out->parms[i].info = NULL;
|
|
out->parms[i].length = 0;
|
|
}
|
|
|
|
static void api_load_msg(API_SAVE *in, API_PARSE *out)
|
|
{
|
|
word i;
|
|
|
|
i = 0;
|
|
do
|
|
{
|
|
out[i].info = in->parms[i].info;
|
|
out[i].length = in->parms[i].length;
|
|
} while (in->parms[i++].info);
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* CAPI remove function */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
word api_remove_start(void)
|
|
{
|
|
word i;
|
|
word j;
|
|
|
|
if (!remove_started) {
|
|
remove_started = true;
|
|
for (i = 0; i < max_adapter; i++) {
|
|
if (adapter[i].request) {
|
|
for (j = 0; j < adapter[i].max_plci; j++) {
|
|
if (adapter[i].plci[j].Sig.Id) plci_remove(&adapter[i].plci[j]);
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
else {
|
|
for (i = 0; i < max_adapter; i++) {
|
|
if (adapter[i].request) {
|
|
for (j = 0; j < adapter[i].max_plci; j++) {
|
|
if (adapter[i].plci[j].Sig.Id) return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
api_remove_complete();
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* internal command queue */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void init_internal_command_queue(PLCI *plci)
|
|
{
|
|
word i;
|
|
|
|
dbug(1, dprintf("%s,%d: init_internal_command_queue",
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
plci->internal_command = 0;
|
|
for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS; i++)
|
|
plci->internal_command_queue[i] = NULL;
|
|
}
|
|
|
|
|
|
static void start_internal_command(dword Id, PLCI *plci, t_std_internal_command command_function)
|
|
{
|
|
word i;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: start_internal_command",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
if (plci->internal_command == 0)
|
|
{
|
|
plci->internal_command_queue[0] = command_function;
|
|
(*command_function)(Id, plci, OK);
|
|
}
|
|
else
|
|
{
|
|
i = 1;
|
|
while (plci->internal_command_queue[i] != NULL)
|
|
i++;
|
|
plci->internal_command_queue[i] = command_function;
|
|
}
|
|
}
|
|
|
|
|
|
static void next_internal_command(dword Id, PLCI *plci)
|
|
{
|
|
word i;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: next_internal_command",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
plci->internal_command = 0;
|
|
plci->internal_command_queue[0] = NULL;
|
|
while (plci->internal_command_queue[1] != NULL)
|
|
{
|
|
for (i = 0; i < MAX_INTERNAL_COMMAND_LEVELS - 1; i++)
|
|
plci->internal_command_queue[i] = plci->internal_command_queue[i + 1];
|
|
plci->internal_command_queue[MAX_INTERNAL_COMMAND_LEVELS - 1] = NULL;
|
|
(*(plci->internal_command_queue[0]))(Id, plci, OK);
|
|
if (plci->internal_command != 0)
|
|
return;
|
|
plci->internal_command_queue[0] = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* NCCI allocate/remove function */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static dword ncci_mapping_bug = 0;
|
|
|
|
static word get_ncci(PLCI *plci, byte ch, word force_ncci)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word ncci, i, j, k;
|
|
|
|
a = plci->adapter;
|
|
if (!ch || a->ch_ncci[ch])
|
|
{
|
|
ncci_mapping_bug++;
|
|
dbug(1, dprintf("NCCI mapping exists %ld %02x %02x %02x-%02x",
|
|
ncci_mapping_bug, ch, force_ncci, a->ncci_ch[a->ch_ncci[ch]], a->ch_ncci[ch]));
|
|
ncci = ch;
|
|
}
|
|
else
|
|
{
|
|
if (force_ncci)
|
|
ncci = force_ncci;
|
|
else
|
|
{
|
|
if ((ch < MAX_NCCI + 1) && !a->ncci_ch[ch])
|
|
ncci = ch;
|
|
else
|
|
{
|
|
ncci = 1;
|
|
while ((ncci < MAX_NCCI + 1) && a->ncci_ch[ncci])
|
|
ncci++;
|
|
if (ncci == MAX_NCCI + 1)
|
|
{
|
|
ncci_mapping_bug++;
|
|
i = 1;
|
|
do
|
|
{
|
|
j = 1;
|
|
while ((j < MAX_NCCI + 1) && (a->ncci_ch[j] != i))
|
|
j++;
|
|
k = j;
|
|
if (j < MAX_NCCI + 1)
|
|
{
|
|
do
|
|
{
|
|
j++;
|
|
} while ((j < MAX_NCCI + 1) && (a->ncci_ch[j] != i));
|
|
}
|
|
} while ((i < MAX_NL_CHANNEL + 1) && (j < MAX_NCCI + 1));
|
|
if (i < MAX_NL_CHANNEL + 1)
|
|
{
|
|
dbug(1, dprintf("NCCI mapping overflow %ld %02x %02x %02x-%02x-%02x",
|
|
ncci_mapping_bug, ch, force_ncci, i, k, j));
|
|
}
|
|
else
|
|
{
|
|
dbug(1, dprintf("NCCI mapping overflow %ld %02x %02x",
|
|
ncci_mapping_bug, ch, force_ncci));
|
|
}
|
|
ncci = ch;
|
|
}
|
|
}
|
|
a->ncci_plci[ncci] = plci->Id;
|
|
a->ncci_state[ncci] = IDLE;
|
|
if (!plci->ncci_ring_list)
|
|
plci->ncci_ring_list = ncci;
|
|
else
|
|
a->ncci_next[ncci] = a->ncci_next[plci->ncci_ring_list];
|
|
a->ncci_next[plci->ncci_ring_list] = (byte) ncci;
|
|
}
|
|
a->ncci_ch[ncci] = ch;
|
|
a->ch_ncci[ch] = (byte) ncci;
|
|
dbug(1, dprintf("NCCI mapping established %ld %02x %02x %02x-%02x",
|
|
ncci_mapping_bug, ch, force_ncci, ch, ncci));
|
|
}
|
|
return (ncci);
|
|
}
|
|
|
|
|
|
static void ncci_free_receive_buffers(PLCI *plci, word ncci)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
APPL *appl;
|
|
word i, ncci_code;
|
|
dword Id;
|
|
|
|
a = plci->adapter;
|
|
Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
|
|
if (ncci)
|
|
{
|
|
if (a->ncci_plci[ncci] == plci->Id)
|
|
{
|
|
if (!plci->appl)
|
|
{
|
|
ncci_mapping_bug++;
|
|
dbug(1, dprintf("NCCI mapping appl expected %ld %08lx",
|
|
ncci_mapping_bug, Id));
|
|
}
|
|
else
|
|
{
|
|
appl = plci->appl;
|
|
ncci_code = ncci | (((word) a->Id) << 8);
|
|
for (i = 0; i < appl->MaxBuffer; i++)
|
|
{
|
|
if ((appl->DataNCCI[i] == ncci_code)
|
|
&& (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
|
|
{
|
|
appl->DataNCCI[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
|
|
{
|
|
if (a->ncci_plci[ncci] == plci->Id)
|
|
{
|
|
if (!plci->appl)
|
|
{
|
|
ncci_mapping_bug++;
|
|
dbug(1, dprintf("NCCI mapping no appl %ld %08lx",
|
|
ncci_mapping_bug, Id));
|
|
}
|
|
else
|
|
{
|
|
appl = plci->appl;
|
|
ncci_code = ncci | (((word) a->Id) << 8);
|
|
for (i = 0; i < appl->MaxBuffer; i++)
|
|
{
|
|
if ((appl->DataNCCI[i] == ncci_code)
|
|
&& (((byte)(appl->DataFlags[i] >> 8)) == plci->Id))
|
|
{
|
|
appl->DataNCCI[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void cleanup_ncci_data(PLCI *plci, word ncci)
|
|
{
|
|
NCCI *ncci_ptr;
|
|
|
|
if (ncci && (plci->adapter->ncci_plci[ncci] == plci->Id))
|
|
{
|
|
ncci_ptr = &(plci->adapter->ncci[ncci]);
|
|
if (plci->appl)
|
|
{
|
|
while (ncci_ptr->data_pending != 0)
|
|
{
|
|
if (!plci->data_sent || (ncci_ptr->DBuffer[ncci_ptr->data_out].P != plci->data_sent_ptr))
|
|
TransmitBufferFree(plci->appl, ncci_ptr->DBuffer[ncci_ptr->data_out].P);
|
|
(ncci_ptr->data_out)++;
|
|
if (ncci_ptr->data_out == MAX_DATA_B3)
|
|
ncci_ptr->data_out = 0;
|
|
(ncci_ptr->data_pending)--;
|
|
}
|
|
}
|
|
ncci_ptr->data_out = 0;
|
|
ncci_ptr->data_pending = 0;
|
|
ncci_ptr->data_ack_out = 0;
|
|
ncci_ptr->data_ack_pending = 0;
|
|
}
|
|
}
|
|
|
|
|
|
static void ncci_remove(PLCI *plci, word ncci, byte preserve_ncci)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
dword Id;
|
|
word i;
|
|
|
|
a = plci->adapter;
|
|
Id = (((dword) ncci) << 16) | (((word)(plci->Id)) << 8) | a->Id;
|
|
if (!preserve_ncci)
|
|
ncci_free_receive_buffers(plci, ncci);
|
|
if (ncci)
|
|
{
|
|
if (a->ncci_plci[ncci] != plci->Id)
|
|
{
|
|
ncci_mapping_bug++;
|
|
dbug(1, dprintf("NCCI mapping doesn't exist %ld %08lx %02x",
|
|
ncci_mapping_bug, Id, preserve_ncci));
|
|
}
|
|
else
|
|
{
|
|
cleanup_ncci_data(plci, ncci);
|
|
dbug(1, dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
|
|
ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
|
|
a->ch_ncci[a->ncci_ch[ncci]] = 0;
|
|
if (!preserve_ncci)
|
|
{
|
|
a->ncci_ch[ncci] = 0;
|
|
a->ncci_plci[ncci] = 0;
|
|
a->ncci_state[ncci] = IDLE;
|
|
i = plci->ncci_ring_list;
|
|
while ((i != 0) && (a->ncci_next[i] != plci->ncci_ring_list) && (a->ncci_next[i] != ncci))
|
|
i = a->ncci_next[i];
|
|
if ((i != 0) && (a->ncci_next[i] == ncci))
|
|
{
|
|
if (i == ncci)
|
|
plci->ncci_ring_list = 0;
|
|
else if (plci->ncci_ring_list == ncci)
|
|
plci->ncci_ring_list = i;
|
|
a->ncci_next[i] = a->ncci_next[ncci];
|
|
}
|
|
a->ncci_next[ncci] = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
|
|
{
|
|
if (a->ncci_plci[ncci] == plci->Id)
|
|
{
|
|
cleanup_ncci_data(plci, ncci);
|
|
dbug(1, dprintf("NCCI mapping released %ld %08lx %02x %02x-%02x",
|
|
ncci_mapping_bug, Id, preserve_ncci, a->ncci_ch[ncci], ncci));
|
|
a->ch_ncci[a->ncci_ch[ncci]] = 0;
|
|
if (!preserve_ncci)
|
|
{
|
|
a->ncci_ch[ncci] = 0;
|
|
a->ncci_plci[ncci] = 0;
|
|
a->ncci_state[ncci] = IDLE;
|
|
a->ncci_next[ncci] = 0;
|
|
}
|
|
}
|
|
}
|
|
if (!preserve_ncci)
|
|
plci->ncci_ring_list = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* PLCI remove function */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void plci_free_msg_in_queue(PLCI *plci)
|
|
{
|
|
word i;
|
|
|
|
if (plci->appl)
|
|
{
|
|
i = plci->msg_in_read_pos;
|
|
while (i != plci->msg_in_write_pos)
|
|
{
|
|
if (i == plci->msg_in_wrap_pos)
|
|
i = 0;
|
|
if (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.command == _DATA_B3_R)
|
|
{
|
|
|
|
TransmitBufferFree(plci->appl,
|
|
(byte *)(long)(((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->info.data_b3_req.Data));
|
|
|
|
}
|
|
|
|
i += (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[i]))->header.length +
|
|
MSG_IN_OVERHEAD + 3) & 0xfffc;
|
|
|
|
}
|
|
}
|
|
plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
|
|
plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
|
|
plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
|
|
}
|
|
|
|
|
|
static void plci_remove(PLCI *plci)
|
|
{
|
|
|
|
if (!plci) {
|
|
dbug(1, dprintf("plci_remove(no plci)"));
|
|
return;
|
|
}
|
|
init_internal_command_queue(plci);
|
|
dbug(1, dprintf("plci_remove(%x,tel=%x)", plci->Id, plci->tel));
|
|
if (plci_remove_check(plci))
|
|
{
|
|
return;
|
|
}
|
|
if (plci->Sig.Id == 0xff)
|
|
{
|
|
dbug(1, dprintf("D-channel X.25 plci->NL.Id:%0x", plci->NL.Id));
|
|
if (plci->NL.Id && !plci->nl_remove_id)
|
|
{
|
|
nl_req_ncci(plci, REMOVE, 0);
|
|
send_req(plci);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!plci->sig_remove_id
|
|
&& (plci->Sig.Id
|
|
|| (plci->req_in != plci->req_out)
|
|
|| (plci->nl_req || plci->sig_req)))
|
|
{
|
|
sig_req(plci, HANGUP, 0);
|
|
send_req(plci);
|
|
}
|
|
}
|
|
ncci_remove(plci, 0, false);
|
|
plci_free_msg_in_queue(plci);
|
|
|
|
plci->channels = 0;
|
|
plci->appl = NULL;
|
|
if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT))
|
|
plci->State = OUTG_DIS_PENDING;
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* Application Group function helpers */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void set_group_ind_mask(PLCI *plci)
|
|
{
|
|
word i;
|
|
|
|
for (i = 0; i < C_IND_MASK_DWORDS; i++)
|
|
plci->group_optimization_mask_table[i] = 0xffffffffL;
|
|
}
|
|
|
|
static void clear_group_ind_mask_bit(PLCI *plci, word b)
|
|
{
|
|
plci->group_optimization_mask_table[b >> 5] &= ~(1L << (b & 0x1f));
|
|
}
|
|
|
|
static byte test_group_ind_mask_bit(PLCI *plci, word b)
|
|
{
|
|
return ((plci->group_optimization_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0);
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* c_ind_mask operations for arbitrary MAX_APPL */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void clear_c_ind_mask(PLCI *plci)
|
|
{
|
|
word i;
|
|
|
|
for (i = 0; i < C_IND_MASK_DWORDS; i++)
|
|
plci->c_ind_mask_table[i] = 0;
|
|
}
|
|
|
|
static byte c_ind_mask_empty(PLCI *plci)
|
|
{
|
|
word i;
|
|
|
|
i = 0;
|
|
while ((i < C_IND_MASK_DWORDS) && (plci->c_ind_mask_table[i] == 0))
|
|
i++;
|
|
return (i == C_IND_MASK_DWORDS);
|
|
}
|
|
|
|
static void set_c_ind_mask_bit(PLCI *plci, word b)
|
|
{
|
|
plci->c_ind_mask_table[b >> 5] |= (1L << (b & 0x1f));
|
|
}
|
|
|
|
static void clear_c_ind_mask_bit(PLCI *plci, word b)
|
|
{
|
|
plci->c_ind_mask_table[b >> 5] &= ~(1L << (b & 0x1f));
|
|
}
|
|
|
|
static byte test_c_ind_mask_bit(PLCI *plci, word b)
|
|
{
|
|
return ((plci->c_ind_mask_table[b >> 5] & (1L << (b & 0x1f))) != 0);
|
|
}
|
|
|
|
static void dump_c_ind_mask(PLCI *plci)
|
|
{
|
|
static char hex_digit_table[0x10] =
|
|
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
|
|
word i, j, k;
|
|
dword d;
|
|
char *p;
|
|
char buf[40];
|
|
|
|
for (i = 0; i < C_IND_MASK_DWORDS; i += 4)
|
|
{
|
|
p = buf + 36;
|
|
*p = '\0';
|
|
for (j = 0; j < 4; j++)
|
|
{
|
|
if (i + j < C_IND_MASK_DWORDS)
|
|
{
|
|
d = plci->c_ind_mask_table[i + j];
|
|
for (k = 0; k < 8; k++)
|
|
{
|
|
*(--p) = hex_digit_table[d & 0xf];
|
|
d >>= 4;
|
|
}
|
|
}
|
|
else if (i != 0)
|
|
{
|
|
for (k = 0; k < 8; k++)
|
|
*(--p) = ' ';
|
|
}
|
|
*(--p) = ' ';
|
|
}
|
|
dbug(1, dprintf("c_ind_mask =%s", (char *) p));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#define dump_plcis(a)
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* translation function for each message */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static byte connect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word ch;
|
|
word i;
|
|
word Info;
|
|
byte LinkLayer;
|
|
API_PARSE *ai;
|
|
API_PARSE *bp;
|
|
API_PARSE ai_parms[5];
|
|
word channel = 0;
|
|
dword ch_mask;
|
|
byte m;
|
|
static byte esc_chi[35] = {0x02, 0x18, 0x01};
|
|
static byte lli[2] = {0x01, 0x00};
|
|
byte noCh = 0;
|
|
word dir = 0;
|
|
byte *p_chi = "";
|
|
|
|
for (i = 0; i < 5; i++) ai_parms[i].length = 0;
|
|
|
|
dbug(1, dprintf("connect_req(%d)", parms->length));
|
|
Info = _WRONG_IDENTIFIER;
|
|
if (a)
|
|
{
|
|
if (a->adapter_disabled)
|
|
{
|
|
dbug(1, dprintf("adapter disabled"));
|
|
Id = ((word)1 << 8) | a->Id;
|
|
sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
|
|
sendf(appl, _DISCONNECT_I, Id, 0, "w", _L1_ERROR);
|
|
return false;
|
|
}
|
|
Info = _OUT_OF_PLCI;
|
|
if ((i = get_plci(a)))
|
|
{
|
|
Info = 0;
|
|
plci = &a->plci[i - 1];
|
|
plci->appl = appl;
|
|
plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
|
|
/* check 'external controller' bit for codec support */
|
|
if (Id & EXT_CONTROLLER)
|
|
{
|
|
if (AdvCodecSupport(a, plci, appl, 0))
|
|
{
|
|
plci->Id = 0;
|
|
sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
|
|
return 2;
|
|
}
|
|
}
|
|
ai = &parms[9];
|
|
bp = &parms[5];
|
|
ch = 0;
|
|
if (bp->length)LinkLayer = bp->info[3];
|
|
else LinkLayer = 0;
|
|
if (ai->length)
|
|
{
|
|
ch = 0xffff;
|
|
if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
|
|
{
|
|
ch = 0;
|
|
if (ai_parms[0].length)
|
|
{
|
|
ch = GET_WORD(ai_parms[0].info + 1);
|
|
if (ch > 4) ch = 0; /* safety -> ignore ChannelID */
|
|
if (ch == 4) /* explizit CHI in message */
|
|
{
|
|
/* check length of B-CH struct */
|
|
if ((ai_parms[0].info)[3] >= 1)
|
|
{
|
|
if ((ai_parms[0].info)[4] == CHI)
|
|
{
|
|
p_chi = &((ai_parms[0].info)[5]);
|
|
}
|
|
else
|
|
{
|
|
p_chi = &((ai_parms[0].info)[3]);
|
|
}
|
|
if (p_chi[0] > 35) /* check length of channel ID */
|
|
{
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
}
|
|
else Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
|
|
if (ch == 3 && ai_parms[0].length >= 7 && ai_parms[0].length <= 36)
|
|
{
|
|
dir = GET_WORD(ai_parms[0].info + 3);
|
|
ch_mask = 0;
|
|
m = 0x3f;
|
|
for (i = 0; i + 5 <= ai_parms[0].length; i++)
|
|
{
|
|
if (ai_parms[0].info[i + 5] != 0)
|
|
{
|
|
if ((ai_parms[0].info[i + 5] | m) != 0xff)
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
else
|
|
{
|
|
if (ch_mask == 0)
|
|
channel = i;
|
|
ch_mask |= 1L << i;
|
|
}
|
|
}
|
|
m = 0;
|
|
}
|
|
if (ch_mask == 0)
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
if (!Info)
|
|
{
|
|
if ((ai_parms[0].length == 36) || (ch_mask != ((dword)(1L << channel))))
|
|
{
|
|
esc_chi[0] = (byte)(ai_parms[0].length - 2);
|
|
for (i = 0; i + 5 <= ai_parms[0].length; i++)
|
|
esc_chi[i + 3] = ai_parms[0].info[i + 5];
|
|
}
|
|
else
|
|
esc_chi[0] = 2;
|
|
esc_chi[2] = (byte)channel;
|
|
plci->b_channel = (byte)channel; /* not correct for ETSI ch 17..31 */
|
|
add_p(plci, LLI, lli);
|
|
add_p(plci, ESC, esc_chi);
|
|
plci->State = LOCAL_CONNECT;
|
|
if (!dir) plci->call_dir |= CALL_DIR_FORCE_OUTG_NL; /* dir 0=DTE, 1=DCE */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
|
|
dbug(1, dprintf("ch=%x,dir=%x,p_ch=%d", ch, dir, channel));
|
|
plci->command = _CONNECT_R;
|
|
plci->number = Number;
|
|
/* x.31 or D-ch free SAPI in LinkLayer? */
|
|
if (ch == 1 && LinkLayer != 3 && LinkLayer != 12) noCh = true;
|
|
if ((ch == 0 || ch == 2 || noCh || ch == 3 || ch == 4) && !Info)
|
|
{
|
|
/* B-channel used for B3 connections (ch==0), or no B channel */
|
|
/* is used (ch==2) or perm. connection (3) is used do a CALL */
|
|
if (noCh) Info = add_b1(plci, &parms[5], 2, 0); /* no resource */
|
|
else Info = add_b1(plci, &parms[5], ch, 0);
|
|
add_s(plci, OAD, &parms[2]);
|
|
add_s(plci, OSA, &parms[4]);
|
|
add_s(plci, BC, &parms[6]);
|
|
add_s(plci, LLC, &parms[7]);
|
|
add_s(plci, HLC, &parms[8]);
|
|
if (a->Info_Mask[appl->Id - 1] & 0x200)
|
|
{
|
|
/* early B3 connect (CIP mask bit 9) no release after a disc */
|
|
add_p(plci, LLI, "\x01\x01");
|
|
}
|
|
if (GET_WORD(parms[0].info) < 29) {
|
|
add_p(plci, BC, cip_bc[GET_WORD(parms[0].info)][a->u_law]);
|
|
add_p(plci, HLC, cip_hlc[GET_WORD(parms[0].info)]);
|
|
}
|
|
add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(plci, ASSIGN, DSIG_ID);
|
|
}
|
|
else if (ch == 1) {
|
|
|
|
/* D-Channel used for B3 connections */
|
|
plci->Sig.Id = 0xff;
|
|
Info = 0;
|
|
}
|
|
|
|
if (!Info && ch != 2 && !noCh) {
|
|
Info = add_b23(plci, &parms[5]);
|
|
if (!Info) {
|
|
if (!(plci->tel && !plci->adv_nl))nl_req_ncci(plci, ASSIGN, 0);
|
|
}
|
|
}
|
|
|
|
if (!Info)
|
|
{
|
|
if (ch == 0 || ch == 2 || ch == 3 || noCh || ch == 4)
|
|
{
|
|
if (plci->spoofed_msg == SPOOFING_REQUIRED)
|
|
{
|
|
api_save_msg(parms, "wsssssssss", &plci->saved_msg);
|
|
plci->spoofed_msg = CALL_REQ;
|
|
plci->internal_command = BLOCK_PLCI;
|
|
plci->command = 0;
|
|
dbug(1, dprintf("Spoof"));
|
|
send_req(plci);
|
|
return false;
|
|
}
|
|
if (ch == 4)add_p(plci, CHI, p_chi);
|
|
add_s(plci, CPN, &parms[1]);
|
|
add_s(plci, DSA, &parms[3]);
|
|
if (noCh) add_p(plci, ESC, "\x02\x18\xfd"); /* D-channel, no B-L3 */
|
|
add_ai(plci, &parms[9]);
|
|
if (!dir)sig_req(plci, CALL_REQ, 0);
|
|
else
|
|
{
|
|
plci->command = PERM_LIST_REQ;
|
|
plci->appl = appl;
|
|
sig_req(plci, LISTEN_REQ, 0);
|
|
send_req(plci);
|
|
return false;
|
|
}
|
|
}
|
|
send_req(plci);
|
|
return false;
|
|
}
|
|
plci->Id = 0;
|
|
}
|
|
}
|
|
sendf(appl,
|
|
_CONNECT_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"w", Info);
|
|
return 2;
|
|
}
|
|
|
|
static byte connect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word i, Info;
|
|
word Reject;
|
|
static byte cau_t[] = {0, 0, 0x90, 0x91, 0xac, 0x9d, 0x86, 0xd8, 0x9b};
|
|
static byte esc_t[] = {0x03, 0x08, 0x00, 0x00};
|
|
API_PARSE *ai;
|
|
API_PARSE ai_parms[5];
|
|
word ch = 0;
|
|
|
|
if (!plci) {
|
|
dbug(1, dprintf("connect_res(no plci)"));
|
|
return 0; /* no plci, no send */
|
|
}
|
|
|
|
dbug(1, dprintf("connect_res(State=0x%x)", plci->State));
|
|
for (i = 0; i < 5; i++) ai_parms[i].length = 0;
|
|
ai = &parms[5];
|
|
dbug(1, dprintf("ai->length=%d", ai->length));
|
|
|
|
if (ai->length)
|
|
{
|
|
if (!api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
|
|
{
|
|
dbug(1, dprintf("ai_parms[0].length=%d/0x%x", ai_parms[0].length, GET_WORD(ai_parms[0].info + 1)));
|
|
ch = 0;
|
|
if (ai_parms[0].length)
|
|
{
|
|
ch = GET_WORD(ai_parms[0].info + 1);
|
|
dbug(1, dprintf("BCH-I=0x%x", ch));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (plci->State == INC_CON_CONNECTED_ALERT)
|
|
{
|
|
dbug(1, dprintf("Connected Alert Call_Res"));
|
|
if (a->Info_Mask[appl->Id - 1] & 0x200)
|
|
{
|
|
/* early B3 connect (CIP mask bit 9) no release after a disc */
|
|
add_p(plci, LLI, "\x01\x01");
|
|
}
|
|
add_s(plci, CONN_NR, &parms[2]);
|
|
add_s(plci, LLC, &parms[4]);
|
|
add_ai(plci, &parms[5]);
|
|
plci->State = INC_CON_ACCEPT;
|
|
sig_req(plci, CALL_RES, 0);
|
|
return 1;
|
|
}
|
|
else if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT) {
|
|
clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
|
|
dump_c_ind_mask(plci);
|
|
Reject = GET_WORD(parms[0].info);
|
|
dbug(1, dprintf("Reject=0x%x", Reject));
|
|
if (Reject)
|
|
{
|
|
if (c_ind_mask_empty(plci))
|
|
{
|
|
if ((Reject & 0xff00) == 0x3400)
|
|
{
|
|
esc_t[2] = ((byte)(Reject & 0x00ff)) | 0x80;
|
|
add_p(plci, ESC, esc_t);
|
|
add_ai(plci, &parms[5]);
|
|
sig_req(plci, REJECT, 0);
|
|
}
|
|
else if (Reject == 1 || Reject > 9)
|
|
{
|
|
add_ai(plci, &parms[5]);
|
|
sig_req(plci, HANGUP, 0);
|
|
}
|
|
else
|
|
{
|
|
esc_t[2] = cau_t[(Reject&0x000f)];
|
|
add_p(plci, ESC, esc_t);
|
|
add_ai(plci, &parms[5]);
|
|
sig_req(plci, REJECT, 0);
|
|
}
|
|
plci->appl = appl;
|
|
}
|
|
else
|
|
{
|
|
sendf(appl, _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
|
|
}
|
|
}
|
|
else {
|
|
plci->appl = appl;
|
|
if (Id & EXT_CONTROLLER) {
|
|
if (AdvCodecSupport(a, plci, appl, 0)) {
|
|
dbug(1, dprintf("connect_res(error from AdvCodecSupport)"));
|
|
sig_req(plci, HANGUP, 0);
|
|
return 1;
|
|
}
|
|
if (plci->tel == ADV_VOICE && a->AdvCodecPLCI)
|
|
{
|
|
Info = add_b23(plci, &parms[1]);
|
|
if (Info)
|
|
{
|
|
dbug(1, dprintf("connect_res(error from add_b23)"));
|
|
sig_req(plci, HANGUP, 0);
|
|
return 1;
|
|
}
|
|
if (plci->adv_nl)
|
|
{
|
|
nl_req_ncci(plci, ASSIGN, 0);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
plci->tel = 0;
|
|
if (ch != 2)
|
|
{
|
|
Info = add_b23(plci, &parms[1]);
|
|
if (Info)
|
|
{
|
|
dbug(1, dprintf("connect_res(error from add_b23 2)"));
|
|
sig_req(plci, HANGUP, 0);
|
|
return 1;
|
|
}
|
|
}
|
|
nl_req_ncci(plci, ASSIGN, 0);
|
|
}
|
|
|
|
if (plci->spoofed_msg == SPOOFING_REQUIRED)
|
|
{
|
|
api_save_msg(parms, "wsssss", &plci->saved_msg);
|
|
plci->spoofed_msg = CALL_RES;
|
|
plci->internal_command = BLOCK_PLCI;
|
|
plci->command = 0;
|
|
dbug(1, dprintf("Spoof"));
|
|
}
|
|
else
|
|
{
|
|
add_b1(plci, &parms[1], ch, plci->B1_facilities);
|
|
if (a->Info_Mask[appl->Id - 1] & 0x200)
|
|
{
|
|
/* early B3 connect (CIP mask bit 9) no release after a disc */
|
|
add_p(plci, LLI, "\x01\x01");
|
|
}
|
|
add_s(plci, CONN_NR, &parms[2]);
|
|
add_s(plci, LLC, &parms[4]);
|
|
add_ai(plci, &parms[5]);
|
|
plci->State = INC_CON_ACCEPT;
|
|
sig_req(plci, CALL_RES, 0);
|
|
}
|
|
|
|
for (i = 0; i < max_appl; i++) {
|
|
if (test_c_ind_mask_bit(plci, i)) {
|
|
sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static byte connect_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
dbug(1, dprintf("connect_a_res"));
|
|
return false;
|
|
}
|
|
|
|
static byte disconnect_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
word Info;
|
|
word i;
|
|
|
|
dbug(1, dprintf("disconnect_req"));
|
|
|
|
Info = _WRONG_IDENTIFIER;
|
|
|
|
if (plci)
|
|
{
|
|
if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT)
|
|
{
|
|
clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
|
|
plci->appl = appl;
|
|
for (i = 0; i < max_appl; i++)
|
|
{
|
|
if (test_c_ind_mask_bit(plci, i))
|
|
sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
|
|
}
|
|
plci->State = OUTG_DIS_PENDING;
|
|
}
|
|
if (plci->Sig.Id && plci->appl)
|
|
{
|
|
Info = 0;
|
|
if (plci->Sig.Id != 0xff)
|
|
{
|
|
if (plci->State != INC_DIS_PENDING)
|
|
{
|
|
add_ai(plci, &msg[0]);
|
|
sig_req(plci, HANGUP, 0);
|
|
plci->State = OUTG_DIS_PENDING;
|
|
return 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (plci->NL.Id && !plci->nl_remove_id)
|
|
{
|
|
mixer_remove(plci);
|
|
nl_req_ncci(plci, REMOVE, 0);
|
|
sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0);
|
|
sendf(appl, _DISCONNECT_I, Id, 0, "w", 0);
|
|
plci->State = INC_DIS_PENDING;
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!appl) return false;
|
|
sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", Info);
|
|
return false;
|
|
}
|
|
|
|
static byte disconnect_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
dbug(1, dprintf("disconnect_res"));
|
|
if (plci)
|
|
{
|
|
/* clear ind mask bit, just in case of collsion of */
|
|
/* DISCONNECT_IND and CONNECT_RES */
|
|
clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
|
|
ncci_free_receive_buffers(plci, 0);
|
|
if (plci_remove_check(plci))
|
|
{
|
|
return 0;
|
|
}
|
|
if (plci->State == INC_DIS_PENDING
|
|
|| plci->State == SUSPENDING) {
|
|
if (c_ind_mask_empty(plci)) {
|
|
if (plci->State != SUSPENDING) plci->State = IDLE;
|
|
dbug(1, dprintf("chs=%d", plci->channels));
|
|
if (!plci->channels) {
|
|
plci_remove(plci);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static byte listen_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word Info;
|
|
byte i;
|
|
|
|
dbug(1, dprintf("listen_req(Appl=0x%x)", appl->Id));
|
|
|
|
Info = _WRONG_IDENTIFIER;
|
|
if (a) {
|
|
Info = 0;
|
|
a->Info_Mask[appl->Id - 1] = GET_DWORD(parms[0].info);
|
|
a->CIP_Mask[appl->Id - 1] = GET_DWORD(parms[1].info);
|
|
dbug(1, dprintf("CIP_MASK=0x%lx", GET_DWORD(parms[1].info)));
|
|
if (a->Info_Mask[appl->Id - 1] & 0x200) { /* early B3 connect provides */
|
|
a->Info_Mask[appl->Id - 1] |= 0x10; /* call progression infos */
|
|
}
|
|
|
|
/* check if external controller listen and switch listen on or off*/
|
|
if (Id&EXT_CONTROLLER && GET_DWORD(parms[1].info)) {
|
|
if (a->profile.Global_Options & ON_BOARD_CODEC) {
|
|
dummy_plci.State = IDLE;
|
|
a->codec_listen[appl->Id - 1] = &dummy_plci;
|
|
a->TelOAD[0] = (byte)(parms[3].length);
|
|
for (i = 1; parms[3].length >= i && i < 22; i++) {
|
|
a->TelOAD[i] = parms[3].info[i];
|
|
}
|
|
a->TelOAD[i] = 0;
|
|
a->TelOSA[0] = (byte)(parms[4].length);
|
|
for (i = 1; parms[4].length >= i && i < 22; i++) {
|
|
a->TelOSA[i] = parms[4].info[i];
|
|
}
|
|
a->TelOSA[i] = 0;
|
|
}
|
|
else Info = 0x2002; /* wrong controller, codec not supported */
|
|
}
|
|
else{ /* clear listen */
|
|
a->codec_listen[appl->Id - 1] = (PLCI *)0;
|
|
}
|
|
}
|
|
sendf(appl,
|
|
_LISTEN_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"w", Info);
|
|
|
|
if (a) listen_check(a);
|
|
return false;
|
|
}
|
|
|
|
static byte info_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
word i;
|
|
API_PARSE *ai;
|
|
PLCI *rc_plci = NULL;
|
|
API_PARSE ai_parms[5];
|
|
word Info = 0;
|
|
|
|
dbug(1, dprintf("info_req"));
|
|
for (i = 0; i < 5; i++) ai_parms[i].length = 0;
|
|
|
|
ai = &msg[1];
|
|
|
|
if (ai->length)
|
|
{
|
|
if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
|
|
{
|
|
dbug(1, dprintf("AddInfo wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
}
|
|
if (!a) Info = _WRONG_STATE;
|
|
|
|
if (!Info && plci)
|
|
{ /* no fac, with CPN, or KEY */
|
|
rc_plci = plci;
|
|
if (!ai_parms[3].length && plci->State && (msg[0].length || ai_parms[1].length))
|
|
{
|
|
/* overlap sending option */
|
|
dbug(1, dprintf("OvlSnd"));
|
|
add_s(plci, CPN, &msg[0]);
|
|
add_s(plci, KEY, &ai_parms[1]);
|
|
sig_req(plci, INFO_REQ, 0);
|
|
send_req(plci);
|
|
return false;
|
|
}
|
|
|
|
if (plci->State && ai_parms[2].length)
|
|
{
|
|
/* User_Info option */
|
|
dbug(1, dprintf("UUI"));
|
|
add_s(plci, UUI, &ai_parms[2]);
|
|
sig_req(plci, USER_DATA, 0);
|
|
}
|
|
else if (plci->State && ai_parms[3].length)
|
|
{
|
|
/* Facility option */
|
|
dbug(1, dprintf("FAC"));
|
|
add_s(plci, CPN, &msg[0]);
|
|
add_ai(plci, &msg[1]);
|
|
sig_req(plci, FACILITY_REQ, 0);
|
|
}
|
|
else
|
|
{
|
|
Info = _WRONG_STATE;
|
|
}
|
|
}
|
|
else if ((ai_parms[1].length || ai_parms[2].length || ai_parms[3].length) && !Info)
|
|
{
|
|
/* NCR_Facility option -> send UUI and Keypad too */
|
|
dbug(1, dprintf("NCR_FAC"));
|
|
if ((i = get_plci(a)))
|
|
{
|
|
rc_plci = &a->plci[i - 1];
|
|
appl->NullCREnable = true;
|
|
rc_plci->internal_command = C_NCR_FAC_REQ;
|
|
rc_plci->appl = appl;
|
|
add_p(rc_plci, CAI, "\x01\x80");
|
|
add_p(rc_plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(rc_plci, ASSIGN, DSIG_ID);
|
|
send_req(rc_plci);
|
|
}
|
|
else
|
|
{
|
|
Info = _OUT_OF_PLCI;
|
|
}
|
|
|
|
if (!Info)
|
|
{
|
|
add_s(rc_plci, CPN, &msg[0]);
|
|
add_ai(rc_plci, &msg[1]);
|
|
sig_req(rc_plci, NCR_FACILITY, 0);
|
|
send_req(rc_plci);
|
|
return false;
|
|
/* for application controlled supplementary services */
|
|
}
|
|
}
|
|
|
|
if (!rc_plci)
|
|
{
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
|
|
if (!Info)
|
|
{
|
|
send_req(rc_plci);
|
|
}
|
|
else
|
|
{ /* appl is not assigned to a PLCI or error condition */
|
|
dbug(1, dprintf("localInfoCon"));
|
|
sendf(appl,
|
|
_INFO_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"w", Info);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static byte info_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
dbug(1, dprintf("info_res"));
|
|
return false;
|
|
}
|
|
|
|
static byte alert_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
word Info;
|
|
byte ret;
|
|
|
|
dbug(1, dprintf("alert_req"));
|
|
|
|
Info = _WRONG_IDENTIFIER;
|
|
ret = false;
|
|
if (plci) {
|
|
Info = _ALERT_IGNORED;
|
|
if (plci->State != INC_CON_ALERT) {
|
|
Info = _WRONG_STATE;
|
|
if (plci->State == INC_CON_PENDING) {
|
|
Info = 0;
|
|
plci->State = INC_CON_ALERT;
|
|
add_ai(plci, &msg[0]);
|
|
sig_req(plci, CALL_ALERT, 0);
|
|
ret = 1;
|
|
}
|
|
}
|
|
}
|
|
sendf(appl,
|
|
_ALERT_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"w", Info);
|
|
return ret;
|
|
}
|
|
|
|
static byte facility_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
word Info = 0;
|
|
word i = 0;
|
|
|
|
word selector;
|
|
word SSreq;
|
|
long relatedPLCIvalue;
|
|
DIVA_CAPI_ADAPTER *relatedadapter;
|
|
byte *SSparms = "";
|
|
byte RCparms[] = "\x05\x00\x00\x02\x00\x00";
|
|
byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
|
|
API_PARSE *parms;
|
|
API_PARSE ss_parms[11];
|
|
PLCI *rplci;
|
|
byte cai[15];
|
|
dword d;
|
|
API_PARSE dummy;
|
|
|
|
dbug(1, dprintf("facility_req"));
|
|
for (i = 0; i < 9; i++) ss_parms[i].length = 0;
|
|
|
|
parms = &msg[1];
|
|
|
|
if (!a)
|
|
{
|
|
dbug(1, dprintf("wrong Ctrl"));
|
|
Info = _WRONG_IDENTIFIER;
|
|
}
|
|
|
|
selector = GET_WORD(msg[0].info);
|
|
|
|
if (!Info)
|
|
{
|
|
switch (selector)
|
|
{
|
|
case SELECTOR_HANDSET:
|
|
Info = AdvCodecSupport(a, plci, appl, HOOK_SUPPORT);
|
|
break;
|
|
|
|
case SELECTOR_SU_SERV:
|
|
if (!msg[1].length)
|
|
{
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
SSreq = GET_WORD(&(msg[1].info[1]));
|
|
PUT_WORD(&RCparms[1], SSreq);
|
|
SSparms = RCparms;
|
|
switch (SSreq)
|
|
{
|
|
case S_GET_SUPPORTED_SERVICES:
|
|
if ((i = get_plci(a)))
|
|
{
|
|
rplci = &a->plci[i - 1];
|
|
rplci->appl = appl;
|
|
add_p(rplci, CAI, "\x01\x80");
|
|
add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(rplci, ASSIGN, DSIG_ID);
|
|
send_req(rplci);
|
|
}
|
|
else
|
|
{
|
|
PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
|
|
SSparms = (byte *)SSstruct;
|
|
break;
|
|
}
|
|
rplci->internal_command = GETSERV_REQ_PEND;
|
|
rplci->number = Number;
|
|
rplci->appl = appl;
|
|
sig_req(rplci, S_SUPPORTED, 0);
|
|
send_req(rplci);
|
|
return false;
|
|
break;
|
|
|
|
case S_LISTEN:
|
|
if (parms->length == 7)
|
|
{
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
a->Notification_Mask[appl->Id - 1] = GET_DWORD(ss_parms[2].info);
|
|
if (a->Notification_Mask[appl->Id - 1] & SMASK_MWI) /* MWI active? */
|
|
{
|
|
if ((i = get_plci(a)))
|
|
{
|
|
rplci = &a->plci[i - 1];
|
|
rplci->appl = appl;
|
|
add_p(rplci, CAI, "\x01\x80");
|
|
add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(rplci, ASSIGN, DSIG_ID);
|
|
send_req(rplci);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
rplci->internal_command = GET_MWI_STATE;
|
|
rplci->number = Number;
|
|
sig_req(rplci, MWI_POLL, 0);
|
|
send_req(rplci);
|
|
}
|
|
break;
|
|
|
|
case S_HOLD:
|
|
api_parse(&parms->info[1], (word)parms->length, "ws", ss_parms);
|
|
if (plci && plci->State && plci->SuppState == IDLE)
|
|
{
|
|
plci->SuppState = HOLD_REQUEST;
|
|
plci->command = C_HOLD_REQ;
|
|
add_s(plci, CAI, &ss_parms[1]);
|
|
sig_req(plci, CALL_HOLD, 0);
|
|
send_req(plci);
|
|
return false;
|
|
}
|
|
else Info = 0x3010; /* wrong state */
|
|
break;
|
|
case S_RETRIEVE:
|
|
if (plci && plci->State && plci->SuppState == CALL_HELD)
|
|
{
|
|
if (Id & EXT_CONTROLLER)
|
|
{
|
|
if (AdvCodecSupport(a, plci, appl, 0))
|
|
{
|
|
Info = 0x3010; /* wrong state */
|
|
break;
|
|
}
|
|
}
|
|
else plci->tel = 0;
|
|
|
|
plci->SuppState = RETRIEVE_REQUEST;
|
|
plci->command = C_RETRIEVE_REQ;
|
|
if (plci->spoofed_msg == SPOOFING_REQUIRED)
|
|
{
|
|
plci->spoofed_msg = CALL_RETRIEVE;
|
|
plci->internal_command = BLOCK_PLCI;
|
|
plci->command = 0;
|
|
dbug(1, dprintf("Spoof"));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
sig_req(plci, CALL_RETRIEVE, 0);
|
|
send_req(plci);
|
|
return false;
|
|
}
|
|
}
|
|
else Info = 0x3010; /* wrong state */
|
|
break;
|
|
case S_SUSPEND:
|
|
if (parms->length)
|
|
{
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms))
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
}
|
|
if (plci && plci->State)
|
|
{
|
|
add_s(plci, CAI, &ss_parms[2]);
|
|
plci->command = SUSPEND_REQ;
|
|
sig_req(plci, SUSPEND, 0);
|
|
plci->State = SUSPENDING;
|
|
send_req(plci);
|
|
}
|
|
else Info = 0x3010; /* wrong state */
|
|
break;
|
|
|
|
case S_RESUME:
|
|
if (!(i = get_plci(a)))
|
|
{
|
|
Info = _OUT_OF_PLCI;
|
|
break;
|
|
}
|
|
rplci = &a->plci[i - 1];
|
|
rplci->appl = appl;
|
|
rplci->number = Number;
|
|
rplci->tel = 0;
|
|
rplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
|
|
/* check 'external controller' bit for codec support */
|
|
if (Id & EXT_CONTROLLER)
|
|
{
|
|
if (AdvCodecSupport(a, rplci, appl, 0))
|
|
{
|
|
rplci->Id = 0;
|
|
Info = 0x300A;
|
|
break;
|
|
}
|
|
}
|
|
if (parms->length)
|
|
{
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbs", ss_parms))
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
rplci->Id = 0;
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
}
|
|
dummy.length = 0;
|
|
dummy.info = "\x00";
|
|
add_b1(rplci, &dummy, 0, 0);
|
|
if (a->Info_Mask[appl->Id - 1] & 0x200)
|
|
{
|
|
/* early B3 connect (CIP mask bit 9) no release after a disc */
|
|
add_p(rplci, LLI, "\x01\x01");
|
|
}
|
|
add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(rplci, ASSIGN, DSIG_ID);
|
|
send_req(rplci);
|
|
add_s(rplci, CAI, &ss_parms[2]);
|
|
rplci->command = RESUME_REQ;
|
|
sig_req(rplci, RESUME, 0);
|
|
rplci->State = RESUMING;
|
|
send_req(rplci);
|
|
break;
|
|
|
|
case S_CONF_BEGIN: /* Request */
|
|
case S_CONF_DROP:
|
|
case S_CONF_ISOLATE:
|
|
case S_CONF_REATTACH:
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
if (plci && plci->State && ((plci->SuppState == IDLE) || (plci->SuppState == CALL_HELD)))
|
|
{
|
|
d = GET_DWORD(ss_parms[2].info);
|
|
if (d >= 0x80)
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
plci->ptyState = (byte)SSreq;
|
|
plci->command = 0;
|
|
cai[0] = 2;
|
|
switch (SSreq)
|
|
{
|
|
case S_CONF_BEGIN:
|
|
cai[1] = CONF_BEGIN;
|
|
plci->internal_command = CONF_BEGIN_REQ_PEND;
|
|
break;
|
|
case S_CONF_DROP:
|
|
cai[1] = CONF_DROP;
|
|
plci->internal_command = CONF_DROP_REQ_PEND;
|
|
break;
|
|
case S_CONF_ISOLATE:
|
|
cai[1] = CONF_ISOLATE;
|
|
plci->internal_command = CONF_ISOLATE_REQ_PEND;
|
|
break;
|
|
case S_CONF_REATTACH:
|
|
cai[1] = CONF_REATTACH;
|
|
plci->internal_command = CONF_REATTACH_REQ_PEND;
|
|
break;
|
|
}
|
|
cai[2] = (byte)d; /* Conference Size resp. PartyId */
|
|
add_p(plci, CAI, cai);
|
|
sig_req(plci, S_SERVICE, 0);
|
|
send_req(plci);
|
|
return false;
|
|
}
|
|
else Info = 0x3010; /* wrong state */
|
|
break;
|
|
|
|
case S_ECT:
|
|
case S_3PTY_BEGIN:
|
|
case S_3PTY_END:
|
|
case S_CONF_ADD:
|
|
if (parms->length == 7)
|
|
{
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
}
|
|
else if (parms->length == 8) /* workaround for the T-View-S */
|
|
{
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbdb", ss_parms))
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
if (!msg[1].length)
|
|
{
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
if (!plci)
|
|
{
|
|
Info = _WRONG_IDENTIFIER;
|
|
break;
|
|
}
|
|
relatedPLCIvalue = GET_DWORD(ss_parms[2].info);
|
|
relatedPLCIvalue &= 0x0000FFFF;
|
|
dbug(1, dprintf("PTY/ECT/addCONF,relPLCI=%lx", relatedPLCIvalue));
|
|
/* controller starts with 0 up to (max_adapter - 1) */
|
|
if (((relatedPLCIvalue & 0x7f) == 0)
|
|
|| (MapController((byte)(relatedPLCIvalue & 0x7f)) == 0)
|
|
|| (MapController((byte)(relatedPLCIvalue & 0x7f)) > max_adapter))
|
|
{
|
|
if (SSreq == S_3PTY_END)
|
|
{
|
|
dbug(1, dprintf("wrong Controller use 2nd PLCI=PLCI"));
|
|
rplci = plci;
|
|
}
|
|
else
|
|
{
|
|
Info = 0x3010; /* wrong state */
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
relatedadapter = &adapter[MapController((byte)(relatedPLCIvalue & 0x7f)) - 1];
|
|
relatedPLCIvalue >>= 8;
|
|
/* find PLCI PTR*/
|
|
for (i = 0, rplci = NULL; i < relatedadapter->max_plci; i++)
|
|
{
|
|
if (relatedadapter->plci[i].Id == (byte)relatedPLCIvalue)
|
|
{
|
|
rplci = &relatedadapter->plci[i];
|
|
}
|
|
}
|
|
if (!rplci || !relatedPLCIvalue)
|
|
{
|
|
if (SSreq == S_3PTY_END)
|
|
{
|
|
dbug(1, dprintf("use 2nd PLCI=PLCI"));
|
|
rplci = plci;
|
|
}
|
|
else
|
|
{
|
|
Info = 0x3010; /* wrong state */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
dbug(1, dprintf("rplci:%x", rplci));
|
|
dbug(1, dprintf("plci:%x", plci));
|
|
dbug(1, dprintf("rplci->ptyState:%x", rplci->ptyState));
|
|
dbug(1, dprintf("plci->ptyState:%x", plci->ptyState));
|
|
dbug(1, dprintf("SSreq:%x", SSreq));
|
|
dbug(1, dprintf("rplci->internal_command:%x", rplci->internal_command));
|
|
dbug(1, dprintf("rplci->appl:%x", rplci->appl));
|
|
dbug(1, dprintf("rplci->Id:%x", rplci->Id));
|
|
*/
|
|
/* send PTY/ECT req, cannot check all states because of US stuff */
|
|
if (!rplci->internal_command && rplci->appl)
|
|
{
|
|
plci->command = 0;
|
|
rplci->relatedPTYPLCI = plci;
|
|
plci->relatedPTYPLCI = rplci;
|
|
rplci->ptyState = (byte)SSreq;
|
|
if (SSreq == S_ECT)
|
|
{
|
|
rplci->internal_command = ECT_REQ_PEND;
|
|
cai[1] = ECT_EXECUTE;
|
|
|
|
rplci->vswitchstate = 0;
|
|
rplci->vsprot = 0;
|
|
rplci->vsprotdialect = 0;
|
|
plci->vswitchstate = 0;
|
|
plci->vsprot = 0;
|
|
plci->vsprotdialect = 0;
|
|
|
|
}
|
|
else if (SSreq == S_CONF_ADD)
|
|
{
|
|
rplci->internal_command = CONF_ADD_REQ_PEND;
|
|
cai[1] = CONF_ADD;
|
|
}
|
|
else
|
|
{
|
|
rplci->internal_command = PTY_REQ_PEND;
|
|
cai[1] = (byte)(SSreq - 3);
|
|
}
|
|
rplci->number = Number;
|
|
if (plci != rplci) /* explicit invocation */
|
|
{
|
|
cai[0] = 2;
|
|
cai[2] = plci->Sig.Id;
|
|
dbug(1, dprintf("explicit invocation"));
|
|
}
|
|
else
|
|
{
|
|
dbug(1, dprintf("implicit invocation"));
|
|
cai[0] = 1;
|
|
}
|
|
add_p(rplci, CAI, cai);
|
|
sig_req(rplci, S_SERVICE, 0);
|
|
send_req(rplci);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
dbug(0, dprintf("Wrong line"));
|
|
Info = 0x3010; /* wrong state */
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case S_CALL_DEFLECTION:
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbwss", ss_parms))
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
if (!plci)
|
|
{
|
|
Info = _WRONG_IDENTIFIER;
|
|
break;
|
|
}
|
|
/* reuse unused screening indicator */
|
|
ss_parms[3].info[3] = (byte)GET_WORD(&(ss_parms[2].info[0]));
|
|
plci->command = 0;
|
|
plci->internal_command = CD_REQ_PEND;
|
|
appl->CDEnable = true;
|
|
cai[0] = 1;
|
|
cai[1] = CALL_DEFLECTION;
|
|
add_p(plci, CAI, cai);
|
|
add_p(plci, CPN, ss_parms[3].info);
|
|
sig_req(plci, S_SERVICE, 0);
|
|
send_req(plci);
|
|
return false;
|
|
break;
|
|
|
|
case S_CALL_FORWARDING_START:
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbdwwsss", ss_parms))
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
|
|
if ((i = get_plci(a)))
|
|
{
|
|
rplci = &a->plci[i - 1];
|
|
rplci->appl = appl;
|
|
add_p(rplci, CAI, "\x01\x80");
|
|
add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(rplci, ASSIGN, DSIG_ID);
|
|
send_req(rplci);
|
|
}
|
|
else
|
|
{
|
|
Info = _OUT_OF_PLCI;
|
|
break;
|
|
}
|
|
|
|
/* reuse unused screening indicator */
|
|
rplci->internal_command = CF_START_PEND;
|
|
rplci->appl = appl;
|
|
rplci->number = Number;
|
|
appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
|
|
cai[0] = 2;
|
|
cai[1] = 0x70 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
|
|
cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
|
|
add_p(rplci, CAI, cai);
|
|
add_p(rplci, OAD, ss_parms[5].info);
|
|
add_p(rplci, CPN, ss_parms[6].info);
|
|
sig_req(rplci, S_SERVICE, 0);
|
|
send_req(rplci);
|
|
return false;
|
|
break;
|
|
|
|
case S_INTERROGATE_DIVERSION:
|
|
case S_INTERROGATE_NUMBERS:
|
|
case S_CALL_FORWARDING_STOP:
|
|
case S_CCBS_REQUEST:
|
|
case S_CCBS_DEACTIVATE:
|
|
case S_CCBS_INTERROGATE:
|
|
switch (SSreq)
|
|
{
|
|
case S_INTERROGATE_NUMBERS:
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbd", ss_parms))
|
|
{
|
|
dbug(0, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
break;
|
|
case S_CCBS_REQUEST:
|
|
case S_CCBS_DEACTIVATE:
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbdw", ss_parms))
|
|
{
|
|
dbug(0, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
break;
|
|
case S_CCBS_INTERROGATE:
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbdws", ss_parms))
|
|
{
|
|
dbug(0, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
break;
|
|
default:
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbdwws", ss_parms))
|
|
{
|
|
dbug(0, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (Info) break;
|
|
if ((i = get_plci(a)))
|
|
{
|
|
rplci = &a->plci[i - 1];
|
|
switch (SSreq)
|
|
{
|
|
case S_INTERROGATE_DIVERSION: /* use cai with S_SERVICE below */
|
|
cai[1] = 0x60 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
|
|
rplci->internal_command = INTERR_DIVERSION_REQ_PEND; /* move to rplci if assigned */
|
|
break;
|
|
case S_INTERROGATE_NUMBERS: /* use cai with S_SERVICE below */
|
|
cai[1] = DIVERSION_INTERROGATE_NUM; /* Function */
|
|
rplci->internal_command = INTERR_NUMBERS_REQ_PEND; /* move to rplci if assigned */
|
|
break;
|
|
case S_CALL_FORWARDING_STOP:
|
|
rplci->internal_command = CF_STOP_PEND;
|
|
cai[1] = 0x80 | (byte)GET_WORD(&(ss_parms[3].info[0])); /* Function */
|
|
break;
|
|
case S_CCBS_REQUEST:
|
|
cai[1] = CCBS_REQUEST;
|
|
rplci->internal_command = CCBS_REQUEST_REQ_PEND;
|
|
break;
|
|
case S_CCBS_DEACTIVATE:
|
|
cai[1] = CCBS_DEACTIVATE;
|
|
rplci->internal_command = CCBS_DEACTIVATE_REQ_PEND;
|
|
break;
|
|
case S_CCBS_INTERROGATE:
|
|
cai[1] = CCBS_INTERROGATE;
|
|
rplci->internal_command = CCBS_INTERROGATE_REQ_PEND;
|
|
break;
|
|
default:
|
|
cai[1] = 0;
|
|
break;
|
|
}
|
|
rplci->appl = appl;
|
|
rplci->number = Number;
|
|
add_p(rplci, CAI, "\x01\x80");
|
|
add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(rplci, ASSIGN, DSIG_ID);
|
|
send_req(rplci);
|
|
}
|
|
else
|
|
{
|
|
Info = _OUT_OF_PLCI;
|
|
break;
|
|
}
|
|
|
|
appl->S_Handle = GET_DWORD(&(ss_parms[2].info[0]));
|
|
switch (SSreq)
|
|
{
|
|
case S_INTERROGATE_NUMBERS:
|
|
cai[0] = 1;
|
|
add_p(rplci, CAI, cai);
|
|
break;
|
|
case S_CCBS_REQUEST:
|
|
case S_CCBS_DEACTIVATE:
|
|
cai[0] = 3;
|
|
PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0])));
|
|
add_p(rplci, CAI, cai);
|
|
break;
|
|
case S_CCBS_INTERROGATE:
|
|
cai[0] = 3;
|
|
PUT_WORD(&cai[2], GET_WORD(&(ss_parms[3].info[0])));
|
|
add_p(rplci, CAI, cai);
|
|
add_p(rplci, OAD, ss_parms[4].info);
|
|
break;
|
|
default:
|
|
cai[0] = 2;
|
|
cai[2] = (byte)GET_WORD(&(ss_parms[4].info[0])); /* Basic Service */
|
|
add_p(rplci, CAI, cai);
|
|
add_p(rplci, OAD, ss_parms[5].info);
|
|
break;
|
|
}
|
|
|
|
sig_req(rplci, S_SERVICE, 0);
|
|
send_req(rplci);
|
|
return false;
|
|
break;
|
|
|
|
case S_MWI_ACTIVATE:
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbwdwwwssss", ss_parms))
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
if (!plci)
|
|
{
|
|
if ((i = get_plci(a)))
|
|
{
|
|
rplci = &a->plci[i - 1];
|
|
rplci->appl = appl;
|
|
rplci->cr_enquiry = true;
|
|
add_p(rplci, CAI, "\x01\x80");
|
|
add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(rplci, ASSIGN, DSIG_ID);
|
|
send_req(rplci);
|
|
}
|
|
else
|
|
{
|
|
Info = _OUT_OF_PLCI;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rplci = plci;
|
|
rplci->cr_enquiry = false;
|
|
}
|
|
|
|
rplci->command = 0;
|
|
rplci->internal_command = MWI_ACTIVATE_REQ_PEND;
|
|
rplci->appl = appl;
|
|
rplci->number = Number;
|
|
|
|
cai[0] = 13;
|
|
cai[1] = ACTIVATION_MWI; /* Function */
|
|
PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
|
|
PUT_DWORD(&cai[4], GET_DWORD(&(ss_parms[3].info[0]))); /* Number of Messages */
|
|
PUT_WORD(&cai[8], GET_WORD(&(ss_parms[4].info[0]))); /* Message Status */
|
|
PUT_WORD(&cai[10], GET_WORD(&(ss_parms[5].info[0]))); /* Message Reference */
|
|
PUT_WORD(&cai[12], GET_WORD(&(ss_parms[6].info[0]))); /* Invocation Mode */
|
|
add_p(rplci, CAI, cai);
|
|
add_p(rplci, CPN, ss_parms[7].info); /* Receiving User Number */
|
|
add_p(rplci, OAD, ss_parms[8].info); /* Controlling User Number */
|
|
add_p(rplci, OSA, ss_parms[9].info); /* Controlling User Provided Number */
|
|
add_p(rplci, UID, ss_parms[10].info); /* Time */
|
|
sig_req(rplci, S_SERVICE, 0);
|
|
send_req(rplci);
|
|
return false;
|
|
|
|
case S_MWI_DEACTIVATE:
|
|
if (api_parse(&parms->info[1], (word)parms->length, "wbwwss", ss_parms))
|
|
{
|
|
dbug(1, dprintf("format wrong"));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
if (!plci)
|
|
{
|
|
if ((i = get_plci(a)))
|
|
{
|
|
rplci = &a->plci[i - 1];
|
|
rplci->appl = appl;
|
|
rplci->cr_enquiry = true;
|
|
add_p(rplci, CAI, "\x01\x80");
|
|
add_p(rplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(rplci, ASSIGN, DSIG_ID);
|
|
send_req(rplci);
|
|
}
|
|
else
|
|
{
|
|
Info = _OUT_OF_PLCI;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rplci = plci;
|
|
rplci->cr_enquiry = false;
|
|
}
|
|
|
|
rplci->command = 0;
|
|
rplci->internal_command = MWI_DEACTIVATE_REQ_PEND;
|
|
rplci->appl = appl;
|
|
rplci->number = Number;
|
|
|
|
cai[0] = 5;
|
|
cai[1] = DEACTIVATION_MWI; /* Function */
|
|
PUT_WORD(&cai[2], GET_WORD(&(ss_parms[2].info[0]))); /* Basic Service */
|
|
PUT_WORD(&cai[4], GET_WORD(&(ss_parms[3].info[0]))); /* Invocation Mode */
|
|
add_p(rplci, CAI, cai);
|
|
add_p(rplci, CPN, ss_parms[4].info); /* Receiving User Number */
|
|
add_p(rplci, OAD, ss_parms[5].info); /* Controlling User Number */
|
|
sig_req(rplci, S_SERVICE, 0);
|
|
send_req(rplci);
|
|
return false;
|
|
|
|
default:
|
|
Info = 0x300E; /* not supported */
|
|
break;
|
|
}
|
|
break; /* case SELECTOR_SU_SERV: end */
|
|
|
|
|
|
case SELECTOR_DTMF:
|
|
return (dtmf_request(Id, Number, a, plci, appl, msg));
|
|
|
|
|
|
|
|
case SELECTOR_LINE_INTERCONNECT:
|
|
return (mixer_request(Id, Number, a, plci, appl, msg));
|
|
|
|
|
|
|
|
case PRIV_SELECTOR_ECHO_CANCELLER:
|
|
appl->appl_flags |= APPL_FLAG_PRIV_EC_SPEC;
|
|
return (ec_request(Id, Number, a, plci, appl, msg));
|
|
|
|
case SELECTOR_ECHO_CANCELLER:
|
|
appl->appl_flags &= ~APPL_FLAG_PRIV_EC_SPEC;
|
|
return (ec_request(Id, Number, a, plci, appl, msg));
|
|
|
|
|
|
case SELECTOR_V42BIS:
|
|
default:
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
} /* end of switch (selector) */
|
|
}
|
|
|
|
dbug(1, dprintf("SendFacRc"));
|
|
sendf(appl,
|
|
_FACILITY_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"wws", Info, selector, SSparms);
|
|
return false;
|
|
}
|
|
|
|
static byte facility_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
dbug(1, dprintf("facility_res"));
|
|
return false;
|
|
}
|
|
|
|
static byte connect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word Info = 0;
|
|
byte req;
|
|
byte len;
|
|
word w;
|
|
word fax_control_bits, fax_feature_bits, fax_info_change;
|
|
API_PARSE *ncpi;
|
|
byte pvc[2];
|
|
|
|
API_PARSE fax_parms[9];
|
|
word i;
|
|
|
|
|
|
dbug(1, dprintf("connect_b3_req"));
|
|
if (plci)
|
|
{
|
|
if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING)
|
|
|| (plci->State == INC_DIS_PENDING) || (plci->SuppState != IDLE))
|
|
{
|
|
Info = _WRONG_STATE;
|
|
}
|
|
else
|
|
{
|
|
/* local reply if assign unsuccessful
|
|
or B3 protocol allows only one layer 3 connection
|
|
and already connected
|
|
or B2 protocol not any LAPD
|
|
and connect_b3_req contradicts originate/answer direction */
|
|
if (!plci->NL.Id
|
|
|| (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
|
|
&& ((plci->channels != 0)
|
|
|| (((plci->B2_prot != B2_SDLC) && (plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL))
|
|
&& ((plci->call_dir & CALL_DIR_ANSWER) && !(plci->call_dir & CALL_DIR_FORCE_OUTG_NL))))))
|
|
{
|
|
dbug(1, dprintf("B3 already connected=%d or no NL.Id=0x%x, dir=%d sstate=0x%x",
|
|
plci->channels, plci->NL.Id, plci->call_dir, plci->SuppState));
|
|
Info = _WRONG_STATE;
|
|
sendf(appl,
|
|
_CONNECT_B3_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"w", Info);
|
|
return false;
|
|
}
|
|
plci->requested_options_conn = 0;
|
|
|
|
req = N_CONNECT;
|
|
ncpi = &parms[0];
|
|
if (plci->B3_prot == 2 || plci->B3_prot == 3)
|
|
{
|
|
if (ncpi->length > 2)
|
|
{
|
|
/* check for PVC */
|
|
if (ncpi->info[2] || ncpi->info[3])
|
|
{
|
|
pvc[0] = ncpi->info[3];
|
|
pvc[1] = ncpi->info[2];
|
|
add_d(plci, 2, pvc);
|
|
req = N_RESET;
|
|
}
|
|
else
|
|
{
|
|
if (ncpi->info[1] & 1) req = N_CONNECT | N_D_BIT;
|
|
add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
|
|
}
|
|
}
|
|
}
|
|
else if (plci->B3_prot == 5)
|
|
{
|
|
if (plci->NL.Id && !plci->nl_remove_id)
|
|
{
|
|
fax_control_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low);
|
|
fax_feature_bits = GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low);
|
|
if (!(fax_control_bits & T30_CONTROL_BIT_MORE_DOCUMENTS)
|
|
|| (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS))
|
|
{
|
|
len = offsetof(T30_INFO, universal_6);
|
|
fax_info_change = false;
|
|
if (ncpi->length >= 4)
|
|
{
|
|
w = GET_WORD(&ncpi->info[3]);
|
|
if ((w & 0x0001) != ((word)(((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & 0x0001)))
|
|
{
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->resolution =
|
|
(byte)((((T30_INFO *)(plci->fax_connect_info_buffer))->resolution & ~T30_RESOLUTION_R8_0770_OR_200) |
|
|
((w & 0x0001) ? T30_RESOLUTION_R8_0770_OR_200 : 0));
|
|
fax_info_change = true;
|
|
}
|
|
fax_control_bits &= ~(T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
|
|
if (w & 0x0002) /* Fax-polling request */
|
|
fax_control_bits |= T30_CONTROL_BIT_REQUEST_POLLING;
|
|
if ((w & 0x0004) /* Request to send / poll another document */
|
|
&& (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_MORE_DOCUMENTS))
|
|
{
|
|
fax_control_bits |= T30_CONTROL_BIT_MORE_DOCUMENTS;
|
|
}
|
|
if (ncpi->length >= 6)
|
|
{
|
|
w = GET_WORD(&ncpi->info[5]);
|
|
if (((byte) w) != ((T30_INFO *)(plci->fax_connect_info_buffer))->data_format)
|
|
{
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->data_format = (byte) w;
|
|
fax_info_change = true;
|
|
}
|
|
|
|
if ((a->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
|
|
&& (GET_WORD(&ncpi->info[5]) & 0x8000)) /* Private SEP/SUB/PWD enable */
|
|
{
|
|
plci->requested_options_conn |= (1L << PRIVATE_FAX_SUB_SEP_PWD);
|
|
}
|
|
if ((a->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
|
|
&& (GET_WORD(&ncpi->info[5]) & 0x4000)) /* Private non-standard facilities enable */
|
|
{
|
|
plci->requested_options_conn |= (1L << PRIVATE_FAX_NONSTANDARD);
|
|
}
|
|
fax_control_bits &= ~(T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_SEL_POLLING |
|
|
T30_CONTROL_BIT_ACCEPT_PASSWORD);
|
|
if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
|
|
& ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
|
|
{
|
|
if (api_parse(&ncpi->info[1], ncpi->length, "wwwwsss", fax_parms))
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
else
|
|
{
|
|
if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
|
|
& (1L << PRIVATE_FAX_SUB_SEP_PWD))
|
|
{
|
|
fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
|
|
if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
|
|
fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
|
|
}
|
|
w = fax_parms[4].length;
|
|
if (w > 20)
|
|
w = 20;
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = (byte) w;
|
|
for (i = 0; i < w; i++)
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->station_id[i] = fax_parms[4].info[1 + i];
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
|
|
len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
|
|
w = fax_parms[5].length;
|
|
if (w > 20)
|
|
w = 20;
|
|
plci->fax_connect_info_buffer[len++] = (byte) w;
|
|
for (i = 0; i < w; i++)
|
|
plci->fax_connect_info_buffer[len++] = fax_parms[5].info[1 + i];
|
|
w = fax_parms[6].length;
|
|
if (w > 20)
|
|
w = 20;
|
|
plci->fax_connect_info_buffer[len++] = (byte) w;
|
|
for (i = 0; i < w; i++)
|
|
plci->fax_connect_info_buffer[len++] = fax_parms[6].info[1 + i];
|
|
if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[appl->Id - 1])
|
|
& (1L << PRIVATE_FAX_NONSTANDARD))
|
|
{
|
|
if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
|
|
{
|
|
dbug(1, dprintf("non-standard facilities info missing or wrong format"));
|
|
plci->fax_connect_info_buffer[len++] = 0;
|
|
}
|
|
else
|
|
{
|
|
if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
|
|
plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
|
|
plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
|
|
for (i = 0; i < fax_parms[7].length; i++)
|
|
plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
len = offsetof(T30_INFO, universal_6);
|
|
}
|
|
fax_info_change = true;
|
|
|
|
}
|
|
if (fax_control_bits != GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low))
|
|
{
|
|
PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low, fax_control_bits);
|
|
fax_info_change = true;
|
|
}
|
|
}
|
|
if (Info == GOOD)
|
|
{
|
|
plci->fax_connect_info_length = len;
|
|
if (fax_info_change)
|
|
{
|
|
if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
|
|
{
|
|
start_internal_command(Id, plci, fax_connect_info_command);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
start_internal_command(Id, plci, fax_adjust_b23_command);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else Info = _WRONG_STATE;
|
|
}
|
|
else Info = _WRONG_STATE;
|
|
}
|
|
|
|
else if (plci->B3_prot == B3_RTP)
|
|
{
|
|
plci->internal_req_buffer[0] = ncpi->length + 1;
|
|
plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
|
|
for (w = 0; w < ncpi->length; w++)
|
|
plci->internal_req_buffer[2 + w] = ncpi->info[1 + w];
|
|
start_internal_command(Id, plci, rtp_connect_b3_req_command);
|
|
return false;
|
|
}
|
|
|
|
if (!Info)
|
|
{
|
|
nl_req_ncci(plci, req, 0);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
else Info = _WRONG_IDENTIFIER;
|
|
|
|
sendf(appl,
|
|
_CONNECT_B3_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"w", Info);
|
|
return false;
|
|
}
|
|
|
|
static byte connect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word ncci;
|
|
API_PARSE *ncpi;
|
|
byte req;
|
|
|
|
word w;
|
|
|
|
|
|
API_PARSE fax_parms[9];
|
|
word i;
|
|
byte len;
|
|
|
|
|
|
dbug(1, dprintf("connect_b3_res"));
|
|
|
|
ncci = (word)(Id >> 16);
|
|
if (plci && ncci) {
|
|
if (a->ncci_state[ncci] == INC_CON_PENDING) {
|
|
if (GET_WORD(&parms[0].info[0]) != 0)
|
|
{
|
|
a->ncci_state[ncci] = OUTG_REJ_PENDING;
|
|
channel_request_xon(plci, a->ncci_ch[ncci]);
|
|
channel_xmit_xon(plci);
|
|
cleanup_ncci_data(plci, ncci);
|
|
nl_req_ncci(plci, N_DISC, (byte)ncci);
|
|
return 1;
|
|
}
|
|
a->ncci_state[ncci] = INC_ACT_PENDING;
|
|
|
|
req = N_CONNECT_ACK;
|
|
ncpi = &parms[1];
|
|
if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
|
|
{
|
|
|
|
if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
|
|
& (1L << PRIVATE_FAX_NONSTANDARD))
|
|
{
|
|
if (((plci->B3_prot == 4) || (plci->B3_prot == 5))
|
|
&& (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
|
|
&& (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
|
|
{
|
|
len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
|
|
if (plci->fax_connect_info_length < len)
|
|
{
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
|
|
}
|
|
if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
|
|
{
|
|
dbug(1, dprintf("non-standard facilities info missing or wrong format"));
|
|
}
|
|
else
|
|
{
|
|
if (plci->fax_connect_info_length <= len)
|
|
plci->fax_connect_info_buffer[len] = 0;
|
|
len += 1 + plci->fax_connect_info_buffer[len];
|
|
if (plci->fax_connect_info_length <= len)
|
|
plci->fax_connect_info_buffer[len] = 0;
|
|
len += 1 + plci->fax_connect_info_buffer[len];
|
|
if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
|
|
plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
|
|
plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
|
|
for (i = 0; i < fax_parms[7].length; i++)
|
|
plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
|
|
}
|
|
plci->fax_connect_info_length = len;
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->code = 0;
|
|
start_internal_command(Id, plci, fax_connect_ack_command);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
nl_req_ncci(plci, req, (byte)ncci);
|
|
if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
|
|
&& !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
|
|
{
|
|
if (plci->B3_prot == 4)
|
|
sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
|
|
else
|
|
sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
|
|
plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
|
|
}
|
|
}
|
|
|
|
else if (plci->B3_prot == B3_RTP)
|
|
{
|
|
plci->internal_req_buffer[0] = ncpi->length + 1;
|
|
plci->internal_req_buffer[1] = UDATA_REQUEST_RTP_RECONFIGURE;
|
|
for (w = 0; w < ncpi->length; w++)
|
|
plci->internal_req_buffer[2 + w] = ncpi->info[1+w];
|
|
start_internal_command(Id, plci, rtp_connect_b3_res_command);
|
|
return false;
|
|
}
|
|
|
|
else
|
|
{
|
|
if (ncpi->length > 2) {
|
|
if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT;
|
|
add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
|
|
}
|
|
nl_req_ncci(plci, req, (byte)ncci);
|
|
sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
|
|
if (plci->adjust_b_restore)
|
|
{
|
|
plci->adjust_b_restore = false;
|
|
start_internal_command(Id, plci, adjust_b_restore);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static byte connect_b3_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word ncci;
|
|
|
|
ncci = (word)(Id >> 16);
|
|
dbug(1, dprintf("connect_b3_a_res(ncci=0x%x)", ncci));
|
|
|
|
if (plci && ncci && (plci->State != IDLE) && (plci->State != INC_DIS_PENDING)
|
|
&& (plci->State != OUTG_DIS_PENDING))
|
|
{
|
|
if (a->ncci_state[ncci] == INC_ACT_PENDING) {
|
|
a->ncci_state[ncci] = CONNECTED;
|
|
if (plci->State != INC_CON_CONNECTED_ALERT) plci->State = CONNECTED;
|
|
channel_request_xon(plci, a->ncci_ch[ncci]);
|
|
channel_xmit_xon(plci);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static byte disconnect_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word Info;
|
|
word ncci;
|
|
API_PARSE *ncpi;
|
|
|
|
dbug(1, dprintf("disconnect_b3_req"));
|
|
|
|
Info = _WRONG_IDENTIFIER;
|
|
ncci = (word)(Id >> 16);
|
|
if (plci && ncci)
|
|
{
|
|
Info = _WRONG_STATE;
|
|
if ((a->ncci_state[ncci] == CONNECTED)
|
|
|| (a->ncci_state[ncci] == OUTG_CON_PENDING)
|
|
|| (a->ncci_state[ncci] == INC_CON_PENDING)
|
|
|| (a->ncci_state[ncci] == INC_ACT_PENDING))
|
|
{
|
|
a->ncci_state[ncci] = OUTG_DIS_PENDING;
|
|
channel_request_xon(plci, a->ncci_ch[ncci]);
|
|
channel_xmit_xon(plci);
|
|
|
|
if (a->ncci[ncci].data_pending
|
|
&& ((plci->B3_prot == B3_TRANSPARENT)
|
|
|| (plci->B3_prot == B3_T30)
|
|
|| (plci->B3_prot == B3_T30_WITH_EXTENSIONS)))
|
|
{
|
|
plci->send_disc = (byte)ncci;
|
|
plci->command = 0;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
cleanup_ncci_data(plci, ncci);
|
|
|
|
if (plci->B3_prot == 2 || plci->B3_prot == 3)
|
|
{
|
|
ncpi = &parms[0];
|
|
if (ncpi->length > 3)
|
|
{
|
|
add_d(plci, (word)(ncpi->length - 3), (byte *)&(ncpi->info[4]));
|
|
}
|
|
}
|
|
nl_req_ncci(plci, N_DISC, (byte)ncci);
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
sendf(appl,
|
|
_DISCONNECT_B3_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"w", Info);
|
|
return false;
|
|
}
|
|
|
|
static byte disconnect_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word ncci;
|
|
word i;
|
|
|
|
ncci = (word)(Id >> 16);
|
|
dbug(1, dprintf("disconnect_b3_res(ncci=0x%x", ncci));
|
|
if (plci && ncci) {
|
|
plci->requested_options_conn = 0;
|
|
plci->fax_connect_info_length = 0;
|
|
plci->ncpi_state = 0x00;
|
|
if (((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE))
|
|
&& ((plci->B2_prot != B2_LAPD) && (plci->B2_prot != B2_LAPD_FREE_SAPI_SEL)))
|
|
{
|
|
plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
|
|
}
|
|
for (i = 0; i < MAX_CHANNELS_PER_PLCI && plci->inc_dis_ncci_table[i] != (byte)ncci; i++);
|
|
if (i < MAX_CHANNELS_PER_PLCI) {
|
|
if (plci->channels)plci->channels--;
|
|
for (; i < MAX_CHANNELS_PER_PLCI - 1; i++) plci->inc_dis_ncci_table[i] = plci->inc_dis_ncci_table[i + 1];
|
|
plci->inc_dis_ncci_table[MAX_CHANNELS_PER_PLCI - 1] = 0;
|
|
|
|
ncci_free_receive_buffers(plci, ncci);
|
|
|
|
if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) {
|
|
if (plci->State == SUSPENDING) {
|
|
sendf(plci->appl,
|
|
_FACILITY_I,
|
|
Id & 0xffffL,
|
|
0,
|
|
"ws", (word)3, "\x03\x04\x00\x00");
|
|
sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
|
|
}
|
|
plci_remove(plci);
|
|
plci->State = IDLE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
|
|
&& ((plci->B3_prot == 4) || (plci->B3_prot == 5))
|
|
&& (a->ncci_state[ncci] == INC_DIS_PENDING))
|
|
{
|
|
ncci_free_receive_buffers(plci, ncci);
|
|
|
|
nl_req_ncci(plci, N_EDATA, (byte)ncci);
|
|
|
|
plci->adapter->ncci_state[ncci] = IDLE;
|
|
start_internal_command(Id, plci, fax_disconnect_command);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static byte data_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
NCCI *ncci_ptr;
|
|
DATA_B3_DESC *data;
|
|
word Info;
|
|
word ncci;
|
|
word i;
|
|
|
|
dbug(1, dprintf("data_b3_req"));
|
|
|
|
Info = _WRONG_IDENTIFIER;
|
|
ncci = (word)(Id >> 16);
|
|
dbug(1, dprintf("ncci=0x%x, plci=0x%x", ncci, plci));
|
|
|
|
if (plci && ncci)
|
|
{
|
|
Info = _WRONG_STATE;
|
|
if ((a->ncci_state[ncci] == CONNECTED)
|
|
|| (a->ncci_state[ncci] == INC_ACT_PENDING))
|
|
{
|
|
/* queue data */
|
|
ncci_ptr = &(a->ncci[ncci]);
|
|
i = ncci_ptr->data_out + ncci_ptr->data_pending;
|
|
if (i >= MAX_DATA_B3)
|
|
i -= MAX_DATA_B3;
|
|
data = &(ncci_ptr->DBuffer[i]);
|
|
data->Number = Number;
|
|
if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
|
|
&& (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
|
|
{
|
|
|
|
data->P = (byte *)(long)(*((dword *)(parms[0].info)));
|
|
|
|
}
|
|
else
|
|
data->P = TransmitBufferSet(appl, *(dword *)parms[0].info);
|
|
data->Length = GET_WORD(parms[1].info);
|
|
data->Handle = GET_WORD(parms[2].info);
|
|
data->Flags = GET_WORD(parms[3].info);
|
|
(ncci_ptr->data_pending)++;
|
|
|
|
/* check for delivery confirmation */
|
|
if (data->Flags & 0x0004)
|
|
{
|
|
i = ncci_ptr->data_ack_out + ncci_ptr->data_ack_pending;
|
|
if (i >= MAX_DATA_ACK)
|
|
i -= MAX_DATA_ACK;
|
|
ncci_ptr->DataAck[i].Number = data->Number;
|
|
ncci_ptr->DataAck[i].Handle = data->Handle;
|
|
(ncci_ptr->data_ack_pending)++;
|
|
}
|
|
|
|
send_data(plci);
|
|
return false;
|
|
}
|
|
}
|
|
if (appl)
|
|
{
|
|
if (plci)
|
|
{
|
|
if ((((byte *)(parms[0].info)) >= ((byte *)(plci->msg_in_queue)))
|
|
&& (((byte *)(parms[0].info)) < ((byte *)(plci->msg_in_queue)) + sizeof(plci->msg_in_queue)))
|
|
{
|
|
|
|
TransmitBufferFree(appl, (byte *)(long)(*((dword *)(parms[0].info))));
|
|
|
|
}
|
|
}
|
|
sendf(appl,
|
|
_DATA_B3_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"ww", GET_WORD(parms[2].info), Info);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static byte data_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word n;
|
|
word ncci;
|
|
word NCCIcode;
|
|
|
|
dbug(1, dprintf("data_b3_res"));
|
|
|
|
ncci = (word)(Id >> 16);
|
|
if (plci && ncci) {
|
|
n = GET_WORD(parms[0].info);
|
|
dbug(1, dprintf("free(%d)", n));
|
|
NCCIcode = ncci | (((word) a->Id) << 8);
|
|
if (n < appl->MaxBuffer &&
|
|
appl->DataNCCI[n] == NCCIcode &&
|
|
(byte)(appl->DataFlags[n] >> 8) == plci->Id) {
|
|
dbug(1, dprintf("found"));
|
|
appl->DataNCCI[n] = 0;
|
|
|
|
if (channel_can_xon(plci, a->ncci_ch[ncci])) {
|
|
channel_request_xon(plci, a->ncci_ch[ncci]);
|
|
}
|
|
channel_xmit_xon(plci);
|
|
|
|
if (appl->DataFlags[n] & 4) {
|
|
nl_req_ncci(plci, N_DATA_ACK, (byte)ncci);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static byte reset_b3_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word Info;
|
|
word ncci;
|
|
|
|
dbug(1, dprintf("reset_b3_req"));
|
|
|
|
Info = _WRONG_IDENTIFIER;
|
|
ncci = (word)(Id >> 16);
|
|
if (plci && ncci)
|
|
{
|
|
Info = _WRONG_STATE;
|
|
switch (plci->B3_prot)
|
|
{
|
|
case B3_ISO8208:
|
|
case B3_X25_DCE:
|
|
if (a->ncci_state[ncci] == CONNECTED)
|
|
{
|
|
nl_req_ncci(plci, N_RESET, (byte)ncci);
|
|
send_req(plci);
|
|
Info = GOOD;
|
|
}
|
|
break;
|
|
case B3_TRANSPARENT:
|
|
if (a->ncci_state[ncci] == CONNECTED)
|
|
{
|
|
start_internal_command(Id, plci, reset_b3_command);
|
|
Info = GOOD;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
/* reset_b3 must result in a reset_b3_con & reset_b3_Ind */
|
|
sendf(appl,
|
|
_RESET_B3_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"w", Info);
|
|
return false;
|
|
}
|
|
|
|
static byte reset_b3_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word ncci;
|
|
|
|
dbug(1, dprintf("reset_b3_res"));
|
|
|
|
ncci = (word)(Id >> 16);
|
|
if (plci && ncci) {
|
|
switch (plci->B3_prot)
|
|
{
|
|
case B3_ISO8208:
|
|
case B3_X25_DCE:
|
|
if (a->ncci_state[ncci] == INC_RES_PENDING)
|
|
{
|
|
a->ncci_state[ncci] = CONNECTED;
|
|
nl_req_ncci(plci, N_RESET_ACK, (byte)ncci);
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static byte connect_b3_t90_a_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word ncci;
|
|
API_PARSE *ncpi;
|
|
byte req;
|
|
|
|
dbug(1, dprintf("connect_b3_t90_a_res"));
|
|
|
|
ncci = (word)(Id >> 16);
|
|
if (plci && ncci) {
|
|
if (a->ncci_state[ncci] == INC_ACT_PENDING) {
|
|
a->ncci_state[ncci] = CONNECTED;
|
|
}
|
|
else if (a->ncci_state[ncci] == INC_CON_PENDING) {
|
|
a->ncci_state[ncci] = CONNECTED;
|
|
|
|
req = N_CONNECT_ACK;
|
|
|
|
/* parms[0]==0 for CAPI original message definition! */
|
|
if (parms[0].info) {
|
|
ncpi = &parms[1];
|
|
if (ncpi->length > 2) {
|
|
if (ncpi->info[1] & 1) req = N_CONNECT_ACK | N_D_BIT;
|
|
add_d(plci, (word)(ncpi->length - 3), &ncpi->info[4]);
|
|
}
|
|
}
|
|
nl_req_ncci(plci, req, (byte)ncci);
|
|
return 1;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
static byte select_b_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
word Info = 0;
|
|
word i;
|
|
byte tel;
|
|
API_PARSE bp_parms[7];
|
|
|
|
if (!plci || !msg)
|
|
{
|
|
Info = _WRONG_IDENTIFIER;
|
|
}
|
|
else
|
|
{
|
|
dbug(1, dprintf("select_b_req[%d],PLCI=0x%x,Tel=0x%x,NL=0x%x,appl=0x%x,sstate=0x%x",
|
|
msg->length, plci->Id, plci->tel, plci->NL.Id, plci->appl, plci->SuppState));
|
|
dbug(1, dprintf("PlciState=0x%x", plci->State));
|
|
for (i = 0; i < 7; i++) bp_parms[i].length = 0;
|
|
|
|
/* check if no channel is open, no B3 connected only */
|
|
if ((plci->State == IDLE) || (plci->State == OUTG_DIS_PENDING) || (plci->State == INC_DIS_PENDING)
|
|
|| (plci->SuppState != IDLE) || plci->channels || plci->nl_remove_id)
|
|
{
|
|
Info = _WRONG_STATE;
|
|
}
|
|
/* check message format and fill bp_parms pointer */
|
|
else if (msg->length && api_parse(&msg->info[1], (word)msg->length, "wwwsss", bp_parms))
|
|
{
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
else
|
|
{
|
|
if ((plci->State == INC_CON_PENDING) || (plci->State == INC_CON_ALERT)) /* send alert tone inband to the network, */
|
|
{ /* e.g. Qsig or RBS or Cornet-N or xess PRI */
|
|
if (Id & EXT_CONTROLLER)
|
|
{
|
|
sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", 0x2002); /* wrong controller */
|
|
return 0;
|
|
}
|
|
plci->State = INC_CON_CONNECTED_ALERT;
|
|
plci->appl = appl;
|
|
clear_c_ind_mask_bit(plci, (word)(appl->Id - 1));
|
|
dump_c_ind_mask(plci);
|
|
for (i = 0; i < max_appl; i++) /* disconnect the other appls */
|
|
{ /* its quasi a connect */
|
|
if (test_c_ind_mask_bit(plci, i))
|
|
sendf(&application[i], _DISCONNECT_I, Id, 0, "w", _OTHER_APPL_CONNECTED);
|
|
}
|
|
}
|
|
|
|
api_save_msg(msg, "s", &plci->saved_msg);
|
|
tel = plci->tel;
|
|
if (Id & EXT_CONTROLLER)
|
|
{
|
|
if (tel) /* external controller in use by this PLCI */
|
|
{
|
|
if (a->AdvSignalAppl && a->AdvSignalAppl != appl)
|
|
{
|
|
dbug(1, dprintf("Ext_Ctrl in use 1"));
|
|
Info = _WRONG_STATE;
|
|
}
|
|
}
|
|
else /* external controller NOT in use by this PLCI ? */
|
|
{
|
|
if (a->AdvSignalPLCI)
|
|
{
|
|
dbug(1, dprintf("Ext_Ctrl in use 2"));
|
|
Info = _WRONG_STATE;
|
|
}
|
|
else /* activate the codec */
|
|
{
|
|
dbug(1, dprintf("Ext_Ctrl start"));
|
|
if (AdvCodecSupport(a, plci, appl, 0))
|
|
{
|
|
dbug(1, dprintf("Error in codec procedures"));
|
|
Info = _WRONG_STATE;
|
|
}
|
|
else if (plci->spoofed_msg == SPOOFING_REQUIRED) /* wait until codec is active */
|
|
{
|
|
plci->spoofed_msg = AWAITING_SELECT_B;
|
|
plci->internal_command = BLOCK_PLCI; /* lock other commands */
|
|
plci->command = 0;
|
|
dbug(1, dprintf("continue if codec loaded"));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else /* external controller bit is OFF */
|
|
{
|
|
if (tel) /* external controller in use, need to switch off */
|
|
{
|
|
if (a->AdvSignalAppl == appl)
|
|
{
|
|
CodecIdCheck(a, plci);
|
|
plci->tel = 0;
|
|
plci->adv_nl = 0;
|
|
dbug(1, dprintf("Ext_Ctrl disable"));
|
|
}
|
|
else
|
|
{
|
|
dbug(1, dprintf("Ext_Ctrl not requested"));
|
|
}
|
|
}
|
|
}
|
|
if (!Info)
|
|
{
|
|
if (plci->call_dir & CALL_DIR_OUT)
|
|
plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
|
|
else if (plci->call_dir & CALL_DIR_IN)
|
|
plci->call_dir = CALL_DIR_IN | CALL_DIR_ANSWER;
|
|
start_internal_command(Id, plci, select_b_command);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
sendf(appl, _SELECT_B_REQ | CONFIRM, Id, Number, "w", Info);
|
|
return false;
|
|
}
|
|
|
|
static byte manufacturer_req(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *parms)
|
|
{
|
|
word command;
|
|
word i;
|
|
word ncci;
|
|
API_PARSE *m;
|
|
API_PARSE m_parms[5];
|
|
word codec;
|
|
byte req;
|
|
byte ch;
|
|
byte dir;
|
|
static byte chi[2] = {0x01, 0x00};
|
|
static byte lli[2] = {0x01, 0x00};
|
|
static byte codec_cai[2] = {0x01, 0x01};
|
|
static byte null_msg = {0};
|
|
static API_PARSE null_parms = { 0, &null_msg };
|
|
PLCI *v_plci;
|
|
word Info = 0;
|
|
|
|
dbug(1, dprintf("manufacturer_req"));
|
|
for (i = 0; i < 5; i++) m_parms[i].length = 0;
|
|
|
|
if (GET_DWORD(parms[0].info) != _DI_MANU_ID) {
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
command = GET_WORD(parms[1].info);
|
|
m = &parms[2];
|
|
if (!Info)
|
|
{
|
|
switch (command) {
|
|
case _DI_ASSIGN_PLCI:
|
|
if (api_parse(&m->info[1], (word)m->length, "wbbs", m_parms)) {
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
codec = GET_WORD(m_parms[0].info);
|
|
ch = m_parms[1].info[0];
|
|
dir = m_parms[2].info[0];
|
|
if ((i = get_plci(a))) {
|
|
plci = &a->plci[i - 1];
|
|
plci->appl = appl;
|
|
plci->command = _MANUFACTURER_R;
|
|
plci->m_command = command;
|
|
plci->number = Number;
|
|
plci->State = LOCAL_CONNECT;
|
|
Id = (((word)plci->Id << 8) | plci->adapter->Id | 0x80);
|
|
dbug(1, dprintf("ManCMD,plci=0x%x", Id));
|
|
|
|
if ((ch == 1 || ch == 2) && (dir <= 2)) {
|
|
chi[1] = (byte)(0x80 | ch);
|
|
lli[1] = 0;
|
|
plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
|
|
switch (codec)
|
|
{
|
|
case 0:
|
|
Info = add_b1(plci, &m_parms[3], 0, 0);
|
|
break;
|
|
case 1:
|
|
add_p(plci, CAI, codec_cai);
|
|
break;
|
|
/* manual 'swich on' to the codec support without signalling */
|
|
/* first 'assign plci' with this function, then use */
|
|
case 2:
|
|
if (AdvCodecSupport(a, plci, appl, 0)) {
|
|
Info = _RESOURCE_ERROR;
|
|
}
|
|
else {
|
|
Info = add_b1(plci, &null_parms, 0, B1_FACILITY_LOCAL);
|
|
lli[1] = 0x10; /* local call codec stream */
|
|
}
|
|
break;
|
|
}
|
|
|
|
plci->State = LOCAL_CONNECT;
|
|
plci->manufacturer = true;
|
|
plci->command = _MANUFACTURER_R;
|
|
plci->m_command = command;
|
|
plci->number = Number;
|
|
|
|
if (!Info)
|
|
{
|
|
add_p(plci, LLI, lli);
|
|
add_p(plci, CHI, chi);
|
|
add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(plci, ASSIGN, DSIG_ID);
|
|
|
|
if (!codec)
|
|
{
|
|
Info = add_b23(plci, &m_parms[3]);
|
|
if (!Info)
|
|
{
|
|
nl_req_ncci(plci, ASSIGN, 0);
|
|
send_req(plci);
|
|
}
|
|
}
|
|
if (!Info)
|
|
{
|
|
dbug(1, dprintf("dir=0x%x,spoof=0x%x", dir, plci->spoofed_msg));
|
|
if (plci->spoofed_msg == SPOOFING_REQUIRED)
|
|
{
|
|
api_save_msg(m_parms, "wbbs", &plci->saved_msg);
|
|
plci->spoofed_msg = AWAITING_MANUF_CON;
|
|
plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
|
|
plci->command = 0;
|
|
send_req(plci);
|
|
return false;
|
|
}
|
|
if (dir == 1) {
|
|
sig_req(plci, CALL_REQ, 0);
|
|
}
|
|
else if (!dir) {
|
|
sig_req(plci, LISTEN_REQ, 0);
|
|
}
|
|
send_req(plci);
|
|
}
|
|
else
|
|
{
|
|
sendf(appl,
|
|
_MANUFACTURER_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"dww", _DI_MANU_ID, command, Info);
|
|
return 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else Info = _OUT_OF_PLCI;
|
|
break;
|
|
|
|
case _DI_IDI_CTRL:
|
|
if (!plci)
|
|
{
|
|
Info = _WRONG_IDENTIFIER;
|
|
break;
|
|
}
|
|
if (api_parse(&m->info[1], (word)m->length, "bs", m_parms)) {
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
req = m_parms[0].info[0];
|
|
plci->command = _MANUFACTURER_R;
|
|
plci->m_command = command;
|
|
plci->number = Number;
|
|
if (req == CALL_REQ)
|
|
{
|
|
plci->b_channel = getChannel(&m_parms[1]);
|
|
mixer_set_bchannel_id_esc(plci, plci->b_channel);
|
|
if (plci->spoofed_msg == SPOOFING_REQUIRED)
|
|
{
|
|
plci->spoofed_msg = CALL_REQ | AWAITING_MANUF_CON;
|
|
plci->internal_command = BLOCK_PLCI; /* reject other req meanwhile */
|
|
plci->command = 0;
|
|
break;
|
|
}
|
|
}
|
|
else if (req == LAW_REQ)
|
|
{
|
|
plci->cr_enquiry = true;
|
|
}
|
|
add_ss(plci, FTY, &m_parms[1]);
|
|
sig_req(plci, req, 0);
|
|
send_req(plci);
|
|
if (req == HANGUP)
|
|
{
|
|
if (plci->NL.Id && !plci->nl_remove_id)
|
|
{
|
|
if (plci->channels)
|
|
{
|
|
for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
|
|
{
|
|
if ((a->ncci_plci[ncci] == plci->Id) && (a->ncci_state[ncci] == CONNECTED))
|
|
{
|
|
a->ncci_state[ncci] = OUTG_DIS_PENDING;
|
|
cleanup_ncci_data(plci, ncci);
|
|
nl_req_ncci(plci, N_DISC, (byte)ncci);
|
|
}
|
|
}
|
|
}
|
|
mixer_remove(plci);
|
|
nl_req_ncci(plci, REMOVE, 0);
|
|
send_req(plci);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case _DI_SIG_CTRL:
|
|
/* signalling control for loop activation B-channel */
|
|
if (!plci)
|
|
{
|
|
Info = _WRONG_IDENTIFIER;
|
|
break;
|
|
}
|
|
if (m->length) {
|
|
plci->command = _MANUFACTURER_R;
|
|
plci->number = Number;
|
|
add_ss(plci, FTY, m);
|
|
sig_req(plci, SIG_CTRL, 0);
|
|
send_req(plci);
|
|
}
|
|
else Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
|
|
case _DI_RXT_CTRL:
|
|
/* activation control for receiver/transmitter B-channel */
|
|
if (!plci)
|
|
{
|
|
Info = _WRONG_IDENTIFIER;
|
|
break;
|
|
}
|
|
if (m->length) {
|
|
plci->command = _MANUFACTURER_R;
|
|
plci->number = Number;
|
|
add_ss(plci, FTY, m);
|
|
sig_req(plci, DSP_CTRL, 0);
|
|
send_req(plci);
|
|
}
|
|
else Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
|
|
case _DI_ADV_CODEC:
|
|
case _DI_DSP_CTRL:
|
|
/* TEL_CTRL commands to support non standard adjustments: */
|
|
/* Ring on/off, Handset micro volume, external micro vol. */
|
|
/* handset+external speaker volume, receiver+transm. gain,*/
|
|
/* handsfree on (hookinfo off), set mixer command */
|
|
|
|
if (command == _DI_ADV_CODEC)
|
|
{
|
|
if (!a->AdvCodecPLCI) {
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
v_plci = a->AdvCodecPLCI;
|
|
}
|
|
else
|
|
{
|
|
if (plci
|
|
&& (m->length >= 3)
|
|
&& (m->info[1] == 0x1c)
|
|
&& (m->info[2] >= 1))
|
|
{
|
|
if (m->info[3] == DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS)
|
|
{
|
|
if ((plci->tel != ADV_VOICE) || (plci != a->AdvSignalPLCI))
|
|
{
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
a->adv_voice_coef_length = m->info[2] - 1;
|
|
if (a->adv_voice_coef_length > m->length - 3)
|
|
a->adv_voice_coef_length = (byte)(m->length - 3);
|
|
if (a->adv_voice_coef_length > ADV_VOICE_COEF_BUFFER_SIZE)
|
|
a->adv_voice_coef_length = ADV_VOICE_COEF_BUFFER_SIZE;
|
|
for (i = 0; i < a->adv_voice_coef_length; i++)
|
|
a->adv_voice_coef_buffer[i] = m->info[4 + i];
|
|
if (plci->B1_facilities & B1_FACILITY_VOICE)
|
|
adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE);
|
|
break;
|
|
}
|
|
else if (m->info[3] == DSP_CTRL_SET_DTMF_PARAMETERS)
|
|
{
|
|
if (!(a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_PARAMETERS))
|
|
{
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
|
|
plci->dtmf_parameter_length = m->info[2] - 1;
|
|
if (plci->dtmf_parameter_length > m->length - 3)
|
|
plci->dtmf_parameter_length = (byte)(m->length - 3);
|
|
if (plci->dtmf_parameter_length > DTMF_PARAMETER_BUFFER_SIZE)
|
|
plci->dtmf_parameter_length = DTMF_PARAMETER_BUFFER_SIZE;
|
|
for (i = 0; i < plci->dtmf_parameter_length; i++)
|
|
plci->dtmf_parameter_buffer[i] = m->info[4 + i];
|
|
if (plci->B1_facilities & B1_FACILITY_DTMFR)
|
|
dtmf_parameter_write(plci);
|
|
break;
|
|
|
|
}
|
|
}
|
|
v_plci = plci;
|
|
}
|
|
|
|
if (!v_plci)
|
|
{
|
|
Info = _WRONG_IDENTIFIER;
|
|
break;
|
|
}
|
|
if (m->length) {
|
|
add_ss(v_plci, FTY, m);
|
|
sig_req(v_plci, TEL_CTRL, 0);
|
|
send_req(v_plci);
|
|
}
|
|
else Info = _WRONG_MESSAGE_FORMAT;
|
|
|
|
break;
|
|
|
|
case _DI_OPTIONS_REQUEST:
|
|
if (api_parse(&m->info[1], (word)m->length, "d", m_parms)) {
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
if (GET_DWORD(m_parms[0].info) & ~a->man_profile.private_options)
|
|
{
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
a->requested_options_table[appl->Id - 1] = GET_DWORD(m_parms[0].info);
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
}
|
|
|
|
sendf(appl,
|
|
_MANUFACTURER_R | CONFIRM,
|
|
Id,
|
|
Number,
|
|
"dww", _DI_MANU_ID, command, Info);
|
|
return false;
|
|
}
|
|
|
|
|
|
static byte manufacturer_res(dword Id, word Number, DIVA_CAPI_ADAPTER *a,
|
|
PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
word indication;
|
|
|
|
API_PARSE m_parms[3];
|
|
API_PARSE *ncpi;
|
|
API_PARSE fax_parms[9];
|
|
word i;
|
|
byte len;
|
|
|
|
|
|
dbug(1, dprintf("manufacturer_res"));
|
|
|
|
if ((msg[0].length == 0)
|
|
|| (msg[1].length == 0)
|
|
|| (GET_DWORD(msg[0].info) != _DI_MANU_ID))
|
|
{
|
|
return false;
|
|
}
|
|
indication = GET_WORD(msg[1].info);
|
|
switch (indication)
|
|
{
|
|
|
|
case _DI_NEGOTIATE_B3:
|
|
if (!plci)
|
|
break;
|
|
if (((plci->B3_prot != 4) && (plci->B3_prot != 5))
|
|
|| !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
|
|
{
|
|
dbug(1, dprintf("wrong state for NEGOTIATE_B3 parameters"));
|
|
break;
|
|
}
|
|
if (api_parse(&msg[2].info[1], msg[2].length, "ws", m_parms))
|
|
{
|
|
dbug(1, dprintf("wrong format in NEGOTIATE_B3 parameters"));
|
|
break;
|
|
}
|
|
ncpi = &m_parms[1];
|
|
len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
|
|
if (plci->fax_connect_info_length < len)
|
|
{
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->station_id_len = 0;
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->head_line_len = 0;
|
|
}
|
|
if (api_parse(&ncpi->info[1], ncpi->length, "wwwwssss", fax_parms))
|
|
{
|
|
dbug(1, dprintf("non-standard facilities info missing or wrong format"));
|
|
}
|
|
else
|
|
{
|
|
if (plci->fax_connect_info_length <= len)
|
|
plci->fax_connect_info_buffer[len] = 0;
|
|
len += 1 + plci->fax_connect_info_buffer[len];
|
|
if (plci->fax_connect_info_length <= len)
|
|
plci->fax_connect_info_buffer[len] = 0;
|
|
len += 1 + plci->fax_connect_info_buffer[len];
|
|
if ((fax_parms[7].length >= 3) && (fax_parms[7].info[1] >= 2))
|
|
plci->nsf_control_bits = GET_WORD(&fax_parms[7].info[2]);
|
|
plci->fax_connect_info_buffer[len++] = (byte)(fax_parms[7].length);
|
|
for (i = 0; i < fax_parms[7].length; i++)
|
|
plci->fax_connect_info_buffer[len++] = fax_parms[7].info[1 + i];
|
|
}
|
|
plci->fax_connect_info_length = len;
|
|
plci->fax_edata_ack_length = plci->fax_connect_info_length;
|
|
start_internal_command(Id, plci, fax_edata_ack_command);
|
|
break;
|
|
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* IDI callback function */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
void callback(ENTITY *e)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
APPL *appl;
|
|
PLCI *plci;
|
|
CAPI_MSG *m;
|
|
word i, j;
|
|
byte rc;
|
|
byte ch;
|
|
byte req;
|
|
byte global_req;
|
|
int no_cancel_rc;
|
|
|
|
dbug(1, dprintf("%x:CB(%x:Req=%x,Rc=%x,Ind=%x)",
|
|
(e->user[0] + 1) & 0x7fff, e->Id, e->Req, e->Rc, e->Ind));
|
|
|
|
a = &(adapter[(byte)e->user[0]]);
|
|
plci = &(a->plci[e->user[1]]);
|
|
no_cancel_rc = DIVA_CAPI_SUPPORTS_NO_CANCEL(a);
|
|
|
|
/*
|
|
If new protocol code and new XDI is used then CAPI should work
|
|
fully in accordance with IDI cpec an look on callback field instead
|
|
of Rc field for return codes.
|
|
*/
|
|
if (((e->complete == 0xff) && no_cancel_rc) ||
|
|
(e->Rc && !no_cancel_rc)) {
|
|
rc = e->Rc;
|
|
ch = e->RcCh;
|
|
req = e->Req;
|
|
e->Rc = 0;
|
|
|
|
if (e->user[0] & 0x8000)
|
|
{
|
|
/*
|
|
If REMOVE request was sent then we have to wait until
|
|
return code with Id set to zero arrives.
|
|
All other return codes should be ignored.
|
|
*/
|
|
if (req == REMOVE)
|
|
{
|
|
if (e->Id)
|
|
{
|
|
dbug(1, dprintf("cancel RC in REMOVE state"));
|
|
return;
|
|
}
|
|
channel_flow_control_remove(plci);
|
|
for (i = 0; i < 256; i++)
|
|
{
|
|
if (a->FlowControlIdTable[i] == plci->nl_remove_id)
|
|
a->FlowControlIdTable[i] = 0;
|
|
}
|
|
plci->nl_remove_id = 0;
|
|
if (plci->rx_dma_descriptor > 0) {
|
|
diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1);
|
|
plci->rx_dma_descriptor = 0;
|
|
}
|
|
}
|
|
if (rc == OK_FC)
|
|
{
|
|
a->FlowControlIdTable[ch] = e->Id;
|
|
a->FlowControlSkipTable[ch] = 0;
|
|
|
|
a->ch_flow_control[ch] |= N_OK_FC_PENDING;
|
|
a->ch_flow_plci[ch] = plci->Id;
|
|
plci->nl_req = 0;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
Cancel return codes self, if feature was requested
|
|
*/
|
|
if (no_cancel_rc && (a->FlowControlIdTable[ch] == e->Id) && e->Id) {
|
|
a->FlowControlIdTable[ch] = 0;
|
|
if ((rc == OK) && a->FlowControlSkipTable[ch]) {
|
|
dbug(3, dprintf("XDI CAPI: RC cancelled Id:0x02, Ch:%02x", e->Id, ch));
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (a->ch_flow_control[ch] & N_OK_FC_PENDING)
|
|
{
|
|
a->ch_flow_control[ch] &= ~N_OK_FC_PENDING;
|
|
if (ch == e->ReqCh)
|
|
plci->nl_req = 0;
|
|
}
|
|
else
|
|
plci->nl_req = 0;
|
|
}
|
|
if (plci->nl_req)
|
|
control_rc(plci, 0, rc, ch, 0, true);
|
|
else
|
|
{
|
|
if (req == N_XON)
|
|
{
|
|
channel_x_on(plci, ch);
|
|
if (plci->internal_command)
|
|
control_rc(plci, req, rc, ch, 0, true);
|
|
}
|
|
else
|
|
{
|
|
if (plci->nl_global_req)
|
|
{
|
|
global_req = plci->nl_global_req;
|
|
plci->nl_global_req = 0;
|
|
if (rc != ASSIGN_OK) {
|
|
e->Id = 0;
|
|
if (plci->rx_dma_descriptor > 0) {
|
|
diva_free_dma_descriptor(plci, plci->rx_dma_descriptor - 1);
|
|
plci->rx_dma_descriptor = 0;
|
|
}
|
|
}
|
|
channel_xmit_xon(plci);
|
|
control_rc(plci, 0, rc, ch, global_req, true);
|
|
}
|
|
else if (plci->data_sent)
|
|
{
|
|
channel_xmit_xon(plci);
|
|
plci->data_sent = false;
|
|
plci->NL.XNum = 1;
|
|
data_rc(plci, ch);
|
|
if (plci->internal_command)
|
|
control_rc(plci, req, rc, ch, 0, true);
|
|
}
|
|
else
|
|
{
|
|
channel_xmit_xon(plci);
|
|
control_rc(plci, req, rc, ch, 0, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
If REMOVE request was sent then we have to wait until
|
|
return code with Id set to zero arrives.
|
|
All other return codes should be ignored.
|
|
*/
|
|
if (req == REMOVE)
|
|
{
|
|
if (e->Id)
|
|
{
|
|
dbug(1, dprintf("cancel RC in REMOVE state"));
|
|
return;
|
|
}
|
|
plci->sig_remove_id = 0;
|
|
}
|
|
plci->sig_req = 0;
|
|
if (plci->sig_global_req)
|
|
{
|
|
global_req = plci->sig_global_req;
|
|
plci->sig_global_req = 0;
|
|
if (rc != ASSIGN_OK)
|
|
e->Id = 0;
|
|
channel_xmit_xon(plci);
|
|
control_rc(plci, 0, rc, ch, global_req, false);
|
|
}
|
|
else
|
|
{
|
|
channel_xmit_xon(plci);
|
|
control_rc(plci, req, rc, ch, 0, false);
|
|
}
|
|
}
|
|
/*
|
|
Again: in accordance with IDI spec Rc and Ind can't be delivered in the
|
|
same callback. Also if new XDI and protocol code used then jump
|
|
direct to finish.
|
|
*/
|
|
if (no_cancel_rc) {
|
|
channel_xmit_xon(plci);
|
|
goto capi_callback_suffix;
|
|
}
|
|
}
|
|
|
|
channel_xmit_xon(plci);
|
|
|
|
if (e->Ind) {
|
|
if (e->user[0] & 0x8000) {
|
|
byte Ind = e->Ind & 0x0f;
|
|
byte Ch = e->IndCh;
|
|
if (((Ind == N_DISC) || (Ind == N_DISC_ACK)) &&
|
|
(a->ch_flow_plci[Ch] == plci->Id)) {
|
|
if (a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK) {
|
|
dbug(3, dprintf("XDI CAPI: I: pending N-XON Ch:%02x", Ch));
|
|
}
|
|
a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
|
|
}
|
|
nl_ind(plci);
|
|
if ((e->RNR != 1) &&
|
|
(a->ch_flow_plci[Ch] == plci->Id) &&
|
|
(a->ch_flow_control[Ch] & N_RX_FLOW_CONTROL_MASK)) {
|
|
a->ch_flow_control[Ch] &= ~N_RX_FLOW_CONTROL_MASK;
|
|
dbug(3, dprintf("XDI CAPI: I: remove faked N-XON Ch:%02x", Ch));
|
|
}
|
|
} else {
|
|
sig_ind(plci);
|
|
}
|
|
e->Ind = 0;
|
|
}
|
|
|
|
capi_callback_suffix:
|
|
|
|
while (!plci->req_in
|
|
&& !plci->internal_command
|
|
&& (plci->msg_in_write_pos != plci->msg_in_read_pos))
|
|
{
|
|
j = (plci->msg_in_read_pos == plci->msg_in_wrap_pos) ? 0 : plci->msg_in_read_pos;
|
|
|
|
i = (((CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]))->header.length + 3) & 0xfffc;
|
|
|
|
m = (CAPI_MSG *)(&((byte *)(plci->msg_in_queue))[j]);
|
|
appl = *((APPL **)(&((byte *)(plci->msg_in_queue))[j + i]));
|
|
dbug(1, dprintf("dequeue msg(0x%04x) - write=%d read=%d wrap=%d",
|
|
m->header.command, plci->msg_in_write_pos, plci->msg_in_read_pos, plci->msg_in_wrap_pos));
|
|
if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
|
|
{
|
|
plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
|
|
plci->msg_in_read_pos = i + MSG_IN_OVERHEAD;
|
|
}
|
|
else
|
|
{
|
|
plci->msg_in_read_pos = j + i + MSG_IN_OVERHEAD;
|
|
}
|
|
if (plci->msg_in_read_pos == plci->msg_in_write_pos)
|
|
{
|
|
plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
|
|
plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
|
|
}
|
|
else if (plci->msg_in_read_pos == plci->msg_in_wrap_pos)
|
|
{
|
|
plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
|
|
plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
|
|
}
|
|
i = api_put(appl, m);
|
|
if (i != 0)
|
|
{
|
|
if (m->header.command == _DATA_B3_R)
|
|
|
|
TransmitBufferFree(appl, (byte *)(long)(m->info.data_b3_req.Data));
|
|
|
|
dbug(1, dprintf("Error 0x%04x from msg(0x%04x)", i, m->header.command));
|
|
break;
|
|
}
|
|
|
|
if (plci->li_notify_update)
|
|
{
|
|
plci->li_notify_update = false;
|
|
mixer_notify_update(plci, false);
|
|
}
|
|
|
|
}
|
|
send_data(plci);
|
|
send_req(plci);
|
|
}
|
|
|
|
|
|
static void control_rc(PLCI *plci, byte req, byte rc, byte ch, byte global_req,
|
|
byte nl_rc)
|
|
{
|
|
dword Id;
|
|
dword rId;
|
|
word Number;
|
|
word Info = 0;
|
|
word i;
|
|
word ncci;
|
|
DIVA_CAPI_ADAPTER *a;
|
|
APPL *appl;
|
|
PLCI *rplci;
|
|
byte SSparms[] = "\x05\x00\x00\x02\x00\x00";
|
|
byte SSstruct[] = "\x09\x00\x00\x06\x00\x00\x00\x00\x00\x00";
|
|
|
|
if (!plci) {
|
|
dbug(0, dprintf("A: control_rc, no plci %02x:%02x:%02x:%02x:%02x", req, rc, ch, global_req, nl_rc));
|
|
return;
|
|
}
|
|
dbug(1, dprintf("req0_in/out=%d/%d", plci->req_in, plci->req_out));
|
|
if (plci->req_in != plci->req_out)
|
|
{
|
|
if (nl_rc || (global_req != ASSIGN) || (rc == ASSIGN_OK))
|
|
{
|
|
dbug(1, dprintf("req_1return"));
|
|
return;
|
|
}
|
|
/* cancel outstanding request on the PLCI after SIG ASSIGN failure */
|
|
}
|
|
plci->req_in = plci->req_in_start = plci->req_out = 0;
|
|
dbug(1, dprintf("control_rc"));
|
|
|
|
appl = plci->appl;
|
|
a = plci->adapter;
|
|
ncci = a->ch_ncci[ch];
|
|
if (appl)
|
|
{
|
|
Id = (((dword)(ncci ? ncci : ch)) << 16) | ((word)plci->Id << 8) | a->Id;
|
|
if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER;
|
|
Number = plci->number;
|
|
dbug(1, dprintf("Contr_RC-Id=%08lx,plci=%x,tel=%x, entity=0x%x, command=0x%x, int_command=0x%x", Id, plci->Id, plci->tel, plci->Sig.Id, plci->command, plci->internal_command));
|
|
dbug(1, dprintf("channels=0x%x", plci->channels));
|
|
if (plci_remove_check(plci))
|
|
return;
|
|
if (req == REMOVE && rc == ASSIGN_OK)
|
|
{
|
|
sig_req(plci, HANGUP, 0);
|
|
sig_req(plci, REMOVE, 0);
|
|
send_req(plci);
|
|
}
|
|
if (plci->command)
|
|
{
|
|
switch (plci->command)
|
|
{
|
|
case C_HOLD_REQ:
|
|
dbug(1, dprintf("HoldRC=0x%x", rc));
|
|
SSparms[1] = (byte)S_HOLD;
|
|
if (rc != OK)
|
|
{
|
|
plci->SuppState = IDLE;
|
|
Info = 0x2001;
|
|
}
|
|
sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms);
|
|
break;
|
|
|
|
case C_RETRIEVE_REQ:
|
|
dbug(1, dprintf("RetrieveRC=0x%x", rc));
|
|
SSparms[1] = (byte)S_RETRIEVE;
|
|
if (rc != OK)
|
|
{
|
|
plci->SuppState = CALL_HELD;
|
|
Info = 0x2001;
|
|
}
|
|
sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", Info, 3, SSparms);
|
|
break;
|
|
|
|
case _INFO_R:
|
|
dbug(1, dprintf("InfoRC=0x%x", rc));
|
|
if (rc != OK) Info = _WRONG_STATE;
|
|
sendf(appl, _INFO_R | CONFIRM, Id, Number, "w", Info);
|
|
break;
|
|
|
|
case _CONNECT_R:
|
|
dbug(1, dprintf("Connect_R=0x%x/0x%x/0x%x/0x%x", req, rc, global_req, nl_rc));
|
|
if (plci->State == INC_DIS_PENDING)
|
|
break;
|
|
if (plci->Sig.Id != 0xff)
|
|
{
|
|
if (((global_req == ASSIGN) && (rc != ASSIGN_OK))
|
|
|| (!nl_rc && (req == CALL_REQ) && (rc != OK)))
|
|
{
|
|
dbug(1, dprintf("No more IDs/Call_Req failed"));
|
|
sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
|
|
plci_remove(plci);
|
|
plci->State = IDLE;
|
|
break;
|
|
}
|
|
if (plci->State != LOCAL_CONNECT) plci->State = OUTG_CON_PENDING;
|
|
sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
|
|
}
|
|
else /* D-ch activation */
|
|
{
|
|
if (rc != ASSIGN_OK)
|
|
{
|
|
dbug(1, dprintf("No more IDs/X.25 Call_Req failed"));
|
|
sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
|
|
plci_remove(plci);
|
|
plci->State = IDLE;
|
|
break;
|
|
}
|
|
sendf(appl, _CONNECT_R | CONFIRM, Id, Number, "w", 0);
|
|
sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "sss", "", "", "");
|
|
plci->State = INC_ACT_PENDING;
|
|
}
|
|
break;
|
|
|
|
case _CONNECT_I | RESPONSE:
|
|
if (plci->State != INC_DIS_PENDING)
|
|
plci->State = INC_CON_ACCEPT;
|
|
break;
|
|
|
|
case _DISCONNECT_R:
|
|
if (plci->State == INC_DIS_PENDING)
|
|
break;
|
|
if (plci->Sig.Id != 0xff)
|
|
{
|
|
plci->State = OUTG_DIS_PENDING;
|
|
sendf(appl, _DISCONNECT_R | CONFIRM, Id, Number, "w", 0);
|
|
}
|
|
break;
|
|
|
|
case SUSPEND_REQ:
|
|
break;
|
|
|
|
case RESUME_REQ:
|
|
break;
|
|
|
|
case _CONNECT_B3_R:
|
|
if (rc != OK)
|
|
{
|
|
sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", _WRONG_IDENTIFIER);
|
|
break;
|
|
}
|
|
ncci = get_ncci(plci, ch, 0);
|
|
Id = (Id & 0xffff) | (((dword) ncci) << 16);
|
|
plci->channels++;
|
|
if (req == N_RESET)
|
|
{
|
|
a->ncci_state[ncci] = INC_ACT_PENDING;
|
|
sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
|
|
sendf(appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
|
|
}
|
|
else
|
|
{
|
|
a->ncci_state[ncci] = OUTG_CON_PENDING;
|
|
sendf(appl, _CONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
|
|
}
|
|
break;
|
|
|
|
case _CONNECT_B3_I | RESPONSE:
|
|
break;
|
|
|
|
case _RESET_B3_R:
|
|
/* sendf(appl, _RESET_B3_R | CONFIRM, Id, Number, "w", 0);*/
|
|
break;
|
|
|
|
case _DISCONNECT_B3_R:
|
|
sendf(appl, _DISCONNECT_B3_R | CONFIRM, Id, Number, "w", 0);
|
|
break;
|
|
|
|
case _MANUFACTURER_R:
|
|
break;
|
|
|
|
case PERM_LIST_REQ:
|
|
if (rc != OK)
|
|
{
|
|
Info = _WRONG_IDENTIFIER;
|
|
sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info);
|
|
plci_remove(plci);
|
|
}
|
|
else
|
|
sendf(plci->appl, _CONNECT_R | CONFIRM, Id, Number, "w", Info);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
plci->command = 0;
|
|
}
|
|
else if (plci->internal_command)
|
|
{
|
|
switch (plci->internal_command)
|
|
{
|
|
case BLOCK_PLCI:
|
|
return;
|
|
|
|
case GET_MWI_STATE:
|
|
if (rc == OK) /* command supported, wait for indication */
|
|
{
|
|
return;
|
|
}
|
|
plci_remove(plci);
|
|
break;
|
|
|
|
/* Get Supported Services */
|
|
case GETSERV_REQ_PEND:
|
|
if (rc == OK) /* command supported, wait for indication */
|
|
{
|
|
break;
|
|
}
|
|
PUT_DWORD(&SSstruct[6], MASK_TERMINAL_PORTABILITY);
|
|
sendf(appl, _FACILITY_R | CONFIRM, Id, Number, "wws", 0, 3, SSstruct);
|
|
plci_remove(plci);
|
|
break;
|
|
|
|
case INTERR_DIVERSION_REQ_PEND: /* Interrogate Parameters */
|
|
case INTERR_NUMBERS_REQ_PEND:
|
|
case CF_START_PEND: /* Call Forwarding Start pending */
|
|
case CF_STOP_PEND: /* Call Forwarding Stop pending */
|
|
case CCBS_REQUEST_REQ_PEND:
|
|
case CCBS_DEACTIVATE_REQ_PEND:
|
|
case CCBS_INTERROGATE_REQ_PEND:
|
|
switch (plci->internal_command)
|
|
{
|
|
case INTERR_DIVERSION_REQ_PEND:
|
|
SSparms[1] = S_INTERROGATE_DIVERSION;
|
|
break;
|
|
case INTERR_NUMBERS_REQ_PEND:
|
|
SSparms[1] = S_INTERROGATE_NUMBERS;
|
|
break;
|
|
case CF_START_PEND:
|
|
SSparms[1] = S_CALL_FORWARDING_START;
|
|
break;
|
|
case CF_STOP_PEND:
|
|
SSparms[1] = S_CALL_FORWARDING_STOP;
|
|
break;
|
|
case CCBS_REQUEST_REQ_PEND:
|
|
SSparms[1] = S_CCBS_REQUEST;
|
|
break;
|
|
case CCBS_DEACTIVATE_REQ_PEND:
|
|
SSparms[1] = S_CCBS_DEACTIVATE;
|
|
break;
|
|
case CCBS_INTERROGATE_REQ_PEND:
|
|
SSparms[1] = S_CCBS_INTERROGATE;
|
|
break;
|
|
}
|
|
if (global_req == ASSIGN)
|
|
{
|
|
dbug(1, dprintf("AssignDiversion_RC=0x%x/0x%x", req, rc));
|
|
return;
|
|
}
|
|
if (!plci->appl) break;
|
|
if (rc == ISDN_GUARD_REJ)
|
|
{
|
|
Info = _CAPI_GUARD_ERROR;
|
|
}
|
|
else if (rc != OK)
|
|
{
|
|
Info = _SUPPLEMENTARY_SERVICE_NOT_SUPPORTED;
|
|
}
|
|
sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7,
|
|
plci->number, "wws", Info, (word)3, SSparms);
|
|
if (Info) plci_remove(plci);
|
|
break;
|
|
|
|
/* 3pty conference pending */
|
|
case PTY_REQ_PEND:
|
|
if (!plci->relatedPTYPLCI) break;
|
|
rplci = plci->relatedPTYPLCI;
|
|
SSparms[1] = plci->ptyState;
|
|
rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
|
|
if (rplci->tel) rId |= EXT_CONTROLLER;
|
|
if (rc != OK)
|
|
{
|
|
Info = 0x300E; /* not supported */
|
|
plci->relatedPTYPLCI = NULL;
|
|
plci->ptyState = 0;
|
|
}
|
|
sendf(rplci->appl,
|
|
_FACILITY_R | CONFIRM,
|
|
rId,
|
|
plci->number,
|
|
"wws", Info, (word)3, SSparms);
|
|
break;
|
|
|
|
/* Explicit Call Transfer pending */
|
|
case ECT_REQ_PEND:
|
|
dbug(1, dprintf("ECT_RC=0x%x/0x%x", req, rc));
|
|
if (!plci->relatedPTYPLCI) break;
|
|
rplci = plci->relatedPTYPLCI;
|
|
SSparms[1] = S_ECT;
|
|
rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
|
|
if (rplci->tel) rId |= EXT_CONTROLLER;
|
|
if (rc != OK)
|
|
{
|
|
Info = 0x300E; /* not supported */
|
|
plci->relatedPTYPLCI = NULL;
|
|
plci->ptyState = 0;
|
|
}
|
|
sendf(rplci->appl,
|
|
_FACILITY_R | CONFIRM,
|
|
rId,
|
|
plci->number,
|
|
"wws", Info, (word)3, SSparms);
|
|
break;
|
|
|
|
case _MANUFACTURER_R:
|
|
dbug(1, dprintf("_Manufacturer_R=0x%x/0x%x", req, rc));
|
|
if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
|
|
{
|
|
dbug(1, dprintf("No more IDs"));
|
|
sendf(appl, _MANUFACTURER_R | CONFIRM, Id, Number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI);
|
|
plci_remove(plci); /* after codec init, internal codec commands pending */
|
|
}
|
|
break;
|
|
|
|
case _CONNECT_R:
|
|
dbug(1, dprintf("_Connect_R=0x%x/0x%x", req, rc));
|
|
if ((global_req == ASSIGN) && (rc != ASSIGN_OK))
|
|
{
|
|
dbug(1, dprintf("No more IDs"));
|
|
sendf(appl, _CONNECT_R | CONFIRM, Id & 0xffL, Number, "w", _OUT_OF_PLCI);
|
|
plci_remove(plci); /* after codec init, internal codec commands pending */
|
|
}
|
|
break;
|
|
|
|
case PERM_COD_HOOK: /* finished with Hook_Ind */
|
|
return;
|
|
|
|
case PERM_COD_CALL:
|
|
dbug(1, dprintf("***Codec Connect_Pending A, Rc = 0x%x", rc));
|
|
plci->internal_command = PERM_COD_CONN_PEND;
|
|
return;
|
|
|
|
case PERM_COD_ASSIGN:
|
|
dbug(1, dprintf("***Codec Assign A, Rc = 0x%x", rc));
|
|
if (rc != ASSIGN_OK) break;
|
|
sig_req(plci, CALL_REQ, 0);
|
|
send_req(plci);
|
|
plci->internal_command = PERM_COD_CALL;
|
|
return;
|
|
|
|
/* Null Call Reference Request pending */
|
|
case C_NCR_FAC_REQ:
|
|
dbug(1, dprintf("NCR_FAC=0x%x/0x%x", req, rc));
|
|
if (global_req == ASSIGN)
|
|
{
|
|
if (rc == ASSIGN_OK)
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE);
|
|
appl->NullCREnable = false;
|
|
plci_remove(plci);
|
|
}
|
|
}
|
|
else if (req == NCR_FACILITY)
|
|
{
|
|
if (rc == OK)
|
|
{
|
|
sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", 0);
|
|
}
|
|
else
|
|
{
|
|
sendf(appl, _INFO_R | CONFIRM, Id & 0xf, Number, "w", _WRONG_STATE);
|
|
appl->NullCREnable = false;
|
|
}
|
|
plci_remove(plci);
|
|
}
|
|
break;
|
|
|
|
case HOOK_ON_REQ:
|
|
if (plci->channels)
|
|
{
|
|
if (a->ncci_state[ncci] == CONNECTED)
|
|
{
|
|
a->ncci_state[ncci] = OUTG_DIS_PENDING;
|
|
cleanup_ncci_data(plci, ncci);
|
|
nl_req_ncci(plci, N_DISC, (byte)ncci);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case HOOK_OFF_REQ:
|
|
if (plci->State == INC_DIS_PENDING)
|
|
break;
|
|
sig_req(plci, CALL_REQ, 0);
|
|
send_req(plci);
|
|
plci->State = OUTG_CON_PENDING;
|
|
break;
|
|
|
|
|
|
case MWI_ACTIVATE_REQ_PEND:
|
|
case MWI_DEACTIVATE_REQ_PEND:
|
|
if (global_req == ASSIGN && rc == ASSIGN_OK)
|
|
{
|
|
dbug(1, dprintf("MWI_REQ assigned"));
|
|
return;
|
|
}
|
|
else if (rc != OK)
|
|
{
|
|
if (rc == WRONG_IE)
|
|
{
|
|
Info = 0x2007; /* Illegal message parameter coding */
|
|
dbug(1, dprintf("MWI_REQ invalid parameter"));
|
|
}
|
|
else
|
|
{
|
|
Info = 0x300B; /* not supported */
|
|
dbug(1, dprintf("MWI_REQ not supported"));
|
|
}
|
|
/* 0x3010: Request not allowed in this state */
|
|
PUT_WORD(&SSparms[4], 0x300E); /* SS not supported */
|
|
|
|
}
|
|
if (plci->internal_command == MWI_ACTIVATE_REQ_PEND)
|
|
{
|
|
PUT_WORD(&SSparms[1], S_MWI_ACTIVATE);
|
|
}
|
|
else PUT_WORD(&SSparms[1], S_MWI_DEACTIVATE);
|
|
|
|
if (plci->cr_enquiry)
|
|
{
|
|
sendf(plci->appl,
|
|
_FACILITY_R | CONFIRM,
|
|
Id & 0xf,
|
|
plci->number,
|
|
"wws", Info, (word)3, SSparms);
|
|
if (rc != OK) plci_remove(plci);
|
|
}
|
|
else
|
|
{
|
|
sendf(plci->appl,
|
|
_FACILITY_R | CONFIRM,
|
|
Id,
|
|
plci->number,
|
|
"wws", Info, (word)3, SSparms);
|
|
}
|
|
break;
|
|
|
|
case CONF_BEGIN_REQ_PEND:
|
|
case CONF_ADD_REQ_PEND:
|
|
case CONF_SPLIT_REQ_PEND:
|
|
case CONF_DROP_REQ_PEND:
|
|
case CONF_ISOLATE_REQ_PEND:
|
|
case CONF_REATTACH_REQ_PEND:
|
|
dbug(1, dprintf("CONF_RC=0x%x/0x%x", req, rc));
|
|
if ((plci->internal_command == CONF_ADD_REQ_PEND) && (!plci->relatedPTYPLCI)) break;
|
|
rplci = plci;
|
|
rId = Id;
|
|
switch (plci->internal_command)
|
|
{
|
|
case CONF_BEGIN_REQ_PEND:
|
|
SSparms[1] = S_CONF_BEGIN;
|
|
break;
|
|
case CONF_ADD_REQ_PEND:
|
|
SSparms[1] = S_CONF_ADD;
|
|
rplci = plci->relatedPTYPLCI;
|
|
rId = ((word)rplci->Id << 8) | rplci->adapter->Id;
|
|
break;
|
|
case CONF_SPLIT_REQ_PEND:
|
|
SSparms[1] = S_CONF_SPLIT;
|
|
break;
|
|
case CONF_DROP_REQ_PEND:
|
|
SSparms[1] = S_CONF_DROP;
|
|
break;
|
|
case CONF_ISOLATE_REQ_PEND:
|
|
SSparms[1] = S_CONF_ISOLATE;
|
|
break;
|
|
case CONF_REATTACH_REQ_PEND:
|
|
SSparms[1] = S_CONF_REATTACH;
|
|
break;
|
|
}
|
|
|
|
if (rc != OK)
|
|
{
|
|
Info = 0x300E; /* not supported */
|
|
plci->relatedPTYPLCI = NULL;
|
|
plci->ptyState = 0;
|
|
}
|
|
sendf(rplci->appl,
|
|
_FACILITY_R | CONFIRM,
|
|
rId,
|
|
plci->number,
|
|
"wws", Info, (word)3, SSparms);
|
|
break;
|
|
|
|
case VSWITCH_REQ_PEND:
|
|
if (rc != OK)
|
|
{
|
|
if (plci->relatedPTYPLCI)
|
|
{
|
|
plci->relatedPTYPLCI->vswitchstate = 0;
|
|
plci->relatedPTYPLCI->vsprot = 0;
|
|
plci->relatedPTYPLCI->vsprotdialect = 0;
|
|
}
|
|
plci->vswitchstate = 0;
|
|
plci->vsprot = 0;
|
|
plci->vsprotdialect = 0;
|
|
}
|
|
else
|
|
{
|
|
if (plci->relatedPTYPLCI &&
|
|
plci->vswitchstate == 1 &&
|
|
plci->relatedPTYPLCI->vswitchstate == 3) /* join complete */
|
|
plci->vswitchstate = 3;
|
|
}
|
|
break;
|
|
|
|
/* Call Deflection Request pending (SSCT) */
|
|
case CD_REQ_PEND:
|
|
SSparms[1] = S_CALL_DEFLECTION;
|
|
if (rc != OK)
|
|
{
|
|
Info = 0x300E; /* not supported */
|
|
plci->appl->CDEnable = 0;
|
|
}
|
|
sendf(plci->appl, _FACILITY_R | CONFIRM, Id,
|
|
plci->number, "wws", Info, (word)3, SSparms);
|
|
break;
|
|
|
|
case RTP_CONNECT_B3_REQ_COMMAND_2:
|
|
if (rc == OK)
|
|
{
|
|
ncci = get_ncci(plci, ch, 0);
|
|
Id = (Id & 0xffff) | (((dword) ncci) << 16);
|
|
plci->channels++;
|
|
a->ncci_state[ncci] = OUTG_CON_PENDING;
|
|
}
|
|
|
|
default:
|
|
if (plci->internal_command_queue[0])
|
|
{
|
|
(*(plci->internal_command_queue[0]))(Id, plci, rc);
|
|
if (plci->internal_command)
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
next_internal_command(Id, plci);
|
|
}
|
|
}
|
|
else /* appl==0 */
|
|
{
|
|
Id = ((word)plci->Id << 8) | plci->adapter->Id;
|
|
if (plci->tel) Id |= EXT_CONTROLLER;
|
|
|
|
switch (plci->internal_command)
|
|
{
|
|
case BLOCK_PLCI:
|
|
return;
|
|
|
|
case START_L1_SIG_ASSIGN_PEND:
|
|
case REM_L1_SIG_ASSIGN_PEND:
|
|
if (global_req == ASSIGN)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
dbug(1, dprintf("***L1 Req rem PLCI"));
|
|
plci->internal_command = 0;
|
|
sig_req(plci, REMOVE, 0);
|
|
send_req(plci);
|
|
}
|
|
break;
|
|
|
|
/* Call Deflection Request pending, just no appl ptr assigned */
|
|
case CD_REQ_PEND:
|
|
SSparms[1] = S_CALL_DEFLECTION;
|
|
if (rc != OK)
|
|
{
|
|
Info = 0x300E; /* not supported */
|
|
}
|
|
for (i = 0; i < max_appl; i++)
|
|
{
|
|
if (application[i].CDEnable)
|
|
{
|
|
if (!application[i].Id) application[i].CDEnable = 0;
|
|
else
|
|
{
|
|
sendf(&application[i], _FACILITY_R | CONFIRM, Id,
|
|
plci->number, "wws", Info, (word)3, SSparms);
|
|
if (Info) application[i].CDEnable = 0;
|
|
}
|
|
}
|
|
}
|
|
plci->internal_command = 0;
|
|
break;
|
|
|
|
case PERM_COD_HOOK: /* finished with Hook_Ind */
|
|
return;
|
|
|
|
case PERM_COD_CALL:
|
|
plci->internal_command = PERM_COD_CONN_PEND;
|
|
dbug(1, dprintf("***Codec Connect_Pending, Rc = 0x%x", rc));
|
|
return;
|
|
|
|
case PERM_COD_ASSIGN:
|
|
dbug(1, dprintf("***Codec Assign, Rc = 0x%x", rc));
|
|
plci->internal_command = 0;
|
|
if (rc != ASSIGN_OK) break;
|
|
plci->internal_command = PERM_COD_CALL;
|
|
sig_req(plci, CALL_REQ, 0);
|
|
send_req(plci);
|
|
return;
|
|
|
|
case LISTEN_SIG_ASSIGN_PEND:
|
|
if (rc == ASSIGN_OK)
|
|
{
|
|
plci->internal_command = 0;
|
|
dbug(1, dprintf("ListenCheck, new SIG_ID = 0x%x", plci->Sig.Id));
|
|
add_p(plci, ESC, "\x02\x18\x00"); /* support call waiting */
|
|
sig_req(plci, INDICATE_REQ, 0);
|
|
send_req(plci);
|
|
}
|
|
else
|
|
{
|
|
dbug(1, dprintf("ListenCheck failed (assignRc=0x%x)", rc));
|
|
a->listen_active--;
|
|
plci_remove(plci);
|
|
plci->State = IDLE;
|
|
}
|
|
break;
|
|
|
|
case USELAW_REQ:
|
|
if (global_req == ASSIGN)
|
|
{
|
|
if (rc == ASSIGN_OK)
|
|
{
|
|
sig_req(plci, LAW_REQ, 0);
|
|
send_req(plci);
|
|
dbug(1, dprintf("Auto-Law assigned"));
|
|
}
|
|
else
|
|
{
|
|
dbug(1, dprintf("Auto-Law assign failed"));
|
|
a->automatic_law = 3;
|
|
plci->internal_command = 0;
|
|
a->automatic_lawPLCI = NULL;
|
|
}
|
|
break;
|
|
}
|
|
else if (req == LAW_REQ && rc == OK)
|
|
{
|
|
dbug(1, dprintf("Auto-Law initiated"));
|
|
a->automatic_law = 2;
|
|
plci->internal_command = 0;
|
|
}
|
|
else
|
|
{
|
|
dbug(1, dprintf("Auto-Law not supported"));
|
|
a->automatic_law = 3;
|
|
plci->internal_command = 0;
|
|
sig_req(plci, REMOVE, 0);
|
|
send_req(plci);
|
|
a->automatic_lawPLCI = NULL;
|
|
}
|
|
break;
|
|
}
|
|
plci_remove_check(plci);
|
|
}
|
|
}
|
|
|
|
static void data_rc(PLCI *plci, byte ch)
|
|
{
|
|
dword Id;
|
|
DIVA_CAPI_ADAPTER *a;
|
|
NCCI *ncci_ptr;
|
|
DATA_B3_DESC *data;
|
|
word ncci;
|
|
|
|
if (plci->appl)
|
|
{
|
|
TransmitBufferFree(plci->appl, plci->data_sent_ptr);
|
|
a = plci->adapter;
|
|
ncci = a->ch_ncci[ch];
|
|
if (ncci && (a->ncci_plci[ncci] == plci->Id))
|
|
{
|
|
ncci_ptr = &(a->ncci[ncci]);
|
|
dbug(1, dprintf("data_out=%d, data_pending=%d", ncci_ptr->data_out, ncci_ptr->data_pending));
|
|
if (ncci_ptr->data_pending)
|
|
{
|
|
data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
|
|
if (!(data->Flags & 4) && a->ncci_state[ncci])
|
|
{
|
|
Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id;
|
|
if (plci->tel) Id |= EXT_CONTROLLER;
|
|
sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, data->Number,
|
|
"ww", data->Handle, 0);
|
|
}
|
|
(ncci_ptr->data_out)++;
|
|
if (ncci_ptr->data_out == MAX_DATA_B3)
|
|
ncci_ptr->data_out = 0;
|
|
(ncci_ptr->data_pending)--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void data_ack(PLCI *plci, byte ch)
|
|
{
|
|
dword Id;
|
|
DIVA_CAPI_ADAPTER *a;
|
|
NCCI *ncci_ptr;
|
|
word ncci;
|
|
|
|
a = plci->adapter;
|
|
ncci = a->ch_ncci[ch];
|
|
ncci_ptr = &(a->ncci[ncci]);
|
|
if (ncci_ptr->data_ack_pending)
|
|
{
|
|
if (a->ncci_state[ncci] && (a->ncci_plci[ncci] == plci->Id))
|
|
{
|
|
Id = (((dword)ncci) << 16) | ((word)plci->Id << 8) | a->Id;
|
|
if (plci->tel) Id |= EXT_CONTROLLER;
|
|
sendf(plci->appl, _DATA_B3_R | CONFIRM, Id, ncci_ptr->DataAck[ncci_ptr->data_ack_out].Number,
|
|
"ww", ncci_ptr->DataAck[ncci_ptr->data_ack_out].Handle, 0);
|
|
}
|
|
(ncci_ptr->data_ack_out)++;
|
|
if (ncci_ptr->data_ack_out == MAX_DATA_ACK)
|
|
ncci_ptr->data_ack_out = 0;
|
|
(ncci_ptr->data_ack_pending)--;
|
|
}
|
|
}
|
|
|
|
static void sig_ind(PLCI *plci)
|
|
{
|
|
dword x_Id;
|
|
dword Id;
|
|
dword rId;
|
|
word i;
|
|
word cip;
|
|
dword cip_mask;
|
|
byte *ie;
|
|
DIVA_CAPI_ADAPTER *a;
|
|
API_PARSE saved_parms[MAX_MSG_PARMS + 1];
|
|
#define MAXPARMSIDS 31
|
|
byte *parms[MAXPARMSIDS];
|
|
byte *add_i[4];
|
|
byte *multi_fac_parms[MAX_MULTI_IE];
|
|
byte *multi_pi_parms[MAX_MULTI_IE];
|
|
byte *multi_ssext_parms[MAX_MULTI_IE];
|
|
byte *multi_CiPN_parms[MAX_MULTI_IE];
|
|
|
|
byte *multi_vswitch_parms[MAX_MULTI_IE];
|
|
|
|
byte ai_len;
|
|
byte *esc_chi = "";
|
|
byte *esc_law = "";
|
|
byte *pty_cai = "";
|
|
byte *esc_cr = "";
|
|
byte *esc_profile = "";
|
|
|
|
byte facility[256];
|
|
PLCI *tplci = NULL;
|
|
byte chi[] = "\x02\x18\x01";
|
|
byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
|
|
byte resume_cau[] = "\x05\x05\x00\x02\x00\x00";
|
|
/* ESC_MSGTYPE must be the last but one message, a new IE has to be */
|
|
/* included before the ESC_MSGTYPE and MAXPARMSIDS has to be incremented */
|
|
/* SMSG is situated at the end because its 0 (for compatibility reasons */
|
|
/* (see Info_Mask Bit 4, first IE. then the message type) */
|
|
word parms_id[] =
|
|
{MAXPARMSIDS, CPN, 0xff, DSA, OSA, BC, LLC, HLC, ESC_CAUSE, DSP, DT, CHA,
|
|
UUI, CONG_RR, CONG_RNR, ESC_CHI, KEY, CHI, CAU, ESC_LAW,
|
|
RDN, RDX, CONN_NR, RIN, NI, CAI, ESC_CR,
|
|
CST, ESC_PROFILE, 0xff, ESC_MSGTYPE, SMSG};
|
|
/* 14 FTY repl by ESC_CHI */
|
|
/* 18 PI repl by ESC_LAW */
|
|
/* removed OAD changed to 0xff for future use, OAD is multiIE now */
|
|
word multi_fac_id[] = {1, FTY};
|
|
word multi_pi_id[] = {1, PI};
|
|
word multi_CiPN_id[] = {1, OAD};
|
|
word multi_ssext_id[] = {1, ESC_SSEXT};
|
|
|
|
word multi_vswitch_id[] = {1, ESC_VSWITCH};
|
|
|
|
byte *cau;
|
|
word ncci;
|
|
byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
|
|
byte CF_Ind[] = "\x09\x02\x00\x06\x00\x00\x00\x00\x00\x00";
|
|
byte Interr_Err_Ind[] = "\x0a\x02\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
|
|
byte CONF_Ind[] = "\x09\x16\x00\x06\x00\x00\0x00\0x00\0x00\0x00";
|
|
byte force_mt_info = false;
|
|
byte dir;
|
|
dword d;
|
|
word w;
|
|
|
|
a = plci->adapter;
|
|
Id = ((word)plci->Id << 8) | a->Id;
|
|
PUT_WORD(&SS_Ind[4], 0x0000);
|
|
|
|
if (plci->sig_remove_id)
|
|
{
|
|
plci->Sig.RNR = 2; /* discard */
|
|
dbug(1, dprintf("SIG discard while remove pending"));
|
|
return;
|
|
}
|
|
if (plci->tel && plci->SuppState != CALL_HELD) Id |= EXT_CONTROLLER;
|
|
dbug(1, dprintf("SigInd-Id=%08lx,plci=%x,tel=%x,state=0x%x,channels=%d,Discflowcl=%d",
|
|
Id, plci->Id, plci->tel, plci->State, plci->channels, plci->hangup_flow_ctrl_timer));
|
|
if (plci->Sig.Ind == CALL_HOLD_ACK && plci->channels)
|
|
{
|
|
plci->Sig.RNR = 1;
|
|
return;
|
|
}
|
|
if (plci->Sig.Ind == HANGUP && plci->channels)
|
|
{
|
|
plci->Sig.RNR = 1;
|
|
plci->hangup_flow_ctrl_timer++;
|
|
/* recover the network layer after timeout */
|
|
if (plci->hangup_flow_ctrl_timer == 100)
|
|
{
|
|
dbug(1, dprintf("Exceptional disc"));
|
|
plci->Sig.RNR = 0;
|
|
plci->hangup_flow_ctrl_timer = 0;
|
|
for (ncci = 1; ncci < MAX_NCCI + 1; ncci++)
|
|
{
|
|
if (a->ncci_plci[ncci] == plci->Id)
|
|
{
|
|
cleanup_ncci_data(plci, ncci);
|
|
if (plci->channels)plci->channels--;
|
|
if (plci->appl)
|
|
sendf(plci->appl, _DISCONNECT_B3_I, (((dword) ncci) << 16) | Id, 0, "ws", 0, "");
|
|
}
|
|
}
|
|
if (plci->appl)
|
|
sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
|
|
plci_remove(plci);
|
|
plci->State = IDLE;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* do first parse the info with no OAD in, because OAD will be converted */
|
|
/* first the multiple facility IE, then mult. progress ind. */
|
|
/* then the parameters for the info_ind + conn_ind */
|
|
IndParse(plci, multi_fac_id, multi_fac_parms, MAX_MULTI_IE);
|
|
IndParse(plci, multi_pi_id, multi_pi_parms, MAX_MULTI_IE);
|
|
IndParse(plci, multi_ssext_id, multi_ssext_parms, MAX_MULTI_IE);
|
|
|
|
IndParse(plci, multi_vswitch_id, multi_vswitch_parms, MAX_MULTI_IE);
|
|
|
|
IndParse(plci, parms_id, parms, 0);
|
|
IndParse(plci, multi_CiPN_id, multi_CiPN_parms, MAX_MULTI_IE);
|
|
esc_chi = parms[14];
|
|
esc_law = parms[18];
|
|
pty_cai = parms[24];
|
|
esc_cr = parms[25];
|
|
esc_profile = parms[27];
|
|
if (esc_cr[0] && plci)
|
|
{
|
|
if (plci->cr_enquiry && plci->appl)
|
|
{
|
|
plci->cr_enquiry = false;
|
|
/* d = MANU_ID */
|
|
/* w = m_command */
|
|
/* b = total length */
|
|
/* b = indication type */
|
|
/* b = length of all IEs */
|
|
/* b = IE1 */
|
|
/* S = IE1 length + cont. */
|
|
/* b = IE2 */
|
|
/* S = IE2 length + cont. */
|
|
sendf(plci->appl,
|
|
_MANUFACTURER_I,
|
|
Id,
|
|
0,
|
|
"dwbbbbSbS", _DI_MANU_ID, plci->m_command,
|
|
2 + 1 + 1 + esc_cr[0] + 1 + 1 + esc_law[0], plci->Sig.Ind, 1 + 1 + esc_cr[0] + 1 + 1 + esc_law[0], ESC, esc_cr, ESC, esc_law);
|
|
}
|
|
}
|
|
/* create the additional info structure */
|
|
add_i[1] = parms[15]; /* KEY of additional info */
|
|
add_i[2] = parms[11]; /* UUI of additional info */
|
|
ai_len = AddInfo(add_i, multi_fac_parms, esc_chi, facility);
|
|
|
|
/* the ESC_LAW indicates if u-Law or a-Law is actually used by the card */
|
|
/* indication returns by the card if requested by the function */
|
|
/* AutomaticLaw() after driver init */
|
|
if (a->automatic_law < 4)
|
|
{
|
|
if (esc_law[0]) {
|
|
if (esc_law[2]) {
|
|
dbug(0, dprintf("u-Law selected"));
|
|
a->u_law = 1;
|
|
}
|
|
else {
|
|
dbug(0, dprintf("a-Law selected"));
|
|
a->u_law = 0;
|
|
}
|
|
a->automatic_law = 4;
|
|
if (plci == a->automatic_lawPLCI) {
|
|
plci->internal_command = 0;
|
|
sig_req(plci, REMOVE, 0);
|
|
send_req(plci);
|
|
a->automatic_lawPLCI = NULL;
|
|
}
|
|
}
|
|
if (esc_profile[0])
|
|
{
|
|
dbug(1, dprintf("[%06x] CardProfile: %lx %lx %lx %lx %lx",
|
|
UnMapController(a->Id), GET_DWORD(&esc_profile[6]),
|
|
GET_DWORD(&esc_profile[10]), GET_DWORD(&esc_profile[14]),
|
|
GET_DWORD(&esc_profile[18]), GET_DWORD(&esc_profile[46])));
|
|
|
|
a->profile.Global_Options &= 0x000000ffL;
|
|
a->profile.B1_Protocols &= 0x000003ffL;
|
|
a->profile.B2_Protocols &= 0x00001fdfL;
|
|
a->profile.B3_Protocols &= 0x000000b7L;
|
|
|
|
a->profile.Global_Options &= GET_DWORD(&esc_profile[6]) |
|
|
GL_BCHANNEL_OPERATION_SUPPORTED;
|
|
a->profile.B1_Protocols &= GET_DWORD(&esc_profile[10]);
|
|
a->profile.B2_Protocols &= GET_DWORD(&esc_profile[14]);
|
|
a->profile.B3_Protocols &= GET_DWORD(&esc_profile[18]);
|
|
a->manufacturer_features = GET_DWORD(&esc_profile[46]);
|
|
a->man_profile.private_options = 0;
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_ECHO_CANCELLER)
|
|
{
|
|
a->man_profile.private_options |= 1L << PRIVATE_ECHO_CANCELLER;
|
|
a->profile.Global_Options |= GL_ECHO_CANCELLER_SUPPORTED;
|
|
}
|
|
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_RTP)
|
|
a->man_profile.private_options |= 1L << PRIVATE_RTP;
|
|
a->man_profile.rtp_primary_payloads = GET_DWORD(&esc_profile[50]);
|
|
a->man_profile.rtp_additional_payloads = GET_DWORD(&esc_profile[54]);
|
|
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_T38)
|
|
a->man_profile.private_options |= 1L << PRIVATE_T38;
|
|
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_SUB_SEP_PWD)
|
|
a->man_profile.private_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
|
|
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_V18)
|
|
a->man_profile.private_options |= 1L << PRIVATE_V18;
|
|
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_DTMF_TONE)
|
|
a->man_profile.private_options |= 1L << PRIVATE_DTMF_TONE;
|
|
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_PIAFS)
|
|
a->man_profile.private_options |= 1L << PRIVATE_PIAFS;
|
|
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
|
|
a->man_profile.private_options |= 1L << PRIVATE_FAX_PAPER_FORMATS;
|
|
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_VOWN)
|
|
a->man_profile.private_options |= 1L << PRIVATE_VOWN;
|
|
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_NONSTANDARD)
|
|
a->man_profile.private_options |= 1L << PRIVATE_FAX_NONSTANDARD;
|
|
|
|
}
|
|
else
|
|
{
|
|
a->profile.Global_Options &= 0x0000007fL;
|
|
a->profile.B1_Protocols &= 0x000003dfL;
|
|
a->profile.B2_Protocols &= 0x00001adfL;
|
|
a->profile.B3_Protocols &= 0x000000b7L;
|
|
a->manufacturer_features &= MANUFACTURER_FEATURE_HARDDTMF;
|
|
}
|
|
if (a->manufacturer_features & (MANUFACTURER_FEATURE_HARDDTMF |
|
|
MANUFACTURER_FEATURE_SOFTDTMF_SEND | MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
|
|
{
|
|
a->profile.Global_Options |= GL_DTMF_SUPPORTED;
|
|
}
|
|
a->manufacturer_features &= ~MANUFACTURER_FEATURE_OOB_CHANNEL;
|
|
dbug(1, dprintf("[%06x] Profile: %lx %lx %lx %lx %lx",
|
|
UnMapController(a->Id), a->profile.Global_Options,
|
|
a->profile.B1_Protocols, a->profile.B2_Protocols,
|
|
a->profile.B3_Protocols, a->manufacturer_features));
|
|
}
|
|
/* codec plci for the handset/hook state support is just an internal id */
|
|
if (plci != a->AdvCodecPLCI)
|
|
{
|
|
force_mt_info = SendMultiIE(plci, Id, multi_fac_parms, FTY, 0x20, 0);
|
|
force_mt_info |= SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, 0);
|
|
SendSSExtInd(NULL, plci, Id, multi_ssext_parms);
|
|
SendInfo(plci, Id, parms, force_mt_info);
|
|
|
|
VSwitchReqInd(plci, Id, multi_vswitch_parms);
|
|
|
|
}
|
|
|
|
/* switch the codec to the b-channel */
|
|
if (esc_chi[0] && plci && !plci->SuppState) {
|
|
plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
|
|
mixer_set_bchannel_id_esc(plci, plci->b_channel);
|
|
dbug(1, dprintf("storeChannel=0x%x", plci->b_channel));
|
|
if (plci->tel == ADV_VOICE && plci->appl) {
|
|
SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
|
|
}
|
|
}
|
|
|
|
if (plci->appl) plci->appl->Number++;
|
|
|
|
switch (plci->Sig.Ind) {
|
|
/* Response to Get_Supported_Services request */
|
|
case S_SUPPORTED:
|
|
dbug(1, dprintf("S_Supported"));
|
|
if (!plci->appl) break;
|
|
if (pty_cai[0] == 4)
|
|
{
|
|
PUT_DWORD(&CF_Ind[6], GET_DWORD(&pty_cai[1]));
|
|
}
|
|
else
|
|
{
|
|
PUT_DWORD(&CF_Ind[6], MASK_TERMINAL_PORTABILITY | MASK_HOLD_RETRIEVE);
|
|
}
|
|
PUT_WORD(&CF_Ind[1], 0);
|
|
PUT_WORD(&CF_Ind[4], 0);
|
|
sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0x7, plci->number, "wws", 0, 3, CF_Ind);
|
|
plci_remove(plci);
|
|
break;
|
|
|
|
/* Supplementary Service rejected */
|
|
case S_SERVICE_REJ:
|
|
dbug(1, dprintf("S_Reject=0x%x", pty_cai[5]));
|
|
if (!pty_cai[0]) break;
|
|
switch (pty_cai[5])
|
|
{
|
|
case ECT_EXECUTE:
|
|
case THREE_PTY_END:
|
|
case THREE_PTY_BEGIN:
|
|
if (!plci->relatedPTYPLCI) break;
|
|
tplci = plci->relatedPTYPLCI;
|
|
rId = ((word)tplci->Id << 8) | tplci->adapter->Id;
|
|
if (tplci->tel) rId |= EXT_CONTROLLER;
|
|
if (pty_cai[5] == ECT_EXECUTE)
|
|
{
|
|
PUT_WORD(&SS_Ind[1], S_ECT);
|
|
|
|
plci->vswitchstate = 0;
|
|
plci->relatedPTYPLCI->vswitchstate = 0;
|
|
|
|
}
|
|
else
|
|
{
|
|
PUT_WORD(&SS_Ind[1], pty_cai[5] + 3);
|
|
}
|
|
if (pty_cai[2] != 0xff)
|
|
{
|
|
PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
|
|
}
|
|
else
|
|
{
|
|
PUT_WORD(&SS_Ind[4], 0x300E);
|
|
}
|
|
plci->relatedPTYPLCI = NULL;
|
|
plci->ptyState = 0;
|
|
sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
|
|
break;
|
|
|
|
case CALL_DEFLECTION:
|
|
if (pty_cai[2] != 0xff)
|
|
{
|
|
PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
|
|
}
|
|
else
|
|
{
|
|
PUT_WORD(&SS_Ind[4], 0x300E);
|
|
}
|
|
PUT_WORD(&SS_Ind[1], pty_cai[5]);
|
|
for (i = 0; i < max_appl; i++)
|
|
{
|
|
if (application[i].CDEnable)
|
|
{
|
|
if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
|
|
application[i].CDEnable = false;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DEACTIVATION_DIVERSION:
|
|
case ACTIVATION_DIVERSION:
|
|
case DIVERSION_INTERROGATE_CFU:
|
|
case DIVERSION_INTERROGATE_CFB:
|
|
case DIVERSION_INTERROGATE_CFNR:
|
|
case DIVERSION_INTERROGATE_NUM:
|
|
case CCBS_REQUEST:
|
|
case CCBS_DEACTIVATE:
|
|
case CCBS_INTERROGATE:
|
|
if (!plci->appl) break;
|
|
if (pty_cai[2] != 0xff)
|
|
{
|
|
PUT_WORD(&Interr_Err_Ind[4], 0x3600 | (word)pty_cai[2]);
|
|
}
|
|
else
|
|
{
|
|
PUT_WORD(&Interr_Err_Ind[4], 0x300E);
|
|
}
|
|
switch (pty_cai[5])
|
|
{
|
|
case DEACTIVATION_DIVERSION:
|
|
dbug(1, dprintf("Deact_Div"));
|
|
Interr_Err_Ind[0] = 0x9;
|
|
Interr_Err_Ind[3] = 0x6;
|
|
PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_STOP);
|
|
break;
|
|
case ACTIVATION_DIVERSION:
|
|
dbug(1, dprintf("Act_Div"));
|
|
Interr_Err_Ind[0] = 0x9;
|
|
Interr_Err_Ind[3] = 0x6;
|
|
PUT_WORD(&Interr_Err_Ind[1], S_CALL_FORWARDING_START);
|
|
break;
|
|
case DIVERSION_INTERROGATE_CFU:
|
|
case DIVERSION_INTERROGATE_CFB:
|
|
case DIVERSION_INTERROGATE_CFNR:
|
|
dbug(1, dprintf("Interr_Div"));
|
|
Interr_Err_Ind[0] = 0xa;
|
|
Interr_Err_Ind[3] = 0x7;
|
|
PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_DIVERSION);
|
|
break;
|
|
case DIVERSION_INTERROGATE_NUM:
|
|
dbug(1, dprintf("Interr_Num"));
|
|
Interr_Err_Ind[0] = 0xa;
|
|
Interr_Err_Ind[3] = 0x7;
|
|
PUT_WORD(&Interr_Err_Ind[1], S_INTERROGATE_NUMBERS);
|
|
break;
|
|
case CCBS_REQUEST:
|
|
dbug(1, dprintf("CCBS Request"));
|
|
Interr_Err_Ind[0] = 0xd;
|
|
Interr_Err_Ind[3] = 0xa;
|
|
PUT_WORD(&Interr_Err_Ind[1], S_CCBS_REQUEST);
|
|
break;
|
|
case CCBS_DEACTIVATE:
|
|
dbug(1, dprintf("CCBS Deactivate"));
|
|
Interr_Err_Ind[0] = 0x9;
|
|
Interr_Err_Ind[3] = 0x6;
|
|
PUT_WORD(&Interr_Err_Ind[1], S_CCBS_DEACTIVATE);
|
|
break;
|
|
case CCBS_INTERROGATE:
|
|
dbug(1, dprintf("CCBS Interrogate"));
|
|
Interr_Err_Ind[0] = 0xb;
|
|
Interr_Err_Ind[3] = 0x8;
|
|
PUT_WORD(&Interr_Err_Ind[1], S_CCBS_INTERROGATE);
|
|
break;
|
|
}
|
|
PUT_DWORD(&Interr_Err_Ind[6], plci->appl->S_Handle);
|
|
sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, Interr_Err_Ind);
|
|
plci_remove(plci);
|
|
break;
|
|
case ACTIVATION_MWI:
|
|
case DEACTIVATION_MWI:
|
|
if (pty_cai[5] == ACTIVATION_MWI)
|
|
{
|
|
PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE);
|
|
}
|
|
else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE);
|
|
|
|
if (pty_cai[2] != 0xff)
|
|
{
|
|
PUT_WORD(&SS_Ind[4], 0x3600 | (word)pty_cai[2]);
|
|
}
|
|
else
|
|
{
|
|
PUT_WORD(&SS_Ind[4], 0x300E);
|
|
}
|
|
|
|
if (plci->cr_enquiry)
|
|
{
|
|
sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind);
|
|
plci_remove(plci);
|
|
}
|
|
else
|
|
{
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
|
|
}
|
|
break;
|
|
case CONF_ADD: /* ERROR */
|
|
case CONF_BEGIN:
|
|
case CONF_DROP:
|
|
case CONF_ISOLATE:
|
|
case CONF_REATTACH:
|
|
CONF_Ind[0] = 9;
|
|
CONF_Ind[3] = 6;
|
|
switch (pty_cai[5])
|
|
{
|
|
case CONF_BEGIN:
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN);
|
|
plci->ptyState = 0;
|
|
break;
|
|
case CONF_DROP:
|
|
CONF_Ind[0] = 5;
|
|
CONF_Ind[3] = 2;
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_DROP);
|
|
plci->ptyState = CONNECTED;
|
|
break;
|
|
case CONF_ISOLATE:
|
|
CONF_Ind[0] = 5;
|
|
CONF_Ind[3] = 2;
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE);
|
|
plci->ptyState = CONNECTED;
|
|
break;
|
|
case CONF_REATTACH:
|
|
CONF_Ind[0] = 5;
|
|
CONF_Ind[3] = 2;
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH);
|
|
plci->ptyState = CONNECTED;
|
|
break;
|
|
case CONF_ADD:
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_ADD);
|
|
plci->relatedPTYPLCI = NULL;
|
|
tplci = plci->relatedPTYPLCI;
|
|
if (tplci) tplci->ptyState = CONNECTED;
|
|
plci->ptyState = CONNECTED;
|
|
break;
|
|
}
|
|
|
|
if (pty_cai[2] != 0xff)
|
|
{
|
|
PUT_WORD(&CONF_Ind[4], 0x3600 | (word)pty_cai[2]);
|
|
}
|
|
else
|
|
{
|
|
PUT_WORD(&CONF_Ind[4], 0x3303); /* Time-out: network did not respond
|
|
within the required time */
|
|
}
|
|
|
|
PUT_DWORD(&CONF_Ind[6], 0x0);
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
/* Supplementary Service indicates success */
|
|
case S_SERVICE:
|
|
dbug(1, dprintf("Service_Ind"));
|
|
PUT_WORD(&CF_Ind[4], 0);
|
|
switch (pty_cai[5])
|
|
{
|
|
case THREE_PTY_END:
|
|
case THREE_PTY_BEGIN:
|
|
case ECT_EXECUTE:
|
|
if (!plci->relatedPTYPLCI) break;
|
|
tplci = plci->relatedPTYPLCI;
|
|
rId = ((word)tplci->Id << 8) | tplci->adapter->Id;
|
|
if (tplci->tel) rId |= EXT_CONTROLLER;
|
|
if (pty_cai[5] == ECT_EXECUTE)
|
|
{
|
|
PUT_WORD(&SS_Ind[1], S_ECT);
|
|
|
|
if (plci->vswitchstate != 3)
|
|
{
|
|
|
|
plci->ptyState = IDLE;
|
|
plci->relatedPTYPLCI = NULL;
|
|
plci->ptyState = 0;
|
|
|
|
}
|
|
|
|
dbug(1, dprintf("ECT OK"));
|
|
sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
|
|
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
switch (plci->ptyState)
|
|
{
|
|
case S_3PTY_BEGIN:
|
|
plci->ptyState = CONNECTED;
|
|
dbug(1, dprintf("3PTY ON"));
|
|
break;
|
|
|
|
case S_3PTY_END:
|
|
plci->ptyState = IDLE;
|
|
plci->relatedPTYPLCI = NULL;
|
|
plci->ptyState = 0;
|
|
dbug(1, dprintf("3PTY OFF"));
|
|
break;
|
|
}
|
|
PUT_WORD(&SS_Ind[1], pty_cai[5] + 3);
|
|
sendf(tplci->appl, _FACILITY_I, rId, 0, "ws", 3, SS_Ind);
|
|
}
|
|
break;
|
|
|
|
case CALL_DEFLECTION:
|
|
PUT_WORD(&SS_Ind[1], pty_cai[5]);
|
|
for (i = 0; i < max_appl; i++)
|
|
{
|
|
if (application[i].CDEnable)
|
|
{
|
|
if (application[i].Id) sendf(&application[i], _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
|
|
application[i].CDEnable = false;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case DEACTIVATION_DIVERSION:
|
|
case ACTIVATION_DIVERSION:
|
|
if (!plci->appl) break;
|
|
PUT_WORD(&CF_Ind[1], pty_cai[5] + 2);
|
|
PUT_DWORD(&CF_Ind[6], plci->appl->S_Handle);
|
|
sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "ws", 3, CF_Ind);
|
|
plci_remove(plci);
|
|
break;
|
|
|
|
case DIVERSION_INTERROGATE_CFU:
|
|
case DIVERSION_INTERROGATE_CFB:
|
|
case DIVERSION_INTERROGATE_CFNR:
|
|
case DIVERSION_INTERROGATE_NUM:
|
|
case CCBS_REQUEST:
|
|
case CCBS_DEACTIVATE:
|
|
case CCBS_INTERROGATE:
|
|
if (!plci->appl) break;
|
|
switch (pty_cai[5])
|
|
{
|
|
case DIVERSION_INTERROGATE_CFU:
|
|
case DIVERSION_INTERROGATE_CFB:
|
|
case DIVERSION_INTERROGATE_CFNR:
|
|
dbug(1, dprintf("Interr_Div"));
|
|
PUT_WORD(&pty_cai[1], S_INTERROGATE_DIVERSION);
|
|
pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
|
|
break;
|
|
case DIVERSION_INTERROGATE_NUM:
|
|
dbug(1, dprintf("Interr_Num"));
|
|
PUT_WORD(&pty_cai[1], S_INTERROGATE_NUMBERS);
|
|
pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
|
|
break;
|
|
case CCBS_REQUEST:
|
|
dbug(1, dprintf("CCBS Request"));
|
|
PUT_WORD(&pty_cai[1], S_CCBS_REQUEST);
|
|
pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
|
|
break;
|
|
case CCBS_DEACTIVATE:
|
|
dbug(1, dprintf("CCBS Deactivate"));
|
|
PUT_WORD(&pty_cai[1], S_CCBS_DEACTIVATE);
|
|
pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
|
|
break;
|
|
case CCBS_INTERROGATE:
|
|
dbug(1, dprintf("CCBS Interrogate"));
|
|
PUT_WORD(&pty_cai[1], S_CCBS_INTERROGATE);
|
|
pty_cai[3] = pty_cai[0] - 3; /* Supplementary Service-specific parameter len */
|
|
break;
|
|
}
|
|
PUT_WORD(&pty_cai[4], 0); /* Supplementary Service Reason */
|
|
PUT_DWORD(&pty_cai[6], plci->appl->S_Handle);
|
|
sendf(plci->appl, _FACILITY_I, Id & 0x7, 0, "wS", 3, pty_cai);
|
|
plci_remove(plci);
|
|
break;
|
|
|
|
case ACTIVATION_MWI:
|
|
case DEACTIVATION_MWI:
|
|
if (pty_cai[5] == ACTIVATION_MWI)
|
|
{
|
|
PUT_WORD(&SS_Ind[1], S_MWI_ACTIVATE);
|
|
}
|
|
else PUT_WORD(&SS_Ind[1], S_MWI_DEACTIVATE);
|
|
if (plci->cr_enquiry)
|
|
{
|
|
sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "ws", 3, SS_Ind);
|
|
plci_remove(plci);
|
|
}
|
|
else
|
|
{
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
|
|
}
|
|
break;
|
|
case MWI_INDICATION:
|
|
if (pty_cai[0] >= 0x12)
|
|
{
|
|
PUT_WORD(&pty_cai[3], S_MWI_INDICATE);
|
|
pty_cai[2] = pty_cai[0] - 2; /* len Parameter */
|
|
pty_cai[5] = pty_cai[0] - 5; /* Supplementary Service-specific parameter len */
|
|
if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_MWI))
|
|
{
|
|
if (plci->internal_command == GET_MWI_STATE) /* result on Message Waiting Listen */
|
|
{
|
|
sendf(plci->appl, _FACILITY_I, Id & 0xf, 0, "wS", 3, &pty_cai[2]);
|
|
plci_remove(plci);
|
|
return;
|
|
}
|
|
else sendf(plci->appl, _FACILITY_I, Id, 0, "wS", 3, &pty_cai[2]);
|
|
pty_cai[0] = 0;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < max_appl; i++)
|
|
{
|
|
if (a->Notification_Mask[i]&SMASK_MWI)
|
|
{
|
|
sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "wS", 3, &pty_cai[2]);
|
|
pty_cai[0] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!pty_cai[0])
|
|
{ /* acknowledge */
|
|
facility[2] = 0; /* returncode */
|
|
}
|
|
else facility[2] = 0xff;
|
|
}
|
|
else
|
|
{
|
|
/* reject */
|
|
facility[2] = 0xff; /* returncode */
|
|
}
|
|
facility[0] = 2;
|
|
facility[1] = MWI_RESPONSE; /* Function */
|
|
add_p(plci, CAI, facility);
|
|
add_p(plci, ESC, multi_ssext_parms[0]); /* remembered parameter -> only one possible */
|
|
sig_req(plci, S_SERVICE, 0);
|
|
send_req(plci);
|
|
plci->command = 0;
|
|
next_internal_command(Id, plci);
|
|
break;
|
|
case CONF_ADD: /* OK */
|
|
case CONF_BEGIN:
|
|
case CONF_DROP:
|
|
case CONF_ISOLATE:
|
|
case CONF_REATTACH:
|
|
case CONF_PARTYDISC:
|
|
CONF_Ind[0] = 9;
|
|
CONF_Ind[3] = 6;
|
|
switch (pty_cai[5])
|
|
{
|
|
case CONF_BEGIN:
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_BEGIN);
|
|
if (pty_cai[0] == 6)
|
|
{
|
|
d = pty_cai[6];
|
|
PUT_DWORD(&CONF_Ind[6], d); /* PartyID */
|
|
}
|
|
else
|
|
{
|
|
PUT_DWORD(&CONF_Ind[6], 0x0);
|
|
}
|
|
break;
|
|
case CONF_ISOLATE:
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_ISOLATE);
|
|
CONF_Ind[0] = 5;
|
|
CONF_Ind[3] = 2;
|
|
break;
|
|
case CONF_REATTACH:
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_REATTACH);
|
|
CONF_Ind[0] = 5;
|
|
CONF_Ind[3] = 2;
|
|
break;
|
|
case CONF_DROP:
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_DROP);
|
|
CONF_Ind[0] = 5;
|
|
CONF_Ind[3] = 2;
|
|
break;
|
|
case CONF_ADD:
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_ADD);
|
|
d = pty_cai[6];
|
|
PUT_DWORD(&CONF_Ind[6], d); /* PartyID */
|
|
tplci = plci->relatedPTYPLCI;
|
|
if (tplci) tplci->ptyState = CONNECTED;
|
|
break;
|
|
case CONF_PARTYDISC:
|
|
CONF_Ind[0] = 7;
|
|
CONF_Ind[3] = 4;
|
|
PUT_WORD(&CONF_Ind[1], S_CONF_PARTYDISC);
|
|
d = pty_cai[6];
|
|
PUT_DWORD(&CONF_Ind[4], d); /* PartyID */
|
|
break;
|
|
}
|
|
plci->ptyState = CONNECTED;
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
|
|
break;
|
|
case CCBS_INFO_RETAIN:
|
|
case CCBS_ERASECALLLINKAGEID:
|
|
case CCBS_STOP_ALERTING:
|
|
CONF_Ind[0] = 5;
|
|
CONF_Ind[3] = 2;
|
|
switch (pty_cai[5])
|
|
{
|
|
case CCBS_INFO_RETAIN:
|
|
PUT_WORD(&CONF_Ind[1], S_CCBS_INFO_RETAIN);
|
|
break;
|
|
case CCBS_STOP_ALERTING:
|
|
PUT_WORD(&CONF_Ind[1], S_CCBS_STOP_ALERTING);
|
|
break;
|
|
case CCBS_ERASECALLLINKAGEID:
|
|
PUT_WORD(&CONF_Ind[1], S_CCBS_ERASECALLLINKAGEID);
|
|
CONF_Ind[0] = 7;
|
|
CONF_Ind[3] = 4;
|
|
CONF_Ind[6] = 0;
|
|
CONF_Ind[7] = 0;
|
|
break;
|
|
}
|
|
w = pty_cai[6];
|
|
PUT_WORD(&CONF_Ind[4], w); /* PartyID */
|
|
|
|
if (plci->appl && (a->Notification_Mask[plci->appl->Id - 1] & SMASK_CCBS))
|
|
{
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, CONF_Ind);
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < max_appl; i++)
|
|
if (a->Notification_Mask[i] & SMASK_CCBS)
|
|
sendf(&application[i], _FACILITY_I, Id & 0x7, 0, "ws", 3, CONF_Ind);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case CALL_HOLD_REJ:
|
|
cau = parms[7];
|
|
if (cau)
|
|
{
|
|
i = _L3_CAUSE | cau[2];
|
|
if (cau[2] == 0) i = 0x3603;
|
|
}
|
|
else
|
|
{
|
|
i = 0x3603;
|
|
}
|
|
PUT_WORD(&SS_Ind[1], S_HOLD);
|
|
PUT_WORD(&SS_Ind[4], i);
|
|
if (plci->SuppState == HOLD_REQUEST)
|
|
{
|
|
plci->SuppState = IDLE;
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
|
|
}
|
|
break;
|
|
|
|
case CALL_HOLD_ACK:
|
|
if (plci->SuppState == HOLD_REQUEST)
|
|
{
|
|
plci->SuppState = CALL_HELD;
|
|
CodecIdCheck(a, plci);
|
|
start_internal_command(Id, plci, hold_save_command);
|
|
}
|
|
break;
|
|
|
|
case CALL_RETRIEVE_REJ:
|
|
cau = parms[7];
|
|
if (cau)
|
|
{
|
|
i = _L3_CAUSE | cau[2];
|
|
if (cau[2] == 0) i = 0x3603;
|
|
}
|
|
else
|
|
{
|
|
i = 0x3603;
|
|
}
|
|
PUT_WORD(&SS_Ind[1], S_RETRIEVE);
|
|
PUT_WORD(&SS_Ind[4], i);
|
|
if (plci->SuppState == RETRIEVE_REQUEST)
|
|
{
|
|
plci->SuppState = CALL_HELD;
|
|
CodecIdCheck(a, plci);
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
|
|
}
|
|
break;
|
|
|
|
case CALL_RETRIEVE_ACK:
|
|
PUT_WORD(&SS_Ind[1], S_RETRIEVE);
|
|
if (plci->SuppState == RETRIEVE_REQUEST)
|
|
{
|
|
plci->SuppState = IDLE;
|
|
plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
|
|
plci->b_channel = esc_chi[esc_chi[0]]&0x1f;
|
|
if (plci->tel)
|
|
{
|
|
mixer_set_bchannel_id_esc(plci, plci->b_channel);
|
|
dbug(1, dprintf("RetrChannel=0x%x", plci->b_channel));
|
|
SetVoiceChannel(a->AdvCodecPLCI, esc_chi, a);
|
|
if (plci->B2_prot == B2_TRANSPARENT && plci->B3_prot == B3_TRANSPARENT)
|
|
{
|
|
dbug(1, dprintf("Get B-ch"));
|
|
start_internal_command(Id, plci, retrieve_restore_command);
|
|
}
|
|
else
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", 3, SS_Ind);
|
|
}
|
|
else
|
|
start_internal_command(Id, plci, retrieve_restore_command);
|
|
}
|
|
break;
|
|
|
|
case INDICATE_IND:
|
|
if (plci->State != LISTENING) {
|
|
sig_req(plci, HANGUP, 0);
|
|
send_req(plci);
|
|
break;
|
|
}
|
|
cip = find_cip(a, parms[4], parms[6]);
|
|
cip_mask = 1L << cip;
|
|
dbug(1, dprintf("cip=%d,cip_mask=%lx", cip, cip_mask));
|
|
clear_c_ind_mask(plci);
|
|
if (!remove_started && !a->adapter_disabled)
|
|
{
|
|
set_c_ind_mask_bit(plci, MAX_APPL);
|
|
group_optimization(a, plci);
|
|
for (i = 0; i < max_appl; i++) {
|
|
if (application[i].Id
|
|
&& (a->CIP_Mask[i] & 1 || a->CIP_Mask[i] & cip_mask)
|
|
&& CPN_filter_ok(parms[0], a, i)
|
|
&& test_group_ind_mask_bit(plci, i)) {
|
|
dbug(1, dprintf("storedcip_mask[%d]=0x%lx", i, a->CIP_Mask[i]));
|
|
set_c_ind_mask_bit(plci, i);
|
|
dump_c_ind_mask(plci);
|
|
plci->State = INC_CON_PENDING;
|
|
plci->call_dir = (plci->call_dir & ~(CALL_DIR_OUT | CALL_DIR_ORIGINATE)) |
|
|
CALL_DIR_IN | CALL_DIR_ANSWER;
|
|
if (esc_chi[0]) {
|
|
plci->b_channel = esc_chi[esc_chi[0]] & 0x1f;
|
|
mixer_set_bchannel_id_esc(plci, plci->b_channel);
|
|
}
|
|
/* if a listen on the ext controller is done, check if hook states */
|
|
/* are supported or if just a on board codec must be activated */
|
|
if (a->codec_listen[i] && !a->AdvSignalPLCI) {
|
|
if (a->profile.Global_Options & HANDSET)
|
|
plci->tel = ADV_VOICE;
|
|
else if (a->profile.Global_Options & ON_BOARD_CODEC)
|
|
plci->tel = CODEC;
|
|
if (plci->tel) Id |= EXT_CONTROLLER;
|
|
a->codec_listen[i] = plci;
|
|
}
|
|
|
|
sendf(&application[i], _CONNECT_I, Id, 0,
|
|
"wSSSSSSSbSSSSS", cip, /* CIP */
|
|
parms[0], /* CalledPartyNumber */
|
|
multi_CiPN_parms[0], /* CallingPartyNumber */
|
|
parms[2], /* CalledPartySubad */
|
|
parms[3], /* CallingPartySubad */
|
|
parms[4], /* BearerCapability */
|
|
parms[5], /* LowLC */
|
|
parms[6], /* HighLC */
|
|
ai_len, /* nested struct add_i */
|
|
add_i[0], /* B channel info */
|
|
add_i[1], /* keypad facility */
|
|
add_i[2], /* user user data */
|
|
add_i[3], /* nested facility */
|
|
multi_CiPN_parms[1] /* second CiPN(SCR) */
|
|
);
|
|
SendSSExtInd(&application[i],
|
|
plci,
|
|
Id,
|
|
multi_ssext_parms);
|
|
SendSetupInfo(&application[i],
|
|
plci,
|
|
Id,
|
|
parms,
|
|
SendMultiIE(plci, Id, multi_pi_parms, PI, 0x210, true));
|
|
}
|
|
}
|
|
clear_c_ind_mask_bit(plci, MAX_APPL);
|
|
dump_c_ind_mask(plci);
|
|
}
|
|
if (c_ind_mask_empty(plci)) {
|
|
sig_req(plci, HANGUP, 0);
|
|
send_req(plci);
|
|
plci->State = IDLE;
|
|
}
|
|
plci->notifiedcall = 0;
|
|
a->listen_active--;
|
|
listen_check(a);
|
|
break;
|
|
|
|
case CALL_PEND_NOTIFY:
|
|
plci->notifiedcall = 1;
|
|
listen_check(a);
|
|
break;
|
|
|
|
case CALL_IND:
|
|
case CALL_CON:
|
|
if (plci->State == ADVANCED_VOICE_SIG || plci->State == ADVANCED_VOICE_NOSIG)
|
|
{
|
|
if (plci->internal_command == PERM_COD_CONN_PEND)
|
|
{
|
|
if (plci->State == ADVANCED_VOICE_NOSIG)
|
|
{
|
|
dbug(1, dprintf("***Codec OK"));
|
|
if (a->AdvSignalPLCI)
|
|
{
|
|
tplci = a->AdvSignalPLCI;
|
|
if (tplci->spoofed_msg)
|
|
{
|
|
dbug(1, dprintf("***Spoofed Msg(0x%x)", tplci->spoofed_msg));
|
|
tplci->command = 0;
|
|
tplci->internal_command = 0;
|
|
x_Id = ((word)tplci->Id << 8) | tplci->adapter->Id | 0x80;
|
|
switch (tplci->spoofed_msg)
|
|
{
|
|
case CALL_RES:
|
|
tplci->command = _CONNECT_I | RESPONSE;
|
|
api_load_msg(&tplci->saved_msg, saved_parms);
|
|
add_b1(tplci, &saved_parms[1], 0, tplci->B1_facilities);
|
|
if (tplci->adapter->Info_Mask[tplci->appl->Id - 1] & 0x200)
|
|
{
|
|
/* early B3 connect (CIP mask bit 9) no release after a disc */
|
|
add_p(tplci, LLI, "\x01\x01");
|
|
}
|
|
add_s(tplci, CONN_NR, &saved_parms[2]);
|
|
add_s(tplci, LLC, &saved_parms[4]);
|
|
add_ai(tplci, &saved_parms[5]);
|
|
tplci->State = INC_CON_ACCEPT;
|
|
sig_req(tplci, CALL_RES, 0);
|
|
send_req(tplci);
|
|
break;
|
|
|
|
case AWAITING_SELECT_B:
|
|
dbug(1, dprintf("Select_B continue"));
|
|
start_internal_command(x_Id, tplci, select_b_command);
|
|
break;
|
|
|
|
case AWAITING_MANUF_CON: /* Get_Plci per Manufacturer_Req to ext controller */
|
|
if (!tplci->Sig.Id)
|
|
{
|
|
dbug(1, dprintf("No SigID!"));
|
|
sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, _OUT_OF_PLCI);
|
|
plci_remove(tplci);
|
|
break;
|
|
}
|
|
tplci->command = _MANUFACTURER_R;
|
|
api_load_msg(&tplci->saved_msg, saved_parms);
|
|
dir = saved_parms[2].info[0];
|
|
if (dir == 1) {
|
|
sig_req(tplci, CALL_REQ, 0);
|
|
}
|
|
else if (!dir) {
|
|
sig_req(tplci, LISTEN_REQ, 0);
|
|
}
|
|
send_req(tplci);
|
|
sendf(tplci->appl, _MANUFACTURER_R | CONFIRM, x_Id, tplci->number, "dww", _DI_MANU_ID, _MANUFACTURER_R, 0);
|
|
break;
|
|
|
|
case (CALL_REQ | AWAITING_MANUF_CON):
|
|
sig_req(tplci, CALL_REQ, 0);
|
|
send_req(tplci);
|
|
break;
|
|
|
|
case CALL_REQ:
|
|
if (!tplci->Sig.Id)
|
|
{
|
|
dbug(1, dprintf("No SigID!"));
|
|
sendf(tplci->appl, _CONNECT_R | CONFIRM, tplci->adapter->Id, 0, "w", _OUT_OF_PLCI);
|
|
plci_remove(tplci);
|
|
break;
|
|
}
|
|
tplci->command = _CONNECT_R;
|
|
api_load_msg(&tplci->saved_msg, saved_parms);
|
|
add_s(tplci, CPN, &saved_parms[1]);
|
|
add_s(tplci, DSA, &saved_parms[3]);
|
|
add_ai(tplci, &saved_parms[9]);
|
|
sig_req(tplci, CALL_REQ, 0);
|
|
send_req(tplci);
|
|
break;
|
|
|
|
case CALL_RETRIEVE:
|
|
tplci->command = C_RETRIEVE_REQ;
|
|
sig_req(tplci, CALL_RETRIEVE, 0);
|
|
send_req(tplci);
|
|
break;
|
|
}
|
|
tplci->spoofed_msg = 0;
|
|
if (tplci->internal_command == 0)
|
|
next_internal_command(x_Id, tplci);
|
|
}
|
|
}
|
|
next_internal_command(Id, plci);
|
|
break;
|
|
}
|
|
dbug(1, dprintf("***Codec Hook Init Req"));
|
|
plci->internal_command = PERM_COD_HOOK;
|
|
add_p(plci, FTY, "\x01\x09"); /* Get Hook State*/
|
|
sig_req(plci, TEL_CTRL, 0);
|
|
send_req(plci);
|
|
}
|
|
}
|
|
else if (plci->command != _MANUFACTURER_R /* old style permanent connect */
|
|
&& plci->State != INC_ACT_PENDING)
|
|
{
|
|
mixer_set_bchannel_id_esc(plci, plci->b_channel);
|
|
if (plci->tel == ADV_VOICE && plci->SuppState == IDLE) /* with permanent codec switch on immediately */
|
|
{
|
|
chi[2] = plci->b_channel;
|
|
SetVoiceChannel(a->AdvCodecPLCI, chi, a);
|
|
}
|
|
sendf(plci->appl, _CONNECT_ACTIVE_I, Id, 0, "Sss", parms[21], "", "");
|
|
plci->State = INC_ACT_PENDING;
|
|
}
|
|
break;
|
|
|
|
case TEL_CTRL:
|
|
ie = multi_fac_parms[0]; /* inspect the facility hook indications */
|
|
if (plci->State == ADVANCED_VOICE_SIG && ie[0]) {
|
|
switch (ie[1] & 0x91) {
|
|
case 0x80: /* hook off */
|
|
case 0x81:
|
|
if (plci->internal_command == PERM_COD_HOOK)
|
|
{
|
|
dbug(1, dprintf("init:hook_off"));
|
|
plci->hook_state = ie[1];
|
|
next_internal_command(Id, plci);
|
|
break;
|
|
}
|
|
else /* ignore doubled hook indications */
|
|
{
|
|
if (((plci->hook_state) & 0xf0) == 0x80)
|
|
{
|
|
dbug(1, dprintf("ignore hook"));
|
|
break;
|
|
}
|
|
plci->hook_state = ie[1]&0x91;
|
|
}
|
|
/* check for incoming call pending */
|
|
/* and signal '+'.Appl must decide */
|
|
/* with connect_res if call must */
|
|
/* accepted or not */
|
|
for (i = 0, tplci = NULL; i < max_appl; i++) {
|
|
if (a->codec_listen[i]
|
|
&& (a->codec_listen[i]->State == INC_CON_PENDING
|
|
|| a->codec_listen[i]->State == INC_CON_ALERT)) {
|
|
tplci = a->codec_listen[i];
|
|
tplci->appl = &application[i];
|
|
}
|
|
}
|
|
/* no incoming call, do outgoing call */
|
|
/* and signal '+' if outg. setup */
|
|
if (!a->AdvSignalPLCI && !tplci) {
|
|
if ((i = get_plci(a))) {
|
|
a->AdvSignalPLCI = &a->plci[i - 1];
|
|
tplci = a->AdvSignalPLCI;
|
|
tplci->tel = ADV_VOICE;
|
|
PUT_WORD(&voice_cai[5], a->AdvSignalAppl->MaxDataLength);
|
|
if (a->Info_Mask[a->AdvSignalAppl->Id - 1] & 0x200) {
|
|
/* early B3 connect (CIP mask bit 9) no release after a disc */
|
|
add_p(tplci, LLI, "\x01\x01");
|
|
}
|
|
add_p(tplci, CAI, voice_cai);
|
|
add_p(tplci, OAD, a->TelOAD);
|
|
add_p(tplci, OSA, a->TelOSA);
|
|
add_p(tplci, SHIFT | 6, NULL);
|
|
add_p(tplci, SIN, "\x02\x01\x00");
|
|
add_p(tplci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(tplci, ASSIGN, DSIG_ID);
|
|
a->AdvSignalPLCI->internal_command = HOOK_OFF_REQ;
|
|
a->AdvSignalPLCI->command = 0;
|
|
tplci->appl = a->AdvSignalAppl;
|
|
tplci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
|
|
send_req(tplci);
|
|
}
|
|
|
|
}
|
|
|
|
if (!tplci) break;
|
|
Id = ((word)tplci->Id << 8) | a->Id;
|
|
Id |= EXT_CONTROLLER;
|
|
sendf(tplci->appl,
|
|
_FACILITY_I,
|
|
Id,
|
|
0,
|
|
"ws", (word)0, "\x01+");
|
|
break;
|
|
|
|
case 0x90: /* hook on */
|
|
case 0x91:
|
|
if (plci->internal_command == PERM_COD_HOOK)
|
|
{
|
|
dbug(1, dprintf("init:hook_on"));
|
|
plci->hook_state = ie[1] & 0x91;
|
|
next_internal_command(Id, plci);
|
|
break;
|
|
}
|
|
else /* ignore doubled hook indications */
|
|
{
|
|
if (((plci->hook_state) & 0xf0) == 0x90) break;
|
|
plci->hook_state = ie[1] & 0x91;
|
|
}
|
|
/* hangup the adv. voice call and signal '-' to the appl */
|
|
if (a->AdvSignalPLCI) {
|
|
Id = ((word)a->AdvSignalPLCI->Id << 8) | a->Id;
|
|
if (plci->tel) Id |= EXT_CONTROLLER;
|
|
sendf(a->AdvSignalAppl,
|
|
_FACILITY_I,
|
|
Id,
|
|
0,
|
|
"ws", (word)0, "\x01-");
|
|
a->AdvSignalPLCI->internal_command = HOOK_ON_REQ;
|
|
a->AdvSignalPLCI->command = 0;
|
|
sig_req(a->AdvSignalPLCI, HANGUP, 0);
|
|
send_req(a->AdvSignalPLCI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RESUME:
|
|
clear_c_ind_mask_bit(plci, (word)(plci->appl->Id - 1));
|
|
PUT_WORD(&resume_cau[4], GOOD);
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau);
|
|
break;
|
|
|
|
case SUSPEND:
|
|
clear_c_ind_mask(plci);
|
|
|
|
if (plci->NL.Id && !plci->nl_remove_id) {
|
|
mixer_remove(plci);
|
|
nl_req_ncci(plci, REMOVE, 0);
|
|
}
|
|
if (!plci->sig_remove_id) {
|
|
plci->internal_command = 0;
|
|
sig_req(plci, REMOVE, 0);
|
|
}
|
|
send_req(plci);
|
|
if (!plci->channels) {
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, "\x05\x04\x00\x02\x00\x00");
|
|
sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", 0);
|
|
}
|
|
break;
|
|
|
|
case SUSPEND_REJ:
|
|
break;
|
|
|
|
case HANGUP:
|
|
plci->hangup_flow_ctrl_timer = 0;
|
|
if (plci->manufacturer && plci->State == LOCAL_CONNECT) break;
|
|
cau = parms[7];
|
|
if (cau) {
|
|
i = _L3_CAUSE | cau[2];
|
|
if (cau[2] == 0) i = 0;
|
|
else if (cau[2] == 8) i = _L1_ERROR;
|
|
else if (cau[2] == 9 || cau[2] == 10) i = _L2_ERROR;
|
|
else if (cau[2] == 5) i = _CAPI_GUARD_ERROR;
|
|
}
|
|
else {
|
|
i = _L3_ERROR;
|
|
}
|
|
|
|
if (plci->State == INC_CON_PENDING || plci->State == INC_CON_ALERT)
|
|
{
|
|
for (i = 0; i < max_appl; i++)
|
|
{
|
|
if (test_c_ind_mask_bit(plci, i))
|
|
sendf(&application[i], _DISCONNECT_I, Id, 0, "w", 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
clear_c_ind_mask(plci);
|
|
}
|
|
if (!plci->appl)
|
|
{
|
|
if (plci->State == LISTENING)
|
|
{
|
|
plci->notifiedcall = 0;
|
|
a->listen_active--;
|
|
}
|
|
plci->State = INC_DIS_PENDING;
|
|
if (c_ind_mask_empty(plci))
|
|
{
|
|
plci->State = IDLE;
|
|
if (plci->NL.Id && !plci->nl_remove_id)
|
|
{
|
|
mixer_remove(plci);
|
|
nl_req_ncci(plci, REMOVE, 0);
|
|
}
|
|
if (!plci->sig_remove_id)
|
|
{
|
|
plci->internal_command = 0;
|
|
sig_req(plci, REMOVE, 0);
|
|
}
|
|
send_req(plci);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* collision of DISCONNECT or CONNECT_RES with HANGUP can */
|
|
/* result in a second HANGUP! Don't generate another */
|
|
/* DISCONNECT */
|
|
if (plci->State != IDLE && plci->State != INC_DIS_PENDING)
|
|
{
|
|
if (plci->State == RESUMING)
|
|
{
|
|
PUT_WORD(&resume_cau[4], i);
|
|
sendf(plci->appl, _FACILITY_I, Id, 0, "ws", (word)3, resume_cau);
|
|
}
|
|
plci->State = INC_DIS_PENDING;
|
|
sendf(plci->appl, _DISCONNECT_I, Id, 0, "w", i);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SSEXT_IND:
|
|
SendSSExtInd(NULL, plci, Id, multi_ssext_parms);
|
|
break;
|
|
|
|
case VSWITCH_REQ:
|
|
VSwitchReqInd(plci, Id, multi_vswitch_parms);
|
|
break;
|
|
case VSWITCH_IND:
|
|
if (plci->relatedPTYPLCI &&
|
|
plci->vswitchstate == 3 &&
|
|
plci->relatedPTYPLCI->vswitchstate == 3 &&
|
|
parms[MAXPARMSIDS - 1][0])
|
|
{
|
|
add_p(plci->relatedPTYPLCI, SMSG, parms[MAXPARMSIDS - 1]);
|
|
sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
|
|
send_req(plci->relatedPTYPLCI);
|
|
}
|
|
else VSwitchReqInd(plci, Id, multi_vswitch_parms);
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
static void SendSetupInfo(APPL *appl, PLCI *plci, dword Id, byte **parms, byte Info_Sent_Flag)
|
|
{
|
|
word i;
|
|
byte *ie;
|
|
word Info_Number;
|
|
byte *Info_Element;
|
|
word Info_Mask = 0;
|
|
|
|
dbug(1, dprintf("SetupInfo"));
|
|
|
|
for (i = 0; i < MAXPARMSIDS; i++) {
|
|
ie = parms[i];
|
|
Info_Number = 0;
|
|
Info_Element = ie;
|
|
if (ie[0]) {
|
|
switch (i) {
|
|
case 0:
|
|
dbug(1, dprintf("CPN "));
|
|
Info_Number = 0x0070;
|
|
Info_Mask = 0x80;
|
|
Info_Sent_Flag = true;
|
|
break;
|
|
case 8: /* display */
|
|
dbug(1, dprintf("display(%d)", i));
|
|
Info_Number = 0x0028;
|
|
Info_Mask = 0x04;
|
|
Info_Sent_Flag = true;
|
|
break;
|
|
case 16: /* Channel Id */
|
|
dbug(1, dprintf("CHI"));
|
|
Info_Number = 0x0018;
|
|
Info_Mask = 0x100;
|
|
Info_Sent_Flag = true;
|
|
mixer_set_bchannel_id(plci, Info_Element);
|
|
break;
|
|
case 19: /* Redirected Number */
|
|
dbug(1, dprintf("RDN"));
|
|
Info_Number = 0x0074;
|
|
Info_Mask = 0x400;
|
|
Info_Sent_Flag = true;
|
|
break;
|
|
case 20: /* Redirected Number extended */
|
|
dbug(1, dprintf("RDX"));
|
|
Info_Number = 0x0073;
|
|
Info_Mask = 0x400;
|
|
Info_Sent_Flag = true;
|
|
break;
|
|
case 22: /* Redirecing Number */
|
|
dbug(1, dprintf("RIN"));
|
|
Info_Number = 0x0076;
|
|
Info_Mask = 0x400;
|
|
Info_Sent_Flag = true;
|
|
break;
|
|
default:
|
|
Info_Number = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == MAXPARMSIDS - 2) { /* to indicate the message type "Setup" */
|
|
Info_Number = 0x8000 | 5;
|
|
Info_Mask = 0x10;
|
|
Info_Element = "";
|
|
}
|
|
|
|
if (Info_Sent_Flag && Info_Number) {
|
|
if (plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask) {
|
|
sendf(appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void SendInfo(PLCI *plci, dword Id, byte **parms, byte iesent)
|
|
{
|
|
word i;
|
|
word j;
|
|
word k;
|
|
byte *ie;
|
|
word Info_Number;
|
|
byte *Info_Element;
|
|
word Info_Mask = 0;
|
|
static byte charges[5] = {4, 0, 0, 0, 0};
|
|
static byte cause[] = {0x02, 0x80, 0x00};
|
|
APPL *appl;
|
|
|
|
dbug(1, dprintf("InfoParse "));
|
|
|
|
if (
|
|
!plci->appl
|
|
&& !plci->State
|
|
&& plci->Sig.Ind != NCR_FACILITY
|
|
)
|
|
{
|
|
dbug(1, dprintf("NoParse "));
|
|
return;
|
|
}
|
|
cause[2] = 0;
|
|
for (i = 0; i < MAXPARMSIDS; i++) {
|
|
ie = parms[i];
|
|
Info_Number = 0;
|
|
Info_Element = ie;
|
|
if (ie[0]) {
|
|
switch (i) {
|
|
case 0:
|
|
dbug(1, dprintf("CPN "));
|
|
Info_Number = 0x0070;
|
|
Info_Mask = 0x80;
|
|
break;
|
|
case 7: /* ESC_CAU */
|
|
dbug(1, dprintf("cau(0x%x)", ie[2]));
|
|
Info_Number = 0x0008;
|
|
Info_Mask = 0x00;
|
|
cause[2] = ie[2];
|
|
Info_Element = NULL;
|
|
break;
|
|
case 8: /* display */
|
|
dbug(1, dprintf("display(%d)", i));
|
|
Info_Number = 0x0028;
|
|
Info_Mask = 0x04;
|
|
break;
|
|
case 9: /* Date display */
|
|
dbug(1, dprintf("date(%d)", i));
|
|
Info_Number = 0x0029;
|
|
Info_Mask = 0x02;
|
|
break;
|
|
case 10: /* charges */
|
|
for (j = 0; j < 4; j++) charges[1 + j] = 0;
|
|
for (j = 0; j < ie[0] && !(ie[1 + j] & 0x80); j++);
|
|
for (k = 1, j++; j < ie[0] && k <= 4; j++, k++) charges[k] = ie[1 + j];
|
|
Info_Number = 0x4000;
|
|
Info_Mask = 0x40;
|
|
Info_Element = charges;
|
|
break;
|
|
case 11: /* user user info */
|
|
dbug(1, dprintf("uui"));
|
|
Info_Number = 0x007E;
|
|
Info_Mask = 0x08;
|
|
break;
|
|
case 12: /* congestion receiver ready */
|
|
dbug(1, dprintf("clRDY"));
|
|
Info_Number = 0x00B0;
|
|
Info_Mask = 0x08;
|
|
Info_Element = "";
|
|
break;
|
|
case 13: /* congestion receiver not ready */
|
|
dbug(1, dprintf("clNRDY"));
|
|
Info_Number = 0x00BF;
|
|
Info_Mask = 0x08;
|
|
Info_Element = "";
|
|
break;
|
|
case 15: /* Keypad Facility */
|
|
dbug(1, dprintf("KEY"));
|
|
Info_Number = 0x002C;
|
|
Info_Mask = 0x20;
|
|
break;
|
|
case 16: /* Channel Id */
|
|
dbug(1, dprintf("CHI"));
|
|
Info_Number = 0x0018;
|
|
Info_Mask = 0x100;
|
|
mixer_set_bchannel_id(plci, Info_Element);
|
|
break;
|
|
case 17: /* if no 1tr6 cause, send full cause, else esc_cause */
|
|
dbug(1, dprintf("q9cau(0x%x)", ie[2]));
|
|
if (!cause[2] || cause[2] < 0x80) break; /* eg. layer 1 error */
|
|
Info_Number = 0x0008;
|
|
Info_Mask = 0x01;
|
|
if (cause[2] != ie[2]) Info_Element = cause;
|
|
break;
|
|
case 19: /* Redirected Number */
|
|
dbug(1, dprintf("RDN"));
|
|
Info_Number = 0x0074;
|
|
Info_Mask = 0x400;
|
|
break;
|
|
case 22: /* Redirecing Number */
|
|
dbug(1, dprintf("RIN"));
|
|
Info_Number = 0x0076;
|
|
Info_Mask = 0x400;
|
|
break;
|
|
case 23: /* Notification Indicator */
|
|
dbug(1, dprintf("NI"));
|
|
Info_Number = (word)NI;
|
|
Info_Mask = 0x210;
|
|
break;
|
|
case 26: /* Call State */
|
|
dbug(1, dprintf("CST"));
|
|
Info_Number = (word)CST;
|
|
Info_Mask = 0x01; /* do with cause i.e. for now */
|
|
break;
|
|
case MAXPARMSIDS - 2: /* Escape Message Type, must be the last indication */
|
|
dbug(1, dprintf("ESC/MT[0x%x]", ie[3]));
|
|
Info_Number = 0x8000 | ie[3];
|
|
if (iesent) Info_Mask = 0xffff;
|
|
else Info_Mask = 0x10;
|
|
Info_Element = "";
|
|
break;
|
|
default:
|
|
Info_Number = 0;
|
|
Info_Mask = 0;
|
|
Info_Element = "";
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (plci->Sig.Ind == NCR_FACILITY) /* check controller broadcast */
|
|
{
|
|
for (j = 0; j < max_appl; j++)
|
|
{
|
|
appl = &application[j];
|
|
if (Info_Number
|
|
&& appl->Id
|
|
&& plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask)
|
|
{
|
|
dbug(1, dprintf("NCR_Ind"));
|
|
iesent = true;
|
|
sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element);
|
|
}
|
|
}
|
|
}
|
|
else if (!plci->appl)
|
|
{ /* overlap receiving broadcast */
|
|
if (Info_Number == CPN
|
|
|| Info_Number == KEY
|
|
|| Info_Number == NI
|
|
|| Info_Number == DSP
|
|
|| Info_Number == UUI)
|
|
{
|
|
for (j = 0; j < max_appl; j++)
|
|
{
|
|
if (test_c_ind_mask_bit(plci, j))
|
|
{
|
|
dbug(1, dprintf("Ovl_Ind"));
|
|
iesent = true;
|
|
sendf(&application[j], _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
|
|
}
|
|
}
|
|
}
|
|
} /* all other signalling states */
|
|
else if (Info_Number
|
|
&& plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask)
|
|
{
|
|
dbug(1, dprintf("Std_Ind"));
|
|
iesent = true;
|
|
sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static byte SendMultiIE(PLCI *plci, dword Id, byte **parms, byte ie_type,
|
|
dword info_mask, byte setupParse)
|
|
{
|
|
word i;
|
|
word j;
|
|
byte *ie;
|
|
word Info_Number;
|
|
byte *Info_Element;
|
|
APPL *appl;
|
|
word Info_Mask = 0;
|
|
byte iesent = 0;
|
|
|
|
if (
|
|
!plci->appl
|
|
&& !plci->State
|
|
&& plci->Sig.Ind != NCR_FACILITY
|
|
&& !setupParse
|
|
)
|
|
{
|
|
dbug(1, dprintf("NoM-IEParse "));
|
|
return 0;
|
|
}
|
|
dbug(1, dprintf("M-IEParse "));
|
|
|
|
for (i = 0; i < MAX_MULTI_IE; i++)
|
|
{
|
|
ie = parms[i];
|
|
Info_Number = 0;
|
|
Info_Element = ie;
|
|
if (ie[0])
|
|
{
|
|
dbug(1, dprintf("[Ind0x%x]:IE=0x%x", plci->Sig.Ind, ie_type));
|
|
Info_Number = (word)ie_type;
|
|
Info_Mask = (word)info_mask;
|
|
}
|
|
|
|
if (plci->Sig.Ind == NCR_FACILITY) /* check controller broadcast */
|
|
{
|
|
for (j = 0; j < max_appl; j++)
|
|
{
|
|
appl = &application[j];
|
|
if (Info_Number
|
|
&& appl->Id
|
|
&& plci->adapter->Info_Mask[appl->Id - 1] & Info_Mask)
|
|
{
|
|
iesent = true;
|
|
dbug(1, dprintf("Mlt_NCR_Ind"));
|
|
sendf(&application[j], _INFO_I, Id & 0x0f, 0, "wS", Info_Number, Info_Element);
|
|
}
|
|
}
|
|
}
|
|
else if (!plci->appl && Info_Number)
|
|
{ /* overlap receiving broadcast */
|
|
for (j = 0; j < max_appl; j++)
|
|
{
|
|
if (test_c_ind_mask_bit(plci, j))
|
|
{
|
|
iesent = true;
|
|
dbug(1, dprintf("Mlt_Ovl_Ind"));
|
|
sendf(&application[j] , _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
|
|
}
|
|
}
|
|
} /* all other signalling states */
|
|
else if (Info_Number
|
|
&& plci->adapter->Info_Mask[plci->appl->Id - 1] & Info_Mask)
|
|
{
|
|
iesent = true;
|
|
dbug(1, dprintf("Mlt_Std_Ind"));
|
|
sendf(plci->appl, _INFO_I, Id, 0, "wS", Info_Number, Info_Element);
|
|
}
|
|
}
|
|
return iesent;
|
|
}
|
|
|
|
static void SendSSExtInd(APPL *appl, PLCI *plci, dword Id, byte **parms)
|
|
{
|
|
word i;
|
|
/* Format of multi_ssext_parms[i][]:
|
|
0 byte length
|
|
1 byte SSEXTIE
|
|
2 byte SSEXT_REQ/SSEXT_IND
|
|
3 byte length
|
|
4 word SSExtCommand
|
|
6... Params
|
|
*/
|
|
if (
|
|
plci
|
|
&& plci->State
|
|
&& plci->Sig.Ind != NCR_FACILITY
|
|
)
|
|
for (i = 0; i < MAX_MULTI_IE; i++)
|
|
{
|
|
if (parms[i][0] < 6) continue;
|
|
if (parms[i][2] == SSEXT_REQ) continue;
|
|
|
|
if (appl)
|
|
{
|
|
parms[i][0] = 0; /* kill it */
|
|
sendf(appl, _MANUFACTURER_I,
|
|
Id,
|
|
0,
|
|
"dwS",
|
|
_DI_MANU_ID,
|
|
_DI_SSEXT_CTRL,
|
|
&parms[i][3]);
|
|
}
|
|
else if (plci->appl)
|
|
{
|
|
parms[i][0] = 0; /* kill it */
|
|
sendf(plci->appl, _MANUFACTURER_I,
|
|
Id,
|
|
0,
|
|
"dwS",
|
|
_DI_MANU_ID,
|
|
_DI_SSEXT_CTRL,
|
|
&parms[i][3]);
|
|
}
|
|
}
|
|
};
|
|
|
|
static void nl_ind(PLCI *plci)
|
|
{
|
|
byte ch;
|
|
word ncci;
|
|
dword Id;
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word NCCIcode;
|
|
APPL *APPLptr;
|
|
word count;
|
|
word Num;
|
|
word i, ncpi_state;
|
|
byte len, ncci_state;
|
|
word msg;
|
|
word info = 0;
|
|
word fax_feature_bits;
|
|
byte fax_send_edata_ack;
|
|
static byte v120_header_buffer[2 + 3];
|
|
static word fax_info[] = {
|
|
0, /* T30_SUCCESS */
|
|
_FAX_NO_CONNECTION, /* T30_ERR_NO_DIS_RECEIVED */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_RESPONSE */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_RESPONSE */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_TOO_MANY_REPEATS */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_UNEXPECTED_MESSAGE */
|
|
_FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DCN */
|
|
_FAX_LOCAL_ABORT, /* T30_ERR_DTC_UNSUPPORTED */
|
|
_FAX_TRAINING_ERROR, /* T30_ERR_ALL_RATES_FAILED */
|
|
_FAX_TRAINING_ERROR, /* T30_ERR_TOO_MANY_TRAINS */
|
|
_FAX_PARAMETER_ERROR, /* T30_ERR_RECEIVE_CORRUPTED */
|
|
_FAX_REMOTE_ABORT, /* T30_ERR_UNEXPECTED_DISC */
|
|
_FAX_LOCAL_ABORT, /* T30_ERR_APPLICATION_DISC */
|
|
_FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_DIS */
|
|
_FAX_LOCAL_ABORT, /* T30_ERR_INCOMPATIBLE_DCS */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_NO_COMMAND */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_COMMAND */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_COMMAND_TOO_LONG */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_TIMEOUT_RESPONSE_TOO_LONG */
|
|
_FAX_NO_CONNECTION, /* T30_ERR_NOT_IDENTIFIED */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_SUPERVISORY_TIMEOUT */
|
|
_FAX_PARAMETER_ERROR, /* T30_ERR_TOO_LONG_SCAN_LINE */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_MPS */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_PAGE_AFTER_CFR */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_FTT */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_EOM */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCS_AFTER_MPS */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_MCF */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_DCN_AFTER_RTN */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_CFR */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOP */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_EOM */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_RETRY_NO_MCF_AFTER_MPS */
|
|
0x331d, /* T30_ERR_SUB_SEP_UNSUPPORTED */
|
|
0x331e, /* T30_ERR_PWD_UNSUPPORTED */
|
|
0x331f, /* T30_ERR_SUB_SEP_PWD_UNSUPPORTED */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_INVALID_COMMAND_FRAME */
|
|
_FAX_PARAMETER_ERROR, /* T30_ERR_UNSUPPORTED_PAGE_CODING */
|
|
_FAX_PARAMETER_ERROR, /* T30_ERR_INVALID_PAGE_CODING */
|
|
_FAX_REMOTE_REJECT, /* T30_ERR_INCOMPATIBLE_PAGE_CONFIG */
|
|
_FAX_LOCAL_ABORT, /* T30_ERR_TIMEOUT_FROM_APPLICATION */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_NO_REACTION_ON_MARK */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_TRAINING_TIMEOUT */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_UNEXPECTED_V21 */
|
|
_FAX_PROTOCOL_ERROR, /* T30_ERR_V34FAX_PRIMARY_CTS_ON */
|
|
_FAX_LOCAL_ABORT, /* T30_ERR_V34FAX_TURNAROUND_POLLING */
|
|
_FAX_LOCAL_ABORT /* T30_ERR_V34FAX_V8_INCOMPATIBILITY */
|
|
};
|
|
|
|
byte dtmf_code_buffer[CAPIDTMF_RECV_DIGIT_BUFFER_SIZE + 1];
|
|
|
|
|
|
static word rtp_info[] = {
|
|
GOOD, /* RTP_SUCCESS */
|
|
0x3600 /* RTP_ERR_SSRC_OR_PAYLOAD_CHANGE */
|
|
};
|
|
|
|
static dword udata_forwarding_table[0x100 / sizeof(dword)] =
|
|
{
|
|
0x0020301e, 0x00000000, 0x00000000, 0x00000000,
|
|
0x00000000, 0x00000000, 0x00000000, 0x00000000
|
|
};
|
|
|
|
ch = plci->NL.IndCh;
|
|
a = plci->adapter;
|
|
ncci = a->ch_ncci[ch];
|
|
Id = (((dword)(ncci ? ncci : ch)) << 16) | (((word) plci->Id) << 8) | a->Id;
|
|
if (plci->tel) Id |= EXT_CONTROLLER;
|
|
APPLptr = plci->appl;
|
|
dbug(1, dprintf("NL_IND-Id(NL:0x%x)=0x%08lx,plci=%x,tel=%x,state=0x%x,ch=0x%x,chs=%d,Ind=%x",
|
|
plci->NL.Id, Id, plci->Id, plci->tel, plci->State, ch, plci->channels, plci->NL.Ind & 0x0f));
|
|
|
|
/* in the case if no connect_active_Ind was sent to the appl we wait for */
|
|
|
|
if (plci->nl_remove_id)
|
|
{
|
|
plci->NL.RNR = 2; /* discard */
|
|
dbug(1, dprintf("NL discard while remove pending"));
|
|
return;
|
|
}
|
|
if ((plci->NL.Ind & 0x0f) == N_CONNECT)
|
|
{
|
|
if (plci->State == INC_DIS_PENDING
|
|
|| plci->State == OUTG_DIS_PENDING
|
|
|| plci->State == IDLE)
|
|
{
|
|
plci->NL.RNR = 2; /* discard */
|
|
dbug(1, dprintf("discard n_connect"));
|
|
return;
|
|
}
|
|
if (plci->State < INC_ACT_PENDING)
|
|
{
|
|
plci->NL.RNR = 1; /* flow control */
|
|
channel_x_off(plci, ch, N_XON_CONNECT_IND);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!APPLptr) /* no application or invalid data */
|
|
{ /* while reloading the DSP */
|
|
dbug(1, dprintf("discard1"));
|
|
plci->NL.RNR = 2;
|
|
return;
|
|
}
|
|
|
|
if (((plci->NL.Ind & 0x0f) == N_UDATA)
|
|
&& (((plci->B2_prot != B2_SDLC) && ((plci->B1_resource == 17) || (plci->B1_resource == 18)))
|
|
|| (plci->B2_prot == 7)
|
|
|| (plci->B3_prot == 7)))
|
|
{
|
|
plci->ncpi_buffer[0] = 0;
|
|
|
|
ncpi_state = plci->ncpi_state;
|
|
if (plci->NL.complete == 1)
|
|
{
|
|
byte *data = &plci->NL.RBuffer->P[0];
|
|
|
|
if ((plci->NL.RBuffer->length >= 12)
|
|
&& ((*data == DSP_UDATA_INDICATION_DCD_ON)
|
|
|| (*data == DSP_UDATA_INDICATION_CTS_ON)))
|
|
{
|
|
word conn_opt, ncpi_opt = 0x00;
|
|
/* HexDump ("MDM N_UDATA:", plci->NL.RBuffer->length, data); */
|
|
|
|
if (*data == DSP_UDATA_INDICATION_DCD_ON)
|
|
plci->ncpi_state |= NCPI_MDM_DCD_ON_RECEIVED;
|
|
if (*data == DSP_UDATA_INDICATION_CTS_ON)
|
|
plci->ncpi_state |= NCPI_MDM_CTS_ON_RECEIVED;
|
|
|
|
data++; /* indication code */
|
|
data += 2; /* timestamp */
|
|
if ((*data == DSP_CONNECTED_NORM_V18) || (*data == DSP_CONNECTED_NORM_VOWN))
|
|
ncpi_state &= ~(NCPI_MDM_DCD_ON_RECEIVED | NCPI_MDM_CTS_ON_RECEIVED);
|
|
data++; /* connected norm */
|
|
conn_opt = GET_WORD(data);
|
|
data += 2; /* connected options */
|
|
|
|
PUT_WORD(&(plci->ncpi_buffer[1]), (word)(GET_DWORD(data) & 0x0000FFFF));
|
|
|
|
if (conn_opt & DSP_CONNECTED_OPTION_MASK_V42)
|
|
{
|
|
ncpi_opt |= MDM_NCPI_ECM_V42;
|
|
}
|
|
else if (conn_opt & DSP_CONNECTED_OPTION_MASK_MNP)
|
|
{
|
|
ncpi_opt |= MDM_NCPI_ECM_MNP;
|
|
}
|
|
else
|
|
{
|
|
ncpi_opt |= MDM_NCPI_TRANSPARENT;
|
|
}
|
|
if (conn_opt & DSP_CONNECTED_OPTION_MASK_COMPRESSION)
|
|
{
|
|
ncpi_opt |= MDM_NCPI_COMPRESSED;
|
|
}
|
|
PUT_WORD(&(plci->ncpi_buffer[3]), ncpi_opt);
|
|
plci->ncpi_buffer[0] = 4;
|
|
|
|
plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND | NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
|
|
}
|
|
}
|
|
if (plci->B3_prot == 7)
|
|
{
|
|
if (((a->ncci_state[ncci] == INC_ACT_PENDING) || (a->ncci_state[ncci] == OUTG_CON_PENDING))
|
|
&& (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
|
|
&& !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
|
|
{
|
|
a->ncci_state[ncci] = INC_ACT_PENDING;
|
|
sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
|
|
plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
|
|
}
|
|
}
|
|
|
|
if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
|
|
& ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
|
|
|| !(ncpi_state & NCPI_MDM_DCD_ON_RECEIVED)
|
|
|| !(ncpi_state & NCPI_MDM_CTS_ON_RECEIVED))
|
|
|
|
{
|
|
plci->NL.RNR = 2;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (plci->NL.complete == 2)
|
|
{
|
|
if (((plci->NL.Ind & 0x0f) == N_UDATA)
|
|
&& !(udata_forwarding_table[plci->RData[0].P[0] >> 5] & (1L << (plci->RData[0].P[0] & 0x1f))))
|
|
{
|
|
switch (plci->RData[0].P[0])
|
|
{
|
|
|
|
case DTMF_UDATA_INDICATION_FAX_CALLING_TONE:
|
|
if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
|
|
sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01X");
|
|
break;
|
|
case DTMF_UDATA_INDICATION_ANSWER_TONE:
|
|
if (plci->dtmf_rec_active & DTMF_LISTEN_ACTIVE_FLAG)
|
|
sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", SELECTOR_DTMF, "\x01Y");
|
|
break;
|
|
case DTMF_UDATA_INDICATION_DIGITS_RECEIVED:
|
|
dtmf_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
|
|
break;
|
|
case DTMF_UDATA_INDICATION_DIGITS_SENT:
|
|
dtmf_confirmation(Id, plci);
|
|
break;
|
|
|
|
|
|
case UDATA_INDICATION_MIXER_TAP_DATA:
|
|
capidtmf_recv_process_block(&(plci->capidtmf_state), plci->RData[0].P + 1, (word)(plci->RData[0].PLength - 1));
|
|
i = capidtmf_indication(&(plci->capidtmf_state), dtmf_code_buffer + 1);
|
|
if (i != 0)
|
|
{
|
|
dtmf_code_buffer[0] = DTMF_UDATA_INDICATION_DIGITS_RECEIVED;
|
|
dtmf_indication(Id, plci, dtmf_code_buffer, (word)(i + 1));
|
|
}
|
|
break;
|
|
|
|
|
|
case UDATA_INDICATION_MIXER_COEFS_SET:
|
|
mixer_indication_coefs_set(Id, plci);
|
|
break;
|
|
case UDATA_INDICATION_XCONNECT_FROM:
|
|
mixer_indication_xconnect_from(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
|
|
break;
|
|
case UDATA_INDICATION_XCONNECT_TO:
|
|
mixer_indication_xconnect_to(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
|
|
break;
|
|
|
|
|
|
case LEC_UDATA_INDICATION_DISABLE_DETECT:
|
|
ec_indication(Id, plci, plci->RData[0].P, plci->RData[0].PLength);
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((plci->RData[0].PLength != 0)
|
|
&& ((plci->B2_prot == B2_V120_ASYNC)
|
|
|| (plci->B2_prot == B2_V120_ASYNC_V42BIS)
|
|
|| (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
|
|
{
|
|
|
|
sendf(plci->appl, _DATA_B3_I, Id, 0,
|
|
"dwww",
|
|
plci->RData[1].P,
|
|
(plci->NL.RNum < 2) ? 0 : plci->RData[1].PLength,
|
|
plci->RNum,
|
|
plci->RFlags);
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
sendf(plci->appl, _DATA_B3_I, Id, 0,
|
|
"dwww",
|
|
plci->RData[0].P,
|
|
plci->RData[0].PLength,
|
|
plci->RNum,
|
|
plci->RFlags);
|
|
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
fax_feature_bits = 0;
|
|
if ((plci->NL.Ind & 0x0f) == N_CONNECT ||
|
|
(plci->NL.Ind & 0x0f) == N_CONNECT_ACK ||
|
|
(plci->NL.Ind & 0x0f) == N_DISC ||
|
|
(plci->NL.Ind & 0x0f) == N_EDATA ||
|
|
(plci->NL.Ind & 0x0f) == N_DISC_ACK)
|
|
{
|
|
info = 0;
|
|
plci->ncpi_buffer[0] = 0;
|
|
switch (plci->B3_prot) {
|
|
case 0: /*XPARENT*/
|
|
case 1: /*T.90 NL*/
|
|
break; /* no network control protocol info - jfr */
|
|
case 2: /*ISO8202*/
|
|
case 3: /*X25 DCE*/
|
|
for (i = 0; i < plci->NL.RLength; i++) plci->ncpi_buffer[4 + i] = plci->NL.RBuffer->P[i];
|
|
plci->ncpi_buffer[0] = (byte)(i + 3);
|
|
plci->ncpi_buffer[1] = (byte)(plci->NL.Ind & N_D_BIT ? 1 : 0);
|
|
plci->ncpi_buffer[2] = 0;
|
|
plci->ncpi_buffer[3] = 0;
|
|
break;
|
|
case 4: /*T.30 - FAX*/
|
|
case 5: /*T.30 - FAX*/
|
|
if (plci->NL.RLength >= sizeof(T30_INFO))
|
|
{
|
|
dbug(1, dprintf("FaxStatus %04x", ((T30_INFO *)plci->NL.RBuffer->P)->code));
|
|
len = 9;
|
|
PUT_WORD(&(plci->ncpi_buffer[1]), ((T30_INFO *)plci->NL.RBuffer->P)->rate_div_2400 * 2400);
|
|
fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
|
|
i = (((T30_INFO *)plci->NL.RBuffer->P)->resolution & T30_RESOLUTION_R8_0770_OR_200) ? 0x0001 : 0x0000;
|
|
if (plci->B3_prot == 5)
|
|
{
|
|
if (!(fax_feature_bits & T30_FEATURE_BIT_ECM))
|
|
i |= 0x8000; /* This is not an ECM connection */
|
|
if (fax_feature_bits & T30_FEATURE_BIT_T6_CODING)
|
|
i |= 0x4000; /* This is a connection with MMR compression */
|
|
if (fax_feature_bits & T30_FEATURE_BIT_2D_CODING)
|
|
i |= 0x2000; /* This is a connection with MR compression */
|
|
if (fax_feature_bits & T30_FEATURE_BIT_MORE_DOCUMENTS)
|
|
i |= 0x0004; /* More documents */
|
|
if (fax_feature_bits & T30_FEATURE_BIT_POLLING)
|
|
i |= 0x0002; /* Fax-polling indication */
|
|
}
|
|
dbug(1, dprintf("FAX Options %04x %04x", fax_feature_bits, i));
|
|
PUT_WORD(&(plci->ncpi_buffer[3]), i);
|
|
PUT_WORD(&(plci->ncpi_buffer[5]), ((T30_INFO *)plci->NL.RBuffer->P)->data_format);
|
|
plci->ncpi_buffer[7] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_low;
|
|
plci->ncpi_buffer[8] = ((T30_INFO *)plci->NL.RBuffer->P)->pages_high;
|
|
plci->ncpi_buffer[len] = 0;
|
|
if (((T30_INFO *)plci->NL.RBuffer->P)->station_id_len)
|
|
{
|
|
plci->ncpi_buffer[len] = 20;
|
|
for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
|
|
plci->ncpi_buffer[++len] = ((T30_INFO *)plci->NL.RBuffer->P)->station_id[i];
|
|
}
|
|
if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
|
|
{
|
|
if (((T30_INFO *)plci->NL.RBuffer->P)->code < ARRAY_SIZE(fax_info))
|
|
info = fax_info[((T30_INFO *)plci->NL.RBuffer->P)->code];
|
|
else
|
|
info = _FAX_PROTOCOL_ERROR;
|
|
}
|
|
|
|
if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
|
|
& ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
|
|
{
|
|
i = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + ((T30_INFO *)plci->NL.RBuffer->P)->head_line_len;
|
|
while (i < plci->NL.RBuffer->length)
|
|
plci->ncpi_buffer[++len] = plci->NL.RBuffer->P[i++];
|
|
}
|
|
|
|
plci->ncpi_buffer[0] = len;
|
|
fax_feature_bits = GET_WORD(&((T30_INFO *)plci->NL.RBuffer->P)->feature_bits_low);
|
|
PUT_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->feature_bits_low, fax_feature_bits);
|
|
|
|
plci->ncpi_state |= NCPI_VALID_CONNECT_B3_IND;
|
|
if (((plci->NL.Ind & 0x0f) == N_CONNECT_ACK)
|
|
|| (((plci->NL.Ind & 0x0f) == N_CONNECT)
|
|
&& (fax_feature_bits & T30_FEATURE_BIT_POLLING))
|
|
|| (((plci->NL.Ind & 0x0f) == N_EDATA)
|
|
&& ((((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_TRAIN_OK)
|
|
|| (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
|
|
|| (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DTC))))
|
|
{
|
|
plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT;
|
|
}
|
|
if (((plci->NL.Ind & 0x0f) == N_DISC)
|
|
|| ((plci->NL.Ind & 0x0f) == N_DISC_ACK)
|
|
|| (((plci->NL.Ind & 0x0f) == N_EDATA)
|
|
&& (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_EOP_CAPI)))
|
|
{
|
|
plci->ncpi_state |= NCPI_VALID_CONNECT_B3_ACT | NCPI_VALID_DISC_B3_IND;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case B3_RTP:
|
|
if (((plci->NL.Ind & 0x0f) == N_DISC) || ((plci->NL.Ind & 0x0f) == N_DISC_ACK))
|
|
{
|
|
if (plci->NL.RLength != 0)
|
|
{
|
|
info = rtp_info[plci->NL.RBuffer->P[0]];
|
|
plci->ncpi_buffer[0] = plci->NL.RLength - 1;
|
|
for (i = 1; i < plci->NL.RLength; i++)
|
|
plci->ncpi_buffer[i] = plci->NL.RBuffer->P[i];
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
plci->NL.RNR = 2;
|
|
}
|
|
switch (plci->NL.Ind & 0x0f) {
|
|
case N_EDATA:
|
|
if ((plci->B3_prot == 4) || (plci->B3_prot == 5))
|
|
{
|
|
dbug(1, dprintf("EDATA ncci=0x%x state=%d code=%02x", ncci, a->ncci_state[ncci],
|
|
((T30_INFO *)plci->NL.RBuffer->P)->code));
|
|
fax_send_edata_ack = (((T30_INFO *)(plci->fax_connect_info_buffer))->operating_mode == T30_OPERATING_MODE_CAPI_NEG);
|
|
|
|
if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
|
|
&& (plci->nsf_control_bits & (T30_NSF_CONTROL_BIT_NEGOTIATE_IND | T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
|
|
&& (((T30_INFO *)plci->NL.RBuffer->P)->code == EDATA_T30_DIS)
|
|
&& (a->ncci_state[ncci] == OUTG_CON_PENDING)
|
|
&& (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
|
|
&& !(plci->ncpi_state & NCPI_NEGOTIATE_B3_SENT))
|
|
{
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
|
|
sendf(plci->appl, _MANUFACTURER_I, Id, 0, "dwbS", _DI_MANU_ID, _DI_NEGOTIATE_B3,
|
|
(byte)(plci->ncpi_buffer[0] + 1), plci->ncpi_buffer);
|
|
plci->ncpi_state |= NCPI_NEGOTIATE_B3_SENT;
|
|
if (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP)
|
|
fax_send_edata_ack = false;
|
|
}
|
|
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
|
|
{
|
|
switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
|
|
{
|
|
case EDATA_T30_DIS:
|
|
if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
|
|
&& !(GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) & T30_CONTROL_BIT_REQUEST_POLLING)
|
|
&& (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
|
|
&& !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
|
|
{
|
|
a->ncci_state[ncci] = INC_ACT_PENDING;
|
|
if (plci->B3_prot == 4)
|
|
sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
|
|
else
|
|
sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
|
|
plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
|
|
}
|
|
break;
|
|
|
|
case EDATA_T30_TRAIN_OK:
|
|
if ((a->ncci_state[ncci] == INC_ACT_PENDING)
|
|
&& (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
|
|
&& !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
|
|
{
|
|
if (plci->B3_prot == 4)
|
|
sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
|
|
else
|
|
sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
|
|
plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
|
|
}
|
|
break;
|
|
|
|
case EDATA_T30_EOP_CAPI:
|
|
if (a->ncci_state[ncci] == CONNECTED)
|
|
{
|
|
sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", GOOD, plci->ncpi_buffer);
|
|
a->ncci_state[ncci] = INC_DIS_PENDING;
|
|
plci->ncpi_state = 0;
|
|
fax_send_edata_ack = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (((T30_INFO *)plci->NL.RBuffer->P)->code)
|
|
{
|
|
case EDATA_T30_TRAIN_OK:
|
|
if ((a->ncci_state[ncci] == INC_ACT_PENDING)
|
|
&& (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
|
|
&& !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
|
|
{
|
|
if (plci->B3_prot == 4)
|
|
sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
|
|
else
|
|
sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
|
|
plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (fax_send_edata_ack)
|
|
{
|
|
((T30_INFO *)(plci->fax_connect_info_buffer))->code = ((T30_INFO *)plci->NL.RBuffer->P)->code;
|
|
plci->fax_edata_ack_length = 1;
|
|
start_internal_command(Id, plci, fax_edata_ack_command);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dbug(1, dprintf("EDATA ncci=0x%x state=%d", ncci, a->ncci_state[ncci]));
|
|
}
|
|
break;
|
|
case N_CONNECT:
|
|
if (!a->ch_ncci[ch])
|
|
{
|
|
ncci = get_ncci(plci, ch, 0);
|
|
Id = (Id & 0xffff) | (((dword) ncci) << 16);
|
|
}
|
|
dbug(1, dprintf("N_CONNECT: ch=%d state=%d plci=%lx plci_Id=%lx plci_State=%d",
|
|
ch, a->ncci_state[ncci], a->ncci_plci[ncci], plci->Id, plci->State));
|
|
|
|
msg = _CONNECT_B3_I;
|
|
if (a->ncci_state[ncci] == IDLE)
|
|
plci->channels++;
|
|
else if (plci->B3_prot == 1)
|
|
msg = _CONNECT_B3_T90_ACTIVE_I;
|
|
|
|
a->ncci_state[ncci] = INC_CON_PENDING;
|
|
if (plci->B3_prot == 4)
|
|
sendf(plci->appl, msg, Id, 0, "s", "");
|
|
else
|
|
sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
|
|
break;
|
|
case N_CONNECT_ACK:
|
|
dbug(1, dprintf("N_connect_Ack"));
|
|
if (plci->internal_command_queue[0]
|
|
&& ((plci->adjust_b_state == ADJUST_B_CONNECT_2)
|
|
|| (plci->adjust_b_state == ADJUST_B_CONNECT_3)
|
|
|| (plci->adjust_b_state == ADJUST_B_CONNECT_4)))
|
|
{
|
|
(*(plci->internal_command_queue[0]))(Id, plci, 0);
|
|
if (!plci->internal_command)
|
|
next_internal_command(Id, plci);
|
|
break;
|
|
}
|
|
msg = _CONNECT_B3_ACTIVE_I;
|
|
if (plci->B3_prot == 1)
|
|
{
|
|
if (a->ncci_state[ncci] != OUTG_CON_PENDING)
|
|
msg = _CONNECT_B3_T90_ACTIVE_I;
|
|
a->ncci_state[ncci] = INC_ACT_PENDING;
|
|
sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
|
|
}
|
|
else if ((plci->B3_prot == 4) || (plci->B3_prot == 5) || (plci->B3_prot == 7))
|
|
{
|
|
if ((a->ncci_state[ncci] == OUTG_CON_PENDING)
|
|
&& (plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
|
|
&& !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
|
|
{
|
|
a->ncci_state[ncci] = INC_ACT_PENDING;
|
|
if (plci->B3_prot == 4)
|
|
sendf(plci->appl, msg, Id, 0, "s", "");
|
|
else
|
|
sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
|
|
plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
a->ncci_state[ncci] = INC_ACT_PENDING;
|
|
sendf(plci->appl, msg, Id, 0, "S", plci->ncpi_buffer);
|
|
}
|
|
if (plci->adjust_b_restore)
|
|
{
|
|
plci->adjust_b_restore = false;
|
|
start_internal_command(Id, plci, adjust_b_restore);
|
|
}
|
|
break;
|
|
case N_DISC:
|
|
case N_DISC_ACK:
|
|
if (plci->internal_command_queue[0]
|
|
&& ((plci->internal_command == FAX_DISCONNECT_COMMAND_1)
|
|
|| (plci->internal_command == FAX_DISCONNECT_COMMAND_2)
|
|
|| (plci->internal_command == FAX_DISCONNECT_COMMAND_3)))
|
|
{
|
|
(*(plci->internal_command_queue[0]))(Id, plci, 0);
|
|
if (!plci->internal_command)
|
|
next_internal_command(Id, plci);
|
|
}
|
|
ncci_state = a->ncci_state[ncci];
|
|
ncci_remove(plci, ncci, false);
|
|
|
|
/* with N_DISC or N_DISC_ACK the IDI frees the respective */
|
|
/* channel, so we cannot store the state in ncci_state! The */
|
|
/* information which channel we received a N_DISC is thus */
|
|
/* stored in the inc_dis_ncci_table buffer. */
|
|
for (i = 0; plci->inc_dis_ncci_table[i]; i++);
|
|
plci->inc_dis_ncci_table[i] = (byte) ncci;
|
|
|
|
/* need a connect_b3_ind before a disconnect_b3_ind with FAX */
|
|
if (!plci->channels
|
|
&& (plci->B1_resource == 16)
|
|
&& (plci->State <= CONNECTED))
|
|
{
|
|
len = 9;
|
|
i = ((T30_INFO *)plci->fax_connect_info_buffer)->rate_div_2400 * 2400;
|
|
PUT_WORD(&plci->ncpi_buffer[1], i);
|
|
PUT_WORD(&plci->ncpi_buffer[3], 0);
|
|
i = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
|
|
PUT_WORD(&plci->ncpi_buffer[5], i);
|
|
PUT_WORD(&plci->ncpi_buffer[7], 0);
|
|
plci->ncpi_buffer[len] = 0;
|
|
plci->ncpi_buffer[0] = len;
|
|
if (plci->B3_prot == 4)
|
|
sendf(plci->appl, _CONNECT_B3_I, Id, 0, "s", "");
|
|
else
|
|
{
|
|
|
|
if ((plci->requested_options_conn | plci->requested_options | a->requested_options_table[plci->appl->Id - 1])
|
|
& ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
|
|
{
|
|
plci->ncpi_buffer[++len] = 0;
|
|
plci->ncpi_buffer[++len] = 0;
|
|
plci->ncpi_buffer[++len] = 0;
|
|
plci->ncpi_buffer[0] = len;
|
|
}
|
|
|
|
sendf(plci->appl, _CONNECT_B3_I, Id, 0, "S", plci->ncpi_buffer);
|
|
}
|
|
sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer);
|
|
plci->ncpi_state = 0;
|
|
sig_req(plci, HANGUP, 0);
|
|
send_req(plci);
|
|
plci->State = OUTG_DIS_PENDING;
|
|
/* disc here */
|
|
}
|
|
else if ((a->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
|
|
&& ((plci->B3_prot == 4) || (plci->B3_prot == 5))
|
|
&& ((ncci_state == INC_DIS_PENDING) || (ncci_state == IDLE)))
|
|
{
|
|
if (ncci_state == IDLE)
|
|
{
|
|
if (plci->channels)
|
|
plci->channels--;
|
|
if ((plci->State == IDLE || plci->State == SUSPENDING) && !plci->channels) {
|
|
if (plci->State == SUSPENDING) {
|
|
sendf(plci->appl,
|
|
_FACILITY_I,
|
|
Id & 0xffffL,
|
|
0,
|
|
"ws", (word)3, "\x03\x04\x00\x00");
|
|
sendf(plci->appl, _DISCONNECT_I, Id & 0xffffL, 0, "w", 0);
|
|
}
|
|
plci_remove(plci);
|
|
plci->State = IDLE;
|
|
}
|
|
}
|
|
}
|
|
else if (plci->channels)
|
|
{
|
|
sendf(plci->appl, _DISCONNECT_B3_I, Id, 0, "wS", info, plci->ncpi_buffer);
|
|
plci->ncpi_state = 0;
|
|
if ((ncci_state == OUTG_REJ_PENDING)
|
|
&& ((plci->B3_prot != B3_T90NL) && (plci->B3_prot != B3_ISO8208) && (plci->B3_prot != B3_X25_DCE)))
|
|
{
|
|
sig_req(plci, HANGUP, 0);
|
|
send_req(plci);
|
|
plci->State = OUTG_DIS_PENDING;
|
|
}
|
|
}
|
|
break;
|
|
case N_RESET:
|
|
a->ncci_state[ncci] = INC_RES_PENDING;
|
|
sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer);
|
|
break;
|
|
case N_RESET_ACK:
|
|
a->ncci_state[ncci] = CONNECTED;
|
|
sendf(plci->appl, _RESET_B3_I, Id, 0, "S", plci->ncpi_buffer);
|
|
break;
|
|
|
|
case N_UDATA:
|
|
if (!(udata_forwarding_table[plci->NL.RBuffer->P[0] >> 5] & (1L << (plci->NL.RBuffer->P[0] & 0x1f))))
|
|
{
|
|
plci->RData[0].P = plci->internal_ind_buffer + (-((int)(long)(plci->internal_ind_buffer)) & 3);
|
|
plci->RData[0].PLength = INTERNAL_IND_BUFFER_SIZE;
|
|
plci->NL.R = plci->RData;
|
|
plci->NL.RNum = 1;
|
|
return;
|
|
}
|
|
case N_BDATA:
|
|
case N_DATA:
|
|
if (((a->ncci_state[ncci] != CONNECTED) && (plci->B2_prot == 1)) /* transparent */
|
|
|| (a->ncci_state[ncci] == IDLE)
|
|
|| (a->ncci_state[ncci] == INC_DIS_PENDING))
|
|
{
|
|
plci->NL.RNR = 2;
|
|
break;
|
|
}
|
|
if ((a->ncci_state[ncci] != CONNECTED)
|
|
&& (a->ncci_state[ncci] != OUTG_DIS_PENDING)
|
|
&& (a->ncci_state[ncci] != OUTG_REJ_PENDING))
|
|
{
|
|
dbug(1, dprintf("flow control"));
|
|
plci->NL.RNR = 1; /* flow control */
|
|
channel_x_off(plci, ch, 0);
|
|
break;
|
|
}
|
|
|
|
NCCIcode = ncci | (((word)a->Id) << 8);
|
|
|
|
/* count all buffers within the Application pool */
|
|
/* belonging to the same NCCI. If this is below the */
|
|
/* number of buffers available per NCCI we accept */
|
|
/* this packet, otherwise we reject it */
|
|
count = 0;
|
|
Num = 0xffff;
|
|
for (i = 0; i < APPLptr->MaxBuffer; i++) {
|
|
if (NCCIcode == APPLptr->DataNCCI[i]) count++;
|
|
if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i;
|
|
}
|
|
|
|
if (count >= APPLptr->MaxNCCIData || Num == 0xffff)
|
|
{
|
|
dbug(3, dprintf("Flow-Control"));
|
|
plci->NL.RNR = 1;
|
|
if (++(APPLptr->NCCIDataFlowCtrlTimer) >=
|
|
(word)((a->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL) ? 40 : 2000))
|
|
{
|
|
plci->NL.RNR = 2;
|
|
dbug(3, dprintf("DiscardData"));
|
|
} else {
|
|
channel_x_off(plci, ch, 0);
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
APPLptr->NCCIDataFlowCtrlTimer = 0;
|
|
}
|
|
|
|
plci->RData[0].P = ReceiveBufferGet(APPLptr, Num);
|
|
if (!plci->RData[0].P) {
|
|
plci->NL.RNR = 1;
|
|
channel_x_off(plci, ch, 0);
|
|
break;
|
|
}
|
|
|
|
APPLptr->DataNCCI[Num] = NCCIcode;
|
|
APPLptr->DataFlags[Num] = (plci->Id << 8) | (plci->NL.Ind >> 4);
|
|
dbug(3, dprintf("Buffer(%d), Max = %d", Num, APPLptr->MaxBuffer));
|
|
|
|
plci->RNum = Num;
|
|
plci->RFlags = plci->NL.Ind >> 4;
|
|
plci->RData[0].PLength = APPLptr->MaxDataLength;
|
|
plci->NL.R = plci->RData;
|
|
if ((plci->NL.RLength != 0)
|
|
&& ((plci->B2_prot == B2_V120_ASYNC)
|
|
|| (plci->B2_prot == B2_V120_ASYNC_V42BIS)
|
|
|| (plci->B2_prot == B2_V120_BIT_TRANSPARENT)))
|
|
{
|
|
plci->RData[1].P = plci->RData[0].P;
|
|
plci->RData[1].PLength = plci->RData[0].PLength;
|
|
plci->RData[0].P = v120_header_buffer + (-((unsigned long)v120_header_buffer) & 3);
|
|
if ((plci->NL.RBuffer->P[0] & V120_HEADER_EXTEND_BIT) || (plci->NL.RLength == 1))
|
|
plci->RData[0].PLength = 1;
|
|
else
|
|
plci->RData[0].PLength = 2;
|
|
if (plci->NL.RBuffer->P[0] & V120_HEADER_BREAK_BIT)
|
|
plci->RFlags |= 0x0010;
|
|
if (plci->NL.RBuffer->P[0] & (V120_HEADER_C1_BIT | V120_HEADER_C2_BIT))
|
|
plci->RFlags |= 0x8000;
|
|
plci->NL.RNum = 2;
|
|
}
|
|
else
|
|
{
|
|
if ((plci->NL.Ind & 0x0f) == N_UDATA)
|
|
plci->RFlags |= 0x0010;
|
|
|
|
else if ((plci->B3_prot == B3_RTP) && ((plci->NL.Ind & 0x0f) == N_BDATA))
|
|
plci->RFlags |= 0x0001;
|
|
|
|
plci->NL.RNum = 1;
|
|
}
|
|
break;
|
|
case N_DATA_ACK:
|
|
data_ack(plci, ch);
|
|
break;
|
|
default:
|
|
plci->NL.RNR = 2;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* find a free PLCI */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static word get_plci(DIVA_CAPI_ADAPTER *a)
|
|
{
|
|
word i, j;
|
|
PLCI *plci;
|
|
|
|
dump_plcis(a);
|
|
for (i = 0; i < a->max_plci && a->plci[i].Id; i++);
|
|
if (i == a->max_plci) {
|
|
dbug(1, dprintf("get_plci: out of PLCIs"));
|
|
return 0;
|
|
}
|
|
plci = &a->plci[i];
|
|
plci->Id = (byte)(i + 1);
|
|
|
|
plci->Sig.Id = 0;
|
|
plci->NL.Id = 0;
|
|
plci->sig_req = 0;
|
|
plci->nl_req = 0;
|
|
|
|
plci->appl = NULL;
|
|
plci->relatedPTYPLCI = NULL;
|
|
plci->State = IDLE;
|
|
plci->SuppState = IDLE;
|
|
plci->channels = 0;
|
|
plci->tel = 0;
|
|
plci->B1_resource = 0;
|
|
plci->B2_prot = 0;
|
|
plci->B3_prot = 0;
|
|
|
|
plci->command = 0;
|
|
plci->m_command = 0;
|
|
init_internal_command_queue(plci);
|
|
plci->number = 0;
|
|
plci->req_in_start = 0;
|
|
plci->req_in = 0;
|
|
plci->req_out = 0;
|
|
plci->msg_in_write_pos = MSG_IN_QUEUE_SIZE;
|
|
plci->msg_in_read_pos = MSG_IN_QUEUE_SIZE;
|
|
plci->msg_in_wrap_pos = MSG_IN_QUEUE_SIZE;
|
|
|
|
plci->data_sent = false;
|
|
plci->send_disc = 0;
|
|
plci->sig_global_req = 0;
|
|
plci->sig_remove_id = 0;
|
|
plci->nl_global_req = 0;
|
|
plci->nl_remove_id = 0;
|
|
plci->adv_nl = 0;
|
|
plci->manufacturer = false;
|
|
plci->call_dir = CALL_DIR_OUT | CALL_DIR_ORIGINATE;
|
|
plci->spoofed_msg = 0;
|
|
plci->ptyState = 0;
|
|
plci->cr_enquiry = false;
|
|
plci->hangup_flow_ctrl_timer = 0;
|
|
|
|
plci->ncci_ring_list = 0;
|
|
for (j = 0; j < MAX_CHANNELS_PER_PLCI; j++) plci->inc_dis_ncci_table[j] = 0;
|
|
clear_c_ind_mask(plci);
|
|
set_group_ind_mask(plci);
|
|
plci->fax_connect_info_length = 0;
|
|
plci->nsf_control_bits = 0;
|
|
plci->ncpi_state = 0x00;
|
|
plci->ncpi_buffer[0] = 0;
|
|
|
|
plci->requested_options_conn = 0;
|
|
plci->requested_options = 0;
|
|
plci->notifiedcall = 0;
|
|
plci->vswitchstate = 0;
|
|
plci->vsprot = 0;
|
|
plci->vsprotdialect = 0;
|
|
init_b1_config(plci);
|
|
dbug(1, dprintf("get_plci(%x)", plci->Id));
|
|
return i + 1;
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* put a parameter in the parameter buffer */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void add_p(PLCI *plci, byte code, byte *p)
|
|
{
|
|
word p_length;
|
|
|
|
p_length = 0;
|
|
if (p) p_length = p[0];
|
|
add_ie(plci, code, p, p_length);
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* put a structure in the parameter buffer */
|
|
/*------------------------------------------------------------------*/
|
|
static void add_s(PLCI *plci, byte code, API_PARSE *p)
|
|
{
|
|
if (p) add_ie(plci, code, p->info, (word)p->length);
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* put multiple structures in the parameter buffer */
|
|
/*------------------------------------------------------------------*/
|
|
static void add_ss(PLCI *plci, byte code, API_PARSE *p)
|
|
{
|
|
byte i;
|
|
|
|
if (p) {
|
|
dbug(1, dprintf("add_ss(%x,len=%d)", code, p->length));
|
|
for (i = 2; i < (byte)p->length; i += p->info[i] + 2) {
|
|
dbug(1, dprintf("add_ss_ie(%x,len=%d)", p->info[i - 1], p->info[i]));
|
|
add_ie(plci, p->info[i - 1], (byte *)&(p->info[i]), (word)p->info[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* return the channel number sent by the application in a esc_chi */
|
|
/*------------------------------------------------------------------*/
|
|
static byte getChannel(API_PARSE *p)
|
|
{
|
|
byte i;
|
|
|
|
if (p) {
|
|
for (i = 2; i < (byte)p->length; i += p->info[i] + 2) {
|
|
if (p->info[i] == 2) {
|
|
if (p->info[i - 1] == ESC && p->info[i + 1] == CHI) return (p->info[i + 2]);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* put an information element in the parameter buffer */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void add_ie(PLCI *plci, byte code, byte *p, word p_length)
|
|
{
|
|
word i;
|
|
|
|
if (!(code & 0x80) && !p_length) return;
|
|
|
|
if (plci->req_in == plci->req_in_start) {
|
|
plci->req_in += 2;
|
|
}
|
|
else {
|
|
plci->req_in--;
|
|
}
|
|
plci->RBuffer[plci->req_in++] = code;
|
|
|
|
if (p) {
|
|
plci->RBuffer[plci->req_in++] = (byte)p_length;
|
|
for (i = 0; i < p_length; i++) plci->RBuffer[plci->req_in++] = p[1 + i];
|
|
}
|
|
|
|
plci->RBuffer[plci->req_in++] = 0;
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* put a unstructured data into the buffer */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void add_d(PLCI *plci, word length, byte *p)
|
|
{
|
|
word i;
|
|
|
|
if (plci->req_in == plci->req_in_start) {
|
|
plci->req_in += 2;
|
|
}
|
|
else {
|
|
plci->req_in--;
|
|
}
|
|
for (i = 0; i < length; i++) plci->RBuffer[plci->req_in++] = p[i];
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* put parameters from the Additional Info parameter in the */
|
|
/* parameter buffer */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void add_ai(PLCI *plci, API_PARSE *ai)
|
|
{
|
|
word i;
|
|
API_PARSE ai_parms[5];
|
|
|
|
for (i = 0; i < 5; i++) ai_parms[i].length = 0;
|
|
|
|
if (!ai->length)
|
|
return;
|
|
if (api_parse(&ai->info[1], (word)ai->length, "ssss", ai_parms))
|
|
return;
|
|
|
|
add_s(plci, KEY, &ai_parms[1]);
|
|
add_s(plci, UUI, &ai_parms[2]);
|
|
add_ss(plci, FTY, &ai_parms[3]);
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* put parameter for b1 protocol in the parameter buffer */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static word add_b1(PLCI *plci, API_PARSE *bp, word b_channel_info,
|
|
word b1_facilities)
|
|
{
|
|
API_PARSE bp_parms[8];
|
|
API_PARSE mdm_cfg[9];
|
|
API_PARSE global_config[2];
|
|
byte cai[256];
|
|
byte resource[] = {5, 9, 13, 12, 16, 39, 9, 17, 17, 18};
|
|
byte voice_cai[] = "\x06\x14\x00\x00\x00\x00\x08";
|
|
word i;
|
|
|
|
API_PARSE mdm_cfg_v18[4];
|
|
word j, n, w;
|
|
dword d;
|
|
|
|
|
|
for (i = 0; i < 8; i++) bp_parms[i].length = 0;
|
|
for (i = 0; i < 2; i++) global_config[i].length = 0;
|
|
|
|
dbug(1, dprintf("add_b1"));
|
|
api_save_msg(bp, "s", &plci->B_protocol);
|
|
|
|
if (b_channel_info == 2) {
|
|
plci->B1_resource = 0;
|
|
adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
|
|
add_p(plci, CAI, "\x01\x00");
|
|
dbug(1, dprintf("Cai=1,0 (no resource)"));
|
|
return 0;
|
|
}
|
|
|
|
if (plci->tel == CODEC_PERMANENT) return 0;
|
|
else if (plci->tel == CODEC) {
|
|
plci->B1_resource = 1;
|
|
adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
|
|
add_p(plci, CAI, "\x01\x01");
|
|
dbug(1, dprintf("Cai=1,1 (Codec)"));
|
|
return 0;
|
|
}
|
|
else if (plci->tel == ADV_VOICE) {
|
|
plci->B1_resource = add_b1_facilities(plci, 9, (word)(b1_facilities | B1_FACILITY_VOICE));
|
|
adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities | B1_FACILITY_VOICE));
|
|
voice_cai[1] = plci->B1_resource;
|
|
PUT_WORD(&voice_cai[5], plci->appl->MaxDataLength);
|
|
add_p(plci, CAI, voice_cai);
|
|
dbug(1, dprintf("Cai=1,0x%x (AdvVoice)", voice_cai[1]));
|
|
return 0;
|
|
}
|
|
plci->call_dir &= ~(CALL_DIR_ORIGINATE | CALL_DIR_ANSWER);
|
|
if (plci->call_dir & CALL_DIR_OUT)
|
|
plci->call_dir |= CALL_DIR_ORIGINATE;
|
|
else if (plci->call_dir & CALL_DIR_IN)
|
|
plci->call_dir |= CALL_DIR_ANSWER;
|
|
|
|
if (!bp->length) {
|
|
plci->B1_resource = 0x5;
|
|
adjust_b1_facilities(plci, plci->B1_resource, b1_facilities);
|
|
add_p(plci, CAI, "\x01\x05");
|
|
return 0;
|
|
}
|
|
|
|
dbug(1, dprintf("b_prot_len=%d", (word)bp->length));
|
|
if (bp->length > 256) return _WRONG_MESSAGE_FORMAT;
|
|
if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
|
|
{
|
|
bp_parms[6].length = 0;
|
|
if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
|
|
{
|
|
dbug(1, dprintf("b-form.!"));
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
}
|
|
else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
|
|
{
|
|
dbug(1, dprintf("b-form.!"));
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
|
|
if (bp_parms[6].length)
|
|
{
|
|
if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
|
|
{
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
switch (GET_WORD(global_config[0].info))
|
|
{
|
|
case 1:
|
|
plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
|
|
break;
|
|
case 2:
|
|
plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
|
|
break;
|
|
}
|
|
}
|
|
dbug(1, dprintf("call_dir=%04x", plci->call_dir));
|
|
|
|
|
|
if ((GET_WORD(bp_parms[0].info) == B1_RTP)
|
|
&& (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
|
|
{
|
|
plci->B1_resource = add_b1_facilities(plci, 31, (word)(b1_facilities & ~B1_FACILITY_VOICE));
|
|
adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
|
|
cai[1] = plci->B1_resource;
|
|
cai[2] = 0;
|
|
cai[3] = 0;
|
|
cai[4] = 0;
|
|
PUT_WORD(&cai[5], plci->appl->MaxDataLength);
|
|
for (i = 0; i < bp_parms[3].length; i++)
|
|
cai[7 + i] = bp_parms[3].info[1 + i];
|
|
cai[0] = 6 + bp_parms[3].length;
|
|
add_p(plci, CAI, cai);
|
|
return 0;
|
|
}
|
|
|
|
|
|
if ((GET_WORD(bp_parms[0].info) == B1_PIAFS)
|
|
&& (plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))
|
|
{
|
|
plci->B1_resource = add_b1_facilities(plci, 35/* PIAFS HARDWARE FACILITY */, (word)(b1_facilities & ~B1_FACILITY_VOICE));
|
|
adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
|
|
cai[1] = plci->B1_resource;
|
|
cai[2] = 0;
|
|
cai[3] = 0;
|
|
cai[4] = 0;
|
|
PUT_WORD(&cai[5], plci->appl->MaxDataLength);
|
|
cai[0] = 6;
|
|
add_p(plci, CAI, cai);
|
|
return 0;
|
|
}
|
|
|
|
|
|
if ((GET_WORD(bp_parms[0].info) >= 32)
|
|
|| (!((1L << GET_WORD(bp_parms[0].info)) & plci->adapter->profile.B1_Protocols)
|
|
&& ((GET_WORD(bp_parms[0].info) != 3)
|
|
|| !((1L << B1_HDLC) & plci->adapter->profile.B1_Protocols)
|
|
|| ((bp_parms[3].length != 0) && (GET_WORD(&bp_parms[3].info[1]) != 0) && (GET_WORD(&bp_parms[3].info[1]) != 56000)))))
|
|
{
|
|
return _B1_NOT_SUPPORTED;
|
|
}
|
|
plci->B1_resource = add_b1_facilities(plci, resource[GET_WORD(bp_parms[0].info)],
|
|
(word)(b1_facilities & ~B1_FACILITY_VOICE));
|
|
adjust_b1_facilities(plci, plci->B1_resource, (word)(b1_facilities & ~B1_FACILITY_VOICE));
|
|
cai[0] = 6;
|
|
cai[1] = plci->B1_resource;
|
|
for (i = 2; i < sizeof(cai); i++) cai[i] = 0;
|
|
|
|
if ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
|
|
|| (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
|
|
|| (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC))
|
|
{ /* B1 - modem */
|
|
for (i = 0; i < 7; i++) mdm_cfg[i].length = 0;
|
|
|
|
if (bp_parms[3].length)
|
|
{
|
|
if (api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwww", mdm_cfg))
|
|
{
|
|
return (_WRONG_MESSAGE_FORMAT);
|
|
}
|
|
|
|
cai[2] = 0; /* Bit rate for adaptation */
|
|
|
|
dbug(1, dprintf("MDM Max Bit Rate:<%d>", GET_WORD(mdm_cfg[0].info)));
|
|
|
|
PUT_WORD(&cai[13], 0); /* Min Tx speed */
|
|
PUT_WORD(&cai[15], GET_WORD(mdm_cfg[0].info)); /* Max Tx speed */
|
|
PUT_WORD(&cai[17], 0); /* Min Rx speed */
|
|
PUT_WORD(&cai[19], GET_WORD(mdm_cfg[0].info)); /* Max Rx speed */
|
|
|
|
cai[3] = 0; /* Async framing parameters */
|
|
switch (GET_WORD(mdm_cfg[2].info))
|
|
{ /* Parity */
|
|
case 1: /* odd parity */
|
|
cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
|
|
dbug(1, dprintf("MDM: odd parity"));
|
|
break;
|
|
|
|
case 2: /* even parity */
|
|
cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
|
|
dbug(1, dprintf("MDM: even parity"));
|
|
break;
|
|
|
|
default:
|
|
dbug(1, dprintf("MDM: no parity"));
|
|
break;
|
|
}
|
|
|
|
switch (GET_WORD(mdm_cfg[3].info))
|
|
{ /* stop bits */
|
|
case 1: /* 2 stop bits */
|
|
cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
|
|
dbug(1, dprintf("MDM: 2 stop bits"));
|
|
break;
|
|
|
|
default:
|
|
dbug(1, dprintf("MDM: 1 stop bit"));
|
|
break;
|
|
}
|
|
|
|
switch (GET_WORD(mdm_cfg[1].info))
|
|
{ /* char length */
|
|
case 5:
|
|
cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
|
|
dbug(1, dprintf("MDM: 5 bits"));
|
|
break;
|
|
|
|
case 6:
|
|
cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
|
|
dbug(1, dprintf("MDM: 6 bits"));
|
|
break;
|
|
|
|
case 7:
|
|
cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
|
|
dbug(1, dprintf("MDM: 7 bits"));
|
|
break;
|
|
|
|
default:
|
|
dbug(1, dprintf("MDM: 8 bits"));
|
|
break;
|
|
}
|
|
|
|
cai[7] = 0; /* Line taking options */
|
|
cai[8] = 0; /* Modulation negotiation options */
|
|
cai[9] = 0; /* Modulation options */
|
|
|
|
if (((plci->call_dir & CALL_DIR_ORIGINATE) != 0) ^ ((plci->call_dir & CALL_DIR_OUT) != 0))
|
|
{
|
|
cai[9] |= DSP_CAI_MODEM_REVERSE_DIRECTION;
|
|
dbug(1, dprintf("MDM: Reverse direction"));
|
|
}
|
|
|
|
if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RETRAIN)
|
|
{
|
|
cai[9] |= DSP_CAI_MODEM_DISABLE_RETRAIN;
|
|
dbug(1, dprintf("MDM: Disable retrain"));
|
|
}
|
|
|
|
if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_DISABLE_RING_TONE)
|
|
{
|
|
cai[7] |= DSP_CAI_MODEM_DISABLE_CALLING_TONE | DSP_CAI_MODEM_DISABLE_ANSWER_TONE;
|
|
dbug(1, dprintf("MDM: Disable ring tone"));
|
|
}
|
|
|
|
if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_1800)
|
|
{
|
|
cai[8] |= DSP_CAI_MODEM_GUARD_TONE_1800HZ;
|
|
dbug(1, dprintf("MDM: 1800 guard tone"));
|
|
}
|
|
else if (GET_WORD(mdm_cfg[4].info) & MDM_CAPI_GUARD_550)
|
|
{
|
|
cai[8] |= DSP_CAI_MODEM_GUARD_TONE_550HZ;
|
|
dbug(1, dprintf("MDM: 550 guard tone"));
|
|
}
|
|
|
|
if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_V100)
|
|
{
|
|
cai[8] |= DSP_CAI_MODEM_NEGOTIATE_V100;
|
|
dbug(1, dprintf("MDM: V100"));
|
|
}
|
|
else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_MOD_CLASS)
|
|
{
|
|
cai[8] |= DSP_CAI_MODEM_NEGOTIATE_IN_CLASS;
|
|
dbug(1, dprintf("MDM: IN CLASS"));
|
|
}
|
|
else if ((GET_WORD(mdm_cfg[5].info) & 0x00ff) == MDM_CAPI_NEG_DISABLED)
|
|
{
|
|
cai[8] |= DSP_CAI_MODEM_NEGOTIATE_DISABLED;
|
|
dbug(1, dprintf("MDM: DISABLED"));
|
|
}
|
|
cai[0] = 20;
|
|
|
|
if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_V18))
|
|
&& (GET_WORD(mdm_cfg[5].info) & 0x8000)) /* Private V.18 enable */
|
|
{
|
|
plci->requested_options |= 1L << PRIVATE_V18;
|
|
}
|
|
if (GET_WORD(mdm_cfg[5].info) & 0x4000) /* Private VOWN enable */
|
|
plci->requested_options |= 1L << PRIVATE_VOWN;
|
|
|
|
if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
|
|
& ((1L << PRIVATE_V18) | (1L << PRIVATE_VOWN)))
|
|
{
|
|
if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwws", mdm_cfg))
|
|
{
|
|
i = 27;
|
|
if (mdm_cfg[6].length >= 4)
|
|
{
|
|
d = GET_DWORD(&mdm_cfg[6].info[1]);
|
|
cai[7] |= (byte) d; /* line taking options */
|
|
cai[9] |= (byte)(d >> 8); /* modulation options */
|
|
cai[++i] = (byte)(d >> 16); /* vown modulation options */
|
|
cai[++i] = (byte)(d >> 24);
|
|
if (mdm_cfg[6].length >= 8)
|
|
{
|
|
d = GET_DWORD(&mdm_cfg[6].info[5]);
|
|
cai[10] |= (byte) d; /* disabled modulations mask */
|
|
cai[11] |= (byte)(d >> 8);
|
|
if (mdm_cfg[6].length >= 12)
|
|
{
|
|
d = GET_DWORD(&mdm_cfg[6].info[9]);
|
|
cai[12] = (byte) d; /* enabled modulations mask */
|
|
cai[++i] = (byte)(d >> 8); /* vown enabled modulations */
|
|
cai[++i] = (byte)(d >> 16);
|
|
cai[++i] = (byte)(d >> 24);
|
|
cai[++i] = 0;
|
|
if (mdm_cfg[6].length >= 14)
|
|
{
|
|
w = GET_WORD(&mdm_cfg[6].info[13]);
|
|
if (w != 0)
|
|
PUT_WORD(&cai[13], w); /* min tx speed */
|
|
if (mdm_cfg[6].length >= 16)
|
|
{
|
|
w = GET_WORD(&mdm_cfg[6].info[15]);
|
|
if (w != 0)
|
|
PUT_WORD(&cai[15], w); /* max tx speed */
|
|
if (mdm_cfg[6].length >= 18)
|
|
{
|
|
w = GET_WORD(&mdm_cfg[6].info[17]);
|
|
if (w != 0)
|
|
PUT_WORD(&cai[17], w); /* min rx speed */
|
|
if (mdm_cfg[6].length >= 20)
|
|
{
|
|
w = GET_WORD(&mdm_cfg[6].info[19]);
|
|
if (w != 0)
|
|
PUT_WORD(&cai[19], w); /* max rx speed */
|
|
if (mdm_cfg[6].length >= 22)
|
|
{
|
|
w = GET_WORD(&mdm_cfg[6].info[21]);
|
|
cai[23] = (byte)(-((short) w)); /* transmit level */
|
|
if (mdm_cfg[6].length >= 24)
|
|
{
|
|
w = GET_WORD(&mdm_cfg[6].info[23]);
|
|
cai[22] |= (byte) w; /* info options mask */
|
|
cai[21] |= (byte)(w >> 8); /* disabled symbol rates */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
cai[27] = i - 27;
|
|
i++;
|
|
if (!api_parse(&bp_parms[3].info[1], (word)bp_parms[3].length, "wwwwwwss", mdm_cfg))
|
|
{
|
|
if (!api_parse(&mdm_cfg[7].info[1], (word)mdm_cfg[7].length, "sss", mdm_cfg_v18))
|
|
{
|
|
for (n = 0; n < 3; n++)
|
|
{
|
|
cai[i] = (byte)(mdm_cfg_v18[n].length);
|
|
for (j = 1; j < ((word)(cai[i] + 1)); j++)
|
|
cai[i + j] = mdm_cfg_v18[n].info[j];
|
|
i += cai[i] + 1;
|
|
}
|
|
}
|
|
}
|
|
cai[0] = (byte)(i - 1);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
if (GET_WORD(bp_parms[0].info) == 2 || /* V.110 async */
|
|
GET_WORD(bp_parms[0].info) == 3) /* V.110 sync */
|
|
{
|
|
if (bp_parms[3].length) {
|
|
dbug(1, dprintf("V.110,%d", GET_WORD(&bp_parms[3].info[1])));
|
|
switch (GET_WORD(&bp_parms[3].info[1])) { /* Rate */
|
|
case 0:
|
|
case 56000:
|
|
if (GET_WORD(bp_parms[0].info) == 3) { /* V.110 sync 56k */
|
|
dbug(1, dprintf("56k sync HSCX"));
|
|
cai[1] = 8;
|
|
cai[2] = 0;
|
|
cai[3] = 0;
|
|
}
|
|
else if (GET_WORD(bp_parms[0].info) == 2) {
|
|
dbug(1, dprintf("56k async DSP"));
|
|
cai[2] = 9;
|
|
}
|
|
break;
|
|
case 50: cai[2] = 1; break;
|
|
case 75: cai[2] = 1; break;
|
|
case 110: cai[2] = 1; break;
|
|
case 150: cai[2] = 1; break;
|
|
case 200: cai[2] = 1; break;
|
|
case 300: cai[2] = 1; break;
|
|
case 600: cai[2] = 1; break;
|
|
case 1200: cai[2] = 2; break;
|
|
case 2400: cai[2] = 3; break;
|
|
case 4800: cai[2] = 4; break;
|
|
case 7200: cai[2] = 10; break;
|
|
case 9600: cai[2] = 5; break;
|
|
case 12000: cai[2] = 13; break;
|
|
case 24000: cai[2] = 0; break;
|
|
case 14400: cai[2] = 11; break;
|
|
case 19200: cai[2] = 6; break;
|
|
case 28800: cai[2] = 12; break;
|
|
case 38400: cai[2] = 7; break;
|
|
case 48000: cai[2] = 8; break;
|
|
case 76: cai[2] = 15; break; /* 75/1200 */
|
|
case 1201: cai[2] = 14; break; /* 1200/75 */
|
|
case 56001: cai[2] = 9; break; /* V.110 56000 */
|
|
|
|
default:
|
|
return _B1_PARM_NOT_SUPPORTED;
|
|
}
|
|
cai[3] = 0;
|
|
if (cai[1] == 13) /* v.110 async */
|
|
{
|
|
if (bp_parms[3].length >= 8)
|
|
{
|
|
switch (GET_WORD(&bp_parms[3].info[3]))
|
|
{ /* char length */
|
|
case 5:
|
|
cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_5;
|
|
break;
|
|
case 6:
|
|
cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_6;
|
|
break;
|
|
case 7:
|
|
cai[3] |= DSP_CAI_ASYNC_CHAR_LENGTH_7;
|
|
break;
|
|
}
|
|
switch (GET_WORD(&bp_parms[3].info[5]))
|
|
{ /* Parity */
|
|
case 1: /* odd parity */
|
|
cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_ODD);
|
|
break;
|
|
case 2: /* even parity */
|
|
cai[3] |= (DSP_CAI_ASYNC_PARITY_ENABLE | DSP_CAI_ASYNC_PARITY_EVEN);
|
|
break;
|
|
}
|
|
switch (GET_WORD(&bp_parms[3].info[7]))
|
|
{ /* stop bits */
|
|
case 1: /* 2 stop bits */
|
|
cai[3] |= DSP_CAI_ASYNC_TWO_STOP_BITS;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (cai[1] == 8 || GET_WORD(bp_parms[0].info) == 3) {
|
|
dbug(1, dprintf("V.110 default 56k sync"));
|
|
cai[1] = 8;
|
|
cai[2] = 0;
|
|
cai[3] = 0;
|
|
}
|
|
else {
|
|
dbug(1, dprintf("V.110 default 9600 async"));
|
|
cai[2] = 5;
|
|
}
|
|
}
|
|
PUT_WORD(&cai[5], plci->appl->MaxDataLength);
|
|
dbug(1, dprintf("CAI[%d]=%x,%x,%x,%x,%x,%x", cai[0], cai[1], cai[2], cai[3], cai[4], cai[5], cai[6]));
|
|
/* HexDump ("CAI", sizeof(cai), &cai[0]); */
|
|
|
|
add_p(plci, CAI, cai);
|
|
return 0;
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* put parameter for b2 and B3 protocol in the parameter buffer */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static word add_b23(PLCI *plci, API_PARSE *bp)
|
|
{
|
|
word i, fax_control_bits;
|
|
byte pos, len;
|
|
byte SAPI = 0x40; /* default SAPI 16 for x.31 */
|
|
API_PARSE bp_parms[8];
|
|
API_PARSE *b1_config;
|
|
API_PARSE *b2_config;
|
|
API_PARSE b2_config_parms[8];
|
|
API_PARSE *b3_config;
|
|
API_PARSE b3_config_parms[6];
|
|
API_PARSE global_config[2];
|
|
|
|
static byte llc[3] = {2,0,0};
|
|
static byte dlc[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
static byte nlc[256];
|
|
static byte lli[12] = {1,1};
|
|
|
|
const byte llc2_out[] = {1,2,4,6,2,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
|
|
const byte llc2_in[] = {1,3,4,6,3,0,0,0, X75_V42BIS,V120_L2,V120_V42BIS,V120_L2,6};
|
|
|
|
const byte llc3[] = {4,3,2,2,6,6,0};
|
|
const byte header[] = {0,2,3,3,0,0,0};
|
|
|
|
for (i = 0; i < 8; i++) bp_parms[i].length = 0;
|
|
for (i = 0; i < 6; i++) b2_config_parms[i].length = 0;
|
|
for (i = 0; i < 5; i++) b3_config_parms[i].length = 0;
|
|
|
|
lli[0] = 1;
|
|
lli[1] = 1;
|
|
if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
|
|
lli[1] |= 2;
|
|
if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
|
|
lli[1] |= 4;
|
|
|
|
if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
|
|
lli[1] |= 0x10;
|
|
if (plci->rx_dma_descriptor <= 0) {
|
|
plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic);
|
|
if (plci->rx_dma_descriptor >= 0)
|
|
plci->rx_dma_descriptor++;
|
|
}
|
|
if (plci->rx_dma_descriptor > 0) {
|
|
lli[0] = 6;
|
|
lli[1] |= 0x40;
|
|
lli[2] = (byte)(plci->rx_dma_descriptor - 1);
|
|
lli[3] = (byte)plci->rx_dma_magic;
|
|
lli[4] = (byte)(plci->rx_dma_magic >> 8);
|
|
lli[5] = (byte)(plci->rx_dma_magic >> 16);
|
|
lli[6] = (byte)(plci->rx_dma_magic >> 24);
|
|
}
|
|
}
|
|
|
|
if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
|
|
lli[1] |= 0x20;
|
|
}
|
|
|
|
dbug(1, dprintf("add_b23"));
|
|
api_save_msg(bp, "s", &plci->B_protocol);
|
|
|
|
if (!bp->length && plci->tel)
|
|
{
|
|
plci->adv_nl = true;
|
|
dbug(1, dprintf("Default adv.Nl"));
|
|
add_p(plci, LLI, lli);
|
|
plci->B2_prot = 1 /*XPARENT*/;
|
|
plci->B3_prot = 0 /*XPARENT*/;
|
|
llc[1] = 2;
|
|
llc[2] = 4;
|
|
add_p(plci, LLC, llc);
|
|
dlc[0] = 2;
|
|
PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
|
|
add_p(plci, DLC, dlc);
|
|
return 0;
|
|
}
|
|
|
|
if (!bp->length) /*default*/
|
|
{
|
|
dbug(1, dprintf("ret default"));
|
|
add_p(plci, LLI, lli);
|
|
plci->B2_prot = 0 /*X.75 */;
|
|
plci->B3_prot = 0 /*XPARENT*/;
|
|
llc[1] = 1;
|
|
llc[2] = 4;
|
|
add_p(plci, LLC, llc);
|
|
dlc[0] = 2;
|
|
PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
|
|
add_p(plci, DLC, dlc);
|
|
return 0;
|
|
}
|
|
dbug(1, dprintf("b_prot_len=%d", (word)bp->length));
|
|
if ((word)bp->length > 256) return _WRONG_MESSAGE_FORMAT;
|
|
|
|
if (api_parse(&bp->info[1], (word)bp->length, "wwwsssb", bp_parms))
|
|
{
|
|
bp_parms[6].length = 0;
|
|
if (api_parse(&bp->info[1], (word)bp->length, "wwwsss", bp_parms))
|
|
{
|
|
dbug(1, dprintf("b-form.!"));
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
}
|
|
else if (api_parse(&bp->info[1], (word)bp->length, "wwwssss", bp_parms))
|
|
{
|
|
dbug(1, dprintf("b-form.!"));
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
|
|
if (plci->tel == ADV_VOICE) /* transparent B on advanced voice */
|
|
{
|
|
if (GET_WORD(bp_parms[1].info) != 1
|
|
|| GET_WORD(bp_parms[2].info) != 0) return _B2_NOT_SUPPORTED;
|
|
plci->adv_nl = true;
|
|
}
|
|
else if (plci->tel) return _B2_NOT_SUPPORTED;
|
|
|
|
|
|
if ((GET_WORD(bp_parms[1].info) == B2_RTP)
|
|
&& (GET_WORD(bp_parms[2].info) == B3_RTP)
|
|
&& (plci->adapter->man_profile.private_options & (1L << PRIVATE_RTP)))
|
|
{
|
|
add_p(plci, LLI, lli);
|
|
plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
|
|
plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
|
|
llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ? 14 : 13;
|
|
llc[2] = 4;
|
|
add_p(plci, LLC, llc);
|
|
dlc[0] = 2;
|
|
PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
|
|
dlc[3] = 3; /* Addr A */
|
|
dlc[4] = 1; /* Addr B */
|
|
dlc[5] = 7; /* modulo mode */
|
|
dlc[6] = 7; /* window size */
|
|
dlc[7] = 0; /* XID len Lo */
|
|
dlc[8] = 0; /* XID len Hi */
|
|
for (i = 0; i < bp_parms[4].length; i++)
|
|
dlc[9 + i] = bp_parms[4].info[1 + i];
|
|
dlc[0] = (byte)(8 + bp_parms[4].length);
|
|
add_p(plci, DLC, dlc);
|
|
for (i = 0; i < bp_parms[5].length; i++)
|
|
nlc[1 + i] = bp_parms[5].info[1 + i];
|
|
nlc[0] = (byte)(bp_parms[5].length);
|
|
add_p(plci, NLC, nlc);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
if ((GET_WORD(bp_parms[1].info) >= 32)
|
|
|| (!((1L << GET_WORD(bp_parms[1].info)) & plci->adapter->profile.B2_Protocols)
|
|
&& ((GET_WORD(bp_parms[1].info) != B2_PIAFS)
|
|
|| !(plci->adapter->man_profile.private_options & (1L << PRIVATE_PIAFS)))))
|
|
|
|
{
|
|
return _B2_NOT_SUPPORTED;
|
|
}
|
|
if ((GET_WORD(bp_parms[2].info) >= 32)
|
|
|| !((1L << GET_WORD(bp_parms[2].info)) & plci->adapter->profile.B3_Protocols))
|
|
{
|
|
return _B3_NOT_SUPPORTED;
|
|
}
|
|
if ((GET_WORD(bp_parms[1].info) != B2_SDLC)
|
|
&& ((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
|
|
|| (GET_WORD(bp_parms[0].info) == B1_MODEM_ASYNC)
|
|
|| (GET_WORD(bp_parms[0].info) == B1_MODEM_SYNC_HDLC)))
|
|
{
|
|
return (add_modem_b23(plci, bp_parms));
|
|
}
|
|
|
|
add_p(plci, LLI, lli);
|
|
|
|
plci->B2_prot = (byte)GET_WORD(bp_parms[1].info);
|
|
plci->B3_prot = (byte)GET_WORD(bp_parms[2].info);
|
|
if (plci->B2_prot == 12) SAPI = 0; /* default SAPI D-channel */
|
|
|
|
if (bp_parms[6].length)
|
|
{
|
|
if (api_parse(&bp_parms[6].info[1], (word)bp_parms[6].length, "w", global_config))
|
|
{
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
switch (GET_WORD(global_config[0].info))
|
|
{
|
|
case 1:
|
|
plci->call_dir = (plci->call_dir & ~CALL_DIR_ANSWER) | CALL_DIR_ORIGINATE;
|
|
break;
|
|
case 2:
|
|
plci->call_dir = (plci->call_dir & ~CALL_DIR_ORIGINATE) | CALL_DIR_ANSWER;
|
|
break;
|
|
}
|
|
}
|
|
dbug(1, dprintf("call_dir=%04x", plci->call_dir));
|
|
|
|
|
|
if (plci->B2_prot == B2_PIAFS)
|
|
llc[1] = PIAFS_CRC;
|
|
else
|
|
/* IMPLEMENT_PIAFS */
|
|
{
|
|
llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
|
|
llc2_out[GET_WORD(bp_parms[1].info)] : llc2_in[GET_WORD(bp_parms[1].info)];
|
|
}
|
|
llc[2] = llc3[GET_WORD(bp_parms[2].info)];
|
|
|
|
add_p(plci, LLC, llc);
|
|
|
|
dlc[0] = 2;
|
|
PUT_WORD(&dlc[1], plci->appl->MaxDataLength +
|
|
header[GET_WORD(bp_parms[2].info)]);
|
|
|
|
b1_config = &bp_parms[3];
|
|
nlc[0] = 0;
|
|
if (plci->B3_prot == 4
|
|
|| plci->B3_prot == 5)
|
|
{
|
|
for (i = 0; i < sizeof(T30_INFO); i++) nlc[i] = 0;
|
|
nlc[0] = sizeof(T30_INFO);
|
|
if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
|
|
((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI;
|
|
((T30_INFO *)&nlc[1])->rate_div_2400 = 0xff;
|
|
if (b1_config->length >= 2)
|
|
{
|
|
((T30_INFO *)&nlc[1])->rate_div_2400 = (byte)(GET_WORD(&b1_config->info[1]) / 2400);
|
|
}
|
|
}
|
|
b2_config = &bp_parms[4];
|
|
|
|
|
|
if (llc[1] == PIAFS_CRC)
|
|
{
|
|
if (plci->B3_prot != B3_TRANSPARENT)
|
|
{
|
|
return _B_STACK_NOT_SUPPORTED;
|
|
}
|
|
if (b2_config->length && api_parse(&b2_config->info[1], (word)b2_config->length, "bwww", b2_config_parms)) {
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
PUT_WORD(&dlc[1], plci->appl->MaxDataLength);
|
|
dlc[3] = 0; /* Addr A */
|
|
dlc[4] = 0; /* Addr B */
|
|
dlc[5] = 0; /* modulo mode */
|
|
dlc[6] = 0; /* window size */
|
|
if (b2_config->length >= 7) {
|
|
dlc[7] = 7;
|
|
dlc[8] = 0;
|
|
dlc[9] = b2_config_parms[0].info[0]; /* PIAFS protocol Speed configuration */
|
|
dlc[10] = b2_config_parms[1].info[0]; /* V.42bis P0 */
|
|
dlc[11] = b2_config_parms[1].info[1]; /* V.42bis P0 */
|
|
dlc[12] = b2_config_parms[2].info[0]; /* V.42bis P1 */
|
|
dlc[13] = b2_config_parms[2].info[1]; /* V.42bis P1 */
|
|
dlc[14] = b2_config_parms[3].info[0]; /* V.42bis P2 */
|
|
dlc[15] = b2_config_parms[3].info[1]; /* V.42bis P2 */
|
|
dlc[0] = 15;
|
|
if (b2_config->length >= 8) { /* PIAFS control abilities */
|
|
dlc[7] = 10;
|
|
dlc[16] = 2; /* Length of PIAFS extension */
|
|
dlc[17] = PIAFS_UDATA_ABILITIES; /* control (UDATA) ability */
|
|
dlc[18] = b2_config_parms[4].info[0]; /* value */
|
|
dlc[0] = 18;
|
|
}
|
|
}
|
|
else /* default values, 64K, variable, no compression */
|
|
{
|
|
dlc[7] = 7;
|
|
dlc[8] = 0;
|
|
dlc[9] = 0x03; /* PIAFS protocol Speed configuration */
|
|
dlc[10] = 0x03; /* V.42bis P0 */
|
|
dlc[11] = 0; /* V.42bis P0 */
|
|
dlc[12] = 0; /* V.42bis P1 */
|
|
dlc[13] = 0; /* V.42bis P1 */
|
|
dlc[14] = 0; /* V.42bis P2 */
|
|
dlc[15] = 0; /* V.42bis P2 */
|
|
dlc[0] = 15;
|
|
}
|
|
add_p(plci, DLC, dlc);
|
|
}
|
|
else
|
|
|
|
if ((llc[1] == V120_L2) || (llc[1] == V120_V42BIS))
|
|
{
|
|
if (plci->B3_prot != B3_TRANSPARENT)
|
|
return _B_STACK_NOT_SUPPORTED;
|
|
|
|
dlc[0] = 6;
|
|
PUT_WORD(&dlc[1], GET_WORD(&dlc[1]) + 2);
|
|
dlc[3] = 0x08;
|
|
dlc[4] = 0x01;
|
|
dlc[5] = 127;
|
|
dlc[6] = 7;
|
|
if (b2_config->length != 0)
|
|
{
|
|
if ((llc[1] == V120_V42BIS) && api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms)) {
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
dlc[3] = (byte)((b2_config->info[2] << 3) | ((b2_config->info[1] >> 5) & 0x04));
|
|
dlc[4] = (byte)((b2_config->info[1] << 1) | 0x01);
|
|
if (b2_config->info[3] != 128)
|
|
{
|
|
dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
|
|
return _B2_PARM_NOT_SUPPORTED;
|
|
}
|
|
dlc[5] = (byte)(b2_config->info[3] - 1);
|
|
dlc[6] = b2_config->info[4];
|
|
if (llc[1] == V120_V42BIS) {
|
|
if (b2_config->length >= 10) {
|
|
dlc[7] = 6;
|
|
dlc[8] = 0;
|
|
dlc[9] = b2_config_parms[4].info[0];
|
|
dlc[10] = b2_config_parms[4].info[1];
|
|
dlc[11] = b2_config_parms[5].info[0];
|
|
dlc[12] = b2_config_parms[5].info[1];
|
|
dlc[13] = b2_config_parms[6].info[0];
|
|
dlc[14] = b2_config_parms[6].info[1];
|
|
dlc[0] = 14;
|
|
dbug(1, dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
|
|
dbug(1, dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
|
|
dbug(1, dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
|
|
}
|
|
else {
|
|
dlc[6] = 14;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (b2_config->length)
|
|
{
|
|
dbug(1, dprintf("B2-Config"));
|
|
if (llc[1] == X75_V42BIS) {
|
|
if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbwww", b2_config_parms))
|
|
{
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
}
|
|
else {
|
|
if (api_parse(&b2_config->info[1], (word)b2_config->length, "bbbbs", b2_config_parms))
|
|
{
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
}
|
|
/* if B2 Protocol is LAPD, b2_config structure is different */
|
|
if (llc[1] == 6)
|
|
{
|
|
dlc[0] = 4;
|
|
if (b2_config->length >= 1) dlc[2] = b2_config->info[1]; /* TEI */
|
|
else dlc[2] = 0x01;
|
|
if ((b2_config->length >= 2) && (plci->B2_prot == 12))
|
|
{
|
|
SAPI = b2_config->info[2]; /* SAPI */
|
|
}
|
|
dlc[1] = SAPI;
|
|
if ((b2_config->length >= 3) && (b2_config->info[3] == 128))
|
|
{
|
|
dlc[3] = 127; /* Mode */
|
|
}
|
|
else
|
|
{
|
|
dlc[3] = 7; /* Mode */
|
|
}
|
|
|
|
if (b2_config->length >= 4) dlc[4] = b2_config->info[4]; /* Window */
|
|
else dlc[4] = 1;
|
|
dbug(1, dprintf("D-dlc[%d]=%x,%x,%x,%x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
|
|
if (b2_config->length > 5) return _B2_PARM_NOT_SUPPORTED;
|
|
}
|
|
else
|
|
{
|
|
dlc[0] = (byte)(b2_config_parms[4].length + 6);
|
|
dlc[3] = b2_config->info[1];
|
|
dlc[4] = b2_config->info[2];
|
|
if (b2_config->info[3] != 8 && b2_config->info[3] != 128) {
|
|
dbug(1, dprintf("1D-dlc= %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4]));
|
|
return _B2_PARM_NOT_SUPPORTED;
|
|
}
|
|
|
|
dlc[5] = (byte)(b2_config->info[3] - 1);
|
|
dlc[6] = b2_config->info[4];
|
|
if (dlc[6] > dlc[5]) {
|
|
dbug(1, dprintf("2D-dlc= %x %x %x %x %x %x %x", dlc[0], dlc[1], dlc[2], dlc[3], dlc[4], dlc[5], dlc[6]));
|
|
return _B2_PARM_NOT_SUPPORTED;
|
|
}
|
|
|
|
if (llc[1] == X75_V42BIS) {
|
|
if (b2_config->length >= 10) {
|
|
dlc[7] = 6;
|
|
dlc[8] = 0;
|
|
dlc[9] = b2_config_parms[4].info[0];
|
|
dlc[10] = b2_config_parms[4].info[1];
|
|
dlc[11] = b2_config_parms[5].info[0];
|
|
dlc[12] = b2_config_parms[5].info[1];
|
|
dlc[13] = b2_config_parms[6].info[0];
|
|
dlc[14] = b2_config_parms[6].info[1];
|
|
dlc[0] = 14;
|
|
dbug(1, dprintf("b2_config_parms[4].info[0] [1]: %x %x", b2_config_parms[4].info[0], b2_config_parms[4].info[1]));
|
|
dbug(1, dprintf("b2_config_parms[5].info[0] [1]: %x %x", b2_config_parms[5].info[0], b2_config_parms[5].info[1]));
|
|
dbug(1, dprintf("b2_config_parms[6].info[0] [1]: %x %x", b2_config_parms[6].info[0], b2_config_parms[6].info[1]));
|
|
}
|
|
else {
|
|
dlc[6] = 14;
|
|
}
|
|
|
|
}
|
|
else {
|
|
PUT_WORD(&dlc[7], (word)b2_config_parms[4].length);
|
|
for (i = 0; i < b2_config_parms[4].length; i++)
|
|
dlc[11 + i] = b2_config_parms[4].info[1 + i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
add_p(plci, DLC, dlc);
|
|
|
|
b3_config = &bp_parms[5];
|
|
if (b3_config->length)
|
|
{
|
|
if (plci->B3_prot == 4
|
|
|| plci->B3_prot == 5)
|
|
{
|
|
if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwss", b3_config_parms))
|
|
{
|
|
return _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
i = GET_WORD((byte *)(b3_config_parms[0].info));
|
|
((T30_INFO *)&nlc[1])->resolution = (byte)(((i & 0x0001) ||
|
|
((plci->B3_prot == 4) && (((byte)(GET_WORD((byte *)b3_config_parms[1].info))) != 5))) ? T30_RESOLUTION_R8_0770_OR_200 : 0);
|
|
((T30_INFO *)&nlc[1])->data_format = (byte)(GET_WORD((byte *)b3_config_parms[1].info));
|
|
fax_control_bits = T30_CONTROL_BIT_ALL_FEATURES;
|
|
if ((((T30_INFO *)&nlc[1])->rate_div_2400 != 0) && (((T30_INFO *)&nlc[1])->rate_div_2400 <= 6))
|
|
fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_V34FAX;
|
|
if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_FAX_PAPER_FORMATS)
|
|
{
|
|
|
|
if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
|
|
& (1L << PRIVATE_FAX_PAPER_FORMATS))
|
|
{
|
|
((T30_INFO *)&nlc[1])->resolution |= T30_RESOLUTION_R8_1540 |
|
|
T30_RESOLUTION_R16_1540_OR_400 | T30_RESOLUTION_300_300 |
|
|
T30_RESOLUTION_INCH_BASED | T30_RESOLUTION_METRIC_BASED;
|
|
}
|
|
|
|
((T30_INFO *)&nlc[1])->recording_properties =
|
|
T30_RECORDING_WIDTH_ISO_A3 |
|
|
(T30_RECORDING_LENGTH_UNLIMITED << 2) |
|
|
(T30_MIN_SCANLINE_TIME_00_00_00 << 4);
|
|
}
|
|
if (plci->B3_prot == 5)
|
|
{
|
|
if (i & 0x0002) /* Accept incoming fax-polling requests */
|
|
fax_control_bits |= T30_CONTROL_BIT_ACCEPT_POLLING;
|
|
if (i & 0x2000) /* Do not use MR compression */
|
|
fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_2D_CODING;
|
|
if (i & 0x4000) /* Do not use MMR compression */
|
|
fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_T6_CODING;
|
|
if (i & 0x8000) /* Do not use ECM */
|
|
fax_control_bits &= ~T30_CONTROL_BIT_ENABLE_ECM;
|
|
if (plci->fax_connect_info_length != 0)
|
|
{
|
|
((T30_INFO *)&nlc[1])->resolution = ((T30_INFO *)plci->fax_connect_info_buffer)->resolution;
|
|
((T30_INFO *)&nlc[1])->data_format = ((T30_INFO *)plci->fax_connect_info_buffer)->data_format;
|
|
((T30_INFO *)&nlc[1])->recording_properties = ((T30_INFO *)plci->fax_connect_info_buffer)->recording_properties;
|
|
fax_control_bits |= GET_WORD(&((T30_INFO *)plci->fax_connect_info_buffer)->control_bits_low) &
|
|
(T30_CONTROL_BIT_REQUEST_POLLING | T30_CONTROL_BIT_MORE_DOCUMENTS);
|
|
}
|
|
}
|
|
/* copy station id to NLC */
|
|
for (i = 0; i < T30_MAX_STATION_ID_LENGTH; i++)
|
|
{
|
|
if (i < b3_config_parms[2].length)
|
|
{
|
|
((T30_INFO *)&nlc[1])->station_id[i] = ((byte *)b3_config_parms[2].info)[1 + i];
|
|
}
|
|
else
|
|
{
|
|
((T30_INFO *)&nlc[1])->station_id[i] = ' ';
|
|
}
|
|
}
|
|
((T30_INFO *)&nlc[1])->station_id_len = T30_MAX_STATION_ID_LENGTH;
|
|
/* copy head line to NLC */
|
|
if (b3_config_parms[3].length)
|
|
{
|
|
|
|
pos = (byte)(fax_head_line_time(&(((T30_INFO *)&nlc[1])->station_id[T30_MAX_STATION_ID_LENGTH])));
|
|
if (pos != 0)
|
|
{
|
|
if (CAPI_MAX_DATE_TIME_LENGTH + 2 + b3_config_parms[3].length > CAPI_MAX_HEAD_LINE_SPACE)
|
|
pos = 0;
|
|
else
|
|
{
|
|
nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
|
|
nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
|
|
len = (byte)b3_config_parms[2].length;
|
|
if (len > 20)
|
|
len = 20;
|
|
if (CAPI_MAX_DATE_TIME_LENGTH + 2 + len + 2 + b3_config_parms[3].length <= CAPI_MAX_HEAD_LINE_SPACE)
|
|
{
|
|
for (i = 0; i < len; i++)
|
|
nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[2].info)[1 + i];
|
|
nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
|
|
nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ' ';
|
|
}
|
|
}
|
|
}
|
|
|
|
len = (byte)b3_config_parms[3].length;
|
|
if (len > CAPI_MAX_HEAD_LINE_SPACE - pos)
|
|
len = (byte)(CAPI_MAX_HEAD_LINE_SPACE - pos);
|
|
((T30_INFO *)&nlc[1])->head_line_len = (byte)(pos + len);
|
|
nlc[0] += (byte)(pos + len);
|
|
for (i = 0; i < len; i++)
|
|
nlc[1 + offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH + pos++] = ((byte *)b3_config_parms[3].info)[1 + i];
|
|
} else
|
|
((T30_INFO *)&nlc[1])->head_line_len = 0;
|
|
|
|
plci->nsf_control_bits = 0;
|
|
if (plci->B3_prot == 5)
|
|
{
|
|
if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_SUB_SEP_PWD))
|
|
&& (GET_WORD((byte *)b3_config_parms[1].info) & 0x8000)) /* Private SUB/SEP/PWD enable */
|
|
{
|
|
plci->requested_options |= 1L << PRIVATE_FAX_SUB_SEP_PWD;
|
|
}
|
|
if ((plci->adapter->man_profile.private_options & (1L << PRIVATE_FAX_NONSTANDARD))
|
|
&& (GET_WORD((byte *)b3_config_parms[1].info) & 0x4000)) /* Private non-standard facilities enable */
|
|
{
|
|
plci->requested_options |= 1L << PRIVATE_FAX_NONSTANDARD;
|
|
}
|
|
if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
|
|
& ((1L << PRIVATE_FAX_SUB_SEP_PWD) | (1L << PRIVATE_FAX_NONSTANDARD)))
|
|
{
|
|
if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
|
|
& (1L << PRIVATE_FAX_SUB_SEP_PWD))
|
|
{
|
|
fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SUBADDRESS | T30_CONTROL_BIT_ACCEPT_PASSWORD;
|
|
if (fax_control_bits & T30_CONTROL_BIT_ACCEPT_POLLING)
|
|
fax_control_bits |= T30_CONTROL_BIT_ACCEPT_SEL_POLLING;
|
|
}
|
|
len = nlc[0];
|
|
pos = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
|
|
if (pos < plci->fax_connect_info_length)
|
|
{
|
|
for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
|
|
nlc[++len] = plci->fax_connect_info_buffer[pos++];
|
|
}
|
|
else
|
|
nlc[++len] = 0;
|
|
if (pos < plci->fax_connect_info_length)
|
|
{
|
|
for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
|
|
nlc[++len] = plci->fax_connect_info_buffer[pos++];
|
|
}
|
|
else
|
|
nlc[++len] = 0;
|
|
if ((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[plci->appl->Id - 1])
|
|
& (1L << PRIVATE_FAX_NONSTANDARD))
|
|
{
|
|
if ((pos < plci->fax_connect_info_length) && (plci->fax_connect_info_buffer[pos] != 0))
|
|
{
|
|
if ((plci->fax_connect_info_buffer[pos] >= 3) && (plci->fax_connect_info_buffer[pos + 1] >= 2))
|
|
plci->nsf_control_bits = GET_WORD(&plci->fax_connect_info_buffer[pos + 2]);
|
|
for (i = 1 + plci->fax_connect_info_buffer[pos]; i != 0; i--)
|
|
nlc[++len] = plci->fax_connect_info_buffer[pos++];
|
|
}
|
|
else
|
|
{
|
|
if (api_parse(&b3_config->info[1], (word)b3_config->length, "wwsss", b3_config_parms))
|
|
{
|
|
dbug(1, dprintf("non-standard facilities info missing or wrong format"));
|
|
nlc[++len] = 0;
|
|
}
|
|
else
|
|
{
|
|
if ((b3_config_parms[4].length >= 3) && (b3_config_parms[4].info[1] >= 2))
|
|
plci->nsf_control_bits = GET_WORD(&b3_config_parms[4].info[2]);
|
|
nlc[++len] = (byte)(b3_config_parms[4].length);
|
|
for (i = 0; i < b3_config_parms[4].length; i++)
|
|
nlc[++len] = b3_config_parms[4].info[1 + i];
|
|
}
|
|
}
|
|
}
|
|
nlc[0] = len;
|
|
if ((plci->nsf_control_bits & T30_NSF_CONTROL_BIT_ENABLE_NSF)
|
|
&& (plci->nsf_control_bits & T30_NSF_CONTROL_BIT_NEGOTIATE_RESP))
|
|
{
|
|
((T30_INFO *)&nlc[1])->operating_mode = T30_OPERATING_MODE_CAPI_NEG;
|
|
}
|
|
}
|
|
}
|
|
|
|
PUT_WORD(&(((T30_INFO *)&nlc[1])->control_bits_low), fax_control_bits);
|
|
len = offsetof(T30_INFO, station_id) + T30_MAX_STATION_ID_LENGTH;
|
|
for (i = 0; i < len; i++)
|
|
plci->fax_connect_info_buffer[i] = nlc[1 + i];
|
|
((T30_INFO *) plci->fax_connect_info_buffer)->head_line_len = 0;
|
|
i += ((T30_INFO *)&nlc[1])->head_line_len;
|
|
while (i < nlc[0])
|
|
plci->fax_connect_info_buffer[len++] = nlc[++i];
|
|
plci->fax_connect_info_length = len;
|
|
}
|
|
else
|
|
{
|
|
nlc[0] = 14;
|
|
if (b3_config->length != 16)
|
|
return _B3_PARM_NOT_SUPPORTED;
|
|
for (i = 0; i < 12; i++) nlc[1 + i] = b3_config->info[1 + i];
|
|
if (GET_WORD(&b3_config->info[13]) != 8 && GET_WORD(&b3_config->info[13]) != 128)
|
|
return _B3_PARM_NOT_SUPPORTED;
|
|
nlc[13] = b3_config->info[13];
|
|
if (GET_WORD(&b3_config->info[15]) >= nlc[13])
|
|
return _B3_PARM_NOT_SUPPORTED;
|
|
nlc[14] = b3_config->info[15];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (plci->B3_prot == 4
|
|
|| plci->B3_prot == 5 /*T.30 - FAX*/) return _B3_PARM_NOT_SUPPORTED;
|
|
}
|
|
add_p(plci, NLC, nlc);
|
|
return 0;
|
|
}
|
|
|
|
/*----------------------------------------------------------------*/
|
|
/* make the same as add_b23, but only for the modem related */
|
|
/* L2 and L3 B-Chan protocol. */
|
|
/* */
|
|
/* Enabled L2 and L3 Configurations: */
|
|
/* If L1 == Modem all negotiation */
|
|
/* only L2 == Modem with full negotiation is allowed */
|
|
/* If L1 == Modem async or sync */
|
|
/* only L2 == Transparent is allowed */
|
|
/* L3 == Modem or L3 == Transparent are allowed */
|
|
/* B2 Configuration for modem: */
|
|
/* word : enable/disable compression, bitoptions */
|
|
/* B3 Configuration for modem: */
|
|
/* empty */
|
|
/*----------------------------------------------------------------*/
|
|
static word add_modem_b23(PLCI *plci, API_PARSE *bp_parms)
|
|
{
|
|
static byte lli[12] = {1,1};
|
|
static byte llc[3] = {2,0,0};
|
|
static byte dlc[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
API_PARSE mdm_config[2];
|
|
word i;
|
|
word b2_config = 0;
|
|
|
|
for (i = 0; i < 2; i++) mdm_config[i].length = 0;
|
|
for (i = 0; i < sizeof(dlc); i++) dlc[i] = 0;
|
|
|
|
if (((GET_WORD(bp_parms[0].info) == B1_MODEM_ALL_NEGOTIATE)
|
|
&& (GET_WORD(bp_parms[1].info) != B2_MODEM_EC_COMPRESSION))
|
|
|| ((GET_WORD(bp_parms[0].info) != B1_MODEM_ALL_NEGOTIATE)
|
|
&& (GET_WORD(bp_parms[1].info) != B2_TRANSPARENT)))
|
|
{
|
|
return (_B_STACK_NOT_SUPPORTED);
|
|
}
|
|
if ((GET_WORD(bp_parms[2].info) != B3_MODEM)
|
|
&& (GET_WORD(bp_parms[2].info) != B3_TRANSPARENT))
|
|
{
|
|
return (_B_STACK_NOT_SUPPORTED);
|
|
}
|
|
|
|
plci->B2_prot = (byte) GET_WORD(bp_parms[1].info);
|
|
plci->B3_prot = (byte) GET_WORD(bp_parms[2].info);
|
|
|
|
if ((GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION) && bp_parms[4].length)
|
|
{
|
|
if (api_parse(&bp_parms[4].info[1],
|
|
(word)bp_parms[4].length, "w",
|
|
mdm_config))
|
|
{
|
|
return (_WRONG_MESSAGE_FORMAT);
|
|
}
|
|
b2_config = GET_WORD(mdm_config[0].info);
|
|
}
|
|
|
|
/* OK, L2 is modem */
|
|
|
|
lli[0] = 1;
|
|
lli[1] = 1;
|
|
if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)
|
|
lli[1] |= 2;
|
|
if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_OOB_CHANNEL)
|
|
lli[1] |= 4;
|
|
|
|
if ((lli[1] & 0x02) && (diva_xdi_extended_features & DIVA_CAPI_USE_CMA)) {
|
|
lli[1] |= 0x10;
|
|
if (plci->rx_dma_descriptor <= 0) {
|
|
plci->rx_dma_descriptor = diva_get_dma_descriptor(plci, &plci->rx_dma_magic);
|
|
if (plci->rx_dma_descriptor >= 0)
|
|
plci->rx_dma_descriptor++;
|
|
}
|
|
if (plci->rx_dma_descriptor > 0) {
|
|
lli[1] |= 0x40;
|
|
lli[0] = 6;
|
|
lli[2] = (byte)(plci->rx_dma_descriptor - 1);
|
|
lli[3] = (byte)plci->rx_dma_magic;
|
|
lli[4] = (byte)(plci->rx_dma_magic >> 8);
|
|
lli[5] = (byte)(plci->rx_dma_magic >> 16);
|
|
lli[6] = (byte)(plci->rx_dma_magic >> 24);
|
|
}
|
|
}
|
|
|
|
if (DIVA_CAPI_SUPPORTS_NO_CANCEL(plci->adapter)) {
|
|
lli[1] |= 0x20;
|
|
}
|
|
|
|
llc[1] = (plci->call_dir & (CALL_DIR_ORIGINATE | CALL_DIR_FORCE_OUTG_NL)) ?
|
|
/*V42*/ 10 : /*V42_IN*/ 9;
|
|
llc[2] = 4; /* pass L3 always transparent */
|
|
add_p(plci, LLI, lli);
|
|
add_p(plci, LLC, llc);
|
|
i = 1;
|
|
PUT_WORD(&dlc[i], plci->appl->MaxDataLength);
|
|
i += 2;
|
|
if (GET_WORD(bp_parms[1].info) == B2_MODEM_EC_COMPRESSION)
|
|
{
|
|
if (bp_parms[4].length)
|
|
{
|
|
dbug(1, dprintf("MDM b2_config=%02x", b2_config));
|
|
dlc[i++] = 3; /* Addr A */
|
|
dlc[i++] = 1; /* Addr B */
|
|
dlc[i++] = 7; /* modulo mode */
|
|
dlc[i++] = 7; /* window size */
|
|
dlc[i++] = 0; /* XID len Lo */
|
|
dlc[i++] = 0; /* XID len Hi */
|
|
|
|
if (b2_config & MDM_B2_DISABLE_V42bis)
|
|
{
|
|
dlc[i] |= DLC_MODEMPROT_DISABLE_V42_V42BIS;
|
|
}
|
|
if (b2_config & MDM_B2_DISABLE_MNP)
|
|
{
|
|
dlc[i] |= DLC_MODEMPROT_DISABLE_MNP_MNP5;
|
|
}
|
|
if (b2_config & MDM_B2_DISABLE_TRANS)
|
|
{
|
|
dlc[i] |= DLC_MODEMPROT_REQUIRE_PROTOCOL;
|
|
}
|
|
if (b2_config & MDM_B2_DISABLE_V42)
|
|
{
|
|
dlc[i] |= DLC_MODEMPROT_DISABLE_V42_DETECT;
|
|
}
|
|
if (b2_config & MDM_B2_DISABLE_COMP)
|
|
{
|
|
dlc[i] |= DLC_MODEMPROT_DISABLE_COMPRESSION;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dlc[i++] = 3; /* Addr A */
|
|
dlc[i++] = 1; /* Addr B */
|
|
dlc[i++] = 7; /* modulo mode */
|
|
dlc[i++] = 7; /* window size */
|
|
dlc[i++] = 0; /* XID len Lo */
|
|
dlc[i++] = 0; /* XID len Hi */
|
|
dlc[i++] = DLC_MODEMPROT_DISABLE_V42_V42BIS |
|
|
DLC_MODEMPROT_DISABLE_MNP_MNP5 |
|
|
DLC_MODEMPROT_DISABLE_V42_DETECT |
|
|
DLC_MODEMPROT_DISABLE_COMPRESSION;
|
|
}
|
|
dlc[0] = (byte)(i - 1);
|
|
/* HexDump ("DLC", sizeof(dlc), &dlc[0]); */
|
|
add_p(plci, DLC, dlc);
|
|
return (0);
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* send a request for the signaling entity */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void sig_req(PLCI *plci, byte req, byte Id)
|
|
{
|
|
if (!plci) return;
|
|
if (plci->adapter->adapter_disabled) return;
|
|
dbug(1, dprintf("sig_req(%x)", req));
|
|
if (req == REMOVE)
|
|
plci->sig_remove_id = plci->Sig.Id;
|
|
if (plci->req_in == plci->req_in_start) {
|
|
plci->req_in += 2;
|
|
plci->RBuffer[plci->req_in++] = 0;
|
|
}
|
|
PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2);
|
|
plci->RBuffer[plci->req_in++] = Id; /* sig/nl flag */
|
|
plci->RBuffer[plci->req_in++] = req; /* request */
|
|
plci->RBuffer[plci->req_in++] = 0; /* channel */
|
|
plci->req_in_start = plci->req_in;
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* send a request for the network layer entity */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void nl_req_ncci(PLCI *plci, byte req, byte ncci)
|
|
{
|
|
if (!plci) return;
|
|
if (plci->adapter->adapter_disabled) return;
|
|
dbug(1, dprintf("nl_req %02x %02x %02x", plci->Id, req, ncci));
|
|
if (req == REMOVE)
|
|
{
|
|
plci->nl_remove_id = plci->NL.Id;
|
|
ncci_remove(plci, 0, (byte)(ncci != 0));
|
|
ncci = 0;
|
|
}
|
|
if (plci->req_in == plci->req_in_start) {
|
|
plci->req_in += 2;
|
|
plci->RBuffer[plci->req_in++] = 0;
|
|
}
|
|
PUT_WORD(&plci->RBuffer[plci->req_in_start], plci->req_in-plci->req_in_start - 2);
|
|
plci->RBuffer[plci->req_in++] = 1; /* sig/nl flag */
|
|
plci->RBuffer[plci->req_in++] = req; /* request */
|
|
plci->RBuffer[plci->req_in++] = plci->adapter->ncci_ch[ncci]; /* channel */
|
|
plci->req_in_start = plci->req_in;
|
|
}
|
|
|
|
static void send_req(PLCI *plci)
|
|
{
|
|
ENTITY *e;
|
|
word l;
|
|
/* word i; */
|
|
|
|
if (!plci) return;
|
|
if (plci->adapter->adapter_disabled) return;
|
|
channel_xmit_xon(plci);
|
|
|
|
/* if nothing to do, return */
|
|
if (plci->req_in == plci->req_out) return;
|
|
dbug(1, dprintf("send_req(in=%d,out=%d)", plci->req_in, plci->req_out));
|
|
|
|
if (plci->nl_req || plci->sig_req) return;
|
|
|
|
l = GET_WORD(&plci->RBuffer[plci->req_out]);
|
|
plci->req_out += 2;
|
|
plci->XData[0].P = &plci->RBuffer[plci->req_out];
|
|
plci->req_out += l;
|
|
if (plci->RBuffer[plci->req_out] == 1)
|
|
{
|
|
e = &plci->NL;
|
|
plci->req_out++;
|
|
e->Req = plci->nl_req = plci->RBuffer[plci->req_out++];
|
|
e->ReqCh = plci->RBuffer[plci->req_out++];
|
|
if (!(e->Id & 0x1f))
|
|
{
|
|
e->Id = NL_ID;
|
|
plci->RBuffer[plci->req_out - 4] = CAI;
|
|
plci->RBuffer[plci->req_out - 3] = 1;
|
|
plci->RBuffer[plci->req_out - 2] = (plci->Sig.Id == 0xff) ? 0 : plci->Sig.Id;
|
|
plci->RBuffer[plci->req_out - 1] = 0;
|
|
l += 3;
|
|
plci->nl_global_req = plci->nl_req;
|
|
}
|
|
dbug(1, dprintf("%x:NLREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh));
|
|
}
|
|
else
|
|
{
|
|
e = &plci->Sig;
|
|
if (plci->RBuffer[plci->req_out])
|
|
e->Id = plci->RBuffer[plci->req_out];
|
|
plci->req_out++;
|
|
e->Req = plci->sig_req = plci->RBuffer[plci->req_out++];
|
|
e->ReqCh = plci->RBuffer[plci->req_out++];
|
|
if (!(e->Id & 0x1f))
|
|
plci->sig_global_req = plci->sig_req;
|
|
dbug(1, dprintf("%x:SIGREQ(%x:%x:%x)", plci->adapter->Id, e->Id, e->Req, e->ReqCh));
|
|
}
|
|
plci->XData[0].PLength = l;
|
|
e->X = plci->XData;
|
|
plci->adapter->request(e);
|
|
dbug(1, dprintf("send_ok"));
|
|
}
|
|
|
|
static void send_data(PLCI *plci)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
DATA_B3_DESC *data;
|
|
NCCI *ncci_ptr;
|
|
word ncci;
|
|
|
|
if (!plci->nl_req && plci->ncci_ring_list)
|
|
{
|
|
a = plci->adapter;
|
|
ncci = plci->ncci_ring_list;
|
|
do
|
|
{
|
|
ncci = a->ncci_next[ncci];
|
|
ncci_ptr = &(a->ncci[ncci]);
|
|
if (!(a->ncci_ch[ncci]
|
|
&& (a->ch_flow_control[a->ncci_ch[ncci]] & N_OK_FC_PENDING)))
|
|
{
|
|
if (ncci_ptr->data_pending)
|
|
{
|
|
if ((a->ncci_state[ncci] == CONNECTED)
|
|
|| (a->ncci_state[ncci] == INC_ACT_PENDING)
|
|
|| (plci->send_disc == ncci))
|
|
{
|
|
data = &(ncci_ptr->DBuffer[ncci_ptr->data_out]);
|
|
if ((plci->B2_prot == B2_V120_ASYNC)
|
|
|| (plci->B2_prot == B2_V120_ASYNC_V42BIS)
|
|
|| (plci->B2_prot == B2_V120_BIT_TRANSPARENT))
|
|
{
|
|
plci->NData[1].P = TransmitBufferGet(plci->appl, data->P);
|
|
plci->NData[1].PLength = data->Length;
|
|
if (data->Flags & 0x10)
|
|
plci->NData[0].P = v120_break_header;
|
|
else
|
|
plci->NData[0].P = v120_default_header;
|
|
plci->NData[0].PLength = 1;
|
|
plci->NL.XNum = 2;
|
|
plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA);
|
|
}
|
|
else
|
|
{
|
|
plci->NData[0].P = TransmitBufferGet(plci->appl, data->P);
|
|
plci->NData[0].PLength = data->Length;
|
|
if (data->Flags & 0x10)
|
|
plci->NL.Req = plci->nl_req = (byte)N_UDATA;
|
|
|
|
else if ((plci->B3_prot == B3_RTP) && (data->Flags & 0x01))
|
|
plci->NL.Req = plci->nl_req = (byte)N_BDATA;
|
|
|
|
else
|
|
plci->NL.Req = plci->nl_req = (byte)((data->Flags & 0x07) << 4 | N_DATA);
|
|
}
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.ReqCh = a->ncci_ch[ncci];
|
|
dbug(1, dprintf("%x:DREQ(%x:%x)", a->Id, plci->NL.Id, plci->NL.Req));
|
|
plci->data_sent = true;
|
|
plci->data_sent_ptr = data->P;
|
|
a->request(&plci->NL);
|
|
}
|
|
else {
|
|
cleanup_ncci_data(plci, ncci);
|
|
}
|
|
}
|
|
else if (plci->send_disc == ncci)
|
|
{
|
|
/* dprintf("N_DISC"); */
|
|
plci->NData[0].PLength = 0;
|
|
plci->NL.ReqCh = a->ncci_ch[ncci];
|
|
plci->NL.Req = plci->nl_req = N_DISC;
|
|
a->request(&plci->NL);
|
|
plci->command = _DISCONNECT_B3_R;
|
|
plci->send_disc = 0;
|
|
}
|
|
}
|
|
} while (!plci->nl_req && (ncci != plci->ncci_ring_list));
|
|
plci->ncci_ring_list = ncci;
|
|
}
|
|
}
|
|
|
|
static void listen_check(DIVA_CAPI_ADAPTER *a)
|
|
{
|
|
word i, j;
|
|
PLCI *plci;
|
|
byte activnotifiedcalls = 0;
|
|
|
|
dbug(1, dprintf("listen_check(%d,%d)", a->listen_active, a->max_listen));
|
|
if (!remove_started && !a->adapter_disabled)
|
|
{
|
|
for (i = 0; i < a->max_plci; i++)
|
|
{
|
|
plci = &(a->plci[i]);
|
|
if (plci->notifiedcall) activnotifiedcalls++;
|
|
}
|
|
dbug(1, dprintf("listen_check(%d)", activnotifiedcalls));
|
|
|
|
for (i = a->listen_active; i < ((word)(a->max_listen + activnotifiedcalls)); i++) {
|
|
if ((j = get_plci(a))) {
|
|
a->listen_active++;
|
|
plci = &a->plci[j - 1];
|
|
plci->State = LISTENING;
|
|
|
|
add_p(plci, OAD, "\x01\xfd");
|
|
|
|
add_p(plci, KEY, "\x04\x43\x41\x32\x30");
|
|
|
|
add_p(plci, CAI, "\x01\xc0");
|
|
add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
add_p(plci, LLI, "\x01\xc4"); /* support Dummy CR FAC + MWI + SpoofNotify */
|
|
add_p(plci, SHIFT | 6, NULL);
|
|
add_p(plci, SIN, "\x02\x00\x00");
|
|
plci->internal_command = LISTEN_SIG_ASSIGN_PEND; /* do indicate_req if OK */
|
|
sig_req(plci, ASSIGN, DSIG_ID);
|
|
send_req(plci);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* functions for all parameters sent in INDs */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void IndParse(PLCI *plci, word *parms_id, byte **parms, byte multiIEsize)
|
|
{
|
|
word ploc; /* points to current location within packet */
|
|
byte w;
|
|
byte wlen;
|
|
byte codeset, lock;
|
|
byte *in;
|
|
word i;
|
|
word code;
|
|
word mIEindex = 0;
|
|
ploc = 0;
|
|
codeset = 0;
|
|
lock = 0;
|
|
|
|
in = plci->Sig.RBuffer->P;
|
|
for (i = 0; i < parms_id[0]; i++) /* multiIE parms_id contains just the 1st */
|
|
{ /* element but parms array is larger */
|
|
parms[i] = (byte *)"";
|
|
}
|
|
for (i = 0; i < multiIEsize; i++)
|
|
{
|
|
parms[i] = (byte *)"";
|
|
}
|
|
|
|
while (ploc < plci->Sig.RBuffer->length - 1) {
|
|
|
|
/* read information element id and length */
|
|
w = in[ploc];
|
|
|
|
if (w & 0x80) {
|
|
/* w &=0xf0; removed, cannot detect congestion levels */
|
|
/* upper 4 bit masked with w==SHIFT now */
|
|
wlen = 0;
|
|
}
|
|
else {
|
|
wlen = (byte)(in[ploc + 1] + 1);
|
|
}
|
|
/* check if length valid (not exceeding end of packet) */
|
|
if ((ploc + wlen) > 270) return;
|
|
if (lock & 0x80) lock &= 0x7f;
|
|
else codeset = lock;
|
|
|
|
if ((w & 0xf0) == SHIFT) {
|
|
codeset = in[ploc];
|
|
if (!(codeset & 0x08)) lock = (byte)(codeset & 7);
|
|
codeset &= 7;
|
|
lock |= 0x80;
|
|
}
|
|
else {
|
|
if (w == ESC && wlen >= 3) code = in[ploc + 2] | 0x800;
|
|
else code = w;
|
|
code |= (codeset << 8);
|
|
|
|
for (i = 1; i < parms_id[0] + 1 && parms_id[i] != code; i++);
|
|
|
|
if (i < parms_id[0] + 1) {
|
|
if (!multiIEsize) { /* with multiIEs use next field index, */
|
|
mIEindex = i - 1; /* with normal IEs use same index like parms_id */
|
|
}
|
|
|
|
parms[mIEindex] = &in[ploc + 1];
|
|
dbug(1, dprintf("mIE[%d]=0x%x", *parms[mIEindex], in[ploc]));
|
|
if (parms_id[i] == OAD
|
|
|| parms_id[i] == CONN_NR
|
|
|| parms_id[i] == CAD) {
|
|
if (in[ploc + 2] & 0x80) {
|
|
in[ploc + 0] = (byte)(in[ploc + 1] + 1);
|
|
in[ploc + 1] = (byte)(in[ploc + 2] & 0x7f);
|
|
in[ploc + 2] = 0x80;
|
|
parms[mIEindex] = &in[ploc];
|
|
}
|
|
}
|
|
mIEindex++; /* effects multiIEs only */
|
|
}
|
|
}
|
|
|
|
ploc += (wlen + 1);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* try to match a cip from received BC and HLC */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static byte ie_compare(byte *ie1, byte *ie2)
|
|
{
|
|
word i;
|
|
if (!ie1 || !ie2) return false;
|
|
if (!ie1[0]) return false;
|
|
for (i = 0; i < (word)(ie1[0] + 1); i++) if (ie1[i] != ie2[i]) return false;
|
|
return true;
|
|
}
|
|
|
|
static word find_cip(DIVA_CAPI_ADAPTER *a, byte *bc, byte *hlc)
|
|
{
|
|
word i;
|
|
word j;
|
|
|
|
for (i = 9; i && !ie_compare(bc, cip_bc[i][a->u_law]); i--);
|
|
|
|
for (j = 16; j < 29 &&
|
|
(!ie_compare(bc, cip_bc[j][a->u_law]) || !ie_compare(hlc, cip_hlc[j])); j++);
|
|
if (j == 29) return i;
|
|
return j;
|
|
}
|
|
|
|
|
|
static byte AddInfo(byte **add_i,
|
|
byte **fty_i,
|
|
byte *esc_chi,
|
|
byte *facility)
|
|
{
|
|
byte i;
|
|
byte j;
|
|
byte k;
|
|
byte flen;
|
|
byte len = 0;
|
|
/* facility is a nested structure */
|
|
/* FTY can be more than once */
|
|
|
|
if (esc_chi[0] && !(esc_chi[esc_chi[0]] & 0x7f))
|
|
{
|
|
add_i[0] = (byte *)"\x02\x02\x00"; /* use neither b nor d channel */
|
|
}
|
|
|
|
else
|
|
{
|
|
add_i[0] = (byte *)"";
|
|
}
|
|
if (!fty_i[0][0])
|
|
{
|
|
add_i[3] = (byte *)"";
|
|
}
|
|
else
|
|
{ /* facility array found */
|
|
for (i = 0, j = 1; i < MAX_MULTI_IE && fty_i[i][0]; i++)
|
|
{
|
|
dbug(1, dprintf("AddIFac[%d]", fty_i[i][0]));
|
|
len += fty_i[i][0];
|
|
len += 2;
|
|
flen = fty_i[i][0];
|
|
facility[j++] = 0x1c; /* copy fac IE */
|
|
for (k = 0; k <= flen; k++, j++)
|
|
{
|
|
facility[j] = fty_i[i][k];
|
|
/* dbug(1, dprintf("%x ",facility[j])); */
|
|
}
|
|
}
|
|
facility[0] = len;
|
|
add_i[3] = facility;
|
|
}
|
|
/* dbug(1, dprintf("FacArrLen=%d ",len)); */
|
|
len = add_i[0][0] + add_i[1][0] + add_i[2][0] + add_i[3][0];
|
|
len += 4; /* calculate length of all */
|
|
return (len);
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* voice and codec features */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void SetVoiceChannel(PLCI *plci, byte *chi, DIVA_CAPI_ADAPTER *a)
|
|
{
|
|
byte voice_chi[] = "\x02\x18\x01";
|
|
byte channel;
|
|
|
|
channel = chi[chi[0]] & 0x3;
|
|
dbug(1, dprintf("ExtDevON(Ch=0x%x)", channel));
|
|
voice_chi[2] = (channel) ? channel : 1;
|
|
add_p(plci, FTY, "\x02\x01\x07"); /* B On, default on 1 */
|
|
add_p(plci, ESC, voice_chi); /* Channel */
|
|
sig_req(plci, TEL_CTRL, 0);
|
|
send_req(plci);
|
|
if (a->AdvSignalPLCI)
|
|
{
|
|
adv_voice_write_coefs(a->AdvSignalPLCI, ADV_VOICE_WRITE_ACTIVATION);
|
|
}
|
|
}
|
|
|
|
static void VoiceChannelOff(PLCI *plci)
|
|
{
|
|
dbug(1, dprintf("ExtDevOFF"));
|
|
add_p(plci, FTY, "\x02\x01\x08"); /* B Off */
|
|
sig_req(plci, TEL_CTRL, 0);
|
|
send_req(plci);
|
|
if (plci->adapter->AdvSignalPLCI)
|
|
{
|
|
adv_voice_clear_config(plci->adapter->AdvSignalPLCI);
|
|
}
|
|
}
|
|
|
|
|
|
static word AdvCodecSupport(DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl,
|
|
byte hook_listen)
|
|
{
|
|
word j;
|
|
PLCI *splci;
|
|
|
|
/* check if hardware supports handset with hook states (adv.codec) */
|
|
/* or if just a on board codec is supported */
|
|
/* the advanced codec plci is just for internal use */
|
|
|
|
/* diva Pro with on-board codec: */
|
|
if (a->profile.Global_Options & HANDSET)
|
|
{
|
|
/* new call, but hook states are already signalled */
|
|
if (a->AdvCodecFLAG)
|
|
{
|
|
if (a->AdvSignalAppl != appl || a->AdvSignalPLCI)
|
|
{
|
|
dbug(1, dprintf("AdvSigPlci=0x%x", a->AdvSignalPLCI));
|
|
return 0x2001; /* codec in use by another application */
|
|
}
|
|
if (plci != NULL)
|
|
{
|
|
a->AdvSignalPLCI = plci;
|
|
plci->tel = ADV_VOICE;
|
|
}
|
|
return 0; /* adv codec still used */
|
|
}
|
|
if ((j = get_plci(a)))
|
|
{
|
|
splci = &a->plci[j - 1];
|
|
splci->tel = CODEC_PERMANENT;
|
|
/* hook_listen indicates if a facility_req with handset/hook support */
|
|
/* was sent. Otherwise if just a call on an external device was made */
|
|
/* the codec will be used but the hook info will be discarded (just */
|
|
/* the external controller is in use */
|
|
if (hook_listen) splci->State = ADVANCED_VOICE_SIG;
|
|
else
|
|
{
|
|
splci->State = ADVANCED_VOICE_NOSIG;
|
|
if (plci)
|
|
{
|
|
plci->spoofed_msg = SPOOFING_REQUIRED;
|
|
}
|
|
/* indicate D-ch connect if */
|
|
} /* codec is connected OK */
|
|
if (plci != NULL)
|
|
{
|
|
a->AdvSignalPLCI = plci;
|
|
plci->tel = ADV_VOICE;
|
|
}
|
|
a->AdvSignalAppl = appl;
|
|
a->AdvCodecFLAG = true;
|
|
a->AdvCodecPLCI = splci;
|
|
add_p(splci, CAI, "\x01\x15");
|
|
add_p(splci, LLI, "\x01\x00");
|
|
add_p(splci, ESC, "\x02\x18\x00");
|
|
add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
splci->internal_command = PERM_COD_ASSIGN;
|
|
dbug(1, dprintf("Codec Assign"));
|
|
sig_req(splci, ASSIGN, DSIG_ID);
|
|
send_req(splci);
|
|
}
|
|
else
|
|
{
|
|
return 0x2001; /* wrong state, no more plcis */
|
|
}
|
|
}
|
|
else if (a->profile.Global_Options & ON_BOARD_CODEC)
|
|
{
|
|
if (hook_listen) return 0x300B; /* Facility not supported */
|
|
/* no hook with SCOM */
|
|
if (plci != NULL) plci->tel = CODEC;
|
|
dbug(1, dprintf("S/SCOM codec"));
|
|
/* first time we use the scom-s codec we must shut down the internal */
|
|
/* handset application of the card. This can be done by an assign with */
|
|
/* a cai with the 0x80 bit set. Assign return code is 'out of resource'*/
|
|
if (!a->scom_appl_disable) {
|
|
if ((j = get_plci(a))) {
|
|
splci = &a->plci[j - 1];
|
|
add_p(splci, CAI, "\x01\x80");
|
|
add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
sig_req(splci, ASSIGN, 0xC0); /* 0xc0 is the TEL_ID */
|
|
send_req(splci);
|
|
a->scom_appl_disable = true;
|
|
}
|
|
else{
|
|
return 0x2001; /* wrong state, no more plcis */
|
|
}
|
|
}
|
|
}
|
|
else return 0x300B; /* Facility not supported */
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void CodecIdCheck(DIVA_CAPI_ADAPTER *a, PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("CodecIdCheck"));
|
|
|
|
if (a->AdvSignalPLCI == plci)
|
|
{
|
|
dbug(1, dprintf("PLCI owns codec"));
|
|
VoiceChannelOff(a->AdvCodecPLCI);
|
|
if (a->AdvCodecPLCI->State == ADVANCED_VOICE_NOSIG)
|
|
{
|
|
dbug(1, dprintf("remove temp codec PLCI"));
|
|
plci_remove(a->AdvCodecPLCI);
|
|
a->AdvCodecFLAG = 0;
|
|
a->AdvCodecPLCI = NULL;
|
|
a->AdvSignalAppl = NULL;
|
|
}
|
|
a->AdvSignalPLCI = NULL;
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------------------------------
|
|
Ask for physical address of card on PCI bus
|
|
------------------------------------------------------------------- */
|
|
static void diva_ask_for_xdi_sdram_bar(DIVA_CAPI_ADAPTER *a,
|
|
IDI_SYNC_REQ *preq) {
|
|
a->sdram_bar = 0;
|
|
if (diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR) {
|
|
ENTITY *e = (ENTITY *)preq;
|
|
|
|
e->user[0] = a->Id - 1;
|
|
preq->xdi_sdram_bar.info.bar = 0;
|
|
preq->xdi_sdram_bar.Req = 0;
|
|
preq->xdi_sdram_bar.Rc = IDI_SYNC_REQ_XDI_GET_ADAPTER_SDRAM_BAR;
|
|
|
|
(*(a->request))(e);
|
|
|
|
a->sdram_bar = preq->xdi_sdram_bar.info.bar;
|
|
dbug(3, dprintf("A(%d) SDRAM BAR = %08x", a->Id, a->sdram_bar));
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------------------------------
|
|
Ask XDI about extended features
|
|
------------------------------------------------------------------- */
|
|
static void diva_get_extended_adapter_features(DIVA_CAPI_ADAPTER *a) {
|
|
IDI_SYNC_REQ *preq;
|
|
char buffer[((sizeof(preq->xdi_extended_features) + 4) > sizeof(ENTITY)) ? (sizeof(preq->xdi_extended_features) + 4) : sizeof(ENTITY)];
|
|
|
|
char features[4];
|
|
preq = (IDI_SYNC_REQ *)&buffer[0];
|
|
|
|
if (!diva_xdi_extended_features) {
|
|
ENTITY *e = (ENTITY *)preq;
|
|
diva_xdi_extended_features |= 0x80000000;
|
|
|
|
e->user[0] = a->Id - 1;
|
|
preq->xdi_extended_features.Req = 0;
|
|
preq->xdi_extended_features.Rc = IDI_SYNC_REQ_XDI_GET_EXTENDED_FEATURES;
|
|
preq->xdi_extended_features.info.buffer_length_in_bytes = sizeof(features);
|
|
preq->xdi_extended_features.info.features = &features[0];
|
|
|
|
(*(a->request))(e);
|
|
|
|
if (features[0] & DIVA_XDI_EXTENDED_FEATURES_VALID) {
|
|
/*
|
|
Check features located in the byte '0'
|
|
*/
|
|
if (features[0] & DIVA_XDI_EXTENDED_FEATURE_CMA) {
|
|
diva_xdi_extended_features |= DIVA_CAPI_USE_CMA;
|
|
}
|
|
if (features[0] & DIVA_XDI_EXTENDED_FEATURE_RX_DMA) {
|
|
diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_RX_DMA;
|
|
dbug(1, dprintf("XDI provides RxDMA"));
|
|
}
|
|
if (features[0] & DIVA_XDI_EXTENDED_FEATURE_SDRAM_BAR) {
|
|
diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_SDRAM_BAR;
|
|
}
|
|
if (features[0] & DIVA_XDI_EXTENDED_FEATURE_NO_CANCEL_RC) {
|
|
diva_xdi_extended_features |= DIVA_CAPI_XDI_PROVIDES_NO_CANCEL;
|
|
dbug(3, dprintf("XDI provides NO_CANCEL_RC feature"));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
diva_ask_for_xdi_sdram_bar(a, preq);
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* automatic law */
|
|
/*------------------------------------------------------------------*/
|
|
/* called from OS specific part after init time to get the Law */
|
|
/* a-law (Euro) and u-law (us,japan) use different BCs in the Setup message */
|
|
void AutomaticLaw(DIVA_CAPI_ADAPTER *a)
|
|
{
|
|
word j;
|
|
PLCI *splci;
|
|
|
|
if (a->automatic_law) {
|
|
return;
|
|
}
|
|
if ((j = get_plci(a))) {
|
|
diva_get_extended_adapter_features(a);
|
|
splci = &a->plci[j - 1];
|
|
a->automatic_lawPLCI = splci;
|
|
a->automatic_law = 1;
|
|
add_p(splci, CAI, "\x01\x80");
|
|
add_p(splci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
splci->internal_command = USELAW_REQ;
|
|
splci->command = 0;
|
|
splci->number = 0;
|
|
sig_req(splci, ASSIGN, DSIG_ID);
|
|
send_req(splci);
|
|
}
|
|
}
|
|
|
|
/* called from OS specific part if an application sends an Capi20Release */
|
|
word CapiRelease(word Id)
|
|
{
|
|
word i, j, appls_found;
|
|
PLCI *plci;
|
|
APPL *this;
|
|
DIVA_CAPI_ADAPTER *a;
|
|
|
|
if (!Id)
|
|
{
|
|
dbug(0, dprintf("A: CapiRelease(Id==0)"));
|
|
return (_WRONG_APPL_ID);
|
|
}
|
|
|
|
this = &application[Id - 1]; /* get application pointer */
|
|
|
|
for (i = 0, appls_found = 0; i < max_appl; i++)
|
|
{
|
|
if (application[i].Id) /* an application has been found */
|
|
{
|
|
appls_found++;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < max_adapter; i++) /* scan all adapters... */
|
|
{
|
|
a = &adapter[i];
|
|
if (a->request)
|
|
{
|
|
a->Info_Mask[Id - 1] = 0;
|
|
a->CIP_Mask[Id - 1] = 0;
|
|
a->Notification_Mask[Id - 1] = 0;
|
|
a->codec_listen[Id - 1] = NULL;
|
|
a->requested_options_table[Id - 1] = 0;
|
|
for (j = 0; j < a->max_plci; j++) /* and all PLCIs connected */
|
|
{ /* with this application */
|
|
plci = &a->plci[j];
|
|
if (plci->Id) /* if plci owns no application */
|
|
{ /* it may be not jet connected */
|
|
if (plci->State == INC_CON_PENDING
|
|
|| plci->State == INC_CON_ALERT)
|
|
{
|
|
if (test_c_ind_mask_bit(plci, (word)(Id - 1)))
|
|
{
|
|
clear_c_ind_mask_bit(plci, (word)(Id - 1));
|
|
if (c_ind_mask_empty(plci))
|
|
{
|
|
sig_req(plci, HANGUP, 0);
|
|
send_req(plci);
|
|
plci->State = OUTG_DIS_PENDING;
|
|
}
|
|
}
|
|
}
|
|
if (test_c_ind_mask_bit(plci, (word)(Id - 1)))
|
|
{
|
|
clear_c_ind_mask_bit(plci, (word)(Id - 1));
|
|
if (c_ind_mask_empty(plci))
|
|
{
|
|
if (!plci->appl)
|
|
{
|
|
plci_remove(plci);
|
|
plci->State = IDLE;
|
|
}
|
|
}
|
|
}
|
|
if (plci->appl == this)
|
|
{
|
|
plci->appl = NULL;
|
|
plci_remove(plci);
|
|
plci->State = IDLE;
|
|
}
|
|
}
|
|
}
|
|
listen_check(a);
|
|
|
|
if (a->flag_dynamic_l1_down)
|
|
{
|
|
if (appls_found == 1) /* last application does a capi release */
|
|
{
|
|
if ((j = get_plci(a)))
|
|
{
|
|
plci = &a->plci[j - 1];
|
|
plci->command = 0;
|
|
add_p(plci, OAD, "\x01\xfd");
|
|
add_p(plci, CAI, "\x01\x80");
|
|
add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
add_p(plci, SHIFT | 6, NULL);
|
|
add_p(plci, SIN, "\x02\x00\x00");
|
|
plci->internal_command = REM_L1_SIG_ASSIGN_PEND;
|
|
sig_req(plci, ASSIGN, DSIG_ID);
|
|
add_p(plci, FTY, "\x02\xff\x06"); /* l1 down */
|
|
sig_req(plci, SIG_CTRL, 0);
|
|
send_req(plci);
|
|
}
|
|
}
|
|
}
|
|
if (a->AdvSignalAppl == this)
|
|
{
|
|
this->NullCREnable = false;
|
|
if (a->AdvCodecPLCI)
|
|
{
|
|
plci_remove(a->AdvCodecPLCI);
|
|
a->AdvCodecPLCI->tel = 0;
|
|
a->AdvCodecPLCI->adv_nl = 0;
|
|
}
|
|
a->AdvSignalAppl = NULL;
|
|
a->AdvSignalPLCI = NULL;
|
|
a->AdvCodecFLAG = 0;
|
|
a->AdvCodecPLCI = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
this->Id = 0;
|
|
|
|
return GOOD;
|
|
}
|
|
|
|
static word plci_remove_check(PLCI *plci)
|
|
{
|
|
if (!plci) return true;
|
|
if (!plci->NL.Id && c_ind_mask_empty(plci))
|
|
{
|
|
if (plci->Sig.Id == 0xff)
|
|
plci->Sig.Id = 0;
|
|
if (!plci->Sig.Id)
|
|
{
|
|
dbug(1, dprintf("plci_remove_complete(%x)", plci->Id));
|
|
dbug(1, dprintf("tel=0x%x,Sig=0x%x", plci->tel, plci->Sig.Id));
|
|
if (plci->Id)
|
|
{
|
|
CodecIdCheck(plci->adapter, plci);
|
|
clear_b1_config(plci);
|
|
ncci_remove(plci, 0, false);
|
|
plci_free_msg_in_queue(plci);
|
|
channel_flow_control_remove(plci);
|
|
plci->Id = 0;
|
|
plci->State = IDLE;
|
|
plci->channels = 0;
|
|
plci->appl = NULL;
|
|
plci->notifiedcall = 0;
|
|
}
|
|
listen_check(plci->adapter);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static byte plci_nl_busy(PLCI *plci)
|
|
{
|
|
/* only applicable for non-multiplexed protocols */
|
|
return (plci->nl_req
|
|
|| (plci->ncci_ring_list
|
|
&& plci->adapter->ncci_ch[plci->ncci_ring_list]
|
|
&& (plci->adapter->ch_flow_control[plci->adapter->ncci_ch[plci->ncci_ring_list]] & N_OK_FC_PENDING)));
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* DTMF facilities */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
|
|
static struct
|
|
{
|
|
byte send_mask;
|
|
byte listen_mask;
|
|
byte character;
|
|
byte code;
|
|
} dtmf_digit_map[] =
|
|
{
|
|
{ 0x01, 0x01, 0x23, DTMF_DIGIT_TONE_CODE_HASHMARK },
|
|
{ 0x01, 0x01, 0x2a, DTMF_DIGIT_TONE_CODE_STAR },
|
|
{ 0x01, 0x01, 0x30, DTMF_DIGIT_TONE_CODE_0 },
|
|
{ 0x01, 0x01, 0x31, DTMF_DIGIT_TONE_CODE_1 },
|
|
{ 0x01, 0x01, 0x32, DTMF_DIGIT_TONE_CODE_2 },
|
|
{ 0x01, 0x01, 0x33, DTMF_DIGIT_TONE_CODE_3 },
|
|
{ 0x01, 0x01, 0x34, DTMF_DIGIT_TONE_CODE_4 },
|
|
{ 0x01, 0x01, 0x35, DTMF_DIGIT_TONE_CODE_5 },
|
|
{ 0x01, 0x01, 0x36, DTMF_DIGIT_TONE_CODE_6 },
|
|
{ 0x01, 0x01, 0x37, DTMF_DIGIT_TONE_CODE_7 },
|
|
{ 0x01, 0x01, 0x38, DTMF_DIGIT_TONE_CODE_8 },
|
|
{ 0x01, 0x01, 0x39, DTMF_DIGIT_TONE_CODE_9 },
|
|
{ 0x01, 0x01, 0x41, DTMF_DIGIT_TONE_CODE_A },
|
|
{ 0x01, 0x01, 0x42, DTMF_DIGIT_TONE_CODE_B },
|
|
{ 0x01, 0x01, 0x43, DTMF_DIGIT_TONE_CODE_C },
|
|
{ 0x01, 0x01, 0x44, DTMF_DIGIT_TONE_CODE_D },
|
|
{ 0x01, 0x00, 0x61, DTMF_DIGIT_TONE_CODE_A },
|
|
{ 0x01, 0x00, 0x62, DTMF_DIGIT_TONE_CODE_B },
|
|
{ 0x01, 0x00, 0x63, DTMF_DIGIT_TONE_CODE_C },
|
|
{ 0x01, 0x00, 0x64, DTMF_DIGIT_TONE_CODE_D },
|
|
|
|
{ 0x04, 0x04, 0x80, DTMF_SIGNAL_NO_TONE },
|
|
{ 0x00, 0x04, 0x81, DTMF_SIGNAL_UNIDENTIFIED_TONE },
|
|
{ 0x04, 0x04, 0x82, DTMF_SIGNAL_DIAL_TONE },
|
|
{ 0x04, 0x04, 0x83, DTMF_SIGNAL_PABX_INTERNAL_DIAL_TONE },
|
|
{ 0x04, 0x04, 0x84, DTMF_SIGNAL_SPECIAL_DIAL_TONE },
|
|
{ 0x04, 0x04, 0x85, DTMF_SIGNAL_SECOND_DIAL_TONE },
|
|
{ 0x04, 0x04, 0x86, DTMF_SIGNAL_RINGING_TONE },
|
|
{ 0x04, 0x04, 0x87, DTMF_SIGNAL_SPECIAL_RINGING_TONE },
|
|
{ 0x04, 0x04, 0x88, DTMF_SIGNAL_BUSY_TONE },
|
|
{ 0x04, 0x04, 0x89, DTMF_SIGNAL_CONGESTION_TONE },
|
|
{ 0x04, 0x04, 0x8a, DTMF_SIGNAL_SPECIAL_INFORMATION_TONE },
|
|
{ 0x04, 0x04, 0x8b, DTMF_SIGNAL_COMFORT_TONE },
|
|
{ 0x04, 0x04, 0x8c, DTMF_SIGNAL_HOLD_TONE },
|
|
{ 0x04, 0x04, 0x8d, DTMF_SIGNAL_RECORD_TONE },
|
|
{ 0x04, 0x04, 0x8e, DTMF_SIGNAL_CALLER_WAITING_TONE },
|
|
{ 0x04, 0x04, 0x8f, DTMF_SIGNAL_CALL_WAITING_TONE },
|
|
{ 0x04, 0x04, 0x90, DTMF_SIGNAL_PAY_TONE },
|
|
{ 0x04, 0x04, 0x91, DTMF_SIGNAL_POSITIVE_INDICATION_TONE },
|
|
{ 0x04, 0x04, 0x92, DTMF_SIGNAL_NEGATIVE_INDICATION_TONE },
|
|
{ 0x04, 0x04, 0x93, DTMF_SIGNAL_WARNING_TONE },
|
|
{ 0x04, 0x04, 0x94, DTMF_SIGNAL_INTRUSION_TONE },
|
|
{ 0x04, 0x04, 0x95, DTMF_SIGNAL_CALLING_CARD_SERVICE_TONE },
|
|
{ 0x04, 0x04, 0x96, DTMF_SIGNAL_PAYPHONE_RECOGNITION_TONE },
|
|
{ 0x04, 0x04, 0x97, DTMF_SIGNAL_CPE_ALERTING_SIGNAL },
|
|
{ 0x04, 0x04, 0x98, DTMF_SIGNAL_OFF_HOOK_WARNING_TONE },
|
|
{ 0x04, 0x04, 0xbf, DTMF_SIGNAL_INTERCEPT_TONE },
|
|
{ 0x04, 0x04, 0xc0, DTMF_SIGNAL_MODEM_CALLING_TONE },
|
|
{ 0x04, 0x04, 0xc1, DTMF_SIGNAL_FAX_CALLING_TONE },
|
|
{ 0x04, 0x04, 0xc2, DTMF_SIGNAL_ANSWER_TONE },
|
|
{ 0x04, 0x04, 0xc3, DTMF_SIGNAL_REVERSED_ANSWER_TONE },
|
|
{ 0x04, 0x04, 0xc4, DTMF_SIGNAL_ANSAM_TONE },
|
|
{ 0x04, 0x04, 0xc5, DTMF_SIGNAL_REVERSED_ANSAM_TONE },
|
|
{ 0x04, 0x04, 0xc6, DTMF_SIGNAL_BELL103_ANSWER_TONE },
|
|
{ 0x04, 0x04, 0xc7, DTMF_SIGNAL_FAX_FLAGS },
|
|
{ 0x04, 0x04, 0xc8, DTMF_SIGNAL_G2_FAX_GROUP_ID },
|
|
{ 0x00, 0x04, 0xc9, DTMF_SIGNAL_HUMAN_SPEECH },
|
|
{ 0x04, 0x04, 0xca, DTMF_SIGNAL_ANSWERING_MACHINE_390 },
|
|
{ 0x02, 0x02, 0xf1, DTMF_MF_DIGIT_TONE_CODE_1 },
|
|
{ 0x02, 0x02, 0xf2, DTMF_MF_DIGIT_TONE_CODE_2 },
|
|
{ 0x02, 0x02, 0xf3, DTMF_MF_DIGIT_TONE_CODE_3 },
|
|
{ 0x02, 0x02, 0xf4, DTMF_MF_DIGIT_TONE_CODE_4 },
|
|
{ 0x02, 0x02, 0xf5, DTMF_MF_DIGIT_TONE_CODE_5 },
|
|
{ 0x02, 0x02, 0xf6, DTMF_MF_DIGIT_TONE_CODE_6 },
|
|
{ 0x02, 0x02, 0xf7, DTMF_MF_DIGIT_TONE_CODE_7 },
|
|
{ 0x02, 0x02, 0xf8, DTMF_MF_DIGIT_TONE_CODE_8 },
|
|
{ 0x02, 0x02, 0xf9, DTMF_MF_DIGIT_TONE_CODE_9 },
|
|
{ 0x02, 0x02, 0xfa, DTMF_MF_DIGIT_TONE_CODE_0 },
|
|
{ 0x02, 0x02, 0xfb, DTMF_MF_DIGIT_TONE_CODE_K1 },
|
|
{ 0x02, 0x02, 0xfc, DTMF_MF_DIGIT_TONE_CODE_K2 },
|
|
{ 0x02, 0x02, 0xfd, DTMF_MF_DIGIT_TONE_CODE_KP },
|
|
{ 0x02, 0x02, 0xfe, DTMF_MF_DIGIT_TONE_CODE_S1 },
|
|
{ 0x02, 0x02, 0xff, DTMF_MF_DIGIT_TONE_CODE_ST },
|
|
|
|
};
|
|
|
|
#define DTMF_DIGIT_MAP_ENTRIES ARRAY_SIZE(dtmf_digit_map)
|
|
|
|
|
|
static void dtmf_enable_receiver(PLCI *plci, byte enable_mask)
|
|
{
|
|
word min_digit_duration, min_gap_duration;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_enable_receiver %02x",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, enable_mask));
|
|
|
|
if (enable_mask != 0)
|
|
{
|
|
min_digit_duration = (plci->dtmf_rec_pulse_ms == 0) ? 40 : plci->dtmf_rec_pulse_ms;
|
|
min_gap_duration = (plci->dtmf_rec_pause_ms == 0) ? 40 : plci->dtmf_rec_pause_ms;
|
|
plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_ENABLE_RECEIVER;
|
|
PUT_WORD(&plci->internal_req_buffer[1], min_digit_duration);
|
|
PUT_WORD(&plci->internal_req_buffer[3], min_gap_duration);
|
|
plci->NData[0].PLength = 5;
|
|
|
|
PUT_WORD(&plci->internal_req_buffer[5], INTERNAL_IND_BUFFER_SIZE);
|
|
plci->NData[0].PLength += 2;
|
|
capidtmf_recv_enable(&(plci->capidtmf_state), min_digit_duration, min_gap_duration);
|
|
|
|
}
|
|
else
|
|
{
|
|
plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_DISABLE_RECEIVER;
|
|
plci->NData[0].PLength = 1;
|
|
|
|
capidtmf_recv_disable(&(plci->capidtmf_state));
|
|
|
|
}
|
|
plci->NData[0].P = plci->internal_req_buffer;
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.ReqCh = 0;
|
|
plci->NL.Req = plci->nl_req = (byte) N_UDATA;
|
|
plci->adapter->request(&plci->NL);
|
|
}
|
|
|
|
|
|
static void dtmf_send_digits(PLCI *plci, byte *digit_buffer, word digit_count)
|
|
{
|
|
word w, i;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_digits %d",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, digit_count));
|
|
|
|
plci->internal_req_buffer[0] = DTMF_UDATA_REQUEST_SEND_DIGITS;
|
|
w = (plci->dtmf_send_pulse_ms == 0) ? 40 : plci->dtmf_send_pulse_ms;
|
|
PUT_WORD(&plci->internal_req_buffer[1], w);
|
|
w = (plci->dtmf_send_pause_ms == 0) ? 40 : plci->dtmf_send_pause_ms;
|
|
PUT_WORD(&plci->internal_req_buffer[3], w);
|
|
for (i = 0; i < digit_count; i++)
|
|
{
|
|
w = 0;
|
|
while ((w < DTMF_DIGIT_MAP_ENTRIES)
|
|
&& (digit_buffer[i] != dtmf_digit_map[w].character))
|
|
{
|
|
w++;
|
|
}
|
|
plci->internal_req_buffer[5 + i] = (w < DTMF_DIGIT_MAP_ENTRIES) ?
|
|
dtmf_digit_map[w].code : DTMF_DIGIT_TONE_CODE_STAR;
|
|
}
|
|
plci->NData[0].PLength = 5 + digit_count;
|
|
plci->NData[0].P = plci->internal_req_buffer;
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.ReqCh = 0;
|
|
plci->NL.Req = plci->nl_req = (byte) N_UDATA;
|
|
plci->adapter->request(&plci->NL);
|
|
}
|
|
|
|
|
|
static void dtmf_rec_clear_config(PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_rec_clear_config",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
plci->dtmf_rec_active = 0;
|
|
plci->dtmf_rec_pulse_ms = 0;
|
|
plci->dtmf_rec_pause_ms = 0;
|
|
|
|
capidtmf_init(&(plci->capidtmf_state), plci->adapter->u_law);
|
|
|
|
}
|
|
|
|
|
|
static void dtmf_send_clear_config(PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_send_clear_config",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
plci->dtmf_send_requests = 0;
|
|
plci->dtmf_send_pulse_ms = 0;
|
|
plci->dtmf_send_pause_ms = 0;
|
|
}
|
|
|
|
|
|
static void dtmf_prepare_switch(dword Id, PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_prepare_switch",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
while (plci->dtmf_send_requests != 0)
|
|
dtmf_confirmation(Id, plci);
|
|
}
|
|
|
|
|
|
static word dtmf_save_config(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_save_config %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
return (GOOD);
|
|
}
|
|
|
|
|
|
static word dtmf_restore_config(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word Info;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_restore_config %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
Info = GOOD;
|
|
if (plci->B1_facilities & B1_FACILITY_DTMFR)
|
|
{
|
|
switch (plci->adjust_b_state)
|
|
{
|
|
case ADJUST_B_RESTORE_DTMF_1:
|
|
plci->internal_command = plci->adjust_b_command;
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
|
|
break;
|
|
}
|
|
dtmf_enable_receiver(plci, plci->dtmf_rec_active);
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_2;
|
|
break;
|
|
case ADJUST_B_RESTORE_DTMF_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Reenable DTMF receiver failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return (Info);
|
|
}
|
|
|
|
|
|
static void dtmf_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word internal_command, Info;
|
|
byte mask;
|
|
byte result[4];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_command %02x %04x %04x %d %d %d %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
|
|
plci->dtmf_cmd, plci->dtmf_rec_pulse_ms, plci->dtmf_rec_pause_ms,
|
|
plci->dtmf_send_pulse_ms, plci->dtmf_send_pause_ms));
|
|
|
|
Info = GOOD;
|
|
result[0] = 2;
|
|
PUT_WORD(&result[1], DTMF_SUCCESS);
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
mask = 0x01;
|
|
switch (plci->dtmf_cmd)
|
|
{
|
|
|
|
case DTMF_LISTEN_TONE_START:
|
|
mask <<= 1;
|
|
case DTMF_LISTEN_MF_START:
|
|
mask <<= 1;
|
|
|
|
case DTMF_LISTEN_START:
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
|
|
B1_FACILITY_DTMFR), DTMF_COMMAND_1);
|
|
case DTMF_COMMAND_1:
|
|
if (adjust_b_process(Id, plci, Rc) != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
case DTMF_COMMAND_2:
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = DTMF_COMMAND_2;
|
|
return;
|
|
}
|
|
plci->internal_command = DTMF_COMMAND_3;
|
|
dtmf_enable_receiver(plci, (byte)(plci->dtmf_rec_active | mask));
|
|
return;
|
|
case DTMF_COMMAND_3:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Enable DTMF receiver failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
|
|
plci->tone_last_indication_code = DTMF_SIGNAL_NO_TONE;
|
|
|
|
plci->dtmf_rec_active |= mask;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
|
|
case DTMF_LISTEN_TONE_STOP:
|
|
mask <<= 1;
|
|
case DTMF_LISTEN_MF_STOP:
|
|
mask <<= 1;
|
|
|
|
case DTMF_LISTEN_STOP:
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->dtmf_rec_active &= ~mask;
|
|
if (plci->dtmf_rec_active)
|
|
break;
|
|
/*
|
|
case DTMF_COMMAND_1:
|
|
if (plci->dtmf_rec_active)
|
|
{
|
|
if (plci_nl_busy (plci))
|
|
{
|
|
plci->internal_command = DTMF_COMMAND_1;
|
|
return;
|
|
}
|
|
plci->dtmf_rec_active &= ~mask;
|
|
plci->internal_command = DTMF_COMMAND_2;
|
|
dtmf_enable_receiver (plci, false);
|
|
return;
|
|
}
|
|
Rc = OK;
|
|
case DTMF_COMMAND_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug (1, dprintf("[%06lx] %s,%d: Disable DTMF receiver failed %02x",
|
|
UnMapId (Id), (char far *)(FILE_), __LINE__, Rc));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
*/
|
|
adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
|
|
~(B1_FACILITY_DTMFX | B1_FACILITY_DTMFR)), DTMF_COMMAND_3);
|
|
case DTMF_COMMAND_3:
|
|
if (adjust_b_process(Id, plci, Rc) != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Unload DTMF failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
|
|
case DTMF_SEND_TONE:
|
|
mask <<= 1;
|
|
case DTMF_SEND_MF:
|
|
mask <<= 1;
|
|
|
|
case DTMF_DIGITS_SEND:
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
|
|
((plci->dtmf_parameter_length != 0) ? B1_FACILITY_DTMFX | B1_FACILITY_DTMFR : B1_FACILITY_DTMFX)),
|
|
DTMF_COMMAND_1);
|
|
case DTMF_COMMAND_1:
|
|
if (adjust_b_process(Id, plci, Rc) != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Load DTMF failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
case DTMF_COMMAND_2:
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = DTMF_COMMAND_2;
|
|
return;
|
|
}
|
|
plci->dtmf_msg_number_queue[(plci->dtmf_send_requests)++] = plci->number;
|
|
plci->internal_command = DTMF_COMMAND_3;
|
|
dtmf_send_digits(plci, &plci->saved_msg.parms[3].info[1], plci->saved_msg.parms[3].length);
|
|
return;
|
|
case DTMF_COMMAND_3:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Send DTMF digits failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
if (plci->dtmf_send_requests != 0)
|
|
(plci->dtmf_send_requests)--;
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
|
|
"wws", Info, SELECTOR_DTMF, result);
|
|
}
|
|
|
|
|
|
static byte dtmf_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
word Info;
|
|
word i, j;
|
|
byte mask;
|
|
API_PARSE dtmf_parms[5];
|
|
byte result[40];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_request",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
Info = GOOD;
|
|
result[0] = 2;
|
|
PUT_WORD(&result[1], DTMF_SUCCESS);
|
|
if (!(a->profile.Global_Options & GL_DTMF_SUPPORTED))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
}
|
|
else if (api_parse(&msg[1].info[1], msg[1].length, "w", dtmf_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
|
|
else if ((GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
|
|
|| (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_SEND_CODES))
|
|
{
|
|
if (!((a->requested_options_table[appl->Id - 1])
|
|
& (1L << PRIVATE_DTMF_TONE)))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
|
|
PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < 32; i++)
|
|
result[4 + i] = 0;
|
|
if (GET_WORD(dtmf_parms[0].info) == DTMF_GET_SUPPORTED_DETECT_CODES)
|
|
{
|
|
for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
|
|
{
|
|
if (dtmf_digit_map[i].listen_mask != 0)
|
|
result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < DTMF_DIGIT_MAP_ENTRIES; i++)
|
|
{
|
|
if (dtmf_digit_map[i].send_mask != 0)
|
|
result[4 + (dtmf_digit_map[i].character >> 3)] |= (1 << (dtmf_digit_map[i].character & 0x7));
|
|
}
|
|
}
|
|
result[0] = 3 + 32;
|
|
result[3] = 32;
|
|
}
|
|
}
|
|
|
|
else if (plci == NULL)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_IDENTIFIER;
|
|
}
|
|
else
|
|
{
|
|
if (!plci->State
|
|
|| !plci->NL.Id || plci->nl_remove_id)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_STATE;
|
|
}
|
|
else
|
|
{
|
|
plci->command = 0;
|
|
plci->dtmf_cmd = GET_WORD(dtmf_parms[0].info);
|
|
mask = 0x01;
|
|
switch (plci->dtmf_cmd)
|
|
{
|
|
|
|
case DTMF_LISTEN_TONE_START:
|
|
case DTMF_LISTEN_TONE_STOP:
|
|
mask <<= 1;
|
|
case DTMF_LISTEN_MF_START:
|
|
case DTMF_LISTEN_MF_STOP:
|
|
mask <<= 1;
|
|
if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1])
|
|
& (1L << PRIVATE_DTMF_TONE)))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
|
|
PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
|
|
break;
|
|
}
|
|
|
|
case DTMF_LISTEN_START:
|
|
case DTMF_LISTEN_STOP:
|
|
if (!(a->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
|
|
&& !(a->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
if (mask & DTMF_LISTEN_ACTIVE_FLAG)
|
|
{
|
|
if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
|
|
{
|
|
plci->dtmf_rec_pulse_ms = 0;
|
|
plci->dtmf_rec_pause_ms = 0;
|
|
}
|
|
else
|
|
{
|
|
plci->dtmf_rec_pulse_ms = GET_WORD(dtmf_parms[1].info);
|
|
plci->dtmf_rec_pause_ms = GET_WORD(dtmf_parms[2].info);
|
|
}
|
|
}
|
|
start_internal_command(Id, plci, dtmf_command);
|
|
return (false);
|
|
|
|
|
|
case DTMF_SEND_TONE:
|
|
mask <<= 1;
|
|
case DTMF_SEND_MF:
|
|
mask <<= 1;
|
|
if (!((plci->requested_options_conn | plci->requested_options | plci->adapter->requested_options_table[appl->Id - 1])
|
|
& (1L << PRIVATE_DTMF_TONE)))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(dtmf_parms[0].info)));
|
|
PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
|
|
break;
|
|
}
|
|
|
|
case DTMF_DIGITS_SEND:
|
|
if (api_parse(&msg[1].info[1], msg[1].length, "wwws", dtmf_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
if (mask & DTMF_LISTEN_ACTIVE_FLAG)
|
|
{
|
|
plci->dtmf_send_pulse_ms = GET_WORD(dtmf_parms[1].info);
|
|
plci->dtmf_send_pause_ms = GET_WORD(dtmf_parms[2].info);
|
|
}
|
|
i = 0;
|
|
j = 0;
|
|
while ((i < dtmf_parms[3].length) && (j < DTMF_DIGIT_MAP_ENTRIES))
|
|
{
|
|
j = 0;
|
|
while ((j < DTMF_DIGIT_MAP_ENTRIES)
|
|
&& ((dtmf_parms[3].info[i + 1] != dtmf_digit_map[j].character)
|
|
|| ((dtmf_digit_map[j].send_mask & mask) == 0)))
|
|
{
|
|
j++;
|
|
}
|
|
i++;
|
|
}
|
|
if (j == DTMF_DIGIT_MAP_ENTRIES)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Incorrect DTMF digit %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, dtmf_parms[3].info[i]));
|
|
PUT_WORD(&result[1], DTMF_INCORRECT_DIGIT);
|
|
break;
|
|
}
|
|
if (plci->dtmf_send_requests >= ARRAY_SIZE(plci->dtmf_msg_number_queue))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: DTMF request overrun",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
api_save_msg(dtmf_parms, "wwws", &plci->saved_msg);
|
|
start_internal_command(Id, plci, dtmf_command);
|
|
return (false);
|
|
|
|
default:
|
|
dbug(1, dprintf("[%06lx] %s,%d: DTMF unknown request %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci->dtmf_cmd));
|
|
PUT_WORD(&result[1], DTMF_UNKNOWN_REQUEST);
|
|
}
|
|
}
|
|
}
|
|
sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
|
|
"wws", Info, SELECTOR_DTMF, result);
|
|
return (false);
|
|
}
|
|
|
|
|
|
static void dtmf_confirmation(dword Id, PLCI *plci)
|
|
{
|
|
word i;
|
|
byte result[4];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_confirmation",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
result[0] = 2;
|
|
PUT_WORD(&result[1], DTMF_SUCCESS);
|
|
if (plci->dtmf_send_requests != 0)
|
|
{
|
|
sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->dtmf_msg_number_queue[0],
|
|
"wws", GOOD, SELECTOR_DTMF, result);
|
|
(plci->dtmf_send_requests)--;
|
|
for (i = 0; i < plci->dtmf_send_requests; i++)
|
|
plci->dtmf_msg_number_queue[i] = plci->dtmf_msg_number_queue[i + 1];
|
|
}
|
|
}
|
|
|
|
|
|
static void dtmf_indication(dword Id, PLCI *plci, byte *msg, word length)
|
|
{
|
|
word i, j, n;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_indication",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
n = 0;
|
|
for (i = 1; i < length; i++)
|
|
{
|
|
j = 0;
|
|
while ((j < DTMF_DIGIT_MAP_ENTRIES)
|
|
&& ((msg[i] != dtmf_digit_map[j].code)
|
|
|| ((dtmf_digit_map[j].listen_mask & plci->dtmf_rec_active) == 0)))
|
|
{
|
|
j++;
|
|
}
|
|
if (j < DTMF_DIGIT_MAP_ENTRIES)
|
|
{
|
|
|
|
if ((dtmf_digit_map[j].listen_mask & DTMF_TONE_LISTEN_ACTIVE_FLAG)
|
|
&& (plci->tone_last_indication_code == DTMF_SIGNAL_NO_TONE)
|
|
&& (dtmf_digit_map[j].character != DTMF_SIGNAL_UNIDENTIFIED_TONE))
|
|
{
|
|
if (n + 1 == i)
|
|
{
|
|
for (i = length; i > n + 1; i--)
|
|
msg[i] = msg[i - 1];
|
|
length++;
|
|
i++;
|
|
}
|
|
msg[++n] = DTMF_SIGNAL_UNIDENTIFIED_TONE;
|
|
}
|
|
plci->tone_last_indication_code = dtmf_digit_map[j].character;
|
|
|
|
msg[++n] = dtmf_digit_map[j].character;
|
|
}
|
|
}
|
|
if (n != 0)
|
|
{
|
|
msg[0] = (byte) n;
|
|
sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "wS", SELECTOR_DTMF, msg);
|
|
}
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* DTMF parameters */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void dtmf_parameter_write(PLCI *plci)
|
|
{
|
|
word i;
|
|
byte parameter_buffer[DTMF_PARAMETER_BUFFER_SIZE + 2];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_write",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
parameter_buffer[0] = plci->dtmf_parameter_length + 1;
|
|
parameter_buffer[1] = DSP_CTRL_SET_DTMF_PARAMETERS;
|
|
for (i = 0; i < plci->dtmf_parameter_length; i++)
|
|
parameter_buffer[2 + i] = plci->dtmf_parameter_buffer[i];
|
|
add_p(plci, FTY, parameter_buffer);
|
|
sig_req(plci, TEL_CTRL, 0);
|
|
send_req(plci);
|
|
}
|
|
|
|
|
|
static void dtmf_parameter_clear_config(PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_clear_config",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
plci->dtmf_parameter_length = 0;
|
|
}
|
|
|
|
|
|
static void dtmf_parameter_prepare_switch(dword Id, PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_prepare_switch",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
}
|
|
|
|
|
|
static word dtmf_parameter_save_config(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_save_config %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
return (GOOD);
|
|
}
|
|
|
|
|
|
static word dtmf_parameter_restore_config(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word Info;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: dtmf_parameter_restore_config %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
Info = GOOD;
|
|
if ((plci->B1_facilities & B1_FACILITY_DTMFR)
|
|
&& (plci->dtmf_parameter_length != 0))
|
|
{
|
|
switch (plci->adjust_b_state)
|
|
{
|
|
case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
|
|
plci->internal_command = plci->adjust_b_command;
|
|
if (plci->sig_req)
|
|
{
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
|
|
break;
|
|
}
|
|
dtmf_parameter_write(plci);
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_2;
|
|
break;
|
|
case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Restore DTMF parameters failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return (Info);
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* Line interconnect facilities */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
|
|
LI_CONFIG *li_config_table;
|
|
word li_total_channels;
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* translate a CHI information element to a channel number */
|
|
/* returns 0xff - any channel */
|
|
/* 0xfe - chi wrong coding */
|
|
/* 0xfd - D-channel */
|
|
/* 0x00 - no channel */
|
|
/* else channel number / PRI: timeslot */
|
|
/* if channels is provided we accept more than one channel. */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static byte chi_to_channel(byte *chi, dword *pchannelmap)
|
|
{
|
|
int p;
|
|
int i;
|
|
dword map;
|
|
byte excl;
|
|
byte ofs;
|
|
byte ch;
|
|
|
|
if (pchannelmap) *pchannelmap = 0;
|
|
if (!chi[0]) return 0xff;
|
|
excl = 0;
|
|
|
|
if (chi[1] & 0x20) {
|
|
if (chi[0] == 1 && chi[1] == 0xac) return 0xfd; /* exclusive d-channel */
|
|
for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++);
|
|
if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
|
|
if ((chi[1] | 0xc8) != 0xe9) return 0xfe;
|
|
if (chi[1] & 0x08) excl = 0x40;
|
|
|
|
/* int. id present */
|
|
if (chi[1] & 0x40) {
|
|
p = i + 1;
|
|
for (i = p; i < chi[0] && !(chi[i] & 0x80); i++);
|
|
if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
|
|
}
|
|
|
|
/* coding standard, Number/Map, Channel Type */
|
|
p = i + 1;
|
|
for (i = p; i < chi[0] && !(chi[i] & 0x80); i++);
|
|
if (i == chi[0] || !(chi[i] & 0x80)) return 0xfe;
|
|
if ((chi[p] | 0xd0) != 0xd3) return 0xfe;
|
|
|
|
/* Number/Map */
|
|
if (chi[p] & 0x10) {
|
|
|
|
/* map */
|
|
if ((chi[0] - p) == 4) ofs = 0;
|
|
else if ((chi[0] - p) == 3) ofs = 1;
|
|
else return 0xfe;
|
|
ch = 0;
|
|
map = 0;
|
|
for (i = 0; i < 4 && p < chi[0]; i++) {
|
|
p++;
|
|
ch += 8;
|
|
map <<= 8;
|
|
if (chi[p]) {
|
|
for (ch = 0; !(chi[p] & (1 << ch)); ch++);
|
|
map |= chi[p];
|
|
}
|
|
}
|
|
ch += ofs;
|
|
map <<= ofs;
|
|
}
|
|
else {
|
|
|
|
/* number */
|
|
p = i + 1;
|
|
ch = chi[p] & 0x3f;
|
|
if (pchannelmap) {
|
|
if ((byte)(chi[0] - p) > 30) return 0xfe;
|
|
map = 0;
|
|
for (i = p; i <= chi[0]; i++) {
|
|
if ((chi[i] & 0x7f) > 31) return 0xfe;
|
|
map |= (1L << (chi[i] & 0x7f));
|
|
}
|
|
}
|
|
else {
|
|
if (p != chi[0]) return 0xfe;
|
|
if (ch > 31) return 0xfe;
|
|
map = (1L << ch);
|
|
}
|
|
if (chi[p] & 0x40) return 0xfe;
|
|
}
|
|
if (pchannelmap) *pchannelmap = map;
|
|
else if (map != ((dword)(1L << ch))) return 0xfe;
|
|
return (byte)(excl | ch);
|
|
}
|
|
else { /* not PRI */
|
|
for (i = 1; i < chi[0] && !(chi[i] & 0x80); i++);
|
|
if (i != chi[0] || !(chi[i] & 0x80)) return 0xfe;
|
|
if (chi[1] & 0x08) excl = 0x40;
|
|
|
|
switch (chi[1] | 0x98) {
|
|
case 0x98: return 0;
|
|
case 0x99:
|
|
if (pchannelmap) *pchannelmap = 2;
|
|
return excl | 1;
|
|
case 0x9a:
|
|
if (pchannelmap) *pchannelmap = 4;
|
|
return excl | 2;
|
|
case 0x9b: return 0xff;
|
|
case 0x9c: return 0xfd; /* d-ch */
|
|
default: return 0xfe;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void mixer_set_bchannel_id_esc(PLCI *plci, byte bchannel_id)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
PLCI *splci;
|
|
byte old_id;
|
|
|
|
a = plci->adapter;
|
|
old_id = plci->li_bchannel_id;
|
|
if (a->li_pri)
|
|
{
|
|
if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
|
|
li_config_table[a->li_base + (old_id - 1)].plci = NULL;
|
|
plci->li_bchannel_id = (bchannel_id & 0x1f) + 1;
|
|
if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
|
|
li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
|
|
}
|
|
else
|
|
{
|
|
if (((bchannel_id & 0x03) == 1) || ((bchannel_id & 0x03) == 2))
|
|
{
|
|
if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
|
|
li_config_table[a->li_base + (old_id - 1)].plci = NULL;
|
|
plci->li_bchannel_id = bchannel_id & 0x03;
|
|
if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
|
|
{
|
|
splci = a->AdvSignalPLCI;
|
|
if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
|
|
{
|
|
if ((splci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
|
|
{
|
|
li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
|
|
}
|
|
splci->li_bchannel_id = 3 - plci->li_bchannel_id;
|
|
li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
|
|
dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id_esc %d",
|
|
(dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, splci->li_bchannel_id));
|
|
}
|
|
}
|
|
if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
|
|
li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
|
|
}
|
|
}
|
|
if ((old_id == 0) && (plci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
|
|
{
|
|
mixer_clear_config(plci);
|
|
}
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id_esc %d %d",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, bchannel_id, plci->li_bchannel_id));
|
|
}
|
|
|
|
|
|
static void mixer_set_bchannel_id(PLCI *plci, byte *chi)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
PLCI *splci;
|
|
byte ch, old_id;
|
|
|
|
a = plci->adapter;
|
|
old_id = plci->li_bchannel_id;
|
|
ch = chi_to_channel(chi, NULL);
|
|
if (!(ch & 0x80))
|
|
{
|
|
if (a->li_pri)
|
|
{
|
|
if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
|
|
li_config_table[a->li_base + (old_id - 1)].plci = NULL;
|
|
plci->li_bchannel_id = (ch & 0x1f) + 1;
|
|
if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
|
|
li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
|
|
}
|
|
else
|
|
{
|
|
if (((ch & 0x1f) == 1) || ((ch & 0x1f) == 2))
|
|
{
|
|
if ((old_id != 0) && (li_config_table[a->li_base + (old_id - 1)].plci == plci))
|
|
li_config_table[a->li_base + (old_id - 1)].plci = NULL;
|
|
plci->li_bchannel_id = ch & 0x1f;
|
|
if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI != plci) && (a->AdvSignalPLCI->tel == ADV_VOICE))
|
|
{
|
|
splci = a->AdvSignalPLCI;
|
|
if (li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci == NULL)
|
|
{
|
|
if ((splci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci == splci))
|
|
{
|
|
li_config_table[a->li_base + (splci->li_bchannel_id - 1)].plci = NULL;
|
|
}
|
|
splci->li_bchannel_id = 3 - plci->li_bchannel_id;
|
|
li_config_table[a->li_base + (2 - plci->li_bchannel_id)].plci = splci;
|
|
dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
|
|
(dword)((splci->Id << 8) | UnMapController(splci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, splci->li_bchannel_id));
|
|
}
|
|
}
|
|
if (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == NULL)
|
|
li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci = plci;
|
|
}
|
|
}
|
|
}
|
|
if ((old_id == 0) && (plci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
|
|
{
|
|
mixer_clear_config(plci);
|
|
}
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_set_bchannel_id %02x %d",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, ch, plci->li_bchannel_id));
|
|
}
|
|
|
|
|
|
#define MIXER_MAX_DUMP_CHANNELS 34
|
|
|
|
static void mixer_calculate_coefs(DIVA_CAPI_ADAPTER *a)
|
|
{
|
|
static char hex_digit_table[0x10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
|
|
word n, i, j;
|
|
char *p;
|
|
char hex_line[2 * MIXER_MAX_DUMP_CHANNELS + MIXER_MAX_DUMP_CHANNELS / 8 + 4];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_calculate_coefs",
|
|
(dword)(UnMapController(a->Id)), (char *)(FILE_), __LINE__));
|
|
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
li_config_table[i].channel &= LI_CHANNEL_ADDRESSES_SET;
|
|
if (li_config_table[i].chflags != 0)
|
|
li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
|
|
else
|
|
{
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
if (((li_config_table[i].flag_table[j]) != 0)
|
|
|| ((li_config_table[j].flag_table[i]) != 0))
|
|
{
|
|
li_config_table[i].channel |= LI_CHANNEL_INVOLVED;
|
|
}
|
|
if (((li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE) != 0)
|
|
|| ((li_config_table[j].flag_table[i] & LI_FLAG_CONFERENCE) != 0))
|
|
{
|
|
li_config_table[i].channel |= LI_CHANNEL_CONFERENCE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC);
|
|
if (li_config_table[i].flag_table[j] & LI_FLAG_CONFERENCE)
|
|
li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
|
|
}
|
|
}
|
|
for (n = 0; n < li_total_channels; n++)
|
|
{
|
|
if (li_config_table[n].channel & LI_CHANNEL_CONFERENCE)
|
|
{
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if (li_config_table[i].channel & LI_CHANNEL_CONFERENCE)
|
|
{
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[i].coef_table[j] |=
|
|
li_config_table[i].coef_table[n] & li_config_table[n].coef_table[j];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
|
|
{
|
|
li_config_table[i].coef_table[i] &= ~LI_COEF_CH_CH;
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
if (li_config_table[i].coef_table[j] & LI_COEF_CH_CH)
|
|
li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE;
|
|
}
|
|
if (li_config_table[i].flag_table[i] & LI_FLAG_CONFERENCE)
|
|
li_config_table[i].coef_table[i] |= LI_COEF_CH_CH;
|
|
}
|
|
}
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
|
|
{
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
|
|
li_config_table[i].coef_table[j] |= LI_COEF_CH_CH;
|
|
if (li_config_table[i].flag_table[j] & LI_FLAG_MONITOR)
|
|
li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
|
|
if (li_config_table[i].flag_table[j] & LI_FLAG_MIX)
|
|
li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
|
|
if (li_config_table[i].flag_table[j] & LI_FLAG_PCCONNECT)
|
|
li_config_table[i].coef_table[j] |= LI_COEF_PC_PC;
|
|
}
|
|
if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
|
|
{
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
|
|
{
|
|
li_config_table[i].coef_table[j] |= LI_COEF_CH_PC;
|
|
if (li_config_table[j].chflags & LI_CHFLAG_MIX)
|
|
li_config_table[i].coef_table[j] |= LI_COEF_PC_CH | LI_COEF_PC_PC;
|
|
}
|
|
}
|
|
}
|
|
if (li_config_table[i].chflags & LI_CHFLAG_MIX)
|
|
{
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
if (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT)
|
|
li_config_table[j].coef_table[i] |= LI_COEF_PC_CH;
|
|
}
|
|
}
|
|
if (li_config_table[i].chflags & LI_CHFLAG_LOOP)
|
|
{
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
if (li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
|
|
{
|
|
for (n = 0; n < li_total_channels; n++)
|
|
{
|
|
if (li_config_table[n].flag_table[i] & LI_FLAG_INTERCONNECT)
|
|
{
|
|
li_config_table[n].coef_table[j] |= LI_COEF_CH_CH;
|
|
if (li_config_table[j].chflags & LI_CHFLAG_MIX)
|
|
{
|
|
li_config_table[n].coef_table[j] |= LI_COEF_PC_CH;
|
|
if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
|
|
li_config_table[n].coef_table[j] |= LI_COEF_CH_PC | LI_COEF_PC_PC;
|
|
}
|
|
else if (li_config_table[n].chflags & LI_CHFLAG_MONITOR)
|
|
li_config_table[n].coef_table[j] |= LI_COEF_CH_PC;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
|
|
{
|
|
if (li_config_table[i].chflags & (LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP))
|
|
li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
|
|
if (li_config_table[i].chflags & LI_CHFLAG_MONITOR)
|
|
li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
|
|
if (li_config_table[i].chflags & LI_CHFLAG_MIX)
|
|
li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
if ((li_config_table[i].flag_table[j] &
|
|
(LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_MONITOR))
|
|
|| (li_config_table[j].flag_table[i] &
|
|
(LI_FLAG_INTERCONNECT | LI_FLAG_PCCONNECT | LI_FLAG_CONFERENCE | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX)))
|
|
{
|
|
li_config_table[i].channel |= LI_CHANNEL_ACTIVE;
|
|
}
|
|
if (li_config_table[i].flag_table[j] & (LI_FLAG_PCCONNECT | LI_FLAG_MONITOR))
|
|
li_config_table[i].channel |= LI_CHANNEL_RX_DATA;
|
|
if (li_config_table[j].flag_table[i] & (LI_FLAG_PCCONNECT | LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX))
|
|
li_config_table[i].channel |= LI_CHANNEL_TX_DATA;
|
|
}
|
|
if (!(li_config_table[i].channel & LI_CHANNEL_ACTIVE))
|
|
{
|
|
li_config_table[i].coef_table[i] |= LI_COEF_PC_CH | LI_COEF_CH_PC;
|
|
li_config_table[i].channel |= LI_CHANNEL_TX_DATA | LI_CHANNEL_RX_DATA;
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if (li_config_table[i].channel & LI_CHANNEL_INVOLVED)
|
|
{
|
|
j = 0;
|
|
while ((j < li_total_channels) && !(li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT))
|
|
j++;
|
|
if (j < li_total_channels)
|
|
{
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[i].coef_table[j] &= ~(LI_COEF_CH_CH | LI_COEF_PC_CH);
|
|
if (li_config_table[i].flag_table[j] & LI_FLAG_ANNOUNCEMENT)
|
|
li_config_table[i].coef_table[j] |= LI_COEF_PC_CH;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
n = li_total_channels;
|
|
if (n > MIXER_MAX_DUMP_CHANNELS)
|
|
n = MIXER_MAX_DUMP_CHANNELS;
|
|
p = hex_line;
|
|
for (j = 0; j < n; j++)
|
|
{
|
|
if ((j & 0x7) == 0)
|
|
*(p++) = ' ';
|
|
*(p++) = hex_digit_table[li_config_table[j].curchnl >> 4];
|
|
*(p++) = hex_digit_table[li_config_table[j].curchnl & 0xf];
|
|
}
|
|
*p = '\0';
|
|
dbug(1, dprintf("[%06lx] CURRENT %s",
|
|
(dword)(UnMapController(a->Id)), (char *)hex_line));
|
|
p = hex_line;
|
|
for (j = 0; j < n; j++)
|
|
{
|
|
if ((j & 0x7) == 0)
|
|
*(p++) = ' ';
|
|
*(p++) = hex_digit_table[li_config_table[j].channel >> 4];
|
|
*(p++) = hex_digit_table[li_config_table[j].channel & 0xf];
|
|
}
|
|
*p = '\0';
|
|
dbug(1, dprintf("[%06lx] CHANNEL %s",
|
|
(dword)(UnMapController(a->Id)), (char *)hex_line));
|
|
p = hex_line;
|
|
for (j = 0; j < n; j++)
|
|
{
|
|
if ((j & 0x7) == 0)
|
|
*(p++) = ' ';
|
|
*(p++) = hex_digit_table[li_config_table[j].chflags >> 4];
|
|
*(p++) = hex_digit_table[li_config_table[j].chflags & 0xf];
|
|
}
|
|
*p = '\0';
|
|
dbug(1, dprintf("[%06lx] CHFLAG %s",
|
|
(dword)(UnMapController(a->Id)), (char *)hex_line));
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
p = hex_line;
|
|
for (j = 0; j < n; j++)
|
|
{
|
|
if ((j & 0x7) == 0)
|
|
*(p++) = ' ';
|
|
*(p++) = hex_digit_table[li_config_table[i].flag_table[j] >> 4];
|
|
*(p++) = hex_digit_table[li_config_table[i].flag_table[j] & 0xf];
|
|
}
|
|
*p = '\0';
|
|
dbug(1, dprintf("[%06lx] FLAG[%02x]%s",
|
|
(dword)(UnMapController(a->Id)), i, (char *)hex_line));
|
|
}
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
p = hex_line;
|
|
for (j = 0; j < n; j++)
|
|
{
|
|
if ((j & 0x7) == 0)
|
|
*(p++) = ' ';
|
|
*(p++) = hex_digit_table[li_config_table[i].coef_table[j] >> 4];
|
|
*(p++) = hex_digit_table[li_config_table[i].coef_table[j] & 0xf];
|
|
}
|
|
*p = '\0';
|
|
dbug(1, dprintf("[%06lx] COEF[%02x]%s",
|
|
(dword)(UnMapController(a->Id)), i, (char *)hex_line));
|
|
}
|
|
}
|
|
|
|
|
|
static struct
|
|
{
|
|
byte mask;
|
|
byte line_flags;
|
|
} mixer_write_prog_pri[] =
|
|
{
|
|
{ LI_COEF_CH_CH, 0 },
|
|
{ LI_COEF_CH_PC, MIXER_COEF_LINE_TO_PC_FLAG },
|
|
{ LI_COEF_PC_CH, MIXER_COEF_LINE_FROM_PC_FLAG },
|
|
{ LI_COEF_PC_PC, MIXER_COEF_LINE_TO_PC_FLAG | MIXER_COEF_LINE_FROM_PC_FLAG }
|
|
};
|
|
|
|
static struct
|
|
{
|
|
byte from_ch;
|
|
byte to_ch;
|
|
byte mask;
|
|
byte xconnect_override;
|
|
} mixer_write_prog_bri[] =
|
|
{
|
|
{ 0, 0, LI_COEF_CH_CH, 0x01 }, /* B to B */
|
|
{ 1, 0, LI_COEF_CH_CH, 0x01 }, /* Alt B to B */
|
|
{ 0, 0, LI_COEF_PC_CH, 0x80 }, /* PC to B */
|
|
{ 1, 0, LI_COEF_PC_CH, 0x01 }, /* Alt PC to B */
|
|
{ 2, 0, LI_COEF_CH_CH, 0x00 }, /* IC to B */
|
|
{ 3, 0, LI_COEF_CH_CH, 0x00 }, /* Alt IC to B */
|
|
{ 0, 0, LI_COEF_CH_PC, 0x80 }, /* B to PC */
|
|
{ 1, 0, LI_COEF_CH_PC, 0x01 }, /* Alt B to PC */
|
|
{ 0, 0, LI_COEF_PC_PC, 0x01 }, /* PC to PC */
|
|
{ 1, 0, LI_COEF_PC_PC, 0x01 }, /* Alt PC to PC */
|
|
{ 2, 0, LI_COEF_CH_PC, 0x00 }, /* IC to PC */
|
|
{ 3, 0, LI_COEF_CH_PC, 0x00 }, /* Alt IC to PC */
|
|
{ 0, 2, LI_COEF_CH_CH, 0x00 }, /* B to IC */
|
|
{ 1, 2, LI_COEF_CH_CH, 0x00 }, /* Alt B to IC */
|
|
{ 0, 2, LI_COEF_PC_CH, 0x00 }, /* PC to IC */
|
|
{ 1, 2, LI_COEF_PC_CH, 0x00 }, /* Alt PC to IC */
|
|
{ 2, 2, LI_COEF_CH_CH, 0x00 }, /* IC to IC */
|
|
{ 3, 2, LI_COEF_CH_CH, 0x00 }, /* Alt IC to IC */
|
|
{ 1, 1, LI_COEF_CH_CH, 0x01 }, /* Alt B to Alt B */
|
|
{ 0, 1, LI_COEF_CH_CH, 0x01 }, /* B to Alt B */
|
|
{ 1, 1, LI_COEF_PC_CH, 0x80 }, /* Alt PC to Alt B */
|
|
{ 0, 1, LI_COEF_PC_CH, 0x01 }, /* PC to Alt B */
|
|
{ 3, 1, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt B */
|
|
{ 2, 1, LI_COEF_CH_CH, 0x00 }, /* IC to Alt B */
|
|
{ 1, 1, LI_COEF_CH_PC, 0x80 }, /* Alt B to Alt PC */
|
|
{ 0, 1, LI_COEF_CH_PC, 0x01 }, /* B to Alt PC */
|
|
{ 1, 1, LI_COEF_PC_PC, 0x01 }, /* Alt PC to Alt PC */
|
|
{ 0, 1, LI_COEF_PC_PC, 0x01 }, /* PC to Alt PC */
|
|
{ 3, 1, LI_COEF_CH_PC, 0x00 }, /* Alt IC to Alt PC */
|
|
{ 2, 1, LI_COEF_CH_PC, 0x00 }, /* IC to Alt PC */
|
|
{ 1, 3, LI_COEF_CH_CH, 0x00 }, /* Alt B to Alt IC */
|
|
{ 0, 3, LI_COEF_CH_CH, 0x00 }, /* B to Alt IC */
|
|
{ 1, 3, LI_COEF_PC_CH, 0x00 }, /* Alt PC to Alt IC */
|
|
{ 0, 3, LI_COEF_PC_CH, 0x00 }, /* PC to Alt IC */
|
|
{ 3, 3, LI_COEF_CH_CH, 0x00 }, /* Alt IC to Alt IC */
|
|
{ 2, 3, LI_COEF_CH_CH, 0x00 } /* IC to Alt IC */
|
|
};
|
|
|
|
static byte mixer_swapped_index_bri[] =
|
|
{
|
|
18, /* B to B */
|
|
19, /* Alt B to B */
|
|
20, /* PC to B */
|
|
21, /* Alt PC to B */
|
|
22, /* IC to B */
|
|
23, /* Alt IC to B */
|
|
24, /* B to PC */
|
|
25, /* Alt B to PC */
|
|
26, /* PC to PC */
|
|
27, /* Alt PC to PC */
|
|
28, /* IC to PC */
|
|
29, /* Alt IC to PC */
|
|
30, /* B to IC */
|
|
31, /* Alt B to IC */
|
|
32, /* PC to IC */
|
|
33, /* Alt PC to IC */
|
|
34, /* IC to IC */
|
|
35, /* Alt IC to IC */
|
|
0, /* Alt B to Alt B */
|
|
1, /* B to Alt B */
|
|
2, /* Alt PC to Alt B */
|
|
3, /* PC to Alt B */
|
|
4, /* Alt IC to Alt B */
|
|
5, /* IC to Alt B */
|
|
6, /* Alt B to Alt PC */
|
|
7, /* B to Alt PC */
|
|
8, /* Alt PC to Alt PC */
|
|
9, /* PC to Alt PC */
|
|
10, /* Alt IC to Alt PC */
|
|
11, /* IC to Alt PC */
|
|
12, /* Alt B to Alt IC */
|
|
13, /* B to Alt IC */
|
|
14, /* Alt PC to Alt IC */
|
|
15, /* PC to Alt IC */
|
|
16, /* Alt IC to Alt IC */
|
|
17 /* IC to Alt IC */
|
|
};
|
|
|
|
static struct
|
|
{
|
|
byte mask;
|
|
byte from_pc;
|
|
byte to_pc;
|
|
} xconnect_write_prog[] =
|
|
{
|
|
{ LI_COEF_CH_CH, false, false },
|
|
{ LI_COEF_CH_PC, false, true },
|
|
{ LI_COEF_PC_CH, true, false },
|
|
{ LI_COEF_PC_PC, true, true }
|
|
};
|
|
|
|
|
|
static void xconnect_query_addresses(PLCI *plci)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word w, ch;
|
|
byte *p;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: xconnect_query_addresses",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
a = plci->adapter;
|
|
if (a->li_pri && ((plci->li_bchannel_id == 0)
|
|
|| (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci)))
|
|
{
|
|
dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
return;
|
|
}
|
|
p = plci->internal_req_buffer;
|
|
ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
|
|
*(p++) = UDATA_REQUEST_XCONNECT_FROM;
|
|
w = ch;
|
|
*(p++) = (byte) w;
|
|
*(p++) = (byte)(w >> 8);
|
|
w = ch | XCONNECT_CHANNEL_PORT_PC;
|
|
*(p++) = (byte) w;
|
|
*(p++) = (byte)(w >> 8);
|
|
plci->NData[0].P = plci->internal_req_buffer;
|
|
plci->NData[0].PLength = p - plci->internal_req_buffer;
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.ReqCh = 0;
|
|
plci->NL.Req = plci->nl_req = (byte) N_UDATA;
|
|
plci->adapter->request(&plci->NL);
|
|
}
|
|
|
|
|
|
static void xconnect_write_coefs(PLCI *plci, word internal_command)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: xconnect_write_coefs %04x",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, internal_command));
|
|
|
|
plci->li_write_command = internal_command;
|
|
plci->li_write_channel = 0;
|
|
}
|
|
|
|
|
|
static byte xconnect_write_coefs_process(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word w, n, i, j, r, s, to_ch;
|
|
dword d;
|
|
byte *p;
|
|
struct xconnect_transfer_address_s *transfer_address;
|
|
byte ch_map[MIXER_CHANNELS_BRI];
|
|
|
|
dbug(1, dprintf("[%06x] %s,%d: xconnect_write_coefs_process %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->li_write_channel));
|
|
|
|
a = plci->adapter;
|
|
if ((plci->li_bchannel_id == 0)
|
|
|| (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
|
|
{
|
|
dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
return (true);
|
|
}
|
|
i = a->li_base + (plci->li_bchannel_id - 1);
|
|
j = plci->li_write_channel;
|
|
p = plci->internal_req_buffer;
|
|
if (j != 0)
|
|
{
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI write coefs failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
return (false);
|
|
}
|
|
}
|
|
if (li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
|
|
{
|
|
r = 0;
|
|
s = 0;
|
|
if (j < li_total_channels)
|
|
{
|
|
if (li_config_table[i].channel & LI_CHANNEL_ADDRESSES_SET)
|
|
{
|
|
s = ((li_config_table[i].send_b.card_address.low | li_config_table[i].send_b.card_address.high) ?
|
|
(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_PC | LI_COEF_PC_PC)) &
|
|
((li_config_table[i].send_pc.card_address.low | li_config_table[i].send_pc.card_address.high) ?
|
|
(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_PC_CH));
|
|
}
|
|
r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
|
|
while ((j < li_total_channels)
|
|
&& ((r == 0)
|
|
|| (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
|
|
|| (!li_config_table[j].adapter->li_pri
|
|
&& (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
|
|
|| (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
|
|
|| (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
|
|
&& (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
|
|
|| !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
|
|
|| ((li_config_table[j].adapter->li_base != a->li_base)
|
|
&& !(r & s &
|
|
((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
|
|
(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
|
|
((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
|
|
(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))))
|
|
{
|
|
j++;
|
|
if (j < li_total_channels)
|
|
r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
|
|
}
|
|
}
|
|
if (j < li_total_channels)
|
|
{
|
|
plci->internal_command = plci->li_write_command;
|
|
if (plci_nl_busy(plci))
|
|
return (true);
|
|
to_ch = (a->li_pri) ? plci->li_bchannel_id - 1 : 0;
|
|
*(p++) = UDATA_REQUEST_XCONNECT_TO;
|
|
do
|
|
{
|
|
if (li_config_table[j].adapter->li_base != a->li_base)
|
|
{
|
|
r &= s &
|
|
((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
|
|
(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
|
|
((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
|
|
(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC));
|
|
}
|
|
n = 0;
|
|
do
|
|
{
|
|
if (r & xconnect_write_prog[n].mask)
|
|
{
|
|
if (xconnect_write_prog[n].from_pc)
|
|
transfer_address = &(li_config_table[j].send_pc);
|
|
else
|
|
transfer_address = &(li_config_table[j].send_b);
|
|
d = transfer_address->card_address.low;
|
|
*(p++) = (byte) d;
|
|
*(p++) = (byte)(d >> 8);
|
|
*(p++) = (byte)(d >> 16);
|
|
*(p++) = (byte)(d >> 24);
|
|
d = transfer_address->card_address.high;
|
|
*(p++) = (byte) d;
|
|
*(p++) = (byte)(d >> 8);
|
|
*(p++) = (byte)(d >> 16);
|
|
*(p++) = (byte)(d >> 24);
|
|
d = transfer_address->offset;
|
|
*(p++) = (byte) d;
|
|
*(p++) = (byte)(d >> 8);
|
|
*(p++) = (byte)(d >> 16);
|
|
*(p++) = (byte)(d >> 24);
|
|
w = xconnect_write_prog[n].to_pc ? to_ch | XCONNECT_CHANNEL_PORT_PC : to_ch;
|
|
*(p++) = (byte) w;
|
|
*(p++) = (byte)(w >> 8);
|
|
w = ((li_config_table[i].coef_table[j] & xconnect_write_prog[n].mask) == 0) ? 0x01 :
|
|
(li_config_table[i].adapter->u_law ?
|
|
(li_config_table[j].adapter->u_law ? 0x80 : 0x86) :
|
|
(li_config_table[j].adapter->u_law ? 0x7a : 0x80));
|
|
*(p++) = (byte) w;
|
|
*(p++) = (byte) 0;
|
|
li_config_table[i].coef_table[j] ^= xconnect_write_prog[n].mask << 4;
|
|
}
|
|
n++;
|
|
} while ((n < ARRAY_SIZE(xconnect_write_prog))
|
|
&& ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
|
|
if (n == ARRAY_SIZE(xconnect_write_prog))
|
|
{
|
|
do
|
|
{
|
|
j++;
|
|
if (j < li_total_channels)
|
|
r = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
|
|
} while ((j < li_total_channels)
|
|
&& ((r == 0)
|
|
|| (!(li_config_table[j].channel & LI_CHANNEL_ADDRESSES_SET))
|
|
|| (!li_config_table[j].adapter->li_pri
|
|
&& (j >= li_config_table[j].adapter->li_base + MIXER_BCHANNELS_BRI))
|
|
|| (((li_config_table[j].send_b.card_address.low != li_config_table[i].send_b.card_address.low)
|
|
|| (li_config_table[j].send_b.card_address.high != li_config_table[i].send_b.card_address.high))
|
|
&& (!(a->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)
|
|
|| !(li_config_table[j].adapter->manufacturer_features & MANUFACTURER_FEATURE_DMACONNECT)))
|
|
|| ((li_config_table[j].adapter->li_base != a->li_base)
|
|
&& !(r & s &
|
|
((li_config_table[j].send_b.card_address.low | li_config_table[j].send_b.card_address.high) ?
|
|
(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_PC_CH | LI_COEF_PC_PC)) &
|
|
((li_config_table[j].send_pc.card_address.low | li_config_table[j].send_pc.card_address.high) ?
|
|
(LI_COEF_CH_CH | LI_COEF_CH_PC | LI_COEF_PC_CH | LI_COEF_PC_PC) : (LI_COEF_CH_CH | LI_COEF_CH_PC))))));
|
|
}
|
|
} while ((j < li_total_channels)
|
|
&& ((p - plci->internal_req_buffer) + 16 < INTERNAL_REQ_BUFFER_SIZE));
|
|
}
|
|
else if (j == li_total_channels)
|
|
{
|
|
plci->internal_command = plci->li_write_command;
|
|
if (plci_nl_busy(plci))
|
|
return (true);
|
|
if (a->li_pri)
|
|
{
|
|
*(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
|
|
w = 0;
|
|
if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
|
|
w |= MIXER_FEATURE_ENABLE_TX_DATA;
|
|
if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
|
|
w |= MIXER_FEATURE_ENABLE_RX_DATA;
|
|
*(p++) = (byte) w;
|
|
*(p++) = (byte)(w >> 8);
|
|
}
|
|
else
|
|
{
|
|
*(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
|
|
w = 0;
|
|
if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
|
|
&& (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
|
|
{
|
|
w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
|
|
}
|
|
if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
|
|
w |= MIXER_FEATURE_ENABLE_TX_DATA;
|
|
if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
|
|
w |= MIXER_FEATURE_ENABLE_RX_DATA;
|
|
*(p++) = (byte) w;
|
|
*(p++) = (byte)(w >> 8);
|
|
for (j = 0; j < sizeof(ch_map); j += 2)
|
|
{
|
|
if (plci->li_bchannel_id == 2)
|
|
{
|
|
ch_map[j] = (byte)(j + 1);
|
|
ch_map[j + 1] = (byte) j;
|
|
}
|
|
else
|
|
{
|
|
ch_map[j] = (byte) j;
|
|
ch_map[j + 1] = (byte)(j + 1);
|
|
}
|
|
}
|
|
for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
|
|
{
|
|
i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
|
|
j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
|
|
if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
|
|
{
|
|
*p = (mixer_write_prog_bri[n].xconnect_override != 0) ?
|
|
mixer_write_prog_bri[n].xconnect_override :
|
|
((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
|
|
if ((i >= a->li_base + MIXER_BCHANNELS_BRI) || (j >= a->li_base + MIXER_BCHANNELS_BRI))
|
|
{
|
|
w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
|
|
li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*p = 0x00;
|
|
if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
|
|
{
|
|
w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
|
|
if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
|
|
*p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
j = li_total_channels + 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (j <= li_total_channels)
|
|
{
|
|
plci->internal_command = plci->li_write_command;
|
|
if (plci_nl_busy(plci))
|
|
return (true);
|
|
if (j < a->li_base)
|
|
j = a->li_base;
|
|
if (a->li_pri)
|
|
{
|
|
*(p++) = UDATA_REQUEST_SET_MIXER_COEFS_PRI_SYNC;
|
|
w = 0;
|
|
if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
|
|
w |= MIXER_FEATURE_ENABLE_TX_DATA;
|
|
if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
|
|
w |= MIXER_FEATURE_ENABLE_RX_DATA;
|
|
*(p++) = (byte) w;
|
|
*(p++) = (byte)(w >> 8);
|
|
for (n = 0; n < ARRAY_SIZE(mixer_write_prog_pri); n++)
|
|
{
|
|
*(p++) = (byte)((plci->li_bchannel_id - 1) | mixer_write_prog_pri[n].line_flags);
|
|
for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
|
|
{
|
|
w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
|
|
if (w & mixer_write_prog_pri[n].mask)
|
|
{
|
|
*(p++) = (li_config_table[i].coef_table[j] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
|
|
li_config_table[i].coef_table[j] ^= mixer_write_prog_pri[n].mask << 4;
|
|
}
|
|
else
|
|
*(p++) = 0x00;
|
|
}
|
|
*(p++) = (byte)((plci->li_bchannel_id - 1) | MIXER_COEF_LINE_ROW_FLAG | mixer_write_prog_pri[n].line_flags);
|
|
for (j = a->li_base; j < a->li_base + MIXER_CHANNELS_PRI; j++)
|
|
{
|
|
w = ((li_config_table[j].coef_table[i] & 0xf) ^ (li_config_table[j].coef_table[i] >> 4));
|
|
if (w & mixer_write_prog_pri[n].mask)
|
|
{
|
|
*(p++) = (li_config_table[j].coef_table[i] & mixer_write_prog_pri[n].mask) ? 0x80 : 0x01;
|
|
li_config_table[j].coef_table[i] ^= mixer_write_prog_pri[n].mask << 4;
|
|
}
|
|
else
|
|
*(p++) = 0x00;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*(p++) = UDATA_REQUEST_SET_MIXER_COEFS_BRI;
|
|
w = 0;
|
|
if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI)
|
|
&& (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length))
|
|
{
|
|
w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
|
|
}
|
|
if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
|
|
w |= MIXER_FEATURE_ENABLE_TX_DATA;
|
|
if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
|
|
w |= MIXER_FEATURE_ENABLE_RX_DATA;
|
|
*(p++) = (byte) w;
|
|
*(p++) = (byte)(w >> 8);
|
|
for (j = 0; j < sizeof(ch_map); j += 2)
|
|
{
|
|
if (plci->li_bchannel_id == 2)
|
|
{
|
|
ch_map[j] = (byte)(j + 1);
|
|
ch_map[j + 1] = (byte) j;
|
|
}
|
|
else
|
|
{
|
|
ch_map[j] = (byte) j;
|
|
ch_map[j + 1] = (byte)(j + 1);
|
|
}
|
|
}
|
|
for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
|
|
{
|
|
i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
|
|
j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
|
|
if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
|
|
{
|
|
*p = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
|
|
w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
|
|
li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
|
|
}
|
|
else
|
|
{
|
|
*p = 0x00;
|
|
if ((a->AdvSignalPLCI != NULL) && (a->AdvSignalPLCI->tel == ADV_VOICE))
|
|
{
|
|
w = (plci == a->AdvSignalPLCI) ? n : mixer_swapped_index_bri[n];
|
|
if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w < a->adv_voice_coef_length)
|
|
*p = a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + w];
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
j = li_total_channels + 1;
|
|
}
|
|
}
|
|
plci->li_write_channel = j;
|
|
if (p != plci->internal_req_buffer)
|
|
{
|
|
plci->NData[0].P = plci->internal_req_buffer;
|
|
plci->NData[0].PLength = p - plci->internal_req_buffer;
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.ReqCh = 0;
|
|
plci->NL.Req = plci->nl_req = (byte) N_UDATA;
|
|
plci->adapter->request(&plci->NL);
|
|
}
|
|
return (true);
|
|
}
|
|
|
|
|
|
static void mixer_notify_update(PLCI *plci, byte others)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word i, w;
|
|
PLCI *notify_plci;
|
|
byte msg[sizeof(CAPI_MSG_HEADER) + 6];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_notify_update %d",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, others));
|
|
|
|
a = plci->adapter;
|
|
if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
|
|
{
|
|
if (others)
|
|
plci->li_notify_update = true;
|
|
i = 0;
|
|
do
|
|
{
|
|
notify_plci = NULL;
|
|
if (others)
|
|
{
|
|
while ((i < li_total_channels) && (li_config_table[i].plci == NULL))
|
|
i++;
|
|
if (i < li_total_channels)
|
|
notify_plci = li_config_table[i++].plci;
|
|
}
|
|
else
|
|
{
|
|
if ((plci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
|
|
{
|
|
notify_plci = plci;
|
|
}
|
|
}
|
|
if ((notify_plci != NULL)
|
|
&& !notify_plci->li_notify_update
|
|
&& (notify_plci->appl != NULL)
|
|
&& (notify_plci->State)
|
|
&& notify_plci->NL.Id && !notify_plci->nl_remove_id)
|
|
{
|
|
notify_plci->li_notify_update = true;
|
|
((CAPI_MSG *) msg)->header.length = 18;
|
|
((CAPI_MSG *) msg)->header.appl_id = notify_plci->appl->Id;
|
|
((CAPI_MSG *) msg)->header.command = _FACILITY_R;
|
|
((CAPI_MSG *) msg)->header.number = 0;
|
|
((CAPI_MSG *) msg)->header.controller = notify_plci->adapter->Id;
|
|
((CAPI_MSG *) msg)->header.plci = notify_plci->Id;
|
|
((CAPI_MSG *) msg)->header.ncci = 0;
|
|
((CAPI_MSG *) msg)->info.facility_req.Selector = SELECTOR_LINE_INTERCONNECT;
|
|
((CAPI_MSG *) msg)->info.facility_req.structs[0] = 3;
|
|
PUT_WORD(&(((CAPI_MSG *) msg)->info.facility_req.structs[1]), LI_REQ_SILENT_UPDATE);
|
|
((CAPI_MSG *) msg)->info.facility_req.structs[3] = 0;
|
|
w = api_put(notify_plci->appl, (CAPI_MSG *) msg);
|
|
if (w != _QUEUE_FULL)
|
|
{
|
|
if (w != 0)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Interconnect notify failed %06x %d",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__,
|
|
(dword)((notify_plci->Id << 8) | UnMapController(notify_plci->adapter->Id)), w));
|
|
}
|
|
notify_plci->li_notify_update = false;
|
|
}
|
|
}
|
|
} while (others && (notify_plci != NULL));
|
|
if (others)
|
|
plci->li_notify_update = false;
|
|
}
|
|
}
|
|
|
|
|
|
static void mixer_clear_config(PLCI *plci)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word i, j;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_clear_config",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
plci->li_notify_update = false;
|
|
plci->li_plci_b_write_pos = 0;
|
|
plci->li_plci_b_read_pos = 0;
|
|
plci->li_plci_b_req_pos = 0;
|
|
a = plci->adapter;
|
|
if ((plci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
|
|
{
|
|
i = a->li_base + (plci->li_bchannel_id - 1);
|
|
li_config_table[i].curchnl = 0;
|
|
li_config_table[i].channel = 0;
|
|
li_config_table[i].chflags = 0;
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[j].flag_table[i] = 0;
|
|
li_config_table[i].flag_table[j] = 0;
|
|
li_config_table[i].coef_table[j] = 0;
|
|
li_config_table[j].coef_table[i] = 0;
|
|
}
|
|
if (!a->li_pri)
|
|
{
|
|
li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
|
|
if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
|
|
{
|
|
i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
|
|
li_config_table[i].curchnl = 0;
|
|
li_config_table[i].channel = 0;
|
|
li_config_table[i].chflags = 0;
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[i].flag_table[j] = 0;
|
|
li_config_table[j].flag_table[i] = 0;
|
|
li_config_table[i].coef_table[j] = 0;
|
|
li_config_table[j].coef_table[i] = 0;
|
|
}
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
|
|
{
|
|
i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
|
|
li_config_table[i].curchnl = 0;
|
|
li_config_table[i].channel = 0;
|
|
li_config_table[i].chflags = 0;
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[i].flag_table[j] = 0;
|
|
li_config_table[j].flag_table[i] = 0;
|
|
li_config_table[i].coef_table[j] = 0;
|
|
li_config_table[j].coef_table[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void mixer_prepare_switch(dword Id, PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_prepare_switch",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
do
|
|
{
|
|
mixer_indication_coefs_set(Id, plci);
|
|
} while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
|
|
}
|
|
|
|
|
|
static word mixer_save_config(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word i, j;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_save_config %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
a = plci->adapter;
|
|
if ((plci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
|
|
{
|
|
i = a->li_base + (plci->li_bchannel_id - 1);
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[i].coef_table[j] &= 0xf;
|
|
li_config_table[j].coef_table[i] &= 0xf;
|
|
}
|
|
if (!a->li_pri)
|
|
li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
|
|
}
|
|
return (GOOD);
|
|
}
|
|
|
|
|
|
static word mixer_restore_config(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word Info;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_restore_config %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
Info = GOOD;
|
|
a = plci->adapter;
|
|
if ((plci->B1_facilities & B1_FACILITY_MIXER)
|
|
&& (plci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
|
|
{
|
|
switch (plci->adjust_b_state)
|
|
{
|
|
case ADJUST_B_RESTORE_MIXER_1:
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
|
|
{
|
|
plci->internal_command = plci->adjust_b_command;
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
|
|
break;
|
|
}
|
|
xconnect_query_addresses(plci);
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_2;
|
|
break;
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
|
|
Rc = OK;
|
|
case ADJUST_B_RESTORE_MIXER_2:
|
|
case ADJUST_B_RESTORE_MIXER_3:
|
|
case ADJUST_B_RESTORE_MIXER_4:
|
|
if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B query addresses failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
if (Rc == OK)
|
|
{
|
|
if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_3;
|
|
else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
|
|
}
|
|
else if (Rc == 0)
|
|
{
|
|
if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_4;
|
|
else if (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_5;
|
|
}
|
|
if (plci->adjust_b_state != ADJUST_B_RESTORE_MIXER_5)
|
|
{
|
|
plci->internal_command = plci->adjust_b_command;
|
|
break;
|
|
}
|
|
case ADJUST_B_RESTORE_MIXER_5:
|
|
xconnect_write_coefs(plci, plci->adjust_b_command);
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_6;
|
|
Rc = OK;
|
|
case ADJUST_B_RESTORE_MIXER_6:
|
|
if (!xconnect_write_coefs_process(Id, plci, Rc))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
break;
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_7;
|
|
case ADJUST_B_RESTORE_MIXER_7:
|
|
break;
|
|
}
|
|
}
|
|
return (Info);
|
|
}
|
|
|
|
|
|
static void mixer_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word i, internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_command %02x %04x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
|
|
plci->li_cmd));
|
|
|
|
a = plci->adapter;
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (plci->li_cmd)
|
|
{
|
|
case LI_REQ_CONNECT:
|
|
case LI_REQ_DISCONNECT:
|
|
case LI_REQ_SILENT_UPDATE:
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
|
|
{
|
|
adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
|
|
B1_FACILITY_MIXER), MIXER_COMMAND_1);
|
|
}
|
|
case MIXER_COMMAND_1:
|
|
if (plci->li_channel_bits & LI_CHANNEL_INVOLVED)
|
|
{
|
|
if (adjust_b_process(Id, plci, Rc) != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Load mixer failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
}
|
|
plci->li_plci_b_req_pos = plci->li_plci_b_write_pos;
|
|
if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
|
|
|| ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER)
|
|
&& (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities &
|
|
~B1_FACILITY_MIXER)) == plci->B1_resource)))
|
|
{
|
|
xconnect_write_coefs(plci, MIXER_COMMAND_2);
|
|
}
|
|
else
|
|
{
|
|
do
|
|
{
|
|
mixer_indication_coefs_set(Id, plci);
|
|
} while (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos);
|
|
}
|
|
case MIXER_COMMAND_2:
|
|
if ((plci->li_channel_bits & LI_CHANNEL_INVOLVED)
|
|
|| ((get_b1_facilities(plci, plci->B1_resource) & B1_FACILITY_MIXER)
|
|
&& (add_b1_facilities(plci, plci->B1_resource, (word)(plci->B1_facilities &
|
|
~B1_FACILITY_MIXER)) == plci->B1_resource)))
|
|
{
|
|
if (!xconnect_write_coefs_process(Id, plci, Rc))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Write mixer coefs failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
if (plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
|
|
{
|
|
do
|
|
{
|
|
plci->li_plci_b_write_pos = (plci->li_plci_b_write_pos == 0) ?
|
|
LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1;
|
|
i = (plci->li_plci_b_write_pos == 0) ?
|
|
LI_PLCI_B_QUEUE_ENTRIES - 1 : plci->li_plci_b_write_pos - 1;
|
|
} while ((plci->li_plci_b_write_pos != plci->li_plci_b_req_pos)
|
|
&& !(plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG));
|
|
}
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
}
|
|
if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
|
|
{
|
|
adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
|
|
~B1_FACILITY_MIXER), MIXER_COMMAND_3);
|
|
}
|
|
case MIXER_COMMAND_3:
|
|
if (!(plci->li_channel_bits & LI_CHANNEL_INVOLVED))
|
|
{
|
|
if (adjust_b_process(Id, plci, Rc) != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Unload mixer failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if ((plci->li_bchannel_id == 0)
|
|
|| (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci != plci))
|
|
{
|
|
dbug(1, dprintf("[%06x] %s,%d: Channel id wiped out %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, (int)(plci->li_bchannel_id)));
|
|
}
|
|
else
|
|
{
|
|
i = a->li_base + (plci->li_bchannel_id - 1);
|
|
li_config_table[i].curchnl = plci->li_channel_bits;
|
|
if (!a->li_pri && (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
|
|
{
|
|
i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
|
|
li_config_table[i].curchnl = plci->li_channel_bits;
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
|
|
{
|
|
i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
|
|
li_config_table[i].curchnl = plci->li_channel_bits;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void li_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
|
|
dword plci_b_id, byte connect, dword li_flags)
|
|
{
|
|
word i, ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
|
|
PLCI *plci_b;
|
|
DIVA_CAPI_ADAPTER *a_b;
|
|
|
|
a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]);
|
|
plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
|
|
ch_a = a->li_base + (plci->li_bchannel_id - 1);
|
|
if (!a->li_pri && (plci->tel == ADV_VOICE)
|
|
&& (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
|
|
{
|
|
ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
|
|
ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
|
|
a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
|
|
}
|
|
else
|
|
{
|
|
ch_a_v = ch_a;
|
|
ch_a_s = ch_a;
|
|
}
|
|
ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
|
|
if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
|
|
&& (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
|
|
{
|
|
ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
|
|
ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
|
|
a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
|
|
}
|
|
else
|
|
{
|
|
ch_b_v = ch_b;
|
|
ch_b_s = ch_b;
|
|
}
|
|
if (connect)
|
|
{
|
|
li_config_table[ch_a].flag_table[ch_a_v] &= ~LI_FLAG_MONITOR;
|
|
li_config_table[ch_a].flag_table[ch_a_s] &= ~LI_FLAG_MONITOR;
|
|
li_config_table[ch_a_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
|
|
li_config_table[ch_a_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
|
|
}
|
|
li_config_table[ch_a].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
|
|
li_config_table[ch_a].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
|
|
li_config_table[ch_b_v].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
|
|
li_config_table[ch_b_s].flag_table[ch_a] &= ~(LI_FLAG_ANNOUNCEMENT | LI_FLAG_MIX);
|
|
if (ch_a_v == ch_b_v)
|
|
{
|
|
li_config_table[ch_a_v].flag_table[ch_b_v] &= ~LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_a_s].flag_table[ch_b_s] &= ~LI_FLAG_CONFERENCE;
|
|
}
|
|
else
|
|
{
|
|
if (li_config_table[ch_a_v].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
|
|
{
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if (i != ch_a_v)
|
|
li_config_table[ch_a_v].flag_table[i] &= ~LI_FLAG_CONFERENCE;
|
|
}
|
|
}
|
|
if (li_config_table[ch_a_s].flag_table[ch_b_v] & LI_FLAG_CONFERENCE)
|
|
{
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if (i != ch_a_s)
|
|
li_config_table[ch_a_s].flag_table[i] &= ~LI_FLAG_CONFERENCE;
|
|
}
|
|
}
|
|
if (li_config_table[ch_b_v].flag_table[ch_a_v] & LI_FLAG_CONFERENCE)
|
|
{
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if (i != ch_a_v)
|
|
li_config_table[i].flag_table[ch_a_v] &= ~LI_FLAG_CONFERENCE;
|
|
}
|
|
}
|
|
if (li_config_table[ch_b_v].flag_table[ch_a_s] & LI_FLAG_CONFERENCE)
|
|
{
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if (i != ch_a_s)
|
|
li_config_table[i].flag_table[ch_a_s] &= ~LI_FLAG_CONFERENCE;
|
|
}
|
|
}
|
|
}
|
|
if (li_flags & LI_FLAG_CONFERENCE_A_B)
|
|
{
|
|
li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
|
|
}
|
|
if (li_flags & LI_FLAG_CONFERENCE_B_A)
|
|
{
|
|
li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
|
|
}
|
|
if (li_flags & LI_FLAG_MONITOR_A)
|
|
{
|
|
li_config_table[ch_a].flag_table[ch_a_v] |= LI_FLAG_MONITOR;
|
|
li_config_table[ch_a].flag_table[ch_a_s] |= LI_FLAG_MONITOR;
|
|
}
|
|
if (li_flags & LI_FLAG_MONITOR_B)
|
|
{
|
|
li_config_table[ch_a].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
|
|
li_config_table[ch_a].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
|
|
}
|
|
if (li_flags & LI_FLAG_ANNOUNCEMENT_A)
|
|
{
|
|
li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
|
|
li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
|
|
}
|
|
if (li_flags & LI_FLAG_ANNOUNCEMENT_B)
|
|
{
|
|
li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
|
|
li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_ANNOUNCEMENT;
|
|
}
|
|
if (li_flags & LI_FLAG_MIX_A)
|
|
{
|
|
li_config_table[ch_a_v].flag_table[ch_a] |= LI_FLAG_MIX;
|
|
li_config_table[ch_a_s].flag_table[ch_a] |= LI_FLAG_MIX;
|
|
}
|
|
if (li_flags & LI_FLAG_MIX_B)
|
|
{
|
|
li_config_table[ch_b_v].flag_table[ch_a] |= LI_FLAG_MIX;
|
|
li_config_table[ch_b_s].flag_table[ch_a] |= LI_FLAG_MIX;
|
|
}
|
|
if (ch_a_v != ch_a_s)
|
|
{
|
|
li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
|
|
}
|
|
if (ch_b_v != ch_b_s)
|
|
{
|
|
li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
|
|
}
|
|
}
|
|
|
|
|
|
static void li2_update_connect(dword Id, DIVA_CAPI_ADAPTER *a, PLCI *plci,
|
|
dword plci_b_id, byte connect, dword li_flags)
|
|
{
|
|
word ch_a, ch_a_v, ch_a_s, ch_b, ch_b_v, ch_b_s;
|
|
PLCI *plci_b;
|
|
DIVA_CAPI_ADAPTER *a_b;
|
|
|
|
a_b = &(adapter[MapController((byte)(plci_b_id & 0x7f)) - 1]);
|
|
plci_b = &(a_b->plci[((plci_b_id >> 8) & 0xff) - 1]);
|
|
ch_a = a->li_base + (plci->li_bchannel_id - 1);
|
|
if (!a->li_pri && (plci->tel == ADV_VOICE)
|
|
&& (plci == a->AdvSignalPLCI) && (Id & EXT_CONTROLLER))
|
|
{
|
|
ch_a_v = ch_a + MIXER_IC_CHANNEL_BASE;
|
|
ch_a_s = (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
|
|
a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id) : ch_a_v;
|
|
}
|
|
else
|
|
{
|
|
ch_a_v = ch_a;
|
|
ch_a_s = ch_a;
|
|
}
|
|
ch_b = a_b->li_base + (plci_b->li_bchannel_id - 1);
|
|
if (!a_b->li_pri && (plci_b->tel == ADV_VOICE)
|
|
&& (plci_b == a_b->AdvSignalPLCI) && (plci_b_id & EXT_CONTROLLER))
|
|
{
|
|
ch_b_v = ch_b + MIXER_IC_CHANNEL_BASE;
|
|
ch_b_s = (a_b->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC) ?
|
|
a_b->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci_b->li_bchannel_id) : ch_b_v;
|
|
}
|
|
else
|
|
{
|
|
ch_b_v = ch_b;
|
|
ch_b_s = ch_b;
|
|
}
|
|
if (connect)
|
|
{
|
|
li_config_table[ch_b].flag_table[ch_b_v] &= ~LI_FLAG_MONITOR;
|
|
li_config_table[ch_b].flag_table[ch_b_s] &= ~LI_FLAG_MONITOR;
|
|
li_config_table[ch_b_v].flag_table[ch_b] &= ~LI_FLAG_MIX;
|
|
li_config_table[ch_b_s].flag_table[ch_b] &= ~LI_FLAG_MIX;
|
|
li_config_table[ch_b].flag_table[ch_b] &= ~LI_FLAG_PCCONNECT;
|
|
li_config_table[ch_b].chflags &= ~(LI_CHFLAG_MONITOR | LI_CHFLAG_MIX | LI_CHFLAG_LOOP);
|
|
}
|
|
li_config_table[ch_b_v].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
|
|
li_config_table[ch_b_s].flag_table[ch_a_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
|
|
li_config_table[ch_b_v].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
|
|
li_config_table[ch_b_s].flag_table[ch_a_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
|
|
li_config_table[ch_a_v].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
|
|
li_config_table[ch_a_v].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
|
|
li_config_table[ch_a_s].flag_table[ch_b_v] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
|
|
li_config_table[ch_a_s].flag_table[ch_b_s] &= ~(LI_FLAG_INTERCONNECT | LI_FLAG_CONFERENCE);
|
|
if (li_flags & LI2_FLAG_INTERCONNECT_A_B)
|
|
{
|
|
li_config_table[ch_b_v].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
|
|
li_config_table[ch_b_s].flag_table[ch_a_v] |= LI_FLAG_INTERCONNECT;
|
|
li_config_table[ch_b_v].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
|
|
li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_INTERCONNECT;
|
|
}
|
|
if (li_flags & LI2_FLAG_INTERCONNECT_B_A)
|
|
{
|
|
li_config_table[ch_a_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
|
|
li_config_table[ch_a_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
|
|
li_config_table[ch_a_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
|
|
li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
|
|
}
|
|
if (li_flags & LI2_FLAG_MONITOR_B)
|
|
{
|
|
li_config_table[ch_b].flag_table[ch_b_v] |= LI_FLAG_MONITOR;
|
|
li_config_table[ch_b].flag_table[ch_b_s] |= LI_FLAG_MONITOR;
|
|
}
|
|
if (li_flags & LI2_FLAG_MIX_B)
|
|
{
|
|
li_config_table[ch_b_v].flag_table[ch_b] |= LI_FLAG_MIX;
|
|
li_config_table[ch_b_s].flag_table[ch_b] |= LI_FLAG_MIX;
|
|
}
|
|
if (li_flags & LI2_FLAG_MONITOR_X)
|
|
li_config_table[ch_b].chflags |= LI_CHFLAG_MONITOR;
|
|
if (li_flags & LI2_FLAG_MIX_X)
|
|
li_config_table[ch_b].chflags |= LI_CHFLAG_MIX;
|
|
if (li_flags & LI2_FLAG_LOOP_B)
|
|
{
|
|
li_config_table[ch_b_v].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
|
|
li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_INTERCONNECT;
|
|
li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
|
|
li_config_table[ch_b_s].flag_table[ch_b_s] |= LI_FLAG_INTERCONNECT;
|
|
}
|
|
if (li_flags & LI2_FLAG_LOOP_PC)
|
|
li_config_table[ch_b].flag_table[ch_b] |= LI_FLAG_PCCONNECT;
|
|
if (li_flags & LI2_FLAG_LOOP_X)
|
|
li_config_table[ch_b].chflags |= LI_CHFLAG_LOOP;
|
|
if (li_flags & LI2_FLAG_PCCONNECT_A_B)
|
|
li_config_table[ch_b_s].flag_table[ch_a_s] |= LI_FLAG_PCCONNECT;
|
|
if (li_flags & LI2_FLAG_PCCONNECT_B_A)
|
|
li_config_table[ch_a_s].flag_table[ch_b_s] |= LI_FLAG_PCCONNECT;
|
|
if (ch_a_v != ch_a_s)
|
|
{
|
|
li_config_table[ch_a_v].flag_table[ch_a_s] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_a_s].flag_table[ch_a_v] |= LI_FLAG_CONFERENCE;
|
|
}
|
|
if (ch_b_v != ch_b_s)
|
|
{
|
|
li_config_table[ch_b_v].flag_table[ch_b_s] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[ch_b_s].flag_table[ch_b_v] |= LI_FLAG_CONFERENCE;
|
|
}
|
|
}
|
|
|
|
|
|
static word li_check_main_plci(dword Id, PLCI *plci)
|
|
{
|
|
if (plci == NULL)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
return (_WRONG_IDENTIFIER);
|
|
}
|
|
if (!plci->State
|
|
|| !plci->NL.Id || plci->nl_remove_id
|
|
|| (plci->li_bchannel_id == 0))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
return (_WRONG_STATE);
|
|
}
|
|
li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = plci;
|
|
return (GOOD);
|
|
}
|
|
|
|
|
|
static PLCI *li_check_plci_b(dword Id, PLCI *plci,
|
|
dword plci_b_id, word plci_b_write_pos, byte *p_result)
|
|
{
|
|
byte ctlr_b;
|
|
PLCI *plci_b;
|
|
|
|
if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
|
|
LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
|
|
return (NULL);
|
|
}
|
|
ctlr_b = 0;
|
|
if ((plci_b_id & 0x7f) != 0)
|
|
{
|
|
ctlr_b = MapController((byte)(plci_b_id & 0x7f));
|
|
if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
|
|
ctlr_b = 0;
|
|
}
|
|
if ((ctlr_b == 0)
|
|
|| (((plci_b_id >> 8) & 0xff) == 0)
|
|
|| (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
|
|
PUT_WORD(p_result, _WRONG_IDENTIFIER);
|
|
return (NULL);
|
|
}
|
|
plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
|
|
if (!plci_b->State
|
|
|| !plci_b->NL.Id || plci_b->nl_remove_id
|
|
|| (plci_b->li_bchannel_id == 0))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
|
|
PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
|
|
return (NULL);
|
|
}
|
|
li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci = plci_b;
|
|
if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
|
|
((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER))
|
|
&& (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
|
|
|| !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
|
|
PUT_WORD(p_result, _WRONG_IDENTIFIER);
|
|
return (NULL);
|
|
}
|
|
if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource,
|
|
(word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
|
|
PUT_WORD(p_result, _REQUEST_NOT_ALLOWED_IN_THIS_STATE);
|
|
return (NULL);
|
|
}
|
|
return (plci_b);
|
|
}
|
|
|
|
|
|
static PLCI *li2_check_plci_b(dword Id, PLCI *plci,
|
|
dword plci_b_id, word plci_b_write_pos, byte *p_result)
|
|
{
|
|
byte ctlr_b;
|
|
PLCI *plci_b;
|
|
|
|
if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
|
|
LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
PUT_WORD(p_result, _WRONG_STATE);
|
|
return (NULL);
|
|
}
|
|
ctlr_b = 0;
|
|
if ((plci_b_id & 0x7f) != 0)
|
|
{
|
|
ctlr_b = MapController((byte)(plci_b_id & 0x7f));
|
|
if ((ctlr_b > max_adapter) || ((ctlr_b != 0) && (adapter[ctlr_b - 1].request == NULL)))
|
|
ctlr_b = 0;
|
|
}
|
|
if ((ctlr_b == 0)
|
|
|| (((plci_b_id >> 8) & 0xff) == 0)
|
|
|| (((plci_b_id >> 8) & 0xff) > adapter[ctlr_b - 1].max_plci))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI invalid second PLCI %08lx",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
|
|
PUT_WORD(p_result, _WRONG_IDENTIFIER);
|
|
return (NULL);
|
|
}
|
|
plci_b = &(adapter[ctlr_b - 1].plci[((plci_b_id >> 8) & 0xff) - 1]);
|
|
if (!plci_b->State
|
|
|| !plci_b->NL.Id || plci_b->nl_remove_id
|
|
|| (plci_b->li_bchannel_id == 0)
|
|
|| (li_config_table[plci_b->adapter->li_base + (plci_b->li_bchannel_id - 1)].plci != plci_b))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI peer in wrong state %08lx",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
|
|
PUT_WORD(p_result, _WRONG_STATE);
|
|
return (NULL);
|
|
}
|
|
if (((byte)(plci_b_id & ~EXT_CONTROLLER)) !=
|
|
((byte)(UnMapController(plci->adapter->Id) & ~EXT_CONTROLLER))
|
|
&& (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
|
|
|| !(plci_b->adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI not on same ctrl %08lx",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci_b_id));
|
|
PUT_WORD(p_result, _WRONG_IDENTIFIER);
|
|
return (NULL);
|
|
}
|
|
if (!(get_b1_facilities(plci_b, add_b1_facilities(plci_b, plci_b->B1_resource,
|
|
(word)(plci_b->B1_facilities | B1_FACILITY_MIXER))) & B1_FACILITY_MIXER))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Interconnect peer cannot mix %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci_b->B1_resource));
|
|
PUT_WORD(p_result, _WRONG_STATE);
|
|
return (NULL);
|
|
}
|
|
return (plci_b);
|
|
}
|
|
|
|
|
|
static byte mixer_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
word Info;
|
|
word i;
|
|
dword d, li_flags, plci_b_id;
|
|
PLCI *plci_b;
|
|
API_PARSE li_parms[3];
|
|
API_PARSE li_req_parms[3];
|
|
API_PARSE li_participant_struct[2];
|
|
API_PARSE li_participant_parms[3];
|
|
word participant_parms_pos;
|
|
byte result_buffer[32];
|
|
byte *result;
|
|
word result_pos;
|
|
word plci_b_write_pos;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_request",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
Info = GOOD;
|
|
result = result_buffer;
|
|
result_buffer[0] = 0;
|
|
if (!(a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
}
|
|
else if (api_parse(&msg[1].info[1], msg[1].length, "ws", li_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
else
|
|
{
|
|
result_buffer[0] = 3;
|
|
PUT_WORD(&result_buffer[1], GET_WORD(li_parms[0].info));
|
|
result_buffer[3] = 0;
|
|
switch (GET_WORD(li_parms[0].info))
|
|
{
|
|
case LI_GET_SUPPORTED_SERVICES:
|
|
if (appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
|
|
{
|
|
result_buffer[0] = 17;
|
|
result_buffer[3] = 14;
|
|
PUT_WORD(&result_buffer[4], GOOD);
|
|
d = 0;
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_CH)
|
|
d |= LI_CONFERENCING_SUPPORTED;
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
|
|
d |= LI_MONITORING_SUPPORTED;
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
|
|
d |= LI_ANNOUNCEMENTS_SUPPORTED | LI_MIXING_SUPPORTED;
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
|
|
d |= LI_CROSS_CONTROLLER_SUPPORTED;
|
|
PUT_DWORD(&result_buffer[6], d);
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
|
|
{
|
|
d = 0;
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
|
|
&& (li_config_table[i].adapter->li_pri
|
|
|| (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
|
|
{
|
|
d++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
|
|
}
|
|
PUT_DWORD(&result_buffer[10], d / 2);
|
|
PUT_DWORD(&result_buffer[14], d);
|
|
}
|
|
else
|
|
{
|
|
result_buffer[0] = 25;
|
|
result_buffer[3] = 22;
|
|
PUT_WORD(&result_buffer[4], GOOD);
|
|
d = LI2_ASYMMETRIC_SUPPORTED | LI2_B_LOOPING_SUPPORTED | LI2_X_LOOPING_SUPPORTED;
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_CH_PC)
|
|
d |= LI2_MONITORING_SUPPORTED | LI2_REMOTE_MONITORING_SUPPORTED;
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_CH)
|
|
d |= LI2_MIXING_SUPPORTED | LI2_REMOTE_MIXING_SUPPORTED;
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_MIXER_PC_PC)
|
|
d |= LI2_PC_LOOPING_SUPPORTED;
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
|
|
d |= LI2_CROSS_CONTROLLER_SUPPORTED;
|
|
PUT_DWORD(&result_buffer[6], d);
|
|
d = a->li_pri ? a->li_channels : MIXER_BCHANNELS_BRI;
|
|
PUT_DWORD(&result_buffer[10], d / 2);
|
|
PUT_DWORD(&result_buffer[14], d - 1);
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
|
|
{
|
|
d = 0;
|
|
for (i = 0; i < li_total_channels; i++)
|
|
{
|
|
if ((li_config_table[i].adapter->manufacturer_features & MANUFACTURER_FEATURE_XCONNECT)
|
|
&& (li_config_table[i].adapter->li_pri
|
|
|| (i < li_config_table[i].adapter->li_base + MIXER_BCHANNELS_BRI)))
|
|
{
|
|
d++;
|
|
}
|
|
}
|
|
}
|
|
PUT_DWORD(&result_buffer[18], d / 2);
|
|
PUT_DWORD(&result_buffer[22], d - 1);
|
|
}
|
|
break;
|
|
|
|
case LI_REQ_CONNECT:
|
|
if (li_parms[1].length == 8)
|
|
{
|
|
appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
|
|
if (api_parse(&li_parms[1].info[1], li_parms[1].length, "dd", li_req_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff;
|
|
li_flags = GET_DWORD(li_req_parms[1].info);
|
|
Info = li_check_main_plci(Id, plci);
|
|
result_buffer[0] = 9;
|
|
result_buffer[3] = 6;
|
|
PUT_DWORD(&result_buffer[4], plci_b_id);
|
|
PUT_WORD(&result_buffer[8], GOOD);
|
|
if (Info != GOOD)
|
|
break;
|
|
result = plci->saved_msg.info;
|
|
for (i = 0; i <= result_buffer[0]; i++)
|
|
result[i] = result_buffer[i];
|
|
plci_b_write_pos = plci->li_plci_b_write_pos;
|
|
plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
|
|
if (plci_b == NULL)
|
|
break;
|
|
li_update_connect(Id, a, plci, plci_b_id, true, li_flags);
|
|
plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_LAST_FLAG;
|
|
plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
|
|
plci->li_plci_b_write_pos = plci_b_write_pos;
|
|
}
|
|
else
|
|
{
|
|
appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
|
|
if (api_parse(&li_parms[1].info[1], li_parms[1].length, "ds", li_req_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
li_flags = GET_DWORD(li_req_parms[0].info) & ~(LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A);
|
|
Info = li_check_main_plci(Id, plci);
|
|
result_buffer[0] = 7;
|
|
result_buffer[3] = 4;
|
|
PUT_WORD(&result_buffer[4], Info);
|
|
result_buffer[6] = 0;
|
|
if (Info != GOOD)
|
|
break;
|
|
result = plci->saved_msg.info;
|
|
for (i = 0; i <= result_buffer[0]; i++)
|
|
result[i] = result_buffer[i];
|
|
plci_b_write_pos = plci->li_plci_b_write_pos;
|
|
participant_parms_pos = 0;
|
|
result_pos = 7;
|
|
li2_update_connect(Id, a, plci, UnMapId(Id), true, li_flags);
|
|
while (participant_parms_pos < li_req_parms[1].length)
|
|
{
|
|
result[result_pos] = 6;
|
|
result_pos += 7;
|
|
PUT_DWORD(&result[result_pos - 6], 0);
|
|
PUT_WORD(&result[result_pos - 2], GOOD);
|
|
if (api_parse(&li_req_parms[1].info[1 + participant_parms_pos],
|
|
(word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
|
|
break;
|
|
}
|
|
if (api_parse(&li_participant_struct[0].info[1],
|
|
li_participant_struct[0].length, "dd", li_participant_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
|
|
break;
|
|
}
|
|
plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff;
|
|
li_flags = GET_DWORD(li_participant_parms[1].info);
|
|
PUT_DWORD(&result[result_pos - 6], plci_b_id);
|
|
if (sizeof(result) - result_pos < 7)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI result overrun",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
PUT_WORD(&result[result_pos - 2], _WRONG_STATE);
|
|
break;
|
|
}
|
|
plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
|
|
if (plci_b != NULL)
|
|
{
|
|
li2_update_connect(Id, a, plci, plci_b_id, true, li_flags);
|
|
plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id |
|
|
((li_flags & (LI2_FLAG_INTERCONNECT_A_B | LI2_FLAG_INTERCONNECT_B_A |
|
|
LI2_FLAG_PCCONNECT_A_B | LI2_FLAG_PCCONNECT_B_A)) ? 0 : LI_PLCI_B_DISC_FLAG);
|
|
plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
|
|
}
|
|
participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
|
|
(&li_req_parms[1].info[1]));
|
|
}
|
|
result[0] = (byte)(result_pos - 1);
|
|
result[3] = (byte)(result_pos - 4);
|
|
result[6] = (byte)(result_pos - 7);
|
|
i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
|
|
if ((plci_b_write_pos == plci->li_plci_b_read_pos)
|
|
|| (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
|
|
{
|
|
plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
|
|
plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
|
|
}
|
|
else
|
|
plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
|
|
plci->li_plci_b_write_pos = plci_b_write_pos;
|
|
}
|
|
mixer_calculate_coefs(a);
|
|
plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
|
|
mixer_notify_update(plci, true);
|
|
sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
|
|
"wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
|
|
plci->command = 0;
|
|
plci->li_cmd = GET_WORD(li_parms[0].info);
|
|
start_internal_command(Id, plci, mixer_command);
|
|
return (false);
|
|
|
|
case LI_REQ_DISCONNECT:
|
|
if (li_parms[1].length == 4)
|
|
{
|
|
appl->appl_flags |= APPL_FLAG_OLD_LI_SPEC;
|
|
if (api_parse(&li_parms[1].info[1], li_parms[1].length, "d", li_req_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
plci_b_id = GET_DWORD(li_req_parms[0].info) & 0xffff;
|
|
Info = li_check_main_plci(Id, plci);
|
|
result_buffer[0] = 9;
|
|
result_buffer[3] = 6;
|
|
PUT_DWORD(&result_buffer[4], GET_DWORD(li_req_parms[0].info));
|
|
PUT_WORD(&result_buffer[8], GOOD);
|
|
if (Info != GOOD)
|
|
break;
|
|
result = plci->saved_msg.info;
|
|
for (i = 0; i <= result_buffer[0]; i++)
|
|
result[i] = result_buffer[i];
|
|
plci_b_write_pos = plci->li_plci_b_write_pos;
|
|
plci_b = li_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[8]);
|
|
if (plci_b == NULL)
|
|
break;
|
|
li_update_connect(Id, a, plci, plci_b_id, false, 0);
|
|
plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG | LI_PLCI_B_LAST_FLAG;
|
|
plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
|
|
plci->li_plci_b_write_pos = plci_b_write_pos;
|
|
}
|
|
else
|
|
{
|
|
appl->appl_flags &= ~APPL_FLAG_OLD_LI_SPEC;
|
|
if (api_parse(&li_parms[1].info[1], li_parms[1].length, "s", li_req_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
break;
|
|
}
|
|
Info = li_check_main_plci(Id, plci);
|
|
result_buffer[0] = 7;
|
|
result_buffer[3] = 4;
|
|
PUT_WORD(&result_buffer[4], Info);
|
|
result_buffer[6] = 0;
|
|
if (Info != GOOD)
|
|
break;
|
|
result = plci->saved_msg.info;
|
|
for (i = 0; i <= result_buffer[0]; i++)
|
|
result[i] = result_buffer[i];
|
|
plci_b_write_pos = plci->li_plci_b_write_pos;
|
|
participant_parms_pos = 0;
|
|
result_pos = 7;
|
|
while (participant_parms_pos < li_req_parms[0].length)
|
|
{
|
|
result[result_pos] = 6;
|
|
result_pos += 7;
|
|
PUT_DWORD(&result[result_pos - 6], 0);
|
|
PUT_WORD(&result[result_pos - 2], GOOD);
|
|
if (api_parse(&li_req_parms[0].info[1 + participant_parms_pos],
|
|
(word)(li_parms[1].length - participant_parms_pos), "s", li_participant_struct))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
|
|
break;
|
|
}
|
|
if (api_parse(&li_participant_struct[0].info[1],
|
|
li_participant_struct[0].length, "d", li_participant_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
PUT_WORD(&result[result_pos - 2], _WRONG_MESSAGE_FORMAT);
|
|
break;
|
|
}
|
|
plci_b_id = GET_DWORD(li_participant_parms[0].info) & 0xffff;
|
|
PUT_DWORD(&result[result_pos - 6], plci_b_id);
|
|
if (sizeof(result) - result_pos < 7)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI result overrun",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
PUT_WORD(&result[result_pos - 2], _WRONG_STATE);
|
|
break;
|
|
}
|
|
plci_b = li2_check_plci_b(Id, plci, plci_b_id, plci_b_write_pos, &result[result_pos - 2]);
|
|
if (plci_b != NULL)
|
|
{
|
|
li2_update_connect(Id, a, plci, plci_b_id, false, 0);
|
|
plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
|
|
plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
|
|
}
|
|
participant_parms_pos = (word)((&li_participant_struct[0].info[1 + li_participant_struct[0].length]) -
|
|
(&li_req_parms[0].info[1]));
|
|
}
|
|
result[0] = (byte)(result_pos - 1);
|
|
result[3] = (byte)(result_pos - 4);
|
|
result[6] = (byte)(result_pos - 7);
|
|
i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
|
|
if ((plci_b_write_pos == plci->li_plci_b_read_pos)
|
|
|| (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
|
|
{
|
|
plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
|
|
plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
|
|
}
|
|
else
|
|
plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
|
|
plci->li_plci_b_write_pos = plci_b_write_pos;
|
|
}
|
|
mixer_calculate_coefs(a);
|
|
plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
|
|
mixer_notify_update(plci, true);
|
|
sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
|
|
"wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
|
|
plci->command = 0;
|
|
plci->li_cmd = GET_WORD(li_parms[0].info);
|
|
start_internal_command(Id, plci, mixer_command);
|
|
return (false);
|
|
|
|
case LI_REQ_SILENT_UPDATE:
|
|
if (!plci || !plci->State
|
|
|| !plci->NL.Id || plci->nl_remove_id
|
|
|| (plci->li_bchannel_id == 0)
|
|
|| (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci != plci))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
return (false);
|
|
}
|
|
plci_b_write_pos = plci->li_plci_b_write_pos;
|
|
if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
|
|
LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 2)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
return (false);
|
|
}
|
|
i = (plci_b_write_pos == 0) ? LI_PLCI_B_QUEUE_ENTRIES - 1 : plci_b_write_pos - 1;
|
|
if ((plci_b_write_pos == plci->li_plci_b_read_pos)
|
|
|| (plci->li_plci_b_queue[i] & LI_PLCI_B_LAST_FLAG))
|
|
{
|
|
plci->li_plci_b_queue[plci_b_write_pos] = LI_PLCI_B_SKIP_FLAG | LI_PLCI_B_LAST_FLAG;
|
|
plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
|
|
}
|
|
else
|
|
plci->li_plci_b_queue[i] |= LI_PLCI_B_LAST_FLAG;
|
|
plci->li_plci_b_write_pos = plci_b_write_pos;
|
|
plci->li_channel_bits = li_config_table[a->li_base + (plci->li_bchannel_id - 1)].channel;
|
|
plci->command = 0;
|
|
plci->li_cmd = GET_WORD(li_parms[0].info);
|
|
start_internal_command(Id, plci, mixer_command);
|
|
return (false);
|
|
|
|
default:
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI unknown request %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, GET_WORD(li_parms[0].info)));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
}
|
|
}
|
|
sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
|
|
"wwS", Info, SELECTOR_LINE_INTERCONNECT, result);
|
|
return (false);
|
|
}
|
|
|
|
|
|
static void mixer_indication_coefs_set(dword Id, PLCI *plci)
|
|
{
|
|
dword d;
|
|
byte result[12];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_coefs_set",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
if (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos)
|
|
{
|
|
do
|
|
{
|
|
d = plci->li_plci_b_queue[plci->li_plci_b_read_pos];
|
|
if (!(d & LI_PLCI_B_SKIP_FLAG))
|
|
{
|
|
if (plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
|
|
{
|
|
if (d & LI_PLCI_B_DISC_FLAG)
|
|
{
|
|
result[0] = 5;
|
|
PUT_WORD(&result[1], LI_IND_DISCONNECT);
|
|
result[3] = 2;
|
|
PUT_WORD(&result[4], _LI_USER_INITIATED);
|
|
}
|
|
else
|
|
{
|
|
result[0] = 7;
|
|
PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE);
|
|
result[3] = 4;
|
|
PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (d & LI_PLCI_B_DISC_FLAG)
|
|
{
|
|
result[0] = 9;
|
|
PUT_WORD(&result[1], LI_IND_DISCONNECT);
|
|
result[3] = 6;
|
|
PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
|
|
PUT_WORD(&result[8], _LI_USER_INITIATED);
|
|
}
|
|
else
|
|
{
|
|
result[0] = 7;
|
|
PUT_WORD(&result[1], LI_IND_CONNECT_ACTIVE);
|
|
result[3] = 4;
|
|
PUT_DWORD(&result[4], d & ~LI_PLCI_B_FLAG_MASK);
|
|
}
|
|
}
|
|
sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0,
|
|
"ws", SELECTOR_LINE_INTERCONNECT, result);
|
|
}
|
|
plci->li_plci_b_read_pos = (plci->li_plci_b_read_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ?
|
|
0 : plci->li_plci_b_read_pos + 1;
|
|
} while (!(d & LI_PLCI_B_LAST_FLAG) && (plci->li_plci_b_read_pos != plci->li_plci_b_req_pos));
|
|
}
|
|
}
|
|
|
|
|
|
static void mixer_indication_xconnect_from(dword Id, PLCI *plci, byte *msg, word length)
|
|
{
|
|
word i, j, ch;
|
|
struct xconnect_transfer_address_s s, *p;
|
|
DIVA_CAPI_ADAPTER *a;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_from %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, (int)length));
|
|
|
|
a = plci->adapter;
|
|
i = 1;
|
|
for (i = 1; i < length; i += 16)
|
|
{
|
|
s.card_address.low = msg[i] | (msg[i + 1] << 8) | (((dword)(msg[i + 2])) << 16) | (((dword)(msg[i + 3])) << 24);
|
|
s.card_address.high = msg[i + 4] | (msg[i + 5] << 8) | (((dword)(msg[i + 6])) << 16) | (((dword)(msg[i + 7])) << 24);
|
|
s.offset = msg[i + 8] | (msg[i + 9] << 8) | (((dword)(msg[i + 10])) << 16) | (((dword)(msg[i + 11])) << 24);
|
|
ch = msg[i + 12] | (msg[i + 13] << 8);
|
|
j = ch & XCONNECT_CHANNEL_NUMBER_MASK;
|
|
if (!a->li_pri && (plci->li_bchannel_id == 2))
|
|
j = 1 - j;
|
|
j += a->li_base;
|
|
if (ch & XCONNECT_CHANNEL_PORT_PC)
|
|
p = &(li_config_table[j].send_pc);
|
|
else
|
|
p = &(li_config_table[j].send_b);
|
|
p->card_address.low = s.card_address.low;
|
|
p->card_address.high = s.card_address.high;
|
|
p->offset = s.offset;
|
|
li_config_table[j].channel |= LI_CHANNEL_ADDRESSES_SET;
|
|
}
|
|
if (plci->internal_command_queue[0]
|
|
&& ((plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_2)
|
|
|| (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_3)
|
|
|| (plci->adjust_b_state == ADJUST_B_RESTORE_MIXER_4)))
|
|
{
|
|
(*(plci->internal_command_queue[0]))(Id, plci, 0);
|
|
if (!plci->internal_command)
|
|
next_internal_command(Id, plci);
|
|
}
|
|
mixer_notify_update(plci, true);
|
|
}
|
|
|
|
|
|
static void mixer_indication_xconnect_to(dword Id, PLCI *plci, byte *msg, word length)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_indication_xconnect_to %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, (int) length));
|
|
|
|
}
|
|
|
|
|
|
static byte mixer_notify_source_removed(PLCI *plci, dword plci_b_id)
|
|
{
|
|
word plci_b_write_pos;
|
|
|
|
plci_b_write_pos = plci->li_plci_b_write_pos;
|
|
if (((plci->li_plci_b_read_pos > plci_b_write_pos) ? plci->li_plci_b_read_pos :
|
|
LI_PLCI_B_QUEUE_ENTRIES + plci->li_plci_b_read_pos) - plci_b_write_pos - 1 < 1)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: LI request overrun",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
return (false);
|
|
}
|
|
plci->li_plci_b_queue[plci_b_write_pos] = plci_b_id | LI_PLCI_B_DISC_FLAG;
|
|
plci_b_write_pos = (plci_b_write_pos == LI_PLCI_B_QUEUE_ENTRIES - 1) ? 0 : plci_b_write_pos + 1;
|
|
plci->li_plci_b_write_pos = plci_b_write_pos;
|
|
return (true);
|
|
}
|
|
|
|
|
|
static void mixer_remove(PLCI *plci)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
PLCI *notify_plci;
|
|
dword plci_b_id;
|
|
word i, j;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: mixer_remove",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
a = plci->adapter;
|
|
plci_b_id = (plci->Id << 8) | UnMapController(plci->adapter->Id);
|
|
if (a->profile.Global_Options & GL_LINE_INTERCONNECT_SUPPORTED)
|
|
{
|
|
if ((plci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
|
|
{
|
|
i = a->li_base + (plci->li_bchannel_id - 1);
|
|
if ((li_config_table[i].curchnl | li_config_table[i].channel) & LI_CHANNEL_INVOLVED)
|
|
{
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
if ((li_config_table[i].flag_table[j] & LI_FLAG_INTERCONNECT)
|
|
|| (li_config_table[j].flag_table[i] & LI_FLAG_INTERCONNECT))
|
|
{
|
|
notify_plci = li_config_table[j].plci;
|
|
if ((notify_plci != NULL)
|
|
&& (notify_plci != plci)
|
|
&& (notify_plci->appl != NULL)
|
|
&& !(notify_plci->appl->appl_flags & APPL_FLAG_OLD_LI_SPEC)
|
|
&& (notify_plci->State)
|
|
&& notify_plci->NL.Id && !notify_plci->nl_remove_id)
|
|
{
|
|
mixer_notify_source_removed(notify_plci, plci_b_id);
|
|
}
|
|
}
|
|
}
|
|
mixer_clear_config(plci);
|
|
mixer_calculate_coefs(a);
|
|
mixer_notify_update(plci, true);
|
|
}
|
|
li_config_table[i].plci = NULL;
|
|
plci->li_bchannel_id = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* Echo canceller facilities */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
|
|
static void ec_write_parameters(PLCI *plci)
|
|
{
|
|
word w;
|
|
byte parameter_buffer[6];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: ec_write_parameters",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
parameter_buffer[0] = 5;
|
|
parameter_buffer[1] = DSP_CTRL_SET_LEC_PARAMETERS;
|
|
PUT_WORD(¶meter_buffer[2], plci->ec_idi_options);
|
|
plci->ec_idi_options &= ~LEC_RESET_COEFFICIENTS;
|
|
w = (plci->ec_tail_length == 0) ? 128 : plci->ec_tail_length;
|
|
PUT_WORD(¶meter_buffer[4], w);
|
|
add_p(plci, FTY, parameter_buffer);
|
|
sig_req(plci, TEL_CTRL, 0);
|
|
send_req(plci);
|
|
}
|
|
|
|
|
|
static void ec_clear_config(PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: ec_clear_config",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
|
|
LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING;
|
|
plci->ec_tail_length = 0;
|
|
}
|
|
|
|
|
|
static void ec_prepare_switch(dword Id, PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: ec_prepare_switch",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
}
|
|
|
|
|
|
static word ec_save_config(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: ec_save_config %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
return (GOOD);
|
|
}
|
|
|
|
|
|
static word ec_restore_config(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word Info;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: ec_restore_config %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
Info = GOOD;
|
|
if (plci->B1_facilities & B1_FACILITY_EC)
|
|
{
|
|
switch (plci->adjust_b_state)
|
|
{
|
|
case ADJUST_B_RESTORE_EC_1:
|
|
plci->internal_command = plci->adjust_b_command;
|
|
if (plci->sig_req)
|
|
{
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
|
|
break;
|
|
}
|
|
ec_write_parameters(plci);
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_EC_2;
|
|
break;
|
|
case ADJUST_B_RESTORE_EC_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Restore EC failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return (Info);
|
|
}
|
|
|
|
|
|
static void ec_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word internal_command, Info;
|
|
byte result[8];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: ec_command %02x %04x %04x %04x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command,
|
|
plci->ec_cmd, plci->ec_idi_options, plci->ec_tail_length));
|
|
|
|
Info = GOOD;
|
|
if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
|
|
{
|
|
result[0] = 2;
|
|
PUT_WORD(&result[1], EC_SUCCESS);
|
|
}
|
|
else
|
|
{
|
|
result[0] = 5;
|
|
PUT_WORD(&result[1], plci->ec_cmd);
|
|
result[3] = 2;
|
|
PUT_WORD(&result[4], GOOD);
|
|
}
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (plci->ec_cmd)
|
|
{
|
|
case EC_ENABLE_OPERATION:
|
|
case EC_FREEZE_COEFFICIENTS:
|
|
case EC_RESUME_COEFFICIENT_UPDATE:
|
|
case EC_RESET_COEFFICIENTS:
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities |
|
|
B1_FACILITY_EC), EC_COMMAND_1);
|
|
case EC_COMMAND_1:
|
|
if (adjust_b_process(Id, plci, Rc) != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Load EC failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
case EC_COMMAND_2:
|
|
if (plci->sig_req)
|
|
{
|
|
plci->internal_command = EC_COMMAND_2;
|
|
return;
|
|
}
|
|
plci->internal_command = EC_COMMAND_3;
|
|
ec_write_parameters(plci);
|
|
return;
|
|
case EC_COMMAND_3:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Enable EC failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case EC_DISABLE_OPERATION:
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
case EC_COMMAND_1:
|
|
if (plci->B1_facilities & B1_FACILITY_EC)
|
|
{
|
|
if (plci->sig_req)
|
|
{
|
|
plci->internal_command = EC_COMMAND_1;
|
|
return;
|
|
}
|
|
plci->internal_command = EC_COMMAND_2;
|
|
ec_write_parameters(plci);
|
|
return;
|
|
}
|
|
Rc = OK;
|
|
case EC_COMMAND_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Disable EC failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
adjust_b1_resource(Id, plci, NULL, (word)(plci->B1_facilities &
|
|
~B1_FACILITY_EC), EC_COMMAND_3);
|
|
case EC_COMMAND_3:
|
|
if (adjust_b_process(Id, plci, Rc) != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Unload EC failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
sendf(plci->appl, _FACILITY_R | CONFIRM, Id & 0xffffL, plci->number,
|
|
"wws", Info, (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
|
|
PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
|
|
}
|
|
|
|
|
|
static byte ec_request(dword Id, word Number, DIVA_CAPI_ADAPTER *a, PLCI *plci, APPL *appl, API_PARSE *msg)
|
|
{
|
|
word Info;
|
|
word opt;
|
|
API_PARSE ec_parms[3];
|
|
byte result[16];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: ec_request",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
Info = GOOD;
|
|
result[0] = 0;
|
|
if (!(a->man_profile.private_options & (1L << PRIVATE_ECHO_CANCELLER)))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Facility not supported",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _FACILITY_NOT_SUPPORTED;
|
|
}
|
|
else
|
|
{
|
|
if (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
|
|
{
|
|
if (api_parse(&msg[1].info[1], msg[1].length, "w", ec_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
else
|
|
{
|
|
if (plci == NULL)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_IDENTIFIER;
|
|
}
|
|
else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_STATE;
|
|
}
|
|
else
|
|
{
|
|
plci->command = 0;
|
|
plci->ec_cmd = GET_WORD(ec_parms[0].info);
|
|
plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
|
|
result[0] = 2;
|
|
PUT_WORD(&result[1], EC_SUCCESS);
|
|
if (msg[1].length >= 4)
|
|
{
|
|
opt = GET_WORD(&ec_parms[0].info[2]);
|
|
plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
|
|
LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
|
|
if (!(opt & EC_DISABLE_NON_LINEAR_PROCESSING))
|
|
plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
|
|
if (opt & EC_DETECT_DISABLE_TONE)
|
|
plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
|
|
if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
|
|
plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
|
|
if (msg[1].length >= 6)
|
|
{
|
|
plci->ec_tail_length = GET_WORD(&ec_parms[0].info[4]);
|
|
}
|
|
}
|
|
switch (plci->ec_cmd)
|
|
{
|
|
case EC_ENABLE_OPERATION:
|
|
plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
|
|
start_internal_command(Id, plci, ec_command);
|
|
return (false);
|
|
|
|
case EC_DISABLE_OPERATION:
|
|
plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
|
|
LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
|
|
LEC_RESET_COEFFICIENTS;
|
|
start_internal_command(Id, plci, ec_command);
|
|
return (false);
|
|
|
|
case EC_FREEZE_COEFFICIENTS:
|
|
plci->ec_idi_options |= LEC_FREEZE_COEFFICIENTS;
|
|
start_internal_command(Id, plci, ec_command);
|
|
return (false);
|
|
|
|
case EC_RESUME_COEFFICIENT_UPDATE:
|
|
plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
|
|
start_internal_command(Id, plci, ec_command);
|
|
return (false);
|
|
|
|
case EC_RESET_COEFFICIENTS:
|
|
plci->ec_idi_options |= LEC_RESET_COEFFICIENTS;
|
|
start_internal_command(Id, plci, ec_command);
|
|
return (false);
|
|
|
|
default:
|
|
dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
|
|
PUT_WORD(&result[1], EC_UNSUPPORTED_OPERATION);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (api_parse(&msg[1].info[1], msg[1].length, "ws", ec_parms))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong message format",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_MESSAGE_FORMAT;
|
|
}
|
|
else
|
|
{
|
|
if (GET_WORD(ec_parms[0].info) == EC_GET_SUPPORTED_SERVICES)
|
|
{
|
|
result[0] = 11;
|
|
PUT_WORD(&result[1], EC_GET_SUPPORTED_SERVICES);
|
|
result[3] = 8;
|
|
PUT_WORD(&result[4], GOOD);
|
|
PUT_WORD(&result[6], 0x0007);
|
|
PUT_WORD(&result[8], LEC_MAX_SUPPORTED_TAIL_LENGTH);
|
|
PUT_WORD(&result[10], 0);
|
|
}
|
|
else if (plci == NULL)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong PLCI",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_IDENTIFIER;
|
|
}
|
|
else if (!plci->State || !plci->NL.Id || plci->nl_remove_id)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Wrong state",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
Info = _WRONG_STATE;
|
|
}
|
|
else
|
|
{
|
|
plci->command = 0;
|
|
plci->ec_cmd = GET_WORD(ec_parms[0].info);
|
|
plci->ec_idi_options &= ~(LEC_MANUAL_DISABLE | LEC_RESET_COEFFICIENTS);
|
|
result[0] = 5;
|
|
PUT_WORD(&result[1], plci->ec_cmd);
|
|
result[3] = 2;
|
|
PUT_WORD(&result[4], GOOD);
|
|
plci->ec_idi_options &= ~(LEC_ENABLE_NONLINEAR_PROCESSING |
|
|
LEC_ENABLE_2100HZ_DETECTOR | LEC_REQUIRE_2100HZ_REVERSALS);
|
|
plci->ec_tail_length = 0;
|
|
if (ec_parms[1].length >= 2)
|
|
{
|
|
opt = GET_WORD(&ec_parms[1].info[1]);
|
|
if (opt & EC_ENABLE_NON_LINEAR_PROCESSING)
|
|
plci->ec_idi_options |= LEC_ENABLE_NONLINEAR_PROCESSING;
|
|
if (opt & EC_DETECT_DISABLE_TONE)
|
|
plci->ec_idi_options |= LEC_ENABLE_2100HZ_DETECTOR;
|
|
if (!(opt & EC_DO_NOT_REQUIRE_REVERSALS))
|
|
plci->ec_idi_options |= LEC_REQUIRE_2100HZ_REVERSALS;
|
|
if (ec_parms[1].length >= 4)
|
|
{
|
|
plci->ec_tail_length = GET_WORD(&ec_parms[1].info[3]);
|
|
}
|
|
}
|
|
switch (plci->ec_cmd)
|
|
{
|
|
case EC_ENABLE_OPERATION:
|
|
plci->ec_idi_options &= ~LEC_FREEZE_COEFFICIENTS;
|
|
start_internal_command(Id, plci, ec_command);
|
|
return (false);
|
|
|
|
case EC_DISABLE_OPERATION:
|
|
plci->ec_idi_options = LEC_ENABLE_ECHO_CANCELLER |
|
|
LEC_MANUAL_DISABLE | LEC_ENABLE_NONLINEAR_PROCESSING |
|
|
LEC_RESET_COEFFICIENTS;
|
|
start_internal_command(Id, plci, ec_command);
|
|
return (false);
|
|
|
|
default:
|
|
dbug(1, dprintf("[%06lx] %s,%d: EC unknown request %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, plci->ec_cmd));
|
|
PUT_WORD(&result[4], _FACILITY_SPECIFIC_FUNCTION_NOT_SUPP);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
sendf(appl, _FACILITY_R | CONFIRM, Id & 0xffffL, Number,
|
|
"wws", Info, (appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
|
|
PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
|
|
return (false);
|
|
}
|
|
|
|
|
|
static void ec_indication(dword Id, PLCI *plci, byte *msg, word length)
|
|
{
|
|
byte result[8];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: ec_indication",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
if (!(plci->ec_idi_options & LEC_MANUAL_DISABLE))
|
|
{
|
|
if (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC)
|
|
{
|
|
result[0] = 2;
|
|
PUT_WORD(&result[1], 0);
|
|
switch (msg[1])
|
|
{
|
|
case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
|
|
PUT_WORD(&result[1], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
|
|
break;
|
|
case LEC_DISABLE_TYPE_REVERSED_2100HZ:
|
|
PUT_WORD(&result[1], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
|
|
break;
|
|
case LEC_DISABLE_RELEASED:
|
|
PUT_WORD(&result[1], EC_BYPASS_RELEASED);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result[0] = 5;
|
|
PUT_WORD(&result[1], EC_BYPASS_INDICATION);
|
|
result[3] = 2;
|
|
PUT_WORD(&result[4], 0);
|
|
switch (msg[1])
|
|
{
|
|
case LEC_DISABLE_TYPE_CONTIGNUOUS_2100HZ:
|
|
PUT_WORD(&result[4], EC_BYPASS_DUE_TO_CONTINUOUS_2100HZ);
|
|
break;
|
|
case LEC_DISABLE_TYPE_REVERSED_2100HZ:
|
|
PUT_WORD(&result[4], EC_BYPASS_DUE_TO_REVERSED_2100HZ);
|
|
break;
|
|
case LEC_DISABLE_RELEASED:
|
|
PUT_WORD(&result[4], EC_BYPASS_RELEASED);
|
|
break;
|
|
}
|
|
}
|
|
sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", (plci->appl->appl_flags & APPL_FLAG_PRIV_EC_SPEC) ?
|
|
PRIV_SELECTOR_ECHO_CANCELLER : SELECTOR_ECHO_CANCELLER, result);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* Advanced voice */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static void adv_voice_write_coefs(PLCI *plci, word write_command)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word i;
|
|
byte *p;
|
|
|
|
word w, n, j, k;
|
|
byte ch_map[MIXER_CHANNELS_BRI];
|
|
|
|
byte coef_buffer[ADV_VOICE_COEF_BUFFER_SIZE + 2];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: adv_voice_write_coefs %d",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, write_command));
|
|
|
|
a = plci->adapter;
|
|
p = coef_buffer + 1;
|
|
*(p++) = DSP_CTRL_OLD_SET_MIXER_COEFFICIENTS;
|
|
i = 0;
|
|
while (i + sizeof(word) <= a->adv_voice_coef_length)
|
|
{
|
|
PUT_WORD(p, GET_WORD(a->adv_voice_coef_buffer + i));
|
|
p += 2;
|
|
i += 2;
|
|
}
|
|
while (i < ADV_VOICE_OLD_COEF_COUNT * sizeof(word))
|
|
{
|
|
PUT_WORD(p, 0x8000);
|
|
p += 2;
|
|
i += 2;
|
|
}
|
|
|
|
if (!a->li_pri && (plci->li_bchannel_id == 0))
|
|
{
|
|
if ((li_config_table[a->li_base].plci == NULL) && (li_config_table[a->li_base + 1].plci != NULL))
|
|
{
|
|
plci->li_bchannel_id = 1;
|
|
li_config_table[a->li_base].plci = plci;
|
|
dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, plci->li_bchannel_id));
|
|
}
|
|
else if ((li_config_table[a->li_base].plci != NULL) && (li_config_table[a->li_base + 1].plci == NULL))
|
|
{
|
|
plci->li_bchannel_id = 2;
|
|
li_config_table[a->li_base + 1].plci = plci;
|
|
dbug(1, dprintf("[%06lx] %s,%d: adv_voice_set_bchannel_id %d",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, plci->li_bchannel_id));
|
|
}
|
|
}
|
|
if (!a->li_pri && (plci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
|
|
{
|
|
i = a->li_base + (plci->li_bchannel_id - 1);
|
|
switch (write_command)
|
|
{
|
|
case ADV_VOICE_WRITE_ACTIVATION:
|
|
j = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
|
|
k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
|
|
if (!(plci->B1_facilities & B1_FACILITY_MIXER))
|
|
{
|
|
li_config_table[j].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
|
|
li_config_table[i].flag_table[j] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
|
|
}
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
|
|
{
|
|
li_config_table[k].flag_table[i] |= LI_FLAG_CONFERENCE | LI_FLAG_MIX;
|
|
li_config_table[i].flag_table[k] |= LI_FLAG_CONFERENCE | LI_FLAG_MONITOR;
|
|
li_config_table[k].flag_table[j] |= LI_FLAG_CONFERENCE;
|
|
li_config_table[j].flag_table[k] |= LI_FLAG_CONFERENCE;
|
|
}
|
|
mixer_calculate_coefs(a);
|
|
li_config_table[i].curchnl = li_config_table[i].channel;
|
|
li_config_table[j].curchnl = li_config_table[j].channel;
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
|
|
li_config_table[k].curchnl = li_config_table[k].channel;
|
|
break;
|
|
|
|
case ADV_VOICE_WRITE_DEACTIVATION:
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[i].flag_table[j] = 0;
|
|
li_config_table[j].flag_table[i] = 0;
|
|
}
|
|
k = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[k].flag_table[j] = 0;
|
|
li_config_table[j].flag_table[k] = 0;
|
|
}
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
|
|
{
|
|
k = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[k].flag_table[j] = 0;
|
|
li_config_table[j].flag_table[k] = 0;
|
|
}
|
|
}
|
|
mixer_calculate_coefs(a);
|
|
break;
|
|
}
|
|
if (plci->B1_facilities & B1_FACILITY_MIXER)
|
|
{
|
|
w = 0;
|
|
if (ADV_VOICE_NEW_COEF_BASE + sizeof(word) <= a->adv_voice_coef_length)
|
|
w = GET_WORD(a->adv_voice_coef_buffer + ADV_VOICE_NEW_COEF_BASE);
|
|
if (li_config_table[i].channel & LI_CHANNEL_TX_DATA)
|
|
w |= MIXER_FEATURE_ENABLE_TX_DATA;
|
|
if (li_config_table[i].channel & LI_CHANNEL_RX_DATA)
|
|
w |= MIXER_FEATURE_ENABLE_RX_DATA;
|
|
*(p++) = (byte) w;
|
|
*(p++) = (byte)(w >> 8);
|
|
for (j = 0; j < sizeof(ch_map); j += 2)
|
|
{
|
|
ch_map[j] = (byte)(j + (plci->li_bchannel_id - 1));
|
|
ch_map[j + 1] = (byte)(j + (2 - plci->li_bchannel_id));
|
|
}
|
|
for (n = 0; n < ARRAY_SIZE(mixer_write_prog_bri); n++)
|
|
{
|
|
i = a->li_base + ch_map[mixer_write_prog_bri[n].to_ch];
|
|
j = a->li_base + ch_map[mixer_write_prog_bri[n].from_ch];
|
|
if (li_config_table[i].channel & li_config_table[j].channel & LI_CHANNEL_INVOLVED)
|
|
{
|
|
*(p++) = ((li_config_table[i].coef_table[j] & mixer_write_prog_bri[n].mask) ? 0x80 : 0x01);
|
|
w = ((li_config_table[i].coef_table[j] & 0xf) ^ (li_config_table[i].coef_table[j] >> 4));
|
|
li_config_table[i].coef_table[j] ^= (w & mixer_write_prog_bri[n].mask) << 4;
|
|
}
|
|
else
|
|
{
|
|
*(p++) = (ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n < a->adv_voice_coef_length) ?
|
|
a->adv_voice_coef_buffer[ADV_VOICE_NEW_COEF_BASE + sizeof(word) + n] : 0x00;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
|
|
*(p++) = a->adv_voice_coef_buffer[i];
|
|
}
|
|
}
|
|
else
|
|
|
|
{
|
|
for (i = ADV_VOICE_NEW_COEF_BASE; i < a->adv_voice_coef_length; i++)
|
|
*(p++) = a->adv_voice_coef_buffer[i];
|
|
}
|
|
coef_buffer[0] = (p - coef_buffer) - 1;
|
|
add_p(plci, FTY, coef_buffer);
|
|
sig_req(plci, TEL_CTRL, 0);
|
|
send_req(plci);
|
|
}
|
|
|
|
|
|
static void adv_voice_clear_config(PLCI *plci)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
|
|
word i, j;
|
|
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: adv_voice_clear_config",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
a = plci->adapter;
|
|
if ((plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
|
|
{
|
|
a->adv_voice_coef_length = 0;
|
|
|
|
if (!a->li_pri && (plci->li_bchannel_id != 0)
|
|
&& (li_config_table[a->li_base + (plci->li_bchannel_id - 1)].plci == plci))
|
|
{
|
|
i = a->li_base + (plci->li_bchannel_id - 1);
|
|
li_config_table[i].curchnl = 0;
|
|
li_config_table[i].channel = 0;
|
|
li_config_table[i].chflags = 0;
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[i].flag_table[j] = 0;
|
|
li_config_table[j].flag_table[i] = 0;
|
|
li_config_table[i].coef_table[j] = 0;
|
|
li_config_table[j].coef_table[i] = 0;
|
|
}
|
|
li_config_table[i].coef_table[i] |= LI_COEF_CH_PC_SET | LI_COEF_PC_CH_SET;
|
|
i = a->li_base + MIXER_IC_CHANNEL_BASE + (plci->li_bchannel_id - 1);
|
|
li_config_table[i].curchnl = 0;
|
|
li_config_table[i].channel = 0;
|
|
li_config_table[i].chflags = 0;
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[i].flag_table[j] = 0;
|
|
li_config_table[j].flag_table[i] = 0;
|
|
li_config_table[i].coef_table[j] = 0;
|
|
li_config_table[j].coef_table[i] = 0;
|
|
}
|
|
if (a->manufacturer_features & MANUFACTURER_FEATURE_SLAVE_CODEC)
|
|
{
|
|
i = a->li_base + MIXER_IC_CHANNEL_BASE + (2 - plci->li_bchannel_id);
|
|
li_config_table[i].curchnl = 0;
|
|
li_config_table[i].channel = 0;
|
|
li_config_table[i].chflags = 0;
|
|
for (j = 0; j < li_total_channels; j++)
|
|
{
|
|
li_config_table[i].flag_table[j] = 0;
|
|
li_config_table[j].flag_table[i] = 0;
|
|
li_config_table[i].coef_table[j] = 0;
|
|
li_config_table[j].coef_table[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
static void adv_voice_prepare_switch(dword Id, PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: adv_voice_prepare_switch",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
|
|
}
|
|
|
|
|
|
static word adv_voice_save_config(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: adv_voice_save_config %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
return (GOOD);
|
|
}
|
|
|
|
|
|
static word adv_voice_restore_config(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word Info;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: adv_voice_restore_config %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
Info = GOOD;
|
|
a = plci->adapter;
|
|
if ((plci->B1_facilities & B1_FACILITY_VOICE)
|
|
&& (plci->tel == ADV_VOICE) && (plci == a->AdvSignalPLCI))
|
|
{
|
|
switch (plci->adjust_b_state)
|
|
{
|
|
case ADJUST_B_RESTORE_VOICE_1:
|
|
plci->internal_command = plci->adjust_b_command;
|
|
if (plci->sig_req)
|
|
{
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
|
|
break;
|
|
}
|
|
adv_voice_write_coefs(plci, ADV_VOICE_WRITE_UPDATE);
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_2;
|
|
break;
|
|
case ADJUST_B_RESTORE_VOICE_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Restore voice config failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return (Info);
|
|
}
|
|
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
/* B1 resource switching */
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static byte b1_facilities_table[] =
|
|
{
|
|
0x00, /* 0 No bchannel resources */
|
|
0x00, /* 1 Codec (automatic law) */
|
|
0x00, /* 2 Codec (A-law) */
|
|
0x00, /* 3 Codec (y-law) */
|
|
0x00, /* 4 HDLC for X.21 */
|
|
0x00, /* 5 HDLC */
|
|
0x00, /* 6 External Device 0 */
|
|
0x00, /* 7 External Device 1 */
|
|
0x00, /* 8 HDLC 56k */
|
|
0x00, /* 9 Transparent */
|
|
0x00, /* 10 Loopback to network */
|
|
0x00, /* 11 Test pattern to net */
|
|
0x00, /* 12 Rate adaptation sync */
|
|
0x00, /* 13 Rate adaptation async */
|
|
0x00, /* 14 R-Interface */
|
|
0x00, /* 15 HDLC 128k leased line */
|
|
0x00, /* 16 FAX */
|
|
0x00, /* 17 Modem async */
|
|
0x00, /* 18 Modem sync HDLC */
|
|
0x00, /* 19 V.110 async HDLC */
|
|
0x12, /* 20 Adv voice (Trans,mixer) */
|
|
0x00, /* 21 Codec connected to IC */
|
|
0x0c, /* 22 Trans,DTMF */
|
|
0x1e, /* 23 Trans,DTMF+mixer */
|
|
0x1f, /* 24 Trans,DTMF+mixer+local */
|
|
0x13, /* 25 Trans,mixer+local */
|
|
0x12, /* 26 HDLC,mixer */
|
|
0x12, /* 27 HDLC 56k,mixer */
|
|
0x2c, /* 28 Trans,LEC+DTMF */
|
|
0x3e, /* 29 Trans,LEC+DTMF+mixer */
|
|
0x3f, /* 30 Trans,LEC+DTMF+mixer+local */
|
|
0x2c, /* 31 RTP,LEC+DTMF */
|
|
0x3e, /* 32 RTP,LEC+DTMF+mixer */
|
|
0x3f, /* 33 RTP,LEC+DTMF+mixer+local */
|
|
0x00, /* 34 Signaling task */
|
|
0x00, /* 35 PIAFS */
|
|
0x0c, /* 36 Trans,DTMF+TONE */
|
|
0x1e, /* 37 Trans,DTMF+TONE+mixer */
|
|
0x1f /* 38 Trans,DTMF+TONE+mixer+local*/
|
|
};
|
|
|
|
|
|
static word get_b1_facilities(PLCI *plci, byte b1_resource)
|
|
{
|
|
word b1_facilities;
|
|
|
|
b1_facilities = b1_facilities_table[b1_resource];
|
|
if ((b1_resource == 9) || (b1_resource == 20) || (b1_resource == 25))
|
|
{
|
|
|
|
if (!(((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
|
|
|| (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE)))))
|
|
|
|
{
|
|
if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND)
|
|
b1_facilities |= B1_FACILITY_DTMFX;
|
|
if (plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)
|
|
b1_facilities |= B1_FACILITY_DTMFR;
|
|
}
|
|
}
|
|
if ((b1_resource == 17) || (b1_resource == 18))
|
|
{
|
|
if (plci->adapter->manufacturer_features & (MANUFACTURER_FEATURE_V18 | MANUFACTURER_FEATURE_VOWN))
|
|
b1_facilities |= B1_FACILITY_DTMFX | B1_FACILITY_DTMFR;
|
|
}
|
|
/*
|
|
dbug (1, dprintf("[%06lx] %s,%d: get_b1_facilities %d %04x",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char far *)(FILE_), __LINE__, b1_resource, b1_facilites));
|
|
*/
|
|
return (b1_facilities);
|
|
}
|
|
|
|
|
|
static byte add_b1_facilities(PLCI *plci, byte b1_resource, word b1_facilities)
|
|
{
|
|
byte b;
|
|
|
|
switch (b1_resource)
|
|
{
|
|
case 5:
|
|
case 26:
|
|
if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
|
|
b = 26;
|
|
else
|
|
b = 5;
|
|
break;
|
|
|
|
case 8:
|
|
case 27:
|
|
if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
|
|
b = 27;
|
|
else
|
|
b = 8;
|
|
break;
|
|
|
|
case 9:
|
|
case 20:
|
|
case 22:
|
|
case 23:
|
|
case 24:
|
|
case 25:
|
|
case 28:
|
|
case 29:
|
|
case 30:
|
|
case 36:
|
|
case 37:
|
|
case 38:
|
|
if (b1_facilities & B1_FACILITY_EC)
|
|
{
|
|
if (b1_facilities & B1_FACILITY_LOCAL)
|
|
b = 30;
|
|
else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
|
|
b = 29;
|
|
else
|
|
b = 28;
|
|
}
|
|
|
|
else if ((b1_facilities & (B1_FACILITY_DTMFX | B1_FACILITY_DTMFR | B1_FACILITY_MIXER))
|
|
&& (((plci->requested_options_conn | plci->requested_options) & (1L << PRIVATE_DTMF_TONE))
|
|
|| (plci->appl && (plci->adapter->requested_options_table[plci->appl->Id - 1] & (1L << PRIVATE_DTMF_TONE)))))
|
|
{
|
|
if (b1_facilities & B1_FACILITY_LOCAL)
|
|
b = 38;
|
|
else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
|
|
b = 37;
|
|
else
|
|
b = 36;
|
|
}
|
|
|
|
else if (((plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_HARDDTMF)
|
|
&& !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE))
|
|
|| ((b1_facilities & B1_FACILITY_DTMFR)
|
|
&& ((b1_facilities & B1_FACILITY_MIXER)
|
|
|| !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_RECEIVE)))
|
|
|| ((b1_facilities & B1_FACILITY_DTMFX)
|
|
&& ((b1_facilities & B1_FACILITY_MIXER)
|
|
|| !(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_SOFTDTMF_SEND))))
|
|
{
|
|
if (b1_facilities & B1_FACILITY_LOCAL)
|
|
b = 24;
|
|
else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
|
|
b = 23;
|
|
else
|
|
b = 22;
|
|
}
|
|
else
|
|
{
|
|
if (b1_facilities & B1_FACILITY_LOCAL)
|
|
b = 25;
|
|
else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
|
|
b = 20;
|
|
else
|
|
b = 9;
|
|
}
|
|
break;
|
|
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
if (b1_facilities & B1_FACILITY_LOCAL)
|
|
b = 33;
|
|
else if (b1_facilities & (B1_FACILITY_MIXER | B1_FACILITY_VOICE))
|
|
b = 32;
|
|
else
|
|
b = 31;
|
|
break;
|
|
|
|
default:
|
|
b = b1_resource;
|
|
}
|
|
dbug(1, dprintf("[%06lx] %s,%d: add_b1_facilities %d %04x %d %04x",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__,
|
|
b1_resource, b1_facilities, b, get_b1_facilities(plci, b)));
|
|
return (b);
|
|
}
|
|
|
|
|
|
static void adjust_b1_facilities(PLCI *plci, byte new_b1_resource, word new_b1_facilities)
|
|
{
|
|
word removed_facilities;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_facilities %d %04x %04x",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__, new_b1_resource, new_b1_facilities,
|
|
new_b1_facilities & get_b1_facilities(plci, new_b1_resource)));
|
|
|
|
new_b1_facilities &= get_b1_facilities(plci, new_b1_resource);
|
|
removed_facilities = plci->B1_facilities & ~new_b1_facilities;
|
|
|
|
if (removed_facilities & B1_FACILITY_EC)
|
|
ec_clear_config(plci);
|
|
|
|
|
|
if (removed_facilities & B1_FACILITY_DTMFR)
|
|
{
|
|
dtmf_rec_clear_config(plci);
|
|
dtmf_parameter_clear_config(plci);
|
|
}
|
|
if (removed_facilities & B1_FACILITY_DTMFX)
|
|
dtmf_send_clear_config(plci);
|
|
|
|
|
|
if (removed_facilities & B1_FACILITY_MIXER)
|
|
mixer_clear_config(plci);
|
|
|
|
if (removed_facilities & B1_FACILITY_VOICE)
|
|
adv_voice_clear_config(plci);
|
|
plci->B1_facilities = new_b1_facilities;
|
|
}
|
|
|
|
|
|
static void adjust_b_clear(PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: adjust_b_clear",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
plci->adjust_b_restore = false;
|
|
}
|
|
|
|
|
|
static word adjust_b_process(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word Info;
|
|
byte b1_resource;
|
|
NCCI *ncci_ptr;
|
|
API_PARSE bp[2];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: adjust_b_process %02x %d",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->adjust_b_state));
|
|
|
|
Info = GOOD;
|
|
switch (plci->adjust_b_state)
|
|
{
|
|
case ADJUST_B_START:
|
|
if ((plci->adjust_b_parms_msg == NULL)
|
|
&& (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
|
|
&& ((plci->adjust_b_mode & ~(ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 |
|
|
ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_RESTORE)) == 0))
|
|
{
|
|
b1_resource = (plci->adjust_b_mode == ADJUST_B_MODE_NO_RESOURCE) ?
|
|
0 : add_b1_facilities(plci, plci->B1_resource, plci->adjust_b_facilities);
|
|
if (b1_resource == plci->B1_resource)
|
|
{
|
|
adjust_b1_facilities(plci, b1_resource, plci->adjust_b_facilities);
|
|
break;
|
|
}
|
|
if (plci->adjust_b_facilities & ~get_b1_facilities(plci, b1_resource))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B nonsupported facilities %d %d %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__,
|
|
plci->B1_resource, b1_resource, plci->adjust_b_facilities));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
}
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
|
|
{
|
|
|
|
mixer_prepare_switch(Id, plci);
|
|
|
|
|
|
dtmf_prepare_switch(Id, plci);
|
|
dtmf_parameter_prepare_switch(Id, plci);
|
|
|
|
|
|
ec_prepare_switch(Id, plci);
|
|
|
|
adv_voice_prepare_switch(Id, plci);
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_SAVE_MIXER_1;
|
|
Rc = OK;
|
|
case ADJUST_B_SAVE_MIXER_1:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
|
|
{
|
|
|
|
Info = mixer_save_config(Id, plci, Rc);
|
|
if ((Info != GOOD) || plci->internal_command)
|
|
break;
|
|
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_SAVE_DTMF_1;
|
|
Rc = OK;
|
|
case ADJUST_B_SAVE_DTMF_1:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
|
|
{
|
|
|
|
Info = dtmf_save_config(Id, plci, Rc);
|
|
if ((Info != GOOD) || plci->internal_command)
|
|
break;
|
|
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_REMOVE_L23_1;
|
|
case ADJUST_B_REMOVE_L23_1:
|
|
if ((plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
|
|
&& plci->NL.Id && !plci->nl_remove_id)
|
|
{
|
|
plci->internal_command = plci->adjust_b_command;
|
|
if (plci->adjust_b_ncci != 0)
|
|
{
|
|
ncci_ptr = &(plci->adapter->ncci[plci->adjust_b_ncci]);
|
|
while (ncci_ptr->data_pending)
|
|
{
|
|
plci->data_sent_ptr = ncci_ptr->DBuffer[ncci_ptr->data_out].P;
|
|
data_rc(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
|
|
}
|
|
while (ncci_ptr->data_ack_pending)
|
|
data_ack(plci, plci->adapter->ncci_ch[plci->adjust_b_ncci]);
|
|
}
|
|
nl_req_ncci(plci, REMOVE,
|
|
(byte)((plci->adjust_b_mode & ADJUST_B_MODE_CONNECT) ? plci->adjust_b_ncci : 0));
|
|
send_req(plci);
|
|
plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
|
|
break;
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_REMOVE_L23_2;
|
|
Rc = OK;
|
|
case ADJUST_B_REMOVE_L23_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B remove failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_REMOVE_L23)
|
|
{
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = plci->adjust_b_command;
|
|
break;
|
|
}
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_SAVE_EC_1;
|
|
Rc = OK;
|
|
case ADJUST_B_SAVE_EC_1:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
|
|
{
|
|
|
|
Info = ec_save_config(Id, plci, Rc);
|
|
if ((Info != GOOD) || plci->internal_command)
|
|
break;
|
|
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_SAVE_DTMF_PARAMETER_1;
|
|
Rc = OK;
|
|
case ADJUST_B_SAVE_DTMF_PARAMETER_1:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
|
|
{
|
|
|
|
Info = dtmf_parameter_save_config(Id, plci, Rc);
|
|
if ((Info != GOOD) || plci->internal_command)
|
|
break;
|
|
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_SAVE_VOICE_1;
|
|
Rc = OK;
|
|
case ADJUST_B_SAVE_VOICE_1:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_SAVE)
|
|
{
|
|
Info = adv_voice_save_config(Id, plci, Rc);
|
|
if ((Info != GOOD) || plci->internal_command)
|
|
break;
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_SWITCH_L1_1;
|
|
case ADJUST_B_SWITCH_L1_1:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_SWITCH_L1)
|
|
{
|
|
if (plci->sig_req)
|
|
{
|
|
plci->internal_command = plci->adjust_b_command;
|
|
break;
|
|
}
|
|
if (plci->adjust_b_parms_msg != NULL)
|
|
api_load_msg(plci->adjust_b_parms_msg, bp);
|
|
else
|
|
api_load_msg(&plci->B_protocol, bp);
|
|
Info = add_b1(plci, bp,
|
|
(word)((plci->adjust_b_mode & ADJUST_B_MODE_NO_RESOURCE) ? 2 : 0),
|
|
plci->adjust_b_facilities);
|
|
if (Info != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L1 parameters %d %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__,
|
|
plci->B1_resource, plci->adjust_b_facilities));
|
|
break;
|
|
}
|
|
plci->internal_command = plci->adjust_b_command;
|
|
sig_req(plci, RESOURCES, 0);
|
|
send_req(plci);
|
|
plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
|
|
break;
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_SWITCH_L1_2;
|
|
Rc = OK;
|
|
case ADJUST_B_SWITCH_L1_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B switch failed %02x %d %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__,
|
|
Rc, plci->B1_resource, plci->adjust_b_facilities));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_VOICE_1;
|
|
Rc = OK;
|
|
case ADJUST_B_RESTORE_VOICE_1:
|
|
case ADJUST_B_RESTORE_VOICE_2:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
|
|
{
|
|
Info = adv_voice_restore_config(Id, plci, Rc);
|
|
if ((Info != GOOD) || plci->internal_command)
|
|
break;
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_PARAMETER_1;
|
|
Rc = OK;
|
|
case ADJUST_B_RESTORE_DTMF_PARAMETER_1:
|
|
case ADJUST_B_RESTORE_DTMF_PARAMETER_2:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
|
|
{
|
|
|
|
Info = dtmf_parameter_restore_config(Id, plci, Rc);
|
|
if ((Info != GOOD) || plci->internal_command)
|
|
break;
|
|
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_EC_1;
|
|
Rc = OK;
|
|
case ADJUST_B_RESTORE_EC_1:
|
|
case ADJUST_B_RESTORE_EC_2:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
|
|
{
|
|
|
|
Info = ec_restore_config(Id, plci, Rc);
|
|
if ((Info != GOOD) || plci->internal_command)
|
|
break;
|
|
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_ASSIGN_L23_1;
|
|
case ADJUST_B_ASSIGN_L23_1:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
|
|
{
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = plci->adjust_b_command;
|
|
break;
|
|
}
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
|
|
plci->call_dir |= CALL_DIR_FORCE_OUTG_NL;
|
|
if (plci->adjust_b_parms_msg != NULL)
|
|
api_load_msg(plci->adjust_b_parms_msg, bp);
|
|
else
|
|
api_load_msg(&plci->B_protocol, bp);
|
|
Info = add_b23(plci, bp);
|
|
if (Info != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B invalid L23 parameters %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Info));
|
|
break;
|
|
}
|
|
plci->internal_command = plci->adjust_b_command;
|
|
nl_req_ncci(plci, ASSIGN, 0);
|
|
send_req(plci);
|
|
plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
|
|
break;
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_ASSIGN_L23_2;
|
|
Rc = ASSIGN_OK;
|
|
case ADJUST_B_ASSIGN_L23_2:
|
|
if ((Rc != OK) && (Rc != OK_FC) && (Rc != ASSIGN_OK))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B assign failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_ASSIGN_L23)
|
|
{
|
|
if (Rc != ASSIGN_OK)
|
|
{
|
|
plci->internal_command = plci->adjust_b_command;
|
|
break;
|
|
}
|
|
}
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_USER_CONNECT)
|
|
{
|
|
plci->adjust_b_restore = true;
|
|
break;
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_CONNECT_1;
|
|
case ADJUST_B_CONNECT_1:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
|
|
{
|
|
plci->internal_command = plci->adjust_b_command;
|
|
if (plci_nl_busy(plci))
|
|
break;
|
|
nl_req_ncci(plci, N_CONNECT, 0);
|
|
send_req(plci);
|
|
plci->adjust_b_state = ADJUST_B_CONNECT_2;
|
|
break;
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
|
|
Rc = OK;
|
|
case ADJUST_B_CONNECT_2:
|
|
case ADJUST_B_CONNECT_3:
|
|
case ADJUST_B_CONNECT_4:
|
|
if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B connect failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
if (Rc == OK)
|
|
{
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_CONNECT)
|
|
{
|
|
get_ncci(plci, (byte)(Id >> 16), plci->adjust_b_ncci);
|
|
Id = (Id & 0xffff) | (((dword)(plci->adjust_b_ncci)) << 16);
|
|
}
|
|
if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
|
|
plci->adjust_b_state = ADJUST_B_CONNECT_3;
|
|
else if (plci->adjust_b_state == ADJUST_B_CONNECT_4)
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
|
|
}
|
|
else if (Rc == 0)
|
|
{
|
|
if (plci->adjust_b_state == ADJUST_B_CONNECT_2)
|
|
plci->adjust_b_state = ADJUST_B_CONNECT_4;
|
|
else if (plci->adjust_b_state == ADJUST_B_CONNECT_3)
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_DTMF_1;
|
|
}
|
|
if (plci->adjust_b_state != ADJUST_B_RESTORE_DTMF_1)
|
|
{
|
|
plci->internal_command = plci->adjust_b_command;
|
|
break;
|
|
}
|
|
Rc = OK;
|
|
case ADJUST_B_RESTORE_DTMF_1:
|
|
case ADJUST_B_RESTORE_DTMF_2:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
|
|
{
|
|
|
|
Info = dtmf_restore_config(Id, plci, Rc);
|
|
if ((Info != GOOD) || plci->internal_command)
|
|
break;
|
|
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_RESTORE_MIXER_1;
|
|
Rc = OK;
|
|
case ADJUST_B_RESTORE_MIXER_1:
|
|
case ADJUST_B_RESTORE_MIXER_2:
|
|
case ADJUST_B_RESTORE_MIXER_3:
|
|
case ADJUST_B_RESTORE_MIXER_4:
|
|
case ADJUST_B_RESTORE_MIXER_5:
|
|
case ADJUST_B_RESTORE_MIXER_6:
|
|
case ADJUST_B_RESTORE_MIXER_7:
|
|
if (plci->adjust_b_mode & ADJUST_B_MODE_RESTORE)
|
|
{
|
|
|
|
Info = mixer_restore_config(Id, plci, Rc);
|
|
if ((Info != GOOD) || plci->internal_command)
|
|
break;
|
|
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_END;
|
|
case ADJUST_B_END:
|
|
break;
|
|
}
|
|
return (Info);
|
|
}
|
|
|
|
|
|
static void adjust_b1_resource(dword Id, PLCI *plci, API_SAVE *bp_msg, word b1_facilities, word internal_command)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: adjust_b1_resource %d %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__,
|
|
plci->B1_resource, b1_facilities));
|
|
|
|
plci->adjust_b_parms_msg = bp_msg;
|
|
plci->adjust_b_facilities = b1_facilities;
|
|
plci->adjust_b_command = internal_command;
|
|
plci->adjust_b_ncci = (word)(Id >> 16);
|
|
if ((bp_msg == NULL) && (plci->B1_resource == 0))
|
|
plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_NO_RESOURCE | ADJUST_B_MODE_SWITCH_L1;
|
|
else
|
|
plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_SWITCH_L1 | ADJUST_B_MODE_RESTORE;
|
|
plci->adjust_b_state = ADJUST_B_START;
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B1 resource %d %04x...",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__,
|
|
plci->B1_resource, b1_facilities));
|
|
}
|
|
|
|
|
|
static void adjust_b_restore(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: adjust_b_restore %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
if (plci->req_in != 0)
|
|
{
|
|
plci->internal_command = ADJUST_B_RESTORE_1;
|
|
break;
|
|
}
|
|
Rc = OK;
|
|
case ADJUST_B_RESTORE_1:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B enqueued failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
}
|
|
plci->adjust_b_parms_msg = NULL;
|
|
plci->adjust_b_facilities = plci->B1_facilities;
|
|
plci->adjust_b_command = ADJUST_B_RESTORE_2;
|
|
plci->adjust_b_ncci = (word)(Id >> 16);
|
|
plci->adjust_b_mode = ADJUST_B_MODE_RESTORE;
|
|
plci->adjust_b_state = ADJUST_B_START;
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore...",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
case ADJUST_B_RESTORE_2:
|
|
if (adjust_b_process(Id, plci, Rc) != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Adjust B restore failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
}
|
|
if (plci->internal_command)
|
|
break;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void reset_b3_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word Info;
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: reset_b3_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
Info = GOOD;
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
plci->adjust_b_parms_msg = NULL;
|
|
plci->adjust_b_facilities = plci->B1_facilities;
|
|
plci->adjust_b_command = RESET_B3_COMMAND_1;
|
|
plci->adjust_b_ncci = (word)(Id >> 16);
|
|
plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_CONNECT;
|
|
plci->adjust_b_state = ADJUST_B_START;
|
|
dbug(1, dprintf("[%06lx] %s,%d: Reset B3...",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
case RESET_B3_COMMAND_1:
|
|
Info = adjust_b_process(Id, plci, Rc);
|
|
if (Info != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Reset failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
break;
|
|
}
|
|
/* sendf (plci->appl, _RESET_B3_R | CONFIRM, Id, plci->number, "w", Info);*/
|
|
sendf(plci->appl, _RESET_B3_I, Id, 0, "s", "");
|
|
}
|
|
|
|
|
|
static void select_b_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word Info;
|
|
word internal_command;
|
|
byte esc_chi[3];
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: select_b_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
Info = GOOD;
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
plci->adjust_b_parms_msg = &plci->saved_msg;
|
|
if ((plci->tel == ADV_VOICE) && (plci == plci->adapter->AdvSignalPLCI))
|
|
plci->adjust_b_facilities = plci->B1_facilities | B1_FACILITY_VOICE;
|
|
else
|
|
plci->adjust_b_facilities = plci->B1_facilities & ~B1_FACILITY_VOICE;
|
|
plci->adjust_b_command = SELECT_B_COMMAND_1;
|
|
plci->adjust_b_ncci = (word)(Id >> 16);
|
|
if (plci->saved_msg.parms[0].length == 0)
|
|
{
|
|
plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
|
|
ADJUST_B_MODE_NO_RESOURCE;
|
|
}
|
|
else
|
|
{
|
|
plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_SWITCH_L1 |
|
|
ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
|
|
}
|
|
plci->adjust_b_state = ADJUST_B_START;
|
|
dbug(1, dprintf("[%06lx] %s,%d: Select B protocol...",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
case SELECT_B_COMMAND_1:
|
|
Info = adjust_b_process(Id, plci, Rc);
|
|
if (Info != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: Select B protocol failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
if (plci->tel == ADV_VOICE)
|
|
{
|
|
esc_chi[0] = 0x02;
|
|
esc_chi[1] = 0x18;
|
|
esc_chi[2] = plci->b_channel;
|
|
SetVoiceChannel(plci->adapter->AdvCodecPLCI, esc_chi, plci->adapter);
|
|
}
|
|
break;
|
|
}
|
|
sendf(plci->appl, _SELECT_B_REQ | CONFIRM, Id, plci->number, "w", Info);
|
|
}
|
|
|
|
|
|
static void fax_connect_ack_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: fax_connect_ack_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
case FAX_CONNECT_ACK_COMMAND_1:
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = FAX_CONNECT_ACK_COMMAND_1;
|
|
return;
|
|
}
|
|
plci->internal_command = FAX_CONNECT_ACK_COMMAND_2;
|
|
plci->NData[0].P = plci->fax_connect_info_buffer;
|
|
plci->NData[0].PLength = plci->fax_connect_info_length;
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.ReqCh = 0;
|
|
plci->NL.Req = plci->nl_req = (byte) N_CONNECT_ACK;
|
|
plci->adapter->request(&plci->NL);
|
|
return;
|
|
case FAX_CONNECT_ACK_COMMAND_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: FAX issue CONNECT ACK failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
break;
|
|
}
|
|
}
|
|
if ((plci->ncpi_state & NCPI_VALID_CONNECT_B3_ACT)
|
|
&& !(plci->ncpi_state & NCPI_CONNECT_B3_ACT_SENT))
|
|
{
|
|
if (plci->B3_prot == 4)
|
|
sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
|
|
else
|
|
sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "S", plci->ncpi_buffer);
|
|
plci->ncpi_state |= NCPI_CONNECT_B3_ACT_SENT;
|
|
}
|
|
}
|
|
|
|
|
|
static void fax_edata_ack_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: fax_edata_ack_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
case FAX_EDATA_ACK_COMMAND_1:
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = FAX_EDATA_ACK_COMMAND_1;
|
|
return;
|
|
}
|
|
plci->internal_command = FAX_EDATA_ACK_COMMAND_2;
|
|
plci->NData[0].P = plci->fax_connect_info_buffer;
|
|
plci->NData[0].PLength = plci->fax_edata_ack_length;
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.ReqCh = 0;
|
|
plci->NL.Req = plci->nl_req = (byte) N_EDATA;
|
|
plci->adapter->request(&plci->NL);
|
|
return;
|
|
case FAX_EDATA_ACK_COMMAND_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: FAX issue EDATA ACK failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void fax_connect_info_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word Info;
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: fax_connect_info_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
Info = GOOD;
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
case FAX_CONNECT_INFO_COMMAND_1:
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = FAX_CONNECT_INFO_COMMAND_1;
|
|
return;
|
|
}
|
|
plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
|
|
plci->NData[0].P = plci->fax_connect_info_buffer;
|
|
plci->NData[0].PLength = plci->fax_connect_info_length;
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.ReqCh = 0;
|
|
plci->NL.Req = plci->nl_req = (byte) N_EDATA;
|
|
plci->adapter->request(&plci->NL);
|
|
return;
|
|
case FAX_CONNECT_INFO_COMMAND_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: FAX setting connect info failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = FAX_CONNECT_INFO_COMMAND_2;
|
|
return;
|
|
}
|
|
plci->command = _CONNECT_B3_R;
|
|
nl_req_ncci(plci, N_CONNECT, 0);
|
|
send_req(plci);
|
|
return;
|
|
}
|
|
sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
|
|
}
|
|
|
|
|
|
static void fax_adjust_b23_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word Info;
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: fax_adjust_b23_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
Info = GOOD;
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
plci->adjust_b_parms_msg = NULL;
|
|
plci->adjust_b_facilities = plci->B1_facilities;
|
|
plci->adjust_b_command = FAX_ADJUST_B23_COMMAND_1;
|
|
plci->adjust_b_ncci = (word)(Id >> 16);
|
|
plci->adjust_b_mode = ADJUST_B_MODE_REMOVE_L23 | ADJUST_B_MODE_ASSIGN_L23;
|
|
plci->adjust_b_state = ADJUST_B_START;
|
|
dbug(1, dprintf("[%06lx] %s,%d: FAX adjust B23...",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
case FAX_ADJUST_B23_COMMAND_1:
|
|
Info = adjust_b_process(Id, plci, Rc);
|
|
if (Info != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: FAX adjust failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
case FAX_ADJUST_B23_COMMAND_2:
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = FAX_ADJUST_B23_COMMAND_2;
|
|
return;
|
|
}
|
|
plci->command = _CONNECT_B3_R;
|
|
nl_req_ncci(plci, N_CONNECT, 0);
|
|
send_req(plci);
|
|
return;
|
|
}
|
|
sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
|
|
}
|
|
|
|
|
|
static void fax_disconnect_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: fax_disconnect_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
plci->internal_command = FAX_DISCONNECT_COMMAND_1;
|
|
return;
|
|
case FAX_DISCONNECT_COMMAND_1:
|
|
case FAX_DISCONNECT_COMMAND_2:
|
|
case FAX_DISCONNECT_COMMAND_3:
|
|
if ((Rc != OK) && (Rc != OK_FC) && (Rc != 0))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: FAX disconnect EDATA failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
break;
|
|
}
|
|
if (Rc == OK)
|
|
{
|
|
if ((internal_command == FAX_DISCONNECT_COMMAND_1)
|
|
|| (internal_command == FAX_DISCONNECT_COMMAND_2))
|
|
{
|
|
plci->internal_command = FAX_DISCONNECT_COMMAND_2;
|
|
}
|
|
}
|
|
else if (Rc == 0)
|
|
{
|
|
if (internal_command == FAX_DISCONNECT_COMMAND_1)
|
|
plci->internal_command = FAX_DISCONNECT_COMMAND_3;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void rtp_connect_b3_req_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word Info;
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_req_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
Info = GOOD;
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
case RTP_CONNECT_B3_REQ_COMMAND_1:
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_1;
|
|
return;
|
|
}
|
|
plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
|
|
nl_req_ncci(plci, N_CONNECT, 0);
|
|
send_req(plci);
|
|
return;
|
|
case RTP_CONNECT_B3_REQ_COMMAND_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect info failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
Info = _WRONG_STATE;
|
|
break;
|
|
}
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_2;
|
|
return;
|
|
}
|
|
plci->internal_command = RTP_CONNECT_B3_REQ_COMMAND_3;
|
|
plci->NData[0].PLength = plci->internal_req_buffer[0];
|
|
plci->NData[0].P = plci->internal_req_buffer + 1;
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.ReqCh = 0;
|
|
plci->NL.Req = plci->nl_req = (byte) N_UDATA;
|
|
plci->adapter->request(&plci->NL);
|
|
break;
|
|
case RTP_CONNECT_B3_REQ_COMMAND_3:
|
|
return;
|
|
}
|
|
sendf(plci->appl, _CONNECT_B3_R | CONFIRM, Id, plci->number, "w", Info);
|
|
}
|
|
|
|
|
|
static void rtp_connect_b3_res_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: rtp_connect_b3_res_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
case RTP_CONNECT_B3_RES_COMMAND_1:
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_1;
|
|
return;
|
|
}
|
|
plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
|
|
nl_req_ncci(plci, N_CONNECT_ACK, (byte)(Id >> 16));
|
|
send_req(plci);
|
|
return;
|
|
case RTP_CONNECT_B3_RES_COMMAND_2:
|
|
if ((Rc != OK) && (Rc != OK_FC))
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: RTP setting connect resp info failed %02x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc));
|
|
break;
|
|
}
|
|
if (plci_nl_busy(plci))
|
|
{
|
|
plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_2;
|
|
return;
|
|
}
|
|
sendf(plci->appl, _CONNECT_B3_ACTIVE_I, Id, 0, "s", "");
|
|
plci->internal_command = RTP_CONNECT_B3_RES_COMMAND_3;
|
|
plci->NData[0].PLength = plci->internal_req_buffer[0];
|
|
plci->NData[0].P = plci->internal_req_buffer + 1;
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.ReqCh = 0;
|
|
plci->NL.Req = plci->nl_req = (byte) N_UDATA;
|
|
plci->adapter->request(&plci->NL);
|
|
return;
|
|
case RTP_CONNECT_B3_RES_COMMAND_3:
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static void hold_save_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
byte SS_Ind[] = "\x05\x02\x00\x02\x00\x00"; /* Hold_Ind struct*/
|
|
word Info;
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: hold_save_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
Info = GOOD;
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
if (!plci->NL.Id)
|
|
break;
|
|
plci->command = 0;
|
|
plci->adjust_b_parms_msg = NULL;
|
|
plci->adjust_b_facilities = plci->B1_facilities;
|
|
plci->adjust_b_command = HOLD_SAVE_COMMAND_1;
|
|
plci->adjust_b_ncci = (word)(Id >> 16);
|
|
plci->adjust_b_mode = ADJUST_B_MODE_SAVE | ADJUST_B_MODE_REMOVE_L23;
|
|
plci->adjust_b_state = ADJUST_B_START;
|
|
dbug(1, dprintf("[%06lx] %s,%d: HOLD save...",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
case HOLD_SAVE_COMMAND_1:
|
|
Info = adjust_b_process(Id, plci, Rc);
|
|
if (Info != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: HOLD save failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
}
|
|
sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
|
|
}
|
|
|
|
|
|
static void retrieve_restore_command(dword Id, PLCI *plci, byte Rc)
|
|
{
|
|
byte SS_Ind[] = "\x05\x03\x00\x02\x00\x00"; /* Retrieve_Ind struct*/
|
|
word Info;
|
|
word internal_command;
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: retrieve_restore_command %02x %04x",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__, Rc, plci->internal_command));
|
|
|
|
Info = GOOD;
|
|
internal_command = plci->internal_command;
|
|
plci->internal_command = 0;
|
|
switch (internal_command)
|
|
{
|
|
default:
|
|
plci->command = 0;
|
|
plci->adjust_b_parms_msg = NULL;
|
|
plci->adjust_b_facilities = plci->B1_facilities;
|
|
plci->adjust_b_command = RETRIEVE_RESTORE_COMMAND_1;
|
|
plci->adjust_b_ncci = (word)(Id >> 16);
|
|
plci->adjust_b_mode = ADJUST_B_MODE_ASSIGN_L23 | ADJUST_B_MODE_USER_CONNECT | ADJUST_B_MODE_RESTORE;
|
|
plci->adjust_b_state = ADJUST_B_START;
|
|
dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore...",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
case RETRIEVE_RESTORE_COMMAND_1:
|
|
Info = adjust_b_process(Id, plci, Rc);
|
|
if (Info != GOOD)
|
|
{
|
|
dbug(1, dprintf("[%06lx] %s,%d: RETRIEVE restore failed",
|
|
UnMapId(Id), (char *)(FILE_), __LINE__));
|
|
break;
|
|
}
|
|
if (plci->internal_command)
|
|
return;
|
|
}
|
|
sendf(plci->appl, _FACILITY_I, Id & 0xffffL, 0, "ws", 3, SS_Ind);
|
|
}
|
|
|
|
|
|
static void init_b1_config(PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: init_b1_config",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
plci->B1_resource = 0;
|
|
plci->B1_facilities = 0;
|
|
|
|
plci->li_bchannel_id = 0;
|
|
mixer_clear_config(plci);
|
|
|
|
|
|
ec_clear_config(plci);
|
|
|
|
|
|
dtmf_rec_clear_config(plci);
|
|
dtmf_send_clear_config(plci);
|
|
dtmf_parameter_clear_config(plci);
|
|
|
|
adv_voice_clear_config(plci);
|
|
adjust_b_clear(plci);
|
|
}
|
|
|
|
|
|
static void clear_b1_config(PLCI *plci)
|
|
{
|
|
|
|
dbug(1, dprintf("[%06lx] %s,%d: clear_b1_config",
|
|
(dword)((plci->Id << 8) | UnMapController(plci->adapter->Id)),
|
|
(char *)(FILE_), __LINE__));
|
|
|
|
adv_voice_clear_config(plci);
|
|
adjust_b_clear(plci);
|
|
|
|
ec_clear_config(plci);
|
|
|
|
|
|
dtmf_rec_clear_config(plci);
|
|
dtmf_send_clear_config(plci);
|
|
dtmf_parameter_clear_config(plci);
|
|
|
|
|
|
if ((plci->li_bchannel_id != 0)
|
|
&& (li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci == plci))
|
|
{
|
|
mixer_clear_config(plci);
|
|
li_config_table[plci->adapter->li_base + (plci->li_bchannel_id - 1)].plci = NULL;
|
|
plci->li_bchannel_id = 0;
|
|
}
|
|
|
|
plci->B1_resource = 0;
|
|
plci->B1_facilities = 0;
|
|
}
|
|
|
|
|
|
/* -----------------------------------------------------------------
|
|
XON protocol local helpers
|
|
----------------------------------------------------------------- */
|
|
static void channel_flow_control_remove(PLCI *plci) {
|
|
DIVA_CAPI_ADAPTER *a = plci->adapter;
|
|
word i;
|
|
for (i = 1; i < MAX_NL_CHANNEL + 1; i++) {
|
|
if (a->ch_flow_plci[i] == plci->Id) {
|
|
a->ch_flow_plci[i] = 0;
|
|
a->ch_flow_control[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void channel_x_on(PLCI *plci, byte ch) {
|
|
DIVA_CAPI_ADAPTER *a = plci->adapter;
|
|
if (a->ch_flow_control[ch] & N_XON_SENT) {
|
|
a->ch_flow_control[ch] &= ~N_XON_SENT;
|
|
}
|
|
}
|
|
|
|
static void channel_x_off(PLCI *plci, byte ch, byte flag) {
|
|
DIVA_CAPI_ADAPTER *a = plci->adapter;
|
|
if ((a->ch_flow_control[ch] & N_RX_FLOW_CONTROL_MASK) == 0) {
|
|
a->ch_flow_control[ch] |= (N_CH_XOFF | flag);
|
|
a->ch_flow_plci[ch] = plci->Id;
|
|
a->ch_flow_control_pending++;
|
|
}
|
|
}
|
|
|
|
static void channel_request_xon(PLCI *plci, byte ch) {
|
|
DIVA_CAPI_ADAPTER *a = plci->adapter;
|
|
|
|
if (a->ch_flow_control[ch] & N_CH_XOFF) {
|
|
a->ch_flow_control[ch] |= N_XON_REQ;
|
|
a->ch_flow_control[ch] &= ~N_CH_XOFF;
|
|
a->ch_flow_control[ch] &= ~N_XON_CONNECT_IND;
|
|
}
|
|
}
|
|
|
|
static void channel_xmit_extended_xon(PLCI *plci) {
|
|
DIVA_CAPI_ADAPTER *a;
|
|
int max_ch = ARRAY_SIZE(a->ch_flow_control);
|
|
int i, one_requested = 0;
|
|
|
|
if ((!plci) || (!plci->Id) || ((a = plci->adapter) == NULL)) {
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < max_ch; i++) {
|
|
if ((a->ch_flow_control[i] & N_CH_XOFF) &&
|
|
(a->ch_flow_control[i] & N_XON_CONNECT_IND) &&
|
|
(plci->Id == a->ch_flow_plci[i])) {
|
|
channel_request_xon(plci, (byte)i);
|
|
one_requested = 1;
|
|
}
|
|
}
|
|
|
|
if (one_requested) {
|
|
channel_xmit_xon(plci);
|
|
}
|
|
}
|
|
|
|
/*
|
|
Try to xmit next X_ON
|
|
*/
|
|
static int find_channel_with_pending_x_on(DIVA_CAPI_ADAPTER *a, PLCI *plci) {
|
|
int max_ch = ARRAY_SIZE(a->ch_flow_control);
|
|
int i;
|
|
|
|
if (!(plci->adapter->manufacturer_features & MANUFACTURER_FEATURE_XONOFF_FLOW_CONTROL)) {
|
|
return (0);
|
|
}
|
|
|
|
if (a->last_flow_control_ch >= max_ch) {
|
|
a->last_flow_control_ch = 1;
|
|
}
|
|
for (i = a->last_flow_control_ch; i < max_ch; i++) {
|
|
if ((a->ch_flow_control[i] & N_XON_REQ) &&
|
|
(plci->Id == a->ch_flow_plci[i])) {
|
|
a->last_flow_control_ch = i + 1;
|
|
return (i);
|
|
}
|
|
}
|
|
|
|
for (i = 1; i < a->last_flow_control_ch; i++) {
|
|
if ((a->ch_flow_control[i] & N_XON_REQ) &&
|
|
(plci->Id == a->ch_flow_plci[i])) {
|
|
a->last_flow_control_ch = i + 1;
|
|
return (i);
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
static void channel_xmit_xon(PLCI *plci) {
|
|
DIVA_CAPI_ADAPTER *a = plci->adapter;
|
|
byte ch;
|
|
|
|
if (plci->nl_req || !plci->NL.Id || plci->nl_remove_id) {
|
|
return;
|
|
}
|
|
if ((ch = (byte)find_channel_with_pending_x_on(a, plci)) == 0) {
|
|
return;
|
|
}
|
|
a->ch_flow_control[ch] &= ~N_XON_REQ;
|
|
a->ch_flow_control[ch] |= N_XON_SENT;
|
|
|
|
plci->NL.Req = plci->nl_req = (byte)N_XON;
|
|
plci->NL.ReqCh = ch;
|
|
plci->NL.X = plci->NData;
|
|
plci->NL.XNum = 1;
|
|
plci->NData[0].P = &plci->RBuffer[0];
|
|
plci->NData[0].PLength = 0;
|
|
|
|
plci->adapter->request(&plci->NL);
|
|
}
|
|
|
|
static int channel_can_xon(PLCI *plci, byte ch) {
|
|
APPL *APPLptr;
|
|
DIVA_CAPI_ADAPTER *a;
|
|
word NCCIcode;
|
|
dword count;
|
|
word Num;
|
|
word i;
|
|
|
|
APPLptr = plci->appl;
|
|
a = plci->adapter;
|
|
|
|
if (!APPLptr)
|
|
return (0);
|
|
|
|
NCCIcode = a->ch_ncci[ch] | (((word) a->Id) << 8);
|
|
|
|
/* count all buffers within the Application pool */
|
|
/* belonging to the same NCCI. XON if a first is */
|
|
/* used. */
|
|
count = 0;
|
|
Num = 0xffff;
|
|
for (i = 0; i < APPLptr->MaxBuffer; i++) {
|
|
if (NCCIcode == APPLptr->DataNCCI[i]) count++;
|
|
if (!APPLptr->DataNCCI[i] && Num == 0xffff) Num = i;
|
|
}
|
|
if ((count > 2) || (Num == 0xffff)) {
|
|
return (0);
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static word CPN_filter_ok(byte *cpn, DIVA_CAPI_ADAPTER *a, word offset)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************************/
|
|
/* function groups the listening applications according to the CIP mask and the */
|
|
/* Info_Mask. Each group gets just one Connect_Ind. Some application manufacturer */
|
|
/* are not multi-instance capable, so they start e.g. 30 applications what causes */
|
|
/* big problems on application level (one call, 30 Connect_Ind, ect). The */
|
|
/* function must be enabled by setting "a->group_optimization_enabled" from the */
|
|
/* OS specific part (per adapter). */
|
|
/**********************************************************************************/
|
|
static void group_optimization(DIVA_CAPI_ADAPTER *a, PLCI *plci)
|
|
{
|
|
word i, j, k, busy, group_found;
|
|
dword info_mask_group[MAX_CIP_TYPES];
|
|
dword cip_mask_group[MAX_CIP_TYPES];
|
|
word appl_number_group_type[MAX_APPL];
|
|
PLCI *auxplci;
|
|
|
|
set_group_ind_mask(plci); /* all APPLs within this inc. call are allowed to dial in */
|
|
|
|
if (!a->group_optimization_enabled)
|
|
{
|
|
dbug(1, dprintf("No group optimization"));
|
|
return;
|
|
}
|
|
|
|
dbug(1, dprintf("Group optimization = 0x%x...", a->group_optimization_enabled));
|
|
|
|
for (i = 0; i < MAX_CIP_TYPES; i++)
|
|
{
|
|
info_mask_group[i] = 0;
|
|
cip_mask_group[i] = 0;
|
|
}
|
|
for (i = 0; i < MAX_APPL; i++)
|
|
{
|
|
appl_number_group_type[i] = 0;
|
|
}
|
|
for (i = 0; i < max_appl; i++) /* check if any multi instance capable application is present */
|
|
{ /* group_optimization set to 1 means not to optimize multi-instance capable applications (default) */
|
|
if (application[i].Id && (application[i].MaxNCCI) > 1 && (a->CIP_Mask[i]) && (a->group_optimization_enabled == 1))
|
|
{
|
|
dbug(1, dprintf("Multi-Instance capable, no optimization required"));
|
|
return; /* allow good application unfiltered access */
|
|
}
|
|
}
|
|
for (i = 0; i < max_appl; i++) /* Build CIP Groups */
|
|
{
|
|
if (application[i].Id && a->CIP_Mask[i])
|
|
{
|
|
for (k = 0, busy = false; k < a->max_plci; k++)
|
|
{
|
|
if (a->plci[k].Id)
|
|
{
|
|
auxplci = &a->plci[k];
|
|
if (auxplci->appl == &application[i]) /* application has a busy PLCI */
|
|
{
|
|
busy = true;
|
|
dbug(1, dprintf("Appl 0x%x is busy", i + 1));
|
|
}
|
|
else if (test_c_ind_mask_bit(auxplci, i)) /* application has an incoming call pending */
|
|
{
|
|
busy = true;
|
|
dbug(1, dprintf("Appl 0x%x has inc. call pending", i + 1));
|
|
}
|
|
}
|
|
}
|
|
|
|
for (j = 0, group_found = 0; j <= (MAX_CIP_TYPES) && !busy && !group_found; j++) /* build groups with free applications only */
|
|
{
|
|
if (j == MAX_CIP_TYPES) /* all groups are in use but group still not found */
|
|
{ /* the MAX_CIP_TYPES group enables all calls because of field overflow */
|
|
appl_number_group_type[i] = MAX_CIP_TYPES;
|
|
group_found = true;
|
|
dbug(1, dprintf("Field overflow appl 0x%x", i + 1));
|
|
}
|
|
else if ((info_mask_group[j] == a->CIP_Mask[i]) && (cip_mask_group[j] == a->Info_Mask[i]))
|
|
{ /* is group already present ? */
|
|
appl_number_group_type[i] = j | 0x80; /* store the group number for each application */
|
|
group_found = true;
|
|
dbug(1, dprintf("Group 0x%x found with appl 0x%x, CIP=0x%lx", appl_number_group_type[i], i + 1, info_mask_group[j]));
|
|
}
|
|
else if (!info_mask_group[j])
|
|
{ /* establish a new group */
|
|
appl_number_group_type[i] = j | 0x80; /* store the group number for each application */
|
|
info_mask_group[j] = a->CIP_Mask[i]; /* store the new CIP mask for the new group */
|
|
cip_mask_group[j] = a->Info_Mask[i]; /* store the new Info_Mask for this new group */
|
|
group_found = true;
|
|
dbug(1, dprintf("New Group 0x%x established with appl 0x%x, CIP=0x%lx", appl_number_group_type[i], i + 1, info_mask_group[j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < max_appl; i++) /* Build group_optimization_mask_table */
|
|
{
|
|
if (appl_number_group_type[i]) /* application is free, has listens and is member of a group */
|
|
{
|
|
if (appl_number_group_type[i] == MAX_CIP_TYPES)
|
|
{
|
|
dbug(1, dprintf("OverflowGroup 0x%x, valid appl = 0x%x, call enabled", appl_number_group_type[i], i + 1));
|
|
}
|
|
else
|
|
{
|
|
dbug(1, dprintf("Group 0x%x, valid appl = 0x%x", appl_number_group_type[i], i + 1));
|
|
for (j = i + 1; j < max_appl; j++) /* search other group members and mark them as busy */
|
|
{
|
|
if (appl_number_group_type[i] == appl_number_group_type[j])
|
|
{
|
|
dbug(1, dprintf("Appl 0x%x is member of group 0x%x, no call", j + 1, appl_number_group_type[j]));
|
|
clear_group_ind_mask_bit(plci, j); /* disable call on other group members */
|
|
appl_number_group_type[j] = 0; /* remove disabled group member from group list */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else /* application should not get a call */
|
|
{
|
|
clear_group_ind_mask_bit(plci, i);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* OS notifies the driver about a application Capi_Register */
|
|
word CapiRegister(word id)
|
|
{
|
|
word i, j, appls_found;
|
|
|
|
PLCI *plci;
|
|
DIVA_CAPI_ADAPTER *a;
|
|
|
|
for (i = 0, appls_found = 0; i < max_appl; i++)
|
|
{
|
|
if (application[i].Id && (application[i].Id != id))
|
|
{
|
|
appls_found++; /* an application has been found */
|
|
}
|
|
}
|
|
|
|
if (appls_found) return true;
|
|
for (i = 0; i < max_adapter; i++) /* scan all adapters... */
|
|
{
|
|
a = &adapter[i];
|
|
if (a->request)
|
|
{
|
|
if (a->flag_dynamic_l1_down) /* remove adapter from L1 tristate (Huntgroup) */
|
|
{
|
|
if (!appls_found) /* first application does a capi register */
|
|
{
|
|
if ((j = get_plci(a))) /* activate L1 of all adapters */
|
|
{
|
|
plci = &a->plci[j - 1];
|
|
plci->command = 0;
|
|
add_p(plci, OAD, "\x01\xfd");
|
|
add_p(plci, CAI, "\x01\x80");
|
|
add_p(plci, UID, "\x06\x43\x61\x70\x69\x32\x30");
|
|
add_p(plci, SHIFT | 6, NULL);
|
|
add_p(plci, SIN, "\x02\x00\x00");
|
|
plci->internal_command = START_L1_SIG_ASSIGN_PEND;
|
|
sig_req(plci, ASSIGN, DSIG_ID);
|
|
add_p(plci, FTY, "\x02\xff\x07"); /* l1 start */
|
|
sig_req(plci, SIG_CTRL, 0);
|
|
send_req(plci);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
|
|
/* Functions for virtual Switching e.g. Transfer by join, Conference */
|
|
|
|
static void VSwitchReqInd(PLCI *plci, dword Id, byte **parms)
|
|
{
|
|
word i;
|
|
/* Format of vswitch_t:
|
|
0 byte length
|
|
1 byte VSWITCHIE
|
|
2 byte VSWITCH_REQ/VSWITCH_IND
|
|
3 byte reserved
|
|
4 word VSwitchcommand
|
|
6 word returnerror
|
|
8... Params
|
|
*/
|
|
if (!plci ||
|
|
!plci->appl ||
|
|
!plci->State ||
|
|
plci->Sig.Ind == NCR_FACILITY
|
|
)
|
|
return;
|
|
|
|
for (i = 0; i < MAX_MULTI_IE; i++)
|
|
{
|
|
if (!parms[i][0]) continue;
|
|
if (parms[i][0] < 7)
|
|
{
|
|
parms[i][0] = 0; /* kill it */
|
|
continue;
|
|
}
|
|
dbug(1, dprintf("VSwitchReqInd(%d)", parms[i][4]));
|
|
switch (parms[i][4])
|
|
{
|
|
case VSJOIN:
|
|
if (!plci->relatedPTYPLCI ||
|
|
(plci->ptyState != S_ECT && plci->relatedPTYPLCI->ptyState != S_ECT))
|
|
{ /* Error */
|
|
break;
|
|
}
|
|
/* remember all necessary informations */
|
|
if (parms[i][0] != 11 || parms[i][8] != 3) /* Length Test */
|
|
{
|
|
break;
|
|
}
|
|
if (parms[i][2] == VSWITCH_IND && parms[i][9] == 1)
|
|
{ /* first indication after ECT-Request on Consultation Call */
|
|
plci->vswitchstate = parms[i][9];
|
|
parms[i][9] = 2; /* State */
|
|
/* now ask first Call to join */
|
|
}
|
|
else if (parms[i][2] == VSWITCH_REQ && parms[i][9] == 3)
|
|
{ /* Answer of VSWITCH_REQ from first Call */
|
|
plci->vswitchstate = parms[i][9];
|
|
/* tell consultation call to join
|
|
and the protocol capabilities of the first call */
|
|
}
|
|
else
|
|
{ /* Error */
|
|
break;
|
|
}
|
|
plci->vsprot = parms[i][10]; /* protocol */
|
|
plci->vsprotdialect = parms[i][11]; /* protocoldialect */
|
|
/* send join request to related PLCI */
|
|
parms[i][1] = VSWITCHIE;
|
|
parms[i][2] = VSWITCH_REQ;
|
|
|
|
plci->relatedPTYPLCI->command = 0;
|
|
plci->relatedPTYPLCI->internal_command = VSWITCH_REQ_PEND;
|
|
add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]);
|
|
sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
|
|
send_req(plci->relatedPTYPLCI);
|
|
break;
|
|
case VSTRANSPORT:
|
|
default:
|
|
if (plci->relatedPTYPLCI &&
|
|
plci->vswitchstate == 3 &&
|
|
plci->relatedPTYPLCI->vswitchstate == 3)
|
|
{
|
|
add_p(plci->relatedPTYPLCI, ESC, &parms[i][0]);
|
|
sig_req(plci->relatedPTYPLCI, VSWITCH_REQ, 0);
|
|
send_req(plci->relatedPTYPLCI);
|
|
}
|
|
break;
|
|
}
|
|
parms[i][0] = 0; /* kill it */
|
|
}
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------*/
|
|
|
|
static int diva_get_dma_descriptor(PLCI *plci, dword *dma_magic) {
|
|
ENTITY e;
|
|
IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e;
|
|
|
|
if (!(diva_xdi_extended_features & DIVA_CAPI_XDI_PROVIDES_RX_DMA)) {
|
|
return (-1);
|
|
}
|
|
|
|
pReq->xdi_dma_descriptor_operation.Req = 0;
|
|
pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
|
|
|
|
pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_ALLOC;
|
|
pReq->xdi_dma_descriptor_operation.info.descriptor_number = -1;
|
|
pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
|
|
pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0;
|
|
|
|
e.user[0] = plci->adapter->Id - 1;
|
|
plci->adapter->request((ENTITY *)pReq);
|
|
|
|
if (!pReq->xdi_dma_descriptor_operation.info.operation &&
|
|
(pReq->xdi_dma_descriptor_operation.info.descriptor_number >= 0) &&
|
|
pReq->xdi_dma_descriptor_operation.info.descriptor_magic) {
|
|
*dma_magic = pReq->xdi_dma_descriptor_operation.info.descriptor_magic;
|
|
dbug(3, dprintf("dma_alloc, a:%d (%d-%08x)",
|
|
plci->adapter->Id,
|
|
pReq->xdi_dma_descriptor_operation.info.descriptor_number,
|
|
*dma_magic));
|
|
return (pReq->xdi_dma_descriptor_operation.info.descriptor_number);
|
|
} else {
|
|
dbug(1, dprintf("dma_alloc failed"));
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
static void diva_free_dma_descriptor(PLCI *plci, int nr) {
|
|
ENTITY e;
|
|
IDI_SYNC_REQ *pReq = (IDI_SYNC_REQ *)&e;
|
|
|
|
if (nr < 0) {
|
|
return;
|
|
}
|
|
|
|
pReq->xdi_dma_descriptor_operation.Req = 0;
|
|
pReq->xdi_dma_descriptor_operation.Rc = IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION;
|
|
|
|
pReq->xdi_dma_descriptor_operation.info.operation = IDI_SYNC_REQ_DMA_DESCRIPTOR_FREE;
|
|
pReq->xdi_dma_descriptor_operation.info.descriptor_number = nr;
|
|
pReq->xdi_dma_descriptor_operation.info.descriptor_address = NULL;
|
|
pReq->xdi_dma_descriptor_operation.info.descriptor_magic = 0;
|
|
|
|
e.user[0] = plci->adapter->Id - 1;
|
|
plci->adapter->request((ENTITY *)pReq);
|
|
|
|
if (!pReq->xdi_dma_descriptor_operation.info.operation) {
|
|
dbug(1, dprintf("dma_free(%d)", nr));
|
|
} else {
|
|
dbug(1, dprintf("dma_free failed (%d)", nr));
|
|
}
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|